/FileExtraction/Java_unseen/dlitz_resin/modules/kernel/src/com/caucho/xpath/XPathParser.java
/*
 * Copyright (c) 1998-2011 Caucho Technology -- all rights reserved
 *
 * This file is part of Resin(R) Open Source
 *
 * Each copy or derived work must preserve the copyright notice and this
 * notice unmodified.
 *
 * Resin Open Source is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * Resin Open Source is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, or any warranty
 * of NON-INFRINGEMENT.  See the GNU General Public License for more
 * details.
 *
 * You should have received a copy of the GNU General Public License
 * along with Resin Open Source; if not, write to the
 *   Free SoftwareFoundation, Inc.
 *   59 Temple Place, Suite 330
 *   Boston, MA 02111-1307  USA
 *
 * @author Scott Ferguson
 */

package com.caucho.xpath;

import com.caucho.server.util.CauchoSystem;
import com.caucho.util.CharBuffer;
import com.caucho.util.IntMap;
import com.caucho.util.L10N;
import com.caucho.xml.XmlChar;
import com.caucho.xpath.expr.*;
import com.caucho.xpath.functions.BaseURI;
import com.caucho.xpath.functions.ResolveURI;
import com.caucho.xpath.functions.Trace;
import com.caucho.xpath.pattern.*;

import org.w3c.dom.Node;

import java.lang.reflect.Constructor;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.logging.Logger;


/**
 * Parses an XPath expression.
 */
class XPathParser {
  private static final Logger log
    = Logger.getLogger(XPathParser.class.getName());
  private static final L10N L = new L10N(XPathParser.class);

  private final static int ANCESTOR_AXIS = 0;
  private final static int ANCESTOR_OR_SELF_AXIS = ANCESTOR_AXIS + 1;
  private final static int ATTRIBUTE_AXIS = ANCESTOR_OR_SELF_AXIS + 1;
  private final static int CHILD_AXIS = ATTRIBUTE_AXIS + 1;
  private final static int DESCENDANT_AXIS = CHILD_AXIS + 1;
  private final static int DESCENDANT_OR_SELF_AXIS = DESCENDANT_AXIS + 1;
  private final static int FOLLOWING_AXIS = DESCENDANT_OR_SELF_AXIS + 1;
  private final static int FOLLOWING_SIBLING_AXIS = FOLLOWING_AXIS + 1;
  private final static int NAMESPACE_AXIS = FOLLOWING_SIBLING_AXIS + 1;
  private final static int PARENT_AXIS = NAMESPACE_AXIS + 1;
  private final static int PRECEDING_AXIS = PARENT_AXIS + 1;
  private final static int PRECEDING_SIBLING_AXIS = PRECEDING_AXIS + 1;
  private final static int SELF_AXIS = PRECEDING_SIBLING_AXIS + 1;

  private final static int TEXT = Expr.LAST_FUN + 1;
  private final static int COMMENT = TEXT + 1;
  private final static int ER = COMMENT + 1;
  private final static int PI = ER + 1;
  private final static int NODE = PI + 1;
  private final static int CURRENT = NODE + 1;
  private final static int NODE_TEXT = CURRENT + 1;
  private final static int CONTEXT = NODE_TEXT + 1;

  private static IntMap exprFunctions;
  private static IntMap axisMap;

  private static HashMap<String,Constructor> _exprFunctions;
  
  private CharBuffer tag = new CharBuffer();

  private String _string;
  private int index;
  private int peek;

  private NamespaceContext _namespace;

  XPathParser(String string, NamespaceContext namespace)
  {
    _string = string;
    _namespace = namespace;
  }

  /**
   * Parse a select pattern, i.e. a path rooted in a context.
   */
  AbstractPattern parseSelect()
    throws XPathParseException
  {
    AbstractPattern top = new FromContext();

    AbstractPattern pattern = parseUnion(parseTop(top), top);

    if (index < _string.length())
      throw error(L.l("unexpected character at `{0}'", badChar(read())));

    return pattern;
  }

  /**
   * Parse a match pattern, i.e. a path with no root.
   */
  AbstractPattern parseMatch()
    throws XPathParseException
  {
    AbstractPattern root = new FromAny();
    AbstractPattern pattern = parseUnion(parseTop(root), root);

    if (index < _string.length())
      throw error(L.l("unexpected character at `{0}'", badChar(read())));

    return pattern;
  }


  /**
   * Parse an expression.
   */
  Expr parseExpr()
    throws XPathParseException
  {
    Expr expr = parseExpr(null, null);

    if (index < _string.length())
      throw error(L.l("unexpected character at `{0}'", badChar(read())));

    return expr;
  }

  private AbstractPattern parseStep(AbstractPattern root)
    throws XPathParseException
  {
    return parseUnion(parseTop(root), root);
  }

  private AbstractPattern parseUnion(AbstractPattern left, AbstractPattern root)
    throws XPathParseException
  {
    int ch = skipWhitespace(read());

    while (ch >= 0) {
      if (ch == '|') {
        AbstractPattern tail = parseUnion(parseTop(root), root);
        left = new UnionPattern(left, tail);
      } else
        break;

      for (ch = read(); XmlChar.isWhitespace(ch); ch = read()) {
      }
    }

    unread();

    return left;
  }

  /**
   * Parses the top expression.
   *
   * <pre>
   *  top ::= (expr)
   *      ::= term
   * </pre>
   */
  private AbstractPattern parseTop(AbstractPattern pattern)
    throws XPathParseException
  {
    int ch = skipWhitespace(read());
    unread();

    if (ch == '(') {
      Expr expr = parseTerm(pattern, pattern);

      // If the expression is really a pattern and the iterator is
      // ascending, then just unwrap it.
      if (expr instanceof NodeSetExpr) {
        AbstractPattern nodeSet = ((NodeSetExpr) expr).getPattern();

        if (nodeSet.isAscending())
          return nodeSet;
      }

      return new FromExpr(null, expr);
    }
    else
      return parseTerm(pattern, pattern).toNodeList();
  }

  private AbstractPattern parseBasisTop(AbstractPattern pattern)
    throws XPathParseException
  {
    int ch;

    ch = skipWhitespace(read());
    if (ch == '/') {
      ch = read();
      if (ch == '/') {
        pattern = new FromRoot();
        pattern = new FromDescendants(pattern, false);
        pattern = parseBasis(pattern);
        pattern = parseFilter(pattern);
        pattern = parsePath(pattern);

        return pattern;
      }
      pattern = new FromRoot();
      ch = skipWhitespace(ch);

      if (ch == -1)
        return pattern;
    }

    unread();

    if (pattern == null)
      pattern = new FromContext();

    pattern = parseBasis(pattern);
    pattern = parseFilter(pattern);

    return parsePath(pattern);
  }

  /**
   * path ::= top ('/' filter)*
   */
  private AbstractPattern parsePath(AbstractPattern pattern)
    throws XPathParseException
  {
    int ch = skipWhitespace(read());

    while (ch == '/') {
      ch = read();

      if (ch == '/') {
        pattern = new FromDescendants(pattern, false);
        pattern = parseBasis(pattern);
        pattern = parseFilter(pattern);
      }
      else {
        unread();
        pattern = parseBasis(pattern);
        pattern = parseFilter(pattern);
      }

      ch = skipWhitespace(read());
    }

    unread();
    
    return pattern;
  }
  
  /**
   * filter ::= atom('[' expr ']')*
   */
  private AbstractPattern parseFilter(AbstractPattern pattern)
    throws XPathParseException
  {
    int ch = skipWhitespace(read());
    while (ch == '[') {
      AbstractPattern context = new FromContext();
      Expr expr = parseExpr(context, pattern);
      pattern = new FilterPattern(pattern, expr);

      ch = skipWhitespace(read());
      if (ch !=  ']')
        throw error(L.l("expected `{0}' at {1}", "]", badChar(ch)));

      ch = skipWhitespace(read());
    }
    unread();

    return pattern;
  }

  /**
   * basis ::= name::node-test
   *         | node-test
   *         | @node-test
   *         | .
   *         | ..
   *         ;
   */
  private AbstractPattern parseBasis(AbstractPattern pattern)
    throws XPathParseException
  {
    boolean fromChildren = true;
    int ch = skipWhitespace(read());

    int nodeType = Node.ELEMENT_NODE;
    String namespace = null;
    tag.clear();

    if (ch == '@') {
      if (pattern instanceof FromDescendants)
        pattern = NodeTypePattern.create(pattern, NodeTypePattern.NODE);
      
      pattern = new FromAttributes(pattern);
      nodeType = Node.ATTRIBUTE_NODE;
      fromChildren = false;
      ch = read();
    }
    else if (ch == '.') {
      ch = read();
      if (ch == '.')
        return NodeTypePattern.create(new FromParent(pattern),
                                      NodeTypePattern.NODE);
      else {
        unread();
        if (pattern != null)
          return pattern;
        else
          return NodeTypePattern.create(new FromSelf(pattern), NodeTypePattern.ANY);
      }
    }
    else if (ch == '(') {
      // XXX: not strictly correct for counting
      Expr expr = parseExpr(null, null);

      if ((ch = read()) != ')')
        throw error(L.l("expected `{0}' at {1}", ")", badChar(ch)));

      return new FromExpr(pattern, expr);
    }

    if (ch == '*') {
      tag.append('*');
    }

    else if (XmlChar.isNameStart(ch)) {
      for (; XmlChar.isNameChar(ch); ch = read())
        tag.append((char) ch);

      if (ch == '*' && tag.endsWith(":"))
        tag.append('*');
      else
        unread();
    }
    else
      unread();

    String name = tag.toString();

    if (name.equals(""))
      throw error(L.l("expected name at {0}", badChar(ch)));

    return parseAxis(pattern, name, fromChildren, nodeType);
  }

  private AbstractPattern parseAxis(AbstractPattern pattern, String name,
                                    boolean fromChildren, int nodeType)
    throws XPathParseException
  {
    String axis = "";
    int axisIndex = name.indexOf("::");

    if (axisIndex >= 0 && nodeType != Node.ATTRIBUTE_NODE) {
      axis = name.substring(0, axisIndex);
      name = name.substring(axisIndex + 2);
    }

    if (pattern instanceof FromDescendants)
      return parseNodeTest(pattern, name, false, Node.ELEMENT_NODE);

    switch (axisMap.get(axis)) {
    case ANCESTOR_AXIS:
      return parseNodeTest(new FromAncestors(pattern, false),
                           name, false, Node.ELEMENT_NODE);

    case ANCESTOR_OR_SELF_AXIS:
      return parseNodeTest(new FromAncestors(pattern, true),
                           name, false, Node.ELEMENT_NODE);

    case ATTRIBUTE_AXIS:
      return parseNodeTest(new FromAttributes(pattern),
                           name, false, Node.ATTRIBUTE_NODE);

    case CHILD_AXIS:
      return parseNodeTest(new FromChildren(pattern),
                           name, false, Node.ELEMENT_NODE);

    case DESCENDANT_AXIS:
      return parseNodeTest(new FromDescendants(pattern, false),
                           name, false, Node.ELEMENT_NODE);

    case DESCENDANT_OR_SELF_AXIS:
      return parseNodeTest(new FromDescendants(pattern, true),
                           name, false, Node.ELEMENT_NODE);

    case FOLLOWING_AXIS:
      return parseNodeTest(new FromNext(pattern),
                           name, false, Node.ELEMENT_NODE);

    case FOLLOWING_SIBLING_AXIS:
      return parseNodeTest(new FromNextSibling(pattern),
                           name, false, Node.ELEMENT_NODE);

    case NAMESPACE_AXIS:
      return parseNodeTest(new FromNamespace(pattern),
                           name, false, Node.ATTRIBUTE_NODE);

    case PARENT_AXIS:
      return parseNodeTest(new FromParent(pattern),
                           name, false, Node.ELEMENT_NODE);

    case PRECEDING_AXIS:
      return parseNodeTest(new FromPrevious(pattern),
                           name, false, Node.ELEMENT_NODE);

    case PRECEDING_SIBLING_AXIS:
      return parseNodeTest(new FromPreviousSibling(pattern),
                           name, false, Node.ELEMENT_NODE);

    case SELF_AXIS:
      return parseNodeTest(new FromSelf(pattern),
                           name, false, Node.ELEMENT_NODE);

    default:
      return parseNodeTest(pattern, name, fromChildren, nodeType);
    }
  }

  /**
   * node-test ::= qname
   *             | *:name
   *             | *
   *             | name '(' args ')'
   *             ;
   */
  private AbstractPattern parseNodeTest(AbstractPattern pattern, String name,
                                        boolean fromChildren, int nodeType)
    throws XPathParseException
  {
    int ch = skipWhitespace(read());

    AbstractPattern tagPattern;

    if (ch == '(') {
      Expr expr = parseFunction(pattern, pattern, name, fromChildren);
      return expr.toNodeList();
    }
    else if (ch == '{') {
      tag.clear();
      while ((ch = read()) >= 0 && ch != '}')
        tag.append((char) ch);
      String url = tag.toString();
      tag.clear();
      for (ch = read(); XmlChar.isNameChar(ch); ch = read())
        tag.append((char) ch);

      pattern = new NSNamePattern(pattern, url, tag.toString(), nodeType);
    }
    else {
      if (fromChildren)
        pattern = new FromChildren(pattern);

      if (name.equals("*"))
        pattern = NodeTypePattern.create(pattern, nodeType);
      else if (name.endsWith(":*")) {
        pattern = new NamespacePattern(pattern,
                                       name.substring(0, name.length() - 2),
                                       nodeType);
      }
      else {
        int p = name.indexOf(':');
        String ns = null;
        String local = name;

        if (p > 0) {
          String prefix = name.substring(0, p);
          ns = NamespaceContext.find(_namespace, prefix);
          local = name.substring(p + 1);
        }
        else if (nodeType != Node.ATTRIBUTE_NODE)
          ns = _namespace.find(_namespace, "");
        else
          ns = null; // _namespace.find(_namespace, "");

        if (ns == null)
          pattern = new NodePattern(pattern, name, nodeType);
        else
          pattern = new NSNamePattern(pattern, ns, local, nodeType);
      }
    }
    unread();

    return pattern;
  }

  /**
   * expr ::= or-expr
   */
  Expr parseExpr(AbstractPattern parent, AbstractPattern listParent)
    throws XPathParseException
  {
    peek = -1;
    Expr left = parseTerm(parent, listParent);

    while (true) {
      int token = scanToken();
      switch (token) {
      case Expr.OR:
        left = parseOrExpr(token, left, parseTerm(parent, listParent),
                           parent, listParent);
        break;

      case Expr.AND:
        left = parseAndExpr(token, left, parseTerm(parent, listParent),
                            parent, listParent);
        break;

      case Expr.EQ: case Expr.NEQ: case Expr.LT:
      case Expr.LE: case Expr.GT: case Expr.GE:
        left = parseCmpExpr(token, left, parseTerm(parent, listParent),
                            parent, listParent);
        break;

      case Expr.ADD: case Expr.SUB:
        left = parseAddExpr(token, left, parseTerm(parent, listParent),
                            parent, listParent);
        break;

      case Expr.MUL: case Expr.DIV: case Expr.QUO: case Expr.MOD:
        left = parseMulExpr(token, left, parseTerm(parent, listParent),
                            parent, listParent);
        break;

      default:
        return left;
      }
    }
  }

  /**
   * or-expr ::= or-expr 'OR' expr
   *           | and-expr
   */
  private Expr parseOrExpr(int code, Expr left, Expr right,
                           AbstractPattern parent, AbstractPattern listParent)
    throws XPathParseException
  {
    while (true) {
      int token = scanToken();
      switch (token) {
      case Expr.OR:
        left = new BooleanExpr(code, left, right);
        code = token;
        right = parseTerm(parent, listParent);
        break;

      case Expr.AND:
        right = parseAndExpr(token, right, parseTerm(parent, listParent),
                             parent, listParent);
        break;

      case Expr.EQ: case Expr.NEQ: case Expr.LT:
      case Expr.LE: case Expr.GT: case Expr.GE:
        right = parseCmpExpr(token, right, parseTerm(parent, listParent),
                             parent, listParent);
        break;

      case Expr.ADD: case Expr.SUB:
        right = parseAddExpr(token, right, parseTerm(parent, listParent),
                             parent, listParent);
        break;

      case Expr.MUL: case Expr.DIV: case Expr.QUO: case Expr.MOD:
        right = parseMulExpr(token, right, parseTerm(parent, listParent),
                             parent, listParent);
        break;

      default:
        undoToken(token);
        return new BooleanExpr(code, left, right);
      }
    }
  }

  /**
   * and-expr ::= and-expr 'AND' expr
   *            | cmp-expr
   */
  private Expr parseAndExpr(int code, Expr left, Expr right,
                            AbstractPattern parent, AbstractPattern listParent)
    throws XPathParseException
  {
    while (true) {
      int token = scanToken();
      switch (token) {
      case Expr.AND:
        left = new BooleanExpr(code, left, right);
        code = token;
        right = parseTerm(parent, listParent);
        break;

      case Expr.EQ: case Expr.NEQ: case Expr.LT:
      case Expr.LE: case Expr.GT: case Expr.GE:
        right = parseCmpExpr(token, right, parseTerm(parent, listParent),
                             parent, listParent);
        break;

      case Expr.ADD: case Expr.SUB:
        right = parseAddExpr(token, right, parseTerm(parent, listParent),
                             parent, listParent);
        break;

      case Expr.MUL: case Expr.DIV: case Expr.QUO: case Expr.MOD:
        right = parseMulExpr(token, right, parseTerm(parent, listParent),
                             parent, listParent);
        break;

      default:
        undoToken(token);
        return new BooleanExpr(code, left, right);
      }
    }
  }

  /**
   * cmp-expr ::= cmp-expr '<' expr
   *            | add-expr
   */
  private Expr parseCmpExpr(int code, Expr left, Expr right,
                            AbstractPattern parent, AbstractPattern listParent)
    throws XPathParseException
  {
    while (true) {
      int token = scanToken();
      switch (token) {
      case Expr.EQ: case Expr.NEQ: case Expr.LT:
      case Expr.LE: case Expr.GT: case Expr.GE:
        left = new BooleanExpr(code, left, right);
        code = token;
        right = parseTerm(parent, listParent);
        break;

      case Expr.ADD: case Expr.SUB:
        right = parseAddExpr(token, right, parseTerm(parent, listParent),
                             parent, listParent);
        break;

      case Expr.MUL: case Expr.DIV: case Expr.QUO: case Expr.MOD:
        right = parseMulExpr(token, right, parseTerm(parent, listParent),
                             parent, listParent);
        break;

      default:
        undoToken(token);
        return new BooleanExpr(code, left, right);
      }
    }
  }

  /**
   * add-expr ::= add-expr '+' expr
   *            | mul-expr
   */
  private Expr parseAddExpr(int code, Expr left, Expr right,
                            AbstractPattern parent, AbstractPattern listParent)
    throws XPathParseException
  {
    while (true) {
      int token = scanToken();
      switch (token) {
      case Expr.ADD: case Expr.SUB:
        left = new NumericExpr(code, left, right);
        code = token;
        right = parseTerm(parent, listParent);
        break;

      case Expr.MUL: case Expr.DIV: case Expr.QUO: case Expr.MOD:
        right = parseMulExpr(token, right, parseTerm(parent, listParent),
                             parent, listParent);
        break;

      default:
        undoToken(token);
        return new NumericExpr(code, left, right);
      }
    }
  }

  /**
   * mul-expr ::= mul-expr '*' expr
   *            | term
   */
  private Expr parseMulExpr(int code, Expr left, Expr right,
                            AbstractPattern parent, AbstractPattern listParent)
    throws XPathParseException
  {
    while (true) {
      int token = scanToken();
      switch (token) {
      case Expr.MUL: case Expr.DIV: case Expr.QUO: case Expr.MOD:
        left = new NumericExpr(code, left, right);
        code = token;
        right = parseTerm(parent, listParent);
        break;

      default:
        undoToken(token);
        return new NumericExpr(code, left, right);
      }
    }
  }

  /**
   * term ::= simple-term path?
   */
  private Expr parseTerm(AbstractPattern parent, AbstractPattern listParent)
    throws XPathParseException
  {
    int ch = skipWhitespace(read());
    unread();
    Expr expr = parseSimpleTerm(parent, listParent);

    int nextCh = skipWhitespace(read());
    unread();
    if (nextCh == '/' || nextCh == '[') {
      AbstractPattern pattern = expr.toNodeList();

      if (ch == '(' && ! pattern.isStrictlyAscending())
        pattern = new FromExpr(null, expr);

      return NodeSetExpr.create(parseUnion(parsePath(parseFilter(pattern)),
                                           pattern));
    }
    else if (nextCh == '|') {
      AbstractPattern pattern = expr.toNodeList();

      return NodeSetExpr.create(parseUnion(parsePath(parseFilter(pattern)),
                                           listParent));
    }
    else
      return expr;
  }

  /**
   * simple-term ::= number
   *             ::= '(' expr ')'
   *             ::= '$' variable
   *             ::= '"' string '"'
   *             ::= node-set
   */
  private Expr parseSimpleTerm(AbstractPattern parent, AbstractPattern listParent)
    throws XPathParseException
  {
    int ch = read();
    
    ch = skipWhitespace(ch);

    switch (ch) {
    case '.':
      ch = read();
      unread();
      unread();
      if (! ('0' <= ch && ch <= '9')) {
        return NodeSetExpr.create(parseUnion(parseBasisTop(parent), parent));
      }
      ch = read();
      // fall through to parse the number

    case '0': case '1': case '2': case '3': case '4':
    case '5': case '6': case '7': case '8': case '9':
      {
        long value = 0;
        double exp = 1;
        int digits = 0;
        for (; ch >= '0' && ch <= '9'; ch = read())
          value = 10 * value + ch - '0';
        if (ch == '.') {
          for (ch = read(); ch >= '0' && ch <= '9'; ch = read()) {
            value = 10 * value + ch - '0';
            exp *= 10;
            digits--;
          }
        }

        if (ch == 'e' || ch == 'E') {
          int sign = 1;
          int expValue = 0;
          
          ch = read();
          if (ch == '-') {
            sign = -1;
            ch = read();
          }
          else if (ch == '+')
            ch = read();
          
          for (; ch >= '0' && ch <= '9'; ch = read())
            expValue = 10 * expValue + ch - '0';

          exp = Math.pow(10, digits + sign * expValue);

          unread();
          
          return new NumericExpr((double) value * (double) exp);
        }
        
        unread();
        return new NumericExpr((double) value / (double) exp);
      }

    case '-':
      return new NumericExpr(Expr.NEG, parseTerm(parent, listParent));

    case '+':
      return parseTerm(parent, listParent);

    case '(':
      {
        Expr expr = parseExpr(parent, listParent);
        if ((ch = skipWhitespace(read())) != ')')
          throw error(L.l("expected `{0}' at {1}", ")", badChar(ch)));

        return expr;
      }

    case '/': case '@': case '*':
      unread();
      return NodeSetExpr.create(parseUnion(parseBasisTop(parent), parent));

    case '\'': case '"':
      {
        int end = ch;
        CharBuffer cb = new CharBuffer();
        for (ch = read(); ch >= 0; ch = read()) {
          if (ch != end)
            cb.append((char) ch);
          else if ((ch = read()) == end)
            cb.append((char) ch);
          else {
            unread();
            break;
          }
        }

        return new StringExpr(cb.toString());
      }

    case '$':
      {
        String name = readName(read());
        return new VarExpr(name);
      }

    default:
      if (! XmlChar.isNameStart(ch))
        throw error(L.l("unknown character at {0}", badChar(ch)));

      String name = readName(ch);

      ch = skipWhitespace(read());
      int axisIndex = name.indexOf("::");

      // make sure axis are treated as node sets
      if (ch == '(' && axisIndex < 0) {
        return parseFunction(parent, listParent, name, true);
      }
      else if (ch == '(') {
        String axis = name.substring(0, axisIndex);
        if (axisMap.get(axis) <= 0)
          return parseFunction(parent, listParent, name, true);
      }
      
      unread();

      if (parent == null)
        parent = new FromContext();
      return parseNodeSetExpr(parent, name, Node.ELEMENT_NODE);
    }
  }

  /**
   * function ::= name '(' args ')'
   *
   * The XPath library functions are hard-coded for a little extra
   * execution efficiency.
   */
  Expr parseFunction(AbstractPattern parent,
                     AbstractPattern listParent,
                     String name,
                     boolean fromChildren)
    throws XPathParseException
  {
    int ch = skipWhitespace(read());

    ArrayList<Expr> args = new ArrayList<Expr>();

    for (; ch >= 0 && ch != ')'; ch = skipWhitespace(read())) {
      if (ch != ',')
        unread();
      Expr expr = parseExpr(parent, listParent);

      if (expr == null)
        throw error(L.l("null expression"));
      
      args.add(expr);
    }

    int code = exprFunctions.get(name);
    switch (code) {
    case Expr.TRUE: case Expr.FALSE: case Expr.NOT: case Expr.BOOLEAN:
    case Expr.STARTS_WITH: case Expr.CONTAINS: case Expr.LANG:
    case Expr.FUNCTION_AVAILABLE:
      return new BooleanExpr(code, args);

    case Expr.NUMBER: case Expr.FLOOR: case Expr.CEILING: case Expr.ROUND:
    case Expr.STRING_LENGTH:
      return new NumericExpr(code, args);

    case Expr.POSITION: 
    case Expr.LAST:
      return new NumericExpr(code, listParent);

    case Expr.COUNT: case Expr.SUM:
      if (args.size() == 0)
        args.add(NodeSetExpr.create(new FromContext()));
      return new NumericExpr(code, ((Expr) args.get(0)).toNodeList());


    case Expr.CONCAT: 
    case Expr.SUBSTRING_BEFORE:
    case Expr.SUBSTRING: case Expr.SUBSTRING_AFTER:
    case Expr.TRANSLATE: 
    case Expr.SYSTEM_PROPERTY:
      return new StringExpr(code, args);

    case Expr.STRING: case Expr.NORMALIZE:
      return new StringExpr(code, args);

    case Expr.LOCAL_PART: case Expr.NAMESPACE:
    case Expr.QNAME: case Expr.GENERATE_ID:
      if (args.size() == 0)
        args.add(NodeSetExpr.create(new FromContext()));
      return new StringExpr(code, args);

    case Expr.ID:
      if (args.size() == 0) {
        args.add(NodeSetExpr.create(parent));
        return new IdExpr(args);
      }
      else
        return new IdExpr(args);

    case Expr.IF:
      if (args.size() != 3)
        throw error(L.l("`if' needs three args."));

      return new ObjectExpr(code, args);

    case Expr.BASE_URI:
      if (args.size() != 1)
        throw error(L.l("`base-uri' needs one args."));

      return new StringExpr(code, args.get(0));

    case TEXT:
      if (fromChildren)
        parent = new FromChildren(parent);
      AbstractPattern pattern = NodeTypePattern.create(parent, Node.TEXT_NODE);
      return NodeSetExpr.create(pattern);

    case COMMENT:
      if (fromChildren)
        parent = new FromChildren(parent);
      pattern = NodeTypePattern.create(parent, Node.COMMENT_NODE);
      return NodeSetExpr.create(pattern);

    case ER:
      if (fromChildren)
        parent = new FromChildren(parent);
      pattern = NodeTypePattern.create(parent, Node.ENTITY_REFERENCE_NODE);
      return NodeSetExpr.create(pattern);

    case PI:
      if (fromChildren)
        parent = new FromChildren(parent);
      if (args.size() == 1) {
        Expr expr = (Expr) args.get(0);
        String value = null;
        if (expr instanceof StringExpr)
          value = ((StringExpr) expr).getValue();
        if (value == null)
          throw error(L.l("processing-instruction expects string literal"));
        pattern = new NodePattern(parent, value,
                                  Node.PROCESSING_INSTRUCTION_NODE);
      }
      else
        pattern = NodeTypePattern.create(parent, Node.PROCESSING_INSTRUCTION_NODE);
      return NodeSetExpr.create(pattern);

    case NODE:
      if (fromChildren)
        parent = new FromChildren(parent);
      pattern = NodeTypePattern.create(parent, NodeTypePattern.NODE);
      return NodeSetExpr.create(pattern);

    case CURRENT:
      return NodeSetExpr.create(new CurrentPattern());

    case CONTEXT:
      return NodeSetExpr.create(new FromContext());

    default:
      Expr function = constructorFunction(name, args);

      if (function != null)
        return function;
      
      int p = name.lastIndexOf(':');
      String prefix;
      
      if (p > 0)
        prefix = name.substring(0, p);
      else
        prefix = "";
      
      String context = NamespaceContext.find(_namespace, prefix);

      if (context == null) {
      }
      else if (context.startsWith("java:"))
        name = context + "." + name.substring(p + 1);
      else if (context.indexOf(':') < 0)
        name = "java:" + context + "." + name.substring(p + 1);
      
      if (name.startsWith("java:")) {
        p = name.lastIndexOf('.');
        if (p < 0)
          throw error(L.l("`{0}' is an illegal extension function.  Java extension functions must look like java:mypkg.MyClass.mymethod.", name));

        String className = name.substring(5, p);
        String methodName = name.substring(p + 1);

        Class cl;
        try {
          cl = CauchoSystem.loadClass(className);
        } catch (ClassNotFoundException e) {
          throw error(L.l("`{0}' is an unknown Java class.  Java extension functions must use public classes.", className));
        }

        if (methodName.equals("new")) {
          Constructor []constructors = cl.getConstructors();
          
          for (int i = 0; i < constructors.length; i++) {
            if (constructors[i].getParameterTypes().length == args.size())
              return new NewJavaExpr(constructors[i], args);
          }
            
          throw error(L.l("No matching public constructor in `{0}'",
                          className));
        }

        Method method = null;
        Method []methods = cl.getMethods();

        if (args.size() > 0) {
          for (int i = 0; i < methods.length; i++) {
            if (methods[i].getName().equals(methodName) &&
                methods[i].getParameterTypes().length == args.size() - 1 &&
                ! Modifier.isStatic(methods[i].getModifiers())) {
              Expr objArg = (Expr) args.remove(0);

              return new ObjectJavaExpr(methods[i], objArg, args);
            }
          }
        }

        for (int i = 0; i < methods.length; i++) {
          if (methods[i].getName().equals(methodName) &&
              methods[i].getParameterTypes().length == args.size()) {
            method = methods[i];
            break;
          }
        }

        if (method == null)
          throw error(L.l("`{0}' does not match a public method in `{1}'",
                          methodName, className));

        if (! Modifier.isStatic(method.getModifiers()))
          throw error(L.l("`{0}' is not a static method in `{1}'",
                          methodName, className));

        return new StaticJavaExpr(method, args);
      }
      else if (name.equals(""))
        throw error(L.l("expected node-test at `{0}'", "("));

      return new FunExpr(name, parent, args);
    }
  }

  private Expr constructorFunction(String name, ArrayList<Expr> args)
    throws XPathParseException
  {
    Constructor constructor = _exprFunctions.get(name);

    if (constructor == null)
      return null;
    
    Class []params = constructor.getParameterTypes();

    if (params.length < args.size())
      throw error(L.l("`{0}' needs {1} arguments",
                      name, "" + params.length));

    Object []values = new Object[params.length];
    
    for (int i = 0; i < args.size(); i++)
      values[i] = args.get(i);

    try {
      return (Expr) constructor.newInstance(values);
    } catch (Throwable e) {
      throw new XPathParseException(e);
    }
  }

  private Expr parseNodeSetExpr(AbstractPattern parent, String name, int nodeType)
    throws XPathParseException
  {
    AbstractPattern top = parseAxis(parent, name, true, nodeType);
    top = parseFilter(top);

    return NodeSetExpr.create(parseUnion(parsePath(top), parent));
  }

  /**
   * Scans the next token.
   *
   * @return token code, expressed as an Expr enumeration.
   */
  private int scanToken()
    throws XPathParseException
  {
    if (peek >= 0) {
      int value = peek;
      peek = -1;
      return value;
    }

    int ch = skipWhitespace(read());

    switch (ch) {
    case '+': return Expr.ADD;
    case '-': return Expr.SUB;
    case '*': return Expr.MUL;
    case '=': return Expr.EQ;

    case '!':
      ch = read();
      if (ch == '=')
        return Expr.NEQ;
      else
        throw error(L.l("expected `{0}' at {1}", "=", badChar(ch)));

    case '<':
      ch = read();
      if (ch == '=')
        return Expr.LE;
      else {
        unread();
        return Expr.LT;
      }

    case '>':
      ch = read();
      if (ch == '=')
        return Expr.GE;
      else {
        unread();
        return Expr.GT;
      }

    default:
      if (XmlChar.isNameStart(ch)) {
        String name = readName(ch);

        if (name.equals("div"))
          return Expr.DIV;
        else if (name.equals("quo"))
          return Expr.QUO;
        else if (name.equals("mod"))
          return Expr.MOD;
        else if (name.equals("and"))
          return Expr.AND;
        else if (name.equals("or"))
          return Expr.OR;
        else
          throw error(L.l("expected binary operation at `{0}'", name));
      }

      unread();
      return -1;
    }
  }

  private String readName(int ch)
  {
    tag.clear();
    for (; XmlChar.isNameChar(ch); ch = read())
      tag.append((char) ch);
    
    if (ch == '*' && tag.endsWith(":"))
      tag.append((char) ch);
    else
      unread();

    return tag.toString();
  }

  private void undoToken(int token)
  {
    peek = token;
  }

  private int read()
  {
    if (index < _string.length()) {
      return _string.charAt(index++);
    }
    else {
      index++;
      return -1;
    }
  }

  private void unread()
  {
    index--;
  }
  
  private XPathParseException error(String message)
  {
    return new XPathParseException(message + " in " + _string);
  }
  
  private String badChar(int ch)
  {
    if (ch < 0)
      return L.l("end of file");
    else if (ch == '\n')
      return L.l("end of line");
    else
      return "`" + (char) ch + "'";
  }

  private int skipWhitespace(int ch)
    throws XPathParseException
  {
    for (; ch == ' ' || ch == '\t' || ch == '\n' || ch == '\r'; ch = read()) {
    }

    return ch;
  }

  private static void addFunction(String name, Class cl)
  {
    Constructor []constructors = cl.getConstructors();
    
    _exprFunctions.put(name, constructors[0]);
  }

  static {
    exprFunctions = new IntMap();
    exprFunctions.put("id", Expr.ID);

    exprFunctions.put("true", Expr.TRUE);
    exprFunctions.put("false", Expr.FALSE);
    exprFunctions.put("not", Expr.NOT);
    exprFunctions.put("boolean", Expr.BOOLEAN);
    exprFunctions.put("starts-with", Expr.STARTS_WITH);
    exprFunctions.put("contains", Expr.CONTAINS);
    exprFunctions.put("lang", Expr.LANG);

    exprFunctions.put("number", Expr.NUMBER);
    exprFunctions.put("sum", Expr.SUM);
    exprFunctions.put("floor", Expr.FLOOR);
    exprFunctions.put("ceiling", Expr.CEILING);
    exprFunctions.put("round", Expr.ROUND);
    exprFunctions.put("position", Expr.POSITION);
    exprFunctions.put("count", Expr.COUNT);
    exprFunctions.put("last", Expr.LAST);
    exprFunctions.put("string-length", Expr.STRING_LENGTH);

    exprFunctions.put("string", Expr.STRING);
    exprFunctions.put("concat", Expr.CONCAT);
    exprFunctions.put("substring", Expr.SUBSTRING);
    exprFunctions.put("substring-before", Expr.SUBSTRING_BEFORE);
    exprFunctions.put("substring-after", Expr.SUBSTRING_AFTER);
    exprFunctions.put("normalize-space", Expr.NORMALIZE);
    exprFunctions.put("translate", Expr.TRANSLATE);

    exprFunctions.put("local-name", Expr.LOCAL_PART);
    exprFunctions.put("local-part", Expr.LOCAL_PART);
    exprFunctions.put("namespace-uri", Expr.NAMESPACE);
    exprFunctions.put("name", Expr.QNAME);
    exprFunctions.put("generate-id", Expr.GENERATE_ID);

    exprFunctions.put("if", Expr.IF);
    
    exprFunctions.put("text", TEXT);
    exprFunctions.put("comment", COMMENT);
    exprFunctions.put("er", ER);
    exprFunctions.put("entity-reference", ER);
    exprFunctions.put("pi", PI);
    exprFunctions.put("processing-instruction", PI);
    exprFunctions.put("node", NODE);
    exprFunctions.put("current", CURRENT);
    exprFunctions.put("context", CONTEXT);

    axisMap = new IntMap();
    axisMap.put("ancestor", ANCESTOR_AXIS);
    axisMap.put("ancestor-or-self", ANCESTOR_OR_SELF_AXIS);
    axisMap.put("attribute", ATTRIBUTE_AXIS);
    axisMap.put("child", CHILD_AXIS);
    axisMap.put("descendant", DESCENDANT_AXIS);
    axisMap.put("descendant-or-self", DESCENDANT_OR_SELF_AXIS);
    axisMap.put("following", FOLLOWING_AXIS);
    axisMap.put("following-sibling", FOLLOWING_SIBLING_AXIS);
    axisMap.put("namespace", NAMESPACE_AXIS);
    axisMap.put("parent", PARENT_AXIS);
    axisMap.put("preceding", PRECEDING_AXIS);
    axisMap.put("preceding-sibling", PRECEDING_SIBLING_AXIS);
    axisMap.put("self", SELF_AXIS);

    _exprFunctions = new HashMap<String,Constructor>();
    addFunction("fn:base-uri", BaseURI.class);
    addFunction("fn:resolve-uri", ResolveURI.class);
    addFunction("fn:trace", Trace.class);
  }
}
