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

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

xml/soap/webservice

开发平台：

C/C++

RegularExpression.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: RegularExpression.cpp,v $
  59.  * Revision 1.5  2001/10/09 12:20:25  tng
  60.  * Leak fix: Need to delete fMatch if adopted.
  61.  *
  62.  * Revision 1.4  2001/05/11 21:50:58  knoaman
  63.  * Schema updates and fixes.
  64.  *
  65.  * Revision 1.3  2001/05/11 13:26:46  tng
  66.  * Copyright update.
  67.  *
  68.  * Revision 1.2  2001/05/03 18:17:42  knoaman
  69.  * Some design changes:
  70.  * o Changed the TokenFactory from a single static instance, to a
  71.  *    normal class. Each RegularExpression object will have its own
  72.  *    instance of TokenFactory, and that instance will be passed to
  73.  *    other classes that need to use a TokenFactory to create Token
  74.  *    objects (with the exception of RangeTokenMap).
  75.  * o Added a new class RangeTokenMap to map a the different ranges
  76.  *    in a given category to a specific RangeFactory object. In the old
  77.  *    design RangeFactory had dual functionality (act as a Map, and as
  78.  *    a factory for creating RangeToken(s)). The RangeTokenMap will
  79.  *    have its own copy of the TokenFactory. There will be only one
  80.  *    instance of the RangeTokenMap class, and that instance will be
  81.  *    lazily deleted when XPlatformUtils::Terminate is called.
  82.  *
  83.  * Revision 1.1  2001/03/02 19:22:52  knoaman
  84.  * Schema: Regular expression handling part I
  85.  *
  86.  */
  88. // ---------------------------------------------------------------------------
  89. //  Includes
  90. // ---------------------------------------------------------------------------
  91. #include <util/regx/RegularExpression.hpp>
  92. #include <util/XMLString.hpp>
  93. #include <util/PlatformUtils.hpp>
  94. #include <util/regx/RegxUtil.hpp>
  95. #include <util/regx/Match.hpp>
  96. #include <util/regx/RangeToken.hpp>
  97. #include <util/regx/RegxDefs.hpp>
  98. #include <util/regx/XMLUniCharacter.hpp>
  99. #include <util/regx/ParserForXMLSchema.hpp>
  100. #include <util/Janitor.hpp>
  101. #include <util/ParseException.hpp>
  104. // ---------------------------------------------------------------------------
  105. //  Static member data initialization
  106. // ---------------------------------------------------------------------------
  107. const unsigned int RegularExpression::MARK_PARENS = 1;
  108. const unsigned int RegularExpression::IGNORE_CASE = 2;
  109. const unsigned int RegularExpression::SINGLE_LINE = 4;
  110. const unsigned int RegularExpression::MULTIPLE_LINE = 8;
  111. const unsigned int RegularExpression::EXTENDED_COMMENT = 16;
  112. const unsigned int RegularExpression::USE_UNICODE_CATEGORY = 32;
  113. const unsigned int RegularExpression::UNICODE_WORD_BOUNDARY = 64;
  114. const unsigned int RegularExpression::PROHIBIT_HEAD_CHARACTER_OPTIMIZATION = 128;
  115. const unsigned int RegularExpression::PROHIBIT_FIXED_STRING_OPTIMIZATION = 256;
  116. const unsigned int RegularExpression::XMLSCHEMA_MODE = 512;
  117. const unsigned int RegularExpression::SPECIAL_COMMA = 1024;
  118. const unsigned short RegularExpression::WT_IGNORE = 0;
  119. const unsigned short RegularExpression::WT_LETTER = 1;
  120. const unsigned short RegularExpression::WT_OTHER = 2;
  121. RangeToken*          RegularExpression::fWordRange = 0;
  123. // ---------------------------------------------------------------------------
  124. //  RegularExpression::Context: Constructors and Destructor
  125. // ---------------------------------------------------------------------------
  126. RegularExpression::Context::Context() :
  127.     fInUse(false)
  128. , fAdoptMatch(false)
  129.     , fStart(0)
  130. , fLimit(0)
  131. , fLength(0)
  132. , fSize(0)
  133. , fOffsets(0)
  134. , fMatch(0)
  135. , fString(0)
  136. {
  137. }
  139. RegularExpression::Context::~Context()
  140. {
  141. delete [] fOffsets;
  142.     delete [] fString;
  144. if (fAdoptMatch)
  145. delete fMatch;
  146. }
  148. // ---------------------------------------------------------------------------
  149. //  RegularExpression::Context: Public methods
  150. // ---------------------------------------------------------------------------
  151. void RegularExpression::Context::reset(const XMLCh* const string
  152.                                        , const int start, const int limit
  153.                                        , const int noClosures)
  154. {
  155.     delete [] fString;
  156.     fString = XMLString::replicate(string);
  157. fStart = start;
  158. fLimit = limit;
  159. fLength = fLimit - fStart;
  160. fInUse = true;
  161. if (fAdoptMatch)
  162. delete fMatch;
  163. fMatch = 0;
  165. if (fOffsets == 0 || fSize != noClosures) {
  167. delete [] fOffsets;
  168. fOffsets = new int[noClosures];
  169. }
  171. fSize = noClosures;
  173. for (int i = 0; i< fSize; i++)
  174. fOffsets[i] = -1;
  175. }
  177. bool RegularExpression::Context::nextCh(XMLInt32& ch, int& offset,
  178. const short direction)
  179. {
  181. ch = fString[offset];
  183. if (RegxUtil::isHighSurrogate(ch)) {
  184. if ((offset + 1 < fLimit) && (direction > 0) &&
  185. RegxUtil::isLowSurrogate(fString[offset+1])) {
  187. ch = RegxUtil::composeFromSurrogate(ch, fString[++offset]);
  188. }
  189. else
  190. return false;
  191. }
  192. else if (RegxUtil::isLowSurrogate(ch)) {
  193. if ((offset - 1 >= 0) && (direction <= 0) &&
  194. RegxUtil::isHighSurrogate(fString[offset-1])) {
  196. ch = RegxUtil::composeFromSurrogate(fString[--offset], ch);
  197. }
  198. else
  199. return false;
  200. }
  202. return true;
  203. }
  205. // ---------------------------------------------------------------------------
  206. //  RegularExpression: Constructors and Destructors
  207. // ---------------------------------------------------------------------------
  208. RegularExpression::RegularExpression(const char* const pattern)
  209. :fHasBackReferences(false),
  210.  fFixedStringOnly(false),
  211.  fNoGroups(0),
  212.  fMinLength(0),
  213.  fNoClosures(0),
  214.  fOptions(0),
  215.  fContext(0),
  216.  fBMPattern(0),
  217.  fPattern(0),
  218.  fFixedString(0),
  219.  fOperations(0),
  220.  fTokenTree(0),
  221.  fFirstChar(0),
  222.      fTokenFactory(0)
  223. {
  224. try {
  226. XMLCh* tmpBuf = XMLString::transcode(pattern);
  227.         ArrayJanitor<XMLCh> janBuf(tmpBuf);
  228. setPattern(tmpBuf);
  229. }
  230. catch (...) {
  232. cleanUp();
  233. throw;
  234. }
  235. }
  237. RegularExpression::RegularExpression(const char* const pattern,
  238.  const char* const options)
  239. :fHasBackReferences(false),
  240.  fFixedStringOnly(false),
  241.  fNoGroups(0),
  242.  fMinLength(0),
  243.  fNoClosures(0),
  244.  fOptions(0),
  245.  fContext(0),
  246.  fBMPattern(0),
  247.  fPattern(0),
  248.  fFixedString(0),
  249.  fOperations(0),
  250.  fTokenTree(0),
  251.  fFirstChar(0)
  252. {
  253. try {
  255. XMLCh* tmpBuf = XMLString::transcode(pattern);
  256. ArrayJanitor<XMLCh> janBuf(tmpBuf);
  257. XMLCh* tmpOptions = XMLString::transcode(options);
  258. ArrayJanitor<XMLCh> janOps(tmpOptions);
  259. setPattern(tmpBuf, tmpOptions);
  260. }
  261. catch (...) {
  263. cleanUp();
  264. throw;
  265. }
  266. }
  269. RegularExpression::RegularExpression(const XMLCh* const pattern)
  270. :fHasBackReferences(false),
  271.  fFixedStringOnly(false),
  272.  fNoGroups(0),
  273.  fMinLength(0),
  274.  fNoClosures(0),
  275.  fOptions(0),
  276.  fContext(0),
  277.  fBMPattern(0),
  278.  fPattern(0),
  279.  fFixedString(0),
  280.  fOperations(0),
  281.  fTokenTree(0),
  282.  fFirstChar(0)
  283. {
  284. try {
  286. setPattern(pattern);
  287. }
  288. catch (...) {
  290. cleanUp();
  291. throw;
  292. }
  293. }
  295. RegularExpression::RegularExpression(const XMLCh* const pattern,
  296.  const XMLCh* const options)
  297. :fHasBackReferences(false),
  298.  fFixedStringOnly(false),
  299.  fNoGroups(0),
  300.  fMinLength(0),
  301.  fNoClosures(0),
  302.  fOptions(0),
  303.  fContext(0),
  304.  fBMPattern(0),
  305.  fPattern(0),
  306.  fFixedString(0),
  307.  fOperations(0),
  308.  fTokenTree(0),
  309.  fFirstChar(0)
  310. {
  311. try {
  313. setPattern(pattern, options);
  314. }
  315. catch (...) {
  317. cleanUp();
  318. throw;
  319. }
  320. }
  322. RegularExpression::~RegularExpression() {
  324. cleanUp();
  325. }
  327. // ---------------------------------------------------------------------------
  328. //  RegularExpression: Setter methods
  329. // ---------------------------------------------------------------------------
  330. void RegularExpression::setPattern(const XMLCh* const pattern,
  331.    const XMLCh* const options) {
  333.     fTokenFactory = new TokenFactory();
  334. fOptions = parseOptions(options);
  335. fPattern = XMLString::replicate(pattern);
  337. RegxParser* regxParser = isSet(fOptions, XMLSCHEMA_MODE)
  338. ? new ParserForXMLSchema() : new RegxParser();
  340.     if (regxParser) {
  341.         regxParser->setTokenFactory(fTokenFactory);
  342.     }
  344. Janitor<RegxParser> janRegxParser(regxParser);
  345. fTokenTree = regxParser->parse(fPattern, fOptions);
  346. fNoGroups = regxParser->getNoParen();
  347. fHasBackReferences = regxParser->hasBackReferences();
  348. }
  350. // ---------------------------------------------------------------------------
  351. //  RegularExpression: Matching methods
  352. // ---------------------------------------------------------------------------
  353. bool RegularExpression::matches(const char* const expression) {
  355.     XMLCh* tmpBuf = XMLString::transcode(expression);
  356.     ArrayJanitor<XMLCh> janBuf(tmpBuf);
  357. return matches(tmpBuf, 0, XMLString::stringLen(tmpBuf), 0);
  358. }
  360. bool RegularExpression::matches(const char* const expression,
  361. const int start, const int end) {
  363. XMLCh* tmpBuf = XMLString::transcode(expression);
  364.     ArrayJanitor<XMLCh> janBuf(tmpBuf);
  365. return matches(tmpBuf, start, end, 0);
  366. }
  368. bool RegularExpression::matches(const char* const expression,
  369. Match* const match) {
  371. XMLCh* tmpBuf = XMLString::transcode(expression);
  372.     ArrayJanitor<XMLCh> janBuf(tmpBuf);
  373. return matches(tmpBuf, 0, XMLString::stringLen(tmpBuf), match);
  374. }
  376. bool RegularExpression::matches(const char* const expression, const int start,
  377.                                 const int end, Match* const pMatch) {
  379. XMLCh* tmpBuf = XMLString::transcode(expression);
  380.     ArrayJanitor<XMLCh> janBuf(tmpBuf);
  381. return matches(tmpBuf, start, end, pMatch);
  382. }
  385. // ---------------------------------------------------------------------------
  386. //  RegularExpression: Matching methods - Wide char version
  387. // ---------------------------------------------------------------------------
  388. bool RegularExpression::matches(const XMLCh* const expression) {
  390. return matches(expression, 0, XMLString::stringLen(expression), 0);
  391. }
  393. bool RegularExpression::matches(const XMLCh* const expression,
  394. const int start, const int end) {
  396. return matches(expression, start, end, 0);
  397. }
  399. bool RegularExpression::matches(const XMLCh* const expression,
  400. Match* const match) {
  402. return matches(expression, 0, XMLString::stringLen(expression), match);
  403. }
  405. bool RegularExpression::matches(const XMLCh* const expression, const int start,
  406.                                 const int end, Match* const pMatch) {
  408. if (fOperations == 0)
  409. prepare();
  411. Context* context = 0;
  412. Context* tmpContext = 0;
  413. int  strLength = XMLString::stringLen(expression);
  415. {
  416. XMLMutexLock lockInit(&fMutex);
  418. if (fContext == 0)
  419. fContext = new Context();
  421. if (fContext->fInUse) {
  422. context = new Context();
  423. tmpContext = context;
  424. }
  425. else {
  426. context = fContext;
  427. }
  429. context->reset(expression, start, end, fNoClosures);
  430. }
  432. Janitor<Context> janContext(tmpContext);
  434. bool adoptMatch = false;
  435. Match* lMatch = pMatch;
  437. if (lMatch != 0) {
  438. lMatch->setNoGroups(fNoGroups);
  439. }
  440. else if (fHasBackReferences) {
  442. lMatch = new Match();
  443. lMatch->setNoGroups(fNoGroups);
  444. adoptMatch = true;
  445. }
  447. if (context->fAdoptMatch)
  448. delete context->fMatch;
  449.     context->fMatch = lMatch;
  450. context->fAdoptMatch = adoptMatch;
  452. if (isSet(fOptions, XMLSCHEMA_MODE)) {
  454. int matchEnd = match(context, fOperations, context->fStart, 1);
  456. if (matchEnd == context->fLimit) {
  458. if (context->fMatch != 0) {
  460. context->fMatch->setStartPos(0, context->fStart);
  461. context->fMatch->setEndPos(0, matchEnd);
  462. }
  464. context->fInUse = false;
  465. return true;
  466. }
  468. return false;
  469. }
  471. /*
  472.  * If the pattern has only fixed string, use Boyer-Moore
  473.  */
  474. if (fFixedStringOnly) {
  476. int ret = fBMPattern->matches(expression, context->fStart,
  477.                           context->fLimit);
  478. if (ret >= 0) {
  480. if (context->fMatch != 0) {
  481. context->fMatch->setStartPos(0, ret);
  482. context->fMatch->setEndPos(0, ret + strLength);
  483. }
  485. context->fInUse = false;
  486. return true;
  487. }
  488. context->fInUse = false;
  489. return false;
  490. }
  492. /*
  493.  * If the pattern contains a fixed string, we check with Boyer-Moore
  494.  * whether the text contains the fixed string or not. If not found
  495.  * return false
  496.  */
  497. if (fFixedString != 0) {
  499. int ret = fBMPattern->matches(expression, context->fStart,
  500.                                       context->fLimit);
  502. if (ret < 0) { // No match
  504. context->fInUse = false;
  505. return false;
  506. }
  507. }
  509. int limit = context->fLimit - fMinLength;
  510. int matchStart;
  511. int matchEnd = -1;
  513. /*
  514.  * Check whether the expression start with ".*"
  515.  */
  516. if (fOperations != 0 && fOperations->getOpType() == Op::CLOSURE
  517.         && fOperations->getChild()->getOpType() == Op::DOT) {
  519. if (isSet(fOptions, SINGLE_LINE)) {
  520. matchStart = context->fStart;
  521. matchEnd = match(context, fOperations, matchStart, 1);
  522. }
  523. else {
  524. bool previousIsEOL = true;
  526. for (matchStart=context->fStart; matchStart<=limit; matchStart++) {
  528. XMLCh ch = expression[matchStart];
  529. if (RegxUtil::isEOLChar(ch)) {
  530. previousIsEOL = true;
  531. }
  532. else {
  534. if (previousIsEOL) {
  535. if (0 <= (matchEnd = match(context, fOperations,
  536.                                                    matchStart, 1)))
  537.                             break;
  538. }
  540. previousIsEOL = false;
  541. }
  542. }
  543. }
  544. }
  545. else {
  546.         /*
  547.          * Optimization against the first char
  548.          */
  549. if (fFirstChar != 0) {
  550. bool ignoreCase = isSet(fOptions, IGNORE_CASE);
  551. RangeToken* range = fFirstChar;
  553. if (ignoreCase)
  554. range = fFirstChar->getCaseInsensitiveToken(fTokenFactory);
  556. for (matchStart=context->fStart; matchStart<=limit; matchStart++) {
  558.                 XMLInt32 ch;
  560. if (!context->nextCh(ch, matchStart, 1))
  561. break;
  563. if (!range->match(ch)) {
  565. if (!ignoreCase)
  566. continue;
  568. // Perform case insensitive match
  569. // REVISIT
  570. continue;
  571. }
  573. if (0 <= (matchEnd = match(context,fOperations,matchStart,1)))
  574. break;
  575.             }
  576. }
  577. else {
  579.             /*
  580.              * Straightforward matching
  581.              */
  582. for (matchStart=context->fStart; matchStart<=limit; matchStart++) {
  584. if (0 <= (matchEnd = match(context,fOperations,matchStart,1)))
  585. break;
  586. }
  587. }
  588. }
  590. if (matchEnd >= 0) {
  592. if (context->fMatch != 0) {
  594. context->fMatch->setStartPos(0, matchStart);
  595. context->fMatch->setEndPos(0, matchEnd);
  596. }
  598. context->fInUse = false;
  599. return true;
  600. }
  602. context->fInUse = false;
  603. return false;
  604. }
  606. // ---------------------------------------------------------------------------
  607. //  RegularExpression: Helpers methods
  608. // ---------------------------------------------------------------------------
  609. int RegularExpression::getOptionValue(const XMLCh ch) {
  611. int ret = 0;
  613. switch (ch) {
  615. case chLatin_i:
  616. ret = IGNORE_CASE;
  617. break;
  618. case chLatin_m:
  619. ret = MULTIPLE_LINE;
  620. break;
  621. case chLatin_s:
  622. ret = SINGLE_LINE;
  623. break;
  624. case chLatin_x:
  625. ret = EXTENDED_COMMENT;
  626. break;
  627. case chLatin_u:
  628. ret = USE_UNICODE_CATEGORY;
  629. break;
  630. case chLatin_w:
  631. ret = UNICODE_WORD_BOUNDARY;
  632. break;
  633. case chLatin_F:
  634. ret = PROHIBIT_FIXED_STRING_OPTIMIZATION;
  635. break;
  636. case chLatin_H:
  637. ret = PROHIBIT_HEAD_CHARACTER_OPTIMIZATION;
  638. break;
  639. case chLatin_X:
  640. ret = XMLSCHEMA_MODE;
  641. break;
  642. case chComma:
  643. ret = SPECIAL_COMMA;
  644. break;
  645. default:
  646. break;
  647. }
  649. return ret;
  650. }
  652. int RegularExpression::match(Context* const context, const Op* const operations
  653.  , int offset, const short direction)
  654. {
  655. const Op* tmpOp = operations;
  656. bool ignoreCase = isSet(fOptions, IGNORE_CASE);
  658. while (true) {
  660. if (tmpOp == 0)
  661. break;
  663. if (offset > context->fLimit || offset < context->fStart)
  664. return -1;
  666. switch(tmpOp->getOpType()) {
  667. case Op::CHAR:
  668. if (!matchChar(context, tmpOp->getData(), offset, direction,
  669.    ignoreCase))
  670. return -1;
  671. tmpOp = tmpOp->getNextOp();
  672. break;
  673. case Op::DOT:
  674. if (!matchDot(context, offset, direction))
  675. return -1;
  676. tmpOp = tmpOp->getNextOp();
  677. break;
  678. case Op::RANGE:
  679. case Op::NRANGE:
  680. if (!matchRange(context, tmpOp, offset, direction, ignoreCase))
  681. return -1;
  682. tmpOp = tmpOp->getNextOp();
  683. break;
  684. case Op::ANCHOR:
  685. if (!matchAnchor(context, tmpOp->getData(), offset))
  686. return -1;
  687. tmpOp->getNextOp();
  688. break;
  689. case Op::BACKREFERENCE:
  690. if (!matchBackReference(context, tmpOp->getData(), offset,
  691. direction, ignoreCase))
  692. return -1;
  693. tmpOp->getNextOp();
  694. break;
  695. case Op::STRING:
  696. if (!matchString(context, tmpOp->getLiteral(), offset, direction,
  697.  ignoreCase))
  698. return -1;
  699. tmpOp = tmpOp->getNextOp();
  700. break;
  701. case Op::CLOSURE:
  702. {
  703. XMLInt32 id = tmpOp->getData();
  704. if (id >= 0) {
  705. int prevOffset = context->fOffsets[id];
  706. if (prevOffset < 0 || prevOffset != offset) {
  707. context->fOffsets[id] = offset;
  708. }
  709. else {
  711. context->fOffsets[id] = -1;
  712. tmpOp = tmpOp->getNextOp();
  713. break;
  714. }
  715. }
  717. int ret = match(context, tmpOp->getChild(), offset, direction);
  718. if (id >= 0) {
  719. context->fOffsets[id] = -1;
  720. }
  722. if (ret >= 0)
  723. return ret;
  725. tmpOp = tmpOp->getNextOp();
  726. }
  727. break;
  728. case Op::QUESTION:
  729. {
  730. int ret = match(context, tmpOp->getChild(), offset, direction);
  731. if (ret >= 0)
  732. return ret;
  733. tmpOp = tmpOp->getNextOp();
  734. }
  735. break;
  736. case Op::NONGREEDYCLOSURE:
  737. case Op::NONGREEDYQUESTION:
  738. {
  739. int ret = match(context,tmpOp->getNextOp(),offset,direction);
  740. if (ret >= 0)
  741. return ret;
  742. tmpOp = tmpOp->getChild();
  743. }
  744. break;
  745. case Op::UNION:
  746. {
  747. return matchUnion(context, tmpOp, offset, direction);
  748. }
  749. case Op::CAPTURE:
  750. if (context->fMatch != 0 && tmpOp->getData() != 0)
  751. return matchCapture(context, tmpOp, offset, direction);
  752. tmpOp = tmpOp->getNextOp();
  753. break;
  754. case Op::LOOKAHEAD:
  755. if (0 > match(context, tmpOp->getChild(), offset, 1))
  756. return -1;
  757. tmpOp = tmpOp->getNextOp();
  758. break;
  759. case Op::NEGATIVELOOKAHEAD:
  760. if (0 <= match(context, tmpOp->getChild(), offset, 1))
  761. return -1;
  762. tmpOp = tmpOp->getNextOp();
  763. break;
  764. case Op::LOOKBEHIND:
  765. if (0 > match(context, tmpOp->getChild(), offset, -1))
  766. return - 1;
  767. tmpOp = tmpOp->getNextOp();
  768. break;
  769. case Op::NEGATIVELOOKBEHIND:
  770. if (0 <= match(context, tmpOp->getChild(), offset, -1))
  771. return -1;
  772. tmpOp = tmpOp->getNextOp();
  773. break;
  774. case Op::INDEPENDENT:
  775.         case Op::MODIFIER:
  776. {
  777. int ret = (tmpOp->getOpType() == Op::INDEPENDENT)
  778.    ? match(context, tmpOp->getChild(), offset, direction)
  779.                        : matchModifier(context, tmpOp, offset, direction);
  780.                 if (ret < 0)
  781.                     return ret;
  782. offset = ret;
  783. tmpOp = tmpOp->getNextOp();
  784. }
  785. break;
  786. case Op::CONDITION:
  787. if (tmpOp->getRefNo() >= fNoGroups)
  788. return -1;
  789. if (matchCondition(context, tmpOp, offset, direction))
  790. tmpOp = tmpOp->getYesFlow();
  791. else
  792. if (tmpOp->getNoFlow() != 0)
  793.                     tmpOp = tmpOp->getNoFlow();
  794.                 else
  795.                     tmpOp = tmpOp->getNextOp();
  796. break;
  797. }
  798. }
  800. return offset;
  801. }
  803. bool RegularExpression::matchChar(Context* const context,
  804.   const XMLInt32 ch, int& offset,
  805.   const short direction, const bool ignoreCase)
  806. {
  807. int tmpOffset = direction > 0 ? offset : offset - 1;
  809. if (tmpOffset >= context->fLimit || tmpOffset < 0)
  810. return false;
  812. XMLInt32 strCh = 0;
  814. if (!context->nextCh(strCh, tmpOffset, direction))
  815. return false;
  817. bool match = ignoreCase ? matchIgnoreCase(ch, strCh)
  818.                     : (ch == strCh);
  820. if (!match)
  821. return false;
  823. offset = (direction > 0) ? ++tmpOffset : tmpOffset;
  825. return true;
  826. }
  828. bool RegularExpression::matchDot(Context* const context, int& offset,
  829.  const short direction)
  830. {
  831. int tmpOffset = direction > 0 ? offset : offset - 1;
  833. if (tmpOffset >= context->fLimit || tmpOffset < 0)
  834. return false;
  836. XMLInt32 strCh = 0;
  838. if (!context->nextCh(strCh, tmpOffset, direction))
  839. return false;
  841. if (!isSet(fOptions, SINGLE_LINE)) {
  843. if (direction > 0 && RegxUtil::isEOLChar(strCh))
  844. return false;
  846. if (direction <= 0 && !RegxUtil::isEOLChar(strCh) )
  847. return false;
  848. }
  850.     offset = (direction > 0) ? ++tmpOffset : tmpOffset;
  851. return true;
  852. }
  854. bool RegularExpression::matchRange(Context* const context, const Op* const op,
  855.    int& offset, const short direction,
  856.    const bool ignoreCase)
  857. {
  858. int tmpOffset = direction > 0 ? offset : offset - 1;
  860. if (tmpOffset >= context->fLimit || tmpOffset < 0)
  861. return false;
  863. XMLInt32 strCh = 0;
  865. if (!context->nextCh(strCh, tmpOffset, direction))
  866. return false;
  868. RangeToken* tok = (RangeToken *) op->getToken();
  869. bool match = false;
  871. if (ignoreCase) {
  873. //REVISIT we should match ignoring case, but for now
  874. //we will do a normal match
  875. //tok = tok->getCaseInsensitiveToken();
  876. //if (!token->match(strCh)) {
  878. // if (strCh > 0x10000)
  879. // return -1;
  880. // Do case insensitive matching - uppercase match
  881. // or lowercase match
  882. //}
  883. match = tok->match(strCh);
  884. }
  885. else
  886. match = tok->match(strCh);
  888. if (!match)
  889. return false;
  891. offset = (direction > 0) ? ++tmpOffset : tmpOffset;
  893. return true;
  894. }
  896. bool RegularExpression::matchAnchor(Context* const context, const XMLInt32 ch,
  897. const int offset)
  898. {
  899. switch ((XMLCh) ch) {
  900. case chLatin_A:
  901. if (offset != context->fStart)
  902. return false;
  903. break;
  904. case chLatin_B:
  905. if (context->fLength == 0)
  906. break;
  907. {
  908. int after = getWordType(context->fString, context->fStart,
  909. context->fLimit, offset);
  910. if (after == WT_IGNORE
  911. || after == getPreviousWordType(context->fString,
  912. context->fStart,
  913. context->fLimit, offset))
  914. break;
  915. }
  916. return false;
  917. case chLatin_b:
  918. if (context->fLength == 0)
  919. return false;
  920. {
  921. int after = getWordType(context->fString, context->fStart,
  922. context->fLimit, offset);
  923. if (after == WT_IGNORE
  924. || after == getPreviousWordType(context->fString,
  925. context->fStart
  926. , context->fLimit, offset))
  927. return false;
  928. }
  929. break;
  930. case chLatin_Z:
  931. case chDollarSign:
  932. if ( (XMLCh) ch == chDollarSign && isSet(fOptions, MULTIPLE_LINE)) {
  933. if (!(offset == context->fLimit || (offset < context->fLimit
  934. && RegxUtil::isEOLChar(context->fString[offset]))))
  935. return false;
  936. }
  937. else {
  939. if (!(offset == context->fLimit
  940. || (offset+1 == context->fLimit
  941.     && RegxUtil::isEOLChar(context->fString[offset]))
  942. || (offset+2 == context->fLimit
  943.     && context->fString[offset] == chCR
  944. && context->fString[offset+1] == chLF)))
  945. return false;
  946. }
  947. break;
  948. case chLatin_z:
  949. if (offset != context->fLimit)
  950. return false;
  951. break;
  952. case chAt:
  953. case chCaret:
  954. if ( (XMLCh) ch == chCaret && !isSet(fOptions, MULTIPLE_LINE)) {
  956. if (offset != context->fStart)
  957. return false;
  958. }
  959. else {
  961. if (!(offset == context->fStart || (offset > context->fStart
  962.       && RegxUtil::isEOLChar(context->fString[offset-1]))))
  963. return false;
  964. }
  965. break;
  966. case chOpenAngle:
  967. if (context->fLength == 0 || offset == context->fLimit)
  968. return false;
  970. if (getWordType(context->fString, context->fStart, context->fLimit,
  971. offset) != WT_LETTER
  972. || getPreviousWordType(context->fString, context->fStart,
  973.    context->fLimit, offset) != WT_OTHER)
  974. return false;
  975. break;
  976. case chCloseAngle:
  977. if (context->fLength == 0 || offset == context->fStart)
  978. return false;
  980. if (getWordType(context->fString, context->fStart, context->fLimit,
  981. offset) != WT_OTHER
  982. || getPreviousWordType(context->fString, context->fStart,
  983.    context->fLimit, offset) != WT_LETTER)
  984. return false;
  985. break;
  986. }
  988. return true;
  989. }
  991. bool RegularExpression::matchBackReference(Context* const context,
  992.    const XMLInt32 refNo, int& offset,
  993.    const short direction,
  994.    const bool ignoreCase)
  995. {
  996. if (refNo <=0 || refNo >= fNoGroups)
  997. ThrowXML(IllegalArgumentException, XMLExcepts::Regex_BadRefNo);
  999. if (context->fMatch->getStartPos(refNo) < 0
  1000. || context->fMatch->getEndPos(refNo) < 0)
  1001. return false;
  1003. int start = context->fMatch->getStartPos(refNo);
  1004. int length = context->fMatch->getEndPos(refNo) - start;
  1005. int tmpOffset = (direction > 0) ? offset : offset - length;
  1007. if (context->fLimit - tmpOffset < length)
  1008. return false;
  1010. bool match = ignoreCase
  1011. ? XMLString::regionIMatches(context->fString,tmpOffset,
  1012. context->fString,start,length)
  1013. : XMLString::regionMatches(context->fString, tmpOffset,
  1014.    context->fString, start,length);
  1016. if (!match)
  1017. return false;
  1019. offset = (direction > 0) ? offset + length : offset - length;
  1020. return true;
  1021. }
  1023. bool RegularExpression::matchString(Context* const context,
  1024. const XMLCh* const literal, int& offset,
  1025. const short direction, const bool ignoreCase)
  1026. {
  1027. int length = XMLString::stringLen(literal);
  1028. int tmpOffset = (direction > 0) ? offset : offset - length;
  1030. if (context->fLimit - tmpOffset < length)
  1031. return false;
  1033. bool match = ignoreCase
  1034. ? XMLString::regionIMatches(context->fString, tmpOffset,
  1035. literal, 0, length)
  1036. : XMLString::regionMatches(context->fString, tmpOffset,
  1037.    literal, 0, length);
  1039. if (match) {
  1040.     offset = direction > 0 ? offset + length : offset - length;
  1041.     }
  1043. return match;
  1044. }
  1046. int RegularExpression::matchCapture(Context* const context, const Op* const op,
  1047.                                     int offset, const short direction)
  1048. {
  1049. // No check is made for nullness of fMatch as the function is only called if
  1050. // fMatch is not null.
  1051. XMLInt32 index = op->getData();
  1052. int save = (index > 0) ? context->fMatch->getStartPos(index)
  1053.                            : context->fMatch->getEndPos(-index);
  1055. if (index > 0) {
  1057. context->fMatch->setStartPos(index, offset);
  1058. int ret = match(context, op->getNextOp(), offset, direction);
  1059. if (ret < 0)
  1060. context->fMatch->setStartPos(index, save);
  1061. return ret;
  1062. }
  1064. context->fMatch->setEndPos(-index, offset);
  1065. int ret = match(context, op->getNextOp(), offset, direction);
  1066. if (ret < 0)
  1067. context->fMatch->setEndPos(-index, save);
  1068. return ret;
  1069. }
  1071. bool RegularExpression::matchCondition(Context* const context,
  1072.                                               const Op* const op, int offset,
  1073.                                               const short direction)
  1074. {
  1076. int refNo = op->getRefNo();
  1077. if ( refNo > 0)
  1078. return (context->fMatch->getStartPos(refNo) >= 0
  1079.                 && context->fMatch->getEndPos(refNo) >= 0);
  1081. return (0 <= match(context, op->getConditionFlow(), offset, direction));
  1082. }
  1084. int RegularExpression::parseOptions(const XMLCh* const options)
  1085. {
  1087. if (options == 0)
  1088. return 0;
  1090. int opts = 0;
  1091. int length = XMLString::stringLen(options);
  1093. for (int i=0; i < length; i++) {
  1095. int v = getOptionValue(options[i]);
  1097. if (v == 0)
  1098. ThrowXML1(ParseException, XMLExcepts::Regex_UnknownOption, options);
  1100. opts |= v;
  1101. }
  1103. return opts;
  1104. }
  1106. void RegularExpression::compile(const Token* const token) {
  1108. if (fOperations != 0)
  1109. return;
  1111. fNoClosures = 0;
  1112. fOperations = compile(token, 0, false);
  1113. }
  1115. Op* RegularExpression::compile(const Token* const token, Op* const next,
  1116.    const bool reverse) {
  1118. Op* ret = 0;
  1120. const unsigned short tokenType = token->getTokenType();
  1122. switch(tokenType) {
  1123. case Token::DOT:
  1124. case Token::CHAR:
  1125. case Token::ANCHOR:
  1126. case Token::RANGE:
  1127. case Token::NRANGE:
  1128. case Token::STRING:
  1129. case Token::BACKREFERENCE:
  1130. case Token::EMPTY:
  1131. ret = compileSingle(token, next, tokenType);
  1132. break;
  1133. case Token::CONCAT:
  1134. ret = compileConcat(token, next, reverse);
  1135. break;
  1136. case Token::UNION:
  1137. ret = compileUnion(token, next, reverse);
  1138. break;
  1139. case Token::CLOSURE:
  1140. case Token::NONGREEDYCLOSURE:
  1141. ret = compileClosure(token, next, reverse, tokenType);
  1142. break;
  1143. case Token::PAREN:
  1144. ret = compileParenthesis(token, next, reverse);
  1145. break;
  1146. case Token::LOOKAHEAD:
  1147. case Token::NEGATIVELOOKAHEAD:
  1148. ret = compileLook(token, next, false, tokenType);
  1149. break;
  1150. case Token::LOOKBEHIND:
  1151. case Token::NEGATIVELOOKBEHIND:
  1152. ret = compileLook(token, next, true, tokenType);
  1153. break;
  1154. case Token::INDEPENDENT:
  1155. case Token::MODIFIERGROUP:
  1156. ret = compileLook(token, next, reverse, tokenType);
  1157. break;
  1158. case Token::CONDITION:
  1159. ret = compileCondition(token, next, reverse);
  1160. break;
  1161. default:
  1162. ThrowXML(RuntimeException, XMLExcepts::Regex_UnknownTokenType);
  1163. break; // this line to be deleted
  1164. }
  1166. return ret;
  1167. }
  1169. /*
  1170.  * Prepares for matching. This method is called just before starting matching
  1171.  */
  1172. void RegularExpression::prepare() {
  1174. XMLMutexLock lockInit(&fMutex);
  1176. compile(fTokenTree);
  1178. if (fOperations->getOpType() == Op::CLOSURE &&
  1179. fOperations->getChild()->getOpType() == Op::DOT) {
  1181. Op* anchor = fOpFactory.createAnchorOp(isSet(fOptions, SINGLE_LINE) ? chLatin_A
  1182.  : chAt);
  1183. anchor->setNextOp(fOperations);
  1184. fOperations = anchor;
  1185. }
  1187. fMinLength = fTokenTree->getMinLength();
  1188. fFirstChar = 0;
  1190. if (!isSet(fOptions, PROHIBIT_HEAD_CHARACTER_OPTIMIZATION) &&
  1191. !isSet(fOptions, XMLSCHEMA_MODE)) {
  1193. RangeToken* rangeTok = fTokenFactory->createRange();
  1194. int result = fTokenTree->analyzeFirstCharacter(rangeTok, fOptions, fTokenFactory);
  1196. if (result == Token::FC_TERMINAL) {
  1198. rangeTok->compactRanges();
  1199. fFirstChar = rangeTok;
  1200. }
  1201. }
  1203. if (fOperations != 0 && fOperations->getNextOp() == 0 &&
  1204. (fOperations->getOpType() == Op::STRING ||
  1205.  fOperations->getOpType() == Op::CHAR) )  {
  1207. fFixedStringOnly = true;
  1209. if (fOperations->getOpType() == Op::STRING) {
  1210. delete [] fFixedString;
  1211. fFixedString = XMLString::replicate(fOperations->getLiteral());
  1212. }
  1213. else{
  1215. XMLInt32 ch = fOperations->getData();
  1217. if ( ch >= 0x10000) { // add as constant
  1218. delete [] fFixedString;
  1219. fFixedString = RegxUtil::decomposeToSurrogates(ch);
  1220. }
  1221. else {
  1223. XMLCh* dummyStr = new XMLCh[2];
  1224. dummyStr[0] = (XMLCh) fOperations->getData();
  1225. dummyStr[1] = chNull;
  1226. delete [] fFixedString;
  1227. fFixedString = dummyStr;
  1228. }
  1229. }
  1231. fBMPattern = new BMPattern(fFixedString, 256,
  1232.   isSet(fOptions, IGNORE_CASE));
  1233. }
  1234. else if (!isSet(fOptions, XMLSCHEMA_MODE) &&
  1235.  !isSet(fOptions, PROHIBIT_FIXED_STRING_OPTIMIZATION)) {
  1237. int fixedOpts = 0;
  1238. Token* tok = fTokenTree->findFixedString(fOptions, fixedOpts);
  1240. delete [] fFixedString;
  1242. fFixedString = (tok == 0) ? 0
  1243. : XMLString::replicate(tok->getString());
  1245. if (fFixedString != 0 && XMLString::stringLen(fFixedString) < 2) {
  1247. delete [] fFixedString;
  1248. fFixedString = 0;
  1249. }
  1251. if (fFixedString != 0) {
  1253. fBMPattern = new BMPattern(fFixedString, 256,
  1254.    isSet(fixedOpts, IGNORE_CASE));
  1255. }
  1256. }
  1257. }
  1259. unsigned short RegularExpression::getCharType(const XMLCh ch) {
  1261.     if (!isSet(fOptions, UNICODE_WORD_BOUNDARY)) {
  1263. if (isSet(fOptions, USE_UNICODE_CATEGORY)) {
  1265. if (fWordRange == 0) {
  1267. fWordRange = fTokenFactory->getRange(fgUniIsWord);
  1268. if (fWordRange == 0)
  1269. ThrowXML1(RuntimeException, XMLExcepts::Regex_RangeTokenGetError, fgUniIsWord);
  1270. }
  1272. return fWordRange->match(ch) ? WT_LETTER : WT_OTHER;
  1273. }
  1275. return RegxUtil::isWordChar(ch);
  1276.     }
  1278. switch (XMLUniCharacter::getType(ch)) {
  1279. case XMLUniCharacter::UPPERCASE_LETTER:
  1280. case XMLUniCharacter::LOWERCASE_LETTER:
  1281. case XMLUniCharacter::TITLECASE_LETTER:
  1282. case XMLUniCharacter::MODIFIER_LETTER:
  1283. case XMLUniCharacter::OTHER_LETTER:
  1284. case XMLUniCharacter::LETTER_NUMBER:
  1285. case XMLUniCharacter::DECIMAL_DIGIT_NUMBER:
  1286. case XMLUniCharacter::OTHER_NUMBER:
  1287. case XMLUniCharacter::COMBINING_SPACING_MARK:
  1288. return WT_LETTER;
  1289. case XMLUniCharacter::FORMAT:
  1290. case XMLUniCharacter::NON_SPACING_MARK:
  1291. case XMLUniCharacter::ENCLOSING_MARK:
  1292. return WT_IGNORE;
  1293. case XMLUniCharacter::CONTROL:
  1294. switch (ch) {
  1295. case chHTab:
  1296. case chLF:
  1297. case chVTab:
  1298. case chFF:
  1299. case chCR:
  1300. return WT_OTHER;
  1301. default:
  1302. return WT_IGNORE;
  1303. }
  1304. }
  1306.     return WT_OTHER;
  1307. }
  1309. /**
  1310.   * End of file RegularExpression.cpp
  1311.   */