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

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

词法分析

开发平台：

Visual C++

RegularExpression.cpp：源码内容
  1. /*
  2.  * The Apache Software License, Version 1.1
  3.  *
  4.  * Copyright (c) 2001-2003 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: RegularExpression.cpp,v $
  59.  * Revision 1.13  2003/05/25 21:42:41  knoaman
  60.  * Allocate/Deallocate Context::xxx only when necessary.
  61.  *
  62.  * Revision 1.12  2003/05/18 14:02:06  knoaman
  63.  * Memory manager implementation: pass per instance manager.
  64.  *
  65.  * Revision 1.11  2003/05/16 21:37:00  knoaman
  66.  * Memory manager implementation: Modify constructors to pass in the memory manager.
  67.  *
  68.  * Revision 1.10  2003/05/16 06:01:57  knoaman
  69.  * Partial implementation of the configurable memory manager.
  70.  *
  71.  * Revision 1.9  2003/05/16 00:03:10  knoaman
  72.  * Partial implementation of the configurable memory manager.
  73.  *
  74.  * Revision 1.8  2003/05/15 18:42:54  knoaman
  75.  * Partial implementation of the configurable memory manager.
  76.  *
  77.  * Revision 1.7  2003/05/12 10:08:22  gareth
  78.  * The correct file this time.
  79.  *
  80.  * Revision 1.5  2002/12/18 13:01:02  gareth
  81.  * New functionality - tokenize and replace. Fixed REVISIT for case insensitive match. Patch by Jennifer Schachter.
  82.  *
  83.  * Revision 1.4  2002/11/04 15:17:00  tng
  84.  * C++ Namespace Support.
  85.  *
  86.  * Revision 1.3  2002/10/15 18:56:02  knoaman
  87.  * [Bug 13604] while loop never terminates.
  88.  *
  89.  * Revision 1.2  2002/03/18 19:29:53  knoaman
  90.  * Change constant names to eliminate possible conflict with user defined ones.
  91.  *
  92.  * Revision 1.1.1.1  2002/02/01 22:22:30  peiyongz
  93.  * sane_include
  94.  *
  95.  * Revision 1.6  2002/01/02 20:09:11  knoaman
  96.  * Fix for regular expression patterns that begin with ".".
  97.  *
  98.  * Revision 1.5  2001/10/09 12:20:25  tng
  99.  * Leak fix: Need to delete fMatch if adopted.
  100.  *
  101.  * Revision 1.4  2001/05/11 21:50:58  knoaman
  102.  * Schema updates and fixes.
  103.  *
  104.  * Revision 1.3  2001/05/11 13:26:46  tng
  105.  * Copyright update.
  106.  *
  107.  * Revision 1.2  2001/05/03 18:17:42  knoaman
  108.  * Some design changes:
  109.  * o Changed the TokenFactory from a single static instance, to a
  110.  *    normal class. Each RegularExpression object will have its own
  111.  *    instance of TokenFactory, and that instance will be passed to
  112.  *    other classes that need to use a TokenFactory to create Token
  113.  *    objects (with the exception of RangeTokenMap).
  114.  * o Added a new class RangeTokenMap to map a the different ranges
  115.  *    in a given category to a specific RangeFactory object. In the old
  116.  *    design RangeFactory had dual functionality (act as a Map, and as
  117.  *    a factory for creating RangeToken(s)). The RangeTokenMap will
  118.  *    have its own copy of the TokenFactory. There will be only one
  119.  *    instance of the RangeTokenMap class, and that instance will be
  120.  *    lazily deleted when XPlatformUtils::Terminate is called.
  121.  *
  122.  * Revision 1.1  2001/03/02 19:22:52  knoaman
  123.  * Schema: Regular expression handling part I
  124.  *
  125.  */
  127. // ---------------------------------------------------------------------------
  128. //  Includes
  129. // ---------------------------------------------------------------------------
  130. #include <xercesc/util/regx/RegularExpression.hpp>
  131. #include <xercesc/util/PlatformUtils.hpp>
  132. #include <xercesc/util/regx/RegxUtil.hpp>
  133. #include <xercesc/util/regx/Match.hpp>
  134. #include <xercesc/util/regx/RangeToken.hpp>
  135. #include <xercesc/util/regx/RegxDefs.hpp>
  136. #include <xercesc/util/regx/XMLUniCharacter.hpp>
  137. #include <xercesc/util/regx/ParserForXMLSchema.hpp>
  138. #include <xercesc/util/Janitor.hpp>
  139. #include <xercesc/util/ParseException.hpp>
  140. #include <xercesc/util/IllegalArgumentException.hpp>
  141. #include <xercesc/framework/XMLBuffer.hpp>
  143. XERCES_CPP_NAMESPACE_BEGIN
  145. // ---------------------------------------------------------------------------
  146. //  Static member data initialization
  147. // ---------------------------------------------------------------------------
  148. const unsigned int RegularExpression::MARK_PARENS = 1;
  149. const unsigned int RegularExpression::IGNORE_CASE = 2;
  150. const unsigned int RegularExpression::SINGLE_LINE = 4;
  151. const unsigned int RegularExpression::MULTIPLE_LINE = 8;
  152. const unsigned int RegularExpression::EXTENDED_COMMENT = 16;
  153. const unsigned int RegularExpression::USE_UNICODE_CATEGORY = 32;
  154. const unsigned int RegularExpression::UNICODE_WORD_BOUNDARY = 64;
  155. const unsigned int RegularExpression::PROHIBIT_HEAD_CHARACTER_OPTIMIZATION = 128;
  156. const unsigned int RegularExpression::PROHIBIT_FIXED_STRING_OPTIMIZATION = 256;
  157. const unsigned int RegularExpression::XMLSCHEMA_MODE = 512;
  158. const unsigned int RegularExpression::SPECIAL_COMMA = 1024;
  159. const unsigned short RegularExpression::WT_IGNORE = 0;
  160. const unsigned short RegularExpression::WT_LETTER = 1;
  161. const unsigned short RegularExpression::WT_OTHER = 2;
  162. RangeToken*          RegularExpression::fWordRange = 0;
  164. // ---------------------------------------------------------------------------
  165. //  RegularExpression::Context: Constructors and Destructor
  166. // ---------------------------------------------------------------------------
  167. RegularExpression::Context::Context(MemoryManager* const manager) :
  168.     fInUse(false)
  169. , fAdoptMatch(false)
  170.     , fStart(0)
  171. , fLimit(0)
  172. , fLength(0)
  173. , fSize(0)
  174. , fOffsets(0)
  175. , fMatch(0)
  176. , fString(0)
  177.     , fMemoryManager(manager)
  178. {
  179. }
  181. RegularExpression::Context::~Context()
  182. {
  183. if (fOffsets)
  184.         fMemoryManager->deallocate(fOffsets);//delete [] fOffsets;
  186.     fMemoryManager->deallocate(fString);//delete [] fString;
  188. if (fAdoptMatch)
  189. delete fMatch;
  190. }
  192. // ---------------------------------------------------------------------------
  193. //  RegularExpression::Context: Public methods
  194. // ---------------------------------------------------------------------------
  195. void RegularExpression::Context::reset(const XMLCh* const string
  196.                                        , const int start, const int limit
  197.                                        , const int noClosures)
  198. {
  199.     if (fString)
  200.         fMemoryManager->deallocate(fString);//delete [] fString;
  202.     fString = XMLString::replicate(string, fMemoryManager);
  203. fStart = start;
  204. fLimit = limit;
  205. fLength = fLimit - fStart;
  206. fInUse = true;
  207. if (fAdoptMatch)
  208. delete fMatch;
  209. fMatch = 0;
  212. if (fSize != noClosures) {
  214. if (fOffsets)
  215.             fMemoryManager->deallocate(fOffsets);//delete [] fOffsets;
  216. fOffsets = (int*) fMemoryManager->allocate(noClosures * sizeof(int));//new int[noClosures];
  217. }
  219. fSize = noClosures;
  221. for (int i = 0; i< fSize; i++)
  222. fOffsets[i] = -1;
  223. }
  225. bool RegularExpression::Context::nextCh(XMLInt32& ch, int& offset,
  226. const short direction)
  227. {
  229. ch = fString[offset];
  231. if (RegxUtil::isHighSurrogate(ch)) {
  232. if ((offset + 1 < fLimit) && (direction > 0) &&
  233. RegxUtil::isLowSurrogate(fString[offset+1])) {
  235. ch = RegxUtil::composeFromSurrogate(ch, fString[++offset]);
  236. }
  237. else
  238. return false;
  239. }
  240. else if (RegxUtil::isLowSurrogate(ch)) {
  241. if ((offset - 1 >= 0) && (direction <= 0) &&
  242. RegxUtil::isHighSurrogate(fString[offset-1])) {
  244. ch = RegxUtil::composeFromSurrogate(fString[--offset], ch);
  245. }
  246. else
  247. return false;
  248. }
  250. return true;
  251. }
  253. // ---------------------------------------------------------------------------
  254. //  RegularExpression: Constructors and Destructors
  255. // ---------------------------------------------------------------------------
  256. RegularExpression::RegularExpression(const char* const pattern,
  257.                                      MemoryManager* const manager)
  258. :fHasBackReferences(false),
  259.  fFixedStringOnly(false),
  260.  fNoGroups(0),
  261.  fMinLength(0),
  262.  fNoClosures(0),
  263.  fOptions(0),
  264.  fContext(0),
  265.  fBMPattern(0),
  266.  fPattern(0),
  267.  fFixedString(0),
  268.  fOperations(0),
  269.  fTokenTree(0),
  270.  fFirstChar(0),
  271.      fOpFactory(manager),
  272.      fTokenFactory(0),
  273.      fMemoryManager(manager)
  274. {
  275. try {
  277. XMLCh* tmpBuf = XMLString::transcode(pattern, fMemoryManager);
  278.         ArrayJanitor<XMLCh> janBuf(tmpBuf, fMemoryManager);
  279. setPattern(tmpBuf);
  280. }
  281. catch (...) {
  283. cleanUp();
  284. throw;
  285. }
  286. }
  288. RegularExpression::RegularExpression(const char* const pattern,
  289.  const char* const options,
  290.                                      MemoryManager* const manager)
  291. :fHasBackReferences(false),
  292.  fFixedStringOnly(false),
  293.  fNoGroups(0),
  294.  fMinLength(0),
  295.  fNoClosures(0),
  296.  fOptions(0),
  297.  fContext(0),
  298.  fBMPattern(0),
  299.  fPattern(0),
  300.  fFixedString(0),
  301.  fOperations(0),
  302.  fTokenTree(0),
  303.  fFirstChar(0),
  304.      fOpFactory(manager),
  305.      fTokenFactory(0),
  306.      fMemoryManager(manager)
  307. {
  308. try {
  310. XMLCh* tmpBuf = XMLString::transcode(pattern, fMemoryManager);
  311. ArrayJanitor<XMLCh> janBuf(tmpBuf, fMemoryManager);
  312. XMLCh* tmpOptions = XMLString::transcode(options, fMemoryManager);
  313. ArrayJanitor<XMLCh> janOps(tmpOptions, fMemoryManager);
  314. setPattern(tmpBuf, tmpOptions);
  315. }
  316. catch (...) {
  318. cleanUp();
  319. throw;
  320. }
  321. }
  324. RegularExpression::RegularExpression(const XMLCh* const pattern,
  325.                                      MemoryManager* const manager)
  326. :fHasBackReferences(false),
  327.  fFixedStringOnly(false),
  328.  fNoGroups(0),
  329.  fMinLength(0),
  330.  fNoClosures(0),
  331.  fOptions(0),
  332.  fContext(0),
  333.  fBMPattern(0),
  334.  fPattern(0),
  335.  fFixedString(0),
  336.  fOperations(0),
  337.  fTokenTree(0),
  338.  fFirstChar(0),
  339.      fOpFactory(manager),
  340.      fTokenFactory(0),
  341.      fMemoryManager(manager)
  342. {
  343. try {
  345. setPattern(pattern);
  346. }
  347. catch (...) {
  349. cleanUp();
  350. throw;
  351. }
  352. }
  354. RegularExpression::RegularExpression(const XMLCh* const pattern,
  355.  const XMLCh* const options,
  356.                                      MemoryManager* const manager)
  357. :fHasBackReferences(false),
  358.  fFixedStringOnly(false),
  359.  fNoGroups(0),
  360.  fMinLength(0),
  361.  fNoClosures(0),
  362.  fOptions(0),
  363.  fContext(0),
  364.  fBMPattern(0),
  365.  fPattern(0),
  366.  fFixedString(0),
  367.  fOperations(0),
  368.  fTokenTree(0),
  369.  fFirstChar(0),
  370.      fOpFactory(manager),
  371.      fTokenFactory(0),
  372.      fMemoryManager(manager)
  373. {
  374. try {
  376. setPattern(pattern, options);
  377. }
  378. catch (...) {
  380. cleanUp();
  381. throw;
  382. }
  383. }
  385. RegularExpression::~RegularExpression() {
  387. cleanUp();
  388. }
  390. // ---------------------------------------------------------------------------
  391. //  RegularExpression: Setter methods
  392. // ---------------------------------------------------------------------------
  393. void RegularExpression::setPattern(const XMLCh* const pattern,
  394.    const XMLCh* const options) {
  396.     fTokenFactory = new (fMemoryManager) TokenFactory(fMemoryManager);
  397. fOptions = parseOptions(options);
  398. fPattern = XMLString::replicate(pattern, fMemoryManager);
  400. RegxParser* regxParser = isSet(fOptions, XMLSCHEMA_MODE)
  401. ? new (fMemoryManager) ParserForXMLSchema(fMemoryManager) 
  402.         : new (fMemoryManager) RegxParser(fMemoryManager);
  404.     if (regxParser) {
  405.         regxParser->setTokenFactory(fTokenFactory);
  406.     }
  408. Janitor<RegxParser> janRegxParser(regxParser);
  409. fTokenTree = regxParser->parse(fPattern, fOptions);
  410. fNoGroups = regxParser->getNoParen();
  411. fHasBackReferences = regxParser->hasBackReferences();
  412. }
  414. // ---------------------------------------------------------------------------
  415. //  RegularExpression: Matching methods
  416. // ---------------------------------------------------------------------------
  417. bool RegularExpression::matches(const char* const expression) {
  419.     XMLCh* tmpBuf = XMLString::transcode(expression, fMemoryManager);
  420.     ArrayJanitor<XMLCh> janBuf(tmpBuf, fMemoryManager);
  421. return matches(tmpBuf, 0, XMLString::stringLen(tmpBuf), 0);
  422. }
  424. bool RegularExpression::matches(const char* const expression,
  425. const int start, const int end) {
  427. XMLCh* tmpBuf = XMLString::transcode(expression, fMemoryManager);
  428.     ArrayJanitor<XMLCh> janBuf(tmpBuf, fMemoryManager);
  429. return matches(tmpBuf, start, end, 0);
  430. }
  432. bool RegularExpression::matches(const char* const expression,
  433. Match* const match) {
  435. XMLCh* tmpBuf = XMLString::transcode(expression, fMemoryManager);
  436.     ArrayJanitor<XMLCh> janBuf(tmpBuf, fMemoryManager);
  437. return matches(tmpBuf, 0, XMLString::stringLen(tmpBuf), match);
  438. }
  440. bool RegularExpression::matches(const char* const expression, const int start,
  441.                                 const int end, Match* const pMatch) {
  443. XMLCh* tmpBuf = XMLString::transcode(expression, fMemoryManager);
  444.     ArrayJanitor<XMLCh> janBuf(tmpBuf, fMemoryManager);
  445. return matches(tmpBuf, start, end, pMatch);
  446. }
  449. // ---------------------------------------------------------------------------
  450. //  RegularExpression: Matching methods - Wide char version
  451. // ---------------------------------------------------------------------------
  452. bool RegularExpression::matches(const XMLCh* const expression) {
  454. return matches(expression, 0, XMLString::stringLen(expression), 0);
  455. }
  457. bool RegularExpression::matches(const XMLCh* const expression,
  458. const int start, const int end) {
  460. return matches(expression, start, end, 0);
  461. }
  463. bool RegularExpression::matches(const XMLCh* const expression,
  464. Match* const match) {
  466. return matches(expression, 0, XMLString::stringLen(expression), match);
  467. }
  469. bool RegularExpression::matches(const XMLCh* const expression, const int start,
  470.                                 const int end, Match* const pMatch) {
  472. if (fOperations == 0)
  473. prepare();
  475. Context* context = 0;
  476. Context* tmpContext = 0;
  477. int  strLength = XMLString::stringLen(expression);
  479. {
  480. XMLMutexLock lockInit(&fMutex);
  482. if (fContext == 0)
  483. fContext = new (fMemoryManager) Context(fMemoryManager);
  485. if (fContext->fInUse) {
  486. context = new (fMemoryManager) Context(fMemoryManager);
  487. tmpContext = context;
  488. }
  489. else {
  490. context = fContext;
  491. }
  493. context->reset(expression, start, end, fNoClosures);
  494. }
  496. Janitor<Context> janContext(tmpContext);
  498. bool adoptMatch = false;
  499. Match* lMatch = pMatch;
  501. if (lMatch != 0) {
  502. lMatch->setNoGroups(fNoGroups);
  503. }
  504. else if (fHasBackReferences) {
  506. lMatch = new (fMemoryManager) Match(fMemoryManager);
  507. lMatch->setNoGroups(fNoGroups);
  508. adoptMatch = true;
  509. }
  511. if (context->fAdoptMatch)
  512. delete context->fMatch;
  513.     context->fMatch = lMatch;
  514. context->fAdoptMatch = adoptMatch;
  516. if (isSet(fOptions, XMLSCHEMA_MODE)) {
  518. int matchEnd = match(context, fOperations, context->fStart, 1);
  520. if (matchEnd == context->fLimit) {
  522. if (context->fMatch != 0) {
  524. context->fMatch->setStartPos(0, context->fStart);
  525. context->fMatch->setEndPos(0, matchEnd);
  526. }
  528. context->fInUse = false;
  529. return true;
  530. }
  532. return false;
  533. }
  535. /*
  536.  * If the pattern has only fixed string, use Boyer-Moore
  537.  */
  538. if (fFixedStringOnly) {
  540. int ret = fBMPattern->matches(expression, context->fStart,
  541.                           context->fLimit);
  542. if (ret >= 0) {
  544. if (context->fMatch != 0) {
  545. context->fMatch->setStartPos(0, ret);
  546. context->fMatch->setEndPos(0, ret + strLength);
  547. }
  549. context->fInUse = false;
  550. return true;
  551. }
  552. context->fInUse = false;
  553. return false;
  554. }
  556. /*
  557.  * If the pattern contains a fixed string, we check with Boyer-Moore
  558.  * whether the text contains the fixed string or not. If not found
  559.  * return false
  560.  */
  561. if (fFixedString != 0) {
  563. int ret = fBMPattern->matches(expression, context->fStart,
  564.                                       context->fLimit);
  566. if (ret < 0) { // No match
  568. context->fInUse = false;
  569. return false;
  570. }
  571. }
  573. int limit = context->fLimit - fMinLength;
  574. int matchStart;
  575. int matchEnd = -1;
  577. /*
  578.  * Check whether the expression start with ".*"
  579.  */
  580. if (fOperations != 0 && fOperations->getOpType() == Op::O_CLOSURE
  581.         && fOperations->getChild()->getOpType() == Op::O_DOT) {
  583. if (isSet(fOptions, SINGLE_LINE)) {
  584. matchStart = context->fStart;
  585. matchEnd = match(context, fOperations, matchStart, 1);
  586. }
  587. else {
  588. bool previousIsEOL = true;
  590. for (matchStart=context->fStart; matchStart<=limit; matchStart++) {
  592. XMLCh ch = expression[matchStart];
  593. if (RegxUtil::isEOLChar(ch)) {
  594. previousIsEOL = true;
  595. }
  596. else {
  598. if (previousIsEOL) {
  599. if (0 <= (matchEnd = match(context, fOperations,
  600.                                                    matchStart, 1)))
  601.                             break;
  602. }
  604. previousIsEOL = false;
  605. }
  606. }
  607. }
  608. }
  609. else {
  610.         /*
  611.          * Optimization against the first char
  612.          */
  613. if (fFirstChar != 0) {
  614. bool ignoreCase = isSet(fOptions, IGNORE_CASE);
  615. RangeToken* range = fFirstChar;
  617. if (ignoreCase)
  618. range = fFirstChar->getCaseInsensitiveToken(fTokenFactory);
  620. for (matchStart=context->fStart; matchStart<=limit; matchStart++) {
  622.                 XMLInt32 ch;
  624. if (!context->nextCh(ch, matchStart, 1))
  625. break;
  627. if (!range->match(ch)) {
  629. if (!ignoreCase)
  630. continue;
  632. // Perform case insensitive match
  633. // REVISIT
  634. continue;
  635. }
  637. if (0 <= (matchEnd = match(context,fOperations,matchStart,1)))
  638. break;
  639.             }
  640. }
  641. else {
  643.             /*
  644.              * Straightforward matching
  645.              */
  646. for (matchStart=context->fStart; matchStart<=limit; matchStart++) {
  648. if (0 <= (matchEnd = match(context,fOperations,matchStart,1)))
  649. break;
  650. }
  651. }
  652. }
  654. if (matchEnd >= 0) {
  656. if (context->fMatch != 0) {
  658. context->fMatch->setStartPos(0, matchStart);
  659. context->fMatch->setEndPos(0, matchEnd);
  660. }
  662. context->fInUse = false;
  663. return true;
  664. }
  666. context->fInUse = false;
  667. return false;
  668. }
  670. // ---------------------------------------------------------------------------
  671. //  RegularExpression: Tokenize methods
  672. // ---------------------------------------------------------------------------
  673. RefArrayVectorOf<XMLCh>* RegularExpression::tokenize(const char* const expression) {
  675.   XMLCh* tmpBuf = XMLString::transcode(expression);
  676.   ArrayJanitor<XMLCh> janBuf(tmpBuf);
  677.   return tokenize(tmpBuf, 0, XMLString::stringLen(tmpBuf));
  678. }
  680. RefArrayVectorOf<XMLCh>* RegularExpression::tokenize(const char* const expression,
  681. const int start, const int end) {
  683.   XMLCh* tmpBuf = XMLString::transcode(expression);
  684.   ArrayJanitor<XMLCh> janBuf(tmpBuf);
  685.   return tokenize(tmpBuf, start, end);
  686. }
  690. // ---------------------------------------------------------------------------
  691. //  RegularExpression: Tokenize methods - Wide char version
  692. // ---------------------------------------------------------------------------
  693. RefArrayVectorOf<XMLCh>* RegularExpression::tokenize(const XMLCh* const expression) {
  694.   return tokenize(expression, 0, XMLString::stringLen(expression), 0);
  695. }
  697. RefArrayVectorOf<XMLCh>* RegularExpression::tokenize(const XMLCh* const expression,
  698.                                      const int start, const int end)
  699. {
  700.   return tokenize(expression, start, end, 0);
  701. }
  703. RefArrayVectorOf<XMLCh>* RegularExpression::tokenize(const XMLCh* const expression, 
  704.                                                      const int start, const int end,
  705.                                                      RefVectorOf<Match> *subEx){
  706.   
  707.   if (fOperations == 0)
  708.   prepare();
  710.   RefArrayVectorOf<XMLCh>* tokenStack = new (fMemoryManager) RefArrayVectorOf<XMLCh>(16, true, fMemoryManager);
  712.   Context* context = 0;
  713.   Context* tmpContext = 0;
  715.   int  strLength = XMLString::stringLen(expression);
  716.  
  717.   {
  718.      XMLMutexLock lockInit(&fMutex);
  720.      if (fContext == 0)
  721.        fContext = new (fMemoryManager) Context(fMemoryManager);
  723.      if (fContext->fInUse) {
  724.        context = new (fMemoryManager) Context(fMemoryManager);
  725.        tmpContext = context;
  726.      }
  727.      else {
  728.        context = fContext;
  729.      }
  731.      context->reset(expression, start, end, fNoClosures);
  732.   }
  734.   Janitor<Context> janContext(tmpContext);
  736.   Match* lMatch = 0;
  737.   bool adoptMatch = false;
  739.   if (subEx || fHasBackReferences) {
  740.     lMatch = new (fMemoryManager) Match(fMemoryManager);
  741.     adoptMatch = true;
  742.     lMatch->setNoGroups(fNoGroups);
  743.   }
  745.   if (context->fAdoptMatch)
  746.     delete context->fMatch;
  747.   
  748.   context->fMatch = lMatch;
  749.   context->fAdoptMatch = adoptMatch;
  751.   int tokStart = start;
  752.   int matchStart = start;
  754.   for (; matchStart <= end; matchStart++) { 
  755.   
  756.     int matchEnd = match(context, fOperations, matchStart, 1);
  757.   
  758.     if (matchEnd != -1) {
  760.       if (context->fMatch != 0) {
  761.         context->fMatch->setStartPos(0, context->fStart);
  762.         context->fMatch->setEndPos(0, matchEnd);
  763.       }
  765.       if (subEx){
  766.         subEx->addElement(lMatch);
  767.         lMatch = new (fMemoryManager) Match(*(context->fMatch));
  768.         adoptMatch = true;
  769.         
  770.         context->fAdoptMatch = adoptMatch;
  771.         context->fMatch = lMatch;
  772.       }
  773.   
  774.       context->fInUse = false;
  776.       XMLCh* token;
  777.       if (tokStart == matchStart){
  778.   
  779.         if (tokStart == strLength){
  780.           tokStart--;
  781.           break;  
  782.         }
  784.         token = (XMLCh*) fMemoryManager->allocate(sizeof(XMLCh));//new XMLCh[1];
  785.         token[0] = chNull;
  787.         // When you tokenize using zero string, will return each
  788.         // token in the string. Since the zero string will also 
  789.         // match the start/end characters, resulting in empty 
  790.         // tokens, we ignore them and do not add them to the stack. 
  791.         if (!XMLString::equals(fPattern, &chNull)) 
  792.           tokenStack->addElement(token); 
  793.         else
  794.             fMemoryManager->deallocate(token);//delete[] token;
  796.       } else {
  797.         token = (XMLCh*) fMemoryManager->allocate
  798.         (
  799.             (matchStart + 1 - tokStart) * sizeof(XMLCh)
  800.         );//new XMLCh[matchStart + 1 - tokStart];
  801.         XMLString::subString(token, expression, tokStart, matchStart);
  802.         tokenStack->addElement(token);
  803.       } 
  805.       tokStart = matchEnd;
  807.       //decrement matchStart as will increment it at the top of the loop
  808.       if (matchStart < matchEnd - 1) 
  809.         matchStart = matchEnd - 1;      
  810.     }
  811.   }
  812.  
  813.   XMLCh* token;
  814.  
  815.   if (matchStart == tokStart + 1){
  816.     token = (XMLCh*) fMemoryManager->allocate(sizeof(XMLCh));//new XMLCh[1];
  817.     token[0] = chNull;
  818.   
  819.   } else {
  820.     token = (XMLCh*) fMemoryManager->allocate
  821.     (
  822.         (strLength + 1 - tokStart) * sizeof(XMLCh)
  823.     );//new XMLCh[strLength + 1 - tokStart];
  824.     XMLString::subString(token, expression, tokStart, strLength);
  825.   }  
  827.   if (!XMLString::equals(fPattern, &chNull)) 
  828.     tokenStack->addElement(token);
  829.   else
  830.     fMemoryManager->deallocate(token);//delete[] token;
  832.   return tokenStack;
  834. }
  837. // -----------------------------------------------------------------------
  838. //  RegularExpression: Replace methods
  839. // -----------------------------------------------------------------------
  840. XMLCh* RegularExpression::replace(const char* const matchString, 
  841.                                   const char* const replaceString){
  843. XMLCh* tmpBuf = XMLString::transcode(matchString);
  844.     ArrayJanitor<XMLCh> janBuf(tmpBuf);
  845. XMLCh* tmpBuf2 = XMLString::transcode(replaceString);
  846.     ArrayJanitor<XMLCh> janBuf2(tmpBuf2);
  848. return replace(tmpBuf, tmpBuf2, 0, XMLString::stringLen(tmpBuf));
  849. }
  851. XMLCh* RegularExpression::replace(const char* const matchString, 
  852.                                   const char* const replaceString,
  853.                                   const int start, const int end){
  855.   XMLCh* tmpBuf = XMLString::transcode(matchString);
  856.     ArrayJanitor<XMLCh> janBuf(tmpBuf);
  857.   XMLCh* tmpBuf2 = XMLString::transcode(replaceString);
  858.     ArrayJanitor<XMLCh> janBuf2(tmpBuf2);
  859.   
  860.   return replace(tmpBuf, tmpBuf2, start, end);
  861. }
  864. // ---------------------------------------------------------------------------
  865. //  RegularExpression: Replace methods - Wide char version
  866. // ---------------------------------------------------------------------------
  867. XMLCh* RegularExpression::replace(const XMLCh* const matchString, 
  868.                                   const XMLCh* const replaceString){
  870.   return replace(matchString, replaceString, 0, 
  871.                  XMLString::stringLen(matchString));
  872. }
  874. XMLCh* RegularExpression::replace(const XMLCh* const matchString,  
  875.                                   const XMLCh* const replaceString,
  876.                                   const int start, const int end)
  877. {
  878.   //check if matches zero length string - throw error if so
  879.   if (matches(XMLUni::fgZeroLenString)){
  880. ThrowXML(RuntimeException, XMLExcepts::Regex_RepPatMatchesZeroString);
  881.   }
  882.       
  883.   RefVectorOf<Match> *subEx = new (fMemoryManager) RefVectorOf<Match>(10, true, fMemoryManager);
  884.   Janitor<RefVectorOf<Match> > janSubEx(subEx);
  886.   //Call to tokenize with Match vector so that we keep track of the locations
  887.   //of the subExpression within each of the matches
  888.   RefArrayVectorOf<XMLCh>* tokenStack = tokenize(matchString, start, end, subEx);
  889.   Janitor<RefArrayVectorOf<XMLCh> > janTokStack(tokenStack);
  890.     
  891.   XMLBuffer result(1023, fMemoryManager);
  892.   
  893.   int numSubEx = 0;
  894.   
  895.   if (subEx && subEx->size() > 0)
  896.     numSubEx = subEx->elementAt(0)->getNoGroups() - 1;
  897.   
  898.   int tokStackSize = tokenStack->size();
  899.   const XMLCh* curRepString = XMLString::replicate(replaceString);
  900.     
  901.   for (int i = 0; i < tokStackSize; i++){
  902.       
  903.     result.append(tokenStack->elementAt(i));
  904.   
  905.     if (i != tokStackSize - 1) {
  906.        
  907.       //if there are subExpressions, then determine the string we want to 
  908.       //substitute in.
  909.         if (numSubEx != 0) {
  910.             delete[] (XMLCh*)curRepString;
  911.             curRepString = subInExp(replaceString, matchString, subEx->elementAt(i));     
  912.         }
  913.       result.append(curRepString);
  914.     }
  915.   }  
  916.     
  917.   delete[] (XMLCh*)curRepString;
  918.   return XMLString::replicate(result.getRawBuffer()); 
  919.     
  920. }
  922. // ---------------------------------------------------------------------------
  923. //  RegularExpression: Helpers methods
  924. // ---------------------------------------------------------------------------
  925. int RegularExpression::getOptionValue(const XMLCh ch) {
  927. int ret = 0;
  929. switch (ch) {
  931. case chLatin_i:
  932. ret = IGNORE_CASE;
  933. break;
  934. case chLatin_m:
  935. ret = MULTIPLE_LINE;
  936. break;
  937. case chLatin_s:
  938. ret = SINGLE_LINE;
  939. break;
  940. case chLatin_x:
  941. ret = EXTENDED_COMMENT;
  942. break;
  943. case chLatin_u:
  944. ret = USE_UNICODE_CATEGORY;
  945. break;
  946. case chLatin_w:
  947. ret = UNICODE_WORD_BOUNDARY;
  948. break;
  949. case chLatin_F:
  950. ret = PROHIBIT_FIXED_STRING_OPTIMIZATION;
  951. break;
  952. case chLatin_H:
  953. ret = PROHIBIT_HEAD_CHARACTER_OPTIMIZATION;
  954. break;
  955. case chLatin_X:
  956. ret = XMLSCHEMA_MODE;
  957. break;
  958. case chComma:
  959. ret = SPECIAL_COMMA;
  960. break;
  961. default:
  962. break;
  963. }
  965. return ret;
  966. }
  969. int RegularExpression::match(Context* const context, const Op* const operations
  970.  , int offset, const short direction)
  971. {
  972. const Op* tmpOp = operations;
  973. bool ignoreCase = isSet(fOptions, IGNORE_CASE);
  975. while (true) {
  977. if (tmpOp == 0)
  978. break;
  980. if (offset > context->fLimit || offset < context->fStart)
  981. return -1;
  983. switch(tmpOp->getOpType()) {
  984. case Op::O_CHAR:
  985. if (!matchChar(context, tmpOp->getData(), offset, direction,
  986.    ignoreCase))
  987. return -1;
  988. tmpOp = tmpOp->getNextOp();
  989. break;
  990. case Op::O_DOT:
  991. if (!matchDot(context, offset, direction))
  992. return -1;
  993. tmpOp = tmpOp->getNextOp();
  994. break;
  995. case Op::O_RANGE:
  996. case Op::O_NRANGE:
  997. if (!matchRange(context, tmpOp, offset, direction, ignoreCase))
  998. return -1;
  999. tmpOp = tmpOp->getNextOp();
  1000. break;
  1001. case Op::O_ANCHOR:
  1002. if (!matchAnchor(context, tmpOp->getData(), offset))
  1003. return -1;
  1004. tmpOp = tmpOp->getNextOp();
  1005. break;
  1006. case Op::O_BACKREFERENCE:
  1007. if (!matchBackReference(context, tmpOp->getData(), offset,
  1008. direction, ignoreCase))
  1009. return -1;
  1010. tmpOp = tmpOp->getNextOp();
  1011. break;
  1012. case Op::O_STRING:
  1013. if (!matchString(context, tmpOp->getLiteral(), offset, direction,
  1014.  ignoreCase))
  1015. return -1;
  1016. tmpOp = tmpOp->getNextOp();
  1017. break;
  1018. case Op::O_CLOSURE:
  1019. {
  1020. XMLInt32 id = tmpOp->getData();
  1021. if (id >= 0) {
  1022. int prevOffset = context->fOffsets[id];
  1023. if (prevOffset < 0 || prevOffset != offset) {
  1024. context->fOffsets[id] = offset;
  1025. }
  1026. else {
  1028. context->fOffsets[id] = -1;
  1029. tmpOp = tmpOp->getNextOp();
  1030. break;
  1031. }
  1032. }
  1034. int ret = match(context, tmpOp->getChild(), offset, direction);
  1035. if (id >= 0) {
  1036. context->fOffsets[id] = -1;
  1037. }
  1039. if (ret >= 0)
  1040. return ret;
  1042. tmpOp = tmpOp->getNextOp();
  1043. }
  1044. break;
  1045. case Op::O_QUESTION:
  1046. {
  1047. int ret = match(context, tmpOp->getChild(), offset, direction);
  1048. if (ret >= 0)
  1049. return ret;
  1050. tmpOp = tmpOp->getNextOp();
  1051. }
  1052. break;
  1053. case Op::O_NONGREEDYCLOSURE:
  1054. case Op::O_NONGREEDYQUESTION:
  1055. {
  1056. int ret = match(context,tmpOp->getNextOp(),offset,direction);
  1057. if (ret >= 0)
  1058. return ret;
  1059. tmpOp = tmpOp->getChild();
  1060. }
  1061. break;
  1062. case Op::O_UNION:
  1063. {
  1064. return matchUnion(context, tmpOp, offset, direction);
  1065. }
  1066. case Op::O_CAPTURE:
  1067. if (context->fMatch != 0 && tmpOp->getData() != 0)
  1068. return matchCapture(context, tmpOp, offset, direction);
  1069. tmpOp = tmpOp->getNextOp();
  1070. break;
  1071. case Op::O_LOOKAHEAD:
  1072. if (0 > match(context, tmpOp->getChild(), offset, 1))
  1073. return -1;
  1074. tmpOp = tmpOp->getNextOp();
  1075. break;
  1076. case Op::O_NEGATIVELOOKAHEAD:
  1077. if (0 <= match(context, tmpOp->getChild(), offset, 1))
  1078. return -1;
  1079. tmpOp = tmpOp->getNextOp();
  1080. break;
  1081. case Op::O_LOOKBEHIND:
  1082. if (0 > match(context, tmpOp->getChild(), offset, -1))
  1083. return - 1;
  1084. tmpOp = tmpOp->getNextOp();
  1085. break;
  1086. case Op::O_NEGATIVELOOKBEHIND:
  1087. if (0 <= match(context, tmpOp->getChild(), offset, -1))
  1088. return -1;
  1089. tmpOp = tmpOp->getNextOp();
  1090. break;
  1091. case Op::O_INDEPENDENT:
  1092.         case Op::O_MODIFIER:
  1093. {
  1094. int ret = (tmpOp->getOpType() == Op::O_INDEPENDENT)
  1095.    ? match(context, tmpOp->getChild(), offset, direction)
  1096.                        : matchModifier(context, tmpOp, offset, direction);
  1097.                 if (ret < 0)
  1098.                     return ret;
  1099. offset = ret;
  1100. tmpOp = tmpOp->getNextOp();
  1101. }
  1102. break;
  1103. case Op::O_CONDITION:
  1104. if (tmpOp->getRefNo() >= fNoGroups)
  1105. return -1;
  1106. if (matchCondition(context, tmpOp, offset, direction))
  1107. tmpOp = tmpOp->getYesFlow();
  1108. else
  1109. if (tmpOp->getNoFlow() != 0)
  1110.                     tmpOp = tmpOp->getNoFlow();
  1111.                 else
  1112.                     tmpOp = tmpOp->getNextOp();
  1113. break;
  1114. }
  1115. }
  1117. return offset;
  1118. }
  1119. bool RegularExpression::matchChar(Context* const context,
  1120.   const XMLInt32 ch, int& offset,
  1121.   const short direction, const bool ignoreCase)
  1122. {
  1123. int tmpOffset = direction > 0 ? offset : offset - 1;
  1125. if (tmpOffset >= context->fLimit || tmpOffset < 0)
  1126. return false;
  1128. XMLInt32 strCh = 0;
  1130. if (!context->nextCh(strCh, tmpOffset, direction))
  1131. return false;
  1133. bool match = ignoreCase ? matchIgnoreCase(ch, strCh)
  1134.                     : (ch == strCh);
  1135. if (!match)
  1136. return false;
  1138. offset = (direction > 0) ? ++tmpOffset : tmpOffset;
  1140. return true;
  1141. }
  1143. bool RegularExpression::matchDot(Context* const context, int& offset,
  1144.  const short direction)
  1145. {
  1146. int tmpOffset = direction > 0 ? offset : offset - 1;
  1148. if (tmpOffset >= context->fLimit || tmpOffset < 0)
  1149. return false;
  1151. XMLInt32 strCh = 0;
  1153. if (!context->nextCh(strCh, tmpOffset, direction))
  1154. return false;
  1156. if (!isSet(fOptions, SINGLE_LINE)) {
  1158. if (direction > 0 && RegxUtil::isEOLChar(strCh))
  1159. return false;
  1161. if (direction <= 0 && !RegxUtil::isEOLChar(strCh) )
  1162. return false;
  1163. }
  1165.     offset = (direction > 0) ? ++tmpOffset : tmpOffset;
  1166. return true;
  1167. }
  1169. bool RegularExpression::matchRange(Context* const context, const Op* const op,
  1170.    int& offset, const short direction,
  1171.    const bool ignoreCase)
  1172. {
  1173. int tmpOffset = direction > 0 ? offset : offset - 1;
  1175. if (tmpOffset >= context->fLimit || tmpOffset < 0)
  1176. return false;
  1178. XMLInt32 strCh = 0;
  1180. if (!context->nextCh(strCh, tmpOffset, direction))
  1181. return false;
  1183. RangeToken* tok = (RangeToken *) op->getToken();
  1184. bool match = false;
  1186. if (ignoreCase) {
  1188. //REVISIT we should match ignoring case, but for now
  1189. //we will do a normal match
  1190. //tok = tok->getCaseInsensitiveToken();
  1191. //if (!token->match(strCh)) {
  1193. // if (strCh > 0x10000)
  1194. // return -1;
  1195. // Do case insensitive matching - uppercase match
  1196. // or lowercase match
  1197. //}
  1198. match = tok->match(strCh);
  1199. }
  1200. else
  1201. match = tok->match(strCh);
  1203. if (!match)
  1204. return false;
  1206. offset = (direction > 0) ? ++tmpOffset : tmpOffset;
  1208. return true;
  1209. }
  1211. bool RegularExpression::matchAnchor(Context* const context, const XMLInt32 ch,
  1212. const int offset)
  1213. {
  1214. switch ((XMLCh) ch) {
  1215. case chLatin_A:
  1216. if (offset != context->fStart)
  1217. return false;
  1218. break;
  1219. case chLatin_B:
  1220. if (context->fLength == 0)
  1221. break;
  1222. {
  1223. int after = getWordType(context->fString, context->fStart,
  1224. context->fLimit, offset);
  1225. if (after == WT_IGNORE
  1226. || after == getPreviousWordType(context->fString,
  1227. context->fStart,
  1228. context->fLimit, offset))
  1229. break;
  1230. }
  1231. return false;
  1232. case chLatin_b:
  1233. if (context->fLength == 0)
  1234. return false;
  1235. {
  1236. int after = getWordType(context->fString, context->fStart,
  1237. context->fLimit, offset);
  1238. if (after == WT_IGNORE
  1239. || after == getPreviousWordType(context->fString,
  1240. context->fStart
  1241. , context->fLimit, offset))
  1242. return false;
  1243. }
  1244. break;
  1245. case chLatin_Z:
  1246. case chDollarSign:
  1247. if ( (XMLCh) ch == chDollarSign && isSet(fOptions, MULTIPLE_LINE)) {
  1248. if (!(offset == context->fLimit || (offset < context->fLimit
  1249. && RegxUtil::isEOLChar(context->fString[offset]))))
  1250. return false;
  1251. }
  1252. else {
  1254. if (!(offset == context->fLimit
  1255. || (offset+1 == context->fLimit
  1256.     && RegxUtil::isEOLChar(context->fString[offset]))
  1257. || (offset+2 == context->fLimit
  1258.     && context->fString[offset] == chCR
  1259. && context->fString[offset+1] == chLF)))
  1260. return false;
  1261. }
  1262. break;
  1263. case chLatin_z:
  1264. if (offset != context->fLimit)
  1265. return false;
  1266. break;
  1267. case chAt:
  1268. case chCaret:
  1269. if ( (XMLCh) ch == chCaret && !isSet(fOptions, MULTIPLE_LINE)) {
  1271. if (offset != context->fStart)
  1272. return false;
  1273. }
  1274. else {
  1276. if (!(offset == context->fStart || (offset > context->fStart
  1277.       && RegxUtil::isEOLChar(context->fString[offset-1]))))
  1278. return false;
  1279. }
  1280. break;
  1281. case chOpenAngle:
  1282. if (context->fLength == 0 || offset == context->fLimit)
  1283. return false;
  1285. if (getWordType(context->fString, context->fStart, context->fLimit,
  1286. offset) != WT_LETTER
  1287. || getPreviousWordType(context->fString, context->fStart,
  1288.    context->fLimit, offset) != WT_OTHER)
  1289. return false;
  1290. break;
  1291. case chCloseAngle:
  1292. if (context->fLength == 0 || offset == context->fStart)
  1293. return false;
  1295. if (getWordType(context->fString, context->fStart, context->fLimit,
  1296. offset) != WT_OTHER
  1297. || getPreviousWordType(context->fString, context->fStart,
  1298.    context->fLimit, offset) != WT_LETTER)
  1299. return false;
  1300. break;
  1301. }
  1303. return true;
  1304. }
  1306. bool RegularExpression::matchBackReference(Context* const context,
  1307.    const XMLInt32 refNo, int& offset,
  1308.    const short direction,
  1309.    const bool ignoreCase)
  1310. {
  1311. if (refNo <=0 || refNo >= fNoGroups)
  1312. ThrowXML(IllegalArgumentException, XMLExcepts::Regex_BadRefNo);
  1314. if (context->fMatch->getStartPos(refNo) < 0
  1315. || context->fMatch->getEndPos(refNo) < 0)
  1316. return false;
  1318. int start = context->fMatch->getStartPos(refNo);
  1319. int length = context->fMatch->getEndPos(refNo) - start;
  1320. int tmpOffset = (direction > 0) ? offset : offset - length;
  1322. if (context->fLimit - tmpOffset < length)
  1323. return false;
  1325. bool match = ignoreCase
  1326. ? XMLString::regionIMatches(context->fString,tmpOffset,
  1327. context->fString,start,length)
  1328. : XMLString::regionMatches(context->fString, tmpOffset,
  1329.    context->fString, start,length);
  1331. if (!match)
  1332. return false;
  1334. offset = (direction > 0) ? offset + length : offset - length;
  1335. return true;
  1336. }
  1338. bool RegularExpression::matchString(Context* const context,
  1339. const XMLCh* const literal, int& offset,
  1340. const short direction, const bool ignoreCase)
  1341. {
  1342. int length = XMLString::stringLen(literal);
  1343. int tmpOffset = (direction > 0) ? offset : offset - length;
  1345. if (context->fLimit - tmpOffset < length)
  1346. return false;
  1348. bool match = ignoreCase
  1349. ? XMLString::regionIMatches(context->fString, tmpOffset,
  1350. literal, 0, length)
  1351. : XMLString::regionMatches(context->fString, tmpOffset,
  1352.    literal, 0, length);
  1354. if (match) {
  1355.     offset = direction > 0 ? offset + length : offset - length;
  1356.     }
  1358. return match;
  1359. }
  1361. int RegularExpression::matchCapture(Context* const context, const Op* const op,
  1362.                                     int offset, const short direction)
  1363. {
  1364. // No check is made for nullness of fMatch as the function is only called if
  1365. // fMatch is not null.
  1366. XMLInt32 index = op->getData();
  1367. int save = (index > 0) ? context->fMatch->getStartPos(index)
  1368.                            : context->fMatch->getEndPos(-index);
  1370. if (index > 0) {
  1372. context->fMatch->setStartPos(index, offset);
  1373. int ret = match(context, op->getNextOp(), offset, direction);
  1374. if (ret < 0)
  1375. context->fMatch->setStartPos(index, save);
  1376. return ret;
  1377. }
  1379. context->fMatch->setEndPos(-index, offset);
  1380. int ret = match(context, op->getNextOp(), offset, direction);
  1381. if (ret < 0)
  1382. context->fMatch->setEndPos(-index, save);
  1383. return ret;
  1384. }
  1386. bool RegularExpression::matchCondition(Context* const context,
  1387.                                               const Op* const op, int offset,
  1388.                                               const short direction)
  1389. {
  1391. int refNo = op->getRefNo();
  1392. if ( refNo > 0)
  1393. return (context->fMatch->getStartPos(refNo) >= 0
  1394.                 && context->fMatch->getEndPos(refNo) >= 0);
  1396. return (0 <= match(context, op->getConditionFlow(), offset, direction));
  1397. }
  1399. int RegularExpression::parseOptions(const XMLCh* const options)
  1400. {
  1402. if (options == 0)
  1403. return 0;
  1405. int opts = 0;
  1406. int length = XMLString::stringLen(options);
  1408. for (int i=0; i < length; i++) {
  1410. int v = getOptionValue(options[i]);
  1412. if (v == 0)
  1413. ThrowXML1(ParseException, XMLExcepts::Regex_UnknownOption, options);
  1415. opts |= v;
  1416. }
  1418. return opts;
  1419. }
  1421. void RegularExpression::compile(const Token* const token) {
  1423. if (fOperations != 0)
  1424. return;
  1426. fNoClosures = 0;
  1427. fOperations = compile(token, 0, false);
  1428. }
  1430. Op* RegularExpression::compile(const Token* const token, Op* const next,
  1431.    const bool reverse) {
  1433. Op* ret = 0;
  1435. const unsigned short tokenType = token->getTokenType();
  1437. switch(tokenType) {
  1438. case Token::T_DOT:
  1439. case Token::T_CHAR:
  1440. case Token::T_ANCHOR:
  1441. case Token::T_RANGE:
  1442. case Token::T_NRANGE:
  1443. case Token::T_STRING:
  1444. case Token::T_BACKREFERENCE:
  1445. case Token::T_EMPTY:
  1446. ret = compileSingle(token, next, tokenType);
  1447. break;
  1448. case Token::T_CONCAT:
  1449. ret = compileConcat(token, next, reverse);
  1450. break;
  1451. case Token::T_UNION:
  1452. ret = compileUnion(token, next, reverse);
  1453. break;
  1454. case Token::T_CLOSURE:
  1455. case Token::T_NONGREEDYCLOSURE:
  1456. ret = compileClosure(token, next, reverse, tokenType);
  1457. break;
  1458. case Token::T_PAREN:
  1459. ret = compileParenthesis(token, next, reverse);
  1460. break;
  1461. case Token::T_LOOKAHEAD:
  1462. case Token::T_NEGATIVELOOKAHEAD:
  1463. ret = compileLook(token, next, false, tokenType);
  1464. break;
  1465. case Token::T_LOOKBEHIND:
  1466. case Token::T_NEGATIVELOOKBEHIND:
  1467. ret = compileLook(token, next, true, tokenType);
  1468. break;
  1469. case Token::T_INDEPENDENT:
  1470. case Token::T_MODIFIERGROUP:
  1471. ret = compileLook(token, next, reverse, tokenType);
  1472. break;
  1473. case Token::T_CONDITION:
  1474. ret = compileCondition(token, next, reverse);
  1475. break;
  1476. default:
  1477. ThrowXML(RuntimeException, XMLExcepts::Regex_UnknownTokenType);
  1478. break; // this line to be deleted
  1479. }
  1481. return ret;
  1482. }
  1484. /*
  1485.  * Helper for Replace. This method prepares the replacement string by substituting
  1486.  * in actual values for parenthesized sub expressions. 
  1487.  *
  1488.  * An error will be thrown if:
  1489.  *  1) repString references an undefined subExpression
  1490.  *  2) there is an unescaped chDollar which is not followed by a digit
  1491.  *
  1492.  */
  1493. const XMLCh* RegularExpression::subInExp(const XMLCh* const repString, 
  1494.                                          const XMLCh* const origString, 
  1495.                                          const Match* subEx){
  1497.   int numSubExp = subEx->getNoGroups() - 1;
  1499.   if (numSubExp == 0)
  1500.     return XMLString::replicate(repString);
  1501.   
  1502.   bool notEscaped = true;                 
  1503.   
  1504.   XMLBuffer newString(1023, fMemoryManager);                   
  1505.   
  1506.   XMLCh indexStr[2]; //holds the string rep of a 
  1508.   indexStr[1] = chNull;
  1509.   int index = -1;
  1511.   for (const XMLCh* ptr = repString; *ptr != chNull; ptr++){
  1513.     if ((*ptr == chDollarSign) && notEscaped) {
  1514.       
  1515.       ptr++;
  1516.       
  1517.       //check that after the $ is a digit 
  1518.       if (!XMLString::isDigit(*ptr)){
  1519.        
  1520.         //invalid replace string - $ must be followed by a digit
  1521. ThrowXML(RuntimeException, XMLExcepts::Regex_InvalidRepPattern);
  1522.       }
  1523.         
  1524.       indexStr[0] = *ptr;                     //get the digit 
  1525.       index = XMLString::parseInt(indexStr);  //convert it to an int
  1527.       //now check that the index is legal
  1528.       if (index > numSubExp){
  1529. ThrowXML(RuntimeException, XMLExcepts::Regex_InvalidRepPattern);
  1530.       }
  1531.         
  1532.       int start = subEx->getStartPos(index);
  1533.       int end = subEx->getEndPos(index);
  1535.       //now copy the substring into the new string
  1536.       for (int i=start; i<end; i++){
  1537.         newString.append(origString[i]);
  1538.       }
  1539.           
  1540.     } else {
  1541.  
  1542.       //if you have a slash and then a character that's not a $ or /, 
  1543.       //then it's an invalid replace string  
  1544.       if (!notEscaped && (*ptr != chDollarSign && *ptr != chBackSlash)){
  1545. ThrowXML(RuntimeException, XMLExcepts::Regex_InvalidRepPattern);
  1546.       }
  1547.       
  1548.       if (*ptr == chBackSlash){
  1549.         notEscaped = false;
  1550.         continue;
  1551.         
  1552.       }else   
  1553.         notEscaped = true;  
  1555.       newString.append(*ptr);
  1556.     }
  1557.   }
  1559.   return XMLString::replicate(newString.getRawBuffer());
  1560.        
  1561. }
  1564. /*
  1565.  * Prepares for matching. This method is called just before starting matching
  1566.  */
  1567. void RegularExpression::prepare() {
  1569. XMLMutexLock lockInit(&fMutex);
  1571. compile(fTokenTree);
  1573. fMinLength = fTokenTree->getMinLength();
  1574. fFirstChar = 0;
  1576. if (!isSet(fOptions, PROHIBIT_HEAD_CHARACTER_OPTIMIZATION) &&
  1577. !isSet(fOptions, XMLSCHEMA_MODE)) {
  1579. RangeToken* rangeTok = fTokenFactory->createRange();
  1580. int result = fTokenTree->analyzeFirstCharacter(rangeTok, fOptions, fTokenFactory);
  1582. if (result == Token::FC_TERMINAL) {
  1584. rangeTok->compactRanges();
  1585. fFirstChar = rangeTok;
  1586. }
  1587. }
  1589. if (fOperations != 0 && fOperations->getNextOp() == 0 &&
  1590. (fOperations->getOpType() == Op::O_STRING ||
  1591.  fOperations->getOpType() == Op::O_CHAR) )  {
  1593. fFixedStringOnly = true;
  1595. if (fOperations->getOpType() == Op::O_STRING) {
  1596. fMemoryManager->deallocate(fFixedString);//delete [] fFixedString;
  1597. fFixedString = XMLString::replicate(fOperations->getLiteral(), fMemoryManager);
  1598. }
  1599. else{
  1601. XMLInt32 ch = fOperations->getData();
  1603. if ( ch >= 0x10000) { // add as constant
  1604. fMemoryManager->deallocate(fFixedString);//delete [] fFixedString;
  1605. fFixedString = RegxUtil::decomposeToSurrogates(ch, fMemoryManager);
  1606. }
  1607. else {
  1609. XMLCh* dummyStr = (XMLCh*) fMemoryManager->allocate(2 * sizeof(XMLCh));//new XMLCh[2];
  1610. dummyStr[0] = (XMLCh) fOperations->getData();
  1611. dummyStr[1] = chNull;
  1612. fMemoryManager->deallocate(fFixedString);//delete [] fFixedString;
  1613. fFixedString = dummyStr;
  1614. }
  1615. }
  1617. fBMPattern = new (fMemoryManager) BMPattern(fFixedString, 256,
  1618.   isSet(fOptions, IGNORE_CASE));
  1619. }
  1620. else if (!isSet(fOptions, XMLSCHEMA_MODE) &&
  1621.  !isSet(fOptions, PROHIBIT_FIXED_STRING_OPTIMIZATION)) {
  1623. int fixedOpts = 0;
  1624. Token* tok = fTokenTree->findFixedString(fOptions, fixedOpts);
  1626. fMemoryManager->deallocate(fFixedString);//delete [] fFixedString;
  1628. fFixedString = (tok == 0) ? 0
  1629. : XMLString::replicate(tok->getString(), fMemoryManager);
  1631. if (fFixedString != 0 && XMLString::stringLen(fFixedString) < 2) {
  1633. fMemoryManager->deallocate(fFixedString);//delete [] fFixedString;
  1634. fFixedString = 0;
  1635. }
  1637. if (fFixedString != 0) {
  1639. fBMPattern = new (fMemoryManager) BMPattern(fFixedString, 256,
  1640.    isSet(fixedOpts, IGNORE_CASE));
  1641. }
  1642. }
  1643. }
  1645. unsigned short RegularExpression::getCharType(const XMLCh ch) {
  1647.     if (!isSet(fOptions, UNICODE_WORD_BOUNDARY)) {
  1649. if (isSet(fOptions, USE_UNICODE_CATEGORY)) {
  1651. if (fWordRange == 0) {
  1653. fWordRange = fTokenFactory->getRange(fgUniIsWord);
  1654. if (fWordRange == 0)
  1655. ThrowXML1(RuntimeException, XMLExcepts::Regex_RangeTokenGetError, fgUniIsWord);
  1656. }
  1658. return fWordRange->match(ch) ? WT_LETTER : WT_OTHER;
  1659. }
  1661. return RegxUtil::isWordChar(ch);
  1662.     }
  1664. switch (XMLUniCharacter::getType(ch)) {
  1665. case XMLUniCharacter::UPPERCASE_LETTER:
  1666. case XMLUniCharacter::LOWERCASE_LETTER:
  1667. case XMLUniCharacter::TITLECASE_LETTER:
  1668. case XMLUniCharacter::MODIFIER_LETTER:
  1669. case XMLUniCharacter::OTHER_LETTER:
  1670. case XMLUniCharacter::LETTER_NUMBER:
  1671. case XMLUniCharacter::DECIMAL_DIGIT_NUMBER:
  1672. case XMLUniCharacter::OTHER_NUMBER:
  1673. case XMLUniCharacter::COMBINING_SPACING_MARK:
  1674. return WT_LETTER;
  1675. case XMLUniCharacter::FORMAT:
  1676. case XMLUniCharacter::NON_SPACING_MARK:
  1677. case XMLUniCharacter::ENCLOSING_MARK:
  1678. return WT_IGNORE;
  1679. case XMLUniCharacter::CONTROL:
  1680. switch (ch) {
  1681. case chHTab:
  1682. case chLF:
  1683. case chVTab:
  1684. case chFF:
  1685. case chCR:
  1686. return WT_OTHER;
  1687. default:
  1688. return WT_IGNORE;
  1689. }
  1690. }
  1692.     return WT_OTHER;
  1693. }
  1696. XERCES_CPP_NAMESPACE_END
  1698. /**
  1699.   * End of file RegularExpression.cpp
  1700.   */