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

源码开发语言/平台
当前位置：首页 > 源码/资料 > 多国语言处理 > 词法分析 > 查看源码
XercesXPath.cpp
资源名称：xerces-c-src_2_3_0.zip　[点击查看]
上传用户：zhuqijet
上传日期：2013-06-25
资源大小：10074k
文件大小：51k
源码类别：

词法分析

开发平台：

Visual 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.8  2003/05/18 14:02:09  knoaman
  60.  * Memory manager implementation: pass per instance manager.
  61.  *
  62.  * Revision 1.7  2003/05/16 21:43:22  knoaman
  63.  * Memory manager implementation: Modify constructors to pass in the memory manager.
  64.  *
  65.  * Revision 1.6  2003/05/15 18:59:34  knoaman
  66.  * Partial implementation of the configurable memory manager.
  67.  *
  68.  * Revision 1.5  2002/12/20 22:10:48  tng
  69.  * XML 1.1
  70.  *
  71.  * Revision 1.4  2002/12/04 18:21:23  knoaman
  72.  * Identity constraint fix.
  73.  *
  74.  * Revision 1.3  2002/11/04 14:47:42  tng
  75.  * C++ Namespace Support.
  76.  *
  77.  * Revision 1.2  2002/10/30 21:52:01  tng
  78.  * [Bug 13641] compiler-generated copy-constructor for QName doesn't do the right thing.
  79.  *
  80.  * Revision 1.1.1.1  2002/02/01 22:22:51  peiyongz
  81.  * sane_include
  82.  *
  83.  * Revision 1.3  2001/11/15 17:10:19  knoaman
  84.  * Particle derivation checking support.
  85.  *
  86.  * Revision 1.2  2001/11/07 14:25:36  knoaman
  87.  * Fix compliation error on Unix.
  88.  *
  89.  * Revision 1.1  2001/11/02 14:08:40  knoaman
  90.  * Add support for identity constraints.
  91.  *
  92.  */
  94. // ---------------------------------------------------------------------------
  95. //  Includes
  96. // ---------------------------------------------------------------------------
  97. #include <xercesc/validators/schema/identity/XercesXPath.hpp>
  98. #include <xercesc/validators/schema/identity/XPathSymbols.hpp>
  99. #include <xercesc/validators/schema/identity/XPathException.hpp>
  100. #include <xercesc/validators/schema/NamespaceScope.hpp>
  101. #include <xercesc/util/StringPool.hpp>
  102. #include <xercesc/util/Janitor.hpp>
  103. #include <xercesc/framework/XMLBuffer.hpp>
  104. #include <xercesc/internal/XMLReader.hpp>
  105. #include <xercesc/util/RuntimeException.hpp>
  107. XERCES_CPP_NAMESPACE_BEGIN
  110. // ---------------------------------------------------------------------------
  111. //  Static data
  112. // ---------------------------------------------------------------------------
  113. const XMLByte XPathScanner::fASCIICharMap[128] =
  114. {
  115.     0,  0,  0,  0,  0,  0,  0,  0,  0,  2,  2,  0,  0,  2,  0,  0,
  116.     0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,  0,
  117.     2,  3,  4,  1,  5,  1,  1,  4,  6,  7,  8,  9, 10, 11, 12, 13,
  118.     14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15,  1, 16, 17, 18,  1,
  119.     19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
  120.     20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 21,  1, 22,  1, 23,
  121.     1, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
  122.     20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,  1, 24,  1,  1,  1
  123. };
  126. // ---------------------------------------------------------------------------
  127. //  XercesNodeTest: Constructors and Destructor
  128. // ---------------------------------------------------------------------------
  129. XercesNodeTest::XercesNodeTest(const short aType,
  130.                                MemoryManager* const manager)
  131.     : fType(aType)
  132.     , fName(new (manager) QName(manager))
  133. {
  134. }
  136. XercesNodeTest::XercesNodeTest(const QName* const qName)
  137.     : fType(QNAME)
  138.     , fName(new (qName->getMemoryManager()) QName(*qName))
  139. {
  140. }
  142. XercesNodeTest::XercesNodeTest(const XMLCh* const prefix,
  143.                                const unsigned int uriId,
  144.                                MemoryManager* const manager)
  145.     : fType(NAMESPACE)
  146.     , fName(new (manager) QName(manager))
  147. {
  148.     fName->setURI(uriId);
  149.     fName->setPrefix(prefix);
  150. }
  152. XercesNodeTest::XercesNodeTest(const XercesNodeTest& other)
  153.     : fType(other.fType)
  154.     , fName(new ((other.fName)->getMemoryManager())QName(*other.fName))
  155. {
  156. }
  158. // ---------------------------------------------------------------------------
  159. //  XercesNodeTest: Operators
  160. // ---------------------------------------------------------------------------
  161. XercesNodeTest& XercesNodeTest::operator=(const XercesNodeTest& other)
  162. {
  163.     if (this == &other)
  164.         return *this;
  166.     fType = other.fType;
  167.     fName->setValues(*(other.fName));
  168.     return *this;
  169. }
  171. bool XercesNodeTest::operator ==(const XercesNodeTest& other) const {
  173.     if (this == &other)
  174.         return true;
  176.     if (fType != other.fType)
  177.         return false;
  179.     return (*fName == *(other.fName));
  180. }
  183. bool XercesNodeTest::operator !=(const XercesNodeTest& other) const {
  185.     return !operator==(other);
  186. }
  188. // ---------------------------------------------------------------------------
  189. //  XercesStep: Constructors and Destructor
  190. // ---------------------------------------------------------------------------
  191. XercesStep::XercesStep(const unsigned short axisType, XercesNodeTest* const nodeTest)
  192.     : fAxisType(axisType)
  193.     , fNodeTest(nodeTest)
  194. {
  195. }
  197. XercesStep::XercesStep(const XercesStep& other)
  198.     : fAxisType(other.fAxisType)
  199.     , fNodeTest(0)
  200. {
  201.     fNodeTest = new (other.fNodeTest->getName()->getMemoryManager()) XercesNodeTest(*(other.fNodeTest));
  202. }
  205. // ---------------------------------------------------------------------------
  206. //  XercesStep: Operators
  207. // ---------------------------------------------------------------------------
  208. XercesStep& XercesStep::operator=(const XercesStep& other)
  209. {
  210.     if (this == &other)
  211.         return *this;
  213.     fAxisType = other.fAxisType;
  214.     *fNodeTest = *(other.fNodeTest);
  215.     return *this;
  216. }
  218. bool XercesStep::operator==(const XercesStep& other) const {
  220.     if (this == &other)
  221.         return true;
  223.     if (fAxisType != other.fAxisType)
  224.         return false;
  226.     if (fAxisType == XercesStep::CHILD ||
  227.         fAxisType == XercesStep::ATTRIBUTE) {
  228.         return (*fNodeTest == *(other.fNodeTest));
  229.     }
  231.     return true;
  232. }
  234. bool XercesStep::operator!=(const XercesStep& other) const {
  236.     return !operator==(other);
  237. }
  239. // ---------------------------------------------------------------------------
  240. //  XercesLocationPath: Constructors and Destructor
  241. // ---------------------------------------------------------------------------
  242. XercesLocationPath::XercesLocationPath(RefVectorOf<XercesStep>* const steps)
  243.     : fSteps(steps)
  244. {
  245. }
  247. // ---------------------------------------------------------------------------
  248. //  XercesLocationPath: Operators
  249. // ---------------------------------------------------------------------------
  250. bool XercesLocationPath::operator==(const XercesLocationPath& other) const {
  252.     unsigned int stepsSize = fSteps->size();
  254.     if (stepsSize != other.fSteps->size())
  255.         return false;
  257.     for (unsigned int i=0; i < stepsSize; i++) {
  258.         if (*(fSteps->elementAt(i)) != *(other.fSteps->elementAt(i)))
  259.             return false;
  260.     }
  262.     return true;
  263. }
  265. bool XercesLocationPath::operator!=(const XercesLocationPath& other) const {
  267.     return !operator==(other);
  268. }
  270. // ---------------------------------------------------------------------------
  271. //  XercesPath: Constructors and Destructor
  272. // ---------------------------------------------------------------------------
  273. XercesXPath::XercesXPath(const XMLCh* const xpathExpr,
  274.                          XMLStringPool* const stringPool,
  275.                          NamespaceScope* const scopeContext,
  276.                          const unsigned int emptyNamespaceId,
  277.                          const bool isSelector,
  278.                          MemoryManager* const manager)
  279.     : fEmptyNamespaceId(emptyNamespaceId)
  280.     , fExpression(0)
  281.     , fLocationPaths(0)
  282.     , fMemoryManager(manager)
  283. {
  284.     try
  285.     {
  286.         fExpression = XMLString::replicate(xpathExpr, fMemoryManager);
  287.         parseExpression(stringPool, scopeContext);
  289.         if (isSelector) {
  290.             checkForSelectedAttributes();
  291.         }
  292.     }
  293.     catch(...) {
  295.         cleanUp();
  296.         throw;
  297.     }
  298. }
  300. XercesXPath::~XercesXPath() {
  301.     cleanUp();
  302. }
  305. // ---------------------------------------------------------------------------
  306. //  XercesXPath: Operators
  307. // ---------------------------------------------------------------------------
  308. bool XercesXPath::operator==(const XercesXPath& other) const {
  310.     unsigned int locPathSize = fLocationPaths->size();
  312.     if (locPathSize != other.fLocationPaths->size())
  313.         return false;
  315.     for (unsigned int i=0; i < locPathSize; i++) {
  316.         if (*(fLocationPaths->elementAt(i)) != *(other.fLocationPaths->elementAt(i)))
  317.             return false;
  318.     }
  320.     return true;
  321. }
  323. bool XercesXPath::operator!=(const XercesXPath& other) const {
  325.     return !operator==(other);
  326. }
  328. // ---------------------------------------------------------------------------
  329. //  XercesPath: Helper methods
  330. // ---------------------------------------------------------------------------
  331. void XercesXPath::cleanUp() {
  333.     fMemoryManager->deallocate(fExpression);//delete [] fExpression;
  334.     delete fLocationPaths;
  335. }
  337. void XercesXPath::checkForSelectedAttributes() {
  339.     // verify that an attribute is not selected
  340.     unsigned int locSize = (fLocationPaths) ? fLocationPaths->size() : 0;
  342.     for (unsigned int i = 0; i < locSize; i++) {
  344.         XercesLocationPath* locPath = fLocationPaths->elementAt(i);
  345.         unsigned int stepSize = locPath->getStepSize();
  347.         if (stepSize) {
  348.             if (locPath->getStep(stepSize - 1)->getAxisType() == XercesStep::ATTRIBUTE) {
  349.                 ThrowXML(XPathException, XMLExcepts::XPath_NoAttrSelector);
  350.             }
  351. }
  352.     }
  353. }
  355. void XercesXPath::parseExpression(XMLStringPool* const stringPool,
  356.                                   NamespaceScope* const scopeContext) {
  358.     unsigned int length = XMLString::stringLen(fExpression);
  360.     if (!length) {
  361.         return;
  362.     }
  364.     ValueVectorOf<int>                tokens(16, fMemoryManager);
  365.     XPathScannerForSchema             scanner(stringPool);
  366.     bool                              success = scanner.scanExpression(fExpression, 0, length, &tokens);
  367.     bool                              firstTokenOfLocationPath=true;
  368.     unsigned int                      tokenCount = tokens.size();
  369.     RefVectorOf<XercesStep>*          stepsVector = new (fMemoryManager) RefVectorOf<XercesStep>(16, true, fMemoryManager);
  370.     Janitor<RefVectorOf<XercesStep> > janSteps(stepsVector);
  372.     if (tokenCount) {
  373.         fLocationPaths = new (fMemoryManager) RefVectorOf<XercesLocationPath>(8, true, fMemoryManager);
  374.     }
  376.     for (unsigned int i = 0; i < tokenCount; i++) {
  378.         int  aToken = tokens.elementAt(i);
  379.         bool isNamespace=false;
  381.         switch (aToken) {
  382.         case  XercesXPath::EXPRTOKEN_OPERATOR_UNION:
  383.             {
  384.                 if (i == 0) {
  385.                     ThrowXML(XPathException, XMLExcepts::XPath_NoUnionAtStart);
  386.                 }
  388.                 int stepsSize = stepsVector->size();
  390.                 if (stepsSize == 0) {
  391.                     ThrowXML(XPathException, XMLExcepts::XPath_NoMultipleUnion);
  392.                 }
  394.                 fLocationPaths->addElement(new (fMemoryManager) XercesLocationPath(stepsVector));
  395.                 janSteps.orphan();
  396.                 stepsVector = new (fMemoryManager) RefVectorOf<XercesStep>(16, true, fMemoryManager);
  397.                 janSteps.reset(stepsVector);
  398.                 firstTokenOfLocationPath = true;
  399.             }
  400.             break;
  401.         case XercesXPath::EXPRTOKEN_AXISNAME_ATTRIBUTE:
  402.             {
  403.                 // consume "::" token and drop through
  404.                 i++;
  405.             }
  406.         case XercesXPath::EXPRTOKEN_ATSIGN:
  407.             {
  408.                 // consume QName token
  409.                 if (i == tokenCount - 1) {
  410.                     ThrowXML(XPathException, XMLExcepts::XPath_MissingAttr);
  411.                 }
  413.                 aToken = tokens.elementAt(++i);
  415.                 if (aToken != XercesXPath::EXPRTOKEN_NAMETEST_QNAME
  416.                     && aToken!= XercesXPath::EXPRTOKEN_NAMETEST_ANY
  417.                     && aToken!= XercesXPath::EXPRTOKEN_NAMETEST_NAMESPACE) {
  418.                         ThrowXML(XPathException, XMLExcepts::XPath_ExpectedToken1);
  419.                 }
  421.                 bool isNamespaceAtt=false;
  423.                 switch (aToken) {
  425.                 case XercesXPath::EXPRTOKEN_NAMETEST_ANY:
  426.                     {
  427.                         XercesNodeTest* nodeTest = new (fMemoryManager) XercesNodeTest(XercesNodeTest::WILDCARD, fMemoryManager);
  428.                         XercesStep* step = new (fMemoryManager) XercesStep(XercesStep::ATTRIBUTE, nodeTest);
  429.                         stepsVector->addElement(step);
  430.                         break;
  431.                     }
  432.                 case XercesXPath::EXPRTOKEN_NAMETEST_NAMESPACE:
  433.                     {
  434.                         isNamespaceAtt = true;
  435.                     }
  436.                 case XercesXPath::EXPRTOKEN_NAMETEST_QNAME:
  437.                     {
  438.                         aToken = tokens.elementAt(++i);
  440.                         const XMLCh* prefix = XMLUni::fgZeroLenString;
  441.                         unsigned int uri = fEmptyNamespaceId;
  443.                         if (scopeContext && aToken != -1) {
  445.                             prefix = stringPool->getValueForId(aToken);
  446.                             uri = scopeContext->getNamespaceForPrefix(prefix);
  447.                         }
  449.                         if (aToken != -1 && scopeContext && uri == fEmptyNamespaceId) {
  450.                             ThrowXML1(XPathException, XMLExcepts::XPath_PrefixNoURI, prefix);
  451.                         }
  453.                         if (isNamespaceAtt) {
  455.                             // build step
  456.                             XercesNodeTest* nodeTest = new (fMemoryManager) XercesNodeTest(prefix, uri, fMemoryManager);
  457.                             XercesStep* step = new (fMemoryManager) XercesStep(XercesStep::ATTRIBUTE, nodeTest);
  458.                             stepsVector->addElement(step);
  459.                             break;
  460.                         }
  462.                         aToken = tokens.elementAt(++i);
  464.                         const XMLCh* localPart = stringPool->getValueForId(aToken);
  465.                         QName aQName(prefix, localPart, uri, fMemoryManager);
  467.                         // build step
  468.                         XercesNodeTest* nodeTest = new (fMemoryManager) XercesNodeTest(&aQName);
  469.                         XercesStep* step = new (fMemoryManager) XercesStep(XercesStep::ATTRIBUTE, nodeTest);
  470.                         stepsVector->addElement(step);
  471.                         break;
  472.                     }
  473. }
  475.                 firstTokenOfLocationPath=false;
  476.                 break;
  477.             }
  478.         case XercesXPath::EXPRTOKEN_DOUBLE_COLON:
  479.             {
  480.                 // should never have a bare double colon
  481.                 ThrowXML(XPathException, XMLExcepts::XPath_NoDoubleColon);
  482.             }
  483.         case XercesXPath::EXPRTOKEN_AXISNAME_CHILD:
  484.             {
  485.                 // consume "::" token and drop through
  486.                 i++;
  488.                 if (i == tokenCount - 1) {
  489.                     ThrowXML(XPathException, XMLExcepts::XPath_ExpectedStep1);
  490.                 }
  492.                 firstTokenOfLocationPath=false;
  493.                 break;
  494.             }
  495.         case XercesXPath::EXPRTOKEN_NAMETEST_ANY:
  496.             {
  497.                 XercesNodeTest* nodeTest = new (fMemoryManager) XercesNodeTest(XercesNodeTest::WILDCARD, fMemoryManager);
  498.                 XercesStep* step = new (fMemoryManager) XercesStep(XercesStep::CHILD, nodeTest);
  499.                 stepsVector->addElement(step);
  500.                 firstTokenOfLocationPath = false;
  501.                 break;
  502.             }
  503.         case XercesXPath::EXPRTOKEN_NAMETEST_NAMESPACE:
  504.             {
  505.                 isNamespace=true;
  506.             }
  507.         case XercesXPath::EXPRTOKEN_NAMETEST_QNAME:
  508.             {
  509.                 // consume QName token
  510.                 aToken = tokens.elementAt(++i);
  512.                 const XMLCh* prefix = XMLUni::fgZeroLenString;
  513.                 unsigned int uri = fEmptyNamespaceId;
  515.                 if (scopeContext && aToken != -1) {
  517.                     prefix = stringPool->getValueForId(aToken);
  518.                     uri = scopeContext->getNamespaceForPrefix(prefix);
  519.                 }
  521.                 if (aToken != -1 && scopeContext && uri == fEmptyNamespaceId) {
  522.                     ThrowXML1(XPathException, XMLExcepts::XPath_PrefixNoURI, prefix);
  523.                 }
  525.                 if (isNamespace) {
  527.                     // build step
  528.                     XercesNodeTest* nodeTest = new (fMemoryManager) XercesNodeTest(prefix, uri, fMemoryManager);
  529.                     XercesStep* step = new (fMemoryManager) XercesStep(XercesStep::CHILD, nodeTest);
  530.                     stepsVector->addElement(step);
  531.                     break;
  532.                 }
  534.                 aToken = tokens.elementAt(++i);
  535.                 const XMLCh* localPart = stringPool->getValueForId(aToken);
  536.                 QName aQName(prefix, localPart, uri, fMemoryManager);
  538.                 // build step
  539.                 XercesNodeTest* nodeTest = new (fMemoryManager) XercesNodeTest(&aQName);
  540.                 XercesStep* step = new (fMemoryManager) XercesStep(XercesStep::CHILD, nodeTest);
  541.                 stepsVector->addElement(step);
  542.                 firstTokenOfLocationPath = false;
  543.                 break;
  544.             }
  545.         case XercesXPath::EXPRTOKEN_PERIOD:
  546.             {
  547.                 // build step
  548.                 XercesNodeTest* nodeTest = new (fMemoryManager) XercesNodeTest(XercesNodeTest::NODE, fMemoryManager);
  549.                 XercesStep* step = new (fMemoryManager) XercesStep(XercesStep::SELF, nodeTest);
  550.                 stepsVector->addElement(step);
  552.                 if (firstTokenOfLocationPath && i+1 < tokenCount) {
  554.                     aToken = tokens.elementAt(i+1);
  556.                     if (aToken == XercesXPath::EXPRTOKEN_OPERATOR_DOUBLE_SLASH){
  558.                         if (++i == tokenCount - 1) {
  559.                             ThrowXML(XPathException, XMLExcepts::XPath_ExpectedStep2);
  560.                         }
  562.                         if (i+1 < tokenCount) {
  564.                             aToken = tokens.elementAt(i+1);
  566.                             if (aToken == XercesXPath::EXPRTOKEN_OPERATOR_SLASH) {
  567.                                 ThrowXML(XPathException, XMLExcepts::XPath_NoForwardSlash);
  568.                             }
  569.                         }
  570.                         // build step
  571.                         nodeTest = new (fMemoryManager) XercesNodeTest(XercesNodeTest::NODE, fMemoryManager);
  572.                         step = new (fMemoryManager) XercesStep(XercesStep::DESCENDANT, nodeTest);
  573.                         stepsVector->addElement(step);
  574.                     }
  575.                 }
  576.                 firstTokenOfLocationPath=false;
  577.                 break;
  578.             }
  579.         case XercesXPath::EXPRTOKEN_OPERATOR_DOUBLE_SLASH:
  580.             {
  581.                 ThrowXML(XPathException, XMLExcepts::XPath_NoDoubleForwardSlash);
  582.             }
  583.         case XercesXPath::EXPRTOKEN_OPERATOR_SLASH:
  584.             {
  585.                 if (i == 0) {
  586.                     ThrowXML(XPathException, XMLExcepts::XPath_NoForwardSlashAtStart);
  587.                 }
  589.                 // keep on truckin'
  590.                 if (firstTokenOfLocationPath) {
  591.                     ThrowXML(XPathException, XMLExcepts::XPath_NoSelectionOfRoot);
  592.                 }
  594.                 if (i == tokenCount - 1) {
  595.                     ThrowXML(XPathException, XMLExcepts::XPath_ExpectedStep3);
  596.                 }
  598.                 firstTokenOfLocationPath=false;
  599.                 break;
  600.             }
  601.         default:
  602.             firstTokenOfLocationPath=false;
  603.         }
  604.     }
  606.     int stepsSize = stepsVector->size();
  608.     if (stepsSize == 0) {
  609.         if (!fLocationPaths || fLocationPaths->size() == 0) {
  610.             ThrowXML(XPathException, XMLExcepts::XPath_EmptyExpr);
  611.         }
  612.         else {
  613.             ThrowXML(XPathException, XMLExcepts::XPath_NoUnionAtEnd);
  614.         }
  615.     }
  617.     fLocationPaths->addElement(new (fMemoryManager) XercesLocationPath(stepsVector));
  618.     janSteps.orphan();
  619. }
  621. // ---------------------------------------------------------------------------
  622. //  XPathScanner: Constructors and Destructor
  623. // ---------------------------------------------------------------------------
  624. XPathScanner::XPathScanner(XMLStringPool* const stringPool)
  625.     : fAndSymbol (0)
  626.     , fOrSymbol(0)
  627.     , fModSymbol(0)
  628.     , fDivSymbol(0)
  629.     , fCommentSymbol(0)
  630.     , fTextSymbol(0)
  631.     , fPISymbol(0)
  632.     , fNodeSymbol(0)
  633.     , fAncestorSymbol(0)
  634.     , fAncestorOrSelfSymbol(0)
  635.     , fAttributeSymbol(0)
  636.     , fChildSymbol(0)
  637.     , fDescendantSymbol(0)
  638.     , fDescendantOrSelfSymbol(0)
  639.     , fFollowingSymbol(0)
  640.     , fFollowingSiblingSymbol(0)
  641.     , fNamespaceSymbol(0)
  642.     , fParentSymbol(0)
  643.     , fPrecedingSymbol(0)
  644.     , fPrecedingSiblingSymbol(0)
  645.     , fSelfSymbol(0)
  646.     , fStringPool(stringPool)
  647. {
  648.     init();
  649. }
  651. // ---------------------------------------------------------------------------
  652. //  XPathScanner: Helper methods
  653. // ---------------------------------------------------------------------------
  654. void XPathScanner::init() {
  656.     fAndSymbol = fStringPool->addOrFind(XPathSymbols::fgSYMBOL_AND);
  657.     fOrSymbol = fStringPool->addOrFind(XPathSymbols::fgSYMBOL_OR);
  658.     fModSymbol = fStringPool->addOrFind(XPathSymbols::fgSYMBOL_MOD);
  659.     fDivSymbol = fStringPool->addOrFind(XPathSymbols::fgSYMBOL_DIV);
  660.     fCommentSymbol = fStringPool->addOrFind(XPathSymbols::fgSYMBOL_COMMENT);
  661.     fTextSymbol = fStringPool->addOrFind(XPathSymbols::fgSYMBOL_TEXT);
  662.     fPISymbol = fStringPool->addOrFind(XPathSymbols::fgSYMBOL_PI);
  663.     fNodeSymbol = fStringPool->addOrFind(XPathSymbols::fgSYMBOL_NODE);
  664.     fAncestorSymbol = fStringPool->addOrFind(XPathSymbols::fgSYMBOL_ANCESTOR);
  665.     fAncestorOrSelfSymbol = fStringPool->addOrFind(XPathSymbols::fgSYMBOL_ANCESTOR_OR_SELF);
  666.     fAttributeSymbol = fStringPool->addOrFind(XPathSymbols::fgSYMBOL_ATTRIBUTE);
  667.     fChildSymbol = fStringPool->addOrFind(XPathSymbols::fgSYMBOL_CHILD);
  668.     fDescendantSymbol = fStringPool->addOrFind(XPathSymbols::fgSYMBOL_DESCENDANT);
  669.     fDescendantOrSelfSymbol = fStringPool->addOrFind(XPathSymbols::fgSYMBOL_DESCENDANT_OR_SELF);
  670.     fFollowingSymbol = fStringPool->addOrFind(XPathSymbols::fgSYMBOL_FOLLOWING);
  671.     fFollowingSiblingSymbol = fStringPool->addOrFind(XPathSymbols::fgSYMBOL_FOLLOWING_SIBLING);
  672.     fNamespaceSymbol = fStringPool->addOrFind(XPathSymbols::fgSYMBOL_NAMESPACE);
  673.     fParentSymbol = fStringPool->addOrFind(XPathSymbols::fgSYMBOL_PARENT);
  674.     fPrecedingSymbol = fStringPool->addOrFind(XPathSymbols::fgSYMBOL_PRECEDING);
  675.     fPrecedingSiblingSymbol = fStringPool->addOrFind(XPathSymbols::fgSYMBOL_PRECEDING_SIBLING);
  676.     fSelfSymbol = fStringPool->addOrFind(XPathSymbols::fgSYMBOL_SELF);
  677. }
  680. // ---------------------------------------------------------------------------
  681. //  XPathScanner: Scan methods
  682. // ---------------------------------------------------------------------------
  683. bool XPathScanner::scanExpression(const XMLCh* const data,
  684.                                   int currentOffset,
  685.                                   const int endOffset,
  686.                                   ValueVectorOf<int>* const tokens) {
  688.     bool      starIsMultiplyOperator = false;
  689.     int       nameOffset = -1;
  690.     int       nameHandle = -1;
  691.     int       prefixHandle = -1;
  692.     XMLCh     ch;
  693.     XMLBuffer dataBuffer(128, tokens->getMemoryManager());
  695.     while (true) {
  697.         if (currentOffset == endOffset) {
  698.             break;
  699.         }
  701.         ch = data[currentOffset];
  703.         while (XMLChar1_0::isWhitespace(ch)) {
  705.             if (++currentOffset == endOffset) {
  706.                 break;
  707.             }
  709.             ch = data[currentOffset];
  710.         }
  712.         if (currentOffset == endOffset) {
  713.             break;
  714.         }
  715.         //
  716.         // [28] ExprToken ::= '(' | ')' | '[' | ']' | '.' | '..' | '@' | ',' | '::'
  717.         //                  | NameTest | NodeType | Operator | FunctionName
  718.         //                  | AxisName | Literal | Number | VariableReference
  719.         //
  720.         XMLByte chartype = (ch >= 0x80) ? CHARTYPE_NONASCII : fASCIICharMap[ch];
  722.         switch (chartype) {
  723.         case CHARTYPE_OPEN_PAREN:       // '('
  724.             addToken(tokens, XercesXPath::EXPRTOKEN_OPEN_PAREN);
  725.             starIsMultiplyOperator = false;
  726.             ++currentOffset;
  727.             break;
  728.         case CHARTYPE_CLOSE_PAREN:      // ')'
  729.             addToken(tokens, XercesXPath::EXPRTOKEN_CLOSE_PAREN);
  730.             starIsMultiplyOperator = true;
  731.             ++currentOffset;
  732.             break;
  733.         case CHARTYPE_OPEN_BRACKET:     // '['
  734.             addToken(tokens, XercesXPath::EXPRTOKEN_OPEN_BRACKET);
  735.             starIsMultiplyOperator = false;
  736.             ++currentOffset;
  737.             break;
  738.         case CHARTYPE_CLOSE_BRACKET:    // ']'
  739.             addToken(tokens, XercesXPath::EXPRTOKEN_CLOSE_BRACKET);
  740.             starIsMultiplyOperator = true;
  741.             ++currentOffset;
  742.             break;
  743.                 //
  744.                 // [30] Number ::= Digits ('.' Digits?)? | '.' Digits
  745.                 //                                         ^^^^^^^^^^
  746.                 //
  747.         case CHARTYPE_PERIOD:           // '.', '..' or '.' Digits
  748.             if (currentOffset + 1 == endOffset) {
  749.                 addToken(tokens, XercesXPath::EXPRTOKEN_PERIOD);
  750.                 starIsMultiplyOperator = true;
  751.                 currentOffset++;
  752.                 break;
  753.             }
  755.             ch = data[currentOffset + 1];
  757.             if (ch == chPeriod) {            // '..'
  758.                 addToken(tokens, XercesXPath::EXPRTOKEN_DOUBLE_PERIOD);
  759.                 starIsMultiplyOperator = true;
  760.                 currentOffset += 2;
  761.             } else if (ch >= chDigit_0 && ch <= chDigit_9) {
  762.                 addToken(tokens, XercesXPath::EXPRTOKEN_NUMBER);
  763.                 starIsMultiplyOperator = true;
  764.                 currentOffset = scanNumber(data, endOffset, currentOffset, tokens);
  765.             } else if (ch == chForwardSlash) {
  766.                 addToken(tokens, XercesXPath::EXPRTOKEN_PERIOD);
  767.                 starIsMultiplyOperator = true;
  768.                 currentOffset++;
  769.             } else if (ch == chPipe) { // '|'
  770.                 addToken(tokens, XercesXPath::EXPRTOKEN_PERIOD);
  771.                 starIsMultiplyOperator = true;
  772.                 currentOffset++;
  773.             } else if (XMLChar1_0::isWhitespace(ch)) {
  774.                 do {
  775.                     if (++currentOffset == endOffset)
  776.                         break;
  778.                     ch = data[currentOffset];
  779.                 } while (XMLChar1_0::isWhitespace(ch));
  781.                 if (currentOffset == endOffset || ch == chPipe) {
  782.     addToken(tokens, XercesXPath::EXPRTOKEN_PERIOD);
  783.                     starIsMultiplyOperator = true;
  784.                     break;
  785.                 }
  786.             } else {
  787.                 ThrowXML(XPathException, XMLExcepts::XPath_InvalidChar);
  788.             }
  790.             break;
  791.         case CHARTYPE_ATSIGN:           // '@'
  792.             addToken(tokens, XercesXPath::EXPRTOKEN_ATSIGN);
  793.             starIsMultiplyOperator = false;
  794.             ++currentOffset;
  795.             break;
  796.         case CHARTYPE_COMMA:            // ','
  797.             addToken(tokens, XercesXPath::EXPRTOKEN_COMMA);
  798.             starIsMultiplyOperator = false;
  799.             ++currentOffset;
  800.             break;
  801.         case CHARTYPE_COLON:            // '::'
  802.             if (++currentOffset == endOffset) {
  803.                 return false; // REVISIT
  804.             }
  805.             ch = data[currentOffset];
  807.             if (ch != chColon) {
  808.                 return false; // REVISIT
  809.             }
  810.             addToken(tokens, XercesXPath::EXPRTOKEN_DOUBLE_COLON);
  811.             starIsMultiplyOperator = false;
  812.             ++currentOffset;
  813.             break;
  814.         case CHARTYPE_SLASH:            // '/' and '//'
  815.             if (++currentOffset == endOffset) {
  816.                 addToken(tokens, XercesXPath::EXPRTOKEN_OPERATOR_SLASH);
  817.                 starIsMultiplyOperator = false;
  818.                 break;
  819.             }
  821.             ch = data[currentOffset];
  823.             if (ch == chForwardSlash) { // '//'
  824.                 addToken(tokens, XercesXPath::EXPRTOKEN_OPERATOR_DOUBLE_SLASH);
  825.                 starIsMultiplyOperator = false;
  826.                 ++currentOffset;
  827.             } else {
  828.                 addToken(tokens, XercesXPath::EXPRTOKEN_OPERATOR_SLASH);
  829.                 starIsMultiplyOperator = false;
  830.             }
  831.             break;
  832.         case CHARTYPE_UNION:            // '|'
  833.             addToken(tokens, XercesXPath::EXPRTOKEN_OPERATOR_UNION);
  834.             starIsMultiplyOperator = false;
  835.             ++currentOffset;
  836.             break;
  837.         case CHARTYPE_PLUS:             // '+'
  838.             addToken(tokens, XercesXPath::EXPRTOKEN_OPERATOR_PLUS);
  839.             starIsMultiplyOperator = false;
  840.             ++currentOffset;
  841.             break;
  842.         case CHARTYPE_MINUS:            // '-'
  843.             addToken(tokens, XercesXPath::EXPRTOKEN_OPERATOR_MINUS);
  844.             starIsMultiplyOperator = false;
  845.             ++currentOffset;
  846.             break;
  847.         case CHARTYPE_EQUAL:            // '='
  848.             addToken(tokens, XercesXPath::EXPRTOKEN_OPERATOR_EQUAL);
  849.             starIsMultiplyOperator = false;
  850.             ++currentOffset;
  851.             break;
  852.         case CHARTYPE_EXCLAMATION:      // '!='
  853.             if (++currentOffset == endOffset) {
  854.                 return false; // REVISIT
  855.             }
  857.             ch = data[currentOffset];
  859.             if (ch != chEqual) {
  860.                 return false; // REVISIT
  861.             }
  863.             addToken(tokens, XercesXPath::EXPRTOKEN_OPERATOR_NOT_EQUAL);
  864.             starIsMultiplyOperator = false;
  865.             ++currentOffset;
  866.             break;
  867.         case CHARTYPE_LESS: // '<' and '<='
  868.             if (++currentOffset == endOffset) {
  869.                 addToken(tokens, XercesXPath::EXPRTOKEN_OPERATOR_LESS);
  870.                 starIsMultiplyOperator = false;
  871.                 break;
  872.             }
  874.             ch = data[currentOffset];
  876.             if (ch == chEqual) { // '<='
  877.                 addToken(tokens, XercesXPath::EXPRTOKEN_OPERATOR_LESS_EQUAL);
  878.                 starIsMultiplyOperator = false;
  879.                 ++currentOffset;
  880.             } else {
  881.                 addToken(tokens, XercesXPath::EXPRTOKEN_OPERATOR_LESS);
  882.                 starIsMultiplyOperator = false;
  883.             }
  884.             break;
  885.         case CHARTYPE_GREATER: // '>' and '>='
  886.             if (++currentOffset == endOffset) {
  887.                 addToken(tokens, XercesXPath::EXPRTOKEN_OPERATOR_GREATER);
  888.                 starIsMultiplyOperator = false;
  889.                 break;
  890.             }
  892.             ch = data[currentOffset];
  894.             if (ch == chEqual) { // '>='
  895.                 addToken(tokens, XercesXPath::EXPRTOKEN_OPERATOR_GREATER_EQUAL);
  896.                 starIsMultiplyOperator = false;
  897.                 ++currentOffset;
  898.             } else {
  899.                 addToken(tokens, XercesXPath::EXPRTOKEN_OPERATOR_GREATER);
  900.                 starIsMultiplyOperator = false;
  901.             }
  902.             break;
  903.         //
  904.         // [29] Literal ::= '"' [^"]* '"' | "'" [^']* "'"
  905.         //
  906.         case CHARTYPE_QUOTE:            // '"' or '''
  907.             {
  908.                 XMLCh qchar = ch;
  909.                 if (++currentOffset == endOffset) {
  910.                     return false; // REVISIT
  911.                 }
  913.                 ch = data[currentOffset];
  915.                 int litOffset = currentOffset;
  916.                 while (ch != qchar) {
  917.                     if (++currentOffset == endOffset) {
  918.                         return false; // REVISIT
  919.                     }
  921.                     ch = data[currentOffset];
  922.                 }
  924.                 addToken(tokens, XercesXPath::EXPRTOKEN_LITERAL);
  925.                 starIsMultiplyOperator = true;
  927.                 dataBuffer.set(data + litOffset, currentOffset - litOffset);
  928.                 tokens->addElement(fStringPool->addOrFind(dataBuffer.getRawBuffer()));
  929.                 ++currentOffset;
  930.                 break;
  931.             }
  932.         //
  933.         // [30] Number ::= Digits ('.' Digits?)? | '.' Digits
  934.         // [31] Digits ::= [0-9]+
  935.         //
  936.         case CHARTYPE_DIGIT:
  937.             addToken(tokens, XercesXPath::EXPRTOKEN_NUMBER);
  938.             starIsMultiplyOperator = true;
  939.             currentOffset = scanNumber(data, endOffset, currentOffset, tokens);
  940.             break;
  941.         //
  942.         // [36] VariableReference ::= '$' QName
  943.         //
  944.         case CHARTYPE_DOLLAR:
  945.             if (++currentOffset == endOffset) {
  946.                 return false; // REVISIT
  947.             }
  948.             nameOffset = currentOffset;
  949.             currentOffset = scanNCName(data, endOffset, currentOffset);
  951.             if (currentOffset == nameOffset) {
  952.                 return false; // REVISIT
  953.             }
  955.             if (currentOffset < endOffset) {
  956.                 ch = data[currentOffset];
  957.             }
  958.             else {
  959.                 ch = 0;
  960.             }
  962.             dataBuffer.set(data + nameOffset, currentOffset - nameOffset);
  963.             nameHandle = fStringPool->addOrFind(dataBuffer.getRawBuffer());
  964.             prefixHandle = -1;
  966.             if (ch == chColon) {
  968.                 prefixHandle = nameHandle;
  969.                 if (++currentOffset == endOffset) {
  970.                     return false; // REVISIT
  971.                 }
  972.                 nameOffset = currentOffset;
  973.                 currentOffset = scanNCName(data, endOffset, currentOffset);
  975.                 if (currentOffset == nameOffset) {
  976.                     return false; // REVISIT
  977.                 }
  979.                 dataBuffer.set(data + nameOffset, currentOffset - nameOffset);
  980.                 nameHandle = fStringPool->addOrFind(dataBuffer.getRawBuffer());
  981.             }
  982.             addToken(tokens, XercesXPath::EXPRTOKEN_VARIABLE_REFERENCE);
  983.             starIsMultiplyOperator = true;
  984.             tokens->addElement(prefixHandle);
  985.             tokens->addElement(nameHandle);
  986.             break;
  987.         //
  988.         // [37] NameTest ::= '*' | NCName ':' '*' | QName
  989.         // [34] MultiplyOperator ::= '*'
  990.         //
  991.         case CHARTYPE_STAR:             // '*'
  992.             //
  993.             // 3.7 Lexical Structure
  994.             //
  995.             //  If there is a preceding token and the preceding token is not one of @, ::, (, [, , or
  996.             //  an Operator, then a * must be recognized as a MultiplyOperator.
  997.             //
  998.             // Otherwise, the token must not be recognized as a MultiplyOperator.
  999.             //
  1000.             if (starIsMultiplyOperator) {
  1001.                 addToken(tokens, XercesXPath::EXPRTOKEN_OPERATOR_MULT);
  1002.                 starIsMultiplyOperator = false;
  1003.             } else {
  1004.                 addToken(tokens, XercesXPath::EXPRTOKEN_NAMETEST_ANY);
  1005.                 starIsMultiplyOperator = true;
  1006.             }
  1008.             ++currentOffset;
  1009.             break;
  1010.         //
  1011.         // NCName, QName and non-terminals
  1012.         //
  1013.         case CHARTYPE_NONASCII: // possibly a valid non-ascii 'Letter' (BaseChar | Ideographic)
  1014.         case CHARTYPE_LETTER:
  1015.         case CHARTYPE_UNDERSCORE:
  1016.             //
  1017.             // 3.7 Lexical Structure
  1018.             //
  1019.             //  If there is a preceding token and the preceding token is not one of @, ::, (, [, , or
  1020.             //  an Operator, then an NCName must be recognized as an OperatorName.
  1021.             //
  1022.             //  If the character following an NCName (possibly after intervening ExprWhitespace) is (,
  1023.             //  then the token must be recognized as a NodeType or a FunctionName.
  1024.             //
  1025.             //  If the two characters following an NCName (possibly after intervening ExprWhitespace)
  1026.             //  are ::, then the token must be recognized as an AxisName.
  1027.             //
  1028.             //  Otherwise, the token must not be recognized as an OperatorName, a NodeType, a
  1029.             //  FunctionName, or an AxisName.
  1030.             //
  1031.             // [33] OperatorName ::= 'and' | 'or' | 'mod' | 'div'
  1032.             // [38] NodeType ::= 'comment' | 'text' | 'processing-instruction' | 'node'
  1033.             // [35] FunctionName ::= QName - NodeType
  1034.             // [6] AxisName ::= (see above)
  1035.             //
  1036.             // [37] NameTest ::= '*' | NCName ':' '*' | QName
  1037.             // [5] NCName ::= (Letter | '_') (NCNameChar)*
  1038.             // [?] NCNameChar ::= Letter | Digit | '.' | '-' | '_'  (ascii subset of 'NCNameChar')
  1039.             // [?] QName ::= (NCName ':')? NCName
  1040.             // [?] Letter ::= [A-Za-z]                              (ascii subset of 'Letter')
  1041.             // [?] Digit ::= [0-9]                                  (ascii subset of 'Digit')
  1042.             //
  1043.             nameOffset = currentOffset;
  1044.             currentOffset = scanNCName(data, endOffset, currentOffset);
  1045.             if (currentOffset == nameOffset) {
  1046.                 return false; // REVISIT
  1047. }
  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());
  1059.             bool isNameTestNCName = false;
  1060.             bool isAxisName = false;
  1061.             prefixHandle = -1;
  1063.             if (ch == chColon) {
  1065.                 if (++currentOffset == endOffset) {
  1066.                     return false; // REVISIT
  1067.                 }
  1069.                 ch = data[currentOffset];
  1071.                 if (ch == chAsterisk) {
  1072.                     if (++currentOffset < endOffset) {
  1073.                         ch = data[currentOffset];
  1074.                     }
  1076.                     isNameTestNCName = true;
  1077.                 } else if (ch == chColon) {
  1078.                     if (++currentOffset < endOffset) {
  1079.                         ch = data[currentOffset];
  1080.                     }
  1082.                     isAxisName = true;
  1083.                 } else {
  1084.                     prefixHandle = nameHandle;
  1085.                     nameOffset = currentOffset;
  1086.                     currentOffset = scanNCName(data, endOffset, currentOffset);
  1087.                     if (currentOffset == nameOffset) {
  1088.                         return false; // REVISIT
  1089.                     }
  1090.                     if (currentOffset < endOffset) {
  1091.                         ch = data[currentOffset];
  1092.                     }
  1093.                     else {
  1094.                         ch = 0;
  1095.                     }
  1097.                     dataBuffer.set(data + nameOffset, currentOffset - nameOffset);
  1098.                     nameHandle = fStringPool->addOrFind(dataBuffer.getRawBuffer());
  1099.                 }
  1100.             }
  1101.             //
  1102.             // [39] ExprWhitespace ::= S
  1103.             //
  1104.             while (XMLChar1_0::isWhitespace(ch)) {
  1105.                 if (++currentOffset == endOffset) {
  1106.                     break;
  1107.                 }
  1108.                 ch = data[currentOffset];
  1109.             }
  1111.             //
  1112.             //  If there is a preceding token and the preceding token is not one of @, ::, (, [, , or
  1113.             //  an Operator, then an NCName must be recognized as an OperatorName.
  1114.             //
  1115.             if (starIsMultiplyOperator) {
  1116.                 if (nameHandle == fAndSymbol) {
  1117.                     addToken(tokens, XercesXPath::EXPRTOKEN_OPERATOR_AND);
  1118.                     starIsMultiplyOperator = false;
  1119.                 } else if (nameHandle == fOrSymbol) {
  1120.                     addToken(tokens, XercesXPath::EXPRTOKEN_OPERATOR_OR);
  1121.                     starIsMultiplyOperator = false;
  1122.                 } else if (nameHandle == fModSymbol) {
  1123.                     addToken(tokens, XercesXPath::EXPRTOKEN_OPERATOR_MOD);
  1124.                     starIsMultiplyOperator = false;
  1125.                 } else if (nameHandle == fDivSymbol) {
  1126.                     addToken(tokens, XercesXPath::EXPRTOKEN_OPERATOR_DIV);
  1127.                     starIsMultiplyOperator = false;
  1128.                 } else {
  1129.                     return false; // REVISIT
  1130.                 }
  1132.                 if (isNameTestNCName) {
  1133.                     return false; // REVISIT - NCName:* where an OperatorName is required
  1134.                 } else if (isAxisName) {
  1135.                     return false; // REVISIT - AxisName:: where an OperatorName is required
  1136.                 }
  1137.                 break;
  1138.             }
  1139.             //
  1140.             //  If the character following an NCName (possibly after intervening ExprWhitespace) is (,
  1141.             //  then the token must be recognized as a NodeType or a FunctionName.
  1142.             //
  1143.             if (ch == chOpenParen && !isNameTestNCName && !isAxisName) {
  1144.                 if (nameHandle == fCommentSymbol) {
  1145.                     addToken(tokens, XercesXPath::EXPRTOKEN_NODETYPE_COMMENT);
  1146.                 } else if (nameHandle == fTextSymbol) {
  1147.                     addToken(tokens, XercesXPath::EXPRTOKEN_NODETYPE_TEXT);
  1148.                 } else if (nameHandle == fPISymbol) {
  1149.                     addToken(tokens, XercesXPath::EXPRTOKEN_NODETYPE_PI);
  1150.                 } else if (nameHandle == fNodeSymbol) {
  1151.                     addToken(tokens, XercesXPath::EXPRTOKEN_NODETYPE_NODE);
  1152.                 } else {
  1153.                     addToken(tokens, XercesXPath::EXPRTOKEN_FUNCTION_NAME);
  1154.                     tokens->addElement(prefixHandle);
  1155.                     tokens->addElement(nameHandle);
  1156.                 }
  1157.                 addToken(tokens, XercesXPath::EXPRTOKEN_OPEN_PAREN);
  1158.                 starIsMultiplyOperator = false;
  1159.                 ++currentOffset;
  1160.                 break;
  1161.             }
  1163.             //
  1164.             //  If the two characters following an NCName (possibly after intervening ExprWhitespace)
  1165.             //  are ::, then the token must be recognized as an AxisName.
  1166.             //
  1167.             if (isAxisName ||
  1168.                 (ch == chColon && currentOffset + 1 < endOffset &&
  1169.                  data[currentOffset + 1] == chColon)) {
  1171.                 if (nameHandle == fAncestorSymbol) {
  1172.                     addToken(tokens, XercesXPath::EXPRTOKEN_AXISNAME_ANCESTOR);
  1173.                 } else if (nameHandle == fAncestorOrSelfSymbol) {
  1174.                     addToken(tokens, XercesXPath::EXPRTOKEN_AXISNAME_ANCESTOR_OR_SELF);
  1175.                 } else if (nameHandle == fAttributeSymbol) {
  1176.                     addToken(tokens, XercesXPath::EXPRTOKEN_AXISNAME_ATTRIBUTE);
  1177.                 } else if (nameHandle == fChildSymbol) {
  1178.                     addToken(tokens, XercesXPath::EXPRTOKEN_AXISNAME_CHILD);
  1179.                 } else if (nameHandle == fDescendantSymbol) {
  1180.                     addToken(tokens, XercesXPath::EXPRTOKEN_AXISNAME_DESCENDANT);
  1181.                 } else if (nameHandle == fDescendantOrSelfSymbol) {
  1182.                     addToken(tokens, XercesXPath::EXPRTOKEN_AXISNAME_DESCENDANT_OR_SELF);
  1183.                 } else if (nameHandle == fFollowingSymbol) {
  1184.                     addToken(tokens, XercesXPath::EXPRTOKEN_AXISNAME_FOLLOWING);
  1185.                 } else if (nameHandle == fFollowingSiblingSymbol) {
  1186.                     addToken(tokens, XercesXPath::EXPRTOKEN_AXISNAME_FOLLOWING_SIBLING);
  1187.                 } else if (nameHandle == fNamespaceSymbol) {
  1188.                     addToken(tokens, XercesXPath::EXPRTOKEN_AXISNAME_NAMESPACE);
  1189.                 } else if (nameHandle == fParentSymbol) {
  1190.                     addToken(tokens, XercesXPath::EXPRTOKEN_AXISNAME_PARENT);
  1191.                 } else if (nameHandle == fPrecedingSymbol) {
  1192.                     addToken(tokens, XercesXPath::EXPRTOKEN_AXISNAME_PRECEDING);
  1193.                 } else if (nameHandle == fPrecedingSiblingSymbol) {
  1194.                     addToken(tokens, XercesXPath::EXPRTOKEN_AXISNAME_PRECEDING_SIBLING);
  1195.                 } else if (nameHandle == fSelfSymbol) {
  1196.                     addToken(tokens, XercesXPath::EXPRTOKEN_AXISNAME_SELF);
  1197.                 } else {
  1198.                     return false; // REVISIT
  1199.                 }
  1201.                 if (isNameTestNCName) {
  1202.                     return false; // REVISIT - "NCName:* ::" where "AxisName ::" is required
  1203.                 }
  1205.                 addToken(tokens, XercesXPath::EXPRTOKEN_DOUBLE_COLON);
  1206.                 starIsMultiplyOperator = false;
  1207.                 if (!isAxisName) {
  1208.                     currentOffset += 2;
  1209.                 }
  1210.                 break;
  1211.             }
  1212.             //
  1213.             //  Otherwise, the token must not be recognized as an OperatorName, a NodeType, a
  1214.             //  FunctionName, or an AxisName.
  1215.             //
  1216.             if (isNameTestNCName) {
  1217.                 addToken(tokens, XercesXPath::EXPRTOKEN_NAMETEST_NAMESPACE);
  1218.                 tokens->addElement(nameHandle);
  1219.             } else {
  1220.                 addToken(tokens, XercesXPath::EXPRTOKEN_NAMETEST_QNAME);
  1221.                 tokens->addElement(prefixHandle);
  1222.                 tokens->addElement(nameHandle);
  1223.             }
  1225.             starIsMultiplyOperator = true;
  1226.             break;
  1227.         }
  1228.     }
  1230.     return true;
  1231. }
  1234. int XPathScanner::scanNCName(const XMLCh* const data,
  1235.                              const int endOffset,
  1236.                              int currentOffset) {
  1238.     XMLCh ch = data[currentOffset];
  1240.     if (!XMLChar1_0::isXMLLetter(ch) && ch != chUnderscore) {
  1241.         return currentOffset;
  1242.     }
  1244.     while (++currentOffset < endOffset) {
  1246.         ch = data[currentOffset];
  1248.         if (ch == chColon || !XMLChar1_0::isNameChar(ch)) {
  1249.             break;
  1250.         }
  1251.     }
  1253.     return currentOffset;
  1254. }
  1257. int XPathScanner::scanNumber(const XMLCh* const data,
  1258.                              const int endOffset,
  1259.                              int currentOffset,
  1260.                              ValueVectorOf<int>* const tokens) {
  1262.     XMLCh ch = data[currentOffset];
  1263.     int   whole = 0;
  1264.     int   part = 0;
  1266.     while (ch >= chDigit_0 && ch <= chDigit_9) {
  1268.         whole = (whole * 10) + (ch - chDigit_0);
  1270.         if (++currentOffset == endOffset) {
  1271.             break;
  1272.         }
  1274.         ch = data[currentOffset];
  1275.     }
  1277.     if (ch == chPeriod) {
  1279.         if (++currentOffset < endOffset) {
  1281.             int start = currentOffset;
  1283.             ch = data[currentOffset];
  1285.             while (ch >= chDigit_0 && ch <= chDigit_9) {
  1287.                 part = (part * 10) + (ch - chDigit_0);
  1289.                 if (++currentOffset == endOffset) {
  1290.                     break;
  1291.                 }
  1293.                 ch = data[currentOffset];
  1294.             }
  1296.             if (part != 0) {
  1297.                 ThrowXML(RuntimeException, XMLExcepts::XPath_FindSolution);
  1298.             }
  1299.         }
  1300.     }
  1302.     tokens->addElement(whole);
  1303.     tokens->addElement(part);
  1305.     return currentOffset;
  1306. }
  1309. // ---------------------------------------------------------------------------
  1310. //  XPathScannerForSchema: Constructors and Destructor
  1311. // ---------------------------------------------------------------------------
  1312. XPathScannerForSchema::XPathScannerForSchema(XMLStringPool* const stringPool)
  1313.     : XPathScanner(stringPool)
  1314. {
  1315. }
  1318. // ---------------------------------------------------------------------------
  1319. //  XPathScannerForSchema: Helper methods
  1320. // ---------------------------------------------------------------------------
  1321. void XPathScannerForSchema::addToken(ValueVectorOf<int>* const tokens,
  1322.                                      const int aToken) {
  1324.     if (aToken == XercesXPath::EXPRTOKEN_ATSIGN ||
  1325.         aToken == XercesXPath::EXPRTOKEN_AXISNAME_ATTRIBUTE ||
  1326.         aToken == XercesXPath::EXPRTOKEN_AXISNAME_CHILD ||
  1327.         //token == XercesXPath::EXPRTOKEN_AXISNAME_SELF ||
  1328.         aToken == XercesXPath::EXPRTOKEN_DOUBLE_COLON ||
  1329.         aToken == XercesXPath::EXPRTOKEN_NAMETEST_QNAME ||
  1330.         //token == XercesXPath::EXPRTOKEN_NODETYPE_NODE ||
  1331.         aToken == XercesXPath::EXPRTOKEN_OPERATOR_SLASH ||
  1332.         aToken == XercesXPath::EXPRTOKEN_PERIOD ||
  1333.         aToken == XercesXPath::EXPRTOKEN_NAMETEST_ANY ||
  1334.         aToken == XercesXPath::EXPRTOKEN_NAMETEST_NAMESPACE ||
  1335.         aToken == XercesXPath::EXPRTOKEN_OPERATOR_DOUBLE_SLASH ||
  1336.         aToken == XercesXPath::EXPRTOKEN_OPERATOR_UNION) {
  1338.         tokens->addElement(aToken);
  1339.         return;
  1340.     }
  1342.     ThrowXML(XPathException, XMLExcepts::XPath_TokenNotSupported);
  1343. }
  1345. XERCES_CPP_NAMESPACE_END
  1347. /**
  1348.   * End of file XercesPath.cpp
  1349.   */