fork/rust

git clone https://git.julia.blue/fork/rust

borsAuto merge of #66089 - Mark-Simulacrum:stable-next, r=Mark-Simulacrum4560ea788cb

1.39.0
9.2 KiB350 linesraw
1%{
2#include <stdio.h>
3#include <ctype.h>
4
5static int num_hashes;
6static int end_hashes;
7static int saw_non_hash;
8
9%}
10
11%option stack
12%option yylineno
13
14%x str
15%x rawstr
16%x rawstr_esc_begin
17%x rawstr_esc_body
18%x rawstr_esc_end
19%x byte
20%x bytestr
21%x rawbytestr
22%x rawbytestr_nohash
23%x pound
24%x shebang_or_attr
25%x ltorchar
26%x linecomment
27%x doc_line
28%x blockcomment
29%x doc_block
30%x suffix
31
32ident [a-zA-Z\x80-\xff_][a-zA-Z0-9\x80-\xff_]*
33
34%%
35
36<suffix>{ident}            { BEGIN(INITIAL); }
37<suffix>(.|\n)  { yyless(0); BEGIN(INITIAL); }
38
39[ \n\t\r]             { }
40
41\xef\xbb\xbf {
42  // UTF-8 byte order mark (BOM), ignore if in line 1, error otherwise
43  if (yyget_lineno() != 1) {
44    return -1;
45  }
46}
47
48\/\/(\/|\!)           { BEGIN(doc_line); yymore(); }
49<doc_line>\n          { BEGIN(INITIAL);
50                        yyleng--;
51                        yytext[yyleng] = 0;
52                        return ((yytext[2] == '!') ? INNER_DOC_COMMENT : OUTER_DOC_COMMENT);
53                      }
54<doc_line>[^\n]*      { yymore(); }
55
56\/\/|\/\/\/\/         { BEGIN(linecomment); }
57<linecomment>\n       { BEGIN(INITIAL); }
58<linecomment>[^\n]*   { }
59
60\/\*(\*|\!)[^*]       { yy_push_state(INITIAL); yy_push_state(doc_block); yymore(); }
61<doc_block>\/\*       { yy_push_state(doc_block); yymore(); }
62<doc_block>\*\/       {
63    yy_pop_state();
64    if (yy_top_state() == doc_block) {
65        yymore();
66    } else {
67        return ((yytext[2] == '!') ? INNER_DOC_COMMENT : OUTER_DOC_COMMENT);
68    }
69}
70<doc_block>(.|\n)     { yymore(); }
71
72\/\*                  { yy_push_state(blockcomment); }
73<blockcomment>\/\*    { yy_push_state(blockcomment); }
74<blockcomment>\*\/    { yy_pop_state(); }
75<blockcomment>(.|\n)   { }
76
77_        { return UNDERSCORE; }
78abstract { return ABSTRACT; }
79alignof  { return ALIGNOF; }
80as       { return AS; }
81become   { return BECOME; }
82box      { return BOX; }
83break    { return BREAK; }
84catch    { return CATCH; }
85const    { return CONST; }
86continue { return CONTINUE; }
87crate    { return CRATE; }
88default  { return DEFAULT; }
89do       { return DO; }
90else     { return ELSE; }
91enum     { return ENUM; }
92extern   { return EXTERN; }
93false    { return FALSE; }
94final    { return FINAL; }
95fn       { return FN; }
96for      { return FOR; }
97if       { return IF; }
98impl     { return IMPL; }
99in       { return IN; }
100let      { return LET; }
101loop     { return LOOP; }
102macro    { return MACRO; }
103match    { return MATCH; }
104mod      { return MOD; }
105move     { return MOVE; }
106mut      { return MUT; }
107offsetof { return OFFSETOF; }
108override { return OVERRIDE; }
109priv     { return PRIV; }
110proc     { return PROC; }
111pure     { return PURE; }
112pub      { return PUB; }
113ref      { return REF; }
114return   { return RETURN; }
115self     { return SELF; }
116sizeof   { return SIZEOF; }
117static   { return STATIC; }
118struct   { return STRUCT; }
119super    { return SUPER; }
120trait    { return TRAIT; }
121true     { return TRUE; }
122type     { return TYPE; }
123typeof   { return TYPEOF; }
124union    { return UNION; }
125unsafe   { return UNSAFE; }
126unsized  { return UNSIZED; }
127use      { return USE; }
128virtual  { return VIRTUAL; }
129where    { return WHERE; }
130while    { return WHILE; }
131yield    { return YIELD; }
132
133{ident}  { return IDENT; }
134
1350x[0-9a-fA-F_]+                                    { BEGIN(suffix); return LIT_INTEGER; }
1360o[0-7_]+                                          { BEGIN(suffix); return LIT_INTEGER; }
1370b[01_]+                                           { BEGIN(suffix); return LIT_INTEGER; }
138[0-9][0-9_]*                                       { BEGIN(suffix); return LIT_INTEGER; }
139[0-9][0-9_]*\.(\.|[a-zA-Z])    { yyless(yyleng - 2); BEGIN(suffix); return LIT_INTEGER; }
140
141[0-9][0-9_]*\.[0-9_]*([eE][-\+]?[0-9_]+)?          { BEGIN(suffix); return LIT_FLOAT; }
142[0-9][0-9_]*(\.[0-9_]*)?[eE][-\+]?[0-9_]+          { BEGIN(suffix); return LIT_FLOAT; }
143
144;      { return ';'; }
145,      { return ','; }
146\.\.\. { return DOTDOTDOT; }
147\.\.   { return DOTDOT; }
148\.     { return '.'; }
149\(     { return '('; }
150\)     { return ')'; }
151\{     { return '{'; }
152\}     { return '}'; }
153\[     { return '['; }
154\]     { return ']'; }
155@      { return '@'; }
156#      { BEGIN(pound); yymore(); }
157<pound>\! { BEGIN(shebang_or_attr); yymore(); }
158<shebang_or_attr>\[ {
159  BEGIN(INITIAL);
160  yyless(2);
161  return SHEBANG;
162}
163<shebang_or_attr>[^\[\n]*\n {
164  // Since the \n was eaten as part of the token, yylineno will have
165  // been incremented to the value 2 if the shebang was on the first
166  // line. This yyless undoes that, setting yylineno back to 1.
167  yyless(yyleng - 1);
168  if (yyget_lineno() == 1) {
169    BEGIN(INITIAL);
170    return SHEBANG_LINE;
171  } else {
172    BEGIN(INITIAL);
173    yyless(2);
174    return SHEBANG;
175  }
176}
177<pound>. { BEGIN(INITIAL); yyless(1); return '#'; }
178
179\~     { return '~'; }
180::     { return MOD_SEP; }
181:      { return ':'; }
182\$     { return '$'; }
183\?     { return '?'; }
184
185==    { return EQEQ; }
186=>    { return FAT_ARROW; }
187=     { return '='; }
188\!=   { return NE; }
189\!    { return '!'; }
190\<=   { return LE; }
191\<\<  { return SHL; }
192\<\<= { return SHLEQ; }
193\<    { return '<'; }
194\>=   { return GE; }
195\>\>  { return SHR; }
196\>\>= { return SHREQ; }
197\>    { return '>'; }
198
199\x27                                      { BEGIN(ltorchar); yymore(); }
200<ltorchar>static                          { BEGIN(INITIAL); return STATIC_LIFETIME; }
201<ltorchar>{ident}                         { BEGIN(INITIAL); return LIFETIME; }
202<ltorchar>\\[nrt\\\x27\x220]\x27          { BEGIN(suffix); return LIT_CHAR; }
203<ltorchar>\\x[0-9a-fA-F]{2}\x27           { BEGIN(suffix); return LIT_CHAR; }
204<ltorchar>\\u\{([0-9a-fA-F]_*){1,6}\}\x27 { BEGIN(suffix); return LIT_CHAR; }
205<ltorchar>.\x27                           { BEGIN(suffix); return LIT_CHAR; }
206<ltorchar>[\x80-\xff]{2,4}\x27            { BEGIN(suffix); return LIT_CHAR; }
207<ltorchar><<EOF>>                         { BEGIN(INITIAL); return -1; }
208
209b\x22              { BEGIN(bytestr); yymore(); }
210<bytestr>\x22      { BEGIN(suffix); return LIT_BYTE_STR; }
211
212<bytestr><<EOF>>                     { return -1; }
213<bytestr>\\[n\nrt\\\x27\x220]        { yymore(); }
214<bytestr>\\x[0-9a-fA-F]{2}           { yymore(); }
215<bytestr>\\u\{([0-9a-fA-F]_*){1,6}\} { yymore(); }
216<bytestr>\\[^n\nrt\\\x27\x220]       { return -1; }
217<bytestr>(.|\n)                      { yymore(); }
218
219br\x22                      { BEGIN(rawbytestr_nohash); yymore(); }
220<rawbytestr_nohash>\x22     { BEGIN(suffix); return LIT_BYTE_STR_RAW; }
221<rawbytestr_nohash>(.|\n)   { yymore(); }
222<rawbytestr_nohash><<EOF>>  { return -1; }
223
224br/# {
225    BEGIN(rawbytestr);
226    yymore();
227    num_hashes = 0;
228    saw_non_hash = 0;
229    end_hashes = 0;
230}
231<rawbytestr># {
232    if (!saw_non_hash) {
233        num_hashes++;
234    } else if (end_hashes != 0) {
235        end_hashes++;
236        if (end_hashes == num_hashes) {
237            BEGIN(INITIAL);
238            return LIT_BYTE_STR_RAW;
239        }
240    }
241    yymore();
242}
243<rawbytestr>\x22# {
244    end_hashes = 1;
245    if (end_hashes == num_hashes) {
246        BEGIN(INITIAL);
247        return LIT_BYTE_STR_RAW;
248    }
249    yymore();
250}
251<rawbytestr>(.|\n) {
252    if (!saw_non_hash) {
253        saw_non_hash = 1;
254    }
255    if (end_hashes != 0) {
256        end_hashes = 0;
257    }
258    yymore();
259}
260<rawbytestr><<EOF>> { return -1; }
261
262b\x27                           { BEGIN(byte); yymore(); }
263<byte>\\[nrt\\\x27\x220]\x27    { BEGIN(INITIAL); return LIT_BYTE; }
264<byte>\\x[0-9a-fA-F]{2}\x27     { BEGIN(INITIAL); return LIT_BYTE; }
265<byte>\\u([0-9a-fA-F]_*){4}\x27 { BEGIN(INITIAL); return LIT_BYTE; }
266<byte>\\U([0-9a-fA-F]_*){8}\x27 { BEGIN(INITIAL); return LIT_BYTE; }
267<byte>.\x27                     { BEGIN(INITIAL); return LIT_BYTE; }
268<byte><<EOF>>                   { BEGIN(INITIAL); return -1; }
269
270r\x22           { BEGIN(rawstr); yymore(); }
271<rawstr>\x22    { BEGIN(suffix); return LIT_STR_RAW; }
272<rawstr>(.|\n)  { yymore(); }
273<rawstr><<EOF>> { return -1; }
274
275r/#             {
276    BEGIN(rawstr_esc_begin);
277    yymore();
278    num_hashes = 0;
279    saw_non_hash = 0;
280    end_hashes = 0;
281}
282
283<rawstr_esc_begin># {
284    num_hashes++;
285    yymore();
286}
287<rawstr_esc_begin>\x22 {
288    BEGIN(rawstr_esc_body);
289    yymore();
290}
291<rawstr_esc_begin>(.|\n) { return -1; }
292
293<rawstr_esc_body>\x22/# {
294  BEGIN(rawstr_esc_end);
295  yymore();
296 }
297<rawstr_esc_body>(.|\n) {
298  yymore();
299 }
300
301<rawstr_esc_end># {
302  end_hashes++;
303  if (end_hashes == num_hashes) {
304    BEGIN(INITIAL);
305    return LIT_STR_RAW;
306  }
307  yymore();
308 }
309<rawstr_esc_end>[^#] {
310  end_hashes = 0;
311  BEGIN(rawstr_esc_body);
312  yymore();
313 }
314
315<rawstr_esc_begin,rawstr_esc_body,rawstr_esc_end><<EOF>> { return -1; }
316
317\x22                     { BEGIN(str); yymore(); }
318<str>\x22                { BEGIN(suffix); return LIT_STR; }
319
320<str><<EOF>>                     { return -1; }
321<str>\\[n\nr\rt\\\x27\x220]      { yymore(); }
322<str>\\x[0-9a-fA-F]{2}           { yymore(); }
323<str>\\u\{([0-9a-fA-F]_*){1,6}\} { yymore(); }
324<str>\\[^n\nrt\\\x27\x220]       { return -1; }
325<str>(.|\n)                      { yymore(); }
326
327\<-  { return LARROW; }
328-\>  { return RARROW; }
329-    { return '-'; }
330-=   { return MINUSEQ; }
331&&   { return ANDAND; }
332&    { return '&'; }
333&=   { return ANDEQ; }
334\|\| { return OROR; }
335\|   { return '|'; }
336\|=  { return OREQ; }
337\+   { return '+'; }
338\+=  { return PLUSEQ; }
339\*   { return '*'; }
340\*=  { return STAREQ; }
341\/   { return '/'; }
342\/=  { return SLASHEQ; }
343\^   { return '^'; }
344\^=  { return CARETEQ; }
345%    { return '%'; }
346%=   { return PERCENTEQ; }
347
348<<EOF>> { return 0; }
349
350%%