开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > xml/soap/webservice > 查看源码
XercesXPath.cpp
资源名称：xerces-c-src1_6_0.tar.gz　[点击查看]
上传用户：huihehuasu
上传日期：2007-01-10
资源大小：6948k
文件大小：47k
源码类别：

xml/soap/webservice

开发平台：

C/C++

XercesXPath.cpp：源码内容
  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 2001 The Apache Software Foundation.  All rights
  5.  * reserved.
  6.  *
  7.  * Redistribution and use in source and binary forms, with or without
  8.  * modification, are permitted provided that the following conditions
  9.  * are met:
  10.  *
  11.  * 1. Redistributions of source code must retain the above copyright
  12.  *    notice, this list of conditions and the following disclaimer.
  13.  *
  14.  * 2. Redistributions in binary form must reproduce the above copyright
  15.  *    notice, this list of conditions and the following disclaimer in
  16.  *    the documentation and/or other materials provided with the
  17.  *    distribution.
  18.  *
  19.  * 3. The end-user documentation included with the redistribution,
  20.  *    if any, must include the following acknowledgment:
  21.  *       "This product includes software developed by the
  22.  *        Apache Software Foundation (http://www.apache.org/)."
  23.  *    Alternately, this acknowledgment may appear in the software itself,
  24.  *    if and wherever such third-party acknowledgments normally appear.
  25.  *
  26.  * 4. The names "Xerces" and "Apache Software Foundation" must
  27.  *    not be used to endorse or promote products derived from this
  28.  *    software without prior written permission. For written
  29.  *    permission, please contact apache@apache.org.
  30.  *
  31.  * 5. Products derived from this software may not be called "Apache",
  32.  *    nor may "Apache" appear in their name, without prior written
  33.  *    permission of the Apache Software Foundation.
  34.  *
  35.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
  36.  * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  37.  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  38.  * DISCLAIMED.  IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
  39.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  40.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  41.  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
  42.  * USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
  43.  * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  44.  * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
  45.  * OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  46.  * SUCH DAMAGE.
  47.  * ====================================================================
  48.  *
  49.  * This software consists of voluntary contributions made by many
  50.  * individuals on behalf of the Apache Software Foundation, and was
  51.  * originally based on software copyright (c) 1999, International
  52.  * Business Machines, Inc., http://www.ibm.com .  For more information
  53.  * on the Apache Software Foundation, please see
  54.  * <http://www.apache.org/>.
  55.  */
  57. /*
  58.  * $Log: XercesXPath.cpp,v $
  59.  * Revision 1.3  2001/11/15 17:10:19  knoaman
  60.  * Particle derivation checking support.
  61.  *
  62.  * Revision 1.2  2001/11/07 14:25:36  knoaman
  63.  * Fix compliation error on Unix.
  64.  *
  65.  * Revision 1.1  2001/11/02 14:08:40  knoaman
  66.  * Add support for identity constraints.
  67.  *
  68.  */
  70. // ---------------------------------------------------------------------------
  71. //  Includes
  72. // ---------------------------------------------------------------------------
  73. #include <validators/schema/identity/XercesXPath.hpp>
  74. #include <validators/schema/identity/XPathSymbols.hpp>
  75. #include <validators/schema/identity/XPathException.hpp>
  76. #include <validators/schema/NamespaceScope.hpp>
  77. #include <util/StringPool.hpp>
  78. #include <util/Janitor.hpp>
  79. #include <framework/XMLBuffer.hpp>
  80. #include <internal/XMLReader.hpp>
  81. #include <util/RuntimeException.hpp>
  84. // ---------------------------------------------------------------------------
  85. //  Static data
  86. // ---------------------------------------------------------------------------
  87. const XMLByte XPathScanner::fASCIICharMap[128] = 
  88. {
  89.     0,  0,  0,  0,  0,  0,  0,  0,  0,  2,  2,  0,  0,  2,  0,  0,
  90.     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  91.     2,  3,  4,  1,  5,  1,  1,  4,  6,  7,  8,  9, 10, 11, 12, 13,
  92.     14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15,  1, 16, 17, 18,  1,
  93.     19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
  94.     20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 21,  1, 22,  1, 23,
  95.     1, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
  96.     20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,  1, 24,  1,  1,  1
  97. };
  100. // ---------------------------------------------------------------------------
  101. //  XercesNodeTest: Constructors and Destructor
  102. // ---------------------------------------------------------------------------
  103. XercesNodeTest::XercesNodeTest(const short aType)
  104.     : fType(aType)
  105.     , fName(new QName())
  106. {
  107. }
  109. XercesNodeTest::XercesNodeTest(const QName* const qName)
  110.     : fType(QNAME)
  111.     , fName(new QName(qName))
  112. {
  113. }
  115. XercesNodeTest::XercesNodeTest(const XMLCh* const prefix,
  116.                                const unsigned int uriId)
  117.     : fType(NAMESPACE)
  118.     , fName(new QName())
  119. {
  120.     fName->setURI(uriId);
  121.     fName->setPrefix(prefix);
  122. }
  124. XercesNodeTest::XercesNodeTest(const XercesNodeTest& other)
  125.     : fType(other.fType)
  126.     , fName(new QName(other.fName))
  127. {
  128. }
  130. // ---------------------------------------------------------------------------
  131. //  XercesNodeTest: Operators
  132. // ---------------------------------------------------------------------------
  133. XercesNodeTest& XercesNodeTest::operator=(const XercesNodeTest& other)
  134. {
  135.     if (this == &other)
  136.         return *this;
  138.     fType = other.fType;
  139.     fName->setValues(*(other.fName));
  140.     return *this;
  141. }
  143. bool XercesNodeTest::operator ==(const XercesNodeTest& other) const {
  145.     if (this == &other)
  146.         return true;
  148.     if (fType != other.fType)
  149.         return false;
  151.     return (*fName == *(other.fName));
  152. }
  155. bool XercesNodeTest::operator !=(const XercesNodeTest& other) const {
  157.     return !operator==(other);
  158. }
  160. // ---------------------------------------------------------------------------
  161. //  XercesStep: Constructors and Destructor
  162. // ---------------------------------------------------------------------------
  163. XercesStep::XercesStep(const unsigned short axisType, XercesNodeTest* const nodeTest)
  164.     : fAxisType(axisType)
  165.     , fNodeTest(nodeTest)
  166. {
  167. }
  169. XercesStep::XercesStep(const XercesStep& other)
  170.     : fAxisType(other.fAxisType)
  171.     , fNodeTest(0)
  172. {
  173.     fNodeTest = new XercesNodeTest(*(other.fNodeTest));
  174. }
  177. // ---------------------------------------------------------------------------
  178. //  XercesStep: Operators
  179. // ---------------------------------------------------------------------------
  180. XercesStep& XercesStep::operator=(const XercesStep& other)
  181. {
  182.     if (this == &other)
  183.         return *this;
  185.     fAxisType = other.fAxisType;
  186.     *fNodeTest = *(other.fNodeTest);
  187.     return *this;
  188. }
  190. bool XercesStep::operator==(const XercesStep& other) const {
  192.     if (this == &other)
  193.         return true;
  195.     if (fAxisType != other.fAxisType)
  196.         return false;
  198.     if (fAxisType == XercesStep::CHILD ||
  199.         fAxisType == XercesStep::ATTRIBUTE) {
  200.         return (*fNodeTest == *(other.fNodeTest));
  201.     }
  203.     return true;
  204. }
  206. bool XercesStep::operator!=(const XercesStep& other) const {
  208.     return !operator==(other);
  209. }
  211. // ---------------------------------------------------------------------------
  212. //  XercesLocationPath: Constructors and Destructor
  213. // ---------------------------------------------------------------------------
  214. XercesLocationPath::XercesLocationPath()
  215.     : fSteps(0)
  216. {
  217. }
  219. XercesLocationPath::XercesLocationPath(RefVectorOf<XercesStep>* const steps)
  220.     : fSteps(steps)
  221. {
  222. }
  224. // ---------------------------------------------------------------------------
  225. //  XercesLocationPath: Operators
  226. // ---------------------------------------------------------------------------
  227. bool XercesLocationPath::operator==(const XercesLocationPath& other) const {
  229.     unsigned int stepsSize = fSteps->size();
  231.     if (stepsSize != other.fSteps->size())
  232.         return false;
  234.     for (unsigned int i=0; i < stepsSize; i++) {
  235.         if (*(fSteps->elementAt(i)) != *(other.fSteps->elementAt(i)))
  236.             return false;
  237.     }
  239.     return true;
  240. }
  242. bool XercesLocationPath::operator!=(const XercesLocationPath& other) const {
  244.     return !operator==(other);
  245. }
  247. // ---------------------------------------------------------------------------
  248. //  XercesPath: Constructors and Destructor
  249. // ---------------------------------------------------------------------------
  250. XercesXPath::XercesXPath(const XMLCh* const xpathExpr,
  251.                          XMLStringPool* const stringPool,
  252.                          NamespaceScope* const scopeContext,
  253.                          const unsigned int emptyNamespaceId,
  254.                          const bool isSelector)
  255.     : fEmptyNamespaceId(emptyNamespaceId)
  256.     , fExpression(XMLString::replicate(xpathExpr))
  257.     , fLocationPaths(0)
  258. {
  259.     try {
  260.         parseExpression(stringPool, scopeContext);
  262.         if (isSelector) {
  263.             checkForSelectedAttributes();
  264.         }
  265.     }
  266.     catch(...) {
  268.         cleanUp();
  269.         throw;
  270.     }
  271. }
  273. XercesXPath::~XercesXPath() {
  274.     cleanUp();
  275. }
  278. // ---------------------------------------------------------------------------
  279. //  XercesXPath: Operators
  280. // ---------------------------------------------------------------------------
  281. bool XercesXPath::operator==(const XercesXPath& other) const {
  283.     unsigned int locPathSize = fLocationPaths->size();
  285.     if (locPathSize != other.fLocationPaths->size())
  286.         return false;
  288.     for (unsigned int i=0; i < locPathSize; i++) {
  289.         if (*(fLocationPaths->elementAt(i)) != *(other.fLocationPaths->elementAt(i)))
  290.             return false;
  291.     }
  293.     return true;
  294. }
  296. bool XercesXPath::operator!=(const XercesXPath& other) const {
  298.     return !operator==(other);
  299. }
  301. // ---------------------------------------------------------------------------
  302. //  XercesPath: Helper methods
  303. // ---------------------------------------------------------------------------
  304. void XercesXPath::cleanUp() {
  306.     delete [] fExpression;
  307.     delete fLocationPaths;
  308. }
  310. void XercesXPath::checkForSelectedAttributes() {
  312.     // verify that an attribute is not selected
  313.     unsigned int locSize = (fLocationPaths) ? fLocationPaths->size() : 0;
  315.     for (unsigned int i = 0; i < locSize; i++) {
  317.         XercesLocationPath* locPath = fLocationPaths->elementAt(i);
  318.         unsigned int stepSize = locPath->getStepSize();
  320.         if (stepSize) {
  321.             if (locPath->getStep(stepSize - 1)->getAxisType() == XercesStep::ATTRIBUTE) {
  322.                 ThrowXML(XPathException, XMLExcepts::XPath_NoAttrSelector);
  323.             }        
  324. }
  325.     }
  326. }
  328. void XercesXPath::parseExpression(XMLStringPool* const stringPool,
  329.                                   NamespaceScope* const scopeContext) {
  331.     unsigned int length = XMLString::stringLen(fExpression);
  333.     if (!length) {
  334.         return;
  335.     }
  337.     ValueVectorOf<int>                tokens(16);
  338.     XPathScannerForSchema             scanner(stringPool);
  339.     bool                              success = scanner.scanExpression(fExpression, 0, length, &tokens);
  340.     bool                              firstTokenOfLocationPath=true;
  341.     unsigned int                      tokenCount = tokens.size();
  342.     RefVectorOf<XercesStep>*          stepsVector = new RefVectorOf<XercesStep>(16);
  343.     Janitor<RefVectorOf<XercesStep> > janSteps(stepsVector);
  345.     if (tokenCount) {
  346.         fLocationPaths = new RefVectorOf<XercesLocationPath>(8);
  347.     }
  349.     for (unsigned int i = 0; i < tokenCount; i++) {
  351.         int  aToken = tokens.elementAt(i);
  352.         bool isNamespace=false;
  354.         switch (aToken) {
  355.         case  XercesXPath::EXPRTOKEN_OPERATOR_UNION:
  356.             {
  357.                 if (i == 0) {
  358.                     ThrowXML(XPathException, XMLExcepts::XPath_NoUnionAtStart);
  359.                 }
  361.                 int stepsSize = stepsVector->size();
  363.                 if (stepsSize == 0) {
  364.                     ThrowXML(XPathException, XMLExcepts::XPath_NoMultipleUnion);
  365.                 }
  367.                 fLocationPaths->addElement(new XercesLocationPath(stepsVector));
  368.                 janSteps.orphan();
  369.                 stepsVector = new RefVectorOf<XercesStep>(16);
  370.                 janSteps.reset(stepsVector);
  371.                 firstTokenOfLocationPath = true;
  372.             }
  373.             break;
  374.         case XercesXPath::EXPRTOKEN_AXISNAME_ATTRIBUTE:
  375.             {
  376.                 // consume "::" token and drop through
  377.                 i++;
  378.             }
  379.         case XercesXPath::EXPRTOKEN_ATSIGN:
  380.             {
  381.                 // consume QName token
  382.                 if (i == tokenCount - 1) {
  383.                     ThrowXML(XPathException, XMLExcepts::XPath_MissingAttr);
  384.                 }
  386.                 aToken = tokens.elementAt(++i);
  388.                 if (aToken != XercesXPath::EXPRTOKEN_NAMETEST_QNAME
  389.                     && aToken!= XercesXPath::EXPRTOKEN_NAMETEST_ANY
  390.                     && aToken!= XercesXPath::EXPRTOKEN_NAMETEST_NAMESPACE) {
  391.                         ThrowXML(XPathException, XMLExcepts::XPath_ExpectedToken1);
  392.                 }
  394.                 bool isNamespaceAtt=false;
  396.                 switch (aToken) {
  398.                 case XercesXPath::EXPRTOKEN_NAMETEST_ANY:
  399.                     {
  400.                         XercesNodeTest* nodeTest = new XercesNodeTest(XercesNodeTest::WILDCARD);
  401.                         XercesStep* step = new XercesStep(XercesStep::ATTRIBUTE, nodeTest);
  402.                         stepsVector->addElement(step);
  403.                         break;
  404.                     }
  405.                 case XercesXPath::EXPRTOKEN_NAMETEST_NAMESPACE:
  406.                     {
  407.                         isNamespaceAtt = true;
  408.                     }
  409.                 case XercesXPath::EXPRTOKEN_NAMETEST_QNAME:
  410.                     {
  411.                         aToken = tokens.elementAt(++i);
  413.                         const XMLCh* prefix = XMLUni::fgZeroLenString;
  414.                         unsigned int uri = fEmptyNamespaceId;
  416.                         if (scopeContext && aToken != -1) {
  418.                             prefix = stringPool->getValueForId(aToken);
  419.                             uri = scopeContext->getNamespaceForPrefix(prefix);
  420.                         }
  422.                         if (aToken != -1 && scopeContext && uri == fEmptyNamespaceId) {
  423.                             ThrowXML1(XPathException, XMLExcepts::XPath_PrefixNoURI, prefix);
  424.                         }
  426.                         if (isNamespaceAtt) {
  428.                             // build step
  429.                             XercesNodeTest* nodeTest = new XercesNodeTest(prefix, uri);
  430.                             XercesStep* step = new XercesStep(XercesStep::ATTRIBUTE, nodeTest);
  431.                             stepsVector->addElement(step);
  432.                             break;
  433.                         }
  435.                         aToken = tokens.elementAt(++i);
  437.                         const XMLCh* localPart = stringPool->getValueForId(aToken);
  438.                         QName aQName(prefix, localPart, uri);
  440.                         // build step
  441.                         XercesNodeTest* nodeTest = new XercesNodeTest(&aQName);
  442.                         XercesStep* step = new XercesStep(XercesStep::ATTRIBUTE, nodeTest);
  443.                         stepsVector->addElement(step);
  444.                         break;
  445.                     }
  446. }
  448.                 firstTokenOfLocationPath=false;
  449.                 break;
  450.             }
  451.         case XercesXPath::EXPRTOKEN_DOUBLE_COLON: 
  452.             {
  453.                 // should never have a bare double colon
  454.                 ThrowXML(XPathException, XMLExcepts::XPath_NoDoubleColon);
  455.             }
  456.         case XercesXPath::EXPRTOKEN_AXISNAME_CHILD:
  457.             {
  458.                 // consume "::" token and drop through
  459.                 i++;
  461.                 if (i == tokenCount - 1) {
  462.                     ThrowXML(XPathException, XMLExcepts::XPath_ExpectedStep1);
  463.                 }
  465.                 firstTokenOfLocationPath=false;
  466.                 break;
  467.             }
  468.         case XercesXPath::EXPRTOKEN_NAMETEST_ANY:
  469.             {
  470.                 XercesNodeTest* nodeTest = new XercesNodeTest(XercesNodeTest::WILDCARD);
  471.                 XercesStep* step = new XercesStep(XercesStep::CHILD, nodeTest);
  472.                 stepsVector->addElement(step);
  473.                 firstTokenOfLocationPath = false;
  474.                 break;
  475.             }
  476.         case XercesXPath::EXPRTOKEN_NAMETEST_NAMESPACE:
  477.             {
  478.                 isNamespace=true;
  479.             }
  480.         case XercesXPath::EXPRTOKEN_NAMETEST_QNAME:
  481.             {
  482.                 // consume QName token
  483.                 aToken = tokens.elementAt(++i);
  485.                 const XMLCh* prefix = XMLUni::fgZeroLenString;
  486.                 unsigned int uri = fEmptyNamespaceId;
  488.                 if (scopeContext && aToken != -1) {
  490.                     prefix = stringPool->getValueForId(aToken);
  491.                     uri = scopeContext->getNamespaceForPrefix(prefix);
  492.                 }
  494.                 if (aToken != -1 && scopeContext && uri == fEmptyNamespaceId) {
  495.                     ThrowXML1(XPathException, XMLExcepts::XPath_PrefixNoURI, prefix);
  496.                 }
  498.                 if (isNamespace) {
  500.                     // build step
  501.                     XercesNodeTest* nodeTest = new XercesNodeTest(prefix, uri);
  502.                     XercesStep* step = new XercesStep(XercesStep::CHILD, nodeTest);
  503.                     stepsVector->addElement(step);
  504.                     break;
  505.                 }
  507.                 aToken = tokens.elementAt(++i);
  508.                 const XMLCh* localPart = stringPool->getValueForId(aToken);
  509.                 QName aQName(prefix, localPart, uri);
  511.                 // build step
  512.                 XercesNodeTest* nodeTest = new XercesNodeTest(&aQName);
  513.                 XercesStep* step = new XercesStep(XercesStep::CHILD, nodeTest);
  514.                 stepsVector->addElement(step);
  515.                 firstTokenOfLocationPath = false;
  516.                 break;
  517.             }
  518.         case XercesXPath::EXPRTOKEN_PERIOD:
  519.             {
  520.                 // build step
  521.                 XercesNodeTest* nodeTest = new XercesNodeTest(XercesNodeTest::NODE);
  522.                 XercesStep* step = new XercesStep(XercesStep::SELF, nodeTest);
  523.                 stepsVector->addElement(step);
  525.                 if (firstTokenOfLocationPath && i+1 < tokenCount) {
  527.                     aToken = tokens.elementAt(i+1);
  529.                     if (aToken == XercesXPath::EXPRTOKEN_OPERATOR_DOUBLE_SLASH){
  531.                         if (++i == tokenCount - 1) {
  532.                             ThrowXML(XPathException, XMLExcepts::XPath_ExpectedStep2);
  533.                         }
  535.                         if (i+1 < tokenCount) {
  537.                             aToken = tokens.elementAt(i+1);
  539.                             if (aToken == XercesXPath::EXPRTOKEN_OPERATOR_SLASH) {
  540.                                 ThrowXML(XPathException, XMLExcepts::XPath_NoForwardSlash);
  541.                             }
  542.                         }
  543.                         // build step
  544.                         nodeTest = new XercesNodeTest(XercesNodeTest::NODE);
  545.                         step = new XercesStep(XercesStep::DESCENDANT, nodeTest);
  546.                         stepsVector->addElement(step);
  547.                     }
  548.                 }
  549.                 firstTokenOfLocationPath=false;
  550.                 break;
  551.             }
  552.         case XercesXPath::EXPRTOKEN_OPERATOR_DOUBLE_SLASH:
  553.             {
  554.                 ThrowXML(XPathException, XMLExcepts::XPath_NoDoubleForwardSlash); 
  555.             }
  556.         case XercesXPath::EXPRTOKEN_OPERATOR_SLASH:
  557.             {
  558.                 if (i == 0) {
  559.                     ThrowXML(XPathException, XMLExcepts::XPath_NoForwardSlashAtStart); 
  560.                 }
  562.                 // keep on truckin'
  563.                 if (firstTokenOfLocationPath) {
  564.                     ThrowXML(XPathException, XMLExcepts::XPath_NoSelectionOfRoot); 
  565.                 }
  567.                 if (i == tokenCount - 1) {
  568.                     ThrowXML(XPathException, XMLExcepts::XPath_ExpectedStep3); 
  569.                 }
  571.                 firstTokenOfLocationPath=false;
  572.                 break;
  573.             }
  574.         default:
  575.             firstTokenOfLocationPath=false;
  576.         }
  577.     }
  579.     int stepsSize = stepsVector->size();
  581.     if (stepsSize == 0) {
  582.         if (!fLocationPaths || fLocationPaths->size() == 0) {
  583.             ThrowXML(XPathException, XMLExcepts::XPath_EmptyExpr);
  584.         }
  585.         else {
  586.             ThrowXML(XPathException, XMLExcepts::XPath_NoUnionAtEnd);
  587.         }
  588.     }
  590.     fLocationPaths->addElement(new XercesLocationPath(stepsVector));
  591.     janSteps.orphan();
  592. }
  594. // ---------------------------------------------------------------------------
  595. //  XPathScanner: Constructors and Destructor
  596. // ---------------------------------------------------------------------------
  597. XPathScanner::XPathScanner(XMLStringPool* const stringPool)
  598.     : fAndSymbol (0)
  599.     , fOrSymbol(0)
  600.     , fModSymbol(0)
  601.     , fDivSymbol(0)
  602.     , fCommentSymbol(0)
  603.     , fTextSymbol(0)
  604.     , fPISymbol(0)
  605.     , fNodeSymbol(0)
  606.     , fAncestorSymbol(0)
  607.     , fAncestorOrSelfSymbol(0)
  608.     , fAttributeSymbol(0)
  609.     , fChildSymbol(0)
  610.     , fDescendantSymbol(0)
  611.     , fDescendantOrSelfSymbol(0)
  612.     , fFollowingSymbol(0)
  613.     , fFollowingSiblingSymbol(0)
  614.     , fNamespaceSymbol(0)
  615.     , fParentSymbol(0)
  616.     , fPrecedingSymbol(0)
  617.     , fPrecedingSiblingSymbol(0)
  618.     , fSelfSymbol(0)
  619.     , fStringPool(stringPool)
  620. {
  621.     init();
  622. }
  624. // ---------------------------------------------------------------------------
  625. //  XPathScanner: Helper methods
  626. // ---------------------------------------------------------------------------
  627. void XPathScanner::init() {
  629.     fAndSymbol = fStringPool->addOrFind(XPathSymbols::fgSYMBOL_AND);
  630.     fOrSymbol = fStringPool->addOrFind(XPathSymbols::fgSYMBOL_OR);
  631.     fModSymbol = fStringPool->addOrFind(XPathSymbols::fgSYMBOL_MOD);
  632.     fDivSymbol = fStringPool->addOrFind(XPathSymbols::fgSYMBOL_DIV);
  633.     fCommentSymbol = fStringPool->addOrFind(XPathSymbols::fgSYMBOL_COMMENT);
  634.     fTextSymbol = fStringPool->addOrFind(XPathSymbols::fgSYMBOL_TEXT);
  635.     fPISymbol = fStringPool->addOrFind(XPathSymbols::fgSYMBOL_PI);
  636.     fNodeSymbol = fStringPool->addOrFind(XPathSymbols::fgSYMBOL_NODE);
  637.     fAncestorSymbol = fStringPool->addOrFind(XPathSymbols::fgSYMBOL_ANCESTOR);
  638.     fAncestorOrSelfSymbol = fStringPool->addOrFind(XPathSymbols::fgSYMBOL_ANCESTOR_OR_SELF);
  639.     fAttributeSymbol = fStringPool->addOrFind(XPathSymbols::fgSYMBOL_ATTRIBUTE);
  640.     fChildSymbol = fStringPool->addOrFind(XPathSymbols::fgSYMBOL_CHILD);
  641.     fDescendantSymbol = fStringPool->addOrFind(XPathSymbols::fgSYMBOL_DESCENDANT);
  642.     fDescendantOrSelfSymbol = fStringPool->addOrFind(XPathSymbols::fgSYMBOL_DESCENDANT_OR_SELF);
  643.     fFollowingSymbol = fStringPool->addOrFind(XPathSymbols::fgSYMBOL_FOLLOWING);
  644.     fFollowingSiblingSymbol = fStringPool->addOrFind(XPathSymbols::fgSYMBOL_FOLLOWING_SIBLING);
  645.     fNamespaceSymbol = fStringPool->addOrFind(XPathSymbols::fgSYMBOL_NAMESPACE);
  646.     fParentSymbol = fStringPool->addOrFind(XPathSymbols::fgSYMBOL_PARENT);
  647.     fPrecedingSymbol = fStringPool->addOrFind(XPathSymbols::fgSYMBOL_PRECEDING);
  648.     fPrecedingSiblingSymbol = fStringPool->addOrFind(XPathSymbols::fgSYMBOL_PRECEDING_SIBLING);
  649.     fSelfSymbol = fStringPool->addOrFind(XPathSymbols::fgSYMBOL_SELF);
  650. }
  653. // ---------------------------------------------------------------------------
  654. //  XPathScanner: Scan methods
  655. // ---------------------------------------------------------------------------
  656. bool XPathScanner::scanExpression(const XMLCh* const data,
  657.                                   int currentOffset,
  658.                                   const int endOffset,
  659.                                   ValueVectorOf<int>* const tokens) {
  661.     bool      starIsMultiplyOperator = false;
  662.     int       nameOffset = -1;
  663.     int       nameHandle = -1;
  664.     int       prefixHandle = -1;
  665.     XMLCh     ch;
  666.     XMLBuffer dataBuffer(128);
  668.     while (true) {
  670.         if (currentOffset == endOffset) {
  671.             break;
  672.         }
  674.         ch = data[currentOffset];
  676.         while (XMLReader::isWhitespace(ch)) {
  678.             if (++currentOffset == endOffset) {
  679.                 break;
  680.             }
  682.             ch = data[currentOffset];
  683.         }
  685.         if (currentOffset == endOffset) {
  686.             break;
  687.         }
  688.         //
  689.         // [28] ExprToken ::= '(' | ')' | '[' | ']' | '.' | '..' | '@' | ',' | '::'
  690.         //                  | NameTest | NodeType | Operator | FunctionName
  691.         //                  | AxisName | Literal | Number | VariableReference
  692.         //
  693.         XMLByte chartype = (ch >= 0x80) ? CHARTYPE_NONASCII : fASCIICharMap[ch];
  695.         switch (chartype) {
  696.         case CHARTYPE_OPEN_PAREN:       // '('
  697.             addToken(tokens, XercesXPath::EXPRTOKEN_OPEN_PAREN);
  698.             starIsMultiplyOperator = false;
  699.             ++currentOffset;
  700.             break;
  701.         case CHARTYPE_CLOSE_PAREN:      // ')'
  702.             addToken(tokens, XercesXPath::EXPRTOKEN_CLOSE_PAREN);
  703.             starIsMultiplyOperator = true;
  704.             ++currentOffset;
  705.             break;
  706.         case CHARTYPE_OPEN_BRACKET:     // '['
  707.             addToken(tokens, XercesXPath::EXPRTOKEN_OPEN_BRACKET);
  708.             starIsMultiplyOperator = false;
  709.             ++currentOffset;
  710.             break;
  711.         case CHARTYPE_CLOSE_BRACKET:    // ']'
  712.             addToken(tokens, XercesXPath::EXPRTOKEN_CLOSE_BRACKET);
  713.             starIsMultiplyOperator = true;
  714.             ++currentOffset;
  715.             break;
  716.                 //
  717.                 // [30] Number ::= Digits ('.' Digits?)? | '.' Digits
  718.                 //                                         ^^^^^^^^^^
  719.                 //
  720.         case CHARTYPE_PERIOD:           // '.', '..' or '.' Digits
  721.             if (currentOffset + 1 == endOffset) {
  722.                 addToken(tokens, XercesXPath::EXPRTOKEN_PERIOD);
  723.                 starIsMultiplyOperator = true;
  724.                 currentOffset++;
  725.                 break;
  726.             }
  728.             ch = data[currentOffset + 1];
  730.             if (ch == chPeriod) {            // '..'
  731.                 addToken(tokens, XercesXPath::EXPRTOKEN_DOUBLE_PERIOD);
  732.                 starIsMultiplyOperator = true;
  733.                 currentOffset += 2;
  734.             } else if (ch >= chDigit_0 && ch <= chDigit_9) {
  735.                 addToken(tokens, XercesXPath::EXPRTOKEN_NUMBER);
  736.                 starIsMultiplyOperator = true;
  737.                 currentOffset = scanNumber(data, endOffset, currentOffset, tokens);
  738.             } else if (ch == chForwardSlash) {
  739.                 addToken(tokens, XercesXPath::EXPRTOKEN_PERIOD);
  740.                 starIsMultiplyOperator = true;
  741.                 currentOffset++;
  742.             } else {                    // '.'
  743.                 ThrowXML(XPathException, XMLExcepts::XPath_InvalidChar);
  744.             }
  746.             if (currentOffset == endOffset) {
  747.                 break;
  748.             }
  749.             break;
  750.         case CHARTYPE_ATSIGN:           // '@'
  751.             addToken(tokens, XercesXPath::EXPRTOKEN_ATSIGN);
  752.             starIsMultiplyOperator = false;
  753.             ++currentOffset;
  754.             break;
  755.         case CHARTYPE_COMMA:            // ','
  756.             addToken(tokens, XercesXPath::EXPRTOKEN_COMMA);
  757.             starIsMultiplyOperator = false;
  758.             ++currentOffset;
  759.             break;
  760.         case CHARTYPE_COLON:            // '::'
  761.             if (++currentOffset == endOffset) {
  762.                 return false; // REVISIT
  763.             }
  764.             ch = data[currentOffset];
  766.             if (ch != chColon) {
  767.                 return false; // REVISIT
  768.             }
  769.             addToken(tokens, XercesXPath::EXPRTOKEN_DOUBLE_COLON);
  770.             starIsMultiplyOperator = false;
  771.             ++currentOffset;
  772.             break;
  773.         case CHARTYPE_SLASH:            // '/' and '//'
  774.             if (++currentOffset == endOffset) {
  775.                 addToken(tokens, XercesXPath::EXPRTOKEN_OPERATOR_SLASH);
  776.                 starIsMultiplyOperator = false;
  777.                 break;
  778.             }
  780.             ch = data[currentOffset];
  782.             if (ch == chForwardSlash) { // '//'
  783.                 addToken(tokens, XercesXPath::EXPRTOKEN_OPERATOR_DOUBLE_SLASH);
  784.                 starIsMultiplyOperator = false;
  785.                 ++currentOffset;
  786.             } else {
  787.                 addToken(tokens, XercesXPath::EXPRTOKEN_OPERATOR_SLASH);
  788.                 starIsMultiplyOperator = false;
  789.             }
  790.             break;
  791.         case CHARTYPE_UNION:            // '|'
  792.             addToken(tokens, XercesXPath::EXPRTOKEN_OPERATOR_UNION);
  793.             starIsMultiplyOperator = false;
  794.             ++currentOffset;
  795.             break;
  796.         case CHARTYPE_PLUS:             // '+'
  797.             addToken(tokens, XercesXPath::EXPRTOKEN_OPERATOR_PLUS);
  798.             starIsMultiplyOperator = false;
  799.             ++currentOffset;
  800.             break;
  801.         case CHARTYPE_MINUS:            // '-'
  802.             addToken(tokens, XercesXPath::EXPRTOKEN_OPERATOR_MINUS);
  803.             starIsMultiplyOperator = false;
  804.             ++currentOffset;
  805.             break;
  806.         case CHARTYPE_EQUAL:            // '='
  807.             addToken(tokens, XercesXPath::EXPRTOKEN_OPERATOR_EQUAL);
  808.             starIsMultiplyOperator = false;
  809.             ++currentOffset;
  810.             break;
  811.         case CHARTYPE_EXCLAMATION:      // '!='
  812.             if (++currentOffset == endOffset) {
  813.                 return false; // REVISIT
  814.             }
  816.             ch = data[currentOffset];
  818.             if (ch != chEqual) {
  819.                 return false; // REVISIT
  820.             }
  822.             addToken(tokens, XercesXPath::EXPRTOKEN_OPERATOR_NOT_EQUAL);
  823.             starIsMultiplyOperator = false;
  824.             ++currentOffset;
  825.             break;
  826.         case CHARTYPE_LESS: // '<' and '<='
  827.             if (++currentOffset == endOffset) {
  828.                 addToken(tokens, XercesXPath::EXPRTOKEN_OPERATOR_LESS);
  829.                 starIsMultiplyOperator = false;
  830.                 break;
  831.             }
  833.             ch = data[currentOffset];
  835.             if (ch == chEqual) { // '<='
  836.                 addToken(tokens, XercesXPath::EXPRTOKEN_OPERATOR_LESS_EQUAL);
  837.                 starIsMultiplyOperator = false;
  838.                 ++currentOffset;
  839.             } else {
  840.                 addToken(tokens, XercesXPath::EXPRTOKEN_OPERATOR_LESS);
  841.                 starIsMultiplyOperator = false;
  842.             }
  843.             break;
  844.         case CHARTYPE_GREATER: // '>' and '>='
  845.             if (++currentOffset == endOffset) {
  846.                 addToken(tokens, XercesXPath::EXPRTOKEN_OPERATOR_GREATER);
  847.                 starIsMultiplyOperator = false;
  848.                 break;
  849.             }
  851.             ch = data[currentOffset];
  853.             if (ch == chEqual) { // '>='
  854.                 addToken(tokens, XercesXPath::EXPRTOKEN_OPERATOR_GREATER_EQUAL);
  855.                 starIsMultiplyOperator = false;
  856.                 ++currentOffset;
  857.             } else {
  858.                 addToken(tokens, XercesXPath::EXPRTOKEN_OPERATOR_GREATER);
  859.                 starIsMultiplyOperator = false;
  860.             }
  861.             break;
  862.         //
  863.         // [29] Literal ::= '"' [^"]* '"' | "'" [^']* "'"
  864.         //
  865.         case CHARTYPE_QUOTE:            // '"' or '''
  866.             {
  867.                 XMLCh qchar = ch;
  868.                 if (++currentOffset == endOffset) {
  869.                     return false; // REVISIT
  870.                 }
  872.                 ch = data[currentOffset];
  874.                 int litOffset = currentOffset;
  875.                 while (ch != qchar) {
  876.                     if (++currentOffset == endOffset) {
  877.                         return false; // REVISIT
  878.                     } 
  880.                     ch = data[currentOffset];
  881.                 }
  883.                 addToken(tokens, XercesXPath::EXPRTOKEN_LITERAL);
  884.                 starIsMultiplyOperator = true;
  886.                 dataBuffer.set(data + litOffset, currentOffset - litOffset);
  887.                 tokens->addElement(fStringPool->addOrFind(dataBuffer.getRawBuffer()));
  888.                 ++currentOffset;
  889.                 break;
  890.             }
  891.         //
  892.         // [30] Number ::= Digits ('.' Digits?)? | '.' Digits
  893.         // [31] Digits ::= [0-9]+
  894.         //
  895.         case CHARTYPE_DIGIT:
  896.             addToken(tokens, XercesXPath::EXPRTOKEN_NUMBER);
  897.             starIsMultiplyOperator = true;
  898.             currentOffset = scanNumber(data, endOffset, currentOffset, tokens);
  899.             break;
  900.         //
  901.         // [36] VariableReference ::= '$' QName
  902.         //
  903.         case CHARTYPE_DOLLAR:
  904.             if (++currentOffset == endOffset) {
  905.                 return false; // REVISIT
  906.             }
  907.             nameOffset = currentOffset;
  908.             currentOffset = scanNCName(data, endOffset, currentOffset);
  910.             if (currentOffset == nameOffset) {
  911.                 return false; // REVISIT
  912.             }
  914.             if (currentOffset < endOffset) {
  915.                 ch = data[currentOffset];
  916.             }
  917.             else {
  918.                 ch = 0;
  919.             }
  921.             dataBuffer.set(data + nameOffset, currentOffset - nameOffset);
  922.             nameHandle = fStringPool->addOrFind(dataBuffer.getRawBuffer());
  923.             prefixHandle = -1;
  925.             if (ch == chColon) {
  927.                 prefixHandle = nameHandle;
  928.                 if (++currentOffset == endOffset) {
  929.                     return false; // REVISIT
  930.                 }
  931.                 nameOffset = currentOffset;
  932.                 currentOffset = scanNCName(data, endOffset, currentOffset);
  934.                 if (currentOffset == nameOffset) {
  935.                     return false; // REVISIT
  936.                 }
  938.                 dataBuffer.set(data + nameOffset, currentOffset - nameOffset);
  939.                 nameHandle = fStringPool->addOrFind(dataBuffer.getRawBuffer());
  940.             }
  941.             addToken(tokens, XercesXPath::EXPRTOKEN_VARIABLE_REFERENCE);
  942.             starIsMultiplyOperator = true;
  943.             tokens->addElement(prefixHandle);
  944.             tokens->addElement(nameHandle);
  945.             break;
  946.         //
  947.         // [37] NameTest ::= '*' | NCName ':' '*' | QName
  948.         // [34] MultiplyOperator ::= '*'
  949.         //
  950.         case CHARTYPE_STAR:             // '*'
  951.             //
  952.             // 3.7 Lexical Structure
  953.             //
  954.             //  If there is a preceding token and the preceding token is not one of @, ::, (, [, , or
  955.             //  an Operator, then a * must be recognized as a MultiplyOperator.
  956.             //
  957.             // Otherwise, the token must not be recognized as a MultiplyOperator.
  958.             //
  959.             if (starIsMultiplyOperator) {
  960.                 addToken(tokens, XercesXPath::EXPRTOKEN_OPERATOR_MULT);
  961.                 starIsMultiplyOperator = false;
  962.             } else {
  963.                 addToken(tokens, XercesXPath::EXPRTOKEN_NAMETEST_ANY);
  964.                 starIsMultiplyOperator = true;
  965.             }
  967.             ++currentOffset;
  968.             break;
  969.         //
  970.         // NCName, QName and non-terminals
  971.         //
  972.         case CHARTYPE_NONASCII: // possibly a valid non-ascii 'Letter' (BaseChar | Ideographic)
  973.         case CHARTYPE_LETTER:
  974.         case CHARTYPE_UNDERSCORE:
  975.             //
  976.             // 3.7 Lexical Structure
  977.             //
  978.             //  If there is a preceding token and the preceding token is not one of @, ::, (, [, , or
  979.             //  an Operator, then an NCName must be recognized as an OperatorName.
  980.             //
  981.             //  If the character following an NCName (possibly after intervening ExprWhitespace) is (,
  982.             //  then the token must be recognized as a NodeType or a FunctionName.
  983.             //
  984.             //  If the two characters following an NCName (possibly after intervening ExprWhitespace)
  985.             //  are ::, then the token must be recognized as an AxisName.
  986.             //
  987.             //  Otherwise, the token must not be recognized as an OperatorName, a NodeType, a
  988.             //  FunctionName, or an AxisName.
  989.             //
  990.             // [33] OperatorName ::= 'and' | 'or' | 'mod' | 'div'
  991.             // [38] NodeType ::= 'comment' | 'text' | 'processing-instruction' | 'node'
  992.             // [35] FunctionName ::= QName - NodeType
  993.             // [6] AxisName ::= (see above)
  994.             //
  995.             // [37] NameTest ::= '*' | NCName ':' '*' | QName
  996.             // [5] NCName ::= (Letter | '_') (NCNameChar)*
  997.             // [?] NCNameChar ::= Letter | Digit | '.' | '-' | '_'  (ascii subset of 'NCNameChar')
  998.             // [?] QName ::= (NCName ':')? NCName
  999.             // [?] Letter ::= [A-Za-z]                              (ascii subset of 'Letter')
  1000.             // [?] Digit ::= [0-9]                                  (ascii subset of 'Digit')
  1001.             //
  1002.             nameOffset = currentOffset;
  1003.             currentOffset = scanNCName(data, endOffset, currentOffset);
  1004.             if (currentOffset == nameOffset) {
  1005.                 return false; // REVISIT            
  1006. }
  1008.             if (currentOffset < endOffset) {
  1009.                 ch = data[currentOffset];
  1010.             }
  1011.             else {
  1012.                 ch = 0;
  1013.             }
  1015.             dataBuffer.set(data + nameOffset, currentOffset - nameOffset);
  1016.             nameHandle = fStringPool->addOrFind(dataBuffer.getRawBuffer());
  1018.             bool isNameTestNCName = false;
  1019.             bool isAxisName = false;
  1020.             prefixHandle = -1;
  1022.             if (ch == chColon) {
  1024.                 if (++currentOffset == endOffset) {
  1025.                     return false; // REVISIT
  1026.                 }
  1028.                 ch = data[currentOffset];
  1030.                 if (ch == chAsterisk) {
  1031.                     if (++currentOffset < endOffset) {
  1032.                         ch = data[currentOffset];
  1033.                     }
  1035.                     isNameTestNCName = true;
  1036.                 } else if (ch == chColon) {
  1037.                     if (++currentOffset < endOffset) {
  1038.                         ch = data[currentOffset];
  1039.                     }
  1041.                     isAxisName = true;
  1042.                 } else {
  1043.                     prefixHandle = nameHandle;
  1044.                     nameOffset = currentOffset;
  1045.                     currentOffset = scanNCName(data, endOffset, currentOffset);
  1046.                     if (currentOffset == nameOffset) {
  1047.                         return false; // REVISIT
  1048.                     }
  1049.                     if (currentOffset < endOffset) {
  1050.                         ch = data[currentOffset];
  1051.                     }
  1052.                     else {
  1053.                         ch = 0;
  1054.                     }
  1056.                     dataBuffer.set(data + nameOffset, currentOffset - nameOffset);
  1057.                     nameHandle = fStringPool->addOrFind(dataBuffer.getRawBuffer());
  1058.                 }
  1059.             }
  1060.             //
  1061.             // [39] ExprWhitespace ::= S
  1062.             //
  1063.             while (XMLReader::isWhitespace(ch)) {
  1064.                 if (++currentOffset == endOffset) {
  1065.                     break;
  1066.                 }
  1067.                 ch = data[currentOffset];
  1068.             }
  1070.             //
  1071.             //  If there is a preceding token and the preceding token is not one of @, ::, (, [, , or
  1072.             //  an Operator, then an NCName must be recognized as an OperatorName.
  1073.             //
  1074.             if (starIsMultiplyOperator) {
  1075.                 if (nameHandle == fAndSymbol) {
  1076.                     addToken(tokens, XercesXPath::EXPRTOKEN_OPERATOR_AND);
  1077.                     starIsMultiplyOperator = false;
  1078.                 } else if (nameHandle == fOrSymbol) {
  1079.                     addToken(tokens, XercesXPath::EXPRTOKEN_OPERATOR_OR);
  1080.                     starIsMultiplyOperator = false;
  1081.                 } else if (nameHandle == fModSymbol) {
  1082.                     addToken(tokens, XercesXPath::EXPRTOKEN_OPERATOR_MOD);
  1083.                     starIsMultiplyOperator = false;
  1084.                 } else if (nameHandle == fDivSymbol) {
  1085.                     addToken(tokens, XercesXPath::EXPRTOKEN_OPERATOR_DIV);
  1086.                     starIsMultiplyOperator = false;
  1087.                 } else {
  1088.                     return false; // REVISIT
  1089.                 }
  1091.                 if (isNameTestNCName) {
  1092.                     return false; // REVISIT - NCName:* where an OperatorName is required
  1093.                 } else if (isAxisName) {
  1094.                     return false; // REVISIT - AxisName:: where an OperatorName is required
  1095.                 }
  1096.                 break;
  1097.             }
  1098.             //
  1099.             //  If the character following an NCName (possibly after intervening ExprWhitespace) is (,
  1100.             //  then the token must be recognized as a NodeType or a FunctionName.
  1101.             //
  1102.             if (ch == chOpenParen && !isNameTestNCName && !isAxisName) {
  1103.                 if (nameHandle == fCommentSymbol) {
  1104.                     addToken(tokens, XercesXPath::EXPRTOKEN_NODETYPE_COMMENT);
  1105.                 } else if (nameHandle == fTextSymbol) {
  1106.                     addToken(tokens, XercesXPath::EXPRTOKEN_NODETYPE_TEXT);
  1107.                 } else if (nameHandle == fPISymbol) {
  1108.                     addToken(tokens, XercesXPath::EXPRTOKEN_NODETYPE_PI);
  1109.                 } else if (nameHandle == fNodeSymbol) {
  1110.                     addToken(tokens, XercesXPath::EXPRTOKEN_NODETYPE_NODE);
  1111.                 } else {
  1112.                     addToken(tokens, XercesXPath::EXPRTOKEN_FUNCTION_NAME);
  1113.                     tokens->addElement(prefixHandle);
  1114.                     tokens->addElement(nameHandle);
  1115.                 }
  1116.                 addToken(tokens, XercesXPath::EXPRTOKEN_OPEN_PAREN);
  1117.                 starIsMultiplyOperator = false;
  1118.                 ++currentOffset;
  1119.                 break;
  1120.             }
  1122.             //
  1123.             //  If the two characters following an NCName (possibly after intervening ExprWhitespace)
  1124.             //  are ::, then the token must be recognized as an AxisName.
  1125.             //
  1126.             if (isAxisName ||
  1127.                 (ch == chColon && currentOffset + 1 < endOffset &&
  1128.                  data[currentOffset + 1] == chColon)) {
  1130.                 if (nameHandle == fAncestorSymbol) {
  1131.                     addToken(tokens, XercesXPath::EXPRTOKEN_AXISNAME_ANCESTOR);
  1132.                 } else if (nameHandle == fAncestorOrSelfSymbol) {
  1133.                     addToken(tokens, XercesXPath::EXPRTOKEN_AXISNAME_ANCESTOR_OR_SELF);
  1134.                 } else if (nameHandle == fAttributeSymbol) {
  1135.                     addToken(tokens, XercesXPath::EXPRTOKEN_AXISNAME_ATTRIBUTE);
  1136.                 } else if (nameHandle == fChildSymbol) {
  1137.                     addToken(tokens, XercesXPath::EXPRTOKEN_AXISNAME_CHILD);
  1138.                 } else if (nameHandle == fDescendantSymbol) {
  1139.                     addToken(tokens, XercesXPath::EXPRTOKEN_AXISNAME_DESCENDANT);
  1140.                 } else if (nameHandle == fDescendantOrSelfSymbol) {
  1141.                     addToken(tokens, XercesXPath::EXPRTOKEN_AXISNAME_DESCENDANT_OR_SELF);
  1142.                 } else if (nameHandle == fFollowingSymbol) {
  1143.                     addToken(tokens, XercesXPath::EXPRTOKEN_AXISNAME_FOLLOWING);
  1144.                 } else if (nameHandle == fFollowingSiblingSymbol) {
  1145.                     addToken(tokens, XercesXPath::EXPRTOKEN_AXISNAME_FOLLOWING_SIBLING);
  1146.                 } else if (nameHandle == fNamespaceSymbol) {
  1147.                     addToken(tokens, XercesXPath::EXPRTOKEN_AXISNAME_NAMESPACE);
  1148.                 } else if (nameHandle == fParentSymbol) {
  1149.                     addToken(tokens, XercesXPath::EXPRTOKEN_AXISNAME_PARENT);
  1150.                 } else if (nameHandle == fPrecedingSymbol) {
  1151.                     addToken(tokens, XercesXPath::EXPRTOKEN_AXISNAME_PRECEDING);
  1152.                 } else if (nameHandle == fPrecedingSiblingSymbol) {
  1153.                     addToken(tokens, XercesXPath::EXPRTOKEN_AXISNAME_PRECEDING_SIBLING);
  1154.                 } else if (nameHandle == fSelfSymbol) {
  1155.                     addToken(tokens, XercesXPath::EXPRTOKEN_AXISNAME_SELF);
  1156.                 } else {
  1157.                     return false; // REVISIT
  1158.                 }
  1160.                 if (isNameTestNCName) {
  1161.                     return false; // REVISIT - "NCName:* ::" where "AxisName ::" is required
  1162.                 }
  1164.                 addToken(tokens, XercesXPath::EXPRTOKEN_DOUBLE_COLON);
  1165.                 starIsMultiplyOperator = false;
  1166.                 if (!isAxisName) {
  1167.                     currentOffset += 2;
  1168.                 }
  1169.                 break;
  1170.             }
  1171.             //
  1172.             //  Otherwise, the token must not be recognized as an OperatorName, a NodeType, a
  1173.             //  FunctionName, or an AxisName.
  1174.             //
  1175.             if (isNameTestNCName) {
  1176.                 addToken(tokens, XercesXPath::EXPRTOKEN_NAMETEST_NAMESPACE);
  1177.                 tokens->addElement(nameHandle);
  1178.             } else {
  1179.                 addToken(tokens, XercesXPath::EXPRTOKEN_NAMETEST_QNAME);
  1180.                 tokens->addElement(prefixHandle);
  1181.                 tokens->addElement(nameHandle);
  1182.             }
  1184.             starIsMultiplyOperator = true;
  1185.             break;
  1186.         }
  1187.     }
  1189.     return true;
  1190. }
  1193. int XPathScanner::scanNCName(const XMLCh* const data,
  1194.                              const int endOffset,
  1195.                              int currentOffset) {
  1197.     XMLCh ch = data[currentOffset];
  1199.     if (!XMLReader::isXMLLetter(ch) && ch != chUnderscore) {
  1200.         return currentOffset;
  1201.     }
  1203.     while (++currentOffset < endOffset) {
  1205.         ch = data[currentOffset];
  1207.         if (ch == chColon || !XMLReader::isNameChar(ch)) {
  1208.             break;
  1209.         }
  1210.     }
  1212.     return currentOffset;
  1213. }
  1216. int XPathScanner::scanNumber(const XMLCh* const data,
  1217.                              const int endOffset,
  1218.                              int currentOffset,
  1219.                              ValueVectorOf<int>* const tokens) {
  1221.     XMLCh ch = data[currentOffset];
  1222.     int   whole = 0;
  1223.     int   part = 0;
  1225.     while (ch >= chDigit_0 && ch <= chDigit_9) {
  1227.         whole = (whole * 10) + (ch - chDigit_0);
  1229.         if (++currentOffset == endOffset) {
  1230.             break;
  1231.         }
  1233.         ch = data[currentOffset];
  1234.     }
  1236.     if (ch == chPeriod) {
  1238.         if (++currentOffset < endOffset) {
  1240.             int start = currentOffset;
  1242.             ch = data[currentOffset];
  1244.             while (ch >= chDigit_0 && ch <= chDigit_9) {
  1246.                 part = (part * 10) + (ch - chDigit_0);
  1248.                 if (++currentOffset == endOffset) {
  1249.                     break;
  1250.                 }
  1252.                 ch = data[currentOffset];
  1253.             }
  1255.             if (part != 0) {
  1256.                 ThrowXML(RuntimeException, XMLExcepts::XPath_FindSolution);
  1257.             }
  1258.         }
  1259.     }
  1261.     tokens->addElement(whole);
  1262.     tokens->addElement(part);
  1264.     return currentOffset;
  1265. }
  1268. // ---------------------------------------------------------------------------
  1269. //  XPathScannerForSchema: Constructors and Destructor
  1270. // ---------------------------------------------------------------------------
  1271. XPathScannerForSchema::XPathScannerForSchema(XMLStringPool* const stringPool)
  1272.     : XPathScanner(stringPool)
  1273. {
  1274. }
  1277. // ---------------------------------------------------------------------------
  1278. //  XPathScannerForSchema: Helper methods
  1279. // ---------------------------------------------------------------------------
  1280. void XPathScannerForSchema::addToken(ValueVectorOf<int>* const tokens,
  1281.                                      const int aToken) {
  1283.     if (aToken == XercesXPath::EXPRTOKEN_ATSIGN ||
  1284.         aToken == XercesXPath::EXPRTOKEN_AXISNAME_ATTRIBUTE ||
  1285.         aToken == XercesXPath::EXPRTOKEN_AXISNAME_CHILD ||
  1286.         //token == XercesXPath::EXPRTOKEN_AXISNAME_SELF ||
  1287.         aToken == XercesXPath::EXPRTOKEN_DOUBLE_COLON ||
  1288.         aToken == XercesXPath::EXPRTOKEN_NAMETEST_QNAME ||
  1289.         //token == XercesXPath::EXPRTOKEN_NODETYPE_NODE ||
  1290.         aToken == XercesXPath::EXPRTOKEN_OPERATOR_SLASH ||
  1291.         aToken == XercesXPath::EXPRTOKEN_PERIOD ||
  1292.         aToken == XercesXPath::EXPRTOKEN_NAMETEST_ANY ||
  1293.         aToken == XercesXPath::EXPRTOKEN_NAMETEST_NAMESPACE ||
  1294.         aToken == XercesXPath::EXPRTOKEN_OPERATOR_DOUBLE_SLASH ||
  1295.         aToken == XercesXPath::EXPRTOKEN_OPERATOR_UNION) {
  1297.         tokens->addElement(aToken);
  1298.         return;
  1299.     }
  1301.     ThrowXML(XPathException, XMLExcepts::XPath_TokenNotSupported);
  1302. }
  1304. /**
  1305.   * End of file XercesPath.cpp
  1306.   */