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

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

词法分析

开发平台：

Visual C++

TokenFactory.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: TokenFactory.cpp,v $
  59.  * Revision 1.8  2003/05/18 14:02:06  knoaman
  60.  * Memory manager implementation: pass per instance manager.
  61.  *
  62.  * Revision 1.7  2003/05/16 21:37:00  knoaman
  63.  * Memory manager implementation: Modify constructors to pass in the memory manager.
  64.  *
  65.  * Revision 1.6  2003/05/16 00:03:10  knoaman
  66.  * Partial implementation of the configurable memory manager.
  67.  *
  68.  * Revision 1.5  2003/03/04 21:11:12  knoaman
  69.  * [Bug 17516] Thread safety problems in ../util/ and ../util/regx.
  70.  *
  71.  * Revision 1.4  2002/12/24 17:59:07  tng
  72.  * Build with ICU 2.4
  73.  *
  74.  * Revision 1.3  2002/11/04 15:17:00  tng
  75.  * C++ Namespace Support.
  76.  *
  77.  * Revision 1.2  2002/03/18 19:29:53  knoaman
  78.  * Change constant names to eliminate possible conflict with user defined ones.
  79.  *
  80.  * Revision 1.1.1.1  2002/02/01 22:22:31  peiyongz
  81.  * sane_include
  82.  *
  83.  * Revision 1.5  2001/06/07 20:55:39  tng
  84.  * Fix no newline at the end warning.  By Pei Yong Zhang.
  85.  *
  86.  * Revision 1.4  2001/05/11 13:26:51  tng
  87.  * Copyright update.
  88.  *
  89.  * Revision 1.3  2001/05/03 18:17:52  knoaman
  90.  * Some design changes:
  91.  * o Changed the TokenFactory from a single static instance, to a
  92.  *    normal class. Each RegularExpression object will have its own
  93.  *    instance of TokenFactory, and that instance will be passed to
  94.  *    other classes that need to use a TokenFactory to create Token
  95.  *    objects (with the exception of RangeTokenMap).
  96.  * o Added a new class RangeTokenMap to map a the different ranges
  97.  *    in a given category to a specific RangeFactory object. In the old
  98.  *    design RangeFactory had dual functionality (act as a Map, and as
  99.  *    a factory for creating RangeToken(s)). The RangeTokenMap will
  100.  *    have its own copy of the TokenFactory. There will be only one
  101.  *    instance of the RangeTokenMap class, and that instance will be
  102.  *    lazily deleted when XPlatformUtils::Terminate is called.
  103.  *
  104.  * Revision 1.2  2001/03/22 13:23:34  knoaman
  105.  * Minor modifications to eliminate compiler warnings.
  106.  *
  107.  * Revision 1.1  2001/03/02 19:23:00  knoaman
  108.  * Schema: Regular expression handling part I
  109.  *
  110.  */
  112. // ---------------------------------------------------------------------------
  113. //  Includes
  114. // ---------------------------------------------------------------------------
  115. #include <xercesc/util/regx/TokenFactory.hpp>
  116. #include <xercesc/util/regx/TokenInc.hpp>
  117. #include <xercesc/util/regx/XMLRangeFactory.hpp>
  118. #include <xercesc/util/regx/ASCIIRangeFactory.hpp>
  119. #include <xercesc/util/regx/UnicodeRangeFactory.hpp>
  120. #include <xercesc/util/regx/BlockRangeFactory.hpp>
  121. #include <xercesc/util/regx/RangeTokenMap.hpp>
  122. #include <xercesc/util/regx/RegxDefs.hpp>
  124. XERCES_CPP_NAMESPACE_BEGIN
  126. bool TokenFactory::fRangeInitialized = false;
  128. // ---------------------------------------------------------------------------
  129. //  TokenFactory: Constructors and Destructor
  130. // ---------------------------------------------------------------------------
  131. TokenFactory::TokenFactory(MemoryManager* const manager) :
  132.     fTokens(new (manager) RefVectorOf<Token> (16, true, manager))
  133.     , fEmpty(0)
  134.     , fLineBegin(0)
  135.     , fLineBegin2(0)
  136.     , fLineEnd(0)
  137.     , fStringBegin(0)
  138.     , fStringEnd(0)
  139.     , fStringEnd2(0)
  140.     , fWordEdge(0)
  141.     , fNotWordEdge(0)
  142.     , fWordEnd(0)
  143.     , fWordBegin(0)
  144.     , fDot(0)
  145.     , fCombiningChar(0)
  146.     , fGrapheme(0)
  147.     , fMemoryManager(manager)
  148. {
  150. }
  152. TokenFactory::~TokenFactory() {
  154. delete fTokens;
  155. fTokens = 0;
  156. }
  158. // ---------------------------------------------------------------------------
  159. //  TokenFactory - Factory methods
  160. // ---------------------------------------------------------------------------
  161. Token* TokenFactory::createToken(const unsigned short tokType) {
  163. if (tokType == Token::T_EMPTY && fEmpty != 0)
  164. return fEmpty;
  166. Token* tmpTok = new (fMemoryManager) Token(tokType);
  168. if (tokType == Token::T_EMPTY) {
  169. fEmpty = tmpTok;
  170.     }
  172. fTokens->addElement(tmpTok);
  174. return tmpTok;
  175. }
  178. ParenToken* TokenFactory::createLook(const unsigned short tokType,
  179.  Token* const token) {
  181. ParenToken* tmpTok = new (fMemoryManager) ParenToken(tokType, token, 0);
  183. fTokens->addElement(tmpTok);
  184. return tmpTok;
  185. }
  187. ParenToken* TokenFactory::createParenthesis(Token* const token,
  188. const int noGroups) {
  190. ParenToken* tmpTok = new (fMemoryManager) ParenToken(Token::T_PAREN, token, noGroups);
  192. fTokens->addElement(tmpTok);
  193. return tmpTok;
  194. }
  196. ClosureToken* TokenFactory::createClosure(Token* const token,
  197.   bool isNonGreedy) {
  199. ClosureToken* tmpTok = isNonGreedy ? new (fMemoryManager) ClosureToken(Token::T_NONGREEDYCLOSURE, token)
  200.    : new (fMemoryManager) ClosureToken(Token::T_CLOSURE, token);
  202. fTokens->addElement(tmpTok);
  203. return tmpTok;
  204. }
  206. ConcatToken* TokenFactory::createConcat(Token* const token1,
  207.                                         Token* const token2) {
  209.     ConcatToken* tmpTok = new (fMemoryManager) ConcatToken(token1, token2);
  211.     fTokens->addElement(tmpTok);
  212.     return tmpTok;
  213. }
  215. UnionToken* TokenFactory::createUnion(const bool isConcat) {
  217. UnionToken* tmpTok = isConcat ? new (fMemoryManager) UnionToken(Token::T_CONCAT)
  218.   : new (fMemoryManager) UnionToken(Token::T_UNION);
  220. fTokens->addElement(tmpTok);
  221. return tmpTok;
  222. }
  224. RangeToken* TokenFactory::createRange(const bool isNegRange){
  227. RangeToken* tmpTok = isNegRange ? new (fMemoryManager) RangeToken(Token::T_NRANGE, fMemoryManager)
  228.    : new (fMemoryManager) RangeToken(Token::T_RANGE, fMemoryManager);
  230. fTokens->addElement(tmpTok);
  231. return tmpTok;
  233. return 0;
  234. }
  236. CharToken* TokenFactory::createChar(const XMLUInt32 ch, const bool isAnchor) {
  238. CharToken* tmpTok = isAnchor ? new (fMemoryManager) CharToken(Token::T_ANCHOR, ch)
  239. : new (fMemoryManager) CharToken(Token::T_CHAR, ch);
  241. fTokens->addElement(tmpTok);
  242. return tmpTok;
  243. }
  245. StringToken* TokenFactory::createBackReference(const int noRefs) {
  247. StringToken* tmpTok = new (fMemoryManager) StringToken(Token::T_BACKREFERENCE, 0, noRefs, fMemoryManager);
  249. fTokens->addElement(tmpTok);
  250. return tmpTok;
  251. }
  253. StringToken* TokenFactory::createString(const XMLCh* const literal) {
  255. StringToken* tmpTok = new (fMemoryManager) StringToken(Token::T_STRING, literal, 0, fMemoryManager);
  257. fTokens->addElement(tmpTok);
  258. return tmpTok;
  259. }
  261. ModifierToken* TokenFactory::createModifierGroup(Token* const child,
  262.                                                  const int add,
  263.                                                  const int mask) {
  265. ModifierToken* tmpTok = new (fMemoryManager) ModifierToken(child, add, mask);
  267. fTokens->addElement(tmpTok);
  268. return tmpTok;
  269. }
  271. ConditionToken* TokenFactory::createCondition(const int refNo,
  272.                                               Token* const condition,
  273.                                               Token* const yesFlow,
  274.                                               Token* const noFlow) {
  276. ConditionToken* tmpTok = new (fMemoryManager) ConditionToken(refNo, condition, yesFlow,
  277.                                                 noFlow);
  278. fTokens->addElement(tmpTok);
  279. return tmpTok;
  280. }
  282. // ---------------------------------------------------------------------------
  283. //  TokenFactory - Getter methods
  284. // ---------------------------------------------------------------------------
  285. RangeToken* TokenFactory::getRange(const XMLCh* const keyword,
  286.                                    const bool complement) {
  288.     if (!fRangeInitialized) {
  289. initializeRegistry();
  290. }
  292. return RangeTokenMap::instance()->getRange(keyword, complement);
  293. }
  295. Token* TokenFactory::getLineBegin() {
  297. if (fLineBegin == 0)
  298.         fLineBegin = createChar(chCaret, true);
  300.     return fLineBegin;
  301. }
  303. Token* TokenFactory::getLineBegin2() {
  305. if (fLineBegin2 == 0)
  306.         fLineBegin2 = createChar(chAt, true);
  308.     return fLineBegin2;
  309. }
  311. Token* TokenFactory::getLineEnd() {
  313. if (fLineEnd == 0)
  314.         fLineEnd = createChar(chDollarSign, true);
  316.     return fLineEnd;
  317. }
  319. Token* TokenFactory::getStringBegin() {
  321. if (fStringBegin == 0)
  322.         fStringBegin = createChar(chLatin_A, true);
  324.     return fStringBegin;
  325. }
  327. Token* TokenFactory::getStringEnd() {
  329. if (fStringEnd == 0)
  330.         fStringEnd = createChar(chLatin_z, true);
  332.     return fStringEnd;
  333. }
  335. Token* TokenFactory::getStringEnd2() {
  337. if (fStringEnd2 == 0)
  338.         fStringEnd2 = createChar(chLatin_Z, true);
  340.     return fStringEnd2;
  341. }
  343. Token* TokenFactory::getWordEdge() {
  345. if (fWordEdge == 0)
  346.         fWordEdge = createChar(chLatin_b, true);
  348.     return fWordEdge;
  349. }
  351. Token* TokenFactory::getNotWordEdge(){
  353. if (fNotWordEdge == 0)
  354.         fNotWordEdge = createChar(chLatin_B, true);
  356.     return fNotWordEdge;
  357. }
  359. Token* TokenFactory::getWordBegin() {
  361. if (fWordBegin == 0)
  362.         fWordBegin = createChar(chOpenAngle, true);
  364.     return fWordBegin;
  365. }
  367. Token* TokenFactory::getWordEnd() {
  369. if (fWordEnd == 0)
  370.         fWordEnd = createChar(chCloseAngle, true);
  372.     return fWordEnd;
  373. }
  375. Token* TokenFactory::getDot() {
  377. if (fDot == 0)
  378.         fDot = createToken(Token::T_DOT);
  380.     return fDot;
  381. }
  383. Token* TokenFactory::getCombiningCharacterSequence() {
  385. if (fCombiningChar == 0) {
  387. Token* foo = createClosure(getRange(fgUniMark)); // pM*
  388. foo = createConcat(getRange(fgUniMark, true), foo); // PM + pM*
  389. fCombiningChar = foo;
  390. }
  392. return fCombiningChar;
  393. }
  397. //    static final String viramaString =
  400. Token* TokenFactory::getGraphemePattern() {
  402. if (fGrapheme == 0) {
  404.         Token* base_char = createRange();  // [{ASSIGNED}]-[{M},{C}]
  405.         base_char->mergeRanges(getRange(fgUniAssigned));
  406.         base_char->subtractRanges(getRange(fgUniMark));
  407.         base_char->subtractRanges(getRange(fgUniControl));
  409.         Token* virama = createRange();
  410. virama->addRange(0x094D, 0x094D);
  411. virama->addRange(0x09CD, 0x09CD);
  412. virama->addRange(0x0A4D, 0x0A4D);
  413. virama->addRange(0x0ACD, 0x0ACD);
  414. virama->addRange(0x0B4D, 0x0B4D);
  415. virama->addRange(0x0BCD, 0x0BCD);
  416. virama->addRange(0x0C4D, 0x0C4D);
  417. virama->addRange(0x0CCD, 0x0CCD);
  418. virama->addRange(0x0D4D, 0x0D4D);
  419. virama->addRange(0x0E3A, 0x0E3A);
  420. virama->addRange(0x0F84, 0x0F84);
  422.         Token* combiner_wo_virama = createRange();
  423.         combiner_wo_virama->mergeRanges(getRange(fgUniMark));
  424.         combiner_wo_virama->addRange(0x1160, 0x11FF); // hangul_medial and hangul_final
  425.         combiner_wo_virama->addRange(0xFF9F, 0xFF9F); // extras
  427.         Token* left = TokenFactory::createUnion();       // base_char?
  428.         left->addChild(base_char, this);
  429.         left->addChild(createToken(Token::T_EMPTY), this);
  431.         Token* foo = createUnion();
  432.         foo->addChild(TokenFactory::createConcat(virama,getRange(fgUniLetter)), this);
  433.         foo->addChild(combiner_wo_virama, this);
  435.         foo = createClosure(foo);
  436.         foo = createConcat(left, foo);
  438.         fGrapheme = foo;
  439. }
  441. return fGrapheme;
  442. }
  444. // ---------------------------------------------------------------------------
  445. //  TokenFactory - Helper methods
  446. // ---------------------------------------------------------------------------
  447. void TokenFactory::initializeRegistry() {
  449.     if (fRangeInitialized)
  450.         return;
  452.     // Use a faux scope to synchronize while we do this
  453.     {
  454.         XMLMutexLock lockInit(&fMutex);
  456.         if (!fRangeInitialized) {
  458.             RangeTokenMap::instance()->initializeRegistry();
  460.             // Add categories
  461.             RangeTokenMap::instance()->addCategory(fgXMLCategory);
  462.             RangeTokenMap::instance()->addCategory(fgASCIICategory);
  463.             RangeTokenMap::instance()->addCategory(fgUnicodeCategory);
  464.             RangeTokenMap::instance()->addCategory(fgBlockCategory);
  466.          // Add xml range factory
  467.             RangeFactory* rangeFact = new XMLRangeFactory();
  468.             RangeTokenMap::instance()->addRangeMap(fgXMLCategory, rangeFact);
  469.             rangeFact->initializeKeywordMap();
  471.             // Add ascii range factory
  472.             rangeFact = new ASCIIRangeFactory();
  473.             RangeTokenMap::instance()->addRangeMap(fgASCIICategory, rangeFact);
  474.             rangeFact->initializeKeywordMap();
  476.             // Add unicode range factory
  477.             rangeFact = new UnicodeRangeFactory();
  478.             RangeTokenMap::instance()->addRangeMap(fgUnicodeCategory, rangeFact);
  479.             rangeFact->initializeKeywordMap();
  481.             // Add block range factory
  482.             rangeFact = new BlockRangeFactory();
  483.             RangeTokenMap::instance()->addRangeMap(fgBlockCategory, rangeFact);
  484.             rangeFact->initializeKeywordMap();
  486.             fRangeInitialized = true;
  487.         }
  488.     }
  489. }
  491. /*
  492. #if defined (XML_USE_ICU_TRANSCODER)
  493.    #include <unicode/uchar.h>
  494. #endif
  496. #include <stdio.h>
  497. void TokenFactory::printUnicode() {
  499. #if defined (XML_USE_ICU_TRANSCODER)
  500.     //
  501.     //  Write it out to a temp file to be read back into this source later.
  502.     //
  503. printf("Printingn");
  504. //sprintf(msg, "Printingn");
  505.     FILE* outFl = fopen("table.out", "wt+");
  506.     fprintf(outFl, "const XMLByte fgUniCharsTable[0x10000] =n{    ");
  507.     for (unsigned int index = 0; index <= 0xFFFF; index += 16)
  508.     {
  509.         fprintf(outFl
  510.                 , "    , 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02X, 0x%02Xn"
  511.                 , (unsigned int)u_charType(index)
  512.                 , (unsigned int)u_charType(index+1)
  513.                 , (unsigned int)u_charType(index+2)
  514.                 , (unsigned int)u_charType(index+3)
  515.                 , (unsigned int)u_charType(index+4)
  516.                 , (unsigned int)u_charType(index+5)
  517.                 , (unsigned int)u_charType(index+6)
  518.                 , (unsigned int)u_charType(index+7)
  519. , (unsigned int)u_charType(index+8)
  520.                 , (unsigned int)u_charType(index+9)
  521.                 , (unsigned int)u_charType(index+10)
  522.                 , (unsigned int)u_charType(index+11)
  523. , (unsigned int)u_charType(index+12)
  524.                 , (unsigned int)u_charType(index+13)
  525.                 , (unsigned int)u_charType(index+14)
  526.                 , (unsigned int)u_charType(index+15));
  527.     }
  528.     fprintf(outFl, "};n");
  530.     fclose(outFl);
  531. #endif
  532. }
  533. */
  535. XERCES_CPP_NAMESPACE_END
  537. /**
  538.   * End of file TokenFactory.cpp
  539.   */