public void testJXPATH118IssueWithAsPath() throws Exception

    {

        Object contextBean = new SomeChildClass();

        JXPathContext context = JXPathContext.newContext(contextBean);

        Iterator iteratePointers = context.iteratePointers("//*");

        Assert.assertEquals("/bar", ((Pointer) iteratePointers.next()).asPath());

        Assert.assertEquals("/baz", ((Pointer) iteratePointers.next()).asPath());

        Assert.assertEquals("/foo", ((Pointer) iteratePointers.next()).asPath());

    }

    private static final Compiler COMPILER = new TreeCompiler();

    private static Map compiled = new HashMap();

    private static int cleanupCount = 0;

    private static NodePointerFactory[] nodeFactoryArray = null;

    private static final Vector nodeFactories = new Vector();

        nodeFactories.add(new CollectionPointerFactory());

        nodeFactories.add(new BeanPointerFactory());

        nodeFactories.add(new DynamicPointerFactory());

        nodeFactories.add(new VariablePointerFactory());

        Object domFactory = allocateConditionally(

        if (domFactory != null) {

            nodeFactories.add(domFactory);

        Object jdomFactory = allocateConditionally(

        if (jdomFactory != null) {

            nodeFactories.add(jdomFactory);

        Object dynaBeanFactory =

        if (dynaBeanFactory != null) {

            nodeFactories.add(dynaBeanFactory);

        nodeFactories.add(new ContainerPointerFactory());

        createNodeFactoryArray();

    }

        if (nodeFactoryArray == null) {

            nodeFactoryArray =

            Arrays.sort(nodeFactoryArray, new Comparator() {

    }

        return nodeFactoryArray;

        this(parentContext, contextBean, null);

    }

        super(parentContext, contextBean);

        synchronized (nodeFactories) {

            createNodeFactoryArray();

        }

        if (contextPointer != null) {

            this.contextPointer =

            this.rootPointer = this.contextPointer;

        NamespaceResolver parentNR = null;

        if (parentContext instanceof JXPathContextReferenceImpl) {

        namespaceResolver = new NamespaceResolver(parentNR);

        namespaceResolver

    }

        return COMPILER;

        synchronized (compiled) {

                expr = null;

                SoftReference ref = (SoftReference) compiled.get(xpath);

                if (ref != null) {

        }

        if (expr != null) {

        expr = (Expression) Parser.parseExpression(xpath, getCompiler());

        synchronized (compiled) {

                if (cleanupCount++ >= CLEANUP_THRESHOLD) {

                compiled.put(xpath, new SoftReference(expr));

        }

        return expr;

        return iteratePointers(xpath, compileExpression(xpath));

        return expr.iteratePointers(getEvalContext());

        return contextPointer;

        return (NodePointer) rootPointer;

        return new InitialContext(new RootContext(this,

        return new InitialContext(new RootContext(this,

        namespaceResolver.seal();

        return namespaceResolver;

            }

            return cls.newInstance();

    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

        return test instanceof NodeTypeTest && ((NodeTypeTest) test).getNodeType() == Compiler.NODE_TYPE_NODE

        return new PropertyIterator(this, property, reverse, startWith);

        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());

        int r = pointer1.getName().toString().compareTo(pointer2.getName().toString());

        return r == 0 ? pointer1.getIndex() - pointer2.getIndex() : r;

    protected HashMap namespaceMap = new HashMap();

    protected HashMap reverseMap = new HashMap();

    public NamespaceResolver(NamespaceResolver parent) {

        this.parent = parent;

    }

        this.pointer = pointer;

    }

        sealed = true;

        if (parent != null) {

    }

public abstract class Expression {

    protected static final Double ZERO = new Double(0);

    protected static final Double ONE = new Double(1);

    protected static final Double NOT_A_NUMBER = new Double(Double.NaN);

    private boolean contextDependencyKnown = false;

        Object result = compute(context);

        if (result == null) {

        if (result instanceof EvalContext) {

            return (EvalContext) result;

    public static class ValueIterator implements Iterator {

    private static final Comparator PROPERTY_DESCRIPTOR_COMPARATOR = new Comparator() {

            return ((PropertyDescriptor) left).getName().compareTo(

    private int availableRegister = 0;

    public static final Object UNKNOWN_VALUE = new Object();

        super(null);

        this.jxpathContext = jxpathContext;

        this.pointer = pointer;

        if (pointer != null) {

            pointer.setNamespaceResolver(jxpathContext.getNamespaceResolver());

    }

        return this;

        return jxpathContext.getAbsoluteRootContext();

        return pointer;

    protected JXPathContextFactory () {

    }

            factoryImpl = (JXPathContextFactory) clazz.newInstance();

        }

        return factoryImpl;

    private static boolean debug = false;

            debug = System.getProperty("jxpath.debug") != null;

        }

    }

            String systemProp = System.getProperty(property);

            if (systemProp != null) {

       }

            String javah = System.getProperty("java.home");

            String configFile =

            File f = new File(configFile);

            if (f.exists()) {

        }

        String serviceId = "META-INF/services/" + property;

            ClassLoader cl = JXPathContextFactory.class.getClassLoader();

            InputStream is = null;

            if (cl == null) {

                is = cl.getResourceAsStream(serviceId);

            if (is != null) {

        }

        return defaultFactory;

  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)

     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);

  }

            this.compiler = compiler;

        }

    ex = Expression();

    jj_consume_token(0);

        {if (true) return ex;}

 Object ex = null;

    switch (jj_nt.kind) {

      ex = AbsoluteLocationPath();

      break;

        {if (true) return ex;}

    ArrayList steps = new ArrayList();

    if (jj_2_2(2147483647)) {

      LocationStep(steps);

        switch (jj_nt.kind) {

          jj_la1[6] = jj_gen;

          break label_1;

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

    switch (jj_nt.kind) {

      jj_consume_token(SLASHSLASH);

            t = compiler.nodeTypeTest(Compiler.NODE_TYPE_NODE);

            steps.add(compiler.step(Compiler.AXIS_DESCENDANT_OR_SELF, t, null));

      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;}

    ArrayList list = null;

    ex = PathExpr();

      switch (jj_nt.kind) {

        jj_la1[20] = jj_gen;

        break label_5;

        if (list != null){

        {if (true) return ex;}

    Object ex = null;

    if (jj_2_6(2147483647)) {

      switch (jj_nt.kind) {

        ex = LocationPath();

        break;

        {if (true) return ex;}

    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;}

    String nc1, nc2 = null;

    switch (jj_nt.kind) {

      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;

    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;

    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_18()) return true;

    xsp = jj_scanpos;

    jj_scanpos = xsp;

    return false;

    xsp = jj_scanpos;

    jj_scanpos = xsp;

    xsp = jj_scanpos;

    xsp = jj_scanpos;

    return false;

    return false;

    if (jj_scan_token(VARIABLE)) return true;

    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;

    return false;

    if (jj_scan_token(FUNCTION_NUMBER)) return true;

    if (jj_scan_token(FUNCTION_LANG)) return true;

    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;

    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;

    if (jj_scan_token(FUNCTION_NAMESPACE_URI)) return true;

    if (jj_scan_token(FUNCTION_LOCAL_NAME)) return true;

  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;

  }

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  java.io.PrintStream debugStream = System.out;

   jjmatchedKind = kind;

   jjmatchedPos = pos;

   return pos + 1;

   switch(curChar)

         jjmatchedKind = 6;

         return jjMoveStringLiteralDfa1_0(0x80L, 0x0L);

   try { curChar = input_stream.readChar(); }

   }

   switch(curChar)

         if ((active0 & 0x80L) != 0L)

            return jjStopAtPos(1, 7);

static final long[] jjbitVec0 = {

static final long[] jjbitVec2 = {

static final long[] jjbitVec3 = {

static final long[] jjbitVec4 = {

static final long[] jjbitVec5 = {

static final long[] jjbitVec6 = {

static final long[] jjbitVec7 = {

static final long[] jjbitVec8 = {

static final long[] jjbitVec9 = {

static final long[] jjbitVec10 = {

static final long[] jjbitVec11 = {

static final long[] jjbitVec12 = {

static final long[] jjbitVec13 = {

static final long[] jjbitVec14 = {

static final long[] jjbitVec15 = {

static final long[] jjbitVec16 = {

static final long[] jjbitVec17 = {

static final long[] jjbitVec18 = {

static final long[] jjbitVec19 = {

static final long[] jjbitVec20 = {

static final long[] jjbitVec21 = {

static final long[] jjbitVec22 = {

static final long[] jjbitVec23 = {

static final long[] jjbitVec24 = {

static final long[] jjbitVec25 = {

static final long[] jjbitVec26 = {

static final long[] jjbitVec27 = {

static final long[] jjbitVec28 = {

static final long[] jjbitVec29 = {

static final long[] jjbitVec30 = {

static final long[] jjbitVec31 = {

static final long[] jjbitVec32 = {

static final long[] jjbitVec33 = {

static final long[] jjbitVec34 = {

static final long[] jjbitVec35 = {

static final long[] jjbitVec36 = {

static final long[] jjbitVec37 = {

static final long[] jjbitVec38 = {

static final long[] jjbitVec39 = {

static final long[] jjbitVec40 = {

static final long[] jjbitVec41 = {

static final int[] jjnextStates = {

public static final String[] jjstrLiteralImages = {

public static final String[] lexStateNames = {

static final long[] jjtoToken = {

static final long[] jjtoSkip = {

private final int[] jjrounds = new int[13];

private final int[] jjstateSet = new int[26];

{

   input_stream = stream;

}

   jjmatchedPos = jjnewStateCnt = 0;

   curLexState = defaultLexState;

   input_stream = stream;

   ReInitRounds();

}

   jjround = 0x80000001;

   for (i = 13; i-- > 0;)

      jjrounds[i] = 0x80000000;

}

   Token t = Token.newToken(jjmatchedKind);

   t.kind = jjmatchedKind;

   String im = jjstrLiteralImages[jjmatchedKind];

   t.image = (im == null) ? input_stream.GetImage() : im;

   t.beginLine = input_stream.getBeginLine();

   t.beginColumn = input_stream.getBeginColumn();

   t.endLine = input_stream.getEndLine();

   t.endColumn = input_stream.getEndColumn();

   return t;

int curLexState = 0;

int defaultLexState = 0;

  Token specialToken = null;

  int curPos = 0;

      curChar = input_stream.BeginToken();

   catch(java.io.IOException e)

      jjmatchedKind = 0;

      matchedToken = jjFillToken();

      return matchedToken;

   }

   try { input_stream.backup(0);

      while (curChar <= 32 && (0x100003600L & (1L << curChar)) != 0L)

   catch (java.io.IOException e1) { continue EOFLoop; }

   jjmatchedKind = 0x7fffffff;

   jjmatchedPos = 0;

   curPos = jjMoveStringLiteralDfa0_0();

   if (jjmatchedKind != 0x7fffffff)

      if (jjmatchedPos + 1 < curPos)

      if ((jjtoToken[jjmatchedKind >> 6] & (1L << (jjmatchedKind & 077))) != 0L)

         matchedToken = jjFillToken();

         return matchedToken;

    private boolean setStarted = false;

    private Stack stack = null;

    private NodePointer currentNodePointer = null;

    private static final NodeTest ELEMENT_NODE_TEST =

        super(parentContext);

        this.includeSelf = includeSelf;

        this.nodeTest = nodeTest;

    }

        return true;

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

        return currentNodePointer;

        super.reset();

        setStarted = false;

    }

        if (!setStarted) {

            setStarted = true;

            if (stack == null) {

                stack = new Stack();

            currentNodePointer = parentContext.getCurrentNodePointer();

            if (currentNodePointer != null) {

                if (!currentNodePointer.isLeaf()) {

                    stack.push(

                if (includeSelf && currentNodePointer.testNode(nodeTest)) {

                    position++;

                    return true;

        while (!stack.isEmpty()) {

            NodeIterator it = (NodeIterator) stack.peek();

            if (it.setPosition(it.getPosition() + 1)) {

                currentNodePointer = it.getNodePointer();

                if (!isRecursive()) {

                    if (!currentNodePointer.isLeaf()) {

                    if (currentNodePointer.testNode(nodeTest)) {

                        position++;

                        return true;

                stack.pop();

        }

        return false;

        Object node = currentNodePointer.getNode();

        for (int i = stack.size() - 1; --i >= 0;) {

        return false;

public abstract class NodeTest {

    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 atomic;

        return dynamicPropertyHandlerClass != null;

        if (propertyDescriptors == null) {

            if (clazz == Object.class) {

                    BeanInfo bi = null;

                    if (clazz.isInterface()) {

                        bi = Introspector.getBeanInfo(clazz, Object.class);

                    PropertyDescriptor[] pds = bi.getPropertyDescriptors();

                    PropertyDescriptor[] descriptors = new PropertyDescriptor[pds.length];

                    System.arraycopy(pds, 0, descriptors, 0, pds.length);

                    Arrays.sort(descriptors, PROPERTY_DESCRIPTOR_COMPARATOR);

                    propertyDescriptors = descriptors;

                }

        if (propertyDescriptors.length == 0) {

        PropertyDescriptor[] result = new PropertyDescriptor[propertyDescriptors.length];

        System.arraycopy(propertyDescriptors, 0, result, 0, propertyDescriptors.length);

        return result;

            Arrays.sort(nodeFactoryArray, new Comparator() {

                    int orderA = ((NodePointerFactory) a).getOrder();

                    int orderB = ((NodePointerFactory) b).getOrder();

                    return orderA - orderB;

    protected int position = 0;

    private boolean startedSetIteration = false;

    private boolean done = false;

    private boolean hasPerformedIteratorStep = false;

    public EvalContext(EvalContext parentContext) {

        this.parentContext = parentContext;

    }

        return parentContext != null && parentContext.isChildOrderingRequired() ? 1 : 0;

        if (pointerIterator != null) {

            return pointerIterator.next();

        if (getDocumentOrder() != 0) {

            if (!constructIterator()) {

            return pointerIterator.next();

        HashSet set = new HashSet();

        ArrayList list = new ArrayList();

        while (nextSet()) {

            while (nextNode()) {

                NodePointer pointer = getCurrentNodePointer();

                if (!set.contains(pointer)) {

                    set.add(pointer);

                    list.add(pointer);

            }

        if (list.isEmpty()) {

        sortPointers(list);

        pointerIterator = list.iterator();

        return true;

        switch (getDocumentOrder()) {

            Collections.sort(l);

            break;

    }

        if (rootContext == null) {

            rootContext = parentContext.getRootContext();

        return rootContext;

        position = 0;

    }

        return position;

        reset(); // Restart iteration within the set

        if (!startedSetIteration) {

            startedSetIteration = true;

            while (parentContext.nextSet()) {

                if (parentContext.nextNode()) {

                    return true;

        if (parentContext.nextNode()) {

            return true;

        while (parentContext.nextSet()) {

        return false;

        this.position = position;

        return true;

    private static final PackageFunctions GENERIC_FUNCTIONS =

    private boolean lenientSet = false;

    private boolean lenient = false;

        return getContextFactory().newContext(null, contextBean);

        return contextFactory;

    protected JXPathContext(JXPathContext parentContext, Object contextBean) {

        this.parentContext = parentContext;

        this.contextBean = contextBean;

    }

        if (locale == null) {

            if (parentContext != null) {

            locale = Locale.getDefault();

        return locale;

  static final class JJCalls {

public class DynamicPointerFactory implements NodePointerFactory {

        return DYNAMIC_POINTER_FACTORY_ORDER;

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

        if (bi.isDynamic()) {

        return null;

        if (bean == null) {

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

        if (bi.isDynamic()) {

        return null;

        super(parentContext);

        this.nodeTest = nodeTest;

        this.startFromParentLocation = startFromParentLocation;

        this.reverse = reverse;

    }

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

        return iterator == null ? null : iterator.getNodePointer();

        return setPosition(getCurrentPosition() + 1);

        super.reset();

        iterator = null;

    }

        int oldPosition = getCurrentPosition();

        super.setPosition(position);

        if (oldPosition == 0) {

            prepare();

        return iterator == null ? false : iterator.setPosition(position);

        NodePointer parent = parentContext.getCurrentNodePointer();

        if (parent == null) {

        NodePointer useParent = startFromParentLocation ? parent.getParent() : parent;

        iterator = useParent.childIterator(nodeTest, reverse,

    }

public class BeanPointerFactory implements NodePointerFactory {

        return BEAN_POINTER_FACTORY_ORDER;

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

        return new BeanPointer(name, bean, bi, locale);

        if (bean == null) {

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

        return new BeanPointer(parent, name, bean, bi);

public class DOMPointerFactory implements NodePointerFactory {

        return DOM_POINTER_FACTORY_ORDER;

        return bean instanceof Node ? new DOMNodePointer((Node) bean, locale) : null;

        return bean instanceof Node ? new DOMNodePointer(parent, (Node) bean) : null;

    protected Step(int axis, NodeTest nodeTest, Expression[] predicates) {

        this.axis = axis;

        this.nodeTest = nodeTest;

        this.predicates = predicates;

    }

        return axis;

        return nodeTest;

        return predicates;

public class TreeCompiler implements Compiler {

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

        return new QName(prefix, name);

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

        return new NodeNameTest((QName) qname);

        return new NodeTypeTest(nodeType);

        return new Step(

        Expression[] expArray = null;

        if (array != null) {

            expArray = new Expression[array.length];

            for (int i = 0; i < expArray.length; 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;

        super(steps);

        this.absolute = absolute;

    }

        return absolute;

        if (isAbsolute()) {

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

        return evalSteps(rootContext);

    private boolean started = false;

        super(parentContext);

        nodePointer =

        if (nodePointer != null) {

            collection =

    }

        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;

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

    public PackageFunctions(String classPrefix, String namespace) {

        this.classPrefix = classPrefix;

        this.namespace = namespace;

    }

    private static Map dynamicPropertyHandlerMap = new HashMap();

        value = getValue(value);

        if (value == null) {

        if (value.getClass().isArray()) {

        if (value instanceof Collection) {

        return false;

        if (clazz.isArray()) {

        if (Collection.class.isAssignableFrom(clazz)) {

        if (clazz.isPrimitive()) {

            return -1;