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

Last change on this file was 5646, checked in by nmedfort, 4 days ago

Minor clean up. Bug fix for object cache when the same cached kernel is used twice in a single run. Improvement to RE Minimizer.

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