public void testIssue113() throws Exception

    {

        Document doc = JAXP.getDocument("");

        JXPathContext context = JXPathContext.newContext(doc);

        context.selectNodes("//following-sibling::node()");

    }

    public QName(String prefix, String localName) {

        this.prefix = prefix;

        this.name = localName;

        this.qualifiedName = prefix == null ? localName : prefix + ':' + localName;

    }

    public JXPathContextFactoryReferenceImpl() {

    }

        return new JXPathContextReferenceImpl(parentContext, contextBean);

public class VariablePointerFactory implements NodePointerFactory {

    public static final class VariableContextWrapper {

        return VARIABLE_POINTER_FACTORY_ORDER;

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

        this.axis = axis;

        this.nodeTest = nodeTest;

        this.predicates = predicates;

    }

        return axis;

        return nodeTest;

        return predicates;

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

        type = NodeType();

        jj_consume_token(81);

      switch (jj_nt.kind) {

        jj_la1[12] = jj_gen;

        break label_3;

        if (name != null){

        else if (instruction != null){

            s = compiler.nodeTypeTest(type);

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

  }

    switch (jj_nt.kind) {

      axis = AxisName();

      break;

        {if (true) return axis;}

    int axis = 0;

    switch (jj_nt.kind) {

      jj_consume_token(AXIS_FOLLOWING_SIBLING);

                                          axis = Compiler.AXIS_FOLLOWING_SIBLING;

      break;

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

    switch (jj_nt.kind) {

      jj_consume_token(NODE);

                      type = Compiler.NODE_TYPE_NODE;

      break;

        {if (true) return type;}

    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;

    return false;

    return false;

    xsp = jj_scanpos;

    return false;

    if (jj_scan_token(NODE)) return true;

    return false;

    if (jj_scan_token(TEXT)) return true;

    return false;

    xsp = jj_scanpos;

    jj_scanpos = xsp;

    if (jj_3R_15()) return true;

    if (jj_3R_18()) return true;

    xsp = jj_scanpos;

    return false;

    xsp = jj_scanpos;

    jj_scanpos = xsp;

    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;

  }

        super(null, locale);

        this.node = node;

    }

        super(parent);

        this.node = node;

    }

        return testNode(node, test);

        if (test == null) {

        if (test instanceof NodeNameTest) {

        if (test instanceof NodeTypeTest) {

            int nodeType = node.getNodeType();

            switch (((NodeTypeTest) test).getNodeType()) {

                    return true;

        return new DOMNodeIterator(this, test, reverse, startWith);

        return node;

        return 1;

        return !node.hasChildNodes();

    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;

public class ContainerPointerFactory implements NodePointerFactory {

        return CONTAINER_POINTER_FACTORY_ORDER;

    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;

        ArrayList list = new ArrayList();

        Iterator iterator = iteratePointers(xpath);

        while (iterator.hasNext()) {

        return list;

    private static XPathParser parser = new XPathParser(new StringReader(""));

        synchronized (parser) {

            parser.setCompiler(compiler);

            Object expr = null;

                parser.ReInit(new StringReader(expression));

                expr = parser.parseExpression();

            }

            return expr;

public class CollectionPointerFactory implements NodePointerFactory {

        return COLLECTION_POINTER_FACTORY_ORDER;

        return ValueUtils.isCollection(bean) ? new CollectionPointer(bean, locale) : null;

public abstract class NodeTest {

public class Token {

     switch(ofKind)

       default : return new Token();

        super(steps);

        this.absolute = absolute;

    }

        return absolute;

        if (isAbsolute()) {

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

        return evalSteps(rootContext);

    private static Map dynamicPropertyHandlerMap = new HashMap();

        value = getValue(value);

        if (value == null) {

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

        if (value instanceof Collection) {

        return false;

        while (object instanceof Container) {

        return object;

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

        if (getDocumentOrder() != 0) {

            return constructIterator();

        HashSet set = new HashSet();

        ArrayList list = new ArrayList();

        while (nextSet()) {

            while (nextNode()) {

        if (list.isEmpty()) {

            return false;

        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 boolean basicKnown = false;

    public Path(Step[] steps) {

        this.steps = steps;

    }

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

        switch (axis) {

            return new DescendantContext(context, true, nodeTest);

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

        super(parentContext);

        this.nodeTest = nodeTest;

        this.startFromParentLocation = startFromParentLocation;

        this.reverse = reverse;

    }

        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;

    }

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

  }

    private Node child = null;

    private int position = 0;

        NodePointer startWith) {

        this.parent = parent;

        this.node = (Node) parent.getNode();

        if (startWith != null) {

            this.child = (Node) startWith.getNode();

        this.nodeTest = nodeTest;

        this.reverse = reverse;

    }

        if (position == 0) {

        return child == null ? null : new DOMNodePointer(parent, child);

        return position;

        while (this.position < position) {

            if (!next()) {

                return false;

        while (this.position > position) {

        return true;

        position++;

        if (!reverse) {

            if (position == 1) {

                if (child == null) {

                    child = node.getFirstChild();

                    child = child.getNextSibling();

                child = child.getNextSibling();

            while (child != null && !testChild()) {

        return child != null;

        return DOMNodePointer.testNode(child, nodeTest);

public class DOMPointerFactory implements NodePointerFactory {

        return DOM_POINTER_FACTORY_ORDER;

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

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

    public PackageFunctions(String classPrefix, String namespace) {

        this.classPrefix = classPrefix;

        this.namespace = namespace;

    }

public class DynaBeanPointerFactory implements NodePointerFactory {

        return DYNA_BEAN_POINTER_FACTORY_ORDER;

public class BeanPointerFactory implements NodePointerFactory {

        return BEAN_POINTER_FACTORY_ORDER;

public class DynamicPointerFactory implements NodePointerFactory {

        return DYNAMIC_POINTER_FACTORY_ORDER;

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 {

public class TreeCompiler implements Compiler {

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

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

        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;

            Arrays.sort(nodeFactoryArray, new Comparator() {

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

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

                    return orderA - orderB;

    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;

    protected NodePointer(NodePointer parent) {

        this.parent = parent;

    }

    protected NodePointer(NodePointer parent, Locale locale) {

        this.parent = parent;

        this.locale = locale;

    }

        this.namespaceResolver = namespaceResolver;

    }

        NodePointer pointer = parent;

        while (pointer != null && pointer.isContainer()) {

        return pointer;

        return false;

        return index;

        this.index = index;

    }

        NodePointer ivp = getImmediateValuePointer();

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

        return this;

        return getValuePointer().getImmediateNode();

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

            if (parent != null) {

            return ptr;

    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;

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

  public  java.io.PrintStream debugStream = System.out;

   jjmatchedKind = kind;

   jjmatchedPos = pos;

   return pos + 1;

   jjmatchedKind = kind;

   jjmatchedPos = pos;

   try { curChar = input_stream.readChar(); }

   catch(java.io.IOException e) { return pos + 1; }

   return jjMoveNfa_0(state, pos + 1);

   switch(curChar)

         return jjStopAtPos(0, 81);

         jjmatchedKind = 6;

         return jjMoveStringLiteralDfa1_0(0x80L, 0x0L);

   try { curChar = input_stream.readChar(); }

   }

   switch(curChar)

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

            return jjStopAtPos(1, 7);

   if (((active0 &= old0) | (active1 &= old1)) == 0L)

   try { curChar = input_stream.readChar(); }

   }

   switch(curChar)

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

         else if ((active0 & 0x20000000L) != 0L)

   if (((active0 &= old0) | (active1 &= old1)) == 0L)

   try { curChar = input_stream.readChar(); }

   }

   switch(curChar)

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

            return jjStartNfaWithStates_0(3, 31, 12);

   if (((active0 &= old0) | (active1 &= old1)) == 0L)

   try { curChar = input_stream.readChar(); }

   }

   switch(curChar)

         return jjMoveStringLiteralDfa5_0(active0, 0x240000000000L, active1, 0L);

   if (((active0 &= old0) | (active1 &= old1)) == 0L)

   try { curChar = input_stream.readChar(); }

   }

   switch(curChar)

   if (((active0 &= old0) | (active1 &= old1)) == 0L)

   try { curChar = input_stream.readChar(); }

   }

   switch(curChar)

   if (((active0 &= old0) | (active1 &= old1)) == 0L)

   try { curChar = input_stream.readChar(); }

   }

   switch(curChar)

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

   if (((active0 &= old0) | (active1 &= old1)) == 0L)

   try { curChar = input_stream.readChar(); }

   }

   switch(curChar)

   if (((active0 &= old0) | (active1 &= old1)) == 0L)

   try { curChar = input_stream.readChar(); }

   }

   switch(curChar)

   if (((active0 &= old0) | (active1 &= old1)) == 0L)

   try { curChar = input_stream.readChar(); }

   }

   switch(curChar)

   if (((active0 &= old0) | (active1 &= old1)) == 0L)

   try { curChar = input_stream.readChar(); }

   }

   switch(curChar)

         return jjMoveStringLiteralDfa12_0(active0, 0x600400000000L, active1, 0L);

   if (((active0 &= old0) | (active1 &= old1)) == 0L)

   try { curChar = input_stream.readChar(); }

   }

   switch(curChar)

         return jjMoveStringLiteralDfa13_0(active0, 0x600000000000L, active1, 0L);

   if (((active0 &= old0) | (active1 &= old1)) == 0L)

   try { curChar = input_stream.readChar(); }

   }

   switch(curChar)

         return jjMoveStringLiteralDfa14_0(active0, 0x600000000000L, active1, 0L);

   if (((active0 &= old0) | (active1 &= old1)) == 0L)

   try { curChar = input_stream.readChar(); }

   }

   switch(curChar)

         return jjMoveStringLiteralDfa15_0(active0, 0x600000000000L, active1, 0L);

   if (((active0 &= old0) | (active1 &= old1)) == 0L)

   try { curChar = input_stream.readChar(); }

   }

   switch(curChar)

         return jjMoveStringLiteralDfa16_0(active0, 0x600000000000L);

   if (((active0 &= old0)) == 0L)

   try { curChar = input_stream.readChar(); }

   }

   switch(curChar)

         return jjMoveStringLiteralDfa17_0(active0, 0x600000000000L);

   if (((active0 &= old0)) == 0L)

   try { curChar = input_stream.readChar(); }

   }

   switch(curChar)

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

         return jjMoveStringLiteralDfa18_0(active0, 0x600000000000L);

   if (((active0 &= old0)) == 0L)

   try { curChar = input_stream.readChar(); }

   }

   switch(curChar)

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

            return jjStopAtPos(18, 45);

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 = {