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

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

xml/soap/webservice

开发平台：

C/C++

Token.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: Token.cpp,v $
  59.  * Revision 1.3  2001/05/11 13:26:50  tng
  60.  * Copyright update.
  61.  *
  62.  * Revision 1.2  2001/05/03 18:17:49  knoaman
  63.  * Some design changes:
  64.  * o Changed the TokenFactory from a single static instance, to a
  65.  *    normal class. Each RegularExpression object will have its own
  66.  *    instance of TokenFactory, and that instance will be passed to
  67.  *    other classes that need to use a TokenFactory to create Token
  68.  *    objects (with the exception of RangeTokenMap).
  69.  * o Added a new class RangeTokenMap to map a the different ranges
  70.  *    in a given category to a specific RangeFactory object. In the old
  71.  *    design RangeFactory had dual functionality (act as a Map, and as
  72.  *    a factory for creating RangeToken(s)). The RangeTokenMap will
  73.  *    have its own copy of the TokenFactory. There will be only one
  74.  *    instance of the RangeTokenMap class, and that instance will be
  75.  *    lazily deleted when XPlatformUtils::Terminate is called.
  76.  *
  77.  * Revision 1.1  2001/03/02 19:22:58  knoaman
  78.  * Schema: Regular expression handling part I
  79.  *
  80.  */
  82. // ---------------------------------------------------------------------------
  83. //  Includes
  84. // ---------------------------------------------------------------------------
  85. #include <util/regx/RangeToken.hpp>
  86. #include <util/regx/ModifierToken.hpp>
  87. #include <util/regx/RegularExpression.hpp>
  88. #include <util/regx/RegxUtil.hpp>
  90. // ---------------------------------------------------------------------------
  91. //  Static member data initialization
  92. // ---------------------------------------------------------------------------
  93. const XMLInt32  Token::UTF16_MAX = 0x10FFFF;
  94. const unsigned short Token::FC_CONTINUE = 0;
  95. const unsigned short Token::FC_TERMINAL = 1;
  96. const unsigned short Token::FC_ANY = 2;
  98. // ---------------------------------------------------------------------------
  99. //  Token: Constructors and Destructors
  100. // ---------------------------------------------------------------------------
  101. Token::Token(const unsigned short tokType) : fTokenType(tokType) {
  103. }
  106. Token::~Token() {
  108. }
  110. // ---------------------------------------------------------------------------
  111. //  Token: Getter mthods
  112. // ---------------------------------------------------------------------------
  113. int Token::getMinLength() const {
  115. switch (fTokenType) {
  117. case CONCAT:
  118.         {
  119.             int sum = 0;
  120.             unsigned int childSize = size();
  122.             for (unsigned int i=0; i<childSize; i++) {
  123.                 sum += getChild(i)->getMinLength();
  124.             }
  125.             return sum;
  126.         }
  127. case CONDITION:
  128. case UNION:
  129.         {
  130. unsigned int childSize = size();
  132.             if (childSize == 0) {
  133.                 return 0;
  134.             }
  135. int ret = getChild(0)->getMinLength();
  137.             for (unsigned int i=1; i < childSize; i++) {
  139.                 int min = getChild(i)->getMinLength();
  140.                 if (min < ret)
  141.                     ret = min;
  142.             }
  143. return ret;
  144.         }
  145. case CLOSURE:
  146. case NONGREEDYCLOSURE:
  147.         if (getMin() >= 0)
  148.             return getMin() * getChild(0)->getMinLength();
  150. return 0;
  151. case EMPTY:
  152. case ANCHOR:
  153. return 0;
  154. case DOT:
  155. case CHAR:
  156. case RANGE:
  157. case NRANGE:
  158. return 1;
  159. case INDEPENDENT:
  160. case PAREN:
  161. case MODIFIERGROUP:
  162. return getChild(0)->getMinLength();
  163. case BACKREFERENCE:
  164. return 0; // *****  - REVISIT
  165. case STRING:
  166. return XMLString::stringLen(getString());
  167. case LOOKAHEAD:
  168. case NEGATIVELOOKAHEAD:
  169. case LOOKBEHIND:
  170. case NEGATIVELOOKBEHIND:
  171. return 0; // *****  - REVIST
  172. // default:
  173. // throw;
  174. }
  176. // We should not get here, but we have it to make some compilers happy
  177. return -1;
  178. }
  181. int Token::getMaxLength() const {
  183. switch (fTokenType) {
  185. case CONCAT:
  186.         {
  187.             int sum = 0;
  188.             unsigned int childSize = size();
  190.             for (unsigned int i=0; i<childSize; i++) {
  192.                 int val = getChild(i)->getMaxLength();
  194. if (val < 0){
  195. return -1;
  196. }
  197.                 sum += val;
  198.             }
  199.             return sum;
  200.         }
  201.     case CONDITION:
  202.     case UNION:
  203.         {
  204.             unsigned int childSize = size();
  206. if (childSize == 0)
  207.                 return 0;
  209.             int ret = getChild(0)->getMaxLength();
  211.             for (unsigned i = 1; ret > 0 && i < childSize; i++) {
  213.                 int max = getChild(i)->getMaxLength();
  215.                 if (max < 0) {
  217.                     ret = -1;
  218.                     break;
  219.                 }
  221.                 if (max > ret)
  222.                     ret = max;
  223.             }
  224. return ret;
  225.         }
  226.     case CLOSURE:
  227.     case NONGREEDYCLOSURE:
  228.         if (getMax() >= 0) {
  229.             return getMax() * getChild(0)->getMaxLength();
  230. }
  231. return -1;
  232.     case EMPTY:
  233.     case ANCHOR:
  234.         return 0;
  235.     case CHAR:
  236.         return 1;
  237.     case DOT:
  238.     case RANGE:
  239.     case NRANGE:
  240.         return 2;
  241.     case INDEPENDENT:
  242.     case PAREN:
  243.     case MODIFIERGROUP:
  244.         return getChild(0)->getMaxLength();
  245.     case BACKREFERENCE:
  246. return -1; // REVISIT
  247.     case STRING:
  248.         return XMLString::stringLen(getString());
  249.     case LOOKAHEAD:
  250.     case NEGATIVELOOKAHEAD:
  251.     case LOOKBEHIND:
  252.     case NEGATIVELOOKBEHIND:
  253. return 0; // REVISIT
  254. //    default:
  255. // throw; //ThrowXML(RuntimeException, ...)
  256.     } // end switch
  258. return -1;
  259. }
  261. // ---------------------------------------------------------------------------
  262. //  Token: Helper mthods
  263. // ---------------------------------------------------------------------------
  264. int Token::analyzeFirstCharacter(RangeToken* const rangeTok,
  265.  const int options,
  266.                                  TokenFactory* const tokFactory)
  267. {
  268. switch(fTokenType) {
  269. case CONCAT:
  270. {
  271. int ret = FC_CONTINUE;
  272. for (int i=0; i<size(); i++) {
  274. Token* tok = getChild(i);
  275. if (tok
  276. && (ret=tok->analyzeFirstCharacter(rangeTok,
  277.                                     options, tokFactory))!= FC_CONTINUE)
  278. break;
  279. }
  280. return ret;
  281. }
  282. case UNION:
  283. {
  284. unsigned int childSize = size();
  285.             if (childSize == 0)
  286.                 return FC_CONTINUE;
  288.             int ret = FC_CONTINUE;
  289. bool hasEmpty = false;
  291. for (unsigned int i=0; i < childSize; i++) {
  293.                 ret = getChild(i)->analyzeFirstCharacter(rangeTok, options, tokFactory);
  295. if (ret == FC_ANY)
  296. break;
  297. else
  298. hasEmpty = true;
  299. }
  300. return hasEmpty ? FC_CONTINUE : ret;
  301. }
  302. case CONDITION:
  303. {
  304.             int ret1 = getChild(0)->analyzeFirstCharacter(rangeTok, options, tokFactory);
  306.             if (size() == 1)
  307.                 return FC_CONTINUE;
  309. int ret2;
  310. if (ret1 != FC_ANY) {
  311.     ret2 = getChild(1)->analyzeFirstCharacter(rangeTok, options, tokFactory);
  312. }
  314. if (ret1 == FC_ANY || ret2 == FC_ANY)
  315. return FC_ANY;
  317. if (ret1 == FC_CONTINUE || ret2 == FC_CONTINUE)
  318. return FC_CONTINUE;
  320. return FC_TERMINAL;
  321. }
  322. case CLOSURE:
  323. case NONGREEDYCLOSURE:
  324. {
  325. Token* tok = getChild(0);
  326. if (tok)
  327. tok->analyzeFirstCharacter(rangeTok, options, tokFactory);
  328. return FC_CONTINUE;
  329. }
  330. case DOT:
  331. case EMPTY:
  332. case ANCHOR:
  333. return FC_CONTINUE;
  334. case CHAR:
  335. {
  336.             XMLInt32 ch = getChar();
  337. rangeTok->addRange(ch, ch);
  338. if (ch < 0x1000 && isSet(options,RegularExpression::IGNORE_CASE)) {
  339. //REVISIT
  340. }
  341. }
  342. return FC_TERMINAL;
  343. case RANGE:
  344. {
  345. if (isSet(options, RegularExpression::IGNORE_CASE)) {
  346.                 rangeTok->mergeRanges(((RangeToken*)
  347.                                          this)->getCaseInsensitiveToken(tokFactory));
  348. }
  349. else {
  350. rangeTok->mergeRanges(this);
  351. }
  352. return FC_TERMINAL;
  353. }
  354. case NRANGE:
  355. {
  356. if (isSet(options, RegularExpression::IGNORE_CASE)) {
  358. RangeToken* caseITok = (((RangeToken*)
  359.                        this)->getCaseInsensitiveToken(tokFactory));
  360. rangeTok->mergeRanges(RangeToken::complementRanges(caseITok, tokFactory));
  361. }
  362. else {
  363. rangeTok->mergeRanges(
  364. RangeToken::complementRanges((RangeToken*) this, tokFactory));
  365. }
  366. }
  367. case INDEPENDENT:
  368. case PAREN:
  369. {
  370. Token* tok = getChild(0);
  371. if (tok)
  372. return tok->analyzeFirstCharacter(rangeTok,options, tokFactory);
  373. }
  374. case MODIFIERGROUP:
  375. case BACKREFERENCE:
  376. rangeTok->addRange(0, UTF16_MAX);
  377. return FC_ANY;
  378. case STRING:
  379. {
  380. const XMLCh* str = getString();
  381.             XMLInt32 ch = str[0];
  383. if (RegxUtil::isHighSurrogate((XMLCh) ch)) {
  384. }
  386.     rangeTok->addRange(ch, ch);
  387.     if (ch<0x10000 && isSet(options,RegularExpression::IGNORE_CASE)) {
  388.                 //REVISIT
  389.             }
  390. }
  391. return FC_TERMINAL;
  392. case LOOKAHEAD:
  393. case NEGATIVELOOKAHEAD:
  394. case LOOKBEHIND:
  395. case NEGATIVELOOKBEHIND:
  396. FC_CONTINUE;
  397. // default:
  398. // throw;
  399. }
  401. return 0;
  402. }
  405. Token* Token::findFixedString(int options, int& outOptions) {
  407.     switch(fTokenType) {
  409.     case CHAR:
  410. return 0;
  411.     case STRING:
  412. outOptions = options;
  413. return this;
  414.     case UNION:
  415.     case CLOSURE:
  416.     case NONGREEDYCLOSURE:
  417.     case EMPTY:
  418.     case ANCHOR:
  419.     case RANGE:
  420.     case NRANGE:
  421.     case DOT:
  422.     case BACKREFERENCE:
  423.     case LOOKAHEAD:
  424.     case NEGATIVELOOKAHEAD:
  425.     case LOOKBEHIND:
  426.     case NEGATIVELOOKBEHIND:
  427.     case CONDITION:
  428. return 0;
  429.     case INDEPENDENT:
  430.     case PAREN:
  431. return getChild(0)->findFixedString(options, outOptions);
  432.     case CONCAT:
  433.         {
  434.             Token* prevTok = 0;
  435.             int prevOptions = 0;
  437.             for (int i=0; i<size(); i++) {
  439.                 Token* tok = getChild(i)->findFixedString(options, outOptions);
  441.                 if (prevTok == 0 || prevTok->isShorterThan(tok)) {
  443.                     prevTok = tok;
  444. prevOptions = outOptions;
  445.                 }
  446.             }
  448. outOptions = prevOptions;
  449.             return prevTok;
  450.         }
  451.     case MODIFIERGROUP:
  452.         {
  453.             options |= ((ModifierToken *) this)->getOptions();
  454.             options &= ~((ModifierToken *) this)->getOptionsMask();
  455.             return getChild(0)->findFixedString(options, outOptions);
  456.         }
  457.     } // end switch
  459.     return 0;
  460. }
  463. bool Token::isShorterThan(Token* const tok) {
  465. if (tok == 0)
  466. return false;
  468. if (getTokenType() != STRING && tok->getTokenType() != STRING)
  469. return false; //Should we throw an exception?
  471.     int length = XMLString::stringLen(getString());
  472.     int tokLength = XMLString::stringLen(tok->getString());
  474. return length < tokLength;
  475. }
  477. /**
  478.   * End of file Token.cpp
  479.   */