public void testJx177_Union2()

    {

        doTest("$__root/x/unexisting|name", "ROOT name");

    }

    protected int index = WHOLE_COLLECTION;

    private boolean attribute = false;

        NodePointer pointer = null;

        if (bean == null) {

        NodePointerFactory[] factories =

        for (int i = 0; i < factories.length; i++) {

            pointer = factories[i].createNodePointer(name, bean, locale);

            if (pointer != null) {

                return pointer;

        NodePointerFactory[] factories =

        for (int i = 0; i < factories.length; i++) {

            NodePointer pointer =

            if (pointer != null) {

                return pointer;

    protected NodePointer(NodePointer parent) {

        this.parent = parent;

    }

    protected NodePointer(NodePointer parent, Locale locale) {

        this.parent = parent;

        this.locale = locale;

    }

        this.namespaceResolver = namespaceResolver;

    }

        return parent;

        this.attribute = attribute;

    }

        return index;

        this.index = index;

    }

        NodePointer ivp = getImmediateValuePointer();

        return ivp == this ? this : ivp.getValuePointer();

        return this;

        return index == WHOLE_COLLECTION || index >= 0 && index < getLength();

        return getValuePointer().getImmediateNode();

        if (prefix == null) {

            return true;

            NodePointer ptr = (NodePointer) super.clone();

            if (parent != null) {

                ptr.parent = (NodePointer) parent.clone();

            return ptr;

        if (object == this) {

        NodePointer pointer = (NodePointer) object;

        int depth1 = 0;

        NodePointer p1 = this;

        HashSet parents1 = new HashSet();

        while (p1 != null) {

            depth1++;

            p1 = p1.parent;

            if (p1 != null) {

                parents1.add(p1);

        boolean commonParentFound = false;

        int depth2 = 0;

        NodePointer p2 = pointer;

        while (p2 != null) {

            depth2++;

            p2 = p2.parent;

            if (parents1.contains(p2)) {

        return commonParentFound ? compareNodePointers(this, depth1, pointer, depth2) : 0;

    private static final Comparator PROPERTY_DESCRIPTOR_COMPARATOR = new Comparator() {

    private boolean atomic = false;

    public JXPathBasicBeanInfo(Class clazz) {

        this.clazz = clazz;

    }

    public JXPathBasicBeanInfo(Class clazz, boolean atomic) {

        this.clazz = clazz;

        this.atomic = atomic;

    }

    public JXPathBasicBeanInfo(Class clazz, Class dynamicPropertyHandlerClass) {

        this.clazz = clazz;

        this.atomic = false;

        this.dynamicPropertyHandlerClass = dynamicPropertyHandlerClass;

    }

        return dynamicPropertyHandlerClass != null;

        return dynamicPropertyHandlerClass;

        super(steps);

        this.absolute = absolute;

    }

        return absolute;

        if (isAbsolute()) {

            rootContext = new InitialContext(context);

        return evalSteps(rootContext);

        if (isAbsolute()) {

            rootContext = context.getRootContext().getAbsoluteRootContext();

            rootContext = new InitialContext(context);

        return getSingleNodePointerForSteps(rootContext);

            this.compiler = compiler;

        }

    switch (jj_nt.kind) {

      NCName_Without_CoreFunctions();

      break;

      jj_consume_token(FUNCTION_NAME);

      break;

        {if (true) return token.image;}

    switch (jj_nt.kind) {

      jj_consume_token(NCName);

      break;

        {if (true) return token.image;}

 String nc1, nc2 = null;

    nc1 = NCName();

    switch (jj_nt.kind) {

      jj_la1[3] = jj_gen;

        if (nc2 == null){

            {if (true) return compiler.qname(null, nc1);}

    ex = Expression();

    jj_consume_token(0);

        {if (true) return ex;}

 Object ex = null;

    switch (jj_nt.kind) {

      ex = RelativeLocationPath();

      break;

      ex = AbsoluteLocationPath();

      break;

        {if (true) return ex;}

    ArrayList steps = new ArrayList();

    if (jj_2_2(2147483647)) {

      LocationStep(steps);

        switch (jj_nt.kind) {

          break;

          jj_la1[6] = jj_gen;

          break label_1;

        LocationStep(steps);

        {if (true) return compiler.locationPath(true, steps.toArray());}

    ArrayList steps = new ArrayList();

    NodeTest(steps);

      switch (jj_nt.kind) {

        jj_la1[8] = jj_gen;

        break label_2;

        {if (true) return compiler.locationPath(false, steps.toArray());}

    switch (jj_nt.kind) {

      jj_consume_token(SLASH);

      break;

    NodeTest(steps);

  }

    int type = -1;

    String instruction = null;

    Object name = null;

    ArrayList ps = new ArrayList();

    switch (jj_nt.kind) {

      axis = AxisSpecifier();

      if (jj_2_3(2147483647)) {

      } else if (jj_2_4(2147483647)) {

        switch (jj_nt.kind) {

          name = WildcardName();

          break;

      switch (jj_nt.kind) {

        jj_la1[12] = jj_gen;

        break label_3;

        if (name != null){

            s = compiler.nodeNameTest(name);

        steps.add(compiler.step(axis, s, ps.toArray()));

  }

    switch (jj_nt.kind) {

      jj_la1[13] = jj_gen;

      axis = AbbreviatedAxisSpecifier();

        {if (true) return axis;}

    int axis = Compiler.AXIS_CHILD;

    switch (jj_nt.kind) {

      jj_la1[15] = jj_gen;

        {if (true) return axis;}

    ex = OrExpr();

        {if (true) return ex;}

    Object ex = null;

    switch (jj_nt.kind) {

      ex = VariableReference();

      break;

        {if (true) return ex;}

    ArrayList list = null;

    ex = PathExpr();

      switch (jj_nt.kind) {

        break;

        jj_la1[20] = jj_gen;

        break label_5;

      jj_consume_token(UNION);

      r = PathExpr();

                if (list == null){

                    list = new ArrayList();

                    list.add(ex);

                list.add(r);

        if (list != null){

            ex = compiler.union(list.toArray());

        {if (true) return ex;}

    Object ex = null;

    if (jj_2_6(2147483647)) {

      ex = FilterExpr();

      switch (jj_nt.kind) {

        ex = LocationPath();

        break;

        {if (true) return ex;}

    ArrayList ps = new ArrayList();

    boolean path = false;

    ArrayList steps = new ArrayList();

    ex = PrimaryExpr();

      switch (jj_nt.kind) {

        jj_la1[22] = jj_gen;

        break label_6;

      switch (jj_nt.kind) {

        break;

        jj_la1[23] = jj_gen;

        break label_7;

      LocationStep(steps);

                path = true;

        if (path){

            {if (true) return compiler.expressionPath(ex, ps.toArray(), steps.toArray());}

    ArrayList list = null;

    ex = AndExpr();

      switch (jj_nt.kind) {

        jj_la1[24] = jj_gen;

        break label_8;

        if (list != null){

        {if (true) return ex;}

    ArrayList list = null;

    ex = EqualityExpr();

      switch (jj_nt.kind) {

        jj_la1[25] = jj_gen;

        break label_9;

        if (list != null){

        {if (true) return ex;}

    ex = RelationalExpr();

      switch (jj_nt.kind) {

        jj_la1[26] = jj_gen;

        break label_10;

        {if (true) return ex;}

    ex = AdditiveExpr();

      switch (jj_nt.kind) {

        jj_la1[28] = jj_gen;

        break label_11;

        {if (true) return ex;}

    ArrayList list = null;

    ex = SubtractiveExpr();

      switch (jj_nt.kind) {

        jj_la1[30] = jj_gen;

        break label_12;

        if (list != null){

        {if (true) return ex;}

    Object ex, r = null;

    ex = MultiplicativeExpr();

      switch (jj_nt.kind) {

        jj_la1[31] = jj_gen;

        break label_13;

        {if (true) return ex;}

    ex = UnaryExpr();

      switch (jj_nt.kind) {

        jj_la1[32] = jj_gen;

        break label_14;

        {if (true) return ex;}

    switch (jj_nt.kind) {

      ex = UnionExpr();

      break;

        {if (true) return ex;}

    jj_consume_token(VARIABLE);

    ex = QName();

        {if (true) return compiler.variableReference(ex);}

    String nc1, nc2 = null;

    switch (jj_nt.kind) {

      NCName();

      break;

                           nc1 = token.image;

    switch (jj_nt.kind) {

      jj_la1[37] = jj_gen;

        if (nc2 != null){

            qn = compiler.qname(null, nc1);

        {if (true) return qn;}

    jj_la = xla; jj_lastpos = jj_scanpos = token;

    jj_la = xla; jj_lastpos = jj_scanpos = token;

    jj_la = xla; jj_lastpos = jj_scanpos = token;

    jj_la = xla; jj_lastpos = jj_scanpos = token;

    return false;

    return false;

    return false;

    return false;

    return false;

    xsp = jj_scanpos;

    if (jj_3R_20()) {

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    return false;

    xsp = jj_scanpos;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    return false;

    xsp = jj_scanpos;

    jj_scanpos = xsp;

    return false;

    if (jj_scan_token(COMMENT)) return true;

    if (jj_scan_token(NODE)) return true;

    if (jj_scan_token(TEXT)) return true;

    xsp = jj_scanpos;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    if (jj_3R_15()) return true;

    if (jj_3R_15()) return true;

    return false;

    if (jj_3R_18()) return true;

    xsp = jj_scanpos;

    jj_scanpos = xsp;

    return false;

    xsp = jj_scanpos;

    jj_scanpos = xsp;

    xsp = jj_scanpos;

    jj_scanpos = xsp;

    xsp = jj_scanpos;

    return false;

    return false;

    if (jj_scan_token(VARIABLE)) return true;

    return false;

    if (jj_scan_token(FUNCTION_FORMAT_NUMBER)) return true;

    if (jj_scan_token(FUNCTION_KEY)) return true;

    if (jj_scan_token(FUNCTION_ROUND)) return true;

    if (jj_scan_token(FUNCTION_CEILING)) return true;

    if (jj_scan_token(FUNCTION_FLOOR)) return true;

    if (jj_scan_token(FUNCTION_SUM)) return true;

    if (jj_scan_token(FUNCTION_NUMBER)) return true;

    if (jj_scan_token(FUNCTION_LANG)) return true;

    return false;

    if (jj_scan_token(FUNCTION_FALSE)) return true;

    if (jj_scan_token(FUNCTION_TRUE)) return true;

    return false;

    xsp = jj_scanpos;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    jj_scanpos = xsp;

    return false;

    if (jj_scan_token(FUNCTION_STRING_LENGTH)) return true;

    if (jj_scan_token(FUNCTION_SUBSTRING)) return true;

    if (jj_scan_token(FUNCTION_SUBSTRING_AFTER)) return true;

    if (jj_scan_token(FUNCTION_SUBSTRING_BEFORE)) return true;

    if (jj_scan_token(FUNCTION_CONTAINS)) return true;

    if (jj_scan_token(FUNCTION_STARTS_WITH)) return true;

    if (jj_scan_token(FUNCTION_CONCAT)) return true;

    if (jj_scan_token(FUNCTION_STRING)) return true;

    if (jj_scan_token(FUNCTION_NAME)) return true;

    return false;

    if (jj_scan_token(FUNCTION_NAMESPACE_URI)) return true;

    if (jj_scan_token(FUNCTION_LOCAL_NAME)) return true;

    return false;

  public boolean lookingAhead = false;

  final private int[] jj_la1 = new int[39];

      jj_la1_0();

      jj_la1_1();

      jj_la1_2();

   }

      jj_la1_0 = new int[] {0xf8000000,0x78000000,0x0,0x0,0x78000000,0xf80000c0,0xc0,0x40,0xc0,0xc0,0xf8000000,0xf8000000,0x0,0x0,0x0,0x0,0x160000,0xf8000000,0x0,0xf81604c0,0x100,0xf80000c0,0x0,0xc0,0x8000000,0x10000000,0x1800,0x1800,0x1e000,0x1e000,0x200,0x400,0x60000000,0x60000000,0xf81604c0,0xf8000000,0xf8000000,0x0,0x80000000,};

   }

      jj_la1_1 = new int[] {0xffff0007,0x0,0xffff0000,0x0,0x0,0xffffffff,0x0,0x0,0x0,0x0,0xffff0007,0xffffffff,0x0,0xfff8,0xfff8,0x0,0x0,0xffff0007,0x0,0xffffffff,0x0,0xffffffff,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0x0,0xffffffff,0xffff0007,0xffff0007,0x0,0x7,};

   }

   }

  final private JJCalls[] jj_2_rtns = new JJCalls[6];

  private boolean jj_rescan = false;

  private int jj_gc = 0;

  public XPathParser(java.io.Reader stream) {

    jj_input_stream = new SimpleCharStream(stream, 1, 1);

    token_source = new XPathParserTokenManager(jj_input_stream);

    token = new Token();

    token.next = jj_nt = token_source.getNextToken();

    jj_gen = 0;

    for (int i = 0; i < 39; i++) jj_la1[i] = -1;

    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();

  }

    jj_input_stream.ReInit(stream, 1, 1);

    token_source.ReInit(jj_input_stream);

    token = new Token();

    token.next = jj_nt = token_source.getNextToken();

    jj_gen = 0;

    for (int i = 0; i < 39; i++) jj_la1[i] = -1;

    for (int i = 0; i < jj_2_rtns.length; i++) jj_2_rtns[i] = new JJCalls();

  }

    Token oldToken = token;

    if ((token = jj_nt).next != null) jj_nt = jj_nt.next;

    else jj_nt = jj_nt.next = token_source.getNextToken();

    if (token.kind == kind) {

      jj_gen++;

      if (++jj_gc > 100) {

      return token;

    if (jj_scanpos == jj_lastpos) {

      jj_la--;

      if (jj_scanpos.next == null) {

        jj_lastpos = jj_scanpos = jj_scanpos.next = token_source.getNextToken();

        jj_lastpos = jj_scanpos = jj_scanpos.next;

      jj_scanpos = jj_scanpos.next;

    if (jj_rescan) {

  private java.util.Vector jj_expentries = new java.util.Vector();

  private int jj_kind = -1;

  private int[] jj_lasttokens = new int[100];

    JJCalls p = jj_2_rtns[index];

    while (p.gen > jj_gen) {

    p.gen = jj_gen + xla - jj_la; p.first = token; p.arg = xla;

  }

        super(parent);

        this.handler = handler;

    }

        if (names == null) {

            String[] allNames = handler.getPropertyNames(getBean());

            names = new String[allNames.length];

            for (int i = 0; i < names.length; i++) {

                names[i] = allNames[i];

            Arrays.sort(names);

            if (requiredPropertyName != null) {

        return names;

        if (name == null) {

            String[] names = getPropertyNames();

            name = propertyIndex >= 0 && propertyIndex < names.length ? names[propertyIndex] : "*";

        return name;

        setPropertyIndex(UNSPECIFIED_PROPERTY);

        this.name = propertyName;

        requiredPropertyName = propertyName;

        if (names != null && Arrays.binarySearch(names, propertyName) < 0) {

    }

        if (propertyIndex != index) {

            super.setPropertyIndex(index);

            name = null;

    }

        return handler.getProperty(getBean(), getPropertyName());

        if (index == WHOLE_COLLECTION) {

            value = ValueUtils.getValue(handler.getProperty(

            value = ValueUtils.getValue(handler.getProperty(

        return value;

        return true;

    private boolean startedSet = false;

        super(parentContext);

        this.nodeSet = nodeSet;

    }

        return nodeSet;

        if (position == 0 && !setPosition(1)) {

        return (NodePointer) nodeSet.getPointers().get(position - 1);

        super.setPosition(position);

        return position >= 1 && position <= nodeSet.getPointers().size();

        if (startedSet) {

        startedSet = true;

        return true;

        return setPosition(position + 1);

    private boolean started = false;

        super(parentContext);

        nodePointer =

        if (nodePointer != null) {

            collection =

    }

        return nodePointer;

        return nodePointer;

        return setPosition(position + 1);

        this.position = position;

        if (collection) {

            if (position >= 1 && position <= nodePointer.getLength()) {

                nodePointer.setIndex(position - 1);

                return true;

            return false;

        if (started) {

            return false;

        started = true;

        return true;

public class Token {

     switch(ofKind)

       default : return new Token();

public class VariablePointerFactory implements NodePointerFactory {

    public static final class VariableContextWrapper {

        return new VariableContextWrapper(context);

        if (object instanceof VariableContextWrapper) {

            JXPathContext varCtx = ((VariableContextWrapper) object).getContext();

            while (varCtx != null) {

                Variables vars = varCtx.getVariables();

                if (vars.isDeclaredVariable(name.toString())) {

                    return new VariablePointer(vars, name);

        return null;

        return createNodePointer(name, object, null);

        return VARIABLE_POINTER_FACTORY_ORDER;

    private static final Object UNINITIALIZED = new Object();

    private Object value = UNINITIALIZED;

        if (test == null) {

        if (test instanceof NodeNameTest) {

            NodeNameTest nodeNameTest = (NodeNameTest) test;

            QName testName = nodeNameTest.getNodeName();

            if (isValidProperty(testName)) {

                return createNodeIterator(nodeNameTest.isWildcard() ? null

        super(parent, locale);

    }

        super(parent);

    }

        if (this.index != index) {

            super.setIndex(index);

            value = UNINITIALIZED;

    }

        if (value == UNINITIALIZED) {

            value = index == WHOLE_COLLECTION ? ValueUtils.getValue(getBaseValue())

        return value;

        return isDefaultNamespace(name.getPrefix());

        registerAtomicClass(Class.class);

        registerAtomicClass(Boolean.TYPE);

        registerAtomicClass(Boolean.class);

        registerAtomicClass(Byte.TYPE);

        registerAtomicClass(Byte.class);

        registerAtomicClass(Character.TYPE);

        registerAtomicClass(Character.class);

        registerAtomicClass(Short.TYPE);

        registerAtomicClass(Short.class);

        registerAtomicClass(Integer.TYPE);

        registerAtomicClass(Integer.class);

        registerAtomicClass(Long.TYPE);

        registerAtomicClass(Long.class);

        registerAtomicClass(Float.TYPE);

        registerAtomicClass(Float.class);

        registerAtomicClass(Double.TYPE);

        registerAtomicClass(Double.class);

        registerAtomicClass(String.class);

        registerAtomicClass(Date.class);

        registerAtomicClass(java.sql.Date.class);

        registerAtomicClass(java.sql.Time.class);

        registerAtomicClass(java.sql.Timestamp.class);

        registerDynamicClass(Map.class, MapDynamicPropertyHandler.class);

    }

    }

        JXPathBasicBeanInfo bi =

        if (beanClass.isInterface()) {

    }

        JXPathBeanInfo beanInfo = (JXPathBeanInfo) byClass.get(beanClass);

        if (beanInfo == null) {

            beanInfo = findDynamicBeanInfo(beanClass);

            if (beanInfo == null) {

                beanInfo = findInformant(beanClass);

                if (beanInfo == null) {

                    beanInfo = new JXPathBasicBeanInfo(beanClass);

        return beanInfo;

        JXPathBeanInfo beanInfo = null;

        if (beanClass.isInterface()) {

            beanInfo = (JXPathBeanInfo) byInterface.get(beanClass);

            if (beanInfo != null && beanInfo.isDynamic()) {

                return beanInfo;

        Class[] interfaces = beanClass.getInterfaces();

        if (interfaces != null) {

            for (int i = 0; i < interfaces.length; i++) {

                beanInfo = findDynamicBeanInfo(interfaces[i]);

                if (beanInfo != null && beanInfo.isDynamic()) {

                    return beanInfo;

        Class sup = beanClass.getSuperclass();

        if (sup != null) {

            beanInfo = (JXPathBeanInfo) byClass.get(sup);

            if (beanInfo != null && beanInfo.isDynamic()) {

            return findDynamicBeanInfo(sup);

        return null;

        String name = beanClass.getName() + "XBeanInfo";

        catch (Exception ex) { //NOPMD

            if (JXPathBeanInfo.class.isAssignableFrom(beanClass)) {

        }

        return null;

        ClassLoader cl = sibling.getClassLoader();

        if (cl != null) {

            catch (Exception ex) { //NOPMD

    private boolean basicKnown = false;

    public Path(Step[] steps) {

        this.steps = steps;

    }

        return steps;

        if (!basicKnown) {

            basicKnown = true;

            basic = true;

            Step[] steps = getSteps();

            for (int i = 0; i < steps.length; i++) {

                if (!isSimpleStep(steps[i])) {

        return basic;

        if (step.getAxis() == Compiler.AXIS_SELF) {

        if (step.getAxis() == Compiler.AXIS_CHILD

            NodeTest nodeTest = step.getNodeTest();

            if (!(nodeTest instanceof NodeNameTest)) {

            if (((NodeNameTest) nodeTest).isWildcard()) {

            return areBasicPredicates(step.getPredicates());

        if (predicates != null && predicates.length != 0) {

        return true;

        if (steps.length == 0) {

        if (isSimplePath()) {

            NodePointer ptr = (NodePointer) context.getSingleNodePointer();

            return SimplePathInterpreter.interpretSimpleLocationPath(

        return buildContextChain(context, steps.length, false);

        if (createInitialContext) {

        if (steps.length == 0) {

        for (int i = 0; i < stepCount; i++) {

            context =

            Expression[] predicates = steps[i].getPredicates();

            if (predicates != null) {

                for (int j = 0; j < predicates.length; j++) {

        return context;

        if (nodeTest instanceof NodeNameTest) {

            QName qname = ((NodeNameTest) nodeTest).getNodeName();

            String prefix = qname.getPrefix();

            if (prefix != null) {

        switch (axis) {

            return new ChildContext(context, nodeTest, false, false);

  public int bufpos = -1;

  protected int column = 0;

  protected int line = 1;

  protected boolean prevCharIsCR = false;

  protected boolean prevCharIsLF = false;

  protected int maxNextCharInd = 0;

  protected int inBuf = 0;

     if (maxNextCharInd == available)

        if ((i = inputStream.read(buffer, maxNextCharInd,

           inputStream.close();

           throw new java.io.IOException();

           maxNextCharInd += i;

        return;

     catch(java.io.IOException e) {

        --bufpos;

        backup(0);

        if (tokenBegin == -1)

           tokenBegin = bufpos;

        throw e;

     tokenBegin = -1;

     char c = readChar();

     tokenBegin = bufpos;

     return c;

     column++;

     if (prevCharIsLF)

     else if (prevCharIsCR)

     switch (c)

     bufline[bufpos] = line;

     bufcolumn[bufpos] = column;

  }

     if (inBuf > 0)

        --inBuf;

        if (++bufpos == bufsize)

        return buffer[bufpos];

     if (++bufpos >= maxNextCharInd)

        FillBuff();

     char c = buffer[bufpos];

     UpdateLineColumn(c);

     return (c);

     return bufcolumn[bufpos];

     return bufline[bufpos];

     return bufcolumn[tokenBegin];

     return bufline[tokenBegin];

    inBuf += amount;

    if ((bufpos -= amount) < 0)

       bufpos += bufsize;

  }

  {

    inputStream = dstream;

    line = startline;

    column = startcolumn - 1;

    available = bufsize = buffersize;

    buffer = new char[buffersize];

    bufline = new int[buffersize];

    bufcolumn = new int[buffersize];

  }

     this(dstream, startline, startcolumn, 4096);

  }

    inputStream = dstream;

    line = startline;

    column = startcolumn - 1;

    if (buffer == null || buffersize != buffer.length)

    prevCharIsLF = prevCharIsCR = false;

    tokenBegin = inBuf = maxNextCharInd = 0;

    bufpos = -1;

  }

     ReInit(dstream, startline, startcolumn, 4096);

  }

     if (bufpos >= tokenBegin)

        return new String(buffer, tokenBegin, bufpos - tokenBegin + 1);

    public JXPathContextFactoryReferenceImpl() {

    }

        return new JXPathContextReferenceImpl(parentContext, contextBean);

        private VariableContextWrapper(JXPathContext context) {

            this.context = context;

        }

            return context;

    private static final Object[] EMPTY_ARRAY = new Object[0];

    public PackageFunctions(String classPrefix, String namespace) {

        this.classPrefix = classPrefix;

        this.namespace = namespace;

    }

    public NodeNameTest(QName qname) {

        this.qname = qname;

    }

        return qname;

        return qname.getName().equals("*");

  static final class JJCalls {

        super(parentContext, new BasicNodeSet());

        this.contexts = contexts;

    }

        return contexts.length > 1 ? 1 : super.getDocumentOrder();

        if (!prepared) {

            prepared = true;

            BasicNodeSet nodeSet = (BasicNodeSet) getNodeSet();

            ArrayList pointers = new ArrayList();

            for (int i = 0; i < contexts.length; i++) {

                while (ctx.nextSet()) {

                    while (ctx.nextNode()) {

                        NodePointer ptr = ctx.getCurrentNodePointer();

                        if (!pointers.contains(ptr)) {

                            pointers.add(ptr);

                    }

            sortPointers(pointers);

            for (Iterator it = pointers.iterator(); it.hasNext();) {

                nodeSet.add((Pointer) it.next());

        return super.setPosition(position);

public class DynaBeanPointerFactory implements NodePointerFactory {

        return DYNA_BEAN_POINTER_FACTORY_ORDER;

        return bean instanceof DynaBean ? new DynaBeanPointer(name, (DynaBean) bean, locale) : null;

        return bean instanceof DynaBean ? new DynaBeanPointer(parent, name, (DynaBean) bean) : null;

public class TreeCompiler implements Compiler {

    private static final QName QNAME_NAME = new QName(null, "name");

        return new QName(prefix, name);

        return new VariableReference((QName) qName);

        return new CoreOperationUnion(toExpressionArray(arguments));

        return new LocationPath(absolute, toStepArray(steps));

        return new ExpressionPath(

        return new NodeNameTest((QName) qname);

        return new Step(

        Expression[] expArray = null;

        if (array != null) {

            expArray = new Expression[array.length];

            for (int i = 0; i < expArray.length; i++) {

                expArray[i] = (Expression) array[i];

        return expArray;

        Step[] stepArray = null;

        if (array != null) {

            stepArray = new Step[array.length];

            for (int i = 0; i < stepArray.length; i++) {

                stepArray[i] = (Step) array[i];

        return stepArray;

public class DynamicPointerFactory implements NodePointerFactory {

        return DYNAMIC_POINTER_FACTORY_ORDER;

        JXPathBeanInfo bi = JXPathIntrospector.getBeanInfo(bean.getClass());

        if (bi.isDynamic()) {

            DynamicPropertyHandler handler =

            return new DynamicPointer(name, bean, handler, locale);

        return null;

        if (bean == null) {

        JXPathBeanInfo bi = JXPathIntrospector.getBeanInfo(bean.getClass());

        if (bi.isDynamic()) {

            DynamicPropertyHandler handler =

            return new DynamicPointer(parent, name, bean, handler);

        return null;

    public VariableReference(QName varName) {

        this.varName = varName;

    }

        return computeValue(context);

        return context.getRootContext().getVariableContext(varName);

    protected int propertyIndex = UNSPECIFIED_PROPERTY;

        super(parent);

    }

        if (propertyIndex != index) {

            propertyIndex = index;

            setIndex(WHOLE_COLLECTION);

    }

        if (bean == null) {

            bean = getImmediateParentPointer().getNode();

        return bean;

        return new QName(null, getPropertyName());

        if (!isActualProperty()) {

        return super.isActual();

    private static final Object UNINITIALIZED = new Object();

    private Object value = UNINITIALIZED;

        Object value = getBaseValue();

        return value != null && ValueUtils.isCollection(value);

        return NodePointer.newChildNodePointer(

        return getImmediateParentPointer().hashCode() + propertyIndex + index;

        if (object == this) {

        if (!(object instanceof PropertyPointer)) {

        PropertyPointer other = (PropertyPointer) object;

        if (parent != other.parent && (parent == null || !parent.equals(other.parent))) {

            return false;

public class BasicNodeSet implements NodeSet {

    private List pointers = new ArrayList();

        if (pointers.add(pointer)) {

            clearCacheLists();

    }

        if (readOnlyPointers == null) {

            readOnlyPointers = Collections.unmodifiableList(pointers);

        return readOnlyPointers;

        readOnlyPointers = null;

        nodes = null;

        values = null;

    }

public class JDOMPointerFactory implements NodePointerFactory {

        return JDOM_POINTER_FACTORY_ORDER;

        if (bean instanceof Document) {

        if (bean instanceof Element) {

        return null;

        if (bean instanceof Document) {

        if (bean instanceof Element) {

        return null;

public class MapDynamicPropertyHandler implements DynamicPropertyHandler {

        Map map = (Map) object;

        Set set = map.keySet();

        String[] names = new String[set.size()];

        Iterator it = set.iterator();

        for (int i = 0; i < names.length; i++) {

            names[i] = String.valueOf(it.next());

        return names;

        return ((Map) object).get(propertyName);

    private boolean basicKnown = false;

        super(steps);

        this.expression = expression;

        this.predicates = predicates;

    }

        return predicates;

        if (!basicKnown) {

            basicKnown = true;

            basic = isSimplePath() && areBasicPredicates(getPredicates());

        return basic;

        return expressionPath(context, false);

        return expressionPath(context, true);

        Object value = expression.compute(evalContext);

        if (value instanceof InitialContext) {

            context = (InitialContext) value;

        if (firstMatch