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

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

词法分析

开发平台：

Visual C++

RangeToken.cpp：源码内容
  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 2001-2002 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: RangeToken.cpp,v $
  59.  * Revision 1.8  2003/05/16 21:37:00  knoaman
  60.  * Memory manager implementation: Modify constructors to pass in the memory manager.
  61.  *
  62.  * Revision 1.7  2003/05/15 21:46:47  knoaman
  63.  * Add missing include.
  64.  *
  65.  * Revision 1.6  2002/11/04 15:17:00  tng
  66.  * C++ Namespace Support.
  67.  *
  68.  * Revision 1.5  2002/10/15 18:15:02  knoaman
  69.  * [Bug 13490]: - new[]/delete mismatch in RangeToken.cpp
  70.  *
  71.  * Revision 1.4  2002/05/27 11:46:53  tng
  72.  * Fix compilation error.  The definition should match declaration.
  73.  *
  74.  * Revision 1.3  2002/05/24 16:42:20  knoaman
  75.  * Performance fixes: eliminate mulitple calls to addRange and sort.
  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:30  peiyongz
  81.  * sane_include
  82.  *
  83.  * Revision 1.4  2001/05/29 19:39:33  knoaman
  84.  * Typo fix
  85.  *
  86.  * Revision 1.3  2001/05/11 13:26:45  tng
  87.  * Copyright update.
  88.  *
  89.  * Revision 1.2  2001/05/03 18:17:37  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.1  2001/03/02 19:26:46  knoaman
  105.  * Schema: Regular expression handling part II
  106.  *
  107.  */
  109. // ---------------------------------------------------------------------------
  110. //  Includes
  111. // ---------------------------------------------------------------------------
  112. #include <xercesc/util/regx/RangeToken.hpp>
  113. #include <xercesc/util/regx/TokenFactory.hpp>
  114. #include <xercesc/util/IllegalArgumentException.hpp>
  116. XERCES_CPP_NAMESPACE_BEGIN
  118. // ---------------------------------------------------------------------------
  119. //  Static member data initialization
  120. // ---------------------------------------------------------------------------
  121. const int RangeToken::MAPSIZE = 256;
  122. const unsigned int RangeToken::INITIALSIZE = 16;
  124. // ---------------------------------------------------------------------------
  125. //  RangeToken: Constructors and Destructors
  126. // ---------------------------------------------------------------------------
  127. RangeToken::RangeToken(const unsigned short tokType,
  128.                        MemoryManager* const manager) 
  129.     : Token(tokType)
  130.     , fSorted(false)
  131.     , fCompacted(false)
  132.     , fNonMapIndex(0)
  133.     , fElemCount(0)
  134.     , fMaxCount(INITIALSIZE)
  135.     , fMap(0)
  136.     , fRanges(0)
  137.     , fCaseIToken(0)
  138.     , fMemoryManager(manager)
  139. {
  141. }
  143. RangeToken::~RangeToken() {
  145.     fMemoryManager->deallocate(fMap);//delete [] fMap;
  146.     fMemoryManager->deallocate(fRanges);//delete[] fRanges;
  147. }
  150. // ---------------------------------------------------------------------------
  151. //  RangeToken: Getter methods
  152. // ---------------------------------------------------------------------------
  153. RangeToken* RangeToken::getCaseInsensitiveToken(TokenFactory* const tokFactory) {
  155.     // REVIST
  156.     // We will not build a token with case insenstive ranges
  157.     // For now we will return a copy of ourselves.
  158.     if (fCaseIToken == 0 && tokFactory) {
  160.         bool isNRange = (getTokenType() == T_NRANGE) ? true : false;
  161.         RangeToken* lwrToken = tokFactory->createRange(isNRange);
  163.         lwrToken->mergeRanges(this);
  164.         fCaseIToken = lwrToken;
  165.     }
  167.     return fCaseIToken;
  168. }
  170. // ---------------------------------------------------------------------------
  171. //  RangeToken: Setter methods
  172. // ---------------------------------------------------------------------------
  173. void RangeToken::setRangeValues(XMLInt32* const rangeValues, const unsigned int count)
  174. {
  175.     if (fRanges) {
  177.         if (fMap) {
  178.             fMemoryManager->deallocate(fMap);//delete [] fMap;
  179.             fMap = 0;
  180.         }
  182.         fElemCount = 0;
  183.         fMemoryManager->deallocate(fRanges);//delete [] fRanges;
  184.         fRanges = 0;
  185.     }
  187.     fElemCount = fMaxCount = count;
  188.     fRanges = rangeValues;
  189. }
  191. // ---------------------------------------------------------------------------
  192. //  RangeToken: Range manipulation methods
  193. // ---------------------------------------------------------------------------
  194. void RangeToken::addRange(const XMLInt32 start, const XMLInt32 end) {
  196.     XMLInt32 val1, val2;
  198.     fCaseIToken = 0;
  200.     if (start <= end) {
  202.         val1 = start;
  203.         val2 = end;
  204.     }
  205.     else {
  207.         val1 = end;
  208.         val2 = start;
  209.     }
  211.     if (fRanges == 0) {
  213.         fRanges = (XMLInt32*) fMemoryManager->allocate
  214.         (
  215.             fMaxCount * sizeof(XMLInt32)
  216.         );//new XMLInt32[fMaxCount];
  217.         fRanges[0] = val1;
  218.         fRanges[1] = val2;
  219.         fElemCount = 2;
  220.         fSorted = true;
  221.     }
  222.     else {
  224.         if (fRanges[fElemCount-1] + 1 == val1) {
  226.             fRanges[fElemCount-1] = val2;
  227.             return;
  228.         }
  230.         if (fElemCount + 2 >= fMaxCount) {
  231.             expand(2);
  232.         }
  234.         if (fRanges[fElemCount-1] >= val1)
  235.             fSorted = false;
  237.         fRanges[fElemCount++] = val1;
  238.         fRanges[fElemCount++] = val2;
  240.         if (!fSorted) {
  241.             sortRanges();
  242.         }
  243.     }
  244. }
  246. void RangeToken::sortRanges() {
  248.     if (fSorted || fRanges == 0)
  249.         return;
  251.     for (int i = fElemCount - 4; i >= 0; i -= 2) {
  253.         for (int j = 0; j <= i; j +=2) {
  255.             if (fRanges[j] > fRanges[j + 2]
  256.                 || (fRanges[j]==fRanges[j+2] && fRanges[j+1] > fRanges[j+3])) {
  258.                 XMLInt32 tmpVal = fRanges[j+2];
  259.                 fRanges[j+2] = fRanges[j];
  260.                 fRanges[j] = tmpVal;
  261.                 tmpVal = fRanges[j+3];
  262.                 fRanges[j+3] = fRanges[j+1];
  263.                 fRanges[j+1] = tmpVal;
  264.             }
  265.         }
  266.     }
  268.     fSorted = true;
  269. }
  271. void RangeToken::compactRanges() {
  273.     if (fCompacted || fRanges == 0 || fElemCount <= 2)
  274.         return;
  276.     unsigned int base = 0;
  277.     unsigned int target = 0;
  279.     while (target < fElemCount) {
  281.         if (base != target) {
  283.             fRanges[base] = fRanges[target++];
  284.             fRanges[base+1] = fRanges[target++];
  285.         }
  286.         else
  287.             target += 2;
  289.         XMLInt32 baseEnd = fRanges[base + 1];
  291.         while (target < fElemCount) {
  293.             XMLInt32 startRange = fRanges[target];
  295.             if (baseEnd + 1 < startRange)
  296.                 break;
  298.             XMLInt32 endRange = fRanges[target + 1];
  300.             if (baseEnd + 1 == startRange || baseEnd < endRange) {
  302.                 baseEnd = endRange;
  303.                 fRanges[base+1] = baseEnd;
  304.                 target += 2;
  305.             }
  306.             else if (baseEnd >= endRange) {
  307.                 target += 2;
  308.             }
  309.             else {
  310.                 ThrowXML(RuntimeException, XMLExcepts::Regex_CompactRangesError);
  311.             }
  312.         } // inner while
  314.         base += 2;
  315.     }
  317.     fElemCount = base;
  318.     fCompacted = true;
  319. }
  321. void RangeToken::mergeRanges(const Token *const tok) {
  324.     if (tok->getTokenType() != this->getTokenType())
  325.         ThrowXML(IllegalArgumentException, XMLExcepts::Regex_MergeRangesTypeMismatch);
  327.     RangeToken* rangeTok = (RangeToken *) tok;
  329.     if (rangeTok->fRanges == 0)
  330.         return;
  332.     fCaseIToken = 0;
  333.     sortRanges();
  334.     rangeTok->sortRanges();
  336.     if (fRanges == 0) {
  338.         fMaxCount = rangeTok->fMaxCount;
  339.         fRanges = (XMLInt32*) fMemoryManager->allocate
  340.         (
  341.             fMaxCount * sizeof(XMLInt32)
  342.         );//new XMLInt32[fMaxCount];
  343.         for (unsigned int index = 0; index < rangeTok->fElemCount; index++) {
  344.             fRanges[index] = rangeTok->fRanges[index];
  345.         }
  347.         fElemCount = rangeTok->fElemCount;
  348.         return;
  349.     }
  351.     unsigned int newMaxCount = (fElemCount + rangeTok->fElemCount >= fMaxCount)
  352.                                  ? fMaxCount + rangeTok->fMaxCount : fMaxCount;
  353.     XMLInt32* result = (XMLInt32*) fMemoryManager->allocate
  354.     (
  355.         newMaxCount * sizeof(XMLInt32)
  356.     );//new XMLInt32[newMaxCount];
  358.     for (unsigned int i=0, j=0, k=0; i < fElemCount || j < rangeTok->fElemCount;) {
  360.         if (i >= fElemCount) {
  362.             for (int count = 0; count < 2; count++) {
  363.                 result[k++] = rangeTok->fRanges[j++];
  364.             }
  365.         }
  366.         else if (j >= rangeTok->fElemCount) {
  368.             for (int count = 0; count < 2; count++) {
  369.                 result[k++] = fRanges[i++];
  370.             }
  371.         }
  372.         else if (rangeTok->fRanges[j] < fRanges[i]
  373.                  || (rangeTok->fRanges[j] == fRanges[i]
  374.                      && rangeTok->fRanges[j+1] < fRanges[i+1])) {
  376.             for (int count = 0; count < 2; count++) {
  377.                 result[k++] = rangeTok->fRanges[j++];
  378.             }
  379.         }
  380.         else {
  382.             for (int count = 0; count < 2; count++) {
  384.                 result[k++] = fRanges[i++];
  385.             }
  386.         }
  387.     }
  389.     fMemoryManager->deallocate(fRanges);//delete [] fRanges;
  390.     fElemCount += rangeTok->fElemCount;
  391.     fRanges = result;
  392.     fMaxCount = newMaxCount;
  393. }
  395. void RangeToken::subtractRanges(RangeToken* const tok) {
  397.     if (fRanges == 0 || tok->fRanges == 0)
  398.         return;
  400.     if (tok->getTokenType() == T_NRANGE) {
  402.         intersectRanges(tok);
  403.         return;
  404.     }
  406.     fCaseIToken = 0;
  407.     sortRanges();
  408.     compactRanges();
  409.     tok->sortRanges();
  410.     tok->compactRanges();
  412.     unsigned int newMax = (fElemCount + tok->fElemCount >= fMaxCount)
  413.                              ? fMaxCount + tok->fMaxCount : fMaxCount;
  414.     XMLInt32* result = (XMLInt32*) fMemoryManager->allocate
  415.     (
  416.         newMax * sizeof(XMLInt32)
  417.     );//new XMLInt32[newMax];
  418.     unsigned int newElemCount = 0;
  419.     unsigned int srcCount = 0;
  420.     unsigned int subCount = 0;
  422.     while (srcCount < fElemCount && subCount < tok->fElemCount) {
  424.         XMLInt32 srcBegin = fRanges[srcCount];
  425.         XMLInt32 srcEnd = fRanges[srcCount + 1];
  426.         XMLInt32 subBegin = tok->fRanges[subCount];
  427.         XMLInt32 subEnd = tok->fRanges[subCount + 1];
  429.         if (srcEnd < subBegin) { // no overlap
  431.             result[newElemCount++] = fRanges[srcCount++];
  432.             result[newElemCount++] = fRanges[srcCount++];
  433.         }
  434.         else if (srcEnd >= subBegin && srcBegin <= subEnd) {
  436.             if (subBegin <= srcBegin && srcEnd <= subEnd) {
  437.                 srcCount += 2;
  438.             }
  439.             else if (subBegin <= srcBegin) {
  441.                 fRanges[srcCount] = subEnd + 1;
  442.                 subCount += 2;
  443.             }
  444.             else if (srcEnd <= subEnd) {
  446.                 result[newElemCount++] = srcBegin;
  447.                 result[newElemCount++] = subBegin - 1;
  448.                 srcCount += 2;
  449.             }
  450.             else {
  452.                 result[newElemCount++] = srcBegin;
  453.                 result[newElemCount++] = subBegin - 1;
  454.                 fRanges[srcCount] = subEnd + 1;
  455.                 subCount += 2;
  456.             }
  457.         }
  458.         else if (subEnd < srcBegin) {
  459.             subCount += 2;
  460.         }
  461.         else {
  462.             fMemoryManager->deallocate(result);//delete [] result;
  463.             ThrowXML(RuntimeException, XMLExcepts::Regex_SubtractRangesError);
  464.         }
  465.     } //end while
  467.     while (srcCount < fElemCount) {
  469.         result[newElemCount++] = fRanges[srcCount++];
  470.         result[newElemCount++] = fRanges[srcCount++];
  471.     }
  473.     fMemoryManager->deallocate(fRanges);//delete [] fRanges;
  474.     fRanges = result;
  475.     fElemCount = newElemCount;
  476.     fMaxCount = newMax;
  477. }
  479. /**
  480.   * Ignore whether 'tok' is NRANGE or not.
  481.   */
  482. void RangeToken::intersectRanges(RangeToken* const tok) {
  484.     if (fRanges == 0 || tok->fRanges == 0)
  485.         return;
  487.     fCaseIToken = 0;
  488.     sortRanges();
  489.     compactRanges();
  490.     tok->sortRanges();
  491.     tok->compactRanges();
  493.     unsigned int newMax = (fElemCount + tok->fElemCount >= fMaxCount)
  494.                              ? fMaxCount + tok->fMaxCount : fMaxCount;
  495.     XMLInt32* result = (XMLInt32*) fMemoryManager->allocate
  496.     (
  497.         newMax * sizeof(XMLInt32)
  498.     );//new XMLInt32[newMax];
  499.     unsigned int newElemCount = 0;
  500.     unsigned int srcCount = 0;
  501.     unsigned int tokCount = 0;
  503.     while (srcCount < fElemCount && tokCount < tok->fElemCount) {
  505.         XMLInt32 srcBegin = fRanges[srcCount];
  506.         XMLInt32 srcEnd = fRanges[srcCount + 1];
  507.         XMLInt32 tokBegin = tok->fRanges[tokCount];
  508.         XMLInt32 tokEnd = tok->fRanges[tokCount + 1];
  510.         if (srcEnd < tokBegin) {
  511.             srcCount += 2;
  512.         }
  513.         else if (srcEnd >= tokBegin && srcBegin <= tokEnd) {
  515.             if (tokBegin <= srcBegin && srcEnd <= tokEnd) {
  517.                 result[newElemCount++] = srcBegin;
  518.                 result[newElemCount++] = srcEnd;
  519.                 srcCount += 2;
  520.             }
  521.             else if (tokBegin <= srcBegin) {
  523.                 result[newElemCount++] = srcBegin;
  524.                 result[newElemCount++] = tokEnd;
  525.                 tokCount += 2;
  527.                 if (tokCount < tok->fElemCount)
  528.                     fRanges[srcCount] = tokEnd + 1;
  529.                 else
  530.                     srcCount += 2;
  531.             }
  532.             else if (srcEnd <= tokEnd) {
  534.                 result[newElemCount++] = tokBegin;
  535.                 result[newElemCount++] = srcEnd;
  536.                 srcCount += 2;
  537.             }
  538.             else {
  540.                 result[newElemCount++] = tokBegin;
  541.                 result[newElemCount++] = tokEnd;
  542.                 tokCount += 2;
  544.                 if (tokCount < tok->fElemCount)
  545.                     fRanges[srcCount] = tokEnd + 1;
  546.                 else
  547.                     srcCount += 2;
  548.             }
  549.         }
  550.         else if (tokEnd < srcBegin) {
  551.             tokCount += 2;
  553.             if (tokCount >= tok->fElemCount)
  554.                 srcCount += 2;
  555.         }
  556.         else {
  558.             fMemoryManager->deallocate(result);//delete [] result;
  559.             ThrowXML(RuntimeException, XMLExcepts::Regex_IntersectRangesError);
  560.         }
  561.     } //end while
  563.     fMemoryManager->deallocate(fRanges);//delete [] fRanges;
  564.     fRanges = result;
  565.     fElemCount = newElemCount;
  566.     fMaxCount = newMax;
  567. }
  569. /**
  570.   * for RANGE: Creates complement.
  571.   * for NRANGE: Creates the same meaning RANGE.
  572.   */
  573. Token* RangeToken::complementRanges(RangeToken* const tok,
  574.                                     TokenFactory* const tokFactory) {
  576.     if (tok->getTokenType() != T_RANGE && tok->getTokenType() != T_NRANGE)
  577.         ThrowXML(IllegalArgumentException, XMLExcepts::Regex_ComplementRangesInvalidArg);
  579.     tok->sortRanges();
  580.     tok->compactRanges();
  582.     XMLInt32 lastElem = tok->fRanges[tok->fElemCount - 1];
  583.     RangeToken* rangeTok = tokFactory->createRange();
  585.     if (tok->fRanges[0] > 0) {
  586.         rangeTok->addRange(0, tok->fRanges[0] - 1);
  587.     }
  589.     for (unsigned int i= 1; i< tok->fElemCount - 2; i += 2) {
  590.         rangeTok->addRange(tok->fRanges[i] + 1, tok->fRanges[i+1] - 1);
  591.     }
  593.     if (lastElem != UTF16_MAX) {
  594.         rangeTok->addRange(lastElem + 1, UTF16_MAX);
  595.     }
  597.     rangeTok->fCompacted = true;
  599.     return rangeTok;
  600. }
  603. // ---------------------------------------------------------------------------
  604. //  RangeToken: Match methods
  605. // ---------------------------------------------------------------------------
  606. bool RangeToken::match(const XMLInt32 ch) {
  608.     if (fMap == 0)
  609.         createMap();
  611.     bool ret;
  613.     if (getTokenType() == T_RANGE) {
  615.         if (ch < MAPSIZE)
  616.             return ((fMap[ch/32] & (1<<(ch&0x1f))) != 0);
  618.         ret = false;
  620.         for (unsigned int i= fNonMapIndex; i< fElemCount; i +=2) {
  622.             if (fRanges[i] <= ch && ch <= fRanges[i+1])
  623.                 return true;
  624.         }
  625.     }
  626.     else {
  628.         if (ch < MAPSIZE)
  629.             return ((fMap[ch/32] & (1<<(ch&0x1f))) == 0);
  631.         ret = true;
  633.         for (unsigned int i= fNonMapIndex; i< fElemCount; i += 2) {
  635.             if (fRanges[i] <= ch && ch <= fRanges[i+1])
  636.                 return false;
  637.         }
  638.     }
  640.     return ret;
  641. }
  643. // ---------------------------------------------------------------------------
  644. //  RangeToken: Private helpers methods
  645. // ---------------------------------------------------------------------------
  646. void RangeToken::expand(const unsigned int length) {
  648.     unsigned int newMax = fElemCount + length;
  650.     // Avoid too many reallocations by expanding by a percentage
  651.     unsigned int minNewMax = (unsigned int)((double)fElemCount * 1.25);
  652.     if (newMax < minNewMax)
  653.         newMax = minNewMax;
  655.     XMLInt32* newList = (XMLInt32*) fMemoryManager->allocate
  656.     (
  657.         newMax * sizeof(XMLInt32)
  658.     );//new XMLInt32[newMax];
  659.     for (unsigned int index = 0; index < fElemCount; index++)
  660.         newList[index] = fRanges[index];
  662.     fMemoryManager->deallocate(fRanges);//delete [] fRanges;
  663.     fRanges = newList;
  664.     fMaxCount = newMax;
  665. }
  667. void RangeToken::createMap() {
  669.     int asize = MAPSIZE/32;
  670.     fMap = (int*) fMemoryManager->allocate(asize * sizeof(int));//new int[asize];
  671.     fNonMapIndex = fElemCount;
  673.     for (int i = 0; i < asize; i++) {
  674.         fMap[i] = 0;
  675.     }
  677.     for (unsigned int j= 0; j < fElemCount; j += 2) {
  679.         XMLInt32 begin = fRanges[j];
  680.         XMLInt32 end = fRanges[j+1];
  682.         if (begin < MAPSIZE) {
  684.             for (int k = begin; k <= end && k < MAPSIZE; k++) {
  685.                 fMap[k/32] |= 1<<(k&0x1F);
  686.             }
  687.         }
  688.         else {
  690.             fNonMapIndex = j;
  691.             break;
  692.         }
  694.         if (end >= MAPSIZE) {
  696.             fNonMapIndex = j;
  697.             break;
  698.         }
  699.     }
  700. }
  702. XERCES_CPP_NAMESPACE_END
  704. /**
  705.   * End of file RangeToken.cpp
  706.   */