OILS / cpp / frontend_match.cc View on Github | oils.pub

159 lines, 100 significant
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
12namespace match {
13
14using id_kind_asdl::Id;
15
16Tuple2<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
27Tuple2<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
42List<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
55SimpleLexer* BraceRangeLexer(BigStr* s) {
56 return Alloc<SimpleLexer>(&MatchBraceRangeToken, s);
57}
58
59SimpleLexer* GlobLexer(BigStr* s) {
60 return Alloc<SimpleLexer>(&MatchGlobToken, s);
61}
62
63SimpleLexer* EchoLexer(BigStr* s) {
64 return Alloc<SimpleLexer>(&MatchEchoToken, s);
65}
66
67SimpleLexer* PrintfBLexer(BigStr* s) {
68 return Alloc<SimpleLexer>(&MatchPrintfBToken, s);
69}
70
71List<Tuple2<Id_t, BigStr*>*>* Ps1Tokens(BigStr* s) {
72 SimpleLexer lexer(&MatchPS1Token, s);
73 return lexer.Tokens();
74}
75
76Id_t BracketUnary(BigStr* s) {
77 return ::BracketUnary(reinterpret_cast<const unsigned char*>(s->data_),
78 len(s));
79}
80Id_t BracketBinary(BigStr* s) {
81 return ::BracketBinary(reinterpret_cast<const unsigned char*>(s->data_),
82 len(s));
83}
84Id_t BracketOther(BigStr* s) {
85 return ::BracketOther(reinterpret_cast<const unsigned char*>(s->data_),
86 len(s));
87}
88
89Tuple2<Id_t, int> MatchJ8Token(BigStr* s, int pos) {
90 int id;
91 int end_pos;
92 ::MatchJ8Token(reinterpret_cast<const unsigned char*>(s->data_), len(s), pos,
93 &id, &end_pos);
94 return Tuple2<Id_t, int>(static_cast<Id_t>(id), end_pos);
95}
96
97Tuple2<Id_t, int> MatchJ8LinesToken(BigStr* s, int pos) {
98 int id;
99 int end_pos;
100 ::MatchJ8LinesToken(reinterpret_cast<const unsigned char*>(s->data_), len(s),
101 pos, &id, &end_pos);
102 return Tuple2<Id_t, int>(static_cast<Id_t>(id), end_pos);
103}
104
105Tuple2<Id_t, int> MatchJ8StrToken(BigStr* s, int pos) {
106 int id;
107 int end_pos;
108 ::MatchJ8StrToken(reinterpret_cast<const unsigned char*>(s->data_), len(s),
109 pos, &id, &end_pos);
110 return Tuple2<Id_t, int>(static_cast<Id_t>(id), end_pos);
111}
112
113Tuple2<Id_t, int> MatchJsonStrToken(BigStr* s, int pos) {
114 int id;
115 int end_pos;
116 ::MatchJsonStrToken(reinterpret_cast<const unsigned char*>(s->data_), len(s),
117 pos, &id, &end_pos);
118 return Tuple2<Id_t, int>(static_cast<Id_t>(id), end_pos);
119}
120
121Tuple2<Id_t, int> MatchShNumberToken(BigStr* s, int pos) {
122 int id;
123 int end_pos;
124 ::MatchShNumberToken(reinterpret_cast<const unsigned char*>(s->data_), len(s),
125 pos, &id, &end_pos);
126 return Tuple2<Id_t, int>(static_cast<Id_t>(id), end_pos);
127}
128
129bool IsUtf8Codeset(BigStr* s) {
130 return ::IsUtf8Codeset(reinterpret_cast<const unsigned char*>(s->data_),
131 len(s));
132}
133
134bool IsValidVarName(BigStr* s) {
135 return ::IsValidVarName(reinterpret_cast<const unsigned char*>(s->data_),
136 len(s));
137}
138
139bool ShouldHijack(BigStr* s) {
140 return ::ShouldHijack(reinterpret_cast<const unsigned char*>(s->data_),
141 len(s));
142}
143
144bool LooksLikeInteger(BigStr* s) {
145 return ::LooksLikeInteger(reinterpret_cast<const unsigned char*>(s->data_),
146 len(s));
147}
148
149bool LooksLikeYshInt(BigStr* s) {
150 return ::LooksLikeYshInt(reinterpret_cast<const unsigned char*>(s->data_),
151 len(s));
152}
153
154bool LooksLikeYshFloat(BigStr* s) {
155 return ::LooksLikeYshFloat(reinterpret_cast<const unsigned char*>(s->data_),
156 len(s));
157}
158
159} // namespace match