source: icXML/icXML-devel/src/xercesc/util/regx/RegxParser.hpp @ 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: 9.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.hpp 711369 2008-11-04 20:03:14Z amassari $
20 */
21
22#if !defined(XERCESC_INCLUDE_GUARD_REGXPARSER_HPP)
23#define XERCESC_INCLUDE_GUARD_REGXPARSER_HPP
24
25/*
26 *    A regular expression parser
27 */
28// ---------------------------------------------------------------------------
29//  Includes
30// ---------------------------------------------------------------------------
31#include <xercesc/util/RefVectorOf.hpp>
32#include <xercesc/util/XMLUniDefs.hpp>
33#include <xercesc/util/regx/Token.hpp>
34
35XERCES_CPP_NAMESPACE_BEGIN
36
37// ---------------------------------------------------------------------------
38//  Forward Declaration
39// ---------------------------------------------------------------------------
40class Token;
41class RangeToken;
42class TokenFactory;
43
44class XMLUTIL_EXPORT RegxParser : public XMemory
45{
46public:
47
48    // -----------------------------------------------------------------------
49    //  Public constant data
50    // -----------------------------------------------------------------------
51    // Parse tokens
52    typedef enum {
53        REGX_T_CHAR                     = 0,
54        REGX_T_EOF                      = 1,
55        REGX_T_OR                       = 2,
56        REGX_T_STAR                     = 3,
57        REGX_T_PLUS                     = 4,
58        REGX_T_QUESTION                 = 5,
59        REGX_T_LPAREN                   = 6,
60        REGX_T_RPAREN                   = 7,
61        REGX_T_DOT                      = 8,
62        REGX_T_LBRACKET                 = 9,
63        REGX_T_BACKSOLIDUS              = 10,
64        REGX_T_CARET                    = 11,
65        REGX_T_DOLLAR                   = 12,
66        REGX_T_XMLSCHEMA_CC_SUBTRACTION    = 13
67    } parserState;
68
69    typedef enum {
70        regexParserStateNormal = 0,
71        regexParserStateInBrackets = 1
72    } parserStateContext;
73
74    // -----------------------------------------------------------------------
75    //  Public Constructors and Destructor
76    // -----------------------------------------------------------------------
77    RegxParser(MemoryManager* const manager = XMLPlatformUtils::fgMemoryManager);
78    virtual ~RegxParser();
79
80    // -----------------------------------------------------------------------
81    //  Getter methods
82    // -----------------------------------------------------------------------
83    parserStateContext  getParseContext() const;
84    parserState         getState() const;
85    XMLInt32            getCharData() const;
86    int                 getNoParen() const;
87    XMLSize_t           getOffset() const;
88    bool                hasBackReferences() const;
89    TokenFactory*       getTokenFactory() const;
90    int                 getOptions() const;
91
92    // -----------------------------------------------------------------------
93    //  Setter methods
94    // -----------------------------------------------------------------------
95    void setParseContext(const parserStateContext value);
96    void setTokenFactory(TokenFactory* const tokFactory);
97    void setOptions(const int options);
98
99    // -----------------------------------------------------------------------
100    //  Public Parsing methods
101    // -----------------------------------------------------------------------
102    Token* parse(const XMLCh* const regxStr, const int options);
103
104protected:
105    // -----------------------------------------------------------------------
106    //  Protected Helper methods
107    // -----------------------------------------------------------------------
108    virtual bool        checkQuestion(const XMLSize_t off);
109    virtual XMLInt32    decodeEscaped();
110    MemoryManager*      getMemoryManager() const;
111    // -----------------------------------------------------------------------
112    //  Protected Parsing/Processing methods
113    // -----------------------------------------------------------------------
114    void                processNext();
115
116    Token*              parseRegx(const bool matchingRParen = false);
117    virtual Token*      processCaret();
118    virtual Token*      processDollar();
119    virtual Token*      processBackReference();
120    virtual Token*      processStar(Token* const tok);
121    virtual Token*      processPlus(Token* const tok);
122    virtual Token*      processQuestion(Token* const tok);
123    virtual Token*      processParen();
124
125    RangeToken*         parseCharacterClass(const bool useNRange);
126    RangeToken*         processBacksolidus_pP(const XMLInt32 ch);
127
128    // -----------------------------------------------------------------------
129    //  Protected PreCreated RangeToken access methods
130    // -----------------------------------------------------------------------
131    RangeToken*         getTokenForShorthand(const XMLInt32 ch);
132
133    bool isSet(const int flag);
134private:
135    // -----------------------------------------------------------------------
136    //  Private parsing/processing methods
137    // -----------------------------------------------------------------------
138    Token* parseTerm(const bool matchingRParen = false);
139    Token* parseFactor();
140    Token* parseAtom();
141
142    // -----------------------------------------------------------------------
143    //  Unimplemented constructors and operators
144    // -----------------------------------------------------------------------
145    RegxParser(const RegxParser&);
146    RegxParser& operator=(const RegxParser&);
147
148    // -----------------------------------------------------------------------
149    //  Private data types
150    // -----------------------------------------------------------------------
151    class ReferencePosition : public XMemory
152    {
153        public :
154            ReferencePosition(const int refNo, const XMLSize_t position);
155
156            int            fReferenceNo;
157            XMLSize_t   fPosition;
158    };
159
160    // -----------------------------------------------------------------------
161    //  Private Helper methods
162    // -----------------------------------------------------------------------
163    int hexChar(const XMLInt32 ch);
164
165    // -----------------------------------------------------------------------
166    //  Private data members
167    // -----------------------------------------------------------------------
168    MemoryManager*                  fMemoryManager;
169    bool                            fHasBackReferences;
170    int                             fOptions;
171    XMLSize_t                       fOffset;
172    int                             fNoGroups;
173    parserStateContext              fParseContext;
174    XMLSize_t                       fStringLen;
175    parserState                     fState;
176    XMLInt32                        fCharData;
177    XMLCh*                          fString;
178    RefVectorOf<ReferencePosition>* fReferences;
179    TokenFactory*                   fTokenFactory;
180};
181
182
183// ---------------------------------------------------------------------------
184//  RegxParser: Getter Methods
185// ---------------------------------------------------------------------------
186inline RegxParser::parserStateContext RegxParser::getParseContext() const {
187
188    return fParseContext;
189}
190
191inline RegxParser::parserState RegxParser::getState() const {
192
193    return fState;
194}
195
196inline XMLInt32 RegxParser::getCharData() const {
197
198    return fCharData;
199}
200
201inline int RegxParser::getNoParen() const {
202
203    return fNoGroups;
204}
205
206inline XMLSize_t RegxParser::getOffset() const {
207
208    return fOffset;
209}
210
211inline bool RegxParser::hasBackReferences() const {
212
213    return fHasBackReferences;
214}
215
216inline TokenFactory* RegxParser::getTokenFactory() const {
217
218    return fTokenFactory;
219}
220
221inline MemoryManager* RegxParser::getMemoryManager() const {
222    return fMemoryManager;
223}
224
225inline int RegxParser::getOptions() const {
226
227    return fOptions;
228}
229
230// ---------------------------------------------------------------------------
231//  RegxParser: Setter Methods
232// ---------------------------------------------------------------------------
233inline void RegxParser::setParseContext(const RegxParser::parserStateContext value) {
234
235    fParseContext = value;
236}
237
238inline void RegxParser::setTokenFactory(TokenFactory* const tokFactory) {
239
240    fTokenFactory = tokFactory;
241}
242
243inline void RegxParser::setOptions(const int options) {
244
245    fOptions = options;
246}
247
248// ---------------------------------------------------------------------------
249//  RegxParser: Helper Methods
250// ---------------------------------------------------------------------------
251inline bool RegxParser::isSet(const int flag) {
252
253    return (fOptions & flag) == flag;
254}
255
256
257inline int RegxParser::hexChar(const XMLInt32 ch) {
258
259    if (ch < chDigit_0 || ch > chLatin_f)
260        return -1;
261
262    if (ch <= chDigit_9)
263        return ch - chDigit_0;
264
265    if (ch < chLatin_A)
266        return -1;
267
268    if (ch <= chLatin_F)
269        return ch - chLatin_A + 10;
270
271    if (ch < chLatin_a)
272        return -1;
273
274    return ch - chLatin_a + 10;
275}
276
277XERCES_CPP_NAMESPACE_END
278
279#endif
280
281/**
282  *    End file RegxParser.hpp
283  */
284
Note: See TracBrowser for help on using the repository browser.