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

Last change on this file since 4983 was 4852, checked in by nmedfort, 4 years ago

Bug fix for \N{..} + minor optimization changes.

File size: 4.5 KB
RevLine 
[3850]1/*
2 *  Copyright (c) 2014 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
[4673]10#include <re/re_re.h>
11#include <re/re_any.h>
12#include <re/re_name.h>
13#include <UCD/resolve_properties.h>
[3850]14#include <string>
[4182]15#include <list>
16#include <memory>
[4671]17#include <map>
[4819]18#include <re/re_memoizer.hpp>
[4829]19#include <re/parsefailure.h>
[3850]20
[4194]21namespace re {
[4673]22
[4309]23enum CharsetOperatorKind
[4798]24    {intersectOp, setDiffOp, ampChar, hyphenChar, rangeHyphen, posixPropertyOpener, setOpener, setCloser, backSlash, emptyOperator};
[4194]25
[4831]26enum ModeFlagType : unsigned {
27    NONE = 0,
28    CASE_INSENSITIVE_MODE_FLAG = 1,
29    MULTILINE_MODE_FLAG = 2,      // not currently implemented
30    DOTALL_MODE_FLAG = 4,         // not currently implemented
31    IGNORE_SPACE_MODE_FLAG = 8,   // not currently implemented
32    UNIX_LINES_MODE_FLAG = 16,    // not currently implemented
33    GRAPHEME_CLUSTER_MODE = 32
34};
[4798]35
[4429]36const int MAX_REPETITION_LOWER_BOUND = 1024;
37const int MAX_REPETITION_UPPER_BOUND = 2048;
38
[4312]39typedef unsigned ModeFlagSet;
[4798]40
[4182]41class RE_Parser
42{
43public:
[3850]44
[4412]45    static RE * parse(const std::string &input_string, ModeFlagSet initialFlags);
[3850]46
[4182]47private:
[3850]48
[4829]49    using NameMap = std::map<std::pair<std::string, std::string>, re::Name *>;
[4671]50
[4819]51    using cursor_t = std::string::const_iterator;
[3850]52
[4829]53    using char_t = const std::string::value_type;
54
55    struct Cursor {
56
57        inline Cursor & operator++() {
58            if (LLVM_UNLIKELY(mCursor == mEnd)) {
59                throw IncompleteRegularExpression();
60            }
61            ++mCursor;
62            return *this;
63        }
64
65        inline Cursor operator++(int) {
66            if (LLVM_UNLIKELY(mCursor == mEnd)) {
67                throw IncompleteRegularExpression();
68            }
69            Cursor tmp(*this);
70            ++mCursor;
71            return tmp;
72        }
73
74        inline const char_t operator*() const {
75            if (LLVM_UNLIKELY(mCursor == mEnd)) {
[4831]76                return 0;
[4829]77            }
78            return *mCursor;
79        }
80
81        inline bool noMore() const {
82            return mCursor == mEnd;
83        }
84
85        inline bool more() const {
86            return mCursor != mEnd;
87        }
88
89        inline cursor_t::difference_type remaining() const {
90            return mEnd - mCursor;
91        }
92
93        inline cursor_t pos() const {
94            return mCursor;
95        }
96
97        Cursor(const std::string & expression) : mCursor(expression.cbegin()), mEnd(expression.cend()) {}
98        Cursor(const Cursor & cursor) : mCursor(cursor.mCursor), mEnd(cursor.mEnd) {}
99        inline Cursor & operator=(const Cursor & cursor) {
100            mCursor = cursor.mCursor;
101            mEnd = cursor.mEnd;
102            return *this;
103        }
104    private:
105        cursor_t    mCursor;
106        cursor_t    mEnd;
107    };
108
[4307]109    RE_Parser(const std::string & regular_expression);
[4798]110
[4412]111    RE_Parser(const std::string & regular_expression, ModeFlagSet initialFlags);
[3914]112
[4311]113    RE * parse_RE();
[4798]114
[4311]115    RE * parse_alt();
[4798]116
[4182]117    RE * parse_seq();
[3935]118
[4311]119    RE * parse_next_item();
[4798]120
[4311]121    RE * parse_group();
[4798]122
[4182]123    RE * extend_item(RE * re);
124
[4829]125    RE * parseGraphemeBoundary(RE * re);
[4182]126
[4829]127    std::pair<int, int> parse_range_bound();
128
[4311]129    unsigned parse_int();
[4798]130
[4307]131    RE * parse_escaped();
[4182]132
[4671]133    RE * parseEscapedSet();
[4307]134
[4311]135    codepoint_t parse_utf8_codepoint();
[4182]136
[4819]137    RE * parsePropertyExpression();
[4798]138
[4852]139    Name * parseNamePatternExpression();
[4798]140
[4671]141    RE * makeComplement(RE * s);
[4673]142    RE * makeWordBoundary();
143    RE * makeWordNonBoundary();
[4829]144    Name * makeDigitSet();
145    Name * makeAlphaNumeric();
146    Name * makeWhitespaceSet();
147    Name * makeWordSet();
[4671]148
[4829]149    Name * createName(std::string && value);
150    Name * createName(std::string && prop, std::string && value);
[4671]151
[4798]152    CharsetOperatorKind getCharsetOperator();
[4182]153
154    RE * parse_charset();
155
[4311]156    codepoint_t parse_codepoint();
[4182]157
[4311]158    codepoint_t parse_escaped_codepoint();
[4182]159
[4311]160    codepoint_t parse_hex_codepoint(int mindigits, int maxdigits);
[4305]161
[4311]162    codepoint_t parse_octal_codepoint(int mindigits, int maxdigits);
[4305]163
[4316]164    // CC insertion dependent on case-insensitive flag.
[4819]165    Name * createCC(const codepoint_t cp);
166    void insert(CC * cc, const codepoint_t cp);
167    void insert_range(CC * cc, const codepoint_t lo, const codepoint_t hi);
[4798]168
[4671]169    static std::string canonicalize(const cursor_t begin, const cursor_t end);
170
[4182]171private:
172
[4829]173    Cursor                      mCursor;
[4671]174    ModeFlagSet                 fModeFlagSet;
[4798]175    bool                        fNested;
[4671]176    NameMap                     mNameMap;
[4819]177    Memoizer                    mMemoizer;
[3850]178};
179
[4194]180}
181
[3850]182#endif // RE_PARSER_H
Note: See TracBrowser for help on using the repository browser.