| /* |
| * Licensed to the Apache Software Foundation (ASF) under one |
| * or more contributor license agreements. See the NOTICE file |
| * distributed with this work for additional information |
| * regarding copyright ownership. The ASF licenses this file |
| * to you under the Apache License, Version 2.0 (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.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| #if !defined(XPATHPROCESSORIMPL_HEADER_GUARD_1357924680) |
| #define XPATHPROCESSORIMPL_HEADER_GUARD_1357924680 |
| |
| |
| |
| // Base header file. Must be first. |
| #include <xalanc/XPath/XPathDefinitions.hpp> |
| |
| |
| |
| #include <cstdlib> |
| |
| |
| |
| #include <xalanc/XalanDOM/XalanDOMString.hpp> |
| |
| |
| |
| #include <xalanc/Include/XalanVector.hpp> |
| #include <xalanc/Include/XalanMap.hpp> |
| |
| |
| |
| #include "xalanc/PlatformSupport/XalanMessageLoader.hpp" |
| |
| |
| |
| // Base class header file... |
| #include <xalanc/XPath/XPathProcessor.hpp> |
| |
| |
| |
| #include <xalanc/XPath/XPath.hpp> |
| |
| |
| |
| namespace XALAN_CPP_NAMESPACE { |
| |
| |
| |
| class XalanNode; |
| |
| |
| |
| /** |
| * The XPathProcessorImpl class responsibilities include tokenizing and |
| * parsing the XPath expression, and acting as a general interface to XPaths. |
| */ |
| class XALAN_XPATH_EXPORT XPathProcessorImpl : public XPathProcessor |
| { |
| public: |
| |
| typedef XalanMap<XalanDOMString, |
| const XalanDOMString*> StringToStringMapType; |
| |
| typedef XalanVector<bool> BoolVectorType; |
| |
| typedef XalanDOMString::size_type t_size_type; |
| |
| XPathProcessorImpl(MemoryManager& theManager XALAN_DEFAULT_MEMMGR); |
| |
| virtual |
| ~XPathProcessorImpl(); |
| |
| |
| static XPathProcessorImpl* |
| create(MemoryManager& theManager); |
| // These are inherited from XPathProcessor... |
| |
| virtual void |
| initXPath( |
| XPath& pathObj, |
| XPathConstructionContext& constructionContext, |
| const XalanDOMString& expression, |
| const PrefixResolver& resolver, |
| const Locator* locator = 0, |
| bool allowVariableReferences = true, |
| bool allowKeyFunction = true); |
| |
| virtual void |
| initMatchPattern( |
| XPath& pathObj, |
| XPathConstructionContext& constructionContext, |
| const XalanDOMString& expression, |
| const PrefixResolver& resolver, |
| const Locator* locator = 0, |
| bool allowVariableReferences = true, |
| bool allowKeyFunction = true); |
| |
| private: |
| |
| /** |
| * Walk through the expression and build a token queue, and a map of the |
| * top-level elements. |
| * |
| * @param pat XSLT Expression. |
| */ |
| void |
| tokenize(const XalanDOMString& pat); |
| |
| void |
| addToTokenQueue(const XalanDOMString& s) const; |
| |
| void |
| replaceTokenWithNamespaceToken() const; |
| |
| /** |
| * When a separator token is found, see if there's a element name or the |
| * like to map. |
| */ |
| t_size_type |
| mapNSTokens( |
| const XalanDOMString& pat, |
| t_size_type startSubstring, |
| t_size_type posOfNSSep, |
| t_size_type posOfScan); |
| |
| /** |
| * Check if m_token==s. If m_token is null, this won't throw |
| * an exception, instead it just returns false (or true |
| * if s is also null). |
| */ |
| bool |
| tokenIs(const XalanDOMString& s) const; |
| |
| /** |
| * Check if m_token==s. If m_token is null, this won't throw |
| * an exception, instead it just returns false (or true |
| * if s is also null). |
| */ |
| bool |
| tokenIs(const XalanDOMChar* s) const; |
| |
| /** |
| * Check if m_token==s. If m_token is null, this won't throw |
| * an exception, instead it just returns false (or true |
| * if s is also null). |
| */ |
| bool |
| tokenIs(XalanDOMChar c) const; |
| |
| /** |
| * Lookahead of the current token in order to |
| * make a branching decision. |
| * @param s the string to compare it to. |
| * @param n number of tokens to lookahead. Must be |
| * greater than 1. |
| */ |
| bool |
| lookahead( |
| XalanDOMChar c, |
| int n) const; |
| |
| /** |
| * Lookahead of the current token in order to |
| * make a branching decision. |
| * @param s the string to compare it to. |
| * @param n number of tokens to lookahead. Must be |
| * greater than 1. |
| */ |
| bool |
| lookahead( |
| const XalanDOMChar* s, |
| int n) const; |
| |
| /** |
| * Lookahead of the current token in order to |
| * make a branching decision. |
| * @param s the string to compare it to. |
| * @param n number of tokens to lookahead. Must be |
| * greater than 1. |
| */ |
| bool |
| lookahead( |
| const XalanDOMString& s, |
| int n) const; |
| |
| /** |
| * Lookbehind the first character of the current token in order to |
| * make a branching decision. |
| * @param c the character to compare it to. |
| * @param n number of tokens to lookbehind. Must be |
| * greater than 1. Note that the lookbehind terminates |
| * at either the beginning of the string or on a '|' |
| * character. Because of this, this method should only |
| * be used for pattern matching. |
| */ |
| bool |
| lookbehind( |
| char c, |
| int n) const; |
| |
| /** |
| * look behind the current token in order to |
| * see if there is a useable token. |
| * @param n number of tokens to lookahead. Must be |
| * greater than 1. Note that the lookbehind terminates |
| * at either the beginning of the string or on a '|' |
| * character. Because of this, this method should only |
| * be used for pattern matching. |
| * @return true if lookbehind has a token, false otherwise. |
| */ |
| bool |
| lookbehindHasToken(int n) const; |
| |
| /** |
| * Retrieve the next token from the command and |
| * store it in m_token string. |
| */ |
| bool |
| nextToken(); |
| |
| /** |
| * Retrieve the next token from the command and |
| * store it in m_token string. |
| */ |
| const XalanDOMString& |
| getTokenRelative(int theOffset) const; |
| |
| /** |
| * Retrieve the previous token from the command and |
| * store it in m_token string. |
| */ |
| void |
| prevToken(); |
| |
| /** |
| * Consume an expected token, throwing an exception if it |
| * isn't there. |
| */ |
| void |
| consumeExpected(XalanDOMChar expected); |
| |
| bool |
| isCurrentLiteral() const; |
| |
| /** |
| * Determine if the token is an axis |
| * |
| * @param theToken The token to test |
| * @return true if the token is a valid axis, false if not. |
| */ |
| static bool |
| isAxis(const XalanDOMString& theToken); |
| |
| /** |
| * Determine if the token could be a node test |
| * |
| * @param theToken The token to test |
| * @return true if the token is a valid node test, false if not. |
| */ |
| static bool |
| isNodeTest(const XalanDOMString& theToken); |
| |
| /** |
| * Throw an exception using the provided message text. |
| */ |
| void |
| error(const XalanDOMString& msg) const; |
| |
| /** |
| * Throw an exception using the provided message text. |
| */ |
| void |
| error(XalanMessages::Codes theCode) const; |
| |
| void |
| error( |
| XalanMessages::Codes theCode, |
| const XalanDOMString& theToken) const; |
| |
| void |
| error( |
| XalanMessages::Codes theCode, |
| const XalanDOMChar* theToken) const; |
| |
| void |
| error( |
| XalanMessages::Codes theCode, |
| XalanDOMChar theToken1, |
| const XalanDOMString& theToken2) const; |
| |
| /** |
| * Given a string, return the corresponding token. |
| */ |
| static XPathExpression::eOpCodes |
| getFunctionToken(const XalanDOMString& key) |
| { |
| return searchTable(s_functionTable, s_functionTableSize, key).m_opCode; |
| } |
| |
| /** |
| * Given a string, return the corresponding token. |
| */ |
| static XPathExpression::eOpCodes |
| getNodeTypeToken(const XalanDOMString& key) |
| { |
| return searchTable(s_nodeTypeTable, s_nodeTypeTableSize, key).m_opCode; |
| } |
| |
| /** |
| * Given a string, return the corresponding token. |
| */ |
| static XPathExpression::eOpCodes |
| getAxisToken(const XalanDOMString& key) |
| { |
| return searchTable(s_axisTable, s_axisTableSize, key).m_opCode; |
| } |
| |
| /** |
| * |
| * -------------------------------------------------------------------------------- |
| Expr ::= OrExpr |
| * -------------------------------------------------------------------------------- |
| */ |
| void |
| Expr(); |
| |
| |
| /** |
| * |
| * -------------------------------------------------------------------------------- |
| OrExpr ::= AndExpr |
| | OrExpr 'or' AndExpr |
| * -------------------------------------------------------------------------------- |
| */ |
| void |
| OrExpr(); |
| |
| /** |
| * |
| * -------------------------------------------------------------------------------- |
| AndExpr ::= EqualityExpr |
| | AndExpr 'and' EqualityExpr |
| * -------------------------------------------------------------------------------- |
| */ |
| void |
| AndExpr() ; |
| |
| /** |
| * XXXX. |
| * @returns an Object which is either a String, a Number, a Boolean, or a vector |
| * of nodes. |
| * -------------------------------------------------------------------------------- |
| EqualityExpr ::= RelationalExpr |
| | EqualityExpr '=' RelationalExpr |
| * -------------------------------------------------------------------------------- |
| */ |
| int |
| EqualityExpr(int opCodePos = -1); |
| |
| /** |
| * XXXX. |
| * @returns an Object which is either a String, a Number, a Boolean, or a vector |
| * of nodes. |
| * -------------------------------------------------------------------------------- |
| RelationalExpr ::= AdditiveExpr |
| | RelationalExpr '<' AdditiveExpr |
| | RelationalExpr '>' AdditiveExpr |
| | RelationalExpr '<=' AdditiveExpr |
| | RelationalExpr '>=' AdditiveExpr |
| * -------------------------------------------------------------------------------- |
| */ |
| int |
| RelationalExpr(int opCodePos = -1); |
| |
| /** |
| * XXXX. |
| * @returns an Object which is either a String, a Number, a Boolean, or a vector |
| * of nodes. |
| * -------------------------------------------------------------------------------- |
| AdditiveExpr ::= MultiplicativeExpr |
| | AdditiveExpr '+' MultiplicativeExpr |
| | AdditiveExpr '-' MultiplicativeExpr |
| * -------------------------------------------------------------------------------- |
| */ |
| int |
| AdditiveExpr(int opCodePos = -1); |
| |
| /** |
| * XXXX. |
| * @returns an Object which is either a String, a Number, a Boolean, or a vector |
| * of nodes. |
| * -------------------------------------------------------------------------------- |
| MultiplicativeExpr ::= UnaryExpr |
| | MultiplicativeExpr MultiplyOperator UnaryExpr |
| | MultiplicativeExpr 'div' UnaryExpr |
| | MultiplicativeExpr 'mod' UnaryExpr |
| | MultiplicativeExpr 'quo' UnaryExpr |
| * -------------------------------------------------------------------------------- |
| */ |
| int |
| MultiplicativeExpr(int opCodePos = -1); |
| |
| /** |
| * XXXX. |
| * @returns an Object which is either a String, a Number, a Boolean, or a vector |
| * of nodes. |
| * -------------------------------------------------------------------------------- |
| UnaryExpr ::= UnionExpr |
| | '-' UnaryExpr |
| * -------------------------------------------------------------------------------- |
| */ |
| void |
| UnaryExpr(); |
| |
| /** |
| * The context of the right hand side expressions is the context of the |
| * left hand side expression. The results of the right hand side expressions |
| * are node sets. The result of the left hand side UnionExpr is the union |
| * of the results of the right hand side expressions. |
| * |
| * -------------------------------------------------------------------------------- |
| UnionExpr ::= PathExpr |
| | UnionExpr '|' PathExpr |
| * -------------------------------------------------------------------------------- |
| */ |
| void |
| UnionExpr(); |
| |
| /** |
| * |
| * -------------------------------------------------------------------------------- |
| PathExpr ::= LocationPath |
| | FilterExpr |
| | FilterExpr '/' RelativeLocationPath |
| | FilterExpr '//' RelativeLocationPath |
| * -------------------------------------------------------------------------------- |
| * @exception XSLProcessorException thrown if the active ProblemListener and XMLParserLiaison decide |
| * the error condition is severe enough to halt processing. |
| */ |
| void |
| PathExpr(); |
| |
| /** |
| * |
| * -------------------------------------------------------------------------------- |
| FilterExpr ::= PrimaryExpr |
| | FilterExpr Predicate |
| * -------------------------------------------------------------------------------- |
| * @exception XSLProcessorException thrown if the active ProblemListener and XMLParserLiaison decide |
| * the error condition is severe enough to halt processing. |
| */ |
| void |
| FilterExpr(); |
| |
| /** |
| * -------------------------------------------------------------------------------- |
| PrimaryExpr ::= VariableReference |
| | '(' Expr ')' |
| | Literal |
| | Number |
| | FunctionCall |
| * -------------------------------------------------------------------------------- |
| */ |
| void |
| PrimaryExpr(); |
| |
| |
| /** |
| * -------------------------------------------------------------------------------- |
| Argument ::= Expr |
| * -------------------------------------------------------------------------------- |
| */ |
| void |
| Argument(); |
| |
| /** |
| * -------------------------------------------------------------------------------- |
| FunctionCall ::= FunctionName '(' ( Argument ( ',' Argument)*)? ')' |
| * -------------------------------------------------------------------------------- |
| */ |
| void |
| FunctionCall(); |
| |
| void |
| FunctionPosition(); |
| |
| void |
| FunctionLast(); |
| |
| void |
| FunctionCount(); |
| |
| void |
| FunctionNot(); |
| |
| void |
| FunctionTrue(); |
| |
| void |
| FunctionFalse(); |
| |
| void |
| FunctionBoolean(); |
| |
| void |
| FunctionName(int opPos); |
| |
| void |
| FunctionLocalName(int opPos); |
| |
| void |
| FunctionNumber(int opPos); |
| |
| void |
| FunctionFloor(); |
| |
| void |
| FunctionCeiling(); |
| |
| void |
| FunctionRound(); |
| |
| void |
| FunctionString(int opPos); |
| |
| void |
| FunctionStringLength(int opPos); |
| |
| void |
| FunctionSum(); |
| |
| void |
| FunctionNamespaceURI(int opPos); |
| |
| /** |
| * -------------------------------------------------------------------------------- |
| LocationPath ::= RelativeLocationPath |
| | AbsoluteLocationPath |
| * -------------------------------------------------------------------------------- |
| */ |
| void |
| LocationPath(); |
| |
| /** |
| * -------------------------------------------------------------------------------- |
| RelativeLocationPath ::= Step |
| | RelativeLocationPath '/' Step |
| | AbbreviatedRelativeLocationPath |
| * -------------------------------------------------------------------------------- |
| */ |
| void |
| RelativeLocationPath(); |
| |
| /** |
| * -------------------------------------------------------------------------------- |
| Step ::= Basis Predicate* |
| | AbbreviatedStep |
| */ |
| void |
| Step(); |
| |
| /** |
| * -------------------------------------------------------------------------------- |
| Basis ::= AxisName '::' NodeTest |
| | AbbreviatedBasis |
| */ |
| void |
| Basis(); |
| |
| /** |
| * -------------------------------------------------------------------------------- |
| Basis ::= AxisName '::' NodeTest |
| | AbbreviatedBasis |
| */ |
| XPathExpression::eOpCodes |
| AxisName(); |
| |
| /** |
| * -------------------------------------------------------------------------------- |
| NodeTest ::= WildcardName |
| | NodeType '(' ')' |
| | 'processing-instruction' '(' Literal ')' |
| */ |
| int |
| NodeTest(); |
| |
| /** |
| * -------------------------------------------------------------------------------- |
| Predicate ::= '[' PredicateExpr ']' |
| * -------------------------------------------------------------------------------- |
| */ |
| void |
| Predicate(); |
| |
| /** |
| *-------------------------------------------------------------------------------- |
| PredicateExpr ::= Expr |
| *-------------------------------------------------------------------------------- |
| */ |
| void |
| PredicateExpr(); |
| |
| /** |
| * QName ::= (Prefix ':')? LocalPart |
| * Prefix ::= NCName |
| * LocalPart ::= NCName |
| */ |
| void |
| QName(); |
| |
| /** |
| * NCName ::= (Letter | '_') (NCNameChar)* |
| * NCNameChar ::= Letter | Digit | '.' | '-' | '_' | CombiningChar | Extender |
| */ |
| void |
| NCName(); |
| |
| /** |
| * The value of the Literal is the sequence of characters inside |
| * the " or ' characters>. |
| * -------------------------------------------------------------------------------- |
| Literal ::= '"' [^"]* '"' |
| | "'" [^']* "'" |
| * -------------------------------------------------------------------------------- |
| */ |
| void |
| Literal(); |
| |
| /** |
| * -------------------------------------------------------------------------------- |
| * Number ::= [0-9]+('.'[0-9]+)? | '.'[0-9]+ |
| * -------------------------------------------------------------------------------- |
| */ |
| void |
| Number(); |
| |
| /** |
| * -------------------------------------------------------------------------------- |
| Pattern ::= LocationPathPattern |
| | Pattern '|' LocationPathPattern |
| * -------------------------------------------------------------------------------- |
| */ |
| void |
| Pattern(); |
| |
| /** |
| * |
| * -------------------------------------------------------------------------------- |
| LocationPathPattern ::= '/' RelativePathPattern? |
| | IdKeyPattern (('/' | '//') RelativePathPattern)? |
| | '//'? RelativePathPattern |
| * -------------------------------------------------------------------------------- |
| */ |
| void |
| LocationPathPattern(); |
| |
| /** |
| * -------------------------------------------------------------------------------- |
| IdKeyPattern ::= 'id' '(' Literal ')' |
| | 'key' '(' Literal ',' Literal ')' |
| * (Also handle doc()) |
| * -------------------------------------------------------------------------------- |
| */ |
| void |
| IdKeyPattern(); |
| |
| /** |
| * -------------------------------------------------------------------------------- |
| RelativePathPattern ::= StepPattern |
| | RelativePathPattern '/' StepPattern |
| | RelativePathPattern '//' StepPattern |
| * -------------------------------------------------------------------------------- |
| */ |
| void |
| RelativePathPattern(); |
| |
| /** |
| * -------------------------------------------------------------------------------- |
| StepPattern ::= AbbreviatedNodeTestStep |
| * -------------------------------------------------------------------------------- |
| */ |
| void |
| StepPattern(); |
| |
| /** |
| * -------------------------------------------------------------------------------- |
| AbbreviatedNodeTestStep ::= '@'? NodeTest Predicate* |
| * -------------------------------------------------------------------------------- |
| */ |
| void |
| AbbreviatedNodeTestStep(); |
| |
| static bool |
| isValidFunction(const XalanDOMString& key); |
| |
| private: |
| |
| int |
| FunctionCallArguments(); |
| |
| struct TableEntry |
| { |
| const XalanDOMChar* m_string; |
| |
| XPathExpression::eOpCodes m_opCode; |
| }; |
| |
| typedef std::size_t size_type; |
| |
| static const TableEntry& |
| searchTable( |
| const TableEntry theTable[], |
| size_type theTableSize, |
| const XalanDOMString& theString); |
| |
| /** |
| * The current input token. |
| */ |
| XalanDOMString m_token; |
| |
| /** |
| * The first char in m_token, the theory being that this |
| * is an optimization because we won't have to do index |
| * into the string as often. |
| */ |
| XalanDOMChar m_tokenChar; |
| |
| /** |
| * A pointer to the current XPath. |
| */ |
| XPath* m_xpath; |
| |
| /** |
| * A pointer to the current XPathConstructionContext. |
| */ |
| XPathConstructionContext* m_constructionContext; |
| |
| /** |
| * A pointer to the current XPath's expression. |
| */ |
| XPathExpression* m_expression; |
| |
| /** |
| * A pointer to the current executionContext. |
| */ |
| const PrefixResolver* m_prefixResolver; |
| |
| bool m_requireLiterals; |
| |
| bool m_isMatchPattern; |
| |
| const Locator* m_locator; |
| |
| BoolVectorType m_positionPredicateStack; |
| |
| StringToStringMapType m_namespaces; |
| |
| bool m_allowVariableReferences; |
| |
| bool m_allowKeyFunction; |
| |
| // Static stuff here... |
| static const XalanDOMString s_emptyString; |
| |
| static const XalanDOMChar s_functionIDString[]; |
| |
| // This shouldn't really be here, since it's not part of the XPath standard, |
| // but rather a part ofthe XSLT standard. |
| static const XalanDOMChar s_functionKeyString[]; |
| |
| static const XalanDOMChar s_orString[]; |
| |
| static const XalanDOMChar s_andString[]; |
| |
| static const XalanDOMChar s_divString[]; |
| |
| static const XalanDOMChar s_modString[]; |
| |
| static const XalanDOMChar s_dotString[]; |
| |
| static const XalanDOMChar s_dotDotString[]; |
| |
| static const XalanDOMChar s_axisString[]; |
| |
| static const XalanDOMChar s_attributeString[]; |
| |
| static const XalanDOMChar s_childString[]; |
| |
| static const XalanDOMChar s_lastString[]; |
| |
| static const XalanDOMChar s_positionString[]; |
| |
| static const XalanDOMChar s_asteriskString[]; |
| |
| static const XalanDOMChar s_commentString[]; |
| |
| static const XalanDOMChar s_piString[]; |
| |
| static const XalanDOMChar s_nodeString[]; |
| |
| static const XalanDOMChar s_textString[]; |
| |
| static const XalanDOMChar s_ancestorString[]; |
| |
| static const XalanDOMChar s_ancestorOrSelfString[]; |
| |
| static const XalanDOMChar s_descendantString[]; |
| |
| static const XalanDOMChar s_descendantOrSelfString[]; |
| |
| static const XalanDOMChar s_followingString[]; |
| |
| static const XalanDOMChar s_followingSiblingString[]; |
| |
| static const XalanDOMChar s_parentString[]; |
| |
| static const XalanDOMChar s_precedingString[]; |
| |
| static const XalanDOMChar s_precedingSiblingString[]; |
| |
| static const XalanDOMChar s_selfString[]; |
| |
| static const XalanDOMChar s_namespaceString[]; |
| |
| static const TableEntry s_functionTable[]; |
| |
| static const size_type s_functionTableSize; |
| |
| static const TableEntry s_nodeTypeTable[]; |
| |
| static const size_type s_nodeTypeTableSize; |
| |
| static const TableEntry s_axisTable[]; |
| |
| static const size_type s_axisTableSize; |
| |
| static const TableEntry s_dummyEntry; |
| }; |
| |
| |
| |
| } |
| |
| |
| |
| #endif // XPATHPROCESSORIMPL_HEADER_GUARD_1357924680 |
