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

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

xml/soap/webservice

开发平台：

C/C++

RegxParser.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) 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.10  2001/11/20 20:48:10  knoaman
  60.  * Fix for invalid repeating quantifier check.
  61.  *
  62.  * Revision 1.9  2001/11/16 15:56:37  knoaman
  63.  * Add check for invalid repeating quantifier.
  64.  *
  65.  * Revision 1.8  2001/09/20 13:11:42  knoaman
  66.  * Regx  + misc. fixes
  67.  *
  68.  * Revision 1.7  2001/08/31 16:53:41  knoaman
  69.  * Misc. fixes.
  70.  *
  71.  * Revision 1.6  2001/07/26 12:46:48  knoaman
  72.  * Fix for bug 2815.
  73.  *
  74.  * Revision 1.5  2001/06/06 13:49:27  jberry
  75.  * Fix two improper NULL tests
  76.  *
  77.  * Revision 1.4  2001/05/11 21:51:01  knoaman
  78.  * Schema updates and fixes.
  79.  *
  80.  * Revision 1.3  2001/05/11 13:26:48  tng
  81.  * Copyright update.
  82.  *
  83.  * Revision 1.2  2001/05/03 18:17:45  knoaman
  84.  * Some design changes:
  85.  * o Changed the TokenFactory from a single static instance, to a
  86.  *    normal class. Each RegularExpression object will have its own
  87.  *    instance of TokenFactory, and that instance will be passed to
  88.  *    other classes that need to use a TokenFactory to create Token
  89.  *    objects (with the exception of RangeTokenMap).
  90.  * o Added a new class RangeTokenMap to map a the different ranges
  91.  *    in a given category to a specific RangeFactory object. In the old
  92.  *    design RangeFactory had dual functionality (act as a Map, and as
  93.  *    a factory for creating RangeToken(s)). The RangeTokenMap will
  94.  *    have its own copy of the TokenFactory. There will be only one
  95.  *    instance of the RangeTokenMap class, and that instance will be
  96.  *    lazily deleted when XPlatformUtils::Terminate is called.
  97.  *
  98.  * Revision 1.1  2001/03/02 19:22:54  knoaman
  99.  * Schema: Regular expression handling part I
  100.  *
  101.  */
  103. // ---------------------------------------------------------------------------
  104. //  Includes
  105. // ---------------------------------------------------------------------------
  106. #include <util/regx/RegxParser.hpp>
  107. #include <util/PlatformUtils.hpp>
  108. #include <util/XMLString.hpp>
  109. #include <util/regx/RegularExpression.hpp>
  110. #include <util/regx/RegxUtil.hpp>
  111. #include <util/regx/RegxDefs.hpp>
  112. #include <util/regx/TokenInc.hpp>
  113. #include <framework/XMLErrorCodes.hpp>
  114. #include <util/ParseException.hpp>
  116. // ---------------------------------------------------------------------------
  117. //  Static member data initialization
  118. // ---------------------------------------------------------------------------
  119. const unsigned short RegxParser::S_NORMAL = 0;
  120. const unsigned short RegxParser::S_INBRACKETS = 1;
  121. const unsigned short RegxParser::S_INXBRACKETS = 2;
  123. // ---------------------------------------------------------------------------
  124. //  RegxParser::ReferencePostion: Constructors and Destructor
  125. // ---------------------------------------------------------------------------
  126. RegxParser::ReferencePosition::ReferencePosition(const int refNo,
  127.  const int position)
  128. :fReferenceNo(refNo)
  129. , fPosition(position)
  130. {
  132. }
  134. // ---------------------------------------------------------------------------
  135. //  RegxParser: Constructors and Destructors
  136. // ---------------------------------------------------------------------------
  137. RegxParser::RegxParser()
  138.     :fHasBackReferences(false),
  139.      fOptions(0),
  140.      fOffset(0),
  141.      fNoGroups(1),
  142.      fParseContext(S_NORMAL),
  143.      fStringLen(0),
  144.      fState(0),
  145.      fCharData(0),
  146.      fString(0),
  147.      fReferences(0),
  148.      fTokenFactory(0)
  149. {
  150. }
  152. RegxParser::~RegxParser() {
  154. delete [] fString;
  155. delete fReferences;
  156. }
  158. // ---------------------------------------------------------------------------
  159. //  RegxParser: Parsing methods
  160. // ---------------------------------------------------------------------------
  161. Token* RegxParser::parse(const XMLCh* const regxStr, const int options) {
  163.     // if TokenFactory is not set do nothing.
  164.     // REVISIT - should we throw an exception
  165.     if (fTokenFactory == 0) {
  166.         return 0;
  167.     }
  169. XMLMutexLock lockInit(&fMutex);
  171. fOptions = options;
  172. fOffset = 0;
  173. fNoGroups = 1;
  174. fHasBackReferences = false;
  175. setParseContext(S_NORMAL);
  176. delete [] fString;
  177. fString = XMLString::replicate(regxStr);
  179. if (isSet(RegularExpression::EXTENDED_COMMENT)) {
  181.         delete [] fString;
  182. fString = RegxUtil::stripExtendedComment(regxStr);
  183.     }
  185.     fStringLen = XMLString::stringLen(fString);
  186.     processNext();
  188.     Token* retTok = parseRegx();
  190. if (fOffset != fStringLen) {
  191.         ThrowXML(ParseException,XMLExcepts::Parser_Parse1);
  192.     }
  194.     if (fReferences != 0) {
  196. unsigned int refSize = fReferences->size();
  197.         for (unsigned int i = 0; i < refSize; i++) {
  199. if (fNoGroups <= fReferences->elementAt(i)->fReferenceNo) {
  200.                 ThrowXML(ParseException,XMLExcepts::Parser_Parse2);
  201.             }
  202.         }
  204. fReferences->removeAllElements();
  205.     }
  207.     return retTok;
  208. }
  211. void RegxParser::processNext() {
  213.     if (fOffset >= fStringLen) {
  215.         fCharData = -1;
  216.         fState = T_EOF;
  217.         return;
  218. }
  220.     unsigned short nextState;
  221. XMLCh ch = fString[fOffset++];
  222. fCharData = ch;
  224.     if (fParseContext == S_INBRACKETS) {
  226. switch (ch) {
  227.         case chBackSlash:
  228.             nextState = T_BACKSOLIDUS;
  230. if (fOffset >= fStringLen) {
  231. ThrowXML(ParseException,XMLExcepts::Parser_Next1);
  232. }
  234. fCharData = fString[fOffset++];
  235. break;
  236. case chDash:
  237.             if (isSet(RegularExpression::XMLSCHEMA_MODE)
  238.                 && fOffset < fStringLen && fString[fOffset] == chOpenSquare) {
  240.                 fOffset++;
  241.                 nextState = T_XMLSCHEMA_CC_SUBTRACTION;
  242.             }
  243.             else {
  244.                 nextState = T_CHAR;
  245.             }
  246.             break;
  247.         case chOpenSquare:
  248.             if (!isSet(RegularExpression::XMLSCHEMA_MODE)
  249.                 && fOffset < fStringLen && fString[fOffset] == chColon) {
  251.                 fOffset++;
  252.                 nextState = T_POSIX_CHARCLASS_START;
  253.                 break;
  254. } // Through down
  255.         default:
  256.             if (RegxUtil::isHighSurrogate(ch) && fOffset < fStringLen) {
  258.                 XMLCh lowCh = fString[fOffset];
  259.                 if (RegxUtil::isLowSurrogate(lowCh)) {
  260.                     fCharData = RegxUtil::composeFromSurrogate(ch, lowCh);
  261. fOffset++;
  262.                 }
  263. else {
  264.                     throw XMLErrs::Expected2ndSurrogateChar;
  265.                 }
  266.             }
  268. nextState = T_CHAR;
  269.         }
  271.         fState = nextState;
  272.         return;
  273.     }
  275.     switch (ch) {
  277.     case chPipe:
  278.         nextState = T_OR;
  279.         break;
  280.     case chAsterisk:
  281.         nextState = T_STAR;
  282.         break;
  283.     case chPlus:
  284.         nextState = T_PLUS;
  285.         break;
  286.     case chQuestion:
  287. nextState = T_QUESTION;
  288. break;
  289.     case chCloseParen:
  290.         nextState = T_RPAREN;
  291.         break;
  292.     case chPeriod:
  293. nextState = T_DOT;
  294. break;
  295.     case chOpenSquare:
  296.         nextState = T_LBRACKET;
  297.         break;
  298.     case chCaret:
  299.         nextState = T_CARET;
  300.         break;
  301.     case chDollarSign:
  302. nextState = T_DOLLAR;
  303. break;
  304. case chOpenParen:
  305.         {
  306.     nextState = T_LPAREN;
  307.             if (fOffset >= fStringLen)
  308.                 break;
  310. if (fString[fOffset] != chQuestion)
  311.                 break;
  313.             if (++fOffset >= fStringLen)
  314.                 ThrowXML(ParseException,XMLExcepts::Parser_Next2);
  316.             ch = fString[fOffset++];
  318.             switch (ch) {
  319.             case chColon:
  320.                 nextState = T_LPAREN2;
  321.                 break;
  322. case chEqual:
  323.                 nextState = T_LOOKAHEAD;
  324.                 break;
  325.             case chBang:
  326.                 nextState = T_NEGATIVELOOKAHEAD;
  327.                 break;
  328.             case chOpenSquare:
  329.                 nextState = T_SET_OPERATIONS;
  330.                 break;
  331.             case chCloseAngle:
  332.                 nextState = T_INDEPENDENT;
  333. break;
  334.             case chOpenAngle:
  335. if (fOffset >= fStringLen)
  336. ThrowXML(ParseException,XMLExcepts::Parser_Next2);
  338. ch = fString[fOffset++];
  340. if (ch == chEqual) {
  341. nextState = T_LOOKBEHIND;
  342. }
  343. else if (ch == chBang) {
  344. nextState = T_NEGATIVELOOKBEHIND;
  345. }
  346. else {
  347. ThrowXML(ParseException,XMLExcepts::Parser_Next3);
  348. }
  349. break;
  350.             case chPound:
  351. while (fOffset < fStringLen) {
  353. ch = fString[fOffset++];
  354. if (ch == chCloseParen)
  355. break;
  356. }
  358. if (ch != chCloseParen)
  359. ThrowXML(ParseException,XMLExcepts::Parser_Next4);
  361. nextState = T_COMMENT;
  362. break;
  363.             default:
  364. if (ch == chDash || chLatin_a <= ch && ch <= chLatin_z
  365.                     || chLatin_A <= ch && ch <= chLatin_Z) { // Options
  367.                     fOffset--;
  368.                     nextState = T_MODIFIERS;
  369.                     break;
  370.                 }
  371.                 else if (ch == chOpenParen) {
  372.                     nextState = T_CONDITION;
  373.                     break;
  374.                 }
  375.                 ThrowXML(ParseException,XMLExcepts::Parser_Next2);
  376.             }
  377.         }
  378. break;
  379. case chBackSlash:
  380.         nextState = T_BACKSOLIDUS;
  381.         if (fOffset >= fStringLen) {
  382. ThrowXML(ParseException,XMLExcepts::Parser_Next1);
  383.         }
  385.         fCharData = fString[fOffset++];
  386.         break;
  387. default:
  388. nextState = T_CHAR;
  389. if (RegxUtil::isHighSurrogate(ch) && fOffset < fStringLen) {
  391.                 XMLCh lowCh = fString[fOffset];
  392.                 if (RegxUtil::isLowSurrogate(lowCh)) {
  393.                     fCharData = RegxUtil::composeFromSurrogate(ch, lowCh);
  394. fOffset++;
  395.                 }
  396. else {
  397.                     throw XMLErrs::Expected2ndSurrogateChar;
  398.                 }
  399.             }
  400. }
  402. fState = nextState;
  403. }
  406. Token* RegxParser::parseRegx() {
  408.     Token* tok = parseTerm();
  409.     Token* parentTok = 0;
  411.     while (fState == T_OR) {
  413.         processNext();
  414.         if (parentTok == 0) {
  416.             parentTok = fTokenFactory->createUnion();
  417.     parentTok->addChild(tok, fTokenFactory);
  418.             tok = parentTok;
  419.         }
  421.         tok->addChild(parseTerm(), fTokenFactory);
  422.     }
  424.     return tok;
  425. }
  428. Token* RegxParser::parseTerm() {
  430.     unsigned short state = fState;
  432.     if (state == T_OR || state == T_RPAREN || state == T_EOF) {
  433.         return fTokenFactory->createToken(Token::EMPTY);
  434.     }
  435.     else {
  437. Token* tok = parseFactor();
  438. Token* concatTok = 0;
  440. while ((state = fState) != T_OR && state != T_RPAREN && state != T_EOF)
  441.         {
  442.             if (concatTok == 0) {
  444.                 concatTok = fTokenFactory->createUnion(true);
  445.                 concatTok->addChild(tok, fTokenFactory);
  446.                 tok = concatTok;
  447.             }
  448.             concatTok->addChild(parseFactor(), fTokenFactory);
  449.         }
  451.         return tok;
  452.     }
  453. }
  456. Token* RegxParser::processCaret() {
  458.     processNext();
  459. return fTokenFactory->getLineBegin();
  460. }
  463. Token* RegxParser::processDollar() {
  465.     processNext();
  466.     return fTokenFactory->getLineEnd();
  467. }
  470. Token* RegxParser::processLook(const unsigned short tokType) {
  472.     processNext();
  474. Token* tok = fTokenFactory->createLook(tokType, parseRegx());
  476.     if (fState != T_RPAREN) {
  477.         ThrowXML(ParseException,XMLExcepts::Parser_Factor1);
  478.     }
  480.     processNext();
  482.     return tok;
  483. }
  486. Token* RegxParser::processBacksolidus_A() {
  488.     processNext();
  489. return fTokenFactory->getStringBegin();
  490. }
  493. Token* RegxParser::processBacksolidus_Z() {
  495.     processNext();
  496.     return fTokenFactory->getStringEnd2();
  497. }
  500. Token* RegxParser::processBacksolidus_z() {
  502.     processNext();
  503.     return fTokenFactory->getStringEnd();
  504. }
  507. Token* RegxParser::processBacksolidus_b() {
  509.     processNext();
  510.     return fTokenFactory->getWordEdge();
  511. }
  514. Token* RegxParser::processBacksolidus_B() {
  516.     processNext();
  517.     return fTokenFactory->getNotWordEdge();
  518. }
  521. Token* RegxParser::processBacksolidus_lt() {
  523.     processNext();
  524.     return fTokenFactory->getWordBegin();
  525. }
  528. Token* RegxParser::processBacksolidus_gt() {
  530.     processNext();
  531.     return fTokenFactory->getWordEnd();
  532. }
  535. Token* RegxParser::processStar(Token* const tok) {
  537.     processNext();
  539.     if (fState == T_QUESTION) {
  541.         processNext();
  542.         return fTokenFactory->createClosure(tok, true);
  543.     }
  545.     return fTokenFactory->createClosure(tok);
  546. }
  549. Token* RegxParser::processPlus(Token* const tok) {
  551.     processNext();
  553.     if (fState == T_QUESTION) {
  555. processNext();
  556. return fTokenFactory->createConcat(tok,
  557.                fTokenFactory->createClosure(tok,true));
  558.     }
  560.     return fTokenFactory->createConcat(tok,
  561.                         fTokenFactory->createClosure(tok));
  562. }
  565. Token* RegxParser::processQuestion(Token* const tok) {
  567.     processNext();
  569.     Token* parentTok = fTokenFactory->createUnion();
  571.     if (fState == T_QUESTION) {
  573.         processNext();
  574.         parentTok->addChild(fTokenFactory->createToken(Token::EMPTY), fTokenFactory);
  575.         parentTok->addChild(tok, fTokenFactory);
  576.     }
  577.     else {
  579.         parentTok->addChild(tok, fTokenFactory);
  580.         parentTok->addChild(fTokenFactory->createToken(Token::EMPTY), fTokenFactory);
  581.     }
  583.     return parentTok;
  584. }
  587. Token* RegxParser::processParen() {
  589.     processNext();
  590.     int num = fNoGroups++;
  591.     Token* tok = fTokenFactory->createParenthesis(parseRegx(),num);
  593.     if (fState != T_RPAREN)
  594.         ThrowXML(ParseException,XMLExcepts::Parser_Factor1);
  596.     processNext();
  597.     return tok;
  598. }
  601. Token* RegxParser::processParen2() {
  603.     processNext();
  604.     Token* tok = fTokenFactory->createParenthesis(parseRegx(), 0);
  606.     if (fState != T_RPAREN)
  607.         ThrowXML(ParseException,XMLExcepts::Parser_Factor1);
  609.     processNext();
  610.     return tok;
  611. }
  614. Token* RegxParser::processCondition() {
  616.     if (fOffset + 1 >= fStringLen)
  617. ThrowXML(ParseException,XMLExcepts::Parser_Factor4);
  619.     int refNo = -1;
  620. Token* conditionTok = 0;
  621. XMLInt32 ch = fString[fOffset];
  623.     if (chDigit_1 <= ch && ch <= chDigit_9) {
  625.         refNo = ch - chDigit_0;
  626.         fHasBackReferences =  true;
  628.         if (fReferences == 0) {
  629.             this->fReferences = new RefVectorOf<ReferencePosition>(8, true);
  630.         }
  632.         fReferences->addElement(new ReferencePosition(refNo, fOffset));
  633.         fOffset++;
  635.         if (fString[fOffset] != chCloseParen)
  636.             ThrowXML(ParseException,XMLExcepts::Parser_Factor1);
  638.         fOffset++;
  639.     }
  640.     else {
  642.         if (ch == chQuestion) {
  643.             fOffset--;
  644.         }
  646.         processNext();
  647.         conditionTok = parseFactor();
  648.         switch(conditionTok->getTokenType()) {
  649.         case Token::LOOKAHEAD:
  650.         case Token::NEGATIVELOOKAHEAD:
  651.         case Token::LOOKBEHIND:
  652.         case Token::NEGATIVELOOKBEHIND:
  653.             break;
  654.         case Token::ANCHOR:
  655.             if (fState != T_RPAREN)
  656. ThrowXML(ParseException,XMLExcepts::Parser_Factor1);
  657. break;
  658.         default:
  659. ThrowXML(ParseException,XMLExcepts::Parser_Factor5);
  660.         }
  661.     }
  663.     processNext();
  664.     Token* yesPattern = parseRegx();
  665.     Token* noPattern = 0;
  667.     if (yesPattern->getTokenType() == Token::UNION) {
  669.         if (yesPattern->size() != 2)
  670.             ThrowXML(ParseException,XMLExcepts::Parser_Factor6);
  672.         noPattern = yesPattern->getChild(1);
  673.         yesPattern = yesPattern->getChild(0);
  674.     }
  676.     if (fState != T_RPAREN)
  677.         ThrowXML(ParseException,XMLExcepts::Parser_Factor1);
  679. processNext();
  680. return fTokenFactory->createCondition(refNo,conditionTok,
  681.                                              yesPattern,noPattern);
  682. }
  685. Token* RegxParser::processModifiers() {
  687.     // fOffset points to the next '?'.
  688. // modifiers ::= [imsw]* ('-' [imsw]*)? ':'
  689.     int add = 0;
  690.     int mask = 0;
  691.     XMLInt32 ch = -1;
  693.     while (fOffset < fStringLen) {
  695.         int v = RegularExpression::getOptionValue(fString[fOffset]);
  697.         ch = fString[fOffset];
  698.         if (v == 0)
  699.             break;
  701.         add |= v;
  702.         fOffset++;
  703.     } // end while
  705.     if (fOffset >= fStringLen)
  706.         ThrowXML(ParseException,XMLExcepts::Parser_Factor2);
  708.     if (ch == chDash) {
  710.         fOffset++;
  711.         while(fOffset < fStringLen) {
  712.             int v = RegularExpression::getOptionValue(fString[fOffset]);
  714.             ch = fString[fOffset];
  715.             if (v == 0)
  716.                 break;
  718.             mask |= v;
  719.             fOffset++;
  720.         }
  722.         if (fOffset >= fStringLen)
  723.             ThrowXML(ParseException,XMLExcepts::Parser_Factor2);
  724.     }
  726.     Token* tok = 0;
  728.     if (ch == chColon) {
  730.         fOffset++;
  731. processNext();
  732.         tok = fTokenFactory->createModifierGroup(parseRegx(),add,mask);
  734.         if (fState != T_RPAREN)
  735.             ThrowXML(ParseException,XMLExcepts::Parser_Factor1);
  737.         processNext();
  738.     }
  739.     else if (ch == chCloseParen) {
  741.         fOffset++;
  742.         processNext();
  743.         tok = fTokenFactory->createModifierGroup(parseRegx(),add,mask);
  744.     }
  745.     else {
  746.         ThrowXML(ParseException,XMLExcepts::Parser_Factor3);
  747. }
  749. return tok;
  750. }
  753. Token* RegxParser::processIndependent() {
  755.     processNext();
  757. Token* tok = fTokenFactory->createLook(Token::INDEPENDENT,
  758.                                               parseRegx());
  760. if (fState != T_RPAREN)
  761. ThrowXML(ParseException,XMLExcepts::Parser_Factor1);
  763.     processNext();
  764.     return tok;
  765. }
  768. Token* RegxParser::processBacksolidus_c() {
  770.     XMLCh ch; //Must be in 0x0040-0x005F
  772.     if (fOffset >= fStringLen
  773.         || ((ch = fString[fOffset++]) & 0xFFE0) != 0x0040)
  774.         ThrowXML(ParseException,XMLExcepts::Parser_Atom1);
  776.     processNext();
  777. return fTokenFactory->createChar(ch - 0x40);
  778. }
  781. Token* RegxParser::processBacksolidus_C() {
  783. // REVISIT - Do we throw an exception - we do not want to throw too
  784. // many exceptions
  785.     return 0;
  786. }
  788. Token* RegxParser::processBacksolidus_i() {
  790.     processNext();
  791. return fTokenFactory->createChar(chLatin_i);
  792. }
  795. Token* RegxParser::processBacksolidus_I() {
  797. //Ditto
  798.     return 0;
  799. }
  802. Token* RegxParser::processBacksolidus_g() {
  804.     processNext();
  805.     return fTokenFactory->getGraphemePattern();
  806. }
  809. Token* RegxParser::processBacksolidus_X() {
  811.     processNext();
  812.     return fTokenFactory->getCombiningCharacterSequence();
  813. }
  815. Token* RegxParser::processBackReference() {
  817.     int refNo = fCharData - chDigit_0;
  818.     Token* tok = fTokenFactory->createBackReference(refNo);
  820.     fHasBackReferences = true;
  821.     if (fReferences == 0) {
  822.         fReferences = new RefVectorOf<ReferencePosition>(8, true);
  823.     }
  825.     fReferences->addElement(new ReferencePosition(refNo, fOffset - 2));
  826.     processNext();
  827.     return tok;
  828. }
  831. Token* RegxParser::parseFactor() {
  833.     switch (fState) {
  835.     case T_CARET:
  836.         return processCaret();
  837.     case T_DOLLAR:
  838.         return processDollar();
  839.     case T_LOOKAHEAD:
  840.         return processLook(Token::LOOKAHEAD);
  841.     case T_NEGATIVELOOKAHEAD:
  842.         return processLook(Token::NEGATIVELOOKAHEAD);
  843.     case T_LOOKBEHIND:
  844.         return processLook(Token::LOOKBEHIND);
  845.     case T_NEGATIVELOOKBEHIND:
  846.         return processLook(Token::NEGATIVELOOKBEHIND);
  847.     case T_COMMENT:
  848.         processNext();
  849.         return fTokenFactory->createToken(Token::EMPTY);
  850.     case T_BACKSOLIDUS:
  851.         switch(fCharData) {
  852.         case chLatin_A:
  853.             return processBacksolidus_A();
  854.         case chLatin_Z:
  855.             return processBacksolidus_Z();
  856.         case chLatin_z:
  857.             return processBacksolidus_z();
  858.         case chLatin_b:
  859.             return processBacksolidus_B();
  860.         case chLatin_B:
  861.             return processBacksolidus_B();
  862.         case chOpenAngle:
  863.             return processBacksolidus_lt();
  864.         case chCloseAngle:
  865.             return processBacksolidus_gt();
  866. }
  867.     }
  869. Token* tok = parseAtom();
  871. switch(fState) {
  873.     case T_STAR:
  874.         return processStar(tok);
  875.     case T_PLUS:
  876.         return processPlus(tok);
  877.     case T_QUESTION:
  878.         return processQuestion(tok);
  879.     case T_CHAR:
  880. if (fCharData == chOpenCurly) {
  882.             int offset = fOffset;
  883.             int min = 0;
  884.             int max = -1;
  885.             bool minExist = false;
  887.             if (offset >= fStringLen)
  888.                 break;
  890.             XMLInt32 ch = fString[offset++];
  892.             if (ch != chComma && (ch < chDigit_0 || ch > chDigit_9))
  893.                 ThrowXML1(ParseException, XMLExcepts::Regex_InvalidQuantifier, fString);
  895.             if (ch != chComma) {
  896.                 minExist = true;
  897.                 min = ch - chDigit_0;
  898.                 while (offset < fStringLen
  899.                        && (ch = fString[offset++]) >= chDigit_0
  900.                        && ch <= chDigit_9) {
  902.                     min = min*10 + ch - chDigit_0;
  903.                     ch = -1;
  904.                 }
  905.             }
  907.             max = min;
  909.             if (ch != chCloseCurly && ch != chComma)  {
  910.                 ThrowXML1(ParseException, XMLExcepts::Regex_InvalidQuantifier, fString);
  911.             }
  913.             if (ch == chComma) {
  915.                 if (offset >= fStringLen)
  916.                     break;
  918.                 if (((ch = fString[offset++]) < chDigit_0 || ch > chDigit_9)
  919.                     && ch != chCloseCurly)
  920.                     ThrowXML1(ParseException, XMLExcepts::Regex_InvalidQuantifier, fString);
  922.                 if (ch == chCloseCurly) {
  923.                     if (minExist)
  924.                         max = -1;
  925.                     else
  926.                         ThrowXML1(ParseException, XMLExcepts::Regex_InvalidQuantifier, fString);
  927.                 }
  928.                 else {
  929.                     max = ch - chDigit_0;
  930.                     while (offset < fStringLen
  931.                            && (ch = fString[offset++]) >= chDigit_0
  932.                            && ch <= chDigit_9) {
  934.                         max = max*10 + ch - chDigit_0;
  935.                         ch = -1;
  936.                     }
  938.                     if (ch != chCloseCurly)  {
  939.                         ThrowXML1(ParseException, XMLExcepts::Regex_InvalidQuantifier, fString);
  940.                     }
  941.                 }
  942.             } // end if ch = chComma
  944.             if (checkQuestion(offset)) {
  946.                 tok = fTokenFactory->createClosure(tok, true);
  947.                 fOffset = offset + 1;
  948.             }
  949.             else {
  951.                 tok = fTokenFactory->createClosure(tok);
  952.                 fOffset = offset;
  953.             }
  955.             tok->setMin(min);
  956.             tok->setMax(max);
  957.             processNext();
  958. }
  959. }
  961. return tok;
  962. }
  965. Token* RegxParser::parseAtom() {
  967.     Token* tok = 0;
  969.     switch(fState) {
  971.     case T_LPAREN:
  972.         return processParen();
  973.     case T_LPAREN2:
  974.         return processParen2();
  975.     case T_CONDITION:
  976.         return processCondition();
  977.     case T_MODIFIERS:
  978.         return processModifiers();
  979.     case T_INDEPENDENT:
  980.         return processIndependent();
  981.     case T_DOT:
  982.         processNext();
  983.         tok = fTokenFactory->getDot();
  984.         break;
  985.     case T_LBRACKET:
  986.         return parseCharacterClass(true);
  987.     case T_SET_OPERATIONS:
  988.         return parseSetOperations();
  989.     case T_BACKSOLIDUS:
  990. switch(fCharData) {
  992.         case chLatin_d:
  993.         case chLatin_D:
  994.         case chLatin_w:
  995.         case chLatin_W:
  996.         case chLatin_s:
  997.         case chLatin_S:
  998.             tok = getTokenForShorthand(fCharData);
  999.             processNext();
  1000.             return tok;
  1001.         case chLatin_e:
  1002.         case chLatin_f:
  1003.         case chLatin_n:
  1004.         case chLatin_r:
  1005.         case chLatin_t:
  1006.         case chLatin_u:
  1007.         case chLatin_v:
  1008.         case chLatin_x:
  1009. {
  1010.                 XMLInt32 ch = decodeEscaped();
  1011.                 if (ch < 0x10000) {
  1012.                     tok = fTokenFactory->createChar(ch);
  1013.                 }
  1014.                 else {
  1016.                     XMLCh* surrogateStr = RegxUtil::decomposeToSurrogates(ch);
  1017.     ArrayJanitor<XMLCh> janSurrogate(surrogateStr);
  1018.     tok = fTokenFactory->createString(surrogateStr);
  1019.                 }
  1020.             }
  1021. break;
  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.             tok = fTokenFactory->createChar(fCharData);
  1057. } // end switch
  1059.         processNext();
  1060.         break;
  1061.     case T_CHAR:
  1062.         tok = fTokenFactory->createChar(fCharData);
  1063.         processNext();
  1064.         break;
  1065.     default:
  1066.         ThrowXML(ParseException,XMLExcepts::Parser_Atom4);
  1067.     } //end switch
  1069.     return tok;
  1070. }
  1073. RangeToken* RegxParser::processBacksolidus_pP(const XMLInt32 ch) {
  1075.     bool positive = (ch == chLatin_p);
  1077.     processNext();
  1078. if (fState != T_CHAR)
  1079. ThrowXML(ParseException,XMLExcepts::Parser_Atom2);
  1081.     RangeToken* tok = 0;
  1083. switch(fCharData) {
  1085.     case chLatin_L:
  1086. tok = fTokenFactory->getRange(fgUniLetter, !positive);
  1087. break;
  1088.     case chLatin_M:
  1089. tok = fTokenFactory->getRange(fgUniMark, !positive);
  1090. break;
  1091.     case chLatin_N:
  1092. tok = fTokenFactory->getRange(fgUniNumber, !positive);
  1093. break;
  1094.     case chLatin_Z:
  1095. tok = fTokenFactory->getRange(fgUniSeparator, !positive);
  1096. break;
  1097.     case chLatin_C:
  1098. tok = fTokenFactory->getRange(fgUniControl, !positive);
  1099. break;
  1100.     case chLatin_P:
  1101. tok = fTokenFactory->getRange(fgUniPunctuation, !positive);
  1102. break;
  1103.     case chLatin_S:
  1104. tok = fTokenFactory->getRange(fgUniSymbol, !positive);
  1105. break;
  1106.     case chOpenCurly:
  1107. {
  1108. int nameStart = fOffset;
  1109. int nameEnd = XMLString::indexOf(fString,chCloseCurly,nameStart);
  1111. if (nameEnd < 0)
  1112. ThrowXML(ParseException,XMLExcepts::Parser_Atom3);
  1114. fOffset = nameEnd + 1;
  1115. XMLCh* rangeName = new XMLCh[(nameEnd - nameStart) + 1];
  1116. ArrayJanitor<XMLCh> janRangeName(rangeName);
  1117. XMLString::subString(rangeName, fString, nameStart, nameEnd);
  1118. tok = fTokenFactory->getRange(rangeName, !positive);
  1119. }
  1120. break;
  1121. default:
  1122. ThrowXML(ParseException,XMLExcepts::Parser_Atom2);
  1123. }
  1125.     return tok;
  1126. }
  1129. XMLInt32 RegxParser::processCInCharacterClass(RangeToken* const tok,
  1130.                                               const XMLInt32 ch) {
  1132. return decodeEscaped();
  1133. }
  1136. RangeToken* RegxParser::parseCharacterClass(const bool useNRange) {
  1138.     setParseContext(S_INBRACKETS);
  1139. processNext();
  1141.     RangeToken* base = 0;
  1142.     RangeToken* tok = 0;
  1143.     bool nRange = false;
  1145. if (fState == T_CHAR && fCharData == chCaret) {
  1147.         nRange = true;
  1148.         processNext();
  1150. if (useNRange) {
  1151.             tok = fTokenFactory->createRange(true);
  1152.         }
  1153.         else {
  1155. base = fTokenFactory->createRange();
  1156.             base->addRange(0, Token::UTF16_MAX);
  1157.             tok = fTokenFactory->createRange();
  1158.         }
  1159.     }
  1160.     else {
  1161.         tok = fTokenFactory->createRange();
  1162.     }
  1164.     bool firstLoop = true;
  1166.     while (fState != T_EOF) {
  1168.         if (fState == T_CHAR && fCharData == chCloseSquare && !firstLoop)
  1169. break;
  1171.         bool end = false;
  1172.         XMLInt32 ch = fCharData;
  1174.         firstLoop = false;
  1175.         if (fState == T_BACKSOLIDUS) {
  1177.             switch(ch) {
  1178.             case chLatin_d:
  1179.             case chLatin_D:
  1180.             case chLatin_w:
  1181.             case chLatin_W:
  1182.             case chLatin_s:
  1183.             case chLatin_S:
  1184.                 tok->mergeRanges(getTokenForShorthand(ch));
  1185.                 end = true;
  1186. break;
  1187.             case chLatin_i:
  1188.             case chLatin_I:
  1189.             case chLatin_c:
  1190.             case chLatin_C:
  1191.                 ch = processCInCharacterClass(tok, ch);
  1192. if (ch < 0){
  1193.     end = true;
  1194.                 }
  1195.                 break;
  1196.             case chLatin_p:
  1197.             case chLatin_P:
  1198. {
  1199. int pStart = fOffset;
  1200. RangeToken* tok2 = processBacksolidus_pP(ch);
  1202. if (tok2 == 0) {
  1203. ThrowXML(ParseException,XMLExcepts::Parser_Atom5);
  1204. }
  1206. tok->mergeRanges(tok2);
  1207. end = true;
  1208. }
  1209.                 break;
  1210.             default:
  1211.                 ch = decodeEscaped();
  1212. }
  1213.         } // end if T_BACKSOLIDUS
  1214.         else if (fState == T_POSIX_CHARCLASS_START) {
  1216.             int nameEnd = XMLString::indexOf(fString, chColon, fOffset);
  1218.             if (nameEnd < 0) {
  1219. ThrowXML(ParseException,XMLExcepts::Parser_CC1);
  1220. }
  1222.             bool positive = true;
  1224.             if (fString[fOffset] == chCaret) {
  1226.                 fOffset++;
  1227.                 positive = false;
  1228.             }
  1230. XMLCh* name = new XMLCh[(nameEnd - fOffset) + 1];
  1231. ArrayJanitor<XMLCh> janName(name);
  1233. XMLString::subString(name, fString, fOffset, nameEnd);
  1234.             RangeToken* rangeTok = fTokenFactory->getRange(name, !positive);
  1236.             if (rangeTok == 0) {
  1237. ThrowXML(ParseException,XMLExcepts::Parser_CC3);
  1238.             }
  1240. tok->mergeRanges(rangeTok);
  1241. end = true;
  1243. if (nameEnd+1 >= fStringLen || fString[nameEnd+1] != chCloseSquare) {
  1244. ThrowXML(ParseException,XMLExcepts::Parser_CC1);
  1245. }
  1247. fOffset = nameEnd + 2;
  1248.         }
  1250.         processNext();
  1251. if (!end) {
  1253.             if (fState != T_CHAR || fCharData != chDash) {
  1254.                 tok->addRange(ch, ch);
  1255.             }
  1256.             else {
  1258.                 processNext();
  1260.                 if (fState == T_EOF)
  1261.                     ThrowXML(ParseException,XMLExcepts::Parser_CC2);
  1263.                 if (fState == T_CHAR && fCharData == chCloseSquare) {
  1265.                     tok->addRange(ch, ch);
  1266.                     tok->addRange(chDash, chDash);
  1267.                 }
  1268.                 else {
  1270.                     XMLInt32 rangeEnd = fCharData;
  1272.                     if (fState == T_BACKSOLIDUS) {
  1273.                         rangeEnd = decodeEscaped();
  1274.                     }
  1276.                     processNext();
  1277.                     tok->addRange(ch, rangeEnd);
  1278.                 }
  1279.             }
  1280.         }
  1282.         if (isSet(RegularExpression::SPECIAL_COMMA)
  1283.             && fState == T_CHAR && fCharData == chComma) {
  1284.             processNext();
  1285.         }
  1286.     } // end while fState
  1288. if (fState == T_EOF) {
  1289.         ThrowXML(ParseException,XMLExcepts::Parser_CC2);
  1290. }
  1292.     if (!useNRange && nRange) {
  1294.         base->subtractRanges(tok);
  1295.         tok = base;
  1296.     }
  1298.     tok->sortRanges();
  1299.     tok->compactRanges();
  1300.     setParseContext(S_NORMAL);
  1301.     processNext();
  1303.     return tok;
  1304. }
  1307. RangeToken* RegxParser::parseSetOperations() {
  1309.     RangeToken* tok = parseCharacterClass(false);
  1311.     while (fState != T_RPAREN) {
  1313. if (fState == T_CHAR
  1314.             && (fCharData == chDash || fCharData == chAmpersand)
  1315.             || fState == T_PLUS) {
  1317.             processNext();
  1318.             if (fState != T_LBRACKET)
  1319.                 ThrowXML(ParseException,XMLExcepts::Parser_Ope1);
  1321.             RangeToken* tok2 = parseCharacterClass(false);
  1323.             if (fState == T_PLUS) {
  1324.                 tok->mergeRanges(tok2);
  1325.             }
  1326.             else if (fCharData == chDash) {
  1327.                 tok->subtractRanges(tok2);
  1328.             }
  1329.             else if (fCharData == chAmpersand) {
  1330.                 tok->intersectRanges(tok2);
  1331.             }
  1332.             else {
  1333.                 throw 0; // ThrowXML(RuntimeException, "ASSERT")
  1334.             }
  1335.         }
  1336.         else {
  1337. ThrowXML(ParseException,XMLExcepts::Parser_Ope2);
  1338. }
  1339.     }
  1341.     processNext();
  1342.     return tok;
  1343. }
  1345. Token* RegxParser::getTokenForShorthand(const XMLInt32 ch) {
  1347.     Token* tok = 0;
  1348.     bool useUnicode = isSet(RegularExpression::USE_UNICODE_CATEGORY);
  1350. switch (ch) {
  1351. case chLatin_d:
  1352. tok = useUnicode ? fTokenFactory->getRange(fgUniDecimalDigit)
  1353.  : fTokenFactory->getRange(fgASCIIDigit);
  1354. break;
  1355. case chLatin_D:
  1356. tok = useUnicode ? fTokenFactory->getRange(fgUniDecimalDigit, true)
  1357.  : fTokenFactory->getRange(fgASCIIDigit, true);
  1358. break;
  1359. case chLatin_w:
  1360. tok = useUnicode ? fTokenFactory->getRange(fgUniIsWord)
  1361.  : fTokenFactory->getRange(fgASCIIWord);
  1362. break;
  1363. case chLatin_W:
  1364. tok = useUnicode ? fTokenFactory->getRange(fgUniIsWord, true)
  1365.  : fTokenFactory->getRange(fgASCIIWord, true);
  1366. break;
  1367. case chLatin_s:
  1368. tok = useUnicode ? fTokenFactory->getRange(fgUniIsSpace)
  1369.  : fTokenFactory->getRange(fgASCIISpace);
  1370. break;
  1371. case chLatin_S:
  1372. tok = useUnicode ? fTokenFactory->getRange(fgUniIsSpace, true)
  1373.  : fTokenFactory->getRange(fgASCIISpace, true);
  1374. // default:
  1375. // ThrowXML(RuntimeException, "Invalid shorthand {0}", chAsString)
  1376. }
  1378.     return tok;
  1379. }
  1382. XMLInt32 RegxParser::decodeEscaped() {
  1384.     if (fState != T_BACKSOLIDUS)
  1385. ThrowXML(ParseException,XMLExcepts::Parser_Next1);
  1387.     XMLInt32 ch = fCharData;
  1389. switch (ch) {
  1390. case chLatin_e:
  1391. ch = 0x1B; // Escape
  1392. break;
  1393. case chLatin_f:
  1394. ch = chFF;
  1395. break;
  1396. case chLatin_n:
  1397. ch = chLF;
  1398. break;
  1399. case chLatin_r:
  1400. ch = chCR;
  1401. break;
  1402. case chLatin_t:
  1403. ch = chHTab;
  1404. break;
  1405. case chLatin_x:
  1406. {
  1407. processNext();
  1408. if (fState != T_CHAR) {
  1409. ThrowXML(ParseException,XMLExcepts::Parser_Descape1);
  1410. }
  1411. if (fCharData == chOpenCurly) {
  1413. int v1 = 0;
  1414. XMLInt32 uv = 0;
  1416. do {
  1417. processNext();
  1418. if (fState != T_CHAR)
  1419. ThrowXML(ParseException,XMLExcepts::Parser_Descape1);
  1421. if ((v1 = hexChar(fCharData)) < 0)
  1422. break;
  1424. uv = uv*16 + v1;
  1425. } while (true);
  1427. if (fCharData != chCloseCurly)
  1428. ThrowXML(ParseException,XMLExcepts::Parser_Descape3);
  1430. if (uv > Token::UTF16_MAX)
  1431. ThrowXML(ParseException,XMLExcepts::Parser_Descape4);
  1433. ch = uv;
  1434. }
  1435. else {
  1436. int v1 = 0;
  1437. if (fState != T_CHAR || (v1 = hexChar(fCharData)) < 0)
  1438. ThrowXML(ParseException,XMLExcepts::Parser_Descape1);
  1440. int uv = v1;
  1442. processNext();
  1443. if (fState != T_CHAR || (v1 = hexChar(fCharData)) < 0)
  1444. ThrowXML(ParseException,XMLExcepts::Parser_Descape1);
  1446. ch = uv*16 + v1;
  1447. }
  1448. }
  1449. break;
  1450. case chLatin_u:
  1451. {
  1452. int v1 = 0;
  1453. int uv = 0;
  1455. for (int i=0; i< 4; i++) {
  1457. processNext();
  1458. if (fState != T_CHAR || (v1 = hexChar(fCharData)) < 0)
  1459. ThrowXML(ParseException,XMLExcepts::Parser_Descape1);
  1461. uv = (i == 0) ? v1 : uv*16 + v1;
  1462. }
  1464. ch = uv;
  1465. }
  1466. break;
  1467. case chLatin_v:
  1468. {
  1469. int v1 = 0;
  1470. int uv = 0;
  1472. for (int i=0; i< 6; i++) {
  1474. processNext();
  1475. if (fState != T_CHAR || (v1 = hexChar(fCharData)) < 0)
  1476. ThrowXML(ParseException,XMLExcepts::Parser_Descape1);
  1478. uv = (i == 0) ? v1 : uv*16 + v1;
  1479. }
  1481. if (uv > Token::UTF16_MAX)
  1482. ThrowXML(ParseException,XMLExcepts::Parser_Descape1);
  1484. ch = uv;
  1485. }
  1486. break;
  1487. case chLatin_A:
  1488. case chLatin_Z:
  1489. case chLatin_z:
  1490. ThrowXML(ParseException,XMLExcepts::Parser_Descape5);
  1491. } // end switch
  1493.     return ch;
  1494. }
  1496. // ---------------------------------------------------------------------------
  1497. //  RegxParser: Helper Methods
  1498. // ---------------------------------------------------------------------------
  1499. bool RegxParser::checkQuestion(const int off) {
  1501.     return ((off < fStringLen) && fString[off] == chQuestion);
  1502. }
  1504. /**
  1505.   * End file RegxParser.cpp
  1506.   */