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

Last change on this file since 5678 was 5646, checked in by nmedfort, 2 years 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
RevLine 
[3850]1/*
[5161]2 *  Copyright (c) 2014-6 International Characters.
[3850]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
[5267]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; }
[3850]14
[4194]15namespace re {
[4673]16
[5218]17enum RE_Syntax {FixedStrings, BRE, ERE, PCRE, PROSITE};
[5267]18
[4309]19enum CharsetOperatorKind
[4798]20    {intersectOp, setDiffOp, ampChar, hyphenChar, rangeHyphen, posixPropertyOpener, setOpener, setCloser, backSlash, emptyOperator};
[4194]21
[4831]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
[5558]27    IGNORE_SPACE_MODE_FLAG = 8,
28    UNIX_LINES_MODE_FLAG = 16,
[4831]29    GRAPHEME_CLUSTER_MODE = 32
30};
[4798]31
[4429]32const int MAX_REPETITION_LOWER_BOUND = 1024;
33const int MAX_REPETITION_UPPER_BOUND = 2048;
34
[5267]35using ModeFlagSet = unsigned;
[4798]36
[5267]37class RE_Parser {
[4182]38public:
[3850]39
[5267]40    static LLVM_ATTRIBUTE_NORETURN void ParseFailure(std::string errmsg);
41
[5646]42    static RE * parse(const std::string &input_string, ModeFlagSet initialFlags, RE_Syntax syntax = RE_Syntax::PCRE, bool ByteMode = false) LLVM_ATTRIBUTE_UNUSED_RESULT;
[3850]43
[5180]44protected:
[5267]45
[4829]46    using NameMap = std::map<std::pair<std::string, std::string>, re::Name *>;
[4671]47
[4819]48    using cursor_t = std::string::const_iterator;
[3850]49
[4829]50    using char_t = const std::string::value_type;
51
52    struct Cursor {
53
54        inline Cursor & operator++() {
55            if (LLVM_UNLIKELY(mCursor == mEnd)) {
[5161]56                ParseFailure("Incomplete regular expression!");
[4829]57            }
58            ++mCursor;
59            return *this;
60        }
61
62        inline Cursor operator++(int) {
63            if (LLVM_UNLIKELY(mCursor == mEnd)) {
[5161]64                ParseFailure("Incomplete regular expression!");
[4829]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)) {
[4831]73                return 0;
[4829]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
[4307]106    RE_Parser(const std::string & regular_expression);
[4798]107
[4412]108    RE_Parser(const std::string & regular_expression, ModeFlagSet initialFlags);
[3914]109
[5180]110    virtual RE * parse_RE();
[4798]111
[5218]112    virtual RE * parse_alt();
[4798]113
[5206]114    virtual RE * parse_alt_with_intersect(RE* reToBeIntersected);
115
[5218]116    virtual RE * parse_seq();
[3935]117
[5206]118    RE * parse_seq_with_intersect(RE* reToBeIntersected);
119
[5180]120    virtual RE * parse_next_item();
[4798]121
[5180]122    virtual RE * parse_group();
[4798]123
[5180]124    virtual bool isSetEscapeChar(char c);
[4182]125
[5180]126    virtual RE * extend_item(RE * re);
127
[4829]128    RE * parseGraphemeBoundary(RE * re);
[4182]129
[5180]130    virtual std::pair<int, int> parse_range_bound();
[4829]131
[4311]132    unsigned parse_int();
[4798]133
[5180]134    virtual RE * parse_escaped();
[4182]135
[5180]136    virtual RE * parseEscapedSet();
[4307]137
[5554]138    codepoint_t parse_literal_codepoint();
139   
[4311]140    codepoint_t parse_utf8_codepoint();
[4182]141
[5180]142    virtual RE * parsePropertyExpression();
[5206]143    RE * parseRegexPropertyValue(const std::string& propName, const std::string& regexValue);
[4798]144
[4852]145    Name * parseNamePatternExpression();
[4798]146
[4671]147    RE * makeComplement(RE * s);
[4673]148    RE * makeWordBoundary();
149    RE * makeWordNonBoundary();
[5206]150    RE * makeReBoundary(RE * wordC);
151    RE * makeReNonBoundary(RE * wordC);
[5132]152    RE * makeWordBegin();
153    RE * makeWordEnd();
[4829]154    Name * makeDigitSet();
155    Name * makeAlphaNumeric();
156    Name * makeWhitespaceSet();
157    Name * makeWordSet();
[5091]158   
[5241]159    Name * createName(std::string value);
160    Name * createName(std::string prop, std::string value);
[4671]161
[5180]162    virtual bool isUnsupportChartsetOperator(char c);
[4798]163    CharsetOperatorKind getCharsetOperator();
[4182]164
165    RE * parse_charset();
166
[4311]167    codepoint_t parse_codepoint();
[4182]168
[5180]169    virtual codepoint_t parse_escaped_codepoint();
[4182]170
[4311]171    codepoint_t parse_hex_codepoint(int mindigits, int maxdigits);
[4305]172
[4311]173    codepoint_t parse_octal_codepoint(int mindigits, int maxdigits);
[4305]174
[4316]175    // CC insertion dependent on case-insensitive flag.
[4819]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);
[4798]179
[4671]180    static std::string canonicalize(const cursor_t begin, const cursor_t end);
[5206]181    bool isCharAhead(char c);
[4671]182
[5180]183protected:
[5554]184    bool                        fByteMode;
[4671]185    ModeFlagSet                 fModeFlagSet;
[4798]186    bool                        fNested;
[5091]187    bool                        fGraphemeBoundaryPending;
[5180]188    bool                        fSupportNonCaptureGroup;
[5080]189    Cursor                      mCursor;
190    unsigned                    mCaptureGroupCount;
[4671]191    NameMap                     mNameMap;
[4819]192    Memoizer                    mMemoizer;
[5206]193    RE_Syntax                   mReSyntax;
[3850]194};
195
[4194]196}
197
[3850]198#endif // RE_PARSER_H
Note: See TracBrowser for help on using the repository browser.