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

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

词法分析

开发平台：

Visual C++

RegxParser.cpp：源码内容
  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 2003 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) 2001, 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: RegxParser.cpp,v $
  59.  * Revision 1.9  2003/05/18 14:02:06  knoaman
  60.  * Memory manager implementation: pass per instance manager.
  61.  *
  62.  * Revision 1.8  2003/05/16 00:03:10  knoaman
  63.  * Partial implementation of the configurable memory manager.
  64.  *
  65.  * Revision 1.7  2003/05/15 18:42:55  knoaman
  66.  * Partial implementation of the configurable memory manager.
  67.  *
  68.  * Revision 1.6  2003/03/18 19:38:28  knoaman
  69.  * Schema Errata E2-18 + misc. regex fixes.
  70.  *
  71.  * Revision 1.5  2003/03/04 16:36:17  knoaman
  72.  * RegEx: fix for character category escape
  73.  *
  74.  * Revision 1.4  2003/01/13 19:02:23  knoaman
  75.  * [Bug 14390] C++ Indentifier collision with Python.
  76.  *
  77.  * Revision 1.3  2002/11/04 15:17:00  tng
  78.  * C++ Namespace Support.
  79.  *
  80.  * Revision 1.2  2002/03/18 19:29:53  knoaman
  81.  * Change constant names to eliminate possible conflict with user defined ones.
  82.  *
  83.  * Revision 1.1.1.1  2002/02/01 22:22:30  peiyongz
  84.  * sane_include
  85.  *
  86.  * Revision 1.10  2001/11/20 20:48:10  knoaman
  87.  * Fix for invalid repeating quantifier check.
  88.  *
  89.  * Revision 1.9  2001/11/16 15:56:37  knoaman
  90.  * Add check for invalid repeating quantifier.
  91.  *
  92.  * Revision 1.8  2001/09/20 13:11:42  knoaman
  93.  * Regx  + misc. fixes
  94.  *
  95.  * Revision 1.7  2001/08/31 16:53:41  knoaman
  96.  * Misc. fixes.
  97.  *
  98.  * Revision 1.6  2001/07/26 12:46:48  knoaman
  99.  * Fix for bug 2815.
  100.  *
  101.  * Revision 1.5  2001/06/06 13:49:27  jberry
  102.  * Fix two improper NULL tests
  103.  *
  104.  * Revision 1.4  2001/05/11 21:51:01  knoaman
  105.  * Schema updates and fixes.
  106.  *
  107.  * Revision 1.3  2001/05/11 13:26:48  tng
  108.  * Copyright update.
  109.  *
  110.  * Revision 1.2  2001/05/03 18:17:45  knoaman
  111.  * Some design changes:
  112.  * o Changed the TokenFactory from a single static instance, to a
  113.  *    normal class. Each RegularExpression object will have its own
  114.  *    instance of TokenFactory, and that instance will be passed to
  115.  *    other classes that need to use a TokenFactory to create Token
  116.  *    objects (with the exception of RangeTokenMap).
  117.  * o Added a new class RangeTokenMap to map a the different ranges
  118.  *    in a given category to a specific RangeFactory object. In the old
  119.  *    design RangeFactory had dual functionality (act as a Map, and as
  120.  *    a factory for creating RangeToken(s)). The RangeTokenMap will
  121.  *    have its own copy of the TokenFactory. There will be only one
  122.  *    instance of the RangeTokenMap class, and that instance will be
  123.  *    lazily deleted when XPlatformUtils::Terminate is called.
  124.  *
  125.  * Revision 1.1  2001/03/02 19:22:54  knoaman
  126.  * Schema: Regular expression handling part I
  127.  *
  128.  */
  130. // ---------------------------------------------------------------------------
  131. //  Includes
  132. // ---------------------------------------------------------------------------
  133. #include <xercesc/util/regx/RegxParser.hpp>
  134. #include <xercesc/util/XMLString.hpp>
  135. #include <xercesc/util/ParseException.hpp>
  136. #include <xercesc/util/regx/RegularExpression.hpp>
  137. #include <xercesc/util/regx/RegxUtil.hpp>
  138. #include <xercesc/util/regx/RegxDefs.hpp>
  139. #include <xercesc/util/regx/TokenInc.hpp>
  140. #include <xercesc/framework/XMLErrorCodes.hpp>
  142. XERCES_CPP_NAMESPACE_BEGIN
  144. // ---------------------------------------------------------------------------
  145. //  Static member data initialization
  146. // ---------------------------------------------------------------------------
  147. const unsigned short RegxParser::S_NORMAL = 0;
  148. const unsigned short RegxParser::S_INBRACKETS = 1;
  149. const unsigned short RegxParser::S_INXBRACKETS = 2;
  151. // ---------------------------------------------------------------------------
  152. //  RegxParser::ReferencePostion: Constructors and Destructor
  153. // ---------------------------------------------------------------------------
  154. RegxParser::ReferencePosition::ReferencePosition(const int refNo,
  155.  const int position)
  156. :fReferenceNo(refNo)
  157. , fPosition(position)
  158. {
  160. }
  162. // ---------------------------------------------------------------------------
  163. //  RegxParser: Constructors and Destructors
  164. // ---------------------------------------------------------------------------
  165. RegxParser::RegxParser(MemoryManager* const manager)
  166.     :fMemoryManager(manager),
  167.      fHasBackReferences(false),
  168.      fOptions(0),
  169.      fOffset(0),
  170.      fNoGroups(1),
  171.      fParseContext(S_NORMAL),
  172.      fStringLen(0),
  173.      fState(0),
  174.      fCharData(0),
  175.      fString(0),
  176.      fReferences(0),
  177.      fTokenFactory(0)
  178. {
  179. }
  181. RegxParser::~RegxParser() {
  183. fMemoryManager->deallocate(fString);//delete [] fString;
  184. delete fReferences;
  185. }
  187. // ---------------------------------------------------------------------------
  188. //  RegxParser: Parsing methods
  189. // ---------------------------------------------------------------------------
  190. Token* RegxParser::parse(const XMLCh* const regxStr, const int options) {
  192.     // if TokenFactory is not set do nothing.
  193.     // REVISIT - should we throw an exception
  194.     if (fTokenFactory == 0) {
  195.         return 0;
  196.     }
  198. XMLMutexLock lockInit(&fMutex);
  200. fOptions = options;
  201. fOffset = 0;
  202. fNoGroups = 1;
  203. fHasBackReferences = false;
  204. setParseContext(S_NORMAL);
  205. if (fString)
  206.         fMemoryManager->deallocate(fString);//delete [] fString;
  207. fString = XMLString::replicate(regxStr, fMemoryManager);
  209. if (isSet(RegularExpression::EXTENDED_COMMENT)) {
  211.         if (fString)
  212.             fMemoryManager->deallocate(fString);//delete [] fString;
  213. fString = RegxUtil::stripExtendedComment(regxStr, fMemoryManager);
  214.     }
  216.     fStringLen = XMLString::stringLen(fString);
  217.     processNext();
  219.     Token* retTok = parseRegx();
  221. if (fOffset != fStringLen) {
  222.         ThrowXML(ParseException,XMLExcepts::Parser_Parse1);
  223.     }
  225.     if (fReferences != 0) {
  227. unsigned int refSize = fReferences->size();
  228.         for (unsigned int i = 0; i < refSize; i++) {
  230. if (fNoGroups <= fReferences->elementAt(i)->fReferenceNo) {
  231.                 ThrowXML(ParseException,XMLExcepts::Parser_Parse2);
  232.             }
  233.         }
  235. fReferences->removeAllElements();
  236.     }
  238.     return retTok;
  239. }
  242. void RegxParser::processNext() {
  244.     if (fOffset >= fStringLen) {
  246.         fCharData = -1;
  247.         fState = REGX_T_EOF;
  248.         return;
  249. }
  251.     unsigned short nextState;
  252. XMLCh ch = fString[fOffset++];
  253. fCharData = ch;
  255.     if (fParseContext == S_INBRACKETS) {
  257. switch (ch) {
  258.         case chBackSlash:
  259.             nextState = REGX_T_BACKSOLIDUS;
  261. if (fOffset >= fStringLen) {
  262. ThrowXML(ParseException,XMLExcepts::Parser_Next1);
  263. }
  265. fCharData = fString[fOffset++];
  266. break;
  267. case chDash:
  268.             if (isSet(RegularExpression::XMLSCHEMA_MODE)
  269.                 && fOffset < fStringLen && fString[fOffset] == chOpenSquare) {
  271.                 fOffset++;
  272.                 nextState = REGX_T_XMLSCHEMA_CC_SUBTRACTION;
  273.             }
  274.             else {
  275.                 nextState = REGX_T_CHAR;
  276.             }
  277.             break;
  278.         case chOpenSquare:
  279.             if (!isSet(RegularExpression::XMLSCHEMA_MODE)
  280.                 && fOffset < fStringLen && fString[fOffset] == chColon) {
  282.                 fOffset++;
  283.                 nextState = REGX_T_POSIX_CHARCLASS_START;
  284.                 break;
  285. } // Through down
  286.         default:
  287.             if (RegxUtil::isHighSurrogate(ch) && fOffset < fStringLen) {
  289.                 XMLCh lowCh = fString[fOffset];
  290.                 if (RegxUtil::isLowSurrogate(lowCh)) {
  291.                     fCharData = RegxUtil::composeFromSurrogate(ch, lowCh);
  292. fOffset++;
  293.                 }
  294. else {
  295.                     throw XMLErrs::Expected2ndSurrogateChar;
  296.                 }
  297.             }
  299. nextState = REGX_T_CHAR;
  300.         }
  302.         fState = nextState;
  303.         return;
  304.     }
  306.     switch (ch) {
  308.     case chPipe:
  309.         nextState = REGX_T_OR;
  310.         break;
  311.     case chAsterisk:
  312.         nextState = REGX_T_STAR;
  313.         break;
  314.     case chPlus:
  315.         nextState = REGX_T_PLUS;
  316.         break;
  317.     case chQuestion:
  318. nextState = REGX_T_QUESTION;
  319. break;
  320.     case chCloseParen:
  321.         nextState = REGX_T_RPAREN;
  322.         break;
  323.     case chPeriod:
  324. nextState = REGX_T_DOT;
  325. break;
  326.     case chOpenSquare:
  327.         nextState = REGX_T_LBRACKET;
  328.         break;
  329.     case chCaret:
  330.         nextState = REGX_T_CARET;
  331.         break;
  332.     case chDollarSign:
  333. nextState = REGX_T_DOLLAR;
  334. break;
  335. case chOpenParen:
  336.         {
  337.     nextState = REGX_T_LPAREN;
  338.             if (fOffset >= fStringLen)
  339.                 break;
  341. if (fString[fOffset] != chQuestion)
  342.                 break;
  344.             if (++fOffset >= fStringLen)
  345.                 ThrowXML(ParseException,XMLExcepts::Parser_Next2);
  347.             ch = fString[fOffset++];
  349.             switch (ch) {
  350.             case chColon:
  351.                 nextState = REGX_T_LPAREN2;
  352.                 break;
  353. case chEqual:
  354.                 nextState = REGX_T_LOOKAHEAD;
  355.                 break;
  356.             case chBang:
  357.                 nextState = REGX_T_NEGATIVELOOKAHEAD;
  358.                 break;
  359.             case chOpenSquare:
  360.                 nextState = REGX_T_SET_OPERATIONS;
  361.                 break;
  362.             case chCloseAngle:
  363.                 nextState = REGX_T_INDEPENDENT;
  364. break;
  365.             case chOpenAngle:
  366. if (fOffset >= fStringLen)
  367. ThrowXML(ParseException,XMLExcepts::Parser_Next2);
  369. ch = fString[fOffset++];
  371. if (ch == chEqual) {
  372. nextState = REGX_T_LOOKBEHIND;
  373. }
  374. else if (ch == chBang) {
  375. nextState = REGX_T_NEGATIVELOOKBEHIND;
  376. }
  377. else {
  378. ThrowXML(ParseException,XMLExcepts::Parser_Next3);
  379. }
  380. break;
  381.             case chPound:
  382. while (fOffset < fStringLen) {
  384. ch = fString[fOffset++];
  385. if (ch == chCloseParen)
  386. break;
  387. }
  389. if (ch != chCloseParen)
  390. ThrowXML(ParseException,XMLExcepts::Parser_Next4);
  392. nextState = REGX_T_COMMENT;
  393. break;
  394.             default:
  395. if (ch == chDash || chLatin_a <= ch && ch <= chLatin_z
  396.                     || chLatin_A <= ch && ch <= chLatin_Z) { // Options
  398.                     fOffset--;
  399.                     nextState = REGX_T_MODIFIERS;
  400.                     break;
  401.                 }
  402.                 else if (ch == chOpenParen) {
  403.                     nextState = REGX_T_CONDITION;
  404.                     break;
  405.                 }
  406.                 ThrowXML(ParseException,XMLExcepts::Parser_Next2);
  407.             }
  408.         }
  409. break;
  410. case chBackSlash:
  411.         nextState = REGX_T_BACKSOLIDUS;
  412.         if (fOffset >= fStringLen) {
  413. ThrowXML(ParseException,XMLExcepts::Parser_Next1);
  414.         }
  416.         fCharData = fString[fOffset++];
  417.         break;
  418. default:
  419. nextState = REGX_T_CHAR;
  420. if (RegxUtil::isHighSurrogate(ch) && fOffset < fStringLen) {
  422.                 XMLCh lowCh = fString[fOffset];
  423.                 if (RegxUtil::isLowSurrogate(lowCh)) {
  424.                     fCharData = RegxUtil::composeFromSurrogate(ch, lowCh);
  425. fOffset++;
  426.                 }
  427. else {
  428.                     throw XMLErrs::Expected2ndSurrogateChar;
  429.                 }
  430.             }
  431. }
  433. fState = nextState;
  434. }
  437. Token* RegxParser::parseRegx(const bool matchingRParen) {
  439.     Token* tok = parseTerm(matchingRParen);
  440.     Token* parentTok = 0;
  442.     while (fState == REGX_T_OR) {
  444.         processNext();
  445.         if (parentTok == 0) {
  447.             parentTok = fTokenFactory->createUnion();
  448.     parentTok->addChild(tok, fTokenFactory);
  449.             tok = parentTok;
  450.         }
  452.         tok->addChild(parseTerm(matchingRParen), fTokenFactory);
  453.     }
  455.     return tok;
  456. }
  459. Token* RegxParser::parseTerm(const bool matchingRParen) {
  461.     unsigned short state = fState;
  463.     if (state == REGX_T_OR || state == REGX_T_EOF
  464.         || (state == REGX_T_RPAREN && matchingRParen)) {
  465.         return fTokenFactory->createToken(Token::T_EMPTY);
  466.     }
  467.     else {
  469.         Token* tok = parseFactor();
  470.         Token* concatTok = 0;
  472.         while ((state = fState) != REGX_T_OR && state != REGX_T_EOF
  473.                && (state != REGX_T_RPAREN || !matchingRParen))
  474.         {
  475.             if (concatTok == 0) {
  477.                 concatTok = fTokenFactory->createUnion(true);
  478.                 concatTok->addChild(tok, fTokenFactory);
  479.                 tok = concatTok;
  480.             }
  481.             concatTok->addChild(parseFactor(), fTokenFactory);
  482.         }
  484.         return tok;
  485.     }
  486. }
  489. Token* RegxParser::processCaret() {
  491.     processNext();
  492. return fTokenFactory->getLineBegin();
  493. }
  496. Token* RegxParser::processDollar() {
  498.     processNext();
  499.     return fTokenFactory->getLineEnd();
  500. }
  503. Token* RegxParser::processLook(const unsigned short tokType) {
  505.     processNext();
  507. Token* tok = fTokenFactory->createLook(tokType, parseRegx());
  509.     if (fState != REGX_T_RPAREN) {
  510.         ThrowXML(ParseException,XMLExcepts::Parser_Factor1);
  511.     }
  513.     processNext();
  515.     return tok;
  516. }
  519. Token* RegxParser::processBacksolidus_A() {
  521.     processNext();
  522. return fTokenFactory->getStringBegin();
  523. }
  526. Token* RegxParser::processBacksolidus_Z() {
  528.     processNext();
  529.     return fTokenFactory->getStringEnd2();
  530. }
  533. Token* RegxParser::processBacksolidus_z() {
  535.     processNext();
  536.     return fTokenFactory->getStringEnd();
  537. }
  540. Token* RegxParser::processBacksolidus_b() {
  542.     processNext();
  543.     return fTokenFactory->getWordEdge();
  544. }
  547. Token* RegxParser::processBacksolidus_B() {
  549.     processNext();
  550.     return fTokenFactory->getNotWordEdge();
  551. }
  554. Token* RegxParser::processBacksolidus_lt() {
  556.     processNext();
  557.     return fTokenFactory->getWordBegin();
  558. }
  561. Token* RegxParser::processBacksolidus_gt() {
  563.     processNext();
  564.     return fTokenFactory->getWordEnd();
  565. }
  568. Token* RegxParser::processStar(Token* const tok) {
  570.     processNext();
  572.     if (fState == REGX_T_QUESTION) {
  574.         processNext();
  575.         return fTokenFactory->createClosure(tok, true);
  576.     }
  578.     return fTokenFactory->createClosure(tok);
  579. }
  582. Token* RegxParser::processPlus(Token* const tok) {
  584.     processNext();
  586.     if (fState == REGX_T_QUESTION) {
  588. processNext();
  589. return fTokenFactory->createConcat(tok,
  590.                fTokenFactory->createClosure(tok,true));
  591.     }
  593.     return fTokenFactory->createConcat(tok,
  594.                         fTokenFactory->createClosure(tok));
  595. }
  598. Token* RegxParser::processQuestion(Token* const tok) {
  600.     processNext();
  602.     Token* parentTok = fTokenFactory->createUnion();
  604.     if (fState == REGX_T_QUESTION) {
  606.         processNext();
  607.         parentTok->addChild(fTokenFactory->createToken(Token::T_EMPTY), fTokenFactory);
  608.         parentTok->addChild(tok, fTokenFactory);
  609.     }
  610.     else {
  612.         parentTok->addChild(tok, fTokenFactory);
  613.         parentTok->addChild(fTokenFactory->createToken(Token::T_EMPTY), fTokenFactory);
  614.     }
  616.     return parentTok;
  617. }
  620. Token* RegxParser::processParen() {
  622.     processNext();
  623.     int num = fNoGroups++;
  624.     Token* tok = fTokenFactory->createParenthesis(parseRegx(true),num);
  626.     if (fState != REGX_T_RPAREN)
  627.         ThrowXML(ParseException,XMLExcepts::Parser_Factor1);
  629.     processNext();
  630.     return tok;
  631. }
  634. Token* RegxParser::processParen2() {
  636.     processNext();
  637.     Token* tok = fTokenFactory->createParenthesis(parseRegx(), 0);
  639.     if (fState != REGX_T_RPAREN)
  640.         ThrowXML(ParseException,XMLExcepts::Parser_Factor1);
  642.     processNext();
  643.     return tok;
  644. }
  647. Token* RegxParser::processCondition() {
  649.     if (fOffset + 1 >= fStringLen)
  650. ThrowXML(ParseException,XMLExcepts::Parser_Factor4);
  652.     int refNo = -1;
  653. Token* conditionTok = 0;
  654. XMLInt32 ch = fString[fOffset];
  656.     if (chDigit_1 <= ch && ch <= chDigit_9) {
  658.         refNo = ch - chDigit_0;
  659.         fHasBackReferences =  true;
  661.         if (fReferences == 0) {
  662.             this->fReferences = new (fMemoryManager) RefVectorOf<ReferencePosition>(8, true, fMemoryManager);
  663.         }
  665.         fReferences->addElement(new (fMemoryManager) ReferencePosition(refNo, fOffset));
  666.         fOffset++;
  668.         if (fString[fOffset] != chCloseParen)
  669.             ThrowXML(ParseException,XMLExcepts::Parser_Factor1);
  671.         fOffset++;
  672.     }
  673.     else {
  675.         if (ch == chQuestion) {
  676.             fOffset--;
  677.         }
  679.         processNext();
  680.         conditionTok = parseFactor();
  681.         switch(conditionTok->getTokenType()) {
  682.         case Token::T_LOOKAHEAD:
  683.         case Token::T_NEGATIVELOOKAHEAD:
  684.         case Token::T_LOOKBEHIND:
  685.         case Token::T_NEGATIVELOOKBEHIND:
  686.             break;
  687.         case Token::T_ANCHOR:
  688.             if (fState != REGX_T_RPAREN)
  689. ThrowXML(ParseException,XMLExcepts::Parser_Factor1);
  690. break;
  691.         default:
  692. ThrowXML(ParseException,XMLExcepts::Parser_Factor5);
  693.         }
  694.     }
  696.     processNext();
  697.     Token* yesPattern = parseRegx();
  698.     Token* noPattern = 0;
  700.     if (yesPattern->getTokenType() == Token::T_UNION) {
  702.         if (yesPattern->size() != 2)
  703.             ThrowXML(ParseException,XMLExcepts::Parser_Factor6);
  705.         noPattern = yesPattern->getChild(1);
  706.         yesPattern = yesPattern->getChild(0);
  707.     }
  709.     if (fState != REGX_T_RPAREN)
  710.         ThrowXML(ParseException,XMLExcepts::Parser_Factor1);
  712. processNext();
  713. return fTokenFactory->createCondition(refNo,conditionTok,
  714.                                              yesPattern,noPattern);
  715. }
  718. Token* RegxParser::processModifiers() {
  720.     // fOffset points to the next '?'.
  721. // modifiers ::= [imsw]* ('-' [imsw]*)? ':'
  722.     int add = 0;
  723.     int mask = 0;
  724.     XMLInt32 ch = -1;
  726.     while (fOffset < fStringLen) {
  728.         int v = RegularExpression::getOptionValue(fString[fOffset]);
  730.         ch = fString[fOffset];
  731.         if (v == 0)
  732.             break;
  734.         add |= v;
  735.         fOffset++;
  736.     } // end while
  738.     if (fOffset >= fStringLen)
  739.         ThrowXML(ParseException,XMLExcepts::Parser_Factor2);
  741.     if (ch == chDash) {
  743.         fOffset++;
  744.         while(fOffset < fStringLen) {
  745.             int v = RegularExpression::getOptionValue(fString[fOffset]);
  747.             ch = fString[fOffset];
  748.             if (v == 0)
  749.                 break;
  751.             mask |= v;
  752.             fOffset++;
  753.         }
  755.         if (fOffset >= fStringLen)
  756.             ThrowXML(ParseException,XMLExcepts::Parser_Factor2);
  757.     }
  759.     Token* tok = 0;
  761.     if (ch == chColon) {
  763.         fOffset++;
  764. processNext();
  765.         tok = fTokenFactory->createModifierGroup(parseRegx(),add,mask);
  767.         if (fState != REGX_T_RPAREN)
  768.             ThrowXML(ParseException,XMLExcepts::Parser_Factor1);
  770.         processNext();
  771.     }
  772.     else if (ch == chCloseParen) {
  774.         fOffset++;
  775.         processNext();
  776.         tok = fTokenFactory->createModifierGroup(parseRegx(),add,mask);
  777.     }
  778.     else {
  779.         ThrowXML(ParseException,XMLExcepts::Parser_Factor3);
  780. }
  782. return tok;
  783. }
  786. Token* RegxParser::processIndependent() {
  788.     processNext();
  790. Token* tok = fTokenFactory->createLook(Token::T_INDEPENDENT, parseRegx());
  792. if (fState != REGX_T_RPAREN)
  793. ThrowXML(ParseException,XMLExcepts::Parser_Factor1);
  795.     processNext();
  796.     return tok;
  797. }
  800. Token* RegxParser::processBacksolidus_c() {
  802.     XMLCh ch; //Must be in 0x0040-0x005F
  804.     if (fOffset >= fStringLen
  805.         || ((ch = fString[fOffset++]) & 0xFFE0) != 0x0040)
  806.         ThrowXML(ParseException,XMLExcepts::Parser_Atom1);
  808.     processNext();
  809. return fTokenFactory->createChar(ch - 0x40);
  810. }
  813. Token* RegxParser::processBacksolidus_C() {
  815. // REVISIT - Do we throw an exception - we do not want to throw too
  816. // many exceptions
  817.     return 0;
  818. }
  820. Token* RegxParser::processBacksolidus_i() {
  822.     processNext();
  823. return fTokenFactory->createChar(chLatin_i);
  824. }
  827. Token* RegxParser::processBacksolidus_I() {
  829. //Ditto
  830.     return 0;
  831. }
  834. Token* RegxParser::processBacksolidus_g() {
  836.     processNext();
  837.     return fTokenFactory->getGraphemePattern();
  838. }
  841. Token* RegxParser::processBacksolidus_X() {
  843.     processNext();
  844.     return fTokenFactory->getCombiningCharacterSequence();
  845. }
  847. Token* RegxParser::processBackReference() {
  849.     int refNo = fCharData - chDigit_0;
  850.     Token* tok = fTokenFactory->createBackReference(refNo);
  852.     fHasBackReferences = true;
  853.     if (fReferences == 0) {
  854.         fReferences = new (fMemoryManager) RefVectorOf<ReferencePosition>(8, true, fMemoryManager);
  855.     }
  857.     fReferences->addElement(new (fMemoryManager) ReferencePosition(refNo, fOffset - 2));
  858.     processNext();
  859.     return tok;
  860. }
  863. Token* RegxParser::parseFactor() {
  865.     switch (fState) {
  867.     case REGX_T_CARET:
  868.         return processCaret();
  869.     case REGX_T_DOLLAR:
  870.         return processDollar();
  871.     case REGX_T_LOOKAHEAD:
  872.         return processLook(Token::T_LOOKAHEAD);
  873.     case REGX_T_NEGATIVELOOKAHEAD:
  874.         return processLook(Token::T_NEGATIVELOOKAHEAD);
  875.     case REGX_T_LOOKBEHIND:
  876.         return processLook(Token::T_LOOKBEHIND);
  877.     case REGX_T_NEGATIVELOOKBEHIND:
  878.         return processLook(Token::T_NEGATIVELOOKBEHIND);
  879.     case REGX_T_COMMENT:
  880.         processNext();
  881.         return fTokenFactory->createToken(Token::T_EMPTY);
  882.     case REGX_T_BACKSOLIDUS:
  883.         switch(fCharData) {
  884.         case chLatin_A:
  885.             return processBacksolidus_A();
  886.         case chLatin_Z:
  887.             return processBacksolidus_Z();
  888.         case chLatin_z:
  889.             return processBacksolidus_z();
  890.         case chLatin_b:
  891.             return processBacksolidus_B();
  892.         case chLatin_B:
  893.             return processBacksolidus_B();
  894.         case chOpenAngle:
  895.             return processBacksolidus_lt();
  896.         case chCloseAngle:
  897.             return processBacksolidus_gt();
  898. }
  899.     }
  901. Token* tok = parseAtom();
  903. switch(fState) {
  905.     case REGX_T_STAR:
  906.         return processStar(tok);
  907.     case REGX_T_PLUS:
  908.         return processPlus(tok);
  909.     case REGX_T_QUESTION:
  910.         return processQuestion(tok);
  911.     case REGX_T_CHAR:
  912.         if (fCharData == chOpenCurly && fOffset < fStringLen) {
  914.             int min = 0;
  915.             int max = -1;
  916.             XMLInt32 ch = fString[fOffset++];
  918.             if (ch >= chDigit_0 && ch <= chDigit_9) {
  920.                 min = ch - chDigit_0;
  921.                 while (fOffset < fStringLen
  922.                        && (ch = fString[fOffset++]) >= chDigit_0
  923.                        && ch <= chDigit_9) {
  925.                     min = min*10 + ch - chDigit_0;
  926.                 }
  928.                 if (min < 0)
  929.                     ThrowXML1(ParseException, XMLExcepts::Parser_Quantifier5, fString);
  930.             }
  931.             else {
  932.                 ThrowXML1(ParseException, XMLExcepts::Parser_Quantifier1, fString);
  933.             }
  935.             max = min;
  937.             if (ch == chComma) {
  939.                 if (fOffset >= fStringLen) {
  940.                     ThrowXML1(ParseException, XMLExcepts::Parser_Quantifier3, fString);
  941.                 }
  942.                 else if ((ch = fString[fOffset++]) >= chDigit_0 && ch <= chDigit_9) {
  944.                     max = ch - chDigit_0;
  945.                     while (fOffset < fStringLen
  946.                            && (ch = fString[fOffset++]) >= chDigit_0
  947.                            && ch <= chDigit_9) {
  949.                         max = max*10 + ch - chDigit_0;
  950.                     }
  952.                     if (max < 0)
  953.                         ThrowXML1(ParseException, XMLExcepts::Parser_Quantifier5, fString);
  954.                     else if (min > max)
  955.                         ThrowXML1(ParseException, XMLExcepts::Parser_Quantifier4, fString);
  956.                 }
  957.                 else {
  958.                     max = -1;
  959.                 }
  960.             }
  962.             if (ch != chCloseCurly)  {
  963.                 ThrowXML1(ParseException, XMLExcepts::Parser_Quantifier2, fString);
  964.             }
  966.             if (checkQuestion(fOffset)) {
  968.                 tok = fTokenFactory->createClosure(tok, true);
  969.                 fOffset++;
  970.             }
  971.             else {
  972.                 tok = fTokenFactory->createClosure(tok);
  973.             }
  975.             tok->setMin(min);
  976.             tok->setMax(max);
  977.             processNext();
  978. }
  979.         break;
  980. }
  982. return tok;
  983. }
  986. Token* RegxParser::parseAtom() {
  988.     Token* tok = 0;
  990.     switch(fState) {
  992.     case REGX_T_LPAREN:
  993.         return processParen();
  994.     case REGX_T_LPAREN2:
  995.         return processParen2();
  996.     case REGX_T_CONDITION:
  997.         return processCondition();
  998.     case REGX_T_MODIFIERS:
  999.         return processModifiers();
  1000.     case REGX_T_INDEPENDENT:
  1001.         return processIndependent();
  1002.     case REGX_T_DOT:
  1003.         processNext();
  1004.         tok = fTokenFactory->getDot();
  1005.         break;
  1006.     case REGX_T_LBRACKET:
  1007.         return parseCharacterClass(true);
  1008.     case REGX_T_SET_OPERATIONS:
  1009.         return parseSetOperations();
  1010.     case REGX_T_BACKSOLIDUS:
  1011. switch(fCharData) {
  1013.         case chLatin_d:
  1014.         case chLatin_D:
  1015.         case chLatin_w:
  1016.         case chLatin_W:
  1017.         case chLatin_s:
  1018.         case chLatin_S:
  1019.             tok = getTokenForShorthand(fCharData);
  1020.             processNext();
  1021.             return tok;
  1022.         case chLatin_c:
  1023.             return processBacksolidus_c();
  1024.         case chLatin_C:
  1025.             return processBacksolidus_C();
  1026.         case chLatin_i:
  1027.             return processBacksolidus_i();
  1028.         case chLatin_I:
  1029.             return processBacksolidus_I();
  1030.         case chLatin_g:
  1031.             return processBacksolidus_g();
  1032.         case chLatin_X:
  1033.             return processBacksolidus_X();
  1034.         case chDigit_0:
  1035.         case chDigit_1:
  1036.         case chDigit_2:
  1037.         case chDigit_3:
  1038.         case chDigit_4:
  1039.         case chDigit_5:
  1040.         case chDigit_6:
  1041.         case chDigit_7:
  1042.         case chDigit_8:
  1043.         case chDigit_9:
  1044.             return processBackReference();
  1045.         case chLatin_p:
  1046.         case chLatin_P:
  1047. {
  1048. int start = fOffset;
  1049. tok = processBacksolidus_pP(fCharData);
  1050. if (tok == 0) {
  1051. ThrowXML(ParseException,XMLExcepts::Parser_Atom5);
  1052. }
  1053. }
  1054.             break;
  1055.         default:
  1056.             {
  1057.                 XMLInt32 ch = decodeEscaped();
  1058.                 if (ch < 0x10000) {
  1059.                     tok = fTokenFactory->createChar(ch);
  1060.                 }
  1061.                 else {
  1063.                     XMLCh* surrogateStr = RegxUtil::decomposeToSurrogates(ch, fMemoryManager);
  1064.     ArrayJanitor<XMLCh> janSurrogate(surrogateStr, fMemoryManager);
  1065.     tok = fTokenFactory->createString(surrogateStr);
  1066.                 }
  1067.             }
  1068. break;
  1069. } // end switch
  1071.         processNext();
  1072.         break;
  1073.     case REGX_T_CHAR:
  1074.         if (fCharData == chOpenCurly
  1075.             || fCharData == chCloseCurly
  1076.             || fCharData == chCloseSquare)
  1077.             ThrowXML(ParseException,XMLExcepts::Parser_Atom4);
  1079.         tok = fTokenFactory->createChar(fCharData);
  1080.         processNext();
  1081.         break;
  1082.     default:
  1083.         ThrowXML(ParseException,XMLExcepts::Parser_Atom4);
  1084.     } //end switch
  1086.     return tok;
  1087. }
  1090. RangeToken* RegxParser::processBacksolidus_pP(const XMLInt32 ch) {
  1092.     processNext();
  1094.     if (fState != REGX_T_CHAR || fCharData != chOpenCurly)
  1095.         ThrowXML(ParseException,XMLExcepts::Parser_Atom2);
  1097.     int nameStart = fOffset;
  1098.     int nameEnd = XMLString::indexOf(fString,chCloseCurly,nameStart);
  1100.     if (nameEnd < 0)
  1101.         ThrowXML(ParseException,XMLExcepts::Parser_Atom3);
  1102.     
  1103.     fOffset = nameEnd + 1;
  1104.     XMLCh* rangeName = (XMLCh*) fMemoryManager->allocate
  1105.     (
  1106.         (nameEnd - nameStart + 1) * sizeof(XMLCh)
  1107.     );//new XMLCh[(nameEnd - nameStart) + 1];
  1108.     ArrayJanitor<XMLCh> janRangeName(rangeName, fMemoryManager);
  1109.     XMLString::subString(rangeName, fString, nameStart, nameEnd);
  1111.     return  fTokenFactory->getRange(rangeName, !(ch == chLatin_p));
  1112. }
  1115. XMLInt32 RegxParser::processCInCharacterClass(RangeToken* const tok,
  1116.                                               const XMLInt32 ch) {
  1118. return decodeEscaped();
  1119. }
  1122. RangeToken* RegxParser::parseCharacterClass(const bool useNRange) {
  1124.     setParseContext(S_INBRACKETS);
  1125. processNext();
  1127.     RangeToken* base = 0;
  1128.     RangeToken* tok = 0;
  1129.     bool nRange = false;
  1131. if (fState == REGX_T_CHAR && fCharData == chCaret) {
  1133.         nRange = true;
  1134.         processNext();
  1136. if (useNRange) {
  1137.             tok = fTokenFactory->createRange(true);
  1138.         }
  1139.         else {
  1141. base = fTokenFactory->createRange();
  1142.             base->addRange(0, Token::UTF16_MAX);
  1143.             tok = fTokenFactory->createRange();
  1144.         }
  1145.     }
  1146.     else {
  1147.         tok = fTokenFactory->createRange();
  1148.     }
  1150.     bool firstLoop = true;
  1152.     while (fState != REGX_T_EOF) {
  1154.         if (fState == REGX_T_CHAR && fCharData == chCloseSquare && !firstLoop)
  1155. break;
  1157.         bool end = false;
  1158.         XMLInt32 ch = fCharData;
  1160.         firstLoop = false;
  1161.         if (fState == REGX_T_BACKSOLIDUS) {
  1163.             switch(ch) {
  1164.             case chLatin_d:
  1165.             case chLatin_D:
  1166.             case chLatin_w:
  1167.             case chLatin_W:
  1168.             case chLatin_s:
  1169.             case chLatin_S:
  1170.                 tok->mergeRanges(getTokenForShorthand(ch));
  1171.                 end = true;
  1172. break;
  1173.             case chLatin_i:
  1174.             case chLatin_I:
  1175.             case chLatin_c:
  1176.             case chLatin_C:
  1177.                 ch = processCInCharacterClass(tok, ch);
  1178. if (ch < 0){
  1179.     end = true;
  1180.                 }
  1181.                 break;
  1182.             case chLatin_p:
  1183.             case chLatin_P:
  1184. {
  1185. int pStart = fOffset;
  1186. RangeToken* tok2 = processBacksolidus_pP(ch);
  1188. if (tok2 == 0) {
  1189. ThrowXML(ParseException,XMLExcepts::Parser_Atom5);
  1190. }
  1192. tok->mergeRanges(tok2);
  1193. end = true;
  1194. }
  1195.                 break;
  1196.             default:
  1197.                 ch = decodeEscaped();
  1198. }
  1199.         } // end if REGX_T_BACKSOLIDUS
  1200.         else if (fState == REGX_T_POSIX_CHARCLASS_START) {
  1202.             int nameEnd = XMLString::indexOf(fString, chColon, fOffset);
  1204.             if (nameEnd < 0) {
  1205. ThrowXML(ParseException,XMLExcepts::Parser_CC1);
  1206. }
  1208.             bool positive = true;
  1210.             if (fString[fOffset] == chCaret) {
  1212.                 fOffset++;
  1213.                 positive = false;
  1214.             }
  1216. XMLCh* name = (XMLCh*) fMemoryManager->allocate
  1217.             (
  1218.                 (nameEnd - fOffset + 1) * sizeof(XMLCh)
  1219.             );//new XMLCh[(nameEnd - fOffset) + 1];
  1220. ArrayJanitor<XMLCh> janName(name, fMemoryManager);
  1222. XMLString::subString(name, fString, fOffset, nameEnd);
  1223.             RangeToken* rangeTok = fTokenFactory->getRange(name, !positive);
  1225.             if (rangeTok == 0) {
  1226. ThrowXML(ParseException,XMLExcepts::Parser_CC3);
  1227.             }
  1229. tok->mergeRanges(rangeTok);
  1230. end = true;
  1232. if (nameEnd+1 >= fStringLen || fString[nameEnd+1] != chCloseSquare) {
  1233. ThrowXML(ParseException,XMLExcepts::Parser_CC1);
  1234. }
  1236. fOffset = nameEnd + 2;
  1237.         }
  1239.         processNext();
  1240. if (!end) {
  1242.             if (fState != REGX_T_CHAR || fCharData != chDash) {
  1243.                 tok->addRange(ch, ch);
  1244.             }
  1245.             else {
  1247.                 processNext();
  1249.                 if (fState == REGX_T_EOF)
  1250.                     ThrowXML(ParseException,XMLExcepts::Parser_CC2);
  1252.                 if (fState == REGX_T_CHAR && fCharData == chCloseSquare) {
  1254.                     tok->addRange(ch, ch);
  1255.                     tok->addRange(chDash, chDash);
  1256.                 }
  1257.                 else {
  1259.                     XMLInt32 rangeEnd = fCharData;
  1261.                     if (fState == REGX_T_BACKSOLIDUS) {
  1262.                         rangeEnd = decodeEscaped();
  1263.                     }
  1265.                     processNext();
  1266.                     tok->addRange(ch, rangeEnd);
  1267.                 }
  1268.             }
  1269.         }
  1271.         if (isSet(RegularExpression::SPECIAL_COMMA)
  1272.             && fState == REGX_T_CHAR && fCharData == chComma) {
  1273.             processNext();
  1274.         }
  1275.     } // end while fState
  1277. if (fState == REGX_T_EOF) {
  1278.         ThrowXML(ParseException,XMLExcepts::Parser_CC2);
  1279. }
  1281.     if (!useNRange && nRange) {
  1283.         base->subtractRanges(tok);
  1284.         tok = base;
  1285.     }
  1287.     tok->sortRanges();
  1288.     tok->compactRanges();
  1289.     setParseContext(S_NORMAL);
  1290.     processNext();
  1292.     return tok;
  1293. }
  1296. RangeToken* RegxParser::parseSetOperations() {
  1298.     RangeToken* tok = parseCharacterClass(false);
  1300.     while (fState != REGX_T_RPAREN) {
  1302. if (fState == REGX_T_CHAR
  1303.             && (fCharData == chDash || fCharData == chAmpersand)
  1304.             || fState == REGX_T_PLUS) {
  1306.             processNext();
  1307.             if (fState != REGX_T_LBRACKET)
  1308.                 ThrowXML(ParseException,XMLExcepts::Parser_Ope1);
  1310.             RangeToken* tok2 = parseCharacterClass(false);
  1312.             if (fState == REGX_T_PLUS) {
  1313.                 tok->mergeRanges(tok2);
  1314.             }
  1315.             else if (fCharData == chDash) {
  1316.                 tok->subtractRanges(tok2);
  1317.             }
  1318.             else if (fCharData == chAmpersand) {
  1319.                 tok->intersectRanges(tok2);
  1320.             }
  1321.             else {
  1322.                 throw 0; // ThrowXML(RuntimeException, "ASSERT")
  1323.             }
  1324.         }
  1325.         else {
  1326. ThrowXML(ParseException,XMLExcepts::Parser_Ope2);
  1327. }
  1328.     }
  1330.     processNext();
  1331.     return tok;
  1332. }
  1334. Token* RegxParser::getTokenForShorthand(const XMLInt32 ch) {
  1336.     Token* tok = 0;
  1337.     bool useUnicode = isSet(RegularExpression::USE_UNICODE_CATEGORY);
  1339. switch (ch) {
  1340. case chLatin_d:
  1341. tok = useUnicode ? fTokenFactory->getRange(fgUniDecimalDigit)
  1342.  : fTokenFactory->getRange(fgASCIIDigit);
  1343. break;
  1344. case chLatin_D:
  1345. tok = useUnicode ? fTokenFactory->getRange(fgUniDecimalDigit, true)
  1346.  : fTokenFactory->getRange(fgASCIIDigit, true);
  1347. break;
  1348. case chLatin_w:
  1349. tok = useUnicode ? fTokenFactory->getRange(fgUniIsWord)
  1350.  : fTokenFactory->getRange(fgASCIIWord);
  1351. break;
  1352. case chLatin_W:
  1353. tok = useUnicode ? fTokenFactory->getRange(fgUniIsWord, true)
  1354.  : fTokenFactory->getRange(fgASCIIWord, true);
  1355. break;
  1356. case chLatin_s:
  1357. tok = useUnicode ? fTokenFactory->getRange(fgUniIsSpace)
  1358.  : fTokenFactory->getRange(fgASCIISpace);
  1359. break;
  1360. case chLatin_S:
  1361. tok = useUnicode ? fTokenFactory->getRange(fgUniIsSpace, true)
  1362.  : fTokenFactory->getRange(fgASCIISpace, true);
  1363. // default:
  1364. // ThrowXML(RuntimeException, "Invalid shorthand {0}", chAsString)
  1365. }
  1367.     return tok;
  1368. }
  1371. XMLInt32 RegxParser::decodeEscaped() {
  1373.     if (fState != REGX_T_BACKSOLIDUS)
  1374. ThrowXML(ParseException,XMLExcepts::Parser_Next1);
  1376.     XMLInt32 ch = fCharData;
  1378. switch (ch) {
  1379. case chLatin_e:
  1380. ch = 0x1B; // Escape
  1381. break;
  1382. case chLatin_f:
  1383. ch = chFF;
  1384. break;
  1385. case chLatin_n:
  1386. ch = chLF;
  1387. break;
  1388. case chLatin_r:
  1389. ch = chCR;
  1390. break;
  1391. case chLatin_t:
  1392. ch = chHTab;
  1393. break;
  1394. case chLatin_x:
  1395. {
  1396. processNext();
  1397. if (fState != REGX_T_CHAR) {
  1398. ThrowXML(ParseException,XMLExcepts::Parser_Descape1);
  1399. }
  1400. if (fCharData == chOpenCurly) {
  1402. int v1 = 0;
  1403. XMLInt32 uv = 0;
  1405. do {
  1406. processNext();
  1407. if (fState != REGX_T_CHAR)
  1408. ThrowXML(ParseException,XMLExcepts::Parser_Descape1);
  1410. if ((v1 = hexChar(fCharData)) < 0)
  1411. break;
  1413. uv = uv*16 + v1;
  1414. } while (true);
  1416. if (fCharData != chCloseCurly)
  1417. ThrowXML(ParseException,XMLExcepts::Parser_Descape3);
  1419. if (uv > Token::UTF16_MAX)
  1420. ThrowXML(ParseException,XMLExcepts::Parser_Descape4);
  1422. ch = uv;
  1423. }
  1424. else {
  1425. int v1 = 0;
  1426. if (fState != REGX_T_CHAR || (v1 = hexChar(fCharData)) < 0)
  1427. ThrowXML(ParseException,XMLExcepts::Parser_Descape1);
  1429. int uv = v1;
  1431. processNext();
  1432. if (fState != REGX_T_CHAR || (v1 = hexChar(fCharData)) < 0)
  1433. ThrowXML(ParseException,XMLExcepts::Parser_Descape1);
  1435. ch = uv*16 + v1;
  1436. }
  1437. }
  1438. break;
  1439. case chLatin_u:
  1440. {
  1441. int v1 = 0;
  1442. int uv = 0;
  1444. for (int i=0; i< 4; i++) {
  1446. processNext();
  1447. if (fState != REGX_T_CHAR || (v1 = hexChar(fCharData)) < 0)
  1448. ThrowXML(ParseException,XMLExcepts::Parser_Descape1);
  1450. uv = (i == 0) ? v1 : uv*16 + v1;
  1451. }
  1453. ch = uv;
  1454. }
  1455. break;
  1456. case chLatin_v:
  1457. {
  1458. int v1 = 0;
  1459. int uv = 0;
  1461. for (int i=0; i< 6; i++) {
  1463. processNext();
  1464. if (fState != REGX_T_CHAR || (v1 = hexChar(fCharData)) < 0)
  1465. ThrowXML(ParseException,XMLExcepts::Parser_Descape1);
  1467. uv = (i == 0) ? v1 : uv*16 + v1;
  1468. }
  1470. if (uv > Token::UTF16_MAX)
  1471. ThrowXML(ParseException,XMLExcepts::Parser_Descape1);
  1473. ch = uv;
  1474. }
  1475. break;
  1476. case chLatin_A:
  1477. case chLatin_Z:
  1478. case chLatin_z:
  1479. ThrowXML(ParseException,XMLExcepts::Parser_Descape5);
  1480. } // end switch
  1482.     return ch;
  1483. }
  1485. // ---------------------------------------------------------------------------
  1486. //  RegxParser: Helper Methods
  1487. // ---------------------------------------------------------------------------
  1488. bool RegxParser::checkQuestion(const int off) {
  1490.     return ((off < fStringLen) && fString[off] == chQuestion);
  1491. }
  1493. XERCES_CPP_NAMESPACE_END
  1495. /**
  1496.   * End file RegxParser.cpp
  1497.   */