OILS / cpp / frontend_match.cc View on Github | oilshell.org

155 lines, 98 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
67List<Tuple2<Id_t, BigStr*>*>* HistoryTokens(BigStr* s) {
68 SimpleLexer lexer(&MatchHistoryToken, s);
69 return lexer.Tokens();
70}
71
72List<Tuple2<Id_t, BigStr*>*>* Ps1Tokens(BigStr* s) {
73 SimpleLexer lexer(&MatchPS1Token, s);
74 return lexer.Tokens();
75}
76
77Id_t BracketUnary(BigStr* s) {
78 return ::BracketUnary(reinterpret_cast<const unsigned char*>(s->data_),
79 len(s));
80}
81Id_t BracketBinary(BigStr* s) {
82 return ::BracketBinary(reinterpret_cast<const unsigned char*>(s->data_),
83 len(s));
84}
85Id_t BracketOther(BigStr* s) {
86 return ::BracketOther(reinterpret_cast<const unsigned char*>(s->data_),
87 len(s));
88}
89
90Tuple2<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
98Tuple2<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
106Tuple2<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
114Tuple2<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
122Tuple2<Id_t, int> MatchShNumberToken(BigStr* s, int pos) {
123 int id;
124 int end_pos;
125 ::MatchShNumberToken(reinterpret_cast<const unsigned char*>(s->data_), len(s),
126 pos, &id, &end_pos);
127 return Tuple2<Id_t, int>(static_cast<Id_t>(id), end_pos);
128}
129
130bool IsValidVarName(BigStr* s) {
131 return ::IsValidVarName(reinterpret_cast<const unsigned char*>(s->data_),
132 len(s));
133}
134
135bool ShouldHijack(BigStr* s) {
136 return ::ShouldHijack(reinterpret_cast<const unsigned char*>(s->data_),
137 len(s));
138}
139
140bool LooksLikeInteger(BigStr* s) {
141 return ::LooksLikeInteger(reinterpret_cast<const unsigned char*>(s->data_),
142 len(s));
143}
144
145bool LooksLikeYshInt(BigStr* s) {
146 return ::LooksLikeYshInt(reinterpret_cast<const unsigned char*>(s->data_),
147 len(s));
148}
149
150bool LooksLikeYshFloat(BigStr* s) {
151 return ::LooksLikeYshFloat(reinterpret_cast<const unsigned char*>(s->data_),
152 len(s));
153}
154
155} // namespace match