# XPath parsing

from Parser import Parser

class XpathElem:

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

        is_ptr=False):

        if attrs == None: attrs = []

        self.name = name

        self.value = value

        self.attrs = attrs

        self.is_attr = is_attr

        self.is_ptr = is_ptr

    def __repr__(self):

        str_ = ''

        if self.is_attr: str_ += '@'

        if self.attrs != []: str_ += repr(self.attrs)

        if self.value != None: str_ += '='+repr(self.value)

        return str_

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

    len(elem.attrs[0]) == 1: return elem.attrs[0]

    parser = Parser(str_)

        while True:

                parser.str_('}', required=True)

                name=parser.re(r'[\w.*]+', required=True))

                parser.str_(']', required=True)

            # Lookahead assertion

                parser.str_('/', required=True) # next / is inside ()

                path = _path()

                parser.str_(')', required=True)

                tree += path

            elem = tree[i]

            if id_ != None: elem = id_[0]; offset = -2

            elif elem.is_ptr: offset = 2

            else: offset = 1

            before, abbr, after = elem.name.partition('*')

            if abbr != '':

    parser.str_('/') # optional leading /

    path = _path()

    parser.end()

    return path

    return obj_path

    path[id_level].attrs.append([XpathElem('id', id_, is_attr=True)])

def is_id(path): return path[0].is_attr and path[0].name == 'id'

def is_instance(elem): return elem.attrs != [] and is_id(elem.attrs[0])

def get(doc, xpath, create=False, last_only=None, parent=None):

    # Warning: The last_only optimization may put data that should be together

    # into separate nodes

    if parent == None: parent = doc.documentElement

    if last_only == None: last_only = create

        children = []

        if elem.is_attr:

            child = parent.getAttributeNode(elem.name)

            if child != None: children = [child]

        elif elem.name == '.': children = [parent]

        else:

            children = xml_dom.by_tag_name(parent, elem.name,

            last_only and (elem.attrs == [] or is_instance(elem)))

        # Check each match

        node = None

        for child in children:

            is_match = elem.value == None or xml_dom.value(child) == elem.value

            for attr in elem.attrs:

                if not is_match: break

                is_match = get(doc, attr, False, last_only, child) != None

            if is_match: node = child; break

        # Create node

        if node == None:

            if not create: return None

            if elem.is_attr:

                parent.setAttribute(elem.name, '')

                node = parent.getAttributeNode(elem.name)

            else: node = parent.appendChild(doc.createElement(elem.name))

            if elem.value != None: xml_dom.set_value(doc, node, elem.value)

            for attr in elem.attrs: get(doc, attr, create, last_only, node)

            get(doc, branch, create, last_only, node)

        if elem.is_ptr:

            xpath = copy.deepcopy(xpath[elem_idx+1:]) # rest of XPath

            id_elem = backward_id(xpath[instance_level])

            if id_elem != None:

                # backward (child-to-parent) pointer with target ID attr

                set_value(id_elem, xml_dom.get_id(node))

            else: # forward (parent-to-child) pointer

                id_ = xml_dom.value(node)

                obj_xpath = obj(xpath) # target object

                if id_ == None or get(doc, obj_xpath, False, True) == None:

                    # no target or target attrs don't match

                    if not create: return None

                    # Use last target object's ID + 1

                    obj_xpath[-1].attrs = [] # just get by tag name

                    last = get(doc, obj_xpath, False, True)

                    if last != None: id_ = str(int(xml_dom.get_id(last)) + 1)

                    else: id_ = '0'

                    # Will append if target attrs didn't match. Place ! in XPath

                    # after element to fork at to avoid this.

                    xml_dom.set_value(doc, node, id_)

                else: last_only = False

                set_id(xpath, id_)

            return get(doc, xpath, create, last_only)

        parent = node

    return parent

    set_id(xpath, id_, has_types)