1 | // frontend_match.cc: manual port of frontend/match
|
2 |
|
3 | #include "frontend_match.h"
|
4 |
|
5 | // This order is required to get it to compile, despite clang-format
|
6 | // clang-format off
|
7 | #include "_gen/frontend/types.asdl_c.h"
|
8 | #include "_gen/frontend/id_kind.asdl_c.h"
|
9 | #include "_gen/frontend/match.re2c.h"
|
10 | // clang-format on
|
11 |
|
12 | namespace match {
|
13 |
|
14 | using id_kind_asdl::Id;
|
15 |
|
16 | Tuple2<Id_t, int> OneToken(lex_mode_t lex_mode, BigStr* line, int start_pos) {
|
17 | int id;
|
18 | int end_pos;
|
19 |
|
20 | // TODO: get rid of these casts
|
21 | MatchOshToken(static_cast<int>(lex_mode),
|
22 | reinterpret_cast<const unsigned char*>(line->data_), len(line),
|
23 | start_pos, &id, &end_pos);
|
24 | return Tuple2<Id_t, int>(static_cast<Id_t>(id), end_pos);
|
25 | }
|
26 |
|
27 | Tuple2<Id_t, BigStr*> SimpleLexer::Next() {
|
28 | int id;
|
29 | int end_pos;
|
30 | match_func_(reinterpret_cast<const unsigned char*>(s_->data_), len(s_), pos_,
|
31 | &id, &end_pos);
|
32 |
|
33 | int len = end_pos - pos_;
|
34 | BigStr* val = NewStr(len);
|
35 | memcpy(val->data_, s_->data_ + pos_, len); // copy the list item
|
36 | val->data_[len] = '\0';
|
37 |
|
38 | pos_ = end_pos;
|
39 | return Tuple2<Id_t, BigStr*>(static_cast<Id_t>(id), val);
|
40 | }
|
41 |
|
42 | List<Tuple2<Id_t, BigStr*>*>* SimpleLexer::Tokens() {
|
43 | auto tokens = NewList<Tuple2<Id_t, BigStr*>*>();
|
44 | while (true) {
|
45 | auto tup2 = Next();
|
46 | if (tup2.at0() == Id::Eol_Tok) {
|
47 | break;
|
48 | }
|
49 | // it's annoying that we have to put it on the heap
|
50 | tokens->append(Alloc<Tuple2<Id_t, BigStr*>>(tup2.at0(), tup2.at1()));
|
51 | }
|
52 | return tokens;
|
53 | }
|
54 |
|
55 | SimpleLexer* BraceRangeLexer(BigStr* s) {
|
56 | return Alloc<SimpleLexer>(&MatchBraceRangeToken, s);
|
57 | }
|
58 |
|
59 | SimpleLexer* GlobLexer(BigStr* s) {
|
60 | return Alloc<SimpleLexer>(&MatchGlobToken, s);
|
61 | }
|
62 |
|
63 | SimpleLexer* EchoLexer(BigStr* s) {
|
64 | return Alloc<SimpleLexer>(&MatchEchoToken, s);
|
65 | }
|
66 |
|
67 | List<Tuple2<Id_t, BigStr*>*>* HistoryTokens(BigStr* s) {
|
68 | SimpleLexer lexer(&MatchHistoryToken, s);
|
69 | return lexer.Tokens();
|
70 | }
|
71 |
|
72 | List<Tuple2<Id_t, BigStr*>*>* Ps1Tokens(BigStr* s) {
|
73 | SimpleLexer lexer(&MatchPS1Token, s);
|
74 | return lexer.Tokens();
|
75 | }
|
76 |
|
77 | Id_t BracketUnary(BigStr* s) {
|
78 | return ::BracketUnary(reinterpret_cast<const unsigned char*>(s->data_),
|
79 | len(s));
|
80 | }
|
81 | Id_t BracketBinary(BigStr* s) {
|
82 | return ::BracketBinary(reinterpret_cast<const unsigned char*>(s->data_),
|
83 | len(s));
|
84 | }
|
85 | Id_t BracketOther(BigStr* s) {
|
86 | return ::BracketOther(reinterpret_cast<const unsigned char*>(s->data_),
|
87 | len(s));
|
88 | }
|
89 |
|
90 | Tuple2<Id_t, int> MatchJ8Token(BigStr* s, int pos) {
|
91 | int id;
|
92 | int end_pos;
|
93 | ::MatchJ8Token(reinterpret_cast<const unsigned char*>(s->data_), len(s), pos,
|
94 | &id, &end_pos);
|
95 | return Tuple2<Id_t, int>(static_cast<Id_t>(id), end_pos);
|
96 | }
|
97 |
|
98 | Tuple2<Id_t, int> MatchJ8LinesToken(BigStr* s, int pos) {
|
99 | int id;
|
100 | int end_pos;
|
101 | ::MatchJ8LinesToken(reinterpret_cast<const unsigned char*>(s->data_), len(s),
|
102 | pos, &id, &end_pos);
|
103 | return Tuple2<Id_t, int>(static_cast<Id_t>(id), end_pos);
|
104 | }
|
105 |
|
106 | Tuple2<Id_t, int> MatchJ8StrToken(BigStr* s, int pos) {
|
107 | int id;
|
108 | int end_pos;
|
109 | ::MatchJ8StrToken(reinterpret_cast<const unsigned char*>(s->data_), len(s),
|
110 | pos, &id, &end_pos);
|
111 | return Tuple2<Id_t, int>(static_cast<Id_t>(id), end_pos);
|
112 | }
|
113 |
|
114 | Tuple2<Id_t, int> MatchJsonStrToken(BigStr* s, int pos) {
|
115 | int id;
|
116 | int end_pos;
|
117 | ::MatchJsonStrToken(reinterpret_cast<const unsigned char*>(s->data_), len(s),
|
118 | pos, &id, &end_pos);
|
119 | return Tuple2<Id_t, int>(static_cast<Id_t>(id), end_pos);
|
120 | }
|
121 |
|
122 | bool IsValidVarName(BigStr* s) {
|
123 | return ::IsValidVarName(reinterpret_cast<const unsigned char*>(s->data_),
|
124 | len(s));
|
125 | }
|
126 |
|
127 | bool ShouldHijack(BigStr* s) {
|
128 | return ::ShouldHijack(reinterpret_cast<const unsigned char*>(s->data_),
|
129 | len(s));
|
130 | }
|
131 |
|
132 | bool LooksLikeFloat(BigStr* s) {
|
133 | return ::LooksLikeFloat(reinterpret_cast<const unsigned char*>(s->data_),
|
134 | len(s));
|
135 | }
|
136 |
|
137 | bool LooksLikeInteger(BigStr* s) {
|
138 | return ::LooksLikeInteger(reinterpret_cast<const unsigned char*>(s->data_),
|
139 | len(s));
|
140 | }
|
141 |
|
142 | } // namespace match
|