source: icXML/icXML-devel/src/xercesc/util/regx/RegxParser.cpp @ 2722

Last change on this file since 2722 was 2722, checked in by cameron, 6 years ago

Original Xerces files with import mods for icxercesc

File size: 24.5 KB
Line 
1/*
2 * Licensed to the Apache Software Foundation (ASF) under one or more
3 * contributor license agreements.  See the NOTICE file distributed with
4 * this work for additional information regarding copyright ownership.
5 * The ASF licenses this file to You under the Apache License, Version 2.0
6 * (the "License"); you may not use this file except in compliance with
7 * the License.  You may obtain a copy of the License at
8 *
9 *      http://www.apache.org/licenses/LICENSE-2.0
10 *
11 * Unless required by applicable law or agreed to in writing, software
12 * distributed under the License is distributed on an "AS IS" BASIS,
13 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14 * See the License for the specific language governing permissions and
15 * limitations under the License.
16 */
17
18/*
19 * $Id: RegxParser.cpp 834826 2009-11-11 10:03:53Z borisk $
20 */
21
22// ---------------------------------------------------------------------------
23//  Includes
24// ---------------------------------------------------------------------------
25#include <xercesc/util/regx/RegxParser.hpp>
26#include <icxercesc/util/XMLString.hpp>
27#include <xercesc/util/ParseException.hpp>
28#include <icxercesc/util/regx/RegularExpression.hpp>
29#include <xercesc/util/regx/RegxUtil.hpp>
30#include <xercesc/util/regx/RegxDefs.hpp>
31#include <xercesc/util/regx/TokenInc.hpp>
32#include <xercesc/framework/XMLErrorCodes.hpp>
33
34XERCES_CPP_NAMESPACE_BEGIN
35
36// ---------------------------------------------------------------------------
37//  RegxParser::ReferencePostion: Constructors and Destructor
38// ---------------------------------------------------------------------------
39RegxParser::ReferencePosition::ReferencePosition(const int refNo,
40                                                 const XMLSize_t position)
41    :fReferenceNo(refNo)
42    , fPosition(position)
43{
44
45}
46
47// ---------------------------------------------------------------------------
48//  RegxParser: Constructors and Destructors
49// ---------------------------------------------------------------------------
50RegxParser::RegxParser(MemoryManager* const manager)
51    :fMemoryManager(manager),
52     fHasBackReferences(false),
53     fOptions(0),
54     fOffset(0),
55     fNoGroups(1),
56     fParseContext(regexParserStateNormal),
57     fStringLen(0),
58     fState(REGX_T_EOF),
59     fCharData(0),
60     fString(0),
61     fReferences(0),
62     fTokenFactory(0)
63{
64}
65
66RegxParser::~RegxParser() {
67
68    fMemoryManager->deallocate(fString);//delete [] fString;
69    delete fReferences;
70}
71
72// ---------------------------------------------------------------------------
73//  RegxParser: Parsing methods
74// ---------------------------------------------------------------------------
75Token* RegxParser::parse(const XMLCh* const regxStr, const int options) {
76
77    // if TokenFactory is not set do nothing.
78    // REVISIT - should we throw an exception
79    if (fTokenFactory == 0) {
80        return 0;
81    }
82
83    fOptions = options;
84    fOffset = 0;
85    fNoGroups = 1;
86    fHasBackReferences = false;
87    setParseContext(regexParserStateNormal);
88    if (fString)
89        fMemoryManager->deallocate(fString);//delete [] fString;
90    fString = XMLString::replicate(regxStr, fMemoryManager);
91
92    if (isSet(RegularExpression::EXTENDED_COMMENT)) {
93
94        if (fString)
95            fMemoryManager->deallocate(fString);//delete [] fString;
96        fString = RegxUtil::stripExtendedComment(regxStr, fMemoryManager);
97    }
98
99    fStringLen = XMLString::stringLen(fString);
100    processNext();
101
102    Token* retTok = parseRegx();
103
104    if (fOffset != fStringLen) {
105        XMLCh value1[65];
106        XMLString::sizeToText(fOffset, value1, 64, 10, fMemoryManager);
107        ThrowXMLwithMemMgr2(ParseException,XMLExcepts::Parser_Parse1, value1, fString, fMemoryManager);
108    }
109
110    if (fReferences != 0) {
111
112        XMLSize_t refSize = fReferences->size();
113        for (XMLSize_t i = 0; i < refSize; i++) {
114
115            if (fNoGroups <= fReferences->elementAt(i)->fReferenceNo) {
116                ThrowXMLwithMemMgr(ParseException,XMLExcepts::Parser_Parse2, fMemoryManager);
117            }
118        }
119
120        fReferences->removeAllElements();
121    }
122
123    return retTok;
124}
125
126
127void RegxParser::processNext() {
128
129    if (fOffset >= fStringLen) {
130
131        fCharData = -1;
132        fState = REGX_T_EOF;
133        return;
134    }
135
136    parserState nextState;
137    XMLCh ch = fString[fOffset++];
138    fCharData = ch;
139
140    if (fParseContext == regexParserStateInBrackets) {
141
142        switch (ch) {
143        case chBackSlash:
144            nextState = REGX_T_BACKSOLIDUS;
145
146            if (fOffset >= fStringLen) {
147                ThrowXMLwithMemMgr(ParseException,XMLExcepts::Parser_Next1, fMemoryManager);
148            }
149
150            fCharData = fString[fOffset++];
151            break;
152        case chDash:
153            if (fOffset < fStringLen && fString[fOffset] == chOpenSquare) {
154
155                fOffset++;
156                nextState = REGX_T_XMLSCHEMA_CC_SUBTRACTION;
157            }
158            else {
159                nextState = REGX_T_CHAR;
160            }
161            break;
162        default:
163            if (RegxUtil::isHighSurrogate(ch) && fOffset < fStringLen) {
164
165                XMLCh lowCh = fString[fOffset];
166                if (RegxUtil::isLowSurrogate(lowCh)) {
167                    fCharData = RegxUtil::composeFromSurrogate(ch, lowCh);
168                    fOffset++;
169                }
170                else {
171                    throw XMLErrs::Expected2ndSurrogateChar;
172                }
173            }
174
175            nextState = REGX_T_CHAR;
176        }
177
178        fState = nextState;
179        return;
180    }
181
182    switch (ch) {
183
184    case chPipe:
185        nextState = REGX_T_OR;
186        break;
187    case chAsterisk:
188        nextState = REGX_T_STAR;
189        break;
190    case chPlus:
191        nextState = REGX_T_PLUS;
192        break;
193    case chQuestion:
194        nextState = REGX_T_QUESTION;
195        break;
196    case chCloseParen:
197        nextState = REGX_T_RPAREN;
198        break;
199    case chPeriod:
200        nextState = REGX_T_DOT;
201        break;
202    case chOpenSquare:
203        nextState = REGX_T_LBRACKET;
204        break;
205    case chCaret:
206        nextState = REGX_T_CARET;
207        break;
208    case chDollarSign:
209        nextState = REGX_T_DOLLAR;
210        break;
211    case chOpenParen:
212        nextState = REGX_T_LPAREN;
213        break;
214    case chBackSlash:
215        nextState = REGX_T_BACKSOLIDUS;
216        if (fOffset >= fStringLen) {
217            ThrowXMLwithMemMgr(ParseException,XMLExcepts::Parser_Next1, fMemoryManager);
218        }
219
220        fCharData = fString[fOffset++];
221        break;
222    default:
223        nextState = REGX_T_CHAR;
224        if (RegxUtil::isHighSurrogate(ch) && fOffset < fStringLen) {
225
226                XMLCh lowCh = fString[fOffset];
227                if (RegxUtil::isLowSurrogate(lowCh)) {
228                    fCharData = RegxUtil::composeFromSurrogate(ch, lowCh);
229                    fOffset++;
230                }
231                else {
232                    throw XMLErrs::Expected2ndSurrogateChar;
233                }
234            }
235    }
236
237    fState = nextState;
238}
239
240
241Token* RegxParser::parseRegx(const bool matchingRParen) {
242
243    Token* tok = parseTerm(matchingRParen);
244    Token* parentTok = 0;
245
246    while (fState == REGX_T_OR) {
247
248        processNext();
249        if (parentTok == 0) {
250
251            parentTok = fTokenFactory->createUnion();
252            parentTok->addChild(tok, fTokenFactory);
253            tok = parentTok;
254        }
255
256        tok->addChild(parseTerm(matchingRParen), fTokenFactory);
257    }
258
259    return tok;
260}
261
262
263Token* RegxParser::parseTerm(const bool matchingRParen) {
264
265    parserState state = fState;
266
267    if (state == REGX_T_OR || state == REGX_T_EOF
268        || (state == REGX_T_RPAREN && matchingRParen)) {
269        return fTokenFactory->createToken(Token::T_EMPTY);
270    }
271    else {
272
273        Token* tok = parseFactor();
274        Token* concatTok = 0;
275
276        while ((state = fState) != REGX_T_OR && state != REGX_T_EOF
277               && (state != REGX_T_RPAREN || !matchingRParen))
278        {
279            if (concatTok == 0) {
280
281                concatTok = fTokenFactory->createUnion(true);
282                concatTok->addChild(tok, fTokenFactory);
283                tok = concatTok;
284            }
285            concatTok->addChild(parseFactor(), fTokenFactory);
286        }
287
288        return tok;
289    }
290}
291
292
293Token* RegxParser::processCaret() {
294
295    processNext();
296    return fTokenFactory->getLineBegin();
297}
298
299
300Token* RegxParser::processDollar() {
301
302    processNext();
303    return fTokenFactory->getLineEnd();
304}
305
306
307Token* RegxParser::processStar(Token* const tok) {
308
309    processNext();
310
311    if (fState == REGX_T_QUESTION) {
312        processNext();
313        return fTokenFactory->createClosure(tok, true);
314    }
315
316    return fTokenFactory->createClosure(tok);
317}
318
319
320Token* RegxParser::processPlus(Token* const tok) {
321
322    processNext();
323
324    if (fState == REGX_T_QUESTION) {
325        processNext();
326        return fTokenFactory->createConcat(tok,
327                           fTokenFactory->createClosure(tok,true));
328    }
329
330    return fTokenFactory->createConcat(tok,
331                                fTokenFactory->createClosure(tok));
332}
333
334
335Token* RegxParser::processQuestion(Token* const tok) {
336
337    processNext();
338
339    Token* parentTok = fTokenFactory->createUnion();
340
341    if (fState == REGX_T_QUESTION) {
342        processNext();
343        parentTok->addChild(fTokenFactory->createToken(Token::T_EMPTY), fTokenFactory);
344        parentTok->addChild(tok, fTokenFactory);
345    }
346    else {
347        parentTok->addChild(tok, fTokenFactory);
348        parentTok->addChild(fTokenFactory->createToken(Token::T_EMPTY), fTokenFactory);
349    }
350
351    return parentTok;
352}
353
354
355Token* RegxParser::processParen() {
356
357    processNext();
358    int num = fNoGroups++;
359    Token* tok = fTokenFactory->createParenthesis(parseRegx(true),num);
360
361    if (fState != REGX_T_RPAREN)
362        ThrowXMLwithMemMgr(ParseException,XMLExcepts::Parser_Factor1, fMemoryManager);
363
364    processNext();
365    return tok;
366}
367
368
369Token* RegxParser::processBackReference() {
370
371    XMLSize_t position = fOffset - 2;
372
373    // Handle multi digit back references
374    int refNo = fCharData - chDigit_0;
375    while(true) {
376        processNext();
377        if(fState != REGX_T_CHAR || fCharData < chDigit_0 || fCharData > chDigit_9)
378            break;
379
380        int nextRefNo = (refNo * 10) + fCharData - chDigit_0;
381        if(nextRefNo >= fNoGroups)
382            break;
383
384        refNo = nextRefNo;
385    }
386
387    Token* tok = fTokenFactory->createBackReference(refNo);
388
389    fHasBackReferences = true;
390    if (fReferences == 0) {
391        fReferences = new (fMemoryManager) RefVectorOf<ReferencePosition>(8, true, fMemoryManager);
392    }
393
394    fReferences->addElement(new (fMemoryManager) ReferencePosition(refNo, position));
395    return tok;
396}
397
398
399Token* RegxParser::parseFactor() {
400
401    Token* tok = parseAtom();
402
403    switch(fState) {
404
405    case REGX_T_STAR:
406        return processStar(tok);
407    case REGX_T_PLUS:
408        return processPlus(tok);
409    case REGX_T_QUESTION:
410        return processQuestion(tok);
411    case REGX_T_CHAR:
412        if (fCharData == chOpenCurly && fOffset < fStringLen) {
413
414            int min = 0;
415            int max = -1;
416            XMLInt32 ch = fString[fOffset++];
417
418            if (ch >= chDigit_0 && ch <= chDigit_9) {
419
420                min = ch - chDigit_0;
421                while (fOffset < fStringLen
422                       && (ch = fString[fOffset++]) >= chDigit_0
423                       && ch <= chDigit_9) {
424
425                    min = min*10 + ch - chDigit_0;
426                }
427
428                if (min < 0)
429                    ThrowXMLwithMemMgr1(ParseException, XMLExcepts::Parser_Quantifier5, fString, fMemoryManager);
430            }
431            else {
432                ThrowXMLwithMemMgr1(ParseException, XMLExcepts::Parser_Quantifier1, fString, fMemoryManager);
433            }
434
435            max = min;
436
437            if (ch == chComma) {
438
439                if (fOffset >= fStringLen) {
440                    ThrowXMLwithMemMgr1(ParseException, XMLExcepts::Parser_Quantifier3, fString, fMemoryManager);
441                }
442                else if ((ch = fString[fOffset++]) >= chDigit_0 && ch <= chDigit_9) {
443
444                    max = ch - chDigit_0;
445                    while (fOffset < fStringLen
446                           && (ch = fString[fOffset++]) >= chDigit_0
447                           && ch <= chDigit_9) {
448
449                        max = max*10 + ch - chDigit_0;
450                    }
451
452                    if (max < 0)
453                        ThrowXMLwithMemMgr1(ParseException, XMLExcepts::Parser_Quantifier5, fString, fMemoryManager);
454                    else if (min > max)
455                        ThrowXMLwithMemMgr1(ParseException, XMLExcepts::Parser_Quantifier4, fString, fMemoryManager);
456                }
457                else {
458                    max = -1;
459                }
460            }
461
462            if (ch != chCloseCurly)  {
463                ThrowXMLwithMemMgr1(ParseException, XMLExcepts::Parser_Quantifier2, fString, fMemoryManager);
464            }
465
466            if (checkQuestion(fOffset)) {
467
468                tok = fTokenFactory->createClosure(tok, true);
469                fOffset++;
470            }
471            else {
472                tok = fTokenFactory->createClosure(tok);
473            }
474
475            tok->setMin(min);
476            tok->setMax(max);
477            processNext();
478        }
479        break;
480    default:
481        break;
482    }
483
484    return tok;
485}
486
487
488Token* RegxParser::parseAtom() {
489
490    Token* tok = 0;
491
492    switch(fState) {
493
494    case REGX_T_LPAREN:
495        return processParen();
496    case REGX_T_DOT:
497        processNext();
498        tok = fTokenFactory->getDot();
499        break;
500    case REGX_T_CARET:
501        return processCaret();
502    case REGX_T_DOLLAR:
503        return processDollar();
504    case REGX_T_LBRACKET:
505        return parseCharacterClass(true);
506    case REGX_T_BACKSOLIDUS:
507        switch(fCharData) {
508
509        case chLatin_d:
510        case chLatin_D:
511        case chLatin_w:
512        case chLatin_W:
513        case chLatin_s:
514        case chLatin_S:
515        case chLatin_c:
516        case chLatin_C:
517        case chLatin_i:
518        case chLatin_I:
519            tok = getTokenForShorthand(fCharData);
520            processNext();
521            return tok;
522        case chDigit_0:
523        case chDigit_1:
524        case chDigit_2:
525        case chDigit_3:
526        case chDigit_4:
527        case chDigit_5:
528        case chDigit_6:
529        case chDigit_7:
530        case chDigit_8:
531        case chDigit_9:
532            return processBackReference();
533        case chLatin_p:
534        case chLatin_P:
535            {               
536                tok = processBacksolidus_pP(fCharData);
537                if (tok == 0) {
538                    ThrowXMLwithMemMgr(ParseException,XMLExcepts::Parser_Atom5, fMemoryManager);
539                }
540            }
541            break;
542        default:
543            {
544                XMLInt32 ch = decodeEscaped();
545                if (ch < 0x10000) {
546                    tok = fTokenFactory->createChar(ch);
547                }
548                else {
549
550                    XMLCh* surrogateStr = RegxUtil::decomposeToSurrogates(ch, fMemoryManager);
551                    ArrayJanitor<XMLCh> janSurrogate(surrogateStr, fMemoryManager);
552                    tok = fTokenFactory->createString(surrogateStr);
553                }
554            }
555            break;
556        } // end switch
557
558        processNext();
559        break;
560    case REGX_T_CHAR:
561        if (fCharData == chOpenCurly
562            || fCharData == chCloseCurly
563            || fCharData == chCloseSquare)
564            ThrowXMLwithMemMgr(ParseException,XMLExcepts::Parser_Atom4, fMemoryManager);
565
566        tok = fTokenFactory->createChar(fCharData);
567        processNext();
568        break;
569    default:
570        ThrowXMLwithMemMgr(ParseException,XMLExcepts::Parser_Atom4, fMemoryManager);
571    } //end switch
572
573    return tok;
574}
575
576
577RangeToken* RegxParser::processBacksolidus_pP(const XMLInt32 ch) {
578
579    processNext();
580
581    if (fState != REGX_T_CHAR || fCharData != chOpenCurly)
582        ThrowXMLwithMemMgr(ParseException,XMLExcepts::Parser_Atom2, fMemoryManager);
583
584    XMLSize_t nameStart = fOffset;
585    int nameEnd = XMLString::indexOf(fString,chCloseCurly,nameStart, fMemoryManager);
586
587    if (nameEnd < 0)
588        ThrowXMLwithMemMgr(ParseException,XMLExcepts::Parser_Atom3, fMemoryManager);
589   
590    fOffset = nameEnd + 1;
591    XMLCh* rangeName = (XMLCh*) fMemoryManager->allocate
592    (
593        (nameEnd - nameStart + 1) * sizeof(XMLCh)
594    );//new XMLCh[(nameEnd - nameStart) + 1];
595    ArrayJanitor<XMLCh> janRangeName(rangeName, fMemoryManager);
596    XMLString::subString(rangeName, fString, nameStart, nameEnd, fMemoryManager);
597
598    return  fTokenFactory->getRange(rangeName, !(ch == chLatin_p));
599}
600
601RangeToken* RegxParser::parseCharacterClass(const bool useNRange) {
602
603    setParseContext(regexParserStateInBrackets);
604    processNext();
605
606    RangeToken* tok = 0;
607    bool isNRange = false;
608
609    if (getState() == REGX_T_CHAR && getCharData() == chCaret) {
610        isNRange = true;
611        processNext();
612    }
613    tok = fTokenFactory->createRange();
614
615    parserState type;
616    bool firstLoop = true;
617    bool wasDecoded;
618
619    while ( (type = getState()) != REGX_T_EOF) {
620
621        wasDecoded = false;
622
623        // single range | from-to-range | subtraction
624        if (type == REGX_T_CHAR && getCharData() == chCloseSquare && !firstLoop)
625            break;
626
627        XMLInt32 ch = getCharData();
628        bool     end = false;
629
630        if (type == REGX_T_BACKSOLIDUS) {
631
632            switch(ch) {
633            case chLatin_d:
634            case chLatin_D:
635            case chLatin_w:
636            case chLatin_W:
637            case chLatin_s:
638            case chLatin_S:
639            case chLatin_i:
640            case chLatin_I:
641            case chLatin_c:
642            case chLatin_C:
643                {
644                    tok->mergeRanges(getTokenForShorthand(ch));
645                    end = true;
646                }
647                break;
648            case chLatin_p:
649            case chLatin_P:
650                {                   
651                    RangeToken* tok2 = processBacksolidus_pP(ch);
652
653                    if (tok2 == 0) {
654                        ThrowXMLwithMemMgr(ParseException,XMLExcepts::Parser_Atom5, getMemoryManager());
655                    }
656
657                    tok->mergeRanges(tok2);
658                    end = true;
659                }
660                break;
661            case chDash:
662                wasDecoded = true;
663                // fall thru to default.
664            default:
665                ch = decodeEscaped();
666            }
667        } // end if REGX_T_BACKSOLIDUS
668        else if (type == REGX_T_XMLSCHEMA_CC_SUBTRACTION && !firstLoop) {
669
670            if (isNRange)
671            {
672                tok = RangeToken::complementRanges(tok, fTokenFactory, fMemoryManager);
673                isNRange=false;
674            }
675            RangeToken* rangeTok = parseCharacterClass(false);
676            tok->subtractRanges(rangeTok);
677
678            if (getState() != REGX_T_CHAR || getCharData() != chCloseSquare) {
679                ThrowXMLwithMemMgr(ParseException,XMLExcepts::Parser_CC5, getMemoryManager());
680            }
681            break;
682        } // end if REGX_T_XMLSCHEMA...
683
684        processNext();
685
686        if (!end) {
687
688            if (type == REGX_T_CHAR
689                && (ch == chOpenSquare
690                    || ch == chCloseSquare
691                    || (ch == chDash && getCharData() == chCloseSquare && firstLoop))) {
692                // if regex = [-] then invalid...
693                // '[', ']', '-' not allowed and should be escaped
694                XMLCh chStr[] = { ch, chNull };
695                ThrowXMLwithMemMgr2(ParseException,XMLExcepts::Parser_CC6, chStr, chStr, getMemoryManager());
696            }
697            if (ch == chDash && getCharData() == chDash && getState() != REGX_T_BACKSOLIDUS && !wasDecoded) {
698                XMLCh chStr[] = { ch, chNull };
699                ThrowXMLwithMemMgr2(ParseException,XMLExcepts::Parser_CC6, chStr, chStr, getMemoryManager());
700            }
701
702            if (getState() != REGX_T_CHAR || getCharData() != chDash) {
703                tok->addRange(ch, ch);
704            }
705            else {
706
707                processNext();
708                if ((type = getState()) == REGX_T_EOF)
709                    ThrowXMLwithMemMgr(ParseException,XMLExcepts::Parser_CC2, getMemoryManager());
710
711                if (type == REGX_T_CHAR && getCharData() == chCloseSquare) {
712                    tok->addRange(ch, ch);
713                    tok->addRange(chDash, chDash);
714                }
715                else if (type == REGX_T_XMLSCHEMA_CC_SUBTRACTION) {
716
717                    static const XMLCh dashStr[] = { chDash, chNull};
718                    ThrowXMLwithMemMgr2(ParseException, XMLExcepts::Parser_CC6, dashStr, dashStr, getMemoryManager());
719                }
720                else {
721
722                    XMLInt32 rangeEnd = getCharData();
723                    XMLCh rangeEndStr[] = { rangeEnd, chNull };
724
725                    if (type == REGX_T_CHAR) {
726
727                        if (rangeEnd == chOpenSquare
728                            || rangeEnd == chCloseSquare
729                            || rangeEnd == chDash)
730                            // '[', ']', '-' not allowed and should be escaped
731                            ThrowXMLwithMemMgr2(ParseException, XMLExcepts::Parser_CC6, rangeEndStr, rangeEndStr, getMemoryManager());
732                    }
733                    else if (type == REGX_T_BACKSOLIDUS) {
734                        rangeEnd = decodeEscaped();
735                    }
736
737                    processNext();
738
739                    if (ch > rangeEnd) {
740                        XMLCh chStr[] = { ch, chNull };
741                        ThrowXMLwithMemMgr2(ParseException,XMLExcepts::Parser_Ope3, rangeEndStr, chStr, getMemoryManager());
742                    }
743
744                    tok->addRange(ch, rangeEnd);
745                }
746            }
747        }
748        firstLoop = false;
749    }
750
751    if (getState() == REGX_T_EOF)
752        ThrowXMLwithMemMgr(ParseException,XMLExcepts::Parser_CC2, getMemoryManager());
753
754    if (isNRange)
755    {
756        if(useNRange)
757            tok->setTokenType(Token::T_NRANGE);
758        else
759            tok = RangeToken::complementRanges(tok, fTokenFactory, fMemoryManager);
760    }
761
762    tok->sortRanges();
763    tok->compactRanges();
764
765    // If the case-insensitive option is enabled, we need to
766    // have the new RangeToken instance build its internal
767    // case-insensitive RangeToken.
768    if (RegularExpression::isSet(fOptions, RegularExpression::IGNORE_CASE))
769    {
770        tok->getCaseInsensitiveToken(fTokenFactory);
771    }
772
773    setParseContext(regexParserStateNormal);
774    processNext();
775
776    return tok;
777}
778
779
780RangeToken* RegxParser::getTokenForShorthand(const XMLInt32 ch) {
781
782    switch(ch) {
783    case chLatin_d:
784        return fTokenFactory->getRange(fgUniDecimalDigit);
785        //return fTokenFactory->getRange(fgXMLDigit);
786    case chLatin_D:
787        return fTokenFactory->getRange(fgUniDecimalDigit, true);
788        //return fTokenFactory->getRange(fgXMLDigit, true);
789    case chLatin_w:
790        return fTokenFactory->getRange(fgXMLWord);
791    case chLatin_W:
792        return fTokenFactory->getRange(fgXMLWord, true);
793    case chLatin_s:
794        return fTokenFactory->getRange(fgXMLSpace);
795    case chLatin_S:
796        return fTokenFactory->getRange(fgXMLSpace, true);
797    case chLatin_c:
798        return fTokenFactory->getRange(fgXMLNameChar);
799    case chLatin_C:
800        return fTokenFactory->getRange(fgXMLNameChar, true);
801    case chLatin_i:
802        return fTokenFactory->getRange(fgXMLInitialNameChar);
803    case chLatin_I:
804        return fTokenFactory->getRange(fgXMLInitialNameChar, true);
805//    default:
806//        ThrowXMLwithMemMgr(RuntimeException, "Invalid shorthand {0}", chAsString)
807    }
808
809    return 0;
810}
811
812
813XMLInt32 RegxParser::decodeEscaped() {
814
815    if (fState != REGX_T_BACKSOLIDUS)
816        ThrowXMLwithMemMgr(ParseException,XMLExcepts::Parser_Next1, getMemoryManager());
817
818    XMLInt32 ch = fCharData;
819
820    switch (ch) {
821    case chLatin_n:
822        ch = chLF;
823        break;
824    case chLatin_r:
825        ch = chCR;
826        break;
827    case chLatin_t:
828        ch = chHTab;
829        break;
830    case chBackSlash:
831    case chPipe:
832    case chPeriod:
833    case chCaret:
834    case chDash:
835    case chQuestion:
836    case chAsterisk:
837    case chPlus:
838    case chOpenCurly:
839    case chCloseCurly:
840    case chOpenParen:
841    case chCloseParen:
842    case chOpenSquare:
843    case chCloseSquare:
844    case chDollarSign:
845        break;
846    default:
847    {
848        XMLCh chString[] = {chBackSlash, ch, chNull};       
849        ThrowXMLwithMemMgr1(ParseException,XMLExcepts::Parser_Process2, chString, getMemoryManager());
850    }
851    }
852
853    return ch;
854}
855
856// ---------------------------------------------------------------------------
857//  RegxParser: Helper Methods
858// ---------------------------------------------------------------------------
859bool RegxParser::checkQuestion(const XMLSize_t off) {
860
861    return ((off < fStringLen) && fString[off] == chQuestion);
862}
863
864XERCES_CPP_NAMESPACE_END
865
866/**
867  *    End file RegxParser.cpp
868  */
Note: See TracBrowser for help on using the repository browser.