Attachment 38596 Details for Bug 75102

[patch] To be super-reviewed (diff -u -w -N)

Macintosh HD:parserfinal-w.patch (text/plain), 149.92 KB, created by Peter Van der Beken [:peterv]

(hide)

Description:

Filename:

MIME Type:

Creator: Peter Van der Beken [:peterv]

Size: 149.92 KB

patch

obsolete

>Index: build/Makefile.in
>===================================================================
>RCS file: /cvsroot/mozilla/extensions/transformiix/build/Makefile.in,v
>retrieving revision 1.18
>diff -w -u -3 -r1.18 Makefile.in
>--- Makefile.in	2001/05/22 07:52:27	1.18
>+++ Makefile.in	2001/06/15 10:34:29
>@@ -77,12 +77,13 @@
>   ../source/xpath/BooleanResult.o \
>   ../source/xpath/ElementExpr.o \
>   ../source/xpath/ErrorFunctionCall.o \
>+  ../source/xpath/Expr.o \
>   ../source/xpath/ExprLexer.o \
>+  ../source/xpath/ExprLexerChars.o \
>   ../source/xpath/ExprParser.o \
>   ../source/xpath/ExtensionFunctionCall.o \
>   ../source/xpath/FilterExpr.o \
>   ../source/xpath/FunctionCall.o \
>-  ../source/xpath/IdentityExpr.o \
>   ../source/xpath/LocationStep.o \
>   ../source/xpath/MultiplicativeExpr.o \
>   ../source/xpath/NodeSet.o \
>@@ -91,7 +92,6 @@
>   ../source/xpath/NumberExpr.o \
>   ../source/xpath/NumberFunctionCall.o \
>   ../source/xpath/NumberResult.o \
>-  ../source/xpath/ParentExpr.o \
>   ../source/xpath/PathExpr.o \
>   ../source/xpath/PredicateList.o \
>   ../source/xpath/RelationalExpr.o \
>@@ -101,6 +101,7 @@
>   ../source/xpath/StringResult.o \
>   ../source/xpath/TextExpr.o \
>   ../source/xpath/UnionExpr.o \
>+  ../source/xpath/UnaryExpr.o \
>   ../source/xpath/VariableRefExpr.o \
>   ../source/xpath/XPathNames.o \
>   ../source/xpath/XPathProcessor.o \
>Index: build/makefile.win
>===================================================================
>RCS file: /cvsroot/mozilla/extensions/transformiix/build/makefile.win,v
>retrieving revision 1.18
>diff -w -u -3 -r1.18 makefile.win
>--- makefile.win	2001/06/10 16:41:57	1.18
>+++ makefile.win	2001/06/15 10:34:29
>@@ -72,12 +72,13 @@
> 	..\source\xpath\$(OBJDIR)\BooleanResult.obj \
> 	..\source\xpath\$(OBJDIR)\ElementExpr.obj \
> 	..\source\xpath\$(OBJDIR)\ErrorFunctionCall.obj \
>+	..\source\xpath\$(OBJDIR)\Expr.obj \
> 	..\source\xpath\$(OBJDIR)\ExprLexer.obj \
>+	..\source\xpath\$(OBJDIR)\ExprLexerChars.obj \
> 	..\source\xpath\$(OBJDIR)\ExprParser.obj \
> 	..\source\xpath\$(OBJDIR)\ExtensionFunctionCall.obj \
> 	..\source\xpath\$(OBJDIR)\FilterExpr.obj \
> 	..\source\xpath\$(OBJDIR)\FunctionCall.obj \
>-	..\source\xpath\$(OBJDIR)\IdentityExpr.obj \
> 	..\source\xpath\$(OBJDIR)\LocationStep.obj \
> 	..\source\xpath\$(OBJDIR)\MultiplicativeExpr.obj \
> 	..\source\xpath\$(OBJDIR)\NodeSet.obj \
>@@ -86,7 +87,6 @@
> 	..\source\xpath\$(OBJDIR)\NumberExpr.obj \
> 	..\source\xpath\$(OBJDIR)\NumberFunctionCall.obj \
> 	..\source\xpath\$(OBJDIR)\NumberResult.obj \
>-	..\source\xpath\$(OBJDIR)\ParentExpr.obj \
> 	..\source\xpath\$(OBJDIR)\PathExpr.obj \
> 	..\source\xpath\$(OBJDIR)\PredicateList.obj \
> 	..\source\xpath\$(OBJDIR)\RelationalExpr.obj \
>@@ -96,6 +96,7 @@
> 	..\source\xpath\$(OBJDIR)\StringResult.obj \
> 	..\source\xpath\$(OBJDIR)\TextExpr.obj \
> 	..\source\xpath\$(OBJDIR)\UnionExpr.obj \
>+	..\source\xpath\$(OBJDIR)\UnaryExpr.obj \
> 	..\source\xpath\$(OBJDIR)\VariableRefExpr.obj \
> 	..\source\xpath\$(OBJDIR)\XPathNames.obj \
> 	..\source\xpath\$(OBJDIR)\XPathProcessor.obj \
>Index: source/main/Makefile.in
>===================================================================
>RCS file: /cvsroot/mozilla/extensions/transformiix/source/main/Makefile.in,v
>retrieving revision 1.8
>diff -w -u -3 -r1.8 Makefile.in
>--- Makefile.in	2001/04/08 14:35:10	1.8
>+++ Makefile.in	2001/06/15 10:34:29
>@@ -70,12 +70,13 @@
>   ../xpath/BooleanResult.o \
>   ../xpath/ElementExpr.o \
>   ../xpath/ErrorFunctionCall.o \
>+  ../xpath/Expr.o \
>   ../xpath/ExprLexer.o \
>+  ../xpath/ExprLexerChars.o \
>   ../xpath/ExprParser.o \
>   ../xpath/ExtensionFunctionCall.o \
>   ../xpath/FilterExpr.o \
>   ../xpath/FunctionCall.o \
>-  ../xpath/IdentityExpr.o \
>   ../xpath/LocationStep.o \
>   ../xpath/MultiplicativeExpr.o \
>   ../xpath/NodeSet.o \
>@@ -83,7 +84,6 @@
>   ../xpath/NumberExpr.o \
>   ../xpath/NumberFunctionCall.o \
>   ../xpath/NumberResult.o \
>-  ../xpath/ParentExpr.o \
>   ../xpath/PathExpr.o \
>   ../xpath/PredicateList.o \
>   ../xpath/RelationalExpr.o \
>@@ -93,6 +93,7 @@
>   ../xpath/StringResult.o \
>   ../xpath/TextExpr.o \
>   ../xpath/UnionExpr.o \
>+  ../xpath/UnaryExpr.o \
>   ../xpath/VariableRefExpr.o \
>   ../xpath/XPathNames.o \
>   ../xml/XMLUtils.o \
>Index: source/main/makefile.win
>===================================================================
>RCS file: /cvsroot/mozilla/extensions/transformiix/source/main/makefile.win,v
>retrieving revision 1.6
>diff -w -u -3 -r1.6 makefile.win
>--- makefile.win	2001/05/11 10:13:12	1.6
>+++ makefile.win	2001/06/15 10:34:29
>@@ -68,12 +68,13 @@
>   ../xpath/$(OBJDIR)/BooleanResult.obj \
>   ../xpath/$(OBJDIR)/ElementExpr.obj \
>   ../xpath/$(OBJDIR)/ErrorFunctionCall.obj \
>+  ../xpath/$(OBJDIR)/Expr.obj \
>   ../xpath/$(OBJDIR)/ExprLexer.obj \
>+  ../xpath/$(OBJDIR)/ExprLexerChars.obj \
>   ../xpath/$(OBJDIR)/ExprParser.obj \
>   ../xpath/$(OBJDIR)/ExtensionFunctionCall.obj \
>   ../xpath/$(OBJDIR)/FilterExpr.obj \
>   ../xpath/$(OBJDIR)/FunctionCall.obj \
>-  ../xpath/$(OBJDIR)/IdentityExpr.obj \
>   ../xpath/$(OBJDIR)/LocationStep.obj \
>   ../xpath/$(OBJDIR)/MultiplicativeExpr.obj \
>   ../xpath/$(OBJDIR)/NodeSet.obj \
>@@ -81,7 +82,6 @@
>   ../xpath/$(OBJDIR)/NumberExpr.obj \
>   ../xpath/$(OBJDIR)/NumberFunctionCall.obj \
>   ../xpath/$(OBJDIR)/NumberResult.obj \
>-  ../xpath/$(OBJDIR)/ParentExpr.obj \
>   ../xpath/$(OBJDIR)/PathExpr.obj \
>   ../xpath/$(OBJDIR)/PredicateList.obj \
>   ../xpath/$(OBJDIR)/RelationalExpr.obj \
>@@ -91,6 +91,7 @@
>   ../xpath/$(OBJDIR)/StringResult.obj \
>   ../xpath/$(OBJDIR)/TextExpr.obj \
>   ../xpath/$(OBJDIR)/UnionExpr.obj \
>+  ../xpath/$(OBJDIR)/UnaryExpr.obj \
>   ../xpath/$(OBJDIR)/VariableRefExpr.obj \
>   ../xpath/$(OBJDIR)/XPathNames.obj \
>   ../xml/$(OBJDIR)/XMLUtils.obj \
>Index: source/xpath/BasicNodeExpr.cpp
>===================================================================
>RCS file: /cvsroot/mozilla/extensions/transformiix/source/xpath/BasicNodeExpr.cpp,v
>retrieving revision 1.4
>diff -w -u -3 -r1.4 BasicNodeExpr.cpp
>--- BasicNodeExpr.cpp	2001/05/14 14:22:46	1.4
>+++ BasicNodeExpr.cpp	2001/06/15 10:34:30
>@@ -38,6 +38,7 @@
> **/
> BasicNodeExpr::BasicNodeExpr() {
>     this->type = NodeExpr::NODE_EXPR;
>+    nodeNameSet = MB_FALSE;
> } //-- BasicNodeExpr
> 
> /**
>@@ -45,6 +46,7 @@
> **/
> BasicNodeExpr::BasicNodeExpr(NodeExpr::NodeExprType nodeExprType) {
>     this->type = nodeExprType;
>+    nodeNameSet = MB_FALSE;
> } //-- BasicNodeExpr
> 
> /**
>@@ -56,6 +58,15 @@
>  //- Public Methods -/
> //------------------/
> 
>+void BasicNodeExpr::setNodeName(const String& name) {
>+    this->nodeName = name;
>+    nodeNameSet = MB_TRUE;
>+}
>+
>+  //-----------------------------/
>+ //- Methods from NodeExpr.cpp -/
>+//-----------------------------/
>+
> /**
>  * Evaluates this Expr based on the given context node and processor state
>  * @param context the context node for evaluation of this Expr
>@@ -75,17 +86,12 @@
>     return nodeSet;
> } //-- evaluate
> 
>-  //-----------------------------/
>- //- Methods from NodeExpr.cpp -/
>-//-----------------------------/
>-
> /**
>- * Returns the default priority of this Pattern based on the given Node,
>+ * Returns the default priority of this Expr based on the given Node,
>  * context Node, and ContextState.
>- * If this pattern does not match the given Node under the current context Node and
>- * ContextState then Negative Infinity is returned.
> **/
> double BasicNodeExpr::getDefaultPriority(Node* node, Node* context, ContextState* cs) {
>+    if (nodeNameSet) return 0;
>     return -0.5;
> } //-- getDefaultPriority
> 
>@@ -107,7 +113,8 @@
>         case NodeExpr::COMMENT_EXPR:
>             return (MBool) (node->getNodeType() == Node::COMMENT_NODE);
>         case NodeExpr::PI_EXPR :
>-            return (MBool) (node->getNodeType() == Node::PROCESSING_INSTRUCTION_NODE);
>+            return (MBool) (node->getNodeType() == Node::PROCESSING_INSTRUCTION_NODE &&
>+                            !nodeNameSet || nodeName.isEqual(node->getNodeName()));
>         default: //-- node()
>             if(node->getNodeType() == Node::TEXT_NODE)
>                 return !cs->isStripSpaceAllowed(node);
>@@ -133,7 +140,13 @@
>             dest.append("comment()");
>             break;
>         case NodeExpr::PI_EXPR :
>-            dest.append("processing-instruction()");
>+            dest.append("processing-instruction(");
>+            if (nodeNameSet) {
>+                dest.append('\'');
>+                dest.append(nodeName);
>+                dest.append('\'');
>+            }
>+            dest.append(')');
>             break;
>         default: //-- node()
>             dest.append("node()");
>Index: source/xpath/Expr.cpp
>===================================================================
>RCS file: Expr.cpp
>diff -N Expr.cpp
>--- /dev/null	Wed Apr 26 15:53:02 2000
>+++ Expr.cpp	Fri Jun 15 03:34:30 2001
>@@ -0,0 +1,48 @@
>+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
>+ * The contents of this file are subject to the Mozilla Public
>+ * License Version 1.1 (the "License"); you may not use this file
>+ * except in compliance with the License. You may obtain a copy of
>+ * the License at http://www.mozilla.org/MPL/
>+ *
>+ * Software distributed under the License is distributed on an "AS
>+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
>+ * implied. See the License for the specific language governing
>+ * rights and limitations under the License.
>+ *
>+ * The Initial Developer of the Original Code is Jonas Sicking.
>+ * Portions created by Jonas Sicking are Copyright (C) 2001, Jonas Sicking.
>+ * All rights reserved.
>+ *
>+ * Contributor(s):
>+ * Jonas Sicking, sicking@bigfoot.com
>+ *   -- original author.
>+ */
>+ 
>+#include "Expr.h"
>+
>+Expr::~Expr() {
>+} //-- ~Expr
>+
>+/**
>+ * Determines whether this Expr matches the given node within
>+ * the given context
>+**/
>+MBool Expr::matches(Node* node, Node* context, ContextState* cs)
>+{
>+    #ifndef TX_EXE
>+    NS_ASSERTION(0,"Expr::matches() called");
>+    #endif
>+    return MB_FALSE;
>+} //-- matches
>+
>+/**
>+ * Returns the default priority of this Expr based on the given Node,
>+ * context Node, and ContextState.
>+**/
>+double Expr::getDefaultPriority(Node* node, Node* context, ContextState* cs)
>+{
>+    #ifndef TX_EXE
>+    NS_ASSERTION(0,"Expr::matches() called");
>+    #endif
>+    return 0;
>+} //-- getDefaultPriority
>Index: source/xpath/Expr.h
>===================================================================
>RCS file: /cvsroot/mozilla/extensions/transformiix/source/xpath/Expr.h,v
>retrieving revision 1.13
>diff -w -u -3 -r1.13 Expr.h
>--- Expr.h	2001/05/12 09:54:15	1.13
>+++ Expr.h	2001/06/15 10:34:30
>@@ -24,6 +24,9 @@
>  *   -- 19990806
>  *     - changed constant short declarations in many of the classes
>  *       with enumerations, commented with //--LF
>+ * Jonas Sicking, sicking@bigfoot.com
>+ *   -- removal of Patterns and some restructuring
>+ *      in the class set
>  *
>  * $Id: Expr.h,v 1.13 2001/05/12 09:54:15 nisheeth%netscape.com Exp $
>  */
>@@ -52,6 +55,10 @@
> //necessary prototypes
> class FunctionCall;
> 
>+typedef class Expr Pattern;
>+typedef class Expr PatternExpr;
>+
>+
> /**
>  * The expression context and state class used when evaluating XPath Expressions.
> **/
>@@ -115,7 +122,7 @@
>     /**
>      * Virtual destructor, important for subclasses
>     **/
>-    virtual ~Expr() {};
>+    virtual ~Expr();
> 
>     /**
>      * Evaluates this Expr based on the given context node and processor state
>@@ -127,6 +134,18 @@
>     virtual ExprResult* evaluate(Node* context, ContextState* cs) = 0;
> 
>     /**
>+     * Determines whether this Expr matches the given node within
>+     * the given context
>+    **/
>+    virtual MBool matches(Node* node, Node* context, ContextState* cs);
>+
>+    /**
>+     * Returns the default priority of this Expr based on the given Node,
>+     * context Node, and ContextState.
>+    **/
>+    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs);
>+
>+    /**
>      * Returns the String representation of this Expr.
>      * @param dest the String to use when creating the String
>      * representation. The String representation will be appended to
>@@ -138,7 +157,6 @@
> 
> }; //-- Expr
> 
>-
> /**
>  * This class represents a FunctionCall as defined by the XPath 1.0
>  * Recommendation.
>@@ -149,23 +167,21 @@
> 
>     static const String INVALID_PARAM_COUNT;
> 
>-
>     virtual ~FunctionCall();
> 
>     /**
>-     * Adds the given parameter to this FunctionCall's parameter list
>-     * @param expr the Expr to add to this FunctionCall's parameter list
>+     * Virtual methods from Expr 
>     **/
>-    void addParam(Expr* expr);
>+    virtual ExprResult* evaluate(Node* context, ContextState* cs) = 0;
>+    virtual MBool matches(Node* node, Node* context, ContextState* cs);
>+    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs);
>+    virtual void toString(String& dest);
> 
>     /**
>-     * Evaluates this Expr based on the given context node and processor state
>-     * @param context the context node for evaluation of this Expr
>-     * @param ps the ContextState containing the stack information needed
>-     * for evaluation
>-     * @return the result of the evaluation
>+     * Adds the given parameter to this FunctionCall's parameter list
>+     * @param expr the Expr to add to this FunctionCall's parameter list
>     **/
>-    virtual ExprResult* evaluate(Node* context, ContextState* cs) = 0;
>+    void addParam(Expr* expr);
> 
>     /**
>      * Returns the name of this FunctionCall
>@@ -184,15 +200,6 @@
>      * @param name the name of this Function
>     **/
>     void setName(const String& name);
>-    /**
>-     * Returns the String representation of this Pattern.
>-     * @param dest the String to use when creating the String
>-     * representation. The String representation will be appended to
>-     * any data in the destination String, to allow cascading calls to
>-     * other #toString() methods for Expressions.
>-     * @return the String representation of this Pattern.
>-    **/
>-    virtual void toString(String& dest);
> 
> 
> protected:
>@@ -221,97 +228,8 @@
>     String name;
> }; //-- FunctionCall
> 
>-/**
>- * A base Pattern class
>-**/
>-class Pattern {
>-
>-public:
>-
>-    /**
>-     * Virtual destructor, important for subclasses
>-    **/
>-    virtual ~Pattern() {};
>-
>-    /**
>-     * Returns the default priority of this Pattern based on the given Node,
>-     * context Node, and ContextState.
>-     * If this pattern does not match the given Node under the current context Node and
>-     * ContextState then Negative Infinity is returned.
>-    **/
>-    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs) = 0;
>-
>-    /**
>-     * Determines whether this Pattern matches the given node within
>-     * the given context
>-    **/
>-    virtual MBool matches(Node* node, Node* context, ContextState* cs) = 0;
>-
>-
>-    /**
>-     * Returns the String representation of this Pattern.
>-     * @param dest the String to use when creating the String
>-     * representation. The String representation will be appended to
>-     * any data in the destination String, to allow cascading calls to
>-     * other #toString() methods for Expressions.
>-     * @return the String representation of this Pattern.
>-    **/
>-    virtual void toString(String& dest) = 0;
>-
>-}; //-- Pattern
>-
>-
>-/**
>- * A Base class for all Expressions and Patterns
>-**/
>-class PatternExpr :
>-    public Expr,
>-    public Pattern
>-{
>-
>-public:
>-
>-    /**
>-     * Virtual destructor, important for subclasses
>-    **/
>-    virtual ~PatternExpr() {};
> 
>     /**
>-     * Evaluates this Expr based on the given context node and processor state
>-     * @param context the context node for evaluation of this Expr
>-     * @param ps the ContextState containing the stack information needed
>-     * for evaluation
>-     * @return the result of the evaluation
>-    **/
>-    virtual ExprResult* evaluate(Node* context, ContextState* cs) = 0;
>-
>-    /**
>-     * Returns the default priority of this Pattern based on the given Node,
>-     * context Node, and ContextState.
>-     * If this pattern does not match the given Node under the current context Node and
>-     * ContextState then Negative Infinity is returned.
>-    **/
>-    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs) = 0;
>-
>-    /**
>-     * Determines whether this PatternExpr matches the given node within
>-     * the given context
>-    **/
>-    virtual MBool matches(Node* node, Node* context, ContextState* cs) = 0;
>-
>-    /**
>-     * Returns the String representation of this PatternExpr.
>-     * @param dest the String to use when creating the String
>-     * representation. The String representation will be appended to
>-     * any data in the destination String, to allow cascading calls to
>-     * other #toString() methods for Expressions.
>-     * @return the String representation of this PatternExpr.
>-    **/
>-    virtual void toString(String& dest) = 0;
>-
>-}; //-- PatternExpr
>-
>-/**
>  * Represents an AttributeValueTemplate
> **/
> class AttributeValueTemplate: public Expr {
>@@ -328,22 +246,9 @@
>     void addExpr(Expr* expr);
> 
>     /**
>-     * Evaluates this Expr based on the given context node and processor state
>-     * @param context the context node for evaluation of this Expr
>-     * @param ps the ContextState containing the stack information needed
>-     * for evaluation
>-     * @return the result of the evaluation
>+     * Virtual methods from Expr 
>     **/
>     virtual ExprResult* evaluate(Node* context, ContextState* cs);
>-
>-    /**
>-     * Returns the String representation of this Expr.
>-     * @param dest the String to use when creating the String
>-     * representation. The String representation will be appended to
>-     * any data in the destination String, to allow cascading calls to
>-     * other #toString() methods for Expressions.
>-     * @return the String representation of this Expr.
>-    **/
>     virtual void toString(String& str);
> 
> private:
>@@ -355,7 +260,7 @@
>  * This class represents a NodeTestExpr as defined by the XSL
>  * Working Draft
> **/
>-class NodeExpr : public PatternExpr {
>+class NodeExpr : public Expr {
> 
> public:
> 
>@@ -379,33 +284,16 @@
>     //------------------/
> 
>     /**
>-     * Returns the default priority of this Pattern based on the given Node,
>-     * context Node, and ContextState.
>-     * If this pattern does not match the given Node under the current context Node and
>-     * ContextState then Negative Infinity is returned.
>-    **/
>-    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs) = 0;
>-
>-    /**
>      * Returns the type of this NodeExpr
>      * @return the type of this NodeExpr
>     **/
>     virtual short getType() = 0;
> 
>     /**
>-     * Determines whether this NodeExpr matches the given node within
>-     * the given context
>+     * Virtual methods from Expr 
>     **/
>     virtual MBool matches(Node* node, Node* context, ContextState* cs) = 0;
>-
>-    /**
>-     * Returns the String representation of this Pattern.
>-     * @param dest the String to use when creating the String
>-     * representation. The String representation will be appended to
>-     * any data in the destination String, to allow cascading calls to
>-     * other #toString() methods for Expressions.
>-     * @return the String representation of this Pattern.
>-    **/
>+    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs) = 0;
>     virtual void toString(String& dest) = 0;
> 
> }; //-- NodeExpr
>@@ -440,47 +328,13 @@
>     **/
>     void setName(const String& name);
> 
>-    //-----------------------------------/
>-   //- Method signatures from NodeExpr -/
>-  //-----------------------------------/
>-
>     /**
>-     * Returns the default priority of this Pattern based on the given Node,
>-     * context Node, and ContextState.
>-     * If this pattern does not match the given Node under the current context Node and
>-     * ContextState then Negative Infinity is returned.
>-    **/
>-    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs);
>-
>-    /**
>-     * Evaluates this Expr based on the given context node and processor state
>-     * @param context the context node for evaluation of this Expr
>-     * @param ps the ContextState containing the stack information needed
>-     * for evaluation
>-     * @return the result of the evaluation
>+     * Virtual methods from NodeExpr 
>     **/
>     virtual ExprResult* evaluate(Node* context, ContextState* cs);
>-
>-    /**
>-     * Returns the type of this NodeExpr
>-     * @return the type of this NodeExpr
>-    **/
>     short getType();
>-
>-    /**
>-     * Determines whether this NodeExpr matches the given node within
>-     * the given context
>-    **/
>     virtual MBool matches(Node* node, Node* context, ContextState* cs);
>-
>-    /**
>-     * Returns the String representation of this NodeExpr.
>-     * @param dest the String to use when creating the String
>-     * representation. The String representation will be appended to
>-     * any data in the destination String, to allow cascading calls to
>-     * other #toString() methods for Expressions.
>-     * @return the String representation of this NodeExpr.
>-    **/
>+    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs);
>     virtual void toString(String& dest);
> 
> private:
>@@ -522,51 +376,24 @@
>     **/
>     virtual ~BasicNodeExpr();
> 
>-    //-----------------------------------/
>-   //- Method signatures from NodeExpr -/
>-  //-----------------------------------/
>-
>     /**
>-     * Returns the default priority of this Pattern based on the given Node,
>-     * context Node, and ContextState.
>-     * If this pattern does not match the given Node under the current context Node and
>-     * ContextState then Negative Infinity is returned.
>+     * Sets the name of the node to match. Only availible for pi nodes
>     **/
>-    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs);
>+    void setNodeName(const String& name);
> 
>     /**
>-     * Evaluates this Expr based on the given context node and processor state
>-     * @param context the context node for evaluation of this Expr
>-     * @param ps the ContextState containing the stack information needed
>-     * for evaluation
>-     * @return the result of the evaluation
>+     * Virtual methods from NodeExpr 
>     **/
>     virtual ExprResult* evaluate(Node* context, ContextState* cs);
>-
>-    /**
>-     * Returns the type of this NodeExpr
>-     * @return the type of this NodeExpr
>-    **/
>     short getType();
>-
>-    /**
>-     * Determines whether this NodeExpr matches the given node within
>-     * the given context
>-    **/
>     virtual MBool matches(Node* node, Node* context, ContextState* cs);
>-
>-    /**
>-     * Returns the String representation of this NodeExpr.
>-     * @param dest the String to use when creating the String
>-     * representation. The String representation will be appended to
>-     * any data in the destination String, to allow cascading calls to
>-     * other #toString() methods for Expressions.
>-     * @return the String representation of this NodeExpr.
>-    **/
>+    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs);
>     virtual void toString(String& dest);
> 
> private:
>     NodeExprType type;
>+    String nodeName;
>+    MBool nodeNameSet;
> }; //-- BasicNodeExpr
> 
> /**
>@@ -597,47 +424,13 @@
>     **/
>     void setName(const String& name);
> 
>-    //-----------------------------------/
>-   //- Method signatures from NodeExpr -/
>-  //-----------------------------------/
>-
>     /**
>-     * Evaluates this Expr based on the given context node and processor state
>-     * @param context the context node for evaluation of this Expr
>-     * @param ps the ContextState containing the stack information needed
>-     * for evaluation
>-     * @return the result of the evaluation
>+     * Virtual methods from NodeExpr 
>     **/
>     virtual ExprResult* evaluate(Node* context, ContextState* cs);
>-
>-    /**
>-     * Returns the default priority of this Pattern based on the given Node,
>-     * context Node, and ContextState.
>-     * If this pattern does not match the given Node under the current context Node and
>-     * ContextState then Negative Infinity is returned.
>-    **/
>-    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs);
>-
>-    /**
>-     * Returns the type of this NodeExpr
>-     * @return the type of this NodeExpr
>-    **/
>     short getType();
>-
>-    /**
>-     * Determines whether this NodeExpr matches the given node within
>-     * the given context
>-    **/
>+    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs);
>     virtual MBool matches(Node* node, Node* context, ContextState* cs);
>-
>-    /**
>-     * Returns the String representation of this NodeExpr.
>-     * @param dest the String to use when creating the String
>-     * representation. The String representation will be appended to
>-     * any data in the destination String, to allow cascading calls to
>-     * other #toString() methods for Expressions.
>-     * @return the String representation of this NodeExpr.
>-    **/
>     virtual void toString(String& dest);
> 
> private:
>@@ -655,121 +448,23 @@
> }; //-- ElementExpr
> 
> /**
>- * This class represents a IdentityExpr, which only matches a node
>- * if it is equal to the context node
>-**/
>-class IdentityExpr : public Expr {
>-
>-public:
>-
>-      //------------------/
>-     //- Public Methods -/
>-    //------------------/
>-
>-    /**
>-     * Evaluates this Expr based on the given context node and processor state
>-     * @param context the context node for evaluation of this Expr
>-     * @param ps the ContextState containing the stack information needed
>-     * for evaluation
>-     * @return the result of the evaluation
>-    **/
>-    virtual ExprResult* evaluate(Node* context, ContextState* cs);
>-
>-    /**
>-     * Returns the String representation of this NodeExpr.
>-     * @param dest the String to use when creating the String
>-     * representation. The String representation will be appended to
>-     * any data in the destination String, to allow cascading calls to
>-     * other #toString() methods for Expressions.
>-     * @return the String representation of this NodeExpr.
>-    **/
>-    virtual void toString(String& dest);
>-
>-}; //-- IdentityExpr
>-
>-/**
>- * This class represents a ParentExpr, which only selects a node
>- * if it is equal to the context node's parent
>-**/
>-class ParentExpr : public Expr {
>-
>-public:
>-
>-      //------------------/
>-     //- Public Methods -/
>-    //------------------/
>-
>-    /**
>-     * Evaluates this Expr based on the given context node and processor state
>-     * @param context the context node for evaluation of this Expr
>-     * @param ps the ContextState containing the stack information needed
>-     * for evaluation
>-     * @return the result of the evaluation
>-    **/
>-    virtual ExprResult* evaluate(Node* context, ContextState* cs);
>-
>-
>-    /**
>-     * Returns the String representation of this NodeExpr.
>-     * @param dest the String to use when creating the String
>-     * representation. The String representation will be appended to
>-     * any data in the destination String, to allow cascading calls to
>-     * other #toString() methods for Expressions.
>-     * @return the String representation of this NodeExpr.
>-    **/
>-    virtual void toString(String& dest);
>-
>-}; //-- ParentExpr
>-
>-/**
>  * This class represents a TextExpr, which only matches any text node
> **/
> class TextExpr : public NodeExpr {
>-
>-public:
>-
>-      //------------------/
>-     //- Public Methods -/
>-    //------------------/
>-
>-    /**
>-     * Evaluates this Expr based on the given context node and processor state
>-     * @param context the context node for evaluation of this Expr
>-     * @param ps the ContextState containing the stack information needed
>-     * for evaluation
>-     * @return the result of the evaluation
>-    **/
>-    virtual ExprResult* evaluate(Node* context, ContextState* cs);
>-
>-    /**
>-     * Returns the default priority of this Pattern based on the given Node,
>-     * context Node, and ContextState.
>-     * If this pattern does not match the given Node under the current context Node and
>-     * ContextState then Negative Infinity is returned.
>-    **/
>-    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs);
>-
>-    /**
>-     * Returns the type of this NodeExpr
>-     * @return the type of this NodeExpr
>-    **/
>-    virtual short getType();
>-
>-    /**
>-     * Determines whether this NodeExpr matches the given node within
>-     * the given context
>-    **/
>-    virtual MBool matches(Node* node, Node* context, ContextState* cs);
> 
>+public:
>+
>+      //------------------/
>+     //- Public Methods -/
>+    //------------------/
> 
>     /**
>-     * Returns the String representation of this NodeExpr.
>-     * @param dest the String to use when creating the String
>-     * representation. The String representation will be appended to
>-     * any data in the destination String, to allow cascading calls to
>-     * other #toString() methods for Expressions.
>-     * @return the String representation of this NodeExpr.
>+     * Virtual methods from NodeExpr 
>     **/
>+    virtual ExprResult* evaluate(Node* context, ContextState* cs);
>+    virtual short getType();
>+    virtual MBool matches(Node* node, Node* context, ContextState* cs);
>+    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs);
>     virtual void toString(String& dest);
> 
> }; //-- TextExpr
>@@ -827,7 +522,7 @@
>     List predicates;
> }; //-- PredicateList
> 
>-class LocationStep : public PredicateList, public PatternExpr {
>+class LocationStep : public PredicateList, public Expr {
> 
> public:
> 
>@@ -887,41 +582,12 @@
>     **/
>     void setNodeExpr(NodeExpr* nodeExpr);
> 
>-      //------------------------------------/
>-     //- Virtual methods from PatternExpr -/
>-    //------------------------------------/
>-
>     /**
>-     * Evaluates this Expr based on the given context node and processor state
>-     * @param context the context node for evaluation of this Expr
>-     * @param ps the ContextState containing the stack information needed
>-     * for evaluation
>-     * @return the result of the evaluation
>+     * Virtual methods from Expr 
>     **/
>     virtual ExprResult* evaluate(Node* context, ContextState* cs);
>-
>-    /**
>-     * Returns the default priority of this Pattern based on the given Node,
>-     * context Node, and ContextState.
>-     * If this pattern does not match the given Node under the current context Node and
>-     * ContextState then Negative Infinity is returned.
>-    **/
>-    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs);
>-
>-    /**
>-     * Determines whether this PatternExpr matches the given node within
>-     * the given context
>-    **/
>     virtual MBool matches(Node* node, Node* context, ContextState* cs);
>-
>-    /**
>-     * Returns the String representation of this PatternExpr.
>-     * @param dest the String to use when creating the String
>-     * representation. The String representation will be appended to
>-     * any data in the destination String, to allow cascading calls to
>-     * other #toString() methods for Expressions.
>-     * @return the String representation of this PatternExpr.
>-    **/
>+    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs);
>     virtual void toString(String& dest);
> 
> private:
>@@ -935,7 +601,7 @@
> }; //-- LocationStep
> 
> 
>-class FilterExpr : public PredicateList, public PatternExpr {
>+class FilterExpr : public PredicateList, public Expr {
> 
> public:
> 
>@@ -962,41 +628,12 @@
>     **/
>     void setExpr(Expr* expr);
> 
>-      //------------------------------------/
>-     //- Virtual methods from PatternExpr -/
>-    //------------------------------------/
>-
>     /**
>-     * Evaluates this Expr based on the given context node and processor state
>-     * @param context the context node for evaluation of this Expr
>-     * @param ps the ContextState containing the stack information needed
>-     * for evaluation
>-     * @return the result of the evaluation
>+     * Virtual methods from Expr 
>     **/
>     virtual ExprResult* evaluate(Node* context, ContextState* cs);
>-
>-    /**
>-     * Returns the default priority of this Pattern based on the given Node,
>-     * context Node, and ContextState.
>-     * If this pattern does not match the given Node under the current context Node and
>-     * ContextState then Negative Infinity is returned.
>-    **/
>-    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs);
>-
>-    /**
>-     * Determines whether this PatternExpr matches the given node within
>-     * the given context
>-    **/
>     virtual MBool matches(Node* node, Node* context, ContextState* cs);
>-
>-    /**
>-     * Returns the String representation of this PatternExpr.
>-     * @param dest the String to use when creating the String
>-     * representation. The String representation will be appended to
>-     * any data in the destination String, to allow cascading calls to
>-     * other #toString() methods for Expressions.
>-     * @return the String representation of this PatternExpr.
>-    **/
>+    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs);
>     virtual void toString(String& dest);
> 
> private:
>@@ -1015,22 +652,9 @@
>     ~NumberExpr();
> 
>     /**
>-     * Evaluates this Expr based on the given context node and processor state
>-     * @param context the context node for evaluation of this Expr
>-     * @param ps the ContextState containing the stack information needed
>-     * for evaluation
>-     * @return the result of the evaluation
>+     * Virtual methods from Expr 
>     **/
>     virtual ExprResult* evaluate(Node* context, ContextState* cs);
>-
>-    /**
>-     * Returns the String representation of this Expr.
>-     * @param dest the String to use when creating the String
>-     * representation. The String representation will be appended to
>-     * any data in the destination String, to allow cascading calls to
>-     * other #toString() methods for Expressions.
>-     * @return the String representation of this Expr.
>-    **/
>     virtual void toString(String& str);
> 
> private:
>@@ -1052,22 +676,9 @@
>     ~StringExpr();
> 
>     /**
>-     * Evaluates this Expr based on the given context node and processor state
>-     * @param context the context node for evaluation of this Expr
>-     * @param ps the ContextState containing the stack information needed
>-     * for evaluation
>-     * @return the result of the evaluation
>+     * Virtual methods from Expr 
>     **/
>     virtual ExprResult* evaluate(Node* context, ContextState* cs);
>-
>-    /**
>-     * Returns the String representation of this Expr.
>-     * @param dest the String to use when creating the String
>-     * representation. The String representation will be appended to
>-     * any data in the destination String, to allow cascading calls to
>-     * other #toString() methods for Expressions.
>-     * @return the String representation of this Expr.
>-    **/
>     virtual void toString(String& str);
> 
> private:
>@@ -1106,22 +717,9 @@
> 
> 
>     /**
>-     * Evaluates this Expr based on the given context node and processor state
>-     * @param context the context node for evaluation of this Expr
>-     * @param ps the ContextState containing the stack information needed
>-     * for evaluation
>-     * @return the result of the evaluation
>+     * Virtual methods from Expr 
>     **/
>     virtual ExprResult* evaluate(Node* context, ContextState* cs);
>-
>-    /**
>-     * Returns the String representation of this Expr.
>-     * @param dest the String to use when creating the String
>-     * representation. The String representation will be appended to
>-     * any data in the destination String, to allow cascading calls to
>-     * other #toString() methods for Expressions.
>-     * @return the String representation of this Expr.
>-    **/
>     virtual void toString(String& str);
> 
> 
>@@ -1133,6 +731,32 @@
> }; //-- AdditiveExpr
> 
> /**
>+ * Represents an UnaryExpr. Returns the negative value of it's expr.
>+**/
>+class UnaryExpr : public Expr {
>+
>+public:
>+
>+     UnaryExpr();
>+     UnaryExpr(Expr* expr);
>+     ~UnaryExpr();
>+
>+    /**
>+     * Sets the expression to negate
>+    **/
>+    void setExpr(Expr* expr);
>+
>+    /**
>+     * Virtual methods from Expr 
>+    **/
>+    virtual ExprResult* evaluate(Node* context, ContextState* cs);
>+    virtual void toString(String& str);
>+
>+private:
>+    Expr* expr;
>+}; //-- UnaryExpr
>+
>+/**
>  * Represents a BooleanExpr, a binary expression that
>  * performs a boolean operation between it's lvalue and rvalue:<BR/>
> **/
>@@ -1148,33 +772,20 @@
>      ~BooleanExpr();
> 
>     /**
>-     * Sets the left side of this AdditiveExpr
>+     * Sets the left side of this BooleanExpr
>     **/
>     void setLeftExpr(Expr* leftExpr);
> 
>     /**
>-     * Sets the right side of this AdditiveExpr
>+     * Sets the right side of this BooleanExpr
>     **/
>     void setRightExpr(Expr* rightExpr);
> 
> 
>     /**
>-     * Evaluates this Expr based on the given context node and processor state
>-     * @param context the context node for evaluation of this Expr
>-     * @param ps the ContextState containing the stack information needed
>-     * for evaluation
>-     * @return the result of the evaluation
>+     * Virtual methods from Expr 
>     **/
>     virtual ExprResult* evaluate(Node* context, ContextState* cs);
>-
>-    /**
>-     * Returns the String representation of this Expr.
>-     * @param dest the String to use when creating the String
>-     * representation. The String representation will be appended to
>-     * any data in the destination String, to allow cascading calls to
>-     * other #toString() methods for Expressions.
>-     * @return the String representation of this Expr.
>-    **/
>     virtual void toString(String& str);
> 
> 
>@@ -1215,28 +826,12 @@
>     **/
>     void setRightExpr(Expr* rightExpr);
> 
>-
>     /**
>-     * Evaluates this Expr based on the given context node and processor state
>-     * @param context the context node for evaluation of this Expr
>-     * @param ps the ContextState containing the stack information needed
>-     * for evaluation
>-     * @return the result of the evaluation
>+     * Virtual methods from Expr 
>     **/
>     virtual ExprResult* evaluate(Node* context, ContextState* cs);
>-
>-    /**
>-     * Returns the String representation of this Expr.
>-     * @param dest the String to use when creating the String
>-     * representation. The String representation will be appended to
>-     * any data in the destination String, to allow cascading calls to
>-     * other #toString() methods for Expressions.
>-     * @return the String representation of this Expr.
>-    **/
>     virtual void toString(String& str);
> 
>-
>-
> private:
>     short op;
>     Expr* leftExpr;
>@@ -1273,26 +868,11 @@
>      ~RelationalExpr();
> 
>     /**
>-     * Evaluates this Expr based on the given context node and processor state
>-     * @param context the context node for evaluation of this Expr
>-     * @param ps the ContextState containing the stack information needed
>-     * for evaluation
>-     * @return the result of the evaluation
>+     * Virtual methods from Expr 
>     **/
>     virtual ExprResult* evaluate(Node* context, ContextState* cs);
>-
>-    /**
>-     * Returns the String representation of this Expr.
>-     * @param dest the String to use when creating the String
>-     * representation. The String representation will be appended to
>-     * any data in the destination String, to allow cascading calls to
>-     * other #toString() methods for Expressions.
>-     * @return the String representation of this Expr.
>-    **/
>     virtual void toString(String& str);
> 
>-
>-
> private:
>     short op;
>     Expr* leftExpr;
>@@ -1320,22 +900,9 @@
>     void setName(const String& name);
> 
>     /**
>-     * Evaluates this Expr based on the given context node and processor state
>-     * @param context the context node for evaluation of this Expr
>-     * @param ps the ContextState containing the stack information needed
>-     * for evaluation
>-     * @return the result of the evaluation
>+     * Virtual methods from Expr 
>     **/
>     virtual ExprResult* evaluate(Node* context, ContextState* cs);
>-
>-    /**
>-     * Returns the String representation of this Expr.
>-     * @param dest the String to use when creating the String
>-     * representation. The String representation will be appended to
>-     * any data in the destination String, to allow cascading calls to
>-     * other #toString() methods for Expressions.
>-     * @return the String representation of this Expr.
>-    **/
>     virtual void toString(String& str);
> 
> private:
>@@ -1346,7 +913,7 @@
> /**
>  *  Represents a PathExpr
> **/
>-class PathExpr : public PatternExpr {
>+class PathExpr : public Expr {
> 
> public:
> 
>@@ -1361,66 +928,37 @@
>     PathExpr();
> 
>     /**
>-     * Destructor, will delete all Pattern Expressions
>+     * Destructor, will delete all Expressions
>     **/
>     virtual ~PathExpr();
> 
>     /**
>-     * Adds the PatternExpr to this PathExpr
>+     * Adds the Expr to this PathExpr
>      * @param expr the Expr to add to this PathExpr
>      * @param index the index at which to add the given Expr
>     **/
>-    void addPatternExpr(int index, PatternExpr* expr, short ancestryOp);
>+    void addExpr(int index, Expr* expr, short ancestryOp);
> 
>     /**
>-     * Adds the PatternExpr to this PathExpr
>+     * Adds the Expr to this PathExpr
>      * @param expr the Expr to add to this PathExpr
>     **/
>-    void addPatternExpr(PatternExpr* expr, short ancestryOp);
>+    void addExpr(Expr* expr, short ancestryOp);
> 
>     virtual MBool isAbsolute();
> 
>-      //------------------------------------/
>-     //- Virtual methods from PatternExpr -/
>-    //------------------------------------/
>-
>     /**
>-     * Evaluates this Expr based on the given context node and processor state
>-     * @param context the context node for evaluation of this Expr
>-     * @param ps the ContextState containing the stack information needed
>-     * for evaluation
>-     * @return the result of the evaluation
>+     * Virtual methods from Expr 
>     **/
>     virtual ExprResult* evaluate(Node* context, ContextState* cs);
>-
>-    /**
>-     * Returns the default priority of this Pattern based on the given Node,
>-     * context Node, and ContextState.
>-     * If this pattern does not match the given Node under the current context Node and
>-     * ContextState then Negative Infinity is returned.
>-    **/
>-    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs);
>-
>-    /**
>-     * Determines whether this PatternExpr matches the given node within
>-     * the given context
>-    **/
>     virtual MBool matches(Node* node, Node* context, ContextState* cs);
>-
>-    /**
>-     * Returns the String representation of this PatternExpr.
>-     * @param dest the String to use when creating the String
>-     * representation. The String representation will be appended to
>-     * any data in the destination String, to allow cascading calls to
>-     * other #toString() methods for Expressions.
>-     * @return the String representation of this PatternExpr.
>-    **/
>+    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs);
>     virtual void toString(String& dest);
> 
> private:
> 
>     struct PathExprItem {
>-        PatternExpr* pExpr;
>+        Expr* expr;
>         short ancestryOp;
>     };
> 
>@@ -1428,13 +966,13 @@
> 
>    /**
>     * Selects from the descendants of the context node
>-    * all nodes that match the PatternExpr
>+    * all nodes that match the Expr
>     * -- this will be moving to a Utility class
>    **/
>-   void evalDescendants(PatternExpr* pExpr,
>+   void evalDescendants(Expr* expr,
>                         Node* context,
>                         ContextState* cs,
>-                        NodeSet* nodes);
>+                        NodeSet* resNodes);
> 
> }; //-- PathExpr
> 
>@@ -1450,47 +988,22 @@
>     //------------------/
> 
>     /**
>-     * Evaluates this Expr based on the given context node and processor state
>-     * @param context the context node for evaluation of this Expr
>-     * @param ps the ContextState containing the stack information needed
>-     * for evaluation
>-     * @return the result of the evaluation
>+     * Virtual methods from Expr 
>     **/
>     virtual ExprResult* evaluate(Node* context, ContextState* cs);
>-
>-    virtual MBool isAbsolute();
>-
>-    /**
>-     * Returns the default priority of this Pattern based on the given Node,
>-     * context Node, and ContextState.
>-     * If this pattern does not match the given Node under the current context Node and
>-     * ContextState then Negative Infinity is returned.
>-    **/
>-    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs);
>-
>-    /**
>-     * Determines whether this NodeExpr matches the given node within
>-     * the given context
>-    **/
>     virtual MBool matches(Node* node, Node* context, ContextState* cs);
>-
>-    /**
>-     * Returns the String representation of this PatternExpr.
>-     * @param dest the String to use when creating the String
>-     * representation. The String representation will be appended to
>-     * any data in the destination String, to allow cascading calls to
>-     * other #toString() methods for Expressions.
>-     * @return the String representation of this PatternExpr.
>-    **/
>+    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs);
>     virtual void toString(String& dest);
> 
>+    virtual MBool isAbsolute();
>+
> 
> }; //-- RootExpr
> 
> /**
>  *  Represents a UnionExpr
> **/
>-class UnionExpr : public PatternExpr {
>+class UnionExpr : public Expr {
> 
> public:
> 
>@@ -1508,49 +1021,20 @@
>      * Adds the PathExpr to this UnionExpr
>      * @param expr the Expr to add to this UnionExpr
>     **/
>-    void addPathExpr(PathExpr* expr);
>+    void addExpr(Expr* expr);
> 
>     /**
>      * Adds the PathExpr to this UnionExpr at the specified index
>      * @param expr the Expr to add to this UnionExpr
>     **/
>-    void addPathExpr(int index, PathExpr* expr);
>-
>-      //------------------------------------/
>-     //- Virtual methods from PatternExpr -/
>-    //------------------------------------/
>+    void addExpr(int index, Expr* expr);
> 
>     /**
>-     * Evaluates this Expr based on the given context node and processor state
>-     * @param context the context node for evaluation of this Expr
>-     * @param ps the ContextState containing the stack information needed
>-     * for evaluation
>-     * @return the result of the evaluation
>+     * Virtual methods from Expr 
>     **/
>     virtual ExprResult* evaluate(Node* context, ContextState* cs);
>-
>-    /**
>-     * Returns the default priority of this Pattern based on the given Node,
>-     * context Node, and ContextState.
>-     * If this pattern does not match the given Node under the current context Node and
>-     * ContextState then Negative Infinity is returned.
>-    **/
>-    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs);
>-
>-    /**
>-     * Determines whether this PatternExpr matches the given node within
>-     * the given context
>-    **/
>     virtual MBool matches(Node* node, Node* context, ContextState* cs);
>-
>-    /**
>-     * Returns the String representation of this PatternExpr.
>-     * @param dest the String to use when creating the String
>-     * representation. The String representation will be appended to
>-     * any data in the destination String, to allow cascading calls to
>-     * other #toString() methods for Expressions.
>-     * @return the String representation of this PatternExpr.
>-    **/
>+    virtual double getDefaultPriority(Node* node, Node* context, ContextState* cs);
>     virtual void toString(String& dest);
> 
> private:
>Index: source/xpath/ExprLexer.cpp
>===================================================================
>RCS file: /cvsroot/mozilla/extensions/transformiix/source/xpath/ExprLexer.cpp,v
>retrieving revision 1.13
>diff -w -u -3 -r1.13 ExprLexer.cpp
>--- ExprLexer.cpp	2001/05/12 11:59:44	1.13
>+++ ExprLexer.cpp	2001/06/15 10:34:30
>@@ -1,4 +1,4 @@
>-/*
>+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- 
>  * The contents of this file are subject to the Mozilla Public
>  * License Version 1.1 (the "License"); you may not use this file
>  * except in compliance with the License. You may obtain a copy of
>@@ -29,6 +29,9 @@
>  *   -- Fixed bug in parse method so that we make sure we check for
>  *      axis identifier wild cards, such as ancestor::*
>  *
>+ * Axel Hecht <axel@pike.org>
>+ *   -- big beating, general overhaul
>+ *
>  * $Id: ExprLexer.cpp,v 1.13 2001/05/12 11:59:44 peterv%netscape.com Exp $
>  */
> 
>@@ -48,7 +51,8 @@
> /**
>  * Default constructor for Token
> **/
>-Token::Token() {
>+Token::Token()
>+{
>     this->type =0;
> } //-- Token;
> 
>@@ -56,7 +60,8 @@
>  * Constructor for Token
>  * @param type, the type of Token being represented
> **/
>-Token::Token(short type) {
>+Token::Token(short type)
>+{
>     this->type = type;
> } //-- Token;
> 
>@@ -65,13 +70,15 @@
>  * @param value the value of this Token
>  * @param type, the type of Token being represented
> **/
>-Token::Token(const String& value, short type) {
>+Token::Token(const String& value, short type)
>+{
>     this->type = type;
>     //-- make copy of value String
>     this->value = value;
> } //-- Token
> 
>-Token::Token(UNICODE_CHAR uniChar, short type) {
>+Token::Token(UNICODE_CHAR uniChar, short type)
>+{
>     this->type = type;
>     this->value.append(uniChar);
> } //-- Token
>@@ -79,7 +86,8 @@
> /**
>  * Copy Constructor
> **/
>-Token::Token(const Token& token) {
>+Token::Token(const Token& token)
>+{
>     this->type = token.type;
>     this->value = token.value;
> } //-- Token
>@@ -87,7 +95,8 @@
> /**
>  * Destructor for Token
> **/
>-Token::~Token() {
>+Token::~Token()
>+{
>     //-- currently nothing is needed
> } //-- ~Token
> 
>@@ -113,28 +122,19 @@
> const String ExprLexer::MODULUS = "mod";
> const String ExprLexer::DIVIDE  = "div";
> 
>-
> /**
>- * The set of a XSL Expression Tokens
>+ * The set of Lexer error messages
> **/
>-const Token ExprLexer::TOKENS[] = {
>-
>-    //-- Nodetype tokens
>-    Token(ExprLexer::COMMENT,       Token::COMMENT),
>-    Token(ExprLexer::NODE,          Token::NODE),
>-    Token(ExprLexer::PROC_INST,     Token::PROC_INST),
>-    Token(ExprLexer::TEXT,          Token::TEXT),
>-    //-- boolean operators
>-    Token(ExprLexer::AND,           Token::AND_OP),
>-    Token(ExprLexer::OR,            Token::OR_OP),
>-
>-    //-- multiplicative operators
>-    Token(ExprLexer::MODULUS,       Token::MODULUS_OP),
>-    Token(ExprLexer::DIVIDE,        Token::DIVIDE_OP)
>+const String ExprLexer::error_message[] =
>+{
>+  "VariableReference expected",
>+  "Operator expected",
>+  "Literal is not closed",
>+  ": not expected",
>+  "! not expected, use != or not()",
>+  "found a unkown character"
> };
> 
>-const short ExprLexer::NUMBER_OF_TOKENS  = 8;
>-
>   //---------------/
>  //- Contructors -/
> //---------------/
>@@ -142,12 +142,13 @@
> /**
>  * Creates a new ExprLexer using the given String
> **/
>-ExprLexer::ExprLexer(const String& pattern) {
>-
>+ExprLexer::ExprLexer(const String& pattern)
>+{
>     firstItem    = 0;
>     lastItem     = 0;
>     tokenCount   = 0;
>     prevToken    = 0;
>+  endToken.type = Token::END;
>     parse(pattern);
>     currentItem = firstItem;
> } //-- ExprLexer
>@@ -155,85 +156,51 @@
> /**
>  * Destroys this instance of an ExprLexer
> **/
>-ExprLexer::~ExprLexer() {
>+ExprLexer::~ExprLexer()
>+{
>    //-- delete tokens
>-
>-   //cout << "~ExprLexer() - start"<<endl;
>    currentItem = firstItem;
>    while ( currentItem ) {
>        TokenListItem* temp = currentItem->next;
>-       //cout << "deleting token: " << currentItem->token->value << endl;
>        delete currentItem->token;
>        delete currentItem;
>        currentItem = temp;
>    }
>-   //cout << "~ExprLexer() - done"<<endl;
> } //-- ~ExprLexer
> 
> 
>-int ExprLexer::countAllTokens() {
>-    return tokenCount;
>-} //-- countAllTokens
>-
>-int ExprLexer::countRemainingTokens() {
>-    TokenListItem* temp = currentItem;
>-    int c = 0;
>-    while ( temp ) {
>-        ++c;
>-        temp = temp->next;
>-    }
>-    return c;
>-} //-- countRemainingTokens
>-
>-
>-MBool ExprLexer::hasMoreTokens() {
>+MBool ExprLexer::hasMoreTokens()
>+{
>     return (MBool) ( currentItem );
> } //-- hasMoreTokens
> 
>-Token* ExprLexer::nextToken() {
>+Token* ExprLexer::nextToken()
>+{
>     if ( currentItem ) {
>         Token* token = currentItem->token;
>         currentItem = currentItem->next;
>         return token;
>     }
>-    return 0;
>+  return &endToken;
> } //-- nextToken
> 
>-void ExprLexer::pushBack() {
>+void ExprLexer::pushBack()
>+{
>     if ( !currentItem ) {
>         currentItem = lastItem;
>     }
>     else currentItem = currentItem->previous;
> } //-- pushBack
>-
>-/*
>-Token* ExprLexer::lastToken() {
>-    if (lastItem) {
>-        return lastItem->token;
>-    }
>-    return 0;
>-} //-- lastToken
>-*/
> 
>-Token* ExprLexer::peek() {
>-    Token* token = 0;
>-    TokenListItem* tlItem = currentItem;
>-    if (tlItem) token = tlItem->token;
>-    return token;
>+Token* ExprLexer::peek()
>+{
>+  if ( currentItem )
>+    return currentItem->token;
>+  return &endToken;
> } //-- peek
>-
>-Token* ExprLexer::lookAhead(int offset) {
>-    Token* token = 0;
>-    TokenListItem* tlItem = currentItem;
>-    //-- advance to proper offset
>-    for ( int i = 0; i < offset; i++ )
>-        if ( tlItem ) tlItem = currentItem->next;
>-
>-    if (tlItem) token = tlItem->token;
>-    return token;
>-} //-- lookAhead
> 
>-void ExprLexer::addToken(Token* token) {
>+void ExprLexer::addToken(Token* token)
>+{
>     TokenListItem* tlItem = new TokenListItem;
>     tlItem->token = token;
>     tlItem->next  = 0;
>@@ -247,266 +214,32 @@
>     ++tokenCount;
> } //-- addToken
> 
>-/**
>- * Returns true if the given character represents an Alpha letter
>-**/
>-MBool ExprLexer::isAlphaChar(Int32 ch) {
>-    if ((ch >= 'a' ) && (ch <= 'z' )) return MB_TRUE;
>-    if ((ch >= 'A' ) && (ch <= 'Z' )) return MB_TRUE;
>-    return MB_FALSE;
>-} //-- isAlphaChar
>-
> /**
>- * Returns true if the given character represents a numeric letter (digit)
>-**/
>-MBool ExprLexer::isDigit(Int32 ch) {
>-    if ((ch >= '0') && (ch <= '9'))   return MB_TRUE;
>-    return MB_FALSE;
>-} //-- isDigit
>-
>-/**
>- * Returns true if the given character is an allowable NCName character
>-**/
>-MBool ExprLexer::isNCNameChar(Int32 ch) {
>-    if (isDigit(ch) || isAlphaChar(ch)) return MB_TRUE;
>-    return (MBool) ((ch == '.') || (ch == '_') || (ch == '-'));
>-} //-- isNCNameChar
>-
>-/**
>- * Returns true if the given character is an allowable QName character
>-**/
>-MBool ExprLexer::isQNameChar(Int32 ch) {
>-    return (MBool) (( ch == ':') || isNCNameChar(ch));
>-} //-- isQNameChar
>-
>-/**
>- * Returns true if the given String is a valid XML QName
>-**/
>-MBool ExprLexer::isValidQName(String& name) {
>-
>-    int size = name.length();
>-    if ( size == 0 ) return MB_FALSE;
>-    else if ( !isAlphaChar(name.charAt(0))) return MB_FALSE;
>-    else {
>-        for ( int i = 1; i < size; i++) {
>-            if ( ! isQNameChar(name.charAt(i))) return MB_FALSE;
>-        }
>-    }
>-    return MB_TRUE;
>-} //-- isValidQName
>-
>-MBool ExprLexer::isOperatorToken(Token* token) {
>-    if ( !token ) return MB_FALSE;
>-    switch ( token->type ) {
>-        //-- boolean operators
>-        case Token::AND_OP:
>-        case Token::OR_OP:
>-        //-- relational operators
>-        case Token::EQUAL_OP:
>-        case Token::NOT_EQUAL_OP:
>-        case Token::LESS_THAN_OP:
>-        case Token::GREATER_THAN_OP:
>-        case Token::LESS_OR_EQUAL_OP:
>-        case Token::GREATER_OR_EQUAL_OP:
>-        //-- additive operators
>-        case Token::ADDITION_OP:
>-        case Token::SUBTRACTION_OP:
>-        //-- multiplicative operators
>-        case Token::DIVIDE_OP:
>-        case Token::MODULUS_OP:
>-        case Token::MULTIPLY_OP:
>-            return MB_TRUE;
>-        default:
>-            break;
>-    }
>-
>-    return MB_FALSE;
>-} //-- isOperatorToken
>-
>-MBool ExprLexer::matchDelimiter(UNICODE_CHAR ch) {
>-
>-    short tokenType = 0;
>-    MBool addChar = MB_TRUE;
>-    switch (ch) {
>-        case FORWARD_SLASH :
>-            tokenType = Token::PARENT_OP;
>-            break;
>-        case L_PAREN :
>-            tokenType = Token::L_PAREN;
>-            break;
>-        case R_PAREN :
>-            tokenType = Token::R_PAREN;
>-            break;
>-        case L_BRACKET :
>-            tokenType = Token::L_BRACKET;
>-            break;
>-        case R_BRACKET :
>-            tokenType = Token::R_BRACKET;
>-            break;
>-        case L_ANGLE :
>-            tokenType = Token::LESS_THAN_OP;
>-            break;
>-        case R_ANGLE :
>-            tokenType = Token::GREATER_THAN_OP;
>-            break;
>-        case COMMA :
>-            tokenType = Token::COMMA;
>-            break;
>-        case PERIOD :
>-            tokenType = Token::SELF_NODE;
>-            break;
>-        case EQUAL :
>-            tokenType = Token::EQUAL_OP;
>-            break;
>-        case PLUS :
>-            tokenType = Token::ADDITION_OP;
>-            break;
>-        case HYPHEN :
>-            tokenType = Token::SUBTRACTION_OP;
>-            break;
>-        case VERT_BAR:
>-            tokenType = Token::UNION_OP;
>-            break;
>-        case AT_SIGN:
>-            tokenType = Token::AT_SIGN;
>-            break;
>-        case DOLLAR_SIGN:
>-            tokenType = Token::VAR_REFERENCE;
>-            addChar = MB_FALSE;
>-            break;
>-        default:
>+ * Returns true if the following Token should be an operator.
>+ * This is a helper for the first bullet of [XPath 3.7]
>+ *  Lexical Structure
>+**/
>+MBool ExprLexer::nextIsOperatorToken(Token* token)
>+{
>+  if ( !token || token->type == Token::NULL_TOKEN) return MB_FALSE;
>+  /* This relies on the tokens having the right order in ExprLexer.h */
>+  if (token->type >= Token::COMMA && 
>+      token->type <= Token::UNION_OP)
>             return MB_FALSE;
>-    }
>-    Token* token = 0;
>-    if ( addChar ) token = new Token(ch, tokenType);
>-    else token = new Token(tokenType);
>-
>-    addToken(token);
>     return MB_TRUE;
>-} //-- matchDelimiter
>-
>-/**
>- * Returns true if the value of the given String matches
>- * an OperatorName
>-**/
>-MBool ExprLexer::matchesOperator(String& buffer) {
>-
>-    int index = 0;
>-    while (index < NUMBER_OF_TOKENS) {
>-        Token tok = TOKENS[index++];
>-        if ( tok.value.isEqual(buffer) ) {
>-            if (isOperatorToken( &tok )) return MB_TRUE;
>-        }
>-    }
>-    return MB_FALSE;
>-
>-} //-- matchesOperator
>-
>-/**
>- * Matches the given String to the appropriate Token
>- * @param buffer the current StringBuffer representing the value of the Token
>- * @param ch, the current delimiter token
>-**/
>-void ExprLexer::matchToken(String& buffer, UNICODE_CHAR ch) {
>-
>-    if ( buffer.length() == 0) return;
>-
>-    Token* match = new Token();
>-    MBool foundMatch = MB_FALSE;
>-    int index = 0;
>-
>-    //-- check previous token
>-    switch(prevToken->type) {
>-        case Token::VAR_REFERENCE :
>-            if ( prevToken->value.length() == 0) {
>-                prevToken->value.append(buffer);
>-                buffer.clear();
>-                return;
>-            }
>-            break;
>-        default:
>-            break;
>-    }
>+} //-- nextIsOperatorToken
> 
>-    //-- look for next match
>-    while ( !foundMatch && (index < NUMBER_OF_TOKENS) ) {
>-
>-        Token tok = TOKENS[index++];
>-
>-        if ( tok.value.isEqual(buffer) ) {
>-
>-            foundMatch = MB_TRUE;
>-
>-            switch (tok.type) {
>-
>-                //-- NodeType tokens
>-                case Token::COMMENT:
>-                case Token::NODE :
>-                case Token::PROC_INST :
>-                case Token::TEXT :
>-                    // make sure next delimiter is '('
>-                    if ( ch != L_PAREN) {
>-                        foundMatch = MB_FALSE;
>-                        break;
>-                    }
>-                    //-- copy buffer
>-                    match->value = buffer;
>-                    //-- copy type
>-                    match->type = tok.type;
>-                    break;
>-               case Token::MULTIPLY_OP :
>-               case Token::DIVIDE_OP:
>-               case Token::MODULUS_OP:
>-                    switch ( prevToken->type ) {
>-                        case Token::AT_SIGN :
>-                        case Token::NULL_TOKEN:
>-                        case Token::L_PAREN:
>-                        case Token::L_BRACKET:
>-                            foundMatch = MB_FALSE;
>-                            break; //-- do not match
>-                        default:
>-                            if ( isOperatorToken(prevToken) ) {
>-                                foundMatch = MB_FALSE;
>-                                break; //-- do not match
>-                            }
>-                            match->value = buffer;
>-                            match->type = tok.type;
>-                    }
>-                    break;
>-               default :
>-                    //-- copy buffer
>-                    match->value = buffer;
>-                    match->type = tok.type;
>-                    break;
>-            }
>-        } //-- if equal
>-    } //-- while
>-
>-    if (!foundMatch) {
>-        //-- copy buffer
>-        match->value = buffer;
>-        //-- look for function name
>-        if ( ch == L_PAREN) match->type = Token::FUNCTION_NAME;
>-        else match->type = Token::CNAME;
>-    }
>-    addToken(match);
>-    buffer.clear();
>-} //-- matchToken
>-
> /**
>  *  Parses the given String into the set of Tokens
> **/
>-void ExprLexer::parse(const String& pattern) {
>-
>-
>+void ExprLexer::parse(const String& pattern)
>+{
>     String tokenBuffer;
>-    UNICODE_CHAR inLiteral = '\0';
>-    MBool inNumber  = MB_FALSE;
>-
>-    Int32 currentPos = 0;
>-
>-    UNICODE_CHAR ch = '\0';
>-    UNICODE_CHAR prevCh = ch;
>+  Int32 iter = 0, start;
>+  Int32 size = pattern.length();
>+  short defType;
>+  UNICODE_CHAR ch;
>+  if ( size==0 ) return;
> 
>     //-- initialize previous token, this will automatically get
>     //-- deleted when it goes out of scope
>@@ -514,212 +247,249 @@
> 
>     prevToken = &nullToken;
> 
>-    while (currentPos < pattern.length()) {
>+  while (iter < size) {
> 
>-        prevCh = ch;
>-        ch = pattern.charAt(currentPos);
>+    ch = pattern.charAt(iter);
>+    defType = Token::CNAME;
> 
>-        if ( inLiteral ) {
>-            //-- look for end of literal
>-            if ( ch == inLiteral ) {
>-                inLiteral = '\0';
>-                addToken(new Token(tokenBuffer, Token::LITERAL));
>-                tokenBuffer.clear();
>-            }
>-            else {
>-                tokenBuffer.append(ch);
>-            }
>-        }
>-        else if ( inNumber ) {
>-            if (isDigit(ch) || (ch == '.')) {
>-                tokenBuffer.append(ch);
>-            }
>+    if (ch==DOLLAR_SIGN) {
>+      if (++iter == size || !isLetter(ch=pattern.charAt(iter))) {
>+        // Error, VariableReference expected
>+        errorPos = iter;
>+        errorCode = ERROR_UNRESOLVED_VAR_REFERENCE;
>+        if (firstItem)
>+          firstItem->token->type=Token::ERROR;
>+        else
>+          addToken(new Token('\0',Token::ERROR));
>+        iter=size; // bail
>+      } else
>+        defType = Token::VAR_REFERENCE;
>+    } 
>+    // just reuse the QName parsing, which will use defType 
>+    // the token to construct
>+
>+    if ( isLetter(ch) ) {
>+      // NCName, can get QName or OperatorName;
>+      //  FunctionName, NodeName, and AxisSpecifier may want whitespace,
>+      //  and are dealt with below
>+      start = iter;
>+      while (++iter < size && 
>+             isNCNameChar(pattern.charAt(iter))) /* just go */ ;
>+      Int32 end = iter;
>+      if (pattern.charAt(iter)==COLON) {
>+        // try QName or wildcard, might need to step back for axis
>+        if (++iter < size)
>+          if (isLetter(pattern.charAt(iter)))
>+            while(++iter < size && 
>+                  isNCNameChar(pattern.charAt(iter))) /* just go */ ;
>+          else if (pattern.charAt(iter)=='*' 
>+                   && defType != Token::VAR_REFERENCE)
>+            ++iter; /* eat wildcard for NameTest, bail for var ref at COLON */
>+          else 
>+            iter--; // step back
>+      }
>+      if (nextIsOperatorToken(prevToken)) {
>+        if (pattern.subString(start,end,subStr).isEqual(AND))
>+          defType = Token::AND_OP;
>+        else if (pattern.subString(start,end,subStr).isEqual(OR))
>+          defType = Token::OR_OP;
>+        else if (pattern.subString(start,end,subStr).isEqual(MODULUS))
>+          defType = Token::MODULUS_OP;
>+        else if (pattern.subString(start,end,subStr).isEqual(DIVIDE))
>+          defType = Token::DIVIDE_OP;
>             else {
>-                inNumber = MB_FALSE;
>-                addToken(new Token(tokenBuffer, Token::NUMBER));
>-                tokenBuffer.clear();
>-                //-- push back last char
>-                --currentPos;
>-            }
>-        }
>-        else if (isDigit(ch)) {
>-            if  ((tokenBuffer.length() == 0 ) || matchesOperator(tokenBuffer) ) {
>-                //-- match operator and free up token buffer
>-                matchToken(tokenBuffer, ch);
>-                inNumber = MB_TRUE;
>-            }
>-            else if (( tokenBuffer.length() == 1 ) && (prevCh = '-')) {
>-                inNumber = MB_TRUE;
>-            }
>-            tokenBuffer.append(ch);
>-        }
>-        else {
>+          // Error "operator expected"
>+          // XXX QUESTION: spec is not too precise
>+          // badops is sure an error, but is bad:ops, too? We say yes!
>+          errorPos = iter;
>+          errorCode = ERROR_OP_EXPECTED;
>+          if (firstItem)
>+            firstItem->token->type=Token::ERROR;
>+          else
>+            addToken(new Token('\0',Token::ERROR));
>+          iter=size; // bail
>+        }
>+      }
>+      addToken(new Token(pattern.subString(start,iter,subStr),defType));
>+    } else if ( isDigit(ch) ) {
>+      start = iter;
>+      while (++iter < size && 
>+             isDigit(pattern.charAt(iter))) /* just go */;
>+      if (pattern.charAt(iter)=='.')
>+        while (++iter < size && 
>+               isDigit(pattern.charAt(iter))) /* just go */;
>+      addToken(new Token(pattern.subString(start,iter,subStr),Token::NUMBER));
>+    } else {
>             switch (ch) {
>                 //-- ignore whitespace
>                 case SPACE:
>                 case TX_TAB:
>                 case TX_CR:
>                 case TX_LF:
>+        ++iter;
>                     break;
>                 case S_QUOTE :
>                 case D_QUOTE :
>-                    matchToken(tokenBuffer, ch);
>-                    inLiteral = ch;
>+        start=iter;
>+        iter = pattern.indexOf(ch,start+1);
>+        if (iter==NOT_FOUND) {
>+          // XXX Error reporting "unclosed literal"
>+          errorPos = start;
>+          errorCode = ERROR_UNCLOSED_LITERAL;
>+          if (firstItem)
>+            firstItem->token->type=Token::ERROR;
>+          else
>+            addToken(new Token('\0',Token::ERROR));
>+          iter=size; // bail
>+        } else {
>+          addToken(new Token(pattern.subString(start+1,iter,subStr),
>+                             Token::LITERAL));
>+          ++iter;
>+        }
>                     break;
>                 case PERIOD:
>-                    if ( inNumber ) tokenBuffer.append(ch);
>-                    else if ( prevToken->type == Token::SELF_NODE ) {
>-                        prevToken->type = Token::PARENT_NODE;
>-                    }
>-                    else if ( tokenBuffer.length() > 0 )
>-                        tokenBuffer.append(ch);
>-                    else matchDelimiter(ch);
>-                    break;
>-                case COLON:
>-                    if ( prevCh == ch) {
>-                        Int32 bufSize = tokenBuffer.length();
>-                        tokenBuffer.setLength(bufSize-1);
>-                        addToken(new Token(tokenBuffer, Token::AXIS_IDENTIFIER));
>-                        tokenBuffer.clear();
>+        // period can be .., .(DIGITS)+ or ., check next
>+        if (++iter < size) {
>+          ch=pattern.charAt(iter);
>+          if (isDigit(ch)) {
>+            start=iter-1;
>+            while (++iter < size && 
>+                   isDigit(pattern.charAt(iter))) /* just go */;
>+            addToken(new Token(pattern.subString(start,iter,subStr),
>+                               Token::NUMBER));
>+          } else if (ch==PERIOD) {
>+            addToken(new Token(pattern.subString(iter-1,iter++,subStr),
>+                               Token::PARENT_NODE));
>+          } else
>+            addToken(new Token(PERIOD, Token::SELF_NODE));
>+        } else
>+          addToken(new Token(ch, Token::SELF_NODE));
>+        // iter++ is already in the number test
>+        
>+        break;
>+      case COLON: // QNames are dealt above, must be axis ident
>+        if (++iter < size && pattern.charAt(iter)==COLON &&
>+            prevToken->type == Token::CNAME) {
>+          prevToken->type = Token::AXIS_IDENTIFIER;
>+          ++iter;
>+        } else {
>+          // XXX Error report "colon is neither QName nor axis"
>+          errorPos = iter;
>+          errorCode = ERROR_COLON;
>+          if (firstItem)
>+            firstItem->token->type=Token::ERROR;
>+          else
>+            addToken(new Token('\0',Token::ERROR));
>+          iter=size; // bail
>                     }
>-                    else tokenBuffer.append(ch);
>                     break;
>                 case FORWARD_SLASH :
>-                    matchToken(tokenBuffer, ch);
>-                    if ( prevToken->type == Token::PARENT_OP ) {
>-                        prevToken->type = Token::ANCESTOR_OP;
>-                        prevToken->value.append(ch);
>-                    }
>-                    //-- handle possible error in using /
>-                    else if ( prevToken->type == Token::NUMBER ) {
>-                        prevToken->type = Token::ERROR;
>-                        prevToken->value = "Error in expression, misuse of '/', try 'div' instead.";
>-                    }
>-                    else matchDelimiter(ch);
>-                    break;
>-                case BANG : //-- used as previous...see EQUAL
>-                    matchToken(tokenBuffer,ch);
>-                    addToken(new Token(ch, Token::ERROR));
>+        if (++iter < size && pattern.charAt(iter)==ch) {
>+          addToken(new Token(pattern.subString(iter-1,++iter,subStr),
>+                             Token::ANCESTOR_OP));
>+        } else {
>+          addToken(new Token(ch, Token::PARENT_OP));
>+        }
>+        break;
>+      case BANG : // can only be !=
>+        if (++iter < size && pattern.charAt(iter)==EQUAL) {
>+          addToken(new Token(pattern.subString(iter-1,++iter,subStr),
>+                             Token::NOT_EQUAL_OP));
>+        } else {
>+          // Error ! is not not()
>+          errorPos = iter;
>+          errorCode = ERROR_BANG;
>+          if (firstItem)
>+            firstItem->token->type=Token::ERROR;
>+          else
>+            addToken(new Token('\0',Token::ERROR));
>+          iter=size; // bail
>+        }
>                     break;
>                 case EQUAL:
>-                    switch ( prevCh ) {
>-                        case BANG:
>-                            prevToken->type = Token::NOT_EQUAL_OP;
>-                            prevToken->value.append("=");
>+        addToken(new Token(ch,Token::EQUAL_OP));
>+        ++iter;
>                             break;
>                         case L_ANGLE:
>-                            prevToken->type = Token::LESS_OR_EQUAL_OP;
>-                            prevToken->value.append("=");
>-                            break;
>-                        case R_ANGLE:
>-                            prevToken->type = Token::GREATER_OR_EQUAL_OP;
>-                            prevToken->value.append("=");
>+        if (++iter < size && pattern.charAt(iter)==EQUAL) {
>+          addToken(new Token(pattern.subString(iter-1,++iter,subStr),
>+                             Token::LESS_OR_EQUAL_OP));
>+        } else
>+          addToken(new Token(ch,Token::LESS_THAN_OP));
>                             break;
>-                        default:
>-                            matchToken(tokenBuffer, ch);
>-                            matchDelimiter(ch);
>-                            break;
>-                    }
>-                    break;
>-                case L_ANGLE :
>                 case R_ANGLE :
>-                    matchToken(tokenBuffer, ch);
>-                    matchDelimiter(ch);
>+        if (++iter < size && pattern.charAt(iter)==EQUAL) {
>+          addToken(new Token(pattern.subString(iter-1,++iter,subStr),
>+                             Token::GREATER_OR_EQUAL_OP));
>+        } else
>+          addToken(new Token(ch,Token::GREATER_THAN_OP));
>                     break;
>                 case HYPHEN :
>-                    if ( isValidQName(tokenBuffer) && 
>-                         !( prevCh==SPACE || prevCh==TX_TAB||
>-                            prevCh==TX_CR || prevCh==TX_LF ) )
>-                        tokenBuffer.append(ch);
>-                    else {
>-                        switch ( prevToken->type ) {
>-                            case Token::NULL_TOKEN:
>-                            case Token::L_PAREN:
>-                            case Token::L_BRACKET:
>-                            case Token::COMMA:
>-                                inNumber = MB_TRUE;
>-                                tokenBuffer.append(ch);
>-                                break;
>-                            default:
>-                                matchToken(tokenBuffer, ch);
>-                                matchDelimiter(ch);
>-                                break;
>-                        }
>-                    }
>+        addToken(new Token(ch,Token::SUBTRACTION_OP));
>+        ++iter;
>                     break;
>                 case ASTERIX:
>-                    matchToken(tokenBuffer, ch);
>-                    switch ( prevToken->type ) {
>-                        //-- temporary fix for Namespace wild-cards - KV
>-                        case Token::CNAME :
>-                            prevToken->value.append(ch);
>-                            break;
>-                        //-- end temporary fix for Namespace wild-cards
>-
>-                        //-- Fix: make sure check for axis identifier wild cards, such as
>-                        //-- ancestor::* - Marina M.
>-                        case Token::AXIS_IDENTIFIER :
>-                        //-- End Fix
>-                        case Token::PARENT_OP :
>-                        case Token::ANCESTOR_OP:
>-                        case Token::AT_SIGN :
>-                        case Token::NULL_TOKEN:
>-                        case Token::L_PAREN:
>-                        case Token::L_BRACKET:
>-                            tokenBuffer.append(ch);
>-                            //matchDelimiter(ch);
>-                            break;
>-                        default:
>-                            if ( isOperatorToken(prevToken) ) {
>-                                matchDelimiter(ch);
>-                                break; //-- do not match
>-                            }
>+        if (nextIsOperatorToken(prevToken))
>                             addToken( new Token(ch, Token::MULTIPLY_OP) );
>-                    }
>+        else
>+          addToken(new Token(ch,Token::CNAME));
>+        ++iter;
>                     break;
>                 case L_PAREN:
>+        if (prevToken->type == Token::CNAME) {
>+          if (prevToken->value.isEqual(COMMENT))
>+            prevToken->type = Token::COMMENT;
>+          else if (prevToken->value.isEqual(NODE))
>+            prevToken->type = Token::NODE;
>+          else if (prevToken->value.isEqual(PROC_INST))
>+            prevToken->type = Token::PROC_INST;
>+          else if (prevToken->value.isEqual(TEXT))
>+            prevToken->type = Token::TEXT;
>+          else
>+            prevToken->type = Token::FUNCTION_NAME;
>+        }
>+        ++iter;
>+        addToken(new Token(ch,Token::L_PAREN));
>+        break;
>                 case R_PAREN:
>+        ++iter;
>+        addToken(new Token(ch,Token::R_PAREN));
>+        break;
>                 case L_BRACKET:
>+        ++iter;
>+        addToken(new Token(ch,Token::L_BRACKET));
>+        break;
>                 case R_BRACKET:
>+        ++iter;
>+        addToken(new Token(ch,Token::R_BRACKET));
>+        break;
>                 case COMMA:
>+        ++iter;
>+        addToken(new Token(ch,Token::COMMA));
>+        break;
>                 case AT_SIGN :
>+        ++iter;
>+        addToken(new Token(ch,Token::AT_SIGN));
>+        break;
>                 case PLUS:
>-                case DOLLAR_SIGN :
>-                    matchToken(tokenBuffer, ch);
>-                    matchDelimiter(ch);
>+        ++iter;
>+        addToken(new Token(ch,Token::ADDITION_OP));
>                     break;
>                 case VERT_BAR:
>-                    matchToken(tokenBuffer, ch);
>-                    matchDelimiter(ch);
>-                    //-- Reset previous token to Null, since this is the "Union Operator"
>-                    //-- and the next set of tokens should start as a fresh expression
>-                    prevToken = &nullToken;
>-                    break;
>-                default:
>-                    switch (prevCh) {
>-                        case SPACE :
>-                        case TX_TAB :
>-                        case TX_CR :
>-                        case TX_LF :
>-                            matchToken(tokenBuffer, ch);
>-                            tokenBuffer.append(ch);
>+        ++iter;
>+        addToken(new Token(ch,Token::UNION_OP));
>                             break;
>                         default:
>-                            tokenBuffer.append(ch);
>-                            break;
>+        // Error, don't grok character :-(
>+        errorPos = iter;
>+        errorCode = ERROR_UNKNOWN_CHAR;
>+        if (firstItem)
>+          firstItem->token->type=Token::ERROR;
>+        else
>+          addToken(new Token('\0',Token::ERROR));
>+        iter=size; // bail       
>                     }
>-                    break;
>-            }
>         }
>-        ++currentPos;
>     }
>-    //-- end lexical parsing of current token
>-    //-- freeBuffer if needed
>-
>-    if ( inNumber ) {
>-        addToken(new Token(tokenBuffer, Token::NUMBER));
>-    }
>-    else matchToken(tokenBuffer, ch);
>-    prevToken = 0;
> } //-- parse
> 
>Index: source/xpath/ExprLexer.h
>===================================================================
>RCS file: /cvsroot/mozilla/extensions/transformiix/source/xpath/ExprLexer.h,v
>retrieving revision 1.7
>diff -w -u -3 -r1.7 ExprLexer.h
>--- ExprLexer.h	2001/05/12 11:59:51	1.7
>+++ ExprLexer.h	2001/06/15 10:34:30
>@@ -1,4 +1,4 @@
>-/*
>+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
>  * The contents of this file are subject to the Mozilla Public
>  * License Version 1.1 (the "License"); you may not use this file
>  * except in compliance with the License. You may obtain a copy of
>@@ -25,7 +25,6 @@
>  *    -- changed constant short declarations in Token and ExprLexer to
>  *       enumerations, commented with //--LF
>  * 
>- * $Id: ExprLexer.h,v 1.7 2001/05/12 11:59:51 peterv%netscape.com Exp $
>  */
> 
> 
>@@ -41,7 +40,6 @@
>  * This class was ported from XSL:P, an open source Java based 
>  * XSLT processor, written by yours truly.
>  * @author <a href="mailto:kvisco@ziplink.net">Keith Visco</a>
>- * @version $Revision: 1.7 $ $Date: 2001/05/12 11:59:51 $
> **/
> class Token {
> 
>@@ -60,48 +58,59 @@
>         LITERAL,
>         NUMBER,
>         CNAME,
>-        L_PAREN,
>-        R_PAREN,
>-        L_BRACKET,
>-        R_BRACKET,
>-        COMMA,
>         FUNCTION_NAME,
>-        AT_SIGN,
>         VAR_REFERENCE,
>         PARENT_NODE,
>         SELF_NODE,
>+        R_PAREN,
>+        R_BRACKET, // 10
>+        /**
>+         * start of tokens for 3.7, bullet 1
>+         * ExprLexer::nextIsOperatorToken bails if the tokens aren't
>+         * consecutive.
>+         **/
>+        COMMA,
>+        AT_SIGN,
>+        L_PAREN,
>+        L_BRACKET,
>         AXIS_IDENTIFIER,
>           //-------------/
>          //- operators -/
>         //-------------/
> 
>         //-- boolean ops
>-        AND_OP,
>+        AND_OP, // 16
>         OR_OP,
> 
>         //-- relational
>-        EQUAL_OP,
>+        EQUAL_OP, // 18
>         NOT_EQUAL_OP,
>         LESS_THAN_OP,
>         GREATER_THAN_OP,
>         LESS_OR_EQUAL_OP,
>         GREATER_OR_EQUAL_OP,
>         //-- additive operators
>-        ADDITION_OP,
>+        ADDITION_OP, // 24
>         SUBTRACTION_OP,
>         //-- multiplicative
>-        DIVIDE_OP ,
>+        DIVIDE_OP , // 26
>         MULTIPLY_OP,
>         MODULUS_OP,
>         //-- path operators
>-        PARENT_OP,
>+        PARENT_OP, // 29
>         ANCESTOR_OP,
>         UNION_OP,
>+        /**
>+         * end of tokens for 3.7, bullet 1 -/
>+         **/
>         //-- node type tokens
>-        COMMENT,
>+        COMMENT, // 32
>         NODE,
>         PROC_INST,
>-        TEXT
>+        TEXT,
>+        
>+        //-- Special endtoken
>+        END // 36
>     };
> 
> 
>@@ -166,6 +175,17 @@
>         TX_LF             = '\r'
>     };
> 
>+    enum _error_consts {
>+        ERROR_UNRESOLVED_VAR_REFERENCE = 0,
>+        ERROR_OP_EXPECTED,
>+        ERROR_UNCLOSED_LITERAL,
>+        ERROR_COLON,
>+        ERROR_BANG,
>+        ERROR_UNKNOWN_CHAR
>+    };
>+    static const String error_message[];
>+    Int32 errorPos;
>+    short errorCode;
> 
>     /*
>      * Complex Tokens
>@@ -197,31 +217,15 @@
> 
>     ~ExprLexer();
> 
>-    /**
>-     * Counts the total number of tokens in this Lexer, even if the token
>-     * has already been seen
>-     * @return the total number of tokens in this Lexer
>-    **/
>-    int countAllTokens();
>-
>     /**
>-     * Counts the remaining number of tokens in this Lexer
>-     * @return the number of remaining tokens in this Lexer
>+     * Functions for iterating over the TokenList
>     **/
>-    int countRemainingTokens();
> 
>-    /**
>-     * Returns the type of token that was last return by a call to nextToken
>-    **/
>-
>-    Token* lookAhead(int offset);
>     Token* nextToken();
>     Token* peek();
>     void   pushBack();
>     MBool  hasMoreTokens();
> 
>-    MBool isOperatorToken(Token* token);
>-
> private:
> 
>     struct TokenListItem {
>@@ -237,50 +241,36 @@
>     int tokenCount;
> 
>     Token* prevToken;
>+    Token endToken;
> 
>     void addToken(Token* token);
> 
>     /**
>-     * Returns true if the given character represents an Alpha letter
>+     * Returns true if the following Token should be an operator.
>+     * This is a helper for the first bullet of [XPath 3.7]
>+     *  Lexical Structure
>     **/
>-    static MBool isAlphaChar(Int32 ch);
>+    MBool nextIsOperatorToken(Token* token);
> 
>     /**
>-     * Returns true if the given character represents a numeric letter (digit)
>+     * Returns true if the given character represents an Alpha letter
>+     * Implemented in ExprLexerChars.cpp
>     **/
>-    static MBool isDigit(Int32 ch);
>+    static MBool isLetter(UNICODE_CHAR ch);
> 
>     /**
>-     * Returns true if the given character is an allowable QName character
>+     * Returns true if the given character represents a numeric letter (digit)
>+     * Implemented in ExprLexerChars.cpp
>     **/
>-    static MBool isQNameChar(Int32 ch);
>+    static MBool isDigit(UNICODE_CHAR ch);
> 
>     /**
>      * Returns true if the given character is an allowable NCName character
>+     * Implemented in ExprLexerChars.cpp
>     **/
>-    static MBool isNCNameChar(Int32 ch);
>-
>-    /**
>-     * Returns true if the given String is a valid XML QName
>-    **/
>-    static MBool isValidQName(String& name);
>-
>-    MBool matchDelimiter(UNICODE_CHAR ch);
>-
>-    /**
>-     * Returns true if the value of the given String matches
>-     * an OperatorName
>-    **/
>-    MBool matchesOperator(String& buffer);
>-
>-    /**
>-     * Matches the given String to the appropriate Token
>-     * @param buffer the current StringBuffer representing the value of the Token
>-     * @param ch, the current delimiter token
>-    **/
>-    void matchToken(String& buffer, UNICODE_CHAR ch);
>-
>+    static MBool isNCNameChar(UNICODE_CHAR ch);
> 
>+    String subStr;
>     void parse(const String& pattern);
> 
> }; //-- ExprLexer
>Index: source/xpath/ExprLexerChars.cpp
>===================================================================
>RCS file: ExprLexerChars.cpp
>diff -N ExprLexerChars.cpp
>--- /dev/null	Wed Apr 26 15:53:02 2000
>+++ ExprLexerChars.cpp	Fri Jun 15 03:34:30 2001
>@@ -0,0 +1,373 @@
>+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- 
>+ * The contents of this file are subject to the Mozilla Public
>+ * License Version 1.1 (the "License"); you may not use this file
>+ * except in compliance with the License. You may obtain a copy of
>+ * the License at http://www.mozilla.org/MPL/
>+ *
>+ * Software distributed under the License is distributed on an "AS
>+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
>+ * implied. See the License for the specific language governing
>+ * rights and limitations under the License.
>+ *
>+ * The Original Code is mozilla.org code.
>+ *
>+ * The Initial Developer of the Original Code is Axel Hecht.  Portions
>+ * created by Axel Hecht are Copyright (C) 2001 Axel Hecht. All
>+ * Rights Reserved.
>+ *
>+ * Contributor(s): 
>+ *   Axel Hecht <axel@pike.org> (Original Author)
>+ */
>+
>+#include "ExprLexer.h"
>+
>+// macros for inclusion of char range headers
>+#define TX_CHAR_RANGE(a,b) if (ch<a) return MB_FALSE; \
>+  if (ch<=b) return MB_TRUE
>+#define TX_MATCH_CHAR(a) if (ch<a) return MB_FALSE; \
>+  if (ch==a) return MB_TRUE
>+
>+/**
>+ * Returns true if the given character represents a numeric letter (digit)
>+**/
>+MBool ExprLexer::isDigit(UNICODE_CHAR ch)
>+{
>+  TX_CHAR_RANGE('0','9');
>+  return MB_FALSE;
>+} //-- isDigit
>+
>+/**
>+ * Returns true if the given character represents an Alpha letter
>+**/
>+MBool ExprLexer::isLetter(UNICODE_CHAR ch)
>+{
>+/* Letter = BaseChar | Ideographic; and _ */
>+  TX_CHAR_RANGE(0x0041,0x005A);
>+  TX_MATCH_CHAR(0x005F);        /* '_' */
>+  TX_CHAR_RANGE(0x0061,0x007A);
>+  TX_CHAR_RANGE(0x00C0,0x00D6);
>+  TX_CHAR_RANGE(0x00D8,0x00F6);
>+  TX_CHAR_RANGE(0x00F8,0x00FF);
>+  TX_CHAR_RANGE(0x0100,0x0131);
>+  TX_CHAR_RANGE(0x0134,0x013E);
>+  TX_CHAR_RANGE(0x0141,0x0148);
>+  TX_CHAR_RANGE(0x014A,0x017E);
>+  TX_CHAR_RANGE(0x0180,0x01C3);
>+  TX_CHAR_RANGE(0x01CD,0x01F0);
>+  TX_CHAR_RANGE(0x01F4,0x01F5);
>+  TX_CHAR_RANGE(0x01FA,0x0217);
>+  TX_CHAR_RANGE(0x0250,0x02A8);
>+  TX_CHAR_RANGE(0x02BB,0x02C1);
>+  TX_MATCH_CHAR(0x0386);
>+  TX_CHAR_RANGE(0x0388,0x038A);
>+  TX_MATCH_CHAR(0x038C);
>+  TX_CHAR_RANGE(0x038E,0x03A1);
>+  TX_CHAR_RANGE(0x03A3,0x03CE);
>+  TX_CHAR_RANGE(0x03D0,0x03D6);
>+  TX_MATCH_CHAR(0x03DA);
>+  TX_MATCH_CHAR(0x03DC);
>+  TX_MATCH_CHAR(0x03DE);
>+  TX_MATCH_CHAR(0x03E0);
>+  TX_CHAR_RANGE(0x03E2,0x03F3);
>+  TX_CHAR_RANGE(0x0401,0x040C);
>+  TX_CHAR_RANGE(0x040E,0x044F);
>+  TX_CHAR_RANGE(0x0451,0x045C);
>+  TX_CHAR_RANGE(0x045E,0x0481);
>+  TX_CHAR_RANGE(0x0490,0x04C4);
>+  TX_CHAR_RANGE(0x04C7,0x04C8);
>+  TX_CHAR_RANGE(0x04CB,0x04CC);
>+  TX_CHAR_RANGE(0x04D0,0x04EB);
>+  TX_CHAR_RANGE(0x04EE,0x04F5);
>+  TX_CHAR_RANGE(0x04F8,0x04F9);
>+  TX_CHAR_RANGE(0x0531,0x0556);
>+  TX_MATCH_CHAR(0x0559);
>+  TX_CHAR_RANGE(0x0561,0x0586);
>+  TX_CHAR_RANGE(0x05D0,0x05EA);
>+  TX_CHAR_RANGE(0x05F0,0x05F2);
>+  TX_CHAR_RANGE(0x0621,0x063A);
>+  TX_CHAR_RANGE(0x0641,0x064A);
>+  TX_CHAR_RANGE(0x0671,0x06B7);
>+  TX_CHAR_RANGE(0x06BA,0x06BE);
>+  TX_CHAR_RANGE(0x06C0,0x06CE);
>+  TX_CHAR_RANGE(0x06D0,0x06D3);
>+  TX_MATCH_CHAR(0x06D5);
>+  TX_CHAR_RANGE(0x06E5,0x06E6);
>+  TX_CHAR_RANGE(0x0905,0x0939);
>+  TX_MATCH_CHAR(0x093D);
>+  TX_CHAR_RANGE(0x0958,0x0961);
>+  TX_CHAR_RANGE(0x0985,0x098C);
>+  TX_CHAR_RANGE(0x098F,0x0990);
>+  TX_CHAR_RANGE(0x0993,0x09A8);
>+  TX_CHAR_RANGE(0x09AA,0x09B0);
>+  TX_MATCH_CHAR(0x09B2);
>+  TX_CHAR_RANGE(0x09B6,0x09B9);
>+  TX_CHAR_RANGE(0x09DC,0x09DD);
>+  TX_CHAR_RANGE(0x09DF,0x09E1);
>+  TX_CHAR_RANGE(0x09F0,0x09F1);
>+  TX_CHAR_RANGE(0x0A05,0x0A0A);
>+  TX_CHAR_RANGE(0x0A0F,0x0A10);
>+  TX_CHAR_RANGE(0x0A13,0x0A28);
>+  TX_CHAR_RANGE(0x0A2A,0x0A30);
>+  TX_CHAR_RANGE(0x0A32,0x0A33);
>+  TX_CHAR_RANGE(0x0A35,0x0A36);
>+  TX_CHAR_RANGE(0x0A38,0x0A39);
>+  TX_CHAR_RANGE(0x0A59,0x0A5C);
>+  TX_MATCH_CHAR(0x0A5E);
>+  TX_CHAR_RANGE(0x0A72,0x0A74);
>+  TX_CHAR_RANGE(0x0A85,0x0A8B);
>+  TX_MATCH_CHAR(0x0A8D);
>+  TX_CHAR_RANGE(0x0A8F,0x0A91);
>+  TX_CHAR_RANGE(0x0A93,0x0AA8);
>+  TX_CHAR_RANGE(0x0AAA,0x0AB0);
>+  TX_CHAR_RANGE(0x0AB2,0x0AB3);
>+  TX_CHAR_RANGE(0x0AB5,0x0AB9);
>+  TX_MATCH_CHAR(0x0ABD);
>+  TX_MATCH_CHAR(0x0AE0);
>+  TX_CHAR_RANGE(0x0B05,0x0B0C);
>+  TX_CHAR_RANGE(0x0B0F,0x0B10);
>+  TX_CHAR_RANGE(0x0B13,0x0B28);
>+  TX_CHAR_RANGE(0x0B2A,0x0B30);
>+  TX_CHAR_RANGE(0x0B32,0x0B33);
>+  TX_CHAR_RANGE(0x0B36,0x0B39);
>+  TX_MATCH_CHAR(0x0B3D);
>+  TX_CHAR_RANGE(0x0B5C,0x0B5D);
>+  TX_CHAR_RANGE(0x0B5F,0x0B61);
>+  TX_CHAR_RANGE(0x0B85,0x0B8A);
>+  TX_CHAR_RANGE(0x0B8E,0x0B90);
>+  TX_CHAR_RANGE(0x0B92,0x0B95);
>+  TX_CHAR_RANGE(0x0B99,0x0B9A);
>+  TX_MATCH_CHAR(0x0B9C);
>+  TX_CHAR_RANGE(0x0B9E,0x0B9F);
>+  TX_CHAR_RANGE(0x0BA3,0x0BA4);
>+  TX_CHAR_RANGE(0x0BA8,0x0BAA);
>+  TX_CHAR_RANGE(0x0BAE,0x0BB5);
>+  TX_CHAR_RANGE(0x0BB7,0x0BB9);
>+  TX_CHAR_RANGE(0x0C05,0x0C0C);
>+  TX_CHAR_RANGE(0x0C0E,0x0C10);
>+  TX_CHAR_RANGE(0x0C12,0x0C28);
>+  TX_CHAR_RANGE(0x0C2A,0x0C33);
>+  TX_CHAR_RANGE(0x0C35,0x0C39);
>+  TX_CHAR_RANGE(0x0C60,0x0C61);
>+  TX_CHAR_RANGE(0x0C85,0x0C8C);
>+  TX_CHAR_RANGE(0x0C8E,0x0C90);
>+  TX_CHAR_RANGE(0x0C92,0x0CA8);
>+  TX_CHAR_RANGE(0x0CAA,0x0CB3);
>+  TX_CHAR_RANGE(0x0CB5,0x0CB9);
>+  TX_MATCH_CHAR(0x0CDE);
>+  TX_CHAR_RANGE(0x0CE0,0x0CE1);
>+  TX_CHAR_RANGE(0x0D05,0x0D0C);
>+  TX_CHAR_RANGE(0x0D0E,0x0D10);
>+  TX_CHAR_RANGE(0x0D12,0x0D28);
>+  TX_CHAR_RANGE(0x0D2A,0x0D39);
>+  TX_CHAR_RANGE(0x0D60,0x0D61);
>+  TX_CHAR_RANGE(0x0E01,0x0E2E);
>+  TX_MATCH_CHAR(0x0E30);
>+  TX_CHAR_RANGE(0x0E32,0x0E33);
>+  TX_CHAR_RANGE(0x0E40,0x0E45);
>+  TX_CHAR_RANGE(0x0E81,0x0E82);
>+  TX_MATCH_CHAR(0x0E84);
>+  TX_CHAR_RANGE(0x0E87,0x0E88);
>+  TX_MATCH_CHAR(0x0E8A);
>+  TX_MATCH_CHAR(0x0E8D);
>+  TX_CHAR_RANGE(0x0E94,0x0E97);
>+  TX_CHAR_RANGE(0x0E99,0x0E9F);
>+  TX_CHAR_RANGE(0x0EA1,0x0EA3);
>+  TX_MATCH_CHAR(0x0EA5);
>+  TX_MATCH_CHAR(0x0EA7);
>+  TX_CHAR_RANGE(0x0EAA,0x0EAB);
>+  TX_CHAR_RANGE(0x0EAD,0x0EAE);
>+  TX_MATCH_CHAR(0x0EB0);
>+  TX_CHAR_RANGE(0x0EB2,0x0EB3);
>+  TX_MATCH_CHAR(0x0EBD);
>+  TX_CHAR_RANGE(0x0EC0,0x0EC4);
>+  TX_CHAR_RANGE(0x0F40,0x0F47);
>+  TX_CHAR_RANGE(0x0F49,0x0F69);
>+  TX_CHAR_RANGE(0x10A0,0x10C5);
>+  TX_CHAR_RANGE(0x10D0,0x10F6);
>+  TX_MATCH_CHAR(0x1100);
>+  TX_CHAR_RANGE(0x1102,0x1103);
>+  TX_CHAR_RANGE(0x1105,0x1107);
>+  TX_MATCH_CHAR(0x1109);
>+  TX_CHAR_RANGE(0x110B,0x110C);
>+  TX_CHAR_RANGE(0x110E,0x1112);
>+  TX_MATCH_CHAR(0x113C);
>+  TX_MATCH_CHAR(0x113E);
>+  TX_MATCH_CHAR(0x1140);
>+  TX_MATCH_CHAR(0x114C);
>+  TX_MATCH_CHAR(0x114E);
>+  TX_MATCH_CHAR(0x1150);
>+  TX_CHAR_RANGE(0x1154,0x1155);
>+  TX_MATCH_CHAR(0x1159);
>+  TX_CHAR_RANGE(0x115F,0x1161);
>+  TX_MATCH_CHAR(0x1163);
>+  TX_MATCH_CHAR(0x1165);
>+  TX_MATCH_CHAR(0x1167);
>+  TX_MATCH_CHAR(0x1169);
>+  TX_CHAR_RANGE(0x116D,0x116E);
>+  TX_CHAR_RANGE(0x1172,0x1173);
>+  TX_MATCH_CHAR(0x1175);
>+  TX_MATCH_CHAR(0x119E);
>+  TX_MATCH_CHAR(0x11A8);
>+  TX_MATCH_CHAR(0x11AB);
>+  TX_CHAR_RANGE(0x11AE,0x11AF);
>+  TX_CHAR_RANGE(0x11B7,0x11B8);
>+  TX_MATCH_CHAR(0x11BA);
>+  TX_CHAR_RANGE(0x11BC,0x11C2);
>+  TX_MATCH_CHAR(0x11EB);
>+  TX_MATCH_CHAR(0x11F0);
>+  TX_MATCH_CHAR(0x11F9);
>+  TX_CHAR_RANGE(0x1E00,0x1E9B);
>+  TX_CHAR_RANGE(0x1EA0,0x1EF9);
>+  TX_CHAR_RANGE(0x1F00,0x1F15);
>+  TX_CHAR_RANGE(0x1F18,0x1F1D);
>+  TX_CHAR_RANGE(0x1F20,0x1F45);
>+  TX_CHAR_RANGE(0x1F48,0x1F4D);
>+  TX_CHAR_RANGE(0x1F50,0x1F57);
>+  TX_MATCH_CHAR(0x1F59);
>+  TX_MATCH_CHAR(0x1F5B);
>+  TX_MATCH_CHAR(0x1F5D);
>+  TX_CHAR_RANGE(0x1F5F,0x1F7D);
>+  TX_CHAR_RANGE(0x1F80,0x1FB4);
>+  TX_CHAR_RANGE(0x1FB6,0x1FBC);
>+  TX_MATCH_CHAR(0x1FBE);
>+  TX_CHAR_RANGE(0x1FC2,0x1FC4);
>+  TX_CHAR_RANGE(0x1FC6,0x1FCC);
>+  TX_CHAR_RANGE(0x1FD0,0x1FD3);
>+  TX_CHAR_RANGE(0x1FD6,0x1FDB);
>+  TX_CHAR_RANGE(0x1FE0,0x1FEC);
>+  TX_CHAR_RANGE(0x1FF2,0x1FF4);
>+  TX_CHAR_RANGE(0x1FF6,0x1FFC);
>+  TX_MATCH_CHAR(0x2126);
>+  TX_CHAR_RANGE(0x212A,0x212B);
>+  TX_MATCH_CHAR(0x212E);
>+  TX_CHAR_RANGE(0x2180,0x2182);
>+  TX_MATCH_CHAR(0x3007);
>+  TX_CHAR_RANGE(0x3021,0x3029);
>+  TX_CHAR_RANGE(0x3041,0x3094);
>+  TX_CHAR_RANGE(0x30A1,0x30FA);
>+  TX_CHAR_RANGE(0x3105,0x312C);
>+  TX_CHAR_RANGE(0x4E00,0x9FA5);
>+  TX_CHAR_RANGE(0xAC00,0xD7A3);
>+  return MB_FALSE;
>+} //-- isAlphaChar
>+
>+/**
>+ * Returns true if the given character is an allowable NCName character
>+**/
>+MBool ExprLexer::isNCNameChar(UNICODE_CHAR ch)
>+{
>+/* NCNameChar = Letter | Digit ('0'-'9') | '.' | '-' | '_'  | 
>+   CombiningChar | Extender */
>+  if (isLetter(ch)) return MB_TRUE;  /* Letter | '_' */
>+
>+  TX_CHAR_RANGE(0x002D,0x002E);  /* '-' | '.' */
>+  TX_CHAR_RANGE(0x0030,0x0039);  /* Digit */
>+  TX_MATCH_CHAR(0x00B7);
>+  TX_MATCH_CHAR(0x02D0);
>+  TX_MATCH_CHAR(0x02D1);
>+  TX_CHAR_RANGE(0x0300,0x0345);
>+  TX_CHAR_RANGE(0x0360,0x0361);
>+  TX_MATCH_CHAR(0x0387);
>+  TX_CHAR_RANGE(0x0483,0x0486);
>+  TX_CHAR_RANGE(0x0591,0x05A1);
>+  TX_CHAR_RANGE(0x05A3,0x05B9);
>+  TX_CHAR_RANGE(0x05BB,0x05BD);
>+  TX_MATCH_CHAR(0x05BF);
>+  TX_CHAR_RANGE(0x05C1,0x05C2);
>+  TX_MATCH_CHAR(0x05C4);
>+  TX_MATCH_CHAR(0x0640);
>+  TX_CHAR_RANGE(0x064B,0x0652);
>+  TX_MATCH_CHAR(0x0670);
>+  TX_CHAR_RANGE(0x06D6,0x06DC);
>+  TX_CHAR_RANGE(0x06DD,0x06DF);
>+  TX_CHAR_RANGE(0x06E0,0x06E4);
>+  TX_CHAR_RANGE(0x06E7,0x06E8);
>+  TX_CHAR_RANGE(0x06EA,0x06ED);
>+  TX_CHAR_RANGE(0x0901,0x0903);
>+  TX_MATCH_CHAR(0x093C);
>+  TX_CHAR_RANGE(0x093E,0x094C);
>+  TX_MATCH_CHAR(0x094D);
>+  TX_CHAR_RANGE(0x0951,0x0954);
>+  TX_CHAR_RANGE(0x0962,0x0963);
>+  TX_CHAR_RANGE(0x0981,0x0983);
>+  TX_MATCH_CHAR(0x09BC);
>+  TX_MATCH_CHAR(0x09BE);
>+  TX_MATCH_CHAR(0x09BF);
>+  TX_CHAR_RANGE(0x09C0,0x09C4);
>+  TX_CHAR_RANGE(0x09C7,0x09C8);
>+  TX_CHAR_RANGE(0x09CB,0x09CD);
>+  TX_MATCH_CHAR(0x09D7);
>+  TX_CHAR_RANGE(0x09E2,0x09E3);
>+  TX_MATCH_CHAR(0x0A02);
>+  TX_MATCH_CHAR(0x0A3C);
>+  TX_MATCH_CHAR(0x0A3E);
>+  TX_MATCH_CHAR(0x0A3F);
>+  TX_CHAR_RANGE(0x0A40,0x0A42);
>+  TX_CHAR_RANGE(0x0A47,0x0A48);
>+  TX_CHAR_RANGE(0x0A4B,0x0A4D);
>+  TX_CHAR_RANGE(0x0A70,0x0A71);
>+  TX_CHAR_RANGE(0x0A81,0x0A83);
>+  TX_MATCH_CHAR(0x0ABC);
>+  TX_CHAR_RANGE(0x0ABE,0x0AC5);
>+  TX_CHAR_RANGE(0x0AC7,0x0AC9);
>+  TX_CHAR_RANGE(0x0ACB,0x0ACD);
>+  TX_CHAR_RANGE(0x0B01,0x0B03);
>+  TX_MATCH_CHAR(0x0B3C);
>+  TX_CHAR_RANGE(0x0B3E,0x0B43);
>+  TX_CHAR_RANGE(0x0B47,0x0B48);
>+  TX_CHAR_RANGE(0x0B4B,0x0B4D);
>+  TX_CHAR_RANGE(0x0B56,0x0B57);
>+  TX_CHAR_RANGE(0x0B82,0x0B83);
>+  TX_CHAR_RANGE(0x0BBE,0x0BC2);
>+  TX_CHAR_RANGE(0x0BC6,0x0BC8);
>+  TX_CHAR_RANGE(0x0BCA,0x0BCD);
>+  TX_MATCH_CHAR(0x0BD7);
>+  TX_CHAR_RANGE(0x0C01,0x0C03);
>+  TX_CHAR_RANGE(0x0C3E,0x0C44);
>+  TX_CHAR_RANGE(0x0C46,0x0C48);
>+  TX_CHAR_RANGE(0x0C4A,0x0C4D);
>+  TX_CHAR_RANGE(0x0C55,0x0C56);
>+  TX_CHAR_RANGE(0x0C82,0x0C83);
>+  TX_CHAR_RANGE(0x0CBE,0x0CC4);
>+  TX_CHAR_RANGE(0x0CC6,0x0CC8);
>+  TX_CHAR_RANGE(0x0CCA,0x0CCD);
>+  TX_CHAR_RANGE(0x0CD5,0x0CD6);
>+  TX_CHAR_RANGE(0x0D02,0x0D03);
>+  TX_CHAR_RANGE(0x0D3E,0x0D43);
>+  TX_CHAR_RANGE(0x0D46,0x0D48);
>+  TX_CHAR_RANGE(0x0D4A,0x0D4D);
>+  TX_MATCH_CHAR(0x0D57);
>+  TX_MATCH_CHAR(0x0E31);
>+  TX_CHAR_RANGE(0x0E34,0x0E3A);
>+  TX_MATCH_CHAR(0x0E46);
>+  TX_CHAR_RANGE(0x0E47,0x0E4E);
>+  TX_MATCH_CHAR(0x0EB1);
>+  TX_CHAR_RANGE(0x0EB4,0x0EB9);
>+  TX_CHAR_RANGE(0x0EBB,0x0EBC);
>+  TX_MATCH_CHAR(0x0EC6);
>+  TX_CHAR_RANGE(0x0EC8,0x0ECD);
>+  TX_CHAR_RANGE(0x0F18,0x0F19);
>+  TX_MATCH_CHAR(0x0F35);
>+  TX_MATCH_CHAR(0x0F37);
>+  TX_MATCH_CHAR(0x0F39);
>+  TX_MATCH_CHAR(0x0F3E);
>+  TX_MATCH_CHAR(0x0F3F);
>+  TX_CHAR_RANGE(0x0F71,0x0F84);
>+  TX_CHAR_RANGE(0x0F86,0x0F8B);
>+  TX_CHAR_RANGE(0x0F90,0x0F95);
>+  TX_MATCH_CHAR(0x0F97);
>+  TX_CHAR_RANGE(0x0F99,0x0FAD);
>+  TX_CHAR_RANGE(0x0FB1,0x0FB7);
>+  TX_MATCH_CHAR(0x0FB9);
>+  TX_CHAR_RANGE(0x20D0,0x20DC);
>+  TX_MATCH_CHAR(0x20E1);
>+  TX_MATCH_CHAR(0x3005);
>+  TX_CHAR_RANGE(0x302A,0x302F);
>+  TX_CHAR_RANGE(0x3031,0x3035);
>+  TX_MATCH_CHAR(0x3099);
>+  TX_MATCH_CHAR(0x309A);
>+  TX_CHAR_RANGE(0x309D,0x309E);
>+  TX_CHAR_RANGE(0x30FC,0x30FE);
>+  return MB_FALSE;
>+} //-- isNCNameChar
>+
>Index: source/xpath/ExprParser.cpp
>===================================================================
>RCS file: /cvsroot/mozilla/extensions/transformiix/source/xpath/ExprParser.cpp,v
>retrieving revision 1.11
>diff -w -u -3 -r1.11 ExprParser.cpp
>--- ExprParser.cpp	2001/05/12 11:59:59	1.11
>+++ ExprParser.cpp	2001/06/15 10:34:31
>@@ -1,4 +1,4 @@
>-/*
>+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
>  * The contents of this file are subject to the Mozilla Public
>  * License Version 1.1 (the "License"); you may not use this file
>  * except in compliance with the License. You may obtain a copy of
>@@ -45,9 +45,6 @@
> #include "FunctionLib.h"
> #include "Names.h"
> 
>-const String ExprParser::L_CURLY_BRACE = "{";
>-const String ExprParser::R_CURLY_BRACE = "}";
>-
> /**
>  * Creates a new ExprParser
> **/
>@@ -60,86 +57,101 @@
> 
> /**
>  * Creates an Attribute Value Template using the given value
>+ * This should move to XSLProcessor class
> **/
> AttributeValueTemplate* ExprParser::createAttributeValueTemplate
>     (const String& attValue)
> {
> 
>     AttributeValueTemplate* avt = new AttributeValueTemplate();
>+
>     Int32 size = attValue.length();
>+    if ( size == 0) return avt; //XXX should return 0, but that causes crash in lre12
>+
>     int cc = 0;
>+    UNICODE_CHAR nextCh;
>+    UNICODE_CHAR ch;
>     String buffer;
>     MBool inExpr    = MB_FALSE;
>     MBool inLiteral = MB_FALSE;
>-    UNICODE_CHAR endLiteral = '"';
>-    UNICODE_CHAR prevCh = '\0';
>+    UNICODE_CHAR endLiteral;
> 
>-    while ( cc < size) {
>-        UNICODE_CHAR ch = attValue.charAt(cc++);
>+    nextCh = attValue.charAt(cc);
>+    while ( cc++ < size) {
>+        ch = nextCh;
>+        nextCh = cc != size ? attValue.charAt(cc) : 0;
>+        
>         // if in literal just add ch to buffer
>         if ( inLiteral && (ch != endLiteral) ) {
>                 buffer.append(ch);
>-                prevCh = ch;
>                 continue;
>         }
>         switch ( ch ) {
>             case '\'' :
>             case '"' :
>                 buffer.append(ch);
>-                if (inLiteral) inLiteral = MB_FALSE;
>-                else {
>+                if (inLiteral)
>+                    inLiteral = MB_FALSE;
>+                else if (inExpr) {
>                     inLiteral = MB_TRUE;
>                     endLiteral = ch;
>                 }
>                 break;
>             case  '{' :
>-                // Ignore case where we find two { without a }
>                 if (!inExpr) {
>-                    //-- clear buffer
>-                    if ( buffer.length() > 0) {
>+                    // Ignore case where we find two {
>+                    if ( nextCh == ch ) {
>+                        buffer.append(ch); //-- append '{'
>+                        cc++;
>+                        nextCh = cc != size ? attValue.charAt(cc) : 0;
>+                    }
>+                    else {
>+                        if ( buffer.length() > 0)
>                         avt->addExpr(new StringExpr(buffer));
>                         buffer.clear();
>-                    }
>                     inExpr = MB_TRUE;
>                 }
>-                else if (prevCh == ch) {
>-                    inExpr = MB_FALSE;
>-                    buffer.append(ch);
>                 }
>-                else {
>+                else
>                     buffer.append(ch); //-- simply append '{'
>-                    ch = '\0';
>-                }
>                 break;
>             case '}':
>                 if (inExpr) {
>                     inExpr = MB_FALSE;
>-                    avt->addExpr(createExpr(buffer));
>+                    Expr* expr = createExpr(buffer);
>+                    if (!expr) {
>+                        delete avt;
>+                        return 0;
>+                    }
>+                    avt->addExpr(expr);
>                     buffer.clear();
>-                    //-- change in case another '}' follows
>-                    ch = '\0';
>                 }
>-                else if (prevCh != ch) {
>-                    if ( buffer.length() > 0) buffer.append('}');
>-                    else avt->addExpr(new StringExpr(R_CURLY_BRACE));
>+                else if (nextCh == ch) {
>+                    buffer.append(ch);
>+                    cc++;
>+                    nextCh = cc != size ? attValue.charAt(cc) : 0;
>+                }
>+                else {
>+                    //XXX ErrorReport: unmatched '}' found
>+                    delete avt;
>+                    return 0;
>                 }
>                 break;
>             default:
>                 buffer.append(ch);
>                 break;
>         }
>-        prevCh = ch;
>     }
>-    if ( buffer.length() > 0) {
>+
>         if ( inExpr ) {
>-            //-- error
>-            String errMsg("#error evaluating AttributeValueTemplate. ");
>-            errMsg.append("Missing '}' after: ");
>-            errMsg.append(buffer);
>-            avt->addExpr(new StringExpr(errMsg));
>-        }
>-        else avt->addExpr(new StringExpr(buffer));
>+        //XXX ErrorReport: ending '}' missing
>+        delete avt;
>+        return 0;
>     }
>+
>+    if ( buffer.length() > 0)
>+        avt->addExpr(new StringExpr(buffer));
>+
>     return avt;
> 
> } //-- createAttributeValueTemplate
>@@ -149,9 +161,10 @@
>     return createExpr(lexer);
> } //-- createExpr
> 
>-PatternExpr* ExprParser::createPatternExpr(const String& pattern) {
>+Expr* ExprParser::createPatternExpr(const String& pattern) {
>     ExprLexer lexer(pattern);
>-    return createUnionExpr(lexer);
>+    Expr* expr = createUnionExpr(lexer);
>+    return expr;
> } //-- createPatternExpr
> 
> LocationStep* ExprParser::createLocationStep(const String& path) {
>@@ -225,67 +238,23 @@
>     Stack exprs;
>     Stack ops;
> 
>-    while ( lexer.hasMoreTokens() && (!done)) {
>+    while ( !done ) {
> 
>-        Token* tok = lexer.nextToken();
>-        switch ( tok->type ) {
>-            case Token::L_BRACKET: // Predicate starts here
>-            case Token::R_BRACKET:
>-            case Token::R_PAREN:
>-            case Token::COMMA :
>-                lexer.pushBack();
>-                done = MB_TRUE;
>-                break;
>-            case Token::L_PAREN: //-- Grouping Expression
>-                expr = createExpr(lexer);
>-                //-- look for end ')'
>-                if ( lexer.hasMoreTokens() &&
>-                        ( lexer.nextToken()->type == Token::R_PAREN ) ) break;
>-                else {
>-                    //-- error
>-                    delete expr;
>-                    expr = new StringExpr("missing ')' in expression");
>-                }
>-                break;
>-            case Token::ANCESTOR_OP:
>-            case Token::PARENT_OP:
>-                lexer.pushBack();
>-                if ( !expr ) expr = createPathExpr(lexer);
>-                else {
>-                    PathExpr* pathExpr = createPathExpr(lexer);
>-                    pathExpr->addPatternExpr(0, (PatternExpr*)expr,
>-                                                 PathExpr::RELATIVE_OP);
>-                    expr = pathExpr;
>-                }
>-                //done = MB_TRUE;
>-                break;
>-            case Token::UNION_OP :
>-            {
>-                UnionExpr* unionExpr = createUnionExpr(lexer);
>-                unionExpr->addPathExpr(0, (PathExpr*)expr );
>-                expr = unionExpr;
>-                done = MB_TRUE;
>-                break;
>-            }
>-            case Token::LITERAL :
>-                expr = new StringExpr(tok->value);
>-                break;
>-            case Token::NUMBER:
>-            {
>-                StringResult str(tok->value);
>-                expr = new NumberExpr(str.numberValue());
>-                break;
>-            }
>-            case Token::FUNCTION_NAME:
>-            {
>-                lexer.pushBack();
>-                expr = createFunctionCall(lexer);
>-                break;
>+        MBool unary = MB_FALSE;
>+        while( lexer.peek()->type == Token::SUBTRACTION_OP ) {
>+            unary = !unary;
>+            lexer.nextToken();
>             }
>-            case Token::VAR_REFERENCE:
>-                expr = new VariableRefExpr(tok->value);
>+
>+        expr = createUnionExpr(lexer);
>+        if ( !expr )
>                 break;
>-            //-- additive ops
>+
>+        if ( unary )
>+            expr = new UnaryExpr(expr);
>+
>+        Token* tok = lexer.nextToken();
>+        switch ( tok->type ) {
>             case Token::ADDITION_OP:
>             case Token::DIVIDE_OP:
>             //-- boolean ops
>@@ -304,28 +273,30 @@
>             case Token::MULTIPLY_OP:
>             case Token::SUBTRACTION_OP:
>             {
>-                if ( !exprs.empty() ) {
>-                    short ttype = ((Token*)ops.peek())->type;
>-                    if (precedenceLevel(tok->type) < precedenceLevel(ttype)) {
>-                        expr = createBinaryExpr((Expr*)exprs.pop(), expr,
>+                while ( !exprs.empty() &&
>+                        precedenceLevel(tok->type) <= precedenceLevel(((Token*)ops.peek())->type)) {
>+                    expr = createBinaryExpr((Expr*)exprs.pop(),
>+                                             expr,
>                             (Token*)ops.pop());
>                     }
>-                }
>                 exprs.push(expr);
>                 ops.push(tok);
>-                expr = 0; // OG, prevent reuse of expr
>                 break;
>             }
>             default:
>                 lexer.pushBack();
>-                expr = createPatternExpr(lexer);
>+                done = MB_TRUE;
>                 break;
>         }
>     }
> 
>-    // make sure expr != 0, will this happen?
>-    if (( expr == 0 ) && (!exprs.empty()))
>-        expr = (Expr*) exprs.pop();
>+    // make sure expr != 0
>+    if ( expr == 0 ) {
>+        while (!exprs.empty() ) {
>+            delete (Expr*)exprs.pop();
>+        }
>+        return 0;
>+    }
> 
>     while (!exprs.empty() ) {
>         expr = createBinaryExpr((Expr*)exprs.pop(), expr, (Token*)ops.pop());
>@@ -335,67 +306,73 @@
> 
> } //-- createExpr
> 
>-FilterExpr*  ExprParser::createFilterExpr(ExprLexer& lexer) {
>+Expr* ExprParser::createFilterExpr(ExprLexer& lexer) {
> 
>-    FilterExpr* filterExpr = new FilterExpr();
>     Token* tok = lexer.nextToken();
>-    if ( !tok ) return filterExpr;
> 
>     Expr* expr = 0;
>     switch ( tok->type ) {
>         case Token::FUNCTION_NAME :
>+            lexer.pushBack();
>             expr = createFunctionCall(lexer);
>-            filterExpr->setExpr(expr);
>             break;
>         case Token::VAR_REFERENCE :
>             expr = new VariableRefExpr(tok->value);
>-            filterExpr->setExpr(expr);
>             break;
>         case Token::L_PAREN:
>-            //-- primary group expr:
>             expr = createExpr(lexer);
>-            tok = lexer.nextToken();
>-            if ( (!tok) || (tok->type != Token::R_PAREN ) ) {
>-                String errMsg("error: ");
>-                expr->toString(errMsg);
>-                errMsg.append(" - missing ')'");
>-                delete expr; //-- free up current expr
>-                expr = new ErrorFunctionCall(errMsg);
>+            if(!expr) return 0;
>+
>+            if ( lexer.nextToken()->type != Token::R_PAREN ) {
>+                lexer.pushBack();
>+                //XXX ErrorReport: right parenthesis expected
>+                delete expr;
>+                return 0;
>             }
>-            filterExpr->setExpr(expr);
>             break;
>-        case Token::PARENT_NODE :
>-            expr = new ParentExpr();
>-            filterExpr->setExpr(expr);
>+        case Token::LITERAL :
>+            expr = new StringExpr(tok->value);
>             break;
>-        case Token::SELF_NODE :
>-            expr = new IdentityExpr();
>-            filterExpr->setExpr(expr);
>+        case Token::NUMBER:
>+        {
>+            StringResult str(tok->value);
>+            expr = new NumberExpr(str.numberValue());
>             break;
>+        }
>         default:
>+            // this should never ever happen.
>+            lexer.pushBack();
>+            //XXX ErrorReport: error in parser, please report on bugzilla.mozilla.org
>+            return 0;
>             break;
>     }
>+    if(!expr) return 0;
>+
>+    if ( lexer.peek()->type == Token::L_BRACKET ) {
> 
>+        FilterExpr* filterExpr = new FilterExpr();
>+        filterExpr->setExpr(expr);
>+
>     //-- handle predicates
>-    parsePredicates(filterExpr, lexer);
>+        if(!parsePredicates(filterExpr, lexer)) {
>+            delete filterExpr;
>+            return 0;
>+        }
>+        expr = filterExpr;
>+    }
> 
>-    return filterExpr;
>+    return expr;
> 
> } //-- createFilterExpr
> 
> FunctionCall* ExprParser::createFunctionCall(ExprLexer& lexer) {
> 
>-    if ( !lexer.hasMoreTokens() ) {
>-        //-- should never see this, I hope
>-        return new ErrorFunctionCall("no tokens, invalid function call");
>-    }
>-
>     FunctionCall* fnCall = 0;
> 
>     Token* tok = lexer.nextToken();
>-
>     if ( tok->type != Token::FUNCTION_NAME ) {
>-        return new ErrorFunctionCall("invalid function call");
>+        //XXX ErrorReport: error in parser, please report on bugzilla.mozilla.org
>+        return 0;
>     }
> 
>     String fnName = tok->value;
>@@ -491,22 +468,11 @@
>         //-- not our job to report an invalid function call here
>         fnCall = new ExtensionFunctionCall(fnName);
>     }
>+    
>     //-- handle parametes
>-    List params;
>-    String* errMsg = parseParameters(&params, lexer);
>-    if (errMsg) {
>-        String err("error with function call, \"");
>-        err.append(fnName);
>-        err.append("\" : ");
>-        err.append(*errMsg);
>-        fnCall = new ErrorFunctionCall(err);
>-        delete errMsg;
>-    }
>-    // copy params
>-    else if (params.getLength() > 0) {
>-        ListIterator* iter = params.iterator();
>-        while ( iter->hasNext() ) fnCall->addParam( (Expr*)iter->next() );
>-        delete iter;
>+    if(!parseParameters(fnCall, lexer)) {
>+        delete fnCall;
>+        return 0;
>     }
>     return fnCall;
> } //-- createFunctionCall
>@@ -514,9 +480,12 @@
> LocationStep* ExprParser::createLocationStep(ExprLexer& lexer) {
> 
>     LocationStep* lstep = new LocationStep();
>+
>+    //-- child axis is default
>     short axisIdentifier = LocationStep::CHILD_AXIS;
>+    NodeExpr* nodeExpr = 0;
> 
>-    //-- get Axis Identifier, if present
>+    //-- get Axis Identifier or AbbreviatedStep, if present
>     Token* tok = lexer.peek();
>     switch (tok->type) {
>         case Token::AXIS_IDENTIFIER:
>@@ -550,11 +519,10 @@
>                 axisIdentifier = LocationStep::PRECEDING_SIBLING_AXIS;
>             else if ( SELF_AXIS.isEqual(tok->value) )
>                 axisIdentifier = LocationStep::SELF_AXIS;
>-            //-- child axis is default
>-            else if (!CHILD_AXIS.isEqual(tok->value)) {
>-                //-- handle error gracefully, simply ignore invalid axis and
>-                //-- use default. Add error message when message observer
>-                //-- is implemented
>+            else {
>+                delete lstep;
>+                //XXX ErrorReport: unknow axis
>+                return 0;
>             }
>             break;
>         }
>@@ -563,49 +531,53 @@
>             lexer.nextToken();
>             axisIdentifier = LocationStep::ATTRIBUTE_AXIS;
>             break;
>+        case Token::PARENT_NODE :
>+            //-- eat token
>+            lexer.nextToken();
>+            axisIdentifier = LocationStep::PARENT_AXIS;
>+            nodeExpr = new BasicNodeExpr();
>+            break;
>+        case Token::SELF_NODE :
>+            //-- eat token
>+            lexer.nextToken();
>+            axisIdentifier = LocationStep::SELF_AXIS;
>+            nodeExpr = new BasicNodeExpr();
>+            break;
>         default:
>             break;
>     }
> 
>-    lstep->setAxisIdentifier(axisIdentifier);
>-
>-
>-    NodeExpr* nodeExpr = 0;
>+    //-- get NodeTest unless AbbreviatedStep was found
>+    if ( !nodeExpr ) {
>+        tok = lexer.nextToken();
> 
>-    tok = lexer.peek();
>-    if (!tok) {
>-        ///XXXXX We need to create an ErrorExpr or something to
>-        ///XXXXX handle errors
>-    }
>+        switch(tok->type) {
>+            case Token::CNAME :
>     // NameTest
>-    else if (tok->type == Token::CNAME) {
>-        //-- handle NameTest
>-        //-- eat token
>-        lexer.nextToken();
>+                // XXX Namespace: handle namespaces here
>         if (axisIdentifier ==  LocationStep::ATTRIBUTE_AXIS)
>             nodeExpr = new AttributeExpr(tok->value);
>         else
>             nodeExpr = new ElementExpr(tok->value);
>-
>-    }
>-    // NodeType
>-    else {
>+                break;
>+            default:
>+                lexer.pushBack();
>        nodeExpr = createNodeExpr(lexer);
>+                if(!nodeExpr) {
>+                    delete lstep;
>+                    return 0;
>+                }
>     }
>+    }
> 
>+    lstep->setAxisIdentifier(axisIdentifier);
>     lstep->setNodeExpr(nodeExpr);
> 
>-
>-
>     //-- handle predicates
>-
>-    parsePredicates(lstep, lexer);
>-
>-    //<debug>
>-    //String tmp;
>-    //lstep->toString(tmp);
>-    //cout << "returning LocationStep: "<< tmp <<endl;
>-    //</debug>
>+    if(!parsePredicates(lstep, lexer)) {
>+        delete lstep;
>+        return 0;
>+    }
> 
>     return lstep;
> } //-- createLocationPath
>@@ -616,48 +588,48 @@
> **/
> NodeExpr* ExprParser::createNodeExpr(ExprLexer& lexer) {
> 
>-    //cout << "creating NodeExpr: "<<endl;
>-    if (!lexer.hasMoreTokens() )  cout << "Lexer has no Tokens"<<endl;
>-
>-    if (!lexer.hasMoreTokens() )  return 0;
>-
>     NodeExpr* nodeExpr = 0;
>-
>-    Token* tok = lexer.nextToken();
>-    //cout << "Token #" << tok->type <<endl;
>-    List params;
> 
>-    String* errMsg = 0;
>+    Token* nodeTok = lexer.nextToken();
> 
>-    switch ( tok->type ) {
>+    switch ( nodeTok->type ) {
>         case Token::COMMENT:
>             nodeExpr = new BasicNodeExpr(NodeExpr::COMMENT_EXPR);
>-            errMsg = parseParameters(&params, lexer);
>-            //-- ignore errMsg for now
>-            delete errMsg;
>             break;
>         case Token::NODE :
>             nodeExpr = new BasicNodeExpr();
>-            errMsg = parseParameters(&params, lexer);
>-            //-- ignore errMsg for now
>-            delete errMsg;
>             break;
>         case Token::PROC_INST :
>             nodeExpr = new BasicNodeExpr(NodeExpr::PI_EXPR);
>-            errMsg = parseParameters(&params, lexer);
>-            //-- ignore errMsg for now
>-            delete errMsg;
>             break;
>         case Token::TEXT :
>             nodeExpr = new TextExpr();
>-            errMsg = parseParameters(&params, lexer);
>-            //-- ignore errMsg for now
>-            delete errMsg;
>             break;
>         default:
>-            //XXXX ignore error for now
>+            lexer.pushBack();
>+            // XXX ErrorReport: unexpected token
>+            return 0;
>             break;
>     }
>+
>+    if ( lexer.nextToken()->type != Token::L_PAREN ) {
>+        lexer.pushBack();
>+        //XXX ErrorReport: left parenthesis expected
>+        delete nodeExpr;
>+        return 0;
>+    }
>+    if ( nodeTok->type == Token::PROC_INST &&
>+         lexer.peek()->type == Token::LITERAL ) {
>+        Token* tok = lexer.nextToken();
>+        ((BasicNodeExpr*)nodeExpr)->setNodeName(tok->value);
>+    }
>+    if ( lexer.nextToken()->type != Token::R_PAREN ) {
>+        lexer.pushBack();
>+        //XXX ErrorReport: right parenthesis expected (or literal for pi)
>+        delete nodeExpr;
>+        return 0;
>+    }
>+
>     return nodeExpr;
> } //-- createNodeExpr
> 
>@@ -665,37 +637,51 @@
>  * Creates a PathExpr using the given ExprLexer
>  * @param lexer the ExprLexer for retrieving Tokens
> **/
>-PathExpr* ExprParser::createPathExpr(ExprLexer& lexer) {
>+Expr* ExprParser::createPathExpr(ExprLexer& lexer) {
> 
>+    Expr* expr = 0;
> 
>-    //-- check for RootExpr
>-    if ( lexer.countRemainingTokens() == 1 ) {
>-        if ( lexer.peek()->type == Token::PARENT_OP ) {
>-            lexer.nextToken(); //-- eat token
>-            return new RootExpr();
>+    Token* tok = lexer.peek();
>+
>+    // is this a root expression?
>+    if ( tok->type == Token::PARENT_OP ) {
>+        lexer.nextToken();
>+        if ( !isLocationStepToken(lexer.peek()) )
>+            return new RootExpr;
>+
>+        lexer.pushBack();
>         }
>+
>+    // parse first step (possibly a FilterExpr)
>+    if ( tok->type != Token::PARENT_OP &&
>+         tok->type != Token::ANCESTOR_OP ) {
>+        if ( isFilterExprToken(tok) ) {
>+            expr = createFilterExpr(lexer);
>     }
>+        else
>+            expr = createLocationStep(lexer);
> 
>-    PathExpr* pathExpr = new PathExpr();
>-    short ancestryOp = PathExpr::RELATIVE_OP;
>+        if ( !expr ) {
>+            return 0;
>+        }
> 
>-    while ( lexer.hasMoreTokens() ) {
>-        Token* tok = lexer.nextToken();
>-        if ( lexer.isOperatorToken(tok) ) {
>-            lexer.pushBack();
>-            return pathExpr;
>+        // is this a singlestep path expression?
>+        tok = lexer.peek();
>+        if ( tok->type != Token::PARENT_OP &&
>+             tok->type != Token::ANCESTOR_OP)
>+            return expr;
>         }
>+    
>+    //we have a pathexpression containing several steps
>+    PathExpr* pathExpr = new PathExpr();
>+    if(expr)
>+        pathExpr->addExpr(expr, PathExpr::RELATIVE_OP);
>+
>+    // this is ugly
>+    while (1) {
>+        short ancestryOp;
>+        tok = lexer.nextToken();
>         switch ( tok->type ) {
>-            case Token::R_PAREN:
>-            case Token::R_BRACKET:
>-            case Token::UNION_OP:
>-                //Marina, addition start
>-                // When parsing a list of parameters for a function comma should signal a spot
>-                // without it further processing pathExpr was causing "invalid token" error
>-            case Token::COMMA:
>-                // Marina, addition ends
>-                lexer.pushBack();
>-                return pathExpr;
>             case Token::ANCESTOR_OP :
>                 ancestryOp = PathExpr::ANCESTOR_OP;
>                 break;
>@@ -704,83 +690,59 @@
>                 break;
>             default:
>                 lexer.pushBack();
>-                pathExpr->addPatternExpr(createPatternExpr(lexer), ancestryOp);
>-                ancestryOp = PathExpr::RELATIVE_OP;
>-                break;
>+                return pathExpr;
>         }
>+        
>+        expr = createLocationStep(lexer);
>+        if ( !expr ) {
>+            delete pathExpr;
>+            return 0;
>     }
> 
>-    /* <debug> *
>-    String tmp;
>-    pathExpr->toString(tmp);
>-    cout << "creating pathExpr: " << tmp << endl;
>-    /* </debug> */
>+        pathExpr->addExpr(expr, ancestryOp);
>+    }
> 
>     return pathExpr;
> } //-- createPathExpr
> 
> /**
>- * Creates a PatternExpr using the given ExprLexer
>+ * Creates a PathExpr using the given ExprLexer
>+ * XXX temporary use as top of XSLT Pattern
>  * @param lexer the ExprLexer for retrieving Tokens
> **/
>-PatternExpr* ExprParser::createPatternExpr(ExprLexer& lexer) {
>+Expr* ExprParser::createUnionExpr(ExprLexer& lexer) {
> 
>-    PatternExpr* pExpr = 0;
>-    Token* tok = lexer.peek();
>-    if ( isLocationStepToken(tok) ) {
>-        pExpr = createLocationStep(lexer);
>-    }
>-    else if ( isFilterExprToken(tok) ) {
>-        pExpr = createFilterExpr(lexer);
>-    }
>-    else {
>-        cout << "invalid token: " << tok->value << endl;
>-        //-- eat token for now
>-        lexer.nextToken();
>-    }
>-    return pExpr;
>-} //-- createPatternExpr
>+    Expr* expr = createPathExpr(lexer);
>+    if(!expr)
>+        return 0;
> 
>-/**
>- * Creates a PathExpr using the given ExprLexer
>- * @param lexer the ExprLexer for retrieving Tokens
>-**/
>-UnionExpr* ExprParser::createUnionExpr(ExprLexer& lexer) {
>+    if ( lexer.peek()->type != Token::UNION_OP )
>+        return expr;
>+
>     UnionExpr* unionExpr = new UnionExpr();
>+    unionExpr->addExpr(expr);
> 
>-    while ( lexer.hasMoreTokens() ) {
>-        Token* tok = lexer.nextToken();
>-        switch ( tok->type ) {
>+    while ( lexer.peek()->type == Token::UNION_OP ) {
>+        lexer.nextToken(); //-- eat token
> 
>-            case Token::R_PAREN:
>-            case Token::R_BRACKET:
>-                lexer.pushBack();
>-                return unionExpr;
>-            case Token::UNION_OP :
>-                //-- eat token
>-                break;
>-            default:
>-                lexer.pushBack();
>-                unionExpr->addPathExpr(createPathExpr(lexer));
>-                break;
>+        expr = createPathExpr(lexer);
>+        if ( !expr ) {
>+            delete unionExpr;
>+            return 0;
>         }
>+        unionExpr->addExpr(expr);
>     }
>-    //String tmp;
>-    //unionExpr->toString(tmp);
>-    //cout << "creating UnionExpr: " << tmp << endl;
>+
>     return unionExpr;
> } //-- createUnionExpr
> 
> MBool ExprParser::isFilterExprToken(Token* token) {
>-    if ( !token ) return MB_FALSE;
>     switch (token->type) {
>         case Token::LITERAL:
>         case Token::NUMBER:
>         case Token::FUNCTION_NAME:
>         case Token::VAR_REFERENCE:
>         case Token::L_PAREN:            // grouping expr
>-        case Token::PARENT_NODE:
>-        case Token::SELF_NODE :
>             return MB_TRUE;
>         default:
>             return MB_FALSE;
>@@ -788,15 +750,19 @@
> } //-- isFilterExprToken
> 
> MBool ExprParser::isLocationStepToken(Token* token) {
>-    if (!token) return MB_FALSE;
>-    return ((token->type == Token::AXIS_IDENTIFIER) || isNodeTypeToken(token));
>+    switch (token->type) {
>+        case Token::AXIS_IDENTIFIER :
>+        case Token::AT_SIGN :
>+        case Token::PARENT_NODE :
>+        case Token::SELF_NODE :
>+            return MB_TRUE;
>+        default:
>+            return isNodeTypeToken(token);
>+    }
> } //-- isLocationStepToken
> 
> MBool ExprParser::isNodeTypeToken(Token* token) {
>-    if (!token) return MB_FALSE;
>-
>     switch ( token->type ) {
>-        case Token::AT_SIGN:
>         case Token::CNAME:
>         case Token::COMMENT:
>         case Token::NODE :
>@@ -806,7 +772,7 @@
>         default:
>             return MB_FALSE;
>     }
>-} //-- isLocationStepToken
>+} //-- isNodeTypeToken
> 
> /**
>  * Using the given lexer, parses the tokens if they represent a predicate list
>@@ -816,43 +782,28 @@
>  * @param lexer the ExprLexer to use for parsing tokens
>  * @return 0 if successful, or a String pointer to the error message
> **/
>-String* ExprParser::parsePredicates(PredicateList* predicateList, ExprLexer& lexer) {
>+MBool ExprParser::parsePredicates(PredicateList* predicateList, ExprLexer& lexer) {
> 
>     String* errorMsg = 0;
>-
>-    Token* tok = lexer.peek();
> 
>-    if ( !tok ) return 0; //-- no predicates
>-    if ( tok->type != Token::L_BRACKET ) return 0; //-- not start of predicate list
>-
>+    while ( lexer.peek()->type == Token::L_BRACKET ) {
>+        //-- eat Token
>     lexer.nextToken();
> 
>-    while ( lexer.hasMoreTokens() ) {
>-        tok = lexer.peek();
>-        if(!tok) {
>-            //-- error missing ']'
>-            errorMsg = new String("missing close of predicate expression ']'");
>-            break;
>-        }
>-        if ( tok->type == Token::R_BRACKET) {
>-            lexer.nextToken(); //-- eat ']'
>+        Expr* expr = createExpr(lexer);
>+        if(!expr)
>+            return MB_FALSE;
> 
>+        predicateList->add(expr);
> 
>-            //-- Fix: look ahead at next token for mulitple predicates - Marina M.
>-            tok = lexer.peek();
>-            if ((!tok) || ( tok->type != Token::L_BRACKET )) break;
>-            //-- /Fix
>+        if(lexer.nextToken()->type != Token::R_BRACKET) {
>+            lexer.pushBack();
>+            //XXX ErrorReport: right bracket expected
>+            return MB_FALSE;
>         }
> 
>-        //-- Fix: handle multiple predicates - Marina M.
>-        if (tok->type == Token::L_BRACKET)
>-            lexer.nextToken(); //-- swallow '['
>-        //-- /Fix
>-
>-        Expr* expr = createExpr(lexer);
>-        predicateList->add(expr);
>     }
>-    return errorMsg;
>+    return MB_TRUE;
> 
> } //-- parsePredicates
> 
>@@ -863,48 +814,41 @@
>  * error message.
>  * @param list, the List to add parameter expressions to
>  * @param lexer the ExprLexer to use for parsing tokens
>- * @return 0 if successful, or a String pointer to the error message
>+ * @return MB_TRUE if successful, or a MB_FALSE otherwise
> **/
>-String* ExprParser::parseParameters(List* list, ExprLexer& lexer) {
>+MBool ExprParser::parseParameters(FunctionCall* fnCall, ExprLexer& lexer) {
> 
>-    String* errorMsg = 0;
>-
>-    Token* tok = lexer.peek();
>+    if ( lexer.nextToken()->type != Token::L_PAREN ) {
>+        lexer.pushBack();
>+        //XXX ErrorReport: left parenthesis expected
>+        return MB_FALSE;
>+    }
> 
>-    if ( !tok ) return 0; //-- no params
>-    if ( tok->type != Token::L_PAREN ) return 0; //-- not start of param list
>+    if( lexer.peek()->type == Token::R_PAREN ) {
>+        lexer.nextToken();
>+        return MB_TRUE;
>+    }
> 
>-    lexer.nextToken(); //-- eat L_PAREN
>+    while ( 1 ) {
>+        Expr* expr = createExpr(lexer);
>+        if(!expr)
>+            return MB_FALSE;
> 
>-    MBool done     = MB_FALSE;
>-    MBool foundSep = MB_FALSE;
>+        fnCall->addParam(expr);
> 
>-    while ( lexer.hasMoreTokens() && !done) {
>-        tok = lexer.peek();
>-        switch ( tok->type ) {
>+        switch ( lexer.nextToken()->type ) {
>             case Token::R_PAREN :
>-                if (foundSep) errorMsg = new String("missing expression after ','");
>-                lexer.nextToken(); //-- eat R_PAREN
>-                done = MB_TRUE;
>-                break;
>+                return MB_TRUE;
>             case Token::COMMA: //-- param separator
>-                //-- eat COMMA
>-                lexer.nextToken();
>-                foundSep = MB_TRUE;
>                 break;
>             default:
>-                if ((list->getLength() > 0) && (!foundSep)) {
>-                    errorMsg = new String("missing ',' or ')'");
>-                    done = MB_TRUE;
>-                    break;
>-                }
>-                foundSep = MB_FALSE;
>-                Expr* expr = createExpr(lexer);
>-                list->add(expr);
>-                break;
>+                lexer.pushBack();
>+                //XXX ErrorReport: right parenthesis or comma expected
>+                return MB_FALSE;
>         }
>     }
>-    return errorMsg;
>+
>+    return MB_FALSE;
> 
> } //-- parseParameters
> 
>Index: source/xpath/ExprParser.h
>===================================================================
>RCS file: /cvsroot/mozilla/extensions/transformiix/source/xpath/ExprParser.h,v
>retrieving revision 1.4
>diff -w -u -3 -r1.4 ExprParser.h
>--- ExprParser.h	2001/04/08 14:38:23	1.4
>+++ ExprParser.h	2001/06/15 10:34:31
>@@ -1,4 +1,4 @@
>-/*
>+/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
>  * The contents of this file are subject to the Mozilla Public
>  * License Version 1.1 (the "License"); you may not use this file
>  * except in compliance with the License. You may obtain a copy of
>@@ -44,9 +44,6 @@
> 
> public:
> 
>-    static const String R_CURLY_BRACE;
>-    static const String L_CURLY_BRACE;
>-
>     /**
>      * Creates a new ExprParser
>     **/
>@@ -58,7 +55,7 @@
>     ~ExprParser();
> 
>     Expr*          createExpr        (const String& pattern);
>-    PatternExpr*   createPatternExpr (const String& pattern);
>+    Expr*          createPatternExpr (const String& pattern);
>     LocationStep*  createLocationStep(const String& path);
> 
>     /**
>@@ -72,13 +69,12 @@
> 
>     Expr*          createBinaryExpr   (Expr* left, Expr* right, Token* op);
>     Expr*          createExpr         (ExprLexer& lexer);
>-    FilterExpr*    createFilterExpr   (ExprLexer& lexer);
>+    Expr*          createFilterExpr   (ExprLexer& lexer);
>     FunctionCall*  createFunctionCall (ExprLexer& lexer);
>     LocationStep*  createLocationStep (ExprLexer& lexer);
>     NodeExpr*      createNodeExpr     (ExprLexer& lexer);
>-    PathExpr*      createPathExpr     (ExprLexer& lexer);
>-    PatternExpr*   createPatternExpr  (ExprLexer& lexer);
>-    UnionExpr*     createUnionExpr    (ExprLexer& lexer);
>+    Expr*          createPathExpr     (ExprLexer& lexer);
>+    Expr*          createUnionExpr    (ExprLexer& lexer);
> 
>     MBool          isFilterExprToken   (Token* tok);
>     MBool          isLocationStepToken (Token* tok);
>@@ -94,8 +90,8 @@
>      * @param lexer the ExprLexer to use for parsing tokens
>      * @return 0 if successful, or a String pointer to the error message
>     **/
>-    String* parsePredicates(PredicateList* predicateList, ExprLexer& lexer);
>-    String* parseParameters(List* list, ExprLexer& lexer);
>+    MBool parsePredicates(PredicateList* predicateList, ExprLexer& lexer);
>+    MBool parseParameters(FunctionCall* fnCall, ExprLexer& lexer);
> 
> 
> }; //-- ExprParser
>Index: source/xpath/FunctionCall.cpp
>===================================================================
>RCS file: /cvsroot/mozilla/extensions/transformiix/source/xpath/FunctionCall.cpp,v
>retrieving revision 1.2
>diff -w -u -3 -r1.2 FunctionCall.cpp
>--- FunctionCall.cpp	2000/04/19 10:36:17	1.2
>+++ FunctionCall.cpp	2001/06/15 10:34:31
>@@ -101,6 +101,31 @@
> } //-- addParam
> 
> /**
>+ * Returns the default priority of this Expr based on the given Node,
>+ * context Node, and ContextState.
>+**/
>+double FunctionCall::getDefaultPriority(Node* node, Node* context, ContextState* cs) {
>+    return 0.5;
>+} //-- getDefaultPriority
>+
>+/**
>+ * Determines whether this Expr matches the given node within
>+ * the given context
>+**/
>+MBool FunctionCall::matches(Node* node, Node* context, ContextState* cs) {
>+
>+    MBool result = MB_FALSE;
>+    ExprResult* exprResult = evaluate(node, cs);
>+    if ( exprResult->getResultType() == ExprResult::NODESET ) {
>+        NodeSet* nodes = (NodeSet*)exprResult;
>+        result = (nodes->contains(node));
>+    }
>+    delete exprResult;
>+    return result;
>+
>+} //-- matches
>+
>+/**
>  * Evaluates the given Expression and converts it's result to a String.
>  * The value is appended to the given destination String
> **/
>Index: source/xpath/Makefile.in
>===================================================================
>RCS file: /cvsroot/mozilla/extensions/transformiix/source/xpath/Makefile.in,v
>retrieving revision 1.12
>diff -w -u -3 -r1.12 Makefile.in
>--- Makefile.in	2001/06/10 16:42:59	1.12
>+++ Makefile.in	2001/06/15 10:34:31
>@@ -40,12 +40,13 @@
>         BooleanResult.cpp \
>         ElementExpr.cpp \
>         ErrorFunctionCall.cpp \
>+        Expr.cpp \
>         ExprLexer.cpp \
>+        ExprLexerChars.cpp \
>         ExprParser.cpp \
>         ExtensionFunctionCall.cpp \
>         FilterExpr.cpp \
>         FunctionCall.cpp \
>-        IdentityExpr.cpp \
>         LocationStep.cpp \
>         MultiplicativeExpr.cpp \
>         NodeSet.cpp \
>@@ -53,7 +54,6 @@
>         NumberExpr.cpp \
>         NumberFunctionCall.cpp \
>         NumberResult.cpp \
>-        ParentExpr.cpp \
>         PathExpr.cpp \
>         PredicateList.cpp \
>         RelationalExpr.cpp \
>@@ -63,6 +63,7 @@
>         StringResult.cpp \
>         TextExpr.cpp \
>         UnionExpr.cpp \
>+        UnaryExpr.cpp \
>         VariableRefExpr.cpp \
>         XPathNames.cpp
> ifndef TX_EXE
>Index: source/xpath/PathExpr.cpp
>===================================================================
>RCS file: /cvsroot/mozilla/extensions/transformiix/source/xpath/PathExpr.cpp,v
>retrieving revision 1.6
>diff -w -u -3 -r1.6 PathExpr.cpp
>--- PathExpr.cpp	2001/04/14 17:24:59	1.6
>+++ PathExpr.cpp	2001/06/15 10:34:32
>@@ -48,41 +48,41 @@
> }
> 
> /**
>- * Destructor, will delete all Pattern Expressions
>+ * Destructor, will delete all Expressions
> **/
> PathExpr::~PathExpr() {
>     ListIterator* iter = expressions.iterator();
>     while ( iter->hasNext() ) {
>          iter->next();
>          PathExprItem* pxi = (PathExprItem*)iter->remove();
>-         delete pxi->pExpr;
>+         delete pxi->expr;
>          delete pxi;
>     }
>     delete iter;
> } //-- ~PathExpr
> 
> /**
>- * Adds the PatternExpr to this PathExpr
>+ * Adds the Expr to this PathExpr
>  * @param expr the Expr to add to this PathExpr
>  * @param index the index at which to add the given Expr
> **/
>-void PathExpr::addPatternExpr(int index, PatternExpr* expr, short ancestryOp) {
>+void PathExpr::addExpr(int index, Expr* expr, short ancestryOp) {
>     if (expr) {
>         PathExprItem* pxi = new PathExprItem;
>-        pxi->pExpr = expr;
>+        pxi->expr = expr;
>         pxi->ancestryOp = ancestryOp;
>         expressions.insert(index, pxi);
>     }
> } //-- addPattenExpr
> 
> /**
>- * Adds the PatternExpr to this PathExpr
>+ * Adds the Expr to this PathExpr
>  * @param expr the Expr to add to this PathExpr
> **/
>-void PathExpr::addPatternExpr(PatternExpr* expr, short ancestryOp) {
>+void PathExpr::addExpr(Expr* expr, short ancestryOp) {
>     if (expr) {
>         PathExprItem* pxi = new PathExprItem;
>-        pxi->pExpr = expr;
>+        pxi->expr = expr;
>         pxi->ancestryOp = ancestryOp;
>         expressions.add(pxi);
>     }
>@@ -98,9 +98,9 @@
>     return MB_FALSE;
> } //-- isAbsolute
> 
>-    //------------------------------------/
>-  //- Virtual methods from PatternExpr -/
>-//------------------------------------/
>+    //-----------------------------/
>+  //- Virtual methods from Expr -/
>+//-----------------------------/
> 
> /**
>  * Evaluates this Expr based on the given context node and processor state
>@@ -136,10 +136,10 @@
>             NodeSet* resNodes;
>             if ( pxi->ancestryOp == ANCESTOR_OP) {
>                 resNodes = new NodeSet;
>-                evalDescendants(pxi->pExpr, node, cs, resNodes);
>+                evalDescendants(pxi->expr, node, cs, resNodes);
>             }
>             else {
>-                ExprResult *res = pxi->pExpr->evaluate(node, cs);
>+                ExprResult *res = pxi->expr->evaluate(node, cs);
>                 if (!res || res->getResultType() != ExprResult::NODESET) {
>                     //XXX ErrorReport: report nonnodeset error
>                     delete res;
>@@ -168,13 +168,13 @@
> 
> /**
>  * Selects from the descendants of the context node
>- * all nodes that match the PatternExpr
>+ * all nodes that match the Expr
>  * -- this will be moving to a Utility class
> **/
> void PathExpr::evalDescendants
>-    (PatternExpr* pExpr, Node* context, ContextState* cs, NodeSet* resNodes)
>+    (Expr* expr, Node* context, ContextState* cs, NodeSet* resNodes)
> {
>-    ExprResult *res = pExpr->evaluate(context, cs);
>+    ExprResult *res = expr->evaluate(context, cs);
>     if (!res || res->getResultType() != ExprResult::NODESET) {
>         //XXX ErrorReport: report nonnodeset error
>     }
>@@ -188,7 +188,7 @@
>     while(child) {
>         if(!(filterWS && child->getNodeType() == Node::TEXT_NODE &&
>              XMLUtils::shouldStripTextnode(child->getNodeValue())))
>-            evalDescendants(pExpr, child, cs, resNodes);
>+            evalDescendants(expr, child, cs, resNodes);
>         child = child->getNextSibling();
>     }
> } //-- evalDescendants
>@@ -207,7 +207,7 @@
>             ListIterator* iter = expressions.iterator();
>             PathExprItem* pxi = (PathExprItem*)iter->next();
>             delete iter;
>-            return pxi->pExpr->getDefaultPriority(node, context, cs);
>+            return pxi->expr->getDefaultPriority(node, context, cs);
>         }
>         else if ( size > 1 ) {
>             return 0.5;
>@@ -217,7 +217,7 @@
> } //-- getDefaultPriority
> 
> /**
>- * Determines whether this PatternExpr matches the given node within
>+ * Determines whether this Expr matches the given node within
>  * the given context
> **/
> MBool PathExpr::matches(Node* node, Node* context, ContextState* cs) {
>@@ -241,7 +241,7 @@
>             {
>                 Node* ancestor = node;
>                 while (ancestor = cs->getParentNode(ancestor))  {
>-                    if (pxi->pExpr->matches(node, ancestor, cs))
>+                    if (pxi->expr->matches(node, ancestor, cs))
>                         return MB_TRUE;
>                 }
>                 break;
>@@ -252,12 +252,12 @@
>                 if (parent) {
>                     //-- make sure node is Document node
>                     if (parent->getNodeType() == Node::DOCUMENT_NODE)
>-                        return pxi->pExpr->matches(node, parent, cs);
>+                        return pxi->expr->matches(node, parent, cs);
>                 }
>                 break;
>             }
>             default:
>-                return pxi->pExpr->matches(node, context, cs);
>+                return pxi->expr->matches(node, context, cs);
> 
>         }
> 
>@@ -290,7 +290,7 @@
>                 {
>                     Node* parent = tnode;
>                     while (parent = cs->getParentNode(parent))  {
>-                        if (pxi->pExpr->matches(tnode, parent, cs))
>+                        if (pxi->expr->matches(tnode, parent, cs))
>                             tmpNodes.add(parent);
>                     }
>                     break;
>@@ -304,7 +304,7 @@
>                         if ( !iter->hasNext() )
>                             if (parent->getNodeType() != Node::DOCUMENT_NODE) break;
> 
>-                        if (pxi->pExpr->matches(tnode, parent, cs))
>+                        if (pxi->expr->matches(tnode, parent, cs))
>                             tmpNodes.add(parent);
>                     }
>                     break;
>@@ -313,15 +313,15 @@
>                     if ( !iter->hasNext() ) {
> 
>                         /*
>-                          // PREVIOUS // result = pxi->pExpr->matches(tnode, context, cs);
>+                          // PREVIOUS // result = pxi->expr->matches(tnode, context, cs);
>                           // result was being overwritten if there was more than one
>                           // node in nodes during the final iteration  (Marina)
> 
>-                          result = result || pxi->pExpr->matches(tnode, context, cs)
>+                          result = result || pxi->expr->matches(tnode, context, cs)
>                         */
> 
>                         //-- Just return true if we match here
>-                        if (pxi->pExpr->matches(tnode, context, cs)) {
>+                        if (pxi->expr->matches(tnode, context, cs)) {
>                             delete iter;
>                             return MB_TRUE;
>                         }
>@@ -362,12 +362,12 @@
> 
> 
> /**
>- * Returns the String representation of this PatternExpr.
>+ * Returns the String representation of this Expr.
>  * @param dest the String to use when creating the String
>  * representation. The String representation will be appended to
>  *  any data in the destination String, to allow cascading calls to
>  * other #toString() methods for Expressions.
>- * @return the String representation of this PatternExpr.
>+ * @return the String representation of this Expr.
> **/
> void PathExpr::toString(String& dest) {
>     ListIterator* iter = expressions.iterator();
>@@ -384,7 +384,7 @@
>             default:
>                 break;
>         }
>-        pxi->pExpr->toString(dest);
>+        pxi->expr->toString(dest);
>     }
>     delete iter;
> } //-- toString
>Index: source/xpath/StringExpr.cpp
>===================================================================
>RCS file: /cvsroot/mozilla/extensions/transformiix/source/xpath/StringExpr.cpp,v
>retrieving revision 1.2
>diff -w -u -3 -r1.2 StringExpr.cpp
>--- StringExpr.cpp	2001/05/12 09:54:16	1.2
>+++ StringExpr.cpp	2001/06/15 10:34:32
>@@ -77,8 +77,11 @@
>  * @return the String representation of this Expr.
> **/
> void StringExpr::toString(String& str) {
>-    str.append('\'');
>+    UNICODE_CHAR ch = '\'';
>+    if ( value.indexOf(ch) != NOT_FOUND )
>+        ch = '\"';
>+    str.append(ch);
>     str.append(value);
>-    str.append('\'');
>+    str.append(ch);
> } //-- toString
> 
>Index: source/xpath/UnaryExpr.cpp
>===================================================================
>RCS file: UnaryExpr.cpp
>diff -N UnaryExpr.cpp
>--- /dev/null	Wed Apr 26 15:53:02 2000
>+++ UnaryExpr.cpp	Fri Jun 15 03:34:32 2001
>@@ -0,0 +1,71 @@
>+/*
>+ * The contents of this file are subject to the Mozilla Public
>+ * License Version 1.1 (the "License"); you may not use this file
>+ * except in compliance with the License. You may obtain a copy of
>+ * the License at http://www.mozilla.org/MPL/
>+ *
>+ * Software distributed under the License is distributed on an "AS
>+ * IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
>+ * implied. See the License for the specific language governing
>+ * rights and limitations under the License.
>+ *
>+ * The Initial Developer of the Original Code is Jonas Sicking.
>+ * Portions created by Jonas Sicking are Copyright (C) 2001, Jonas Sicking.
>+ * All rights reserved.
>+ *
>+ * Contributor(s):
>+ * Jonas Sicking, sicking@bigfoot.com
>+ *   -- original author.
>+ */
>+
>+#include "Expr.h"
>+
>+  //-------------/
>+ //- UnaryExpr -/
>+//-------------/
>+
>+UnaryExpr::UnaryExpr() {
>+    expr = 0;
>+}
>+
>+UnaryExpr::UnaryExpr(Expr* expr) {
>+    this->expr = expr;
>+}
>+
>+UnaryExpr::~UnaryExpr() {
>+    delete expr;
>+}
>+
>+void UnaryExpr::setExpr(Expr* expr) {
>+    delete this->expr;
>+    this->expr = expr;
>+}
>+
>+/**
>+ * Evaluates this Expr based on the given context node and processor state
>+ * @param context the context node for evaluation of this Expr
>+ * @param ps the ContextState containing the stack information needed
>+ * for evaluation
>+ * @return the result of the evaluation
>+**/
>+ExprResult* UnaryExpr::evaluate(Node* context, ContextState* cs) {
>+    ExprResult* exprRes = expr->evaluate(context, cs);
>+    double value = exprRes->numberValue();
>+    delete exprRes;
>+    return new NumberResult(-value);
>+}
>+
>+/**
>+ * Returns the String representation of this Expr.
>+ * @param dest the String to use when creating the String
>+ * representation. The String representation will be appended to
>+ * any data in the destination String, to allow cascading calls to
>+ * other #toString() methods for Expressions.
>+ * @return the String representation of this Expr.
>+**/
>+void UnaryExpr::toString(String& str) {
>+    if (!expr) return;
>+    str.append('-');
>+    expr->toString(str);
>+}
>+
>Index: source/xpath/UnionExpr.cpp
>===================================================================
>RCS file: /cvsroot/mozilla/extensions/transformiix/source/xpath/UnionExpr.cpp,v
>retrieving revision 1.1
>diff -w -u -3 -r1.1 UnionExpr.cpp
>--- UnionExpr.cpp	2000/04/06 07:45:52	1.1
>+++ UnionExpr.cpp	2001/06/15 10:34:32
>@@ -45,29 +45,29 @@
>     ListIterator* iter = expressions.iterator();
>     while ( iter->hasNext() ) {
>          iter->next();
>-         delete  (PathExpr*)iter->remove();
>+         delete  (Expr*)iter->remove();
>     }
>     delete iter;
> } //-- ~UnionExpr
> 
> /**
>- * Adds the PathExpr to this UnionExpr
>- * @param pathExpr the PathExpr to add to this UnionExpr
>+ * Adds the Expr to this UnionExpr
>+ * @param expr the Expr to add to this UnionExpr
> **/
>-void UnionExpr::addPathExpr(PathExpr* pathExpr) {
>-    if (pathExpr) expressions.add(pathExpr);
>-} //-- addPathExpr
>+void UnionExpr::addExpr(Expr* expr) {
>+    if (expr) expressions.add(expr);
>+} //-- addExpr
> 
> /**
>- * Adds the PathExpr to this UnionExpr
>- * @param pathExpr the PathExpr to add to this UnionExpr
>+ * Adds the Expr to this UnionExpr
>+ * @param expr the Expr to add to this UnionExpr
> **/
>-void UnionExpr::addPathExpr(int index, PathExpr* pathExpr) {
>-    if (pathExpr) expressions.insert(index, pathExpr);
>-} //-- addPathExpr
>+void UnionExpr::addExpr(int index, Expr* expr) {
>+    if (expr) expressions.insert(index, expr);
>+} //-- addExpr
> 
>     //------------------------------------/
>-  //- Virtual methods from PatternExpr -/
>+  //- Virtual methods from Expr -/
> //------------------------------------/
> 
> /**
>@@ -88,12 +88,11 @@
> 
>     while ( iter->hasNext() ) {
> 
>-        PathExpr* pExpr = (PathExpr*)iter->next();
>-        NodeSet* tmpNodes = (NodeSet*)pExpr->evaluate(context, cs);
>-        for (int j = 0; j < tmpNodes->size(); j++) {
>-            nodes->add(tmpNodes->get(j));
>+        Expr* expr = (Expr*)iter->next();
>+        ExprResult* exprResult = expr->evaluate(context, cs);
>+        if ( exprResult->getResultType() == ExprResult::NODESET ) {
>+            ((NodeSet*)exprResult)->copyInto(*nodes);
>         }
>-        delete tmpNodes;
>     }
> 
>     delete iter;
>@@ -112,9 +111,9 @@
>     double priority = Double::NEGATIVE_INFINITY;
>     ListIterator* iter = expressions.iterator();
>     while ( iter->hasNext() ) {
>-        PathExpr* pExpr = (PathExpr*)iter->next();
>-        if ( pExpr->matches(node, context, cs) ) {
>-            double tmpPriority = pExpr->getDefaultPriority(node, context, cs);
>+        Expr* expr = (Expr*)iter->next();
>+        if ( expr->matches(node, context, cs) ) {
>+            double tmpPriority = expr->getDefaultPriority(node, context, cs);
>             priority = (tmpPriority > priority) ? tmpPriority : priority;
>         }
>     }
>@@ -132,8 +131,8 @@
>     ListIterator* iter = expressions.iterator();
> 
>     while ( iter->hasNext() ) {
>-        PathExpr* pExpr = (PathExpr*)iter->next();
>-        if ( pExpr->matches(node, context, cs) ) {
>+        Expr* expr = (Expr*)iter->next();
>+        if ( expr->matches(node, context, cs) ) {
>              delete iter;
>              return MB_TRUE;
>         }
>@@ -144,12 +143,12 @@
> 
> 
> /**
>- * Returns the String representation of this PatternExpr.
>+ * Returns the String representation of this Expr.
>  * @param dest the String to use when creating the String
>  * representation. The String representation will be appended to
>  *  any data in the destination String, to allow cascading calls to
>  * other #toString() methods for Expressions.
>- * @return the String representation of this PatternExpr.
>+ * @return the String representation of this Expr.
> **/
> void UnionExpr::toString(String& dest) {
>     ListIterator* iter = expressions.iterator();
>@@ -158,7 +157,7 @@
>     while ( iter->hasNext() ) {
>         //-- set operator
>         if (count > 0) dest.append(" | ");
>-        ((PathExpr*)iter->next())->toString(dest);
>+        ((Expr*)iter->next())->toString(dest);
>         ++count;
>     }
>     delete iter;
>Index: source/xpath/makefile.win
>===================================================================
>RCS file: /cvsroot/mozilla/extensions/transformiix/source/xpath/makefile.win,v
>retrieving revision 1.16
>diff -w -u -3 -r1.16 makefile.win
>--- makefile.win	2001/06/10 16:42:07	1.16
>+++ makefile.win	2001/06/15 10:34:31
>@@ -36,12 +36,13 @@
> 	BooleanResult.cpp		\
> 	ElementExpr.cpp			\
> 	ErrorFunctionCall.cpp		\
>+	Expr.cpp			\
> 	ExprLexer.cpp			\
>+	ExprLexerChars.cpp		\
> 	ExprParser.cpp			\
> 	ExtensionFunctionCall.cpp	\
> 	FilterExpr.cpp			\
> 	FunctionCall.cpp		\
>-	IdentityExpr.cpp		\
> 	LocationStep.cpp		\
> 	MultiplicativeExpr.cpp		\
> 	NodeSet.cpp			\
>@@ -49,7 +50,6 @@
> 	NumberExpr.cpp			\
> 	NumberFunctionCall.cpp		\
> 	NumberResult.cpp		\
>-	ParentExpr.cpp			\
> 	PathExpr.cpp			\
> 	PredicateList.cpp		\
> 	RelationalExpr.cpp		\
>@@ -59,6 +59,7 @@
> 	StringResult.cpp		\
> 	TextExpr.cpp			\
> 	UnionExpr.cpp			\
>+	UnaryExpr.cpp			\
> 	VariableRefExpr.cpp		\
> 	XPathNames.cpp			\
> !if !defined(TX_EXE)
>@@ -77,12 +78,13 @@
> 	.\$(OBJDIR)\BooleanResult.obj			\
> 	.\$(OBJDIR)\ElementExpr.obj			\
> 	.\$(OBJDIR)\ErrorFunctionCall.obj		\
>+	.\$(OBJDIR)\Expr.obj				\
> 	.\$(OBJDIR)\ExprLexer.obj			\
>+	.\$(OBJDIR)\ExprLexerChars.obj			\
> 	.\$(OBJDIR)\ExprParser.obj			\
> 	.\$(OBJDIR)\ExtensionFunctionCall.obj		\
> 	.\$(OBJDIR)\FilterExpr.obj			\
> 	.\$(OBJDIR)\FunctionCall.obj			\
>-	.\$(OBJDIR)\IdentityExpr.obj			\
> 	.\$(OBJDIR)\LocationStep.obj			\
> 	.\$(OBJDIR)\MultiplicativeExpr.obj		\
> 	.\$(OBJDIR)\NodeSet.obj				\
>@@ -90,7 +92,6 @@
> 	.\$(OBJDIR)\NumberExpr.obj			\
> 	.\$(OBJDIR)\NumberFunctionCall.obj		\
> 	.\$(OBJDIR)\NumberResult.obj			\
>-	.\$(OBJDIR)\ParentExpr.obj			\
> 	.\$(OBJDIR)\PathExpr.obj			\
> 	.\$(OBJDIR)\PredicateList.obj			\
> 	.\$(OBJDIR)\RelationalExpr.obj			\
>@@ -100,6 +101,7 @@
> 	.\$(OBJDIR)\StringResult.obj			\
> 	.\$(OBJDIR)\TextExpr.obj			\
> 	.\$(OBJDIR)\UnionExpr.obj			\
>+	.\$(OBJDIR)\UnaryExpr.obj			\
> 	.\$(OBJDIR)\VariableRefExpr.obj			\
> 	.\$(OBJDIR)\XPathNames.obj			\
> !if !defined(TX_EXE)
>Index: source/xslt/ProcessorState.cpp
>===================================================================
>RCS file: /cvsroot/mozilla/extensions/transformiix/source/xslt/ProcessorState.cpp,v
>retrieving revision 1.29
>diff -w -u -3 -r1.29 ProcessorState.cpp
>--- ProcessorState.cpp	2001/06/10 16:41:35	1.29
>+++ ProcessorState.cpp	2001/06/15 10:34:32
>@@ -196,8 +196,10 @@
>         namedTemplates.put(name,mObj);
>         if ( oldObj ) delete oldObj;
>     }
>+    if ( match.length() > 0 ) {
>     patternExprHash.put(match, exprParser.createPatternExpr(match));
>     templates.add(xslTemplate);
>+    }
> } //-- addTempalte
> 
> /**

Actions: View | Diff | Review

Attachments on bug 75102: 30266 | 30268 | 30269 | 30270 | 30271 | 30662 | 30663 | 30664 | 30666 | 37652 | 37653 | 38503 | 38508 | 38590 | 38591 | 38595 | 38596 | 39504 | 40618