source: icGREP/icgrep-devel/icgrep/re/re_parser.h @ 5218

Last change on this file since 5218 was 5218, checked in by xuedongx, 3 years ago

Add parser for PROSITE protein patterns

File size: 5.5 KB
Line 
1/*
2 *  Copyright (c) 2014-6 International Characters.
3 *  This software is licensed to the public under the Open Software License 3.0.
4 *  icgrep is a trademark of International Characters.
5 */
6
7#ifndef RE_PARSER_H
8#define RE_PARSER_H
9
10#include <re/re_re.h>
11#include <re/re_any.h>
12#include <re/re_name.h>
13#include <UCD/resolve_properties.h>
14#include <string>
15#include <list>
16#include <memory>
17#include <map>
18#include <re/re_memoizer.hpp>
19#include <llvm/Support/ErrorHandling.h>
20
21namespace re {
22
23enum RE_Syntax {FixedStrings, BRE, ERE, PCRE, PROSITE};
24enum CharsetOperatorKind
25    {intersectOp, setDiffOp, ampChar, hyphenChar, rangeHyphen, posixPropertyOpener, setOpener, setCloser, backSlash, emptyOperator};
26
27enum ModeFlagType : unsigned {
28    NONE = 0,
29    CASE_INSENSITIVE_MODE_FLAG = 1,
30    MULTILINE_MODE_FLAG = 2,      // not currently implemented
31    DOTALL_MODE_FLAG = 4,         // not currently implemented
32    IGNORE_SPACE_MODE_FLAG = 8,   // not currently implemented
33    UNIX_LINES_MODE_FLAG = 16,    // not currently implemented
34    GRAPHEME_CLUSTER_MODE = 32
35};
36
37const int MAX_REPETITION_LOWER_BOUND = 1024;
38const int MAX_REPETITION_UPPER_BOUND = 2048;
39
40typedef unsigned ModeFlagSet;
41
42
43class RE_Parser
44{
45public:
46
47    static RE * parse(const std::string &input_string, ModeFlagSet initialFlags, RE_Syntax syntax = RE_Syntax::PCRE);
48
49   
50    static LLVM_ATTRIBUTE_NORETURN void ParseFailure(std::string errmsg) {
51        llvm::report_fatal_error(errmsg);
52    }
53   
54protected:
55    using NameMap = std::map<std::pair<std::string, std::string>, re::Name *>;
56
57    using cursor_t = std::string::const_iterator;
58
59    using char_t = const std::string::value_type;
60
61    struct Cursor {
62
63        inline Cursor & operator++() {
64            if (LLVM_UNLIKELY(mCursor == mEnd)) {
65                ParseFailure("Incomplete regular expression!");
66            }
67            ++mCursor;
68            return *this;
69        }
70
71        inline Cursor operator++(int) {
72            if (LLVM_UNLIKELY(mCursor == mEnd)) {
73                ParseFailure("Incomplete regular expression!");
74            }
75            Cursor tmp(*this);
76            ++mCursor;
77            return tmp;
78        }
79
80        inline const char_t operator*() const {
81            if (LLVM_UNLIKELY(mCursor == mEnd)) {
82                return 0;
83            }
84            return *mCursor;
85        }
86
87        inline bool noMore() const {
88            return mCursor == mEnd;
89        }
90
91        inline bool more() const {
92            return mCursor != mEnd;
93        }
94
95        inline cursor_t::difference_type remaining() const {
96            return mEnd - mCursor;
97        }
98
99        inline cursor_t pos() const {
100            return mCursor;
101        }
102
103        Cursor(const std::string & expression) : mCursor(expression.cbegin()), mEnd(expression.cend()) {}
104        Cursor(const Cursor & cursor) : mCursor(cursor.mCursor), mEnd(cursor.mEnd) {}
105        inline Cursor & operator=(const Cursor & cursor) {
106            mCursor = cursor.mCursor;
107            mEnd = cursor.mEnd;
108            return *this;
109        }
110    private:
111        cursor_t    mCursor;
112        cursor_t    mEnd;
113    };
114
115    RE_Parser(const std::string & regular_expression);
116
117    RE_Parser(const std::string & regular_expression, ModeFlagSet initialFlags);
118
119    virtual RE * parse_RE();
120
121    virtual RE * parse_alt();
122
123    virtual RE * parse_alt_with_intersect(RE* reToBeIntersected);
124
125    virtual RE * parse_seq();
126
127    RE * parse_seq_with_intersect(RE* reToBeIntersected);
128
129    virtual RE * parse_next_item();
130
131    virtual RE * parse_group();
132
133    virtual bool isSetEscapeChar(char c);
134
135    virtual RE * extend_item(RE * re);
136
137    RE * parseGraphemeBoundary(RE * re);
138
139    virtual std::pair<int, int> parse_range_bound();
140
141    unsigned parse_int();
142
143    virtual RE * parse_escaped();
144
145    virtual RE * parseEscapedSet();
146
147    codepoint_t parse_utf8_codepoint();
148
149    virtual RE * parsePropertyExpression();
150    RE * parseRegexPropertyValue(const std::string& propName, const std::string& regexValue);
151
152    Name * parseNamePatternExpression();
153
154    RE * makeComplement(RE * s);
155    RE * makeWordBoundary();
156    RE * makeWordNonBoundary();
157    RE * makeReBoundary(RE * wordC);
158    RE * makeReNonBoundary(RE * wordC);
159    RE * makeWordBegin();
160    RE * makeWordEnd();
161    Name * makeDigitSet();
162    Name * makeAlphaNumeric();
163    Name * makeWhitespaceSet();
164    Name * makeWordSet();
165   
166    Name * createName(std::string && value);
167    Name * createName(std::string && prop, std::string && value);
168
169    virtual bool isUnsupportChartsetOperator(char c);
170    CharsetOperatorKind getCharsetOperator();
171
172    RE * parse_charset();
173
174    codepoint_t parse_codepoint();
175
176    virtual codepoint_t parse_escaped_codepoint();
177
178    codepoint_t parse_hex_codepoint(int mindigits, int maxdigits);
179
180    codepoint_t parse_octal_codepoint(int mindigits, int maxdigits);
181
182    // CC insertion dependent on case-insensitive flag.
183    Name * createCC(const codepoint_t cp);
184    void insert(CC * cc, const codepoint_t cp);
185    void insert_range(CC * cc, const codepoint_t lo, const codepoint_t hi);
186
187    static std::string canonicalize(const cursor_t begin, const cursor_t end);
188    bool isCharAhead(char c);
189
190protected:
191
192    ModeFlagSet                 fModeFlagSet;
193    bool                        fNested;
194    bool                        fGraphemeBoundaryPending;
195    bool                        fSupportNonCaptureGroup;
196    Cursor                      mCursor;
197    unsigned                    mCaptureGroupCount;
198    NameMap                     mNameMap;
199    Memoizer                    mMemoizer;
200    RE_Syntax                   mReSyntax;
201};
202
203}
204
205#endif // RE_PARSER_H
Note: See TracBrowser for help on using the repository browser.