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

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

词法分析

开发平台：

Visual C++

ParserForXMLSchema.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: ParserForXMLSchema.cpp,v $
  59.  * Revision 1.6  2003/05/15 18:42:54  knoaman
  60.  * Partial implementation of the configurable memory manager.
  61.  *
  62.  * Revision 1.5  2003/03/18 19:38:28  knoaman
  63.  * Schema Errata E2-18 + misc. regex fixes.
  64.  *
  65.  * Revision 1.4  2003/01/13 19:02:23  knoaman
  66.  * [Bug 14390] C++ Indentifier collision with Python.
  67.  *
  68.  * Revision 1.3  2002/11/04 15:17:00  tng
  69.  * C++ Namespace Support.
  70.  *
  71.  * Revision 1.2  2002/03/18 19:29:53  knoaman
  72.  * Change constant names to eliminate possible conflict with user defined ones.
  73.  *
  74.  * Revision 1.1.1.1  2002/02/01 22:22:29  peiyongz
  75.  * sane_include
  76.  *
  77.  * Revision 1.6  2001/09/20 13:11:42  knoaman
  78.  * Regx  + misc. fixes
  79.  *
  80.  * Revision 1.5  2001/06/01 14:15:37  knoaman
  81.  * Add a return value to satisfy compilers that complain about
  82.  * no return value, although that code will not be executed.
  83.  *
  84.  * Revision 1.4  2001/05/11 21:50:56  knoaman
  85.  * Schema updates and fixes.
  86.  *
  87.  * Revision 1.3  2001/05/11 13:26:44  tng
  88.  * Copyright update.
  89.  *
  90.  * Revision 1.2  2001/05/03 18:17:30  knoaman
  91.  * Some design changes:
  92.  * o Changed the TokenFactory from a single static instance, to a
  93.  *    normal class. Each RegularExpression object will have its own
  94.  *    instance of TokenFactory, and that instance will be passed to
  95.  *    other classes that need to use a TokenFactory to create Token
  96.  *    objects (with the exception of RangeTokenMap).
  97.  * o Added a new class RangeTokenMap to map a the different ranges
  98.  *    in a given category to a specific RangeFactory object. In the old
  99.  *    design RangeFactory had dual functionality (act as a Map, and as
  100.  *    a factory for creating RangeToken(s)). The RangeTokenMap will
  101.  *    have its own copy of the TokenFactory. There will be only one
  102.  *    instance of the RangeTokenMap class, and that instance will be
  103.  *    lazily deleted when XPlatformUtils::Terminate is called.
  104.  *
  105.  * Revision 1.1  2001/03/02 19:26:43  knoaman
  106.  * Schema: Regular expression handling part II
  107.  *
  108.  */
  110. // ---------------------------------------------------------------------------
  111. //  Includes
  112. // ---------------------------------------------------------------------------
  113. #include <xercesc/util/regx/ParserForXMLSchema.hpp>
  114. #include <xercesc/util/regx/TokenFactory.hpp>
  115. #include <xercesc/util/regx/RangeToken.hpp>
  116. #include <xercesc/util/regx/TokenInc.hpp>
  117. #include <xercesc/util/regx/RegxDefs.hpp>
  118. #include <xercesc/util/ParseException.hpp>
  119. #include <xercesc/util/RuntimeException.hpp>
  120. #include <xercesc/util/PlatformUtils.hpp>
  122. XERCES_CPP_NAMESPACE_BEGIN
  124. // ---------------------------------------------------------------------------
  125. //  ParserForXMLSchema: Constructors and Destructors
  126. // ---------------------------------------------------------------------------
  127. ParserForXMLSchema::ParserForXMLSchema(MemoryManager* const manager)
  128.     : RegxParser(manager)
  129. {
  131. }
  133. ParserForXMLSchema::~ParserForXMLSchema() {
  135. }
  137. // ---------------------------------------------------------------------------
  138. //  ParserForXMLSchema: Parsing/Processing methods
  139. // ---------------------------------------------------------------------------
  140. Token* ParserForXMLSchema::processCaret() {
  142.     processNext();
  143.     return getTokenFactory()->createChar(chCaret);
  144. }
  146. Token* ParserForXMLSchema::processDollar() {
  148.     processNext();
  149.     return getTokenFactory()->createChar(chDollarSign);
  150. }
  152. Token* ParserForXMLSchema::processPlus(Token* const tok) {
  154.     processNext();
  155.     return getTokenFactory()->createConcat(tok,
  156.                                getTokenFactory()->createClosure(tok));
  157. }
  159. Token* ParserForXMLSchema::processStar(Token* const tok) {
  161.     processNext();
  162.     return getTokenFactory()->createClosure(tok);
  163. }
  165. Token* ParserForXMLSchema::processQuestion(Token* const tok) {
  167.     processNext();
  169.     TokenFactory* tokFactory = getTokenFactory();
  170.     Token* retTok = tokFactory->createUnion();
  171.     retTok->addChild(tok, tokFactory);
  172.     retTok->addChild(tokFactory->createToken(Token::T_EMPTY), tokFactory);
  173.     return retTok;
  174. }
  176. Token* ParserForXMLSchema::processParen() {
  178.     processNext();
  179.     Token* retTok = getTokenFactory()->createParenthesis(parseRegx(true), 0);
  181.     if (getState() != REGX_T_RPAREN) {
  182.         ThrowXML(ParseException, XMLExcepts::Parser_Factor1);
  183.     }
  185.     processNext();
  186.     return retTok;
  187. }
  189. RangeToken* ParserForXMLSchema::parseCharacterClass(const bool useNRange) {
  191.     setParseContext(S_INBRACKETS);
  192.     processNext();
  194.     RangeToken* base = 0;
  195.     RangeToken* tok = 0;
  196.     bool isNRange = false;
  198.     if (getState() == REGX_T_CHAR && getCharData() == chCaret) {
  200.         isNRange = true;
  201.         processNext();
  202.         base = getTokenFactory()->createRange();
  203.         base->addRange(0, Token::UTF16_MAX);
  204.         tok = getTokenFactory()->createRange();
  205.     }
  206.     else {
  207.         tok= getTokenFactory()->createRange();
  208.     }
  210.     int type;
  211.     bool firstLoop = true;
  213.     while ( (type = getState()) != REGX_T_EOF) {
  215.         // single range | from-to-range | subtraction
  216.         if (type == REGX_T_CHAR && getCharData() == chCloseSquare && !firstLoop) {
  218.             if (isNRange) {
  220.                 base->subtractRanges(tok);
  221.                 tok = base;
  222.             }
  223.             break;
  224.         }
  226.         XMLInt32 ch = getCharData();
  227.         bool     end = false;
  229.         if (type == REGX_T_BACKSOLIDUS) {
  231.             switch(ch) {
  232.             case chLatin_d:
  233.             case chLatin_D:
  234.             case chLatin_w:
  235.             case chLatin_W:
  236.             case chLatin_s:
  237.             case chLatin_S:
  238.                 {
  239.                     tok->mergeRanges(getTokenForShorthand(ch));
  240.                     end = true;
  241.                 }
  242.                 break;
  243.             case chLatin_i:
  244.             case chLatin_I:
  245.             case chLatin_c:
  246.             case chLatin_C:
  247.                 {
  248.                     ch = processCInCharacterClass(tok, ch);
  249.                     if (ch < 0) {
  250.                         end = true;
  251.                     }
  252.                 }
  253.                 break;
  254.             case chLatin_p:
  255.             case chLatin_P:
  256.                 {
  257.                     int start = getOffset();
  258.                     RangeToken* tok2 = processBacksolidus_pP(ch);
  260.                     if (tok2 == 0) {
  261.                         ThrowXML(ParseException,XMLExcepts::Parser_Atom5);
  262.                     }
  264.                     tok->mergeRanges(tok2);
  265.                     end = true;
  266.                 }
  267.                 break;
  268.             default:
  269.                 ch = decodeEscaped();
  270.             }
  271.         } // end if REGX_T_BACKSOLIDUS
  272.         else if (type == REGX_T_XMLSCHEMA_CC_SUBTRACTION && !firstLoop) {
  274.             if (isNRange) {
  276.                 base->subtractRanges(tok);
  277.                 tok = base;
  278.             }
  280.             RangeToken* rangeTok = parseCharacterClass(false);
  281.             tok->subtractRanges(rangeTok);
  283.             if (getState() != REGX_T_CHAR || getCharData() != chCloseSquare) {
  284.                 ThrowXML(ParseException,XMLExcepts::Parser_CC5);
  285.             }
  286.             break;
  287.         } // end if REGX_T_XMLSCHEMA...
  289.         processNext();
  291.         if (!end) {
  293.             if (type == REGX_T_CHAR
  294.                 && (ch == chOpenSquare
  295.                     || ch == chCloseSquare
  296.                     || ch == chDash)) {
  297.                 // '[', ']', '-' not allowed and should be esacaped
  298.                 XMLCh chStr[] = { ch, chNull };
  299.                 ThrowXML2(ParseException,XMLExcepts::Parser_CC6, chStr, chStr);
  300.             }
  302.             if (getState() != REGX_T_CHAR || getCharData() != chDash) {
  303.                 tok->addRange(ch, ch);
  304.             }
  305.             else {
  307.                 processNext();
  308.                 if ((type = getState()) == REGX_T_EOF)
  309.                     ThrowXML(ParseException,XMLExcepts::Parser_CC2);
  311.                 if ((type == REGX_T_CHAR && getCharData() == chCloseSquare)
  312.                     || type == REGX_T_XMLSCHEMA_CC_SUBTRACTION) {
  314.                     static const XMLCh dashStr[] = { chDash, chNull};
  315.                     ThrowXML2(ParseException, XMLExcepts::Parser_CC6, dashStr, dashStr);
  316.                 }
  317.                 else {
  319.                     XMLInt32 rangeEnd = getCharData();
  320.                     XMLCh rangeEndStr[] = { rangeEnd, chNull };
  322.                     if (type == REGX_T_CHAR) {
  324.                         if (rangeEnd == chOpenSquare
  325.                             || rangeEnd == chCloseSquare
  326.                             || rangeEnd == chDash)
  327.                             // '[', ']', '-' not allowed and should be esacaped
  328.                             ThrowXML2(ParseException, XMLExcepts::Parser_CC6, rangeEndStr, rangeEndStr);
  329.                     }
  330.                     else if (type == REGX_T_BACKSOLIDUS) {
  331.                         rangeEnd = decodeEscaped();
  332.                     }
  334.                     processNext();
  336.                     if (ch > rangeEnd) {
  337.                         XMLCh chStr[] = { ch, chNull };
  338.                         ThrowXML2(ParseException,XMLExcepts::Parser_Ope3, rangeEndStr, chStr);
  339.                     }
  341.                     tok->addRange(ch, rangeEnd);
  342.                 }
  343.             }
  344.         }
  345.         firstLoop = false;
  346.     }
  348.     if (getState() == REGX_T_EOF)
  349.         ThrowXML(ParseException,XMLExcepts::Parser_CC2);
  351.     tok->sortRanges();
  352.     tok->compactRanges();
  353.     setParseContext(S_NORMAL);
  354.     processNext();
  356.     return tok;
  357. }
  359. XMLInt32 ParserForXMLSchema::processCInCharacterClass(RangeToken* const tok,
  360.                                                       const XMLInt32 ch)
  361. {
  362.     tok->mergeRanges(getTokenForShorthand(ch));
  363.     return -1;
  364. }
  366. Token* ParserForXMLSchema::processLook(const unsigned short tokType) {
  368.     ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
  369.     return 0; // for compilers that complain about no return value
  370. }
  372. Token* ParserForXMLSchema::processBacksolidus_A() {
  374.     ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
  375.     return 0; // for compilers that complain about no return value
  376. }
  378. Token* ParserForXMLSchema::processBacksolidus_B() {
  380.     ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
  381.     return 0; // for compilers that complain about no return value
  382. }
  384. Token* ParserForXMLSchema::processBacksolidus_b() {
  386.     ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
  387.     return 0; // for compilers that complain about no return value
  388. }
  390. Token* ParserForXMLSchema::processBacksolidus_C() {
  392.     processNext();
  393.     return getTokenForShorthand(chLatin_C);
  394. }
  396. Token* ParserForXMLSchema::processBacksolidus_c() {
  398.     processNext();
  399.     return getTokenForShorthand(chLatin_c);
  400. }
  402. Token* ParserForXMLSchema::processBacksolidus_g() {
  404.     ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
  405.     return 0; // for compilers that complain about no return value
  406. }
  408. Token* ParserForXMLSchema::processBacksolidus_gt() {
  410.     ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
  411.     return 0; // for compilers that complain about no return value
  412. }
  414. Token* ParserForXMLSchema::processBacksolidus_I() {
  416.     processNext();
  417.     return getTokenForShorthand(chLatin_I);
  418. }
  420. Token* ParserForXMLSchema::processBacksolidus_i() {
  422.     processNext();
  423.     return getTokenForShorthand(chLatin_i);
  424. }
  426. Token* ParserForXMLSchema::processBacksolidus_lt() {
  428.     ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
  429.     return 0; // for compilers that complain about no return value
  430. }
  432. Token* ParserForXMLSchema::processBacksolidus_X() {
  434.     ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
  435.     return 0; // for compilers that complain about no return value
  436. }
  438. Token* ParserForXMLSchema::processBacksolidus_Z() {
  440.     ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
  441.     return 0; // for compilers that complain about no return value
  442. }
  444. Token* ParserForXMLSchema::processBacksolidus_z() {
  446.     ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
  447.     return 0; // for compilers that complain about no return value
  448. }
  450. Token* ParserForXMLSchema::processBackReference() {
  452.     ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
  453.     return 0; // for compilers that complain about no return value
  454. }
  456. Token* ParserForXMLSchema::processCondition() {
  458.     ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
  459.     return 0; // for compilers that complain about no return value
  460. }
  462. Token* ParserForXMLSchema::processIndependent() {
  464.     ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
  465.     return 0; // for compilers that complain about no return value
  466. }
  468. Token* ParserForXMLSchema::processModifiers() {
  470.     ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
  471.     return 0; // for compilers that complain about no return value
  472. }
  474. Token* ParserForXMLSchema::processParen2() {
  476.     ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
  477.     return 0; // for compilers that complain about no return value
  478. }
  480. RangeToken* ParserForXMLSchema::parseSetOperations() {
  482.     ThrowXML(RuntimeException, XMLExcepts::Regex_NotSupported);
  483.     return 0; // for compilers that complain about no return value
  484. }
  486. // ---------------------------------------------------------------------------
  487. //  ParserForXMLSchema: Getter methods
  488. // ---------------------------------------------------------------------------
  489. Token* ParserForXMLSchema::getTokenForShorthand(const XMLInt32 ch) {
  491.     switch(ch) {
  492.     case chLatin_d:
  493.         return getTokenFactory()->getRange(fgXMLDigit);
  494.     case chLatin_D:
  495.         return getTokenFactory()->getRange(fgXMLDigit, true);
  496.     case chLatin_w:
  497.         return getTokenFactory()->getRange(fgXMLWord);
  498.     case chLatin_W:
  499.         return getTokenFactory()->getRange(fgXMLWord, true);
  500.     case chLatin_s:
  501.         return getTokenFactory()->getRange(fgXMLSpace);
  502.     case chLatin_S:
  503.         return getTokenFactory()->getRange(fgXMLSpace, true);
  504.     case chLatin_c:
  505.         return getTokenFactory()->getRange(fgXMLNameChar);
  506.     case chLatin_C:
  507.         return getTokenFactory()->getRange(fgXMLNameChar, true);
  508.     case chLatin_i:
  509.         return getTokenFactory()->getRange(fgXMLInitialNameChar);
  510.     case chLatin_I:
  511.         return getTokenFactory()->getRange(fgXMLInitialNameChar, true);
  512.     }
  514.     return 0;
  515. }
  517. // ---------------------------------------------------------------------------
  518. //  ParserForXMLSchema: Helper methods
  519. // ---------------------------------------------------------------------------
  520. bool ParserForXMLSchema::checkQuestion(const int off) {
  522.     return false;
  523. }
  526. XMLInt32 ParserForXMLSchema::decodeEscaped() {
  528.     if (getState() != REGX_T_BACKSOLIDUS)
  529.         ThrowXML(ParseException,XMLExcepts::Parser_Next1);;
  531.     XMLInt32 ch = getCharData();
  533.     switch (ch) {
  534.     case chLatin_n:
  535.         ch = chLF;
  536.         break;
  537.     case chLatin_r:
  538.         ch = chCR;
  539.         break;
  540.     case chLatin_t:
  541.         ch = chHTab;
  542.         break;
  543.     case chBackSlash:
  544.     case chPipe:
  545.     case chPeriod:
  546.     case chCaret:
  547.     case chDash:
  548.     case chQuestion:
  549.     case chAsterisk:
  550.     case chPlus:
  551.     case chOpenCurly:
  552.     case chCloseCurly:
  553.     case chOpenParen:
  554.     case chCloseParen:
  555.     case chOpenSquare:
  556.     case chCloseSquare:
  557.         break;
  558.     default:
  559. {
  560.         XMLCh chString[] = {chBackSlash, ch, chNull};
  561.         chString[1] = ch;
  562.         ThrowXML1(ParseException,XMLExcepts::Parser_Process2, chString);
  563.         }
  564.     }
  566.     return ch;
  567. }
  569. XERCES_CPP_NAMESPACE_END
  571. /**
  572.   * End of file ParserForXMLSchema.cpp
  573.   */