authorgravatar for mail@isaacfreund.comIsaac Freund <mail@isaacfreund.com> 2026-06-11 09:07:00+02:00
committergravatar for mail@isaacfreund.comIsaac Freund <mail@isaacfreund.com> 2026-07-08 11:48:57+02:00
log25dee862b47e235a6b1e86ea596f91ed57c83f85
treef57896d5f6816346598974ceb0f1bb230e945852
parent20a2485061b9c480d1df82f8fef2bec13a23e74a
signaturelock-open Commit is signed but in an unrecognized format.

std.zig.Ast: fuzz test against generated oracle

(currently broken/failing)

3 files changed, 4885 insertions(+), 0 deletions(-)

lib/std/zig.zig+1
...@@ -1879,4 +1879,5 @@ test {...@@ -1879,4 +1879,5 @@ test {
1879 _ = target;1879 _ = target;
1880 _ = c_translation;1880 _ = c_translation;
1881 _ = llvm;1881 _ = llvm;
1882 _ = @import("zig/parser_fuzz.zig");
1882}1883}
lib/std/zig/parser_fuzz.zig created+87
...@@ -0,0 +1,87 @@
1const std = @import("../std.zig");
2const Smith = std.testing.Smith;
3
4const oracle = @import("parser_generated_oracle.zig");
5
6test "fuzz std.zig.Ast.parse() against generated oracle" {
7 try std.testing.fuzz({}, checkAgainstOracle, .{});
8}
9
10fn checkAgainstOracle(_: void, smith: *Smith) !void {
11 var buffer: [1 << 14]u8 = undefined;
12 const len = smith.slice(buffer[0 .. buffer.len - 1]);
13 buffer[len] = 0;
14 const source = buffer[0..len :0];
15
16 var fba_buf: [1 << 18]u8 = undefined;
17 var fba: std.heap.FixedBufferAllocator = .init(&fba_buf);
18 const ast = try std.zig.Ast.parse(fba.allocator(), source, .zig);
19
20 errdefer logBadSource(source, ast);
21 try std.testing.expectEqual(oracle.parse(source), ast.errors.len == 0);
22}
23
24fn logBadSource(source: []const u8, ast: std.zig.Ast) void {
25 @disableInstrumentation();
26 var buf: [256]u8 = undefined;
27 const ls = std.debug.lockStderr(&buf);
28 defer std.debug.unlockStderr();
29 logBadSourceInner(source, ls.terminal(), ast) catch {};
30}
31
32fn logBadSourceInner(source: []const u8, t: std.Io.Terminal, ast: std.zig.Ast) std.Io.Writer.Error!void {
33 @disableInstrumentation();
34 try logSourceInner(source, t);
35 const w = t.writer;
36
37 try w.writeAll("=== Parse Errors ===\n");
38 for (ast.errors) |err| {
39 const loc = ast.tokenLocation(0, err.token);
40 try w.print("{}:{}: ", .{ loc.line + 1, loc.column + 1 });
41 try ast.renderError(err, w);
42 try w.writeByte('\n');
43 }
44}
45
46pub fn logSource(source: []const u8) void {
47 @disableInstrumentation();
48 var buf: [256]u8 = undefined;
49 const ls = std.debug.lockStderr(&buf);
50 defer std.debug.unlockStderr();
51 logSourceInner(source, ls.terminal()) catch {};
52}
53
54fn logSourceInner(source: []const u8, t: std.Io.Terminal) std.Io.Writer.Error!void {
55 @disableInstrumentation();
56 const w = t.writer;
57
58 t.setColor(.dim) catch {};
59 try w.writeAll("=== Source ===\n");
60 t.setColor(.reset) catch {};
61
62 var line: usize = 1;
63 try w.print("{: >5} ", .{line});
64 for (source) |c| switch (c) {
65 ' '...0x7e => try w.writeByte(c),
66 '\n' => {
67 line += 1;
68 try w.print("\n{: >5} ", .{line});
69 },
70 '\r' => {
71 t.setColor(.cyan) catch {};
72 try w.writeAll("\\r");
73 t.setColor(.reset) catch {};
74 },
75 '\t' => {
76 t.setColor(.cyan) catch {};
77 try w.writeAll("\\t");
78 t.setColor(.reset) catch {};
79 },
80 else => {
81 t.setColor(.cyan) catch {};
82 try w.print("\\x{x:0>2}", .{c});
83 t.setColor(.reset) catch {};
84 },
85 };
86 try w.writeByte('\n');
87}
lib/std/zig/parser_generated_oracle.zig created+4797
...@@ -0,0 +1,4797 @@
1//! This file is generated, do not edit manually! To generate, run:
2//! zig run ./tools/gen_parser_oracle.zig -- ./doc/langref/grammar.peg > ./lib/std/zig/parser_generated_oracle.zig
3
4const std = @import("std");
5
6/// Returns true if the input source is in the language defined by
7/// the grammar.
8pub fn parse(source: []const u8) bool {
9 var p: Parser = .{ .source = source, .i = 0 };
10 return p.parseRoot();
11}
12
13const Parser = struct {
14 source: []const u8,
15 i: usize,
16 pub fn parseRoot(p: *Parser) bool {
17 return blk_0: {
18 const pos_0 = p.i;
19 if (p.parseskip() and p.parseContainerMembers() and p.parseeof()) break :blk_0 true;
20 p.i = pos_0;
21 break :blk_0 false;
22 };
23 }
24 pub fn parseContainerMembers(p: *Parser) bool {
25 return blk_0: {
26 const pos_0 = p.i;
27 if ((p.parsecontainer_doc_comment() or true) and blk_1: {
28 while (p.parseContainerDeclaration()) {}
29 break :blk_1 true;
30 } and blk_1: {
31 while (blk_3: {
32 const pos_3 = p.i;
33 if (p.parseContainerField() and p.parseCOMMA()) break :blk_3 true;
34 p.i = pos_3;
35 break :blk_3 false;
36 }) {}
37 break :blk_1 true;
38 } and blk_2: {
39 const pos_2 = p.i;
40 if (p.parseContainerField()) break :blk_2 true;
41 p.i = pos_2;
42 if (blk_3: {
43 while (p.parseContainerDeclaration()) {}
44 break :blk_3 true;
45 }) break :blk_2 true;
46 p.i = pos_2;
47 break :blk_2 false;
48 }) break :blk_0 true;
49 p.i = pos_0;
50 break :blk_0 false;
51 };
52 }
53 pub fn parseContainerDeclaration(p: *Parser) bool {
54 return blk_0: {
55 const pos_0 = p.i;
56 if (p.parseTestDecl()) break :blk_0 true;
57 p.i = pos_0;
58 if (p.parseComptimeDecl()) break :blk_0 true;
59 p.i = pos_0;
60 if ((p.parsedoc_comment() or true) and (p.parseKEYWORD_pub() or true) and p.parseDecl()) break :blk_0 true;
61 p.i = pos_0;
62 break :blk_0 false;
63 };
64 }
65 pub fn parseTestDecl(p: *Parser) bool {
66 return blk_0: {
67 const pos_0 = p.i;
68 if (p.parseKEYWORD_test() and (blk_3: {
69 const pos_3 = p.i;
70 if (p.parseSTRINGLITERALSINGLE()) break :blk_3 true;
71 p.i = pos_3;
72 if (p.parseIDENTIFIER()) break :blk_3 true;
73 p.i = pos_3;
74 break :blk_3 false;
75 } or true) and p.parseBlock()) break :blk_0 true;
76 p.i = pos_0;
77 break :blk_0 false;
78 };
79 }
80 pub fn parseComptimeDecl(p: *Parser) bool {
81 return blk_0: {
82 const pos_0 = p.i;
83 if (p.parseKEYWORD_comptime() and p.parseBlock()) break :blk_0 true;
84 p.i = pos_0;
85 break :blk_0 false;
86 };
87 }
88 pub fn parseDecl(p: *Parser) bool {
89 return blk_0: {
90 const pos_0 = p.i;
91 if ((blk_3: {
92 const pos_3 = p.i;
93 if (p.parseKEYWORD_export()) break :blk_3 true;
94 p.i = pos_3;
95 if (p.parseKEYWORD_inline()) break :blk_3 true;
96 p.i = pos_3;
97 if (p.parseKEYWORD_noinline()) break :blk_3 true;
98 p.i = pos_3;
99 break :blk_3 false;
100 } or true) and p.parseFnProto() and blk_2: {
101 const pos_2 = p.i;
102 if (p.parseSEMICOLON()) break :blk_2 true;
103 p.i = pos_2;
104 if (p.parseBlock()) break :blk_2 true;
105 p.i = pos_2;
106 break :blk_2 false;
107 }) break :blk_0 true;
108 p.i = pos_0;
109 if (p.parseKEYWORD_extern() and (p.parseSTRINGLITERALSINGLE() or true) and p.parseFnProto() and p.parseSEMICOLON()) break :blk_0 true;
110 p.i = pos_0;
111 if ((blk_3: {
112 const pos_3 = p.i;
113 if (p.parseKEYWORD_export()) break :blk_3 true;
114 p.i = pos_3;
115 if (p.parseKEYWORD_extern() and (p.parseSTRINGLITERALSINGLE() or true)) break :blk_3 true;
116 p.i = pos_3;
117 break :blk_3 false;
118 } or true) and (p.parseKEYWORD_threadlocal() or true) and p.parseGlobalVarDecl()) break :blk_0 true;
119 p.i = pos_0;
120 break :blk_0 false;
121 };
122 }
123 pub fn parseFnProto(p: *Parser) bool {
124 return blk_0: {
125 const pos_0 = p.i;
126 if (p.parseKEYWORD_fn() and (p.parseIDENTIFIER() or true) and p.parseLPAREN() and p.parseParamDeclList() and p.parseRPAREN() and (p.parseByteAlign() or true) and (p.parseAddrSpace() or true) and (p.parseLinkSection() or true) and (p.parseCallConv() or true) and (p.parseEXCLAMATIONMARK() or true) and p.parseTypeExpr() and blk_1: {
127 const pos_1 = p.i;
128 const match_1 = p.parseExprSuffix();
129 p.i = pos_1;
130 break :blk_1 !match_1;
131 }) break :blk_0 true;
132 p.i = pos_0;
133 break :blk_0 false;
134 };
135 }
136 pub fn parseVarDeclProto(p: *Parser) bool {
137 return blk_0: {
138 const pos_0 = p.i;
139 if (blk_2: {
140 const pos_2 = p.i;
141 if (p.parseKEYWORD_const()) break :blk_2 true;
142 p.i = pos_2;
143 if (p.parseKEYWORD_var()) break :blk_2 true;
144 p.i = pos_2;
145 break :blk_2 false;
146 } and p.parseIDENTIFIER() and (blk_3: {
147 const pos_3 = p.i;
148 if (p.parseCOLON() and p.parseTypeExpr()) break :blk_3 true;
149 p.i = pos_3;
150 break :blk_3 false;
151 } or true) and (p.parseByteAlign() or true) and (p.parseAddrSpace() or true) and (p.parseLinkSection() or true)) break :blk_0 true;
152 p.i = pos_0;
153 break :blk_0 false;
154 };
155 }
156 pub fn parseGlobalVarDecl(p: *Parser) bool {
157 return blk_0: {
158 const pos_0 = p.i;
159 if (p.parseVarDeclProto() and (blk_3: {
160 const pos_3 = p.i;
161 if (p.parseEQUAL() and p.parseExpr()) break :blk_3 true;
162 p.i = pos_3;
163 break :blk_3 false;
164 } or true) and p.parseSEMICOLON()) break :blk_0 true;
165 p.i = pos_0;
166 break :blk_0 false;
167 };
168 }
169 pub fn parseContainerField(p: *Parser) bool {
170 return blk_0: {
171 const pos_0 = p.i;
172 if ((p.parsedoc_comment() or true) and blk_2: {
173 const pos_2 = p.i;
174 if (p.parseKEYWORD_comptime()) break :blk_2 true;
175 p.i = pos_2;
176 if (blk_3: {
177 const pos_3 = p.i;
178 const match_3 = p.parseKEYWORD_comptime();
179 p.i = pos_3;
180 break :blk_3 !match_3;
181 }) break :blk_2 true;
182 p.i = pos_2;
183 break :blk_2 false;
184 } and blk_1: {
185 const pos_1 = p.i;
186 const match_1 = p.parseKEYWORD_fn();
187 p.i = pos_1;
188 break :blk_1 !match_1;
189 } and (blk_3: {
190 const pos_3 = p.i;
191 if (p.parseIDENTIFIER() and p.parseCOLON()) break :blk_3 true;
192 p.i = pos_3;
193 if (blk_4: {
194 const pos_4 = p.i;
195 const match_4 = blk_6: {
196 const pos_6 = p.i;
197 if (p.parseIDENTIFIER() and p.parseCOLON()) break :blk_6 true;
198 p.i = pos_6;
199 break :blk_6 false;
200 };
201 p.i = pos_4;
202 break :blk_4 !match_4;
203 }) break :blk_3 true;
204 p.i = pos_3;
205 break :blk_3 false;
206 } or true) and p.parseTypeExpr() and (p.parseByteAlign() or true) and (blk_3: {
207 const pos_3 = p.i;
208 if (p.parseEQUAL() and p.parseExpr()) break :blk_3 true;
209 p.i = pos_3;
210 break :blk_3 false;
211 } or true)) break :blk_0 true;
212 p.i = pos_0;
213 break :blk_0 false;
214 };
215 }
216 pub fn parseBlockStatement(p: *Parser) bool {
217 return blk_0: {
218 const pos_0 = p.i;
219 if (p.parseStatement()) break :blk_0 true;
220 p.i = pos_0;
221 if (p.parseKEYWORD_defer() and p.parseBlockExprStatement()) break :blk_0 true;
222 p.i = pos_0;
223 if (p.parseKEYWORD_errdefer() and p.parseBlockExprStatement()) break :blk_0 true;
224 p.i = pos_0;
225 if (blk_1: {
226 const pos_1 = p.i;
227 const match_1 = p.parseExprStatement();
228 p.i = pos_1;
229 break :blk_1 !match_1;
230 } and (blk_3: {
231 const pos_3 = p.i;
232 if (p.parseKEYWORD_comptime() and blk_4: {
233 const pos_4 = p.i;
234 const match_4 = p.parseBlockExpr();
235 p.i = pos_4;
236 break :blk_4 !match_4;
237 }) break :blk_3 true;
238 p.i = pos_3;
239 break :blk_3 false;
240 } or true) and p.parseVarAssignStatement()) break :blk_0 true;
241 p.i = pos_0;
242 break :blk_0 false;
243 };
244 }
245 pub fn parseStatement(p: *Parser) bool {
246 return blk_0: {
247 const pos_0 = p.i;
248 if (p.parseExprStatement()) break :blk_0 true;
249 p.i = pos_0;
250 if (p.parseKEYWORD_suspend() and p.parseBlockExprStatement()) break :blk_0 true;
251 p.i = pos_0;
252 if (blk_1: {
253 const pos_1 = p.i;
254 const match_1 = p.parseExprStatement();
255 p.i = pos_1;
256 break :blk_1 !match_1;
257 } and (blk_3: {
258 const pos_3 = p.i;
259 if (p.parseKEYWORD_comptime() and blk_4: {
260 const pos_4 = p.i;
261 const match_4 = p.parseBlockExpr();
262 p.i = pos_4;
263 break :blk_4 !match_4;
264 }) break :blk_3 true;
265 p.i = pos_3;
266 break :blk_3 false;
267 } or true) and p.parseAssignExpr() and p.parseSEMICOLON()) break :blk_0 true;
268 p.i = pos_0;
269 break :blk_0 false;
270 };
271 }
272 pub fn parseExprStatement(p: *Parser) bool {
273 return blk_0: {
274 const pos_0 = p.i;
275 if (p.parseIfStatement()) break :blk_0 true;
276 p.i = pos_0;
277 if (p.parseLabeledStatement()) break :blk_0 true;
278 p.i = pos_0;
279 if (p.parseKEYWORD_nosuspend() and p.parseBlockExprStatement()) break :blk_0 true;
280 p.i = pos_0;
281 if (p.parseKEYWORD_comptime() and p.parseBlockExpr()) break :blk_0 true;
282 p.i = pos_0;
283 break :blk_0 false;
284 };
285 }
286 pub fn parseIfStatement(p: *Parser) bool {
287 return blk_0: {
288 const pos_0 = p.i;
289 if (p.parseIfPrefix() and p.parseBlockExpr() and (blk_3: {
290 const pos_3 = p.i;
291 if (p.parseKEYWORD_else() and (p.parsePayload() or true) and p.parseStatement()) break :blk_3 true;
292 p.i = pos_3;
293 break :blk_3 false;
294 } or true)) break :blk_0 true;
295 p.i = pos_0;
296 if (p.parseIfPrefix() and blk_1: {
297 const pos_1 = p.i;
298 const match_1 = p.parseBlockExpr();
299 p.i = pos_1;
300 break :blk_1 !match_1;
301 } and p.parseAssignExpr() and blk_2: {
302 const pos_2 = p.i;
303 if (p.parseSEMICOLON()) break :blk_2 true;
304 p.i = pos_2;
305 if (p.parseKEYWORD_else() and (p.parsePayload() or true) and p.parseStatement()) break :blk_2 true;
306 p.i = pos_2;
307 break :blk_2 false;
308 }) break :blk_0 true;
309 p.i = pos_0;
310 break :blk_0 false;
311 };
312 }
313 pub fn parseLabeledStatement(p: *Parser) bool {
314 return blk_0: {
315 const pos_0 = p.i;
316 if ((p.parseBlockLabel() or true) and blk_2: {
317 const pos_2 = p.i;
318 if (p.parseBlock()) break :blk_2 true;
319 p.i = pos_2;
320 if (p.parseLoopStatement()) break :blk_2 true;
321 p.i = pos_2;
322 if (p.parseSwitchExpr()) break :blk_2 true;
323 p.i = pos_2;
324 break :blk_2 false;
325 }) break :blk_0 true;
326 p.i = pos_0;
327 break :blk_0 false;
328 };
329 }
330 pub fn parseLoopStatement(p: *Parser) bool {
331 return blk_0: {
332 const pos_0 = p.i;
333 if ((p.parseKEYWORD_inline() or true) and blk_2: {
334 const pos_2 = p.i;
335 if (p.parseForStatement()) break :blk_2 true;
336 p.i = pos_2;
337 if (p.parseWhileStatement()) break :blk_2 true;
338 p.i = pos_2;
339 break :blk_2 false;
340 }) break :blk_0 true;
341 p.i = pos_0;
342 break :blk_0 false;
343 };
344 }
345 pub fn parseForStatement(p: *Parser) bool {
346 return blk_0: {
347 const pos_0 = p.i;
348 if (p.parseForPrefix() and p.parseBlockExpr() and blk_2: {
349 const pos_2 = p.i;
350 if (p.parseKEYWORD_else() and p.parseStatement()) break :blk_2 true;
351 p.i = pos_2;
352 if (blk_3: {
353 const pos_3 = p.i;
354 const match_3 = p.parseKEYWORD_else();
355 p.i = pos_3;
356 break :blk_3 !match_3;
357 }) break :blk_2 true;
358 p.i = pos_2;
359 break :blk_2 false;
360 }) break :blk_0 true;
361 p.i = pos_0;
362 if (p.parseForPrefix() and blk_1: {
363 const pos_1 = p.i;
364 const match_1 = p.parseBlockExpr();
365 p.i = pos_1;
366 break :blk_1 !match_1;
367 } and p.parseAssignExpr() and blk_2: {
368 const pos_2 = p.i;
369 if (p.parseSEMICOLON()) break :blk_2 true;
370 p.i = pos_2;
371 if (p.parseKEYWORD_else() and p.parseStatement()) break :blk_2 true;
372 p.i = pos_2;
373 break :blk_2 false;
374 }) break :blk_0 true;
375 p.i = pos_0;
376 break :blk_0 false;
377 };
378 }
379 pub fn parseWhileStatement(p: *Parser) bool {
380 return blk_0: {
381 const pos_0 = p.i;
382 if (p.parseWhilePrefix() and p.parseBlockExpr() and (blk_3: {
383 const pos_3 = p.i;
384 if (p.parseKEYWORD_else() and (p.parsePayload() or true) and p.parseStatement()) break :blk_3 true;
385 p.i = pos_3;
386 break :blk_3 false;
387 } or true)) break :blk_0 true;
388 p.i = pos_0;
389 if (p.parseWhilePrefix() and blk_1: {
390 const pos_1 = p.i;
391 const match_1 = p.parseBlockExpr();
392 p.i = pos_1;
393 break :blk_1 !match_1;
394 } and p.parseAssignExpr() and blk_2: {
395 const pos_2 = p.i;
396 if (p.parseSEMICOLON()) break :blk_2 true;
397 p.i = pos_2;
398 if (p.parseKEYWORD_else() and (p.parsePayload() or true) and p.parseStatement()) break :blk_2 true;
399 p.i = pos_2;
400 break :blk_2 false;
401 }) break :blk_0 true;
402 p.i = pos_0;
403 break :blk_0 false;
404 };
405 }
406 pub fn parseBlockExprStatement(p: *Parser) bool {
407 return blk_0: {
408 const pos_0 = p.i;
409 if (p.parseBlockExpr()) break :blk_0 true;
410 p.i = pos_0;
411 if (blk_1: {
412 const pos_1 = p.i;
413 const match_1 = p.parseBlockExpr();
414 p.i = pos_1;
415 break :blk_1 !match_1;
416 } and p.parseAssignExpr() and p.parseSEMICOLON()) break :blk_0 true;
417 p.i = pos_0;
418 break :blk_0 false;
419 };
420 }
421 pub fn parseBlockExpr(p: *Parser) bool {
422 return blk_0: {
423 const pos_0 = p.i;
424 if ((p.parseBlockLabel() or true) and p.parseBlock()) break :blk_0 true;
425 p.i = pos_0;
426 break :blk_0 false;
427 };
428 }
429 pub fn parseVarAssignStatement(p: *Parser) bool {
430 return blk_0: {
431 const pos_0 = p.i;
432 if (blk_2: {
433 const pos_2 = p.i;
434 if (p.parseVarDeclProto()) break :blk_2 true;
435 p.i = pos_2;
436 if (p.parseExpr()) break :blk_2 true;
437 p.i = pos_2;
438 break :blk_2 false;
439 } and blk_1: {
440 while (blk_3: {
441 const pos_3 = p.i;
442 if (p.parseCOMMA() and blk_5: {
443 const pos_5 = p.i;
444 if (p.parseVarDeclProto()) break :blk_5 true;
445 p.i = pos_5;
446 if (p.parseExpr()) break :blk_5 true;
447 p.i = pos_5;
448 break :blk_5 false;
449 }) break :blk_3 true;
450 p.i = pos_3;
451 break :blk_3 false;
452 }) {}
453 break :blk_1 true;
454 } and p.parseEQUAL() and p.parseExpr() and p.parseSEMICOLON()) break :blk_0 true;
455 p.i = pos_0;
456 break :blk_0 false;
457 };
458 }
459 pub fn parseAssignExpr(p: *Parser) bool {
460 return blk_0: {
461 const pos_0 = p.i;
462 if (p.parseExpr() and (blk_3: {
463 const pos_3 = p.i;
464 if (p.parseAssignOp() and p.parseExpr()) break :blk_3 true;
465 p.i = pos_3;
466 if (blk_4: {
467 var match_4 = false;
468 while (blk_6: {
469 const pos_6 = p.i;
470 if (p.parseCOMMA() and p.parseExpr()) break :blk_6 true;
471 p.i = pos_6;
472 break :blk_6 false;
473 }) {
474 match_4 = true;
475 }
476 break :blk_4 match_4;
477 } and p.parseEQUAL() and p.parseExpr()) break :blk_3 true;
478 p.i = pos_3;
479 break :blk_3 false;
480 } or true)) break :blk_0 true;
481 p.i = pos_0;
482 break :blk_0 false;
483 };
484 }
485 pub fn parseSingleAssignExpr(p: *Parser) bool {
486 return blk_0: {
487 const pos_0 = p.i;
488 if (p.parseExpr() and (blk_3: {
489 const pos_3 = p.i;
490 if (p.parseAssignOp() and p.parseExpr()) break :blk_3 true;
491 p.i = pos_3;
492 break :blk_3 false;
493 } or true)) break :blk_0 true;
494 p.i = pos_0;
495 break :blk_0 false;
496 };
497 }
498 pub fn parseExpr(p: *Parser) bool {
499 return blk_0: {
500 const pos_0 = p.i;
501 if (p.parseBoolOrExpr()) break :blk_0 true;
502 p.i = pos_0;
503 break :blk_0 false;
504 };
505 }
506 pub fn parseBoolOrExpr(p: *Parser) bool {
507 return blk_0: {
508 const pos_0 = p.i;
509 if (p.parseBoolAndExpr() and blk_1: {
510 while (blk_3: {
511 const pos_3 = p.i;
512 if (p.parseKEYWORD_or() and p.parseBoolAndExpr()) break :blk_3 true;
513 p.i = pos_3;
514 break :blk_3 false;
515 }) {}
516 break :blk_1 true;
517 }) break :blk_0 true;
518 p.i = pos_0;
519 break :blk_0 false;
520 };
521 }
522 pub fn parseBoolAndExpr(p: *Parser) bool {
523 return blk_0: {
524 const pos_0 = p.i;
525 if (p.parseCompareExpr() and blk_1: {
526 while (blk_3: {
527 const pos_3 = p.i;
528 if (p.parseKEYWORD_and() and p.parseCompareExpr()) break :blk_3 true;
529 p.i = pos_3;
530 break :blk_3 false;
531 }) {}
532 break :blk_1 true;
533 }) break :blk_0 true;
534 p.i = pos_0;
535 break :blk_0 false;
536 };
537 }
538 pub fn parseCompareExpr(p: *Parser) bool {
539 return blk_0: {
540 const pos_0 = p.i;
541 if (p.parseBitwiseExpr() and (blk_3: {
542 const pos_3 = p.i;
543 if (p.parseCompareOp() and p.parseBitwiseExpr()) break :blk_3 true;
544 p.i = pos_3;
545 break :blk_3 false;
546 } or true)) break :blk_0 true;
547 p.i = pos_0;
548 break :blk_0 false;
549 };
550 }
551 pub fn parseBitwiseExpr(p: *Parser) bool {
552 return blk_0: {
553 const pos_0 = p.i;
554 if (p.parseBitShiftExpr() and blk_1: {
555 while (blk_3: {
556 const pos_3 = p.i;
557 if (p.parseBitwiseOp() and p.parseBitShiftExpr()) break :blk_3 true;
558 p.i = pos_3;
559 break :blk_3 false;
560 }) {}
561 break :blk_1 true;
562 }) break :blk_0 true;
563 p.i = pos_0;
564 break :blk_0 false;
565 };
566 }
567 pub fn parseBitShiftExpr(p: *Parser) bool {
568 return blk_0: {
569 const pos_0 = p.i;
570 if (p.parseAdditionExpr() and blk_1: {
571 while (blk_3: {
572 const pos_3 = p.i;
573 if (p.parseBitShiftOp() and p.parseAdditionExpr()) break :blk_3 true;
574 p.i = pos_3;
575 break :blk_3 false;
576 }) {}
577 break :blk_1 true;
578 }) break :blk_0 true;
579 p.i = pos_0;
580 break :blk_0 false;
581 };
582 }
583 pub fn parseAdditionExpr(p: *Parser) bool {
584 return blk_0: {
585 const pos_0 = p.i;
586 if (p.parseMultiplyExpr() and blk_1: {
587 while (blk_3: {
588 const pos_3 = p.i;
589 if (p.parseAdditionOp() and p.parseMultiplyExpr()) break :blk_3 true;
590 p.i = pos_3;
591 break :blk_3 false;
592 }) {}
593 break :blk_1 true;
594 }) break :blk_0 true;
595 p.i = pos_0;
596 break :blk_0 false;
597 };
598 }
599 pub fn parseMultiplyExpr(p: *Parser) bool {
600 return blk_0: {
601 const pos_0 = p.i;
602 if (p.parsePrefixExpr() and blk_1: {
603 while (blk_3: {
604 const pos_3 = p.i;
605 if (p.parseMultiplyOp() and p.parsePrefixExpr()) break :blk_3 true;
606 p.i = pos_3;
607 break :blk_3 false;
608 }) {}
609 break :blk_1 true;
610 }) break :blk_0 true;
611 p.i = pos_0;
612 break :blk_0 false;
613 };
614 }
615 pub fn parsePrefixExpr(p: *Parser) bool {
616 return blk_0: {
617 const pos_0 = p.i;
618 if (blk_1: {
619 while (p.parsePrefixOp()) {}
620 break :blk_1 true;
621 } and p.parsePrimaryExpr()) break :blk_0 true;
622 p.i = pos_0;
623 break :blk_0 false;
624 };
625 }
626 pub fn parsePrimaryExpr(p: *Parser) bool {
627 return blk_0: {
628 const pos_0 = p.i;
629 if (p.parseAsmExpr()) break :blk_0 true;
630 p.i = pos_0;
631 if (p.parseIfExpr()) break :blk_0 true;
632 p.i = pos_0;
633 if (p.parseKEYWORD_break() and blk_2: {
634 const pos_2 = p.i;
635 if (p.parseBreakLabel()) break :blk_2 true;
636 p.i = pos_2;
637 if (blk_3: {
638 const pos_3 = p.i;
639 const match_3 = p.parseBreakLabel();
640 p.i = pos_3;
641 break :blk_3 !match_3;
642 }) break :blk_2 true;
643 p.i = pos_2;
644 break :blk_2 false;
645 } and blk_2: {
646 const pos_2 = p.i;
647 if (p.parseExpr() and blk_3: {
648 const pos_3 = p.i;
649 const match_3 = p.parseExprSuffix();
650 p.i = pos_3;
651 break :blk_3 !match_3;
652 }) break :blk_2 true;
653 p.i = pos_2;
654 if (blk_3: {
655 const pos_3 = p.i;
656 const match_3 = p.parseSinglePtrTypeStart();
657 p.i = pos_3;
658 break :blk_3 !match_3;
659 }) break :blk_2 true;
660 p.i = pos_2;
661 break :blk_2 false;
662 }) break :blk_0 true;
663 p.i = pos_0;
664 if (p.parseKEYWORD_comptime() and p.parseExpr() and blk_1: {
665 const pos_1 = p.i;
666 const match_1 = p.parseExprSuffix();
667 p.i = pos_1;
668 break :blk_1 !match_1;
669 }) break :blk_0 true;
670 p.i = pos_0;
671 if (p.parseKEYWORD_nosuspend() and p.parseExpr() and blk_1: {
672 const pos_1 = p.i;
673 const match_1 = p.parseExprSuffix();
674 p.i = pos_1;
675 break :blk_1 !match_1;
676 }) break :blk_0 true;
677 p.i = pos_0;
678 if (p.parseKEYWORD_continue() and blk_2: {
679 const pos_2 = p.i;
680 if (p.parseBreakLabel()) break :blk_2 true;
681 p.i = pos_2;
682 if (blk_3: {
683 const pos_3 = p.i;
684 const match_3 = p.parseBreakLabel();
685 p.i = pos_3;
686 break :blk_3 !match_3;
687 }) break :blk_2 true;
688 p.i = pos_2;
689 break :blk_2 false;
690 } and blk_2: {
691 const pos_2 = p.i;
692 if (p.parseExpr() and blk_3: {
693 const pos_3 = p.i;
694 const match_3 = p.parseExprSuffix();
695 p.i = pos_3;
696 break :blk_3 !match_3;
697 }) break :blk_2 true;
698 p.i = pos_2;
699 if (blk_3: {
700 const pos_3 = p.i;
701 const match_3 = p.parseSinglePtrTypeStart();
702 p.i = pos_3;
703 break :blk_3 !match_3;
704 }) break :blk_2 true;
705 p.i = pos_2;
706 break :blk_2 false;
707 }) break :blk_0 true;
708 p.i = pos_0;
709 if (p.parseKEYWORD_resume() and p.parseExpr() and blk_1: {
710 const pos_1 = p.i;
711 const match_1 = p.parseExprSuffix();
712 p.i = pos_1;
713 break :blk_1 !match_1;
714 }) break :blk_0 true;
715 p.i = pos_0;
716 if (p.parseKEYWORD_return() and blk_2: {
717 const pos_2 = p.i;
718 if (p.parseExpr() and blk_3: {
719 const pos_3 = p.i;
720 const match_3 = p.parseExprSuffix();
721 p.i = pos_3;
722 break :blk_3 !match_3;
723 }) break :blk_2 true;
724 p.i = pos_2;
725 if (blk_3: {
726 const pos_3 = p.i;
727 const match_3 = p.parseSinglePtrTypeStart();
728 p.i = pos_3;
729 break :blk_3 !match_3;
730 }) break :blk_2 true;
731 p.i = pos_2;
732 break :blk_2 false;
733 }) break :blk_0 true;
734 p.i = pos_0;
735 if ((p.parseBlockLabel() or true) and p.parseLoopExpr()) break :blk_0 true;
736 p.i = pos_0;
737 if (p.parseBlock()) break :blk_0 true;
738 p.i = pos_0;
739 if (p.parseCurlySuffixExpr()) break :blk_0 true;
740 p.i = pos_0;
741 break :blk_0 false;
742 };
743 }
744 pub fn parseIfExpr(p: *Parser) bool {
745 return blk_0: {
746 const pos_0 = p.i;
747 if (p.parseIfPrefix() and p.parseExpr() and (blk_3: {
748 const pos_3 = p.i;
749 if (p.parseKEYWORD_else() and (p.parsePayload() or true) and p.parseExpr()) break :blk_3 true;
750 p.i = pos_3;
751 break :blk_3 false;
752 } or true) and blk_1: {
753 const pos_1 = p.i;
754 const match_1 = p.parseExprSuffix();
755 p.i = pos_1;
756 break :blk_1 !match_1;
757 }) break :blk_0 true;
758 p.i = pos_0;
759 break :blk_0 false;
760 };
761 }
762 pub fn parseBlock(p: *Parser) bool {
763 return blk_0: {
764 const pos_0 = p.i;
765 if (p.parseLBRACE() and blk_1: {
766 while (p.parseBlockStatement()) {}
767 break :blk_1 true;
768 } and p.parseRBRACE()) break :blk_0 true;
769 p.i = pos_0;
770 break :blk_0 false;
771 };
772 }
773 pub fn parseLoopExpr(p: *Parser) bool {
774 return blk_0: {
775 const pos_0 = p.i;
776 if ((p.parseKEYWORD_inline() or true) and blk_2: {
777 const pos_2 = p.i;
778 if (p.parseForExpr()) break :blk_2 true;
779 p.i = pos_2;
780 if (p.parseWhileExpr()) break :blk_2 true;
781 p.i = pos_2;
782 break :blk_2 false;
783 }) break :blk_0 true;
784 p.i = pos_0;
785 break :blk_0 false;
786 };
787 }
788 pub fn parseForExpr(p: *Parser) bool {
789 return blk_0: {
790 const pos_0 = p.i;
791 if (p.parseForPrefix() and p.parseExpr() and blk_2: {
792 const pos_2 = p.i;
793 if (p.parseKEYWORD_else() and p.parseExpr()) break :blk_2 true;
794 p.i = pos_2;
795 if (blk_3: {
796 const pos_3 = p.i;
797 const match_3 = p.parseKEYWORD_else();
798 p.i = pos_3;
799 break :blk_3 !match_3;
800 }) break :blk_2 true;
801 p.i = pos_2;
802 break :blk_2 false;
803 } and blk_1: {
804 const pos_1 = p.i;
805 const match_1 = p.parseExprSuffix();
806 p.i = pos_1;
807 break :blk_1 !match_1;
808 }) break :blk_0 true;
809 p.i = pos_0;
810 break :blk_0 false;
811 };
812 }
813 pub fn parseWhileExpr(p: *Parser) bool {
814 return blk_0: {
815 const pos_0 = p.i;
816 if (p.parseWhilePrefix() and p.parseExpr() and (blk_3: {
817 const pos_3 = p.i;
818 if (p.parseKEYWORD_else() and (p.parsePayload() or true) and p.parseExpr()) break :blk_3 true;
819 p.i = pos_3;
820 break :blk_3 false;
821 } or true) and blk_1: {
822 const pos_1 = p.i;
823 const match_1 = p.parseExprSuffix();
824 p.i = pos_1;
825 break :blk_1 !match_1;
826 }) break :blk_0 true;
827 p.i = pos_0;
828 break :blk_0 false;
829 };
830 }
831 pub fn parseCurlySuffixExpr(p: *Parser) bool {
832 return blk_0: {
833 const pos_0 = p.i;
834 if (p.parseTypeExpr() and (p.parseInitList() or true)) break :blk_0 true;
835 p.i = pos_0;
836 break :blk_0 false;
837 };
838 }
839 pub fn parseInitList(p: *Parser) bool {
840 return blk_0: {
841 const pos_0 = p.i;
842 if (p.parseLBRACE() and p.parseFieldInit() and blk_1: {
843 while (blk_3: {
844 const pos_3 = p.i;
845 if (p.parseCOMMA() and p.parseFieldInit()) break :blk_3 true;
846 p.i = pos_3;
847 break :blk_3 false;
848 }) {}
849 break :blk_1 true;
850 } and (p.parseCOMMA() or true) and p.parseRBRACE()) break :blk_0 true;
851 p.i = pos_0;
852 if (p.parseLBRACE() and p.parseExpr() and blk_1: {
853 while (blk_3: {
854 const pos_3 = p.i;
855 if (p.parseCOMMA() and p.parseExpr()) break :blk_3 true;
856 p.i = pos_3;
857 break :blk_3 false;
858 }) {}
859 break :blk_1 true;
860 } and (p.parseCOMMA() or true) and p.parseRBRACE()) break :blk_0 true;
861 p.i = pos_0;
862 if (p.parseLBRACE() and p.parseRBRACE()) break :blk_0 true;
863 p.i = pos_0;
864 break :blk_0 false;
865 };
866 }
867 pub fn parseTypeExpr(p: *Parser) bool {
868 return blk_0: {
869 const pos_0 = p.i;
870 if (blk_1: {
871 while (p.parsePrefixTypeOp()) {}
872 break :blk_1 true;
873 } and p.parseErrorUnionExpr()) break :blk_0 true;
874 p.i = pos_0;
875 break :blk_0 false;
876 };
877 }
878 pub fn parseErrorUnionExpr(p: *Parser) bool {
879 return blk_0: {
880 const pos_0 = p.i;
881 if (p.parseSuffixExpr() and (blk_3: {
882 const pos_3 = p.i;
883 if (p.parseEXCLAMATIONMARK() and p.parseTypeExpr()) break :blk_3 true;
884 p.i = pos_3;
885 break :blk_3 false;
886 } or true)) break :blk_0 true;
887 p.i = pos_0;
888 break :blk_0 false;
889 };
890 }
891 pub fn parseSuffixExpr(p: *Parser) bool {
892 return blk_0: {
893 const pos_0 = p.i;
894 if (p.parsePrimaryTypeExpr() and blk_1: {
895 while (blk_3: {
896 const pos_3 = p.i;
897 if (p.parseSuffixOp()) break :blk_3 true;
898 p.i = pos_3;
899 if (p.parseFnCallArguments()) break :blk_3 true;
900 p.i = pos_3;
901 break :blk_3 false;
902 }) {}
903 break :blk_1 true;
904 }) break :blk_0 true;
905 p.i = pos_0;
906 break :blk_0 false;
907 };
908 }
909 pub fn parsePrimaryTypeExpr(p: *Parser) bool {
910 return blk_0: {
911 const pos_0 = p.i;
912 if (p.parseBUILTINIDENTIFIER() and p.parseFnCallArguments()) break :blk_0 true;
913 p.i = pos_0;
914 if (p.parseCHAR_LITERAL()) break :blk_0 true;
915 p.i = pos_0;
916 if (p.parseContainerDecl()) break :blk_0 true;
917 p.i = pos_0;
918 if (p.parseDOT() and p.parseIDENTIFIER()) break :blk_0 true;
919 p.i = pos_0;
920 if (p.parseDOT() and p.parseInitList()) break :blk_0 true;
921 p.i = pos_0;
922 if (p.parseErrorSetDecl()) break :blk_0 true;
923 p.i = pos_0;
924 if (p.parseFLOAT()) break :blk_0 true;
925 p.i = pos_0;
926 if (p.parseFnProto()) break :blk_0 true;
927 p.i = pos_0;
928 if (p.parseGroupedExpr()) break :blk_0 true;
929 p.i = pos_0;
930 if (p.parseLabeledTypeExpr()) break :blk_0 true;
931 p.i = pos_0;
932 if (p.parseIDENTIFIER() and blk_1: {
933 const pos_1 = p.i;
934 const match_1 = blk_3: {
935 const pos_3 = p.i;
936 if (p.parseCOLON() and p.parseLabelableExpr()) break :blk_3 true;
937 p.i = pos_3;
938 break :blk_3 false;
939 };
940 p.i = pos_1;
941 break :blk_1 !match_1;
942 }) break :blk_0 true;
943 p.i = pos_0;
944 if (p.parseIfTypeExpr()) break :blk_0 true;
945 p.i = pos_0;
946 if (p.parseINTEGER()) break :blk_0 true;
947 p.i = pos_0;
948 if (p.parseKEYWORD_comptime() and p.parseTypeExpr() and blk_1: {
949 const pos_1 = p.i;
950 const match_1 = p.parseExprSuffix();
951 p.i = pos_1;
952 break :blk_1 !match_1;
953 }) break :blk_0 true;
954 p.i = pos_0;
955 if (p.parseKEYWORD_error() and p.parseDOT() and p.parseIDENTIFIER()) break :blk_0 true;
956 p.i = pos_0;
957 if (p.parseKEYWORD_anyframe()) break :blk_0 true;
958 p.i = pos_0;
959 if (p.parseKEYWORD_unreachable()) break :blk_0 true;
960 p.i = pos_0;
961 if (p.parseSTRINGLITERAL()) break :blk_0 true;
962 p.i = pos_0;
963 break :blk_0 false;
964 };
965 }
966 pub fn parseContainerDecl(p: *Parser) bool {
967 return blk_0: {
968 const pos_0 = p.i;
969 if ((blk_3: {
970 const pos_3 = p.i;
971 if (p.parseKEYWORD_extern()) break :blk_3 true;
972 p.i = pos_3;
973 if (p.parseKEYWORD_packed()) break :blk_3 true;
974 p.i = pos_3;
975 break :blk_3 false;
976 } or true) and p.parseContainerDeclAuto()) break :blk_0 true;
977 p.i = pos_0;
978 break :blk_0 false;
979 };
980 }
981 pub fn parseErrorSetDecl(p: *Parser) bool {
982 return blk_0: {
983 const pos_0 = p.i;
984 if (p.parseKEYWORD_error() and p.parseLBRACE() and p.parseIdentifierList() and p.parseRBRACE()) break :blk_0 true;
985 p.i = pos_0;
986 break :blk_0 false;
987 };
988 }
989 pub fn parseGroupedExpr(p: *Parser) bool {
990 return blk_0: {
991 const pos_0 = p.i;
992 if (p.parseLPAREN() and p.parseExpr() and p.parseRPAREN()) break :blk_0 true;
993 p.i = pos_0;
994 break :blk_0 false;
995 };
996 }
997 pub fn parseIfTypeExpr(p: *Parser) bool {
998 return blk_0: {
999 const pos_0 = p.i;
1000 if (p.parseIfPrefix() and p.parseTypeExpr() and (blk_3: {
1001 const pos_3 = p.i;
1002 if (p.parseKEYWORD_else() and (p.parsePayload() or true) and p.parseTypeExpr()) break :blk_3 true;
1003 p.i = pos_3;
1004 break :blk_3 false;
1005 } or true) and blk_1: {
1006 const pos_1 = p.i;
1007 const match_1 = p.parseExprSuffix();
1008 p.i = pos_1;
1009 break :blk_1 !match_1;
1010 }) break :blk_0 true;
1011 p.i = pos_0;
1012 break :blk_0 false;
1013 };
1014 }
1015 pub fn parseLabeledTypeExpr(p: *Parser) bool {
1016 return blk_0: {
1017 const pos_0 = p.i;
1018 if (p.parseBlockLabel() and p.parseBlock()) break :blk_0 true;
1019 p.i = pos_0;
1020 if ((p.parseBlockLabel() or true) and p.parseLoopTypeExpr()) break :blk_0 true;
1021 p.i = pos_0;
1022 if ((p.parseBlockLabel() or true) and p.parseSwitchExpr()) break :blk_0 true;
1023 p.i = pos_0;
1024 break :blk_0 false;
1025 };
1026 }
1027 pub fn parseLoopTypeExpr(p: *Parser) bool {
1028 return blk_0: {
1029 const pos_0 = p.i;
1030 if ((p.parseKEYWORD_inline() or true) and blk_2: {
1031 const pos_2 = p.i;
1032 if (p.parseForTypeExpr()) break :blk_2 true;
1033 p.i = pos_2;
1034 if (p.parseWhileTypeExpr()) break :blk_2 true;
1035 p.i = pos_2;
1036 break :blk_2 false;
1037 }) break :blk_0 true;
1038 p.i = pos_0;
1039 break :blk_0 false;
1040 };
1041 }
1042 pub fn parseForTypeExpr(p: *Parser) bool {
1043 return blk_0: {
1044 const pos_0 = p.i;
1045 if (p.parseForPrefix() and p.parseTypeExpr() and blk_2: {
1046 const pos_2 = p.i;
1047 if (p.parseKEYWORD_else() and p.parseTypeExpr()) break :blk_2 true;
1048 p.i = pos_2;
1049 if (blk_3: {
1050 const pos_3 = p.i;
1051 const match_3 = p.parseKEYWORD_else();
1052 p.i = pos_3;
1053 break :blk_3 !match_3;
1054 }) break :blk_2 true;
1055 p.i = pos_2;
1056 break :blk_2 false;
1057 } and blk_1: {
1058 const pos_1 = p.i;
1059 const match_1 = p.parseExprSuffix();
1060 p.i = pos_1;
1061 break :blk_1 !match_1;
1062 }) break :blk_0 true;
1063 p.i = pos_0;
1064 break :blk_0 false;
1065 };
1066 }
1067 pub fn parseWhileTypeExpr(p: *Parser) bool {
1068 return blk_0: {
1069 const pos_0 = p.i;
1070 if (p.parseWhilePrefix() and p.parseTypeExpr() and (blk_3: {
1071 const pos_3 = p.i;
1072 if (p.parseKEYWORD_else() and (p.parsePayload() or true) and p.parseTypeExpr()) break :blk_3 true;
1073 p.i = pos_3;
1074 break :blk_3 false;
1075 } or true) and blk_1: {
1076 const pos_1 = p.i;
1077 const match_1 = p.parseExprSuffix();
1078 p.i = pos_1;
1079 break :blk_1 !match_1;
1080 }) break :blk_0 true;
1081 p.i = pos_0;
1082 break :blk_0 false;
1083 };
1084 }
1085 pub fn parseSwitchExpr(p: *Parser) bool {
1086 return blk_0: {
1087 const pos_0 = p.i;
1088 if (p.parseKEYWORD_switch() and p.parseLPAREN() and p.parseExpr() and p.parseRPAREN() and p.parseLBRACE() and p.parseSwitchProngList() and p.parseRBRACE()) break :blk_0 true;
1089 p.i = pos_0;
1090 break :blk_0 false;
1091 };
1092 }
1093 pub fn parseAsmExpr(p: *Parser) bool {
1094 return blk_0: {
1095 const pos_0 = p.i;
1096 if (p.parseKEYWORD_asm() and (p.parseKEYWORD_volatile() or true) and p.parseLPAREN() and p.parseExpr() and (p.parseAsmOutput() or true) and p.parseRPAREN()) break :blk_0 true;
1097 p.i = pos_0;
1098 break :blk_0 false;
1099 };
1100 }
1101 pub fn parseAsmOutput(p: *Parser) bool {
1102 return blk_0: {
1103 const pos_0 = p.i;
1104 if (p.parseCOLON() and p.parseAsmOutputList() and (p.parseAsmInput() or true)) break :blk_0 true;
1105 p.i = pos_0;
1106 break :blk_0 false;
1107 };
1108 }
1109 pub fn parseAsmOutputItem(p: *Parser) bool {
1110 return blk_0: {
1111 const pos_0 = p.i;
1112 if (p.parseLBRACKET() and p.parseIDENTIFIER() and p.parseRBRACKET() and p.parseSTRINGLITERALSINGLE() and p.parseLPAREN() and blk_2: {
1113 const pos_2 = p.i;
1114 if (p.parseMINUSRARROW() and p.parseTypeExpr()) break :blk_2 true;
1115 p.i = pos_2;
1116 if (p.parseIDENTIFIER()) break :blk_2 true;
1117 p.i = pos_2;
1118 break :blk_2 false;
1119 } and p.parseRPAREN()) break :blk_0 true;
1120 p.i = pos_0;
1121 break :blk_0 false;
1122 };
1123 }
1124 pub fn parseAsmInput(p: *Parser) bool {
1125 return blk_0: {
1126 const pos_0 = p.i;
1127 if (p.parseCOLON() and p.parseAsmInputList() and (p.parseAsmClobbers() or true)) break :blk_0 true;
1128 p.i = pos_0;
1129 break :blk_0 false;
1130 };
1131 }
1132 pub fn parseAsmInputItem(p: *Parser) bool {
1133 return blk_0: {
1134 const pos_0 = p.i;
1135 if (p.parseLBRACKET() and p.parseIDENTIFIER() and p.parseRBRACKET() and p.parseSTRINGLITERALSINGLE() and p.parseLPAREN() and p.parseExpr() and p.parseRPAREN()) break :blk_0 true;
1136 p.i = pos_0;
1137 break :blk_0 false;
1138 };
1139 }
1140 pub fn parseAsmClobbers(p: *Parser) bool {
1141 return blk_0: {
1142 const pos_0 = p.i;
1143 if (p.parseCOLON() and p.parseExpr()) break :blk_0 true;
1144 p.i = pos_0;
1145 break :blk_0 false;
1146 };
1147 }
1148 pub fn parseBreakLabel(p: *Parser) bool {
1149 return blk_0: {
1150 const pos_0 = p.i;
1151 if (p.parseCOLON() and p.parseIDENTIFIER()) break :blk_0 true;
1152 p.i = pos_0;
1153 break :blk_0 false;
1154 };
1155 }
1156 pub fn parseBlockLabel(p: *Parser) bool {
1157 return blk_0: {
1158 const pos_0 = p.i;
1159 if (p.parseIDENTIFIER() and p.parseCOLON()) break :blk_0 true;
1160 p.i = pos_0;
1161 break :blk_0 false;
1162 };
1163 }
1164 pub fn parseFieldInit(p: *Parser) bool {
1165 return blk_0: {
1166 const pos_0 = p.i;
1167 if (p.parseDOT() and p.parseIDENTIFIER() and p.parseEQUAL() and p.parseExpr()) break :blk_0 true;
1168 p.i = pos_0;
1169 break :blk_0 false;
1170 };
1171 }
1172 pub fn parseWhileContinueExpr(p: *Parser) bool {
1173 return blk_0: {
1174 const pos_0 = p.i;
1175 if (p.parseCOLON() and p.parseLPAREN() and p.parseAssignExpr() and p.parseRPAREN()) break :blk_0 true;
1176 p.i = pos_0;
1177 break :blk_0 false;
1178 };
1179 }
1180 pub fn parseLinkSection(p: *Parser) bool {
1181 return blk_0: {
1182 const pos_0 = p.i;
1183 if (p.parseKEYWORD_linksection() and p.parseLPAREN() and p.parseExpr() and p.parseRPAREN()) break :blk_0 true;
1184 p.i = pos_0;
1185 break :blk_0 false;
1186 };
1187 }
1188 pub fn parseAddrSpace(p: *Parser) bool {
1189 return blk_0: {
1190 const pos_0 = p.i;
1191 if (p.parseKEYWORD_addrspace() and p.parseLPAREN() and p.parseExpr() and p.parseRPAREN()) break :blk_0 true;
1192 p.i = pos_0;
1193 break :blk_0 false;
1194 };
1195 }
1196 pub fn parseCallConv(p: *Parser) bool {
1197 return blk_0: {
1198 const pos_0 = p.i;
1199 if (p.parseKEYWORD_callconv() and p.parseLPAREN() and p.parseExpr() and p.parseRPAREN()) break :blk_0 true;
1200 p.i = pos_0;
1201 break :blk_0 false;
1202 };
1203 }
1204 pub fn parseParamDecl(p: *Parser) bool {
1205 return blk_0: {
1206 const pos_0 = p.i;
1207 if ((p.parsedoc_comment() or true) and blk_2: {
1208 const pos_2 = p.i;
1209 if (p.parseKEYWORD_noalias()) break :blk_2 true;
1210 p.i = pos_2;
1211 if (p.parseKEYWORD_comptime()) break :blk_2 true;
1212 p.i = pos_2;
1213 if (blk_3: {
1214 const pos_3 = p.i;
1215 const match_3 = p.parseKEYWORD_comptime();
1216 p.i = pos_3;
1217 break :blk_3 !match_3;
1218 }) break :blk_2 true;
1219 p.i = pos_2;
1220 break :blk_2 false;
1221 } and blk_2: {
1222 const pos_2 = p.i;
1223 if (p.parseIDENTIFIER() and p.parseCOLON()) break :blk_2 true;
1224 p.i = pos_2;
1225 if (blk_3: {
1226 const pos_3 = p.i;
1227 const match_3 = blk_5: {
1228 const pos_5 = p.i;
1229 if (p.parseIDENTIFIER() and p.parseCOLON()) break :blk_5 true;
1230 p.i = pos_5;
1231 break :blk_5 false;
1232 };
1233 p.i = pos_3;
1234 break :blk_3 !match_3;
1235 }) break :blk_2 true;
1236 p.i = pos_2;
1237 break :blk_2 false;
1238 } and p.parseParamType()) break :blk_0 true;
1239 p.i = pos_0;
1240 break :blk_0 false;
1241 };
1242 }
1243 pub fn parseParamType(p: *Parser) bool {
1244 return blk_0: {
1245 const pos_0 = p.i;
1246 if (p.parseKEYWORD_anytype()) break :blk_0 true;
1247 p.i = pos_0;
1248 if (p.parseTypeExpr()) break :blk_0 true;
1249 p.i = pos_0;
1250 break :blk_0 false;
1251 };
1252 }
1253 pub fn parseIfPrefix(p: *Parser) bool {
1254 return blk_0: {
1255 const pos_0 = p.i;
1256 if (p.parseKEYWORD_if() and p.parseLPAREN() and p.parseExpr() and p.parseRPAREN() and (p.parsePtrPayload() or true)) break :blk_0 true;
1257 p.i = pos_0;
1258 break :blk_0 false;
1259 };
1260 }
1261 pub fn parseWhilePrefix(p: *Parser) bool {
1262 return blk_0: {
1263 const pos_0 = p.i;
1264 if (p.parseKEYWORD_while() and p.parseLPAREN() and p.parseExpr() and p.parseRPAREN() and (p.parsePtrPayload() or true) and (p.parseWhileContinueExpr() or true)) break :blk_0 true;
1265 p.i = pos_0;
1266 break :blk_0 false;
1267 };
1268 }
1269 pub fn parseForPrefix(p: *Parser) bool {
1270 return blk_0: {
1271 const pos_0 = p.i;
1272 if (p.parseKEYWORD_for() and p.parseLPAREN() and p.parseForArgumentsList() and p.parseRPAREN() and p.parsePtrListPayload()) break :blk_0 true;
1273 p.i = pos_0;
1274 break :blk_0 false;
1275 };
1276 }
1277 pub fn parsePayload(p: *Parser) bool {
1278 return blk_0: {
1279 const pos_0 = p.i;
1280 if (p.parsePIPE() and p.parseIDENTIFIER() and p.parsePIPE()) break :blk_0 true;
1281 p.i = pos_0;
1282 break :blk_0 false;
1283 };
1284 }
1285 pub fn parsePtrPayload(p: *Parser) bool {
1286 return blk_0: {
1287 const pos_0 = p.i;
1288 if (p.parsePIPE() and (p.parseASTERISK() or true) and p.parseIDENTIFIER() and p.parsePIPE()) break :blk_0 true;
1289 p.i = pos_0;
1290 break :blk_0 false;
1291 };
1292 }
1293 pub fn parsePtrIndexPayload(p: *Parser) bool {
1294 return blk_0: {
1295 const pos_0 = p.i;
1296 if (p.parsePIPE() and (p.parseASTERISK() or true) and p.parseIDENTIFIER() and (blk_3: {
1297 const pos_3 = p.i;
1298 if (p.parseCOMMA() and p.parseIDENTIFIER()) break :blk_3 true;
1299 p.i = pos_3;
1300 break :blk_3 false;
1301 } or true) and p.parsePIPE()) break :blk_0 true;
1302 p.i = pos_0;
1303 break :blk_0 false;
1304 };
1305 }
1306 pub fn parsePtrListPayload(p: *Parser) bool {
1307 return blk_0: {
1308 const pos_0 = p.i;
1309 if (p.parsePIPE() and (p.parseASTERISK() or true) and p.parseIDENTIFIER() and blk_1: {
1310 while (blk_3: {
1311 const pos_3 = p.i;
1312 if (p.parseCOMMA() and (p.parseASTERISK() or true) and p.parseIDENTIFIER()) break :blk_3 true;
1313 p.i = pos_3;
1314 break :blk_3 false;
1315 }) {}
1316 break :blk_1 true;
1317 } and (p.parseCOMMA() or true) and p.parsePIPE()) break :blk_0 true;
1318 p.i = pos_0;
1319 break :blk_0 false;
1320 };
1321 }
1322 pub fn parseSwitchProng(p: *Parser) bool {
1323 return blk_0: {
1324 const pos_0 = p.i;
1325 if ((p.parseKEYWORD_inline() or true) and p.parseSwitchCase() and p.parseEQUALRARROW() and (p.parsePtrIndexPayload() or true) and p.parseSingleAssignExpr()) break :blk_0 true;
1326 p.i = pos_0;
1327 break :blk_0 false;
1328 };
1329 }
1330 pub fn parseSwitchCase(p: *Parser) bool {
1331 return blk_0: {
1332 const pos_0 = p.i;
1333 if (p.parseSwitchItem() and blk_1: {
1334 while (blk_3: {
1335 const pos_3 = p.i;
1336 if (p.parseCOMMA() and p.parseSwitchItem()) break :blk_3 true;
1337 p.i = pos_3;
1338 break :blk_3 false;
1339 }) {}
1340 break :blk_1 true;
1341 } and (p.parseCOMMA() or true)) break :blk_0 true;
1342 p.i = pos_0;
1343 if (p.parseKEYWORD_else()) break :blk_0 true;
1344 p.i = pos_0;
1345 break :blk_0 false;
1346 };
1347 }
1348 pub fn parseSwitchItem(p: *Parser) bool {
1349 return blk_0: {
1350 const pos_0 = p.i;
1351 if (p.parseExpr() and (blk_3: {
1352 const pos_3 = p.i;
1353 if (p.parseDOT3() and p.parseExpr()) break :blk_3 true;
1354 p.i = pos_3;
1355 break :blk_3 false;
1356 } or true)) break :blk_0 true;
1357 p.i = pos_0;
1358 break :blk_0 false;
1359 };
1360 }
1361 pub fn parseForArgumentsList(p: *Parser) bool {
1362 return blk_0: {
1363 const pos_0 = p.i;
1364 if (p.parseForItem() and blk_1: {
1365 while (blk_3: {
1366 const pos_3 = p.i;
1367 if (p.parseCOMMA() and p.parseForItem()) break :blk_3 true;
1368 p.i = pos_3;
1369 break :blk_3 false;
1370 }) {}
1371 break :blk_1 true;
1372 } and (p.parseCOMMA() or true)) break :blk_0 true;
1373 p.i = pos_0;
1374 break :blk_0 false;
1375 };
1376 }
1377 pub fn parseForItem(p: *Parser) bool {
1378 return blk_0: {
1379 const pos_0 = p.i;
1380 if (p.parseExpr() and (blk_3: {
1381 const pos_3 = p.i;
1382 if (p.parseDOT2() and (p.parseExpr() or true)) break :blk_3 true;
1383 p.i = pos_3;
1384 break :blk_3 false;
1385 } or true)) break :blk_0 true;
1386 p.i = pos_0;
1387 break :blk_0 false;
1388 };
1389 }
1390 pub fn parseAssignOp(p: *Parser) bool {
1391 return blk_0: {
1392 const pos_0 = p.i;
1393 if (p.parseASTERISKEQUAL()) break :blk_0 true;
1394 p.i = pos_0;
1395 if (p.parseASTERISKPIPEEQUAL()) break :blk_0 true;
1396 p.i = pos_0;
1397 if (p.parseSLASHEQUAL()) break :blk_0 true;
1398 p.i = pos_0;
1399 if (p.parsePERCENTEQUAL()) break :blk_0 true;
1400 p.i = pos_0;
1401 if (p.parsePLUSEQUAL()) break :blk_0 true;
1402 p.i = pos_0;
1403 if (p.parsePLUSPIPEEQUAL()) break :blk_0 true;
1404 p.i = pos_0;
1405 if (p.parseMINUSEQUAL()) break :blk_0 true;
1406 p.i = pos_0;
1407 if (p.parseMINUSPIPEEQUAL()) break :blk_0 true;
1408 p.i = pos_0;
1409 if (p.parseLARROW2EQUAL()) break :blk_0 true;
1410 p.i = pos_0;
1411 if (p.parseLARROW2PIPEEQUAL()) break :blk_0 true;
1412 p.i = pos_0;
1413 if (p.parseRARROW2EQUAL()) break :blk_0 true;
1414 p.i = pos_0;
1415 if (p.parseAMPERSANDEQUAL()) break :blk_0 true;
1416 p.i = pos_0;
1417 if (p.parseCARETEQUAL()) break :blk_0 true;
1418 p.i = pos_0;
1419 if (p.parsePIPEEQUAL()) break :blk_0 true;
1420 p.i = pos_0;
1421 if (p.parseASTERISKPERCENTEQUAL()) break :blk_0 true;
1422 p.i = pos_0;
1423 if (p.parsePLUSPERCENTEQUAL()) break :blk_0 true;
1424 p.i = pos_0;
1425 if (p.parseMINUSPERCENTEQUAL()) break :blk_0 true;
1426 p.i = pos_0;
1427 if (p.parseEQUAL()) break :blk_0 true;
1428 p.i = pos_0;
1429 break :blk_0 false;
1430 };
1431 }
1432 pub fn parseCompareOp(p: *Parser) bool {
1433 return blk_0: {
1434 const pos_0 = p.i;
1435 if (p.parseEQUALEQUAL()) break :blk_0 true;
1436 p.i = pos_0;
1437 if (p.parseEXCLAMATIONMARKEQUAL()) break :blk_0 true;
1438 p.i = pos_0;
1439 if (p.parseLARROW()) break :blk_0 true;
1440 p.i = pos_0;
1441 if (p.parseRARROW()) break :blk_0 true;
1442 p.i = pos_0;
1443 if (p.parseLARROWEQUAL()) break :blk_0 true;
1444 p.i = pos_0;
1445 if (p.parseRARROWEQUAL()) break :blk_0 true;
1446 p.i = pos_0;
1447 break :blk_0 false;
1448 };
1449 }
1450 pub fn parseBitwiseOp(p: *Parser) bool {
1451 return blk_0: {
1452 const pos_0 = p.i;
1453 if (p.parseAMPERSAND()) break :blk_0 true;
1454 p.i = pos_0;
1455 if (p.parseCARET()) break :blk_0 true;
1456 p.i = pos_0;
1457 if (p.parsePIPE()) break :blk_0 true;
1458 p.i = pos_0;
1459 if (p.parseKEYWORD_orelse()) break :blk_0 true;
1460 p.i = pos_0;
1461 if (p.parseKEYWORD_catch() and (p.parsePayload() or true)) break :blk_0 true;
1462 p.i = pos_0;
1463 break :blk_0 false;
1464 };
1465 }
1466 pub fn parseBitShiftOp(p: *Parser) bool {
1467 return blk_0: {
1468 const pos_0 = p.i;
1469 if (p.parseLARROW2()) break :blk_0 true;
1470 p.i = pos_0;
1471 if (p.parseRARROW2()) break :blk_0 true;
1472 p.i = pos_0;
1473 if (p.parseLARROW2PIPE()) break :blk_0 true;
1474 p.i = pos_0;
1475 break :blk_0 false;
1476 };
1477 }
1478 pub fn parseAdditionOp(p: *Parser) bool {
1479 return blk_0: {
1480 const pos_0 = p.i;
1481 if (p.parsePLUS()) break :blk_0 true;
1482 p.i = pos_0;
1483 if (p.parseMINUS()) break :blk_0 true;
1484 p.i = pos_0;
1485 if (p.parsePLUS2()) break :blk_0 true;
1486 p.i = pos_0;
1487 if (p.parsePLUSPERCENT()) break :blk_0 true;
1488 p.i = pos_0;
1489 if (p.parseMINUSPERCENT()) break :blk_0 true;
1490 p.i = pos_0;
1491 if (p.parsePLUSPIPE()) break :blk_0 true;
1492 p.i = pos_0;
1493 if (p.parseMINUSPIPE()) break :blk_0 true;
1494 p.i = pos_0;
1495 break :blk_0 false;
1496 };
1497 }
1498 pub fn parseMultiplyOp(p: *Parser) bool {
1499 return blk_0: {
1500 const pos_0 = p.i;
1501 if (p.parsePIPE2()) break :blk_0 true;
1502 p.i = pos_0;
1503 if (p.parseASTERISK()) break :blk_0 true;
1504 p.i = pos_0;
1505 if (p.parseSLASH()) break :blk_0 true;
1506 p.i = pos_0;
1507 if (p.parsePERCENT()) break :blk_0 true;
1508 p.i = pos_0;
1509 if (p.parseASTERISKPERCENT()) break :blk_0 true;
1510 p.i = pos_0;
1511 if (p.parseASTERISKPIPE()) break :blk_0 true;
1512 p.i = pos_0;
1513 break :blk_0 false;
1514 };
1515 }
1516 pub fn parsePrefixOp(p: *Parser) bool {
1517 return blk_0: {
1518 const pos_0 = p.i;
1519 if (p.parseEXCLAMATIONMARK()) break :blk_0 true;
1520 p.i = pos_0;
1521 if (p.parseMINUS()) break :blk_0 true;
1522 p.i = pos_0;
1523 if (p.parseTILDE()) break :blk_0 true;
1524 p.i = pos_0;
1525 if (p.parseMINUSPERCENT()) break :blk_0 true;
1526 p.i = pos_0;
1527 if (p.parseAMPERSAND()) break :blk_0 true;
1528 p.i = pos_0;
1529 if (p.parseKEYWORD_try()) break :blk_0 true;
1530 p.i = pos_0;
1531 break :blk_0 false;
1532 };
1533 }
1534 pub fn parsePrefixTypeOp(p: *Parser) bool {
1535 return blk_0: {
1536 const pos_0 = p.i;
1537 if (p.parseQUESTIONMARK()) break :blk_0 true;
1538 p.i = pos_0;
1539 if (p.parseKEYWORD_anyframe() and p.parseMINUSRARROW()) break :blk_0 true;
1540 p.i = pos_0;
1541 if (blk_2: {
1542 const pos_2 = p.i;
1543 if (p.parseManyPtrTypeStart()) break :blk_2 true;
1544 p.i = pos_2;
1545 if (p.parseSliceTypeStart()) break :blk_2 true;
1546 p.i = pos_2;
1547 break :blk_2 false;
1548 } and (p.parseKEYWORD_allowzero() or true) and (p.parseByteAlign() or true) and (p.parseAddrSpace() or true) and (p.parseKEYWORD_const() or true) and (p.parseKEYWORD_volatile() or true)) break :blk_0 true;
1549 p.i = pos_0;
1550 if (p.parseSinglePtrTypeStart() and (p.parseKEYWORD_allowzero() or true) and (p.parseBitAlign() or true) and (p.parseAddrSpace() or true) and (p.parseKEYWORD_const() or true) and (p.parseKEYWORD_volatile() or true)) break :blk_0 true;
1551 p.i = pos_0;
1552 if (p.parseArrayTypeStart()) break :blk_0 true;
1553 p.i = pos_0;
1554 break :blk_0 false;
1555 };
1556 }
1557 pub fn parseSuffixOp(p: *Parser) bool {
1558 return blk_0: {
1559 const pos_0 = p.i;
1560 if (p.parseLBRACKET() and p.parseExpr() and (blk_3: {
1561 const pos_3 = p.i;
1562 if (p.parseDOT2() and (p.parseExpr() or true) and (blk_6: {
1563 const pos_6 = p.i;
1564 if (p.parseCOLON() and p.parseExpr()) break :blk_6 true;
1565 p.i = pos_6;
1566 break :blk_6 false;
1567 } or true)) break :blk_3 true;
1568 p.i = pos_3;
1569 break :blk_3 false;
1570 } or true) and p.parseRBRACKET()) break :blk_0 true;
1571 p.i = pos_0;
1572 if (p.parseDOT() and p.parseIDENTIFIER()) break :blk_0 true;
1573 p.i = pos_0;
1574 if (p.parseDOTASTERISK()) break :blk_0 true;
1575 p.i = pos_0;
1576 if (p.parseDOTQUESTIONMARK()) break :blk_0 true;
1577 p.i = pos_0;
1578 break :blk_0 false;
1579 };
1580 }
1581 pub fn parseFnCallArguments(p: *Parser) bool {
1582 return blk_0: {
1583 const pos_0 = p.i;
1584 if (p.parseLPAREN() and p.parseExprList() and p.parseRPAREN()) break :blk_0 true;
1585 p.i = pos_0;
1586 break :blk_0 false;
1587 };
1588 }
1589 pub fn parseExprSuffix(p: *Parser) bool {
1590 return blk_0: {
1591 const pos_0 = p.i;
1592 if (p.parseKEYWORD_or()) break :blk_0 true;
1593 p.i = pos_0;
1594 if (p.parseKEYWORD_and()) break :blk_0 true;
1595 p.i = pos_0;
1596 if (p.parseCompareOp()) break :blk_0 true;
1597 p.i = pos_0;
1598 if (p.parseBitwiseOp()) break :blk_0 true;
1599 p.i = pos_0;
1600 if (p.parseBitShiftOp()) break :blk_0 true;
1601 p.i = pos_0;
1602 if (p.parseAdditionOp()) break :blk_0 true;
1603 p.i = pos_0;
1604 if (p.parseMultiplyOp()) break :blk_0 true;
1605 p.i = pos_0;
1606 if (p.parseEXCLAMATIONMARK()) break :blk_0 true;
1607 p.i = pos_0;
1608 if (p.parseSuffixOp()) break :blk_0 true;
1609 p.i = pos_0;
1610 if (p.parseFnCallArguments()) break :blk_0 true;
1611 p.i = pos_0;
1612 break :blk_0 false;
1613 };
1614 }
1615 pub fn parseLabelableExpr(p: *Parser) bool {
1616 return blk_0: {
1617 const pos_0 = p.i;
1618 if (p.parseBlock()) break :blk_0 true;
1619 p.i = pos_0;
1620 if (p.parseSwitchExpr()) break :blk_0 true;
1621 p.i = pos_0;
1622 if (p.parseLoopExpr()) break :blk_0 true;
1623 p.i = pos_0;
1624 break :blk_0 false;
1625 };
1626 }
1627 pub fn parseSliceTypeStart(p: *Parser) bool {
1628 return blk_0: {
1629 const pos_0 = p.i;
1630 if (p.parseLBRACKET() and (blk_3: {
1631 const pos_3 = p.i;
1632 if (p.parseCOLON() and p.parseExpr()) break :blk_3 true;
1633 p.i = pos_3;
1634 break :blk_3 false;
1635 } or true) and p.parseRBRACKET()) break :blk_0 true;
1636 p.i = pos_0;
1637 break :blk_0 false;
1638 };
1639 }
1640 pub fn parseSinglePtrTypeStart(p: *Parser) bool {
1641 return blk_0: {
1642 const pos_0 = p.i;
1643 if (p.parseASTERISK()) break :blk_0 true;
1644 p.i = pos_0;
1645 break :blk_0 false;
1646 };
1647 }
1648 pub fn parseManyPtrTypeStart(p: *Parser) bool {
1649 return blk_0: {
1650 const pos_0 = p.i;
1651 if (p.parseLBRACKET() and p.parseASTERISK() and (blk_3: {
1652 const pos_3 = p.i;
1653 if (p.parseLETTERC()) break :blk_3 true;
1654 p.i = pos_3;
1655 if (p.parseCOLON() and p.parseExpr()) break :blk_3 true;
1656 p.i = pos_3;
1657 break :blk_3 false;
1658 } or true) and p.parseRBRACKET()) break :blk_0 true;
1659 p.i = pos_0;
1660 break :blk_0 false;
1661 };
1662 }
1663 pub fn parseArrayTypeStart(p: *Parser) bool {
1664 return blk_0: {
1665 const pos_0 = p.i;
1666 if (p.parseLBRACKET() and p.parseExpr() and blk_1: {
1667 const pos_1 = p.i;
1668 const match_1 = p.parseASTERISK();
1669 p.i = pos_1;
1670 break :blk_1 !match_1;
1671 } and (blk_3: {
1672 const pos_3 = p.i;
1673 if (p.parseCOLON() and p.parseExpr()) break :blk_3 true;
1674 p.i = pos_3;
1675 break :blk_3 false;
1676 } or true) and p.parseRBRACKET()) break :blk_0 true;
1677 p.i = pos_0;
1678 break :blk_0 false;
1679 };
1680 }
1681 pub fn parseContainerDeclAuto(p: *Parser) bool {
1682 return blk_0: {
1683 const pos_0 = p.i;
1684 if (p.parseContainerDeclType() and p.parseLBRACE() and p.parseContainerMembers() and p.parseRBRACE()) break :blk_0 true;
1685 p.i = pos_0;
1686 break :blk_0 false;
1687 };
1688 }
1689 pub fn parseContainerDeclType(p: *Parser) bool {
1690 return blk_0: {
1691 const pos_0 = p.i;
1692 if (p.parseKEYWORD_struct() and (blk_3: {
1693 const pos_3 = p.i;
1694 if (p.parseLPAREN() and p.parseExpr() and p.parseRPAREN()) break :blk_3 true;
1695 p.i = pos_3;
1696 break :blk_3 false;
1697 } or true)) break :blk_0 true;
1698 p.i = pos_0;
1699 if (p.parseKEYWORD_opaque()) break :blk_0 true;
1700 p.i = pos_0;
1701 if (p.parseKEYWORD_enum() and (blk_3: {
1702 const pos_3 = p.i;
1703 if (p.parseLPAREN() and p.parseExpr() and p.parseRPAREN()) break :blk_3 true;
1704 p.i = pos_3;
1705 break :blk_3 false;
1706 } or true)) break :blk_0 true;
1707 p.i = pos_0;
1708 if (p.parseKEYWORD_union() and (blk_3: {
1709 const pos_3 = p.i;
1710 if (p.parseLPAREN() and blk_5: {
1711 const pos_5 = p.i;
1712 if (p.parseKEYWORD_enum() and (blk_8: {
1713 const pos_8 = p.i;
1714 if (p.parseLPAREN() and p.parseExpr() and p.parseRPAREN()) break :blk_8 true;
1715 p.i = pos_8;
1716 break :blk_8 false;
1717 } or true)) break :blk_5 true;
1718 p.i = pos_5;
1719 if (blk_6: {
1720 const pos_6 = p.i;
1721 const match_6 = p.parseKEYWORD_enum();
1722 p.i = pos_6;
1723 break :blk_6 !match_6;
1724 } and p.parseExpr()) break :blk_5 true;
1725 p.i = pos_5;
1726 break :blk_5 false;
1727 } and p.parseRPAREN()) break :blk_3 true;
1728 p.i = pos_3;
1729 break :blk_3 false;
1730 } or true)) break :blk_0 true;
1731 p.i = pos_0;
1732 break :blk_0 false;
1733 };
1734 }
1735 pub fn parseByteAlign(p: *Parser) bool {
1736 return blk_0: {
1737 const pos_0 = p.i;
1738 if (p.parseKEYWORD_align() and p.parseLPAREN() and p.parseExpr() and p.parseRPAREN()) break :blk_0 true;
1739 p.i = pos_0;
1740 break :blk_0 false;
1741 };
1742 }
1743 pub fn parseBitAlign(p: *Parser) bool {
1744 return blk_0: {
1745 const pos_0 = p.i;
1746 if (p.parseKEYWORD_align() and p.parseLPAREN() and p.parseExpr() and (blk_3: {
1747 const pos_3 = p.i;
1748 if (p.parseCOLON() and p.parseExpr() and p.parseCOLON() and p.parseExpr()) break :blk_3 true;
1749 p.i = pos_3;
1750 break :blk_3 false;
1751 } or true) and p.parseRPAREN()) break :blk_0 true;
1752 p.i = pos_0;
1753 break :blk_0 false;
1754 };
1755 }
1756 pub fn parseIdentifierList(p: *Parser) bool {
1757 return blk_0: {
1758 const pos_0 = p.i;
1759 if (blk_1: {
1760 while (blk_3: {
1761 const pos_3 = p.i;
1762 if ((p.parsedoc_comment() or true) and p.parseIDENTIFIER() and p.parseCOMMA()) break :blk_3 true;
1763 p.i = pos_3;
1764 break :blk_3 false;
1765 }) {}
1766 break :blk_1 true;
1767 } and (blk_3: {
1768 const pos_3 = p.i;
1769 if ((p.parsedoc_comment() or true) and p.parseIDENTIFIER()) break :blk_3 true;
1770 p.i = pos_3;
1771 break :blk_3 false;
1772 } or true)) break :blk_0 true;
1773 p.i = pos_0;
1774 break :blk_0 false;
1775 };
1776 }
1777 pub fn parseSwitchProngList(p: *Parser) bool {
1778 return blk_0: {
1779 const pos_0 = p.i;
1780 if (blk_1: {
1781 while (blk_3: {
1782 const pos_3 = p.i;
1783 if (p.parseSwitchProng() and p.parseCOMMA()) break :blk_3 true;
1784 p.i = pos_3;
1785 break :blk_3 false;
1786 }) {}
1787 break :blk_1 true;
1788 } and (p.parseSwitchProng() or true)) break :blk_0 true;
1789 p.i = pos_0;
1790 break :blk_0 false;
1791 };
1792 }
1793 pub fn parseAsmOutputList(p: *Parser) bool {
1794 return blk_0: {
1795 const pos_0 = p.i;
1796 if (blk_1: {
1797 while (blk_3: {
1798 const pos_3 = p.i;
1799 if (p.parseAsmOutputItem() and p.parseCOMMA()) break :blk_3 true;
1800 p.i = pos_3;
1801 break :blk_3 false;
1802 }) {}
1803 break :blk_1 true;
1804 } and (p.parseAsmOutputItem() or true)) break :blk_0 true;
1805 p.i = pos_0;
1806 break :blk_0 false;
1807 };
1808 }
1809 pub fn parseAsmInputList(p: *Parser) bool {
1810 return blk_0: {
1811 const pos_0 = p.i;
1812 if (blk_1: {
1813 while (blk_3: {
1814 const pos_3 = p.i;
1815 if (p.parseAsmInputItem() and p.parseCOMMA()) break :blk_3 true;
1816 p.i = pos_3;
1817 break :blk_3 false;
1818 }) {}
1819 break :blk_1 true;
1820 } and (p.parseAsmInputItem() or true)) break :blk_0 true;
1821 p.i = pos_0;
1822 break :blk_0 false;
1823 };
1824 }
1825 pub fn parseParamDeclList(p: *Parser) bool {
1826 return blk_0: {
1827 const pos_0 = p.i;
1828 if (blk_1: {
1829 while (blk_3: {
1830 const pos_3 = p.i;
1831 if (p.parseParamDecl() and p.parseCOMMA()) break :blk_3 true;
1832 p.i = pos_3;
1833 break :blk_3 false;
1834 }) {}
1835 break :blk_1 true;
1836 } and (blk_3: {
1837 const pos_3 = p.i;
1838 if (p.parseParamDecl()) break :blk_3 true;
1839 p.i = pos_3;
1840 if (p.parseDOT3() and (p.parseCOMMA() or true)) break :blk_3 true;
1841 p.i = pos_3;
1842 break :blk_3 false;
1843 } or true)) break :blk_0 true;
1844 p.i = pos_0;
1845 break :blk_0 false;
1846 };
1847 }
1848 pub fn parseExprList(p: *Parser) bool {
1849 return blk_0: {
1850 const pos_0 = p.i;
1851 if (blk_1: {
1852 while (blk_3: {
1853 const pos_3 = p.i;
1854 if (p.parseExpr() and p.parseCOMMA()) break :blk_3 true;
1855 p.i = pos_3;
1856 break :blk_3 false;
1857 }) {}
1858 break :blk_1 true;
1859 } and (p.parseExpr() or true)) break :blk_0 true;
1860 p.i = pos_0;
1861 break :blk_0 false;
1862 };
1863 }
1864 pub fn parseeof(p: *Parser) bool {
1865 return blk_0: {
1866 const pos_0 = p.i;
1867 if (blk_1: {
1868 const pos_1 = p.i;
1869 const match_1 = blk_2: {
1870 if (p.i < p.source.len) {
1871 p.i += 1;
1872 break :blk_2 true;
1873 }
1874 break :blk_2 false;
1875 };
1876 p.i = pos_1;
1877 break :blk_1 !match_1;
1878 }) break :blk_0 true;
1879 p.i = pos_0;
1880 break :blk_0 false;
1881 };
1882 }
1883 pub fn parsebin(p: *Parser) bool {
1884 return blk_0: {
1885 const pos_0 = p.i;
1886 if ((p.i < p.source.len and switch (p.source[p.i]) {
1887 '0'...'0',
1888 '1'...'1',
1889 => blk_1: {
1890 p.i += 1;
1891 break :blk_1 true;
1892 },
1893 else => false,
1894 })) break :blk_0 true;
1895 p.i = pos_0;
1896 break :blk_0 false;
1897 };
1898 }
1899 pub fn parsebin_(p: *Parser) bool {
1900 return blk_0: {
1901 const pos_0 = p.i;
1902 if ((blk_2: {
1903 if (std.mem.startsWith(u8, p.source[p.i..], "_")) {
1904 p.i += 1;
1905 break :blk_2 true;
1906 }
1907 break :blk_2 false;
1908 } or true) and p.parsebin()) break :blk_0 true;
1909 p.i = pos_0;
1910 break :blk_0 false;
1911 };
1912 }
1913 pub fn parseoct(p: *Parser) bool {
1914 return blk_0: {
1915 const pos_0 = p.i;
1916 if ((p.i < p.source.len and switch (p.source[p.i]) {
1917 '0'...'7',
1918 => blk_1: {
1919 p.i += 1;
1920 break :blk_1 true;
1921 },
1922 else => false,
1923 })) break :blk_0 true;
1924 p.i = pos_0;
1925 break :blk_0 false;
1926 };
1927 }
1928 pub fn parseoct_(p: *Parser) bool {
1929 return blk_0: {
1930 const pos_0 = p.i;
1931 if ((blk_2: {
1932 if (std.mem.startsWith(u8, p.source[p.i..], "_")) {
1933 p.i += 1;
1934 break :blk_2 true;
1935 }
1936 break :blk_2 false;
1937 } or true) and p.parseoct()) break :blk_0 true;
1938 p.i = pos_0;
1939 break :blk_0 false;
1940 };
1941 }
1942 pub fn parsehex(p: *Parser) bool {
1943 return blk_0: {
1944 const pos_0 = p.i;
1945 if ((p.i < p.source.len and switch (p.source[p.i]) {
1946 '0'...'9',
1947 'a'...'f',
1948 'A'...'F',
1949 => blk_1: {
1950 p.i += 1;
1951 break :blk_1 true;
1952 },
1953 else => false,
1954 })) break :blk_0 true;
1955 p.i = pos_0;
1956 break :blk_0 false;
1957 };
1958 }
1959 pub fn parsehex_(p: *Parser) bool {
1960 return blk_0: {
1961 const pos_0 = p.i;
1962 if ((blk_2: {
1963 if (std.mem.startsWith(u8, p.source[p.i..], "_")) {
1964 p.i += 1;
1965 break :blk_2 true;
1966 }
1967 break :blk_2 false;
1968 } or true) and p.parsehex()) break :blk_0 true;
1969 p.i = pos_0;
1970 break :blk_0 false;
1971 };
1972 }
1973 pub fn parsedec(p: *Parser) bool {
1974 return blk_0: {
1975 const pos_0 = p.i;
1976 if ((p.i < p.source.len and switch (p.source[p.i]) {
1977 '0'...'9',
1978 => blk_1: {
1979 p.i += 1;
1980 break :blk_1 true;
1981 },
1982 else => false,
1983 })) break :blk_0 true;
1984 p.i = pos_0;
1985 break :blk_0 false;
1986 };
1987 }
1988 pub fn parsedec_(p: *Parser) bool {
1989 return blk_0: {
1990 const pos_0 = p.i;
1991 if ((blk_2: {
1992 if (std.mem.startsWith(u8, p.source[p.i..], "_")) {
1993 p.i += 1;
1994 break :blk_2 true;
1995 }
1996 break :blk_2 false;
1997 } or true) and p.parsedec()) break :blk_0 true;
1998 p.i = pos_0;
1999 break :blk_0 false;
2000 };
2001 }
2002 pub fn parsebin_int(p: *Parser) bool {
2003 return blk_0: {
2004 const pos_0 = p.i;
2005 if (p.parsebin() and blk_1: {
2006 while (p.parsebin_()) {}
2007 break :blk_1 true;
2008 }) break :blk_0 true;
2009 p.i = pos_0;
2010 break :blk_0 false;
2011 };
2012 }
2013 pub fn parseoct_int(p: *Parser) bool {
2014 return blk_0: {
2015 const pos_0 = p.i;
2016 if (p.parseoct() and blk_1: {
2017 while (p.parseoct_()) {}
2018 break :blk_1 true;
2019 }) break :blk_0 true;
2020 p.i = pos_0;
2021 break :blk_0 false;
2022 };
2023 }
2024 pub fn parsedec_int(p: *Parser) bool {
2025 return blk_0: {
2026 const pos_0 = p.i;
2027 if (p.parsedec() and blk_1: {
2028 while (p.parsedec_()) {}
2029 break :blk_1 true;
2030 }) break :blk_0 true;
2031 p.i = pos_0;
2032 break :blk_0 false;
2033 };
2034 }
2035 pub fn parsehex_int(p: *Parser) bool {
2036 return blk_0: {
2037 const pos_0 = p.i;
2038 if (p.parsehex() and blk_1: {
2039 while (p.parsehex_()) {}
2040 break :blk_1 true;
2041 }) break :blk_0 true;
2042 p.i = pos_0;
2043 break :blk_0 false;
2044 };
2045 }
2046 pub fn parseox80_oxBF(p: *Parser) bool {
2047 return blk_0: {
2048 const pos_0 = p.i;
2049 if ((p.i < p.source.len and switch (p.source[p.i]) {
2050 '\x80'...'\xbf',
2051 => blk_1: {
2052 p.i += 1;
2053 break :blk_1 true;
2054 },
2055 else => false,
2056 })) break :blk_0 true;
2057 p.i = pos_0;
2058 break :blk_0 false;
2059 };
2060 }
2061 pub fn parseoxF4(p: *Parser) bool {
2062 return blk_0: {
2063 const pos_0 = p.i;
2064 if (blk_1: {
2065 if (std.mem.startsWith(u8, p.source[p.i..], "\xf4")) {
2066 p.i += 1;
2067 break :blk_1 true;
2068 }
2069 break :blk_1 false;
2070 }) break :blk_0 true;
2071 p.i = pos_0;
2072 break :blk_0 false;
2073 };
2074 }
2075 pub fn parseox80_ox8F(p: *Parser) bool {
2076 return blk_0: {
2077 const pos_0 = p.i;
2078 if ((p.i < p.source.len and switch (p.source[p.i]) {
2079 '\x80'...'\x8f',
2080 => blk_1: {
2081 p.i += 1;
2082 break :blk_1 true;
2083 },
2084 else => false,
2085 })) break :blk_0 true;
2086 p.i = pos_0;
2087 break :blk_0 false;
2088 };
2089 }
2090 pub fn parseoxF1_oxF3(p: *Parser) bool {
2091 return blk_0: {
2092 const pos_0 = p.i;
2093 if ((p.i < p.source.len and switch (p.source[p.i]) {
2094 '\xf1'...'\xf3',
2095 => blk_1: {
2096 p.i += 1;
2097 break :blk_1 true;
2098 },
2099 else => false,
2100 })) break :blk_0 true;
2101 p.i = pos_0;
2102 break :blk_0 false;
2103 };
2104 }
2105 pub fn parseoxF0(p: *Parser) bool {
2106 return blk_0: {
2107 const pos_0 = p.i;
2108 if (blk_1: {
2109 if (std.mem.startsWith(u8, p.source[p.i..], "\xf0")) {
2110 p.i += 1;
2111 break :blk_1 true;
2112 }
2113 break :blk_1 false;
2114 }) break :blk_0 true;
2115 p.i = pos_0;
2116 break :blk_0 false;
2117 };
2118 }
2119 pub fn parseox90_0xBF(p: *Parser) bool {
2120 return blk_0: {
2121 const pos_0 = p.i;
2122 if ((p.i < p.source.len and switch (p.source[p.i]) {
2123 '\x90'...'\xbf',
2124 => blk_1: {
2125 p.i += 1;
2126 break :blk_1 true;
2127 },
2128 else => false,
2129 })) break :blk_0 true;
2130 p.i = pos_0;
2131 break :blk_0 false;
2132 };
2133 }
2134 pub fn parseoxEE_oxEF(p: *Parser) bool {
2135 return blk_0: {
2136 const pos_0 = p.i;
2137 if ((p.i < p.source.len and switch (p.source[p.i]) {
2138 '\xee'...'\xef',
2139 => blk_1: {
2140 p.i += 1;
2141 break :blk_1 true;
2142 },
2143 else => false,
2144 })) break :blk_0 true;
2145 p.i = pos_0;
2146 break :blk_0 false;
2147 };
2148 }
2149 pub fn parseoxED(p: *Parser) bool {
2150 return blk_0: {
2151 const pos_0 = p.i;
2152 if (blk_1: {
2153 if (std.mem.startsWith(u8, p.source[p.i..], "\xed")) {
2154 p.i += 1;
2155 break :blk_1 true;
2156 }
2157 break :blk_1 false;
2158 }) break :blk_0 true;
2159 p.i = pos_0;
2160 break :blk_0 false;
2161 };
2162 }
2163 pub fn parseox80_ox9F(p: *Parser) bool {
2164 return blk_0: {
2165 const pos_0 = p.i;
2166 if ((p.i < p.source.len and switch (p.source[p.i]) {
2167 '\x80'...'\x9f',
2168 => blk_1: {
2169 p.i += 1;
2170 break :blk_1 true;
2171 },
2172 else => false,
2173 })) break :blk_0 true;
2174 p.i = pos_0;
2175 break :blk_0 false;
2176 };
2177 }
2178 pub fn parseoxE1_oxEC(p: *Parser) bool {
2179 return blk_0: {
2180 const pos_0 = p.i;
2181 if ((p.i < p.source.len and switch (p.source[p.i]) {
2182 '\xe1'...'\xec',
2183 => blk_1: {
2184 p.i += 1;
2185 break :blk_1 true;
2186 },
2187 else => false,
2188 })) break :blk_0 true;
2189 p.i = pos_0;
2190 break :blk_0 false;
2191 };
2192 }
2193 pub fn parseoxE0(p: *Parser) bool {
2194 return blk_0: {
2195 const pos_0 = p.i;
2196 if (blk_1: {
2197 if (std.mem.startsWith(u8, p.source[p.i..], "\xe0")) {
2198 p.i += 1;
2199 break :blk_1 true;
2200 }
2201 break :blk_1 false;
2202 }) break :blk_0 true;
2203 p.i = pos_0;
2204 break :blk_0 false;
2205 };
2206 }
2207 pub fn parseoxA0_oxBF(p: *Parser) bool {
2208 return blk_0: {
2209 const pos_0 = p.i;
2210 if ((p.i < p.source.len and switch (p.source[p.i]) {
2211 '\xa0'...'\xbf',
2212 => blk_1: {
2213 p.i += 1;
2214 break :blk_1 true;
2215 },
2216 else => false,
2217 })) break :blk_0 true;
2218 p.i = pos_0;
2219 break :blk_0 false;
2220 };
2221 }
2222 pub fn parseoxC2_oxDF(p: *Parser) bool {
2223 return blk_0: {
2224 const pos_0 = p.i;
2225 if ((p.i < p.source.len and switch (p.source[p.i]) {
2226 '\xc2'...'\xdf',
2227 => blk_1: {
2228 p.i += 1;
2229 break :blk_1 true;
2230 },
2231 else => false,
2232 })) break :blk_0 true;
2233 p.i = pos_0;
2234 break :blk_0 false;
2235 };
2236 }
2237 pub fn parsemultibyte_utf8(p: *Parser) bool {
2238 return blk_0: {
2239 const pos_0 = p.i;
2240 if (p.parseoxF4() and p.parseox80_ox8F() and p.parseox80_oxBF() and p.parseox80_oxBF()) break :blk_0 true;
2241 p.i = pos_0;
2242 if (p.parseoxF1_oxF3() and p.parseox80_oxBF() and p.parseox80_oxBF() and p.parseox80_oxBF()) break :blk_0 true;
2243 p.i = pos_0;
2244 if (p.parseoxF0() and p.parseox90_0xBF() and p.parseox80_oxBF() and p.parseox80_oxBF()) break :blk_0 true;
2245 p.i = pos_0;
2246 if (p.parseoxEE_oxEF() and p.parseox80_oxBF() and p.parseox80_oxBF()) break :blk_0 true;
2247 p.i = pos_0;
2248 if (p.parseoxED() and p.parseox80_ox9F() and p.parseox80_oxBF()) break :blk_0 true;
2249 p.i = pos_0;
2250 if (p.parseoxE1_oxEC() and p.parseox80_oxBF() and p.parseox80_oxBF()) break :blk_0 true;
2251 p.i = pos_0;
2252 if (p.parseoxE0() and p.parseoxA0_oxBF() and p.parseox80_oxBF()) break :blk_0 true;
2253 p.i = pos_0;
2254 if (p.parseoxC2_oxDF() and p.parseox80_oxBF()) break :blk_0 true;
2255 p.i = pos_0;
2256 break :blk_0 false;
2257 };
2258 }
2259 pub fn parsenon_control_ascii(p: *Parser) bool {
2260 return blk_0: {
2261 const pos_0 = p.i;
2262 if ((p.i < p.source.len and switch (p.source[p.i]) {
2263 ' '...'~',
2264 => blk_1: {
2265 p.i += 1;
2266 break :blk_1 true;
2267 },
2268 else => false,
2269 })) break :blk_0 true;
2270 p.i = pos_0;
2271 break :blk_0 false;
2272 };
2273 }
2274 pub fn parsenon_control_utf8(p: *Parser) bool {
2275 return blk_0: {
2276 const pos_0 = p.i;
2277 if ((p.i < p.source.len and switch (p.source[p.i]) {
2278 ' '...'\xff',
2279 => blk_1: {
2280 p.i += 1;
2281 break :blk_1 true;
2282 },
2283 else => false,
2284 })) break :blk_0 true;
2285 p.i = pos_0;
2286 break :blk_0 false;
2287 };
2288 }
2289 pub fn parsechar_escape(p: *Parser) bool {
2290 return blk_0: {
2291 const pos_0 = p.i;
2292 if (blk_1: {
2293 if (std.mem.startsWith(u8, p.source[p.i..], "\\x")) {
2294 p.i += 2;
2295 break :blk_1 true;
2296 }
2297 break :blk_1 false;
2298 } and p.parsehex() and p.parsehex()) break :blk_0 true;
2299 p.i = pos_0;
2300 if (blk_1: {
2301 if (std.mem.startsWith(u8, p.source[p.i..], "\\u{")) {
2302 p.i += 3;
2303 break :blk_1 true;
2304 }
2305 break :blk_1 false;
2306 } and blk_1: {
2307 var match_1 = false;
2308 while (p.parsehex()) {
2309 match_1 = true;
2310 }
2311 break :blk_1 match_1;
2312 } and blk_1: {
2313 if (std.mem.startsWith(u8, p.source[p.i..], "}")) {
2314 p.i += 1;
2315 break :blk_1 true;
2316 }
2317 break :blk_1 false;
2318 }) break :blk_0 true;
2319 p.i = pos_0;
2320 if (blk_1: {
2321 if (std.mem.startsWith(u8, p.source[p.i..], "\\")) {
2322 p.i += 1;
2323 break :blk_1 true;
2324 }
2325 break :blk_1 false;
2326 } and (p.i < p.source.len and switch (p.source[p.i]) {
2327 'n'...'n',
2328 'r'...'r',
2329 '\\'...'\\',
2330 't'...'t',
2331 '\''...'\'',
2332 '"'...'"',
2333 => blk_1: {
2334 p.i += 1;
2335 break :blk_1 true;
2336 },
2337 else => false,
2338 })) break :blk_0 true;
2339 p.i = pos_0;
2340 break :blk_0 false;
2341 };
2342 }
2343 pub fn parsechar_char(p: *Parser) bool {
2344 return blk_0: {
2345 const pos_0 = p.i;
2346 if (p.parsemultibyte_utf8()) break :blk_0 true;
2347 p.i = pos_0;
2348 if (p.parsechar_escape()) break :blk_0 true;
2349 p.i = pos_0;
2350 if (blk_1: {
2351 const pos_1 = p.i;
2352 const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
2353 '\\'...'\\',
2354 '\''...'\'',
2355 '\n'...'\n',
2356 => blk_2: {
2357 p.i += 1;
2358 break :blk_2 true;
2359 },
2360 else => false,
2361 });
2362 p.i = pos_1;
2363 break :blk_1 !match_1;
2364 } and p.parsenon_control_ascii()) break :blk_0 true;
2365 p.i = pos_0;
2366 break :blk_0 false;
2367 };
2368 }
2369 pub fn parsestring_char(p: *Parser) bool {
2370 return blk_0: {
2371 const pos_0 = p.i;
2372 if (p.parsemultibyte_utf8()) break :blk_0 true;
2373 p.i = pos_0;
2374 if (p.parsechar_escape()) break :blk_0 true;
2375 p.i = pos_0;
2376 if (blk_1: {
2377 const pos_1 = p.i;
2378 const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
2379 '\\'...'\\',
2380 '"'...'"',
2381 '\n'...'\n',
2382 => blk_2: {
2383 p.i += 1;
2384 break :blk_2 true;
2385 },
2386 else => false,
2387 });
2388 p.i = pos_1;
2389 break :blk_1 !match_1;
2390 } and p.parsenon_control_ascii()) break :blk_0 true;
2391 p.i = pos_0;
2392 break :blk_0 false;
2393 };
2394 }
2395 pub fn parsecontainer_doc_comment(p: *Parser) bool {
2396 return blk_0: {
2397 const pos_0 = p.i;
2398 if (blk_1: {
2399 var match_1 = false;
2400 while (blk_3: {
2401 const pos_3 = p.i;
2402 if (blk_4: {
2403 if (std.mem.startsWith(u8, p.source[p.i..], "//!")) {
2404 p.i += 3;
2405 break :blk_4 true;
2406 }
2407 break :blk_4 false;
2408 } and blk_4: {
2409 while (p.parsenon_control_utf8()) {}
2410 break :blk_4 true;
2411 } and blk_4: {
2412 while ((p.i < p.source.len and switch (p.source[p.i]) {
2413 ' '...' ',
2414 '\n'...'\n',
2415 => blk_5: {
2416 p.i += 1;
2417 break :blk_5 true;
2418 },
2419 else => false,
2420 })) {}
2421 break :blk_4 true;
2422 } and p.parseskip()) break :blk_3 true;
2423 p.i = pos_3;
2424 break :blk_3 false;
2425 }) {
2426 match_1 = true;
2427 }
2428 break :blk_1 match_1;
2429 }) break :blk_0 true;
2430 p.i = pos_0;
2431 break :blk_0 false;
2432 };
2433 }
2434 pub fn parsedoc_comment(p: *Parser) bool {
2435 return blk_0: {
2436 const pos_0 = p.i;
2437 if (blk_1: {
2438 var match_1 = false;
2439 while (blk_3: {
2440 const pos_3 = p.i;
2441 if (blk_4: {
2442 if (std.mem.startsWith(u8, p.source[p.i..], "///")) {
2443 p.i += 3;
2444 break :blk_4 true;
2445 }
2446 break :blk_4 false;
2447 } and blk_4: {
2448 while (p.parsenon_control_utf8()) {}
2449 break :blk_4 true;
2450 } and blk_4: {
2451 while ((p.i < p.source.len and switch (p.source[p.i]) {
2452 ' '...' ',
2453 '\n'...'\n',
2454 => blk_5: {
2455 p.i += 1;
2456 break :blk_5 true;
2457 },
2458 else => false,
2459 })) {}
2460 break :blk_4 true;
2461 } and p.parseskip()) break :blk_3 true;
2462 p.i = pos_3;
2463 break :blk_3 false;
2464 }) {
2465 match_1 = true;
2466 }
2467 break :blk_1 match_1;
2468 }) break :blk_0 true;
2469 p.i = pos_0;
2470 break :blk_0 false;
2471 };
2472 }
2473 pub fn parseline_comment(p: *Parser) bool {
2474 return blk_0: {
2475 const pos_0 = p.i;
2476 if (blk_1: {
2477 if (std.mem.startsWith(u8, p.source[p.i..], "//")) {
2478 p.i += 2;
2479 break :blk_1 true;
2480 }
2481 break :blk_1 false;
2482 } and blk_1: {
2483 const pos_1 = p.i;
2484 const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
2485 '!'...'!',
2486 '/'...'/',
2487 => blk_2: {
2488 p.i += 1;
2489 break :blk_2 true;
2490 },
2491 else => false,
2492 });
2493 p.i = pos_1;
2494 break :blk_1 !match_1;
2495 } and blk_1: {
2496 while (p.parsenon_control_utf8()) {}
2497 break :blk_1 true;
2498 }) break :blk_0 true;
2499 p.i = pos_0;
2500 if (blk_1: {
2501 if (std.mem.startsWith(u8, p.source[p.i..], "////")) {
2502 p.i += 4;
2503 break :blk_1 true;
2504 }
2505 break :blk_1 false;
2506 } and blk_1: {
2507 while (p.parsenon_control_utf8()) {}
2508 break :blk_1 true;
2509 }) break :blk_0 true;
2510 p.i = pos_0;
2511 break :blk_0 false;
2512 };
2513 }
2514 pub fn parseline_string(p: *Parser) bool {
2515 return blk_0: {
2516 const pos_0 = p.i;
2517 if (blk_1: {
2518 if (std.mem.startsWith(u8, p.source[p.i..], "\\\\")) {
2519 p.i += 2;
2520 break :blk_1 true;
2521 }
2522 break :blk_1 false;
2523 } and blk_1: {
2524 while (p.parsenon_control_utf8()) {}
2525 break :blk_1 true;
2526 } and blk_1: {
2527 while ((p.i < p.source.len and switch (p.source[p.i]) {
2528 ' '...' ',
2529 '\n'...'\n',
2530 => blk_2: {
2531 p.i += 1;
2532 break :blk_2 true;
2533 },
2534 else => false,
2535 })) {}
2536 break :blk_1 true;
2537 }) break :blk_0 true;
2538 p.i = pos_0;
2539 break :blk_0 false;
2540 };
2541 }
2542 pub fn parseskip(p: *Parser) bool {
2543 return blk_0: {
2544 const pos_0 = p.i;
2545 if (blk_1: {
2546 while (blk_3: {
2547 const pos_3 = p.i;
2548 if ((p.i < p.source.len and switch (p.source[p.i]) {
2549 ' '...' ',
2550 '\n'...'\n',
2551 => blk_4: {
2552 p.i += 1;
2553 break :blk_4 true;
2554 },
2555 else => false,
2556 })) break :blk_3 true;
2557 p.i = pos_3;
2558 if (p.parseline_comment()) break :blk_3 true;
2559 p.i = pos_3;
2560 break :blk_3 false;
2561 }) {}
2562 break :blk_1 true;
2563 }) break :blk_0 true;
2564 p.i = pos_0;
2565 break :blk_0 false;
2566 };
2567 }
2568 pub fn parseCHAR_LITERAL(p: *Parser) bool {
2569 return blk_0: {
2570 const pos_0 = p.i;
2571 if ((p.i < p.source.len and switch (p.source[p.i]) {
2572 '\''...'\'',
2573 => blk_1: {
2574 p.i += 1;
2575 break :blk_1 true;
2576 },
2577 else => false,
2578 }) and p.parsechar_char() and (p.i < p.source.len and switch (p.source[p.i]) {
2579 '\''...'\'',
2580 => blk_1: {
2581 p.i += 1;
2582 break :blk_1 true;
2583 },
2584 else => false,
2585 }) and p.parseskip()) break :blk_0 true;
2586 p.i = pos_0;
2587 break :blk_0 false;
2588 };
2589 }
2590 pub fn parseFLOAT(p: *Parser) bool {
2591 return blk_0: {
2592 const pos_0 = p.i;
2593 if (blk_1: {
2594 if (std.mem.startsWith(u8, p.source[p.i..], "0x")) {
2595 p.i += 2;
2596 break :blk_1 true;
2597 }
2598 break :blk_1 false;
2599 } and p.parsehex_int() and blk_1: {
2600 if (std.mem.startsWith(u8, p.source[p.i..], ".")) {
2601 p.i += 1;
2602 break :blk_1 true;
2603 }
2604 break :blk_1 false;
2605 } and p.parsehex_int() and (blk_3: {
2606 const pos_3 = p.i;
2607 if ((p.i < p.source.len and switch (p.source[p.i]) {
2608 'p'...'p',
2609 'P'...'P',
2610 => blk_4: {
2611 p.i += 1;
2612 break :blk_4 true;
2613 },
2614 else => false,
2615 }) and ((p.i < p.source.len and switch (p.source[p.i]) {
2616 '-'...'-',
2617 '+'...'+',
2618 => blk_5: {
2619 p.i += 1;
2620 break :blk_5 true;
2621 },
2622 else => false,
2623 }) or true) and p.parsedec_int()) break :blk_3 true;
2624 p.i = pos_3;
2625 break :blk_3 false;
2626 } or true) and p.parseskip()) break :blk_0 true;
2627 p.i = pos_0;
2628 if (p.parsedec_int() and blk_1: {
2629 if (std.mem.startsWith(u8, p.source[p.i..], ".")) {
2630 p.i += 1;
2631 break :blk_1 true;
2632 }
2633 break :blk_1 false;
2634 } and p.parsedec_int() and (blk_3: {
2635 const pos_3 = p.i;
2636 if ((p.i < p.source.len and switch (p.source[p.i]) {
2637 'e'...'e',
2638 'E'...'E',
2639 => blk_4: {
2640 p.i += 1;
2641 break :blk_4 true;
2642 },
2643 else => false,
2644 }) and ((p.i < p.source.len and switch (p.source[p.i]) {
2645 '-'...'-',
2646 '+'...'+',
2647 => blk_5: {
2648 p.i += 1;
2649 break :blk_5 true;
2650 },
2651 else => false,
2652 }) or true) and p.parsedec_int()) break :blk_3 true;
2653 p.i = pos_3;
2654 break :blk_3 false;
2655 } or true) and p.parseskip()) break :blk_0 true;
2656 p.i = pos_0;
2657 if (blk_1: {
2658 if (std.mem.startsWith(u8, p.source[p.i..], "0x")) {
2659 p.i += 2;
2660 break :blk_1 true;
2661 }
2662 break :blk_1 false;
2663 } and p.parsehex_int() and (p.i < p.source.len and switch (p.source[p.i]) {
2664 'p'...'p',
2665 'P'...'P',
2666 => blk_1: {
2667 p.i += 1;
2668 break :blk_1 true;
2669 },
2670 else => false,
2671 }) and ((p.i < p.source.len and switch (p.source[p.i]) {
2672 '-'...'-',
2673 '+'...'+',
2674 => blk_2: {
2675 p.i += 1;
2676 break :blk_2 true;
2677 },
2678 else => false,
2679 }) or true) and p.parsedec_int() and p.parseskip()) break :blk_0 true;
2680 p.i = pos_0;
2681 if (p.parsedec_int() and (p.i < p.source.len and switch (p.source[p.i]) {
2682 'e'...'e',
2683 'E'...'E',
2684 => blk_1: {
2685 p.i += 1;
2686 break :blk_1 true;
2687 },
2688 else => false,
2689 }) and ((p.i < p.source.len and switch (p.source[p.i]) {
2690 '-'...'-',
2691 '+'...'+',
2692 => blk_2: {
2693 p.i += 1;
2694 break :blk_2 true;
2695 },
2696 else => false,
2697 }) or true) and p.parsedec_int() and p.parseskip()) break :blk_0 true;
2698 p.i = pos_0;
2699 break :blk_0 false;
2700 };
2701 }
2702 pub fn parseINTEGER(p: *Parser) bool {
2703 return blk_0: {
2704 const pos_0 = p.i;
2705 if (blk_1: {
2706 if (std.mem.startsWith(u8, p.source[p.i..], "0b")) {
2707 p.i += 2;
2708 break :blk_1 true;
2709 }
2710 break :blk_1 false;
2711 } and p.parsebin_int() and p.parseskip()) break :blk_0 true;
2712 p.i = pos_0;
2713 if (blk_1: {
2714 if (std.mem.startsWith(u8, p.source[p.i..], "0o")) {
2715 p.i += 2;
2716 break :blk_1 true;
2717 }
2718 break :blk_1 false;
2719 } and p.parseoct_int() and p.parseskip()) break :blk_0 true;
2720 p.i = pos_0;
2721 if (blk_1: {
2722 if (std.mem.startsWith(u8, p.source[p.i..], "0x")) {
2723 p.i += 2;
2724 break :blk_1 true;
2725 }
2726 break :blk_1 false;
2727 } and p.parsehex_int() and p.parseskip()) break :blk_0 true;
2728 p.i = pos_0;
2729 if (p.parsedec_int() and p.parseskip()) break :blk_0 true;
2730 p.i = pos_0;
2731 break :blk_0 false;
2732 };
2733 }
2734 pub fn parseSTRINGLITERALSINGLE(p: *Parser) bool {
2735 return blk_0: {
2736 const pos_0 = p.i;
2737 if ((p.i < p.source.len and switch (p.source[p.i]) {
2738 '"'...'"',
2739 => blk_1: {
2740 p.i += 1;
2741 break :blk_1 true;
2742 },
2743 else => false,
2744 }) and blk_1: {
2745 while (p.parsestring_char()) {}
2746 break :blk_1 true;
2747 } and (p.i < p.source.len and switch (p.source[p.i]) {
2748 '"'...'"',
2749 => blk_1: {
2750 p.i += 1;
2751 break :blk_1 true;
2752 },
2753 else => false,
2754 }) and p.parseskip()) break :blk_0 true;
2755 p.i = pos_0;
2756 break :blk_0 false;
2757 };
2758 }
2759 pub fn parseSTRINGLITERAL(p: *Parser) bool {
2760 return blk_0: {
2761 const pos_0 = p.i;
2762 if (p.parseSTRINGLITERALSINGLE()) break :blk_0 true;
2763 p.i = pos_0;
2764 if (blk_1: {
2765 var match_1 = false;
2766 while (blk_3: {
2767 const pos_3 = p.i;
2768 if (p.parseline_string() and p.parseskip()) break :blk_3 true;
2769 p.i = pos_3;
2770 break :blk_3 false;
2771 }) {
2772 match_1 = true;
2773 }
2774 break :blk_1 match_1;
2775 }) break :blk_0 true;
2776 p.i = pos_0;
2777 break :blk_0 false;
2778 };
2779 }
2780 pub fn parseIDENTIFIER(p: *Parser) bool {
2781 return blk_0: {
2782 const pos_0 = p.i;
2783 if (blk_1: {
2784 const pos_1 = p.i;
2785 const match_1 = p.parsekeyword();
2786 p.i = pos_1;
2787 break :blk_1 !match_1;
2788 } and (p.i < p.source.len and switch (p.source[p.i]) {
2789 'A'...'Z',
2790 'a'...'z',
2791 '_'...'_',
2792 => blk_1: {
2793 p.i += 1;
2794 break :blk_1 true;
2795 },
2796 else => false,
2797 }) and blk_1: {
2798 while ((p.i < p.source.len and switch (p.source[p.i]) {
2799 'A'...'Z',
2800 'a'...'z',
2801 '0'...'9',
2802 '_'...'_',
2803 => blk_2: {
2804 p.i += 1;
2805 break :blk_2 true;
2806 },
2807 else => false,
2808 })) {}
2809 break :blk_1 true;
2810 } and p.parseskip()) break :blk_0 true;
2811 p.i = pos_0;
2812 if (blk_1: {
2813 if (std.mem.startsWith(u8, p.source[p.i..], "@")) {
2814 p.i += 1;
2815 break :blk_1 true;
2816 }
2817 break :blk_1 false;
2818 } and p.parseSTRINGLITERALSINGLE()) break :blk_0 true;
2819 p.i = pos_0;
2820 break :blk_0 false;
2821 };
2822 }
2823 pub fn parseBUILTINIDENTIFIER(p: *Parser) bool {
2824 return blk_0: {
2825 const pos_0 = p.i;
2826 if (blk_1: {
2827 if (std.mem.startsWith(u8, p.source[p.i..], "@")) {
2828 p.i += 1;
2829 break :blk_1 true;
2830 }
2831 break :blk_1 false;
2832 } and (p.i < p.source.len and switch (p.source[p.i]) {
2833 'A'...'Z',
2834 'a'...'z',
2835 '_'...'_',
2836 => blk_1: {
2837 p.i += 1;
2838 break :blk_1 true;
2839 },
2840 else => false,
2841 }) and blk_1: {
2842 while ((p.i < p.source.len and switch (p.source[p.i]) {
2843 'A'...'Z',
2844 'a'...'z',
2845 '0'...'9',
2846 '_'...'_',
2847 => blk_2: {
2848 p.i += 1;
2849 break :blk_2 true;
2850 },
2851 else => false,
2852 })) {}
2853 break :blk_1 true;
2854 } and p.parseskip()) break :blk_0 true;
2855 p.i = pos_0;
2856 break :blk_0 false;
2857 };
2858 }
2859 pub fn parseAMPERSAND(p: *Parser) bool {
2860 return blk_0: {
2861 const pos_0 = p.i;
2862 if (blk_1: {
2863 if (std.mem.startsWith(u8, p.source[p.i..], "&")) {
2864 p.i += 1;
2865 break :blk_1 true;
2866 }
2867 break :blk_1 false;
2868 } and blk_1: {
2869 const pos_1 = p.i;
2870 const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
2871 '='...'=',
2872 => blk_2: {
2873 p.i += 1;
2874 break :blk_2 true;
2875 },
2876 else => false,
2877 });
2878 p.i = pos_1;
2879 break :blk_1 !match_1;
2880 } and p.parseskip()) break :blk_0 true;
2881 p.i = pos_0;
2882 break :blk_0 false;
2883 };
2884 }
2885 pub fn parseAMPERSANDEQUAL(p: *Parser) bool {
2886 return blk_0: {
2887 const pos_0 = p.i;
2888 if (blk_1: {
2889 if (std.mem.startsWith(u8, p.source[p.i..], "&=")) {
2890 p.i += 2;
2891 break :blk_1 true;
2892 }
2893 break :blk_1 false;
2894 } and p.parseskip()) break :blk_0 true;
2895 p.i = pos_0;
2896 break :blk_0 false;
2897 };
2898 }
2899 pub fn parseASTERISK(p: *Parser) bool {
2900 return blk_0: {
2901 const pos_0 = p.i;
2902 if (blk_1: {
2903 if (std.mem.startsWith(u8, p.source[p.i..], "*")) {
2904 p.i += 1;
2905 break :blk_1 true;
2906 }
2907 break :blk_1 false;
2908 } and blk_1: {
2909 const pos_1 = p.i;
2910 const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
2911 '%'...'%',
2912 '='...'=',
2913 '|'...'|',
2914 => blk_2: {
2915 p.i += 1;
2916 break :blk_2 true;
2917 },
2918 else => false,
2919 });
2920 p.i = pos_1;
2921 break :blk_1 !match_1;
2922 } and p.parseskip()) break :blk_0 true;
2923 p.i = pos_0;
2924 break :blk_0 false;
2925 };
2926 }
2927 pub fn parseASTERISKEQUAL(p: *Parser) bool {
2928 return blk_0: {
2929 const pos_0 = p.i;
2930 if (blk_1: {
2931 if (std.mem.startsWith(u8, p.source[p.i..], "*=")) {
2932 p.i += 2;
2933 break :blk_1 true;
2934 }
2935 break :blk_1 false;
2936 } and p.parseskip()) break :blk_0 true;
2937 p.i = pos_0;
2938 break :blk_0 false;
2939 };
2940 }
2941 pub fn parseASTERISKPERCENT(p: *Parser) bool {
2942 return blk_0: {
2943 const pos_0 = p.i;
2944 if (blk_1: {
2945 if (std.mem.startsWith(u8, p.source[p.i..], "*%")) {
2946 p.i += 2;
2947 break :blk_1 true;
2948 }
2949 break :blk_1 false;
2950 } and blk_1: {
2951 const pos_1 = p.i;
2952 const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
2953 '='...'=',
2954 => blk_2: {
2955 p.i += 1;
2956 break :blk_2 true;
2957 },
2958 else => false,
2959 });
2960 p.i = pos_1;
2961 break :blk_1 !match_1;
2962 } and p.parseskip()) break :blk_0 true;
2963 p.i = pos_0;
2964 break :blk_0 false;
2965 };
2966 }
2967 pub fn parseASTERISKPERCENTEQUAL(p: *Parser) bool {
2968 return blk_0: {
2969 const pos_0 = p.i;
2970 if (blk_1: {
2971 if (std.mem.startsWith(u8, p.source[p.i..], "*%=")) {
2972 p.i += 3;
2973 break :blk_1 true;
2974 }
2975 break :blk_1 false;
2976 } and p.parseskip()) break :blk_0 true;
2977 p.i = pos_0;
2978 break :blk_0 false;
2979 };
2980 }
2981 pub fn parseASTERISKPIPE(p: *Parser) bool {
2982 return blk_0: {
2983 const pos_0 = p.i;
2984 if (blk_1: {
2985 if (std.mem.startsWith(u8, p.source[p.i..], "*|")) {
2986 p.i += 2;
2987 break :blk_1 true;
2988 }
2989 break :blk_1 false;
2990 } and blk_1: {
2991 const pos_1 = p.i;
2992 const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
2993 '='...'=',
2994 => blk_2: {
2995 p.i += 1;
2996 break :blk_2 true;
2997 },
2998 else => false,
2999 });
3000 p.i = pos_1;
3001 break :blk_1 !match_1;
3002 } and p.parseskip()) break :blk_0 true;
3003 p.i = pos_0;
3004 break :blk_0 false;
3005 };
3006 }
3007 pub fn parseASTERISKPIPEEQUAL(p: *Parser) bool {
3008 return blk_0: {
3009 const pos_0 = p.i;
3010 if (blk_1: {
3011 if (std.mem.startsWith(u8, p.source[p.i..], "*|=")) {
3012 p.i += 3;
3013 break :blk_1 true;
3014 }
3015 break :blk_1 false;
3016 } and p.parseskip()) break :blk_0 true;
3017 p.i = pos_0;
3018 break :blk_0 false;
3019 };
3020 }
3021 pub fn parseCARET(p: *Parser) bool {
3022 return blk_0: {
3023 const pos_0 = p.i;
3024 if (blk_1: {
3025 if (std.mem.startsWith(u8, p.source[p.i..], "^")) {
3026 p.i += 1;
3027 break :blk_1 true;
3028 }
3029 break :blk_1 false;
3030 } and blk_1: {
3031 const pos_1 = p.i;
3032 const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
3033 '='...'=',
3034 => blk_2: {
3035 p.i += 1;
3036 break :blk_2 true;
3037 },
3038 else => false,
3039 });
3040 p.i = pos_1;
3041 break :blk_1 !match_1;
3042 } and p.parseskip()) break :blk_0 true;
3043 p.i = pos_0;
3044 break :blk_0 false;
3045 };
3046 }
3047 pub fn parseCARETEQUAL(p: *Parser) bool {
3048 return blk_0: {
3049 const pos_0 = p.i;
3050 if (blk_1: {
3051 if (std.mem.startsWith(u8, p.source[p.i..], "^=")) {
3052 p.i += 2;
3053 break :blk_1 true;
3054 }
3055 break :blk_1 false;
3056 } and p.parseskip()) break :blk_0 true;
3057 p.i = pos_0;
3058 break :blk_0 false;
3059 };
3060 }
3061 pub fn parseCOLON(p: *Parser) bool {
3062 return blk_0: {
3063 const pos_0 = p.i;
3064 if (blk_1: {
3065 if (std.mem.startsWith(u8, p.source[p.i..], ":")) {
3066 p.i += 1;
3067 break :blk_1 true;
3068 }
3069 break :blk_1 false;
3070 } and p.parseskip()) break :blk_0 true;
3071 p.i = pos_0;
3072 break :blk_0 false;
3073 };
3074 }
3075 pub fn parseCOMMA(p: *Parser) bool {
3076 return blk_0: {
3077 const pos_0 = p.i;
3078 if (blk_1: {
3079 if (std.mem.startsWith(u8, p.source[p.i..], ",")) {
3080 p.i += 1;
3081 break :blk_1 true;
3082 }
3083 break :blk_1 false;
3084 } and p.parseskip()) break :blk_0 true;
3085 p.i = pos_0;
3086 break :blk_0 false;
3087 };
3088 }
3089 pub fn parseDOT(p: *Parser) bool {
3090 return blk_0: {
3091 const pos_0 = p.i;
3092 if (blk_1: {
3093 if (std.mem.startsWith(u8, p.source[p.i..], ".")) {
3094 p.i += 1;
3095 break :blk_1 true;
3096 }
3097 break :blk_1 false;
3098 } and blk_1: {
3099 const pos_1 = p.i;
3100 const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
3101 '*'...'*',
3102 '.'...'.',
3103 '?'...'?',
3104 => blk_2: {
3105 p.i += 1;
3106 break :blk_2 true;
3107 },
3108 else => false,
3109 });
3110 p.i = pos_1;
3111 break :blk_1 !match_1;
3112 } and p.parseskip()) break :blk_0 true;
3113 p.i = pos_0;
3114 break :blk_0 false;
3115 };
3116 }
3117 pub fn parseDOT2(p: *Parser) bool {
3118 return blk_0: {
3119 const pos_0 = p.i;
3120 if (blk_1: {
3121 if (std.mem.startsWith(u8, p.source[p.i..], "..")) {
3122 p.i += 2;
3123 break :blk_1 true;
3124 }
3125 break :blk_1 false;
3126 } and blk_1: {
3127 const pos_1 = p.i;
3128 const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
3129 '.'...'.',
3130 => blk_2: {
3131 p.i += 1;
3132 break :blk_2 true;
3133 },
3134 else => false,
3135 });
3136 p.i = pos_1;
3137 break :blk_1 !match_1;
3138 } and p.parseskip()) break :blk_0 true;
3139 p.i = pos_0;
3140 break :blk_0 false;
3141 };
3142 }
3143 pub fn parseDOT3(p: *Parser) bool {
3144 return blk_0: {
3145 const pos_0 = p.i;
3146 if (blk_1: {
3147 if (std.mem.startsWith(u8, p.source[p.i..], "...")) {
3148 p.i += 3;
3149 break :blk_1 true;
3150 }
3151 break :blk_1 false;
3152 } and p.parseskip()) break :blk_0 true;
3153 p.i = pos_0;
3154 break :blk_0 false;
3155 };
3156 }
3157 pub fn parseDOTASTERISK(p: *Parser) bool {
3158 return blk_0: {
3159 const pos_0 = p.i;
3160 if (blk_1: {
3161 if (std.mem.startsWith(u8, p.source[p.i..], ".*")) {
3162 p.i += 2;
3163 break :blk_1 true;
3164 }
3165 break :blk_1 false;
3166 } and p.parseskip()) break :blk_0 true;
3167 p.i = pos_0;
3168 break :blk_0 false;
3169 };
3170 }
3171 pub fn parseDOTQUESTIONMARK(p: *Parser) bool {
3172 return blk_0: {
3173 const pos_0 = p.i;
3174 if (blk_1: {
3175 if (std.mem.startsWith(u8, p.source[p.i..], ".?")) {
3176 p.i += 2;
3177 break :blk_1 true;
3178 }
3179 break :blk_1 false;
3180 } and p.parseskip()) break :blk_0 true;
3181 p.i = pos_0;
3182 break :blk_0 false;
3183 };
3184 }
3185 pub fn parseEQUAL(p: *Parser) bool {
3186 return blk_0: {
3187 const pos_0 = p.i;
3188 if (blk_1: {
3189 if (std.mem.startsWith(u8, p.source[p.i..], "=")) {
3190 p.i += 1;
3191 break :blk_1 true;
3192 }
3193 break :blk_1 false;
3194 } and blk_1: {
3195 const pos_1 = p.i;
3196 const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
3197 '>'...'>',
3198 '='...'=',
3199 => blk_2: {
3200 p.i += 1;
3201 break :blk_2 true;
3202 },
3203 else => false,
3204 });
3205 p.i = pos_1;
3206 break :blk_1 !match_1;
3207 } and p.parseskip()) break :blk_0 true;
3208 p.i = pos_0;
3209 break :blk_0 false;
3210 };
3211 }
3212 pub fn parseEQUALEQUAL(p: *Parser) bool {
3213 return blk_0: {
3214 const pos_0 = p.i;
3215 if (blk_1: {
3216 if (std.mem.startsWith(u8, p.source[p.i..], "==")) {
3217 p.i += 2;
3218 break :blk_1 true;
3219 }
3220 break :blk_1 false;
3221 } and p.parseskip()) break :blk_0 true;
3222 p.i = pos_0;
3223 break :blk_0 false;
3224 };
3225 }
3226 pub fn parseEQUALRARROW(p: *Parser) bool {
3227 return blk_0: {
3228 const pos_0 = p.i;
3229 if (blk_1: {
3230 if (std.mem.startsWith(u8, p.source[p.i..], "=>")) {
3231 p.i += 2;
3232 break :blk_1 true;
3233 }
3234 break :blk_1 false;
3235 } and p.parseskip()) break :blk_0 true;
3236 p.i = pos_0;
3237 break :blk_0 false;
3238 };
3239 }
3240 pub fn parseEXCLAMATIONMARK(p: *Parser) bool {
3241 return blk_0: {
3242 const pos_0 = p.i;
3243 if (blk_1: {
3244 if (std.mem.startsWith(u8, p.source[p.i..], "!")) {
3245 p.i += 1;
3246 break :blk_1 true;
3247 }
3248 break :blk_1 false;
3249 } and blk_1: {
3250 const pos_1 = p.i;
3251 const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
3252 '='...'=',
3253 => blk_2: {
3254 p.i += 1;
3255 break :blk_2 true;
3256 },
3257 else => false,
3258 });
3259 p.i = pos_1;
3260 break :blk_1 !match_1;
3261 } and p.parseskip()) break :blk_0 true;
3262 p.i = pos_0;
3263 break :blk_0 false;
3264 };
3265 }
3266 pub fn parseEXCLAMATIONMARKEQUAL(p: *Parser) bool {
3267 return blk_0: {
3268 const pos_0 = p.i;
3269 if (blk_1: {
3270 if (std.mem.startsWith(u8, p.source[p.i..], "!=")) {
3271 p.i += 2;
3272 break :blk_1 true;
3273 }
3274 break :blk_1 false;
3275 } and p.parseskip()) break :blk_0 true;
3276 p.i = pos_0;
3277 break :blk_0 false;
3278 };
3279 }
3280 pub fn parseLARROW(p: *Parser) bool {
3281 return blk_0: {
3282 const pos_0 = p.i;
3283 if (blk_1: {
3284 if (std.mem.startsWith(u8, p.source[p.i..], "<")) {
3285 p.i += 1;
3286 break :blk_1 true;
3287 }
3288 break :blk_1 false;
3289 } and blk_1: {
3290 const pos_1 = p.i;
3291 const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
3292 '<'...'<',
3293 '='...'=',
3294 => blk_2: {
3295 p.i += 1;
3296 break :blk_2 true;
3297 },
3298 else => false,
3299 });
3300 p.i = pos_1;
3301 break :blk_1 !match_1;
3302 } and p.parseskip()) break :blk_0 true;
3303 p.i = pos_0;
3304 break :blk_0 false;
3305 };
3306 }
3307 pub fn parseLARROW2(p: *Parser) bool {
3308 return blk_0: {
3309 const pos_0 = p.i;
3310 if (blk_1: {
3311 if (std.mem.startsWith(u8, p.source[p.i..], "<<")) {
3312 p.i += 2;
3313 break :blk_1 true;
3314 }
3315 break :blk_1 false;
3316 } and blk_1: {
3317 const pos_1 = p.i;
3318 const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
3319 '='...'=',
3320 '|'...'|',
3321 => blk_2: {
3322 p.i += 1;
3323 break :blk_2 true;
3324 },
3325 else => false,
3326 });
3327 p.i = pos_1;
3328 break :blk_1 !match_1;
3329 } and p.parseskip()) break :blk_0 true;
3330 p.i = pos_0;
3331 break :blk_0 false;
3332 };
3333 }
3334 pub fn parseLARROW2EQUAL(p: *Parser) bool {
3335 return blk_0: {
3336 const pos_0 = p.i;
3337 if (blk_1: {
3338 if (std.mem.startsWith(u8, p.source[p.i..], "<<=")) {
3339 p.i += 3;
3340 break :blk_1 true;
3341 }
3342 break :blk_1 false;
3343 } and p.parseskip()) break :blk_0 true;
3344 p.i = pos_0;
3345 break :blk_0 false;
3346 };
3347 }
3348 pub fn parseLARROW2PIPE(p: *Parser) bool {
3349 return blk_0: {
3350 const pos_0 = p.i;
3351 if (blk_1: {
3352 if (std.mem.startsWith(u8, p.source[p.i..], "<<|")) {
3353 p.i += 3;
3354 break :blk_1 true;
3355 }
3356 break :blk_1 false;
3357 } and blk_1: {
3358 const pos_1 = p.i;
3359 const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
3360 '='...'=',
3361 => blk_2: {
3362 p.i += 1;
3363 break :blk_2 true;
3364 },
3365 else => false,
3366 });
3367 p.i = pos_1;
3368 break :blk_1 !match_1;
3369 } and p.parseskip()) break :blk_0 true;
3370 p.i = pos_0;
3371 break :blk_0 false;
3372 };
3373 }
3374 pub fn parseLARROW2PIPEEQUAL(p: *Parser) bool {
3375 return blk_0: {
3376 const pos_0 = p.i;
3377 if (blk_1: {
3378 if (std.mem.startsWith(u8, p.source[p.i..], "<<|=")) {
3379 p.i += 4;
3380 break :blk_1 true;
3381 }
3382 break :blk_1 false;
3383 } and p.parseskip()) break :blk_0 true;
3384 p.i = pos_0;
3385 break :blk_0 false;
3386 };
3387 }
3388 pub fn parseLARROWEQUAL(p: *Parser) bool {
3389 return blk_0: {
3390 const pos_0 = p.i;
3391 if (blk_1: {
3392 if (std.mem.startsWith(u8, p.source[p.i..], "<=")) {
3393 p.i += 2;
3394 break :blk_1 true;
3395 }
3396 break :blk_1 false;
3397 } and p.parseskip()) break :blk_0 true;
3398 p.i = pos_0;
3399 break :blk_0 false;
3400 };
3401 }
3402 pub fn parseLBRACE(p: *Parser) bool {
3403 return blk_0: {
3404 const pos_0 = p.i;
3405 if (blk_1: {
3406 if (std.mem.startsWith(u8, p.source[p.i..], "{")) {
3407 p.i += 1;
3408 break :blk_1 true;
3409 }
3410 break :blk_1 false;
3411 } and p.parseskip()) break :blk_0 true;
3412 p.i = pos_0;
3413 break :blk_0 false;
3414 };
3415 }
3416 pub fn parseLBRACKET(p: *Parser) bool {
3417 return blk_0: {
3418 const pos_0 = p.i;
3419 if (blk_1: {
3420 if (std.mem.startsWith(u8, p.source[p.i..], "[")) {
3421 p.i += 1;
3422 break :blk_1 true;
3423 }
3424 break :blk_1 false;
3425 } and p.parseskip()) break :blk_0 true;
3426 p.i = pos_0;
3427 break :blk_0 false;
3428 };
3429 }
3430 pub fn parseLPAREN(p: *Parser) bool {
3431 return blk_0: {
3432 const pos_0 = p.i;
3433 if (blk_1: {
3434 if (std.mem.startsWith(u8, p.source[p.i..], "(")) {
3435 p.i += 1;
3436 break :blk_1 true;
3437 }
3438 break :blk_1 false;
3439 } and p.parseskip()) break :blk_0 true;
3440 p.i = pos_0;
3441 break :blk_0 false;
3442 };
3443 }
3444 pub fn parseMINUS(p: *Parser) bool {
3445 return blk_0: {
3446 const pos_0 = p.i;
3447 if (blk_1: {
3448 if (std.mem.startsWith(u8, p.source[p.i..], "-")) {
3449 p.i += 1;
3450 break :blk_1 true;
3451 }
3452 break :blk_1 false;
3453 } and blk_1: {
3454 const pos_1 = p.i;
3455 const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
3456 '%'...'%',
3457 '='...'=',
3458 '>'...'>',
3459 '|'...'|',
3460 => blk_2: {
3461 p.i += 1;
3462 break :blk_2 true;
3463 },
3464 else => false,
3465 });
3466 p.i = pos_1;
3467 break :blk_1 !match_1;
3468 } and p.parseskip()) break :blk_0 true;
3469 p.i = pos_0;
3470 break :blk_0 false;
3471 };
3472 }
3473 pub fn parseMINUSEQUAL(p: *Parser) bool {
3474 return blk_0: {
3475 const pos_0 = p.i;
3476 if (blk_1: {
3477 if (std.mem.startsWith(u8, p.source[p.i..], "-=")) {
3478 p.i += 2;
3479 break :blk_1 true;
3480 }
3481 break :blk_1 false;
3482 } and p.parseskip()) break :blk_0 true;
3483 p.i = pos_0;
3484 break :blk_0 false;
3485 };
3486 }
3487 pub fn parseMINUSPERCENT(p: *Parser) bool {
3488 return blk_0: {
3489 const pos_0 = p.i;
3490 if (blk_1: {
3491 if (std.mem.startsWith(u8, p.source[p.i..], "-%")) {
3492 p.i += 2;
3493 break :blk_1 true;
3494 }
3495 break :blk_1 false;
3496 } and blk_1: {
3497 const pos_1 = p.i;
3498 const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
3499 '='...'=',
3500 => blk_2: {
3501 p.i += 1;
3502 break :blk_2 true;
3503 },
3504 else => false,
3505 });
3506 p.i = pos_1;
3507 break :blk_1 !match_1;
3508 } and p.parseskip()) break :blk_0 true;
3509 p.i = pos_0;
3510 break :blk_0 false;
3511 };
3512 }
3513 pub fn parseMINUSPERCENTEQUAL(p: *Parser) bool {
3514 return blk_0: {
3515 const pos_0 = p.i;
3516 if (blk_1: {
3517 if (std.mem.startsWith(u8, p.source[p.i..], "-%=")) {
3518 p.i += 3;
3519 break :blk_1 true;
3520 }
3521 break :blk_1 false;
3522 } and p.parseskip()) break :blk_0 true;
3523 p.i = pos_0;
3524 break :blk_0 false;
3525 };
3526 }
3527 pub fn parseMINUSPIPE(p: *Parser) bool {
3528 return blk_0: {
3529 const pos_0 = p.i;
3530 if (blk_1: {
3531 if (std.mem.startsWith(u8, p.source[p.i..], "-|")) {
3532 p.i += 2;
3533 break :blk_1 true;
3534 }
3535 break :blk_1 false;
3536 } and blk_1: {
3537 const pos_1 = p.i;
3538 const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
3539 '='...'=',
3540 => blk_2: {
3541 p.i += 1;
3542 break :blk_2 true;
3543 },
3544 else => false,
3545 });
3546 p.i = pos_1;
3547 break :blk_1 !match_1;
3548 } and p.parseskip()) break :blk_0 true;
3549 p.i = pos_0;
3550 break :blk_0 false;
3551 };
3552 }
3553 pub fn parseMINUSPIPEEQUAL(p: *Parser) bool {
3554 return blk_0: {
3555 const pos_0 = p.i;
3556 if (blk_1: {
3557 if (std.mem.startsWith(u8, p.source[p.i..], "-|=")) {
3558 p.i += 3;
3559 break :blk_1 true;
3560 }
3561 break :blk_1 false;
3562 } and p.parseskip()) break :blk_0 true;
3563 p.i = pos_0;
3564 break :blk_0 false;
3565 };
3566 }
3567 pub fn parseMINUSRARROW(p: *Parser) bool {
3568 return blk_0: {
3569 const pos_0 = p.i;
3570 if (blk_1: {
3571 if (std.mem.startsWith(u8, p.source[p.i..], "->")) {
3572 p.i += 2;
3573 break :blk_1 true;
3574 }
3575 break :blk_1 false;
3576 } and p.parseskip()) break :blk_0 true;
3577 p.i = pos_0;
3578 break :blk_0 false;
3579 };
3580 }
3581 pub fn parsePERCENT(p: *Parser) bool {
3582 return blk_0: {
3583 const pos_0 = p.i;
3584 if (blk_1: {
3585 if (std.mem.startsWith(u8, p.source[p.i..], "%")) {
3586 p.i += 1;
3587 break :blk_1 true;
3588 }
3589 break :blk_1 false;
3590 } and blk_1: {
3591 const pos_1 = p.i;
3592 const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
3593 '='...'=',
3594 => blk_2: {
3595 p.i += 1;
3596 break :blk_2 true;
3597 },
3598 else => false,
3599 });
3600 p.i = pos_1;
3601 break :blk_1 !match_1;
3602 } and p.parseskip()) break :blk_0 true;
3603 p.i = pos_0;
3604 break :blk_0 false;
3605 };
3606 }
3607 pub fn parsePERCENTEQUAL(p: *Parser) bool {
3608 return blk_0: {
3609 const pos_0 = p.i;
3610 if (blk_1: {
3611 if (std.mem.startsWith(u8, p.source[p.i..], "%=")) {
3612 p.i += 2;
3613 break :blk_1 true;
3614 }
3615 break :blk_1 false;
3616 } and p.parseskip()) break :blk_0 true;
3617 p.i = pos_0;
3618 break :blk_0 false;
3619 };
3620 }
3621 pub fn parsePIPE(p: *Parser) bool {
3622 return blk_0: {
3623 const pos_0 = p.i;
3624 if (blk_1: {
3625 if (std.mem.startsWith(u8, p.source[p.i..], "|")) {
3626 p.i += 1;
3627 break :blk_1 true;
3628 }
3629 break :blk_1 false;
3630 } and blk_1: {
3631 const pos_1 = p.i;
3632 const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
3633 '|'...'|',
3634 '='...'=',
3635 => blk_2: {
3636 p.i += 1;
3637 break :blk_2 true;
3638 },
3639 else => false,
3640 });
3641 p.i = pos_1;
3642 break :blk_1 !match_1;
3643 } and p.parseskip()) break :blk_0 true;
3644 p.i = pos_0;
3645 break :blk_0 false;
3646 };
3647 }
3648 pub fn parsePIPE2(p: *Parser) bool {
3649 return blk_0: {
3650 const pos_0 = p.i;
3651 if (blk_1: {
3652 if (std.mem.startsWith(u8, p.source[p.i..], "||")) {
3653 p.i += 2;
3654 break :blk_1 true;
3655 }
3656 break :blk_1 false;
3657 } and p.parseskip()) break :blk_0 true;
3658 p.i = pos_0;
3659 break :blk_0 false;
3660 };
3661 }
3662 pub fn parsePIPEEQUAL(p: *Parser) bool {
3663 return blk_0: {
3664 const pos_0 = p.i;
3665 if (blk_1: {
3666 if (std.mem.startsWith(u8, p.source[p.i..], "|=")) {
3667 p.i += 2;
3668 break :blk_1 true;
3669 }
3670 break :blk_1 false;
3671 } and p.parseskip()) break :blk_0 true;
3672 p.i = pos_0;
3673 break :blk_0 false;
3674 };
3675 }
3676 pub fn parsePLUS(p: *Parser) bool {
3677 return blk_0: {
3678 const pos_0 = p.i;
3679 if (blk_1: {
3680 if (std.mem.startsWith(u8, p.source[p.i..], "+")) {
3681 p.i += 1;
3682 break :blk_1 true;
3683 }
3684 break :blk_1 false;
3685 } and blk_1: {
3686 const pos_1 = p.i;
3687 const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
3688 '%'...'%',
3689 '+'...'+',
3690 '='...'=',
3691 '|'...'|',
3692 => blk_2: {
3693 p.i += 1;
3694 break :blk_2 true;
3695 },
3696 else => false,
3697 });
3698 p.i = pos_1;
3699 break :blk_1 !match_1;
3700 } and p.parseskip()) break :blk_0 true;
3701 p.i = pos_0;
3702 break :blk_0 false;
3703 };
3704 }
3705 pub fn parsePLUS2(p: *Parser) bool {
3706 return blk_0: {
3707 const pos_0 = p.i;
3708 if (blk_1: {
3709 if (std.mem.startsWith(u8, p.source[p.i..], "++")) {
3710 p.i += 2;
3711 break :blk_1 true;
3712 }
3713 break :blk_1 false;
3714 } and p.parseskip()) break :blk_0 true;
3715 p.i = pos_0;
3716 break :blk_0 false;
3717 };
3718 }
3719 pub fn parsePLUSEQUAL(p: *Parser) bool {
3720 return blk_0: {
3721 const pos_0 = p.i;
3722 if (blk_1: {
3723 if (std.mem.startsWith(u8, p.source[p.i..], "+=")) {
3724 p.i += 2;
3725 break :blk_1 true;
3726 }
3727 break :blk_1 false;
3728 } and p.parseskip()) break :blk_0 true;
3729 p.i = pos_0;
3730 break :blk_0 false;
3731 };
3732 }
3733 pub fn parsePLUSPERCENT(p: *Parser) bool {
3734 return blk_0: {
3735 const pos_0 = p.i;
3736 if (blk_1: {
3737 if (std.mem.startsWith(u8, p.source[p.i..], "+%")) {
3738 p.i += 2;
3739 break :blk_1 true;
3740 }
3741 break :blk_1 false;
3742 } and blk_1: {
3743 const pos_1 = p.i;
3744 const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
3745 '='...'=',
3746 => blk_2: {
3747 p.i += 1;
3748 break :blk_2 true;
3749 },
3750 else => false,
3751 });
3752 p.i = pos_1;
3753 break :blk_1 !match_1;
3754 } and p.parseskip()) break :blk_0 true;
3755 p.i = pos_0;
3756 break :blk_0 false;
3757 };
3758 }
3759 pub fn parsePLUSPERCENTEQUAL(p: *Parser) bool {
3760 return blk_0: {
3761 const pos_0 = p.i;
3762 if (blk_1: {
3763 if (std.mem.startsWith(u8, p.source[p.i..], "+%=")) {
3764 p.i += 3;
3765 break :blk_1 true;
3766 }
3767 break :blk_1 false;
3768 } and p.parseskip()) break :blk_0 true;
3769 p.i = pos_0;
3770 break :blk_0 false;
3771 };
3772 }
3773 pub fn parsePLUSPIPE(p: *Parser) bool {
3774 return blk_0: {
3775 const pos_0 = p.i;
3776 if (blk_1: {
3777 if (std.mem.startsWith(u8, p.source[p.i..], "+|")) {
3778 p.i += 2;
3779 break :blk_1 true;
3780 }
3781 break :blk_1 false;
3782 } and blk_1: {
3783 const pos_1 = p.i;
3784 const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
3785 '='...'=',
3786 => blk_2: {
3787 p.i += 1;
3788 break :blk_2 true;
3789 },
3790 else => false,
3791 });
3792 p.i = pos_1;
3793 break :blk_1 !match_1;
3794 } and p.parseskip()) break :blk_0 true;
3795 p.i = pos_0;
3796 break :blk_0 false;
3797 };
3798 }
3799 pub fn parsePLUSPIPEEQUAL(p: *Parser) bool {
3800 return blk_0: {
3801 const pos_0 = p.i;
3802 if (blk_1: {
3803 if (std.mem.startsWith(u8, p.source[p.i..], "+|=")) {
3804 p.i += 3;
3805 break :blk_1 true;
3806 }
3807 break :blk_1 false;
3808 } and p.parseskip()) break :blk_0 true;
3809 p.i = pos_0;
3810 break :blk_0 false;
3811 };
3812 }
3813 pub fn parseLETTERC(p: *Parser) bool {
3814 return blk_0: {
3815 const pos_0 = p.i;
3816 if (blk_1: {
3817 if (std.mem.startsWith(u8, p.source[p.i..], "c")) {
3818 p.i += 1;
3819 break :blk_1 true;
3820 }
3821 break :blk_1 false;
3822 } and p.parseskip()) break :blk_0 true;
3823 p.i = pos_0;
3824 break :blk_0 false;
3825 };
3826 }
3827 pub fn parseQUESTIONMARK(p: *Parser) bool {
3828 return blk_0: {
3829 const pos_0 = p.i;
3830 if (blk_1: {
3831 if (std.mem.startsWith(u8, p.source[p.i..], "?")) {
3832 p.i += 1;
3833 break :blk_1 true;
3834 }
3835 break :blk_1 false;
3836 } and p.parseskip()) break :blk_0 true;
3837 p.i = pos_0;
3838 break :blk_0 false;
3839 };
3840 }
3841 pub fn parseRARROW(p: *Parser) bool {
3842 return blk_0: {
3843 const pos_0 = p.i;
3844 if (blk_1: {
3845 if (std.mem.startsWith(u8, p.source[p.i..], ">")) {
3846 p.i += 1;
3847 break :blk_1 true;
3848 }
3849 break :blk_1 false;
3850 } and blk_1: {
3851 const pos_1 = p.i;
3852 const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
3853 '>'...'>',
3854 '='...'=',
3855 => blk_2: {
3856 p.i += 1;
3857 break :blk_2 true;
3858 },
3859 else => false,
3860 });
3861 p.i = pos_1;
3862 break :blk_1 !match_1;
3863 } and p.parseskip()) break :blk_0 true;
3864 p.i = pos_0;
3865 break :blk_0 false;
3866 };
3867 }
3868 pub fn parseRARROW2(p: *Parser) bool {
3869 return blk_0: {
3870 const pos_0 = p.i;
3871 if (blk_1: {
3872 if (std.mem.startsWith(u8, p.source[p.i..], ">>")) {
3873 p.i += 2;
3874 break :blk_1 true;
3875 }
3876 break :blk_1 false;
3877 } and blk_1: {
3878 const pos_1 = p.i;
3879 const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
3880 '='...'=',
3881 => blk_2: {
3882 p.i += 1;
3883 break :blk_2 true;
3884 },
3885 else => false,
3886 });
3887 p.i = pos_1;
3888 break :blk_1 !match_1;
3889 } and p.parseskip()) break :blk_0 true;
3890 p.i = pos_0;
3891 break :blk_0 false;
3892 };
3893 }
3894 pub fn parseRARROW2EQUAL(p: *Parser) bool {
3895 return blk_0: {
3896 const pos_0 = p.i;
3897 if (blk_1: {
3898 if (std.mem.startsWith(u8, p.source[p.i..], ">>=")) {
3899 p.i += 3;
3900 break :blk_1 true;
3901 }
3902 break :blk_1 false;
3903 } and p.parseskip()) break :blk_0 true;
3904 p.i = pos_0;
3905 break :blk_0 false;
3906 };
3907 }
3908 pub fn parseRARROWEQUAL(p: *Parser) bool {
3909 return blk_0: {
3910 const pos_0 = p.i;
3911 if (blk_1: {
3912 if (std.mem.startsWith(u8, p.source[p.i..], ">=")) {
3913 p.i += 2;
3914 break :blk_1 true;
3915 }
3916 break :blk_1 false;
3917 } and p.parseskip()) break :blk_0 true;
3918 p.i = pos_0;
3919 break :blk_0 false;
3920 };
3921 }
3922 pub fn parseRBRACE(p: *Parser) bool {
3923 return blk_0: {
3924 const pos_0 = p.i;
3925 if (blk_1: {
3926 if (std.mem.startsWith(u8, p.source[p.i..], "}")) {
3927 p.i += 1;
3928 break :blk_1 true;
3929 }
3930 break :blk_1 false;
3931 } and p.parseskip()) break :blk_0 true;
3932 p.i = pos_0;
3933 break :blk_0 false;
3934 };
3935 }
3936 pub fn parseRBRACKET(p: *Parser) bool {
3937 return blk_0: {
3938 const pos_0 = p.i;
3939 if (blk_1: {
3940 if (std.mem.startsWith(u8, p.source[p.i..], "]")) {
3941 p.i += 1;
3942 break :blk_1 true;
3943 }
3944 break :blk_1 false;
3945 } and p.parseskip()) break :blk_0 true;
3946 p.i = pos_0;
3947 break :blk_0 false;
3948 };
3949 }
3950 pub fn parseRPAREN(p: *Parser) bool {
3951 return blk_0: {
3952 const pos_0 = p.i;
3953 if (blk_1: {
3954 if (std.mem.startsWith(u8, p.source[p.i..], ")")) {
3955 p.i += 1;
3956 break :blk_1 true;
3957 }
3958 break :blk_1 false;
3959 } and p.parseskip()) break :blk_0 true;
3960 p.i = pos_0;
3961 break :blk_0 false;
3962 };
3963 }
3964 pub fn parseSEMICOLON(p: *Parser) bool {
3965 return blk_0: {
3966 const pos_0 = p.i;
3967 if (blk_1: {
3968 if (std.mem.startsWith(u8, p.source[p.i..], ";")) {
3969 p.i += 1;
3970 break :blk_1 true;
3971 }
3972 break :blk_1 false;
3973 } and p.parseskip()) break :blk_0 true;
3974 p.i = pos_0;
3975 break :blk_0 false;
3976 };
3977 }
3978 pub fn parseSLASH(p: *Parser) bool {
3979 return blk_0: {
3980 const pos_0 = p.i;
3981 if (blk_1: {
3982 if (std.mem.startsWith(u8, p.source[p.i..], "/")) {
3983 p.i += 1;
3984 break :blk_1 true;
3985 }
3986 break :blk_1 false;
3987 } and blk_1: {
3988 const pos_1 = p.i;
3989 const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
3990 '='...'=',
3991 => blk_2: {
3992 p.i += 1;
3993 break :blk_2 true;
3994 },
3995 else => false,
3996 });
3997 p.i = pos_1;
3998 break :blk_1 !match_1;
3999 } and p.parseskip()) break :blk_0 true;
4000 p.i = pos_0;
4001 break :blk_0 false;
4002 };
4003 }
4004 pub fn parseSLASHEQUAL(p: *Parser) bool {
4005 return blk_0: {
4006 const pos_0 = p.i;
4007 if (blk_1: {
4008 if (std.mem.startsWith(u8, p.source[p.i..], "/=")) {
4009 p.i += 2;
4010 break :blk_1 true;
4011 }
4012 break :blk_1 false;
4013 } and p.parseskip()) break :blk_0 true;
4014 p.i = pos_0;
4015 break :blk_0 false;
4016 };
4017 }
4018 pub fn parseTILDE(p: *Parser) bool {
4019 return blk_0: {
4020 const pos_0 = p.i;
4021 if (blk_1: {
4022 if (std.mem.startsWith(u8, p.source[p.i..], "~")) {
4023 p.i += 1;
4024 break :blk_1 true;
4025 }
4026 break :blk_1 false;
4027 } and p.parseskip()) break :blk_0 true;
4028 p.i = pos_0;
4029 break :blk_0 false;
4030 };
4031 }
4032 pub fn parseend_of_word(p: *Parser) bool {
4033 return blk_0: {
4034 const pos_0 = p.i;
4035 if (blk_1: {
4036 const pos_1 = p.i;
4037 const match_1 = (p.i < p.source.len and switch (p.source[p.i]) {
4038 'a'...'z',
4039 'A'...'Z',
4040 '0'...'9',
4041 '_'...'_',
4042 => blk_2: {
4043 p.i += 1;
4044 break :blk_2 true;
4045 },
4046 else => false,
4047 });
4048 p.i = pos_1;
4049 break :blk_1 !match_1;
4050 } and p.parseskip()) break :blk_0 true;
4051 p.i = pos_0;
4052 break :blk_0 false;
4053 };
4054 }
4055 pub fn parseKEYWORD_addrspace(p: *Parser) bool {
4056 return blk_0: {
4057 const pos_0 = p.i;
4058 if (blk_1: {
4059 if (std.mem.startsWith(u8, p.source[p.i..], "addrspace")) {
4060 p.i += 9;
4061 break :blk_1 true;
4062 }
4063 break :blk_1 false;
4064 } and p.parseend_of_word()) break :blk_0 true;
4065 p.i = pos_0;
4066 break :blk_0 false;
4067 };
4068 }
4069 pub fn parseKEYWORD_align(p: *Parser) bool {
4070 return blk_0: {
4071 const pos_0 = p.i;
4072 if (blk_1: {
4073 if (std.mem.startsWith(u8, p.source[p.i..], "align")) {
4074 p.i += 5;
4075 break :blk_1 true;
4076 }
4077 break :blk_1 false;
4078 } and p.parseend_of_word()) break :blk_0 true;
4079 p.i = pos_0;
4080 break :blk_0 false;
4081 };
4082 }
4083 pub fn parseKEYWORD_allowzero(p: *Parser) bool {
4084 return blk_0: {
4085 const pos_0 = p.i;
4086 if (blk_1: {
4087 if (std.mem.startsWith(u8, p.source[p.i..], "allowzero")) {
4088 p.i += 9;
4089 break :blk_1 true;
4090 }
4091 break :blk_1 false;
4092 } and p.parseend_of_word()) break :blk_0 true;
4093 p.i = pos_0;
4094 break :blk_0 false;
4095 };
4096 }
4097 pub fn parseKEYWORD_and(p: *Parser) bool {
4098 return blk_0: {
4099 const pos_0 = p.i;
4100 if (blk_1: {
4101 if (std.mem.startsWith(u8, p.source[p.i..], "and")) {
4102 p.i += 3;
4103 break :blk_1 true;
4104 }
4105 break :blk_1 false;
4106 } and p.parseend_of_word()) break :blk_0 true;
4107 p.i = pos_0;
4108 break :blk_0 false;
4109 };
4110 }
4111 pub fn parseKEYWORD_anyframe(p: *Parser) bool {
4112 return blk_0: {
4113 const pos_0 = p.i;
4114 if (blk_1: {
4115 if (std.mem.startsWith(u8, p.source[p.i..], "anyframe")) {
4116 p.i += 8;
4117 break :blk_1 true;
4118 }
4119 break :blk_1 false;
4120 } and p.parseend_of_word()) break :blk_0 true;
4121 p.i = pos_0;
4122 break :blk_0 false;
4123 };
4124 }
4125 pub fn parseKEYWORD_anytype(p: *Parser) bool {
4126 return blk_0: {
4127 const pos_0 = p.i;
4128 if (blk_1: {
4129 if (std.mem.startsWith(u8, p.source[p.i..], "anytype")) {
4130 p.i += 7;
4131 break :blk_1 true;
4132 }
4133 break :blk_1 false;
4134 } and p.parseend_of_word()) break :blk_0 true;
4135 p.i = pos_0;
4136 break :blk_0 false;
4137 };
4138 }
4139 pub fn parseKEYWORD_asm(p: *Parser) bool {
4140 return blk_0: {
4141 const pos_0 = p.i;
4142 if (blk_1: {
4143 if (std.mem.startsWith(u8, p.source[p.i..], "asm")) {
4144 p.i += 3;
4145 break :blk_1 true;
4146 }
4147 break :blk_1 false;
4148 } and p.parseend_of_word()) break :blk_0 true;
4149 p.i = pos_0;
4150 break :blk_0 false;
4151 };
4152 }
4153 pub fn parseKEYWORD_break(p: *Parser) bool {
4154 return blk_0: {
4155 const pos_0 = p.i;
4156 if (blk_1: {
4157 if (std.mem.startsWith(u8, p.source[p.i..], "break")) {
4158 p.i += 5;
4159 break :blk_1 true;
4160 }
4161 break :blk_1 false;
4162 } and p.parseend_of_word()) break :blk_0 true;
4163 p.i = pos_0;
4164 break :blk_0 false;
4165 };
4166 }
4167 pub fn parseKEYWORD_callconv(p: *Parser) bool {
4168 return blk_0: {
4169 const pos_0 = p.i;
4170 if (blk_1: {
4171 if (std.mem.startsWith(u8, p.source[p.i..], "callconv")) {
4172 p.i += 8;
4173 break :blk_1 true;
4174 }
4175 break :blk_1 false;
4176 } and p.parseend_of_word()) break :blk_0 true;
4177 p.i = pos_0;
4178 break :blk_0 false;
4179 };
4180 }
4181 pub fn parseKEYWORD_catch(p: *Parser) bool {
4182 return blk_0: {
4183 const pos_0 = p.i;
4184 if (blk_1: {
4185 if (std.mem.startsWith(u8, p.source[p.i..], "catch")) {
4186 p.i += 5;
4187 break :blk_1 true;
4188 }
4189 break :blk_1 false;
4190 } and p.parseend_of_word()) break :blk_0 true;
4191 p.i = pos_0;
4192 break :blk_0 false;
4193 };
4194 }
4195 pub fn parseKEYWORD_comptime(p: *Parser) bool {
4196 return blk_0: {
4197 const pos_0 = p.i;
4198 if (blk_1: {
4199 if (std.mem.startsWith(u8, p.source[p.i..], "comptime")) {
4200 p.i += 8;
4201 break :blk_1 true;
4202 }
4203 break :blk_1 false;
4204 } and p.parseend_of_word()) break :blk_0 true;
4205 p.i = pos_0;
4206 break :blk_0 false;
4207 };
4208 }
4209 pub fn parseKEYWORD_const(p: *Parser) bool {
4210 return blk_0: {
4211 const pos_0 = p.i;
4212 if (blk_1: {
4213 if (std.mem.startsWith(u8, p.source[p.i..], "const")) {
4214 p.i += 5;
4215 break :blk_1 true;
4216 }
4217 break :blk_1 false;
4218 } and p.parseend_of_word()) break :blk_0 true;
4219 p.i = pos_0;
4220 break :blk_0 false;
4221 };
4222 }
4223 pub fn parseKEYWORD_continue(p: *Parser) bool {
4224 return blk_0: {
4225 const pos_0 = p.i;
4226 if (blk_1: {
4227 if (std.mem.startsWith(u8, p.source[p.i..], "continue")) {
4228 p.i += 8;
4229 break :blk_1 true;
4230 }
4231 break :blk_1 false;
4232 } and p.parseend_of_word()) break :blk_0 true;
4233 p.i = pos_0;
4234 break :blk_0 false;
4235 };
4236 }
4237 pub fn parseKEYWORD_defer(p: *Parser) bool {
4238 return blk_0: {
4239 const pos_0 = p.i;
4240 if (blk_1: {
4241 if (std.mem.startsWith(u8, p.source[p.i..], "defer")) {
4242 p.i += 5;
4243 break :blk_1 true;
4244 }
4245 break :blk_1 false;
4246 } and p.parseend_of_word()) break :blk_0 true;
4247 p.i = pos_0;
4248 break :blk_0 false;
4249 };
4250 }
4251 pub fn parseKEYWORD_else(p: *Parser) bool {
4252 return blk_0: {
4253 const pos_0 = p.i;
4254 if (blk_1: {
4255 if (std.mem.startsWith(u8, p.source[p.i..], "else")) {
4256 p.i += 4;
4257 break :blk_1 true;
4258 }
4259 break :blk_1 false;
4260 } and p.parseend_of_word()) break :blk_0 true;
4261 p.i = pos_0;
4262 break :blk_0 false;
4263 };
4264 }
4265 pub fn parseKEYWORD_enum(p: *Parser) bool {
4266 return blk_0: {
4267 const pos_0 = p.i;
4268 if (blk_1: {
4269 if (std.mem.startsWith(u8, p.source[p.i..], "enum")) {
4270 p.i += 4;
4271 break :blk_1 true;
4272 }
4273 break :blk_1 false;
4274 } and p.parseend_of_word()) break :blk_0 true;
4275 p.i = pos_0;
4276 break :blk_0 false;
4277 };
4278 }
4279 pub fn parseKEYWORD_errdefer(p: *Parser) bool {
4280 return blk_0: {
4281 const pos_0 = p.i;
4282 if (blk_1: {
4283 if (std.mem.startsWith(u8, p.source[p.i..], "errdefer")) {
4284 p.i += 8;
4285 break :blk_1 true;
4286 }
4287 break :blk_1 false;
4288 } and p.parseend_of_word()) break :blk_0 true;
4289 p.i = pos_0;
4290 break :blk_0 false;
4291 };
4292 }
4293 pub fn parseKEYWORD_error(p: *Parser) bool {
4294 return blk_0: {
4295 const pos_0 = p.i;
4296 if (blk_1: {
4297 if (std.mem.startsWith(u8, p.source[p.i..], "error")) {
4298 p.i += 5;
4299 break :blk_1 true;
4300 }
4301 break :blk_1 false;
4302 } and p.parseend_of_word()) break :blk_0 true;
4303 p.i = pos_0;
4304 break :blk_0 false;
4305 };
4306 }
4307 pub fn parseKEYWORD_export(p: *Parser) bool {
4308 return blk_0: {
4309 const pos_0 = p.i;
4310 if (blk_1: {
4311 if (std.mem.startsWith(u8, p.source[p.i..], "export")) {
4312 p.i += 6;
4313 break :blk_1 true;
4314 }
4315 break :blk_1 false;
4316 } and p.parseend_of_word()) break :blk_0 true;
4317 p.i = pos_0;
4318 break :blk_0 false;
4319 };
4320 }
4321 pub fn parseKEYWORD_extern(p: *Parser) bool {
4322 return blk_0: {
4323 const pos_0 = p.i;
4324 if (blk_1: {
4325 if (std.mem.startsWith(u8, p.source[p.i..], "extern")) {
4326 p.i += 6;
4327 break :blk_1 true;
4328 }
4329 break :blk_1 false;
4330 } and p.parseend_of_word()) break :blk_0 true;
4331 p.i = pos_0;
4332 break :blk_0 false;
4333 };
4334 }
4335 pub fn parseKEYWORD_fn(p: *Parser) bool {
4336 return blk_0: {
4337 const pos_0 = p.i;
4338 if (blk_1: {
4339 if (std.mem.startsWith(u8, p.source[p.i..], "fn")) {
4340 p.i += 2;
4341 break :blk_1 true;
4342 }
4343 break :blk_1 false;
4344 } and p.parseend_of_word()) break :blk_0 true;
4345 p.i = pos_0;
4346 break :blk_0 false;
4347 };
4348 }
4349 pub fn parseKEYWORD_for(p: *Parser) bool {
4350 return blk_0: {
4351 const pos_0 = p.i;
4352 if (blk_1: {
4353 if (std.mem.startsWith(u8, p.source[p.i..], "for")) {
4354 p.i += 3;
4355 break :blk_1 true;
4356 }
4357 break :blk_1 false;
4358 } and p.parseend_of_word()) break :blk_0 true;
4359 p.i = pos_0;
4360 break :blk_0 false;
4361 };
4362 }
4363 pub fn parseKEYWORD_if(p: *Parser) bool {
4364 return blk_0: {
4365 const pos_0 = p.i;
4366 if (blk_1: {
4367 if (std.mem.startsWith(u8, p.source[p.i..], "if")) {
4368 p.i += 2;
4369 break :blk_1 true;
4370 }
4371 break :blk_1 false;
4372 } and p.parseend_of_word()) break :blk_0 true;
4373 p.i = pos_0;
4374 break :blk_0 false;
4375 };
4376 }
4377 pub fn parseKEYWORD_inline(p: *Parser) bool {
4378 return blk_0: {
4379 const pos_0 = p.i;
4380 if (blk_1: {
4381 if (std.mem.startsWith(u8, p.source[p.i..], "inline")) {
4382 p.i += 6;
4383 break :blk_1 true;
4384 }
4385 break :blk_1 false;
4386 } and p.parseend_of_word()) break :blk_0 true;
4387 p.i = pos_0;
4388 break :blk_0 false;
4389 };
4390 }
4391 pub fn parseKEYWORD_noalias(p: *Parser) bool {
4392 return blk_0: {
4393 const pos_0 = p.i;
4394 if (blk_1: {
4395 if (std.mem.startsWith(u8, p.source[p.i..], "noalias")) {
4396 p.i += 7;
4397 break :blk_1 true;
4398 }
4399 break :blk_1 false;
4400 } and p.parseend_of_word()) break :blk_0 true;
4401 p.i = pos_0;
4402 break :blk_0 false;
4403 };
4404 }
4405 pub fn parseKEYWORD_nosuspend(p: *Parser) bool {
4406 return blk_0: {
4407 const pos_0 = p.i;
4408 if (blk_1: {
4409 if (std.mem.startsWith(u8, p.source[p.i..], "nosuspend")) {
4410 p.i += 9;
4411 break :blk_1 true;
4412 }
4413 break :blk_1 false;
4414 } and p.parseend_of_word()) break :blk_0 true;
4415 p.i = pos_0;
4416 break :blk_0 false;
4417 };
4418 }
4419 pub fn parseKEYWORD_noinline(p: *Parser) bool {
4420 return blk_0: {
4421 const pos_0 = p.i;
4422 if (blk_1: {
4423 if (std.mem.startsWith(u8, p.source[p.i..], "noinline")) {
4424 p.i += 8;
4425 break :blk_1 true;
4426 }
4427 break :blk_1 false;
4428 } and p.parseend_of_word()) break :blk_0 true;
4429 p.i = pos_0;
4430 break :blk_0 false;
4431 };
4432 }
4433 pub fn parseKEYWORD_opaque(p: *Parser) bool {
4434 return blk_0: {
4435 const pos_0 = p.i;
4436 if (blk_1: {
4437 if (std.mem.startsWith(u8, p.source[p.i..], "opaque")) {
4438 p.i += 6;
4439 break :blk_1 true;
4440 }
4441 break :blk_1 false;
4442 } and p.parseend_of_word()) break :blk_0 true;
4443 p.i = pos_0;
4444 break :blk_0 false;
4445 };
4446 }
4447 pub fn parseKEYWORD_or(p: *Parser) bool {
4448 return blk_0: {
4449 const pos_0 = p.i;
4450 if (blk_1: {
4451 if (std.mem.startsWith(u8, p.source[p.i..], "or")) {
4452 p.i += 2;
4453 break :blk_1 true;
4454 }
4455 break :blk_1 false;
4456 } and p.parseend_of_word()) break :blk_0 true;
4457 p.i = pos_0;
4458 break :blk_0 false;
4459 };
4460 }
4461 pub fn parseKEYWORD_orelse(p: *Parser) bool {
4462 return blk_0: {
4463 const pos_0 = p.i;
4464 if (blk_1: {
4465 if (std.mem.startsWith(u8, p.source[p.i..], "orelse")) {
4466 p.i += 6;
4467 break :blk_1 true;
4468 }
4469 break :blk_1 false;
4470 } and p.parseend_of_word()) break :blk_0 true;
4471 p.i = pos_0;
4472 break :blk_0 false;
4473 };
4474 }
4475 pub fn parseKEYWORD_packed(p: *Parser) bool {
4476 return blk_0: {
4477 const pos_0 = p.i;
4478 if (blk_1: {
4479 if (std.mem.startsWith(u8, p.source[p.i..], "packed")) {
4480 p.i += 6;
4481 break :blk_1 true;
4482 }
4483 break :blk_1 false;
4484 } and p.parseend_of_word()) break :blk_0 true;
4485 p.i = pos_0;
4486 break :blk_0 false;
4487 };
4488 }
4489 pub fn parseKEYWORD_pub(p: *Parser) bool {
4490 return blk_0: {
4491 const pos_0 = p.i;
4492 if (blk_1: {
4493 if (std.mem.startsWith(u8, p.source[p.i..], "pub")) {
4494 p.i += 3;
4495 break :blk_1 true;
4496 }
4497 break :blk_1 false;
4498 } and p.parseend_of_word()) break :blk_0 true;
4499 p.i = pos_0;
4500 break :blk_0 false;
4501 };
4502 }
4503 pub fn parseKEYWORD_resume(p: *Parser) bool {
4504 return blk_0: {
4505 const pos_0 = p.i;
4506 if (blk_1: {
4507 if (std.mem.startsWith(u8, p.source[p.i..], "resume")) {
4508 p.i += 6;
4509 break :blk_1 true;
4510 }
4511 break :blk_1 false;
4512 } and p.parseend_of_word()) break :blk_0 true;
4513 p.i = pos_0;
4514 break :blk_0 false;
4515 };
4516 }
4517 pub fn parseKEYWORD_return(p: *Parser) bool {
4518 return blk_0: {
4519 const pos_0 = p.i;
4520 if (blk_1: {
4521 if (std.mem.startsWith(u8, p.source[p.i..], "return")) {
4522 p.i += 6;
4523 break :blk_1 true;
4524 }
4525 break :blk_1 false;
4526 } and p.parseend_of_word()) break :blk_0 true;
4527 p.i = pos_0;
4528 break :blk_0 false;
4529 };
4530 }
4531 pub fn parseKEYWORD_linksection(p: *Parser) bool {
4532 return blk_0: {
4533 const pos_0 = p.i;
4534 if (blk_1: {
4535 if (std.mem.startsWith(u8, p.source[p.i..], "linksection")) {
4536 p.i += 11;
4537 break :blk_1 true;
4538 }
4539 break :blk_1 false;
4540 } and p.parseend_of_word()) break :blk_0 true;
4541 p.i = pos_0;
4542 break :blk_0 false;
4543 };
4544 }
4545 pub fn parseKEYWORD_struct(p: *Parser) bool {
4546 return blk_0: {
4547 const pos_0 = p.i;
4548 if (blk_1: {
4549 if (std.mem.startsWith(u8, p.source[p.i..], "struct")) {
4550 p.i += 6;
4551 break :blk_1 true;
4552 }
4553 break :blk_1 false;
4554 } and p.parseend_of_word()) break :blk_0 true;
4555 p.i = pos_0;
4556 break :blk_0 false;
4557 };
4558 }
4559 pub fn parseKEYWORD_suspend(p: *Parser) bool {
4560 return blk_0: {
4561 const pos_0 = p.i;
4562 if (blk_1: {
4563 if (std.mem.startsWith(u8, p.source[p.i..], "suspend")) {
4564 p.i += 7;
4565 break :blk_1 true;
4566 }
4567 break :blk_1 false;
4568 } and p.parseend_of_word()) break :blk_0 true;
4569 p.i = pos_0;
4570 break :blk_0 false;
4571 };
4572 }
4573 pub fn parseKEYWORD_switch(p: *Parser) bool {
4574 return blk_0: {
4575 const pos_0 = p.i;
4576 if (blk_1: {
4577 if (std.mem.startsWith(u8, p.source[p.i..], "switch")) {
4578 p.i += 6;
4579 break :blk_1 true;
4580 }
4581 break :blk_1 false;
4582 } and p.parseend_of_word()) break :blk_0 true;
4583 p.i = pos_0;
4584 break :blk_0 false;
4585 };
4586 }
4587 pub fn parseKEYWORD_test(p: *Parser) bool {
4588 return blk_0: {
4589 const pos_0 = p.i;
4590 if (blk_1: {
4591 if (std.mem.startsWith(u8, p.source[p.i..], "test")) {
4592 p.i += 4;
4593 break :blk_1 true;
4594 }
4595 break :blk_1 false;
4596 } and p.parseend_of_word()) break :blk_0 true;
4597 p.i = pos_0;
4598 break :blk_0 false;
4599 };
4600 }
4601 pub fn parseKEYWORD_threadlocal(p: *Parser) bool {
4602 return blk_0: {
4603 const pos_0 = p.i;
4604 if (blk_1: {
4605 if (std.mem.startsWith(u8, p.source[p.i..], "threadlocal")) {
4606 p.i += 11;
4607 break :blk_1 true;
4608 }
4609 break :blk_1 false;
4610 } and p.parseend_of_word()) break :blk_0 true;
4611 p.i = pos_0;
4612 break :blk_0 false;
4613 };
4614 }
4615 pub fn parseKEYWORD_try(p: *Parser) bool {
4616 return blk_0: {
4617 const pos_0 = p.i;
4618 if (blk_1: {
4619 if (std.mem.startsWith(u8, p.source[p.i..], "try")) {
4620 p.i += 3;
4621 break :blk_1 true;
4622 }
4623 break :blk_1 false;
4624 } and p.parseend_of_word()) break :blk_0 true;
4625 p.i = pos_0;
4626 break :blk_0 false;
4627 };
4628 }
4629 pub fn parseKEYWORD_union(p: *Parser) bool {
4630 return blk_0: {
4631 const pos_0 = p.i;
4632 if (blk_1: {
4633 if (std.mem.startsWith(u8, p.source[p.i..], "union")) {
4634 p.i += 5;
4635 break :blk_1 true;
4636 }
4637 break :blk_1 false;
4638 } and p.parseend_of_word()) break :blk_0 true;
4639 p.i = pos_0;
4640 break :blk_0 false;
4641 };
4642 }
4643 pub fn parseKEYWORD_unreachable(p: *Parser) bool {
4644 return blk_0: {
4645 const pos_0 = p.i;
4646 if (blk_1: {
4647 if (std.mem.startsWith(u8, p.source[p.i..], "unreachable")) {
4648 p.i += 11;
4649 break :blk_1 true;
4650 }
4651 break :blk_1 false;
4652 } and p.parseend_of_word()) break :blk_0 true;
4653 p.i = pos_0;
4654 break :blk_0 false;
4655 };
4656 }
4657 pub fn parseKEYWORD_var(p: *Parser) bool {
4658 return blk_0: {
4659 const pos_0 = p.i;
4660 if (blk_1: {
4661 if (std.mem.startsWith(u8, p.source[p.i..], "var")) {
4662 p.i += 3;
4663 break :blk_1 true;
4664 }
4665 break :blk_1 false;
4666 } and p.parseend_of_word()) break :blk_0 true;
4667 p.i = pos_0;
4668 break :blk_0 false;
4669 };
4670 }
4671 pub fn parseKEYWORD_volatile(p: *Parser) bool {
4672 return blk_0: {
4673 const pos_0 = p.i;
4674 if (blk_1: {
4675 if (std.mem.startsWith(u8, p.source[p.i..], "volatile")) {
4676 p.i += 8;
4677 break :blk_1 true;
4678 }
4679 break :blk_1 false;
4680 } and p.parseend_of_word()) break :blk_0 true;
4681 p.i = pos_0;
4682 break :blk_0 false;
4683 };
4684 }
4685 pub fn parseKEYWORD_while(p: *Parser) bool {
4686 return blk_0: {
4687 const pos_0 = p.i;
4688 if (blk_1: {
4689 if (std.mem.startsWith(u8, p.source[p.i..], "while")) {
4690 p.i += 5;
4691 break :blk_1 true;
4692 }
4693 break :blk_1 false;
4694 } and p.parseend_of_word()) break :blk_0 true;
4695 p.i = pos_0;
4696 break :blk_0 false;
4697 };
4698 }
4699 pub fn parsekeyword(p: *Parser) bool {
4700 return blk_0: {
4701 const pos_0 = p.i;
4702 if (p.parseKEYWORD_addrspace()) break :blk_0 true;
4703 p.i = pos_0;
4704 if (p.parseKEYWORD_align()) break :blk_0 true;
4705 p.i = pos_0;
4706 if (p.parseKEYWORD_allowzero()) break :blk_0 true;
4707 p.i = pos_0;
4708 if (p.parseKEYWORD_and()) break :blk_0 true;
4709 p.i = pos_0;
4710 if (p.parseKEYWORD_anyframe()) break :blk_0 true;
4711 p.i = pos_0;
4712 if (p.parseKEYWORD_anytype()) break :blk_0 true;
4713 p.i = pos_0;
4714 if (p.parseKEYWORD_asm()) break :blk_0 true;
4715 p.i = pos_0;
4716 if (p.parseKEYWORD_break()) break :blk_0 true;
4717 p.i = pos_0;
4718 if (p.parseKEYWORD_callconv()) break :blk_0 true;
4719 p.i = pos_0;
4720 if (p.parseKEYWORD_catch()) break :blk_0 true;
4721 p.i = pos_0;
4722 if (p.parseKEYWORD_comptime()) break :blk_0 true;
4723 p.i = pos_0;
4724 if (p.parseKEYWORD_const()) break :blk_0 true;
4725 p.i = pos_0;
4726 if (p.parseKEYWORD_continue()) break :blk_0 true;
4727 p.i = pos_0;
4728 if (p.parseKEYWORD_defer()) break :blk_0 true;
4729 p.i = pos_0;
4730 if (p.parseKEYWORD_else()) break :blk_0 true;
4731 p.i = pos_0;
4732 if (p.parseKEYWORD_enum()) break :blk_0 true;
4733 p.i = pos_0;
4734 if (p.parseKEYWORD_errdefer()) break :blk_0 true;
4735 p.i = pos_0;
4736 if (p.parseKEYWORD_error()) break :blk_0 true;
4737 p.i = pos_0;
4738 if (p.parseKEYWORD_export()) break :blk_0 true;
4739 p.i = pos_0;
4740 if (p.parseKEYWORD_extern()) break :blk_0 true;
4741 p.i = pos_0;
4742 if (p.parseKEYWORD_fn()) break :blk_0 true;
4743 p.i = pos_0;
4744 if (p.parseKEYWORD_for()) break :blk_0 true;
4745 p.i = pos_0;
4746 if (p.parseKEYWORD_if()) break :blk_0 true;
4747 p.i = pos_0;
4748 if (p.parseKEYWORD_inline()) break :blk_0 true;
4749 p.i = pos_0;
4750 if (p.parseKEYWORD_noalias()) break :blk_0 true;
4751 p.i = pos_0;
4752 if (p.parseKEYWORD_nosuspend()) break :blk_0 true;
4753 p.i = pos_0;
4754 if (p.parseKEYWORD_noinline()) break :blk_0 true;
4755 p.i = pos_0;
4756 if (p.parseKEYWORD_opaque()) break :blk_0 true;
4757 p.i = pos_0;
4758 if (p.parseKEYWORD_or()) break :blk_0 true;
4759 p.i = pos_0;
4760 if (p.parseKEYWORD_orelse()) break :blk_0 true;
4761 p.i = pos_0;
4762 if (p.parseKEYWORD_packed()) break :blk_0 true;
4763 p.i = pos_0;
4764 if (p.parseKEYWORD_pub()) break :blk_0 true;
4765 p.i = pos_0;
4766 if (p.parseKEYWORD_resume()) break :blk_0 true;
4767 p.i = pos_0;
4768 if (p.parseKEYWORD_return()) break :blk_0 true;
4769 p.i = pos_0;
4770 if (p.parseKEYWORD_linksection()) break :blk_0 true;
4771 p.i = pos_0;
4772 if (p.parseKEYWORD_struct()) break :blk_0 true;
4773 p.i = pos_0;
4774 if (p.parseKEYWORD_suspend()) break :blk_0 true;
4775 p.i = pos_0;
4776 if (p.parseKEYWORD_switch()) break :blk_0 true;
4777 p.i = pos_0;
4778 if (p.parseKEYWORD_test()) break :blk_0 true;
4779 p.i = pos_0;
4780 if (p.parseKEYWORD_threadlocal()) break :blk_0 true;
4781 p.i = pos_0;
4782 if (p.parseKEYWORD_try()) break :blk_0 true;
4783 p.i = pos_0;
4784 if (p.parseKEYWORD_union()) break :blk_0 true;
4785 p.i = pos_0;
4786 if (p.parseKEYWORD_unreachable()) break :blk_0 true;
4787 p.i = pos_0;
4788 if (p.parseKEYWORD_var()) break :blk_0 true;
4789 p.i = pos_0;
4790 if (p.parseKEYWORD_volatile()) break :blk_0 true;
4791 p.i = pos_0;
4792 if (p.parseKEYWORD_while()) break :blk_0 true;
4793 p.i = pos_0;
4794 break :blk_0 false;
4795 };
4796 }
4797};