# A general recursive descent parser

from Parser import Parser

class XpathElem:

    def __init__(self, name, value=None, is_attr=False, attrs=None):

        if attrs == None: attrs = []

        self.name = name

        self.value = value

        self.is_attr = is_attr

        self.attrs = attrs

    def __repr__(self):

        if self.is_attr: prefix = '@'

        else: prefix = ''

        return prefix+self.name+repr(self.attrs)+'='+repr(self.value)

    def __eq__(self, other): return self.__dict__ == other.__dict__

class XpathParser(Parser):

    def _main(self):

        while True:

            self._match_str('/', required=True)

            tree = self._path() # just use last path for now

            if not self._match_str('->'): break

        return tree

    def _path(self):

        tree = []

        while True:

            elem = XpathElem(is_attr=self._match_str('@'), name=self._fields())

            if self._match_str('['):

                elem.attrs = self._attrs()

                self._match_str(']', required=True)

            tree.append(elem)

            if not self._match_str('/'): break

        return tree

    def _fields(self):

        if self._match_str('{'):

            tree = []

            while True:

                tree.append(self._field())

                if not self._match_str(','): break

            self._match_str('}', required=True)

            tree = tuple(tree)

            tree = tree[0] # just use first field for now

        else: tree = self._field()

        return tree

    def _attrs(self):

        tree = []

        while True:

            path = self._path()

            self._match_str('=', required=True)

            path[-1].value = self._value()

            tree.append(path)

            if not self._match_str(','): break

        return tree

    def _field(self):

        return self._name()

    def _name(self): return self._match_re(r'[\w.]+', required=True)