From 8898e883761d843d2a3986ec9a1910799869c1a1 Mon Sep 17 00:00:00 2001 From: ecmma Date: Thu, 8 Apr 2021 22:37:01 +0200 Subject: [PATCH 1/9] initial commit --- Cargo.toml | 26 + binding.gyp | 19 + bindings/node/binding.cc | 28 + bindings/node/index.js | 19 + bindings/rust/build.rs | 40 + bindings/rust/lib.rs | 52 + example/+aarch64.ha | 24 + example/+linux.ha | 13 + example/+test.ha | 262 + example/+x86_64.ha | 24 + example/abort+test.ha | 16 + example/abort.ha | 8 + example/addr.ha | 5 + example/adler32.ha | 85 + example/arch+aarch64.ha | 23 + example/arch+x86_64.ha | 23 + example/big.ha | 73 + example/bits.ha | 48 + example/buffered.ha | 294 + example/chars.ha | 30 + example/classes.ha | 42 + example/cmd.ha | 120 + example/common.ha | 32 + example/concat.ha | 34 + example/contains.ha | 15 + example/context.ha | 109 + example/copy.ha | 30 + example/cstring.ha | 16 + example/cstrings.ha | 51 + example/ctype.ha | 102 + example/decl.ha | 192 + example/decode.ha | 151 + example/dirfdfs.ha | 399 + example/docs.ha | 6 + example/dup.ha | 41 + example/dynamic.ha | 192 + example/encode.ha | 41 + example/endian.ha | 29 + example/ensure.ha | 36 + example/env.ha | 4 + example/environ.ha | 112 + example/equal.ha | 24 + example/errno.ha | 423 + example/errors.ha | 40 + example/exec+linux.ha | 83 + example/exit.ha | 4 + example/expr.ha | 89 + example/exprclass.ha | 40 + example/fdstream.ha | 135 + example/fixed.ha | 62 + example/fmt.ha | 432 + example/fnv.ha | 179 + example/fs.ha | 177 + example/ftos.ha | 506 + example/functions.ha | 98 + example/getopts.ha | 307 + example/getuid.ha | 29 + example/hash.ha | 46 + example/hex.ha | 117 + example/host+aarch64.ha | 2 + example/host+x86_64.ha | 2 + example/ident.ha | 31 + example/import.ha | 52 + example/index.ha | 25 + example/ip.ha | 327 + example/iter.ha | 111 + example/itos.ha | 106 + example/jmp.ha | 1 + example/join.ha | 65 + example/lex.ha | 524 + example/limit.ha | 60 + example/limits.ha | 54 + example/little.ha | 73 + example/main.ha | 25 + example/malloc.ha | 163 + example/manifest.ha | 333 + example/md5.ha | 232 + example/memcpy.ha | 6 + example/memset.ha | 6 + example/names.ha | 85 + example/network.ha | 40 + example/nice+linux.ha | 23 + example/numeric.ha | 96 + example/opaque.ha | 26 + example/open.ha | 27 + example/ops.ha | 110 + example/parser.ha | 199 + example/passwd.ha | 135 + example/plan.ha | 197 + example/platformstart.ha | 7 + example/println.ha | 35 + example/process+linux.ha | 87 + example/properties.ha | 1130 + example/random.ha | 35 + example/reverse.ha | 22 + example/rt.ha | 16 + example/run.ha | 108 + example/rune.ha | 27 + example/scan.ha | 391 + example/scanner.ha | 134 + example/schedule.ha | 262 + example/search.ha | 26 + example/segmalloc.ha | 26 + example/setuid.ha | 41 + example/sha1.ha | 224 + example/sha256.ha | 212 + example/sha512.ha | 333 + example/signal.ha | 44 + example/socket.ha | 189 + example/sort.ha | 48 + example/start+test.ha | 22 + example/start.ha | 10 + example/stat.ha | 55 + example/stdfd.ha | 26 + example/stoi.ha | 20 + example/stou.ha | 20 + example/strcmp.ha | 36 + example/stream.ha | 95 + example/string.ha | 20 + example/sub.ha | 55 + example/subcmds.ha | 334 + example/suffix.ha | 48 + example/syscallno+aarch64.ha | 293 + example/syscallno+x86_64.ha | 347 + example/syscalls.ha | 587 + example/tee.ha | 34 + example/token.ha | 283 + example/tokenize.ha | 120 + example/type.ha | 293 + example/types.ha | 23 + example/unicode.ha | 30 + example/unit.ha | 16 + example/utf8.ha | 42 + example/util.ha | 12 + example/utos.ha | 133 + example/uuid.ha | 92 + example/vdso.ha | 166 + example/void.ha | 56 + example/xdg.ha | 58 + example/ztos.ha | 38 + grammar.js | 721 + package.json | 19 + src/grammar.json | 5071 +++++ src/node-types.json | 3059 +++ src/parser.c | 37902 +++++++++++++++++++++++++++++++++ src/tree_sitter/parser.h | 223 + 146 files changed, 62549 insertions(+) create mode 100644 Cargo.toml create mode 100644 binding.gyp create mode 100644 bindings/node/binding.cc create mode 100644 bindings/node/index.js create mode 100644 bindings/rust/build.rs create mode 100644 bindings/rust/lib.rs create mode 100644 example/+aarch64.ha create mode 100644 example/+linux.ha create mode 100644 example/+test.ha create mode 100644 example/+x86_64.ha create mode 100644 example/abort+test.ha create mode 100644 example/abort.ha create mode 100644 example/addr.ha create mode 100644 example/adler32.ha create mode 100644 example/arch+aarch64.ha create mode 100644 example/arch+x86_64.ha create mode 100644 example/big.ha create mode 100644 example/bits.ha create mode 100644 example/buffered.ha create mode 100644 example/chars.ha create mode 100644 example/classes.ha create mode 100644 example/cmd.ha create mode 100644 example/common.ha create mode 100644 example/concat.ha create mode 100644 example/contains.ha create mode 100644 example/context.ha create mode 100644 example/copy.ha create mode 100644 example/cstring.ha create mode 100644 example/cstrings.ha create mode 100644 example/ctype.ha create mode 100644 example/decl.ha create mode 100644 example/decode.ha create mode 100644 example/dirfdfs.ha create mode 100644 example/docs.ha create mode 100644 example/dup.ha create mode 100644 example/dynamic.ha create mode 100644 example/encode.ha create mode 100644 example/endian.ha create mode 100644 example/ensure.ha create mode 100644 example/env.ha create mode 100644 example/environ.ha create mode 100644 example/equal.ha create mode 100644 example/errno.ha create mode 100644 example/errors.ha create mode 100644 example/exec+linux.ha create mode 100644 example/exit.ha create mode 100644 example/expr.ha create mode 100644 example/exprclass.ha create mode 100644 example/fdstream.ha create mode 100644 example/fixed.ha create mode 100644 example/fmt.ha create mode 100644 example/fnv.ha create mode 100644 example/fs.ha create mode 100644 example/ftos.ha create mode 100644 example/functions.ha create mode 100644 example/getopts.ha create mode 100644 example/getuid.ha create mode 100644 example/hash.ha create mode 100644 example/hex.ha create mode 100644 example/host+aarch64.ha create mode 100644 example/host+x86_64.ha create mode 100644 example/ident.ha create mode 100644 example/import.ha create mode 100644 example/index.ha create mode 100644 example/ip.ha create mode 100644 example/iter.ha create mode 100644 example/itos.ha create mode 100644 example/jmp.ha create mode 100644 example/join.ha create mode 100644 example/lex.ha create mode 100644 example/limit.ha create mode 100644 example/limits.ha create mode 100644 example/little.ha create mode 100644 example/main.ha create mode 100644 example/malloc.ha create mode 100644 example/manifest.ha create mode 100644 example/md5.ha create mode 100644 example/memcpy.ha create mode 100644 example/memset.ha create mode 100644 example/names.ha create mode 100644 example/network.ha create mode 100644 example/nice+linux.ha create mode 100644 example/numeric.ha create mode 100644 example/opaque.ha create mode 100644 example/open.ha create mode 100644 example/ops.ha create mode 100644 example/parser.ha create mode 100644 example/passwd.ha create mode 100644 example/plan.ha create mode 100644 example/platformstart.ha create mode 100644 example/println.ha create mode 100644 example/process+linux.ha create mode 100644 example/properties.ha create mode 100644 example/random.ha create mode 100644 example/reverse.ha create mode 100644 example/rt.ha create mode 100644 example/run.ha create mode 100644 example/rune.ha create mode 100644 example/scan.ha create mode 100644 example/scanner.ha create mode 100644 example/schedule.ha create mode 100644 example/search.ha create mode 100644 example/segmalloc.ha create mode 100644 example/setuid.ha create mode 100644 example/sha1.ha create mode 100644 example/sha256.ha create mode 100644 example/sha512.ha create mode 100644 example/signal.ha create mode 100644 example/socket.ha create mode 100644 example/sort.ha create mode 100644 example/start+test.ha create mode 100644 example/start.ha create mode 100644 example/stat.ha create mode 100644 example/stdfd.ha create mode 100644 example/stoi.ha create mode 100644 example/stou.ha create mode 100644 example/strcmp.ha create mode 100644 example/stream.ha create mode 100644 example/string.ha create mode 100644 example/sub.ha create mode 100644 example/subcmds.ha create mode 100644 example/suffix.ha create mode 100644 example/syscallno+aarch64.ha create mode 100644 example/syscallno+x86_64.ha create mode 100644 example/syscalls.ha create mode 100644 example/tee.ha create mode 100644 example/token.ha create mode 100644 example/tokenize.ha create mode 100644 example/type.ha create mode 100644 example/types.ha create mode 100644 example/unicode.ha create mode 100644 example/unit.ha create mode 100644 example/utf8.ha create mode 100644 example/util.ha create mode 100644 example/utos.ha create mode 100644 example/uuid.ha create mode 100644 example/vdso.ha create mode 100644 example/void.ha create mode 100644 example/xdg.ha create mode 100644 example/ztos.ha create mode 100644 grammar.js create mode 100644 package.json create mode 100644 src/grammar.json create mode 100644 src/node-types.json create mode 100644 src/parser.c create mode 100644 src/tree_sitter/parser.h diff --git a/Cargo.toml b/Cargo.toml new file mode 100644 index 000000000..cf1a4a463 --- /dev/null +++ b/Cargo.toml @@ -0,0 +1,26 @@ +[package] +name = "tree-sitter-hare" +description = "hare grammar for the tree-sitter parsing library" +version = "0.0.1" +keywords = ["incremental", "parsing", "hare"] +categories = ["parsing", "text-editors"] +repository = "https://github.com/tree-sitter/tree-sitter-javascript" +edition = "2018" +license = "MIT" + +build = "bindings/rust/build.rs" +include = [ + "bindings/rust/*", + "grammar.js", + "queries/*", + "src/*", +] + +[lib] +path = "bindings/rust/lib.rs" + +[dependencies] +tree-sitter = "0.17" + +[build-dependencies] +cc = "1.0" diff --git a/binding.gyp b/binding.gyp new file mode 100644 index 000000000..027b4ae73 --- /dev/null +++ b/binding.gyp @@ -0,0 +1,19 @@ +{ + "targets": [ + { + "target_name": "tree_sitter_hare_binding", + "include_dirs": [ + " +#include "nan.h" + +using namespace v8; + +extern "C" TSLanguage * tree_sitter_hare(); + +namespace { + +NAN_METHOD(New) {} + +void Init(Local exports, Local module) { + Local tpl = Nan::New(New); + tpl->SetClassName(Nan::New("Language").ToLocalChecked()); + tpl->InstanceTemplate()->SetInternalFieldCount(1); + + Local constructor = Nan::GetFunction(tpl).ToLocalChecked(); + Local instance = constructor->NewInstance(Nan::GetCurrentContext()).ToLocalChecked(); + Nan::SetInternalFieldPointer(instance, 0, tree_sitter_hare()); + + Nan::Set(instance, Nan::New("name").ToLocalChecked(), Nan::New("hare").ToLocalChecked()); + Nan::Set(module, Nan::New("exports").ToLocalChecked(), instance); +} + +NODE_MODULE(tree_sitter_hare_binding, Init) + +} // namespace diff --git a/bindings/node/index.js b/bindings/node/index.js new file mode 100644 index 000000000..c8ec9f108 --- /dev/null +++ b/bindings/node/index.js @@ -0,0 +1,19 @@ +try { + module.exports = require("../../build/Release/tree_sitter_hare_binding"); +} catch (error1) { + if (error1.code !== 'MODULE_NOT_FOUND') { + throw error1; + } + try { + module.exports = require("../../build/Debug/tree_sitter_hare_binding"); + } catch (error2) { + if (error2.code !== 'MODULE_NOT_FOUND') { + throw error2; + } + throw error1 + } +} + +try { + module.exports.nodeTypeInfo = require("../../src/node-types.json"); +} catch (_) {} diff --git a/bindings/rust/build.rs b/bindings/rust/build.rs new file mode 100644 index 000000000..c6061f099 --- /dev/null +++ b/bindings/rust/build.rs @@ -0,0 +1,40 @@ +fn main() { + let src_dir = std::path::Path::new("src"); + + let mut c_config = cc::Build::new(); + c_config.include(&src_dir); + c_config + .flag_if_supported("-Wno-unused-parameter") + .flag_if_supported("-Wno-unused-but-set-variable") + .flag_if_supported("-Wno-trigraphs"); + let parser_path = src_dir.join("parser.c"); + c_config.file(&parser_path); + + // If your language uses an external scanner written in C, + // then include this block of code: + + /* + let scanner_path = src_dir.join("scanner.c"); + c_config.file(&scanner_path); + println!("cargo:rerun-if-changed={}", scanner_path.to_str().unwrap()); + */ + + c_config.compile("parser"); + println!("cargo:rerun-if-changed={}", parser_path.to_str().unwrap()); + + // If your language uses an external scanner written in C++, + // then include this block of code: + + /* + let mut cpp_config = cc::Build::new(); + cpp_config.cpp(true); + cpp_config.include(&src_dir); + cpp_config + .flag_if_supported("-Wno-unused-parameter") + .flag_if_supported("-Wno-unused-but-set-variable"); + let scanner_path = src_dir.join("scanner.cc"); + cpp_config.file(&scanner_path); + cpp_config.compile("scanner"); + println!("cargo:rerun-if-changed={}", scanner_path.to_str().unwrap()); + */ +} diff --git a/bindings/rust/lib.rs b/bindings/rust/lib.rs new file mode 100644 index 000000000..fe4458852 --- /dev/null +++ b/bindings/rust/lib.rs @@ -0,0 +1,52 @@ +//! This crate provides hare language support for the [tree-sitter][] parsing library. +//! +//! Typically, you will use the [language][language func] function to add this language to a +//! tree-sitter [Parser][], and then use the parser to parse some code: +//! +//! ``` +//! let code = ""; +//! let mut parser = tree_sitter::Parser::new(); +//! parser.set_language(tree_sitter_hare::language()).expect("Error loading hare grammar"); +//! let tree = parser.parse(code, None).unwrap(); +//! ``` +//! +//! [Language]: https://docs.rs/tree-sitter/*/tree_sitter/struct.Language.html +//! [language func]: fn.language.html +//! [Parser]: https://docs.rs/tree-sitter/*/tree_sitter/struct.Parser.html +//! [tree-sitter]: https://tree-sitter.github.io/ + +use tree_sitter::Language; + +extern "C" { + fn tree_sitter_hare() -> Language; +} + +/// Get the tree-sitter [Language][] for this grammar. +/// +/// [Language]: https://docs.rs/tree-sitter/*/tree_sitter/struct.Language.html +pub fn language() -> Language { + unsafe { tree_sitter_hare() } +} + +/// The content of the [`node-types.json`][] file for this grammar. +/// +/// [`node-types.json`]: https://tree-sitter.github.io/tree-sitter/using-parsers#static-node-types +pub const NODE_TYPES: &'static str = include_str!("../../src/node-types.json"); + +// Uncomment these to include any queries that this grammar contains + +// pub const HIGHLIGHTS_QUERY: &'static str = include_str!("../../queries/highlights.scm"); +// pub const INJECTIONS_QUERY: &'static str = include_str!("../../queries/injections.scm"); +// pub const LOCALS_QUERY: &'static str = include_str!("../../queries/locals.scm"); +// pub const TAGS_QUERY: &'static str = include_str!("../../queries/tags.scm"); + +#[cfg(test)] +mod tests { + #[test] + fn test_can_load_grammar() { + let mut parser = tree_sitter::Parser::new(); + parser + .set_language(super::language()) + .expect("Error loading hare language"); + } +} diff --git a/example/+aarch64.ha b/example/+aarch64.ha new file mode 100644 index 000000000..039c86fc2 --- /dev/null +++ b/example/+aarch64.ha @@ -0,0 +1,24 @@ +// Returns the new PID to the parent, void to the child, or errno if something +// goes wrong. +export fn clone( + stack: nullable *void, + flags: int, + parent_tid: nullable *int, + child_tid: nullable *int, + tls: u64, +) (int | void | errno) = { + return match (wrap_return(syscall5(SYS_clone, + flags: u64, + stack: uintptr: u64, + parent_tid: uintptr: u64, + tls, + child_tid: uintptr: u64))) { + u: u64 => switch (u) { + 0 => void, + * => u: int, + }, + err: errno => err, + }; +}; + +export def O_DIRECTORY: int = 0o40000; diff --git a/example/+linux.ha b/example/+linux.ha new file mode 100644 index 000000000..8d16e2cec --- /dev/null +++ b/example/+linux.ha @@ -0,0 +1,13 @@ +let start: timespec = timespec { ... }; + +fn time_start() void = { + clock_gettime(CLOCK_MONOTONIC, &start) as void; +}; + +// Returns elapsed time as (seconds, milliseconds) +fn time_stop() (size, size) = { + let end: timespec = timespec { ... }; + clock_gettime(CLOCK_MONOTONIC, &end) as void; + return ((end.tv_sec - start.tv_sec): size, + (end.tv_nsec - start.tv_nsec): size / 10000z); +}; diff --git a/example/+test.ha b/example/+test.ha new file mode 100644 index 000000000..90197c213 --- /dev/null +++ b/example/+test.ha @@ -0,0 +1,262 @@ +use bufio; +use fmt; +use io; +use io::{mode}; +use strings; + +@test fn unget() void = { + let buf = bufio::fixed(strings::toutf8("z"), mode::READ); + let lexer = init(buf, ""); + unget(&lexer, 'x'); + unget(&lexer, 'y'); + assert(next(&lexer) as rune == 'y'); + assert(next(&lexer) as rune == 'x'); + assert(next(&lexer) as rune == 'z'); + assert(next(&lexer) is io::EOF); + unget(&lexer, io::EOF); + assert(next(&lexer) is io::EOF); +}; + +@test fn unlex() void = { + let lexer = init(io::empty, ""); + unlex(&lexer, (btoken::IF, location { + path = "", + line = 1234, + col = 1234, + })); + let t = lex(&lexer) as (token, location); + assert(t.0 is btoken); + assert(t.0 as btoken == btoken::IF); + assert(t.1.path == ""); + assert(t.1.line == 1234 && t.1.col == 1234); +}; + +fn litassert(expected: literal, actual: literal) void = match (expected) { + e: u8 => assert(actual as u8 == e), + e: u16 => assert(actual as u16 == e), + e: u32 => assert(actual as u32 == e), + e: u64 => assert(actual as u64 == e), + e: uint => assert(actual as uint == e), + e: uintptr => assert(actual as uintptr == e), + e: i8 => assert(actual as i8 == e), + e: i16 => assert(actual as i16 == e), + e: i32 => assert(actual as i32 == e), + e: i64 => assert(actual as i64 == e), + e: int => assert(actual as int == e), + e: iconst => assert(actual as iconst == e), + e: f32 => assert(actual as f32 == e), + e: f64 => assert(actual as f64 == e), + e: fconst => assert(actual as fconst == e), + e: rune => assert(actual as rune == e), + e: str => assert(actual as str == e), +}; + +fn lextest(in: str, expected: [](uint, uint, token)) void = { + let buf = bufio::fixed(strings::toutf8(in), mode::READ); + let lexer = init(buf, ""); + for (let i = 0z; i < len(expected); i += 1) { + let eline = expected[i].0, ecol = expected[i].1, + etok = expected[i].2; + let tl = match (lex(&lexer)) { + tl: (token, location) => tl, + io::EOF => { + fmt::errorfln("unexpected EOF at {}", i); + abort(); + }, + err: error => { + fmt::errorfln("{}: {}", i, strerror(err)); + abort(); + }, + }; + let tok = tl.0, loc = tl.1; + match (tok) { + b: btoken => if (!(etok is btoken) || etok as btoken != b) { + fmt::errorfln("bad token at {}: got {}, wanted {}", + i, tokstr(tok), tokstr(etok)); + abort(); + }, + n: name => if (!(etok is name) || etok as name != n) { + fmt::errorfln("bad token at {}: got {}, wanted {}", + i, tokstr(tok), tokstr(etok)); + abort(); + }, + l: literal => if (!(etok is literal)) { + fmt::errorfln("bad token at {}: got {}, wanted {}", + i, tokstr(tok), tokstr(etok)); + abort(); + } else { + litassert(l, etok as literal); + }, + * => abort("TODO"), + }; + assert(loc.path == ""); + if (loc.line != eline || loc.col != ecol) { + fmt::errorfln("bad line/col at {}: got {},{}; wanted {},{}", + i, loc.line, loc.col, eline, ecol); + abort(); + }; + }; + assert(lex(&lexer) is io::EOF); +}; + +@test fn lex1() void = { + const in = "~,{[(}]);"; + const expected: [_](uint, uint, token) = [ + (1, 1, btoken::BNOT), + (1, 2, btoken::COMMA), + (1, 3, btoken::LBRACE), + (1, 4, btoken::LBRACKET), + (1, 5, btoken::LPAREN), + (1, 6, btoken::RBRACE), + (1, 7, btoken::RBRACKET), + (1, 8, btoken::RPAREN), + (1, 9, btoken::SEMICOLON), + ]; + lextest(in, expected); +}; + +@test fn lex2() void = { + // Ends with = to test =, EOF + const in = "^ ^^ ^= * *= % %= + += - -= : :: & && &= | || |= = == / /= ="; + const expected: [_](uint, uint, token) = [ + (1, 1, btoken::BXOR), + (1, 3, btoken::LXOR), + (1, 6, btoken::BXOREQ), + (1, 9, btoken::TIMES), + (1, 11, btoken::TIMESEQ), + (1, 14, btoken::MODULO), + (1, 16, btoken::MODEQ), + (1, 19, btoken::PLUS), + (1, 21, btoken::PLUSEQ), + (1, 24, btoken::MINUS), + (1, 26, btoken::MINUSEQ), + (1, 29, btoken::COLON), + (1, 31, btoken::DOUBLE_COLON), + (1, 34, btoken::BAND), + (1, 36, btoken::LAND), + (1, 39, btoken::ANDEQ), + (1, 42, btoken::BOR), + (1, 44, btoken::LOR), + (1, 47, btoken::OREQ), + (1, 50, btoken::EQUAL), + (1, 52, btoken::LEQUAL), + (1, 55, btoken::DIV), + (1, 57, btoken::DIVEQ), + (1, 60, btoken::EQUAL), + ]; + lextest(in, expected); +}; + +@test fn lex3() void = { + const in = ". .. ... < << <= <<= > >> >= >>= >>"; + const expected: [_](uint, uint, token) = [ + (1, 1, btoken::DOT), + (1, 3, btoken::SLICE), + (1, 6, btoken::ELLIPSIS), + (1, 10, btoken::LESS), + (1, 12, btoken::LSHIFT), + (1, 15, btoken::LESSEQ), + (1, 18, btoken::LSHIFTEQ), + (1, 22, btoken::GREATER), + (1, 24, btoken::RSHIFT), + (1, 27, btoken::GREATEREQ), + (1, 30, btoken::RSHIFTEQ), + (1, 34, btoken::RSHIFT), + ]; + lextest(in, expected); +}; + +@test fn lexname() void = { + const in = "hello world return void foobar"; + const expected: [_](uint, uint, token) = [ + (1, 1, "hello": name), + (1, 7, "world": name), + (1, 13, btoken::RETURN), + (1, 20, btoken::VOID), + (1, 25, "foobar": name), + ]; + lextest(in, expected); +}; + +@test fn keywords() void = { + let keywords = bmap[..btoken::LAST_KEYWORD+1]; + for (let i = 0z; i < len(keywords); i += 1) { + let lexer = init(bufio::fixed( + strings::toutf8(keywords[i]), mode::READ), + ""); + let tl = match (lex(&lexer)) { + tl: (token, location) => tl, + * => abort(), + }; + let tok = tl.0; + assert(tok is btoken); + assert(tok as btoken == i: btoken); + }; +}; + +@test fn comments() void = { + const in = "hello world // foo\nbar"; + const expected: [_](uint, uint, token) = [ + (1, 1, "hello": name), + (1, 7, "world": name), + (2, 1, "bar": name), + ]; + lextest(in, expected); +}; + +@test fn runes() void = { + const in = "'a' 'b' '\\a' '\\b' '\\f' '\\n' '\\r' '\\t' '\\v' '\\0' " + "'\\\\' '\\\'' '\\x0A' '\\u1234' '\\U12345678'"; + const expected: [_](uint, uint, token) = [ + (1, 1, 'a'), + (1, 5, 'b'), + (1, 9, '\a'), + (1, 14, '\b'), + (1, 19, '\f'), + (1, 24, '\n'), + (1, 29, '\r'), + (1, 34, '\t'), + (1, 39, '\v'), + (1, 44, '\0'), + (1, 49, '\\'), + (1, 54, '\''), + (1, 59, '\x0A'), + (1, 66, '\u1234'), + (1, 75, '\U12345678'), + ]; + lextest(in, expected); +}; + +@test fn strings() void = { + const in = "\"a\" \"b\" \"\\a\" \"\\b\" \"\\f\" \"\\n\" \"\\r\" " + "\"\\t\" \"\\v\" \"\\0\" \"\\\\\" \"\\\'\""; + const expected: [_](uint, uint, token) = [ + (1, 1, "a": literal), + (1, 5, "b": literal), + (1, 9, "\a": literal), + (1, 14, "\b": literal), + (1, 19, "\f": literal), + (1, 24, "\n": literal), + (1, 29, "\r": literal), + (1, 34, "\t": literal), + (1, 39, "\v": literal), + (1, 44, "\0": literal), + (1, 49, "\\": literal), + (1, 54, "\'": literal), + ]; + // TODO: test \x and \u and \U + lextest(in, expected); + const in = "\"ab\\a\\b\\f\\n\\r\\t\\v\\0\\\\\\'\""; + const expected: [_](uint, uint, token) = [ + (1, 1, "ab\a\b\f\n\r\t\v\0\\\'": literal), + ]; + lextest(in, expected); + const in = "\"hello world\" \"こんにちは\" \"return\" \"foo\""; + const expected: [_](uint, uint, token) = [ + (1, 1, "hello world": literal), + (1, 15, "こんにちは": literal), + (1, 23, "return": literal), + (1, 32, "foo": literal), + ]; + lextest(in, expected); +}; diff --git a/example/+x86_64.ha b/example/+x86_64.ha new file mode 100644 index 000000000..386aee7ec --- /dev/null +++ b/example/+x86_64.ha @@ -0,0 +1,24 @@ +// Returns the new PID to the parent, void to the child, or errno if something +// goes wrong. +export fn clone( + stack: nullable *void, + flags: int, + parent_tid: nullable *int, + child_tid: nullable *int, + tls: u64, +) (int | void | errno) = { + return match (wrap_return(syscall5(SYS_clone, + flags: u64, + stack: uintptr: u64, + parent_tid: uintptr: u64, + child_tid: uintptr: u64, + tls))) { + u: u64 => switch (u) { + 0 => void, + * => u: int, + }, + err: errno => err, + }; +}; + +export def O_DIRECTORY: int = 0o200000; diff --git a/example/abort+test.ha b/example/abort+test.ha new file mode 100644 index 000000000..947ff6b9a --- /dev/null +++ b/example/abort+test.ha @@ -0,0 +1,16 @@ +export @noreturn @symbol("rt.abort") fn _abort(msg: str) void = { + reason = abort_reason { loc = "", msg = msg }; + longjmp(&jmp, 1); +}; + +// See harec:include/gen.h +const reasons: [_]str = [ + "slice or array access out of bounds", // 0 + "type assertion failed", // 1 + "out of memory", // 2 +]; + +export @noreturn fn abort_fixed(loc: str, i: int) void = { + reason = abort_reason { loc = loc, msg = reasons[i] }; + longjmp(&jmp, 1); +}; diff --git a/example/abort.ha b/example/abort.ha new file mode 100644 index 000000000..7201b75bd --- /dev/null +++ b/example/abort.ha @@ -0,0 +1,8 @@ +fn platform_abort(msg: str) void = { + const prefix = "Abort: "; + const linefeed = "\n"; + write(2, *(&prefix: **void): *const char, len(prefix)); + write(2, *(&msg: **void): *const char, len(msg)); + write(2, *(&linefeed: **void): *const char, 1); + kill(getpid(), SIGABRT); +}; diff --git a/example/addr.ha b/example/addr.ha new file mode 100644 index 000000000..e782334e6 --- /dev/null +++ b/example/addr.ha @@ -0,0 +1,5 @@ +// A UNIX socket address. +export type addr = str; + +// Invalid UNIX socket path. +export type invalid = void!; diff --git a/example/adler32.ha b/example/adler32.ha new file mode 100644 index 000000000..5779f8977 --- /dev/null +++ b/example/adler32.ha @@ -0,0 +1,85 @@ +// Implements the Adler-32 checksum algorithm. It is a non-cryptographic +// checksum. + +use endian; +use hash; +use io; +use strings; + +type state = struct { + hash: hash::hash, + a: u32, + b: u32, +}; + +// Creates a [hash::hash] which computes the Adler-32 checksum algorithm. +export fn adler32() *hash::hash = alloc(state { + hash = hash::hash { + stream = io::stream { + writer = &write, + closer = &close, + ... + }, + sum = &sum, + reset = &reset, + sz = 4, + }, + a = 1, + b = 0, +}): *hash::hash; + +fn close(s: *io::stream) void = free(s); + +fn write(s: *io::stream, buf: const []u8) (size | io::error) = { + let s = s: *state; + for (let i = 0z; i < len(buf); i += 1) { + s.a = (s.a + buf[i]) % 65521; + s.b = (s.b + s.a) % 65521; + }; + return len(buf); +}; + +fn reset(h: *hash::hash) void = { + let h = h: *state; + h.a = 1; + h.b = 0; +}; + +fn sum(h: *hash::hash) []u8 = { + let h = h: *state; + let buf: [4]u8 = [0...]; + // RFC 1950 specifies that Adler-32 checksums are stored in network + // order. + endian::beputu32(buf, (h.b << 16) | h.a); + return alloc(buf); +}; + +export fn sum32(h: *hash::hash) u32 = { + assert(h.reset == &reset); + let h = h: *state; + return h.b << 16 | h.a; +}; + +@test fn adler32() void = { + const vectors: [](str, u32) = [ + ("", 1), + ("hello world", 436929629), + ("Hare is a cool language", 1578567727), + ("'UNIX was not designed to stop its users from doing stupid things, as that would also stop them from doing clever things' - Doug Gwyn", 2140876731), + ("'Life is too short to run proprietary software' - Bdale Garbee", 3135706652), + ("'The central enemy of reliability is complexity.' - Geer et al", 3170309588), + ("'A language that doesn’t have everything is actually easier to program in than some that do.' - Dennis Ritchie", 1148528899), + + ]; + let hash = adler32(); + defer hash::close(hash); + for (let i = 0z; i < len(vectors); i += 1) { + let vec = vectors[i]; + hash::reset(hash); + hash::write(hash, strings::toutf8(vec.0)); + let s = hash::sum(hash); + defer free(s); + assert(endian::begetu32(s) == vec.1); + assert(sum32(hash) == vec.1); + }; +}; diff --git a/example/arch+aarch64.ha b/example/arch+aarch64.ha new file mode 100644 index 000000000..f555dc0d9 --- /dev/null +++ b/example/arch+aarch64.ha @@ -0,0 +1,23 @@ +// Minimum value which can be stored in an int type. +export def INT_MIN: int = I32_MIN; + +// Maximum value which can be stored in an int type. +export def INT_MAX: int = I32_MAX; + +// Minimum value which can be stored in a uint type +export def UINT_MIN: uint = U32_MIN; + +// Maximum value which can be stored in a uint type. +export def UINT_MAX: uint = U32_MAX; + +// Minimum value which can be stored in a size type +export def SIZE_MIN: size = U64_MIN; + +// Maximum value which can be stored in a size type. +export def SIZE_MAX: size = U64_MAX; + +// Minimum value which can be stored in a uintptr type +export def UINTPTR_MIN: uintptr = U64_MIN: uintptr; + +// Maximum value which can be stored in a uintptr type. +export def UINTPTR_MAX: uintptr = U64_MAX: uintptr; diff --git a/example/arch+x86_64.ha b/example/arch+x86_64.ha new file mode 100644 index 000000000..f555dc0d9 --- /dev/null +++ b/example/arch+x86_64.ha @@ -0,0 +1,23 @@ +// Minimum value which can be stored in an int type. +export def INT_MIN: int = I32_MIN; + +// Maximum value which can be stored in an int type. +export def INT_MAX: int = I32_MAX; + +// Minimum value which can be stored in a uint type +export def UINT_MIN: uint = U32_MIN; + +// Maximum value which can be stored in a uint type. +export def UINT_MAX: uint = U32_MAX; + +// Minimum value which can be stored in a size type +export def SIZE_MIN: size = U64_MIN; + +// Maximum value which can be stored in a size type. +export def SIZE_MAX: size = U64_MAX; + +// Minimum value which can be stored in a uintptr type +export def UINTPTR_MIN: uintptr = U64_MIN: uintptr; + +// Maximum value which can be stored in a uintptr type. +export def UINTPTR_MAX: uintptr = U64_MAX: uintptr; diff --git a/example/big.ha b/example/big.ha new file mode 100644 index 000000000..f1eec0b45 --- /dev/null +++ b/example/big.ha @@ -0,0 +1,73 @@ +// Reads a u16 from a buffer in big-endian order. +export fn begetu16(buf: []u8) u16 = { + return + (buf[0] << 8u16) | + (buf[1] << 0); +}; + +// Writes a u16 into a buffer in big-endian order. +export fn beputu16(buf: []u8, in: u16) void = { + buf[1] = (in >> 0): u8; + buf[0] = (in >> 8): u8; +}; + +// Reads a u32 from a buffer in big-endian order. +export fn begetu32(buf: []u8) u32 = { + return + (buf[0] << 24u32) | + (buf[1] << 16u32) | + (buf[2] << 8u32) | + (buf[3] << 0); +}; + +// Writes a u32 into a buffer in big-endian order. +export fn beputu32(buf: []u8, in: u32) void = { + buf[3] = (in >> 0): u8; + buf[2] = (in >> 8): u8; + buf[1] = (in >> 16): u8; + buf[0] = (in >> 24): u8; +}; + +// Reads a u64 from a buffer in big-endian order. +export fn begetu64(buf: []u8) u64 = { + return + (buf[0] << 56u64) | + (buf[1] << 48u64) | + (buf[2] << 40u64) | + (buf[3] << 32u64) | + (buf[4] << 24u64) | + (buf[5] << 16u64) | + (buf[6] << 8u64) | + (buf[7] << 0); +}; + +// Writes a u64 into a buffer in big-endian order. +export fn beputu64(buf: []u8, in: u64) void = { + buf[7] = (in >> 0): u8; + buf[6] = (in >> 8): u8; + buf[5] = (in >> 16): u8; + buf[4] = (in >> 24): u8; + buf[3] = (in >> 32): u8; + buf[2] = (in >> 40): u8; + buf[1] = (in >> 48): u8; + buf[0] = (in >> 56): u8; +}; + +@test fn big() void = { + let buf: [8]u8 = [0...]; + beputu16(buf, 0x1234); + assert(buf[0] == 0x12 && buf[1] == 0x34); + assert(begetu16(buf) == 0x1234); + + beputu32(buf, 0x12345678); + assert(buf[0] == 0x12 && buf[1] == 0x34 + && buf[2] == 0x56 && buf[3] == 0x78); + assert(begetu32(buf) == 0x12345678); + + beputu64(buf, 0x1234567887654321); + assert(buf[0] == 0x12 && buf[1] == 0x34 + && buf[2] == 0x56 && buf[3] == 0x78 + && buf[4] == 0x87 && buf[5] == 0x65 + && buf[6] == 0x43 && buf[7] == 0x21); + assert(begetu64(buf) == 0x1234567887654321); +}; diff --git a/example/bits.ha b/example/bits.ha new file mode 100644 index 000000000..eaa7c9a38 --- /dev/null +++ b/example/bits.ha @@ -0,0 +1,48 @@ +// crypto::math provides constant-time mathematical operations useful for +// cryptographic algorithms. + +// Rotates a 32-bit unsigned integer left by k bits. k may be negative to rotate +// right instead, or see [rotr32]. +export fn rotl32(x: u32, k: int) u32 = { + const n = 32u32; + const s = k: u32 & (n - 1); + return x << s | x >> (n - s); +}; + +// Rotates a 32-bit unsigned integer right by k bits. k may be negative to +// rotate left instead, or see [rotl32]. +export fn rotr32(x: u32, k: int) u32 = rotl32(x, -k); + +@test fn lrot32() void = { + let a = 0b11110000111100001111000011110000u32; + assert(rotl32(a, 2) == 0b11000011110000111100001111000011u32); + assert(rotl32(a, -2) == 0b00111100001111000011110000111100u32); + assert(rotl32(a, 32) == 0b11110000111100001111000011110000u32); + assert(rotl32(a, 64) == 0b11110000111100001111000011110000u32); +}; + +// Rotates a 64-bit unsigned integer left by k bits. k may be negative to rotate +// right instead, or see [rotr64]. +export fn rotl64(x: u64, k: int) u64 = { + const n = 64u64; + const s = k: u64 & (n - 1); + return x << s | x >> (n - s); +}; + +// Rotates a 64-bit unsigned integer right by k bits. k may be negative to rotate +// left instead, or see [rotl64]. +export fn rotr64(x: u64, k: int) u64 = rotl64(x, -k); + +@test fn lrot64() void = { + let a = 1u64; + assert(rotl64(a, 1) == 0b10); + assert(rotl64(a, -1) == 0b1000000000000000000000000000000000000000000000000000000000000000); + assert(rotl64(a, 39) == (1u64 << 39)); + + let a = 0b1111000011110000111100001111000011110000111100001111000011110000u64; + assert(rotl64(a, 64) == a); + assert(rotl64(a, 0) == a); + assert(rotl64(a, 2) == 0b1100001111000011110000111100001111000011110000111100001111000011u64); + assert(rotl64(a, -2) == 0b0011110000111100001111000011110000111100001111000011110000111100u64); + +}; diff --git a/example/buffered.ha b/example/buffered.ha new file mode 100644 index 000000000..2baceea29 --- /dev/null +++ b/example/buffered.ha @@ -0,0 +1,294 @@ +use bytes; +use encoding::utf8; +use errors; +use io; +use strings; + +export type bufstream = struct { + stream: io::stream, + source: *io::stream, + rbuffer: []u8, + wbuffer: []u8, + ravail: size, + wavail: size, + flush: []u8, + unread: []u8, +}; + +export fn static_buffered( + src: *io::stream, + rbuf: []u8, + wbuf: []u8, + s: *bufstream, +) *io::stream = { + static let flush_default = ['\n': u32: u8]; + *s = bufstream { + stream = io::stream { + name = src.name, + closer = &buffered_close_static, + unwrap = &buffered_unwrap, + }, + source = src, + rbuffer = rbuf, + wbuffer = wbuf, + flush = flush_default, + ... + }; + if (len(rbuf) != 0) { + s.stream.reader = &buffered_read; + }; + if (len(wbuf) != 0) { + s.stream.writer = &buffered_write; + }; + if (len(rbuf) != 0 && len(wbuf) != 0) { + assert(rbuf: *[*]u8 != wbuf: *[*]u8, + "Cannot use bufio::buffered with same buffer for reads and writes"); + }; + return &s.stream; +}; + +// Creates a stream which buffers reads and writes for the underlying stream. +// This is generally used to improve performance of small reads/writes for +// sources where I/O operations are costly, such as if they invoke a syscall or +// take place over the network. +// +// The caller should supply one or both of a read and write buffer as a slice of +// the desired buffer, or empty slices if read or write functionality is +// disabled. The same buffer may not be used for both reads and writes. +// +// The caller is responsible for closing the underlying stream and freeing the +// provided buffers after the buffered stream is closed. +export fn buffered( + src: *io::stream, + rbuf: []u8, + wbuf: []u8, +) *io::stream = { + let s = alloc(bufstream { ... }); + let st = static_buffered(src, rbuf, wbuf, s); + st.closer = &buffered_close; + return st; +}; + +// Flushes pending writes to the underlying stream. +export fn flush(s: *io::stream) (io::error | void) = { + assert(s.writer == &buffered_write, + "bufio::flushed used on non-buffered stream"); + let s = s: *bufstream; + io::write(s.source, s.wbuffer[..s.wavail])?; + s.wavail = 0; + return; +}; + +// Sets the list of bytes which will cause the stream to flush when written. By +// default, the stream will flush when a newline (\n) is written. +export fn setflush(s: *io::stream, b: []u8) void = { + assert(s.writer == &buffered_write, + "bufio: setflush used on non-buffered stream"); + let s = s: *bufstream; + s.flush = b; +}; + +// Returns true if this is a buffered stream. +export fn isbuffered(s: *io::stream) bool = { + return s.reader == &buffered_read || s.writer == &buffered_write; +}; + +// Returns true if this stream or any underlying streams are buffered. +export fn any_isbuffered(s: *io::stream) bool = { + for (!isbuffered(s)) { + s = match (io::source(s)) { + errors::unsupported => return false, + s: *io::stream => s, + }; + }; + return true; +}; + +// Unreads a slice of bytes. The next read calls on this buffer will consume the +// un-read data before consuming further data from the underlying source, or any +// buffered data. +export fn unread(s: *io::stream, buf: []u8) void = { + assert(isbuffered(s), "bufio: unread used on non-buffered stream"); + let s = s: *bufstream; + append(s.unread, ...buf); +}; + +// Unreads a rune; see [unread]. +export fn unreadrune(s: *io::stream, rn: rune) void = { + assert(isbuffered(s), "bufio: unread used on non-buffered stream"); + let s = s: *bufstream; + append(s.unread, ...utf8::encoderune(rn)); +}; + +fn buffered_close(s: *io::stream) void = { + assert(s.closer == &buffered_close); + if (s.writer != null) { + flush(s); + }; + free(s); +}; + +fn buffered_close_static(s: *io::stream) void = { + assert(s.closer == &buffered_close_static); + if (s.writer != null) { + flush(s); + }; + free(s); +}; + +fn buffered_unwrap(s: *io::stream) *io::stream = { + assert(s.unwrap == &buffered_unwrap); + let s = s: *bufstream; + return s.source; +}; + +fn buffered_read(s: *io::stream, buf: []u8) (size | io::EOF | io::error) = { + assert(s.reader == &buffered_read); + let s = s: *bufstream; + if (len(s.unread) != 0) { + let n = if (len(buf) < len(s.unread)) len(buf) else len(s.unread); + buf[..n] = s.unread[..n]; + delete(s.unread[..n]); + return n; + }; + + let n = if (len(buf) < len(s.rbuffer)) len(buf) else len(s.rbuffer); + if (n > s.ravail) { + let z = match (io::read(s.source, s.rbuffer[s.ravail..])) { + err: io::error => return err, + io::EOF => { + if (s.ravail == 0) { + return io::EOF; + }; + 0z; + }, + z: size => z, + }; + s.ravail += z; + n = if (n > s.ravail) s.ravail else n; + assert(n != 0); + }; + + buf[..n] = s.rbuffer[..n]; + s.rbuffer[..len(s.rbuffer) - n] = s.rbuffer[n..]; + s.ravail -= n; + return n; +}; + +fn buffered_write(s: *io::stream, buf: const []u8) (size | io::error) = { + assert(s.writer == &buffered_write); + let s = s: *bufstream; + let buf = buf; + + let doflush = false; + for (let i = 0z; i < len(buf); i += 1) { + for (let j = 0z; j < len(s.flush); j += 1) { + if (buf[i] == s.flush[j]) { + doflush = true; + break; + }; + }; + }; + + let z = 0z; + for (len(buf) > 0) { + let avail = len(s.wbuffer) - s.wavail; + if (avail == 0) { + flush(&s.stream)?; + avail = len(s.wbuffer); + }; + + const n = if (avail < len(buf)) avail else len(buf); + s.wbuffer[s.wavail..s.wavail + n] = buf[..n]; + buf = buf[n..]; + s.wavail += n; + z += n; + }; + + if (doflush) { + flush(&s.stream)?; + }; + + return z; +}; + +@test fn buffered_read() void = { + let sourcebuf: []u8 = [1, 3, 3, 7]; + let source = fixed(sourcebuf, io::mode::READ); + let fb = source: *fixed_stream; + defer io::close(source); + + let rbuf: [1024]u8 = [0...]; + let f = buffered(source, rbuf, []); + defer io::close(f); + + let buf: [1024]u8 = [0...]; + assert(io::read(f, buf[..2]) as size == 2); + assert(len(fb.buf) == 0, "fixed stream was not fully consumed"); + assert(bytes::equal(buf[..2], [1, 3])); + + assert(io::read(f, buf[2..]) as size == 2); + assert(bytes::equal(buf[..4], [1, 3, 3, 7])); + assert(io::read(f, buf) is io::EOF); + + let sourcebuf: [32]u8 = [1, 3, 3, 7, 0...]; + sourcebuf[32..36] = [7, 3, 3, 1]; + let source = fixed(sourcebuf, io::mode::READ); + let fb = source: *fixed_stream; + defer io::close(source); + + let rbuf: [16]u8 = [0...]; + let f = buffered(source, rbuf, []); + defer io::close(f); + + let buf: [32]u8 = [0...]; + assert(io::read(f, buf) as size == 16); + assert(len(fb.buf) == 16); + + assert(io::read(f, buf[16..]) as size == 16); + assert(bytes::equal(buf, sourcebuf)); + assert(io::read(f, buf) is io::EOF); + assert(len(fb.buf) == 0); +}; + +@test fn buffered_write() void = { + // Normal case + let sink = dynamic(io::mode::WRITE); + defer io::close(sink); + + let wbuf: [1024]u8 = [0...]; + let f = buffered(sink, [], wbuf); + defer io::close(f); + + assert(io::write(f, [1, 3, 3, 7]) as size == 4); + assert(len(buffer(sink)) == 0); + assert(io::write(f, [1, 3, 3, 7]) as size == 4); + assert(flush(f) is void); + assert(bytes::equal(buffer(sink), [1, 3, 3, 7, 1, 3, 3, 7])); + + // Test flushing via buffer exhaustion + let sink = dynamic(io::mode::WRITE); + defer io::close(sink); + + let wbuf: [4]u8 = [0...]; + let f = buffered(sink, [], wbuf); + + assert(io::write(f, [1, 3, 3, 7]) as size == 4); + assert(len(buffer(sink)) == 0); + assert(io::write(f, [1, 3, 3, 7]) as size == 4); + assert(bytes::equal(buffer(sink), [1, 3, 3, 7])); + io::close(f); // Should flush + assert(bytes::equal(buffer(sink), [1, 3, 3, 7, 1, 3, 3, 7])); + + // Test flushing via flush characters + let sink = dynamic(io::mode::WRITE); + defer io::close(sink); + + let wbuf: [1024]u8 = [0...]; + let f = buffered(sink, [], wbuf); + + assert(io::write(f, strings::toutf8("hello")) as size == 5); + assert(len(buffer(sink)) == 0); + assert(io::write(f, strings::toutf8(" world!\n")) as size == 8); + assert(bytes::equal(buffer(sink), strings::toutf8("hello world!\n"))); +}; diff --git a/example/chars.ha b/example/chars.ha new file mode 100644 index 000000000..3662c7850 --- /dev/null +++ b/example/chars.ha @@ -0,0 +1,30 @@ +use ascii; + +fn isnamestart(rn: rune) bool = { + if (rn == ':' || rn == '_' || ascii::isalpha(rn)) return true; + let rn = rn: u32; + return + (rn >= 0xC0 && rn <= 0xD6) || + (rn >= 0xD8 && rn <= 0xF6) || + (rn >= 0xF8 && rn <= 0x2FF) || + (rn >= 0x370 && rn <= 0x37D) || + (rn >= 0x37F && rn <= 0x1FFF) || + (rn >= 0x200C && rn <= 0x200D) || + (rn >= 0x2070 && rn <= 0x218F) || + (rn >= 0x2C00 && rn <= 0x2FEF) || + (rn >= 0x3001 && rn <= 0xD7FF) || + (rn >= 0xF900 && rn <= 0xFDCF) || + (rn >= 0xFDF0 && rn <= 0xFFFD) || + (rn >= 0x10000 && rn <= 0xEFFFF); +}; + +fn isname(rn: rune) bool = { + if (isnamestart(rn) || rn == '-' || rn == '.' || ascii::isdigit(rn)) { + return true; + }; + let rn = rn: u32; + return + (rn == 0xB7) || + (rn >= 0x300 && rn <= 0x36F) || + (rn >= 0x203F && rn <= 0x2040); +}; diff --git a/example/classes.ha b/example/classes.ha new file mode 100644 index 000000000..d1541af95 --- /dev/null +++ b/example/classes.ha @@ -0,0 +1,42 @@ +// A tagged union of all signed integer types. +export type signed = (i8 | i16 | i32 | i64 | int); + +// A tagged union of all unsigned integer types, excluding uintptr. +export type unsigned = (u8 | u16 | u32 | u64 | uint | size); + +// A tagged union of all integer types. +export type integer = (...signed | ...unsigned); + +// A tagged union of all floating point numeric types. +export type floating = (f32 | f64); + +// A tagged union of all numeric types. +export type numeric = (...integer | ...floating); + +// A type representing the internal structure of strings, useful for low-level +// string manipulation. +export type string = struct { + // UTF-8 encoded octets, plus a NUL terminator. + data: nullable *[*]u8, + + // The length capacity, in octets of UTF-8 data, not including the NUL + // terminator. + length: size, + + // The allocated capacity, in octets of UTF-8 data, not including the + // NUL terminator. + capacity: size, +}; + +// A type representing the internal structure of slices, useful for low-level +// slice manipulation. +export type slice = struct { + // The slice contents. + data: nullable *void, + + // The number of members of the slice. + length: size, + + // The allocated capacity (in members) of data. + capacity: size, +}; diff --git a/example/cmd.ha b/example/cmd.ha new file mode 100644 index 000000000..e8a45010c --- /dev/null +++ b/example/cmd.ha @@ -0,0 +1,120 @@ +use ascii; +use errors; +use os; +use strings; + +// Prepares a [command] based on its name and a list of arguments. The argument +// list should not start with the command name; it will be added for you. The +// argument list is borrowed from the strings you pass into this command. +// +// If 'name' does not contain a '/', the $PATH will be consulted to find the +// correct executable. If path resolution fails, nocmd is returned. +// +// let cmd = exec::cmd("echo", "hello world"); +// let proc = exec::start(&cmd); +// let status = exec::wait(&proc); +// assert(exec::status(status) == 0); +// +// By default, the new command will inherit the current process's environment. +export fn cmd(name: str, args: str...) (command | error) = { + let env = os::getenvs(); + let cmd = command { + platform: platform_cmd = + if (strings::contains(name, '/')) match (open(name)) { + err: errors::opaque => return nocmd, + p: platform_cmd => p, + } else match (lookup(name)) { + void => return nocmd, + p: platform_cmd => p, + }, + argv = alloc([], len(args) + 1z), + env = alloc([], len(env)), + ... + }; + append(cmd.argv, name, ...args); + append(cmd.env, ...env); + return cmd; +}; + +// Sets the 0th value of argv for this command. It is uncommon to need this. +export fn setname(cmd: *command, name: str) void = { + free(cmd.argv[0]); + cmd.argv[0] = name; +}; + +// Frees state associated with a command. You only need to call this if you do +// not execute the command with [exec] or [start]; in those cases the state is +// cleaned up for you. +export fn finish(cmd: *command) void = { + platform_finish(cmd); + free(cmd.argv); +}; + +// Executes a prepared command in the current address space, overwriting the +// running process with the new command. +export @noreturn fn exec(cmd: *command) void = { + defer finish(cmd); // Note: doesn't happen if exec succeeds + platform_exec(cmd); + abort("os::exec::exec failed"); +}; + +// Starts a prepared command in a new process. +export fn start(cmd: *command) (error | process) = { + defer finish(cmd); + return match (platform_start(cmd)) { + err: errors::opaque => err, + proc: process => proc, + }; +}; + +// Empties the environment variables for the command. By default, the command +// inherits the environment of the parent process. +export fn clearenv(cmd: *command) void = { + cmd.env = []; +}; + +// Adds or sets a variable in the command environment. This does not affect the +// current process environment. The 'key' must be a valid environment variable +// name per POSIX definition 3.235. This includes underscores and alphanumeric +// ASCII characters, and cannot begin with a number. +export fn setenv(cmd: *command, key: str, value: str) void = { + let iter = strings::iter(key); + for (let i = 0z; true; i += 1) match (strings::next(&iter)) { + void => break, + r: rune => if (i == 0) assert(r == '_' || ascii::isalpha(r), + "Invalid environment variable") + else assert(r == '_' || ascii::isalnum(r), + "Invalid environment variable"), + }; + + // XXX: This can be a binary search + let fullkey = strings::concat(key, "="); + defer free(fullkey); + for (let i = 0z; i < len(cmd.env); i += 1) { + if (strings::has_prefix(cmd.env[i], fullkey)) { + delete(cmd.env[i]); + break; + }; + }; + append(cmd.env, strings::concat(fullkey, value)); +}; + +fn lookup(name: str) (platform_cmd | void) = { + const path = match (os::getenv("PATH")) { + void => return, + s: str => s, + }; + let tok = strings::tokenize(path, ":"); + for (true) { + const item = match (strings::next_token(&tok)) { + void => break, + s: str => s, + }; + let path = strings::concat(item, "/", name); + defer free(path); + match (open(path)) { + err: errors::opaque => continue, + p: platform_cmd => return p, + }; + }; +}; diff --git a/example/common.ha b/example/common.ha new file mode 100644 index 000000000..1700f6c65 --- /dev/null +++ b/example/common.ha @@ -0,0 +1,32 @@ +// The requested resource is not available. +export type busy = void!; + +// An attempt was made to create a resource which already exists. +export type exists = void!; + +// An function was called with an invalid combination of arguments. +export type invalid = void!; + +// The user does not have permission to use this resource. +export type noaccess = void!; + +// An entry was requested which does not exist. +export type noentry = void; + +// The requested operation caused a numeric overflow condition. +export type overflow = void!; + +// The requested operation is not supported. +export type unsupported = void!; + +// A tagged union of all error types. +export type error = ( + busy | + exists | + invalid | + noaccess | + noentry | + overflow | + unsupported | + opaque +); diff --git a/example/concat.ha b/example/concat.ha new file mode 100644 index 000000000..14e6be57e --- /dev/null +++ b/example/concat.ha @@ -0,0 +1,34 @@ +// Concatenates two or more strings. The caller must free the return value. +export fn concat(strs: str...) str = { + let z = 0z; + for (let i = 0z; i < len(strs); i += 1) { + z += len(strs[i]); + }; + let new: []u8 = alloc([], z); + for (let i = 0z; i < len(strs); i += 1) { + append(new, ...toutf8(strs[i])); + }; + return fromutf8_unsafe(new[..z]); +}; + +@test fn concat() void = { + let s = concat("hello ", "world"); + assert(s == "hello world"); + free(s); + + s = concat("hello", " ", "world"); + assert(s == "hello world"); + free(s); + + s = concat("hello", "", "world"); + assert(s == "helloworld"); + free(s); + + s = concat("", ""); + assert(s == ""); + free(s); + + s = concat(); + assert(s == ""); + free(s); +}; diff --git a/example/contains.ha b/example/contains.ha new file mode 100644 index 000000000..47dc4df57 --- /dev/null +++ b/example/contains.ha @@ -0,0 +1,15 @@ +use bytes; +use encoding::utf8; + +// Returns true if a string contains a rune or a sub-string. +export fn contains(haystack: str, needle: (str | rune)) bool = match (needle) { + s: str => bytes::contains(toutf8(haystack), toutf8(s)), + r: rune => bytes::contains(toutf8(haystack), utf8::encoderune(r)), +}; + +@test fn contains() void = { + assert(contains("hello world", "hello")); + assert(contains("hello world", "world")); + assert(contains("hello world", "")); + assert(!contains("hello world", "foobar")); +}; diff --git a/example/context.ha b/example/context.ha new file mode 100644 index 000000000..9903631e0 --- /dev/null +++ b/example/context.ha @@ -0,0 +1,109 @@ +use dirs; +use fmt; +use fs; +use hare::ast; +use os; +use path; +use strings; +use strio; + +export type context = struct { + // Filesystem to use for the cache and source files. + fs: *fs::fs, + // List of paths to search, generally populated from HAREPATH plus some + // baked-in default. + paths: []str, + // Path to the Hare cache, generally populated from HARECACHE and + // defaulting to $XDG_CACHE_HOME/hare. + cache: str, + // Build tags to apply to this context. + tags: []tag, + // List of -D arguments passed to harec + defines: []str, +}; + +// Initializes a new context with the system default configuration. The tag list +// and list of defines (arguments passed with harec -D) is borrowed from the +// caller. The harepath parameter is not borrowed, but it is ignored if HAREPATH +// is set in the process environment. +export fn context_init(tags: []tag, defs: []str, harepath: str) context = { + let ctx = context { + fs = os::cwd, + tags = tags, + defines = defs, + paths: []str = match (os::getenv("HAREPATH")) { + void => { + let path: []str = alloc([ + strings::dup(harepath), + dirs::data("hare"), + ]); + path; + }, + s: str => { + let sl = strings::split(s, ":"); + let path: []str = alloc([], len(sl) + 1); + for (let i = 0z; i < len(sl); i += 1) { + append(path, strings::dup(sl[i])); + }; + append(path, strings::dup(".")); + free(sl); + path; + }, + }, + cache: str = match (os::getenv("HARECACHE")) { + void => dirs::cache("hare"), + s: str => strings::dup(s), + }, + ... + }; + return ctx; +}; + +// Frees resources associated with this context. +export fn context_finish(ctx: *context) void = { + for (let i = 0z; i < len(ctx.paths); i += 1) { + free(ctx.paths[i]); + }; + free(ctx.paths); + free(ctx.cache); +}; + +// Converts an identifier to a partial path (e.g. foo::bar becomes foo/bar). The +// return value must be freed by the caller. +export fn identpath(name: ast::ident) str = { + let p = path::join(name[0]); + for (let i = 1z; i < len(name); i += 1) { + let q = path::join(p, name[i]); + free(p); + p = q; + }; + return p; +}; + +@test fn identpath() void = { + let ident: ast::ident = ["foo", "bar", "baz"]; + let p = identpath(ident); + defer free(p); + assert(p == "foo/bar/baz"); +}; + +// Joins an ident string with underscores instead of double colons. The return +// value must be freed by the caller. +// +// This is used for module names in environment variables and some file names. +export fn identuscore(ident: ast::ident) str = { + let buf = strio::dynamic(); + for (let i = 0z; i < len(ident); i += 1) { + fmt::fprintf(buf, "{}{}", ident[i], + if (i + 1 < len(ident)) "_" + else "") as size; + }; + return strio::finish(buf); +}; + +@test fn identuscore() void = { + let ident: ast::ident = ["foo", "bar", "baz"]; + let p = identuscore(ident); + defer free(p); + assert(p == "foo_bar_baz"); +}; diff --git a/example/copy.ha b/example/copy.ha new file mode 100644 index 000000000..114a6a446 --- /dev/null +++ b/example/copy.ha @@ -0,0 +1,30 @@ +use errors; + +// Copies data from one stream into another. Note that this function will never +// return if the source stream is infinite. +export fn copy(dest: *stream, src: *stream) (error | size) = { + match (dest.copier) { + null => void, + c: *copier => match (c(dest, src)) { + err: error => match (err) { + errors::unsupported => void, // Use fallback + * => return err, + }, + s: size => return s, + }, + }; + + let w = 0z; + static let buf: [4096]u8 = [0...]; + for (true) { + match (read(src, buf[..])?) { + n: size => for (let i = 0z; i < n) { + let r = write(dest, buf[i..n])?; + w += r; + i += r; + }, + EOF => break, + }; + }; + return w; +}; diff --git a/example/cstring.ha b/example/cstring.ha new file mode 100644 index 000000000..ca8409450 --- /dev/null +++ b/example/cstring.ha @@ -0,0 +1,16 @@ +fn c_strlen(cstr: *const char) size = { + const ptr = cstr: *[*]u8; + let ln = 0z; + for (ptr[ln] != 0; ln += 1) void; + return ln; +}; + +fn from_c_unsafe(cstr: *const char) const str = { + const l = c_strlen(cstr); + const s = struct { + data: *[*]u8 = cstr: *[*]u8, + length: size = l, + capacity: size = l, + }; + return *(&s: *const str); +}; diff --git a/example/cstrings.ha b/example/cstrings.ha new file mode 100644 index 000000000..4ecd04550 --- /dev/null +++ b/example/cstrings.ha @@ -0,0 +1,51 @@ +use encoding::utf8; +use types; +use rt; + +let emptybuf: [1]u8 = [0]; + +// A C-compatible empty string. Empty Hare strings have a null pointer instead +// of containing only '\0', so a special string is needed for this case. +export let c_empty: *const char = &emptybuf: *[*]u8: *const char; + +// Computes the length of a NUL-terminated C string, in octets, in O(n). The +// computed length does not include the NUL terminator. +export fn cstrlen(cstr: *const char) size = { + const ptr = cstr: *[*]u8; + let ln = 0z; + for (ptr[ln] != 0; ln += 1) void; + return ln; +}; + +// Converts a C string to a Hare string in O(n), and does not check if it's +// valid UTF-8. +export fn fromc_unsafe(cstr: *const char) const str = { + const l = cstrlen(cstr); + const s = types::string { + data = cstr: *[*]u8, + length = l, + capacity = l, + }; + return *(&s: *const str); +}; + +// Converts a C string to a Hare string in O(n). If the string is not valid +// UTF-8, abort. +export fn fromc(cstr: *const char) const str = { + let s = fromc_unsafe(cstr); + assert(utf8::valid(s)); + return s; +}; + +// Converts a Hare string to a C string. The result is allocated, the caller +// must free it when they're done. +export fn to_c(s: const str) *char = { + let ptr = rt::malloc(len(s) + 1): nullable *[*]u8; + let ptr = match (ptr) { + null => abort("Out of memory"), + p: *[*]u8 => p, + }; + rt::memcpy(ptr, (&s: *types::string).data, len(s)); + ptr[len(s)] = 0; + return ptr: *char; +}; diff --git a/example/ctype.ha b/example/ctype.ha new file mode 100644 index 000000000..91ca79458 --- /dev/null +++ b/example/ctype.ha @@ -0,0 +1,102 @@ +def U: u8 = 0o1; +def L: u8 = 0o2; +def N: u8 = 0o4; +def S: u8 = 0o10; +def P: u8 = 0o20; +def C: u8 = 0o40; +def B: u8 = 0o100; +def X: u8 = 0o200; + +// LUT of bitfields with character attributes +const cclass: []u8 = [ +// 0 1 2 3 4 5 6 7 + C, C, C, C, C, C, C, C, // 0 + C, S|C, S|C, S|C, S|C, S|C, C, C, // 10 + C, C, C, C, C, C, C, C, // 20 + C, C, C, C, C, C, C, C, // 30 + S|B, P, P, P, P, P, P, P, // 40 + P, P, P, P, P, P, P, P, // 50 + N|X, N|X, N|X, N|X, N|X, N|X, N|X, N|X, // 60 + N|X, N|X, P, P, P, P, P, P, // 70 + P, U|X, U|X, U|X, U|X, U|X, U|X, U, // 100 + U, U, U, U, U, U, U, U, // 110 + U, U, U, U, U, U, U, U, // 120 + U, U, U, P, P, P, P, P, // 130 + P, L|X, L|X, L|X, L|X, L|X, L|X, L, // 140 + L, L, L, L, L, L, L, L, // 150 + L, L, L, L, L, L, L, L, // 160 + L, L, L, P, P, P, P, C, // 170 +]; + +// True if an ASCII character is a letter +export fn isalpha(c: rune) bool = + if (!isascii(c)) false else cclass[c: u32]&(U|L) > 0; + +// True if an ASCII character is uppercase +export fn isupper(c: rune) bool = + if (!isascii(c)) false else cclass[c: u32]&U > 0; + +// True if an ASCII character is lowercase +export fn islower(c: rune) bool = + if (!isascii(c)) false else cclass[c: u32]&L > 0; + +// True if an ASCII character is a digit +export fn isdigit(c: rune) bool = + if (!isascii(c)) false else cclass[c: u32]&N > 0; + +// True if an ASCII character is a hexadecimal digit +export fn isxdigit(c: rune) bool = + if (!isascii(c)) false else cclass[c: u32]&X > 0; + +// True if an ASCII character is a space. +export fn isspace(c: rune) bool = + if (!isascii(c)) false else cclass[c: u32]&S > 0; + +// True if an ASCII character is punctuation. +export fn ispunct(c: rune) bool = + if (!isascii(c)) false else cclass[c: u32]&P > 0; + +// True if an ASCII character is alphanumeric. +export fn isalnum(c: rune) bool = + if (!isascii(c)) false else cclass[c: u32]&(U|L|N) > 0; + +// True if an ASCII character is printable. +export fn isprint(c: rune) bool = + if (!isascii(c)) false else cclass[c: u32]&(P|U|L|N|B) > 0; + +// True if an ASCII character is any printable character other than space. +export fn isgraph(c: rune) bool = + if (!isascii(c)) false else cclass[c: u32]&(P|U|L|N) > 0; + +// True if an ASCII character is a control character. +export fn iscntrl(c: rune) bool = + if (!isascii(c)) false else cclass[c: u32]&C > 0; + +// True if a rune is a valid ASCII character. +export fn isascii(c: rune) bool = c: u32 <= 0o177; + +// Returns the uppercase form of an ASCII character, or the original character +// if it was not a lowercase letter. +export fn toupper(c: rune) rune = { + return if (islower(c)) { + (c: u32 - ('a': u32) + ('A': u32)): rune; + } else c; +}; + +// Returns the lowercase form of an ASCII character, or the original character +// if it was not an uppercase letter. +export fn tolower(c: rune) rune = { + return if (isupper(c)) { + (c: u32 - ('A': u32) + ('a': u32)): rune; + } else c; +}; + +@test fn ctype() void = { + // Just some simple tests + assert(isspace(' ') && !isspace('x') && !isspace('こ')); + assert(isalnum('a') && isalnum('8') && !isalnum('こ')); + assert(!ispunct('\0') && iscntrl('\b')); + assert(isascii('a') && isascii('\0') && isascii('\x7F')); + assert(!isascii('\x80') && !isascii('こ')); + assert(tolower('A') == 'a' && tolower('こ') == 'こ'); +}; diff --git a/example/decl.ha b/example/decl.ha new file mode 100644 index 000000000..047e19590 --- /dev/null +++ b/example/decl.ha @@ -0,0 +1,192 @@ +use io; +use fmt; +use hare::ast; +use hare::lex; +use strio; + +export fn decl(out: *io::stream, d: ast::decl) (size | io::error) = { + let n = 0z; + if (d.exported) { + n += fmt::fprint(out, "export ")?; + }; + match (d.decl) { + g: []ast::decl_global => { + n += fmt::fprint(out, + if (g[0].is_const) "def " else "let ")?; + for (let i = 0z; i < len(g); i += 1) { + if (len(g[i].symbol) != 0) { + n += fmt::fprintf(out, + "@symbol(\"{}\") ", g[i].symbol)?; + }; + n += ident(out, g[i].ident)?; + n += fmt::fprint(out, ": ")?; + n += _type(out, 0, g[i]._type)?; + n += fmt::fprint(out, " = ")?; + n += expr(out, 0, g[i].init)?; + if (i + 1 < len(g)) { + n += fmt::fprint(out, ", ")?; + }; + }; + }, + t: []ast::decl_type => { + n += fmt::fprint(out, "type ")?; + for (let i = 0z; i < len(t); i += 1) { + n += ident(out, t[i].ident)?; + n += fmt::fprint(out, " = ")?; + n += _type(out, 0, t[i]._type)?; + if (i + 1 < len(t)) { + n += fmt::fprint(out, ", ")?; + }; + }; + }, + f: ast::decl_func => { + n += fmt::fprint(out, switch (f.attrs) { + ast::fndecl_attrs::NONE => "", + ast::fndecl_attrs::FINI => "@fini ", + ast::fndecl_attrs::INIT => "@init ", + ast::fndecl_attrs::TEST => "@test ", + })?; + let p = f.prototype._type as ast::func_type; + if (p.attrs & ast::func_attrs::NORETURN != 0) { + n += fmt::fprint(out, "@noreturn ")?; + }; + if (len(f.symbol) != 0) { + n += fmt::fprintf(out, "@symbol(\"{}\") ", + f.symbol)?; + }; + n += fmt::fprint(out, "fn ")?; + n += ident(out, f.ident)?; + n += prototype(out, 0, + f.prototype._type as ast::func_type)?; + match (f.body) { + void => void, + e: ast::expr => { + n += fmt::fprint(out, " = ")?; + n += expr(out, 0, e)?; + }, + }; + }, + }; + n += fmt::fprint(out, ";")?; + return n; +}; + +fn decl_test(d: ast::decl, expected: str) bool = { + let buf = strio::dynamic(); + decl(buf, d) as size; + let s = strio::finish(buf); + defer free(s); + return s == expected; +}; + +@test fn decl() void = { + let loc = lex::location { + path = "", + line = 0, + col = 0, + }; + let type_int = ast::_type { + loc = loc, + flags = 0, + _type = ast::builtin_type::INT, + }; + let type_fn = ast::_type { + loc = loc, + flags = ast::type_flags::CONST, + _type = ast::func_type { + result = &type_int, + attrs = ast::func_attrs::NORETURN, + variadism = ast::variadism::HARE, + params = [ + ast::func_param { + loc = loc, + name = "foo", + _type = &type_int, + }, + ast::func_param { + loc = loc, + name = "bar", + _type = &type_int, + }, + ], + }, + }; + let expr_void = void: ast::constant_expr: ast::expr; + + let d = ast::decl { + loc = loc, + exported = false, + decl = [ + ast::decl_global { + is_const = false, + symbol = "", + ident = ["foo", "bar"], + _type = type_int, + init = expr_void, + }, + ast::decl_global { + is_const = false, + symbol = "foobar", + ident = ["baz"], + _type = type_int, + init = expr_void, + }, + ], + }; + assert(decl_test(d, "let foo::bar: int = void, @symbol(\"foobar\") baz: int = void;")); + + d.exported = true; + d.decl = [ + ast::decl_global { + is_const = true, + ident = ["foo"], + _type = type_int, + init = expr_void, + ... + }, + ]; + assert(decl_test(d, "export def foo: int = void;")); + + d.exported = false; + d.decl = [ + ast::decl_type { + ident = ["foo"], + _type = type_int, + }, + ast::decl_type { + ident = ["bar"], + _type = type_int, + }, + ]; + assert(decl_test(d, "type foo = int, bar = int;")); + + d.decl = ast::decl_func { + symbol = "foo", + ident = ["foo"], + prototype = type_fn, + body = void, + attrs = ast::fndecl_attrs::FINI, + }; + assert(decl_test(d, "@fini @noreturn @symbol(\"foo\") fn foo(foo: int, bar: int...) int;")); + + type_fn._type = ast::func_type { + result = &type_int, + attrs = 0, + variadism = ast::variadism::NONE, + params = [ + ast::func_param { + loc = loc, + name = "", + _type = &type_int, + }, + ], + }; + d.decl = ast::decl_func { + symbol = "", + ident = ["foo"], + prototype = type_fn, + body = expr_void, + attrs = 0, + }; + assert(decl_test(d, "fn foo(_: int) int = void;")); +}; diff --git a/example/decode.ha b/example/decode.ha new file mode 100644 index 000000000..add1f57a2 --- /dev/null +++ b/example/decode.ha @@ -0,0 +1,151 @@ +use types; + +fn toutf8(in: str) []u8 = *(&in: *[]u8); + +// The state for the UTF-8 decoder. +export type decoder = struct { + offs: size, + src: []u8, +}; + +// Initializes a new UTF-8 decoder. +export fn decode(src: (str | []u8)) decoder = match (src) { + s: str => decoder { src = toutf8(s), ... }, + b: []u8 => decoder { src = b, ... }, +}; + +// Indicates that more data is needed, i.e. that a partial UTF-8 sequence was +// encountered. +export type more = void; + +// An error indicating that an invalid UTF-8 sequence was found. +export type invalid = void!; + +// Returns the next rune from a decoder. If the slice ends with a complete UTF-8 +// sequence, void is returned. If an incomplete sequence is encountered, more is +// returned. And if an invalid sequence is encountered, invalid is returned. +export fn next(d: *decoder) (rune | void | more | invalid) = { + assert(d.offs <= len(d.src)); + if (d.offs == len(d.src)) { + return; + }; + + // XXX: It would be faster if we decoded and measured at the same time. + const n = utf8sz(d.src[d.offs]); + if (n == types::SIZE_MAX) { + return invalid; + } else if (d.offs + n > len(d.src)) { + return more; + }; + let bytes = d.src[d.offs..d.offs+n]; + d.offs += n; + + let r = 0u32; + if (bytes[0] < 128) { + // ASCII + return bytes[0]: u32: rune; + }; + + const mask = masks[n - 1]; + r = bytes[0] & mask; + for (let i = 1z; i < len(bytes); i += 1) { + r <<= 6; + r |= bytes[i] & 0x3F; + }; + return r: rune; +}; + +// Returns the previous rune from a decoder. If the slice starts with a complete UTF-8 +// sequence, void is returned. If an incomplete sequence is encountered, more is +// returned. And if an invalid sequence is encountered, invalid is returned. +export fn prev(d: *decoder) (rune | void | more | invalid) = { + if (d.offs == 0) { + return; + }; + + let n = 0z; + let r = 0u32; + + for (let i = 0z; i < d.offs; i += 1) { + if ((d.src[d.offs - i - 1] & 0xC0) == 0x80) { + let tmp: u32 = d.src[d.offs - i - 1] & 0x3F; + r |= tmp << (i * 6): u32; + } else { + n = i + 1; + let tmp: u32 = d.src[d.offs - i - 1] & masks[i]; + r |= tmp << (i * 6): u32; + break; + }; + }; + if (n == 0) { + return more; + }; + d.offs -= n; + if (n != utf8sz(d.src[d.offs])) { + return invalid; + }; + return r: rune; +}; + +@test fn decode() void = { + const input: [_]u8 = [ + 0xE3, 0x81, 0x93, 0xE3, 0x82, 0x93, 0xE3, 0x81, + 0xAB, 0xE3, 0x81, 0xA1, 0xE3, 0x81, 0xAF, 0x00, + ]; + const expected = ['こ', 'ん', 'に', 'ち', 'は', '\0']; + let decoder = decode(input); + for (let i = 0z; i < len(expected); i += 1) { + match (next(&decoder)) { + (invalid | more | void) => abort(), + r: rune => assert(r == expected[i]), + }; + }; + assert(next(&decoder) is void); + assert(decoder.offs == len(decoder.src)); + for (let i = 0z; i < len(expected); i += 1) { + match (prev(&decoder)) { + (invalid | more | void) => abort(), + r: rune => assert(r == expected[len(expected) - i - 1]), + }; + }; + assert(prev(&decoder) is void); + + // TODO: Test more invalid sequences + const invalid: [_]u8 = [0xA0, 0xA1]; + decoder = decode(invalid); + assert(next(&decoder) is invalid); + decoder.offs = 2; + assert(prev(&decoder) is more); + + const incomplete: [_]u8 = [0xE3, 0x81]; + decoder = decode(incomplete); + assert(next(&decoder) is more); + decoder.offs = 2; + assert(prev(&decoder) is invalid); +}; + +// Returns true if a given string or byte slice contains only valid UTF-8 +// sequences. Note that Hare strings (str) are always valid UTF-8 - if this +// returns false for a str type, something funny is going on. +export fn valid(src: (str | []u8)) bool = { + let decoder = decode(src); + for (true) { + match (next(&decoder)) { + void => return true, + invalid => return false, + more => return false, + rune => void, + }; + }; + abort(); +}; + +// Returns the expected length of a UTF-8 character in bytes. +export fn utf8sz(c: u8) size = { + for (let i = 0z; i < len(sizes); i += 1) { + if (c & sizes[i].mask == sizes[i].result) { + return sizes[i].octets; + }; + }; + return types::SIZE_MAX; +}; diff --git a/example/dirfdfs.ha b/example/dirfdfs.ha new file mode 100644 index 000000000..5a1a1ffb6 --- /dev/null +++ b/example/dirfdfs.ha @@ -0,0 +1,399 @@ +use bytes; +use errors; +use encoding::utf8; +use fs; +use io; +use path; +use rt; +use strings; +use time; + +// Controls how symlinks are followed (or not) in a dirfd filesystem. Support +// for this feature varies, you should gate usage of this enum behind a build +// tag. +// +// Note that on Linux, specifying BENEATH or IN_ROOT will also disable magic +// symlinks. +export type resolve_flags = enum { + NORMAL, + + // Does not allow symlink resolution to occur for any symlinks which + // would refer to any anscestor of the fd directory. This disables all + // absolute symlinks, and any call to open or create with an absolute + // path. + BENEATH, + + // Treat the directory fd as the root directory. This affects + // open/create for absolute paths, as well as absolute path resolution + // of symlinks. The effects are similar to chroot. + IN_ROOT, + + // Disables symlink resolution entirely. + NO_SYMLINKS, + + // Disallows traversal of mountpoints during path resolution. This is + // not recommended for general use, as bind mounts are extensively used + // on many systems. + NO_XDEV, +}; + +type os_filesystem = struct { + fs: fs::fs, + dirfd: int, + resolve: resolve_flags, +}; + +fn static_dirfdopen(fd: int, filesystem: *os_filesystem) *fs::fs = { + *filesystem = os_filesystem { + fs = fs::fs { + open = &fs_open, + create = &fs_create, + remove = &fs_remove, + iter = &fs_iter, + stat = &fs_stat, + subdir = &fs_subdir, + mkdir = &fs_mkdir, + rmdir = &fs_rmdir, + chmod = &fs_chmod, + chown = &fs_chown, + resolve = &fs_resolve, + ... + }, + dirfd = fd, + }; + return &filesystem.fs; +}; + +// Opens a file descriptor as an [fs::fs]. This file descriptor must be a +// directory file. The file will be closed when the fs is closed. +// +// If no other flags are provided to [fs::open] and [fs::create] when used with +// a dirfdfs, [fs::flags::NOCTTY] and [fs::flags::CLOEXEC] are used when opening +// the file. If you pass your own flags, it is recommended that you add these +// unless you know that you do not want them. +export fn dirfdopen(fd: int, resolve: resolve_flags...) *fs::fs = { + let ofs = alloc(os_filesystem { ... }); + let fs = static_dirfdopen(fd, ofs); + for (let i = 0z; i < len(resolve); i += 1) { + ofs.resolve |= resolve[i]; + }; + fs.close = &fs_close; + return fs; +}; + +// Clones a dirfd filesystem, optionally adding additional [resolve_flags] +// constraints. +export fn dirfs_clone(fs: *fs::fs, resolve: resolve_flags...) *fs::fs = { + assert(fs.open == &fs_open); + let fs = fs: *os_filesystem; + let new = alloc(*fs); + for (let i = 0z; i < len(resolve); i += 1) { + new.resolve |= resolve[i]; + }; + new.dirfd = rt::dup(new.dirfd) as int; + return &new.fs; +}; + +fn errno_to_fs(err: rt::errno) fs::error = switch (err) { + rt::ENOENT => errors::noentry, + rt::EEXIST => errors::exists, + rt::EACCES => errors::noaccess, + rt::EBUSY => errors::busy, + rt::ENOTDIR => fs::wrongtype, + rt::EOPNOTSUPP, rt::ENOSYS => errors::unsupported, + * => errors::errno(err), +}; + +fn _fs_open( + fs: *fs::fs, + path: str, + mode: io::mode, + oh: *rt::open_how, +) (*io::stream | fs::error) = { + let fs = fs: *os_filesystem; + + oh.resolve = 0u64; + if (fs.resolve & resolve_flags::BENEATH == resolve_flags::BENEATH) { + oh.resolve |= rt::RESOLVE_BENEATH | rt::RESOLVE_NO_MAGICLINKS; + }; + if (fs.resolve & resolve_flags::IN_ROOT == resolve_flags::IN_ROOT) { + oh.resolve |= rt::RESOLVE_IN_ROOT | rt::RESOLVE_NO_MAGICLINKS; + }; + if (fs.resolve & resolve_flags::NO_SYMLINKS == resolve_flags::NO_SYMLINKS) { + oh.resolve |= rt::RESOLVE_NO_SYMLINKS; + }; + if (fs.resolve & resolve_flags::NO_XDEV == resolve_flags::NO_XDEV) { + oh.resolve |= rt::RESOLVE_NO_XDEV; + }; + + let fd = match (rt::openat2(fs.dirfd, path, oh, size(rt::open_how))) { + err: rt::errno => return errno_to_fs(err), + fd: int => fd, + }; + + return fdopen(fd, path, mode); +}; + +fn fs_open( + fs: *fs::fs, + path: str, + flags: fs::flags... +) (*io::stream | fs::error) = { + let oflags = 0; + let iomode = io::mode::NONE; + if (len(flags) == 0z) { + oflags |= (fs::flags::NOCTTY + | fs::flags::CLOEXEC + | fs::flags::RDONLY): int; + }; + for (let i = 0z; i < len(flags); i += 1z) { + oflags |= flags[i]: int; + }; + + if ((oflags: fs::flags & fs::flags::DIRECTORY) == fs::flags::DIRECTORY) { + // This is arch-specific + oflags &= ~fs::flags::DIRECTORY: int; + oflags |= rt::O_DIRECTORY: int; + }; + + if ((oflags: fs::flags & fs::flags::RDWR) == fs::flags::RDWR) { + iomode = io::mode::RDWR; + } else if ((oflags: fs::flags & fs::flags::WRONLY) == fs::flags::WRONLY) { + iomode = io::mode::WRITE; + } else if ((oflags: fs::flags & fs::flags::PATH) != fs::flags::PATH) { + iomode = io::mode::READ; + }; + + let oh = rt::open_how { + flags = oflags: u64, + ... + }; + return _fs_open(fs, path, iomode, &oh); +}; + +fn fs_create( + fs: *fs::fs, + path: str, + mode: fs::mode, + flags: fs::flags... +) (*io::stream | fs::error) = { + let oflags = 0; + let iomode = io::mode::NONE; + if (len(flags) == 0z) { + oflags |= (fs::flags::NOCTTY + | fs::flags::CLOEXEC + | fs::flags::WRONLY): int; + }; + for (let i = 0z; i < len(flags); i += 1z) { + oflags |= flags[i]: int; + }; + oflags |= fs::flags::CREATE: int; + + if ((oflags: fs::flags & fs::flags::RDWR) == fs::flags::RDWR) { + iomode = io::mode::RDWR; + } else if ((oflags: fs::flags & fs::flags::WRONLY) == fs::flags::WRONLY) { + iomode = io::mode::WRITE; + } else if ((oflags: fs::flags & fs::flags::PATH) != fs::flags::PATH) { + iomode = io::mode::READ; + }; + + let oh = rt::open_how { + flags = oflags: u64, + mode = mode: u64, + ... + }; + return _fs_open(fs, path, iomode, &oh); +}; + +fn fs_remove(fs: *fs::fs, path: str) (void | fs::error) = { + let fs = fs: *os_filesystem; + match (rt::unlinkat(fs.dirfd, path, 0)) { + err: rt::errno => return errno_to_fs(err), + void => void, + }; +}; + +fn fs_stat(fs: *fs::fs, path: str) (fs::filestat | fs::error) = { + let fs = fs: *os_filesystem; + let st = rt::st { ... }; + match (rt::fstatat(fs.dirfd, path, &st, rt::AT_SYMLINK_NOFOLLOW)) { + err: rt::errno => return errno_to_fs(err), + void => void, + }; + return fs::filestat { + mask = fs::stat_mask::UID + | fs::stat_mask::GID + | fs::stat_mask::SIZE + | fs::stat_mask::INODE + | fs::stat_mask::ATIME + | fs::stat_mask::MTIME + | fs::stat_mask::CTIME, + mode = st.mode: fs::mode, + uid = st.uid, + uid = st.gid, + sz = st.sz, + inode = st.ino, + atime = time::instant { + sec = st.atime.tv_sec, + nsec = st.atime.tv_nsec, + }, + mtime = time::instant { + sec = st.mtime.tv_sec, + nsec = st.mtime.tv_nsec, + }, + ctime = time::instant { + sec = st.ctime.tv_sec, + nsec = st.ctime.tv_nsec, + }, + }; +}; + +fn fs_subdir(fs: *fs::fs, path: str) (*fs::fs | fs::error) = { + let fs = fs: *os_filesystem; + let oh = rt::open_how { + flags = (rt::O_RDONLY | rt::O_CLOEXEC | rt::O_DIRECTORY): u64, + ... + }; + + let fd: int = match (rt::openat2(fs.dirfd, path, + &oh, size(rt::open_how))) { + err: rt::errno => return errno_to_fs(err), + n: int => n, + }; + + return dirfdopen(fd); +}; + +fn fs_rmdir(fs: *fs::fs, path: str) (void | fs::error) = { + let fs = fs: *os_filesystem; + match (rt::unlinkat(fs.dirfd, path, rt::AT_REMOVEDIR)) { + err: rt::errno => return errno_to_fs(err), + void => void, + }; +}; + +fn fs_mkdir(fs: *fs::fs, path: str) (void | fs::error) = { + let fs = fs: *os_filesystem; + return match (rt::mkdirat(fs.dirfd, path, 0o755)) { + err: rt::errno => errno_to_fs(err), + void => void, + }; +}; + +fn fs_chmod(fs: *fs::fs, path: str, mode: fs::mode) (void | fs::error) = { + let fs = fs: *os_filesystem; + return match (rt::fchmodat(fs.dirfd, path, mode: uint)) { + err: rt::errno => return errno_to_fs(err), + void => void, + }; +}; + +fn fs_chown(fs: *fs::fs, path: str, uid: uint, gid: uint) (void | fs::error) = { + let fs = fs: *os_filesystem; + return match (rt::fchownat(fs.dirfd, path, uid, gid)) { + err: rt::errno => return errno_to_fs(err), + void => void, + }; +}; + +fn resolve_part(parts: *[]str, part: str) void = { + if (part == ".") { + // no-op + void; + } else if (part == "..") { + // XXX: We should not have to dereference this + if (len(*parts) != 0) { + delete(parts[len(*parts) - 1]); + }; + } else { + append(*parts, part); + }; +}; + +fn fs_resolve(fs: *fs::fs, path: str) str = { + let parts: []str = []; + if (!path::abs(path)) { + let iter = path::iter(getcwd()); + for (true) match (path::next(&iter)) { + void => break, + p: str => resolve_part(&parts, p), + }; + }; + let iter = path::iter(path); + for (true) match (path::next(&iter)) { + void => break, + p: str => resolve_part(&parts, p), + }; + return path::join(parts...); +}; + +fn fs_close(fs: *fs::fs) void = { + let fs = fs: *os_filesystem; + rt::close(fs.dirfd); +}; + +def BUFSIZ: size = 2048; + +// Based on musl's readdir +type os_iterator = struct { + iter: fs::iterator, + fd: int, + buf_pos: size, + buf_end: size, + buf: [BUFSIZ]u8, +}; + +fn fs_iter(fs: *fs::fs, path: str) (*fs::iterator | fs::error) = { + let fs = fs: *os_filesystem; + let oh = rt::open_how { + flags = (rt::O_RDONLY | rt::O_CLOEXEC | rt::O_DIRECTORY): u64, + ... + }; + let fd: int = match (rt::openat2(fs.dirfd, path, + &oh, size(rt::open_how))) { + err: rt::errno => return errno_to_fs(err), + n: int => n, + }; + + let iter = alloc(os_iterator { + iter = fs::iterator { + next = &iter_next, + }, + fd = fd, + ... + }); + return &iter.iter; +}; + +fn iter_next(iter: *fs::iterator) (fs::dirent | void) = { + let iter = iter: *os_iterator; + if (iter.buf_pos >= iter.buf_end) { + let n = rt::getdents64(iter.fd, &iter.buf, BUFSIZ) as size; + if (n == 0) { + rt::close(iter.fd); + free(iter); + return; + }; + iter.buf_end = n; + iter.buf_pos = 0; + }; + let de = &iter.buf[iter.buf_pos]: *rt::dirent64; + iter.buf_pos += de.d_reclen; + let name = strings::fromc(&de.d_name: *const char); + + let ftype: fs::mode = switch (de.d_type) { + rt::DT_UNKNOWN => fs::mode::UNKNOWN, + rt::DT_FIFO => fs::mode::FIFO, + rt::DT_CHR => fs::mode::CHR, + rt::DT_DIR => fs::mode::DIR, + rt::DT_BLK => fs::mode::BLK, + rt::DT_REG => fs::mode::REG, + rt::DT_LNK => fs::mode::LINK, + rt::DT_SOCK => fs::mode::SOCK, + * => fs::mode::UNKNOWN, + }; + return fs::dirent { + name = name, + ftype = ftype, + }; +}; diff --git a/example/docs.ha b/example/docs.ha new file mode 100644 index 000000000..afe908f9d --- /dev/null +++ b/example/docs.ha @@ -0,0 +1,6 @@ +// The slice module provides some utility functions for working with slices. In +// order to work with a user-supplied slice of an arbitrary type, the slice must +// be cast to []void and the size of the member type passed alongside it. These +// functions provide support code for common operations such as indexing and +// appending, which are normally provided by language features, but which are +// not available for []void slices. diff --git a/example/dup.ha b/example/dup.ha new file mode 100644 index 000000000..71e977aa3 --- /dev/null +++ b/example/dup.ha @@ -0,0 +1,41 @@ +use bytes; +use rt; +use types; + +// Duplicates a string. Aborts on allocation failure. +export fn dup(s: const str) str = { + const in = &s: *types::string; + const id = match (in.data) { + null => return "", // Empty string + b: *[*]u8 => b, + }; + let buf: *[*]u8 = match (rt::malloc(in.length + 1)) { + null => abort("Out of memory"), + v: *void => v, + }; + bytes::copy(buf[..in.length + 1z], id[..in.length + 1]); + let out = types::string { + data = buf, + length = in.length, + capacity = in.length, + }; + return *(&out: *str); +}; + +// Duplicates every string of a slice in place, returning the same slice with +// new strings. +export fn dupall(s: []str) void = { + for (let i = 0z; i < len(s); i += 1) { + s[i] = strings::dup(s[i]); + }; +}; + +@test fn dup() void = { + let s = dup(""); + assert(s == ""); + free(s); + + s = dup("hello"); + assert(s == "hello"); + free(s); +}; diff --git a/example/dynamic.ha b/example/dynamic.ha new file mode 100644 index 000000000..a4fbe6704 --- /dev/null +++ b/example/dynamic.ha @@ -0,0 +1,192 @@ +use bytes; +use errors; +use io; + +type dynamic_stream = struct { + stream: io::stream, + buf: []u8, + pos: size, +}; + +// Creates an [io::stream] which dynamically allocates a buffer to store writes +// into. Subsequent reads will consume the buffered data. Upon failure to +// allocate sufficient memory to store writes, the program aborts. +// +// Calling [io::close] on this stream will free the buffer. Call [bufio::finish] +// instead to free up resources associated with the stream, but transfer +// ownership of the buffer to the caller. +export fn dynamic(mode: io::mode) *io::stream = dynamic_from([], mode); + +// Like [dynamic], but takes an existing slice as input. Writes are appended to +// it and reads consume bytes from the initial buffer, plus any additional +// writes. Like [dynamic], calling [io::close] will free the buffer, and +// [bufio::finish] can be used to return ownership of the buffer to the caller. +export fn dynamic_from(in: []u8, mode: io::mode) *io::stream = { + let s = alloc(dynamic_stream { + stream = io::stream { + closer = &dynamic_close, + seeker = &dynamic_seek, + ... + }, + buf = in, + pos = 0, + }): *io::stream; + if (mode & io::mode::READ == io::mode::READ) { + s.reader = &dynamic_read; + }; + if (mode & io::mode::WRITE == io::mode::WRITE) { + s.writer = &dynamic_write; + }; + return s; +}; + +fn dynamic_write(s: *io::stream, buf: const []u8) (size | io::error) = { + let s = s: *dynamic_stream; + if (s.pos == len(s.buf)) { + append(s.buf, ...buf); + } else { + // TODO: update this after we add insert + let new: []u8 = alloc([], len(s.buf) + len(buf)); + append(new, ...s.buf[..s.pos]); + append(new, ...buf[..]); + append(new, ...s.buf[s.pos..]); + free(s.buf); + s.buf = new; + }; + + s.pos += len(buf); + return len(buf); +}; + +fn dynamic_read(s: *io::stream, buf: []u8) (size | io::EOF | io::error) = { + let s = s: *dynamic_stream; + if (len(s.buf) == s.pos && len(buf) != 0) { + return io::EOF; + }; + const n = if (len(s.buf) - s.pos < len(buf)) { + len(s.buf) - s.pos; + } else { + len(buf); + }; + buf[..n] = s.buf[s.pos..s.pos + n]; + s.pos += n; + return n; +}; + +fn dynamic_seek( + s: *io::stream, + off: io::off, + w: io::whence +) (io::off | io::error) = { + let stream = s: *dynamic_stream; + switch (w) { + io::whence::SET => { + if (len(stream.buf) < off: size) { + abort("invalid offset"); + }; + stream.pos = off: size; + }, + io::whence::CUR => { + if (stream.pos + off: size > len(stream.buf)) { + abort("invalid offset"); + }; + stream.pos += off: size; + }, + io::whence::END => { + if (len(stream.buf) - (-off): size < len(stream.buf)) { + abort("invalid offset"); + }; + stream.pos = len(stream.buf) - (-off): size; + }, + }; + return stream.pos: io::off; +}; + +fn dynamic_close(s: *io::stream) void = { + const s = s: *dynamic_stream; + free(s.buf); + free(s); +}; + +// Closes the stream without freeing the buffer, instead transferring ownership +// of it to the caller. +export fn finish(s: *io::stream) []u8 = { + if (s.closer != &dynamic_close) { + abort("bufio::finish called on non-bufio stream"); + }; + let s = s: *dynamic_stream; + let buf = s.buf; + free(s); + return buf; +}; + +// Returns the current buffer. +export fn buffer(s: *io::stream) []u8 = { + if (s.closer != &dynamic_close) { + abort("bufio::buffer called on non-bufio stream"); + }; + let s = s: *dynamic_stream; + return s.buf; +}; + +// Resets the buffer's length to zero, but keeps the allocated memory around for +// future writes. +export fn reset(s: *io::stream) void = { + if (s.closer != &dynamic_close) { + abort("bufio::reset called on non-bufio stream"); + }; + const s = s: *dynamic_stream; + s.pos = 0; + s.buf = s.buf[..0]; +}; + +// Truncates the buffer, freeing memory associated with it and setting its +// length to zero. +export fn truncate(s: *io::stream) (void | errors::unsupported) = { + if (s.closer != &dynamic_close) { + return errors::unsupported; + }; + let s = s: *dynamic_stream; + s.pos = 0; + delete(s.buf[..]); +}; + +@test fn dynamic() void = { + // TODO: slice/array equality + let s = dynamic(io::mode::RDWR); + assert(io::write(s, [1, 2, 3]) as size == 3); + assert(bytes::equal(buffer(s), [1, 2, 3])); + assert(io::write(s, [4, 5]) as size == 2); + assert(bytes::equal(buffer(s), [1, 2, 3, 4, 5])); + let buf: [2]u8 = [0...]; + assert(io::seek(s, 0, io::whence::SET) as io::off == 0: io::off); + assert(io::read(s, buf[..]) as size == 2 && bytes::equal(buf, [1, 2])); + assert(io::read(s, buf[..]) as size == 2 && bytes::equal(buf, [3, 4])); + assert(io::read(s, buf[..]) as size == 1 && buf[0] == 5); + assert(io::read(s, buf[..]) is io::EOF); + assert(io::write(s, [6, 7, 8]) as size == 3); + assert(bytes::equal(buffer(s), [1, 2, 3, 4, 5, 6, 7, 8])); + reset(s); + assert(len(buffer(s)) == 0); + assert(io::write(s, [1, 2, 3]) as size == 3); + assert(truncate(s) is void); + assert(len(buffer(s)) == 0); + + let sl: []u8 = alloc([1, 2, 3]); + let s = dynamic_from(sl, io::mode::WRITE); + assert(io::write(s, [0, 0]) as size == 2); + assert(io::seek(s, 0, io::whence::END) as io::off == 5: io::off); + assert(io::write(s, [4, 5, 6]) as size == 3); + assert(bytes::equal(buffer(s), [0, 0, 1, 2, 3, 4, 5, 6])); + // TODO: this should check for errors::unsupported (harec bug prevents that) + assert(io::read(s, buf[..]) is io::error); + io::close(s); + + sl = alloc([1, 2]); + let s = dynamic_from(sl, io::mode::READ); + assert(io::read(s, buf[..1]) as size == 1 && buf[0] == 1); + assert(io::seek(s, 1, io::whence::CUR) as io::off == 2: io::off); + assert(io::read(s, buf[..]) is io::EOF); + // TODO: this should check for errors::unsupported (harec bug prevents that) + assert(io::write(s, [1, 2]) is io::error); +}; diff --git a/example/encode.ha b/example/encode.ha new file mode 100644 index 000000000..42046b06e --- /dev/null +++ b/example/encode.ha @@ -0,0 +1,41 @@ +// Encodes a rune as UTF-8 and returns the result as a slice. The result is +// statically allocated; duplicate it if you aren't using it right away. +export fn encoderune(r: rune) []u8 = { + let ch = r: u32, n = 0z, first = 0u8; + if (ch < 0x80) { + first = 0; + n = 1; + } else if (ch < 0x800) { + first = 0xC0; + n = 2; + } else if (ch < 0x10000) { + first = 0xE0; + n = 3; + } else { + first = 0xF0; + n = 4; + }; + + static let buf: [6]u8 = [0...]; + for (let i = n - 1; i > 0; i -= 1) { + buf[i] = ch: u8 & 0x3F | 0x80; + ch >>= 6; + }; + buf[0] = ch: u8 | first; + return buf[..n]; +}; + +@test fn encode() void = { + const expected: [_][]u8 = [ + [0], + [0x25], + [0xE3, 0x81, 0x93], + ]; + const inputs = ['\0', '%', 'こ']; + for (let i = 0z; i < len(inputs); i += 1) { + const out = encoderune(inputs[i]); + for (let j = 0z; j < len(expected[i]); j += 1) { + assert(out[j] == expected[i][j]); + }; + }; +}; diff --git a/example/endian.ha b/example/endian.ha new file mode 100644 index 000000000..7727eb015 --- /dev/null +++ b/example/endian.ha @@ -0,0 +1,29 @@ +// The set of functions used for endian-aware encoding. +export type endian = struct { + getu16: *fn(buf: []u8) u16, + putu16: *fn(buf: []u8, in: u16) void, + getu32: *fn(buf: []u8) u32, + putu32: *fn(buf: []u8, in: u32) void, + getu64: *fn(buf: []u8) u64, + putu64: *fn(buf: []u8, in: u64) void, +}; + +// Big endian; MSB first. +export const big: endian = endian { + getu16 = &begetu16, + putu16 = &beputu16, + getu32 = &begetu32, + putu32 = &beputu32, + getu64 = &begetu64, + putu64 = &beputu64, +}; + +// Little endian; LSB first. +export const little: endian = endian { + getu16 = &legetu16, + putu16 = &leputu16, + getu32 = &legetu32, + putu32 = &leputu32, + getu64 = &legetu64, + putu64 = &leputu64, +}; diff --git a/example/ensure.ha b/example/ensure.ha new file mode 100644 index 000000000..470a10d1f --- /dev/null +++ b/example/ensure.ha @@ -0,0 +1,36 @@ +export type slice = struct { + data: nullable *void, + length: size, + capacity: size, +}; + +export fn ensure(s: *slice, membsz: size) void = { + let cap = s.capacity; + if (cap >= s.length) { + return; + }; + for (cap < s.length) { + assert(cap >= s.capacity, "slice out of memory (overflow)"); + if (cap == 0) { + cap = s.length; + } else { + cap *= 2; + }; + }; + s.capacity = cap; + const data = realloc(s.data, s.capacity * membsz); + assert(data != null || s.capacity * membsz == 0); + s.data = data; +}; + +export fn unensure(s: *slice, membsz: size) void = { + let cap = s.capacity; + for (cap > s.length) { + cap /= 2; + }; + cap *= 2; + s.capacity = cap; + const data = realloc(s.data, s.capacity * membsz); + assert(data != null || s.capacity * membsz == 0); + s.data = data; +}; diff --git a/example/env.ha b/example/env.ha new file mode 100644 index 000000000..626711ea7 --- /dev/null +++ b/example/env.ha @@ -0,0 +1,4 @@ +use format::elf; + +// System V auxillary vector for the current process +export let auxv: *[*]format::elf::auxv64 = null: *[*]format::elf::auxv64; diff --git a/example/environ.ha b/example/environ.ha new file mode 100644 index 000000000..849d3dc04 --- /dev/null +++ b/example/environ.ha @@ -0,0 +1,112 @@ +use bytes; +use rt; +use strings; +use types; + +// The command line arguments provided to the program. By convention, the first +// member is usually the name of the program. +export let args: []str = []; + +// Statically allocate arg strings if there are few enough arguments, saves a +// syscall if we don't need it. +let args_static: [32]str = [""...]; + +@init fn init_environ() void = { + if (rt::argc < len(args_static)) { + args = args_static[..rt::argc]; + for (let i = 0z; i < rt::argc; i += 1) { + args[i] = strings::fromc(rt::argv[i]); + }; + } else { + args = alloc([], rt::argc); + for (let i = 0z; i < rt::argc; i += 1) { + append(args, strings::fromc(rt::argv[i])); + }; + }; + +}; + +@fini fn fini_environ() void = { + if (rt::argc >= len(args_static)) { + free(args); + }; +}; + +// Looks up an environment variable and returns its value, or void if unset. +export fn getenv(name: const str) (str | void) = { + const name_b = strings::toutf8(name); + for (let i = 0z; rt::envp[i] != null; i += 1) { + const item = rt::envp[i]: *[*]u8; + const eq: size = match (bytes::index(item[..], '=': u32: u8)) { + void => abort("Environment violates System-V invariants"), + i: size => i, + }; + if (bytes::equal(name_b, item[..eq])) { + const ln = strings::cstrlen(item: *const char); + return strings::fromutf8(item[eq+1..ln]); + }; + }; +}; + +// Looks up an environment variable and returns its value, or a default value if +// unset. +export fn tryenv(name: const str, default: str) str = match (getenv(name)) { + s: str => s, + void => default, +}; + +let envp: []str = []; + +// Returns a slice of the environment strings in the form KEY=VALUE. +export fn getenvs() []str = { + if (len(envp) != 0) { + return envp; + }; + for (let i = 0z; rt::envp[i] != null; i += 1) { + append(envp, strings::fromc(rt::envp[i]: *const char)); + }; + return envp; +}; + +let uts: rt::utsname = rt::utsname { ... }; +let uts_valid: bool = false; + +// Returns the host kernel name +export fn sysname() const str = { + if (!uts_valid) { + rt::uname(&uts) as void; + }; + return strings::fromc(&uts.sysname: *const char); +}; + +// Returns the host system hostname +export fn hostname() const str = { + if (!uts_valid) { + rt::uname(&uts) as void; + }; + return strings::fromc(&uts.nodename: *const char); +}; + +// Returns the host kernel version +export fn release() const str = { + if (!uts_valid) { + rt::uname(&uts) as void; + }; + return strings::fromc(&uts.release: *const char); +}; + +// Returns the host operating system version +export fn version() const str = { + if (!uts_valid) { + rt::uname(&uts) as void; + }; + return strings::fromc(&uts.version: *const char); +}; + +// Returns the host CPU architecture +export fn machine() const str = { + if (!uts_valid) { + rt::uname(&uts) as void; + }; + return strings::fromc(&uts.machine: *const char); +}; diff --git a/example/equal.ha b/example/equal.ha new file mode 100644 index 000000000..3a9e57355 --- /dev/null +++ b/example/equal.ha @@ -0,0 +1,24 @@ +// Returns true if the two byte sequences are identical. +export fn equal(a: []u8, b: []u8) bool = { + if (len(a) != len(b)) { + return false; + }; + for (let i = 0z; i < len(a); i += 1) { + if (a[i] != b[i]) { + return false; + }; + }; + return true; +}; + +@test fn equal() void = { + let a: []u8 = [1, 2, 3]; + let b: []u8 = [1, 2, 3]; + let c: []u8 = [1, 4, 5]; + let d: []u8 = [1, 2, 3, 4]; + let e: []u8 = [1, 2]; + assert(equal(a, b)); + assert(!equal(a, c)); + assert(!equal(a, d)); + assert(!equal(a, e)); +}; diff --git a/example/errno.ha b/example/errno.ha new file mode 100644 index 000000000..5cc4ffab8 --- /dev/null +++ b/example/errno.ha @@ -0,0 +1,423 @@ +// Represents an error returned from the Linux kernel. +export type errno = int!; + +// Given an integer error number, wraps it in an error type. +export fn wrap_errno(err: int) errno = err: errno; + +// Checks the return value from a Linux syscall and, if found to be in error, +// returns the appropriate error. Otherwise, returns the original value. +fn wrap_return(r: u64) (errno | u64) = { + if (r > -4096u64) { + return (-(r: i64)): int: errno; + }; + return r; +}; + +// Obtains a human-friendly reading of an [errno] (e.g. "Operation not +// permitted"). +export fn strerror(err: errno) str = { + return switch (err: int) { + EPERM => "Operation not permitted", + ENOENT => "No such file or directory", + ESRCH => "No such process", + EINTR => "Interrupted system call", + EIO => "Input/output error", + ENXIO => "No such device or address", + E2BIG => "Argument list too long", + ENOEXEC => "Exec format error", + EBADF => "Bad file descriptor", + ECHILD => "No child processes", + EAGAIN => "Resource temporarily unavailable", + ENOMEM => "Cannot allocate memory", + EACCES => "Permission denied", + EFAULT => "Bad address", + ENOTBLK => "Block device required", + EBUSY => "Device or resource busy", + EEXIST => "File exists", + EXDEV => "Invalid cross-device link", + ENODEV => "No such device", + ENOTDIR => "Not a directory", + EISDIR => "Is a directory", + EINVAL => "Invalid argument", + ENFILE => "Too many open files in system", + EMFILE => "Too many open files", + ENOTTY => "Inappropriate ioctl for device", + ETXTBSY => "Text file busy", + EFBIG => "File too large", + ENOSPC => "No space left on device", + ESPIPE => "Illegal seek", + EROFS => "Read-only file system", + EMLINK => "Too many links", + EPIPE => "Broken pipe", + EDOM => "Numerical argument out of domain", + ERANGE => "Numerical result out of range", + EDEADLK => "Resource deadlock avoided", + ENAMETOOLONG => "File name too long", + ENOLCK => "No locks available", + ENOSYS => "Function not implemented", + ENOTEMPTY => "Directory not empty", + ELOOP => "Too many levels of symbolic links", + ENOMSG => "No message of desired type", + EIDRM => "Identifier removed", + ECHRNG => "Channel number out of range", + EL2NSYNC => "Level 2 not synchronized", + EL3HLT => "Level 3 halted", + EL3RST => "Level 3 reset", + ELNRNG => "Link number out of range", + EUNATCH => "Protocol driver not attached", + ENOCSI => "No CSI structure available", + EL2HLT => "Level 2 halted", + EBADE => "Invalid exchange", + EBADR => "Invalid request descriptor", + EXFULL => "Exchange full", + ENOANO => "No anode", + EBADRQC => "Invalid request code", + EBADSLT => "Invalid slot", + EBFONT => "Bad font file format", + ENOSTR => "Device not a stream", + ENODATA => "No data available", + ETIME => "Timer expired", + ENOSR => "Out of streams resources", + ENONET => "Machine is not on the network", + ENOPKG => "Package not installed", + EREMOTE => "Object is remote", + ENOLINK => "Link has been severed", + EADV => "Advertise error", + ESRMNT => "Srmount error", + ECOMM => "Communication error on send", + EPROTO => "Protocol error", + EMULTIHOP => "Multihop attempted", + EDOTDOT => "RFS specific error", + EBADMSG => "Bad message", + EOVERFLOW => "Value too large for defined data type", + ENOTUNIQ => "Name not unique on network", + EBADFD => "File descriptor in bad state", + EREMCHG => "Remote address changed", + ELIBACC => "Can not access a needed shared library", + ELIBBAD => "Accessing a corrupted shared library", + ELIBSCN => ".lib section in a.out corrupted", + ELIBMAX => "Attempting to link in too many shared libraries", + ELIBEXEC => "Cannot exec a shared library directly", + EILSEQ => "Invalid or incomplete multibyte or wide character", + ERESTART => "Interrupted system call should be restarted", + ESTRPIPE => "Streams pipe error", + EUSERS => "Too many users", + ENOTSOCK => "Socket operation on non-socket", + EDESTADDRREQ => "Destination address required", + EMSGSIZE => "Message too long", + EPROTOTYPE => "Protocol wrong type for socket", + ENOPROTOOPT => "Protocol not available", + EPROTONOSUPPORT => "Protocol not supported", + ESOCKTNOSUPPORT => "Socket type not supported", + EOPNOTSUPP => "Operation not supported", + EPFNOSUPPORT => "Protocol family not supported", + EAFNOSUPPORT => "Address family not supported by protocol", + EADDRINUSE => "Address already in use", + EADDRNOTAVAIL => "Cannot assign requested address", + ENETDOWN => "Network is down", + ENETUNREACH => "Network is unreachable", + ENETRESET => "Network dropped connection on reset", + ECONNABORTED => "Software caused connection abort", + ECONNRESET => "Connection reset by peer", + ENOBUFS => "No buffer space available", + EISCONN => "Transport endpoint is already connected", + ENOTCONN => "Transport endpoint is not connected", + ESHUTDOWN => "Cannot send after transport endpoint shutdown", + ETOOMANYREFS => "Too many references: cannot splice", + ETIMEDOUT => "Connection timed out", + ECONNREFUSED => "Connection refused", + EHOSTDOWN => "Host is down", + EHOSTUNREACH => "No route to host", + EALREADY => "Operation already in progress", + EINPROGRESS => "Operation now in progress", + ESTALE => "Stale file handle", + EUCLEAN => "Structure needs cleaning", + ENOTNAM => "Not a XENIX named type file", + ENAVAIL => "No XENIX semaphores available", + EISNAM => "Is a named type file", + EREMOTEIO => "Remote I/O error", + EDQUOT => "Disk quota exceeded", + ENOMEDIUM => "No medium found", + EMEDIUMTYPE => "Wrong medium type", + ECANCELED => "Operation canceled", + ENOKEY => "Required key not available", + EKEYEXPIRED => "Key has expired", + EKEYREVOKED => "Key has been revoked", + EKEYREJECTED => "Key was rejected by service", + EOWNERDEAD => "Owner died", + ENOTRECOVERABLE => "State not recoverable", + ERFKILL => "Operation not possible due to RF-kill", + EHWPOISON => "Memory page has hardware error", + * => "Unknown Linux error code", // TODO: snprintf to add errno? + }; +}; + +// Gets the programmer-friendly name for an [errno] (e.g. EPERM). +export fn errname(err: errno) str = { + return switch (err: int) { + EPERM => "EPERM", + ENOENT => "ENOENT", + ESRCH => "ESRCH", + EINTR => "EINTR", + EIO => "EIO", + ENXIO => "ENXIO", + E2BIG => "E2BIG", + ENOEXEC => "ENOEXEC", + EBADF => "EBADF", + ECHILD => "ECHILD", + EAGAIN => "EAGAIN", + ENOMEM => "ENOMEM", + EACCES => "EACCES", + EFAULT => "EFAULT", + ENOTBLK => "ENOTBLK", + EBUSY => "EBUSY", + EEXIST => "EEXIST", + EXDEV => "EXDEV", + ENODEV => "ENODEV", + ENOTDIR => "ENOTDIR", + EISDIR => "EISDIR", + EINVAL => "EINVAL", + ENFILE => "ENFILE", + EMFILE => "EMFILE", + ENOTTY => "ENOTTY", + ETXTBSY => "ETXTBSY", + EFBIG => "EFBIG", + ENOSPC => "ENOSPC", + ESPIPE => "ESPIPE", + EROFS => "EROFS", + EMLINK => "EMLINK", + EPIPE => "EPIPE", + EDOM => "EDOM", + ERANGE => "ERANGE", + EDEADLK => "EDEADLK", + ENAMETOOLONG => "ENAMETOOLONG", + ENOLCK => "ENOLCK", + ENOSYS => "ENOSYS", + ENOTEMPTY => "ENOTEMPTY", + ELOOP => "ELOOP", + ENOMSG => "ENOMSG", + EIDRM => "EIDRM", + ECHRNG => "ECHRNG", + EL2NSYNC => "EL2NSYNC", + EL3HLT => "EL3HLT", + EL3RST => "EL3RST", + ELNRNG => "ELNRNG", + EUNATCH => "EUNATCH", + ENOCSI => "ENOCSI", + EL2HLT => "EL2HLT", + EBADE => "EBADE", + EBADR => "EBADR", + EXFULL => "EXFULL", + ENOANO => "ENOANO", + EBADRQC => "EBADRQC", + EBADSLT => "EBADSLT", + EBFONT => "EBFONT", + ENOSTR => "ENOSTR", + ENODATA => "ENODATA", + ETIME => "ETIME", + ENOSR => "ENOSR", + ENONET => "ENONET", + ENOPKG => "ENOPKG", + EREMOTE => "EREMOTE", + ENOLINK => "ENOLINK", + EADV => "EADV", + ESRMNT => "ESRMNT", + ECOMM => "ECOMM", + EPROTO => "EPROTO", + EMULTIHOP => "EMULTIHOP", + EDOTDOT => "EDOTDOT", + EBADMSG => "EBADMSG", + EOVERFLOW => "EOVERFLOW", + ENOTUNIQ => "ENOTUNIQ", + EBADFD => "EBADFD", + EREMCHG => "EREMCHG", + ELIBACC => "ELIBACC", + ELIBBAD => "ELIBBAD", + ELIBSCN => "ELIBSCN", + ELIBMAX => "ELIBMAX", + ELIBEXEC => "ELIBEXEC", + EILSEQ => "EILSEQ", + ERESTART => "ERESTART", + ESTRPIPE => "ESTRPIPE", + EUSERS => "EUSERS", + ENOTSOCK => "ENOTSOCK", + EDESTADDRREQ => "EDESTADDRREQ", + EMSGSIZE => "EMSGSIZE", + EPROTOTYPE => "EPROTOTYPE", + ENOPROTOOPT => "ENOPROTOOPT", + EPROTONOSUPPORT => "EPROTONOSUPPORT", + ESOCKTNOSUPPORT => "ESOCKTNOSUPPORT", + EOPNOTSUPP => "EOPNOTSUPP", + EPFNOSUPPORT => "EPFNOSUPPORT", + EAFNOSUPPORT => "EAFNOSUPPORT", + EADDRINUSE => "EADDRINUSE", + EADDRNOTAVAIL => "EADDRNOTAVAIL", + ENETDOWN => "ENETDOWN", + ENETUNREACH => "ENETUNREACH", + ENETRESET => "ENETRESET", + ECONNABORTED => "ECONNABORTED", + ECONNRESET => "ECONNRESET", + ENOBUFS => "ENOBUFS", + EISCONN => "EISCONN", + ENOTCONN => "ENOTCONN", + ESHUTDOWN => "ESHUTDOWN", + ETOOMANYREFS => "ETOOMANYREFS", + ETIMEDOUT => "ETIMEDOUT", + ECONNREFUSED => "ECONNREFUSED", + EHOSTDOWN => "EHOSTDOWN", + EHOSTUNREACH => "EHOSTUNREACH", + EALREADY => "EALREADY", + EINPROGRESS => "EINPROGRESS", + ESTALE => "ESTALE", + EUCLEAN => "EUCLEAN", + ENOTNAM => "ENOTNAM", + ENAVAIL => "ENAVAIL", + EISNAM => "EISNAM", + EREMOTEIO => "EREMOTEIO", + EDQUOT => "EDQUOT", + ENOMEDIUM => "ENOMEDIUM", + EMEDIUMTYPE => "EMEDIUMTYPE", + ECANCELED => "ECANCELED", + ENOKEY => "ENOKEY", + EKEYEXPIRED => "EKEYEXPIRED", + EKEYREVOKED => "EKEYREVOKED", + EKEYREJECTED => "EKEYREJECTED", + EOWNERDEAD => "EOWNERDEAD", + ENOTRECOVERABLE => "ENOTRECOVERABLE", + ERFKILL => "ERFKILL", + EHWPOISON => "EHWPOISON", + * => "[unknown errno]", // TODO: snprintf to add errno? + }; +}; + +export def EPERM: int = 1; +export def ENOENT: int = 2; +export def ESRCH: int = 3; +export def EINTR: int = 4; +export def EIO: int = 5; +export def ENXIO: int = 6; +export def E2BIG: int = 7; +export def ENOEXEC: int = 8; +export def EBADF: int = 9; +export def ECHILD: int = 10; +export def EAGAIN: int = 11; +export def ENOMEM: int = 12; +export def EACCES: int = 13; +export def EFAULT: int = 14; +export def ENOTBLK: int = 15; +export def EBUSY: int = 16; +export def EEXIST: int = 17; +export def EXDEV: int = 18; +export def ENODEV: int = 19; +export def ENOTDIR: int = 20; +export def EISDIR: int = 21; +export def EINVAL: int = 22; +export def ENFILE: int = 23; +export def EMFILE: int = 24; +export def ENOTTY: int = 25; +export def ETXTBSY: int = 26; +export def EFBIG: int = 27; +export def ENOSPC: int = 28; +export def ESPIPE: int = 29; +export def EROFS: int = 30; +export def EMLINK: int = 31; +export def EPIPE: int = 32; +export def EDOM: int = 33; +export def ERANGE: int = 34; +export def EDEADLK: int = 35; +export def ENAMETOOLONG: int = 36; +export def ENOLCK: int = 37; +export def ENOSYS: int = 38; +export def ENOTEMPTY: int = 39; +export def ELOOP: int = 40; +export def ENOMSG: int = 42; +export def EIDRM: int = 43; +export def ECHRNG: int = 44; +export def EL2NSYNC: int = 45; +export def EL3HLT: int = 46; +export def EL3RST: int = 47; +export def ELNRNG: int = 48; +export def EUNATCH: int = 49; +export def ENOCSI: int = 50; +export def EL2HLT: int = 51; +export def EBADE: int = 52; +export def EBADR: int = 53; +export def EXFULL: int = 54; +export def ENOANO: int = 55; +export def EBADRQC: int = 56; +export def EBADSLT: int = 57; +export def EBFONT: int = 59; +export def ENOSTR: int = 60; +export def ENODATA: int = 61; +export def ETIME: int = 62; +export def ENOSR: int = 63; +export def ENONET: int = 64; +export def ENOPKG: int = 65; +export def EREMOTE: int = 66; +export def ENOLINK: int = 67; +export def EADV: int = 68; +export def ESRMNT: int = 69; +export def ECOMM: int = 70; +export def EPROTO: int = 71; +export def EMULTIHOP: int = 72; +export def EDOTDOT: int = 73; +export def EBADMSG: int = 74; +export def EOVERFLOW: int = 75; +export def ENOTUNIQ: int = 76; +export def EBADFD: int = 77; +export def EREMCHG: int = 78; +export def ELIBACC: int = 79; +export def ELIBBAD: int = 80; +export def ELIBSCN: int = 81; +export def ELIBMAX: int = 82; +export def ELIBEXEC: int = 83; +export def EILSEQ: int = 84; +export def ERESTART: int = 85; +export def ESTRPIPE: int = 86; +export def EUSERS: int = 87; +export def ENOTSOCK: int = 88; +export def EDESTADDRREQ: int = 89; +export def EMSGSIZE: int = 90; +export def EPROTOTYPE: int = 91; +export def ENOPROTOOPT: int = 92; +export def EPROTONOSUPPORT: int = 93; +export def ESOCKTNOSUPPORT: int = 94; +export def EOPNOTSUPP: int = 95; +export def EPFNOSUPPORT: int = 96; +export def EAFNOSUPPORT: int = 97; +export def EADDRINUSE: int = 98; +export def EADDRNOTAVAIL: int = 99; +export def ENETDOWN: int = 100; +export def ENETUNREACH: int = 101; +export def ENETRESET: int = 102; +export def ECONNABORTED: int = 103; +export def ECONNRESET: int = 104; +export def ENOBUFS: int = 105; +export def EISCONN: int = 106; +export def ENOTCONN: int = 107; +export def ESHUTDOWN: int = 108; +export def ETOOMANYREFS: int = 109; +export def ETIMEDOUT: int = 110; +export def ECONNREFUSED: int = 111; +export def EHOSTDOWN: int = 112; +export def EHOSTUNREACH: int = 113; +export def EALREADY: int = 114; +export def EINPROGRESS: int = 115; +export def ESTALE: int = 116; +export def EUCLEAN: int = 117; +export def ENOTNAM: int = 118; +export def ENAVAIL: int = 119; +export def EISNAM: int = 120; +export def EREMOTEIO: int = 121; +export def EDQUOT: int = 122; +export def ENOMEDIUM: int = 123; +export def EMEDIUMTYPE: int = 124; +export def ECANCELED: int = 125; +export def ENOKEY: int = 126; +export def EKEYEXPIRED: int = 127; +export def EKEYREVOKED: int = 128; +export def EKEYREJECTED: int = 129; +export def EOWNERDEAD: int = 130; +export def ENOTRECOVERABLE: int = 131; +export def ERFKILL: int = 132; +export def EHWPOISON: int = 133; diff --git a/example/errors.ha b/example/errors.ha new file mode 100644 index 000000000..0e8d40a07 --- /dev/null +++ b/example/errors.ha @@ -0,0 +1,40 @@ +use bufio; +use fmt; +use hare::lex; +use hare::parse; +use io; +use os; +use strings; + +// TODO: Expand to more kinds of errors +fn printerr(err: parse::error) void = { + match (err) { + err: lex::syntax => printerr_syntax(err), + err: io::error => fmt::errorln(io::strerror(err)), + }; +}; + +fn printerr_syntax(err: lex::syntax) void = { + let location = err.0, details = err.1; + let file = os::open(location.path) as *io::stream; + defer io::close(file); + + let line = 1u; + for (line < location.line) { + let r = bufio::scanrune(file) as rune; + if (r == '\n') { + line += 1u; + }; + }; + + let line = bufio::scanline(file) as []u8; + defer free(line); + let line = strings::fromutf8(line); + fmt::errorfln("{}:{},{}: Syntax error: {}", + location.path, location.line, location.col, details); + fmt::errorln(line); + for (let i = 0u; i < location.col - 2; i += 1) { + fmt::error(" "); + }; + fmt::errorln("^--- here"); +}; diff --git a/example/exec+linux.ha b/example/exec+linux.ha new file mode 100644 index 000000000..a1b0d7a0c --- /dev/null +++ b/example/exec+linux.ha @@ -0,0 +1,83 @@ +use errors; +use rt; +use strings; +use os; + +// Forks the current process, returning the pid of the child (to the parent) and +// void (to the child), or an error. +export fn fork() (int | void | error) = match (rt::fork()) { + err: rt::errno => errors::errno(err), + i: (int | void) => i, +}; + +fn open(path: str) (platform_cmd | errors::opaque) = { + match (rt::access(path, rt::X_OK)) { + err: rt::errno => errors::errno(err), + b: bool => if (!b) { + return errors::errno(rt::EACCES); + }, + }; + // O_PATH is used because it allows us to use an executable for which we + // have execute permissions, but not read permissions. + return match (rt::open(path, rt::O_PATH, 0u)) { + fd: int => fd, + err: rt::errno => errors::errno(err), + }; +}; + +fn platform_finish(cmd: *command) void = rt::close(cmd.platform); + +fn platform_exec(cmd: *command) errors::opaque = { + // We don't worry about freeing the return values from strings::to_c + // because once we exec(2) our heap is fried anyway + let argv: []nullable *const char = alloc([], len(cmd.argv) + 1z); + for (let i = 0z; i < len(cmd.argv); i += 1z) { + append(argv, strings::to_c(cmd.argv[i])); + }; + append(argv, null); + + let envp: nullable *[*]nullable *const char = null; + if (len(cmd.env) != 0) { + let env: []nullable *const char = alloc([], len(cmd.env) + 1); + for (let i = 0z; i < len(cmd.env); i += 1) { + append(env, strings::to_c(cmd.env[i])); + }; + append(env, null); + envp = env: *[*]nullable *const char; + }; + + return errors::errno(rt::execveat(cmd.platform, strings::c_empty, + argv: *[*]nullable *const char, envp, rt::AT_EMPTY_PATH)); +}; + +fn platform_start(cmd: *command) (errors::opaque | process) = { + // TODO: Let the user configure clone more to their taste (e.g. SIGCHLD) + let pipe: [2]int = [0...]; + match (rt::pipe2(&pipe, rt::O_CLOEXEC)) { + err: rt::errno => return errors::errno(err), + void => void, + }; + + match (rt::clone(null, 0, null, null, 0)) { + err: rt::errno => return errors::errno(err), + pid: int => { + rt::close(pipe[1]); + let errno: int = 0; + return match (rt::read(pipe[0], &errno, size(int))) { + err: rt::errno => errors::errno(err), + n: size => switch (n) { + size(int) => errors::errno(errno), + * => abort("Unexpected rt::read result"), + 0 => pid, + }, + }; + }, + void => { + rt::close(pipe[0]); + let err = platform_exec(cmd); + let err = &err.data: *rt::errno; + rt::write(pipe[1], &err, size(int)); + rt::exit(1); + }, + }; +}; diff --git a/example/exit.ha b/example/exit.ha new file mode 100644 index 000000000..731b503c8 --- /dev/null +++ b/example/exit.ha @@ -0,0 +1,4 @@ +use rt; + +// Exit the program with the provided status code. +export @noreturn fn exit(status: int) void = rt::exit(status); diff --git a/example/expr.ha b/example/expr.ha new file mode 100644 index 000000000..1717fcd1b --- /dev/null +++ b/example/expr.ha @@ -0,0 +1,89 @@ +use io; +use fmt; +use hare::ast; + +// TODO +export fn expr( + out: *io::stream, + indent: size, + t: ast::expr +) (size | io::error) = { + return match (t) { + e: ast::access_expr => abort(), + e: ast::alloc_expr => abort(), + e: ast::append_expr => abort(), + e: ast::assert_expr => abort(), + e: ast::assign_expr => abort(), + e: ast::binarithm_expr => { + let z = expr(out, indent, *e.lvalue)?; + z += fmt::fprintf(out, " {} ", switch (e.op) { + ast::binarithm_op::BAND => "&", + ast::binarithm_op::BOR => "|", + ast::binarithm_op::DIV => "/", + ast::binarithm_op::GT => ">", + ast::binarithm_op::GTEQ => ">=", + ast::binarithm_op::LAND => "&&", + ast::binarithm_op::LEQUAL => "==", + ast::binarithm_op::LESS => "<", + ast::binarithm_op::LESSEQ => "<=", + ast::binarithm_op::LOR => "||", + ast::binarithm_op::LSHIFT => "<<", + ast::binarithm_op::LXOR => "^^", + ast::binarithm_op::MINUS => "-", + ast::binarithm_op::MODULO => "%", + ast::binarithm_op::NEQUAL => "!=", + ast::binarithm_op::PLUS => "+", + ast::binarithm_op::RSHIFT => ">>", + ast::binarithm_op::TIMES => "*", + ast::binarithm_op::BXOR => "^", + })?; + z += expr(out, indent, *e.rvalue)?; + z; + }, + e: []ast::binding_expr => abort(), + e: ast::break_expr => abort(), + e: ast::call_expr => abort(), + e: ast::cast_expr => { + let z = expr(out, indent, *e.value)?; + const op = switch (e.kind) { + ast::cast_kind::CAST => ": ", + ast::cast_kind::ASSERTION => " as ", + ast::cast_kind::TEST => " is ", + }; + z += fmt::fprintf(out, "{}", op)?; + z += _type(out, indent, *e._type)?; + z; + }, + e: ast::constant_expr => { + assert(e is void); + fmt::fprint(out, "void")?; + }, + e: ast::continue_expr => abort(), + e: ast::defer_expr => abort(), + e: ast::delete_expr => abort(), + e: ast::for_expr => abort(), + e: ast::free_expr => abort(), + e: ast::if_expr => abort(), + e: ast::list_expr => abort(), + e: ast::match_expr => abort(), + e: ast::len_expr => abort(), + e: ast::size_expr => abort(), + e: ast::offset_expr => abort(), + e: ast::propagate_expr => abort(), + e: ast::return_expr => abort(), + e: ast::slice_expr => abort(), + e: ast::switch_expr => abort(), + e: ast::unarithm_expr => { + let z = fmt::fprintf(out, "{}", switch (e.op) { + ast::unarithm_op::ADDR => "&", + ast::unarithm_op::BNOT => "~", + ast::unarithm_op::DEREF => "*", + ast::unarithm_op::LNOT => "!", + ast::unarithm_op::MINUS => "-", + ast::unarithm_op::PLUS => "+", + })?; + z += expr(out, indent, *e.operand)?; + z; + }, + }; +}; diff --git a/example/exprclass.ha b/example/exprclass.ha new file mode 100644 index 000000000..d210d054a --- /dev/null +++ b/example/exprclass.ha @@ -0,0 +1,40 @@ +use hare::ast; +use hare::lex::{btoken}; +use hare::lex; +use io; + +// Parses a complex-expression. +export fn complex_expression(lexer: *lex::lexer) (ast::expr | error) = { + // TODO: if, for, switch, match + return simple_expression(lexer); +}; + +// Parses a compound-expression. +export fn compound_expression(lexer: *lex::lexer) (ast::expr | error) = { + let tok = match (lex::lex(lexer)?) { + io::EOF => return syntaxerr(mkloc(lexer), + "Unexpected EOF, expected compound expression"), + t: (lex::token, lex::location) => t, + }; + + lex::unlex(lexer, tok); + let tok = match (tok.0) { + tok: btoken => tok, + * => return complex_expression(lexer), + }; + + return switch (tok) { + btoken::LBRACE => expression_list(lexer), + btoken::BREAK, btoken::CONTINUE, btoken::RETURN => + control_statement(lexer), + * => complex_expression(lexer), + }; +}; + +fn scope_expression(lexer: *lex::lexer) (ast::expr | error) = { + return simple_expression(lexer); // TODO +}; + +// Parses a simple-expression. +export fn simple_expression(lexer: *lex::lexer) (ast::expr | error) = + binarithm(lexer, void, 0); diff --git a/example/fdstream.ha b/example/fdstream.ha new file mode 100644 index 000000000..264c9a949 --- /dev/null +++ b/example/fdstream.ha @@ -0,0 +1,135 @@ +use errors; +use io; +use rt; +use strings; + +type fd_stream = struct { + stream: io::stream, + fd: int, +}; + +fn static_fdopen( + fd: int, name: str, mode: io::mode, stream: *fd_stream, +) *io::stream = { + *stream = fd_stream { + stream = io::stream { + name = name, + closer = &fd_close_static, + copier = &fd_copy, + seeker = &fd_seek, + ... + }, + fd = fd, + }; + if (mode & io::mode::READ == io::mode::READ) { + stream.stream.reader = &fd_read; + }; + if (mode & io::mode::WRITE == io::mode::WRITE) { + stream.stream.writer = &fd_write; + }; + return &stream.stream; +}; + +// Opens a Unix file descriptor as an io::stream. +export fn fdopen(fd: int, name: str, mode: io::mode) *io::stream = { + let stream = alloc(fd_stream { ... }); + static_fdopen(fd, strings::dup(name), mode, stream); + stream.stream.closer = &fd_close; + return &stream.stream; +}; + +fn is_fdstream(s: *io::stream) bool = { + return s.reader == &fd_read + || s.writer == &fd_write + || s.closer == &fd_close + || s.closer == &fd_close_static + || s.copier == &fd_copy; +}; + +// Returns the file descriptor for a given [io::stream]. If there is no fd +// associated with this stream, void is returned. +export fn streamfd(s: *io::stream) (int | void) = { + for (!is_fdstream(s)) { + s = match (io::source(s)) { + errors::unsupported => return, + s: *io::stream => s, + }; + }; + let stream = s: *fd_stream; + return stream.fd; +}; + +fn fd_read(s: *io::stream, buf: []u8) (size | io::EOF | io::error) = { + let stream = s: *fd_stream; + return match (rt::read(stream.fd, buf: *[*]u8, len(buf))) { + err: rt::errno => errors::errno(err), + n: size => switch (n) { + 0 => io::EOF, + * => n, + }, + }; +}; + +fn fd_write(s: *io::stream, buf: const []u8) (size | io::error) = { + let stream = s: *fd_stream; + return match (rt::write(stream.fd, buf: *const [*]u8, len(buf))) { + err: rt::errno => errors::errno(err), + n: size => n, + }; +}; + +fn fd_close(s: *io::stream) void = { + let stream = s: *fd_stream; + rt::close(stream.fd); + free(s.name); + free(stream); +}; + +fn fd_close_static(s: *io::stream) void = { + let stream = s: *fd_stream; + rt::close(stream.fd); + free(stream); +}; + +def SENDFILE_MAX: size = 2147479552z; + +fn fd_copy(to: *io::stream, from: *io::stream) (size | io::error) = { + if (!is_fdstream(from)) { + return errors::unsupported; + }; + + let to = to: *fd_stream, from = from: *fd_stream; + let sum = 0z; + for (true) { + let n = match (rt::sendfile(to.fd, from.fd, + null, SENDFILE_MAX)) { + err: rt::errno => switch (err) { + rt::EINVAL => { + if (sum == 0) { + return errors::unsupported; + }; + return errors::errno(err); + }, + * => return errors::errno(err), + }, + n: size => switch (n) { + 0 => return sum, + * => n, + }, + }; + sum += n; + }; + return sum; +}; + +fn fd_seek( + s: *io::stream, + off: io::off, + whence: io::whence, +) (io::off | io::error) = { + let stream = s: *fd_stream; + return match (rt::lseek(stream.fd, off: i64, whence: uint)) { + err: rt::errno => errors::errno(err), + n: i64 => n: io::off, + }; +}; diff --git a/example/fixed.ha b/example/fixed.ha new file mode 100644 index 000000000..ada891977 --- /dev/null +++ b/example/fixed.ha @@ -0,0 +1,62 @@ +use bytes; +use io; +use strings; + +type fixed_stream = struct { + stream: io::stream, + buf: []u8, +}; + +// Creates an [io::stream] for a fixed, caller-supplied buffer. Supports either +// read or write, but not both. The program aborts if writes would exceed the +// buffer's capacity. +export fn fixed(in: []u8, mode: io::mode) *io::stream = { + let s = alloc(fixed_stream { + stream = io::stream { + name = "", + ... + }, + buf = in, + }); + if (mode & io::mode::READ == io::mode::READ) { + assert(mode & io::mode::WRITE != io::mode::WRITE); + s.stream.reader = &fixed_read; + }; + if (mode & io::mode::WRITE == io::mode::WRITE) { + assert(mode & io::mode::READ != io::mode::READ); + s.stream.writer = &fixed_write; + }; + return &s.stream; +}; + +fn fixed_read(s: *io::stream, buf: []u8) (size | io::error | io::EOF) = { + let stream = s: *fixed_stream; + if (len(stream.buf) == 0) { + return io::EOF; + }; + const n = if (len(buf) > len(stream.buf)) len(stream.buf) else len(buf); + buf[..n] = stream.buf[..n]; + stream.buf = stream.buf[n..]; + return n; +}; + +fn fixed_write(s: *io::stream, buf: const []u8) (size | io::error) = { + let stream = s: *fixed_stream; + if (len(stream.buf) == 0) { + abort("bufio::fixed buffer exceeded"); + }; + const n = if (len(buf) > len(stream.buf)) len(stream.buf) else len(buf); + stream.buf[..n] = buf[..n]; + stream.buf = stream.buf[n..]; + return n; +}; + +@test fn fixed() void = { + // TODO: add a read test too + static let buf: [1024]u8 = [0...]; + let stream = fixed(buf, io::mode::WRITE); + let n = 0z; + n += io::write(stream, strings::toutf8("hello ")) as size; + n += io::write(stream, strings::toutf8("world")) as size; + assert(bytes::equal(buf[..n], strings::toutf8("hello world"))); +}; diff --git a/example/fmt.ha b/example/fmt.ha new file mode 100644 index 000000000..16ef5bc2c --- /dev/null +++ b/example/fmt.ha @@ -0,0 +1,432 @@ +// A format string consists of a string of literal characters, to be printed +// verbatim, and format sequences, which describe how to format arguments from +// a set of variadic parameters for printing. +// +// A format sequence is enclosed in curly braces '{}'. An empty sequence takes +// the next argument from the parameter list, in order. A specific parameter may +// be selected by indexing it from zero: '{0}', '{1}', and so on. To print '{', +// use '{{', and for '}', use '}}'. +// +// You may use a colon to add format modifiers; for example, '{:x}' will format +// an argument in hexadecimal, and '{3:-10}' will left-align the 3rd argument to +// at least 10 characters. +// +// The format modifiers takes the form of an optional flag character: +// +// 0: Numeric values are zero-padded up to the required width. +// -: The value shall be left-aligned, and spaces inserted on the right to meet +// the required width. '-' takes precedence over '0' if both are used. +// : (a space) insert a space before positive numbers, where '-' would be if it +// were negative. +// +: insert a '+' before positive numbers, where '-' would be if it were +// negative. '+' takes precedence over ' ' if both are used. +// +// Following the flag, an optional decimal number shall specify the minimum +// width of this field. If '0' or '-' were not given, the default behavior shall +// be to pad with spaces to achieve the necessary width. +// +// Following the width, an optional precision may be given as a decimal number +// following a '.' character. For integer types, this gives the minimum number +// of digits to include. For floating types, this gives the number of digits +// following the radix to include. +// +// Following the precision, an optional character controls the output format: +// +// x, X: print in lowercase or uppercase hexadecimal +// o, b: print in octal or binary +// +// TODO: Expand this with more format modifiers +use ascii; +use bufio; +use encoding::utf8; +use io; +use os; +use strconv; +use strings; +use types; + +// Tagged union of all types which are formattable. +export type formattable = + (...types::numeric | uintptr | str | rune | bool | nullable *void); + +// Formats text for printing and writes it to [os::stdout]. +export fn printf(fmt: str, args: formattable...) (io::error | size) = + fprintf(os::stdout, fmt, args...); + +// Formats text for printing and writes it to [os::stdout], followed by a line +// feed. +export fn printfln(fmt: str, args: formattable...) (io::error | size) = + fprintfln(os::stdout, fmt, args...); + +// Formats text for printing and writes it to [os::stderr]. +export fn errorf(fmt: str, args: formattable...) (io::error | size) = + fprintf(os::stderr, fmt, args...); + +// Formats text for printing and writes it to [os::stderr], followed by a line +// feed. +export fn errorfln(fmt: str, args: formattable...) (io::error | size) = + fprintfln(os::stderr, fmt, args...); + +// Formats text for printing and writes it into a heap-allocated string. The +// caller must free the return value. +export fn asprintf(fmt: str, args: formattable...) str = { + let buf = bufio::dynamic(io::mode::WRITE); + assert(fprintf(buf, fmt, args...) is size); + return strings::fromutf8_unsafe(bufio::finish(buf)); +}; + +// Formats text for printing and writes it into a caller supplied buffer. The +// returned string is borrowed from this buffer. +export fn bsprintf(buf: []u8, fmt: str, args: formattable...) str = { + let sink = bufio::fixed(buf, io::mode::WRITE); + let l = fprintf(sink, fmt, args...) as size; + return strings::fromutf8_unsafe(buf[..l]); +}; + +// Formats text for printing and writes it to [os::stderr], followed by a line +// feed, then exits the program with an error status. +export @noreturn fn fatal(fmt: str, args: formattable...) void = { + fprintfln(os::stderr, fmt, args...); + os::exit(1); +}; + +// Formats text for printing and writes it to an [io::stream], followed by a +// line feed. +export fn fprintfln( + s: *io::stream, + fmt: str, + args: formattable... +) (io::error | size) = { + return fprintf(s, fmt, args...)? + io::write(s, ['\n': u32: u8])?; +}; + +// Formats values for printing using the default format modifiers and writes +// them to [os::stdout] separated by spaces +export fn print(args: formattable...) (io::error | size) = + fprint(os::stdout, args...); + +// Formats values for printing using the default format modifiers and writes +// them to [os::stdout] separated by spaces and followed by a line feed +export fn println(args: formattable...) (io::error | size) = + fprintln(os::stdout, args...); + +// Formats values for printing using the default format modifiers and writes +// them to [os::stderr] separated by spaces +export fn error(args: formattable...) (io::error | size) = + fprint(os::stderr, args...); + +// Formats values for printing using the default format modifiers and writes +// them to [os::stderr] separated by spaces and followed by a line feed +export fn errorln(args: formattable...) (io::error | size) = + fprintln(os::stderr, args...); + +// Formats values for printing using the default format modifiers and writes +// them into a heap-allocated string separated by spaces. The caller must free +// the return value. +export fn asprint(args: formattable...) str = { + let buf = bufio::dynamic(io::mode::WRITE); + assert(fprint(buf, args...) is size); + return strings::fromutf8_unsafe(bufio::finish(buf)); +}; + +// Formats values for printing using the default format modifiers and writes +// them into a caller supplied buffer separated by spaces. The returned string +// is borrowed from this buffer. +export fn bsprint(buf: []u8, args: formattable...) str = { + let sink = bufio::fixed(buf, io::mode::WRITE); + assert(fprint(sink, args...) is size); + return strings::fromutf8_unsafe(buf); +}; + +// Formats values for printing using the default format modifiers and writes +// them to an [io::stream] separated by spaces and followed by a line feed +export fn fprintln(s: *io::stream, args: formattable...) (io::error | size) = { + return fprint(s, args...)? + io::write(s, ['\n': u32: u8])?; +}; + +// Formats values for printing using the default format modifiers and writes +// them to an [io::stream] separated by spaces +export fn fprint(s: *io::stream, args: formattable...) (io::error | size) = { + let mod = modifiers { base = strconv::base::DEC, ... }; + let n = 0z; + for (let i = 0z; i < len(args); i += 1) { + n += format(s, args[i], &mod)?; + if (i != len(args) - 1) { + n += io::write(s, [' ': u32: u8])?; + }; + }; + return n; +}; + +type negation = enum { + NONE, + SPACE, + PLUS, +}; + +type padding = enum { + ALIGN_RIGHT, + ALIGN_LEFT, + ZEROES, +}; + +type modifiers = struct { + padding: padding, + negation: negation, + width: uint, + precision: uint, + base: strconv::base, +}; + +type modflags = enum uint { + NONE = 0, + ZERO = 1 << 0, + MINUS = 1 << 1, + SPACE = 1 << 2, + PLUS = 1 << 3, +}; + +// Formats text for printing and writes it to an [io::stream]. +export fn fprintf( + s: *io::stream, + fmt: str, + args: formattable... +) (io::error | size) = { + let n = 0z, i = 0z; + let iter = strings::iter(fmt); + for (true) { + let r: rune = match (strings::next(&iter)) { + void => break, + r: rune => r, + }; + + if (r == '{') { + r = match (strings::next(&iter)) { + void => abort("Invalid format string (unterminated '{')"), + r: rune => r, + }; + + const arg = if (r == '{') { + n += io::write(s, utf8::encoderune('{'))?; + continue; + } else if (ascii::isdigit(r)) { + strings::push(&iter, r); + args[scan_uint(&iter)]; + } else { + strings::push(&iter, r); + i += 1; + args[i - 1]; + }; + + let mod = modifiers { base = strconv::base::DEC, ... }; + r = match (strings::next(&iter)) { + void => abort("Invalid format string (unterminated '{')"), + r: rune => r, + }; + switch (r) { + ':' => scan_modifiers(&iter, &mod), + '}' => void, + * => abort("Invalid format string"), + }; + + n += format(s, arg, &mod)?; + } else if (r == '}') { + match (strings::next(&iter)) { + void => abort("Invalid format string (hanging '}')"), + r: rune => assert(r == '}', "Invalid format string (hanging '}')"), + }; + + n += io::write(s, utf8::encoderune('}'))?; + } else { + n += io::write(s, utf8::encoderune(r))?; + }; + }; + + return n; +}; + +fn format(out: *io::stream, arg: formattable, mod: *modifiers) (size | io::error) = { + let z = format_raw(io::empty, arg, mod)?; + + let pad: []u8 = []; + if (z < mod.width: size) { + pad = utf8::encoderune(switch (mod.padding) { + padding::ZEROES => '0', + * => ' ', + }); + }; + + if (mod.padding == padding::ALIGN_LEFT) { + format_raw(out, arg, mod); + }; + + for (z < mod.width: size) { + z += io::write(out, pad)?; + }; + + if (mod.padding != padding::ALIGN_LEFT) { + format_raw(out, arg, mod); + }; + + return z; +}; + +fn format_raw( + out: *io::stream, + arg: formattable, + mod: *modifiers, +) (size | io::error) = match (arg) { + s: str => io::write(out, strings::toutf8(s)), + r: rune => io::write(out, utf8::encoderune(r)), + b: bool => io::write(out, strings::toutf8(if (b) "true" else "false")), + n: types::numeric => { + let s = strconv::numerictosb(n, mod.base); + io::write(out, strings::toutf8(s)); + }, + p: uintptr => { + let s = strconv::uptrtosb(p, mod.base); + io::write(out, strings::toutf8(s)); + }, + v: nullable *void => match (v) { + v: *void => { + let s = strconv::uptrtosb(v: uintptr, + strconv::base::HEX_LOWER); + let n = io::write(out, strings::toutf8("0x"))?; + n += io::write(out, strings::toutf8(s))?; + n; + }, + null => format(out, "(null)", mod), + }, +}; + + +fn scan_uint(iter: *strings::iterator) uint = { + let num: []u8 = []; + defer free(num); + for (true) { + let r = match (strings::next(iter)) { + void => abort("Invalid format string (unterminated '{')"), + r: rune => r, + }; + + if (ascii::isdigit(r)) { + append(num, r: u32: u8); + } else { + strings::push(iter, r); + match (strconv::stou(strings::fromutf8(num))) { + (strconv::invalid | strconv::overflow) => + abort("Invalid format string (invalid index)"), + u: uint => return u, + }; + }; + }; + abort("unreachable"); +}; + +fn scan_modifier_flags(iter: *strings::iterator, mod: *modifiers) void = { + let flags = modflags::NONE; + + for (true) { + let r = match (strings::next(iter)) { + void => abort("Invalid format string (unterminated '{')"), + r: rune => r, + }; + + switch (r) { + '0' => flags |= modflags::ZERO, + '-' => flags |= modflags::MINUS, + ' ' => flags |= modflags::SPACE, + '+' => flags |= modflags::PLUS, + * => { + strings::push(iter, r); + break; + }, + }; + }; + + mod.padding = if (flags & modflags::MINUS != 0) + padding::ALIGN_LEFT + else if (flags & modflags::ZERO != 0) + padding::ZEROES + else + padding::ALIGN_RIGHT; + + mod.negation = if (flags & modflags::PLUS != 0) + negation::PLUS + else if (flags & modflags::SPACE != 0) + negation::SPACE + else + negation::NONE; +}; + +fn scan_modifier_width(iter: *strings::iterator, mod: *modifiers) void = { + let r = match (strings::next(iter)) { + void => abort("Invalid format string (unterminated '{')"), + r: rune => r, + }; + + let is_digit = ascii::isdigit(r); + strings::push(iter, r); + + if (is_digit) { + mod.width = scan_uint(iter); + }; +}; + +fn scan_modifier_precision(iter: *strings::iterator, mod: *modifiers) void = { + let r = match (strings::next(iter)) { + void => abort("Invalid format string (unterminated '{')"), + r: rune => r, + }; + + if (r == '.') { + mod.precision = scan_uint(iter); + } else { + strings::push(iter, r); + }; +}; + +fn scan_modifier_base(iter: *strings::iterator, mod: *modifiers) void = { + let r = match (strings::next(iter)) { + void => abort("Invalid format string (unterminated '{')"), + r: rune => r, + }; + + switch (r) { + 'x' => mod.base = strconv::base::HEX_LOWER, + 'X' => mod.base = strconv::base::HEX_UPPER, + 'o' => mod.base = strconv::base::OCT, + 'b' => mod.base = strconv::base::BIN, + * => strings::push(iter, r), + }; +}; + +fn scan_modifiers(iter: *strings::iterator, mod: *modifiers) void = { + scan_modifier_flags(iter, mod); + scan_modifier_width(iter, mod); + scan_modifier_precision(iter, mod); + scan_modifier_base(iter, mod); + + // eat '}' + let terminated = match (strings::next(iter)) { + void => false, + r: rune => r == '}', + }; + assert(terminated, "Invalid format string (unterminated '{')"); +}; + +@test fn fmt() void = { + let buf: [1024]u8 = [0...]; + assert(bsprintf(buf, "hello world") == "hello world"); + assert(bsprintf(buf, "{} {}", "hello", "world") == "hello world"); + assert(bsprintf(buf, "{0} {1}", "hello", "world") == "hello world"); + assert(bsprintf(buf, "{0} {0}", "hello", "world") == "hello hello"); + assert(bsprintf(buf, "{1} {0} {1}", "hello", "world") == "world hello world"); + assert(bsprintf(buf, "x: {:08x}", 0xBEEF) == "x: 0000beef"); + assert(bsprintf(buf, "x: {:8X}", 0xBEEF) == "x: BEEF"); + assert(bsprintf(buf, "x: {:-8X}", 0xBEEF) == "x: BEEF "); + assert(bsprintf(buf, "x: {:o}", 0o755) == "x: 755"); + assert(bsprintf(buf, "x: {:b}", 0b11011) == "x: 11011"); + assert(bsprintf(buf, "{} {} {} {}", true, false, null, 'x') + == "true false (null) x"); +}; diff --git a/example/fnv.ha b/example/fnv.ha new file mode 100644 index 000000000..9fcae7599 --- /dev/null +++ b/example/fnv.ha @@ -0,0 +1,179 @@ +// Implements the Fowler–Noll–Vo (FNV) hash function. This hash is recommended +// for hash map keys and similar applications. It is a non-cryptographic hash. +use endian; +use hash; +use io; +use strings; + +def prime32: u32 = 16777619; +def prime64: u64 = 1099511628211; +def basis32: u32 = 2166136261; +def basis64: u64 = 14695981039346656037; + +type state32 = struct { + hash: hash::hash, + v: u32, +}; + +type state64 = struct { + hash: hash::hash, + v: u64, +}; + +// Creates a [hash::hash] which computes the FNV-1 32-bit hash function. +// +// Unless you have a reason to use this, [fnv32a] is recommended instead. +export fn fnv32() *hash::hash = alloc(state32 { + hash = hash::hash { + stream = io::stream { + writer = &fnv32_write, + closer = &fnv_close, + }, + sum = &fnv32_sum, + reset = &fnv32_reset, + sz = 4, + }, + v = basis32, +}): *hash::hash; + +// Creates a [hash::hash] which computes the FNV-1a 32-bit hash function. +export fn fnv32a() *hash::hash = alloc(state32 { + hash = hash::hash { + stream = io::stream { + writer = &fnv32a_write, + closer = &fnv_close, + }, + sum = &fnv32_sum, + reset = &fnv32_reset, + sz = 4, + }, + v = basis32, +}): *hash::hash; + +// Creates a [hash::hash] which computes the FNV-1 64-bit hash function. +// +// Unless you have a reason to use this, [fnv64a] is recommended instead. +export fn fnv64() *hash::hash = alloc(state64 { + hash = hash::hash { + stream = io::stream { + writer = &fnv64_write, + closer = &fnv_close, + }, + sum = &fnv64_sum, + reset = &fnv64_reset, + sz = 8, + }, + v = basis64, +}): *hash::hash; + +// Creates a [hash::hash] which computes the FNV-1a 64-bit hash function. +export fn fnv64a() *hash::hash = alloc(state64 { + hash = hash::hash { + stream = io::stream { + writer = &fnv64a_write, + closer = &fnv_close, + }, + sum = &fnv64_sum, + reset = &fnv64_reset, + sz = 8, + }, + v = basis64, +}): *hash::hash; + +fn fnv_close(s: *io::stream) void = free(s); + +fn fnv32_write(s: *io::stream, buf: const []u8) (size | io::error) = { + let s = s: *state32; + for (let i = 0z; i < len(buf); i += 1) { + s.v *= prime32; + s.v ^= buf[i]; + }; + return len(buf); +}; + +fn fnv32a_write(s: *io::stream, buf: const []u8) (size | io::error) = { + let s = s: *state32; + for (let i = 0z; i < len(buf); i += 1) { + s.v ^= buf[i]; + s.v *= prime32; + }; + return len(buf); +}; + +fn fnv32_reset(h: *hash::hash) void = { + let h = h: *state32; + h.v = basis32; +}; + +fn fnv32_sum(h: *hash::hash) []u8 = { + let h = h: *state32; + let buf: [4]u8 = [0...]; + endian::host.putu32(buf, h.v); + return alloc(buf); +}; + +fn fnv64_write(s: *io::stream, buf: const []u8) (size | io::error) = { + let s = s: *state64; + for (let i = 0z; i < len(buf); i += 1) { + s.v *= prime64; + s.v ^= buf[i]; + }; + return len(buf); +}; + +fn fnv64a_write(s: *io::stream, buf: const []u8) (size | io::error) = { + let s = s: *state64; + for (let i = 0z; i < len(buf); i += 1) { + s.v ^= buf[i]; + s.v *= prime64; + }; + return len(buf); +}; + +fn fnv64_reset(h: *hash::hash) void = { + let h = h: *state64; + h.v = basis64; +}; + +fn fnv64_sum(h: *hash::hash) []u8 = { + let h = h: *state64; + let buf: [8]u8 = [0...]; + endian::host.putu64(buf, h.v); + return alloc(buf); +}; + +// Returns the sum of a 32-bit FNV hash. +export fn sum32(h: *hash::hash) u32 = { + assert(h.reset == &fnv32_reset); + let h = h: *state32; + return h.v; +}; + +// Returns the sum of a 64-bit FNV hash. +export fn sum64(h: *hash::hash) u64 = { + assert(h.reset == &fnv64_reset); + let h = h: *state64; + return h.v; +}; + +@test fn fnv32() void = { + // TODO: Expand these tests + // I am too tired + const vectors: [_](str, u32) = [ + ("", 2166136261), + ("hello world", 1418570095), + ("Hare is a cool language", 2663852071), + ("'UNIX was not designed to stop its users from doing stupid things, as that would also stop them from doing clever things' - Doug Gwyn", 1203174417), + ("'Life is too short to run proprietary software' - Bdale Garbee", 493463614), + ("'The central enemy of reliability is complexity.' - Geer et al", 3263526736), + ("'A language that doesn’t have everything is actually easier to program in than some that do.' - Dennis Ritchie", 3069348265), + ]; + let hash = fnv32(); + defer hash::close(hash); + for (let i = 0z; i < len(vectors); i += 1) { + let vec = vectors[i]; + hash::reset(hash); + hash::write(hash, strings::toutf8(vec.0)); + assert(sum32(hash) == vec.1); + }; +}; diff --git a/example/fs.ha b/example/fs.ha new file mode 100644 index 000000000..b2448231f --- /dev/null +++ b/example/fs.ha @@ -0,0 +1,177 @@ +use errors; +use io; +use path; + +// Closes a filesystem. The fs cannot be used after this function is called. +export fn close(fs: *fs) void = { + match (fs.close) { + null => void, + f: *closefunc => f(fs), + }; +}; + +// Opens a file. If no flags are provided, the default read/write mode is +// RDONLY. +export fn open(fs: *fs, path: str, flags: flags...) (*io::stream | error) = { + return match (fs.open) { + null => errors::unsupported, + f: *openfunc => f(fs, path, flags...), + }; +}; + +// Creates a new file and opens it for writing. If no flags are provided, the +// default read/write mode is WRONLY. +// +// Only the permission bits of the mode are used. If other bits are set, they +// are discarded. +export fn create( + fs: *fs, + path: str, + mode: mode, + flags: flags... +) (*io::stream | error) = { + mode = mode & 0o777; + return match (fs.create) { + null => errors::unsupported, + f: *createfunc => f(fs, path, mode, flags...), + }; +}; + +// Removes a file. +export fn remove(fs: *fs, path: str) (void | error) = { + return match (fs.remove) { + null => errors::unsupported, + f: *removefunc => f(fs, path), + }; +}; + +// Returns an iterator for a path, which yields the contents of a directory. +// Pass empty string to yield from the root. The order in which entries are +// returned is undefined. +export fn iter(fs: *fs, path: str) (*iterator | error) = { + return match (fs.iter) { + null => errors::unsupported, + f: *iterfunc => f(fs, path), + }; +}; + +// Obtains information about a file or directory. If the target is a symlink, +// information is returned about the link, not its target. +export fn stat(fs: *fs, path: str) (filestat | error) = { + return match (fs.stat) { + null => errors::unsupported, + f: *statfunc => f(fs, path), + }; +}; + +// Opens a new filesystem for a subdirectory. The subdirectory must be closed +// separately from the parent filesystem, and its lifetime can outlive that of +// its parent. +export fn subdir(fs: *fs, path: str) (*fs | error) = { + return match (fs.subdir) { + null => errors::unsupported, + f: *subdirfunc => f(fs, path), + }; +}; + +// Creates a directory. +export fn mkdir(fs: *fs, path: str) (void | error) = { + return match (fs.mkdir) { + null => errors::unsupported, + f: *mkdirfunc => f(fs, path), + }; +}; + +// Makes a directory, and all non-extant directories in its path. +export fn mkdirs(fs: *fs, path: str) (void | error) = { + let parent = path::dirname(path); + if (path != parent) { + match (mkdirs(fs, parent)) { + errors::exists => void, + err: error => return err, + void => void, + }; + }; + return mkdir(fs, path); +}; + +// Removes a directory. The target directory must be empty; see [rmdirall] to +// remove its contents as well. +export fn rmdir(fs: *fs, path: str) (void | error) = { + if (path == "") { + return errors::invalid; + }; + return match (fs.rmdir) { + null => errors::unsupported, + f: *rmdirfunc => f(fs, path), + }; +}; + +// Removes a directory, and anything in it. +export fn rmdirall(fs: *fs, path: str) (void | error) = { + let it = iter(fs, path)?; + for (true) match (next(it)) { + ent: dirent => { + if (ent.name == "." || ent.name == "..") { + continue; + }; + let p = path::join(path, ent.name); + defer free(p); + switch (ent.ftype) { + mode::DIR => rmdirall(fs, p)?, + * => remove(fs, p)?, + }; + }, + void => break, + }; + if (path != "") { + return rmdir(fs, path); + }; +}; + +// Creates a directory and returns a subdir for it. Some filesystems support +// doing this operation atomically, but if not, a fallback is used. +export fn mksubdir(fs: *fs, path: str) (*fs | error) = { + return match (fs.mksubdir) { + null => { + mkdir(fs, path)?; + subdir(fs, path); + }, + f: *mksubdirfunc => f(fs, path), + }; +}; + +// Changes mode flags on a file or directory. Type bits are discared. +export fn chmod(fs: *fs, path: str, mode: mode) (void | error) = { + mode &= 0o755; + + return match (fs.chmod) { + f: *chmodfunc => f(fs, path, mode), + null => abort(), + }; +}; + +// Changes ownership of a file. +export fn chown(fs: *fs, path: str, uid: uint, gid: uint) (void | error) = { + return match (fs.chown) { + f: *chownfunc => f(fs, path, uid, gid), + null => abort(), + }; +}; + +// Resolves a path to its absolute, normalized value. This consoldates ./ and +// ../ sequences, roots the path, and returns a new path. The caller must free +// the return value. +export fn resolve(fs: *fs, path: str) str = { + match (fs.resolve) { + f: *resolvefunc => return f(fs, path), + null => void, + }; + abort(); // TODO +}; + +// Returns the next directory entry from an interator, or void if none remain. +// It is a programming error to call this again after it has returned void. The +// file stat returned may only have the type bits set on the file mode; callers +// should call [fs::stat] to obtain the detailed file mode. +export fn next(iter: *iterator) (dirent | void) = iter.next(iter); diff --git a/example/ftos.ha b/example/ftos.ha new file mode 100644 index 000000000..232510e99 --- /dev/null +++ b/example/ftos.ha @@ -0,0 +1,506 @@ +use types; + +fn f64bits(a: f64) u64 = *(&a: *u64); + +type r128 = struct { + hi: u64, + lo: u64, +}; + +// TODO: use 128-bit integers when implemented +fn u128mul(a: u64, b: u64) r128 = { + const a0 = a: u32: u64, a1 = a >> 32; + const b0 = b: u32: u64, b1 = b >> 32; + const p00 = a0 * b0, p01 = a0 * b1, p10 = a1 * b0, p11 = a1 * b1; + const p00_lo = p00: u32: u64, p00_hi = p00 >> 32; + const mid1 = p10 + p00_hi; + const mid1_lo = mid1: u32: u64, mid1_hi = mid1 >> 32; + const mid2 = p01 + mid1_lo; + const mid2_lo = mid2: u32: u64, mid2_hi = mid2 >> 32; + const r_hi = p11 + mid1_hi + mid2_hi; + const r_lo = (mid2_lo << 32) | p00_lo; + return r128 { hi = r_hi, lo = r_lo }; +}; + +// TODO: Same as above +fn u128rshift(lo: u64, hi: u64, s: u32) u64 = { + assert(0 <= s); + assert(s <= 64); + return (hi << (64 - s)) | (lo >> s); +}; + +fn pow5fac(value: u64) u32 = { + const m_inv_5: u64 = 14757395258967641293; // 5 * m_inv_5 = 1 (mod 2^64) + const n_div_5: u64 = 3689348814741910323; + let count: u32 = 0; + for (true) { + assert(value != 0); + value *= m_inv_5; + if (value > n_div_5) break; + count += 1; + }; + return count; +}; + +fn ibool(b: bool) u8 = if (b) 1 else 0; + +fn pow5multiple(v: u64, p: u32) bool = pow5fac(v) >= p; + +fn pow2multiple(v: u64, p: u32) bool = { + assert(v > 0); + assert(p < 64); + return (v & ((1u64 << p) - 1)) == 0; +}; + +fn mulshift64(m: u64, mul: (u64, u64), j: u32) u64 = { + // m is maximum 55 bits + let r0 = u128mul(m, mul.0), r1 = u128mul(m, mul.1); + const sum = r1.lo + r0.hi; + r1.hi += ibool(sum < r0.hi); + return u128rshift(sum, r1.hi, j - 64); +}; + +fn mulshiftall64(m: u64, mul: (u64, u64), j: i32, mm_shift: u32) (u64, u64, u64) = { + m <<= 1; + const r0 = u128mul(m, mul.0), r1 = u128mul(m, mul.1); + let lo = r0.lo, tmp = r0.hi, mid = r1.lo, hi = r1.hi; + hi += ibool(mid < tmp); + const lo2 = lo + mul.0; + const mid2 = mid + mul.1 + ibool(lo2 < lo); + const hi2 = hi + ibool(mid2 < mid); + const v_plus = u128rshift(mid2, hi2, (j - 64 - 1): u32); + const v_minus = if (mm_shift == 1) { + const lo3 = lo - mul.0; + const mid3 = mid - mul.1 - ibool(lo3 > lo); + const hi3 = hi - ibool(mid3 > mid); + u128rshift(mid3, hi3, (j - 64 - 1): u32); + } else { + const lo3 = lo + lo; + const mid3 = mid + mid + ibool(lo3 < lo); + const hi3 = hi + hi + ibool(mid3 < mid); + const lo4 = lo3 - mul.0; + const mid4 = mid3 - mul.1 - ibool(lo4 > lo3); + const hi4 = hi3 - ibool(mid4 > mid3); + u128rshift(mid4, hi4, (j - 64): u32); + }; + const v_rounded = u128rshift(mid, hi, (j - 64 - 1): u32); + return (v_plus, v_rounded, v_minus); +}; + +fn log2pow5(e: u32) i32 = { + assert(e <= 3528); + return ((e * 1217359) >> 19): i32; +}; + +fn ceil_log2pow5(e: u32) i32 = log2pow5(e) + 1; + +fn pow5bits(e: u32) i32 = ceil_log2pow5(e); + +fn log10pow2(e: u32) u32 = { + assert(e <= 1650); + return ((e * 78913) >> 18); +}; + +fn log10pow5(e: u32) u32 = { + assert(e <= 2620); + return ((e * 732923) >> 20); +}; + +def F64_POW5_INV_BITCOUNT: u8 = 125; +def F64_POW5_BITCOUNT: u8 = 125; + +const F64_POW5_INV_SPLIT2: [15][2]u64 = [ + [1, 2305843009213693952], + [5955668970331000884, 1784059615882449851], + [8982663654677661702, 1380349269358112757], + [7286864317269821294, 2135987035920910082], + [7005857020398200553, 1652639921975621497], + [17965325103354776697, 1278668206209430417], + [8928596168509315048, 1978643211784836272], + [10075671573058298858, 1530901034580419511], + [597001226353042382, 1184477304306571148], + [1527430471115325346, 1832889850782397517], + [12533209867169019542, 1418129833677084982], + [5577825024675947042, 2194449627517475473], + [11006974540203867551, 1697873161311732311], + [10313493231639821582, 1313665730009899186], + [12701016819766672773, 2032799256770390445], +]; + +const POW5_INV_OFFSETS: [19]u32 = [ + 0x54544554, 0x04055545, 0x10041000, 0x00400414, 0x40010000, 0x41155555, + 0x00000454, 0x00010044, 0x40000000, 0x44000041, 0x50454450, 0x55550054, + 0x51655554, 0x40004000, 0x01000001, 0x00010500, 0x51515411, 0x05555554, + 0x00000000 +]; + +const F64_POW5_SPLIT2: [13][2]u64 = [ + [0, 1152921504606846976], + [0, 1490116119384765625], + [1032610780636961552, 1925929944387235853], + [7910200175544436838, 1244603055572228341], + [16941905809032713930, 1608611746708759036], + [13024893955298202172, 2079081953128979843], + [6607496772837067824, 1343575221513417750], + [17332926989895652603, 1736530273035216783], + [13037379183483547984, 2244412773384604712], + [1605989338741628675, 1450417759929778918], + [9630225068416591280, 1874621017369538693], + [665883850346957067, 1211445438634777304], + [14931890668723713708, 1565756531257009982] +]; + +const POW5_OFFSETS: [21]u32 = [ + 0x00000000, 0x00000000, 0x00000000, 0x00000000, 0x40000000, 0x59695995, + 0x55545555, 0x56555515, 0x41150504, 0x40555410, 0x44555145, 0x44504540, + 0x45555550, 0x40004000, 0x96440440, 0x55565565, 0x54454045, 0x40154151, + 0x55559155, 0x51405555, 0x00000105 +]; + +def POW5_TABLE_SIZE: u8 = 26; + +const POW5_TABLE: [POW5_TABLE_SIZE]u64 = [ + 1u64, 5u64, 25u64, 125u64, 625u64, 3125u64, 15625u64, 78125u64, + 390625u64, 1953125u64, 9765625u64, 48828125u64, 244140625u64, + 1220703125u64, 6103515625u64, 30517578125u64, 152587890625u64, + 762939453125u64, 3814697265625u64, 19073486328125u64, 95367431640625u64, + 476837158203125u64, 2384185791015625u64, 11920928955078125u64, + 59604644775390625u64, 298023223876953125u64 //, 1490116119384765625u64 +]; + +fn f64computeinvpow5(i: u32) (u64, u64) = { + const base = ((i + POW5_TABLE_SIZE - 1) / POW5_TABLE_SIZE): u32; + const base2 = base * POW5_TABLE_SIZE; + const mul = F64_POW5_INV_SPLIT2[base]; + const off = base2 - i; + if (off == 0) { + return (mul[0], mul[1]); + }; + const m = POW5_TABLE[off]; + const r1 = u128mul(m, mul[1]), r0 = u128mul(m, mul[0] - 1); + let high1 = r1.hi, low1 = r1.lo, high0 = r0.hi, low0 = r0.lo; + const sum = high0 + low1; + if (sum < high0) { + high1 += 1; + }; + const delta = (pow5bits(base2) - pow5bits(i)): u32; + const res0 = u128rshift(low0, sum, delta) + 1 + + ((POW5_INV_OFFSETS[i / 16] >> ((i % 16) << 1)) & 3); + const res1 = u128rshift(sum, high1, delta); + return (res0, res1); +}; + +fn f64computepow5(i: u32) (u64, u64) = { + const base = i / POW5_TABLE_SIZE, base2 = base * POW5_TABLE_SIZE; + const mul = F64_POW5_SPLIT2[base]; + const off = i - base2; + if (off == 0) { + return (mul[0], mul[1]); + }; + const m = POW5_TABLE[off]; + const r1 = u128mul(m, mul[1]), r0 = u128mul(m, mul[0]); + let high1 = r1.hi, low1 = r1.lo, high0 = r0.hi, low0 = r0.lo; + const sum = high0 + low1; + if (sum < high0) { + high1 += 1; + }; + const delta = (pow5bits(i) - pow5bits(base2)): u32; + const res0 = u128rshift(low0, sum, delta) + + ((POW5_OFFSETS[i / 16] >> ((i % 16) << 1)) & 3); + const res1 = u128rshift(sum, high1, delta); + return (res0, res1); +}; + +type decf64 = struct { + mantissa: u64, + exponent: i32, +}; + +def F64_MANTISSA_BITS: u64 = 52; +def F64_EXPONENT_BITS: u64 = 11; +def F64_EXPONENT_BIAS: u16 = 1023; + +fn declen(n: u64) u8 = { + assert(n <= 1e17); + return if (n >= 1e17) 18 + else if (n >= 1e16) 17 + else if (n >= 1e15) 16 + else if (n >= 1e14) 15 + else if (n >= 1e13) 14 + else if (n >= 1e12) 13 + else if (n >= 1e11) 12 + else if (n >= 1e10) 11 + else if (n >= 1e9) 10 + else if (n >= 1e8) 9 + else if (n >= 1e7) 8 + else if (n >= 1e6) 7 + else if (n >= 1e5) 6 + else if (n >= 1e4) 5 + else if (n >= 1e3) 4 + else if (n >= 100) 3 + else if (n >= 10) 2 + else 1; +}; + +fn bintodec(mantissa: u64, exponent: u32) decf64 = { + let e2: i32 = 0, m2: u64 = 0; + if (exponent == 0) { + e2 = 1 - (F64_EXPONENT_BIAS + F64_MANTISSA_BITS): i32 - 2; + m2 = mantissa; + } else { + e2 = (exponent: i32) - (F64_EXPONENT_BIAS + F64_MANTISSA_BITS): i32 - 2; + m2 = (1u64 << F64_MANTISSA_BITS) | mantissa; + }; + const even = (m2 & 1) == 0, accept_bounds = even; + const mv = 4 * m2; + const mm_shift: u32 = ibool(mantissa != 0 || exponent <= 1); + let vp: u64 = 0, vr: u64 = 0, vm: u64 = 0; + let e10: i32 = 0; + let vm_trailing_zeros = false, vr_trailing_zeros = false; + if (e2 >= 0) { + const q = log10pow2(e2: u32) - ibool(e2 > 3); + e10 = q: i32; + const k = F64_POW5_INV_BITCOUNT: i32 + pow5bits(q) - 1; + const i = -e2 + (q: i32) + k; + let pow5 = f64computeinvpow5(q); + const res = mulshiftall64(m2, pow5, i, mm_shift); + vp = res.0; vr = res.1; vm = res.2; + if (q <= 21) { + if ((mv - 5 * (mv / 5)) == 0) { + vr_trailing_zeros = pow5multiple(mv, q); + } else if (accept_bounds) { + vm_trailing_zeros = pow5multiple(mv - 1 - mm_shift, q); + } else { + vp -= ibool(pow5multiple(mv + 2, q)); + }; + }; + } else { + const q = log10pow5((-e2): u32) - ibool(-e2 > 1); + e10 = e2 + (q: i32); + const i = -e2 - (q: i32); + const k = pow5bits(i: u32) - F64_POW5_BITCOUNT: i32; + const j = (q: i32) - k; + let pow5 = f64computepow5(i: u32); + const res = mulshiftall64(m2, pow5, j, mm_shift); + vp = res.0; vr = res.1; vm = res.2; + if (q <= 1) { + vr_trailing_zeros = true; + if (accept_bounds) { + vm_trailing_zeros = mm_shift == 1; + } else { + vp -= 1; + }; + } else if (q < 63) { + vr_trailing_zeros = pow2multiple(mv, q); + }; + }; + let removed: i32 = 0, last_removed_digit: u8 = 0; + let output: u64 = 0; + if (vm_trailing_zeros || vr_trailing_zeros) { + for (true) { + const vpby10 = vp / 10, vmby10 = vm / 10; + if (vpby10 <= vmby10) break; + const vmmod10 = (vm: u32) - 10 * (vmby10: u32); + const vrby10 = vr / 10; + const vrmod10 = (vr: u32) - 10 * (vrby10: u32); + vm_trailing_zeros = vm_trailing_zeros && (vmmod10 == 0); + vr_trailing_zeros = vr_trailing_zeros && + (last_removed_digit == 0); + last_removed_digit = vrmod10: u8; + vr = vrby10; vp = vpby10; vm = vmby10; + removed += 1; + }; + if (vm_trailing_zeros) { + for (true) { + const vmby10 = vm / 10; + const vmmod10 = (vm: u32) - 10 * (vmby10: u32); + if (vmmod10 != 0) break; + const vpby10 = vp / 10, vrby10 = vr / 10; + const vrmod10 = (vr: u32) - 10 * (vrby10: u32); + vr_trailing_zeros = vr_trailing_zeros && + (last_removed_digit == 0); + last_removed_digit = vrmod10: u8; + vr = vrby10; vp = vpby10; vm = vmby10; + removed += 1; + }; + }; + if (vr_trailing_zeros && last_removed_digit == 5 && (vr & 1 == 0)) { + // round to even + last_removed_digit = 4; + }; + output = vr + ibool((vr == vm && + (!accept_bounds || !vm_trailing_zeros)) || last_removed_digit >= 5); + } else { + let round_up = false; + const vpby100 = vp / 100, vmby100 = vm / 100; + if (vpby100 > vmby100) { + const vrby100 = vr / 100; + const vrmod100 = (vr: u32) - 100 * (vrby100: u32); + round_up = vrmod100 >= 50; + vr = vrby100; vp = vpby100; vm = vmby100; + removed += 2; + }; + for (true) { + const vmby10 = vm / 10, vpby10 = vp / 10; + if (vpby10 <= vmby10) break; + const vrby10 = vr / 10; + const vrmod10 = (vr: u32) - 10 * (vrby10: u32); + round_up = vrmod10 >= 5; + vr = vrby10; vp = vpby10; vm = vmby10; + removed += 1; + }; + output = vr + ibool(vr == vm || round_up); + }; + const exp = e10 + removed; + return decf64 { exponent = exp, mantissa = output }; +}; + +fn encode(buf: []u8, v: decf64) size = { + const zch = '0': u32: u8; + const n = v.mantissa, e = v.exponent, olen = declen(n); + const exp = e + olen: i32 - 1; + // use scientific notation for numbers whose exponent is beyond the + // precision available for f64 type + if (exp > -17 && exp < 17) { + if (e >= 0) { + let k = exp; + for (let a = e; a > 0; a -= 1) { + buf[k] = zch; + k -= 1; + }; + let m = n; + for (k >= 0; k -= 1) { + const mby10 = m / 10; + const mmod10 = (m: u32) - 10 * (mby10: u32); + buf[k] = zch + mmod10: u8; + m = mby10; + }; + return (e + olen: i32): size; + } else if (exp < 0) { + buf[0] = zch; + buf[1] = '.': u32: u8; + let k = -e + 1; + let m = n; + for (let a = olen: i32; a > 0; a -= 1) { + const mby10 = m / 10; + const mmod10 = (m: u32) - 10 * (mby10: u32); + buf[k] = zch + mmod10: u8; + k -= 1; + m = mby10; + }; + for (k > 1; k -= 1) { + buf[k] = zch; + }; + return (-e + 2): size; + } else { + let k = olen: i32; + let m = n; + for (let a = -e; a > 0; a -= 1) { + const mby10 = m / 10; + const mmod10 = (m: u32) - 10 * (mby10: u32); + buf[k] = zch + mmod10: u8; + k -= 1; + m = mby10; + }; + buf[k] = '.': u32: u8; + k -= 1; + for (k >= 0; k -= 1) { + const mby10 = m / 10; + const mmod10 = (m: u32) - 10 * (mby10: u32); + buf[k] = zch + mmod10: u8; + m = mby10; + }; + return (olen + 1): size; + }; + } else { + let h: i32 = 0; + let m = n; + if (olen == 1) { + buf[0] = zch + m: u8; + h = 1; + } else { + let k = olen: i32; + for (let a = k; a > 1; a -= 1) { + const mby10 = m / 10; + const mmod10 = (m: u32) - 10 * (mby10: u32); + buf[k] = zch + mmod10: u8; + k -= 1; + m = mby10; + }; + buf[k] = '.': u32: u8; + buf[0] = zch + m: u8; + h = olen: i32 + 1; + }; + buf[h] = 'e': u32: u8; + h += 1; + let ex = if (exp < 0) { + buf[h] = '-': u32: u8; + h += 1; + -exp; + } else exp; + const elen = declen(ex: u64); + let k = h + elen: i32 - 1; + for (let a = elen: i32; a > 0; a -= 1) { + const eby10 = ex / 10; + const emod10 = (ex: u32) - 10 * (eby10: u32); + buf[k] = zch + emod10: u8; + k -= 1; + ex = eby10; + }; + h += elen: i32; + return h: size; + }; +}; + +// Converts a f64 to a string in base 10. The return value is statically +// allocated and will be overwritten on subsequent calls; see [strings::dup] to +// duplicate the result. +export fn f64tos(n: f64) const str = { + // The biggest string produced by a f64 number in base 10 would have the + // negative sign, followed by a digit and decimal point, and then + // fifteen more decimal digits, followed by 'e' and another negative + // sign and the maximum of three digits for exponent. + // (1 + 1 + 1 + 15 + 1 + 1 + 3) = 23 + static let buf: [24]u8 = [0...]; + const bits = f64bits(n); + const sign = (bits >> (F64_MANTISSA_BITS + F64_EXPONENT_BITS)): size; + const mantissa = bits & ((1u64 << F64_MANTISSA_BITS) - 1); + const exponent = ((bits >> F64_MANTISSA_BITS) & + (1u64 << F64_EXPONENT_BITS) - 1): u32; + if (mantissa == 0 && exponent == 0) { + return "0"; + } else if (exponent == ((1 << F64_EXPONENT_BITS) - 1)) { + if (mantissa != 0) { + return "NaN"; + }; + return if (sign == 0) "Infinity" else "-Infinity"; + }; + const v = bintodec(mantissa, exponent); + if (sign != 0) { + buf[0] = '-': u32: u8; + }; + let z = encode(buf[sign..], v) + sign; + let s = types::string { data = &buf, length = z, ... }; + return *(&s: *str); +}; + +@test fn f64tos() void = { + assert(f64tos(0.0) == "0"); + assert(f64tos(1.0 / 0.0) == "Infinity"); + assert(f64tos(-1.0 / 0.0) == "-Infinity"); + assert(f64tos(0.0 / 0.0) == "NaN"); + assert(f64tos(1.0) == "1"); + assert(f64tos(0.3) == "0.3"); + assert(f64tos(0.0031415) == "0.0031415"); + assert(f64tos(0.0000012345678) == "0.0000012345678"); + assert(f64tos(1.414) == "1.414"); + assert(f64tos(1e234f64) == "1e234"); + // TODO: Negative exponents for floating point literals not implemented yet! + //assert(f64tos(1.2e-34) == "1.2e-34"); + assert(f64tos(-6345.9721) == "-6345.9721"); + assert(f64tos(1.23456789e67) == "1.23456789e67"); + assert(f64tos(11.2233445566778899e20) == "1.122334455667789e21"); + assert(f64tos(1000000.0e9) == "1000000000000000"); + assert(f64tos(9007199254740991.0) == "9007199254740991"); +}; + diff --git a/example/functions.ha b/example/functions.ha new file mode 100644 index 000000000..15c2f219a --- /dev/null +++ b/example/functions.ha @@ -0,0 +1,98 @@ +use rt; +use linux::vdso; + + +fn duration_to_timespec(n: duration, ts: *rt::timespec) void = { + ts.tv_sec = n / SECOND; + ts.tv_nsec = n % SECOND; +}; + +fn instant_to_timespec(t: instant, ts: *rt::timespec) void = { + ts.tv_sec = t.sec; + ts.tv_nsec = t.nsec; +}; + +fn timespec_to_instant(ts: rt::timespec) instant = instant { + sec = ts.tv_sec, + nsec = ts.tv_nsec, +}; + +// Yields the process to the kernel and returns after the requested duration. +export fn sleep(n: duration) void = { + let in = rt::timespec { ... }; + duration_to_timespec(n, &in); + let req = ∈ + + for (true) { + let res = rt::timespec { ... }; + match (rt::nanosleep(req, &res)) { + void => return, + err: rt::errno => switch (err) { + rt::EINTR => { + req = &res; + }, + * => abort("Unexpected error from nanosleep"), + }, + }; + }; +}; + +export type clock = enum { + // The current wall-clock time. This may jump forwards or backwards in + // time to account for leap seconds, NTP adjustments, etc. + REALTIME = 0, + + // The current monotonic time. This clock measures from some undefined + // epoch and is not affected by leap seconds, NTP adjustments, and + // changes to the system time: it always increases by one second per + // second. + MONOTONIC = 1, + + // Measures CPU time consumed by the calling process. + PROCESS_CPU = 2, + + // Time since the system was booted. Increases monotonically and, + // unlike [MONOTONIC], continues to tick while the system is suspended. + BOOT = 7, +}; + +let cgt_vdso: nullable *fn(_: int, _: *rt::timespec) int = null; + +fn get_cgt_vdso() nullable *fn(_: int, _: *rt::timespec) int = { + static let vdso_checked: bool = false; + if (vdso_checked) + return cgt_vdso; + vdso_checked = true; + + cgt_vdso = vdso::getsym(VDSO_CGT_SYM, VDSO_CGT_VER) + : nullable *fn(_: int, _: *rt::timespec) int; + return cgt_vdso; +}; + +fn now_vdso(clock: clock, tp: *rt::timespec) (void | rt::errno) = { + let vfn = match (get_cgt_vdso()) { + null => return rt::wrap_errno(rt::ENOSYS), + vfn: *fn(_: int, _: *rt::timespec) int => vfn, + }; + let ret = vfn(clock, tp); + if (ret == 0) { + return; + }; + return rt::wrap_errno(ret); +}; + +// Returns the current time for a given clock. +export fn now(clock: clock) instant = { + let tp = rt::timespec { ... }; + let err = match (now_vdso(clock, &tp)) { + void => return timespec_to_instant(tp), + err: rt::errno => err + }; + if (err != rt::wrap_errno(rt::ENOSYS)) { + abort("Unexpected error from clock_gettime"); + }; + return match (rt::clock_gettime(clock, &tp)) { + void => timespec_to_instant(tp), + err: rt::errno => abort("Unexpected error from clock_gettime"), + }; +}; diff --git a/example/getopts.ha b/example/getopts.ha new file mode 100644 index 000000000..7d479aa0f --- /dev/null +++ b/example/getopts.ha @@ -0,0 +1,307 @@ +// getopt provides an interface for parsing command line arguments and +// automatically generates a brief help message explaining the command usage. +// See [parse] for the main entry point. +// +// The help text is brief and should serve only as a reminder. It is recommended +// that your command line program be accompanied by a man page to provide +// detailed usage information. +use encoding::utf8; +use fmt; +use io; +use os; +use strings; + +// A flag which does not take a parameter, e.g. "-a". +export type flag = rune; + +// An option with an included parameter, e.g. "-a foo". +export type parameter = str; + +// A command line option. +export type option = (flag, parameter); + +// The result of parsing the set of command line arguments, including any +// options specified and the list of non-option arguments. +export type command = struct { + opts: []option, + args: []str, +}; + +// Help text providing a short, one-line summary of the command; or providing +// the name of an argument. +export type cmd_help = str; + +// Help text for a flag, formatted as "-a: help text". +export type flag_help = (flag, str); + +// Help text for a parameter, formatted as "-a param: help text" where "param" +// is the first string and "help text" is the second string. +export type parameter_help = (flag, str, str); + +// Help text for a command or option. +// +// cmd_help, flag_help, and parameter_help compose such that the help output for +// +// [ +// "foo bars in order", +// ('a', "a help text"), +// ('b', "b help text"), +// ('c', "cflag", "c help text"), +// ('d', "dflag", "d help text"), +// "files...", +// ] +// +// is: +// +// foo: foo bars in order +// +// Usage: foo [-ab] [-c ] [-d ] files... +// +// -a: a help text +// -b: b help text +// -c : c help text +// -d : d help text +export type help = (cmd_help | flag_help | parameter_help); + +// Parses command line arguments and returns a tuple of the options specified, +// and the remaining arguments. If an error occurs, details are printed to +// [os::stderr] and [os::exit] is called with a nonzero exit status. The +// argument list must include the command name as the first item; [os::args] +// fulfills this criteria. +// +// The caller provides [help] arguments to specify which command line flags and +// parameters are supported, and to provide some brief help text which describes +// their use. Provide [flag_help] to add a flag which does not take a parameter, +// and [parameter_help] to add a flag with a required parameter. The first +// [cmd_help] is used as a short, one-line summary of the command's purpose, and +// any later [cmd_help] arguments are used to provide the name of any arguments +// which follow the options list. +// +// By convention, the caller should sort the list of options, first providing +// all flags, then all parameters, alpha-sorted within each group by the flag +// rune. +// +// // Usage for sed +// let cmd = getopt::parse(os::args +// "stream editor", +// ('E', "use extended regular expressions"), +// ('s', "treat files as separate, rather than one continuous stream"), +// ('i', "edit files in place"), +// ('z', "separate lines by NUL characeters"), +// ('e', "script", "execute commands from script"), +// ('f', "file", "execute commands from a file"), +// "files...", +// ); +// defer getopt::finish(&cmd); +// +// for (let i = 0z; i < len(cmd.opts); i += 1) { +// let opt = cmd.opts[i]; +// switch (opt.0) { +// 'E' => extended = true, +// 's' => continuous = false, +// // ... +// 'e' => script = opt.1, +// 'f' => file = opt.1, +// }; +// }; +// +// for (let i = 0z; i < len(cmd.args); i += 1) { +// let arg = cmd.args[i]; +// // ... +// }; +// +// If "-h" is not among the options defined by the caller, the "-h" option will +// will cause a summary of the command usage to be printed to stderr, and +// [os::exit] will be called with a successful exit status. +export fn parse(args: []str, help: help...) command = { + let opts: []option = []; + let i = 1z; + :arg for (i < len(args); i += 1) { + const arg = args[i]; + if (len(arg) == 0 || arg == "-" + || !strings::has_prefix(arg, "-")) { + break; + }; + if (arg == "--") { + i += 1; + break; + }; + + let d = utf8::decode(arg); + assert(utf8::next(&d) as rune == '-'); + let next = utf8::next(&d); + :flag for (next is rune; next = utf8::next(&d)) { + const r = next as rune; + :help for (let j = 0z; j < len(help); j += 1) { + let p: parameter_help = match (help[j]) { + cmd_help => continue :help, + f: flag_help => if (r == f.0) { + append(opts, (r, "")); + continue :flag; + } else continue :help, + p: parameter_help => if (r == p.0) p + else continue :help, + }; + if (len(d.src) == d.offs) { + if (i + 1 >= len(args)) { + errmsg(args[0], "option requires an argument: ", + r, help); + os::exit(1); + }; + i += 1; + append(opts, (r, args[i])); + } else { + let s = strings::fromutf8(d.src[d.offs..]); + append(opts, (r, s)); + }; + continue :arg; + }; + if (r =='h') { + printhelp(os::stderr, args[0], help); + os::exit(0); + }; + errmsg(args[0], "unrecognized option: ", r, help); + os::exit(1); + }; + match (next) { + rune => abort(), // Unreachable + void => void, + (utf8::more | utf8::invalid) => { + errmsg(args[9], "invalid UTF-8 in arguments", + void, help); + os::exit(1); + }, + }; + }; + return command { + opts = opts, + args = args[i..], + }; +}; + +// Frees resources associated with the return value of [parse]. +export fn finish(cmd: *command) void = { + if (cmd == null) return; + free(cmd.opts); +}; + +fn _printusage(s: *io::stream, name: str, indent: bool, help: []help) size = { + let z = fmt::fprint(s, "Usage:", name) as size; + + let started_flags = false; + for (let i = 0z; i < len(help); i += 1) if (help[i] is flag_help) { + if (!started_flags) { + z += fmt::fprint(s, " [-") as size; + started_flags = true; + }; + const help = help[i] as flag_help; + z += fmt::fprint(s, help.0: rune) as size; + }; + if (started_flags) { + z += fmt::fprint(s, "]") as size; + }; + + for (let i = 0z; i < len(help); i += 1) if (help[i] is parameter_help) { + const help = help[i] as parameter_help; + if (indent) { + z += fmt::fprintf(s, "\n\t") as size; + }; + z += fmt::fprintf(s, " [-{} <{}>]", help.0: rune, help.1) as size; + }; + if (indent) { + z += fmt::fprintf(s, "\n\t") as size; + }; + for (let i = 1z; i < len(help); i += 1) if (help[i] is cmd_help) { + z += fmt::fprintf(s, " {}", help[i] as cmd_help: str) as size; + }; + + return z + fmt::fprint(s, "\n") as size; +}; + +// Prints command usage to the provided stream. +export fn printusage(s: *io::stream, name: str, help: []help) void = { + let z = _printusage(io::empty, name, false, help); + _printusage(s, name, if (z > 72) true else false, help); +}; + +// Prints command help to the provided stream. +export fn printhelp(s: *io::stream, name: str, help: []help) void = { + if (help[0] is cmd_help) { + fmt::fprintfln(s, "{}: {}\n", name, help[0] as cmd_help: str); + }; + + printusage(s, name, help); + + for (let i = 0z; i < len(help); i += 1) match (help[i]) { + cmd_help => void, + (flag_help | parameter_help) => { + // Only print this if there are flags to show + fmt::fprint(s, "\n"); + break; + }, + }; + + for (let i = 0z; i < len(help); i += 1) match (help[i]) { + cmd_help => void, + f: flag_help => { + fmt::fprintfln(s, "-{}: {}", f.0: rune, f.1); + }, + p: parameter_help => { + fmt::fprintfln(s, "-{} <{}>: {}", p.0: rune, p.1, p.2); + }, + }; +}; + +fn errmsg(name: str, err: str, opt: (rune | void), help: []help) void = { + fmt::errorfln("{}: {}{}", name, err, match (opt) { + r: rune => r, + void => "", + }); + printusage(os::stderr, name, help); +}; + +@test fn parse() void = { + let args: []str = ["cat", "-v", "a.out"]; + let cat = parse(args, + "concatenate files", + ('v', "cause Rob Pike to make a USENIX presentation"), + "files...", + ); + defer finish(&cat); + assert(len(cat.args) == 1 && cat.args[0] == "a.out"); + assert(len(cat.opts) == 1 && cat.opts[0].0 == 'v' && cat.opts[0].1 == ""); + + args = ["ls", "-Fahs", "--", "-j"]; + let ls = parse(args, + "list files", + ('F', "Do some stuff"), + ('h', "Do some other stuff"), + ('s', "Do a third type of stuff"), + ('a', "Do a fourth type of stuff"), + "files...", + ); + defer finish(&ls); + assert(len(ls.args) == 1 && ls.args[0] == "-j"); + assert(len(ls.opts) == 4); + assert(ls.opts[0].0 == 'F' && ls.opts[0].1 == ""); + assert(ls.opts[1].0 == 'a' && ls.opts[1].1 == ""); + assert(ls.opts[2].0 == 'h' && ls.opts[2].1 == ""); + assert(ls.opts[3].0 == 's' && ls.opts[3].1 == ""); + + args = ["sed", "-e", "s/C++//g", "-f/tmp/turing.sed", "-"]; + let sed = parse(args, + "edit streams", + ('e', "script", "Add the editing commands specified by the " + "script option to the end of the script of editing " + "commands"), + ('f', "script_file", "Add the editing commands in the file " + "script_file to the end of the script of editing " + "commands"), + "files...", + ); + defer finish(&sed); + assert(len(sed.args) == 1 && sed.args[0] == "-"); + assert(len(sed.opts) == 2); + assert(sed.opts[0].0 == 'e' && sed.opts[0].1 == "s/C++//g"); + assert(sed.opts[1].0 == 'f' && sed.opts[1].1 == "/tmp/turing.sed"); +}; diff --git a/example/getuid.ha b/example/getuid.ha new file mode 100644 index 000000000..da0d9ac22 --- /dev/null +++ b/example/getuid.ha @@ -0,0 +1,29 @@ +use rt; + +// Returns the current process user ID. +export fn getuid() uint = { + let uid = 0u, euid = 0u, suid = 0u; + rt::getresuid(&uid, &euid, &suid) as void; + return uid; +}; + +// Returns the current process effective user ID. +export fn geteuid() uint = { + let uid = 0u, euid = 0u, suid = 0u; + rt::getresuid(&uid, &euid, &suid) as void; + return euid; +}; + +// Returns the current process group ID. +export fn getgid() uint = { + let gid = 0u, egid = 0u, sgid = 0u; + rt::getresgid(&gid, &egid, &sgid) as void; + return gid; +}; + +// Returns the current process effective group ID. +export fn getegid() uint = { + let gid = 0u, egid = 0u, sgid = 0u; + rt::getresgid(&gid, &egid, &sgid) as void; + return egid; +}; diff --git a/example/hash.ha b/example/hash.ha new file mode 100644 index 000000000..48dd1459b --- /dev/null +++ b/example/hash.ha @@ -0,0 +1,46 @@ +use io; +// TODO: Let caller supply the output buffer, to avoid the slice allocation + +// The general purpose interface for a hashing function. +export type hash = struct { + // A stream which only supports writes and never returns errors. + stream: io::stream, + + // Returns the current hash. + sum: *fn(hash: *hash) []u8, + + // Resets the hash function to its initial state. + reset: *fn(hash: *hash) void, + + // Size of the hash in bytes. + sz: size, +}; + +// Returns a writable [io::stream] for a given hash. +export fn writer(h: *hash) *io::stream = &h.stream; + +// Writes an input to the hash function. +export fn write(h: *hash, buf: const []u8) size = + io::write(&h.stream, buf) as size; + +// Finalizes the hash, frees resources associated with the hash, and returns the +// sum. The return value is heap allocated, the caller needs to free it. +export fn finish(h: *hash) []u8 = { + let sum = sum(h); + io::close(&h.stream); + return sum; +}; + +// Closes a hash, freeing its resources and discarding the checksum. +export fn close(h: *hash) void = io::close(&h.stream); + +// Returns the current sum. The return value is heap allocated, the caller +// needs to free it. +export fn sum(h: *hash) []u8 = h.sum(h); + +// Resets the hash function to its initial state. +export fn reset(h: *hash) void = h.reset(h); + +// Returns the size of the hash in bytes. This is consistent regardless +// of the hash state. +export fn sz(h: *hash) size = h.sz; diff --git a/example/hex.ha b/example/hex.ha new file mode 100644 index 000000000..d1f7e5a5c --- /dev/null +++ b/example/hex.ha @@ -0,0 +1,117 @@ +use ascii; +use bytes; +use fmt; +use io; +use strconv; +use strings; +use strio; + +// Error returned when attempting to decode an invalid hex string. +export type invalid = void!; + +// Encodes a byte slice as a hexadecimal string and writes it to a stream. +export fn encode(sink: *io::stream, b: []u8) (size | io::error) = { + let z = 0z; + for (let i = 0z; i < len(b); i += 1) { + let s = strconv::u8tosb(b[i], strconv::base::HEX_LOWER); + if (len(s) == 1) { + z += io::write(sink, ['0': u32: u8])?; + }; + z += io::write(sink, strings::toutf8(s))?; + }; + return z; +}; + +// Encodes a byte slice as a hexadecimal string and returns it. The caller must +// free the return value. +export fn encodestr(b: []u8) str = { + let sink = strio::dynamic(); + encode(sink, b) as size; + return strio::finish(sink); +}; + +@test fn encode() void = { + let in: [_]u8 = [0xCA, 0xFE, 0xBA, 0xBE, 0xDE, 0xAD, 0xF0, 0x0D]; + let s = encodestr(in); + defer free(s); + assert(s == "cafebabedeadf00d"); +}; + +// Decodes a string of hexadecimal bytes into a byte slice. The caller must free +// the return value. +export fn decode(s: str) ([]u8 | invalid) = { + if (len(s) % 2 != 0) { + return invalid; + }; + let buf: []u8 = alloc([], len(s) / 2); + let s = strings::toutf8(s); + for (let i = 0z; i < len(s) / 2; i += 1) { + let oct = strings::fromutf8_unsafe(s[i * 2..i * 2 + 2]); + let u = match (strconv::stou8b(oct, 16)) { + (strconv::invalid | strconv::overflow) => return invalid, + u: u8 => u, + }; + append(buf, u); + }; + return buf; +}; + +@test fn decode() void = { + let s = decode("cafebabedeadf00d") as []u8; + defer free(s); + assert(bytes::equal(s, [0xCA, 0xFE, 0xBA, 0xBE, 0xDE, 0xAD, 0xF0, 0x0D])); + + decode("this is not hex") as invalid; +}; + +// Outputs a dump of hex data to a stream alongside the offset and an ASCII +// representation (if applicable). +// +// Example output: +// +// 00000000 7f 45 4c 46 02 01 01 00 00 00 00 00 00 00 00 00 |.ELF............| +// 00000010 03 00 3e 00 01 00 00 00 80 70 01 00 00 00 00 00 |..>......p......| +export fn dump(out: *io::stream, data: []u8) (void | io::error) = { + let datalen = len(data): u32; + + for (let off = 0u32; off < datalen; off += 16) { + fmt::fprintf(out, "{:08x} ", off)?; + + let toff = 0z; + for (let i = 0z; i < 16 && off + i < datalen; i += 1) { + let val = data[off + i]; + toff += fmt::fprintf(out, "{}{:02x} ", + if (i == 8) " " else "", val)?; + }; + + // Align ASCII representation, max width of hex part (48) + + // spacing around it + for (toff < 50; toff += 1) { + fmt::fprint(out, " ")?; + }; + + fmt::fprint(out, "|")?; + for (let i = 0z; i < 16 && off + i < datalen; i += 1) { + let r = data[off + i]: u32: rune; + + fmt::fprint(out, if (ascii::isprint(r)) r else '.')?; + }; + fmt::fprint(out, "|\n")?; + }; +}; + +@test fn dump() void = { + let in: [_]u8 = [ + 0x7F, 0x45, 0x4c, 0x46, 0x02, 0x01, 0x01, 0x00, 0xCA, 0xFE, + 0xBA, 0xBE, 0xDE, 0xAD, 0xF0, 0x0D, 0xCE, 0xFE, 0xBA, 0xBE, + 0xDE, 0xAD, 0xF0, 0x0D + ]; + + let sink = strio::dynamic(); + dump(sink, in) as void; + + let s = strio::finish(sink); + assert(s == + "00000000 7f 45 4c 46 02 01 01 00 ca fe ba be de ad f0 0d |.ELF............|\n" + "00000010 ce fe ba be de ad f0 0d |........|\n"); +}; diff --git a/example/host+aarch64.ha b/example/host+aarch64.ha new file mode 100644 index 000000000..9bccdb807 --- /dev/null +++ b/example/host+aarch64.ha @@ -0,0 +1,2 @@ +// The [endian] functions which map to the host architecture. +export const host: *endian = &little; diff --git a/example/host+x86_64.ha b/example/host+x86_64.ha new file mode 100644 index 000000000..9bccdb807 --- /dev/null +++ b/example/host+x86_64.ha @@ -0,0 +1,2 @@ +// The [endian] functions which map to the host architecture. +export const host: *endian = &little; diff --git a/example/ident.ha b/example/ident.ha new file mode 100644 index 000000000..c8cf34b8c --- /dev/null +++ b/example/ident.ha @@ -0,0 +1,31 @@ +use fmt; +use hare::ast; +use io; +use strio; + +// Unparses an identifier. +export fn ident(out: *io::stream, id: ast::ident) (size | io::error) = { + let n = 0z; + for (let i = 0z; i < len(id); i += 1) { + n += fmt::fprintf(out, "{}{}", id[i], + if (i + 1 < len(id)) "::" + else "")?; + }; + return n; +}; + +// Unparses an identifier into a string. The caller must free the return value. +export fn identstr(id: ast::ident) str = { + let buf = strio::dynamic(); + ident(buf, id); + return strio::finish(buf); +}; + +@test fn ident() void = { + let s = identstr(["foo", "bar", "baz"]); + assert(s == "foo::bar::baz"); + free(s); + s = identstr(["foo"]); + assert(s == "foo"); + free(s); +}; diff --git a/example/import.ha b/example/import.ha new file mode 100644 index 000000000..3508a6ff0 --- /dev/null +++ b/example/import.ha @@ -0,0 +1,52 @@ +use fmt; +use io; +use hare::ast; +use strio; + +export fn import(out: *io::stream, i: ast::import) (size | io::error) = { + let n = 0z; + n += fmt::fprint(out, "use ")?; + match (i) { + m: ast::import_module => n += ident(out, m)?, + a: ast::import_alias => { + n += fmt::fprint(out, a.alias, "= ")?; + n += ident(out, a.ident)?; + }, + o: ast::import_objects => { + n += ident(out, o.ident)?; + n += fmt::fprint(out, "::{")?; + for (let i = 0z; i < len(o.objects); i += 1) { + n += fmt::fprintf(out, "{}{}", o.objects[i], + if (i + 1 < len(o.objects)) ", " + else "")?; + }; + n += fmt::fprint(out, "}")?; + }, + }; + n += fmt::fprint(out, ";")?; + return n; +}; + +@test fn import() void = { + let buf = strio::dynamic(); + import(buf, ["foo", "bar", "baz"]) as size; + let s = strio::finish(buf); + assert(s == "use foo::bar::baz;"); + free(s); + buf = strio::dynamic(); + import(buf, ast::import_alias { + ident = ["foo"], + alias = "bar", + }) as size; + s = strio::finish(buf); + assert(s == "use bar = foo;"); + free(s); + buf = strio::dynamic(); + import(buf, ast::import_objects { + ident = ["foo"], + objects = ["bar", "baz"], + }) as size; + s = strio::finish(buf); + assert(s == "use foo::{bar, baz};"); + free(s); +}; diff --git a/example/index.ha b/example/index.ha new file mode 100644 index 000000000..3d32e18dc --- /dev/null +++ b/example/index.ha @@ -0,0 +1,25 @@ +use bytes; + +// Returns the index of the first occurance of 'needle' in the 'haystack', or +// void if not present. The index returned is the rune-wise index, not the +// byte-wise index. +export fn index(haystack: str, needle: (str | rune)) (size | void) = { + return match (needle) { + r: rune => index_rune(haystack, r), + s: str => abort(), // TODO + }; +}; + +fn index_rune(s: str, r: rune) (size | void) = { + let iter = iter(s); + for (let i = 0z; true; i += 1) match (next(&iter)) { + n: rune => if (r == n) return i, + void => break, + }; +}; + +@test fn index() void = { + assert(index("hello world", 'w') as size == 6); + assert(index("こんにちは", 'ち') as size == 3); + assert(index("こんにちは", 'q') is void); +}; diff --git a/example/ip.ha b/example/ip.ha new file mode 100644 index 000000000..8e907800f --- /dev/null +++ b/example/ip.ha @@ -0,0 +1,327 @@ +use io; +use strio; +use fmt; +use bytes; +use rt; +use strconv; +use strings; + +// An IPv4 address. +export type addr4 = [4]u8; + +// An IPv6 address. +export type addr6 = [16]u8; + +// An IP address. +export type addr = (addr4 | addr6); + +// An IP subnet. +export type subnet = struct { + addr: addr, + mask: addr, +}; + +// An IPv4 address which represents "any" address, i.e. "0.0.0.0". Binding to +// this address will listen on all available IPv4 interfaces on most systems. +export const ANY_V4: addr4 = [0, 0, 0, 0]; + +// An IPv6 address which represents "any" address, i.e. "::". Binding to this +// address will listen on all available IPv6 interfaces on most systems. +export const ANY_V6: addr6 = [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]; + +// Invalid parse result. +export type invalid = void!; + +// Test if two [addr]s are equal. +export fn equal(l: addr, r: addr) bool = { + return match (l) { + l: addr4 => { + if (!(r is addr4)) { + return false; + }; + let r = r as addr4; + bytes::equal(l, r); + }, + l: addr6 => { + if (!(r is addr6)) { + return false; + }; + let r = r as addr6; + bytes::equal(l, r); + }, + }; +}; + +fn parsev4(st: str) (addr4 | invalid) = { + let ret: addr4 = [0...]; + let tok = strings::tokenize(st, "."); + let i = 0z; + for (i < 4; i += 1) { + let s = wanttoken(&tok)?; + ret[i] = match (strconv::stou8(s)) { + term: u8 => term, + * => return invalid + }; + }; + if (i < 4 || !(strings::next_token(&tok) is void)) { + return invalid; + }; + return ret; +}; + +fn parsev6(st: str) (addr6 | invalid) = { + let ret: addr6 = [0...]; + let tok = strings::tokenize(st, ":"); + if (st == "::") { + return ret; + }; + let ells = -1; + if (strings::has_prefix(st, "::")) { + wanttoken(&tok)?; + wanttoken(&tok)?; + ells = 0; + } else if (strings::has_prefix(st, ":")) { + return invalid; + }; + let i = 0; + for (i < 16) { + let s = match (strings::next_token(&tok)) { + s: str => s, + void => break, + }; + if (s == "") { + if (ells != -1) { + return invalid; + }; + ells = i; + continue; + }; + let val = strconv::stou16b(s, 16); + if (val is u16) { + let v = val as u16; + ret[i] = (v >> 8): u8; + i += 1; + ret[i] = v: u8; + i += 1; + continue; + } else { + let v4 = parsev4(s)?; + rt::memcpy(&ret[i], &v4, 4); + i += 4; + break; + }; + return invalid; + }; + if (!(strings::next_token(&tok) is void)) { + return invalid; + }; + if (ells >= 0) { + if (i >= 15) { + return invalid; + }; + rt::memcpy( + &ret[16 - (i - ells)], + &ret[ells], (i - ells): size); + rt::memset(&ret[ells], 0, (i - ells): size); + } else { + if (i != 16) + return invalid; + }; + + return ret; +}; + + +// Parses an IP address. +export fn parse(s: str) (addr | invalid) = { + match(parsev4(s)) { + v4: addr4 => return v4, + }; + match(parsev6(s)) { + v6: addr6 => return v6, + }; + return invalid; +}; + +fn fmtv4(s: *io::stream, a: addr4) (io::error | size) = { + let ret = 0z; + for (let i = 0; i < 4; i += 1) { + if (i > 0) { + ret += fmt::fprintf(s, ".")?; + }; + ret += fmt::fprintf(s, "{}", a[i])?; + }; + return ret; +}; + +fn fmtv6(s: *io::stream, a: addr6) (io::error | size) = { + let ret = 0z; + let zstart: int = -1; + let zend: int = -1; + for (let i = 0; i < 16; i += 2) { + let j = i; + for (j < 16 && a[j] == 0 && a[j + 1] == 0) { + j += 2; + }; + + if (j > i && j - i > zend - zstart) { + zstart = i; + zend = j; + i = j; + }; + }; + + if (zend - zstart <= 2) { + zstart = -1; + zend = -1; + }; + + for (let i = 0; i < 16; i += 2) { + if (i == zstart) { + ret += fmt::fprintf(s, "::")?; + i = zend; + if (i >= 16) + break; + } else if (i > 0) { + ret += fmt::fprintf(s, ":")?; + }; + let term = (a[i]: u16) << 8 | a[i + 1]; + ret += fmt::fprintf(s, "{:x}", term)?; + }; + return ret; +}; + +// Fills a netmask according to the CIDR value +// e.g. 23 -> [0xFF, 0xFF, 0xFD, 0x00] +fn fillmask(mask: []u8, val: u8) void = { + rt::memset(&mask[0], 0xFF, len(mask)); + let i: int = len(mask): int - 1; + val = 32 - val; + for (val >= 8) { + mask[i] = 0x00; + val -= 8; + i -= 1; + }; + if (i >= 0) { + mask[i] = ~((1 << val) - 1); + }; +}; + +// Returns an addr representing a netmask +fn cidrmask(addr: addr, val: u8) (addr | invalid) = { + let a_len: u8 = match (addr) { + addr4 => 4, + addr6 => 16, + }; + + if (val > 8 * a_len) + return invalid; + if (a_len == 4) { + let ret: addr4 = [0...]; + fillmask(ret[..], val); + return ret; + }; + if (a_len == 16) { + let ret: addr6 = [0...]; + fillmask(ret[..], val); + return ret; + }; + return invalid; +}; + +// Parse an IP subnet in CIDR notation e.g. 192.168.1.0/24 +export fn parsecidr(st: str) (subnet | invalid) = { + let tok = strings::tokenize(st, "/"); + let ips = wanttoken(&tok)?; + let addr = parse(ips)?; + let masks = wanttoken(&tok)?; + let val = match (strconv::stou8(masks)) { + x: u8 => x, + * => return invalid, + }; + if (!(strings::next_token(&tok) is void)) { + return invalid; + }; + return subnet { + addr = addr, + mask = cidrmask(addr, val)? + }; +}; + +fn masklen(addr: []u8) (void | size) = { + let n = 0z; + for (let i = 0z; i < len(addr); i += 1) { + if (addr[i] == 0xff) { + n += 8; + continue; + }; + let val = addr[i]; + for (val & 0x80 != 0) { + n += 1; + val <<= 1; + }; + if (val != 0) + return; + for (let j = i + 1; j < len(addr); j += 1) { + if (addr[j] != 0) + return; + }; + break; + }; + return n; +}; + +fn fmtmask(s: *io::stream, mask: addr) (io::error | size) = { + let ret = 0z; + let slice = match (mask) { + v4: addr4 => v4[..], + v6: addr6 => v6[..], + }; + match (masklen(slice)) { + // format as hex, if zero runs are not contiguous + // (like golang does) + void => { + for (let i = 0z; i < len(slice); i += 1) { + ret += fmt::fprintf(s, "{:x}", slice[i])?; + }; + }, + // standard CIDR integer + n: size => ret += fmt::fprintf(s, "{}", n)?, + }; + return ret; +}; + +fn fmtsubnet(s: *io::stream, subnet: subnet) (io::error | size) = { + let ret = 0z; + ret += fmt(s, subnet.addr)?; + ret += fmt::fprintf(s, "/")?; + ret += fmtmask(s, subnet.mask)?; + return ret; +}; + +// Formats an [addr] or [subnet] and prints it to a stream. +export fn fmt(s: *io::stream, item: (...addr | subnet)) (io::error | size) = { + return match (item) { + v4: addr4 => fmtv4(s, v4)?, + v6: addr6 => fmtv6(s, v6)?, + sub: subnet => fmtsubnet(s, sub), + }; +}; + +// Formats an [addr] or [subnet] as a string. The return value is statically +// allocated and will be overwritten on subsequent calls; see [strings::dup] to +// extend its lifetime. +export fn string(item: (...addr | subnet)) str = { + // Maximum length of an IPv6 address plus its netmask in hexadecimal + static let buf: [64]u8 = [0...]; + let stream = strio::fixed(buf); + fmt(stream, item) as size; + return strio::string(stream); +}; + +fn wanttoken(tok: *strings::tokenizer) (str | invalid) = { + return match (strings::next_token(tok)) { + s: str => s, + void => invalid + }; +}; diff --git a/example/iter.ha b/example/iter.ha new file mode 100644 index 000000000..7b8aba22f --- /dev/null +++ b/example/iter.ha @@ -0,0 +1,111 @@ +use encoding::utf8; + +// An iterator which yields each rune from a string. +export type iterator = struct { + dec: utf8::decoder, + push: (rune | void), +}; + +// Initializes a string iterator, starting at the beginning of the string. +export fn iter(src: str) iterator = iterator { + dec = utf8::decode(src), + push = void, +}; + +// Initializes a string iterator, starting at the end of the string. +export fn riter(src: str) iterator = { + let ret = iterator { + dec = utf8::decode(src), + push = void, + }; + ret.dec.offs = len(src); + return ret; +}; + +// Get the next rune from an iterator, or void if there are none left. +// +// Be aware that a rune is not the minimum lexographical unit of language in +// Unicode strings. If you use these runes to construct a new string, +// reordering, editing, or omitting any of the runes without careful discretion +// may cause linguistic errors to arise. To avoid this, you may need to use +// [unicode::graphiter] instead. +export fn next(iter: *iterator) (rune | void) = { + match (iter.push) { + r: rune => { + iter.push = void; + return r; + }, + void => void, + }; + return match (utf8::next(&iter.dec)) { + r: rune => r, + void => void, + (utf8::more | utf8::invalid) => + abort("Invalid UTF-8 string (this should not happen)"), + }; +}; + +// Get the previous rune from an iterator, or void when at the start of the +// string. +export fn prev(iter: *iterator) (rune | void) = { + assert(iter.push is void); + return match (utf8::prev(&iter.dec)) { + r: rune => r, + void => void, + (utf8::more | utf8::invalid) => + abort("Invalid UTF-8 string (this should not happen)"), + }; +}; + +// Causes the next call to [next] to return the provided rune, effectively +// un-reading it. The next call using this iterator *must* be [next]; all other +// functions will cause the program to abort until the pushed rune is consumed. +// This does not modify the underlying string, and as such, subsequent calls to +// functions like [prev] or [iter_str] will behave as if push were never called. +export fn push(iter: *iterator, r: rune) void = { + assert(iter.push is void); + iter.push = r; +}; + +// Return a substring from the next rune to the end of the string. +export fn iter_str(iter: *iterator) str = { + assert(iter.push is void); + return fromutf8(iter.dec.src[iter.dec.offs..]); +}; + +@test fn iter() void = { + let s = iter("こんにちは"); + assert(prev(&s) is void); + const expected1 = ['こ', 'ん']; + for (let i = 0z; i < len(expected1); i += 1) { + match (next(&s)) { + r: rune => assert(r == expected1[i]), + void => abort(), + }; + }; + assert(iter_str(&s) == "にちは"); + assert(prev(&s) as rune == 'ん'); + const expected2 = ['ん', 'に', 'ち', 'は']; + for (let i = 0z; i < len(expected2); i += 1) { + match (next(&s)) { + r: rune => assert(r == expected2[i]), + void => abort(), + }; + }; + assert(next(&s) is void); + assert(next(&s) is void); + push(&s, 'q'); + assert(next(&s) as rune == 'q'); + assert(prev(&s) as rune == 'は'); + + s = riter("にちは"); + const expected3 = ['は', 'ち', 'に']; + for (let i = 0z; i< len(expected3); i += 1) { + match (prev(&s)) { + r: rune => assert(r == expected3[i]), + void => abort(), + }; + }; + assert(prev(&s) is void); + assert(next(&s) as rune == 'に'); +}; diff --git a/example/itos.ha b/example/itos.ha new file mode 100644 index 000000000..7182f26e6 --- /dev/null +++ b/example/itos.ha @@ -0,0 +1,106 @@ +use bytes; +use types; +use strings; + +// Converts an i64 to a string in the given base. The return value is statically +// allocated and will be overwritten on subsequent calls; see [strings::dup] to +// duplicate the result. +export fn i64tosb(i: i64, b: base) const str = { + static assert(types::I64_MAX == 9223372036854775807); + if (i >= 0) return u64tosb(i: u64, b); + + static let buf: [65]u8 = [0...]; // 64 binary digits plus - + + let s = types::string { data = &buf, ... }; + + buf[0] = '-': u32: u8; + s.length = 1; + + let u = strings::toutf8(u64tosb((-i): u64, b)); + assert(len(u) < len(buf)); + + bytes::copy(buf[1..len(u) + 1], u); + s.length += len(u); + + return *(&s: *str); +}; + +// Converts a i32 to a string in the given base. The return value is statically +// allocated and will be overwritten on subsequent calls; see [strings::dup] to +// duplicate the result. +export fn i32tosb(i: i32, b: base) const str = i64tosb(i, b); + +// Converts a i16 to a string in the given base. The return value is statically +// allocated and will be overwritten on subsequent calls; see [strings::dup] to +// duplicate the result. +export fn i16tosb(i: i16, b: base) const str = i64tosb(i, b); + +// Converts a i8 to a string in the given base. The return value is statically +// allocated and will be overwritten on subsequent calls; see [strings::dup] to +// duplicate the result. +export fn i8tosb(i: i8, b: base) const str = i64tosb(i, b); + +// Converts an int to a string in the given base. The return value is +// statically allocated and will be overwritten on subsequent calls; see +// [strings::dup] to duplicate the result. +export fn itosb(i: int, b: base) const str = i64tosb(i, b); + +// Converts a i64 to a string in base 10. The return value is statically +// allocated and will be overwritten on subsequent calls; see [strings::dup] to +// duplicate the result. +export fn i64tos(i: i64) const str = i64tosb(i, base::DEC); + +// Converts a i32 to a string in base 10. The return value is statically +// allocated and will be overwritten on subsequent calls; see [strings::dup] to +// duplicate the result. +export fn i32tos(i: i32) const str = i64tos(i); + +// Converts a i16 to a string in base 10. The return value is statically +// allocated and will be overwritten on subsequent calls; see [strings::dup] to +// duplicate the result. +export fn i16tos(i: i16) const str = i64tos(i); + +// Converts a i8 to a string in base 10. The return value is statically +// allocated and will be overwritten on subsequent calls; see [strings::dup] to +// duplicate the result. +export fn i8tos(i: i8) const str = i64tos(i); + +// Converts a int to a string in base 10. The return value is statically +// allocated and will be overwritten on subsequent calls; see [strings::dup] to +// duplicate the result. +export fn itos(i: int) const str = i64tos(i); + +@test fn itosb() void = { + assert("11010" == i64tosb(0b11010, base::BIN)); + assert("1234567" == i64tosb(0o1234567, base::OCT)); + assert("123456789" == i64tosb(123456789, base::DEC)); + assert("123456789ABCDEF" == i64tosb(0x123456789ABCDEF, base::HEX)); + assert("123456789ABCDEF" == i64tosb(0x123456789ABCDEF, base::HEX_UPPER)); + assert("123456789abcdef" == i64tosb(0x123456789ABCDEF, base::HEX_LOWER)); + assert("-1000000000000000000000000000000000000000000000000000000000000000" + == i64tosb(types::I64_MIN, base::BIN)); +}; + +@test fn itos() void = { + const samples: [_]i64 = [ + 1234, + 4321, + -1337, + 0, + types::I64_MAX, + types::I64_MIN, + ]; + const expected = [ + "1234", + "4321", + "-1337", + "0", + "9223372036854775807", + "-9223372036854775808", + ]; + + for (let i = 0z; i < len(samples); i += 1) { + const s = i64tos(samples[i]); + assert(s == expected[i]); + }; +}; diff --git a/example/jmp.ha b/example/jmp.ha new file mode 100644 index 000000000..30712ecc6 --- /dev/null +++ b/example/jmp.ha @@ -0,0 +1 @@ +type arch_jmpbuf = [22]u64; diff --git a/example/join.ha b/example/join.ha new file mode 100644 index 000000000..432501b2d --- /dev/null +++ b/example/join.ha @@ -0,0 +1,65 @@ +use bytes; +use bufio; +use strings; +use io; + +// Joins together several path components with the path separator. The caller +// must free the return value. +export fn join(paths: str...) str = { + // TODO: Normalize inputs so that if they end with a / we don't double + // up on delimiters + let sink = bufio::dynamic(io::mode::WRITE); + let utf8 = true; + for (let i = 0z; i < len(paths); i += 1) { + let buf = strings::toutf8(paths[i]); + let l = len(buf); + if (l == 0) continue; + for (l > 0 && buf[l - 1] == PATHSEP) { + l -= 1; + }; + for (let q = 0z; q < l) { + let w = io::write(sink, buf[q..l]) as size; + q += w; + }; + if (i + 1 < len(paths)) { + assert(io::write(sink, [PATHSEP]) as size == 1); + }; + }; + + return strings::fromutf8_unsafe(bufio::finish(sink)); +}; + +@test fn join() void = { + assert(PATHSEP == '/': u32: u8); // TODO: meh + let i = join("foo"); + defer free(i); + assert(i == "foo"); + + let p = join(i, "bar", "baz"); + defer free(p); + assert(p == "foo/bar/baz"); + + let q = join(p, "bat", "bad"); + defer free(q); + assert(q == "foo/bar/baz/bat/bad"); + + let r = join(p, q); + defer free(r); + assert(r == "foo/bar/baz/foo/bar/baz/bat/bad"); + + let p = join("foo/", "bar"); + defer free(p); + assert(p == "foo/bar"); + + let p = join("foo///", "bar"); + defer free(p); + assert(p == "foo/bar"); + + let p = join("foo", "", "bar"); + defer free(p); + assert(p == "foo/bar"); + + let p = join("/", "foo", "bar", "baz"); + defer free(p); + assert(p == "/foo/bar/baz"); +}; diff --git a/example/lex.ha b/example/lex.ha new file mode 100644 index 000000000..759e55b73 --- /dev/null +++ b/example/lex.ha @@ -0,0 +1,524 @@ +// hare::lex provides a lexer for Hare source code. +use ascii; +use bufio; +use encoding::utf8; +use fmt; +use io; +use sort; +use strconv; +use strings; + +// State associated with a lexer. +export type lexer = struct { + in: *io::stream, + path: str, + loc: (uint, uint), + un: ((token, location) | void), + rb: [2](rune | io::EOF | void), +}; + +// A syntax error +export type syntax = (location, str)!; + +// All possible lexer errors +export type error = (io::error | syntax)!; + +// Returns a human-friendly string for a given error +export fn strerror(err: error) const str = { + static let buf: [2048]u8 = [0...]; + return match (err) { + err: io::error => io::strerror(err), + s: syntax => fmt::bsprintf(buf, "{}:{},{}: Syntax error: {}", + s.0.path, s.0.line, s.0.col, s.1), + }; +}; + +// Initializes a new lexer for the given input stream. The path is borrowed. +export fn init(in: *io::stream, path: str) lexer = lexer { + in = in, + path = path, + loc = (1, 1), + un = void, + rb = [void...], +}; + +// Returns the next token from the lexer. +export fn lex(lex: *lexer) ((token, location) | io::EOF | error) = { + match (lex.un) { + tok: (token, location) => { + lex.un = void; + return tok; + }, + void => void, + }; + + let loc = location { ... }; + let r: rune = match (nextw(lex)?) { + io::EOF => return io::EOF, + r: (rune, location) => { + loc = r.1; + r.0; + }, + }; + + if (is_name(r, false)) { + unget(lex, r); + return lex_name(lex, loc); + }; + if (ascii::isdigit(r)) { + unget(lex, r); + abort(); // TODO: Literals + }; + + let tok: token = switch (r) { + * => return syntaxerr(loc, "invalid character"), + '"', '\'' => { + unget(lex, r); + return lex_rn_str(lex, loc); + }, + '.', '<', '>' => return lex3(lex, loc, r), + '^', '*', '%', '/', '+', '-', ':', '!', '&', '|', '=' => { + return lex2(lex, loc, r); + }, + '~' => btoken::BNOT, + ',' => btoken::COMMA, + '{' => btoken::LBRACE, + '[' => btoken::LBRACKET, + '(' => btoken::LPAREN, + '}' => btoken::RBRACE, + ']' => btoken::RBRACKET, + ')' => btoken::RPAREN, + ';' => btoken::SEMICOLON, + '?' => btoken::QUESTION, + }; + return (tok, loc); +}; + +fn is_name(r: rune, num: bool) bool = + ascii::isalpha(r) || r == '_' || r == '@' || (num && ascii::isdigit(r)); + +fn ncmp(a: const *void, b: const *void) int = { + let a = a: const *str, b = b: const *str; + return match (ascii::strcmp(*a, *b)) { + void => abort("non-ascii name"), // TODO: Bubble me up + i: int => i, + }; +}; + +fn lex_unicode(lex: *lexer, loc: location, n: size) (rune | error) = { + assert(n < 9); + let buf: [9]u8 = [0...]; + for (let i = 0z; i < n; i += 1z) { + let r = match (next(lex)?) { + io::EOF => return syntaxerr(loc, + "unexpected EOF scanning for escape"), + r: rune => r, + }; + if (!ascii::isxdigit(r)) { + return syntaxerr(loc, + "unexpected rune scanning for escape"); + }; + buf[i] = r: u32: u8; + }; + let s = strings::fromutf8_unsafe(buf[..n]); + return strconv::stou32b(s, strconv::base::HEX) as u32: rune; +}; + +fn lex_rune(lex: *lexer, loc: location) (rune | error) = { + let r = match (next(lex)?) { + io::EOF => return syntaxerr(loc, + "unexpected EOF scanning for rune"), + r: rune => r, + }; + if (r != '\\') { + return r; + }; + r = match (next(lex)?) { + io::EOF => return syntaxerr(loc, + "unexpected EOF scanning for escape"), + r: rune => r, + }; + return switch (r) { + '\\' => '\\', + '\'' => '\'', + '0' => '\0', + 'a' => '\a', + 'b' => '\b', + 'f' => '\f', + 'n' => '\n', + 'r' => '\r', + 't' => '\t', + 'v' => '\v', + '"' => '\"', + 'x' => lex_unicode(lex, loc, 2), + 'u' => lex_unicode(lex, loc, 4), + 'U' => lex_unicode(lex, loc, 8), + }; +}; + +fn lex_string( + lex: *lexer, + loc: location, +) ((token, location) | io::EOF | error) = { + let chars: []u8 = []; + for (true) match (next(lex)?) { + io::EOF => return syntaxerr(loc, "unexpected EOF scanning string literal"), + r: rune => + if (r == '"') break + else { + unget(lex, r); + r = lex_rune(lex, loc)?; + append(chars, ...utf8::encoderune(r)); + }, + }; + return (strings::fromutf8(chars): literal, loc); +}; + +fn lex_rn_str( + lex: *lexer, + loc: location, +) ((token, location) | io::EOF | error) = { + let r = match (next(lex)) { + r: rune => r, + (io::EOF | io::error) => abort(), + }; + switch (r) { + '\"' => return lex_string(lex, loc), + '\'' => void, + * => abort(), // Invariant + }; + + // Rune literal + let ret: (token, location) = (lex_rune(lex, loc)?: literal, loc); + match (next(lex)?) { + io::EOF => + return syntaxerr(loc, "unexpected EOF"), + n: rune => if (n != '\'') + return syntaxerr(loc, "expected \"\'\""), + }; + return ret; +}; + +fn lex_name( + lex: *lexer, + loc: location, +) ((token, location) | io::EOF | error) = { + let chars: []u8 = []; + match (next(lex)) { + r: rune => { + assert(is_name(r, false)); + append(chars, ...utf8::encoderune(r)); + }, + (io::EOF | io::error) => abort(), + }; + + for (true) match (next(lex)?) { + io::EOF => break, + r: rune => { + if (!is_name(r, true)) { + unget(lex, r); + break; + }; + append(chars, ...utf8::encoderune(r)); + }, + }; + + let n = strings::fromutf8(chars); + return match (sort::search(bmap[..btoken::LAST_KEYWORD+1], + size(str), &n, &ncmp)) { + // TODO: Validate that names are ASCII + null => (n: name: token, loc), + v: *void => { + let tok = v: uintptr - &bmap[0]: uintptr; + tok /= size(str): uintptr; + (tok: btoken: token, loc); + }, + }; +}; + +fn lex2( + lexr: *lexer, + loc: location, + r: rune, +) ((token, location) | io::EOF | error) = { + let n = match (next(lexr)?) { + io::EOF => io::EOF, + r: rune => r, + }; + let tok: token = switch (r) { + '^' => match (n) { + r: rune => switch (r) { + '^' => return (btoken::LXOR: token, loc), + '=' => return (btoken::BXOREQ: token, loc), + * => btoken::BXOR, + }, + io::EOF => btoken::BXOR, + }, + '*' => match (n) { + r: rune => switch (r) { + '=' => return (btoken::TIMESEQ: token, loc), + * => btoken::TIMES, + }, + io::EOF => btoken::TIMES, + }, + '/' => match (n) { + r: rune => switch (r) { + '=' => return (btoken::DIVEQ: token, loc), + '/' => { + // Comment + for (true) match (next(lexr)?) { + io::EOF => break, + r: rune => if (r == '\n') { + break; + }, + }; + return lex(lexr); + }, + * => btoken::DIV, + }, + io::EOF => btoken::DIV, + }, + '%' => match (n) { + r: rune => switch (r) { + '=' => return (btoken::MODEQ: token, loc), + * => btoken::MODULO, + }, + io::EOF => btoken::MODULO, + }, + '+' => match (n) { + r: rune => switch (r) { + '=' => return (btoken::PLUSEQ: token, loc), + * => btoken::PLUS, + }, + io::EOF => btoken::PLUS, + }, + '-' => match (n) { + r: rune => switch (r) { + '=' => return (btoken::MINUSEQ: token, loc), + * => btoken::MINUS, + }, + io::EOF => btoken::MINUS, + }, + ':' => match (n) { + r: rune => switch (r) { + ':' => return (btoken::DOUBLE_COLON: token, loc), + * => btoken::COLON, + }, + io::EOF => btoken::COLON, + }, + '!' => match (n) { + r: rune => switch (r) { + '=' => return (btoken::NEQUAL: token, loc), + * => btoken::LNOT, + }, + io::EOF => btoken::LNOT, + }, + '&' => match (n) { + r: rune => switch (r) { + '&' => return (btoken::LAND: token, loc), + '=' => return (btoken::ANDEQ: token, loc), + * => btoken::BAND, + }, + io::EOF => btoken::BAND, + }, + '|' => match (n) { + r: rune => switch (r) { + '|' => return (btoken::LOR: token, loc), + '=' => return (btoken::OREQ: token, loc), + * => btoken::BOR, + }, + io::EOF => btoken::BOR, + }, + '=' => match (n) { + r: rune => switch (r) { + '=' => return (btoken::LEQUAL: token, loc), + * => btoken::EQUAL, + }, + io::EOF => btoken::EQUAL, + }, + * => return syntaxerr(loc, "unknown token sequence"), + }; + unget(lexr, n); + return (tok, loc); +}; + +fn lex3( + lex: *lexer, + loc: location, + r: rune, +) ((token, location) | io::EOF | error) = { + let n = match (next(lex)?) { + io::EOF => return switch (r) { + '.' => (btoken::DOT: token, loc), + '<' => (btoken::LESS: token, loc), + '>' => (btoken::GREATER: token, loc), + }, + r: rune => r, + }; + return switch (r) { + '.' => lex3dot(lex, loc, n), + '<' => lex3lt(lex, loc, n), + '>' => lex3gt(lex, loc, n), + * => syntaxerr(loc, "unknown token sequence"), + }; +}; + +fn lex3dot( + lex: *lexer, + loc: location, + n: rune, +) ((token, location) | io::EOF | error) = { + let tok: token = switch (n) { + '.' => { + let q = match (next(lex)?) { + io::EOF => io::EOF, + r: rune => r, + }; + let t = match (q) { + r: rune => switch (r) { + '.' => return (btoken::ELLIPSIS: token, loc), + * => btoken::SLICE, + }, + io::EOF => btoken::SLICE, + }; + unget(lex, q); + t; + }, + * => { + unget(lex, n); + btoken::DOT; + } + }; + return (tok, loc); +}; + +fn lex3lt( + lex: *lexer, + loc: location, + n: rune, +) ((token, location) | io::EOF | error) = { + let tok: token = switch (n) { + '<' => { + let q = match (next(lex)?) { + io::EOF => io::EOF, + r: rune => r, + }; + let t = match (q) { + r: rune => switch (r) { + '=' => return (btoken::LSHIFTEQ: token, loc), + * => btoken::LSHIFT, + }, + io::EOF => btoken::LSHIFT, + }; + unget(lex, q); + t; + }, + '=' => btoken::LESSEQ, + * => { + unget(lex, n); + btoken::LESS; + } + }; + return (tok, loc); +}; + +fn lex3gt( + lex: *lexer, + loc: location, + n: rune, +) ((token, location) | io::EOF | error) = { + let tok: token = switch (n) { + '>' => { + let q = match (next(lex)?) { + io::EOF => io::EOF, + r: rune => r, + }; + let t = match (q) { + r: rune => switch (r) { + '=' => return (btoken::RSHIFTEQ: token, loc), + * => btoken::RSHIFT, + }, + io::EOF => btoken::RSHIFT, + }; + unget(lex, q); + t; + }, + '=' => btoken::GREATEREQ, + * => { + unget(lex, n); + btoken::GREATER; + } + }; + return (tok, loc); +}; + +// Unlex a single token. The next call to [lex] will return this token, location +// pair. Only one unlex is supported at a time; you must call [lex] before +// calling [unlex] again. +export fn unlex(lex: *lexer, tok: (token, location)) void = { + assert(lex.un is void, "attempted to unlex more than one token"); + lex.un = tok; +}; + +fn next(lex: *lexer) (rune | io::EOF | io::error) = { + match (lex.rb[0]) { + void => void, + r: (rune | io::EOF) => { + lex.rb[0] = lex.rb[1]; + lex.rb[1] = void; + return r; + }, + }; + + for (true) { + return match (bufio::scanrune(lex.in)) { + e: (io::EOF | io::error) => e, + r: rune => { + lexloc(lex, r); + r; + }, + }; + }; + + abort("unreachable"); +}; + +fn nextw(lex: *lexer) ((rune, location) | io::EOF | io::error) = { + for (true) { + let loc = mkloc(lex); + match (next(lex)) { + e: (io::error | io::EOF) => return e, + r: rune => if (!ascii::isspace(r)) { + return (r, loc); + }, + }; + }; + abort(); +}; + +fn lexloc(lex: *lexer, r: rune) void = { + switch (r) { + '\n' => { + lex.loc.0 += 1; + lex.loc.1 = 1; + }, + '\t' => lex.loc.1 += 8, + * => lex.loc.1 += 1, + }; +}; + +fn unget(lex: *lexer, r: (rune | io::EOF)) void = { + if (!(lex.rb[0] is void)) { + assert(lex.rb[1] is void, "ungot too many runes"); + lex.rb[1] = lex.rb[0]; + }; + lex.rb[0] = r; +}; + +fn mkloc(lex: *lexer) location = location { + path = lex.path, + line = lex.loc.0, + col = lex.loc.1, +}; + +fn syntaxerr(loc: location, why: str) error = (loc, why); diff --git a/example/limit.ha b/example/limit.ha new file mode 100644 index 000000000..563c01104 --- /dev/null +++ b/example/limit.ha @@ -0,0 +1,60 @@ +use strings; + +type limited_stream = struct { + stream: stream, + source: *stream, + limit: size, +}; + +fn limited_stream_new(source: *stream, limit: size) *limited_stream = { + return alloc(limited_stream { + stream = stream { + name = strings::dup(source.name), + closer = &limited_close, + ... + }, + source = source, + limit = limit, + }); +}; + +// Create an overlay stream that only allows a limited amount of bytes to be +// read from the underlying stream. +export fn limitreader(source: *stream, limit: size) *stream = { + let stream = limited_stream_new(source, limit); + stream.stream.reader = &limited_read; + return &stream.stream; +}; + +// Create an overlay stream that only allows a limited amount of bytes to be +// written to the underlying stream. +export fn limitwriter(source: *stream, limit: size) *stream = { + let stream = limited_stream_new(source, limit); + stream.stream.writer = &limited_write; + return &stream.stream; +}; + +fn limited_read(s: *stream, buf: []u8) (size | EOF | error) = { + let stream = s: *limited_stream; + if (len(buf) > stream.limit) { + buf = buf[..stream.limit]; + }; + stream.limit -= len(buf); + return read(stream.source, buf); +}; + +fn limited_write(s: *stream, buf: const []u8) (size | error) = { + let stream = s: *limited_stream; + let slice = if (len(buf) > stream.limit) { + buf[..stream.limit]; + } else { + buf[..]; + }; + stream.limit -= len(slice); + return write(stream.source, slice); +}; + +fn limited_close(s: *stream) void = { + free(s.name); + free(s); +}; diff --git a/example/limits.ha b/example/limits.ha new file mode 100644 index 000000000..3fc8d302f --- /dev/null +++ b/example/limits.ha @@ -0,0 +1,54 @@ +// Minimum value which can be stored in an i8 type. +export def I8_MIN: i8 = -128; + +// Maximum value which can be stored in an i8 type. +export def I8_MAX: i8 = 127; + +// Minimum value which can be stored in an i16 type. +export def I16_MIN: i16 = -32708; + +// Maximum value which can be stored in an i16 type. +export def I16_MAX: i16 = 32707; + +// Minimum value which can be stored in an i32 type. +export def I32_MIN: i32 = -2147483648; + +// Maximum value which can be stored in an i32 type. +export def I32_MAX: i32 = 2147483647; + +// Minimum value which can be stored in an i64 type +export def I64_MIN: i64 = -9223372036854775808; + +// Maximum value which can be stored in an i64 type. +export def I64_MAX: i64 = 9223372036854775807; + + +// Minimum value which can be stored in a u8 type. +export def U8_MIN: u8 = 0; + +// Maximum value which can be stored in a u8 type. +export def U8_MAX: u8 = 255; + +// Minimum value which can be stored in a u16 type +export def U16_MIN: u16 = 0; + +// Maximum value which can be stored in a u16 type. +export def U16_MAX: u16 = 65535; + +// Minimum value which can be stored in a u32 type +export def U32_MIN: u32 = 0; + +// Maximum value which can be stored in a u32 type. +export def U32_MAX: u32 = 4294967295; + +// Minimum value which can be stored in a u64 type +export def U64_MIN: u64 = 0; + +// Maximum value which can be stored in a u64 type. +export def U64_MAX: u64 = 18446744073709551615; + +// Maximum value which can be stored in a rune. +export def RUNE_MIN: rune = U32_MIN: rune; + +// Maximum value which can be stored in a rune. +export def RUNE_MAX: rune = U32_MAX: rune; diff --git a/example/little.ha b/example/little.ha new file mode 100644 index 000000000..1bf79d838 --- /dev/null +++ b/example/little.ha @@ -0,0 +1,73 @@ +// Reads a u16 from a buffer in little-endian order. +export fn legetu16(buf: []u8) u16 = { + return + (buf[1] << 8u16) | + (buf[0] << 0); +}; + +// Writes a u16 into a buffer in little-endian order. +export fn leputu16(buf: []u8, in: u16) void = { + buf[0] = (in >> 0): u8; + buf[1] = (in >> 8): u8; +}; + +// Reads a u32 from a buffer in little-endian order. +export fn legetu32(buf: []u8) u32 = { + return + (buf[3] << 24u32) | + (buf[2] << 16u32) | + (buf[1] << 8u32) | + (buf[0] << 0); +}; + +// Writes a u32 into a buffer in little-endian order. +export fn leputu32(buf: []u8, in: u32) void = { + buf[0] = (in): u8; + buf[1] = (in >> 8): u8; + buf[2] = (in >> 16): u8; + buf[3] = (in >> 24): u8; +}; + +// Reads a u64 from a buffer in little-endian order. +export fn legetu64(buf: []u8) u64 = { + return + (buf[7] << 56u64) | + (buf[6] << 48u64) | + (buf[5] << 40u64) | + (buf[4] << 32u64) | + (buf[3] << 24u64) | + (buf[2] << 16u64) | + (buf[1] << 8u64) | + (buf[0] << 0); +}; + +// Writes a u64 into a buffer in little-endian order. +export fn leputu64(buf: []u8, in: u64) void = { + buf[0] = (in >> 0): u8; + buf[1] = (in >> 8): u8; + buf[2] = (in >> 16): u8; + buf[3] = (in >> 24): u8; + buf[4] = (in >> 32): u8; + buf[5] = (in >> 40): u8; + buf[6] = (in >> 48): u8; + buf[7] = (in >> 56): u8; +}; + +@test fn little() void = { + let buf: [8]u8 = [0...]; + leputu16(buf, 0x1234); + assert(buf[0] == 0x34 && buf[1] == 0x12); + assert(legetu16(buf) == 0x1234); + + leputu32(buf, 0x12345678); + assert(buf[0] == 0x78 && buf[1] == 0x56 + && buf[2] == 0x34 && buf[3] == 0x12); + assert(legetu32(buf) == 0x12345678); + + leputu64(buf, 0x1234567887654321); + assert(buf[0] == 0x21 && buf[1] == 0x43 + && buf[2] == 0x65 && buf[3] == 0x87 + && buf[4] == 0x78 && buf[5] == 0x56 + && buf[6] == 0x34 && buf[7] == 0x12); + assert(legetu64(buf) == 0x1234567887654321); +}; diff --git a/example/main.ha b/example/main.ha new file mode 100644 index 000000000..f66c269ef --- /dev/null +++ b/example/main.ha @@ -0,0 +1,25 @@ +use getopt; +use os; + +export fn main() void = { + let help: []getopt::help = [ + "compile, run, and test Hare programs", + "", "args...", + ]; + let cmd = getopt::parse(os::args, help...); + defer getopt::finish(&cmd); + if (len(cmd.args) < 1) { + getopt::printusage(os::stderr, os::args[0], help...); + os::exit(1); + }; + if (cmd.args[0] == "build") build(cmd.args) + else if (cmd.args[0] == "cache") cache(cmd.args) + else if (cmd.args[0] == "deps") deps(cmd.args) + else if (cmd.args[0] == "run") run(cmd.args) + else if (cmd.args[0] == "test") test(cmd.args) + else if (cmd.args[0] == "version") version(cmd.args) + else { + getopt::printusage(os::stderr, os::args[0], help...); + os::exit(1); + }; +}; diff --git a/example/malloc.ha b/example/malloc.ha new file mode 100644 index 000000000..eac4cd2d1 --- /dev/null +++ b/example/malloc.ha @@ -0,0 +1,163 @@ +// This is a simple memory allocator, based on Appel, Andrew W., and David A. +// Naumann. "Verified sequential malloc/free." It is not thread-safe. +// +// Large allocations are handled with mmap. +// +// For small allocations, we set up 50 bins, where each bin is responsible for +// 16 different allocation sizes (e.g. bin 1 handles allocations from 10 thru 26 +// bytes); except for the first and last bin, which are responsible for fewer +// than 16 allocation sizes. +// +// Each bin is 1MiB (BIGBLOCK) in size. We ceil the allocation size to the +// largest size supported for this bin, then break the bin up into smaller +// blocks. Each block is structured as [{sz: size, data..., link: *void}...]; +// where sz is the size of this (small) block, data is is set aside for the +// user's actual allocation, and link is a pointer to the next bin's data field. +// +// In short, a bin for a particular size is pre-filled with all allocations of +// that size, and the first word of each allocation is set to a pointer to the +// next allocation. As such, malloc becomes: +// +// 1. Look up bin; pre-fill if not already allocated +// 2. Let p = bin; bin = *bin; return p +// +// Then, free is simply: +// 1. Look up bin +// 2. *p = bin; +// 3. bin = p; +// +// Note that over time this can cause the ordering of the allocations in each +// bin to become non-continuous. This has no consequences for performance or +// correctness. + +def ALIGN: size = 2; +def WORD: size = size(size); +def WASTE: size = WORD * ALIGN - WORD; +def BIGBLOCK: size = (2 << 16) * WORD; + +let bins: [50]nullable *void = [null...]; + +fn bin2size(b: size) size = ((b + 1) * ALIGN - 1) * WORD; + +fn size2bin(s: size) size = { + assert(s <= bin2size(len(bins) - 1), "Size exceeds maximum for bin"); + return (s + (WORD * (ALIGN - 1) - 1)) / (WORD * ALIGN); +}; + +// Allocates n bytes of memory and returns a pointer to them, or null if there +// is insufficient memory. +export fn malloc(n: size) nullable *void = { + return if (n == 0) null + else if (n > bin2size(len(bins) - 1)) malloc_large(n) + else malloc_small(n); +}; + +fn malloc_large(n: size) nullable *void = { + let p = segmalloc(n + WASTE + WORD); + if (p == null) { + return null; + }; + let bsize = (p: uintptr + WASTE: uintptr): *[1]size; + bsize[0] = n; + return (p: uintptr + WASTE: uintptr + WORD: uintptr): nullable *void; +}; + +fn malloc_small(n: size) nullable *void = { + const b = size2bin(n); + let p = bins[b]; + if (p == null) { + p = fill_bin(b); + if (p != null) { + bins[b] = p; + }; + }; + return if (p != null) { + let q = *(p: **void); + bins[b] = q; + p; + } else null; +}; + +fn fill_bin(b: size) nullable *void = { + const s = bin2size(b); + let p = segmalloc(BIGBLOCK); + return if (p == null) null else list_from_block(s, p: uintptr); +}; + +fn list_from_block(s: size, p: uintptr) nullable *void = { + const nblocks = (BIGBLOCK - WASTE) / (s + WORD); + + let q = p + WASTE: uintptr; // align q+WORD + for (let j = 0z; j != nblocks - 1; j += 1) { + let sz = q: *size; + let useralloc = q + WORD: uintptr; // aligned + let next = (useralloc + s: uintptr + WORD: uintptr): *void; + *sz = s; + *(useralloc: **void) = next; + q += s: uintptr + WORD: uintptr; + }; + + // Terminate last block: + (q: *[1]size)[0] = s; + *((q + 1: uintptr): *nullable *void) = null; + + // Return first block: + return (p + WASTE: uintptr + WORD: uintptr): *void; +}; + +// Frees a pointer previously allocated with [malloc]. +export @symbol("rt.free") fn free_(_p: nullable *void) void = { + if (_p != null) { + let p = _p: *void; + let bsize = (p: uintptr - size(size): uintptr): *[1]size; + let s = bsize[0]; + if (s <= bin2size(len(bins) - 1)) free_small(p, s) + else free_large(p, s); + }; +}; + +fn free_large(_p: *void, s: size) void = { + let p = (_p: uintptr - (WASTE: uintptr + WORD: uintptr)): *void; + segfree(p, s + WASTE + WORD); +}; + +fn free_small(p: *void, s: size) void = { + let b = size2bin(s); + let q = bins[b]; + *(p: **void) = q; + bins[b] = p: nullable *void; +}; + +// Changes the allocation size of a pointer to n bytes. If n is smaller than +// the prior allocation, it is truncated; otherwise the allocation is expanded +// and the values of the new bytes are undefined. May return a different pointer +// than the one given if there is insufficient space to expand the pointer +// in-place. Returns null if there is insufficient memory to support the +// request. +export fn realloc(_p: nullable *void, n: size) nullable *void = { + if (n == 0) { + free_(_p); + return null; + } else if (_p == null) { + return malloc(n); + }; + + let p = _p: *void; + let bsize = (p: uintptr - size(size): uintptr): *size; + let s = *bsize; + if (s >= n) { + return p; + }; + + if (n < bin2size(len(bins) - 1) && size2bin(n) == size2bin(s)) { + return p; + }; + + let new = malloc(n); + if (new != null) { + memcpy(new: *void, p, s); + free(p); + }; + + return new; +}; diff --git a/example/manifest.ha b/example/manifest.ha new file mode 100644 index 000000000..5912bc26f --- /dev/null +++ b/example/manifest.ha @@ -0,0 +1,333 @@ +use bufio; +use bytes; +use encoding::hex; +use encoding::utf8; +use errors; +use fmt; +use fs; +use hare::ast; +use hare::unparse; +use io; +use os; +use path; +use strconv; +use strings; +use time; + +// The manifest file format is a series of line-oriented records. Lines starting +// with # are ignored. +// +// - "version" indicates the manifest format version, currently 1. +// - "input" is an input file, and its fields are the file hash, path, inode, +// and mtime as a Unix timestamp. +// - "module" is a version of a module, and includes the module hash and the set +// of input hashes which produce it. + +def VERSION: int = 1; + +fn getinput(in: []input, hash: []u8) nullable *input = { + for (let i = 0z; i < len(in); i += 1) { + if (bytes::equal(in[i].hash, hash)) { + return &in[i]; + }; + }; + return null; +}; + +// Loads the module manifest from the build cache for the given ident. The +// return value borrows the ident parameter. If the module is not found, an +// empty manifest is returned. +export fn manifest_load(ctx: *context, ident: ast::ident) (manifest | error) = { + let manifest = manifest { + ident = ident, + inputs = [], + versions = [], + }; + let ipath = identpath(manifest.ident); + defer free(ipath); + let cachedir = path::join(ctx.cache, ipath); + defer free(cachedir); + + let mpath = path::join(cachedir, "manifest"); + defer free(mpath); + + // TODO: We can probably eliminate these locks by using atomic writes + // instead + let l = lock(ctx.fs, cachedir)?; + defer unlock(ctx.fs, cachedir, l); + + let file = match (fs::open(ctx.fs, mpath, fs::flags::RDONLY)) { + errors::noentry => return manifest, + err: fs::error => return err, + file: *io::stream => file, + }; + defer io::close(file); + + let inputs: []input = [], versions: []version = []; + + let buf: [4096]u8 = [0...]; + let file = bufio::buffered(file, buf, []); + for (true) { + let line = match (bufio::scanline(file)?) { + io::EOF => break, + line: []u8 => match (strings::try_fromutf8(line)) { + // Treat an invalid manifest as empty + utf8::invalid => return manifest, + s: str => s, + }, + }; + defer free(line); + + if (strings::has_prefix(line, "#")) { + continue; + }; + + let tok = strings::tokenize(line, " "); + let kind = match (strings::next_token(&tok)) { + void => continue, + s: str => s, + }; + + if (kind == "version") { + let ver = match (strings::next_token(&tok)) { + void => return manifest, + s: str => s, + }; + match (strconv::stoi(ver)) { + v: int => if (v != VERSION) { + return manifest; + }, + * => return manifest, + }; + } else if (kind == "input") { + let hash = match (strings::next_token(&tok)) { + void => return manifest, s: str => s, + }, path = match (strings::next_token(&tok)) { + void => return manifest, s: str => s, + }, inode = match (strings::next_token(&tok)) { + void => return manifest, s: str => s, + }, mtime = match (strings::next_token(&tok)) { + void => return manifest, s: str => s, + }; + + let hash = match (hex::decode(hash)) { + * => return manifest, + b: []u8 => b, + }; + let inode = match (strconv::stoz(inode)) { + * => return manifest, + z: size => z, + }; + let mtime = match (strconv::stoi64(mtime)) { + * => return manifest, + i: i64 => time::from_unix(i), + }; + + let parsed = parse_name(path); + let ftype = match (type_for_ext(path)) { + void => return manifest, + ft: filetype => ft, + }; + + append(inputs, input { + hash = hash, + path = strings::dup(path), + ft = ftype, + stat = fs::filestat { + mask = fs::stat_mask::MTIME | fs::stat_mask::INODE, + mtime = mtime, + inode = inode, + }, + basename = strings::dup(parsed.0), + tags = parsed.2, + }); + } else if (kind == "module") { + let modhash = match (strings::next_token(&tok)) { + void => return manifest, s: str => s, + }; + let modhash = match (hex::decode(modhash)) { + * => return manifest, + b: []u8 => b, + }; + + let minputs: []input = []; + for (true) { + let hash = match (strings::next_token(&tok)) { + void => break, + s: str => s, + }; + let hash = match (hex::decode(hash)) { + * => return manifest, + b: []u8 => b, + }; + defer free(hash); + + let input = match (getinput(inputs, hash)) { + null => return manifest, + i: *input => i, + }; + append(minputs, *input); + }; + + append(versions, version { + hash = modhash, + inputs = minputs, + }); + } else { + return manifest; + }; + + // Check for extra tokens + match (strings::next_token(&tok)) { + void => void, + s: str => return manifest, + }; + }; + + manifest.inputs = inputs; + manifest.versions = versions; + return manifest; +}; + +// Returns true if the desired module version is present and current in this +// manifest. +export fn current(manifest: *manifest, version: *version) bool = { + // TODO: This is kind of dumb. What we really need to do is: + // 1. Update scan to avoid hashing the file if a manifest is present, + // and indicate that the hash is cached somewhere in the type. Get an + // up-to-date stat. + // 2. In [current], test if the inode and mtime are equal to the + // manifest version. If so, presume the file is up-to-date. If not, + // check the hash and update the manifest to the new inode/mtime if + // the hash matches. If not, the module is not current; rebuild. + let cached: nullable *version = null; + for (let i = 0z; i < len(manifest.versions); i += 1) { + if (bytes::equal(manifest.versions[i].hash, version.hash)) { + cached = &manifest.versions[i]; + break; + }; + }; + let cached = match (cached) { + null => return false, + v: *version => v, + }; + + assert(len(cached.inputs) == len(version.inputs)); + for (let i = 0z; i < len(cached.inputs); i += 1) { + let a = cached.inputs[i], b = cached.inputs[i]; + assert(a.path == b.path); + let ast = a.stat, bst = b.stat; + if (ast.inode != bst.inode + || time::compare(ast.mtime, bst.mtime) != 0) { + return false; + }; + }; + return true; +}; + +// Writes a module manifest to the build cache. +export fn manifest_write(ctx: *context, manifest: *manifest) (void | error) = { + let ipath = identpath(manifest.ident); + defer free(ipath); + let cachedir = path::join(ctx.cache, ipath); + defer free(cachedir); + + let mpath = path::join(cachedir, "manifest"); + defer free(mpath); + + let l = lock(ctx.fs, cachedir)?; + defer unlock(ctx.fs, cachedir, l); + + let fd = fs::create(ctx.fs, mpath, 0o644)?; + defer io::close(fd); + + let ident = unparse::identstr(manifest.ident); + defer free(ident); + fmt::fprintfln(fd, "# {}", ident)?; + fmt::fprintln(fd, "# This file is an internal Hare implementation detail.")?; + fmt::fprintln(fd, "# The format is not stable.")?; + fmt::fprintfln(fd, "version {}", VERSION)?; + for (let i = 0z; i < len(manifest.inputs); i += 1) { + const input = manifest.inputs[i]; + let hash = hex::encodestr(input.hash); + defer free(hash); + + const want = fs::stat_mask::INODE | fs::stat_mask::MTIME; + assert(input.stat.mask & want == want); + fmt::fprintfln(fd, "input {} {} {} {}", + hash, input.path, input.stat.inode, + time::unix(input.stat.mtime)); + }; + + for (let i = 0z; i < len(manifest.versions); i += 1) { + const ver = manifest.versions[i]; + let hash = hex::encodestr(ver.hash); + defer free(hash); + + fmt::fprintf(fd, "module {}", hash); + + for (let j = 0z; j < len(ver.inputs); j += 1) { + let hash = hex::encodestr(ver.inputs[i].hash); + defer free(hash); + + fmt::fprintf(fd, " {}", hash); + }; + + fmt::fprintln(fd); + }; +}; + +fn lock(fs: *fs::fs, cachedir: str) (*io::stream | error) = { + // XXX: I wonder if this should be some generic function in fs or + // something + match (os::mkdirs(cachedir)) { + errors::exists => void, + void => void, + e: fs::error => return e, + }; + let lockpath = path::join(cachedir, "manifest.lock"); + defer free(lockpath); + + let logged = false; + for (true) { + match (fs::create(fs, lockpath, 0o644, fs::flags::EXCL)) { + fd: *io::stream => return fd, + (errors::busy | errors::exists) => void, + err: fs::error => return err, + }; + if (!logged) { + fmt::errorfln("Waiting for lock on {}...", lockpath); + logged = true; + }; + time::sleep(1 * time::SECOND); + }; + + abort("Unreachable"); +}; + +fn unlock(fs: *fs::fs, cachedir: str, s: *io::stream) void = { + let lockpath = path::join(cachedir, "manifest.lock"); + defer free(lockpath); + match (fs::remove(fs, lockpath)) { + void => void, + err: fs::error => abort("Error removing module lock"), + }; +}; + +fn input_finish(in: *input) void = { + free(in.hash); + free(in.path); + free(in.basename); + tags_free(in.tags); +}; + +// Frees resources associated with this manifest. +export fn manifest_finish(m: *manifest) void = { + for (let i = 0z; i < len(m.inputs); i += 1) { + input_finish(&m.inputs[i]); + }; + + for (let i = 0z; i < len(m.versions); i += 1) { + free(m.versions[i].inputs); + }; +}; diff --git a/example/md5.ha b/example/md5.ha new file mode 100644 index 000000000..91c0e0f0e --- /dev/null +++ b/example/md5.ha @@ -0,0 +1,232 @@ +use hash; +use io; +use crypto::math; +use endian; + +// The size, in bytes, of a MD5 digest. +export def SIZE: size = 16; + +def chunk: size = 64; +def init0: u32 = 0x67452301; +def init1: u32 = 0xEFCDAB89; +def init2: u32 = 0x98BADCFE; +def init3: u32 = 0x10325476; + +type digest = struct { + hash: hash::hash, + h: [4]u32, + x: [chunk]u8, + nx: size, + ln: size, +}; + +// Creates a [hash::hash] which computes a MD5 hash as defined in RFC 1321. Note +// that MD5 is cryptographically broken and should not be used for secure +// applications. Where possible, applications are encouraged to use [sha256] or +// [sha512] instead. +export fn md5() *hash::hash = { + let md5 = alloc(digest { + hash = hash::hash { + stream = io::stream { + writer = &write, + closer = &close, + ... + }, + sum = &sum, + reset = &reset, + sz = SIZE, + ... + }, + }); + let hash = &md5.hash; + hash::reset(hash); + return hash; +}; + +fn write(st: *io::stream, buf: const []u8) (size | io::error) = { + let h = st: *digest; + let b: []u8 = buf; + let nn = len(buf); + + h.ln += nn; + + if (h.nx > 0) { + // Compute how many bytes can be copied into h.x + let r = len(h.x) - h.nx; + let n = if (nn > r) r else nn; + h.x[h.nx..] = b[..n]; + h.nx += n; + if (h.nx == chunk) { + block(h, h.x[..]); + h.nx = 0; + }; + b = b[n..]; + }; + if (len(b) >= chunk) { + let n = len(b) & ~(chunk - 1); + block(h, b[..n]); + b = b[n..]; + }; + if (len(b) > 0) { + let n = len(b); + h.x[..n] = b[..]; + h.nx = n; + }; + return nn; +}; + +fn close(st: *io::stream) void = free(st); + +fn reset(h: *hash::hash) void = { + let h = h: *digest; + h.h[0] = init0; + h.h[1] = init1; + h.h[2] = init2; + h.h[3] = init3; + h.nx = 0; + h.ln = 0; +}; + +fn sum(h: *hash::hash) []u8 = { + let h = h: *digest; + let copy = *h; + let h = © + + // Padding. Add a 1 bit and 0 bits until 56 bytes mod 64. + let ln = h.ln; + let tmp: [1 + 63 + 8]u8 = [0x80, 0...]; + const pad = (55 - ln) % 64; + endian::leputu32(tmp[1+pad..], (ln << 3) : u32); + write(&h.hash.stream, tmp[..1+pad+8]); // append the length in bits + + assert(h.nx == 0); + + // Where we write the digest + let d: [SIZE]u8 = [0...]; + endian::leputu32(d[0..], h.h[0]); + endian::leputu32(d[4..], h.h[1]); + endian::leputu32(d[8..], h.h[2]); + endian::leputu32(d[12..], h.h[3]); + + let slice: []u8 = alloc([], SIZE); + append(slice, ...d); + return slice; +}; + +// A generic, pure Hare version of the MD5 block step +fn block(h: *digest, p: []u8) void = { + // load state + let a = h.h[0]; + let b = h.h[1]; + let c = h.h[2]; + let d = h.h[3]; + + for (len(p) >= chunk; p = p[chunk..]) { + + // save current state + let aa = a, bb = b, cc = c, dd = d; + + // load input block + let x0 = endian::legetu32(p[4 * 0x0..]); + let x0 = endian::legetu32(p[4 * 0x0..]); + let x1 = endian::legetu32(p[4 * 0x1..]); + let x2 = endian::legetu32(p[4 * 0x2..]); + let x3 = endian::legetu32(p[4 * 0x3..]); + let x4 = endian::legetu32(p[4 * 0x4..]); + let x5 = endian::legetu32(p[4 * 0x5..]); + let x6 = endian::legetu32(p[4 * 0x6..]); + let x7 = endian::legetu32(p[4 * 0x7..]); + let x8 = endian::legetu32(p[4 * 0x8..]); + let x9 = endian::legetu32(p[4 * 0x9..]); + let xa = endian::legetu32(p[4 * 0xa..]); + let xb = endian::legetu32(p[4 * 0xb..]); + let xc = endian::legetu32(p[4 * 0xc..]); + let xd = endian::legetu32(p[4 * 0xd..]); + let xe = endian::legetu32(p[4 * 0xe..]); + let xf = endian::legetu32(p[4 * 0xf..]); + + // round 1 + a = b + math::rotl32((((c^d)&b)^d)+a+x0+0xd76aa478, 7); + d = a + math::rotl32((((b^c)&a)^c)+d+x1+0xe8c7b756, 12); + c = d + math::rotl32((((a^b)&d)^b)+c+x2+0x242070db, 17); + b = c + math::rotl32((((d^a)&c)^a)+b+x3+0xc1bdceee, 22); + a = b + math::rotl32((((c^d)&b)^d)+a+x4+0xf57c0faf, 7); + d = a + math::rotl32((((b^c)&a)^c)+d+x5+0x4787c62a, 12); + c = d + math::rotl32((((a^b)&d)^b)+c+x6+0xa8304613, 17); + b = c + math::rotl32((((d^a)&c)^a)+b+x7+0xfd469501, 22); + a = b + math::rotl32((((c^d)&b)^d)+a+x8+0x698098d8, 7); + d = a + math::rotl32((((b^c)&a)^c)+d+x9+0x8b44f7af, 12); + c = d + math::rotl32((((a^b)&d)^b)+c+xa+0xffff5bb1, 17); + b = c + math::rotl32((((d^a)&c)^a)+b+xb+0x895cd7be, 22); + a = b + math::rotl32((((c^d)&b)^d)+a+xc+0x6b901122, 7); + d = a + math::rotl32((((b^c)&a)^c)+d+xd+0xfd987193, 12); + c = d + math::rotl32((((a^b)&d)^b)+c+xe+0xa679438e, 17); + b = c + math::rotl32((((d^a)&c)^a)+b+xf+0x49b40821, 22); + + // round 2 + a = b + math::rotl32((((b^c)&d)^c)+a+x1+0xf61e2562, 5); + d = a + math::rotl32((((a^b)&c)^b)+d+x6+0xc040b340, 9); + c = d + math::rotl32((((d^a)&b)^a)+c+xb+0x265e5a51, 14); + b = c + math::rotl32((((c^d)&a)^d)+b+x0+0xe9b6c7aa, 20); + a = b + math::rotl32((((b^c)&d)^c)+a+x5+0xd62f105d, 5); + d = a + math::rotl32((((a^b)&c)^b)+d+xa+0x02441453, 9); + c = d + math::rotl32((((d^a)&b)^a)+c+xf+0xd8a1e681, 14); + b = c + math::rotl32((((c^d)&a)^d)+b+x4+0xe7d3fbc8, 20); + a = b + math::rotl32((((b^c)&d)^c)+a+x9+0x21e1cde6, 5); + d = a + math::rotl32((((a^b)&c)^b)+d+xe+0xc33707d6, 9); + c = d + math::rotl32((((d^a)&b)^a)+c+x3+0xf4d50d87, 14); + b = c + math::rotl32((((c^d)&a)^d)+b+x8+0x455a14ed, 20); + a = b + math::rotl32((((b^c)&d)^c)+a+xd+0xa9e3e905, 5); + d = a + math::rotl32((((a^b)&c)^b)+d+x2+0xfcefa3f8, 9); + c = d + math::rotl32((((d^a)&b)^a)+c+x7+0x676f02d9, 14); + b = c + math::rotl32((((c^d)&a)^d)+b+xc+0x8d2a4c8a, 20); + + // round 3 + a = b + math::rotl32((b^c^d)+a+x5+0xfffa3942, 4); + d = a + math::rotl32((a^b^c)+d+x8+0x8771f681, 11); + c = d + math::rotl32((d^a^b)+c+xb+0x6d9d6122, 16); + b = c + math::rotl32((c^d^a)+b+xe+0xfde5380c, 23); + a = b + math::rotl32((b^c^d)+a+x1+0xa4beea44, 4); + d = a + math::rotl32((a^b^c)+d+x4+0x4bdecfa9, 11); + c = d + math::rotl32((d^a^b)+c+x7+0xf6bb4b60, 16); + b = c + math::rotl32((c^d^a)+b+xa+0xbebfbc70, 23); + a = b + math::rotl32((b^c^d)+a+xd+0x289b7ec6, 4); + d = a + math::rotl32((a^b^c)+d+x0+0xeaa127fa, 11); + c = d + math::rotl32((d^a^b)+c+x3+0xd4ef3085, 16); + b = c + math::rotl32((c^d^a)+b+x6+0x04881d05, 23); + a = b + math::rotl32((b^c^d)+a+x9+0xd9d4d039, 4); + d = a + math::rotl32((a^b^c)+d+xc+0xe6db99e5, 11); + c = d + math::rotl32((d^a^b)+c+xf+0x1fa27cf8, 16); + b = c + math::rotl32((c^d^a)+b+x2+0xc4ac5665, 23); + + // round 4 + a = b + math::rotl32((c^(b|~d))+a+x0+0xf4292244, 6); + d = a + math::rotl32((b^(a|~c))+d+x7+0x432aff97, 10); + c = d + math::rotl32((a^(d|~b))+c+xe+0xab9423a7, 15); + b = c + math::rotl32((d^(c|~a))+b+x5+0xfc93a039, 21); + a = b + math::rotl32((c^(b|~d))+a+xc+0x655b59c3, 6); + d = a + math::rotl32((b^(a|~c))+d+x3+0x8f0ccc92, 10); + c = d + math::rotl32((a^(d|~b))+c+xa+0xffeff47d, 15); + b = c + math::rotl32((d^(c|~a))+b+x1+0x85845dd1, 21); + a = b + math::rotl32((c^(b|~d))+a+x8+0x6fa87e4f, 6); + d = a + math::rotl32((b^(a|~c))+d+xf+0xfe2ce6e0, 10); + c = d + math::rotl32((a^(d|~b))+c+x6+0xa3014314, 15); + b = c + math::rotl32((d^(c|~a))+b+xd+0x4e0811a1, 21); + a = b + math::rotl32((c^(b|~d))+a+x4+0xf7537e82, 6); + d = a + math::rotl32((b^(a|~c))+d+xb+0xbd3af235, 10); + c = d + math::rotl32((a^(d|~b))+c+x2+0x2ad7d2bb, 15); + b = c + math::rotl32((d^(c|~a))+b+x9+0xeb86d391, 21); + + // add saved state + a += aa; + b += bb; + c += cc; + d += dd; + }; + + // save state + h.h[0] = a; + h.h[1] = b; + h.h[2] = c; + h.h[3] = d; +}; diff --git a/example/memcpy.ha b/example/memcpy.ha new file mode 100644 index 000000000..cd63770bc --- /dev/null +++ b/example/memcpy.ha @@ -0,0 +1,6 @@ +export fn memcpy(dest: *void, src: *void, amt: size) void = { + let a = dest: *[*]u8, b = src: *[*]u8; + for (let i = 0z; i < amt; i += 1) { + a[i] = b[i]; + }; +}; diff --git a/example/memset.ha b/example/memset.ha new file mode 100644 index 000000000..01b99465f --- /dev/null +++ b/example/memset.ha @@ -0,0 +1,6 @@ +export fn memset(dest: *void, val: u8, amt: size) void = { + let a = dest: *[*]u8; + for (let i = 0z; i < amt; i += 1) { + a[i] = val; + }; +}; diff --git a/example/names.ha b/example/names.ha new file mode 100644 index 000000000..f2cc50429 --- /dev/null +++ b/example/names.ha @@ -0,0 +1,85 @@ +use bytes; +use encoding::utf8; +use strings; + +// Returns the directory name for a given path. For a path to a file name, this +// returns the directory in which that file resides. For a path to a directory, +// this returns the path to its parent directory. The return value is borrowed +// from the input, use [dup] to extend its lifetime. +export fn dirname(path: str) str = { + let b = strings::toutf8(path); + let i = match (bytes::rindex(b, PATHSEP)) { + void => return path, + z: size => z, + }; + if (i == 0) { + i += 1; + }; + return strings::fromutf8_unsafe(b[..i]); +}; + +@test fn dirname() void = { + assert(dirname("/foo/bar") == "/foo"); + assert(dirname("/foo") == "/"); + assert(dirname("/") == "/"); + assert(dirname("foo/bar") == "foo"); + assert(dirname("foo") == "foo"); +}; + +// Returns the final component of a given path. For a path to a file name, this +// returns the file name. For a path to a directory, this returns the directory +// name. The return value is borrowed from the input, use [dup] to extend its +// lifetime. +export fn basename(path: str) str = { + let b = strings::toutf8(path); + let i = match (bytes::rindex(b, PATHSEP)) { + void => return path, + z: size => if (z + 1 < len(b)) z + 1z else 0z, + }; + return strings::fromutf8_unsafe(b[i..]); +}; + +@test fn basename() void = { + assert(basename("/foo/bar") == "bar"); + assert(basename("/foo") == "foo"); + assert(basename("/") == "/"); + assert(basename("foo/bar") == "bar"); + assert(basename("foo") == "foo"); +}; + +// Returns the file name and extension for a path. The return value is borrowed +// from the input, see [strings::dup] to extend its lifetime. +// +// The extension includes the '.' character. +// +// extension("foo/example") => ("example", "") +// extension("foo/example.txt") => ("example", ".txt") +// extension("foo/example.tar.gz") => ("example", ".tar.gz") +export fn extension(p: str) (str, str) = { + let p = basename(p); + let b = strings::toutf8(p); + if (len(b) == 0 || b[len(b) - 1] == PATHSEP) { + return (p, ""); + }; + let b = strings::toutf8(p); + let i = match (bytes::index(b, '.': u32: u8)) { + void => return (p, ""), + z: size => z, + }; + let e = b[i..]; + let n = b[..i]; + return (strings::fromutf8_unsafe(n), strings::fromutf8_unsafe(e)); +}; + +@test fn extension() void = { + assert(extension("").0 == ""); + assert(extension("").1 == ""); + assert(extension("foo/bar").0 == "bar"); + assert(extension("foo/bar").1 == ""); + assert(extension("foo/bar.txt").0 == "bar"); + assert(extension("foo/bar.txt").1 == ".txt"); + assert(extension("foo/bar.tar.gz").0 == "bar"); + assert(extension("foo/bar.tar.gz").1 == ".tar.gz"); + assert(extension("foo.bar/baz.ha").0 == "baz"); + assert(extension("foo.bar/baz.ha").1 == ".ha"); +}; diff --git a/example/network.ha b/example/network.ha new file mode 100644 index 000000000..bc7143816 --- /dev/null +++ b/example/network.ha @@ -0,0 +1,40 @@ +// Converts a u16 from host order to network order. +export fn htonu16(in: u16) u16 = { + if (host == &big) return in; + return in >> 8 | (in & 0xFF) << 8; +}; + +// Converts a u32 from host order to network order. +export fn htonu32(in: u32) u32 = { + if (host == &big) return in; + return in >> 24 | in >> 8 & 0xFF00 | in << 8 & 0xFF0000 | in << 24; +}; + +// Converts a u64 from host order to network order. +export fn htonu64(in: u64) u64 = { + if (host == &big) return in; + return (htonu32(in: u32): u64 << 32u64) | htonu32((in >> 32): u32): u64; +}; + +@test fn hton() void = { + if (host == &big) return; + assert(htonu16(0xCAFE) == 0xFECA); + assert(htonu32(0xDEADBEEF) == 0xEFBEADDE); + assert(htonu64(0xCAFEBABEDEADBEEF) == 0xEFBEADDEBEBAFECA); +}; + +// Converts a u16 from network order to host order. +export fn ntohu16(in: u16) u16 = htonu16(in); + +// Converts a u32 from network order to host order. +export fn ntohu32(in: u32) u32 = htonu32(in); + +// Converts a u64 from network order to host order. +export fn ntohu64(in: u64) u64 = htonu64(in); + +@test fn ntoh() void = { + if (host == &big) return; + assert(htonu16(0xFECA) == 0xCAFE); + assert(htonu32(0xEFBEADDE) == 0xDEADBEEF); + assert(htonu64(0xEFBEADDEBEBAFECA) == 0xCAFEBABEDEADBEEF); +}; diff --git a/example/nice+linux.ha b/example/nice+linux.ha new file mode 100644 index 000000000..bcfd38244 --- /dev/null +++ b/example/nice+linux.ha @@ -0,0 +1,23 @@ +use errors; +use rt; + +// Adds the argument to the niceness of the current process. The input should be +// between -20 and 19 (inclusive); lower numbers represent a higher priority. +// Generally, you must have elevated permissions to reduce your niceness, but +// not to increase it. +export fn nice(inc: int) (void | errors::opaque) = { + let prio = inc; + if (inc > -40 && inc <= 40) { + prio += rt::getpriority(rt::PRIO_PROCESS, 0) as int; + }; + if (prio > 19) { + prio = 19; + }; + if (prio < -20) { + prio = -20; + }; + return match (rt::setpriority(rt::PRIO_PROCESS, 0, prio)) { + void => void, + err: rt::errno => errors::errno(err), + }; +}; diff --git a/example/numeric.ha b/example/numeric.ha new file mode 100644 index 000000000..31710546d --- /dev/null +++ b/example/numeric.ha @@ -0,0 +1,96 @@ +use types; + +// Converts any [types::signed] to a string in a given base. The return value is +// statically allocated and will be overwritten on subsequent calls; see +// [strings::dup] to duplicate the result. +export fn signedtosb(n: types::signed, b: base) const str = { + return match (n) { + i: int => itosb(i, b), + i: i8 => i8tosb(i, b), + i: i16 => i16tosb(i, b), + i: i32 => i32tosb(i, b), + i: i64 => i64tosb(i, b), + }; +}; + +// Converts any [types::signed] to a string in base 10. The return value is +// statically allocated and will be overwritten on subsequent calls; see +// [strings::dup] to duplicate the result. +export fn signedtos(n: types::signed) const str = signedtosb(n, base::DEC); + +// Converts any [types::unsigned] to a string in a given base. The return value +// is statically allocated and will be overwritten on subsequent calls; see +// [strings::dup] to duplicate the result. +export fn unsignedtosb(n: types::unsigned, b: base) const str = { + return match (n) { + u: size => ztosb(u, b), + u: uint => utosb(u, b), + u: u8 => u8tosb(u, b), + u: u16 => u16tosb(u, b), + u: u32 => u32tosb(u, b), + u: u64 => u64tosb(u, b), + }; +}; + +// Converts any [types::unsigned] to a string in base 10. The return value is +// statically allocated and will be overwritten on subsequent calls; see +// [strings::dup] to duplicate the result. +export fn unsignedtos(n: types::unsigned) const str = unsignedtosb(n, base::DEC); + +// Converts any [types::integer] to a string in a given base, which must be 2, +// 8, 10, or 16. The return value is statically allocated and will be +// overwritten on subsequent calls; see [strings::dup] to duplicate the result. +export fn integertosb(n: types::integer, b: base) const str = { + return match (n) { + s: types::signed => signedtosb(s, b), + u: types::unsigned => unsignedtosb(u, b), + }; +}; + +// Converts any [types::integer] to a string in base 10. The return value is +// statically allocated and will be overwritten on subsequent calls; see +// [strings::dup] to duplicate the result. +export fn integertos(n: types::integer) const str = integertosb(n, base::DEC); + +// Converts any [types::floating] to a string in a given base. The return value +// is statically allocated and will be overwritten on subsequent calls; see +// [strings::dup] to duplicate the result. +export fn floatingtosb(n: types::floating, b: base) const str = { + abort(); // TODO +}; + +// Converts any [types::floating] to a string in base 10. The return value is +// statically allocated and will be overwritten on subsequent calls; see +// [strings::dup] to duplicate the result. +export fn floatingtos(n: types::floating) const str = floatingtosb(n, base::DEC); + +// Converts any [types::numeric] to a string in a given base. The return value +// is statically allocated and will be overwritten on subsequent calls; see +// [strings::dup] to duplicate the result. +export fn numerictosb(n: types::numeric, b: base) const str = { + return match (n) { + i: types::integer => integertosb(i, b), + f: types::floating => floatingtosb(f, b), + }; +}; + +// Converts any [types::numeric] to a string in base 10. The return value is +// statically allocated and will be overwritten on subsequent calls; see +// [strings::dup] to duplicate the result. +export fn numerictos(n: types::numeric) const str = numerictosb(n, base::DEC); + +@test fn numeric() void = { + const cases: [_]types::numeric = [ + 42u8, 1337u16, 1337u32, 1337u64, 42i8, -42i8, 1337i16, -1337i16, + 1337i32, -1337i32, 1337i64, -1337i64, 1337i, -1337i, 1337u, + -1337i, + ]; + const expected = [ + "42", "1337", "1337", "1337", "42", "-42", "1337", "-1337", + "1337", "-1337", "1337", "-1337", "1337", "-1337", "1337", + "-1337", + ]; + for (let i = 0z; i < len(cases); i += 1) { + assert(numerictos(cases[i]) == expected[i]); + }; +}; diff --git a/example/opaque.ha b/example/opaque.ha new file mode 100644 index 000000000..72c7c3ca8 --- /dev/null +++ b/example/opaque.ha @@ -0,0 +1,26 @@ +// An "opaque" error is used as a portable error type for an underlying error +// which is implementation-specific. It provides a function which can be used to +// produce a string describing the error, and a small storage area for arbitrary +// implementation-specific storage. +// +// The following example shows the usage of this type for custom errors: +// +// fn wraperror(err: myerror) error::opaque = { +// static assert(size(myerror) <= size(error::opaque_data)); +// let wrapped = opaque { strerror = &opaque_strerror, ... }; +// let myptr = &wrapped.data: *myerror; +// *myptr = err; +// }; +// +// fn opaque_strerror(err: *opaque_data) const str = { +// let ptr = &err: *myerr; +// return strerror(*ptr); +// }; +export type opaque = struct { + strerror: *fn(op: *opaque_data) const str, + data: opaque_data, +}!; + +// Up to 24 bytes of arbitrary data that the opaque error type may use for +// domain-specific storage. +export type opaque_data = [24]u8; diff --git a/example/open.ha b/example/open.ha new file mode 100644 index 000000000..54cdfbc0e --- /dev/null +++ b/example/open.ha @@ -0,0 +1,27 @@ +use fs; +use io; +use path; + +// Opens a file. +// +// If no flags are provided, [fs::flags::RDONLY], [fs::flags::NOCTTY], +// [fs::flags::CLOEXEC] are used when opening the file. If you pass your own +// flags, it is recommended that you add the latter two unless you know that you +// do not want them. +export fn open(path: str, flags: fs::flags...) (*io::stream | fs::error) = + fs::open(cwd, path, flags...); + +// Creates a new file and opens it for writing. +// +// If no flags are provided, [fs::flags::WRONLY], [fs::flags::NOCTTY], +// [fs::flags::CLOEXEC] are used when opening the file. If you pass your own +// flags, it is recommended that you add the latter two unless you know that you +// do not want them. +// +// Only the permission bits of the mode are used. If other bits are set, they +// are discarded. +export fn create( + path: str, + mode: fs::mode, + flags: fs::flags... +) (*io::stream | fs::error) = fs::create(cwd, path, mode, flags...); diff --git a/example/ops.ha b/example/ops.ha new file mode 100644 index 000000000..d8e3430a6 --- /dev/null +++ b/example/ops.ha @@ -0,0 +1,110 @@ +use encoding::utf8; +use io; +use strings; + +// Appends zero or more strings to an [io::stream]. The stream needn't be a +// strio stream, but it's often efficient if it is. Returns the number of bytes +// written, or an error. +export fn concat(st: *io::stream, strs: str...) (size | io::error) = { + let n = 0z; + for (let i = 0z; i < len(strs); i += 1) { + let q = 0z; + let buf = strings::toutf8(strs[i]); + for (q < len(buf)) { + let w = io::write(st, buf[q..])?; + n += w; + q -= w; + }; + }; + return n; +}; + +@test fn concat() void = { + let st = dynamic(); + defer io::close(st); + concat(st, "hello") as size; + concat(st, " ", "world") as size; + assert(string(st) == "hello world"); +}; + +// Joins several strings together by a delimiter and writes them to a stream. +// The stream needn't be a strio stream, but it's often more efficient if it is. +// Returns the number of bytes written, or an error. +export fn join(st: *io::stream, delim: str, strs: str...) (size | io::error) = { + let n = 0z; + let delim = strings::toutf8(delim); + for (let i = 0z; i < len(strs); i += 1) { + let q = 0z; + let buf = strings::toutf8(strs[i]); + for (q < len(buf)) { + let w = io::write(st, buf[q..])?; + n += w; + q -= w; + }; + if (i + 1 < len(strs)) { + let q = 0z; + for (q < len(delim)) { + let w = io::write(st, delim[q..])?; + n += w; + q -= w; + }; + }; + }; + return n; +}; + +@test fn join() void = { + let st = dynamic(); + defer io::close(st); + join(st, "::", "hello", "world") as size; + assert(string(st) == "hello::world"); + truncate(st); + join(st, "::") as size; + assert(string(st) == ""); + truncate(st); + join(st, "::", "foo") as size; + assert(string(st) == "foo"); +}; + +// Joins several strings together by a delimiter and writes them to a stream, in +// reverse order. The stream needn't be a strio stream, but it's often more +// efficient if it is. Returns the number of bytes written, or an error. +export fn rjoin(st: *io::stream, delim: str, strs: str...) (size | io::error) = { + let n = 0z; + let delim = strings::toutf8(delim); + for (let i = len(strs); i > 0; i -= 1) { + let q = 0z; + let buf = strings::toutf8(strs[i - 1]); + for (q < len(buf)) { + let w = io::write(st, buf[q..])?; + n += w; + q -= w; + }; + if (i - 1 > 0) { + let q = 0z; + for (q < len(delim)) { + let w = io::write(st, delim[q..])?; + n += w; + q -= w; + }; + }; + }; + return n; +}; + +@test fn rjoin() void = { + let st = dynamic(); + defer io::close(st); + rjoin(st, "::", "hello", "world") as size; + assert(string(st) == "world::hello"); + truncate(st); + rjoin(st, "::") as size; + assert(string(st) == ""); + truncate(st); + rjoin(st, "::", "foo") as size; + assert(string(st) == "foo"); +}; + +// Appends a rune to a stream. +export fn appendrune(st: *io::stream, r: rune) (size | io::error) = + io::write(st, utf8::encoderune(r)); diff --git a/example/parser.ha b/example/parser.ha new file mode 100644 index 000000000..c944fbf69 --- /dev/null +++ b/example/parser.ha @@ -0,0 +1,199 @@ +use ascii; +use bufio; +use encoding::utf8; +use io; +use strings; +use strio; + +// Returns an XML parser which reads from a stream. The caller must call +// [parser_free] when they are finished with it. +// +// Hare's XML parser only supports UTF-8 encoded input files. +// +// This function will attempt to read the XML prologue before returning, and +// will return an error if it is not valid. +export fn parse(in: *io::stream) (*parser | error) = { + // XXX: The main reason we allocate this instead of returning it on the + // stack is so that we have a consistent address for the bufio buffer. + // This is kind of lame, maybe we can avoid that. + let par = alloc(parser { + orig = in, + in = in, + ... + }); + if (!bufio::isbuffered(in)) { + par.in = bufio::buffered(par.in, par.buf[..], []); + }; + prolog(par)?; + return par; +}; + +// Frees the resources associated with this parser. Does not close the +// underlying stream. +export fn parser_free(par: *parser) void = { + if (par.in != par.orig) { + io::close(par.in); + }; + free(par); +}; + +// Scans for and returns the next [token]. The caller must pass the returned +// token to [token_free] when they're done with it. +export fn scan(par: *parser) (token | void | error) = { + want(par, OPTWS)?; + let rn: rune = match (bufio::scanrune(par.in)?) { + io::EOF => return void, + rn: rune => rn, + }; + bufio::unreadrune(par.in, rn); + return switch (par.state) { + state::ELEMENT => switch (rn) { + '<' => { + let el = scan_element(par); + par.state = state::ATTRS; + el; + }, + * => syntaxerr, + }, + state::ATTRS => { + abort(); // TODO + }, + }; +}; + +fn scan_element(par: *parser) (token | error) = { + want(par, '<')?; + return scan_name(par)?: elementstart; +}; + +fn scan_name(par: *parser) (str | error) = { + let buf = strio::dynamic(); + + const rn = match (bufio::scanrune(par.in)?) { + io::EOF => return syntaxerr, + rn: rune => rn, + }; + if (!isnamestart(rn)) { + return syntaxerr; + }; + strio::appendrune(buf, rn); + + for (true) match (bufio::scanrune(par.in)?) { + io::EOF => return syntaxerr, + rn: rune => if (isname(rn)) { + strio::appendrune(buf, rn); + } else { + bufio::unreadrune(par.in, rn); + break; + }, + }; + + return strio::finish(buf); +}; + +fn prolog(par: *parser) (void | error) = { + want(par, " break, + rn: rune => if (!ascii::isdigit(rn)) { + bufio::unreadrune(par.in, rn); + break; + }, + }; + want(par, quot)?; + + // TODO: Replace this with attribute() when it's written + let hadws = want(par, OPTWS)?; + let encoding = match (bufio::scanrune(par.in)) { + io::EOF => false, + rn: rune => { + bufio::unreadrune(par.in, rn); + hadws && rn == 'e'; + }, + }; + if (encoding) { + want(par, "encoding", OPTWS, '=', OPTWS)?; + let quot = quote(par)?; + match (want(par, "UTF-8")) { + syntaxerr => return utf8::invalid, + err: error => return err, + bool => void, + }; + want(par, quot)?; + }; + + let hadws = want(par, OPTWS)?; + let standalone = match (bufio::scanrune(par.in)) { + io::EOF => false, + rn: rune => { + bufio::unreadrune(par.in, rn); + hadws && rn == 's'; + }, + }; + if (standalone) { + want(par, "standalone", OPTWS, '=', OPTWS)?; + let quot = quote(par)?; + // TODO: Should we support standalone="no"? + want(par, "yes", quot)?; + }; + + want(par, OPTWS, "?>")?; + // TODO: Parse doctypedecl & misc + return; +}; + +// Mandatory if true +type whitespace = bool; +def WS: whitespace = true; +def OPTWS: whitespace = false; + +fn quote(par: *parser) (rune | error) = { + return match (bufio::scanrune(par.in)?) { + * => return syntaxerr, + rn: rune => switch (rn) { + '"', '\'' => rn, + * => return syntaxerr, + }, + }; +}; + +fn want(par: *parser, tok: (rune | str | whitespace)...) (bool | error) = { + let hadws = false; + for (let i = 0z; i < len(tok); i += 1) match (tok[i]) { + x: rune => { + let have = match (bufio::scanrune(par.in)?) { + * => return syntaxerr, + rn: rune => rn, + }; + if (have != x) { + return syntaxerr; + }; + }, + x: str => { + let iter = strings::iter(x); + for (true) match (strings::next(&iter)) { + rn: rune => want(par, rn)?, + void => break, + }; + }, + ws: whitespace => { + let n = 0; + for (true; n += 1) match (bufio::scanrune(par.in)?) { + io::EOF => break, + rn: rune => if (!ascii::isspace(rn)) { + bufio::unreadrune(par.in, rn); + break; + }, + }; + if (ws && n < 1) { + return syntaxerr; + }; + hadws = n >= 1; + }, + }; + return hadws; +}; diff --git a/example/passwd.ha b/example/passwd.ha new file mode 100644 index 000000000..2ac95a8ff --- /dev/null +++ b/example/passwd.ha @@ -0,0 +1,135 @@ +use bufio; +use io; +use os; +use strconv; +use strings; + +// An invalid entry was encountered during parsing. +export type invalid = void!; + +// A Unix-like password database entry. +export type pwent = struct { + // Login name + username: str, + // Optional encrypted password + password: str, + // Numerical user ID + uid: uint, + // Numerical group ID + gid: uint, + // User name or comment field + comment: str, + // User home directory + homedir: str, + // Optional user command interpreter + shell: str, +}; + +// Reads a Unix-like password entry from a stream. The caller must free the +// result using [unix::passwd::pwent_finish]. +export fn nextpw(stream: *io::stream) (pwent | io::EOF | io::error | invalid) = { + let line = match (bufio::scanline(stream)?) { + io::EOF => return io::EOF, + ln: []u8 => ln, + }; + let line = match (strings::try_fromutf8(line)) { + s: str => s, + * => return invalid, + }; + + let fields = strings::split(line, ":"); + defer free(fields); + + if (len(fields) != 7) { + return invalid; + }; + + let uid = match (strconv::stou(fields[2])) { + u: uint => u, + * => return invalid, + }; + + let gid = match (strconv::stou(fields[3])) { + u: uint => u, + * => return invalid, + }; + + return pwent { + // Borrows the return value of bufio::scanline + username = fields[0], + password = fields[1], + uid = uid, + gid = gid, + comment = fields[4], + homedir = fields[5], + shell = fields[6], + }; +}; + +// Frees resources associated with [pwent]. +export fn pwent_finish(ent: pwent) void = { + // pwent fields are sliced from one allocated string returned by + // bufio::scanline. Freeing the first field frees the entire string in + // one go. + free(ent.username); +}; + +// Looks up a user by name in a Unix-like password file. It expects a password +// database file at /etc/passwd. Aborts if that file doesn't exist or is not +// properly formatted. +// +// See [unix::passwd::nextpw] for low-level parsing API. +export fn getuser(username: str) (pwent | void) = { + let file = match (os::open("/etc/passwd")) { + s: *io::stream => s, + * => abort("Can't open /etc/passwd"), + }; + defer io::close(file); + + for (true) { + let ent = match (nextpw(file)) { + e: pwent => e, + io::EOF => break, + * => abort("/etc/passwd entry is invalid"), + }; + defer pwent_finish(ent); + + if (ent.username == username) { + return ent; + }; + }; + + return; +}; + +@test fn nextpw() void = { + let buf = bufio::fixed(strings::toutf8( + "sircmpwn:x:1000:1000:sircmpwn's comment:/home/sircmpwn:/bin/mrsh\n" + "alex:x:1001:1001::/home/alex:/bin/zsh"), io::mode::READ); + defer free(buf); + + let ent = nextpw(buf) as pwent; + defer pwent_finish(ent); + + assert(ent.username == "sircmpwn"); + assert(ent.password == "x"); + assert(ent.uid == 1000); + assert(ent.gid == 1000); + assert(ent.comment == "sircmpwn's comment"); + assert(ent.homedir == "/home/sircmpwn"); + assert(ent.shell == "/bin/mrsh"); + + let ent = nextpw(buf) as pwent; + defer pwent_finish(ent); + + assert(ent.username == "alex"); + assert(ent.password == "x"); + assert(ent.uid == 1001); + assert(ent.gid == 1001); + assert(ent.comment == ""); + assert(ent.homedir == "/home/alex"); + assert(ent.shell == "/bin/zsh"); + + // No more entries + assert(nextpw(buf) is io::EOF); +}; diff --git a/example/plan.ha b/example/plan.ha new file mode 100644 index 000000000..a34e2d71a --- /dev/null +++ b/example/plan.ha @@ -0,0 +1,197 @@ +use fmt; +use hare::ast; +use hare::module; +use os::exec; +use os; +use path; +use strings; +use temp; + +type status = enum { + SCHEDULED, + COMPLETE, + SKIP, +}; + +type task = struct { + status: status, + depend: []*task, + output: str, + cmd: []str, +}; + +fn task_free(task: *task) void = { + free(task.depend); + free(task.output); + free(task.cmd); + free(task); +}; + +type modcache = struct { + hash: u32, + task: *task, + ident: ast::ident, + version: module::version, +}; + +type plan = struct { + context: *module::context, + workdir: str, + counter: uint, + scheduled: []*task, + complete: []*task, + script: str, + environ: [](str, str), + modmap: [64][]modcache, +}; + +fn mkplan(ctx: *module::context) plan = { + const rtdir = match (module::lookup(ctx, ["rt"])) { + err: module::error => fmt::fatal("Error resolving rt: {}", + module::strerror(err)), + ver: module::version => ver.basedir, + }; + return plan { + context = ctx, + workdir = temp::dir(), + script = path::join(rtdir, "hare.sc"), + environ = alloc([ + (strings::dup("HARECACHE"), strings::dup(ctx.cache)), + ]), + ... + }; +}; + +fn plan_finish(plan: *plan) void = { + os::rmdirall(plan.workdir); + free(plan.workdir); + + for (let i = 0z; i < len(plan.complete); i += 1) { + let task = plan.complete[i]; + task_free(task); + }; + free(plan.complete); + + for (let i = 0z; i < len(plan.scheduled); i += 1) { + let task = plan.scheduled[i]; + task_free(task); + }; + free(plan.scheduled); + + for (let i = 0z; i < len(plan.environ); i += 1) { + free(plan.environ[i].0); + free(plan.environ[i].1); + }; + free(plan.environ); + + for (let i = 0z; i < len(plan.modmap); i += 1) { + free(plan.modmap[i]); + }; +}; + +fn plan_execute(plan: *plan, verbose: bool) void = { + for (len(plan.scheduled) != 0) { + let next: nullable *task = null; + let i = 0z; + for (i < len(plan.scheduled); i += 1) { + let task = plan.scheduled[i]; + let eligible = true; + for (let j = 0z; j < len(task.depend); j += 1) { + if (task.depend[j].status == status::SCHEDULED) { + eligible = false; + break; + }; + }; + if (eligible) { + next = task; + break; + }; + }; + // TODO: This can be a type assertion + let task = match (next) { + null => abort(), + t: *task => t, + }; + + match (execute(plan, task, verbose)) { + err: exec::error => fmt::fatal("Error: {}: {}", + task.cmd[0], exec::strerror(err)), + err: exec::exit_status! => fmt::fatal("Error: {}: {}", + task.cmd[0], exec::exitstr(err)), + void => void, + }; + + task.status = status::COMPLETE; + + delete(plan.scheduled[i]); + append(plan.complete, task); + }; + + update_modcache(plan); +}; + +fn update_cache(plan: *plan, mod: modcache) void = { + let manifest = module::manifest { + ident = mod.ident, + inputs = mod.version.inputs, + versions = [mod.version], + }; + match (module::manifest_write(plan.context, &manifest)) { + err: module::error => fmt::fatal( + "Error updating module cache: {}", + module::strerror(err)), + void => void, + }; +}; + +fn update_modcache(plan: *plan) void = { + for (let i = 0z; i < len(plan.modmap); i += 1) { + let mods = plan.modmap[i]; + if (len(mods) == 0) { + continue; + }; + for (let j = 0z; j < len(mods); j += 1) { + if (mods[j].task.status == status::COMPLETE) { + update_cache(plan, mods[j]); + }; + }; + }; +}; + +fn execute( + plan: *plan, + task: *task, + verbose: bool, +) (void | exec::error | exec::exit_status!) = { + if (verbose) { + for (let i = 0z; i < len(task.cmd); i += 1) { + fmt::errorf("{} ", task.cmd[i]); + }; + fmt::errorln(); + }; + + let cmd = exec::cmd(task.cmd[0], task.cmd[1..]...)?; + for (let i = 0z; i < len(plan.environ); i += 1) { + let e = plan.environ[i]; + exec::setenv(&cmd, e.0, e.1); + }; + + let proc = exec::start(&cmd)?; + let st = exec::wait(&proc)?; + return exec::check(&st); +}; + +fn mkfile(plan: *plan, ext: str) str = { + static let namebuf: [32]u8 = [0...]; + const name = fmt::bsprintf(namebuf, "temp.{}.{}", + plan.counter, ext); + plan.counter += 1; + return path::join(plan.workdir, name); +}; + +fn mkdepends(t: *task...) []*task = { + // XXX: This should just be one alloc call + let deps: []*task = alloc([], len(t)); + append(deps, ...t); + return deps; +}; diff --git a/example/platformstart.ha b/example/platformstart.ha new file mode 100644 index 000000000..69a1471bc --- /dev/null +++ b/example/platformstart.ha @@ -0,0 +1,7 @@ +export @noreturn fn start_linux(iv: *[*]uintptr) void = { + // TODO: Find & parse auxv + argc = iv[0]: size; + argv = &iv[1]: *[*]*char; + envp = &argv[argc + 1]: *[*]nullable *char; + start_ha(); +}; diff --git a/example/println.ha b/example/println.ha new file mode 100644 index 000000000..06374aad9 --- /dev/null +++ b/example/println.ha @@ -0,0 +1,35 @@ +use rt; + +// Prints strings to stdout, separated by spaces, and followed by a newline. +// +// The output is unbuffered, and may not have good performance. This is only +// recommended for debugging purposes. See [fmt::println] instead. +export fn println(msgs: str...) void = { + for (let i = 0z; i < len(msgs); i += 1) { + let msg = msgs[i]; + rt::write(1, *(&msg: **void): *const char, len(msg)); + if (i + 1 < len(msgs)) { + const sp = " "; + rt::write(1, *(&sp: **void): *const char, 1); + }; + }; + const linefeed = "\n"; + rt::write(1, *(&linefeed: **void): *const char, 1); +}; + +// Prints strings to stderr, separated by spaces, and followed by a newline. +// +// The output is unbuffered, and may not have good performance. This is only +// recommended for debugging purposes. See [fmt::errorln] instead. +export fn errorln(msgs: str...) void = { + for (let i = 0z; i < len(msgs); i += 1) { + let msg = msgs[i]; + rt::write(2, *(&msg: **void): *const char, len(msg)); + if (i + 1 < len(msgs)) { + const sp = " "; + rt::write(2, *(&sp: **void): *const char, 1); + }; + }; + const linefeed = "\n"; + rt::write(2, *(&linefeed: **void): *const char, 1); +}; diff --git a/example/process+linux.ha b/example/process+linux.ha new file mode 100644 index 000000000..8f71eb4ef --- /dev/null +++ b/example/process+linux.ha @@ -0,0 +1,87 @@ +use errors; +use rt; +use fmt; +// TODO: Add function to wait on all/any children + +fn rusage(st: *status, ru: *rt::rusage) void = { + st.rusage.maxrss = ru.ru_maxrss; + st.rusage.minflt = ru.ru_minflt; + st.rusage.majflt = ru.ru_majflt; + st.rusage.inblock = ru.ru_inblock; + st.rusage.oublock = ru.ru_oublock; + st.rusage.nvcsw = ru.ru_nvcsw; + st.rusage.nivcsw = ru.ru_nivcsw; +}; + +// Waits for a process to complete, then returns its status information. +export fn wait(proc: *process) (status | error) = { + let ru: rt::rusage = rt::rusage { ... }; + let st: status = status { ... }; + match (rt::wait4(*proc, &st.status, 0, &ru)) { + err: rt::errno => errors::errno(err), + pid: int => assert(pid == *proc), + }; + rusage(&st, &ru); + return st; +}; + +// Checks for process completion, returning its status information on +// completion, or void if it is still running. +export fn peek(proc: *process) (status | void | error) = { + let ru: rt::rusage = rt::rusage { ... }; + let st: status = status { ... }; + match (rt::wait4(*proc, &st.status, 0, &ru)) { + err: rt::errno => errors::errno(err), + pid: int => switch (pid) { + 0 => return void, + * => assert(pid == *proc), + }, + }; + rusage(&st, &ru); + return st; +}; + +// The exit status code of a process. +export type exited = int; + +// The signal number which caused a process to terminate. +export type signaled = int; + +// The exit status of a process. +export type exit_status = (exited | signaled); + +// Returns a human friendly string describing the exit status. +export fn exitstr(status: exit_status) const str = { + static let buf: [1024]u8 = [0...]; + return match (status) { + i: exited => switch (i) { + 0 => "exited normally", + * => fmt::bsprintf(buf, "exited with status {}", i: int), + }, + // TODO: Add signal name + s: signaled => fmt::bsprintf(buf, "exited with signal {}", s: int), + }; +}; + +// Returns the exit status of a completed process. +export fn exit(stat: *status) exit_status = { + if (rt::wifexited(stat.status)) { + return rt::wexitstatus(stat.status): exited; + }; + if (rt::wifsignaled(stat.status)) { + return rt::wtermsig(stat.status): signaled; + }; + abort("Unexpected exit status"); +}; + +// Checks the exit status of a completed process, returning void if successful, +// or its status code as an error type if not. +export fn check(stat: *status) (void | exit_status!) = { + if (rt::wifexited(stat.status)) { + return switch (rt::wexitstatus(stat.status)) { + 0 => void, + * => exit(stat), + }; + }; + return exit(stat); +}; diff --git a/example/properties.ha b/example/properties.ha new file mode 100644 index 000000000..ca6ff8c64 --- /dev/null +++ b/example/properties.ha @@ -0,0 +1,1130 @@ +// Unicode character blocks. See Blocks.txt in the UCD. +export type blk = enum { + ADLAM, + AEGEAN_NUMBERS, + AHOM, + ALCHEMICAL, + ALPHABETIC_PF, + ANATOLIAN_HIEROGLYPHS, + ANCIENT_GREEK_MUSIC, + ANCIENT_GREEK_NUMBERS, + ANCIENT_SYMBOLS, + ARABIC, + ARABIC_EXT_A, + ARABIC_MATH, + ARABIC_PF_A, + ARABIC_PF_B, + ARABIC_SUP, + ARMENIAN, + ARROWS, + ASCII, + AVESTAN, + BALINESE, + BAMUM, + BAMUM_SUP, + BASSA_VAH, + BATAK, + BENGALI, + BHAIKSUKI, + BLOCK_ELEMENTS, + BOPOMOFO, + BOPOMOFO_EXT, + BOX_DRAWING, + BRAHMI, + BRAILLE, + BUGINESE, + BUHID, + BYZANTINE_MUSIC, + CARIAN, + CAUCASIAN_ALBANIAN, + CHAKMA, + CHAM, + CHEROKEE, + CHEROKEE_SUP, + CHESS_SYMBOLS, + CHORASMIAN, + CJK, + CJK_COMPAT, + CJK_COMPAT_FORMS, + CJK_COMPAT_IDEOGRAPHS, + CJK_COMPAT_IDEOGRAPHS_SUP, + CJK_EXT_A, + CJK_EXT_B, + CJK_EXT_C, + CJK_EXT_D, + CJK_EXT_E, + CJK_EXT_F, + CJK_EXT_G, + CJK_RADICALS_SUP, + CJK_STROKES, + CJK_SYMBOLS, + COMPAT_JAMO, + CONTROL_PICTURES, + COPTIC, + COPTIC_EPACT_NUMBERS, + COUNTING_ROD, + CUNEIFORM, + CUNEIFORM_NUMBERS, + CURRENCY_SYMBOLS, + CYPRIOT_SYLLABARY, + CYRILLIC, + CYRILLIC_EXT_A, + CYRILLIC_EXT_B, + CYRILLIC_EXT_C, + CYRILLIC_SUP, + DESERET, + DEVANAGARI, + DEVANAGARI_EXT, + DIACRITICALS, + DIACRITICALS_FOR_SYMBOLS, + DIACRITICALS_SUP, + DIACRITICALS_EXT, + DINGBATS, + DIVES_AKURU, + DOGRA, + DOMINO, + DUPLOYAN, + EARLY_DYNASTIC_CUNEIFORM, + EGYPTIAN_HIEROGLYPHS, + EGYPTIAN_HIEROGLYPH_FORMAT_CONTROLS, + ELBASAN, + ELYMAIC, + EMOTICONS, + ENCLOSED_ALPHANUM, + ENCLOSED_ALPHANUM_SUP, + ENCLOSED_CJK, + ENCLOSED_IDEOGRAPHIC_SUP, + ETHIOPIC, + ETHIOPIC_EXT, + ETHIOPIC_EXT_A, + ETHIOPIC_SUP, + GEOMETRIC_SHAPES, + GEOMETRIC_SHAPES_EXT, + GEORGIAN, + GEORGIAN_EXT, + GEORGIAN_SUP, + GLAGOLITIC, + GLAGOLITIC_SUP, + GOTHIC, + GRANTHA, + GREEK, + GREEK_EXT, + GUJARATI, + GUNJALA_GONDI, + GURMUKHI, + HALF_AND_FULL_FORMS, + HALF_MARKS, + HANGUL, + HANIFI_ROHINGYA, + HANUNOO, + HATRAN, + HEBREW, + HIGH_PU_SURROGATES, + HIGH_SURROGATES, + HIRAGANA, + IDC, + IDEOGRAPHIC_SYMBOLS, + IMPERIAL_ARAMAIC, + INDIC_NUMBER_FORMS, + INDIC_SIYAQ_NUMBERS, + INSCRIPTIONAL_PAHLAVI, + INSCRIPTIONAL_PARTHIAN, + IPA_EXT, + JAMO, + JAMO_EXT_A, + JAMO_EXT_B, + JAVANESE, + KAITHI, + KANA_EXT_A, + KANA_SUP, + KANBUN, + KANGXI, + KANNADA, + KATAKANA, + KATAKANA_EXT, + KAYAH_LI, + KHAROSHTHI, + KHITAN_SMALL_SCRIPT, + KHMER, + KHMER_SYMBOLS, + KHOJKI, + KHUDAWADI, + LAO, + LATIN_1_SUP, + LATIN_EXT_A, + LATIN_EXT_ADDITIONAL, + LATIN_EXT_B, + LATIN_EXT_C, + LATIN_EXT_D, + LATIN_EXT_E, + LEPCHA, + LETTERLIKE_SYMBOLS, + LIMBU, + LINEAR_A, + LINEAR_B_IDEOGRAMS, + LINEAR_B_SYLLABARY, + LISU, + LISU_SUP, + LOW_SURROGATES, + LYCIAN, + LYDIAN, + MAHAJANI, + MAHJONG, + MAKASAR, + MALAYALAM, + MANDAIC, + MANICHAEAN, + MARCHEN, + MASARAM_GONDI, + MATH_ALPHANUM, + MATH_OPERATORS, + MAYAN_NUMERALS, + MEDEFAIDRIN, + MEETEI_MAYEK, + MEETEI_MAYEK_EXT, + MENDE_KIKAKUI, + MEROITIC_CURSIVE, + MEROITIC_HIEROGLYPHS, + MIAO, + MISC_ARROWS, + MISC_MATH_SYMBOLS_A, + MISC_MATH_SYMBOLS_B, + MISC_PICTOGRAPHS, + MISC_SYMBOLS, + MISC_TECHNICAL, + MODI, + MODIFIER_LETTERS, + MODIFIER_TONE_LETTERS, + MONGOLIAN, + MONGOLIAN_SUP, + MRO, + MUSIC, + MULTANI, + MYANMAR, + MYANMAR_EXT_A, + MYANMAR_EXT_B, + NABATAEAN, + NANDINAGARI, + NB, + NEW_TAI_LUE, + NEWA, + NKO, + NUMBER_FORMS, + NUSHU, + NYIAKENG_PUACHUE_HMONG, + OCR, + OGHAM, + OL_CHIKI, + OLD_HUNGARIAN, + OLD_ITALIC, + OLD_NORTH_ARABIAN, + OLD_PERMIC, + OLD_PERSIAN, + OLD_SOGDIAN, + OLD_SOUTH_ARABIAN, + OLD_TURKIC, + ORIYA, + ORNAMENTAL_DINGBATS, + OSAGE, + OSMANYA, + OTTOMAN_SIYAQ_NUMBERS, + PAHAWH_HMONG, + PALMYRENE, + PAU_CIN_HAU, + PHAGS_PA, + PHAISTOS, + PHOENICIAN, + PHONETIC_EXT, + PHONETIC_EXT_SUP, + PLAYING_CARDS, + PSALTER_PAHLAVI, + PUA, + PUNCTUATION, + REJANG, + RUMI, + RUNIC, + SAMARITAN, + SAURASHTRA, + SHARADA, + SHAVIAN, + SHORTHAND_FORMAT_CONTROLS, + SIDDHAM, + SINHALA, + SINHALA_ARCHAIC_NUMBERS, + SMALL_FORMS, + SMALL_KANA_EXT, + SOGDIAN, + SORA_SOMPENG, + SOYOMBO, + SPECIALS, + SUNDANESE, + SUNDANESE_SUP, + SUP_ARROWS_A, + SUP_ARROWS_B, + SUP_ARROWS_C, + SUP_MATH_OPERATORS, + SUP_PUA_A, + SUP_PUA_B, + SUP_PUNCTUATION, + SUP_SYMBOLS_AND_PICTOGRAPHS, + SUPER_AND_SUB, + SUTTON_SIGNWRITING, + SYLOTI_NAGRI, + SYMBOLS_AND_PICTOGRAPHS_EXT_A, + SYMBOLS_FOR_LEGACY_COMPUTING, + SYRIAC, + SYRIAC_SUP, + TAGALOG, + TAGBANWA, + TAGS, + TAI_LE, + TAI_THAM, + TAI_VIET, + TAI_XUAN_JING, + TAKRI, + TAMIL, + TAMIL_SUP, + TANGUT, + TANGUT_COMPONENTS, + TANGUT_SUP, + TELUGU, + THAANA, + THAI, + TIBETAN, + TIFINAGH, + TIRHUTA, + TRANSPORT_AND_MAP, + UCAS, + UCAS_EXT, + UGARITIC, + VAI, + VEDIC_EXT, + VERTICAL_FORMS, + VS, + VS_SUP, + WANCHO, + WARANG_CITI, + YEZIDI, + YI_RADICALS, + YI_SYLLABLES, + YIJING, + ZANABAZAR_SQUARE, +}; + +// Unicode general character categories. See Unicode section 4.5. +export type gc = enum { + // Letter, uppercase + LU, + // Letter, lowercase + LL, + // Letter, titlecase + LT, + // Letter, modifier + LM, + // Letter, other + LO, + // Mark, nonspacing + MN, + // Mark, spacing combining + MC, + // Mark, enclosing + ME, + // Number, decimal digit + ND, + // Number, letter + NL, + // Number, other + NO, + // Punctuation, connector + PC, + // Punctuation, dash + PD, + // Punctuation, open + PS, + // Punctuation, close + PE, + // Punctuation, initial quote + PI, + // Punctuation, final quote + PF, + // Punctuation, other + PO, + // Symbol, math + SM, + // Symbol, currency + SC, + // Symbol, modifier + SK, + // Symbol, other + SO, + // Separator, space + ZS, + // Separator, line + ZL, + // Separator, paragraph + ZP, + // Other, control + CC, + // Other, format + CF, + // Other, surrogate + CS, + // Other, private use + CO, + // Other, not assigned (including noncharacters) + CN, +}; + +// Bidirectional class. See UAX #9. +export type bc = enum { + // Right-to-left (Arabic) + AL, + // Arabic number + AN, + // Paragraph separator + B, + // Boundary neutral + BN, + // Common number separator + CS, + // European number + EN, + // European number separator + ES, + // Euromean number terminator + ET, + // First strong isolate + FSI, + // Left-to-right + L, + // Left-to-right embedding + LRE, + // Right-to-left isolate + LRI, + // Left-to-right override + LRO, + // Nonspacing mark + NSM, + // Other neutrals + ON, + // Pop directional format + PDF, + // Pop directional isolate + PDI, + // Right-to-left + R, + // Right-to-left embedding + RLE, + // Right-to-left isolate + RLI, + // Right-to-left override + RLO, + // Segment separator + S, + // Whitespace + WS, +}; + +// Bidi paired bracket type. See BidiBrackets.txt in the UCD. +export type bpt = enum { + // Open + O, + // Closed + C, + // None + N, +}; + +// Decomposition type. See UAX #44, section 5.7.3. +export type dt = enum { + // Canonical mapping + CAN, + // Otherwise unspecified compatibility character + COM, + // Encircled form + ENC, + // Final presentation form (Arabic) + FIN, + // Font variant (for example, a blackletter form) + FONT, + // Vulgar fraction form + FRA, + // Initial presentation form (Arabic) + INIT, + // Isolated presentation form (Arabic) + ISO, + // Medial presentation form (Arabic) + MED, + // Narrow (or hankaku) compatibility character + NAR, + // No-break version of a space or hyphen + NB, + // Small variant form (CNS compatibility) + SML, + // CJK squared font variant + SQR, + // Subscript form + SUB, + // Superscript form + SUP, + // Vertical layout presentation form + VERT, + // Wide (or zenkaku) compatibility character + WIDE, + // None + NONE, +}; + +// Normalization quick-check properties. See UAX #44, section 5.7.5. +export type quickcheck = enum uint { + NO = 0b00, + MAYBE = 0b01, + YES = 0b11, +}; + +// Numeric type. See Unicode section 4.6. +export type nt = enum { + // Non-numeric + NONE, + // Decimal + DE, + // Digit + DI, + // Numeric + NU, +}; + +// Character joining class. See Unicode section 9.2. +export type jt = enum { + // Non-joining + U, + // Join causing + C, + // Transparent + T, + // Dual joining + D, + // Left joining + L, + // Right joining + R, +}; + +// Character joining group. See Unicode section 9.2. +export type jg = enum { + AFRICAN_FEH, + AFRICAN_NOON, + AFRICAN_QAF, + AIN, + ALAPH, + ALEF, + ALEF_MAQSURAH, + BEH, + BETH, + BURUSHASKI_YEH_BARREE, + DAL, + DALATH_RISH, + E, + FARSI_YEH, + FE, + FEH, + FINAL_SEMKATH, + GAF, + GAMAL, + HAH, + HAMZA_ON_HEH_GOAL, + HE, + HEH, + HEH_GOAL, + HETH, + HANIFI_ROHINGYA_KINNA_YA, + HANIFI_ROHINGYA_PA, + KAF, + KAPH, + KHAPH, + KNOTTED_HEH, + LAM, + LAMADH, + MALAYALAM_NGA, + MALAYALAM_JA, + MALAYALAM_NYA, + MALAYALAM_TTA, + MALAYALAM_NNA, + MALAYALAM_NNNA, + MALAYALAM_BHA, + MALAYALAM_RA, + MALAYALAM_LLA, + MALAYALAM_LLLA, + MALAYALAM_SSA, + MANICHAEAN_ALEPH, + MANICHAEAN_AYIN, + MANICHAEAN_BETH, + MANICHAEAN_DALETH, + MANICHAEAN_DHAMEDH, + MANICHAEAN_FIVE, + MANICHAEAN_GIMEL, + MANICHAEAN_HETH, + MANICHAEAN_HUNDRED, + MANICHAEAN_KAPH, + MANICHAEAN_LAMEDH, + MANICHAEAN_MEM, + MANICHAEAN_NUN, + MANICHAEAN_ONE, + MANICHAEAN_PE, + MANICHAEAN_QOPH, + MANICHAEAN_RESH, + MANICHAEAN_SADHE, + MANICHAEAN_SAMEKH, + MANICHAEAN_TAW, + MANICHAEAN_TEN, + MANICHAEAN_TETH, + MANICHAEAN_THAMEDH, + MANICHAEAN_TWENTY, + MANICHAEAN_WAW, + MANICHAEAN_YODH, + MANICHAEAN_ZAYIN, + MEEM, + MIM, + NO_JOINING_GROUP, + NOON, + NUN, + NYA, + PE, + QAF, + QAPH, + REH, + REVERSED_PE, + ROHINGYA_YEH, + SAD, + SADHE, + SEEN, + SEMKATH, + SHIN, + STRAIGHT_WAW, + SWASH_KAF, + SYRIAC_WAW, + TAH, + TAW, + TEH_MARBUTA, + TEH_MARBUTA_GOAL, + TETH, + WAW, + YEH, + YEH_BARREE, + YEH_WITH_TAIL, + YUDH, + YUDH_HE, + ZAIN, + ZHAIN, +}; + +// Line breaking properties. See UAX #14. +export type lb = enum { + // Ambiguous + AI, + // Alphabetic + AL, + // Break opportunity before and after + B2, + // Break after + BA, + // Break before + BB, + // Mandatory break + BK, + // Contingent break opportunity + CB, + // Conditional Japanese starter + CJ, + // Close punctuation + CL, + // Combining mark + CM, + // Close parenthesis + CP, + // Carriage return + CR, + // Emoji base + EB, + // Emoji modifier + EM, + // Exclamation/interrogation + EX, + // Non-breaking ("glue") + GL, + // Hangul LV syllable + H2, + // Hangul LVT syllable + H3, + // Hebrew letter + HL, + // Hyphen + HY, + // Ideographic + ID, + // Inseparable + IN, + // Infix numeric separator + IS, + // Hangul L Jamo + JL, + // Hangul T Jamo + JT, + // Hangul V Jamo + JV, + // Line feed + LF, + // Next line + NL, + // Nonstarter + NS, + // Numeric + NU, + // Open punctuation + OP, + // Postfix numeric + PO, + // Prefix numeric + PR, + // Quotation + QU, + // Regional indicator + RI, + // Complex context dependent (South East Asian) + SA, + // Surrogate + SG, + // Space + SP, + // Symbols allowing break after + SY, + // Word joiner + WJ, + // Unknown + XX, + // Zero width space + ZW, + // Zero width joiner + ZWJ, +}; + +// East-asian width. See UAX #11. +export type ea = enum { + // Ambiguous + A, + // Fullwidth + F, + // Halfwidth + H, + // Neutral + N, + // Narrow + NA, + // Wide + W, +}; + +// Case property. See Unicode section 4.2. +export type case = enum uint { + UPPER = 1 << 0, + LOWER = 1 << 1, + OTHER_UPPER = 1 << 2, + OTHER_LOWER = 1 << 3, +}; + +// Casing attributes. See Unicode section 4.2. +export type case_attrs = enum uint { + // Case ignorable + CI = 1 << 0, + // Cased + CASED = 1 << 1, + // Changes when casefolded + CWCF = 1 << 2, + // Changes when casemapped + CWCM = 1 << 3, + // Changes when lowercased + CWL = 1 << 4, + // Changes when NFKC casefolded + CWKCF = 1 << 5, + // Changes when titlecased + CWT = 1 << 6, + // Changes when uppercased + CWU = 1 << 7, + // NFKC casefold + NFKC_CF = 1 << 8, +}; + +// Script property. See UAX #24. +export type script = enum { + ADLM, + AGHB, + AHOM, + ARAB, + ARMI, + ARMN, + AVST, + BALI, + BAMU, + BASS, + BATK, + BENG, + BHKS, + BOPO, + BRAH, + BRAI, + BUGI, + BUHD, + CAKM, + CANS, + CARI, + CHAM, + CHER, + CHRS, + COPT, + CPRT, + CYRL, + DEVA, + DIAK, + DOGR, + DSRT, + DUPL, + ELBA, + ELYM, + EGYP, + ETHI, + GEOR, + GLAG, + GONG, + GONM, + GOTH, + GRAN, + GREK, + GUJR, + GURU, + HANG, + HANI, + HANO, + HATR, + HEBR, + HIRA, + HLUW, + HMNG, + HMNP, + HRKT, + HUNG, + ITAL, + JAVA, + KALI, + KANA, + KHAR, + KHMR, + KHOJ, + KITS, + KNDA, + KTHI, + LANA, + LAOO, + LATN, + LEPC, + LIMB, + LINA, + LINB, + LISU, + LYCI, + LYDI, + MAHJ, + MAKA, + MAND, + MANI, + MARC, + MEDF, + MEND, + MERC, + MERO, + MLYM, + MODI, + MONG, + MROO, + MTEI, + MULT, + MYMR, + NAND, + NARB, + NBAT, + NEWA, + NKOO, + NSHU, + OGAM, + OLCK, + ORKH, + ORYA, + OSGE, + OSMA, + PALM, + PAUC, + PERM, + PHAG, + PHLI, + PHLP, + PHNX, + PLRD, + PRTI, + QAAI, + ROHG, + RJNG, + RUNR, + SAMR, + SARB, + SAUR, + SGNW, + SHAW, + SHRD, + SIDD, + SIND, + SINH, + SOGD, + SOGO, + SORA, + SOYO, + SUND, + SYLO, + SYRC, + TAGB, + TAKR, + TALE, + TALU, + TAML, + TANG, + TAVT, + TELU, + TFNG, + TGLG, + THAA, + THAI, + TIBT, + TIRH, + UGAR, + VAII, + WARA, + WCHO, + XPEO, + XSUX, + YEZI, + YIII, + ZANB, + ZINH, + ZYYY, + ZZZZ, +}; + +// Hangul syllable type. See Unicode section 3.12 and 18.6. +export type hst = enum { + // Leading consonant + L, + // LV syllable + LV, + // LVT syllable + LVT, + // Trailing consonant + T, + // Vowel + V, + // Non-applicable + NA, +}; + +// Indic syllabic category. See IndicSyllabicCategory.txt in the UCD. +export type insc = enum { + AVAGRAHA, + BINDU, + BRAHMI_JOINING_NUMBER, + CANTILLATION_MARK, + CONSONANT, + CONSONANT_DEAD, + CONSONANT_FINAL, + CONSONANT_HEAD_LETTER, + CONSONANT_INITIAL_POSTFIXED, + CONSONANT_KILLER, + CONSONANT_MEDIAL, + CONSONANT_PLACEHOLDER, + CONSONANT_PRECEDING_REPHA, + CONSONANT_PREFIXED, + CONSONANT_REPHA, + CONSONANT_SUBJOINED, + CONSONANT_SUCCEEDING_REPHA, + CONSONANT_WITH_STACKER, + GEMINATION_MARK, + INVISIBLE_STACKER, + JOINER, + MODIFYING_LETTER, + NON_JOINER, + NUKTA, + NUMBER, + NUMBER_JOINER, + OTHER, + PURE_KILLER, + REGISTER_SHIFTER, + SYLLABLE_MODIFIER, + TONE_LETTER, + TONE_MARK, + VIRAMA, + VISARGA, + VOWEL, + VOWEL_DEPENDENT, + VOWEL_INDEPENDENT, +}; + +// Indic positional category. See IndicPositionalCategory.txt in the UCD. +export type inpc = enum { + BOTTOM, + BOTTOM_AND_LEFT, + BOTTOM_AND_RIGHT, + LEFT, + LEFT_AND_RIGHT, + NA, + OVERSTRUCK, + RIGHT, + TOP, + TOP_AND_BOTTOM, + TOP_AND_BOTTOM_AND_LEFT, + TOP_AND_BOTTOM_AND_RIGHT, + TOP_AND_LEFT, + TOP_AND_LEFT_AND_RIGHT, + TOP_AND_RIGHT, + VISUAL_ORDER_LEFT, +}; + +// Identifier and pattern properties. See UAX #31. +export type id = enum uint { + IDS = 1 << 0, + IDC = 1 << 1, + OIDS = 1 << 2, + OIDC = 1 << 2, + XIDS = 1 << 3, + XIDC = 1 << 4, + SYN = 1 << 5, + WS = 1 << 6, +}; + +// Properties related to function and graphics characteristics. This is a +// synethetic type based on mulitple Unicode properties listed in UAX #42 +// section 4.4.10. +export type fgc = enum uint { + DASH = 1 << 0, + HYPHEN = 1 << 1, + QUOTATION_MARK = 1 << 2, + TERMINAL_PUNCTUATION = 1 << 3, + SENTENCE_TERMINAL = 1 << 4, + DIACRITIC = 1 << 5, + EXTENDER = 1 << 6, + SOFT_DOTTED = 1 << 7, + ALPHABETIC = 1 << 8, + OTHER_ALPHABETIC = 1 << 9, + MATH = 1 << 10, + OTHER_MATH = 1 << 11, + HEX_DIGIT = 1 << 12, + ASCII_HEX_DIGIT = 1 << 13, + DEFAULT_IGNORABLE_CODE_POINT = 1 << 14, + OTHER_DEFAULT_IGNORABLE_CODE_POINT = 1 << 15, + LOGICAL_ORDER_EXCEPTION = 1 << 16, + PREPENDED_CONCATENATION_MARK = 1 << 17, + WHITE_SPACE = 1 << 18, + VERTICAL_ORIENTATION = 1 << 19, + REGIONAL_INDICATOR = 1 << 20, +}; + +// Properties related to boundaries. This is a synethetic type based on mulitple +// Unicode properties listed in UAX #42 section 4.4.20. +export type gr = enum uint { + GR_BASE = 1 << 0, + GR_EXT = 1 << 1, +}; + +// Grapheme cluster break. See UAX #29. +export type gcb = enum { + XX, + CN, + CR, + EX, + L, + LF, + LV, + LVT, + PP, + RI, + SM, + T, + V, + ZWJ, +}; + +// Word break. See UAX #29. +export type wb = enum { + XX, + CR, + DQ, + EX, + EXTEND, + FO, + HL, + KA, + LE, + LF, + MB, + ML, + MN, + NL, + NU, + RI, + SQ, + WSEGSPACE, + ZWJ, +}; + +// Sentence break. See UAX #29. +export type sb = enum { + XX, + AT, + CL, + CR, + EX, + FO, + LE, + LF, + LO, + NU, + SC, + SE, + SP, + ST, + UP, +}; + +// Properties related to ideographs. This is a synethetic type based on mulitple +// Unicode properties listed in UAX #42 section 4.4.21. +export type ideo = enum uint { + IDEO = 1 << 1, + UIDEO = 1 << 2, + IDSB = 1 << 3, + IDST = 1 << 4, + RADICAL = 1 << 5, +}; + +// Miscellaneous properties. This is a synethetic type based on mulitple Unicode +// properties listed in UAX #42 section 4.4.22. +export type misc = enum uint { + DEP = 1 << 0, + VS = 1 << 1, + NCHAR = 1 << 2, +}; + +// Properties related to Emoji. This is a synethetic type based on mulitple +// Unicode properties listed in UAX #42 section 4.4.26. +export type emoji = enum uint { + EMOJI = 1 << 0, + EPRES = 1 << 1, + EMOD = 1 << 2, + EBASE = 1 << 3, + ECOMP = 1 << 4, + EXTPICT = 1 << 5, +}; diff --git a/example/random.ha b/example/random.ha new file mode 100644 index 000000000..2d0dc1ce4 --- /dev/null +++ b/example/random.ha @@ -0,0 +1,35 @@ +// math::random provides a pseudorandom number generator, which yields a +// deterministic sequence of psuedo-random numbers based on a seed value. +// +// Beware! This module is NOT suitable for generating genuinely random data for +// cryptographic use. See [crypto::random] for cryptographically secure random +// number generation. + +// State for a pseudorandom number generator. +export type random = u64; + +// Initializes a pseudorandom number generator with a given seed. This seed will +// yield the same sequence of psuedo-random numbers if used again. +export fn init(seed: u64) random = seed; + +// Returns a psuedo-random 64-bit unsigned integer. +export fn next(r: *random) u64 = { + // SplitMix64 + *r += 0x9e3779b97f4a7c15; + *r = (*r ^ *r >> 30) * 0xbf58476d1ce4e5b9; + *r = (*r ^ *r >> 27) * 0x94d049bb133111eb; + return *r ^ *r >> 31; +}; + +@test fn rng() void = { + let r = init(0); + let expected: [_]u64 = [ + 16294208416658607535, + 15501543990041496116, + 15737388954706874752, + 15091258616627000950, + ]; + for (let i = 0z; i < len(expected); i += 1) { + assert(next(&r) == expected[i]); + }; +}; diff --git a/example/reverse.ha b/example/reverse.ha new file mode 100644 index 000000000..2caab57df --- /dev/null +++ b/example/reverse.ha @@ -0,0 +1,22 @@ +// Reverses a slice. +export fn reverse(b: []void, membsz: size) void = { + if (len(b) == 0) { + return; + }; + let a = b: *[*]u8; + for (let s = 0z, e = len(b) - 1; s < e) { + for (let i = 0z; i < membsz; i += 1z) { + let z = a[s * membsz + i]; + a[s * membsz + i] = a[e * membsz + i]; + a[e * membsz + i] = z; + }; + s += 1; + e -= 1; + }; +}; + +@test fn reverse() void = { + let a: []int = [1, 2, 3, 4]; + reverse(a, size(int)); + assert(a[0] == 4 && a[1] == 3 && a[2] == 2 && a[3] == 1); +}; diff --git a/example/rt.ha b/example/rt.ha new file mode 100644 index 000000000..f73e791ee --- /dev/null +++ b/example/rt.ha @@ -0,0 +1,16 @@ +use rt; + +// Wraps an [rt::errno] to produce an [errors::opaque]. This is a non-portable +// interface which is mainly provided to support internal stdlib requirements. +export fn errno(errno: rt::errno) opaque = { + static assert(size(rt::errno) <= size(opaque_data)); + let err = opaque { strerror = &rt_strerror, ... }; + let ptr = &err.data: *rt::errno; + *ptr = errno; + return err; +}; + +fn rt_strerror(err: *opaque_data) const str = { + let err = &err: *rt::errno; + return rt::strerror(*err); +}; diff --git a/example/run.ha b/example/run.ha new file mode 100644 index 000000000..b9eed39df --- /dev/null +++ b/example/run.ha @@ -0,0 +1,108 @@ +type test = struct { + name: str, + func: *fn() void, +}; + +type abort_reason = struct { + loc: str, + msg: str, +}; + +const @symbol("__test_array_start") test_start: [*]test; +const @symbol("__test_array_end") test_end: [*]test; + +let jmp: jmpbuf = jmpbuf { ... }; +let reason: abort_reason = abort_reason { ... }; + +export fn tests_main() size = { + const ntest = (&test_end: uintptr - &test_start: uintptr): size / size(test); + let maxname = 0z; + for (let i = 0z; i < ntest; i += 1) { + if (len(test_start[i].name) > maxname) { + maxname = len(test_start[i].name); + }; + }; + + let failures: [](str, abort_reason) = []; + let npass = 0z, nfail = 0z; + print("Running "); + print(ztos(ntest)); + print(" tests:\n\n"); + time_start(); + for (let i = 0z; i < ntest; i += 1) { + if (!should_test(test_start[i].name)) { + continue; + }; + print(test_start[i].name); + dots(maxname - len(test_start[i].name) + 3); + print(" "); + + if (setjmp(&jmp) != 0) { + nfail += 1; + append(failures, (test_start[i].name, reason)); + print("FAIL\n"); + continue; + }; + test_start[i].func(); + + npass += 1; + print("OK\n"); + }; + let end = time_stop(); + + if (nfail != 0) { + print("\n"); + print(ztos(nfail)); + if (nfail == 1) { + print(" test failed:\n"); + } else { + print(" tests failed:\n"); + }; + for (let i = 0z; i < nfail; i += 1) { + print(failures[i].0); + print(": "); + if (len(failures[i].1.loc) != 0) { + print(failures[i].1.loc); + print(": "); + }; + print(failures[i].1.msg); + print("\n"); + }; + }; + + print("\n"); + print(ztos(npass)); + print(" passed; "); + print(ztos(nfail)); + print(" failed; "); + print(ztos(ntest)); + print(" tests completed in "); + print(ztos(end.0)); + print("."); + print(ztos(end.1)); + print("s\n"); + + return nfail; +}; + +fn print(msg: str) void = write(1, *(&msg: **void): *const char, len(msg)); + +fn dots(n: size) void = { + // XXX: this is slow, I guess + for (let i = 0z; i < n; i += 1) { + print("."); + }; +}; + +fn should_test(name: str) bool = { + if (argc == 1) { + return true; + }; + for (let i = 1z; i < argc; i += 1) { + let s = from_c_unsafe(argv[i]); + if (name == s) { + return true; + }; + }; + return false; +}; diff --git a/example/rune.ha b/example/rune.ha new file mode 100644 index 000000000..f127a3b27 --- /dev/null +++ b/example/rune.ha @@ -0,0 +1,27 @@ +use types; + +const masks: [_]u8 = [0x7F, 0x1F, 0x0F, 0x07, 0x03, 0x01]; + +type rsize = struct { + mask: u8, + result: u8, + octets: size, +}; + +const sizes: [_]rsize = [ + rsize { mask = 0x80, result = 0x00, octets = 1 }, + rsize { mask = 0xE0, result = 0xC0, octets = 2 }, + rsize { mask = 0xF0, result = 0xE0, octets = 3 }, + rsize { mask = 0xF8, result = 0xF0, octets = 4 }, + rsize { mask = 0xFC, result = 0xF8, octets = 5 }, + rsize { mask = 0xFE, result = 0xF8, octets = 6 }, +]; + +// Returns the size of a rune, in octets, when encoded as UTF-8. +export fn runesz(r: rune) size = { + const ch = r: u32; + return if (ch < 0x80) 1 + else if (ch < 0x800) 2 + else if (ch < 0x10000) 3 + else 4; +}; diff --git a/example/scan.ha b/example/scan.ha new file mode 100644 index 000000000..78f1d48ef --- /dev/null +++ b/example/scan.ha @@ -0,0 +1,391 @@ +use ascii; +use bytes; +use crypto::sha256; +use encoding::utf8; +use fs; +use hare::ast; +use hare::lex; +use hare::parse; +use hash; +use io; +use path; +use slice; +use sort; +use strings; +use strio; +use fmt; + +// Scans the files in a directory for eligible build inputs and returns a +// [version] which includes all applicable files and their dependencies. +export fn scan(ctx: *context, path: str) (version | error) = { + // TODO: Incorporate defines into the hash + let sha = sha256::sha256(); + //defer! hash::close(sha); + let iter = match (fs::iter(ctx.fs, path)) { + fs::wrongtype => { + // Single file case + let inputs: []input = []; + let deps: []ast::ident = []; + let ft = match (type_for_ext(path)) { + void => return module_not_found, + ft: filetype => ft, + }; + let st = fs::stat(ctx.fs, path)?; + let in = input { + path = fs::resolve(ctx.fs, path), + stat = st, + ft = ft, + hash = scan_file(ctx, path, &deps)?, + ... + }; + append(inputs, in); + hash::write(sha, in.hash); + return version { + hash = hash::finish(sha), + basedir = path::dirname(fs::resolve(ctx.fs, path)), + depends = deps, + inputs = inputs, + }; + }, + err: fs::error => return err, + iter: *fs::iterator => iter, + }; + let ver = version { + basedir = strings::dup(path), + ... + }; + scan_directory(ctx, &ver, sha, path, iter)?; + ver.hash = hash::finish(sha); + return ver; +}; + +// Given a file or directory name, parses it into the basename, extension, and +// tag set. +fn parse_name(name: str) (str, str, []tag) = { + let ext = path::extension(name); + let base = ext.0, ext = ext.1; + + let p = strings::index(base, '+'); + let m = strings::index(base, '-'); + if (p is void && m is void) { + return (base, ext, []); + }; + let i: size = + if (p is void && m is size) m: size + else if (m is void && p is size) p: size + else if (m: size < p: size) m: size + else p: size; + let tags = strings::sub(base, i, strings::end); + let tags = match (parsetags(tags)) { + void => return (base, ext, []), + t: []tag => t, + }; + let base = strings::sub(base, 0, i); + return (base, ext, tags); +}; + +fn strcmp(a: const *void, b: const *void) int = { + const a = *(a: const *str); + const b = *(b: const *str); + return ascii::strcmp(a, b) as int; +}; + +fn scan_directory( + ctx: *context, + ver: *version, + sha: *hash::hash, + path: str, + iter: *fs::iterator, +) (void | error) = { + let files: []str = [], dirs: []str = []; + defer { + for (let i = 0z; i < len(files); i += 1) { + free(files[i]); + }; + free(files); + + for (let i = 0z; i < len(dirs); i += 1) { + free(dirs[i]); + }; + free(dirs); + }; + + for (true) { + let ent = match (fs::next(iter)) { + void => break, + ent: fs::dirent => ent, + }; + + switch (ent.ftype) { + fs::mode::LINK => abort(), // TODO + fs::mode::DIR => append(dirs, strings::dup(ent.name)), + fs::mode::REG => append(files, strings::dup(ent.name)), + }; + }; + + // Sorted to keep the hash consistent + sort::sort(dirs, size(str), &strcmp); + sort::sort(files, size(str), &strcmp); + + // Tuple of is_directory, basename, tags, and path to a candidate input. + let inputs: [](bool, str, []tag, str) = []; + defer for (let i = 0z; i < len(inputs); i += 1) { + // For file paths, these are assigned to the input, which + // assumes ownership over them. + if (inputs[i].0) { + free(inputs[i].1); + tags_free(inputs[i].2); + free(inputs[i].3); + }; + }; + + // For a given basename, only the most specific path (i.e. with the most + // tags) is used. + // + // foo.ha + // foo+linux.ha + // foo+linux+x86_64/ + // bar.ha + // baz.ha + // + // In this case, foo+linux+x86_64 is the most specific, and so its used + // as the build input and the other two files are discarded. + + for (let i = 0z; i < len(dirs); i += 1) { + let name = dirs[i]; + let parsed = parse_name(name); + let base = parsed.0, tags = parsed.2; + + let d = strings::toutf8(name); + if (len(d) == 0 || ( + !strings::has_prefix(name, "+") && + !strings::has_prefix(name, "-"))) { + continue; + }; + if (!tagcompat(ctx.tags, tags)) { + continue; + }; + + let path = path::join(path, name); + let tuple = (true, strings::dup(base), tags, path); + let superceeded = false; + for (let j = 0z; j < len(inputs); j += 1) { + if (inputs[j].1 != base) { + continue; + }; + let theirs = inputs[j].2; + if (len(theirs) < len(tags)) { + free(inputs[j].1); + tags_free(inputs[j].2); + free(inputs[j].3); + inputs[j] = tuple; + superceeded = true; + break; + } else if (len(theirs) > len(tags)) { + // They are more specific + superceeded = true; + break; + } else if (len(base) != 0) { + return (path, inputs[j].3): ambiguous; + }; + }; + if (!superceeded) { + append(inputs, tuple); + }; + }; + + for (let i = 0z; i < len(files); i += 1) { + let name = files[i]; + let parsed = parse_name(name); + let base = parsed.0, ext = parsed.1, tags = parsed.2; + + let eligible = false; + static const exts = [".ha", ".s"]; + for (let i = 0z; i < len(exts); i += 1) { + if (exts[i] == ext) { + eligible = true; + break; + }; + }; + if (!eligible || !tagcompat(ctx.tags, tags)) { + tags_free(tags); + continue; + }; + + let path = path::join(path, name); + let tuple = (false, base, tags, path); + let superceeded = false; + for (let j = 0z; j < len(inputs); j += 1) { + if (inputs[j].1 != base) { + continue; + }; + let theirs = inputs[j].2; + if (len(theirs) < len(tags)) { + // We are more specific + free(inputs[j].1); + tags_free(inputs[j].2); + free(inputs[j].3); + inputs[j] = tuple; + superceeded = true; + break; + } else if (len(theirs) > len(tags)) { + // They are more specific + superceeded = true; + break; + } else if (len(base) != 0) { + return (path, inputs[j].3): ambiguous; + }; + }; + if (!superceeded) { + append(inputs, tuple); + }; + }; + + for (let i = 0z; i < len(inputs); i += 1) { + let isdir = inputs[i].0, path = inputs[i].3; + if (isdir) { + let iter = fs::iter(ctx.fs, path)?; + scan_directory(ctx, ver, sha, path, iter)?; + } else { + let st = fs::stat(ctx.fs, path)?; + let in = input { + path = fs::resolve(ctx.fs, path), + stat = st, + ft = type_for_ext(path) as filetype, + hash = scan_file(ctx, path, &ver.depends)?, + basename = inputs[i].1, + tags = inputs[i].2, + ... + }; + append(ver.inputs, in); + hash::write(sha, in.hash); + }; + }; +}; + +// Looks up a module by its identifier from HAREPATH, and returns a [version] +// which includes all eligible build inputs. +export fn lookup(ctx: *context, name: ast::ident) (version | error) = { + let ipath = identpath(name); + for (let i = len(ctx.paths); i > 0; i -= 1) { + let cand = path::join(ctx.paths[i - 1], ipath); + defer free(cand); + match (scan(ctx, cand)) { + v: version => return v, + e: error => void, + }; + }; + return module_not_found; +}; + +fn type_for_ext(name: str) (filetype | void) = { + const ext = path::extension(name).1; + return + if (ext == ".ha") filetype::HARE + else if (ext == ".s") filetype::ASSEMBLY + else void; +}; + +fn scan_file( + ctx: *context, + path: str, + deps: *[]ast::ident, +) ([]u8 | error) = { + let f = fs::open(ctx.fs, path)?; + defer io::close(f); + let sha = sha256::sha256(); + //defer! hash::close(sha); + + hash::write(sha, strings::toutf8(path)); + + let tee = io::tee(f, hash::writer(sha)); + defer io::close(tee); + + let lexer = lex::init(tee, path); + let imports = parse::imports(&lexer)?; + for (let i = 0z; i < len(imports); i += 1) { + let ident = match (imports[i]) { + m: ast::import_module => m: ast::ident, + a: ast::import_alias => a.ident, + o: ast::import_objects => o.ident, + }; + if (!have_ident(deps, ident)) { + append(*deps, ident); + }; + }; + + io::copy(io::empty, tee)?; // Finish spooling out the file for the SHA + return hash::finish(sha); +}; + +fn have_ident(sl: *[]ast::ident, id: ast::ident) bool = { + // XXX: We shouldn't have to deref sl here + for (let i = 0z; i < len(*sl); i += 1) { + if (ast::ident_eq(sl[i], id)) { + return true; + }; + }; + return false; +}; + +// Parses a set of build tags, returning void if the string is an invalid tag +// set. The caller must free the return value with [tags_free]. +export fn parsetags(in: str) ([]tag | void) = { + let tags: []tag = []; + // defer! tags_free(tags); + let iter = strings::iter(in); + for (true) { + let t = tag { ... }; + let m = match (strings::next(&iter)) { + void => break, + r: rune => r, + }; + t.mode = switch (m) { + * => return, + '+' => tag_mode::INCLUSIVE, + '-' => tag_mode::EXCLUSIVE, + }; + let buf = strio::dynamic(); + for (true) match (strings::next(&iter)) { + void => break, + r: rune => { + if (ascii::isalnum(r) || r == '_') { + strio::appendrune(buf, r); + } else { + strings::push(&iter, r); + break; + }; + }, + }; + t.name = strio::finish(buf); + append(tags, t); + }; + return tags; +}; + +// Frees a set of tags. +export fn tags_free(tags: []tag) void = { + for (let i = 0z; i < len(tags); i += 1) { + free(tags[i].name); + }; + free(tags); +}; + +// Compares two tag sets and tells you if they are compatible. +export fn tagcompat(have: []tag, want: []tag) bool = { + // XXX: O(n²), lame + for (let i = 0z; i < len(want); i += 1) { + let present = false; + for (let j = 0z; j < len(have); j += 1) { + if (have[j].name == want[i].name) { + present = have[j].mode == tag_mode::INCLUSIVE; + break; + }; + }; + switch (want[i].mode) { + tag_mode::INCLUSIVE => if (!present) return false, + tag_mode::EXCLUSIVE => if (present) return false, + }; + }; + return true; +}; diff --git a/example/scanner.ha b/example/scanner.ha new file mode 100644 index 000000000..251c988dc --- /dev/null +++ b/example/scanner.ha @@ -0,0 +1,134 @@ +use bytes; +use encoding::utf8; +use io; +use strings; +use types; + +// Reads a single byte from the stream. +export fn scanbyte(stream: *io::stream) (u8 | io::EOF | io::error) = { + let buf: [1]u8 = [0...]; + + return match (io::read(stream, buf)?) { + read: size => if (read > 0) buf[0] else io::EOF, + io::EOF => io::EOF, + }; +}; + +// Reads a slice of bytes until the delimiter. Delimiter is not included. The +// return value must be freed by the caller. +export fn scantok(stream: *io::stream, delim: u8) ([]u8 | io::EOF | io::error) = { + let buf: []u8 = []; + + for (true) { + match (scanbyte(stream)?) { + res: u8 => { + if (res == delim) { + break; + }; + append(buf, res); + }, + io::EOF => { + if (len(buf) == 0) { + return io::EOF; + }; + break; + }, + }; + }; + + return buf; +}; + +// Reads a slice of bytes until a newline character (\n, 0x10). Newline itself +// is not included. The return value must be freed by the caller. +export fn scanline(stream: *io::stream) ([]u8 | io::EOF | io::error) = + scantok(stream, '\n': u32: u8); + +// Reads a rune from a UTF-8 stream. +export fn scanrune(stream: *io::stream) (rune | utf8::invalid | io::EOF | io::error) = { + let b: [4]u8 = [0...]; + match (io::read(stream, b[..1])?) { + n: size => assert(n == 1), + io::EOF => return io::EOF, + }; + + const sz = utf8::utf8sz(b[0]); + if (sz == types::SIZE_MAX) { + return utf8::invalid; + }; + + if (sz == 1) { + return b[0]: u32: rune; + }; + + match (io::read(stream, b[1..sz])) { + n: size => assert(n == sz - 1), + e: (io::error | io::EOF) => return e, + }; + + let dec = utf8::decode(b[..sz]); + return match (utf8::next(&dec)) { + r: rune => r, + utf8::invalid => utf8::invalid, + (void | utf8::more) => io::EOF, + }; +}; + +@test fn scanbyte() void = { + let buf = fixed([1, 3, 3, 7], io::mode::READ); + + assert(scanbyte(buf) as u8 == 1); + assert(scanbyte(buf) as u8 == 3); + assert(scanbyte(buf) as u8 == 3); + assert(scanbyte(buf) as u8 == 7); + assert(scanbyte(buf) is io::EOF); +}; + +@test fn scantok() void = { + let buf = fixed([1, 3, 4, 5, 3, 7], io::mode::READ); + + let tok = scantok(buf, 4) as []u8; + defer free(tok); + assert(bytes::equal(tok, [1, 3])); + + let tok = scantok(buf, 7) as []u8; + defer free(tok); + assert(bytes::equal(tok, [5, 3])); + + assert(scantok(buf, 1) is io::EOF); +}; + +@test fn scanline() void = { + let helloworld = strings::toutf8("hello\nworld"); + let buf = fixed(helloworld, io::mode::READ); + + let line = scanline(buf) as []u8; + defer free(line); + assert(bytes::equal(line, strings::toutf8("hello"))); + + let line = scanline(buf) as []u8; + defer free(line); + assert(bytes::equal(line, strings::toutf8("world"))); + + assert(scanline(buf) is io::EOF); +}; + +@test fn scanrune() void = { + let in = fixed([ + 0xE3, 0x81, 0x93, 0xE3, 0x82, 0x93, 0xE3, 0x81, + 0xAB, 0xE3, 0x81, 0xA1, 0xE3, 0x81, 0xAF, 0x00, + ], io::mode::READ); + + const expected: [_](rune | utf8::invalid | io::EOF | io::error) = [ + 'こ', 'ん', 'に', 'ち', 'は', '\0', io::EOF, + ]; + for (let i = 0z; i < len(expected); i += 1) { + let want = expected[i]; + + match (scanrune(in)) { + r: rune => assert(want is rune && want as rune == r), + io::EOF => assert(want is io::EOF), + * => abort(), + }; + }; +}; diff --git a/example/schedule.ha b/example/schedule.ha new file mode 100644 index 000000000..ee5f138ab --- /dev/null +++ b/example/schedule.ha @@ -0,0 +1,262 @@ +use encoding::hex; +use fmt; +use hare::ast; +use hare::module; +use hare::unparse; +use hash::fnv; +use hash; +use os; +use path; +use strings; +use strio; + +fn ident_hash(ident: ast::ident) u32 = { + let hash = fnv::fnv32(); + defer hash::close(hash); + for (let i = 0z; i < len(ident); i += 1) { + hash::write(hash, strings::toutf8(ident[i])); + hash::write(hash, [0]); + }; + return fnv::sum32(hash); +}; + +fn sched_module(plan: *plan, ident: ast::ident, link: *[]*task) *task = { + let hash = ident_hash(ident); + // TODO: We should not have to dereference the bucket for len or append + let bucket = &plan.modmap[hash % len(plan.modmap)]; + for (let i = 0z; i < len(*bucket); i += 1) { + if (bucket[i].hash == hash) { + return bucket[i].task; + }; + }; + + let ver = match (module::lookup(plan.context, ident)) { + err: module::error => { + let ident = unparse::identstr(ident); + fmt::fatal("Error resolving {}: {}", + ident, module::strerror(err)); + }, + ver: module::version => ver, + }; + + let depends: []*task = []; + defer free(depends); + for (let i = 0z; i < len(ver.depends); i += 1) { + const dep = ver.depends[i]; + let obj = sched_module(plan, dep, link); + append(depends, obj); + }; + + let obj = sched_hare_object(plan, ver, ident, depends...); + append(*bucket, modcache { + hash = hash, + task = obj, + ident = ident, + version = ver, + }); + append(*link, obj); + return obj; +}; + +// Schedules a task which compiles objects into an executable. +fn sched_ld(plan: *plan, output: str, depend: *task...) *task = { + let task = alloc(task { + status = status::SCHEDULED, + output = output, + depend = mkdepends(depend...), + cmd = alloc([ + os::tryenv("LD", "ld"), + "-T", plan.script, + "-o", output, + ]), + }); + for (let i = 0z; i < len(depend); i += 1) { + append(task.cmd, depend[i].output); + }; + append(plan.scheduled, task); + return task; +}; + +// Schedules a task which merges objects into an archive. +fn sched_ar(plan: *plan, output: str, depend: *task...) *task = { + let task = alloc(task { + status = status::SCHEDULED, + output = output, + depend = mkdepends(depend...), + cmd = alloc([ + os::tryenv("AR", "ar"), "-csr", output, + ]), + }); + for (let i = 0z; i < len(depend); i += 1) { + assert(strings::has_suffix(depend[i].output, ".o")); + append(task.cmd, depend[i].output); + }; + append(plan.scheduled, task); + return task; +}; + +// Schedules a task which compiles assembly into an object. +fn sched_as(plan: *plan, output: str, input: str, depend: *task...) *task = { + let task = alloc(task { + status = status::SCHEDULED, + output = output, + depend = mkdepends(depend...), + cmd = alloc([ + os::tryenv("AS", "as"), "-o", output, input, + ]), + }); + append(plan.scheduled, task); + return task; +}; + +// Schedules a task which compiles an SSA file into assembly. +fn sched_qbe(plan: *plan, output: str, depend: *task) *task = { + let task = alloc(task { + status = status::SCHEDULED, + output = output, + depend = mkdepends(depend), + cmd = alloc([ + os::tryenv("QBE", "qbe"), "-o", output, depend.output, + ]), + }); + append(plan.scheduled, task); + return task; +}; + +// Schedules tasks which compiles a Hare module into an object or archive. +fn sched_hare_object( + plan: *plan, + ver: module::version, + namespace: ast::ident, + depend: *task... +) *task = { + // XXX: Do we care to support assembly-only modules? + let mixed = false; + for (let i = 0z; i < len(ver.inputs); i += 1) { + if (strings::has_suffix(ver.inputs[i].path, ".s")) { + mixed = true; + break; + }; + }; + + let ssa = mkfile(plan, "ssa"); + let harec = alloc(task { + status = status::SCHEDULED, + output = ssa, + depend = mkdepends(depend...), + cmd = alloc([ + os::tryenv("HAREC", "harec"), "-o", ssa, + ]), + }); + + let current = false; + let output = if (len(namespace) != 0) { + let version = hex::encodestr(ver.hash); + let ns = unparse::identstr(namespace); + let env = module::identuscore(namespace); + defer free(env); + + append(harec.cmd, "-N", ns); + append(plan.environ, ( + fmt::asprintf("HARE_VERSION_{}", env), version, + )); + + // TODO: Keep this around and append new versions, rather than + // overwriting with just the latest + let manifest = match (module::manifest_load( + plan.context, namespace)) { + err: module::error => fmt::fatal( + "Error reading cache entry for {}: {}", + ns, module::strerror(err)), + m: module::manifest => m, + }; + defer module::manifest_finish(&manifest); + current = module::current(&manifest, &ver); + + let name = fmt::asprintf("{}.{}", version, + if (mixed) "a" else "o"); + defer free(name); + + let td = fmt::asprintf("{}.td", version); + defer free(td); + + let path = plan.context.cache; + for (let i = 0z; i < len(namespace); i += 1) { + path = path::join(path, namespace[i]); + }; + os::mkdirs(path); + append(harec.cmd, "-t", path::join(path, td)); + path::join(path, name); + } else { + // XXX: This is probably kind of dumb + // It would be better to apply any defines which affect this + // namespace instead + for (let i = 0z; i < len(plan.context.defines); i += 1) { + append(harec.cmd, "-D", plan.context.defines[i]); + }; + + // XXX: This is kind of hacky too + for (let i = 0z; i < len(plan.context.tags); i += 1) { + if (plan.context.tags[i].mode == module::tag_mode::INCLUSIVE) { + append(harec.cmd, "-T", strings::concat("+", + plan.context.tags[i].name)); + }; + }; + + mkfile(plan, "o"); // TODO: Should exes go in the cache? + }; + + for (let i = 0z; i < len(ver.inputs); i += 1) { + let path = ver.inputs[i].path; + if (strings::has_suffix(path, ".ha")) { + append(harec.cmd, path); + }; + }; + + if (current) { + harec.status = status::COMPLETE; + harec.output = output; + append(plan.complete, harec); + return harec; + } else { + append(plan.scheduled, harec); + }; + + let s = mkfile(plan, "s"); + let qbe = sched_qbe(plan, s, harec); + let hare_obj = sched_as(plan, + if (mixed) mkfile(plan, "o") else output, + s, qbe); + if (!mixed) { + return hare_obj; + }; + + let objs: []*task = alloc([hare_obj]); + defer free(objs); + for (let i = 0z; i < len(ver.inputs); i += 1) { + // XXX: All of our assembly files don't depend on anything else, + // but that may not be generally true. We may have to address + // this at some point. + let path = ver.inputs[i].path; + if (!strings::has_suffix(path, ".s")) { + continue; + }; + append(objs, sched_as(plan, mkfile(plan, "o"), path)); + }; + return sched_ar(plan, output, objs...); +}; + +// Schedules tasks which compiles hare sources into an executable. +fn sched_hare_exe( + plan: *plan, + ver: module::version, + output: str, + depend: *task... +) *task = { + let obj = sched_hare_object(plan, ver, [], depend...); + // TODO: We should be able to use partial variadic application + let link: []*task = alloc([], len(depend)); + defer free(link); + append(link, obj, ...depend); + return sched_ld(plan, strings::dup(output), link...); +}; diff --git a/example/search.ha b/example/search.ha new file mode 100644 index 000000000..1adadd562 --- /dev/null +++ b/example/search.ha @@ -0,0 +1,26 @@ +// Performs a binary search over a sorted slice. 'in' shall be the sorted slice, +// and 'sz' shall be the size of each array member. The 'cmp' function will be +// called with the key value and an array member, and shall return a integer +// less than, equal to, or greater than zero if the key is, respectively, less +// than, equal to, or greater than the array member. +export fn search( + in: []void, + sz: size, + key: const *void, + cmp: *fn(a: const *void, b: const *void) int, +) nullable *void = { + let ba = in: *[*]u8; + for (let nmemb = len(in); nmemb > 0) { + let v = &ba[nmemb / 2 * sz]; + let r = cmp(key, v); + if (r < 0) { + nmemb /= 2; + } else if (r > 0) { + ba = (v: uintptr + sz: uintptr): *[*]u8; + nmemb -= nmemb / 2 + 1; + } else { + return v; + }; + }; + return null; +}; diff --git a/example/segmalloc.ha b/example/segmalloc.ha new file mode 100644 index 000000000..2017a9f2d --- /dev/null +++ b/example/segmalloc.ha @@ -0,0 +1,26 @@ +// Allocates a segment. +fn segmalloc(n: size) nullable *void = { + return match(mmap(null, n, + PROT_READ | PROT_WRITE, + MAP_PRIVATE | MAP_ANON, -1, 0)) { + err: errno => { + assert(err == ENOMEM: errno); + null; + }, + p: *void => p, + }; +}; + +// Frees a segment allocated with segmalloc. +fn segfree(p: *void, s: size) void = { + match (munmap(p, s)) { + err: errno => abort("munmap failed"), + void => void, + }; +}; + +// Marks a segment as writable and drops the execute bit. +fn segwrite(seg: *void, n: size) void = mprotect(seg, n, PROT_READ | PROT_WRITE); + +// Marks a segment as executable and drops the write bit. +fn segexec(seg: *void, n: size) void = mprotect(seg, n, PROT_READ | PROT_EXEC); diff --git a/example/setuid.ha b/example/setuid.ha new file mode 100644 index 000000000..3b33659d0 --- /dev/null +++ b/example/setuid.ha @@ -0,0 +1,41 @@ +use rt; + +// Sets the caller's user ID to the specified value. This generally requires +// elevated permissions from the calling process. +// +// If the system returns an error, this function will abort the program. Failing +// to handle errors from setuid is a grave security issue in your program, and +// therefore we require this function to succeed. If you need to handle the +// error case gracefully, call the appropriate syscall wrapper in [rt] yourself, +// and take extreme care to handle errors correctly. +export fn setuid(uid: uint) void = rt::setresuid(uid, -1u, -1u) as void; + +// Sets the caller's effective user ID to the specified value. This generally +// requires elevated permissions from the calling process. +// +// If the system returns an error, this function will abort the program. Failing +// to handle errors from seteuid is a grave security issue in your program, and +// therefore we require this function to succeed. If you need to handle the +// error case gracefully, call the appropriate syscall wrapper in [rt] yourself, +// and take extreme care to handle errors correctly. +export fn seteuid(uid: uint) void = rt::setresuid(-1u, uid, -1u) as void; + +// Sets the caller's group ID to the specified value. This generally requires +// elevated permissions from the calling process. +// +// If the system returns an error, this function will abort the program. Failing +// to handle errors from setuid is a grave security issue in your program, and +// therefore we require this function to succeed. If you need to handle the +// error case gracefully, call the appropriate syscall wrapper in [rt] yourself, +// and take extreme care to handle errors correctly. +export fn setgid(gid: uint) void = rt::setresgid(gid, -1u, -1u) as void; + +// Sets the caller's effective group ID to the specified value. This generally +// requires elevated permissions from the calling process. +// +// If the system returns an error, this function will abort the program. Failing +// to handle errors from setegid is a grave security issue in your program, and +// therefore we require this function to succeed. If you need to handle the +// error case gracefully, call the appropriate syscall wrapper in [rt] yourself, +// and take extreme care to handle errors correctly. +export fn setegid(gid: uint) void = rt::setresgid(-1u, gid, -1u) as void; diff --git a/example/sha1.ha b/example/sha1.ha new file mode 100644 index 000000000..ffb36c842 --- /dev/null +++ b/example/sha1.ha @@ -0,0 +1,224 @@ +use hash; +use io; +use crypto::math; +use endian; + +// The size, in bytes, of a SHA-1 digest. +export def SIZE: size = 20; + +export def BLOCKSIZE: size = 64; + +def chunk: size = 64; +def init0: u32 = 0x67452301; +def init1: u32 = 0xEFCDAB89; +def init2: u32 = 0x98BADCFE; +def init3: u32 = 0x10325476; +def init4: u32 = 0xC3D2E1F0; + +type digest = struct { + hash: hash::hash, + h: [5]u32, + x: [chunk]u8, + nx: size, + ln: size, +}; + +// Creates a [hash::hash] which computes a SHA-1 hash. Note that this alogorithm +// is no longer considered secure. Where possible, applications are encouraged +// to use [sha256] or [sha512] instead. +export fn sha1() *hash::hash = { + let sha = alloc(digest { + hash = hash::hash { + stream = io::stream { + writer = &write, + closer = &close, + ... + }, + sum = &sum, + reset = &reset, + sz = SIZE, + ... + }, + }); + let hash = &sha.hash; + hash::reset(hash); + return hash; +}; + +fn write(st: *io::stream, buf: const []u8) (size | io::error) = { + let h = st: *digest; + let b: []u8 = buf; + let nn = len(buf); + + h.ln += nn; + + if (h.nx > 0) { + // Compute how many bytes can be copied into h.x + let r = len(h.x) - h.nx; + let n = if (nn > r) r else nn; + h.x[h.nx..] = b[..n]; + h.nx += n; + if (h.nx == chunk) { + block(h, h.x[..]); + h.nx = 0; + }; + b = b[n..]; + }; + if (len(b) >= chunk) { + let n = len(b) & ~(chunk - 1); + block(h, b[..n]); + b = b[n..]; + }; + if (len(b) > 0) { + let n = len(b); + h.x[..n] = b[..]; + h.nx = n; + }; + return nn; +}; + +fn close(st: *io::stream) void = { + free(st); +}; + +fn reset(h: *hash::hash) void = { + let h = h: *digest; + h.h[0] = init0; + h.h[1] = init1; + h.h[2] = init2; + h.h[3] = init3; + h.h[4] = init4; + h.nx = 0; + h.ln = 0; +}; + +fn sum(h: *hash::hash) []u8 = { + let h = h: *digest; + let copy = *h; + let h = © + + // Padding. Add a 1 bit and 0 bits until 56 bytes mod 64. + let ln = h.ln; + let tmp: [64]u8 = [0x80, 0...]; + const pad = if ((ln % 64z) < 56z) 56z - ln % 64z + else 64 + 56z - ln % 64z; + write(&h.hash.stream, tmp[..pad]); + + // Length in bits. + ln <<= 3; + endian::beputu64(tmp, ln: u64); + write(&h.hash.stream, tmp[..8]); + + assert(h.nx == 0); + + // Where we write the digest + let d: [SIZE]u8 = [0...]; + endian::beputu32(d[0..], h.h[0]); + endian::beputu32(d[4..], h.h[1]); + endian::beputu32(d[8..], h.h[2]); + endian::beputu32(d[12..], h.h[3]); + endian::beputu32(d[16..], h.h[4]); + + let slice: []u8 = alloc([], SIZE); + append(slice, ...d); + return slice; +}; + +let K0: u32 = 0x5A827999; +let K1: u32 = 0x6ED9EBA1; +let K2: u32 = 0x8F1BBCDC; +let K3: u32 = 0xCA62C1D6; + +// A generic, pure Hare version of the SHA-1 block step +fn block(h: *digest, p: []u8) void = { + let w: [16]u32 = [0...]; + + let h0 = h.h[0]; + let h1 = h.h[1]; + let h2 = h.h[2]; + let h3 = h.h[3]; + let h4 = h.h[4]; + + for (len(p) >= chunk) { + for (let i = 0z; i < 16; i += 1) { + let j = i * 4; + w[i] = p[j]: u32 << 24 + | p[j+1]: u32 << 16 + | p[j+2]: u32 << 8 + | p[j+3]: u32; + }; + let a = h0; + let b = h1; + let c = h2; + let d = h3; + let e = h4; + + // Each of the four 20-iteration rounds differs only in the + // computation of f and the choice of Ki for i=0..5 + let i = 0z; + for (i < 16; i += 1) { + let f = (b & c) | (~b & d); + let t = math::rotl32(a, 5) + f + e + w[i & 0xf] + K0; + // The order matters here! + e = d; d = c; c = math::rotl32(b, 30); b = a; a = t; + }; + for (i < 20; i += 1) { + let tmp = w[(i - 3) & 0xf] + ^ w[(i - 8) & 0xf] + ^ w[(i - 14) & 0xf] + ^ w[i & 0xf]; + w[i & 0xf] = tmp << 1 | tmp >> 31; + + let f = (b & c) | (~b & d); + let t = math::rotl32(a, 5) + f + e + w[i & 0xf] + K0; + e = d; d = c; c = math::rotl32(b, 30); b = a; a = t; + }; + for (i < 40; i += 1) { + let tmp = w[(i - 3) & 0xf] + ^ w[(i - 8) & 0xf] + ^ w[(i - 14) & 0xf] + ^ w[i & 0xf]; + w[i & 0xf] = tmp << 1 | tmp >> 31; + + let f = b ^ c ^ d; + let t = math::rotl32(a, 5) + f + e + w[i & 0xf] + K1; + e = d; d = c; c = math::rotl32(b, 30); b = a; a = t; + }; + for (i < 60; i += 1) { + let tmp = w[(i - 3) & 0xf] + ^ w[(i - 8) & 0xf] + ^ w[(i - 14) & 0xf] + ^ w[i & 0xf]; + w[i & 0xf] = tmp << 1 | tmp >> 31; + + let f = ((b | c) & d) | (b & c); + let t = math::rotl32(a, 5) + f + e + w[i & 0xf] + K2; + e = d; d = c; c = math::rotl32(b, 30); b = a; a = t; + }; + for (i < 80; i += 1) { + let tmp = w[(i - 3) & 0xf] + ^ w[(i - 8) & 0xf] + ^ w[(i - 14) & 0xf] + ^ w[i & 0xf]; + w[i & 0xf] = tmp << 1 | tmp >> 31; + + let f = b ^ c ^ d; + let t = math::rotl32(a, 5) + f + e + w[i & 0xf] + K3; + e = d; d = c; c = math::rotl32(b, 30); b = a; a = t; + }; + + h0 += a; + h1 += b; + h2 += c; + h3 += d; + h4 += e; + + p = p[chunk..]; + }; + + h.h[0] = h0; + h.h[1] = h1; + h.h[2] = h2; + h.h[3] = h3; + h.h[4] = h4; +}; diff --git a/example/sha256.ha b/example/sha256.ha new file mode 100644 index 000000000..a463524b6 --- /dev/null +++ b/example/sha256.ha @@ -0,0 +1,212 @@ +use crypto::math; +use endian; +use hash; +use io; + +// The size, in bytes, of a SHA-256 digest. +export def SIZE: size = 32; + +// Loosely based on the Go implementation +def chunk: size = 64; +def init0: u32 = 0x6A09E667; +def init1: u32 = 0xBB67AE85; +def init2: u32 = 0x3C6EF372; +def init3: u32 = 0xA54FF53A; +def init4: u32 = 0x510E527F; +def init5: u32 = 0x9B05688C; +def init6: u32 = 0x1F83D9AB; +def init7: u32 = 0x5BE0CD19; + +const k: [_]u32 = [ + 0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, + 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3, + 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, + 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da, + 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, + 0x06ca6351, 0x14292967, 0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13, + 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, + 0xc24b8b70, 0xc76c51a3, 0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, + 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, + 0x5b9cca4f, 0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, + 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2, +]; + +type state = struct { + hash: hash::hash, + h: [8]u32, + x: [chunk]u8, + nx: size, + ln: size, +}; + +// Creates a [hash::hash] which computes a SHA-256 hash. +export fn sha256() *hash::hash = { + let sha = alloc(state { + hash = hash::hash { + stream = io::stream { + writer = &write, + closer = &close, + ... + }, + sum = &sum, + reset = &reset, + sz = SIZE, + ... + }, + }); + let hash = &sha.hash; + hash::reset(hash); + return hash; +}; + +fn reset(h: *hash::hash) void = { + let h = h: *state; + h.h[0] = init0; + h.h[1] = init1; + h.h[2] = init2; + h.h[3] = init3; + h.h[4] = init4; + h.h[5] = init5; + h.h[6] = init6; + h.h[7] = init7; + h.nx = 0; + h.ln = 0; +}; + +fn write(st: *io::stream, buf: const []u8) (size | io::error) = { + let h = st: *state; + let b: []u8 = buf; + let n = len(b); + h.ln += n; + if (h.nx > 0) { + let n = if (len(b) > len(h.x) - h.nx) { + len(h.x) - h.nx; + } else len(b); + h.x[h.nx..] = b[..n]; + h.nx += n; + if (h.nx == chunk) { + block(h, h.x[..]); + h.nx = 0; + }; + b = b[n..]; + }; + if (len(b) >= chunk) { + let n = len(b) & ~(chunk - 1); + block(h, b[..n]); + b = b[n..]; + }; + if (len(b) > 0) { + let n = len(b); + h.x[..n] = b[..]; + h.nx = n; + }; + return n; +}; + +fn close(st: *io::stream) void = { + free(st); +}; + +fn sum(h: *hash::hash) []u8 = { + let h = h: *state; + let copy = *h; + let h = © + + // Add padding + let ln = h.ln; + let tmp: [64]u8 = [0...]; + tmp[0] = 0x80; + const n = if ((ln % 64z) < 56z) 56z - ln % 64z + else 64z + 56z - ln % 64z; + write(&h.hash.stream, tmp[..n]); + + ln <<= 3; + endian::beputu64(tmp, ln: u64); + write(&h.hash.stream, tmp[..8]); + + assert(h.nx == 0); + + let digest: [SIZE]u8 = [0...]; + endian::beputu32(digest[0..], h.h[0]); + endian::beputu32(digest[4..], h.h[1]); + endian::beputu32(digest[8..], h.h[2]); + endian::beputu32(digest[12..], h.h[3]); + endian::beputu32(digest[16..], h.h[4]); + endian::beputu32(digest[20..], h.h[5]); + endian::beputu32(digest[24..], h.h[6]); + endian::beputu32(digest[28..], h.h[7]); + + let slice: []u8 = alloc([], SIZE); + append(slice, ...digest); + return slice; +}; + +// TODO: Rewrite me in assembly +fn block(h: *state, buf: []u8) void = { + let w: [64]u32 = [0...]; + let h0 = h.h[0], h1 = h.h[1], h2 = h.h[2], h3 = h.h[3], + h4 = h.h[4], h5 = h.h[5], h6 = h.h[6], h7 = h.h[7]; + for (len(buf) >= chunk) { + for (let i = 0; i < 16; i += 1) { + let j = i * 4; + w[i] = buf[j]: u32 << 24 + | buf[j+1]: u32 << 16 + | buf[j+2]: u32 << 8 + | buf[j+3]: u32; + }; + + for (let i = 16; i < 64; i += 1) { + let v1 = w[i - 2]; + let t1 = (math::rotr32(v1, 17)) + ^ (math::rotr32(v1, 19)) + ^ (v1 >> 10); + let v2 = w[i - 15]; + let t2 = (math::rotr32(v2, 7)) + ^ (math::rotr32(v2, 18)) + ^ (v2 >> 3); + w[i] = t1 + w[i - 7] + t2 + w[i - 16]; + }; + + let a = h0, b = h1, c = h2, d = h3, + e = h4, f = h5, g = h6, h = h7; + for (let i = 0; i < 64; i += 1) { + let t1 = h + ((math::rotr32(e, 6)) + ^ (math::rotr32(e, 11)) + ^ (math::rotr32(e, 25))) + + ((e & f) ^ (~e & g)) + k[i] + w[i]; + + let t2 = ((math::rotr32(a, 2)) + ^ (math::rotr32(a, 13)) + ^ (math::rotr32(a, 22))) + + ((a & b) ^ (a & c) ^ (b & c)); + h = g; + g = f; + f = e; + e = d + t1; + d = c; + c = b; + b = a; + a = t1 + t2; + }; + + h0 += a; + h1 += b; + h2 += c; + h3 += d; + h4 += e; + h5 += f; + h6 += g; + h7 += h; + + buf = buf[chunk..]; + }; + + h.h[0] = h0; + h.h[1] = h1; + h.h[2] = h2; + h.h[3] = h3; + h.h[4] = h4; + h.h[5] = h5; + h.h[6] = h6; + h.h[7] = h7; +}; diff --git a/example/sha512.ha b/example/sha512.ha new file mode 100644 index 000000000..f553b42c6 --- /dev/null +++ b/example/sha512.ha @@ -0,0 +1,333 @@ +use crypto::math; +use endian; +use hash; +use io; + +// Package sha512 implements the SHA-384, SHA-512, SHA-512/224, and SHA-512/256 +// hash algorithms as defined in FIPS 180-4. + +type variant = enum { + SHA384, + SHA512, + SHA512_224, + SHA512_256, +}; + +// The size, in bytes, of the SHA-512 checksum. +export def SIZE: size = 64; + +// The size, in bytes, of the SHA-512/224 checksum. +export def SIZE224: size = 28; + +// The size, in bytes, of the SHA-512/256 checksum. +export def SIZE256: size = 32; + +// The size, in bytes, of the SHA-384 checksum. +export def SIZE384: size = 48; + +def chunk: size = 128; +def init0: u64 = 0x6a09e667f3bcc908; +def init1: u64 = 0xbb67ae8584caa73b; +def init2: u64 = 0x3c6ef372fe94f82b; +def init3: u64 = 0xa54ff53a5f1d36f1; +def init4: u64 = 0x510e527fade682d1; +def init5: u64 = 0x9b05688c2b3e6c1f; +def init6: u64 = 0x1f83d9abfb41bd6b; +def init7: u64 = 0x5be0cd19137e2179; +def init0_224: u64 = 0x8c3d37c819544da2; +def init1_224: u64 = 0x73e1996689dcd4d6; +def init2_224: u64 = 0x1dfab7ae32ff9c82; +def init3_224: u64 = 0x679dd514582f9fcf; +def init4_224: u64 = 0x0f6d2b697bd44da8; +def init5_224: u64 = 0x77e36f7304c48942; +def init6_224: u64 = 0x3f9d85a86a1d36c8; +def init7_224: u64 = 0x1112e6ad91d692a1; +def init0_256: u64 = 0x22312194fc2bf72c; +def init1_256: u64 = 0x9f555fa3c84c64c2; +def init2_256: u64 = 0x2393b86b6f53b151; +def init3_256: u64 = 0x963877195940eabd; +def init4_256: u64 = 0x96283ee2a88effe3; +def init5_256: u64 = 0xbe5e1e2553863992; +def init6_256: u64 = 0x2b0199fc2c85b8aa; +def init7_256: u64 = 0x0eb72ddc81c52ca2; +def init0_384: u64 = 0xcbbb9d5dc1059ed8; +def init1_384: u64 = 0x629a292a367cd507; +def init2_384: u64 = 0x9159015a3070dd17; +def init3_384: u64 = 0x152fecd8f70e5939; +def init4_384: u64 = 0x67332667ffc00b31; +def init5_384: u64 = 0x8eb44a8768581511; +def init6_384: u64 = 0xdb0c2e0d64f98fa7; +def init7_384: u64 = 0x47b5481dbefa4fa4; + +type digest = struct { + hash: hash::hash, + h: [8]u64, + x: [chunk]u8, + nx: size, + ln: size, + var: variant, +}; + +// Creates a [hash::hash] which computes a SHA-512 hash. +export fn sha512() *hash::hash = init(variant::SHA512, SIZE); + +// Creates a [hash::hash] which computes a SHA-512/224 hash. +export fn sha512_224() *hash::hash = init(variant::SHA512_224, SIZE224); + +// Creates a [hash::hash] which computes a SHA-512/256 hash. +export fn sha512_256() *hash::hash = init(variant::SHA512_256, SIZE256); + +// Creates a [hash::hash] which computes a SHA-384 hash. +export fn sha384() *hash::hash = init(variant::SHA384, SIZE384); + +// Internal initialization function +fn init(var: variant, sz: size) *hash::hash = { + let sha = alloc(digest { + hash = hash::hash { + stream = io::stream { + writer = &write, + closer = &close, + ... + }, + sum = &sum, + reset = &reset, + sz = sz, + ... + }, + var = var, + }); + + let hash = &sha.hash; + hash::reset(hash); + return hash; +}; + +fn write(st: *io::stream, buf: const []u8) (size | io::error) = { + let h = st: *digest; + let b: []u8 = buf; + let nn = len(buf); + + h.ln += nn; + + if (h.nx > 0) { + // Compute how many bytes can be copied into h.x + let r = len(h.x) - h.nx; + let n = if (nn > r) r else nn; + h.x[h.nx..] = b[..n]; + h.nx += n; + if (h.nx == chunk) { + block(h, h.x[..]); + h.nx = 0; + }; + b = b[n..]; + }; + if (len(b) >= chunk) { + let n = len(b) & ~(chunk - 1); + block(h, b[..n]); + b = b[n..]; + }; + if (len(b) > 0) { + let n = len(b); + h.x[..n] = b[..]; + h.nx = n; + }; + return nn; +}; + +fn close(st: *io::stream) void = free(st); + +fn sum(h: *hash::hash) []u8 = { + let d = h: *digest; + let copy = *d; + let d = © + + // Padding. Add a 1 bit and 0 bits until 112 bytes mod 128 + let ln = d.ln; + let tmp: [chunk]u8 = [0x80, 0...]; + if ((ln % 128) < 112) { + const n = 112 - (ln % 128); + write(&d.hash.stream, tmp[..n]); + } else { + const n = 128 + 112 - (ln % 128); + write(&d.hash.stream, tmp[..n]); + }; + + // Length in bits + ln <<= 3; + endian::beputu64(tmp, 0u64); // upper 64 bits are always zero + endian::beputu64(tmp[8..], ln : u64); + write(&d.hash.stream, tmp[..16]); + + assert(d.nx == 0); + + let dig: [SIZE]u8 = [0...]; + endian::beputu64(dig[0..], d.h[0]); + endian::beputu64(dig[8..], d.h[1]); + endian::beputu64(dig[16..], d.h[2]); + endian::beputu64(dig[24..], d.h[3]); + endian::beputu64(dig[32..], d.h[4]); + endian::beputu64(dig[40..], d.h[5]); + if (d.var != variant::SHA384) { + endian::beputu64(dig[48..], d.h[6]); + endian::beputu64(dig[56..], d.h[7]); + }; + + // We only copy the necessary bytes from fixed-size array into the + // returned slice. The size is already found in the inner hash struct. + let slice: []u8 = alloc([], d.hash.sz); + append(slice, ...dig[..d.hash.sz]); + return slice; +}; + +fn reset(h: *hash::hash) void = { + let d = h: *digest; + switch (d.var) { + variant::SHA384 => { + d.h[0] = init0_384; + d.h[1] = init1_384; + d.h[2] = init2_384; + d.h[3] = init3_384; + d.h[4] = init4_384; + d.h[5] = init5_384; + d.h[6] = init6_384; + d.h[7] = init7_384; + }, + variant::SHA512_224 => { + d.h[0] = init0_224; + d.h[1] = init1_224; + d.h[2] = init2_224; + d.h[3] = init3_224; + d.h[4] = init4_224; + d.h[5] = init5_224; + d.h[6] = init6_224; + d.h[7] = init7_224; + }, + variant::SHA512_256 => { + d.h[0] = init0_256; + d.h[1] = init1_256; + d.h[2] = init2_256; + d.h[3] = init3_256; + d.h[4] = init4_256; + d.h[5] = init5_256; + d.h[6] = init6_256; + d.h[7] = init7_256; + }, + * => { + d.h[0] = init0; + d.h[1] = init1; + d.h[2] = init2; + d.h[3] = init3; + d.h[4] = init4; + d.h[5] = init5; + d.h[6] = init6; + d.h[7] = init7; + } + }; + d.nx = 0; + d.ln = 0; +}; + +const k: [_]u64 = [ + 0x428a2f98d728ae22, 0x7137449123ef65cd, 0xb5c0fbcfec4d3b2f, 0xe9b5dba58189dbbc, + 0x3956c25bf348b538, 0x59f111f1b605d019, 0x923f82a4af194f9b, 0xab1c5ed5da6d8118, + 0xd807aa98a3030242, 0x12835b0145706fbe, 0x243185be4ee4b28c, 0x550c7dc3d5ffb4e2, + 0x72be5d74f27b896f, 0x80deb1fe3b1696b1, 0x9bdc06a725c71235, 0xc19bf174cf692694, + 0xe49b69c19ef14ad2, 0xefbe4786384f25e3, 0x0fc19dc68b8cd5b5, 0x240ca1cc77ac9c65, + 0x2de92c6f592b0275, 0x4a7484aa6ea6e483, 0x5cb0a9dcbd41fbd4, 0x76f988da831153b5, + 0x983e5152ee66dfab, 0xa831c66d2db43210, 0xb00327c898fb213f, 0xbf597fc7beef0ee4, + 0xc6e00bf33da88fc2, 0xd5a79147930aa725, 0x06ca6351e003826f, 0x142929670a0e6e70, + 0x27b70a8546d22ffc, 0x2e1b21385c26c926, 0x4d2c6dfc5ac42aed, 0x53380d139d95b3df, + 0x650a73548baf63de, 0x766a0abb3c77b2a8, 0x81c2c92e47edaee6, 0x92722c851482353b, + 0xa2bfe8a14cf10364, 0xa81a664bbc423001, 0xc24b8b70d0f89791, 0xc76c51a30654be30, + 0xd192e819d6ef5218, 0xd69906245565a910, 0xf40e35855771202a, 0x106aa07032bbd1b8, + 0x19a4c116b8d2d0c8, 0x1e376c085141ab53, 0x2748774cdf8eeb99, 0x34b0bcb5e19b48a8, + 0x391c0cb3c5c95a63, 0x4ed8aa4ae3418acb, 0x5b9cca4f7763e373, 0x682e6ff3d6b2b8a3, + 0x748f82ee5defb2fc, 0x78a5636f43172f60, 0x84c87814a1f0ab72, 0x8cc702081a6439ec, + 0x90befffa23631e28, 0xa4506cebde82bde9, 0xbef9a3f7b2c67915, 0xc67178f2e372532b, + 0xca273eceea26619c, 0xd186b8c721c0c207, 0xeada7dd6cde0eb1e, 0xf57d4f7fee6ed178, + 0x06f067aa72176fba, 0x0a637dc5a2c898a6, 0x113f9804bef90dae, 0x1b710b35131c471b, + 0x28db77f523047d84, 0x32caab7b40c72493, 0x3c9ebe0a15c9bebc, 0x431d67c49c100d4c, + 0x4cc5d4becb3e42b6, 0x597f299cfc657e2a, 0x5fcb6fab3ad6faec, 0x6c44198c4a475817, +]; + +fn block(h: *digest, p: []u8) void = { + let w: [80]u64 = [0...]; + + let h0 = h.h[0]; + let h1 = h.h[1]; + let h2 = h.h[2]; + let h3 = h.h[3]; + let h4 = h.h[4]; + let h5 = h.h[5]; + let h6 = h.h[6]; + let h7 = h.h[7]; + + for (len(p) >= chunk; p = p[chunk..]) { + for (let i = 0z; i < 16; i += 1) { + let j = i * 8; + w[i] = p[j]: u64 << 56 + | p[j+1]: u64 << 48 + | p[j+2]: u64 << 40 + | p[j+3]: u64 << 32 + | p[j+4]: u64 << 24 + | p[j+5]: u64 << 16 + | p[j+6]: u64 << 8 + | p[j+7]: u64; + }; + for (let i = 16z; i < 80; i += 1) { + let v1 = w[i - 2]; + let t1 = math::rotr64(v1, 19) ^ math::rotr64(v1, 61) ^ (v1 >> 6); + let v2 = w[i - 15]; + let t2 = math::rotr64(v2, 1) ^ math::rotr64(v2, 8) ^ (v2 >> 7); + + w[i] = t1 + w[i - 7] + t2 + w[i - 16]; + }; + + let a = h0; + let b = h1; + let c = h2; + let d = h3; + let e = h4; + let f = h5; + let g = h6; + let h = h7; + + for (let i = 0z; i < 80; i += 1) { + let t1 = h + (math::rotr64(e, 14) + ^ math::rotr64(e, 18) + ^ math::rotr64(e, 41)) + + ((e & f) ^ (~e & g)) + + k[i] + w[i]; + + let t2 = (math::rotr64(a, 28) + ^ math::rotr64(a, 34) + ^ math::rotr64(a, 39)) + + ((a & b) ^ (a & c) ^ (b & c)); + + h = g; + g = f; + f = e; + e = d + t1; + d = c; + c = b; + b = a; + a = t1 + t2; + }; + h0 += a; + h1 += b; + h2 += c; + h3 += d; + h4 += e; + h5 += f; + h6 += g; + h7 += h; + }; + h.h[0] = h0; + h.h[1] = h1; + h.h[2] = h2; + h.h[3] = h3; + h.h[4] = h4; + h.h[5] = h5; + h.h[6] = h6; + h.h[7] = h7; +}; diff --git a/example/signal.ha b/example/signal.ha new file mode 100644 index 000000000..3331b95ed --- /dev/null +++ b/example/signal.ha @@ -0,0 +1,44 @@ +// TODO: work when _NSIG != 64 + +export fn sigemptyset(set: *sigset) int = { + if (set.__val[0] == 0) { + return 1; + }; + set.__val[0] = 0; + return 0; +}; + +export fn sigaddset(set: *sigset, signum: int) (int | errno) = { + if (signum > NSIG) { + return EINVAL; + }; + signum -= 1; + set.__val[0] |= (1 << signum): u64; + return 0; +}; + +export fn sigdelset(set: *sigset, signum: int) (int | errno) = { + if (signum > NSIG) { + return EINVAL; + }; + signum -= 1; + set.__val[0] &= ~(1 << signum: u64); + return 0; +}; + +export fn sigismember(set: *sigset, signum: int) (int | errno) = { + if (signum > NSIG) { + return EINVAL; + }; + signum -= 1; + if ((set.__val[0] & (1 << signum: u64)) != 0) { + return 1; + } else { + return 0; + }; +}; + +export fn sigfillset(set: *sigset) (int | errno) = { + set.__val[0] = 0xffffffffffffffff: u64; + return 0; +}; diff --git a/example/socket.ha b/example/socket.ha new file mode 100644 index 000000000..f58dfa3b6 --- /dev/null +++ b/example/socket.ha @@ -0,0 +1,189 @@ +export type sa_family_t = u16; + +export type in_addr = struct { + s_addr: u32 +}; + +export type sockaddr_in = struct { + sin_family: sa_family_t, + sin_port: u16, + sin_addr: in_addr, + __pad: [16]char, +}; + +export type in6_addr = struct { + union { + s6_addr: [16]u8, + s6_addr16: [8]u16, + s6_addr32: [4]u32, + } +}; + +export type sockaddr_in6 = struct { + sin6_family: sa_family_t, + sin6_port: u16, + sin6_flowinfo: u32, + sin6_addr: in6_addr, + sin6_scope_id: u32, +}; + +export def UNIX_PATH_MAX: size = 108; + +export type sockaddr_un = struct { + sun_family: sa_family_t, + sun_path: [UNIX_PATH_MAX]char, +}; + +export type sockaddr = struct { + union { + in: sockaddr_in, + in6: sockaddr_in6, + un: sockaddr_un, + }, +}; + +// domain for socket(2) +export def AF_UNSPEC: u16 = 0; +export def AF_UNIX: u16 = 1; // Unix domain sockets +export def AF_LOCAL: u16 = 1; // POSIX name for AF_UNIX +export def AF_INET: u16 = 2; // Internet IP Protocol +export def AF_AX25: u16 = 3; // Amateur Radio AX.25 +export def AF_IPX: u16 = 4; // Novell IPX +export def AF_APPLETALK: u16 = 5; // AppleTalk DDP +export def AF_NETROM: u16 = 6; // Amateur Radio NET/ROM +export def AF_BRIDGE: u16 = 7; // Multiprotocol bridge +export def AF_ATMPVC: u16 = 8; // ATM PVCs +export def AF_X25: u16 = 9; // Reserved for X.25 project +export def AF_INET6: u16 = 10; // IP version 6 +export def AF_ROSE: u16 = 11; // Amateur Radio X.25 PLP +export def AF_DECnet: u16 = 12; // Reserved for DECnet project +export def AF_NETBEUI: u16 = 13; // Reserved for 802.2LLC project +export def AF_SECURITY: u16 = 14; // Security callback pseudo AF +export def AF_KEY: u16 = 15; // PF_KEY key management API +export def AF_NETLINK: u16 = 16; +export def AF_ROUTE: u16 = AF_NETLINK; // Alias to emulate 4.4BSD +export def AF_PACKET: u16 = 17; // Packet family +export def AF_ASH: u16 = 18; // Ash +export def AF_ECONET: u16 = 19; // Acorn Econet +export def AF_ATMSVC: u16 = 20; // ATM SVCs +export def AF_RDS: u16 = 21; // RDS sockets +export def AF_SNA: u16 = 22; // Linux SNA Project (nutters!) +export def AF_IRDA: u16 = 23; // IRDA sockets +export def AF_PPPOX: u16 = 24; // PPPoX sockets +export def AF_WANPIPE: u16 = 25; // Wanpipe API Sockets +export def AF_LLC: u16 = 26; // Linux LLC +export def AF_IB: u16 = 27; // Native InfiniBand address +export def AF_MPLS: u16 = 28; // MPLS +export def AF_CAN: u16 = 29; // Controller Area Network +export def AF_TIPC: u16 = 30; // TIPC sockets +export def AF_BLUETOOTH: u16 = 31; // Bluetooth sockets +export def AF_IUCV: u16 = 32; // IUCV sockets +export def AF_RXRPC: u16 = 33; // RxRPC sockets +export def AF_ISDN: u16 = 34; // mISDN sockets +export def AF_PHONET: u16 = 35; // Phonet sockets +export def AF_IEEE802154: u16 = 36; // IEEE802154 sockets +export def AF_CAIF: u16 = 37; // CAIF sockets +export def AF_ALG: u16 = 38; // Algorithm sockets +export def AF_NFC: u16 = 39; // NFC sockets +export def AF_VSOCK: u16 = 40; // vSockets +export def AF_KCM: u16 = 41; // Kernel Connection Multiplexor +export def AF_QIPCRTR: u16 = 42; // Qualcomm IPC Router +export def AF_SMC: u16 = 43; // smc sockets +export def AF_XDP: u16 = 44; // XDP sockets + +// type for socket(2) +export def SOCK_STREAM: int = 1; +export def SOCK_DGRAM: int = 2; +export def SOCK_RAW: int = 3; +export def SOCK_RDM: int = 4; +export def SOCK_SEQPACKET: int = 5; +export def SOCK_DCCP: int = 6; +export def SOCK_PACKET: int = 10; + +// protocol for socket(2) +export def IPPROTO_IP: int = 0; // Dummy protocol for TCP +export def IPPROTO_ICMP: int = 1; // Internet Control Message Protocol +export def IPPROTO_IGMP: int = 2; // Internet Group Management Protocol +export def IPPROTO_IPIP: int = 4; // IPIP tunnels (older KA9Q tunnels use 94) +export def IPPROTO_TCP: int = 6; // Transmission Control Protocol +export def IPPROTO_EGP: int = 8; // Exterior Gateway Protocol +export def IPPROTO_PUP: int = 12; // PUP protocol +export def IPPROTO_UDP: int = 17; // User Datagram Protocol +export def IPPROTO_IDP: int = 22; // XNS IDP protocol +export def IPPROTO_TP: int = 29; // SO Transport Protocol Class 4 +export def IPPROTO_DCCP: int = 33; // Datagram Congestion Control Protocol +export def IPPROTO_IPV6: int = 41; // IPv6-in-IPv4 tunnelling +export def IPPROTO_RSVP: int = 46; // RSVP Protocol +export def IPPROTO_GRE: int = 47; // Cisco GRE tunnels (rfc 1701,1702) +export def IPPROTO_ESP: int = 50; // Encapsulation Security Payload protocol +export def IPPROTO_AH: int = 51; // Authentication Header protocol +export def IPPROTO_MTP: int = 92; // Multicast Transport Protocol +export def IPPROTO_BEETPH: int = 94; // IP option pseudo header for BEET +export def IPPROTO_ENCAP: int = 98; // Encapsulation Header +export def IPPROTO_PIM: int = 103; // Protocol Independent Multicast +export def IPPROTO_COMP: int = 108; // Compression Header Protocol +export def IPPROTO_SCTP: int = 132; // Stream Control Transport Protocol +export def IPPROTO_UDPLITE: int = 136; // UDP-Lite (RFC 3828) +export def IPPROTO_MPLS: int = 137; // MPLS in IP (RFC 4023) +export def IPPROTO_ETHERNET: int = 143; // Ethernet-within-IPv6 Encapsulation +export def IPPROTO_RAW: int = 255; // Raw IP packets +export def IPPROTO_MPTCP: int = 262; // Multipath TCP connection + +// send/rcv flags +export def MSG_OOB: int = 1; +export def MSG_PEEK: int = 2; +export def MSG_DONTROUTE: int = 4; +export def MSG_TRYHARD: int = 4; // Synonym for MSG_DONTROUTE for DECnet +export def MSG_CTRUNC: int = 8; +export def MSG_PROBE: int = 0x10; // Do not send. Only probe path f.e. for MTU +export def MSG_TRUNC: int = 0x20; +export def MSG_DONTWAIT: int = 0x40; // Nonblocking io +export def MSG_EOR: int = 0x80; // End of record +export def MSG_WAITALL: int = 0x100; // Wait for a full request +export def MSG_FIN: int = 0x200; +export def MSG_SYN: int = 0x400; +export def MSG_CONFIRM: int = 0x800; // Confirm path validity +export def MSG_RST: int = 0x1000; +export def MSG_ERRQUEUE: int = 0x2000; // Fetch message from error queue +export def MSG_NOSIGNAL: int = 0x4000; // Do not generate SIGPIPE +export def MSG_MORE: int = 0x8000; // Sender will send more +export def MSG_WAITFORONE: int = 0x10000; // recvmmsg(): block until 1+ packets avail +export def MSG_SENDPAGE_NOPOLICY: int = 0x10000; // sendpage() internal : do no apply policy +export def MSG_SENDPAGE_NOTLAST: int = 0x20000; // sendpage() internal : not the last page +export def MSG_BATCH: int = 0x40000; // sendmmsg(): more messages coming +export def MSG_EOF: int = MSG_FIN; +export def MSG_NO_SHARED_FRAGS: int = 0x80000; // sendpage() internal : page frags are not shared +export def MSG_SENDPAGE_DECRYPTED: int = 0x100000; // sendpage() internal : page may carry * plain text and require encryption +export def MSG_ZEROCOPY: int = 0x4000000; // Use user data in kernel path +export def MSG_FASTOPEN: int = 0x20000000; // Send data in TCP SYN +export def MSG_CMSG_CLOEXEC: int = 0x40000000; // Set close_on_exec for file descriptor received through SCM_RIGHTS + +// setsockopt levels +export def SOL_SOCKET: int = 1; + +// setsockopt options +export def SO_DEBUG: int = 1; +export def SO_REUSEADDR: int = 2; +export def SO_TYPE: int = 3; +export def SO_ERROR: int = 4; +export def SO_DONTROUTE: int = 5; +export def SO_BROADCAST: int = 6; +export def SO_SNDBUF: int = 7; +export def SO_RCVBUF: int = 8; +export def SO_SNDBUFFORCE: int = 32; +export def SO_RCVBUFFORCE: int = 33; +export def SO_KEEPALIVE: int = 9; +export def SO_OOBINLINE: int = 10; +export def SO_NO_CHECK: int = 11; +export def SO_PRIORITY: int = 12; +export def SO_LINGER: int = 13; +export def SO_BSDCOMPAT: int = 14; +export def SO_REUSEPORT: int = 15; + +// the following differ on ppc +export def SO_PASSCRED: int = 16; +export def SO_PEERCRED: int = 17; +export def SO_RCVLOWAT: int = 18; +export def SO_SNDLOWAT: int = 19; +export def SO_RCVTIMEO_OLD: int = 20; +export def SO_SNDTIMEO_OLD: int = 21; diff --git a/example/sort.ha b/example/sort.ha new file mode 100644 index 000000000..3fd613197 --- /dev/null +++ b/example/sort.ha @@ -0,0 +1,48 @@ +// Sorts a slice of items in place. Provide a slice of 'items', the size of each +// member, and a function to compare one member to another. The 'cmp' function +// will be called with two pointers to values within the items slice, and shall +// return an integer less than, equal to, or greater than zero if the first +// argument is, respectively, less than, equal to, or greater than the second +// argument. +// +// This implementation provides a stable sort. +export fn sort( + items: []void, + itemsz: size, + cmp: *fn(a: const *void, b: const *void) int, +) void = { + if (len(items) < 256) { + insort(items, itemsz, cmp); + return; + }; + + // TODO: Timsort + insort(items, itemsz, cmp); +}; + +fn swap(a: *void, b: *void, sz: size) void = { + let a = a: *[*]u8, b = b: *[*]u8; + for (let i = 0z; i < sz; i += 1) { + let c = a[i]; + a[i] = b[i]; + b[i] = c; + }; +}; + +fn insort( + items: []void, + itemsz: size, + cmp: *fn(a: const *void, b: const *void) int, +) void = { + let ba = items: *[*]u8; + for (let i = 0z; i < len(items); i += 1) { + for (let j = i; j > 0; j -= 1) { + let a = &ba[(j - 1) * itemsz]; + let b = &ba[j * itemsz]; + if (cmp(a, b) <= 0) { + break; + }; + swap(a, b, itemsz); + }; + }; +}; diff --git a/example/start+test.ha b/example/start+test.ha new file mode 100644 index 000000000..423e247d3 --- /dev/null +++ b/example/start+test.ha @@ -0,0 +1,22 @@ +const @symbol("__init_array_start") init_start: [*]*fn() void; +const @symbol("__init_array_end") init_end: [*]*fn() void; +const @symbol("__fini_array_start") fini_start: [*]*fn() void; +const @symbol("__fini_array_end") fini_end: [*]*fn() void; + +export @noreturn fn start_ha() void = { + const ninit = (&init_end: uintptr - &init_start: uintptr): size + / size(*fn() void); + for (let i = 0z; i < ninit; i += 1) { + init_start[i](); + }; + + let nfail = tests_main(); + + const nfini = (&fini_end: uintptr - &fini_start: uintptr): size + / size(*fn() void); + for (let i = 0z; i < nfini; i += 1) { + fini_start[i](); + }; + + exit(if (nfail > 0) 1 else 0); +}; diff --git a/example/start.ha b/example/start.ha new file mode 100644 index 000000000..61319e07c --- /dev/null +++ b/example/start.ha @@ -0,0 +1,10 @@ +use rt; +use format::elf; + +@init fn init_linux() void = { + let i = 0; + for (rt::envp[i] != null) { + i += 1; + }; + auxv = &rt::envp[i + 1]: *[*]elf::auxv64; +}; diff --git a/example/stat.ha b/example/stat.ha new file mode 100644 index 000000000..6f7ae049c --- /dev/null +++ b/example/stat.ha @@ -0,0 +1,55 @@ +fn mkdev(major: u32, minor: u32) dev_t = + ((major: u64 & 0xFFFFF000) << 32) | + ((major: u64 & 0x00000FFF) << 8) | + ((minor: u64 & 0xFFFFFF00) << 12) | + (minor: u64 & 0x000000FF); + +fn fstatat_statx( + dirfd: int, + path: path, + flags: int, + mask: uint, + statbuf: *stx, +) (void | errno) = { + let path = kpath(path)?; + wrap_return(syscall5(SYS_statx, + dirfd: u64, path: uintptr: u64, flags: u64, + mask: u64, statbuf: uintptr: u64))?; + return; +}; + +export fn fstatat( + dirfd: int, + path: path, + statbuf: *st, + flags: int, +) (errno | void) = { + let path = kpath(path)?; + let statxbuf = stx { ... }; + fstatat_statx(dirfd, path, flags, STATX_BASIC_STATS, &statxbuf)?; + statbuf.dev = mkdev(statxbuf.dev_major, statxbuf.dev_minor); + statbuf.ino = statxbuf.ino; + statbuf.mode = statxbuf.mode; + statbuf.nlink = statxbuf.nlink; + statbuf.uid = statxbuf.uid; + statbuf.gid = statxbuf.gid; + statbuf.rdev = mkdev(statxbuf.dev_major, statxbuf.dev_minor); + statbuf.sz = statxbuf.sz; + statbuf.blksz = statxbuf.blksize; + statbuf.blocks = statxbuf.blocks; + statbuf.atime.tv_sec = statxbuf.atime.tv_sec; + statbuf.atime.tv_nsec = statxbuf.atime.tv_nsec: i64; + statbuf.mtime.tv_sec = statxbuf.mtime.tv_sec; + statbuf.mtime.tv_nsec = statxbuf.mtime.tv_nsec: i64; + statbuf.ctime.tv_sec = statxbuf.ctime.tv_sec; + statbuf.ctime.tv_nsec = statxbuf.ctime.tv_nsec: i64; +}; + +export fn stat(path: path, statbuf: *st) (errno | void) = + fstatat(AT_FDCWD, path, statbuf, 0); + +export fn fstat(fd: int, statbuf: *st) (errno | void) = + fstatat(fd, "", statbuf, AT_EMPTY_PATH); + +export fn lstat(path: path, statbuf: *st) (errno | void) = + fstatat(AT_FDCWD, path, statbuf, AT_SYMLINK_NOFOLLOW); diff --git a/example/stdfd.ha b/example/stdfd.ha new file mode 100644 index 000000000..9eb6fbf5a --- /dev/null +++ b/example/stdfd.ha @@ -0,0 +1,26 @@ +use bufio; +use io; + +let static_stdin_fd: fd_stream = fd_stream { ... }; +let static_stdout_fd: fd_stream = fd_stream { ... }; +let static_stderr_fd: fd_stream = fd_stream { ... }; + +let static_stdin_bufio: bufio::bufstream = bufio::bufstream { ... }; +let static_stdout_bufio: bufio::bufstream = bufio::bufstream { ... }; + +@init fn init_stdfd() void = { + stdin = static_fdopen(0, "", io::mode::READ, &static_stdin_fd); + stdout = static_fdopen(1, "", io::mode::WRITE, &static_stdout_fd); + stderr = static_fdopen(2, "", io::mode::WRITE, &static_stderr_fd); + + static let stdinbuf: [4096]u8 = [0...]; + stdin = bufio::static_buffered(stdin, stdinbuf, [], &static_stdin_bufio); + + static let stdoutbuf: [4096]u8 = [0...]; + stdout = bufio::static_buffered(stdout, [], stdoutbuf, &static_stdout_bufio); +}; + +@fini fn fini_stdfd() void = { + // Flush any pending writes + io::close(stdout); +}; diff --git a/example/stoi.ha b/example/stoi.ha new file mode 100644 index 000000000..86d296606 --- /dev/null +++ b/example/stoi.ha @@ -0,0 +1,20 @@ +@test fn stoi() void = { + assert(stoi64("") as invalid == 0: strconv::invalid); + assert(stoi64("abc") as invalid == 0: strconv::invalid); + assert(stoi64("1a") as invalid == 1: strconv::invalid); + + assert(stoi64("9223372036854775808") is overflow); + assert(stoi64("-9223372036854775809") is overflow); + + assert(stoi64("0") as i64 == 0); + assert(stoi64("1") as i64 == 1); + assert(stoi64("-1") as i64 == -1); + assert(stoi64("9223372036854775807") as i64 == 9223372036854775807); + assert(stoi64("-9223372036854775808") as i64 == -9223372036854775808); + + assert(stoi32("2147483648") is overflow); + assert(stoi32("-2147483649") is overflow); + + assert(stoi32("2147483647") as i32 == 2147483647); + assert(stoi32("-2147483648") as i32 == -2147483648); +}; diff --git a/example/stou.ha b/example/stou.ha new file mode 100644 index 000000000..0b3be895f --- /dev/null +++ b/example/stou.ha @@ -0,0 +1,20 @@ +@test fn stou() void = { + assert(stou64("") as invalid == 0: strconv::invalid); + assert(stou64("abc") as invalid == 0: strconv::invalid); + assert(stou64("1a") as invalid == 1: strconv::invalid); + assert(stou64("-1") as invalid == 0: strconv::invalid); + + assert(stou64("18446744073709551616") is overflow); + assert(stou64("184467440737095516150") is overflow); + + assert(stou64("0") as u64 == 0); + assert(stou64("1") as u64 == 1); + assert(stou64("18446744073709551615") as u64 == 18446744073709551615); +}; + +@test fn stoub() void = { + assert(stou64b("7f", 16) as u64 == 0x7f); + assert(stou64b("7F", 16u) as u64 == 0x7f); + assert(stou64b("37", 8) as u64 == 0o37); + assert(stou64b("110101", 2) as u64 == 0b110101); +}; diff --git a/example/strcmp.ha b/example/strcmp.ha new file mode 100644 index 000000000..25ff287dd --- /dev/null +++ b/example/strcmp.ha @@ -0,0 +1,36 @@ +use strings; + +// Compares two strings by their ASCII sort order. If either string is not +// entirely composed of ASCII characters, void is returned. Otherwise, zero is +// returned if the strings are equal, a negative value if a is less than b, or a +// positive value if a is greater than b. +export fn strcmp(a: str, b: str) (int | void) = { + let a = strings::iter(a), b = strings::iter(b); + for (true) { + let ra = match (strings::next(&a)) { + void => return match (strings::next(&b)) { + void => 0, + rune => -1, + }, + r: rune => r, + }; + let rb = match (strings::next(&b)) { + void => return 1, + r: rune => r, + }; + if (!isascii(ra) || !isascii(rb)) { + return; + }; + if (ra != rb) { + return ra: u32: int - rb: u32: int; + }; + }; +}; + +@test fn strcmp() void = { + assert(strcmp("ABC", "ABC") as int == 0); + assert(strcmp("ABC", "AB") as int == 1); + assert(strcmp("AB", "ABC") as int == -1); + assert(strcmp("BCD", "ABC") as int == 1); + assert(strcmp("ABC", "こんにちは") is void); +}; diff --git a/example/stream.ha b/example/stream.ha new file mode 100644 index 000000000..034390258 --- /dev/null +++ b/example/stream.ha @@ -0,0 +1,95 @@ +use errors; + +// A stream of bytes which supports some subset of read, write, close, or seek +// operations. To create a custom stream, embed this type as the first member of +// a struct with user-specific data and fill out these fields as appropriate. +// +// type my_stream = struct { +// io::stream, +// fd: int, +// }; +// +// fn open(path: str) *io::stream = { +// let fd = // ... +// let stream = alloc(*my_stream, my_stream { +// name = strings::dup(path), +// reader = &my_stream_read, +// writer = &my_stream_write, +// closer = null, +// fd: fd, +// ... +// }); +// return &stream.stream; +// }; +export type stream = struct { + name: str, + reader: nullable *reader, + writer: nullable *writer, + closer: nullable *closer, + copier: nullable *copier, + seeker: nullable *seeker, + unwrap: nullable *unwrap, +}; + +// Reads up to len(buf) bytes from the reader into the given buffer, returning +// the number of bytes read. +export fn read(s: *stream, buf: []u8) (size | EOF | error) = { + return match (s.reader) { + null => errors::unsupported, + r: *reader => r(s, buf), + }; +}; + +// Writes up to len(buf) bytes to the stream from the given buffer, returning +// the number of bytes written. +export fn write(s: *stream, buf: const []u8) (size | error) = { + return match (s.writer) { + null => errors::unsupported, + w: *writer => w(s, buf), + }; +}; + +// Closes the stream. +export fn close(s: *stream) (error | void) = { + return match (s.closer) { + null => errors::unsupported, + c: *closer => c(s), + }; +}; + +// Sets the offset within the stream. +export fn seek(s: *stream, off: off, w: whence) (off | error) = { + return match (s.seeker) { + null => errors::unsupported, + sk: *seeker => sk(s, off, w), + }; +}; + +// Returns the current offset within the stream. +export fn tell(s: *stream) (off | error) = { + return match (s.seeker) { + null => errors::unsupported, + sk: *seeker => sk(s, 0, whence::CUR), + }; +}; + +// Returns the underlying stream for a stream which wraps another stream. +export fn source(s: *stream) (*io::stream | errors::unsupported) = { + return match (s.unwrap) { + null => errors::unsupported, + uw: *unwrap => uw(s), + }; +}; + +let _empty: io::stream = io::stream { + reader = &empty_read, + writer = &empty_write, + ... +}; + +// A [stream] which always reads EOF and discards any writes. +export let empty: *io::stream = &_empty; + +fn empty_read(s: *stream, buf: []u8) (size | EOF | error) = EOF; + +fn empty_write(s: *stream, buf: const []u8) (size | error) = len(buf); diff --git a/example/string.ha b/example/string.ha new file mode 100644 index 000000000..3f4149907 --- /dev/null +++ b/example/string.ha @@ -0,0 +1,20 @@ +// Converts an [error] into a human-friendly string representation. +// +// Note that this strerror implementation lacks any context-specific information +// about the error types supported. For example, [exists] is stringified as "An +// attempt was made to create a resource which already exists", but if source of +// the error is, say, creating a file, it would likely be more appropriate to +// use the term "file" rather than "resource". For this reason, it is preferred +// that modules which return an error type from this module provide their own +// strerror function which provides more context-appropriate error messages for +// each of those types. +export fn strerror(err: error) const str = match (err) { + busy => "The requested resource is not available", + exists => "An attempt was made to create a resource which already exists", + invalid => "An function was called with an invalid combination of arguments", + noaccess => "The user does not have permission to use this resource", + noentry => "An entry was requested which does not exist", + overflow => "The requested operation caused a numeric overflow condition", + unsupported => "The requested operation is not supported", + op: opaque => op.strerror(&op.data), +}; diff --git a/example/sub.ha b/example/sub.ha new file mode 100644 index 000000000..ec5ec8614 --- /dev/null +++ b/example/sub.ha @@ -0,0 +1,55 @@ +use encoding::utf8; + +export type end = void; + +fn utf8_byte_len_bounded(iter: *iterator, end: size) size = { + let pos = 0z; + for (let i = 0z; i < end; i += 1) { + let r: rune = match (strings::next(iter)) { + void => break, + r: rune => r, + }; + + pos += utf8::runesz(r); + }; + return pos; +}; + +fn utf8_byte_len_unbounded(iter: *iterator) size = { + let pos = 0z; + for (true) { + let r: rune = match (strings::next(iter)) { + void => break, + r: rune => r, + }; + + pos += utf8::runesz(r); + }; + return pos; +}; + +// Returns a substring in the range [start, end - 1], where each argument is the +// index of the Nth rune. If the end argument is given as [strings::end], the +// end of the substring is the end of the original string. The lifetime of the +// substring is the same as that of the original string. +// +// Note that substringing runewise is not always the correct thing to do, and it +// may cause unexpected linguistic errors to arise. You may need to use +// [unicode::graphsub] instead. +export fn sub(s: str, start: size, end: (size | end)) str = { + let iter = iter(s); + let starti = utf8_byte_len_bounded(&iter, start); + let endi = match (end) { + sz: size => starti + utf8_byte_len_bounded(&iter, sz - start), + end => starti + utf8_byte_len_unbounded(&iter), + }; + let bytes = toutf8(s); + return fromutf8_unsafe(bytes[starti..endi]); +}; + +@test fn sub() void = { + assert(sub("a string", 2, end) == "string"); + assert(sub("a string", 0, 1) == "a"); + assert(sub("a string", 0, 3) == "a s"); + assert(sub("a string", 2, 8) == "string"); +}; diff --git a/example/subcmds.ha b/example/subcmds.ha new file mode 100644 index 000000000..ff0736715 --- /dev/null +++ b/example/subcmds.ha @@ -0,0 +1,334 @@ +use fmt; +use getopt; +use hare::module; +use os; +use os::exec; +use path; + +fn default_tags() []module::tag = { + return alloc([module::tag { + name = os::machine(), + mode = module::tag_mode::INCLUSIVE, + }, module::tag { + name = PLATFORM, + mode = module::tag_mode::INCLUSIVE, + }]); +}; + +type goal = enum { + OBJ, + EXE, +}; + +fn build(args: []str) void = { + let help: []getopt::help = [ + "compiles Hare programs", + ('c', "build object instead of executable"), + ('v', "print executed commands"), + ('D', "ident:type=value", "define a constant"), + ('j', "jobs", "set parallelism for build"), + ('l', "name", "link with a system library"), + ('o', "path", "set output file name"), + ('t', "arch", "set target architecture"), + ('T', "tags...", "set build tags"), + ('X', "tags...", "unset build tags"), + "path" + ]; + let cmd = getopt::parse(args, help...); + defer getopt::finish(&cmd); + + let verbose = false; + let output = ""; + let goal = goal::EXE; + let defines: []str = []; + for (let i = 0z; i < len(cmd.opts); i += 1) { + let opt = cmd.opts[i]; + switch (opt.0) { + 'c' => goal = goal::OBJ, + 'v' => verbose = true, + 'D' => append(defines, opt.1), + 'j' => abort(), // TODO + 'l' => abort(), // TODO + 'o' => output = opt.1, + 't' => abort(), // TODO + 'T' => abort(), // TODO + 'X' => abort(), // TODO + * => abort(), + }; + }; + + assert(goal == goal::EXE); // TODO + + let input = + if (len(cmd.args) == 0) os::getcwd() + else if (len(cmd.args) == 1) cmd.args[0] + else { + getopt::printusage(os::stderr, args[0], help...); + os::exit(1); + }; + + let tags = default_tags(); + defer free(tags); + + let ctx = module::context_init(tags, defines, HAREPATH); + defer module::context_finish(&ctx); + + let plan = mkplan(&ctx); + defer plan_finish(&plan); + + let ver = match (module::scan(&ctx, input)) { + ver: module::version => ver, + err: module::error => fmt::fatal( + "Error scanning input module: {}", + module::strerror(err)), + }; + + let depends: []*task = []; + sched_module(&plan, ["rt"], &depends); + + for (let i = 0z; i < len(ver.depends); i += 1z) { + const dep = ver.depends[i]; + sched_module(&plan, dep, &depends); + }; + + // TODO: Choose this more intelligently + if (output == "") { + output = path::basename(ver.basedir); + }; + sched_hare_exe(&plan, ver, output, depends...); + plan_execute(&plan, verbose); +}; + +fn cache(args: []str) void = { + let help: []getopt::help = [ + "manages the build cache", + ('c', "cleans the specified modules"), + "modules...", + ]; + let cmd = getopt::parse(args, help...); + defer getopt::finish(&cmd); + + abort(); // TODO +}; + +fn deps(args: []str) void = { + let help: []getopt::help = [ + "prints dependency information for Hare programs", + ('d', "print dot syntax for use with graphviz"), + ('M', "print rules for POSIX make"), + ('T', "tags...", "set build tags"), + ('X', "tags...", "unset build tags"), + "path", + ]; + let cmd = getopt::parse(args, help...); + defer getopt::finish(&cmd); + + abort(); // TODO +}; + +fn run(args: []str) void = { + let help: []getopt::help = [ + "compiles and runs Hare programs", + ('v', "print executed commands"), + ('D', "ident:type=value", "define a constant"), + ('j', "jobs", "set parallelism for build"), + ('l', "name", "link with a system library"), + ('T', "tags...", "set build tags"), + ('X', "tags...", "unset build tags"), + "path", "args...", + ]; + let cmd = getopt::parse(args, help...); + defer getopt::finish(&cmd); + + let verbose = false; + let defines: []str = []; + for (let i = 0z; i < len(cmd.opts); i += 1) { + let opt = cmd.opts[i]; + switch (opt.0) { + 'v' => verbose = true, + 'D' => append(defines, opt.1), + 'j' => abort(), // TODO + 'l' => abort(), // TODO + 't' => abort(), // TODO + 'T' => abort(), // TODO + 'X' => abort(), // TODO + * => abort(), + }; + }; + + let input = ""; + let runargs: []str = []; + if (len(cmd.args) == 0) { + input = os::getcwd(); + } else { + input = cmd.args[0]; + runargs = cmd.args[1..]; + }; + + let tags = default_tags(); + defer free(tags); + + let ctx = module::context_init(tags, defines, HAREPATH); + defer module::context_finish(&ctx); + + let plan = mkplan(&ctx); + defer plan_finish(&plan); + + let ver = match (module::scan(&ctx, input)) { + ver: module::version => ver, + err: module::error => fmt::fatal( + "Error scanning input module: {}", + module::strerror(err)), + }; + + let depends: []*task = []; + sched_module(&plan, ["rt"], &depends); + + for (let i = 0z; i < len(ver.depends); i += 1z) { + const dep = ver.depends[i]; + sched_module(&plan, dep, &depends); + }; + + let output = mkfile(&plan, "out"); + sched_hare_exe(&plan, ver, output, depends...); + plan_execute(&plan, verbose); + let cmd = match (exec::cmd(output, runargs...)) { + err: exec::error => fmt::fatal("exec: {}", exec::strerror(err)), + cmd: exec::command => cmd, + }; + exec::setname(&cmd, input); + exec::exec(&cmd); +}; + +fn test(args: []str) void = { + let help: []getopt::help = [ + "compiles and runs tests for Hare programs", + ('v', "print executed commands"), + ('D', "ident:type=value", "define a constant"), + ('j', "jobs", "set parallelism for build"), + ('l', "name", "link with a system library"), + ('T', "tags...", "set build tags"), + ('X', "tags...", "unset build tags"), + "[tests...]" + ]; + let cmd = getopt::parse(args, help...); + defer getopt::finish(&cmd); + + let verbose = false; + let defines: []str = []; + for (let i = 0z; i < len(cmd.opts); i += 1) { + let opt = cmd.opts[i]; + switch (opt.0) { + 'v' => verbose = true, + 'D' => append(defines, opt.1), + 'j' => abort(), // TODO + 'l' => abort(), // TODO + 't' => abort(), // TODO + 'T' => abort(), // TODO + 'X' => abort(), // TODO + * => abort(), + }; + }; + + let input = ""; + let runargs: []str = []; + if (len(cmd.args) == 0) { + input = os::getcwd(); + } else { + input = cmd.args[0]; + runargs = cmd.args[1..]; + }; + + let tags = default_tags(); + defer free(tags); + append(tags, module::tag { + name = "test", + mode = module::tag_mode::INCLUSIVE, + }); + + let ctx = module::context_init(tags, defines, HAREPATH); + defer module::context_finish(&ctx); + + let plan = mkplan(&ctx); + defer plan_finish(&plan); + + let ver = match (module::scan(&ctx, input)) { + ver: module::version => ver, + err: module::error => fmt::fatal( + "Error scanning input module: {}", + module::strerror(err)), + }; + + let depends: []*task = []; + sched_module(&plan, ["rt"], &depends); + + for (let i = 0z; i < len(ver.depends); i += 1z) { + const dep = ver.depends[i]; + sched_module(&plan, dep, &depends); + }; + + let output = mkfile(&plan, "out"); + sched_hare_exe(&plan, ver, output, depends...); + plan_execute(&plan, verbose); + let cmd = match (exec::cmd(output, runargs...)) { + err: exec::error => fmt::fatal("exec: {}", exec::strerror(err)), + cmd: exec::command => cmd, + }; + exec::setname(&cmd, input); + exec::exec(&cmd); +}; + +fn version(args: []str) void = { + fmt::printfln("Hare version {}", VERSION); + fmt::errorln(); + fmt::printf("Build tags\t"); + const tags = default_tags(); + for (let i = 0z; i < len(tags); i += 1) { + const tag = tags[i]; + const inclusive = (tag.mode & module::tag_mode::INCLUSIVE) == module::tag_mode::INCLUSIVE; + fmt::printf("{}{}", if (inclusive) '+' else '-', tag.name); + }; + fmt::println(); + + match (os::getenv("HAREPATH")) { + void => fmt::printfln("HAREPATH\t{}", HAREPATH), + s: str => fmt::printfln("HAREPATH\t{}\t(from environment)", s), + }; + if (len(args) > 1 && args[1] == "-v") { + fmt::errorln(" +⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣀⣀⡀⠀⠀⠀⠀⠀⢀⣀⣀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⡴⠊⠀⠀⠁⠀⢱⢄⠀⠀⠀⣷⠓⠀⠌⠓⢄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠠⠊⠀⠀⠀⠀⠀⠀⠀⠀⠡⡀⢰⠛⠀⠀⠀⠀⠀⢡⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⡰⠁⠀⠀⢠⢠⠀⡄⢴⢠⣦⠀⢁⢸⢸⠀⠀⠀⠀⠀⠀⢁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢰⠀⠀⡀⢰⠈⠌⠀⠇⣹⡞⡟⠀⢸⢸⡏⠂⠀⠀⡄⠀⠀⠈⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⡄⠀⡒⠀⢴⠏⠄⠘⠁⣾⣿⡆⠀⣸⣷⢠⠀⠀⡀⠀⠀⠀⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢸⠀⠀⢡⠀⡀⢢⠁⢟⢡⣸⢹⡇⠀⢿⡆⡄⡀⠀⠁⠀⠀⠀⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠈⡐⠀⢌⡖⡐⠐⠀⢾⠂⣿⣿⡧⠀⢠⠗⡁⠁⠰⠀⠀⠀⠀⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢣⠀⢘⢻⢠⣧⡆⡘⡐⣿⣽⣷⠀⢸⢸⠃⡀⠀⠀⠀⠀⠀⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠘⡄⠀⠈⣏⢿⣿⡔⣼⣿⣿⣿⠀⠸⡿⡿⢷⢀⡄⠀⠀⠀⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠀⠠⢤⡶⠒⠞⠓⢱⠀⠀⠸⣿⣻⣿⠿⣯⠆⠀⠀⡠⠿⠷⠜⠎⠰⠰⡄⣀⣇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⣀⣠⠈⡠⠅⡢⠄⠌⠀⠦⠀⢀⢇⠀⠀⡙⡯⠋⠀⢀⠨⠒⠑⠃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠣⡂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⣐⣄⢽⠿⡰⡍⠐⠈⠀⠀⠀⠀⠀⠈⠃⠈⢆⠀⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⢢⡀⠀⠟⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +⠀⠀⠀⠀⠀⠀⠀⠀⠀⢀⠐⠶⠿⠫⠠⠀⡐⠀⠀⠀⠀⠀⠉⠀⠀⠀⠒⠊⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠐⣄⠀⠈⠱⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +⠀⠀⠀⠀⠀⠀⠀⠀⠐⠂⠒⠑⠂⠄⣀⡀⠀⠀⠀⠀⠀⠀⠀⠀⢀⢤⡏⠀⠀⠀ ⢠⣾⣿⣿⣿⠶⣄⠀⠀⠀⠀⠀⠀⠊⠀⢸⣾⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +⠀⠀⠀⠀⠀⠀⠀⣰⠂⠀⢔⣊⠉⠀⠒⠂⠀⠀⠀⠀⢤⡀⡀⠀⠐⠔⢒⠀⠂⠀⠀ ⢸⣿⣿⣿⣧⠀⣼⡀⠀⠀⠀⠀⠀⠀⠣⡀⠻⣷⡀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +⠀⠀⠀⠀⠀⠀⢐⡂⠴⠀⡚⠛⠀⠀⠈⠀⠀⠀⠀⠀⠐⠢⠠⠀⠀⠀⢱⡦⠀⠂⠀⠀⠀⠀⢻⣿⣿⣿⣷⣿⡧⠀⠀⠀⠀⠀⠀⠠⠉⠐⠘⡇⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +⠀⠀⠀⠀⠀⠀⠄⠨⠍⠙⠷⠟⠀⠐⠀⠀⠀⠤⡀⠀⠀⠠⣌⡁⠀⠀⢠⡶⠀⢀⡂⠀⠀⠀⠈⠛⠻⠿⠟⠋⠁⠀⠀⠀⠀⠀⠀⠀⠀⢂⠀⠫⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +⠀⠀⠀⠀⠀⢐⣭⡁⠥⣀⠻⣿⡄⣅⣤⠀⠈⠌⡂⠀⠀⠀⢀⡒⠠⠀⠂⣰⣡⡀⠀⠀⠀⠀⠀⠀⡠⠀⢄⢀⠄⠀⠀⠀⠀⠀⠀⠀⠀⠈⠀⢢⠄⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +⠀⠀⠀⠀⠀⢱⣏⣹⣯⢗⡩⣥⠄⠘⢓⠩⡀⠁⠀⠀⡀⠀⠂⡐⠠⠀⠀⢘⡻⣼⠄⡀⠂⠀⠀⠀⠀⠀⠀⠁⠀⠀⠀⠀⠀⠀⣤⣄⠀⢀⡤⠙⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +⠀⠀⠀⠀⢰⣺⣿⣾⣮⡷⣖⣿⠂⡂⢚⣽⠆⠨⠀⠫⠀⠀⠘⠈⢢⠘⠀⠰⡲⡫⢾⣴⣀⠀⠀⠀⠀⠀⠀⡀⣀⢀⢀⠀⠀⠀⠈⢻⣷⠟⠡⡘⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +⠀⠀⠀⠀⡽⣾⣷⣶⣯⣾⢞⣿⡾⠊⣈⢄⡂⠀⠢⢀⠄⡄⠀⠀⠈⠰⡁⡀⡘⠱⣱⡟⣝⢷⣧⣆⡔⡄⡀⡈⠀⠀⠀⠈⠀⠀⡀⠸⣇⣴⠴⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +⠀⠀⠀⠀⠈⡿⢿⣿⣿⣿⣕⣺⣗⣴⡿⣿⣈⣴⢆⠁⠊⠔⡖⠀⠁⡂⠈⠬⣾⣶⢹⣾⣮⣿⣿⣿⢿⣷⣷⣷⣦⣧⣶⣴⣧⣼⣷⣿⣿⢿⡗⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +⢀⠀⠀⠤⠄⢪⢿⣿⣿⣿⣯⣗⡽⢻⣍⡿⣯⠱⣣⡢⢂⢈⠚⠠⠐⢐⠡⢀⢌⠋⢀⣿⡏⠹⣿⣿⣷⣿⣿⣿⠿⣿⣿⣿⣿⣿⣿⣿⣾⠿⠅⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +⠐⠂⣀⣀⣀⠜⣯⣿⢿⣵⣿⣿⣭⡾⣙⠼⣼⡆⡄⣤⡏⠈⠈⠠⠞⠔⡈⠨⡀⠠⡼⣎⡀⣳⢘⣿⣽⣿⣿⣿⣿⣟⣿⣯⣻⣿⣼⣮⣿⡍⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +⠀⠤⠀⠉⠙⠃⠸⣵⣿⣿⣿⣿⣭⣴⣷⣞⢍⠰⣅⡛⡿⣷⣈⡟⢓⣔⠁⡇⣣⣟⠆⣿⡼⣤⣤⣻⣨⣿⣿⣿⣿⣿⣿⣿⣿⣿⣻⣾⠯⠈⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +⠀⠀⠀⠀⠀⠐⠶⢘⢿⣿⣿⣿⣿⣿⣎⣯⡞⣾⣧⣟⣧⣿⡽⡹⢻⢠⢠⣤⣿⠻⠿⢻⠿⣾⣿⣿⣿⣷⣿⣟⣿⣿⣿⣿⣿⣿⡿⢏⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +⠀⠀⢀⣡⡭⣭⣉⣉⣈⠹⢿⣿⣿⣿⣾⣼⣿⣾⣷⣿⡿⢿⣿⣿⢿⣿⣾⣿⣿⣿⢷⣿⣄⣿⣬⣭⡜⡿⡟⢻⣿⣟⣿⣿⠿⡟⠜⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +⠀⠀⠀⠀⠤⠌⠭⠭⢭⢭⣥⣘⣻⠻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⣿⣿⣿⣷⣷⣹⣧⣧⣽⣿⣿⣿⡿⢟⣃⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +⠀⠀⠀⠀⠀⠀⠐⠒⢒⣒⣀⣈⣉⣉⣋⣙⡻⠻⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⣿⡿⡿⣿⢿⢿⣿⠿⠻⠛⠯⠹⠁⢑⠐⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⣀⣈⣀⣒⣓⡒⡒⠒⠒⢒⡀⠀⠀⠀⠀⠴⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠉⠁⠀⣀⠀⠀⠤⠀⠤⠤⠀⠀⠒⠒⠂⠀⠀⠀⠀⠀⠀⠀⠀⠀⠁⠉⠉⠉⠁⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠠⠄⠀⠀⠀⠐⠒⠒⠒⠀⠀⠀⠀⠀⠀⠈⠉⠉⠉⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀ +⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠀⠉⠁"); + }; +}; diff --git a/example/suffix.ha b/example/suffix.ha new file mode 100644 index 000000000..d8644548e --- /dev/null +++ b/example/suffix.ha @@ -0,0 +1,48 @@ +// Returns true if 'in' has the given prefix. +export fn has_prefix(in: str, prefix: str) bool = { + let a = toutf8(in), b = toutf8(prefix); + if (len(a) < len(b)) { + return false; + }; + for (let i = 0z; i < len(b); i += 1) { + if (a[i] != b[i]) { + return false; + }; + }; + return true; +}; + +@test fn prefix() void = { + assert(has_prefix("abcde", "abc")); + assert(has_prefix("abcde", "abcde")); + assert(has_prefix("abcde", "")); + assert(has_prefix("", "")); + assert(!has_prefix("abcde", "cde")); + assert(!has_prefix("abcde", "abcdefg")); + assert(!has_prefix("", "abc")); +}; + +// Returns true if 'in' has the given prefix. +export fn has_suffix(in: str, suff: str) bool = { + let a = toutf8(in), b = toutf8(suff); + if (len(a) < len(b)) { + return false; + }; + for (let i = 0z; i < len(b); i += 1) { + if (a[len(a) - len(b) + i] != b[i]) { + return false; + }; + }; + return true; +}; + +@test fn suffix() void = { + assert(has_suffix("abcde", "cde")); + assert(has_suffix("abcde", "abcde")); + assert(has_suffix("abcde", "")); + assert(has_suffix("", "")); + assert(has_suffix("abcde", "")); + assert(!has_suffix("abcde", "abc")); + assert(!has_suffix("abcde", "fabcde")); + assert(!has_suffix("", "abc")); +}; diff --git a/example/syscallno+aarch64.ha b/example/syscallno+aarch64.ha new file mode 100644 index 000000000..23fab56ea --- /dev/null +++ b/example/syscallno+aarch64.ha @@ -0,0 +1,293 @@ +export def SYS_io_setup: u64 = 0; +export def SYS_io_destroy: u64 = 1; +export def SYS_io_submit: u64 = 2; +export def SYS_io_cancel: u64 = 3; +export def SYS_io_getevents: u64 = 4; +export def SYS_setxattr: u64 = 5; +export def SYS_lsetxattr: u64 = 6; +export def SYS_fsetxattr: u64 = 7; +export def SYS_getxattr: u64 = 8; +export def SYS_lgetxattr: u64 = 9; +export def SYS_fgetxattr: u64 = 10; +export def SYS_listxattr: u64 = 11; +export def SYS_llistxattr: u64 = 12; +export def SYS_flistxattr: u64 = 13; +export def SYS_removexattr: u64 = 14; +export def SYS_lremovexattr: u64 = 15; +export def SYS_fremovexattr: u64 = 16; +export def SYS_getcwd: u64 = 17; +export def SYS_lookup_dcookie: u64 = 18; +export def SYS_eventfd2: u64 = 19; +export def SYS_epoll_create1: u64 = 20; +export def SYS_epoll_ctl: u64 = 21; +export def SYS_epoll_pwait: u64 = 22; +export def SYS_dup: u64 = 23; +export def SYS_dup3: u64 = 24; +export def SYS_fcntl: u64 = 25; +export def SYS_inotify_init1: u64 = 26; +export def SYS_inotify_add_watch: u64 = 27; +export def SYS_inotify_rm_watch: u64 = 28; +export def SYS_ioctl: u64 = 29; +export def SYS_ioprio_set: u64 = 30; +export def SYS_ioprio_get: u64 = 31; +export def SYS_flock: u64 = 32; +export def SYS_mknodat: u64 = 33; +export def SYS_mkdirat: u64 = 34; +export def SYS_unlinkat: u64 = 35; +export def SYS_symlinkat: u64 = 36; +export def SYS_linkat: u64 = 37; +export def SYS_renameat: u64 = 38; +export def SYS_umount2: u64 = 39; +export def SYS_mount: u64 = 40; +export def SYS_pivot_root: u64 = 41; +export def SYS_nfsservctl: u64 = 42; +export def SYS_statfs: u64 = 43; +export def SYS_fstatfs: u64 = 44; +export def SYS_truncate: u64 = 45; +export def SYS_ftruncate: u64 = 46; +export def SYS_fallocate: u64 = 47; +export def SYS_faccessat: u64 = 48; +export def SYS_chdir: u64 = 49; +export def SYS_fchdir: u64 = 50; +export def SYS_chroot: u64 = 51; +export def SYS_fchmod: u64 = 52; +export def SYS_fchmodat: u64 = 53; +export def SYS_fchownat: u64 = 54; +export def SYS_fchown: u64 = 55; +export def SYS_openat: u64 = 56; +export def SYS_close: u64 = 57; +export def SYS_vhangup: u64 = 58; +export def SYS_pipe2: u64 = 59; +export def SYS_quotactl: u64 = 60; +export def SYS_getdents64: u64 = 61; +export def SYS_lseek: u64 = 62; +export def SYS_read: u64 = 63; +export def SYS_write: u64 = 64; +export def SYS_readv: u64 = 65; +export def SYS_writev: u64 = 66; +export def SYS_pread64: u64 = 67; +export def SYS_pwrite64: u64 = 68; +export def SYS_preadv: u64 = 69; +export def SYS_pwritev: u64 = 70; +export def SYS_sendfile: u64 = 71; +export def SYS_pselect6: u64 = 72; +export def SYS_ppoll: u64 = 73; +export def SYS_signalfd4: u64 = 74; +export def SYS_vmsplice: u64 = 75; +export def SYS_splice: u64 = 76; +export def SYS_tee: u64 = 77; +export def SYS_readlinkat: u64 = 78; +export def SYS_newfstatat: u64 = 79; +export def SYS_fstat: u64 = 80; +export def SYS_sync: u64 = 81; +export def SYS_fsync: u64 = 82; +export def SYS_fdatasync: u64 = 83; +export def SYS_sync_file_range: u64 = 84; +export def SYS_timerfd_create: u64 = 85; +export def SYS_timerfd_settime: u64 = 86; +export def SYS_timerfd_gettime: u64 = 87; +export def SYS_utimensat: u64 = 88; +export def SYS_acct: u64 = 89; +export def SYS_capget: u64 = 90; +export def SYS_capset: u64 = 91; +export def SYS_personality: u64 = 92; +export def SYS_exit: u64 = 93; +export def SYS_exit_group: u64 = 94; +export def SYS_waitid: u64 = 95; +export def SYS_set_tid_address: u64 = 96; +export def SYS_unshare: u64 = 97; +export def SYS_futex: u64 = 98; +export def SYS_set_robust_list: u64 = 99; +export def SYS_get_robust_list: u64 = 100; +export def SYS_nanosleep: u64 = 101; +export def SYS_getitimer: u64 = 102; +export def SYS_setitimer: u64 = 103; +export def SYS_kexec_load: u64 = 104; +export def SYS_init_module: u64 = 105; +export def SYS_delete_module: u64 = 106; +export def SYS_timer_create: u64 = 107; +export def SYS_timer_gettime: u64 = 108; +export def SYS_timer_getoverrun: u64 = 109; +export def SYS_timer_settime: u64 = 110; +export def SYS_timer_delete: u64 = 111; +export def SYS_clock_settime: u64 = 112; +export def SYS_clock_gettime: u64 = 113; +export def SYS_clock_getres: u64 = 114; +export def SYS_clock_nanosleep: u64 = 115; +export def SYS_syslog: u64 = 116; +export def SYS_ptrace: u64 = 117; +export def SYS_sched_setparam: u64 = 118; +export def SYS_sched_setscheduler: u64 = 119; +export def SYS_sched_getscheduler: u64 = 120; +export def SYS_sched_getparam: u64 = 121; +export def SYS_sched_setaffinity: u64 = 122; +export def SYS_sched_getaffinity: u64 = 123; +export def SYS_sched_yield: u64 = 124; +export def SYS_sched_get_priority_max: u64 = 125; +export def SYS_sched_get_priority_min: u64 = 126; +export def SYS_sched_rr_get_interval: u64 = 127; +export def SYS_restart_syscall: u64 = 128; +export def SYS_kill: u64 = 129; +export def SYS_tkill: u64 = 130; +export def SYS_tgkill: u64 = 131; +export def SYS_sigaltstack: u64 = 132; +export def SYS_rt_sigsuspend: u64 = 133; +export def SYS_rt_sigaction: u64 = 134; +export def SYS_rt_sigprocmask: u64 = 135; +export def SYS_rt_sigpending: u64 = 136; +export def SYS_rt_sigtimedwait: u64 = 137; +export def SYS_rt_sigqueueinfo: u64 = 138; +export def SYS_rt_sigreturn: u64 = 139; +export def SYS_setpriority: u64 = 140; +export def SYS_getpriority: u64 = 141; +export def SYS_reboot: u64 = 142; +export def SYS_setregid: u64 = 143; +export def SYS_setgid: u64 = 144; +export def SYS_setreuid: u64 = 145; +export def SYS_setuid: u64 = 146; +export def SYS_setresuid: u64 = 147; +export def SYS_getresuid: u64 = 148; +export def SYS_setresgid: u64 = 149; +export def SYS_getresgid: u64 = 150; +export def SYS_setfsuid: u64 = 151; +export def SYS_setfsgid: u64 = 152; +export def SYS_times: u64 = 153; +export def SYS_setpgid: u64 = 154; +export def SYS_getpgid: u64 = 155; +export def SYS_getsid: u64 = 156; +export def SYS_setsid: u64 = 157; +export def SYS_getgroups: u64 = 158; +export def SYS_setgroups: u64 = 159; +export def SYS_uname: u64 = 160; +export def SYS_sethostname: u64 = 161; +export def SYS_setdomainname: u64 = 162; +export def SYS_getrlimit: u64 = 163; +export def SYS_setrlimit: u64 = 164; +export def SYS_getrusage: u64 = 165; +export def SYS_umask: u64 = 166; +export def SYS_prctl: u64 = 167; +export def SYS_getcpu: u64 = 168; +export def SYS_gettimeofday: u64 = 169; +export def SYS_settimeofday: u64 = 170; +export def SYS_adjtimex: u64 = 171; +export def SYS_getpid: u64 = 172; +export def SYS_getppid: u64 = 173; +export def SYS_getuid: u64 = 174; +export def SYS_geteuid: u64 = 175; +export def SYS_getgid: u64 = 176; +export def SYS_getegid: u64 = 177; +export def SYS_gettid: u64 = 178; +export def SYS_sysinfo: u64 = 179; +export def SYS_mq_open: u64 = 180; +export def SYS_mq_unlink: u64 = 181; +export def SYS_mq_timedsend: u64 = 182; +export def SYS_mq_timedreceive: u64 = 183; +export def SYS_mq_notify: u64 = 184; +export def SYS_mq_getsetattr: u64 = 185; +export def SYS_msgget: u64 = 186; +export def SYS_msgctl: u64 = 187; +export def SYS_msgrcv: u64 = 188; +export def SYS_msgsnd: u64 = 189; +export def SYS_semget: u64 = 190; +export def SYS_semctl: u64 = 191; +export def SYS_semtimedop: u64 = 192; +export def SYS_semop: u64 = 193; +export def SYS_shmget: u64 = 194; +export def SYS_shmctl: u64 = 195; +export def SYS_shmat: u64 = 196; +export def SYS_shmdt: u64 = 197; +export def SYS_socket: u64 = 198; +export def SYS_socketpair: u64 = 199; +export def SYS_bind: u64 = 200; +export def SYS_listen: u64 = 201; +export def SYS_accept: u64 = 202; +export def SYS_connect: u64 = 203; +export def SYS_getsockname: u64 = 204; +export def SYS_getpeername: u64 = 205; +export def SYS_sendto: u64 = 206; +export def SYS_recvfrom: u64 = 207; +export def SYS_setsockopt: u64 = 208; +export def SYS_getsockopt: u64 = 209; +export def SYS_shutdown: u64 = 210; +export def SYS_sendmsg: u64 = 211; +export def SYS_recvmsg: u64 = 212; +export def SYS_readahead: u64 = 213; +export def SYS_brk: u64 = 214; +export def SYS_munmap: u64 = 215; +export def SYS_mremap: u64 = 216; +export def SYS_add_key: u64 = 217; +export def SYS_request_key: u64 = 218; +export def SYS_keyctl: u64 = 219; +export def SYS_clone: u64 = 220; +export def SYS_execve: u64 = 221; +export def SYS_mmap: u64 = 222; +export def SYS_fadvise64: u64 = 223; +export def SYS_swapon: u64 = 224; +export def SYS_swapoff: u64 = 225; +export def SYS_mprotect: u64 = 226; +export def SYS_msync: u64 = 227; +export def SYS_mlock: u64 = 228; +export def SYS_munlock: u64 = 229; +export def SYS_mlockall: u64 = 230; +export def SYS_munlockall: u64 = 231; +export def SYS_mincore: u64 = 232; +export def SYS_madvise: u64 = 233; +export def SYS_remap_file_pages: u64 = 234; +export def SYS_mbind: u64 = 235; +export def SYS_get_mempolicy: u64 = 236; +export def SYS_set_mempolicy: u64 = 237; +export def SYS_migrate_pages: u64 = 238; +export def SYS_move_pages: u64 = 239; +export def SYS_rt_tgsigqueueinfo: u64 = 240; +export def SYS_perf_event_open: u64 = 241; +export def SYS_accept4: u64 = 242; +export def SYS_recvmmsg: u64 = 243; +export def SYS_wait4: u64 = 260; +export def SYS_prlimit64: u64 = 261; +export def SYS_fanotify_init: u64 = 262; +export def SYS_fanotify_mark: u64 = 263; +export def SYS_name_to_handle_at: u64 = 264; +export def SYS_open_by_handle_at: u64 = 265; +export def SYS_clock_adjtime: u64 = 266; +export def SYS_syncfs: u64 = 267; +export def SYS_setns: u64 = 268; +export def SYS_sendmmsg: u64 = 269; +export def SYS_process_vm_readv: u64 = 270; +export def SYS_process_vm_writev: u64 = 271; +export def SYS_kcmp: u64 = 272; +export def SYS_finit_module: u64 = 273; +export def SYS_sched_setattr: u64 = 274; +export def SYS_sched_getattr: u64 = 275; +export def SYS_renameat2: u64 = 276; +export def SYS_seccomp: u64 = 277; +export def SYS_getrandom: u64 = 278; +export def SYS_memfd_create: u64 = 279; +export def SYS_bpf: u64 = 280; +export def SYS_execveat: u64 = 281; +export def SYS_userfaultfd: u64 = 282; +export def SYS_membarrier: u64 = 283; +export def SYS_mlock2: u64 = 284; +export def SYS_copy_file_range: u64 = 285; +export def SYS_preadv2: u64 = 286; +export def SYS_pwritev2: u64 = 287; +export def SYS_pkey_mprotect: u64 = 288; +export def SYS_pkey_alloc: u64 = 289; +export def SYS_pkey_free: u64 = 290; +export def SYS_statx: u64 = 291; +export def SYS_io_pgetevents: u64 = 292; +export def SYS_rseq: u64 = 293; +export def SYS_kexec_file_load: u64 = 294; +export def SYS_pidfd_send_signal: u64 = 424; +export def SYS_io_uring_setup: u64 = 425; +export def SYS_io_uring_enter: u64 = 426; +export def SYS_io_uring_register: u64 = 427; +export def SYS_open_tree: u64 = 428; +export def SYS_move_mount: u64 = 429; +export def SYS_fsopen: u64 = 430; +export def SYS_fsconfig: u64 = 431; +export def SYS_fsmount: u64 = 432; +export def SYS_fspick: u64 = 433; +export def SYS_pidfd_open: u64 = 434; +export def SYS_clone3: u64 = 435; +export def SYS_openat2: u64 = 437; +export def SYS_faccessat2: u64 = 439; diff --git a/example/syscallno+x86_64.ha b/example/syscallno+x86_64.ha new file mode 100644 index 000000000..e4bea24e9 --- /dev/null +++ b/example/syscallno+x86_64.ha @@ -0,0 +1,347 @@ +export def SYS_read: u64 = 0; +export def SYS_write: u64 = 1; +export def SYS_open: u64 = 2; +export def SYS_close: u64 = 3; +export def SYS_stat: u64 = 4; +export def SYS_fstat: u64 = 5; +export def SYS_lstat: u64 = 6; +export def SYS_poll: u64 = 7; +export def SYS_lseek: u64 = 8; +export def SYS_mmap: u64 = 9; +export def SYS_mprotect: u64 = 10; +export def SYS_munmap: u64 = 11; +export def SYS_brk: u64 = 12; +export def SYS_rt_sigaction: u64 = 13; +export def SYS_rt_sigprocmask: u64 = 14; +export def SYS_rt_sigreturn: u64 = 15; +export def SYS_ioctl: u64 = 16; +export def SYS_pread64: u64 = 17; +export def SYS_pwrite64: u64 = 18; +export def SYS_readv: u64 = 19; +export def SYS_writev: u64 = 20; +export def SYS_access: u64 = 21; +export def SYS_pipe: u64 = 22; +export def SYS_select: u64 = 23; +export def SYS_sched_yield: u64 = 24; +export def SYS_mremap: u64 = 25; +export def SYS_msync: u64 = 26; +export def SYS_mincore: u64 = 27; +export def SYS_madvise: u64 = 28; +export def SYS_shmget: u64 = 29; +export def SYS_shmat: u64 = 30; +export def SYS_shmctl: u64 = 31; +export def SYS_dup: u64 = 32; +export def SYS_dup2: u64 = 33; +export def SYS_pause: u64 = 34; +export def SYS_nanosleep: u64 = 35; +export def SYS_getitimer: u64 = 36; +export def SYS_alarm: u64 = 37; +export def SYS_setitimer: u64 = 38; +export def SYS_getpid: u64 = 39; +export def SYS_sendfile: u64 = 40; +export def SYS_socket: u64 = 41; +export def SYS_connect: u64 = 42; +export def SYS_accept: u64 = 43; +export def SYS_sendto: u64 = 44; +export def SYS_recvfrom: u64 = 45; +export def SYS_sendmsg: u64 = 46; +export def SYS_recvmsg: u64 = 47; +export def SYS_shutdown: u64 = 48; +export def SYS_bind: u64 = 49; +export def SYS_listen: u64 = 50; +export def SYS_getsockname: u64 = 51; +export def SYS_getpeername: u64 = 52; +export def SYS_socketpair: u64 = 53; +export def SYS_setsockopt: u64 = 54; +export def SYS_getsockopt: u64 = 55; +export def SYS_clone: u64 = 56; +export def SYS_fork: u64 = 57; +export def SYS_vfork: u64 = 58; +export def SYS_execve: u64 = 59; +export def SYS_exit: u64 = 60; +export def SYS_wait4: u64 = 61; +export def SYS_kill: u64 = 62; +export def SYS_uname: u64 = 63; +export def SYS_semget: u64 = 64; +export def SYS_semop: u64 = 65; +export def SYS_semctl: u64 = 66; +export def SYS_shmdt: u64 = 67; +export def SYS_msgget: u64 = 68; +export def SYS_msgsnd: u64 = 69; +export def SYS_msgrcv: u64 = 70; +export def SYS_msgctl: u64 = 71; +export def SYS_fcntl: u64 = 72; +export def SYS_flock: u64 = 73; +export def SYS_fsync: u64 = 74; +export def SYS_fdatasync: u64 = 75; +export def SYS_truncate: u64 = 76; +export def SYS_ftruncate: u64 = 77; +export def SYS_getdents: u64 = 78; +export def SYS_getcwd: u64 = 79; +export def SYS_chdir: u64 = 80; +export def SYS_fchdir: u64 = 81; +export def SYS_rename: u64 = 82; +export def SYS_mkdir: u64 = 83; +export def SYS_rmdir: u64 = 84; +export def SYS_creat: u64 = 85; +export def SYS_link: u64 = 86; +export def SYS_unlink: u64 = 87; +export def SYS_symlink: u64 = 88; +export def SYS_readlink: u64 = 89; +export def SYS_chmod: u64 = 90; +export def SYS_fchmod: u64 = 91; +export def SYS_chown: u64 = 92; +export def SYS_fchown: u64 = 93; +export def SYS_lchown: u64 = 94; +export def SYS_umask: u64 = 95; +export def SYS_gettimeofday: u64 = 96; +export def SYS_getrlimit: u64 = 97; +export def SYS_getrusage: u64 = 98; +export def SYS_sysinfo: u64 = 99; +export def SYS_times: u64 = 100; +export def SYS_ptrace: u64 = 101; +export def SYS_getuid: u64 = 102; +export def SYS_syslog: u64 = 103; +export def SYS_getgid: u64 = 104; +export def SYS_setuid: u64 = 105; +export def SYS_setgid: u64 = 106; +export def SYS_geteuid: u64 = 107; +export def SYS_getegid: u64 = 108; +export def SYS_setpgid: u64 = 109; +export def SYS_getppid: u64 = 110; +export def SYS_getpgrp: u64 = 111; +export def SYS_setsid: u64 = 112; +export def SYS_setreuid: u64 = 113; +export def SYS_setregid: u64 = 114; +export def SYS_getgroups: u64 = 115; +export def SYS_setgroups: u64 = 116; +export def SYS_setresuid: u64 = 117; +export def SYS_getresuid: u64 = 118; +export def SYS_setresgid: u64 = 119; +export def SYS_getresgid: u64 = 120; +export def SYS_getpgid: u64 = 121; +export def SYS_setfsuid: u64 = 122; +export def SYS_setfsgid: u64 = 123; +export def SYS_getsid: u64 = 124; +export def SYS_capget: u64 = 125; +export def SYS_capset: u64 = 126; +export def SYS_rt_sigpending: u64 = 127; +export def SYS_rt_sigtimedwait: u64 = 128; +export def SYS_rt_sigqueueinfo: u64 = 129; +export def SYS_rt_sigsuspend: u64 = 130; +export def SYS_sigaltstack: u64 = 131; +export def SYS_utime: u64 = 132; +export def SYS_mknod: u64 = 133; +export def SYS_uselib: u64 = 134; +export def SYS_personality: u64 = 135; +export def SYS_ustat: u64 = 136; +export def SYS_statfs: u64 = 137; +export def SYS_fstatfs: u64 = 138; +export def SYS_sysfs: u64 = 139; +export def SYS_getpriority: u64 = 140; +export def SYS_setpriority: u64 = 141; +export def SYS_sched_setparam: u64 = 142; +export def SYS_sched_getparam: u64 = 143; +export def SYS_sched_setscheduler: u64 = 144; +export def SYS_sched_getscheduler: u64 = 145; +export def SYS_sched_get_priority_max: u64 = 146; +export def SYS_sched_get_priority_min: u64 = 147; +export def SYS_sched_rr_get_interval: u64 = 148; +export def SYS_mlock: u64 = 149; +export def SYS_munlock: u64 = 150; +export def SYS_mlockall: u64 = 151; +export def SYS_munlockall: u64 = 152; +export def SYS_vhangup: u64 = 153; +export def SYS_modify_ldt: u64 = 154; +export def SYS_pivot_root: u64 = 155; +export def SYS__sysctl: u64 = 156; +export def SYS_prctl: u64 = 157; +export def SYS_arch_prctl: u64 = 158; +export def SYS_adjtimex: u64 = 159; +export def SYS_setrlimit: u64 = 160; +export def SYS_chroot: u64 = 161; +export def SYS_sync: u64 = 162; +export def SYS_acct: u64 = 163; +export def SYS_settimeofday: u64 = 164; +export def SYS_mount: u64 = 165; +export def SYS_umount2: u64 = 166; +export def SYS_swapon: u64 = 167; +export def SYS_swapoff: u64 = 168; +export def SYS_reboot: u64 = 169; +export def SYS_sethostname: u64 = 170; +export def SYS_setdomainname: u64 = 171; +export def SYS_iopl: u64 = 172; +export def SYS_ioperm: u64 = 173; +export def SYS_create_module: u64 = 174; +export def SYS_init_module: u64 = 175; +export def SYS_delete_module: u64 = 176; +export def SYS_get_kernel_syms: u64 = 177; +export def SYS_query_module: u64 = 178; +export def SYS_quotactl: u64 = 179; +export def SYS_nfsservctl: u64 = 180; +export def SYS_getpmsg: u64 = 181; +export def SYS_putpmsg: u64 = 182; +export def SYS_afs_syscall: u64 = 183; +export def SYS_tuxcall: u64 = 184; +export def SYS_security: u64 = 185; +export def SYS_gettid: u64 = 186; +export def SYS_readahead: u64 = 187; +export def SYS_setxattr: u64 = 188; +export def SYS_lsetxattr: u64 = 189; +export def SYS_fsetxattr: u64 = 190; +export def SYS_getxattr: u64 = 191; +export def SYS_lgetxattr: u64 = 192; +export def SYS_fgetxattr: u64 = 193; +export def SYS_listxattr: u64 = 194; +export def SYS_llistxattr: u64 = 195; +export def SYS_flistxattr: u64 = 196; +export def SYS_removexattr: u64 = 197; +export def SYS_lremovexattr: u64 = 198; +export def SYS_fremovexattr: u64 = 199; +export def SYS_tkill: u64 = 200; +export def SYS_time: u64 = 201; +export def SYS_futex: u64 = 202; +export def SYS_sched_setaffinity: u64 = 203; +export def SYS_sched_getaffinity: u64 = 204; +export def SYS_set_thread_area: u64 = 205; +export def SYS_io_setup: u64 = 206; +export def SYS_io_destroy: u64 = 207; +export def SYS_io_getevents: u64 = 208; +export def SYS_io_submit: u64 = 209; +export def SYS_io_cancel: u64 = 210; +export def SYS_get_thread_area: u64 = 211; +export def SYS_lookup_dcookie: u64 = 212; +export def SYS_epoll_create: u64 = 213; +export def SYS_epoll_ctl_old: u64 = 214; +export def SYS_epoll_wait_old: u64 = 215; +export def SYS_remap_file_pages: u64 = 216; +export def SYS_getdents64: u64 = 217; +export def SYS_set_tid_address: u64 = 218; +export def SYS_restart_syscall: u64 = 219; +export def SYS_semtimedop: u64 = 220; +export def SYS_fadvise64: u64 = 221; +export def SYS_timer_create: u64 = 222; +export def SYS_timer_settime: u64 = 223; +export def SYS_timer_gettime: u64 = 224; +export def SYS_timer_getoverrun: u64 = 225; +export def SYS_timer_delete: u64 = 226; +export def SYS_clock_settime: u64 = 227; +export def SYS_clock_gettime: u64 = 228; +export def SYS_clock_getres: u64 = 229; +export def SYS_clock_nanosleep: u64 = 230; +export def SYS_exit_group: u64 = 231; +export def SYS_epoll_wait: u64 = 232; +export def SYS_epoll_ctl: u64 = 233; +export def SYS_tgkill: u64 = 234; +export def SYS_utimes: u64 = 235; +export def SYS_vserver: u64 = 236; +export def SYS_mbind: u64 = 237; +export def SYS_set_mempolicy: u64 = 238; +export def SYS_get_mempolicy: u64 = 239; +export def SYS_mq_open: u64 = 240; +export def SYS_mq_unlink: u64 = 241; +export def SYS_mq_timedsend: u64 = 242; +export def SYS_mq_timedreceive: u64 = 243; +export def SYS_mq_notify: u64 = 244; +export def SYS_mq_getsetattr: u64 = 245; +export def SYS_kexec_load: u64 = 246; +export def SYS_waitid: u64 = 247; +export def SYS_add_key: u64 = 248; +export def SYS_request_key: u64 = 249; +export def SYS_keyctl: u64 = 250; +export def SYS_ioprio_set: u64 = 251; +export def SYS_ioprio_get: u64 = 252; +export def SYS_inotify_init: u64 = 253; +export def SYS_inotify_add_watch: u64 = 254; +export def SYS_inotify_rm_watch: u64 = 255; +export def SYS_migrate_pages: u64 = 256; +export def SYS_openat: u64 = 257; +export def SYS_mkdirat: u64 = 258; +export def SYS_mknodat: u64 = 259; +export def SYS_fchownat: u64 = 260; +export def SYS_futimesat: u64 = 261; +export def SYS_newfstatat: u64 = 262; +export def SYS_unlinkat: u64 = 263; +export def SYS_renameat: u64 = 264; +export def SYS_linkat: u64 = 265; +export def SYS_symlinkat: u64 = 266; +export def SYS_readlinkat: u64 = 267; +export def SYS_fchmodat: u64 = 268; +export def SYS_faccessat: u64 = 269; +export def SYS_pselect6: u64 = 270; +export def SYS_ppoll: u64 = 271; +export def SYS_unshare: u64 = 272; +export def SYS_set_robust_list: u64 = 273; +export def SYS_get_robust_list: u64 = 274; +export def SYS_splice: u64 = 275; +export def SYS_tee: u64 = 276; +export def SYS_sync_file_range: u64 = 277; +export def SYS_vmsplice: u64 = 278; +export def SYS_move_pages: u64 = 279; +export def SYS_utimensat: u64 = 280; +export def SYS_epoll_pwait: u64 = 281; +export def SYS_signalfd: u64 = 282; +export def SYS_timerfd_create: u64 = 283; +export def SYS_eventfd: u64 = 284; +export def SYS_fallocate: u64 = 285; +export def SYS_timerfd_settime: u64 = 286; +export def SYS_timerfd_gettime: u64 = 287; +export def SYS_accept4: u64 = 288; +export def SYS_signalfd4: u64 = 289; +export def SYS_eventfd2: u64 = 290; +export def SYS_epoll_create1: u64 = 291; +export def SYS_dup3: u64 = 292; +export def SYS_pipe2: u64 = 293; +export def SYS_inotify_init1: u64 = 294; +export def SYS_preadv: u64 = 295; +export def SYS_pwritev: u64 = 296; +export def SYS_rt_tgsigqueueinfo: u64 = 297; +export def SYS_perf_event_open: u64 = 298; +export def SYS_recvmmsg: u64 = 299; +export def SYS_fanotify_init: u64 = 300; +export def SYS_fanotify_mark: u64 = 301; +export def SYS_prlimit64: u64 = 302; +export def SYS_name_to_handle_at: u64 = 303; +export def SYS_open_by_handle_at: u64 = 304; +export def SYS_clock_adjtime: u64 = 305; +export def SYS_syncfs: u64 = 306; +export def SYS_sendmmsg: u64 = 307; +export def SYS_setns: u64 = 308; +export def SYS_getcpu: u64 = 309; +export def SYS_process_vm_readv: u64 = 310; +export def SYS_process_vm_writev: u64 = 311; +export def SYS_kcmp: u64 = 312; +export def SYS_finit_module: u64 = 313; +export def SYS_sched_setattr: u64 = 314; +export def SYS_sched_getattr: u64 = 315; +export def SYS_renameat2: u64 = 316; +export def SYS_seccomp: u64 = 317; +export def SYS_getrandom: u64 = 318; +export def SYS_memfd_create: u64 = 319; +export def SYS_kexec_file_load: u64 = 320; +export def SYS_bpf: u64 = 321; +export def SYS_execveat: u64 = 322; +export def SYS_userfaultfd: u64 = 323; +export def SYS_membarrier: u64 = 324; +export def SYS_mlock2: u64 = 325; +export def SYS_copy_file_range: u64 = 326; +export def SYS_preadv2: u64 = 327; +export def SYS_pwritev2: u64 = 328; +export def SYS_pkey_mprotect: u64 = 329; +export def SYS_pkey_alloc: u64 = 330; +export def SYS_pkey_free: u64 = 331; +export def SYS_statx: u64 = 332; +export def SYS_io_pgetevents: u64 = 333; +export def SYS_rseq: u64 = 334; +export def SYS_pidfd_send_signal: u64 = 424; +export def SYS_io_uring_setup: u64 = 425; +export def SYS_io_uring_enter: u64 = 426; +export def SYS_io_uring_register: u64 = 427; +export def SYS_open_tree: u64 = 428; +export def SYS_move_mount: u64 = 429; +export def SYS_fsopen: u64 = 430; +export def SYS_fsconfig: u64 = 431; +export def SYS_fsmount: u64 = 432; +export def SYS_fspick: u64 = 433; +export def SYS_openat2: u64 = 437; +export def SYS_faccessat2: u64 = 439; diff --git a/example/syscalls.ha b/example/syscalls.ha new file mode 100644 index 000000000..f62dd4fae --- /dev/null +++ b/example/syscalls.ha @@ -0,0 +1,587 @@ +fn syscall0(_: u64) u64; +fn syscall1(_: u64, _: u64) u64; +fn syscall2(_: u64, _: u64, _: u64) u64; +fn syscall3(_: u64, _: u64, _: u64, _: u64) u64; +fn syscall4(_: u64, _: u64, _: u64, _: u64, _: u64) u64; +fn syscall5(_: u64, _: u64, _: u64, _: u64, _: u64, _: u64) u64; +fn syscall6(_: u64, _: u64, _: u64, _: u64, _: u64, _: u64, _: u64) u64; + +def PATH_MAX: size = 4096z; +export type path = (str | []u8 | *const char); +let pathbuf: [PATH_MAX + 1]u8 = [0...]; + +// NUL terminates a string and stores it in a static buffer of PATH_MAX+1 bytes +// in length. +fn kpath(path: path) (*const char | errno) = { + let path = match (path) { + c: *const char => return c, + s: str => { + let ptr = &s: *struct { + buf: *[*]u8, + length: size, + capacity: size, + }; + ptr.buf[..ptr.length]; + }, + b: []u8 => b, + }; + if (len(path) + 1 >= len(pathbuf)) { + return ENAMETOOLONG; + }; + memcpy(&pathbuf, path: *[*]u8, len(path)); + pathbuf[len(path)] = 0; + return &pathbuf: *const char; +}; + +export fn read(fd: int, buf: *void, count: size) (size | errno) = { + return wrap_return(syscall3(SYS_read, + fd: u64, buf: uintptr: u64, count: u64))?: size; +}; + +export fn write(fd: int, buf: *const void, count: size) (size | errno) = { + return wrap_return(syscall3(SYS_write, + fd: u64, buf: uintptr: u64, count: u64))?: size; +}; + +export fn open(path: path, flags: int, mode: uint) (int | errno) = { + let path = kpath(path)?; + return wrap_return(syscall4(SYS_openat, AT_FDCWD: u64, + path: uintptr: u64, flags: u64, mode: u64))?: int; +}; + +fn openat( + dirfd: int, + path: *const char, + flags: int, + mode: uint, +) (int | errno) = wrap_return(syscall4(SYS_openat, dirfd: u64, + path: uintptr: u64, flags: u64, mode: u64))?: int; + +export fn openat2( + dirfd: int, + path: path, + how: *open_how, + how_sz: size, +) (int | errno) = { + let path = kpath(path)?; + return openat(dirfd, path, how.flags: int, how.mode: uint); +}; + +export fn unlink(path: path) (void | errno) = { + let path = kpath(path)?; + wrap_return(syscall3(SYS_unlinkat, + AT_FDCWD: u64, path: uintptr: u64, 0u64)); + return; +}; + +export fn unlinkat(dirfd: int, path: path, flags: int) (void | errno) = { + let path = kpath(path)?; + wrap_return(syscall3(SYS_unlinkat, + dirfd: u64, path: uintptr: u64, flags: u64)); + return; +}; + +export fn chmod(path: path, mode: uint) (void | errno) = { + let path = kpath(path)?; + wrap_return(syscall3(SYS_fchmodat, + AT_FDCWD: u64, path: uintptr: u64, mode: u64)); + return; +}; + +export fn fchmodat(dirfd: int, path: path, mode: uint) (void | errno) = { + let path = kpath(path)?; + wrap_return(syscall3(SYS_fchmodat, + dirfd: u64, path: uintptr: u64, mode: u64))?; + return; +}; + +export fn chown(path: path, uid: uint, gid: uint) (void | errno) = { + let path = kpath(path)?; + wrap_return(syscall4(SYS_fchownat, + AT_FDCWD: u64, path: uintptr: u64, uid: u32, gid: u32)); + return; +}; + +export fn fchownat(dirfd: int, path: path, uid: uint, gid: uint) (void | errno) = { + let path = kpath(path)?; + wrap_return(syscall4(SYS_fchownat, + dirfd: u64, path: uintptr: u64, uid: u32, gid: u32))?; + return; +}; + +export fn dup(fd: int) (int | errno) = { + return wrap_return(syscall1(SYS_dup, fd: u64))?: int; +}; + +export fn close(fd: int) (void | errno) = { + wrap_return(syscall1(SYS_close, fd: u64))?; + return; +}; + +export fn chdir(path: path) (void | errno) = { + let path = kpath(path)?; + wrap_return(syscall1(SYS_chdir, path: uintptr: u64))?; + return; +}; + +export fn fchdir(fd: int) (void | errno) = { + wrap_return(syscall1(SYS_fchdir, fd: u64))?; + return; +}; + +export fn chroot(path: path) (void | errno) = { + let path = kpath(path)?; + wrap_return(syscall1(SYS_chroot, path: uintptr: u64))?; + return; +}; + +export fn mkdir(path: path, mode: uint) (void | errno) = { + let path = kpath(path)?; + wrap_return(syscall3(SYS_mkdirat, AT_FDCWD: u64, + path: uintptr: u64, mode: u64))?; + return; +}; + +export fn mkdirat(dirfd: int, path: path, mode: uint) (void | errno) = { + let path = kpath(path)?; + wrap_return(syscall3(SYS_mkdirat, + dirfd: u64, path: uintptr: u64, mode: u64))?; + return; +}; + +export fn execveat(dirfd: int, path: path, argv: *[*]nullable *const char, + envp: *[*]nullable *const char, flags: int) errno = { + let path = kpath(path)?; + return match (wrap_return(syscall5(SYS_execveat, dirfd: u64, + path: uintptr: u64, argv: uintptr: u64, + envp: uintptr: u64, flags: u64))) { + err: errno => err, + u64 => abort("unreachable"), + }; +}; + +// Returns the new PID to the parent, void to the child, or errno if something +// goes wrong. +export fn fork() (int | void | errno) = clone(null, SIGCHLD, null, null, 0); + +export fn getpid() int = syscall0(SYS_getpid): int; + +export fn wait4( + pid: int, + wstatus: *int, + options: int, + rusage: *rusage, +) (int | errno) = { + return wrap_return(syscall4(SYS_wait4, + pid: u64, wstatus: uintptr: u64, + options: u64, rusage: uintptr: u64))?: int; +}; + +export fn sendfile( + out: int, + in: int, + offs: nullable *size, + count: size, +) (size | errno) = wrap_return(syscall4(SYS_sendfile, + out: u64, in: u64, offs: uintptr: u64, count: u64))?: size; + +export @noreturn fn exit(status: int) void = syscall1(SYS_exit, status: u64); + +export fn kill(pid: int, signal: int) (void | errno) = { + wrap_return(syscall2(SYS_kill, pid: u64, signal: u64))?; + return; +}; + +export fn pipe2(pipefd: *[2]int, flags: int) (void | errno) = { + wrap_return(syscall2(SYS_pipe2, pipefd: uintptr: u64, flags: u64))?; + return; +}; + +export fn mmap( + addr: nullable *void, + length: size, + prot: uint, + flags: uint, + fd: int, + offs: size +) (*void | errno) = { + let r = syscall6(SYS_mmap, addr: uintptr: u64, + length: u64, prot: u64, flags: u64, fd: u64, offs: u64); + match (wrap_return(r)) { + err: errno => { + // XXX: Type promotion would simplify this + return if (r: int == -EPERM + && addr: uintptr == null: uintptr + && (flags & MAP_ANON) > 0 + && (flags & MAP_FIXED) == 0) { + // Fix up incorrect EPERM from kernel: + wrap_errno(ENOMEM); + } else err; + }, + n: u64 => n: uintptr: *void, + }; +}; + +export fn munmap(addr: *void, length: size) (void | errno) = { + wrap_return(syscall2(SYS_munmap, + addr: uintptr: u64, length: u64))?; + return; +}; + + +export fn mprotect(addr: *void, length: size, prot: uint) (void | errno) = { + wrap_return(syscall3(SYS_mprotect, + addr: uintptr: u64, length: u64, prot: u64))?; + return; +}; + + +export fn lseek(fd: int, off: i64, whence: uint) (i64 | errno) = { + return wrap_return(syscall3(SYS_lseek, + fd: u64, off: u64, whence: u64))?: i64; +}; + +fn faccessat1(dirfd: int, path: *const char, mode: int) (bool | errno) = { + return match (wrap_return(syscall3(SYS_faccessat, dirfd: u64, + path: uintptr: u64, mode: u64))) { + err: errno => switch (err) { + EACCES => false, + * => err, + }, + n: u64 => { + assert(n == 0); + true; + }, + }; +}; + +// The use of this function is discouraged, as it can create race conditions. +// TOCTOU is preferred: attempt to simply use the resource you need and handle +// any access errors which occur. +export fn faccessat( + dirfd: int, + path: path, + mode: int, + flags: int, +) (bool | errno) = { + let path = kpath(path)?; + return match (wrap_return(syscall4(SYS_faccessat2, dirfd: u64, + path: uintptr: u64, mode: u64, flags: u64))) { + err: errno => switch (err) { + EACCES => false, + ENOSYS => + if (flags == 0) faccessat1(dirfd, path, mode) + else err, + * => err, + }, + n: u64 => { + assert(n == 0); + true; + }, + }; +}; + +export fn getdents64(dirfd: int, dirp: *void, count: size) (size | errno) = { + return wrap_return(syscall3(SYS_getdents64, dirfd: u64, + dirp: uintptr: u64, count: u64))?: size; +}; + +// The use of this function is discouraged, as it can create race conditions. +// TOCTOU is preferred: attempt to simply use the resource you need and handle +// any access errors which occur. +export fn access(path: path, mode: int) (bool | errno) = + faccessat(AT_FDCWD, path, mode, 0); + +export type fcntl_arg = (void | int | *st_flock | *f_owner_ex | *u64); + +export fn fcntl(fd: int, cmd: int, arg: fcntl_arg) (int | errno) = { + let _fd = fd: u64, _cmd = cmd: u64; + return wrap_return(match (arg) { + void => syscall2(SYS_fcntl, _fd, _cmd), + i: int => syscall3(SYS_fcntl, _fd, _cmd, i: u64), + l: *st_flock => syscall3(SYS_fcntl, _fd, _cmd, l: uintptr: u64), + o: *f_owner_ex => syscall3(SYS_fcntl, _fd, _cmd, o: uintptr: u64), + u: *u64 => syscall3(SYS_fcntl, _fd, _cmd, u: uintptr: u64), + })?: int; +}; + +export fn getrandom(buf: *void, bufln: size, flags: uint) (size | errno) = { + return wrap_return(syscall3(SYS_getrandom, + buf: uintptr: u64, bufln: u64, flags: u64))?: size; +}; + +// TODO: Implement me with VDSO +export fn clock_gettime(clock_id: int, tp: *timespec) (void | errno) = { + wrap_return(syscall2(SYS_clock_gettime, + clock_id: u64, tp: uintptr: u64))?; + return; +}; + +export fn nanosleep(req: *const timespec, rem: *timespec) (void | errno) = { + wrap_return(syscall2(SYS_nanosleep, + req: uintptr: u64, rem: uintptr: u64))?; + return; +}; + +export fn uname(uts: *utsname) (void | errno) = { + wrap_return(syscall1(SYS_uname, uts: uintptr: u64))?; + return; +}; + +// The return value is statically allocated and must be duplicated before +// calling getcwd again. +export fn getcwd() (*const char | errno) = { + static let pathbuf: [PATH_MAX + 1]u8 = [0...]; + wrap_return(syscall2(SYS_getcwd, + &pathbuf: *[*]u8: uintptr: u64, + PATH_MAX + 1))?; + return &pathbuf: *const char; +}; + +export fn ppoll( + fds: *pollfd, + nfds: nfds_t, + timeout: const nullable *timespec, + sigmask: const nullable *sigset, +) (int | errno) = { + return wrap_return(syscall4(SYS_ppoll, fds: uintptr: u64, nfds: u64, + timeout: uintptr: u64, sigmask: uintptr: u64))?: int; +}; + +export fn poll(fds: *pollfd, nfds: nfds_t, timeout: int) (int | errno) = { + const ts = timespec { + tv_sec = timeout % 1000, + tv_nsec = timeout * 1000000, + }; + return ppoll(fds, nfds, (if (timeout != -1) &ts else null), null); +}; + +export fn epoll_create1(flags: int) (int | errno) = { + return wrap_return(syscall1(SYS_epoll_create1, flags: u64))?: int; +}; + +export fn epoll_create(size_: int) (int | errno) = { + return epoll_create1(0); +}; + +export fn epoll_ctl( + epfd: int, + op: int, + fd: int, + event: nullable *epoll_event +) (int | errno) = { + return wrap_return(syscall4(SYS_epoll_ctl, + epfd: u64, op: u64, fd: u64, event: uintptr: u64))?: int; +}; + +export fn epoll_pwait( + epfd: int, + events: *epoll_event, + maxevents: int, + timeout: int, + sigmask: nullable *sigset +) (int | errno) = { + return wrap_return(syscall6(SYS_epoll_pwait, + epfd: u64, events: uintptr: u64, + maxevents: u64, timeout: u64, + sigmask: uintptr: u64, size(sigset): u64))?: int; +}; + +export fn epoll_wait( + epfd: int, + events: *epoll_event, + maxevents: int, + timeout: int, +) (int | errno) = { + return epoll_pwait(epfd, events, maxevents, timeout, null); +}; + +export fn timerfd_create(clock_id: int, flags: int) (int | errno) = { + return wrap_return(syscall2(SYS_timerfd_create, + clock_id: u64, flags: u64))?: int; +}; + +export fn timerfd_settime( + fd: int, + flags: int, + new_value: *const itimerspec, + old_value: nullable *itimerspec +) (int | errno) = { + return wrap_return(syscall4(SYS_timerfd_settime, + fd: u64, flags: u64, + new_value: uintptr: u64, old_value: uintptr: u64))?: int; +}; + +export fn timerfd_gettime(fd: int, curr_value: *itimerspec) (int | errno) = { + return wrap_return(syscall2(SYS_timerfd_gettime, + fd: u64, curr_value: uintptr: u64))?: int; +}; + +export fn signalfd(fd: int, mask: *const sigset, flags: int) (int | errno) = { + return wrap_return(syscall4(SYS_signalfd4, + fd: u64, mask: uintptr: u64, size(sigset): u64, + flags: u64))?: int; +}; + +export fn sigprocmask( + how: int, + set: *const sigset, + old: nullable *sigset +) (int | errno) = { + return wrap_return(syscall4(SYS_rt_sigprocmask, + how: u64, set: uintptr: u64, old: uintptr: u64, + size(sigset): u64))?: int; +}; + +fn restore() void; +fn restore_si() void; + +export fn sigaction( + signum: int, + act: *const sigact, + old: nullable *sigact +) (int | errno) = { + let real_act = *act; + real_act.sa_flags |= SA_RESTORER; + let restore_fn = if ((act.sa_flags & SA_SIGINFO) != 0) &restore_si else &restore; + real_act.sa_restorer = &restore; + return wrap_return(syscall4(SYS_rt_sigaction, + signum: u64, &real_act: uintptr: u64, old: uintptr: u64, + size(sigset): u64))?: int; +}; + +export fn socket(domain: int, type_: int, protocol: int) (int | errno) = { + return wrap_return(syscall3(SYS_socket, + domain: u64, type_: u64, protocol: u64))?: int; +}; + +export fn connect(sockfd: int, addr: *const sockaddr, addrlen: u32) (int | errno) = { + return wrap_return(syscall3(SYS_connect, + sockfd: u64, addr: uintptr: u64, addrlen: u64))?: int; +}; + +export fn bind(sockfd: int, addr: *const sockaddr, addrlen: u32) (int | errno) = { + return wrap_return(syscall3(SYS_bind, + sockfd: u64, addr: uintptr: u64, addrlen: u64))?: int; +}; + +export fn listen(sockfd: int, backlog: u32) (int | errno) = { + return wrap_return(syscall2(SYS_listen, + sockfd: u64, backlog: u64))?: int; +}; + +export fn accept(sockfd: int, addr: nullable *sockaddr, addrlen: nullable *u32) (int | errno) = { + return wrap_return(syscall3(SYS_accept, + sockfd: u64, addr: uintptr: u64, addrlen: uintptr: u64))?: int; +}; + +export fn recvfrom(sockfd: int, buf: *void, len_: size, flags: int, + src_addr: nullable *sockaddr, addrlen: nullable *u32 +) (size | errno) = { + return wrap_return(syscall6(SYS_recvfrom, + sockfd: u64, buf: uintptr: u64, len_: u64, flags: u64, + src_addr: uintptr: u64, addrlen: uintptr: u64))?: size; +}; + +export fn sendto(sockfd: int, buf: *void, len_: size, flags: int, + dest_addr: nullable *sockaddr, addrlen: nullable *u32 +) (size | errno) = { + return wrap_return(syscall6(SYS_sendto, + sockfd: u64, buf: uintptr: u64, len_: u64, flags: u64, + dest_addr: uintptr: u64, addrlen: uintptr: u64))?: size; +}; + +export fn recv(sockfd: int, buf: *void, len_: size, flags: int) (size | errno) = { + return recvfrom(sockfd, buf, len_, flags, null, null); +}; + +export fn send(sockfd: int, buf: *void, len_: size, flags: int) (size | errno) = { + return sendto(sockfd, buf, len_, flags, null, null); +}; + +export fn getsockopt(sockfd: int, level: int, optname: int, optval: nullable *void, optlen: nullable *u32) (int | errno) = { + return wrap_return(syscall5(SYS_getsockopt, + sockfd: u64, level: u64, optname: u64, + optval: uintptr: u64, optlen: uintptr: u64))?: int; +}; + +export fn setsockopt(sockfd: int, level: int, optname: int, optval: *void, optlen: u32) (int | errno) = { + return wrap_return(syscall5(SYS_setsockopt, + sockfd: u64, level: u64, optname: u64, + optval: uintptr: u64, optlen: u64))?: int; +}; + +export fn ioctl(fd: int, req: u64, arg: nullable *void) (int | errno) = { + return wrap_return(syscall3(SYS_ioctl, fd: u64, + req, arg: uintptr: u64))?: int; +}; + +export fn getsockname(sockfd: int, addr: nullable *sockaddr, addrlen: nullable *u32) (int | errno) = { + return wrap_return(syscall3(SYS_getsockname, + sockfd: u64, addr: uintptr: u64, addrlen: uintptr: u64))?: int; +}; + +export fn getpeername(sockfd: int, addr: nullable *sockaddr, addrlen: nullable *u32) (int | errno) = { + return wrap_return(syscall3(SYS_getpeername, + sockfd: u64, addr: uintptr: u64, addrlen: uintptr: u64))?: int; +}; + +export fn readv(fd: int, iov: *const iovec, iovcnt: int) (int | errno) = { + return wrap_return(syscall3(SYS_readv, + fd: u64, iov: uintptr: u64, iovcnt: u64))?: int; +}; + +export fn writev(fd: int, iov: *const iovec, iovcnt: int) (int | errno) = { + return wrap_return(syscall3(SYS_writev, + fd: u64, iov: uintptr: u64, iovcnt: u64))?: int; +}; + +export fn sendmsg(fd: int, msg: *const msghdr, flags: int) (int | errno) = { + return wrap_return(syscall3(SYS_sendmsg, + fd: u64, msg: uintptr: u64, flags: u64))?: int; +}; + +export fn recvmsg(fd: int, msg: *const msghdr, flags: int) (int | errno) = { + return wrap_return(syscall3(SYS_recvmsg, + fd: u64, msg: uintptr: u64, flags: u64))?: int; +}; + +export fn umask(mode: mode_t) (mode_t | errno) = { + return wrap_return(syscall1(SYS_umask, mode: u64))?: mode_t; +}; + +export fn setresuid(uid: uid_t, euid: uid_t, suid: uid_t) (void | errno) = { + wrap_return(syscall3(SYS_setresuid, uid: u64, euid: u64, suid: u64))?; + return; +}; + +export fn setresgid(gid: gid_t, egid: gid_t, sgid: gid_t) (void | errno) = { + wrap_return(syscall3(SYS_setresgid, gid: u64, egid: u64, sgid: u64))?; + return; +}; + +export fn getresuid(uid: *uid_t, euid: *uid_t, suid: *uid_t) (void | errno) = { + wrap_return(syscall3(SYS_getresuid, + uid: uintptr: u64, + euid: uintptr: u64, + suid: uintptr: u64))?; + return; +}; + +export fn getresgid(gid: *gid_t, egid: *gid_t, sgid: *gid_t) (void | errno) = { + wrap_return(syscall3(SYS_getresgid, + gid: uintptr: u64, + egid: uintptr: u64, + sgid: uintptr: u64))?; + return; +}; + +export fn getpriority(which: int, who: id_t) (int | errno) = { + return wrap_return(syscall2(SYS_setpriority, + which: u64, who: u64))?: int; +}; + +export fn setpriority(which: int, who: id_t, prio: int) (void | errno) = { + wrap_return(syscall3(SYS_setpriority, which: u64, who: u64, prio: u64))?; + return; +}; diff --git a/example/tee.ha b/example/tee.ha new file mode 100644 index 000000000..1e595eb24 --- /dev/null +++ b/example/tee.ha @@ -0,0 +1,34 @@ +type tee_stream = struct { + stream: stream, + source: *stream, + sink: *stream, +}; + +// Creates a reader which copies reads into a sink before forwarding them to the +// caller. Does not close the secondary streams when the tee stream is closed. +export fn tee(source: *stream, sink: *stream) *stream = { + return alloc(tee_stream { + stream = stream { + reader = &tee_read, + closer = &tee_close, + ... + }, + source = source, + sink = sink, + }): *io::stream; +}; + +fn tee_read(s: *stream, buf: []u8) (size | EOF | error) = { + let s = s: *tee_stream; + let z = match (read(s.source, buf)) { + err: error => return err, + EOF => return EOF, + z: size => z, + }; + for (let n = 0z; n < z) { + n += write(s.sink, buf[n..z])?; + }; + return z; +}; + +fn tee_close(s: *stream) void = free(s); diff --git a/example/token.ha b/example/token.ha new file mode 100644 index 000000000..3d3ed46e4 --- /dev/null +++ b/example/token.ha @@ -0,0 +1,283 @@ +use encoding::utf8; +use strings; + +// A token with no additional context, such as '+' +export type btoken = enum { + // Keep ordered with bmap + // Alpha sorted + ATTR_FINI, + ATTR_INIT, + ATTR_NORETURN, + ATTR_OFFSET, + ATTR_SYMBOL, + ATTR_TEST, + UNDERSCORE, + ABORT, + ALLOC, + APPEND, + AS, + ASSERT, + BOOL, + BREAK, + CHAR, + CONST, + CONTINUE, + DEF, + DEFER, + DELETE, + ELSE, + ENUM, + EXPORT, + F32, + F64, + FALSE, + FN, + FOR, + FREE, + I16, + I32, + I64, + I8, + IF, + INT, + IS, + LEN, + LET, + MATCH, + NULL, + NULLABLE, + OFFSET, + RETURN, + RUNE, + SIZE, + STATIC, + STR, + STRUCT, + SWITCH, + TRUE, + TYPE, + U16, + U32, + U64, + U8, + UINT, + UINTPTR, + UNION, + USE, + VOID, + LAST_KEYWORD = VOID, + + // Operators + ANDEQ, + BAND, + BNOT, + BOR, + BXOR, + BXOREQ, + CASE, + COLON, + COMMA, + DIV, + DIVEQ, + DOT, + DOUBLE_COLON, + ELLIPSIS, + EQUAL, + GREATER, + GREATEREQ, + LAND, + LBRACE, + LBRACKET, + LEQUAL, + LESS, + LESSEQ, + LNOT, + LOR, + LPAREN, + LSHIFT, + LSHIFTEQ, + LXOR, + MINUS, + MINUSEQ, + MINUSMINUS, + MODEQ, + MODULO, + NEQUAL, + OREQ, + PLUS, + PLUSEQ, + PLUSPLUS, + QUESTION, + RBRACE, + RBRACKET, + RPAREN, + RSHIFT, + RSHIFTEQ, + SEMICOLON, + SLICE, + TIMES, + TIMESEQ, +}; + +const bmap: [_]str = [ + // Keep ordered with btoken + "@fini", + "@init", + "@noreturn", + "@offset", + "@symbol", + "@test", + "_", + "abort", + "alloc", + "append", + "as", + "assert", + "bool", + "break", + "char", + "const", + "continue", + "def", + "defer", + "delete", + "else", + "enum", + "export", + "f32", + "f64", + "false", + "fn", + "for", + "free", + "i16", + "i32", + "i64", + "i8", + "if", + "int", + "is", + "len", + "let", + "match", + "null", + "nullable", + "offset", + "return", + "rune", + "size", + "static", + "str", + "struct", + "switch", + "true", + "type", + "u16", + "u32", + "u64", + "u8", + "uint", + "uintptr", + "union", + "use", + "void", + "&=", + "&", + "^", + "^=", + "~", + "|", + "=>", + ":", + ",", + "/", + "/=", + ".", + "::", + "...", + "=", + ">", + ">=", + "&&", + "{", + "[", + "==", + "<", + "<=", + "!", + "||", + "(", + "<<", + "<<=", + "^^", + "-", + "-=", + "--", + "?", + "%=", + "%", + "!=", + "|=", + "+", + "+=", + "++", + "}", + "]", + ")", + ">>", + ">>=", + ";", + "..", + "*", + "*=", +]; + +// A loop label, such as ':example' +export type label = str; + +// A name, such as 'example' +export type name = str; + +export type iconst = i64; +export type fconst = f64; + +// A token for a literal value, such as '1337u32' +export type literal = (u8 | u16 | u32 | u64 | uint | uintptr | i8 | i16 | i32 | + i64 | int | iconst | f32 | f64 | fconst | rune | str); + +// A location within a source file. +// The path is borrowed from the file name given to the lexer. +export type location = struct { + path: str, + line: uint, + col: uint +}; + +// A single lexical token. +export type token = (btoken | label | name | literal); + +// Converts a token to its string representation +export fn tokstr(tok: token) const str = match (tok) { + b: btoken => bmap[b: int], + n: name => n: str, + l: literal => match (l) { + u8 => "u8", + u16 => "u16", + u32 => "u32", + u64 => "u64", + uint => "uint", + uintptr => "uintptr", + i8 => "i8", + i16 => "i16", + i32 => "i32", + i64 => "i64", + int => "int", + iconst => "iconst", + f32 => "f32", + f64 => "f64", + fconst => "fconst", + rune => "rune", + str => "str", + }, + * => abort(), // TODO +}; diff --git a/example/tokenize.ha b/example/tokenize.ha new file mode 100644 index 000000000..0b2331887 --- /dev/null +++ b/example/tokenize.ha @@ -0,0 +1,120 @@ +use bytes; +use types; + +// The state for a tokenizer. +export type tokenizer = bytes::tokenizer; + +// Returns a tokenizer which yields sub-strings tokenized by a delimiter. +// +// let tok = strings::tokenize("hello, my name is drew", " "); +// assert(strings::next_token(tok) == "hello,"); +// assert(strings::next_token(tok) == "my"); +// assert(strings::next_token(tok) == "name"); +// assert(strings::remaining_tokens(tok) == "is drew"); +export fn tokenize(s: str, delim: str) tokenizer = + bytes::tokenize(toutf8(s), toutf8(delim)); + +// Returns the next string from a tokenizer, and advances the cursor. Returns +// void if there are no tokens left. +export fn next_token(s: *tokenizer) (str | void) = { + return match (bytes::next_token(s)) { + b: []u8 => fromutf8(b), + void => void, + }; +}; + +// Same as next_token(), but does not advance the cursor +export fn peek_token(s: *tokenizer) (str | void) = { + return match (bytes::peek_token(s)) { + b: []u8 => fromutf8(b), + void => void, + }; +}; + +// Returns the remainder of the string associated with a tokenizer, without doing +// any further tokenization. +export fn remaining_tokens(s: *tokenizer) str = { + return fromutf8(bytes::remaining_tokens(s)); +}; + +@test fn tokenize() void = { + let tok = tokenize("Hello, my name is drew", " "); + match (next_token(&tok)) { + s: str => assert(s == "Hello,"), + void => abort(), + }; + + match (next_token(&tok)) { + s: str => assert(s == "my"), + void => abort(), + }; + + match (peek_token(&tok)) { + s: str => assert(s == "name"), + void => abort(), + }; + + + match (next_token(&tok)) { + s: str => assert(s == "name"), + void => abort(), + }; + + assert(remaining_tokens(&tok) == "is drew"); + assert(peek_token(&tok) as str == "is"); + assert(remaining_tokens(&tok) == "is drew"); + + tok = tokenize("foo", "foo"); + + assert(peek_token(&tok) as str == ""); + assert(next_token(&tok) as str == ""); + + assert(peek_token(&tok) as str == ""); + assert(next_token(&tok) as str == ""); + + assert(peek_token(&tok) is void); + assert(next_token(&tok) is void); + + tok = tokenize("", "foo"); + assert(peek_token(&tok) is void); + assert(next_token(&tok) is void); +}; + +// Splits a string into tokens delimited by 'delim', returning a slice of up to +// N tokens. The caller must free this slice. The strings within the slice are +// borrowed from 'in', and needn't be freed - but should be [strings::dup_all]'d +// if they should outlive 'in'. +export fn splitN(in: str, delim: str, n: size) []str = { + let toks: []str = alloc([]); + let tok = tokenize(in, delim); + for (let i = 0z; i < n - 1z; i += 1) { + match (next_token(&tok)) { + s: str => append(toks, s), + void => return toks, + }; + }; + append(toks, remaining_tokens(&tok)); + return toks; +}; + +// Splits a string into tokens delimited by 'delim'. The caller must free the +// returned slice. The strings within the slice are borrowed from 'in', and +// needn't be freed - but must be [strings::dup_all]'d if they should outlive +// 'in'. +export fn split(in: str, delim: str) []str = splitN(in, delim, types::SIZE_MAX); + +@test fn split() void = { + const expected = ["Hello,", "my", "name", "is Drew"]; + const actual = splitN("Hello, my name is Drew", " ", 4z); + assert(len(expected) == len(actual)); + for (let i = 0z; i < len(expected); i += 1) { + assert(expected[i] == actual[i]); + }; + + const expected2 = ["Hello,", "my", "name", "is", "Drew"]; + const actual2 = split("Hello, my name is Drew", " "); + assert(len(expected2) == len(actual2)); + for (let i = 0z; i < len(expected2); i += 1) { + assert(expected2[i] == actual2[i]); + }; +}; diff --git a/example/type.ha b/example/type.ha new file mode 100644 index 000000000..b277feb38 --- /dev/null +++ b/example/type.ha @@ -0,0 +1,293 @@ +use fmt; +use io; +use hare::ast; +use hare::lex; +use strio; + +fn builtin_type(b: ast::builtin_type) str = switch (b) { + ast::builtin_type::BOOL => "bool", + ast::builtin_type::CHAR => "char", + ast::builtin_type::F32 => "f32", + ast::builtin_type::F64 => "f64", + ast::builtin_type::FCONST => abort("FCONST has no lexical representation"), + ast::builtin_type::I16 => "i16", + ast::builtin_type::I32 => "i32", + ast::builtin_type::I64 => "i64", + ast::builtin_type::I8 => "i8", + ast::builtin_type::ICONST => abort("ICONST has no lexical representation"), + ast::builtin_type::INT => "int", + ast::builtin_type::NULL => "null", + ast::builtin_type::RUNE => "rune", + ast::builtin_type::SIZE => "size", + ast::builtin_type::STR => "str", + ast::builtin_type::U16 => "u16", + ast::builtin_type::U32 => "u32", + ast::builtin_type::U64 => "u64", + ast::builtin_type::U8 => "u8", + ast::builtin_type::UINT => "uint", + ast::builtin_type::UINTPTR => "uintptr", + ast::builtin_type::VOID => "void", +}; + +fn prototype( + out: *io::stream, + indent: size, + t: ast::func_type, +) (size | io::error) = { + let n = 0z; + n += fmt::fprint(out, "(")?; + for (let i = 0z; i < len(t.params); i += 1) { + let param = t.params[i]; + n += fmt::fprintf(out, "{}: ", + if (len(param.name) == 0) "_" else param.name)?; + n += _type(out, indent, *param._type)?; + if (i + 1 == len(t.params) + && t.variadism == ast::variadism::HARE) { + n += fmt::fprintf(out, "...")?; + }; + if (i + 1 < len(t.params)) { + n += fmt::fprint(out, ", ")?; + }; + }; + if (t.variadism == ast::variadism::C) { + n += fmt::fprint(out, ", ...")?; + }; + n += fmt::fprint(out, ") ")?; + n += _type(out, indent, *t.result)?; + return n; +}; + +export fn _type( + out: *io::stream, + indent: size, + t: ast::_type, +) (size | io::error) = { + let n = 0z; + if (t.flags & ast::type_flags::CONST != 0 + && !(t._type is ast::func_type)) { + n += fmt::fprint(out, "const ")?; + }; + match (t._type) { + a: ast::alias_type => { + if (a.unwrap) { + n += fmt::fprint(out, "...")?; + }; + n += ident(out, a.ident)?; + }, + b: ast::builtin_type => n += fmt::fprint(out, builtin_type(b))?, + e: ast::enum_type => { + n += fmt::fprint(out, "enum", + builtin_type(e.storage), "{")?; + indent += 1; + for (let i = 0z; i < len(e.values); i += 1) { + n += newline(out, indent)?; + let value = e.values[i]; + n += fmt::fprint(out, value.name)?; + match (value.value) { + null => void, + e: *ast::expr => { + n += fmt::fprint(out, ": ")?; + n += expr(out, indent, *e)?; + }, + }; + n += fmt::fprint(out, ",")?; + }; + indent -= 1; + n += newline(out, indent)?; + n += fmt::fprint(out, "}")?; + }, + f: ast::func_type => { + if (f.attrs & ast::func_attrs::NORETURN != 0) { + n += fmt::fprint(out, "@noreturn ")?; + }; + n += fmt::fprint(out, "fn")?; + n += prototype(out, indent, f)?; + }, + l: ast::list_type => { + n += fmt::fprint(out, "[")?; + n += match (l.length) { + ast::len_slice => 0, + ast::len_unbounded => fmt::fprint(out, "*")?, + ast::len_contextual => fmt::fprint(out, "_")?, + e: *ast::expr => expr(out, indent, *e)?, + }; + n += fmt::fprint(out, "]")?; + n += _type(out, indent, *l.members)?; + }, + p: ast::pointer_type => { + if (p.flags & ast::pointer_flags::NULLABLE != 0) { + n += fmt::fprint(out, "nullable ")?; + }; + n += fmt::fprint(out, "*")?; + n += _type(out, indent, *p.referent)?; + }, + s: []ast::struct_member => abort(), // TODO + t: ast::tagged_type => { + n += fmt::fprint(out, "(")?; + for (let i = 0z; i < len(t); i += 1) { + n += _type(out, indent, *t[i])?; + if (i + 1 < len(t)) { + n += fmt::fprint(out, " | ")?; + }; + }; + n += fmt::fprint(out, ")")?; + }, + t: ast::tuple_type => { + n += fmt::fprint(out, "(")?; + for (let i = 0z; i < len(t); i += 1) { + n += _type(out, indent, *t[i])?; + if (i + 1 < len(t)) { + n += fmt::fprint(out, ", ")?; + }; + }; + n += fmt::fprint(out, ")")?; + }, + }; + if (t.flags & ast::type_flags::ERROR != 0) { + n += fmt::fprint(out, "!")?; + }; + return n; +}; + +fn type_test(t: ast::_type, expected: str) bool = { + let buf = strio::dynamic(); + _type(buf, 0, t) as size; + let s = strio::finish(buf); + defer free(s); + return s == expected; +}; + +@test fn _type() void = { + let loc = lex::location { + path = "", + line = 0, + col = 0, + }; + let t = ast::_type { + loc = loc, + flags = ast::type_flags::CONST, + _type = ast::alias_type { + unwrap = false, + ident = ["foo", "bar"], + }, + }; + let type_int = ast::_type { + loc = loc, + flags = 0, + _type = ast::builtin_type::INT, + }; + let expr_void = void: ast::constant_expr: ast::expr; + + assert(type_test(t, "const foo::bar")); + t.flags = 0; + t._type = ast::alias_type { + unwrap = true, + ident = ["baz"], + }; + assert(type_test(t, "...baz")); + + t.flags = ast::type_flags::ERROR; + t._type = ast::builtin_type::INT; + assert(type_test(t, "int!")); + + t.flags = ast::type_flags::CONST | ast::type_flags::ERROR; + t._type = ast::enum_type { + storage = ast::builtin_type::U32, + values = [ + ast::enum_field { + name = "FOO", + value = null, + }, + ast::enum_field { + name = "BAR", + value = &expr_void, + }, + ], + }; + assert(type_test(t, "const enum u32 {\n\tFOO,\n\tBAR: void,\n}!")); + + t.flags = 0; + + t._type = ast::func_type { + result = &type_int, + attrs = 0, + variadism = ast::variadism::NONE, + params = [], + }; + assert(type_test(t, "fn() int")); + t._type = ast::func_type { + result = &type_int, + attrs = ast::func_attrs::NORETURN, + variadism = ast::variadism::C, + params = [ + ast::func_param { + loc = loc, + name = "", + _type = &type_int, + }, + ], + }; + assert(type_test(t, "@noreturn fn(_: int, ...) int")); + t._type = ast::func_type { + result = &type_int, + attrs = 0, + variadism = ast::variadism::HARE, + params = [ + ast::func_param { + loc = loc, + name = "foo", + _type = &type_int, + }, + ast::func_param { + loc = loc, + name = "bar", + _type = &type_int, + }, + ], + }; + assert(type_test(t, "fn(foo: int, bar: int...) int")); + + t.flags = ast::type_flags::CONST; + assert(type_test(t, "fn(foo: int, bar: int...) int")); + + t.flags = 0; + t._type = ast::list_type { + length = ast::len_slice, + members = &type_int, + }; + assert(type_test(t, "[]int")); + t._type = ast::list_type { + length = ast::len_unbounded, + members = &type_int, + }; + assert(type_test(t, "[*]int")); + t._type = ast::list_type { + length = ast::len_contextual, + members = &type_int, + }; + assert(type_test(t, "[_]int")); + t._type = ast::list_type { + length = &expr_void, + members = &type_int, + }; + assert(type_test(t, "[void]int")); + + t._type = ast::pointer_type { + referent = &type_int, + flags = 0, + }; + assert(type_test(t, "*int")); + t._type = ast::pointer_type { + referent = &type_int, + flags = ast::pointer_flags::NULLABLE, + }; + assert(type_test(t, "nullable *int")); + + // TODO: struct_members + + t._type = [&type_int, &type_int]: ast::tagged_type; + assert(type_test(t, "(int | int)")); + + t._type = [&type_int, &type_int]: ast::tuple_type; + assert(type_test(t, "(int, int)")); +}; diff --git a/example/types.ha b/example/types.ha new file mode 100644 index 000000000..e206c6aa7 --- /dev/null +++ b/example/types.ha @@ -0,0 +1,23 @@ +use fmt; +use hare::lex; + +// All possible error types +export type error = lex::error!; + +// Convert an error into a human-friendly string +export fn strerror(err: error) const str = lex::strerror(err: lex::error); + +fn syntaxerr( + loc: lex::location, + fmt: str, + args: fmt::formattable... +) lex::error = { + let why = fmt::asprintf(fmt, args...); + return (loc, why): lex::syntax: lex::error; +}; + +fn mkloc(lex: *lex::lexer) lex::location = lex::location { + path = lex.path, + line = lex.loc.0, + col = lex.loc.1, +}; diff --git a/example/unicode.ha b/example/unicode.ha new file mode 100644 index 000000000..723046ad5 --- /dev/null +++ b/example/unicode.ha @@ -0,0 +1,30 @@ +// This module provides Unicode support for Hare programs. +// +// Programs which deal with basic text manipulation are likely to be served +// sufficiently by the [encoding::utf8], [strings], [ascii], and so on. For +// example, the question of "is this character uppercase?" is often sufficiently +// answered with [ascii::isupper], and matters such as Unicode string +// equivalence are often fraught with error potential - for example, a +// vulnerability was once found in a web login form which used a Unicode +// equivalence comparison on usernames, allowing a malicious actor to register a +// username which was bytewise distinct but uniwise equal to a victim, and then +// use it to log into their account. This module also contains a copy of the +// Unicode Character Database, which is rather large, and linking to it will +// increase the size of your binaries. +// +// The purpose of this module is not to handle every day string manipulation, +// but instead to provide support code for software which is explicitly aware of +// internationalization concerns and seeking out functions which specifically +// address those concerns. +// +// This module makes little attempt to be useful without a broader understanding +// of Unicode. The module is close to a 1:1 implementation of the Unicode +// standard, and it is recommended that any reading of this module's API or +// source code is accompanied by a reading of the Unicode standard. The +// documentation for each type and function makes an effort to direct the reader +// to the appropriate part of the Unicode standard. +// +// See the [i18n] module for a high-level internationalization API. +// +// The present implementation of this module conforms to Unicode 13.0.0, which +// was released on March 11th, 2020. diff --git a/example/unit.ha b/example/unit.ha new file mode 100644 index 000000000..aa94f461b --- /dev/null +++ b/example/unit.ha @@ -0,0 +1,16 @@ +use io; +use fmt; +use hare::ast; + +export fn subunit(out: *io::stream, s: ast::subunit) (size | io::error) = { + let n = 0z; + for (let i = 0z; i < len(s.imports); i += 1) { + n += import(out, s.imports[i])?; + n += fmt::fprintln(out)?; + }; + for (let i = 0z; i < len(s.decls); i += 1) { + n += decl(out, s.decls[i])?; + n += fmt::fprintln(out)?; + }; + return n; +}; diff --git a/example/utf8.ha b/example/utf8.ha new file mode 100644 index 000000000..273a5e9b5 --- /dev/null +++ b/example/utf8.ha @@ -0,0 +1,42 @@ +use encoding::utf8; +use types; + +// Converts a byte slice into a string WITHOUT checking that the byte slice is a +// valid UTF-8 string. +export fn fromutf8_unsafe(in: []u8) str = { + const s = types::string { + data = in: *[*]u8, + length = len(in), + capacity = len(in), + }; + return *(&s: *const str); +}; + +// Converts a byte slice into a string. Aborts if the bytes contain invalid +// UTF-8. To handle such an error without aborting, see +// [encoding::utf8::decode] instead. +export fn fromutf8(in: []u8) str = { + let s = fromutf8_unsafe(in); + assert(utf8::valid(s), "attempted to load invalid UTF-8 string"); + return s; +}; + +// Converts a byte slice into a string. If the slice contains invalid UTF-8 +// sequences, void is returned instead. +export fn try_fromutf8(in: []u8) (str | utf8::invalid) = { + let s = fromutf8_unsafe(in); + if (!utf8::valid(s)) { + return utf8::invalid; + }; + return s; +}; + +// Converts a string to a UTF-8 slice. +export fn toutf8(in: str) []u8 = *(&in: *[]u8); + +@test fn utf8() void = { + assert(fromutf8([ + 0x68, 0x65, 0x6c, 0x6c, 0x6f, 0x20, 0x77, 0x6f, 0x72, 0x6c, 0x64, + ]) == "hello world"); + assert(fromutf8([]) == ""); +}; diff --git a/example/util.ha b/example/util.ha new file mode 100644 index 000000000..962764b8a --- /dev/null +++ b/example/util.ha @@ -0,0 +1,12 @@ +use io; +use fmt; + +fn newline(out: *io::stream, indent: size) (size | io::error) = { + let n = 0z; + n += fmt::fprint(out, "\n")?; + for (let i = 0z; i < indent; i += 1) { + n += fmt::fprint(out, "\t")?; + }; + return n; +}; + diff --git a/example/utos.ha b/example/utos.ha new file mode 100644 index 000000000..0654cfb38 --- /dev/null +++ b/example/utos.ha @@ -0,0 +1,133 @@ +use bytes; +use types; + +// Converts a u64 to a string in the given base. The return value is statically +// allocated and will be overwritten on subsequent calls; see [strings::dup] to +// duplicate the result. +export fn u64tosb(u: u64, b: base) const str = { + static assert(types::U64_MAX == 18446744073709551615); + static let buf: [64]u8 = [0...]; // 64 binary digits + + static const lut_upper = [ + '0', '1', '2', '3', '4', '5', '6', '7', + '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', + ], lut_lower = [ + '0', '1', '2', '3', '4', '5', '6', '7', + '8', '9', 'a', 'b', 'c', 'd', 'e', 'f', + ]; + const lut = if (b != base::HEX_LOWER) &lut_upper else { + b = base::HEX_UPPER; + &lut_lower; + }; + + let s = types::string { data = &buf, ... }; + if (u == 0) { + buf[s.length] = '0': u32: u8; + s.length += 1z; + }; + + for (u > 0u64) { + buf[s.length] = lut[u % b: u64]: u32: u8; + s.length += 1; + u /= b; + }; + + bytes::reverse(buf[..s.length]); + return *(&s: *str); +}; + +// Converts a u32 to a string in the given base. The return value is statically +// allocated and will be overwritten on subsequent calls; see [strings::dup] to +// duplicate the result. +export fn u32tosb(u: u32, b: base) const str = u64tosb(u, b); + +// Converts a u16 to a string in the given base. The return value is statically +// allocated and will be overwritten on subsequent calls; see [strings::dup] to +// duplicate the result. +export fn u16tosb(u: u16, b: base) const str = u64tosb(u, b); + +// Converts a u8 to a string in the given base. The return value is statically +// allocated and will be overwritten on subsequent calls; see [strings::dup] to +// duplicate the result. +export fn u8tosb(u: u8, b: base) const str = u64tosb(u, b); + +// Converts a uint to a string in the given base. The return value is +// statically allocated and will be overwritten on subsequent calls; see +// [strings::dup] to duplicate the result. +export fn utosb(u: uint, b: base) const str = u64tosb(u, b); + +// Converts a size to a string in the given base. The return value is +// statically allocated and will be overwritten on subsequent calls; see +// [strings::dup] to duplicate the result. +export fn ztosb(u: size, b: base) const str = u64tosb(u, b); + +// Converts a size to a string in the given base. The return value is +// statically allocated and will be overwritten on subsequent calls; see +// [strings::dup] to duplicate the result. +export fn uptrtosb(uptr: uintptr, b: base) const str = u64tosb(uptr: u64, b); + +// Converts a u64 to a string in base 10. The return value is statically +// allocated and will be overwritten on subsequent calls; see [strings::dup] to +// duplicate the result. +export fn u64tos(u: u64) const str = u64tosb(u, base::DEC); + +// Converts a u32 to a string in base 10. The return value is statically +// allocated and will be overwritten on subsequent calls; see [strings::dup] to +// duplicate the result. +export fn u32tos(u: u32) const str = u64tos(u); + +// Converts a u16 to a string in base 10. The return value is statically +// allocated and will be overwritten on subsequent calls; see [strings::dup] to +// duplicate the result. +export fn u16tos(u: u16) const str = u64tos(u); + +// Converts a u8 to a string in base 10. The return value is statically +// allocated and will be overwritten on subsequent calls; see [strings::dup] to +// duplicate the result. +export fn u8tos(u: u8) const str = u64tos(u); + +// Converts a uint to a string in base 10. The return value is statically +// allocated and will be overwritten on subsequent calls; see [strings::dup] to +// duplicate the result. +export fn utos(u: uint) const str = u64tos(u); + +// Converts a size to a string in base 10. The return value is statically +// allocated and will be overwritten on subsequent calls; see [strings::dup] to +// duplicate the result, or [strconv::itosb] to pass your own string buffer. +export fn ztos(z: size) const str = u64tos(z); + +// Converts a uintptr to a string in base 10. The return value is statically +// allocated and will be overwritten on subsequent calls; see [strings::dup] to +// duplicate the result. +export fn uptrtos(uptr: uintptr) const str = u64tos(uptr: u64); + +@test fn utosb() void = { + assert("11010" == u64tosb(0b11010, base::BIN)); + assert("1234567" == u64tosb(0o1234567, base::OCT)); + assert("123456789" == u64tosb(123456789, base::DEC)); + assert("123456789ABCDEF" == u64tosb(0x123456789ABCDEF, base::HEX)); + assert("123456789ABCDEF" == u64tosb(0x123456789ABCDEF, base::HEX_UPPER)); + assert("123456789abcdef" == u64tosb(0x123456789ABCDEF, base::HEX_LOWER)); + assert("1111111111111111111111111111111111111111111111111111111111111111" + == u64tosb(types::U64_MAX, base::BIN)); +}; + +@test fn utos() void = { + const samples: [_]u64 = [ + 1234, + 4321, + types::U64_MIN, + types::U64_MAX, + ]; + const expected = [ + "1234", + "4321", + "0", + "18446744073709551615", + ]; + + for (let i = 0z; i < len(samples); i += 1) { + const s = u64tos(samples[i]); + assert(s == expected[i]); + }; +}; diff --git a/example/uuid.ha b/example/uuid.ha new file mode 100644 index 000000000..0a64798e2 --- /dev/null +++ b/example/uuid.ha @@ -0,0 +1,92 @@ +// The uuid module implements RFC 4122-compatible Univerally Unique IDentifiers. +// +// This module only generates UUID4, aka "truly random" UUIDs, due to privacy +// concerns. +use bytes; +use crypto::random; +use endian; +use fmt; +use io; +use strio; +// TODO: decode, decodestr + +// A UUID. +export type uuid = [16]u8; + +export def UUID_LEN: size = 16; +export def UUID_STRLEN: size = 36; +export def UUID_URILEN: size = 45; + +// The "nil" UUID, with all bits set to zero. +export const nil: uuid = [0...]; + +// Octet offsets of various fields as defined by the RFC. +def TIME_LOW: size = 0; +def TIME_MID: size = 4; +def TIME_HI_AND_VERSION: size = 6; +def CLOCK_SEQ_HI_AND_RESERVED: size = 8; +def CLOCK_SEQ_LOW: size = 9; +def NODE: size = 10; + +// Generates a new version 4 UUID. +export fn generate() uuid = { + let id: uuid = [0...]; + random::buffer(id[..]); + let buf = id[CLOCK_SEQ_HI_AND_RESERVED..CLOCK_SEQ_HI_AND_RESERVED + 2]; + let clock = (endian::begetu16(buf) & 0x3FFF) | 0x8000; + endian::beputu16(buf, clock); + let buf = id[TIME_HI_AND_VERSION..TIME_HI_AND_VERSION + 2]; + let version = (endian::begetu16(buf) & 0x0FFF) | 0x4000; + endian::beputu16(buf, version); + return id; +}; + +// Returns true if two UUIDs are equal. +export fn compare(a: uuid, b: uuid) bool = bytes::equal(a, b); + +// Encodes a UUID as a string and writes it to a stream. +export fn encode(out: *io::stream, in: uuid) (size | io::error) = { + let z = 0z; + for (let i = TIME_LOW; i < TIME_LOW + 4; i += 1) { + z += fmt::fprintf(out, "{:02x}", in[i])?; + }; + z += fmt::fprintf(out, "-")?; + for (let i = TIME_MID; i < TIME_MID + 2; i += 1) { + z += fmt::fprintf(out, "{:02x}", in[i])?; + }; + z += fmt::fprintf(out, "-")?; + for (let i = TIME_HI_AND_VERSION; i < TIME_HI_AND_VERSION + 2; i += 1) { + z += fmt::fprintf(out, "{:02x}", in[i])?; + }; + z += fmt::fprintf(out, "-{:02x}{:02x}-", + in[CLOCK_SEQ_HI_AND_RESERVED], in[CLOCK_SEQ_LOW])?; + for (let i = NODE; i < NODE + 6; i += 1) { + z += fmt::fprintf(out, "{:02x}", in[i])?; + }; + return z; +}; + +// Encodes a UUID as a URI and writes it to a stream. +export fn uri(out: *io::stream, in: uuid) (size | io::error) = { + return fmt::fprintf(out, "urn:uuid:")? + encode(out, in)?; +}; + +// Encodes a UUID as a string. The return value is statically allocated, the +// caller must use [strings::dup] to extend its lifetime. +export fn encodestr(in: uuid) str = { + static let buf: [UUID_STRLEN]u8 = [0...]; + let sink = strio::fixed(buf); + defer io::close(sink); + encode(sink, in) as size; + return strio::string(sink); +}; + +// Encodes a UUID as a string. The return value is statically allocated, the +// caller must use [strings::dup] to extend its lifetime. +export fn encodeuri(in: uuid) str = { + static let buf: [UUID_URILEN]u8 = [0...]; + let sink = strio::fixed(buf); + defer io::close(sink); + uri(sink, in) as size; + return strio::string(sink); +}; diff --git a/example/vdso.ha b/example/vdso.ha new file mode 100644 index 000000000..371389194 --- /dev/null +++ b/example/vdso.ha @@ -0,0 +1,166 @@ +use strings; +use format::elf; +use linux; + +let ehdr: nullable *elf::header64 = null; + +fn sys_infoehdr() nullable *elf::header64 = { + static let ehdr_checked = false; + if (ehdr_checked) { + return ehdr; + }; + ehdr_checked = true; + + for (let i = 0; linux::auxv[i].a_type != 0; i += 1) { + if (linux::auxv[i].a_type != elf::at::SYSINFO_EHDR: u64) + continue; + ehdr = linux::auxv[i].a_val: uintptr: *elf::header64; + return ehdr; + }; + return null; +}; + +type vdso_ctx = struct { + segbase: uintptr, + stringtab: *char, + symtab: *[*]elf::sym64, + hashhdr: *elf::hashhdr, + versym: nullable *[*]u16, + verdef: nullable *elf::verdef64, +}; + +let ctx: nullable *vdso_ctx = null; + +fn get_vdso_ctx() nullable *vdso_ctx = { + static let vdso_checked = false; + if (vdso_checked) { + return ctx; + }; + vdso_checked = true; + + const eh = match (sys_infoehdr()) { + null => return null, + x: *elf::header64 => x, + }; + + const ehui = eh: uintptr; + let phui = ehui + eh.e_phoff: uintptr; + let dynvec: nullable *[*]elf::dyn64 = null; + let baseseg: nullable *void = null; + + for (let i: u16 = 0; i < eh.e_phnum; i += 1) { + const ph = phui: *elf::phdr64; + switch (ph.p_type) { + elf::pt::LOAD => + baseseg = ehui + + ph.p_offset: uintptr - + ph.p_vaddr: uintptr, + elf::pt::DYNAMIC => + dynvec = ehui + ph.p_offset: uintptr, + }; + phui += eh.e_phentsize: uintptr; + }; + + if (dynvec == null || baseseg == null) { + return null; + }; + const dynv = dynvec: *[*]elf::dyn64; + + let segbase = baseseg: uintptr; + let stringtab: nullable *char = null; + let symtab: nullable *[*]elf::sym64 = null; + let hashhdr: nullable *elf::hashhdr = null; + let versym: nullable *[*]u16 = null; + let verdef: nullable *elf::verdef64 = null; + + for (let i = 0; dynv[i].d_tag != elf::dt::NULL; i += 1) { + const tabptr = (segbase + dynv[i].d_val: uintptr): *void; + switch (dynv[i].d_tag) { + elf::dt::STRTAB => stringtab = tabptr: *char, + elf::dt::SYMTAB => symtab = tabptr: *[*]elf::sym64, + elf::dt::HASH => hashhdr = tabptr: *elf::hashhdr, + elf::dt::VERSYM => versym = tabptr: *[*]u16, + elf::dt::VERDEF => verdef = tabptr: *elf::verdef64, + * => continue, + }; + }; + + if (stringtab == null || symtab == null || hashhdr == null) { + return null; + }; + + if (verdef == null) { + versym = null; + }; + + // TODO: use a static variable here somehow(?) + const vctx = alloc(vdso_ctx { + segbase = segbase, + stringtab = stringtab: *char, + symtab = symtab: *[*]elf::sym64, + hashhdr = hashhdr: *elf::hashhdr, + verdef = verdef, + versym = versym, + }); + ctx = vctx; + + return ctx; +}; + +fn vdso_checkver(ctx: *vdso_ctx, version: str, num: u32) bool = { + let prev = null: *elf::verdef64; + let cur = match (ctx.verdef) { + null => return true, + vd: *elf::verdef64 => vd, + }; + const versym = match (ctx.versym) { + null => return true, + vs: *[*]u16 => vs[num] & 0x7fff + }; + for (cur != prev) { + if (cur.vd_flags & elf::ver_flg::BASE: u16 == 0 && + cur.vd_ndx & 0x7fff == versym) { + const aux = (cur: uintptr + + cur.vd_aux: uintptr): *elf::verdaux64; + const name = ctx.stringtab + + aux.vda_name: uintptr: *char; + return version == strings::fromc(name); + }; + prev = cur; + cur += cur.vd_next: uintptr; + }; + return false; +}; + +export fn getsym(symname: str, symver: str) nullable *void = { + const ctx = match (get_vdso_ctx()) { + null => return null, + x: *vdso_ctx => x, + }; + + const sym_types = (1 << elf::stt::NOTYPE | + 1 << elf::stt::OBJECT | + 1 << elf::stt::FUNC | + 1 << elf::stt::COMMON): size; + + const sym_binds = (1 << elf::stb::GLOBAL | + 1 << elf::stb::WEAK): size; + + for (let i = 0u32; i < ctx.hashhdr.nchain; i += 1) { + const sym = ctx.symtab[i]; + const symtype = 1 << (sym.st_info & 0xf): size; + const symbind = 1 << (sym.st_info >> 4): size; + if (symtype & sym_types == 0 || symbind & sym_binds == 0 || + sym.st_shndx == 0) { + continue; + }; + const name = ctx.stringtab + sym.st_name: uintptr: *char; + const s: str = strings::fromc(name); + if (s != symname) + continue; + if (!vdso_checkver(ctx, symver, i)) + continue; + return (ctx.segbase + sym.st_value: uintptr): *void; + }; + return null; +}; diff --git a/example/void.ha b/example/void.ha new file mode 100644 index 000000000..13841ba69 --- /dev/null +++ b/example/void.ha @@ -0,0 +1,56 @@ +use rt; +use types; + +// Appends an item, or items, to a slice, returning a new slice. +export fn appendto(sl: *[]void, itemsz: size, items: const *void...) void = { + if (len(items) == 0) { + return; + }; + let sl = sl: *types::slice; + let end = sl.length; + sl.length += len(items); + rt::ensure(sl, itemsz); + let data = sl.data: *[*]u8; + for (let i = 0z; i < len(items); i += 1) { + rt::memcpy(&data[(end + i) * itemsz], items[i], itemsz); + }; +}; + +@test fn appendto() void = { + let input: []int = []; + let num = 1337; + appendto(&input: *[]void, size(int), &num, &num); + assert(len(input) == 2 && input[0] == 1337 && input[1] == 1337); + free(input); +}; + +// Swaps two elements of a slice. +export fn swap(sl: []void, itemsz: size, a: size, b: size) void = { + assert(a < len(sl) && b < len(sl)); + let sl = sl: *[*]u8; + let a = &sl[a * itemsz]: *[*]u8, b = &sl[b * itemsz]: *[*]u8; + for (let i = 0z; i < itemsz; i += 1) { + let c = a[i]; + a[i] = b[i]; + b[i] = c; + }; +}; + +@test fn swap() void = { + let x: []int = [1, 2, 3]; + swap(x: []void, size(int), 0, 2); + assert(x[0] == 3 && x[2] == 1); +}; + +// Returns a pointer to the nth item of a slice. +export fn index(sl: []void, itemsz: size, n: size) *void = { + assert(n < len(sl)); + let ba = sl: *[*]u8; + return &ba[n * itemsz]; +}; + +@test fn index() void = { + let x: []int = [1, 2, 3]; + let ptr = index(x, size(int), 1): *int; + assert(*ptr == 2); +}; diff --git a/example/xdg.ha b/example/xdg.ha new file mode 100644 index 000000000..29e421eff --- /dev/null +++ b/example/xdg.ha @@ -0,0 +1,58 @@ +use fs; +use os; +use path; +use io; + +fn lookup(prog: str, var: str, default: str) str = { + match (os::getenv(var)) { + s: str => { + let path = path::join(s, prog); + match (os::stat(path)) { + err: fs::error => { + os::mkdirs(path) as void; + return path; + }, + st: fs::filestat => { + if (fs::is_dir(st.mode)) { + return path; + }; + }, + }; + }, + void => void, + }; + + let home = match (os::getenv("HOME")) { + s: str => s, + void => abort("$HOME unset"), // TODO: Try reading /etc/passwd + }; + + let path = path::join(home, default, prog); + os::mkdirs(path) as void; + return path; +}; + +// Returns a directory suitable for storing config files. If 'prog' is given, a +// unique path for this program to store data will be returned. +export fn config(prog: str) str = lookup(prog, "XDG_CONFIG_HOME", ".config"); + +// Returns an [fs::fs] for storing config files. If 'prog' is given, a unique +// path for this program to store data will be returned. +export fn configfs(prog: str) *fs::fs = os::diropen(config(prog)) as *fs::fs; + +// Returns a directory suitable for cache files. If 'prog' is given, a unique +// path for this program to store data will be returned. +export fn cache(prog: str) str = lookup(prog, "XDG_CACHE_HOME", ".cache"); + +// Returns an [fs::fs] for cache files. If 'prog' is given, a unique path for +// this program to store data will be returned. +export fn cachefs(prog: str) *fs::fs = os::diropen(cache(prog)) as *fs::fs; + +// Returns a directory suitable for persistent data files. If 'prog' is given, a +// unique path for this program to store data will be returned. +export fn data(prog: str) str = + lookup(prog, "XDG_DATA_HOME", path::join(".local", "share")); + +// Returns an [fs::fs] for persistent data files. If 'prog' is given, a unique +// path for this program to store data will be returned. +export fn datafs(prog: str) *fs::fs = os::diropen(data(prog)) as *fs::fs; diff --git a/example/ztos.ha b/example/ztos.ha new file mode 100644 index 000000000..4d0ea9f25 --- /dev/null +++ b/example/ztos.ha @@ -0,0 +1,38 @@ +fn bytes_reverse(b: []u8) void = { + if (len(b) == 0) { + return; + }; + for (let s = 0z, e = len(b) - 1; s < e) { + let x = b[s]; + b[s] = b[e]; + b[e] = x; + s += 1; + e -= 1; + }; +}; + +fn ztos(u: size) const str = { + static let buf: [21]u8 = [0...]; // 20 digits plus NUL + buf = [0...]; + + let s = struct { + b: *[*]u8 = &buf, + l: size = 0, + c: size = 0, + }; + + if (u == 0) { + s.b[s.l] = '0': u32: u8; + s.l += 1; + }; + + for (u > 0) { + s.b[s.l] = '0': u32: u8 + (u % 10): u8; + s.l += 1; + u /= 10; + }; + + bytes_reverse(s.b[..s.l]); + s.b[s.l] = 0; + return *(&s: *str); +}; diff --git a/grammar.js b/grammar.js new file mode 100644 index 000000000..6469afd17 --- /dev/null +++ b/grammar.js @@ -0,0 +1,721 @@ +const PREC = { + ASSIGNMENT: 0, + LOGICAL_XOR: 1, + LOGICAL_OR: 2, + LOGICAL_AND: 3, + BITWISE_OR: 4, + BITWISE_XOR: 5, + BITWISE_AND: 6, + EQUALITY: 7, + COMPARISON: 8, + SHIFT: 9, + ADD: 10, + MULTIPLY: 11, + CAST: 12, + UNARY: 13, +} + +module.exports = grammar ({ + + name: 'hare', + + extras: $ => [ + /\s|\\\r?\n/, + $.comment, + ], + + conflicts: $ => [ + [$.integer_constant, $.floating_constant], + [$.identifier], // enum + [$.bindings], // parenthesized expressions in array/slice specifiers + [$.for_predicate, $.expression], // second/third production rules in for predicate. + [$.if_expression] + ], + + rules: { + + // The Translation Unit. + unit: $ => seq( + optional($.imports), + optional($.declarations), + ), + + // Imports. + imports: $ => repeat1($.use_statement), + + use_statement: $ => seq( + 'use', + choice( + seq($.identifier, ';'), + seq($.name, '=', $.identifier, ';'), + seq($.identifier, '::', '{', $.name_list, '}', ';') + ), + ), + + name_list: $ => choice( + seq($.name, optional(',')), + seq($.name,',', $.name_list) + ), + + // Declarations. + declarations: $ => repeat1(seq(optional('export'), $.declaration, ';')), + + declaration: $ => choice( + $.global_declaration, + $.constant_declaration, + $.type_declaration, + $.function_declaration + ), + + global_declaration: $ => choice( + seq('let', $.global_bindings), + seq('const', $.global_bindings) + ), + + global_bindings: $ => + seq($.global_binding, optional(seq(',', $.global_bindings))), + + global_binding: $ => seq( + optional($.decl_attr), + $.identifier, ':', $.type, optional(seq('=', $.expression)) + ), + + decl_attr: $ => seq( + '@symbol', '(', $.string_constant, ')' + ), + + constant_declaration: $ => seq('def', $.constant_bindings), + + constant_bindings: $ => + seq($.constant_binding, optional(seq(',', $.constant_bindings))), + + constant_binding: $ => seq( + $.identifier, ':', $.type, '=', $.expression + ), + + + type_declaration: $ => seq('type', $.type_bindings), + + type_bindings: $ => choice( + seq($.identifier, '=', $.type, optional(',')), + seq($.identifier, '=', $.type, ',', $.type_bindings) + ), + + function_declaration: $ => + seq(optional($.fndec_attrs), 'fn', $.identifier, $.prototype, optional(seq('=', $.expression))), + + fndec_attrs: $ => repeat1($.fndec_attr), + + fndec_attr: $ => choice( + '@fini', + '@init', + '@test', + $.fntype_attr, + $.decl_attr + ), + + fntype_attr: $ => choice( + '@noreturn', + ), + + // Types. + type: $ => seq($._inner_type, optional('!')), + + _inner_type: $ => seq( optional('const'), $.storage_class), + + storage_class: $ => choice( + $.scalar_type, + $.struct_type, + $.union_type, + $.tuple_type, + $.tagged_union_type, + $.slice_array_type, + $.function_type, + $.alias_type, + $.unwrapped_alias, + ), + + scalar_type: $ => choice( + $.integer_type, + $.floating_type, + $.enum_type, + $.pointer_type, + 'rune', + 'bool', + 'void' + ), + + integer_type: $ => choice( + 'i8', + 'i16', + 'i32', + 'i64', + 'u8', + 'u16', + 'u32', + 'u64', + 'int', + 'uint', + 'size', + 'uintptr', + 'char', + ), + + floating_type: $ => choice( + 'f32', + 'f64', + ), + + enum_type: $ => choice( + seq('enum', '{', $.enum_values, '}'), + seq('enum', $.integer_type, '{', $.enum_values, '}'), + ), + + enum_values: $ => choice( + seq($.enum_value, optional(',')), + seq($.enum_value, ',', $.enum_values), + ), + + enum_value: $ => choice( + $.name, + seq($.name, '=', $.expression) + ), + + pointer_type: $ => choice( + seq('*', $._inner_type), + seq('nullable', '*', $._inner_type) + ), + + struct_type: $ =>seq('struct', '{', $.struct_union_fields, '}'), + union_type: $ =>seq('union', '{', $.struct_union_fields, '}'), + + struct_union_fields: $ => choice( + seq($.struct_union_field, optional(',')), + seq($.struct_union_field, ',', $.struct_union_fields) + ), + + struct_union_field: $ => seq( + optional($.offset_specifier), + choice( + seq($.name, ':', $.type), + $.struct_type, + $.union_type, + $.identifier + ) + ), + + offset_specifier: $ => seq('@offset', '(', $.expression, ')'), + + tuple_type: $ => seq('(', $.tuple_types, ')'), + + tuple_types: $ => choice( + seq($.type, ',', $.type, optional(',')), + seq($.type, ',', $.tuple_types), + ), + + tagged_union_type: $ => seq('(', $.tagged_types, ')'), + + tagged_types: $ => seq($.type, '|', $.type, repeat(seq('|', $.type))), + + slice_array_type: $ => choice( + seq('[',']', $._inner_type), + seq('[', $.logical_or_expression, ']', $._inner_type), + seq('[', '*', ']', $._inner_type), + seq('[', '_', ']', $._inner_type) + ), + + function_type: $ => seq(optional($.fntype_attr), 'fn', $.prototype), + + prototype: $ => seq('(', optional($.parameter_list), ')', $._inner_type), + + parameter_list: $ => choice( + seq($.parameters, optional(',')), + seq($.parameters, '...', optional(',')), + seq($.parameters, ',', '...', optional(',')), + ), + + parameters: $ => choice( + $.parameter, + seq($.parameters, ',', $.parameter) + ), + + parameter: $ => choice( + seq($.name, ':', $.type), + seq('_', ':', $.type) + ), + + + alias_type: $ => $.identifier, + + unwrapped_alias: $ => seq('...', $.identifier), + + + // Expressions. + constant: $ => choice( + $.integer_constant, + $.floating_constant, + $.rune_constant, + $.string_constant, + 'true', + 'false', + 'null', + 'void' + ), + + integer_constant: $ => choice( + seq('0x', $.hex_digits, optional($.integer_suffix)), + seq('0o', $.octal_digits, optional($.integer_suffix)), + seq('0b', $.binary_digits, optional($.integer_suffix)), + seq($.decimal_digits, optional($.exponent), optional($.integer_suffix)), + ), + + hex_digits: $ => repeat1($.hex_digit), + + hex_digit: $ => choice( + '0', + '1', + '2', + '3', + '4', + '5', + '6', + '7', + '8', + '9', + 'A', + 'B', + 'C', + 'D', + 'E', + 'F', + 'a', + 'b', + 'c', + 'd', + 'e', + 'f' + ), + + octal_digits: $ => repeat1($.octal_digit), + octal_digit: $ => choice( + '0', + '1', + '2', + '3', + '4', + '5', + '6', + '7', + ), + + binary_digits: $ => repeat1($.binary_digit), + binary_digit: $ => choice('0', '1'), + + decimal_digits: $ => repeat1($.decimal_digit), + decimal_digit: $ => choice('0','1', '2', '3', '4', '5', '6', '7', '8', '9'), + + integer_suffix: $ => choice( + 'i', + 'u', + 'z', + 'i8', + 'i16', + 'i32', + 'i64', + 'u8', + 'u16', + 'u32', + 'u64', + ), + + floating_constant: $ => choice( + seq($.decimal_digits, '.', $.decimal_digits, optional($.exponent), optional($.floating_suffix)), + seq($.decimal_digits, optional($.exponent), $.floating_suffix), + ), + + exponent: $ => seq('e', $.decimal_digits), + + floating_suffix: $ => choice( + 'f32', + 'f64' + ), + + rune_constant: $ => seq("'", $.rune, "'"), + + rune: $ => choice( + token.immediate(/[^\']/), + $.escape_sequence + ), + + escape_sequence: $ => choice( + $.named_escape, + seq( + "\\", + token.immediate( + choice( + /x[0-9a-fA-F]{2}/, + /u[0-9a-fA-F]{4}/, + /U[0-9a-fA-F]{8}/ + ) + ) + ) + ), + + named_escape: $ => seq( + '\\', + token.immediate( + choice( + '0', + 'n', + 'r', + 't', + 'b', + 'f', + 'a', + 'v', + '\\', + '\'', + '\"', + )) + ), + + string_constant: $ => repeat1(seq('"', $.string_chars, '"')), + + string_chars: $ => repeat1($.string_char), + string_char: $ => choice( + token.immediate(/[^\n"]/), + $.escape_sequence + ), + + array_literal: $ => seq('[', optional($.array_members), ']'), + array_members: $ => choice( + seq($.expression, optional(',')), + seq($.expression, '...', optional(',')), + seq($.expression, ',', $.array_members), + ), + + enum_literal: $ => seq($.identifier, '::', $.name), + + struct_literal: $ => choice( + seq('struct', '{', seq($.field_values, optional(',')), '}'), + seq($.identifier, '{', $.struct_initializer, '}'), + ), + + struct_initializer: $ => choice( + '...', + seq($.field_values, optional(seq(',', optional('...')))), + ), + + field_values: $ => choice( + $.field_value, + seq($.field_values, ',', $.field_value), + ), + + field_value: $ => choice( + seq($.name, '=', $.expression), + seq($.name, ':', $.type, '=', $.expression), + $.struct_literal + ), + + plain_expression: $ => choice( + $.identifier, + $.constant, + $.array_literal, + $.enum_literal, + $.struct_literal, + ), + + nested_expression: $ => choice( + $.plain_expression, + seq('(', $.expression, ')'), + seq('(', $.tuple_items, ')'), + ), + + tuple_items: $ => choice( + seq($.expression, ',', $.expression, optional(',')), + seq($.expression, ',', $.tuple_items), + ), + + allocation_expression: $ => choice( + seq('alloc','(', $.expression, ')'), + seq('alloc','(', $.expression, ',', $.expression, ')'), + seq('append', '(', $.object_selector, ',', $.append_values, ')'), + seq('append','(', '*', $.unary_expression, ',', $.append_values,')'), + seq('free', '(', $.expression, ')'), + seq('delete', '(', $.slicing_expression, ')'), + seq('delete', '(', $.indexing_expression, ')') + ), + + append_values: $ => choice( + seq($.expression, optional(',')), + seq('...', $.expression, optional(',')), + seq($.expression, ',', $.append_values) + ), + + + assertion_expression: $ => choice( + seq('assert', '(', $.expression, ')'), + seq('assert', '(', $.expression, ',', $.string_constant, ')'), + seq('static', 'assert', '(', $.expression, ')'), + seq('static', 'assert', '(', $.expression ,',', $.string_constant, ')'), + seq('abort', '(', optional($.string_constant), ')'), + ), + + call_expression: $ => seq($.postfix_expression, '(', optional($.argument_list), ')'), + + argument_list: $ => choice( + seq($.expression, optional(',')), + seq($.expression, '...', optional(',')), + seq($.expression, ',', $.argument_list), + ), + + measurement_expression: $ => choice( + $.size_expression, + $.length_expression, + $.offset_expression + ), + + size_expression: $ => seq('size', '(', $.type, ')'), + + length_expression: $ => seq('len', '(', $.expression, ')'), + + offset_expression: $ => seq('offset', '(', $.field_access_expression, ')'), + + field_access_expression: $ => choice( + seq($.postfix_expression, '.', $.name), + seq($.postfix_expression, '.', $.integer_constant) + ), + + indexing_expression: $ => seq($.postfix_expression, '[', $.expression, ']'), + + slicing_expression: $ => seq( + $.postfix_expression, '[', optional($.expression), + '..', optional($.expression), ']' + ), + + error_propagation: $ => seq($.postfix_expression, '?'), + + postfix_expression: $ => choice( + $.nested_expression, + $.allocation_expression, + $.assertion_expression, + $.call_expression, + $.field_access_expression, + $.indexing_expression, + $.measurement_expression, + $.slicing_expression, + $.error_propagation, + ), + + object_selector: $ => choice( + $.identifier, + $.indexing_expression, + $.field_access_expression + ), + + unary_expression: $ => choice( + $.postfix_expression, + prec.right(PREC.UNARY, + seq( + field('operator', choice('+', '-', '~', '!', '*')), + field('argument', $.unary_expression) + ) + ), + prec.right(PREC.UNARY, + seq( + field('address', '&'), + field('argument', $.object_selector) + ) + ) + ), + + cast_expression: $ => choice( + $.unary_expression, + prec.left(PREC.CAST, field('type_cast', seq( $.cast_expression, ':', $.type))), + prec.left(PREC.CAST, field('as_cast', seq( $.cast_expression, 'as', $.type))), + prec.left(PREC.CAST, field('is_cast', seq( $.cast_expression, 'is', $.type))) + ), + + multiplicative_expression: $ => choice( + $.cast_expression, + prec.left(PREC.MULTIPLY, seq($.multiplicative_expression, '*', $.cast_expression)), + prec.left(PREC.MULTIPLY, seq($.multiplicative_expression, '/', $.cast_expression)), + prec.left(PREC.MULTIPLY, seq($.multiplicative_expression, '%', $.cast_expression)) + ), + + additive_expression: $ => choice( + $.multiplicative_expression, + prec.left(PREC.ADD, seq($.additive_expression, '+', $.multiplicative_expression)), + prec.left(PREC.ADD, seq($.additive_expression, '-', $.multiplicative_expression)) + ), + + shift_expression: $ => choice( + $.additive_expression, + prec.left(PREC.SHIFT, seq($.multiplicative_expression, '<<', $.cast_expression)), + prec.left(PREC.SHIFT, seq($.multiplicative_expression, '>>', $.cast_expression)) + ), + + and_expression: $ => choice( + $.shift_expression, + prec.left(PREC.BITWISE_AND, seq($.and_expression, '&', $.shift_expression)), + ), + + exclusive_or_expression: $ => choice( + $.and_expression, + prec.left(PREC.BITWISE_XOR, seq($.exclusive_or_expression, '^', $.and_expression)), + ), + inclusive_or_expression: $ => choice( + $.exclusive_or_expression, + prec.left(PREC.BITWISE_OR, seq($.inclusive_or_expression, '|', $.exclusive_or_expression)), + ), + + comparison_expression: $ => choice( + $.inclusive_or_expression, + prec.left(PREC.COMPARISON, seq($.comparison_expression, '<', $.inclusive_or_expression)), + prec.left(PREC.COMPARISON, seq($.comparison_expression, '>', $.inclusive_or_expression)), + prec.left(PREC.COMPARISON, seq($.comparison_expression, '<=', $.inclusive_or_expression)), + prec.left(PREC.COMPARISON, seq($.comparison_expression, '>=', $.inclusive_or_expression)) + ), + + equality_expression: $ => choice( + $.comparison_expression, + prec.left(PREC.EQUALITY, seq($.equality_expression, '==', $.comparison_expression)), + prec.left(PREC.EQUALITY, seq($.equality_expression, '!=', $.comparison_expression)), + ), + + logical_and_expression: $ => choice( + $.equality_expression, + prec.left(PREC.LOGICAL_AND, seq($.logical_and_expression, '&&', $.equality_expression)), + ), + + logical_xor_expression: $ => choice( + $.logical_and_expression, + prec.left(PREC.LOGICAL_XOR, seq($.logical_xor_expression, '^^', $.logical_and_expression)), + ), + + logical_or_expression: $ => choice( + $.logical_xor_expression, + prec.left(PREC.LOGICAL_OR, seq($.logical_or_expression, '||', $.logical_xor_expression)), + ), + + if_expression: $ => choice( + seq('if', $.conditional_branch), + seq('if', $.conditional_branch, 'else', $.expression) + ), + + conditional_branch: $ => seq('(' , $.expression, ')', $.expression), + + for_loop: $ => seq( + optional($.label), + 'for', '(', $.for_predicate, ')', $.expression + ), + + for_predicate: $ => choice( + $.expression, + seq(field('binding', $.binding_list), ';', $.expression), + seq($.expression, ';', field('afterthought', $.expression)), + seq($.binding_list, ';', $.expression, ';', $.expression), + ), + + label: $ => seq(':', $.name), + + switch_expression: $ => seq( + 'switch', '(', $.expression, ')', '{', $.switch_cases, '}' + ), + + switch_cases: $ => choice( + seq($.switch_case, optional(',')), + seq($.switch_case, ',', $.switch_cases) + ), + + switch_case: $ => choice( + seq($.case_options, '=>', $.expression), + seq('*', '=>', $.expression), + ), + + case_options: $ => choice( + seq($.expression, optional(',')), + seq($.expression, ',', $.case_options) + ), + + match_expression: $ => + seq('match', '(', $.expression, ')', '{', $.match_cases, '}'), + + match_cases: $ => choice( + seq($.match_case, optional(',')), + seq($.match_case, ',', $.match_cases) + ), + + match_case: $ => choice( + seq($.name, ':', $.type, '=>', $.expression), + seq($.type, '=>', $.expression), + seq('*', '=>', $.expression) + ), + + assignment: $ => prec.left(PREC.ASSIGNMENT, + choice( + seq($.object_selector, $.assignment_op, $.expression), + seq('*', $.unary_expression, $.assignment_op, $.expression), + seq($.slicing_expression, '=', $.expression) + )), + + assignment_op: $ => choice( + '=', '+=', '-=', '*=', '/=', '%=', '<<=', '>>=', '&=', '|=', '^=' + ), + + binding_list: $ => choice( + seq(optional('static'), 'let', $.bindings), + seq(optional('static'), 'const', $.bindings), + ), + + bindings: $ => seq($.binding, optional(seq(',', $.bindings))), + + binding: $ => choice( + seq($.name, '=', $.expression), + seq($.name, ':', $.type, '=', $.expression), + seq($.binding_names, '=', $.expression), + seq($.binding_names, ':', $.type, '=', $.expression), + ), + + binding_names: $ => choice( + seq($.name, ',', $.name), + seq($.name, ',', $.binding_names) + ), + + deferred_expression: $ => seq('defer', $.expression), + + expression_list: $ => choice( + seq($.expression, ';'), + seq($.expression, ';', $.expression_list) + ), + + control_statement: $ => choice( + seq('break', optional($.label)), + seq('continue', optional($.label)), + seq('return', optional($.expression)) + ), + + expression: $ => choice( + $.assignment, + $.binding_list, + $.deferred_expression, + $.logical_or_expression, + $.if_expression, + $.for_loop, + $.switch_expression, + $.match_expression, + $.control_statement, + $.compound_expression, + ), + + compound_expression: $ => seq('{', $.expression_list, '}'), + + identifier: $ => + seq($.name, optional(seq('::', $.identifier))), + + name: $ => /[a-zA-Z_]\w*/, + + comment: $ => token(seq('//', /(\\(.|\r?\n)|[^\\\n])*/)), + + } +}) diff --git a/package.json b/package.json new file mode 100644 index 000000000..da683a7cf --- /dev/null +++ b/package.json @@ -0,0 +1,19 @@ +{ + "name": "tree-sitter-hare", + "version": "0.0.1", + "description": "hare grammar for tree-sitter", + "main": "bindings/node", + "keywords": [ + "parsing", + "incremental" + ], + "dependencies": { + "nan": "^2.12.1" + }, + "devDependencies": { + "tree-sitter-cli": "^0.17.3" + }, + "scripts": { + "test": "tree-sitter test" + } +} diff --git a/src/grammar.json b/src/grammar.json new file mode 100644 index 000000000..8a4055a3e --- /dev/null +++ b/src/grammar.json @@ -0,0 +1,5071 @@ +{ + "name": "hare", + "rules": { + "unit": { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "imports" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "declarations" + }, + { + "type": "BLANK" + } + ] + } + ] + }, + "imports": { + "type": "REPEAT1", + "content": { + "type": "SYMBOL", + "name": "use_statement" + } + }, + "use_statement": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "use" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "STRING", + "value": ";" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "name" + }, + { + "type": "STRING", + "value": "=" + }, + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "STRING", + "value": ";" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "STRING", + "value": "::" + }, + { + "type": "STRING", + "value": "{" + }, + { + "type": "SYMBOL", + "name": "name_list" + }, + { + "type": "STRING", + "value": "}" + }, + { + "type": "STRING", + "value": ";" + } + ] + } + ] + } + ] + }, + "name_list": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "name" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "BLANK" + } + ] + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "name" + }, + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "name_list" + } + ] + } + ] + }, + "declarations": { + "type": "REPEAT1", + "content": { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "export" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "SYMBOL", + "name": "declaration" + }, + { + "type": "STRING", + "value": ";" + } + ] + } + }, + "declaration": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "global_declaration" + }, + { + "type": "SYMBOL", + "name": "constant_declaration" + }, + { + "type": "SYMBOL", + "name": "type_declaration" + }, + { + "type": "SYMBOL", + "name": "function_declaration" + } + ] + }, + "global_declaration": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "let" + }, + { + "type": "SYMBOL", + "name": "global_bindings" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "const" + }, + { + "type": "SYMBOL", + "name": "global_bindings" + } + ] + } + ] + }, + "global_bindings": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "global_binding" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "global_bindings" + } + ] + }, + { + "type": "BLANK" + } + ] + } + ] + }, + "global_binding": { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "decl_attr" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "STRING", + "value": ":" + }, + { + "type": "SYMBOL", + "name": "type" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "=" + }, + { + "type": "SYMBOL", + "name": "expression" + } + ] + }, + { + "type": "BLANK" + } + ] + } + ] + }, + "decl_attr": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "@symbol" + }, + { + "type": "STRING", + "value": "(" + }, + { + "type": "SYMBOL", + "name": "string_constant" + }, + { + "type": "STRING", + "value": ")" + } + ] + }, + "constant_declaration": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "def" + }, + { + "type": "SYMBOL", + "name": "constant_bindings" + } + ] + }, + "constant_bindings": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "constant_binding" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "constant_bindings" + } + ] + }, + { + "type": "BLANK" + } + ] + } + ] + }, + "constant_binding": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "STRING", + "value": ":" + }, + { + "type": "SYMBOL", + "name": "type" + }, + { + "type": "STRING", + "value": "=" + }, + { + "type": "SYMBOL", + "name": "expression" + } + ] + }, + "type_declaration": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "type" + }, + { + "type": "SYMBOL", + "name": "type_bindings" + } + ] + }, + "type_bindings": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "STRING", + "value": "=" + }, + { + "type": "SYMBOL", + "name": "type" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "BLANK" + } + ] + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "STRING", + "value": "=" + }, + { + "type": "SYMBOL", + "name": "type" + }, + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "type_bindings" + } + ] + } + ] + }, + "function_declaration": { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "fndec_attrs" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": "fn" + }, + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "SYMBOL", + "name": "prototype" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "=" + }, + { + "type": "SYMBOL", + "name": "expression" + } + ] + }, + { + "type": "BLANK" + } + ] + } + ] + }, + "fndec_attrs": { + "type": "REPEAT1", + "content": { + "type": "SYMBOL", + "name": "fndec_attr" + } + }, + "fndec_attr": { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "@fini" + }, + { + "type": "STRING", + "value": "@init" + }, + { + "type": "STRING", + "value": "@test" + }, + { + "type": "SYMBOL", + "name": "fntype_attr" + }, + { + "type": "SYMBOL", + "name": "decl_attr" + } + ] + }, + "fntype_attr": { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "@noreturn" + } + ] + }, + "type": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "_inner_type" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "!" + }, + { + "type": "BLANK" + } + ] + } + ] + }, + "_inner_type": { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "const" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "SYMBOL", + "name": "storage_class" + } + ] + }, + "storage_class": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "scalar_type" + }, + { + "type": "SYMBOL", + "name": "struct_type" + }, + { + "type": "SYMBOL", + "name": "union_type" + }, + { + "type": "SYMBOL", + "name": "tuple_type" + }, + { + "type": "SYMBOL", + "name": "tagged_union_type" + }, + { + "type": "SYMBOL", + "name": "slice_array_type" + }, + { + "type": "SYMBOL", + "name": "function_type" + }, + { + "type": "SYMBOL", + "name": "alias_type" + }, + { + "type": "SYMBOL", + "name": "unwrapped_alias" + } + ] + }, + "scalar_type": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "integer_type" + }, + { + "type": "SYMBOL", + "name": "floating_type" + }, + { + "type": "SYMBOL", + "name": "enum_type" + }, + { + "type": "SYMBOL", + "name": "pointer_type" + }, + { + "type": "STRING", + "value": "rune" + }, + { + "type": "STRING", + "value": "bool" + }, + { + "type": "STRING", + "value": "void" + } + ] + }, + "integer_type": { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "i8" + }, + { + "type": "STRING", + "value": "i16" + }, + { + "type": "STRING", + "value": "i32" + }, + { + "type": "STRING", + "value": "i64" + }, + { + "type": "STRING", + "value": "u8" + }, + { + "type": "STRING", + "value": "u16" + }, + { + "type": "STRING", + "value": "u32" + }, + { + "type": "STRING", + "value": "u64" + }, + { + "type": "STRING", + "value": "int" + }, + { + "type": "STRING", + "value": "uint" + }, + { + "type": "STRING", + "value": "size" + }, + { + "type": "STRING", + "value": "uintptr" + }, + { + "type": "STRING", + "value": "char" + } + ] + }, + "floating_type": { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "f32" + }, + { + "type": "STRING", + "value": "f64" + } + ] + }, + "enum_type": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "enum" + }, + { + "type": "STRING", + "value": "{" + }, + { + "type": "SYMBOL", + "name": "enum_values" + }, + { + "type": "STRING", + "value": "}" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "enum" + }, + { + "type": "SYMBOL", + "name": "integer_type" + }, + { + "type": "STRING", + "value": "{" + }, + { + "type": "SYMBOL", + "name": "enum_values" + }, + { + "type": "STRING", + "value": "}" + } + ] + } + ] + }, + "enum_values": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "enum_value" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "BLANK" + } + ] + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "enum_value" + }, + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "enum_values" + } + ] + } + ] + }, + "enum_value": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "name" + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "name" + }, + { + "type": "STRING", + "value": "=" + }, + { + "type": "SYMBOL", + "name": "expression" + } + ] + } + ] + }, + "pointer_type": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "*" + }, + { + "type": "SYMBOL", + "name": "_inner_type" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "nullable" + }, + { + "type": "STRING", + "value": "*" + }, + { + "type": "SYMBOL", + "name": "_inner_type" + } + ] + } + ] + }, + "struct_type": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "struct" + }, + { + "type": "STRING", + "value": "{" + }, + { + "type": "SYMBOL", + "name": "struct_union_fields" + }, + { + "type": "STRING", + "value": "}" + } + ] + }, + "union_type": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "union" + }, + { + "type": "STRING", + "value": "{" + }, + { + "type": "SYMBOL", + "name": "struct_union_fields" + }, + { + "type": "STRING", + "value": "}" + } + ] + }, + "struct_union_fields": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "struct_union_field" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "BLANK" + } + ] + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "struct_union_field" + }, + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "struct_union_fields" + } + ] + } + ] + }, + "struct_union_field": { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "offset_specifier" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "name" + }, + { + "type": "STRING", + "value": ":" + }, + { + "type": "SYMBOL", + "name": "type" + } + ] + }, + { + "type": "SYMBOL", + "name": "struct_type" + }, + { + "type": "SYMBOL", + "name": "union_type" + }, + { + "type": "SYMBOL", + "name": "identifier" + } + ] + } + ] + }, + "offset_specifier": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "@offset" + }, + { + "type": "STRING", + "value": "(" + }, + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "STRING", + "value": ")" + } + ] + }, + "tuple_type": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "(" + }, + { + "type": "SYMBOL", + "name": "tuple_types" + }, + { + "type": "STRING", + "value": ")" + } + ] + }, + "tuple_types": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "type" + }, + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "type" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "BLANK" + } + ] + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "type" + }, + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "tuple_types" + } + ] + } + ] + }, + "tagged_union_type": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "(" + }, + { + "type": "SYMBOL", + "name": "tagged_types" + }, + { + "type": "STRING", + "value": ")" + } + ] + }, + "tagged_types": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "type" + }, + { + "type": "STRING", + "value": "|" + }, + { + "type": "SYMBOL", + "name": "type" + }, + { + "type": "REPEAT", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "|" + }, + { + "type": "SYMBOL", + "name": "type" + } + ] + } + } + ] + }, + "slice_array_type": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "[" + }, + { + "type": "STRING", + "value": "]" + }, + { + "type": "SYMBOL", + "name": "_inner_type" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "[" + }, + { + "type": "SYMBOL", + "name": "logical_or_expression" + }, + { + "type": "STRING", + "value": "]" + }, + { + "type": "SYMBOL", + "name": "_inner_type" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "[" + }, + { + "type": "STRING", + "value": "*" + }, + { + "type": "STRING", + "value": "]" + }, + { + "type": "SYMBOL", + "name": "_inner_type" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "[" + }, + { + "type": "STRING", + "value": "_" + }, + { + "type": "STRING", + "value": "]" + }, + { + "type": "SYMBOL", + "name": "_inner_type" + } + ] + } + ] + }, + "function_type": { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "fntype_attr" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": "fn" + }, + { + "type": "SYMBOL", + "name": "prototype" + } + ] + }, + "prototype": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "(" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "parameter_list" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": ")" + }, + { + "type": "SYMBOL", + "name": "_inner_type" + } + ] + }, + "parameter_list": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "parameters" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "BLANK" + } + ] + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "parameters" + }, + { + "type": "STRING", + "value": "..." + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "BLANK" + } + ] + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "parameters" + }, + { + "type": "STRING", + "value": "," + }, + { + "type": "STRING", + "value": "..." + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "BLANK" + } + ] + } + ] + } + ] + }, + "parameters": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "parameter" + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "parameters" + }, + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "parameter" + } + ] + } + ] + }, + "parameter": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "name" + }, + { + "type": "STRING", + "value": ":" + }, + { + "type": "SYMBOL", + "name": "type" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "_" + }, + { + "type": "STRING", + "value": ":" + }, + { + "type": "SYMBOL", + "name": "type" + } + ] + } + ] + }, + "alias_type": { + "type": "SYMBOL", + "name": "identifier" + }, + "unwrapped_alias": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "..." + }, + { + "type": "SYMBOL", + "name": "identifier" + } + ] + }, + "constant": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "integer_constant" + }, + { + "type": "SYMBOL", + "name": "floating_constant" + }, + { + "type": "SYMBOL", + "name": "rune_constant" + }, + { + "type": "SYMBOL", + "name": "string_constant" + }, + { + "type": "STRING", + "value": "true" + }, + { + "type": "STRING", + "value": "false" + }, + { + "type": "STRING", + "value": "null" + }, + { + "type": "STRING", + "value": "void" + } + ] + }, + "integer_constant": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "0x" + }, + { + "type": "SYMBOL", + "name": "hex_digits" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "integer_suffix" + }, + { + "type": "BLANK" + } + ] + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "0o" + }, + { + "type": "SYMBOL", + "name": "octal_digits" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "integer_suffix" + }, + { + "type": "BLANK" + } + ] + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "0b" + }, + { + "type": "SYMBOL", + "name": "binary_digits" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "integer_suffix" + }, + { + "type": "BLANK" + } + ] + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "decimal_digits" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "exponent" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "integer_suffix" + }, + { + "type": "BLANK" + } + ] + } + ] + } + ] + }, + "hex_digits": { + "type": "REPEAT1", + "content": { + "type": "SYMBOL", + "name": "hex_digit" + } + }, + "hex_digit": { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "0" + }, + { + "type": "STRING", + "value": "1" + }, + { + "type": "STRING", + "value": "2" + }, + { + "type": "STRING", + "value": "3" + }, + { + "type": "STRING", + "value": "4" + }, + { + "type": "STRING", + "value": "5" + }, + { + "type": "STRING", + "value": "6" + }, + { + "type": "STRING", + "value": "7" + }, + { + "type": "STRING", + "value": "8" + }, + { + "type": "STRING", + "value": "9" + }, + { + "type": "STRING", + "value": "A" + }, + { + "type": "STRING", + "value": "B" + }, + { + "type": "STRING", + "value": "C" + }, + { + "type": "STRING", + "value": "D" + }, + { + "type": "STRING", + "value": "E" + }, + { + "type": "STRING", + "value": "F" + }, + { + "type": "STRING", + "value": "a" + }, + { + "type": "STRING", + "value": "b" + }, + { + "type": "STRING", + "value": "c" + }, + { + "type": "STRING", + "value": "d" + }, + { + "type": "STRING", + "value": "e" + }, + { + "type": "STRING", + "value": "f" + } + ] + }, + "octal_digits": { + "type": "REPEAT1", + "content": { + "type": "SYMBOL", + "name": "octal_digit" + } + }, + "octal_digit": { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "0" + }, + { + "type": "STRING", + "value": "1" + }, + { + "type": "STRING", + "value": "2" + }, + { + "type": "STRING", + "value": "3" + }, + { + "type": "STRING", + "value": "4" + }, + { + "type": "STRING", + "value": "5" + }, + { + "type": "STRING", + "value": "6" + }, + { + "type": "STRING", + "value": "7" + } + ] + }, + "binary_digits": { + "type": "REPEAT1", + "content": { + "type": "SYMBOL", + "name": "binary_digit" + } + }, + "binary_digit": { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "0" + }, + { + "type": "STRING", + "value": "1" + } + ] + }, + "decimal_digits": { + "type": "REPEAT1", + "content": { + "type": "SYMBOL", + "name": "decimal_digit" + } + }, + "decimal_digit": { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "0" + }, + { + "type": "STRING", + "value": "1" + }, + { + "type": "STRING", + "value": "2" + }, + { + "type": "STRING", + "value": "3" + }, + { + "type": "STRING", + "value": "4" + }, + { + "type": "STRING", + "value": "5" + }, + { + "type": "STRING", + "value": "6" + }, + { + "type": "STRING", + "value": "7" + }, + { + "type": "STRING", + "value": "8" + }, + { + "type": "STRING", + "value": "9" + } + ] + }, + "integer_suffix": { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "i" + }, + { + "type": "STRING", + "value": "u" + }, + { + "type": "STRING", + "value": "z" + }, + { + "type": "STRING", + "value": "i8" + }, + { + "type": "STRING", + "value": "i16" + }, + { + "type": "STRING", + "value": "i32" + }, + { + "type": "STRING", + "value": "i64" + }, + { + "type": "STRING", + "value": "u8" + }, + { + "type": "STRING", + "value": "u16" + }, + { + "type": "STRING", + "value": "u32" + }, + { + "type": "STRING", + "value": "u64" + } + ] + }, + "floating_constant": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "decimal_digits" + }, + { + "type": "STRING", + "value": "." + }, + { + "type": "SYMBOL", + "name": "decimal_digits" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "exponent" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "floating_suffix" + }, + { + "type": "BLANK" + } + ] + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "decimal_digits" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "exponent" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "SYMBOL", + "name": "floating_suffix" + } + ] + } + ] + }, + "exponent": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "e" + }, + { + "type": "SYMBOL", + "name": "decimal_digits" + } + ] + }, + "floating_suffix": { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "f32" + }, + { + "type": "STRING", + "value": "f64" + } + ] + }, + "rune_constant": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "'" + }, + { + "type": "SYMBOL", + "name": "rune" + }, + { + "type": "STRING", + "value": "'" + } + ] + }, + "rune": { + "type": "CHOICE", + "members": [ + { + "type": "IMMEDIATE_TOKEN", + "content": { + "type": "PATTERN", + "value": "[^\\']" + } + }, + { + "type": "SYMBOL", + "name": "escape_sequence" + } + ] + }, + "escape_sequence": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "named_escape" + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "\\" + }, + { + "type": "IMMEDIATE_TOKEN", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "PATTERN", + "value": "x[0-9a-fA-F]{2}" + }, + { + "type": "PATTERN", + "value": "u[0-9a-fA-F]{4}" + }, + { + "type": "PATTERN", + "value": "U[0-9a-fA-F]{8}" + } + ] + } + } + ] + } + ] + }, + "named_escape": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "\\" + }, + { + "type": "IMMEDIATE_TOKEN", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "0" + }, + { + "type": "STRING", + "value": "n" + }, + { + "type": "STRING", + "value": "r" + }, + { + "type": "STRING", + "value": "t" + }, + { + "type": "STRING", + "value": "b" + }, + { + "type": "STRING", + "value": "f" + }, + { + "type": "STRING", + "value": "a" + }, + { + "type": "STRING", + "value": "v" + }, + { + "type": "STRING", + "value": "\\" + }, + { + "type": "STRING", + "value": "'" + }, + { + "type": "STRING", + "value": "\"" + } + ] + } + } + ] + }, + "string_constant": { + "type": "REPEAT1", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "\"" + }, + { + "type": "SYMBOL", + "name": "string_chars" + }, + { + "type": "STRING", + "value": "\"" + } + ] + } + }, + "string_chars": { + "type": "REPEAT1", + "content": { + "type": "SYMBOL", + "name": "string_char" + } + }, + "string_char": { + "type": "CHOICE", + "members": [ + { + "type": "IMMEDIATE_TOKEN", + "content": { + "type": "PATTERN", + "value": "[^\\n\"]" + } + }, + { + "type": "SYMBOL", + "name": "escape_sequence" + } + ] + }, + "array_literal": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "[" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "array_members" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": "]" + } + ] + }, + "array_members": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "BLANK" + } + ] + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "STRING", + "value": "..." + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "BLANK" + } + ] + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "array_members" + } + ] + } + ] + }, + "enum_literal": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "STRING", + "value": "::" + }, + { + "type": "SYMBOL", + "name": "name" + } + ] + }, + "struct_literal": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "struct" + }, + { + "type": "STRING", + "value": "{" + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "field_values" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "BLANK" + } + ] + } + ] + }, + { + "type": "STRING", + "value": "}" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "STRING", + "value": "{" + }, + { + "type": "SYMBOL", + "name": "struct_initializer" + }, + { + "type": "STRING", + "value": "}" + } + ] + } + ] + }, + "struct_initializer": { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "..." + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "field_values" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "..." + }, + { + "type": "BLANK" + } + ] + } + ] + }, + { + "type": "BLANK" + } + ] + } + ] + } + ] + }, + "field_values": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "field_value" + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "field_values" + }, + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "field_value" + } + ] + } + ] + }, + "field_value": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "name" + }, + { + "type": "STRING", + "value": "=" + }, + { + "type": "SYMBOL", + "name": "expression" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "name" + }, + { + "type": "STRING", + "value": ":" + }, + { + "type": "SYMBOL", + "name": "type" + }, + { + "type": "STRING", + "value": "=" + }, + { + "type": "SYMBOL", + "name": "expression" + } + ] + }, + { + "type": "SYMBOL", + "name": "struct_literal" + } + ] + }, + "plain_expression": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "SYMBOL", + "name": "constant" + }, + { + "type": "SYMBOL", + "name": "array_literal" + }, + { + "type": "SYMBOL", + "name": "enum_literal" + }, + { + "type": "SYMBOL", + "name": "struct_literal" + } + ] + }, + "nested_expression": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "plain_expression" + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "(" + }, + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "STRING", + "value": ")" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "(" + }, + { + "type": "SYMBOL", + "name": "tuple_items" + }, + { + "type": "STRING", + "value": ")" + } + ] + } + ] + }, + "tuple_items": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "BLANK" + } + ] + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "tuple_items" + } + ] + } + ] + }, + "allocation_expression": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "alloc" + }, + { + "type": "STRING", + "value": "(" + }, + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "STRING", + "value": ")" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "alloc" + }, + { + "type": "STRING", + "value": "(" + }, + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "STRING", + "value": ")" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "append" + }, + { + "type": "STRING", + "value": "(" + }, + { + "type": "SYMBOL", + "name": "object_selector" + }, + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "append_values" + }, + { + "type": "STRING", + "value": ")" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "append" + }, + { + "type": "STRING", + "value": "(" + }, + { + "type": "STRING", + "value": "*" + }, + { + "type": "SYMBOL", + "name": "unary_expression" + }, + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "append_values" + }, + { + "type": "STRING", + "value": ")" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "free" + }, + { + "type": "STRING", + "value": "(" + }, + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "STRING", + "value": ")" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "delete" + }, + { + "type": "STRING", + "value": "(" + }, + { + "type": "SYMBOL", + "name": "slicing_expression" + }, + { + "type": "STRING", + "value": ")" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "delete" + }, + { + "type": "STRING", + "value": "(" + }, + { + "type": "SYMBOL", + "name": "indexing_expression" + }, + { + "type": "STRING", + "value": ")" + } + ] + } + ] + }, + "append_values": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "BLANK" + } + ] + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "..." + }, + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "BLANK" + } + ] + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "append_values" + } + ] + } + ] + }, + "assertion_expression": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "assert" + }, + { + "type": "STRING", + "value": "(" + }, + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "STRING", + "value": ")" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "assert" + }, + { + "type": "STRING", + "value": "(" + }, + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "string_constant" + }, + { + "type": "STRING", + "value": ")" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "static" + }, + { + "type": "STRING", + "value": "assert" + }, + { + "type": "STRING", + "value": "(" + }, + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "STRING", + "value": ")" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "static" + }, + { + "type": "STRING", + "value": "assert" + }, + { + "type": "STRING", + "value": "(" + }, + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "string_constant" + }, + { + "type": "STRING", + "value": ")" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "abort" + }, + { + "type": "STRING", + "value": "(" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "string_constant" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": ")" + } + ] + } + ] + }, + "call_expression": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "postfix_expression" + }, + { + "type": "STRING", + "value": "(" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "argument_list" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": ")" + } + ] + }, + "argument_list": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "BLANK" + } + ] + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "STRING", + "value": "..." + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "BLANK" + } + ] + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "argument_list" + } + ] + } + ] + }, + "measurement_expression": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "size_expression" + }, + { + "type": "SYMBOL", + "name": "length_expression" + }, + { + "type": "SYMBOL", + "name": "offset_expression" + } + ] + }, + "size_expression": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "size" + }, + { + "type": "STRING", + "value": "(" + }, + { + "type": "SYMBOL", + "name": "type" + }, + { + "type": "STRING", + "value": ")" + } + ] + }, + "length_expression": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "len" + }, + { + "type": "STRING", + "value": "(" + }, + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "STRING", + "value": ")" + } + ] + }, + "offset_expression": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "offset" + }, + { + "type": "STRING", + "value": "(" + }, + { + "type": "SYMBOL", + "name": "field_access_expression" + }, + { + "type": "STRING", + "value": ")" + } + ] + }, + "field_access_expression": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "postfix_expression" + }, + { + "type": "STRING", + "value": "." + }, + { + "type": "SYMBOL", + "name": "name" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "postfix_expression" + }, + { + "type": "STRING", + "value": "." + }, + { + "type": "SYMBOL", + "name": "integer_constant" + } + ] + } + ] + }, + "indexing_expression": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "postfix_expression" + }, + { + "type": "STRING", + "value": "[" + }, + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "STRING", + "value": "]" + } + ] + }, + "slicing_expression": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "postfix_expression" + }, + { + "type": "STRING", + "value": "[" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": ".." + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": "]" + } + ] + }, + "error_propagation": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "postfix_expression" + }, + { + "type": "STRING", + "value": "?" + } + ] + }, + "postfix_expression": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "nested_expression" + }, + { + "type": "SYMBOL", + "name": "allocation_expression" + }, + { + "type": "SYMBOL", + "name": "assertion_expression" + }, + { + "type": "SYMBOL", + "name": "call_expression" + }, + { + "type": "SYMBOL", + "name": "field_access_expression" + }, + { + "type": "SYMBOL", + "name": "indexing_expression" + }, + { + "type": "SYMBOL", + "name": "measurement_expression" + }, + { + "type": "SYMBOL", + "name": "slicing_expression" + }, + { + "type": "SYMBOL", + "name": "error_propagation" + } + ] + }, + "object_selector": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "SYMBOL", + "name": "indexing_expression" + }, + { + "type": "SYMBOL", + "name": "field_access_expression" + } + ] + }, + "unary_expression": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "postfix_expression" + }, + { + "type": "PREC_RIGHT", + "value": 13, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "operator", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "+" + }, + { + "type": "STRING", + "value": "-" + }, + { + "type": "STRING", + "value": "~" + }, + { + "type": "STRING", + "value": "!" + }, + { + "type": "STRING", + "value": "*" + } + ] + } + }, + { + "type": "FIELD", + "name": "argument", + "content": { + "type": "SYMBOL", + "name": "unary_expression" + } + } + ] + } + }, + { + "type": "PREC_RIGHT", + "value": 13, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "address", + "content": { + "type": "STRING", + "value": "&" + } + }, + { + "type": "FIELD", + "name": "argument", + "content": { + "type": "SYMBOL", + "name": "object_selector" + } + } + ] + } + } + ] + }, + "cast_expression": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "unary_expression" + }, + { + "type": "PREC_LEFT", + "value": 12, + "content": { + "type": "FIELD", + "name": "type_cast", + "content": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "cast_expression" + }, + { + "type": "STRING", + "value": ":" + }, + { + "type": "SYMBOL", + "name": "type" + } + ] + } + } + }, + { + "type": "PREC_LEFT", + "value": 12, + "content": { + "type": "FIELD", + "name": "as_cast", + "content": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "cast_expression" + }, + { + "type": "STRING", + "value": "as" + }, + { + "type": "SYMBOL", + "name": "type" + } + ] + } + } + }, + { + "type": "PREC_LEFT", + "value": 12, + "content": { + "type": "FIELD", + "name": "is_cast", + "content": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "cast_expression" + }, + { + "type": "STRING", + "value": "is" + }, + { + "type": "SYMBOL", + "name": "type" + } + ] + } + } + } + ] + }, + "multiplicative_expression": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "cast_expression" + }, + { + "type": "PREC_LEFT", + "value": 11, + "content": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "multiplicative_expression" + }, + { + "type": "STRING", + "value": "*" + }, + { + "type": "SYMBOL", + "name": "cast_expression" + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 11, + "content": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "multiplicative_expression" + }, + { + "type": "STRING", + "value": "/" + }, + { + "type": "SYMBOL", + "name": "cast_expression" + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 11, + "content": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "multiplicative_expression" + }, + { + "type": "STRING", + "value": "%" + }, + { + "type": "SYMBOL", + "name": "cast_expression" + } + ] + } + } + ] + }, + "additive_expression": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "multiplicative_expression" + }, + { + "type": "PREC_LEFT", + "value": 10, + "content": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "additive_expression" + }, + { + "type": "STRING", + "value": "+" + }, + { + "type": "SYMBOL", + "name": "multiplicative_expression" + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 10, + "content": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "additive_expression" + }, + { + "type": "STRING", + "value": "-" + }, + { + "type": "SYMBOL", + "name": "multiplicative_expression" + } + ] + } + } + ] + }, + "shift_expression": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "additive_expression" + }, + { + "type": "PREC_LEFT", + "value": 9, + "content": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "multiplicative_expression" + }, + { + "type": "STRING", + "value": "<<" + }, + { + "type": "SYMBOL", + "name": "cast_expression" + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 9, + "content": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "multiplicative_expression" + }, + { + "type": "STRING", + "value": ">>" + }, + { + "type": "SYMBOL", + "name": "cast_expression" + } + ] + } + } + ] + }, + "and_expression": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "shift_expression" + }, + { + "type": "PREC_LEFT", + "value": 6, + "content": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "and_expression" + }, + { + "type": "STRING", + "value": "&" + }, + { + "type": "SYMBOL", + "name": "shift_expression" + } + ] + } + } + ] + }, + "exclusive_or_expression": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "and_expression" + }, + { + "type": "PREC_LEFT", + "value": 5, + "content": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "exclusive_or_expression" + }, + { + "type": "STRING", + "value": "^" + }, + { + "type": "SYMBOL", + "name": "and_expression" + } + ] + } + } + ] + }, + "inclusive_or_expression": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "exclusive_or_expression" + }, + { + "type": "PREC_LEFT", + "value": 4, + "content": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "inclusive_or_expression" + }, + { + "type": "STRING", + "value": "|" + }, + { + "type": "SYMBOL", + "name": "exclusive_or_expression" + } + ] + } + } + ] + }, + "comparison_expression": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "inclusive_or_expression" + }, + { + "type": "PREC_LEFT", + "value": 8, + "content": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "comparison_expression" + }, + { + "type": "STRING", + "value": "<" + }, + { + "type": "SYMBOL", + "name": "inclusive_or_expression" + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 8, + "content": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "comparison_expression" + }, + { + "type": "STRING", + "value": ">" + }, + { + "type": "SYMBOL", + "name": "inclusive_or_expression" + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 8, + "content": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "comparison_expression" + }, + { + "type": "STRING", + "value": "<=" + }, + { + "type": "SYMBOL", + "name": "inclusive_or_expression" + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 8, + "content": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "comparison_expression" + }, + { + "type": "STRING", + "value": ">=" + }, + { + "type": "SYMBOL", + "name": "inclusive_or_expression" + } + ] + } + } + ] + }, + "equality_expression": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "comparison_expression" + }, + { + "type": "PREC_LEFT", + "value": 7, + "content": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "equality_expression" + }, + { + "type": "STRING", + "value": "==" + }, + { + "type": "SYMBOL", + "name": "comparison_expression" + } + ] + } + }, + { + "type": "PREC_LEFT", + "value": 7, + "content": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "equality_expression" + }, + { + "type": "STRING", + "value": "!=" + }, + { + "type": "SYMBOL", + "name": "comparison_expression" + } + ] + } + } + ] + }, + "logical_and_expression": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "equality_expression" + }, + { + "type": "PREC_LEFT", + "value": 3, + "content": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "logical_and_expression" + }, + { + "type": "STRING", + "value": "&&" + }, + { + "type": "SYMBOL", + "name": "equality_expression" + } + ] + } + } + ] + }, + "logical_xor_expression": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "logical_and_expression" + }, + { + "type": "PREC_LEFT", + "value": 1, + "content": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "logical_xor_expression" + }, + { + "type": "STRING", + "value": "^^" + }, + { + "type": "SYMBOL", + "name": "logical_and_expression" + } + ] + } + } + ] + }, + "logical_or_expression": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "logical_xor_expression" + }, + { + "type": "PREC_LEFT", + "value": 2, + "content": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "logical_or_expression" + }, + { + "type": "STRING", + "value": "||" + }, + { + "type": "SYMBOL", + "name": "logical_xor_expression" + } + ] + } + } + ] + }, + "if_expression": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "if" + }, + { + "type": "SYMBOL", + "name": "conditional_branch" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "if" + }, + { + "type": "SYMBOL", + "name": "conditional_branch" + }, + { + "type": "STRING", + "value": "else" + }, + { + "type": "SYMBOL", + "name": "expression" + } + ] + } + ] + }, + "conditional_branch": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "(" + }, + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "STRING", + "value": ")" + }, + { + "type": "SYMBOL", + "name": "expression" + } + ] + }, + "for_loop": { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "label" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": "for" + }, + { + "type": "STRING", + "value": "(" + }, + { + "type": "SYMBOL", + "name": "for_predicate" + }, + { + "type": "STRING", + "value": ")" + }, + { + "type": "SYMBOL", + "name": "expression" + } + ] + }, + "for_predicate": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "binding", + "content": { + "type": "SYMBOL", + "name": "binding_list" + } + }, + { + "type": "STRING", + "value": ";" + }, + { + "type": "SYMBOL", + "name": "expression" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "STRING", + "value": ";" + }, + { + "type": "FIELD", + "name": "afterthought", + "content": { + "type": "SYMBOL", + "name": "expression" + } + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "binding_list" + }, + { + "type": "STRING", + "value": ";" + }, + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "STRING", + "value": ";" + }, + { + "type": "SYMBOL", + "name": "expression" + } + ] + } + ] + }, + "label": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": ":" + }, + { + "type": "SYMBOL", + "name": "name" + } + ] + }, + "switch_expression": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "switch" + }, + { + "type": "STRING", + "value": "(" + }, + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "STRING", + "value": ")" + }, + { + "type": "STRING", + "value": "{" + }, + { + "type": "SYMBOL", + "name": "switch_cases" + }, + { + "type": "STRING", + "value": "}" + } + ] + }, + "switch_cases": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "switch_case" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "BLANK" + } + ] + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "switch_case" + }, + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "switch_cases" + } + ] + } + ] + }, + "switch_case": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "case_options" + }, + { + "type": "STRING", + "value": "=>" + }, + { + "type": "SYMBOL", + "name": "expression" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "*" + }, + { + "type": "STRING", + "value": "=>" + }, + { + "type": "SYMBOL", + "name": "expression" + } + ] + } + ] + }, + "case_options": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "BLANK" + } + ] + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "case_options" + } + ] + } + ] + }, + "match_expression": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "match" + }, + { + "type": "STRING", + "value": "(" + }, + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "STRING", + "value": ")" + }, + { + "type": "STRING", + "value": "{" + }, + { + "type": "SYMBOL", + "name": "match_cases" + }, + { + "type": "STRING", + "value": "}" + } + ] + }, + "match_cases": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "match_case" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "BLANK" + } + ] + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "match_case" + }, + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "match_cases" + } + ] + } + ] + }, + "match_case": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "name" + }, + { + "type": "STRING", + "value": ":" + }, + { + "type": "SYMBOL", + "name": "type" + }, + { + "type": "STRING", + "value": "=>" + }, + { + "type": "SYMBOL", + "name": "expression" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "type" + }, + { + "type": "STRING", + "value": "=>" + }, + { + "type": "SYMBOL", + "name": "expression" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "*" + }, + { + "type": "STRING", + "value": "=>" + }, + { + "type": "SYMBOL", + "name": "expression" + } + ] + } + ] + }, + "assignment": { + "type": "PREC_LEFT", + "value": 0, + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "object_selector" + }, + { + "type": "SYMBOL", + "name": "assignment_op" + }, + { + "type": "SYMBOL", + "name": "expression" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "*" + }, + { + "type": "SYMBOL", + "name": "unary_expression" + }, + { + "type": "SYMBOL", + "name": "assignment_op" + }, + { + "type": "SYMBOL", + "name": "expression" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "slicing_expression" + }, + { + "type": "STRING", + "value": "=" + }, + { + "type": "SYMBOL", + "name": "expression" + } + ] + } + ] + } + }, + "assignment_op": { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "=" + }, + { + "type": "STRING", + "value": "+=" + }, + { + "type": "STRING", + "value": "-=" + }, + { + "type": "STRING", + "value": "*=" + }, + { + "type": "STRING", + "value": "/=" + }, + { + "type": "STRING", + "value": "%=" + }, + { + "type": "STRING", + "value": "<<=" + }, + { + "type": "STRING", + "value": ">>=" + }, + { + "type": "STRING", + "value": "&=" + }, + { + "type": "STRING", + "value": "|=" + }, + { + "type": "STRING", + "value": "^=" + } + ] + }, + "binding_list": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "static" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": "let" + }, + { + "type": "SYMBOL", + "name": "bindings" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "static" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": "const" + }, + { + "type": "SYMBOL", + "name": "bindings" + } + ] + } + ] + }, + "bindings": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "binding" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "bindings" + } + ] + }, + { + "type": "BLANK" + } + ] + } + ] + }, + "binding": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "name" + }, + { + "type": "STRING", + "value": "=" + }, + { + "type": "SYMBOL", + "name": "expression" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "name" + }, + { + "type": "STRING", + "value": ":" + }, + { + "type": "SYMBOL", + "name": "type" + }, + { + "type": "STRING", + "value": "=" + }, + { + "type": "SYMBOL", + "name": "expression" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "binding_names" + }, + { + "type": "STRING", + "value": "=" + }, + { + "type": "SYMBOL", + "name": "expression" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "binding_names" + }, + { + "type": "STRING", + "value": ":" + }, + { + "type": "SYMBOL", + "name": "type" + }, + { + "type": "STRING", + "value": "=" + }, + { + "type": "SYMBOL", + "name": "expression" + } + ] + } + ] + }, + "binding_names": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "name" + }, + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "name" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "name" + }, + { + "type": "STRING", + "value": "," + }, + { + "type": "SYMBOL", + "name": "binding_names" + } + ] + } + ] + }, + "deferred_expression": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "defer" + }, + { + "type": "SYMBOL", + "name": "expression" + } + ] + }, + "expression_list": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "STRING", + "value": ";" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "STRING", + "value": ";" + }, + { + "type": "SYMBOL", + "name": "expression_list" + } + ] + } + ] + }, + "control_statement": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "break" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "label" + }, + { + "type": "BLANK" + } + ] + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "continue" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "label" + }, + { + "type": "BLANK" + } + ] + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "return" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "expression" + }, + { + "type": "BLANK" + } + ] + } + ] + } + ] + }, + "expression": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "assignment" + }, + { + "type": "SYMBOL", + "name": "binding_list" + }, + { + "type": "SYMBOL", + "name": "deferred_expression" + }, + { + "type": "SYMBOL", + "name": "logical_or_expression" + }, + { + "type": "SYMBOL", + "name": "if_expression" + }, + { + "type": "SYMBOL", + "name": "for_loop" + }, + { + "type": "SYMBOL", + "name": "switch_expression" + }, + { + "type": "SYMBOL", + "name": "match_expression" + }, + { + "type": "SYMBOL", + "name": "control_statement" + }, + { + "type": "SYMBOL", + "name": "compound_expression" + } + ] + }, + "compound_expression": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "{" + }, + { + "type": "SYMBOL", + "name": "expression_list" + }, + { + "type": "STRING", + "value": "}" + } + ] + }, + "identifier": { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "name" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "::" + }, + { + "type": "SYMBOL", + "name": "identifier" + } + ] + }, + { + "type": "BLANK" + } + ] + } + ] + }, + "name": { + "type": "PATTERN", + "value": "[a-zA-Z_]\\w*" + }, + "comment": { + "type": "TOKEN", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "//" + }, + { + "type": "PATTERN", + "value": "(\\\\(.|\\r?\\n)|[^\\\\\\n])*" + } + ] + } + } + }, + "extras": [ + { + "type": "PATTERN", + "value": "\\s|\\\\\\r?\\n" + }, + { + "type": "SYMBOL", + "name": "comment" + } + ], + "conflicts": [ + [ + "integer_constant", + "floating_constant" + ], + [ + "identifier" + ], + [ + "bindings" + ], + [ + "for_predicate", + "expression" + ], + [ + "if_expression" + ] + ], + "precedences": [], + "externals": [], + "inline": [], + "supertypes": [] +} + diff --git a/src/node-types.json b/src/node-types.json new file mode 100644 index 000000000..7e7d6a6d2 --- /dev/null +++ b/src/node-types.json @@ -0,0 +1,3059 @@ +[ + { + "type": "additive_expression", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "additive_expression", + "named": true + }, + { + "type": "multiplicative_expression", + "named": true + } + ] + } + }, + { + "type": "alias_type", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "identifier", + "named": true + } + ] + } + }, + { + "type": "allocation_expression", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "append_values", + "named": true + }, + { + "type": "expression", + "named": true + }, + { + "type": "indexing_expression", + "named": true + }, + { + "type": "object_selector", + "named": true + }, + { + "type": "slicing_expression", + "named": true + }, + { + "type": "unary_expression", + "named": true + } + ] + } + }, + { + "type": "and_expression", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "and_expression", + "named": true + }, + { + "type": "shift_expression", + "named": true + } + ] + } + }, + { + "type": "append_values", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "append_values", + "named": true + }, + { + "type": "expression", + "named": true + } + ] + } + }, + { + "type": "argument_list", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "argument_list", + "named": true + }, + { + "type": "expression", + "named": true + } + ] + } + }, + { + "type": "array_literal", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": false, + "types": [ + { + "type": "array_members", + "named": true + } + ] + } + }, + { + "type": "array_members", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "array_members", + "named": true + }, + { + "type": "expression", + "named": true + } + ] + } + }, + { + "type": "assertion_expression", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "expression", + "named": true + }, + { + "type": "string_constant", + "named": true + } + ] + } + }, + { + "type": "assignment", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "assignment_op", + "named": true + }, + { + "type": "expression", + "named": true + }, + { + "type": "object_selector", + "named": true + }, + { + "type": "slicing_expression", + "named": true + }, + { + "type": "unary_expression", + "named": true + } + ] + } + }, + { + "type": "assignment_op", + "named": true, + "fields": {} + }, + { + "type": "binary_digit", + "named": true, + "fields": {} + }, + { + "type": "binary_digits", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "binary_digit", + "named": true + } + ] + } + }, + { + "type": "binding", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "binding_names", + "named": true + }, + { + "type": "expression", + "named": true + }, + { + "type": "name", + "named": true + }, + { + "type": "type", + "named": true + } + ] + } + }, + { + "type": "binding_list", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "bindings", + "named": true + } + ] + } + }, + { + "type": "binding_names", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "binding_names", + "named": true + }, + { + "type": "name", + "named": true + } + ] + } + }, + { + "type": "bindings", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "binding", + "named": true + }, + { + "type": "bindings", + "named": true + } + ] + } + }, + { + "type": "call_expression", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "argument_list", + "named": true + }, + { + "type": "postfix_expression", + "named": true + } + ] + } + }, + { + "type": "case_options", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "case_options", + "named": true + }, + { + "type": "expression", + "named": true + } + ] + } + }, + { + "type": "cast_expression", + "named": true, + "fields": { + "as_cast": { + "multiple": true, + "required": false, + "types": [ + { + "type": "as", + "named": false + }, + { + "type": "cast_expression", + "named": true + }, + { + "type": "type", + "named": true + } + ] + }, + "is_cast": { + "multiple": true, + "required": false, + "types": [ + { + "type": "cast_expression", + "named": true + }, + { + "type": "is", + "named": false + }, + { + "type": "type", + "named": true + } + ] + }, + "type_cast": { + "multiple": true, + "required": false, + "types": [ + { + "type": ":", + "named": false + }, + { + "type": "cast_expression", + "named": true + }, + { + "type": "type", + "named": true + } + ] + } + }, + "children": { + "multiple": false, + "required": false, + "types": [ + { + "type": "unary_expression", + "named": true + } + ] + } + }, + { + "type": "comparison_expression", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "comparison_expression", + "named": true + }, + { + "type": "inclusive_or_expression", + "named": true + } + ] + } + }, + { + "type": "compound_expression", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "expression_list", + "named": true + } + ] + } + }, + { + "type": "conditional_branch", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "expression", + "named": true + } + ] + } + }, + { + "type": "constant", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": false, + "types": [ + { + "type": "floating_constant", + "named": true + }, + { + "type": "integer_constant", + "named": true + }, + { + "type": "rune_constant", + "named": true + }, + { + "type": "string_constant", + "named": true + } + ] + } + }, + { + "type": "constant_binding", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "expression", + "named": true + }, + { + "type": "identifier", + "named": true + }, + { + "type": "type", + "named": true + } + ] + } + }, + { + "type": "constant_bindings", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "constant_binding", + "named": true + }, + { + "type": "constant_bindings", + "named": true + } + ] + } + }, + { + "type": "constant_declaration", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "constant_bindings", + "named": true + } + ] + } + }, + { + "type": "control_statement", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": false, + "types": [ + { + "type": "expression", + "named": true + }, + { + "type": "label", + "named": true + } + ] + } + }, + { + "type": "decimal_digit", + "named": true, + "fields": {} + }, + { + "type": "decimal_digits", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "decimal_digit", + "named": true + } + ] + } + }, + { + "type": "decl_attr", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "string_constant", + "named": true + } + ] + } + }, + { + "type": "declaration", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "constant_declaration", + "named": true + }, + { + "type": "function_declaration", + "named": true + }, + { + "type": "global_declaration", + "named": true + }, + { + "type": "type_declaration", + "named": true + } + ] + } + }, + { + "type": "declarations", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "declaration", + "named": true + } + ] + } + }, + { + "type": "deferred_expression", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "expression", + "named": true + } + ] + } + }, + { + "type": "enum_literal", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "identifier", + "named": true + }, + { + "type": "name", + "named": true + } + ] + } + }, + { + "type": "enum_type", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "enum_values", + "named": true + }, + { + "type": "integer_type", + "named": true + } + ] + } + }, + { + "type": "enum_value", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "expression", + "named": true + }, + { + "type": "name", + "named": true + } + ] + } + }, + { + "type": "enum_values", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "enum_value", + "named": true + }, + { + "type": "enum_values", + "named": true + } + ] + } + }, + { + "type": "equality_expression", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "comparison_expression", + "named": true + }, + { + "type": "equality_expression", + "named": true + } + ] + } + }, + { + "type": "error_propagation", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "postfix_expression", + "named": true + } + ] + } + }, + { + "type": "escape_sequence", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": false, + "types": [ + { + "type": "named_escape", + "named": true + } + ] + } + }, + { + "type": "exclusive_or_expression", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "and_expression", + "named": true + }, + { + "type": "exclusive_or_expression", + "named": true + } + ] + } + }, + { + "type": "exponent", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "decimal_digits", + "named": true + } + ] + } + }, + { + "type": "expression", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "assignment", + "named": true + }, + { + "type": "binding_list", + "named": true + }, + { + "type": "compound_expression", + "named": true + }, + { + "type": "control_statement", + "named": true + }, + { + "type": "deferred_expression", + "named": true + }, + { + "type": "for_loop", + "named": true + }, + { + "type": "if_expression", + "named": true + }, + { + "type": "logical_or_expression", + "named": true + }, + { + "type": "match_expression", + "named": true + }, + { + "type": "switch_expression", + "named": true + } + ] + } + }, + { + "type": "expression_list", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "expression", + "named": true + }, + { + "type": "expression_list", + "named": true + } + ] + } + }, + { + "type": "field_access_expression", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "integer_constant", + "named": true + }, + { + "type": "name", + "named": true + }, + { + "type": "postfix_expression", + "named": true + } + ] + } + }, + { + "type": "field_value", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "expression", + "named": true + }, + { + "type": "name", + "named": true + }, + { + "type": "struct_literal", + "named": true + }, + { + "type": "type", + "named": true + } + ] + } + }, + { + "type": "field_values", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "field_value", + "named": true + }, + { + "type": "field_values", + "named": true + } + ] + } + }, + { + "type": "floating_constant", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "decimal_digits", + "named": true + }, + { + "type": "exponent", + "named": true + }, + { + "type": "floating_suffix", + "named": true + } + ] + } + }, + { + "type": "floating_suffix", + "named": true, + "fields": {} + }, + { + "type": "floating_type", + "named": true, + "fields": {} + }, + { + "type": "fndec_attr", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": false, + "types": [ + { + "type": "decl_attr", + "named": true + }, + { + "type": "fntype_attr", + "named": true + } + ] + } + }, + { + "type": "fndec_attrs", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "fndec_attr", + "named": true + } + ] + } + }, + { + "type": "fntype_attr", + "named": true, + "fields": {} + }, + { + "type": "for_loop", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "expression", + "named": true + }, + { + "type": "for_predicate", + "named": true + }, + { + "type": "label", + "named": true + } + ] + } + }, + { + "type": "for_predicate", + "named": true, + "fields": { + "afterthought": { + "multiple": false, + "required": false, + "types": [ + { + "type": "expression", + "named": true + } + ] + }, + "binding": { + "multiple": false, + "required": false, + "types": [ + { + "type": "binding_list", + "named": true + } + ] + } + }, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "binding_list", + "named": true + }, + { + "type": "expression", + "named": true + } + ] + } + }, + { + "type": "function_declaration", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "expression", + "named": true + }, + { + "type": "fndec_attrs", + "named": true + }, + { + "type": "identifier", + "named": true + }, + { + "type": "prototype", + "named": true + } + ] + } + }, + { + "type": "function_type", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "fntype_attr", + "named": true + }, + { + "type": "prototype", + "named": true + } + ] + } + }, + { + "type": "global_binding", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "decl_attr", + "named": true + }, + { + "type": "expression", + "named": true + }, + { + "type": "identifier", + "named": true + }, + { + "type": "type", + "named": true + } + ] + } + }, + { + "type": "global_bindings", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "global_binding", + "named": true + }, + { + "type": "global_bindings", + "named": true + } + ] + } + }, + { + "type": "global_declaration", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "global_bindings", + "named": true + } + ] + } + }, + { + "type": "hex_digit", + "named": true, + "fields": {} + }, + { + "type": "hex_digits", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "hex_digit", + "named": true + } + ] + } + }, + { + "type": "identifier", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "identifier", + "named": true + }, + { + "type": "name", + "named": true + } + ] + } + }, + { + "type": "if_expression", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "conditional_branch", + "named": true + }, + { + "type": "expression", + "named": true + } + ] + } + }, + { + "type": "imports", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "use_statement", + "named": true + } + ] + } + }, + { + "type": "inclusive_or_expression", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "exclusive_or_expression", + "named": true + }, + { + "type": "inclusive_or_expression", + "named": true + } + ] + } + }, + { + "type": "indexing_expression", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "expression", + "named": true + }, + { + "type": "postfix_expression", + "named": true + } + ] + } + }, + { + "type": "integer_constant", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "binary_digits", + "named": true + }, + { + "type": "decimal_digits", + "named": true + }, + { + "type": "exponent", + "named": true + }, + { + "type": "hex_digits", + "named": true + }, + { + "type": "integer_suffix", + "named": true + }, + { + "type": "octal_digits", + "named": true + } + ] + } + }, + { + "type": "integer_suffix", + "named": true, + "fields": {} + }, + { + "type": "integer_type", + "named": true, + "fields": {} + }, + { + "type": "label", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "name", + "named": true + } + ] + } + }, + { + "type": "length_expression", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "expression", + "named": true + } + ] + } + }, + { + "type": "logical_and_expression", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "equality_expression", + "named": true + }, + { + "type": "logical_and_expression", + "named": true + } + ] + } + }, + { + "type": "logical_or_expression", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "logical_or_expression", + "named": true + }, + { + "type": "logical_xor_expression", + "named": true + } + ] + } + }, + { + "type": "logical_xor_expression", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "logical_and_expression", + "named": true + }, + { + "type": "logical_xor_expression", + "named": true + } + ] + } + }, + { + "type": "match_case", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "expression", + "named": true + }, + { + "type": "name", + "named": true + }, + { + "type": "type", + "named": true + } + ] + } + }, + { + "type": "match_cases", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "match_case", + "named": true + }, + { + "type": "match_cases", + "named": true + } + ] + } + }, + { + "type": "match_expression", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "expression", + "named": true + }, + { + "type": "match_cases", + "named": true + } + ] + } + }, + { + "type": "measurement_expression", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "length_expression", + "named": true + }, + { + "type": "offset_expression", + "named": true + }, + { + "type": "size_expression", + "named": true + } + ] + } + }, + { + "type": "multiplicative_expression", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "cast_expression", + "named": true + }, + { + "type": "multiplicative_expression", + "named": true + } + ] + } + }, + { + "type": "name_list", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "name", + "named": true + }, + { + "type": "name_list", + "named": true + } + ] + } + }, + { + "type": "named_escape", + "named": true, + "fields": {} + }, + { + "type": "nested_expression", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "expression", + "named": true + }, + { + "type": "plain_expression", + "named": true + }, + { + "type": "tuple_items", + "named": true + } + ] + } + }, + { + "type": "object_selector", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "field_access_expression", + "named": true + }, + { + "type": "identifier", + "named": true + }, + { + "type": "indexing_expression", + "named": true + } + ] + } + }, + { + "type": "octal_digit", + "named": true, + "fields": {} + }, + { + "type": "octal_digits", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "octal_digit", + "named": true + } + ] + } + }, + { + "type": "offset_expression", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "field_access_expression", + "named": true + } + ] + } + }, + { + "type": "offset_specifier", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "expression", + "named": true + } + ] + } + }, + { + "type": "parameter", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "name", + "named": true + }, + { + "type": "type", + "named": true + } + ] + } + }, + { + "type": "parameter_list", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "parameters", + "named": true + } + ] + } + }, + { + "type": "parameters", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "parameter", + "named": true + }, + { + "type": "parameters", + "named": true + } + ] + } + }, + { + "type": "plain_expression", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "array_literal", + "named": true + }, + { + "type": "constant", + "named": true + }, + { + "type": "enum_literal", + "named": true + }, + { + "type": "identifier", + "named": true + }, + { + "type": "struct_literal", + "named": true + } + ] + } + }, + { + "type": "pointer_type", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "storage_class", + "named": true + } + ] + } + }, + { + "type": "postfix_expression", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "allocation_expression", + "named": true + }, + { + "type": "assertion_expression", + "named": true + }, + { + "type": "call_expression", + "named": true + }, + { + "type": "error_propagation", + "named": true + }, + { + "type": "field_access_expression", + "named": true + }, + { + "type": "indexing_expression", + "named": true + }, + { + "type": "measurement_expression", + "named": true + }, + { + "type": "nested_expression", + "named": true + }, + { + "type": "slicing_expression", + "named": true + } + ] + } + }, + { + "type": "prototype", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "parameter_list", + "named": true + }, + { + "type": "storage_class", + "named": true + } + ] + } + }, + { + "type": "rune", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": false, + "types": [ + { + "type": "escape_sequence", + "named": true + } + ] + } + }, + { + "type": "rune_constant", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "rune", + "named": true + } + ] + } + }, + { + "type": "scalar_type", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": false, + "types": [ + { + "type": "enum_type", + "named": true + }, + { + "type": "floating_type", + "named": true + }, + { + "type": "integer_type", + "named": true + }, + { + "type": "pointer_type", + "named": true + } + ] + } + }, + { + "type": "shift_expression", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "additive_expression", + "named": true + }, + { + "type": "cast_expression", + "named": true + }, + { + "type": "multiplicative_expression", + "named": true + } + ] + } + }, + { + "type": "size_expression", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "type", + "named": true + } + ] + } + }, + { + "type": "slice_array_type", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "logical_or_expression", + "named": true + }, + { + "type": "storage_class", + "named": true + } + ] + } + }, + { + "type": "slicing_expression", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "expression", + "named": true + }, + { + "type": "postfix_expression", + "named": true + } + ] + } + }, + { + "type": "storage_class", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "alias_type", + "named": true + }, + { + "type": "function_type", + "named": true + }, + { + "type": "scalar_type", + "named": true + }, + { + "type": "slice_array_type", + "named": true + }, + { + "type": "struct_type", + "named": true + }, + { + "type": "tagged_union_type", + "named": true + }, + { + "type": "tuple_type", + "named": true + }, + { + "type": "union_type", + "named": true + }, + { + "type": "unwrapped_alias", + "named": true + } + ] + } + }, + { + "type": "string_char", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": false, + "types": [ + { + "type": "escape_sequence", + "named": true + } + ] + } + }, + { + "type": "string_chars", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "string_char", + "named": true + } + ] + } + }, + { + "type": "string_constant", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "string_chars", + "named": true + } + ] + } + }, + { + "type": "struct_initializer", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": false, + "types": [ + { + "type": "field_values", + "named": true + } + ] + } + }, + { + "type": "struct_literal", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "field_values", + "named": true + }, + { + "type": "identifier", + "named": true + }, + { + "type": "struct_initializer", + "named": true + } + ] + } + }, + { + "type": "struct_type", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "struct_union_fields", + "named": true + } + ] + } + }, + { + "type": "struct_union_field", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "identifier", + "named": true + }, + { + "type": "name", + "named": true + }, + { + "type": "offset_specifier", + "named": true + }, + { + "type": "struct_type", + "named": true + }, + { + "type": "type", + "named": true + }, + { + "type": "union_type", + "named": true + } + ] + } + }, + { + "type": "struct_union_fields", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "struct_union_field", + "named": true + }, + { + "type": "struct_union_fields", + "named": true + } + ] + } + }, + { + "type": "switch_case", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "case_options", + "named": true + }, + { + "type": "expression", + "named": true + } + ] + } + }, + { + "type": "switch_cases", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "switch_case", + "named": true + }, + { + "type": "switch_cases", + "named": true + } + ] + } + }, + { + "type": "switch_expression", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "expression", + "named": true + }, + { + "type": "switch_cases", + "named": true + } + ] + } + }, + { + "type": "tagged_types", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "type", + "named": true + } + ] + } + }, + { + "type": "tagged_union_type", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "tagged_types", + "named": true + } + ] + } + }, + { + "type": "tuple_items", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "expression", + "named": true + }, + { + "type": "tuple_items", + "named": true + } + ] + } + }, + { + "type": "tuple_type", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "tuple_types", + "named": true + } + ] + } + }, + { + "type": "tuple_types", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "tuple_types", + "named": true + }, + { + "type": "type", + "named": true + } + ] + } + }, + { + "type": "type", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "storage_class", + "named": true + } + ] + } + }, + { + "type": "type_bindings", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "identifier", + "named": true + }, + { + "type": "type", + "named": true + }, + { + "type": "type_bindings", + "named": true + } + ] + } + }, + { + "type": "type_declaration", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "type_bindings", + "named": true + } + ] + } + }, + { + "type": "unary_expression", + "named": true, + "fields": { + "address": { + "multiple": false, + "required": false, + "types": [ + { + "type": "&", + "named": false + } + ] + }, + "argument": { + "multiple": false, + "required": false, + "types": [ + { + "type": "object_selector", + "named": true + }, + { + "type": "unary_expression", + "named": true + } + ] + }, + "operator": { + "multiple": false, + "required": false, + "types": [ + { + "type": "!", + "named": false + }, + { + "type": "*", + "named": false + }, + { + "type": "+", + "named": false + }, + { + "type": "-", + "named": false + }, + { + "type": "~", + "named": false + } + ] + } + }, + "children": { + "multiple": false, + "required": false, + "types": [ + { + "type": "postfix_expression", + "named": true + } + ] + } + }, + { + "type": "union_type", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "struct_union_fields", + "named": true + } + ] + } + }, + { + "type": "unit", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "declarations", + "named": true + }, + { + "type": "imports", + "named": true + } + ] + } + }, + { + "type": "unwrapped_alias", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "type": "identifier", + "named": true + } + ] + } + }, + { + "type": "use_statement", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "identifier", + "named": true + }, + { + "type": "name", + "named": true + }, + { + "type": "name_list", + "named": true + } + ] + } + }, + { + "type": "!", + "named": false + }, + { + "type": "!=", + "named": false + }, + { + "type": "\"", + "named": false + }, + { + "type": "%", + "named": false + }, + { + "type": "%=", + "named": false + }, + { + "type": "&", + "named": false + }, + { + "type": "&&", + "named": false + }, + { + "type": "&=", + "named": false + }, + { + "type": "'", + "named": false + }, + { + "type": "(", + "named": false + }, + { + "type": ")", + "named": false + }, + { + "type": "*", + "named": false + }, + { + "type": "*=", + "named": false + }, + { + "type": "+", + "named": false + }, + { + "type": "+=", + "named": false + }, + { + "type": ",", + "named": false + }, + { + "type": "-", + "named": false + }, + { + "type": "-=", + "named": false + }, + { + "type": ".", + "named": false + }, + { + "type": "..", + "named": false + }, + { + "type": "...", + "named": false + }, + { + "type": "/", + "named": false + }, + { + "type": "/=", + "named": false + }, + { + "type": "0", + "named": false + }, + { + "type": "0b", + "named": false + }, + { + "type": "0o", + "named": false + }, + { + "type": "0x", + "named": false + }, + { + "type": "1", + "named": false + }, + { + "type": "2", + "named": false + }, + { + "type": "3", + "named": false + }, + { + "type": "4", + "named": false + }, + { + "type": "5", + "named": false + }, + { + "type": "6", + "named": false + }, + { + "type": "7", + "named": false + }, + { + "type": "8", + "named": false + }, + { + "type": "9", + "named": false + }, + { + "type": ":", + "named": false + }, + { + "type": "::", + "named": false + }, + { + "type": ";", + "named": false + }, + { + "type": "<", + "named": false + }, + { + "type": "<<", + "named": false + }, + { + "type": "<<=", + "named": false + }, + { + "type": "<=", + "named": false + }, + { + "type": "=", + "named": false + }, + { + "type": "==", + "named": false + }, + { + "type": "=>", + "named": false + }, + { + "type": ">", + "named": false + }, + { + "type": ">=", + "named": false + }, + { + "type": ">>", + "named": false + }, + { + "type": ">>=", + "named": false + }, + { + "type": "?", + "named": false + }, + { + "type": "@fini", + "named": false + }, + { + "type": "@init", + "named": false + }, + { + "type": "@noreturn", + "named": false + }, + { + "type": "@offset", + "named": false + }, + { + "type": "@symbol", + "named": false + }, + { + "type": "@test", + "named": false + }, + { + "type": "A", + "named": false + }, + { + "type": "B", + "named": false + }, + { + "type": "C", + "named": false + }, + { + "type": "D", + "named": false + }, + { + "type": "E", + "named": false + }, + { + "type": "F", + "named": false + }, + { + "type": "[", + "named": false + }, + { + "type": "\\", + "named": false + }, + { + "type": "]", + "named": false + }, + { + "type": "^", + "named": false + }, + { + "type": "^=", + "named": false + }, + { + "type": "^^", + "named": false + }, + { + "type": "_", + "named": false + }, + { + "type": "a", + "named": false + }, + { + "type": "abort", + "named": false + }, + { + "type": "alloc", + "named": false + }, + { + "type": "append", + "named": false + }, + { + "type": "as", + "named": false + }, + { + "type": "assert", + "named": false + }, + { + "type": "b", + "named": false + }, + { + "type": "bool", + "named": false + }, + { + "type": "break", + "named": false + }, + { + "type": "c", + "named": false + }, + { + "type": "char", + "named": false + }, + { + "type": "comment", + "named": true + }, + { + "type": "const", + "named": false + }, + { + "type": "continue", + "named": false + }, + { + "type": "d", + "named": false + }, + { + "type": "def", + "named": false + }, + { + "type": "defer", + "named": false + }, + { + "type": "delete", + "named": false + }, + { + "type": "e", + "named": false + }, + { + "type": "else", + "named": false + }, + { + "type": "enum", + "named": false + }, + { + "type": "export", + "named": false + }, + { + "type": "f", + "named": false + }, + { + "type": "f32", + "named": false + }, + { + "type": "f64", + "named": false + }, + { + "type": "false", + "named": false + }, + { + "type": "fn", + "named": false + }, + { + "type": "for", + "named": false + }, + { + "type": "free", + "named": false + }, + { + "type": "i", + "named": false + }, + { + "type": "i16", + "named": false + }, + { + "type": "i32", + "named": false + }, + { + "type": "i64", + "named": false + }, + { + "type": "i8", + "named": false + }, + { + "type": "if", + "named": false + }, + { + "type": "int", + "named": false + }, + { + "type": "is", + "named": false + }, + { + "type": "len", + "named": false + }, + { + "type": "let", + "named": false + }, + { + "type": "match", + "named": false + }, + { + "type": "name", + "named": true + }, + { + "type": "null", + "named": false + }, + { + "type": "nullable", + "named": false + }, + { + "type": "offset", + "named": false + }, + { + "type": "return", + "named": false + }, + { + "type": "rune", + "named": false + }, + { + "type": "size", + "named": false + }, + { + "type": "static", + "named": false + }, + { + "type": "struct", + "named": false + }, + { + "type": "switch", + "named": false + }, + { + "type": "true", + "named": false + }, + { + "type": "type", + "named": false + }, + { + "type": "u", + "named": false + }, + { + "type": "u16", + "named": false + }, + { + "type": "u32", + "named": false + }, + { + "type": "u64", + "named": false + }, + { + "type": "u8", + "named": false + }, + { + "type": "uint", + "named": false + }, + { + "type": "uintptr", + "named": false + }, + { + "type": "union", + "named": false + }, + { + "type": "use", + "named": false + }, + { + "type": "void", + "named": false + }, + { + "type": "z", + "named": false + }, + { + "type": "{", + "named": false + }, + { + "type": "|", + "named": false + }, + { + "type": "|=", + "named": false + }, + { + "type": "||", + "named": false + }, + { + "type": "}", + "named": false + }, + { + "type": "~", + "named": false + } +] \ No newline at end of file diff --git a/src/parser.c b/src/parser.c new file mode 100644 index 000000000..bc77694d9 --- /dev/null +++ b/src/parser.c @@ -0,0 +1,37902 @@ +#include + +#if defined(__GNUC__) || defined(__clang__) +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wmissing-field-initializers" +#endif + +#ifdef _MSC_VER +#pragma optimize("", off) +#elif defined(__clang__) +#pragma clang optimize off +#elif defined(__GNUC__) +#pragma GCC optimize ("O0") +#endif + +#define LANGUAGE_VERSION 13 +#define STATE_COUNT 820 +#define LARGE_STATE_COUNT 140 +#define SYMBOL_COUNT 283 +#define ALIAS_COUNT 0 +#define TOKEN_COUNT 144 +#define EXTERNAL_TOKEN_COUNT 0 +#define FIELD_COUNT 8 +#define MAX_ALIAS_SEQUENCE_LENGTH 7 +#define PRODUCTION_ID_COUNT 8 + +enum { + anon_sym_use = 1, + anon_sym_SEMI = 2, + anon_sym_EQ = 3, + anon_sym_COLON_COLON = 4, + anon_sym_LBRACE = 5, + anon_sym_RBRACE = 6, + anon_sym_COMMA = 7, + anon_sym_export = 8, + anon_sym_let = 9, + anon_sym_const = 10, + anon_sym_COLON = 11, + anon_sym_ATsymbol = 12, + anon_sym_LPAREN = 13, + anon_sym_RPAREN = 14, + anon_sym_def = 15, + anon_sym_type = 16, + anon_sym_fn = 17, + anon_sym_ATfini = 18, + anon_sym_ATinit = 19, + anon_sym_ATtest = 20, + anon_sym_ATnoreturn = 21, + anon_sym_BANG = 22, + anon_sym_rune = 23, + anon_sym_bool = 24, + anon_sym_void = 25, + anon_sym_i8 = 26, + anon_sym_i16 = 27, + anon_sym_i32 = 28, + anon_sym_i64 = 29, + anon_sym_u8 = 30, + anon_sym_u16 = 31, + anon_sym_u32 = 32, + anon_sym_u64 = 33, + anon_sym_int = 34, + anon_sym_uint = 35, + anon_sym_size = 36, + anon_sym_uintptr = 37, + anon_sym_char = 38, + anon_sym_f32 = 39, + anon_sym_f64 = 40, + anon_sym_enum = 41, + anon_sym_STAR = 42, + anon_sym_nullable = 43, + anon_sym_struct = 44, + anon_sym_union = 45, + anon_sym_AToffset = 46, + anon_sym_PIPE = 47, + anon_sym_LBRACK = 48, + anon_sym_RBRACK = 49, + anon_sym__ = 50, + anon_sym_DOT_DOT_DOT = 51, + anon_sym_true = 52, + anon_sym_false = 53, + anon_sym_null = 54, + anon_sym_0x = 55, + anon_sym_0o = 56, + anon_sym_0b = 57, + anon_sym_0 = 58, + anon_sym_1 = 59, + anon_sym_2 = 60, + anon_sym_3 = 61, + anon_sym_4 = 62, + anon_sym_5 = 63, + anon_sym_6 = 64, + anon_sym_7 = 65, + anon_sym_8 = 66, + anon_sym_9 = 67, + anon_sym_A = 68, + anon_sym_B = 69, + anon_sym_C = 70, + anon_sym_D = 71, + anon_sym_E = 72, + anon_sym_F = 73, + anon_sym_a = 74, + anon_sym_b = 75, + anon_sym_c = 76, + anon_sym_d = 77, + anon_sym_e = 78, + anon_sym_f = 79, + anon_sym_i = 80, + anon_sym_u = 81, + anon_sym_z = 82, + anon_sym_DOT = 83, + anon_sym_SQUOTE = 84, + aux_sym_rune_token1 = 85, + anon_sym_BSLASH = 86, + aux_sym_escape_sequence_token1 = 87, + aux_sym_named_escape_token1 = 88, + anon_sym_DQUOTE = 89, + aux_sym_string_char_token1 = 90, + anon_sym_alloc = 91, + anon_sym_append = 92, + anon_sym_free = 93, + anon_sym_delete = 94, + anon_sym_assert = 95, + anon_sym_static = 96, + anon_sym_abort = 97, + anon_sym_len = 98, + anon_sym_offset = 99, + anon_sym_DOT_DOT = 100, + anon_sym_QMARK = 101, + anon_sym_PLUS = 102, + anon_sym_DASH = 103, + anon_sym_TILDE = 104, + anon_sym_AMP = 105, + anon_sym_as = 106, + anon_sym_is = 107, + anon_sym_SLASH = 108, + anon_sym_PERCENT = 109, + anon_sym_LT_LT = 110, + anon_sym_GT_GT = 111, + anon_sym_CARET = 112, + anon_sym_LT = 113, + anon_sym_GT = 114, + anon_sym_LT_EQ = 115, + anon_sym_GT_EQ = 116, + anon_sym_EQ_EQ = 117, + anon_sym_BANG_EQ = 118, + anon_sym_AMP_AMP = 119, + anon_sym_CARET_CARET = 120, + anon_sym_PIPE_PIPE = 121, + anon_sym_if = 122, + anon_sym_else = 123, + anon_sym_for = 124, + anon_sym_switch = 125, + anon_sym_EQ_GT = 126, + anon_sym_match = 127, + anon_sym_PLUS_EQ = 128, + anon_sym_DASH_EQ = 129, + anon_sym_STAR_EQ = 130, + anon_sym_SLASH_EQ = 131, + anon_sym_PERCENT_EQ = 132, + anon_sym_LT_LT_EQ = 133, + anon_sym_GT_GT_EQ = 134, + anon_sym_AMP_EQ = 135, + anon_sym_PIPE_EQ = 136, + anon_sym_CARET_EQ = 137, + anon_sym_defer = 138, + anon_sym_break = 139, + anon_sym_continue = 140, + anon_sym_return = 141, + sym_name = 142, + sym_comment = 143, + sym_unit = 144, + sym_imports = 145, + sym_use_statement = 146, + sym_name_list = 147, + sym_declarations = 148, + sym_declaration = 149, + sym_global_declaration = 150, + sym_global_bindings = 151, + sym_global_binding = 152, + sym_decl_attr = 153, + sym_constant_declaration = 154, + sym_constant_bindings = 155, + sym_constant_binding = 156, + sym_type_declaration = 157, + sym_type_bindings = 158, + sym_function_declaration = 159, + sym_fndec_attrs = 160, + sym_fndec_attr = 161, + sym_fntype_attr = 162, + sym_type = 163, + sym__inner_type = 164, + sym_storage_class = 165, + sym_scalar_type = 166, + sym_integer_type = 167, + sym_floating_type = 168, + sym_enum_type = 169, + sym_enum_values = 170, + sym_enum_value = 171, + sym_pointer_type = 172, + sym_struct_type = 173, + sym_union_type = 174, + sym_struct_union_fields = 175, + sym_struct_union_field = 176, + sym_offset_specifier = 177, + sym_tuple_type = 178, + sym_tuple_types = 179, + sym_tagged_union_type = 180, + sym_tagged_types = 181, + sym_slice_array_type = 182, + sym_function_type = 183, + sym_prototype = 184, + sym_parameter_list = 185, + sym_parameters = 186, + sym_parameter = 187, + sym_alias_type = 188, + sym_unwrapped_alias = 189, + sym_constant = 190, + sym_integer_constant = 191, + sym_hex_digits = 192, + sym_hex_digit = 193, + sym_octal_digits = 194, + sym_octal_digit = 195, + sym_binary_digits = 196, + sym_binary_digit = 197, + sym_decimal_digits = 198, + sym_decimal_digit = 199, + sym_integer_suffix = 200, + sym_floating_constant = 201, + sym_exponent = 202, + sym_floating_suffix = 203, + sym_rune_constant = 204, + sym_rune = 205, + sym_escape_sequence = 206, + sym_named_escape = 207, + sym_string_constant = 208, + sym_string_chars = 209, + sym_string_char = 210, + sym_array_literal = 211, + sym_array_members = 212, + sym_enum_literal = 213, + sym_struct_literal = 214, + sym_struct_initializer = 215, + sym_field_values = 216, + sym_field_value = 217, + sym_plain_expression = 218, + sym_nested_expression = 219, + sym_tuple_items = 220, + sym_allocation_expression = 221, + sym_append_values = 222, + sym_assertion_expression = 223, + sym_call_expression = 224, + sym_argument_list = 225, + sym_measurement_expression = 226, + sym_size_expression = 227, + sym_length_expression = 228, + sym_offset_expression = 229, + sym_field_access_expression = 230, + sym_indexing_expression = 231, + sym_slicing_expression = 232, + sym_error_propagation = 233, + sym_postfix_expression = 234, + sym_object_selector = 235, + sym_unary_expression = 236, + sym_cast_expression = 237, + sym_multiplicative_expression = 238, + sym_additive_expression = 239, + sym_shift_expression = 240, + sym_and_expression = 241, + sym_exclusive_or_expression = 242, + sym_inclusive_or_expression = 243, + sym_comparison_expression = 244, + sym_equality_expression = 245, + sym_logical_and_expression = 246, + sym_logical_xor_expression = 247, + sym_logical_or_expression = 248, + sym_if_expression = 249, + sym_conditional_branch = 250, + sym_for_loop = 251, + sym_for_predicate = 252, + sym_label = 253, + sym_switch_expression = 254, + sym_switch_cases = 255, + sym_switch_case = 256, + sym_case_options = 257, + sym_match_expression = 258, + sym_match_cases = 259, + sym_match_case = 260, + sym_assignment = 261, + sym_assignment_op = 262, + sym_binding_list = 263, + sym_bindings = 264, + sym_binding = 265, + sym_binding_names = 266, + sym_deferred_expression = 267, + sym_expression_list = 268, + sym_control_statement = 269, + sym_expression = 270, + sym_compound_expression = 271, + sym_identifier = 272, + aux_sym_imports_repeat1 = 273, + aux_sym_declarations_repeat1 = 274, + aux_sym_fndec_attrs_repeat1 = 275, + aux_sym_tagged_types_repeat1 = 276, + aux_sym_hex_digits_repeat1 = 277, + aux_sym_octal_digits_repeat1 = 278, + aux_sym_binary_digits_repeat1 = 279, + aux_sym_decimal_digits_repeat1 = 280, + aux_sym_string_constant_repeat1 = 281, + aux_sym_string_chars_repeat1 = 282, +}; + +static const char *ts_symbol_names[] = { + [ts_builtin_sym_end] = "end", + [anon_sym_use] = "use", + [anon_sym_SEMI] = ";", + [anon_sym_EQ] = "=", + [anon_sym_COLON_COLON] = "::", + [anon_sym_LBRACE] = "{", + [anon_sym_RBRACE] = "}", + [anon_sym_COMMA] = ",", + [anon_sym_export] = "export", + [anon_sym_let] = "let", + [anon_sym_const] = "const", + [anon_sym_COLON] = ":", + [anon_sym_ATsymbol] = "@symbol", + [anon_sym_LPAREN] = "(", + [anon_sym_RPAREN] = ")", + [anon_sym_def] = "def", + [anon_sym_type] = "type", + [anon_sym_fn] = "fn", + [anon_sym_ATfini] = "@fini", + [anon_sym_ATinit] = "@init", + [anon_sym_ATtest] = "@test", + [anon_sym_ATnoreturn] = "@noreturn", + [anon_sym_BANG] = "!", + [anon_sym_rune] = "rune", + [anon_sym_bool] = "bool", + [anon_sym_void] = "void", + [anon_sym_i8] = "i8", + [anon_sym_i16] = "i16", + [anon_sym_i32] = "i32", + [anon_sym_i64] = "i64", + [anon_sym_u8] = "u8", + [anon_sym_u16] = "u16", + [anon_sym_u32] = "u32", + [anon_sym_u64] = "u64", + [anon_sym_int] = "int", + [anon_sym_uint] = "uint", + [anon_sym_size] = "size", + [anon_sym_uintptr] = "uintptr", + [anon_sym_char] = "char", + [anon_sym_f32] = "f32", + [anon_sym_f64] = "f64", + [anon_sym_enum] = "enum", + [anon_sym_STAR] = "*", + [anon_sym_nullable] = "nullable", + [anon_sym_struct] = "struct", + [anon_sym_union] = "union", + [anon_sym_AToffset] = "@offset", + [anon_sym_PIPE] = "|", + [anon_sym_LBRACK] = "[", + [anon_sym_RBRACK] = "]", + [anon_sym__] = "_", + [anon_sym_DOT_DOT_DOT] = "...", + [anon_sym_true] = "true", + [anon_sym_false] = "false", + [anon_sym_null] = "null", + [anon_sym_0x] = "0x", + [anon_sym_0o] = "0o", + [anon_sym_0b] = "0b", + [anon_sym_0] = "0", + [anon_sym_1] = "1", + [anon_sym_2] = "2", + [anon_sym_3] = "3", + [anon_sym_4] = "4", + [anon_sym_5] = "5", + [anon_sym_6] = "6", + [anon_sym_7] = "7", + [anon_sym_8] = "8", + [anon_sym_9] = "9", + [anon_sym_A] = "A", + [anon_sym_B] = "B", + [anon_sym_C] = "C", + [anon_sym_D] = "D", + [anon_sym_E] = "E", + [anon_sym_F] = "F", + [anon_sym_a] = "a", + [anon_sym_b] = "b", + [anon_sym_c] = "c", + [anon_sym_d] = "d", + [anon_sym_e] = "e", + [anon_sym_f] = "f", + [anon_sym_i] = "i", + [anon_sym_u] = "u", + [anon_sym_z] = "z", + [anon_sym_DOT] = ".", + [anon_sym_SQUOTE] = "'", + [aux_sym_rune_token1] = "rune_token1", + [anon_sym_BSLASH] = "\\", + [aux_sym_escape_sequence_token1] = "escape_sequence_token1", + [aux_sym_named_escape_token1] = "named_escape_token1", + [anon_sym_DQUOTE] = "\"", + [aux_sym_string_char_token1] = "string_char_token1", + [anon_sym_alloc] = "alloc", + [anon_sym_append] = "append", + [anon_sym_free] = "free", + [anon_sym_delete] = "delete", + [anon_sym_assert] = "assert", + [anon_sym_static] = "static", + [anon_sym_abort] = "abort", + [anon_sym_len] = "len", + [anon_sym_offset] = "offset", + [anon_sym_DOT_DOT] = "..", + [anon_sym_QMARK] = "\?", + [anon_sym_PLUS] = "+", + [anon_sym_DASH] = "-", + [anon_sym_TILDE] = "~", + [anon_sym_AMP] = "&", + [anon_sym_as] = "as", + [anon_sym_is] = "is", + [anon_sym_SLASH] = "/", + [anon_sym_PERCENT] = "%", + [anon_sym_LT_LT] = "<<", + [anon_sym_GT_GT] = ">>", + [anon_sym_CARET] = "^", + [anon_sym_LT] = "<", + [anon_sym_GT] = ">", + [anon_sym_LT_EQ] = "<=", + [anon_sym_GT_EQ] = ">=", + [anon_sym_EQ_EQ] = "==", + [anon_sym_BANG_EQ] = "!=", + [anon_sym_AMP_AMP] = "&&", + [anon_sym_CARET_CARET] = "^^", + [anon_sym_PIPE_PIPE] = "||", + [anon_sym_if] = "if", + [anon_sym_else] = "else", + [anon_sym_for] = "for", + [anon_sym_switch] = "switch", + [anon_sym_EQ_GT] = "=>", + [anon_sym_match] = "match", + [anon_sym_PLUS_EQ] = "+=", + [anon_sym_DASH_EQ] = "-=", + [anon_sym_STAR_EQ] = "*=", + [anon_sym_SLASH_EQ] = "/=", + [anon_sym_PERCENT_EQ] = "%=", + [anon_sym_LT_LT_EQ] = "<<=", + [anon_sym_GT_GT_EQ] = ">>=", + [anon_sym_AMP_EQ] = "&=", + [anon_sym_PIPE_EQ] = "|=", + [anon_sym_CARET_EQ] = "^=", + [anon_sym_defer] = "defer", + [anon_sym_break] = "break", + [anon_sym_continue] = "continue", + [anon_sym_return] = "return", + [sym_name] = "name", + [sym_comment] = "comment", + [sym_unit] = "unit", + [sym_imports] = "imports", + [sym_use_statement] = "use_statement", + [sym_name_list] = "name_list", + [sym_declarations] = "declarations", + [sym_declaration] = "declaration", + [sym_global_declaration] = "global_declaration", + [sym_global_bindings] = "global_bindings", + [sym_global_binding] = "global_binding", + [sym_decl_attr] = "decl_attr", + [sym_constant_declaration] = "constant_declaration", + [sym_constant_bindings] = "constant_bindings", + [sym_constant_binding] = "constant_binding", + [sym_type_declaration] = "type_declaration", + [sym_type_bindings] = "type_bindings", + [sym_function_declaration] = "function_declaration", + [sym_fndec_attrs] = "fndec_attrs", + [sym_fndec_attr] = "fndec_attr", + [sym_fntype_attr] = "fntype_attr", + [sym_type] = "type", + [sym__inner_type] = "_inner_type", + [sym_storage_class] = "storage_class", + [sym_scalar_type] = "scalar_type", + [sym_integer_type] = "integer_type", + [sym_floating_type] = "floating_type", + [sym_enum_type] = "enum_type", + [sym_enum_values] = "enum_values", + [sym_enum_value] = "enum_value", + [sym_pointer_type] = "pointer_type", + [sym_struct_type] = "struct_type", + [sym_union_type] = "union_type", + [sym_struct_union_fields] = "struct_union_fields", + [sym_struct_union_field] = "struct_union_field", + [sym_offset_specifier] = "offset_specifier", + [sym_tuple_type] = "tuple_type", + [sym_tuple_types] = "tuple_types", + [sym_tagged_union_type] = "tagged_union_type", + [sym_tagged_types] = "tagged_types", + [sym_slice_array_type] = "slice_array_type", + [sym_function_type] = "function_type", + [sym_prototype] = "prototype", + [sym_parameter_list] = "parameter_list", + [sym_parameters] = "parameters", + [sym_parameter] = "parameter", + [sym_alias_type] = "alias_type", + [sym_unwrapped_alias] = "unwrapped_alias", + [sym_constant] = "constant", + [sym_integer_constant] = "integer_constant", + [sym_hex_digits] = "hex_digits", + [sym_hex_digit] = "hex_digit", + [sym_octal_digits] = "octal_digits", + [sym_octal_digit] = "octal_digit", + [sym_binary_digits] = "binary_digits", + [sym_binary_digit] = "binary_digit", + [sym_decimal_digits] = "decimal_digits", + [sym_decimal_digit] = "decimal_digit", + [sym_integer_suffix] = "integer_suffix", + [sym_floating_constant] = "floating_constant", + [sym_exponent] = "exponent", + [sym_floating_suffix] = "floating_suffix", + [sym_rune_constant] = "rune_constant", + [sym_rune] = "rune", + [sym_escape_sequence] = "escape_sequence", + [sym_named_escape] = "named_escape", + [sym_string_constant] = "string_constant", + [sym_string_chars] = "string_chars", + [sym_string_char] = "string_char", + [sym_array_literal] = "array_literal", + [sym_array_members] = "array_members", + [sym_enum_literal] = "enum_literal", + [sym_struct_literal] = "struct_literal", + [sym_struct_initializer] = "struct_initializer", + [sym_field_values] = "field_values", + [sym_field_value] = "field_value", + [sym_plain_expression] = "plain_expression", + [sym_nested_expression] = "nested_expression", + [sym_tuple_items] = "tuple_items", + [sym_allocation_expression] = "allocation_expression", + [sym_append_values] = "append_values", + [sym_assertion_expression] = "assertion_expression", + [sym_call_expression] = "call_expression", + [sym_argument_list] = "argument_list", + [sym_measurement_expression] = "measurement_expression", + [sym_size_expression] = "size_expression", + [sym_length_expression] = "length_expression", + [sym_offset_expression] = "offset_expression", + [sym_field_access_expression] = "field_access_expression", + [sym_indexing_expression] = "indexing_expression", + [sym_slicing_expression] = "slicing_expression", + [sym_error_propagation] = "error_propagation", + [sym_postfix_expression] = "postfix_expression", + [sym_object_selector] = "object_selector", + [sym_unary_expression] = "unary_expression", + [sym_cast_expression] = "cast_expression", + [sym_multiplicative_expression] = "multiplicative_expression", + [sym_additive_expression] = "additive_expression", + [sym_shift_expression] = "shift_expression", + [sym_and_expression] = "and_expression", + [sym_exclusive_or_expression] = "exclusive_or_expression", + [sym_inclusive_or_expression] = "inclusive_or_expression", + [sym_comparison_expression] = "comparison_expression", + [sym_equality_expression] = "equality_expression", + [sym_logical_and_expression] = "logical_and_expression", + [sym_logical_xor_expression] = "logical_xor_expression", + [sym_logical_or_expression] = "logical_or_expression", + [sym_if_expression] = "if_expression", + [sym_conditional_branch] = "conditional_branch", + [sym_for_loop] = "for_loop", + [sym_for_predicate] = "for_predicate", + [sym_label] = "label", + [sym_switch_expression] = "switch_expression", + [sym_switch_cases] = "switch_cases", + [sym_switch_case] = "switch_case", + [sym_case_options] = "case_options", + [sym_match_expression] = "match_expression", + [sym_match_cases] = "match_cases", + [sym_match_case] = "match_case", + [sym_assignment] = "assignment", + [sym_assignment_op] = "assignment_op", + [sym_binding_list] = "binding_list", + [sym_bindings] = "bindings", + [sym_binding] = "binding", + [sym_binding_names] = "binding_names", + [sym_deferred_expression] = "deferred_expression", + [sym_expression_list] = "expression_list", + [sym_control_statement] = "control_statement", + [sym_expression] = "expression", + [sym_compound_expression] = "compound_expression", + [sym_identifier] = "identifier", + [aux_sym_imports_repeat1] = "imports_repeat1", + [aux_sym_declarations_repeat1] = "declarations_repeat1", + [aux_sym_fndec_attrs_repeat1] = "fndec_attrs_repeat1", + [aux_sym_tagged_types_repeat1] = "tagged_types_repeat1", + [aux_sym_hex_digits_repeat1] = "hex_digits_repeat1", + [aux_sym_octal_digits_repeat1] = "octal_digits_repeat1", + [aux_sym_binary_digits_repeat1] = "binary_digits_repeat1", + [aux_sym_decimal_digits_repeat1] = "decimal_digits_repeat1", + [aux_sym_string_constant_repeat1] = "string_constant_repeat1", + [aux_sym_string_chars_repeat1] = "string_chars_repeat1", +}; + +static TSSymbol ts_symbol_map[] = { + [ts_builtin_sym_end] = ts_builtin_sym_end, + [anon_sym_use] = anon_sym_use, + [anon_sym_SEMI] = anon_sym_SEMI, + [anon_sym_EQ] = anon_sym_EQ, + [anon_sym_COLON_COLON] = anon_sym_COLON_COLON, + [anon_sym_LBRACE] = anon_sym_LBRACE, + [anon_sym_RBRACE] = anon_sym_RBRACE, + [anon_sym_COMMA] = anon_sym_COMMA, + [anon_sym_export] = anon_sym_export, + [anon_sym_let] = anon_sym_let, + [anon_sym_const] = anon_sym_const, + [anon_sym_COLON] = anon_sym_COLON, + [anon_sym_ATsymbol] = anon_sym_ATsymbol, + [anon_sym_LPAREN] = anon_sym_LPAREN, + [anon_sym_RPAREN] = anon_sym_RPAREN, + [anon_sym_def] = anon_sym_def, + [anon_sym_type] = anon_sym_type, + [anon_sym_fn] = anon_sym_fn, + [anon_sym_ATfini] = anon_sym_ATfini, + [anon_sym_ATinit] = anon_sym_ATinit, + [anon_sym_ATtest] = anon_sym_ATtest, + [anon_sym_ATnoreturn] = anon_sym_ATnoreturn, + [anon_sym_BANG] = anon_sym_BANG, + [anon_sym_rune] = anon_sym_rune, + [anon_sym_bool] = anon_sym_bool, + [anon_sym_void] = anon_sym_void, + [anon_sym_i8] = anon_sym_i8, + [anon_sym_i16] = anon_sym_i16, + [anon_sym_i32] = anon_sym_i32, + [anon_sym_i64] = anon_sym_i64, + [anon_sym_u8] = anon_sym_u8, + [anon_sym_u16] = anon_sym_u16, + [anon_sym_u32] = anon_sym_u32, + [anon_sym_u64] = anon_sym_u64, + [anon_sym_int] = anon_sym_int, + [anon_sym_uint] = anon_sym_uint, + [anon_sym_size] = anon_sym_size, + [anon_sym_uintptr] = anon_sym_uintptr, + [anon_sym_char] = anon_sym_char, + [anon_sym_f32] = anon_sym_f32, + [anon_sym_f64] = anon_sym_f64, + [anon_sym_enum] = anon_sym_enum, + [anon_sym_STAR] = anon_sym_STAR, + [anon_sym_nullable] = anon_sym_nullable, + [anon_sym_struct] = anon_sym_struct, + [anon_sym_union] = anon_sym_union, + [anon_sym_AToffset] = anon_sym_AToffset, + [anon_sym_PIPE] = anon_sym_PIPE, + [anon_sym_LBRACK] = anon_sym_LBRACK, + [anon_sym_RBRACK] = anon_sym_RBRACK, + [anon_sym__] = anon_sym__, + [anon_sym_DOT_DOT_DOT] = anon_sym_DOT_DOT_DOT, + [anon_sym_true] = anon_sym_true, + [anon_sym_false] = anon_sym_false, + [anon_sym_null] = anon_sym_null, + [anon_sym_0x] = anon_sym_0x, + [anon_sym_0o] = anon_sym_0o, + [anon_sym_0b] = anon_sym_0b, + [anon_sym_0] = anon_sym_0, + [anon_sym_1] = anon_sym_1, + [anon_sym_2] = anon_sym_2, + [anon_sym_3] = anon_sym_3, + [anon_sym_4] = anon_sym_4, + [anon_sym_5] = anon_sym_5, + [anon_sym_6] = anon_sym_6, + [anon_sym_7] = anon_sym_7, + [anon_sym_8] = anon_sym_8, + [anon_sym_9] = anon_sym_9, + [anon_sym_A] = anon_sym_A, + [anon_sym_B] = anon_sym_B, + [anon_sym_C] = anon_sym_C, + [anon_sym_D] = anon_sym_D, + [anon_sym_E] = anon_sym_E, + [anon_sym_F] = anon_sym_F, + [anon_sym_a] = anon_sym_a, + [anon_sym_b] = anon_sym_b, + [anon_sym_c] = anon_sym_c, + [anon_sym_d] = anon_sym_d, + [anon_sym_e] = anon_sym_e, + [anon_sym_f] = anon_sym_f, + [anon_sym_i] = anon_sym_i, + [anon_sym_u] = anon_sym_u, + [anon_sym_z] = anon_sym_z, + [anon_sym_DOT] = anon_sym_DOT, + [anon_sym_SQUOTE] = anon_sym_SQUOTE, + [aux_sym_rune_token1] = aux_sym_rune_token1, + [anon_sym_BSLASH] = anon_sym_BSLASH, + [aux_sym_escape_sequence_token1] = aux_sym_escape_sequence_token1, + [aux_sym_named_escape_token1] = aux_sym_named_escape_token1, + [anon_sym_DQUOTE] = anon_sym_DQUOTE, + [aux_sym_string_char_token1] = aux_sym_string_char_token1, + [anon_sym_alloc] = anon_sym_alloc, + [anon_sym_append] = anon_sym_append, + [anon_sym_free] = anon_sym_free, + [anon_sym_delete] = anon_sym_delete, + [anon_sym_assert] = anon_sym_assert, + [anon_sym_static] = anon_sym_static, + [anon_sym_abort] = anon_sym_abort, + [anon_sym_len] = anon_sym_len, + [anon_sym_offset] = anon_sym_offset, + [anon_sym_DOT_DOT] = anon_sym_DOT_DOT, + [anon_sym_QMARK] = anon_sym_QMARK, + [anon_sym_PLUS] = anon_sym_PLUS, + [anon_sym_DASH] = anon_sym_DASH, + [anon_sym_TILDE] = anon_sym_TILDE, + [anon_sym_AMP] = anon_sym_AMP, + [anon_sym_as] = anon_sym_as, + [anon_sym_is] = anon_sym_is, + [anon_sym_SLASH] = anon_sym_SLASH, + [anon_sym_PERCENT] = anon_sym_PERCENT, + [anon_sym_LT_LT] = anon_sym_LT_LT, + [anon_sym_GT_GT] = anon_sym_GT_GT, + [anon_sym_CARET] = anon_sym_CARET, + [anon_sym_LT] = anon_sym_LT, + [anon_sym_GT] = anon_sym_GT, + [anon_sym_LT_EQ] = anon_sym_LT_EQ, + [anon_sym_GT_EQ] = anon_sym_GT_EQ, + [anon_sym_EQ_EQ] = anon_sym_EQ_EQ, + [anon_sym_BANG_EQ] = anon_sym_BANG_EQ, + [anon_sym_AMP_AMP] = anon_sym_AMP_AMP, + [anon_sym_CARET_CARET] = anon_sym_CARET_CARET, + [anon_sym_PIPE_PIPE] = anon_sym_PIPE_PIPE, + [anon_sym_if] = anon_sym_if, + [anon_sym_else] = anon_sym_else, + [anon_sym_for] = anon_sym_for, + [anon_sym_switch] = anon_sym_switch, + [anon_sym_EQ_GT] = anon_sym_EQ_GT, + [anon_sym_match] = anon_sym_match, + [anon_sym_PLUS_EQ] = anon_sym_PLUS_EQ, + [anon_sym_DASH_EQ] = anon_sym_DASH_EQ, + [anon_sym_STAR_EQ] = anon_sym_STAR_EQ, + [anon_sym_SLASH_EQ] = anon_sym_SLASH_EQ, + [anon_sym_PERCENT_EQ] = anon_sym_PERCENT_EQ, + [anon_sym_LT_LT_EQ] = anon_sym_LT_LT_EQ, + [anon_sym_GT_GT_EQ] = anon_sym_GT_GT_EQ, + [anon_sym_AMP_EQ] = anon_sym_AMP_EQ, + [anon_sym_PIPE_EQ] = anon_sym_PIPE_EQ, + [anon_sym_CARET_EQ] = anon_sym_CARET_EQ, + [anon_sym_defer] = anon_sym_defer, + [anon_sym_break] = anon_sym_break, + [anon_sym_continue] = anon_sym_continue, + [anon_sym_return] = anon_sym_return, + [sym_name] = sym_name, + [sym_comment] = sym_comment, + [sym_unit] = sym_unit, + [sym_imports] = sym_imports, + [sym_use_statement] = sym_use_statement, + [sym_name_list] = sym_name_list, + [sym_declarations] = sym_declarations, + [sym_declaration] = sym_declaration, + [sym_global_declaration] = sym_global_declaration, + [sym_global_bindings] = sym_global_bindings, + [sym_global_binding] = sym_global_binding, + [sym_decl_attr] = sym_decl_attr, + [sym_constant_declaration] = sym_constant_declaration, + [sym_constant_bindings] = sym_constant_bindings, + [sym_constant_binding] = sym_constant_binding, + [sym_type_declaration] = sym_type_declaration, + [sym_type_bindings] = sym_type_bindings, + [sym_function_declaration] = sym_function_declaration, + [sym_fndec_attrs] = sym_fndec_attrs, + [sym_fndec_attr] = sym_fndec_attr, + [sym_fntype_attr] = sym_fntype_attr, + [sym_type] = sym_type, + [sym__inner_type] = sym__inner_type, + [sym_storage_class] = sym_storage_class, + [sym_scalar_type] = sym_scalar_type, + [sym_integer_type] = sym_integer_type, + [sym_floating_type] = sym_floating_type, + [sym_enum_type] = sym_enum_type, + [sym_enum_values] = sym_enum_values, + [sym_enum_value] = sym_enum_value, + [sym_pointer_type] = sym_pointer_type, + [sym_struct_type] = sym_struct_type, + [sym_union_type] = sym_union_type, + [sym_struct_union_fields] = sym_struct_union_fields, + [sym_struct_union_field] = sym_struct_union_field, + [sym_offset_specifier] = sym_offset_specifier, + [sym_tuple_type] = sym_tuple_type, + [sym_tuple_types] = sym_tuple_types, + [sym_tagged_union_type] = sym_tagged_union_type, + [sym_tagged_types] = sym_tagged_types, + [sym_slice_array_type] = sym_slice_array_type, + [sym_function_type] = sym_function_type, + [sym_prototype] = sym_prototype, + [sym_parameter_list] = sym_parameter_list, + [sym_parameters] = sym_parameters, + [sym_parameter] = sym_parameter, + [sym_alias_type] = sym_alias_type, + [sym_unwrapped_alias] = sym_unwrapped_alias, + [sym_constant] = sym_constant, + [sym_integer_constant] = sym_integer_constant, + [sym_hex_digits] = sym_hex_digits, + [sym_hex_digit] = sym_hex_digit, + [sym_octal_digits] = sym_octal_digits, + [sym_octal_digit] = sym_octal_digit, + [sym_binary_digits] = sym_binary_digits, + [sym_binary_digit] = sym_binary_digit, + [sym_decimal_digits] = sym_decimal_digits, + [sym_decimal_digit] = sym_decimal_digit, + [sym_integer_suffix] = sym_integer_suffix, + [sym_floating_constant] = sym_floating_constant, + [sym_exponent] = sym_exponent, + [sym_floating_suffix] = sym_floating_suffix, + [sym_rune_constant] = sym_rune_constant, + [sym_rune] = sym_rune, + [sym_escape_sequence] = sym_escape_sequence, + [sym_named_escape] = sym_named_escape, + [sym_string_constant] = sym_string_constant, + [sym_string_chars] = sym_string_chars, + [sym_string_char] = sym_string_char, + [sym_array_literal] = sym_array_literal, + [sym_array_members] = sym_array_members, + [sym_enum_literal] = sym_enum_literal, + [sym_struct_literal] = sym_struct_literal, + [sym_struct_initializer] = sym_struct_initializer, + [sym_field_values] = sym_field_values, + [sym_field_value] = sym_field_value, + [sym_plain_expression] = sym_plain_expression, + [sym_nested_expression] = sym_nested_expression, + [sym_tuple_items] = sym_tuple_items, + [sym_allocation_expression] = sym_allocation_expression, + [sym_append_values] = sym_append_values, + [sym_assertion_expression] = sym_assertion_expression, + [sym_call_expression] = sym_call_expression, + [sym_argument_list] = sym_argument_list, + [sym_measurement_expression] = sym_measurement_expression, + [sym_size_expression] = sym_size_expression, + [sym_length_expression] = sym_length_expression, + [sym_offset_expression] = sym_offset_expression, + [sym_field_access_expression] = sym_field_access_expression, + [sym_indexing_expression] = sym_indexing_expression, + [sym_slicing_expression] = sym_slicing_expression, + [sym_error_propagation] = sym_error_propagation, + [sym_postfix_expression] = sym_postfix_expression, + [sym_object_selector] = sym_object_selector, + [sym_unary_expression] = sym_unary_expression, + [sym_cast_expression] = sym_cast_expression, + [sym_multiplicative_expression] = sym_multiplicative_expression, + [sym_additive_expression] = sym_additive_expression, + [sym_shift_expression] = sym_shift_expression, + [sym_and_expression] = sym_and_expression, + [sym_exclusive_or_expression] = sym_exclusive_or_expression, + [sym_inclusive_or_expression] = sym_inclusive_or_expression, + [sym_comparison_expression] = sym_comparison_expression, + [sym_equality_expression] = sym_equality_expression, + [sym_logical_and_expression] = sym_logical_and_expression, + [sym_logical_xor_expression] = sym_logical_xor_expression, + [sym_logical_or_expression] = sym_logical_or_expression, + [sym_if_expression] = sym_if_expression, + [sym_conditional_branch] = sym_conditional_branch, + [sym_for_loop] = sym_for_loop, + [sym_for_predicate] = sym_for_predicate, + [sym_label] = sym_label, + [sym_switch_expression] = sym_switch_expression, + [sym_switch_cases] = sym_switch_cases, + [sym_switch_case] = sym_switch_case, + [sym_case_options] = sym_case_options, + [sym_match_expression] = sym_match_expression, + [sym_match_cases] = sym_match_cases, + [sym_match_case] = sym_match_case, + [sym_assignment] = sym_assignment, + [sym_assignment_op] = sym_assignment_op, + [sym_binding_list] = sym_binding_list, + [sym_bindings] = sym_bindings, + [sym_binding] = sym_binding, + [sym_binding_names] = sym_binding_names, + [sym_deferred_expression] = sym_deferred_expression, + [sym_expression_list] = sym_expression_list, + [sym_control_statement] = sym_control_statement, + [sym_expression] = sym_expression, + [sym_compound_expression] = sym_compound_expression, + [sym_identifier] = sym_identifier, + [aux_sym_imports_repeat1] = aux_sym_imports_repeat1, + [aux_sym_declarations_repeat1] = aux_sym_declarations_repeat1, + [aux_sym_fndec_attrs_repeat1] = aux_sym_fndec_attrs_repeat1, + [aux_sym_tagged_types_repeat1] = aux_sym_tagged_types_repeat1, + [aux_sym_hex_digits_repeat1] = aux_sym_hex_digits_repeat1, + [aux_sym_octal_digits_repeat1] = aux_sym_octal_digits_repeat1, + [aux_sym_binary_digits_repeat1] = aux_sym_binary_digits_repeat1, + [aux_sym_decimal_digits_repeat1] = aux_sym_decimal_digits_repeat1, + [aux_sym_string_constant_repeat1] = aux_sym_string_constant_repeat1, + [aux_sym_string_chars_repeat1] = aux_sym_string_chars_repeat1, +}; + +static const TSSymbolMetadata ts_symbol_metadata[] = { + [ts_builtin_sym_end] = { + .visible = false, + .named = true, + }, + [anon_sym_use] = { + .visible = true, + .named = false, + }, + [anon_sym_SEMI] = { + .visible = true, + .named = false, + }, + [anon_sym_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_COLON_COLON] = { + .visible = true, + .named = false, + }, + [anon_sym_LBRACE] = { + .visible = true, + .named = false, + }, + [anon_sym_RBRACE] = { + .visible = true, + .named = false, + }, + [anon_sym_COMMA] = { + .visible = true, + .named = false, + }, + [anon_sym_export] = { + .visible = true, + .named = false, + }, + [anon_sym_let] = { + .visible = true, + .named = false, + }, + [anon_sym_const] = { + .visible = true, + .named = false, + }, + [anon_sym_COLON] = { + .visible = true, + .named = false, + }, + [anon_sym_ATsymbol] = { + .visible = true, + .named = false, + }, + [anon_sym_LPAREN] = { + .visible = true, + .named = false, + }, + [anon_sym_RPAREN] = { + .visible = true, + .named = false, + }, + [anon_sym_def] = { + .visible = true, + .named = false, + }, + [anon_sym_type] = { + .visible = true, + .named = false, + }, + [anon_sym_fn] = { + .visible = true, + .named = false, + }, + [anon_sym_ATfini] = { + .visible = true, + .named = false, + }, + [anon_sym_ATinit] = { + .visible = true, + .named = false, + }, + [anon_sym_ATtest] = { + .visible = true, + .named = false, + }, + [anon_sym_ATnoreturn] = { + .visible = true, + .named = false, + }, + [anon_sym_BANG] = { + .visible = true, + .named = false, + }, + [anon_sym_rune] = { + .visible = true, + .named = false, + }, + [anon_sym_bool] = { + .visible = true, + .named = false, + }, + [anon_sym_void] = { + .visible = true, + .named = false, + }, + [anon_sym_i8] = { + .visible = true, + .named = false, + }, + [anon_sym_i16] = { + .visible = true, + .named = false, + }, + [anon_sym_i32] = { + .visible = true, + .named = false, + }, + [anon_sym_i64] = { + .visible = true, + .named = false, + }, + [anon_sym_u8] = { + .visible = true, + .named = false, + }, + [anon_sym_u16] = { + .visible = true, + .named = false, + }, + [anon_sym_u32] = { + .visible = true, + .named = false, + }, + [anon_sym_u64] = { + .visible = true, + .named = false, + }, + [anon_sym_int] = { + .visible = true, + .named = false, + }, + [anon_sym_uint] = { + .visible = true, + .named = false, + }, + [anon_sym_size] = { + .visible = true, + .named = false, + }, + [anon_sym_uintptr] = { + .visible = true, + .named = false, + }, + [anon_sym_char] = { + .visible = true, + .named = false, + }, + [anon_sym_f32] = { + .visible = true, + .named = false, + }, + [anon_sym_f64] = { + .visible = true, + .named = false, + }, + [anon_sym_enum] = { + .visible = true, + .named = false, + }, + [anon_sym_STAR] = { + .visible = true, + .named = false, + }, + [anon_sym_nullable] = { + .visible = true, + .named = false, + }, + [anon_sym_struct] = { + .visible = true, + .named = false, + }, + [anon_sym_union] = { + .visible = true, + .named = false, + }, + [anon_sym_AToffset] = { + .visible = true, + .named = false, + }, + [anon_sym_PIPE] = { + .visible = true, + .named = false, + }, + [anon_sym_LBRACK] = { + .visible = true, + .named = false, + }, + [anon_sym_RBRACK] = { + .visible = true, + .named = false, + }, + [anon_sym__] = { + .visible = true, + .named = false, + }, + [anon_sym_DOT_DOT_DOT] = { + .visible = true, + .named = false, + }, + [anon_sym_true] = { + .visible = true, + .named = false, + }, + [anon_sym_false] = { + .visible = true, + .named = false, + }, + [anon_sym_null] = { + .visible = true, + .named = false, + }, + [anon_sym_0x] = { + .visible = true, + .named = false, + }, + [anon_sym_0o] = { + .visible = true, + .named = false, + }, + [anon_sym_0b] = { + .visible = true, + .named = false, + }, + [anon_sym_0] = { + .visible = true, + .named = false, + }, + [anon_sym_1] = { + .visible = true, + .named = false, + }, + [anon_sym_2] = { + .visible = true, + .named = false, + }, + [anon_sym_3] = { + .visible = true, + .named = false, + }, + [anon_sym_4] = { + .visible = true, + .named = false, + }, + [anon_sym_5] = { + .visible = true, + .named = false, + }, + [anon_sym_6] = { + .visible = true, + .named = false, + }, + [anon_sym_7] = { + .visible = true, + .named = false, + }, + [anon_sym_8] = { + .visible = true, + .named = false, + }, + [anon_sym_9] = { + .visible = true, + .named = false, + }, + [anon_sym_A] = { + .visible = true, + .named = false, + }, + [anon_sym_B] = { + .visible = true, + .named = false, + }, + [anon_sym_C] = { + .visible = true, + .named = false, + }, + [anon_sym_D] = { + .visible = true, + .named = false, + }, + [anon_sym_E] = { + .visible = true, + .named = false, + }, + [anon_sym_F] = { + .visible = true, + .named = false, + }, + [anon_sym_a] = { + .visible = true, + .named = false, + }, + [anon_sym_b] = { + .visible = true, + .named = false, + }, + [anon_sym_c] = { + .visible = true, + .named = false, + }, + [anon_sym_d] = { + .visible = true, + .named = false, + }, + [anon_sym_e] = { + .visible = true, + .named = false, + }, + [anon_sym_f] = { + .visible = true, + .named = false, + }, + [anon_sym_i] = { + .visible = true, + .named = false, + }, + [anon_sym_u] = { + .visible = true, + .named = false, + }, + [anon_sym_z] = { + .visible = true, + .named = false, + }, + [anon_sym_DOT] = { + .visible = true, + .named = false, + }, + [anon_sym_SQUOTE] = { + .visible = true, + .named = false, + }, + [aux_sym_rune_token1] = { + .visible = false, + .named = false, + }, + [anon_sym_BSLASH] = { + .visible = true, + .named = false, + }, + [aux_sym_escape_sequence_token1] = { + .visible = false, + .named = false, + }, + [aux_sym_named_escape_token1] = { + .visible = false, + .named = false, + }, + [anon_sym_DQUOTE] = { + .visible = true, + .named = false, + }, + [aux_sym_string_char_token1] = { + .visible = false, + .named = false, + }, + [anon_sym_alloc] = { + .visible = true, + .named = false, + }, + [anon_sym_append] = { + .visible = true, + .named = false, + }, + [anon_sym_free] = { + .visible = true, + .named = false, + }, + [anon_sym_delete] = { + .visible = true, + .named = false, + }, + [anon_sym_assert] = { + .visible = true, + .named = false, + }, + [anon_sym_static] = { + .visible = true, + .named = false, + }, + [anon_sym_abort] = { + .visible = true, + .named = false, + }, + [anon_sym_len] = { + .visible = true, + .named = false, + }, + [anon_sym_offset] = { + .visible = true, + .named = false, + }, + [anon_sym_DOT_DOT] = { + .visible = true, + .named = false, + }, + [anon_sym_QMARK] = { + .visible = true, + .named = false, + }, + [anon_sym_PLUS] = { + .visible = true, + .named = false, + }, + [anon_sym_DASH] = { + .visible = true, + .named = false, + }, + [anon_sym_TILDE] = { + .visible = true, + .named = false, + }, + [anon_sym_AMP] = { + .visible = true, + .named = false, + }, + [anon_sym_as] = { + .visible = true, + .named = false, + }, + [anon_sym_is] = { + .visible = true, + .named = false, + }, + [anon_sym_SLASH] = { + .visible = true, + .named = false, + }, + [anon_sym_PERCENT] = { + .visible = true, + .named = false, + }, + [anon_sym_LT_LT] = { + .visible = true, + .named = false, + }, + [anon_sym_GT_GT] = { + .visible = true, + .named = false, + }, + [anon_sym_CARET] = { + .visible = true, + .named = false, + }, + [anon_sym_LT] = { + .visible = true, + .named = false, + }, + [anon_sym_GT] = { + .visible = true, + .named = false, + }, + [anon_sym_LT_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_GT_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_EQ_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_BANG_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_AMP_AMP] = { + .visible = true, + .named = false, + }, + [anon_sym_CARET_CARET] = { + .visible = true, + .named = false, + }, + [anon_sym_PIPE_PIPE] = { + .visible = true, + .named = false, + }, + [anon_sym_if] = { + .visible = true, + .named = false, + }, + [anon_sym_else] = { + .visible = true, + .named = false, + }, + [anon_sym_for] = { + .visible = true, + .named = false, + }, + [anon_sym_switch] = { + .visible = true, + .named = false, + }, + [anon_sym_EQ_GT] = { + .visible = true, + .named = false, + }, + [anon_sym_match] = { + .visible = true, + .named = false, + }, + [anon_sym_PLUS_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_DASH_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_STAR_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_SLASH_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_PERCENT_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_LT_LT_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_GT_GT_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_AMP_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_PIPE_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_CARET_EQ] = { + .visible = true, + .named = false, + }, + [anon_sym_defer] = { + .visible = true, + .named = false, + }, + [anon_sym_break] = { + .visible = true, + .named = false, + }, + [anon_sym_continue] = { + .visible = true, + .named = false, + }, + [anon_sym_return] = { + .visible = true, + .named = false, + }, + [sym_name] = { + .visible = true, + .named = true, + }, + [sym_comment] = { + .visible = true, + .named = true, + }, + [sym_unit] = { + .visible = true, + .named = true, + }, + [sym_imports] = { + .visible = true, + .named = true, + }, + [sym_use_statement] = { + .visible = true, + .named = true, + }, + [sym_name_list] = { + .visible = true, + .named = true, + }, + [sym_declarations] = { + .visible = true, + .named = true, + }, + [sym_declaration] = { + .visible = true, + .named = true, + }, + [sym_global_declaration] = { + .visible = true, + .named = true, + }, + [sym_global_bindings] = { + .visible = true, + .named = true, + }, + [sym_global_binding] = { + .visible = true, + .named = true, + }, + [sym_decl_attr] = { + .visible = true, + .named = true, + }, + [sym_constant_declaration] = { + .visible = true, + .named = true, + }, + [sym_constant_bindings] = { + .visible = true, + .named = true, + }, + [sym_constant_binding] = { + .visible = true, + .named = true, + }, + [sym_type_declaration] = { + .visible = true, + .named = true, + }, + [sym_type_bindings] = { + .visible = true, + .named = true, + }, + [sym_function_declaration] = { + .visible = true, + .named = true, + }, + [sym_fndec_attrs] = { + .visible = true, + .named = true, + }, + [sym_fndec_attr] = { + .visible = true, + .named = true, + }, + [sym_fntype_attr] = { + .visible = true, + .named = true, + }, + [sym_type] = { + .visible = true, + .named = true, + }, + [sym__inner_type] = { + .visible = false, + .named = true, + }, + [sym_storage_class] = { + .visible = true, + .named = true, + }, + [sym_scalar_type] = { + .visible = true, + .named = true, + }, + [sym_integer_type] = { + .visible = true, + .named = true, + }, + [sym_floating_type] = { + .visible = true, + .named = true, + }, + [sym_enum_type] = { + .visible = true, + .named = true, + }, + [sym_enum_values] = { + .visible = true, + .named = true, + }, + [sym_enum_value] = { + .visible = true, + .named = true, + }, + [sym_pointer_type] = { + .visible = true, + .named = true, + }, + [sym_struct_type] = { + .visible = true, + .named = true, + }, + [sym_union_type] = { + .visible = true, + .named = true, + }, + [sym_struct_union_fields] = { + .visible = true, + .named = true, + }, + [sym_struct_union_field] = { + .visible = true, + .named = true, + }, + [sym_offset_specifier] = { + .visible = true, + .named = true, + }, + [sym_tuple_type] = { + .visible = true, + .named = true, + }, + [sym_tuple_types] = { + .visible = true, + .named = true, + }, + [sym_tagged_union_type] = { + .visible = true, + .named = true, + }, + [sym_tagged_types] = { + .visible = true, + .named = true, + }, + [sym_slice_array_type] = { + .visible = true, + .named = true, + }, + [sym_function_type] = { + .visible = true, + .named = true, + }, + [sym_prototype] = { + .visible = true, + .named = true, + }, + [sym_parameter_list] = { + .visible = true, + .named = true, + }, + [sym_parameters] = { + .visible = true, + .named = true, + }, + [sym_parameter] = { + .visible = true, + .named = true, + }, + [sym_alias_type] = { + .visible = true, + .named = true, + }, + [sym_unwrapped_alias] = { + .visible = true, + .named = true, + }, + [sym_constant] = { + .visible = true, + .named = true, + }, + [sym_integer_constant] = { + .visible = true, + .named = true, + }, + [sym_hex_digits] = { + .visible = true, + .named = true, + }, + [sym_hex_digit] = { + .visible = true, + .named = true, + }, + [sym_octal_digits] = { + .visible = true, + .named = true, + }, + [sym_octal_digit] = { + .visible = true, + .named = true, + }, + [sym_binary_digits] = { + .visible = true, + .named = true, + }, + [sym_binary_digit] = { + .visible = true, + .named = true, + }, + [sym_decimal_digits] = { + .visible = true, + .named = true, + }, + [sym_decimal_digit] = { + .visible = true, + .named = true, + }, + [sym_integer_suffix] = { + .visible = true, + .named = true, + }, + [sym_floating_constant] = { + .visible = true, + .named = true, + }, + [sym_exponent] = { + .visible = true, + .named = true, + }, + [sym_floating_suffix] = { + .visible = true, + .named = true, + }, + [sym_rune_constant] = { + .visible = true, + .named = true, + }, + [sym_rune] = { + .visible = true, + .named = true, + }, + [sym_escape_sequence] = { + .visible = true, + .named = true, + }, + [sym_named_escape] = { + .visible = true, + .named = true, + }, + [sym_string_constant] = { + .visible = true, + .named = true, + }, + [sym_string_chars] = { + .visible = true, + .named = true, + }, + [sym_string_char] = { + .visible = true, + .named = true, + }, + [sym_array_literal] = { + .visible = true, + .named = true, + }, + [sym_array_members] = { + .visible = true, + .named = true, + }, + [sym_enum_literal] = { + .visible = true, + .named = true, + }, + [sym_struct_literal] = { + .visible = true, + .named = true, + }, + [sym_struct_initializer] = { + .visible = true, + .named = true, + }, + [sym_field_values] = { + .visible = true, + .named = true, + }, + [sym_field_value] = { + .visible = true, + .named = true, + }, + [sym_plain_expression] = { + .visible = true, + .named = true, + }, + [sym_nested_expression] = { + .visible = true, + .named = true, + }, + [sym_tuple_items] = { + .visible = true, + .named = true, + }, + [sym_allocation_expression] = { + .visible = true, + .named = true, + }, + [sym_append_values] = { + .visible = true, + .named = true, + }, + [sym_assertion_expression] = { + .visible = true, + .named = true, + }, + [sym_call_expression] = { + .visible = true, + .named = true, + }, + [sym_argument_list] = { + .visible = true, + .named = true, + }, + [sym_measurement_expression] = { + .visible = true, + .named = true, + }, + [sym_size_expression] = { + .visible = true, + .named = true, + }, + [sym_length_expression] = { + .visible = true, + .named = true, + }, + [sym_offset_expression] = { + .visible = true, + .named = true, + }, + [sym_field_access_expression] = { + .visible = true, + .named = true, + }, + [sym_indexing_expression] = { + .visible = true, + .named = true, + }, + [sym_slicing_expression] = { + .visible = true, + .named = true, + }, + [sym_error_propagation] = { + .visible = true, + .named = true, + }, + [sym_postfix_expression] = { + .visible = true, + .named = true, + }, + [sym_object_selector] = { + .visible = true, + .named = true, + }, + [sym_unary_expression] = { + .visible = true, + .named = true, + }, + [sym_cast_expression] = { + .visible = true, + .named = true, + }, + [sym_multiplicative_expression] = { + .visible = true, + .named = true, + }, + [sym_additive_expression] = { + .visible = true, + .named = true, + }, + [sym_shift_expression] = { + .visible = true, + .named = true, + }, + [sym_and_expression] = { + .visible = true, + .named = true, + }, + [sym_exclusive_or_expression] = { + .visible = true, + .named = true, + }, + [sym_inclusive_or_expression] = { + .visible = true, + .named = true, + }, + [sym_comparison_expression] = { + .visible = true, + .named = true, + }, + [sym_equality_expression] = { + .visible = true, + .named = true, + }, + [sym_logical_and_expression] = { + .visible = true, + .named = true, + }, + [sym_logical_xor_expression] = { + .visible = true, + .named = true, + }, + [sym_logical_or_expression] = { + .visible = true, + .named = true, + }, + [sym_if_expression] = { + .visible = true, + .named = true, + }, + [sym_conditional_branch] = { + .visible = true, + .named = true, + }, + [sym_for_loop] = { + .visible = true, + .named = true, + }, + [sym_for_predicate] = { + .visible = true, + .named = true, + }, + [sym_label] = { + .visible = true, + .named = true, + }, + [sym_switch_expression] = { + .visible = true, + .named = true, + }, + [sym_switch_cases] = { + .visible = true, + .named = true, + }, + [sym_switch_case] = { + .visible = true, + .named = true, + }, + [sym_case_options] = { + .visible = true, + .named = true, + }, + [sym_match_expression] = { + .visible = true, + .named = true, + }, + [sym_match_cases] = { + .visible = true, + .named = true, + }, + [sym_match_case] = { + .visible = true, + .named = true, + }, + [sym_assignment] = { + .visible = true, + .named = true, + }, + [sym_assignment_op] = { + .visible = true, + .named = true, + }, + [sym_binding_list] = { + .visible = true, + .named = true, + }, + [sym_bindings] = { + .visible = true, + .named = true, + }, + [sym_binding] = { + .visible = true, + .named = true, + }, + [sym_binding_names] = { + .visible = true, + .named = true, + }, + [sym_deferred_expression] = { + .visible = true, + .named = true, + }, + [sym_expression_list] = { + .visible = true, + .named = true, + }, + [sym_control_statement] = { + .visible = true, + .named = true, + }, + [sym_expression] = { + .visible = true, + .named = true, + }, + [sym_compound_expression] = { + .visible = true, + .named = true, + }, + [sym_identifier] = { + .visible = true, + .named = true, + }, + [aux_sym_imports_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_declarations_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_fndec_attrs_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_tagged_types_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_hex_digits_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_octal_digits_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_binary_digits_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_decimal_digits_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_string_constant_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_string_chars_repeat1] = { + .visible = false, + .named = false, + }, +}; + +enum { + field_address = 1, + field_afterthought = 2, + field_argument = 3, + field_as_cast = 4, + field_binding = 5, + field_is_cast = 6, + field_operator = 7, + field_type_cast = 8, +}; + +static const char *ts_field_names[] = { + [0] = NULL, + [field_address] = "address", + [field_afterthought] = "afterthought", + [field_argument] = "argument", + [field_as_cast] = "as_cast", + [field_binding] = "binding", + [field_is_cast] = "is_cast", + [field_operator] = "operator", + [field_type_cast] = "type_cast", +}; + +static const TSFieldMapSlice ts_field_map_slices[PRODUCTION_ID_COUNT] = { + [1] = {.index = 0, .length = 2}, + [2] = {.index = 2, .length = 2}, + [3] = {.index = 4, .length = 3}, + [4] = {.index = 7, .length = 3}, + [5] = {.index = 10, .length = 3}, + [6] = {.index = 13, .length = 1}, + [7] = {.index = 14, .length = 1}, +}; + +static const TSFieldMapEntry ts_field_map_entries[] = { + [0] = + {field_argument, 1}, + {field_operator, 0}, + [2] = + {field_address, 0}, + {field_argument, 1}, + [4] = + {field_type_cast, 0}, + {field_type_cast, 1}, + {field_type_cast, 2}, + [7] = + {field_as_cast, 0}, + {field_as_cast, 1}, + {field_as_cast, 2}, + [10] = + {field_is_cast, 0}, + {field_is_cast, 1}, + {field_is_cast, 2}, + [13] = + {field_binding, 0}, + [14] = + {field_afterthought, 2}, +}; + +static TSSymbol ts_alias_sequences[PRODUCTION_ID_COUNT][MAX_ALIAS_SEQUENCE_LENGTH] = { + [0] = {0}, +}; + +static uint16_t ts_non_terminal_alias_map[] = { + 0, +}; + +static inline bool aux_sym_named_escape_token1_character_set_1(int32_t c) { + return (c < 'f' + ? (c < '0' + ? (c < '\'' + ? c == '"' + : c <= '\'') + : (c <= '0' || (c >= 'a' && c <= 'b'))) + : (c <= 'f' || (c < 't' + ? (c < 'r' + ? c == 'n' + : c <= 'r') + : (c <= 't' || c == 'v')))); +} + +static bool ts_lex(TSLexer *lexer, TSStateId state) { + START_LEXER(); + eof = lexer->eof(lexer); + switch (state) { + case 0: + if (eof) ADVANCE(236); + if (lookahead == '!') ADVANCE(265); + if (lookahead == '"') ADVANCE(370); + if (lookahead == '%') ADVANCE(405); + if (lookahead == '&') ADVANCE(399); + if (lookahead == '\'') ADVANCE(364); + if (lookahead == '(') ADVANCE(254); + if (lookahead == ')') ADVANCE(255); + if (lookahead == '*') ADVANCE(305); + if (lookahead == '+') ADVANCE(393); + if (lookahead == ',') ADVANCE(245); + if (lookahead == '-') ADVANCE(395); + if (lookahead == '.') ADVANCE(361); + if (lookahead == '/') ADVANCE(403); + if (lookahead == '0') ADVANCE(329); + if (lookahead == '1') ADVANCE(330); + if (lookahead == '2') ADVANCE(331); + if (lookahead == '3') ADVANCE(332); + if (lookahead == '4') ADVANCE(333); + if (lookahead == '5') ADVANCE(334); + if (lookahead == '6') ADVANCE(335); + if (lookahead == '7') ADVANCE(336); + if (lookahead == '8') ADVANCE(337); + if (lookahead == '9') ADVANCE(338); + if (lookahead == ':') ADVANCE(252); + if (lookahead == ';') ADVANCE(238); + if (lookahead == '<') ADVANCE(412); + if (lookahead == '=') ADVANCE(240); + if (lookahead == '>') ADVANCE(414); + if (lookahead == '?') ADVANCE(391); + if (lookahead == '@') ADVANCE(119); + if (lookahead == 'A') ADVANCE(339); + if (lookahead == 'B') ADVANCE(340); + if (lookahead == 'C') ADVANCE(341); + if (lookahead == 'D') ADVANCE(342); + if (lookahead == 'E') ADVANCE(343); + if (lookahead == 'F') ADVANCE(344); + if (lookahead == '[') ADVANCE(315); + if (lookahead == '\\') SKIP(232) + if (lookahead == ']') ADVANCE(316); + if (lookahead == '^') ADVANCE(410); + if (lookahead == '_') ADVANCE(317); + if (lookahead == 'a') ADVANCE(345); + if (lookahead == 'b') ADVANCE(348); + if (lookahead == 'c') ADVANCE(350); + if (lookahead == 'd') ADVANCE(351); + if (lookahead == 'e') ADVANCE(353); + if (lookahead == 'f') ADVANCE(355); + if (lookahead == 'i') ADVANCE(356); + if (lookahead == 'l') ADVANCE(99); + if (lookahead == 'm') ADVANCE(88); + if (lookahead == 'n') ADVANCE(211); + if (lookahead == 'o') ADVANCE(122); + if (lookahead == 'r') ADVANCE(111); + if (lookahead == 's') ADVANCE(130); + if (lookahead == 't') ADVANCE(177); + if (lookahead == 'u') ADVANCE(359); + if (lookahead == 'v') ADVANCE(165); + if (lookahead == 'z') ADVANCE(360); + if (lookahead == '{') ADVANCE(243); + if (lookahead == '|') ADVANCE(313); + if (lookahead == '}') ADVANCE(244); + if (lookahead == '~') ADVANCE(396); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(0) + END_STATE(); + case 1: + if (lookahead == '\n') SKIP(50) + END_STATE(); + case 2: + if (lookahead == '\n') SKIP(50) + if (lookahead == '\r') SKIP(1) + END_STATE(); + case 3: + if (lookahead == '\n') SKIP(51) + END_STATE(); + case 4: + if (lookahead == '\n') SKIP(51) + if (lookahead == '\r') SKIP(3) + END_STATE(); + case 5: + if (lookahead == '\n') SKIP(53) + END_STATE(); + case 6: + if (lookahead == '\n') SKIP(53) + if (lookahead == '\r') SKIP(5) + END_STATE(); + case 7: + if (lookahead == '\n') SKIP(54) + END_STATE(); + case 8: + if (lookahead == '\n') SKIP(54) + if (lookahead == '\r') SKIP(7) + END_STATE(); + case 9: + if (lookahead == '\n') SKIP(52) + END_STATE(); + case 10: + if (lookahead == '\n') SKIP(52) + if (lookahead == '\r') SKIP(9) + END_STATE(); + case 11: + if (lookahead == '\n') SKIP(56) + END_STATE(); + case 12: + if (lookahead == '\n') SKIP(56) + if (lookahead == '\r') SKIP(11) + END_STATE(); + case 13: + if (lookahead == '\n') SKIP(45) + END_STATE(); + case 14: + if (lookahead == '\n') SKIP(45) + if (lookahead == '\r') SKIP(13) + END_STATE(); + case 15: + if (lookahead == '\n') SKIP(55) + END_STATE(); + case 16: + if (lookahead == '\n') SKIP(55) + if (lookahead == '\r') SKIP(15) + END_STATE(); + case 17: + if (lookahead == '\n') SKIP(46) + END_STATE(); + case 18: + if (lookahead == '\n') SKIP(46) + if (lookahead == '\r') SKIP(17) + END_STATE(); + case 19: + if (lookahead == '\n') SKIP(44) + END_STATE(); + case 20: + if (lookahead == '\n') SKIP(44) + if (lookahead == '\r') SKIP(19) + END_STATE(); + case 21: + if (lookahead == '\n') SKIP(58) + END_STATE(); + case 22: + if (lookahead == '\n') SKIP(58) + if (lookahead == '\r') SKIP(21) + END_STATE(); + case 23: + if (lookahead == '\n') SKIP(59) + END_STATE(); + case 24: + if (lookahead == '\n') SKIP(59) + if (lookahead == '\r') SKIP(23) + END_STATE(); + case 25: + if (lookahead == '\n') SKIP(47) + END_STATE(); + case 26: + if (lookahead == '\n') SKIP(47) + if (lookahead == '\r') SKIP(25) + END_STATE(); + case 27: + if (lookahead == '\n') SKIP(49) + END_STATE(); + case 28: + if (lookahead == '\n') SKIP(49) + if (lookahead == '\r') SKIP(27) + END_STATE(); + case 29: + if (lookahead == '\n') SKIP(67) + END_STATE(); + case 30: + if (lookahead == '\n') SKIP(67) + if (lookahead == '\r') SKIP(29) + END_STATE(); + case 31: + if (lookahead == '\n') SKIP(68) + END_STATE(); + case 32: + if (lookahead == '\n') SKIP(68) + if (lookahead == '\r') SKIP(31) + END_STATE(); + case 33: + if (lookahead == '\n') SKIP(65) + END_STATE(); + case 34: + if (lookahead == '\n') SKIP(65) + if (lookahead == '\r') SKIP(33) + END_STATE(); + case 35: + if (lookahead == '\n') SKIP(57) + if (lookahead == '"') ADVANCE(370); + if (lookahead == '/') ADVANCE(372); + if (lookahead == '\\') ADVANCE(367); + if (lookahead == '\t' || + lookahead == '\r' || + lookahead == ' ') ADVANCE(371); + if (lookahead != 0) ADVANCE(371); + END_STATE(); + case 36: + if (lookahead == '\n') SKIP(60) + END_STATE(); + case 37: + if (lookahead == '\n') SKIP(60) + if (lookahead == '\r') SKIP(36) + END_STATE(); + case 38: + if (lookahead == '\n') SKIP(69) + END_STATE(); + case 39: + if (lookahead == '\n') SKIP(69) + if (lookahead == '\r') SKIP(38) + END_STATE(); + case 40: + if (lookahead == '\n') SKIP(70) + END_STATE(); + case 41: + if (lookahead == '\n') SKIP(70) + if (lookahead == '\r') SKIP(40) + END_STATE(); + case 42: + if (lookahead == '\n') SKIP(48) + END_STATE(); + case 43: + if (lookahead == '\n') SKIP(48) + if (lookahead == '\r') SKIP(42) + END_STATE(); + case 44: + if (lookahead == '!') ADVANCE(265); + if (lookahead == '"') ADVANCE(370); + if (lookahead == '%') ADVANCE(404); + if (lookahead == '&') ADVANCE(398); + if (lookahead == '(') ADVANCE(254); + if (lookahead == ')') ADVANCE(255); + if (lookahead == '*') ADVANCE(304); + if (lookahead == '+') ADVANCE(392); + if (lookahead == ',') ADVANCE(245); + if (lookahead == '-') ADVANCE(394); + if (lookahead == '.') ADVANCE(361); + if (lookahead == '/') ADVANCE(402); + if (lookahead == '0') ADVANCE(328); + if (lookahead == '1') ADVANCE(330); + if (lookahead == '2') ADVANCE(331); + if (lookahead == '3') ADVANCE(332); + if (lookahead == '4') ADVANCE(333); + if (lookahead == '5') ADVANCE(334); + if (lookahead == '6') ADVANCE(335); + if (lookahead == '7') ADVANCE(336); + if (lookahead == '8') ADVANCE(337); + if (lookahead == '9') ADVANCE(338); + if (lookahead == ':') ADVANCE(252); + if (lookahead == ';') ADVANCE(238); + if (lookahead == '<') ADVANCE(413); + if (lookahead == '=') ADVANCE(240); + if (lookahead == '>') ADVANCE(415); + if (lookahead == '?') ADVANCE(391); + if (lookahead == 'A') ADVANCE(339); + if (lookahead == 'B') ADVANCE(340); + if (lookahead == 'C') ADVANCE(341); + if (lookahead == 'D') ADVANCE(342); + if (lookahead == 'E') ADVANCE(343); + if (lookahead == 'F') ADVANCE(344); + if (lookahead == '[') ADVANCE(315); + if (lookahead == '\\') SKIP(20) + if (lookahead == ']') ADVANCE(316); + if (lookahead == '^') ADVANCE(411); + if (lookahead == 'a') ADVANCE(346); + if (lookahead == 'b') ADVANCE(347); + if (lookahead == 'c') ADVANCE(349); + if (lookahead == 'd') ADVANCE(351); + if (lookahead == 'e') ADVANCE(352); + if (lookahead == 'f') ADVANCE(354); + if (lookahead == 'i') ADVANCE(357); + if (lookahead == 'u') ADVANCE(358); + if (lookahead == 'z') ADVANCE(360); + if (lookahead == '{') ADVANCE(243); + if (lookahead == '|') ADVANCE(314); + if (lookahead == '}') ADVANCE(244); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(44) + END_STATE(); + case 45: + if (lookahead == '!') ADVANCE(84); + if (lookahead == '%') ADVANCE(405); + if (lookahead == '&') ADVANCE(399); + if (lookahead == '(') ADVANCE(254); + if (lookahead == ')') ADVANCE(255); + if (lookahead == '*') ADVANCE(305); + if (lookahead == '+') ADVANCE(393); + if (lookahead == ',') ADVANCE(245); + if (lookahead == '-') ADVANCE(395); + if (lookahead == '.') ADVANCE(361); + if (lookahead == '/') ADVANCE(403); + if (lookahead == '0') ADVANCE(328); + if (lookahead == '1') ADVANCE(330); + if (lookahead == '2') ADVANCE(331); + if (lookahead == '3') ADVANCE(332); + if (lookahead == '4') ADVANCE(333); + if (lookahead == '5') ADVANCE(334); + if (lookahead == '6') ADVANCE(335); + if (lookahead == '7') ADVANCE(336); + if (lookahead == '8') ADVANCE(337); + if (lookahead == '9') ADVANCE(338); + if (lookahead == ':') ADVANCE(251); + if (lookahead == ';') ADVANCE(238); + if (lookahead == '<') ADVANCE(412); + if (lookahead == '=') ADVANCE(240); + if (lookahead == '>') ADVANCE(414); + if (lookahead == '?') ADVANCE(391); + if (lookahead == 'A') ADVANCE(339); + if (lookahead == 'B') ADVANCE(340); + if (lookahead == 'C') ADVANCE(341); + if (lookahead == 'D') ADVANCE(342); + if (lookahead == 'E') ADVANCE(343); + if (lookahead == 'F') ADVANCE(344); + if (lookahead == '[') ADVANCE(315); + if (lookahead == '\\') SKIP(14) + if (lookahead == ']') ADVANCE(316); + if (lookahead == '^') ADVANCE(410); + if (lookahead == 'a') ADVANCE(346); + if (lookahead == 'b') ADVANCE(347); + if (lookahead == 'c') ADVANCE(349); + if (lookahead == 'd') ADVANCE(351); + if (lookahead == 'e') ADVANCE(352); + if (lookahead == 'f') ADVANCE(354); + if (lookahead == 'i') ADVANCE(357); + if (lookahead == 'u') ADVANCE(358); + if (lookahead == 'z') ADVANCE(360); + if (lookahead == '|') ADVANCE(313); + if (lookahead == '}') ADVANCE(244); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(45) + END_STATE(); + case 46: + if (lookahead == '!') ADVANCE(84); + if (lookahead == '%') ADVANCE(405); + if (lookahead == '&') ADVANCE(399); + if (lookahead == '(') ADVANCE(254); + if (lookahead == ')') ADVANCE(255); + if (lookahead == '*') ADVANCE(305); + if (lookahead == '+') ADVANCE(393); + if (lookahead == ',') ADVANCE(245); + if (lookahead == '-') ADVANCE(395); + if (lookahead == '.') ADVANCE(361); + if (lookahead == '/') ADVANCE(403); + if (lookahead == '0') ADVANCE(328); + if (lookahead == '1') ADVANCE(330); + if (lookahead == '2') ADVANCE(331); + if (lookahead == '3') ADVANCE(332); + if (lookahead == '4') ADVANCE(333); + if (lookahead == '5') ADVANCE(334); + if (lookahead == '6') ADVANCE(335); + if (lookahead == '7') ADVANCE(336); + if (lookahead == '8') ADVANCE(337); + if (lookahead == '9') ADVANCE(338); + if (lookahead == ':') ADVANCE(251); + if (lookahead == ';') ADVANCE(238); + if (lookahead == '<') ADVANCE(412); + if (lookahead == '=') ADVANCE(240); + if (lookahead == '>') ADVANCE(414); + if (lookahead == '?') ADVANCE(391); + if (lookahead == '[') ADVANCE(315); + if (lookahead == '\\') SKIP(18) + if (lookahead == ']') ADVANCE(316); + if (lookahead == '^') ADVANCE(410); + if (lookahead == 'a') ADVANCE(184); + if (lookahead == 'e') ADVANCE(352); + if (lookahead == 'f') ADVANCE(77); + if (lookahead == 'i') ADVANCE(357); + if (lookahead == 'u') ADVANCE(358); + if (lookahead == 'z') ADVANCE(360); + if (lookahead == '|') ADVANCE(313); + if (lookahead == '}') ADVANCE(244); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(46) + END_STATE(); + case 47: + if (lookahead == '!') ADVANCE(84); + if (lookahead == '%') ADVANCE(405); + if (lookahead == '&') ADVANCE(399); + if (lookahead == ')') ADVANCE(255); + if (lookahead == '*') ADVANCE(305); + if (lookahead == '+') ADVANCE(393); + if (lookahead == ',') ADVANCE(245); + if (lookahead == '-') ADVANCE(395); + if (lookahead == '.') ADVANCE(63); + if (lookahead == '/') ADVANCE(403); + if (lookahead == ':') ADVANCE(251); + if (lookahead == ';') ADVANCE(238); + if (lookahead == '<') ADVANCE(412); + if (lookahead == '=') ADVANCE(239); + if (lookahead == '>') ADVANCE(414); + if (lookahead == '\\') SKIP(26) + if (lookahead == ']') ADVANCE(316); + if (lookahead == '^') ADVANCE(410); + if (lookahead == 'a') ADVANCE(184); + if (lookahead == 'e') ADVANCE(140); + if (lookahead == 'i') ADVANCE(185); + if (lookahead == '|') ADVANCE(313); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(47) + END_STATE(); + case 48: + if (lookahead == '!') ADVANCE(84); + if (lookahead == '%') ADVANCE(404); + if (lookahead == '&') ADVANCE(398); + if (lookahead == '(') ADVANCE(254); + if (lookahead == ')') ADVANCE(255); + if (lookahead == '*') ADVANCE(304); + if (lookahead == '+') ADVANCE(392); + if (lookahead == ',') ADVANCE(245); + if (lookahead == '-') ADVANCE(394); + if (lookahead == '.') ADVANCE(361); + if (lookahead == '/') ADVANCE(402); + if (lookahead == '0') ADVANCE(328); + if (lookahead == '1') ADVANCE(330); + if (lookahead == '2') ADVANCE(331); + if (lookahead == '3') ADVANCE(332); + if (lookahead == '4') ADVANCE(333); + if (lookahead == '5') ADVANCE(334); + if (lookahead == '6') ADVANCE(335); + if (lookahead == '7') ADVANCE(336); + if (lookahead == '8') ADVANCE(337); + if (lookahead == '9') ADVANCE(338); + if (lookahead == ':') ADVANCE(251); + if (lookahead == ';') ADVANCE(238); + if (lookahead == '<') ADVANCE(413); + if (lookahead == '=') ADVANCE(85); + if (lookahead == '>') ADVANCE(415); + if (lookahead == '?') ADVANCE(391); + if (lookahead == '[') ADVANCE(315); + if (lookahead == '\\') SKIP(43) + if (lookahead == ']') ADVANCE(316); + if (lookahead == '^') ADVANCE(411); + if (lookahead == 'a') ADVANCE(184); + if (lookahead == 'e') ADVANCE(352); + if (lookahead == 'f') ADVANCE(77); + if (lookahead == 'i') ADVANCE(357); + if (lookahead == 'u') ADVANCE(358); + if (lookahead == 'z') ADVANCE(360); + if (lookahead == '|') ADVANCE(314); + if (lookahead == '}') ADVANCE(244); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(48) + END_STATE(); + case 49: + if (lookahead == '!') ADVANCE(84); + if (lookahead == '%') ADVANCE(404); + if (lookahead == '&') ADVANCE(398); + if (lookahead == '(') ADVANCE(254); + if (lookahead == ')') ADVANCE(255); + if (lookahead == '*') ADVANCE(304); + if (lookahead == '+') ADVANCE(392); + if (lookahead == '-') ADVANCE(394); + if (lookahead == '.') ADVANCE(362); + if (lookahead == '/') ADVANCE(402); + if (lookahead == ':') ADVANCE(251); + if (lookahead == ';') ADVANCE(238); + if (lookahead == '<') ADVANCE(413); + if (lookahead == '=') ADVANCE(239); + if (lookahead == '>') ADVANCE(415); + if (lookahead == '?') ADVANCE(391); + if (lookahead == '[') ADVANCE(315); + if (lookahead == '\\') SKIP(28) + if (lookahead == ']') ADVANCE(316); + if (lookahead == '^') ADVANCE(411); + if (lookahead == 'a') ADVANCE(184); + if (lookahead == 'e') ADVANCE(140); + if (lookahead == 'i') ADVANCE(185); + if (lookahead == '|') ADVANCE(314); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(49) + END_STATE(); + case 50: + if (lookahead == '!') ADVANCE(264); + if (lookahead == '"') ADVANCE(370); + if (lookahead == '&') ADVANCE(397); + if (lookahead == '\'') ADVANCE(364); + if (lookahead == '(') ADVANCE(254); + if (lookahead == ')') ADVANCE(255); + if (lookahead == '*') ADVANCE(304); + if (lookahead == '+') ADVANCE(392); + if (lookahead == ',') ADVANCE(245); + if (lookahead == '-') ADVANCE(394); + if (lookahead == '.') ADVANCE(61); + if (lookahead == '/') ADVANCE(66); + if (lookahead == '0') ADVANCE(329); + if (lookahead == '1') ADVANCE(330); + if (lookahead == '2') ADVANCE(331); + if (lookahead == '3') ADVANCE(332); + if (lookahead == '4') ADVANCE(333); + if (lookahead == '5') ADVANCE(334); + if (lookahead == '6') ADVANCE(335); + if (lookahead == '7') ADVANCE(336); + if (lookahead == '8') ADVANCE(337); + if (lookahead == '9') ADVANCE(338); + if (lookahead == ':') ADVANCE(252); + if (lookahead == ';') ADVANCE(238); + if (lookahead == '=') ADVANCE(86); + if (lookahead == '[') ADVANCE(315); + if (lookahead == '\\') SKIP(2) + if (lookahead == ']') ADVANCE(316); + if (lookahead == 'a') ADVANCE(469); + if (lookahead == 'b') ADVANCE(552); + if (lookahead == 'c') ADVANCE(539); + if (lookahead == 'd') ADVANCE(478); + if (lookahead == 'e') ADVANCE(524); + if (lookahead == 'f') ADVANCE(467); + if (lookahead == 'i') ADVANCE(499); + if (lookahead == 'l') ADVANCE(479); + if (lookahead == 'm') ADVANCE(462); + if (lookahead == 'n') ADVANCE(578); + if (lookahead == 'o') ADVANCE(500); + if (lookahead == 'r') ADVANCE(491); + if (lookahead == 's') ADVANCE(507); + if (lookahead == 't') ADVANCE(551); + if (lookahead == 'v') ADVANCE(540); + if (lookahead == '{') ADVANCE(243); + if (lookahead == '}') ADVANCE(244); + if (lookahead == '~') ADVANCE(396); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(50) + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('g' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 51: + if (lookahead == '!') ADVANCE(264); + if (lookahead == '"') ADVANCE(370); + if (lookahead == '&') ADVANCE(397); + if (lookahead == '\'') ADVANCE(364); + if (lookahead == '(') ADVANCE(254); + if (lookahead == ')') ADVANCE(255); + if (lookahead == '*') ADVANCE(304); + if (lookahead == '+') ADVANCE(392); + if (lookahead == ',') ADVANCE(245); + if (lookahead == '-') ADVANCE(394); + if (lookahead == '.') ADVANCE(61); + if (lookahead == '/') ADVANCE(66); + if (lookahead == '0') ADVANCE(329); + if (lookahead == '1') ADVANCE(330); + if (lookahead == '2') ADVANCE(331); + if (lookahead == '3') ADVANCE(332); + if (lookahead == '4') ADVANCE(333); + if (lookahead == '5') ADVANCE(334); + if (lookahead == '6') ADVANCE(335); + if (lookahead == '7') ADVANCE(336); + if (lookahead == '8') ADVANCE(337); + if (lookahead == '9') ADVANCE(338); + if (lookahead == ':') ADVANCE(251); + if (lookahead == ';') ADVANCE(238); + if (lookahead == '=') ADVANCE(86); + if (lookahead == '[') ADVANCE(315); + if (lookahead == '\\') SKIP(4) + if (lookahead == ']') ADVANCE(316); + if (lookahead == 'a') ADVANCE(469); + if (lookahead == 'b') ADVANCE(552); + if (lookahead == 'c') ADVANCE(539); + if (lookahead == 'd') ADVANCE(478); + if (lookahead == 'f') ADVANCE(467); + if (lookahead == 'i') ADVANCE(499); + if (lookahead == 'l') ADVANCE(479); + if (lookahead == 'm') ADVANCE(462); + if (lookahead == 'n') ADVANCE(578); + if (lookahead == 'o') ADVANCE(500); + if (lookahead == 'r') ADVANCE(491); + if (lookahead == 's') ADVANCE(507); + if (lookahead == 't') ADVANCE(551); + if (lookahead == 'v') ADVANCE(540); + if (lookahead == '{') ADVANCE(243); + if (lookahead == '}') ADVANCE(244); + if (lookahead == '~') ADVANCE(396); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(51) + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('e' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 52: + if (lookahead == '!') ADVANCE(264); + if (lookahead == '"') ADVANCE(370); + if (lookahead == '&') ADVANCE(397); + if (lookahead == '\'') ADVANCE(364); + if (lookahead == '(') ADVANCE(254); + if (lookahead == ')') ADVANCE(255); + if (lookahead == '*') ADVANCE(304); + if (lookahead == '+') ADVANCE(392); + if (lookahead == ',') ADVANCE(245); + if (lookahead == '-') ADVANCE(394); + if (lookahead == '.') ADVANCE(363); + if (lookahead == '/') ADVANCE(66); + if (lookahead == '0') ADVANCE(329); + if (lookahead == '1') ADVANCE(330); + if (lookahead == '2') ADVANCE(331); + if (lookahead == '3') ADVANCE(332); + if (lookahead == '4') ADVANCE(333); + if (lookahead == '5') ADVANCE(334); + if (lookahead == '6') ADVANCE(335); + if (lookahead == '7') ADVANCE(336); + if (lookahead == '8') ADVANCE(337); + if (lookahead == '9') ADVANCE(338); + if (lookahead == ':') ADVANCE(252); + if (lookahead == ';') ADVANCE(238); + if (lookahead == '=') ADVANCE(241); + if (lookahead == '?') ADVANCE(391); + if (lookahead == '[') ADVANCE(315); + if (lookahead == '\\') SKIP(10) + if (lookahead == ']') ADVANCE(316); + if (lookahead == 'a') ADVANCE(469); + if (lookahead == 'b') ADVANCE(552); + if (lookahead == 'c') ADVANCE(539); + if (lookahead == 'd') ADVANCE(478); + if (lookahead == 'f') ADVANCE(467); + if (lookahead == 'i') ADVANCE(499); + if (lookahead == 'l') ADVANCE(479); + if (lookahead == 'm') ADVANCE(462); + if (lookahead == 'n') ADVANCE(578); + if (lookahead == 'o') ADVANCE(500); + if (lookahead == 'r') ADVANCE(491); + if (lookahead == 's') ADVANCE(507); + if (lookahead == 't') ADVANCE(551); + if (lookahead == 'v') ADVANCE(540); + if (lookahead == '{') ADVANCE(243); + if (lookahead == '|') ADVANCE(312); + if (lookahead == '}') ADVANCE(244); + if (lookahead == '~') ADVANCE(396); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(52) + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('e' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 53: + if (lookahead == '!') ADVANCE(264); + if (lookahead == '"') ADVANCE(370); + if (lookahead == '&') ADVANCE(397); + if (lookahead == '\'') ADVANCE(364); + if (lookahead == '(') ADVANCE(254); + if (lookahead == ')') ADVANCE(255); + if (lookahead == '*') ADVANCE(304); + if (lookahead == '+') ADVANCE(392); + if (lookahead == ',') ADVANCE(245); + if (lookahead == '-') ADVANCE(394); + if (lookahead == '.') ADVANCE(63); + if (lookahead == '/') ADVANCE(66); + if (lookahead == '0') ADVANCE(329); + if (lookahead == '1') ADVANCE(330); + if (lookahead == '2') ADVANCE(331); + if (lookahead == '3') ADVANCE(332); + if (lookahead == '4') ADVANCE(333); + if (lookahead == '5') ADVANCE(334); + if (lookahead == '6') ADVANCE(335); + if (lookahead == '7') ADVANCE(336); + if (lookahead == '8') ADVANCE(337); + if (lookahead == '9') ADVANCE(338); + if (lookahead == ':') ADVANCE(251); + if (lookahead == ';') ADVANCE(238); + if (lookahead == '[') ADVANCE(315); + if (lookahead == '\\') SKIP(6) + if (lookahead == ']') ADVANCE(316); + if (lookahead == 'a') ADVANCE(469); + if (lookahead == 'b') ADVANCE(552); + if (lookahead == 'c') ADVANCE(539); + if (lookahead == 'd') ADVANCE(478); + if (lookahead == 'e') ADVANCE(524); + if (lookahead == 'f') ADVANCE(467); + if (lookahead == 'i') ADVANCE(499); + if (lookahead == 'l') ADVANCE(479); + if (lookahead == 'm') ADVANCE(462); + if (lookahead == 'n') ADVANCE(578); + if (lookahead == 'o') ADVANCE(500); + if (lookahead == 'r') ADVANCE(491); + if (lookahead == 's') ADVANCE(507); + if (lookahead == 't') ADVANCE(551); + if (lookahead == 'v') ADVANCE(540); + if (lookahead == '{') ADVANCE(243); + if (lookahead == '~') ADVANCE(396); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(53) + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('g' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 54: + if (lookahead == '!') ADVANCE(264); + if (lookahead == '"') ADVANCE(370); + if (lookahead == '&') ADVANCE(397); + if (lookahead == '\'') ADVANCE(364); + if (lookahead == '(') ADVANCE(254); + if (lookahead == ')') ADVANCE(255); + if (lookahead == '*') ADVANCE(304); + if (lookahead == '+') ADVANCE(392); + if (lookahead == '-') ADVANCE(394); + if (lookahead == '.') ADVANCE(63); + if (lookahead == '/') ADVANCE(66); + if (lookahead == '0') ADVANCE(329); + if (lookahead == '1') ADVANCE(330); + if (lookahead == '2') ADVANCE(331); + if (lookahead == '3') ADVANCE(332); + if (lookahead == '4') ADVANCE(333); + if (lookahead == '5') ADVANCE(334); + if (lookahead == '6') ADVANCE(335); + if (lookahead == '7') ADVANCE(336); + if (lookahead == '8') ADVANCE(337); + if (lookahead == '9') ADVANCE(338); + if (lookahead == ':') ADVANCE(251); + if (lookahead == ';') ADVANCE(238); + if (lookahead == '[') ADVANCE(315); + if (lookahead == '\\') SKIP(8) + if (lookahead == ']') ADVANCE(316); + if (lookahead == 'a') ADVANCE(469); + if (lookahead == 'b') ADVANCE(552); + if (lookahead == 'c') ADVANCE(539); + if (lookahead == 'd') ADVANCE(478); + if (lookahead == 'f') ADVANCE(467); + if (lookahead == 'i') ADVANCE(499); + if (lookahead == 'l') ADVANCE(479); + if (lookahead == 'm') ADVANCE(462); + if (lookahead == 'n') ADVANCE(578); + if (lookahead == 'o') ADVANCE(500); + if (lookahead == 'r') ADVANCE(491); + if (lookahead == 's') ADVANCE(507); + if (lookahead == 't') ADVANCE(551); + if (lookahead == 'v') ADVANCE(540); + if (lookahead == '{') ADVANCE(243); + if (lookahead == '~') ADVANCE(396); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(54) + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('e' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 55: + if (lookahead == '!') ADVANCE(264); + if (lookahead == '"') ADVANCE(370); + if (lookahead == '&') ADVANCE(397); + if (lookahead == '\'') ADVANCE(364); + if (lookahead == '(') ADVANCE(254); + if (lookahead == '*') ADVANCE(304); + if (lookahead == '+') ADVANCE(392); + if (lookahead == '-') ADVANCE(394); + if (lookahead == '/') ADVANCE(66); + if (lookahead == '0') ADVANCE(329); + if (lookahead == '1') ADVANCE(330); + if (lookahead == '2') ADVANCE(331); + if (lookahead == '3') ADVANCE(332); + if (lookahead == '4') ADVANCE(333); + if (lookahead == '5') ADVANCE(334); + if (lookahead == '6') ADVANCE(335); + if (lookahead == '7') ADVANCE(336); + if (lookahead == '8') ADVANCE(337); + if (lookahead == '9') ADVANCE(338); + if (lookahead == '=') ADVANCE(86); + if (lookahead == '[') ADVANCE(315); + if (lookahead == '\\') SKIP(16) + if (lookahead == ']') ADVANCE(316); + if (lookahead == 'a') ADVANCE(469); + if (lookahead == 'd') ADVANCE(493); + if (lookahead == 'f') ADVANCE(468); + if (lookahead == 'l') ADVANCE(494); + if (lookahead == 'n') ADVANCE(578); + if (lookahead == 'o') ADVANCE(500); + if (lookahead == 's') ADVANCE(508); + if (lookahead == 't') ADVANCE(551); + if (lookahead == 'v') ADVANCE(540); + if (lookahead == '~') ADVANCE(396); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(55) + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 56: + if (lookahead == '!') ADVANCE(264); + if (lookahead == '"') ADVANCE(370); + if (lookahead == '&') ADVANCE(397); + if (lookahead == '\'') ADVANCE(364); + if (lookahead == '(') ADVANCE(254); + if (lookahead == '*') ADVANCE(304); + if (lookahead == '+') ADVANCE(392); + if (lookahead == '-') ADVANCE(394); + if (lookahead == '/') ADVANCE(66); + if (lookahead == '0') ADVANCE(329); + if (lookahead == '1') ADVANCE(330); + if (lookahead == '2') ADVANCE(331); + if (lookahead == '3') ADVANCE(332); + if (lookahead == '4') ADVANCE(333); + if (lookahead == '5') ADVANCE(334); + if (lookahead == '6') ADVANCE(335); + if (lookahead == '7') ADVANCE(336); + if (lookahead == '8') ADVANCE(337); + if (lookahead == '9') ADVANCE(338); + if (lookahead == '[') ADVANCE(315); + if (lookahead == '\\') SKIP(12) + if (lookahead == ']') ADVANCE(316); + if (lookahead == '_') ADVANCE(318); + if (lookahead == 'a') ADVANCE(469); + if (lookahead == 'd') ADVANCE(493); + if (lookahead == 'f') ADVANCE(468); + if (lookahead == 'l') ADVANCE(494); + if (lookahead == 'n') ADVANCE(578); + if (lookahead == 'o') ADVANCE(500); + if (lookahead == 's') ADVANCE(508); + if (lookahead == 't') ADVANCE(551); + if (lookahead == 'v') ADVANCE(540); + if (lookahead == '~') ADVANCE(396); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(56) + if (('A' <= lookahead && lookahead <= 'Z') || + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 57: + if (lookahead == '"') ADVANCE(370); + if (lookahead == '/') ADVANCE(66); + if (lookahead == '\\') ADVANCE(367); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(57) + END_STATE(); + case 58: + if (lookahead == '(') ADVANCE(254); + if (lookahead == ')') ADVANCE(255); + if (lookahead == '*') ADVANCE(304); + if (lookahead == '.') ADVANCE(64); + if (lookahead == '/') ADVANCE(66); + if (lookahead == '=') ADVANCE(86); + if (lookahead == '@') ADVANCE(154); + if (lookahead == '[') ADVANCE(315); + if (lookahead == '\\') SKIP(22) + if (lookahead == 'b') ADVANCE(543); + if (lookahead == 'c') ADVANCE(505); + if (lookahead == 'e') ADVANCE(535); + if (lookahead == 'f') ADVANCE(456); + if (lookahead == 'i') ADVANCE(451); + if (lookahead == 'n') ADVANCE(584); + if (lookahead == 'r') ADVANCE(581); + if (lookahead == 's') ADVANCE(509); + if (lookahead == 'u') ADVANCE(452); + if (lookahead == 'v') ADVANCE(540); + if (lookahead == '}') ADVANCE(244); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(58) + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 59: + if (lookahead == '(') ADVANCE(254); + if (lookahead == '*') ADVANCE(304); + if (lookahead == '.') ADVANCE(64); + if (lookahead == '/') ADVANCE(66); + if (lookahead == '@') ADVANCE(154); + if (lookahead == '[') ADVANCE(315); + if (lookahead == '\\') SKIP(24) + if (lookahead == 'b') ADVANCE(543); + if (lookahead == 'c') ADVANCE(506); + if (lookahead == 'e') ADVANCE(535); + if (lookahead == 'f') ADVANCE(456); + if (lookahead == 'i') ADVANCE(451); + if (lookahead == 'n') ADVANCE(584); + if (lookahead == 'r') ADVANCE(581); + if (lookahead == 's') ADVANCE(509); + if (lookahead == 'u') ADVANCE(452); + if (lookahead == 'v') ADVANCE(540); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(59) + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 60: + if (lookahead == ')') ADVANCE(255); + if (lookahead == '.') ADVANCE(64); + if (lookahead == '/') ADVANCE(66); + if (lookahead == '\\') SKIP(37) + if (lookahead == '_') ADVANCE(318); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(60) + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 61: + if (lookahead == '.') ADVANCE(390); + END_STATE(); + case 62: + if (lookahead == '.') ADVANCE(319); + END_STATE(); + case 63: + if (lookahead == '.') ADVANCE(389); + END_STATE(); + case 64: + if (lookahead == '.') ADVANCE(62); + END_STATE(); + case 65: + if (lookahead == '.') ADVANCE(64); + if (lookahead == '/') ADVANCE(66); + if (lookahead == '\\') SKIP(34) + if (lookahead == 's') ADVANCE(576); + if (lookahead == '}') ADVANCE(244); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(65) + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 66: + if (lookahead == '/') ADVANCE(587); + END_STATE(); + case 67: + if (lookahead == '/') ADVANCE(66); + if (lookahead == '0') ADVANCE(329); + if (lookahead == '1') ADVANCE(330); + if (lookahead == '2') ADVANCE(331); + if (lookahead == '3') ADVANCE(332); + if (lookahead == '4') ADVANCE(333); + if (lookahead == '5') ADVANCE(334); + if (lookahead == '6') ADVANCE(335); + if (lookahead == '7') ADVANCE(336); + if (lookahead == '8') ADVANCE(337); + if (lookahead == '9') ADVANCE(338); + if (lookahead == ';') ADVANCE(238); + if (lookahead == '@') ADVANCE(183); + if (lookahead == '\\') SKIP(30) + if (lookahead == '}') ADVANCE(244); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(67) + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 68: + if (lookahead == '/') ADVANCE(66); + if (lookahead == '@') ADVANCE(170); + if (lookahead == '\\') SKIP(32) + if (lookahead == 's') ADVANCE(576); + if (lookahead == 'u') ADVANCE(534); + if (lookahead == '}') ADVANCE(244); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(68) + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 69: + if (lookahead == '/') ADVANCE(66); + if (lookahead == '\\') SKIP(39) + if (lookahead == 'a') ADVANCE(193); + if (lookahead == 'c') ADVANCE(169); + if (lookahead == 'l') ADVANCE(116); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(69) + END_STATE(); + case 70: + if (lookahead == '/') ADVANCE(66); + if (lookahead == '\\') SKIP(41) + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(70) + END_STATE(); + case 71: + if (lookahead == '/') ADVANCE(366); + if (lookahead == '\\') ADVANCE(367); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') ADVANCE(365); + if (lookahead != 0 && + lookahead != '\'') ADVANCE(365); + END_STATE(); + case 72: + if (lookahead == '1') ADVANCE(82); + if (lookahead == '3') ADVANCE(74); + if (lookahead == '6') ADVANCE(79); + if (lookahead == '8') ADVANCE(272); + if (lookahead == 'n') ADVANCE(194); + if (lookahead == 's') ADVANCE(401); + END_STATE(); + case 73: + if (lookahead == '1') ADVANCE(83); + if (lookahead == '3') ADVANCE(75); + if (lookahead == '6') ADVANCE(80); + if (lookahead == '8') ADVANCE(280); + if (lookahead == 'i') ADVANCE(158); + if (lookahead == 's') ADVANCE(100); + END_STATE(); + case 74: + if (lookahead == '2') ADVANCE(276); + END_STATE(); + case 75: + if (lookahead == '2') ADVANCE(284); + END_STATE(); + case 76: + if (lookahead == '2') ADVANCE(298); + END_STATE(); + case 77: + if (lookahead == '3') ADVANCE(76); + if (lookahead == '6') ADVANCE(81); + END_STATE(); + case 78: + if (lookahead == '3') ADVANCE(76); + if (lookahead == '6') ADVANCE(81); + if (lookahead == 'n') ADVANCE(258); + if (lookahead == 'o') ADVANCE(174); + END_STATE(); + case 79: + if (lookahead == '4') ADVANCE(278); + END_STATE(); + case 80: + if (lookahead == '4') ADVANCE(286); + END_STATE(); + case 81: + if (lookahead == '4') ADVANCE(300); + END_STATE(); + case 82: + if (lookahead == '6') ADVANCE(274); + END_STATE(); + case 83: + if (lookahead == '6') ADVANCE(282); + END_STATE(); + case 84: + if (lookahead == '=') ADVANCE(419); + END_STATE(); + case 85: + if (lookahead == '=') ADVANCE(418); + if (lookahead == '>') ADVANCE(431); + END_STATE(); + case 86: + if (lookahead == '>') ADVANCE(431); + END_STATE(); + case 87: + if (lookahead == 'a') ADVANCE(139); + END_STATE(); + case 88: + if (lookahead == 'a') ADVANCE(196); + END_STATE(); + case 89: + if (lookahead == 'a') ADVANCE(175); + END_STATE(); + case 90: + if (lookahead == 'a') ADVANCE(207); + if (lookahead == 'r') ADVANCE(213); + END_STATE(); + case 91: + if (lookahead == 'b') ADVANCE(168); + END_STATE(); + case 92: + if (lookahead == 'c') ADVANCE(126); + END_STATE(); + case 93: + if (lookahead == 'c') ADVANCE(373); + END_STATE(); + case 94: + if (lookahead == 'c') ADVANCE(382); + END_STATE(); + case 95: + if (lookahead == 'c') ADVANCE(127); + END_STATE(); + case 96: + if (lookahead == 'c') ADVANCE(202); + END_STATE(); + case 97: + if (lookahead == 'd') ADVANCE(270); + END_STATE(); + case 98: + if (lookahead == 'd') ADVANCE(375); + END_STATE(); + case 99: + if (lookahead == 'e') ADVANCE(150); + END_STATE(); + case 100: + if (lookahead == 'e') ADVANCE(237); + END_STATE(); + case 101: + if (lookahead == 'e') ADVANCE(425); + END_STATE(); + case 102: + if (lookahead == 'e') ADVANCE(377); + END_STATE(); + case 103: + if (lookahead == 'e') ADVANCE(266); + END_STATE(); + case 104: + if (lookahead == 'e') ADVANCE(292); + END_STATE(); + case 105: + if (lookahead == 'e') ADVANCE(320); + END_STATE(); + case 106: + if (lookahead == 'e') ADVANCE(257); + END_STATE(); + case 107: + if (lookahead == 'e') ADVANCE(447); + END_STATE(); + case 108: + if (lookahead == 'e') ADVANCE(186); + END_STATE(); + case 109: + if (lookahead == 'e') ADVANCE(87); + END_STATE(); + case 110: + if (lookahead == 'e') ADVANCE(121); + END_STATE(); + case 111: + if (lookahead == 'e') ADVANCE(206); + if (lookahead == 'u') ADVANCE(157); + END_STATE(); + case 112: + if (lookahead == 'e') ADVANCE(155); + END_STATE(); + case 113: + if (lookahead == 'e') ADVANCE(102); + END_STATE(); + case 114: + if (lookahead == 'e') ADVANCE(201); + END_STATE(); + case 115: + if (lookahead == 'e') ADVANCE(203); + END_STATE(); + case 116: + if (lookahead == 'e') ADVANCE(195); + END_STATE(); + case 117: + if (lookahead == 'e') ADVANCE(182); + END_STATE(); + case 118: + if (lookahead == 'e') ADVANCE(210); + END_STATE(); + case 119: + if (lookahead == 'f') ADVANCE(137); + if (lookahead == 'i') ADVANCE(159); + if (lookahead == 'n') ADVANCE(162); + if (lookahead == 'o') ADVANCE(125); + if (lookahead == 's') ADVANCE(218); + if (lookahead == 't') ADVANCE(108); + END_STATE(); + case 120: + if (lookahead == 'f') ADVANCE(137); + if (lookahead == 'i') ADVANCE(159); + if (lookahead == 'n') ADVANCE(162); + if (lookahead == 's') ADVANCE(218); + if (lookahead == 't') ADVANCE(108); + END_STATE(); + case 121: + if (lookahead == 'f') ADVANCE(256); + END_STATE(); + case 122: + if (lookahead == 'f') ADVANCE(123); + END_STATE(); + case 123: + if (lookahead == 'f') ADVANCE(190); + END_STATE(); + case 124: + if (lookahead == 'f') ADVANCE(191); + END_STATE(); + case 125: + if (lookahead == 'f') ADVANCE(124); + END_STATE(); + case 126: + if (lookahead == 'h') ADVANCE(432); + END_STATE(); + case 127: + if (lookahead == 'h') ADVANCE(429); + END_STATE(); + case 128: + if (lookahead == 'h') ADVANCE(89); + if (lookahead == 'o') ADVANCE(160); + END_STATE(); + case 129: + if (lookahead == 'i') ADVANCE(220); + END_STATE(); + case 130: + if (lookahead == 'i') ADVANCE(220); + if (lookahead == 't') ADVANCE(90); + if (lookahead == 'w') ADVANCE(138); + END_STATE(); + case 131: + if (lookahead == 'i') ADVANCE(97); + END_STATE(); + case 132: + if (lookahead == 'i') ADVANCE(260); + END_STATE(); + case 133: + if (lookahead == 'i') ADVANCE(94); + END_STATE(); + case 134: + if (lookahead == 'i') ADVANCE(167); + END_STATE(); + case 135: + if (lookahead == 'i') ADVANCE(197); + END_STATE(); + case 136: + if (lookahead == 'i') ADVANCE(161); + END_STATE(); + case 137: + if (lookahead == 'i') ADVANCE(156); + END_STATE(); + case 138: + if (lookahead == 'i') ADVANCE(209); + END_STATE(); + case 139: + if (lookahead == 'k') ADVANCE(445); + END_STATE(); + case 140: + if (lookahead == 'l') ADVANCE(187); + END_STATE(); + case 141: + if (lookahead == 'l') ADVANCE(187); + if (lookahead == 'x') ADVANCE(173); + END_STATE(); + case 142: + if (lookahead == 'l') ADVANCE(268); + END_STATE(); + case 143: + if (lookahead == 'l') ADVANCE(323); + END_STATE(); + case 144: + if (lookahead == 'l') ADVANCE(253); + END_STATE(); + case 145: + if (lookahead == 'l') ADVANCE(163); + END_STATE(); + case 146: + if (lookahead == 'l') ADVANCE(143); + END_STATE(); + case 147: + if (lookahead == 'm') ADVANCE(91); + END_STATE(); + case 148: + if (lookahead == 'm') ADVANCE(302); + END_STATE(); + case 149: + if (lookahead == 'n') ADVANCE(189); + END_STATE(); + case 150: + if (lookahead == 'n') ADVANCE(385); + if (lookahead == 't') ADVANCE(247); + END_STATE(); + case 151: + if (lookahead == 'n') ADVANCE(309); + END_STATE(); + case 152: + if (lookahead == 'n') ADVANCE(449); + END_STATE(); + case 153: + if (lookahead == 'n') ADVANCE(263); + END_STATE(); + case 154: + if (lookahead == 'n') ADVANCE(162); + END_STATE(); + case 155: + if (lookahead == 'n') ADVANCE(98); + END_STATE(); + case 156: + if (lookahead == 'n') ADVANCE(132); + END_STATE(); + case 157: + if (lookahead == 'n') ADVANCE(103); + END_STATE(); + case 158: + if (lookahead == 'n') ADVANCE(204); + END_STATE(); + case 159: + if (lookahead == 'n') ADVANCE(135); + END_STATE(); + case 160: + if (lookahead == 'n') ADVANCE(188); + END_STATE(); + case 161: + if (lookahead == 'n') ADVANCE(216); + END_STATE(); + case 162: + if (lookahead == 'o') ADVANCE(181); + END_STATE(); + case 163: + if (lookahead == 'o') ADVANCE(93); + END_STATE(); + case 164: + if (lookahead == 'o') ADVANCE(142); + END_STATE(); + case 165: + if (lookahead == 'o') ADVANCE(131); + END_STATE(); + case 166: + if (lookahead == 'o') ADVANCE(180); + END_STATE(); + case 167: + if (lookahead == 'o') ADVANCE(151); + END_STATE(); + case 168: + if (lookahead == 'o') ADVANCE(144); + END_STATE(); + case 169: + if (lookahead == 'o') ADVANCE(160); + END_STATE(); + case 170: + if (lookahead == 'o') ADVANCE(125); + END_STATE(); + case 171: + if (lookahead == 'p') ADVANCE(112); + END_STATE(); + case 172: + if (lookahead == 'p') ADVANCE(106); + END_STATE(); + case 173: + if (lookahead == 'p') ADVANCE(166); + END_STATE(); + case 174: + if (lookahead == 'r') ADVANCE(427); + END_STATE(); + case 175: + if (lookahead == 'r') ADVANCE(296); + END_STATE(); + case 176: + if (lookahead == 'r') ADVANCE(294); + END_STATE(); + case 177: + if (lookahead == 'r') ADVANCE(215); + if (lookahead == 'y') ADVANCE(172); + END_STATE(); + case 178: + if (lookahead == 'r') ADVANCE(152); + END_STATE(); + case 179: + if (lookahead == 'r') ADVANCE(153); + END_STATE(); + case 180: + if (lookahead == 'r') ADVANCE(200); + END_STATE(); + case 181: + if (lookahead == 'r') ADVANCE(118); + END_STATE(); + case 182: + if (lookahead == 'r') ADVANCE(205); + END_STATE(); + case 183: + if (lookahead == 's') ADVANCE(218); + END_STATE(); + case 184: + if (lookahead == 's') ADVANCE(400); + END_STATE(); + case 185: + if (lookahead == 's') ADVANCE(401); + END_STATE(); + case 186: + if (lookahead == 's') ADVANCE(198); + END_STATE(); + case 187: + if (lookahead == 's') ADVANCE(101); + END_STATE(); + case 188: + if (lookahead == 's') ADVANCE(199); + END_STATE(); + case 189: + if (lookahead == 's') ADVANCE(199); + if (lookahead == 't') ADVANCE(136); + END_STATE(); + case 190: + if (lookahead == 's') ADVANCE(114); + END_STATE(); + case 191: + if (lookahead == 's') ADVANCE(115); + END_STATE(); + case 192: + if (lookahead == 's') ADVANCE(117); + END_STATE(); + case 193: + if (lookahead == 's') ADVANCE(192); + END_STATE(); + case 194: + if (lookahead == 't') ADVANCE(288); + END_STATE(); + case 195: + if (lookahead == 't') ADVANCE(247); + END_STATE(); + case 196: + if (lookahead == 't') ADVANCE(92); + END_STATE(); + case 197: + if (lookahead == 't') ADVANCE(261); + END_STATE(); + case 198: + if (lookahead == 't') ADVANCE(262); + END_STATE(); + case 199: + if (lookahead == 't') ADVANCE(249); + END_STATE(); + case 200: + if (lookahead == 't') ADVANCE(246); + END_STATE(); + case 201: + if (lookahead == 't') ADVANCE(387); + END_STATE(); + case 202: + if (lookahead == 't') ADVANCE(307); + END_STATE(); + case 203: + if (lookahead == 't') ADVANCE(311); + END_STATE(); + case 204: + if (lookahead == 't') ADVANCE(291); + END_STATE(); + case 205: + if (lookahead == 't') ADVANCE(380); + END_STATE(); + case 206: + if (lookahead == 't') ADVANCE(214); + END_STATE(); + case 207: + if (lookahead == 't') ADVANCE(133); + END_STATE(); + case 208: + if (lookahead == 't') ADVANCE(176); + END_STATE(); + case 209: + if (lookahead == 't') ADVANCE(95); + END_STATE(); + case 210: + if (lookahead == 't') ADVANCE(217); + END_STATE(); + case 211: + if (lookahead == 'u') ADVANCE(146); + END_STATE(); + case 212: + if (lookahead == 'u') ADVANCE(148); + END_STATE(); + case 213: + if (lookahead == 'u') ADVANCE(96); + END_STATE(); + case 214: + if (lookahead == 'u') ADVANCE(178); + END_STATE(); + case 215: + if (lookahead == 'u') ADVANCE(105); + END_STATE(); + case 216: + if (lookahead == 'u') ADVANCE(107); + END_STATE(); + case 217: + if (lookahead == 'u') ADVANCE(179); + END_STATE(); + case 218: + if (lookahead == 'y') ADVANCE(147); + END_STATE(); + case 219: + if (lookahead == 'y') ADVANCE(172); + END_STATE(); + case 220: + if (lookahead == 'z') ADVANCE(104); + END_STATE(); + case 221: + if (aux_sym_named_escape_token1_character_set_1(lookahead)) ADVANCE(369); + if (lookahead == '/') ADVANCE(66); + if (lookahead == 'U') ADVANCE(229); + if (lookahead == '\\') ADVANCE(369); + if (lookahead == 'u') ADVANCE(225); + if (lookahead == 'x') ADVANCE(223); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(70) + END_STATE(); + case 222: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(368); + END_STATE(); + case 223: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(222); + END_STATE(); + case 224: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(223); + END_STATE(); + case 225: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(224); + END_STATE(); + case 226: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(225); + END_STATE(); + case 227: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(226); + END_STATE(); + case 228: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(227); + END_STATE(); + case 229: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(228); + END_STATE(); + case 230: + if (lookahead != 0 && + lookahead != '\r') ADVANCE(587); + if (lookahead == '\r') ADVANCE(588); + END_STATE(); + case 231: + if (eof) ADVANCE(236); + if (lookahead == '\n') SKIP(0) + END_STATE(); + case 232: + if (eof) ADVANCE(236); + if (lookahead == '\n') SKIP(0) + if (lookahead == '\r') SKIP(231) + END_STATE(); + case 233: + if (eof) ADVANCE(236); + if (lookahead == '\n') SKIP(235) + END_STATE(); + case 234: + if (eof) ADVANCE(236); + if (lookahead == '\n') SKIP(235) + if (lookahead == '\r') SKIP(233) + END_STATE(); + case 235: + if (eof) ADVANCE(236); + if (lookahead == '!') ADVANCE(84); + if (lookahead == '%') ADVANCE(405); + if (lookahead == '&') ADVANCE(399); + if (lookahead == '(') ADVANCE(254); + if (lookahead == ')') ADVANCE(255); + if (lookahead == '*') ADVANCE(305); + if (lookahead == '+') ADVANCE(393); + if (lookahead == ',') ADVANCE(245); + if (lookahead == '-') ADVANCE(395); + if (lookahead == '.') ADVANCE(361); + if (lookahead == '/') ADVANCE(403); + if (lookahead == '0') ADVANCE(328); + if (lookahead == '1') ADVANCE(330); + if (lookahead == '2') ADVANCE(331); + if (lookahead == '3') ADVANCE(332); + if (lookahead == '4') ADVANCE(333); + if (lookahead == '5') ADVANCE(334); + if (lookahead == '6') ADVANCE(335); + if (lookahead == '7') ADVANCE(336); + if (lookahead == '8') ADVANCE(337); + if (lookahead == '9') ADVANCE(338); + if (lookahead == ':') ADVANCE(251); + if (lookahead == ';') ADVANCE(238); + if (lookahead == '<') ADVANCE(412); + if (lookahead == '=') ADVANCE(240); + if (lookahead == '>') ADVANCE(414); + if (lookahead == '?') ADVANCE(391); + if (lookahead == '@') ADVANCE(120); + if (lookahead == '[') ADVANCE(315); + if (lookahead == '\\') SKIP(234) + if (lookahead == ']') ADVANCE(316); + if (lookahead == '^') ADVANCE(410); + if (lookahead == 'a') ADVANCE(184); + if (lookahead == 'c') ADVANCE(128); + if (lookahead == 'd') ADVANCE(110); + if (lookahead == 'e') ADVANCE(141); + if (lookahead == 'f') ADVANCE(78); + if (lookahead == 'i') ADVANCE(72); + if (lookahead == 'l') ADVANCE(116); + if (lookahead == 's') ADVANCE(129); + if (lookahead == 't') ADVANCE(219); + if (lookahead == 'u') ADVANCE(73); + if (lookahead == '{') ADVANCE(243); + if (lookahead == '|') ADVANCE(313); + if (lookahead == '}') ADVANCE(244); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(235) + END_STATE(); + case 236: + ACCEPT_TOKEN(ts_builtin_sym_end); + END_STATE(); + case 237: + ACCEPT_TOKEN(anon_sym_use); + END_STATE(); + case 238: + ACCEPT_TOKEN(anon_sym_SEMI); + END_STATE(); + case 239: + ACCEPT_TOKEN(anon_sym_EQ); + if (lookahead == '=') ADVANCE(418); + END_STATE(); + case 240: + ACCEPT_TOKEN(anon_sym_EQ); + if (lookahead == '=') ADVANCE(418); + if (lookahead == '>') ADVANCE(431); + END_STATE(); + case 241: + ACCEPT_TOKEN(anon_sym_EQ); + if (lookahead == '>') ADVANCE(431); + END_STATE(); + case 242: + ACCEPT_TOKEN(anon_sym_COLON_COLON); + END_STATE(); + case 243: + ACCEPT_TOKEN(anon_sym_LBRACE); + END_STATE(); + case 244: + ACCEPT_TOKEN(anon_sym_RBRACE); + END_STATE(); + case 245: + ACCEPT_TOKEN(anon_sym_COMMA); + END_STATE(); + case 246: + ACCEPT_TOKEN(anon_sym_export); + END_STATE(); + case 247: + ACCEPT_TOKEN(anon_sym_let); + END_STATE(); + case 248: + ACCEPT_TOKEN(anon_sym_let); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 249: + ACCEPT_TOKEN(anon_sym_const); + END_STATE(); + case 250: + ACCEPT_TOKEN(anon_sym_const); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 251: + ACCEPT_TOKEN(anon_sym_COLON); + END_STATE(); + case 252: + ACCEPT_TOKEN(anon_sym_COLON); + if (lookahead == ':') ADVANCE(242); + END_STATE(); + case 253: + ACCEPT_TOKEN(anon_sym_ATsymbol); + END_STATE(); + case 254: + ACCEPT_TOKEN(anon_sym_LPAREN); + END_STATE(); + case 255: + ACCEPT_TOKEN(anon_sym_RPAREN); + END_STATE(); + case 256: + ACCEPT_TOKEN(anon_sym_def); + END_STATE(); + case 257: + ACCEPT_TOKEN(anon_sym_type); + END_STATE(); + case 258: + ACCEPT_TOKEN(anon_sym_fn); + END_STATE(); + case 259: + ACCEPT_TOKEN(anon_sym_fn); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 260: + ACCEPT_TOKEN(anon_sym_ATfini); + END_STATE(); + case 261: + ACCEPT_TOKEN(anon_sym_ATinit); + END_STATE(); + case 262: + ACCEPT_TOKEN(anon_sym_ATtest); + END_STATE(); + case 263: + ACCEPT_TOKEN(anon_sym_ATnoreturn); + END_STATE(); + case 264: + ACCEPT_TOKEN(anon_sym_BANG); + END_STATE(); + case 265: + ACCEPT_TOKEN(anon_sym_BANG); + if (lookahead == '=') ADVANCE(419); + END_STATE(); + case 266: + ACCEPT_TOKEN(anon_sym_rune); + END_STATE(); + case 267: + ACCEPT_TOKEN(anon_sym_rune); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 268: + ACCEPT_TOKEN(anon_sym_bool); + END_STATE(); + case 269: + ACCEPT_TOKEN(anon_sym_bool); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 270: + ACCEPT_TOKEN(anon_sym_void); + END_STATE(); + case 271: + ACCEPT_TOKEN(anon_sym_void); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 272: + ACCEPT_TOKEN(anon_sym_i8); + END_STATE(); + case 273: + ACCEPT_TOKEN(anon_sym_i8); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 274: + ACCEPT_TOKEN(anon_sym_i16); + END_STATE(); + case 275: + ACCEPT_TOKEN(anon_sym_i16); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 276: + ACCEPT_TOKEN(anon_sym_i32); + END_STATE(); + case 277: + ACCEPT_TOKEN(anon_sym_i32); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 278: + ACCEPT_TOKEN(anon_sym_i64); + END_STATE(); + case 279: + ACCEPT_TOKEN(anon_sym_i64); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 280: + ACCEPT_TOKEN(anon_sym_u8); + END_STATE(); + case 281: + ACCEPT_TOKEN(anon_sym_u8); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 282: + ACCEPT_TOKEN(anon_sym_u16); + END_STATE(); + case 283: + ACCEPT_TOKEN(anon_sym_u16); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 284: + ACCEPT_TOKEN(anon_sym_u32); + END_STATE(); + case 285: + ACCEPT_TOKEN(anon_sym_u32); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 286: + ACCEPT_TOKEN(anon_sym_u64); + END_STATE(); + case 287: + ACCEPT_TOKEN(anon_sym_u64); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 288: + ACCEPT_TOKEN(anon_sym_int); + END_STATE(); + case 289: + ACCEPT_TOKEN(anon_sym_int); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 290: + ACCEPT_TOKEN(anon_sym_uint); + if (lookahead == 'p') ADVANCE(573); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 291: + ACCEPT_TOKEN(anon_sym_uint); + if (lookahead == 'p') ADVANCE(208); + END_STATE(); + case 292: + ACCEPT_TOKEN(anon_sym_size); + END_STATE(); + case 293: + ACCEPT_TOKEN(anon_sym_size); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 294: + ACCEPT_TOKEN(anon_sym_uintptr); + END_STATE(); + case 295: + ACCEPT_TOKEN(anon_sym_uintptr); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 296: + ACCEPT_TOKEN(anon_sym_char); + END_STATE(); + case 297: + ACCEPT_TOKEN(anon_sym_char); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 298: + ACCEPT_TOKEN(anon_sym_f32); + END_STATE(); + case 299: + ACCEPT_TOKEN(anon_sym_f32); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 300: + ACCEPT_TOKEN(anon_sym_f64); + END_STATE(); + case 301: + ACCEPT_TOKEN(anon_sym_f64); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 302: + ACCEPT_TOKEN(anon_sym_enum); + END_STATE(); + case 303: + ACCEPT_TOKEN(anon_sym_enum); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 304: + ACCEPT_TOKEN(anon_sym_STAR); + END_STATE(); + case 305: + ACCEPT_TOKEN(anon_sym_STAR); + if (lookahead == '=') ADVANCE(436); + END_STATE(); + case 306: + ACCEPT_TOKEN(anon_sym_nullable); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 307: + ACCEPT_TOKEN(anon_sym_struct); + END_STATE(); + case 308: + ACCEPT_TOKEN(anon_sym_struct); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 309: + ACCEPT_TOKEN(anon_sym_union); + END_STATE(); + case 310: + ACCEPT_TOKEN(anon_sym_union); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 311: + ACCEPT_TOKEN(anon_sym_AToffset); + END_STATE(); + case 312: + ACCEPT_TOKEN(anon_sym_PIPE); + END_STATE(); + case 313: + ACCEPT_TOKEN(anon_sym_PIPE); + if (lookahead == '=') ADVANCE(442); + if (lookahead == '|') ADVANCE(422); + END_STATE(); + case 314: + ACCEPT_TOKEN(anon_sym_PIPE); + if (lookahead == '|') ADVANCE(422); + END_STATE(); + case 315: + ACCEPT_TOKEN(anon_sym_LBRACK); + END_STATE(); + case 316: + ACCEPT_TOKEN(anon_sym_RBRACK); + END_STATE(); + case 317: + ACCEPT_TOKEN(anon_sym__); + END_STATE(); + case 318: + ACCEPT_TOKEN(anon_sym__); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 319: + ACCEPT_TOKEN(anon_sym_DOT_DOT_DOT); + END_STATE(); + case 320: + ACCEPT_TOKEN(anon_sym_true); + END_STATE(); + case 321: + ACCEPT_TOKEN(anon_sym_true); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 322: + ACCEPT_TOKEN(anon_sym_false); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 323: + ACCEPT_TOKEN(anon_sym_null); + END_STATE(); + case 324: + ACCEPT_TOKEN(anon_sym_null); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 325: + ACCEPT_TOKEN(anon_sym_0x); + END_STATE(); + case 326: + ACCEPT_TOKEN(anon_sym_0o); + END_STATE(); + case 327: + ACCEPT_TOKEN(anon_sym_0b); + END_STATE(); + case 328: + ACCEPT_TOKEN(anon_sym_0); + END_STATE(); + case 329: + ACCEPT_TOKEN(anon_sym_0); + if (lookahead == 'b') ADVANCE(327); + if (lookahead == 'o') ADVANCE(326); + if (lookahead == 'x') ADVANCE(325); + END_STATE(); + case 330: + ACCEPT_TOKEN(anon_sym_1); + END_STATE(); + case 331: + ACCEPT_TOKEN(anon_sym_2); + END_STATE(); + case 332: + ACCEPT_TOKEN(anon_sym_3); + END_STATE(); + case 333: + ACCEPT_TOKEN(anon_sym_4); + END_STATE(); + case 334: + ACCEPT_TOKEN(anon_sym_5); + END_STATE(); + case 335: + ACCEPT_TOKEN(anon_sym_6); + END_STATE(); + case 336: + ACCEPT_TOKEN(anon_sym_7); + END_STATE(); + case 337: + ACCEPT_TOKEN(anon_sym_8); + END_STATE(); + case 338: + ACCEPT_TOKEN(anon_sym_9); + END_STATE(); + case 339: + ACCEPT_TOKEN(anon_sym_A); + END_STATE(); + case 340: + ACCEPT_TOKEN(anon_sym_B); + END_STATE(); + case 341: + ACCEPT_TOKEN(anon_sym_C); + END_STATE(); + case 342: + ACCEPT_TOKEN(anon_sym_D); + END_STATE(); + case 343: + ACCEPT_TOKEN(anon_sym_E); + END_STATE(); + case 344: + ACCEPT_TOKEN(anon_sym_F); + END_STATE(); + case 345: + ACCEPT_TOKEN(anon_sym_a); + if (lookahead == 'l') ADVANCE(145); + if (lookahead == 'p') ADVANCE(171); + if (lookahead == 's') ADVANCE(400); + END_STATE(); + case 346: + ACCEPT_TOKEN(anon_sym_a); + if (lookahead == 's') ADVANCE(400); + END_STATE(); + case 347: + ACCEPT_TOKEN(anon_sym_b); + END_STATE(); + case 348: + ACCEPT_TOKEN(anon_sym_b); + if (lookahead == 'o') ADVANCE(164); + if (lookahead == 'r') ADVANCE(109); + END_STATE(); + case 349: + ACCEPT_TOKEN(anon_sym_c); + END_STATE(); + case 350: + ACCEPT_TOKEN(anon_sym_c); + if (lookahead == 'h') ADVANCE(89); + if (lookahead == 'o') ADVANCE(149); + END_STATE(); + case 351: + ACCEPT_TOKEN(anon_sym_d); + END_STATE(); + case 352: + ACCEPT_TOKEN(anon_sym_e); + if (lookahead == 'l') ADVANCE(187); + END_STATE(); + case 353: + ACCEPT_TOKEN(anon_sym_e); + if (lookahead == 'l') ADVANCE(187); + if (lookahead == 'n') ADVANCE(212); + if (lookahead == 'x') ADVANCE(173); + END_STATE(); + case 354: + ACCEPT_TOKEN(anon_sym_f); + END_STATE(); + case 355: + ACCEPT_TOKEN(anon_sym_f); + if (lookahead == 'n') ADVANCE(258); + if (lookahead == 'o') ADVANCE(174); + if (lookahead == 'r') ADVANCE(113); + END_STATE(); + case 356: + ACCEPT_TOKEN(anon_sym_i); + if (lookahead == '1') ADVANCE(82); + if (lookahead == '3') ADVANCE(74); + if (lookahead == '6') ADVANCE(79); + if (lookahead == '8') ADVANCE(272); + if (lookahead == 'f') ADVANCE(423); + if (lookahead == 'n') ADVANCE(194); + if (lookahead == 's') ADVANCE(401); + END_STATE(); + case 357: + ACCEPT_TOKEN(anon_sym_i); + if (lookahead == '1') ADVANCE(82); + if (lookahead == '3') ADVANCE(74); + if (lookahead == '6') ADVANCE(79); + if (lookahead == '8') ADVANCE(272); + if (lookahead == 's') ADVANCE(401); + END_STATE(); + case 358: + ACCEPT_TOKEN(anon_sym_u); + if (lookahead == '1') ADVANCE(83); + if (lookahead == '3') ADVANCE(75); + if (lookahead == '6') ADVANCE(80); + if (lookahead == '8') ADVANCE(280); + END_STATE(); + case 359: + ACCEPT_TOKEN(anon_sym_u); + if (lookahead == '1') ADVANCE(83); + if (lookahead == '3') ADVANCE(75); + if (lookahead == '6') ADVANCE(80); + if (lookahead == '8') ADVANCE(280); + if (lookahead == 'n') ADVANCE(134); + if (lookahead == 's') ADVANCE(100); + END_STATE(); + case 360: + ACCEPT_TOKEN(anon_sym_z); + END_STATE(); + case 361: + ACCEPT_TOKEN(anon_sym_DOT); + if (lookahead == '.') ADVANCE(390); + END_STATE(); + case 362: + ACCEPT_TOKEN(anon_sym_DOT); + if (lookahead == '.') ADVANCE(389); + END_STATE(); + case 363: + ACCEPT_TOKEN(anon_sym_DOT); + if (lookahead == '.') ADVANCE(62); + END_STATE(); + case 364: + ACCEPT_TOKEN(anon_sym_SQUOTE); + END_STATE(); + case 365: + ACCEPT_TOKEN(aux_sym_rune_token1); + END_STATE(); + case 366: + ACCEPT_TOKEN(aux_sym_rune_token1); + if (lookahead == '/') ADVANCE(587); + END_STATE(); + case 367: + ACCEPT_TOKEN(anon_sym_BSLASH); + END_STATE(); + case 368: + ACCEPT_TOKEN(aux_sym_escape_sequence_token1); + END_STATE(); + case 369: + ACCEPT_TOKEN(aux_sym_named_escape_token1); + END_STATE(); + case 370: + ACCEPT_TOKEN(anon_sym_DQUOTE); + END_STATE(); + case 371: + ACCEPT_TOKEN(aux_sym_string_char_token1); + END_STATE(); + case 372: + ACCEPT_TOKEN(aux_sym_string_char_token1); + if (lookahead == '/') ADVANCE(587); + END_STATE(); + case 373: + ACCEPT_TOKEN(anon_sym_alloc); + END_STATE(); + case 374: + ACCEPT_TOKEN(anon_sym_alloc); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 375: + ACCEPT_TOKEN(anon_sym_append); + END_STATE(); + case 376: + ACCEPT_TOKEN(anon_sym_append); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 377: + ACCEPT_TOKEN(anon_sym_free); + END_STATE(); + case 378: + ACCEPT_TOKEN(anon_sym_free); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 379: + ACCEPT_TOKEN(anon_sym_delete); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 380: + ACCEPT_TOKEN(anon_sym_assert); + END_STATE(); + case 381: + ACCEPT_TOKEN(anon_sym_assert); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 382: + ACCEPT_TOKEN(anon_sym_static); + END_STATE(); + case 383: + ACCEPT_TOKEN(anon_sym_static); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 384: + ACCEPT_TOKEN(anon_sym_abort); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 385: + ACCEPT_TOKEN(anon_sym_len); + END_STATE(); + case 386: + ACCEPT_TOKEN(anon_sym_len); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 387: + ACCEPT_TOKEN(anon_sym_offset); + END_STATE(); + case 388: + ACCEPT_TOKEN(anon_sym_offset); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 389: + ACCEPT_TOKEN(anon_sym_DOT_DOT); + END_STATE(); + case 390: + ACCEPT_TOKEN(anon_sym_DOT_DOT); + if (lookahead == '.') ADVANCE(319); + END_STATE(); + case 391: + ACCEPT_TOKEN(anon_sym_QMARK); + END_STATE(); + case 392: + ACCEPT_TOKEN(anon_sym_PLUS); + END_STATE(); + case 393: + ACCEPT_TOKEN(anon_sym_PLUS); + if (lookahead == '=') ADVANCE(434); + END_STATE(); + case 394: + ACCEPT_TOKEN(anon_sym_DASH); + END_STATE(); + case 395: + ACCEPT_TOKEN(anon_sym_DASH); + if (lookahead == '=') ADVANCE(435); + END_STATE(); + case 396: + ACCEPT_TOKEN(anon_sym_TILDE); + END_STATE(); + case 397: + ACCEPT_TOKEN(anon_sym_AMP); + END_STATE(); + case 398: + ACCEPT_TOKEN(anon_sym_AMP); + if (lookahead == '&') ADVANCE(420); + END_STATE(); + case 399: + ACCEPT_TOKEN(anon_sym_AMP); + if (lookahead == '&') ADVANCE(420); + if (lookahead == '=') ADVANCE(441); + END_STATE(); + case 400: + ACCEPT_TOKEN(anon_sym_as); + END_STATE(); + case 401: + ACCEPT_TOKEN(anon_sym_is); + END_STATE(); + case 402: + ACCEPT_TOKEN(anon_sym_SLASH); + if (lookahead == '/') ADVANCE(587); + END_STATE(); + case 403: + ACCEPT_TOKEN(anon_sym_SLASH); + if (lookahead == '/') ADVANCE(587); + if (lookahead == '=') ADVANCE(437); + END_STATE(); + case 404: + ACCEPT_TOKEN(anon_sym_PERCENT); + END_STATE(); + case 405: + ACCEPT_TOKEN(anon_sym_PERCENT); + if (lookahead == '=') ADVANCE(438); + END_STATE(); + case 406: + ACCEPT_TOKEN(anon_sym_LT_LT); + END_STATE(); + case 407: + ACCEPT_TOKEN(anon_sym_LT_LT); + if (lookahead == '=') ADVANCE(439); + END_STATE(); + case 408: + ACCEPT_TOKEN(anon_sym_GT_GT); + END_STATE(); + case 409: + ACCEPT_TOKEN(anon_sym_GT_GT); + if (lookahead == '=') ADVANCE(440); + END_STATE(); + case 410: + ACCEPT_TOKEN(anon_sym_CARET); + if (lookahead == '=') ADVANCE(443); + if (lookahead == '^') ADVANCE(421); + END_STATE(); + case 411: + ACCEPT_TOKEN(anon_sym_CARET); + if (lookahead == '^') ADVANCE(421); + END_STATE(); + case 412: + ACCEPT_TOKEN(anon_sym_LT); + if (lookahead == '<') ADVANCE(407); + if (lookahead == '=') ADVANCE(416); + END_STATE(); + case 413: + ACCEPT_TOKEN(anon_sym_LT); + if (lookahead == '<') ADVANCE(406); + if (lookahead == '=') ADVANCE(416); + END_STATE(); + case 414: + ACCEPT_TOKEN(anon_sym_GT); + if (lookahead == '=') ADVANCE(417); + if (lookahead == '>') ADVANCE(409); + END_STATE(); + case 415: + ACCEPT_TOKEN(anon_sym_GT); + if (lookahead == '=') ADVANCE(417); + if (lookahead == '>') ADVANCE(408); + END_STATE(); + case 416: + ACCEPT_TOKEN(anon_sym_LT_EQ); + END_STATE(); + case 417: + ACCEPT_TOKEN(anon_sym_GT_EQ); + END_STATE(); + case 418: + ACCEPT_TOKEN(anon_sym_EQ_EQ); + END_STATE(); + case 419: + ACCEPT_TOKEN(anon_sym_BANG_EQ); + END_STATE(); + case 420: + ACCEPT_TOKEN(anon_sym_AMP_AMP); + END_STATE(); + case 421: + ACCEPT_TOKEN(anon_sym_CARET_CARET); + END_STATE(); + case 422: + ACCEPT_TOKEN(anon_sym_PIPE_PIPE); + END_STATE(); + case 423: + ACCEPT_TOKEN(anon_sym_if); + END_STATE(); + case 424: + ACCEPT_TOKEN(anon_sym_if); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 425: + ACCEPT_TOKEN(anon_sym_else); + END_STATE(); + case 426: + ACCEPT_TOKEN(anon_sym_else); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 427: + ACCEPT_TOKEN(anon_sym_for); + END_STATE(); + case 428: + ACCEPT_TOKEN(anon_sym_for); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 429: + ACCEPT_TOKEN(anon_sym_switch); + END_STATE(); + case 430: + ACCEPT_TOKEN(anon_sym_switch); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 431: + ACCEPT_TOKEN(anon_sym_EQ_GT); + END_STATE(); + case 432: + ACCEPT_TOKEN(anon_sym_match); + END_STATE(); + case 433: + ACCEPT_TOKEN(anon_sym_match); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 434: + ACCEPT_TOKEN(anon_sym_PLUS_EQ); + END_STATE(); + case 435: + ACCEPT_TOKEN(anon_sym_DASH_EQ); + END_STATE(); + case 436: + ACCEPT_TOKEN(anon_sym_STAR_EQ); + END_STATE(); + case 437: + ACCEPT_TOKEN(anon_sym_SLASH_EQ); + END_STATE(); + case 438: + ACCEPT_TOKEN(anon_sym_PERCENT_EQ); + END_STATE(); + case 439: + ACCEPT_TOKEN(anon_sym_LT_LT_EQ); + END_STATE(); + case 440: + ACCEPT_TOKEN(anon_sym_GT_GT_EQ); + END_STATE(); + case 441: + ACCEPT_TOKEN(anon_sym_AMP_EQ); + END_STATE(); + case 442: + ACCEPT_TOKEN(anon_sym_PIPE_EQ); + END_STATE(); + case 443: + ACCEPT_TOKEN(anon_sym_CARET_EQ); + END_STATE(); + case 444: + ACCEPT_TOKEN(anon_sym_defer); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 445: + ACCEPT_TOKEN(anon_sym_break); + END_STATE(); + case 446: + ACCEPT_TOKEN(anon_sym_break); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 447: + ACCEPT_TOKEN(anon_sym_continue); + END_STATE(); + case 448: + ACCEPT_TOKEN(anon_sym_continue); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 449: + ACCEPT_TOKEN(anon_sym_return); + END_STATE(); + case 450: + ACCEPT_TOKEN(anon_sym_return); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 451: + ACCEPT_TOKEN(sym_name); + if (lookahead == '1') ADVANCE(460); + if (lookahead == '3') ADVANCE(454); + if (lookahead == '6') ADVANCE(458); + if (lookahead == '8') ADVANCE(273); + if (lookahead == 'n') ADVANCE(569); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 452: + ACCEPT_TOKEN(sym_name); + if (lookahead == '1') ADVANCE(461); + if (lookahead == '3') ADVANCE(455); + if (lookahead == '6') ADVANCE(459); + if (lookahead == '8') ADVANCE(281); + if (lookahead == 'i') ADVANCE(536); + if (lookahead == 'n') ADVANCE(513); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 453: + ACCEPT_TOKEN(sym_name); + if (lookahead == '2') ADVANCE(299); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 454: + ACCEPT_TOKEN(sym_name); + if (lookahead == '2') ADVANCE(277); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 455: + ACCEPT_TOKEN(sym_name); + if (lookahead == '2') ADVANCE(285); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 456: + ACCEPT_TOKEN(sym_name); + if (lookahead == '3') ADVANCE(453); + if (lookahead == '6') ADVANCE(457); + if (lookahead == 'n') ADVANCE(259); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 457: + ACCEPT_TOKEN(sym_name); + if (lookahead == '4') ADVANCE(301); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 458: + ACCEPT_TOKEN(sym_name); + if (lookahead == '4') ADVANCE(279); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 459: + ACCEPT_TOKEN(sym_name); + if (lookahead == '4') ADVANCE(287); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 460: + ACCEPT_TOKEN(sym_name); + if (lookahead == '6') ADVANCE(275); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 461: + ACCEPT_TOKEN(sym_name); + if (lookahead == '6') ADVANCE(283); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 462: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'a') ADVANCE(563); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 463: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'a') ADVANCE(515); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 464: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'a') ADVANCE(470); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 465: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'a') ADVANCE(572); + if (lookahead == 'r') ADVANCE(579); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 466: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'a') ADVANCE(549); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 467: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'a') ADVANCE(525); + if (lookahead == 'o') ADVANCE(547); + if (lookahead == 'r') ADVANCE(497); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 468: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'a') ADVANCE(525); + if (lookahead == 'r') ADVANCE(497); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 469: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'b') ADVANCE(542); + if (lookahead == 'l') ADVANCE(518); + if (lookahead == 'p') ADVANCE(546); + if (lookahead == 's') ADVANCE(559); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 470: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'b') ADVANCE(523); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 471: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'c') ADVANCE(503); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 472: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'c') ADVANCE(374); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 473: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'c') ADVANCE(383); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 474: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'c') ADVANCE(504); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 475: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'c') ADVANCE(568); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 476: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'd') ADVANCE(271); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 477: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'd') ADVANCE(376); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 478: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'e') ADVANCE(501); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 479: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'e') ADVANCE(528); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 480: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'e') ADVANCE(426); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 481: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'e') ADVANCE(378); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 482: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'e') ADVANCE(293); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 483: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'e') ADVANCE(321); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 484: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'e') ADVANCE(322); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 485: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'e') ADVANCE(379); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 486: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'e') ADVANCE(448); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 487: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'e') ADVANCE(267); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 488: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'e') ADVANCE(306); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 489: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'e') ADVANCE(463); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 490: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'e') ADVANCE(533); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 491: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'e') ADVANCE(571); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 492: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'e') ADVANCE(548); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 493: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'e') ADVANCE(522); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 494: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'e') ADVANCE(529); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 495: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'e') ADVANCE(574); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 496: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'e') ADVANCE(567); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 497: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'e') ADVANCE(481); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 498: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'e') ADVANCE(556); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 499: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'f') ADVANCE(424); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 500: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'f') ADVANCE(502); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 501: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'f') ADVANCE(492); + if (lookahead == 'l') ADVANCE(495); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 502: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'f') ADVANCE(562); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 503: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'h') ADVANCE(433); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 504: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'h') ADVANCE(430); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 505: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'h') ADVANCE(466); + if (lookahead == 'o') ADVANCE(532); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 506: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'h') ADVANCE(466); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 507: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'i') ADVANCE(585); + if (lookahead == 't') ADVANCE(465); + if (lookahead == 'w') ADVANCE(514); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 508: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'i') ADVANCE(585); + if (lookahead == 't') ADVANCE(465); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 509: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'i') ADVANCE(585); + if (lookahead == 't') ADVANCE(553); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 510: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'i') ADVANCE(476); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 511: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'i') ADVANCE(538); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 512: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'i') ADVANCE(473); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 513: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'i') ADVANCE(545); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 514: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'i') ADVANCE(575); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 515: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'k') ADVANCE(446); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 516: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'l') ADVANCE(324); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 517: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'l') ADVANCE(269); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 518: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'l') ADVANCE(541); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 519: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'l') ADVANCE(516); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 520: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'l') ADVANCE(464); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 521: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'l') ADVANCE(520); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 522: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'l') ADVANCE(495); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 523: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'l') ADVANCE(488); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 524: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'l') ADVANCE(560); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 525: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'l') ADVANCE(561); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 526: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'm') ADVANCE(303); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 527: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'n') ADVANCE(557); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 528: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'n') ADVANCE(386); + if (lookahead == 't') ADVANCE(248); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 529: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'n') ADVANCE(386); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 530: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'n') ADVANCE(450); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 531: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'n') ADVANCE(310); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 532: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'n') ADVANCE(558); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 533: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'n') ADVANCE(477); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 534: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'n') ADVANCE(513); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 535: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'n') ADVANCE(577); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 536: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'n') ADVANCE(570); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 537: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'n') ADVANCE(487); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 538: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'n') ADVANCE(583); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 539: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'o') ADVANCE(527); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 540: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'o') ADVANCE(510); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 541: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'o') ADVANCE(472); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 542: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'o') ADVANCE(555); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 543: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'o') ADVANCE(544); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 544: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'o') ADVANCE(517); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 545: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'o') ADVANCE(531); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 546: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'p') ADVANCE(490); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 547: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'r') ADVANCE(428); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 548: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'r') ADVANCE(444); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 549: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'r') ADVANCE(297); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 550: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'r') ADVANCE(295); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 551: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'r') ADVANCE(582); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 552: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'r') ADVANCE(489); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 553: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'r') ADVANCE(579); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 554: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'r') ADVANCE(530); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 555: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'r') ADVANCE(564); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 556: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'r') ADVANCE(566); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 557: + ACCEPT_TOKEN(sym_name); + if (lookahead == 's') ADVANCE(565); + if (lookahead == 't') ADVANCE(511); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 558: + ACCEPT_TOKEN(sym_name); + if (lookahead == 's') ADVANCE(565); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 559: + ACCEPT_TOKEN(sym_name); + if (lookahead == 's') ADVANCE(498); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 560: + ACCEPT_TOKEN(sym_name); + if (lookahead == 's') ADVANCE(480); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 561: + ACCEPT_TOKEN(sym_name); + if (lookahead == 's') ADVANCE(484); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 562: + ACCEPT_TOKEN(sym_name); + if (lookahead == 's') ADVANCE(496); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 563: + ACCEPT_TOKEN(sym_name); + if (lookahead == 't') ADVANCE(471); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 564: + ACCEPT_TOKEN(sym_name); + if (lookahead == 't') ADVANCE(384); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 565: + ACCEPT_TOKEN(sym_name); + if (lookahead == 't') ADVANCE(250); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 566: + ACCEPT_TOKEN(sym_name); + if (lookahead == 't') ADVANCE(381); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 567: + ACCEPT_TOKEN(sym_name); + if (lookahead == 't') ADVANCE(388); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 568: + ACCEPT_TOKEN(sym_name); + if (lookahead == 't') ADVANCE(308); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 569: + ACCEPT_TOKEN(sym_name); + if (lookahead == 't') ADVANCE(289); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 570: + ACCEPT_TOKEN(sym_name); + if (lookahead == 't') ADVANCE(290); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 571: + ACCEPT_TOKEN(sym_name); + if (lookahead == 't') ADVANCE(580); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 572: + ACCEPT_TOKEN(sym_name); + if (lookahead == 't') ADVANCE(512); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 573: + ACCEPT_TOKEN(sym_name); + if (lookahead == 't') ADVANCE(550); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 574: + ACCEPT_TOKEN(sym_name); + if (lookahead == 't') ADVANCE(485); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 575: + ACCEPT_TOKEN(sym_name); + if (lookahead == 't') ADVANCE(474); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 576: + ACCEPT_TOKEN(sym_name); + if (lookahead == 't') ADVANCE(553); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 577: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'u') ADVANCE(526); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 578: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'u') ADVANCE(519); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 579: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'u') ADVANCE(475); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 580: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'u') ADVANCE(554); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 581: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'u') ADVANCE(537); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 582: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'u') ADVANCE(483); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 583: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'u') ADVANCE(486); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 584: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'u') ADVANCE(521); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 585: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'z') ADVANCE(482); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'y')) ADVANCE(586); + END_STATE(); + case 586: + ACCEPT_TOKEN(sym_name); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + END_STATE(); + case 587: + ACCEPT_TOKEN(sym_comment); + if (lookahead == '\\') ADVANCE(230); + if (lookahead != 0 && + lookahead != '\n') ADVANCE(587); + END_STATE(); + case 588: + ACCEPT_TOKEN(sym_comment); + if (lookahead != 0 && + lookahead != '\\') ADVANCE(587); + if (lookahead == '\\') ADVANCE(230); + END_STATE(); + default: + return false; + } +} + +static TSLexMode ts_lex_modes[STATE_COUNT] = { + [0] = {.lex_state = 0}, + [1] = {.lex_state = 235}, + [2] = {.lex_state = 50}, + [3] = {.lex_state = 51}, + [4] = {.lex_state = 53}, + [5] = {.lex_state = 51}, + [6] = {.lex_state = 54}, + [7] = {.lex_state = 51}, + [8] = {.lex_state = 52}, + [9] = {.lex_state = 51}, + [10] = {.lex_state = 51}, + [11] = {.lex_state = 51}, + [12] = {.lex_state = 51}, + [13] = {.lex_state = 51}, + [14] = {.lex_state = 52}, + [15] = {.lex_state = 52}, + [16] = {.lex_state = 52}, + [17] = {.lex_state = 51}, + [18] = {.lex_state = 52}, + [19] = {.lex_state = 51}, + [20] = {.lex_state = 51}, + [21] = {.lex_state = 51}, + [22] = {.lex_state = 54}, + [23] = {.lex_state = 51}, + [24] = {.lex_state = 54}, + [25] = {.lex_state = 51}, + [26] = {.lex_state = 51}, + [27] = {.lex_state = 51}, + [28] = {.lex_state = 51}, + [29] = {.lex_state = 51}, + [30] = {.lex_state = 54}, + [31] = {.lex_state = 51}, + [32] = {.lex_state = 51}, + [33] = {.lex_state = 51}, + [34] = {.lex_state = 51}, + [35] = {.lex_state = 51}, + [36] = {.lex_state = 51}, + [37] = {.lex_state = 51}, + [38] = {.lex_state = 51}, + [39] = {.lex_state = 51}, + [40] = {.lex_state = 51}, + [41] = {.lex_state = 51}, + [42] = {.lex_state = 51}, + [43] = {.lex_state = 51}, + [44] = {.lex_state = 51}, + [45] = {.lex_state = 51}, + [46] = {.lex_state = 51}, + [47] = {.lex_state = 51}, + [48] = {.lex_state = 51}, + [49] = {.lex_state = 51}, + [50] = {.lex_state = 51}, + [51] = {.lex_state = 51}, + [52] = {.lex_state = 51}, + [53] = {.lex_state = 51}, + [54] = {.lex_state = 51}, + [55] = {.lex_state = 51}, + [56] = {.lex_state = 51}, + [57] = {.lex_state = 51}, + [58] = {.lex_state = 51}, + [59] = {.lex_state = 51}, + [60] = {.lex_state = 51}, + [61] = {.lex_state = 51}, + [62] = {.lex_state = 51}, + [63] = {.lex_state = 51}, + [64] = {.lex_state = 51}, + [65] = {.lex_state = 51}, + [66] = {.lex_state = 51}, + [67] = {.lex_state = 51}, + [68] = {.lex_state = 51}, + [69] = {.lex_state = 51}, + [70] = {.lex_state = 51}, + [71] = {.lex_state = 51}, + [72] = {.lex_state = 51}, + [73] = {.lex_state = 51}, + [74] = {.lex_state = 51}, + [75] = {.lex_state = 51}, + [76] = {.lex_state = 51}, + [77] = {.lex_state = 51}, + [78] = {.lex_state = 51}, + [79] = {.lex_state = 51}, + [80] = {.lex_state = 51}, + [81] = {.lex_state = 51}, + [82] = {.lex_state = 51}, + [83] = {.lex_state = 51}, + [84] = {.lex_state = 51}, + [85] = {.lex_state = 51}, + [86] = {.lex_state = 51}, + [87] = {.lex_state = 51}, + [88] = {.lex_state = 51}, + [89] = {.lex_state = 51}, + [90] = {.lex_state = 51}, + [91] = {.lex_state = 51}, + [92] = {.lex_state = 51}, + [93] = {.lex_state = 51}, + [94] = {.lex_state = 51}, + [95] = {.lex_state = 51}, + [96] = {.lex_state = 51}, + [97] = {.lex_state = 51}, + [98] = {.lex_state = 51}, + [99] = {.lex_state = 51}, + [100] = {.lex_state = 51}, + [101] = {.lex_state = 51}, + [102] = {.lex_state = 51}, + [103] = {.lex_state = 56}, + [104] = {.lex_state = 45}, + [105] = {.lex_state = 56}, + [106] = {.lex_state = 45}, + [107] = {.lex_state = 45}, + [108] = {.lex_state = 55}, + [109] = {.lex_state = 55}, + [110] = {.lex_state = 55}, + [111] = {.lex_state = 55}, + [112] = {.lex_state = 55}, + [113] = {.lex_state = 55}, + [114] = {.lex_state = 46}, + [115] = {.lex_state = 46}, + [116] = {.lex_state = 55}, + [117] = {.lex_state = 55}, + [118] = {.lex_state = 44}, + [119] = {.lex_state = 44}, + [120] = {.lex_state = 46}, + [121] = {.lex_state = 55}, + [122] = {.lex_state = 55}, + [123] = {.lex_state = 44}, + [124] = {.lex_state = 55}, + [125] = {.lex_state = 55}, + [126] = {.lex_state = 55}, + [127] = {.lex_state = 55}, + [128] = {.lex_state = 45}, + [129] = {.lex_state = 55}, + [130] = {.lex_state = 55}, + [131] = {.lex_state = 55}, + [132] = {.lex_state = 55}, + [133] = {.lex_state = 55}, + [134] = {.lex_state = 55}, + [135] = {.lex_state = 55}, + [136] = {.lex_state = 55}, + [137] = {.lex_state = 45}, + [138] = {.lex_state = 55}, + [139] = {.lex_state = 45}, + [140] = {.lex_state = 46}, + [141] = {.lex_state = 55}, + [142] = {.lex_state = 55}, + [143] = {.lex_state = 45}, + [144] = {.lex_state = 55}, + [145] = {.lex_state = 45}, + [146] = {.lex_state = 48}, + [147] = {.lex_state = 55}, + [148] = {.lex_state = 48}, + [149] = {.lex_state = 46}, + [150] = {.lex_state = 55}, + [151] = {.lex_state = 55}, + [152] = {.lex_state = 55}, + [153] = {.lex_state = 45}, + [154] = {.lex_state = 55}, + [155] = {.lex_state = 55}, + [156] = {.lex_state = 45}, + [157] = {.lex_state = 46}, + [158] = {.lex_state = 48}, + [159] = {.lex_state = 45}, + [160] = {.lex_state = 44}, + [161] = {.lex_state = 44}, + [162] = {.lex_state = 44}, + [163] = {.lex_state = 48}, + [164] = {.lex_state = 58}, + [165] = {.lex_state = 51}, + [166] = {.lex_state = 46}, + [167] = {.lex_state = 44}, + [168] = {.lex_state = 44}, + [169] = {.lex_state = 58}, + [170] = {.lex_state = 58}, + [171] = {.lex_state = 58}, + [172] = {.lex_state = 58}, + [173] = {.lex_state = 48}, + [174] = {.lex_state = 235}, + [175] = {.lex_state = 44}, + [176] = {.lex_state = 58}, + [177] = {.lex_state = 0}, + [178] = {.lex_state = 44}, + [179] = {.lex_state = 58}, + [180] = {.lex_state = 58}, + [181] = {.lex_state = 58}, + [182] = {.lex_state = 58}, + [183] = {.lex_state = 58}, + [184] = {.lex_state = 58}, + [185] = {.lex_state = 0}, + [186] = {.lex_state = 58}, + [187] = {.lex_state = 58}, + [188] = {.lex_state = 58}, + [189] = {.lex_state = 58}, + [190] = {.lex_state = 58}, + [191] = {.lex_state = 58}, + [192] = {.lex_state = 0}, + [193] = {.lex_state = 48}, + [194] = {.lex_state = 58}, + [195] = {.lex_state = 0}, + [196] = {.lex_state = 58}, + [197] = {.lex_state = 0}, + [198] = {.lex_state = 58}, + [199] = {.lex_state = 0}, + [200] = {.lex_state = 58}, + [201] = {.lex_state = 58}, + [202] = {.lex_state = 58}, + [203] = {.lex_state = 58}, + [204] = {.lex_state = 0}, + [205] = {.lex_state = 58}, + [206] = {.lex_state = 58}, + [207] = {.lex_state = 58}, + [208] = {.lex_state = 58}, + [209] = {.lex_state = 0}, + [210] = {.lex_state = 58}, + [211] = {.lex_state = 58}, + [212] = {.lex_state = 44}, + [213] = {.lex_state = 58}, + [214] = {.lex_state = 58}, + [215] = {.lex_state = 58}, + [216] = {.lex_state = 58}, + [217] = {.lex_state = 58}, + [218] = {.lex_state = 58}, + [219] = {.lex_state = 0}, + [220] = {.lex_state = 0}, + [221] = {.lex_state = 0}, + [222] = {.lex_state = 0}, + [223] = {.lex_state = 0}, + [224] = {.lex_state = 0}, + [225] = {.lex_state = 0}, + [226] = {.lex_state = 0}, + [227] = {.lex_state = 0}, + [228] = {.lex_state = 0}, + [229] = {.lex_state = 0}, + [230] = {.lex_state = 0}, + [231] = {.lex_state = 0}, + [232] = {.lex_state = 0}, + [233] = {.lex_state = 0}, + [234] = {.lex_state = 0}, + [235] = {.lex_state = 0}, + [236] = {.lex_state = 0}, + [237] = {.lex_state = 0}, + [238] = {.lex_state = 0}, + [239] = {.lex_state = 0}, + [240] = {.lex_state = 0}, + [241] = {.lex_state = 0}, + [242] = {.lex_state = 0}, + [243] = {.lex_state = 0}, + [244] = {.lex_state = 0}, + [245] = {.lex_state = 0}, + [246] = {.lex_state = 0}, + [247] = {.lex_state = 0}, + [248] = {.lex_state = 0}, + [249] = {.lex_state = 0}, + [250] = {.lex_state = 0}, + [251] = {.lex_state = 0}, + [252] = {.lex_state = 0}, + [253] = {.lex_state = 0}, + [254] = {.lex_state = 0}, + [255] = {.lex_state = 0}, + [256] = {.lex_state = 0}, + [257] = {.lex_state = 0}, + [258] = {.lex_state = 0}, + [259] = {.lex_state = 0}, + [260] = {.lex_state = 0}, + [261] = {.lex_state = 59}, + [262] = {.lex_state = 59}, + [263] = {.lex_state = 0}, + [264] = {.lex_state = 0}, + [265] = {.lex_state = 0}, + [266] = {.lex_state = 0}, + [267] = {.lex_state = 48}, + [268] = {.lex_state = 47}, + [269] = {.lex_state = 44}, + [270] = {.lex_state = 48}, + [271] = {.lex_state = 47}, + [272] = {.lex_state = 44}, + [273] = {.lex_state = 44}, + [274] = {.lex_state = 44}, + [275] = {.lex_state = 44}, + [276] = {.lex_state = 44}, + [277] = {.lex_state = 44}, + [278] = {.lex_state = 44}, + [279] = {.lex_state = 44}, + [280] = {.lex_state = 44}, + [281] = {.lex_state = 44}, + [282] = {.lex_state = 44}, + [283] = {.lex_state = 44}, + [284] = {.lex_state = 44}, + [285] = {.lex_state = 44}, + [286] = {.lex_state = 44}, + [287] = {.lex_state = 44}, + [288] = {.lex_state = 44}, + [289] = {.lex_state = 44}, + [290] = {.lex_state = 44}, + [291] = {.lex_state = 44}, + [292] = {.lex_state = 44}, + [293] = {.lex_state = 44}, + [294] = {.lex_state = 44}, + [295] = {.lex_state = 44}, + [296] = {.lex_state = 44}, + [297] = {.lex_state = 44}, + [298] = {.lex_state = 44}, + [299] = {.lex_state = 44}, + [300] = {.lex_state = 44}, + [301] = {.lex_state = 44}, + [302] = {.lex_state = 44}, + [303] = {.lex_state = 44}, + [304] = {.lex_state = 44}, + [305] = {.lex_state = 44}, + [306] = {.lex_state = 44}, + [307] = {.lex_state = 44}, + [308] = {.lex_state = 44}, + [309] = {.lex_state = 44}, + [310] = {.lex_state = 44}, + [311] = {.lex_state = 44}, + [312] = {.lex_state = 44}, + [313] = {.lex_state = 44}, + [314] = {.lex_state = 44}, + [315] = {.lex_state = 44}, + [316] = {.lex_state = 44}, + [317] = {.lex_state = 44}, + [318] = {.lex_state = 44}, + [319] = {.lex_state = 44}, + [320] = {.lex_state = 44}, + [321] = {.lex_state = 44}, + [322] = {.lex_state = 44}, + [323] = {.lex_state = 44}, + [324] = {.lex_state = 44}, + [325] = {.lex_state = 44}, + [326] = {.lex_state = 44}, + [327] = {.lex_state = 44}, + [328] = {.lex_state = 49}, + [329] = {.lex_state = 44}, + [330] = {.lex_state = 44}, + [331] = {.lex_state = 44}, + [332] = {.lex_state = 44}, + [333] = {.lex_state = 44}, + [334] = {.lex_state = 44}, + [335] = {.lex_state = 44}, + [336] = {.lex_state = 44}, + [337] = {.lex_state = 44}, + [338] = {.lex_state = 44}, + [339] = {.lex_state = 44}, + [340] = {.lex_state = 44}, + [341] = {.lex_state = 44}, + [342] = {.lex_state = 44}, + [343] = {.lex_state = 44}, + [344] = {.lex_state = 44}, + [345] = {.lex_state = 44}, + [346] = {.lex_state = 44}, + [347] = {.lex_state = 44}, + [348] = {.lex_state = 44}, + [349] = {.lex_state = 44}, + [350] = {.lex_state = 44}, + [351] = {.lex_state = 44}, + [352] = {.lex_state = 44}, + [353] = {.lex_state = 44}, + [354] = {.lex_state = 44}, + [355] = {.lex_state = 49}, + [356] = {.lex_state = 44}, + [357] = {.lex_state = 44}, + [358] = {.lex_state = 45}, + [359] = {.lex_state = 45}, + [360] = {.lex_state = 0}, + [361] = {.lex_state = 235}, + [362] = {.lex_state = 0}, + [363] = {.lex_state = 235}, + [364] = {.lex_state = 235}, + [365] = {.lex_state = 0}, + [366] = {.lex_state = 0}, + [367] = {.lex_state = 0}, + [368] = {.lex_state = 0}, + [369] = {.lex_state = 0}, + [370] = {.lex_state = 235}, + [371] = {.lex_state = 0}, + [372] = {.lex_state = 0}, + [373] = {.lex_state = 0}, + [374] = {.lex_state = 67}, + [375] = {.lex_state = 67}, + [376] = {.lex_state = 0}, + [377] = {.lex_state = 0}, + [378] = {.lex_state = 52}, + [379] = {.lex_state = 235}, + [380] = {.lex_state = 235}, + [381] = {.lex_state = 235}, + [382] = {.lex_state = 235}, + [383] = {.lex_state = 0}, + [384] = {.lex_state = 0}, + [385] = {.lex_state = 235}, + [386] = {.lex_state = 235}, + [387] = {.lex_state = 235}, + [388] = {.lex_state = 235}, + [389] = {.lex_state = 235}, + [390] = {.lex_state = 235}, + [391] = {.lex_state = 52}, + [392] = {.lex_state = 235}, + [393] = {.lex_state = 0}, + [394] = {.lex_state = 0}, + [395] = {.lex_state = 0}, + [396] = {.lex_state = 235}, + [397] = {.lex_state = 0}, + [398] = {.lex_state = 0}, + [399] = {.lex_state = 235}, + [400] = {.lex_state = 0}, + [401] = {.lex_state = 235}, + [402] = {.lex_state = 0}, + [403] = {.lex_state = 0}, + [404] = {.lex_state = 68}, + [405] = {.lex_state = 235}, + [406] = {.lex_state = 0}, + [407] = {.lex_state = 68}, + [408] = {.lex_state = 235}, + [409] = {.lex_state = 68}, + [410] = {.lex_state = 68}, + [411] = {.lex_state = 52}, + [412] = {.lex_state = 0}, + [413] = {.lex_state = 68}, + [414] = {.lex_state = 235}, + [415] = {.lex_state = 235}, + [416] = {.lex_state = 0}, + [417] = {.lex_state = 52}, + [418] = {.lex_state = 52}, + [419] = {.lex_state = 0}, + [420] = {.lex_state = 52}, + [421] = {.lex_state = 52}, + [422] = {.lex_state = 0}, + [423] = {.lex_state = 52}, + [424] = {.lex_state = 52}, + [425] = {.lex_state = 0}, + [426] = {.lex_state = 52}, + [427] = {.lex_state = 52}, + [428] = {.lex_state = 52}, + [429] = {.lex_state = 0}, + [430] = {.lex_state = 0}, + [431] = {.lex_state = 0}, + [432] = {.lex_state = 52}, + [433] = {.lex_state = 0}, + [434] = {.lex_state = 52}, + [435] = {.lex_state = 52}, + [436] = {.lex_state = 0}, + [437] = {.lex_state = 0}, + [438] = {.lex_state = 0}, + [439] = {.lex_state = 0}, + [440] = {.lex_state = 0}, + [441] = {.lex_state = 0}, + [442] = {.lex_state = 0}, + [443] = {.lex_state = 0}, + [444] = {.lex_state = 0}, + [445] = {.lex_state = 0}, + [446] = {.lex_state = 0}, + [447] = {.lex_state = 52}, + [448] = {.lex_state = 52}, + [449] = {.lex_state = 52}, + [450] = {.lex_state = 52}, + [451] = {.lex_state = 0}, + [452] = {.lex_state = 52}, + [453] = {.lex_state = 52}, + [454] = {.lex_state = 52}, + [455] = {.lex_state = 52}, + [456] = {.lex_state = 52}, + [457] = {.lex_state = 0}, + [458] = {.lex_state = 65}, + [459] = {.lex_state = 0}, + [460] = {.lex_state = 65}, + [461] = {.lex_state = 35}, + [462] = {.lex_state = 35}, + [463] = {.lex_state = 35}, + [464] = {.lex_state = 35}, + [465] = {.lex_state = 65}, + [466] = {.lex_state = 65}, + [467] = {.lex_state = 68}, + [468] = {.lex_state = 67}, + [469] = {.lex_state = 235}, + [470] = {.lex_state = 47}, + [471] = {.lex_state = 235}, + [472] = {.lex_state = 67}, + [473] = {.lex_state = 65}, + [474] = {.lex_state = 235}, + [475] = {.lex_state = 60}, + [476] = {.lex_state = 65}, + [477] = {.lex_state = 60}, + [478] = {.lex_state = 65}, + [479] = {.lex_state = 47}, + [480] = {.lex_state = 235}, + [481] = {.lex_state = 60}, + [482] = {.lex_state = 53}, + [483] = {.lex_state = 0}, + [484] = {.lex_state = 0}, + [485] = {.lex_state = 71}, + [486] = {.lex_state = 235}, + [487] = {.lex_state = 0}, + [488] = {.lex_state = 0}, + [489] = {.lex_state = 71}, + [490] = {.lex_state = 47}, + [491] = {.lex_state = 0}, + [492] = {.lex_state = 0}, + [493] = {.lex_state = 67}, + [494] = {.lex_state = 67}, + [495] = {.lex_state = 67}, + [496] = {.lex_state = 0}, + [497] = {.lex_state = 67}, + [498] = {.lex_state = 67}, + [499] = {.lex_state = 0}, + [500] = {.lex_state = 0}, + [501] = {.lex_state = 67}, + [502] = {.lex_state = 0}, + [503] = {.lex_state = 50}, + [504] = {.lex_state = 67}, + [505] = {.lex_state = 67}, + [506] = {.lex_state = 67}, + [507] = {.lex_state = 67}, + [508] = {.lex_state = 67}, + [509] = {.lex_state = 0}, + [510] = {.lex_state = 67}, + [511] = {.lex_state = 67}, + [512] = {.lex_state = 67}, + [513] = {.lex_state = 67}, + [514] = {.lex_state = 67}, + [515] = {.lex_state = 69}, + [516] = {.lex_state = 0}, + [517] = {.lex_state = 52}, + [518] = {.lex_state = 0}, + [519] = {.lex_state = 0}, + [520] = {.lex_state = 0}, + [521] = {.lex_state = 52}, + [522] = {.lex_state = 0}, + [523] = {.lex_state = 35}, + [524] = {.lex_state = 35}, + [525] = {.lex_state = 52}, + [526] = {.lex_state = 67}, + [527] = {.lex_state = 52}, + [528] = {.lex_state = 52}, + [529] = {.lex_state = 0}, + [530] = {.lex_state = 0}, + [531] = {.lex_state = 0}, + [532] = {.lex_state = 67}, + [533] = {.lex_state = 0}, + [534] = {.lex_state = 67}, + [535] = {.lex_state = 69}, + [536] = {.lex_state = 67}, + [537] = {.lex_state = 35}, + [538] = {.lex_state = 35}, + [539] = {.lex_state = 0}, + [540] = {.lex_state = 67}, + [541] = {.lex_state = 0}, + [542] = {.lex_state = 0}, + [543] = {.lex_state = 69}, + [544] = {.lex_state = 69}, + [545] = {.lex_state = 0}, + [546] = {.lex_state = 0}, + [547] = {.lex_state = 67}, + [548] = {.lex_state = 0}, + [549] = {.lex_state = 0}, + [550] = {.lex_state = 52}, + [551] = {.lex_state = 68}, + [552] = {.lex_state = 0}, + [553] = {.lex_state = 0}, + [554] = {.lex_state = 0}, + [555] = {.lex_state = 0}, + [556] = {.lex_state = 53}, + [557] = {.lex_state = 0}, + [558] = {.lex_state = 0}, + [559] = {.lex_state = 0}, + [560] = {.lex_state = 67}, + [561] = {.lex_state = 67}, + [562] = {.lex_state = 67}, + [563] = {.lex_state = 67}, + [564] = {.lex_state = 0}, + [565] = {.lex_state = 0}, + [566] = {.lex_state = 0}, + [567] = {.lex_state = 0}, + [568] = {.lex_state = 0}, + [569] = {.lex_state = 0}, + [570] = {.lex_state = 0}, + [571] = {.lex_state = 0}, + [572] = {.lex_state = 0}, + [573] = {.lex_state = 67}, + [574] = {.lex_state = 0}, + [575] = {.lex_state = 0}, + [576] = {.lex_state = 0}, + [577] = {.lex_state = 0}, + [578] = {.lex_state = 0}, + [579] = {.lex_state = 0}, + [580] = {.lex_state = 0}, + [581] = {.lex_state = 0}, + [582] = {.lex_state = 0}, + [583] = {.lex_state = 0}, + [584] = {.lex_state = 53}, + [585] = {.lex_state = 67}, + [586] = {.lex_state = 67}, + [587] = {.lex_state = 0}, + [588] = {.lex_state = 0}, + [589] = {.lex_state = 0}, + [590] = {.lex_state = 0}, + [591] = {.lex_state = 0}, + [592] = {.lex_state = 53}, + [593] = {.lex_state = 0}, + [594] = {.lex_state = 67}, + [595] = {.lex_state = 0}, + [596] = {.lex_state = 0}, + [597] = {.lex_state = 0}, + [598] = {.lex_state = 0}, + [599] = {.lex_state = 0}, + [600] = {.lex_state = 0}, + [601] = {.lex_state = 0}, + [602] = {.lex_state = 0}, + [603] = {.lex_state = 0}, + [604] = {.lex_state = 0}, + [605] = {.lex_state = 0}, + [606] = {.lex_state = 0}, + [607] = {.lex_state = 67}, + [608] = {.lex_state = 0}, + [609] = {.lex_state = 0}, + [610] = {.lex_state = 0}, + [611] = {.lex_state = 0}, + [612] = {.lex_state = 67}, + [613] = {.lex_state = 0}, + [614] = {.lex_state = 0}, + [615] = {.lex_state = 0}, + [616] = {.lex_state = 0}, + [617] = {.lex_state = 0}, + [618] = {.lex_state = 0}, + [619] = {.lex_state = 0}, + [620] = {.lex_state = 0}, + [621] = {.lex_state = 0}, + [622] = {.lex_state = 0}, + [623] = {.lex_state = 67}, + [624] = {.lex_state = 221}, + [625] = {.lex_state = 0}, + [626] = {.lex_state = 0}, + [627] = {.lex_state = 0}, + [628] = {.lex_state = 0}, + [629] = {.lex_state = 0}, + [630] = {.lex_state = 67}, + [631] = {.lex_state = 0}, + [632] = {.lex_state = 0}, + [633] = {.lex_state = 67}, + [634] = {.lex_state = 0}, + [635] = {.lex_state = 0}, + [636] = {.lex_state = 67}, + [637] = {.lex_state = 221}, + [638] = {.lex_state = 0}, + [639] = {.lex_state = 0}, + [640] = {.lex_state = 50}, + [641] = {.lex_state = 0}, + [642] = {.lex_state = 0}, + [643] = {.lex_state = 0}, + [644] = {.lex_state = 0}, + [645] = {.lex_state = 0}, + [646] = {.lex_state = 0}, + [647] = {.lex_state = 50}, + [648] = {.lex_state = 0}, + [649] = {.lex_state = 235}, + [650] = {.lex_state = 0}, + [651] = {.lex_state = 0}, + [652] = {.lex_state = 0}, + [653] = {.lex_state = 0}, + [654] = {.lex_state = 0}, + [655] = {.lex_state = 0}, + [656] = {.lex_state = 0}, + [657] = {.lex_state = 0}, + [658] = {.lex_state = 0}, + [659] = {.lex_state = 0}, + [660] = {.lex_state = 0}, + [661] = {.lex_state = 0}, + [662] = {.lex_state = 0}, + [663] = {.lex_state = 0}, + [664] = {.lex_state = 0}, + [665] = {.lex_state = 0}, + [666] = {.lex_state = 0}, + [667] = {.lex_state = 0}, + [668] = {.lex_state = 0}, + [669] = {.lex_state = 0}, + [670] = {.lex_state = 0}, + [671] = {.lex_state = 0}, + [672] = {.lex_state = 0}, + [673] = {.lex_state = 0}, + [674] = {.lex_state = 67}, + [675] = {.lex_state = 0}, + [676] = {.lex_state = 0}, + [677] = {.lex_state = 0}, + [678] = {.lex_state = 50}, + [679] = {.lex_state = 0}, + [680] = {.lex_state = 0}, + [681] = {.lex_state = 0}, + [682] = {.lex_state = 0}, + [683] = {.lex_state = 0}, + [684] = {.lex_state = 0}, + [685] = {.lex_state = 0}, + [686] = {.lex_state = 67}, + [687] = {.lex_state = 0}, + [688] = {.lex_state = 0}, + [689] = {.lex_state = 0}, + [690] = {.lex_state = 0}, + [691] = {.lex_state = 0}, + [692] = {.lex_state = 0}, + [693] = {.lex_state = 0}, + [694] = {.lex_state = 0}, + [695] = {.lex_state = 0}, + [696] = {.lex_state = 0}, + [697] = {.lex_state = 0}, + [698] = {.lex_state = 0}, + [699] = {.lex_state = 67}, + [700] = {.lex_state = 0}, + [701] = {.lex_state = 0}, + [702] = {.lex_state = 0}, + [703] = {.lex_state = 0}, + [704] = {.lex_state = 0}, + [705] = {.lex_state = 0}, + [706] = {.lex_state = 0}, + [707] = {.lex_state = 0}, + [708] = {.lex_state = 0}, + [709] = {.lex_state = 67}, + [710] = {.lex_state = 0}, + [711] = {.lex_state = 0}, + [712] = {.lex_state = 0}, + [713] = {.lex_state = 0}, + [714] = {.lex_state = 0}, + [715] = {.lex_state = 0}, + [716] = {.lex_state = 0}, + [717] = {.lex_state = 0}, + [718] = {.lex_state = 0}, + [719] = {.lex_state = 0}, + [720] = {.lex_state = 0}, + [721] = {.lex_state = 0}, + [722] = {.lex_state = 0}, + [723] = {.lex_state = 0}, + [724] = {.lex_state = 0}, + [725] = {.lex_state = 0}, + [726] = {.lex_state = 0}, + [727] = {.lex_state = 0}, + [728] = {.lex_state = 0}, + [729] = {.lex_state = 0}, + [730] = {.lex_state = 235}, + [731] = {.lex_state = 0}, + [732] = {.lex_state = 0}, + [733] = {.lex_state = 0}, + [734] = {.lex_state = 0}, + [735] = {.lex_state = 0}, + [736] = {.lex_state = 0}, + [737] = {.lex_state = 235}, + [738] = {.lex_state = 0}, + [739] = {.lex_state = 0}, + [740] = {.lex_state = 0}, + [741] = {.lex_state = 0}, + [742] = {.lex_state = 0}, + [743] = {.lex_state = 0}, + [744] = {.lex_state = 0}, + [745] = {.lex_state = 0}, + [746] = {.lex_state = 0}, + [747] = {.lex_state = 0}, + [748] = {.lex_state = 0}, + [749] = {.lex_state = 0}, + [750] = {.lex_state = 0}, + [751] = {.lex_state = 0}, + [752] = {.lex_state = 0}, + [753] = {.lex_state = 0}, + [754] = {.lex_state = 0}, + [755] = {.lex_state = 0}, + [756] = {.lex_state = 0}, + [757] = {.lex_state = 0}, + [758] = {.lex_state = 0}, + [759] = {.lex_state = 0}, + [760] = {.lex_state = 0}, + [761] = {.lex_state = 0}, + [762] = {.lex_state = 0}, + [763] = {.lex_state = 0}, + [764] = {.lex_state = 0}, + [765] = {.lex_state = 0}, + [766] = {.lex_state = 0}, + [767] = {.lex_state = 0}, + [768] = {.lex_state = 0}, + [769] = {.lex_state = 0}, + [770] = {.lex_state = 235}, + [771] = {.lex_state = 0}, + [772] = {.lex_state = 0}, + [773] = {.lex_state = 0}, + [774] = {.lex_state = 0}, + [775] = {.lex_state = 0}, + [776] = {.lex_state = 0}, + [777] = {.lex_state = 0}, + [778] = {.lex_state = 0}, + [779] = {.lex_state = 0}, + [780] = {.lex_state = 0}, + [781] = {.lex_state = 0}, + [782] = {.lex_state = 0}, + [783] = {.lex_state = 0}, + [784] = {.lex_state = 0}, + [785] = {.lex_state = 0}, + [786] = {.lex_state = 0}, + [787] = {.lex_state = 0}, + [788] = {.lex_state = 0}, + [789] = {.lex_state = 0}, + [790] = {.lex_state = 0}, + [791] = {.lex_state = 0}, + [792] = {.lex_state = 0}, + [793] = {.lex_state = 0}, + [794] = {.lex_state = 0}, + [795] = {.lex_state = 0}, + [796] = {.lex_state = 0}, + [797] = {.lex_state = 0}, + [798] = {.lex_state = 0}, + [799] = {.lex_state = 0}, + [800] = {.lex_state = 0}, + [801] = {.lex_state = 0}, + [802] = {.lex_state = 0}, + [803] = {.lex_state = 0}, + [804] = {.lex_state = 0}, + [805] = {.lex_state = 0}, + [806] = {.lex_state = 0}, + [807] = {.lex_state = 0}, + [808] = {.lex_state = 0}, + [809] = {.lex_state = 0}, + [810] = {.lex_state = 0}, + [811] = {.lex_state = 50}, + [812] = {.lex_state = 0}, + [813] = {.lex_state = 235}, + [814] = {.lex_state = 0}, + [815] = {.lex_state = 0}, + [816] = {.lex_state = 0}, + [817] = {.lex_state = 235}, + [818] = {.lex_state = 0}, + [819] = {.lex_state = 235}, +}; + +static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { + [0] = { + [ts_builtin_sym_end] = ACTIONS(1), + [anon_sym_use] = ACTIONS(1), + [anon_sym_SEMI] = ACTIONS(1), + [anon_sym_EQ] = ACTIONS(1), + [anon_sym_COLON_COLON] = ACTIONS(1), + [anon_sym_LBRACE] = ACTIONS(1), + [anon_sym_RBRACE] = ACTIONS(1), + [anon_sym_COMMA] = ACTIONS(1), + [anon_sym_export] = ACTIONS(1), + [anon_sym_let] = ACTIONS(1), + [anon_sym_const] = ACTIONS(1), + [anon_sym_COLON] = ACTIONS(1), + [anon_sym_ATsymbol] = ACTIONS(1), + [anon_sym_LPAREN] = ACTIONS(1), + [anon_sym_RPAREN] = ACTIONS(1), + [anon_sym_type] = ACTIONS(1), + [anon_sym_fn] = ACTIONS(1), + [anon_sym_ATfini] = ACTIONS(1), + [anon_sym_ATinit] = ACTIONS(1), + [anon_sym_ATtest] = ACTIONS(1), + [anon_sym_ATnoreturn] = ACTIONS(1), + [anon_sym_BANG] = ACTIONS(1), + [anon_sym_rune] = ACTIONS(1), + [anon_sym_bool] = ACTIONS(1), + [anon_sym_void] = ACTIONS(1), + [anon_sym_i8] = ACTIONS(1), + [anon_sym_i16] = ACTIONS(1), + [anon_sym_i32] = ACTIONS(1), + [anon_sym_i64] = ACTIONS(1), + [anon_sym_u8] = ACTIONS(1), + [anon_sym_u16] = ACTIONS(1), + [anon_sym_u32] = ACTIONS(1), + [anon_sym_u64] = ACTIONS(1), + [anon_sym_int] = ACTIONS(1), + [anon_sym_size] = ACTIONS(1), + [anon_sym_char] = ACTIONS(1), + [anon_sym_enum] = ACTIONS(1), + [anon_sym_STAR] = ACTIONS(1), + [anon_sym_struct] = ACTIONS(1), + [anon_sym_union] = ACTIONS(1), + [anon_sym_AToffset] = ACTIONS(1), + [anon_sym_PIPE] = ACTIONS(1), + [anon_sym_LBRACK] = ACTIONS(1), + [anon_sym_RBRACK] = ACTIONS(1), + [anon_sym__] = ACTIONS(1), + [anon_sym_DOT_DOT_DOT] = ACTIONS(1), + [anon_sym_true] = ACTIONS(1), + [anon_sym_null] = ACTIONS(1), + [anon_sym_0x] = ACTIONS(1), + [anon_sym_0o] = ACTIONS(1), + [anon_sym_0b] = ACTIONS(1), + [anon_sym_0] = ACTIONS(1), + [anon_sym_1] = ACTIONS(1), + [anon_sym_2] = ACTIONS(1), + [anon_sym_3] = ACTIONS(1), + [anon_sym_4] = ACTIONS(1), + [anon_sym_5] = ACTIONS(1), + [anon_sym_6] = ACTIONS(1), + [anon_sym_7] = ACTIONS(1), + [anon_sym_8] = ACTIONS(1), + [anon_sym_9] = ACTIONS(1), + [anon_sym_A] = ACTIONS(1), + [anon_sym_B] = ACTIONS(1), + [anon_sym_C] = ACTIONS(1), + [anon_sym_D] = ACTIONS(1), + [anon_sym_E] = ACTIONS(1), + [anon_sym_F] = ACTIONS(1), + [anon_sym_a] = ACTIONS(1), + [anon_sym_b] = ACTIONS(1), + [anon_sym_c] = ACTIONS(1), + [anon_sym_d] = ACTIONS(1), + [anon_sym_e] = ACTIONS(1), + [anon_sym_f] = ACTIONS(1), + [anon_sym_i] = ACTIONS(1), + [anon_sym_u] = ACTIONS(1), + [anon_sym_z] = ACTIONS(1), + [anon_sym_DOT] = ACTIONS(1), + [anon_sym_SQUOTE] = ACTIONS(1), + [anon_sym_DQUOTE] = ACTIONS(1), + [anon_sym_alloc] = ACTIONS(1), + [anon_sym_append] = ACTIONS(1), + [anon_sym_free] = ACTIONS(1), + [anon_sym_static] = ACTIONS(1), + [anon_sym_len] = ACTIONS(1), + [anon_sym_offset] = ACTIONS(1), + [anon_sym_DOT_DOT] = ACTIONS(1), + [anon_sym_QMARK] = ACTIONS(1), + [anon_sym_PLUS] = ACTIONS(1), + [anon_sym_DASH] = ACTIONS(1), + [anon_sym_TILDE] = ACTIONS(1), + [anon_sym_AMP] = ACTIONS(1), + [anon_sym_as] = ACTIONS(1), + [anon_sym_is] = ACTIONS(1), + [anon_sym_SLASH] = ACTIONS(1), + [anon_sym_PERCENT] = ACTIONS(1), + [anon_sym_LT_LT] = ACTIONS(1), + [anon_sym_GT_GT] = ACTIONS(1), + [anon_sym_CARET] = ACTIONS(1), + [anon_sym_LT] = ACTIONS(1), + [anon_sym_GT] = ACTIONS(1), + [anon_sym_LT_EQ] = ACTIONS(1), + [anon_sym_GT_EQ] = ACTIONS(1), + [anon_sym_EQ_EQ] = ACTIONS(1), + [anon_sym_BANG_EQ] = ACTIONS(1), + [anon_sym_AMP_AMP] = ACTIONS(1), + [anon_sym_CARET_CARET] = ACTIONS(1), + [anon_sym_PIPE_PIPE] = ACTIONS(1), + [anon_sym_if] = ACTIONS(1), + [anon_sym_else] = ACTIONS(1), + [anon_sym_for] = ACTIONS(1), + [anon_sym_switch] = ACTIONS(1), + [anon_sym_EQ_GT] = ACTIONS(1), + [anon_sym_match] = ACTIONS(1), + [anon_sym_PLUS_EQ] = ACTIONS(1), + [anon_sym_DASH_EQ] = ACTIONS(1), + [anon_sym_STAR_EQ] = ACTIONS(1), + [anon_sym_SLASH_EQ] = ACTIONS(1), + [anon_sym_PERCENT_EQ] = ACTIONS(1), + [anon_sym_LT_LT_EQ] = ACTIONS(1), + [anon_sym_GT_GT_EQ] = ACTIONS(1), + [anon_sym_AMP_EQ] = ACTIONS(1), + [anon_sym_PIPE_EQ] = ACTIONS(1), + [anon_sym_CARET_EQ] = ACTIONS(1), + [anon_sym_break] = ACTIONS(1), + [anon_sym_continue] = ACTIONS(1), + [anon_sym_return] = ACTIONS(1), + [sym_comment] = ACTIONS(3), + }, + [1] = { + [sym_unit] = STATE(782), + [sym_imports] = STATE(361), + [sym_use_statement] = STATE(379), + [sym_declarations] = STATE(775), + [sym_declaration] = STATE(772), + [sym_global_declaration] = STATE(771), + [sym_decl_attr] = STATE(469), + [sym_constant_declaration] = STATE(771), + [sym_type_declaration] = STATE(771), + [sym_function_declaration] = STATE(771), + [sym_fndec_attrs] = STATE(770), + [sym_fndec_attr] = STATE(408), + [sym_fntype_attr] = STATE(469), + [aux_sym_imports_repeat1] = STATE(379), + [aux_sym_declarations_repeat1] = STATE(364), + [aux_sym_fndec_attrs_repeat1] = STATE(408), + [ts_builtin_sym_end] = ACTIONS(5), + [anon_sym_use] = ACTIONS(7), + [anon_sym_export] = ACTIONS(9), + [anon_sym_let] = ACTIONS(11), + [anon_sym_const] = ACTIONS(11), + [anon_sym_ATsymbol] = ACTIONS(13), + [anon_sym_def] = ACTIONS(15), + [anon_sym_type] = ACTIONS(17), + [anon_sym_fn] = ACTIONS(19), + [anon_sym_ATfini] = ACTIONS(21), + [anon_sym_ATinit] = ACTIONS(21), + [anon_sym_ATtest] = ACTIONS(21), + [anon_sym_ATnoreturn] = ACTIONS(23), + [sym_comment] = ACTIONS(3), + }, + [2] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(278), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(395), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(817), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(443), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_SEMI] = ACTIONS(25), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_RBRACE] = ACTIONS(25), + [anon_sym_COMMA] = ACTIONS(25), + [anon_sym_let] = ACTIONS(29), + [anon_sym_const] = ACTIONS(29), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_RPAREN] = ACTIONS(25), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(41), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_RBRACK] = ACTIONS(25), + [anon_sym_DOT_DOT_DOT] = ACTIONS(25), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(71), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_DOT_DOT] = ACTIONS(79), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(83), + [anon_sym_else] = ACTIONS(79), + [anon_sym_for] = ACTIONS(85), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_EQ_GT] = ACTIONS(25), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(91), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(95), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [3] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(286), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(443), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_SEMI] = ACTIONS(25), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_RBRACE] = ACTIONS(25), + [anon_sym_COMMA] = ACTIONS(25), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_RPAREN] = ACTIONS(25), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(101), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_RBRACK] = ACTIONS(25), + [anon_sym_DOT_DOT_DOT] = ACTIONS(25), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(103), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_DOT_DOT] = ACTIONS(79), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_EQ_GT] = ACTIONS(25), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(109), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(111), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [4] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(328), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(397), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(813), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(443), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_SEMI] = ACTIONS(25), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(113), + [anon_sym_const] = ACTIONS(113), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_RPAREN] = ACTIONS(25), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(115), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_RBRACK] = ACTIONS(25), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(117), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_DOT_DOT] = ACTIONS(25), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(119), + [anon_sym_else] = ACTIONS(79), + [anon_sym_for] = ACTIONS(121), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(123), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(125), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [5] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(286), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(425), + [sym_switch_cases] = STATE(716), + [sym_switch_case] = STATE(579), + [sym_case_options] = STATE(726), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(578), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_RBRACE] = ACTIONS(127), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(129), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(103), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(109), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(111), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [6] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(355), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(393), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(730), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(443), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_SEMI] = ACTIONS(25), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_RPAREN] = ACTIONS(25), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(133), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_RBRACK] = ACTIONS(25), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(135), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_DOT_DOT] = ACTIONS(25), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(141), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(143), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [7] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(286), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(425), + [sym_switch_cases] = STATE(727), + [sym_switch_case] = STATE(579), + [sym_case_options] = STATE(726), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(578), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(129), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(103), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(109), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(111), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [8] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_append_values] = STATE(722), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(286), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(622), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_RPAREN] = ACTIONS(145), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(101), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_DOT_DOT_DOT] = ACTIONS(147), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(103), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(109), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(111), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [9] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_tuple_items] = STATE(779), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(286), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(600), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_RPAREN] = ACTIONS(149), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(101), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(103), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(109), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(111), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [10] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(286), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(425), + [sym_case_options] = STATE(715), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(578), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(101), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(103), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_EQ_GT] = ACTIONS(151), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(109), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(111), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [11] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_array_members] = STATE(778), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(286), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(517), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(101), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_RBRACK] = ACTIONS(153), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(103), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(109), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(111), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [12] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_argument_list] = STATE(773), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(286), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(525), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_RPAREN] = ACTIONS(155), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(101), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(103), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(109), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(111), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [13] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_argument_list] = STATE(745), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(286), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(525), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_RPAREN] = ACTIONS(157), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(101), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(103), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(109), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(111), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [14] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_append_values] = STATE(710), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(286), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(622), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(101), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_DOT_DOT_DOT] = ACTIONS(147), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(103), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(109), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(111), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [15] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_append_values] = STATE(706), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(286), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(622), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(101), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_DOT_DOT_DOT] = ACTIONS(147), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(103), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(109), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(111), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [16] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_append_values] = STATE(750), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(286), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(622), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(101), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_DOT_DOT_DOT] = ACTIONS(147), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(103), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(109), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(111), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [17] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_argument_list] = STATE(690), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(286), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(525), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_RPAREN] = ACTIONS(159), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(101), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(103), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(109), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(111), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [18] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_append_values] = STATE(733), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(286), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(622), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(101), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_DOT_DOT_DOT] = ACTIONS(147), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(103), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(109), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(111), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [19] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_array_members] = STATE(777), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(286), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(517), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(101), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_RBRACK] = ACTIONS(161), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(103), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(109), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(111), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [20] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(355), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(393), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(730), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_expression_list] = STATE(761), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(717), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_RBRACE] = ACTIONS(163), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(133), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(135), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(141), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(143), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [21] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_array_members] = STATE(669), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(286), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(517), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(101), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_RBRACK] = ACTIONS(165), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(103), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(109), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(111), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [22] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(355), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(393), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(730), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(584), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(133), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(135), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_DOT_DOT] = ACTIONS(167), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(141), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(143), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [23] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(355), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(393), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(730), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(763), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(133), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_RBRACK] = ACTIONS(169), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(135), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(141), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(143), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [24] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(355), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(393), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(730), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(592), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(133), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(135), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_DOT_DOT] = ACTIONS(171), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(141), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(143), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [25] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(355), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(393), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_for_predicate] = STATE(774), + [sym_label] = STATE(730), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(577), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(574), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(133), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(135), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(141), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(143), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [26] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(355), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(393), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_for_predicate] = STATE(803), + [sym_label] = STATE(730), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(577), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(574), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(133), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(135), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(141), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(143), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [27] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_tuple_items] = STATE(765), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(286), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(619), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(101), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(103), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(109), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(111), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [28] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(355), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(393), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(730), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_expression_list] = STATE(749), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(717), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(133), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(135), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(141), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(143), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [29] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_tuple_items] = STATE(779), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(286), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(600), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(101), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(103), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(109), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(111), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [30] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(355), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(393), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(730), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(556), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(133), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(135), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_DOT_DOT] = ACTIONS(171), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(141), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(143), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [31] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_tuple_items] = STATE(667), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(286), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(581), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(101), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(103), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(109), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(111), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [32] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(355), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(393), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_for_predicate] = STATE(697), + [sym_label] = STATE(730), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(577), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(574), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(133), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(135), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(141), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(143), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [33] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(355), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(393), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_for_predicate] = STATE(753), + [sym_label] = STATE(730), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(577), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(574), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(133), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(135), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(141), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(143), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [34] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(355), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(393), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_for_predicate] = STATE(705), + [sym_label] = STATE(730), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(577), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(574), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(133), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(135), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(141), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(143), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [35] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(355), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(393), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_for_predicate] = STATE(728), + [sym_label] = STATE(730), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(577), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(574), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(133), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(135), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(141), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(143), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [36] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(355), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(393), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_for_predicate] = STATE(729), + [sym_label] = STATE(730), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(577), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(574), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(133), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(135), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(141), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(143), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [37] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(355), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(393), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(730), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(700), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(133), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_RBRACK] = ACTIONS(173), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(135), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(141), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(143), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [38] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(355), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(393), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(730), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(743), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(133), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_RBRACK] = ACTIONS(175), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(135), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(141), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(143), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [39] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(355), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(393), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_for_predicate] = STATE(769), + [sym_label] = STATE(730), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(577), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(574), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(133), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(135), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(141), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(143), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [40] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(355), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(393), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(730), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(708), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(133), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_RBRACK] = ACTIONS(177), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(135), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(141), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(143), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [41] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(286), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(445), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(101), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(103), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(109), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(111), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [42] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(286), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(564), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(101), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(103), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(109), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(111), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [43] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(278), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(395), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(817), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(445), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(29), + [anon_sym_const] = ACTIONS(29), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(41), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(71), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(83), + [anon_sym_for] = ACTIONS(85), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(91), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(95), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [44] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(278), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(395), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(817), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(444), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(29), + [anon_sym_const] = ACTIONS(29), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(41), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(71), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(83), + [anon_sym_for] = ACTIONS(85), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(91), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(95), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [45] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(278), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(395), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(817), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(451), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(29), + [anon_sym_const] = ACTIONS(29), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(41), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(71), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(83), + [anon_sym_for] = ACTIONS(85), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(91), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(95), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [46] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(328), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(397), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(813), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(451), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(113), + [anon_sym_const] = ACTIONS(113), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(115), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(117), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(119), + [anon_sym_for] = ACTIONS(121), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(123), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(125), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [47] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(286), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(438), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(101), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(103), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(109), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(111), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [48] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(286), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(429), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(101), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(103), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(109), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(111), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [49] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(278), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(395), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(817), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(430), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(29), + [anon_sym_const] = ACTIONS(29), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(41), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(71), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(83), + [anon_sym_for] = ACTIONS(85), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(91), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(95), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [50] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(355), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(393), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(730), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(442), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(133), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(135), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(141), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(143), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [51] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(286), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(444), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(101), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(103), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(109), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(111), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [52] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(355), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(393), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(730), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(451), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(133), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(135), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(141), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(143), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [53] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(278), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(395), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(817), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(438), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(29), + [anon_sym_const] = ACTIONS(29), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(41), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(71), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(83), + [anon_sym_for] = ACTIONS(85), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(91), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(95), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [54] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(286), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(576), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(101), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(103), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(109), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(111), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [55] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(286), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(451), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(101), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(103), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(109), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(111), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [56] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(328), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(397), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(813), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(442), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(113), + [anon_sym_const] = ACTIONS(113), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(115), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(117), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(119), + [anon_sym_for] = ACTIONS(121), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(123), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(125), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [57] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(286), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(634), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(101), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(103), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(109), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(111), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [58] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(278), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(395), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(817), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(442), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(29), + [anon_sym_const] = ACTIONS(29), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(41), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(71), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(83), + [anon_sym_for] = ACTIONS(85), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(91), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(95), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [59] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(286), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(442), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(101), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(103), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(109), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(111), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [60] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(286), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(626), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(101), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(103), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(109), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(111), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [61] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(355), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(393), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(730), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(781), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(133), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(135), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(141), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(143), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [62] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(355), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(393), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(730), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(721), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(133), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(135), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(141), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(143), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [63] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(286), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(566), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(101), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(103), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(109), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(111), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [64] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(355), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(393), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(730), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(668), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(133), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(135), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(141), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(143), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [65] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(286), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(571), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(101), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(103), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(109), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(111), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [66] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(355), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(393), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(730), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(438), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(133), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(135), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(141), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(143), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [67] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(355), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(393), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(730), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(804), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(133), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(135), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(141), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(143), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [68] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(286), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(568), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(101), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(103), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(109), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(111), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [69] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(355), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(393), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(730), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(684), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(133), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(135), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(141), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(143), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [70] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(286), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(555), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(101), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(103), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(109), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(111), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [71] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(286), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(625), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(101), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(103), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(109), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(111), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [72] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(278), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(395), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(817), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(429), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(29), + [anon_sym_const] = ACTIONS(29), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(41), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(71), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(83), + [anon_sym_for] = ACTIONS(85), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(91), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(95), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [73] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(355), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(393), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(730), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(688), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(133), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(135), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(141), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(143), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [74] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(286), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(441), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(101), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(103), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(109), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(111), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [75] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(355), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(393), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(730), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(767), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(133), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(135), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(141), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(143), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [76] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(355), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(393), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(730), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(444), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(133), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(135), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(141), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(143), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [77] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(355), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(393), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(730), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(445), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(133), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(135), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(141), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(143), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [78] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(328), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(397), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(813), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(438), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(113), + [anon_sym_const] = ACTIONS(113), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(115), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(117), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(119), + [anon_sym_for] = ACTIONS(121), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(123), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(125), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [79] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(278), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(395), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(817), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(437), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(29), + [anon_sym_const] = ACTIONS(29), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(41), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(71), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(83), + [anon_sym_for] = ACTIONS(85), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(91), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(95), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [80] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(286), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(590), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(101), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(103), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(109), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(111), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [81] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(355), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(393), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(730), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(746), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(133), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(135), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(141), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(143), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [82] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(286), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(591), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(101), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(103), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(109), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(111), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [83] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(355), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(393), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(730), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(800), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(133), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(135), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(141), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(143), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [84] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(328), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(397), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(813), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(429), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(113), + [anon_sym_const] = ACTIONS(113), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(115), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(117), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(119), + [anon_sym_for] = ACTIONS(121), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(123), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(125), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [85] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(286), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(554), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(101), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(103), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(109), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(111), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [86] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(355), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(393), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(730), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(750), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(133), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(135), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(141), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(143), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [87] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(286), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(601), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(101), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(103), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(109), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(111), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [88] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(355), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(393), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(730), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(799), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(133), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(135), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(141), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(143), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [89] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(355), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(393), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(730), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(706), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(133), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(135), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(141), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(143), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [90] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(286), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(553), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(101), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(103), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(109), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(111), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [91] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(328), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(397), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(813), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(430), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(113), + [anon_sym_const] = ACTIONS(113), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(115), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(117), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(119), + [anon_sym_for] = ACTIONS(121), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(123), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(125), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [92] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(355), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(393), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(730), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(429), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(133), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(135), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(141), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(143), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [93] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(355), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(393), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(730), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(731), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(133), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(135), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(141), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(143), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [94] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(355), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(393), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(730), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(610), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(133), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(135), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(141), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(143), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [95] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(355), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(393), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(730), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(738), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(133), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(135), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(141), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(143), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [96] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(286), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(615), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(101), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(103), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(109), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(111), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [97] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(328), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(397), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(813), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(445), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(113), + [anon_sym_const] = ACTIONS(113), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(115), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(117), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(119), + [anon_sym_for] = ACTIONS(121), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(123), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(125), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [98] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(328), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(397), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(813), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(444), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(113), + [anon_sym_const] = ACTIONS(113), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(115), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(117), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(119), + [anon_sym_for] = ACTIONS(121), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(123), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(125), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [99] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(278), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(395), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(817), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(441), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(29), + [anon_sym_const] = ACTIONS(29), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(41), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(71), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(83), + [anon_sym_for] = ACTIONS(85), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(91), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(95), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [100] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(355), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(393), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(730), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(768), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(133), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(135), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(141), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(143), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [101] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(286), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(596), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(101), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(103), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(109), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(111), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [102] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(253), + [sym_indexing_expression] = STATE(253), + [sym_slicing_expression] = STATE(286), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(289), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(412), + [sym_if_expression] = STATE(425), + [sym_for_loop] = STATE(425), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(425), + [sym_match_expression] = STATE(425), + [sym_assignment] = STATE(425), + [sym_binding_list] = STATE(425), + [sym_deferred_expression] = STATE(425), + [sym_control_statement] = STATE(425), + [sym_expression] = STATE(437), + [sym_compound_expression] = STATE(425), + [sym_identifier] = STATE(192), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LBRACE] = ACTIONS(27), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), + [anon_sym_COLON] = ACTIONS(31), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(101), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(103), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), + [anon_sym_switch] = ACTIONS(87), + [anon_sym_match] = ACTIONS(89), + [anon_sym_defer] = ACTIONS(109), + [anon_sym_break] = ACTIONS(93), + [anon_sym_continue] = ACTIONS(93), + [anon_sym_return] = ACTIONS(111), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [103] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(303), + [sym_indexing_expression] = STATE(303), + [sym_slicing_expression] = STATE(303), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(305), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(608), + [sym_identifier] = STATE(274), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(179), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_RBRACK] = ACTIONS(181), + [anon_sym__] = ACTIONS(183), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(185), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [sym_name] = ACTIONS(187), + [sym_comment] = ACTIONS(3), + }, + [104] = { + [sym_hex_digit] = STATE(104), + [aux_sym_hex_digits_repeat1] = STATE(104), + [anon_sym_SEMI] = ACTIONS(189), + [anon_sym_EQ] = ACTIONS(191), + [anon_sym_RBRACE] = ACTIONS(189), + [anon_sym_COMMA] = ACTIONS(189), + [anon_sym_COLON] = ACTIONS(189), + [anon_sym_LPAREN] = ACTIONS(189), + [anon_sym_RPAREN] = ACTIONS(189), + [anon_sym_i8] = ACTIONS(189), + [anon_sym_i16] = ACTIONS(189), + [anon_sym_i32] = ACTIONS(189), + [anon_sym_i64] = ACTIONS(189), + [anon_sym_u8] = ACTIONS(189), + [anon_sym_u16] = ACTIONS(189), + [anon_sym_u32] = ACTIONS(189), + [anon_sym_u64] = ACTIONS(189), + [anon_sym_STAR] = ACTIONS(191), + [anon_sym_PIPE] = ACTIONS(191), + [anon_sym_LBRACK] = ACTIONS(189), + [anon_sym_RBRACK] = ACTIONS(189), + [anon_sym_DOT_DOT_DOT] = ACTIONS(189), + [anon_sym_0] = ACTIONS(193), + [anon_sym_1] = ACTIONS(193), + [anon_sym_2] = ACTIONS(193), + [anon_sym_3] = ACTIONS(193), + [anon_sym_4] = ACTIONS(193), + [anon_sym_5] = ACTIONS(193), + [anon_sym_6] = ACTIONS(193), + [anon_sym_7] = ACTIONS(193), + [anon_sym_8] = ACTIONS(193), + [anon_sym_9] = ACTIONS(193), + [anon_sym_A] = ACTIONS(193), + [anon_sym_B] = ACTIONS(193), + [anon_sym_C] = ACTIONS(193), + [anon_sym_D] = ACTIONS(193), + [anon_sym_E] = ACTIONS(193), + [anon_sym_F] = ACTIONS(193), + [anon_sym_a] = ACTIONS(196), + [anon_sym_b] = ACTIONS(193), + [anon_sym_c] = ACTIONS(193), + [anon_sym_d] = ACTIONS(193), + [anon_sym_e] = ACTIONS(196), + [anon_sym_f] = ACTIONS(193), + [anon_sym_i] = ACTIONS(191), + [anon_sym_u] = ACTIONS(191), + [anon_sym_z] = ACTIONS(189), + [anon_sym_DOT] = ACTIONS(191), + [anon_sym_DOT_DOT] = ACTIONS(191), + [anon_sym_QMARK] = ACTIONS(189), + [anon_sym_PLUS] = ACTIONS(191), + [anon_sym_DASH] = ACTIONS(191), + [anon_sym_AMP] = ACTIONS(191), + [anon_sym_as] = ACTIONS(189), + [anon_sym_is] = ACTIONS(189), + [anon_sym_SLASH] = ACTIONS(191), + [anon_sym_PERCENT] = ACTIONS(191), + [anon_sym_LT_LT] = ACTIONS(191), + [anon_sym_GT_GT] = ACTIONS(191), + [anon_sym_CARET] = ACTIONS(191), + [anon_sym_LT] = ACTIONS(191), + [anon_sym_GT] = ACTIONS(191), + [anon_sym_LT_EQ] = ACTIONS(189), + [anon_sym_GT_EQ] = ACTIONS(189), + [anon_sym_EQ_EQ] = ACTIONS(189), + [anon_sym_BANG_EQ] = ACTIONS(189), + [anon_sym_AMP_AMP] = ACTIONS(189), + [anon_sym_CARET_CARET] = ACTIONS(189), + [anon_sym_PIPE_PIPE] = ACTIONS(189), + [anon_sym_else] = ACTIONS(189), + [anon_sym_EQ_GT] = ACTIONS(189), + [anon_sym_PLUS_EQ] = ACTIONS(189), + [anon_sym_DASH_EQ] = ACTIONS(189), + [anon_sym_STAR_EQ] = ACTIONS(189), + [anon_sym_SLASH_EQ] = ACTIONS(189), + [anon_sym_PERCENT_EQ] = ACTIONS(189), + [anon_sym_LT_LT_EQ] = ACTIONS(189), + [anon_sym_GT_GT_EQ] = ACTIONS(189), + [anon_sym_AMP_EQ] = ACTIONS(189), + [anon_sym_PIPE_EQ] = ACTIONS(189), + [anon_sym_CARET_EQ] = ACTIONS(189), + [sym_comment] = ACTIONS(3), + }, + [105] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(303), + [sym_indexing_expression] = STATE(303), + [sym_slicing_expression] = STATE(303), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(305), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(403), + [sym_logical_or_expression] = STATE(595), + [sym_identifier] = STATE(274), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(199), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_RBRACK] = ACTIONS(201), + [anon_sym__] = ACTIONS(203), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(185), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [sym_name] = ACTIONS(187), + [sym_comment] = ACTIONS(3), + }, + [106] = { + [sym_hex_digit] = STATE(104), + [aux_sym_hex_digits_repeat1] = STATE(104), + [anon_sym_SEMI] = ACTIONS(205), + [anon_sym_EQ] = ACTIONS(207), + [anon_sym_RBRACE] = ACTIONS(205), + [anon_sym_COMMA] = ACTIONS(205), + [anon_sym_COLON] = ACTIONS(205), + [anon_sym_LPAREN] = ACTIONS(205), + [anon_sym_RPAREN] = ACTIONS(205), + [anon_sym_i8] = ACTIONS(205), + [anon_sym_i16] = ACTIONS(205), + [anon_sym_i32] = ACTIONS(205), + [anon_sym_i64] = ACTIONS(205), + [anon_sym_u8] = ACTIONS(205), + [anon_sym_u16] = ACTIONS(205), + [anon_sym_u32] = ACTIONS(205), + [anon_sym_u64] = ACTIONS(205), + [anon_sym_STAR] = ACTIONS(207), + [anon_sym_PIPE] = ACTIONS(207), + [anon_sym_LBRACK] = ACTIONS(205), + [anon_sym_RBRACK] = ACTIONS(205), + [anon_sym_DOT_DOT_DOT] = ACTIONS(205), + [anon_sym_0] = ACTIONS(209), + [anon_sym_1] = ACTIONS(209), + [anon_sym_2] = ACTIONS(209), + [anon_sym_3] = ACTIONS(209), + [anon_sym_4] = ACTIONS(209), + [anon_sym_5] = ACTIONS(209), + [anon_sym_6] = ACTIONS(209), + [anon_sym_7] = ACTIONS(209), + [anon_sym_8] = ACTIONS(209), + [anon_sym_9] = ACTIONS(209), + [anon_sym_A] = ACTIONS(209), + [anon_sym_B] = ACTIONS(209), + [anon_sym_C] = ACTIONS(209), + [anon_sym_D] = ACTIONS(209), + [anon_sym_E] = ACTIONS(209), + [anon_sym_F] = ACTIONS(209), + [anon_sym_a] = ACTIONS(211), + [anon_sym_b] = ACTIONS(209), + [anon_sym_c] = ACTIONS(209), + [anon_sym_d] = ACTIONS(209), + [anon_sym_e] = ACTIONS(211), + [anon_sym_f] = ACTIONS(209), + [anon_sym_i] = ACTIONS(207), + [anon_sym_u] = ACTIONS(207), + [anon_sym_z] = ACTIONS(205), + [anon_sym_DOT] = ACTIONS(207), + [anon_sym_DOT_DOT] = ACTIONS(207), + [anon_sym_QMARK] = ACTIONS(205), + [anon_sym_PLUS] = ACTIONS(207), + [anon_sym_DASH] = ACTIONS(207), + [anon_sym_AMP] = ACTIONS(207), + [anon_sym_as] = ACTIONS(205), + [anon_sym_is] = ACTIONS(205), + [anon_sym_SLASH] = ACTIONS(207), + [anon_sym_PERCENT] = ACTIONS(207), + [anon_sym_LT_LT] = ACTIONS(207), + [anon_sym_GT_GT] = ACTIONS(207), + [anon_sym_CARET] = ACTIONS(207), + [anon_sym_LT] = ACTIONS(207), + [anon_sym_GT] = ACTIONS(207), + [anon_sym_LT_EQ] = ACTIONS(205), + [anon_sym_GT_EQ] = ACTIONS(205), + [anon_sym_EQ_EQ] = ACTIONS(205), + [anon_sym_BANG_EQ] = ACTIONS(205), + [anon_sym_AMP_AMP] = ACTIONS(205), + [anon_sym_CARET_CARET] = ACTIONS(205), + [anon_sym_PIPE_PIPE] = ACTIONS(205), + [anon_sym_else] = ACTIONS(205), + [anon_sym_EQ_GT] = ACTIONS(205), + [anon_sym_PLUS_EQ] = ACTIONS(205), + [anon_sym_DASH_EQ] = ACTIONS(205), + [anon_sym_STAR_EQ] = ACTIONS(205), + [anon_sym_SLASH_EQ] = ACTIONS(205), + [anon_sym_PERCENT_EQ] = ACTIONS(205), + [anon_sym_LT_LT_EQ] = ACTIONS(205), + [anon_sym_GT_GT_EQ] = ACTIONS(205), + [anon_sym_AMP_EQ] = ACTIONS(205), + [anon_sym_PIPE_EQ] = ACTIONS(205), + [anon_sym_CARET_EQ] = ACTIONS(205), + [sym_comment] = ACTIONS(3), + }, + [107] = { + [anon_sym_SEMI] = ACTIONS(213), + [anon_sym_EQ] = ACTIONS(215), + [anon_sym_RBRACE] = ACTIONS(213), + [anon_sym_COMMA] = ACTIONS(213), + [anon_sym_COLON] = ACTIONS(213), + [anon_sym_LPAREN] = ACTIONS(213), + [anon_sym_RPAREN] = ACTIONS(213), + [anon_sym_i8] = ACTIONS(213), + [anon_sym_i16] = ACTIONS(213), + [anon_sym_i32] = ACTIONS(213), + [anon_sym_i64] = ACTIONS(213), + [anon_sym_u8] = ACTIONS(213), + [anon_sym_u16] = ACTIONS(213), + [anon_sym_u32] = ACTIONS(213), + [anon_sym_u64] = ACTIONS(213), + [anon_sym_STAR] = ACTIONS(215), + [anon_sym_PIPE] = ACTIONS(215), + [anon_sym_LBRACK] = ACTIONS(213), + [anon_sym_RBRACK] = ACTIONS(213), + [anon_sym_DOT_DOT_DOT] = ACTIONS(213), + [anon_sym_0] = ACTIONS(213), + [anon_sym_1] = ACTIONS(213), + [anon_sym_2] = ACTIONS(213), + [anon_sym_3] = ACTIONS(213), + [anon_sym_4] = ACTIONS(213), + [anon_sym_5] = ACTIONS(213), + [anon_sym_6] = ACTIONS(213), + [anon_sym_7] = ACTIONS(213), + [anon_sym_8] = ACTIONS(213), + [anon_sym_9] = ACTIONS(213), + [anon_sym_A] = ACTIONS(213), + [anon_sym_B] = ACTIONS(213), + [anon_sym_C] = ACTIONS(213), + [anon_sym_D] = ACTIONS(213), + [anon_sym_E] = ACTIONS(213), + [anon_sym_F] = ACTIONS(213), + [anon_sym_a] = ACTIONS(215), + [anon_sym_b] = ACTIONS(213), + [anon_sym_c] = ACTIONS(213), + [anon_sym_d] = ACTIONS(213), + [anon_sym_e] = ACTIONS(215), + [anon_sym_f] = ACTIONS(213), + [anon_sym_i] = ACTIONS(215), + [anon_sym_u] = ACTIONS(215), + [anon_sym_z] = ACTIONS(213), + [anon_sym_DOT] = ACTIONS(215), + [anon_sym_DOT_DOT] = ACTIONS(215), + [anon_sym_QMARK] = ACTIONS(213), + [anon_sym_PLUS] = ACTIONS(215), + [anon_sym_DASH] = ACTIONS(215), + [anon_sym_AMP] = ACTIONS(215), + [anon_sym_as] = ACTIONS(213), + [anon_sym_is] = ACTIONS(213), + [anon_sym_SLASH] = ACTIONS(215), + [anon_sym_PERCENT] = ACTIONS(215), + [anon_sym_LT_LT] = ACTIONS(215), + [anon_sym_GT_GT] = ACTIONS(215), + [anon_sym_CARET] = ACTIONS(215), + [anon_sym_LT] = ACTIONS(215), + [anon_sym_GT] = ACTIONS(215), + [anon_sym_LT_EQ] = ACTIONS(213), + [anon_sym_GT_EQ] = ACTIONS(213), + [anon_sym_EQ_EQ] = ACTIONS(213), + [anon_sym_BANG_EQ] = ACTIONS(213), + [anon_sym_AMP_AMP] = ACTIONS(213), + [anon_sym_CARET_CARET] = ACTIONS(213), + [anon_sym_PIPE_PIPE] = ACTIONS(213), + [anon_sym_else] = ACTIONS(213), + [anon_sym_EQ_GT] = ACTIONS(213), + [anon_sym_PLUS_EQ] = ACTIONS(213), + [anon_sym_DASH_EQ] = ACTIONS(213), + [anon_sym_STAR_EQ] = ACTIONS(213), + [anon_sym_SLASH_EQ] = ACTIONS(213), + [anon_sym_PERCENT_EQ] = ACTIONS(213), + [anon_sym_LT_LT_EQ] = ACTIONS(213), + [anon_sym_GT_GT_EQ] = ACTIONS(213), + [anon_sym_AMP_EQ] = ACTIONS(213), + [anon_sym_PIPE_EQ] = ACTIONS(213), + [anon_sym_CARET_EQ] = ACTIONS(213), + [sym_comment] = ACTIONS(3), + }, + [108] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(303), + [sym_indexing_expression] = STATE(303), + [sym_slicing_expression] = STATE(303), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(305), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(398), + [sym_logical_xor_expression] = STATE(402), + [sym_identifier] = STATE(274), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(185), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [sym_name] = ACTIONS(187), + [sym_comment] = ACTIONS(3), + }, + [109] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(303), + [sym_indexing_expression] = STATE(303), + [sym_slicing_expression] = STATE(303), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(305), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(384), + [sym_logical_and_expression] = STATE(394), + [sym_identifier] = STATE(274), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(185), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [sym_name] = ACTIONS(187), + [sym_comment] = ACTIONS(3), + }, + [110] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(303), + [sym_indexing_expression] = STATE(303), + [sym_slicing_expression] = STATE(303), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(305), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(377), + [sym_equality_expression] = STATE(383), + [sym_identifier] = STATE(274), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(185), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [sym_name] = ACTIONS(187), + [sym_comment] = ACTIONS(3), + }, + [111] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(303), + [sym_indexing_expression] = STATE(303), + [sym_slicing_expression] = STATE(303), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(305), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(373), + [sym_comparison_expression] = STATE(376), + [sym_identifier] = STATE(274), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(185), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [sym_name] = ACTIONS(187), + [sym_comment] = ACTIONS(3), + }, + [112] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(303), + [sym_indexing_expression] = STATE(303), + [sym_slicing_expression] = STATE(303), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(305), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(371), + [sym_inclusive_or_expression] = STATE(372), + [sym_identifier] = STATE(274), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(185), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [sym_name] = ACTIONS(187), + [sym_comment] = ACTIONS(3), + }, + [113] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(303), + [sym_indexing_expression] = STATE(303), + [sym_slicing_expression] = STATE(303), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(305), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(365), + [sym_exclusive_or_expression] = STATE(369), + [sym_identifier] = STATE(274), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(185), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [sym_name] = ACTIONS(187), + [sym_comment] = ACTIONS(3), + }, + [114] = { + [sym_decimal_digit] = STATE(115), + [aux_sym_decimal_digits_repeat1] = STATE(115), + [anon_sym_SEMI] = ACTIONS(217), + [anon_sym_EQ] = ACTIONS(219), + [anon_sym_RBRACE] = ACTIONS(217), + [anon_sym_COMMA] = ACTIONS(217), + [anon_sym_COLON] = ACTIONS(217), + [anon_sym_LPAREN] = ACTIONS(217), + [anon_sym_RPAREN] = ACTIONS(217), + [anon_sym_i8] = ACTIONS(217), + [anon_sym_i16] = ACTIONS(217), + [anon_sym_i32] = ACTIONS(217), + [anon_sym_i64] = ACTIONS(217), + [anon_sym_u8] = ACTIONS(217), + [anon_sym_u16] = ACTIONS(217), + [anon_sym_u32] = ACTIONS(217), + [anon_sym_u64] = ACTIONS(217), + [anon_sym_f32] = ACTIONS(217), + [anon_sym_f64] = ACTIONS(217), + [anon_sym_STAR] = ACTIONS(219), + [anon_sym_PIPE] = ACTIONS(219), + [anon_sym_LBRACK] = ACTIONS(217), + [anon_sym_RBRACK] = ACTIONS(217), + [anon_sym_DOT_DOT_DOT] = ACTIONS(217), + [anon_sym_0] = ACTIONS(221), + [anon_sym_1] = ACTIONS(221), + [anon_sym_2] = ACTIONS(221), + [anon_sym_3] = ACTIONS(221), + [anon_sym_4] = ACTIONS(221), + [anon_sym_5] = ACTIONS(221), + [anon_sym_6] = ACTIONS(221), + [anon_sym_7] = ACTIONS(221), + [anon_sym_8] = ACTIONS(221), + [anon_sym_9] = ACTIONS(221), + [anon_sym_e] = ACTIONS(219), + [anon_sym_i] = ACTIONS(219), + [anon_sym_u] = ACTIONS(219), + [anon_sym_z] = ACTIONS(217), + [anon_sym_DOT] = ACTIONS(219), + [anon_sym_DOT_DOT] = ACTIONS(219), + [anon_sym_QMARK] = ACTIONS(217), + [anon_sym_PLUS] = ACTIONS(219), + [anon_sym_DASH] = ACTIONS(219), + [anon_sym_AMP] = ACTIONS(219), + [anon_sym_as] = ACTIONS(217), + [anon_sym_is] = ACTIONS(217), + [anon_sym_SLASH] = ACTIONS(219), + [anon_sym_PERCENT] = ACTIONS(219), + [anon_sym_LT_LT] = ACTIONS(219), + [anon_sym_GT_GT] = ACTIONS(219), + [anon_sym_CARET] = ACTIONS(219), + [anon_sym_LT] = ACTIONS(219), + [anon_sym_GT] = ACTIONS(219), + [anon_sym_LT_EQ] = ACTIONS(217), + [anon_sym_GT_EQ] = ACTIONS(217), + [anon_sym_EQ_EQ] = ACTIONS(217), + [anon_sym_BANG_EQ] = ACTIONS(217), + [anon_sym_AMP_AMP] = ACTIONS(217), + [anon_sym_CARET_CARET] = ACTIONS(217), + [anon_sym_PIPE_PIPE] = ACTIONS(217), + [anon_sym_else] = ACTIONS(217), + [anon_sym_EQ_GT] = ACTIONS(217), + [anon_sym_PLUS_EQ] = ACTIONS(217), + [anon_sym_DASH_EQ] = ACTIONS(217), + [anon_sym_STAR_EQ] = ACTIONS(217), + [anon_sym_SLASH_EQ] = ACTIONS(217), + [anon_sym_PERCENT_EQ] = ACTIONS(217), + [anon_sym_LT_LT_EQ] = ACTIONS(217), + [anon_sym_GT_GT_EQ] = ACTIONS(217), + [anon_sym_AMP_EQ] = ACTIONS(217), + [anon_sym_PIPE_EQ] = ACTIONS(217), + [anon_sym_CARET_EQ] = ACTIONS(217), + [sym_comment] = ACTIONS(3), + }, + [115] = { + [sym_decimal_digit] = STATE(115), + [aux_sym_decimal_digits_repeat1] = STATE(115), + [anon_sym_SEMI] = ACTIONS(223), + [anon_sym_EQ] = ACTIONS(225), + [anon_sym_RBRACE] = ACTIONS(223), + [anon_sym_COMMA] = ACTIONS(223), + [anon_sym_COLON] = ACTIONS(223), + [anon_sym_LPAREN] = ACTIONS(223), + [anon_sym_RPAREN] = ACTIONS(223), + [anon_sym_i8] = ACTIONS(223), + [anon_sym_i16] = ACTIONS(223), + [anon_sym_i32] = ACTIONS(223), + [anon_sym_i64] = ACTIONS(223), + [anon_sym_u8] = ACTIONS(223), + [anon_sym_u16] = ACTIONS(223), + [anon_sym_u32] = ACTIONS(223), + [anon_sym_u64] = ACTIONS(223), + [anon_sym_f32] = ACTIONS(223), + [anon_sym_f64] = ACTIONS(223), + [anon_sym_STAR] = ACTIONS(225), + [anon_sym_PIPE] = ACTIONS(225), + [anon_sym_LBRACK] = ACTIONS(223), + [anon_sym_RBRACK] = ACTIONS(223), + [anon_sym_DOT_DOT_DOT] = ACTIONS(223), + [anon_sym_0] = ACTIONS(227), + [anon_sym_1] = ACTIONS(227), + [anon_sym_2] = ACTIONS(227), + [anon_sym_3] = ACTIONS(227), + [anon_sym_4] = ACTIONS(227), + [anon_sym_5] = ACTIONS(227), + [anon_sym_6] = ACTIONS(227), + [anon_sym_7] = ACTIONS(227), + [anon_sym_8] = ACTIONS(227), + [anon_sym_9] = ACTIONS(227), + [anon_sym_e] = ACTIONS(225), + [anon_sym_i] = ACTIONS(225), + [anon_sym_u] = ACTIONS(225), + [anon_sym_z] = ACTIONS(223), + [anon_sym_DOT] = ACTIONS(225), + [anon_sym_DOT_DOT] = ACTIONS(225), + [anon_sym_QMARK] = ACTIONS(223), + [anon_sym_PLUS] = ACTIONS(225), + [anon_sym_DASH] = ACTIONS(225), + [anon_sym_AMP] = ACTIONS(225), + [anon_sym_as] = ACTIONS(223), + [anon_sym_is] = ACTIONS(223), + [anon_sym_SLASH] = ACTIONS(225), + [anon_sym_PERCENT] = ACTIONS(225), + [anon_sym_LT_LT] = ACTIONS(225), + [anon_sym_GT_GT] = ACTIONS(225), + [anon_sym_CARET] = ACTIONS(225), + [anon_sym_LT] = ACTIONS(225), + [anon_sym_GT] = ACTIONS(225), + [anon_sym_LT_EQ] = ACTIONS(223), + [anon_sym_GT_EQ] = ACTIONS(223), + [anon_sym_EQ_EQ] = ACTIONS(223), + [anon_sym_BANG_EQ] = ACTIONS(223), + [anon_sym_AMP_AMP] = ACTIONS(223), + [anon_sym_CARET_CARET] = ACTIONS(223), + [anon_sym_PIPE_PIPE] = ACTIONS(223), + [anon_sym_else] = ACTIONS(223), + [anon_sym_EQ_GT] = ACTIONS(223), + [anon_sym_PLUS_EQ] = ACTIONS(223), + [anon_sym_DASH_EQ] = ACTIONS(223), + [anon_sym_STAR_EQ] = ACTIONS(223), + [anon_sym_SLASH_EQ] = ACTIONS(223), + [anon_sym_PERCENT_EQ] = ACTIONS(223), + [anon_sym_LT_LT_EQ] = ACTIONS(223), + [anon_sym_GT_GT_EQ] = ACTIONS(223), + [anon_sym_AMP_EQ] = ACTIONS(223), + [anon_sym_PIPE_EQ] = ACTIONS(223), + [anon_sym_CARET_EQ] = ACTIONS(223), + [sym_comment] = ACTIONS(3), + }, + [116] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(303), + [sym_indexing_expression] = STATE(303), + [sym_slicing_expression] = STATE(303), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(305), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(368), + [sym_and_expression] = STATE(367), + [sym_identifier] = STATE(274), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(185), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [sym_name] = ACTIONS(187), + [sym_comment] = ACTIONS(3), + }, + [117] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(303), + [sym_indexing_expression] = STATE(303), + [sym_slicing_expression] = STATE(303), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(305), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(356), + [sym_additive_expression] = STATE(362), + [sym_shift_expression] = STATE(366), + [sym_identifier] = STATE(274), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(185), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [sym_name] = ACTIONS(187), + [sym_comment] = ACTIONS(3), + }, + [118] = { + [sym_hex_digit] = STATE(118), + [aux_sym_hex_digits_repeat1] = STATE(118), + [anon_sym_SEMI] = ACTIONS(189), + [anon_sym_RBRACE] = ACTIONS(189), + [anon_sym_COMMA] = ACTIONS(189), + [anon_sym_COLON] = ACTIONS(189), + [anon_sym_LPAREN] = ACTIONS(189), + [anon_sym_RPAREN] = ACTIONS(189), + [anon_sym_i8] = ACTIONS(189), + [anon_sym_i16] = ACTIONS(189), + [anon_sym_i32] = ACTIONS(189), + [anon_sym_i64] = ACTIONS(189), + [anon_sym_u8] = ACTIONS(189), + [anon_sym_u16] = ACTIONS(189), + [anon_sym_u32] = ACTIONS(189), + [anon_sym_u64] = ACTIONS(189), + [anon_sym_STAR] = ACTIONS(189), + [anon_sym_PIPE] = ACTIONS(191), + [anon_sym_LBRACK] = ACTIONS(189), + [anon_sym_RBRACK] = ACTIONS(189), + [anon_sym_DOT_DOT_DOT] = ACTIONS(189), + [anon_sym_0] = ACTIONS(230), + [anon_sym_1] = ACTIONS(230), + [anon_sym_2] = ACTIONS(230), + [anon_sym_3] = ACTIONS(230), + [anon_sym_4] = ACTIONS(230), + [anon_sym_5] = ACTIONS(230), + [anon_sym_6] = ACTIONS(230), + [anon_sym_7] = ACTIONS(230), + [anon_sym_8] = ACTIONS(230), + [anon_sym_9] = ACTIONS(230), + [anon_sym_A] = ACTIONS(230), + [anon_sym_B] = ACTIONS(230), + [anon_sym_C] = ACTIONS(230), + [anon_sym_D] = ACTIONS(230), + [anon_sym_E] = ACTIONS(230), + [anon_sym_F] = ACTIONS(230), + [anon_sym_a] = ACTIONS(233), + [anon_sym_b] = ACTIONS(230), + [anon_sym_c] = ACTIONS(230), + [anon_sym_d] = ACTIONS(230), + [anon_sym_e] = ACTIONS(233), + [anon_sym_f] = ACTIONS(230), + [anon_sym_i] = ACTIONS(191), + [anon_sym_u] = ACTIONS(191), + [anon_sym_z] = ACTIONS(189), + [anon_sym_DOT] = ACTIONS(191), + [anon_sym_DOT_DOT] = ACTIONS(191), + [anon_sym_QMARK] = ACTIONS(189), + [anon_sym_PLUS] = ACTIONS(189), + [anon_sym_DASH] = ACTIONS(189), + [anon_sym_AMP] = ACTIONS(191), + [anon_sym_as] = ACTIONS(189), + [anon_sym_is] = ACTIONS(189), + [anon_sym_SLASH] = ACTIONS(191), + [anon_sym_PERCENT] = ACTIONS(189), + [anon_sym_LT_LT] = ACTIONS(189), + [anon_sym_GT_GT] = ACTIONS(189), + [anon_sym_CARET] = ACTIONS(191), + [anon_sym_LT] = ACTIONS(191), + [anon_sym_GT] = ACTIONS(191), + [anon_sym_LT_EQ] = ACTIONS(189), + [anon_sym_GT_EQ] = ACTIONS(189), + [anon_sym_EQ_EQ] = ACTIONS(189), + [anon_sym_BANG_EQ] = ACTIONS(189), + [anon_sym_AMP_AMP] = ACTIONS(189), + [anon_sym_CARET_CARET] = ACTIONS(189), + [anon_sym_PIPE_PIPE] = ACTIONS(189), + [anon_sym_else] = ACTIONS(189), + [anon_sym_EQ_GT] = ACTIONS(189), + [sym_comment] = ACTIONS(3), + }, + [119] = { + [sym_hex_digit] = STATE(118), + [aux_sym_hex_digits_repeat1] = STATE(118), + [anon_sym_SEMI] = ACTIONS(205), + [anon_sym_RBRACE] = ACTIONS(205), + [anon_sym_COMMA] = ACTIONS(205), + [anon_sym_COLON] = ACTIONS(205), + [anon_sym_LPAREN] = ACTIONS(205), + [anon_sym_RPAREN] = ACTIONS(205), + [anon_sym_i8] = ACTIONS(205), + [anon_sym_i16] = ACTIONS(205), + [anon_sym_i32] = ACTIONS(205), + [anon_sym_i64] = ACTIONS(205), + [anon_sym_u8] = ACTIONS(205), + [anon_sym_u16] = ACTIONS(205), + [anon_sym_u32] = ACTIONS(205), + [anon_sym_u64] = ACTIONS(205), + [anon_sym_STAR] = ACTIONS(205), + [anon_sym_PIPE] = ACTIONS(207), + [anon_sym_LBRACK] = ACTIONS(205), + [anon_sym_RBRACK] = ACTIONS(205), + [anon_sym_DOT_DOT_DOT] = ACTIONS(205), + [anon_sym_0] = ACTIONS(236), + [anon_sym_1] = ACTIONS(236), + [anon_sym_2] = ACTIONS(236), + [anon_sym_3] = ACTIONS(236), + [anon_sym_4] = ACTIONS(236), + [anon_sym_5] = ACTIONS(236), + [anon_sym_6] = ACTIONS(236), + [anon_sym_7] = ACTIONS(236), + [anon_sym_8] = ACTIONS(236), + [anon_sym_9] = ACTIONS(236), + [anon_sym_A] = ACTIONS(236), + [anon_sym_B] = ACTIONS(236), + [anon_sym_C] = ACTIONS(236), + [anon_sym_D] = ACTIONS(236), + [anon_sym_E] = ACTIONS(236), + [anon_sym_F] = ACTIONS(236), + [anon_sym_a] = ACTIONS(238), + [anon_sym_b] = ACTIONS(236), + [anon_sym_c] = ACTIONS(236), + [anon_sym_d] = ACTIONS(236), + [anon_sym_e] = ACTIONS(238), + [anon_sym_f] = ACTIONS(236), + [anon_sym_i] = ACTIONS(207), + [anon_sym_u] = ACTIONS(207), + [anon_sym_z] = ACTIONS(205), + [anon_sym_DOT] = ACTIONS(207), + [anon_sym_DOT_DOT] = ACTIONS(207), + [anon_sym_QMARK] = ACTIONS(205), + [anon_sym_PLUS] = ACTIONS(205), + [anon_sym_DASH] = ACTIONS(205), + [anon_sym_AMP] = ACTIONS(207), + [anon_sym_as] = ACTIONS(205), + [anon_sym_is] = ACTIONS(205), + [anon_sym_SLASH] = ACTIONS(207), + [anon_sym_PERCENT] = ACTIONS(205), + [anon_sym_LT_LT] = ACTIONS(205), + [anon_sym_GT_GT] = ACTIONS(205), + [anon_sym_CARET] = ACTIONS(207), + [anon_sym_LT] = ACTIONS(207), + [anon_sym_GT] = ACTIONS(207), + [anon_sym_LT_EQ] = ACTIONS(205), + [anon_sym_GT_EQ] = ACTIONS(205), + [anon_sym_EQ_EQ] = ACTIONS(205), + [anon_sym_BANG_EQ] = ACTIONS(205), + [anon_sym_AMP_AMP] = ACTIONS(205), + [anon_sym_CARET_CARET] = ACTIONS(205), + [anon_sym_PIPE_PIPE] = ACTIONS(205), + [anon_sym_else] = ACTIONS(205), + [anon_sym_EQ_GT] = ACTIONS(205), + [sym_comment] = ACTIONS(3), + }, + [120] = { + [anon_sym_SEMI] = ACTIONS(240), + [anon_sym_EQ] = ACTIONS(242), + [anon_sym_RBRACE] = ACTIONS(240), + [anon_sym_COMMA] = ACTIONS(240), + [anon_sym_COLON] = ACTIONS(240), + [anon_sym_LPAREN] = ACTIONS(240), + [anon_sym_RPAREN] = ACTIONS(240), + [anon_sym_i8] = ACTIONS(240), + [anon_sym_i16] = ACTIONS(240), + [anon_sym_i32] = ACTIONS(240), + [anon_sym_i64] = ACTIONS(240), + [anon_sym_u8] = ACTIONS(240), + [anon_sym_u16] = ACTIONS(240), + [anon_sym_u32] = ACTIONS(240), + [anon_sym_u64] = ACTIONS(240), + [anon_sym_f32] = ACTIONS(240), + [anon_sym_f64] = ACTIONS(240), + [anon_sym_STAR] = ACTIONS(242), + [anon_sym_PIPE] = ACTIONS(242), + [anon_sym_LBRACK] = ACTIONS(240), + [anon_sym_RBRACK] = ACTIONS(240), + [anon_sym_DOT_DOT_DOT] = ACTIONS(240), + [anon_sym_0] = ACTIONS(240), + [anon_sym_1] = ACTIONS(240), + [anon_sym_2] = ACTIONS(240), + [anon_sym_3] = ACTIONS(240), + [anon_sym_4] = ACTIONS(240), + [anon_sym_5] = ACTIONS(240), + [anon_sym_6] = ACTIONS(240), + [anon_sym_7] = ACTIONS(240), + [anon_sym_8] = ACTIONS(240), + [anon_sym_9] = ACTIONS(240), + [anon_sym_e] = ACTIONS(242), + [anon_sym_i] = ACTIONS(242), + [anon_sym_u] = ACTIONS(242), + [anon_sym_z] = ACTIONS(240), + [anon_sym_DOT] = ACTIONS(242), + [anon_sym_DOT_DOT] = ACTIONS(242), + [anon_sym_QMARK] = ACTIONS(240), + [anon_sym_PLUS] = ACTIONS(242), + [anon_sym_DASH] = ACTIONS(242), + [anon_sym_AMP] = ACTIONS(242), + [anon_sym_as] = ACTIONS(240), + [anon_sym_is] = ACTIONS(240), + [anon_sym_SLASH] = ACTIONS(242), + [anon_sym_PERCENT] = ACTIONS(242), + [anon_sym_LT_LT] = ACTIONS(242), + [anon_sym_GT_GT] = ACTIONS(242), + [anon_sym_CARET] = ACTIONS(242), + [anon_sym_LT] = ACTIONS(242), + [anon_sym_GT] = ACTIONS(242), + [anon_sym_LT_EQ] = ACTIONS(240), + [anon_sym_GT_EQ] = ACTIONS(240), + [anon_sym_EQ_EQ] = ACTIONS(240), + [anon_sym_BANG_EQ] = ACTIONS(240), + [anon_sym_AMP_AMP] = ACTIONS(240), + [anon_sym_CARET_CARET] = ACTIONS(240), + [anon_sym_PIPE_PIPE] = ACTIONS(240), + [anon_sym_else] = ACTIONS(240), + [anon_sym_EQ_GT] = ACTIONS(240), + [anon_sym_PLUS_EQ] = ACTIONS(240), + [anon_sym_DASH_EQ] = ACTIONS(240), + [anon_sym_STAR_EQ] = ACTIONS(240), + [anon_sym_SLASH_EQ] = ACTIONS(240), + [anon_sym_PERCENT_EQ] = ACTIONS(240), + [anon_sym_LT_LT_EQ] = ACTIONS(240), + [anon_sym_GT_GT_EQ] = ACTIONS(240), + [anon_sym_AMP_EQ] = ACTIONS(240), + [anon_sym_PIPE_EQ] = ACTIONS(240), + [anon_sym_CARET_EQ] = ACTIONS(240), + [sym_comment] = ACTIONS(3), + }, + [121] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(303), + [sym_indexing_expression] = STATE(303), + [sym_slicing_expression] = STATE(303), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(305), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(347), + [sym_multiplicative_expression] = STATE(357), + [sym_identifier] = STATE(274), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(185), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [sym_name] = ACTIONS(187), + [sym_comment] = ACTIONS(3), + }, + [122] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(303), + [sym_indexing_expression] = STATE(303), + [sym_slicing_expression] = STATE(303), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(305), + [sym_unary_expression] = STATE(349), + [sym_identifier] = STATE(274), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_RBRACK] = ACTIONS(244), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(185), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [sym_name] = ACTIONS(187), + [sym_comment] = ACTIONS(3), + }, + [123] = { + [anon_sym_SEMI] = ACTIONS(213), + [anon_sym_RBRACE] = ACTIONS(213), + [anon_sym_COMMA] = ACTIONS(213), + [anon_sym_COLON] = ACTIONS(213), + [anon_sym_LPAREN] = ACTIONS(213), + [anon_sym_RPAREN] = ACTIONS(213), + [anon_sym_i8] = ACTIONS(213), + [anon_sym_i16] = ACTIONS(213), + [anon_sym_i32] = ACTIONS(213), + [anon_sym_i64] = ACTIONS(213), + [anon_sym_u8] = ACTIONS(213), + [anon_sym_u16] = ACTIONS(213), + [anon_sym_u32] = ACTIONS(213), + [anon_sym_u64] = ACTIONS(213), + [anon_sym_STAR] = ACTIONS(213), + [anon_sym_PIPE] = ACTIONS(215), + [anon_sym_LBRACK] = ACTIONS(213), + [anon_sym_RBRACK] = ACTIONS(213), + [anon_sym_DOT_DOT_DOT] = ACTIONS(213), + [anon_sym_0] = ACTIONS(213), + [anon_sym_1] = ACTIONS(213), + [anon_sym_2] = ACTIONS(213), + [anon_sym_3] = ACTIONS(213), + [anon_sym_4] = ACTIONS(213), + [anon_sym_5] = ACTIONS(213), + [anon_sym_6] = ACTIONS(213), + [anon_sym_7] = ACTIONS(213), + [anon_sym_8] = ACTIONS(213), + [anon_sym_9] = ACTIONS(213), + [anon_sym_A] = ACTIONS(213), + [anon_sym_B] = ACTIONS(213), + [anon_sym_C] = ACTIONS(213), + [anon_sym_D] = ACTIONS(213), + [anon_sym_E] = ACTIONS(213), + [anon_sym_F] = ACTIONS(213), + [anon_sym_a] = ACTIONS(215), + [anon_sym_b] = ACTIONS(213), + [anon_sym_c] = ACTIONS(213), + [anon_sym_d] = ACTIONS(213), + [anon_sym_e] = ACTIONS(215), + [anon_sym_f] = ACTIONS(213), + [anon_sym_i] = ACTIONS(215), + [anon_sym_u] = ACTIONS(215), + [anon_sym_z] = ACTIONS(213), + [anon_sym_DOT] = ACTIONS(215), + [anon_sym_DOT_DOT] = ACTIONS(215), + [anon_sym_QMARK] = ACTIONS(213), + [anon_sym_PLUS] = ACTIONS(213), + [anon_sym_DASH] = ACTIONS(213), + [anon_sym_AMP] = ACTIONS(215), + [anon_sym_as] = ACTIONS(213), + [anon_sym_is] = ACTIONS(213), + [anon_sym_SLASH] = ACTIONS(215), + [anon_sym_PERCENT] = ACTIONS(213), + [anon_sym_LT_LT] = ACTIONS(213), + [anon_sym_GT_GT] = ACTIONS(213), + [anon_sym_CARET] = ACTIONS(215), + [anon_sym_LT] = ACTIONS(215), + [anon_sym_GT] = ACTIONS(215), + [anon_sym_LT_EQ] = ACTIONS(213), + [anon_sym_GT_EQ] = ACTIONS(213), + [anon_sym_EQ_EQ] = ACTIONS(213), + [anon_sym_BANG_EQ] = ACTIONS(213), + [anon_sym_AMP_AMP] = ACTIONS(213), + [anon_sym_CARET_CARET] = ACTIONS(213), + [anon_sym_PIPE_PIPE] = ACTIONS(213), + [anon_sym_else] = ACTIONS(213), + [anon_sym_EQ_GT] = ACTIONS(213), + [sym_comment] = ACTIONS(3), + }, + [124] = { + [sym_constant] = STATE(246), + [sym_integer_constant] = STATE(259), + [sym_decimal_digits] = STATE(140), + [sym_decimal_digit] = STATE(114), + [sym_floating_constant] = STATE(259), + [sym_rune_constant] = STATE(259), + [sym_string_constant] = STATE(259), + [sym_array_literal] = STATE(246), + [sym_enum_literal] = STATE(246), + [sym_struct_literal] = STATE(246), + [sym_plain_expression] = STATE(241), + [sym_nested_expression] = STATE(227), + [sym_allocation_expression] = STATE(227), + [sym_assertion_expression] = STATE(227), + [sym_call_expression] = STATE(227), + [sym_measurement_expression] = STATE(227), + [sym_size_expression] = STATE(225), + [sym_length_expression] = STATE(225), + [sym_offset_expression] = STATE(225), + [sym_field_access_expression] = STATE(227), + [sym_indexing_expression] = STATE(227), + [sym_slicing_expression] = STATE(227), + [sym_error_propagation] = STATE(227), + [sym_postfix_expression] = STATE(222), + [sym_unary_expression] = STATE(265), + [sym_identifier] = STATE(199), + [aux_sym_decimal_digits_repeat1] = STATE(114), + [aux_sym_string_constant_repeat1] = STATE(195), + [anon_sym_LPAREN] = ACTIONS(246), + [anon_sym_BANG] = ACTIONS(248), + [anon_sym_void] = ACTIONS(250), + [anon_sym_size] = ACTIONS(252), + [anon_sym_STAR] = ACTIONS(248), + [anon_sym_struct] = ACTIONS(254), + [anon_sym_LBRACK] = ACTIONS(256), + [anon_sym_true] = ACTIONS(250), + [anon_sym_false] = ACTIONS(250), + [anon_sym_null] = ACTIONS(250), + [anon_sym_0x] = ACTIONS(258), + [anon_sym_0o] = ACTIONS(260), + [anon_sym_0b] = ACTIONS(262), + [anon_sym_0] = ACTIONS(264), + [anon_sym_1] = ACTIONS(221), + [anon_sym_2] = ACTIONS(221), + [anon_sym_3] = ACTIONS(221), + [anon_sym_4] = ACTIONS(221), + [anon_sym_5] = ACTIONS(221), + [anon_sym_6] = ACTIONS(221), + [anon_sym_7] = ACTIONS(221), + [anon_sym_8] = ACTIONS(221), + [anon_sym_9] = ACTIONS(221), + [anon_sym_SQUOTE] = ACTIONS(266), + [anon_sym_DQUOTE] = ACTIONS(268), + [anon_sym_alloc] = ACTIONS(270), + [anon_sym_append] = ACTIONS(272), + [anon_sym_free] = ACTIONS(274), + [anon_sym_delete] = ACTIONS(276), + [anon_sym_assert] = ACTIONS(278), + [anon_sym_static] = ACTIONS(280), + [anon_sym_abort] = ACTIONS(282), + [anon_sym_len] = ACTIONS(284), + [anon_sym_offset] = ACTIONS(286), + [anon_sym_PLUS] = ACTIONS(248), + [anon_sym_DASH] = ACTIONS(248), + [anon_sym_TILDE] = ACTIONS(248), + [anon_sym_AMP] = ACTIONS(288), + [anon_sym_EQ_GT] = ACTIONS(290), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [125] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(303), + [sym_indexing_expression] = STATE(303), + [sym_slicing_expression] = STATE(303), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(305), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(360), + [sym_identifier] = STATE(274), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(185), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [sym_name] = ACTIONS(187), + [sym_comment] = ACTIONS(3), + }, + [126] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(303), + [sym_indexing_expression] = STATE(303), + [sym_slicing_expression] = STATE(303), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(305), + [sym_unary_expression] = STATE(348), + [sym_cast_expression] = STATE(354), + [sym_identifier] = STATE(274), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(185), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [sym_name] = ACTIONS(187), + [sym_comment] = ACTIONS(3), + }, + [127] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(303), + [sym_indexing_expression] = STATE(303), + [sym_slicing_expression] = STATE(303), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(305), + [sym_unary_expression] = STATE(349), + [sym_identifier] = STATE(274), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_RBRACK] = ACTIONS(292), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(185), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [sym_name] = ACTIONS(187), + [sym_comment] = ACTIONS(3), + }, + [128] = { + [sym_octal_digit] = STATE(128), + [aux_sym_octal_digits_repeat1] = STATE(128), + [anon_sym_SEMI] = ACTIONS(294), + [anon_sym_EQ] = ACTIONS(296), + [anon_sym_RBRACE] = ACTIONS(294), + [anon_sym_COMMA] = ACTIONS(294), + [anon_sym_COLON] = ACTIONS(294), + [anon_sym_LPAREN] = ACTIONS(294), + [anon_sym_RPAREN] = ACTIONS(294), + [anon_sym_i8] = ACTIONS(294), + [anon_sym_i16] = ACTIONS(294), + [anon_sym_i32] = ACTIONS(294), + [anon_sym_i64] = ACTIONS(294), + [anon_sym_u8] = ACTIONS(294), + [anon_sym_u16] = ACTIONS(294), + [anon_sym_u32] = ACTIONS(294), + [anon_sym_u64] = ACTIONS(294), + [anon_sym_STAR] = ACTIONS(296), + [anon_sym_PIPE] = ACTIONS(296), + [anon_sym_LBRACK] = ACTIONS(294), + [anon_sym_RBRACK] = ACTIONS(294), + [anon_sym_DOT_DOT_DOT] = ACTIONS(294), + [anon_sym_0] = ACTIONS(298), + [anon_sym_1] = ACTIONS(298), + [anon_sym_2] = ACTIONS(298), + [anon_sym_3] = ACTIONS(298), + [anon_sym_4] = ACTIONS(298), + [anon_sym_5] = ACTIONS(298), + [anon_sym_6] = ACTIONS(298), + [anon_sym_7] = ACTIONS(298), + [anon_sym_i] = ACTIONS(296), + [anon_sym_u] = ACTIONS(296), + [anon_sym_z] = ACTIONS(294), + [anon_sym_DOT] = ACTIONS(296), + [anon_sym_DOT_DOT] = ACTIONS(296), + [anon_sym_QMARK] = ACTIONS(294), + [anon_sym_PLUS] = ACTIONS(296), + [anon_sym_DASH] = ACTIONS(296), + [anon_sym_AMP] = ACTIONS(296), + [anon_sym_as] = ACTIONS(294), + [anon_sym_is] = ACTIONS(294), + [anon_sym_SLASH] = ACTIONS(296), + [anon_sym_PERCENT] = ACTIONS(296), + [anon_sym_LT_LT] = ACTIONS(296), + [anon_sym_GT_GT] = ACTIONS(296), + [anon_sym_CARET] = ACTIONS(296), + [anon_sym_LT] = ACTIONS(296), + [anon_sym_GT] = ACTIONS(296), + [anon_sym_LT_EQ] = ACTIONS(294), + [anon_sym_GT_EQ] = ACTIONS(294), + [anon_sym_EQ_EQ] = ACTIONS(294), + [anon_sym_BANG_EQ] = ACTIONS(294), + [anon_sym_AMP_AMP] = ACTIONS(294), + [anon_sym_CARET_CARET] = ACTIONS(294), + [anon_sym_PIPE_PIPE] = ACTIONS(294), + [anon_sym_else] = ACTIONS(294), + [anon_sym_EQ_GT] = ACTIONS(294), + [anon_sym_PLUS_EQ] = ACTIONS(294), + [anon_sym_DASH_EQ] = ACTIONS(294), + [anon_sym_STAR_EQ] = ACTIONS(294), + [anon_sym_SLASH_EQ] = ACTIONS(294), + [anon_sym_PERCENT_EQ] = ACTIONS(294), + [anon_sym_LT_LT_EQ] = ACTIONS(294), + [anon_sym_GT_GT_EQ] = ACTIONS(294), + [anon_sym_AMP_EQ] = ACTIONS(294), + [anon_sym_PIPE_EQ] = ACTIONS(294), + [anon_sym_CARET_EQ] = ACTIONS(294), + [sym_comment] = ACTIONS(3), + }, + [129] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(303), + [sym_indexing_expression] = STATE(303), + [sym_slicing_expression] = STATE(303), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(305), + [sym_unary_expression] = STATE(349), + [sym_identifier] = STATE(274), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(35), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(35), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(185), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [sym_name] = ACTIONS(187), + [sym_comment] = ACTIONS(3), + }, + [130] = { + [sym_constant] = STATE(246), + [sym_integer_constant] = STATE(259), + [sym_decimal_digits] = STATE(140), + [sym_decimal_digit] = STATE(114), + [sym_floating_constant] = STATE(259), + [sym_rune_constant] = STATE(259), + [sym_string_constant] = STATE(259), + [sym_array_literal] = STATE(246), + [sym_enum_literal] = STATE(246), + [sym_struct_literal] = STATE(246), + [sym_plain_expression] = STATE(241), + [sym_nested_expression] = STATE(227), + [sym_allocation_expression] = STATE(227), + [sym_assertion_expression] = STATE(227), + [sym_call_expression] = STATE(227), + [sym_measurement_expression] = STATE(227), + [sym_size_expression] = STATE(225), + [sym_length_expression] = STATE(225), + [sym_offset_expression] = STATE(225), + [sym_field_access_expression] = STATE(227), + [sym_indexing_expression] = STATE(227), + [sym_slicing_expression] = STATE(227), + [sym_error_propagation] = STATE(227), + [sym_postfix_expression] = STATE(222), + [sym_unary_expression] = STATE(271), + [sym_identifier] = STATE(199), + [aux_sym_decimal_digits_repeat1] = STATE(114), + [aux_sym_string_constant_repeat1] = STATE(195), + [anon_sym_LPAREN] = ACTIONS(246), + [anon_sym_BANG] = ACTIONS(248), + [anon_sym_void] = ACTIONS(250), + [anon_sym_size] = ACTIONS(252), + [anon_sym_STAR] = ACTIONS(248), + [anon_sym_struct] = ACTIONS(254), + [anon_sym_LBRACK] = ACTIONS(256), + [anon_sym_true] = ACTIONS(250), + [anon_sym_false] = ACTIONS(250), + [anon_sym_null] = ACTIONS(250), + [anon_sym_0x] = ACTIONS(258), + [anon_sym_0o] = ACTIONS(260), + [anon_sym_0b] = ACTIONS(262), + [anon_sym_0] = ACTIONS(264), + [anon_sym_1] = ACTIONS(221), + [anon_sym_2] = ACTIONS(221), + [anon_sym_3] = ACTIONS(221), + [anon_sym_4] = ACTIONS(221), + [anon_sym_5] = ACTIONS(221), + [anon_sym_6] = ACTIONS(221), + [anon_sym_7] = ACTIONS(221), + [anon_sym_8] = ACTIONS(221), + [anon_sym_9] = ACTIONS(221), + [anon_sym_SQUOTE] = ACTIONS(266), + [anon_sym_DQUOTE] = ACTIONS(268), + [anon_sym_alloc] = ACTIONS(270), + [anon_sym_append] = ACTIONS(272), + [anon_sym_free] = ACTIONS(274), + [anon_sym_delete] = ACTIONS(276), + [anon_sym_assert] = ACTIONS(278), + [anon_sym_static] = ACTIONS(280), + [anon_sym_abort] = ACTIONS(282), + [anon_sym_len] = ACTIONS(284), + [anon_sym_offset] = ACTIONS(286), + [anon_sym_PLUS] = ACTIONS(248), + [anon_sym_DASH] = ACTIONS(248), + [anon_sym_TILDE] = ACTIONS(248), + [anon_sym_AMP] = ACTIONS(288), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [131] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(303), + [sym_indexing_expression] = STATE(303), + [sym_slicing_expression] = STATE(303), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(305), + [sym_unary_expression] = STATE(349), + [sym_identifier] = STATE(274), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(301), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(301), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(185), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(301), + [anon_sym_DASH] = ACTIONS(301), + [anon_sym_TILDE] = ACTIONS(301), + [anon_sym_AMP] = ACTIONS(303), + [sym_name] = ACTIONS(305), + [sym_comment] = ACTIONS(3), + }, + [132] = { + [sym_constant] = STATE(246), + [sym_integer_constant] = STATE(259), + [sym_decimal_digits] = STATE(140), + [sym_decimal_digit] = STATE(114), + [sym_floating_constant] = STATE(259), + [sym_rune_constant] = STATE(259), + [sym_string_constant] = STATE(259), + [sym_array_literal] = STATE(246), + [sym_enum_literal] = STATE(246), + [sym_struct_literal] = STATE(246), + [sym_plain_expression] = STATE(241), + [sym_nested_expression] = STATE(227), + [sym_allocation_expression] = STATE(227), + [sym_assertion_expression] = STATE(227), + [sym_call_expression] = STATE(227), + [sym_measurement_expression] = STATE(227), + [sym_size_expression] = STATE(225), + [sym_length_expression] = STATE(225), + [sym_offset_expression] = STATE(225), + [sym_field_access_expression] = STATE(227), + [sym_indexing_expression] = STATE(227), + [sym_slicing_expression] = STATE(227), + [sym_error_propagation] = STATE(227), + [sym_postfix_expression] = STATE(222), + [sym_unary_expression] = STATE(268), + [sym_identifier] = STATE(199), + [aux_sym_decimal_digits_repeat1] = STATE(114), + [aux_sym_string_constant_repeat1] = STATE(195), + [anon_sym_LPAREN] = ACTIONS(246), + [anon_sym_BANG] = ACTIONS(248), + [anon_sym_void] = ACTIONS(250), + [anon_sym_size] = ACTIONS(252), + [anon_sym_STAR] = ACTIONS(248), + [anon_sym_struct] = ACTIONS(254), + [anon_sym_LBRACK] = ACTIONS(256), + [anon_sym_true] = ACTIONS(250), + [anon_sym_false] = ACTIONS(250), + [anon_sym_null] = ACTIONS(250), + [anon_sym_0x] = ACTIONS(258), + [anon_sym_0o] = ACTIONS(260), + [anon_sym_0b] = ACTIONS(262), + [anon_sym_0] = ACTIONS(264), + [anon_sym_1] = ACTIONS(221), + [anon_sym_2] = ACTIONS(221), + [anon_sym_3] = ACTIONS(221), + [anon_sym_4] = ACTIONS(221), + [anon_sym_5] = ACTIONS(221), + [anon_sym_6] = ACTIONS(221), + [anon_sym_7] = ACTIONS(221), + [anon_sym_8] = ACTIONS(221), + [anon_sym_9] = ACTIONS(221), + [anon_sym_SQUOTE] = ACTIONS(266), + [anon_sym_DQUOTE] = ACTIONS(268), + [anon_sym_alloc] = ACTIONS(270), + [anon_sym_append] = ACTIONS(272), + [anon_sym_free] = ACTIONS(274), + [anon_sym_delete] = ACTIONS(276), + [anon_sym_assert] = ACTIONS(278), + [anon_sym_static] = ACTIONS(280), + [anon_sym_abort] = ACTIONS(282), + [anon_sym_len] = ACTIONS(284), + [anon_sym_offset] = ACTIONS(286), + [anon_sym_PLUS] = ACTIONS(248), + [anon_sym_DASH] = ACTIONS(248), + [anon_sym_TILDE] = ACTIONS(248), + [anon_sym_AMP] = ACTIONS(288), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [133] = { + [sym_constant] = STATE(246), + [sym_integer_constant] = STATE(259), + [sym_decimal_digits] = STATE(140), + [sym_decimal_digit] = STATE(114), + [sym_floating_constant] = STATE(259), + [sym_rune_constant] = STATE(259), + [sym_string_constant] = STATE(259), + [sym_array_literal] = STATE(246), + [sym_enum_literal] = STATE(246), + [sym_struct_literal] = STATE(246), + [sym_plain_expression] = STATE(241), + [sym_nested_expression] = STATE(227), + [sym_allocation_expression] = STATE(227), + [sym_assertion_expression] = STATE(227), + [sym_call_expression] = STATE(227), + [sym_measurement_expression] = STATE(227), + [sym_size_expression] = STATE(225), + [sym_length_expression] = STATE(225), + [sym_offset_expression] = STATE(225), + [sym_field_access_expression] = STATE(227), + [sym_indexing_expression] = STATE(227), + [sym_slicing_expression] = STATE(227), + [sym_error_propagation] = STATE(227), + [sym_postfix_expression] = STATE(222), + [sym_unary_expression] = STATE(263), + [sym_identifier] = STATE(199), + [aux_sym_decimal_digits_repeat1] = STATE(114), + [aux_sym_string_constant_repeat1] = STATE(195), + [anon_sym_LPAREN] = ACTIONS(246), + [anon_sym_BANG] = ACTIONS(248), + [anon_sym_void] = ACTIONS(250), + [anon_sym_size] = ACTIONS(252), + [anon_sym_STAR] = ACTIONS(248), + [anon_sym_struct] = ACTIONS(254), + [anon_sym_LBRACK] = ACTIONS(256), + [anon_sym_true] = ACTIONS(250), + [anon_sym_false] = ACTIONS(250), + [anon_sym_null] = ACTIONS(250), + [anon_sym_0x] = ACTIONS(258), + [anon_sym_0o] = ACTIONS(260), + [anon_sym_0b] = ACTIONS(262), + [anon_sym_0] = ACTIONS(264), + [anon_sym_1] = ACTIONS(221), + [anon_sym_2] = ACTIONS(221), + [anon_sym_3] = ACTIONS(221), + [anon_sym_4] = ACTIONS(221), + [anon_sym_5] = ACTIONS(221), + [anon_sym_6] = ACTIONS(221), + [anon_sym_7] = ACTIONS(221), + [anon_sym_8] = ACTIONS(221), + [anon_sym_9] = ACTIONS(221), + [anon_sym_SQUOTE] = ACTIONS(266), + [anon_sym_DQUOTE] = ACTIONS(268), + [anon_sym_alloc] = ACTIONS(270), + [anon_sym_append] = ACTIONS(272), + [anon_sym_free] = ACTIONS(274), + [anon_sym_delete] = ACTIONS(276), + [anon_sym_assert] = ACTIONS(278), + [anon_sym_static] = ACTIONS(280), + [anon_sym_abort] = ACTIONS(282), + [anon_sym_len] = ACTIONS(284), + [anon_sym_offset] = ACTIONS(286), + [anon_sym_PLUS] = ACTIONS(248), + [anon_sym_DASH] = ACTIONS(248), + [anon_sym_TILDE] = ACTIONS(248), + [anon_sym_AMP] = ACTIONS(288), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [134] = { + [sym_constant] = STATE(246), + [sym_integer_constant] = STATE(259), + [sym_decimal_digits] = STATE(140), + [sym_decimal_digit] = STATE(114), + [sym_floating_constant] = STATE(259), + [sym_rune_constant] = STATE(259), + [sym_string_constant] = STATE(259), + [sym_array_literal] = STATE(246), + [sym_enum_literal] = STATE(246), + [sym_struct_literal] = STATE(246), + [sym_plain_expression] = STATE(241), + [sym_nested_expression] = STATE(227), + [sym_allocation_expression] = STATE(227), + [sym_assertion_expression] = STATE(227), + [sym_call_expression] = STATE(227), + [sym_measurement_expression] = STATE(227), + [sym_size_expression] = STATE(225), + [sym_length_expression] = STATE(225), + [sym_offset_expression] = STATE(225), + [sym_field_access_expression] = STATE(227), + [sym_indexing_expression] = STATE(227), + [sym_slicing_expression] = STATE(227), + [sym_error_propagation] = STATE(227), + [sym_postfix_expression] = STATE(222), + [sym_unary_expression] = STATE(266), + [sym_identifier] = STATE(199), + [aux_sym_decimal_digits_repeat1] = STATE(114), + [aux_sym_string_constant_repeat1] = STATE(195), + [anon_sym_LPAREN] = ACTIONS(246), + [anon_sym_BANG] = ACTIONS(248), + [anon_sym_void] = ACTIONS(250), + [anon_sym_size] = ACTIONS(252), + [anon_sym_STAR] = ACTIONS(248), + [anon_sym_struct] = ACTIONS(254), + [anon_sym_LBRACK] = ACTIONS(256), + [anon_sym_true] = ACTIONS(250), + [anon_sym_false] = ACTIONS(250), + [anon_sym_null] = ACTIONS(250), + [anon_sym_0x] = ACTIONS(258), + [anon_sym_0o] = ACTIONS(260), + [anon_sym_0b] = ACTIONS(262), + [anon_sym_0] = ACTIONS(264), + [anon_sym_1] = ACTIONS(221), + [anon_sym_2] = ACTIONS(221), + [anon_sym_3] = ACTIONS(221), + [anon_sym_4] = ACTIONS(221), + [anon_sym_5] = ACTIONS(221), + [anon_sym_6] = ACTIONS(221), + [anon_sym_7] = ACTIONS(221), + [anon_sym_8] = ACTIONS(221), + [anon_sym_9] = ACTIONS(221), + [anon_sym_SQUOTE] = ACTIONS(266), + [anon_sym_DQUOTE] = ACTIONS(268), + [anon_sym_alloc] = ACTIONS(270), + [anon_sym_append] = ACTIONS(272), + [anon_sym_free] = ACTIONS(274), + [anon_sym_delete] = ACTIONS(276), + [anon_sym_assert] = ACTIONS(278), + [anon_sym_static] = ACTIONS(280), + [anon_sym_abort] = ACTIONS(282), + [anon_sym_len] = ACTIONS(284), + [anon_sym_offset] = ACTIONS(286), + [anon_sym_PLUS] = ACTIONS(248), + [anon_sym_DASH] = ACTIONS(248), + [anon_sym_TILDE] = ACTIONS(248), + [anon_sym_AMP] = ACTIONS(288), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [135] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(303), + [sym_indexing_expression] = STATE(303), + [sym_slicing_expression] = STATE(303), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(305), + [sym_unary_expression] = STATE(776), + [sym_identifier] = STATE(274), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(301), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(301), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(185), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(301), + [anon_sym_DASH] = ACTIONS(301), + [anon_sym_TILDE] = ACTIONS(301), + [anon_sym_AMP] = ACTIONS(303), + [sym_name] = ACTIONS(305), + [sym_comment] = ACTIONS(3), + }, + [136] = { + [sym_constant] = STATE(301), + [sym_integer_constant] = STATE(293), + [sym_decimal_digits] = STATE(163), + [sym_decimal_digit] = STATE(146), + [sym_floating_constant] = STATE(293), + [sym_rune_constant] = STATE(293), + [sym_string_constant] = STATE(293), + [sym_array_literal] = STATE(301), + [sym_enum_literal] = STATE(301), + [sym_struct_literal] = STATE(301), + [sym_plain_expression] = STATE(302), + [sym_nested_expression] = STATE(303), + [sym_allocation_expression] = STATE(303), + [sym_assertion_expression] = STATE(303), + [sym_call_expression] = STATE(303), + [sym_measurement_expression] = STATE(303), + [sym_size_expression] = STATE(304), + [sym_length_expression] = STATE(304), + [sym_offset_expression] = STATE(304), + [sym_field_access_expression] = STATE(303), + [sym_indexing_expression] = STATE(303), + [sym_slicing_expression] = STATE(303), + [sym_error_propagation] = STATE(303), + [sym_postfix_expression] = STATE(305), + [sym_unary_expression] = STATE(808), + [sym_identifier] = STATE(274), + [aux_sym_decimal_digits_repeat1] = STATE(146), + [aux_sym_string_constant_repeat1] = STATE(272), + [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_BANG] = ACTIONS(301), + [anon_sym_void] = ACTIONS(37), + [anon_sym_size] = ACTIONS(39), + [anon_sym_STAR] = ACTIONS(301), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_true] = ACTIONS(37), + [anon_sym_false] = ACTIONS(37), + [anon_sym_null] = ACTIONS(37), + [anon_sym_0x] = ACTIONS(47), + [anon_sym_0o] = ACTIONS(49), + [anon_sym_0b] = ACTIONS(51), + [anon_sym_0] = ACTIONS(53), + [anon_sym_1] = ACTIONS(55), + [anon_sym_2] = ACTIONS(55), + [anon_sym_3] = ACTIONS(55), + [anon_sym_4] = ACTIONS(55), + [anon_sym_5] = ACTIONS(55), + [anon_sym_6] = ACTIONS(55), + [anon_sym_7] = ACTIONS(55), + [anon_sym_8] = ACTIONS(55), + [anon_sym_9] = ACTIONS(55), + [anon_sym_SQUOTE] = ACTIONS(57), + [anon_sym_DQUOTE] = ACTIONS(59), + [anon_sym_alloc] = ACTIONS(61), + [anon_sym_append] = ACTIONS(63), + [anon_sym_free] = ACTIONS(65), + [anon_sym_delete] = ACTIONS(67), + [anon_sym_assert] = ACTIONS(69), + [anon_sym_static] = ACTIONS(185), + [anon_sym_abort] = ACTIONS(73), + [anon_sym_len] = ACTIONS(75), + [anon_sym_offset] = ACTIONS(77), + [anon_sym_PLUS] = ACTIONS(301), + [anon_sym_DASH] = ACTIONS(301), + [anon_sym_TILDE] = ACTIONS(301), + [anon_sym_AMP] = ACTIONS(303), + [sym_name] = ACTIONS(305), + [sym_comment] = ACTIONS(3), + }, + [137] = { + [sym_octal_digit] = STATE(128), + [aux_sym_octal_digits_repeat1] = STATE(128), + [anon_sym_SEMI] = ACTIONS(307), + [anon_sym_EQ] = ACTIONS(309), + [anon_sym_RBRACE] = ACTIONS(307), + [anon_sym_COMMA] = ACTIONS(307), + [anon_sym_COLON] = ACTIONS(307), + [anon_sym_LPAREN] = ACTIONS(307), + [anon_sym_RPAREN] = ACTIONS(307), + [anon_sym_i8] = ACTIONS(307), + [anon_sym_i16] = ACTIONS(307), + [anon_sym_i32] = ACTIONS(307), + [anon_sym_i64] = ACTIONS(307), + [anon_sym_u8] = ACTIONS(307), + [anon_sym_u16] = ACTIONS(307), + [anon_sym_u32] = ACTIONS(307), + [anon_sym_u64] = ACTIONS(307), + [anon_sym_STAR] = ACTIONS(309), + [anon_sym_PIPE] = ACTIONS(309), + [anon_sym_LBRACK] = ACTIONS(307), + [anon_sym_RBRACK] = ACTIONS(307), + [anon_sym_DOT_DOT_DOT] = ACTIONS(307), + [anon_sym_0] = ACTIONS(311), + [anon_sym_1] = ACTIONS(311), + [anon_sym_2] = ACTIONS(311), + [anon_sym_3] = ACTIONS(311), + [anon_sym_4] = ACTIONS(311), + [anon_sym_5] = ACTIONS(311), + [anon_sym_6] = ACTIONS(311), + [anon_sym_7] = ACTIONS(311), + [anon_sym_i] = ACTIONS(309), + [anon_sym_u] = ACTIONS(309), + [anon_sym_z] = ACTIONS(307), + [anon_sym_DOT] = ACTIONS(309), + [anon_sym_DOT_DOT] = ACTIONS(309), + [anon_sym_QMARK] = ACTIONS(307), + [anon_sym_PLUS] = ACTIONS(309), + [anon_sym_DASH] = ACTIONS(309), + [anon_sym_AMP] = ACTIONS(309), + [anon_sym_as] = ACTIONS(307), + [anon_sym_is] = ACTIONS(307), + [anon_sym_SLASH] = ACTIONS(309), + [anon_sym_PERCENT] = ACTIONS(309), + [anon_sym_LT_LT] = ACTIONS(309), + [anon_sym_GT_GT] = ACTIONS(309), + [anon_sym_CARET] = ACTIONS(309), + [anon_sym_LT] = ACTIONS(309), + [anon_sym_GT] = ACTIONS(309), + [anon_sym_LT_EQ] = ACTIONS(307), + [anon_sym_GT_EQ] = ACTIONS(307), + [anon_sym_EQ_EQ] = ACTIONS(307), + [anon_sym_BANG_EQ] = ACTIONS(307), + [anon_sym_AMP_AMP] = ACTIONS(307), + [anon_sym_CARET_CARET] = ACTIONS(307), + [anon_sym_PIPE_PIPE] = ACTIONS(307), + [anon_sym_else] = ACTIONS(307), + [anon_sym_EQ_GT] = ACTIONS(307), + [anon_sym_PLUS_EQ] = ACTIONS(307), + [anon_sym_DASH_EQ] = ACTIONS(307), + [anon_sym_STAR_EQ] = ACTIONS(307), + [anon_sym_SLASH_EQ] = ACTIONS(307), + [anon_sym_PERCENT_EQ] = ACTIONS(307), + [anon_sym_LT_LT_EQ] = ACTIONS(307), + [anon_sym_GT_GT_EQ] = ACTIONS(307), + [anon_sym_AMP_EQ] = ACTIONS(307), + [anon_sym_PIPE_EQ] = ACTIONS(307), + [anon_sym_CARET_EQ] = ACTIONS(307), + [sym_comment] = ACTIONS(3), + }, + [138] = { + [sym_constant] = STATE(246), + [sym_integer_constant] = STATE(259), + [sym_decimal_digits] = STATE(140), + [sym_decimal_digit] = STATE(114), + [sym_floating_constant] = STATE(259), + [sym_rune_constant] = STATE(259), + [sym_string_constant] = STATE(259), + [sym_array_literal] = STATE(246), + [sym_enum_literal] = STATE(246), + [sym_struct_literal] = STATE(246), + [sym_plain_expression] = STATE(241), + [sym_nested_expression] = STATE(227), + [sym_allocation_expression] = STATE(227), + [sym_assertion_expression] = STATE(227), + [sym_call_expression] = STATE(227), + [sym_measurement_expression] = STATE(227), + [sym_size_expression] = STATE(225), + [sym_length_expression] = STATE(225), + [sym_offset_expression] = STATE(225), + [sym_field_access_expression] = STATE(227), + [sym_indexing_expression] = STATE(227), + [sym_slicing_expression] = STATE(227), + [sym_error_propagation] = STATE(227), + [sym_postfix_expression] = STATE(222), + [sym_unary_expression] = STATE(265), + [sym_identifier] = STATE(199), + [aux_sym_decimal_digits_repeat1] = STATE(114), + [aux_sym_string_constant_repeat1] = STATE(195), + [anon_sym_LPAREN] = ACTIONS(246), + [anon_sym_BANG] = ACTIONS(248), + [anon_sym_void] = ACTIONS(250), + [anon_sym_size] = ACTIONS(252), + [anon_sym_STAR] = ACTIONS(248), + [anon_sym_struct] = ACTIONS(254), + [anon_sym_LBRACK] = ACTIONS(256), + [anon_sym_true] = ACTIONS(250), + [anon_sym_false] = ACTIONS(250), + [anon_sym_null] = ACTIONS(250), + [anon_sym_0x] = ACTIONS(258), + [anon_sym_0o] = ACTIONS(260), + [anon_sym_0b] = ACTIONS(262), + [anon_sym_0] = ACTIONS(264), + [anon_sym_1] = ACTIONS(221), + [anon_sym_2] = ACTIONS(221), + [anon_sym_3] = ACTIONS(221), + [anon_sym_4] = ACTIONS(221), + [anon_sym_5] = ACTIONS(221), + [anon_sym_6] = ACTIONS(221), + [anon_sym_7] = ACTIONS(221), + [anon_sym_8] = ACTIONS(221), + [anon_sym_9] = ACTIONS(221), + [anon_sym_SQUOTE] = ACTIONS(266), + [anon_sym_DQUOTE] = ACTIONS(268), + [anon_sym_alloc] = ACTIONS(270), + [anon_sym_append] = ACTIONS(272), + [anon_sym_free] = ACTIONS(274), + [anon_sym_delete] = ACTIONS(276), + [anon_sym_assert] = ACTIONS(278), + [anon_sym_static] = ACTIONS(280), + [anon_sym_abort] = ACTIONS(282), + [anon_sym_len] = ACTIONS(284), + [anon_sym_offset] = ACTIONS(286), + [anon_sym_PLUS] = ACTIONS(248), + [anon_sym_DASH] = ACTIONS(248), + [anon_sym_TILDE] = ACTIONS(248), + [anon_sym_AMP] = ACTIONS(288), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [139] = { + [anon_sym_SEMI] = ACTIONS(313), + [anon_sym_EQ] = ACTIONS(315), + [anon_sym_RBRACE] = ACTIONS(313), + [anon_sym_COMMA] = ACTIONS(313), + [anon_sym_COLON] = ACTIONS(313), + [anon_sym_LPAREN] = ACTIONS(313), + [anon_sym_RPAREN] = ACTIONS(313), + [anon_sym_i8] = ACTIONS(313), + [anon_sym_i16] = ACTIONS(313), + [anon_sym_i32] = ACTIONS(313), + [anon_sym_i64] = ACTIONS(313), + [anon_sym_u8] = ACTIONS(313), + [anon_sym_u16] = ACTIONS(313), + [anon_sym_u32] = ACTIONS(313), + [anon_sym_u64] = ACTIONS(313), + [anon_sym_STAR] = ACTIONS(315), + [anon_sym_PIPE] = ACTIONS(315), + [anon_sym_LBRACK] = ACTIONS(313), + [anon_sym_RBRACK] = ACTIONS(313), + [anon_sym_DOT_DOT_DOT] = ACTIONS(313), + [anon_sym_0] = ACTIONS(313), + [anon_sym_1] = ACTIONS(313), + [anon_sym_2] = ACTIONS(313), + [anon_sym_3] = ACTIONS(313), + [anon_sym_4] = ACTIONS(313), + [anon_sym_5] = ACTIONS(313), + [anon_sym_6] = ACTIONS(313), + [anon_sym_7] = ACTIONS(313), + [anon_sym_i] = ACTIONS(315), + [anon_sym_u] = ACTIONS(315), + [anon_sym_z] = ACTIONS(313), + [anon_sym_DOT] = ACTIONS(315), + [anon_sym_DOT_DOT] = ACTIONS(315), + [anon_sym_QMARK] = ACTIONS(313), + [anon_sym_PLUS] = ACTIONS(315), + [anon_sym_DASH] = ACTIONS(315), + [anon_sym_AMP] = ACTIONS(315), + [anon_sym_as] = ACTIONS(313), + [anon_sym_is] = ACTIONS(313), + [anon_sym_SLASH] = ACTIONS(315), + [anon_sym_PERCENT] = ACTIONS(315), + [anon_sym_LT_LT] = ACTIONS(315), + [anon_sym_GT_GT] = ACTIONS(315), + [anon_sym_CARET] = ACTIONS(315), + [anon_sym_LT] = ACTIONS(315), + [anon_sym_GT] = ACTIONS(315), + [anon_sym_LT_EQ] = ACTIONS(313), + [anon_sym_GT_EQ] = ACTIONS(313), + [anon_sym_EQ_EQ] = ACTIONS(313), + [anon_sym_BANG_EQ] = ACTIONS(313), + [anon_sym_AMP_AMP] = ACTIONS(313), + [anon_sym_CARET_CARET] = ACTIONS(313), + [anon_sym_PIPE_PIPE] = ACTIONS(313), + [anon_sym_else] = ACTIONS(313), + [anon_sym_EQ_GT] = ACTIONS(313), + [anon_sym_PLUS_EQ] = ACTIONS(313), + [anon_sym_DASH_EQ] = ACTIONS(313), + [anon_sym_STAR_EQ] = ACTIONS(313), + [anon_sym_SLASH_EQ] = ACTIONS(313), + [anon_sym_PERCENT_EQ] = ACTIONS(313), + [anon_sym_LT_LT_EQ] = ACTIONS(313), + [anon_sym_GT_GT_EQ] = ACTIONS(313), + [anon_sym_AMP_EQ] = ACTIONS(313), + [anon_sym_PIPE_EQ] = ACTIONS(313), + [anon_sym_CARET_EQ] = ACTIONS(313), + [sym_comment] = ACTIONS(3), + }, +}; + +static uint16_t ts_small_parse_table[] = { + [0] = 11, + ACTIONS(3), 1, + sym_comment, + ACTIONS(325), 1, + anon_sym_e, + ACTIONS(329), 1, + anon_sym_DOT, + STATE(149), 1, + sym_exponent, + STATE(257), 1, + sym_floating_suffix, + STATE(258), 1, + sym_integer_suffix, + ACTIONS(323), 2, + anon_sym_f32, + anon_sym_f64, + ACTIONS(327), 2, + anon_sym_i, + anon_sym_u, + ACTIONS(321), 9, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_z, + ACTIONS(319), 14, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(317), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [87] = 36, + ACTIONS(3), 1, + sym_comment, + ACTIONS(33), 1, + anon_sym_LPAREN, + ACTIONS(39), 1, + anon_sym_size, + ACTIONS(43), 1, + anon_sym_struct, + ACTIONS(45), 1, + anon_sym_LBRACK, + ACTIONS(47), 1, + anon_sym_0x, + ACTIONS(49), 1, + anon_sym_0o, + ACTIONS(51), 1, + anon_sym_0b, + ACTIONS(53), 1, + anon_sym_0, + ACTIONS(57), 1, + anon_sym_SQUOTE, + ACTIONS(59), 1, + anon_sym_DQUOTE, + ACTIONS(61), 1, + anon_sym_alloc, + ACTIONS(63), 1, + anon_sym_append, + ACTIONS(65), 1, + anon_sym_free, + ACTIONS(67), 1, + anon_sym_delete, + ACTIONS(69), 1, + anon_sym_assert, + ACTIONS(73), 1, + anon_sym_abort, + ACTIONS(75), 1, + anon_sym_len, + ACTIONS(77), 1, + anon_sym_offset, + ACTIONS(185), 1, + anon_sym_static, + ACTIONS(305), 1, + sym_name, + ACTIONS(332), 1, + anon_sym_STAR, + STATE(163), 1, + sym_decimal_digits, + STATE(272), 1, + aux_sym_string_constant_repeat1, + STATE(276), 1, + sym_identifier, + STATE(302), 1, + sym_plain_expression, + STATE(502), 1, + sym_postfix_expression, + STATE(806), 1, + sym_object_selector, + STATE(146), 2, + sym_decimal_digit, + aux_sym_decimal_digits_repeat1, + STATE(313), 2, + sym_field_access_expression, + sym_indexing_expression, + STATE(304), 3, + sym_size_expression, + sym_length_expression, + sym_offset_expression, + ACTIONS(37), 4, + anon_sym_void, + anon_sym_true, + anon_sym_false, + anon_sym_null, + STATE(293), 4, + sym_integer_constant, + sym_floating_constant, + sym_rune_constant, + sym_string_constant, + STATE(301), 4, + sym_constant, + sym_array_literal, + sym_enum_literal, + sym_struct_literal, + STATE(303), 7, + sym_nested_expression, + sym_allocation_expression, + sym_assertion_expression, + sym_call_expression, + sym_measurement_expression, + sym_slicing_expression, + sym_error_propagation, + ACTIONS(55), 9, + anon_sym_1, + anon_sym_2, + anon_sym_3, + anon_sym_4, + anon_sym_5, + anon_sym_6, + anon_sym_7, + anon_sym_8, + anon_sym_9, + [223] = 36, + ACTIONS(3), 1, + sym_comment, + ACTIONS(33), 1, + anon_sym_LPAREN, + ACTIONS(39), 1, + anon_sym_size, + ACTIONS(43), 1, + anon_sym_struct, + ACTIONS(45), 1, + anon_sym_LBRACK, + ACTIONS(47), 1, + anon_sym_0x, + ACTIONS(49), 1, + anon_sym_0o, + ACTIONS(51), 1, + anon_sym_0b, + ACTIONS(53), 1, + anon_sym_0, + ACTIONS(57), 1, + anon_sym_SQUOTE, + ACTIONS(59), 1, + anon_sym_DQUOTE, + ACTIONS(61), 1, + anon_sym_alloc, + ACTIONS(63), 1, + anon_sym_append, + ACTIONS(65), 1, + anon_sym_free, + ACTIONS(67), 1, + anon_sym_delete, + ACTIONS(69), 1, + anon_sym_assert, + ACTIONS(73), 1, + anon_sym_abort, + ACTIONS(75), 1, + anon_sym_len, + ACTIONS(77), 1, + anon_sym_offset, + ACTIONS(185), 1, + anon_sym_static, + ACTIONS(305), 1, + sym_name, + ACTIONS(334), 1, + anon_sym_STAR, + STATE(163), 1, + sym_decimal_digits, + STATE(272), 1, + aux_sym_string_constant_repeat1, + STATE(276), 1, + sym_identifier, + STATE(302), 1, + sym_plain_expression, + STATE(502), 1, + sym_postfix_expression, + STATE(734), 1, + sym_object_selector, + STATE(146), 2, + sym_decimal_digit, + aux_sym_decimal_digits_repeat1, + STATE(313), 2, + sym_field_access_expression, + sym_indexing_expression, + STATE(304), 3, + sym_size_expression, + sym_length_expression, + sym_offset_expression, + ACTIONS(37), 4, + anon_sym_void, + anon_sym_true, + anon_sym_false, + anon_sym_null, + STATE(293), 4, + sym_integer_constant, + sym_floating_constant, + sym_rune_constant, + sym_string_constant, + STATE(301), 4, + sym_constant, + sym_array_literal, + sym_enum_literal, + sym_struct_literal, + STATE(303), 7, + sym_nested_expression, + sym_allocation_expression, + sym_assertion_expression, + sym_call_expression, + sym_measurement_expression, + sym_slicing_expression, + sym_error_propagation, + ACTIONS(55), 9, + anon_sym_1, + anon_sym_2, + anon_sym_3, + anon_sym_4, + anon_sym_5, + anon_sym_6, + anon_sym_7, + anon_sym_8, + anon_sym_9, + [359] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(340), 2, + anon_sym_0, + anon_sym_1, + STATE(145), 2, + sym_binary_digit, + aux_sym_binary_digits_repeat1, + ACTIONS(338), 17, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_i, + anon_sym_u, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(336), 40, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_z, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [432] = 35, + ACTIONS(3), 1, + sym_comment, + ACTIONS(33), 1, + anon_sym_LPAREN, + ACTIONS(39), 1, + anon_sym_size, + ACTIONS(43), 1, + anon_sym_struct, + ACTIONS(45), 1, + anon_sym_LBRACK, + ACTIONS(47), 1, + anon_sym_0x, + ACTIONS(49), 1, + anon_sym_0o, + ACTIONS(51), 1, + anon_sym_0b, + ACTIONS(53), 1, + anon_sym_0, + ACTIONS(57), 1, + anon_sym_SQUOTE, + ACTIONS(59), 1, + anon_sym_DQUOTE, + ACTIONS(61), 1, + anon_sym_alloc, + ACTIONS(63), 1, + anon_sym_append, + ACTIONS(65), 1, + anon_sym_free, + ACTIONS(67), 1, + anon_sym_delete, + ACTIONS(69), 1, + anon_sym_assert, + ACTIONS(73), 1, + anon_sym_abort, + ACTIONS(75), 1, + anon_sym_len, + ACTIONS(77), 1, + anon_sym_offset, + ACTIONS(185), 1, + anon_sym_static, + ACTIONS(305), 1, + sym_name, + STATE(163), 1, + sym_decimal_digits, + STATE(272), 1, + aux_sym_string_constant_repeat1, + STATE(276), 1, + sym_identifier, + STATE(302), 1, + sym_plain_expression, + STATE(350), 1, + sym_object_selector, + STATE(502), 1, + sym_postfix_expression, + STATE(146), 2, + sym_decimal_digit, + aux_sym_decimal_digits_repeat1, + STATE(313), 2, + sym_field_access_expression, + sym_indexing_expression, + STATE(304), 3, + sym_size_expression, + sym_length_expression, + sym_offset_expression, + ACTIONS(37), 4, + anon_sym_void, + anon_sym_true, + anon_sym_false, + anon_sym_null, + STATE(293), 4, + sym_integer_constant, + sym_floating_constant, + sym_rune_constant, + sym_string_constant, + STATE(301), 4, + sym_constant, + sym_array_literal, + sym_enum_literal, + sym_struct_literal, + STATE(303), 7, + sym_nested_expression, + sym_allocation_expression, + sym_assertion_expression, + sym_call_expression, + sym_measurement_expression, + sym_slicing_expression, + sym_error_propagation, + ACTIONS(55), 9, + anon_sym_1, + anon_sym_2, + anon_sym_3, + anon_sym_4, + anon_sym_5, + anon_sym_6, + anon_sym_7, + anon_sym_8, + anon_sym_9, + [565] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(346), 2, + anon_sym_0, + anon_sym_1, + STATE(145), 2, + sym_binary_digit, + aux_sym_binary_digits_repeat1, + ACTIONS(344), 17, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_i, + anon_sym_u, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(342), 40, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_z, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [638] = 5, + ACTIONS(3), 1, + sym_comment, + STATE(148), 2, + sym_decimal_digit, + aux_sym_decimal_digits_repeat1, + ACTIONS(55), 10, + anon_sym_0, + anon_sym_1, + anon_sym_2, + anon_sym_3, + anon_sym_4, + anon_sym_5, + anon_sym_6, + anon_sym_7, + anon_sym_8, + anon_sym_9, + ACTIONS(219), 11, + anon_sym_PIPE, + anon_sym_e, + anon_sym_i, + anon_sym_u, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(217), 38, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_f32, + anon_sym_f64, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_z, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [711] = 35, + ACTIONS(3), 1, + sym_comment, + ACTIONS(33), 1, + anon_sym_LPAREN, + ACTIONS(39), 1, + anon_sym_size, + ACTIONS(43), 1, + anon_sym_struct, + ACTIONS(45), 1, + anon_sym_LBRACK, + ACTIONS(47), 1, + anon_sym_0x, + ACTIONS(49), 1, + anon_sym_0o, + ACTIONS(51), 1, + anon_sym_0b, + ACTIONS(53), 1, + anon_sym_0, + ACTIONS(57), 1, + anon_sym_SQUOTE, + ACTIONS(59), 1, + anon_sym_DQUOTE, + ACTIONS(61), 1, + anon_sym_alloc, + ACTIONS(63), 1, + anon_sym_append, + ACTIONS(65), 1, + anon_sym_free, + ACTIONS(67), 1, + anon_sym_delete, + ACTIONS(69), 1, + anon_sym_assert, + ACTIONS(73), 1, + anon_sym_abort, + ACTIONS(75), 1, + anon_sym_len, + ACTIONS(77), 1, + anon_sym_offset, + ACTIONS(185), 1, + anon_sym_static, + ACTIONS(187), 1, + sym_name, + STATE(163), 1, + sym_decimal_digits, + STATE(272), 1, + aux_sym_string_constant_repeat1, + STATE(276), 1, + sym_identifier, + STATE(302), 1, + sym_plain_expression, + STATE(350), 1, + sym_object_selector, + STATE(502), 1, + sym_postfix_expression, + STATE(146), 2, + sym_decimal_digit, + aux_sym_decimal_digits_repeat1, + STATE(313), 2, + sym_field_access_expression, + sym_indexing_expression, + STATE(304), 3, + sym_size_expression, + sym_length_expression, + sym_offset_expression, + ACTIONS(37), 4, + anon_sym_void, + anon_sym_true, + anon_sym_false, + anon_sym_null, + STATE(293), 4, + sym_integer_constant, + sym_floating_constant, + sym_rune_constant, + sym_string_constant, + STATE(301), 4, + sym_constant, + sym_array_literal, + sym_enum_literal, + sym_struct_literal, + STATE(303), 7, + sym_nested_expression, + sym_allocation_expression, + sym_assertion_expression, + sym_call_expression, + sym_measurement_expression, + sym_slicing_expression, + sym_error_propagation, + ACTIONS(55), 9, + anon_sym_1, + anon_sym_2, + anon_sym_3, + anon_sym_4, + anon_sym_5, + anon_sym_6, + anon_sym_7, + anon_sym_8, + anon_sym_9, + [844] = 5, + ACTIONS(3), 1, + sym_comment, + STATE(148), 2, + sym_decimal_digit, + aux_sym_decimal_digits_repeat1, + ACTIONS(349), 10, + anon_sym_0, + anon_sym_1, + anon_sym_2, + anon_sym_3, + anon_sym_4, + anon_sym_5, + anon_sym_6, + anon_sym_7, + anon_sym_8, + anon_sym_9, + ACTIONS(225), 11, + anon_sym_PIPE, + anon_sym_e, + anon_sym_i, + anon_sym_u, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(223), 38, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_f32, + anon_sym_f64, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_z, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [917] = 8, + ACTIONS(3), 1, + sym_comment, + STATE(247), 1, + sym_floating_suffix, + STATE(252), 1, + sym_integer_suffix, + ACTIONS(323), 2, + anon_sym_f32, + anon_sym_f64, + ACTIONS(327), 2, + anon_sym_i, + anon_sym_u, + ACTIONS(321), 9, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_z, + ACTIONS(354), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(352), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [996] = 35, + ACTIONS(3), 1, + sym_comment, + ACTIONS(33), 1, + anon_sym_LPAREN, + ACTIONS(39), 1, + anon_sym_size, + ACTIONS(43), 1, + anon_sym_struct, + ACTIONS(45), 1, + anon_sym_LBRACK, + ACTIONS(47), 1, + anon_sym_0x, + ACTIONS(49), 1, + anon_sym_0o, + ACTIONS(51), 1, + anon_sym_0b, + ACTIONS(53), 1, + anon_sym_0, + ACTIONS(57), 1, + anon_sym_SQUOTE, + ACTIONS(59), 1, + anon_sym_DQUOTE, + ACTIONS(61), 1, + anon_sym_alloc, + ACTIONS(63), 1, + anon_sym_append, + ACTIONS(65), 1, + anon_sym_free, + ACTIONS(67), 1, + anon_sym_delete, + ACTIONS(69), 1, + anon_sym_assert, + ACTIONS(73), 1, + anon_sym_abort, + ACTIONS(75), 1, + anon_sym_len, + ACTIONS(77), 1, + anon_sym_offset, + ACTIONS(97), 1, + sym_name, + ACTIONS(185), 1, + anon_sym_static, + STATE(163), 1, + sym_decimal_digits, + STATE(185), 1, + sym_identifier, + STATE(264), 1, + sym_object_selector, + STATE(272), 1, + aux_sym_string_constant_repeat1, + STATE(302), 1, + sym_plain_expression, + STATE(500), 1, + sym_postfix_expression, + STATE(146), 2, + sym_decimal_digit, + aux_sym_decimal_digits_repeat1, + STATE(220), 2, + sym_field_access_expression, + sym_indexing_expression, + STATE(304), 3, + sym_size_expression, + sym_length_expression, + sym_offset_expression, + ACTIONS(37), 4, + anon_sym_void, + anon_sym_true, + anon_sym_false, + anon_sym_null, + STATE(293), 4, + sym_integer_constant, + sym_floating_constant, + sym_rune_constant, + sym_string_constant, + STATE(301), 4, + sym_constant, + sym_array_literal, + sym_enum_literal, + sym_struct_literal, + STATE(303), 7, + sym_nested_expression, + sym_allocation_expression, + sym_assertion_expression, + sym_call_expression, + sym_measurement_expression, + sym_slicing_expression, + sym_error_propagation, + ACTIONS(55), 9, + anon_sym_1, + anon_sym_2, + anon_sym_3, + anon_sym_4, + anon_sym_5, + anon_sym_6, + anon_sym_7, + anon_sym_8, + anon_sym_9, + [1129] = 34, + ACTIONS(3), 1, + sym_comment, + ACTIONS(33), 1, + anon_sym_LPAREN, + ACTIONS(39), 1, + anon_sym_size, + ACTIONS(43), 1, + anon_sym_struct, + ACTIONS(45), 1, + anon_sym_LBRACK, + ACTIONS(47), 1, + anon_sym_0x, + ACTIONS(49), 1, + anon_sym_0o, + ACTIONS(51), 1, + anon_sym_0b, + ACTIONS(53), 1, + anon_sym_0, + ACTIONS(57), 1, + anon_sym_SQUOTE, + ACTIONS(59), 1, + anon_sym_DQUOTE, + ACTIONS(61), 1, + anon_sym_alloc, + ACTIONS(63), 1, + anon_sym_append, + ACTIONS(65), 1, + anon_sym_free, + ACTIONS(67), 1, + anon_sym_delete, + ACTIONS(69), 1, + anon_sym_assert, + ACTIONS(73), 1, + anon_sym_abort, + ACTIONS(75), 1, + anon_sym_len, + ACTIONS(77), 1, + anon_sym_offset, + ACTIONS(185), 1, + anon_sym_static, + ACTIONS(305), 1, + sym_name, + STATE(163), 1, + sym_decimal_digits, + STATE(272), 1, + aux_sym_string_constant_repeat1, + STATE(274), 1, + sym_identifier, + STATE(302), 1, + sym_plain_expression, + STATE(484), 1, + sym_field_access_expression, + STATE(502), 1, + sym_postfix_expression, + STATE(146), 2, + sym_decimal_digit, + aux_sym_decimal_digits_repeat1, + STATE(304), 3, + sym_size_expression, + sym_length_expression, + sym_offset_expression, + ACTIONS(37), 4, + anon_sym_void, + anon_sym_true, + anon_sym_false, + anon_sym_null, + STATE(293), 4, + sym_integer_constant, + sym_floating_constant, + sym_rune_constant, + sym_string_constant, + STATE(301), 4, + sym_constant, + sym_array_literal, + sym_enum_literal, + sym_struct_literal, + STATE(303), 8, + sym_nested_expression, + sym_allocation_expression, + sym_assertion_expression, + sym_call_expression, + sym_measurement_expression, + sym_indexing_expression, + sym_slicing_expression, + sym_error_propagation, + ACTIONS(55), 9, + anon_sym_1, + anon_sym_2, + anon_sym_3, + anon_sym_4, + anon_sym_5, + anon_sym_6, + anon_sym_7, + anon_sym_8, + anon_sym_9, + [1259] = 34, + ACTIONS(3), 1, + sym_comment, + ACTIONS(33), 1, + anon_sym_LPAREN, + ACTIONS(39), 1, + anon_sym_size, + ACTIONS(43), 1, + anon_sym_struct, + ACTIONS(45), 1, + anon_sym_LBRACK, + ACTIONS(47), 1, + anon_sym_0x, + ACTIONS(49), 1, + anon_sym_0o, + ACTIONS(51), 1, + anon_sym_0b, + ACTIONS(53), 1, + anon_sym_0, + ACTIONS(57), 1, + anon_sym_SQUOTE, + ACTIONS(59), 1, + anon_sym_DQUOTE, + ACTIONS(61), 1, + anon_sym_alloc, + ACTIONS(63), 1, + anon_sym_append, + ACTIONS(65), 1, + anon_sym_free, + ACTIONS(67), 1, + anon_sym_delete, + ACTIONS(69), 1, + anon_sym_assert, + ACTIONS(73), 1, + anon_sym_abort, + ACTIONS(75), 1, + anon_sym_len, + ACTIONS(77), 1, + anon_sym_offset, + ACTIONS(185), 1, + anon_sym_static, + ACTIONS(305), 1, + sym_name, + STATE(163), 1, + sym_decimal_digits, + STATE(272), 1, + aux_sym_string_constant_repeat1, + STATE(274), 1, + sym_identifier, + STATE(302), 1, + sym_plain_expression, + STATE(502), 1, + sym_postfix_expression, + STATE(146), 2, + sym_decimal_digit, + aux_sym_decimal_digits_repeat1, + STATE(488), 2, + sym_indexing_expression, + sym_slicing_expression, + STATE(304), 3, + sym_size_expression, + sym_length_expression, + sym_offset_expression, + ACTIONS(37), 4, + anon_sym_void, + anon_sym_true, + anon_sym_false, + anon_sym_null, + STATE(293), 4, + sym_integer_constant, + sym_floating_constant, + sym_rune_constant, + sym_string_constant, + STATE(301), 4, + sym_constant, + sym_array_literal, + sym_enum_literal, + sym_struct_literal, + STATE(303), 7, + sym_nested_expression, + sym_allocation_expression, + sym_assertion_expression, + sym_call_expression, + sym_measurement_expression, + sym_field_access_expression, + sym_error_propagation, + ACTIONS(55), 9, + anon_sym_1, + anon_sym_2, + anon_sym_3, + anon_sym_4, + anon_sym_5, + anon_sym_6, + anon_sym_7, + anon_sym_8, + anon_sym_9, + [1389] = 8, + ACTIONS(3), 1, + sym_comment, + ACTIONS(325), 1, + anon_sym_e, + STATE(159), 1, + sym_exponent, + STATE(258), 1, + sym_integer_suffix, + ACTIONS(327), 2, + anon_sym_i, + anon_sym_u, + ACTIONS(321), 9, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_z, + ACTIONS(319), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(317), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [1467] = 34, + ACTIONS(3), 1, + sym_comment, + ACTIONS(33), 1, + anon_sym_LPAREN, + ACTIONS(39), 1, + anon_sym_size, + ACTIONS(43), 1, + anon_sym_struct, + ACTIONS(45), 1, + anon_sym_LBRACK, + ACTIONS(47), 1, + anon_sym_0x, + ACTIONS(49), 1, + anon_sym_0o, + ACTIONS(51), 1, + anon_sym_0b, + ACTIONS(53), 1, + anon_sym_0, + ACTIONS(57), 1, + anon_sym_SQUOTE, + ACTIONS(59), 1, + anon_sym_DQUOTE, + ACTIONS(61), 1, + anon_sym_alloc, + ACTIONS(63), 1, + anon_sym_append, + ACTIONS(65), 1, + anon_sym_free, + ACTIONS(67), 1, + anon_sym_delete, + ACTIONS(69), 1, + anon_sym_assert, + ACTIONS(73), 1, + anon_sym_abort, + ACTIONS(75), 1, + anon_sym_len, + ACTIONS(77), 1, + anon_sym_offset, + ACTIONS(185), 1, + anon_sym_static, + ACTIONS(305), 1, + sym_name, + STATE(163), 1, + sym_decimal_digits, + STATE(272), 1, + aux_sym_string_constant_repeat1, + STATE(274), 1, + sym_identifier, + STATE(302), 1, + sym_plain_expression, + STATE(502), 1, + sym_postfix_expression, + STATE(146), 2, + sym_decimal_digit, + aux_sym_decimal_digits_repeat1, + STATE(483), 2, + sym_indexing_expression, + sym_slicing_expression, + STATE(304), 3, + sym_size_expression, + sym_length_expression, + sym_offset_expression, + ACTIONS(37), 4, + anon_sym_void, + anon_sym_true, + anon_sym_false, + anon_sym_null, + STATE(293), 4, + sym_integer_constant, + sym_floating_constant, + sym_rune_constant, + sym_string_constant, + STATE(301), 4, + sym_constant, + sym_array_literal, + sym_enum_literal, + sym_struct_literal, + STATE(303), 7, + sym_nested_expression, + sym_allocation_expression, + sym_assertion_expression, + sym_call_expression, + sym_measurement_expression, + sym_field_access_expression, + sym_error_propagation, + ACTIONS(55), 9, + anon_sym_1, + anon_sym_2, + anon_sym_3, + anon_sym_4, + anon_sym_5, + anon_sym_6, + anon_sym_7, + anon_sym_8, + anon_sym_9, + [1597] = 34, + ACTIONS(3), 1, + sym_comment, + ACTIONS(33), 1, + anon_sym_LPAREN, + ACTIONS(39), 1, + anon_sym_size, + ACTIONS(43), 1, + anon_sym_struct, + ACTIONS(45), 1, + anon_sym_LBRACK, + ACTIONS(47), 1, + anon_sym_0x, + ACTIONS(49), 1, + anon_sym_0o, + ACTIONS(51), 1, + anon_sym_0b, + ACTIONS(53), 1, + anon_sym_0, + ACTIONS(57), 1, + anon_sym_SQUOTE, + ACTIONS(59), 1, + anon_sym_DQUOTE, + ACTIONS(61), 1, + anon_sym_alloc, + ACTIONS(63), 1, + anon_sym_append, + ACTIONS(65), 1, + anon_sym_free, + ACTIONS(67), 1, + anon_sym_delete, + ACTIONS(69), 1, + anon_sym_assert, + ACTIONS(73), 1, + anon_sym_abort, + ACTIONS(75), 1, + anon_sym_len, + ACTIONS(77), 1, + anon_sym_offset, + ACTIONS(185), 1, + anon_sym_static, + ACTIONS(305), 1, + sym_name, + STATE(163), 1, + sym_decimal_digits, + STATE(272), 1, + aux_sym_string_constant_repeat1, + STATE(274), 1, + sym_identifier, + STATE(302), 1, + sym_plain_expression, + STATE(487), 1, + sym_field_access_expression, + STATE(502), 1, + sym_postfix_expression, + STATE(146), 2, + sym_decimal_digit, + aux_sym_decimal_digits_repeat1, + STATE(304), 3, + sym_size_expression, + sym_length_expression, + sym_offset_expression, + ACTIONS(37), 4, + anon_sym_void, + anon_sym_true, + anon_sym_false, + anon_sym_null, + STATE(293), 4, + sym_integer_constant, + sym_floating_constant, + sym_rune_constant, + sym_string_constant, + STATE(301), 4, + sym_constant, + sym_array_literal, + sym_enum_literal, + sym_struct_literal, + STATE(303), 8, + sym_nested_expression, + sym_allocation_expression, + sym_assertion_expression, + sym_call_expression, + sym_measurement_expression, + sym_indexing_expression, + sym_slicing_expression, + sym_error_propagation, + ACTIONS(55), 9, + anon_sym_1, + anon_sym_2, + anon_sym_3, + anon_sym_4, + anon_sym_5, + anon_sym_6, + anon_sym_7, + anon_sym_8, + anon_sym_9, + [1727] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(358), 17, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_i, + anon_sym_u, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(356), 42, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_0, + anon_sym_1, + anon_sym_z, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [1794] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(362), 17, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_i, + anon_sym_u, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(360), 42, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_f32, + anon_sym_f64, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_z, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [1861] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(242), 11, + anon_sym_PIPE, + anon_sym_e, + anon_sym_i, + anon_sym_u, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(240), 48, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_f32, + anon_sym_f64, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_0, + anon_sym_1, + anon_sym_2, + anon_sym_3, + anon_sym_4, + anon_sym_5, + anon_sym_6, + anon_sym_7, + anon_sym_8, + anon_sym_9, + anon_sym_z, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [1928] = 6, + ACTIONS(3), 1, + sym_comment, + STATE(252), 1, + sym_integer_suffix, + ACTIONS(327), 2, + anon_sym_i, + anon_sym_u, + ACTIONS(321), 9, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_z, + ACTIONS(354), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(352), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [2000] = 5, + ACTIONS(3), 1, + sym_comment, + STATE(161), 2, + sym_octal_digit, + aux_sym_octal_digits_repeat1, + ACTIONS(364), 8, + anon_sym_0, + anon_sym_1, + anon_sym_2, + anon_sym_3, + anon_sym_4, + anon_sym_5, + anon_sym_6, + anon_sym_7, + ACTIONS(309), 10, + anon_sym_PIPE, + anon_sym_i, + anon_sym_u, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(307), 36, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_z, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [2068] = 5, + ACTIONS(3), 1, + sym_comment, + STATE(161), 2, + sym_octal_digit, + aux_sym_octal_digits_repeat1, + ACTIONS(366), 8, + anon_sym_0, + anon_sym_1, + anon_sym_2, + anon_sym_3, + anon_sym_4, + anon_sym_5, + anon_sym_6, + anon_sym_7, + ACTIONS(296), 10, + anon_sym_PIPE, + anon_sym_i, + anon_sym_u, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(294), 36, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_z, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [2136] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(315), 10, + anon_sym_PIPE, + anon_sym_i, + anon_sym_u, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(313), 44, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_0, + anon_sym_1, + anon_sym_2, + anon_sym_3, + anon_sym_4, + anon_sym_5, + anon_sym_6, + anon_sym_7, + anon_sym_z, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [2198] = 11, + ACTIONS(3), 1, + sym_comment, + ACTIONS(373), 1, + anon_sym_e, + ACTIONS(377), 1, + anon_sym_DOT, + STATE(173), 1, + sym_exponent, + STATE(298), 1, + sym_integer_suffix, + STATE(299), 1, + sym_floating_suffix, + ACTIONS(371), 2, + anon_sym_f32, + anon_sym_f64, + ACTIONS(375), 2, + anon_sym_i, + anon_sym_u, + ACTIONS(319), 7, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(369), 9, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_z, + ACTIONS(317), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [2274] = 25, + ACTIONS(3), 1, + sym_comment, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(380), 1, + anon_sym_RBRACE, + ACTIONS(382), 1, + anon_sym_const, + ACTIONS(384), 1, + anon_sym_LPAREN, + ACTIONS(386), 1, + anon_sym_fn, + ACTIONS(394), 1, + anon_sym_enum, + ACTIONS(396), 1, + anon_sym_STAR, + ACTIONS(398), 1, + anon_sym_nullable, + ACTIONS(400), 1, + anon_sym_struct, + ACTIONS(402), 1, + anon_sym_union, + ACTIONS(404), 1, + anon_sym_LBRACK, + ACTIONS(406), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(408), 1, + sym_name, + STATE(428), 1, + sym_identifier, + STATE(552), 1, + sym_match_case, + STATE(649), 1, + sym_fntype_attr, + STATE(713), 1, + sym_match_cases, + STATE(725), 1, + sym_type, + ACTIONS(392), 2, + anon_sym_f32, + anon_sym_f64, + STATE(426), 2, + sym__inner_type, + sym_storage_class, + ACTIONS(388), 3, + anon_sym_rune, + anon_sym_bool, + anon_sym_void, + STATE(424), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(427), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(390), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [2377] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(410), 24, + anon_sym_LBRACE, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_BANG, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_0x, + anon_sym_0o, + anon_sym_0b, + anon_sym_1, + anon_sym_2, + anon_sym_3, + anon_sym_4, + anon_sym_5, + anon_sym_6, + anon_sym_7, + anon_sym_8, + anon_sym_9, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_TILDE, + anon_sym_AMP, + ACTIONS(412), 27, + anon_sym_let, + anon_sym_const, + anon_sym_void, + anon_sym_size, + anon_sym_struct, + anon_sym_true, + anon_sym_false, + anon_sym_null, + anon_sym_0, + anon_sym_alloc, + anon_sym_append, + anon_sym_free, + anon_sym_delete, + anon_sym_assert, + anon_sym_static, + anon_sym_abort, + anon_sym_len, + anon_sym_offset, + anon_sym_if, + anon_sym_for, + anon_sym_switch, + anon_sym_match, + anon_sym_defer, + anon_sym_break, + anon_sym_continue, + anon_sym_return, + sym_name, + [2436] = 7, + ACTIONS(3), 1, + sym_comment, + ACTIONS(325), 1, + anon_sym_e, + STATE(174), 1, + sym_exponent, + STATE(221), 1, + sym_floating_suffix, + ACTIONS(323), 2, + anon_sym_f32, + anon_sym_f64, + ACTIONS(416), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(414), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [2503] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(418), 2, + anon_sym_0, + anon_sym_1, + STATE(167), 2, + sym_binary_digit, + aux_sym_binary_digits_repeat1, + ACTIONS(344), 10, + anon_sym_PIPE, + anon_sym_i, + anon_sym_u, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(342), 36, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_z, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [2565] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(421), 2, + anon_sym_0, + anon_sym_1, + STATE(167), 2, + sym_binary_digit, + aux_sym_binary_digits_repeat1, + ACTIONS(338), 10, + anon_sym_PIPE, + anon_sym_i, + anon_sym_u, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(336), 36, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_z, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [2627] = 24, + ACTIONS(3), 1, + sym_comment, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(382), 1, + anon_sym_const, + ACTIONS(384), 1, + anon_sym_LPAREN, + ACTIONS(386), 1, + anon_sym_fn, + ACTIONS(394), 1, + anon_sym_enum, + ACTIONS(398), 1, + anon_sym_nullable, + ACTIONS(400), 1, + anon_sym_struct, + ACTIONS(402), 1, + anon_sym_union, + ACTIONS(404), 1, + anon_sym_LBRACK, + ACTIONS(406), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(423), 1, + anon_sym_RPAREN, + ACTIONS(425), 1, + anon_sym_STAR, + ACTIONS(427), 1, + sym_name, + STATE(428), 1, + sym_identifier, + STATE(567), 1, + sym_type, + STATE(649), 1, + sym_fntype_attr, + STATE(685), 1, + sym_tuple_types, + ACTIONS(392), 2, + anon_sym_f32, + anon_sym_f64, + STATE(426), 2, + sym__inner_type, + sym_storage_class, + ACTIONS(388), 3, + anon_sym_rune, + anon_sym_bool, + anon_sym_void, + STATE(424), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(427), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(390), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [2727] = 24, + ACTIONS(3), 1, + sym_comment, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(382), 1, + anon_sym_const, + ACTIONS(384), 1, + anon_sym_LPAREN, + ACTIONS(386), 1, + anon_sym_fn, + ACTIONS(394), 1, + anon_sym_enum, + ACTIONS(396), 1, + anon_sym_STAR, + ACTIONS(398), 1, + anon_sym_nullable, + ACTIONS(400), 1, + anon_sym_struct, + ACTIONS(402), 1, + anon_sym_union, + ACTIONS(404), 1, + anon_sym_LBRACK, + ACTIONS(406), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(408), 1, + sym_name, + STATE(428), 1, + sym_identifier, + STATE(552), 1, + sym_match_case, + STATE(649), 1, + sym_fntype_attr, + STATE(723), 1, + sym_match_cases, + STATE(725), 1, + sym_type, + ACTIONS(392), 2, + anon_sym_f32, + anon_sym_f64, + STATE(426), 2, + sym__inner_type, + sym_storage_class, + ACTIONS(388), 3, + anon_sym_rune, + anon_sym_bool, + anon_sym_void, + STATE(424), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(427), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(390), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [2827] = 24, + ACTIONS(3), 1, + sym_comment, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(382), 1, + anon_sym_const, + ACTIONS(384), 1, + anon_sym_LPAREN, + ACTIONS(386), 1, + anon_sym_fn, + ACTIONS(394), 1, + anon_sym_enum, + ACTIONS(398), 1, + anon_sym_nullable, + ACTIONS(400), 1, + anon_sym_struct, + ACTIONS(402), 1, + anon_sym_union, + ACTIONS(404), 1, + anon_sym_LBRACK, + ACTIONS(406), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(425), 1, + anon_sym_STAR, + ACTIONS(427), 1, + sym_name, + STATE(428), 1, + sym_identifier, + STATE(604), 1, + sym_type, + STATE(645), 1, + sym_tuple_types, + STATE(646), 1, + sym_tagged_types, + STATE(649), 1, + sym_fntype_attr, + ACTIONS(392), 2, + anon_sym_f32, + anon_sym_f64, + STATE(426), 2, + sym__inner_type, + sym_storage_class, + ACTIONS(388), 3, + anon_sym_rune, + anon_sym_bool, + anon_sym_void, + STATE(424), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(427), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(390), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [2927] = 24, + ACTIONS(3), 1, + sym_comment, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(382), 1, + anon_sym_const, + ACTIONS(384), 1, + anon_sym_LPAREN, + ACTIONS(386), 1, + anon_sym_fn, + ACTIONS(394), 1, + anon_sym_enum, + ACTIONS(398), 1, + anon_sym_nullable, + ACTIONS(400), 1, + anon_sym_struct, + ACTIONS(402), 1, + anon_sym_union, + ACTIONS(404), 1, + anon_sym_LBRACK, + ACTIONS(406), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(425), 1, + anon_sym_STAR, + ACTIONS(427), 1, + sym_name, + STATE(428), 1, + sym_identifier, + STATE(604), 1, + sym_type, + STATE(649), 1, + sym_fntype_attr, + STATE(658), 1, + sym_tuple_types, + STATE(659), 1, + sym_tagged_types, + ACTIONS(392), 2, + anon_sym_f32, + anon_sym_f64, + STATE(426), 2, + sym__inner_type, + sym_storage_class, + ACTIONS(388), 3, + anon_sym_rune, + anon_sym_bool, + anon_sym_void, + STATE(424), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(427), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(390), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [3027] = 8, + ACTIONS(3), 1, + sym_comment, + STATE(297), 1, + sym_floating_suffix, + STATE(320), 1, + sym_integer_suffix, + ACTIONS(371), 2, + anon_sym_f32, + anon_sym_f64, + ACTIONS(375), 2, + anon_sym_i, + anon_sym_u, + ACTIONS(354), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(369), 9, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_z, + ACTIONS(352), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [3095] = 5, + ACTIONS(3), 1, + sym_comment, + STATE(236), 1, + sym_floating_suffix, + ACTIONS(323), 2, + anon_sym_f32, + anon_sym_f64, + ACTIONS(431), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(429), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [3156] = 8, + ACTIONS(3), 1, + sym_comment, + ACTIONS(373), 1, + anon_sym_e, + STATE(212), 1, + sym_exponent, + STATE(298), 1, + sym_integer_suffix, + ACTIONS(375), 2, + anon_sym_i, + anon_sym_u, + ACTIONS(319), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(369), 9, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_z, + ACTIONS(317), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [3223] = 23, + ACTIONS(3), 1, + sym_comment, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(382), 1, + anon_sym_const, + ACTIONS(384), 1, + anon_sym_LPAREN, + ACTIONS(386), 1, + anon_sym_fn, + ACTIONS(394), 1, + anon_sym_enum, + ACTIONS(398), 1, + anon_sym_nullable, + ACTIONS(400), 1, + anon_sym_struct, + ACTIONS(402), 1, + anon_sym_union, + ACTIONS(404), 1, + anon_sym_LBRACK, + ACTIONS(406), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(425), 1, + anon_sym_STAR, + ACTIONS(427), 1, + sym_name, + STATE(428), 1, + sym_identifier, + STATE(567), 1, + sym_type, + STATE(649), 1, + sym_fntype_attr, + STATE(685), 1, + sym_tuple_types, + ACTIONS(392), 2, + anon_sym_f32, + anon_sym_f64, + STATE(426), 2, + sym__inner_type, + sym_storage_class, + ACTIONS(388), 3, + anon_sym_rune, + anon_sym_bool, + anon_sym_void, + STATE(424), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(427), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(390), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [3320] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(435), 16, + anon_sym_EQ, + anon_sym_COLON, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(433), 32, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [3376] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(358), 10, + anon_sym_PIPE, + anon_sym_i, + anon_sym_u, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(356), 38, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_0, + anon_sym_1, + anon_sym_z, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [3432] = 22, + ACTIONS(3), 1, + sym_comment, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(382), 1, + anon_sym_const, + ACTIONS(384), 1, + anon_sym_LPAREN, + ACTIONS(386), 1, + anon_sym_fn, + ACTIONS(394), 1, + anon_sym_enum, + ACTIONS(398), 1, + anon_sym_nullable, + ACTIONS(400), 1, + anon_sym_struct, + ACTIONS(402), 1, + anon_sym_union, + ACTIONS(404), 1, + anon_sym_LBRACK, + ACTIONS(406), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(425), 1, + anon_sym_STAR, + ACTIONS(427), 1, + sym_name, + STATE(428), 1, + sym_identifier, + STATE(559), 1, + sym_type, + STATE(649), 1, + sym_fntype_attr, + ACTIONS(392), 2, + anon_sym_f32, + anon_sym_f64, + STATE(426), 2, + sym__inner_type, + sym_storage_class, + ACTIONS(388), 3, + anon_sym_rune, + anon_sym_bool, + anon_sym_void, + STATE(424), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(427), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(390), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [3526] = 22, + ACTIONS(3), 1, + sym_comment, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(382), 1, + anon_sym_const, + ACTIONS(384), 1, + anon_sym_LPAREN, + ACTIONS(386), 1, + anon_sym_fn, + ACTIONS(394), 1, + anon_sym_enum, + ACTIONS(398), 1, + anon_sym_nullable, + ACTIONS(400), 1, + anon_sym_struct, + ACTIONS(402), 1, + anon_sym_union, + ACTIONS(404), 1, + anon_sym_LBRACK, + ACTIONS(406), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(425), 1, + anon_sym_STAR, + ACTIONS(427), 1, + sym_name, + STATE(428), 1, + sym_identifier, + STATE(649), 1, + sym_fntype_attr, + STATE(714), 1, + sym_type, + ACTIONS(392), 2, + anon_sym_f32, + anon_sym_f64, + STATE(426), 2, + sym__inner_type, + sym_storage_class, + ACTIONS(388), 3, + anon_sym_rune, + anon_sym_bool, + anon_sym_void, + STATE(424), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(427), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(390), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [3620] = 22, + ACTIONS(3), 1, + sym_comment, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(437), 1, + anon_sym_const, + ACTIONS(439), 1, + anon_sym_LPAREN, + ACTIONS(441), 1, + anon_sym_fn, + ACTIONS(449), 1, + anon_sym_enum, + ACTIONS(451), 1, + anon_sym_STAR, + ACTIONS(453), 1, + anon_sym_nullable, + ACTIONS(455), 1, + anon_sym_struct, + ACTIONS(457), 1, + anon_sym_union, + ACTIONS(459), 1, + anon_sym_LBRACK, + ACTIONS(461), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(463), 1, + sym_name, + STATE(326), 1, + sym_identifier, + STATE(353), 1, + sym_type, + STATE(737), 1, + sym_fntype_attr, + ACTIONS(447), 2, + anon_sym_f32, + anon_sym_f64, + STATE(330), 2, + sym__inner_type, + sym_storage_class, + ACTIONS(443), 3, + anon_sym_rune, + anon_sym_bool, + anon_sym_void, + STATE(327), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(342), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(445), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [3714] = 22, + ACTIONS(3), 1, + sym_comment, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(437), 1, + anon_sym_const, + ACTIONS(439), 1, + anon_sym_LPAREN, + ACTIONS(441), 1, + anon_sym_fn, + ACTIONS(449), 1, + anon_sym_enum, + ACTIONS(451), 1, + anon_sym_STAR, + ACTIONS(453), 1, + anon_sym_nullable, + ACTIONS(455), 1, + anon_sym_struct, + ACTIONS(457), 1, + anon_sym_union, + ACTIONS(459), 1, + anon_sym_LBRACK, + ACTIONS(461), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(463), 1, + sym_name, + STATE(326), 1, + sym_identifier, + STATE(352), 1, + sym_type, + STATE(737), 1, + sym_fntype_attr, + ACTIONS(447), 2, + anon_sym_f32, + anon_sym_f64, + STATE(330), 2, + sym__inner_type, + sym_storage_class, + ACTIONS(443), 3, + anon_sym_rune, + anon_sym_bool, + anon_sym_void, + STATE(327), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(342), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(445), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [3808] = 22, + ACTIONS(3), 1, + sym_comment, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(382), 1, + anon_sym_const, + ACTIONS(384), 1, + anon_sym_LPAREN, + ACTIONS(386), 1, + anon_sym_fn, + ACTIONS(394), 1, + anon_sym_enum, + ACTIONS(398), 1, + anon_sym_nullable, + ACTIONS(400), 1, + anon_sym_struct, + ACTIONS(402), 1, + anon_sym_union, + ACTIONS(404), 1, + anon_sym_LBRACK, + ACTIONS(406), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(425), 1, + anon_sym_STAR, + ACTIONS(427), 1, + sym_name, + STATE(428), 1, + sym_identifier, + STATE(649), 1, + sym_fntype_attr, + STATE(702), 1, + sym_type, + ACTIONS(392), 2, + anon_sym_f32, + anon_sym_f64, + STATE(426), 2, + sym__inner_type, + sym_storage_class, + ACTIONS(388), 3, + anon_sym_rune, + anon_sym_bool, + anon_sym_void, + STATE(424), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(427), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(390), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [3902] = 22, + ACTIONS(3), 1, + sym_comment, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(437), 1, + anon_sym_const, + ACTIONS(439), 1, + anon_sym_LPAREN, + ACTIONS(441), 1, + anon_sym_fn, + ACTIONS(449), 1, + anon_sym_enum, + ACTIONS(451), 1, + anon_sym_STAR, + ACTIONS(453), 1, + anon_sym_nullable, + ACTIONS(455), 1, + anon_sym_struct, + ACTIONS(457), 1, + anon_sym_union, + ACTIONS(459), 1, + anon_sym_LBRACK, + ACTIONS(461), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(463), 1, + sym_name, + STATE(326), 1, + sym_identifier, + STATE(351), 1, + sym_type, + STATE(737), 1, + sym_fntype_attr, + ACTIONS(447), 2, + anon_sym_f32, + anon_sym_f64, + STATE(330), 2, + sym__inner_type, + sym_storage_class, + ACTIONS(443), 3, + anon_sym_rune, + anon_sym_bool, + anon_sym_void, + STATE(327), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(342), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(445), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [3996] = 7, + ACTIONS(3), 1, + sym_comment, + ACTIONS(469), 1, + anon_sym_COLON_COLON, + ACTIONS(471), 1, + anon_sym_LBRACE, + ACTIONS(475), 1, + anon_sym_DOT, + ACTIONS(473), 3, + anon_sym_LPAREN, + anon_sym_LBRACK, + anon_sym_QMARK, + ACTIONS(467), 15, + anon_sym_EQ, + anon_sym_COLON, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(465), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [4060] = 22, + ACTIONS(3), 1, + sym_comment, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(382), 1, + anon_sym_const, + ACTIONS(384), 1, + anon_sym_LPAREN, + ACTIONS(386), 1, + anon_sym_fn, + ACTIONS(394), 1, + anon_sym_enum, + ACTIONS(398), 1, + anon_sym_nullable, + ACTIONS(400), 1, + anon_sym_struct, + ACTIONS(402), 1, + anon_sym_union, + ACTIONS(404), 1, + anon_sym_LBRACK, + ACTIONS(406), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(425), 1, + anon_sym_STAR, + ACTIONS(427), 1, + sym_name, + STATE(428), 1, + sym_identifier, + STATE(557), 1, + sym_type, + STATE(649), 1, + sym_fntype_attr, + ACTIONS(392), 2, + anon_sym_f32, + anon_sym_f64, + STATE(426), 2, + sym__inner_type, + sym_storage_class, + ACTIONS(388), 3, + anon_sym_rune, + anon_sym_bool, + anon_sym_void, + STATE(424), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(427), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(390), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [4154] = 22, + ACTIONS(3), 1, + sym_comment, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(382), 1, + anon_sym_const, + ACTIONS(384), 1, + anon_sym_LPAREN, + ACTIONS(386), 1, + anon_sym_fn, + ACTIONS(394), 1, + anon_sym_enum, + ACTIONS(398), 1, + anon_sym_nullable, + ACTIONS(400), 1, + anon_sym_struct, + ACTIONS(402), 1, + anon_sym_union, + ACTIONS(404), 1, + anon_sym_LBRACK, + ACTIONS(406), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(425), 1, + anon_sym_STAR, + ACTIONS(427), 1, + sym_name, + ACTIONS(477), 1, + anon_sym_EQ_GT, + STATE(428), 1, + sym_identifier, + STATE(649), 1, + sym_fntype_attr, + ACTIONS(392), 2, + anon_sym_f32, + anon_sym_f64, + STATE(435), 2, + sym__inner_type, + sym_storage_class, + ACTIONS(388), 3, + anon_sym_rune, + anon_sym_bool, + anon_sym_void, + STATE(424), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(427), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(390), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [4248] = 22, + ACTIONS(3), 1, + sym_comment, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(382), 1, + anon_sym_const, + ACTIONS(384), 1, + anon_sym_LPAREN, + ACTIONS(386), 1, + anon_sym_fn, + ACTIONS(394), 1, + anon_sym_enum, + ACTIONS(398), 1, + anon_sym_nullable, + ACTIONS(400), 1, + anon_sym_struct, + ACTIONS(402), 1, + anon_sym_union, + ACTIONS(404), 1, + anon_sym_LBRACK, + ACTIONS(406), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(425), 1, + anon_sym_STAR, + ACTIONS(427), 1, + sym_name, + STATE(428), 1, + sym_identifier, + STATE(649), 1, + sym_fntype_attr, + STATE(751), 1, + sym_type, + ACTIONS(392), 2, + anon_sym_f32, + anon_sym_f64, + STATE(426), 2, + sym__inner_type, + sym_storage_class, + ACTIONS(388), 3, + anon_sym_rune, + anon_sym_bool, + anon_sym_void, + STATE(424), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(427), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(390), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [4342] = 22, + ACTIONS(3), 1, + sym_comment, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(382), 1, + anon_sym_const, + ACTIONS(384), 1, + anon_sym_LPAREN, + ACTIONS(386), 1, + anon_sym_fn, + ACTIONS(394), 1, + anon_sym_enum, + ACTIONS(398), 1, + anon_sym_nullable, + ACTIONS(400), 1, + anon_sym_struct, + ACTIONS(402), 1, + anon_sym_union, + ACTIONS(404), 1, + anon_sym_LBRACK, + ACTIONS(406), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(425), 1, + anon_sym_STAR, + ACTIONS(427), 1, + sym_name, + STATE(428), 1, + sym_identifier, + STATE(520), 1, + sym_type, + STATE(649), 1, + sym_fntype_attr, + ACTIONS(392), 2, + anon_sym_f32, + anon_sym_f64, + STATE(426), 2, + sym__inner_type, + sym_storage_class, + ACTIONS(388), 3, + anon_sym_rune, + anon_sym_bool, + anon_sym_void, + STATE(424), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(427), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(390), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [4436] = 22, + ACTIONS(3), 1, + sym_comment, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(382), 1, + anon_sym_const, + ACTIONS(384), 1, + anon_sym_LPAREN, + ACTIONS(386), 1, + anon_sym_fn, + ACTIONS(394), 1, + anon_sym_enum, + ACTIONS(398), 1, + anon_sym_nullable, + ACTIONS(400), 1, + anon_sym_struct, + ACTIONS(402), 1, + anon_sym_union, + ACTIONS(404), 1, + anon_sym_LBRACK, + ACTIONS(406), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(425), 1, + anon_sym_STAR, + ACTIONS(427), 1, + sym_name, + STATE(428), 1, + sym_identifier, + STATE(649), 1, + sym_fntype_attr, + STATE(698), 1, + sym_type, + ACTIONS(392), 2, + anon_sym_f32, + anon_sym_f64, + STATE(426), 2, + sym__inner_type, + sym_storage_class, + ACTIONS(388), 3, + anon_sym_rune, + anon_sym_bool, + anon_sym_void, + STATE(424), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(427), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(390), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [4530] = 22, + ACTIONS(3), 1, + sym_comment, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(382), 1, + anon_sym_const, + ACTIONS(384), 1, + anon_sym_LPAREN, + ACTIONS(386), 1, + anon_sym_fn, + ACTIONS(394), 1, + anon_sym_enum, + ACTIONS(398), 1, + anon_sym_nullable, + ACTIONS(400), 1, + anon_sym_struct, + ACTIONS(402), 1, + anon_sym_union, + ACTIONS(404), 1, + anon_sym_LBRACK, + ACTIONS(406), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(425), 1, + anon_sym_STAR, + ACTIONS(427), 1, + sym_name, + STATE(428), 1, + sym_identifier, + STATE(649), 1, + sym_fntype_attr, + STATE(653), 1, + sym_type, + ACTIONS(392), 2, + anon_sym_f32, + anon_sym_f64, + STATE(426), 2, + sym__inner_type, + sym_storage_class, + ACTIONS(388), 3, + anon_sym_rune, + anon_sym_bool, + anon_sym_void, + STATE(424), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(427), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(390), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [4624] = 7, + ACTIONS(3), 1, + sym_comment, + ACTIONS(467), 1, + anon_sym_EQ, + ACTIONS(469), 1, + anon_sym_COLON_COLON, + ACTIONS(471), 1, + anon_sym_LBRACE, + ACTIONS(465), 10, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + ACTIONS(475), 15, + anon_sym_COLON, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(473), 20, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [4688] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(362), 10, + anon_sym_PIPE, + anon_sym_i, + anon_sym_u, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(360), 38, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_f32, + anon_sym_f64, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_z, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [4744] = 22, + ACTIONS(3), 1, + sym_comment, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(382), 1, + anon_sym_const, + ACTIONS(384), 1, + anon_sym_LPAREN, + ACTIONS(386), 1, + anon_sym_fn, + ACTIONS(394), 1, + anon_sym_enum, + ACTIONS(398), 1, + anon_sym_nullable, + ACTIONS(400), 1, + anon_sym_struct, + ACTIONS(402), 1, + anon_sym_union, + ACTIONS(404), 1, + anon_sym_LBRACK, + ACTIONS(406), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(425), 1, + anon_sym_STAR, + ACTIONS(427), 1, + sym_name, + STATE(428), 1, + sym_identifier, + STATE(616), 1, + sym_type, + STATE(649), 1, + sym_fntype_attr, + ACTIONS(392), 2, + anon_sym_f32, + anon_sym_f64, + STATE(426), 2, + sym__inner_type, + sym_storage_class, + ACTIONS(388), 3, + anon_sym_rune, + anon_sym_bool, + anon_sym_void, + STATE(424), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(427), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(390), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [4838] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(268), 1, + anon_sym_DQUOTE, + STATE(204), 1, + aux_sym_string_constant_repeat1, + ACTIONS(481), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(479), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [4898] = 22, + ACTIONS(3), 1, + sym_comment, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(382), 1, + anon_sym_const, + ACTIONS(384), 1, + anon_sym_LPAREN, + ACTIONS(386), 1, + anon_sym_fn, + ACTIONS(394), 1, + anon_sym_enum, + ACTIONS(398), 1, + anon_sym_nullable, + ACTIONS(400), 1, + anon_sym_struct, + ACTIONS(402), 1, + anon_sym_union, + ACTIONS(404), 1, + anon_sym_LBRACK, + ACTIONS(406), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(425), 1, + anon_sym_STAR, + ACTIONS(427), 1, + sym_name, + STATE(428), 1, + sym_identifier, + STATE(529), 1, + sym_type, + STATE(649), 1, + sym_fntype_attr, + ACTIONS(392), 2, + anon_sym_f32, + anon_sym_f64, + STATE(426), 2, + sym__inner_type, + sym_storage_class, + ACTIONS(388), 3, + anon_sym_rune, + anon_sym_bool, + anon_sym_void, + STATE(424), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(427), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(390), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [4992] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(487), 1, + anon_sym_COLON_COLON, + ACTIONS(485), 16, + anon_sym_EQ, + anon_sym_COLON, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(483), 31, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [5050] = 22, + ACTIONS(3), 1, + sym_comment, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(382), 1, + anon_sym_const, + ACTIONS(384), 1, + anon_sym_LPAREN, + ACTIONS(386), 1, + anon_sym_fn, + ACTIONS(394), 1, + anon_sym_enum, + ACTIONS(398), 1, + anon_sym_nullable, + ACTIONS(400), 1, + anon_sym_struct, + ACTIONS(402), 1, + anon_sym_union, + ACTIONS(404), 1, + anon_sym_LBRACK, + ACTIONS(406), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(425), 1, + anon_sym_STAR, + ACTIONS(427), 1, + sym_name, + STATE(428), 1, + sym_identifier, + STATE(549), 1, + sym_type, + STATE(649), 1, + sym_fntype_attr, + ACTIONS(392), 2, + anon_sym_f32, + anon_sym_f64, + STATE(426), 2, + sym__inner_type, + sym_storage_class, + ACTIONS(388), 3, + anon_sym_rune, + anon_sym_bool, + anon_sym_void, + STATE(424), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(427), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(390), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [5144] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(490), 1, + anon_sym_COLON_COLON, + ACTIONS(492), 1, + anon_sym_LBRACE, + ACTIONS(475), 16, + anon_sym_EQ, + anon_sym_COLON, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(473), 30, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [5204] = 22, + ACTIONS(3), 1, + sym_comment, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(382), 1, + anon_sym_const, + ACTIONS(384), 1, + anon_sym_LPAREN, + ACTIONS(386), 1, + anon_sym_fn, + ACTIONS(394), 1, + anon_sym_enum, + ACTIONS(398), 1, + anon_sym_nullable, + ACTIONS(400), 1, + anon_sym_struct, + ACTIONS(402), 1, + anon_sym_union, + ACTIONS(404), 1, + anon_sym_LBRACK, + ACTIONS(406), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(425), 1, + anon_sym_STAR, + ACTIONS(427), 1, + sym_name, + STATE(428), 1, + sym_identifier, + STATE(550), 1, + sym_type, + STATE(649), 1, + sym_fntype_attr, + ACTIONS(392), 2, + anon_sym_f32, + anon_sym_f64, + STATE(426), 2, + sym__inner_type, + sym_storage_class, + ACTIONS(388), 3, + anon_sym_rune, + anon_sym_bool, + anon_sym_void, + STATE(424), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(427), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(390), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [5298] = 22, + ACTIONS(3), 1, + sym_comment, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(382), 1, + anon_sym_const, + ACTIONS(384), 1, + anon_sym_LPAREN, + ACTIONS(386), 1, + anon_sym_fn, + ACTIONS(394), 1, + anon_sym_enum, + ACTIONS(398), 1, + anon_sym_nullable, + ACTIONS(400), 1, + anon_sym_struct, + ACTIONS(402), 1, + anon_sym_union, + ACTIONS(404), 1, + anon_sym_LBRACK, + ACTIONS(406), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(425), 1, + anon_sym_STAR, + ACTIONS(427), 1, + sym_name, + STATE(428), 1, + sym_identifier, + STATE(649), 1, + sym_fntype_attr, + STATE(760), 1, + sym_type, + ACTIONS(392), 2, + anon_sym_f32, + anon_sym_f64, + STATE(426), 2, + sym__inner_type, + sym_storage_class, + ACTIONS(388), 3, + anon_sym_rune, + anon_sym_bool, + anon_sym_void, + STATE(424), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(427), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(390), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [5392] = 22, + ACTIONS(3), 1, + sym_comment, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(382), 1, + anon_sym_const, + ACTIONS(384), 1, + anon_sym_LPAREN, + ACTIONS(386), 1, + anon_sym_fn, + ACTIONS(394), 1, + anon_sym_enum, + ACTIONS(398), 1, + anon_sym_nullable, + ACTIONS(400), 1, + anon_sym_struct, + ACTIONS(402), 1, + anon_sym_union, + ACTIONS(404), 1, + anon_sym_LBRACK, + ACTIONS(406), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(425), 1, + anon_sym_STAR, + ACTIONS(427), 1, + sym_name, + STATE(428), 1, + sym_identifier, + STATE(629), 1, + sym_type, + STATE(649), 1, + sym_fntype_attr, + ACTIONS(392), 2, + anon_sym_f32, + anon_sym_f64, + STATE(426), 2, + sym__inner_type, + sym_storage_class, + ACTIONS(388), 3, + anon_sym_rune, + anon_sym_bool, + anon_sym_void, + STATE(424), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(427), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(390), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [5486] = 22, + ACTIONS(3), 1, + sym_comment, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(382), 1, + anon_sym_const, + ACTIONS(384), 1, + anon_sym_LPAREN, + ACTIONS(386), 1, + anon_sym_fn, + ACTIONS(394), 1, + anon_sym_enum, + ACTIONS(398), 1, + anon_sym_nullable, + ACTIONS(400), 1, + anon_sym_struct, + ACTIONS(402), 1, + anon_sym_union, + ACTIONS(404), 1, + anon_sym_LBRACK, + ACTIONS(406), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(425), 1, + anon_sym_STAR, + ACTIONS(427), 1, + sym_name, + STATE(428), 1, + sym_identifier, + STATE(649), 1, + sym_fntype_attr, + STATE(681), 1, + sym_type, + ACTIONS(392), 2, + anon_sym_f32, + anon_sym_f64, + STATE(426), 2, + sym__inner_type, + sym_storage_class, + ACTIONS(388), 3, + anon_sym_rune, + anon_sym_bool, + anon_sym_void, + STATE(424), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(427), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(390), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [5580] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(498), 1, + anon_sym_DQUOTE, + STATE(204), 1, + aux_sym_string_constant_repeat1, + ACTIONS(496), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(494), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [5640] = 21, + ACTIONS(3), 1, + sym_comment, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(382), 1, + anon_sym_const, + ACTIONS(384), 1, + anon_sym_LPAREN, + ACTIONS(386), 1, + anon_sym_fn, + ACTIONS(394), 1, + anon_sym_enum, + ACTIONS(398), 1, + anon_sym_nullable, + ACTIONS(400), 1, + anon_sym_struct, + ACTIONS(402), 1, + anon_sym_union, + ACTIONS(404), 1, + anon_sym_LBRACK, + ACTIONS(406), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(425), 1, + anon_sym_STAR, + ACTIONS(427), 1, + sym_name, + STATE(428), 1, + sym_identifier, + STATE(649), 1, + sym_fntype_attr, + ACTIONS(392), 2, + anon_sym_f32, + anon_sym_f64, + STATE(452), 2, + sym__inner_type, + sym_storage_class, + ACTIONS(388), 3, + anon_sym_rune, + anon_sym_bool, + anon_sym_void, + STATE(424), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(427), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(390), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [5731] = 21, + ACTIONS(3), 1, + sym_comment, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(437), 1, + anon_sym_const, + ACTIONS(439), 1, + anon_sym_LPAREN, + ACTIONS(441), 1, + anon_sym_fn, + ACTIONS(449), 1, + anon_sym_enum, + ACTIONS(451), 1, + anon_sym_STAR, + ACTIONS(453), 1, + anon_sym_nullable, + ACTIONS(455), 1, + anon_sym_struct, + ACTIONS(457), 1, + anon_sym_union, + ACTIONS(459), 1, + anon_sym_LBRACK, + ACTIONS(461), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(463), 1, + sym_name, + STATE(326), 1, + sym_identifier, + STATE(737), 1, + sym_fntype_attr, + ACTIONS(447), 2, + anon_sym_f32, + anon_sym_f64, + STATE(334), 2, + sym__inner_type, + sym_storage_class, + ACTIONS(443), 3, + anon_sym_rune, + anon_sym_bool, + anon_sym_void, + STATE(327), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(342), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(445), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [5822] = 21, + ACTIONS(3), 1, + sym_comment, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(437), 1, + anon_sym_const, + ACTIONS(439), 1, + anon_sym_LPAREN, + ACTIONS(441), 1, + anon_sym_fn, + ACTIONS(449), 1, + anon_sym_enum, + ACTIONS(451), 1, + anon_sym_STAR, + ACTIONS(453), 1, + anon_sym_nullable, + ACTIONS(455), 1, + anon_sym_struct, + ACTIONS(457), 1, + anon_sym_union, + ACTIONS(459), 1, + anon_sym_LBRACK, + ACTIONS(461), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(463), 1, + sym_name, + STATE(326), 1, + sym_identifier, + STATE(737), 1, + sym_fntype_attr, + ACTIONS(447), 2, + anon_sym_f32, + anon_sym_f64, + STATE(337), 2, + sym__inner_type, + sym_storage_class, + ACTIONS(443), 3, + anon_sym_rune, + anon_sym_bool, + anon_sym_void, + STATE(327), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(342), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(445), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [5913] = 21, + ACTIONS(3), 1, + sym_comment, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(437), 1, + anon_sym_const, + ACTIONS(439), 1, + anon_sym_LPAREN, + ACTIONS(441), 1, + anon_sym_fn, + ACTIONS(449), 1, + anon_sym_enum, + ACTIONS(451), 1, + anon_sym_STAR, + ACTIONS(453), 1, + anon_sym_nullable, + ACTIONS(455), 1, + anon_sym_struct, + ACTIONS(457), 1, + anon_sym_union, + ACTIONS(459), 1, + anon_sym_LBRACK, + ACTIONS(461), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(463), 1, + sym_name, + STATE(326), 1, + sym_identifier, + STATE(737), 1, + sym_fntype_attr, + ACTIONS(447), 2, + anon_sym_f32, + anon_sym_f64, + STATE(331), 2, + sym__inner_type, + sym_storage_class, + ACTIONS(443), 3, + anon_sym_rune, + anon_sym_bool, + anon_sym_void, + STATE(327), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(342), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(445), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [6004] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(503), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(501), 32, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_DQUOTE, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [6059] = 21, + ACTIONS(3), 1, + sym_comment, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(437), 1, + anon_sym_const, + ACTIONS(439), 1, + anon_sym_LPAREN, + ACTIONS(441), 1, + anon_sym_fn, + ACTIONS(449), 1, + anon_sym_enum, + ACTIONS(451), 1, + anon_sym_STAR, + ACTIONS(453), 1, + anon_sym_nullable, + ACTIONS(455), 1, + anon_sym_struct, + ACTIONS(457), 1, + anon_sym_union, + ACTIONS(459), 1, + anon_sym_LBRACK, + ACTIONS(461), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(463), 1, + sym_name, + STATE(326), 1, + sym_identifier, + STATE(737), 1, + sym_fntype_attr, + ACTIONS(447), 2, + anon_sym_f32, + anon_sym_f64, + STATE(329), 2, + sym__inner_type, + sym_storage_class, + ACTIONS(443), 3, + anon_sym_rune, + anon_sym_bool, + anon_sym_void, + STATE(327), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(342), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(445), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [6150] = 21, + ACTIONS(3), 1, + sym_comment, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(437), 1, + anon_sym_const, + ACTIONS(439), 1, + anon_sym_LPAREN, + ACTIONS(441), 1, + anon_sym_fn, + ACTIONS(449), 1, + anon_sym_enum, + ACTIONS(451), 1, + anon_sym_STAR, + ACTIONS(453), 1, + anon_sym_nullable, + ACTIONS(455), 1, + anon_sym_struct, + ACTIONS(457), 1, + anon_sym_union, + ACTIONS(459), 1, + anon_sym_LBRACK, + ACTIONS(461), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(463), 1, + sym_name, + STATE(326), 1, + sym_identifier, + STATE(737), 1, + sym_fntype_attr, + ACTIONS(447), 2, + anon_sym_f32, + anon_sym_f64, + STATE(339), 2, + sym__inner_type, + sym_storage_class, + ACTIONS(443), 3, + anon_sym_rune, + anon_sym_bool, + anon_sym_void, + STATE(327), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(342), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(445), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [6241] = 6, + ACTIONS(3), 1, + sym_comment, + STATE(320), 1, + sym_integer_suffix, + ACTIONS(375), 2, + anon_sym_i, + anon_sym_u, + ACTIONS(354), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(369), 9, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_z, + ACTIONS(352), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [6302] = 21, + ACTIONS(3), 1, + sym_comment, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(382), 1, + anon_sym_const, + ACTIONS(384), 1, + anon_sym_LPAREN, + ACTIONS(386), 1, + anon_sym_fn, + ACTIONS(394), 1, + anon_sym_enum, + ACTIONS(398), 1, + anon_sym_nullable, + ACTIONS(400), 1, + anon_sym_struct, + ACTIONS(402), 1, + anon_sym_union, + ACTIONS(404), 1, + anon_sym_LBRACK, + ACTIONS(406), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(425), 1, + anon_sym_STAR, + ACTIONS(427), 1, + sym_name, + STATE(428), 1, + sym_identifier, + STATE(649), 1, + sym_fntype_attr, + ACTIONS(392), 2, + anon_sym_f32, + anon_sym_f64, + STATE(447), 2, + sym__inner_type, + sym_storage_class, + ACTIONS(388), 3, + anon_sym_rune, + anon_sym_bool, + anon_sym_void, + STATE(424), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(427), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(390), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [6393] = 21, + ACTIONS(3), 1, + sym_comment, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(382), 1, + anon_sym_const, + ACTIONS(384), 1, + anon_sym_LPAREN, + ACTIONS(386), 1, + anon_sym_fn, + ACTIONS(394), 1, + anon_sym_enum, + ACTIONS(398), 1, + anon_sym_nullable, + ACTIONS(400), 1, + anon_sym_struct, + ACTIONS(402), 1, + anon_sym_union, + ACTIONS(404), 1, + anon_sym_LBRACK, + ACTIONS(406), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(425), 1, + anon_sym_STAR, + ACTIONS(427), 1, + sym_name, + STATE(428), 1, + sym_identifier, + STATE(649), 1, + sym_fntype_attr, + ACTIONS(392), 2, + anon_sym_f32, + anon_sym_f64, + STATE(450), 2, + sym__inner_type, + sym_storage_class, + ACTIONS(388), 3, + anon_sym_rune, + anon_sym_bool, + anon_sym_void, + STATE(424), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(427), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(390), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [6484] = 21, + ACTIONS(3), 1, + sym_comment, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(437), 1, + anon_sym_const, + ACTIONS(439), 1, + anon_sym_LPAREN, + ACTIONS(441), 1, + anon_sym_fn, + ACTIONS(449), 1, + anon_sym_enum, + ACTIONS(451), 1, + anon_sym_STAR, + ACTIONS(453), 1, + anon_sym_nullable, + ACTIONS(455), 1, + anon_sym_struct, + ACTIONS(457), 1, + anon_sym_union, + ACTIONS(459), 1, + anon_sym_LBRACK, + ACTIONS(461), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(463), 1, + sym_name, + STATE(326), 1, + sym_identifier, + STATE(737), 1, + sym_fntype_attr, + ACTIONS(447), 2, + anon_sym_f32, + anon_sym_f64, + STATE(323), 2, + sym__inner_type, + sym_storage_class, + ACTIONS(443), 3, + anon_sym_rune, + anon_sym_bool, + anon_sym_void, + STATE(327), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(342), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(445), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [6575] = 21, + ACTIONS(3), 1, + sym_comment, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(382), 1, + anon_sym_const, + ACTIONS(384), 1, + anon_sym_LPAREN, + ACTIONS(386), 1, + anon_sym_fn, + ACTIONS(394), 1, + anon_sym_enum, + ACTIONS(398), 1, + anon_sym_nullable, + ACTIONS(400), 1, + anon_sym_struct, + ACTIONS(402), 1, + anon_sym_union, + ACTIONS(404), 1, + anon_sym_LBRACK, + ACTIONS(406), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(425), 1, + anon_sym_STAR, + ACTIONS(427), 1, + sym_name, + STATE(428), 1, + sym_identifier, + STATE(649), 1, + sym_fntype_attr, + ACTIONS(392), 2, + anon_sym_f32, + anon_sym_f64, + STATE(453), 2, + sym__inner_type, + sym_storage_class, + ACTIONS(388), 3, + anon_sym_rune, + anon_sym_bool, + anon_sym_void, + STATE(424), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(427), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(390), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [6666] = 21, + ACTIONS(3), 1, + sym_comment, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(382), 1, + anon_sym_const, + ACTIONS(384), 1, + anon_sym_LPAREN, + ACTIONS(386), 1, + anon_sym_fn, + ACTIONS(394), 1, + anon_sym_enum, + ACTIONS(398), 1, + anon_sym_nullable, + ACTIONS(400), 1, + anon_sym_struct, + ACTIONS(402), 1, + anon_sym_union, + ACTIONS(404), 1, + anon_sym_LBRACK, + ACTIONS(406), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(425), 1, + anon_sym_STAR, + ACTIONS(427), 1, + sym_name, + STATE(428), 1, + sym_identifier, + STATE(649), 1, + sym_fntype_attr, + ACTIONS(392), 2, + anon_sym_f32, + anon_sym_f64, + STATE(418), 2, + sym__inner_type, + sym_storage_class, + ACTIONS(388), 3, + anon_sym_rune, + anon_sym_bool, + anon_sym_void, + STATE(424), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(427), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(390), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [6757] = 21, + ACTIONS(3), 1, + sym_comment, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(382), 1, + anon_sym_const, + ACTIONS(384), 1, + anon_sym_LPAREN, + ACTIONS(386), 1, + anon_sym_fn, + ACTIONS(394), 1, + anon_sym_enum, + ACTIONS(398), 1, + anon_sym_nullable, + ACTIONS(400), 1, + anon_sym_struct, + ACTIONS(402), 1, + anon_sym_union, + ACTIONS(404), 1, + anon_sym_LBRACK, + ACTIONS(406), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(425), 1, + anon_sym_STAR, + ACTIONS(427), 1, + sym_name, + STATE(428), 1, + sym_identifier, + STATE(649), 1, + sym_fntype_attr, + ACTIONS(392), 2, + anon_sym_f32, + anon_sym_f64, + STATE(435), 2, + sym__inner_type, + sym_storage_class, + ACTIONS(388), 3, + anon_sym_rune, + anon_sym_bool, + anon_sym_void, + STATE(424), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(427), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(390), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [6848] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(507), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(505), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [6902] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(511), 1, + anon_sym_DOT, + ACTIONS(509), 3, + anon_sym_LPAREN, + anon_sym_LBRACK, + anon_sym_QMARK, + ACTIONS(467), 14, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(465), 28, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [6960] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(431), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(429), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [7014] = 7, + ACTIONS(3), 1, + sym_comment, + ACTIONS(517), 1, + anon_sym_LPAREN, + ACTIONS(519), 1, + anon_sym_LBRACK, + ACTIONS(521), 1, + anon_sym_DOT, + ACTIONS(523), 1, + anon_sym_QMARK, + ACTIONS(515), 14, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(513), 28, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [7076] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(527), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(525), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [7130] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(531), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(529), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [7184] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(535), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(533), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [7238] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(539), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(537), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [7292] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(511), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(509), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [7346] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(543), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(541), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [7400] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(547), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(545), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [7454] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(551), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(549), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [7508] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(555), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(553), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [7562] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(559), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(557), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [7616] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(563), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(561), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [7670] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(567), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(565), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [7724] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(571), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(569), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [7778] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(575), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(573), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [7832] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(579), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(577), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [7886] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(583), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(581), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [7940] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(587), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(585), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [7994] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(591), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(589), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [8048] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(595), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(593), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [8102] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(599), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(597), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [8156] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(603), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(601), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [8210] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(607), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(605), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [8264] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(611), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(609), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [8318] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(475), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(473), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [8372] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(416), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(414), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [8426] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(615), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(613), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [8480] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(619), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(617), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [8534] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(623), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(621), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [8588] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(627), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(625), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [8642] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(631), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(629), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [8696] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(467), 1, + anon_sym_EQ, + ACTIONS(465), 10, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + ACTIONS(511), 14, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(509), 21, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [8754] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(635), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(633), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [8808] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(639), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(637), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [8862] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(643), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(641), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [8916] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(647), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(645), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [8970] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(354), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(352), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [9024] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(651), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(649), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [9078] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(655), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(653), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [9132] = 20, + ACTIONS(3), 1, + sym_comment, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(384), 1, + anon_sym_LPAREN, + ACTIONS(386), 1, + anon_sym_fn, + ACTIONS(394), 1, + anon_sym_enum, + ACTIONS(398), 1, + anon_sym_nullable, + ACTIONS(400), 1, + anon_sym_struct, + ACTIONS(402), 1, + anon_sym_union, + ACTIONS(404), 1, + anon_sym_LBRACK, + ACTIONS(406), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(425), 1, + anon_sym_STAR, + ACTIONS(427), 1, + sym_name, + STATE(428), 1, + sym_identifier, + STATE(432), 1, + sym_storage_class, + STATE(649), 1, + sym_fntype_attr, + ACTIONS(392), 2, + anon_sym_f32, + anon_sym_f64, + ACTIONS(388), 3, + anon_sym_rune, + anon_sym_bool, + anon_sym_void, + STATE(424), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(427), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(390), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [9219] = 20, + ACTIONS(3), 1, + sym_comment, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(439), 1, + anon_sym_LPAREN, + ACTIONS(441), 1, + anon_sym_fn, + ACTIONS(449), 1, + anon_sym_enum, + ACTIONS(451), 1, + anon_sym_STAR, + ACTIONS(453), 1, + anon_sym_nullable, + ACTIONS(455), 1, + anon_sym_struct, + ACTIONS(457), 1, + anon_sym_union, + ACTIONS(459), 1, + anon_sym_LBRACK, + ACTIONS(461), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(463), 1, + sym_name, + STATE(326), 1, + sym_identifier, + STATE(345), 1, + sym_storage_class, + STATE(737), 1, + sym_fntype_attr, + ACTIONS(447), 2, + anon_sym_f32, + anon_sym_f64, + ACTIONS(443), 3, + anon_sym_rune, + anon_sym_bool, + anon_sym_void, + STATE(327), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(342), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(445), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [9306] = 6, + ACTIONS(3), 1, + sym_comment, + ACTIONS(659), 1, + anon_sym_EQ, + STATE(44), 1, + sym_assignment_op, + ACTIONS(663), 10, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + ACTIONS(661), 13, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(657), 18, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [9363] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(667), 14, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(665), 28, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [9413] = 6, + ACTIONS(3), 1, + sym_comment, + ACTIONS(659), 1, + anon_sym_EQ, + STATE(51), 1, + sym_assignment_op, + ACTIONS(663), 10, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + ACTIONS(661), 13, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(657), 17, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_EQ_GT, + [9469] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(661), 14, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(657), 28, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [9519] = 7, + ACTIONS(3), 1, + sym_comment, + ACTIONS(373), 1, + anon_sym_e, + STATE(270), 1, + sym_exponent, + STATE(283), 1, + sym_floating_suffix, + ACTIONS(371), 2, + anon_sym_f32, + anon_sym_f64, + ACTIONS(416), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(414), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [9575] = 6, + ACTIONS(3), 1, + sym_comment, + ACTIONS(659), 1, + anon_sym_EQ, + STATE(98), 1, + sym_assignment_op, + ACTIONS(663), 10, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + ACTIONS(661), 12, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(657), 15, + anon_sym_SEMI, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + [9628] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(435), 10, + anon_sym_COLON, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(433), 28, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [9674] = 5, + ACTIONS(3), 1, + sym_comment, + STATE(311), 1, + sym_floating_suffix, + ACTIONS(371), 2, + anon_sym_f32, + anon_sym_f64, + ACTIONS(431), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(429), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [9724] = 6, + ACTIONS(3), 1, + sym_comment, + ACTIONS(659), 1, + anon_sym_EQ, + STATE(76), 1, + sym_assignment_op, + ACTIONS(663), 10, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + ACTIONS(661), 12, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(657), 14, + anon_sym_SEMI, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + [9776] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(59), 1, + anon_sym_DQUOTE, + STATE(275), 1, + aux_sym_string_constant_repeat1, + ACTIONS(481), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(479), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [9825] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(669), 1, + anon_sym_COLON_COLON, + ACTIONS(485), 9, + anon_sym_COLON, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(483), 27, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [9872] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(469), 1, + anon_sym_COLON_COLON, + ACTIONS(471), 1, + anon_sym_LBRACE, + ACTIONS(475), 9, + anon_sym_COLON, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(473), 26, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [9921] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(672), 1, + anon_sym_DQUOTE, + STATE(275), 1, + aux_sym_string_constant_repeat1, + ACTIONS(496), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(494), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [9970] = 7, + ACTIONS(3), 1, + sym_comment, + ACTIONS(469), 1, + anon_sym_COLON_COLON, + ACTIONS(471), 1, + anon_sym_LBRACE, + ACTIONS(475), 1, + anon_sym_DOT, + ACTIONS(473), 3, + anon_sym_LPAREN, + anon_sym_LBRACK, + anon_sym_QMARK, + ACTIONS(467), 8, + anon_sym_COLON, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(465), 23, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [10023] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(503), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(501), 28, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_DQUOTE, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [10067] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(675), 1, + anon_sym_EQ, + ACTIONS(511), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(509), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [10113] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(599), 9, + anon_sym_EQ, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(597), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [10157] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(579), 9, + anon_sym_EQ, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(577), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [10201] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(527), 9, + anon_sym_EQ, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(525), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [10245] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(547), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(545), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [10288] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(431), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(429), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [10331] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(531), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(529), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [10374] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(655), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(653), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [10417] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(677), 1, + anon_sym_EQ, + ACTIONS(511), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(509), 26, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_EQ_GT, + [10462] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(571), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(569), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [10505] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(627), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(625), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [10548] = 7, + ACTIONS(3), 1, + sym_comment, + ACTIONS(521), 1, + anon_sym_DOT, + ACTIONS(679), 1, + anon_sym_LPAREN, + ACTIONS(681), 1, + anon_sym_LBRACK, + ACTIONS(683), 1, + anon_sym_QMARK, + ACTIONS(515), 7, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(513), 24, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [10599] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(551), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(549), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [10642] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(591), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(589), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [10685] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(563), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(561), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [10728] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(651), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(649), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [10771] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(543), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(541), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [10814] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(507), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(505), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [10857] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(607), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(605), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [10900] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(416), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(414), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [10943] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(354), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(352), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [10986] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(647), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(645), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [11029] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(539), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(537), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [11072] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(475), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(473), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [11115] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(595), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(593), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [11158] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(511), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(509), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [11201] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(535), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(533), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [11244] = 7, + ACTIONS(3), 1, + sym_comment, + ACTIONS(679), 1, + anon_sym_LPAREN, + ACTIONS(683), 1, + anon_sym_QMARK, + ACTIONS(685), 1, + anon_sym_LBRACK, + ACTIONS(687), 1, + anon_sym_DOT, + ACTIONS(515), 7, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(513), 24, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [11295] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(623), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(621), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [11338] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(615), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(613), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [11381] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(555), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(553), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [11424] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(559), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(557), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [11467] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(567), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(565), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [11510] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(575), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(573), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [11553] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(643), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(641), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [11596] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(511), 1, + anon_sym_DOT, + ACTIONS(509), 3, + anon_sym_LPAREN, + anon_sym_LBRACK, + anon_sym_QMARK, + ACTIONS(467), 7, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(465), 24, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [11643] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(583), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(581), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [11686] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(619), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(617), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [11729] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(587), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(585), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [11772] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(639), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(637), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [11815] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(603), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(601), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [11858] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(611), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(609), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [11901] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(631), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(629), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [11944] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(635), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(633), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [11987] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(689), 1, + anon_sym_COLON_COLON, + ACTIONS(485), 9, + anon_sym_COLON, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(483), 23, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [12030] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(693), 8, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(691), 24, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [12070] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(697), 8, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(695), 24, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [12110] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(701), 8, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(699), 24, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [12150] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(705), 8, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(703), 24, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [12190] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(709), 8, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(707), 24, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [12230] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(711), 1, + anon_sym_EQ, + ACTIONS(511), 7, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(509), 24, + anon_sym_SEMI, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + [12272] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(715), 8, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(713), 24, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [12312] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(719), 1, + anon_sym_BANG, + ACTIONS(721), 7, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(717), 24, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [12354] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(725), 8, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(723), 24, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [12394] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(729), 8, + anon_sym_EQ, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(727), 24, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [12434] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(733), 8, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(731), 24, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [12474] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(737), 8, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(735), 24, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [12514] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(741), 8, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(739), 24, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [12554] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(745), 8, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(743), 24, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [12594] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(749), 8, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(747), 24, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [12634] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(753), 8, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(751), 24, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [12674] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(757), 8, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(755), 24, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [12714] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(761), 8, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(759), 24, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [12754] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(765), 8, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(763), 24, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [12794] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(769), 8, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(767), 24, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [12834] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(773), 8, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(771), 24, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [12874] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(777), 8, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(775), 24, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [12914] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(781), 8, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(779), 24, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [12954] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(785), 8, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(783), 24, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [12994] = 6, + ACTIONS(3), 1, + sym_comment, + ACTIONS(789), 1, + anon_sym_COLON, + ACTIONS(793), 1, + anon_sym_as, + ACTIONS(795), 1, + anon_sym_is, + ACTIONS(791), 7, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(787), 21, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [13039] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(799), 7, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(797), 24, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [13078] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(661), 7, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(657), 24, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [13117] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(667), 7, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(665), 24, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [13156] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(803), 7, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(801), 24, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [13195] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(807), 7, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(805), 24, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [13234] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(811), 7, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(809), 24, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [13273] = 6, + ACTIONS(3), 1, + sym_comment, + ACTIONS(789), 1, + anon_sym_COLON, + ACTIONS(793), 1, + anon_sym_as, + ACTIONS(795), 1, + anon_sym_is, + ACTIONS(815), 7, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(813), 21, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [13318] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(817), 1, + anon_sym_EQ, + ACTIONS(511), 7, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(509), 23, + anon_sym_SEMI, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + [13359] = 6, + ACTIONS(3), 1, + sym_comment, + ACTIONS(825), 1, + anon_sym_SLASH, + ACTIONS(821), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(827), 2, + anon_sym_LT_LT, + anon_sym_GT_GT, + ACTIONS(823), 6, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(819), 17, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [13401] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(825), 1, + anon_sym_SLASH, + ACTIONS(821), 2, + anon_sym_STAR, + anon_sym_PERCENT, + ACTIONS(831), 6, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(829), 17, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [13439] = 4, + ACTIONS(3), 1, + sym_comment, + STATE(212), 1, + sym_hex_digits, + STATE(119), 2, + sym_hex_digit, + aux_sym_hex_digits_repeat1, + ACTIONS(236), 22, + anon_sym_0, + anon_sym_1, + anon_sym_2, + anon_sym_3, + anon_sym_4, + anon_sym_5, + anon_sym_6, + anon_sym_7, + anon_sym_8, + anon_sym_9, + anon_sym_A, + anon_sym_B, + anon_sym_C, + anon_sym_D, + anon_sym_E, + anon_sym_F, + anon_sym_a, + anon_sym_b, + anon_sym_c, + anon_sym_d, + anon_sym_e, + anon_sym_f, + [13474] = 4, + ACTIONS(3), 1, + sym_comment, + STATE(159), 1, + sym_hex_digits, + STATE(106), 2, + sym_hex_digit, + aux_sym_hex_digits_repeat1, + ACTIONS(209), 22, + anon_sym_0, + anon_sym_1, + anon_sym_2, + anon_sym_3, + anon_sym_4, + anon_sym_5, + anon_sym_6, + anon_sym_7, + anon_sym_8, + anon_sym_9, + anon_sym_A, + anon_sym_B, + anon_sym_C, + anon_sym_D, + anon_sym_E, + anon_sym_F, + anon_sym_a, + anon_sym_b, + anon_sym_c, + anon_sym_d, + anon_sym_e, + anon_sym_f, + [13509] = 6, + ACTIONS(3), 1, + sym_comment, + ACTIONS(789), 1, + anon_sym_COLON, + ACTIONS(793), 1, + anon_sym_as, + ACTIONS(795), 1, + anon_sym_is, + ACTIONS(835), 6, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(833), 15, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [13547] = 17, + ACTIONS(3), 1, + sym_comment, + ACTIONS(9), 1, + anon_sym_export, + ACTIONS(13), 1, + anon_sym_ATsymbol, + ACTIONS(15), 1, + anon_sym_def, + ACTIONS(17), 1, + anon_sym_type, + ACTIONS(19), 1, + anon_sym_fn, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(837), 1, + ts_builtin_sym_end, + STATE(364), 1, + aux_sym_declarations_repeat1, + STATE(724), 1, + sym_declarations, + STATE(770), 1, + sym_fndec_attrs, + STATE(772), 1, + sym_declaration, + ACTIONS(11), 2, + anon_sym_let, + anon_sym_const, + STATE(408), 2, + sym_fndec_attr, + aux_sym_fndec_attrs_repeat1, + STATE(469), 2, + sym_decl_attr, + sym_fntype_attr, + ACTIONS(21), 3, + anon_sym_ATfini, + anon_sym_ATinit, + anon_sym_ATtest, + STATE(771), 4, + sym_global_declaration, + sym_constant_declaration, + sym_type_declaration, + sym_function_declaration, + [13607] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(843), 2, + anon_sym_PLUS, + anon_sym_DASH, + ACTIONS(841), 6, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(839), 15, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [13640] = 16, + ACTIONS(3), 1, + sym_comment, + ACTIONS(845), 1, + ts_builtin_sym_end, + ACTIONS(847), 1, + anon_sym_export, + ACTIONS(853), 1, + anon_sym_ATsymbol, + ACTIONS(856), 1, + anon_sym_def, + ACTIONS(859), 1, + anon_sym_type, + ACTIONS(862), 1, + anon_sym_fn, + ACTIONS(868), 1, + anon_sym_ATnoreturn, + STATE(363), 1, + aux_sym_declarations_repeat1, + STATE(770), 1, + sym_fndec_attrs, + STATE(772), 1, + sym_declaration, + ACTIONS(850), 2, + anon_sym_let, + anon_sym_const, + STATE(408), 2, + sym_fndec_attr, + aux_sym_fndec_attrs_repeat1, + STATE(469), 2, + sym_decl_attr, + sym_fntype_attr, + ACTIONS(865), 3, + anon_sym_ATfini, + anon_sym_ATinit, + anon_sym_ATtest, + STATE(771), 4, + sym_global_declaration, + sym_constant_declaration, + sym_type_declaration, + sym_function_declaration, + [13697] = 16, + ACTIONS(3), 1, + sym_comment, + ACTIONS(9), 1, + anon_sym_export, + ACTIONS(13), 1, + anon_sym_ATsymbol, + ACTIONS(15), 1, + anon_sym_def, + ACTIONS(17), 1, + anon_sym_type, + ACTIONS(19), 1, + anon_sym_fn, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(871), 1, + ts_builtin_sym_end, + STATE(363), 1, + aux_sym_declarations_repeat1, + STATE(770), 1, + sym_fndec_attrs, + STATE(772), 1, + sym_declaration, + ACTIONS(11), 2, + anon_sym_let, + anon_sym_const, + STATE(408), 2, + sym_fndec_attr, + aux_sym_fndec_attrs_repeat1, + STATE(469), 2, + sym_decl_attr, + sym_fntype_attr, + ACTIONS(21), 3, + anon_sym_ATfini, + anon_sym_ATinit, + anon_sym_ATtest, + STATE(771), 4, + sym_global_declaration, + sym_constant_declaration, + sym_type_declaration, + sym_function_declaration, + [13754] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(877), 1, + anon_sym_AMP, + ACTIONS(875), 5, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(873), 15, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [13785] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(881), 6, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(879), 15, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [13814] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(877), 1, + anon_sym_AMP, + ACTIONS(885), 5, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(883), 15, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [13845] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(889), 6, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(887), 15, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [13874] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(895), 1, + anon_sym_CARET, + ACTIONS(893), 4, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_LT, + anon_sym_GT, + ACTIONS(891), 15, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [13904] = 13, + ACTIONS(3), 1, + sym_comment, + ACTIONS(13), 1, + anon_sym_ATsymbol, + ACTIONS(15), 1, + anon_sym_def, + ACTIONS(17), 1, + anon_sym_type, + ACTIONS(19), 1, + anon_sym_fn, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + STATE(759), 1, + sym_declaration, + STATE(770), 1, + sym_fndec_attrs, + ACTIONS(11), 2, + anon_sym_let, + anon_sym_const, + STATE(408), 2, + sym_fndec_attr, + aux_sym_fndec_attrs_repeat1, + STATE(469), 2, + sym_decl_attr, + sym_fntype_attr, + ACTIONS(21), 3, + anon_sym_ATfini, + anon_sym_ATinit, + anon_sym_ATtest, + STATE(771), 4, + sym_global_declaration, + sym_constant_declaration, + sym_type_declaration, + sym_function_declaration, + [13952] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(895), 1, + anon_sym_CARET, + ACTIONS(899), 4, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_LT, + anon_sym_GT, + ACTIONS(897), 15, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [13982] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(903), 1, + anon_sym_PIPE, + ACTIONS(905), 3, + anon_sym_DOT_DOT, + anon_sym_LT, + anon_sym_GT, + ACTIONS(901), 15, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [14011] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(903), 1, + anon_sym_PIPE, + ACTIONS(909), 3, + anon_sym_DOT_DOT, + anon_sym_LT, + anon_sym_GT, + ACTIONS(907), 15, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [14040] = 10, + ACTIONS(3), 1, + sym_comment, + ACTIONS(258), 1, + anon_sym_0x, + ACTIONS(260), 1, + anon_sym_0o, + ACTIONS(262), 1, + anon_sym_0b, + ACTIONS(264), 1, + anon_sym_0, + ACTIONS(911), 1, + sym_name, + STATE(153), 1, + sym_decimal_digits, + STATE(240), 1, + sym_integer_constant, + STATE(114), 2, + sym_decimal_digit, + aux_sym_decimal_digits_repeat1, + ACTIONS(221), 9, + anon_sym_1, + anon_sym_2, + anon_sym_3, + anon_sym_4, + anon_sym_5, + anon_sym_6, + anon_sym_7, + anon_sym_8, + anon_sym_9, + [14080] = 10, + ACTIONS(3), 1, + sym_comment, + ACTIONS(47), 1, + anon_sym_0x, + ACTIONS(49), 1, + anon_sym_0o, + ACTIONS(51), 1, + anon_sym_0b, + ACTIONS(53), 1, + anon_sym_0, + ACTIONS(913), 1, + sym_name, + STATE(175), 1, + sym_decimal_digits, + STATE(291), 1, + sym_integer_constant, + STATE(146), 2, + sym_decimal_digit, + aux_sym_decimal_digits_repeat1, + ACTIONS(55), 9, + anon_sym_1, + anon_sym_2, + anon_sym_3, + anon_sym_4, + anon_sym_5, + anon_sym_6, + anon_sym_7, + anon_sym_8, + anon_sym_9, + [14120] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(917), 1, + anon_sym_DOT_DOT, + ACTIONS(919), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(921), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(915), 13, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [14150] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(925), 1, + anon_sym_DOT_DOT, + ACTIONS(919), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(921), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(923), 13, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [14180] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(435), 3, + anon_sym_EQ, + anon_sym_COLON, + anon_sym_DOT, + ACTIONS(433), 13, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_LBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_EQ_GT, + [14204] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(7), 1, + anon_sym_use, + STATE(382), 2, + sym_use_statement, + aux_sym_imports_repeat1, + ACTIONS(927), 12, + ts_builtin_sym_end, + anon_sym_export, + anon_sym_let, + anon_sym_const, + anon_sym_ATsymbol, + anon_sym_def, + anon_sym_type, + anon_sym_fn, + anon_sym_ATfini, + anon_sym_ATinit, + anon_sym_ATtest, + anon_sym_ATnoreturn, + [14229] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(390), 1, + anon_sym_uint, + ACTIONS(929), 1, + anon_sym_LBRACE, + STATE(660), 1, + sym_integer_type, + ACTIONS(931), 12, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [14256] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(390), 1, + anon_sym_uint, + ACTIONS(933), 1, + anon_sym_LBRACE, + STATE(790), 1, + sym_integer_type, + ACTIONS(931), 12, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [14283] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(937), 1, + anon_sym_use, + STATE(382), 2, + sym_use_statement, + aux_sym_imports_repeat1, + ACTIONS(935), 12, + ts_builtin_sym_end, + anon_sym_export, + anon_sym_let, + anon_sym_const, + anon_sym_ATsymbol, + anon_sym_def, + anon_sym_type, + anon_sym_fn, + anon_sym_ATfini, + anon_sym_ATinit, + anon_sym_ATtest, + anon_sym_ATnoreturn, + [14308] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(942), 1, + anon_sym_DOT_DOT, + ACTIONS(944), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(940), 11, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [14332] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(948), 1, + anon_sym_DOT_DOT, + ACTIONS(944), 2, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + ACTIONS(946), 11, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [14356] = 4, + ACTIONS(3), 1, + sym_comment, + STATE(157), 1, + sym_decimal_digits, + STATE(114), 2, + sym_decimal_digit, + aux_sym_decimal_digits_repeat1, + ACTIONS(221), 10, + anon_sym_0, + anon_sym_1, + anon_sym_2, + anon_sym_3, + anon_sym_4, + anon_sym_5, + anon_sym_6, + anon_sym_7, + anon_sym_8, + anon_sym_9, + [14379] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(950), 13, + ts_builtin_sym_end, + anon_sym_use, + anon_sym_export, + anon_sym_let, + anon_sym_const, + anon_sym_ATsymbol, + anon_sym_def, + anon_sym_type, + anon_sym_fn, + anon_sym_ATfini, + anon_sym_ATinit, + anon_sym_ATtest, + anon_sym_ATnoreturn, + [14398] = 4, + ACTIONS(3), 1, + sym_comment, + STATE(166), 1, + sym_decimal_digits, + STATE(114), 2, + sym_decimal_digit, + aux_sym_decimal_digits_repeat1, + ACTIONS(221), 10, + anon_sym_0, + anon_sym_1, + anon_sym_2, + anon_sym_3, + anon_sym_4, + anon_sym_5, + anon_sym_6, + anon_sym_7, + anon_sym_8, + anon_sym_9, + [14421] = 4, + ACTIONS(3), 1, + sym_comment, + STATE(193), 1, + sym_decimal_digits, + STATE(146), 2, + sym_decimal_digit, + aux_sym_decimal_digits_repeat1, + ACTIONS(55), 10, + anon_sym_0, + anon_sym_1, + anon_sym_2, + anon_sym_3, + anon_sym_4, + anon_sym_5, + anon_sym_6, + anon_sym_7, + anon_sym_8, + anon_sym_9, + [14444] = 4, + ACTIONS(3), 1, + sym_comment, + STATE(267), 1, + sym_decimal_digits, + STATE(146), 2, + sym_decimal_digit, + aux_sym_decimal_digits_repeat1, + ACTIONS(55), 10, + anon_sym_0, + anon_sym_1, + anon_sym_2, + anon_sym_3, + anon_sym_4, + anon_sym_5, + anon_sym_6, + anon_sym_7, + anon_sym_8, + anon_sym_9, + [14467] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(952), 13, + ts_builtin_sym_end, + anon_sym_use, + anon_sym_export, + anon_sym_let, + anon_sym_const, + anon_sym_ATsymbol, + anon_sym_def, + anon_sym_type, + anon_sym_fn, + anon_sym_ATfini, + anon_sym_ATinit, + anon_sym_ATtest, + anon_sym_ATnoreturn, + [14486] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(954), 1, + anon_sym_COLON_COLON, + ACTIONS(485), 2, + anon_sym_EQ, + anon_sym_COLON, + ACTIONS(483), 10, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT_DOT, + anon_sym_EQ_GT, + [14509] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(956), 13, + ts_builtin_sym_end, + anon_sym_use, + anon_sym_export, + anon_sym_let, + anon_sym_const, + anon_sym_ATsymbol, + anon_sym_def, + anon_sym_type, + anon_sym_fn, + anon_sym_ATfini, + anon_sym_ATinit, + anon_sym_ATtest, + anon_sym_ATnoreturn, + [14528] = 3, + ACTIONS(3), 1, + sym_comment, + STATE(52), 1, + sym_assignment_op, + ACTIONS(663), 11, + anon_sym_EQ, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [14548] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(960), 1, + anon_sym_DOT_DOT, + ACTIONS(962), 1, + anon_sym_AMP_AMP, + ACTIONS(958), 10, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [14570] = 3, + ACTIONS(3), 1, + sym_comment, + STATE(45), 1, + sym_assignment_op, + ACTIONS(663), 11, + anon_sym_EQ, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [14590] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(845), 12, + ts_builtin_sym_end, + anon_sym_export, + anon_sym_let, + anon_sym_const, + anon_sym_ATsymbol, + anon_sym_def, + anon_sym_type, + anon_sym_fn, + anon_sym_ATfini, + anon_sym_ATinit, + anon_sym_ATtest, + anon_sym_ATnoreturn, + [14608] = 3, + ACTIONS(3), 1, + sym_comment, + STATE(46), 1, + sym_assignment_op, + ACTIONS(663), 11, + anon_sym_EQ, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [14628] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(962), 1, + anon_sym_AMP_AMP, + ACTIONS(966), 1, + anon_sym_DOT_DOT, + ACTIONS(964), 10, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [14650] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(968), 12, + ts_builtin_sym_end, + anon_sym_export, + anon_sym_let, + anon_sym_const, + anon_sym_ATsymbol, + anon_sym_def, + anon_sym_type, + anon_sym_fn, + anon_sym_ATfini, + anon_sym_ATinit, + anon_sym_ATtest, + anon_sym_ATnoreturn, + [14668] = 3, + ACTIONS(3), 1, + sym_comment, + STATE(55), 1, + sym_assignment_op, + ACTIONS(663), 11, + anon_sym_EQ, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [14688] = 4, + ACTIONS(3), 1, + sym_comment, + STATE(212), 1, + sym_octal_digits, + STATE(160), 2, + sym_octal_digit, + aux_sym_octal_digits_repeat1, + ACTIONS(364), 8, + anon_sym_0, + anon_sym_1, + anon_sym_2, + anon_sym_3, + anon_sym_4, + anon_sym_5, + anon_sym_6, + anon_sym_7, + [14709] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(972), 1, + anon_sym_DOT_DOT, + ACTIONS(974), 1, + anon_sym_CARET_CARET, + ACTIONS(970), 9, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [14730] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(974), 1, + anon_sym_CARET_CARET, + ACTIONS(978), 1, + anon_sym_DOT_DOT, + ACTIONS(976), 9, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [14751] = 10, + ACTIONS(3), 1, + sym_comment, + ACTIONS(400), 1, + anon_sym_struct, + ACTIONS(402), 1, + anon_sym_union, + ACTIONS(980), 1, + anon_sym_RBRACE, + ACTIONS(982), 1, + anon_sym_AToffset, + ACTIONS(984), 1, + sym_name, + STATE(467), 1, + sym_offset_specifier, + STATE(565), 1, + sym_struct_union_field, + STATE(780), 1, + sym_struct_union_fields, + STATE(582), 3, + sym_struct_type, + sym_union_type, + sym_identifier, + [14784] = 4, + ACTIONS(3), 1, + sym_comment, + STATE(159), 1, + sym_octal_digits, + STATE(137), 2, + sym_octal_digit, + aux_sym_octal_digits_repeat1, + ACTIONS(311), 8, + anon_sym_0, + anon_sym_1, + anon_sym_2, + anon_sym_3, + anon_sym_4, + anon_sym_5, + anon_sym_6, + anon_sym_7, + [14805] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(31), 1, + anon_sym_COLON, + ACTIONS(79), 1, + anon_sym_DOT_DOT, + STATE(443), 1, + sym_label, + ACTIONS(25), 8, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_else, + anon_sym_EQ_GT, + [14828] = 9, + ACTIONS(3), 1, + sym_comment, + ACTIONS(400), 1, + anon_sym_struct, + ACTIONS(402), 1, + anon_sym_union, + ACTIONS(982), 1, + anon_sym_AToffset, + ACTIONS(984), 1, + sym_name, + STATE(467), 1, + sym_offset_specifier, + STATE(565), 1, + sym_struct_union_field, + STATE(758), 1, + sym_struct_union_fields, + STATE(582), 3, + sym_struct_type, + sym_union_type, + sym_identifier, + [14858] = 7, + ACTIONS(3), 1, + sym_comment, + ACTIONS(13), 1, + anon_sym_ATsymbol, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(986), 1, + anon_sym_fn, + STATE(414), 2, + sym_fndec_attr, + aux_sym_fndec_attrs_repeat1, + STATE(469), 2, + sym_decl_attr, + sym_fntype_attr, + ACTIONS(21), 3, + anon_sym_ATfini, + anon_sym_ATinit, + anon_sym_ATtest, + [14884] = 9, + ACTIONS(3), 1, + sym_comment, + ACTIONS(400), 1, + anon_sym_struct, + ACTIONS(402), 1, + anon_sym_union, + ACTIONS(982), 1, + anon_sym_AToffset, + ACTIONS(984), 1, + sym_name, + STATE(467), 1, + sym_offset_specifier, + STATE(565), 1, + sym_struct_union_field, + STATE(666), 1, + sym_struct_union_fields, + STATE(582), 3, + sym_struct_type, + sym_union_type, + sym_identifier, + [14914] = 9, + ACTIONS(3), 1, + sym_comment, + ACTIONS(400), 1, + anon_sym_struct, + ACTIONS(402), 1, + anon_sym_union, + ACTIONS(982), 1, + anon_sym_AToffset, + ACTIONS(984), 1, + sym_name, + STATE(467), 1, + sym_offset_specifier, + STATE(565), 1, + sym_struct_union_field, + STATE(665), 1, + sym_struct_union_fields, + STATE(582), 3, + sym_struct_type, + sym_union_type, + sym_identifier, + [14944] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(701), 1, + anon_sym_EQ, + ACTIONS(699), 9, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT_DOT, + anon_sym_EQ_GT, + [14962] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(990), 1, + anon_sym_DOT_DOT, + ACTIONS(992), 1, + anon_sym_PIPE_PIPE, + ACTIONS(988), 8, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_else, + anon_sym_EQ_GT, + [14982] = 9, + ACTIONS(3), 1, + sym_comment, + ACTIONS(400), 1, + anon_sym_struct, + ACTIONS(402), 1, + anon_sym_union, + ACTIONS(982), 1, + anon_sym_AToffset, + ACTIONS(984), 1, + sym_name, + STATE(467), 1, + sym_offset_specifier, + STATE(565), 1, + sym_struct_union_field, + STATE(764), 1, + sym_struct_union_fields, + STATE(582), 3, + sym_struct_type, + sym_union_type, + sym_identifier, + [15012] = 7, + ACTIONS(3), 1, + sym_comment, + ACTIONS(994), 1, + anon_sym_ATsymbol, + ACTIONS(997), 1, + anon_sym_fn, + ACTIONS(1002), 1, + anon_sym_ATnoreturn, + STATE(414), 2, + sym_fndec_attr, + aux_sym_fndec_attrs_repeat1, + STATE(469), 2, + sym_decl_attr, + sym_fntype_attr, + ACTIONS(999), 3, + anon_sym_ATfini, + anon_sym_ATinit, + anon_sym_ATtest, + [15038] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1007), 1, + anon_sym_DOT_DOT, + ACTIONS(1005), 9, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_else, + anon_sym_for, + anon_sym_EQ_GT, + [15056] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1011), 1, + anon_sym_DOT_DOT, + ACTIONS(1009), 8, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_else, + anon_sym_EQ_GT, + [15073] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(733), 1, + anon_sym_EQ, + ACTIONS(731), 8, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT_DOT, + anon_sym_EQ_GT, + [15090] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(693), 1, + anon_sym_EQ, + ACTIONS(691), 8, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT_DOT, + anon_sym_EQ_GT, + [15107] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1015), 1, + anon_sym_DOT_DOT, + ACTIONS(1017), 1, + anon_sym_else, + ACTIONS(1013), 7, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_EQ_GT, + [15126] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(777), 1, + anon_sym_EQ, + ACTIONS(775), 8, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT_DOT, + anon_sym_EQ_GT, + [15143] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(741), 1, + anon_sym_EQ, + ACTIONS(739), 8, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT_DOT, + anon_sym_EQ_GT, + [15160] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1022), 1, + anon_sym_COMMA, + ACTIONS(1025), 1, + anon_sym_DOT_DOT, + ACTIONS(1020), 7, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_else, + anon_sym_EQ_GT, + [15179] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(745), 1, + anon_sym_EQ, + ACTIONS(743), 8, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT_DOT, + anon_sym_EQ_GT, + [15196] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(709), 1, + anon_sym_EQ, + ACTIONS(707), 8, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT_DOT, + anon_sym_EQ_GT, + [15213] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(990), 1, + anon_sym_DOT_DOT, + ACTIONS(988), 8, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_else, + anon_sym_EQ_GT, + [15230] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(721), 1, + anon_sym_EQ, + ACTIONS(1027), 1, + anon_sym_BANG, + ACTIONS(717), 7, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_PIPE, + anon_sym_DOT_DOT_DOT, + anon_sym_EQ_GT, + [15249] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(769), 1, + anon_sym_EQ, + ACTIONS(767), 8, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT_DOT, + anon_sym_EQ_GT, + [15266] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(705), 1, + anon_sym_EQ, + ACTIONS(703), 8, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT_DOT, + anon_sym_EQ_GT, + [15283] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1031), 1, + anon_sym_DOT_DOT, + ACTIONS(1029), 8, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_else, + anon_sym_EQ_GT, + [15300] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1035), 1, + anon_sym_DOT_DOT, + ACTIONS(1033), 8, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_else, + anon_sym_EQ_GT, + [15317] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1039), 1, + anon_sym_DOT_DOT, + ACTIONS(1037), 8, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_else, + anon_sym_EQ_GT, + [15334] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(781), 1, + anon_sym_EQ, + ACTIONS(779), 8, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT_DOT, + anon_sym_EQ_GT, + [15351] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1015), 1, + anon_sym_DOT_DOT, + ACTIONS(1041), 1, + anon_sym_else, + ACTIONS(1013), 7, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_EQ_GT, + [15370] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(773), 1, + anon_sym_EQ, + ACTIONS(771), 8, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT_DOT, + anon_sym_EQ_GT, + [15387] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(725), 1, + anon_sym_EQ, + ACTIONS(723), 8, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT_DOT, + anon_sym_EQ_GT, + [15404] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1045), 1, + anon_sym_DOT_DOT, + ACTIONS(1043), 8, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_else, + anon_sym_EQ_GT, + [15421] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1049), 1, + anon_sym_DOT_DOT, + ACTIONS(1047), 8, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_else, + anon_sym_EQ_GT, + [15438] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1053), 1, + anon_sym_DOT_DOT, + ACTIONS(1051), 8, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_else, + anon_sym_EQ_GT, + [15455] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1057), 1, + anon_sym_DOT_DOT, + ACTIONS(1055), 8, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_else, + anon_sym_EQ_GT, + [15472] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1061), 1, + anon_sym_DOT_DOT, + ACTIONS(1059), 8, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_else, + anon_sym_EQ_GT, + [15489] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1065), 1, + anon_sym_DOT_DOT, + ACTIONS(1063), 8, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_else, + anon_sym_EQ_GT, + [15506] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1069), 1, + anon_sym_DOT_DOT, + ACTIONS(1067), 8, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_else, + anon_sym_EQ_GT, + [15523] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1073), 1, + anon_sym_DOT_DOT, + ACTIONS(1071), 8, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_else, + anon_sym_EQ_GT, + [15540] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1077), 1, + anon_sym_DOT_DOT, + ACTIONS(1075), 8, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_else, + anon_sym_EQ_GT, + [15557] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1081), 1, + anon_sym_DOT_DOT, + ACTIONS(1079), 8, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_else, + anon_sym_EQ_GT, + [15574] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1085), 1, + anon_sym_DOT_DOT, + ACTIONS(1083), 8, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_else, + anon_sym_EQ_GT, + [15591] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(749), 1, + anon_sym_EQ, + ACTIONS(747), 8, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT_DOT, + anon_sym_EQ_GT, + [15608] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(785), 1, + anon_sym_EQ, + ACTIONS(783), 8, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT_DOT, + anon_sym_EQ_GT, + [15625] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(765), 1, + anon_sym_EQ, + ACTIONS(763), 8, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT_DOT, + anon_sym_EQ_GT, + [15642] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(737), 1, + anon_sym_EQ, + ACTIONS(735), 8, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT_DOT, + anon_sym_EQ_GT, + [15659] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1089), 1, + anon_sym_DOT_DOT, + ACTIONS(1087), 8, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_else, + anon_sym_EQ_GT, + [15676] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(715), 1, + anon_sym_EQ, + ACTIONS(713), 8, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT_DOT, + anon_sym_EQ_GT, + [15693] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(757), 1, + anon_sym_EQ, + ACTIONS(755), 8, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT_DOT, + anon_sym_EQ_GT, + [15710] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(697), 1, + anon_sym_EQ, + ACTIONS(695), 8, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT_DOT, + anon_sym_EQ_GT, + [15727] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(761), 1, + anon_sym_EQ, + ACTIONS(759), 8, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT_DOT, + anon_sym_EQ_GT, + [15744] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(753), 1, + anon_sym_EQ, + ACTIONS(751), 8, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT_DOT, + anon_sym_EQ_GT, + [15761] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1091), 1, + anon_sym_COLON_COLON, + ACTIONS(483), 7, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_QMARK, + [15777] = 9, + ACTIONS(3), 1, + sym_comment, + ACTIONS(43), 1, + anon_sym_struct, + ACTIONS(1094), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(1096), 1, + sym_name, + STATE(602), 1, + sym_struct_literal, + STATE(606), 1, + sym_field_value, + STATE(632), 1, + sym_field_values, + STATE(704), 1, + sym_identifier, + STATE(816), 1, + sym_struct_initializer, + [15805] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1025), 1, + anon_sym_DOT_DOT, + ACTIONS(1098), 1, + anon_sym_COMMA, + ACTIONS(1020), 6, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_EQ_GT, + [15823] = 9, + ACTIONS(3), 1, + sym_comment, + ACTIONS(43), 1, + anon_sym_struct, + ACTIONS(1094), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(1096), 1, + sym_name, + STATE(602), 1, + sym_struct_literal, + STATE(606), 1, + sym_field_value, + STATE(632), 1, + sym_field_values, + STATE(693), 1, + sym_struct_initializer, + STATE(704), 1, + sym_identifier, + [15851] = 7, + ACTIONS(1101), 1, + anon_sym_BSLASH, + ACTIONS(1104), 1, + anon_sym_DQUOTE, + ACTIONS(1106), 1, + aux_sym_string_char_token1, + ACTIONS(1109), 1, + sym_comment, + STATE(523), 1, + sym_escape_sequence, + STATE(524), 1, + sym_named_escape, + STATE(461), 2, + sym_string_char, + aux_sym_string_chars_repeat1, + [15874] = 7, + ACTIONS(1109), 1, + sym_comment, + ACTIONS(1111), 1, + anon_sym_BSLASH, + ACTIONS(1113), 1, + aux_sym_string_char_token1, + STATE(523), 1, + sym_escape_sequence, + STATE(524), 1, + sym_named_escape, + STATE(651), 1, + sym_string_chars, + STATE(464), 2, + sym_string_char, + aux_sym_string_chars_repeat1, + [15897] = 7, + ACTIONS(1109), 1, + sym_comment, + ACTIONS(1111), 1, + anon_sym_BSLASH, + ACTIONS(1113), 1, + aux_sym_string_char_token1, + STATE(523), 1, + sym_escape_sequence, + STATE(524), 1, + sym_named_escape, + STATE(643), 1, + sym_string_chars, + STATE(464), 2, + sym_string_char, + aux_sym_string_chars_repeat1, + [15920] = 7, + ACTIONS(1109), 1, + sym_comment, + ACTIONS(1111), 1, + anon_sym_BSLASH, + ACTIONS(1113), 1, + aux_sym_string_char_token1, + ACTIONS(1115), 1, + anon_sym_DQUOTE, + STATE(523), 1, + sym_escape_sequence, + STATE(524), 1, + sym_named_escape, + STATE(461), 2, + sym_string_char, + aux_sym_string_chars_repeat1, + [15943] = 8, + ACTIONS(3), 1, + sym_comment, + ACTIONS(43), 1, + anon_sym_struct, + ACTIONS(1096), 1, + sym_name, + ACTIONS(1117), 1, + anon_sym_RBRACE, + ACTIONS(1119), 1, + anon_sym_DOT_DOT_DOT, + STATE(597), 1, + sym_field_value, + STATE(602), 1, + sym_struct_literal, + STATE(704), 1, + sym_identifier, + [15968] = 7, + ACTIONS(3), 1, + sym_comment, + ACTIONS(43), 1, + anon_sym_struct, + ACTIONS(1096), 1, + sym_name, + ACTIONS(1121), 1, + anon_sym_RBRACE, + STATE(597), 1, + sym_field_value, + STATE(602), 1, + sym_struct_literal, + STATE(704), 1, + sym_identifier, + [15990] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(400), 1, + anon_sym_struct, + ACTIONS(402), 1, + anon_sym_union, + ACTIONS(1123), 1, + sym_name, + STATE(558), 3, + sym_struct_type, + sym_union_type, + sym_identifier, + [16008] = 7, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1125), 1, + anon_sym_ATsymbol, + ACTIONS(1127), 1, + sym_name, + STATE(563), 1, + sym_decl_attr, + STATE(587), 1, + sym_global_binding, + STATE(754), 1, + sym_identifier, + STATE(757), 1, + sym_global_bindings, + [16030] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1129), 6, + anon_sym_ATsymbol, + anon_sym_fn, + anon_sym_ATfini, + anon_sym_ATinit, + anon_sym_ATtest, + anon_sym_ATnoreturn, + [16042] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1131), 1, + anon_sym_COMMA, + ACTIONS(1020), 5, + anon_sym_SEMI, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT, + anon_sym_else, + [16056] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1133), 6, + anon_sym_ATsymbol, + anon_sym_fn, + anon_sym_ATfini, + anon_sym_ATinit, + anon_sym_ATtest, + anon_sym_ATnoreturn, + [16068] = 7, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1125), 1, + anon_sym_ATsymbol, + ACTIONS(1127), 1, + sym_name, + STATE(563), 1, + sym_decl_attr, + STATE(587), 1, + sym_global_binding, + STATE(654), 1, + sym_global_bindings, + STATE(754), 1, + sym_identifier, + [16090] = 7, + ACTIONS(3), 1, + sym_comment, + ACTIONS(43), 1, + anon_sym_struct, + ACTIONS(1096), 1, + sym_name, + STATE(602), 1, + sym_struct_literal, + STATE(606), 1, + sym_field_value, + STATE(627), 1, + sym_field_values, + STATE(704), 1, + sym_identifier, + [16112] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1135), 6, + anon_sym_ATsymbol, + anon_sym_fn, + anon_sym_ATfini, + anon_sym_ATinit, + anon_sym_ATtest, + anon_sym_ATnoreturn, + [16124] = 6, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1137), 1, + anon_sym_RPAREN, + STATE(527), 1, + sym_parameters, + STATE(528), 1, + sym_parameter, + STATE(656), 1, + sym_parameter_list, + ACTIONS(1139), 2, + anon_sym__, + sym_name, + [16144] = 7, + ACTIONS(3), 1, + sym_comment, + ACTIONS(43), 1, + anon_sym_struct, + ACTIONS(1096), 1, + sym_name, + ACTIONS(1141), 1, + anon_sym_RBRACE, + STATE(597), 1, + sym_field_value, + STATE(602), 1, + sym_struct_literal, + STATE(704), 1, + sym_identifier, + [16166] = 6, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1143), 1, + anon_sym_RPAREN, + STATE(527), 1, + sym_parameters, + STATE(528), 1, + sym_parameter, + STATE(644), 1, + sym_parameter_list, + ACTIONS(1139), 2, + anon_sym__, + sym_name, + [16186] = 7, + ACTIONS(3), 1, + sym_comment, + ACTIONS(43), 1, + anon_sym_struct, + ACTIONS(1096), 1, + sym_name, + STATE(569), 1, + sym_field_values, + STATE(602), 1, + sym_struct_literal, + STATE(606), 1, + sym_field_value, + STATE(704), 1, + sym_identifier, + [16208] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1145), 1, + anon_sym_else, + ACTIONS(1013), 4, + anon_sym_SEMI, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT, + [16221] = 4, + ACTIONS(3), 1, + sym_comment, + STATE(212), 1, + sym_binary_digits, + ACTIONS(421), 2, + anon_sym_0, + anon_sym_1, + STATE(168), 2, + sym_binary_digit, + aux_sym_binary_digits_repeat1, + [16236] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1148), 1, + anon_sym_RPAREN, + ACTIONS(1150), 1, + anon_sym_DOT_DOT_DOT, + STATE(521), 1, + sym_parameter, + ACTIONS(1139), 2, + anon_sym__, + sym_name, + [16253] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1152), 1, + anon_sym_COMMA, + ACTIONS(1020), 4, + anon_sym_SEMI, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT, + [16266] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1154), 1, + anon_sym_RPAREN, + ACTIONS(509), 4, + anon_sym_LPAREN, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_QMARK, + [16279] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1156), 1, + anon_sym_RPAREN, + ACTIONS(509), 4, + anon_sym_LPAREN, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_QMARK, + [16292] = 6, + ACTIONS(1109), 1, + sym_comment, + ACTIONS(1158), 1, + aux_sym_rune_token1, + ACTIONS(1160), 1, + anon_sym_BSLASH, + STATE(670), 1, + sym_rune, + STATE(701), 1, + sym_named_escape, + STATE(784), 1, + sym_escape_sequence, + [16311] = 4, + ACTIONS(3), 1, + sym_comment, + STATE(159), 1, + sym_binary_digits, + ACTIONS(340), 2, + anon_sym_0, + anon_sym_1, + STATE(143), 2, + sym_binary_digit, + aux_sym_binary_digits_repeat1, + [16326] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1162), 1, + anon_sym_RPAREN, + ACTIONS(509), 4, + anon_sym_LPAREN, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_QMARK, + [16339] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1164), 1, + anon_sym_RPAREN, + ACTIONS(509), 4, + anon_sym_LPAREN, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_QMARK, + [16352] = 6, + ACTIONS(1109), 1, + sym_comment, + ACTIONS(1158), 1, + aux_sym_rune_token1, + ACTIONS(1160), 1, + anon_sym_BSLASH, + STATE(701), 1, + sym_named_escape, + STATE(784), 1, + sym_escape_sequence, + STATE(785), 1, + sym_rune, + [16371] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1166), 1, + anon_sym_else, + ACTIONS(1013), 4, + anon_sym_SEMI, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT, + [16384] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(59), 1, + anon_sym_DQUOTE, + ACTIONS(1168), 1, + anon_sym_RPAREN, + STATE(272), 1, + aux_sym_string_constant_repeat1, + STATE(762), 1, + sym_string_constant, + [16400] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(954), 1, + anon_sym_COLON_COLON, + ACTIONS(1170), 1, + anon_sym_COLON, + ACTIONS(483), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [16414] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1172), 1, + sym_name, + STATE(416), 1, + sym_bindings, + STATE(422), 1, + sym_binding, + STATE(575), 1, + sym_binding_names, + [16430] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1172), 1, + sym_name, + STATE(422), 1, + sym_binding, + STATE(440), 1, + sym_bindings, + STATE(575), 1, + sym_binding_names, + [16446] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1174), 1, + sym_name, + STATE(440), 1, + sym_bindings, + STATE(482), 1, + sym_binding, + STATE(631), 1, + sym_binding_names, + [16462] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(483), 1, + anon_sym_LBRACE, + ACTIONS(954), 1, + anon_sym_COLON_COLON, + ACTIONS(1176), 1, + anon_sym_EQ, + ACTIONS(1178), 1, + anon_sym_COLON, + [16478] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1172), 1, + sym_name, + STATE(436), 1, + sym_bindings, + STATE(470), 1, + sym_binding, + STATE(575), 1, + sym_binding_names, + [16494] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1172), 1, + sym_name, + STATE(416), 1, + sym_bindings, + STATE(470), 1, + sym_binding, + STATE(575), 1, + sym_binding_names, + [16510] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(59), 1, + anon_sym_DQUOTE, + ACTIONS(1180), 1, + anon_sym_RPAREN, + STATE(272), 1, + aux_sym_string_constant_repeat1, + STATE(687), 1, + sym_string_constant, + [16526] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(679), 1, + anon_sym_LPAREN, + ACTIONS(681), 1, + anon_sym_LBRACK, + ACTIONS(683), 1, + anon_sym_QMARK, + ACTIONS(1182), 1, + anon_sym_DOT, + [16542] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1172), 1, + sym_name, + STATE(440), 1, + sym_bindings, + STATE(470), 1, + sym_binding, + STATE(575), 1, + sym_binding_names, + [16558] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(679), 1, + anon_sym_LPAREN, + ACTIONS(683), 1, + anon_sym_QMARK, + ACTIONS(685), 1, + anon_sym_LBRACK, + ACTIONS(1184), 1, + anon_sym_DOT, + [16574] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(954), 1, + anon_sym_COLON_COLON, + ACTIONS(1186), 1, + anon_sym_COLON, + ACTIONS(483), 2, + anon_sym_BANG, + anon_sym_EQ_GT, + [16588] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1174), 1, + sym_name, + STATE(440), 1, + sym_bindings, + STATE(459), 1, + sym_binding, + STATE(631), 1, + sym_binding_names, + [16604] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1174), 1, + sym_name, + STATE(416), 1, + sym_bindings, + STATE(482), 1, + sym_binding, + STATE(631), 1, + sym_binding_names, + [16620] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1188), 1, + anon_sym_RBRACE, + ACTIONS(1190), 1, + sym_name, + STATE(617), 1, + sym_enum_value, + STATE(783), 1, + sym_enum_values, + [16636] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1174), 1, + sym_name, + STATE(436), 1, + sym_bindings, + STATE(459), 1, + sym_binding, + STATE(631), 1, + sym_binding_names, + [16652] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1172), 1, + sym_name, + STATE(422), 1, + sym_binding, + STATE(436), 1, + sym_bindings, + STATE(575), 1, + sym_binding_names, + [16668] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(954), 1, + anon_sym_COLON_COLON, + ACTIONS(1192), 1, + anon_sym_COLON, + ACTIONS(483), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [16682] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1174), 1, + sym_name, + STATE(416), 1, + sym_bindings, + STATE(459), 1, + sym_binding, + STATE(631), 1, + sym_binding_names, + [16698] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1127), 1, + sym_name, + STATE(618), 1, + sym_constant_binding, + STATE(652), 1, + sym_constant_bindings, + STATE(742), 1, + sym_identifier, + [16714] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1127), 1, + sym_name, + STATE(618), 1, + sym_constant_binding, + STATE(742), 1, + sym_identifier, + STATE(747), 1, + sym_constant_bindings, + [16730] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1127), 1, + sym_name, + ACTIONS(1194), 1, + anon_sym_SEMI, + STATE(692), 1, + sym_type_bindings, + STATE(736), 1, + sym_identifier, + [16746] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1174), 1, + sym_name, + STATE(436), 1, + sym_bindings, + STATE(482), 1, + sym_binding, + STATE(631), 1, + sym_binding_names, + [16762] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1198), 1, + anon_sym_assert, + ACTIONS(1196), 2, + anon_sym_let, + anon_sym_const, + [16773] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1200), 1, + anon_sym_RPAREN, + ACTIONS(1202), 1, + anon_sym_PIPE, + STATE(516), 1, + aux_sym_tagged_types_repeat1, + [16786] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1205), 1, + anon_sym_COMMA, + ACTIONS(1207), 1, + anon_sym_RBRACK, + ACTIONS(1209), 1, + anon_sym_DOT_DOT_DOT, + [16799] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(59), 1, + anon_sym_DQUOTE, + STATE(272), 1, + aux_sym_string_constant_repeat1, + STATE(711), 1, + sym_string_constant, + [16812] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(59), 1, + anon_sym_DQUOTE, + STATE(272), 1, + aux_sym_string_constant_repeat1, + STATE(707), 1, + sym_string_constant, + [16825] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1213), 1, + anon_sym_EQ, + ACTIONS(1211), 2, + anon_sym_SEMI, + anon_sym_COMMA, + [16836] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1215), 3, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_DOT_DOT_DOT, + [16845] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(59), 1, + anon_sym_DQUOTE, + STATE(272), 1, + aux_sym_string_constant_repeat1, + STATE(748), 1, + sym_string_constant, + [16858] = 2, + ACTIONS(1109), 1, + sym_comment, + ACTIONS(1217), 3, + anon_sym_BSLASH, + anon_sym_DQUOTE, + aux_sym_string_char_token1, + [16867] = 2, + ACTIONS(1109), 1, + sym_comment, + ACTIONS(1219), 3, + anon_sym_BSLASH, + anon_sym_DQUOTE, + aux_sym_string_char_token1, + [16876] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1221), 1, + anon_sym_COMMA, + ACTIONS(1223), 1, + anon_sym_RPAREN, + ACTIONS(1225), 1, + anon_sym_DOT_DOT_DOT, + [16889] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1190), 1, + sym_name, + STATE(617), 1, + sym_enum_value, + STATE(664), 1, + sym_enum_values, + [16902] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1227), 1, + anon_sym_COMMA, + ACTIONS(1229), 1, + anon_sym_RPAREN, + ACTIONS(1231), 1, + anon_sym_DOT_DOT_DOT, + [16915] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1233), 3, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_DOT_DOT_DOT, + [16924] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1237), 1, + anon_sym_EQ, + ACTIONS(1235), 2, + anon_sym_SEMI, + anon_sym_COMMA, + [16935] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1239), 1, + anon_sym_EQ, + ACTIONS(1241), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [16946] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(483), 1, + anon_sym_SEMI, + ACTIONS(1091), 1, + anon_sym_COLON_COLON, + ACTIONS(1243), 1, + anon_sym_EQ, + [16959] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1190), 1, + sym_name, + STATE(617), 1, + sym_enum_value, + STATE(739), 1, + sym_enum_values, + [16972] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(59), 1, + anon_sym_DQUOTE, + STATE(272), 1, + aux_sym_string_constant_repeat1, + STATE(642), 1, + sym_string_constant, + [16985] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1190), 1, + sym_name, + STATE(617), 1, + sym_enum_value, + STATE(691), 1, + sym_enum_values, + [16998] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1198), 1, + anon_sym_assert, + ACTIONS(1245), 2, + anon_sym_let, + anon_sym_const, + [17009] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1247), 1, + anon_sym_RBRACE, + ACTIONS(1249), 1, + sym_name, + STATE(671), 1, + sym_name_list, + [17022] = 2, + ACTIONS(1109), 1, + sym_comment, + ACTIONS(1251), 3, + anon_sym_BSLASH, + anon_sym_DQUOTE, + aux_sym_string_char_token1, + [17031] = 2, + ACTIONS(1109), 1, + sym_comment, + ACTIONS(1253), 3, + anon_sym_BSLASH, + anon_sym_DQUOTE, + aux_sym_string_char_token1, + [17040] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1257), 1, + anon_sym_COMMA, + ACTIONS(1255), 2, + anon_sym_EQ, + anon_sym_COLON, + [17051] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1127), 1, + sym_name, + STATE(736), 1, + sym_identifier, + STATE(741), 1, + sym_type_bindings, + [17064] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1257), 1, + anon_sym_COMMA, + ACTIONS(1259), 1, + anon_sym_EQ, + ACTIONS(1261), 1, + anon_sym_COLON, + [17077] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(59), 1, + anon_sym_DQUOTE, + STATE(272), 1, + aux_sym_string_constant_repeat1, + STATE(732), 1, + sym_string_constant, + [17090] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1198), 1, + anon_sym_assert, + ACTIONS(1263), 2, + anon_sym_let, + anon_sym_const, + [17101] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1198), 1, + anon_sym_assert, + ACTIONS(1265), 2, + anon_sym_let, + anon_sym_const, + [17112] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1257), 1, + anon_sym_COMMA, + ACTIONS(1267), 1, + anon_sym_EQ, + ACTIONS(1269), 1, + anon_sym_COLON, + [17125] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1271), 1, + anon_sym_RPAREN, + ACTIONS(1273), 1, + anon_sym_PIPE, + STATE(516), 1, + aux_sym_tagged_types_repeat1, + [17138] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1190), 1, + sym_name, + STATE(617), 1, + sym_enum_value, + STATE(680), 1, + sym_enum_values, + [17151] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(59), 1, + anon_sym_DQUOTE, + STATE(272), 1, + aux_sym_string_constant_repeat1, + STATE(696), 1, + sym_string_constant, + [17164] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1273), 1, + anon_sym_PIPE, + ACTIONS(1275), 1, + anon_sym_RPAREN, + STATE(546), 1, + aux_sym_tagged_types_repeat1, + [17177] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1277), 3, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_DOT_DOT_DOT, + [17186] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1279), 3, + anon_sym_struct, + anon_sym_union, + sym_name, + [17195] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1281), 1, + anon_sym_RBRACE, + ACTIONS(1283), 1, + anon_sym_COMMA, + [17205] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1285), 2, + anon_sym_SEMI, + anon_sym_COMMA, + [17213] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1287), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [17221] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1289), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [17229] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1291), 1, + anon_sym_RBRACK, + ACTIONS(1293), 1, + anon_sym_DOT_DOT, + [17239] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1295), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [17247] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1297), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [17255] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1200), 2, + anon_sym_RPAREN, + anon_sym_PIPE, + [17263] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1299), 1, + sym_name, + STATE(598), 1, + sym_identifier, + [17273] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1301), 1, + sym_name, + STATE(177), 1, + sym_identifier, + [17283] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1127), 1, + sym_name, + STATE(572), 1, + sym_identifier, + [17293] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1127), 1, + sym_name, + STATE(703), 1, + sym_identifier, + [17303] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1303), 1, + anon_sym_COMMA, + ACTIONS(1305), 1, + anon_sym_RPAREN, + [17313] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1307), 1, + anon_sym_RBRACE, + ACTIONS(1309), 1, + anon_sym_COMMA, + [17323] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1164), 1, + anon_sym_RPAREN, + ACTIONS(1311), 1, + anon_sym_COMMA, + [17333] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1313), 1, + anon_sym_COMMA, + ACTIONS(1315), 1, + anon_sym_RPAREN, + [17343] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1317), 2, + anon_sym_SEMI, + anon_sym_COMMA, + [17351] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1319), 1, + anon_sym_RBRACE, + ACTIONS(1321), 1, + anon_sym_COMMA, + [17361] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1323), 1, + anon_sym_SEMI, + ACTIONS(1325), 1, + anon_sym_EQ, + [17371] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1327), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [17379] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1329), 1, + anon_sym_LPAREN, + STATE(611), 1, + sym_prototype, + [17389] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1127), 1, + sym_name, + STATE(588), 1, + sym_identifier, + [17399] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1331), 1, + anon_sym_SEMI, + ACTIONS(1333), 1, + anon_sym_RPAREN, + [17409] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1267), 1, + anon_sym_EQ, + ACTIONS(1269), 1, + anon_sym_COLON, + [17419] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1335), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [17427] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(988), 1, + anon_sym_RPAREN, + ACTIONS(1337), 1, + anon_sym_SEMI, + [17437] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1340), 1, + anon_sym_COMMA, + ACTIONS(1342), 1, + anon_sym_EQ_GT, + [17447] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1344), 1, + anon_sym_RBRACE, + ACTIONS(1346), 1, + anon_sym_COMMA, + [17457] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1348), 1, + anon_sym_LPAREN, + STATE(433), 1, + sym_conditional_branch, + [17467] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1350), 1, + anon_sym_COMMA, + ACTIONS(1352), 1, + anon_sym_RPAREN, + [17477] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1354), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [17485] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1348), 1, + anon_sym_LPAREN, + STATE(419), 1, + sym_conditional_branch, + [17495] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1291), 1, + anon_sym_RBRACK, + ACTIONS(1356), 1, + anon_sym_DOT_DOT, + [17505] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1358), 1, + sym_name, + STATE(269), 1, + sym_identifier, + [17515] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1127), 1, + sym_name, + STATE(673), 1, + sym_identifier, + [17525] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1360), 1, + anon_sym_SEMI, + ACTIONS(1362), 1, + anon_sym_COMMA, + [17535] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1329), 1, + anon_sym_LPAREN, + STATE(570), 1, + sym_prototype, + [17545] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1255), 2, + anon_sym_EQ, + anon_sym_COLON, + [17553] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1364), 1, + anon_sym_COMMA, + ACTIONS(1366), 1, + anon_sym_RPAREN, + [17563] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1154), 1, + anon_sym_RPAREN, + ACTIONS(1368), 1, + anon_sym_COMMA, + [17573] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1293), 1, + anon_sym_DOT_DOT, + ACTIONS(1370), 1, + anon_sym_RBRACK, + [17583] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1329), 1, + anon_sym_LPAREN, + STATE(417), 1, + sym_prototype, + [17593] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1249), 1, + sym_name, + STATE(657), 1, + sym_name_list, + [17603] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(244), 1, + anon_sym_RBRACK, + ACTIONS(992), 1, + anon_sym_PIPE_PIPE, + [17613] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(145), 1, + anon_sym_RPAREN, + ACTIONS(1372), 1, + anon_sym_COMMA, + [17623] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1374), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [17631] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1376), 1, + anon_sym_SEMI, + ACTIONS(1378), 1, + anon_sym_COLON_COLON, + [17641] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1380), 1, + anon_sym_LPAREN, + STATE(479), 1, + sym_conditional_branch, + [17651] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1382), 1, + anon_sym_COMMA, + ACTIONS(1384), 1, + anon_sym_RPAREN, + [17661] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1386), 1, + anon_sym_COMMA, + ACTIONS(1388), 1, + anon_sym_RPAREN, + [17671] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1390), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [17679] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1392), 1, + anon_sym_LPAREN, + STATE(333), 1, + sym_prototype, + [17689] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1394), 1, + anon_sym_COMMA, + ACTIONS(1396), 1, + anon_sym_PIPE, + [17699] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(157), 1, + anon_sym_RPAREN, + ACTIONS(1398), 1, + anon_sym_COMMA, + [17709] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1400), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [17717] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1402), 1, + sym_name, + STATE(589), 1, + sym_binding_names, + [17727] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(292), 1, + anon_sym_RBRACK, + ACTIONS(992), 1, + anon_sym_PIPE_PIPE, + [17737] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1404), 1, + anon_sym_RBRACE, + ACTIONS(1406), 1, + anon_sym_COMMA, + [17747] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1408), 1, + anon_sym_SEMI, + ACTIONS(1410), 1, + anon_sym_RPAREN, + [17757] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1412), 1, + anon_sym_SEMI, + ACTIONS(1414), 1, + anon_sym_EQ, + [17767] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1358), 1, + sym_name, + STATE(324), 1, + sym_identifier, + [17777] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1148), 1, + anon_sym_RPAREN, + ACTIONS(1416), 1, + anon_sym_COMMA, + [17787] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1418), 1, + anon_sym_COMMA, + ACTIONS(1420), 1, + anon_sym_RPAREN, + [17797] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1422), 2, + anon_sym_SEMI, + anon_sym_COMMA, + [17805] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1424), 1, + anon_sym_SEMI, + ACTIONS(1426), 1, + anon_sym_COMMA, + [17815] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1428), 1, + anon_sym_RBRACE, + ACTIONS(1430), 1, + anon_sym_COMMA, + [17825] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1432), 1, + anon_sym_SEMI, + ACTIONS(1434), 1, + anon_sym_COMMA, + [17835] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1350), 1, + anon_sym_COMMA, + ACTIONS(1436), 1, + anon_sym_RPAREN, + [17845] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(161), 1, + anon_sym_RBRACK, + ACTIONS(1438), 1, + anon_sym_COMMA, + [17855] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1329), 1, + anon_sym_LPAREN, + STATE(434), 1, + sym_prototype, + [17865] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1440), 1, + anon_sym_COMMA, + ACTIONS(1442), 1, + anon_sym_RPAREN, + [17875] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1127), 1, + sym_name, + STATE(378), 1, + sym_identifier, + [17885] = 3, + ACTIONS(1109), 1, + sym_comment, + ACTIONS(1444), 1, + aux_sym_escape_sequence_token1, + ACTIONS(1446), 1, + aux_sym_named_escape_token1, + [17895] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1448), 1, + anon_sym_COMMA, + ACTIONS(1450), 1, + anon_sym_RPAREN, + [17905] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1452), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [17913] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1454), 1, + anon_sym_RBRACE, + ACTIONS(1456), 1, + anon_sym_COMMA, + [17923] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1380), 1, + anon_sym_LPAREN, + STATE(490), 1, + sym_conditional_branch, + [17933] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1458), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [17941] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1127), 1, + sym_name, + STATE(454), 1, + sym_identifier, + [17951] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1259), 1, + anon_sym_EQ, + ACTIONS(1261), 1, + anon_sym_COLON, + [17961] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1460), 1, + anon_sym_RBRACE, + ACTIONS(1462), 1, + anon_sym_COMMA, + [17971] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1464), 1, + sym_name, + STATE(269), 1, + sym_identifier, + [17981] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1466), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [17989] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1392), 1, + anon_sym_LPAREN, + STATE(343), 1, + sym_prototype, + [17999] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1468), 1, + sym_name, + STATE(378), 1, + sym_identifier, + [18009] = 3, + ACTIONS(1109), 1, + sym_comment, + ACTIONS(1470), 1, + aux_sym_escape_sequence_token1, + ACTIONS(1472), 1, + aux_sym_named_escape_token1, + [18019] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(244), 1, + anon_sym_RBRACK, + [18026] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1474), 1, + anon_sym_LBRACE, + [18033] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1476), 1, + anon_sym_STAR, + [18040] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1478), 1, + anon_sym_LBRACE, + [18047] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1480), 1, + anon_sym_RPAREN, + [18054] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1482), 1, + anon_sym_DQUOTE, + [18061] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1484), 1, + anon_sym_RPAREN, + [18068] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1486), 1, + anon_sym_RPAREN, + [18075] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1488), 1, + anon_sym_RPAREN, + [18082] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1490), 1, + anon_sym_STAR, + [18089] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1492), 1, + anon_sym_LPAREN, + [18096] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1494), 1, + anon_sym_fn, + [18103] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(292), 1, + anon_sym_RBRACK, + [18110] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1496), 1, + anon_sym_DQUOTE, + [18117] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1498), 1, + anon_sym_SEMI, + [18124] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1500), 1, + anon_sym_EQ, + [18131] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1502), 1, + anon_sym_SEMI, + [18138] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1504), 1, + anon_sym_COLON, + [18145] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1506), 1, + anon_sym_RPAREN, + [18152] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1508), 1, + anon_sym_RBRACE, + [18159] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1510), 1, + anon_sym_RPAREN, + [18166] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1512), 1, + anon_sym_RPAREN, + [18173] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1514), 1, + anon_sym_LBRACE, + [18180] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1516), 1, + anon_sym_LPAREN, + [18187] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1518), 1, + anon_sym_LBRACE, + [18194] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1520), 1, + anon_sym_LPAREN, + [18201] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1522), 1, + anon_sym_RBRACE, + [18208] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1524), 1, + anon_sym_RBRACE, + [18215] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1526), 1, + anon_sym_RBRACE, + [18222] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1352), 1, + anon_sym_RPAREN, + [18229] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1528), 1, + anon_sym_SEMI, + [18236] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1530), 1, + anon_sym_RBRACK, + [18243] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1532), 1, + anon_sym_SQUOTE, + [18250] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1534), 1, + anon_sym_RBRACE, + [18257] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1536), 1, + anon_sym_LPAREN, + [18264] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1538), 1, + anon_sym_SEMI, + [18271] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1540), 1, + sym_name, + [18278] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1542), 1, + anon_sym_LPAREN, + [18285] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1544), 1, + anon_sym_LPAREN, + [18292] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1546), 1, + anon_sym_LPAREN, + [18299] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1198), 1, + anon_sym_assert, + [18306] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1548), 1, + anon_sym_LPAREN, + [18313] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1550), 1, + anon_sym_RBRACE, + [18320] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1552), 1, + anon_sym_RPAREN, + [18327] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1554), 1, + anon_sym_LPAREN, + [18334] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1556), 1, + anon_sym_LPAREN, + [18341] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1164), 1, + anon_sym_RPAREN, + [18348] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1315), 1, + anon_sym_RPAREN, + [18355] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1558), 1, + sym_name, + [18362] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1305), 1, + anon_sym_RPAREN, + [18369] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1560), 1, + anon_sym_RPAREN, + [18376] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1562), 1, + anon_sym_LPAREN, + [18383] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1564), 1, + anon_sym_RPAREN, + [18390] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1566), 1, + anon_sym_RBRACE, + [18397] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1568), 1, + anon_sym_SEMI, + [18404] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1319), 1, + anon_sym_RBRACE, + [18411] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1570), 1, + anon_sym_SQUOTE, + [18418] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1572), 1, + anon_sym_SQUOTE, + [18425] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1574), 1, + anon_sym_RPAREN, + [18432] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1576), 1, + anon_sym_RPAREN, + [18439] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1578), 1, + anon_sym_RPAREN, + [18446] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1133), 1, + sym_name, + [18453] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(177), 1, + anon_sym_RBRACK, + [18460] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1580), 1, + anon_sym_SQUOTE, + [18467] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1582), 1, + anon_sym_EQ, + [18474] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1584), 1, + anon_sym_COLON, + [18481] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(471), 1, + anon_sym_LBRACE, + [18488] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1586), 1, + anon_sym_RPAREN, + [18495] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1588), 1, + anon_sym_RPAREN, + [18502] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1590), 1, + anon_sym_RPAREN, + [18509] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1592), 1, + anon_sym_RBRACK, + [18516] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1594), 1, + sym_name, + [18523] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1596), 1, + anon_sym_RPAREN, + [18530] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1598), 1, + anon_sym_RPAREN, + [18537] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1600), 1, + anon_sym_LBRACE, + [18544] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1602), 1, + anon_sym_RBRACE, + [18551] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1604), 1, + anon_sym_EQ_GT, + [18558] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1606), 1, + anon_sym_EQ_GT, + [18565] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1608), 1, + anon_sym_RBRACE, + [18572] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1610), 1, + anon_sym_SEMI, + [18579] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1460), 1, + anon_sym_RBRACE, + [18586] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1612), 1, + anon_sym_LPAREN, + [18593] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1614), 1, + anon_sym_LPAREN, + [18600] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1616), 1, + anon_sym_RPAREN, + [18607] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1618), 1, + anon_sym_RPAREN, + [18614] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1620), 1, + anon_sym_RBRACE, + [18621] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1622), 1, + ts_builtin_sym_end, + [18628] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(477), 1, + anon_sym_EQ_GT, + [18635] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(290), 1, + anon_sym_EQ_GT, + [18642] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1624), 1, + anon_sym_RBRACE, + [18649] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1626), 1, + anon_sym_RPAREN, + [18656] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1628), 1, + anon_sym_RPAREN, + [18663] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1630), 1, + anon_sym_for, + [18670] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1632), 1, + anon_sym_SEMI, + [18677] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1634), 1, + anon_sym_RPAREN, + [18684] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1636), 1, + anon_sym_RPAREN, + [18691] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1638), 1, + anon_sym_COMMA, + [18698] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1640), 1, + anon_sym_SEMI, + [18705] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1642), 1, + anon_sym_EQ, + [18712] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1644), 1, + anon_sym_fn, + [18719] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1646), 1, + anon_sym_RPAREN, + [18726] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1648), 1, + anon_sym_RBRACE, + [18733] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1650), 1, + anon_sym_RBRACE, + [18740] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1652), 1, + anon_sym_SEMI, + [18747] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1654), 1, + anon_sym_COLON, + [18754] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1656), 1, + anon_sym_RBRACK, + [18761] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1658), 1, + anon_sym_LPAREN, + [18768] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1660), 1, + anon_sym_RPAREN, + [18775] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1154), 1, + anon_sym_RPAREN, + [18782] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1662), 1, + anon_sym_SEMI, + [18789] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1664), 1, + anon_sym_RPAREN, + [18796] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1666), 1, + anon_sym_RBRACE, + [18803] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1668), 1, + anon_sym_RPAREN, + [18810] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1670), 1, + anon_sym_EQ, + [18817] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1672), 1, + anon_sym_LPAREN, + [18824] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1674), 1, + anon_sym_RPAREN, + [18831] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1676), 1, + anon_sym_COLON, + [18838] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1678), 1, + anon_sym_LBRACE, + [18845] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1680), 1, + anon_sym_LBRACE, + [18852] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1682), 1, + anon_sym_SEMI, + [18859] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1684), 1, + anon_sym_RBRACE, + [18866] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1686), 1, + anon_sym_SEMI, + [18873] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1688), 1, + anon_sym_EQ, + [18880] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1690), 1, + anon_sym_RBRACE, + [18887] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1366), 1, + anon_sym_RPAREN, + [18894] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(175), 1, + anon_sym_RBRACK, + [18901] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1692), 1, + anon_sym_RBRACE, + [18908] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1436), 1, + anon_sym_RPAREN, + [18915] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1420), 1, + anon_sym_RPAREN, + [18922] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1694), 1, + anon_sym_RPAREN, + [18929] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1696), 1, + anon_sym_RPAREN, + [18936] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1698), 1, + anon_sym_RPAREN, + [18943] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1700), 1, + anon_sym_fn, + [18950] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1702), 1, + anon_sym_SEMI, + [18957] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1704), 1, + anon_sym_SEMI, + [18964] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1706), 1, + anon_sym_RPAREN, + [18971] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1708), 1, + anon_sym_RPAREN, + [18978] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(837), 1, + ts_builtin_sym_end, + [18985] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1710), 1, + anon_sym_COMMA, + [18992] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1712), 1, + anon_sym_RBRACK, + [18999] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1714), 1, + anon_sym_RBRACK, + [19006] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1384), 1, + anon_sym_RPAREN, + [19013] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1716), 1, + anon_sym_RBRACE, + [19020] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1718), 1, + anon_sym_RPAREN, + [19027] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1720), 1, + ts_builtin_sym_end, + [19034] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1722), 1, + anon_sym_RBRACE, + [19041] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1724), 1, + anon_sym_SQUOTE, + [19048] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1726), 1, + anon_sym_SQUOTE, + [19055] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1728), 1, + anon_sym_LPAREN, + [19062] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1730), 1, + anon_sym_LPAREN, + [19069] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1732), 1, + anon_sym_LBRACE, + [19076] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1734), 1, + anon_sym_LBRACE, + [19083] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1736), 1, + anon_sym_LBRACE, + [19090] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1738), 1, + anon_sym_LPAREN, + [19097] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1740), 1, + anon_sym_LBRACE, + [19104] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1742), 1, + anon_sym_LPAREN, + [19111] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1744), 1, + anon_sym_LPAREN, + [19118] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1746), 1, + anon_sym_LPAREN, + [19125] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1748), 1, + anon_sym_LPAREN, + [19132] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1750), 1, + anon_sym_LPAREN, + [19139] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1752), 1, + anon_sym_LPAREN, + [19146] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1754), 1, + anon_sym_RPAREN, + [19153] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1756), 1, + anon_sym_RPAREN, + [19160] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1758), 1, + anon_sym_LPAREN, + [19167] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1760), 1, + anon_sym_LPAREN, + [19174] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1762), 1, + anon_sym_RPAREN, + [19181] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1764), 1, + anon_sym_RPAREN, + [19188] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1766), 1, + anon_sym_LPAREN, + [19195] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1768), 1, + anon_sym_COMMA, + [19202] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1770), 1, + anon_sym_LPAREN, + [19209] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1772), 1, + anon_sym_COMMA, + [19216] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1774), 1, + anon_sym_LPAREN, + [19223] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1776), 1, + anon_sym_LPAREN, + [19230] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1778), 1, + anon_sym_assert, + [19237] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1780), 1, + anon_sym_LPAREN, + [19244] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1782), 1, + anon_sym_for, + [19251] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1784), 1, + anon_sym_RPAREN, + [19258] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1786), 1, + anon_sym_LPAREN, + [19265] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1454), 1, + anon_sym_RBRACE, + [19272] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1788), 1, + anon_sym_for, + [19279] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1790), 1, + anon_sym_LPAREN, + [19286] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1792), 1, + anon_sym_for, +}; + +static uint32_t ts_small_parse_table_map[] = { + [SMALL_STATE(140)] = 0, + [SMALL_STATE(141)] = 87, + [SMALL_STATE(142)] = 223, + [SMALL_STATE(143)] = 359, + [SMALL_STATE(144)] = 432, + [SMALL_STATE(145)] = 565, + [SMALL_STATE(146)] = 638, + [SMALL_STATE(147)] = 711, + [SMALL_STATE(148)] = 844, + [SMALL_STATE(149)] = 917, + [SMALL_STATE(150)] = 996, + [SMALL_STATE(151)] = 1129, + [SMALL_STATE(152)] = 1259, + [SMALL_STATE(153)] = 1389, + [SMALL_STATE(154)] = 1467, + [SMALL_STATE(155)] = 1597, + [SMALL_STATE(156)] = 1727, + [SMALL_STATE(157)] = 1794, + [SMALL_STATE(158)] = 1861, + [SMALL_STATE(159)] = 1928, + [SMALL_STATE(160)] = 2000, + [SMALL_STATE(161)] = 2068, + [SMALL_STATE(162)] = 2136, + [SMALL_STATE(163)] = 2198, + [SMALL_STATE(164)] = 2274, + [SMALL_STATE(165)] = 2377, + [SMALL_STATE(166)] = 2436, + [SMALL_STATE(167)] = 2503, + [SMALL_STATE(168)] = 2565, + [SMALL_STATE(169)] = 2627, + [SMALL_STATE(170)] = 2727, + [SMALL_STATE(171)] = 2827, + [SMALL_STATE(172)] = 2927, + [SMALL_STATE(173)] = 3027, + [SMALL_STATE(174)] = 3095, + [SMALL_STATE(175)] = 3156, + [SMALL_STATE(176)] = 3223, + [SMALL_STATE(177)] = 3320, + [SMALL_STATE(178)] = 3376, + [SMALL_STATE(179)] = 3432, + [SMALL_STATE(180)] = 3526, + [SMALL_STATE(181)] = 3620, + [SMALL_STATE(182)] = 3714, + [SMALL_STATE(183)] = 3808, + [SMALL_STATE(184)] = 3902, + [SMALL_STATE(185)] = 3996, + [SMALL_STATE(186)] = 4060, + [SMALL_STATE(187)] = 4154, + [SMALL_STATE(188)] = 4248, + [SMALL_STATE(189)] = 4342, + [SMALL_STATE(190)] = 4436, + [SMALL_STATE(191)] = 4530, + [SMALL_STATE(192)] = 4624, + [SMALL_STATE(193)] = 4688, + [SMALL_STATE(194)] = 4744, + [SMALL_STATE(195)] = 4838, + [SMALL_STATE(196)] = 4898, + [SMALL_STATE(197)] = 4992, + [SMALL_STATE(198)] = 5050, + [SMALL_STATE(199)] = 5144, + [SMALL_STATE(200)] = 5204, + [SMALL_STATE(201)] = 5298, + [SMALL_STATE(202)] = 5392, + [SMALL_STATE(203)] = 5486, + [SMALL_STATE(204)] = 5580, + [SMALL_STATE(205)] = 5640, + [SMALL_STATE(206)] = 5731, + [SMALL_STATE(207)] = 5822, + [SMALL_STATE(208)] = 5913, + [SMALL_STATE(209)] = 6004, + [SMALL_STATE(210)] = 6059, + [SMALL_STATE(211)] = 6150, + [SMALL_STATE(212)] = 6241, + [SMALL_STATE(213)] = 6302, + [SMALL_STATE(214)] = 6393, + [SMALL_STATE(215)] = 6484, + [SMALL_STATE(216)] = 6575, + [SMALL_STATE(217)] = 6666, + [SMALL_STATE(218)] = 6757, + [SMALL_STATE(219)] = 6848, + [SMALL_STATE(220)] = 6902, + [SMALL_STATE(221)] = 6960, + [SMALL_STATE(222)] = 7014, + [SMALL_STATE(223)] = 7076, + [SMALL_STATE(224)] = 7130, + [SMALL_STATE(225)] = 7184, + [SMALL_STATE(226)] = 7238, + [SMALL_STATE(227)] = 7292, + [SMALL_STATE(228)] = 7346, + [SMALL_STATE(229)] = 7400, + [SMALL_STATE(230)] = 7454, + [SMALL_STATE(231)] = 7508, + [SMALL_STATE(232)] = 7562, + [SMALL_STATE(233)] = 7616, + [SMALL_STATE(234)] = 7670, + [SMALL_STATE(235)] = 7724, + [SMALL_STATE(236)] = 7778, + [SMALL_STATE(237)] = 7832, + [SMALL_STATE(238)] = 7886, + [SMALL_STATE(239)] = 7940, + [SMALL_STATE(240)] = 7994, + [SMALL_STATE(241)] = 8048, + [SMALL_STATE(242)] = 8102, + [SMALL_STATE(243)] = 8156, + [SMALL_STATE(244)] = 8210, + [SMALL_STATE(245)] = 8264, + [SMALL_STATE(246)] = 8318, + [SMALL_STATE(247)] = 8372, + [SMALL_STATE(248)] = 8426, + [SMALL_STATE(249)] = 8480, + [SMALL_STATE(250)] = 8534, + [SMALL_STATE(251)] = 8588, + [SMALL_STATE(252)] = 8642, + [SMALL_STATE(253)] = 8696, + [SMALL_STATE(254)] = 8754, + [SMALL_STATE(255)] = 8808, + [SMALL_STATE(256)] = 8862, + [SMALL_STATE(257)] = 8916, + [SMALL_STATE(258)] = 8970, + [SMALL_STATE(259)] = 9024, + [SMALL_STATE(260)] = 9078, + [SMALL_STATE(261)] = 9132, + [SMALL_STATE(262)] = 9219, + [SMALL_STATE(263)] = 9306, + [SMALL_STATE(264)] = 9363, + [SMALL_STATE(265)] = 9413, + [SMALL_STATE(266)] = 9469, + [SMALL_STATE(267)] = 9519, + [SMALL_STATE(268)] = 9575, + [SMALL_STATE(269)] = 9628, + [SMALL_STATE(270)] = 9674, + [SMALL_STATE(271)] = 9724, + [SMALL_STATE(272)] = 9776, + [SMALL_STATE(273)] = 9825, + [SMALL_STATE(274)] = 9872, + [SMALL_STATE(275)] = 9921, + [SMALL_STATE(276)] = 9970, + [SMALL_STATE(277)] = 10023, + [SMALL_STATE(278)] = 10067, + [SMALL_STATE(279)] = 10113, + [SMALL_STATE(280)] = 10157, + [SMALL_STATE(281)] = 10201, + [SMALL_STATE(282)] = 10245, + [SMALL_STATE(283)] = 10288, + [SMALL_STATE(284)] = 10331, + [SMALL_STATE(285)] = 10374, + [SMALL_STATE(286)] = 10417, + [SMALL_STATE(287)] = 10462, + [SMALL_STATE(288)] = 10505, + [SMALL_STATE(289)] = 10548, + [SMALL_STATE(290)] = 10599, + [SMALL_STATE(291)] = 10642, + [SMALL_STATE(292)] = 10685, + [SMALL_STATE(293)] = 10728, + [SMALL_STATE(294)] = 10771, + [SMALL_STATE(295)] = 10814, + [SMALL_STATE(296)] = 10857, + [SMALL_STATE(297)] = 10900, + [SMALL_STATE(298)] = 10943, + [SMALL_STATE(299)] = 10986, + [SMALL_STATE(300)] = 11029, + [SMALL_STATE(301)] = 11072, + [SMALL_STATE(302)] = 11115, + [SMALL_STATE(303)] = 11158, + [SMALL_STATE(304)] = 11201, + [SMALL_STATE(305)] = 11244, + [SMALL_STATE(306)] = 11295, + [SMALL_STATE(307)] = 11338, + [SMALL_STATE(308)] = 11381, + [SMALL_STATE(309)] = 11424, + [SMALL_STATE(310)] = 11467, + [SMALL_STATE(311)] = 11510, + [SMALL_STATE(312)] = 11553, + [SMALL_STATE(313)] = 11596, + [SMALL_STATE(314)] = 11643, + [SMALL_STATE(315)] = 11686, + [SMALL_STATE(316)] = 11729, + [SMALL_STATE(317)] = 11772, + [SMALL_STATE(318)] = 11815, + [SMALL_STATE(319)] = 11858, + [SMALL_STATE(320)] = 11901, + [SMALL_STATE(321)] = 11944, + [SMALL_STATE(322)] = 11987, + [SMALL_STATE(323)] = 12030, + [SMALL_STATE(324)] = 12070, + [SMALL_STATE(325)] = 12110, + [SMALL_STATE(326)] = 12150, + [SMALL_STATE(327)] = 12190, + [SMALL_STATE(328)] = 12230, + [SMALL_STATE(329)] = 12272, + [SMALL_STATE(330)] = 12312, + [SMALL_STATE(331)] = 12354, + [SMALL_STATE(332)] = 12394, + [SMALL_STATE(333)] = 12434, + [SMALL_STATE(334)] = 12474, + [SMALL_STATE(335)] = 12514, + [SMALL_STATE(336)] = 12554, + [SMALL_STATE(337)] = 12594, + [SMALL_STATE(338)] = 12634, + [SMALL_STATE(339)] = 12674, + [SMALL_STATE(340)] = 12714, + [SMALL_STATE(341)] = 12754, + [SMALL_STATE(342)] = 12794, + [SMALL_STATE(343)] = 12834, + [SMALL_STATE(344)] = 12874, + [SMALL_STATE(345)] = 12914, + [SMALL_STATE(346)] = 12954, + [SMALL_STATE(347)] = 12994, + [SMALL_STATE(348)] = 13039, + [SMALL_STATE(349)] = 13078, + [SMALL_STATE(350)] = 13117, + [SMALL_STATE(351)] = 13156, + [SMALL_STATE(352)] = 13195, + [SMALL_STATE(353)] = 13234, + [SMALL_STATE(354)] = 13273, + [SMALL_STATE(355)] = 13318, + [SMALL_STATE(356)] = 13359, + [SMALL_STATE(357)] = 13401, + [SMALL_STATE(358)] = 13439, + [SMALL_STATE(359)] = 13474, + [SMALL_STATE(360)] = 13509, + [SMALL_STATE(361)] = 13547, + [SMALL_STATE(362)] = 13607, + [SMALL_STATE(363)] = 13640, + [SMALL_STATE(364)] = 13697, + [SMALL_STATE(365)] = 13754, + [SMALL_STATE(366)] = 13785, + [SMALL_STATE(367)] = 13814, + [SMALL_STATE(368)] = 13845, + [SMALL_STATE(369)] = 13874, + [SMALL_STATE(370)] = 13904, + [SMALL_STATE(371)] = 13952, + [SMALL_STATE(372)] = 13982, + [SMALL_STATE(373)] = 14011, + [SMALL_STATE(374)] = 14040, + [SMALL_STATE(375)] = 14080, + [SMALL_STATE(376)] = 14120, + [SMALL_STATE(377)] = 14150, + [SMALL_STATE(378)] = 14180, + [SMALL_STATE(379)] = 14204, + [SMALL_STATE(380)] = 14229, + [SMALL_STATE(381)] = 14256, + [SMALL_STATE(382)] = 14283, + [SMALL_STATE(383)] = 14308, + [SMALL_STATE(384)] = 14332, + [SMALL_STATE(385)] = 14356, + [SMALL_STATE(386)] = 14379, + [SMALL_STATE(387)] = 14398, + [SMALL_STATE(388)] = 14421, + [SMALL_STATE(389)] = 14444, + [SMALL_STATE(390)] = 14467, + [SMALL_STATE(391)] = 14486, + [SMALL_STATE(392)] = 14509, + [SMALL_STATE(393)] = 14528, + [SMALL_STATE(394)] = 14548, + [SMALL_STATE(395)] = 14570, + [SMALL_STATE(396)] = 14590, + [SMALL_STATE(397)] = 14608, + [SMALL_STATE(398)] = 14628, + [SMALL_STATE(399)] = 14650, + [SMALL_STATE(400)] = 14668, + [SMALL_STATE(401)] = 14688, + [SMALL_STATE(402)] = 14709, + [SMALL_STATE(403)] = 14730, + [SMALL_STATE(404)] = 14751, + [SMALL_STATE(405)] = 14784, + [SMALL_STATE(406)] = 14805, + [SMALL_STATE(407)] = 14828, + [SMALL_STATE(408)] = 14858, + [SMALL_STATE(409)] = 14884, + [SMALL_STATE(410)] = 14914, + [SMALL_STATE(411)] = 14944, + [SMALL_STATE(412)] = 14962, + [SMALL_STATE(413)] = 14982, + [SMALL_STATE(414)] = 15012, + [SMALL_STATE(415)] = 15038, + [SMALL_STATE(416)] = 15056, + [SMALL_STATE(417)] = 15073, + [SMALL_STATE(418)] = 15090, + [SMALL_STATE(419)] = 15107, + [SMALL_STATE(420)] = 15126, + [SMALL_STATE(421)] = 15143, + [SMALL_STATE(422)] = 15160, + [SMALL_STATE(423)] = 15179, + [SMALL_STATE(424)] = 15196, + [SMALL_STATE(425)] = 15213, + [SMALL_STATE(426)] = 15230, + [SMALL_STATE(427)] = 15249, + [SMALL_STATE(428)] = 15266, + [SMALL_STATE(429)] = 15283, + [SMALL_STATE(430)] = 15300, + [SMALL_STATE(431)] = 15317, + [SMALL_STATE(432)] = 15334, + [SMALL_STATE(433)] = 15351, + [SMALL_STATE(434)] = 15370, + [SMALL_STATE(435)] = 15387, + [SMALL_STATE(436)] = 15404, + [SMALL_STATE(437)] = 15421, + [SMALL_STATE(438)] = 15438, + [SMALL_STATE(439)] = 15455, + [SMALL_STATE(440)] = 15472, + [SMALL_STATE(441)] = 15489, + [SMALL_STATE(442)] = 15506, + [SMALL_STATE(443)] = 15523, + [SMALL_STATE(444)] = 15540, + [SMALL_STATE(445)] = 15557, + [SMALL_STATE(446)] = 15574, + [SMALL_STATE(447)] = 15591, + [SMALL_STATE(448)] = 15608, + [SMALL_STATE(449)] = 15625, + [SMALL_STATE(450)] = 15642, + [SMALL_STATE(451)] = 15659, + [SMALL_STATE(452)] = 15676, + [SMALL_STATE(453)] = 15693, + [SMALL_STATE(454)] = 15710, + [SMALL_STATE(455)] = 15727, + [SMALL_STATE(456)] = 15744, + [SMALL_STATE(457)] = 15761, + [SMALL_STATE(458)] = 15777, + [SMALL_STATE(459)] = 15805, + [SMALL_STATE(460)] = 15823, + [SMALL_STATE(461)] = 15851, + [SMALL_STATE(462)] = 15874, + [SMALL_STATE(463)] = 15897, + [SMALL_STATE(464)] = 15920, + [SMALL_STATE(465)] = 15943, + [SMALL_STATE(466)] = 15968, + [SMALL_STATE(467)] = 15990, + [SMALL_STATE(468)] = 16008, + [SMALL_STATE(469)] = 16030, + [SMALL_STATE(470)] = 16042, + [SMALL_STATE(471)] = 16056, + [SMALL_STATE(472)] = 16068, + [SMALL_STATE(473)] = 16090, + [SMALL_STATE(474)] = 16112, + [SMALL_STATE(475)] = 16124, + [SMALL_STATE(476)] = 16144, + [SMALL_STATE(477)] = 16166, + [SMALL_STATE(478)] = 16186, + [SMALL_STATE(479)] = 16208, + [SMALL_STATE(480)] = 16221, + [SMALL_STATE(481)] = 16236, + [SMALL_STATE(482)] = 16253, + [SMALL_STATE(483)] = 16266, + [SMALL_STATE(484)] = 16279, + [SMALL_STATE(485)] = 16292, + [SMALL_STATE(486)] = 16311, + [SMALL_STATE(487)] = 16326, + [SMALL_STATE(488)] = 16339, + [SMALL_STATE(489)] = 16352, + [SMALL_STATE(490)] = 16371, + [SMALL_STATE(491)] = 16384, + [SMALL_STATE(492)] = 16400, + [SMALL_STATE(493)] = 16414, + [SMALL_STATE(494)] = 16430, + [SMALL_STATE(495)] = 16446, + [SMALL_STATE(496)] = 16462, + [SMALL_STATE(497)] = 16478, + [SMALL_STATE(498)] = 16494, + [SMALL_STATE(499)] = 16510, + [SMALL_STATE(500)] = 16526, + [SMALL_STATE(501)] = 16542, + [SMALL_STATE(502)] = 16558, + [SMALL_STATE(503)] = 16574, + [SMALL_STATE(504)] = 16588, + [SMALL_STATE(505)] = 16604, + [SMALL_STATE(506)] = 16620, + [SMALL_STATE(507)] = 16636, + [SMALL_STATE(508)] = 16652, + [SMALL_STATE(509)] = 16668, + [SMALL_STATE(510)] = 16682, + [SMALL_STATE(511)] = 16698, + [SMALL_STATE(512)] = 16714, + [SMALL_STATE(513)] = 16730, + [SMALL_STATE(514)] = 16746, + [SMALL_STATE(515)] = 16762, + [SMALL_STATE(516)] = 16773, + [SMALL_STATE(517)] = 16786, + [SMALL_STATE(518)] = 16799, + [SMALL_STATE(519)] = 16812, + [SMALL_STATE(520)] = 16825, + [SMALL_STATE(521)] = 16836, + [SMALL_STATE(522)] = 16845, + [SMALL_STATE(523)] = 16858, + [SMALL_STATE(524)] = 16867, + [SMALL_STATE(525)] = 16876, + [SMALL_STATE(526)] = 16889, + [SMALL_STATE(527)] = 16902, + [SMALL_STATE(528)] = 16915, + [SMALL_STATE(529)] = 16924, + [SMALL_STATE(530)] = 16935, + [SMALL_STATE(531)] = 16946, + [SMALL_STATE(532)] = 16959, + [SMALL_STATE(533)] = 16972, + [SMALL_STATE(534)] = 16985, + [SMALL_STATE(535)] = 16998, + [SMALL_STATE(536)] = 17009, + [SMALL_STATE(537)] = 17022, + [SMALL_STATE(538)] = 17031, + [SMALL_STATE(539)] = 17040, + [SMALL_STATE(540)] = 17051, + [SMALL_STATE(541)] = 17064, + [SMALL_STATE(542)] = 17077, + [SMALL_STATE(543)] = 17090, + [SMALL_STATE(544)] = 17101, + [SMALL_STATE(545)] = 17112, + [SMALL_STATE(546)] = 17125, + [SMALL_STATE(547)] = 17138, + [SMALL_STATE(548)] = 17151, + [SMALL_STATE(549)] = 17164, + [SMALL_STATE(550)] = 17177, + [SMALL_STATE(551)] = 17186, + [SMALL_STATE(552)] = 17195, + [SMALL_STATE(553)] = 17205, + [SMALL_STATE(554)] = 17213, + [SMALL_STATE(555)] = 17221, + [SMALL_STATE(556)] = 17229, + [SMALL_STATE(557)] = 17239, + [SMALL_STATE(558)] = 17247, + [SMALL_STATE(559)] = 17255, + [SMALL_STATE(560)] = 17263, + [SMALL_STATE(561)] = 17273, + [SMALL_STATE(562)] = 17283, + [SMALL_STATE(563)] = 17293, + [SMALL_STATE(564)] = 17303, + [SMALL_STATE(565)] = 17313, + [SMALL_STATE(566)] = 17323, + [SMALL_STATE(567)] = 17333, + [SMALL_STATE(568)] = 17343, + [SMALL_STATE(569)] = 17351, + [SMALL_STATE(570)] = 17361, + [SMALL_STATE(571)] = 17371, + [SMALL_STATE(572)] = 17379, + [SMALL_STATE(573)] = 17389, + [SMALL_STATE(574)] = 17399, + [SMALL_STATE(575)] = 17409, + [SMALL_STATE(576)] = 17419, + [SMALL_STATE(577)] = 17427, + [SMALL_STATE(578)] = 17437, + [SMALL_STATE(579)] = 17447, + [SMALL_STATE(580)] = 17457, + [SMALL_STATE(581)] = 17467, + [SMALL_STATE(582)] = 17477, + [SMALL_STATE(583)] = 17485, + [SMALL_STATE(584)] = 17495, + [SMALL_STATE(585)] = 17505, + [SMALL_STATE(586)] = 17515, + [SMALL_STATE(587)] = 17525, + [SMALL_STATE(588)] = 17535, + [SMALL_STATE(589)] = 17545, + [SMALL_STATE(590)] = 17553, + [SMALL_STATE(591)] = 17563, + [SMALL_STATE(592)] = 17573, + [SMALL_STATE(593)] = 17583, + [SMALL_STATE(594)] = 17593, + [SMALL_STATE(595)] = 17603, + [SMALL_STATE(596)] = 17613, + [SMALL_STATE(597)] = 17623, + [SMALL_STATE(598)] = 17631, + [SMALL_STATE(599)] = 17641, + [SMALL_STATE(600)] = 17651, + [SMALL_STATE(601)] = 17661, + [SMALL_STATE(602)] = 17671, + [SMALL_STATE(603)] = 17679, + [SMALL_STATE(604)] = 17689, + [SMALL_STATE(605)] = 17699, + [SMALL_STATE(606)] = 17709, + [SMALL_STATE(607)] = 17717, + [SMALL_STATE(608)] = 17727, + [SMALL_STATE(609)] = 17737, + [SMALL_STATE(610)] = 17747, + [SMALL_STATE(611)] = 17757, + [SMALL_STATE(612)] = 17767, + [SMALL_STATE(613)] = 17777, + [SMALL_STATE(614)] = 17787, + [SMALL_STATE(615)] = 17797, + [SMALL_STATE(616)] = 17805, + [SMALL_STATE(617)] = 17815, + [SMALL_STATE(618)] = 17825, + [SMALL_STATE(619)] = 17835, + [SMALL_STATE(620)] = 17845, + [SMALL_STATE(621)] = 17855, + [SMALL_STATE(622)] = 17865, + [SMALL_STATE(623)] = 17875, + [SMALL_STATE(624)] = 17885, + [SMALL_STATE(625)] = 17895, + [SMALL_STATE(626)] = 17905, + [SMALL_STATE(627)] = 17913, + [SMALL_STATE(628)] = 17923, + [SMALL_STATE(629)] = 17933, + [SMALL_STATE(630)] = 17941, + [SMALL_STATE(631)] = 17951, + [SMALL_STATE(632)] = 17961, + [SMALL_STATE(633)] = 17971, + [SMALL_STATE(634)] = 17981, + [SMALL_STATE(635)] = 17989, + [SMALL_STATE(636)] = 17999, + [SMALL_STATE(637)] = 18009, + [SMALL_STATE(638)] = 18019, + [SMALL_STATE(639)] = 18026, + [SMALL_STATE(640)] = 18033, + [SMALL_STATE(641)] = 18040, + [SMALL_STATE(642)] = 18047, + [SMALL_STATE(643)] = 18054, + [SMALL_STATE(644)] = 18061, + [SMALL_STATE(645)] = 18068, + [SMALL_STATE(646)] = 18075, + [SMALL_STATE(647)] = 18082, + [SMALL_STATE(648)] = 18089, + [SMALL_STATE(649)] = 18096, + [SMALL_STATE(650)] = 18103, + [SMALL_STATE(651)] = 18110, + [SMALL_STATE(652)] = 18117, + [SMALL_STATE(653)] = 18124, + [SMALL_STATE(654)] = 18131, + [SMALL_STATE(655)] = 18138, + [SMALL_STATE(656)] = 18145, + [SMALL_STATE(657)] = 18152, + [SMALL_STATE(658)] = 18159, + [SMALL_STATE(659)] = 18166, + [SMALL_STATE(660)] = 18173, + [SMALL_STATE(661)] = 18180, + [SMALL_STATE(662)] = 18187, + [SMALL_STATE(663)] = 18194, + [SMALL_STATE(664)] = 18201, + [SMALL_STATE(665)] = 18208, + [SMALL_STATE(666)] = 18215, + [SMALL_STATE(667)] = 18222, + [SMALL_STATE(668)] = 18229, + [SMALL_STATE(669)] = 18236, + [SMALL_STATE(670)] = 18243, + [SMALL_STATE(671)] = 18250, + [SMALL_STATE(672)] = 18257, + [SMALL_STATE(673)] = 18264, + [SMALL_STATE(674)] = 18271, + [SMALL_STATE(675)] = 18278, + [SMALL_STATE(676)] = 18285, + [SMALL_STATE(677)] = 18292, + [SMALL_STATE(678)] = 18299, + [SMALL_STATE(679)] = 18306, + [SMALL_STATE(680)] = 18313, + [SMALL_STATE(681)] = 18320, + [SMALL_STATE(682)] = 18327, + [SMALL_STATE(683)] = 18334, + [SMALL_STATE(684)] = 18341, + [SMALL_STATE(685)] = 18348, + [SMALL_STATE(686)] = 18355, + [SMALL_STATE(687)] = 18362, + [SMALL_STATE(688)] = 18369, + [SMALL_STATE(689)] = 18376, + [SMALL_STATE(690)] = 18383, + [SMALL_STATE(691)] = 18390, + [SMALL_STATE(692)] = 18397, + [SMALL_STATE(693)] = 18404, + [SMALL_STATE(694)] = 18411, + [SMALL_STATE(695)] = 18418, + [SMALL_STATE(696)] = 18425, + [SMALL_STATE(697)] = 18432, + [SMALL_STATE(698)] = 18439, + [SMALL_STATE(699)] = 18446, + [SMALL_STATE(700)] = 18453, + [SMALL_STATE(701)] = 18460, + [SMALL_STATE(702)] = 18467, + [SMALL_STATE(703)] = 18474, + [SMALL_STATE(704)] = 18481, + [SMALL_STATE(705)] = 18488, + [SMALL_STATE(706)] = 18495, + [SMALL_STATE(707)] = 18502, + [SMALL_STATE(708)] = 18509, + [SMALL_STATE(709)] = 18516, + [SMALL_STATE(710)] = 18523, + [SMALL_STATE(711)] = 18530, + [SMALL_STATE(712)] = 18537, + [SMALL_STATE(713)] = 18544, + [SMALL_STATE(714)] = 18551, + [SMALL_STATE(715)] = 18558, + [SMALL_STATE(716)] = 18565, + [SMALL_STATE(717)] = 18572, + [SMALL_STATE(718)] = 18579, + [SMALL_STATE(719)] = 18586, + [SMALL_STATE(720)] = 18593, + [SMALL_STATE(721)] = 18600, + [SMALL_STATE(722)] = 18607, + [SMALL_STATE(723)] = 18614, + [SMALL_STATE(724)] = 18621, + [SMALL_STATE(725)] = 18628, + [SMALL_STATE(726)] = 18635, + [SMALL_STATE(727)] = 18642, + [SMALL_STATE(728)] = 18649, + [SMALL_STATE(729)] = 18656, + [SMALL_STATE(730)] = 18663, + [SMALL_STATE(731)] = 18670, + [SMALL_STATE(732)] = 18677, + [SMALL_STATE(733)] = 18684, + [SMALL_STATE(734)] = 18691, + [SMALL_STATE(735)] = 18698, + [SMALL_STATE(736)] = 18705, + [SMALL_STATE(737)] = 18712, + [SMALL_STATE(738)] = 18719, + [SMALL_STATE(739)] = 18726, + [SMALL_STATE(740)] = 18733, + [SMALL_STATE(741)] = 18740, + [SMALL_STATE(742)] = 18747, + [SMALL_STATE(743)] = 18754, + [SMALL_STATE(744)] = 18761, + [SMALL_STATE(745)] = 18768, + [SMALL_STATE(746)] = 18775, + [SMALL_STATE(747)] = 18782, + [SMALL_STATE(748)] = 18789, + [SMALL_STATE(749)] = 18796, + [SMALL_STATE(750)] = 18803, + [SMALL_STATE(751)] = 18810, + [SMALL_STATE(752)] = 18817, + [SMALL_STATE(753)] = 18824, + [SMALL_STATE(754)] = 18831, + [SMALL_STATE(755)] = 18838, + [SMALL_STATE(756)] = 18845, + [SMALL_STATE(757)] = 18852, + [SMALL_STATE(758)] = 18859, + [SMALL_STATE(759)] = 18866, + [SMALL_STATE(760)] = 18873, + [SMALL_STATE(761)] = 18880, + [SMALL_STATE(762)] = 18887, + [SMALL_STATE(763)] = 18894, + [SMALL_STATE(764)] = 18901, + [SMALL_STATE(765)] = 18908, + [SMALL_STATE(766)] = 18915, + [SMALL_STATE(767)] = 18922, + [SMALL_STATE(768)] = 18929, + [SMALL_STATE(769)] = 18936, + [SMALL_STATE(770)] = 18943, + [SMALL_STATE(771)] = 18950, + [SMALL_STATE(772)] = 18957, + [SMALL_STATE(773)] = 18964, + [SMALL_STATE(774)] = 18971, + [SMALL_STATE(775)] = 18978, + [SMALL_STATE(776)] = 18985, + [SMALL_STATE(777)] = 18992, + [SMALL_STATE(778)] = 18999, + [SMALL_STATE(779)] = 19006, + [SMALL_STATE(780)] = 19013, + [SMALL_STATE(781)] = 19020, + [SMALL_STATE(782)] = 19027, + [SMALL_STATE(783)] = 19034, + [SMALL_STATE(784)] = 19041, + [SMALL_STATE(785)] = 19048, + [SMALL_STATE(786)] = 19055, + [SMALL_STATE(787)] = 19062, + [SMALL_STATE(788)] = 19069, + [SMALL_STATE(789)] = 19076, + [SMALL_STATE(790)] = 19083, + [SMALL_STATE(791)] = 19090, + [SMALL_STATE(792)] = 19097, + [SMALL_STATE(793)] = 19104, + [SMALL_STATE(794)] = 19111, + [SMALL_STATE(795)] = 19118, + [SMALL_STATE(796)] = 19125, + [SMALL_STATE(797)] = 19132, + [SMALL_STATE(798)] = 19139, + [SMALL_STATE(799)] = 19146, + [SMALL_STATE(800)] = 19153, + [SMALL_STATE(801)] = 19160, + [SMALL_STATE(802)] = 19167, + [SMALL_STATE(803)] = 19174, + [SMALL_STATE(804)] = 19181, + [SMALL_STATE(805)] = 19188, + [SMALL_STATE(806)] = 19195, + [SMALL_STATE(807)] = 19202, + [SMALL_STATE(808)] = 19209, + [SMALL_STATE(809)] = 19216, + [SMALL_STATE(810)] = 19223, + [SMALL_STATE(811)] = 19230, + [SMALL_STATE(812)] = 19237, + [SMALL_STATE(813)] = 19244, + [SMALL_STATE(814)] = 19251, + [SMALL_STATE(815)] = 19258, + [SMALL_STATE(816)] = 19265, + [SMALL_STATE(817)] = 19272, + [SMALL_STATE(818)] = 19279, + [SMALL_STATE(819)] = 19286, +}; + +static TSParseActionEntry ts_parse_actions[] = { + [0] = {.entry = {.count = 0, .reusable = false}}, + [1] = {.entry = {.count = 1, .reusable = false}}, RECOVER(), + [3] = {.entry = {.count = 1, .reusable = true}}, SHIFT_EXTRA(), + [5] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_unit, 0), + [7] = {.entry = {.count = 1, .reusable = true}}, SHIFT(560), + [9] = {.entry = {.count = 1, .reusable = true}}, SHIFT(370), + [11] = {.entry = {.count = 1, .reusable = true}}, SHIFT(468), + [13] = {.entry = {.count = 1, .reusable = true}}, SHIFT(807), + [15] = {.entry = {.count = 1, .reusable = true}}, SHIFT(512), + [17] = {.entry = {.count = 1, .reusable = true}}, SHIFT(540), + [19] = {.entry = {.count = 1, .reusable = true}}, SHIFT(573), + [21] = {.entry = {.count = 1, .reusable = true}}, SHIFT(469), + [23] = {.entry = {.count = 1, .reusable = true}}, SHIFT(474), + [25] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_control_statement, 1), + [27] = {.entry = {.count = 1, .reusable = true}}, SHIFT(28), + [29] = {.entry = {.count = 1, .reusable = false}}, SHIFT(508), + [31] = {.entry = {.count = 1, .reusable = true}}, SHIFT(709), + [33] = {.entry = {.count = 1, .reusable = true}}, SHIFT(27), + [35] = {.entry = {.count = 1, .reusable = true}}, SHIFT(129), + [37] = {.entry = {.count = 1, .reusable = false}}, SHIFT(293), + [39] = {.entry = {.count = 1, .reusable = false}}, SHIFT(661), + [41] = {.entry = {.count = 1, .reusable = true}}, SHIFT(133), + [43] = {.entry = {.count = 1, .reusable = false}}, SHIFT(662), + [45] = {.entry = {.count = 1, .reusable = true}}, SHIFT(11), + [47] = {.entry = {.count = 1, .reusable = true}}, SHIFT(358), + [49] = {.entry = {.count = 1, .reusable = true}}, SHIFT(401), + [51] = {.entry = {.count = 1, .reusable = true}}, SHIFT(480), + [53] = {.entry = {.count = 1, .reusable = false}}, SHIFT(158), + [55] = {.entry = {.count = 1, .reusable = true}}, SHIFT(158), + [57] = {.entry = {.count = 1, .reusable = true}}, SHIFT(489), + [59] = {.entry = {.count = 1, .reusable = true}}, SHIFT(462), + [61] = {.entry = {.count = 1, .reusable = false}}, SHIFT(672), + [63] = {.entry = {.count = 1, .reusable = false}}, SHIFT(675), + [65] = {.entry = {.count = 1, .reusable = false}}, SHIFT(676), + [67] = {.entry = {.count = 1, .reusable = false}}, SHIFT(648), + [69] = {.entry = {.count = 1, .reusable = false}}, SHIFT(677), + [71] = {.entry = {.count = 1, .reusable = false}}, SHIFT(543), + [73] = {.entry = {.count = 1, .reusable = false}}, SHIFT(679), + [75] = {.entry = {.count = 1, .reusable = false}}, SHIFT(682), + [77] = {.entry = {.count = 1, .reusable = false}}, SHIFT(683), + [79] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_control_statement, 1), + [81] = {.entry = {.count = 1, .reusable = true}}, SHIFT(147), + [83] = {.entry = {.count = 1, .reusable = false}}, SHIFT(583), + [85] = {.entry = {.count = 1, .reusable = false}}, SHIFT(809), + [87] = {.entry = {.count = 1, .reusable = false}}, SHIFT(719), + [89] = {.entry = {.count = 1, .reusable = false}}, SHIFT(720), + [91] = {.entry = {.count = 1, .reusable = false}}, SHIFT(58), + [93] = {.entry = {.count = 1, .reusable = false}}, SHIFT(406), + [95] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2), + [97] = {.entry = {.count = 1, .reusable = false}}, SHIFT(197), + [99] = {.entry = {.count = 1, .reusable = false}}, SHIFT(507), + [101] = {.entry = {.count = 1, .reusable = true}}, SHIFT(138), + [103] = {.entry = {.count = 1, .reusable = false}}, SHIFT(535), + [105] = {.entry = {.count = 1, .reusable = false}}, SHIFT(580), + [107] = {.entry = {.count = 1, .reusable = false}}, SHIFT(812), + [109] = {.entry = {.count = 1, .reusable = false}}, SHIFT(59), + [111] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3), + [113] = {.entry = {.count = 1, .reusable = false}}, SHIFT(497), + [115] = {.entry = {.count = 1, .reusable = true}}, SHIFT(132), + [117] = {.entry = {.count = 1, .reusable = false}}, SHIFT(544), + [119] = {.entry = {.count = 1, .reusable = false}}, SHIFT(599), + [121] = {.entry = {.count = 1, .reusable = false}}, SHIFT(801), + [123] = {.entry = {.count = 1, .reusable = false}}, SHIFT(56), + [125] = {.entry = {.count = 1, .reusable = false}}, SHIFT(4), + [127] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_switch_cases, 2), + [129] = {.entry = {.count = 1, .reusable = true}}, SHIFT(124), + [131] = {.entry = {.count = 1, .reusable = false}}, SHIFT(514), + [133] = {.entry = {.count = 1, .reusable = true}}, SHIFT(130), + [135] = {.entry = {.count = 1, .reusable = false}}, SHIFT(515), + [137] = {.entry = {.count = 1, .reusable = false}}, SHIFT(628), + [139] = {.entry = {.count = 1, .reusable = false}}, SHIFT(689), + [141] = {.entry = {.count = 1, .reusable = false}}, SHIFT(50), + [143] = {.entry = {.count = 1, .reusable = false}}, SHIFT(6), + [145] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_append_values, 2), + [147] = {.entry = {.count = 1, .reusable = true}}, SHIFT(101), + [149] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tuple_items, 4), + [151] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_case_options, 2), + [153] = {.entry = {.count = 1, .reusable = true}}, SHIFT(284), + [155] = {.entry = {.count = 1, .reusable = true}}, SHIFT(296), + [157] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_argument_list, 2), + [159] = {.entry = {.count = 1, .reusable = true}}, SHIFT(244), + [161] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array_members, 2), + [163] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression_list, 2), + [165] = {.entry = {.count = 1, .reusable = true}}, SHIFT(224), + [167] = {.entry = {.count = 1, .reusable = true}}, SHIFT(37), + [169] = {.entry = {.count = 1, .reusable = true}}, SHIFT(281), + [171] = {.entry = {.count = 1, .reusable = true}}, SHIFT(23), + [173] = {.entry = {.count = 1, .reusable = true}}, SHIFT(223), + [175] = {.entry = {.count = 1, .reusable = true}}, SHIFT(280), + [177] = {.entry = {.count = 1, .reusable = true}}, SHIFT(237), + [179] = {.entry = {.count = 1, .reusable = true}}, SHIFT(127), + [181] = {.entry = {.count = 1, .reusable = true}}, SHIFT(215), + [183] = {.entry = {.count = 1, .reusable = false}}, SHIFT(650), + [185] = {.entry = {.count = 1, .reusable = false}}, SHIFT(678), + [187] = {.entry = {.count = 1, .reusable = false}}, SHIFT(273), + [189] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_hex_digits_repeat1, 2), + [191] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_hex_digits_repeat1, 2), + [193] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_hex_digits_repeat1, 2), SHIFT_REPEAT(107), + [196] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_hex_digits_repeat1, 2), SHIFT_REPEAT(107), + [199] = {.entry = {.count = 1, .reusable = true}}, SHIFT(122), + [201] = {.entry = {.count = 1, .reusable = true}}, SHIFT(217), + [203] = {.entry = {.count = 1, .reusable = false}}, SHIFT(638), + [205] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_hex_digits, 1), + [207] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_hex_digits, 1), + [209] = {.entry = {.count = 1, .reusable = true}}, SHIFT(107), + [211] = {.entry = {.count = 1, .reusable = false}}, SHIFT(107), + [213] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_hex_digit, 1), + [215] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_hex_digit, 1), + [217] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_decimal_digits, 1), + [219] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_decimal_digits, 1), + [221] = {.entry = {.count = 1, .reusable = true}}, SHIFT(120), + [223] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_decimal_digits_repeat1, 2), + [225] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_decimal_digits_repeat1, 2), + [227] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_decimal_digits_repeat1, 2), SHIFT_REPEAT(120), + [230] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_hex_digits_repeat1, 2), SHIFT_REPEAT(123), + [233] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_hex_digits_repeat1, 2), SHIFT_REPEAT(123), + [236] = {.entry = {.count = 1, .reusable = true}}, SHIFT(123), + [238] = {.entry = {.count = 1, .reusable = false}}, SHIFT(123), + [240] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_decimal_digit, 1), + [242] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_decimal_digit, 1), + [244] = {.entry = {.count = 1, .reusable = true}}, SHIFT(216), + [246] = {.entry = {.count = 1, .reusable = true}}, SHIFT(31), + [248] = {.entry = {.count = 1, .reusable = true}}, SHIFT(134), + [250] = {.entry = {.count = 1, .reusable = false}}, SHIFT(259), + [252] = {.entry = {.count = 1, .reusable = false}}, SHIFT(791), + [254] = {.entry = {.count = 1, .reusable = false}}, SHIFT(792), + [256] = {.entry = {.count = 1, .reusable = true}}, SHIFT(21), + [258] = {.entry = {.count = 1, .reusable = true}}, SHIFT(359), + [260] = {.entry = {.count = 1, .reusable = true}}, SHIFT(405), + [262] = {.entry = {.count = 1, .reusable = true}}, SHIFT(486), + [264] = {.entry = {.count = 1, .reusable = false}}, SHIFT(120), + [266] = {.entry = {.count = 1, .reusable = true}}, SHIFT(485), + [268] = {.entry = {.count = 1, .reusable = true}}, SHIFT(463), + [270] = {.entry = {.count = 1, .reusable = false}}, SHIFT(793), + [272] = {.entry = {.count = 1, .reusable = false}}, SHIFT(818), + [274] = {.entry = {.count = 1, .reusable = false}}, SHIFT(794), + [276] = {.entry = {.count = 1, .reusable = false}}, SHIFT(795), + [278] = {.entry = {.count = 1, .reusable = false}}, SHIFT(796), + [280] = {.entry = {.count = 1, .reusable = false}}, SHIFT(811), + [282] = {.entry = {.count = 1, .reusable = false}}, SHIFT(744), + [284] = {.entry = {.count = 1, .reusable = false}}, SHIFT(797), + [286] = {.entry = {.count = 1, .reusable = false}}, SHIFT(798), + [288] = {.entry = {.count = 1, .reusable = true}}, SHIFT(150), + [290] = {.entry = {.count = 1, .reusable = true}}, SHIFT(54), + [292] = {.entry = {.count = 1, .reusable = true}}, SHIFT(211), + [294] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_octal_digits_repeat1, 2), + [296] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_octal_digits_repeat1, 2), + [298] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_octal_digits_repeat1, 2), SHIFT_REPEAT(139), + [301] = {.entry = {.count = 1, .reusable = true}}, SHIFT(131), + [303] = {.entry = {.count = 1, .reusable = true}}, SHIFT(144), + [305] = {.entry = {.count = 1, .reusable = false}}, SHIFT(457), + [307] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_octal_digits, 1), + [309] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_octal_digits, 1), + [311] = {.entry = {.count = 1, .reusable = true}}, SHIFT(139), + [313] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_octal_digit, 1), + [315] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_octal_digit, 1), + [317] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_integer_constant, 1), + [319] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_integer_constant, 1), + [321] = {.entry = {.count = 1, .reusable = true}}, SHIFT(260), + [323] = {.entry = {.count = 1, .reusable = true}}, SHIFT(251), + [325] = {.entry = {.count = 1, .reusable = false}}, SHIFT(385), + [327] = {.entry = {.count = 1, .reusable = false}}, SHIFT(260), + [329] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_integer_constant, 1), SHIFT(387), + [332] = {.entry = {.count = 1, .reusable = true}}, SHIFT(136), + [334] = {.entry = {.count = 1, .reusable = true}}, SHIFT(135), + [336] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_binary_digits, 1), + [338] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_binary_digits, 1), + [340] = {.entry = {.count = 1, .reusable = true}}, SHIFT(156), + [342] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_binary_digits_repeat1, 2), + [344] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_binary_digits_repeat1, 2), + [346] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_binary_digits_repeat1, 2), SHIFT_REPEAT(156), + [349] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_decimal_digits_repeat1, 2), SHIFT_REPEAT(158), + [352] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_integer_constant, 2), + [354] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_integer_constant, 2), + [356] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_binary_digit, 1), + [358] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_binary_digit, 1), + [360] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_exponent, 2), + [362] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_exponent, 2), + [364] = {.entry = {.count = 1, .reusable = true}}, SHIFT(162), + [366] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_octal_digits_repeat1, 2), SHIFT_REPEAT(162), + [369] = {.entry = {.count = 1, .reusable = true}}, SHIFT(285), + [371] = {.entry = {.count = 1, .reusable = true}}, SHIFT(288), + [373] = {.entry = {.count = 1, .reusable = false}}, SHIFT(388), + [375] = {.entry = {.count = 1, .reusable = false}}, SHIFT(285), + [377] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_integer_constant, 1), SHIFT(389), + [380] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_cases, 2), + [382] = {.entry = {.count = 1, .reusable = false}}, SHIFT(261), + [384] = {.entry = {.count = 1, .reusable = true}}, SHIFT(172), + [386] = {.entry = {.count = 1, .reusable = false}}, SHIFT(621), + [388] = {.entry = {.count = 1, .reusable = false}}, SHIFT(424), + [390] = {.entry = {.count = 1, .reusable = false}}, SHIFT(411), + [392] = {.entry = {.count = 1, .reusable = false}}, SHIFT(420), + [394] = {.entry = {.count = 1, .reusable = false}}, SHIFT(380), + [396] = {.entry = {.count = 1, .reusable = true}}, SHIFT(187), + [398] = {.entry = {.count = 1, .reusable = false}}, SHIFT(647), + [400] = {.entry = {.count = 1, .reusable = false}}, SHIFT(641), + [402] = {.entry = {.count = 1, .reusable = false}}, SHIFT(639), + [404] = {.entry = {.count = 1, .reusable = true}}, SHIFT(105), + [406] = {.entry = {.count = 1, .reusable = true}}, SHIFT(630), + [408] = {.entry = {.count = 1, .reusable = false}}, SHIFT(503), + [410] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assignment_op, 1), + [412] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assignment_op, 1), + [414] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_floating_constant, 3), + [416] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_floating_constant, 3), + [418] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_binary_digits_repeat1, 2), SHIFT_REPEAT(178), + [421] = {.entry = {.count = 1, .reusable = true}}, SHIFT(178), + [423] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tuple_types, 4), + [425] = {.entry = {.count = 1, .reusable = true}}, SHIFT(218), + [427] = {.entry = {.count = 1, .reusable = false}}, SHIFT(391), + [429] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_floating_constant, 4), + [431] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_floating_constant, 4), + [433] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_identifier, 3), + [435] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_identifier, 3), + [437] = {.entry = {.count = 1, .reusable = false}}, SHIFT(262), + [439] = {.entry = {.count = 1, .reusable = true}}, SHIFT(171), + [441] = {.entry = {.count = 1, .reusable = false}}, SHIFT(635), + [443] = {.entry = {.count = 1, .reusable = false}}, SHIFT(327), + [445] = {.entry = {.count = 1, .reusable = false}}, SHIFT(325), + [447] = {.entry = {.count = 1, .reusable = false}}, SHIFT(344), + [449] = {.entry = {.count = 1, .reusable = false}}, SHIFT(381), + [451] = {.entry = {.count = 1, .reusable = true}}, SHIFT(208), + [453] = {.entry = {.count = 1, .reusable = false}}, SHIFT(640), + [455] = {.entry = {.count = 1, .reusable = false}}, SHIFT(788), + [457] = {.entry = {.count = 1, .reusable = false}}, SHIFT(789), + [459] = {.entry = {.count = 1, .reusable = true}}, SHIFT(103), + [461] = {.entry = {.count = 1, .reusable = true}}, SHIFT(612), + [463] = {.entry = {.count = 1, .reusable = false}}, SHIFT(322), + [465] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_object_selector, 1), + [467] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_object_selector, 1), + [469] = {.entry = {.count = 1, .reusable = true}}, SHIFT(686), + [471] = {.entry = {.count = 1, .reusable = true}}, SHIFT(458), + [473] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_plain_expression, 1), + [475] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_plain_expression, 1), + [477] = {.entry = {.count = 1, .reusable = true}}, SHIFT(57), + [479] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_string_constant, 1), + [481] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_string_constant, 1), + [483] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_identifier, 1), + [485] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_identifier, 1), + [487] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_identifier, 1), SHIFT(561), + [490] = {.entry = {.count = 1, .reusable = true}}, SHIFT(674), + [492] = {.entry = {.count = 1, .reusable = true}}, SHIFT(460), + [494] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_string_constant_repeat1, 2), + [496] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_string_constant_repeat1, 2), + [498] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_string_constant_repeat1, 2), SHIFT_REPEAT(463), + [501] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_string_constant_repeat1, 3), + [503] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_string_constant_repeat1, 3), + [505] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_length_expression, 4), + [507] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_length_expression, 4), + [509] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_postfix_expression, 1), + [511] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_postfix_expression, 1), + [513] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_unary_expression, 1), + [515] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_unary_expression, 1), + [517] = {.entry = {.count = 1, .reusable = true}}, SHIFT(17), + [519] = {.entry = {.count = 1, .reusable = true}}, SHIFT(22), + [521] = {.entry = {.count = 1, .reusable = false}}, SHIFT(374), + [523] = {.entry = {.count = 1, .reusable = true}}, SHIFT(256), + [525] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_slicing_expression, 4), + [527] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_slicing_expression, 4), + [529] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array_literal, 2), + [531] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array_literal, 2), + [533] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_measurement_expression, 1), + [535] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_measurement_expression, 1), + [537] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_offset_expression, 4), + [539] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_offset_expression, 4), + [541] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assertion_expression, 4), + [543] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assertion_expression, 4), + [545] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_allocation_expression, 4), + [547] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_allocation_expression, 4), + [549] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_literal, 4), + [551] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_struct_literal, 4), + [553] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_indexing_expression, 4), + [555] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_indexing_expression, 4), + [557] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_literal, 5), + [559] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_struct_literal, 5), + [561] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_size_expression, 4), + [563] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_size_expression, 4), + [565] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assertion_expression, 5), + [567] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assertion_expression, 5), + [569] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_literal, 3), + [571] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_enum_literal, 3), + [573] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_floating_constant, 5), + [575] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_floating_constant, 5), + [577] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_slicing_expression, 5), + [579] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_slicing_expression, 5), + [581] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_allocation_expression, 6), + [583] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_allocation_expression, 6), + [585] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assertion_expression, 6), + [587] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assertion_expression, 6), + [589] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_access_expression, 3), + [591] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_field_access_expression, 3), + [593] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_nested_expression, 1), + [595] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_nested_expression, 1), + [597] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_slicing_expression, 6), + [599] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_slicing_expression, 6), + [601] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_allocation_expression, 7), + [603] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_allocation_expression, 7), + [605] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 3), + [607] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 3), + [609] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assertion_expression, 7), + [611] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assertion_expression, 7), + [613] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assertion_expression, 3), + [615] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assertion_expression, 3), + [617] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_rune_constant, 3), + [619] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_rune_constant, 3), + [621] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 4), + [623] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 4), + [625] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_floating_suffix, 1), + [627] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_floating_suffix, 1), + [629] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_integer_constant, 3), + [631] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_integer_constant, 3), + [633] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array_literal, 3), + [635] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array_literal, 3), + [637] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_nested_expression, 3), + [639] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_nested_expression, 3), + [641] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_error_propagation, 2), + [643] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_error_propagation, 2), + [645] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_floating_constant, 2), + [647] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_floating_constant, 2), + [649] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_constant, 1), + [651] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_constant, 1), + [653] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_integer_suffix, 1), + [655] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_integer_suffix, 1), + [657] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_unary_expression, 2, .production_id = 1), + [659] = {.entry = {.count = 1, .reusable = false}}, SHIFT(165), + [661] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_unary_expression, 2, .production_id = 1), + [663] = {.entry = {.count = 1, .reusable = true}}, SHIFT(165), + [665] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_unary_expression, 2, .production_id = 2), + [667] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_unary_expression, 2, .production_id = 2), + [669] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_identifier, 1), SHIFT(633), + [672] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_string_constant_repeat1, 2), SHIFT_REPEAT(462), + [675] = {.entry = {.count = 1, .reusable = false}}, SHIFT(45), + [677] = {.entry = {.count = 1, .reusable = false}}, SHIFT(55), + [679] = {.entry = {.count = 1, .reusable = true}}, SHIFT(12), + [681] = {.entry = {.count = 1, .reusable = true}}, SHIFT(30), + [683] = {.entry = {.count = 1, .reusable = true}}, SHIFT(312), + [685] = {.entry = {.count = 1, .reusable = true}}, SHIFT(24), + [687] = {.entry = {.count = 1, .reusable = false}}, SHIFT(375), + [689] = {.entry = {.count = 1, .reusable = true}}, SHIFT(585), + [691] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_slice_array_type, 3), + [693] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_slice_array_type, 3), + [695] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_unwrapped_alias, 2), + [697] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_unwrapped_alias, 2), + [699] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_integer_type, 1), + [701] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_integer_type, 1), + [703] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_alias_type, 1), + [705] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_alias_type, 1), + [707] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_scalar_type, 1), + [709] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_scalar_type, 1), + [711] = {.entry = {.count = 1, .reusable = false}}, SHIFT(46), + [713] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_prototype, 4), + [715] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_prototype, 4), + [717] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type, 1), + [719] = {.entry = {.count = 1, .reusable = false}}, SHIFT(332), + [721] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type, 1), + [723] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pointer_type, 2), + [725] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_pointer_type, 2), + [727] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type, 2), + [729] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type, 2), + [731] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_type, 3), + [733] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_type, 3), + [735] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_prototype, 3), + [737] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_prototype, 3), + [739] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tuple_type, 3), + [741] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_tuple_type, 3), + [743] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tagged_union_type, 3), + [745] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_tagged_union_type, 3), + [747] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pointer_type, 3), + [749] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_pointer_type, 3), + [751] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_type, 5), + [753] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_enum_type, 5), + [755] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_slice_array_type, 4), + [757] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_slice_array_type, 4), + [759] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_union_type, 4), + [761] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_union_type, 4), + [763] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_type, 4), + [765] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_struct_type, 4), + [767] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_storage_class, 1), + [769] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_storage_class, 1), + [771] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_type, 2), + [773] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_type, 2), + [775] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_floating_type, 1), + [777] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_floating_type, 1), + [779] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__inner_type, 2), + [781] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__inner_type, 2), + [783] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_type, 4), + [785] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_enum_type, 4), + [787] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_multiplicative_expression, 1), + [789] = {.entry = {.count = 1, .reusable = true}}, SHIFT(184), + [791] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_multiplicative_expression, 1), + [793] = {.entry = {.count = 1, .reusable = true}}, SHIFT(182), + [795] = {.entry = {.count = 1, .reusable = true}}, SHIFT(181), + [797] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_cast_expression, 1), + [799] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_cast_expression, 1), + [801] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_cast_expression, 3, .production_id = 3), + [803] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_cast_expression, 3, .production_id = 3), + [805] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_cast_expression, 3, .production_id = 4), + [807] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_cast_expression, 3, .production_id = 4), + [809] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_cast_expression, 3, .production_id = 5), + [811] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_cast_expression, 3, .production_id = 5), + [813] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_multiplicative_expression, 3), + [815] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_multiplicative_expression, 3), + [817] = {.entry = {.count = 1, .reusable = false}}, SHIFT(52), + [819] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_additive_expression, 1), + [821] = {.entry = {.count = 1, .reusable = true}}, SHIFT(126), + [823] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_additive_expression, 1), + [825] = {.entry = {.count = 1, .reusable = false}}, SHIFT(126), + [827] = {.entry = {.count = 1, .reusable = true}}, SHIFT(125), + [829] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_additive_expression, 3), + [831] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_additive_expression, 3), + [833] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_shift_expression, 3), + [835] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_shift_expression, 3), + [837] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_unit, 1), + [839] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_shift_expression, 1), + [841] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_shift_expression, 1), + [843] = {.entry = {.count = 1, .reusable = true}}, SHIFT(121), + [845] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_declarations_repeat1, 2), + [847] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_declarations_repeat1, 2), SHIFT_REPEAT(370), + [850] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_declarations_repeat1, 2), SHIFT_REPEAT(468), + [853] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_declarations_repeat1, 2), SHIFT_REPEAT(807), + [856] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_declarations_repeat1, 2), SHIFT_REPEAT(512), + [859] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_declarations_repeat1, 2), SHIFT_REPEAT(540), + [862] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_declarations_repeat1, 2), SHIFT_REPEAT(573), + [865] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_declarations_repeat1, 2), SHIFT_REPEAT(469), + [868] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_declarations_repeat1, 2), SHIFT_REPEAT(474), + [871] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_declarations, 1), + [873] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_exclusive_or_expression, 1), + [875] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_exclusive_or_expression, 1), + [877] = {.entry = {.count = 1, .reusable = false}}, SHIFT(117), + [879] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_and_expression, 3), + [881] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_and_expression, 3), + [883] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_exclusive_or_expression, 3), + [885] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_exclusive_or_expression, 3), + [887] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_and_expression, 1), + [889] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_and_expression, 1), + [891] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_inclusive_or_expression, 3), + [893] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_inclusive_or_expression, 3), + [895] = {.entry = {.count = 1, .reusable = false}}, SHIFT(116), + [897] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_inclusive_or_expression, 1), + [899] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_inclusive_or_expression, 1), + [901] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_comparison_expression, 3), + [903] = {.entry = {.count = 1, .reusable = false}}, SHIFT(113), + [905] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_comparison_expression, 3), + [907] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_comparison_expression, 1), + [909] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_comparison_expression, 1), + [911] = {.entry = {.count = 1, .reusable = true}}, SHIFT(240), + [913] = {.entry = {.count = 1, .reusable = true}}, SHIFT(291), + [915] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_equality_expression, 3), + [917] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_equality_expression, 3), + [919] = {.entry = {.count = 1, .reusable = false}}, SHIFT(112), + [921] = {.entry = {.count = 1, .reusable = true}}, SHIFT(112), + [923] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_equality_expression, 1), + [925] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_equality_expression, 1), + [927] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_imports, 1), + [929] = {.entry = {.count = 1, .reusable = true}}, SHIFT(532), + [931] = {.entry = {.count = 1, .reusable = true}}, SHIFT(411), + [933] = {.entry = {.count = 1, .reusable = true}}, SHIFT(526), + [935] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_imports_repeat1, 2), + [937] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_imports_repeat1, 2), SHIFT_REPEAT(560), + [940] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_logical_and_expression, 3), + [942] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_logical_and_expression, 3), + [944] = {.entry = {.count = 1, .reusable = true}}, SHIFT(111), + [946] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_logical_and_expression, 1), + [948] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_logical_and_expression, 1), + [950] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_use_statement, 7), + [952] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_use_statement, 5), + [954] = {.entry = {.count = 1, .reusable = true}}, SHIFT(623), + [956] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_use_statement, 3), + [958] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_logical_xor_expression, 3), + [960] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_logical_xor_expression, 3), + [962] = {.entry = {.count = 1, .reusable = true}}, SHIFT(110), + [964] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_logical_xor_expression, 1), + [966] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_logical_xor_expression, 1), + [968] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_declarations_repeat1, 3), + [970] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_logical_or_expression, 3), + [972] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_logical_or_expression, 3), + [974] = {.entry = {.count = 1, .reusable = true}}, SHIFT(109), + [976] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_logical_or_expression, 1), + [978] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_logical_or_expression, 1), + [980] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_union_fields, 2), + [982] = {.entry = {.count = 1, .reusable = true}}, SHIFT(752), + [984] = {.entry = {.count = 1, .reusable = false}}, SHIFT(492), + [986] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_fndec_attrs, 1), + [988] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression, 1), + [990] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_expression, 1), + [992] = {.entry = {.count = 1, .reusable = true}}, SHIFT(108), + [994] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_fndec_attrs_repeat1, 2), SHIFT_REPEAT(807), + [997] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_fndec_attrs_repeat1, 2), + [999] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_fndec_attrs_repeat1, 2), SHIFT_REPEAT(469), + [1002] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_fndec_attrs_repeat1, 2), SHIFT_REPEAT(474), + [1005] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_label, 2), + [1007] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_label, 2), + [1009] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_bindings, 3), + [1011] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_bindings, 3), + [1013] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_expression, 2), + [1015] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_expression, 2), + [1017] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_if_expression, 2), SHIFT(43), + [1020] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_bindings, 1), + [1022] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_bindings, 1), SHIFT(493), + [1025] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_bindings, 1), + [1027] = {.entry = {.count = 1, .reusable = true}}, SHIFT(332), + [1029] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_loop, 5), + [1031] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_loop, 5), + [1033] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_conditional_branch, 4), + [1035] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_conditional_branch, 4), + [1037] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_compound_expression, 3), + [1039] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_compound_expression, 3), + [1041] = {.entry = {.count = 1, .reusable = true}}, SHIFT(41), + [1043] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_binding_list, 2), + [1045] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_binding_list, 2), + [1047] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_binding, 5), + [1049] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_binding, 5), + [1051] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_loop, 6), + [1053] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_loop, 6), + [1055] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_expression, 7), + [1057] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_expression, 7), + [1059] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_binding_list, 3), + [1061] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_binding_list, 3), + [1063] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_binding, 3), + [1065] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_binding, 3), + [1067] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_deferred_expression, 2), + [1069] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_deferred_expression, 2), + [1071] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_control_statement, 2), + [1073] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_control_statement, 2), + [1075] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assignment, 4), + [1077] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assignment, 4), + [1079] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_expression, 4), + [1081] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_expression, 4), + [1083] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_switch_expression, 7), + [1085] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_switch_expression, 7), + [1087] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assignment, 3), + [1089] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assignment, 3), + [1091] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_identifier, 1), SHIFT(636), + [1094] = {.entry = {.count = 1, .reusable = true}}, SHIFT(718), + [1096] = {.entry = {.count = 1, .reusable = false}}, SHIFT(496), + [1098] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_bindings, 1), SHIFT(510), + [1101] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_string_chars_repeat1, 2), SHIFT_REPEAT(624), + [1104] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_string_chars_repeat1, 2), + [1106] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_string_chars_repeat1, 2), SHIFT_REPEAT(523), + [1109] = {.entry = {.count = 1, .reusable = false}}, SHIFT_EXTRA(), + [1111] = {.entry = {.count = 1, .reusable = false}}, SHIFT(624), + [1113] = {.entry = {.count = 1, .reusable = false}}, SHIFT(523), + [1115] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_string_chars, 1), + [1117] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_initializer, 2), + [1119] = {.entry = {.count = 1, .reusable = true}}, SHIFT(740), + [1121] = {.entry = {.count = 1, .reusable = true}}, SHIFT(232), + [1123] = {.entry = {.count = 1, .reusable = false}}, SHIFT(509), + [1125] = {.entry = {.count = 1, .reusable = true}}, SHIFT(786), + [1127] = {.entry = {.count = 1, .reusable = true}}, SHIFT(391), + [1129] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_fndec_attr, 1), + [1131] = {.entry = {.count = 1, .reusable = true}}, SHIFT(498), + [1133] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_decl_attr, 4), + [1135] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_fntype_attr, 1), + [1137] = {.entry = {.count = 1, .reusable = true}}, SHIFT(214), + [1139] = {.entry = {.count = 1, .reusable = false}}, SHIFT(655), + [1141] = {.entry = {.count = 1, .reusable = true}}, SHIFT(309), + [1143] = {.entry = {.count = 1, .reusable = true}}, SHIFT(206), + [1145] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_if_expression, 2), SHIFT(97), + [1148] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter_list, 2), + [1150] = {.entry = {.count = 1, .reusable = true}}, SHIFT(614), + [1152] = {.entry = {.count = 1, .reusable = true}}, SHIFT(505), + [1154] = {.entry = {.count = 1, .reusable = true}}, SHIFT(282), + [1156] = {.entry = {.count = 1, .reusable = true}}, SHIFT(226), + [1158] = {.entry = {.count = 1, .reusable = false}}, SHIFT(784), + [1160] = {.entry = {.count = 1, .reusable = false}}, SHIFT(637), + [1162] = {.entry = {.count = 1, .reusable = true}}, SHIFT(300), + [1164] = {.entry = {.count = 1, .reusable = true}}, SHIFT(229), + [1166] = {.entry = {.count = 1, .reusable = true}}, SHIFT(77), + [1168] = {.entry = {.count = 1, .reusable = true}}, SHIFT(307), + [1170] = {.entry = {.count = 1, .reusable = false}}, SHIFT(202), + [1172] = {.entry = {.count = 1, .reusable = true}}, SHIFT(545), + [1174] = {.entry = {.count = 1, .reusable = true}}, SHIFT(541), + [1176] = {.entry = {.count = 1, .reusable = true}}, SHIFT(85), + [1178] = {.entry = {.count = 1, .reusable = false}}, SHIFT(188), + [1180] = {.entry = {.count = 1, .reusable = true}}, SHIFT(248), + [1182] = {.entry = {.count = 1, .reusable = true}}, SHIFT(374), + [1184] = {.entry = {.count = 1, .reusable = true}}, SHIFT(375), + [1186] = {.entry = {.count = 1, .reusable = false}}, SHIFT(180), + [1188] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_values, 2), + [1190] = {.entry = {.count = 1, .reusable = true}}, SHIFT(530), + [1192] = {.entry = {.count = 1, .reusable = false}}, SHIFT(186), + [1194] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_bindings, 4), + [1196] = {.entry = {.count = 1, .reusable = true}}, SHIFT(495), + [1198] = {.entry = {.count = 1, .reusable = true}}, SHIFT(787), + [1200] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_tagged_types_repeat1, 2), + [1202] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_tagged_types_repeat1, 2), SHIFT_REPEAT(179), + [1205] = {.entry = {.count = 1, .reusable = true}}, SHIFT(19), + [1207] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array_members, 1), + [1209] = {.entry = {.count = 1, .reusable = true}}, SHIFT(620), + [1211] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_global_binding, 3), + [1213] = {.entry = {.count = 1, .reusable = true}}, SHIFT(96), + [1215] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameters, 3), + [1217] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_string_char, 1), + [1219] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_escape_sequence, 1), + [1221] = {.entry = {.count = 1, .reusable = true}}, SHIFT(13), + [1223] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_argument_list, 1), + [1225] = {.entry = {.count = 1, .reusable = true}}, SHIFT(605), + [1227] = {.entry = {.count = 1, .reusable = true}}, SHIFT(481), + [1229] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter_list, 1), + [1231] = {.entry = {.count = 1, .reusable = true}}, SHIFT(613), + [1233] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameters, 1), + [1235] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_global_binding, 4), + [1237] = {.entry = {.count = 1, .reusable = true}}, SHIFT(68), + [1239] = {.entry = {.count = 1, .reusable = true}}, SHIFT(70), + [1241] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_value, 1), + [1243] = {.entry = {.count = 1, .reusable = true}}, SHIFT(586), + [1245] = {.entry = {.count = 1, .reusable = true}}, SHIFT(504), + [1247] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_name_list, 2), + [1249] = {.entry = {.count = 1, .reusable = true}}, SHIFT(609), + [1251] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_named_escape, 2), + [1253] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_escape_sequence, 2), + [1255] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_binding_names, 3), + [1257] = {.entry = {.count = 1, .reusable = true}}, SHIFT(607), + [1259] = {.entry = {.count = 1, .reusable = true}}, SHIFT(74), + [1261] = {.entry = {.count = 1, .reusable = true}}, SHIFT(201), + [1263] = {.entry = {.count = 1, .reusable = true}}, SHIFT(494), + [1265] = {.entry = {.count = 1, .reusable = true}}, SHIFT(501), + [1267] = {.entry = {.count = 1, .reusable = true}}, SHIFT(99), + [1269] = {.entry = {.count = 1, .reusable = true}}, SHIFT(183), + [1271] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tagged_types, 4), + [1273] = {.entry = {.count = 1, .reusable = true}}, SHIFT(179), + [1275] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tagged_types, 3), + [1277] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter, 3), + [1279] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_offset_specifier, 4), + [1281] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_cases, 1), + [1283] = {.entry = {.count = 1, .reusable = true}}, SHIFT(164), + [1285] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_constant_binding, 5), + [1287] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_value, 3), + [1289] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_value, 3), + [1291] = {.entry = {.count = 1, .reusable = true}}, SHIFT(231), + [1293] = {.entry = {.count = 1, .reusable = true}}, SHIFT(38), + [1295] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_union_field, 4), + [1297] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_union_field, 2), + [1299] = {.entry = {.count = 1, .reusable = true}}, SHIFT(531), + [1301] = {.entry = {.count = 1, .reusable = true}}, SHIFT(197), + [1303] = {.entry = {.count = 1, .reusable = true}}, SHIFT(519), + [1305] = {.entry = {.count = 1, .reusable = true}}, SHIFT(228), + [1307] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_union_fields, 1), + [1309] = {.entry = {.count = 1, .reusable = true}}, SHIFT(404), + [1311] = {.entry = {.count = 1, .reusable = true}}, SHIFT(89), + [1313] = {.entry = {.count = 1, .reusable = true}}, SHIFT(169), + [1315] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tuple_types, 3), + [1317] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_global_binding, 6), + [1319] = {.entry = {.count = 1, .reusable = true}}, SHIFT(230), + [1321] = {.entry = {.count = 1, .reusable = true}}, SHIFT(466), + [1323] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 3), + [1325] = {.entry = {.count = 1, .reusable = true}}, SHIFT(93), + [1327] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_value, 5), + [1329] = {.entry = {.count = 1, .reusable = true}}, SHIFT(475), + [1331] = {.entry = {.count = 1, .reusable = true}}, SHIFT(95), + [1333] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_predicate, 1), + [1335] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_switch_case, 3), + [1337] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_expression, 1), SHIFT(94), + [1340] = {.entry = {.count = 1, .reusable = true}}, SHIFT(10), + [1342] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_case_options, 1), + [1344] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_switch_cases, 1), + [1346] = {.entry = {.count = 1, .reusable = true}}, SHIFT(5), + [1348] = {.entry = {.count = 1, .reusable = true}}, SHIFT(100), + [1350] = {.entry = {.count = 1, .reusable = true}}, SHIFT(29), + [1352] = {.entry = {.count = 1, .reusable = true}}, SHIFT(255), + [1354] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_union_field, 1), + [1356] = {.entry = {.count = 1, .reusable = true}}, SHIFT(40), + [1358] = {.entry = {.count = 1, .reusable = true}}, SHIFT(322), + [1360] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_global_bindings, 1), + [1362] = {.entry = {.count = 1, .reusable = true}}, SHIFT(472), + [1364] = {.entry = {.count = 1, .reusable = true}}, SHIFT(522), + [1366] = {.entry = {.count = 1, .reusable = true}}, SHIFT(294), + [1368] = {.entry = {.count = 1, .reusable = true}}, SHIFT(86), + [1370] = {.entry = {.count = 1, .reusable = true}}, SHIFT(308), + [1372] = {.entry = {.count = 1, .reusable = true}}, SHIFT(722), + [1374] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_values, 3), + [1376] = {.entry = {.count = 1, .reusable = true}}, SHIFT(392), + [1378] = {.entry = {.count = 1, .reusable = true}}, SHIFT(712), + [1380] = {.entry = {.count = 1, .reusable = true}}, SHIFT(67), + [1382] = {.entry = {.count = 1, .reusable = true}}, SHIFT(9), + [1384] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tuple_items, 3), + [1386] = {.entry = {.count = 1, .reusable = true}}, SHIFT(518), + [1388] = {.entry = {.count = 1, .reusable = true}}, SHIFT(234), + [1390] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_value, 1), + [1392] = {.entry = {.count = 1, .reusable = true}}, SHIFT(477), + [1394] = {.entry = {.count = 1, .reusable = true}}, SHIFT(176), + [1396] = {.entry = {.count = 1, .reusable = true}}, SHIFT(198), + [1398] = {.entry = {.count = 1, .reusable = true}}, SHIFT(745), + [1400] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_values, 1), + [1402] = {.entry = {.count = 1, .reusable = true}}, SHIFT(539), + [1404] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_name_list, 1), + [1406] = {.entry = {.count = 1, .reusable = true}}, SHIFT(536), + [1408] = {.entry = {.count = 1, .reusable = true}}, SHIFT(62), + [1410] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_predicate, 3, .production_id = 6), + [1412] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 4), + [1414] = {.entry = {.count = 1, .reusable = true}}, SHIFT(64), + [1416] = {.entry = {.count = 1, .reusable = true}}, SHIFT(766), + [1418] = {.entry = {.count = 1, .reusable = true}}, SHIFT(814), + [1420] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter_list, 3), + [1422] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_global_binding, 5), + [1424] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_bindings, 3), + [1426] = {.entry = {.count = 1, .reusable = true}}, SHIFT(513), + [1428] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_values, 1), + [1430] = {.entry = {.count = 1, .reusable = true}}, SHIFT(506), + [1432] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_constant_bindings, 1), + [1434] = {.entry = {.count = 1, .reusable = true}}, SHIFT(511), + [1436] = {.entry = {.count = 1, .reusable = true}}, SHIFT(317), + [1438] = {.entry = {.count = 1, .reusable = true}}, SHIFT(777), + [1440] = {.entry = {.count = 1, .reusable = true}}, SHIFT(8), + [1442] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_append_values, 1), + [1444] = {.entry = {.count = 1, .reusable = true}}, SHIFT(538), + [1446] = {.entry = {.count = 1, .reusable = true}}, SHIFT(537), + [1448] = {.entry = {.count = 1, .reusable = true}}, SHIFT(542), + [1450] = {.entry = {.count = 1, .reusable = true}}, SHIFT(310), + [1452] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_case, 5), + [1454] = {.entry = {.count = 1, .reusable = true}}, SHIFT(290), + [1456] = {.entry = {.count = 1, .reusable = true}}, SHIFT(476), + [1458] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_union_field, 3), + [1460] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_initializer, 1), + [1462] = {.entry = {.count = 1, .reusable = true}}, SHIFT(465), + [1464] = {.entry = {.count = 1, .reusable = true}}, SHIFT(273), + [1466] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_case, 3), + [1468] = {.entry = {.count = 1, .reusable = true}}, SHIFT(457), + [1470] = {.entry = {.count = 1, .reusable = true}}, SHIFT(695), + [1472] = {.entry = {.count = 1, .reusable = true}}, SHIFT(694), + [1474] = {.entry = {.count = 1, .reusable = true}}, SHIFT(413), + [1476] = {.entry = {.count = 1, .reusable = true}}, SHIFT(207), + [1478] = {.entry = {.count = 1, .reusable = true}}, SHIFT(407), + [1480] = {.entry = {.count = 1, .reusable = true}}, SHIFT(699), + [1482] = {.entry = {.count = 1, .reusable = true}}, SHIFT(209), + [1484] = {.entry = {.count = 1, .reusable = true}}, SHIFT(210), + [1486] = {.entry = {.count = 1, .reusable = true}}, SHIFT(335), + [1488] = {.entry = {.count = 1, .reusable = true}}, SHIFT(336), + [1490] = {.entry = {.count = 1, .reusable = true}}, SHIFT(213), + [1492] = {.entry = {.count = 1, .reusable = true}}, SHIFT(154), + [1494] = {.entry = {.count = 1, .reusable = true}}, SHIFT(593), + [1496] = {.entry = {.count = 1, .reusable = true}}, SHIFT(277), + [1498] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_constant_bindings, 3), + [1500] = {.entry = {.count = 1, .reusable = true}}, SHIFT(90), + [1502] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_global_bindings, 3), + [1504] = {.entry = {.count = 1, .reusable = true}}, SHIFT(200), + [1506] = {.entry = {.count = 1, .reusable = true}}, SHIFT(205), + [1508] = {.entry = {.count = 1, .reusable = true}}, SHIFT(735), + [1510] = {.entry = {.count = 1, .reusable = true}}, SHIFT(421), + [1512] = {.entry = {.count = 1, .reusable = true}}, SHIFT(423), + [1514] = {.entry = {.count = 1, .reusable = true}}, SHIFT(534), + [1516] = {.entry = {.count = 1, .reusable = true}}, SHIFT(190), + [1518] = {.entry = {.count = 1, .reusable = true}}, SHIFT(473), + [1520] = {.entry = {.count = 1, .reusable = true}}, SHIFT(33), + [1522] = {.entry = {.count = 1, .reusable = true}}, SHIFT(346), + [1524] = {.entry = {.count = 1, .reusable = true}}, SHIFT(341), + [1526] = {.entry = {.count = 1, .reusable = true}}, SHIFT(340), + [1528] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6), + [1530] = {.entry = {.count = 1, .reusable = true}}, SHIFT(254), + [1532] = {.entry = {.count = 1, .reusable = true}}, SHIFT(249), + [1534] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_name_list, 3), + [1536] = {.entry = {.count = 1, .reusable = true}}, SHIFT(82), + [1538] = {.entry = {.count = 1, .reusable = true}}, SHIFT(390), + [1540] = {.entry = {.count = 1, .reusable = true}}, SHIFT(235), + [1542] = {.entry = {.count = 1, .reusable = true}}, SHIFT(142), + [1544] = {.entry = {.count = 1, .reusable = true}}, SHIFT(81), + [1546] = {.entry = {.count = 1, .reusable = true}}, SHIFT(80), + [1548] = {.entry = {.count = 1, .reusable = true}}, SHIFT(491), + [1550] = {.entry = {.count = 1, .reusable = true}}, SHIFT(338), + [1552] = {.entry = {.count = 1, .reusable = true}}, SHIFT(233), + [1554] = {.entry = {.count = 1, .reusable = true}}, SHIFT(75), + [1556] = {.entry = {.count = 1, .reusable = true}}, SHIFT(155), + [1558] = {.entry = {.count = 1, .reusable = true}}, SHIFT(287), + [1560] = {.entry = {.count = 1, .reusable = true}}, SHIFT(219), + [1562] = {.entry = {.count = 1, .reusable = true}}, SHIFT(26), + [1564] = {.entry = {.count = 1, .reusable = true}}, SHIFT(250), + [1566] = {.entry = {.count = 1, .reusable = true}}, SHIFT(456), + [1568] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_bindings, 5), + [1570] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_named_escape, 2), + [1572] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_escape_sequence, 2), + [1574] = {.entry = {.count = 1, .reusable = true}}, SHIFT(471), + [1576] = {.entry = {.count = 1, .reusable = true}}, SHIFT(84), + [1578] = {.entry = {.count = 1, .reusable = true}}, SHIFT(292), + [1580] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_escape_sequence, 1), + [1582] = {.entry = {.count = 1, .reusable = true}}, SHIFT(79), + [1584] = {.entry = {.count = 1, .reusable = true}}, SHIFT(196), + [1586] = {.entry = {.count = 1, .reusable = true}}, SHIFT(78), + [1588] = {.entry = {.count = 1, .reusable = true}}, SHIFT(238), + [1590] = {.entry = {.count = 1, .reusable = true}}, SHIFT(239), + [1592] = {.entry = {.count = 1, .reusable = true}}, SHIFT(242), + [1594] = {.entry = {.count = 1, .reusable = true}}, SHIFT(415), + [1596] = {.entry = {.count = 1, .reusable = true}}, SHIFT(243), + [1598] = {.entry = {.count = 1, .reusable = true}}, SHIFT(245), + [1600] = {.entry = {.count = 1, .reusable = true}}, SHIFT(594), + [1602] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_cases, 3), + [1604] = {.entry = {.count = 1, .reusable = true}}, SHIFT(60), + [1606] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_case_options, 3), + [1608] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_switch_cases, 3), + [1610] = {.entry = {.count = 1, .reusable = true}}, SHIFT(20), + [1612] = {.entry = {.count = 1, .reusable = true}}, SHIFT(83), + [1614] = {.entry = {.count = 1, .reusable = true}}, SHIFT(88), + [1616] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_predicate, 5), + [1618] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_append_values, 3), + [1620] = {.entry = {.count = 1, .reusable = true}}, SHIFT(439), + [1622] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_unit, 2), + [1624] = {.entry = {.count = 1, .reusable = true}}, SHIFT(446), + [1626] = {.entry = {.count = 1, .reusable = true}}, SHIFT(72), + [1628] = {.entry = {.count = 1, .reusable = true}}, SHIFT(53), + [1630] = {.entry = {.count = 1, .reusable = true}}, SHIFT(663), + [1632] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 5), + [1634] = {.entry = {.count = 1, .reusable = true}}, SHIFT(319), + [1636] = {.entry = {.count = 1, .reusable = true}}, SHIFT(318), + [1638] = {.entry = {.count = 1, .reusable = true}}, SHIFT(16), + [1640] = {.entry = {.count = 1, .reusable = true}}, SHIFT(386), + [1642] = {.entry = {.count = 1, .reusable = true}}, SHIFT(194), + [1644] = {.entry = {.count = 1, .reusable = true}}, SHIFT(603), + [1646] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_predicate, 3, .production_id = 7), + [1648] = {.entry = {.count = 1, .reusable = true}}, SHIFT(448), + [1650] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_initializer, 3), + [1652] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 2), + [1654] = {.entry = {.count = 1, .reusable = true}}, SHIFT(191), + [1656] = {.entry = {.count = 1, .reusable = true}}, SHIFT(279), + [1658] = {.entry = {.count = 1, .reusable = true}}, SHIFT(499), + [1660] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_argument_list, 3), + [1662] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_constant_declaration, 2), + [1664] = {.entry = {.count = 1, .reusable = true}}, SHIFT(316), + [1666] = {.entry = {.count = 1, .reusable = true}}, SHIFT(431), + [1668] = {.entry = {.count = 1, .reusable = true}}, SHIFT(314), + [1670] = {.entry = {.count = 1, .reusable = true}}, SHIFT(65), + [1672] = {.entry = {.count = 1, .reusable = true}}, SHIFT(61), + [1674] = {.entry = {.count = 1, .reusable = true}}, SHIFT(66), + [1676] = {.entry = {.count = 1, .reusable = true}}, SHIFT(189), + [1678] = {.entry = {.count = 1, .reusable = true}}, SHIFT(170), + [1680] = {.entry = {.count = 1, .reusable = true}}, SHIFT(7), + [1682] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_global_declaration, 2), + [1684] = {.entry = {.count = 1, .reusable = true}}, SHIFT(449), + [1686] = {.entry = {.count = 1, .reusable = true}}, SHIFT(399), + [1688] = {.entry = {.count = 1, .reusable = true}}, SHIFT(102), + [1690] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression_list, 3), + [1692] = {.entry = {.count = 1, .reusable = true}}, SHIFT(455), + [1694] = {.entry = {.count = 1, .reusable = true}}, SHIFT(295), + [1696] = {.entry = {.count = 1, .reusable = true}}, SHIFT(49), + [1698] = {.entry = {.count = 1, .reusable = true}}, SHIFT(48), + [1700] = {.entry = {.count = 1, .reusable = true}}, SHIFT(562), + [1702] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_declaration, 1), + [1704] = {.entry = {.count = 1, .reusable = true}}, SHIFT(396), + [1706] = {.entry = {.count = 1, .reusable = true}}, SHIFT(306), + [1708] = {.entry = {.count = 1, .reusable = true}}, SHIFT(47), + [1710] = {.entry = {.count = 1, .reusable = true}}, SHIFT(18), + [1712] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array_members, 3), + [1714] = {.entry = {.count = 1, .reusable = true}}, SHIFT(321), + [1716] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_union_fields, 3), + [1718] = {.entry = {.count = 1, .reusable = true}}, SHIFT(551), + [1720] = {.entry = {.count = 1, .reusable = true}}, ACCEPT_INPUT(), + [1722] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_values, 3), + [1724] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_rune, 1), + [1726] = {.entry = {.count = 1, .reusable = true}}, SHIFT(315), + [1728] = {.entry = {.count = 1, .reusable = true}}, SHIFT(533), + [1730] = {.entry = {.count = 1, .reusable = true}}, SHIFT(71), + [1732] = {.entry = {.count = 1, .reusable = true}}, SHIFT(410), + [1734] = {.entry = {.count = 1, .reusable = true}}, SHIFT(409), + [1736] = {.entry = {.count = 1, .reusable = true}}, SHIFT(547), + [1738] = {.entry = {.count = 1, .reusable = true}}, SHIFT(203), + [1740] = {.entry = {.count = 1, .reusable = true}}, SHIFT(478), + [1742] = {.entry = {.count = 1, .reusable = true}}, SHIFT(63), + [1744] = {.entry = {.count = 1, .reusable = true}}, SHIFT(69), + [1746] = {.entry = {.count = 1, .reusable = true}}, SHIFT(152), + [1748] = {.entry = {.count = 1, .reusable = true}}, SHIFT(42), + [1750] = {.entry = {.count = 1, .reusable = true}}, SHIFT(73), + [1752] = {.entry = {.count = 1, .reusable = true}}, SHIFT(151), + [1754] = {.entry = {.count = 1, .reusable = true}}, SHIFT(755), + [1756] = {.entry = {.count = 1, .reusable = true}}, SHIFT(756), + [1758] = {.entry = {.count = 1, .reusable = true}}, SHIFT(32), + [1760] = {.entry = {.count = 1, .reusable = true}}, SHIFT(87), + [1762] = {.entry = {.count = 1, .reusable = true}}, SHIFT(92), + [1764] = {.entry = {.count = 1, .reusable = true}}, SHIFT(91), + [1766] = {.entry = {.count = 1, .reusable = true}}, SHIFT(34), + [1768] = {.entry = {.count = 1, .reusable = true}}, SHIFT(15), + [1770] = {.entry = {.count = 1, .reusable = true}}, SHIFT(548), + [1772] = {.entry = {.count = 1, .reusable = true}}, SHIFT(14), + [1774] = {.entry = {.count = 1, .reusable = true}}, SHIFT(35), + [1776] = {.entry = {.count = 1, .reusable = true}}, SHIFT(36), + [1778] = {.entry = {.count = 1, .reusable = true}}, SHIFT(802), + [1780] = {.entry = {.count = 1, .reusable = true}}, SHIFT(39), + [1782] = {.entry = {.count = 1, .reusable = true}}, SHIFT(805), + [1784] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter_list, 4), + [1786] = {.entry = {.count = 1, .reusable = true}}, SHIFT(25), + [1788] = {.entry = {.count = 1, .reusable = true}}, SHIFT(810), + [1790] = {.entry = {.count = 1, .reusable = true}}, SHIFT(141), + [1792] = {.entry = {.count = 1, .reusable = true}}, SHIFT(815), +}; + +#ifdef __cplusplus +extern "C" { +#endif +#ifdef _WIN32 +#define extern __declspec(dllexport) +#endif + +extern const TSLanguage *tree_sitter_hare(void) { + static TSLanguage language = { + .version = LANGUAGE_VERSION, + .symbol_count = SYMBOL_COUNT, + .alias_count = ALIAS_COUNT, + .token_count = TOKEN_COUNT, + .external_token_count = EXTERNAL_TOKEN_COUNT, + .state_count = STATE_COUNT, + .large_state_count = LARGE_STATE_COUNT, + .production_id_count = PRODUCTION_ID_COUNT, + .field_count = FIELD_COUNT, + .max_alias_sequence_length = MAX_ALIAS_SEQUENCE_LENGTH, + .parse_table = (const uint16_t *)ts_parse_table, + .small_parse_table = (const uint16_t *)ts_small_parse_table, + .small_parse_table_map = (const uint32_t *)ts_small_parse_table_map, + .parse_actions = ts_parse_actions, + .symbol_names = ts_symbol_names, + .field_names = ts_field_names, + .field_map_slices = (const TSFieldMapSlice *)ts_field_map_slices, + .field_map_entries = (const TSFieldMapEntry *)ts_field_map_entries, + .symbol_metadata = ts_symbol_metadata, + .public_symbol_map = ts_symbol_map, + .alias_map = ts_non_terminal_alias_map, + .alias_sequences = (const TSSymbol *)ts_alias_sequences, + .lex_modes = ts_lex_modes, + .lex_fn = ts_lex, + }; + return &language; +} +#ifdef __cplusplus +} +#endif diff --git a/src/tree_sitter/parser.h b/src/tree_sitter/parser.h new file mode 100644 index 000000000..a3a87bd1d --- /dev/null +++ b/src/tree_sitter/parser.h @@ -0,0 +1,223 @@ +#ifndef TREE_SITTER_PARSER_H_ +#define TREE_SITTER_PARSER_H_ + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include +#include + +#define ts_builtin_sym_error ((TSSymbol)-1) +#define ts_builtin_sym_end 0 +#define TREE_SITTER_SERIALIZATION_BUFFER_SIZE 1024 + +typedef uint16_t TSStateId; + +#ifndef TREE_SITTER_API_H_ +typedef uint16_t TSSymbol; +typedef uint16_t TSFieldId; +typedef struct TSLanguage TSLanguage; +#endif + +typedef struct { + TSFieldId field_id; + uint8_t child_index; + bool inherited; +} TSFieldMapEntry; + +typedef struct { + uint16_t index; + uint16_t length; +} TSFieldMapSlice; + +typedef struct { + bool visible; + bool named; + bool supertype; +} TSSymbolMetadata; + +typedef struct TSLexer TSLexer; + +struct TSLexer { + int32_t lookahead; + TSSymbol result_symbol; + void (*advance)(TSLexer *, bool); + void (*mark_end)(TSLexer *); + uint32_t (*get_column)(TSLexer *); + bool (*is_at_included_range_start)(const TSLexer *); + bool (*eof)(const TSLexer *); +}; + +typedef enum { + TSParseActionTypeShift, + TSParseActionTypeReduce, + TSParseActionTypeAccept, + TSParseActionTypeRecover, +} TSParseActionType; + +typedef union { + struct { + uint8_t type; + TSStateId state; + bool extra; + bool repetition; + } shift; + struct { + uint8_t type; + uint8_t child_count; + TSSymbol symbol; + int16_t dynamic_precedence; + uint16_t production_id; + } reduce; + uint8_t type; +} TSParseAction; + +typedef struct { + uint16_t lex_state; + uint16_t external_lex_state; +} TSLexMode; + +typedef union { + TSParseAction action; + struct { + uint8_t count; + bool reusable; + } entry; +} TSParseActionEntry; + +struct TSLanguage { + uint32_t version; + uint32_t symbol_count; + uint32_t alias_count; + uint32_t token_count; + uint32_t external_token_count; + uint32_t state_count; + uint32_t large_state_count; + uint32_t production_id_count; + uint32_t field_count; + uint16_t max_alias_sequence_length; + const uint16_t *parse_table; + const uint16_t *small_parse_table; + const uint32_t *small_parse_table_map; + const TSParseActionEntry *parse_actions; + const char **symbol_names; + const char **field_names; + const TSFieldMapSlice *field_map_slices; + const TSFieldMapEntry *field_map_entries; + const TSSymbolMetadata *symbol_metadata; + const TSSymbol *public_symbol_map; + const uint16_t *alias_map; + const TSSymbol *alias_sequences; + const TSLexMode *lex_modes; + bool (*lex_fn)(TSLexer *, TSStateId); + bool (*keyword_lex_fn)(TSLexer *, TSStateId); + TSSymbol keyword_capture_token; + struct { + const bool *states; + const TSSymbol *symbol_map; + void *(*create)(void); + void (*destroy)(void *); + bool (*scan)(void *, TSLexer *, const bool *symbol_whitelist); + unsigned (*serialize)(void *, char *); + void (*deserialize)(void *, const char *, unsigned); + } external_scanner; +}; + +/* + * Lexer Macros + */ + +#define START_LEXER() \ + bool result = false; \ + bool skip = false; \ + bool eof = false; \ + int32_t lookahead; \ + goto start; \ + next_state: \ + lexer->advance(lexer, skip); \ + start: \ + skip = false; \ + lookahead = lexer->lookahead; + +#define ADVANCE(state_value) \ + { \ + state = state_value; \ + goto next_state; \ + } + +#define SKIP(state_value) \ + { \ + skip = true; \ + state = state_value; \ + goto next_state; \ + } + +#define ACCEPT_TOKEN(symbol_value) \ + result = true; \ + lexer->result_symbol = symbol_value; \ + lexer->mark_end(lexer); + +#define END_STATE() return result; + +/* + * Parse Table Macros + */ + +#define SMALL_STATE(id) id - LARGE_STATE_COUNT + +#define STATE(id) id + +#define ACTIONS(id) id + +#define SHIFT(state_value) \ + {{ \ + .shift = { \ + .type = TSParseActionTypeShift, \ + .state = state_value \ + } \ + }} + +#define SHIFT_REPEAT(state_value) \ + {{ \ + .shift = { \ + .type = TSParseActionTypeShift, \ + .state = state_value, \ + .repetition = true \ + } \ + }} + +#define SHIFT_EXTRA() \ + {{ \ + .shift = { \ + .type = TSParseActionTypeShift, \ + .extra = true \ + } \ + }} + +#define REDUCE(symbol_val, child_count_val, ...) \ + {{ \ + .reduce = { \ + .type = TSParseActionTypeReduce, \ + .symbol = symbol_val, \ + .child_count = child_count_val, \ + __VA_ARGS__ \ + }, \ + }} + +#define RECOVER() \ + {{ \ + .type = TSParseActionTypeRecover \ + }} + +#define ACCEPT_INPUT() \ + {{ \ + .type = TSParseActionTypeAccept \ + }} + +#ifdef __cplusplus +} +#endif + +#endif // TREE_SITTER_PARSER_H_ From 83a6feee4fbe7c0b571b97d0e55bc6efb0eb802d Mon Sep 17 00:00:00 2001 From: ecmma Date: Thu, 8 Apr 2021 22:40:18 +0200 Subject: [PATCH 2/9] added license --- COPYING | 674 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 674 insertions(+) create mode 100644 COPYING diff --git a/COPYING b/COPYING new file mode 100644 index 000000000..73dc198f9 --- /dev/null +++ b/COPYING @@ -0,0 +1,674 @@ + GNU GENERAL PUBLIC LICENSE + Version 3, 29 June 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU General Public License is a free, copyleft license for +software and other kinds of works. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +the GNU General Public License is intended to guarantee your freedom to +share and change all versions of a program--to make sure it remains free +software for all its users. We, the Free Software Foundation, use the +GNU General Public License for most of our software; it applies also to +any other work released this way by its authors. You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +them if you wish), that you receive source code or can get it if you +want it, that you can change the software or use pieces of it in new +free programs, and that you know you can do these things. + + To protect your rights, we need to prevent others from denying you +these rights or asking you to surrender the rights. Therefore, you have +certain responsibilities if you distribute copies of the software, or if +you modify it: responsibilities to respect the freedom of others. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must pass on to the recipients the same +freedoms that you received. You must make sure that they, too, receive +or can get the source code. And you must show them these terms so they +know their rights. + + Developers that use the GNU GPL protect your rights with two steps: +(1) assert copyright on the software, and (2) offer you this License +giving you legal permission to copy, distribute and/or modify it. + + For the developers' and authors' protection, the GPL clearly explains +that there is no warranty for this free software. For both users' and +authors' sake, the GPL requires that modified versions be marked as +changed, so that their problems will not be attributed erroneously to +authors of previous versions. + + Some devices are designed to deny users access to install or run +modified versions of the software inside them, although the manufacturer +can do so. This is fundamentally incompatible with the aim of +protecting users' freedom to change the software. The systematic +pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we +have designed this version of the GPL to prohibit the practice for those +products. If such problems arise substantially in other domains, we +stand ready to extend this provision to those domains in future versions +of the GPL, as needed to protect the freedom of users. + + Finally, every program is threatened constantly by software patents. +States should not allow patents to restrict development and use of +software on general-purpose computers, but in those that do, we wish to +avoid the special danger that patents applied to a free program could +make it effectively proprietary. To prevent this, the GPL assures that +patents cannot be used to render the program non-free. + + The precise terms and conditions for copying, distribution and +modification follow. + + TERMS AND CONDITIONS + + 0. Definitions. + + "This License" refers to version 3 of the GNU General Public License. + + "Copyright" also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + + "The Program" refers to any copyrightable work licensed under this +License. Each licensee is addressed as "you". "Licensees" and +"recipients" may be individuals or organizations. + + To "modify" a work means to copy from or adapt all or part of the work +in a fashion requiring copyright permission, other than the making of an +exact copy. The resulting work is called a "modified version" of the +earlier work or a work "based on" the earlier work. + + A "covered work" means either the unmodified Program or a work based +on the Program. + + To "propagate" a work means to do anything with it that, without +permission, would make you directly or secondarily liable for +infringement under applicable copyright law, except executing it on a +computer or modifying a private copy. Propagation includes copying, +distribution (with or without modification), making available to the +public, and in some countries other activities as well. + + To "convey" a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through +a computer network, with no transfer of a copy, is not conveying. + + An interactive user interface displays "Appropriate Legal Notices" +to the extent that it includes a convenient and prominently visible +feature that (1) displays an appropriate copyright notice, and (2) +tells the user that there is no warranty for the work (except to the +extent that warranties are provided), that licensees may convey the +work under this License, and how to view a copy of this License. If +the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + + 1. Source Code. + + The "source code" for a work means the preferred form of the work +for making modifications to it. "Object code" means any non-source +form of a work. + + A "Standard Interface" means an interface that either is an official +standard defined by a recognized standards body, or, in the case of +interfaces specified for a particular programming language, one that +is widely used among developers working in that language. + + The "System Libraries" of an executable work include anything, other +than the work as a whole, that (a) is included in the normal form of +packaging a Major Component, but which is not part of that Major +Component, and (b) serves only to enable use of the work with that +Major Component, or to implement a Standard Interface for which an +implementation is available to the public in source code form. A +"Major Component", in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system +(if any) on which the executable work runs, or a compiler used to +produce the work, or an object code interpreter used to run it. + + The "Corresponding Source" for a work in object code form means all +the source code needed to generate, install, and (for an executable +work) run the object code and to modify the work, including scripts to +control those activities. However, it does not include the work's +System Libraries, or general-purpose tools or generally available free +programs which are used unmodified in performing those activities but +which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for +the work, and the source code for shared libraries and dynamically +linked subprograms that the work is specifically designed to require, +such as by intimate data communication or control flow between those +subprograms and other parts of the work. + + The Corresponding Source need not include anything that users +can regenerate automatically from other parts of the Corresponding +Source. + + The Corresponding Source for a work in source code form is that +same work. + + 2. Basic Permissions. + + All rights granted under this License are granted for the term of +copyright on the Program, and are irrevocable provided the stated +conditions are met. This License explicitly affirms your unlimited +permission to run the unmodified Program. The output from running a +covered work is covered by this License only if the output, given its +content, constitutes a covered work. This License acknowledges your +rights of fair use or other equivalent, as provided by copyright law. + + You may make, run and propagate covered works that you do not +convey, without conditions so long as your license otherwise remains +in force. You may convey covered works to others for the sole purpose +of having them make modifications exclusively for you, or provide you +with facilities for running those works, provided that you comply with +the terms of this License in conveying all material for which you do +not control copyright. Those thus making or running the covered works +for you must do so exclusively on your behalf, under your direction +and control, on terms that prohibit them from making any copies of +your copyrighted material outside their relationship with you. + + Conveying under any other circumstances is permitted solely under +the conditions stated below. Sublicensing is not allowed; section 10 +makes it unnecessary. + + 3. Protecting Users' Legal Rights From Anti-Circumvention Law. + + No covered work shall be deemed part of an effective technological +measure under any applicable law fulfilling obligations under article +11 of the WIPO copyright treaty adopted on 20 December 1996, or +similar laws prohibiting or restricting circumvention of such +measures. + + When you convey a covered work, you waive any legal power to forbid +circumvention of technological measures to the extent such circumvention +is effected by exercising rights under this License with respect to +the covered work, and you disclaim any intention to limit operation or +modification of the work as a means of enforcing, against the work's +users, your or third parties' legal rights to forbid circumvention of +technological measures. + + 4. Conveying Verbatim Copies. + + You may convey verbatim copies of the Program's source code as you +receive it, in any medium, provided that you conspicuously and +appropriately publish on each copy an appropriate copyright notice; +keep intact all notices stating that this License and any +non-permissive terms added in accord with section 7 apply to the code; +keep intact all notices of the absence of any warranty; and give all +recipients a copy of this License along with the Program. + + You may charge any price or no price for each copy that you convey, +and you may offer support or warranty protection for a fee. + + 5. Conveying Modified Source Versions. + + You may convey a work based on the Program, or the modifications to +produce it from the Program, in the form of source code under the +terms of section 4, provided that you also meet all of these conditions: + + a) The work must carry prominent notices stating that you modified + it, and giving a relevant date. + + b) The work must carry prominent notices stating that it is + released under this License and any conditions added under section + 7. This requirement modifies the requirement in section 4 to + "keep intact all notices". + + c) You must license the entire work, as a whole, under this + License to anyone who comes into possession of a copy. This + License will therefore apply, along with any applicable section 7 + additional terms, to the whole of the work, and all its parts, + regardless of how they are packaged. This License gives no + permission to license the work in any other way, but it does not + invalidate such permission if you have separately received it. + + d) If the work has interactive user interfaces, each must display + Appropriate Legal Notices; however, if the Program has interactive + interfaces that do not display Appropriate Legal Notices, your + work need not make them do so. + + A compilation of a covered work with other separate and independent +works, which are not by their nature extensions of the covered work, +and which are not combined with it such as to form a larger program, +in or on a volume of a storage or distribution medium, is called an +"aggregate" if the compilation and its resulting copyright are not +used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work +in an aggregate does not cause this License to apply to the other +parts of the aggregate. + + 6. Conveying Non-Source Forms. + + You may convey a covered work in object code form under the terms +of sections 4 and 5, provided that you also convey the +machine-readable Corresponding Source under the terms of this License, +in one of these ways: + + a) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by the + Corresponding Source fixed on a durable physical medium + customarily used for software interchange. + + b) Convey the object code in, or embodied in, a physical product + (including a physical distribution medium), accompanied by a + written offer, valid for at least three years and valid for as + long as you offer spare parts or customer support for that product + model, to give anyone who possesses the object code either (1) a + copy of the Corresponding Source for all the software in the + product that is covered by this License, on a durable physical + medium customarily used for software interchange, for a price no + more than your reasonable cost of physically performing this + conveying of source, or (2) access to copy the + Corresponding Source from a network server at no charge. + + c) Convey individual copies of the object code with a copy of the + written offer to provide the Corresponding Source. This + alternative is allowed only occasionally and noncommercially, and + only if you received the object code with such an offer, in accord + with subsection 6b. + + d) Convey the object code by offering access from a designated + place (gratis or for a charge), and offer equivalent access to the + Corresponding Source in the same way through the same place at no + further charge. You need not require recipients to copy the + Corresponding Source along with the object code. If the place to + copy the object code is a network server, the Corresponding Source + may be on a different server (operated by you or a third party) + that supports equivalent copying facilities, provided you maintain + clear directions next to the object code saying where to find the + Corresponding Source. Regardless of what server hosts the + Corresponding Source, you remain obligated to ensure that it is + available for as long as needed to satisfy these requirements. + + e) Convey the object code using peer-to-peer transmission, provided + you inform other peers where the object code and Corresponding + Source of the work are being offered to the general public at no + charge under subsection 6d. + + A separable portion of the object code, whose source code is excluded +from the Corresponding Source as a System Library, need not be +included in conveying the object code work. + + A "User Product" is either (1) a "consumer product", which means any +tangible personal property which is normally used for personal, family, +or household purposes, or (2) anything designed or sold for incorporation +into a dwelling. In determining whether a product is a consumer product, +doubtful cases shall be resolved in favor of coverage. For a particular +product received by a particular user, "normally used" refers to a +typical or common use of that class of product, regardless of the status +of the particular user or of the way in which the particular user +actually uses, or expects or is expected to use, the product. A product +is a consumer product regardless of whether the product has substantial +commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + + "Installation Information" for a User Product means any methods, +procedures, authorization keys, or other information required to install +and execute modified versions of a covered work in that User Product from +a modified version of its Corresponding Source. The information must +suffice to ensure that the continued functioning of the modified object +code is in no case prevented or interfered with solely because +modification has been made. + + If you convey an object code work under this section in, or with, or +specifically for use in, a User Product, and the conveying occurs as +part of a transaction in which the right of possession and use of the +User Product is transferred to the recipient in perpetuity or for a +fixed term (regardless of how the transaction is characterized), the +Corresponding Source conveyed under this section must be accompanied +by the Installation Information. But this requirement does not apply +if neither you nor any third party retains the ability to install +modified object code on the User Product (for example, the work has +been installed in ROM). + + The requirement to provide Installation Information does not include a +requirement to continue to provide support service, warranty, or updates +for a work that has been modified or installed by the recipient, or for +the User Product in which it has been modified or installed. Access to a +network may be denied when the modification itself materially and +adversely affects the operation of the network or violates the rules and +protocols for communication across the network. + + Corresponding Source conveyed, and Installation Information provided, +in accord with this section must be in a format that is publicly +documented (and with an implementation available to the public in +source code form), and must require no special password or key for +unpacking, reading or copying. + + 7. Additional Terms. + + "Additional permissions" are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. +Additional permissions that are applicable to the entire Program shall +be treated as though they were included in this License, to the extent +that they are valid under applicable law. If additional permissions +apply only to part of the Program, that part may be used separately +under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + + When you convey a copy of a covered work, you may at your option +remove any additional permissions from that copy, or from any part of +it. (Additional permissions may be written to require their own +removal in certain cases when you modify the work.) You may place +additional permissions on material, added by you to a covered work, +for which you have or can give appropriate copyright permission. + + Notwithstanding any other provision of this License, for material you +add to a covered work, you may (if authorized by the copyright holders of +that material) supplement the terms of this License with terms: + + a) Disclaiming warranty or limiting liability differently from the + terms of sections 15 and 16 of this License; or + + b) Requiring preservation of specified reasonable legal notices or + author attributions in that material or in the Appropriate Legal + Notices displayed by works containing it; or + + c) Prohibiting misrepresentation of the origin of that material, or + requiring that modified versions of such material be marked in + reasonable ways as different from the original version; or + + d) Limiting the use for publicity purposes of names of licensors or + authors of the material; or + + e) Declining to grant rights under trademark law for use of some + trade names, trademarks, or service marks; or + + f) Requiring indemnification of licensors and authors of that + material by anyone who conveys the material (or modified versions of + it) with contractual assumptions of liability to the recipient, for + any liability that these contractual assumptions directly impose on + those licensors and authors. + + All other non-permissive additional terms are considered "further +restrictions" within the meaning of section 10. If the Program as you +received it, or any part of it, contains a notice stating that it is +governed by this License along with a term that is a further +restriction, you may remove that term. If a license document contains +a further restriction but permits relicensing or conveying under this +License, you may add to a covered work material governed by the terms +of that license document, provided that the further restriction does +not survive such relicensing or conveying. + + If you add terms to a covered work in accord with this section, you +must place, in the relevant source files, a statement of the +additional terms that apply to those files, or a notice indicating +where to find the applicable terms. + + Additional terms, permissive or non-permissive, may be stated in the +form of a separately written license, or stated as exceptions; +the above requirements apply either way. + + 8. Termination. + + You may not propagate or modify a covered work except as expressly +provided under this License. Any attempt otherwise to propagate or +modify it is void, and will automatically terminate your rights under +this License (including any patent licenses granted under the third +paragraph of section 11). + + However, if you cease all violation of this License, then your +license from a particular copyright holder is reinstated (a) +provisionally, unless and until the copyright holder explicitly and +finally terminates your license, and (b) permanently, if the copyright +holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + + Moreover, your license from a particular copyright holder is +reinstated permanently if the copyright holder notifies you of the +violation by some reasonable means, this is the first time you have +received notice of violation of this License (for any work) from that +copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + + Termination of your rights under this section does not terminate the +licenses of parties who have received copies or rights from you under +this License. If your rights have been terminated and not permanently +reinstated, you do not qualify to receive new licenses for the same +material under section 10. + + 9. Acceptance Not Required for Having Copies. + + You are not required to accept this License in order to receive or +run a copy of the Program. Ancillary propagation of a covered work +occurring solely as a consequence of using peer-to-peer transmission +to receive a copy likewise does not require acceptance. However, +nothing other than this License grants you permission to propagate or +modify any covered work. These actions infringe copyright if you do +not accept this License. Therefore, by modifying or propagating a +covered work, you indicate your acceptance of this License to do so. + + 10. Automatic Licensing of Downstream Recipients. + + Each time you convey a covered work, the recipient automatically +receives a license from the original licensors, to run, modify and +propagate that work, subject to this License. You are not responsible +for enforcing compliance by third parties with this License. + + An "entity transaction" is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an +organization, or merging organizations. If propagation of a covered +work results from an entity transaction, each party to that +transaction who receives a copy of the work also receives whatever +licenses to the work the party's predecessor in interest had or could +give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if +the predecessor has it or can get it with reasonable efforts. + + You may not impose any further restrictions on the exercise of the +rights granted or affirmed under this License. For example, you may +not impose a license fee, royalty, or other charge for exercise of +rights granted under this License, and you may not initiate litigation +(including a cross-claim or counterclaim in a lawsuit) alleging that +any patent claim is infringed by making, using, selling, offering for +sale, or importing the Program or any portion of it. + + 11. Patents. + + A "contributor" is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The +work thus licensed is called the contributor's "contributor version". + + A contributor's "essential patent claims" are all patent claims +owned or controlled by the contributor, whether already acquired or +hereafter acquired, that would be infringed by some manner, permitted +by this License, of making, using, or selling its contributor version, +but do not include claims that would be infringed only as a +consequence of further modification of the contributor version. For +purposes of this definition, "control" includes the right to grant +patent sublicenses in a manner consistent with the requirements of +this License. + + Each contributor grants you a non-exclusive, worldwide, royalty-free +patent license under the contributor's essential patent claims, to +make, use, sell, offer for sale, import and otherwise run, modify and +propagate the contents of its contributor version. + + In the following three paragraphs, a "patent license" is any express +agreement or commitment, however denominated, not to enforce a patent +(such as an express permission to practice a patent or covenant not to +sue for patent infringement). To "grant" such a patent license to a +party means to make such an agreement or commitment not to enforce a +patent against the party. + + If you convey a covered work, knowingly relying on a patent license, +and the Corresponding Source of the work is not available for anyone +to copy, free of charge and under the terms of this License, through a +publicly available network server or other readily accessible means, +then you must either (1) cause the Corresponding Source to be so +available, or (2) arrange to deprive yourself of the benefit of the +patent license for this particular work, or (3) arrange, in a manner +consistent with the requirements of this License, to extend the patent +license to downstream recipients. "Knowingly relying" means you have +actual knowledge that, but for the patent license, your conveying the +covered work in a country, or your recipient's use of the covered work +in a country, would infringe one or more identifiable patents in that +country that you have reason to believe are valid. + + If, pursuant to or in connection with a single transaction or +arrangement, you convey, or propagate by procuring conveyance of, a +covered work, and grant a patent license to some of the parties +receiving the covered work authorizing them to use, propagate, modify +or convey a specific copy of the covered work, then the patent license +you grant is automatically extended to all recipients of the covered +work and works based on it. + + A patent license is "discriminatory" if it does not include within +the scope of its coverage, prohibits the exercise of, or is +conditioned on the non-exercise of one or more of the rights that are +specifically granted under this License. You may not convey a covered +work if you are a party to an arrangement with a third party that is +in the business of distributing software, under which you make payment +to the third party based on the extent of your activity of conveying +the work, and under which the third party grants, to any of the +parties who would receive the covered work from you, a discriminatory +patent license (a) in connection with copies of the covered work +conveyed by you (or copies made from those copies), or (b) primarily +for and in connection with specific products or compilations that +contain the covered work, unless you entered into that arrangement, +or that patent license was granted, prior to 28 March 2007. + + Nothing in this License shall be construed as excluding or limiting +any implied license or other defenses to infringement that may +otherwise be available to you under applicable patent law. + + 12. No Surrender of Others' Freedom. + + If conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot convey a +covered work so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you may +not convey it at all. For example, if you agree to terms that obligate you +to collect a royalty for further conveying from those to whom you convey +the Program, the only way you could satisfy both those terms and this +License would be to refrain entirely from conveying the Program. + + 13. Use with the GNU Affero General Public License. + + Notwithstanding any other provision of this License, you have +permission to link or combine any covered work with a work licensed +under version 3 of the GNU Affero General Public License into a single +combined work, and to convey the resulting work. The terms of this +License will continue to apply to the part which is the covered work, +but the special requirements of the GNU Affero General Public License, +section 13, concerning interaction through a network will apply to the +combination as such. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + + Each version is given a distinguishing version number. If the +Program specifies that a certain numbered version of the GNU General +Public License "or any later version" applies to it, you have the +option of following the terms and conditions either of that numbered +version or of any later version published by the Free Software +Foundation. If the Program does not specify a version number of the +GNU General Public License, you may choose any version ever published +by the Free Software Foundation. + + If the Program specifies that a proxy can decide which future +versions of the GNU General Public License can be used, that proxy's +public statement of acceptance of a version permanently authorizes you +to choose that version for the Program. + + Later license versions may give you additional or different +permissions. However, no additional obligations are imposed on any +author or copyright holder as a result of your choosing to follow a +later version. + + 15. Disclaimer of Warranty. + + THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY +APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT +HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY +OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, +THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM +IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF +ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. Limitation of Liability. + + IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS +THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY +GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE +USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF +DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD +PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS), +EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF +SUCH DAMAGES. + + 17. Interpretation of Sections 15 and 16. + + If the disclaimer of warranty and limitation of liability provided +above cannot be given local legal effect according to their terms, +reviewing courts shall apply local law that most closely approximates +an absolute waiver of all civil liability in connection with the +Program, unless a warranty or assumption of liability accompanies a +copy of the Program in return for a fee. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +state the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation, either version 3 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If the program does terminal interaction, make it output a short +notice like this when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, your program's commands +might be different; for a GUI interface, you would use an "about box". + + You should also get your employer (if you work as a programmer) or school, +if any, to sign a "copyright disclaimer" for the program, if necessary. +For more information on this, and how to apply and follow the GNU GPL, see +. + + The GNU General Public License does not permit incorporating your program +into proprietary programs. If your program is a subroutine library, you +may consider it more useful to permit linking proprietary applications with +the library. If this is what you want to do, use the GNU Lesser General +Public License instead of this License. But first, please read +. From dab63a308f45ec40b50ddd6ecf3f1823404b068e Mon Sep 17 00:00:00 2001 From: ecmma Date: Fri, 9 Apr 2021 17:17:47 +0200 Subject: [PATCH 3/9] grammar: minor changes --- grammar.js | 10 +- src/grammar.json | 70 +- src/node-types.json | 84 +- src/parser.c | 10506 +++++++++++++++++++++--------------------- 4 files changed, 5418 insertions(+), 5252 deletions(-) diff --git a/grammar.js b/grammar.js index 6469afd17..9fb226ba2 100644 --- a/grammar.js +++ b/grammar.js @@ -102,7 +102,10 @@ module.exports = grammar ({ ), function_declaration: $ => - seq(optional($.fndec_attrs), 'fn', $.identifier, $.prototype, optional(seq('=', $.expression))), + seq(optional($.fndec_attrs), 'fn', + field('name', $.identifier), field('type', $.prototype), + optional(seq('=', field('body', $.expression))) + ), fndec_attrs: $ => repeat1($.fndec_attr), @@ -141,6 +144,7 @@ module.exports = grammar ({ $.enum_type, $.pointer_type, 'rune', + 'str', 'bool', 'void' ), @@ -482,8 +486,8 @@ module.exports = grammar ({ offset_expression: $ => seq('offset', '(', $.field_access_expression, ')'), field_access_expression: $ => choice( - seq($.postfix_expression, '.', $.name), - seq($.postfix_expression, '.', $.integer_constant) + seq($.postfix_expression, field('selector', seq('.', $.name))), + seq($.postfix_expression, field('selector', seq('.', $.integer_constant))) ), indexing_expression: $ => seq($.postfix_expression, '[', $.expression, ']'), diff --git a/src/grammar.json b/src/grammar.json index 8a4055a3e..6eac4c24c 100644 --- a/src/grammar.json +++ b/src/grammar.json @@ -498,12 +498,20 @@ "value": "fn" }, { - "type": "SYMBOL", - "name": "identifier" + "type": "FIELD", + "name": "name", + "content": { + "type": "SYMBOL", + "name": "identifier" + } }, { - "type": "SYMBOL", - "name": "prototype" + "type": "FIELD", + "name": "type", + "content": { + "type": "SYMBOL", + "name": "prototype" + } }, { "type": "CHOICE", @@ -516,8 +524,12 @@ "value": "=" }, { - "type": "SYMBOL", - "name": "expression" + "type": "FIELD", + "name": "body", + "content": { + "type": "SYMBOL", + "name": "expression" + } } ] }, @@ -675,6 +687,10 @@ "type": "STRING", "value": "rune" }, + { + "type": "STRING", + "value": "str" + }, { "type": "STRING", "value": "bool" @@ -3168,12 +3184,21 @@ "name": "postfix_expression" }, { - "type": "STRING", - "value": "." - }, - { - "type": "SYMBOL", - "name": "name" + "type": "FIELD", + "name": "selector", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "." + }, + { + "type": "SYMBOL", + "name": "name" + } + ] + } } ] }, @@ -3185,12 +3210,21 @@ "name": "postfix_expression" }, { - "type": "STRING", - "value": "." - }, - { - "type": "SYMBOL", - "name": "integer_constant" + "type": "FIELD", + "name": "selector", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "." + }, + { + "type": "SYMBOL", + "name": "integer_constant" + } + ] + } } ] } diff --git a/src/node-types.json b/src/node-types.json index 7e7d6a6d2..606302cba 100644 --- a/src/node-types.json +++ b/src/node-types.json @@ -898,19 +898,30 @@ { "type": "field_access_expression", "named": true, - "fields": {}, + "fields": { + "selector": { + "multiple": true, + "required": true, + "types": [ + { + "type": ".", + "named": false + }, + { + "type": "integer_constant", + "named": true + }, + { + "type": "name", + "named": true + } + ] + } + }, "children": { - "multiple": true, + "multiple": false, "required": true, "types": [ - { - "type": "integer_constant", - "named": true - }, - { - "type": "name", - "named": true - }, { "type": "postfix_expression", "named": true @@ -1102,26 +1113,45 @@ { "type": "function_declaration", "named": true, - "fields": {}, + "fields": { + "body": { + "multiple": false, + "required": false, + "types": [ + { + "type": "expression", + "named": true + } + ] + }, + "name": { + "multiple": false, + "required": true, + "types": [ + { + "type": "identifier", + "named": true + } + ] + }, + "type": { + "multiple": false, + "required": true, + "types": [ + { + "type": "prototype", + "named": true + } + ] + } + }, "children": { - "multiple": true, - "required": true, + "multiple": false, + "required": false, "types": [ - { - "type": "expression", - "named": true - }, { "type": "fndec_attrs", "named": true - }, - { - "type": "identifier", - "named": true - }, - { - "type": "prototype", - "named": true } ] } @@ -2972,6 +3002,10 @@ "type": "static", "named": false }, + { + "type": "str", + "named": false + }, { "type": "struct", "named": false diff --git a/src/parser.c b/src/parser.c index bc77694d9..5774c3362 100644 --- a/src/parser.c +++ b/src/parser.c @@ -16,13 +16,13 @@ #define LANGUAGE_VERSION 13 #define STATE_COUNT 820 #define LARGE_STATE_COUNT 140 -#define SYMBOL_COUNT 283 +#define SYMBOL_COUNT 284 #define ALIAS_COUNT 0 -#define TOKEN_COUNT 144 +#define TOKEN_COUNT 145 #define EXTERNAL_TOKEN_COUNT 0 -#define FIELD_COUNT 8 +#define FIELD_COUNT 12 #define MAX_ALIAS_SEQUENCE_LENGTH 7 -#define PRODUCTION_ID_COUNT 8 +#define PRODUCTION_ID_COUNT 13 enum { anon_sym_use = 1, @@ -48,265 +48,266 @@ enum { anon_sym_ATnoreturn = 21, anon_sym_BANG = 22, anon_sym_rune = 23, - anon_sym_bool = 24, - anon_sym_void = 25, - anon_sym_i8 = 26, - anon_sym_i16 = 27, - anon_sym_i32 = 28, - anon_sym_i64 = 29, - anon_sym_u8 = 30, - anon_sym_u16 = 31, - anon_sym_u32 = 32, - anon_sym_u64 = 33, - anon_sym_int = 34, - anon_sym_uint = 35, - anon_sym_size = 36, - anon_sym_uintptr = 37, - anon_sym_char = 38, - anon_sym_f32 = 39, - anon_sym_f64 = 40, - anon_sym_enum = 41, - anon_sym_STAR = 42, - anon_sym_nullable = 43, - anon_sym_struct = 44, - anon_sym_union = 45, - anon_sym_AToffset = 46, - anon_sym_PIPE = 47, - anon_sym_LBRACK = 48, - anon_sym_RBRACK = 49, - anon_sym__ = 50, - anon_sym_DOT_DOT_DOT = 51, - anon_sym_true = 52, - anon_sym_false = 53, - anon_sym_null = 54, - anon_sym_0x = 55, - anon_sym_0o = 56, - anon_sym_0b = 57, - anon_sym_0 = 58, - anon_sym_1 = 59, - anon_sym_2 = 60, - anon_sym_3 = 61, - anon_sym_4 = 62, - anon_sym_5 = 63, - anon_sym_6 = 64, - anon_sym_7 = 65, - anon_sym_8 = 66, - anon_sym_9 = 67, - anon_sym_A = 68, - anon_sym_B = 69, - anon_sym_C = 70, - anon_sym_D = 71, - anon_sym_E = 72, - anon_sym_F = 73, - anon_sym_a = 74, - anon_sym_b = 75, - anon_sym_c = 76, - anon_sym_d = 77, - anon_sym_e = 78, - anon_sym_f = 79, - anon_sym_i = 80, - anon_sym_u = 81, - anon_sym_z = 82, - anon_sym_DOT = 83, - anon_sym_SQUOTE = 84, - aux_sym_rune_token1 = 85, - anon_sym_BSLASH = 86, - aux_sym_escape_sequence_token1 = 87, - aux_sym_named_escape_token1 = 88, - anon_sym_DQUOTE = 89, - aux_sym_string_char_token1 = 90, - anon_sym_alloc = 91, - anon_sym_append = 92, - anon_sym_free = 93, - anon_sym_delete = 94, - anon_sym_assert = 95, - anon_sym_static = 96, - anon_sym_abort = 97, - anon_sym_len = 98, - anon_sym_offset = 99, - anon_sym_DOT_DOT = 100, - anon_sym_QMARK = 101, - anon_sym_PLUS = 102, - anon_sym_DASH = 103, - anon_sym_TILDE = 104, - anon_sym_AMP = 105, - anon_sym_as = 106, - anon_sym_is = 107, - anon_sym_SLASH = 108, - anon_sym_PERCENT = 109, - anon_sym_LT_LT = 110, - anon_sym_GT_GT = 111, - anon_sym_CARET = 112, - anon_sym_LT = 113, - anon_sym_GT = 114, - anon_sym_LT_EQ = 115, - anon_sym_GT_EQ = 116, - anon_sym_EQ_EQ = 117, - anon_sym_BANG_EQ = 118, - anon_sym_AMP_AMP = 119, - anon_sym_CARET_CARET = 120, - anon_sym_PIPE_PIPE = 121, - anon_sym_if = 122, - anon_sym_else = 123, - anon_sym_for = 124, - anon_sym_switch = 125, - anon_sym_EQ_GT = 126, - anon_sym_match = 127, - anon_sym_PLUS_EQ = 128, - anon_sym_DASH_EQ = 129, - anon_sym_STAR_EQ = 130, - anon_sym_SLASH_EQ = 131, - anon_sym_PERCENT_EQ = 132, - anon_sym_LT_LT_EQ = 133, - anon_sym_GT_GT_EQ = 134, - anon_sym_AMP_EQ = 135, - anon_sym_PIPE_EQ = 136, - anon_sym_CARET_EQ = 137, - anon_sym_defer = 138, - anon_sym_break = 139, - anon_sym_continue = 140, - anon_sym_return = 141, - sym_name = 142, - sym_comment = 143, - sym_unit = 144, - sym_imports = 145, - sym_use_statement = 146, - sym_name_list = 147, - sym_declarations = 148, - sym_declaration = 149, - sym_global_declaration = 150, - sym_global_bindings = 151, - sym_global_binding = 152, - sym_decl_attr = 153, - sym_constant_declaration = 154, - sym_constant_bindings = 155, - sym_constant_binding = 156, - sym_type_declaration = 157, - sym_type_bindings = 158, - sym_function_declaration = 159, - sym_fndec_attrs = 160, - sym_fndec_attr = 161, - sym_fntype_attr = 162, - sym_type = 163, - sym__inner_type = 164, - sym_storage_class = 165, - sym_scalar_type = 166, - sym_integer_type = 167, - sym_floating_type = 168, - sym_enum_type = 169, - sym_enum_values = 170, - sym_enum_value = 171, - sym_pointer_type = 172, - sym_struct_type = 173, - sym_union_type = 174, - sym_struct_union_fields = 175, - sym_struct_union_field = 176, - sym_offset_specifier = 177, - sym_tuple_type = 178, - sym_tuple_types = 179, - sym_tagged_union_type = 180, - sym_tagged_types = 181, - sym_slice_array_type = 182, - sym_function_type = 183, - sym_prototype = 184, - sym_parameter_list = 185, - sym_parameters = 186, - sym_parameter = 187, - sym_alias_type = 188, - sym_unwrapped_alias = 189, - sym_constant = 190, - sym_integer_constant = 191, - sym_hex_digits = 192, - sym_hex_digit = 193, - sym_octal_digits = 194, - sym_octal_digit = 195, - sym_binary_digits = 196, - sym_binary_digit = 197, - sym_decimal_digits = 198, - sym_decimal_digit = 199, - sym_integer_suffix = 200, - sym_floating_constant = 201, - sym_exponent = 202, - sym_floating_suffix = 203, - sym_rune_constant = 204, - sym_rune = 205, - sym_escape_sequence = 206, - sym_named_escape = 207, - sym_string_constant = 208, - sym_string_chars = 209, - sym_string_char = 210, - sym_array_literal = 211, - sym_array_members = 212, - sym_enum_literal = 213, - sym_struct_literal = 214, - sym_struct_initializer = 215, - sym_field_values = 216, - sym_field_value = 217, - sym_plain_expression = 218, - sym_nested_expression = 219, - sym_tuple_items = 220, - sym_allocation_expression = 221, - sym_append_values = 222, - sym_assertion_expression = 223, - sym_call_expression = 224, - sym_argument_list = 225, - sym_measurement_expression = 226, - sym_size_expression = 227, - sym_length_expression = 228, - sym_offset_expression = 229, - sym_field_access_expression = 230, - sym_indexing_expression = 231, - sym_slicing_expression = 232, - sym_error_propagation = 233, - sym_postfix_expression = 234, - sym_object_selector = 235, - sym_unary_expression = 236, - sym_cast_expression = 237, - sym_multiplicative_expression = 238, - sym_additive_expression = 239, - sym_shift_expression = 240, - sym_and_expression = 241, - sym_exclusive_or_expression = 242, - sym_inclusive_or_expression = 243, - sym_comparison_expression = 244, - sym_equality_expression = 245, - sym_logical_and_expression = 246, - sym_logical_xor_expression = 247, - sym_logical_or_expression = 248, - sym_if_expression = 249, - sym_conditional_branch = 250, - sym_for_loop = 251, - sym_for_predicate = 252, - sym_label = 253, - sym_switch_expression = 254, - sym_switch_cases = 255, - sym_switch_case = 256, - sym_case_options = 257, - sym_match_expression = 258, - sym_match_cases = 259, - sym_match_case = 260, - sym_assignment = 261, - sym_assignment_op = 262, - sym_binding_list = 263, - sym_bindings = 264, - sym_binding = 265, - sym_binding_names = 266, - sym_deferred_expression = 267, - sym_expression_list = 268, - sym_control_statement = 269, - sym_expression = 270, - sym_compound_expression = 271, - sym_identifier = 272, - aux_sym_imports_repeat1 = 273, - aux_sym_declarations_repeat1 = 274, - aux_sym_fndec_attrs_repeat1 = 275, - aux_sym_tagged_types_repeat1 = 276, - aux_sym_hex_digits_repeat1 = 277, - aux_sym_octal_digits_repeat1 = 278, - aux_sym_binary_digits_repeat1 = 279, - aux_sym_decimal_digits_repeat1 = 280, - aux_sym_string_constant_repeat1 = 281, - aux_sym_string_chars_repeat1 = 282, + anon_sym_str = 24, + anon_sym_bool = 25, + anon_sym_void = 26, + anon_sym_i8 = 27, + anon_sym_i16 = 28, + anon_sym_i32 = 29, + anon_sym_i64 = 30, + anon_sym_u8 = 31, + anon_sym_u16 = 32, + anon_sym_u32 = 33, + anon_sym_u64 = 34, + anon_sym_int = 35, + anon_sym_uint = 36, + anon_sym_size = 37, + anon_sym_uintptr = 38, + anon_sym_char = 39, + anon_sym_f32 = 40, + anon_sym_f64 = 41, + anon_sym_enum = 42, + anon_sym_STAR = 43, + anon_sym_nullable = 44, + anon_sym_struct = 45, + anon_sym_union = 46, + anon_sym_AToffset = 47, + anon_sym_PIPE = 48, + anon_sym_LBRACK = 49, + anon_sym_RBRACK = 50, + anon_sym__ = 51, + anon_sym_DOT_DOT_DOT = 52, + anon_sym_true = 53, + anon_sym_false = 54, + anon_sym_null = 55, + anon_sym_0x = 56, + anon_sym_0o = 57, + anon_sym_0b = 58, + anon_sym_0 = 59, + anon_sym_1 = 60, + anon_sym_2 = 61, + anon_sym_3 = 62, + anon_sym_4 = 63, + anon_sym_5 = 64, + anon_sym_6 = 65, + anon_sym_7 = 66, + anon_sym_8 = 67, + anon_sym_9 = 68, + anon_sym_A = 69, + anon_sym_B = 70, + anon_sym_C = 71, + anon_sym_D = 72, + anon_sym_E = 73, + anon_sym_F = 74, + anon_sym_a = 75, + anon_sym_b = 76, + anon_sym_c = 77, + anon_sym_d = 78, + anon_sym_e = 79, + anon_sym_f = 80, + anon_sym_i = 81, + anon_sym_u = 82, + anon_sym_z = 83, + anon_sym_DOT = 84, + anon_sym_SQUOTE = 85, + aux_sym_rune_token1 = 86, + anon_sym_BSLASH = 87, + aux_sym_escape_sequence_token1 = 88, + aux_sym_named_escape_token1 = 89, + anon_sym_DQUOTE = 90, + aux_sym_string_char_token1 = 91, + anon_sym_alloc = 92, + anon_sym_append = 93, + anon_sym_free = 94, + anon_sym_delete = 95, + anon_sym_assert = 96, + anon_sym_static = 97, + anon_sym_abort = 98, + anon_sym_len = 99, + anon_sym_offset = 100, + anon_sym_DOT_DOT = 101, + anon_sym_QMARK = 102, + anon_sym_PLUS = 103, + anon_sym_DASH = 104, + anon_sym_TILDE = 105, + anon_sym_AMP = 106, + anon_sym_as = 107, + anon_sym_is = 108, + anon_sym_SLASH = 109, + anon_sym_PERCENT = 110, + anon_sym_LT_LT = 111, + anon_sym_GT_GT = 112, + anon_sym_CARET = 113, + anon_sym_LT = 114, + anon_sym_GT = 115, + anon_sym_LT_EQ = 116, + anon_sym_GT_EQ = 117, + anon_sym_EQ_EQ = 118, + anon_sym_BANG_EQ = 119, + anon_sym_AMP_AMP = 120, + anon_sym_CARET_CARET = 121, + anon_sym_PIPE_PIPE = 122, + anon_sym_if = 123, + anon_sym_else = 124, + anon_sym_for = 125, + anon_sym_switch = 126, + anon_sym_EQ_GT = 127, + anon_sym_match = 128, + anon_sym_PLUS_EQ = 129, + anon_sym_DASH_EQ = 130, + anon_sym_STAR_EQ = 131, + anon_sym_SLASH_EQ = 132, + anon_sym_PERCENT_EQ = 133, + anon_sym_LT_LT_EQ = 134, + anon_sym_GT_GT_EQ = 135, + anon_sym_AMP_EQ = 136, + anon_sym_PIPE_EQ = 137, + anon_sym_CARET_EQ = 138, + anon_sym_defer = 139, + anon_sym_break = 140, + anon_sym_continue = 141, + anon_sym_return = 142, + sym_name = 143, + sym_comment = 144, + sym_unit = 145, + sym_imports = 146, + sym_use_statement = 147, + sym_name_list = 148, + sym_declarations = 149, + sym_declaration = 150, + sym_global_declaration = 151, + sym_global_bindings = 152, + sym_global_binding = 153, + sym_decl_attr = 154, + sym_constant_declaration = 155, + sym_constant_bindings = 156, + sym_constant_binding = 157, + sym_type_declaration = 158, + sym_type_bindings = 159, + sym_function_declaration = 160, + sym_fndec_attrs = 161, + sym_fndec_attr = 162, + sym_fntype_attr = 163, + sym_type = 164, + sym__inner_type = 165, + sym_storage_class = 166, + sym_scalar_type = 167, + sym_integer_type = 168, + sym_floating_type = 169, + sym_enum_type = 170, + sym_enum_values = 171, + sym_enum_value = 172, + sym_pointer_type = 173, + sym_struct_type = 174, + sym_union_type = 175, + sym_struct_union_fields = 176, + sym_struct_union_field = 177, + sym_offset_specifier = 178, + sym_tuple_type = 179, + sym_tuple_types = 180, + sym_tagged_union_type = 181, + sym_tagged_types = 182, + sym_slice_array_type = 183, + sym_function_type = 184, + sym_prototype = 185, + sym_parameter_list = 186, + sym_parameters = 187, + sym_parameter = 188, + sym_alias_type = 189, + sym_unwrapped_alias = 190, + sym_constant = 191, + sym_integer_constant = 192, + sym_hex_digits = 193, + sym_hex_digit = 194, + sym_octal_digits = 195, + sym_octal_digit = 196, + sym_binary_digits = 197, + sym_binary_digit = 198, + sym_decimal_digits = 199, + sym_decimal_digit = 200, + sym_integer_suffix = 201, + sym_floating_constant = 202, + sym_exponent = 203, + sym_floating_suffix = 204, + sym_rune_constant = 205, + sym_rune = 206, + sym_escape_sequence = 207, + sym_named_escape = 208, + sym_string_constant = 209, + sym_string_chars = 210, + sym_string_char = 211, + sym_array_literal = 212, + sym_array_members = 213, + sym_enum_literal = 214, + sym_struct_literal = 215, + sym_struct_initializer = 216, + sym_field_values = 217, + sym_field_value = 218, + sym_plain_expression = 219, + sym_nested_expression = 220, + sym_tuple_items = 221, + sym_allocation_expression = 222, + sym_append_values = 223, + sym_assertion_expression = 224, + sym_call_expression = 225, + sym_argument_list = 226, + sym_measurement_expression = 227, + sym_size_expression = 228, + sym_length_expression = 229, + sym_offset_expression = 230, + sym_field_access_expression = 231, + sym_indexing_expression = 232, + sym_slicing_expression = 233, + sym_error_propagation = 234, + sym_postfix_expression = 235, + sym_object_selector = 236, + sym_unary_expression = 237, + sym_cast_expression = 238, + sym_multiplicative_expression = 239, + sym_additive_expression = 240, + sym_shift_expression = 241, + sym_and_expression = 242, + sym_exclusive_or_expression = 243, + sym_inclusive_or_expression = 244, + sym_comparison_expression = 245, + sym_equality_expression = 246, + sym_logical_and_expression = 247, + sym_logical_xor_expression = 248, + sym_logical_or_expression = 249, + sym_if_expression = 250, + sym_conditional_branch = 251, + sym_for_loop = 252, + sym_for_predicate = 253, + sym_label = 254, + sym_switch_expression = 255, + sym_switch_cases = 256, + sym_switch_case = 257, + sym_case_options = 258, + sym_match_expression = 259, + sym_match_cases = 260, + sym_match_case = 261, + sym_assignment = 262, + sym_assignment_op = 263, + sym_binding_list = 264, + sym_bindings = 265, + sym_binding = 266, + sym_binding_names = 267, + sym_deferred_expression = 268, + sym_expression_list = 269, + sym_control_statement = 270, + sym_expression = 271, + sym_compound_expression = 272, + sym_identifier = 273, + aux_sym_imports_repeat1 = 274, + aux_sym_declarations_repeat1 = 275, + aux_sym_fndec_attrs_repeat1 = 276, + aux_sym_tagged_types_repeat1 = 277, + aux_sym_hex_digits_repeat1 = 278, + aux_sym_octal_digits_repeat1 = 279, + aux_sym_binary_digits_repeat1 = 280, + aux_sym_decimal_digits_repeat1 = 281, + aux_sym_string_constant_repeat1 = 282, + aux_sym_string_chars_repeat1 = 283, }; static const char *ts_symbol_names[] = { @@ -334,6 +335,7 @@ static const char *ts_symbol_names[] = { [anon_sym_ATnoreturn] = "@noreturn", [anon_sym_BANG] = "!", [anon_sym_rune] = "rune", + [anon_sym_str] = "str", [anon_sym_bool] = "bool", [anon_sym_void] = "void", [anon_sym_i8] = "i8", @@ -620,6 +622,7 @@ static TSSymbol ts_symbol_map[] = { [anon_sym_ATnoreturn] = anon_sym_ATnoreturn, [anon_sym_BANG] = anon_sym_BANG, [anon_sym_rune] = anon_sym_rune, + [anon_sym_str] = anon_sym_str, [anon_sym_bool] = anon_sym_bool, [anon_sym_void] = anon_sym_void, [anon_sym_i8] = anon_sym_i8, @@ -978,6 +981,10 @@ static const TSSymbolMetadata ts_symbol_metadata[] = { .visible = true, .named = false, }, + [anon_sym_str] = { + .visible = true, + .named = false, + }, [anon_sym_bool] = { .visible = true, .named = false, @@ -2022,9 +2029,13 @@ enum { field_argument = 3, field_as_cast = 4, field_binding = 5, - field_is_cast = 6, - field_operator = 7, - field_type_cast = 8, + field_body = 6, + field_is_cast = 7, + field_name = 8, + field_operator = 9, + field_selector = 10, + field_type = 11, + field_type_cast = 12, }; static const char *ts_field_names[] = { @@ -2034,8 +2045,12 @@ static const char *ts_field_names[] = { [field_argument] = "argument", [field_as_cast] = "as_cast", [field_binding] = "binding", + [field_body] = "body", [field_is_cast] = "is_cast", + [field_name] = "name", [field_operator] = "operator", + [field_selector] = "selector", + [field_type] = "type", [field_type_cast] = "type_cast", }; @@ -2043,34 +2058,56 @@ static const TSFieldMapSlice ts_field_map_slices[PRODUCTION_ID_COUNT] = { [1] = {.index = 0, .length = 2}, [2] = {.index = 2, .length = 2}, [3] = {.index = 4, .length = 3}, - [4] = {.index = 7, .length = 3}, - [5] = {.index = 10, .length = 3}, - [6] = {.index = 13, .length = 1}, - [7] = {.index = 14, .length = 1}, + [4] = {.index = 7, .length = 2}, + [5] = {.index = 9, .length = 2}, + [6] = {.index = 11, .length = 3}, + [7] = {.index = 14, .length = 2}, + [8] = {.index = 16, .length = 3}, + [9] = {.index = 19, .length = 3}, + [10] = {.index = 22, .length = 3}, + [11] = {.index = 25, .length = 1}, + [12] = {.index = 26, .length = 1}, }; static const TSFieldMapEntry ts_field_map_entries[] = { [0] = + {field_name, 1}, + {field_type, 2}, + [2] = + {field_name, 2}, + {field_type, 3}, + [4] = + {field_body, 4}, + {field_name, 1}, + {field_type, 2}, + [7] = {field_argument, 1}, {field_operator, 0}, - [2] = + [9] = {field_address, 0}, {field_argument, 1}, - [4] = + [11] = + {field_body, 5}, + {field_name, 2}, + {field_type, 3}, + [14] = + {field_selector, 1}, + {field_selector, 2}, + [16] = {field_type_cast, 0}, {field_type_cast, 1}, {field_type_cast, 2}, - [7] = + [19] = {field_as_cast, 0}, {field_as_cast, 1}, {field_as_cast, 2}, - [10] = + [22] = {field_is_cast, 0}, {field_is_cast, 1}, {field_is_cast, 2}, - [13] = + [25] = {field_binding, 0}, - [14] = + [26] = {field_afterthought, 2}, }; @@ -2101,55 +2138,55 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { eof = lexer->eof(lexer); switch (state) { case 0: - if (eof) ADVANCE(236); - if (lookahead == '!') ADVANCE(265); - if (lookahead == '"') ADVANCE(370); - if (lookahead == '%') ADVANCE(405); - if (lookahead == '&') ADVANCE(399); - if (lookahead == '\'') ADVANCE(364); - if (lookahead == '(') ADVANCE(254); - if (lookahead == ')') ADVANCE(255); - if (lookahead == '*') ADVANCE(305); - if (lookahead == '+') ADVANCE(393); - if (lookahead == ',') ADVANCE(245); - if (lookahead == '-') ADVANCE(395); - if (lookahead == '.') ADVANCE(361); - if (lookahead == '/') ADVANCE(403); - if (lookahead == '0') ADVANCE(329); - if (lookahead == '1') ADVANCE(330); - if (lookahead == '2') ADVANCE(331); - if (lookahead == '3') ADVANCE(332); - if (lookahead == '4') ADVANCE(333); - if (lookahead == '5') ADVANCE(334); - if (lookahead == '6') ADVANCE(335); - if (lookahead == '7') ADVANCE(336); - if (lookahead == '8') ADVANCE(337); - if (lookahead == '9') ADVANCE(338); - if (lookahead == ':') ADVANCE(252); - if (lookahead == ';') ADVANCE(238); - if (lookahead == '<') ADVANCE(412); - if (lookahead == '=') ADVANCE(240); - if (lookahead == '>') ADVANCE(414); - if (lookahead == '?') ADVANCE(391); + if (eof) ADVANCE(235); + if (lookahead == '!') ADVANCE(264); + if (lookahead == '"') ADVANCE(371); + if (lookahead == '%') ADVANCE(406); + if (lookahead == '&') ADVANCE(400); + if (lookahead == '\'') ADVANCE(365); + if (lookahead == '(') ADVANCE(253); + if (lookahead == ')') ADVANCE(254); + if (lookahead == '*') ADVANCE(306); + if (lookahead == '+') ADVANCE(394); + if (lookahead == ',') ADVANCE(244); + if (lookahead == '-') ADVANCE(396); + if (lookahead == '.') ADVANCE(362); + if (lookahead == '/') ADVANCE(404); + if (lookahead == '0') ADVANCE(330); + if (lookahead == '1') ADVANCE(331); + if (lookahead == '2') ADVANCE(332); + if (lookahead == '3') ADVANCE(333); + if (lookahead == '4') ADVANCE(334); + if (lookahead == '5') ADVANCE(335); + if (lookahead == '6') ADVANCE(336); + if (lookahead == '7') ADVANCE(337); + if (lookahead == '8') ADVANCE(338); + if (lookahead == '9') ADVANCE(339); + if (lookahead == ':') ADVANCE(251); + if (lookahead == ';') ADVANCE(237); + if (lookahead == '<') ADVANCE(413); + if (lookahead == '=') ADVANCE(239); + if (lookahead == '>') ADVANCE(415); + if (lookahead == '?') ADVANCE(392); if (lookahead == '@') ADVANCE(119); - if (lookahead == 'A') ADVANCE(339); - if (lookahead == 'B') ADVANCE(340); - if (lookahead == 'C') ADVANCE(341); - if (lookahead == 'D') ADVANCE(342); - if (lookahead == 'E') ADVANCE(343); - if (lookahead == 'F') ADVANCE(344); - if (lookahead == '[') ADVANCE(315); - if (lookahead == '\\') SKIP(232) - if (lookahead == ']') ADVANCE(316); - if (lookahead == '^') ADVANCE(410); - if (lookahead == '_') ADVANCE(317); - if (lookahead == 'a') ADVANCE(345); - if (lookahead == 'b') ADVANCE(348); - if (lookahead == 'c') ADVANCE(350); - if (lookahead == 'd') ADVANCE(351); - if (lookahead == 'e') ADVANCE(353); - if (lookahead == 'f') ADVANCE(355); - if (lookahead == 'i') ADVANCE(356); + if (lookahead == 'A') ADVANCE(340); + if (lookahead == 'B') ADVANCE(341); + if (lookahead == 'C') ADVANCE(342); + if (lookahead == 'D') ADVANCE(343); + if (lookahead == 'E') ADVANCE(344); + if (lookahead == 'F') ADVANCE(345); + if (lookahead == '[') ADVANCE(316); + if (lookahead == '\\') SKIP(231) + if (lookahead == ']') ADVANCE(317); + if (lookahead == '^') ADVANCE(411); + if (lookahead == '_') ADVANCE(318); + if (lookahead == 'a') ADVANCE(346); + if (lookahead == 'b') ADVANCE(349); + if (lookahead == 'c') ADVANCE(351); + if (lookahead == 'd') ADVANCE(352); + if (lookahead == 'e') ADVANCE(354); + if (lookahead == 'f') ADVANCE(356); + if (lookahead == 'i') ADVANCE(357); if (lookahead == 'l') ADVANCE(99); if (lookahead == 'm') ADVANCE(88); if (lookahead == 'n') ADVANCE(211); @@ -2157,13 +2194,13 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { if (lookahead == 'r') ADVANCE(111); if (lookahead == 's') ADVANCE(130); if (lookahead == 't') ADVANCE(177); - if (lookahead == 'u') ADVANCE(359); + if (lookahead == 'u') ADVANCE(360); if (lookahead == 'v') ADVANCE(165); - if (lookahead == 'z') ADVANCE(360); - if (lookahead == '{') ADVANCE(243); - if (lookahead == '|') ADVANCE(313); - if (lookahead == '}') ADVANCE(244); - if (lookahead == '~') ADVANCE(396); + if (lookahead == 'z') ADVANCE(361); + if (lookahead == '{') ADVANCE(242); + if (lookahead == '|') ADVANCE(314); + if (lookahead == '}') ADVANCE(243); + if (lookahead == '~') ADVANCE(397); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r' || @@ -2290,13 +2327,13 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { END_STATE(); case 35: if (lookahead == '\n') SKIP(57) - if (lookahead == '"') ADVANCE(370); - if (lookahead == '/') ADVANCE(372); - if (lookahead == '\\') ADVANCE(367); + if (lookahead == '"') ADVANCE(371); + if (lookahead == '/') ADVANCE(373); + if (lookahead == '\\') ADVANCE(368); if (lookahead == '\t' || lookahead == '\r' || - lookahead == ' ') ADVANCE(371); - if (lookahead != 0) ADVANCE(371); + lookahead == ' ') ADVANCE(372); + if (lookahead != 0) ADVANCE(372); END_STATE(); case 36: if (lookahead == '\n') SKIP(60) @@ -2327,56 +2364,56 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { if (lookahead == '\r') SKIP(42) END_STATE(); case 44: - if (lookahead == '!') ADVANCE(265); - if (lookahead == '"') ADVANCE(370); - if (lookahead == '%') ADVANCE(404); - if (lookahead == '&') ADVANCE(398); - if (lookahead == '(') ADVANCE(254); - if (lookahead == ')') ADVANCE(255); - if (lookahead == '*') ADVANCE(304); - if (lookahead == '+') ADVANCE(392); - if (lookahead == ',') ADVANCE(245); - if (lookahead == '-') ADVANCE(394); - if (lookahead == '.') ADVANCE(361); - if (lookahead == '/') ADVANCE(402); - if (lookahead == '0') ADVANCE(328); - if (lookahead == '1') ADVANCE(330); - if (lookahead == '2') ADVANCE(331); - if (lookahead == '3') ADVANCE(332); - if (lookahead == '4') ADVANCE(333); - if (lookahead == '5') ADVANCE(334); - if (lookahead == '6') ADVANCE(335); - if (lookahead == '7') ADVANCE(336); - if (lookahead == '8') ADVANCE(337); - if (lookahead == '9') ADVANCE(338); - if (lookahead == ':') ADVANCE(252); - if (lookahead == ';') ADVANCE(238); - if (lookahead == '<') ADVANCE(413); - if (lookahead == '=') ADVANCE(240); - if (lookahead == '>') ADVANCE(415); - if (lookahead == '?') ADVANCE(391); - if (lookahead == 'A') ADVANCE(339); - if (lookahead == 'B') ADVANCE(340); - if (lookahead == 'C') ADVANCE(341); - if (lookahead == 'D') ADVANCE(342); - if (lookahead == 'E') ADVANCE(343); - if (lookahead == 'F') ADVANCE(344); - if (lookahead == '[') ADVANCE(315); + if (lookahead == '!') ADVANCE(264); + if (lookahead == '"') ADVANCE(371); + if (lookahead == '%') ADVANCE(405); + if (lookahead == '&') ADVANCE(399); + if (lookahead == '(') ADVANCE(253); + if (lookahead == ')') ADVANCE(254); + if (lookahead == '*') ADVANCE(305); + if (lookahead == '+') ADVANCE(393); + if (lookahead == ',') ADVANCE(244); + if (lookahead == '-') ADVANCE(395); + if (lookahead == '.') ADVANCE(362); + if (lookahead == '/') ADVANCE(403); + if (lookahead == '0') ADVANCE(329); + if (lookahead == '1') ADVANCE(331); + if (lookahead == '2') ADVANCE(332); + if (lookahead == '3') ADVANCE(333); + if (lookahead == '4') ADVANCE(334); + if (lookahead == '5') ADVANCE(335); + if (lookahead == '6') ADVANCE(336); + if (lookahead == '7') ADVANCE(337); + if (lookahead == '8') ADVANCE(338); + if (lookahead == '9') ADVANCE(339); + if (lookahead == ':') ADVANCE(251); + if (lookahead == ';') ADVANCE(237); + if (lookahead == '<') ADVANCE(414); + if (lookahead == '=') ADVANCE(239); + if (lookahead == '>') ADVANCE(416); + if (lookahead == '?') ADVANCE(392); + if (lookahead == 'A') ADVANCE(340); + if (lookahead == 'B') ADVANCE(341); + if (lookahead == 'C') ADVANCE(342); + if (lookahead == 'D') ADVANCE(343); + if (lookahead == 'E') ADVANCE(344); + if (lookahead == 'F') ADVANCE(345); + if (lookahead == '[') ADVANCE(316); if (lookahead == '\\') SKIP(20) - if (lookahead == ']') ADVANCE(316); - if (lookahead == '^') ADVANCE(411); - if (lookahead == 'a') ADVANCE(346); - if (lookahead == 'b') ADVANCE(347); - if (lookahead == 'c') ADVANCE(349); - if (lookahead == 'd') ADVANCE(351); - if (lookahead == 'e') ADVANCE(352); - if (lookahead == 'f') ADVANCE(354); - if (lookahead == 'i') ADVANCE(357); - if (lookahead == 'u') ADVANCE(358); - if (lookahead == 'z') ADVANCE(360); - if (lookahead == '{') ADVANCE(243); - if (lookahead == '|') ADVANCE(314); - if (lookahead == '}') ADVANCE(244); + if (lookahead == ']') ADVANCE(317); + if (lookahead == '^') ADVANCE(412); + if (lookahead == 'a') ADVANCE(347); + if (lookahead == 'b') ADVANCE(348); + if (lookahead == 'c') ADVANCE(350); + if (lookahead == 'd') ADVANCE(352); + if (lookahead == 'e') ADVANCE(353); + if (lookahead == 'f') ADVANCE(355); + if (lookahead == 'i') ADVANCE(358); + if (lookahead == 'u') ADVANCE(359); + if (lookahead == 'z') ADVANCE(361); + if (lookahead == '{') ADVANCE(242); + if (lookahead == '|') ADVANCE(315); + if (lookahead == '}') ADVANCE(243); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r' || @@ -2384,53 +2421,53 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { END_STATE(); case 45: if (lookahead == '!') ADVANCE(84); - if (lookahead == '%') ADVANCE(405); - if (lookahead == '&') ADVANCE(399); - if (lookahead == '(') ADVANCE(254); - if (lookahead == ')') ADVANCE(255); - if (lookahead == '*') ADVANCE(305); - if (lookahead == '+') ADVANCE(393); - if (lookahead == ',') ADVANCE(245); - if (lookahead == '-') ADVANCE(395); - if (lookahead == '.') ADVANCE(361); - if (lookahead == '/') ADVANCE(403); - if (lookahead == '0') ADVANCE(328); - if (lookahead == '1') ADVANCE(330); - if (lookahead == '2') ADVANCE(331); - if (lookahead == '3') ADVANCE(332); - if (lookahead == '4') ADVANCE(333); - if (lookahead == '5') ADVANCE(334); - if (lookahead == '6') ADVANCE(335); - if (lookahead == '7') ADVANCE(336); - if (lookahead == '8') ADVANCE(337); - if (lookahead == '9') ADVANCE(338); - if (lookahead == ':') ADVANCE(251); - if (lookahead == ';') ADVANCE(238); - if (lookahead == '<') ADVANCE(412); - if (lookahead == '=') ADVANCE(240); - if (lookahead == '>') ADVANCE(414); - if (lookahead == '?') ADVANCE(391); - if (lookahead == 'A') ADVANCE(339); - if (lookahead == 'B') ADVANCE(340); - if (lookahead == 'C') ADVANCE(341); - if (lookahead == 'D') ADVANCE(342); - if (lookahead == 'E') ADVANCE(343); - if (lookahead == 'F') ADVANCE(344); - if (lookahead == '[') ADVANCE(315); + if (lookahead == '%') ADVANCE(406); + if (lookahead == '&') ADVANCE(400); + if (lookahead == '(') ADVANCE(253); + if (lookahead == ')') ADVANCE(254); + if (lookahead == '*') ADVANCE(306); + if (lookahead == '+') ADVANCE(394); + if (lookahead == ',') ADVANCE(244); + if (lookahead == '-') ADVANCE(396); + if (lookahead == '.') ADVANCE(362); + if (lookahead == '/') ADVANCE(404); + if (lookahead == '0') ADVANCE(329); + if (lookahead == '1') ADVANCE(331); + if (lookahead == '2') ADVANCE(332); + if (lookahead == '3') ADVANCE(333); + if (lookahead == '4') ADVANCE(334); + if (lookahead == '5') ADVANCE(335); + if (lookahead == '6') ADVANCE(336); + if (lookahead == '7') ADVANCE(337); + if (lookahead == '8') ADVANCE(338); + if (lookahead == '9') ADVANCE(339); + if (lookahead == ':') ADVANCE(250); + if (lookahead == ';') ADVANCE(237); + if (lookahead == '<') ADVANCE(413); + if (lookahead == '=') ADVANCE(239); + if (lookahead == '>') ADVANCE(415); + if (lookahead == '?') ADVANCE(392); + if (lookahead == 'A') ADVANCE(340); + if (lookahead == 'B') ADVANCE(341); + if (lookahead == 'C') ADVANCE(342); + if (lookahead == 'D') ADVANCE(343); + if (lookahead == 'E') ADVANCE(344); + if (lookahead == 'F') ADVANCE(345); + if (lookahead == '[') ADVANCE(316); if (lookahead == '\\') SKIP(14) - if (lookahead == ']') ADVANCE(316); - if (lookahead == '^') ADVANCE(410); - if (lookahead == 'a') ADVANCE(346); - if (lookahead == 'b') ADVANCE(347); - if (lookahead == 'c') ADVANCE(349); - if (lookahead == 'd') ADVANCE(351); - if (lookahead == 'e') ADVANCE(352); - if (lookahead == 'f') ADVANCE(354); - if (lookahead == 'i') ADVANCE(357); - if (lookahead == 'u') ADVANCE(358); - if (lookahead == 'z') ADVANCE(360); - if (lookahead == '|') ADVANCE(313); - if (lookahead == '}') ADVANCE(244); + if (lookahead == ']') ADVANCE(317); + if (lookahead == '^') ADVANCE(411); + if (lookahead == 'a') ADVANCE(347); + if (lookahead == 'b') ADVANCE(348); + if (lookahead == 'c') ADVANCE(350); + if (lookahead == 'd') ADVANCE(352); + if (lookahead == 'e') ADVANCE(353); + if (lookahead == 'f') ADVANCE(355); + if (lookahead == 'i') ADVANCE(358); + if (lookahead == 'u') ADVANCE(359); + if (lookahead == 'z') ADVANCE(361); + if (lookahead == '|') ADVANCE(314); + if (lookahead == '}') ADVANCE(243); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r' || @@ -2438,44 +2475,44 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { END_STATE(); case 46: if (lookahead == '!') ADVANCE(84); - if (lookahead == '%') ADVANCE(405); - if (lookahead == '&') ADVANCE(399); - if (lookahead == '(') ADVANCE(254); - if (lookahead == ')') ADVANCE(255); - if (lookahead == '*') ADVANCE(305); - if (lookahead == '+') ADVANCE(393); - if (lookahead == ',') ADVANCE(245); - if (lookahead == '-') ADVANCE(395); - if (lookahead == '.') ADVANCE(361); - if (lookahead == '/') ADVANCE(403); - if (lookahead == '0') ADVANCE(328); - if (lookahead == '1') ADVANCE(330); - if (lookahead == '2') ADVANCE(331); - if (lookahead == '3') ADVANCE(332); - if (lookahead == '4') ADVANCE(333); - if (lookahead == '5') ADVANCE(334); - if (lookahead == '6') ADVANCE(335); - if (lookahead == '7') ADVANCE(336); - if (lookahead == '8') ADVANCE(337); - if (lookahead == '9') ADVANCE(338); - if (lookahead == ':') ADVANCE(251); - if (lookahead == ';') ADVANCE(238); - if (lookahead == '<') ADVANCE(412); - if (lookahead == '=') ADVANCE(240); - if (lookahead == '>') ADVANCE(414); - if (lookahead == '?') ADVANCE(391); - if (lookahead == '[') ADVANCE(315); + if (lookahead == '%') ADVANCE(406); + if (lookahead == '&') ADVANCE(400); + if (lookahead == '(') ADVANCE(253); + if (lookahead == ')') ADVANCE(254); + if (lookahead == '*') ADVANCE(306); + if (lookahead == '+') ADVANCE(394); + if (lookahead == ',') ADVANCE(244); + if (lookahead == '-') ADVANCE(396); + if (lookahead == '.') ADVANCE(362); + if (lookahead == '/') ADVANCE(404); + if (lookahead == '0') ADVANCE(329); + if (lookahead == '1') ADVANCE(331); + if (lookahead == '2') ADVANCE(332); + if (lookahead == '3') ADVANCE(333); + if (lookahead == '4') ADVANCE(334); + if (lookahead == '5') ADVANCE(335); + if (lookahead == '6') ADVANCE(336); + if (lookahead == '7') ADVANCE(337); + if (lookahead == '8') ADVANCE(338); + if (lookahead == '9') ADVANCE(339); + if (lookahead == ':') ADVANCE(250); + if (lookahead == ';') ADVANCE(237); + if (lookahead == '<') ADVANCE(413); + if (lookahead == '=') ADVANCE(239); + if (lookahead == '>') ADVANCE(415); + if (lookahead == '?') ADVANCE(392); + if (lookahead == '[') ADVANCE(316); if (lookahead == '\\') SKIP(18) - if (lookahead == ']') ADVANCE(316); - if (lookahead == '^') ADVANCE(410); + if (lookahead == ']') ADVANCE(317); + if (lookahead == '^') ADVANCE(411); if (lookahead == 'a') ADVANCE(184); - if (lookahead == 'e') ADVANCE(352); + if (lookahead == 'e') ADVANCE(353); if (lookahead == 'f') ADVANCE(77); - if (lookahead == 'i') ADVANCE(357); - if (lookahead == 'u') ADVANCE(358); - if (lookahead == 'z') ADVANCE(360); - if (lookahead == '|') ADVANCE(313); - if (lookahead == '}') ADVANCE(244); + if (lookahead == 'i') ADVANCE(358); + if (lookahead == 'u') ADVANCE(359); + if (lookahead == 'z') ADVANCE(361); + if (lookahead == '|') ADVANCE(314); + if (lookahead == '}') ADVANCE(243); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r' || @@ -2483,27 +2520,27 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { END_STATE(); case 47: if (lookahead == '!') ADVANCE(84); - if (lookahead == '%') ADVANCE(405); - if (lookahead == '&') ADVANCE(399); - if (lookahead == ')') ADVANCE(255); - if (lookahead == '*') ADVANCE(305); - if (lookahead == '+') ADVANCE(393); - if (lookahead == ',') ADVANCE(245); - if (lookahead == '-') ADVANCE(395); + if (lookahead == '%') ADVANCE(406); + if (lookahead == '&') ADVANCE(400); + if (lookahead == ')') ADVANCE(254); + if (lookahead == '*') ADVANCE(306); + if (lookahead == '+') ADVANCE(394); + if (lookahead == ',') ADVANCE(244); + if (lookahead == '-') ADVANCE(396); if (lookahead == '.') ADVANCE(63); - if (lookahead == '/') ADVANCE(403); - if (lookahead == ':') ADVANCE(251); - if (lookahead == ';') ADVANCE(238); - if (lookahead == '<') ADVANCE(412); - if (lookahead == '=') ADVANCE(239); - if (lookahead == '>') ADVANCE(414); + if (lookahead == '/') ADVANCE(404); + if (lookahead == ':') ADVANCE(250); + if (lookahead == ';') ADVANCE(237); + if (lookahead == '<') ADVANCE(413); + if (lookahead == '=') ADVANCE(238); + if (lookahead == '>') ADVANCE(415); if (lookahead == '\\') SKIP(26) - if (lookahead == ']') ADVANCE(316); - if (lookahead == '^') ADVANCE(410); + if (lookahead == ']') ADVANCE(317); + if (lookahead == '^') ADVANCE(411); if (lookahead == 'a') ADVANCE(184); if (lookahead == 'e') ADVANCE(140); if (lookahead == 'i') ADVANCE(185); - if (lookahead == '|') ADVANCE(313); + if (lookahead == '|') ADVANCE(314); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r' || @@ -2511,44 +2548,44 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { END_STATE(); case 48: if (lookahead == '!') ADVANCE(84); - if (lookahead == '%') ADVANCE(404); - if (lookahead == '&') ADVANCE(398); - if (lookahead == '(') ADVANCE(254); - if (lookahead == ')') ADVANCE(255); - if (lookahead == '*') ADVANCE(304); - if (lookahead == '+') ADVANCE(392); - if (lookahead == ',') ADVANCE(245); - if (lookahead == '-') ADVANCE(394); - if (lookahead == '.') ADVANCE(361); - if (lookahead == '/') ADVANCE(402); - if (lookahead == '0') ADVANCE(328); - if (lookahead == '1') ADVANCE(330); - if (lookahead == '2') ADVANCE(331); - if (lookahead == '3') ADVANCE(332); - if (lookahead == '4') ADVANCE(333); - if (lookahead == '5') ADVANCE(334); - if (lookahead == '6') ADVANCE(335); - if (lookahead == '7') ADVANCE(336); - if (lookahead == '8') ADVANCE(337); - if (lookahead == '9') ADVANCE(338); - if (lookahead == ':') ADVANCE(251); - if (lookahead == ';') ADVANCE(238); - if (lookahead == '<') ADVANCE(413); + if (lookahead == '%') ADVANCE(405); + if (lookahead == '&') ADVANCE(399); + if (lookahead == '(') ADVANCE(253); + if (lookahead == ')') ADVANCE(254); + if (lookahead == '*') ADVANCE(305); + if (lookahead == '+') ADVANCE(393); + if (lookahead == ',') ADVANCE(244); + if (lookahead == '-') ADVANCE(395); + if (lookahead == '.') ADVANCE(362); + if (lookahead == '/') ADVANCE(403); + if (lookahead == '0') ADVANCE(329); + if (lookahead == '1') ADVANCE(331); + if (lookahead == '2') ADVANCE(332); + if (lookahead == '3') ADVANCE(333); + if (lookahead == '4') ADVANCE(334); + if (lookahead == '5') ADVANCE(335); + if (lookahead == '6') ADVANCE(336); + if (lookahead == '7') ADVANCE(337); + if (lookahead == '8') ADVANCE(338); + if (lookahead == '9') ADVANCE(339); + if (lookahead == ':') ADVANCE(250); + if (lookahead == ';') ADVANCE(237); + if (lookahead == '<') ADVANCE(414); if (lookahead == '=') ADVANCE(85); - if (lookahead == '>') ADVANCE(415); - if (lookahead == '?') ADVANCE(391); - if (lookahead == '[') ADVANCE(315); + if (lookahead == '>') ADVANCE(416); + if (lookahead == '?') ADVANCE(392); + if (lookahead == '[') ADVANCE(316); if (lookahead == '\\') SKIP(43) - if (lookahead == ']') ADVANCE(316); - if (lookahead == '^') ADVANCE(411); + if (lookahead == ']') ADVANCE(317); + if (lookahead == '^') ADVANCE(412); if (lookahead == 'a') ADVANCE(184); - if (lookahead == 'e') ADVANCE(352); + if (lookahead == 'e') ADVANCE(353); if (lookahead == 'f') ADVANCE(77); - if (lookahead == 'i') ADVANCE(357); - if (lookahead == 'u') ADVANCE(358); - if (lookahead == 'z') ADVANCE(360); - if (lookahead == '|') ADVANCE(314); - if (lookahead == '}') ADVANCE(244); + if (lookahead == 'i') ADVANCE(358); + if (lookahead == 'u') ADVANCE(359); + if (lookahead == 'z') ADVANCE(361); + if (lookahead == '|') ADVANCE(315); + if (lookahead == '}') ADVANCE(243); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r' || @@ -2556,471 +2593,471 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { END_STATE(); case 49: if (lookahead == '!') ADVANCE(84); - if (lookahead == '%') ADVANCE(404); - if (lookahead == '&') ADVANCE(398); - if (lookahead == '(') ADVANCE(254); - if (lookahead == ')') ADVANCE(255); - if (lookahead == '*') ADVANCE(304); - if (lookahead == '+') ADVANCE(392); - if (lookahead == '-') ADVANCE(394); - if (lookahead == '.') ADVANCE(362); - if (lookahead == '/') ADVANCE(402); - if (lookahead == ':') ADVANCE(251); - if (lookahead == ';') ADVANCE(238); - if (lookahead == '<') ADVANCE(413); - if (lookahead == '=') ADVANCE(239); - if (lookahead == '>') ADVANCE(415); - if (lookahead == '?') ADVANCE(391); - if (lookahead == '[') ADVANCE(315); + if (lookahead == '%') ADVANCE(405); + if (lookahead == '&') ADVANCE(399); + if (lookahead == '(') ADVANCE(253); + if (lookahead == ')') ADVANCE(254); + if (lookahead == '*') ADVANCE(305); + if (lookahead == '+') ADVANCE(393); + if (lookahead == '-') ADVANCE(395); + if (lookahead == '.') ADVANCE(363); + if (lookahead == '/') ADVANCE(403); + if (lookahead == ':') ADVANCE(250); + if (lookahead == ';') ADVANCE(237); + if (lookahead == '<') ADVANCE(414); + if (lookahead == '=') ADVANCE(238); + if (lookahead == '>') ADVANCE(416); + if (lookahead == '?') ADVANCE(392); + if (lookahead == '[') ADVANCE(316); if (lookahead == '\\') SKIP(28) - if (lookahead == ']') ADVANCE(316); - if (lookahead == '^') ADVANCE(411); + if (lookahead == ']') ADVANCE(317); + if (lookahead == '^') ADVANCE(412); if (lookahead == 'a') ADVANCE(184); if (lookahead == 'e') ADVANCE(140); if (lookahead == 'i') ADVANCE(185); - if (lookahead == '|') ADVANCE(314); + if (lookahead == '|') ADVANCE(315); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r' || lookahead == ' ') SKIP(49) END_STATE(); case 50: - if (lookahead == '!') ADVANCE(264); - if (lookahead == '"') ADVANCE(370); - if (lookahead == '&') ADVANCE(397); - if (lookahead == '\'') ADVANCE(364); - if (lookahead == '(') ADVANCE(254); - if (lookahead == ')') ADVANCE(255); - if (lookahead == '*') ADVANCE(304); - if (lookahead == '+') ADVANCE(392); - if (lookahead == ',') ADVANCE(245); - if (lookahead == '-') ADVANCE(394); + if (lookahead == '!') ADVANCE(263); + if (lookahead == '"') ADVANCE(371); + if (lookahead == '&') ADVANCE(398); + if (lookahead == '\'') ADVANCE(365); + if (lookahead == '(') ADVANCE(253); + if (lookahead == ')') ADVANCE(254); + if (lookahead == '*') ADVANCE(305); + if (lookahead == '+') ADVANCE(393); + if (lookahead == ',') ADVANCE(244); + if (lookahead == '-') ADVANCE(395); if (lookahead == '.') ADVANCE(61); if (lookahead == '/') ADVANCE(66); - if (lookahead == '0') ADVANCE(329); - if (lookahead == '1') ADVANCE(330); - if (lookahead == '2') ADVANCE(331); - if (lookahead == '3') ADVANCE(332); - if (lookahead == '4') ADVANCE(333); - if (lookahead == '5') ADVANCE(334); - if (lookahead == '6') ADVANCE(335); - if (lookahead == '7') ADVANCE(336); - if (lookahead == '8') ADVANCE(337); - if (lookahead == '9') ADVANCE(338); - if (lookahead == ':') ADVANCE(252); - if (lookahead == ';') ADVANCE(238); + if (lookahead == '0') ADVANCE(330); + if (lookahead == '1') ADVANCE(331); + if (lookahead == '2') ADVANCE(332); + if (lookahead == '3') ADVANCE(333); + if (lookahead == '4') ADVANCE(334); + if (lookahead == '5') ADVANCE(335); + if (lookahead == '6') ADVANCE(336); + if (lookahead == '7') ADVANCE(337); + if (lookahead == '8') ADVANCE(338); + if (lookahead == '9') ADVANCE(339); + if (lookahead == ':') ADVANCE(251); + if (lookahead == ';') ADVANCE(237); if (lookahead == '=') ADVANCE(86); - if (lookahead == '[') ADVANCE(315); + if (lookahead == '[') ADVANCE(316); if (lookahead == '\\') SKIP(2) - if (lookahead == ']') ADVANCE(316); - if (lookahead == 'a') ADVANCE(469); - if (lookahead == 'b') ADVANCE(552); - if (lookahead == 'c') ADVANCE(539); - if (lookahead == 'd') ADVANCE(478); - if (lookahead == 'e') ADVANCE(524); - if (lookahead == 'f') ADVANCE(467); - if (lookahead == 'i') ADVANCE(499); - if (lookahead == 'l') ADVANCE(479); - if (lookahead == 'm') ADVANCE(462); - if (lookahead == 'n') ADVANCE(578); - if (lookahead == 'o') ADVANCE(500); - if (lookahead == 'r') ADVANCE(491); - if (lookahead == 's') ADVANCE(507); - if (lookahead == 't') ADVANCE(551); - if (lookahead == 'v') ADVANCE(540); - if (lookahead == '{') ADVANCE(243); - if (lookahead == '}') ADVANCE(244); - if (lookahead == '~') ADVANCE(396); + if (lookahead == ']') ADVANCE(317); + if (lookahead == 'a') ADVANCE(470); + if (lookahead == 'b') ADVANCE(554); + if (lookahead == 'c') ADVANCE(540); + if (lookahead == 'd') ADVANCE(479); + if (lookahead == 'e') ADVANCE(525); + if (lookahead == 'f') ADVANCE(468); + if (lookahead == 'i') ADVANCE(500); + if (lookahead == 'l') ADVANCE(480); + if (lookahead == 'm') ADVANCE(463); + if (lookahead == 'n') ADVANCE(580); + if (lookahead == 'o') ADVANCE(501); + if (lookahead == 'r') ADVANCE(492); + if (lookahead == 's') ADVANCE(508); + if (lookahead == 't') ADVANCE(553); + if (lookahead == 'v') ADVANCE(541); + if (lookahead == '{') ADVANCE(242); + if (lookahead == '}') ADVANCE(243); + if (lookahead == '~') ADVANCE(397); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r' || lookahead == ' ') SKIP(50) if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('g' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('g' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 51: - if (lookahead == '!') ADVANCE(264); - if (lookahead == '"') ADVANCE(370); - if (lookahead == '&') ADVANCE(397); - if (lookahead == '\'') ADVANCE(364); - if (lookahead == '(') ADVANCE(254); - if (lookahead == ')') ADVANCE(255); - if (lookahead == '*') ADVANCE(304); - if (lookahead == '+') ADVANCE(392); - if (lookahead == ',') ADVANCE(245); - if (lookahead == '-') ADVANCE(394); + if (lookahead == '!') ADVANCE(263); + if (lookahead == '"') ADVANCE(371); + if (lookahead == '&') ADVANCE(398); + if (lookahead == '\'') ADVANCE(365); + if (lookahead == '(') ADVANCE(253); + if (lookahead == ')') ADVANCE(254); + if (lookahead == '*') ADVANCE(305); + if (lookahead == '+') ADVANCE(393); + if (lookahead == ',') ADVANCE(244); + if (lookahead == '-') ADVANCE(395); if (lookahead == '.') ADVANCE(61); if (lookahead == '/') ADVANCE(66); - if (lookahead == '0') ADVANCE(329); - if (lookahead == '1') ADVANCE(330); - if (lookahead == '2') ADVANCE(331); - if (lookahead == '3') ADVANCE(332); - if (lookahead == '4') ADVANCE(333); - if (lookahead == '5') ADVANCE(334); - if (lookahead == '6') ADVANCE(335); - if (lookahead == '7') ADVANCE(336); - if (lookahead == '8') ADVANCE(337); - if (lookahead == '9') ADVANCE(338); - if (lookahead == ':') ADVANCE(251); - if (lookahead == ';') ADVANCE(238); + if (lookahead == '0') ADVANCE(330); + if (lookahead == '1') ADVANCE(331); + if (lookahead == '2') ADVANCE(332); + if (lookahead == '3') ADVANCE(333); + if (lookahead == '4') ADVANCE(334); + if (lookahead == '5') ADVANCE(335); + if (lookahead == '6') ADVANCE(336); + if (lookahead == '7') ADVANCE(337); + if (lookahead == '8') ADVANCE(338); + if (lookahead == '9') ADVANCE(339); + if (lookahead == ':') ADVANCE(250); + if (lookahead == ';') ADVANCE(237); if (lookahead == '=') ADVANCE(86); - if (lookahead == '[') ADVANCE(315); + if (lookahead == '[') ADVANCE(316); if (lookahead == '\\') SKIP(4) - if (lookahead == ']') ADVANCE(316); - if (lookahead == 'a') ADVANCE(469); - if (lookahead == 'b') ADVANCE(552); - if (lookahead == 'c') ADVANCE(539); - if (lookahead == 'd') ADVANCE(478); - if (lookahead == 'f') ADVANCE(467); - if (lookahead == 'i') ADVANCE(499); - if (lookahead == 'l') ADVANCE(479); - if (lookahead == 'm') ADVANCE(462); - if (lookahead == 'n') ADVANCE(578); - if (lookahead == 'o') ADVANCE(500); - if (lookahead == 'r') ADVANCE(491); - if (lookahead == 's') ADVANCE(507); - if (lookahead == 't') ADVANCE(551); - if (lookahead == 'v') ADVANCE(540); - if (lookahead == '{') ADVANCE(243); - if (lookahead == '}') ADVANCE(244); - if (lookahead == '~') ADVANCE(396); + if (lookahead == ']') ADVANCE(317); + if (lookahead == 'a') ADVANCE(470); + if (lookahead == 'b') ADVANCE(554); + if (lookahead == 'c') ADVANCE(540); + if (lookahead == 'd') ADVANCE(479); + if (lookahead == 'f') ADVANCE(468); + if (lookahead == 'i') ADVANCE(500); + if (lookahead == 'l') ADVANCE(480); + if (lookahead == 'm') ADVANCE(463); + if (lookahead == 'n') ADVANCE(580); + if (lookahead == 'o') ADVANCE(501); + if (lookahead == 'r') ADVANCE(492); + if (lookahead == 's') ADVANCE(508); + if (lookahead == 't') ADVANCE(553); + if (lookahead == 'v') ADVANCE(541); + if (lookahead == '{') ADVANCE(242); + if (lookahead == '}') ADVANCE(243); + if (lookahead == '~') ADVANCE(397); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r' || lookahead == ' ') SKIP(51) if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('e' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('e' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 52: - if (lookahead == '!') ADVANCE(264); - if (lookahead == '"') ADVANCE(370); - if (lookahead == '&') ADVANCE(397); - if (lookahead == '\'') ADVANCE(364); - if (lookahead == '(') ADVANCE(254); - if (lookahead == ')') ADVANCE(255); - if (lookahead == '*') ADVANCE(304); - if (lookahead == '+') ADVANCE(392); - if (lookahead == ',') ADVANCE(245); - if (lookahead == '-') ADVANCE(394); - if (lookahead == '.') ADVANCE(363); + if (lookahead == '!') ADVANCE(263); + if (lookahead == '"') ADVANCE(371); + if (lookahead == '&') ADVANCE(398); + if (lookahead == '\'') ADVANCE(365); + if (lookahead == '(') ADVANCE(253); + if (lookahead == ')') ADVANCE(254); + if (lookahead == '*') ADVANCE(305); + if (lookahead == '+') ADVANCE(393); + if (lookahead == ',') ADVANCE(244); + if (lookahead == '-') ADVANCE(395); + if (lookahead == '.') ADVANCE(364); if (lookahead == '/') ADVANCE(66); - if (lookahead == '0') ADVANCE(329); - if (lookahead == '1') ADVANCE(330); - if (lookahead == '2') ADVANCE(331); - if (lookahead == '3') ADVANCE(332); - if (lookahead == '4') ADVANCE(333); - if (lookahead == '5') ADVANCE(334); - if (lookahead == '6') ADVANCE(335); - if (lookahead == '7') ADVANCE(336); - if (lookahead == '8') ADVANCE(337); - if (lookahead == '9') ADVANCE(338); - if (lookahead == ':') ADVANCE(252); - if (lookahead == ';') ADVANCE(238); - if (lookahead == '=') ADVANCE(241); - if (lookahead == '?') ADVANCE(391); - if (lookahead == '[') ADVANCE(315); + if (lookahead == '0') ADVANCE(330); + if (lookahead == '1') ADVANCE(331); + if (lookahead == '2') ADVANCE(332); + if (lookahead == '3') ADVANCE(333); + if (lookahead == '4') ADVANCE(334); + if (lookahead == '5') ADVANCE(335); + if (lookahead == '6') ADVANCE(336); + if (lookahead == '7') ADVANCE(337); + if (lookahead == '8') ADVANCE(338); + if (lookahead == '9') ADVANCE(339); + if (lookahead == ':') ADVANCE(251); + if (lookahead == ';') ADVANCE(237); + if (lookahead == '=') ADVANCE(240); + if (lookahead == '?') ADVANCE(392); + if (lookahead == '[') ADVANCE(316); if (lookahead == '\\') SKIP(10) - if (lookahead == ']') ADVANCE(316); - if (lookahead == 'a') ADVANCE(469); - if (lookahead == 'b') ADVANCE(552); - if (lookahead == 'c') ADVANCE(539); - if (lookahead == 'd') ADVANCE(478); - if (lookahead == 'f') ADVANCE(467); - if (lookahead == 'i') ADVANCE(499); - if (lookahead == 'l') ADVANCE(479); - if (lookahead == 'm') ADVANCE(462); - if (lookahead == 'n') ADVANCE(578); - if (lookahead == 'o') ADVANCE(500); - if (lookahead == 'r') ADVANCE(491); - if (lookahead == 's') ADVANCE(507); - if (lookahead == 't') ADVANCE(551); - if (lookahead == 'v') ADVANCE(540); - if (lookahead == '{') ADVANCE(243); - if (lookahead == '|') ADVANCE(312); - if (lookahead == '}') ADVANCE(244); - if (lookahead == '~') ADVANCE(396); + if (lookahead == ']') ADVANCE(317); + if (lookahead == 'a') ADVANCE(470); + if (lookahead == 'b') ADVANCE(554); + if (lookahead == 'c') ADVANCE(540); + if (lookahead == 'd') ADVANCE(479); + if (lookahead == 'f') ADVANCE(468); + if (lookahead == 'i') ADVANCE(500); + if (lookahead == 'l') ADVANCE(480); + if (lookahead == 'm') ADVANCE(463); + if (lookahead == 'n') ADVANCE(580); + if (lookahead == 'o') ADVANCE(501); + if (lookahead == 'r') ADVANCE(492); + if (lookahead == 's') ADVANCE(508); + if (lookahead == 't') ADVANCE(553); + if (lookahead == 'v') ADVANCE(541); + if (lookahead == '{') ADVANCE(242); + if (lookahead == '|') ADVANCE(313); + if (lookahead == '}') ADVANCE(243); + if (lookahead == '~') ADVANCE(397); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r' || lookahead == ' ') SKIP(52) if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('e' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('e' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 53: - if (lookahead == '!') ADVANCE(264); - if (lookahead == '"') ADVANCE(370); - if (lookahead == '&') ADVANCE(397); - if (lookahead == '\'') ADVANCE(364); - if (lookahead == '(') ADVANCE(254); - if (lookahead == ')') ADVANCE(255); - if (lookahead == '*') ADVANCE(304); - if (lookahead == '+') ADVANCE(392); - if (lookahead == ',') ADVANCE(245); - if (lookahead == '-') ADVANCE(394); + if (lookahead == '!') ADVANCE(263); + if (lookahead == '"') ADVANCE(371); + if (lookahead == '&') ADVANCE(398); + if (lookahead == '\'') ADVANCE(365); + if (lookahead == '(') ADVANCE(253); + if (lookahead == ')') ADVANCE(254); + if (lookahead == '*') ADVANCE(305); + if (lookahead == '+') ADVANCE(393); + if (lookahead == ',') ADVANCE(244); + if (lookahead == '-') ADVANCE(395); if (lookahead == '.') ADVANCE(63); if (lookahead == '/') ADVANCE(66); - if (lookahead == '0') ADVANCE(329); - if (lookahead == '1') ADVANCE(330); - if (lookahead == '2') ADVANCE(331); - if (lookahead == '3') ADVANCE(332); - if (lookahead == '4') ADVANCE(333); - if (lookahead == '5') ADVANCE(334); - if (lookahead == '6') ADVANCE(335); - if (lookahead == '7') ADVANCE(336); - if (lookahead == '8') ADVANCE(337); - if (lookahead == '9') ADVANCE(338); - if (lookahead == ':') ADVANCE(251); - if (lookahead == ';') ADVANCE(238); - if (lookahead == '[') ADVANCE(315); + if (lookahead == '0') ADVANCE(330); + if (lookahead == '1') ADVANCE(331); + if (lookahead == '2') ADVANCE(332); + if (lookahead == '3') ADVANCE(333); + if (lookahead == '4') ADVANCE(334); + if (lookahead == '5') ADVANCE(335); + if (lookahead == '6') ADVANCE(336); + if (lookahead == '7') ADVANCE(337); + if (lookahead == '8') ADVANCE(338); + if (lookahead == '9') ADVANCE(339); + if (lookahead == ':') ADVANCE(250); + if (lookahead == ';') ADVANCE(237); + if (lookahead == '[') ADVANCE(316); if (lookahead == '\\') SKIP(6) - if (lookahead == ']') ADVANCE(316); - if (lookahead == 'a') ADVANCE(469); - if (lookahead == 'b') ADVANCE(552); - if (lookahead == 'c') ADVANCE(539); - if (lookahead == 'd') ADVANCE(478); - if (lookahead == 'e') ADVANCE(524); - if (lookahead == 'f') ADVANCE(467); - if (lookahead == 'i') ADVANCE(499); - if (lookahead == 'l') ADVANCE(479); - if (lookahead == 'm') ADVANCE(462); - if (lookahead == 'n') ADVANCE(578); - if (lookahead == 'o') ADVANCE(500); - if (lookahead == 'r') ADVANCE(491); - if (lookahead == 's') ADVANCE(507); - if (lookahead == 't') ADVANCE(551); - if (lookahead == 'v') ADVANCE(540); - if (lookahead == '{') ADVANCE(243); - if (lookahead == '~') ADVANCE(396); + if (lookahead == ']') ADVANCE(317); + if (lookahead == 'a') ADVANCE(470); + if (lookahead == 'b') ADVANCE(554); + if (lookahead == 'c') ADVANCE(540); + if (lookahead == 'd') ADVANCE(479); + if (lookahead == 'e') ADVANCE(525); + if (lookahead == 'f') ADVANCE(468); + if (lookahead == 'i') ADVANCE(500); + if (lookahead == 'l') ADVANCE(480); + if (lookahead == 'm') ADVANCE(463); + if (lookahead == 'n') ADVANCE(580); + if (lookahead == 'o') ADVANCE(501); + if (lookahead == 'r') ADVANCE(492); + if (lookahead == 's') ADVANCE(508); + if (lookahead == 't') ADVANCE(553); + if (lookahead == 'v') ADVANCE(541); + if (lookahead == '{') ADVANCE(242); + if (lookahead == '~') ADVANCE(397); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r' || lookahead == ' ') SKIP(53) if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('g' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('g' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 54: - if (lookahead == '!') ADVANCE(264); - if (lookahead == '"') ADVANCE(370); - if (lookahead == '&') ADVANCE(397); - if (lookahead == '\'') ADVANCE(364); - if (lookahead == '(') ADVANCE(254); - if (lookahead == ')') ADVANCE(255); - if (lookahead == '*') ADVANCE(304); - if (lookahead == '+') ADVANCE(392); - if (lookahead == '-') ADVANCE(394); + if (lookahead == '!') ADVANCE(263); + if (lookahead == '"') ADVANCE(371); + if (lookahead == '&') ADVANCE(398); + if (lookahead == '\'') ADVANCE(365); + if (lookahead == '(') ADVANCE(253); + if (lookahead == ')') ADVANCE(254); + if (lookahead == '*') ADVANCE(305); + if (lookahead == '+') ADVANCE(393); + if (lookahead == '-') ADVANCE(395); if (lookahead == '.') ADVANCE(63); if (lookahead == '/') ADVANCE(66); - if (lookahead == '0') ADVANCE(329); - if (lookahead == '1') ADVANCE(330); - if (lookahead == '2') ADVANCE(331); - if (lookahead == '3') ADVANCE(332); - if (lookahead == '4') ADVANCE(333); - if (lookahead == '5') ADVANCE(334); - if (lookahead == '6') ADVANCE(335); - if (lookahead == '7') ADVANCE(336); - if (lookahead == '8') ADVANCE(337); - if (lookahead == '9') ADVANCE(338); - if (lookahead == ':') ADVANCE(251); - if (lookahead == ';') ADVANCE(238); - if (lookahead == '[') ADVANCE(315); + if (lookahead == '0') ADVANCE(330); + if (lookahead == '1') ADVANCE(331); + if (lookahead == '2') ADVANCE(332); + if (lookahead == '3') ADVANCE(333); + if (lookahead == '4') ADVANCE(334); + if (lookahead == '5') ADVANCE(335); + if (lookahead == '6') ADVANCE(336); + if (lookahead == '7') ADVANCE(337); + if (lookahead == '8') ADVANCE(338); + if (lookahead == '9') ADVANCE(339); + if (lookahead == ':') ADVANCE(250); + if (lookahead == ';') ADVANCE(237); + if (lookahead == '[') ADVANCE(316); if (lookahead == '\\') SKIP(8) - if (lookahead == ']') ADVANCE(316); - if (lookahead == 'a') ADVANCE(469); - if (lookahead == 'b') ADVANCE(552); - if (lookahead == 'c') ADVANCE(539); - if (lookahead == 'd') ADVANCE(478); - if (lookahead == 'f') ADVANCE(467); - if (lookahead == 'i') ADVANCE(499); - if (lookahead == 'l') ADVANCE(479); - if (lookahead == 'm') ADVANCE(462); - if (lookahead == 'n') ADVANCE(578); - if (lookahead == 'o') ADVANCE(500); - if (lookahead == 'r') ADVANCE(491); - if (lookahead == 's') ADVANCE(507); - if (lookahead == 't') ADVANCE(551); - if (lookahead == 'v') ADVANCE(540); - if (lookahead == '{') ADVANCE(243); - if (lookahead == '~') ADVANCE(396); + if (lookahead == ']') ADVANCE(317); + if (lookahead == 'a') ADVANCE(470); + if (lookahead == 'b') ADVANCE(554); + if (lookahead == 'c') ADVANCE(540); + if (lookahead == 'd') ADVANCE(479); + if (lookahead == 'f') ADVANCE(468); + if (lookahead == 'i') ADVANCE(500); + if (lookahead == 'l') ADVANCE(480); + if (lookahead == 'm') ADVANCE(463); + if (lookahead == 'n') ADVANCE(580); + if (lookahead == 'o') ADVANCE(501); + if (lookahead == 'r') ADVANCE(492); + if (lookahead == 's') ADVANCE(508); + if (lookahead == 't') ADVANCE(553); + if (lookahead == 'v') ADVANCE(541); + if (lookahead == '{') ADVANCE(242); + if (lookahead == '~') ADVANCE(397); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r' || lookahead == ' ') SKIP(54) if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('e' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('e' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 55: - if (lookahead == '!') ADVANCE(264); - if (lookahead == '"') ADVANCE(370); - if (lookahead == '&') ADVANCE(397); - if (lookahead == '\'') ADVANCE(364); - if (lookahead == '(') ADVANCE(254); - if (lookahead == '*') ADVANCE(304); - if (lookahead == '+') ADVANCE(392); - if (lookahead == '-') ADVANCE(394); + if (lookahead == '!') ADVANCE(263); + if (lookahead == '"') ADVANCE(371); + if (lookahead == '&') ADVANCE(398); + if (lookahead == '\'') ADVANCE(365); + if (lookahead == '(') ADVANCE(253); + if (lookahead == '*') ADVANCE(305); + if (lookahead == '+') ADVANCE(393); + if (lookahead == '-') ADVANCE(395); if (lookahead == '/') ADVANCE(66); - if (lookahead == '0') ADVANCE(329); - if (lookahead == '1') ADVANCE(330); - if (lookahead == '2') ADVANCE(331); - if (lookahead == '3') ADVANCE(332); - if (lookahead == '4') ADVANCE(333); - if (lookahead == '5') ADVANCE(334); - if (lookahead == '6') ADVANCE(335); - if (lookahead == '7') ADVANCE(336); - if (lookahead == '8') ADVANCE(337); - if (lookahead == '9') ADVANCE(338); + if (lookahead == '0') ADVANCE(330); + if (lookahead == '1') ADVANCE(331); + if (lookahead == '2') ADVANCE(332); + if (lookahead == '3') ADVANCE(333); + if (lookahead == '4') ADVANCE(334); + if (lookahead == '5') ADVANCE(335); + if (lookahead == '6') ADVANCE(336); + if (lookahead == '7') ADVANCE(337); + if (lookahead == '8') ADVANCE(338); + if (lookahead == '9') ADVANCE(339); if (lookahead == '=') ADVANCE(86); - if (lookahead == '[') ADVANCE(315); + if (lookahead == '[') ADVANCE(316); if (lookahead == '\\') SKIP(16) - if (lookahead == ']') ADVANCE(316); - if (lookahead == 'a') ADVANCE(469); - if (lookahead == 'd') ADVANCE(493); - if (lookahead == 'f') ADVANCE(468); - if (lookahead == 'l') ADVANCE(494); - if (lookahead == 'n') ADVANCE(578); - if (lookahead == 'o') ADVANCE(500); - if (lookahead == 's') ADVANCE(508); - if (lookahead == 't') ADVANCE(551); - if (lookahead == 'v') ADVANCE(540); - if (lookahead == '~') ADVANCE(396); + if (lookahead == ']') ADVANCE(317); + if (lookahead == 'a') ADVANCE(470); + if (lookahead == 'd') ADVANCE(494); + if (lookahead == 'f') ADVANCE(469); + if (lookahead == 'l') ADVANCE(495); + if (lookahead == 'n') ADVANCE(580); + if (lookahead == 'o') ADVANCE(501); + if (lookahead == 's') ADVANCE(509); + if (lookahead == 't') ADVANCE(553); + if (lookahead == 'v') ADVANCE(541); + if (lookahead == '~') ADVANCE(397); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r' || lookahead == ' ') SKIP(55) if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('b' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 56: - if (lookahead == '!') ADVANCE(264); - if (lookahead == '"') ADVANCE(370); - if (lookahead == '&') ADVANCE(397); - if (lookahead == '\'') ADVANCE(364); - if (lookahead == '(') ADVANCE(254); - if (lookahead == '*') ADVANCE(304); - if (lookahead == '+') ADVANCE(392); - if (lookahead == '-') ADVANCE(394); + if (lookahead == '!') ADVANCE(263); + if (lookahead == '"') ADVANCE(371); + if (lookahead == '&') ADVANCE(398); + if (lookahead == '\'') ADVANCE(365); + if (lookahead == '(') ADVANCE(253); + if (lookahead == '*') ADVANCE(305); + if (lookahead == '+') ADVANCE(393); + if (lookahead == '-') ADVANCE(395); if (lookahead == '/') ADVANCE(66); - if (lookahead == '0') ADVANCE(329); - if (lookahead == '1') ADVANCE(330); - if (lookahead == '2') ADVANCE(331); - if (lookahead == '3') ADVANCE(332); - if (lookahead == '4') ADVANCE(333); - if (lookahead == '5') ADVANCE(334); - if (lookahead == '6') ADVANCE(335); - if (lookahead == '7') ADVANCE(336); - if (lookahead == '8') ADVANCE(337); - if (lookahead == '9') ADVANCE(338); - if (lookahead == '[') ADVANCE(315); + if (lookahead == '0') ADVANCE(330); + if (lookahead == '1') ADVANCE(331); + if (lookahead == '2') ADVANCE(332); + if (lookahead == '3') ADVANCE(333); + if (lookahead == '4') ADVANCE(334); + if (lookahead == '5') ADVANCE(335); + if (lookahead == '6') ADVANCE(336); + if (lookahead == '7') ADVANCE(337); + if (lookahead == '8') ADVANCE(338); + if (lookahead == '9') ADVANCE(339); + if (lookahead == '[') ADVANCE(316); if (lookahead == '\\') SKIP(12) - if (lookahead == ']') ADVANCE(316); - if (lookahead == '_') ADVANCE(318); - if (lookahead == 'a') ADVANCE(469); - if (lookahead == 'd') ADVANCE(493); - if (lookahead == 'f') ADVANCE(468); - if (lookahead == 'l') ADVANCE(494); - if (lookahead == 'n') ADVANCE(578); - if (lookahead == 'o') ADVANCE(500); - if (lookahead == 's') ADVANCE(508); - if (lookahead == 't') ADVANCE(551); - if (lookahead == 'v') ADVANCE(540); - if (lookahead == '~') ADVANCE(396); + if (lookahead == ']') ADVANCE(317); + if (lookahead == '_') ADVANCE(319); + if (lookahead == 'a') ADVANCE(470); + if (lookahead == 'd') ADVANCE(494); + if (lookahead == 'f') ADVANCE(469); + if (lookahead == 'l') ADVANCE(495); + if (lookahead == 'n') ADVANCE(580); + if (lookahead == 'o') ADVANCE(501); + if (lookahead == 's') ADVANCE(509); + if (lookahead == 't') ADVANCE(553); + if (lookahead == 'v') ADVANCE(541); + if (lookahead == '~') ADVANCE(397); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r' || lookahead == ' ') SKIP(56) if (('A' <= lookahead && lookahead <= 'Z') || - ('b' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 57: - if (lookahead == '"') ADVANCE(370); + if (lookahead == '"') ADVANCE(371); if (lookahead == '/') ADVANCE(66); - if (lookahead == '\\') ADVANCE(367); + if (lookahead == '\\') ADVANCE(368); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r' || lookahead == ' ') SKIP(57) END_STATE(); case 58: - if (lookahead == '(') ADVANCE(254); - if (lookahead == ')') ADVANCE(255); - if (lookahead == '*') ADVANCE(304); + if (lookahead == '(') ADVANCE(253); + if (lookahead == ')') ADVANCE(254); + if (lookahead == '*') ADVANCE(305); if (lookahead == '.') ADVANCE(64); if (lookahead == '/') ADVANCE(66); if (lookahead == '=') ADVANCE(86); if (lookahead == '@') ADVANCE(154); - if (lookahead == '[') ADVANCE(315); + if (lookahead == '[') ADVANCE(316); if (lookahead == '\\') SKIP(22) - if (lookahead == 'b') ADVANCE(543); - if (lookahead == 'c') ADVANCE(505); - if (lookahead == 'e') ADVANCE(535); - if (lookahead == 'f') ADVANCE(456); - if (lookahead == 'i') ADVANCE(451); - if (lookahead == 'n') ADVANCE(584); - if (lookahead == 'r') ADVANCE(581); - if (lookahead == 's') ADVANCE(509); - if (lookahead == 'u') ADVANCE(452); - if (lookahead == 'v') ADVANCE(540); - if (lookahead == '}') ADVANCE(244); + if (lookahead == 'b') ADVANCE(544); + if (lookahead == 'c') ADVANCE(506); + if (lookahead == 'e') ADVANCE(536); + if (lookahead == 'f') ADVANCE(457); + if (lookahead == 'i') ADVANCE(452); + if (lookahead == 'n') ADVANCE(586); + if (lookahead == 'r') ADVANCE(583); + if (lookahead == 's') ADVANCE(510); + if (lookahead == 'u') ADVANCE(453); + if (lookahead == 'v') ADVANCE(541); + if (lookahead == '}') ADVANCE(243); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r' || lookahead == ' ') SKIP(58) if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 59: - if (lookahead == '(') ADVANCE(254); - if (lookahead == '*') ADVANCE(304); + if (lookahead == '(') ADVANCE(253); + if (lookahead == '*') ADVANCE(305); if (lookahead == '.') ADVANCE(64); if (lookahead == '/') ADVANCE(66); if (lookahead == '@') ADVANCE(154); - if (lookahead == '[') ADVANCE(315); + if (lookahead == '[') ADVANCE(316); if (lookahead == '\\') SKIP(24) - if (lookahead == 'b') ADVANCE(543); - if (lookahead == 'c') ADVANCE(506); - if (lookahead == 'e') ADVANCE(535); - if (lookahead == 'f') ADVANCE(456); - if (lookahead == 'i') ADVANCE(451); - if (lookahead == 'n') ADVANCE(584); - if (lookahead == 'r') ADVANCE(581); - if (lookahead == 's') ADVANCE(509); - if (lookahead == 'u') ADVANCE(452); - if (lookahead == 'v') ADVANCE(540); + if (lookahead == 'b') ADVANCE(544); + if (lookahead == 'c') ADVANCE(507); + if (lookahead == 'e') ADVANCE(536); + if (lookahead == 'f') ADVANCE(457); + if (lookahead == 'i') ADVANCE(452); + if (lookahead == 'n') ADVANCE(586); + if (lookahead == 'r') ADVANCE(583); + if (lookahead == 's') ADVANCE(510); + if (lookahead == 'u') ADVANCE(453); + if (lookahead == 'v') ADVANCE(541); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r' || lookahead == ' ') SKIP(59) if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 60: - if (lookahead == ')') ADVANCE(255); + if (lookahead == ')') ADVANCE(254); if (lookahead == '.') ADVANCE(64); if (lookahead == '/') ADVANCE(66); if (lookahead == '\\') SKIP(37) - if (lookahead == '_') ADVANCE(318); + if (lookahead == '_') ADVANCE(319); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r' || lookahead == ' ') SKIP(60) if (('A' <= lookahead && lookahead <= 'Z') || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 61: - if (lookahead == '.') ADVANCE(390); + if (lookahead == '.') ADVANCE(391); END_STATE(); case 62: - if (lookahead == '.') ADVANCE(319); + if (lookahead == '.') ADVANCE(320); END_STATE(); case 63: - if (lookahead == '.') ADVANCE(389); + if (lookahead == '.') ADVANCE(390); END_STATE(); case 64: if (lookahead == '.') ADVANCE(62); @@ -3029,57 +3066,57 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { if (lookahead == '.') ADVANCE(64); if (lookahead == '/') ADVANCE(66); if (lookahead == '\\') SKIP(34) - if (lookahead == 's') ADVANCE(576); - if (lookahead == '}') ADVANCE(244); + if (lookahead == 's') ADVANCE(578); + if (lookahead == '}') ADVANCE(243); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r' || lookahead == ' ') SKIP(65) if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 66: - if (lookahead == '/') ADVANCE(587); + if (lookahead == '/') ADVANCE(589); END_STATE(); case 67: if (lookahead == '/') ADVANCE(66); - if (lookahead == '0') ADVANCE(329); - if (lookahead == '1') ADVANCE(330); - if (lookahead == '2') ADVANCE(331); - if (lookahead == '3') ADVANCE(332); - if (lookahead == '4') ADVANCE(333); - if (lookahead == '5') ADVANCE(334); - if (lookahead == '6') ADVANCE(335); - if (lookahead == '7') ADVANCE(336); - if (lookahead == '8') ADVANCE(337); - if (lookahead == '9') ADVANCE(338); - if (lookahead == ';') ADVANCE(238); + if (lookahead == '0') ADVANCE(330); + if (lookahead == '1') ADVANCE(331); + if (lookahead == '2') ADVANCE(332); + if (lookahead == '3') ADVANCE(333); + if (lookahead == '4') ADVANCE(334); + if (lookahead == '5') ADVANCE(335); + if (lookahead == '6') ADVANCE(336); + if (lookahead == '7') ADVANCE(337); + if (lookahead == '8') ADVANCE(338); + if (lookahead == '9') ADVANCE(339); + if (lookahead == ';') ADVANCE(237); if (lookahead == '@') ADVANCE(183); if (lookahead == '\\') SKIP(30) - if (lookahead == '}') ADVANCE(244); + if (lookahead == '}') ADVANCE(243); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r' || lookahead == ' ') SKIP(67) if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 68: if (lookahead == '/') ADVANCE(66); if (lookahead == '@') ADVANCE(170); if (lookahead == '\\') SKIP(32) - if (lookahead == 's') ADVANCE(576); - if (lookahead == 'u') ADVANCE(534); - if (lookahead == '}') ADVANCE(244); + if (lookahead == 's') ADVANCE(578); + if (lookahead == 'u') ADVANCE(535); + if (lookahead == '}') ADVANCE(243); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r' || lookahead == ' ') SKIP(68) if (('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 69: if (lookahead == '/') ADVANCE(66); @@ -3101,39 +3138,39 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { lookahead == ' ') SKIP(70) END_STATE(); case 71: - if (lookahead == '/') ADVANCE(366); - if (lookahead == '\\') ADVANCE(367); + if (lookahead == '/') ADVANCE(367); + if (lookahead == '\\') ADVANCE(368); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r' || - lookahead == ' ') ADVANCE(365); + lookahead == ' ') ADVANCE(366); if (lookahead != 0 && - lookahead != '\'') ADVANCE(365); + lookahead != '\'') ADVANCE(366); END_STATE(); case 72: if (lookahead == '1') ADVANCE(82); if (lookahead == '3') ADVANCE(74); if (lookahead == '6') ADVANCE(79); - if (lookahead == '8') ADVANCE(272); + if (lookahead == '8') ADVANCE(273); if (lookahead == 'n') ADVANCE(194); - if (lookahead == 's') ADVANCE(401); + if (lookahead == 's') ADVANCE(402); END_STATE(); case 73: if (lookahead == '1') ADVANCE(83); if (lookahead == '3') ADVANCE(75); if (lookahead == '6') ADVANCE(80); - if (lookahead == '8') ADVANCE(280); + if (lookahead == '8') ADVANCE(281); if (lookahead == 'i') ADVANCE(158); if (lookahead == 's') ADVANCE(100); END_STATE(); case 74: - if (lookahead == '2') ADVANCE(276); + if (lookahead == '2') ADVANCE(277); END_STATE(); case 75: - if (lookahead == '2') ADVANCE(284); + if (lookahead == '2') ADVANCE(285); END_STATE(); case 76: - if (lookahead == '2') ADVANCE(298); + if (lookahead == '2') ADVANCE(299); END_STATE(); case 77: if (lookahead == '3') ADVANCE(76); @@ -3142,33 +3179,33 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { case 78: if (lookahead == '3') ADVANCE(76); if (lookahead == '6') ADVANCE(81); - if (lookahead == 'n') ADVANCE(258); + if (lookahead == 'n') ADVANCE(257); if (lookahead == 'o') ADVANCE(174); END_STATE(); case 79: - if (lookahead == '4') ADVANCE(278); + if (lookahead == '4') ADVANCE(279); END_STATE(); case 80: - if (lookahead == '4') ADVANCE(286); + if (lookahead == '4') ADVANCE(287); END_STATE(); case 81: - if (lookahead == '4') ADVANCE(300); + if (lookahead == '4') ADVANCE(301); END_STATE(); case 82: - if (lookahead == '6') ADVANCE(274); + if (lookahead == '6') ADVANCE(275); END_STATE(); case 83: - if (lookahead == '6') ADVANCE(282); + if (lookahead == '6') ADVANCE(283); END_STATE(); case 84: - if (lookahead == '=') ADVANCE(419); + if (lookahead == '=') ADVANCE(420); END_STATE(); case 85: - if (lookahead == '=') ADVANCE(418); - if (lookahead == '>') ADVANCE(431); + if (lookahead == '=') ADVANCE(419); + if (lookahead == '>') ADVANCE(432); END_STATE(); case 86: - if (lookahead == '>') ADVANCE(431); + if (lookahead == '>') ADVANCE(432); END_STATE(); case 87: if (lookahead == 'a') ADVANCE(139); @@ -3181,7 +3218,7 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { END_STATE(); case 90: if (lookahead == 'a') ADVANCE(207); - if (lookahead == 'r') ADVANCE(213); + if (lookahead == 'r') ADVANCE(267); END_STATE(); case 91: if (lookahead == 'b') ADVANCE(168); @@ -3190,10 +3227,10 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { if (lookahead == 'c') ADVANCE(126); END_STATE(); case 93: - if (lookahead == 'c') ADVANCE(373); + if (lookahead == 'c') ADVANCE(374); END_STATE(); case 94: - if (lookahead == 'c') ADVANCE(382); + if (lookahead == 'c') ADVANCE(383); END_STATE(); case 95: if (lookahead == 'c') ADVANCE(127); @@ -3202,37 +3239,37 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { if (lookahead == 'c') ADVANCE(202); END_STATE(); case 97: - if (lookahead == 'd') ADVANCE(270); + if (lookahead == 'd') ADVANCE(271); END_STATE(); case 98: - if (lookahead == 'd') ADVANCE(375); + if (lookahead == 'd') ADVANCE(376); END_STATE(); case 99: if (lookahead == 'e') ADVANCE(150); END_STATE(); case 100: - if (lookahead == 'e') ADVANCE(237); + if (lookahead == 'e') ADVANCE(236); END_STATE(); case 101: - if (lookahead == 'e') ADVANCE(425); + if (lookahead == 'e') ADVANCE(426); END_STATE(); case 102: - if (lookahead == 'e') ADVANCE(377); + if (lookahead == 'e') ADVANCE(378); END_STATE(); case 103: - if (lookahead == 'e') ADVANCE(266); + if (lookahead == 'e') ADVANCE(265); END_STATE(); case 104: - if (lookahead == 'e') ADVANCE(292); + if (lookahead == 'e') ADVANCE(293); END_STATE(); case 105: - if (lookahead == 'e') ADVANCE(320); + if (lookahead == 'e') ADVANCE(321); END_STATE(); case 106: - if (lookahead == 'e') ADVANCE(257); + if (lookahead == 'e') ADVANCE(256); END_STATE(); case 107: - if (lookahead == 'e') ADVANCE(447); + if (lookahead == 'e') ADVANCE(448); END_STATE(); case 108: if (lookahead == 'e') ADVANCE(186); @@ -3273,18 +3310,18 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { if (lookahead == 'i') ADVANCE(159); if (lookahead == 'n') ADVANCE(162); if (lookahead == 'o') ADVANCE(125); - if (lookahead == 's') ADVANCE(218); + if (lookahead == 's') ADVANCE(217); if (lookahead == 't') ADVANCE(108); END_STATE(); case 120: if (lookahead == 'f') ADVANCE(137); if (lookahead == 'i') ADVANCE(159); if (lookahead == 'n') ADVANCE(162); - if (lookahead == 's') ADVANCE(218); + if (lookahead == 's') ADVANCE(217); if (lookahead == 't') ADVANCE(108); END_STATE(); case 121: - if (lookahead == 'f') ADVANCE(256); + if (lookahead == 'f') ADVANCE(255); END_STATE(); case 122: if (lookahead == 'f') ADVANCE(123); @@ -3299,20 +3336,20 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { if (lookahead == 'f') ADVANCE(124); END_STATE(); case 126: - if (lookahead == 'h') ADVANCE(432); + if (lookahead == 'h') ADVANCE(433); END_STATE(); case 127: - if (lookahead == 'h') ADVANCE(429); + if (lookahead == 'h') ADVANCE(430); END_STATE(); case 128: if (lookahead == 'h') ADVANCE(89); if (lookahead == 'o') ADVANCE(160); END_STATE(); case 129: - if (lookahead == 'i') ADVANCE(220); + if (lookahead == 'i') ADVANCE(219); END_STATE(); case 130: - if (lookahead == 'i') ADVANCE(220); + if (lookahead == 'i') ADVANCE(219); if (lookahead == 't') ADVANCE(90); if (lookahead == 'w') ADVANCE(138); END_STATE(); @@ -3320,7 +3357,7 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { if (lookahead == 'i') ADVANCE(97); END_STATE(); case 132: - if (lookahead == 'i') ADVANCE(260); + if (lookahead == 'i') ADVANCE(259); END_STATE(); case 133: if (lookahead == 'i') ADVANCE(94); @@ -3341,7 +3378,7 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { if (lookahead == 'i') ADVANCE(209); END_STATE(); case 139: - if (lookahead == 'k') ADVANCE(445); + if (lookahead == 'k') ADVANCE(446); END_STATE(); case 140: if (lookahead == 'l') ADVANCE(187); @@ -3351,13 +3388,13 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { if (lookahead == 'x') ADVANCE(173); END_STATE(); case 142: - if (lookahead == 'l') ADVANCE(268); + if (lookahead == 'l') ADVANCE(269); END_STATE(); case 143: - if (lookahead == 'l') ADVANCE(323); + if (lookahead == 'l') ADVANCE(324); END_STATE(); case 144: - if (lookahead == 'l') ADVANCE(253); + if (lookahead == 'l') ADVANCE(252); END_STATE(); case 145: if (lookahead == 'l') ADVANCE(163); @@ -3369,23 +3406,23 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { if (lookahead == 'm') ADVANCE(91); END_STATE(); case 148: - if (lookahead == 'm') ADVANCE(302); + if (lookahead == 'm') ADVANCE(303); END_STATE(); case 149: if (lookahead == 'n') ADVANCE(189); END_STATE(); case 150: - if (lookahead == 'n') ADVANCE(385); - if (lookahead == 't') ADVANCE(247); + if (lookahead == 'n') ADVANCE(386); + if (lookahead == 't') ADVANCE(246); END_STATE(); case 151: - if (lookahead == 'n') ADVANCE(309); + if (lookahead == 'n') ADVANCE(310); END_STATE(); case 152: - if (lookahead == 'n') ADVANCE(449); + if (lookahead == 'n') ADVANCE(450); END_STATE(); case 153: - if (lookahead == 'n') ADVANCE(263); + if (lookahead == 'n') ADVANCE(262); END_STATE(); case 154: if (lookahead == 'n') ADVANCE(162); @@ -3409,7 +3446,7 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { if (lookahead == 'n') ADVANCE(188); END_STATE(); case 161: - if (lookahead == 'n') ADVANCE(216); + if (lookahead == 'n') ADVANCE(215); END_STATE(); case 162: if (lookahead == 'o') ADVANCE(181); @@ -3448,16 +3485,16 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { if (lookahead == 'p') ADVANCE(166); END_STATE(); case 174: - if (lookahead == 'r') ADVANCE(427); + if (lookahead == 'r') ADVANCE(428); END_STATE(); case 175: - if (lookahead == 'r') ADVANCE(296); + if (lookahead == 'r') ADVANCE(297); END_STATE(); case 176: - if (lookahead == 'r') ADVANCE(294); + if (lookahead == 'r') ADVANCE(295); END_STATE(); case 177: - if (lookahead == 'r') ADVANCE(215); + if (lookahead == 'r') ADVANCE(214); if (lookahead == 'y') ADVANCE(172); END_STATE(); case 178: @@ -3476,13 +3513,13 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { if (lookahead == 'r') ADVANCE(205); END_STATE(); case 183: - if (lookahead == 's') ADVANCE(218); + if (lookahead == 's') ADVANCE(217); END_STATE(); case 184: - if (lookahead == 's') ADVANCE(400); + if (lookahead == 's') ADVANCE(401); END_STATE(); case 185: - if (lookahead == 's') ADVANCE(401); + if (lookahead == 's') ADVANCE(402); END_STATE(); case 186: if (lookahead == 's') ADVANCE(198); @@ -3510,43 +3547,43 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { if (lookahead == 's') ADVANCE(192); END_STATE(); case 194: - if (lookahead == 't') ADVANCE(288); + if (lookahead == 't') ADVANCE(289); END_STATE(); case 195: - if (lookahead == 't') ADVANCE(247); + if (lookahead == 't') ADVANCE(246); END_STATE(); case 196: if (lookahead == 't') ADVANCE(92); END_STATE(); case 197: - if (lookahead == 't') ADVANCE(261); + if (lookahead == 't') ADVANCE(260); END_STATE(); case 198: - if (lookahead == 't') ADVANCE(262); + if (lookahead == 't') ADVANCE(261); END_STATE(); case 199: - if (lookahead == 't') ADVANCE(249); + if (lookahead == 't') ADVANCE(248); END_STATE(); case 200: - if (lookahead == 't') ADVANCE(246); + if (lookahead == 't') ADVANCE(245); END_STATE(); case 201: - if (lookahead == 't') ADVANCE(387); + if (lookahead == 't') ADVANCE(388); END_STATE(); case 202: - if (lookahead == 't') ADVANCE(307); + if (lookahead == 't') ADVANCE(308); END_STATE(); case 203: - if (lookahead == 't') ADVANCE(311); + if (lookahead == 't') ADVANCE(312); END_STATE(); case 204: - if (lookahead == 't') ADVANCE(291); + if (lookahead == 't') ADVANCE(292); END_STATE(); case 205: - if (lookahead == 't') ADVANCE(380); + if (lookahead == 't') ADVANCE(381); END_STATE(); case 206: - if (lookahead == 't') ADVANCE(214); + if (lookahead == 't') ADVANCE(213); END_STATE(); case 207: if (lookahead == 't') ADVANCE(133); @@ -3558,7 +3595,7 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { if (lookahead == 't') ADVANCE(95); END_STATE(); case 210: - if (lookahead == 't') ADVANCE(217); + if (lookahead == 't') ADVANCE(216); END_STATE(); case 211: if (lookahead == 'u') ADVANCE(146); @@ -3567,45 +3604,47 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { if (lookahead == 'u') ADVANCE(148); END_STATE(); case 213: - if (lookahead == 'u') ADVANCE(96); - END_STATE(); - case 214: if (lookahead == 'u') ADVANCE(178); END_STATE(); - case 215: + case 214: if (lookahead == 'u') ADVANCE(105); END_STATE(); - case 216: + case 215: if (lookahead == 'u') ADVANCE(107); END_STATE(); - case 217: + case 216: if (lookahead == 'u') ADVANCE(179); END_STATE(); - case 218: + case 217: if (lookahead == 'y') ADVANCE(147); END_STATE(); - case 219: + case 218: if (lookahead == 'y') ADVANCE(172); END_STATE(); - case 220: + case 219: if (lookahead == 'z') ADVANCE(104); END_STATE(); - case 221: - if (aux_sym_named_escape_token1_character_set_1(lookahead)) ADVANCE(369); + case 220: + if (aux_sym_named_escape_token1_character_set_1(lookahead)) ADVANCE(370); if (lookahead == '/') ADVANCE(66); - if (lookahead == 'U') ADVANCE(229); - if (lookahead == '\\') ADVANCE(369); - if (lookahead == 'u') ADVANCE(225); - if (lookahead == 'x') ADVANCE(223); + if (lookahead == 'U') ADVANCE(228); + if (lookahead == '\\') ADVANCE(370); + if (lookahead == 'u') ADVANCE(224); + if (lookahead == 'x') ADVANCE(222); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r' || lookahead == ' ') SKIP(70) END_STATE(); + case 221: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(369); + END_STATE(); case 222: if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'F') || - ('a' <= lookahead && lookahead <= 'f')) ADVANCE(368); + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(221); END_STATE(); case 223: if (('0' <= lookahead && lookahead <= '9') || @@ -3638,67 +3677,62 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { ('a' <= lookahead && lookahead <= 'f')) ADVANCE(227); END_STATE(); case 229: - if (('0' <= lookahead && lookahead <= '9') || - ('A' <= lookahead && lookahead <= 'F') || - ('a' <= lookahead && lookahead <= 'f')) ADVANCE(228); + if (lookahead != 0 && + lookahead != '\r') ADVANCE(589); + if (lookahead == '\r') ADVANCE(590); END_STATE(); case 230: - if (lookahead != 0 && - lookahead != '\r') ADVANCE(587); - if (lookahead == '\r') ADVANCE(588); + if (eof) ADVANCE(235); + if (lookahead == '\n') SKIP(0) END_STATE(); case 231: - if (eof) ADVANCE(236); + if (eof) ADVANCE(235); if (lookahead == '\n') SKIP(0) + if (lookahead == '\r') SKIP(230) END_STATE(); case 232: - if (eof) ADVANCE(236); - if (lookahead == '\n') SKIP(0) - if (lookahead == '\r') SKIP(231) + if (eof) ADVANCE(235); + if (lookahead == '\n') SKIP(234) END_STATE(); case 233: - if (eof) ADVANCE(236); - if (lookahead == '\n') SKIP(235) + if (eof) ADVANCE(235); + if (lookahead == '\n') SKIP(234) + if (lookahead == '\r') SKIP(232) END_STATE(); case 234: - if (eof) ADVANCE(236); - if (lookahead == '\n') SKIP(235) - if (lookahead == '\r') SKIP(233) - END_STATE(); - case 235: - if (eof) ADVANCE(236); + if (eof) ADVANCE(235); if (lookahead == '!') ADVANCE(84); - if (lookahead == '%') ADVANCE(405); - if (lookahead == '&') ADVANCE(399); - if (lookahead == '(') ADVANCE(254); - if (lookahead == ')') ADVANCE(255); - if (lookahead == '*') ADVANCE(305); - if (lookahead == '+') ADVANCE(393); - if (lookahead == ',') ADVANCE(245); - if (lookahead == '-') ADVANCE(395); - if (lookahead == '.') ADVANCE(361); - if (lookahead == '/') ADVANCE(403); - if (lookahead == '0') ADVANCE(328); - if (lookahead == '1') ADVANCE(330); - if (lookahead == '2') ADVANCE(331); - if (lookahead == '3') ADVANCE(332); - if (lookahead == '4') ADVANCE(333); - if (lookahead == '5') ADVANCE(334); - if (lookahead == '6') ADVANCE(335); - if (lookahead == '7') ADVANCE(336); - if (lookahead == '8') ADVANCE(337); - if (lookahead == '9') ADVANCE(338); - if (lookahead == ':') ADVANCE(251); - if (lookahead == ';') ADVANCE(238); - if (lookahead == '<') ADVANCE(412); - if (lookahead == '=') ADVANCE(240); - if (lookahead == '>') ADVANCE(414); - if (lookahead == '?') ADVANCE(391); + if (lookahead == '%') ADVANCE(406); + if (lookahead == '&') ADVANCE(400); + if (lookahead == '(') ADVANCE(253); + if (lookahead == ')') ADVANCE(254); + if (lookahead == '*') ADVANCE(306); + if (lookahead == '+') ADVANCE(394); + if (lookahead == ',') ADVANCE(244); + if (lookahead == '-') ADVANCE(396); + if (lookahead == '.') ADVANCE(362); + if (lookahead == '/') ADVANCE(404); + if (lookahead == '0') ADVANCE(329); + if (lookahead == '1') ADVANCE(331); + if (lookahead == '2') ADVANCE(332); + if (lookahead == '3') ADVANCE(333); + if (lookahead == '4') ADVANCE(334); + if (lookahead == '5') ADVANCE(335); + if (lookahead == '6') ADVANCE(336); + if (lookahead == '7') ADVANCE(337); + if (lookahead == '8') ADVANCE(338); + if (lookahead == '9') ADVANCE(339); + if (lookahead == ':') ADVANCE(250); + if (lookahead == ';') ADVANCE(237); + if (lookahead == '<') ADVANCE(413); + if (lookahead == '=') ADVANCE(239); + if (lookahead == '>') ADVANCE(415); + if (lookahead == '?') ADVANCE(392); if (lookahead == '@') ADVANCE(120); - if (lookahead == '[') ADVANCE(315); - if (lookahead == '\\') SKIP(234) - if (lookahead == ']') ADVANCE(316); - if (lookahead == '^') ADVANCE(410); + if (lookahead == '[') ADVANCE(316); + if (lookahead == '\\') SKIP(233) + if (lookahead == ']') ADVANCE(317); + if (lookahead == '^') ADVANCE(411); if (lookahead == 'a') ADVANCE(184); if (lookahead == 'c') ADVANCE(128); if (lookahead == 'd') ADVANCE(110); @@ -3707,1210 +3741,1214 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { if (lookahead == 'i') ADVANCE(72); if (lookahead == 'l') ADVANCE(116); if (lookahead == 's') ADVANCE(129); - if (lookahead == 't') ADVANCE(219); + if (lookahead == 't') ADVANCE(218); if (lookahead == 'u') ADVANCE(73); - if (lookahead == '{') ADVANCE(243); - if (lookahead == '|') ADVANCE(313); - if (lookahead == '}') ADVANCE(244); + if (lookahead == '{') ADVANCE(242); + if (lookahead == '|') ADVANCE(314); + if (lookahead == '}') ADVANCE(243); if (lookahead == '\t' || lookahead == '\n' || lookahead == '\r' || - lookahead == ' ') SKIP(235) + lookahead == ' ') SKIP(234) END_STATE(); - case 236: + case 235: ACCEPT_TOKEN(ts_builtin_sym_end); END_STATE(); - case 237: + case 236: ACCEPT_TOKEN(anon_sym_use); END_STATE(); - case 238: + case 237: ACCEPT_TOKEN(anon_sym_SEMI); END_STATE(); + case 238: + ACCEPT_TOKEN(anon_sym_EQ); + if (lookahead == '=') ADVANCE(419); + END_STATE(); case 239: ACCEPT_TOKEN(anon_sym_EQ); - if (lookahead == '=') ADVANCE(418); + if (lookahead == '=') ADVANCE(419); + if (lookahead == '>') ADVANCE(432); END_STATE(); case 240: ACCEPT_TOKEN(anon_sym_EQ); - if (lookahead == '=') ADVANCE(418); - if (lookahead == '>') ADVANCE(431); + if (lookahead == '>') ADVANCE(432); END_STATE(); case 241: - ACCEPT_TOKEN(anon_sym_EQ); - if (lookahead == '>') ADVANCE(431); - END_STATE(); - case 242: ACCEPT_TOKEN(anon_sym_COLON_COLON); END_STATE(); - case 243: + case 242: ACCEPT_TOKEN(anon_sym_LBRACE); END_STATE(); - case 244: + case 243: ACCEPT_TOKEN(anon_sym_RBRACE); END_STATE(); - case 245: + case 244: ACCEPT_TOKEN(anon_sym_COMMA); END_STATE(); - case 246: + case 245: ACCEPT_TOKEN(anon_sym_export); END_STATE(); - case 247: + case 246: ACCEPT_TOKEN(anon_sym_let); END_STATE(); - case 248: + case 247: ACCEPT_TOKEN(anon_sym_let); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); - case 249: + case 248: ACCEPT_TOKEN(anon_sym_const); END_STATE(); - case 250: + case 249: ACCEPT_TOKEN(anon_sym_const); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); - case 251: + case 250: ACCEPT_TOKEN(anon_sym_COLON); END_STATE(); - case 252: + case 251: ACCEPT_TOKEN(anon_sym_COLON); - if (lookahead == ':') ADVANCE(242); + if (lookahead == ':') ADVANCE(241); END_STATE(); - case 253: + case 252: ACCEPT_TOKEN(anon_sym_ATsymbol); END_STATE(); - case 254: + case 253: ACCEPT_TOKEN(anon_sym_LPAREN); END_STATE(); - case 255: + case 254: ACCEPT_TOKEN(anon_sym_RPAREN); END_STATE(); - case 256: + case 255: ACCEPT_TOKEN(anon_sym_def); END_STATE(); - case 257: + case 256: ACCEPT_TOKEN(anon_sym_type); END_STATE(); - case 258: + case 257: ACCEPT_TOKEN(anon_sym_fn); END_STATE(); - case 259: + case 258: ACCEPT_TOKEN(anon_sym_fn); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); - case 260: + case 259: ACCEPT_TOKEN(anon_sym_ATfini); END_STATE(); - case 261: + case 260: ACCEPT_TOKEN(anon_sym_ATinit); END_STATE(); - case 262: + case 261: ACCEPT_TOKEN(anon_sym_ATtest); END_STATE(); - case 263: + case 262: ACCEPT_TOKEN(anon_sym_ATnoreturn); END_STATE(); + case 263: + ACCEPT_TOKEN(anon_sym_BANG); + END_STATE(); case 264: ACCEPT_TOKEN(anon_sym_BANG); + if (lookahead == '=') ADVANCE(420); END_STATE(); case 265: - ACCEPT_TOKEN(anon_sym_BANG); - if (lookahead == '=') ADVANCE(419); + ACCEPT_TOKEN(anon_sym_rune); END_STATE(); case 266: ACCEPT_TOKEN(anon_sym_rune); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 267: - ACCEPT_TOKEN(anon_sym_rune); + ACCEPT_TOKEN(anon_sym_str); + if (lookahead == 'u') ADVANCE(96); + END_STATE(); + case 268: + ACCEPT_TOKEN(anon_sym_str); + if (lookahead == 'u') ADVANCE(476); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); - case 268: + case 269: ACCEPT_TOKEN(anon_sym_bool); END_STATE(); - case 269: + case 270: ACCEPT_TOKEN(anon_sym_bool); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); - case 270: + case 271: ACCEPT_TOKEN(anon_sym_void); END_STATE(); - case 271: + case 272: ACCEPT_TOKEN(anon_sym_void); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); - case 272: + case 273: ACCEPT_TOKEN(anon_sym_i8); END_STATE(); - case 273: + case 274: ACCEPT_TOKEN(anon_sym_i8); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); - case 274: + case 275: ACCEPT_TOKEN(anon_sym_i16); END_STATE(); - case 275: + case 276: ACCEPT_TOKEN(anon_sym_i16); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); - case 276: + case 277: ACCEPT_TOKEN(anon_sym_i32); END_STATE(); - case 277: + case 278: ACCEPT_TOKEN(anon_sym_i32); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); - case 278: + case 279: ACCEPT_TOKEN(anon_sym_i64); END_STATE(); - case 279: + case 280: ACCEPT_TOKEN(anon_sym_i64); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); - case 280: + case 281: ACCEPT_TOKEN(anon_sym_u8); END_STATE(); - case 281: + case 282: ACCEPT_TOKEN(anon_sym_u8); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); - case 282: + case 283: ACCEPT_TOKEN(anon_sym_u16); END_STATE(); - case 283: + case 284: ACCEPT_TOKEN(anon_sym_u16); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); - case 284: + case 285: ACCEPT_TOKEN(anon_sym_u32); END_STATE(); - case 285: + case 286: ACCEPT_TOKEN(anon_sym_u32); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); - case 286: + case 287: ACCEPT_TOKEN(anon_sym_u64); END_STATE(); - case 287: + case 288: ACCEPT_TOKEN(anon_sym_u64); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); - case 288: + case 289: ACCEPT_TOKEN(anon_sym_int); END_STATE(); - case 289: + case 290: ACCEPT_TOKEN(anon_sym_int); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); - case 290: + case 291: ACCEPT_TOKEN(anon_sym_uint); - if (lookahead == 'p') ADVANCE(573); + if (lookahead == 'p') ADVANCE(575); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); - case 291: + case 292: ACCEPT_TOKEN(anon_sym_uint); if (lookahead == 'p') ADVANCE(208); END_STATE(); - case 292: + case 293: ACCEPT_TOKEN(anon_sym_size); END_STATE(); - case 293: + case 294: ACCEPT_TOKEN(anon_sym_size); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); - case 294: + case 295: ACCEPT_TOKEN(anon_sym_uintptr); END_STATE(); - case 295: + case 296: ACCEPT_TOKEN(anon_sym_uintptr); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); - case 296: + case 297: ACCEPT_TOKEN(anon_sym_char); END_STATE(); - case 297: + case 298: ACCEPT_TOKEN(anon_sym_char); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); - case 298: + case 299: ACCEPT_TOKEN(anon_sym_f32); END_STATE(); - case 299: + case 300: ACCEPT_TOKEN(anon_sym_f32); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); - case 300: + case 301: ACCEPT_TOKEN(anon_sym_f64); END_STATE(); - case 301: + case 302: ACCEPT_TOKEN(anon_sym_f64); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); - case 302: + case 303: ACCEPT_TOKEN(anon_sym_enum); END_STATE(); - case 303: + case 304: ACCEPT_TOKEN(anon_sym_enum); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); - END_STATE(); - case 304: - ACCEPT_TOKEN(anon_sym_STAR); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 305: ACCEPT_TOKEN(anon_sym_STAR); - if (lookahead == '=') ADVANCE(436); END_STATE(); case 306: + ACCEPT_TOKEN(anon_sym_STAR); + if (lookahead == '=') ADVANCE(437); + END_STATE(); + case 307: ACCEPT_TOKEN(anon_sym_nullable); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); - case 307: + case 308: ACCEPT_TOKEN(anon_sym_struct); END_STATE(); - case 308: + case 309: ACCEPT_TOKEN(anon_sym_struct); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); - case 309: + case 310: ACCEPT_TOKEN(anon_sym_union); END_STATE(); - case 310: + case 311: ACCEPT_TOKEN(anon_sym_union); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); - END_STATE(); - case 311: - ACCEPT_TOKEN(anon_sym_AToffset); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 312: - ACCEPT_TOKEN(anon_sym_PIPE); + ACCEPT_TOKEN(anon_sym_AToffset); END_STATE(); case 313: ACCEPT_TOKEN(anon_sym_PIPE); - if (lookahead == '=') ADVANCE(442); - if (lookahead == '|') ADVANCE(422); END_STATE(); case 314: ACCEPT_TOKEN(anon_sym_PIPE); - if (lookahead == '|') ADVANCE(422); + if (lookahead == '=') ADVANCE(443); + if (lookahead == '|') ADVANCE(423); END_STATE(); case 315: - ACCEPT_TOKEN(anon_sym_LBRACK); + ACCEPT_TOKEN(anon_sym_PIPE); + if (lookahead == '|') ADVANCE(423); END_STATE(); case 316: - ACCEPT_TOKEN(anon_sym_RBRACK); + ACCEPT_TOKEN(anon_sym_LBRACK); END_STATE(); case 317: - ACCEPT_TOKEN(anon_sym__); + ACCEPT_TOKEN(anon_sym_RBRACK); END_STATE(); case 318: + ACCEPT_TOKEN(anon_sym__); + END_STATE(); + case 319: ACCEPT_TOKEN(anon_sym__); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); - case 319: + case 320: ACCEPT_TOKEN(anon_sym_DOT_DOT_DOT); END_STATE(); - case 320: + case 321: ACCEPT_TOKEN(anon_sym_true); END_STATE(); - case 321: + case 322: ACCEPT_TOKEN(anon_sym_true); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); - case 322: + case 323: ACCEPT_TOKEN(anon_sym_false); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); - case 323: + case 324: ACCEPT_TOKEN(anon_sym_null); END_STATE(); - case 324: + case 325: ACCEPT_TOKEN(anon_sym_null); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); - END_STATE(); - case 325: - ACCEPT_TOKEN(anon_sym_0x); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 326: - ACCEPT_TOKEN(anon_sym_0o); + ACCEPT_TOKEN(anon_sym_0x); END_STATE(); case 327: - ACCEPT_TOKEN(anon_sym_0b); + ACCEPT_TOKEN(anon_sym_0o); END_STATE(); case 328: - ACCEPT_TOKEN(anon_sym_0); + ACCEPT_TOKEN(anon_sym_0b); END_STATE(); case 329: ACCEPT_TOKEN(anon_sym_0); - if (lookahead == 'b') ADVANCE(327); - if (lookahead == 'o') ADVANCE(326); - if (lookahead == 'x') ADVANCE(325); END_STATE(); case 330: - ACCEPT_TOKEN(anon_sym_1); + ACCEPT_TOKEN(anon_sym_0); + if (lookahead == 'b') ADVANCE(328); + if (lookahead == 'o') ADVANCE(327); + if (lookahead == 'x') ADVANCE(326); END_STATE(); case 331: - ACCEPT_TOKEN(anon_sym_2); + ACCEPT_TOKEN(anon_sym_1); END_STATE(); case 332: - ACCEPT_TOKEN(anon_sym_3); + ACCEPT_TOKEN(anon_sym_2); END_STATE(); case 333: - ACCEPT_TOKEN(anon_sym_4); + ACCEPT_TOKEN(anon_sym_3); END_STATE(); case 334: - ACCEPT_TOKEN(anon_sym_5); + ACCEPT_TOKEN(anon_sym_4); END_STATE(); case 335: - ACCEPT_TOKEN(anon_sym_6); + ACCEPT_TOKEN(anon_sym_5); END_STATE(); case 336: - ACCEPT_TOKEN(anon_sym_7); + ACCEPT_TOKEN(anon_sym_6); END_STATE(); case 337: - ACCEPT_TOKEN(anon_sym_8); + ACCEPT_TOKEN(anon_sym_7); END_STATE(); case 338: - ACCEPT_TOKEN(anon_sym_9); + ACCEPT_TOKEN(anon_sym_8); END_STATE(); case 339: - ACCEPT_TOKEN(anon_sym_A); + ACCEPT_TOKEN(anon_sym_9); END_STATE(); case 340: - ACCEPT_TOKEN(anon_sym_B); + ACCEPT_TOKEN(anon_sym_A); END_STATE(); case 341: - ACCEPT_TOKEN(anon_sym_C); + ACCEPT_TOKEN(anon_sym_B); END_STATE(); case 342: - ACCEPT_TOKEN(anon_sym_D); + ACCEPT_TOKEN(anon_sym_C); END_STATE(); case 343: - ACCEPT_TOKEN(anon_sym_E); + ACCEPT_TOKEN(anon_sym_D); END_STATE(); case 344: - ACCEPT_TOKEN(anon_sym_F); + ACCEPT_TOKEN(anon_sym_E); END_STATE(); case 345: + ACCEPT_TOKEN(anon_sym_F); + END_STATE(); + case 346: ACCEPT_TOKEN(anon_sym_a); if (lookahead == 'l') ADVANCE(145); if (lookahead == 'p') ADVANCE(171); - if (lookahead == 's') ADVANCE(400); + if (lookahead == 's') ADVANCE(401); END_STATE(); - case 346: + case 347: ACCEPT_TOKEN(anon_sym_a); - if (lookahead == 's') ADVANCE(400); + if (lookahead == 's') ADVANCE(401); END_STATE(); - case 347: + case 348: ACCEPT_TOKEN(anon_sym_b); END_STATE(); - case 348: + case 349: ACCEPT_TOKEN(anon_sym_b); if (lookahead == 'o') ADVANCE(164); if (lookahead == 'r') ADVANCE(109); END_STATE(); - case 349: + case 350: ACCEPT_TOKEN(anon_sym_c); END_STATE(); - case 350: + case 351: ACCEPT_TOKEN(anon_sym_c); if (lookahead == 'h') ADVANCE(89); if (lookahead == 'o') ADVANCE(149); END_STATE(); - case 351: + case 352: ACCEPT_TOKEN(anon_sym_d); END_STATE(); - case 352: + case 353: ACCEPT_TOKEN(anon_sym_e); if (lookahead == 'l') ADVANCE(187); END_STATE(); - case 353: + case 354: ACCEPT_TOKEN(anon_sym_e); if (lookahead == 'l') ADVANCE(187); if (lookahead == 'n') ADVANCE(212); if (lookahead == 'x') ADVANCE(173); END_STATE(); - case 354: + case 355: ACCEPT_TOKEN(anon_sym_f); END_STATE(); - case 355: + case 356: ACCEPT_TOKEN(anon_sym_f); - if (lookahead == 'n') ADVANCE(258); + if (lookahead == 'n') ADVANCE(257); if (lookahead == 'o') ADVANCE(174); if (lookahead == 'r') ADVANCE(113); END_STATE(); - case 356: + case 357: ACCEPT_TOKEN(anon_sym_i); if (lookahead == '1') ADVANCE(82); if (lookahead == '3') ADVANCE(74); if (lookahead == '6') ADVANCE(79); - if (lookahead == '8') ADVANCE(272); - if (lookahead == 'f') ADVANCE(423); + if (lookahead == '8') ADVANCE(273); + if (lookahead == 'f') ADVANCE(424); if (lookahead == 'n') ADVANCE(194); - if (lookahead == 's') ADVANCE(401); + if (lookahead == 's') ADVANCE(402); END_STATE(); - case 357: + case 358: ACCEPT_TOKEN(anon_sym_i); if (lookahead == '1') ADVANCE(82); if (lookahead == '3') ADVANCE(74); if (lookahead == '6') ADVANCE(79); - if (lookahead == '8') ADVANCE(272); - if (lookahead == 's') ADVANCE(401); + if (lookahead == '8') ADVANCE(273); + if (lookahead == 's') ADVANCE(402); END_STATE(); - case 358: + case 359: ACCEPT_TOKEN(anon_sym_u); if (lookahead == '1') ADVANCE(83); if (lookahead == '3') ADVANCE(75); if (lookahead == '6') ADVANCE(80); - if (lookahead == '8') ADVANCE(280); + if (lookahead == '8') ADVANCE(281); END_STATE(); - case 359: + case 360: ACCEPT_TOKEN(anon_sym_u); if (lookahead == '1') ADVANCE(83); if (lookahead == '3') ADVANCE(75); if (lookahead == '6') ADVANCE(80); - if (lookahead == '8') ADVANCE(280); + if (lookahead == '8') ADVANCE(281); if (lookahead == 'n') ADVANCE(134); if (lookahead == 's') ADVANCE(100); END_STATE(); - case 360: - ACCEPT_TOKEN(anon_sym_z); - END_STATE(); case 361: - ACCEPT_TOKEN(anon_sym_DOT); - if (lookahead == '.') ADVANCE(390); + ACCEPT_TOKEN(anon_sym_z); END_STATE(); case 362: ACCEPT_TOKEN(anon_sym_DOT); - if (lookahead == '.') ADVANCE(389); + if (lookahead == '.') ADVANCE(391); END_STATE(); case 363: ACCEPT_TOKEN(anon_sym_DOT); - if (lookahead == '.') ADVANCE(62); + if (lookahead == '.') ADVANCE(390); END_STATE(); case 364: - ACCEPT_TOKEN(anon_sym_SQUOTE); + ACCEPT_TOKEN(anon_sym_DOT); + if (lookahead == '.') ADVANCE(62); END_STATE(); case 365: - ACCEPT_TOKEN(aux_sym_rune_token1); + ACCEPT_TOKEN(anon_sym_SQUOTE); END_STATE(); case 366: ACCEPT_TOKEN(aux_sym_rune_token1); - if (lookahead == '/') ADVANCE(587); END_STATE(); case 367: - ACCEPT_TOKEN(anon_sym_BSLASH); + ACCEPT_TOKEN(aux_sym_rune_token1); + if (lookahead == '/') ADVANCE(589); END_STATE(); case 368: - ACCEPT_TOKEN(aux_sym_escape_sequence_token1); + ACCEPT_TOKEN(anon_sym_BSLASH); END_STATE(); case 369: - ACCEPT_TOKEN(aux_sym_named_escape_token1); + ACCEPT_TOKEN(aux_sym_escape_sequence_token1); END_STATE(); case 370: - ACCEPT_TOKEN(anon_sym_DQUOTE); + ACCEPT_TOKEN(aux_sym_named_escape_token1); END_STATE(); case 371: - ACCEPT_TOKEN(aux_sym_string_char_token1); + ACCEPT_TOKEN(anon_sym_DQUOTE); END_STATE(); case 372: ACCEPT_TOKEN(aux_sym_string_char_token1); - if (lookahead == '/') ADVANCE(587); END_STATE(); case 373: - ACCEPT_TOKEN(anon_sym_alloc); + ACCEPT_TOKEN(aux_sym_string_char_token1); + if (lookahead == '/') ADVANCE(589); END_STATE(); case 374: + ACCEPT_TOKEN(anon_sym_alloc); + END_STATE(); + case 375: ACCEPT_TOKEN(anon_sym_alloc); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); - case 375: + case 376: ACCEPT_TOKEN(anon_sym_append); END_STATE(); - case 376: + case 377: ACCEPT_TOKEN(anon_sym_append); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); - case 377: + case 378: ACCEPT_TOKEN(anon_sym_free); END_STATE(); - case 378: + case 379: ACCEPT_TOKEN(anon_sym_free); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); - case 379: + case 380: ACCEPT_TOKEN(anon_sym_delete); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); - case 380: + case 381: ACCEPT_TOKEN(anon_sym_assert); END_STATE(); - case 381: + case 382: ACCEPT_TOKEN(anon_sym_assert); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); - case 382: + case 383: ACCEPT_TOKEN(anon_sym_static); END_STATE(); - case 383: + case 384: ACCEPT_TOKEN(anon_sym_static); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); - case 384: + case 385: ACCEPT_TOKEN(anon_sym_abort); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); - case 385: + case 386: ACCEPT_TOKEN(anon_sym_len); END_STATE(); - case 386: + case 387: ACCEPT_TOKEN(anon_sym_len); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); - case 387: + case 388: ACCEPT_TOKEN(anon_sym_offset); END_STATE(); - case 388: + case 389: ACCEPT_TOKEN(anon_sym_offset); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); - END_STATE(); - case 389: - ACCEPT_TOKEN(anon_sym_DOT_DOT); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 390: ACCEPT_TOKEN(anon_sym_DOT_DOT); - if (lookahead == '.') ADVANCE(319); END_STATE(); case 391: - ACCEPT_TOKEN(anon_sym_QMARK); + ACCEPT_TOKEN(anon_sym_DOT_DOT); + if (lookahead == '.') ADVANCE(320); END_STATE(); case 392: - ACCEPT_TOKEN(anon_sym_PLUS); + ACCEPT_TOKEN(anon_sym_QMARK); END_STATE(); case 393: ACCEPT_TOKEN(anon_sym_PLUS); - if (lookahead == '=') ADVANCE(434); END_STATE(); case 394: - ACCEPT_TOKEN(anon_sym_DASH); + ACCEPT_TOKEN(anon_sym_PLUS); + if (lookahead == '=') ADVANCE(435); END_STATE(); case 395: ACCEPT_TOKEN(anon_sym_DASH); - if (lookahead == '=') ADVANCE(435); END_STATE(); case 396: - ACCEPT_TOKEN(anon_sym_TILDE); + ACCEPT_TOKEN(anon_sym_DASH); + if (lookahead == '=') ADVANCE(436); END_STATE(); case 397: - ACCEPT_TOKEN(anon_sym_AMP); + ACCEPT_TOKEN(anon_sym_TILDE); END_STATE(); case 398: ACCEPT_TOKEN(anon_sym_AMP); - if (lookahead == '&') ADVANCE(420); END_STATE(); case 399: ACCEPT_TOKEN(anon_sym_AMP); - if (lookahead == '&') ADVANCE(420); - if (lookahead == '=') ADVANCE(441); + if (lookahead == '&') ADVANCE(421); END_STATE(); case 400: - ACCEPT_TOKEN(anon_sym_as); + ACCEPT_TOKEN(anon_sym_AMP); + if (lookahead == '&') ADVANCE(421); + if (lookahead == '=') ADVANCE(442); END_STATE(); case 401: - ACCEPT_TOKEN(anon_sym_is); + ACCEPT_TOKEN(anon_sym_as); END_STATE(); case 402: - ACCEPT_TOKEN(anon_sym_SLASH); - if (lookahead == '/') ADVANCE(587); + ACCEPT_TOKEN(anon_sym_is); END_STATE(); case 403: ACCEPT_TOKEN(anon_sym_SLASH); - if (lookahead == '/') ADVANCE(587); - if (lookahead == '=') ADVANCE(437); + if (lookahead == '/') ADVANCE(589); END_STATE(); case 404: - ACCEPT_TOKEN(anon_sym_PERCENT); + ACCEPT_TOKEN(anon_sym_SLASH); + if (lookahead == '/') ADVANCE(589); + if (lookahead == '=') ADVANCE(438); END_STATE(); case 405: ACCEPT_TOKEN(anon_sym_PERCENT); - if (lookahead == '=') ADVANCE(438); END_STATE(); case 406: - ACCEPT_TOKEN(anon_sym_LT_LT); + ACCEPT_TOKEN(anon_sym_PERCENT); + if (lookahead == '=') ADVANCE(439); END_STATE(); case 407: ACCEPT_TOKEN(anon_sym_LT_LT); - if (lookahead == '=') ADVANCE(439); END_STATE(); case 408: - ACCEPT_TOKEN(anon_sym_GT_GT); + ACCEPT_TOKEN(anon_sym_LT_LT); + if (lookahead == '=') ADVANCE(440); END_STATE(); case 409: ACCEPT_TOKEN(anon_sym_GT_GT); - if (lookahead == '=') ADVANCE(440); END_STATE(); case 410: - ACCEPT_TOKEN(anon_sym_CARET); - if (lookahead == '=') ADVANCE(443); - if (lookahead == '^') ADVANCE(421); + ACCEPT_TOKEN(anon_sym_GT_GT); + if (lookahead == '=') ADVANCE(441); END_STATE(); case 411: ACCEPT_TOKEN(anon_sym_CARET); - if (lookahead == '^') ADVANCE(421); + if (lookahead == '=') ADVANCE(444); + if (lookahead == '^') ADVANCE(422); END_STATE(); case 412: - ACCEPT_TOKEN(anon_sym_LT); - if (lookahead == '<') ADVANCE(407); - if (lookahead == '=') ADVANCE(416); + ACCEPT_TOKEN(anon_sym_CARET); + if (lookahead == '^') ADVANCE(422); END_STATE(); case 413: ACCEPT_TOKEN(anon_sym_LT); - if (lookahead == '<') ADVANCE(406); - if (lookahead == '=') ADVANCE(416); + if (lookahead == '<') ADVANCE(408); + if (lookahead == '=') ADVANCE(417); END_STATE(); case 414: - ACCEPT_TOKEN(anon_sym_GT); + ACCEPT_TOKEN(anon_sym_LT); + if (lookahead == '<') ADVANCE(407); if (lookahead == '=') ADVANCE(417); - if (lookahead == '>') ADVANCE(409); END_STATE(); case 415: ACCEPT_TOKEN(anon_sym_GT); - if (lookahead == '=') ADVANCE(417); - if (lookahead == '>') ADVANCE(408); + if (lookahead == '=') ADVANCE(418); + if (lookahead == '>') ADVANCE(410); END_STATE(); case 416: - ACCEPT_TOKEN(anon_sym_LT_EQ); + ACCEPT_TOKEN(anon_sym_GT); + if (lookahead == '=') ADVANCE(418); + if (lookahead == '>') ADVANCE(409); END_STATE(); case 417: - ACCEPT_TOKEN(anon_sym_GT_EQ); + ACCEPT_TOKEN(anon_sym_LT_EQ); END_STATE(); case 418: - ACCEPT_TOKEN(anon_sym_EQ_EQ); + ACCEPT_TOKEN(anon_sym_GT_EQ); END_STATE(); case 419: - ACCEPT_TOKEN(anon_sym_BANG_EQ); + ACCEPT_TOKEN(anon_sym_EQ_EQ); END_STATE(); case 420: - ACCEPT_TOKEN(anon_sym_AMP_AMP); + ACCEPT_TOKEN(anon_sym_BANG_EQ); END_STATE(); case 421: - ACCEPT_TOKEN(anon_sym_CARET_CARET); + ACCEPT_TOKEN(anon_sym_AMP_AMP); END_STATE(); case 422: - ACCEPT_TOKEN(anon_sym_PIPE_PIPE); + ACCEPT_TOKEN(anon_sym_CARET_CARET); END_STATE(); case 423: - ACCEPT_TOKEN(anon_sym_if); + ACCEPT_TOKEN(anon_sym_PIPE_PIPE); END_STATE(); case 424: + ACCEPT_TOKEN(anon_sym_if); + END_STATE(); + case 425: ACCEPT_TOKEN(anon_sym_if); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); - case 425: + case 426: ACCEPT_TOKEN(anon_sym_else); END_STATE(); - case 426: + case 427: ACCEPT_TOKEN(anon_sym_else); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); - case 427: + case 428: ACCEPT_TOKEN(anon_sym_for); END_STATE(); - case 428: + case 429: ACCEPT_TOKEN(anon_sym_for); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); - case 429: + case 430: ACCEPT_TOKEN(anon_sym_switch); END_STATE(); - case 430: + case 431: ACCEPT_TOKEN(anon_sym_switch); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); - case 431: + case 432: ACCEPT_TOKEN(anon_sym_EQ_GT); END_STATE(); - case 432: + case 433: ACCEPT_TOKEN(anon_sym_match); END_STATE(); - case 433: + case 434: ACCEPT_TOKEN(anon_sym_match); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); - case 434: + case 435: ACCEPT_TOKEN(anon_sym_PLUS_EQ); END_STATE(); - case 435: + case 436: ACCEPT_TOKEN(anon_sym_DASH_EQ); END_STATE(); - case 436: + case 437: ACCEPT_TOKEN(anon_sym_STAR_EQ); END_STATE(); - case 437: + case 438: ACCEPT_TOKEN(anon_sym_SLASH_EQ); END_STATE(); - case 438: + case 439: ACCEPT_TOKEN(anon_sym_PERCENT_EQ); END_STATE(); - case 439: + case 440: ACCEPT_TOKEN(anon_sym_LT_LT_EQ); END_STATE(); - case 440: + case 441: ACCEPT_TOKEN(anon_sym_GT_GT_EQ); END_STATE(); - case 441: + case 442: ACCEPT_TOKEN(anon_sym_AMP_EQ); END_STATE(); - case 442: + case 443: ACCEPT_TOKEN(anon_sym_PIPE_EQ); END_STATE(); - case 443: + case 444: ACCEPT_TOKEN(anon_sym_CARET_EQ); END_STATE(); - case 444: + case 445: ACCEPT_TOKEN(anon_sym_defer); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); - case 445: + case 446: ACCEPT_TOKEN(anon_sym_break); END_STATE(); - case 446: + case 447: ACCEPT_TOKEN(anon_sym_break); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); - case 447: + case 448: ACCEPT_TOKEN(anon_sym_continue); END_STATE(); - case 448: + case 449: ACCEPT_TOKEN(anon_sym_continue); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); - END_STATE(); - case 449: - ACCEPT_TOKEN(anon_sym_return); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 450: ACCEPT_TOKEN(anon_sym_return); - if (('0' <= lookahead && lookahead <= '9') || - ('A' <= lookahead && lookahead <= 'Z') || - lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); END_STATE(); case 451: - ACCEPT_TOKEN(sym_name); - if (lookahead == '1') ADVANCE(460); - if (lookahead == '3') ADVANCE(454); - if (lookahead == '6') ADVANCE(458); - if (lookahead == '8') ADVANCE(273); - if (lookahead == 'n') ADVANCE(569); + ACCEPT_TOKEN(anon_sym_return); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 452: ACCEPT_TOKEN(sym_name); if (lookahead == '1') ADVANCE(461); if (lookahead == '3') ADVANCE(455); if (lookahead == '6') ADVANCE(459); - if (lookahead == '8') ADVANCE(281); - if (lookahead == 'i') ADVANCE(536); - if (lookahead == 'n') ADVANCE(513); + if (lookahead == '8') ADVANCE(274); + if (lookahead == 'n') ADVANCE(571); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 453: ACCEPT_TOKEN(sym_name); - if (lookahead == '2') ADVANCE(299); + if (lookahead == '1') ADVANCE(462); + if (lookahead == '3') ADVANCE(456); + if (lookahead == '6') ADVANCE(460); + if (lookahead == '8') ADVANCE(282); + if (lookahead == 'i') ADVANCE(537); + if (lookahead == 'n') ADVANCE(514); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 454: ACCEPT_TOKEN(sym_name); - if (lookahead == '2') ADVANCE(277); + if (lookahead == '2') ADVANCE(300); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 455: ACCEPT_TOKEN(sym_name); - if (lookahead == '2') ADVANCE(285); + if (lookahead == '2') ADVANCE(278); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 456: ACCEPT_TOKEN(sym_name); - if (lookahead == '3') ADVANCE(453); - if (lookahead == '6') ADVANCE(457); - if (lookahead == 'n') ADVANCE(259); + if (lookahead == '2') ADVANCE(286); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 457: ACCEPT_TOKEN(sym_name); - if (lookahead == '4') ADVANCE(301); + if (lookahead == '3') ADVANCE(454); + if (lookahead == '6') ADVANCE(458); + if (lookahead == 'n') ADVANCE(258); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 458: ACCEPT_TOKEN(sym_name); - if (lookahead == '4') ADVANCE(279); + if (lookahead == '4') ADVANCE(302); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 459: ACCEPT_TOKEN(sym_name); - if (lookahead == '4') ADVANCE(287); + if (lookahead == '4') ADVANCE(280); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 460: ACCEPT_TOKEN(sym_name); - if (lookahead == '6') ADVANCE(275); + if (lookahead == '4') ADVANCE(288); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 461: ACCEPT_TOKEN(sym_name); - if (lookahead == '6') ADVANCE(283); + if (lookahead == '6') ADVANCE(276); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 462: ACCEPT_TOKEN(sym_name); - if (lookahead == 'a') ADVANCE(563); + if (lookahead == '6') ADVANCE(284); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('b' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 463: ACCEPT_TOKEN(sym_name); - if (lookahead == 'a') ADVANCE(515); + if (lookahead == 'a') ADVANCE(565); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('b' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 464: ACCEPT_TOKEN(sym_name); - if (lookahead == 'a') ADVANCE(470); + if (lookahead == 'a') ADVANCE(516); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('b' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 465: ACCEPT_TOKEN(sym_name); - if (lookahead == 'a') ADVANCE(572); - if (lookahead == 'r') ADVANCE(579); + if (lookahead == 'a') ADVANCE(471); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('b' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 466: ACCEPT_TOKEN(sym_name); - if (lookahead == 'a') ADVANCE(549); + if (lookahead == 'a') ADVANCE(574); + if (lookahead == 'r') ADVANCE(581); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('b' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 467: ACCEPT_TOKEN(sym_name); - if (lookahead == 'a') ADVANCE(525); - if (lookahead == 'o') ADVANCE(547); - if (lookahead == 'r') ADVANCE(497); + if (lookahead == 'a') ADVANCE(551); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('b' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 468: ACCEPT_TOKEN(sym_name); - if (lookahead == 'a') ADVANCE(525); - if (lookahead == 'r') ADVANCE(497); + if (lookahead == 'a') ADVANCE(526); + if (lookahead == 'o') ADVANCE(548); + if (lookahead == 'r') ADVANCE(498); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('b' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 469: ACCEPT_TOKEN(sym_name); - if (lookahead == 'b') ADVANCE(542); - if (lookahead == 'l') ADVANCE(518); - if (lookahead == 'p') ADVANCE(546); - if (lookahead == 's') ADVANCE(559); + if (lookahead == 'a') ADVANCE(526); + if (lookahead == 'r') ADVANCE(498); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 470: ACCEPT_TOKEN(sym_name); - if (lookahead == 'b') ADVANCE(523); + if (lookahead == 'b') ADVANCE(543); + if (lookahead == 'l') ADVANCE(519); + if (lookahead == 'p') ADVANCE(547); + if (lookahead == 's') ADVANCE(561); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 471: ACCEPT_TOKEN(sym_name); - if (lookahead == 'c') ADVANCE(503); + if (lookahead == 'b') ADVANCE(524); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 472: ACCEPT_TOKEN(sym_name); - if (lookahead == 'c') ADVANCE(374); + if (lookahead == 'c') ADVANCE(504); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 473: ACCEPT_TOKEN(sym_name); - if (lookahead == 'c') ADVANCE(383); + if (lookahead == 'c') ADVANCE(375); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 474: ACCEPT_TOKEN(sym_name); - if (lookahead == 'c') ADVANCE(504); + if (lookahead == 'c') ADVANCE(384); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 475: ACCEPT_TOKEN(sym_name); - if (lookahead == 'c') ADVANCE(568); + if (lookahead == 'c') ADVANCE(505); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 476: ACCEPT_TOKEN(sym_name); - if (lookahead == 'd') ADVANCE(271); + if (lookahead == 'c') ADVANCE(570); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 477: ACCEPT_TOKEN(sym_name); - if (lookahead == 'd') ADVANCE(376); + if (lookahead == 'd') ADVANCE(272); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 478: ACCEPT_TOKEN(sym_name); - if (lookahead == 'e') ADVANCE(501); + if (lookahead == 'd') ADVANCE(377); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 479: ACCEPT_TOKEN(sym_name); - if (lookahead == 'e') ADVANCE(528); + if (lookahead == 'e') ADVANCE(502); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 480: ACCEPT_TOKEN(sym_name); - if (lookahead == 'e') ADVANCE(426); + if (lookahead == 'e') ADVANCE(529); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 481: ACCEPT_TOKEN(sym_name); - if (lookahead == 'e') ADVANCE(378); + if (lookahead == 'e') ADVANCE(427); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 482: ACCEPT_TOKEN(sym_name); - if (lookahead == 'e') ADVANCE(293); + if (lookahead == 'e') ADVANCE(379); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 483: ACCEPT_TOKEN(sym_name); - if (lookahead == 'e') ADVANCE(321); + if (lookahead == 'e') ADVANCE(294); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 484: ACCEPT_TOKEN(sym_name); @@ -4918,842 +4956,858 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 485: ACCEPT_TOKEN(sym_name); - if (lookahead == 'e') ADVANCE(379); + if (lookahead == 'e') ADVANCE(323); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 486: ACCEPT_TOKEN(sym_name); - if (lookahead == 'e') ADVANCE(448); + if (lookahead == 'e') ADVANCE(380); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 487: ACCEPT_TOKEN(sym_name); - if (lookahead == 'e') ADVANCE(267); + if (lookahead == 'e') ADVANCE(449); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 488: ACCEPT_TOKEN(sym_name); - if (lookahead == 'e') ADVANCE(306); + if (lookahead == 'e') ADVANCE(266); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 489: ACCEPT_TOKEN(sym_name); - if (lookahead == 'e') ADVANCE(463); + if (lookahead == 'e') ADVANCE(307); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 490: ACCEPT_TOKEN(sym_name); - if (lookahead == 'e') ADVANCE(533); + if (lookahead == 'e') ADVANCE(464); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 491: ACCEPT_TOKEN(sym_name); - if (lookahead == 'e') ADVANCE(571); + if (lookahead == 'e') ADVANCE(534); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 492: ACCEPT_TOKEN(sym_name); - if (lookahead == 'e') ADVANCE(548); + if (lookahead == 'e') ADVANCE(573); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 493: ACCEPT_TOKEN(sym_name); - if (lookahead == 'e') ADVANCE(522); + if (lookahead == 'e') ADVANCE(549); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 494: ACCEPT_TOKEN(sym_name); - if (lookahead == 'e') ADVANCE(529); + if (lookahead == 'e') ADVANCE(523); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 495: ACCEPT_TOKEN(sym_name); - if (lookahead == 'e') ADVANCE(574); + if (lookahead == 'e') ADVANCE(530); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 496: ACCEPT_TOKEN(sym_name); - if (lookahead == 'e') ADVANCE(567); + if (lookahead == 'e') ADVANCE(576); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 497: ACCEPT_TOKEN(sym_name); - if (lookahead == 'e') ADVANCE(481); + if (lookahead == 'e') ADVANCE(569); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 498: ACCEPT_TOKEN(sym_name); - if (lookahead == 'e') ADVANCE(556); + if (lookahead == 'e') ADVANCE(482); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 499: ACCEPT_TOKEN(sym_name); - if (lookahead == 'f') ADVANCE(424); + if (lookahead == 'e') ADVANCE(558); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 500: ACCEPT_TOKEN(sym_name); - if (lookahead == 'f') ADVANCE(502); + if (lookahead == 'f') ADVANCE(425); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 501: ACCEPT_TOKEN(sym_name); - if (lookahead == 'f') ADVANCE(492); - if (lookahead == 'l') ADVANCE(495); + if (lookahead == 'f') ADVANCE(503); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 502: ACCEPT_TOKEN(sym_name); - if (lookahead == 'f') ADVANCE(562); + if (lookahead == 'f') ADVANCE(493); + if (lookahead == 'l') ADVANCE(496); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 503: ACCEPT_TOKEN(sym_name); - if (lookahead == 'h') ADVANCE(433); + if (lookahead == 'f') ADVANCE(564); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 504: ACCEPT_TOKEN(sym_name); - if (lookahead == 'h') ADVANCE(430); + if (lookahead == 'h') ADVANCE(434); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 505: ACCEPT_TOKEN(sym_name); - if (lookahead == 'h') ADVANCE(466); - if (lookahead == 'o') ADVANCE(532); + if (lookahead == 'h') ADVANCE(431); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 506: ACCEPT_TOKEN(sym_name); - if (lookahead == 'h') ADVANCE(466); + if (lookahead == 'h') ADVANCE(467); + if (lookahead == 'o') ADVANCE(533); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 507: ACCEPT_TOKEN(sym_name); - if (lookahead == 'i') ADVANCE(585); - if (lookahead == 't') ADVANCE(465); - if (lookahead == 'w') ADVANCE(514); + if (lookahead == 'h') ADVANCE(467); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 508: ACCEPT_TOKEN(sym_name); - if (lookahead == 'i') ADVANCE(585); - if (lookahead == 't') ADVANCE(465); + if (lookahead == 'i') ADVANCE(587); + if (lookahead == 't') ADVANCE(466); + if (lookahead == 'w') ADVANCE(515); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 509: ACCEPT_TOKEN(sym_name); - if (lookahead == 'i') ADVANCE(585); - if (lookahead == 't') ADVANCE(553); + if (lookahead == 'i') ADVANCE(587); + if (lookahead == 't') ADVANCE(466); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 510: ACCEPT_TOKEN(sym_name); - if (lookahead == 'i') ADVANCE(476); + if (lookahead == 'i') ADVANCE(587); + if (lookahead == 't') ADVANCE(550); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 511: ACCEPT_TOKEN(sym_name); - if (lookahead == 'i') ADVANCE(538); + if (lookahead == 'i') ADVANCE(477); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 512: ACCEPT_TOKEN(sym_name); - if (lookahead == 'i') ADVANCE(473); + if (lookahead == 'i') ADVANCE(539); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 513: ACCEPT_TOKEN(sym_name); - if (lookahead == 'i') ADVANCE(545); + if (lookahead == 'i') ADVANCE(474); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 514: ACCEPT_TOKEN(sym_name); - if (lookahead == 'i') ADVANCE(575); + if (lookahead == 'i') ADVANCE(546); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 515: ACCEPT_TOKEN(sym_name); - if (lookahead == 'k') ADVANCE(446); + if (lookahead == 'i') ADVANCE(577); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 516: ACCEPT_TOKEN(sym_name); - if (lookahead == 'l') ADVANCE(324); + if (lookahead == 'k') ADVANCE(447); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 517: ACCEPT_TOKEN(sym_name); - if (lookahead == 'l') ADVANCE(269); + if (lookahead == 'l') ADVANCE(325); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 518: ACCEPT_TOKEN(sym_name); - if (lookahead == 'l') ADVANCE(541); + if (lookahead == 'l') ADVANCE(270); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 519: ACCEPT_TOKEN(sym_name); - if (lookahead == 'l') ADVANCE(516); + if (lookahead == 'l') ADVANCE(542); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 520: ACCEPT_TOKEN(sym_name); - if (lookahead == 'l') ADVANCE(464); + if (lookahead == 'l') ADVANCE(517); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 521: ACCEPT_TOKEN(sym_name); - if (lookahead == 'l') ADVANCE(520); + if (lookahead == 'l') ADVANCE(465); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 522: ACCEPT_TOKEN(sym_name); - if (lookahead == 'l') ADVANCE(495); + if (lookahead == 'l') ADVANCE(521); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 523: ACCEPT_TOKEN(sym_name); - if (lookahead == 'l') ADVANCE(488); + if (lookahead == 'l') ADVANCE(496); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 524: ACCEPT_TOKEN(sym_name); - if (lookahead == 'l') ADVANCE(560); + if (lookahead == 'l') ADVANCE(489); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 525: ACCEPT_TOKEN(sym_name); - if (lookahead == 'l') ADVANCE(561); + if (lookahead == 'l') ADVANCE(562); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 526: ACCEPT_TOKEN(sym_name); - if (lookahead == 'm') ADVANCE(303); + if (lookahead == 'l') ADVANCE(563); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 527: ACCEPT_TOKEN(sym_name); - if (lookahead == 'n') ADVANCE(557); + if (lookahead == 'm') ADVANCE(304); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 528: ACCEPT_TOKEN(sym_name); - if (lookahead == 'n') ADVANCE(386); - if (lookahead == 't') ADVANCE(248); + if (lookahead == 'n') ADVANCE(559); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 529: ACCEPT_TOKEN(sym_name); - if (lookahead == 'n') ADVANCE(386); + if (lookahead == 'n') ADVANCE(387); + if (lookahead == 't') ADVANCE(247); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 530: ACCEPT_TOKEN(sym_name); - if (lookahead == 'n') ADVANCE(450); + if (lookahead == 'n') ADVANCE(387); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 531: ACCEPT_TOKEN(sym_name); - if (lookahead == 'n') ADVANCE(310); + if (lookahead == 'n') ADVANCE(451); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 532: ACCEPT_TOKEN(sym_name); - if (lookahead == 'n') ADVANCE(558); + if (lookahead == 'n') ADVANCE(311); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 533: ACCEPT_TOKEN(sym_name); - if (lookahead == 'n') ADVANCE(477); + if (lookahead == 'n') ADVANCE(560); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 534: ACCEPT_TOKEN(sym_name); - if (lookahead == 'n') ADVANCE(513); + if (lookahead == 'n') ADVANCE(478); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 535: ACCEPT_TOKEN(sym_name); - if (lookahead == 'n') ADVANCE(577); + if (lookahead == 'n') ADVANCE(514); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 536: ACCEPT_TOKEN(sym_name); - if (lookahead == 'n') ADVANCE(570); + if (lookahead == 'n') ADVANCE(579); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 537: ACCEPT_TOKEN(sym_name); - if (lookahead == 'n') ADVANCE(487); + if (lookahead == 'n') ADVANCE(572); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 538: ACCEPT_TOKEN(sym_name); - if (lookahead == 'n') ADVANCE(583); + if (lookahead == 'n') ADVANCE(488); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 539: ACCEPT_TOKEN(sym_name); - if (lookahead == 'o') ADVANCE(527); + if (lookahead == 'n') ADVANCE(585); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 540: ACCEPT_TOKEN(sym_name); - if (lookahead == 'o') ADVANCE(510); + if (lookahead == 'o') ADVANCE(528); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 541: ACCEPT_TOKEN(sym_name); - if (lookahead == 'o') ADVANCE(472); + if (lookahead == 'o') ADVANCE(511); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 542: ACCEPT_TOKEN(sym_name); - if (lookahead == 'o') ADVANCE(555); + if (lookahead == 'o') ADVANCE(473); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 543: ACCEPT_TOKEN(sym_name); - if (lookahead == 'o') ADVANCE(544); + if (lookahead == 'o') ADVANCE(557); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 544: ACCEPT_TOKEN(sym_name); - if (lookahead == 'o') ADVANCE(517); + if (lookahead == 'o') ADVANCE(545); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 545: ACCEPT_TOKEN(sym_name); - if (lookahead == 'o') ADVANCE(531); + if (lookahead == 'o') ADVANCE(518); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 546: ACCEPT_TOKEN(sym_name); - if (lookahead == 'p') ADVANCE(490); + if (lookahead == 'o') ADVANCE(532); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 547: ACCEPT_TOKEN(sym_name); - if (lookahead == 'r') ADVANCE(428); + if (lookahead == 'p') ADVANCE(491); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 548: ACCEPT_TOKEN(sym_name); - if (lookahead == 'r') ADVANCE(444); + if (lookahead == 'r') ADVANCE(429); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 549: ACCEPT_TOKEN(sym_name); - if (lookahead == 'r') ADVANCE(297); + if (lookahead == 'r') ADVANCE(445); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 550: ACCEPT_TOKEN(sym_name); - if (lookahead == 'r') ADVANCE(295); + if (lookahead == 'r') ADVANCE(268); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 551: ACCEPT_TOKEN(sym_name); - if (lookahead == 'r') ADVANCE(582); + if (lookahead == 'r') ADVANCE(298); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 552: ACCEPT_TOKEN(sym_name); - if (lookahead == 'r') ADVANCE(489); + if (lookahead == 'r') ADVANCE(296); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 553: ACCEPT_TOKEN(sym_name); - if (lookahead == 'r') ADVANCE(579); + if (lookahead == 'r') ADVANCE(584); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 554: ACCEPT_TOKEN(sym_name); - if (lookahead == 'r') ADVANCE(530); + if (lookahead == 'r') ADVANCE(490); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 555: ACCEPT_TOKEN(sym_name); - if (lookahead == 'r') ADVANCE(564); + if (lookahead == 'r') ADVANCE(581); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 556: ACCEPT_TOKEN(sym_name); - if (lookahead == 'r') ADVANCE(566); + if (lookahead == 'r') ADVANCE(531); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 557: ACCEPT_TOKEN(sym_name); - if (lookahead == 's') ADVANCE(565); - if (lookahead == 't') ADVANCE(511); + if (lookahead == 'r') ADVANCE(566); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 558: ACCEPT_TOKEN(sym_name); - if (lookahead == 's') ADVANCE(565); + if (lookahead == 'r') ADVANCE(568); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 559: ACCEPT_TOKEN(sym_name); - if (lookahead == 's') ADVANCE(498); + if (lookahead == 's') ADVANCE(567); + if (lookahead == 't') ADVANCE(512); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 560: ACCEPT_TOKEN(sym_name); - if (lookahead == 's') ADVANCE(480); + if (lookahead == 's') ADVANCE(567); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 561: ACCEPT_TOKEN(sym_name); - if (lookahead == 's') ADVANCE(484); + if (lookahead == 's') ADVANCE(499); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 562: ACCEPT_TOKEN(sym_name); - if (lookahead == 's') ADVANCE(496); + if (lookahead == 's') ADVANCE(481); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 563: ACCEPT_TOKEN(sym_name); - if (lookahead == 't') ADVANCE(471); + if (lookahead == 's') ADVANCE(485); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 564: ACCEPT_TOKEN(sym_name); - if (lookahead == 't') ADVANCE(384); + if (lookahead == 's') ADVANCE(497); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 565: ACCEPT_TOKEN(sym_name); - if (lookahead == 't') ADVANCE(250); + if (lookahead == 't') ADVANCE(472); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 566: ACCEPT_TOKEN(sym_name); - if (lookahead == 't') ADVANCE(381); + if (lookahead == 't') ADVANCE(385); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 567: ACCEPT_TOKEN(sym_name); - if (lookahead == 't') ADVANCE(388); + if (lookahead == 't') ADVANCE(249); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 568: ACCEPT_TOKEN(sym_name); - if (lookahead == 't') ADVANCE(308); + if (lookahead == 't') ADVANCE(382); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 569: ACCEPT_TOKEN(sym_name); - if (lookahead == 't') ADVANCE(289); + if (lookahead == 't') ADVANCE(389); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 570: ACCEPT_TOKEN(sym_name); - if (lookahead == 't') ADVANCE(290); + if (lookahead == 't') ADVANCE(309); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 571: ACCEPT_TOKEN(sym_name); - if (lookahead == 't') ADVANCE(580); + if (lookahead == 't') ADVANCE(290); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 572: ACCEPT_TOKEN(sym_name); - if (lookahead == 't') ADVANCE(512); + if (lookahead == 't') ADVANCE(291); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 573: ACCEPT_TOKEN(sym_name); - if (lookahead == 't') ADVANCE(550); + if (lookahead == 't') ADVANCE(582); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 574: ACCEPT_TOKEN(sym_name); - if (lookahead == 't') ADVANCE(485); + if (lookahead == 't') ADVANCE(513); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 575: ACCEPT_TOKEN(sym_name); - if (lookahead == 't') ADVANCE(474); + if (lookahead == 't') ADVANCE(552); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 576: ACCEPT_TOKEN(sym_name); - if (lookahead == 't') ADVANCE(553); + if (lookahead == 't') ADVANCE(486); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 577: ACCEPT_TOKEN(sym_name); - if (lookahead == 'u') ADVANCE(526); + if (lookahead == 't') ADVANCE(475); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 578: ACCEPT_TOKEN(sym_name); - if (lookahead == 'u') ADVANCE(519); + if (lookahead == 't') ADVANCE(555); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 579: ACCEPT_TOKEN(sym_name); - if (lookahead == 'u') ADVANCE(475); + if (lookahead == 'u') ADVANCE(527); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 580: ACCEPT_TOKEN(sym_name); - if (lookahead == 'u') ADVANCE(554); + if (lookahead == 'u') ADVANCE(520); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 581: ACCEPT_TOKEN(sym_name); - if (lookahead == 'u') ADVANCE(537); + if (lookahead == 'u') ADVANCE(476); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 582: ACCEPT_TOKEN(sym_name); - if (lookahead == 'u') ADVANCE(483); + if (lookahead == 'u') ADVANCE(556); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 583: ACCEPT_TOKEN(sym_name); - if (lookahead == 'u') ADVANCE(486); + if (lookahead == 'u') ADVANCE(538); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 584: ACCEPT_TOKEN(sym_name); - if (lookahead == 'u') ADVANCE(521); + if (lookahead == 'u') ADVANCE(484); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 585: ACCEPT_TOKEN(sym_name); - if (lookahead == 'z') ADVANCE(482); + if (lookahead == 'u') ADVANCE(487); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'y')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 586: ACCEPT_TOKEN(sym_name); + if (lookahead == 'u') ADVANCE(522); if (('0' <= lookahead && lookahead <= '9') || ('A' <= lookahead && lookahead <= 'Z') || lookahead == '_' || - ('a' <= lookahead && lookahead <= 'z')) ADVANCE(586); + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); END_STATE(); case 587: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'z') ADVANCE(483); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'y')) ADVANCE(588); + END_STATE(); + case 588: + ACCEPT_TOKEN(sym_name); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 589: ACCEPT_TOKEN(sym_comment); - if (lookahead == '\\') ADVANCE(230); + if (lookahead == '\\') ADVANCE(229); if (lookahead != 0 && - lookahead != '\n') ADVANCE(587); + lookahead != '\n') ADVANCE(589); END_STATE(); - case 588: + case 590: ACCEPT_TOKEN(sym_comment); if (lookahead != 0 && - lookahead != '\\') ADVANCE(587); - if (lookahead == '\\') ADVANCE(230); + lookahead != '\\') ADVANCE(589); + if (lookahead == '\\') ADVANCE(229); END_STATE(); default: return false; @@ -5762,7 +5816,7 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { static TSLexMode ts_lex_modes[STATE_COUNT] = { [0] = {.lex_state = 0}, - [1] = {.lex_state = 235}, + [1] = {.lex_state = 234}, [2] = {.lex_state = 50}, [3] = {.lex_state = 51}, [4] = {.lex_state = 53}, @@ -5905,8 +5959,8 @@ static TSLexMode ts_lex_modes[STATE_COUNT] = { [141] = {.lex_state = 55}, [142] = {.lex_state = 55}, [143] = {.lex_state = 45}, - [144] = {.lex_state = 55}, - [145] = {.lex_state = 45}, + [144] = {.lex_state = 45}, + [145] = {.lex_state = 55}, [146] = {.lex_state = 48}, [147] = {.lex_state = 55}, [148] = {.lex_state = 48}, @@ -5917,69 +5971,69 @@ static TSLexMode ts_lex_modes[STATE_COUNT] = { [153] = {.lex_state = 45}, [154] = {.lex_state = 55}, [155] = {.lex_state = 55}, - [156] = {.lex_state = 45}, - [157] = {.lex_state = 46}, + [156] = {.lex_state = 46}, + [157] = {.lex_state = 45}, [158] = {.lex_state = 48}, [159] = {.lex_state = 45}, [160] = {.lex_state = 44}, [161] = {.lex_state = 44}, [162] = {.lex_state = 44}, - [163] = {.lex_state = 48}, - [164] = {.lex_state = 58}, - [165] = {.lex_state = 51}, - [166] = {.lex_state = 46}, - [167] = {.lex_state = 44}, - [168] = {.lex_state = 44}, + [163] = {.lex_state = 58}, + [164] = {.lex_state = 48}, + [165] = {.lex_state = 58}, + [166] = {.lex_state = 51}, + [167] = {.lex_state = 58}, + [168] = {.lex_state = 46}, [169] = {.lex_state = 58}, [170] = {.lex_state = 58}, - [171] = {.lex_state = 58}, + [171] = {.lex_state = 44}, [172] = {.lex_state = 58}, [173] = {.lex_state = 48}, - [174] = {.lex_state = 235}, - [175] = {.lex_state = 44}, + [174] = {.lex_state = 44}, + [175] = {.lex_state = 58}, [176] = {.lex_state = 58}, - [177] = {.lex_state = 0}, - [178] = {.lex_state = 44}, + [177] = {.lex_state = 58}, + [178] = {.lex_state = 58}, [179] = {.lex_state = 58}, [180] = {.lex_state = 58}, [181] = {.lex_state = 58}, [182] = {.lex_state = 58}, [183] = {.lex_state = 58}, [184] = {.lex_state = 58}, - [185] = {.lex_state = 0}, + [185] = {.lex_state = 234}, [186] = {.lex_state = 58}, [187] = {.lex_state = 58}, [188] = {.lex_state = 58}, [189] = {.lex_state = 58}, [190] = {.lex_state = 58}, [191] = {.lex_state = 58}, - [192] = {.lex_state = 0}, - [193] = {.lex_state = 48}, + [192] = {.lex_state = 44}, + [193] = {.lex_state = 58}, [194] = {.lex_state = 58}, - [195] = {.lex_state = 0}, + [195] = {.lex_state = 58}, [196] = {.lex_state = 58}, [197] = {.lex_state = 0}, - [198] = {.lex_state = 58}, + [198] = {.lex_state = 0}, [199] = {.lex_state = 0}, - [200] = {.lex_state = 58}, - [201] = {.lex_state = 58}, + [200] = {.lex_state = 48}, + [201] = {.lex_state = 0}, [202] = {.lex_state = 58}, [203] = {.lex_state = 58}, [204] = {.lex_state = 0}, - [205] = {.lex_state = 58}, + [205] = {.lex_state = 0}, [206] = {.lex_state = 58}, [207] = {.lex_state = 58}, - [208] = {.lex_state = 58}, - [209] = {.lex_state = 0}, + [208] = {.lex_state = 44}, + [209] = {.lex_state = 58}, [210] = {.lex_state = 58}, [211] = {.lex_state = 58}, - [212] = {.lex_state = 44}, + [212] = {.lex_state = 58}, [213] = {.lex_state = 58}, [214] = {.lex_state = 58}, - [215] = {.lex_state = 58}, + [215] = {.lex_state = 0}, [216] = {.lex_state = 58}, - [217] = {.lex_state = 58}, - [218] = {.lex_state = 58}, + [217] = {.lex_state = 44}, + [218] = {.lex_state = 0}, [219] = {.lex_state = 0}, [220] = {.lex_state = 0}, [221] = {.lex_state = 0}, @@ -6020,10 +6074,10 @@ static TSLexMode ts_lex_modes[STATE_COUNT] = { [256] = {.lex_state = 0}, [257] = {.lex_state = 0}, [258] = {.lex_state = 0}, - [259] = {.lex_state = 0}, + [259] = {.lex_state = 59}, [260] = {.lex_state = 0}, [261] = {.lex_state = 59}, - [262] = {.lex_state = 59}, + [262] = {.lex_state = 0}, [263] = {.lex_state = 0}, [264] = {.lex_state = 0}, [265] = {.lex_state = 0}, @@ -6122,16 +6176,16 @@ static TSLexMode ts_lex_modes[STATE_COUNT] = { [358] = {.lex_state = 45}, [359] = {.lex_state = 45}, [360] = {.lex_state = 0}, - [361] = {.lex_state = 235}, + [361] = {.lex_state = 234}, [362] = {.lex_state = 0}, - [363] = {.lex_state = 235}, - [364] = {.lex_state = 235}, + [363] = {.lex_state = 234}, + [364] = {.lex_state = 234}, [365] = {.lex_state = 0}, [366] = {.lex_state = 0}, [367] = {.lex_state = 0}, [368] = {.lex_state = 0}, [369] = {.lex_state = 0}, - [370] = {.lex_state = 235}, + [370] = {.lex_state = 234}, [371] = {.lex_state = 0}, [372] = {.lex_state = 0}, [373] = {.lex_state = 0}, @@ -6140,43 +6194,43 @@ static TSLexMode ts_lex_modes[STATE_COUNT] = { [376] = {.lex_state = 0}, [377] = {.lex_state = 0}, [378] = {.lex_state = 52}, - [379] = {.lex_state = 235}, - [380] = {.lex_state = 235}, - [381] = {.lex_state = 235}, - [382] = {.lex_state = 235}, + [379] = {.lex_state = 234}, + [380] = {.lex_state = 234}, + [381] = {.lex_state = 234}, + [382] = {.lex_state = 234}, [383] = {.lex_state = 0}, [384] = {.lex_state = 0}, - [385] = {.lex_state = 235}, - [386] = {.lex_state = 235}, - [387] = {.lex_state = 235}, - [388] = {.lex_state = 235}, - [389] = {.lex_state = 235}, - [390] = {.lex_state = 235}, + [385] = {.lex_state = 234}, + [386] = {.lex_state = 234}, + [387] = {.lex_state = 234}, + [388] = {.lex_state = 234}, + [389] = {.lex_state = 234}, + [390] = {.lex_state = 234}, [391] = {.lex_state = 52}, - [392] = {.lex_state = 235}, + [392] = {.lex_state = 234}, [393] = {.lex_state = 0}, [394] = {.lex_state = 0}, [395] = {.lex_state = 0}, - [396] = {.lex_state = 235}, + [396] = {.lex_state = 234}, [397] = {.lex_state = 0}, [398] = {.lex_state = 0}, - [399] = {.lex_state = 235}, + [399] = {.lex_state = 234}, [400] = {.lex_state = 0}, - [401] = {.lex_state = 235}, + [401] = {.lex_state = 234}, [402] = {.lex_state = 0}, [403] = {.lex_state = 0}, [404] = {.lex_state = 68}, - [405] = {.lex_state = 235}, + [405] = {.lex_state = 234}, [406] = {.lex_state = 0}, [407] = {.lex_state = 68}, - [408] = {.lex_state = 235}, + [408] = {.lex_state = 234}, [409] = {.lex_state = 68}, [410] = {.lex_state = 68}, [411] = {.lex_state = 52}, [412] = {.lex_state = 0}, [413] = {.lex_state = 68}, - [414] = {.lex_state = 235}, - [415] = {.lex_state = 235}, + [414] = {.lex_state = 234}, + [415] = {.lex_state = 234}, [416] = {.lex_state = 0}, [417] = {.lex_state = 52}, [418] = {.lex_state = 52}, @@ -6230,24 +6284,24 @@ static TSLexMode ts_lex_modes[STATE_COUNT] = { [466] = {.lex_state = 65}, [467] = {.lex_state = 68}, [468] = {.lex_state = 67}, - [469] = {.lex_state = 235}, + [469] = {.lex_state = 234}, [470] = {.lex_state = 47}, - [471] = {.lex_state = 235}, + [471] = {.lex_state = 234}, [472] = {.lex_state = 67}, [473] = {.lex_state = 65}, - [474] = {.lex_state = 235}, + [474] = {.lex_state = 234}, [475] = {.lex_state = 60}, [476] = {.lex_state = 65}, [477] = {.lex_state = 60}, [478] = {.lex_state = 65}, [479] = {.lex_state = 47}, - [480] = {.lex_state = 235}, + [480] = {.lex_state = 234}, [481] = {.lex_state = 60}, [482] = {.lex_state = 53}, [483] = {.lex_state = 0}, [484] = {.lex_state = 0}, [485] = {.lex_state = 71}, - [486] = {.lex_state = 235}, + [486] = {.lex_state = 234}, [487] = {.lex_state = 0}, [488] = {.lex_state = 0}, [489] = {.lex_state = 71}, @@ -6385,7 +6439,7 @@ static TSLexMode ts_lex_modes[STATE_COUNT] = { [621] = {.lex_state = 0}, [622] = {.lex_state = 0}, [623] = {.lex_state = 67}, - [624] = {.lex_state = 221}, + [624] = {.lex_state = 220}, [625] = {.lex_state = 0}, [626] = {.lex_state = 0}, [627] = {.lex_state = 0}, @@ -6398,7 +6452,7 @@ static TSLexMode ts_lex_modes[STATE_COUNT] = { [634] = {.lex_state = 0}, [635] = {.lex_state = 0}, [636] = {.lex_state = 67}, - [637] = {.lex_state = 221}, + [637] = {.lex_state = 220}, [638] = {.lex_state = 0}, [639] = {.lex_state = 0}, [640] = {.lex_state = 50}, @@ -6410,7 +6464,7 @@ static TSLexMode ts_lex_modes[STATE_COUNT] = { [646] = {.lex_state = 0}, [647] = {.lex_state = 50}, [648] = {.lex_state = 0}, - [649] = {.lex_state = 235}, + [649] = {.lex_state = 234}, [650] = {.lex_state = 0}, [651] = {.lex_state = 0}, [652] = {.lex_state = 0}, @@ -6491,14 +6545,14 @@ static TSLexMode ts_lex_modes[STATE_COUNT] = { [727] = {.lex_state = 0}, [728] = {.lex_state = 0}, [729] = {.lex_state = 0}, - [730] = {.lex_state = 235}, + [730] = {.lex_state = 234}, [731] = {.lex_state = 0}, [732] = {.lex_state = 0}, [733] = {.lex_state = 0}, [734] = {.lex_state = 0}, [735] = {.lex_state = 0}, [736] = {.lex_state = 0}, - [737] = {.lex_state = 235}, + [737] = {.lex_state = 234}, [738] = {.lex_state = 0}, [739] = {.lex_state = 0}, [740] = {.lex_state = 0}, @@ -6531,7 +6585,7 @@ static TSLexMode ts_lex_modes[STATE_COUNT] = { [767] = {.lex_state = 0}, [768] = {.lex_state = 0}, [769] = {.lex_state = 0}, - [770] = {.lex_state = 235}, + [770] = {.lex_state = 234}, [771] = {.lex_state = 0}, [772] = {.lex_state = 0}, [773] = {.lex_state = 0}, @@ -6574,13 +6628,13 @@ static TSLexMode ts_lex_modes[STATE_COUNT] = { [810] = {.lex_state = 0}, [811] = {.lex_state = 50}, [812] = {.lex_state = 0}, - [813] = {.lex_state = 235}, + [813] = {.lex_state = 234}, [814] = {.lex_state = 0}, [815] = {.lex_state = 0}, [816] = {.lex_state = 0}, - [817] = {.lex_state = 235}, + [817] = {.lex_state = 234}, [818] = {.lex_state = 0}, - [819] = {.lex_state = 235}, + [819] = {.lex_state = 234}, }; static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { @@ -6608,6 +6662,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_ATnoreturn] = ACTIONS(1), [anon_sym_BANG] = ACTIONS(1), [anon_sym_rune] = ACTIONS(1), + [anon_sym_str] = ACTIONS(1), [anon_sym_bool] = ACTIONS(1), [anon_sym_void] = ACTIONS(1), [anon_sym_i8] = ACTIONS(1), @@ -6748,7 +6803,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [2] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -6795,7 +6850,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(443), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_SEMI] = ACTIONS(25), @@ -6863,7 +6918,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [3] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -6910,7 +6965,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(443), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_SEMI] = ACTIONS(25), @@ -6977,7 +7032,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [4] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -7024,7 +7079,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(443), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_SEMI] = ACTIONS(25), @@ -7088,7 +7143,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [5] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -7138,7 +7193,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(578), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -7198,7 +7253,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [6] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -7245,7 +7300,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(443), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_SEMI] = ACTIONS(25), @@ -7308,7 +7363,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [7] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -7358,7 +7413,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(578), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -7417,7 +7472,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [8] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -7465,7 +7520,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(622), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -7526,7 +7581,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [9] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -7574,7 +7629,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(600), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -7634,7 +7689,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [10] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -7682,7 +7737,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(578), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -7742,7 +7797,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [11] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -7790,7 +7845,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(517), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -7850,7 +7905,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [12] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -7898,7 +7953,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(525), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -7958,7 +8013,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [13] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -8006,7 +8061,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(525), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -8066,7 +8121,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [14] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -8114,7 +8169,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(622), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -8174,7 +8229,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [15] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -8222,7 +8277,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(622), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -8282,7 +8337,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [16] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -8330,7 +8385,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(622), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -8390,7 +8445,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [17] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -8438,7 +8493,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(525), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -8498,7 +8553,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [18] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -8546,7 +8601,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(622), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -8606,7 +8661,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [19] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -8654,7 +8709,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(517), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -8714,7 +8769,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [20] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -8762,7 +8817,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(717), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -8822,7 +8877,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [21] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -8870,7 +8925,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(517), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -8930,7 +8985,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [22] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -8977,7 +9032,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(584), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -9037,7 +9092,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [23] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -9084,7 +9139,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(763), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -9144,7 +9199,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [24] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -9191,7 +9246,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(592), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -9251,7 +9306,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [25] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -9299,7 +9354,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(574), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -9358,7 +9413,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [26] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -9406,7 +9461,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(574), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -9465,7 +9520,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [27] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -9513,7 +9568,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(619), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -9572,7 +9627,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [28] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -9620,7 +9675,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(717), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -9679,7 +9734,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [29] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -9727,7 +9782,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(600), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -9786,7 +9841,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [30] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -9833,7 +9888,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(556), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -9893,7 +9948,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [31] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -9941,7 +9996,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(581), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -10000,7 +10055,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [32] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -10048,7 +10103,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(574), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -10107,7 +10162,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [33] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -10155,7 +10210,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(574), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -10214,7 +10269,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [34] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -10262,7 +10317,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(574), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -10321,7 +10376,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [35] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -10369,7 +10424,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(574), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -10428,7 +10483,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [36] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -10476,7 +10531,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(574), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -10535,7 +10590,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [37] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -10582,7 +10637,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(700), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -10642,7 +10697,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [38] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -10689,7 +10744,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(743), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -10749,7 +10804,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [39] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -10797,7 +10852,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(574), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -10856,7 +10911,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [40] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -10903,7 +10958,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(708), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -10963,7 +11018,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [41] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -11010,7 +11065,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(445), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -11069,7 +11124,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [42] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -11116,7 +11171,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(564), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -11175,7 +11230,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [43] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -11222,7 +11277,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(445), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -11281,7 +11336,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [44] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -11328,7 +11383,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(444), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -11387,7 +11442,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [45] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -11434,7 +11489,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(451), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -11493,7 +11548,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [46] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -11540,7 +11595,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(451), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -11599,7 +11654,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [47] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -11646,7 +11701,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(438), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -11705,7 +11760,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [48] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -11752,7 +11807,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(429), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -11811,7 +11866,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [49] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -11858,7 +11913,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(430), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -11917,7 +11972,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [50] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -11964,7 +12019,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(442), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -12023,7 +12078,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [51] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -12070,7 +12125,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(444), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -12129,7 +12184,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [52] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -12176,7 +12231,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(451), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -12235,7 +12290,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [53] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -12282,7 +12337,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(438), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -12341,7 +12396,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [54] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -12388,7 +12443,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(576), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -12447,7 +12502,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [55] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -12494,7 +12549,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(451), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -12553,7 +12608,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [56] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -12600,7 +12655,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(442), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -12659,7 +12714,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [57] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -12706,7 +12761,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(634), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -12765,7 +12820,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [58] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -12812,7 +12867,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(442), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -12871,7 +12926,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [59] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -12918,7 +12973,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(442), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -12977,7 +13032,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [60] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -13024,7 +13079,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(626), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -13083,7 +13138,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [61] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -13130,7 +13185,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(781), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -13189,7 +13244,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [62] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -13236,7 +13291,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(721), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -13295,7 +13350,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [63] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -13342,7 +13397,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(566), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -13401,7 +13456,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [64] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -13448,7 +13503,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(668), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -13507,7 +13562,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [65] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -13554,7 +13609,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(571), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -13613,7 +13668,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [66] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -13660,7 +13715,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(438), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -13719,7 +13774,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [67] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -13766,7 +13821,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(804), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -13825,7 +13880,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [68] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -13872,7 +13927,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(568), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -13931,7 +13986,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [69] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -13978,7 +14033,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(684), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -14037,7 +14092,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [70] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -14084,7 +14139,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(555), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -14143,7 +14198,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [71] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -14190,7 +14245,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(625), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -14249,7 +14304,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [72] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -14296,7 +14351,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(429), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -14355,7 +14410,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [73] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -14402,7 +14457,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(688), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -14461,7 +14516,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [74] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -14508,7 +14563,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(441), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -14567,7 +14622,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [75] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -14614,7 +14669,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(767), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -14673,7 +14728,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [76] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -14720,7 +14775,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(444), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -14779,7 +14834,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [77] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -14826,7 +14881,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(445), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -14885,7 +14940,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [78] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -14932,7 +14987,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(438), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -14991,7 +15046,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [79] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -15038,7 +15093,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(437), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -15097,7 +15152,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [80] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -15144,7 +15199,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(590), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -15203,7 +15258,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [81] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -15250,7 +15305,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(746), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -15309,7 +15364,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [82] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -15356,7 +15411,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(591), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -15415,7 +15470,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [83] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -15462,7 +15517,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(800), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -15521,7 +15576,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [84] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -15568,7 +15623,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(429), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -15627,7 +15682,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [85] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -15674,7 +15729,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(554), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -15733,7 +15788,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [86] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -15780,7 +15835,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(750), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -15839,7 +15894,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [87] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -15886,7 +15941,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(601), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -15945,7 +16000,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [88] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -15992,7 +16047,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(799), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -16051,7 +16106,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [89] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -16098,7 +16153,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(706), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -16157,7 +16212,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [90] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -16204,7 +16259,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(553), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -16263,7 +16318,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [91] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -16310,7 +16365,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(430), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -16369,7 +16424,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [92] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -16416,7 +16471,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(429), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -16475,7 +16530,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [93] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -16522,7 +16577,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(731), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -16581,7 +16636,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [94] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -16628,7 +16683,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(610), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -16687,7 +16742,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [95] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -16734,7 +16789,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(738), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -16793,7 +16848,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [96] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -16840,7 +16895,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(615), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -16899,7 +16954,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [97] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -16946,7 +17001,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(445), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -17005,7 +17060,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [98] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -17052,7 +17107,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(444), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -17111,7 +17166,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [99] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -17158,7 +17213,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(441), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -17217,7 +17272,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [100] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -17264,7 +17319,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(768), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -17323,7 +17378,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [101] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -17370,7 +17425,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(596), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -17429,7 +17484,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [102] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -17476,7 +17531,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_control_statement] = STATE(425), [sym_expression] = STATE(437), [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(192), + [sym_identifier] = STATE(201), [aux_sym_decimal_digits_repeat1] = STATE(146), [aux_sym_string_constant_repeat1] = STATE(272), [anon_sym_LBRACE] = ACTIONS(27), @@ -17535,7 +17590,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [103] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -17703,7 +17758,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [105] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -17953,7 +18008,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [108] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -18034,7 +18089,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [109] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -18114,7 +18169,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [110] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -18193,7 +18248,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [111] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -18271,7 +18326,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [112] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -18348,7 +18403,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [113] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -18574,7 +18629,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [116] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -18649,7 +18704,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [117] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -18942,7 +18997,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [121] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -19014,7 +19069,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [122] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -19155,12 +19210,12 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { }, [124] = { [sym_constant] = STATE(246), - [sym_integer_constant] = STATE(259), + [sym_integer_constant] = STATE(260), [sym_decimal_digits] = STATE(140), [sym_decimal_digit] = STATE(114), - [sym_floating_constant] = STATE(259), - [sym_rune_constant] = STATE(259), - [sym_string_constant] = STATE(259), + [sym_floating_constant] = STATE(260), + [sym_rune_constant] = STATE(260), + [sym_string_constant] = STATE(260), [sym_array_literal] = STATE(246), [sym_enum_literal] = STATE(246), [sym_struct_literal] = STATE(246), @@ -19179,9 +19234,9 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_error_propagation] = STATE(227), [sym_postfix_expression] = STATE(222), [sym_unary_expression] = STATE(265), - [sym_identifier] = STATE(199), + [sym_identifier] = STATE(204), [aux_sym_decimal_digits_repeat1] = STATE(114), - [aux_sym_string_constant_repeat1] = STATE(195), + [aux_sym_string_constant_repeat1] = STATE(198), [anon_sym_LPAREN] = ACTIONS(246), [anon_sym_BANG] = ACTIONS(248), [anon_sym_void] = ACTIONS(250), @@ -19227,7 +19282,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [125] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -19298,7 +19353,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [126] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -19369,7 +19424,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [127] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -19510,7 +19565,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [129] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -19579,12 +19634,12 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { }, [130] = { [sym_constant] = STATE(246), - [sym_integer_constant] = STATE(259), + [sym_integer_constant] = STATE(260), [sym_decimal_digits] = STATE(140), [sym_decimal_digit] = STATE(114), - [sym_floating_constant] = STATE(259), - [sym_rune_constant] = STATE(259), - [sym_string_constant] = STATE(259), + [sym_floating_constant] = STATE(260), + [sym_rune_constant] = STATE(260), + [sym_string_constant] = STATE(260), [sym_array_literal] = STATE(246), [sym_enum_literal] = STATE(246), [sym_struct_literal] = STATE(246), @@ -19603,9 +19658,9 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_error_propagation] = STATE(227), [sym_postfix_expression] = STATE(222), [sym_unary_expression] = STATE(271), - [sym_identifier] = STATE(199), + [sym_identifier] = STATE(204), [aux_sym_decimal_digits_repeat1] = STATE(114), - [aux_sym_string_constant_repeat1] = STATE(195), + [aux_sym_string_constant_repeat1] = STATE(198), [anon_sym_LPAREN] = ACTIONS(246), [anon_sym_BANG] = ACTIONS(248), [anon_sym_void] = ACTIONS(250), @@ -19650,7 +19705,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [131] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -19719,12 +19774,12 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { }, [132] = { [sym_constant] = STATE(246), - [sym_integer_constant] = STATE(259), + [sym_integer_constant] = STATE(260), [sym_decimal_digits] = STATE(140), [sym_decimal_digit] = STATE(114), - [sym_floating_constant] = STATE(259), - [sym_rune_constant] = STATE(259), - [sym_string_constant] = STATE(259), + [sym_floating_constant] = STATE(260), + [sym_rune_constant] = STATE(260), + [sym_string_constant] = STATE(260), [sym_array_literal] = STATE(246), [sym_enum_literal] = STATE(246), [sym_struct_literal] = STATE(246), @@ -19743,9 +19798,9 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_error_propagation] = STATE(227), [sym_postfix_expression] = STATE(222), [sym_unary_expression] = STATE(268), - [sym_identifier] = STATE(199), + [sym_identifier] = STATE(204), [aux_sym_decimal_digits_repeat1] = STATE(114), - [aux_sym_string_constant_repeat1] = STATE(195), + [aux_sym_string_constant_repeat1] = STATE(198), [anon_sym_LPAREN] = ACTIONS(246), [anon_sym_BANG] = ACTIONS(248), [anon_sym_void] = ACTIONS(250), @@ -19789,12 +19844,12 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { }, [133] = { [sym_constant] = STATE(246), - [sym_integer_constant] = STATE(259), + [sym_integer_constant] = STATE(260), [sym_decimal_digits] = STATE(140), [sym_decimal_digit] = STATE(114), - [sym_floating_constant] = STATE(259), - [sym_rune_constant] = STATE(259), - [sym_string_constant] = STATE(259), + [sym_floating_constant] = STATE(260), + [sym_rune_constant] = STATE(260), + [sym_string_constant] = STATE(260), [sym_array_literal] = STATE(246), [sym_enum_literal] = STATE(246), [sym_struct_literal] = STATE(246), @@ -19813,9 +19868,9 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_error_propagation] = STATE(227), [sym_postfix_expression] = STATE(222), [sym_unary_expression] = STATE(263), - [sym_identifier] = STATE(199), + [sym_identifier] = STATE(204), [aux_sym_decimal_digits_repeat1] = STATE(114), - [aux_sym_string_constant_repeat1] = STATE(195), + [aux_sym_string_constant_repeat1] = STATE(198), [anon_sym_LPAREN] = ACTIONS(246), [anon_sym_BANG] = ACTIONS(248), [anon_sym_void] = ACTIONS(250), @@ -19859,12 +19914,12 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { }, [134] = { [sym_constant] = STATE(246), - [sym_integer_constant] = STATE(259), + [sym_integer_constant] = STATE(260), [sym_decimal_digits] = STATE(140), [sym_decimal_digit] = STATE(114), - [sym_floating_constant] = STATE(259), - [sym_rune_constant] = STATE(259), - [sym_string_constant] = STATE(259), + [sym_floating_constant] = STATE(260), + [sym_rune_constant] = STATE(260), + [sym_string_constant] = STATE(260), [sym_array_literal] = STATE(246), [sym_enum_literal] = STATE(246), [sym_struct_literal] = STATE(246), @@ -19883,9 +19938,9 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_error_propagation] = STATE(227), [sym_postfix_expression] = STATE(222), [sym_unary_expression] = STATE(266), - [sym_identifier] = STATE(199), + [sym_identifier] = STATE(204), [aux_sym_decimal_digits_repeat1] = STATE(114), - [aux_sym_string_constant_repeat1] = STATE(195), + [aux_sym_string_constant_repeat1] = STATE(198), [anon_sym_LPAREN] = ACTIONS(246), [anon_sym_BANG] = ACTIONS(248), [anon_sym_void] = ACTIONS(250), @@ -19930,7 +19985,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [135] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -20000,7 +20055,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [136] = { [sym_constant] = STATE(301), [sym_integer_constant] = STATE(293), - [sym_decimal_digits] = STATE(163), + [sym_decimal_digits] = STATE(164), [sym_decimal_digit] = STATE(146), [sym_floating_constant] = STATE(293), [sym_rune_constant] = STATE(293), @@ -20139,12 +20194,12 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { }, [138] = { [sym_constant] = STATE(246), - [sym_integer_constant] = STATE(259), + [sym_integer_constant] = STATE(260), [sym_decimal_digits] = STATE(140), [sym_decimal_digit] = STATE(114), - [sym_floating_constant] = STATE(259), - [sym_rune_constant] = STATE(259), - [sym_string_constant] = STATE(259), + [sym_floating_constant] = STATE(260), + [sym_rune_constant] = STATE(260), + [sym_string_constant] = STATE(260), [sym_array_literal] = STATE(246), [sym_enum_literal] = STATE(246), [sym_struct_literal] = STATE(246), @@ -20163,9 +20218,9 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_error_propagation] = STATE(227), [sym_postfix_expression] = STATE(222), [sym_unary_expression] = STATE(265), - [sym_identifier] = STATE(199), + [sym_identifier] = STATE(204), [aux_sym_decimal_digits_repeat1] = STATE(114), - [aux_sym_string_constant_repeat1] = STATE(195), + [aux_sym_string_constant_repeat1] = STATE(198), [anon_sym_LPAREN] = ACTIONS(246), [anon_sym_BANG] = ACTIONS(248), [anon_sym_void] = ACTIONS(250), @@ -20399,7 +20454,7 @@ static uint16_t ts_small_parse_table[] = { sym_name, ACTIONS(332), 1, anon_sym_STAR, - STATE(163), 1, + STATE(164), 1, sym_decimal_digits, STATE(272), 1, aux_sym_string_constant_repeat1, @@ -20409,7 +20464,7 @@ static uint16_t ts_small_parse_table[] = { sym_plain_expression, STATE(502), 1, sym_postfix_expression, - STATE(806), 1, + STATE(734), 1, sym_object_selector, STATE(146), 2, sym_decimal_digit, @@ -20499,7 +20554,7 @@ static uint16_t ts_small_parse_table[] = { sym_name, ACTIONS(334), 1, anon_sym_STAR, - STATE(163), 1, + STATE(164), 1, sym_decimal_digits, STATE(272), 1, aux_sym_string_constant_repeat1, @@ -20509,7 +20564,7 @@ static uint16_t ts_small_parse_table[] = { sym_plain_expression, STATE(502), 1, sym_postfix_expression, - STATE(734), 1, + STATE(806), 1, sym_object_selector, STATE(146), 2, sym_decimal_digit, @@ -20560,7 +20615,7 @@ static uint16_t ts_small_parse_table[] = { ACTIONS(340), 2, anon_sym_0, anon_sym_1, - STATE(145), 2, + STATE(143), 2, sym_binary_digit, aux_sym_binary_digits_repeat1, ACTIONS(338), 17, @@ -20622,114 +20677,16 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [432] = 35, + [432] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(33), 1, - anon_sym_LPAREN, - ACTIONS(39), 1, - anon_sym_size, - ACTIONS(43), 1, - anon_sym_struct, - ACTIONS(45), 1, - anon_sym_LBRACK, - ACTIONS(47), 1, - anon_sym_0x, - ACTIONS(49), 1, - anon_sym_0o, - ACTIONS(51), 1, - anon_sym_0b, - ACTIONS(53), 1, + ACTIONS(347), 2, anon_sym_0, - ACTIONS(57), 1, - anon_sym_SQUOTE, - ACTIONS(59), 1, - anon_sym_DQUOTE, - ACTIONS(61), 1, - anon_sym_alloc, - ACTIONS(63), 1, - anon_sym_append, - ACTIONS(65), 1, - anon_sym_free, - ACTIONS(67), 1, - anon_sym_delete, - ACTIONS(69), 1, - anon_sym_assert, - ACTIONS(73), 1, - anon_sym_abort, - ACTIONS(75), 1, - anon_sym_len, - ACTIONS(77), 1, - anon_sym_offset, - ACTIONS(185), 1, - anon_sym_static, - ACTIONS(305), 1, - sym_name, - STATE(163), 1, - sym_decimal_digits, - STATE(272), 1, - aux_sym_string_constant_repeat1, - STATE(276), 1, - sym_identifier, - STATE(302), 1, - sym_plain_expression, - STATE(350), 1, - sym_object_selector, - STATE(502), 1, - sym_postfix_expression, - STATE(146), 2, - sym_decimal_digit, - aux_sym_decimal_digits_repeat1, - STATE(313), 2, - sym_field_access_expression, - sym_indexing_expression, - STATE(304), 3, - sym_size_expression, - sym_length_expression, - sym_offset_expression, - ACTIONS(37), 4, - anon_sym_void, - anon_sym_true, - anon_sym_false, - anon_sym_null, - STATE(293), 4, - sym_integer_constant, - sym_floating_constant, - sym_rune_constant, - sym_string_constant, - STATE(301), 4, - sym_constant, - sym_array_literal, - sym_enum_literal, - sym_struct_literal, - STATE(303), 7, - sym_nested_expression, - sym_allocation_expression, - sym_assertion_expression, - sym_call_expression, - sym_measurement_expression, - sym_slicing_expression, - sym_error_propagation, - ACTIONS(55), 9, anon_sym_1, - anon_sym_2, - anon_sym_3, - anon_sym_4, - anon_sym_5, - anon_sym_6, - anon_sym_7, - anon_sym_8, - anon_sym_9, - [565] = 5, - ACTIONS(3), 1, - sym_comment, - ACTIONS(346), 2, - anon_sym_0, - anon_sym_1, - STATE(145), 2, + STATE(143), 2, sym_binary_digit, aux_sym_binary_digits_repeat1, - ACTIONS(344), 17, + ACTIONS(345), 17, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -20747,7 +20704,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(342), 40, + ACTIONS(343), 40, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -20788,75 +20745,173 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [638] = 5, - ACTIONS(3), 1, - sym_comment, - STATE(148), 2, - sym_decimal_digit, - aux_sym_decimal_digits_repeat1, - ACTIONS(55), 10, - anon_sym_0, - anon_sym_1, - anon_sym_2, - anon_sym_3, - anon_sym_4, - anon_sym_5, - anon_sym_6, - anon_sym_7, - anon_sym_8, - anon_sym_9, - ACTIONS(219), 11, - anon_sym_PIPE, - anon_sym_e, - anon_sym_i, - anon_sym_u, - anon_sym_DOT, - anon_sym_DOT_DOT, - anon_sym_AMP, - anon_sym_SLASH, - anon_sym_CARET, - anon_sym_LT, - anon_sym_GT, - ACTIONS(217), 38, - anon_sym_SEMI, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_i8, - anon_sym_i16, - anon_sym_i32, - anon_sym_i64, - anon_sym_u8, - anon_sym_u16, - anon_sym_u32, - anon_sym_u64, - anon_sym_f32, - anon_sym_f64, - anon_sym_STAR, - anon_sym_LBRACK, - anon_sym_RBRACK, - anon_sym_DOT_DOT_DOT, - anon_sym_z, - anon_sym_QMARK, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_as, - anon_sym_is, - anon_sym_PERCENT, - anon_sym_LT_LT, - anon_sym_GT_GT, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_CARET_CARET, - anon_sym_PIPE_PIPE, - anon_sym_else, - anon_sym_EQ_GT, - [711] = 35, + [505] = 35, + ACTIONS(3), 1, + sym_comment, + ACTIONS(33), 1, + anon_sym_LPAREN, + ACTIONS(39), 1, + anon_sym_size, + ACTIONS(43), 1, + anon_sym_struct, + ACTIONS(45), 1, + anon_sym_LBRACK, + ACTIONS(47), 1, + anon_sym_0x, + ACTIONS(49), 1, + anon_sym_0o, + ACTIONS(51), 1, + anon_sym_0b, + ACTIONS(53), 1, + anon_sym_0, + ACTIONS(57), 1, + anon_sym_SQUOTE, + ACTIONS(59), 1, + anon_sym_DQUOTE, + ACTIONS(61), 1, + anon_sym_alloc, + ACTIONS(63), 1, + anon_sym_append, + ACTIONS(65), 1, + anon_sym_free, + ACTIONS(67), 1, + anon_sym_delete, + ACTIONS(69), 1, + anon_sym_assert, + ACTIONS(73), 1, + anon_sym_abort, + ACTIONS(75), 1, + anon_sym_len, + ACTIONS(77), 1, + anon_sym_offset, + ACTIONS(185), 1, + anon_sym_static, + ACTIONS(305), 1, + sym_name, + STATE(164), 1, + sym_decimal_digits, + STATE(272), 1, + aux_sym_string_constant_repeat1, + STATE(276), 1, + sym_identifier, + STATE(302), 1, + sym_plain_expression, + STATE(350), 1, + sym_object_selector, + STATE(502), 1, + sym_postfix_expression, + STATE(146), 2, + sym_decimal_digit, + aux_sym_decimal_digits_repeat1, + STATE(313), 2, + sym_field_access_expression, + sym_indexing_expression, + STATE(304), 3, + sym_size_expression, + sym_length_expression, + sym_offset_expression, + ACTIONS(37), 4, + anon_sym_void, + anon_sym_true, + anon_sym_false, + anon_sym_null, + STATE(293), 4, + sym_integer_constant, + sym_floating_constant, + sym_rune_constant, + sym_string_constant, + STATE(301), 4, + sym_constant, + sym_array_literal, + sym_enum_literal, + sym_struct_literal, + STATE(303), 7, + sym_nested_expression, + sym_allocation_expression, + sym_assertion_expression, + sym_call_expression, + sym_measurement_expression, + sym_slicing_expression, + sym_error_propagation, + ACTIONS(55), 9, + anon_sym_1, + anon_sym_2, + anon_sym_3, + anon_sym_4, + anon_sym_5, + anon_sym_6, + anon_sym_7, + anon_sym_8, + anon_sym_9, + [638] = 5, + ACTIONS(3), 1, + sym_comment, + STATE(148), 2, + sym_decimal_digit, + aux_sym_decimal_digits_repeat1, + ACTIONS(55), 10, + anon_sym_0, + anon_sym_1, + anon_sym_2, + anon_sym_3, + anon_sym_4, + anon_sym_5, + anon_sym_6, + anon_sym_7, + anon_sym_8, + anon_sym_9, + ACTIONS(219), 11, + anon_sym_PIPE, + anon_sym_e, + anon_sym_i, + anon_sym_u, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(217), 38, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_f32, + anon_sym_f64, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_z, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [711] = 35, ACTIONS(3), 1, sym_comment, ACTIONS(33), 1, @@ -20899,7 +20954,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_static, ACTIONS(187), 1, sym_name, - STATE(163), 1, + STATE(164), 1, sym_decimal_digits, STATE(272), 1, aux_sym_string_constant_repeat1, @@ -21136,9 +21191,9 @@ static uint16_t ts_small_parse_table[] = { sym_name, ACTIONS(185), 1, anon_sym_static, - STATE(163), 1, + STATE(164), 1, sym_decimal_digits, - STATE(185), 1, + STATE(215), 1, sym_identifier, STATE(264), 1, sym_object_selector, @@ -21234,7 +21289,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_static, ACTIONS(305), 1, sym_name, - STATE(163), 1, + STATE(164), 1, sym_decimal_digits, STATE(272), 1, aux_sym_string_constant_repeat1, @@ -21330,7 +21385,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_static, ACTIONS(305), 1, sym_name, - STATE(163), 1, + STATE(164), 1, sym_decimal_digits, STATE(272), 1, aux_sym_string_constant_repeat1, @@ -21496,7 +21551,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_static, ACTIONS(305), 1, sym_name, - STATE(163), 1, + STATE(164), 1, sym_decimal_digits, STATE(272), 1, aux_sym_string_constant_repeat1, @@ -21592,7 +21647,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_static, ACTIONS(305), 1, sym_name, - STATE(163), 1, + STATE(164), 1, sym_decimal_digits, STATE(272), 1, aux_sym_string_constant_repeat1, @@ -21681,11 +21736,11 @@ static uint16_t ts_small_parse_table[] = { anon_sym_u16, anon_sym_u32, anon_sym_u64, + anon_sym_f32, + anon_sym_f64, anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, - anon_sym_0, - anon_sym_1, anon_sym_z, anon_sym_QMARK, anon_sym_as, @@ -21745,11 +21800,11 @@ static uint16_t ts_small_parse_table[] = { anon_sym_u16, anon_sym_u32, anon_sym_u64, - anon_sym_f32, - anon_sym_f64, anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, + anon_sym_0, + anon_sym_1, anon_sym_z, anon_sym_QMARK, anon_sym_as, @@ -22088,12 +22143,91 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [2198] = 11, + [2198] = 25, ACTIONS(3), 1, sym_comment, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(369), 1, + anon_sym_RBRACE, + ACTIONS(371), 1, + anon_sym_const, ACTIONS(373), 1, + anon_sym_LPAREN, + ACTIONS(375), 1, + anon_sym_fn, + ACTIONS(383), 1, + anon_sym_enum, + ACTIONS(385), 1, + anon_sym_STAR, + ACTIONS(387), 1, + anon_sym_nullable, + ACTIONS(389), 1, + anon_sym_struct, + ACTIONS(391), 1, + anon_sym_union, + ACTIONS(393), 1, + anon_sym_LBRACK, + ACTIONS(395), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(397), 1, + sym_name, + STATE(428), 1, + sym_identifier, + STATE(552), 1, + sym_match_case, + STATE(649), 1, + sym_fntype_attr, + STATE(713), 1, + sym_match_cases, + STATE(725), 1, + sym_type, + ACTIONS(381), 2, + anon_sym_f32, + anon_sym_f64, + STATE(426), 2, + sym__inner_type, + sym_storage_class, + ACTIONS(377), 4, + anon_sym_rune, + anon_sym_str, + anon_sym_bool, + anon_sym_void, + STATE(424), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(427), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(379), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [2302] = 11, + ACTIONS(3), 1, + sym_comment, + ACTIONS(403), 1, anon_sym_e, - ACTIONS(377), 1, + ACTIONS(407), 1, anon_sym_DOT, STATE(173), 1, sym_exponent, @@ -22101,10 +22235,10 @@ static uint16_t ts_small_parse_table[] = { sym_integer_suffix, STATE(299), 1, sym_floating_suffix, - ACTIONS(371), 2, + ACTIONS(401), 2, anon_sym_f32, anon_sym_f64, - ACTIONS(375), 2, + ACTIONS(405), 2, anon_sym_i, anon_sym_u, ACTIONS(319), 7, @@ -22115,7 +22249,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(369), 9, + ACTIONS(399), 9, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -22153,53 +22287,52 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [2274] = 25, + [2378] = 24, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, anon_sym_ATnoreturn, - ACTIONS(380), 1, - anon_sym_RBRACE, - ACTIONS(382), 1, + ACTIONS(371), 1, anon_sym_const, - ACTIONS(384), 1, + ACTIONS(373), 1, anon_sym_LPAREN, - ACTIONS(386), 1, + ACTIONS(375), 1, anon_sym_fn, - ACTIONS(394), 1, + ACTIONS(383), 1, anon_sym_enum, - ACTIONS(396), 1, - anon_sym_STAR, - ACTIONS(398), 1, + ACTIONS(387), 1, anon_sym_nullable, - ACTIONS(400), 1, + ACTIONS(389), 1, anon_sym_struct, - ACTIONS(402), 1, + ACTIONS(391), 1, anon_sym_union, - ACTIONS(404), 1, + ACTIONS(393), 1, anon_sym_LBRACK, - ACTIONS(406), 1, + ACTIONS(395), 1, anon_sym_DOT_DOT_DOT, - ACTIONS(408), 1, + ACTIONS(410), 1, + anon_sym_RPAREN, + ACTIONS(412), 1, + anon_sym_STAR, + ACTIONS(414), 1, sym_name, STATE(428), 1, sym_identifier, - STATE(552), 1, - sym_match_case, + STATE(567), 1, + sym_type, STATE(649), 1, sym_fntype_attr, - STATE(713), 1, - sym_match_cases, - STATE(725), 1, - sym_type, - ACTIONS(392), 2, + STATE(685), 1, + sym_tuple_types, + ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, STATE(426), 2, sym__inner_type, sym_storage_class, - ACTIONS(388), 3, + ACTIONS(377), 4, anon_sym_rune, + anon_sym_str, anon_sym_bool, anon_sym_void, STATE(424), 4, @@ -22217,7 +22350,7 @@ static uint16_t ts_small_parse_table[] = { sym_function_type, sym_alias_type, sym_unwrapped_alias, - ACTIONS(390), 13, + ACTIONS(379), 13, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -22231,10 +22364,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [2377] = 3, + [2479] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(410), 24, + ACTIONS(416), 24, anon_sym_LBRACE, anon_sym_COLON, anon_sym_LPAREN, @@ -22259,7 +22392,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DASH, anon_sym_TILDE, anon_sym_AMP, - ACTIONS(412), 27, + ACTIONS(418), 27, anon_sym_let, anon_sym_const, anon_sym_void, @@ -22287,19 +22420,96 @@ static uint16_t ts_small_parse_table[] = { anon_sym_continue, anon_sym_return, sym_name, - [2436] = 7, + [2538] = 24, + ACTIONS(3), 1, + sym_comment, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(371), 1, + anon_sym_const, + ACTIONS(373), 1, + anon_sym_LPAREN, + ACTIONS(375), 1, + anon_sym_fn, + ACTIONS(383), 1, + anon_sym_enum, + ACTIONS(385), 1, + anon_sym_STAR, + ACTIONS(387), 1, + anon_sym_nullable, + ACTIONS(389), 1, + anon_sym_struct, + ACTIONS(391), 1, + anon_sym_union, + ACTIONS(393), 1, + anon_sym_LBRACK, + ACTIONS(395), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(397), 1, + sym_name, + STATE(428), 1, + sym_identifier, + STATE(552), 1, + sym_match_case, + STATE(649), 1, + sym_fntype_attr, + STATE(723), 1, + sym_match_cases, + STATE(725), 1, + sym_type, + ACTIONS(381), 2, + anon_sym_f32, + anon_sym_f64, + STATE(426), 2, + sym__inner_type, + sym_storage_class, + ACTIONS(377), 4, + anon_sym_rune, + anon_sym_str, + anon_sym_bool, + anon_sym_void, + STATE(424), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(427), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(379), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [2639] = 7, ACTIONS(3), 1, sym_comment, ACTIONS(325), 1, anon_sym_e, - STATE(174), 1, + STATE(185), 1, sym_exponent, STATE(221), 1, sym_floating_suffix, ACTIONS(323), 2, anon_sym_f32, anon_sym_f64, - ACTIONS(416), 15, + ACTIONS(422), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -22315,7 +22525,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(414), 31, + ACTIONS(420), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -22347,165 +22557,52 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [2503] = 5, - ACTIONS(3), 1, - sym_comment, - ACTIONS(418), 2, - anon_sym_0, - anon_sym_1, - STATE(167), 2, - sym_binary_digit, - aux_sym_binary_digits_repeat1, - ACTIONS(344), 10, - anon_sym_PIPE, - anon_sym_i, - anon_sym_u, - anon_sym_DOT, - anon_sym_DOT_DOT, - anon_sym_AMP, - anon_sym_SLASH, - anon_sym_CARET, - anon_sym_LT, - anon_sym_GT, - ACTIONS(342), 36, - anon_sym_SEMI, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_i8, - anon_sym_i16, - anon_sym_i32, - anon_sym_i64, - anon_sym_u8, - anon_sym_u16, - anon_sym_u32, - anon_sym_u64, - anon_sym_STAR, - anon_sym_LBRACK, - anon_sym_RBRACK, - anon_sym_DOT_DOT_DOT, - anon_sym_z, - anon_sym_QMARK, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_as, - anon_sym_is, - anon_sym_PERCENT, - anon_sym_LT_LT, - anon_sym_GT_GT, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_CARET_CARET, - anon_sym_PIPE_PIPE, - anon_sym_else, - anon_sym_EQ_GT, - [2565] = 5, - ACTIONS(3), 1, - sym_comment, - ACTIONS(421), 2, - anon_sym_0, - anon_sym_1, - STATE(167), 2, - sym_binary_digit, - aux_sym_binary_digits_repeat1, - ACTIONS(338), 10, - anon_sym_PIPE, - anon_sym_i, - anon_sym_u, - anon_sym_DOT, - anon_sym_DOT_DOT, - anon_sym_AMP, - anon_sym_SLASH, - anon_sym_CARET, - anon_sym_LT, - anon_sym_GT, - ACTIONS(336), 36, - anon_sym_SEMI, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_i8, - anon_sym_i16, - anon_sym_i32, - anon_sym_i64, - anon_sym_u8, - anon_sym_u16, - anon_sym_u32, - anon_sym_u64, - anon_sym_STAR, - anon_sym_LBRACK, - anon_sym_RBRACK, - anon_sym_DOT_DOT_DOT, - anon_sym_z, - anon_sym_QMARK, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_as, - anon_sym_is, - anon_sym_PERCENT, - anon_sym_LT_LT, - anon_sym_GT_GT, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_CARET_CARET, - anon_sym_PIPE_PIPE, - anon_sym_else, - anon_sym_EQ_GT, - [2627] = 24, + [2706] = 24, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, anon_sym_ATnoreturn, - ACTIONS(382), 1, + ACTIONS(371), 1, anon_sym_const, - ACTIONS(384), 1, + ACTIONS(373), 1, anon_sym_LPAREN, - ACTIONS(386), 1, + ACTIONS(375), 1, anon_sym_fn, - ACTIONS(394), 1, + ACTIONS(383), 1, anon_sym_enum, - ACTIONS(398), 1, + ACTIONS(387), 1, anon_sym_nullable, - ACTIONS(400), 1, + ACTIONS(389), 1, anon_sym_struct, - ACTIONS(402), 1, + ACTIONS(391), 1, anon_sym_union, - ACTIONS(404), 1, + ACTIONS(393), 1, anon_sym_LBRACK, - ACTIONS(406), 1, + ACTIONS(395), 1, anon_sym_DOT_DOT_DOT, - ACTIONS(423), 1, - anon_sym_RPAREN, - ACTIONS(425), 1, + ACTIONS(412), 1, anon_sym_STAR, - ACTIONS(427), 1, + ACTIONS(414), 1, sym_name, STATE(428), 1, sym_identifier, - STATE(567), 1, + STATE(604), 1, sym_type, + STATE(645), 1, + sym_tuple_types, + STATE(646), 1, + sym_tagged_types, STATE(649), 1, sym_fntype_attr, - STATE(685), 1, - sym_tuple_types, - ACTIONS(392), 2, + ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, STATE(426), 2, sym__inner_type, sym_storage_class, - ACTIONS(388), 3, + ACTIONS(377), 4, anon_sym_rune, + anon_sym_str, anon_sym_bool, anon_sym_void, STATE(424), 4, @@ -22523,7 +22620,7 @@ static uint16_t ts_small_parse_table[] = { sym_function_type, sym_alias_type, sym_unwrapped_alias, - ACTIONS(390), 13, + ACTIONS(379), 13, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -22537,51 +22634,52 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [2727] = 24, + [2807] = 24, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, anon_sym_ATnoreturn, - ACTIONS(382), 1, + ACTIONS(371), 1, anon_sym_const, - ACTIONS(384), 1, + ACTIONS(373), 1, anon_sym_LPAREN, - ACTIONS(386), 1, + ACTIONS(375), 1, anon_sym_fn, - ACTIONS(394), 1, + ACTIONS(383), 1, anon_sym_enum, - ACTIONS(396), 1, - anon_sym_STAR, - ACTIONS(398), 1, + ACTIONS(387), 1, anon_sym_nullable, - ACTIONS(400), 1, + ACTIONS(389), 1, anon_sym_struct, - ACTIONS(402), 1, + ACTIONS(391), 1, anon_sym_union, - ACTIONS(404), 1, + ACTIONS(393), 1, anon_sym_LBRACK, - ACTIONS(406), 1, + ACTIONS(395), 1, anon_sym_DOT_DOT_DOT, - ACTIONS(408), 1, + ACTIONS(412), 1, + anon_sym_STAR, + ACTIONS(414), 1, sym_name, STATE(428), 1, sym_identifier, - STATE(552), 1, - sym_match_case, + STATE(604), 1, + sym_type, STATE(649), 1, sym_fntype_attr, - STATE(723), 1, - sym_match_cases, - STATE(725), 1, - sym_type, - ACTIONS(392), 2, + STATE(658), 1, + sym_tuple_types, + STATE(659), 1, + sym_tagged_types, + ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, STATE(426), 2, sym__inner_type, sym_storage_class, - ACTIONS(388), 3, + ACTIONS(377), 4, anon_sym_rune, + anon_sym_str, anon_sym_bool, anon_sym_void, STATE(424), 4, @@ -22599,7 +22697,7 @@ static uint16_t ts_small_parse_table[] = { sym_function_type, sym_alias_type, sym_unwrapped_alias, - ACTIONS(390), 13, + ACTIONS(379), 13, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -22613,69 +22711,33 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [2827] = 24, + [2908] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(23), 1, - anon_sym_ATnoreturn, - ACTIONS(382), 1, - anon_sym_const, - ACTIONS(384), 1, + ACTIONS(424), 2, + anon_sym_0, + anon_sym_1, + STATE(174), 2, + sym_binary_digit, + aux_sym_binary_digits_repeat1, + ACTIONS(345), 10, + anon_sym_PIPE, + anon_sym_i, + anon_sym_u, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(343), 36, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, anon_sym_LPAREN, - ACTIONS(386), 1, - anon_sym_fn, - ACTIONS(394), 1, - anon_sym_enum, - ACTIONS(398), 1, - anon_sym_nullable, - ACTIONS(400), 1, - anon_sym_struct, - ACTIONS(402), 1, - anon_sym_union, - ACTIONS(404), 1, - anon_sym_LBRACK, - ACTIONS(406), 1, - anon_sym_DOT_DOT_DOT, - ACTIONS(425), 1, - anon_sym_STAR, - ACTIONS(427), 1, - sym_name, - STATE(428), 1, - sym_identifier, - STATE(604), 1, - sym_type, - STATE(645), 1, - sym_tuple_types, - STATE(646), 1, - sym_tagged_types, - STATE(649), 1, - sym_fntype_attr, - ACTIONS(392), 2, - anon_sym_f32, - anon_sym_f64, - STATE(426), 2, - sym__inner_type, - sym_storage_class, - ACTIONS(388), 3, - anon_sym_rune, - anon_sym_bool, - anon_sym_void, - STATE(424), 4, - sym_integer_type, - sym_floating_type, - sym_enum_type, - sym_pointer_type, - STATE(427), 9, - sym_scalar_type, - sym_struct_type, - sym_union_type, - sym_tuple_type, - sym_tagged_union_type, - sym_slice_array_type, - sym_function_type, - sym_alias_type, - sym_unwrapped_alias, - ACTIONS(390), 13, + anon_sym_RPAREN, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -22684,56 +22746,72 @@ static uint16_t ts_small_parse_table[] = { anon_sym_u16, anon_sym_u32, anon_sym_u64, - anon_sym_int, - anon_sym_uint, - anon_sym_size, - anon_sym_uintptr, - anon_sym_char, - [2927] = 24, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_z, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [2970] = 23, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, anon_sym_ATnoreturn, - ACTIONS(382), 1, + ACTIONS(371), 1, anon_sym_const, - ACTIONS(384), 1, + ACTIONS(373), 1, anon_sym_LPAREN, - ACTIONS(386), 1, + ACTIONS(375), 1, anon_sym_fn, - ACTIONS(394), 1, + ACTIONS(383), 1, anon_sym_enum, - ACTIONS(398), 1, + ACTIONS(387), 1, anon_sym_nullable, - ACTIONS(400), 1, + ACTIONS(389), 1, anon_sym_struct, - ACTIONS(402), 1, + ACTIONS(391), 1, anon_sym_union, - ACTIONS(404), 1, + ACTIONS(393), 1, anon_sym_LBRACK, - ACTIONS(406), 1, + ACTIONS(395), 1, anon_sym_DOT_DOT_DOT, - ACTIONS(425), 1, + ACTIONS(412), 1, anon_sym_STAR, - ACTIONS(427), 1, + ACTIONS(414), 1, sym_name, STATE(428), 1, sym_identifier, - STATE(604), 1, + STATE(567), 1, sym_type, STATE(649), 1, sym_fntype_attr, - STATE(658), 1, + STATE(685), 1, sym_tuple_types, - STATE(659), 1, - sym_tagged_types, - ACTIONS(392), 2, + ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, STATE(426), 2, sym__inner_type, sym_storage_class, - ACTIONS(388), 3, + ACTIONS(377), 4, anon_sym_rune, + anon_sym_str, anon_sym_bool, anon_sym_void, STATE(424), 4, @@ -22751,7 +22829,7 @@ static uint16_t ts_small_parse_table[] = { sym_function_type, sym_alias_type, sym_unwrapped_alias, - ACTIONS(390), 13, + ACTIONS(379), 13, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -22765,17 +22843,17 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [3027] = 8, + [3068] = 8, ACTIONS(3), 1, sym_comment, STATE(297), 1, sym_floating_suffix, STATE(320), 1, sym_integer_suffix, - ACTIONS(371), 2, + ACTIONS(401), 2, anon_sym_f32, anon_sym_f64, - ACTIONS(375), 2, + ACTIONS(405), 2, anon_sym_i, anon_sym_u, ACTIONS(354), 8, @@ -22787,7 +22865,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(369), 9, + ACTIONS(399), 9, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -22825,84 +22903,33 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [3095] = 5, + [3136] = 5, ACTIONS(3), 1, sym_comment, - STATE(236), 1, - sym_floating_suffix, - ACTIONS(323), 2, - anon_sym_f32, - anon_sym_f64, - ACTIONS(431), 15, - anon_sym_EQ, - anon_sym_STAR, + ACTIONS(426), 2, + anon_sym_0, + anon_sym_1, + STATE(174), 2, + sym_binary_digit, + aux_sym_binary_digits_repeat1, + ACTIONS(338), 10, anon_sym_PIPE, + anon_sym_i, + anon_sym_u, anon_sym_DOT, anon_sym_DOT_DOT, - anon_sym_PLUS, - anon_sym_DASH, anon_sym_AMP, anon_sym_SLASH, - anon_sym_PERCENT, - anon_sym_LT_LT, - anon_sym_GT_GT, anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(429), 31, + ACTIONS(336), 36, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, anon_sym_COLON, anon_sym_LPAREN, anon_sym_RPAREN, - anon_sym_LBRACK, - anon_sym_RBRACK, - anon_sym_DOT_DOT_DOT, - anon_sym_QMARK, - anon_sym_as, - anon_sym_is, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_CARET_CARET, - anon_sym_PIPE_PIPE, - anon_sym_else, - anon_sym_EQ_GT, - anon_sym_PLUS_EQ, - anon_sym_DASH_EQ, - anon_sym_STAR_EQ, - anon_sym_SLASH_EQ, - anon_sym_PERCENT_EQ, - anon_sym_LT_LT_EQ, - anon_sym_GT_GT_EQ, - anon_sym_AMP_EQ, - anon_sym_PIPE_EQ, - anon_sym_CARET_EQ, - [3156] = 8, - ACTIONS(3), 1, - sym_comment, - ACTIONS(373), 1, - anon_sym_e, - STATE(212), 1, - sym_exponent, - STATE(298), 1, - sym_integer_suffix, - ACTIONS(375), 2, - anon_sym_i, - anon_sym_u, - ACTIONS(319), 8, - anon_sym_PIPE, - anon_sym_DOT, - anon_sym_DOT_DOT, - anon_sym_AMP, - anon_sym_SLASH, - anon_sym_CARET, - anon_sym_LT, - anon_sym_GT, - ACTIONS(369), 9, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -22911,18 +22938,11 @@ static uint16_t ts_small_parse_table[] = { anon_sym_u16, anon_sym_u32, anon_sym_u64, - anon_sym_z, - ACTIONS(317), 27, - anon_sym_SEMI, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, anon_sym_STAR, anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, + anon_sym_z, anon_sym_QMARK, anon_sym_PLUS, anon_sym_DASH, @@ -22940,49 +22960,48 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [3223] = 23, + [3198] = 22, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, anon_sym_ATnoreturn, - ACTIONS(382), 1, + ACTIONS(371), 1, anon_sym_const, - ACTIONS(384), 1, + ACTIONS(373), 1, anon_sym_LPAREN, - ACTIONS(386), 1, + ACTIONS(375), 1, anon_sym_fn, - ACTIONS(394), 1, + ACTIONS(383), 1, anon_sym_enum, - ACTIONS(398), 1, + ACTIONS(387), 1, anon_sym_nullable, - ACTIONS(400), 1, + ACTIONS(389), 1, anon_sym_struct, - ACTIONS(402), 1, + ACTIONS(391), 1, anon_sym_union, - ACTIONS(404), 1, + ACTIONS(393), 1, anon_sym_LBRACK, - ACTIONS(406), 1, + ACTIONS(395), 1, anon_sym_DOT_DOT_DOT, - ACTIONS(425), 1, + ACTIONS(412), 1, anon_sym_STAR, - ACTIONS(427), 1, + ACTIONS(414), 1, sym_name, STATE(428), 1, sym_identifier, - STATE(567), 1, + STATE(559), 1, sym_type, STATE(649), 1, sym_fntype_attr, - STATE(685), 1, - sym_tuple_types, - ACTIONS(392), 2, + ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, STATE(426), 2, sym__inner_type, sym_storage_class, - ACTIONS(388), 3, + ACTIONS(377), 4, anon_sym_rune, + anon_sym_str, anon_sym_bool, anon_sym_void, STATE(424), 4, @@ -23000,7 +23019,7 @@ static uint16_t ts_small_parse_table[] = { sym_function_type, sym_alias_type, sym_unwrapped_alias, - ACTIONS(390), 13, + ACTIONS(379), 13, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -23014,153 +23033,48 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [3320] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(435), 16, - anon_sym_EQ, - anon_sym_COLON, - anon_sym_STAR, - anon_sym_PIPE, - anon_sym_DOT, - anon_sym_DOT_DOT, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_AMP, - anon_sym_SLASH, - anon_sym_PERCENT, - anon_sym_LT_LT, - anon_sym_GT_GT, - anon_sym_CARET, - anon_sym_LT, - anon_sym_GT, - ACTIONS(433), 32, - anon_sym_SEMI, - anon_sym_COLON_COLON, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_LBRACK, - anon_sym_RBRACK, - anon_sym_DOT_DOT_DOT, - anon_sym_QMARK, - anon_sym_as, - anon_sym_is, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_CARET_CARET, - anon_sym_PIPE_PIPE, - anon_sym_else, - anon_sym_EQ_GT, - anon_sym_PLUS_EQ, - anon_sym_DASH_EQ, - anon_sym_STAR_EQ, - anon_sym_SLASH_EQ, - anon_sym_PERCENT_EQ, - anon_sym_LT_LT_EQ, - anon_sym_GT_GT_EQ, - anon_sym_AMP_EQ, - anon_sym_PIPE_EQ, - anon_sym_CARET_EQ, - [3376] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(358), 10, - anon_sym_PIPE, - anon_sym_i, - anon_sym_u, - anon_sym_DOT, - anon_sym_DOT_DOT, - anon_sym_AMP, - anon_sym_SLASH, - anon_sym_CARET, - anon_sym_LT, - anon_sym_GT, - ACTIONS(356), 38, - anon_sym_SEMI, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_i8, - anon_sym_i16, - anon_sym_i32, - anon_sym_i64, - anon_sym_u8, - anon_sym_u16, - anon_sym_u32, - anon_sym_u64, - anon_sym_STAR, - anon_sym_LBRACK, - anon_sym_RBRACK, - anon_sym_DOT_DOT_DOT, - anon_sym_0, - anon_sym_1, - anon_sym_z, - anon_sym_QMARK, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_as, - anon_sym_is, - anon_sym_PERCENT, - anon_sym_LT_LT, - anon_sym_GT_GT, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_CARET_CARET, - anon_sym_PIPE_PIPE, - anon_sym_else, - anon_sym_EQ_GT, - [3432] = 22, + [3293] = 22, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, anon_sym_ATnoreturn, - ACTIONS(382), 1, + ACTIONS(371), 1, anon_sym_const, - ACTIONS(384), 1, + ACTIONS(373), 1, anon_sym_LPAREN, - ACTIONS(386), 1, + ACTIONS(375), 1, anon_sym_fn, - ACTIONS(394), 1, + ACTIONS(383), 1, anon_sym_enum, - ACTIONS(398), 1, + ACTIONS(387), 1, anon_sym_nullable, - ACTIONS(400), 1, + ACTIONS(389), 1, anon_sym_struct, - ACTIONS(402), 1, + ACTIONS(391), 1, anon_sym_union, - ACTIONS(404), 1, + ACTIONS(393), 1, anon_sym_LBRACK, - ACTIONS(406), 1, + ACTIONS(395), 1, anon_sym_DOT_DOT_DOT, - ACTIONS(425), 1, + ACTIONS(412), 1, anon_sym_STAR, - ACTIONS(427), 1, + ACTIONS(414), 1, sym_name, STATE(428), 1, sym_identifier, - STATE(559), 1, + STATE(529), 1, sym_type, STATE(649), 1, sym_fntype_attr, - ACTIONS(392), 2, + ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, STATE(426), 2, sym__inner_type, sym_storage_class, - ACTIONS(388), 3, + ACTIONS(377), 4, anon_sym_rune, + anon_sym_str, anon_sym_bool, anon_sym_void, STATE(424), 4, @@ -23178,7 +23092,7 @@ static uint16_t ts_small_parse_table[] = { sym_function_type, sym_alias_type, sym_unwrapped_alias, - ACTIONS(390), 13, + ACTIONS(379), 13, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -23192,47 +23106,48 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [3526] = 22, + [3388] = 22, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, anon_sym_ATnoreturn, - ACTIONS(382), 1, + ACTIONS(371), 1, anon_sym_const, - ACTIONS(384), 1, + ACTIONS(373), 1, anon_sym_LPAREN, - ACTIONS(386), 1, + ACTIONS(375), 1, anon_sym_fn, - ACTIONS(394), 1, + ACTIONS(383), 1, anon_sym_enum, - ACTIONS(398), 1, + ACTIONS(387), 1, anon_sym_nullable, - ACTIONS(400), 1, + ACTIONS(389), 1, anon_sym_struct, - ACTIONS(402), 1, + ACTIONS(391), 1, anon_sym_union, - ACTIONS(404), 1, + ACTIONS(393), 1, anon_sym_LBRACK, - ACTIONS(406), 1, + ACTIONS(395), 1, anon_sym_DOT_DOT_DOT, - ACTIONS(425), 1, + ACTIONS(412), 1, anon_sym_STAR, - ACTIONS(427), 1, + ACTIONS(414), 1, sym_name, STATE(428), 1, sym_identifier, + STATE(557), 1, + sym_type, STATE(649), 1, sym_fntype_attr, - STATE(714), 1, - sym_type, - ACTIONS(392), 2, + ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, STATE(426), 2, sym__inner_type, sym_storage_class, - ACTIONS(388), 3, + ACTIONS(377), 4, anon_sym_rune, + anon_sym_str, anon_sym_bool, anon_sym_void, STATE(424), 4, @@ -23250,7 +23165,7 @@ static uint16_t ts_small_parse_table[] = { sym_function_type, sym_alias_type, sym_unwrapped_alias, - ACTIONS(390), 13, + ACTIONS(379), 13, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -23264,55 +23179,56 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [3620] = 22, + [3483] = 22, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, anon_sym_ATnoreturn, - ACTIONS(437), 1, + ACTIONS(371), 1, anon_sym_const, - ACTIONS(439), 1, + ACTIONS(373), 1, anon_sym_LPAREN, - ACTIONS(441), 1, + ACTIONS(375), 1, anon_sym_fn, - ACTIONS(449), 1, + ACTIONS(383), 1, anon_sym_enum, - ACTIONS(451), 1, - anon_sym_STAR, - ACTIONS(453), 1, + ACTIONS(387), 1, anon_sym_nullable, - ACTIONS(455), 1, + ACTIONS(389), 1, anon_sym_struct, - ACTIONS(457), 1, + ACTIONS(391), 1, anon_sym_union, - ACTIONS(459), 1, + ACTIONS(393), 1, anon_sym_LBRACK, - ACTIONS(461), 1, + ACTIONS(395), 1, anon_sym_DOT_DOT_DOT, - ACTIONS(463), 1, + ACTIONS(412), 1, + anon_sym_STAR, + ACTIONS(414), 1, sym_name, - STATE(326), 1, + STATE(428), 1, sym_identifier, - STATE(353), 1, - sym_type, - STATE(737), 1, + STATE(649), 1, sym_fntype_attr, - ACTIONS(447), 2, + STATE(751), 1, + sym_type, + ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, - STATE(330), 2, + STATE(426), 2, sym__inner_type, sym_storage_class, - ACTIONS(443), 3, + ACTIONS(377), 4, anon_sym_rune, + anon_sym_str, anon_sym_bool, anon_sym_void, - STATE(327), 4, + STATE(424), 4, sym_integer_type, sym_floating_type, sym_enum_type, sym_pointer_type, - STATE(342), 9, + STATE(427), 9, sym_scalar_type, sym_struct_type, sym_union_type, @@ -23322,7 +23238,7 @@ static uint16_t ts_small_parse_table[] = { sym_function_type, sym_alias_type, sym_unwrapped_alias, - ACTIONS(445), 13, + ACTIONS(379), 13, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -23336,55 +23252,56 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [3714] = 22, + [3578] = 22, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, anon_sym_ATnoreturn, - ACTIONS(437), 1, + ACTIONS(371), 1, anon_sym_const, - ACTIONS(439), 1, + ACTIONS(373), 1, anon_sym_LPAREN, - ACTIONS(441), 1, + ACTIONS(375), 1, anon_sym_fn, - ACTIONS(449), 1, + ACTIONS(383), 1, anon_sym_enum, - ACTIONS(451), 1, - anon_sym_STAR, - ACTIONS(453), 1, + ACTIONS(387), 1, anon_sym_nullable, - ACTIONS(455), 1, + ACTIONS(389), 1, anon_sym_struct, - ACTIONS(457), 1, + ACTIONS(391), 1, anon_sym_union, - ACTIONS(459), 1, + ACTIONS(393), 1, anon_sym_LBRACK, - ACTIONS(461), 1, + ACTIONS(395), 1, anon_sym_DOT_DOT_DOT, - ACTIONS(463), 1, + ACTIONS(412), 1, + anon_sym_STAR, + ACTIONS(414), 1, sym_name, - STATE(326), 1, + STATE(428), 1, sym_identifier, - STATE(352), 1, - sym_type, - STATE(737), 1, + STATE(649), 1, sym_fntype_attr, - ACTIONS(447), 2, + STATE(698), 1, + sym_type, + ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, - STATE(330), 2, + STATE(426), 2, sym__inner_type, sym_storage_class, - ACTIONS(443), 3, + ACTIONS(377), 4, anon_sym_rune, + anon_sym_str, anon_sym_bool, anon_sym_void, - STATE(327), 4, + STATE(424), 4, sym_integer_type, sym_floating_type, sym_enum_type, sym_pointer_type, - STATE(342), 9, + STATE(427), 9, sym_scalar_type, sym_struct_type, sym_union_type, @@ -23394,7 +23311,7 @@ static uint16_t ts_small_parse_table[] = { sym_function_type, sym_alias_type, sym_unwrapped_alias, - ACTIONS(445), 13, + ACTIONS(379), 13, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -23408,47 +23325,48 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [3808] = 22, + [3673] = 22, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, anon_sym_ATnoreturn, - ACTIONS(382), 1, + ACTIONS(371), 1, anon_sym_const, - ACTIONS(384), 1, + ACTIONS(373), 1, anon_sym_LPAREN, - ACTIONS(386), 1, + ACTIONS(375), 1, anon_sym_fn, - ACTIONS(394), 1, + ACTIONS(383), 1, anon_sym_enum, - ACTIONS(398), 1, + ACTIONS(387), 1, anon_sym_nullable, - ACTIONS(400), 1, + ACTIONS(389), 1, anon_sym_struct, - ACTIONS(402), 1, + ACTIONS(391), 1, anon_sym_union, - ACTIONS(404), 1, + ACTIONS(393), 1, anon_sym_LBRACK, - ACTIONS(406), 1, + ACTIONS(395), 1, anon_sym_DOT_DOT_DOT, - ACTIONS(425), 1, + ACTIONS(412), 1, anon_sym_STAR, - ACTIONS(427), 1, + ACTIONS(414), 1, sym_name, STATE(428), 1, sym_identifier, STATE(649), 1, sym_fntype_attr, - STATE(702), 1, + STATE(714), 1, sym_type, - ACTIONS(392), 2, + ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, STATE(426), 2, sym__inner_type, sym_storage_class, - ACTIONS(388), 3, + ACTIONS(377), 4, anon_sym_rune, + anon_sym_str, anon_sym_bool, anon_sym_void, STATE(424), 4, @@ -23466,7 +23384,7 @@ static uint16_t ts_small_parse_table[] = { sym_function_type, sym_alias_type, sym_unwrapped_alias, - ACTIONS(390), 13, + ACTIONS(379), 13, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -23480,47 +23398,48 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [3902] = 22, + [3768] = 22, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, anon_sym_ATnoreturn, - ACTIONS(437), 1, + ACTIONS(429), 1, anon_sym_const, - ACTIONS(439), 1, + ACTIONS(431), 1, anon_sym_LPAREN, - ACTIONS(441), 1, + ACTIONS(433), 1, anon_sym_fn, - ACTIONS(449), 1, + ACTIONS(441), 1, anon_sym_enum, - ACTIONS(451), 1, + ACTIONS(443), 1, anon_sym_STAR, - ACTIONS(453), 1, + ACTIONS(445), 1, anon_sym_nullable, - ACTIONS(455), 1, + ACTIONS(447), 1, anon_sym_struct, - ACTIONS(457), 1, + ACTIONS(449), 1, anon_sym_union, - ACTIONS(459), 1, + ACTIONS(451), 1, anon_sym_LBRACK, - ACTIONS(461), 1, + ACTIONS(453), 1, anon_sym_DOT_DOT_DOT, - ACTIONS(463), 1, + ACTIONS(455), 1, sym_name, STATE(326), 1, sym_identifier, - STATE(351), 1, + STATE(353), 1, sym_type, STATE(737), 1, sym_fntype_attr, - ACTIONS(447), 2, + ACTIONS(439), 2, anon_sym_f32, anon_sym_f64, STATE(330), 2, sym__inner_type, sym_storage_class, - ACTIONS(443), 3, + ACTIONS(435), 4, anon_sym_rune, + anon_sym_str, anon_sym_bool, anon_sym_void, STATE(327), 4, @@ -23538,7 +23457,7 @@ static uint16_t ts_small_parse_table[] = { sym_function_type, sym_alias_type, sym_unwrapped_alias, - ACTIONS(445), 13, + ACTIONS(437), 13, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -23552,112 +23471,56 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [3996] = 7, + [3863] = 22, ACTIONS(3), 1, sym_comment, - ACTIONS(469), 1, - anon_sym_COLON_COLON, - ACTIONS(471), 1, - anon_sym_LBRACE, - ACTIONS(475), 1, - anon_sym_DOT, - ACTIONS(473), 3, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(429), 1, + anon_sym_const, + ACTIONS(431), 1, anon_sym_LPAREN, - anon_sym_LBRACK, - anon_sym_QMARK, - ACTIONS(467), 15, - anon_sym_EQ, - anon_sym_COLON, + ACTIONS(433), 1, + anon_sym_fn, + ACTIONS(441), 1, + anon_sym_enum, + ACTIONS(443), 1, anon_sym_STAR, - anon_sym_PIPE, - anon_sym_DOT_DOT, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_AMP, - anon_sym_SLASH, - anon_sym_PERCENT, - anon_sym_LT_LT, - anon_sym_GT_GT, - anon_sym_CARET, - anon_sym_LT, - anon_sym_GT, - ACTIONS(465), 27, - anon_sym_SEMI, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_RPAREN, - anon_sym_RBRACK, - anon_sym_DOT_DOT_DOT, - anon_sym_as, - anon_sym_is, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_CARET_CARET, - anon_sym_PIPE_PIPE, - anon_sym_else, - anon_sym_EQ_GT, - anon_sym_PLUS_EQ, - anon_sym_DASH_EQ, - anon_sym_STAR_EQ, - anon_sym_SLASH_EQ, - anon_sym_PERCENT_EQ, - anon_sym_LT_LT_EQ, - anon_sym_GT_GT_EQ, - anon_sym_AMP_EQ, - anon_sym_PIPE_EQ, - anon_sym_CARET_EQ, - [4060] = 22, - ACTIONS(3), 1, - sym_comment, - ACTIONS(23), 1, - anon_sym_ATnoreturn, - ACTIONS(382), 1, - anon_sym_const, - ACTIONS(384), 1, - anon_sym_LPAREN, - ACTIONS(386), 1, - anon_sym_fn, - ACTIONS(394), 1, - anon_sym_enum, - ACTIONS(398), 1, + ACTIONS(445), 1, anon_sym_nullable, - ACTIONS(400), 1, + ACTIONS(447), 1, anon_sym_struct, - ACTIONS(402), 1, + ACTIONS(449), 1, anon_sym_union, - ACTIONS(404), 1, + ACTIONS(451), 1, anon_sym_LBRACK, - ACTIONS(406), 1, + ACTIONS(453), 1, anon_sym_DOT_DOT_DOT, - ACTIONS(425), 1, - anon_sym_STAR, - ACTIONS(427), 1, + ACTIONS(455), 1, sym_name, - STATE(428), 1, + STATE(326), 1, sym_identifier, - STATE(557), 1, + STATE(352), 1, sym_type, - STATE(649), 1, + STATE(737), 1, sym_fntype_attr, - ACTIONS(392), 2, + ACTIONS(439), 2, anon_sym_f32, anon_sym_f64, - STATE(426), 2, + STATE(330), 2, sym__inner_type, sym_storage_class, - ACTIONS(388), 3, + ACTIONS(435), 4, anon_sym_rune, + anon_sym_str, anon_sym_bool, anon_sym_void, - STATE(424), 4, + STATE(327), 4, sym_integer_type, sym_floating_type, sym_enum_type, sym_pointer_type, - STATE(427), 9, + STATE(342), 9, sym_scalar_type, sym_struct_type, sym_union_type, @@ -23667,7 +23530,7 @@ static uint16_t ts_small_parse_table[] = { sym_function_type, sym_alias_type, sym_unwrapped_alias, - ACTIONS(390), 13, + ACTIONS(437), 13, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -23681,47 +23544,48 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [4154] = 22, + [3958] = 22, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, anon_sym_ATnoreturn, - ACTIONS(382), 1, + ACTIONS(371), 1, anon_sym_const, - ACTIONS(384), 1, + ACTIONS(373), 1, anon_sym_LPAREN, - ACTIONS(386), 1, + ACTIONS(375), 1, anon_sym_fn, - ACTIONS(394), 1, + ACTIONS(383), 1, anon_sym_enum, - ACTIONS(398), 1, + ACTIONS(387), 1, anon_sym_nullable, - ACTIONS(400), 1, + ACTIONS(389), 1, anon_sym_struct, - ACTIONS(402), 1, + ACTIONS(391), 1, anon_sym_union, - ACTIONS(404), 1, + ACTIONS(393), 1, anon_sym_LBRACK, - ACTIONS(406), 1, + ACTIONS(395), 1, anon_sym_DOT_DOT_DOT, - ACTIONS(425), 1, + ACTIONS(412), 1, anon_sym_STAR, - ACTIONS(427), 1, + ACTIONS(414), 1, sym_name, - ACTIONS(477), 1, - anon_sym_EQ_GT, STATE(428), 1, sym_identifier, + STATE(520), 1, + sym_type, STATE(649), 1, sym_fntype_attr, - ACTIONS(392), 2, + ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, - STATE(435), 2, + STATE(426), 2, sym__inner_type, sym_storage_class, - ACTIONS(388), 3, + ACTIONS(377), 4, anon_sym_rune, + anon_sym_str, anon_sym_bool, anon_sym_void, STATE(424), 4, @@ -23739,7 +23603,7 @@ static uint16_t ts_small_parse_table[] = { sym_function_type, sym_alias_type, sym_unwrapped_alias, - ACTIONS(390), 13, + ACTIONS(379), 13, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -23753,55 +23617,56 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [4248] = 22, + [4053] = 22, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, anon_sym_ATnoreturn, - ACTIONS(382), 1, + ACTIONS(429), 1, anon_sym_const, - ACTIONS(384), 1, + ACTIONS(431), 1, anon_sym_LPAREN, - ACTIONS(386), 1, + ACTIONS(433), 1, anon_sym_fn, - ACTIONS(394), 1, + ACTIONS(441), 1, anon_sym_enum, - ACTIONS(398), 1, + ACTIONS(443), 1, + anon_sym_STAR, + ACTIONS(445), 1, anon_sym_nullable, - ACTIONS(400), 1, + ACTIONS(447), 1, anon_sym_struct, - ACTIONS(402), 1, + ACTIONS(449), 1, anon_sym_union, - ACTIONS(404), 1, + ACTIONS(451), 1, anon_sym_LBRACK, - ACTIONS(406), 1, + ACTIONS(453), 1, anon_sym_DOT_DOT_DOT, - ACTIONS(425), 1, - anon_sym_STAR, - ACTIONS(427), 1, + ACTIONS(455), 1, sym_name, - STATE(428), 1, + STATE(326), 1, sym_identifier, - STATE(649), 1, - sym_fntype_attr, - STATE(751), 1, + STATE(351), 1, sym_type, - ACTIONS(392), 2, + STATE(737), 1, + sym_fntype_attr, + ACTIONS(439), 2, anon_sym_f32, anon_sym_f64, - STATE(426), 2, + STATE(330), 2, sym__inner_type, sym_storage_class, - ACTIONS(388), 3, + ACTIONS(435), 4, anon_sym_rune, + anon_sym_str, anon_sym_bool, anon_sym_void, - STATE(424), 4, + STATE(327), 4, sym_integer_type, sym_floating_type, sym_enum_type, sym_pointer_type, - STATE(427), 9, + STATE(342), 9, sym_scalar_type, sym_struct_type, sym_union_type, @@ -23811,7 +23676,7 @@ static uint16_t ts_small_parse_table[] = { sym_function_type, sym_alias_type, sym_unwrapped_alias, - ACTIONS(390), 13, + ACTIONS(437), 13, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -23825,47 +23690,104 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [4342] = 22, + [4148] = 5, + ACTIONS(3), 1, + sym_comment, + STATE(236), 1, + sym_floating_suffix, + ACTIONS(323), 2, + anon_sym_f32, + anon_sym_f64, + ACTIONS(459), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(457), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [4209] = 22, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, anon_sym_ATnoreturn, - ACTIONS(382), 1, + ACTIONS(371), 1, anon_sym_const, - ACTIONS(384), 1, + ACTIONS(373), 1, anon_sym_LPAREN, - ACTIONS(386), 1, + ACTIONS(375), 1, anon_sym_fn, - ACTIONS(394), 1, + ACTIONS(383), 1, anon_sym_enum, - ACTIONS(398), 1, + ACTIONS(387), 1, anon_sym_nullable, - ACTIONS(400), 1, + ACTIONS(389), 1, anon_sym_struct, - ACTIONS(402), 1, + ACTIONS(391), 1, anon_sym_union, - ACTIONS(404), 1, + ACTIONS(393), 1, anon_sym_LBRACK, - ACTIONS(406), 1, + ACTIONS(395), 1, anon_sym_DOT_DOT_DOT, - ACTIONS(425), 1, + ACTIONS(412), 1, anon_sym_STAR, - ACTIONS(427), 1, + ACTIONS(414), 1, sym_name, STATE(428), 1, sym_identifier, - STATE(520), 1, - sym_type, STATE(649), 1, sym_fntype_attr, - ACTIONS(392), 2, + STATE(702), 1, + sym_type, + ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, STATE(426), 2, sym__inner_type, sym_storage_class, - ACTIONS(388), 3, + ACTIONS(377), 4, anon_sym_rune, + anon_sym_str, anon_sym_bool, anon_sym_void, STATE(424), 4, @@ -23883,7 +23805,7 @@ static uint16_t ts_small_parse_table[] = { sym_function_type, sym_alias_type, sym_unwrapped_alias, - ACTIONS(390), 13, + ACTIONS(379), 13, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -23897,47 +23819,48 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [4436] = 22, + [4304] = 22, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, anon_sym_ATnoreturn, - ACTIONS(382), 1, + ACTIONS(371), 1, anon_sym_const, - ACTIONS(384), 1, + ACTIONS(373), 1, anon_sym_LPAREN, - ACTIONS(386), 1, + ACTIONS(375), 1, anon_sym_fn, - ACTIONS(394), 1, + ACTIONS(383), 1, anon_sym_enum, - ACTIONS(398), 1, + ACTIONS(387), 1, anon_sym_nullable, - ACTIONS(400), 1, + ACTIONS(389), 1, anon_sym_struct, - ACTIONS(402), 1, + ACTIONS(391), 1, anon_sym_union, - ACTIONS(404), 1, + ACTIONS(393), 1, anon_sym_LBRACK, - ACTIONS(406), 1, + ACTIONS(395), 1, anon_sym_DOT_DOT_DOT, - ACTIONS(425), 1, + ACTIONS(412), 1, anon_sym_STAR, - ACTIONS(427), 1, + ACTIONS(414), 1, sym_name, + ACTIONS(461), 1, + anon_sym_EQ_GT, STATE(428), 1, sym_identifier, STATE(649), 1, sym_fntype_attr, - STATE(698), 1, - sym_type, - ACTIONS(392), 2, + ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, - STATE(426), 2, + STATE(435), 2, sym__inner_type, sym_storage_class, - ACTIONS(388), 3, + ACTIONS(377), 4, anon_sym_rune, + anon_sym_str, anon_sym_bool, anon_sym_void, STATE(424), 4, @@ -23955,7 +23878,7 @@ static uint16_t ts_small_parse_table[] = { sym_function_type, sym_alias_type, sym_unwrapped_alias, - ACTIONS(390), 13, + ACTIONS(379), 13, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -23969,47 +23892,48 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [4530] = 22, + [4399] = 22, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, anon_sym_ATnoreturn, - ACTIONS(382), 1, + ACTIONS(371), 1, anon_sym_const, - ACTIONS(384), 1, + ACTIONS(373), 1, anon_sym_LPAREN, - ACTIONS(386), 1, + ACTIONS(375), 1, anon_sym_fn, - ACTIONS(394), 1, + ACTIONS(383), 1, anon_sym_enum, - ACTIONS(398), 1, + ACTIONS(387), 1, anon_sym_nullable, - ACTIONS(400), 1, + ACTIONS(389), 1, anon_sym_struct, - ACTIONS(402), 1, + ACTIONS(391), 1, anon_sym_union, - ACTIONS(404), 1, + ACTIONS(393), 1, anon_sym_LBRACK, - ACTIONS(406), 1, + ACTIONS(395), 1, anon_sym_DOT_DOT_DOT, - ACTIONS(425), 1, + ACTIONS(412), 1, anon_sym_STAR, - ACTIONS(427), 1, + ACTIONS(414), 1, sym_name, STATE(428), 1, sym_identifier, + STATE(616), 1, + sym_type, STATE(649), 1, sym_fntype_attr, - STATE(653), 1, - sym_type, - ACTIONS(392), 2, + ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, STATE(426), 2, sym__inner_type, sym_storage_class, - ACTIONS(388), 3, + ACTIONS(377), 4, anon_sym_rune, + anon_sym_str, anon_sym_bool, anon_sym_void, STATE(424), 4, @@ -24027,7 +23951,7 @@ static uint16_t ts_small_parse_table[] = { sym_function_type, sym_alias_type, sym_unwrapped_alias, - ACTIONS(390), 13, + ACTIONS(379), 13, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -24041,157 +23965,48 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [4624] = 7, - ACTIONS(3), 1, - sym_comment, - ACTIONS(467), 1, - anon_sym_EQ, - ACTIONS(469), 1, - anon_sym_COLON_COLON, - ACTIONS(471), 1, - anon_sym_LBRACE, - ACTIONS(465), 10, - anon_sym_PLUS_EQ, - anon_sym_DASH_EQ, - anon_sym_STAR_EQ, - anon_sym_SLASH_EQ, - anon_sym_PERCENT_EQ, - anon_sym_LT_LT_EQ, - anon_sym_GT_GT_EQ, - anon_sym_AMP_EQ, - anon_sym_PIPE_EQ, - anon_sym_CARET_EQ, - ACTIONS(475), 15, - anon_sym_COLON, - anon_sym_STAR, - anon_sym_PIPE, - anon_sym_DOT, - anon_sym_DOT_DOT, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_AMP, - anon_sym_SLASH, - anon_sym_PERCENT, - anon_sym_LT_LT, - anon_sym_GT_GT, - anon_sym_CARET, - anon_sym_LT, - anon_sym_GT, - ACTIONS(473), 20, - anon_sym_SEMI, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_LBRACK, - anon_sym_RBRACK, - anon_sym_DOT_DOT_DOT, - anon_sym_QMARK, - anon_sym_as, - anon_sym_is, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_CARET_CARET, - anon_sym_PIPE_PIPE, - anon_sym_else, - anon_sym_EQ_GT, - [4688] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(362), 10, - anon_sym_PIPE, - anon_sym_i, - anon_sym_u, - anon_sym_DOT, - anon_sym_DOT_DOT, - anon_sym_AMP, - anon_sym_SLASH, - anon_sym_CARET, - anon_sym_LT, - anon_sym_GT, - ACTIONS(360), 38, - anon_sym_SEMI, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_i8, - anon_sym_i16, - anon_sym_i32, - anon_sym_i64, - anon_sym_u8, - anon_sym_u16, - anon_sym_u32, - anon_sym_u64, - anon_sym_f32, - anon_sym_f64, - anon_sym_STAR, - anon_sym_LBRACK, - anon_sym_RBRACK, - anon_sym_DOT_DOT_DOT, - anon_sym_z, - anon_sym_QMARK, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_as, - anon_sym_is, - anon_sym_PERCENT, - anon_sym_LT_LT, - anon_sym_GT_GT, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_CARET_CARET, - anon_sym_PIPE_PIPE, - anon_sym_else, - anon_sym_EQ_GT, - [4744] = 22, + [4494] = 22, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, anon_sym_ATnoreturn, - ACTIONS(382), 1, + ACTIONS(371), 1, anon_sym_const, - ACTIONS(384), 1, + ACTIONS(373), 1, anon_sym_LPAREN, - ACTIONS(386), 1, + ACTIONS(375), 1, anon_sym_fn, - ACTIONS(394), 1, + ACTIONS(383), 1, anon_sym_enum, - ACTIONS(398), 1, + ACTIONS(387), 1, anon_sym_nullable, - ACTIONS(400), 1, + ACTIONS(389), 1, anon_sym_struct, - ACTIONS(402), 1, + ACTIONS(391), 1, anon_sym_union, - ACTIONS(404), 1, + ACTIONS(393), 1, anon_sym_LBRACK, - ACTIONS(406), 1, + ACTIONS(395), 1, anon_sym_DOT_DOT_DOT, - ACTIONS(425), 1, + ACTIONS(412), 1, anon_sym_STAR, - ACTIONS(427), 1, + ACTIONS(414), 1, sym_name, STATE(428), 1, sym_identifier, - STATE(616), 1, - sym_type, STATE(649), 1, sym_fntype_attr, - ACTIONS(392), 2, + STATE(653), 1, + sym_type, + ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, STATE(426), 2, sym__inner_type, sym_storage_class, - ACTIONS(388), 3, + ACTIONS(377), 4, anon_sym_rune, + anon_sym_str, anon_sym_bool, anon_sym_void, STATE(424), 4, @@ -24209,7 +24024,7 @@ static uint16_t ts_small_parse_table[] = { sym_function_type, sym_alias_type, sym_unwrapped_alias, - ACTIONS(390), 13, + ACTIONS(379), 13, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -24223,102 +24038,48 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [4838] = 5, - ACTIONS(3), 1, - sym_comment, - ACTIONS(268), 1, - anon_sym_DQUOTE, - STATE(204), 1, - aux_sym_string_constant_repeat1, - ACTIONS(481), 15, - anon_sym_EQ, - anon_sym_STAR, - anon_sym_PIPE, - anon_sym_DOT, - anon_sym_DOT_DOT, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_AMP, - anon_sym_SLASH, - anon_sym_PERCENT, - anon_sym_LT_LT, - anon_sym_GT_GT, - anon_sym_CARET, - anon_sym_LT, - anon_sym_GT, - ACTIONS(479), 31, - anon_sym_SEMI, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_LBRACK, - anon_sym_RBRACK, - anon_sym_DOT_DOT_DOT, - anon_sym_QMARK, - anon_sym_as, - anon_sym_is, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_CARET_CARET, - anon_sym_PIPE_PIPE, - anon_sym_else, - anon_sym_EQ_GT, - anon_sym_PLUS_EQ, - anon_sym_DASH_EQ, - anon_sym_STAR_EQ, - anon_sym_SLASH_EQ, - anon_sym_PERCENT_EQ, - anon_sym_LT_LT_EQ, - anon_sym_GT_GT_EQ, - anon_sym_AMP_EQ, - anon_sym_PIPE_EQ, - anon_sym_CARET_EQ, - [4898] = 22, + [4589] = 22, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, anon_sym_ATnoreturn, - ACTIONS(382), 1, + ACTIONS(371), 1, anon_sym_const, - ACTIONS(384), 1, + ACTIONS(373), 1, anon_sym_LPAREN, - ACTIONS(386), 1, + ACTIONS(375), 1, anon_sym_fn, - ACTIONS(394), 1, + ACTIONS(383), 1, anon_sym_enum, - ACTIONS(398), 1, + ACTIONS(387), 1, anon_sym_nullable, - ACTIONS(400), 1, + ACTIONS(389), 1, anon_sym_struct, - ACTIONS(402), 1, + ACTIONS(391), 1, anon_sym_union, - ACTIONS(404), 1, + ACTIONS(393), 1, anon_sym_LBRACK, - ACTIONS(406), 1, + ACTIONS(395), 1, anon_sym_DOT_DOT_DOT, - ACTIONS(425), 1, + ACTIONS(412), 1, anon_sym_STAR, - ACTIONS(427), 1, + ACTIONS(414), 1, sym_name, STATE(428), 1, sym_identifier, - STATE(529), 1, - sym_type, STATE(649), 1, sym_fntype_attr, - ACTIONS(392), 2, + STATE(681), 1, + sym_type, + ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, STATE(426), 2, sym__inner_type, sym_storage_class, - ACTIONS(388), 3, + ACTIONS(377), 4, anon_sym_rune, + anon_sym_str, anon_sym_bool, anon_sym_void, STATE(424), 4, @@ -24336,7 +24097,7 @@ static uint16_t ts_small_parse_table[] = { sym_function_type, sym_alias_type, sym_unwrapped_alias, - ACTIONS(390), 13, + ACTIONS(379), 13, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -24350,101 +24111,48 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [4992] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(487), 1, - anon_sym_COLON_COLON, - ACTIONS(485), 16, - anon_sym_EQ, - anon_sym_COLON, - anon_sym_STAR, - anon_sym_PIPE, - anon_sym_DOT, - anon_sym_DOT_DOT, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_AMP, - anon_sym_SLASH, - anon_sym_PERCENT, - anon_sym_LT_LT, - anon_sym_GT_GT, - anon_sym_CARET, - anon_sym_LT, - anon_sym_GT, - ACTIONS(483), 31, - anon_sym_SEMI, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_LBRACK, - anon_sym_RBRACK, - anon_sym_DOT_DOT_DOT, - anon_sym_QMARK, - anon_sym_as, - anon_sym_is, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_CARET_CARET, - anon_sym_PIPE_PIPE, - anon_sym_else, - anon_sym_EQ_GT, - anon_sym_PLUS_EQ, - anon_sym_DASH_EQ, - anon_sym_STAR_EQ, - anon_sym_SLASH_EQ, - anon_sym_PERCENT_EQ, - anon_sym_LT_LT_EQ, - anon_sym_GT_GT_EQ, - anon_sym_AMP_EQ, - anon_sym_PIPE_EQ, - anon_sym_CARET_EQ, - [5050] = 22, + [4684] = 22, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, anon_sym_ATnoreturn, - ACTIONS(382), 1, + ACTIONS(371), 1, anon_sym_const, - ACTIONS(384), 1, + ACTIONS(373), 1, anon_sym_LPAREN, - ACTIONS(386), 1, + ACTIONS(375), 1, anon_sym_fn, - ACTIONS(394), 1, + ACTIONS(383), 1, anon_sym_enum, - ACTIONS(398), 1, + ACTIONS(387), 1, anon_sym_nullable, - ACTIONS(400), 1, + ACTIONS(389), 1, anon_sym_struct, - ACTIONS(402), 1, + ACTIONS(391), 1, anon_sym_union, - ACTIONS(404), 1, + ACTIONS(393), 1, anon_sym_LBRACK, - ACTIONS(406), 1, + ACTIONS(395), 1, anon_sym_DOT_DOT_DOT, - ACTIONS(425), 1, + ACTIONS(412), 1, anon_sym_STAR, - ACTIONS(427), 1, + ACTIONS(414), 1, sym_name, STATE(428), 1, sym_identifier, - STATE(549), 1, - sym_type, STATE(649), 1, sym_fntype_attr, - ACTIONS(392), 2, + STATE(760), 1, + sym_type, + ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, STATE(426), 2, sym__inner_type, sym_storage_class, - ACTIONS(388), 3, + ACTIONS(377), 4, anon_sym_rune, + anon_sym_str, anon_sym_bool, anon_sym_void, STATE(424), 4, @@ -24462,7 +24170,7 @@ static uint16_t ts_small_parse_table[] = { sym_function_type, sym_alias_type, sym_unwrapped_alias, - ACTIONS(390), 13, + ACTIONS(379), 13, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -24476,42 +24184,56 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [5144] = 5, + [4779] = 8, ACTIONS(3), 1, sym_comment, - ACTIONS(490), 1, - anon_sym_COLON_COLON, - ACTIONS(492), 1, - anon_sym_LBRACE, - ACTIONS(475), 16, - anon_sym_EQ, - anon_sym_COLON, - anon_sym_STAR, + ACTIONS(403), 1, + anon_sym_e, + STATE(217), 1, + sym_exponent, + STATE(298), 1, + sym_integer_suffix, + ACTIONS(405), 2, + anon_sym_i, + anon_sym_u, + ACTIONS(319), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, - anon_sym_PLUS, - anon_sym_DASH, anon_sym_AMP, anon_sym_SLASH, - anon_sym_PERCENT, - anon_sym_LT_LT, - anon_sym_GT_GT, anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(473), 30, + ACTIONS(399), 9, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_z, + ACTIONS(317), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, + anon_sym_COLON, anon_sym_LPAREN, anon_sym_RPAREN, + anon_sym_STAR, anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, anon_sym_as, anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, anon_sym_LT_EQ, anon_sym_GT_EQ, anon_sym_EQ_EQ, @@ -24521,57 +24243,48 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - anon_sym_PLUS_EQ, - anon_sym_DASH_EQ, - anon_sym_STAR_EQ, - anon_sym_SLASH_EQ, - anon_sym_PERCENT_EQ, - anon_sym_LT_LT_EQ, - anon_sym_GT_GT_EQ, - anon_sym_AMP_EQ, - anon_sym_PIPE_EQ, - anon_sym_CARET_EQ, - [5204] = 22, + [4846] = 22, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, anon_sym_ATnoreturn, - ACTIONS(382), 1, + ACTIONS(371), 1, anon_sym_const, - ACTIONS(384), 1, + ACTIONS(373), 1, anon_sym_LPAREN, - ACTIONS(386), 1, + ACTIONS(375), 1, anon_sym_fn, - ACTIONS(394), 1, + ACTIONS(383), 1, anon_sym_enum, - ACTIONS(398), 1, + ACTIONS(387), 1, anon_sym_nullable, - ACTIONS(400), 1, + ACTIONS(389), 1, anon_sym_struct, - ACTIONS(402), 1, + ACTIONS(391), 1, anon_sym_union, - ACTIONS(404), 1, + ACTIONS(393), 1, anon_sym_LBRACK, - ACTIONS(406), 1, + ACTIONS(395), 1, anon_sym_DOT_DOT_DOT, - ACTIONS(425), 1, + ACTIONS(412), 1, anon_sym_STAR, - ACTIONS(427), 1, + ACTIONS(414), 1, sym_name, STATE(428), 1, sym_identifier, - STATE(550), 1, + STATE(549), 1, sym_type, STATE(649), 1, sym_fntype_attr, - ACTIONS(392), 2, + ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, STATE(426), 2, sym__inner_type, sym_storage_class, - ACTIONS(388), 3, + ACTIONS(377), 4, anon_sym_rune, + anon_sym_str, anon_sym_bool, anon_sym_void, STATE(424), 4, @@ -24589,7 +24302,7 @@ static uint16_t ts_small_parse_table[] = { sym_function_type, sym_alias_type, sym_unwrapped_alias, - ACTIONS(390), 13, + ACTIONS(379), 13, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -24603,47 +24316,48 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [5298] = 22, + [4941] = 22, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, anon_sym_ATnoreturn, - ACTIONS(382), 1, + ACTIONS(371), 1, anon_sym_const, - ACTIONS(384), 1, + ACTIONS(373), 1, anon_sym_LPAREN, - ACTIONS(386), 1, + ACTIONS(375), 1, anon_sym_fn, - ACTIONS(394), 1, + ACTIONS(383), 1, anon_sym_enum, - ACTIONS(398), 1, + ACTIONS(387), 1, anon_sym_nullable, - ACTIONS(400), 1, + ACTIONS(389), 1, anon_sym_struct, - ACTIONS(402), 1, + ACTIONS(391), 1, anon_sym_union, - ACTIONS(404), 1, + ACTIONS(393), 1, anon_sym_LBRACK, - ACTIONS(406), 1, + ACTIONS(395), 1, anon_sym_DOT_DOT_DOT, - ACTIONS(425), 1, + ACTIONS(412), 1, anon_sym_STAR, - ACTIONS(427), 1, + ACTIONS(414), 1, sym_name, STATE(428), 1, sym_identifier, + STATE(550), 1, + sym_type, STATE(649), 1, sym_fntype_attr, - STATE(760), 1, - sym_type, - ACTIONS(392), 2, + ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, STATE(426), 2, sym__inner_type, sym_storage_class, - ACTIONS(388), 3, + ACTIONS(377), 4, anon_sym_rune, + anon_sym_str, anon_sym_bool, anon_sym_void, STATE(424), 4, @@ -24661,7 +24375,7 @@ static uint16_t ts_small_parse_table[] = { sym_function_type, sym_alias_type, sym_unwrapped_alias, - ACTIONS(390), 13, + ACTIONS(379), 13, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -24675,32 +24389,32 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [5392] = 22, + [5036] = 22, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, anon_sym_ATnoreturn, - ACTIONS(382), 1, + ACTIONS(371), 1, anon_sym_const, - ACTIONS(384), 1, + ACTIONS(373), 1, anon_sym_LPAREN, - ACTIONS(386), 1, + ACTIONS(375), 1, anon_sym_fn, - ACTIONS(394), 1, + ACTIONS(383), 1, anon_sym_enum, - ACTIONS(398), 1, + ACTIONS(387), 1, anon_sym_nullable, - ACTIONS(400), 1, + ACTIONS(389), 1, anon_sym_struct, - ACTIONS(402), 1, + ACTIONS(391), 1, anon_sym_union, - ACTIONS(404), 1, + ACTIONS(393), 1, anon_sym_LBRACK, - ACTIONS(406), 1, + ACTIONS(395), 1, anon_sym_DOT_DOT_DOT, - ACTIONS(425), 1, + ACTIONS(412), 1, anon_sym_STAR, - ACTIONS(427), 1, + ACTIONS(414), 1, sym_name, STATE(428), 1, sym_identifier, @@ -24708,14 +24422,15 @@ static uint16_t ts_small_parse_table[] = { sym_type, STATE(649), 1, sym_fntype_attr, - ACTIONS(392), 2, + ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, STATE(426), 2, sym__inner_type, sym_storage_class, - ACTIONS(388), 3, + ACTIONS(377), 4, anon_sym_rune, + anon_sym_str, anon_sym_bool, anon_sym_void, STATE(424), 4, @@ -24733,7 +24448,7 @@ static uint16_t ts_small_parse_table[] = { sym_function_type, sym_alias_type, sym_unwrapped_alias, - ACTIONS(390), 13, + ACTIONS(379), 13, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -24747,47 +24462,46 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [5486] = 22, + [5131] = 21, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, anon_sym_ATnoreturn, - ACTIONS(382), 1, + ACTIONS(371), 1, anon_sym_const, - ACTIONS(384), 1, + ACTIONS(373), 1, anon_sym_LPAREN, - ACTIONS(386), 1, + ACTIONS(375), 1, anon_sym_fn, - ACTIONS(394), 1, + ACTIONS(383), 1, anon_sym_enum, - ACTIONS(398), 1, + ACTIONS(387), 1, anon_sym_nullable, - ACTIONS(400), 1, + ACTIONS(389), 1, anon_sym_struct, - ACTIONS(402), 1, + ACTIONS(391), 1, anon_sym_union, - ACTIONS(404), 1, + ACTIONS(393), 1, anon_sym_LBRACK, - ACTIONS(406), 1, + ACTIONS(395), 1, anon_sym_DOT_DOT_DOT, - ACTIONS(425), 1, + ACTIONS(412), 1, anon_sym_STAR, - ACTIONS(427), 1, + ACTIONS(414), 1, sym_name, STATE(428), 1, sym_identifier, STATE(649), 1, sym_fntype_attr, - STATE(681), 1, - sym_type, - ACTIONS(392), 2, + ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, - STATE(426), 2, + STATE(452), 2, sym__inner_type, sym_storage_class, - ACTIONS(388), 3, + ACTIONS(377), 4, anon_sym_rune, + anon_sym_str, anon_sym_bool, anon_sym_void, STATE(424), 4, @@ -24805,7 +24519,7 @@ static uint16_t ts_small_parse_table[] = { sym_function_type, sym_alias_type, sym_unwrapped_alias, - ACTIONS(390), 13, + ACTIONS(379), 13, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -24819,14 +24533,67 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [5580] = 5, + [5223] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(498), 1, + ACTIONS(465), 16, + anon_sym_EQ, + anon_sym_COLON, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(463), 32, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [5279] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(268), 1, anon_sym_DQUOTE, - STATE(204), 1, + STATE(199), 1, aux_sym_string_constant_repeat1, - ACTIONS(496), 15, + ACTIONS(469), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -24842,19 +24609,137 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(494), 31, + ACTIONS(467), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [5339] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(475), 1, + anon_sym_DQUOTE, + STATE(199), 1, + aux_sym_string_constant_repeat1, + ACTIONS(473), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(471), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [5399] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(358), 10, + anon_sym_PIPE, + anon_sym_i, + anon_sym_u, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(356), 38, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, anon_sym_COLON, anon_sym_LPAREN, anon_sym_RPAREN, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_f32, + anon_sym_f64, + anon_sym_STAR, anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, + anon_sym_z, anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, anon_sym_as, anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, anon_sym_LT_EQ, anon_sym_GT_EQ, anon_sym_EQ_EQ, @@ -24864,6 +24749,16 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, + [5455] = 7, + ACTIONS(3), 1, + sym_comment, + ACTIONS(480), 1, + anon_sym_EQ, + ACTIONS(482), 1, + anon_sym_COLON_COLON, + ACTIONS(484), 1, + anon_sym_LBRACE, + ACTIONS(488), 10, anon_sym_PLUS_EQ, anon_sym_DASH_EQ, anon_sym_STAR_EQ, @@ -24874,53 +24769,91 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [5640] = 21, + ACTIONS(486), 15, + anon_sym_COLON, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(478), 20, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [5519] = 21, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, anon_sym_ATnoreturn, - ACTIONS(382), 1, + ACTIONS(429), 1, anon_sym_const, - ACTIONS(384), 1, + ACTIONS(431), 1, anon_sym_LPAREN, - ACTIONS(386), 1, + ACTIONS(433), 1, anon_sym_fn, - ACTIONS(394), 1, + ACTIONS(441), 1, anon_sym_enum, - ACTIONS(398), 1, + ACTIONS(443), 1, + anon_sym_STAR, + ACTIONS(445), 1, anon_sym_nullable, - ACTIONS(400), 1, + ACTIONS(447), 1, anon_sym_struct, - ACTIONS(402), 1, + ACTIONS(449), 1, anon_sym_union, - ACTIONS(404), 1, + ACTIONS(451), 1, anon_sym_LBRACK, - ACTIONS(406), 1, + ACTIONS(453), 1, anon_sym_DOT_DOT_DOT, - ACTIONS(425), 1, - anon_sym_STAR, - ACTIONS(427), 1, + ACTIONS(455), 1, sym_name, - STATE(428), 1, + STATE(326), 1, sym_identifier, - STATE(649), 1, + STATE(737), 1, sym_fntype_attr, - ACTIONS(392), 2, + ACTIONS(439), 2, anon_sym_f32, anon_sym_f64, - STATE(452), 2, + STATE(331), 2, sym__inner_type, sym_storage_class, - ACTIONS(388), 3, + ACTIONS(435), 4, anon_sym_rune, + anon_sym_str, anon_sym_bool, anon_sym_void, - STATE(424), 4, + STATE(327), 4, sym_integer_type, sym_floating_type, sym_enum_type, sym_pointer_type, - STATE(427), 9, + STATE(342), 9, sym_scalar_type, sym_struct_type, sym_union_type, @@ -24930,7 +24863,7 @@ static uint16_t ts_small_parse_table[] = { sym_function_type, sym_alias_type, sym_unwrapped_alias, - ACTIONS(390), 13, + ACTIONS(437), 13, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -24944,45 +24877,46 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [5731] = 21, + [5611] = 21, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, anon_sym_ATnoreturn, - ACTIONS(437), 1, + ACTIONS(429), 1, anon_sym_const, - ACTIONS(439), 1, + ACTIONS(431), 1, anon_sym_LPAREN, - ACTIONS(441), 1, + ACTIONS(433), 1, anon_sym_fn, - ACTIONS(449), 1, + ACTIONS(441), 1, anon_sym_enum, - ACTIONS(451), 1, + ACTIONS(443), 1, anon_sym_STAR, - ACTIONS(453), 1, + ACTIONS(445), 1, anon_sym_nullable, - ACTIONS(455), 1, + ACTIONS(447), 1, anon_sym_struct, - ACTIONS(457), 1, + ACTIONS(449), 1, anon_sym_union, - ACTIONS(459), 1, + ACTIONS(451), 1, anon_sym_LBRACK, - ACTIONS(461), 1, + ACTIONS(453), 1, anon_sym_DOT_DOT_DOT, - ACTIONS(463), 1, + ACTIONS(455), 1, sym_name, STATE(326), 1, sym_identifier, STATE(737), 1, sym_fntype_attr, - ACTIONS(447), 2, + ACTIONS(439), 2, anon_sym_f32, anon_sym_f64, STATE(334), 2, sym__inner_type, sym_storage_class, - ACTIONS(443), 3, + ACTIONS(435), 4, anon_sym_rune, + anon_sym_str, anon_sym_bool, anon_sym_void, STATE(327), 4, @@ -25000,7 +24934,7 @@ static uint16_t ts_small_parse_table[] = { sym_function_type, sym_alias_type, sym_unwrapped_alias, - ACTIONS(445), 13, + ACTIONS(437), 13, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -25014,45 +24948,155 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [5822] = 21, + [5703] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(490), 1, + anon_sym_COLON_COLON, + ACTIONS(492), 1, + anon_sym_LBRACE, + ACTIONS(486), 16, + anon_sym_EQ, + anon_sym_COLON, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(478), 30, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [5763] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(498), 1, + anon_sym_COLON_COLON, + ACTIONS(496), 16, + anon_sym_EQ, + anon_sym_COLON, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(494), 31, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [5821] = 21, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, anon_sym_ATnoreturn, - ACTIONS(437), 1, + ACTIONS(429), 1, anon_sym_const, - ACTIONS(439), 1, + ACTIONS(431), 1, anon_sym_LPAREN, - ACTIONS(441), 1, + ACTIONS(433), 1, anon_sym_fn, - ACTIONS(449), 1, + ACTIONS(441), 1, anon_sym_enum, - ACTIONS(451), 1, + ACTIONS(443), 1, anon_sym_STAR, - ACTIONS(453), 1, + ACTIONS(445), 1, anon_sym_nullable, - ACTIONS(455), 1, + ACTIONS(447), 1, anon_sym_struct, - ACTIONS(457), 1, + ACTIONS(449), 1, anon_sym_union, - ACTIONS(459), 1, + ACTIONS(451), 1, anon_sym_LBRACK, - ACTIONS(461), 1, + ACTIONS(453), 1, anon_sym_DOT_DOT_DOT, - ACTIONS(463), 1, + ACTIONS(455), 1, sym_name, STATE(326), 1, sym_identifier, STATE(737), 1, sym_fntype_attr, - ACTIONS(447), 2, + ACTIONS(439), 2, anon_sym_f32, anon_sym_f64, STATE(337), 2, sym__inner_type, sym_storage_class, - ACTIONS(443), 3, + ACTIONS(435), 4, anon_sym_rune, + anon_sym_str, anon_sym_bool, anon_sym_void, STATE(327), 4, @@ -25070,7 +25114,7 @@ static uint16_t ts_small_parse_table[] = { sym_function_type, sym_alias_type, sym_unwrapped_alias, - ACTIONS(445), 13, + ACTIONS(437), 13, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -25089,48 +25133,49 @@ static uint16_t ts_small_parse_table[] = { sym_comment, ACTIONS(23), 1, anon_sym_ATnoreturn, - ACTIONS(437), 1, + ACTIONS(371), 1, anon_sym_const, - ACTIONS(439), 1, + ACTIONS(373), 1, anon_sym_LPAREN, - ACTIONS(441), 1, + ACTIONS(375), 1, anon_sym_fn, - ACTIONS(449), 1, + ACTIONS(383), 1, anon_sym_enum, - ACTIONS(451), 1, - anon_sym_STAR, - ACTIONS(453), 1, + ACTIONS(387), 1, anon_sym_nullable, - ACTIONS(455), 1, + ACTIONS(389), 1, anon_sym_struct, - ACTIONS(457), 1, + ACTIONS(391), 1, anon_sym_union, - ACTIONS(459), 1, + ACTIONS(393), 1, anon_sym_LBRACK, - ACTIONS(461), 1, + ACTIONS(395), 1, anon_sym_DOT_DOT_DOT, - ACTIONS(463), 1, + ACTIONS(412), 1, + anon_sym_STAR, + ACTIONS(414), 1, sym_name, - STATE(326), 1, + STATE(428), 1, sym_identifier, - STATE(737), 1, + STATE(649), 1, sym_fntype_attr, - ACTIONS(447), 2, + ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, - STATE(331), 2, + STATE(447), 2, sym__inner_type, sym_storage_class, - ACTIONS(443), 3, + ACTIONS(377), 4, anon_sym_rune, + anon_sym_str, anon_sym_bool, anon_sym_void, - STATE(327), 4, + STATE(424), 4, sym_integer_type, sym_floating_type, sym_enum_type, sym_pointer_type, - STATE(342), 9, + STATE(427), 9, sym_scalar_type, sym_struct_type, sym_union_type, @@ -25140,7 +25185,7 @@ static uint16_t ts_small_parse_table[] = { sym_function_type, sym_alias_type, sym_unwrapped_alias, - ACTIONS(445), 13, + ACTIONS(379), 13, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -25154,39 +25199,50 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [6004] = 3, + [6005] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(503), 15, - anon_sym_EQ, - anon_sym_STAR, + ACTIONS(362), 10, anon_sym_PIPE, + anon_sym_i, + anon_sym_u, anon_sym_DOT, anon_sym_DOT_DOT, - anon_sym_PLUS, - anon_sym_DASH, anon_sym_AMP, anon_sym_SLASH, - anon_sym_PERCENT, - anon_sym_LT_LT, - anon_sym_GT_GT, anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(501), 32, + ACTIONS(360), 38, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, anon_sym_COLON, anon_sym_LPAREN, anon_sym_RPAREN, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_STAR, anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, - anon_sym_DQUOTE, + anon_sym_0, + anon_sym_1, + anon_sym_z, anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, anon_sym_as, anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, anon_sym_LT_EQ, anon_sym_GT_EQ, anon_sym_EQ_EQ, @@ -25196,55 +25252,46 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - anon_sym_PLUS_EQ, - anon_sym_DASH_EQ, - anon_sym_STAR_EQ, - anon_sym_SLASH_EQ, - anon_sym_PERCENT_EQ, - anon_sym_LT_LT_EQ, - anon_sym_GT_GT_EQ, - anon_sym_AMP_EQ, - anon_sym_PIPE_EQ, - anon_sym_CARET_EQ, - [6059] = 21, + [6061] = 21, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, anon_sym_ATnoreturn, - ACTIONS(437), 1, + ACTIONS(429), 1, anon_sym_const, - ACTIONS(439), 1, + ACTIONS(431), 1, anon_sym_LPAREN, - ACTIONS(441), 1, + ACTIONS(433), 1, anon_sym_fn, - ACTIONS(449), 1, + ACTIONS(441), 1, anon_sym_enum, - ACTIONS(451), 1, + ACTIONS(443), 1, anon_sym_STAR, - ACTIONS(453), 1, + ACTIONS(445), 1, anon_sym_nullable, - ACTIONS(455), 1, + ACTIONS(447), 1, anon_sym_struct, - ACTIONS(457), 1, + ACTIONS(449), 1, anon_sym_union, - ACTIONS(459), 1, + ACTIONS(451), 1, anon_sym_LBRACK, - ACTIONS(461), 1, + ACTIONS(453), 1, anon_sym_DOT_DOT_DOT, - ACTIONS(463), 1, + ACTIONS(455), 1, sym_name, STATE(326), 1, sym_identifier, STATE(737), 1, sym_fntype_attr, - ACTIONS(447), 2, + ACTIONS(439), 2, anon_sym_f32, anon_sym_f64, STATE(329), 2, sym__inner_type, sym_storage_class, - ACTIONS(443), 3, + ACTIONS(435), 4, anon_sym_rune, + anon_sym_str, anon_sym_bool, anon_sym_void, STATE(327), 4, @@ -25262,7 +25309,7 @@ static uint16_t ts_small_parse_table[] = { sym_function_type, sym_alias_type, sym_unwrapped_alias, - ACTIONS(445), 13, + ACTIONS(437), 13, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -25276,45 +25323,46 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [6150] = 21, + [6153] = 21, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, anon_sym_ATnoreturn, - ACTIONS(437), 1, + ACTIONS(429), 1, anon_sym_const, - ACTIONS(439), 1, + ACTIONS(431), 1, anon_sym_LPAREN, - ACTIONS(441), 1, + ACTIONS(433), 1, anon_sym_fn, - ACTIONS(449), 1, + ACTIONS(441), 1, anon_sym_enum, - ACTIONS(451), 1, + ACTIONS(443), 1, anon_sym_STAR, - ACTIONS(453), 1, + ACTIONS(445), 1, anon_sym_nullable, - ACTIONS(455), 1, + ACTIONS(447), 1, anon_sym_struct, - ACTIONS(457), 1, + ACTIONS(449), 1, anon_sym_union, - ACTIONS(459), 1, + ACTIONS(451), 1, anon_sym_LBRACK, - ACTIONS(461), 1, + ACTIONS(453), 1, anon_sym_DOT_DOT_DOT, - ACTIONS(463), 1, + ACTIONS(455), 1, sym_name, STATE(326), 1, sym_identifier, STATE(737), 1, sym_fntype_attr, - ACTIONS(447), 2, + ACTIONS(439), 2, anon_sym_f32, anon_sym_f64, STATE(339), 2, sym__inner_type, sym_storage_class, - ACTIONS(443), 3, + ACTIONS(435), 4, anon_sym_rune, + anon_sym_str, anon_sym_bool, anon_sym_void, STATE(327), 4, @@ -25332,7 +25380,7 @@ static uint16_t ts_small_parse_table[] = { sym_function_type, sym_alias_type, sym_unwrapped_alias, - ACTIONS(445), 13, + ACTIONS(437), 13, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -25346,100 +25394,46 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [6241] = 6, - ACTIONS(3), 1, - sym_comment, - STATE(320), 1, - sym_integer_suffix, - ACTIONS(375), 2, - anon_sym_i, - anon_sym_u, - ACTIONS(354), 8, - anon_sym_PIPE, - anon_sym_DOT, - anon_sym_DOT_DOT, - anon_sym_AMP, - anon_sym_SLASH, - anon_sym_CARET, - anon_sym_LT, - anon_sym_GT, - ACTIONS(369), 9, - anon_sym_i8, - anon_sym_i16, - anon_sym_i32, - anon_sym_i64, - anon_sym_u8, - anon_sym_u16, - anon_sym_u32, - anon_sym_u64, - anon_sym_z, - ACTIONS(352), 27, - anon_sym_SEMI, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_STAR, - anon_sym_LBRACK, - anon_sym_RBRACK, - anon_sym_DOT_DOT_DOT, - anon_sym_QMARK, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_as, - anon_sym_is, - anon_sym_PERCENT, - anon_sym_LT_LT, - anon_sym_GT_GT, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_CARET_CARET, - anon_sym_PIPE_PIPE, - anon_sym_else, - anon_sym_EQ_GT, - [6302] = 21, + [6245] = 21, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, anon_sym_ATnoreturn, - ACTIONS(382), 1, + ACTIONS(371), 1, anon_sym_const, - ACTIONS(384), 1, + ACTIONS(373), 1, anon_sym_LPAREN, - ACTIONS(386), 1, + ACTIONS(375), 1, anon_sym_fn, - ACTIONS(394), 1, + ACTIONS(383), 1, anon_sym_enum, - ACTIONS(398), 1, + ACTIONS(387), 1, anon_sym_nullable, - ACTIONS(400), 1, + ACTIONS(389), 1, anon_sym_struct, - ACTIONS(402), 1, + ACTIONS(391), 1, anon_sym_union, - ACTIONS(404), 1, + ACTIONS(393), 1, anon_sym_LBRACK, - ACTIONS(406), 1, + ACTIONS(395), 1, anon_sym_DOT_DOT_DOT, - ACTIONS(425), 1, + ACTIONS(412), 1, anon_sym_STAR, - ACTIONS(427), 1, + ACTIONS(414), 1, sym_name, STATE(428), 1, sym_identifier, STATE(649), 1, sym_fntype_attr, - ACTIONS(392), 2, + ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, - STATE(447), 2, + STATE(418), 2, sym__inner_type, sym_storage_class, - ACTIONS(388), 3, + ACTIONS(377), 4, anon_sym_rune, + anon_sym_str, anon_sym_bool, anon_sym_void, STATE(424), 4, @@ -25457,7 +25451,7 @@ static uint16_t ts_small_parse_table[] = { sym_function_type, sym_alias_type, sym_unwrapped_alias, - ACTIONS(390), 13, + ACTIONS(379), 13, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -25471,53 +25465,54 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [6393] = 21, + [6337] = 21, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, anon_sym_ATnoreturn, - ACTIONS(382), 1, + ACTIONS(429), 1, anon_sym_const, - ACTIONS(384), 1, + ACTIONS(431), 1, anon_sym_LPAREN, - ACTIONS(386), 1, + ACTIONS(433), 1, anon_sym_fn, - ACTIONS(394), 1, + ACTIONS(441), 1, anon_sym_enum, - ACTIONS(398), 1, + ACTIONS(443), 1, + anon_sym_STAR, + ACTIONS(445), 1, anon_sym_nullable, - ACTIONS(400), 1, + ACTIONS(447), 1, anon_sym_struct, - ACTIONS(402), 1, + ACTIONS(449), 1, anon_sym_union, - ACTIONS(404), 1, + ACTIONS(451), 1, anon_sym_LBRACK, - ACTIONS(406), 1, + ACTIONS(453), 1, anon_sym_DOT_DOT_DOT, - ACTIONS(425), 1, - anon_sym_STAR, - ACTIONS(427), 1, + ACTIONS(455), 1, sym_name, - STATE(428), 1, + STATE(326), 1, sym_identifier, - STATE(649), 1, + STATE(737), 1, sym_fntype_attr, - ACTIONS(392), 2, + ACTIONS(439), 2, anon_sym_f32, anon_sym_f64, - STATE(450), 2, + STATE(323), 2, sym__inner_type, sym_storage_class, - ACTIONS(388), 3, + ACTIONS(435), 4, anon_sym_rune, + anon_sym_str, anon_sym_bool, anon_sym_void, - STATE(424), 4, + STATE(327), 4, sym_integer_type, sym_floating_type, sym_enum_type, sym_pointer_type, - STATE(427), 9, + STATE(342), 9, sym_scalar_type, sym_struct_type, sym_union_type, @@ -25527,7 +25522,7 @@ static uint16_t ts_small_parse_table[] = { sym_function_type, sym_alias_type, sym_unwrapped_alias, - ACTIONS(390), 13, + ACTIONS(437), 13, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -25541,53 +25536,54 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [6484] = 21, + [6429] = 21, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, anon_sym_ATnoreturn, - ACTIONS(437), 1, + ACTIONS(371), 1, anon_sym_const, - ACTIONS(439), 1, + ACTIONS(373), 1, anon_sym_LPAREN, - ACTIONS(441), 1, + ACTIONS(375), 1, anon_sym_fn, - ACTIONS(449), 1, + ACTIONS(383), 1, anon_sym_enum, - ACTIONS(451), 1, - anon_sym_STAR, - ACTIONS(453), 1, + ACTIONS(387), 1, anon_sym_nullable, - ACTIONS(455), 1, + ACTIONS(389), 1, anon_sym_struct, - ACTIONS(457), 1, + ACTIONS(391), 1, anon_sym_union, - ACTIONS(459), 1, + ACTIONS(393), 1, anon_sym_LBRACK, - ACTIONS(461), 1, + ACTIONS(395), 1, anon_sym_DOT_DOT_DOT, - ACTIONS(463), 1, + ACTIONS(412), 1, + anon_sym_STAR, + ACTIONS(414), 1, sym_name, - STATE(326), 1, + STATE(428), 1, sym_identifier, - STATE(737), 1, + STATE(649), 1, sym_fntype_attr, - ACTIONS(447), 2, + ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, - STATE(323), 2, + STATE(435), 2, sym__inner_type, sym_storage_class, - ACTIONS(443), 3, + ACTIONS(377), 4, anon_sym_rune, + anon_sym_str, anon_sym_bool, anon_sym_void, - STATE(327), 4, + STATE(424), 4, sym_integer_type, sym_floating_type, sym_enum_type, sym_pointer_type, - STATE(342), 9, + STATE(427), 9, sym_scalar_type, sym_struct_type, sym_union_type, @@ -25597,7 +25593,7 @@ static uint16_t ts_small_parse_table[] = { sym_function_type, sym_alias_type, sym_unwrapped_alias, - ACTIONS(445), 13, + ACTIONS(379), 13, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -25611,45 +25607,46 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [6575] = 21, + [6521] = 21, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, anon_sym_ATnoreturn, - ACTIONS(382), 1, + ACTIONS(371), 1, anon_sym_const, - ACTIONS(384), 1, + ACTIONS(373), 1, anon_sym_LPAREN, - ACTIONS(386), 1, + ACTIONS(375), 1, anon_sym_fn, - ACTIONS(394), 1, + ACTIONS(383), 1, anon_sym_enum, - ACTIONS(398), 1, + ACTIONS(387), 1, anon_sym_nullable, - ACTIONS(400), 1, + ACTIONS(389), 1, anon_sym_struct, - ACTIONS(402), 1, + ACTIONS(391), 1, anon_sym_union, - ACTIONS(404), 1, + ACTIONS(393), 1, anon_sym_LBRACK, - ACTIONS(406), 1, + ACTIONS(395), 1, anon_sym_DOT_DOT_DOT, - ACTIONS(425), 1, + ACTIONS(412), 1, anon_sym_STAR, - ACTIONS(427), 1, + ACTIONS(414), 1, sym_name, STATE(428), 1, sym_identifier, STATE(649), 1, sym_fntype_attr, - ACTIONS(392), 2, + ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, - STATE(453), 2, + STATE(450), 2, sym__inner_type, sym_storage_class, - ACTIONS(388), 3, + ACTIONS(377), 4, anon_sym_rune, + anon_sym_str, anon_sym_bool, anon_sym_void, STATE(424), 4, @@ -25667,7 +25664,7 @@ static uint16_t ts_small_parse_table[] = { sym_function_type, sym_alias_type, sym_unwrapped_alias, - ACTIONS(390), 13, + ACTIONS(379), 13, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -25681,45 +25678,103 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [6666] = 21, + [6613] = 7, + ACTIONS(3), 1, + sym_comment, + ACTIONS(482), 1, + anon_sym_COLON_COLON, + ACTIONS(484), 1, + anon_sym_LBRACE, + ACTIONS(486), 1, + anon_sym_DOT, + ACTIONS(478), 3, + anon_sym_LPAREN, + anon_sym_LBRACK, + anon_sym_QMARK, + ACTIONS(480), 15, + anon_sym_EQ, + anon_sym_COLON, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(488), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [6677] = 21, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, anon_sym_ATnoreturn, - ACTIONS(382), 1, + ACTIONS(371), 1, anon_sym_const, - ACTIONS(384), 1, + ACTIONS(373), 1, anon_sym_LPAREN, - ACTIONS(386), 1, + ACTIONS(375), 1, anon_sym_fn, - ACTIONS(394), 1, + ACTIONS(383), 1, anon_sym_enum, - ACTIONS(398), 1, + ACTIONS(387), 1, anon_sym_nullable, - ACTIONS(400), 1, + ACTIONS(389), 1, anon_sym_struct, - ACTIONS(402), 1, + ACTIONS(391), 1, anon_sym_union, - ACTIONS(404), 1, + ACTIONS(393), 1, anon_sym_LBRACK, - ACTIONS(406), 1, + ACTIONS(395), 1, anon_sym_DOT_DOT_DOT, - ACTIONS(425), 1, + ACTIONS(412), 1, anon_sym_STAR, - ACTIONS(427), 1, + ACTIONS(414), 1, sym_name, STATE(428), 1, sym_identifier, STATE(649), 1, sym_fntype_attr, - ACTIONS(392), 2, + ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, - STATE(418), 2, + STATE(453), 2, sym__inner_type, sym_storage_class, - ACTIONS(388), 3, + ACTIONS(377), 4, anon_sym_rune, + anon_sym_str, anon_sym_bool, anon_sym_void, STATE(424), 4, @@ -25737,7 +25792,7 @@ static uint16_t ts_small_parse_table[] = { sym_function_type, sym_alias_type, sym_unwrapped_alias, - ACTIONS(390), 13, + ACTIONS(379), 13, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -25751,63 +25806,24 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [6757] = 21, + [6769] = 6, ACTIONS(3), 1, sym_comment, - ACTIONS(23), 1, - anon_sym_ATnoreturn, - ACTIONS(382), 1, - anon_sym_const, - ACTIONS(384), 1, - anon_sym_LPAREN, - ACTIONS(386), 1, - anon_sym_fn, - ACTIONS(394), 1, - anon_sym_enum, - ACTIONS(398), 1, - anon_sym_nullable, - ACTIONS(400), 1, - anon_sym_struct, - ACTIONS(402), 1, - anon_sym_union, - ACTIONS(404), 1, - anon_sym_LBRACK, - ACTIONS(406), 1, - anon_sym_DOT_DOT_DOT, - ACTIONS(425), 1, - anon_sym_STAR, - ACTIONS(427), 1, - sym_name, - STATE(428), 1, - sym_identifier, - STATE(649), 1, - sym_fntype_attr, - ACTIONS(392), 2, - anon_sym_f32, - anon_sym_f64, - STATE(435), 2, - sym__inner_type, - sym_storage_class, - ACTIONS(388), 3, - anon_sym_rune, - anon_sym_bool, - anon_sym_void, - STATE(424), 4, - sym_integer_type, - sym_floating_type, - sym_enum_type, - sym_pointer_type, - STATE(427), 9, - sym_scalar_type, - sym_struct_type, - sym_union_type, - sym_tuple_type, - sym_tagged_union_type, - sym_slice_array_type, - sym_function_type, - sym_alias_type, - sym_unwrapped_alias, - ACTIONS(390), 13, + STATE(320), 1, + sym_integer_suffix, + ACTIONS(405), 2, + anon_sym_i, + anon_sym_u, + ACTIONS(354), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(399), 9, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -25816,12 +25832,88 @@ static uint16_t ts_small_parse_table[] = { anon_sym_u16, anon_sym_u32, anon_sym_u64, - anon_sym_int, - anon_sym_uint, - anon_sym_size, - anon_sym_uintptr, - anon_sym_char, - [6848] = 3, + anon_sym_z, + ACTIONS(352), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [6830] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(503), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(501), 32, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_DQUOTE, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [6885] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(507), 15, @@ -25872,7 +25964,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [6902] = 5, + [6939] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(511), 1, @@ -25881,7 +25973,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, anon_sym_LBRACK, anon_sym_QMARK, - ACTIONS(467), 14, + ACTIONS(480), 14, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -25896,7 +25988,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(465), 28, + ACTIONS(488), 28, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -25925,10 +26017,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [6960] = 3, + [6997] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(431), 15, + ACTIONS(459), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -25944,7 +26036,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(429), 31, + ACTIONS(457), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -25976,7 +26068,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [7014] = 7, + [7051] = 7, ACTIONS(3), 1, sym_comment, ACTIONS(517), 1, @@ -26031,7 +26123,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [7076] = 3, + [7113] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(527), 15, @@ -26082,7 +26174,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [7130] = 3, + [7167] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(531), 15, @@ -26133,7 +26225,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [7184] = 3, + [7221] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(535), 15, @@ -26184,7 +26276,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [7238] = 3, + [7275] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(539), 15, @@ -26235,7 +26327,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [7292] = 3, + [7329] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(511), 15, @@ -26286,7 +26378,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [7346] = 3, + [7383] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(543), 15, @@ -26337,7 +26429,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [7400] = 3, + [7437] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(547), 15, @@ -26388,7 +26480,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [7454] = 3, + [7491] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(551), 15, @@ -26439,7 +26531,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [7508] = 3, + [7545] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(555), 15, @@ -26490,7 +26582,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [7562] = 3, + [7599] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(559), 15, @@ -26541,7 +26633,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [7616] = 3, + [7653] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(563), 15, @@ -26592,7 +26684,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [7670] = 3, + [7707] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(567), 15, @@ -26643,7 +26735,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [7724] = 3, + [7761] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(571), 15, @@ -26694,7 +26786,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [7778] = 3, + [7815] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(575), 15, @@ -26745,7 +26837,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [7832] = 3, + [7869] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(579), 15, @@ -26796,7 +26888,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [7886] = 3, + [7923] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(583), 15, @@ -26847,7 +26939,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [7940] = 3, + [7977] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(587), 15, @@ -26898,7 +26990,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [7994] = 3, + [8031] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(591), 15, @@ -26949,7 +27041,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [8048] = 3, + [8085] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(595), 15, @@ -27000,7 +27092,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [8102] = 3, + [8139] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(599), 15, @@ -27051,7 +27143,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [8156] = 3, + [8193] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(603), 15, @@ -27102,7 +27194,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [8210] = 3, + [8247] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(607), 15, @@ -27153,61 +27245,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [8264] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(611), 15, - anon_sym_EQ, - anon_sym_STAR, - anon_sym_PIPE, - anon_sym_DOT, - anon_sym_DOT_DOT, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_AMP, - anon_sym_SLASH, - anon_sym_PERCENT, - anon_sym_LT_LT, - anon_sym_GT_GT, - anon_sym_CARET, - anon_sym_LT, - anon_sym_GT, - ACTIONS(609), 31, - anon_sym_SEMI, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_LBRACK, - anon_sym_RBRACK, - anon_sym_DOT_DOT_DOT, - anon_sym_QMARK, - anon_sym_as, - anon_sym_is, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_CARET_CARET, - anon_sym_PIPE_PIPE, - anon_sym_else, - anon_sym_EQ_GT, - anon_sym_PLUS_EQ, - anon_sym_DASH_EQ, - anon_sym_STAR_EQ, - anon_sym_SLASH_EQ, - anon_sym_PERCENT_EQ, - anon_sym_LT_LT_EQ, - anon_sym_GT_GT_EQ, - anon_sym_AMP_EQ, - anon_sym_PIPE_EQ, - anon_sym_CARET_EQ, - [8318] = 3, + [8301] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(475), 15, + ACTIONS(611), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -27223,7 +27264,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(473), 31, + ACTIONS(609), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -27255,10 +27296,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [8372] = 3, + [8355] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(416), 15, + ACTIONS(486), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -27274,7 +27315,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(414), 31, + ACTIONS(478), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -27306,10 +27347,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [8426] = 3, + [8409] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(615), 15, + ACTIONS(422), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -27325,7 +27366,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(613), 31, + ACTIONS(420), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -27357,10 +27398,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [8480] = 3, + [8463] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(619), 15, + ACTIONS(615), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -27376,7 +27417,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(617), 31, + ACTIONS(613), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -27408,10 +27449,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [8534] = 3, + [8517] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(623), 15, + ACTIONS(619), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -27427,7 +27468,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(621), 31, + ACTIONS(617), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -27459,10 +27500,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [8588] = 3, + [8571] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(627), 15, + ACTIONS(623), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -27478,7 +27519,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(625), 31, + ACTIONS(621), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -27510,10 +27551,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [8642] = 3, + [8625] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(631), 15, + ACTIONS(627), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -27529,7 +27570,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(629), 31, + ACTIONS(625), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -27561,63 +27602,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [8696] = 5, + [8679] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(467), 1, - anon_sym_EQ, - ACTIONS(465), 10, - anon_sym_PLUS_EQ, - anon_sym_DASH_EQ, - anon_sym_STAR_EQ, - anon_sym_SLASH_EQ, - anon_sym_PERCENT_EQ, - anon_sym_LT_LT_EQ, - anon_sym_GT_GT_EQ, - anon_sym_AMP_EQ, - anon_sym_PIPE_EQ, - anon_sym_CARET_EQ, - ACTIONS(511), 14, - anon_sym_STAR, - anon_sym_PIPE, - anon_sym_DOT, - anon_sym_DOT_DOT, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_AMP, - anon_sym_SLASH, - anon_sym_PERCENT, - anon_sym_LT_LT, - anon_sym_GT_GT, - anon_sym_CARET, - anon_sym_LT, - anon_sym_GT, - ACTIONS(509), 21, - anon_sym_SEMI, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_LBRACK, - anon_sym_RBRACK, - anon_sym_DOT_DOT_DOT, - anon_sym_QMARK, - anon_sym_as, - anon_sym_is, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_CARET_CARET, - anon_sym_PIPE_PIPE, - anon_sym_else, - anon_sym_EQ_GT, - [8754] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(635), 15, + ACTIONS(631), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -27633,7 +27621,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(633), 31, + ACTIONS(629), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -27665,11 +27653,23 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [8808] = 3, + [8733] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(639), 15, + ACTIONS(480), 1, anon_sym_EQ, + ACTIONS(488), 10, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + ACTIONS(511), 14, anon_sym_STAR, anon_sym_PIPE, anon_sym_DOT, @@ -27684,7 +27684,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(637), 31, + ACTIONS(509), 21, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -27706,20 +27706,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - anon_sym_PLUS_EQ, - anon_sym_DASH_EQ, - anon_sym_STAR_EQ, - anon_sym_SLASH_EQ, - anon_sym_PERCENT_EQ, - anon_sym_LT_LT_EQ, - anon_sym_GT_GT_EQ, - anon_sym_AMP_EQ, - anon_sym_PIPE_EQ, - anon_sym_CARET_EQ, - [8862] = 3, + [8791] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(643), 15, + ACTIONS(635), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -27735,7 +27725,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(641), 31, + ACTIONS(633), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -27767,10 +27757,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [8916] = 3, + [8845] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(647), 15, + ACTIONS(639), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -27786,7 +27776,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(645), 31, + ACTIONS(637), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -27818,10 +27808,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [8970] = 3, + [8899] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(354), 15, + ACTIONS(643), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -27837,7 +27827,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(352), 31, + ACTIONS(641), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -27869,10 +27859,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [9024] = 3, + [8953] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(651), 15, + ACTIONS(647), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -27888,7 +27878,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(649), 31, + ACTIONS(645), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -27920,10 +27910,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [9078] = 3, + [9007] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(655), 15, + ACTIONS(354), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -27939,7 +27929,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(653), 31, + ACTIONS(352), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -27971,30 +27961,30 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [9132] = 20, + [9061] = 20, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, anon_sym_ATnoreturn, - ACTIONS(384), 1, + ACTIONS(373), 1, anon_sym_LPAREN, - ACTIONS(386), 1, + ACTIONS(375), 1, anon_sym_fn, - ACTIONS(394), 1, + ACTIONS(383), 1, anon_sym_enum, - ACTIONS(398), 1, + ACTIONS(387), 1, anon_sym_nullable, - ACTIONS(400), 1, + ACTIONS(389), 1, anon_sym_struct, - ACTIONS(402), 1, + ACTIONS(391), 1, anon_sym_union, - ACTIONS(404), 1, + ACTIONS(393), 1, anon_sym_LBRACK, - ACTIONS(406), 1, + ACTIONS(395), 1, anon_sym_DOT_DOT_DOT, - ACTIONS(425), 1, + ACTIONS(412), 1, anon_sym_STAR, - ACTIONS(427), 1, + ACTIONS(414), 1, sym_name, STATE(428), 1, sym_identifier, @@ -28002,11 +27992,12 @@ static uint16_t ts_small_parse_table[] = { sym_storage_class, STATE(649), 1, sym_fntype_attr, - ACTIONS(392), 2, + ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, - ACTIONS(388), 3, + ACTIONS(377), 4, anon_sym_rune, + anon_sym_str, anon_sym_bool, anon_sym_void, STATE(424), 4, @@ -28024,7 +28015,7 @@ static uint16_t ts_small_parse_table[] = { sym_function_type, sym_alias_type, sym_unwrapped_alias, - ACTIONS(390), 13, + ACTIONS(379), 13, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -28038,30 +28029,81 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [9219] = 20, + [9149] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(651), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(649), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [9203] = 20, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, anon_sym_ATnoreturn, - ACTIONS(439), 1, + ACTIONS(431), 1, anon_sym_LPAREN, - ACTIONS(441), 1, + ACTIONS(433), 1, anon_sym_fn, - ACTIONS(449), 1, + ACTIONS(441), 1, anon_sym_enum, - ACTIONS(451), 1, + ACTIONS(443), 1, anon_sym_STAR, - ACTIONS(453), 1, + ACTIONS(445), 1, anon_sym_nullable, - ACTIONS(455), 1, + ACTIONS(447), 1, anon_sym_struct, - ACTIONS(457), 1, + ACTIONS(449), 1, anon_sym_union, - ACTIONS(459), 1, + ACTIONS(451), 1, anon_sym_LBRACK, - ACTIONS(461), 1, + ACTIONS(453), 1, anon_sym_DOT_DOT_DOT, - ACTIONS(463), 1, + ACTIONS(455), 1, sym_name, STATE(326), 1, sym_identifier, @@ -28069,11 +28111,12 @@ static uint16_t ts_small_parse_table[] = { sym_storage_class, STATE(737), 1, sym_fntype_attr, - ACTIONS(447), 2, + ACTIONS(439), 2, anon_sym_f32, anon_sym_f64, - ACTIONS(443), 3, + ACTIONS(435), 4, anon_sym_rune, + anon_sym_str, anon_sym_bool, anon_sym_void, STATE(327), 4, @@ -28091,7 +28134,7 @@ static uint16_t ts_small_parse_table[] = { sym_function_type, sym_alias_type, sym_unwrapped_alias, - ACTIONS(445), 13, + ACTIONS(437), 13, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -28105,7 +28148,58 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [9306] = 6, + [9291] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(655), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(653), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [9345] = 6, ACTIONS(3), 1, sym_comment, ACTIONS(659), 1, @@ -28156,7 +28250,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [9363] = 3, + [9402] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(667), 14, @@ -28203,7 +28297,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [9413] = 6, + [9452] = 6, ACTIONS(3), 1, sym_comment, ACTIONS(659), 1, @@ -28253,7 +28347,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET_CARET, anon_sym_PIPE_PIPE, anon_sym_EQ_GT, - [9469] = 3, + [9508] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(661), 14, @@ -28300,19 +28394,19 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [9519] = 7, + [9558] = 7, ACTIONS(3), 1, sym_comment, - ACTIONS(373), 1, + ACTIONS(403), 1, anon_sym_e, STATE(270), 1, sym_exponent, STATE(283), 1, sym_floating_suffix, - ACTIONS(371), 2, + ACTIONS(401), 2, anon_sym_f32, anon_sym_f64, - ACTIONS(416), 8, + ACTIONS(422), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -28321,7 +28415,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(414), 27, + ACTIONS(420), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -28349,7 +28443,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [9575] = 6, + [9614] = 6, ACTIONS(3), 1, sym_comment, ACTIONS(659), 1, @@ -28396,10 +28490,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET_CARET, anon_sym_PIPE_PIPE, anon_sym_else, - [9628] = 3, + [9667] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(435), 10, + ACTIONS(465), 10, anon_sym_COLON, anon_sym_BANG, anon_sym_PIPE, @@ -28410,7 +28504,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(433), 28, + ACTIONS(463), 28, anon_sym_SEMI, anon_sym_COLON_COLON, anon_sym_LBRACE, @@ -28439,15 +28533,15 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [9674] = 5, + [9713] = 5, ACTIONS(3), 1, sym_comment, STATE(311), 1, sym_floating_suffix, - ACTIONS(371), 2, + ACTIONS(401), 2, anon_sym_f32, anon_sym_f64, - ACTIONS(431), 8, + ACTIONS(459), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -28456,7 +28550,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(429), 27, + ACTIONS(457), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -28484,7 +28578,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [9724] = 6, + [9763] = 6, ACTIONS(3), 1, sym_comment, ACTIONS(659), 1, @@ -28530,14 +28624,14 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_AMP, anon_sym_CARET_CARET, anon_sym_PIPE_PIPE, - [9776] = 5, + [9815] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(59), 1, anon_sym_DQUOTE, STATE(275), 1, aux_sym_string_constant_repeat1, - ACTIONS(481), 8, + ACTIONS(469), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -28546,7 +28640,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(479), 27, + ACTIONS(467), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -28574,12 +28668,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [9825] = 4, + [9864] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(669), 1, anon_sym_COLON_COLON, - ACTIONS(485), 9, + ACTIONS(496), 9, anon_sym_COLON, anon_sym_PIPE, anon_sym_DOT, @@ -28589,7 +28683,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(483), 27, + ACTIONS(494), 27, anon_sym_SEMI, anon_sym_LBRACE, anon_sym_RBRACE, @@ -28617,14 +28711,14 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [9872] = 5, + [9911] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(469), 1, + ACTIONS(482), 1, anon_sym_COLON_COLON, - ACTIONS(471), 1, + ACTIONS(484), 1, anon_sym_LBRACE, - ACTIONS(475), 9, + ACTIONS(486), 9, anon_sym_COLON, anon_sym_PIPE, anon_sym_DOT, @@ -28634,7 +28728,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(473), 26, + ACTIONS(478), 26, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -28661,14 +28755,14 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [9921] = 5, + [9960] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(672), 1, anon_sym_DQUOTE, STATE(275), 1, aux_sym_string_constant_repeat1, - ACTIONS(496), 8, + ACTIONS(473), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -28677,7 +28771,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(494), 27, + ACTIONS(471), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -28705,20 +28799,20 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [9970] = 7, + [10009] = 7, ACTIONS(3), 1, sym_comment, - ACTIONS(469), 1, + ACTIONS(482), 1, anon_sym_COLON_COLON, - ACTIONS(471), 1, + ACTIONS(484), 1, anon_sym_LBRACE, - ACTIONS(475), 1, + ACTIONS(486), 1, anon_sym_DOT, - ACTIONS(473), 3, + ACTIONS(478), 3, anon_sym_LPAREN, anon_sym_LBRACK, anon_sym_QMARK, - ACTIONS(467), 8, + ACTIONS(480), 8, anon_sym_COLON, anon_sym_PIPE, anon_sym_DOT_DOT, @@ -28727,7 +28821,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(465), 23, + ACTIONS(488), 23, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -28751,7 +28845,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [10023] = 3, + [10062] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(503), 8, @@ -28792,7 +28886,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [10067] = 4, + [10106] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(675), 1, @@ -28834,7 +28928,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [10113] = 3, + [10152] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(599), 9, @@ -28875,7 +28969,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [10157] = 3, + [10196] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(579), 9, @@ -28916,7 +29010,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [10201] = 3, + [10240] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(527), 9, @@ -28957,7 +29051,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [10245] = 3, + [10284] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(547), 8, @@ -28997,10 +29091,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [10288] = 3, + [10327] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(431), 8, + ACTIONS(459), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -29009,7 +29103,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(429), 27, + ACTIONS(457), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -29037,7 +29131,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [10331] = 3, + [10370] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(531), 8, @@ -29077,7 +29171,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [10374] = 3, + [10413] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(655), 8, @@ -29117,7 +29211,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [10417] = 4, + [10456] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(677), 1, @@ -29158,7 +29252,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET_CARET, anon_sym_PIPE_PIPE, anon_sym_EQ_GT, - [10462] = 3, + [10501] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(571), 8, @@ -29198,7 +29292,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [10505] = 3, + [10544] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(627), 8, @@ -29238,7 +29332,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [10548] = 7, + [10587] = 7, ACTIONS(3), 1, sym_comment, ACTIONS(521), 1, @@ -29282,7 +29376,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [10599] = 3, + [10638] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(551), 8, @@ -29322,7 +29416,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [10642] = 3, + [10681] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(591), 8, @@ -29362,7 +29456,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [10685] = 3, + [10724] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(563), 8, @@ -29402,7 +29496,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [10728] = 3, + [10767] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(651), 8, @@ -29442,7 +29536,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [10771] = 3, + [10810] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(543), 8, @@ -29482,7 +29576,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [10814] = 3, + [10853] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(507), 8, @@ -29522,7 +29616,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [10857] = 3, + [10896] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(607), 8, @@ -29562,10 +29656,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [10900] = 3, + [10939] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(416), 8, + ACTIONS(422), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -29574,7 +29668,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(414), 27, + ACTIONS(420), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -29602,7 +29696,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [10943] = 3, + [10982] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(354), 8, @@ -29642,7 +29736,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [10986] = 3, + [11025] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(647), 8, @@ -29682,7 +29776,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11029] = 3, + [11068] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(539), 8, @@ -29722,10 +29816,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11072] = 3, + [11111] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(475), 8, + ACTIONS(486), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -29734,7 +29828,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(473), 27, + ACTIONS(478), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -29762,7 +29856,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11115] = 3, + [11154] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(595), 8, @@ -29802,7 +29896,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11158] = 3, + [11197] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(511), 8, @@ -29842,7 +29936,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11201] = 3, + [11240] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(535), 8, @@ -29882,7 +29976,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11244] = 7, + [11283] = 7, ACTIONS(3), 1, sym_comment, ACTIONS(679), 1, @@ -29926,7 +30020,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11295] = 3, + [11334] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(623), 8, @@ -29966,7 +30060,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11338] = 3, + [11377] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(615), 8, @@ -30006,7 +30100,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11381] = 3, + [11420] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(555), 8, @@ -30046,7 +30140,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11424] = 3, + [11463] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(559), 8, @@ -30086,7 +30180,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11467] = 3, + [11506] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(567), 8, @@ -30126,7 +30220,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11510] = 3, + [11549] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(575), 8, @@ -30166,7 +30260,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11553] = 3, + [11592] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(643), 8, @@ -30206,7 +30300,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11596] = 5, + [11635] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(511), 1, @@ -30215,7 +30309,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_LPAREN, anon_sym_LBRACK, anon_sym_QMARK, - ACTIONS(467), 7, + ACTIONS(480), 7, anon_sym_PIPE, anon_sym_DOT_DOT, anon_sym_AMP, @@ -30223,7 +30317,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(465), 24, + ACTIONS(488), 24, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -30248,7 +30342,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11643] = 3, + [11682] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(583), 8, @@ -30288,7 +30382,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11686] = 3, + [11725] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(619), 8, @@ -30328,7 +30422,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11729] = 3, + [11768] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(587), 8, @@ -30368,7 +30462,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11772] = 3, + [11811] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(639), 8, @@ -30408,7 +30502,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11815] = 3, + [11854] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(603), 8, @@ -30448,7 +30542,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11858] = 3, + [11897] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(611), 8, @@ -30488,7 +30582,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11901] = 3, + [11940] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(631), 8, @@ -30528,7 +30622,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11944] = 3, + [11983] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(635), 8, @@ -30568,12 +30662,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11987] = 4, + [12026] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(689), 1, anon_sym_COLON_COLON, - ACTIONS(485), 9, + ACTIONS(496), 9, anon_sym_COLON, anon_sym_BANG, anon_sym_PIPE, @@ -30583,7 +30677,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(483), 23, + ACTIONS(494), 23, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -30607,7 +30701,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12030] = 3, + [12069] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(693), 8, @@ -30644,7 +30738,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12070] = 3, + [12109] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(697), 8, @@ -30681,7 +30775,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12110] = 3, + [12149] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(701), 8, @@ -30718,7 +30812,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12150] = 3, + [12189] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(705), 8, @@ -30755,7 +30849,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12190] = 3, + [12229] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(709), 8, @@ -30792,7 +30886,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12230] = 4, + [12269] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(711), 1, @@ -30830,7 +30924,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET_CARET, anon_sym_PIPE_PIPE, anon_sym_else, - [12272] = 3, + [12311] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(715), 8, @@ -30867,7 +30961,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12312] = 4, + [12351] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(719), 1, @@ -30905,7 +30999,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12354] = 3, + [12393] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(725), 8, @@ -30942,7 +31036,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12394] = 3, + [12433] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(729), 8, @@ -30979,7 +31073,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12434] = 3, + [12473] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(733), 8, @@ -31016,7 +31110,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12474] = 3, + [12513] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(737), 8, @@ -31053,7 +31147,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12514] = 3, + [12553] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(741), 8, @@ -31090,7 +31184,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12554] = 3, + [12593] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(745), 8, @@ -31127,7 +31221,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12594] = 3, + [12633] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(749), 8, @@ -31164,7 +31258,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12634] = 3, + [12673] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(753), 8, @@ -31201,7 +31295,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12674] = 3, + [12713] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(757), 8, @@ -31238,7 +31332,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12714] = 3, + [12753] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(761), 8, @@ -31275,7 +31369,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12754] = 3, + [12793] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(765), 8, @@ -31312,7 +31406,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12794] = 3, + [12833] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(769), 8, @@ -31349,7 +31443,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12834] = 3, + [12873] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(773), 8, @@ -31386,7 +31480,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12874] = 3, + [12913] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(777), 8, @@ -31423,7 +31517,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12914] = 3, + [12953] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(781), 8, @@ -31460,7 +31554,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12954] = 3, + [12993] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(785), 8, @@ -31497,7 +31591,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12994] = 6, + [13033] = 6, ACTIONS(3), 1, sym_comment, ACTIONS(789), 1, @@ -31536,7 +31630,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [13039] = 3, + [13078] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(799), 7, @@ -31572,7 +31666,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [13078] = 3, + [13117] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(661), 7, @@ -31608,7 +31702,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [13117] = 3, + [13156] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(667), 7, @@ -31644,7 +31738,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [13156] = 3, + [13195] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(803), 7, @@ -31680,7 +31774,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [13195] = 3, + [13234] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(807), 7, @@ -31716,7 +31810,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [13234] = 3, + [13273] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(811), 7, @@ -31752,7 +31846,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [13273] = 6, + [13312] = 6, ACTIONS(3), 1, sym_comment, ACTIONS(789), 1, @@ -31791,7 +31885,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [13318] = 4, + [13357] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(817), 1, @@ -31828,7 +31922,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_AMP, anon_sym_CARET_CARET, anon_sym_PIPE_PIPE, - [13359] = 6, + [13398] = 6, ACTIONS(3), 1, sym_comment, ACTIONS(825), 1, @@ -31864,7 +31958,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [13401] = 5, + [13440] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(825), 1, @@ -31897,10 +31991,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [13439] = 4, + [13478] = 4, ACTIONS(3), 1, sym_comment, - STATE(212), 1, + STATE(217), 1, sym_hex_digits, STATE(119), 2, sym_hex_digit, @@ -31928,7 +32022,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_d, anon_sym_e, anon_sym_f, - [13474] = 4, + [13513] = 4, ACTIONS(3), 1, sym_comment, STATE(159), 1, @@ -31959,7 +32053,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_d, anon_sym_e, anon_sym_f, - [13509] = 6, + [13548] = 6, ACTIONS(3), 1, sym_comment, ACTIONS(789), 1, @@ -31991,7 +32085,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [13547] = 17, + [13586] = 17, ACTIONS(3), 1, sym_comment, ACTIONS(9), 1, @@ -32034,7 +32128,7 @@ static uint16_t ts_small_parse_table[] = { sym_constant_declaration, sym_type_declaration, sym_function_declaration, - [13607] = 4, + [13646] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(843), 2, @@ -32063,7 +32157,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [13640] = 16, + [13679] = 16, ACTIONS(3), 1, sym_comment, ACTIONS(845), 1, @@ -32104,7 +32198,7 @@ static uint16_t ts_small_parse_table[] = { sym_constant_declaration, sym_type_declaration, sym_function_declaration, - [13697] = 16, + [13736] = 16, ACTIONS(3), 1, sym_comment, ACTIONS(9), 1, @@ -32145,7 +32239,7 @@ static uint16_t ts_small_parse_table[] = { sym_constant_declaration, sym_type_declaration, sym_function_declaration, - [13754] = 4, + [13793] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(877), 1, @@ -32172,7 +32266,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [13785] = 3, + [13824] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(881), 6, @@ -32198,7 +32292,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [13814] = 4, + [13853] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(877), 1, @@ -32225,7 +32319,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [13845] = 3, + [13884] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(889), 6, @@ -32251,7 +32345,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [13874] = 4, + [13913] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(895), 1, @@ -32277,7 +32371,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [13904] = 13, + [13943] = 13, ACTIONS(3), 1, sym_comment, ACTIONS(13), 1, @@ -32312,7 +32406,7 @@ static uint16_t ts_small_parse_table[] = { sym_constant_declaration, sym_type_declaration, sym_function_declaration, - [13952] = 4, + [13991] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(895), 1, @@ -32338,7 +32432,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [13982] = 4, + [14021] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(903), 1, @@ -32363,7 +32457,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [14011] = 4, + [14050] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(903), 1, @@ -32388,7 +32482,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [14040] = 10, + [14079] = 10, ACTIONS(3), 1, sym_comment, ACTIONS(258), 1, @@ -32418,7 +32512,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_7, anon_sym_8, anon_sym_9, - [14080] = 10, + [14119] = 10, ACTIONS(3), 1, sym_comment, ACTIONS(47), 1, @@ -32431,7 +32525,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_0, ACTIONS(913), 1, sym_name, - STATE(175), 1, + STATE(192), 1, sym_decimal_digits, STATE(291), 1, sym_integer_constant, @@ -32448,7 +32542,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_7, anon_sym_8, anon_sym_9, - [14120] = 5, + [14159] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(917), 1, @@ -32473,7 +32567,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [14150] = 5, + [14189] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(925), 1, @@ -32498,14 +32592,14 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [14180] = 3, + [14219] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(435), 3, + ACTIONS(465), 3, anon_sym_EQ, anon_sym_COLON, anon_sym_DOT, - ACTIONS(433), 13, + ACTIONS(463), 13, anon_sym_SEMI, anon_sym_COLON_COLON, anon_sym_LBRACE, @@ -32519,7 +32613,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, anon_sym_QMARK, anon_sym_EQ_GT, - [14204] = 4, + [14243] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(7), 1, @@ -32540,10 +32634,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_ATinit, anon_sym_ATtest, anon_sym_ATnoreturn, - [14229] = 5, + [14268] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(390), 1, + ACTIONS(379), 1, anon_sym_uint, ACTIONS(929), 1, anon_sym_LBRACE, @@ -32562,10 +32656,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [14256] = 5, + [14295] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(390), 1, + ACTIONS(379), 1, anon_sym_uint, ACTIONS(933), 1, anon_sym_LBRACE, @@ -32584,7 +32678,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [14283] = 4, + [14322] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(937), 1, @@ -32605,7 +32699,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_ATinit, anon_sym_ATtest, anon_sym_ATnoreturn, - [14308] = 4, + [14347] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(942), 1, @@ -32625,7 +32719,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [14332] = 4, + [14371] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(948), 1, @@ -32645,10 +32739,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [14356] = 4, + [14395] = 4, ACTIONS(3), 1, sym_comment, - STATE(157), 1, + STATE(156), 1, sym_decimal_digits, STATE(114), 2, sym_decimal_digit, @@ -32664,7 +32758,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_7, anon_sym_8, anon_sym_9, - [14379] = 2, + [14418] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(950), 13, @@ -32681,10 +32775,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_ATinit, anon_sym_ATtest, anon_sym_ATnoreturn, - [14398] = 4, + [14437] = 4, ACTIONS(3), 1, sym_comment, - STATE(166), 1, + STATE(168), 1, sym_decimal_digits, STATE(114), 2, sym_decimal_digit, @@ -32700,10 +32794,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_7, anon_sym_8, anon_sym_9, - [14421] = 4, + [14460] = 4, ACTIONS(3), 1, sym_comment, - STATE(193), 1, + STATE(200), 1, sym_decimal_digits, STATE(146), 2, sym_decimal_digit, @@ -32719,7 +32813,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_7, anon_sym_8, anon_sym_9, - [14444] = 4, + [14483] = 4, ACTIONS(3), 1, sym_comment, STATE(267), 1, @@ -32738,7 +32832,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_7, anon_sym_8, anon_sym_9, - [14467] = 2, + [14506] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(952), 13, @@ -32755,15 +32849,15 @@ static uint16_t ts_small_parse_table[] = { anon_sym_ATinit, anon_sym_ATtest, anon_sym_ATnoreturn, - [14486] = 4, + [14525] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(954), 1, anon_sym_COLON_COLON, - ACTIONS(485), 2, + ACTIONS(496), 2, anon_sym_EQ, anon_sym_COLON, - ACTIONS(483), 10, + ACTIONS(494), 10, anon_sym_SEMI, anon_sym_LBRACE, anon_sym_RBRACE, @@ -32774,7 +32868,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE, anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [14509] = 2, + [14548] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(956), 13, @@ -32791,7 +32885,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_ATinit, anon_sym_ATtest, anon_sym_ATnoreturn, - [14528] = 3, + [14567] = 3, ACTIONS(3), 1, sym_comment, STATE(52), 1, @@ -32808,7 +32902,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [14548] = 4, + [14587] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(960), 1, @@ -32826,7 +32920,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [14570] = 3, + [14609] = 3, ACTIONS(3), 1, sym_comment, STATE(45), 1, @@ -32843,7 +32937,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [14590] = 2, + [14629] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(845), 12, @@ -32859,7 +32953,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_ATinit, anon_sym_ATtest, anon_sym_ATnoreturn, - [14608] = 3, + [14647] = 3, ACTIONS(3), 1, sym_comment, STATE(46), 1, @@ -32876,7 +32970,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [14628] = 4, + [14667] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(962), 1, @@ -32894,7 +32988,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [14650] = 2, + [14689] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(968), 12, @@ -32910,7 +33004,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_ATinit, anon_sym_ATtest, anon_sym_ATnoreturn, - [14668] = 3, + [14707] = 3, ACTIONS(3), 1, sym_comment, STATE(55), 1, @@ -32927,10 +33021,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [14688] = 4, + [14727] = 4, ACTIONS(3), 1, sym_comment, - STATE(212), 1, + STATE(217), 1, sym_octal_digits, STATE(160), 2, sym_octal_digit, @@ -32944,7 +33038,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_5, anon_sym_6, anon_sym_7, - [14709] = 4, + [14748] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(972), 1, @@ -32961,7 +33055,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [14730] = 4, + [14769] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(974), 1, @@ -32978,12 +33072,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [14751] = 10, + [14790] = 10, ACTIONS(3), 1, sym_comment, - ACTIONS(400), 1, + ACTIONS(389), 1, anon_sym_struct, - ACTIONS(402), 1, + ACTIONS(391), 1, anon_sym_union, ACTIONS(980), 1, anon_sym_RBRACE, @@ -33001,7 +33095,7 @@ static uint16_t ts_small_parse_table[] = { sym_struct_type, sym_union_type, sym_identifier, - [14784] = 4, + [14823] = 4, ACTIONS(3), 1, sym_comment, STATE(159), 1, @@ -33018,7 +33112,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_5, anon_sym_6, anon_sym_7, - [14805] = 5, + [14844] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(31), 1, @@ -33036,12 +33130,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, anon_sym_else, anon_sym_EQ_GT, - [14828] = 9, + [14867] = 9, ACTIONS(3), 1, sym_comment, - ACTIONS(400), 1, + ACTIONS(389), 1, anon_sym_struct, - ACTIONS(402), 1, + ACTIONS(391), 1, anon_sym_union, ACTIONS(982), 1, anon_sym_AToffset, @@ -33057,7 +33151,7 @@ static uint16_t ts_small_parse_table[] = { sym_struct_type, sym_union_type, sym_identifier, - [14858] = 7, + [14897] = 7, ACTIONS(3), 1, sym_comment, ACTIONS(13), 1, @@ -33076,12 +33170,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_ATfini, anon_sym_ATinit, anon_sym_ATtest, - [14884] = 9, + [14923] = 9, ACTIONS(3), 1, sym_comment, - ACTIONS(400), 1, + ACTIONS(389), 1, anon_sym_struct, - ACTIONS(402), 1, + ACTIONS(391), 1, anon_sym_union, ACTIONS(982), 1, anon_sym_AToffset, @@ -33097,12 +33191,12 @@ static uint16_t ts_small_parse_table[] = { sym_struct_type, sym_union_type, sym_identifier, - [14914] = 9, + [14953] = 9, ACTIONS(3), 1, sym_comment, - ACTIONS(400), 1, + ACTIONS(389), 1, anon_sym_struct, - ACTIONS(402), 1, + ACTIONS(391), 1, anon_sym_union, ACTIONS(982), 1, anon_sym_AToffset, @@ -33118,7 +33212,7 @@ static uint16_t ts_small_parse_table[] = { sym_struct_type, sym_union_type, sym_identifier, - [14944] = 3, + [14983] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(701), 1, @@ -33133,7 +33227,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE, anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [14962] = 4, + [15001] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(990), 1, @@ -33149,12 +33243,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, anon_sym_else, anon_sym_EQ_GT, - [14982] = 9, + [15021] = 9, ACTIONS(3), 1, sym_comment, - ACTIONS(400), 1, + ACTIONS(389), 1, anon_sym_struct, - ACTIONS(402), 1, + ACTIONS(391), 1, anon_sym_union, ACTIONS(982), 1, anon_sym_AToffset, @@ -33170,7 +33264,7 @@ static uint16_t ts_small_parse_table[] = { sym_struct_type, sym_union_type, sym_identifier, - [15012] = 7, + [15051] = 7, ACTIONS(3), 1, sym_comment, ACTIONS(994), 1, @@ -33189,7 +33283,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_ATfini, anon_sym_ATinit, anon_sym_ATtest, - [15038] = 3, + [15077] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1007), 1, @@ -33204,7 +33298,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_else, anon_sym_for, anon_sym_EQ_GT, - [15056] = 3, + [15095] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1011), 1, @@ -33218,7 +33312,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, anon_sym_else, anon_sym_EQ_GT, - [15073] = 3, + [15112] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(733), 1, @@ -33232,7 +33326,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE, anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [15090] = 3, + [15129] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(693), 1, @@ -33246,7 +33340,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE, anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [15107] = 4, + [15146] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1015), 1, @@ -33261,7 +33355,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [15126] = 3, + [15165] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(777), 1, @@ -33275,7 +33369,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE, anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [15143] = 3, + [15182] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(741), 1, @@ -33289,7 +33383,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE, anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [15160] = 4, + [15199] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1022), 1, @@ -33304,7 +33398,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, anon_sym_else, anon_sym_EQ_GT, - [15179] = 3, + [15218] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(745), 1, @@ -33318,7 +33412,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE, anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [15196] = 3, + [15235] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(709), 1, @@ -33332,7 +33426,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE, anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [15213] = 3, + [15252] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(990), 1, @@ -33346,7 +33440,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, anon_sym_else, anon_sym_EQ_GT, - [15230] = 4, + [15269] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(721), 1, @@ -33361,7 +33455,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE, anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [15249] = 3, + [15288] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(769), 1, @@ -33375,7 +33469,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE, anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [15266] = 3, + [15305] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(705), 1, @@ -33389,7 +33483,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE, anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [15283] = 3, + [15322] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1031), 1, @@ -33403,7 +33497,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, anon_sym_else, anon_sym_EQ_GT, - [15300] = 3, + [15339] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1035), 1, @@ -33417,7 +33511,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, anon_sym_else, anon_sym_EQ_GT, - [15317] = 3, + [15356] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1039), 1, @@ -33431,7 +33525,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, anon_sym_else, anon_sym_EQ_GT, - [15334] = 3, + [15373] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(781), 1, @@ -33445,7 +33539,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE, anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [15351] = 4, + [15390] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1015), 1, @@ -33460,7 +33554,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [15370] = 3, + [15409] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(773), 1, @@ -33474,7 +33568,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE, anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [15387] = 3, + [15426] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(725), 1, @@ -33488,7 +33582,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE, anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [15404] = 3, + [15443] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1045), 1, @@ -33502,7 +33596,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, anon_sym_else, anon_sym_EQ_GT, - [15421] = 3, + [15460] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1049), 1, @@ -33516,7 +33610,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, anon_sym_else, anon_sym_EQ_GT, - [15438] = 3, + [15477] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1053), 1, @@ -33530,7 +33624,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, anon_sym_else, anon_sym_EQ_GT, - [15455] = 3, + [15494] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1057), 1, @@ -33544,7 +33638,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, anon_sym_else, anon_sym_EQ_GT, - [15472] = 3, + [15511] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1061), 1, @@ -33558,7 +33652,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, anon_sym_else, anon_sym_EQ_GT, - [15489] = 3, + [15528] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1065), 1, @@ -33572,7 +33666,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, anon_sym_else, anon_sym_EQ_GT, - [15506] = 3, + [15545] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1069), 1, @@ -33586,7 +33680,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, anon_sym_else, anon_sym_EQ_GT, - [15523] = 3, + [15562] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1073), 1, @@ -33600,7 +33694,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, anon_sym_else, anon_sym_EQ_GT, - [15540] = 3, + [15579] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1077), 1, @@ -33614,7 +33708,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, anon_sym_else, anon_sym_EQ_GT, - [15557] = 3, + [15596] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1081), 1, @@ -33628,7 +33722,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, anon_sym_else, anon_sym_EQ_GT, - [15574] = 3, + [15613] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1085), 1, @@ -33642,7 +33736,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, anon_sym_else, anon_sym_EQ_GT, - [15591] = 3, + [15630] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(749), 1, @@ -33656,7 +33750,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE, anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [15608] = 3, + [15647] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(785), 1, @@ -33670,7 +33764,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE, anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [15625] = 3, + [15664] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(765), 1, @@ -33684,7 +33778,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE, anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [15642] = 3, + [15681] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(737), 1, @@ -33698,7 +33792,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE, anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [15659] = 3, + [15698] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1089), 1, @@ -33712,7 +33806,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, anon_sym_else, anon_sym_EQ_GT, - [15676] = 3, + [15715] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(715), 1, @@ -33726,7 +33820,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE, anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [15693] = 3, + [15732] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(757), 1, @@ -33740,7 +33834,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE, anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [15710] = 3, + [15749] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(697), 1, @@ -33754,7 +33848,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE, anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [15727] = 3, + [15766] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(761), 1, @@ -33768,7 +33862,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE, anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [15744] = 3, + [15783] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(753), 1, @@ -33782,12 +33876,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE, anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [15761] = 3, + [15800] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1091), 1, anon_sym_COLON_COLON, - ACTIONS(483), 7, + ACTIONS(494), 7, anon_sym_SEMI, anon_sym_LBRACE, anon_sym_COMMA, @@ -33795,7 +33889,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_DOT, anon_sym_QMARK, - [15777] = 9, + [15816] = 9, ACTIONS(3), 1, sym_comment, ACTIONS(43), 1, @@ -33814,7 +33908,7 @@ static uint16_t ts_small_parse_table[] = { sym_identifier, STATE(816), 1, sym_struct_initializer, - [15805] = 4, + [15844] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1025), 1, @@ -33828,7 +33922,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [15823] = 9, + [15862] = 9, ACTIONS(3), 1, sym_comment, ACTIONS(43), 1, @@ -33847,7 +33941,7 @@ static uint16_t ts_small_parse_table[] = { sym_struct_initializer, STATE(704), 1, sym_identifier, - [15851] = 7, + [15890] = 7, ACTIONS(1101), 1, anon_sym_BSLASH, ACTIONS(1104), 1, @@ -33863,7 +33957,7 @@ static uint16_t ts_small_parse_table[] = { STATE(461), 2, sym_string_char, aux_sym_string_chars_repeat1, - [15874] = 7, + [15913] = 7, ACTIONS(1109), 1, sym_comment, ACTIONS(1111), 1, @@ -33879,7 +33973,7 @@ static uint16_t ts_small_parse_table[] = { STATE(464), 2, sym_string_char, aux_sym_string_chars_repeat1, - [15897] = 7, + [15936] = 7, ACTIONS(1109), 1, sym_comment, ACTIONS(1111), 1, @@ -33895,7 +33989,7 @@ static uint16_t ts_small_parse_table[] = { STATE(464), 2, sym_string_char, aux_sym_string_chars_repeat1, - [15920] = 7, + [15959] = 7, ACTIONS(1109), 1, sym_comment, ACTIONS(1111), 1, @@ -33911,7 +34005,7 @@ static uint16_t ts_small_parse_table[] = { STATE(461), 2, sym_string_char, aux_sym_string_chars_repeat1, - [15943] = 8, + [15982] = 8, ACTIONS(3), 1, sym_comment, ACTIONS(43), 1, @@ -33928,7 +34022,7 @@ static uint16_t ts_small_parse_table[] = { sym_struct_literal, STATE(704), 1, sym_identifier, - [15968] = 7, + [16007] = 7, ACTIONS(3), 1, sym_comment, ACTIONS(43), 1, @@ -33943,12 +34037,12 @@ static uint16_t ts_small_parse_table[] = { sym_struct_literal, STATE(704), 1, sym_identifier, - [15990] = 5, + [16029] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(400), 1, + ACTIONS(389), 1, anon_sym_struct, - ACTIONS(402), 1, + ACTIONS(391), 1, anon_sym_union, ACTIONS(1123), 1, sym_name, @@ -33956,7 +34050,7 @@ static uint16_t ts_small_parse_table[] = { sym_struct_type, sym_union_type, sym_identifier, - [16008] = 7, + [16047] = 7, ACTIONS(3), 1, sym_comment, ACTIONS(1125), 1, @@ -33971,7 +34065,7 @@ static uint16_t ts_small_parse_table[] = { sym_identifier, STATE(757), 1, sym_global_bindings, - [16030] = 2, + [16069] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1129), 6, @@ -33981,7 +34075,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_ATinit, anon_sym_ATtest, anon_sym_ATnoreturn, - [16042] = 3, + [16081] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1131), 1, @@ -33992,7 +34086,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_RBRACK, anon_sym_DOT_DOT, anon_sym_else, - [16056] = 2, + [16095] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1133), 6, @@ -34002,7 +34096,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_ATinit, anon_sym_ATtest, anon_sym_ATnoreturn, - [16068] = 7, + [16107] = 7, ACTIONS(3), 1, sym_comment, ACTIONS(1125), 1, @@ -34017,7 +34111,7 @@ static uint16_t ts_small_parse_table[] = { sym_global_bindings, STATE(754), 1, sym_identifier, - [16090] = 7, + [16129] = 7, ACTIONS(3), 1, sym_comment, ACTIONS(43), 1, @@ -34032,7 +34126,7 @@ static uint16_t ts_small_parse_table[] = { sym_field_values, STATE(704), 1, sym_identifier, - [16112] = 2, + [16151] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1135), 6, @@ -34042,7 +34136,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_ATinit, anon_sym_ATtest, anon_sym_ATnoreturn, - [16124] = 6, + [16163] = 6, ACTIONS(3), 1, sym_comment, ACTIONS(1137), 1, @@ -34056,7 +34150,7 @@ static uint16_t ts_small_parse_table[] = { ACTIONS(1139), 2, anon_sym__, sym_name, - [16144] = 7, + [16183] = 7, ACTIONS(3), 1, sym_comment, ACTIONS(43), 1, @@ -34071,7 +34165,7 @@ static uint16_t ts_small_parse_table[] = { sym_struct_literal, STATE(704), 1, sym_identifier, - [16166] = 6, + [16205] = 6, ACTIONS(3), 1, sym_comment, ACTIONS(1143), 1, @@ -34085,7 +34179,7 @@ static uint16_t ts_small_parse_table[] = { ACTIONS(1139), 2, anon_sym__, sym_name, - [16186] = 7, + [16225] = 7, ACTIONS(3), 1, sym_comment, ACTIONS(43), 1, @@ -34100,7 +34194,7 @@ static uint16_t ts_small_parse_table[] = { sym_field_value, STATE(704), 1, sym_identifier, - [16208] = 3, + [16247] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1145), 1, @@ -34110,18 +34204,18 @@ static uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, anon_sym_RBRACK, anon_sym_DOT_DOT, - [16221] = 4, + [16260] = 4, ACTIONS(3), 1, sym_comment, - STATE(212), 1, + STATE(217), 1, sym_binary_digits, - ACTIONS(421), 2, + ACTIONS(424), 2, anon_sym_0, anon_sym_1, - STATE(168), 2, + STATE(171), 2, sym_binary_digit, aux_sym_binary_digits_repeat1, - [16236] = 5, + [16275] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1148), 1, @@ -34133,7 +34227,7 @@ static uint16_t ts_small_parse_table[] = { ACTIONS(1139), 2, anon_sym__, sym_name, - [16253] = 3, + [16292] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1152), 1, @@ -34143,7 +34237,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, anon_sym_RBRACK, anon_sym_DOT_DOT, - [16266] = 3, + [16305] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1154), 1, @@ -34153,7 +34247,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_DOT, anon_sym_QMARK, - [16279] = 3, + [16318] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1156), 1, @@ -34163,7 +34257,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_DOT, anon_sym_QMARK, - [16292] = 6, + [16331] = 6, ACTIONS(1109), 1, sym_comment, ACTIONS(1158), 1, @@ -34176,18 +34270,18 @@ static uint16_t ts_small_parse_table[] = { sym_named_escape, STATE(784), 1, sym_escape_sequence, - [16311] = 4, + [16350] = 4, ACTIONS(3), 1, sym_comment, STATE(159), 1, sym_binary_digits, - ACTIONS(340), 2, + ACTIONS(347), 2, anon_sym_0, anon_sym_1, - STATE(143), 2, + STATE(144), 2, sym_binary_digit, aux_sym_binary_digits_repeat1, - [16326] = 3, + [16365] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1162), 1, @@ -34197,7 +34291,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_DOT, anon_sym_QMARK, - [16339] = 3, + [16378] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1164), 1, @@ -34207,7 +34301,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_DOT, anon_sym_QMARK, - [16352] = 6, + [16391] = 6, ACTIONS(1109), 1, sym_comment, ACTIONS(1158), 1, @@ -34220,7 +34314,7 @@ static uint16_t ts_small_parse_table[] = { sym_escape_sequence, STATE(785), 1, sym_rune, - [16371] = 3, + [16410] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1166), 1, @@ -34230,7 +34324,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, anon_sym_RBRACK, anon_sym_DOT_DOT, - [16384] = 5, + [16423] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(59), 1, @@ -34241,17 +34335,17 @@ static uint16_t ts_small_parse_table[] = { aux_sym_string_constant_repeat1, STATE(762), 1, sym_string_constant, - [16400] = 4, + [16439] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(954), 1, anon_sym_COLON_COLON, ACTIONS(1170), 1, anon_sym_COLON, - ACTIONS(483), 2, + ACTIONS(494), 2, anon_sym_RBRACE, anon_sym_COMMA, - [16414] = 5, + [16453] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1172), 1, @@ -34262,7 +34356,7 @@ static uint16_t ts_small_parse_table[] = { sym_binding, STATE(575), 1, sym_binding_names, - [16430] = 5, + [16469] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1172), 1, @@ -34273,7 +34367,7 @@ static uint16_t ts_small_parse_table[] = { sym_bindings, STATE(575), 1, sym_binding_names, - [16446] = 5, + [16485] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1174), 1, @@ -34284,10 +34378,10 @@ static uint16_t ts_small_parse_table[] = { sym_binding, STATE(631), 1, sym_binding_names, - [16462] = 5, + [16501] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(483), 1, + ACTIONS(494), 1, anon_sym_LBRACE, ACTIONS(954), 1, anon_sym_COLON_COLON, @@ -34295,7 +34389,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_EQ, ACTIONS(1178), 1, anon_sym_COLON, - [16478] = 5, + [16517] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1172), 1, @@ -34306,7 +34400,7 @@ static uint16_t ts_small_parse_table[] = { sym_binding, STATE(575), 1, sym_binding_names, - [16494] = 5, + [16533] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1172), 1, @@ -34317,7 +34411,7 @@ static uint16_t ts_small_parse_table[] = { sym_binding, STATE(575), 1, sym_binding_names, - [16510] = 5, + [16549] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(59), 1, @@ -34328,7 +34422,7 @@ static uint16_t ts_small_parse_table[] = { aux_sym_string_constant_repeat1, STATE(687), 1, sym_string_constant, - [16526] = 5, + [16565] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(679), 1, @@ -34339,7 +34433,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_QMARK, ACTIONS(1182), 1, anon_sym_DOT, - [16542] = 5, + [16581] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1172), 1, @@ -34350,7 +34444,7 @@ static uint16_t ts_small_parse_table[] = { sym_binding, STATE(575), 1, sym_binding_names, - [16558] = 5, + [16597] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(679), 1, @@ -34361,17 +34455,17 @@ static uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, ACTIONS(1184), 1, anon_sym_DOT, - [16574] = 4, + [16613] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(954), 1, anon_sym_COLON_COLON, ACTIONS(1186), 1, anon_sym_COLON, - ACTIONS(483), 2, + ACTIONS(494), 2, anon_sym_BANG, anon_sym_EQ_GT, - [16588] = 5, + [16627] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1174), 1, @@ -34382,7 +34476,7 @@ static uint16_t ts_small_parse_table[] = { sym_binding, STATE(631), 1, sym_binding_names, - [16604] = 5, + [16643] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1174), 1, @@ -34393,7 +34487,7 @@ static uint16_t ts_small_parse_table[] = { sym_binding, STATE(631), 1, sym_binding_names, - [16620] = 5, + [16659] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1188), 1, @@ -34404,7 +34498,7 @@ static uint16_t ts_small_parse_table[] = { sym_enum_value, STATE(783), 1, sym_enum_values, - [16636] = 5, + [16675] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1174), 1, @@ -34415,7 +34509,7 @@ static uint16_t ts_small_parse_table[] = { sym_binding, STATE(631), 1, sym_binding_names, - [16652] = 5, + [16691] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1172), 1, @@ -34426,17 +34520,17 @@ static uint16_t ts_small_parse_table[] = { sym_bindings, STATE(575), 1, sym_binding_names, - [16668] = 4, + [16707] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(954), 1, anon_sym_COLON_COLON, ACTIONS(1192), 1, anon_sym_COLON, - ACTIONS(483), 2, + ACTIONS(494), 2, anon_sym_RBRACE, anon_sym_COMMA, - [16682] = 5, + [16721] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1174), 1, @@ -34447,7 +34541,7 @@ static uint16_t ts_small_parse_table[] = { sym_binding, STATE(631), 1, sym_binding_names, - [16698] = 5, + [16737] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1127), 1, @@ -34458,7 +34552,7 @@ static uint16_t ts_small_parse_table[] = { sym_constant_bindings, STATE(742), 1, sym_identifier, - [16714] = 5, + [16753] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1127), 1, @@ -34469,7 +34563,7 @@ static uint16_t ts_small_parse_table[] = { sym_identifier, STATE(747), 1, sym_constant_bindings, - [16730] = 5, + [16769] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1127), 1, @@ -34480,7 +34574,7 @@ static uint16_t ts_small_parse_table[] = { sym_type_bindings, STATE(736), 1, sym_identifier, - [16746] = 5, + [16785] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1174), 1, @@ -34491,7 +34585,7 @@ static uint16_t ts_small_parse_table[] = { sym_binding, STATE(631), 1, sym_binding_names, - [16762] = 3, + [16801] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1198), 1, @@ -34499,7 +34593,7 @@ static uint16_t ts_small_parse_table[] = { ACTIONS(1196), 2, anon_sym_let, anon_sym_const, - [16773] = 4, + [16812] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1200), 1, @@ -34508,7 +34602,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE, STATE(516), 1, aux_sym_tagged_types_repeat1, - [16786] = 4, + [16825] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1205), 1, @@ -34517,7 +34611,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_RBRACK, ACTIONS(1209), 1, anon_sym_DOT_DOT_DOT, - [16799] = 4, + [16838] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(59), 1, @@ -34526,7 +34620,7 @@ static uint16_t ts_small_parse_table[] = { aux_sym_string_constant_repeat1, STATE(711), 1, sym_string_constant, - [16812] = 4, + [16851] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(59), 1, @@ -34535,7 +34629,7 @@ static uint16_t ts_small_parse_table[] = { aux_sym_string_constant_repeat1, STATE(707), 1, sym_string_constant, - [16825] = 3, + [16864] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1213), 1, @@ -34543,14 +34637,14 @@ static uint16_t ts_small_parse_table[] = { ACTIONS(1211), 2, anon_sym_SEMI, anon_sym_COMMA, - [16836] = 2, + [16875] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1215), 3, anon_sym_COMMA, anon_sym_RPAREN, anon_sym_DOT_DOT_DOT, - [16845] = 4, + [16884] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(59), 1, @@ -34559,21 +34653,21 @@ static uint16_t ts_small_parse_table[] = { aux_sym_string_constant_repeat1, STATE(748), 1, sym_string_constant, - [16858] = 2, + [16897] = 2, ACTIONS(1109), 1, sym_comment, ACTIONS(1217), 3, anon_sym_BSLASH, anon_sym_DQUOTE, aux_sym_string_char_token1, - [16867] = 2, + [16906] = 2, ACTIONS(1109), 1, sym_comment, ACTIONS(1219), 3, anon_sym_BSLASH, anon_sym_DQUOTE, aux_sym_string_char_token1, - [16876] = 4, + [16915] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1221), 1, @@ -34582,7 +34676,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, ACTIONS(1225), 1, anon_sym_DOT_DOT_DOT, - [16889] = 4, + [16928] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1190), 1, @@ -34591,7 +34685,7 @@ static uint16_t ts_small_parse_table[] = { sym_enum_value, STATE(664), 1, sym_enum_values, - [16902] = 4, + [16941] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1227), 1, @@ -34600,14 +34694,14 @@ static uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, ACTIONS(1231), 1, anon_sym_DOT_DOT_DOT, - [16915] = 2, + [16954] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1233), 3, anon_sym_COMMA, anon_sym_RPAREN, anon_sym_DOT_DOT_DOT, - [16924] = 3, + [16963] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1237), 1, @@ -34615,7 +34709,7 @@ static uint16_t ts_small_parse_table[] = { ACTIONS(1235), 2, anon_sym_SEMI, anon_sym_COMMA, - [16935] = 3, + [16974] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1239), 1, @@ -34623,16 +34717,16 @@ static uint16_t ts_small_parse_table[] = { ACTIONS(1241), 2, anon_sym_RBRACE, anon_sym_COMMA, - [16946] = 4, + [16985] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(483), 1, + ACTIONS(494), 1, anon_sym_SEMI, ACTIONS(1091), 1, anon_sym_COLON_COLON, ACTIONS(1243), 1, anon_sym_EQ, - [16959] = 4, + [16998] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1190), 1, @@ -34641,7 +34735,7 @@ static uint16_t ts_small_parse_table[] = { sym_enum_value, STATE(739), 1, sym_enum_values, - [16972] = 4, + [17011] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(59), 1, @@ -34650,7 +34744,7 @@ static uint16_t ts_small_parse_table[] = { aux_sym_string_constant_repeat1, STATE(642), 1, sym_string_constant, - [16985] = 4, + [17024] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1190), 1, @@ -34659,7 +34753,7 @@ static uint16_t ts_small_parse_table[] = { sym_enum_value, STATE(691), 1, sym_enum_values, - [16998] = 3, + [17037] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1198), 1, @@ -34667,7 +34761,7 @@ static uint16_t ts_small_parse_table[] = { ACTIONS(1245), 2, anon_sym_let, anon_sym_const, - [17009] = 4, + [17048] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1247), 1, @@ -34676,21 +34770,21 @@ static uint16_t ts_small_parse_table[] = { sym_name, STATE(671), 1, sym_name_list, - [17022] = 2, + [17061] = 2, ACTIONS(1109), 1, sym_comment, ACTIONS(1251), 3, anon_sym_BSLASH, anon_sym_DQUOTE, aux_sym_string_char_token1, - [17031] = 2, + [17070] = 2, ACTIONS(1109), 1, sym_comment, ACTIONS(1253), 3, anon_sym_BSLASH, anon_sym_DQUOTE, aux_sym_string_char_token1, - [17040] = 3, + [17079] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1257), 1, @@ -34698,7 +34792,7 @@ static uint16_t ts_small_parse_table[] = { ACTIONS(1255), 2, anon_sym_EQ, anon_sym_COLON, - [17051] = 4, + [17090] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1127), 1, @@ -34707,7 +34801,7 @@ static uint16_t ts_small_parse_table[] = { sym_identifier, STATE(741), 1, sym_type_bindings, - [17064] = 4, + [17103] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1257), 1, @@ -34716,7 +34810,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_EQ, ACTIONS(1261), 1, anon_sym_COLON, - [17077] = 4, + [17116] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(59), 1, @@ -34725,7 +34819,7 @@ static uint16_t ts_small_parse_table[] = { aux_sym_string_constant_repeat1, STATE(732), 1, sym_string_constant, - [17090] = 3, + [17129] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1198), 1, @@ -34733,7 +34827,7 @@ static uint16_t ts_small_parse_table[] = { ACTIONS(1263), 2, anon_sym_let, anon_sym_const, - [17101] = 3, + [17140] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1198), 1, @@ -34741,7 +34835,7 @@ static uint16_t ts_small_parse_table[] = { ACTIONS(1265), 2, anon_sym_let, anon_sym_const, - [17112] = 4, + [17151] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1257), 1, @@ -34750,7 +34844,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_EQ, ACTIONS(1269), 1, anon_sym_COLON, - [17125] = 4, + [17164] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1271), 1, @@ -34759,7 +34853,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE, STATE(516), 1, aux_sym_tagged_types_repeat1, - [17138] = 4, + [17177] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1190), 1, @@ -34768,7 +34862,7 @@ static uint16_t ts_small_parse_table[] = { sym_enum_value, STATE(680), 1, sym_enum_values, - [17151] = 4, + [17190] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(59), 1, @@ -34777,7 +34871,7 @@ static uint16_t ts_small_parse_table[] = { aux_sym_string_constant_repeat1, STATE(696), 1, sym_string_constant, - [17164] = 4, + [17203] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1273), 1, @@ -34786,1510 +34880,1510 @@ static uint16_t ts_small_parse_table[] = { anon_sym_RPAREN, STATE(546), 1, aux_sym_tagged_types_repeat1, - [17177] = 2, + [17216] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1277), 3, anon_sym_COMMA, anon_sym_RPAREN, anon_sym_DOT_DOT_DOT, - [17186] = 2, + [17225] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1279), 3, anon_sym_struct, anon_sym_union, sym_name, - [17195] = 3, + [17234] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1281), 1, anon_sym_RBRACE, ACTIONS(1283), 1, anon_sym_COMMA, - [17205] = 2, + [17244] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1285), 2, anon_sym_SEMI, anon_sym_COMMA, - [17213] = 2, + [17252] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1287), 2, anon_sym_RBRACE, anon_sym_COMMA, - [17221] = 2, + [17260] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1289), 2, anon_sym_RBRACE, anon_sym_COMMA, - [17229] = 3, + [17268] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1291), 1, anon_sym_RBRACK, ACTIONS(1293), 1, anon_sym_DOT_DOT, - [17239] = 2, + [17278] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1295), 2, anon_sym_RBRACE, anon_sym_COMMA, - [17247] = 2, + [17286] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1297), 2, anon_sym_RBRACE, anon_sym_COMMA, - [17255] = 2, + [17294] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1200), 2, anon_sym_RPAREN, anon_sym_PIPE, - [17263] = 3, + [17302] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1299), 1, sym_name, STATE(598), 1, sym_identifier, - [17273] = 3, + [17312] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1301), 1, sym_name, - STATE(177), 1, + STATE(197), 1, sym_identifier, - [17283] = 3, + [17322] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1127), 1, sym_name, STATE(572), 1, sym_identifier, - [17293] = 3, + [17332] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1127), 1, sym_name, STATE(703), 1, sym_identifier, - [17303] = 3, + [17342] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1303), 1, anon_sym_COMMA, ACTIONS(1305), 1, anon_sym_RPAREN, - [17313] = 3, + [17352] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1307), 1, anon_sym_RBRACE, ACTIONS(1309), 1, anon_sym_COMMA, - [17323] = 3, + [17362] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1164), 1, anon_sym_RPAREN, ACTIONS(1311), 1, anon_sym_COMMA, - [17333] = 3, + [17372] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1313), 1, anon_sym_COMMA, ACTIONS(1315), 1, anon_sym_RPAREN, - [17343] = 2, + [17382] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1317), 2, anon_sym_SEMI, anon_sym_COMMA, - [17351] = 3, + [17390] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1319), 1, anon_sym_RBRACE, ACTIONS(1321), 1, anon_sym_COMMA, - [17361] = 3, + [17400] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1323), 1, anon_sym_SEMI, ACTIONS(1325), 1, anon_sym_EQ, - [17371] = 2, + [17410] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1327), 2, anon_sym_RBRACE, anon_sym_COMMA, - [17379] = 3, + [17418] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1329), 1, anon_sym_LPAREN, STATE(611), 1, sym_prototype, - [17389] = 3, + [17428] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1127), 1, sym_name, STATE(588), 1, sym_identifier, - [17399] = 3, + [17438] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1331), 1, anon_sym_SEMI, ACTIONS(1333), 1, anon_sym_RPAREN, - [17409] = 3, + [17448] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1267), 1, anon_sym_EQ, ACTIONS(1269), 1, anon_sym_COLON, - [17419] = 2, + [17458] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1335), 2, anon_sym_RBRACE, anon_sym_COMMA, - [17427] = 3, + [17466] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(988), 1, anon_sym_RPAREN, ACTIONS(1337), 1, anon_sym_SEMI, - [17437] = 3, + [17476] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1340), 1, anon_sym_COMMA, ACTIONS(1342), 1, anon_sym_EQ_GT, - [17447] = 3, + [17486] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1344), 1, anon_sym_RBRACE, ACTIONS(1346), 1, anon_sym_COMMA, - [17457] = 3, + [17496] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1348), 1, anon_sym_LPAREN, STATE(433), 1, sym_conditional_branch, - [17467] = 3, + [17506] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1350), 1, anon_sym_COMMA, ACTIONS(1352), 1, anon_sym_RPAREN, - [17477] = 2, + [17516] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1354), 2, anon_sym_RBRACE, anon_sym_COMMA, - [17485] = 3, + [17524] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1348), 1, anon_sym_LPAREN, STATE(419), 1, sym_conditional_branch, - [17495] = 3, + [17534] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1291), 1, anon_sym_RBRACK, ACTIONS(1356), 1, anon_sym_DOT_DOT, - [17505] = 3, + [17544] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1358), 1, sym_name, STATE(269), 1, sym_identifier, - [17515] = 3, + [17554] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1127), 1, sym_name, STATE(673), 1, sym_identifier, - [17525] = 3, + [17564] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1360), 1, anon_sym_SEMI, ACTIONS(1362), 1, anon_sym_COMMA, - [17535] = 3, + [17574] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1329), 1, anon_sym_LPAREN, STATE(570), 1, sym_prototype, - [17545] = 2, + [17584] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1255), 2, anon_sym_EQ, anon_sym_COLON, - [17553] = 3, + [17592] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1364), 1, anon_sym_COMMA, ACTIONS(1366), 1, anon_sym_RPAREN, - [17563] = 3, + [17602] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1154), 1, anon_sym_RPAREN, ACTIONS(1368), 1, anon_sym_COMMA, - [17573] = 3, + [17612] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1293), 1, anon_sym_DOT_DOT, ACTIONS(1370), 1, anon_sym_RBRACK, - [17583] = 3, + [17622] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1329), 1, anon_sym_LPAREN, STATE(417), 1, sym_prototype, - [17593] = 3, + [17632] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1249), 1, sym_name, STATE(657), 1, sym_name_list, - [17603] = 3, + [17642] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(244), 1, anon_sym_RBRACK, ACTIONS(992), 1, anon_sym_PIPE_PIPE, - [17613] = 3, + [17652] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(145), 1, anon_sym_RPAREN, ACTIONS(1372), 1, anon_sym_COMMA, - [17623] = 2, + [17662] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1374), 2, anon_sym_RBRACE, anon_sym_COMMA, - [17631] = 3, + [17670] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1376), 1, anon_sym_SEMI, ACTIONS(1378), 1, anon_sym_COLON_COLON, - [17641] = 3, + [17680] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1380), 1, anon_sym_LPAREN, STATE(479), 1, sym_conditional_branch, - [17651] = 3, + [17690] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1382), 1, anon_sym_COMMA, ACTIONS(1384), 1, anon_sym_RPAREN, - [17661] = 3, + [17700] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1386), 1, anon_sym_COMMA, ACTIONS(1388), 1, anon_sym_RPAREN, - [17671] = 2, + [17710] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1390), 2, anon_sym_RBRACE, anon_sym_COMMA, - [17679] = 3, + [17718] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1392), 1, anon_sym_LPAREN, STATE(333), 1, sym_prototype, - [17689] = 3, + [17728] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1394), 1, anon_sym_COMMA, ACTIONS(1396), 1, anon_sym_PIPE, - [17699] = 3, + [17738] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(157), 1, anon_sym_RPAREN, ACTIONS(1398), 1, anon_sym_COMMA, - [17709] = 2, + [17748] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1400), 2, anon_sym_RBRACE, anon_sym_COMMA, - [17717] = 3, + [17756] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1402), 1, sym_name, STATE(589), 1, sym_binding_names, - [17727] = 3, + [17766] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(292), 1, anon_sym_RBRACK, ACTIONS(992), 1, anon_sym_PIPE_PIPE, - [17737] = 3, + [17776] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1404), 1, anon_sym_RBRACE, ACTIONS(1406), 1, anon_sym_COMMA, - [17747] = 3, + [17786] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1408), 1, anon_sym_SEMI, ACTIONS(1410), 1, anon_sym_RPAREN, - [17757] = 3, + [17796] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1412), 1, anon_sym_SEMI, ACTIONS(1414), 1, anon_sym_EQ, - [17767] = 3, + [17806] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1358), 1, sym_name, STATE(324), 1, sym_identifier, - [17777] = 3, + [17816] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1148), 1, anon_sym_RPAREN, ACTIONS(1416), 1, anon_sym_COMMA, - [17787] = 3, + [17826] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1418), 1, anon_sym_COMMA, ACTIONS(1420), 1, anon_sym_RPAREN, - [17797] = 2, + [17836] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1422), 2, anon_sym_SEMI, anon_sym_COMMA, - [17805] = 3, + [17844] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1424), 1, anon_sym_SEMI, ACTIONS(1426), 1, anon_sym_COMMA, - [17815] = 3, + [17854] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1428), 1, anon_sym_RBRACE, ACTIONS(1430), 1, anon_sym_COMMA, - [17825] = 3, + [17864] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1432), 1, anon_sym_SEMI, ACTIONS(1434), 1, anon_sym_COMMA, - [17835] = 3, + [17874] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1350), 1, anon_sym_COMMA, ACTIONS(1436), 1, anon_sym_RPAREN, - [17845] = 3, + [17884] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(161), 1, anon_sym_RBRACK, ACTIONS(1438), 1, anon_sym_COMMA, - [17855] = 3, + [17894] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1329), 1, anon_sym_LPAREN, STATE(434), 1, sym_prototype, - [17865] = 3, + [17904] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1440), 1, anon_sym_COMMA, ACTIONS(1442), 1, anon_sym_RPAREN, - [17875] = 3, + [17914] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1127), 1, sym_name, STATE(378), 1, sym_identifier, - [17885] = 3, + [17924] = 3, ACTIONS(1109), 1, sym_comment, ACTIONS(1444), 1, aux_sym_escape_sequence_token1, ACTIONS(1446), 1, aux_sym_named_escape_token1, - [17895] = 3, + [17934] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1448), 1, anon_sym_COMMA, ACTIONS(1450), 1, anon_sym_RPAREN, - [17905] = 2, + [17944] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1452), 2, anon_sym_RBRACE, anon_sym_COMMA, - [17913] = 3, + [17952] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1454), 1, anon_sym_RBRACE, ACTIONS(1456), 1, anon_sym_COMMA, - [17923] = 3, + [17962] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1380), 1, anon_sym_LPAREN, STATE(490), 1, sym_conditional_branch, - [17933] = 2, + [17972] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1458), 2, anon_sym_RBRACE, anon_sym_COMMA, - [17941] = 3, + [17980] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1127), 1, sym_name, STATE(454), 1, sym_identifier, - [17951] = 3, + [17990] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1259), 1, anon_sym_EQ, ACTIONS(1261), 1, anon_sym_COLON, - [17961] = 3, + [18000] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1460), 1, anon_sym_RBRACE, ACTIONS(1462), 1, anon_sym_COMMA, - [17971] = 3, + [18010] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1464), 1, sym_name, STATE(269), 1, sym_identifier, - [17981] = 2, + [18020] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1466), 2, anon_sym_RBRACE, anon_sym_COMMA, - [17989] = 3, + [18028] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1392), 1, anon_sym_LPAREN, STATE(343), 1, sym_prototype, - [17999] = 3, + [18038] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1468), 1, sym_name, STATE(378), 1, sym_identifier, - [18009] = 3, + [18048] = 3, ACTIONS(1109), 1, sym_comment, ACTIONS(1470), 1, aux_sym_escape_sequence_token1, ACTIONS(1472), 1, aux_sym_named_escape_token1, - [18019] = 2, + [18058] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(244), 1, anon_sym_RBRACK, - [18026] = 2, + [18065] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1474), 1, anon_sym_LBRACE, - [18033] = 2, + [18072] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1476), 1, anon_sym_STAR, - [18040] = 2, + [18079] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1478), 1, anon_sym_LBRACE, - [18047] = 2, + [18086] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1480), 1, anon_sym_RPAREN, - [18054] = 2, + [18093] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1482), 1, anon_sym_DQUOTE, - [18061] = 2, + [18100] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1484), 1, anon_sym_RPAREN, - [18068] = 2, + [18107] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1486), 1, anon_sym_RPAREN, - [18075] = 2, + [18114] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1488), 1, anon_sym_RPAREN, - [18082] = 2, + [18121] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1490), 1, anon_sym_STAR, - [18089] = 2, + [18128] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1492), 1, anon_sym_LPAREN, - [18096] = 2, + [18135] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1494), 1, anon_sym_fn, - [18103] = 2, + [18142] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(292), 1, anon_sym_RBRACK, - [18110] = 2, + [18149] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1496), 1, anon_sym_DQUOTE, - [18117] = 2, + [18156] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1498), 1, anon_sym_SEMI, - [18124] = 2, + [18163] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1500), 1, anon_sym_EQ, - [18131] = 2, + [18170] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1502), 1, anon_sym_SEMI, - [18138] = 2, + [18177] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1504), 1, anon_sym_COLON, - [18145] = 2, + [18184] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1506), 1, anon_sym_RPAREN, - [18152] = 2, + [18191] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1508), 1, anon_sym_RBRACE, - [18159] = 2, + [18198] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1510), 1, anon_sym_RPAREN, - [18166] = 2, + [18205] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1512), 1, anon_sym_RPAREN, - [18173] = 2, + [18212] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1514), 1, anon_sym_LBRACE, - [18180] = 2, + [18219] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1516), 1, anon_sym_LPAREN, - [18187] = 2, + [18226] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1518), 1, anon_sym_LBRACE, - [18194] = 2, + [18233] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1520), 1, anon_sym_LPAREN, - [18201] = 2, + [18240] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1522), 1, anon_sym_RBRACE, - [18208] = 2, + [18247] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1524), 1, anon_sym_RBRACE, - [18215] = 2, + [18254] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1526), 1, anon_sym_RBRACE, - [18222] = 2, + [18261] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1352), 1, anon_sym_RPAREN, - [18229] = 2, + [18268] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1528), 1, anon_sym_SEMI, - [18236] = 2, + [18275] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1530), 1, anon_sym_RBRACK, - [18243] = 2, + [18282] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1532), 1, anon_sym_SQUOTE, - [18250] = 2, + [18289] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1534), 1, anon_sym_RBRACE, - [18257] = 2, + [18296] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1536), 1, anon_sym_LPAREN, - [18264] = 2, + [18303] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1538), 1, anon_sym_SEMI, - [18271] = 2, + [18310] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1540), 1, sym_name, - [18278] = 2, + [18317] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1542), 1, anon_sym_LPAREN, - [18285] = 2, + [18324] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1544), 1, anon_sym_LPAREN, - [18292] = 2, + [18331] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1546), 1, anon_sym_LPAREN, - [18299] = 2, + [18338] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1198), 1, anon_sym_assert, - [18306] = 2, + [18345] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1548), 1, anon_sym_LPAREN, - [18313] = 2, + [18352] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1550), 1, anon_sym_RBRACE, - [18320] = 2, + [18359] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1552), 1, anon_sym_RPAREN, - [18327] = 2, + [18366] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1554), 1, anon_sym_LPAREN, - [18334] = 2, + [18373] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1556), 1, anon_sym_LPAREN, - [18341] = 2, + [18380] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1164), 1, anon_sym_RPAREN, - [18348] = 2, + [18387] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1315), 1, anon_sym_RPAREN, - [18355] = 2, + [18394] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1558), 1, sym_name, - [18362] = 2, + [18401] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1305), 1, anon_sym_RPAREN, - [18369] = 2, + [18408] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1560), 1, anon_sym_RPAREN, - [18376] = 2, + [18415] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1562), 1, anon_sym_LPAREN, - [18383] = 2, + [18422] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1564), 1, anon_sym_RPAREN, - [18390] = 2, + [18429] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1566), 1, anon_sym_RBRACE, - [18397] = 2, + [18436] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1568), 1, anon_sym_SEMI, - [18404] = 2, + [18443] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1319), 1, anon_sym_RBRACE, - [18411] = 2, + [18450] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1570), 1, anon_sym_SQUOTE, - [18418] = 2, + [18457] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1572), 1, anon_sym_SQUOTE, - [18425] = 2, + [18464] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1574), 1, anon_sym_RPAREN, - [18432] = 2, + [18471] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1576), 1, anon_sym_RPAREN, - [18439] = 2, + [18478] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1578), 1, anon_sym_RPAREN, - [18446] = 2, + [18485] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1133), 1, sym_name, - [18453] = 2, + [18492] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(177), 1, anon_sym_RBRACK, - [18460] = 2, + [18499] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1580), 1, anon_sym_SQUOTE, - [18467] = 2, + [18506] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1582), 1, anon_sym_EQ, - [18474] = 2, + [18513] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1584), 1, anon_sym_COLON, - [18481] = 2, + [18520] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(471), 1, + ACTIONS(484), 1, anon_sym_LBRACE, - [18488] = 2, + [18527] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1586), 1, anon_sym_RPAREN, - [18495] = 2, + [18534] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1588), 1, anon_sym_RPAREN, - [18502] = 2, + [18541] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1590), 1, anon_sym_RPAREN, - [18509] = 2, + [18548] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1592), 1, anon_sym_RBRACK, - [18516] = 2, + [18555] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1594), 1, sym_name, - [18523] = 2, + [18562] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1596), 1, anon_sym_RPAREN, - [18530] = 2, + [18569] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1598), 1, anon_sym_RPAREN, - [18537] = 2, + [18576] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1600), 1, anon_sym_LBRACE, - [18544] = 2, + [18583] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1602), 1, anon_sym_RBRACE, - [18551] = 2, + [18590] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1604), 1, anon_sym_EQ_GT, - [18558] = 2, + [18597] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1606), 1, anon_sym_EQ_GT, - [18565] = 2, + [18604] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1608), 1, anon_sym_RBRACE, - [18572] = 2, + [18611] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1610), 1, anon_sym_SEMI, - [18579] = 2, + [18618] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1460), 1, anon_sym_RBRACE, - [18586] = 2, + [18625] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1612), 1, anon_sym_LPAREN, - [18593] = 2, + [18632] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1614), 1, anon_sym_LPAREN, - [18600] = 2, + [18639] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1616), 1, anon_sym_RPAREN, - [18607] = 2, + [18646] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1618), 1, anon_sym_RPAREN, - [18614] = 2, + [18653] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1620), 1, anon_sym_RBRACE, - [18621] = 2, + [18660] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1622), 1, ts_builtin_sym_end, - [18628] = 2, + [18667] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(477), 1, + ACTIONS(461), 1, anon_sym_EQ_GT, - [18635] = 2, + [18674] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(290), 1, anon_sym_EQ_GT, - [18642] = 2, + [18681] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1624), 1, anon_sym_RBRACE, - [18649] = 2, + [18688] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1626), 1, anon_sym_RPAREN, - [18656] = 2, + [18695] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1628), 1, anon_sym_RPAREN, - [18663] = 2, + [18702] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1630), 1, anon_sym_for, - [18670] = 2, + [18709] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1632), 1, anon_sym_SEMI, - [18677] = 2, + [18716] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1634), 1, anon_sym_RPAREN, - [18684] = 2, + [18723] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1636), 1, anon_sym_RPAREN, - [18691] = 2, + [18730] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1638), 1, anon_sym_COMMA, - [18698] = 2, + [18737] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1640), 1, anon_sym_SEMI, - [18705] = 2, + [18744] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1642), 1, anon_sym_EQ, - [18712] = 2, + [18751] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1644), 1, anon_sym_fn, - [18719] = 2, + [18758] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1646), 1, anon_sym_RPAREN, - [18726] = 2, + [18765] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1648), 1, anon_sym_RBRACE, - [18733] = 2, + [18772] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1650), 1, anon_sym_RBRACE, - [18740] = 2, + [18779] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1652), 1, anon_sym_SEMI, - [18747] = 2, + [18786] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1654), 1, anon_sym_COLON, - [18754] = 2, + [18793] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1656), 1, anon_sym_RBRACK, - [18761] = 2, + [18800] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1658), 1, anon_sym_LPAREN, - [18768] = 2, + [18807] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1660), 1, anon_sym_RPAREN, - [18775] = 2, + [18814] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1154), 1, anon_sym_RPAREN, - [18782] = 2, + [18821] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1662), 1, anon_sym_SEMI, - [18789] = 2, + [18828] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1664), 1, anon_sym_RPAREN, - [18796] = 2, + [18835] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1666), 1, anon_sym_RBRACE, - [18803] = 2, + [18842] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1668), 1, anon_sym_RPAREN, - [18810] = 2, + [18849] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1670), 1, anon_sym_EQ, - [18817] = 2, + [18856] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1672), 1, anon_sym_LPAREN, - [18824] = 2, + [18863] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1674), 1, anon_sym_RPAREN, - [18831] = 2, + [18870] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1676), 1, anon_sym_COLON, - [18838] = 2, + [18877] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1678), 1, anon_sym_LBRACE, - [18845] = 2, + [18884] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1680), 1, anon_sym_LBRACE, - [18852] = 2, + [18891] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1682), 1, anon_sym_SEMI, - [18859] = 2, + [18898] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1684), 1, anon_sym_RBRACE, - [18866] = 2, + [18905] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1686), 1, anon_sym_SEMI, - [18873] = 2, + [18912] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1688), 1, anon_sym_EQ, - [18880] = 2, + [18919] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1690), 1, anon_sym_RBRACE, - [18887] = 2, + [18926] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1366), 1, anon_sym_RPAREN, - [18894] = 2, + [18933] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(175), 1, anon_sym_RBRACK, - [18901] = 2, + [18940] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1692), 1, anon_sym_RBRACE, - [18908] = 2, + [18947] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1436), 1, anon_sym_RPAREN, - [18915] = 2, + [18954] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1420), 1, anon_sym_RPAREN, - [18922] = 2, + [18961] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1694), 1, anon_sym_RPAREN, - [18929] = 2, + [18968] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1696), 1, anon_sym_RPAREN, - [18936] = 2, + [18975] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1698), 1, anon_sym_RPAREN, - [18943] = 2, + [18982] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1700), 1, anon_sym_fn, - [18950] = 2, + [18989] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1702), 1, anon_sym_SEMI, - [18957] = 2, + [18996] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1704), 1, anon_sym_SEMI, - [18964] = 2, + [19003] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1706), 1, anon_sym_RPAREN, - [18971] = 2, + [19010] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1708), 1, anon_sym_RPAREN, - [18978] = 2, + [19017] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(837), 1, ts_builtin_sym_end, - [18985] = 2, + [19024] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1710), 1, anon_sym_COMMA, - [18992] = 2, + [19031] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1712), 1, anon_sym_RBRACK, - [18999] = 2, + [19038] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1714), 1, anon_sym_RBRACK, - [19006] = 2, + [19045] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1384), 1, anon_sym_RPAREN, - [19013] = 2, + [19052] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1716), 1, anon_sym_RBRACE, - [19020] = 2, + [19059] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1718), 1, anon_sym_RPAREN, - [19027] = 2, + [19066] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1720), 1, ts_builtin_sym_end, - [19034] = 2, + [19073] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1722), 1, anon_sym_RBRACE, - [19041] = 2, + [19080] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1724), 1, anon_sym_SQUOTE, - [19048] = 2, + [19087] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1726), 1, anon_sym_SQUOTE, - [19055] = 2, + [19094] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1728), 1, anon_sym_LPAREN, - [19062] = 2, + [19101] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1730), 1, anon_sym_LPAREN, - [19069] = 2, + [19108] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1732), 1, anon_sym_LBRACE, - [19076] = 2, + [19115] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1734), 1, anon_sym_LBRACE, - [19083] = 2, + [19122] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1736), 1, anon_sym_LBRACE, - [19090] = 2, + [19129] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1738), 1, anon_sym_LPAREN, - [19097] = 2, + [19136] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1740), 1, anon_sym_LBRACE, - [19104] = 2, + [19143] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1742), 1, anon_sym_LPAREN, - [19111] = 2, + [19150] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1744), 1, anon_sym_LPAREN, - [19118] = 2, + [19157] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1746), 1, anon_sym_LPAREN, - [19125] = 2, + [19164] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1748), 1, anon_sym_LPAREN, - [19132] = 2, + [19171] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1750), 1, anon_sym_LPAREN, - [19139] = 2, + [19178] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1752), 1, anon_sym_LPAREN, - [19146] = 2, + [19185] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1754), 1, anon_sym_RPAREN, - [19153] = 2, + [19192] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1756), 1, anon_sym_RPAREN, - [19160] = 2, + [19199] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1758), 1, anon_sym_LPAREN, - [19167] = 2, + [19206] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1760), 1, anon_sym_LPAREN, - [19174] = 2, + [19213] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1762), 1, anon_sym_RPAREN, - [19181] = 2, + [19220] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1764), 1, anon_sym_RPAREN, - [19188] = 2, + [19227] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1766), 1, anon_sym_LPAREN, - [19195] = 2, + [19234] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1768), 1, anon_sym_COMMA, - [19202] = 2, + [19241] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1770), 1, anon_sym_LPAREN, - [19209] = 2, + [19248] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1772), 1, anon_sym_COMMA, - [19216] = 2, + [19255] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1774), 1, anon_sym_LPAREN, - [19223] = 2, + [19262] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1776), 1, anon_sym_LPAREN, - [19230] = 2, + [19269] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1778), 1, anon_sym_assert, - [19237] = 2, + [19276] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1780), 1, anon_sym_LPAREN, - [19244] = 2, + [19283] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1782), 1, anon_sym_for, - [19251] = 2, + [19290] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1784), 1, anon_sym_RPAREN, - [19258] = 2, + [19297] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1786), 1, anon_sym_LPAREN, - [19265] = 2, + [19304] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1454), 1, anon_sym_RBRACE, - [19272] = 2, + [19311] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1788), 1, anon_sym_for, - [19279] = 2, + [19318] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1790), 1, anon_sym_LPAREN, - [19286] = 2, + [19325] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1792), 1, @@ -36302,7 +36396,7 @@ static uint32_t ts_small_parse_table_map[] = { [SMALL_STATE(142)] = 223, [SMALL_STATE(143)] = 359, [SMALL_STATE(144)] = 432, - [SMALL_STATE(145)] = 565, + [SMALL_STATE(145)] = 505, [SMALL_STATE(146)] = 638, [SMALL_STATE(147)] = 711, [SMALL_STATE(148)] = 844, @@ -36321,662 +36415,662 @@ static uint32_t ts_small_parse_table_map[] = { [SMALL_STATE(161)] = 2068, [SMALL_STATE(162)] = 2136, [SMALL_STATE(163)] = 2198, - [SMALL_STATE(164)] = 2274, - [SMALL_STATE(165)] = 2377, - [SMALL_STATE(166)] = 2436, - [SMALL_STATE(167)] = 2503, - [SMALL_STATE(168)] = 2565, - [SMALL_STATE(169)] = 2627, - [SMALL_STATE(170)] = 2727, - [SMALL_STATE(171)] = 2827, - [SMALL_STATE(172)] = 2927, - [SMALL_STATE(173)] = 3027, - [SMALL_STATE(174)] = 3095, - [SMALL_STATE(175)] = 3156, - [SMALL_STATE(176)] = 3223, - [SMALL_STATE(177)] = 3320, - [SMALL_STATE(178)] = 3376, - [SMALL_STATE(179)] = 3432, - [SMALL_STATE(180)] = 3526, - [SMALL_STATE(181)] = 3620, - [SMALL_STATE(182)] = 3714, - [SMALL_STATE(183)] = 3808, - [SMALL_STATE(184)] = 3902, - [SMALL_STATE(185)] = 3996, - [SMALL_STATE(186)] = 4060, - [SMALL_STATE(187)] = 4154, - [SMALL_STATE(188)] = 4248, - [SMALL_STATE(189)] = 4342, - [SMALL_STATE(190)] = 4436, - [SMALL_STATE(191)] = 4530, - [SMALL_STATE(192)] = 4624, - [SMALL_STATE(193)] = 4688, - [SMALL_STATE(194)] = 4744, - [SMALL_STATE(195)] = 4838, - [SMALL_STATE(196)] = 4898, - [SMALL_STATE(197)] = 4992, - [SMALL_STATE(198)] = 5050, - [SMALL_STATE(199)] = 5144, - [SMALL_STATE(200)] = 5204, - [SMALL_STATE(201)] = 5298, - [SMALL_STATE(202)] = 5392, - [SMALL_STATE(203)] = 5486, - [SMALL_STATE(204)] = 5580, - [SMALL_STATE(205)] = 5640, - [SMALL_STATE(206)] = 5731, - [SMALL_STATE(207)] = 5822, - [SMALL_STATE(208)] = 5913, - [SMALL_STATE(209)] = 6004, - [SMALL_STATE(210)] = 6059, - [SMALL_STATE(211)] = 6150, - [SMALL_STATE(212)] = 6241, - [SMALL_STATE(213)] = 6302, - [SMALL_STATE(214)] = 6393, - [SMALL_STATE(215)] = 6484, - [SMALL_STATE(216)] = 6575, - [SMALL_STATE(217)] = 6666, - [SMALL_STATE(218)] = 6757, - [SMALL_STATE(219)] = 6848, - [SMALL_STATE(220)] = 6902, - [SMALL_STATE(221)] = 6960, - [SMALL_STATE(222)] = 7014, - [SMALL_STATE(223)] = 7076, - [SMALL_STATE(224)] = 7130, - [SMALL_STATE(225)] = 7184, - [SMALL_STATE(226)] = 7238, - [SMALL_STATE(227)] = 7292, - [SMALL_STATE(228)] = 7346, - [SMALL_STATE(229)] = 7400, - [SMALL_STATE(230)] = 7454, - [SMALL_STATE(231)] = 7508, - [SMALL_STATE(232)] = 7562, - [SMALL_STATE(233)] = 7616, - [SMALL_STATE(234)] = 7670, - [SMALL_STATE(235)] = 7724, - [SMALL_STATE(236)] = 7778, - [SMALL_STATE(237)] = 7832, - [SMALL_STATE(238)] = 7886, - [SMALL_STATE(239)] = 7940, - [SMALL_STATE(240)] = 7994, - [SMALL_STATE(241)] = 8048, - [SMALL_STATE(242)] = 8102, - [SMALL_STATE(243)] = 8156, - [SMALL_STATE(244)] = 8210, - [SMALL_STATE(245)] = 8264, - [SMALL_STATE(246)] = 8318, - [SMALL_STATE(247)] = 8372, - [SMALL_STATE(248)] = 8426, - [SMALL_STATE(249)] = 8480, - [SMALL_STATE(250)] = 8534, - [SMALL_STATE(251)] = 8588, - [SMALL_STATE(252)] = 8642, - [SMALL_STATE(253)] = 8696, - [SMALL_STATE(254)] = 8754, - [SMALL_STATE(255)] = 8808, - [SMALL_STATE(256)] = 8862, - [SMALL_STATE(257)] = 8916, - [SMALL_STATE(258)] = 8970, - [SMALL_STATE(259)] = 9024, - [SMALL_STATE(260)] = 9078, - [SMALL_STATE(261)] = 9132, - [SMALL_STATE(262)] = 9219, - [SMALL_STATE(263)] = 9306, - [SMALL_STATE(264)] = 9363, - [SMALL_STATE(265)] = 9413, - [SMALL_STATE(266)] = 9469, - [SMALL_STATE(267)] = 9519, - [SMALL_STATE(268)] = 9575, - [SMALL_STATE(269)] = 9628, - [SMALL_STATE(270)] = 9674, - [SMALL_STATE(271)] = 9724, - [SMALL_STATE(272)] = 9776, - [SMALL_STATE(273)] = 9825, - [SMALL_STATE(274)] = 9872, - [SMALL_STATE(275)] = 9921, - [SMALL_STATE(276)] = 9970, - [SMALL_STATE(277)] = 10023, - [SMALL_STATE(278)] = 10067, - [SMALL_STATE(279)] = 10113, - [SMALL_STATE(280)] = 10157, - [SMALL_STATE(281)] = 10201, - [SMALL_STATE(282)] = 10245, - [SMALL_STATE(283)] = 10288, - [SMALL_STATE(284)] = 10331, - [SMALL_STATE(285)] = 10374, - [SMALL_STATE(286)] = 10417, - [SMALL_STATE(287)] = 10462, - [SMALL_STATE(288)] = 10505, - [SMALL_STATE(289)] = 10548, - [SMALL_STATE(290)] = 10599, - [SMALL_STATE(291)] = 10642, - [SMALL_STATE(292)] = 10685, - [SMALL_STATE(293)] = 10728, - [SMALL_STATE(294)] = 10771, - [SMALL_STATE(295)] = 10814, - [SMALL_STATE(296)] = 10857, - [SMALL_STATE(297)] = 10900, - [SMALL_STATE(298)] = 10943, - [SMALL_STATE(299)] = 10986, - [SMALL_STATE(300)] = 11029, - [SMALL_STATE(301)] = 11072, - [SMALL_STATE(302)] = 11115, - [SMALL_STATE(303)] = 11158, - [SMALL_STATE(304)] = 11201, - [SMALL_STATE(305)] = 11244, - [SMALL_STATE(306)] = 11295, - [SMALL_STATE(307)] = 11338, - [SMALL_STATE(308)] = 11381, - [SMALL_STATE(309)] = 11424, - [SMALL_STATE(310)] = 11467, - [SMALL_STATE(311)] = 11510, - [SMALL_STATE(312)] = 11553, - [SMALL_STATE(313)] = 11596, - [SMALL_STATE(314)] = 11643, - [SMALL_STATE(315)] = 11686, - [SMALL_STATE(316)] = 11729, - [SMALL_STATE(317)] = 11772, - [SMALL_STATE(318)] = 11815, - [SMALL_STATE(319)] = 11858, - [SMALL_STATE(320)] = 11901, - [SMALL_STATE(321)] = 11944, - [SMALL_STATE(322)] = 11987, - [SMALL_STATE(323)] = 12030, - [SMALL_STATE(324)] = 12070, - [SMALL_STATE(325)] = 12110, - [SMALL_STATE(326)] = 12150, - [SMALL_STATE(327)] = 12190, - [SMALL_STATE(328)] = 12230, - [SMALL_STATE(329)] = 12272, - [SMALL_STATE(330)] = 12312, - [SMALL_STATE(331)] = 12354, - [SMALL_STATE(332)] = 12394, - [SMALL_STATE(333)] = 12434, - [SMALL_STATE(334)] = 12474, - [SMALL_STATE(335)] = 12514, - [SMALL_STATE(336)] = 12554, - [SMALL_STATE(337)] = 12594, - [SMALL_STATE(338)] = 12634, - [SMALL_STATE(339)] = 12674, - [SMALL_STATE(340)] = 12714, - [SMALL_STATE(341)] = 12754, - [SMALL_STATE(342)] = 12794, - [SMALL_STATE(343)] = 12834, - [SMALL_STATE(344)] = 12874, - [SMALL_STATE(345)] = 12914, - [SMALL_STATE(346)] = 12954, - [SMALL_STATE(347)] = 12994, - [SMALL_STATE(348)] = 13039, - [SMALL_STATE(349)] = 13078, - [SMALL_STATE(350)] = 13117, - [SMALL_STATE(351)] = 13156, - [SMALL_STATE(352)] = 13195, - [SMALL_STATE(353)] = 13234, - [SMALL_STATE(354)] = 13273, - [SMALL_STATE(355)] = 13318, - [SMALL_STATE(356)] = 13359, - [SMALL_STATE(357)] = 13401, - [SMALL_STATE(358)] = 13439, - [SMALL_STATE(359)] = 13474, - [SMALL_STATE(360)] = 13509, - [SMALL_STATE(361)] = 13547, - [SMALL_STATE(362)] = 13607, - [SMALL_STATE(363)] = 13640, - [SMALL_STATE(364)] = 13697, - [SMALL_STATE(365)] = 13754, - [SMALL_STATE(366)] = 13785, - [SMALL_STATE(367)] = 13814, - [SMALL_STATE(368)] = 13845, - [SMALL_STATE(369)] = 13874, - [SMALL_STATE(370)] = 13904, - [SMALL_STATE(371)] = 13952, - [SMALL_STATE(372)] = 13982, - [SMALL_STATE(373)] = 14011, - [SMALL_STATE(374)] = 14040, - [SMALL_STATE(375)] = 14080, - [SMALL_STATE(376)] = 14120, - [SMALL_STATE(377)] = 14150, - [SMALL_STATE(378)] = 14180, - [SMALL_STATE(379)] = 14204, - [SMALL_STATE(380)] = 14229, - [SMALL_STATE(381)] = 14256, - [SMALL_STATE(382)] = 14283, - [SMALL_STATE(383)] = 14308, - [SMALL_STATE(384)] = 14332, - [SMALL_STATE(385)] = 14356, - [SMALL_STATE(386)] = 14379, - [SMALL_STATE(387)] = 14398, - [SMALL_STATE(388)] = 14421, - [SMALL_STATE(389)] = 14444, - [SMALL_STATE(390)] = 14467, - [SMALL_STATE(391)] = 14486, - [SMALL_STATE(392)] = 14509, - [SMALL_STATE(393)] = 14528, - [SMALL_STATE(394)] = 14548, - [SMALL_STATE(395)] = 14570, - [SMALL_STATE(396)] = 14590, - [SMALL_STATE(397)] = 14608, - [SMALL_STATE(398)] = 14628, - [SMALL_STATE(399)] = 14650, - [SMALL_STATE(400)] = 14668, - [SMALL_STATE(401)] = 14688, - [SMALL_STATE(402)] = 14709, - [SMALL_STATE(403)] = 14730, - [SMALL_STATE(404)] = 14751, - [SMALL_STATE(405)] = 14784, - [SMALL_STATE(406)] = 14805, - [SMALL_STATE(407)] = 14828, - [SMALL_STATE(408)] = 14858, - [SMALL_STATE(409)] = 14884, - [SMALL_STATE(410)] = 14914, - [SMALL_STATE(411)] = 14944, - [SMALL_STATE(412)] = 14962, - [SMALL_STATE(413)] = 14982, - [SMALL_STATE(414)] = 15012, - [SMALL_STATE(415)] = 15038, - [SMALL_STATE(416)] = 15056, - [SMALL_STATE(417)] = 15073, - [SMALL_STATE(418)] = 15090, - [SMALL_STATE(419)] = 15107, - [SMALL_STATE(420)] = 15126, - [SMALL_STATE(421)] = 15143, - [SMALL_STATE(422)] = 15160, - [SMALL_STATE(423)] = 15179, - [SMALL_STATE(424)] = 15196, - [SMALL_STATE(425)] = 15213, - [SMALL_STATE(426)] = 15230, - [SMALL_STATE(427)] = 15249, - [SMALL_STATE(428)] = 15266, - [SMALL_STATE(429)] = 15283, - [SMALL_STATE(430)] = 15300, - [SMALL_STATE(431)] = 15317, - [SMALL_STATE(432)] = 15334, - [SMALL_STATE(433)] = 15351, - [SMALL_STATE(434)] = 15370, - [SMALL_STATE(435)] = 15387, - [SMALL_STATE(436)] = 15404, - [SMALL_STATE(437)] = 15421, - [SMALL_STATE(438)] = 15438, - [SMALL_STATE(439)] = 15455, - [SMALL_STATE(440)] = 15472, - [SMALL_STATE(441)] = 15489, - [SMALL_STATE(442)] = 15506, - [SMALL_STATE(443)] = 15523, - [SMALL_STATE(444)] = 15540, - [SMALL_STATE(445)] = 15557, - [SMALL_STATE(446)] = 15574, - [SMALL_STATE(447)] = 15591, - [SMALL_STATE(448)] = 15608, - [SMALL_STATE(449)] = 15625, - [SMALL_STATE(450)] = 15642, - [SMALL_STATE(451)] = 15659, - [SMALL_STATE(452)] = 15676, - [SMALL_STATE(453)] = 15693, - [SMALL_STATE(454)] = 15710, - [SMALL_STATE(455)] = 15727, - [SMALL_STATE(456)] = 15744, - [SMALL_STATE(457)] = 15761, - [SMALL_STATE(458)] = 15777, - [SMALL_STATE(459)] = 15805, - [SMALL_STATE(460)] = 15823, - [SMALL_STATE(461)] = 15851, - [SMALL_STATE(462)] = 15874, - [SMALL_STATE(463)] = 15897, - [SMALL_STATE(464)] = 15920, - [SMALL_STATE(465)] = 15943, - [SMALL_STATE(466)] = 15968, - [SMALL_STATE(467)] = 15990, - [SMALL_STATE(468)] = 16008, - [SMALL_STATE(469)] = 16030, - [SMALL_STATE(470)] = 16042, - [SMALL_STATE(471)] = 16056, - [SMALL_STATE(472)] = 16068, - [SMALL_STATE(473)] = 16090, - [SMALL_STATE(474)] = 16112, - [SMALL_STATE(475)] = 16124, - [SMALL_STATE(476)] = 16144, - [SMALL_STATE(477)] = 16166, - [SMALL_STATE(478)] = 16186, - [SMALL_STATE(479)] = 16208, - [SMALL_STATE(480)] = 16221, - [SMALL_STATE(481)] = 16236, - [SMALL_STATE(482)] = 16253, - [SMALL_STATE(483)] = 16266, - [SMALL_STATE(484)] = 16279, - [SMALL_STATE(485)] = 16292, - [SMALL_STATE(486)] = 16311, - [SMALL_STATE(487)] = 16326, - [SMALL_STATE(488)] = 16339, - [SMALL_STATE(489)] = 16352, - [SMALL_STATE(490)] = 16371, - [SMALL_STATE(491)] = 16384, - [SMALL_STATE(492)] = 16400, - [SMALL_STATE(493)] = 16414, - [SMALL_STATE(494)] = 16430, - [SMALL_STATE(495)] = 16446, - [SMALL_STATE(496)] = 16462, - [SMALL_STATE(497)] = 16478, - [SMALL_STATE(498)] = 16494, - [SMALL_STATE(499)] = 16510, - [SMALL_STATE(500)] = 16526, - [SMALL_STATE(501)] = 16542, - [SMALL_STATE(502)] = 16558, - [SMALL_STATE(503)] = 16574, - [SMALL_STATE(504)] = 16588, - [SMALL_STATE(505)] = 16604, - [SMALL_STATE(506)] = 16620, - [SMALL_STATE(507)] = 16636, - [SMALL_STATE(508)] = 16652, - [SMALL_STATE(509)] = 16668, - [SMALL_STATE(510)] = 16682, - [SMALL_STATE(511)] = 16698, - [SMALL_STATE(512)] = 16714, - [SMALL_STATE(513)] = 16730, - [SMALL_STATE(514)] = 16746, - [SMALL_STATE(515)] = 16762, - [SMALL_STATE(516)] = 16773, - [SMALL_STATE(517)] = 16786, - [SMALL_STATE(518)] = 16799, - [SMALL_STATE(519)] = 16812, - [SMALL_STATE(520)] = 16825, - [SMALL_STATE(521)] = 16836, - [SMALL_STATE(522)] = 16845, - [SMALL_STATE(523)] = 16858, - [SMALL_STATE(524)] = 16867, - [SMALL_STATE(525)] = 16876, - [SMALL_STATE(526)] = 16889, - [SMALL_STATE(527)] = 16902, - [SMALL_STATE(528)] = 16915, - [SMALL_STATE(529)] = 16924, - [SMALL_STATE(530)] = 16935, - [SMALL_STATE(531)] = 16946, - [SMALL_STATE(532)] = 16959, - [SMALL_STATE(533)] = 16972, - [SMALL_STATE(534)] = 16985, - [SMALL_STATE(535)] = 16998, - [SMALL_STATE(536)] = 17009, - [SMALL_STATE(537)] = 17022, - [SMALL_STATE(538)] = 17031, - [SMALL_STATE(539)] = 17040, - [SMALL_STATE(540)] = 17051, - [SMALL_STATE(541)] = 17064, - [SMALL_STATE(542)] = 17077, - [SMALL_STATE(543)] = 17090, - [SMALL_STATE(544)] = 17101, - [SMALL_STATE(545)] = 17112, - [SMALL_STATE(546)] = 17125, - [SMALL_STATE(547)] = 17138, - [SMALL_STATE(548)] = 17151, - [SMALL_STATE(549)] = 17164, - [SMALL_STATE(550)] = 17177, - [SMALL_STATE(551)] = 17186, - [SMALL_STATE(552)] = 17195, - [SMALL_STATE(553)] = 17205, - [SMALL_STATE(554)] = 17213, - [SMALL_STATE(555)] = 17221, - [SMALL_STATE(556)] = 17229, - [SMALL_STATE(557)] = 17239, - [SMALL_STATE(558)] = 17247, - [SMALL_STATE(559)] = 17255, - [SMALL_STATE(560)] = 17263, - [SMALL_STATE(561)] = 17273, - [SMALL_STATE(562)] = 17283, - [SMALL_STATE(563)] = 17293, - [SMALL_STATE(564)] = 17303, - [SMALL_STATE(565)] = 17313, - [SMALL_STATE(566)] = 17323, - [SMALL_STATE(567)] = 17333, - [SMALL_STATE(568)] = 17343, - [SMALL_STATE(569)] = 17351, - [SMALL_STATE(570)] = 17361, - [SMALL_STATE(571)] = 17371, - [SMALL_STATE(572)] = 17379, - [SMALL_STATE(573)] = 17389, - [SMALL_STATE(574)] = 17399, - [SMALL_STATE(575)] = 17409, - [SMALL_STATE(576)] = 17419, - [SMALL_STATE(577)] = 17427, - [SMALL_STATE(578)] = 17437, - [SMALL_STATE(579)] = 17447, - [SMALL_STATE(580)] = 17457, - [SMALL_STATE(581)] = 17467, - [SMALL_STATE(582)] = 17477, - [SMALL_STATE(583)] = 17485, - [SMALL_STATE(584)] = 17495, - [SMALL_STATE(585)] = 17505, - [SMALL_STATE(586)] = 17515, - [SMALL_STATE(587)] = 17525, - [SMALL_STATE(588)] = 17535, - [SMALL_STATE(589)] = 17545, - [SMALL_STATE(590)] = 17553, - [SMALL_STATE(591)] = 17563, - [SMALL_STATE(592)] = 17573, - [SMALL_STATE(593)] = 17583, - [SMALL_STATE(594)] = 17593, - [SMALL_STATE(595)] = 17603, - [SMALL_STATE(596)] = 17613, - [SMALL_STATE(597)] = 17623, - [SMALL_STATE(598)] = 17631, - [SMALL_STATE(599)] = 17641, - [SMALL_STATE(600)] = 17651, - [SMALL_STATE(601)] = 17661, - [SMALL_STATE(602)] = 17671, - [SMALL_STATE(603)] = 17679, - [SMALL_STATE(604)] = 17689, - [SMALL_STATE(605)] = 17699, - [SMALL_STATE(606)] = 17709, - [SMALL_STATE(607)] = 17717, - [SMALL_STATE(608)] = 17727, - [SMALL_STATE(609)] = 17737, - [SMALL_STATE(610)] = 17747, - [SMALL_STATE(611)] = 17757, - [SMALL_STATE(612)] = 17767, - [SMALL_STATE(613)] = 17777, - [SMALL_STATE(614)] = 17787, - [SMALL_STATE(615)] = 17797, - [SMALL_STATE(616)] = 17805, - [SMALL_STATE(617)] = 17815, - [SMALL_STATE(618)] = 17825, - [SMALL_STATE(619)] = 17835, - [SMALL_STATE(620)] = 17845, - [SMALL_STATE(621)] = 17855, - [SMALL_STATE(622)] = 17865, - [SMALL_STATE(623)] = 17875, - [SMALL_STATE(624)] = 17885, - [SMALL_STATE(625)] = 17895, - [SMALL_STATE(626)] = 17905, - [SMALL_STATE(627)] = 17913, - [SMALL_STATE(628)] = 17923, - [SMALL_STATE(629)] = 17933, - [SMALL_STATE(630)] = 17941, - [SMALL_STATE(631)] = 17951, - [SMALL_STATE(632)] = 17961, - [SMALL_STATE(633)] = 17971, - [SMALL_STATE(634)] = 17981, - [SMALL_STATE(635)] = 17989, - [SMALL_STATE(636)] = 17999, - [SMALL_STATE(637)] = 18009, - [SMALL_STATE(638)] = 18019, - [SMALL_STATE(639)] = 18026, - [SMALL_STATE(640)] = 18033, - [SMALL_STATE(641)] = 18040, - [SMALL_STATE(642)] = 18047, - [SMALL_STATE(643)] = 18054, - [SMALL_STATE(644)] = 18061, - [SMALL_STATE(645)] = 18068, - [SMALL_STATE(646)] = 18075, - [SMALL_STATE(647)] = 18082, - [SMALL_STATE(648)] = 18089, - [SMALL_STATE(649)] = 18096, - [SMALL_STATE(650)] = 18103, - [SMALL_STATE(651)] = 18110, - [SMALL_STATE(652)] = 18117, - [SMALL_STATE(653)] = 18124, - [SMALL_STATE(654)] = 18131, - [SMALL_STATE(655)] = 18138, - [SMALL_STATE(656)] = 18145, - [SMALL_STATE(657)] = 18152, - [SMALL_STATE(658)] = 18159, - [SMALL_STATE(659)] = 18166, - [SMALL_STATE(660)] = 18173, - [SMALL_STATE(661)] = 18180, - [SMALL_STATE(662)] = 18187, - [SMALL_STATE(663)] = 18194, - [SMALL_STATE(664)] = 18201, - [SMALL_STATE(665)] = 18208, - [SMALL_STATE(666)] = 18215, - [SMALL_STATE(667)] = 18222, - [SMALL_STATE(668)] = 18229, - [SMALL_STATE(669)] = 18236, - [SMALL_STATE(670)] = 18243, - [SMALL_STATE(671)] = 18250, - [SMALL_STATE(672)] = 18257, - [SMALL_STATE(673)] = 18264, - [SMALL_STATE(674)] = 18271, - [SMALL_STATE(675)] = 18278, - [SMALL_STATE(676)] = 18285, - [SMALL_STATE(677)] = 18292, - [SMALL_STATE(678)] = 18299, - [SMALL_STATE(679)] = 18306, - [SMALL_STATE(680)] = 18313, - [SMALL_STATE(681)] = 18320, - [SMALL_STATE(682)] = 18327, - [SMALL_STATE(683)] = 18334, - [SMALL_STATE(684)] = 18341, - [SMALL_STATE(685)] = 18348, - [SMALL_STATE(686)] = 18355, - [SMALL_STATE(687)] = 18362, - [SMALL_STATE(688)] = 18369, - [SMALL_STATE(689)] = 18376, - [SMALL_STATE(690)] = 18383, - [SMALL_STATE(691)] = 18390, - [SMALL_STATE(692)] = 18397, - [SMALL_STATE(693)] = 18404, - [SMALL_STATE(694)] = 18411, - [SMALL_STATE(695)] = 18418, - [SMALL_STATE(696)] = 18425, - [SMALL_STATE(697)] = 18432, - [SMALL_STATE(698)] = 18439, - [SMALL_STATE(699)] = 18446, - [SMALL_STATE(700)] = 18453, - [SMALL_STATE(701)] = 18460, - [SMALL_STATE(702)] = 18467, - [SMALL_STATE(703)] = 18474, - [SMALL_STATE(704)] = 18481, - [SMALL_STATE(705)] = 18488, - [SMALL_STATE(706)] = 18495, - [SMALL_STATE(707)] = 18502, - [SMALL_STATE(708)] = 18509, - [SMALL_STATE(709)] = 18516, - [SMALL_STATE(710)] = 18523, - [SMALL_STATE(711)] = 18530, - [SMALL_STATE(712)] = 18537, - [SMALL_STATE(713)] = 18544, - [SMALL_STATE(714)] = 18551, - [SMALL_STATE(715)] = 18558, - [SMALL_STATE(716)] = 18565, - [SMALL_STATE(717)] = 18572, - [SMALL_STATE(718)] = 18579, - [SMALL_STATE(719)] = 18586, - [SMALL_STATE(720)] = 18593, - [SMALL_STATE(721)] = 18600, - [SMALL_STATE(722)] = 18607, - [SMALL_STATE(723)] = 18614, - [SMALL_STATE(724)] = 18621, - [SMALL_STATE(725)] = 18628, - [SMALL_STATE(726)] = 18635, - [SMALL_STATE(727)] = 18642, - [SMALL_STATE(728)] = 18649, - [SMALL_STATE(729)] = 18656, - [SMALL_STATE(730)] = 18663, - [SMALL_STATE(731)] = 18670, - [SMALL_STATE(732)] = 18677, - [SMALL_STATE(733)] = 18684, - [SMALL_STATE(734)] = 18691, - [SMALL_STATE(735)] = 18698, - [SMALL_STATE(736)] = 18705, - [SMALL_STATE(737)] = 18712, - [SMALL_STATE(738)] = 18719, - [SMALL_STATE(739)] = 18726, - [SMALL_STATE(740)] = 18733, - [SMALL_STATE(741)] = 18740, - [SMALL_STATE(742)] = 18747, - [SMALL_STATE(743)] = 18754, - [SMALL_STATE(744)] = 18761, - [SMALL_STATE(745)] = 18768, - [SMALL_STATE(746)] = 18775, - [SMALL_STATE(747)] = 18782, - [SMALL_STATE(748)] = 18789, - [SMALL_STATE(749)] = 18796, - [SMALL_STATE(750)] = 18803, - [SMALL_STATE(751)] = 18810, - [SMALL_STATE(752)] = 18817, - [SMALL_STATE(753)] = 18824, - [SMALL_STATE(754)] = 18831, - [SMALL_STATE(755)] = 18838, - [SMALL_STATE(756)] = 18845, - [SMALL_STATE(757)] = 18852, - [SMALL_STATE(758)] = 18859, - [SMALL_STATE(759)] = 18866, - [SMALL_STATE(760)] = 18873, - [SMALL_STATE(761)] = 18880, - [SMALL_STATE(762)] = 18887, - [SMALL_STATE(763)] = 18894, - [SMALL_STATE(764)] = 18901, - [SMALL_STATE(765)] = 18908, - [SMALL_STATE(766)] = 18915, - [SMALL_STATE(767)] = 18922, - [SMALL_STATE(768)] = 18929, - [SMALL_STATE(769)] = 18936, - [SMALL_STATE(770)] = 18943, - [SMALL_STATE(771)] = 18950, - [SMALL_STATE(772)] = 18957, - [SMALL_STATE(773)] = 18964, - [SMALL_STATE(774)] = 18971, - [SMALL_STATE(775)] = 18978, - [SMALL_STATE(776)] = 18985, - [SMALL_STATE(777)] = 18992, - [SMALL_STATE(778)] = 18999, - [SMALL_STATE(779)] = 19006, - [SMALL_STATE(780)] = 19013, - [SMALL_STATE(781)] = 19020, - [SMALL_STATE(782)] = 19027, - [SMALL_STATE(783)] = 19034, - [SMALL_STATE(784)] = 19041, - [SMALL_STATE(785)] = 19048, - [SMALL_STATE(786)] = 19055, - [SMALL_STATE(787)] = 19062, - [SMALL_STATE(788)] = 19069, - [SMALL_STATE(789)] = 19076, - [SMALL_STATE(790)] = 19083, - [SMALL_STATE(791)] = 19090, - [SMALL_STATE(792)] = 19097, - [SMALL_STATE(793)] = 19104, - [SMALL_STATE(794)] = 19111, - [SMALL_STATE(795)] = 19118, - [SMALL_STATE(796)] = 19125, - [SMALL_STATE(797)] = 19132, - [SMALL_STATE(798)] = 19139, - [SMALL_STATE(799)] = 19146, - [SMALL_STATE(800)] = 19153, - [SMALL_STATE(801)] = 19160, - [SMALL_STATE(802)] = 19167, - [SMALL_STATE(803)] = 19174, - [SMALL_STATE(804)] = 19181, - [SMALL_STATE(805)] = 19188, - [SMALL_STATE(806)] = 19195, - [SMALL_STATE(807)] = 19202, - [SMALL_STATE(808)] = 19209, - [SMALL_STATE(809)] = 19216, - [SMALL_STATE(810)] = 19223, - [SMALL_STATE(811)] = 19230, - [SMALL_STATE(812)] = 19237, - [SMALL_STATE(813)] = 19244, - [SMALL_STATE(814)] = 19251, - [SMALL_STATE(815)] = 19258, - [SMALL_STATE(816)] = 19265, - [SMALL_STATE(817)] = 19272, - [SMALL_STATE(818)] = 19279, - [SMALL_STATE(819)] = 19286, + [SMALL_STATE(164)] = 2302, + [SMALL_STATE(165)] = 2378, + [SMALL_STATE(166)] = 2479, + [SMALL_STATE(167)] = 2538, + [SMALL_STATE(168)] = 2639, + [SMALL_STATE(169)] = 2706, + [SMALL_STATE(170)] = 2807, + [SMALL_STATE(171)] = 2908, + [SMALL_STATE(172)] = 2970, + [SMALL_STATE(173)] = 3068, + [SMALL_STATE(174)] = 3136, + [SMALL_STATE(175)] = 3198, + [SMALL_STATE(176)] = 3293, + [SMALL_STATE(177)] = 3388, + [SMALL_STATE(178)] = 3483, + [SMALL_STATE(179)] = 3578, + [SMALL_STATE(180)] = 3673, + [SMALL_STATE(181)] = 3768, + [SMALL_STATE(182)] = 3863, + [SMALL_STATE(183)] = 3958, + [SMALL_STATE(184)] = 4053, + [SMALL_STATE(185)] = 4148, + [SMALL_STATE(186)] = 4209, + [SMALL_STATE(187)] = 4304, + [SMALL_STATE(188)] = 4399, + [SMALL_STATE(189)] = 4494, + [SMALL_STATE(190)] = 4589, + [SMALL_STATE(191)] = 4684, + [SMALL_STATE(192)] = 4779, + [SMALL_STATE(193)] = 4846, + [SMALL_STATE(194)] = 4941, + [SMALL_STATE(195)] = 5036, + [SMALL_STATE(196)] = 5131, + [SMALL_STATE(197)] = 5223, + [SMALL_STATE(198)] = 5279, + [SMALL_STATE(199)] = 5339, + [SMALL_STATE(200)] = 5399, + [SMALL_STATE(201)] = 5455, + [SMALL_STATE(202)] = 5519, + [SMALL_STATE(203)] = 5611, + [SMALL_STATE(204)] = 5703, + [SMALL_STATE(205)] = 5763, + [SMALL_STATE(206)] = 5821, + [SMALL_STATE(207)] = 5913, + [SMALL_STATE(208)] = 6005, + [SMALL_STATE(209)] = 6061, + [SMALL_STATE(210)] = 6153, + [SMALL_STATE(211)] = 6245, + [SMALL_STATE(212)] = 6337, + [SMALL_STATE(213)] = 6429, + [SMALL_STATE(214)] = 6521, + [SMALL_STATE(215)] = 6613, + [SMALL_STATE(216)] = 6677, + [SMALL_STATE(217)] = 6769, + [SMALL_STATE(218)] = 6830, + [SMALL_STATE(219)] = 6885, + [SMALL_STATE(220)] = 6939, + [SMALL_STATE(221)] = 6997, + [SMALL_STATE(222)] = 7051, + [SMALL_STATE(223)] = 7113, + [SMALL_STATE(224)] = 7167, + [SMALL_STATE(225)] = 7221, + [SMALL_STATE(226)] = 7275, + [SMALL_STATE(227)] = 7329, + [SMALL_STATE(228)] = 7383, + [SMALL_STATE(229)] = 7437, + [SMALL_STATE(230)] = 7491, + [SMALL_STATE(231)] = 7545, + [SMALL_STATE(232)] = 7599, + [SMALL_STATE(233)] = 7653, + [SMALL_STATE(234)] = 7707, + [SMALL_STATE(235)] = 7761, + [SMALL_STATE(236)] = 7815, + [SMALL_STATE(237)] = 7869, + [SMALL_STATE(238)] = 7923, + [SMALL_STATE(239)] = 7977, + [SMALL_STATE(240)] = 8031, + [SMALL_STATE(241)] = 8085, + [SMALL_STATE(242)] = 8139, + [SMALL_STATE(243)] = 8193, + [SMALL_STATE(244)] = 8247, + [SMALL_STATE(245)] = 8301, + [SMALL_STATE(246)] = 8355, + [SMALL_STATE(247)] = 8409, + [SMALL_STATE(248)] = 8463, + [SMALL_STATE(249)] = 8517, + [SMALL_STATE(250)] = 8571, + [SMALL_STATE(251)] = 8625, + [SMALL_STATE(252)] = 8679, + [SMALL_STATE(253)] = 8733, + [SMALL_STATE(254)] = 8791, + [SMALL_STATE(255)] = 8845, + [SMALL_STATE(256)] = 8899, + [SMALL_STATE(257)] = 8953, + [SMALL_STATE(258)] = 9007, + [SMALL_STATE(259)] = 9061, + [SMALL_STATE(260)] = 9149, + [SMALL_STATE(261)] = 9203, + [SMALL_STATE(262)] = 9291, + [SMALL_STATE(263)] = 9345, + [SMALL_STATE(264)] = 9402, + [SMALL_STATE(265)] = 9452, + [SMALL_STATE(266)] = 9508, + [SMALL_STATE(267)] = 9558, + [SMALL_STATE(268)] = 9614, + [SMALL_STATE(269)] = 9667, + [SMALL_STATE(270)] = 9713, + [SMALL_STATE(271)] = 9763, + [SMALL_STATE(272)] = 9815, + [SMALL_STATE(273)] = 9864, + [SMALL_STATE(274)] = 9911, + [SMALL_STATE(275)] = 9960, + [SMALL_STATE(276)] = 10009, + [SMALL_STATE(277)] = 10062, + [SMALL_STATE(278)] = 10106, + [SMALL_STATE(279)] = 10152, + [SMALL_STATE(280)] = 10196, + [SMALL_STATE(281)] = 10240, + [SMALL_STATE(282)] = 10284, + [SMALL_STATE(283)] = 10327, + [SMALL_STATE(284)] = 10370, + [SMALL_STATE(285)] = 10413, + [SMALL_STATE(286)] = 10456, + [SMALL_STATE(287)] = 10501, + [SMALL_STATE(288)] = 10544, + [SMALL_STATE(289)] = 10587, + [SMALL_STATE(290)] = 10638, + [SMALL_STATE(291)] = 10681, + [SMALL_STATE(292)] = 10724, + [SMALL_STATE(293)] = 10767, + [SMALL_STATE(294)] = 10810, + [SMALL_STATE(295)] = 10853, + [SMALL_STATE(296)] = 10896, + [SMALL_STATE(297)] = 10939, + [SMALL_STATE(298)] = 10982, + [SMALL_STATE(299)] = 11025, + [SMALL_STATE(300)] = 11068, + [SMALL_STATE(301)] = 11111, + [SMALL_STATE(302)] = 11154, + [SMALL_STATE(303)] = 11197, + [SMALL_STATE(304)] = 11240, + [SMALL_STATE(305)] = 11283, + [SMALL_STATE(306)] = 11334, + [SMALL_STATE(307)] = 11377, + [SMALL_STATE(308)] = 11420, + [SMALL_STATE(309)] = 11463, + [SMALL_STATE(310)] = 11506, + [SMALL_STATE(311)] = 11549, + [SMALL_STATE(312)] = 11592, + [SMALL_STATE(313)] = 11635, + [SMALL_STATE(314)] = 11682, + [SMALL_STATE(315)] = 11725, + [SMALL_STATE(316)] = 11768, + [SMALL_STATE(317)] = 11811, + [SMALL_STATE(318)] = 11854, + [SMALL_STATE(319)] = 11897, + [SMALL_STATE(320)] = 11940, + [SMALL_STATE(321)] = 11983, + [SMALL_STATE(322)] = 12026, + [SMALL_STATE(323)] = 12069, + [SMALL_STATE(324)] = 12109, + [SMALL_STATE(325)] = 12149, + [SMALL_STATE(326)] = 12189, + [SMALL_STATE(327)] = 12229, + [SMALL_STATE(328)] = 12269, + [SMALL_STATE(329)] = 12311, + [SMALL_STATE(330)] = 12351, + [SMALL_STATE(331)] = 12393, + [SMALL_STATE(332)] = 12433, + [SMALL_STATE(333)] = 12473, + [SMALL_STATE(334)] = 12513, + [SMALL_STATE(335)] = 12553, + [SMALL_STATE(336)] = 12593, + [SMALL_STATE(337)] = 12633, + [SMALL_STATE(338)] = 12673, + [SMALL_STATE(339)] = 12713, + [SMALL_STATE(340)] = 12753, + [SMALL_STATE(341)] = 12793, + [SMALL_STATE(342)] = 12833, + [SMALL_STATE(343)] = 12873, + [SMALL_STATE(344)] = 12913, + [SMALL_STATE(345)] = 12953, + [SMALL_STATE(346)] = 12993, + [SMALL_STATE(347)] = 13033, + [SMALL_STATE(348)] = 13078, + [SMALL_STATE(349)] = 13117, + [SMALL_STATE(350)] = 13156, + [SMALL_STATE(351)] = 13195, + [SMALL_STATE(352)] = 13234, + [SMALL_STATE(353)] = 13273, + [SMALL_STATE(354)] = 13312, + [SMALL_STATE(355)] = 13357, + [SMALL_STATE(356)] = 13398, + [SMALL_STATE(357)] = 13440, + [SMALL_STATE(358)] = 13478, + [SMALL_STATE(359)] = 13513, + [SMALL_STATE(360)] = 13548, + [SMALL_STATE(361)] = 13586, + [SMALL_STATE(362)] = 13646, + [SMALL_STATE(363)] = 13679, + [SMALL_STATE(364)] = 13736, + [SMALL_STATE(365)] = 13793, + [SMALL_STATE(366)] = 13824, + [SMALL_STATE(367)] = 13853, + [SMALL_STATE(368)] = 13884, + [SMALL_STATE(369)] = 13913, + [SMALL_STATE(370)] = 13943, + [SMALL_STATE(371)] = 13991, + [SMALL_STATE(372)] = 14021, + [SMALL_STATE(373)] = 14050, + [SMALL_STATE(374)] = 14079, + [SMALL_STATE(375)] = 14119, + [SMALL_STATE(376)] = 14159, + [SMALL_STATE(377)] = 14189, + [SMALL_STATE(378)] = 14219, + [SMALL_STATE(379)] = 14243, + [SMALL_STATE(380)] = 14268, + [SMALL_STATE(381)] = 14295, + [SMALL_STATE(382)] = 14322, + [SMALL_STATE(383)] = 14347, + [SMALL_STATE(384)] = 14371, + [SMALL_STATE(385)] = 14395, + [SMALL_STATE(386)] = 14418, + [SMALL_STATE(387)] = 14437, + [SMALL_STATE(388)] = 14460, + [SMALL_STATE(389)] = 14483, + [SMALL_STATE(390)] = 14506, + [SMALL_STATE(391)] = 14525, + [SMALL_STATE(392)] = 14548, + [SMALL_STATE(393)] = 14567, + [SMALL_STATE(394)] = 14587, + [SMALL_STATE(395)] = 14609, + [SMALL_STATE(396)] = 14629, + [SMALL_STATE(397)] = 14647, + [SMALL_STATE(398)] = 14667, + [SMALL_STATE(399)] = 14689, + [SMALL_STATE(400)] = 14707, + [SMALL_STATE(401)] = 14727, + [SMALL_STATE(402)] = 14748, + [SMALL_STATE(403)] = 14769, + [SMALL_STATE(404)] = 14790, + [SMALL_STATE(405)] = 14823, + [SMALL_STATE(406)] = 14844, + [SMALL_STATE(407)] = 14867, + [SMALL_STATE(408)] = 14897, + [SMALL_STATE(409)] = 14923, + [SMALL_STATE(410)] = 14953, + [SMALL_STATE(411)] = 14983, + [SMALL_STATE(412)] = 15001, + [SMALL_STATE(413)] = 15021, + [SMALL_STATE(414)] = 15051, + [SMALL_STATE(415)] = 15077, + [SMALL_STATE(416)] = 15095, + [SMALL_STATE(417)] = 15112, + [SMALL_STATE(418)] = 15129, + [SMALL_STATE(419)] = 15146, + [SMALL_STATE(420)] = 15165, + [SMALL_STATE(421)] = 15182, + [SMALL_STATE(422)] = 15199, + [SMALL_STATE(423)] = 15218, + [SMALL_STATE(424)] = 15235, + [SMALL_STATE(425)] = 15252, + [SMALL_STATE(426)] = 15269, + [SMALL_STATE(427)] = 15288, + [SMALL_STATE(428)] = 15305, + [SMALL_STATE(429)] = 15322, + [SMALL_STATE(430)] = 15339, + [SMALL_STATE(431)] = 15356, + [SMALL_STATE(432)] = 15373, + [SMALL_STATE(433)] = 15390, + [SMALL_STATE(434)] = 15409, + [SMALL_STATE(435)] = 15426, + [SMALL_STATE(436)] = 15443, + [SMALL_STATE(437)] = 15460, + [SMALL_STATE(438)] = 15477, + [SMALL_STATE(439)] = 15494, + [SMALL_STATE(440)] = 15511, + [SMALL_STATE(441)] = 15528, + [SMALL_STATE(442)] = 15545, + [SMALL_STATE(443)] = 15562, + [SMALL_STATE(444)] = 15579, + [SMALL_STATE(445)] = 15596, + [SMALL_STATE(446)] = 15613, + [SMALL_STATE(447)] = 15630, + [SMALL_STATE(448)] = 15647, + [SMALL_STATE(449)] = 15664, + [SMALL_STATE(450)] = 15681, + [SMALL_STATE(451)] = 15698, + [SMALL_STATE(452)] = 15715, + [SMALL_STATE(453)] = 15732, + [SMALL_STATE(454)] = 15749, + [SMALL_STATE(455)] = 15766, + [SMALL_STATE(456)] = 15783, + [SMALL_STATE(457)] = 15800, + [SMALL_STATE(458)] = 15816, + [SMALL_STATE(459)] = 15844, + [SMALL_STATE(460)] = 15862, + [SMALL_STATE(461)] = 15890, + [SMALL_STATE(462)] = 15913, + [SMALL_STATE(463)] = 15936, + [SMALL_STATE(464)] = 15959, + [SMALL_STATE(465)] = 15982, + [SMALL_STATE(466)] = 16007, + [SMALL_STATE(467)] = 16029, + [SMALL_STATE(468)] = 16047, + [SMALL_STATE(469)] = 16069, + [SMALL_STATE(470)] = 16081, + [SMALL_STATE(471)] = 16095, + [SMALL_STATE(472)] = 16107, + [SMALL_STATE(473)] = 16129, + [SMALL_STATE(474)] = 16151, + [SMALL_STATE(475)] = 16163, + [SMALL_STATE(476)] = 16183, + [SMALL_STATE(477)] = 16205, + [SMALL_STATE(478)] = 16225, + [SMALL_STATE(479)] = 16247, + [SMALL_STATE(480)] = 16260, + [SMALL_STATE(481)] = 16275, + [SMALL_STATE(482)] = 16292, + [SMALL_STATE(483)] = 16305, + [SMALL_STATE(484)] = 16318, + [SMALL_STATE(485)] = 16331, + [SMALL_STATE(486)] = 16350, + [SMALL_STATE(487)] = 16365, + [SMALL_STATE(488)] = 16378, + [SMALL_STATE(489)] = 16391, + [SMALL_STATE(490)] = 16410, + [SMALL_STATE(491)] = 16423, + [SMALL_STATE(492)] = 16439, + [SMALL_STATE(493)] = 16453, + [SMALL_STATE(494)] = 16469, + [SMALL_STATE(495)] = 16485, + [SMALL_STATE(496)] = 16501, + [SMALL_STATE(497)] = 16517, + [SMALL_STATE(498)] = 16533, + [SMALL_STATE(499)] = 16549, + [SMALL_STATE(500)] = 16565, + [SMALL_STATE(501)] = 16581, + [SMALL_STATE(502)] = 16597, + [SMALL_STATE(503)] = 16613, + [SMALL_STATE(504)] = 16627, + [SMALL_STATE(505)] = 16643, + [SMALL_STATE(506)] = 16659, + [SMALL_STATE(507)] = 16675, + [SMALL_STATE(508)] = 16691, + [SMALL_STATE(509)] = 16707, + [SMALL_STATE(510)] = 16721, + [SMALL_STATE(511)] = 16737, + [SMALL_STATE(512)] = 16753, + [SMALL_STATE(513)] = 16769, + [SMALL_STATE(514)] = 16785, + [SMALL_STATE(515)] = 16801, + [SMALL_STATE(516)] = 16812, + [SMALL_STATE(517)] = 16825, + [SMALL_STATE(518)] = 16838, + [SMALL_STATE(519)] = 16851, + [SMALL_STATE(520)] = 16864, + [SMALL_STATE(521)] = 16875, + [SMALL_STATE(522)] = 16884, + [SMALL_STATE(523)] = 16897, + [SMALL_STATE(524)] = 16906, + [SMALL_STATE(525)] = 16915, + [SMALL_STATE(526)] = 16928, + [SMALL_STATE(527)] = 16941, + [SMALL_STATE(528)] = 16954, + [SMALL_STATE(529)] = 16963, + [SMALL_STATE(530)] = 16974, + [SMALL_STATE(531)] = 16985, + [SMALL_STATE(532)] = 16998, + [SMALL_STATE(533)] = 17011, + [SMALL_STATE(534)] = 17024, + [SMALL_STATE(535)] = 17037, + [SMALL_STATE(536)] = 17048, + [SMALL_STATE(537)] = 17061, + [SMALL_STATE(538)] = 17070, + [SMALL_STATE(539)] = 17079, + [SMALL_STATE(540)] = 17090, + [SMALL_STATE(541)] = 17103, + [SMALL_STATE(542)] = 17116, + [SMALL_STATE(543)] = 17129, + [SMALL_STATE(544)] = 17140, + [SMALL_STATE(545)] = 17151, + [SMALL_STATE(546)] = 17164, + [SMALL_STATE(547)] = 17177, + [SMALL_STATE(548)] = 17190, + [SMALL_STATE(549)] = 17203, + [SMALL_STATE(550)] = 17216, + [SMALL_STATE(551)] = 17225, + [SMALL_STATE(552)] = 17234, + [SMALL_STATE(553)] = 17244, + [SMALL_STATE(554)] = 17252, + [SMALL_STATE(555)] = 17260, + [SMALL_STATE(556)] = 17268, + [SMALL_STATE(557)] = 17278, + [SMALL_STATE(558)] = 17286, + [SMALL_STATE(559)] = 17294, + [SMALL_STATE(560)] = 17302, + [SMALL_STATE(561)] = 17312, + [SMALL_STATE(562)] = 17322, + [SMALL_STATE(563)] = 17332, + [SMALL_STATE(564)] = 17342, + [SMALL_STATE(565)] = 17352, + [SMALL_STATE(566)] = 17362, + [SMALL_STATE(567)] = 17372, + [SMALL_STATE(568)] = 17382, + [SMALL_STATE(569)] = 17390, + [SMALL_STATE(570)] = 17400, + [SMALL_STATE(571)] = 17410, + [SMALL_STATE(572)] = 17418, + [SMALL_STATE(573)] = 17428, + [SMALL_STATE(574)] = 17438, + [SMALL_STATE(575)] = 17448, + [SMALL_STATE(576)] = 17458, + [SMALL_STATE(577)] = 17466, + [SMALL_STATE(578)] = 17476, + [SMALL_STATE(579)] = 17486, + [SMALL_STATE(580)] = 17496, + [SMALL_STATE(581)] = 17506, + [SMALL_STATE(582)] = 17516, + [SMALL_STATE(583)] = 17524, + [SMALL_STATE(584)] = 17534, + [SMALL_STATE(585)] = 17544, + [SMALL_STATE(586)] = 17554, + [SMALL_STATE(587)] = 17564, + [SMALL_STATE(588)] = 17574, + [SMALL_STATE(589)] = 17584, + [SMALL_STATE(590)] = 17592, + [SMALL_STATE(591)] = 17602, + [SMALL_STATE(592)] = 17612, + [SMALL_STATE(593)] = 17622, + [SMALL_STATE(594)] = 17632, + [SMALL_STATE(595)] = 17642, + [SMALL_STATE(596)] = 17652, + [SMALL_STATE(597)] = 17662, + [SMALL_STATE(598)] = 17670, + [SMALL_STATE(599)] = 17680, + [SMALL_STATE(600)] = 17690, + [SMALL_STATE(601)] = 17700, + [SMALL_STATE(602)] = 17710, + [SMALL_STATE(603)] = 17718, + [SMALL_STATE(604)] = 17728, + [SMALL_STATE(605)] = 17738, + [SMALL_STATE(606)] = 17748, + [SMALL_STATE(607)] = 17756, + [SMALL_STATE(608)] = 17766, + [SMALL_STATE(609)] = 17776, + [SMALL_STATE(610)] = 17786, + [SMALL_STATE(611)] = 17796, + [SMALL_STATE(612)] = 17806, + [SMALL_STATE(613)] = 17816, + [SMALL_STATE(614)] = 17826, + [SMALL_STATE(615)] = 17836, + [SMALL_STATE(616)] = 17844, + [SMALL_STATE(617)] = 17854, + [SMALL_STATE(618)] = 17864, + [SMALL_STATE(619)] = 17874, + [SMALL_STATE(620)] = 17884, + [SMALL_STATE(621)] = 17894, + [SMALL_STATE(622)] = 17904, + [SMALL_STATE(623)] = 17914, + [SMALL_STATE(624)] = 17924, + [SMALL_STATE(625)] = 17934, + [SMALL_STATE(626)] = 17944, + [SMALL_STATE(627)] = 17952, + [SMALL_STATE(628)] = 17962, + [SMALL_STATE(629)] = 17972, + [SMALL_STATE(630)] = 17980, + [SMALL_STATE(631)] = 17990, + [SMALL_STATE(632)] = 18000, + [SMALL_STATE(633)] = 18010, + [SMALL_STATE(634)] = 18020, + [SMALL_STATE(635)] = 18028, + [SMALL_STATE(636)] = 18038, + [SMALL_STATE(637)] = 18048, + [SMALL_STATE(638)] = 18058, + [SMALL_STATE(639)] = 18065, + [SMALL_STATE(640)] = 18072, + [SMALL_STATE(641)] = 18079, + [SMALL_STATE(642)] = 18086, + [SMALL_STATE(643)] = 18093, + [SMALL_STATE(644)] = 18100, + [SMALL_STATE(645)] = 18107, + [SMALL_STATE(646)] = 18114, + [SMALL_STATE(647)] = 18121, + [SMALL_STATE(648)] = 18128, + [SMALL_STATE(649)] = 18135, + [SMALL_STATE(650)] = 18142, + [SMALL_STATE(651)] = 18149, + [SMALL_STATE(652)] = 18156, + [SMALL_STATE(653)] = 18163, + [SMALL_STATE(654)] = 18170, + [SMALL_STATE(655)] = 18177, + [SMALL_STATE(656)] = 18184, + [SMALL_STATE(657)] = 18191, + [SMALL_STATE(658)] = 18198, + [SMALL_STATE(659)] = 18205, + [SMALL_STATE(660)] = 18212, + [SMALL_STATE(661)] = 18219, + [SMALL_STATE(662)] = 18226, + [SMALL_STATE(663)] = 18233, + [SMALL_STATE(664)] = 18240, + [SMALL_STATE(665)] = 18247, + [SMALL_STATE(666)] = 18254, + [SMALL_STATE(667)] = 18261, + [SMALL_STATE(668)] = 18268, + [SMALL_STATE(669)] = 18275, + [SMALL_STATE(670)] = 18282, + [SMALL_STATE(671)] = 18289, + [SMALL_STATE(672)] = 18296, + [SMALL_STATE(673)] = 18303, + [SMALL_STATE(674)] = 18310, + [SMALL_STATE(675)] = 18317, + [SMALL_STATE(676)] = 18324, + [SMALL_STATE(677)] = 18331, + [SMALL_STATE(678)] = 18338, + [SMALL_STATE(679)] = 18345, + [SMALL_STATE(680)] = 18352, + [SMALL_STATE(681)] = 18359, + [SMALL_STATE(682)] = 18366, + [SMALL_STATE(683)] = 18373, + [SMALL_STATE(684)] = 18380, + [SMALL_STATE(685)] = 18387, + [SMALL_STATE(686)] = 18394, + [SMALL_STATE(687)] = 18401, + [SMALL_STATE(688)] = 18408, + [SMALL_STATE(689)] = 18415, + [SMALL_STATE(690)] = 18422, + [SMALL_STATE(691)] = 18429, + [SMALL_STATE(692)] = 18436, + [SMALL_STATE(693)] = 18443, + [SMALL_STATE(694)] = 18450, + [SMALL_STATE(695)] = 18457, + [SMALL_STATE(696)] = 18464, + [SMALL_STATE(697)] = 18471, + [SMALL_STATE(698)] = 18478, + [SMALL_STATE(699)] = 18485, + [SMALL_STATE(700)] = 18492, + [SMALL_STATE(701)] = 18499, + [SMALL_STATE(702)] = 18506, + [SMALL_STATE(703)] = 18513, + [SMALL_STATE(704)] = 18520, + [SMALL_STATE(705)] = 18527, + [SMALL_STATE(706)] = 18534, + [SMALL_STATE(707)] = 18541, + [SMALL_STATE(708)] = 18548, + [SMALL_STATE(709)] = 18555, + [SMALL_STATE(710)] = 18562, + [SMALL_STATE(711)] = 18569, + [SMALL_STATE(712)] = 18576, + [SMALL_STATE(713)] = 18583, + [SMALL_STATE(714)] = 18590, + [SMALL_STATE(715)] = 18597, + [SMALL_STATE(716)] = 18604, + [SMALL_STATE(717)] = 18611, + [SMALL_STATE(718)] = 18618, + [SMALL_STATE(719)] = 18625, + [SMALL_STATE(720)] = 18632, + [SMALL_STATE(721)] = 18639, + [SMALL_STATE(722)] = 18646, + [SMALL_STATE(723)] = 18653, + [SMALL_STATE(724)] = 18660, + [SMALL_STATE(725)] = 18667, + [SMALL_STATE(726)] = 18674, + [SMALL_STATE(727)] = 18681, + [SMALL_STATE(728)] = 18688, + [SMALL_STATE(729)] = 18695, + [SMALL_STATE(730)] = 18702, + [SMALL_STATE(731)] = 18709, + [SMALL_STATE(732)] = 18716, + [SMALL_STATE(733)] = 18723, + [SMALL_STATE(734)] = 18730, + [SMALL_STATE(735)] = 18737, + [SMALL_STATE(736)] = 18744, + [SMALL_STATE(737)] = 18751, + [SMALL_STATE(738)] = 18758, + [SMALL_STATE(739)] = 18765, + [SMALL_STATE(740)] = 18772, + [SMALL_STATE(741)] = 18779, + [SMALL_STATE(742)] = 18786, + [SMALL_STATE(743)] = 18793, + [SMALL_STATE(744)] = 18800, + [SMALL_STATE(745)] = 18807, + [SMALL_STATE(746)] = 18814, + [SMALL_STATE(747)] = 18821, + [SMALL_STATE(748)] = 18828, + [SMALL_STATE(749)] = 18835, + [SMALL_STATE(750)] = 18842, + [SMALL_STATE(751)] = 18849, + [SMALL_STATE(752)] = 18856, + [SMALL_STATE(753)] = 18863, + [SMALL_STATE(754)] = 18870, + [SMALL_STATE(755)] = 18877, + [SMALL_STATE(756)] = 18884, + [SMALL_STATE(757)] = 18891, + [SMALL_STATE(758)] = 18898, + [SMALL_STATE(759)] = 18905, + [SMALL_STATE(760)] = 18912, + [SMALL_STATE(761)] = 18919, + [SMALL_STATE(762)] = 18926, + [SMALL_STATE(763)] = 18933, + [SMALL_STATE(764)] = 18940, + [SMALL_STATE(765)] = 18947, + [SMALL_STATE(766)] = 18954, + [SMALL_STATE(767)] = 18961, + [SMALL_STATE(768)] = 18968, + [SMALL_STATE(769)] = 18975, + [SMALL_STATE(770)] = 18982, + [SMALL_STATE(771)] = 18989, + [SMALL_STATE(772)] = 18996, + [SMALL_STATE(773)] = 19003, + [SMALL_STATE(774)] = 19010, + [SMALL_STATE(775)] = 19017, + [SMALL_STATE(776)] = 19024, + [SMALL_STATE(777)] = 19031, + [SMALL_STATE(778)] = 19038, + [SMALL_STATE(779)] = 19045, + [SMALL_STATE(780)] = 19052, + [SMALL_STATE(781)] = 19059, + [SMALL_STATE(782)] = 19066, + [SMALL_STATE(783)] = 19073, + [SMALL_STATE(784)] = 19080, + [SMALL_STATE(785)] = 19087, + [SMALL_STATE(786)] = 19094, + [SMALL_STATE(787)] = 19101, + [SMALL_STATE(788)] = 19108, + [SMALL_STATE(789)] = 19115, + [SMALL_STATE(790)] = 19122, + [SMALL_STATE(791)] = 19129, + [SMALL_STATE(792)] = 19136, + [SMALL_STATE(793)] = 19143, + [SMALL_STATE(794)] = 19150, + [SMALL_STATE(795)] = 19157, + [SMALL_STATE(796)] = 19164, + [SMALL_STATE(797)] = 19171, + [SMALL_STATE(798)] = 19178, + [SMALL_STATE(799)] = 19185, + [SMALL_STATE(800)] = 19192, + [SMALL_STATE(801)] = 19199, + [SMALL_STATE(802)] = 19206, + [SMALL_STATE(803)] = 19213, + [SMALL_STATE(804)] = 19220, + [SMALL_STATE(805)] = 19227, + [SMALL_STATE(806)] = 19234, + [SMALL_STATE(807)] = 19241, + [SMALL_STATE(808)] = 19248, + [SMALL_STATE(809)] = 19255, + [SMALL_STATE(810)] = 19262, + [SMALL_STATE(811)] = 19269, + [SMALL_STATE(812)] = 19276, + [SMALL_STATE(813)] = 19283, + [SMALL_STATE(814)] = 19290, + [SMALL_STATE(815)] = 19297, + [SMALL_STATE(816)] = 19304, + [SMALL_STATE(817)] = 19311, + [SMALL_STATE(818)] = 19318, + [SMALL_STATE(819)] = 19325, }; static TSParseActionEntry ts_parse_actions[] = { @@ -37029,7 +37123,7 @@ static TSParseActionEntry ts_parse_actions[] = { [91] = {.entry = {.count = 1, .reusable = false}}, SHIFT(58), [93] = {.entry = {.count = 1, .reusable = false}}, SHIFT(406), [95] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2), - [97] = {.entry = {.count = 1, .reusable = false}}, SHIFT(197), + [97] = {.entry = {.count = 1, .reusable = false}}, SHIFT(205), [99] = {.entry = {.count = 1, .reusable = false}}, SHIFT(507), [101] = {.entry = {.count = 1, .reusable = true}}, SHIFT(138), [103] = {.entry = {.count = 1, .reusable = false}}, SHIFT(535), @@ -37071,7 +37165,7 @@ static TSParseActionEntry ts_parse_actions[] = { [175] = {.entry = {.count = 1, .reusable = true}}, SHIFT(280), [177] = {.entry = {.count = 1, .reusable = true}}, SHIFT(237), [179] = {.entry = {.count = 1, .reusable = true}}, SHIFT(127), - [181] = {.entry = {.count = 1, .reusable = true}}, SHIFT(215), + [181] = {.entry = {.count = 1, .reusable = true}}, SHIFT(212), [183] = {.entry = {.count = 1, .reusable = false}}, SHIFT(650), [185] = {.entry = {.count = 1, .reusable = false}}, SHIFT(678), [187] = {.entry = {.count = 1, .reusable = false}}, SHIFT(273), @@ -37080,7 +37174,7 @@ static TSParseActionEntry ts_parse_actions[] = { [193] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_hex_digits_repeat1, 2), SHIFT_REPEAT(107), [196] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_hex_digits_repeat1, 2), SHIFT_REPEAT(107), [199] = {.entry = {.count = 1, .reusable = true}}, SHIFT(122), - [201] = {.entry = {.count = 1, .reusable = true}}, SHIFT(217), + [201] = {.entry = {.count = 1, .reusable = true}}, SHIFT(211), [203] = {.entry = {.count = 1, .reusable = false}}, SHIFT(638), [205] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_hex_digits, 1), [207] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_hex_digits, 1), @@ -37103,7 +37197,7 @@ static TSParseActionEntry ts_parse_actions[] = { [244] = {.entry = {.count = 1, .reusable = true}}, SHIFT(216), [246] = {.entry = {.count = 1, .reusable = true}}, SHIFT(31), [248] = {.entry = {.count = 1, .reusable = true}}, SHIFT(134), - [250] = {.entry = {.count = 1, .reusable = false}}, SHIFT(259), + [250] = {.entry = {.count = 1, .reusable = false}}, SHIFT(260), [252] = {.entry = {.count = 1, .reusable = false}}, SHIFT(791), [254] = {.entry = {.count = 1, .reusable = false}}, SHIFT(792), [256] = {.entry = {.count = 1, .reusable = true}}, SHIFT(21), @@ -37124,12 +37218,12 @@ static TSParseActionEntry ts_parse_actions[] = { [286] = {.entry = {.count = 1, .reusable = false}}, SHIFT(798), [288] = {.entry = {.count = 1, .reusable = true}}, SHIFT(150), [290] = {.entry = {.count = 1, .reusable = true}}, SHIFT(54), - [292] = {.entry = {.count = 1, .reusable = true}}, SHIFT(211), + [292] = {.entry = {.count = 1, .reusable = true}}, SHIFT(210), [294] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_octal_digits_repeat1, 2), [296] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_octal_digits_repeat1, 2), [298] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_octal_digits_repeat1, 2), SHIFT_REPEAT(139), [301] = {.entry = {.count = 1, .reusable = true}}, SHIFT(131), - [303] = {.entry = {.count = 1, .reusable = true}}, SHIFT(144), + [303] = {.entry = {.count = 1, .reusable = true}}, SHIFT(145), [305] = {.entry = {.count = 1, .reusable = false}}, SHIFT(457), [307] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_octal_digits, 1), [309] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_octal_digits, 1), @@ -37138,92 +37232,92 @@ static TSParseActionEntry ts_parse_actions[] = { [315] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_octal_digit, 1), [317] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_integer_constant, 1), [319] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_integer_constant, 1), - [321] = {.entry = {.count = 1, .reusable = true}}, SHIFT(260), + [321] = {.entry = {.count = 1, .reusable = true}}, SHIFT(262), [323] = {.entry = {.count = 1, .reusable = true}}, SHIFT(251), [325] = {.entry = {.count = 1, .reusable = false}}, SHIFT(385), - [327] = {.entry = {.count = 1, .reusable = false}}, SHIFT(260), + [327] = {.entry = {.count = 1, .reusable = false}}, SHIFT(262), [329] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_integer_constant, 1), SHIFT(387), - [332] = {.entry = {.count = 1, .reusable = true}}, SHIFT(136), - [334] = {.entry = {.count = 1, .reusable = true}}, SHIFT(135), - [336] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_binary_digits, 1), - [338] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_binary_digits, 1), - [340] = {.entry = {.count = 1, .reusable = true}}, SHIFT(156), - [342] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_binary_digits_repeat1, 2), - [344] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_binary_digits_repeat1, 2), - [346] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_binary_digits_repeat1, 2), SHIFT_REPEAT(156), + [332] = {.entry = {.count = 1, .reusable = true}}, SHIFT(135), + [334] = {.entry = {.count = 1, .reusable = true}}, SHIFT(136), + [336] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_binary_digits_repeat1, 2), + [338] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_binary_digits_repeat1, 2), + [340] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_binary_digits_repeat1, 2), SHIFT_REPEAT(157), + [343] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_binary_digits, 1), + [345] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_binary_digits, 1), + [347] = {.entry = {.count = 1, .reusable = true}}, SHIFT(157), [349] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_decimal_digits_repeat1, 2), SHIFT_REPEAT(158), [352] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_integer_constant, 2), [354] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_integer_constant, 2), - [356] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_binary_digit, 1), - [358] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_binary_digit, 1), - [360] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_exponent, 2), - [362] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_exponent, 2), + [356] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_exponent, 2), + [358] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_exponent, 2), + [360] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_binary_digit, 1), + [362] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_binary_digit, 1), [364] = {.entry = {.count = 1, .reusable = true}}, SHIFT(162), [366] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_octal_digits_repeat1, 2), SHIFT_REPEAT(162), - [369] = {.entry = {.count = 1, .reusable = true}}, SHIFT(285), - [371] = {.entry = {.count = 1, .reusable = true}}, SHIFT(288), - [373] = {.entry = {.count = 1, .reusable = false}}, SHIFT(388), - [375] = {.entry = {.count = 1, .reusable = false}}, SHIFT(285), - [377] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_integer_constant, 1), SHIFT(389), - [380] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_cases, 2), - [382] = {.entry = {.count = 1, .reusable = false}}, SHIFT(261), - [384] = {.entry = {.count = 1, .reusable = true}}, SHIFT(172), - [386] = {.entry = {.count = 1, .reusable = false}}, SHIFT(621), - [388] = {.entry = {.count = 1, .reusable = false}}, SHIFT(424), - [390] = {.entry = {.count = 1, .reusable = false}}, SHIFT(411), - [392] = {.entry = {.count = 1, .reusable = false}}, SHIFT(420), - [394] = {.entry = {.count = 1, .reusable = false}}, SHIFT(380), - [396] = {.entry = {.count = 1, .reusable = true}}, SHIFT(187), - [398] = {.entry = {.count = 1, .reusable = false}}, SHIFT(647), - [400] = {.entry = {.count = 1, .reusable = false}}, SHIFT(641), - [402] = {.entry = {.count = 1, .reusable = false}}, SHIFT(639), - [404] = {.entry = {.count = 1, .reusable = true}}, SHIFT(105), - [406] = {.entry = {.count = 1, .reusable = true}}, SHIFT(630), - [408] = {.entry = {.count = 1, .reusable = false}}, SHIFT(503), - [410] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assignment_op, 1), - [412] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assignment_op, 1), - [414] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_floating_constant, 3), - [416] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_floating_constant, 3), - [418] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_binary_digits_repeat1, 2), SHIFT_REPEAT(178), - [421] = {.entry = {.count = 1, .reusable = true}}, SHIFT(178), - [423] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tuple_types, 4), - [425] = {.entry = {.count = 1, .reusable = true}}, SHIFT(218), - [427] = {.entry = {.count = 1, .reusable = false}}, SHIFT(391), - [429] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_floating_constant, 4), - [431] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_floating_constant, 4), - [433] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_identifier, 3), - [435] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_identifier, 3), - [437] = {.entry = {.count = 1, .reusable = false}}, SHIFT(262), - [439] = {.entry = {.count = 1, .reusable = true}}, SHIFT(171), - [441] = {.entry = {.count = 1, .reusable = false}}, SHIFT(635), - [443] = {.entry = {.count = 1, .reusable = false}}, SHIFT(327), - [445] = {.entry = {.count = 1, .reusable = false}}, SHIFT(325), - [447] = {.entry = {.count = 1, .reusable = false}}, SHIFT(344), - [449] = {.entry = {.count = 1, .reusable = false}}, SHIFT(381), - [451] = {.entry = {.count = 1, .reusable = true}}, SHIFT(208), - [453] = {.entry = {.count = 1, .reusable = false}}, SHIFT(640), - [455] = {.entry = {.count = 1, .reusable = false}}, SHIFT(788), - [457] = {.entry = {.count = 1, .reusable = false}}, SHIFT(789), - [459] = {.entry = {.count = 1, .reusable = true}}, SHIFT(103), - [461] = {.entry = {.count = 1, .reusable = true}}, SHIFT(612), - [463] = {.entry = {.count = 1, .reusable = false}}, SHIFT(322), - [465] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_object_selector, 1), - [467] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_object_selector, 1), - [469] = {.entry = {.count = 1, .reusable = true}}, SHIFT(686), - [471] = {.entry = {.count = 1, .reusable = true}}, SHIFT(458), - [473] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_plain_expression, 1), - [475] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_plain_expression, 1), - [477] = {.entry = {.count = 1, .reusable = true}}, SHIFT(57), - [479] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_string_constant, 1), - [481] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_string_constant, 1), - [483] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_identifier, 1), - [485] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_identifier, 1), - [487] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_identifier, 1), SHIFT(561), + [369] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_cases, 2), + [371] = {.entry = {.count = 1, .reusable = false}}, SHIFT(259), + [373] = {.entry = {.count = 1, .reusable = true}}, SHIFT(170), + [375] = {.entry = {.count = 1, .reusable = false}}, SHIFT(621), + [377] = {.entry = {.count = 1, .reusable = false}}, SHIFT(424), + [379] = {.entry = {.count = 1, .reusable = false}}, SHIFT(411), + [381] = {.entry = {.count = 1, .reusable = false}}, SHIFT(420), + [383] = {.entry = {.count = 1, .reusable = false}}, SHIFT(380), + [385] = {.entry = {.count = 1, .reusable = true}}, SHIFT(187), + [387] = {.entry = {.count = 1, .reusable = false}}, SHIFT(647), + [389] = {.entry = {.count = 1, .reusable = false}}, SHIFT(641), + [391] = {.entry = {.count = 1, .reusable = false}}, SHIFT(639), + [393] = {.entry = {.count = 1, .reusable = true}}, SHIFT(105), + [395] = {.entry = {.count = 1, .reusable = true}}, SHIFT(630), + [397] = {.entry = {.count = 1, .reusable = false}}, SHIFT(503), + [399] = {.entry = {.count = 1, .reusable = true}}, SHIFT(285), + [401] = {.entry = {.count = 1, .reusable = true}}, SHIFT(288), + [403] = {.entry = {.count = 1, .reusable = false}}, SHIFT(388), + [405] = {.entry = {.count = 1, .reusable = false}}, SHIFT(285), + [407] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_integer_constant, 1), SHIFT(389), + [410] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tuple_types, 4), + [412] = {.entry = {.count = 1, .reusable = true}}, SHIFT(213), + [414] = {.entry = {.count = 1, .reusable = false}}, SHIFT(391), + [416] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assignment_op, 1), + [418] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assignment_op, 1), + [420] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_floating_constant, 3), + [422] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_floating_constant, 3), + [424] = {.entry = {.count = 1, .reusable = true}}, SHIFT(208), + [426] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_binary_digits_repeat1, 2), SHIFT_REPEAT(208), + [429] = {.entry = {.count = 1, .reusable = false}}, SHIFT(261), + [431] = {.entry = {.count = 1, .reusable = true}}, SHIFT(169), + [433] = {.entry = {.count = 1, .reusable = false}}, SHIFT(635), + [435] = {.entry = {.count = 1, .reusable = false}}, SHIFT(327), + [437] = {.entry = {.count = 1, .reusable = false}}, SHIFT(325), + [439] = {.entry = {.count = 1, .reusable = false}}, SHIFT(344), + [441] = {.entry = {.count = 1, .reusable = false}}, SHIFT(381), + [443] = {.entry = {.count = 1, .reusable = true}}, SHIFT(202), + [445] = {.entry = {.count = 1, .reusable = false}}, SHIFT(640), + [447] = {.entry = {.count = 1, .reusable = false}}, SHIFT(788), + [449] = {.entry = {.count = 1, .reusable = false}}, SHIFT(789), + [451] = {.entry = {.count = 1, .reusable = true}}, SHIFT(103), + [453] = {.entry = {.count = 1, .reusable = true}}, SHIFT(612), + [455] = {.entry = {.count = 1, .reusable = false}}, SHIFT(322), + [457] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_floating_constant, 4), + [459] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_floating_constant, 4), + [461] = {.entry = {.count = 1, .reusable = true}}, SHIFT(57), + [463] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_identifier, 3), + [465] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_identifier, 3), + [467] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_string_constant, 1), + [469] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_string_constant, 1), + [471] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_string_constant_repeat1, 2), + [473] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_string_constant_repeat1, 2), + [475] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_string_constant_repeat1, 2), SHIFT_REPEAT(463), + [478] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_plain_expression, 1), + [480] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_object_selector, 1), + [482] = {.entry = {.count = 1, .reusable = true}}, SHIFT(686), + [484] = {.entry = {.count = 1, .reusable = true}}, SHIFT(458), + [486] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_plain_expression, 1), + [488] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_object_selector, 1), [490] = {.entry = {.count = 1, .reusable = true}}, SHIFT(674), [492] = {.entry = {.count = 1, .reusable = true}}, SHIFT(460), - [494] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_string_constant_repeat1, 2), - [496] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_string_constant_repeat1, 2), - [498] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_string_constant_repeat1, 2), SHIFT_REPEAT(463), + [494] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_identifier, 1), + [496] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_identifier, 1), + [498] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_identifier, 1), SHIFT(561), [501] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_string_constant_repeat1, 3), [503] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_string_constant_repeat1, 3), [505] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_length_expression, 4), @@ -37268,8 +37362,8 @@ static TSParseActionEntry ts_parse_actions[] = { [583] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_allocation_expression, 6), [585] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assertion_expression, 6), [587] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assertion_expression, 6), - [589] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_access_expression, 3), - [591] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_field_access_expression, 3), + [589] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_access_expression, 3, .production_id = 7), + [591] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_field_access_expression, 3, .production_id = 7), [593] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_nested_expression, 1), [595] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_nested_expression, 1), [597] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_slicing_expression, 6), @@ -37302,12 +37396,12 @@ static TSParseActionEntry ts_parse_actions[] = { [651] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_constant, 1), [653] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_integer_suffix, 1), [655] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_integer_suffix, 1), - [657] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_unary_expression, 2, .production_id = 1), - [659] = {.entry = {.count = 1, .reusable = false}}, SHIFT(165), - [661] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_unary_expression, 2, .production_id = 1), - [663] = {.entry = {.count = 1, .reusable = true}}, SHIFT(165), - [665] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_unary_expression, 2, .production_id = 2), - [667] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_unary_expression, 2, .production_id = 2), + [657] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_unary_expression, 2, .production_id = 4), + [659] = {.entry = {.count = 1, .reusable = false}}, SHIFT(166), + [661] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_unary_expression, 2, .production_id = 4), + [663] = {.entry = {.count = 1, .reusable = true}}, SHIFT(166), + [665] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_unary_expression, 2, .production_id = 5), + [667] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_unary_expression, 2, .production_id = 5), [669] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_identifier, 1), SHIFT(633), [672] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_string_constant_repeat1, 2), SHIFT_REPEAT(462), [675] = {.entry = {.count = 1, .reusable = false}}, SHIFT(45), @@ -37373,12 +37467,12 @@ static TSParseActionEntry ts_parse_actions[] = { [795] = {.entry = {.count = 1, .reusable = true}}, SHIFT(181), [797] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_cast_expression, 1), [799] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_cast_expression, 1), - [801] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_cast_expression, 3, .production_id = 3), - [803] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_cast_expression, 3, .production_id = 3), - [805] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_cast_expression, 3, .production_id = 4), - [807] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_cast_expression, 3, .production_id = 4), - [809] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_cast_expression, 3, .production_id = 5), - [811] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_cast_expression, 3, .production_id = 5), + [801] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_cast_expression, 3, .production_id = 8), + [803] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_cast_expression, 3, .production_id = 8), + [805] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_cast_expression, 3, .production_id = 9), + [807] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_cast_expression, 3, .production_id = 9), + [809] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_cast_expression, 3, .production_id = 10), + [811] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_cast_expression, 3, .production_id = 10), [813] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_multiplicative_expression, 3), [815] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_multiplicative_expression, 3), [817] = {.entry = {.count = 1, .reusable = false}}, SHIFT(52), @@ -37535,7 +37629,7 @@ static TSParseActionEntry ts_parse_actions[] = { [1137] = {.entry = {.count = 1, .reusable = true}}, SHIFT(214), [1139] = {.entry = {.count = 1, .reusable = false}}, SHIFT(655), [1141] = {.entry = {.count = 1, .reusable = true}}, SHIFT(309), - [1143] = {.entry = {.count = 1, .reusable = true}}, SHIFT(206), + [1143] = {.entry = {.count = 1, .reusable = true}}, SHIFT(203), [1145] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_if_expression, 2), SHIFT(97), [1148] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter_list, 2), [1150] = {.entry = {.count = 1, .reusable = true}}, SHIFT(614), @@ -37548,23 +37642,23 @@ static TSParseActionEntry ts_parse_actions[] = { [1164] = {.entry = {.count = 1, .reusable = true}}, SHIFT(229), [1166] = {.entry = {.count = 1, .reusable = true}}, SHIFT(77), [1168] = {.entry = {.count = 1, .reusable = true}}, SHIFT(307), - [1170] = {.entry = {.count = 1, .reusable = false}}, SHIFT(202), + [1170] = {.entry = {.count = 1, .reusable = false}}, SHIFT(195), [1172] = {.entry = {.count = 1, .reusable = true}}, SHIFT(545), [1174] = {.entry = {.count = 1, .reusable = true}}, SHIFT(541), [1176] = {.entry = {.count = 1, .reusable = true}}, SHIFT(85), - [1178] = {.entry = {.count = 1, .reusable = false}}, SHIFT(188), + [1178] = {.entry = {.count = 1, .reusable = false}}, SHIFT(178), [1180] = {.entry = {.count = 1, .reusable = true}}, SHIFT(248), [1182] = {.entry = {.count = 1, .reusable = true}}, SHIFT(374), [1184] = {.entry = {.count = 1, .reusable = true}}, SHIFT(375), [1186] = {.entry = {.count = 1, .reusable = false}}, SHIFT(180), [1188] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_values, 2), [1190] = {.entry = {.count = 1, .reusable = true}}, SHIFT(530), - [1192] = {.entry = {.count = 1, .reusable = false}}, SHIFT(186), + [1192] = {.entry = {.count = 1, .reusable = false}}, SHIFT(177), [1194] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_bindings, 4), [1196] = {.entry = {.count = 1, .reusable = true}}, SHIFT(495), [1198] = {.entry = {.count = 1, .reusable = true}}, SHIFT(787), [1200] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_tagged_types_repeat1, 2), - [1202] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_tagged_types_repeat1, 2), SHIFT_REPEAT(179), + [1202] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_tagged_types_repeat1, 2), SHIFT_REPEAT(175), [1205] = {.entry = {.count = 1, .reusable = true}}, SHIFT(19), [1207] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array_members, 1), [1209] = {.entry = {.count = 1, .reusable = true}}, SHIFT(620), @@ -37593,18 +37687,18 @@ static TSParseActionEntry ts_parse_actions[] = { [1255] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_binding_names, 3), [1257] = {.entry = {.count = 1, .reusable = true}}, SHIFT(607), [1259] = {.entry = {.count = 1, .reusable = true}}, SHIFT(74), - [1261] = {.entry = {.count = 1, .reusable = true}}, SHIFT(201), + [1261] = {.entry = {.count = 1, .reusable = true}}, SHIFT(191), [1263] = {.entry = {.count = 1, .reusable = true}}, SHIFT(494), [1265] = {.entry = {.count = 1, .reusable = true}}, SHIFT(501), [1267] = {.entry = {.count = 1, .reusable = true}}, SHIFT(99), - [1269] = {.entry = {.count = 1, .reusable = true}}, SHIFT(183), + [1269] = {.entry = {.count = 1, .reusable = true}}, SHIFT(186), [1271] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tagged_types, 4), - [1273] = {.entry = {.count = 1, .reusable = true}}, SHIFT(179), + [1273] = {.entry = {.count = 1, .reusable = true}}, SHIFT(175), [1275] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tagged_types, 3), [1277] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter, 3), [1279] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_offset_specifier, 4), [1281] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_cases, 1), - [1283] = {.entry = {.count = 1, .reusable = true}}, SHIFT(164), + [1283] = {.entry = {.count = 1, .reusable = true}}, SHIFT(163), [1285] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_constant_binding, 5), [1287] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_value, 3), [1289] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_value, 3), @@ -37613,18 +37707,18 @@ static TSParseActionEntry ts_parse_actions[] = { [1295] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_union_field, 4), [1297] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_union_field, 2), [1299] = {.entry = {.count = 1, .reusable = true}}, SHIFT(531), - [1301] = {.entry = {.count = 1, .reusable = true}}, SHIFT(197), + [1301] = {.entry = {.count = 1, .reusable = true}}, SHIFT(205), [1303] = {.entry = {.count = 1, .reusable = true}}, SHIFT(519), [1305] = {.entry = {.count = 1, .reusable = true}}, SHIFT(228), [1307] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_union_fields, 1), [1309] = {.entry = {.count = 1, .reusable = true}}, SHIFT(404), [1311] = {.entry = {.count = 1, .reusable = true}}, SHIFT(89), - [1313] = {.entry = {.count = 1, .reusable = true}}, SHIFT(169), + [1313] = {.entry = {.count = 1, .reusable = true}}, SHIFT(165), [1315] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tuple_types, 3), [1317] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_global_binding, 6), [1319] = {.entry = {.count = 1, .reusable = true}}, SHIFT(230), [1321] = {.entry = {.count = 1, .reusable = true}}, SHIFT(466), - [1323] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 3), + [1323] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 3, .production_id = 1), [1325] = {.entry = {.count = 1, .reusable = true}}, SHIFT(93), [1327] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_value, 5), [1329] = {.entry = {.count = 1, .reusable = true}}, SHIFT(475), @@ -37659,16 +37753,16 @@ static TSParseActionEntry ts_parse_actions[] = { [1388] = {.entry = {.count = 1, .reusable = true}}, SHIFT(234), [1390] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_value, 1), [1392] = {.entry = {.count = 1, .reusable = true}}, SHIFT(477), - [1394] = {.entry = {.count = 1, .reusable = true}}, SHIFT(176), - [1396] = {.entry = {.count = 1, .reusable = true}}, SHIFT(198), + [1394] = {.entry = {.count = 1, .reusable = true}}, SHIFT(172), + [1396] = {.entry = {.count = 1, .reusable = true}}, SHIFT(193), [1398] = {.entry = {.count = 1, .reusable = true}}, SHIFT(745), [1400] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_values, 1), [1402] = {.entry = {.count = 1, .reusable = true}}, SHIFT(539), [1404] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_name_list, 1), [1406] = {.entry = {.count = 1, .reusable = true}}, SHIFT(536), [1408] = {.entry = {.count = 1, .reusable = true}}, SHIFT(62), - [1410] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_predicate, 3, .production_id = 6), - [1412] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 4), + [1410] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_predicate, 3, .production_id = 11), + [1412] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 4, .production_id = 2), [1414] = {.entry = {.count = 1, .reusable = true}}, SHIFT(64), [1416] = {.entry = {.count = 1, .reusable = true}}, SHIFT(766), [1418] = {.entry = {.count = 1, .reusable = true}}, SHIFT(814), @@ -37700,40 +37794,40 @@ static TSParseActionEntry ts_parse_actions[] = { [1470] = {.entry = {.count = 1, .reusable = true}}, SHIFT(695), [1472] = {.entry = {.count = 1, .reusable = true}}, SHIFT(694), [1474] = {.entry = {.count = 1, .reusable = true}}, SHIFT(413), - [1476] = {.entry = {.count = 1, .reusable = true}}, SHIFT(207), + [1476] = {.entry = {.count = 1, .reusable = true}}, SHIFT(206), [1478] = {.entry = {.count = 1, .reusable = true}}, SHIFT(407), [1480] = {.entry = {.count = 1, .reusable = true}}, SHIFT(699), - [1482] = {.entry = {.count = 1, .reusable = true}}, SHIFT(209), - [1484] = {.entry = {.count = 1, .reusable = true}}, SHIFT(210), + [1482] = {.entry = {.count = 1, .reusable = true}}, SHIFT(218), + [1484] = {.entry = {.count = 1, .reusable = true}}, SHIFT(209), [1486] = {.entry = {.count = 1, .reusable = true}}, SHIFT(335), [1488] = {.entry = {.count = 1, .reusable = true}}, SHIFT(336), - [1490] = {.entry = {.count = 1, .reusable = true}}, SHIFT(213), + [1490] = {.entry = {.count = 1, .reusable = true}}, SHIFT(207), [1492] = {.entry = {.count = 1, .reusable = true}}, SHIFT(154), [1494] = {.entry = {.count = 1, .reusable = true}}, SHIFT(593), [1496] = {.entry = {.count = 1, .reusable = true}}, SHIFT(277), [1498] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_constant_bindings, 3), [1500] = {.entry = {.count = 1, .reusable = true}}, SHIFT(90), [1502] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_global_bindings, 3), - [1504] = {.entry = {.count = 1, .reusable = true}}, SHIFT(200), - [1506] = {.entry = {.count = 1, .reusable = true}}, SHIFT(205), + [1504] = {.entry = {.count = 1, .reusable = true}}, SHIFT(194), + [1506] = {.entry = {.count = 1, .reusable = true}}, SHIFT(196), [1508] = {.entry = {.count = 1, .reusable = true}}, SHIFT(735), [1510] = {.entry = {.count = 1, .reusable = true}}, SHIFT(421), [1512] = {.entry = {.count = 1, .reusable = true}}, SHIFT(423), [1514] = {.entry = {.count = 1, .reusable = true}}, SHIFT(534), - [1516] = {.entry = {.count = 1, .reusable = true}}, SHIFT(190), + [1516] = {.entry = {.count = 1, .reusable = true}}, SHIFT(179), [1518] = {.entry = {.count = 1, .reusable = true}}, SHIFT(473), [1520] = {.entry = {.count = 1, .reusable = true}}, SHIFT(33), [1522] = {.entry = {.count = 1, .reusable = true}}, SHIFT(346), [1524] = {.entry = {.count = 1, .reusable = true}}, SHIFT(341), [1526] = {.entry = {.count = 1, .reusable = true}}, SHIFT(340), - [1528] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6), + [1528] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6, .production_id = 6), [1530] = {.entry = {.count = 1, .reusable = true}}, SHIFT(254), [1532] = {.entry = {.count = 1, .reusable = true}}, SHIFT(249), [1534] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_name_list, 3), [1536] = {.entry = {.count = 1, .reusable = true}}, SHIFT(82), [1538] = {.entry = {.count = 1, .reusable = true}}, SHIFT(390), [1540] = {.entry = {.count = 1, .reusable = true}}, SHIFT(235), - [1542] = {.entry = {.count = 1, .reusable = true}}, SHIFT(142), + [1542] = {.entry = {.count = 1, .reusable = true}}, SHIFT(141), [1544] = {.entry = {.count = 1, .reusable = true}}, SHIFT(81), [1546] = {.entry = {.count = 1, .reusable = true}}, SHIFT(80), [1548] = {.entry = {.count = 1, .reusable = true}}, SHIFT(491), @@ -37754,7 +37848,7 @@ static TSParseActionEntry ts_parse_actions[] = { [1578] = {.entry = {.count = 1, .reusable = true}}, SHIFT(292), [1580] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_escape_sequence, 1), [1582] = {.entry = {.count = 1, .reusable = true}}, SHIFT(79), - [1584] = {.entry = {.count = 1, .reusable = true}}, SHIFT(196), + [1584] = {.entry = {.count = 1, .reusable = true}}, SHIFT(176), [1586] = {.entry = {.count = 1, .reusable = true}}, SHIFT(78), [1588] = {.entry = {.count = 1, .reusable = true}}, SHIFT(238), [1590] = {.entry = {.count = 1, .reusable = true}}, SHIFT(239), @@ -37778,18 +37872,18 @@ static TSParseActionEntry ts_parse_actions[] = { [1626] = {.entry = {.count = 1, .reusable = true}}, SHIFT(72), [1628] = {.entry = {.count = 1, .reusable = true}}, SHIFT(53), [1630] = {.entry = {.count = 1, .reusable = true}}, SHIFT(663), - [1632] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 5), + [1632] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 5, .production_id = 3), [1634] = {.entry = {.count = 1, .reusable = true}}, SHIFT(319), [1636] = {.entry = {.count = 1, .reusable = true}}, SHIFT(318), [1638] = {.entry = {.count = 1, .reusable = true}}, SHIFT(16), [1640] = {.entry = {.count = 1, .reusable = true}}, SHIFT(386), - [1642] = {.entry = {.count = 1, .reusable = true}}, SHIFT(194), + [1642] = {.entry = {.count = 1, .reusable = true}}, SHIFT(188), [1644] = {.entry = {.count = 1, .reusable = true}}, SHIFT(603), - [1646] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_predicate, 3, .production_id = 7), + [1646] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_predicate, 3, .production_id = 12), [1648] = {.entry = {.count = 1, .reusable = true}}, SHIFT(448), [1650] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_initializer, 3), [1652] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 2), - [1654] = {.entry = {.count = 1, .reusable = true}}, SHIFT(191), + [1654] = {.entry = {.count = 1, .reusable = true}}, SHIFT(189), [1656] = {.entry = {.count = 1, .reusable = true}}, SHIFT(279), [1658] = {.entry = {.count = 1, .reusable = true}}, SHIFT(499), [1660] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_argument_list, 3), @@ -37800,8 +37894,8 @@ static TSParseActionEntry ts_parse_actions[] = { [1670] = {.entry = {.count = 1, .reusable = true}}, SHIFT(65), [1672] = {.entry = {.count = 1, .reusable = true}}, SHIFT(61), [1674] = {.entry = {.count = 1, .reusable = true}}, SHIFT(66), - [1676] = {.entry = {.count = 1, .reusable = true}}, SHIFT(189), - [1678] = {.entry = {.count = 1, .reusable = true}}, SHIFT(170), + [1676] = {.entry = {.count = 1, .reusable = true}}, SHIFT(183), + [1678] = {.entry = {.count = 1, .reusable = true}}, SHIFT(167), [1680] = {.entry = {.count = 1, .reusable = true}}, SHIFT(7), [1682] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_global_declaration, 2), [1684] = {.entry = {.count = 1, .reusable = true}}, SHIFT(449), @@ -37831,7 +37925,7 @@ static TSParseActionEntry ts_parse_actions[] = { [1732] = {.entry = {.count = 1, .reusable = true}}, SHIFT(410), [1734] = {.entry = {.count = 1, .reusable = true}}, SHIFT(409), [1736] = {.entry = {.count = 1, .reusable = true}}, SHIFT(547), - [1738] = {.entry = {.count = 1, .reusable = true}}, SHIFT(203), + [1738] = {.entry = {.count = 1, .reusable = true}}, SHIFT(190), [1740] = {.entry = {.count = 1, .reusable = true}}, SHIFT(478), [1742] = {.entry = {.count = 1, .reusable = true}}, SHIFT(63), [1744] = {.entry = {.count = 1, .reusable = true}}, SHIFT(69), @@ -37857,7 +37951,7 @@ static TSParseActionEntry ts_parse_actions[] = { [1784] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter_list, 4), [1786] = {.entry = {.count = 1, .reusable = true}}, SHIFT(25), [1788] = {.entry = {.count = 1, .reusable = true}}, SHIFT(810), - [1790] = {.entry = {.count = 1, .reusable = true}}, SHIFT(141), + [1790] = {.entry = {.count = 1, .reusable = true}}, SHIFT(142), [1792] = {.entry = {.count = 1, .reusable = true}}, SHIFT(815), }; From 7949c5e15b17cdd087c58afda83f3e984ab70d83 Mon Sep 17 00:00:00 2001 From: ecmma Date: Fri, 9 Apr 2021 17:18:31 +0200 Subject: [PATCH 4/9] init --- package.json | 28 ++++++++++++++++++++++------ 1 file changed, 22 insertions(+), 6 deletions(-) diff --git a/package.json b/package.json index da683a7cf..3ca75d25c 100644 --- a/package.json +++ b/package.json @@ -1,19 +1,35 @@ { "name": "tree-sitter-hare", "version": "0.0.1", - "description": "hare grammar for tree-sitter", + "description": "Hare grammar for tree-sitter", "main": "bindings/node", + "keywords": [ - "parsing", - "incremental" + "parser", + "hare" ], + + "author": "ecmma", + "license": "GNU GPL", + "dependencies": { - "nan": "^2.12.1" + "nan": "^2.14.1" }, "devDependencies": { - "tree-sitter-cli": "^0.17.3" + "tree-sitter-cli": "^0.19.1" }, + "scripts": { + "build": "tree-sitter generate && node-gyp build", "test": "tree-sitter test" - } + }, + + "tree-sitter": [ + { + "scope": "source.ha", + "file-types": [ + "hare" + ] + } + ] } From 4b7b09643b8e8e6d448213d3247ae2932f5465e5 Mon Sep 17 00:00:00 2001 From: ecmma Date: Fri, 9 Apr 2021 17:18:50 +0200 Subject: [PATCH 5/9] added tree-sitter features --- queries/highlights.scm | 115 +++++++++++++++++++++++++++++++++++++++++ queries/indents.scm | 14 +++++ queries/locals.scm | 19 +++++++ 3 files changed, 148 insertions(+) create mode 100644 queries/highlights.scm create mode 100644 queries/indents.scm create mode 100644 queries/locals.scm diff --git a/queries/highlights.scm b/queries/highlights.scm new file mode 100644 index 000000000..6d78b87d4 --- /dev/null +++ b/queries/highlights.scm @@ -0,0 +1,115 @@ +"abort" @keyword +"alloc" @keyword +"append" @keyword +"as" @keyword +"assert" @keyword +"bool" @keyword +"break" @keyword +"char" @keyword +"const" @keyword +"continue" @keyword +"def" @keyword +"defer" @keyword +"delete" @keyword +"else" @keyword +"enum" @keyword +"export" @keyword +"f32" @type +"f64" @type +"false" @constant +"fn" @keyword +"for" @keyword +"free" @keyword +"i16" @type +"i32" @type +"i64" @type +"i8" @type +"if" @keyword +"int" @type +"is" @keyword +"len" @keyword +"let" @keyword +"match" @keyword +"null" @constant +"nullable" @keyword +"offset" @keyword +"return" @keyword +"rune" @type +"size" @keyword +"static" @keyword +"str" @type +"struct" @keyword +"switch" @keyword +"true" @keyword +"type" @keyword +"u16" @type +"u32" @type +"u64" @type +"u8" @type +"uint" @type +"uintptr" @type +"union" @keyword +"use" @keyword +"void" @type +"..." @special + +"." @operator +"!" @operator +"~" @operator +"?" @operator +"*" @operator +"/" @operator +"%" @operator +"+" @operator +"-" @operator +"<<" @operator +">>" @operator +"::" @operator +"<" @operator +"<=" @operator +">" @operator +">=" @operator +"==" @operator +"!=" @operator +"&" @operator +"|" @operator +"^" @operator +"&&" @operator +"||" @operator +"=" @operator +"+=" @operator +"-=" @operator +"*=" @operator +"/=" @operator +"%=" @operator +"&=" @operator +"|=" @operator +"<<=" @operator +">>=" @operator +"^=" @operator + +":" @delimiter +";" @delimiter + +(comment) @comment + +(string_constant) @string +(escape_sequence) @type +(rune_constant) @string +(integer_constant) @number +(floating_constant) @number + +(call_expression + (postfix_expression) @function) + +(function_declaration + name: (identifier) @function) + +(parameter (name) @variable.parameter) + +(field_access_expression + selector: (name) @field) +(decl_attr) @special +(fndec_attrs) @special + +(identifier) @variable diff --git a/queries/indents.scm b/queries/indents.scm new file mode 100644 index 000000000..86ffc4782 --- /dev/null +++ b/queries/indents.scm @@ -0,0 +1,14 @@ +[ + (struct_union_fields) + (expression_list) +] @indent + + +[ + "{" + "}" +] @branch + +[ + (comment) +] @ignore diff --git a/queries/locals.scm b/queries/locals.scm new file mode 100644 index 000000000..d10a57166 --- /dev/null +++ b/queries/locals.scm @@ -0,0 +1,19 @@ +(unit) @local.scope + +(function_declaration) @local.scope + +(global_binding + (identifier) @local.definition) +(constant_binding + (identifier) @local.definition) +(type_bindings + (identifier) @local.definition) + +(function_declaration + (prototype + (parameter_list + (parameters + (parameter + (name) @local.definition))))) + +(identifier) @local.reference From 00a2a647f667e88e5ef3df0cd67b1450d93462ba Mon Sep 17 00:00:00 2001 From: ecmma Date: Wed, 14 Apr 2021 14:19:23 +0200 Subject: [PATCH 6/9] minor grammar changes --- grammar.js | 2 +- src/grammar.json | 12 +- src/node-types.json | 2 +- src/parser.c | 25831 +++++++++++++++++++++--------------------- 4 files changed, 12979 insertions(+), 12868 deletions(-) diff --git a/grammar.js b/grammar.js index 9fb226ba2..4fd59607e 100644 --- a/grammar.js +++ b/grammar.js @@ -383,7 +383,7 @@ module.exports = grammar ({ )) ), - string_constant: $ => repeat1(seq('"', $.string_chars, '"')), + string_constant: $ => repeat1(seq('"', optional($.string_chars), '"')), string_chars: $ => repeat1($.string_char), string_char: $ => choice( diff --git a/src/grammar.json b/src/grammar.json index 6eac4c24c..135aa03ae 100644 --- a/src/grammar.json +++ b/src/grammar.json @@ -2156,8 +2156,16 @@ "value": "\"" }, { - "type": "SYMBOL", - "name": "string_chars" + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "string_chars" + }, + { + "type": "BLANK" + } + ] }, { "type": "STRING", diff --git a/src/node-types.json b/src/node-types.json index 606302cba..acee8589a 100644 --- a/src/node-types.json +++ b/src/node-types.json @@ -2083,7 +2083,7 @@ "fields": {}, "children": { "multiple": true, - "required": true, + "required": false, "types": [ { "type": "string_chars", diff --git a/src/parser.c b/src/parser.c index 5774c3362..c44ff50e4 100644 --- a/src/parser.c +++ b/src/parser.c @@ -14,7 +14,7 @@ #endif #define LANGUAGE_VERSION 13 -#define STATE_COUNT 820 +#define STATE_COUNT 822 #define LARGE_STATE_COUNT 140 #define SYMBOL_COUNT 284 #define ALIAS_COUNT 0 @@ -2242,17 +2242,17 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { if (lookahead == '\r') SKIP(9) END_STATE(); case 11: - if (lookahead == '\n') SKIP(56) + if (lookahead == '\n') SKIP(45) END_STATE(); case 12: - if (lookahead == '\n') SKIP(56) + if (lookahead == '\n') SKIP(45) if (lookahead == '\r') SKIP(11) END_STATE(); case 13: - if (lookahead == '\n') SKIP(45) + if (lookahead == '\n') SKIP(56) END_STATE(); case 14: - if (lookahead == '\n') SKIP(45) + if (lookahead == '\n') SKIP(56) if (lookahead == '\r') SKIP(13) END_STATE(); case 15: @@ -2454,7 +2454,7 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { if (lookahead == 'E') ADVANCE(344); if (lookahead == 'F') ADVANCE(345); if (lookahead == '[') ADVANCE(316); - if (lookahead == '\\') SKIP(14) + if (lookahead == '\\') SKIP(12) if (lookahead == ']') ADVANCE(317); if (lookahead == '^') ADVANCE(411); if (lookahead == 'a') ADVANCE(347); @@ -2953,7 +2953,7 @@ static bool ts_lex(TSLexer *lexer, TSStateId state) { if (lookahead == '8') ADVANCE(338); if (lookahead == '9') ADVANCE(339); if (lookahead == '[') ADVANCE(316); - if (lookahead == '\\') SKIP(12) + if (lookahead == '\\') SKIP(14) if (lookahead == ']') ADVANCE(317); if (lookahead == '_') ADVANCE(319); if (lookahead == 'a') ADVANCE(470); @@ -5827,25 +5827,25 @@ static TSLexMode ts_lex_modes[STATE_COUNT] = { [9] = {.lex_state = 51}, [10] = {.lex_state = 51}, [11] = {.lex_state = 51}, - [12] = {.lex_state = 51}, - [13] = {.lex_state = 51}, - [14] = {.lex_state = 52}, + [12] = {.lex_state = 52}, + [13] = {.lex_state = 52}, + [14] = {.lex_state = 51}, [15] = {.lex_state = 52}, - [16] = {.lex_state = 52}, + [16] = {.lex_state = 51}, [17] = {.lex_state = 51}, - [18] = {.lex_state = 52}, + [18] = {.lex_state = 51}, [19] = {.lex_state = 51}, [20] = {.lex_state = 51}, - [21] = {.lex_state = 51}, + [21] = {.lex_state = 52}, [22] = {.lex_state = 54}, - [23] = {.lex_state = 51}, - [24] = {.lex_state = 54}, + [23] = {.lex_state = 54}, + [24] = {.lex_state = 51}, [25] = {.lex_state = 51}, [26] = {.lex_state = 51}, [27] = {.lex_state = 51}, [28] = {.lex_state = 51}, - [29] = {.lex_state = 51}, - [30] = {.lex_state = 54}, + [29] = {.lex_state = 54}, + [30] = {.lex_state = 51}, [31] = {.lex_state = 51}, [32] = {.lex_state = 51}, [33] = {.lex_state = 51}, @@ -5918,10 +5918,10 @@ static TSLexMode ts_lex_modes[STATE_COUNT] = { [100] = {.lex_state = 51}, [101] = {.lex_state = 51}, [102] = {.lex_state = 51}, - [103] = {.lex_state = 56}, + [103] = {.lex_state = 45}, [104] = {.lex_state = 45}, [105] = {.lex_state = 56}, - [106] = {.lex_state = 45}, + [106] = {.lex_state = 56}, [107] = {.lex_state = 45}, [108] = {.lex_state = 55}, [109] = {.lex_state = 55}, @@ -5933,47 +5933,47 @@ static TSLexMode ts_lex_modes[STATE_COUNT] = { [115] = {.lex_state = 46}, [116] = {.lex_state = 55}, [117] = {.lex_state = 55}, - [118] = {.lex_state = 44}, + [118] = {.lex_state = 46}, [119] = {.lex_state = 44}, - [120] = {.lex_state = 46}, + [120] = {.lex_state = 44}, [121] = {.lex_state = 55}, [122] = {.lex_state = 55}, - [123] = {.lex_state = 44}, + [123] = {.lex_state = 55}, [124] = {.lex_state = 55}, [125] = {.lex_state = 55}, - [126] = {.lex_state = 55}, + [126] = {.lex_state = 44}, [127] = {.lex_state = 55}, - [128] = {.lex_state = 45}, - [129] = {.lex_state = 55}, + [128] = {.lex_state = 55}, + [129] = {.lex_state = 45}, [130] = {.lex_state = 55}, [131] = {.lex_state = 55}, [132] = {.lex_state = 55}, [133] = {.lex_state = 55}, [134] = {.lex_state = 55}, [135] = {.lex_state = 55}, - [136] = {.lex_state = 55}, - [137] = {.lex_state = 45}, + [136] = {.lex_state = 45}, + [137] = {.lex_state = 55}, [138] = {.lex_state = 55}, [139] = {.lex_state = 45}, [140] = {.lex_state = 46}, [141] = {.lex_state = 55}, [142] = {.lex_state = 55}, - [143] = {.lex_state = 45}, + [143] = {.lex_state = 46}, [144] = {.lex_state = 45}, - [145] = {.lex_state = 55}, - [146] = {.lex_state = 48}, + [145] = {.lex_state = 48}, + [146] = {.lex_state = 55}, [147] = {.lex_state = 55}, - [148] = {.lex_state = 48}, - [149] = {.lex_state = 46}, - [150] = {.lex_state = 55}, + [148] = {.lex_state = 55}, + [149] = {.lex_state = 48}, + [150] = {.lex_state = 45}, [151] = {.lex_state = 55}, [152] = {.lex_state = 55}, - [153] = {.lex_state = 45}, - [154] = {.lex_state = 55}, + [153] = {.lex_state = 55}, + [154] = {.lex_state = 45}, [155] = {.lex_state = 55}, [156] = {.lex_state = 46}, - [157] = {.lex_state = 45}, - [158] = {.lex_state = 48}, + [157] = {.lex_state = 48}, + [158] = {.lex_state = 45}, [159] = {.lex_state = 45}, [160] = {.lex_state = 44}, [161] = {.lex_state = 44}, @@ -5981,65 +5981,65 @@ static TSLexMode ts_lex_modes[STATE_COUNT] = { [163] = {.lex_state = 58}, [164] = {.lex_state = 48}, [165] = {.lex_state = 58}, - [166] = {.lex_state = 51}, + [166] = {.lex_state = 46}, [167] = {.lex_state = 58}, - [168] = {.lex_state = 46}, + [168] = {.lex_state = 58}, [169] = {.lex_state = 58}, - [170] = {.lex_state = 58}, - [171] = {.lex_state = 44}, + [170] = {.lex_state = 51}, + [171] = {.lex_state = 48}, [172] = {.lex_state = 58}, - [173] = {.lex_state = 48}, + [173] = {.lex_state = 44}, [174] = {.lex_state = 44}, [175] = {.lex_state = 58}, [176] = {.lex_state = 58}, [177] = {.lex_state = 58}, - [178] = {.lex_state = 58}, + [178] = {.lex_state = 44}, [179] = {.lex_state = 58}, [180] = {.lex_state = 58}, [181] = {.lex_state = 58}, [182] = {.lex_state = 58}, - [183] = {.lex_state = 58}, + [183] = {.lex_state = 234}, [184] = {.lex_state = 58}, - [185] = {.lex_state = 234}, + [185] = {.lex_state = 58}, [186] = {.lex_state = 58}, [187] = {.lex_state = 58}, [188] = {.lex_state = 58}, [189] = {.lex_state = 58}, [190] = {.lex_state = 58}, [191] = {.lex_state = 58}, - [192] = {.lex_state = 44}, + [192] = {.lex_state = 58}, [193] = {.lex_state = 58}, [194] = {.lex_state = 58}, [195] = {.lex_state = 58}, - [196] = {.lex_state = 58}, + [196] = {.lex_state = 0}, [197] = {.lex_state = 0}, - [198] = {.lex_state = 0}, - [199] = {.lex_state = 0}, - [200] = {.lex_state = 48}, - [201] = {.lex_state = 0}, + [198] = {.lex_state = 58}, + [199] = {.lex_state = 58}, + [200] = {.lex_state = 58}, + [201] = {.lex_state = 58}, [202] = {.lex_state = 58}, - [203] = {.lex_state = 58}, - [204] = {.lex_state = 0}, - [205] = {.lex_state = 0}, + [203] = {.lex_state = 48}, + [204] = {.lex_state = 58}, + [205] = {.lex_state = 58}, [206] = {.lex_state = 58}, [207] = {.lex_state = 58}, - [208] = {.lex_state = 44}, - [209] = {.lex_state = 58}, - [210] = {.lex_state = 58}, + [208] = {.lex_state = 0}, + [209] = {.lex_state = 0}, + [210] = {.lex_state = 44}, [211] = {.lex_state = 58}, - [212] = {.lex_state = 58}, + [212] = {.lex_state = 0}, [213] = {.lex_state = 58}, - [214] = {.lex_state = 58}, - [215] = {.lex_state = 0}, - [216] = {.lex_state = 58}, - [217] = {.lex_state = 44}, + [214] = {.lex_state = 0}, + [215] = {.lex_state = 58}, + [216] = {.lex_state = 0}, + [217] = {.lex_state = 0}, [218] = {.lex_state = 0}, - [219] = {.lex_state = 0}, + [219] = {.lex_state = 44}, [220] = {.lex_state = 0}, [221] = {.lex_state = 0}, [222] = {.lex_state = 0}, [223] = {.lex_state = 0}, - [224] = {.lex_state = 0}, + [224] = {.lex_state = 59}, [225] = {.lex_state = 0}, [226] = {.lex_state = 0}, [227] = {.lex_state = 0}, @@ -6049,7 +6049,7 @@ static TSLexMode ts_lex_modes[STATE_COUNT] = { [231] = {.lex_state = 0}, [232] = {.lex_state = 0}, [233] = {.lex_state = 0}, - [234] = {.lex_state = 0}, + [234] = {.lex_state = 59}, [235] = {.lex_state = 0}, [236] = {.lex_state = 0}, [237] = {.lex_state = 0}, @@ -6074,20 +6074,20 @@ static TSLexMode ts_lex_modes[STATE_COUNT] = { [256] = {.lex_state = 0}, [257] = {.lex_state = 0}, [258] = {.lex_state = 0}, - [259] = {.lex_state = 59}, + [259] = {.lex_state = 0}, [260] = {.lex_state = 0}, - [261] = {.lex_state = 59}, + [261] = {.lex_state = 0}, [262] = {.lex_state = 0}, [263] = {.lex_state = 0}, [264] = {.lex_state = 0}, [265] = {.lex_state = 0}, [266] = {.lex_state = 0}, - [267] = {.lex_state = 48}, - [268] = {.lex_state = 47}, - [269] = {.lex_state = 44}, + [267] = {.lex_state = 0}, + [268] = {.lex_state = 48}, + [269] = {.lex_state = 47}, [270] = {.lex_state = 48}, - [271] = {.lex_state = 47}, - [272] = {.lex_state = 44}, + [271] = {.lex_state = 44}, + [272] = {.lex_state = 47}, [273] = {.lex_state = 44}, [274] = {.lex_state = 44}, [275] = {.lex_state = 44}, @@ -6143,14 +6143,14 @@ static TSLexMode ts_lex_modes[STATE_COUNT] = { [325] = {.lex_state = 44}, [326] = {.lex_state = 44}, [327] = {.lex_state = 44}, - [328] = {.lex_state = 49}, + [328] = {.lex_state = 44}, [329] = {.lex_state = 44}, [330] = {.lex_state = 44}, [331] = {.lex_state = 44}, [332] = {.lex_state = 44}, [333] = {.lex_state = 44}, [334] = {.lex_state = 44}, - [335] = {.lex_state = 44}, + [335] = {.lex_state = 49}, [336] = {.lex_state = 44}, [337] = {.lex_state = 44}, [338] = {.lex_state = 44}, @@ -6164,221 +6164,221 @@ static TSLexMode ts_lex_modes[STATE_COUNT] = { [346] = {.lex_state = 44}, [347] = {.lex_state = 44}, [348] = {.lex_state = 44}, - [349] = {.lex_state = 44}, + [349] = {.lex_state = 49}, [350] = {.lex_state = 44}, [351] = {.lex_state = 44}, [352] = {.lex_state = 44}, [353] = {.lex_state = 44}, [354] = {.lex_state = 44}, - [355] = {.lex_state = 49}, + [355] = {.lex_state = 44}, [356] = {.lex_state = 44}, [357] = {.lex_state = 44}, - [358] = {.lex_state = 45}, - [359] = {.lex_state = 45}, - [360] = {.lex_state = 0}, - [361] = {.lex_state = 234}, + [358] = {.lex_state = 44}, + [359] = {.lex_state = 44}, + [360] = {.lex_state = 45}, + [361] = {.lex_state = 45}, [362] = {.lex_state = 0}, [363] = {.lex_state = 234}, - [364] = {.lex_state = 234}, - [365] = {.lex_state = 0}, - [366] = {.lex_state = 0}, + [364] = {.lex_state = 0}, + [365] = {.lex_state = 234}, + [366] = {.lex_state = 234}, [367] = {.lex_state = 0}, [368] = {.lex_state = 0}, [369] = {.lex_state = 0}, - [370] = {.lex_state = 234}, + [370] = {.lex_state = 0}, [371] = {.lex_state = 0}, - [372] = {.lex_state = 0}, + [372] = {.lex_state = 234}, [373] = {.lex_state = 0}, - [374] = {.lex_state = 67}, - [375] = {.lex_state = 67}, + [374] = {.lex_state = 0}, + [375] = {.lex_state = 0}, [376] = {.lex_state = 0}, - [377] = {.lex_state = 0}, - [378] = {.lex_state = 52}, - [379] = {.lex_state = 234}, - [380] = {.lex_state = 234}, + [377] = {.lex_state = 67}, + [378] = {.lex_state = 67}, + [379] = {.lex_state = 0}, + [380] = {.lex_state = 52}, [381] = {.lex_state = 234}, [382] = {.lex_state = 234}, - [383] = {.lex_state = 0}, - [384] = {.lex_state = 0}, - [385] = {.lex_state = 234}, - [386] = {.lex_state = 234}, + [383] = {.lex_state = 234}, + [384] = {.lex_state = 234}, + [385] = {.lex_state = 0}, + [386] = {.lex_state = 0}, [387] = {.lex_state = 234}, - [388] = {.lex_state = 234}, + [388] = {.lex_state = 52}, [389] = {.lex_state = 234}, [390] = {.lex_state = 234}, - [391] = {.lex_state = 52}, + [391] = {.lex_state = 234}, [392] = {.lex_state = 234}, - [393] = {.lex_state = 0}, - [394] = {.lex_state = 0}, - [395] = {.lex_state = 0}, + [393] = {.lex_state = 234}, + [394] = {.lex_state = 234}, + [395] = {.lex_state = 234}, [396] = {.lex_state = 234}, [397] = {.lex_state = 0}, [398] = {.lex_state = 0}, - [399] = {.lex_state = 234}, + [399] = {.lex_state = 0}, [400] = {.lex_state = 0}, - [401] = {.lex_state = 234}, + [401] = {.lex_state = 0}, [402] = {.lex_state = 0}, [403] = {.lex_state = 0}, - [404] = {.lex_state = 68}, - [405] = {.lex_state = 234}, + [404] = {.lex_state = 234}, + [405] = {.lex_state = 68}, [406] = {.lex_state = 0}, - [407] = {.lex_state = 68}, + [407] = {.lex_state = 0}, [408] = {.lex_state = 234}, [409] = {.lex_state = 68}, - [410] = {.lex_state = 68}, - [411] = {.lex_state = 52}, - [412] = {.lex_state = 0}, - [413] = {.lex_state = 68}, + [410] = {.lex_state = 234}, + [411] = {.lex_state = 234}, + [412] = {.lex_state = 68}, + [413] = {.lex_state = 52}, [414] = {.lex_state = 234}, - [415] = {.lex_state = 234}, + [415] = {.lex_state = 68}, [416] = {.lex_state = 0}, - [417] = {.lex_state = 52}, - [418] = {.lex_state = 52}, - [419] = {.lex_state = 0}, + [417] = {.lex_state = 68}, + [418] = {.lex_state = 0}, + [419] = {.lex_state = 52}, [420] = {.lex_state = 52}, [421] = {.lex_state = 52}, [422] = {.lex_state = 0}, - [423] = {.lex_state = 52}, + [423] = {.lex_state = 0}, [424] = {.lex_state = 52}, [425] = {.lex_state = 0}, - [426] = {.lex_state = 52}, + [426] = {.lex_state = 0}, [427] = {.lex_state = 52}, [428] = {.lex_state = 52}, - [429] = {.lex_state = 0}, - [430] = {.lex_state = 0}, + [429] = {.lex_state = 52}, + [430] = {.lex_state = 52}, [431] = {.lex_state = 0}, - [432] = {.lex_state = 52}, - [433] = {.lex_state = 0}, - [434] = {.lex_state = 52}, + [432] = {.lex_state = 0}, + [433] = {.lex_state = 52}, + [434] = {.lex_state = 0}, [435] = {.lex_state = 52}, [436] = {.lex_state = 0}, - [437] = {.lex_state = 0}, - [438] = {.lex_state = 0}, - [439] = {.lex_state = 0}, + [437] = {.lex_state = 52}, + [438] = {.lex_state = 52}, + [439] = {.lex_state = 52}, [440] = {.lex_state = 0}, - [441] = {.lex_state = 0}, - [442] = {.lex_state = 0}, + [441] = {.lex_state = 52}, + [442] = {.lex_state = 52}, [443] = {.lex_state = 0}, [444] = {.lex_state = 0}, [445] = {.lex_state = 0}, [446] = {.lex_state = 0}, - [447] = {.lex_state = 52}, - [448] = {.lex_state = 52}, - [449] = {.lex_state = 52}, - [450] = {.lex_state = 52}, - [451] = {.lex_state = 0}, - [452] = {.lex_state = 52}, + [447] = {.lex_state = 0}, + [448] = {.lex_state = 0}, + [449] = {.lex_state = 0}, + [450] = {.lex_state = 0}, + [451] = {.lex_state = 52}, + [452] = {.lex_state = 0}, [453] = {.lex_state = 52}, [454] = {.lex_state = 52}, [455] = {.lex_state = 52}, - [456] = {.lex_state = 52}, - [457] = {.lex_state = 0}, - [458] = {.lex_state = 65}, + [456] = {.lex_state = 0}, + [457] = {.lex_state = 52}, + [458] = {.lex_state = 52}, [459] = {.lex_state = 0}, [460] = {.lex_state = 65}, - [461] = {.lex_state = 35}, - [462] = {.lex_state = 35}, + [461] = {.lex_state = 0}, + [462] = {.lex_state = 65}, [463] = {.lex_state = 35}, [464] = {.lex_state = 35}, [465] = {.lex_state = 65}, - [466] = {.lex_state = 65}, - [467] = {.lex_state = 68}, + [466] = {.lex_state = 35}, + [467] = {.lex_state = 35}, [468] = {.lex_state = 67}, [469] = {.lex_state = 234}, - [470] = {.lex_state = 47}, - [471] = {.lex_state = 234}, + [470] = {.lex_state = 65}, + [471] = {.lex_state = 60}, [472] = {.lex_state = 67}, [473] = {.lex_state = 65}, - [474] = {.lex_state = 234}, + [474] = {.lex_state = 65}, [475] = {.lex_state = 60}, - [476] = {.lex_state = 65}, - [477] = {.lex_state = 60}, - [478] = {.lex_state = 65}, - [479] = {.lex_state = 47}, + [476] = {.lex_state = 68}, + [477] = {.lex_state = 65}, + [478] = {.lex_state = 47}, + [479] = {.lex_state = 234}, [480] = {.lex_state = 234}, - [481] = {.lex_state = 60}, + [481] = {.lex_state = 71}, [482] = {.lex_state = 53}, - [483] = {.lex_state = 0}, + [483] = {.lex_state = 234}, [484] = {.lex_state = 0}, - [485] = {.lex_state = 71}, - [486] = {.lex_state = 234}, - [487] = {.lex_state = 0}, - [488] = {.lex_state = 0}, - [489] = {.lex_state = 71}, + [485] = {.lex_state = 60}, + [486] = {.lex_state = 47}, + [487] = {.lex_state = 234}, + [488] = {.lex_state = 71}, + [489] = {.lex_state = 0}, [490] = {.lex_state = 47}, [491] = {.lex_state = 0}, [492] = {.lex_state = 0}, [493] = {.lex_state = 67}, [494] = {.lex_state = 67}, [495] = {.lex_state = 67}, - [496] = {.lex_state = 0}, + [496] = {.lex_state = 67}, [497] = {.lex_state = 67}, - [498] = {.lex_state = 67}, - [499] = {.lex_state = 0}, - [500] = {.lex_state = 0}, + [498] = {.lex_state = 0}, + [499] = {.lex_state = 67}, + [500] = {.lex_state = 67}, [501] = {.lex_state = 67}, - [502] = {.lex_state = 0}, - [503] = {.lex_state = 50}, + [502] = {.lex_state = 67}, + [503] = {.lex_state = 0}, [504] = {.lex_state = 67}, - [505] = {.lex_state = 67}, + [505] = {.lex_state = 50}, [506] = {.lex_state = 67}, [507] = {.lex_state = 67}, - [508] = {.lex_state = 67}, + [508] = {.lex_state = 0}, [509] = {.lex_state = 0}, [510] = {.lex_state = 67}, - [511] = {.lex_state = 67}, - [512] = {.lex_state = 67}, + [511] = {.lex_state = 0}, + [512] = {.lex_state = 0}, [513] = {.lex_state = 67}, [514] = {.lex_state = 67}, - [515] = {.lex_state = 69}, + [515] = {.lex_state = 67}, [516] = {.lex_state = 0}, - [517] = {.lex_state = 52}, - [518] = {.lex_state = 0}, + [517] = {.lex_state = 0}, + [518] = {.lex_state = 35}, [519] = {.lex_state = 0}, - [520] = {.lex_state = 0}, - [521] = {.lex_state = 52}, - [522] = {.lex_state = 0}, - [523] = {.lex_state = 35}, - [524] = {.lex_state = 35}, - [525] = {.lex_state = 52}, - [526] = {.lex_state = 67}, - [527] = {.lex_state = 52}, + [520] = {.lex_state = 67}, + [521] = {.lex_state = 67}, + [522] = {.lex_state = 69}, + [523] = {.lex_state = 69}, + [524] = {.lex_state = 67}, + [525] = {.lex_state = 0}, + [526] = {.lex_state = 0}, + [527] = {.lex_state = 68}, [528] = {.lex_state = 52}, [529] = {.lex_state = 0}, [530] = {.lex_state = 0}, - [531] = {.lex_state = 0}, - [532] = {.lex_state = 67}, - [533] = {.lex_state = 0}, - [534] = {.lex_state = 67}, - [535] = {.lex_state = 69}, - [536] = {.lex_state = 67}, - [537] = {.lex_state = 35}, + [531] = {.lex_state = 52}, + [532] = {.lex_state = 52}, + [533] = {.lex_state = 52}, + [534] = {.lex_state = 0}, + [535] = {.lex_state = 0}, + [536] = {.lex_state = 0}, + [537] = {.lex_state = 0}, [538] = {.lex_state = 35}, - [539] = {.lex_state = 0}, - [540] = {.lex_state = 67}, - [541] = {.lex_state = 0}, - [542] = {.lex_state = 0}, - [543] = {.lex_state = 69}, - [544] = {.lex_state = 69}, + [539] = {.lex_state = 35}, + [540] = {.lex_state = 35}, + [541] = {.lex_state = 52}, + [542] = {.lex_state = 69}, + [543] = {.lex_state = 0}, + [544] = {.lex_state = 0}, [545] = {.lex_state = 0}, - [546] = {.lex_state = 0}, + [546] = {.lex_state = 69}, [547] = {.lex_state = 67}, - [548] = {.lex_state = 0}, + [548] = {.lex_state = 67}, [549] = {.lex_state = 0}, - [550] = {.lex_state = 52}, - [551] = {.lex_state = 68}, + [550] = {.lex_state = 67}, + [551] = {.lex_state = 0}, [552] = {.lex_state = 0}, - [553] = {.lex_state = 0}, + [553] = {.lex_state = 52}, [554] = {.lex_state = 0}, - [555] = {.lex_state = 0}, - [556] = {.lex_state = 53}, - [557] = {.lex_state = 0}, - [558] = {.lex_state = 0}, + [555] = {.lex_state = 67}, + [556] = {.lex_state = 0}, + [557] = {.lex_state = 53}, + [558] = {.lex_state = 67}, [559] = {.lex_state = 0}, - [560] = {.lex_state = 67}, - [561] = {.lex_state = 67}, - [562] = {.lex_state = 67}, - [563] = {.lex_state = 67}, + [560] = {.lex_state = 0}, + [561] = {.lex_state = 0}, + [562] = {.lex_state = 0}, + [563] = {.lex_state = 0}, [564] = {.lex_state = 0}, [565] = {.lex_state = 0}, [566] = {.lex_state = 0}, @@ -6388,7 +6388,7 @@ static TSLexMode ts_lex_modes[STATE_COUNT] = { [570] = {.lex_state = 0}, [571] = {.lex_state = 0}, [572] = {.lex_state = 0}, - [573] = {.lex_state = 67}, + [573] = {.lex_state = 0}, [574] = {.lex_state = 0}, [575] = {.lex_state = 0}, [576] = {.lex_state = 0}, @@ -6398,75 +6398,75 @@ static TSLexMode ts_lex_modes[STATE_COUNT] = { [580] = {.lex_state = 0}, [581] = {.lex_state = 0}, [582] = {.lex_state = 0}, - [583] = {.lex_state = 0}, - [584] = {.lex_state = 53}, - [585] = {.lex_state = 67}, - [586] = {.lex_state = 67}, + [583] = {.lex_state = 67}, + [584] = {.lex_state = 0}, + [585] = {.lex_state = 0}, + [586] = {.lex_state = 0}, [587] = {.lex_state = 0}, [588] = {.lex_state = 0}, [589] = {.lex_state = 0}, - [590] = {.lex_state = 0}, + [590] = {.lex_state = 67}, [591] = {.lex_state = 0}, - [592] = {.lex_state = 53}, + [592] = {.lex_state = 0}, [593] = {.lex_state = 0}, - [594] = {.lex_state = 67}, - [595] = {.lex_state = 0}, + [594] = {.lex_state = 0}, + [595] = {.lex_state = 67}, [596] = {.lex_state = 0}, [597] = {.lex_state = 0}, [598] = {.lex_state = 0}, [599] = {.lex_state = 0}, [600] = {.lex_state = 0}, [601] = {.lex_state = 0}, - [602] = {.lex_state = 0}, + [602] = {.lex_state = 67}, [603] = {.lex_state = 0}, [604] = {.lex_state = 0}, [605] = {.lex_state = 0}, [606] = {.lex_state = 0}, - [607] = {.lex_state = 67}, + [607] = {.lex_state = 0}, [608] = {.lex_state = 0}, - [609] = {.lex_state = 0}, - [610] = {.lex_state = 0}, + [609] = {.lex_state = 67}, + [610] = {.lex_state = 67}, [611] = {.lex_state = 0}, - [612] = {.lex_state = 67}, + [612] = {.lex_state = 0}, [613] = {.lex_state = 0}, - [614] = {.lex_state = 0}, - [615] = {.lex_state = 0}, + [614] = {.lex_state = 220}, + [615] = {.lex_state = 67}, [616] = {.lex_state = 0}, - [617] = {.lex_state = 0}, + [617] = {.lex_state = 67}, [618] = {.lex_state = 0}, [619] = {.lex_state = 0}, [620] = {.lex_state = 0}, [621] = {.lex_state = 0}, [622] = {.lex_state = 0}, - [623] = {.lex_state = 67}, - [624] = {.lex_state = 220}, + [623] = {.lex_state = 0}, + [624] = {.lex_state = 0}, [625] = {.lex_state = 0}, - [626] = {.lex_state = 0}, - [627] = {.lex_state = 0}, - [628] = {.lex_state = 0}, + [626] = {.lex_state = 220}, + [627] = {.lex_state = 67}, + [628] = {.lex_state = 53}, [629] = {.lex_state = 0}, - [630] = {.lex_state = 67}, + [630] = {.lex_state = 0}, [631] = {.lex_state = 0}, - [632] = {.lex_state = 0}, - [633] = {.lex_state = 67}, + [632] = {.lex_state = 67}, + [633] = {.lex_state = 0}, [634] = {.lex_state = 0}, - [635] = {.lex_state = 0}, - [636] = {.lex_state = 67}, - [637] = {.lex_state = 220}, + [635] = {.lex_state = 67}, + [636] = {.lex_state = 53}, + [637] = {.lex_state = 67}, [638] = {.lex_state = 0}, [639] = {.lex_state = 0}, - [640] = {.lex_state = 50}, + [640] = {.lex_state = 0}, [641] = {.lex_state = 0}, [642] = {.lex_state = 0}, - [643] = {.lex_state = 0}, - [644] = {.lex_state = 0}, + [643] = {.lex_state = 50}, + [644] = {.lex_state = 50}, [645] = {.lex_state = 0}, [646] = {.lex_state = 0}, - [647] = {.lex_state = 50}, + [647] = {.lex_state = 0}, [648] = {.lex_state = 0}, - [649] = {.lex_state = 234}, + [649] = {.lex_state = 0}, [650] = {.lex_state = 0}, - [651] = {.lex_state = 0}, + [651] = {.lex_state = 234}, [652] = {.lex_state = 0}, [653] = {.lex_state = 0}, [654] = {.lex_state = 0}, @@ -6489,21 +6489,21 @@ static TSLexMode ts_lex_modes[STATE_COUNT] = { [671] = {.lex_state = 0}, [672] = {.lex_state = 0}, [673] = {.lex_state = 0}, - [674] = {.lex_state = 67}, + [674] = {.lex_state = 0}, [675] = {.lex_state = 0}, [676] = {.lex_state = 0}, - [677] = {.lex_state = 0}, - [678] = {.lex_state = 50}, + [677] = {.lex_state = 67}, + [678] = {.lex_state = 0}, [679] = {.lex_state = 0}, - [680] = {.lex_state = 0}, + [680] = {.lex_state = 50}, [681] = {.lex_state = 0}, [682] = {.lex_state = 0}, [683] = {.lex_state = 0}, [684] = {.lex_state = 0}, [685] = {.lex_state = 0}, - [686] = {.lex_state = 67}, + [686] = {.lex_state = 0}, [687] = {.lex_state = 0}, - [688] = {.lex_state = 0}, + [688] = {.lex_state = 67}, [689] = {.lex_state = 0}, [690] = {.lex_state = 0}, [691] = {.lex_state = 0}, @@ -6514,17 +6514,17 @@ static TSLexMode ts_lex_modes[STATE_COUNT] = { [696] = {.lex_state = 0}, [697] = {.lex_state = 0}, [698] = {.lex_state = 0}, - [699] = {.lex_state = 67}, + [699] = {.lex_state = 0}, [700] = {.lex_state = 0}, - [701] = {.lex_state = 0}, + [701] = {.lex_state = 67}, [702] = {.lex_state = 0}, [703] = {.lex_state = 0}, [704] = {.lex_state = 0}, [705] = {.lex_state = 0}, [706] = {.lex_state = 0}, - [707] = {.lex_state = 0}, + [707] = {.lex_state = 67}, [708] = {.lex_state = 0}, - [709] = {.lex_state = 67}, + [709] = {.lex_state = 0}, [710] = {.lex_state = 0}, [711] = {.lex_state = 0}, [712] = {.lex_state = 0}, @@ -6544,17 +6544,17 @@ static TSLexMode ts_lex_modes[STATE_COUNT] = { [726] = {.lex_state = 0}, [727] = {.lex_state = 0}, [728] = {.lex_state = 0}, - [729] = {.lex_state = 0}, - [730] = {.lex_state = 234}, + [729] = {.lex_state = 234}, + [730] = {.lex_state = 0}, [731] = {.lex_state = 0}, [732] = {.lex_state = 0}, [733] = {.lex_state = 0}, [734] = {.lex_state = 0}, [735] = {.lex_state = 0}, [736] = {.lex_state = 0}, - [737] = {.lex_state = 234}, + [737] = {.lex_state = 0}, [738] = {.lex_state = 0}, - [739] = {.lex_state = 0}, + [739] = {.lex_state = 234}, [740] = {.lex_state = 0}, [741] = {.lex_state = 0}, [742] = {.lex_state = 0}, @@ -6585,9 +6585,9 @@ static TSLexMode ts_lex_modes[STATE_COUNT] = { [767] = {.lex_state = 0}, [768] = {.lex_state = 0}, [769] = {.lex_state = 0}, - [770] = {.lex_state = 234}, + [770] = {.lex_state = 0}, [771] = {.lex_state = 0}, - [772] = {.lex_state = 0}, + [772] = {.lex_state = 234}, [773] = {.lex_state = 0}, [774] = {.lex_state = 0}, [775] = {.lex_state = 0}, @@ -6626,15 +6626,17 @@ static TSLexMode ts_lex_modes[STATE_COUNT] = { [808] = {.lex_state = 0}, [809] = {.lex_state = 0}, [810] = {.lex_state = 0}, - [811] = {.lex_state = 50}, + [811] = {.lex_state = 0}, [812] = {.lex_state = 0}, - [813] = {.lex_state = 234}, + [813] = {.lex_state = 50}, [814] = {.lex_state = 0}, - [815] = {.lex_state = 0}, + [815] = {.lex_state = 234}, [816] = {.lex_state = 0}, - [817] = {.lex_state = 234}, + [817] = {.lex_state = 0}, [818] = {.lex_state = 0}, [819] = {.lex_state = 234}, + [820] = {.lex_state = 0}, + [821] = {.lex_state = 234}, }; static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { @@ -6769,22 +6771,22 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [1] = { - [sym_unit] = STATE(782), - [sym_imports] = STATE(361), - [sym_use_statement] = STATE(379), - [sym_declarations] = STATE(775), - [sym_declaration] = STATE(772), - [sym_global_declaration] = STATE(771), - [sym_decl_attr] = STATE(469), - [sym_constant_declaration] = STATE(771), - [sym_type_declaration] = STATE(771), - [sym_function_declaration] = STATE(771), - [sym_fndec_attrs] = STATE(770), - [sym_fndec_attr] = STATE(408), - [sym_fntype_attr] = STATE(469), - [aux_sym_imports_repeat1] = STATE(379), - [aux_sym_declarations_repeat1] = STATE(364), - [aux_sym_fndec_attrs_repeat1] = STATE(408), + [sym_unit] = STATE(784), + [sym_imports] = STATE(363), + [sym_use_statement] = STATE(381), + [sym_declarations] = STATE(777), + [sym_declaration] = STATE(774), + [sym_global_declaration] = STATE(773), + [sym_decl_attr] = STATE(479), + [sym_constant_declaration] = STATE(773), + [sym_type_declaration] = STATE(773), + [sym_function_declaration] = STATE(773), + [sym_fndec_attrs] = STATE(772), + [sym_fndec_attr] = STATE(411), + [sym_fntype_attr] = STATE(479), + [aux_sym_imports_repeat1] = STATE(381), + [aux_sym_declarations_repeat1] = STATE(366), + [aux_sym_fndec_attrs_repeat1] = STATE(411), [ts_builtin_sym_end] = ACTIONS(5), [anon_sym_use] = ACTIONS(7), [anon_sym_export] = ACTIONS(9), @@ -6801,58 +6803,58 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [2] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(278), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(395), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(281), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(402), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(817), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(443), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(449), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_SEMI] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_RBRACE] = ACTIONS(25), @@ -6916,58 +6918,58 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [3] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(286), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(288), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), [sym_object_selector] = STATE(400), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(819), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(443), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(821), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(449), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_SEMI] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_RBRACE] = ACTIONS(25), @@ -7030,58 +7032,58 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [4] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(328), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(397), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(335), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(398), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(813), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(443), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(815), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(449), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_SEMI] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(113), @@ -7141,61 +7143,61 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [5] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(286), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(288), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), [sym_object_selector] = STATE(400), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(819), - [sym_switch_expression] = STATE(425), - [sym_switch_cases] = STATE(716), - [sym_switch_case] = STATE(579), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(821), + [sym_switch_expression] = STATE(422), + [sym_switch_cases] = STATE(719), + [sym_switch_case] = STATE(633), [sym_case_options] = STATE(726), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(578), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(630), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_RBRACE] = ACTIONS(127), [anon_sym_let] = ACTIONS(99), @@ -7251,58 +7253,58 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [6] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(355), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(393), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(349), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(399), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(730), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(443), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(729), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(449), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_SEMI] = ACTIONS(25), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(131), @@ -7361,61 +7363,61 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [7] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(286), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(288), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), [sym_object_selector] = STATE(400), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(819), - [sym_switch_expression] = STATE(425), - [sym_switch_cases] = STATE(727), - [sym_switch_case] = STATE(579), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(821), + [sym_switch_expression] = STATE(422), + [sym_switch_cases] = STATE(728), + [sym_switch_case] = STATE(633), [sym_case_options] = STATE(726), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(578), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(630), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(99), [anon_sym_const] = ACTIONS(99), @@ -7470,59 +7472,59 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [8] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_append_values] = STATE(722), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(286), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_append_values] = STATE(723), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(288), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), [sym_object_selector] = STATE(400), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(819), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(622), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(821), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(563), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(99), [anon_sym_const] = ACTIONS(99), @@ -7579,59 +7581,59 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [9] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_tuple_items] = STATE(779), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(286), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_argument_list] = STATE(769), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(288), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), [sym_object_selector] = STATE(400), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(819), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(600), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(821), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(541), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(99), [anon_sym_const] = ACTIONS(99), @@ -7687,64 +7689,65 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [10] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(286), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_tuple_items] = STATE(780), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(288), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), [sym_object_selector] = STATE(400), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(819), - [sym_switch_expression] = STATE(425), - [sym_case_options] = STATE(715), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(578), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(821), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(580), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(99), [anon_sym_const] = ACTIONS(99), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_RPAREN] = ACTIONS(151), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), @@ -7785,7 +7788,6 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_if] = ACTIONS(105), [anon_sym_for] = ACTIONS(107), [anon_sym_switch] = ACTIONS(87), - [anon_sym_EQ_GT] = ACTIONS(151), [anon_sym_match] = ACTIONS(89), [anon_sym_defer] = ACTIONS(109), [anon_sym_break] = ACTIONS(93), @@ -7795,59 +7797,59 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [11] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_array_members] = STATE(778), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(286), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(288), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), [sym_object_selector] = STATE(400), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(819), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(517), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(821), + [sym_switch_expression] = STATE(422), + [sym_case_options] = STATE(718), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(630), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(99), [anon_sym_const] = ACTIONS(99), @@ -7859,7 +7861,6 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_STAR] = ACTIONS(101), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), - [anon_sym_RBRACK] = ACTIONS(153), [anon_sym_true] = ACTIONS(37), [anon_sym_false] = ACTIONS(37), [anon_sym_null] = ACTIONS(37), @@ -7894,6 +7895,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_if] = ACTIONS(105), [anon_sym_for] = ACTIONS(107), [anon_sym_switch] = ACTIONS(87), + [anon_sym_EQ_GT] = ACTIONS(153), [anon_sym_match] = ACTIONS(89), [anon_sym_defer] = ACTIONS(109), [anon_sym_break] = ACTIONS(93), @@ -7903,71 +7905,71 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [12] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_argument_list] = STATE(773), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(286), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_append_values] = STATE(713), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(288), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), [sym_object_selector] = STATE(400), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(819), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(525), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(821), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(563), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(99), [anon_sym_const] = ACTIONS(99), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), - [anon_sym_RPAREN] = ACTIONS(155), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), [anon_sym_STAR] = ACTIONS(101), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_DOT_DOT_DOT] = ACTIONS(147), [anon_sym_true] = ACTIONS(37), [anon_sym_false] = ACTIONS(37), [anon_sym_null] = ACTIONS(37), @@ -8011,71 +8013,71 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [13] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_argument_list] = STATE(745), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(286), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_append_values] = STATE(709), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(288), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), [sym_object_selector] = STATE(400), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(819), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(525), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(821), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(563), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(99), [anon_sym_const] = ACTIONS(99), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), - [anon_sym_RPAREN] = ACTIONS(157), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), [anon_sym_STAR] = ACTIONS(101), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_DOT_DOT_DOT] = ACTIONS(147), [anon_sym_true] = ACTIONS(37), [anon_sym_false] = ACTIONS(37), [anon_sym_null] = ACTIONS(37), @@ -8119,59 +8121,59 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [14] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_append_values] = STATE(710), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(286), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_array_members] = STATE(778), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(288), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), [sym_object_selector] = STATE(400), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(819), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(622), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(821), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(531), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(99), [anon_sym_const] = ACTIONS(99), @@ -8183,7 +8185,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_STAR] = ACTIONS(101), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), - [anon_sym_DOT_DOT_DOT] = ACTIONS(147), + [anon_sym_RBRACK] = ACTIONS(155), [anon_sym_true] = ACTIONS(37), [anon_sym_false] = ACTIONS(37), [anon_sym_null] = ACTIONS(37), @@ -8227,59 +8229,59 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [15] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_append_values] = STATE(706), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(286), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_append_values] = STATE(752), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(288), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), [sym_object_selector] = STATE(400), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(819), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(622), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(821), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(563), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(99), [anon_sym_const] = ACTIONS(99), @@ -8335,59 +8337,59 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [16] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_append_values] = STATE(750), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(286), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_array_members] = STATE(779), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(288), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), [sym_object_selector] = STATE(400), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(819), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(622), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(821), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(531), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(99), [anon_sym_const] = ACTIONS(99), @@ -8399,7 +8401,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_STAR] = ACTIONS(101), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), - [anon_sym_DOT_DOT_DOT] = ACTIONS(147), + [anon_sym_RBRACK] = ACTIONS(157), [anon_sym_true] = ACTIONS(37), [anon_sym_false] = ACTIONS(37), [anon_sym_null] = ACTIONS(37), @@ -8443,69 +8445,69 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [17] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_argument_list] = STATE(690), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(286), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(400), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(349), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(399), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(819), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(525), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(729), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_expression_list] = STATE(763), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(751), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(99), - [anon_sym_const] = ACTIONS(99), + [anon_sym_RBRACE] = ACTIONS(159), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), - [anon_sym_RPAREN] = ACTIONS(159), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(101), + [anon_sym_STAR] = ACTIONS(133), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -8531,7 +8533,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(103), + [anon_sym_static] = ACTIONS(135), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -8539,83 +8541,83 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(105), - [anon_sym_for] = ACTIONS(107), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(109), + [anon_sym_defer] = ACTIONS(141), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(111), + [anon_sym_return] = ACTIONS(143), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [18] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_append_values] = STATE(733), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(286), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_argument_list] = STATE(745), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(288), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), [sym_object_selector] = STATE(400), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(819), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(622), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(821), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(541), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(99), [anon_sym_const] = ACTIONS(99), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_RPAREN] = ACTIONS(161), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), [anon_sym_STAR] = ACTIONS(101), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), - [anon_sym_DOT_DOT_DOT] = ACTIONS(147), [anon_sym_true] = ACTIONS(37), [anon_sym_false] = ACTIONS(37), [anon_sym_null] = ACTIONS(37), @@ -8659,59 +8661,59 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [19] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_array_members] = STATE(777), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(286), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_array_members] = STATE(672), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(288), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), [sym_object_selector] = STATE(400), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(819), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(517), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(821), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(531), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(99), [anon_sym_const] = ACTIONS(99), @@ -8723,7 +8725,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_STAR] = ACTIONS(101), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), - [anon_sym_RBRACK] = ACTIONS(161), + [anon_sym_RBRACK] = ACTIONS(163), [anon_sym_true] = ACTIONS(37), [anon_sym_false] = ACTIONS(37), [anon_sym_null] = ACTIONS(37), @@ -8767,69 +8769,69 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [20] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(355), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(393), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_argument_list] = STATE(693), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(288), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(730), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_expression_list] = STATE(761), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(717), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(821), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(541), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_RBRACE] = ACTIONS(163), - [anon_sym_let] = ACTIONS(131), - [anon_sym_const] = ACTIONS(131), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), + [anon_sym_RPAREN] = ACTIONS(165), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(133), + [anon_sym_STAR] = ACTIONS(101), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -8855,7 +8857,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(135), + [anon_sym_static] = ACTIONS(103), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -8863,71 +8865,71 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(137), - [anon_sym_for] = ACTIONS(139), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(141), + [anon_sym_defer] = ACTIONS(109), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(143), + [anon_sym_return] = ACTIONS(111), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [21] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_array_members] = STATE(669), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(286), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_append_values] = STATE(735), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(288), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), [sym_object_selector] = STATE(400), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(819), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(517), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(821), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(563), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(99), [anon_sym_const] = ACTIONS(99), @@ -8939,7 +8941,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_STAR] = ACTIONS(101), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), - [anon_sym_RBRACK] = ACTIONS(165), + [anon_sym_DOT_DOT_DOT] = ACTIONS(147), [anon_sym_true] = ACTIONS(37), [anon_sym_false] = ACTIONS(37), [anon_sym_null] = ACTIONS(37), @@ -8983,58 +8985,58 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [22] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(355), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(393), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(349), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(399), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(730), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(584), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(729), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(636), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(131), [anon_sym_const] = ACTIONS(131), @@ -9090,58 +9092,58 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [23] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(355), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(393), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(349), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(399), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(730), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(763), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(729), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(557), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(131), [anon_sym_const] = ACTIONS(131), @@ -9153,7 +9155,6 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_STAR] = ACTIONS(133), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), - [anon_sym_RBRACK] = ACTIONS(169), [anon_sym_true] = ACTIONS(37), [anon_sym_false] = ACTIONS(37), [anon_sym_null] = ACTIONS(37), @@ -9181,6 +9182,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), + [anon_sym_DOT_DOT] = ACTIONS(169), [anon_sym_PLUS] = ACTIONS(35), [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), @@ -9197,67 +9199,68 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [24] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(355), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(393), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_tuple_items] = STATE(780), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(288), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(730), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(592), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(821), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(580), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(131), - [anon_sym_const] = ACTIONS(131), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(133), + [anon_sym_STAR] = ACTIONS(101), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -9283,80 +9286,78 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(135), + [anon_sym_static] = ACTIONS(103), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), - [anon_sym_DOT_DOT] = ACTIONS(171), [anon_sym_PLUS] = ACTIONS(35), [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(137), - [anon_sym_for] = ACTIONS(139), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(141), + [anon_sym_defer] = ACTIONS(109), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(143), + [anon_sym_return] = ACTIONS(111), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [25] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(355), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(393), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(349), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(399), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_for_predicate] = STATE(774), - [sym_label] = STATE(730), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(577), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(574), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(729), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(742), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(131), [anon_sym_const] = ACTIONS(131), @@ -9368,6 +9369,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_STAR] = ACTIONS(133), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_RBRACK] = ACTIONS(171), [anon_sym_true] = ACTIONS(37), [anon_sym_false] = ACTIONS(37), [anon_sym_null] = ACTIONS(37), @@ -9411,68 +9413,68 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [26] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(355), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(393), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_tuple_items] = STATE(767), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(288), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_for_predicate] = STATE(803), - [sym_label] = STATE(730), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(577), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(574), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(821), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(623), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(131), - [anon_sym_const] = ACTIONS(131), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(133), + [anon_sym_STAR] = ACTIONS(101), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -9498,7 +9500,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(135), + [anon_sym_static] = ACTIONS(103), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -9506,80 +9508,80 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(137), - [anon_sym_for] = ACTIONS(139), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(141), + [anon_sym_defer] = ACTIONS(109), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(143), + [anon_sym_return] = ACTIONS(111), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [27] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_tuple_items] = STATE(765), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(286), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(400), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(349), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(399), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(819), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(619), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_for_predicate] = STATE(700), + [sym_label] = STATE(729), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(589), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(587), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(99), - [anon_sym_const] = ACTIONS(99), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(101), + [anon_sym_STAR] = ACTIONS(133), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -9605,7 +9607,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(103), + [anon_sym_static] = ACTIONS(135), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -9613,71 +9615,71 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(105), - [anon_sym_for] = ACTIONS(107), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(109), + [anon_sym_defer] = ACTIONS(141), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(111), + [anon_sym_return] = ACTIONS(143), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [28] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(355), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(393), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(349), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(399), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(730), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_expression_list] = STATE(749), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(717), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_for_predicate] = STATE(805), + [sym_label] = STATE(729), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(589), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(587), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(131), [anon_sym_const] = ACTIONS(131), @@ -9732,68 +9734,67 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [29] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_tuple_items] = STATE(779), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(286), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(400), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(349), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(399), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(819), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(600), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(729), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(628), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(99), - [anon_sym_const] = ACTIONS(99), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(101), + [anon_sym_STAR] = ACTIONS(133), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -9819,78 +9820,80 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(103), + [anon_sym_static] = ACTIONS(135), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), + [anon_sym_DOT_DOT] = ACTIONS(169), [anon_sym_PLUS] = ACTIONS(35), [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(105), - [anon_sym_for] = ACTIONS(107), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(109), + [anon_sym_defer] = ACTIONS(141), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(111), + [anon_sym_return] = ACTIONS(143), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [30] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(355), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(393), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(349), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(399), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(730), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(556), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_for_predicate] = STATE(708), + [sym_label] = STATE(729), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(589), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(587), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(131), [anon_sym_const] = ACTIONS(131), @@ -9929,7 +9932,6 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), - [anon_sym_DOT_DOT] = ACTIONS(171), [anon_sym_PLUS] = ACTIONS(35), [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), @@ -9946,59 +9948,59 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [31] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_tuple_items] = STATE(667), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(286), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_tuple_items] = STATE(670), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(288), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), [sym_object_selector] = STATE(400), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(819), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(821), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), [sym_expression] = STATE(581), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(99), [anon_sym_const] = ACTIONS(99), @@ -10053,59 +10055,58 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [32] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(355), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(393), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(349), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(399), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_for_predicate] = STATE(697), - [sym_label] = STATE(730), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(577), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(574), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(729), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(766), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(131), [anon_sym_const] = ACTIONS(131), @@ -10117,6 +10118,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_STAR] = ACTIONS(133), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_RBRACK] = ACTIONS(173), [anon_sym_true] = ACTIONS(37), [anon_sym_false] = ACTIONS(37), [anon_sym_null] = ACTIONS(37), @@ -10160,59 +10162,58 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [33] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(355), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(393), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(349), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(399), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_for_predicate] = STATE(753), - [sym_label] = STATE(730), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(577), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(574), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(729), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(703), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(131), [anon_sym_const] = ACTIONS(131), @@ -10224,6 +10225,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_STAR] = ACTIONS(133), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_RBRACK] = ACTIONS(175), [anon_sym_true] = ACTIONS(37), [anon_sym_false] = ACTIONS(37), [anon_sym_null] = ACTIONS(37), @@ -10267,59 +10269,59 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [34] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(355), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(393), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(349), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(399), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_for_predicate] = STATE(705), - [sym_label] = STATE(730), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(577), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(574), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_for_predicate] = STATE(731), + [sym_label] = STATE(729), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(589), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(587), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(131), [anon_sym_const] = ACTIONS(131), @@ -10374,59 +10376,59 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [35] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(355), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(393), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(349), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(399), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_for_predicate] = STATE(728), - [sym_label] = STATE(730), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(577), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(574), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_for_predicate] = STATE(732), + [sym_label] = STATE(729), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(589), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(587), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(131), [anon_sym_const] = ACTIONS(131), @@ -10481,59 +10483,59 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [36] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(355), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(393), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(349), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(399), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_for_predicate] = STATE(729), - [sym_label] = STATE(730), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(577), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(574), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(729), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_expression_list] = STATE(768), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(751), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(131), [anon_sym_const] = ACTIONS(131), @@ -10588,58 +10590,59 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [37] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(355), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(393), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(349), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(399), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(730), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(700), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_for_predicate] = STATE(771), + [sym_label] = STATE(729), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(589), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(587), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(131), [anon_sym_const] = ACTIONS(131), @@ -10651,7 +10654,6 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_STAR] = ACTIONS(133), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), - [anon_sym_RBRACK] = ACTIONS(173), [anon_sym_true] = ACTIONS(37), [anon_sym_false] = ACTIONS(37), [anon_sym_null] = ACTIONS(37), @@ -10695,58 +10697,59 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [38] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(355), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(393), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(349), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(399), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(730), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(743), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_for_predicate] = STATE(776), + [sym_label] = STATE(729), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(589), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(587), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(131), [anon_sym_const] = ACTIONS(131), @@ -10758,7 +10761,6 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_STAR] = ACTIONS(133), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), - [anon_sym_RBRACK] = ACTIONS(175), [anon_sym_true] = ACTIONS(37), [anon_sym_false] = ACTIONS(37), [anon_sym_null] = ACTIONS(37), @@ -10802,59 +10804,59 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [39] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(355), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(393), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(349), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(399), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_for_predicate] = STATE(769), - [sym_label] = STATE(730), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(577), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(574), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_for_predicate] = STATE(754), + [sym_label] = STATE(729), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(589), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(587), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(131), [anon_sym_const] = ACTIONS(131), @@ -10909,58 +10911,58 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [40] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(355), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(393), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(349), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(399), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(730), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(708), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(729), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(711), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(131), [anon_sym_const] = ACTIONS(131), @@ -11016,67 +11018,67 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [41] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(286), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(400), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(349), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(399), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(819), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(445), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(729), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(687), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(99), - [anon_sym_const] = ACTIONS(99), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(101), + [anon_sym_STAR] = ACTIONS(133), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -11102,7 +11104,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(103), + [anon_sym_static] = ACTIONS(135), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -11110,70 +11112,70 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(105), - [anon_sym_for] = ACTIONS(107), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(109), + [anon_sym_defer] = ACTIONS(141), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(111), + [anon_sym_return] = ACTIONS(143), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [42] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(286), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(288), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), [sym_object_selector] = STATE(400), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(819), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(821), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), [sym_expression] = STATE(564), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(99), [anon_sym_const] = ACTIONS(99), @@ -11228,58 +11230,58 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [43] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(278), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(395), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(281), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(402), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(817), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(445), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(446), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(29), [anon_sym_const] = ACTIONS(29), @@ -11334,58 +11336,58 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [44] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(278), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(395), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(281), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(402), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(817), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), [sym_expression] = STATE(444), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(29), [anon_sym_const] = ACTIONS(29), @@ -11440,58 +11442,58 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [45] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(278), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(395), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(281), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(402), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(817), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(451), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(456), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(29), [anon_sym_const] = ACTIONS(29), @@ -11546,67 +11548,67 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [46] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(328), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(397), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(349), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(399), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(813), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(451), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(729), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(444), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(113), - [anon_sym_const] = ACTIONS(113), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(115), + [anon_sym_STAR] = ACTIONS(133), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -11632,7 +11634,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(117), + [anon_sym_static] = ACTIONS(135), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -11640,70 +11642,70 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(119), - [anon_sym_for] = ACTIONS(121), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(123), + [anon_sym_defer] = ACTIONS(141), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(125), + [anon_sym_return] = ACTIONS(143), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [47] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(286), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(288), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), [sym_object_selector] = STATE(400), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(819), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(438), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(821), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(432), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(99), [anon_sym_const] = ACTIONS(99), @@ -11758,58 +11760,58 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [48] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(286), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(288), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), [sym_object_selector] = STATE(400), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(819), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(429), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(821), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(447), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(99), [anon_sym_const] = ACTIONS(99), @@ -11864,58 +11866,58 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [49] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(278), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(395), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(281), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(402), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(817), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(430), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(450), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(29), [anon_sym_const] = ACTIONS(29), @@ -11970,58 +11972,58 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [50] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(355), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(393), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(349), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(399), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(730), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(442), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(729), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(765), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(131), [anon_sym_const] = ACTIONS(131), @@ -12076,58 +12078,58 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [51] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(286), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(288), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), [sym_object_selector] = STATE(400), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(819), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(444), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(821), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(446), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(99), [anon_sym_const] = ACTIONS(99), @@ -12182,67 +12184,67 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [52] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(355), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(393), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(288), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(730), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(451), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(821), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(444), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(131), - [anon_sym_const] = ACTIONS(131), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(133), + [anon_sym_STAR] = ACTIONS(101), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -12268,7 +12270,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(135), + [anon_sym_static] = ACTIONS(103), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -12276,79 +12278,79 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(137), - [anon_sym_for] = ACTIONS(139), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(141), + [anon_sym_defer] = ACTIONS(109), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(143), + [anon_sym_return] = ACTIONS(111), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [53] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(278), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(395), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(349), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(399), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(817), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(438), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(729), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(446), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(29), - [anon_sym_const] = ACTIONS(29), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(41), + [anon_sym_STAR] = ACTIONS(133), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -12374,7 +12376,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(71), + [anon_sym_static] = ACTIONS(135), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -12382,70 +12384,70 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(83), - [anon_sym_for] = ACTIONS(85), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(91), + [anon_sym_defer] = ACTIONS(141), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(95), + [anon_sym_return] = ACTIONS(143), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [54] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(286), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(288), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), [sym_object_selector] = STATE(400), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(819), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(576), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(821), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(566), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(99), [anon_sym_const] = ACTIONS(99), @@ -12500,58 +12502,58 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [55] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(286), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(288), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), [sym_object_selector] = STATE(400), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(819), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(451), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(821), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(456), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(99), [anon_sym_const] = ACTIONS(99), @@ -12606,67 +12608,67 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [56] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(328), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(397), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(349), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(399), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(813), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(442), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(729), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(747), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(113), - [anon_sym_const] = ACTIONS(113), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(115), + [anon_sym_STAR] = ACTIONS(133), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -12692,7 +12694,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(117), + [anon_sym_static] = ACTIONS(135), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -12700,79 +12702,79 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(119), - [anon_sym_for] = ACTIONS(121), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(123), + [anon_sym_defer] = ACTIONS(141), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(125), + [anon_sym_return] = ACTIONS(143), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [57] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(286), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(400), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(349), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(399), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(819), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(634), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(729), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(806), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(99), - [anon_sym_const] = ACTIONS(99), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(101), + [anon_sym_STAR] = ACTIONS(133), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -12798,7 +12800,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(103), + [anon_sym_static] = ACTIONS(135), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -12806,70 +12808,70 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(105), - [anon_sym_for] = ACTIONS(107), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(109), + [anon_sym_defer] = ACTIONS(141), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(111), + [anon_sym_return] = ACTIONS(143), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [58] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(278), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(395), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(281), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(402), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(817), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(442), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(432), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(29), [anon_sym_const] = ACTIONS(29), @@ -12924,58 +12926,58 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [59] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(286), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(288), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), [sym_object_selector] = STATE(400), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(819), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(442), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(821), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(448), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(99), [anon_sym_const] = ACTIONS(99), @@ -13030,58 +13032,58 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [60] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(286), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(288), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), [sym_object_selector] = STATE(400), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(819), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(626), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(821), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(621), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(99), [anon_sym_const] = ACTIONS(99), @@ -13136,67 +13138,67 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [61] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(355), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(393), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(335), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(398), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(730), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(781), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(815), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(448), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(131), - [anon_sym_const] = ACTIONS(131), + [anon_sym_let] = ACTIONS(113), + [anon_sym_const] = ACTIONS(113), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(133), + [anon_sym_STAR] = ACTIONS(115), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -13222,7 +13224,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(135), + [anon_sym_static] = ACTIONS(117), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -13230,79 +13232,79 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(137), - [anon_sym_for] = ACTIONS(139), + [anon_sym_if] = ACTIONS(119), + [anon_sym_for] = ACTIONS(121), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(141), + [anon_sym_defer] = ACTIONS(123), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(143), + [anon_sym_return] = ACTIONS(125), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [62] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(355), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(393), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(288), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(730), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(721), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(821), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(578), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(131), - [anon_sym_const] = ACTIONS(131), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(133), + [anon_sym_STAR] = ACTIONS(101), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -13328,7 +13330,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(135), + [anon_sym_static] = ACTIONS(103), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -13336,79 +13338,79 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(137), - [anon_sym_for] = ACTIONS(139), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(141), + [anon_sym_defer] = ACTIONS(109), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(143), + [anon_sym_return] = ACTIONS(111), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [63] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(286), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(400), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(349), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(399), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(819), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(566), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(729), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(752), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(99), - [anon_sym_const] = ACTIONS(99), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(101), + [anon_sym_STAR] = ACTIONS(133), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -13434,7 +13436,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(103), + [anon_sym_static] = ACTIONS(135), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -13442,79 +13444,79 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(105), - [anon_sym_for] = ACTIONS(107), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(109), + [anon_sym_defer] = ACTIONS(141), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(111), + [anon_sym_return] = ACTIONS(143), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [64] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(355), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(393), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(288), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(730), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(668), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(821), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(440), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(131), - [anon_sym_const] = ACTIONS(131), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(133), + [anon_sym_STAR] = ACTIONS(101), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -13540,7 +13542,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(135), + [anon_sym_static] = ACTIONS(103), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -13548,79 +13550,79 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(137), - [anon_sym_for] = ACTIONS(139), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(141), + [anon_sym_defer] = ACTIONS(109), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(143), + [anon_sym_return] = ACTIONS(111), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [65] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(286), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(400), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(281), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(402), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), [sym_label] = STATE(819), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(571), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(448), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(99), - [anon_sym_const] = ACTIONS(99), + [anon_sym_let] = ACTIONS(29), + [anon_sym_const] = ACTIONS(29), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(101), + [anon_sym_STAR] = ACTIONS(41), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -13646,7 +13648,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(103), + [anon_sym_static] = ACTIONS(71), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -13654,79 +13656,79 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(105), - [anon_sym_for] = ACTIONS(107), + [anon_sym_if] = ACTIONS(83), + [anon_sym_for] = ACTIONS(85), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(109), + [anon_sym_defer] = ACTIONS(91), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(111), + [anon_sym_return] = ACTIONS(95), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [66] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(355), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(393), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(288), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(730), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(438), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(821), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(629), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(131), - [anon_sym_const] = ACTIONS(131), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(133), + [anon_sym_STAR] = ACTIONS(101), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -13752,7 +13754,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(135), + [anon_sym_static] = ACTIONS(103), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -13760,70 +13762,70 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(137), - [anon_sym_for] = ACTIONS(139), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(141), + [anon_sym_defer] = ACTIONS(109), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(143), + [anon_sym_return] = ACTIONS(111), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [67] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(355), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(393), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(349), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(399), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(730), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(804), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(729), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(456), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(131), [anon_sym_const] = ACTIONS(131), @@ -13878,58 +13880,58 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [68] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(286), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(288), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), [sym_object_selector] = STATE(400), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(819), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(568), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(821), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(567), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(99), [anon_sym_const] = ACTIONS(99), @@ -13984,67 +13986,67 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [69] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(355), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(393), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(335), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(398), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(730), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(684), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(815), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(450), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(131), - [anon_sym_const] = ACTIONS(131), + [anon_sym_let] = ACTIONS(113), + [anon_sym_const] = ACTIONS(113), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(133), + [anon_sym_STAR] = ACTIONS(115), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -14070,7 +14072,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(135), + [anon_sym_static] = ACTIONS(117), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -14078,79 +14080,79 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(137), - [anon_sym_for] = ACTIONS(139), + [anon_sym_if] = ACTIONS(119), + [anon_sym_for] = ACTIONS(121), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(141), + [anon_sym_defer] = ACTIONS(123), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(143), + [anon_sym_return] = ACTIONS(125), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [70] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(286), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(400), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(349), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(399), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(819), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(555), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(729), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(447), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(99), - [anon_sym_const] = ACTIONS(99), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(101), + [anon_sym_STAR] = ACTIONS(133), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -14176,7 +14178,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(103), + [anon_sym_static] = ACTIONS(135), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -14184,79 +14186,79 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(105), - [anon_sym_for] = ACTIONS(107), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(109), + [anon_sym_defer] = ACTIONS(141), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(111), + [anon_sym_return] = ACTIONS(143), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [71] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(286), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(400), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(349), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(399), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(819), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(625), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(729), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(577), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(99), - [anon_sym_const] = ACTIONS(99), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(101), + [anon_sym_STAR] = ACTIONS(133), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -14282,7 +14284,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(103), + [anon_sym_static] = ACTIONS(135), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -14290,79 +14292,79 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(105), - [anon_sym_for] = ACTIONS(107), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(109), + [anon_sym_defer] = ACTIONS(141), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(111), + [anon_sym_return] = ACTIONS(143), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [72] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(278), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(395), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(349), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(399), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(817), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(429), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(729), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(740), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(29), - [anon_sym_const] = ACTIONS(29), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(41), + [anon_sym_STAR] = ACTIONS(133), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -14388,7 +14390,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(71), + [anon_sym_static] = ACTIONS(135), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -14396,79 +14398,79 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(83), - [anon_sym_for] = ACTIONS(85), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(91), + [anon_sym_defer] = ACTIONS(141), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(95), + [anon_sym_return] = ACTIONS(143), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [73] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(355), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(393), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(335), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(398), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(730), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(688), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(815), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(456), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(131), - [anon_sym_const] = ACTIONS(131), + [anon_sym_let] = ACTIONS(113), + [anon_sym_const] = ACTIONS(113), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(133), + [anon_sym_STAR] = ACTIONS(115), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -14494,7 +14496,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(135), + [anon_sym_static] = ACTIONS(117), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -14502,79 +14504,79 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(137), - [anon_sym_for] = ACTIONS(139), + [anon_sym_if] = ACTIONS(119), + [anon_sym_for] = ACTIONS(121), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(141), + [anon_sym_defer] = ACTIONS(123), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(143), + [anon_sym_return] = ACTIONS(125), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [74] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(286), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(400), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(349), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(399), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(819), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(441), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(729), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(770), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(99), - [anon_sym_const] = ACTIONS(99), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(101), + [anon_sym_STAR] = ACTIONS(133), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -14600,7 +14602,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(103), + [anon_sym_static] = ACTIONS(135), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -14608,79 +14610,79 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(105), - [anon_sym_for] = ACTIONS(107), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(109), + [anon_sym_defer] = ACTIONS(141), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(111), + [anon_sym_return] = ACTIONS(143), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [75] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(355), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(393), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(281), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(402), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(730), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(767), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(447), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(131), - [anon_sym_const] = ACTIONS(131), + [anon_sym_let] = ACTIONS(29), + [anon_sym_const] = ACTIONS(29), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(133), + [anon_sym_STAR] = ACTIONS(41), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -14706,7 +14708,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(135), + [anon_sym_static] = ACTIONS(71), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -14714,79 +14716,79 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(137), - [anon_sym_for] = ACTIONS(139), + [anon_sym_if] = ACTIONS(83), + [anon_sym_for] = ACTIONS(85), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(141), + [anon_sym_defer] = ACTIONS(91), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(143), + [anon_sym_return] = ACTIONS(95), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [76] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(355), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(393), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(288), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(730), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(444), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(821), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(639), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(131), - [anon_sym_const] = ACTIONS(131), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(133), + [anon_sym_STAR] = ACTIONS(101), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -14812,7 +14814,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(135), + [anon_sym_static] = ACTIONS(103), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -14820,79 +14822,79 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(137), - [anon_sym_for] = ACTIONS(139), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(141), + [anon_sym_defer] = ACTIONS(109), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(143), + [anon_sym_return] = ACTIONS(111), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [77] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(355), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(393), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(288), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(730), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(445), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(821), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(431), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(131), - [anon_sym_const] = ACTIONS(131), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(133), + [anon_sym_STAR] = ACTIONS(101), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -14918,7 +14920,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(135), + [anon_sym_static] = ACTIONS(103), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -14926,79 +14928,79 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(137), - [anon_sym_for] = ACTIONS(139), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(141), + [anon_sym_defer] = ACTIONS(109), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(143), + [anon_sym_return] = ACTIONS(111), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [78] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(328), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(397), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(349), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(399), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(813), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(438), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(729), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(691), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(113), - [anon_sym_const] = ACTIONS(113), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(115), + [anon_sym_STAR] = ACTIONS(133), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -15024,7 +15026,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(117), + [anon_sym_static] = ACTIONS(135), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -15032,79 +15034,79 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(119), - [anon_sym_for] = ACTIONS(121), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(123), + [anon_sym_defer] = ACTIONS(141), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(125), + [anon_sym_return] = ACTIONS(143), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [79] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(278), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(395), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(335), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(398), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(817), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(437), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(815), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(432), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(29), - [anon_sym_const] = ACTIONS(29), + [anon_sym_let] = ACTIONS(113), + [anon_sym_const] = ACTIONS(113), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(41), + [anon_sym_STAR] = ACTIONS(115), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -15130,7 +15132,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(71), + [anon_sym_static] = ACTIONS(117), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -15138,79 +15140,79 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(83), - [anon_sym_for] = ACTIONS(85), + [anon_sym_if] = ACTIONS(119), + [anon_sym_for] = ACTIONS(121), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(91), + [anon_sym_defer] = ACTIONS(123), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(95), + [anon_sym_return] = ACTIONS(125), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [80] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(286), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(400), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(281), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(402), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), [sym_label] = STATE(819), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(590), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(431), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(99), - [anon_sym_const] = ACTIONS(99), + [anon_sym_let] = ACTIONS(29), + [anon_sym_const] = ACTIONS(29), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(101), + [anon_sym_STAR] = ACTIONS(41), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -15236,7 +15238,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(103), + [anon_sym_static] = ACTIONS(71), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -15244,70 +15246,70 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(105), - [anon_sym_for] = ACTIONS(107), + [anon_sym_if] = ACTIONS(83), + [anon_sym_for] = ACTIONS(85), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(109), + [anon_sym_defer] = ACTIONS(91), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(111), + [anon_sym_return] = ACTIONS(95), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [81] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(355), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(393), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(349), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(399), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(730), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(746), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(729), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(432), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(131), [anon_sym_const] = ACTIONS(131), @@ -15362,58 +15364,58 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [82] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(286), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(288), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), [sym_object_selector] = STATE(400), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(819), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(591), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(821), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(582), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(99), [anon_sym_const] = ACTIONS(99), @@ -15468,67 +15470,67 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [83] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(355), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(393), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(288), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(730), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(800), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(821), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(624), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(131), - [anon_sym_const] = ACTIONS(131), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(133), + [anon_sym_STAR] = ACTIONS(101), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -15554,7 +15556,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(135), + [anon_sym_static] = ACTIONS(103), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -15562,79 +15564,79 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(137), - [anon_sym_for] = ACTIONS(139), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(141), + [anon_sym_defer] = ACTIONS(109), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(143), + [anon_sym_return] = ACTIONS(111), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [84] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(328), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(397), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(349), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(399), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(813), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(429), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(729), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(785), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(113), - [anon_sym_const] = ACTIONS(113), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(115), + [anon_sym_STAR] = ACTIONS(133), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -15660,7 +15662,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(117), + [anon_sym_static] = ACTIONS(135), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -15668,79 +15670,79 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(119), - [anon_sym_for] = ACTIONS(121), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(123), + [anon_sym_defer] = ACTIONS(141), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(125), + [anon_sym_return] = ACTIONS(143), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [85] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(286), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(400), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(349), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(399), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(819), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(554), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(729), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(666), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(99), - [anon_sym_const] = ACTIONS(99), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(101), + [anon_sym_STAR] = ACTIONS(133), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -15766,7 +15768,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(103), + [anon_sym_static] = ACTIONS(135), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -15774,79 +15776,79 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(105), - [anon_sym_for] = ACTIONS(107), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(109), + [anon_sym_defer] = ACTIONS(141), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(111), + [anon_sym_return] = ACTIONS(143), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [86] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(355), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(393), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(335), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(398), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(730), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(750), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(815), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(447), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(131), - [anon_sym_const] = ACTIONS(131), + [anon_sym_let] = ACTIONS(113), + [anon_sym_const] = ACTIONS(113), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(133), + [anon_sym_STAR] = ACTIONS(115), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -15872,7 +15874,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(135), + [anon_sym_static] = ACTIONS(117), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -15880,79 +15882,79 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(137), - [anon_sym_for] = ACTIONS(139), + [anon_sym_if] = ACTIONS(119), + [anon_sym_for] = ACTIONS(121), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(141), + [anon_sym_defer] = ACTIONS(123), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(143), + [anon_sym_return] = ACTIONS(125), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [87] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(286), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(400), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(349), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(399), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(819), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(601), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(729), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(722), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(99), - [anon_sym_const] = ACTIONS(99), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(101), + [anon_sym_STAR] = ACTIONS(133), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -15978,7 +15980,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(103), + [anon_sym_static] = ACTIONS(135), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -15986,79 +15988,79 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(105), - [anon_sym_for] = ACTIONS(107), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(109), + [anon_sym_defer] = ACTIONS(141), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(111), + [anon_sym_return] = ACTIONS(143), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [88] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(355), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(393), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(288), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(730), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(799), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(821), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(612), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(131), - [anon_sym_const] = ACTIONS(131), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(133), + [anon_sym_STAR] = ACTIONS(101), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -16084,7 +16086,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(135), + [anon_sym_static] = ACTIONS(103), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -16092,79 +16094,79 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(137), - [anon_sym_for] = ACTIONS(139), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(141), + [anon_sym_defer] = ACTIONS(109), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(143), + [anon_sym_return] = ACTIONS(111), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [89] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(355), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(393), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(288), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(730), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(706), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(821), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(560), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(131), - [anon_sym_const] = ACTIONS(131), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(133), + [anon_sym_STAR] = ACTIONS(101), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -16190,7 +16192,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(135), + [anon_sym_static] = ACTIONS(103), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -16198,70 +16200,70 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(137), - [anon_sym_for] = ACTIONS(139), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(141), + [anon_sym_defer] = ACTIONS(109), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(143), + [anon_sym_return] = ACTIONS(111), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [90] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(286), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(288), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), [sym_object_selector] = STATE(400), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(819), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(553), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(821), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(586), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(99), [anon_sym_const] = ACTIONS(99), @@ -16316,67 +16318,67 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [91] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(328), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(397), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(349), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(399), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(813), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(430), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(729), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(709), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(113), - [anon_sym_const] = ACTIONS(113), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(115), + [anon_sym_STAR] = ACTIONS(133), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -16402,7 +16404,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(117), + [anon_sym_static] = ACTIONS(135), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -16410,70 +16412,70 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(119), - [anon_sym_for] = ACTIONS(121), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(123), + [anon_sym_defer] = ACTIONS(141), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(125), + [anon_sym_return] = ACTIONS(143), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [92] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(355), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(393), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(349), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(399), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(730), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(429), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(729), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(448), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(131), [anon_sym_const] = ACTIONS(131), @@ -16528,67 +16530,67 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [93] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(355), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(393), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(288), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(730), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(731), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(821), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(608), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(131), - [anon_sym_const] = ACTIONS(131), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(133), + [anon_sym_STAR] = ACTIONS(101), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -16614,7 +16616,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(135), + [anon_sym_static] = ACTIONS(103), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -16622,79 +16624,79 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(137), - [anon_sym_for] = ACTIONS(139), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(141), + [anon_sym_defer] = ACTIONS(109), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(143), + [anon_sym_return] = ACTIONS(111), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [94] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(355), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(393), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(288), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(730), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(610), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(821), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(607), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(131), - [anon_sym_const] = ACTIONS(131), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(133), + [anon_sym_STAR] = ACTIONS(101), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -16720,7 +16722,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(135), + [anon_sym_static] = ACTIONS(103), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -16728,70 +16730,70 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(137), - [anon_sym_for] = ACTIONS(139), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(141), + [anon_sym_defer] = ACTIONS(109), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(143), + [anon_sym_return] = ACTIONS(111), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [95] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(355), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(393), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(349), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(399), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(730), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(738), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(729), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(802), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(131), [anon_sym_const] = ACTIONS(131), @@ -16846,58 +16848,58 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [96] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(286), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(288), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), [sym_object_selector] = STATE(400), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(819), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(615), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(821), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(591), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), [anon_sym_let] = ACTIONS(99), [anon_sym_const] = ACTIONS(99), @@ -16952,67 +16954,67 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [97] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(328), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(397), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(349), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(399), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(813), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(445), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(729), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(730), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(113), - [anon_sym_const] = ACTIONS(113), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(115), + [anon_sym_STAR] = ACTIONS(133), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -17038,7 +17040,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(117), + [anon_sym_static] = ACTIONS(135), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -17046,79 +17048,79 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(119), - [anon_sym_for] = ACTIONS(121), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(123), + [anon_sym_defer] = ACTIONS(141), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(125), + [anon_sym_return] = ACTIONS(143), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [98] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(328), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(397), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(288), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(400), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(813), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(444), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(821), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(598), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(113), - [anon_sym_const] = ACTIONS(113), + [anon_sym_let] = ACTIONS(99), + [anon_sym_const] = ACTIONS(99), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(115), + [anon_sym_STAR] = ACTIONS(101), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -17144,7 +17146,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(117), + [anon_sym_static] = ACTIONS(103), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -17152,79 +17154,79 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(119), - [anon_sym_for] = ACTIONS(121), + [anon_sym_if] = ACTIONS(105), + [anon_sym_for] = ACTIONS(107), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(123), + [anon_sym_defer] = ACTIONS(109), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(125), + [anon_sym_return] = ACTIONS(111), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [99] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(278), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(395), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(349), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(399), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(817), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(441), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(729), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(801), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(29), - [anon_sym_const] = ACTIONS(29), + [anon_sym_let] = ACTIONS(131), + [anon_sym_const] = ACTIONS(131), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(41), + [anon_sym_STAR] = ACTIONS(133), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -17250,7 +17252,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(71), + [anon_sym_static] = ACTIONS(135), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -17258,79 +17260,79 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(83), - [anon_sym_for] = ACTIONS(85), + [anon_sym_if] = ACTIONS(137), + [anon_sym_for] = ACTIONS(139), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(91), + [anon_sym_defer] = ACTIONS(141), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(95), + [anon_sym_return] = ACTIONS(143), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [100] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(355), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(393), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(281), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(402), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(730), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(768), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(819), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(440), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(131), - [anon_sym_const] = ACTIONS(131), + [anon_sym_let] = ACTIONS(29), + [anon_sym_const] = ACTIONS(29), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(133), + [anon_sym_STAR] = ACTIONS(41), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -17356,7 +17358,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(135), + [anon_sym_static] = ACTIONS(71), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -17364,79 +17366,79 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(137), - [anon_sym_for] = ACTIONS(139), + [anon_sym_if] = ACTIONS(83), + [anon_sym_for] = ACTIONS(85), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(141), + [anon_sym_defer] = ACTIONS(91), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(143), + [anon_sym_return] = ACTIONS(95), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [101] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(286), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(400), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(335), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(398), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(819), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(596), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(815), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(446), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(99), - [anon_sym_const] = ACTIONS(99), + [anon_sym_let] = ACTIONS(113), + [anon_sym_const] = ACTIONS(113), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(101), + [anon_sym_STAR] = ACTIONS(115), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -17462,7 +17464,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(103), + [anon_sym_static] = ACTIONS(117), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -17470,79 +17472,79 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(105), - [anon_sym_for] = ACTIONS(107), + [anon_sym_if] = ACTIONS(119), + [anon_sym_for] = ACTIONS(121), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(109), + [anon_sym_defer] = ACTIONS(123), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(111), + [anon_sym_return] = ACTIONS(125), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [102] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(253), - [sym_indexing_expression] = STATE(253), - [sym_slicing_expression] = STATE(286), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(289), - [sym_object_selector] = STATE(400), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(221), + [sym_indexing_expression] = STATE(221), + [sym_slicing_expression] = STATE(335), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(291), + [sym_object_selector] = STATE(398), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(412), - [sym_if_expression] = STATE(425), - [sym_for_loop] = STATE(425), - [sym_label] = STATE(819), - [sym_switch_expression] = STATE(425), - [sym_match_expression] = STATE(425), - [sym_assignment] = STATE(425), - [sym_binding_list] = STATE(425), - [sym_deferred_expression] = STATE(425), - [sym_control_statement] = STATE(425), - [sym_expression] = STATE(437), - [sym_compound_expression] = STATE(425), - [sym_identifier] = STATE(201), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [sym_logical_or_expression] = STATE(416), + [sym_if_expression] = STATE(422), + [sym_for_loop] = STATE(422), + [sym_label] = STATE(815), + [sym_switch_expression] = STATE(422), + [sym_match_expression] = STATE(422), + [sym_assignment] = STATE(422), + [sym_binding_list] = STATE(422), + [sym_deferred_expression] = STATE(422), + [sym_control_statement] = STATE(422), + [sym_expression] = STATE(444), + [sym_compound_expression] = STATE(422), + [sym_identifier] = STATE(216), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LBRACE] = ACTIONS(27), - [anon_sym_let] = ACTIONS(99), - [anon_sym_const] = ACTIONS(99), + [anon_sym_let] = ACTIONS(113), + [anon_sym_const] = ACTIONS(113), [anon_sym_COLON] = ACTIONS(31), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(101), + [anon_sym_STAR] = ACTIONS(115), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -17568,7 +17570,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(103), + [anon_sym_static] = ACTIONS(117), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -17576,67 +17578,235 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [anon_sym_if] = ACTIONS(105), - [anon_sym_for] = ACTIONS(107), + [anon_sym_if] = ACTIONS(119), + [anon_sym_for] = ACTIONS(121), [anon_sym_switch] = ACTIONS(87), [anon_sym_match] = ACTIONS(89), - [anon_sym_defer] = ACTIONS(109), + [anon_sym_defer] = ACTIONS(123), [anon_sym_break] = ACTIONS(93), [anon_sym_continue] = ACTIONS(93), - [anon_sym_return] = ACTIONS(111), + [anon_sym_return] = ACTIONS(125), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, [103] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_hex_digit] = STATE(104), + [aux_sym_hex_digits_repeat1] = STATE(104), + [anon_sym_SEMI] = ACTIONS(179), + [anon_sym_EQ] = ACTIONS(181), + [anon_sym_RBRACE] = ACTIONS(179), + [anon_sym_COMMA] = ACTIONS(179), + [anon_sym_COLON] = ACTIONS(179), + [anon_sym_LPAREN] = ACTIONS(179), + [anon_sym_RPAREN] = ACTIONS(179), + [anon_sym_i8] = ACTIONS(179), + [anon_sym_i16] = ACTIONS(179), + [anon_sym_i32] = ACTIONS(179), + [anon_sym_i64] = ACTIONS(179), + [anon_sym_u8] = ACTIONS(179), + [anon_sym_u16] = ACTIONS(179), + [anon_sym_u32] = ACTIONS(179), + [anon_sym_u64] = ACTIONS(179), + [anon_sym_STAR] = ACTIONS(181), + [anon_sym_PIPE] = ACTIONS(181), + [anon_sym_LBRACK] = ACTIONS(179), + [anon_sym_RBRACK] = ACTIONS(179), + [anon_sym_DOT_DOT_DOT] = ACTIONS(179), + [anon_sym_0] = ACTIONS(183), + [anon_sym_1] = ACTIONS(183), + [anon_sym_2] = ACTIONS(183), + [anon_sym_3] = ACTIONS(183), + [anon_sym_4] = ACTIONS(183), + [anon_sym_5] = ACTIONS(183), + [anon_sym_6] = ACTIONS(183), + [anon_sym_7] = ACTIONS(183), + [anon_sym_8] = ACTIONS(183), + [anon_sym_9] = ACTIONS(183), + [anon_sym_A] = ACTIONS(183), + [anon_sym_B] = ACTIONS(183), + [anon_sym_C] = ACTIONS(183), + [anon_sym_D] = ACTIONS(183), + [anon_sym_E] = ACTIONS(183), + [anon_sym_F] = ACTIONS(183), + [anon_sym_a] = ACTIONS(185), + [anon_sym_b] = ACTIONS(183), + [anon_sym_c] = ACTIONS(183), + [anon_sym_d] = ACTIONS(183), + [anon_sym_e] = ACTIONS(185), + [anon_sym_f] = ACTIONS(183), + [anon_sym_i] = ACTIONS(181), + [anon_sym_u] = ACTIONS(181), + [anon_sym_z] = ACTIONS(179), + [anon_sym_DOT] = ACTIONS(181), + [anon_sym_DOT_DOT] = ACTIONS(181), + [anon_sym_QMARK] = ACTIONS(179), + [anon_sym_PLUS] = ACTIONS(181), + [anon_sym_DASH] = ACTIONS(181), + [anon_sym_AMP] = ACTIONS(181), + [anon_sym_as] = ACTIONS(179), + [anon_sym_is] = ACTIONS(179), + [anon_sym_SLASH] = ACTIONS(181), + [anon_sym_PERCENT] = ACTIONS(181), + [anon_sym_LT_LT] = ACTIONS(181), + [anon_sym_GT_GT] = ACTIONS(181), + [anon_sym_CARET] = ACTIONS(181), + [anon_sym_LT] = ACTIONS(181), + [anon_sym_GT] = ACTIONS(181), + [anon_sym_LT_EQ] = ACTIONS(179), + [anon_sym_GT_EQ] = ACTIONS(179), + [anon_sym_EQ_EQ] = ACTIONS(179), + [anon_sym_BANG_EQ] = ACTIONS(179), + [anon_sym_AMP_AMP] = ACTIONS(179), + [anon_sym_CARET_CARET] = ACTIONS(179), + [anon_sym_PIPE_PIPE] = ACTIONS(179), + [anon_sym_else] = ACTIONS(179), + [anon_sym_EQ_GT] = ACTIONS(179), + [anon_sym_PLUS_EQ] = ACTIONS(179), + [anon_sym_DASH_EQ] = ACTIONS(179), + [anon_sym_STAR_EQ] = ACTIONS(179), + [anon_sym_SLASH_EQ] = ACTIONS(179), + [anon_sym_PERCENT_EQ] = ACTIONS(179), + [anon_sym_LT_LT_EQ] = ACTIONS(179), + [anon_sym_GT_GT_EQ] = ACTIONS(179), + [anon_sym_AMP_EQ] = ACTIONS(179), + [anon_sym_PIPE_EQ] = ACTIONS(179), + [anon_sym_CARET_EQ] = ACTIONS(179), + [sym_comment] = ACTIONS(3), + }, + [104] = { + [sym_hex_digit] = STATE(104), + [aux_sym_hex_digits_repeat1] = STATE(104), + [anon_sym_SEMI] = ACTIONS(187), + [anon_sym_EQ] = ACTIONS(189), + [anon_sym_RBRACE] = ACTIONS(187), + [anon_sym_COMMA] = ACTIONS(187), + [anon_sym_COLON] = ACTIONS(187), + [anon_sym_LPAREN] = ACTIONS(187), + [anon_sym_RPAREN] = ACTIONS(187), + [anon_sym_i8] = ACTIONS(187), + [anon_sym_i16] = ACTIONS(187), + [anon_sym_i32] = ACTIONS(187), + [anon_sym_i64] = ACTIONS(187), + [anon_sym_u8] = ACTIONS(187), + [anon_sym_u16] = ACTIONS(187), + [anon_sym_u32] = ACTIONS(187), + [anon_sym_u64] = ACTIONS(187), + [anon_sym_STAR] = ACTIONS(189), + [anon_sym_PIPE] = ACTIONS(189), + [anon_sym_LBRACK] = ACTIONS(187), + [anon_sym_RBRACK] = ACTIONS(187), + [anon_sym_DOT_DOT_DOT] = ACTIONS(187), + [anon_sym_0] = ACTIONS(191), + [anon_sym_1] = ACTIONS(191), + [anon_sym_2] = ACTIONS(191), + [anon_sym_3] = ACTIONS(191), + [anon_sym_4] = ACTIONS(191), + [anon_sym_5] = ACTIONS(191), + [anon_sym_6] = ACTIONS(191), + [anon_sym_7] = ACTIONS(191), + [anon_sym_8] = ACTIONS(191), + [anon_sym_9] = ACTIONS(191), + [anon_sym_A] = ACTIONS(191), + [anon_sym_B] = ACTIONS(191), + [anon_sym_C] = ACTIONS(191), + [anon_sym_D] = ACTIONS(191), + [anon_sym_E] = ACTIONS(191), + [anon_sym_F] = ACTIONS(191), + [anon_sym_a] = ACTIONS(194), + [anon_sym_b] = ACTIONS(191), + [anon_sym_c] = ACTIONS(191), + [anon_sym_d] = ACTIONS(191), + [anon_sym_e] = ACTIONS(194), + [anon_sym_f] = ACTIONS(191), + [anon_sym_i] = ACTIONS(189), + [anon_sym_u] = ACTIONS(189), + [anon_sym_z] = ACTIONS(187), + [anon_sym_DOT] = ACTIONS(189), + [anon_sym_DOT_DOT] = ACTIONS(189), + [anon_sym_QMARK] = ACTIONS(187), + [anon_sym_PLUS] = ACTIONS(189), + [anon_sym_DASH] = ACTIONS(189), + [anon_sym_AMP] = ACTIONS(189), + [anon_sym_as] = ACTIONS(187), + [anon_sym_is] = ACTIONS(187), + [anon_sym_SLASH] = ACTIONS(189), + [anon_sym_PERCENT] = ACTIONS(189), + [anon_sym_LT_LT] = ACTIONS(189), + [anon_sym_GT_GT] = ACTIONS(189), + [anon_sym_CARET] = ACTIONS(189), + [anon_sym_LT] = ACTIONS(189), + [anon_sym_GT] = ACTIONS(189), + [anon_sym_LT_EQ] = ACTIONS(187), + [anon_sym_GT_EQ] = ACTIONS(187), + [anon_sym_EQ_EQ] = ACTIONS(187), + [anon_sym_BANG_EQ] = ACTIONS(187), + [anon_sym_AMP_AMP] = ACTIONS(187), + [anon_sym_CARET_CARET] = ACTIONS(187), + [anon_sym_PIPE_PIPE] = ACTIONS(187), + [anon_sym_else] = ACTIONS(187), + [anon_sym_EQ_GT] = ACTIONS(187), + [anon_sym_PLUS_EQ] = ACTIONS(187), + [anon_sym_DASH_EQ] = ACTIONS(187), + [anon_sym_STAR_EQ] = ACTIONS(187), + [anon_sym_SLASH_EQ] = ACTIONS(187), + [anon_sym_PERCENT_EQ] = ACTIONS(187), + [anon_sym_LT_LT_EQ] = ACTIONS(187), + [anon_sym_GT_GT_EQ] = ACTIONS(187), + [anon_sym_AMP_EQ] = ACTIONS(187), + [anon_sym_PIPE_EQ] = ACTIONS(187), + [anon_sym_CARET_EQ] = ACTIONS(187), + [sym_comment] = ACTIONS(3), + }, + [105] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(303), - [sym_indexing_expression] = STATE(303), - [sym_slicing_expression] = STATE(303), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(305), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(305), + [sym_indexing_expression] = STATE(305), + [sym_slicing_expression] = STATE(305), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(307), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(608), + [sym_logical_or_expression] = STATE(574), [sym_identifier] = STATE(274), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(179), + [anon_sym_STAR] = ACTIONS(197), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), - [anon_sym_RBRACK] = ACTIONS(181), - [anon_sym__] = ACTIONS(183), + [anon_sym_RBRACK] = ACTIONS(199), + [anon_sym__] = ACTIONS(201), [anon_sym_true] = ACTIONS(37), [anon_sym_false] = ACTIONS(37), [anon_sym_null] = ACTIONS(37), @@ -17660,7 +17830,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(185), + [anon_sym_static] = ACTIONS(203), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -17668,143 +17838,59 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [sym_name] = ACTIONS(187), - [sym_comment] = ACTIONS(3), - }, - [104] = { - [sym_hex_digit] = STATE(104), - [aux_sym_hex_digits_repeat1] = STATE(104), - [anon_sym_SEMI] = ACTIONS(189), - [anon_sym_EQ] = ACTIONS(191), - [anon_sym_RBRACE] = ACTIONS(189), - [anon_sym_COMMA] = ACTIONS(189), - [anon_sym_COLON] = ACTIONS(189), - [anon_sym_LPAREN] = ACTIONS(189), - [anon_sym_RPAREN] = ACTIONS(189), - [anon_sym_i8] = ACTIONS(189), - [anon_sym_i16] = ACTIONS(189), - [anon_sym_i32] = ACTIONS(189), - [anon_sym_i64] = ACTIONS(189), - [anon_sym_u8] = ACTIONS(189), - [anon_sym_u16] = ACTIONS(189), - [anon_sym_u32] = ACTIONS(189), - [anon_sym_u64] = ACTIONS(189), - [anon_sym_STAR] = ACTIONS(191), - [anon_sym_PIPE] = ACTIONS(191), - [anon_sym_LBRACK] = ACTIONS(189), - [anon_sym_RBRACK] = ACTIONS(189), - [anon_sym_DOT_DOT_DOT] = ACTIONS(189), - [anon_sym_0] = ACTIONS(193), - [anon_sym_1] = ACTIONS(193), - [anon_sym_2] = ACTIONS(193), - [anon_sym_3] = ACTIONS(193), - [anon_sym_4] = ACTIONS(193), - [anon_sym_5] = ACTIONS(193), - [anon_sym_6] = ACTIONS(193), - [anon_sym_7] = ACTIONS(193), - [anon_sym_8] = ACTIONS(193), - [anon_sym_9] = ACTIONS(193), - [anon_sym_A] = ACTIONS(193), - [anon_sym_B] = ACTIONS(193), - [anon_sym_C] = ACTIONS(193), - [anon_sym_D] = ACTIONS(193), - [anon_sym_E] = ACTIONS(193), - [anon_sym_F] = ACTIONS(193), - [anon_sym_a] = ACTIONS(196), - [anon_sym_b] = ACTIONS(193), - [anon_sym_c] = ACTIONS(193), - [anon_sym_d] = ACTIONS(193), - [anon_sym_e] = ACTIONS(196), - [anon_sym_f] = ACTIONS(193), - [anon_sym_i] = ACTIONS(191), - [anon_sym_u] = ACTIONS(191), - [anon_sym_z] = ACTIONS(189), - [anon_sym_DOT] = ACTIONS(191), - [anon_sym_DOT_DOT] = ACTIONS(191), - [anon_sym_QMARK] = ACTIONS(189), - [anon_sym_PLUS] = ACTIONS(191), - [anon_sym_DASH] = ACTIONS(191), - [anon_sym_AMP] = ACTIONS(191), - [anon_sym_as] = ACTIONS(189), - [anon_sym_is] = ACTIONS(189), - [anon_sym_SLASH] = ACTIONS(191), - [anon_sym_PERCENT] = ACTIONS(191), - [anon_sym_LT_LT] = ACTIONS(191), - [anon_sym_GT_GT] = ACTIONS(191), - [anon_sym_CARET] = ACTIONS(191), - [anon_sym_LT] = ACTIONS(191), - [anon_sym_GT] = ACTIONS(191), - [anon_sym_LT_EQ] = ACTIONS(189), - [anon_sym_GT_EQ] = ACTIONS(189), - [anon_sym_EQ_EQ] = ACTIONS(189), - [anon_sym_BANG_EQ] = ACTIONS(189), - [anon_sym_AMP_AMP] = ACTIONS(189), - [anon_sym_CARET_CARET] = ACTIONS(189), - [anon_sym_PIPE_PIPE] = ACTIONS(189), - [anon_sym_else] = ACTIONS(189), - [anon_sym_EQ_GT] = ACTIONS(189), - [anon_sym_PLUS_EQ] = ACTIONS(189), - [anon_sym_DASH_EQ] = ACTIONS(189), - [anon_sym_STAR_EQ] = ACTIONS(189), - [anon_sym_SLASH_EQ] = ACTIONS(189), - [anon_sym_PERCENT_EQ] = ACTIONS(189), - [anon_sym_LT_LT_EQ] = ACTIONS(189), - [anon_sym_GT_GT_EQ] = ACTIONS(189), - [anon_sym_AMP_EQ] = ACTIONS(189), - [anon_sym_PIPE_EQ] = ACTIONS(189), - [anon_sym_CARET_EQ] = ACTIONS(189), + [sym_name] = ACTIONS(205), [sym_comment] = ACTIONS(3), }, - [105] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [106] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(303), - [sym_indexing_expression] = STATE(303), - [sym_slicing_expression] = STATE(303), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(305), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(305), + [sym_indexing_expression] = STATE(305), + [sym_slicing_expression] = STATE(305), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(307), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), [sym_logical_xor_expression] = STATE(403), - [sym_logical_or_expression] = STATE(595), + [sym_logical_or_expression] = STATE(605), [sym_identifier] = STATE(274), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(199), + [anon_sym_STAR] = ACTIONS(207), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), - [anon_sym_RBRACK] = ACTIONS(201), - [anon_sym__] = ACTIONS(203), + [anon_sym_RBRACK] = ACTIONS(209), + [anon_sym__] = ACTIONS(211), [anon_sym_true] = ACTIONS(37), [anon_sym_false] = ACTIONS(37), [anon_sym_null] = ACTIONS(37), @@ -17828,7 +17914,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(185), + [anon_sym_static] = ACTIONS(203), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -17836,91 +17922,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [sym_name] = ACTIONS(187), - [sym_comment] = ACTIONS(3), - }, - [106] = { - [sym_hex_digit] = STATE(104), - [aux_sym_hex_digits_repeat1] = STATE(104), - [anon_sym_SEMI] = ACTIONS(205), - [anon_sym_EQ] = ACTIONS(207), - [anon_sym_RBRACE] = ACTIONS(205), - [anon_sym_COMMA] = ACTIONS(205), - [anon_sym_COLON] = ACTIONS(205), - [anon_sym_LPAREN] = ACTIONS(205), - [anon_sym_RPAREN] = ACTIONS(205), - [anon_sym_i8] = ACTIONS(205), - [anon_sym_i16] = ACTIONS(205), - [anon_sym_i32] = ACTIONS(205), - [anon_sym_i64] = ACTIONS(205), - [anon_sym_u8] = ACTIONS(205), - [anon_sym_u16] = ACTIONS(205), - [anon_sym_u32] = ACTIONS(205), - [anon_sym_u64] = ACTIONS(205), - [anon_sym_STAR] = ACTIONS(207), - [anon_sym_PIPE] = ACTIONS(207), - [anon_sym_LBRACK] = ACTIONS(205), - [anon_sym_RBRACK] = ACTIONS(205), - [anon_sym_DOT_DOT_DOT] = ACTIONS(205), - [anon_sym_0] = ACTIONS(209), - [anon_sym_1] = ACTIONS(209), - [anon_sym_2] = ACTIONS(209), - [anon_sym_3] = ACTIONS(209), - [anon_sym_4] = ACTIONS(209), - [anon_sym_5] = ACTIONS(209), - [anon_sym_6] = ACTIONS(209), - [anon_sym_7] = ACTIONS(209), - [anon_sym_8] = ACTIONS(209), - [anon_sym_9] = ACTIONS(209), - [anon_sym_A] = ACTIONS(209), - [anon_sym_B] = ACTIONS(209), - [anon_sym_C] = ACTIONS(209), - [anon_sym_D] = ACTIONS(209), - [anon_sym_E] = ACTIONS(209), - [anon_sym_F] = ACTIONS(209), - [anon_sym_a] = ACTIONS(211), - [anon_sym_b] = ACTIONS(209), - [anon_sym_c] = ACTIONS(209), - [anon_sym_d] = ACTIONS(209), - [anon_sym_e] = ACTIONS(211), - [anon_sym_f] = ACTIONS(209), - [anon_sym_i] = ACTIONS(207), - [anon_sym_u] = ACTIONS(207), - [anon_sym_z] = ACTIONS(205), - [anon_sym_DOT] = ACTIONS(207), - [anon_sym_DOT_DOT] = ACTIONS(207), - [anon_sym_QMARK] = ACTIONS(205), - [anon_sym_PLUS] = ACTIONS(207), - [anon_sym_DASH] = ACTIONS(207), - [anon_sym_AMP] = ACTIONS(207), - [anon_sym_as] = ACTIONS(205), - [anon_sym_is] = ACTIONS(205), - [anon_sym_SLASH] = ACTIONS(207), - [anon_sym_PERCENT] = ACTIONS(207), - [anon_sym_LT_LT] = ACTIONS(207), - [anon_sym_GT_GT] = ACTIONS(207), - [anon_sym_CARET] = ACTIONS(207), - [anon_sym_LT] = ACTIONS(207), - [anon_sym_GT] = ACTIONS(207), - [anon_sym_LT_EQ] = ACTIONS(205), - [anon_sym_GT_EQ] = ACTIONS(205), - [anon_sym_EQ_EQ] = ACTIONS(205), - [anon_sym_BANG_EQ] = ACTIONS(205), - [anon_sym_AMP_AMP] = ACTIONS(205), - [anon_sym_CARET_CARET] = ACTIONS(205), - [anon_sym_PIPE_PIPE] = ACTIONS(205), - [anon_sym_else] = ACTIONS(205), - [anon_sym_EQ_GT] = ACTIONS(205), - [anon_sym_PLUS_EQ] = ACTIONS(205), - [anon_sym_DASH_EQ] = ACTIONS(205), - [anon_sym_STAR_EQ] = ACTIONS(205), - [anon_sym_SLASH_EQ] = ACTIONS(205), - [anon_sym_PERCENT_EQ] = ACTIONS(205), - [anon_sym_LT_LT_EQ] = ACTIONS(205), - [anon_sym_GT_GT_EQ] = ACTIONS(205), - [anon_sym_AMP_EQ] = ACTIONS(205), - [anon_sym_PIPE_EQ] = ACTIONS(205), - [anon_sym_CARET_EQ] = ACTIONS(205), + [sym_name] = ACTIONS(205), [sym_comment] = ACTIONS(3), }, [107] = { @@ -18006,45 +18008,45 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [108] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(303), - [sym_indexing_expression] = STATE(303), - [sym_slicing_expression] = STATE(303), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(305), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(398), - [sym_logical_xor_expression] = STATE(402), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(305), + [sym_indexing_expression] = STATE(305), + [sym_slicing_expression] = STATE(305), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(307), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(401), + [sym_logical_xor_expression] = STATE(406), [sym_identifier] = STATE(274), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), @@ -18075,7 +18077,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(185), + [anon_sym_static] = ACTIONS(203), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -18083,48 +18085,48 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [sym_name] = ACTIONS(187), + [sym_name] = ACTIONS(205), [sym_comment] = ACTIONS(3), }, [109] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(303), - [sym_indexing_expression] = STATE(303), - [sym_slicing_expression] = STATE(303), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(305), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(384), - [sym_logical_and_expression] = STATE(394), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(305), + [sym_indexing_expression] = STATE(305), + [sym_slicing_expression] = STATE(305), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(307), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(386), + [sym_logical_and_expression] = STATE(397), [sym_identifier] = STATE(274), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), @@ -18155,7 +18157,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(185), + [anon_sym_static] = ACTIONS(203), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -18163,47 +18165,47 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [sym_name] = ACTIONS(187), + [sym_name] = ACTIONS(205), [sym_comment] = ACTIONS(3), }, [110] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(303), - [sym_indexing_expression] = STATE(303), - [sym_slicing_expression] = STATE(303), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(305), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), - [sym_comparison_expression] = STATE(377), - [sym_equality_expression] = STATE(383), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(305), + [sym_indexing_expression] = STATE(305), + [sym_slicing_expression] = STATE(305), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(307), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), + [sym_comparison_expression] = STATE(379), + [sym_equality_expression] = STATE(385), [sym_identifier] = STATE(274), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), @@ -18234,7 +18236,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(185), + [anon_sym_static] = ACTIONS(203), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -18242,46 +18244,46 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [sym_name] = ACTIONS(187), + [sym_name] = ACTIONS(205), [sym_comment] = ACTIONS(3), }, [111] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(303), - [sym_indexing_expression] = STATE(303), - [sym_slicing_expression] = STATE(303), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(305), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(373), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(305), + [sym_indexing_expression] = STATE(305), + [sym_slicing_expression] = STATE(305), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(307), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(374), [sym_comparison_expression] = STATE(376), [sym_identifier] = STATE(274), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), @@ -18312,7 +18314,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(185), + [anon_sym_static] = ACTIONS(203), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -18320,45 +18322,45 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [sym_name] = ACTIONS(187), + [sym_name] = ACTIONS(205), [sym_comment] = ACTIONS(3), }, [112] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(303), - [sym_indexing_expression] = STATE(303), - [sym_slicing_expression] = STATE(303), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(305), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(371), - [sym_inclusive_or_expression] = STATE(372), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(305), + [sym_indexing_expression] = STATE(305), + [sym_slicing_expression] = STATE(305), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(307), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(373), + [sym_inclusive_or_expression] = STATE(375), [sym_identifier] = STATE(274), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), @@ -18389,7 +18391,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(185), + [anon_sym_static] = ACTIONS(203), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -18397,44 +18399,44 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [sym_name] = ACTIONS(187), + [sym_name] = ACTIONS(205), [sym_comment] = ACTIONS(3), }, [113] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(303), - [sym_indexing_expression] = STATE(303), - [sym_slicing_expression] = STATE(303), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(305), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(365), - [sym_exclusive_or_expression] = STATE(369), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(305), + [sym_indexing_expression] = STATE(305), + [sym_slicing_expression] = STATE(305), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(307), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(367), + [sym_exclusive_or_expression] = STATE(371), [sym_identifier] = STATE(274), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), @@ -18465,7 +18467,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(185), + [anon_sym_static] = ACTIONS(203), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -18473,12 +18475,12 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [sym_name] = ACTIONS(187), + [sym_name] = ACTIONS(205), [sym_comment] = ACTIONS(3), }, [114] = { - [sym_decimal_digit] = STATE(115), - [aux_sym_decimal_digits_repeat1] = STATE(115), + [sym_decimal_digit] = STATE(114), + [aux_sym_decimal_digits_repeat1] = STATE(114), [anon_sym_SEMI] = ACTIONS(217), [anon_sym_EQ] = ACTIONS(219), [anon_sym_RBRACE] = ACTIONS(217), @@ -18552,114 +18554,114 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_comment] = ACTIONS(3), }, [115] = { - [sym_decimal_digit] = STATE(115), - [aux_sym_decimal_digits_repeat1] = STATE(115), - [anon_sym_SEMI] = ACTIONS(223), - [anon_sym_EQ] = ACTIONS(225), - [anon_sym_RBRACE] = ACTIONS(223), - [anon_sym_COMMA] = ACTIONS(223), - [anon_sym_COLON] = ACTIONS(223), - [anon_sym_LPAREN] = ACTIONS(223), - [anon_sym_RPAREN] = ACTIONS(223), - [anon_sym_i8] = ACTIONS(223), - [anon_sym_i16] = ACTIONS(223), - [anon_sym_i32] = ACTIONS(223), - [anon_sym_i64] = ACTIONS(223), - [anon_sym_u8] = ACTIONS(223), - [anon_sym_u16] = ACTIONS(223), - [anon_sym_u32] = ACTIONS(223), - [anon_sym_u64] = ACTIONS(223), - [anon_sym_f32] = ACTIONS(223), - [anon_sym_f64] = ACTIONS(223), - [anon_sym_STAR] = ACTIONS(225), - [anon_sym_PIPE] = ACTIONS(225), - [anon_sym_LBRACK] = ACTIONS(223), - [anon_sym_RBRACK] = ACTIONS(223), - [anon_sym_DOT_DOT_DOT] = ACTIONS(223), - [anon_sym_0] = ACTIONS(227), - [anon_sym_1] = ACTIONS(227), - [anon_sym_2] = ACTIONS(227), - [anon_sym_3] = ACTIONS(227), - [anon_sym_4] = ACTIONS(227), - [anon_sym_5] = ACTIONS(227), - [anon_sym_6] = ACTIONS(227), - [anon_sym_7] = ACTIONS(227), - [anon_sym_8] = ACTIONS(227), - [anon_sym_9] = ACTIONS(227), - [anon_sym_e] = ACTIONS(225), - [anon_sym_i] = ACTIONS(225), - [anon_sym_u] = ACTIONS(225), - [anon_sym_z] = ACTIONS(223), - [anon_sym_DOT] = ACTIONS(225), - [anon_sym_DOT_DOT] = ACTIONS(225), - [anon_sym_QMARK] = ACTIONS(223), - [anon_sym_PLUS] = ACTIONS(225), - [anon_sym_DASH] = ACTIONS(225), - [anon_sym_AMP] = ACTIONS(225), - [anon_sym_as] = ACTIONS(223), - [anon_sym_is] = ACTIONS(223), - [anon_sym_SLASH] = ACTIONS(225), - [anon_sym_PERCENT] = ACTIONS(225), - [anon_sym_LT_LT] = ACTIONS(225), - [anon_sym_GT_GT] = ACTIONS(225), - [anon_sym_CARET] = ACTIONS(225), - [anon_sym_LT] = ACTIONS(225), - [anon_sym_GT] = ACTIONS(225), - [anon_sym_LT_EQ] = ACTIONS(223), - [anon_sym_GT_EQ] = ACTIONS(223), - [anon_sym_EQ_EQ] = ACTIONS(223), - [anon_sym_BANG_EQ] = ACTIONS(223), - [anon_sym_AMP_AMP] = ACTIONS(223), - [anon_sym_CARET_CARET] = ACTIONS(223), - [anon_sym_PIPE_PIPE] = ACTIONS(223), - [anon_sym_else] = ACTIONS(223), - [anon_sym_EQ_GT] = ACTIONS(223), - [anon_sym_PLUS_EQ] = ACTIONS(223), - [anon_sym_DASH_EQ] = ACTIONS(223), - [anon_sym_STAR_EQ] = ACTIONS(223), - [anon_sym_SLASH_EQ] = ACTIONS(223), - [anon_sym_PERCENT_EQ] = ACTIONS(223), - [anon_sym_LT_LT_EQ] = ACTIONS(223), - [anon_sym_GT_GT_EQ] = ACTIONS(223), - [anon_sym_AMP_EQ] = ACTIONS(223), - [anon_sym_PIPE_EQ] = ACTIONS(223), - [anon_sym_CARET_EQ] = ACTIONS(223), + [sym_decimal_digit] = STATE(114), + [aux_sym_decimal_digits_repeat1] = STATE(114), + [anon_sym_SEMI] = ACTIONS(224), + [anon_sym_EQ] = ACTIONS(226), + [anon_sym_RBRACE] = ACTIONS(224), + [anon_sym_COMMA] = ACTIONS(224), + [anon_sym_COLON] = ACTIONS(224), + [anon_sym_LPAREN] = ACTIONS(224), + [anon_sym_RPAREN] = ACTIONS(224), + [anon_sym_i8] = ACTIONS(224), + [anon_sym_i16] = ACTIONS(224), + [anon_sym_i32] = ACTIONS(224), + [anon_sym_i64] = ACTIONS(224), + [anon_sym_u8] = ACTIONS(224), + [anon_sym_u16] = ACTIONS(224), + [anon_sym_u32] = ACTIONS(224), + [anon_sym_u64] = ACTIONS(224), + [anon_sym_f32] = ACTIONS(224), + [anon_sym_f64] = ACTIONS(224), + [anon_sym_STAR] = ACTIONS(226), + [anon_sym_PIPE] = ACTIONS(226), + [anon_sym_LBRACK] = ACTIONS(224), + [anon_sym_RBRACK] = ACTIONS(224), + [anon_sym_DOT_DOT_DOT] = ACTIONS(224), + [anon_sym_0] = ACTIONS(228), + [anon_sym_1] = ACTIONS(228), + [anon_sym_2] = ACTIONS(228), + [anon_sym_3] = ACTIONS(228), + [anon_sym_4] = ACTIONS(228), + [anon_sym_5] = ACTIONS(228), + [anon_sym_6] = ACTIONS(228), + [anon_sym_7] = ACTIONS(228), + [anon_sym_8] = ACTIONS(228), + [anon_sym_9] = ACTIONS(228), + [anon_sym_e] = ACTIONS(226), + [anon_sym_i] = ACTIONS(226), + [anon_sym_u] = ACTIONS(226), + [anon_sym_z] = ACTIONS(224), + [anon_sym_DOT] = ACTIONS(226), + [anon_sym_DOT_DOT] = ACTIONS(226), + [anon_sym_QMARK] = ACTIONS(224), + [anon_sym_PLUS] = ACTIONS(226), + [anon_sym_DASH] = ACTIONS(226), + [anon_sym_AMP] = ACTIONS(226), + [anon_sym_as] = ACTIONS(224), + [anon_sym_is] = ACTIONS(224), + [anon_sym_SLASH] = ACTIONS(226), + [anon_sym_PERCENT] = ACTIONS(226), + [anon_sym_LT_LT] = ACTIONS(226), + [anon_sym_GT_GT] = ACTIONS(226), + [anon_sym_CARET] = ACTIONS(226), + [anon_sym_LT] = ACTIONS(226), + [anon_sym_GT] = ACTIONS(226), + [anon_sym_LT_EQ] = ACTIONS(224), + [anon_sym_GT_EQ] = ACTIONS(224), + [anon_sym_EQ_EQ] = ACTIONS(224), + [anon_sym_BANG_EQ] = ACTIONS(224), + [anon_sym_AMP_AMP] = ACTIONS(224), + [anon_sym_CARET_CARET] = ACTIONS(224), + [anon_sym_PIPE_PIPE] = ACTIONS(224), + [anon_sym_else] = ACTIONS(224), + [anon_sym_EQ_GT] = ACTIONS(224), + [anon_sym_PLUS_EQ] = ACTIONS(224), + [anon_sym_DASH_EQ] = ACTIONS(224), + [anon_sym_STAR_EQ] = ACTIONS(224), + [anon_sym_SLASH_EQ] = ACTIONS(224), + [anon_sym_PERCENT_EQ] = ACTIONS(224), + [anon_sym_LT_LT_EQ] = ACTIONS(224), + [anon_sym_GT_GT_EQ] = ACTIONS(224), + [anon_sym_AMP_EQ] = ACTIONS(224), + [anon_sym_PIPE_EQ] = ACTIONS(224), + [anon_sym_CARET_EQ] = ACTIONS(224), [sym_comment] = ACTIONS(3), }, [116] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(303), - [sym_indexing_expression] = STATE(303), - [sym_slicing_expression] = STATE(303), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(305), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(368), - [sym_and_expression] = STATE(367), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(305), + [sym_indexing_expression] = STATE(305), + [sym_slicing_expression] = STATE(305), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(307), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(370), + [sym_and_expression] = STATE(369), [sym_identifier] = STATE(274), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), @@ -18690,7 +18692,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(185), + [anon_sym_static] = ACTIONS(203), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -18698,42 +18700,42 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [sym_name] = ACTIONS(187), + [sym_name] = ACTIONS(205), [sym_comment] = ACTIONS(3), }, [117] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(303), - [sym_indexing_expression] = STATE(303), - [sym_slicing_expression] = STATE(303), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(305), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(356), - [sym_additive_expression] = STATE(362), - [sym_shift_expression] = STATE(366), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(305), + [sym_indexing_expression] = STATE(305), + [sym_slicing_expression] = STATE(305), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(307), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(358), + [sym_additive_expression] = STATE(364), + [sym_shift_expression] = STATE(368), [sym_identifier] = STATE(274), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), @@ -18764,7 +18766,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(185), + [anon_sym_static] = ACTIONS(203), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -18772,31 +18774,32 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [sym_name] = ACTIONS(187), + [sym_name] = ACTIONS(205), [sym_comment] = ACTIONS(3), }, [118] = { - [sym_hex_digit] = STATE(118), - [aux_sym_hex_digits_repeat1] = STATE(118), - [anon_sym_SEMI] = ACTIONS(189), - [anon_sym_RBRACE] = ACTIONS(189), - [anon_sym_COMMA] = ACTIONS(189), - [anon_sym_COLON] = ACTIONS(189), - [anon_sym_LPAREN] = ACTIONS(189), - [anon_sym_RPAREN] = ACTIONS(189), - [anon_sym_i8] = ACTIONS(189), - [anon_sym_i16] = ACTIONS(189), - [anon_sym_i32] = ACTIONS(189), - [anon_sym_i64] = ACTIONS(189), - [anon_sym_u8] = ACTIONS(189), - [anon_sym_u16] = ACTIONS(189), - [anon_sym_u32] = ACTIONS(189), - [anon_sym_u64] = ACTIONS(189), - [anon_sym_STAR] = ACTIONS(189), - [anon_sym_PIPE] = ACTIONS(191), - [anon_sym_LBRACK] = ACTIONS(189), - [anon_sym_RBRACK] = ACTIONS(189), - [anon_sym_DOT_DOT_DOT] = ACTIONS(189), + [anon_sym_SEMI] = ACTIONS(230), + [anon_sym_EQ] = ACTIONS(232), + [anon_sym_RBRACE] = ACTIONS(230), + [anon_sym_COMMA] = ACTIONS(230), + [anon_sym_COLON] = ACTIONS(230), + [anon_sym_LPAREN] = ACTIONS(230), + [anon_sym_RPAREN] = ACTIONS(230), + [anon_sym_i8] = ACTIONS(230), + [anon_sym_i16] = ACTIONS(230), + [anon_sym_i32] = ACTIONS(230), + [anon_sym_i64] = ACTIONS(230), + [anon_sym_u8] = ACTIONS(230), + [anon_sym_u16] = ACTIONS(230), + [anon_sym_u32] = ACTIONS(230), + [anon_sym_u64] = ACTIONS(230), + [anon_sym_f32] = ACTIONS(230), + [anon_sym_f64] = ACTIONS(230), + [anon_sym_STAR] = ACTIONS(232), + [anon_sym_PIPE] = ACTIONS(232), + [anon_sym_LBRACK] = ACTIONS(230), + [anon_sym_RBRACK] = ACTIONS(230), + [anon_sym_DOT_DOT_DOT] = ACTIONS(230), [anon_sym_0] = ACTIONS(230), [anon_sym_1] = ACTIONS(230), [anon_sym_2] = ACTIONS(230), @@ -18807,224 +18810,223 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_7] = ACTIONS(230), [anon_sym_8] = ACTIONS(230), [anon_sym_9] = ACTIONS(230), - [anon_sym_A] = ACTIONS(230), - [anon_sym_B] = ACTIONS(230), - [anon_sym_C] = ACTIONS(230), - [anon_sym_D] = ACTIONS(230), - [anon_sym_E] = ACTIONS(230), - [anon_sym_F] = ACTIONS(230), - [anon_sym_a] = ACTIONS(233), - [anon_sym_b] = ACTIONS(230), - [anon_sym_c] = ACTIONS(230), - [anon_sym_d] = ACTIONS(230), - [anon_sym_e] = ACTIONS(233), - [anon_sym_f] = ACTIONS(230), - [anon_sym_i] = ACTIONS(191), - [anon_sym_u] = ACTIONS(191), - [anon_sym_z] = ACTIONS(189), - [anon_sym_DOT] = ACTIONS(191), - [anon_sym_DOT_DOT] = ACTIONS(191), - [anon_sym_QMARK] = ACTIONS(189), - [anon_sym_PLUS] = ACTIONS(189), - [anon_sym_DASH] = ACTIONS(189), - [anon_sym_AMP] = ACTIONS(191), - [anon_sym_as] = ACTIONS(189), - [anon_sym_is] = ACTIONS(189), - [anon_sym_SLASH] = ACTIONS(191), - [anon_sym_PERCENT] = ACTIONS(189), - [anon_sym_LT_LT] = ACTIONS(189), - [anon_sym_GT_GT] = ACTIONS(189), - [anon_sym_CARET] = ACTIONS(191), - [anon_sym_LT] = ACTIONS(191), - [anon_sym_GT] = ACTIONS(191), - [anon_sym_LT_EQ] = ACTIONS(189), - [anon_sym_GT_EQ] = ACTIONS(189), - [anon_sym_EQ_EQ] = ACTIONS(189), - [anon_sym_BANG_EQ] = ACTIONS(189), - [anon_sym_AMP_AMP] = ACTIONS(189), - [anon_sym_CARET_CARET] = ACTIONS(189), - [anon_sym_PIPE_PIPE] = ACTIONS(189), - [anon_sym_else] = ACTIONS(189), - [anon_sym_EQ_GT] = ACTIONS(189), + [anon_sym_e] = ACTIONS(232), + [anon_sym_i] = ACTIONS(232), + [anon_sym_u] = ACTIONS(232), + [anon_sym_z] = ACTIONS(230), + [anon_sym_DOT] = ACTIONS(232), + [anon_sym_DOT_DOT] = ACTIONS(232), + [anon_sym_QMARK] = ACTIONS(230), + [anon_sym_PLUS] = ACTIONS(232), + [anon_sym_DASH] = ACTIONS(232), + [anon_sym_AMP] = ACTIONS(232), + [anon_sym_as] = ACTIONS(230), + [anon_sym_is] = ACTIONS(230), + [anon_sym_SLASH] = ACTIONS(232), + [anon_sym_PERCENT] = ACTIONS(232), + [anon_sym_LT_LT] = ACTIONS(232), + [anon_sym_GT_GT] = ACTIONS(232), + [anon_sym_CARET] = ACTIONS(232), + [anon_sym_LT] = ACTIONS(232), + [anon_sym_GT] = ACTIONS(232), + [anon_sym_LT_EQ] = ACTIONS(230), + [anon_sym_GT_EQ] = ACTIONS(230), + [anon_sym_EQ_EQ] = ACTIONS(230), + [anon_sym_BANG_EQ] = ACTIONS(230), + [anon_sym_AMP_AMP] = ACTIONS(230), + [anon_sym_CARET_CARET] = ACTIONS(230), + [anon_sym_PIPE_PIPE] = ACTIONS(230), + [anon_sym_else] = ACTIONS(230), + [anon_sym_EQ_GT] = ACTIONS(230), + [anon_sym_PLUS_EQ] = ACTIONS(230), + [anon_sym_DASH_EQ] = ACTIONS(230), + [anon_sym_STAR_EQ] = ACTIONS(230), + [anon_sym_SLASH_EQ] = ACTIONS(230), + [anon_sym_PERCENT_EQ] = ACTIONS(230), + [anon_sym_LT_LT_EQ] = ACTIONS(230), + [anon_sym_GT_GT_EQ] = ACTIONS(230), + [anon_sym_AMP_EQ] = ACTIONS(230), + [anon_sym_PIPE_EQ] = ACTIONS(230), + [anon_sym_CARET_EQ] = ACTIONS(230), [sym_comment] = ACTIONS(3), }, [119] = { - [sym_hex_digit] = STATE(118), - [aux_sym_hex_digits_repeat1] = STATE(118), - [anon_sym_SEMI] = ACTIONS(205), - [anon_sym_RBRACE] = ACTIONS(205), - [anon_sym_COMMA] = ACTIONS(205), - [anon_sym_COLON] = ACTIONS(205), - [anon_sym_LPAREN] = ACTIONS(205), - [anon_sym_RPAREN] = ACTIONS(205), - [anon_sym_i8] = ACTIONS(205), - [anon_sym_i16] = ACTIONS(205), - [anon_sym_i32] = ACTIONS(205), - [anon_sym_i64] = ACTIONS(205), - [anon_sym_u8] = ACTIONS(205), - [anon_sym_u16] = ACTIONS(205), - [anon_sym_u32] = ACTIONS(205), - [anon_sym_u64] = ACTIONS(205), - [anon_sym_STAR] = ACTIONS(205), - [anon_sym_PIPE] = ACTIONS(207), - [anon_sym_LBRACK] = ACTIONS(205), - [anon_sym_RBRACK] = ACTIONS(205), - [anon_sym_DOT_DOT_DOT] = ACTIONS(205), - [anon_sym_0] = ACTIONS(236), - [anon_sym_1] = ACTIONS(236), - [anon_sym_2] = ACTIONS(236), - [anon_sym_3] = ACTIONS(236), - [anon_sym_4] = ACTIONS(236), - [anon_sym_5] = ACTIONS(236), - [anon_sym_6] = ACTIONS(236), - [anon_sym_7] = ACTIONS(236), - [anon_sym_8] = ACTIONS(236), - [anon_sym_9] = ACTIONS(236), - [anon_sym_A] = ACTIONS(236), - [anon_sym_B] = ACTIONS(236), - [anon_sym_C] = ACTIONS(236), - [anon_sym_D] = ACTIONS(236), - [anon_sym_E] = ACTIONS(236), - [anon_sym_F] = ACTIONS(236), - [anon_sym_a] = ACTIONS(238), - [anon_sym_b] = ACTIONS(236), - [anon_sym_c] = ACTIONS(236), - [anon_sym_d] = ACTIONS(236), - [anon_sym_e] = ACTIONS(238), - [anon_sym_f] = ACTIONS(236), - [anon_sym_i] = ACTIONS(207), - [anon_sym_u] = ACTIONS(207), - [anon_sym_z] = ACTIONS(205), - [anon_sym_DOT] = ACTIONS(207), - [anon_sym_DOT_DOT] = ACTIONS(207), - [anon_sym_QMARK] = ACTIONS(205), - [anon_sym_PLUS] = ACTIONS(205), - [anon_sym_DASH] = ACTIONS(205), - [anon_sym_AMP] = ACTIONS(207), - [anon_sym_as] = ACTIONS(205), - [anon_sym_is] = ACTIONS(205), - [anon_sym_SLASH] = ACTIONS(207), - [anon_sym_PERCENT] = ACTIONS(205), - [anon_sym_LT_LT] = ACTIONS(205), - [anon_sym_GT_GT] = ACTIONS(205), - [anon_sym_CARET] = ACTIONS(207), - [anon_sym_LT] = ACTIONS(207), - [anon_sym_GT] = ACTIONS(207), - [anon_sym_LT_EQ] = ACTIONS(205), - [anon_sym_GT_EQ] = ACTIONS(205), - [anon_sym_EQ_EQ] = ACTIONS(205), - [anon_sym_BANG_EQ] = ACTIONS(205), - [anon_sym_AMP_AMP] = ACTIONS(205), - [anon_sym_CARET_CARET] = ACTIONS(205), - [anon_sym_PIPE_PIPE] = ACTIONS(205), - [anon_sym_else] = ACTIONS(205), - [anon_sym_EQ_GT] = ACTIONS(205), + [sym_hex_digit] = STATE(120), + [aux_sym_hex_digits_repeat1] = STATE(120), + [anon_sym_SEMI] = ACTIONS(179), + [anon_sym_RBRACE] = ACTIONS(179), + [anon_sym_COMMA] = ACTIONS(179), + [anon_sym_COLON] = ACTIONS(179), + [anon_sym_LPAREN] = ACTIONS(179), + [anon_sym_RPAREN] = ACTIONS(179), + [anon_sym_i8] = ACTIONS(179), + [anon_sym_i16] = ACTIONS(179), + [anon_sym_i32] = ACTIONS(179), + [anon_sym_i64] = ACTIONS(179), + [anon_sym_u8] = ACTIONS(179), + [anon_sym_u16] = ACTIONS(179), + [anon_sym_u32] = ACTIONS(179), + [anon_sym_u64] = ACTIONS(179), + [anon_sym_STAR] = ACTIONS(179), + [anon_sym_PIPE] = ACTIONS(181), + [anon_sym_LBRACK] = ACTIONS(179), + [anon_sym_RBRACK] = ACTIONS(179), + [anon_sym_DOT_DOT_DOT] = ACTIONS(179), + [anon_sym_0] = ACTIONS(234), + [anon_sym_1] = ACTIONS(234), + [anon_sym_2] = ACTIONS(234), + [anon_sym_3] = ACTIONS(234), + [anon_sym_4] = ACTIONS(234), + [anon_sym_5] = ACTIONS(234), + [anon_sym_6] = ACTIONS(234), + [anon_sym_7] = ACTIONS(234), + [anon_sym_8] = ACTIONS(234), + [anon_sym_9] = ACTIONS(234), + [anon_sym_A] = ACTIONS(234), + [anon_sym_B] = ACTIONS(234), + [anon_sym_C] = ACTIONS(234), + [anon_sym_D] = ACTIONS(234), + [anon_sym_E] = ACTIONS(234), + [anon_sym_F] = ACTIONS(234), + [anon_sym_a] = ACTIONS(236), + [anon_sym_b] = ACTIONS(234), + [anon_sym_c] = ACTIONS(234), + [anon_sym_d] = ACTIONS(234), + [anon_sym_e] = ACTIONS(236), + [anon_sym_f] = ACTIONS(234), + [anon_sym_i] = ACTIONS(181), + [anon_sym_u] = ACTIONS(181), + [anon_sym_z] = ACTIONS(179), + [anon_sym_DOT] = ACTIONS(181), + [anon_sym_DOT_DOT] = ACTIONS(181), + [anon_sym_QMARK] = ACTIONS(179), + [anon_sym_PLUS] = ACTIONS(179), + [anon_sym_DASH] = ACTIONS(179), + [anon_sym_AMP] = ACTIONS(181), + [anon_sym_as] = ACTIONS(179), + [anon_sym_is] = ACTIONS(179), + [anon_sym_SLASH] = ACTIONS(181), + [anon_sym_PERCENT] = ACTIONS(179), + [anon_sym_LT_LT] = ACTIONS(179), + [anon_sym_GT_GT] = ACTIONS(179), + [anon_sym_CARET] = ACTIONS(181), + [anon_sym_LT] = ACTIONS(181), + [anon_sym_GT] = ACTIONS(181), + [anon_sym_LT_EQ] = ACTIONS(179), + [anon_sym_GT_EQ] = ACTIONS(179), + [anon_sym_EQ_EQ] = ACTIONS(179), + [anon_sym_BANG_EQ] = ACTIONS(179), + [anon_sym_AMP_AMP] = ACTIONS(179), + [anon_sym_CARET_CARET] = ACTIONS(179), + [anon_sym_PIPE_PIPE] = ACTIONS(179), + [anon_sym_else] = ACTIONS(179), + [anon_sym_EQ_GT] = ACTIONS(179), [sym_comment] = ACTIONS(3), }, [120] = { - [anon_sym_SEMI] = ACTIONS(240), - [anon_sym_EQ] = ACTIONS(242), - [anon_sym_RBRACE] = ACTIONS(240), - [anon_sym_COMMA] = ACTIONS(240), - [anon_sym_COLON] = ACTIONS(240), - [anon_sym_LPAREN] = ACTIONS(240), - [anon_sym_RPAREN] = ACTIONS(240), - [anon_sym_i8] = ACTIONS(240), - [anon_sym_i16] = ACTIONS(240), - [anon_sym_i32] = ACTIONS(240), - [anon_sym_i64] = ACTIONS(240), - [anon_sym_u8] = ACTIONS(240), - [anon_sym_u16] = ACTIONS(240), - [anon_sym_u32] = ACTIONS(240), - [anon_sym_u64] = ACTIONS(240), - [anon_sym_f32] = ACTIONS(240), - [anon_sym_f64] = ACTIONS(240), - [anon_sym_STAR] = ACTIONS(242), - [anon_sym_PIPE] = ACTIONS(242), - [anon_sym_LBRACK] = ACTIONS(240), - [anon_sym_RBRACK] = ACTIONS(240), - [anon_sym_DOT_DOT_DOT] = ACTIONS(240), - [anon_sym_0] = ACTIONS(240), - [anon_sym_1] = ACTIONS(240), - [anon_sym_2] = ACTIONS(240), - [anon_sym_3] = ACTIONS(240), - [anon_sym_4] = ACTIONS(240), - [anon_sym_5] = ACTIONS(240), - [anon_sym_6] = ACTIONS(240), - [anon_sym_7] = ACTIONS(240), - [anon_sym_8] = ACTIONS(240), - [anon_sym_9] = ACTIONS(240), - [anon_sym_e] = ACTIONS(242), - [anon_sym_i] = ACTIONS(242), - [anon_sym_u] = ACTIONS(242), - [anon_sym_z] = ACTIONS(240), - [anon_sym_DOT] = ACTIONS(242), - [anon_sym_DOT_DOT] = ACTIONS(242), - [anon_sym_QMARK] = ACTIONS(240), - [anon_sym_PLUS] = ACTIONS(242), - [anon_sym_DASH] = ACTIONS(242), - [anon_sym_AMP] = ACTIONS(242), - [anon_sym_as] = ACTIONS(240), - [anon_sym_is] = ACTIONS(240), - [anon_sym_SLASH] = ACTIONS(242), - [anon_sym_PERCENT] = ACTIONS(242), - [anon_sym_LT_LT] = ACTIONS(242), - [anon_sym_GT_GT] = ACTIONS(242), - [anon_sym_CARET] = ACTIONS(242), - [anon_sym_LT] = ACTIONS(242), - [anon_sym_GT] = ACTIONS(242), - [anon_sym_LT_EQ] = ACTIONS(240), - [anon_sym_GT_EQ] = ACTIONS(240), - [anon_sym_EQ_EQ] = ACTIONS(240), - [anon_sym_BANG_EQ] = ACTIONS(240), - [anon_sym_AMP_AMP] = ACTIONS(240), - [anon_sym_CARET_CARET] = ACTIONS(240), - [anon_sym_PIPE_PIPE] = ACTIONS(240), - [anon_sym_else] = ACTIONS(240), - [anon_sym_EQ_GT] = ACTIONS(240), - [anon_sym_PLUS_EQ] = ACTIONS(240), - [anon_sym_DASH_EQ] = ACTIONS(240), - [anon_sym_STAR_EQ] = ACTIONS(240), - [anon_sym_SLASH_EQ] = ACTIONS(240), - [anon_sym_PERCENT_EQ] = ACTIONS(240), - [anon_sym_LT_LT_EQ] = ACTIONS(240), - [anon_sym_GT_GT_EQ] = ACTIONS(240), - [anon_sym_AMP_EQ] = ACTIONS(240), - [anon_sym_PIPE_EQ] = ACTIONS(240), - [anon_sym_CARET_EQ] = ACTIONS(240), + [sym_hex_digit] = STATE(120), + [aux_sym_hex_digits_repeat1] = STATE(120), + [anon_sym_SEMI] = ACTIONS(187), + [anon_sym_RBRACE] = ACTIONS(187), + [anon_sym_COMMA] = ACTIONS(187), + [anon_sym_COLON] = ACTIONS(187), + [anon_sym_LPAREN] = ACTIONS(187), + [anon_sym_RPAREN] = ACTIONS(187), + [anon_sym_i8] = ACTIONS(187), + [anon_sym_i16] = ACTIONS(187), + [anon_sym_i32] = ACTIONS(187), + [anon_sym_i64] = ACTIONS(187), + [anon_sym_u8] = ACTIONS(187), + [anon_sym_u16] = ACTIONS(187), + [anon_sym_u32] = ACTIONS(187), + [anon_sym_u64] = ACTIONS(187), + [anon_sym_STAR] = ACTIONS(187), + [anon_sym_PIPE] = ACTIONS(189), + [anon_sym_LBRACK] = ACTIONS(187), + [anon_sym_RBRACK] = ACTIONS(187), + [anon_sym_DOT_DOT_DOT] = ACTIONS(187), + [anon_sym_0] = ACTIONS(238), + [anon_sym_1] = ACTIONS(238), + [anon_sym_2] = ACTIONS(238), + [anon_sym_3] = ACTIONS(238), + [anon_sym_4] = ACTIONS(238), + [anon_sym_5] = ACTIONS(238), + [anon_sym_6] = ACTIONS(238), + [anon_sym_7] = ACTIONS(238), + [anon_sym_8] = ACTIONS(238), + [anon_sym_9] = ACTIONS(238), + [anon_sym_A] = ACTIONS(238), + [anon_sym_B] = ACTIONS(238), + [anon_sym_C] = ACTIONS(238), + [anon_sym_D] = ACTIONS(238), + [anon_sym_E] = ACTIONS(238), + [anon_sym_F] = ACTIONS(238), + [anon_sym_a] = ACTIONS(241), + [anon_sym_b] = ACTIONS(238), + [anon_sym_c] = ACTIONS(238), + [anon_sym_d] = ACTIONS(238), + [anon_sym_e] = ACTIONS(241), + [anon_sym_f] = ACTIONS(238), + [anon_sym_i] = ACTIONS(189), + [anon_sym_u] = ACTIONS(189), + [anon_sym_z] = ACTIONS(187), + [anon_sym_DOT] = ACTIONS(189), + [anon_sym_DOT_DOT] = ACTIONS(189), + [anon_sym_QMARK] = ACTIONS(187), + [anon_sym_PLUS] = ACTIONS(187), + [anon_sym_DASH] = ACTIONS(187), + [anon_sym_AMP] = ACTIONS(189), + [anon_sym_as] = ACTIONS(187), + [anon_sym_is] = ACTIONS(187), + [anon_sym_SLASH] = ACTIONS(189), + [anon_sym_PERCENT] = ACTIONS(187), + [anon_sym_LT_LT] = ACTIONS(187), + [anon_sym_GT_GT] = ACTIONS(187), + [anon_sym_CARET] = ACTIONS(189), + [anon_sym_LT] = ACTIONS(189), + [anon_sym_GT] = ACTIONS(189), + [anon_sym_LT_EQ] = ACTIONS(187), + [anon_sym_GT_EQ] = ACTIONS(187), + [anon_sym_EQ_EQ] = ACTIONS(187), + [anon_sym_BANG_EQ] = ACTIONS(187), + [anon_sym_AMP_AMP] = ACTIONS(187), + [anon_sym_CARET_CARET] = ACTIONS(187), + [anon_sym_PIPE_PIPE] = ACTIONS(187), + [anon_sym_else] = ACTIONS(187), + [anon_sym_EQ_GT] = ACTIONS(187), [sym_comment] = ACTIONS(3), }, [121] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(303), - [sym_indexing_expression] = STATE(303), - [sym_slicing_expression] = STATE(303), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(305), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(347), - [sym_multiplicative_expression] = STATE(357), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(305), + [sym_indexing_expression] = STATE(305), + [sym_slicing_expression] = STATE(305), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(307), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(350), + [sym_multiplicative_expression] = STATE(359), [sym_identifier] = STATE(274), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), @@ -19055,7 +19057,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(185), + [anon_sym_static] = ACTIONS(203), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -19063,38 +19065,39 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [sym_name] = ACTIONS(187), + [sym_name] = ACTIONS(205), [sym_comment] = ACTIONS(3), }, [122] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(303), - [sym_indexing_expression] = STATE(303), - [sym_slicing_expression] = STATE(303), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(305), - [sym_unary_expression] = STATE(349), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(305), + [sym_indexing_expression] = STATE(305), + [sym_slicing_expression] = STATE(305), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(307), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(362), [sym_identifier] = STATE(274), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), @@ -19102,7 +19105,6 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_STAR] = ACTIONS(35), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), - [anon_sym_RBRACK] = ACTIONS(244), [anon_sym_true] = ACTIONS(37), [anon_sym_false] = ACTIONS(37), [anon_sym_null] = ACTIONS(37), @@ -19126,7 +19128,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(185), + [anon_sym_static] = ACTIONS(203), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -19134,181 +19136,38 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [sym_name] = ACTIONS(187), + [sym_name] = ACTIONS(205), [sym_comment] = ACTIONS(3), }, [123] = { - [anon_sym_SEMI] = ACTIONS(213), - [anon_sym_RBRACE] = ACTIONS(213), - [anon_sym_COMMA] = ACTIONS(213), - [anon_sym_COLON] = ACTIONS(213), - [anon_sym_LPAREN] = ACTIONS(213), - [anon_sym_RPAREN] = ACTIONS(213), - [anon_sym_i8] = ACTIONS(213), - [anon_sym_i16] = ACTIONS(213), - [anon_sym_i32] = ACTIONS(213), - [anon_sym_i64] = ACTIONS(213), - [anon_sym_u8] = ACTIONS(213), - [anon_sym_u16] = ACTIONS(213), - [anon_sym_u32] = ACTIONS(213), - [anon_sym_u64] = ACTIONS(213), - [anon_sym_STAR] = ACTIONS(213), - [anon_sym_PIPE] = ACTIONS(215), - [anon_sym_LBRACK] = ACTIONS(213), - [anon_sym_RBRACK] = ACTIONS(213), - [anon_sym_DOT_DOT_DOT] = ACTIONS(213), - [anon_sym_0] = ACTIONS(213), - [anon_sym_1] = ACTIONS(213), - [anon_sym_2] = ACTIONS(213), - [anon_sym_3] = ACTIONS(213), - [anon_sym_4] = ACTIONS(213), - [anon_sym_5] = ACTIONS(213), - [anon_sym_6] = ACTIONS(213), - [anon_sym_7] = ACTIONS(213), - [anon_sym_8] = ACTIONS(213), - [anon_sym_9] = ACTIONS(213), - [anon_sym_A] = ACTIONS(213), - [anon_sym_B] = ACTIONS(213), - [anon_sym_C] = ACTIONS(213), - [anon_sym_D] = ACTIONS(213), - [anon_sym_E] = ACTIONS(213), - [anon_sym_F] = ACTIONS(213), - [anon_sym_a] = ACTIONS(215), - [anon_sym_b] = ACTIONS(213), - [anon_sym_c] = ACTIONS(213), - [anon_sym_d] = ACTIONS(213), - [anon_sym_e] = ACTIONS(215), - [anon_sym_f] = ACTIONS(213), - [anon_sym_i] = ACTIONS(215), - [anon_sym_u] = ACTIONS(215), - [anon_sym_z] = ACTIONS(213), - [anon_sym_DOT] = ACTIONS(215), - [anon_sym_DOT_DOT] = ACTIONS(215), - [anon_sym_QMARK] = ACTIONS(213), - [anon_sym_PLUS] = ACTIONS(213), - [anon_sym_DASH] = ACTIONS(213), - [anon_sym_AMP] = ACTIONS(215), - [anon_sym_as] = ACTIONS(213), - [anon_sym_is] = ACTIONS(213), - [anon_sym_SLASH] = ACTIONS(215), - [anon_sym_PERCENT] = ACTIONS(213), - [anon_sym_LT_LT] = ACTIONS(213), - [anon_sym_GT_GT] = ACTIONS(213), - [anon_sym_CARET] = ACTIONS(215), - [anon_sym_LT] = ACTIONS(215), - [anon_sym_GT] = ACTIONS(215), - [anon_sym_LT_EQ] = ACTIONS(213), - [anon_sym_GT_EQ] = ACTIONS(213), - [anon_sym_EQ_EQ] = ACTIONS(213), - [anon_sym_BANG_EQ] = ACTIONS(213), - [anon_sym_AMP_AMP] = ACTIONS(213), - [anon_sym_CARET_CARET] = ACTIONS(213), - [anon_sym_PIPE_PIPE] = ACTIONS(213), - [anon_sym_else] = ACTIONS(213), - [anon_sym_EQ_GT] = ACTIONS(213), - [sym_comment] = ACTIONS(3), - }, - [124] = { - [sym_constant] = STATE(246), - [sym_integer_constant] = STATE(260), - [sym_decimal_digits] = STATE(140), - [sym_decimal_digit] = STATE(114), - [sym_floating_constant] = STATE(260), - [sym_rune_constant] = STATE(260), - [sym_string_constant] = STATE(260), - [sym_array_literal] = STATE(246), - [sym_enum_literal] = STATE(246), - [sym_struct_literal] = STATE(246), - [sym_plain_expression] = STATE(241), - [sym_nested_expression] = STATE(227), - [sym_allocation_expression] = STATE(227), - [sym_assertion_expression] = STATE(227), - [sym_call_expression] = STATE(227), - [sym_measurement_expression] = STATE(227), - [sym_size_expression] = STATE(225), - [sym_length_expression] = STATE(225), - [sym_offset_expression] = STATE(225), - [sym_field_access_expression] = STATE(227), - [sym_indexing_expression] = STATE(227), - [sym_slicing_expression] = STATE(227), - [sym_error_propagation] = STATE(227), - [sym_postfix_expression] = STATE(222), - [sym_unary_expression] = STATE(265), - [sym_identifier] = STATE(204), - [aux_sym_decimal_digits_repeat1] = STATE(114), - [aux_sym_string_constant_repeat1] = STATE(198), - [anon_sym_LPAREN] = ACTIONS(246), - [anon_sym_BANG] = ACTIONS(248), - [anon_sym_void] = ACTIONS(250), - [anon_sym_size] = ACTIONS(252), - [anon_sym_STAR] = ACTIONS(248), - [anon_sym_struct] = ACTIONS(254), - [anon_sym_LBRACK] = ACTIONS(256), - [anon_sym_true] = ACTIONS(250), - [anon_sym_false] = ACTIONS(250), - [anon_sym_null] = ACTIONS(250), - [anon_sym_0x] = ACTIONS(258), - [anon_sym_0o] = ACTIONS(260), - [anon_sym_0b] = ACTIONS(262), - [anon_sym_0] = ACTIONS(264), - [anon_sym_1] = ACTIONS(221), - [anon_sym_2] = ACTIONS(221), - [anon_sym_3] = ACTIONS(221), - [anon_sym_4] = ACTIONS(221), - [anon_sym_5] = ACTIONS(221), - [anon_sym_6] = ACTIONS(221), - [anon_sym_7] = ACTIONS(221), - [anon_sym_8] = ACTIONS(221), - [anon_sym_9] = ACTIONS(221), - [anon_sym_SQUOTE] = ACTIONS(266), - [anon_sym_DQUOTE] = ACTIONS(268), - [anon_sym_alloc] = ACTIONS(270), - [anon_sym_append] = ACTIONS(272), - [anon_sym_free] = ACTIONS(274), - [anon_sym_delete] = ACTIONS(276), - [anon_sym_assert] = ACTIONS(278), - [anon_sym_static] = ACTIONS(280), - [anon_sym_abort] = ACTIONS(282), - [anon_sym_len] = ACTIONS(284), - [anon_sym_offset] = ACTIONS(286), - [anon_sym_PLUS] = ACTIONS(248), - [anon_sym_DASH] = ACTIONS(248), - [anon_sym_TILDE] = ACTIONS(248), - [anon_sym_AMP] = ACTIONS(288), - [anon_sym_EQ_GT] = ACTIONS(290), - [sym_name] = ACTIONS(97), - [sym_comment] = ACTIONS(3), - }, - [125] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(303), - [sym_indexing_expression] = STATE(303), - [sym_slicing_expression] = STATE(303), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(305), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(360), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(305), + [sym_indexing_expression] = STATE(305), + [sym_slicing_expression] = STATE(305), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(307), + [sym_unary_expression] = STATE(357), [sym_identifier] = STATE(274), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), @@ -19316,6 +19175,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_STAR] = ACTIONS(35), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_RBRACK] = ACTIONS(244), [anon_sym_true] = ACTIONS(37), [anon_sym_false] = ACTIONS(37), [anon_sym_null] = ACTIONS(37), @@ -19339,7 +19199,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(185), + [anon_sym_static] = ACTIONS(203), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -19347,39 +19207,38 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [sym_name] = ACTIONS(187), + [sym_name] = ACTIONS(205), [sym_comment] = ACTIONS(3), }, - [126] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [124] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(303), - [sym_indexing_expression] = STATE(303), - [sym_slicing_expression] = STATE(303), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(305), - [sym_unary_expression] = STATE(348), - [sym_cast_expression] = STATE(354), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(305), + [sym_indexing_expression] = STATE(305), + [sym_slicing_expression] = STATE(305), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(307), + [sym_unary_expression] = STATE(357), [sym_identifier] = STATE(274), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), @@ -19387,6 +19246,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_STAR] = ACTIONS(35), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_RBRACK] = ACTIONS(246), [anon_sym_true] = ACTIONS(37), [anon_sym_false] = ACTIONS(37), [anon_sym_null] = ACTIONS(37), @@ -19410,7 +19270,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(185), + [anon_sym_static] = ACTIONS(203), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -19418,38 +19278,181 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [sym_name] = ACTIONS(187), + [sym_name] = ACTIONS(205), + [sym_comment] = ACTIONS(3), + }, + [125] = { + [sym_constant] = STATE(226), + [sym_integer_constant] = STATE(249), + [sym_decimal_digits] = STATE(140), + [sym_decimal_digit] = STATE(115), + [sym_floating_constant] = STATE(249), + [sym_rune_constant] = STATE(249), + [sym_string_constant] = STATE(249), + [sym_array_literal] = STATE(226), + [sym_enum_literal] = STATE(226), + [sym_struct_literal] = STATE(226), + [sym_plain_expression] = STATE(254), + [sym_nested_expression] = STATE(255), + [sym_allocation_expression] = STATE(255), + [sym_assertion_expression] = STATE(255), + [sym_call_expression] = STATE(255), + [sym_measurement_expression] = STATE(255), + [sym_size_expression] = STATE(256), + [sym_length_expression] = STATE(256), + [sym_offset_expression] = STATE(256), + [sym_field_access_expression] = STATE(255), + [sym_indexing_expression] = STATE(255), + [sym_slicing_expression] = STATE(255), + [sym_error_propagation] = STATE(255), + [sym_postfix_expression] = STATE(257), + [sym_unary_expression] = STATE(267), + [sym_identifier] = STATE(196), + [aux_sym_decimal_digits_repeat1] = STATE(115), + [aux_sym_string_constant_repeat1] = STATE(208), + [anon_sym_LPAREN] = ACTIONS(248), + [anon_sym_BANG] = ACTIONS(250), + [anon_sym_void] = ACTIONS(252), + [anon_sym_size] = ACTIONS(254), + [anon_sym_STAR] = ACTIONS(250), + [anon_sym_struct] = ACTIONS(256), + [anon_sym_LBRACK] = ACTIONS(258), + [anon_sym_true] = ACTIONS(252), + [anon_sym_false] = ACTIONS(252), + [anon_sym_null] = ACTIONS(252), + [anon_sym_0x] = ACTIONS(260), + [anon_sym_0o] = ACTIONS(262), + [anon_sym_0b] = ACTIONS(264), + [anon_sym_0] = ACTIONS(266), + [anon_sym_1] = ACTIONS(228), + [anon_sym_2] = ACTIONS(228), + [anon_sym_3] = ACTIONS(228), + [anon_sym_4] = ACTIONS(228), + [anon_sym_5] = ACTIONS(228), + [anon_sym_6] = ACTIONS(228), + [anon_sym_7] = ACTIONS(228), + [anon_sym_8] = ACTIONS(228), + [anon_sym_9] = ACTIONS(228), + [anon_sym_SQUOTE] = ACTIONS(268), + [anon_sym_DQUOTE] = ACTIONS(270), + [anon_sym_alloc] = ACTIONS(272), + [anon_sym_append] = ACTIONS(274), + [anon_sym_free] = ACTIONS(276), + [anon_sym_delete] = ACTIONS(278), + [anon_sym_assert] = ACTIONS(280), + [anon_sym_static] = ACTIONS(282), + [anon_sym_abort] = ACTIONS(284), + [anon_sym_len] = ACTIONS(286), + [anon_sym_offset] = ACTIONS(288), + [anon_sym_PLUS] = ACTIONS(250), + [anon_sym_DASH] = ACTIONS(250), + [anon_sym_TILDE] = ACTIONS(250), + [anon_sym_AMP] = ACTIONS(290), + [anon_sym_EQ_GT] = ACTIONS(292), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [126] = { + [anon_sym_SEMI] = ACTIONS(213), + [anon_sym_RBRACE] = ACTIONS(213), + [anon_sym_COMMA] = ACTIONS(213), + [anon_sym_COLON] = ACTIONS(213), + [anon_sym_LPAREN] = ACTIONS(213), + [anon_sym_RPAREN] = ACTIONS(213), + [anon_sym_i8] = ACTIONS(213), + [anon_sym_i16] = ACTIONS(213), + [anon_sym_i32] = ACTIONS(213), + [anon_sym_i64] = ACTIONS(213), + [anon_sym_u8] = ACTIONS(213), + [anon_sym_u16] = ACTIONS(213), + [anon_sym_u32] = ACTIONS(213), + [anon_sym_u64] = ACTIONS(213), + [anon_sym_STAR] = ACTIONS(213), + [anon_sym_PIPE] = ACTIONS(215), + [anon_sym_LBRACK] = ACTIONS(213), + [anon_sym_RBRACK] = ACTIONS(213), + [anon_sym_DOT_DOT_DOT] = ACTIONS(213), + [anon_sym_0] = ACTIONS(213), + [anon_sym_1] = ACTIONS(213), + [anon_sym_2] = ACTIONS(213), + [anon_sym_3] = ACTIONS(213), + [anon_sym_4] = ACTIONS(213), + [anon_sym_5] = ACTIONS(213), + [anon_sym_6] = ACTIONS(213), + [anon_sym_7] = ACTIONS(213), + [anon_sym_8] = ACTIONS(213), + [anon_sym_9] = ACTIONS(213), + [anon_sym_A] = ACTIONS(213), + [anon_sym_B] = ACTIONS(213), + [anon_sym_C] = ACTIONS(213), + [anon_sym_D] = ACTIONS(213), + [anon_sym_E] = ACTIONS(213), + [anon_sym_F] = ACTIONS(213), + [anon_sym_a] = ACTIONS(215), + [anon_sym_b] = ACTIONS(213), + [anon_sym_c] = ACTIONS(213), + [anon_sym_d] = ACTIONS(213), + [anon_sym_e] = ACTIONS(215), + [anon_sym_f] = ACTIONS(213), + [anon_sym_i] = ACTIONS(215), + [anon_sym_u] = ACTIONS(215), + [anon_sym_z] = ACTIONS(213), + [anon_sym_DOT] = ACTIONS(215), + [anon_sym_DOT_DOT] = ACTIONS(215), + [anon_sym_QMARK] = ACTIONS(213), + [anon_sym_PLUS] = ACTIONS(213), + [anon_sym_DASH] = ACTIONS(213), + [anon_sym_AMP] = ACTIONS(215), + [anon_sym_as] = ACTIONS(213), + [anon_sym_is] = ACTIONS(213), + [anon_sym_SLASH] = ACTIONS(215), + [anon_sym_PERCENT] = ACTIONS(213), + [anon_sym_LT_LT] = ACTIONS(213), + [anon_sym_GT_GT] = ACTIONS(213), + [anon_sym_CARET] = ACTIONS(215), + [anon_sym_LT] = ACTIONS(215), + [anon_sym_GT] = ACTIONS(215), + [anon_sym_LT_EQ] = ACTIONS(213), + [anon_sym_GT_EQ] = ACTIONS(213), + [anon_sym_EQ_EQ] = ACTIONS(213), + [anon_sym_BANG_EQ] = ACTIONS(213), + [anon_sym_AMP_AMP] = ACTIONS(213), + [anon_sym_CARET_CARET] = ACTIONS(213), + [anon_sym_PIPE_PIPE] = ACTIONS(213), + [anon_sym_else] = ACTIONS(213), + [anon_sym_EQ_GT] = ACTIONS(213), [sym_comment] = ACTIONS(3), }, [127] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(303), - [sym_indexing_expression] = STATE(303), - [sym_slicing_expression] = STATE(303), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(305), - [sym_unary_expression] = STATE(349), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(305), + [sym_indexing_expression] = STATE(305), + [sym_slicing_expression] = STATE(305), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(307), + [sym_unary_expression] = STATE(351), + [sym_cast_expression] = STATE(356), [sym_identifier] = STATE(274), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), @@ -19457,7 +19460,6 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_STAR] = ACTIONS(35), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), - [anon_sym_RBRACK] = ACTIONS(292), [anon_sym_true] = ACTIONS(37), [anon_sym_false] = ACTIONS(37), [anon_sym_null] = ACTIONS(37), @@ -19481,7 +19483,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(185), + [anon_sym_static] = ACTIONS(203), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -19489,12 +19491,82 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_DASH] = ACTIONS(35), [anon_sym_TILDE] = ACTIONS(35), [anon_sym_AMP] = ACTIONS(81), - [sym_name] = ACTIONS(187), + [sym_name] = ACTIONS(205), [sym_comment] = ACTIONS(3), }, [128] = { - [sym_octal_digit] = STATE(128), - [aux_sym_octal_digits_repeat1] = STATE(128), + [sym_constant] = STATE(226), + [sym_integer_constant] = STATE(249), + [sym_decimal_digits] = STATE(140), + [sym_decimal_digit] = STATE(115), + [sym_floating_constant] = STATE(249), + [sym_rune_constant] = STATE(249), + [sym_string_constant] = STATE(249), + [sym_array_literal] = STATE(226), + [sym_enum_literal] = STATE(226), + [sym_struct_literal] = STATE(226), + [sym_plain_expression] = STATE(254), + [sym_nested_expression] = STATE(255), + [sym_allocation_expression] = STATE(255), + [sym_assertion_expression] = STATE(255), + [sym_call_expression] = STATE(255), + [sym_measurement_expression] = STATE(255), + [sym_size_expression] = STATE(256), + [sym_length_expression] = STATE(256), + [sym_offset_expression] = STATE(256), + [sym_field_access_expression] = STATE(255), + [sym_indexing_expression] = STATE(255), + [sym_slicing_expression] = STATE(255), + [sym_error_propagation] = STATE(255), + [sym_postfix_expression] = STATE(257), + [sym_unary_expression] = STATE(272), + [sym_identifier] = STATE(196), + [aux_sym_decimal_digits_repeat1] = STATE(115), + [aux_sym_string_constant_repeat1] = STATE(208), + [anon_sym_LPAREN] = ACTIONS(248), + [anon_sym_BANG] = ACTIONS(250), + [anon_sym_void] = ACTIONS(252), + [anon_sym_size] = ACTIONS(254), + [anon_sym_STAR] = ACTIONS(250), + [anon_sym_struct] = ACTIONS(256), + [anon_sym_LBRACK] = ACTIONS(258), + [anon_sym_true] = ACTIONS(252), + [anon_sym_false] = ACTIONS(252), + [anon_sym_null] = ACTIONS(252), + [anon_sym_0x] = ACTIONS(260), + [anon_sym_0o] = ACTIONS(262), + [anon_sym_0b] = ACTIONS(264), + [anon_sym_0] = ACTIONS(266), + [anon_sym_1] = ACTIONS(228), + [anon_sym_2] = ACTIONS(228), + [anon_sym_3] = ACTIONS(228), + [anon_sym_4] = ACTIONS(228), + [anon_sym_5] = ACTIONS(228), + [anon_sym_6] = ACTIONS(228), + [anon_sym_7] = ACTIONS(228), + [anon_sym_8] = ACTIONS(228), + [anon_sym_9] = ACTIONS(228), + [anon_sym_SQUOTE] = ACTIONS(268), + [anon_sym_DQUOTE] = ACTIONS(270), + [anon_sym_alloc] = ACTIONS(272), + [anon_sym_append] = ACTIONS(274), + [anon_sym_free] = ACTIONS(276), + [anon_sym_delete] = ACTIONS(278), + [anon_sym_assert] = ACTIONS(280), + [anon_sym_static] = ACTIONS(282), + [anon_sym_abort] = ACTIONS(284), + [anon_sym_len] = ACTIONS(286), + [anon_sym_offset] = ACTIONS(288), + [anon_sym_PLUS] = ACTIONS(250), + [anon_sym_DASH] = ACTIONS(250), + [anon_sym_TILDE] = ACTIONS(250), + [anon_sym_AMP] = ACTIONS(290), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [129] = { + [sym_octal_digit] = STATE(129), + [aux_sym_octal_digits_repeat1] = STATE(129), [anon_sym_SEMI] = ACTIONS(294), [anon_sym_EQ] = ACTIONS(296), [anon_sym_RBRACE] = ACTIONS(294), @@ -19562,40 +19634,110 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_CARET_EQ] = ACTIONS(294), [sym_comment] = ACTIONS(3), }, - [129] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [130] = { + [sym_constant] = STATE(226), + [sym_integer_constant] = STATE(249), + [sym_decimal_digits] = STATE(140), + [sym_decimal_digit] = STATE(115), + [sym_floating_constant] = STATE(249), + [sym_rune_constant] = STATE(249), + [sym_string_constant] = STATE(249), + [sym_array_literal] = STATE(226), + [sym_enum_literal] = STATE(226), + [sym_struct_literal] = STATE(226), + [sym_plain_expression] = STATE(254), + [sym_nested_expression] = STATE(255), + [sym_allocation_expression] = STATE(255), + [sym_assertion_expression] = STATE(255), + [sym_call_expression] = STATE(255), + [sym_measurement_expression] = STATE(255), + [sym_size_expression] = STATE(256), + [sym_length_expression] = STATE(256), + [sym_offset_expression] = STATE(256), + [sym_field_access_expression] = STATE(255), + [sym_indexing_expression] = STATE(255), + [sym_slicing_expression] = STATE(255), + [sym_error_propagation] = STATE(255), + [sym_postfix_expression] = STATE(257), + [sym_unary_expression] = STATE(269), + [sym_identifier] = STATE(196), + [aux_sym_decimal_digits_repeat1] = STATE(115), + [aux_sym_string_constant_repeat1] = STATE(208), + [anon_sym_LPAREN] = ACTIONS(248), + [anon_sym_BANG] = ACTIONS(250), + [anon_sym_void] = ACTIONS(252), + [anon_sym_size] = ACTIONS(254), + [anon_sym_STAR] = ACTIONS(250), + [anon_sym_struct] = ACTIONS(256), + [anon_sym_LBRACK] = ACTIONS(258), + [anon_sym_true] = ACTIONS(252), + [anon_sym_false] = ACTIONS(252), + [anon_sym_null] = ACTIONS(252), + [anon_sym_0x] = ACTIONS(260), + [anon_sym_0o] = ACTIONS(262), + [anon_sym_0b] = ACTIONS(264), + [anon_sym_0] = ACTIONS(266), + [anon_sym_1] = ACTIONS(228), + [anon_sym_2] = ACTIONS(228), + [anon_sym_3] = ACTIONS(228), + [anon_sym_4] = ACTIONS(228), + [anon_sym_5] = ACTIONS(228), + [anon_sym_6] = ACTIONS(228), + [anon_sym_7] = ACTIONS(228), + [anon_sym_8] = ACTIONS(228), + [anon_sym_9] = ACTIONS(228), + [anon_sym_SQUOTE] = ACTIONS(268), + [anon_sym_DQUOTE] = ACTIONS(270), + [anon_sym_alloc] = ACTIONS(272), + [anon_sym_append] = ACTIONS(274), + [anon_sym_free] = ACTIONS(276), + [anon_sym_delete] = ACTIONS(278), + [anon_sym_assert] = ACTIONS(280), + [anon_sym_static] = ACTIONS(282), + [anon_sym_abort] = ACTIONS(284), + [anon_sym_len] = ACTIONS(286), + [anon_sym_offset] = ACTIONS(288), + [anon_sym_PLUS] = ACTIONS(250), + [anon_sym_DASH] = ACTIONS(250), + [anon_sym_TILDE] = ACTIONS(250), + [anon_sym_AMP] = ACTIONS(290), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [131] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(303), - [sym_indexing_expression] = STATE(303), - [sym_slicing_expression] = STATE(303), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(305), - [sym_unary_expression] = STATE(349), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(305), + [sym_indexing_expression] = STATE(305), + [sym_slicing_expression] = STATE(305), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(307), + [sym_unary_expression] = STATE(810), [sym_identifier] = STATE(274), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LPAREN] = ACTIONS(33), - [anon_sym_BANG] = ACTIONS(35), + [anon_sym_BANG] = ACTIONS(301), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(35), + [anon_sym_STAR] = ACTIONS(301), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -19621,121 +19763,51 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(185), + [anon_sym_static] = ACTIONS(203), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), - [anon_sym_PLUS] = ACTIONS(35), - [anon_sym_DASH] = ACTIONS(35), - [anon_sym_TILDE] = ACTIONS(35), - [anon_sym_AMP] = ACTIONS(81), - [sym_name] = ACTIONS(187), - [sym_comment] = ACTIONS(3), - }, - [130] = { - [sym_constant] = STATE(246), - [sym_integer_constant] = STATE(260), - [sym_decimal_digits] = STATE(140), - [sym_decimal_digit] = STATE(114), - [sym_floating_constant] = STATE(260), - [sym_rune_constant] = STATE(260), - [sym_string_constant] = STATE(260), - [sym_array_literal] = STATE(246), - [sym_enum_literal] = STATE(246), - [sym_struct_literal] = STATE(246), - [sym_plain_expression] = STATE(241), - [sym_nested_expression] = STATE(227), - [sym_allocation_expression] = STATE(227), - [sym_assertion_expression] = STATE(227), - [sym_call_expression] = STATE(227), - [sym_measurement_expression] = STATE(227), - [sym_size_expression] = STATE(225), - [sym_length_expression] = STATE(225), - [sym_offset_expression] = STATE(225), - [sym_field_access_expression] = STATE(227), - [sym_indexing_expression] = STATE(227), - [sym_slicing_expression] = STATE(227), - [sym_error_propagation] = STATE(227), - [sym_postfix_expression] = STATE(222), - [sym_unary_expression] = STATE(271), - [sym_identifier] = STATE(204), - [aux_sym_decimal_digits_repeat1] = STATE(114), - [aux_sym_string_constant_repeat1] = STATE(198), - [anon_sym_LPAREN] = ACTIONS(246), - [anon_sym_BANG] = ACTIONS(248), - [anon_sym_void] = ACTIONS(250), - [anon_sym_size] = ACTIONS(252), - [anon_sym_STAR] = ACTIONS(248), - [anon_sym_struct] = ACTIONS(254), - [anon_sym_LBRACK] = ACTIONS(256), - [anon_sym_true] = ACTIONS(250), - [anon_sym_false] = ACTIONS(250), - [anon_sym_null] = ACTIONS(250), - [anon_sym_0x] = ACTIONS(258), - [anon_sym_0o] = ACTIONS(260), - [anon_sym_0b] = ACTIONS(262), - [anon_sym_0] = ACTIONS(264), - [anon_sym_1] = ACTIONS(221), - [anon_sym_2] = ACTIONS(221), - [anon_sym_3] = ACTIONS(221), - [anon_sym_4] = ACTIONS(221), - [anon_sym_5] = ACTIONS(221), - [anon_sym_6] = ACTIONS(221), - [anon_sym_7] = ACTIONS(221), - [anon_sym_8] = ACTIONS(221), - [anon_sym_9] = ACTIONS(221), - [anon_sym_SQUOTE] = ACTIONS(266), - [anon_sym_DQUOTE] = ACTIONS(268), - [anon_sym_alloc] = ACTIONS(270), - [anon_sym_append] = ACTIONS(272), - [anon_sym_free] = ACTIONS(274), - [anon_sym_delete] = ACTIONS(276), - [anon_sym_assert] = ACTIONS(278), - [anon_sym_static] = ACTIONS(280), - [anon_sym_abort] = ACTIONS(282), - [anon_sym_len] = ACTIONS(284), - [anon_sym_offset] = ACTIONS(286), - [anon_sym_PLUS] = ACTIONS(248), - [anon_sym_DASH] = ACTIONS(248), - [anon_sym_TILDE] = ACTIONS(248), - [anon_sym_AMP] = ACTIONS(288), - [sym_name] = ACTIONS(97), + [anon_sym_PLUS] = ACTIONS(301), + [anon_sym_DASH] = ACTIONS(301), + [anon_sym_TILDE] = ACTIONS(301), + [anon_sym_AMP] = ACTIONS(303), + [sym_name] = ACTIONS(305), [sym_comment] = ACTIONS(3), }, - [131] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [132] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(303), - [sym_indexing_expression] = STATE(303), - [sym_slicing_expression] = STATE(303), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(305), - [sym_unary_expression] = STATE(349), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(305), + [sym_indexing_expression] = STATE(305), + [sym_slicing_expression] = STATE(305), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(307), + [sym_unary_expression] = STATE(357), [sym_identifier] = STATE(274), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LPAREN] = ACTIONS(33), - [anon_sym_BANG] = ACTIONS(301), + [anon_sym_BANG] = ACTIONS(35), [anon_sym_void] = ACTIONS(37), [anon_sym_size] = ACTIONS(39), - [anon_sym_STAR] = ACTIONS(301), + [anon_sym_STAR] = ACTIONS(35), [anon_sym_struct] = ACTIONS(43), [anon_sym_LBRACK] = ACTIONS(45), [anon_sym_true] = ACTIONS(37), @@ -19761,256 +19833,46 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(185), + [anon_sym_static] = ACTIONS(203), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), - [anon_sym_PLUS] = ACTIONS(301), - [anon_sym_DASH] = ACTIONS(301), - [anon_sym_TILDE] = ACTIONS(301), - [anon_sym_AMP] = ACTIONS(303), - [sym_name] = ACTIONS(305), - [sym_comment] = ACTIONS(3), - }, - [132] = { - [sym_constant] = STATE(246), - [sym_integer_constant] = STATE(260), - [sym_decimal_digits] = STATE(140), - [sym_decimal_digit] = STATE(114), - [sym_floating_constant] = STATE(260), - [sym_rune_constant] = STATE(260), - [sym_string_constant] = STATE(260), - [sym_array_literal] = STATE(246), - [sym_enum_literal] = STATE(246), - [sym_struct_literal] = STATE(246), - [sym_plain_expression] = STATE(241), - [sym_nested_expression] = STATE(227), - [sym_allocation_expression] = STATE(227), - [sym_assertion_expression] = STATE(227), - [sym_call_expression] = STATE(227), - [sym_measurement_expression] = STATE(227), - [sym_size_expression] = STATE(225), - [sym_length_expression] = STATE(225), - [sym_offset_expression] = STATE(225), - [sym_field_access_expression] = STATE(227), - [sym_indexing_expression] = STATE(227), - [sym_slicing_expression] = STATE(227), - [sym_error_propagation] = STATE(227), - [sym_postfix_expression] = STATE(222), - [sym_unary_expression] = STATE(268), - [sym_identifier] = STATE(204), - [aux_sym_decimal_digits_repeat1] = STATE(114), - [aux_sym_string_constant_repeat1] = STATE(198), - [anon_sym_LPAREN] = ACTIONS(246), - [anon_sym_BANG] = ACTIONS(248), - [anon_sym_void] = ACTIONS(250), - [anon_sym_size] = ACTIONS(252), - [anon_sym_STAR] = ACTIONS(248), - [anon_sym_struct] = ACTIONS(254), - [anon_sym_LBRACK] = ACTIONS(256), - [anon_sym_true] = ACTIONS(250), - [anon_sym_false] = ACTIONS(250), - [anon_sym_null] = ACTIONS(250), - [anon_sym_0x] = ACTIONS(258), - [anon_sym_0o] = ACTIONS(260), - [anon_sym_0b] = ACTIONS(262), - [anon_sym_0] = ACTIONS(264), - [anon_sym_1] = ACTIONS(221), - [anon_sym_2] = ACTIONS(221), - [anon_sym_3] = ACTIONS(221), - [anon_sym_4] = ACTIONS(221), - [anon_sym_5] = ACTIONS(221), - [anon_sym_6] = ACTIONS(221), - [anon_sym_7] = ACTIONS(221), - [anon_sym_8] = ACTIONS(221), - [anon_sym_9] = ACTIONS(221), - [anon_sym_SQUOTE] = ACTIONS(266), - [anon_sym_DQUOTE] = ACTIONS(268), - [anon_sym_alloc] = ACTIONS(270), - [anon_sym_append] = ACTIONS(272), - [anon_sym_free] = ACTIONS(274), - [anon_sym_delete] = ACTIONS(276), - [anon_sym_assert] = ACTIONS(278), - [anon_sym_static] = ACTIONS(280), - [anon_sym_abort] = ACTIONS(282), - [anon_sym_len] = ACTIONS(284), - [anon_sym_offset] = ACTIONS(286), - [anon_sym_PLUS] = ACTIONS(248), - [anon_sym_DASH] = ACTIONS(248), - [anon_sym_TILDE] = ACTIONS(248), - [anon_sym_AMP] = ACTIONS(288), - [sym_name] = ACTIONS(97), + [anon_sym_PLUS] = ACTIONS(35), + [anon_sym_DASH] = ACTIONS(35), + [anon_sym_TILDE] = ACTIONS(35), + [anon_sym_AMP] = ACTIONS(81), + [sym_name] = ACTIONS(205), [sym_comment] = ACTIONS(3), }, [133] = { - [sym_constant] = STATE(246), - [sym_integer_constant] = STATE(260), - [sym_decimal_digits] = STATE(140), - [sym_decimal_digit] = STATE(114), - [sym_floating_constant] = STATE(260), - [sym_rune_constant] = STATE(260), - [sym_string_constant] = STATE(260), - [sym_array_literal] = STATE(246), - [sym_enum_literal] = STATE(246), - [sym_struct_literal] = STATE(246), - [sym_plain_expression] = STATE(241), - [sym_nested_expression] = STATE(227), - [sym_allocation_expression] = STATE(227), - [sym_assertion_expression] = STATE(227), - [sym_call_expression] = STATE(227), - [sym_measurement_expression] = STATE(227), - [sym_size_expression] = STATE(225), - [sym_length_expression] = STATE(225), - [sym_offset_expression] = STATE(225), - [sym_field_access_expression] = STATE(227), - [sym_indexing_expression] = STATE(227), - [sym_slicing_expression] = STATE(227), - [sym_error_propagation] = STATE(227), - [sym_postfix_expression] = STATE(222), - [sym_unary_expression] = STATE(263), - [sym_identifier] = STATE(204), - [aux_sym_decimal_digits_repeat1] = STATE(114), - [aux_sym_string_constant_repeat1] = STATE(198), - [anon_sym_LPAREN] = ACTIONS(246), - [anon_sym_BANG] = ACTIONS(248), - [anon_sym_void] = ACTIONS(250), - [anon_sym_size] = ACTIONS(252), - [anon_sym_STAR] = ACTIONS(248), - [anon_sym_struct] = ACTIONS(254), - [anon_sym_LBRACK] = ACTIONS(256), - [anon_sym_true] = ACTIONS(250), - [anon_sym_false] = ACTIONS(250), - [anon_sym_null] = ACTIONS(250), - [anon_sym_0x] = ACTIONS(258), - [anon_sym_0o] = ACTIONS(260), - [anon_sym_0b] = ACTIONS(262), - [anon_sym_0] = ACTIONS(264), - [anon_sym_1] = ACTIONS(221), - [anon_sym_2] = ACTIONS(221), - [anon_sym_3] = ACTIONS(221), - [anon_sym_4] = ACTIONS(221), - [anon_sym_5] = ACTIONS(221), - [anon_sym_6] = ACTIONS(221), - [anon_sym_7] = ACTIONS(221), - [anon_sym_8] = ACTIONS(221), - [anon_sym_9] = ACTIONS(221), - [anon_sym_SQUOTE] = ACTIONS(266), - [anon_sym_DQUOTE] = ACTIONS(268), - [anon_sym_alloc] = ACTIONS(270), - [anon_sym_append] = ACTIONS(272), - [anon_sym_free] = ACTIONS(274), - [anon_sym_delete] = ACTIONS(276), - [anon_sym_assert] = ACTIONS(278), - [anon_sym_static] = ACTIONS(280), - [anon_sym_abort] = ACTIONS(282), - [anon_sym_len] = ACTIONS(284), - [anon_sym_offset] = ACTIONS(286), - [anon_sym_PLUS] = ACTIONS(248), - [anon_sym_DASH] = ACTIONS(248), - [anon_sym_TILDE] = ACTIONS(248), - [anon_sym_AMP] = ACTIONS(288), - [sym_name] = ACTIONS(97), - [sym_comment] = ACTIONS(3), - }, - [134] = { - [sym_constant] = STATE(246), - [sym_integer_constant] = STATE(260), - [sym_decimal_digits] = STATE(140), - [sym_decimal_digit] = STATE(114), - [sym_floating_constant] = STATE(260), - [sym_rune_constant] = STATE(260), - [sym_string_constant] = STATE(260), - [sym_array_literal] = STATE(246), - [sym_enum_literal] = STATE(246), - [sym_struct_literal] = STATE(246), - [sym_plain_expression] = STATE(241), - [sym_nested_expression] = STATE(227), - [sym_allocation_expression] = STATE(227), - [sym_assertion_expression] = STATE(227), - [sym_call_expression] = STATE(227), - [sym_measurement_expression] = STATE(227), - [sym_size_expression] = STATE(225), - [sym_length_expression] = STATE(225), - [sym_offset_expression] = STATE(225), - [sym_field_access_expression] = STATE(227), - [sym_indexing_expression] = STATE(227), - [sym_slicing_expression] = STATE(227), - [sym_error_propagation] = STATE(227), - [sym_postfix_expression] = STATE(222), - [sym_unary_expression] = STATE(266), - [sym_identifier] = STATE(204), - [aux_sym_decimal_digits_repeat1] = STATE(114), - [aux_sym_string_constant_repeat1] = STATE(198), - [anon_sym_LPAREN] = ACTIONS(246), - [anon_sym_BANG] = ACTIONS(248), - [anon_sym_void] = ACTIONS(250), - [anon_sym_size] = ACTIONS(252), - [anon_sym_STAR] = ACTIONS(248), - [anon_sym_struct] = ACTIONS(254), - [anon_sym_LBRACK] = ACTIONS(256), - [anon_sym_true] = ACTIONS(250), - [anon_sym_false] = ACTIONS(250), - [anon_sym_null] = ACTIONS(250), - [anon_sym_0x] = ACTIONS(258), - [anon_sym_0o] = ACTIONS(260), - [anon_sym_0b] = ACTIONS(262), - [anon_sym_0] = ACTIONS(264), - [anon_sym_1] = ACTIONS(221), - [anon_sym_2] = ACTIONS(221), - [anon_sym_3] = ACTIONS(221), - [anon_sym_4] = ACTIONS(221), - [anon_sym_5] = ACTIONS(221), - [anon_sym_6] = ACTIONS(221), - [anon_sym_7] = ACTIONS(221), - [anon_sym_8] = ACTIONS(221), - [anon_sym_9] = ACTIONS(221), - [anon_sym_SQUOTE] = ACTIONS(266), - [anon_sym_DQUOTE] = ACTIONS(268), - [anon_sym_alloc] = ACTIONS(270), - [anon_sym_append] = ACTIONS(272), - [anon_sym_free] = ACTIONS(274), - [anon_sym_delete] = ACTIONS(276), - [anon_sym_assert] = ACTIONS(278), - [anon_sym_static] = ACTIONS(280), - [anon_sym_abort] = ACTIONS(282), - [anon_sym_len] = ACTIONS(284), - [anon_sym_offset] = ACTIONS(286), - [anon_sym_PLUS] = ACTIONS(248), - [anon_sym_DASH] = ACTIONS(248), - [anon_sym_TILDE] = ACTIONS(248), - [anon_sym_AMP] = ACTIONS(288), - [sym_name] = ACTIONS(97), - [sym_comment] = ACTIONS(3), - }, - [135] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(303), - [sym_indexing_expression] = STATE(303), - [sym_slicing_expression] = STATE(303), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(305), - [sym_unary_expression] = STATE(776), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(305), + [sym_indexing_expression] = STATE(305), + [sym_slicing_expression] = STATE(305), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(307), + [sym_unary_expression] = STATE(357), [sym_identifier] = STATE(274), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(301), [anon_sym_void] = ACTIONS(37), @@ -20041,7 +19903,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(185), + [anon_sym_static] = ACTIONS(203), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -20052,35 +19914,35 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_name] = ACTIONS(305), [sym_comment] = ACTIONS(3), }, - [136] = { - [sym_constant] = STATE(301), - [sym_integer_constant] = STATE(293), + [134] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), [sym_decimal_digits] = STATE(164), - [sym_decimal_digit] = STATE(146), - [sym_floating_constant] = STATE(293), - [sym_rune_constant] = STATE(293), - [sym_string_constant] = STATE(293), - [sym_array_literal] = STATE(301), - [sym_enum_literal] = STATE(301), - [sym_struct_literal] = STATE(301), - [sym_plain_expression] = STATE(302), - [sym_nested_expression] = STATE(303), - [sym_allocation_expression] = STATE(303), - [sym_assertion_expression] = STATE(303), - [sym_call_expression] = STATE(303), - [sym_measurement_expression] = STATE(303), - [sym_size_expression] = STATE(304), - [sym_length_expression] = STATE(304), - [sym_offset_expression] = STATE(304), - [sym_field_access_expression] = STATE(303), - [sym_indexing_expression] = STATE(303), - [sym_slicing_expression] = STATE(303), - [sym_error_propagation] = STATE(303), - [sym_postfix_expression] = STATE(305), - [sym_unary_expression] = STATE(808), + [sym_decimal_digit] = STATE(149), + [sym_floating_constant] = STATE(295), + [sym_rune_constant] = STATE(295), + [sym_string_constant] = STATE(295), + [sym_array_literal] = STATE(303), + [sym_enum_literal] = STATE(303), + [sym_struct_literal] = STATE(303), + [sym_plain_expression] = STATE(304), + [sym_nested_expression] = STATE(305), + [sym_allocation_expression] = STATE(305), + [sym_assertion_expression] = STATE(305), + [sym_call_expression] = STATE(305), + [sym_measurement_expression] = STATE(305), + [sym_size_expression] = STATE(306), + [sym_length_expression] = STATE(306), + [sym_offset_expression] = STATE(306), + [sym_field_access_expression] = STATE(305), + [sym_indexing_expression] = STATE(305), + [sym_slicing_expression] = STATE(305), + [sym_error_propagation] = STATE(305), + [sym_postfix_expression] = STATE(307), + [sym_unary_expression] = STATE(775), [sym_identifier] = STATE(274), - [aux_sym_decimal_digits_repeat1] = STATE(146), - [aux_sym_string_constant_repeat1] = STATE(272), + [aux_sym_decimal_digits_repeat1] = STATE(149), + [aux_sym_string_constant_repeat1] = STATE(276), [anon_sym_LPAREN] = ACTIONS(33), [anon_sym_BANG] = ACTIONS(301), [anon_sym_void] = ACTIONS(37), @@ -20111,7 +19973,7 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_free] = ACTIONS(65), [anon_sym_delete] = ACTIONS(67), [anon_sym_assert] = ACTIONS(69), - [anon_sym_static] = ACTIONS(185), + [anon_sym_static] = ACTIONS(203), [anon_sym_abort] = ACTIONS(73), [anon_sym_len] = ACTIONS(75), [anon_sym_offset] = ACTIONS(77), @@ -20122,9 +19984,79 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [sym_name] = ACTIONS(305), [sym_comment] = ACTIONS(3), }, - [137] = { - [sym_octal_digit] = STATE(128), - [aux_sym_octal_digits_repeat1] = STATE(128), + [135] = { + [sym_constant] = STATE(226), + [sym_integer_constant] = STATE(249), + [sym_decimal_digits] = STATE(140), + [sym_decimal_digit] = STATE(115), + [sym_floating_constant] = STATE(249), + [sym_rune_constant] = STATE(249), + [sym_string_constant] = STATE(249), + [sym_array_literal] = STATE(226), + [sym_enum_literal] = STATE(226), + [sym_struct_literal] = STATE(226), + [sym_plain_expression] = STATE(254), + [sym_nested_expression] = STATE(255), + [sym_allocation_expression] = STATE(255), + [sym_assertion_expression] = STATE(255), + [sym_call_expression] = STATE(255), + [sym_measurement_expression] = STATE(255), + [sym_size_expression] = STATE(256), + [sym_length_expression] = STATE(256), + [sym_offset_expression] = STATE(256), + [sym_field_access_expression] = STATE(255), + [sym_indexing_expression] = STATE(255), + [sym_slicing_expression] = STATE(255), + [sym_error_propagation] = STATE(255), + [sym_postfix_expression] = STATE(257), + [sym_unary_expression] = STATE(267), + [sym_identifier] = STATE(196), + [aux_sym_decimal_digits_repeat1] = STATE(115), + [aux_sym_string_constant_repeat1] = STATE(208), + [anon_sym_LPAREN] = ACTIONS(248), + [anon_sym_BANG] = ACTIONS(250), + [anon_sym_void] = ACTIONS(252), + [anon_sym_size] = ACTIONS(254), + [anon_sym_STAR] = ACTIONS(250), + [anon_sym_struct] = ACTIONS(256), + [anon_sym_LBRACK] = ACTIONS(258), + [anon_sym_true] = ACTIONS(252), + [anon_sym_false] = ACTIONS(252), + [anon_sym_null] = ACTIONS(252), + [anon_sym_0x] = ACTIONS(260), + [anon_sym_0o] = ACTIONS(262), + [anon_sym_0b] = ACTIONS(264), + [anon_sym_0] = ACTIONS(266), + [anon_sym_1] = ACTIONS(228), + [anon_sym_2] = ACTIONS(228), + [anon_sym_3] = ACTIONS(228), + [anon_sym_4] = ACTIONS(228), + [anon_sym_5] = ACTIONS(228), + [anon_sym_6] = ACTIONS(228), + [anon_sym_7] = ACTIONS(228), + [anon_sym_8] = ACTIONS(228), + [anon_sym_9] = ACTIONS(228), + [anon_sym_SQUOTE] = ACTIONS(268), + [anon_sym_DQUOTE] = ACTIONS(270), + [anon_sym_alloc] = ACTIONS(272), + [anon_sym_append] = ACTIONS(274), + [anon_sym_free] = ACTIONS(276), + [anon_sym_delete] = ACTIONS(278), + [anon_sym_assert] = ACTIONS(280), + [anon_sym_static] = ACTIONS(282), + [anon_sym_abort] = ACTIONS(284), + [anon_sym_len] = ACTIONS(286), + [anon_sym_offset] = ACTIONS(288), + [anon_sym_PLUS] = ACTIONS(250), + [anon_sym_DASH] = ACTIONS(250), + [anon_sym_TILDE] = ACTIONS(250), + [anon_sym_AMP] = ACTIONS(290), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [136] = { + [sym_octal_digit] = STATE(129), + [aux_sym_octal_digits_repeat1] = STATE(129), [anon_sym_SEMI] = ACTIONS(307), [anon_sym_EQ] = ACTIONS(309), [anon_sym_RBRACE] = ACTIONS(307), @@ -20192,73 +20124,143 @@ static uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { [anon_sym_CARET_EQ] = ACTIONS(307), [sym_comment] = ACTIONS(3), }, - [138] = { - [sym_constant] = STATE(246), - [sym_integer_constant] = STATE(260), + [137] = { + [sym_constant] = STATE(226), + [sym_integer_constant] = STATE(249), [sym_decimal_digits] = STATE(140), - [sym_decimal_digit] = STATE(114), - [sym_floating_constant] = STATE(260), - [sym_rune_constant] = STATE(260), - [sym_string_constant] = STATE(260), - [sym_array_literal] = STATE(246), - [sym_enum_literal] = STATE(246), - [sym_struct_literal] = STATE(246), - [sym_plain_expression] = STATE(241), - [sym_nested_expression] = STATE(227), - [sym_allocation_expression] = STATE(227), - [sym_assertion_expression] = STATE(227), - [sym_call_expression] = STATE(227), - [sym_measurement_expression] = STATE(227), - [sym_size_expression] = STATE(225), - [sym_length_expression] = STATE(225), - [sym_offset_expression] = STATE(225), - [sym_field_access_expression] = STATE(227), - [sym_indexing_expression] = STATE(227), - [sym_slicing_expression] = STATE(227), - [sym_error_propagation] = STATE(227), - [sym_postfix_expression] = STATE(222), - [sym_unary_expression] = STATE(265), - [sym_identifier] = STATE(204), - [aux_sym_decimal_digits_repeat1] = STATE(114), - [aux_sym_string_constant_repeat1] = STATE(198), - [anon_sym_LPAREN] = ACTIONS(246), - [anon_sym_BANG] = ACTIONS(248), - [anon_sym_void] = ACTIONS(250), - [anon_sym_size] = ACTIONS(252), - [anon_sym_STAR] = ACTIONS(248), - [anon_sym_struct] = ACTIONS(254), - [anon_sym_LBRACK] = ACTIONS(256), - [anon_sym_true] = ACTIONS(250), - [anon_sym_false] = ACTIONS(250), - [anon_sym_null] = ACTIONS(250), - [anon_sym_0x] = ACTIONS(258), - [anon_sym_0o] = ACTIONS(260), - [anon_sym_0b] = ACTIONS(262), - [anon_sym_0] = ACTIONS(264), - [anon_sym_1] = ACTIONS(221), - [anon_sym_2] = ACTIONS(221), - [anon_sym_3] = ACTIONS(221), - [anon_sym_4] = ACTIONS(221), - [anon_sym_5] = ACTIONS(221), - [anon_sym_6] = ACTIONS(221), - [anon_sym_7] = ACTIONS(221), - [anon_sym_8] = ACTIONS(221), - [anon_sym_9] = ACTIONS(221), - [anon_sym_SQUOTE] = ACTIONS(266), - [anon_sym_DQUOTE] = ACTIONS(268), - [anon_sym_alloc] = ACTIONS(270), - [anon_sym_append] = ACTIONS(272), - [anon_sym_free] = ACTIONS(274), - [anon_sym_delete] = ACTIONS(276), - [anon_sym_assert] = ACTIONS(278), - [anon_sym_static] = ACTIONS(280), - [anon_sym_abort] = ACTIONS(282), - [anon_sym_len] = ACTIONS(284), - [anon_sym_offset] = ACTIONS(286), - [anon_sym_PLUS] = ACTIONS(248), - [anon_sym_DASH] = ACTIONS(248), - [anon_sym_TILDE] = ACTIONS(248), - [anon_sym_AMP] = ACTIONS(288), + [sym_decimal_digit] = STATE(115), + [sym_floating_constant] = STATE(249), + [sym_rune_constant] = STATE(249), + [sym_string_constant] = STATE(249), + [sym_array_literal] = STATE(226), + [sym_enum_literal] = STATE(226), + [sym_struct_literal] = STATE(226), + [sym_plain_expression] = STATE(254), + [sym_nested_expression] = STATE(255), + [sym_allocation_expression] = STATE(255), + [sym_assertion_expression] = STATE(255), + [sym_call_expression] = STATE(255), + [sym_measurement_expression] = STATE(255), + [sym_size_expression] = STATE(256), + [sym_length_expression] = STATE(256), + [sym_offset_expression] = STATE(256), + [sym_field_access_expression] = STATE(255), + [sym_indexing_expression] = STATE(255), + [sym_slicing_expression] = STATE(255), + [sym_error_propagation] = STATE(255), + [sym_postfix_expression] = STATE(257), + [sym_unary_expression] = STATE(264), + [sym_identifier] = STATE(196), + [aux_sym_decimal_digits_repeat1] = STATE(115), + [aux_sym_string_constant_repeat1] = STATE(208), + [anon_sym_LPAREN] = ACTIONS(248), + [anon_sym_BANG] = ACTIONS(250), + [anon_sym_void] = ACTIONS(252), + [anon_sym_size] = ACTIONS(254), + [anon_sym_STAR] = ACTIONS(250), + [anon_sym_struct] = ACTIONS(256), + [anon_sym_LBRACK] = ACTIONS(258), + [anon_sym_true] = ACTIONS(252), + [anon_sym_false] = ACTIONS(252), + [anon_sym_null] = ACTIONS(252), + [anon_sym_0x] = ACTIONS(260), + [anon_sym_0o] = ACTIONS(262), + [anon_sym_0b] = ACTIONS(264), + [anon_sym_0] = ACTIONS(266), + [anon_sym_1] = ACTIONS(228), + [anon_sym_2] = ACTIONS(228), + [anon_sym_3] = ACTIONS(228), + [anon_sym_4] = ACTIONS(228), + [anon_sym_5] = ACTIONS(228), + [anon_sym_6] = ACTIONS(228), + [anon_sym_7] = ACTIONS(228), + [anon_sym_8] = ACTIONS(228), + [anon_sym_9] = ACTIONS(228), + [anon_sym_SQUOTE] = ACTIONS(268), + [anon_sym_DQUOTE] = ACTIONS(270), + [anon_sym_alloc] = ACTIONS(272), + [anon_sym_append] = ACTIONS(274), + [anon_sym_free] = ACTIONS(276), + [anon_sym_delete] = ACTIONS(278), + [anon_sym_assert] = ACTIONS(280), + [anon_sym_static] = ACTIONS(282), + [anon_sym_abort] = ACTIONS(284), + [anon_sym_len] = ACTIONS(286), + [anon_sym_offset] = ACTIONS(288), + [anon_sym_PLUS] = ACTIONS(250), + [anon_sym_DASH] = ACTIONS(250), + [anon_sym_TILDE] = ACTIONS(250), + [anon_sym_AMP] = ACTIONS(290), + [sym_name] = ACTIONS(97), + [sym_comment] = ACTIONS(3), + }, + [138] = { + [sym_constant] = STATE(226), + [sym_integer_constant] = STATE(249), + [sym_decimal_digits] = STATE(140), + [sym_decimal_digit] = STATE(115), + [sym_floating_constant] = STATE(249), + [sym_rune_constant] = STATE(249), + [sym_string_constant] = STATE(249), + [sym_array_literal] = STATE(226), + [sym_enum_literal] = STATE(226), + [sym_struct_literal] = STATE(226), + [sym_plain_expression] = STATE(254), + [sym_nested_expression] = STATE(255), + [sym_allocation_expression] = STATE(255), + [sym_assertion_expression] = STATE(255), + [sym_call_expression] = STATE(255), + [sym_measurement_expression] = STATE(255), + [sym_size_expression] = STATE(256), + [sym_length_expression] = STATE(256), + [sym_offset_expression] = STATE(256), + [sym_field_access_expression] = STATE(255), + [sym_indexing_expression] = STATE(255), + [sym_slicing_expression] = STATE(255), + [sym_error_propagation] = STATE(255), + [sym_postfix_expression] = STATE(257), + [sym_unary_expression] = STATE(265), + [sym_identifier] = STATE(196), + [aux_sym_decimal_digits_repeat1] = STATE(115), + [aux_sym_string_constant_repeat1] = STATE(208), + [anon_sym_LPAREN] = ACTIONS(248), + [anon_sym_BANG] = ACTIONS(250), + [anon_sym_void] = ACTIONS(252), + [anon_sym_size] = ACTIONS(254), + [anon_sym_STAR] = ACTIONS(250), + [anon_sym_struct] = ACTIONS(256), + [anon_sym_LBRACK] = ACTIONS(258), + [anon_sym_true] = ACTIONS(252), + [anon_sym_false] = ACTIONS(252), + [anon_sym_null] = ACTIONS(252), + [anon_sym_0x] = ACTIONS(260), + [anon_sym_0o] = ACTIONS(262), + [anon_sym_0b] = ACTIONS(264), + [anon_sym_0] = ACTIONS(266), + [anon_sym_1] = ACTIONS(228), + [anon_sym_2] = ACTIONS(228), + [anon_sym_3] = ACTIONS(228), + [anon_sym_4] = ACTIONS(228), + [anon_sym_5] = ACTIONS(228), + [anon_sym_6] = ACTIONS(228), + [anon_sym_7] = ACTIONS(228), + [anon_sym_8] = ACTIONS(228), + [anon_sym_9] = ACTIONS(228), + [anon_sym_SQUOTE] = ACTIONS(268), + [anon_sym_DQUOTE] = ACTIONS(270), + [anon_sym_alloc] = ACTIONS(272), + [anon_sym_append] = ACTIONS(274), + [anon_sym_free] = ACTIONS(276), + [anon_sym_delete] = ACTIONS(278), + [anon_sym_assert] = ACTIONS(280), + [anon_sym_static] = ACTIONS(282), + [anon_sym_abort] = ACTIONS(284), + [anon_sym_len] = ACTIONS(286), + [anon_sym_offset] = ACTIONS(288), + [anon_sym_PLUS] = ACTIONS(250), + [anon_sym_DASH] = ACTIONS(250), + [anon_sym_TILDE] = ACTIONS(250), + [anon_sym_AMP] = ACTIONS(290), [sym_name] = ACTIONS(97), [sym_comment] = ACTIONS(3), }, @@ -20340,11 +20342,11 @@ static uint16_t ts_small_parse_table[] = { anon_sym_e, ACTIONS(329), 1, anon_sym_DOT, - STATE(149), 1, + STATE(143), 1, sym_exponent, - STATE(257), 1, + STATE(251), 1, sym_floating_suffix, - STATE(258), 1, + STATE(252), 1, sym_integer_suffix, ACTIONS(323), 2, anon_sym_f32, @@ -20448,7 +20450,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_len, ACTIONS(77), 1, anon_sym_offset, - ACTIONS(185), 1, + ACTIONS(203), 1, anon_sym_static, ACTIONS(305), 1, sym_name, @@ -20456,23 +20458,23 @@ static uint16_t ts_small_parse_table[] = { anon_sym_STAR, STATE(164), 1, sym_decimal_digits, - STATE(272), 1, - aux_sym_string_constant_repeat1, - STATE(276), 1, + STATE(273), 1, sym_identifier, - STATE(302), 1, + STATE(276), 1, + aux_sym_string_constant_repeat1, + STATE(304), 1, sym_plain_expression, - STATE(502), 1, + STATE(516), 1, sym_postfix_expression, - STATE(734), 1, + STATE(736), 1, sym_object_selector, - STATE(146), 2, + STATE(149), 2, sym_decimal_digit, aux_sym_decimal_digits_repeat1, - STATE(313), 2, + STATE(315), 2, sym_field_access_expression, sym_indexing_expression, - STATE(304), 3, + STATE(306), 3, sym_size_expression, sym_length_expression, sym_offset_expression, @@ -20481,17 +20483,17 @@ static uint16_t ts_small_parse_table[] = { anon_sym_true, anon_sym_false, anon_sym_null, - STATE(293), 4, + STATE(295), 4, sym_integer_constant, sym_floating_constant, sym_rune_constant, sym_string_constant, - STATE(301), 4, + STATE(303), 4, sym_constant, sym_array_literal, sym_enum_literal, sym_struct_literal, - STATE(303), 7, + STATE(305), 7, sym_nested_expression, sym_allocation_expression, sym_assertion_expression, @@ -20548,7 +20550,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_len, ACTIONS(77), 1, anon_sym_offset, - ACTIONS(185), 1, + ACTIONS(203), 1, anon_sym_static, ACTIONS(305), 1, sym_name, @@ -20556,23 +20558,23 @@ static uint16_t ts_small_parse_table[] = { anon_sym_STAR, STATE(164), 1, sym_decimal_digits, - STATE(272), 1, - aux_sym_string_constant_repeat1, - STATE(276), 1, + STATE(273), 1, sym_identifier, - STATE(302), 1, + STATE(276), 1, + aux_sym_string_constant_repeat1, + STATE(304), 1, sym_plain_expression, - STATE(502), 1, + STATE(516), 1, sym_postfix_expression, - STATE(806), 1, + STATE(808), 1, sym_object_selector, - STATE(146), 2, + STATE(149), 2, sym_decimal_digit, aux_sym_decimal_digits_repeat1, - STATE(313), 2, + STATE(315), 2, sym_field_access_expression, sym_indexing_expression, - STATE(304), 3, + STATE(306), 3, sym_size_expression, sym_length_expression, sym_offset_expression, @@ -20581,17 +20583,17 @@ static uint16_t ts_small_parse_table[] = { anon_sym_true, anon_sym_false, anon_sym_null, - STATE(293), 4, + STATE(295), 4, sym_integer_constant, sym_floating_constant, sym_rune_constant, sym_string_constant, - STATE(301), 4, + STATE(303), 4, sym_constant, sym_array_literal, sym_enum_literal, sym_struct_literal, - STATE(303), 7, + STATE(305), 7, sym_nested_expression, sym_allocation_expression, sym_assertion_expression, @@ -20609,21 +20611,33 @@ static uint16_t ts_small_parse_table[] = { anon_sym_7, anon_sym_8, anon_sym_9, - [359] = 5, + [359] = 8, ACTIONS(3), 1, sym_comment, - ACTIONS(340), 2, - anon_sym_0, - anon_sym_1, - STATE(143), 2, - sym_binary_digit, - aux_sym_binary_digits_repeat1, - ACTIONS(338), 17, + STATE(228), 1, + sym_floating_suffix, + STATE(244), 1, + sym_integer_suffix, + ACTIONS(323), 2, + anon_sym_f32, + anon_sym_f64, + ACTIONS(327), 2, + anon_sym_i, + anon_sym_u, + ACTIONS(321), 9, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_z, + ACTIONS(338), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, - anon_sym_i, - anon_sym_u, anon_sym_DOT, anon_sym_DOT_DOT, anon_sym_PLUS, @@ -20636,25 +20650,16 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(336), 40, + ACTIONS(336), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, anon_sym_COLON, anon_sym_LPAREN, anon_sym_RPAREN, - anon_sym_i8, - anon_sym_i16, - anon_sym_i32, - anon_sym_i64, - anon_sym_u8, - anon_sym_u16, - anon_sym_u32, - anon_sym_u64, anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, - anon_sym_z, anon_sym_QMARK, anon_sym_as, anon_sym_is, @@ -20677,16 +20682,16 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [432] = 5, + [438] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(347), 2, + ACTIONS(344), 2, anon_sym_0, anon_sym_1, - STATE(143), 2, + STATE(144), 2, sym_binary_digit, aux_sym_binary_digits_repeat1, - ACTIONS(345), 17, + ACTIONS(342), 17, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -20704,7 +20709,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(343), 40, + ACTIONS(340), 40, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -20745,7 +20750,75 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [505] = 35, + [511] = 5, + ACTIONS(3), 1, + sym_comment, + STATE(145), 2, + sym_decimal_digit, + aux_sym_decimal_digits_repeat1, + ACTIONS(347), 10, + anon_sym_0, + anon_sym_1, + anon_sym_2, + anon_sym_3, + anon_sym_4, + anon_sym_5, + anon_sym_6, + anon_sym_7, + anon_sym_8, + anon_sym_9, + ACTIONS(219), 11, + anon_sym_PIPE, + anon_sym_e, + anon_sym_i, + anon_sym_u, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(217), 38, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_f32, + anon_sym_f64, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_z, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [584] = 35, ACTIONS(3), 1, sym_comment, ACTIONS(33), 1, @@ -20784,29 +20857,29 @@ static uint16_t ts_small_parse_table[] = { anon_sym_len, ACTIONS(77), 1, anon_sym_offset, - ACTIONS(185), 1, - anon_sym_static, - ACTIONS(305), 1, + ACTIONS(97), 1, sym_name, + ACTIONS(203), 1, + anon_sym_static, STATE(164), 1, sym_decimal_digits, - STATE(272), 1, - aux_sym_string_constant_repeat1, - STATE(276), 1, + STATE(212), 1, sym_identifier, - STATE(302), 1, - sym_plain_expression, - STATE(350), 1, + STATE(266), 1, sym_object_selector, - STATE(502), 1, + STATE(276), 1, + aux_sym_string_constant_repeat1, + STATE(304), 1, + sym_plain_expression, + STATE(509), 1, sym_postfix_expression, - STATE(146), 2, + STATE(149), 2, sym_decimal_digit, aux_sym_decimal_digits_repeat1, - STATE(313), 2, + STATE(230), 2, sym_field_access_expression, sym_indexing_expression, - STATE(304), 3, + STATE(306), 3, sym_size_expression, sym_length_expression, sym_offset_expression, @@ -20815,17 +20888,17 @@ static uint16_t ts_small_parse_table[] = { anon_sym_true, anon_sym_false, anon_sym_null, - STATE(293), 4, + STATE(295), 4, sym_integer_constant, sym_floating_constant, sym_rune_constant, sym_string_constant, - STATE(301), 4, + STATE(303), 4, sym_constant, sym_array_literal, sym_enum_literal, sym_struct_literal, - STATE(303), 7, + STATE(305), 7, sym_nested_expression, sym_allocation_expression, sym_assertion_expression, @@ -20843,75 +20916,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_7, anon_sym_8, anon_sym_9, - [638] = 5, - ACTIONS(3), 1, - sym_comment, - STATE(148), 2, - sym_decimal_digit, - aux_sym_decimal_digits_repeat1, - ACTIONS(55), 10, - anon_sym_0, - anon_sym_1, - anon_sym_2, - anon_sym_3, - anon_sym_4, - anon_sym_5, - anon_sym_6, - anon_sym_7, - anon_sym_8, - anon_sym_9, - ACTIONS(219), 11, - anon_sym_PIPE, - anon_sym_e, - anon_sym_i, - anon_sym_u, - anon_sym_DOT, - anon_sym_DOT_DOT, - anon_sym_AMP, - anon_sym_SLASH, - anon_sym_CARET, - anon_sym_LT, - anon_sym_GT, - ACTIONS(217), 38, - anon_sym_SEMI, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_i8, - anon_sym_i16, - anon_sym_i32, - anon_sym_i64, - anon_sym_u8, - anon_sym_u16, - anon_sym_u32, - anon_sym_u64, - anon_sym_f32, - anon_sym_f64, - anon_sym_STAR, - anon_sym_LBRACK, - anon_sym_RBRACK, - anon_sym_DOT_DOT_DOT, - anon_sym_z, - anon_sym_QMARK, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_as, - anon_sym_is, - anon_sym_PERCENT, - anon_sym_LT_LT, - anon_sym_GT_GT, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_CARET_CARET, - anon_sym_PIPE_PIPE, - anon_sym_else, - anon_sym_EQ_GT, - [711] = 35, + [717] = 35, ACTIONS(3), 1, sym_comment, ACTIONS(33), 1, @@ -20950,29 +20955,29 @@ static uint16_t ts_small_parse_table[] = { anon_sym_len, ACTIONS(77), 1, anon_sym_offset, - ACTIONS(185), 1, + ACTIONS(203), 1, anon_sym_static, - ACTIONS(187), 1, + ACTIONS(205), 1, sym_name, STATE(164), 1, sym_decimal_digits, - STATE(272), 1, - aux_sym_string_constant_repeat1, - STATE(276), 1, + STATE(273), 1, sym_identifier, - STATE(302), 1, + STATE(276), 1, + aux_sym_string_constant_repeat1, + STATE(304), 1, sym_plain_expression, - STATE(350), 1, + STATE(352), 1, sym_object_selector, - STATE(502), 1, + STATE(516), 1, sym_postfix_expression, - STATE(146), 2, + STATE(149), 2, sym_decimal_digit, aux_sym_decimal_digits_repeat1, - STATE(313), 2, + STATE(315), 2, sym_field_access_expression, sym_indexing_expression, - STATE(304), 3, + STATE(306), 3, sym_size_expression, sym_length_expression, sym_offset_expression, @@ -20981,17 +20986,17 @@ static uint16_t ts_small_parse_table[] = { anon_sym_true, anon_sym_false, anon_sym_null, - STATE(293), 4, + STATE(295), 4, sym_integer_constant, sym_floating_constant, sym_rune_constant, sym_string_constant, - STATE(301), 4, + STATE(303), 4, sym_constant, sym_array_literal, sym_enum_literal, sym_struct_literal, - STATE(303), 7, + STATE(305), 7, sym_nested_expression, sym_allocation_expression, sym_assertion_expression, @@ -21009,88 +21014,140 @@ static uint16_t ts_small_parse_table[] = { anon_sym_7, anon_sym_8, anon_sym_9, - [844] = 5, + [850] = 35, ACTIONS(3), 1, sym_comment, - STATE(148), 2, - sym_decimal_digit, - aux_sym_decimal_digits_repeat1, - ACTIONS(349), 10, - anon_sym_0, - anon_sym_1, - anon_sym_2, - anon_sym_3, - anon_sym_4, - anon_sym_5, - anon_sym_6, - anon_sym_7, - anon_sym_8, - anon_sym_9, - ACTIONS(225), 11, - anon_sym_PIPE, - anon_sym_e, - anon_sym_i, - anon_sym_u, - anon_sym_DOT, - anon_sym_DOT_DOT, - anon_sym_AMP, - anon_sym_SLASH, - anon_sym_CARET, - anon_sym_LT, - anon_sym_GT, - ACTIONS(223), 38, - anon_sym_SEMI, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_COLON, + ACTIONS(33), 1, anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_i8, - anon_sym_i16, - anon_sym_i32, - anon_sym_i64, - anon_sym_u8, - anon_sym_u16, - anon_sym_u32, - anon_sym_u64, - anon_sym_f32, - anon_sym_f64, - anon_sym_STAR, + ACTIONS(39), 1, + anon_sym_size, + ACTIONS(43), 1, + anon_sym_struct, + ACTIONS(45), 1, anon_sym_LBRACK, - anon_sym_RBRACK, - anon_sym_DOT_DOT_DOT, - anon_sym_z, - anon_sym_QMARK, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_as, - anon_sym_is, - anon_sym_PERCENT, - anon_sym_LT_LT, - anon_sym_GT_GT, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_CARET_CARET, - anon_sym_PIPE_PIPE, - anon_sym_else, - anon_sym_EQ_GT, - [917] = 8, + ACTIONS(47), 1, + anon_sym_0x, + ACTIONS(49), 1, + anon_sym_0o, + ACTIONS(51), 1, + anon_sym_0b, + ACTIONS(53), 1, + anon_sym_0, + ACTIONS(57), 1, + anon_sym_SQUOTE, + ACTIONS(59), 1, + anon_sym_DQUOTE, + ACTIONS(61), 1, + anon_sym_alloc, + ACTIONS(63), 1, + anon_sym_append, + ACTIONS(65), 1, + anon_sym_free, + ACTIONS(67), 1, + anon_sym_delete, + ACTIONS(69), 1, + anon_sym_assert, + ACTIONS(73), 1, + anon_sym_abort, + ACTIONS(75), 1, + anon_sym_len, + ACTIONS(77), 1, + anon_sym_offset, + ACTIONS(203), 1, + anon_sym_static, + ACTIONS(305), 1, + sym_name, + STATE(164), 1, + sym_decimal_digits, + STATE(273), 1, + sym_identifier, + STATE(276), 1, + aux_sym_string_constant_repeat1, + STATE(304), 1, + sym_plain_expression, + STATE(352), 1, + sym_object_selector, + STATE(516), 1, + sym_postfix_expression, + STATE(149), 2, + sym_decimal_digit, + aux_sym_decimal_digits_repeat1, + STATE(315), 2, + sym_field_access_expression, + sym_indexing_expression, + STATE(306), 3, + sym_size_expression, + sym_length_expression, + sym_offset_expression, + ACTIONS(37), 4, + anon_sym_void, + anon_sym_true, + anon_sym_false, + anon_sym_null, + STATE(295), 4, + sym_integer_constant, + sym_floating_constant, + sym_rune_constant, + sym_string_constant, + STATE(303), 4, + sym_constant, + sym_array_literal, + sym_enum_literal, + sym_struct_literal, + STATE(305), 7, + sym_nested_expression, + sym_allocation_expression, + sym_assertion_expression, + sym_call_expression, + sym_measurement_expression, + sym_slicing_expression, + sym_error_propagation, + ACTIONS(55), 9, + anon_sym_1, + anon_sym_2, + anon_sym_3, + anon_sym_4, + anon_sym_5, + anon_sym_6, + anon_sym_7, + anon_sym_8, + anon_sym_9, + [983] = 5, ACTIONS(3), 1, sym_comment, - STATE(247), 1, - sym_floating_suffix, - STATE(252), 1, - sym_integer_suffix, - ACTIONS(323), 2, - anon_sym_f32, - anon_sym_f64, - ACTIONS(327), 2, + STATE(145), 2, + sym_decimal_digit, + aux_sym_decimal_digits_repeat1, + ACTIONS(55), 10, + anon_sym_0, + anon_sym_1, + anon_sym_2, + anon_sym_3, + anon_sym_4, + anon_sym_5, + anon_sym_6, + anon_sym_7, + anon_sym_8, + anon_sym_9, + ACTIONS(226), 11, + anon_sym_PIPE, + anon_sym_e, anon_sym_i, anon_sym_u, - ACTIONS(321), 9, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(224), 38, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -21099,11 +21156,45 @@ static uint16_t ts_small_parse_table[] = { anon_sym_u16, anon_sym_u32, anon_sym_u64, + anon_sym_f32, + anon_sym_f64, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, anon_sym_z, - ACTIONS(354), 15, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [1056] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(354), 2, + anon_sym_0, + anon_sym_1, + STATE(144), 2, + sym_binary_digit, + aux_sym_binary_digits_repeat1, + ACTIONS(352), 17, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, + anon_sym_i, + anon_sym_u, anon_sym_DOT, anon_sym_DOT_DOT, anon_sym_PLUS, @@ -21116,16 +21207,25 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(352), 31, + ACTIONS(350), 40, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, anon_sym_COLON, anon_sym_LPAREN, anon_sym_RPAREN, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, + anon_sym_z, anon_sym_QMARK, anon_sym_as, anon_sym_is, @@ -21148,7 +21248,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [996] = 35, + [1129] = 34, ACTIONS(3), 1, sym_comment, ACTIONS(33), 1, @@ -21187,29 +21287,27 @@ static uint16_t ts_small_parse_table[] = { anon_sym_len, ACTIONS(77), 1, anon_sym_offset, - ACTIONS(97), 1, - sym_name, - ACTIONS(185), 1, + ACTIONS(203), 1, anon_sym_static, + ACTIONS(305), 1, + sym_name, STATE(164), 1, sym_decimal_digits, - STATE(215), 1, + STATE(274), 1, sym_identifier, - STATE(264), 1, - sym_object_selector, - STATE(272), 1, + STATE(276), 1, aux_sym_string_constant_repeat1, - STATE(302), 1, + STATE(304), 1, sym_plain_expression, - STATE(500), 1, + STATE(516), 1, sym_postfix_expression, - STATE(146), 2, + STATE(149), 2, sym_decimal_digit, aux_sym_decimal_digits_repeat1, - STATE(220), 2, - sym_field_access_expression, + STATE(491), 2, sym_indexing_expression, - STATE(304), 3, + sym_slicing_expression, + STATE(306), 3, sym_size_expression, sym_length_expression, sym_offset_expression, @@ -21218,23 +21316,23 @@ static uint16_t ts_small_parse_table[] = { anon_sym_true, anon_sym_false, anon_sym_null, - STATE(293), 4, + STATE(295), 4, sym_integer_constant, sym_floating_constant, sym_rune_constant, sym_string_constant, - STATE(301), 4, + STATE(303), 4, sym_constant, sym_array_literal, sym_enum_literal, sym_struct_literal, - STATE(303), 7, + STATE(305), 7, sym_nested_expression, sym_allocation_expression, sym_assertion_expression, sym_call_expression, sym_measurement_expression, - sym_slicing_expression, + sym_field_access_expression, sym_error_propagation, ACTIONS(55), 9, anon_sym_1, @@ -21246,7 +21344,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_7, anon_sym_8, anon_sym_9, - [1129] = 34, + [1259] = 34, ACTIONS(3), 1, sym_comment, ACTIONS(33), 1, @@ -21285,26 +21383,26 @@ static uint16_t ts_small_parse_table[] = { anon_sym_len, ACTIONS(77), 1, anon_sym_offset, - ACTIONS(185), 1, + ACTIONS(203), 1, anon_sym_static, ACTIONS(305), 1, sym_name, STATE(164), 1, sym_decimal_digits, - STATE(272), 1, - aux_sym_string_constant_repeat1, STATE(274), 1, sym_identifier, - STATE(302), 1, + STATE(276), 1, + aux_sym_string_constant_repeat1, + STATE(304), 1, sym_plain_expression, - STATE(484), 1, + STATE(492), 1, sym_field_access_expression, - STATE(502), 1, + STATE(516), 1, sym_postfix_expression, - STATE(146), 2, + STATE(149), 2, sym_decimal_digit, aux_sym_decimal_digits_repeat1, - STATE(304), 3, + STATE(306), 3, sym_size_expression, sym_length_expression, sym_offset_expression, @@ -21313,17 +21411,17 @@ static uint16_t ts_small_parse_table[] = { anon_sym_true, anon_sym_false, anon_sym_null, - STATE(293), 4, + STATE(295), 4, sym_integer_constant, sym_floating_constant, sym_rune_constant, sym_string_constant, - STATE(301), 4, + STATE(303), 4, sym_constant, sym_array_literal, sym_enum_literal, sym_struct_literal, - STATE(303), 8, + STATE(305), 8, sym_nested_expression, sym_allocation_expression, sym_assertion_expression, @@ -21342,7 +21440,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_7, anon_sym_8, anon_sym_9, - [1259] = 34, + [1389] = 34, ACTIONS(3), 1, sym_comment, ACTIONS(33), 1, @@ -21381,27 +21479,27 @@ static uint16_t ts_small_parse_table[] = { anon_sym_len, ACTIONS(77), 1, anon_sym_offset, - ACTIONS(185), 1, + ACTIONS(203), 1, anon_sym_static, ACTIONS(305), 1, sym_name, STATE(164), 1, sym_decimal_digits, - STATE(272), 1, - aux_sym_string_constant_repeat1, STATE(274), 1, sym_identifier, - STATE(302), 1, + STATE(276), 1, + aux_sym_string_constant_repeat1, + STATE(304), 1, sym_plain_expression, - STATE(502), 1, + STATE(516), 1, sym_postfix_expression, - STATE(146), 2, + STATE(149), 2, sym_decimal_digit, aux_sym_decimal_digits_repeat1, - STATE(488), 2, + STATE(484), 2, sym_indexing_expression, sym_slicing_expression, - STATE(304), 3, + STATE(306), 3, sym_size_expression, sym_length_expression, sym_offset_expression, @@ -21410,17 +21508,17 @@ static uint16_t ts_small_parse_table[] = { anon_sym_true, anon_sym_false, anon_sym_null, - STATE(293), 4, + STATE(295), 4, sym_integer_constant, sym_floating_constant, sym_rune_constant, sym_string_constant, - STATE(301), 4, + STATE(303), 4, sym_constant, sym_array_literal, sym_enum_literal, sym_struct_literal, - STATE(303), 7, + STATE(305), 7, sym_nested_expression, sym_allocation_expression, sym_assertion_expression, @@ -21438,14 +21536,14 @@ static uint16_t ts_small_parse_table[] = { anon_sym_7, anon_sym_8, anon_sym_9, - [1389] = 8, + [1519] = 8, ACTIONS(3), 1, sym_comment, ACTIONS(325), 1, anon_sym_e, STATE(159), 1, sym_exponent, - STATE(258), 1, + STATE(252), 1, sym_integer_suffix, ACTIONS(327), 2, anon_sym_i, @@ -21508,7 +21606,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [1467] = 34, + [1597] = 34, ACTIONS(3), 1, sym_comment, ACTIONS(33), 1, @@ -21547,27 +21645,26 @@ static uint16_t ts_small_parse_table[] = { anon_sym_len, ACTIONS(77), 1, anon_sym_offset, - ACTIONS(185), 1, + ACTIONS(203), 1, anon_sym_static, ACTIONS(305), 1, sym_name, STATE(164), 1, sym_decimal_digits, - STATE(272), 1, - aux_sym_string_constant_repeat1, STATE(274), 1, sym_identifier, - STATE(302), 1, + STATE(276), 1, + aux_sym_string_constant_repeat1, + STATE(304), 1, sym_plain_expression, - STATE(502), 1, + STATE(489), 1, + sym_field_access_expression, + STATE(516), 1, sym_postfix_expression, - STATE(146), 2, + STATE(149), 2, sym_decimal_digit, aux_sym_decimal_digits_repeat1, - STATE(483), 2, - sym_indexing_expression, - sym_slicing_expression, - STATE(304), 3, + STATE(306), 3, sym_size_expression, sym_length_expression, sym_offset_expression, @@ -21576,23 +21673,24 @@ static uint16_t ts_small_parse_table[] = { anon_sym_true, anon_sym_false, anon_sym_null, - STATE(293), 4, + STATE(295), 4, sym_integer_constant, sym_floating_constant, sym_rune_constant, sym_string_constant, - STATE(301), 4, + STATE(303), 4, sym_constant, sym_array_literal, sym_enum_literal, sym_struct_literal, - STATE(303), 7, + STATE(305), 8, sym_nested_expression, sym_allocation_expression, sym_assertion_expression, sym_call_expression, sym_measurement_expression, - sym_field_access_expression, + sym_indexing_expression, + sym_slicing_expression, sym_error_propagation, ACTIONS(55), 9, anon_sym_1, @@ -21604,140 +21702,44 @@ static uint16_t ts_small_parse_table[] = { anon_sym_7, anon_sym_8, anon_sym_9, - [1597] = 34, + [1727] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(33), 1, + ACTIONS(358), 17, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_i, + anon_sym_u, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(356), 42, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, anon_sym_LPAREN, - ACTIONS(39), 1, - anon_sym_size, - ACTIONS(43), 1, - anon_sym_struct, - ACTIONS(45), 1, - anon_sym_LBRACK, - ACTIONS(47), 1, - anon_sym_0x, - ACTIONS(49), 1, - anon_sym_0o, - ACTIONS(51), 1, - anon_sym_0b, - ACTIONS(53), 1, - anon_sym_0, - ACTIONS(57), 1, - anon_sym_SQUOTE, - ACTIONS(59), 1, - anon_sym_DQUOTE, - ACTIONS(61), 1, - anon_sym_alloc, - ACTIONS(63), 1, - anon_sym_append, - ACTIONS(65), 1, - anon_sym_free, - ACTIONS(67), 1, - anon_sym_delete, - ACTIONS(69), 1, - anon_sym_assert, - ACTIONS(73), 1, - anon_sym_abort, - ACTIONS(75), 1, - anon_sym_len, - ACTIONS(77), 1, - anon_sym_offset, - ACTIONS(185), 1, - anon_sym_static, - ACTIONS(305), 1, - sym_name, - STATE(164), 1, - sym_decimal_digits, - STATE(272), 1, - aux_sym_string_constant_repeat1, - STATE(274), 1, - sym_identifier, - STATE(302), 1, - sym_plain_expression, - STATE(487), 1, - sym_field_access_expression, - STATE(502), 1, - sym_postfix_expression, - STATE(146), 2, - sym_decimal_digit, - aux_sym_decimal_digits_repeat1, - STATE(304), 3, - sym_size_expression, - sym_length_expression, - sym_offset_expression, - ACTIONS(37), 4, - anon_sym_void, - anon_sym_true, - anon_sym_false, - anon_sym_null, - STATE(293), 4, - sym_integer_constant, - sym_floating_constant, - sym_rune_constant, - sym_string_constant, - STATE(301), 4, - sym_constant, - sym_array_literal, - sym_enum_literal, - sym_struct_literal, - STATE(303), 8, - sym_nested_expression, - sym_allocation_expression, - sym_assertion_expression, - sym_call_expression, - sym_measurement_expression, - sym_indexing_expression, - sym_slicing_expression, - sym_error_propagation, - ACTIONS(55), 9, - anon_sym_1, - anon_sym_2, - anon_sym_3, - anon_sym_4, - anon_sym_5, - anon_sym_6, - anon_sym_7, - anon_sym_8, - anon_sym_9, - [1727] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(358), 17, - anon_sym_EQ, - anon_sym_STAR, - anon_sym_PIPE, - anon_sym_i, - anon_sym_u, - anon_sym_DOT, - anon_sym_DOT_DOT, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_AMP, - anon_sym_SLASH, - anon_sym_PERCENT, - anon_sym_LT_LT, - anon_sym_GT_GT, - anon_sym_CARET, - anon_sym_LT, - anon_sym_GT, - ACTIONS(356), 42, - anon_sym_SEMI, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_i8, - anon_sym_i16, - anon_sym_i32, - anon_sym_i64, - anon_sym_u8, - anon_sym_u16, - anon_sym_u32, - anon_sym_u64, - anon_sym_f32, - anon_sym_f64, + anon_sym_RPAREN, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_f32, + anon_sym_f64, anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, @@ -21767,25 +21769,19 @@ static uint16_t ts_small_parse_table[] = { [1794] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(362), 17, - anon_sym_EQ, - anon_sym_STAR, + ACTIONS(232), 11, anon_sym_PIPE, + anon_sym_e, anon_sym_i, anon_sym_u, anon_sym_DOT, anon_sym_DOT_DOT, - anon_sym_PLUS, - anon_sym_DASH, anon_sym_AMP, anon_sym_SLASH, - anon_sym_PERCENT, - anon_sym_LT_LT, - anon_sym_GT_GT, anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(360), 42, + ACTIONS(230), 48, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -21800,15 +21796,31 @@ static uint16_t ts_small_parse_table[] = { anon_sym_u16, anon_sym_u32, anon_sym_u64, + anon_sym_f32, + anon_sym_f64, + anon_sym_STAR, anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, anon_sym_0, anon_sym_1, + anon_sym_2, + anon_sym_3, + anon_sym_4, + anon_sym_5, + anon_sym_6, + anon_sym_7, + anon_sym_8, + anon_sym_9, anon_sym_z, anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, anon_sym_as, anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, anon_sym_LT_EQ, anon_sym_GT_EQ, anon_sym_EQ_EQ, @@ -21818,32 +21830,28 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - anon_sym_PLUS_EQ, - anon_sym_DASH_EQ, - anon_sym_STAR_EQ, - anon_sym_SLASH_EQ, - anon_sym_PERCENT_EQ, - anon_sym_LT_LT_EQ, - anon_sym_GT_GT_EQ, - anon_sym_AMP_EQ, - anon_sym_PIPE_EQ, - anon_sym_CARET_EQ, [1861] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(242), 11, + ACTIONS(362), 17, + anon_sym_EQ, + anon_sym_STAR, anon_sym_PIPE, - anon_sym_e, anon_sym_i, anon_sym_u, anon_sym_DOT, anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, anon_sym_AMP, anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(240), 48, + ACTIONS(360), 42, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -21858,31 +21866,15 @@ static uint16_t ts_small_parse_table[] = { anon_sym_u16, anon_sym_u32, anon_sym_u64, - anon_sym_f32, - anon_sym_f64, - anon_sym_STAR, anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, anon_sym_0, anon_sym_1, - anon_sym_2, - anon_sym_3, - anon_sym_4, - anon_sym_5, - anon_sym_6, - anon_sym_7, - anon_sym_8, - anon_sym_9, anon_sym_z, anon_sym_QMARK, - anon_sym_PLUS, - anon_sym_DASH, anon_sym_as, anon_sym_is, - anon_sym_PERCENT, - anon_sym_LT_LT, - anon_sym_GT_GT, anon_sym_LT_EQ, anon_sym_GT_EQ, anon_sym_EQ_EQ, @@ -21892,10 +21884,20 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, [1928] = 6, ACTIONS(3), 1, sym_comment, - STATE(252), 1, + STATE(244), 1, sym_integer_suffix, ACTIONS(327), 2, anon_sym_i, @@ -21910,7 +21912,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_u32, anon_sym_u64, anon_sym_z, - ACTIONS(354), 15, + ACTIONS(338), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -21926,7 +21928,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(352), 31, + ACTIONS(336), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -22172,20 +22174,20 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, ACTIONS(397), 1, sym_name, - STATE(428), 1, + STATE(429), 1, sym_identifier, - STATE(552), 1, + STATE(625), 1, sym_match_case, - STATE(649), 1, + STATE(651), 1, sym_fntype_attr, - STATE(713), 1, + STATE(716), 1, sym_match_cases, STATE(725), 1, sym_type, ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, - STATE(426), 2, + STATE(427), 2, sym__inner_type, sym_storage_class, ACTIONS(377), 4, @@ -22193,12 +22195,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_str, anon_sym_bool, anon_sym_void, - STATE(424), 4, + STATE(430), 4, sym_integer_type, sym_floating_type, sym_enum_type, sym_pointer_type, - STATE(427), 9, + STATE(428), 9, sym_scalar_type, sym_struct_type, sym_union_type, @@ -22229,11 +22231,11 @@ static uint16_t ts_small_parse_table[] = { anon_sym_e, ACTIONS(407), 1, anon_sym_DOT, - STATE(173), 1, + STATE(171), 1, sym_exponent, - STATE(298), 1, + STATE(296), 1, sym_integer_suffix, - STATE(299), 1, + STATE(301), 1, sym_floating_suffix, ACTIONS(401), 2, anon_sym_f32, @@ -22316,18 +22318,18 @@ static uint16_t ts_small_parse_table[] = { anon_sym_STAR, ACTIONS(414), 1, sym_name, - STATE(428), 1, + STATE(429), 1, sym_identifier, - STATE(567), 1, + STATE(569), 1, sym_type, - STATE(649), 1, + STATE(651), 1, sym_fntype_attr, - STATE(685), 1, + STATE(686), 1, sym_tuple_types, ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, - STATE(426), 2, + STATE(427), 2, sym__inner_type, sym_storage_class, ACTIONS(377), 4, @@ -22335,12 +22337,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_str, anon_sym_bool, anon_sym_void, - STATE(424), 4, + STATE(430), 4, sym_integer_type, sym_floating_type, sym_enum_type, sym_pointer_type, - STATE(427), 9, + STATE(428), 9, sym_scalar_type, sym_struct_type, sym_union_type, @@ -22364,77 +22366,79 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [2479] = 3, + [2479] = 7, ACTIONS(3), 1, sym_comment, - ACTIONS(416), 24, - anon_sym_LBRACE, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_BANG, + ACTIONS(325), 1, + anon_sym_e, + STATE(183), 1, + sym_exponent, + STATE(227), 1, + sym_floating_suffix, + ACTIONS(323), 2, + anon_sym_f32, + anon_sym_f64, + ACTIONS(418), 15, + anon_sym_EQ, anon_sym_STAR, - anon_sym_LBRACK, - anon_sym_0x, - anon_sym_0o, - anon_sym_0b, - anon_sym_1, - anon_sym_2, - anon_sym_3, - anon_sym_4, - anon_sym_5, - anon_sym_6, - anon_sym_7, - anon_sym_8, - anon_sym_9, - anon_sym_SQUOTE, - anon_sym_DQUOTE, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, - anon_sym_TILDE, anon_sym_AMP, - ACTIONS(418), 27, - anon_sym_let, - anon_sym_const, - anon_sym_void, - anon_sym_size, - anon_sym_struct, - anon_sym_true, - anon_sym_false, - anon_sym_null, - anon_sym_0, - anon_sym_alloc, - anon_sym_append, - anon_sym_free, - anon_sym_delete, - anon_sym_assert, - anon_sym_static, - anon_sym_abort, - anon_sym_len, - anon_sym_offset, - anon_sym_if, - anon_sym_for, - anon_sym_switch, - anon_sym_match, - anon_sym_defer, - anon_sym_break, - anon_sym_continue, - anon_sym_return, - sym_name, - [2538] = 24, - ACTIONS(3), 1, - sym_comment, - ACTIONS(23), 1, - anon_sym_ATnoreturn, - ACTIONS(371), 1, - anon_sym_const, - ACTIONS(373), 1, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(416), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, anon_sym_LPAREN, - ACTIONS(375), 1, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [2546] = 24, + ACTIONS(3), 1, + sym_comment, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(371), 1, + anon_sym_const, + ACTIONS(373), 1, + anon_sym_LPAREN, + ACTIONS(375), 1, anon_sym_fn, ACTIONS(383), 1, anon_sym_enum, - ACTIONS(385), 1, - anon_sym_STAR, ACTIONS(387), 1, anon_sym_nullable, ACTIONS(389), 1, @@ -22445,22 +22449,24 @@ static uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, ACTIONS(395), 1, anon_sym_DOT_DOT_DOT, - ACTIONS(397), 1, + ACTIONS(412), 1, + anon_sym_STAR, + ACTIONS(414), 1, sym_name, - STATE(428), 1, + STATE(429), 1, sym_identifier, - STATE(552), 1, - sym_match_case, + STATE(606), 1, + sym_type, + STATE(648), 1, + sym_tuple_types, STATE(649), 1, + sym_tagged_types, + STATE(651), 1, sym_fntype_attr, - STATE(723), 1, - sym_match_cases, - STATE(725), 1, - sym_type, ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, - STATE(426), 2, + STATE(427), 2, sym__inner_type, sym_storage_class, ACTIONS(377), 4, @@ -22468,12 +22474,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_str, anon_sym_bool, anon_sym_void, - STATE(424), 4, + STATE(430), 4, sym_integer_type, sym_floating_type, sym_enum_type, sym_pointer_type, - STATE(427), 9, + STATE(428), 9, sym_scalar_type, sym_struct_type, sym_union_type, @@ -22497,67 +22503,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [2639] = 7, - ACTIONS(3), 1, - sym_comment, - ACTIONS(325), 1, - anon_sym_e, - STATE(185), 1, - sym_exponent, - STATE(221), 1, - sym_floating_suffix, - ACTIONS(323), 2, - anon_sym_f32, - anon_sym_f64, - ACTIONS(422), 15, - anon_sym_EQ, - anon_sym_STAR, - anon_sym_PIPE, - anon_sym_DOT, - anon_sym_DOT_DOT, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_AMP, - anon_sym_SLASH, - anon_sym_PERCENT, - anon_sym_LT_LT, - anon_sym_GT_GT, - anon_sym_CARET, - anon_sym_LT, - anon_sym_GT, - ACTIONS(420), 31, - anon_sym_SEMI, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_LBRACK, - anon_sym_RBRACK, - anon_sym_DOT_DOT_DOT, - anon_sym_QMARK, - anon_sym_as, - anon_sym_is, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_CARET_CARET, - anon_sym_PIPE_PIPE, - anon_sym_else, - anon_sym_EQ_GT, - anon_sym_PLUS_EQ, - anon_sym_DASH_EQ, - anon_sym_STAR_EQ, - anon_sym_SLASH_EQ, - anon_sym_PERCENT_EQ, - anon_sym_LT_LT_EQ, - anon_sym_GT_GT_EQ, - anon_sym_AMP_EQ, - anon_sym_PIPE_EQ, - anon_sym_CARET_EQ, - [2706] = 24, + [2647] = 24, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, @@ -22570,6 +22516,8 @@ static uint16_t ts_small_parse_table[] = { anon_sym_fn, ACTIONS(383), 1, anon_sym_enum, + ACTIONS(385), 1, + anon_sym_STAR, ACTIONS(387), 1, anon_sym_nullable, ACTIONS(389), 1, @@ -22580,24 +22528,22 @@ static uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, ACTIONS(395), 1, anon_sym_DOT_DOT_DOT, - ACTIONS(412), 1, - anon_sym_STAR, - ACTIONS(414), 1, + ACTIONS(397), 1, sym_name, - STATE(428), 1, + STATE(429), 1, sym_identifier, - STATE(604), 1, - sym_type, - STATE(645), 1, - sym_tuple_types, - STATE(646), 1, - sym_tagged_types, - STATE(649), 1, + STATE(625), 1, + sym_match_case, + STATE(651), 1, sym_fntype_attr, + STATE(724), 1, + sym_match_cases, + STATE(725), 1, + sym_type, ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, - STATE(426), 2, + STATE(427), 2, sym__inner_type, sym_storage_class, ACTIONS(377), 4, @@ -22605,12 +22551,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_str, anon_sym_bool, anon_sym_void, - STATE(424), 4, + STATE(430), 4, sym_integer_type, sym_floating_type, sym_enum_type, sym_pointer_type, - STATE(427), 9, + STATE(428), 9, sym_scalar_type, sym_struct_type, sym_union_type, @@ -22634,7 +22580,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [2807] = 24, + [2748] = 24, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, @@ -22661,20 +22607,20 @@ static uint16_t ts_small_parse_table[] = { anon_sym_STAR, ACTIONS(414), 1, sym_name, - STATE(428), 1, + STATE(429), 1, sym_identifier, - STATE(604), 1, + STATE(606), 1, sym_type, - STATE(649), 1, + STATE(651), 1, sym_fntype_attr, - STATE(658), 1, + STATE(660), 1, sym_tuple_types, - STATE(659), 1, + STATE(661), 1, sym_tagged_types, ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, - STATE(426), 2, + STATE(427), 2, sym__inner_type, sym_storage_class, ACTIONS(377), 4, @@ -22682,12 +22628,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_str, anon_sym_bool, anon_sym_void, - STATE(424), 4, + STATE(430), 4, sym_integer_type, sym_floating_type, sym_enum_type, sym_pointer_type, - STATE(427), 9, + STATE(428), 9, sym_scalar_type, sym_struct_type, sym_union_type, @@ -22711,19 +22657,77 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [2908] = 5, + [2849] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(424), 2, - anon_sym_0, + ACTIONS(420), 24, + anon_sym_LBRACE, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_BANG, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_0x, + anon_sym_0o, + anon_sym_0b, anon_sym_1, - STATE(174), 2, - sym_binary_digit, - aux_sym_binary_digits_repeat1, - ACTIONS(345), 10, - anon_sym_PIPE, + anon_sym_2, + anon_sym_3, + anon_sym_4, + anon_sym_5, + anon_sym_6, + anon_sym_7, + anon_sym_8, + anon_sym_9, + anon_sym_SQUOTE, + anon_sym_DQUOTE, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_TILDE, + anon_sym_AMP, + ACTIONS(422), 27, + anon_sym_let, + anon_sym_const, + anon_sym_void, + anon_sym_size, + anon_sym_struct, + anon_sym_true, + anon_sym_false, + anon_sym_null, + anon_sym_0, + anon_sym_alloc, + anon_sym_append, + anon_sym_free, + anon_sym_delete, + anon_sym_assert, + anon_sym_static, + anon_sym_abort, + anon_sym_len, + anon_sym_offset, + anon_sym_if, + anon_sym_for, + anon_sym_switch, + anon_sym_match, + anon_sym_defer, + anon_sym_break, + anon_sym_continue, + anon_sym_return, + sym_name, + [2908] = 8, + ACTIONS(3), 1, + sym_comment, + STATE(300), 1, + sym_floating_suffix, + STATE(322), 1, + sym_integer_suffix, + ACTIONS(401), 2, + anon_sym_f32, + anon_sym_f64, + ACTIONS(405), 2, anon_sym_i, anon_sym_u, + ACTIONS(338), 8, + anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, anon_sym_AMP, @@ -22731,13 +22735,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(343), 36, - anon_sym_SEMI, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, + ACTIONS(399), 9, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -22746,11 +22744,18 @@ static uint16_t ts_small_parse_table[] = { anon_sym_u16, anon_sym_u32, anon_sym_u64, + anon_sym_z, + ACTIONS(336), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, anon_sym_STAR, anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, - anon_sym_z, anon_sym_QMARK, anon_sym_PLUS, anon_sym_DASH, @@ -22768,7 +22773,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [2970] = 23, + [2976] = 23, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, @@ -22795,18 +22800,18 @@ static uint16_t ts_small_parse_table[] = { anon_sym_STAR, ACTIONS(414), 1, sym_name, - STATE(428), 1, + STATE(429), 1, sym_identifier, - STATE(567), 1, + STATE(569), 1, sym_type, - STATE(649), 1, + STATE(651), 1, sym_fntype_attr, - STATE(685), 1, + STATE(686), 1, sym_tuple_types, ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, - STATE(426), 2, + STATE(427), 2, sym__inner_type, sym_storage_class, ACTIONS(377), 4, @@ -22814,12 +22819,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_str, anon_sym_bool, anon_sym_void, - STATE(424), 4, + STATE(430), 4, sym_integer_type, sym_floating_type, sym_enum_type, sym_pointer_type, - STATE(427), 9, + STATE(428), 9, sym_scalar_type, sym_struct_type, sym_union_type, @@ -22843,21 +22848,19 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [3068] = 8, + [3074] = 5, ACTIONS(3), 1, sym_comment, - STATE(297), 1, - sym_floating_suffix, - STATE(320), 1, - sym_integer_suffix, - ACTIONS(401), 2, - anon_sym_f32, - anon_sym_f64, - ACTIONS(405), 2, + ACTIONS(424), 2, + anon_sym_0, + anon_sym_1, + STATE(173), 2, + sym_binary_digit, + aux_sym_binary_digits_repeat1, + ACTIONS(342), 10, + anon_sym_PIPE, anon_sym_i, anon_sym_u, - ACTIONS(354), 8, - anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, anon_sym_AMP, @@ -22865,7 +22868,13 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(399), 9, + ACTIONS(340), 36, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -22874,18 +22883,11 @@ static uint16_t ts_small_parse_table[] = { anon_sym_u16, anon_sym_u32, anon_sym_u64, - anon_sym_z, - ACTIONS(352), 27, - anon_sym_SEMI, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, anon_sym_STAR, anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, + anon_sym_z, anon_sym_QMARK, anon_sym_PLUS, anon_sym_DASH, @@ -22906,13 +22908,13 @@ static uint16_t ts_small_parse_table[] = { [3136] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(426), 2, + ACTIONS(427), 2, anon_sym_0, anon_sym_1, - STATE(174), 2, + STATE(173), 2, sym_binary_digit, aux_sym_binary_digits_repeat1, - ACTIONS(338), 10, + ACTIONS(352), 10, anon_sym_PIPE, anon_sym_i, anon_sym_u, @@ -22923,7 +22925,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(336), 36, + ACTIONS(350), 36, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -22987,16 +22989,16 @@ static uint16_t ts_small_parse_table[] = { anon_sym_STAR, ACTIONS(414), 1, sym_name, - STATE(428), 1, + STATE(429), 1, sym_identifier, - STATE(559), 1, - sym_type, - STATE(649), 1, + STATE(651), 1, sym_fntype_attr, + STATE(655), 1, + sym_type, ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, - STATE(426), 2, + STATE(427), 2, sym__inner_type, sym_storage_class, ACTIONS(377), 4, @@ -23004,12 +23006,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_str, anon_sym_bool, anon_sym_void, - STATE(424), 4, + STATE(430), 4, sym_integer_type, sym_floating_type, sym_enum_type, sym_pointer_type, - STATE(427), 9, + STATE(428), 9, sym_scalar_type, sym_struct_type, sym_union_type, @@ -23060,16 +23062,16 @@ static uint16_t ts_small_parse_table[] = { anon_sym_STAR, ACTIONS(414), 1, sym_name, - STATE(428), 1, + STATE(429), 1, sym_identifier, - STATE(529), 1, + STATE(536), 1, sym_type, - STATE(649), 1, + STATE(651), 1, sym_fntype_attr, ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, - STATE(426), 2, + STATE(427), 2, sym__inner_type, sym_storage_class, ACTIONS(377), 4, @@ -23077,12 +23079,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_str, anon_sym_bool, anon_sym_void, - STATE(424), 4, + STATE(430), 4, sym_integer_type, sym_floating_type, sym_enum_type, sym_pointer_type, - STATE(427), 9, + STATE(428), 9, sym_scalar_type, sym_struct_type, sym_union_type, @@ -23133,16 +23135,16 @@ static uint16_t ts_small_parse_table[] = { anon_sym_STAR, ACTIONS(414), 1, sym_name, - STATE(428), 1, + STATE(429), 1, sym_identifier, - STATE(557), 1, + STATE(588), 1, sym_type, - STATE(649), 1, + STATE(651), 1, sym_fntype_attr, ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, - STATE(426), 2, + STATE(427), 2, sym__inner_type, sym_storage_class, ACTIONS(377), 4, @@ -23150,12 +23152,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_str, anon_sym_bool, anon_sym_void, - STATE(424), 4, + STATE(430), 4, sym_integer_type, sym_floating_type, sym_enum_type, sym_pointer_type, - STATE(427), 9, + STATE(428), 9, sym_scalar_type, sym_struct_type, sym_union_type, @@ -23179,56 +23181,115 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [3483] = 22, + [3483] = 8, ACTIONS(3), 1, sym_comment, - ACTIONS(23), 1, - anon_sym_ATnoreturn, - ACTIONS(371), 1, - anon_sym_const, - ACTIONS(373), 1, + ACTIONS(403), 1, + anon_sym_e, + STATE(219), 1, + sym_exponent, + STATE(296), 1, + sym_integer_suffix, + ACTIONS(405), 2, + anon_sym_i, + anon_sym_u, + ACTIONS(319), 8, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(399), 9, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_z, + ACTIONS(317), 27, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, anon_sym_LPAREN, - ACTIONS(375), 1, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [3550] = 22, + ACTIONS(3), 1, + sym_comment, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(429), 1, + anon_sym_const, + ACTIONS(431), 1, + anon_sym_LPAREN, + ACTIONS(433), 1, anon_sym_fn, - ACTIONS(383), 1, + ACTIONS(441), 1, anon_sym_enum, - ACTIONS(387), 1, + ACTIONS(443), 1, + anon_sym_STAR, + ACTIONS(445), 1, anon_sym_nullable, - ACTIONS(389), 1, + ACTIONS(447), 1, anon_sym_struct, - ACTIONS(391), 1, + ACTIONS(449), 1, anon_sym_union, - ACTIONS(393), 1, + ACTIONS(451), 1, anon_sym_LBRACK, - ACTIONS(395), 1, + ACTIONS(453), 1, anon_sym_DOT_DOT_DOT, - ACTIONS(412), 1, - anon_sym_STAR, - ACTIONS(414), 1, + ACTIONS(455), 1, sym_name, - STATE(428), 1, + STATE(327), 1, sym_identifier, - STATE(649), 1, - sym_fntype_attr, - STATE(751), 1, + STATE(354), 1, sym_type, - ACTIONS(381), 2, + STATE(739), 1, + sym_fntype_attr, + ACTIONS(439), 2, anon_sym_f32, anon_sym_f64, - STATE(426), 2, + STATE(340), 2, sym__inner_type, sym_storage_class, - ACTIONS(377), 4, + ACTIONS(435), 4, anon_sym_rune, anon_sym_str, anon_sym_bool, anon_sym_void, - STATE(424), 4, + STATE(329), 4, sym_integer_type, sym_floating_type, sym_enum_type, sym_pointer_type, - STATE(427), 9, + STATE(334), 9, sym_scalar_type, sym_struct_type, sym_union_type, @@ -23238,7 +23299,7 @@ static uint16_t ts_small_parse_table[] = { sym_function_type, sym_alias_type, sym_unwrapped_alias, - ACTIONS(379), 13, + ACTIONS(437), 13, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -23252,7 +23313,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [3578] = 22, + [3645] = 22, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, @@ -23279,16 +23340,16 @@ static uint16_t ts_small_parse_table[] = { anon_sym_STAR, ACTIONS(414), 1, sym_name, - STATE(428), 1, + STATE(429), 1, sym_identifier, - STATE(649), 1, + STATE(651), 1, sym_fntype_attr, - STATE(698), 1, + STATE(762), 1, sym_type, ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, - STATE(426), 2, + STATE(427), 2, sym__inner_type, sym_storage_class, ACTIONS(377), 4, @@ -23296,12 +23357,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_str, anon_sym_bool, anon_sym_void, - STATE(424), 4, + STATE(430), 4, sym_integer_type, sym_floating_type, sym_enum_type, sym_pointer_type, - STATE(427), 9, + STATE(428), 9, sym_scalar_type, sym_struct_type, sym_union_type, @@ -23325,7 +23386,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [3673] = 22, + [3740] = 22, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, @@ -23352,16 +23413,16 @@ static uint16_t ts_small_parse_table[] = { anon_sym_STAR, ACTIONS(414), 1, sym_name, - STATE(428), 1, + STATE(429), 1, sym_identifier, - STATE(649), 1, + STATE(651), 1, sym_fntype_attr, - STATE(714), 1, + STATE(717), 1, sym_type, ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, - STATE(426), 2, + STATE(427), 2, sym__inner_type, sym_storage_class, ACTIONS(377), 4, @@ -23369,12 +23430,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_str, anon_sym_bool, anon_sym_void, - STATE(424), 4, + STATE(430), 4, sym_integer_type, sym_floating_type, sym_enum_type, sym_pointer_type, - STATE(427), 9, + STATE(428), 9, sym_scalar_type, sym_struct_type, sym_union_type, @@ -23398,7 +23459,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [3768] = 22, + [3835] = 22, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, @@ -23425,16 +23486,16 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, ACTIONS(455), 1, sym_name, - STATE(326), 1, + STATE(327), 1, sym_identifier, - STATE(353), 1, + STATE(355), 1, sym_type, - STATE(737), 1, + STATE(739), 1, sym_fntype_attr, ACTIONS(439), 2, anon_sym_f32, anon_sym_f64, - STATE(330), 2, + STATE(340), 2, sym__inner_type, sym_storage_class, ACTIONS(435), 4, @@ -23442,12 +23503,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_str, anon_sym_bool, anon_sym_void, - STATE(327), 4, + STATE(329), 4, sym_integer_type, sym_floating_type, sym_enum_type, sym_pointer_type, - STATE(342), 9, + STATE(334), 9, sym_scalar_type, sym_struct_type, sym_union_type, @@ -23471,7 +23532,63 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [3863] = 22, + [3930] = 5, + ACTIONS(3), 1, + sym_comment, + STATE(239), 1, + sym_floating_suffix, + ACTIONS(323), 2, + anon_sym_f32, + anon_sym_f64, + ACTIONS(459), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(457), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [3991] = 22, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, @@ -23498,16 +23615,16 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, ACTIONS(455), 1, sym_name, - STATE(326), 1, + STATE(327), 1, sym_identifier, - STATE(352), 1, + STATE(353), 1, sym_type, - STATE(737), 1, + STATE(739), 1, sym_fntype_attr, ACTIONS(439), 2, anon_sym_f32, anon_sym_f64, - STATE(330), 2, + STATE(340), 2, sym__inner_type, sym_storage_class, ACTIONS(435), 4, @@ -23515,12 +23632,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_str, anon_sym_bool, anon_sym_void, - STATE(327), 4, + STATE(329), 4, sym_integer_type, sym_floating_type, sym_enum_type, sym_pointer_type, - STATE(342), 9, + STATE(334), 9, sym_scalar_type, sym_struct_type, sym_union_type, @@ -23544,7 +23661,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [3958] = 22, + [4086] = 22, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, @@ -23571,16 +23688,16 @@ static uint16_t ts_small_parse_table[] = { anon_sym_STAR, ACTIONS(414), 1, sym_name, - STATE(428), 1, + STATE(429), 1, sym_identifier, - STATE(520), 1, + STATE(543), 1, sym_type, - STATE(649), 1, + STATE(651), 1, sym_fntype_attr, ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, - STATE(426), 2, + STATE(427), 2, sym__inner_type, sym_storage_class, ACTIONS(377), 4, @@ -23588,12 +23705,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_str, anon_sym_bool, anon_sym_void, - STATE(424), 4, + STATE(430), 4, sym_integer_type, sym_floating_type, sym_enum_type, sym_pointer_type, - STATE(427), 9, + STATE(428), 9, sym_scalar_type, sym_struct_type, sym_union_type, @@ -23617,56 +23734,56 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [4053] = 22, + [4181] = 22, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, anon_sym_ATnoreturn, - ACTIONS(429), 1, + ACTIONS(371), 1, anon_sym_const, - ACTIONS(431), 1, + ACTIONS(373), 1, anon_sym_LPAREN, - ACTIONS(433), 1, + ACTIONS(375), 1, anon_sym_fn, - ACTIONS(441), 1, + ACTIONS(383), 1, anon_sym_enum, - ACTIONS(443), 1, - anon_sym_STAR, - ACTIONS(445), 1, + ACTIONS(387), 1, anon_sym_nullable, - ACTIONS(447), 1, + ACTIONS(389), 1, anon_sym_struct, - ACTIONS(449), 1, + ACTIONS(391), 1, anon_sym_union, - ACTIONS(451), 1, + ACTIONS(393), 1, anon_sym_LBRACK, - ACTIONS(453), 1, + ACTIONS(395), 1, anon_sym_DOT_DOT_DOT, - ACTIONS(455), 1, + ACTIONS(412), 1, + anon_sym_STAR, + ACTIONS(414), 1, sym_name, - STATE(326), 1, + STATE(429), 1, sym_identifier, - STATE(351), 1, + STATE(584), 1, sym_type, - STATE(737), 1, + STATE(651), 1, sym_fntype_attr, - ACTIONS(439), 2, + ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, - STATE(330), 2, + STATE(427), 2, sym__inner_type, sym_storage_class, - ACTIONS(435), 4, + ACTIONS(377), 4, anon_sym_rune, anon_sym_str, anon_sym_bool, anon_sym_void, - STATE(327), 4, + STATE(430), 4, sym_integer_type, sym_floating_type, sym_enum_type, sym_pointer_type, - STATE(342), 9, + STATE(428), 9, sym_scalar_type, sym_struct_type, sym_union_type, @@ -23676,7 +23793,7 @@ static uint16_t ts_small_parse_table[] = { sym_function_type, sym_alias_type, sym_unwrapped_alias, - ACTIONS(437), 13, + ACTIONS(379), 13, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -23690,63 +23807,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [4148] = 5, - ACTIONS(3), 1, - sym_comment, - STATE(236), 1, - sym_floating_suffix, - ACTIONS(323), 2, - anon_sym_f32, - anon_sym_f64, - ACTIONS(459), 15, - anon_sym_EQ, - anon_sym_STAR, - anon_sym_PIPE, - anon_sym_DOT, - anon_sym_DOT_DOT, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_AMP, - anon_sym_SLASH, - anon_sym_PERCENT, - anon_sym_LT_LT, - anon_sym_GT_GT, - anon_sym_CARET, - anon_sym_LT, - anon_sym_GT, - ACTIONS(457), 31, - anon_sym_SEMI, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_LBRACK, - anon_sym_RBRACK, - anon_sym_DOT_DOT_DOT, - anon_sym_QMARK, - anon_sym_as, - anon_sym_is, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_CARET_CARET, - anon_sym_PIPE_PIPE, - anon_sym_else, - anon_sym_EQ_GT, - anon_sym_PLUS_EQ, - anon_sym_DASH_EQ, - anon_sym_STAR_EQ, - anon_sym_SLASH_EQ, - anon_sym_PERCENT_EQ, - anon_sym_LT_LT_EQ, - anon_sym_GT_GT_EQ, - anon_sym_AMP_EQ, - anon_sym_PIPE_EQ, - anon_sym_CARET_EQ, - [4209] = 22, + [4276] = 22, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, @@ -23773,16 +23834,16 @@ static uint16_t ts_small_parse_table[] = { anon_sym_STAR, ACTIONS(414), 1, sym_name, - STATE(428), 1, + STATE(429), 1, sym_identifier, - STATE(649), 1, + STATE(651), 1, sym_fntype_attr, - STATE(702), 1, + STATE(753), 1, sym_type, ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, - STATE(426), 2, + STATE(427), 2, sym__inner_type, sym_storage_class, ACTIONS(377), 4, @@ -23790,12 +23851,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_str, anon_sym_bool, anon_sym_void, - STATE(424), 4, + STATE(430), 4, sym_integer_type, sym_floating_type, sym_enum_type, sym_pointer_type, - STATE(427), 9, + STATE(428), 9, sym_scalar_type, sym_struct_type, sym_union_type, @@ -23819,7 +23880,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [4304] = 22, + [4371] = 22, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, @@ -23846,16 +23907,16 @@ static uint16_t ts_small_parse_table[] = { anon_sym_STAR, ACTIONS(414), 1, sym_name, - ACTIONS(461), 1, - anon_sym_EQ_GT, - STATE(428), 1, + STATE(429), 1, sym_identifier, - STATE(649), 1, + STATE(553), 1, + sym_type, + STATE(651), 1, sym_fntype_attr, ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, - STATE(435), 2, + STATE(427), 2, sym__inner_type, sym_storage_class, ACTIONS(377), 4, @@ -23863,12 +23924,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_str, anon_sym_bool, anon_sym_void, - STATE(424), 4, + STATE(430), 4, sym_integer_type, sym_floating_type, sym_enum_type, sym_pointer_type, - STATE(427), 9, + STATE(428), 9, sym_scalar_type, sym_struct_type, sym_union_type, @@ -23892,7 +23953,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [4399] = 22, + [4466] = 22, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, @@ -23919,16 +23980,16 @@ static uint16_t ts_small_parse_table[] = { anon_sym_STAR, ACTIONS(414), 1, sym_name, - STATE(428), 1, + ACTIONS(461), 1, + anon_sym_EQ_GT, + STATE(429), 1, sym_identifier, - STATE(616), 1, - sym_type, - STATE(649), 1, + STATE(651), 1, sym_fntype_attr, ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, - STATE(426), 2, + STATE(442), 2, sym__inner_type, sym_storage_class, ACTIONS(377), 4, @@ -23936,12 +23997,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_str, anon_sym_bool, anon_sym_void, - STATE(424), 4, + STATE(430), 4, sym_integer_type, sym_floating_type, sym_enum_type, sym_pointer_type, - STATE(427), 9, + STATE(428), 9, sym_scalar_type, sym_struct_type, sym_union_type, @@ -23965,7 +24026,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [4494] = 22, + [4561] = 22, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, @@ -23992,16 +24053,16 @@ static uint16_t ts_small_parse_table[] = { anon_sym_STAR, ACTIONS(414), 1, sym_name, - STATE(428), 1, + STATE(429), 1, sym_identifier, - STATE(649), 1, + STATE(651), 1, sym_fntype_attr, - STATE(653), 1, + STATE(684), 1, sym_type, ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, - STATE(426), 2, + STATE(427), 2, sym__inner_type, sym_storage_class, ACTIONS(377), 4, @@ -24009,12 +24070,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_str, anon_sym_bool, anon_sym_void, - STATE(424), 4, + STATE(430), 4, sym_integer_type, sym_floating_type, sym_enum_type, sym_pointer_type, - STATE(427), 9, + STATE(428), 9, sym_scalar_type, sym_struct_type, sym_union_type, @@ -24038,7 +24099,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [4589] = 22, + [4656] = 22, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, @@ -24065,16 +24126,16 @@ static uint16_t ts_small_parse_table[] = { anon_sym_STAR, ACTIONS(414), 1, sym_name, - STATE(428), 1, + STATE(429), 1, sym_identifier, - STATE(649), 1, - sym_fntype_attr, - STATE(681), 1, + STATE(556), 1, sym_type, + STATE(651), 1, + sym_fntype_attr, ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, - STATE(426), 2, + STATE(427), 2, sym__inner_type, sym_storage_class, ACTIONS(377), 4, @@ -24082,12 +24143,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_str, anon_sym_bool, anon_sym_void, - STATE(424), 4, + STATE(430), 4, sym_integer_type, sym_floating_type, sym_enum_type, sym_pointer_type, - STATE(427), 9, + STATE(428), 9, sym_scalar_type, sym_struct_type, sym_union_type, @@ -24111,7 +24172,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [4684] = 22, + [4751] = 22, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, @@ -24138,16 +24199,16 @@ static uint16_t ts_small_parse_table[] = { anon_sym_STAR, ACTIONS(414), 1, sym_name, - STATE(428), 1, + STATE(429), 1, sym_identifier, - STATE(649), 1, + STATE(651), 1, sym_fntype_attr, - STATE(760), 1, + STATE(698), 1, sym_type, ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, - STATE(426), 2, + STATE(427), 2, sym__inner_type, sym_storage_class, ACTIONS(377), 4, @@ -24155,12 +24216,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_str, anon_sym_bool, anon_sym_void, - STATE(424), 4, + STATE(430), 4, sym_integer_type, sym_floating_type, sym_enum_type, sym_pointer_type, - STATE(427), 9, + STATE(428), 9, sym_scalar_type, sym_struct_type, sym_union_type, @@ -24184,65 +24245,6 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [4779] = 8, - ACTIONS(3), 1, - sym_comment, - ACTIONS(403), 1, - anon_sym_e, - STATE(217), 1, - sym_exponent, - STATE(298), 1, - sym_integer_suffix, - ACTIONS(405), 2, - anon_sym_i, - anon_sym_u, - ACTIONS(319), 8, - anon_sym_PIPE, - anon_sym_DOT, - anon_sym_DOT_DOT, - anon_sym_AMP, - anon_sym_SLASH, - anon_sym_CARET, - anon_sym_LT, - anon_sym_GT, - ACTIONS(399), 9, - anon_sym_i8, - anon_sym_i16, - anon_sym_i32, - anon_sym_i64, - anon_sym_u8, - anon_sym_u16, - anon_sym_u32, - anon_sym_u64, - anon_sym_z, - ACTIONS(317), 27, - anon_sym_SEMI, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_STAR, - anon_sym_LBRACK, - anon_sym_RBRACK, - anon_sym_DOT_DOT_DOT, - anon_sym_QMARK, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_as, - anon_sym_is, - anon_sym_PERCENT, - anon_sym_LT_LT, - anon_sym_GT_GT, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_CARET_CARET, - anon_sym_PIPE_PIPE, - anon_sym_else, - anon_sym_EQ_GT, [4846] = 22, ACTIONS(3), 1, sym_comment, @@ -24270,16 +24272,16 @@ static uint16_t ts_small_parse_table[] = { anon_sym_STAR, ACTIONS(414), 1, sym_name, - STATE(428), 1, + STATE(429), 1, sym_identifier, - STATE(549), 1, - sym_type, - STATE(649), 1, + STATE(651), 1, sym_fntype_attr, + STATE(705), 1, + sym_type, ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, - STATE(426), 2, + STATE(427), 2, sym__inner_type, sym_storage_class, ACTIONS(377), 4, @@ -24287,12 +24289,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_str, anon_sym_bool, anon_sym_void, - STATE(424), 4, + STATE(430), 4, sym_integer_type, sym_floating_type, sym_enum_type, sym_pointer_type, - STATE(427), 9, + STATE(428), 9, sym_scalar_type, sym_struct_type, sym_union_type, @@ -24343,16 +24345,16 @@ static uint16_t ts_small_parse_table[] = { anon_sym_STAR, ACTIONS(414), 1, sym_name, - STATE(428), 1, + STATE(429), 1, sym_identifier, - STATE(550), 1, + STATE(618), 1, sym_type, - STATE(649), 1, + STATE(651), 1, sym_fntype_attr, ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, - STATE(426), 2, + STATE(427), 2, sym__inner_type, sym_storage_class, ACTIONS(377), 4, @@ -24360,12 +24362,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_str, anon_sym_bool, anon_sym_void, - STATE(424), 4, + STATE(430), 4, sym_integer_type, sym_floating_type, sym_enum_type, sym_pointer_type, - STATE(427), 9, + STATE(428), 9, sym_scalar_type, sym_struct_type, sym_union_type, @@ -24416,87 +24418,16 @@ static uint16_t ts_small_parse_table[] = { anon_sym_STAR, ACTIONS(414), 1, sym_name, - STATE(428), 1, + STATE(429), 1, sym_identifier, - STATE(629), 1, + STATE(544), 1, sym_type, - STATE(649), 1, - sym_fntype_attr, - ACTIONS(381), 2, - anon_sym_f32, - anon_sym_f64, - STATE(426), 2, - sym__inner_type, - sym_storage_class, - ACTIONS(377), 4, - anon_sym_rune, - anon_sym_str, - anon_sym_bool, - anon_sym_void, - STATE(424), 4, - sym_integer_type, - sym_floating_type, - sym_enum_type, - sym_pointer_type, - STATE(427), 9, - sym_scalar_type, - sym_struct_type, - sym_union_type, - sym_tuple_type, - sym_tagged_union_type, - sym_slice_array_type, - sym_function_type, - sym_alias_type, - sym_unwrapped_alias, - ACTIONS(379), 13, - anon_sym_i8, - anon_sym_i16, - anon_sym_i32, - anon_sym_i64, - anon_sym_u8, - anon_sym_u16, - anon_sym_u32, - anon_sym_u64, - anon_sym_int, - anon_sym_uint, - anon_sym_size, - anon_sym_uintptr, - anon_sym_char, - [5131] = 21, - ACTIONS(3), 1, - sym_comment, - ACTIONS(23), 1, - anon_sym_ATnoreturn, - ACTIONS(371), 1, - anon_sym_const, - ACTIONS(373), 1, - anon_sym_LPAREN, - ACTIONS(375), 1, - anon_sym_fn, - ACTIONS(383), 1, - anon_sym_enum, - ACTIONS(387), 1, - anon_sym_nullable, - ACTIONS(389), 1, - anon_sym_struct, - ACTIONS(391), 1, - anon_sym_union, - ACTIONS(393), 1, - anon_sym_LBRACK, - ACTIONS(395), 1, - anon_sym_DOT_DOT_DOT, - ACTIONS(412), 1, - anon_sym_STAR, - ACTIONS(414), 1, - sym_name, - STATE(428), 1, - sym_identifier, - STATE(649), 1, + STATE(651), 1, sym_fntype_attr, ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, - STATE(452), 2, + STATE(427), 2, sym__inner_type, sym_storage_class, ACTIONS(377), 4, @@ -24504,12 +24435,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_str, anon_sym_bool, anon_sym_void, - STATE(424), 4, + STATE(430), 4, sym_integer_type, sym_floating_type, sym_enum_type, sym_pointer_type, - STATE(427), 9, + STATE(428), 9, sym_scalar_type, sym_struct_type, sym_union_type, @@ -24533,68 +24464,16 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [5223] = 3, + [5131] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(465), 16, - anon_sym_EQ, - anon_sym_COLON, - anon_sym_STAR, - anon_sym_PIPE, - anon_sym_DOT, - anon_sym_DOT_DOT, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_AMP, - anon_sym_SLASH, - anon_sym_PERCENT, - anon_sym_LT_LT, - anon_sym_GT_GT, - anon_sym_CARET, - anon_sym_LT, - anon_sym_GT, - ACTIONS(463), 32, - anon_sym_SEMI, + ACTIONS(467), 1, anon_sym_COLON_COLON, + ACTIONS(469), 1, anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_LBRACK, - anon_sym_RBRACK, - anon_sym_DOT_DOT_DOT, - anon_sym_QMARK, - anon_sym_as, - anon_sym_is, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_CARET_CARET, - anon_sym_PIPE_PIPE, - anon_sym_else, - anon_sym_EQ_GT, - anon_sym_PLUS_EQ, - anon_sym_DASH_EQ, - anon_sym_STAR_EQ, - anon_sym_SLASH_EQ, - anon_sym_PERCENT_EQ, - anon_sym_LT_LT_EQ, - anon_sym_GT_GT_EQ, - anon_sym_AMP_EQ, - anon_sym_PIPE_EQ, - anon_sym_CARET_EQ, - [5279] = 5, - ACTIONS(3), 1, - sym_comment, - ACTIONS(268), 1, - anon_sym_DQUOTE, - STATE(199), 1, - aux_sym_string_constant_repeat1, - ACTIONS(469), 15, + ACTIONS(465), 16, anon_sym_EQ, + anon_sym_COLON, anon_sym_STAR, anon_sym_PIPE, anon_sym_DOT, @@ -24609,11 +24488,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(467), 31, + ACTIONS(463), 30, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, - anon_sym_COLON, anon_sym_LPAREN, anon_sym_RPAREN, anon_sym_LBRACK, @@ -24641,12 +24519,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [5339] = 5, + [5191] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(475), 1, anon_sym_DQUOTE, - STATE(199), 1, + STATE(197), 1, aux_sym_string_constant_repeat1, ACTIONS(473), 15, anon_sym_EQ, @@ -24696,164 +24574,125 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [5399] = 3, + [5251] = 21, ACTIONS(3), 1, sym_comment, - ACTIONS(358), 10, - anon_sym_PIPE, - anon_sym_i, - anon_sym_u, - anon_sym_DOT, - anon_sym_DOT_DOT, - anon_sym_AMP, - anon_sym_SLASH, - anon_sym_CARET, - anon_sym_LT, - anon_sym_GT, - ACTIONS(356), 38, - anon_sym_SEMI, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_COLON, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(371), 1, + anon_sym_const, + ACTIONS(373), 1, anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_i8, - anon_sym_i16, - anon_sym_i32, - anon_sym_i64, - anon_sym_u8, - anon_sym_u16, - anon_sym_u32, - anon_sym_u64, - anon_sym_f32, - anon_sym_f64, - anon_sym_STAR, + ACTIONS(375), 1, + anon_sym_fn, + ACTIONS(383), 1, + anon_sym_enum, + ACTIONS(387), 1, + anon_sym_nullable, + ACTIONS(389), 1, + anon_sym_struct, + ACTIONS(391), 1, + anon_sym_union, + ACTIONS(393), 1, anon_sym_LBRACK, - anon_sym_RBRACK, + ACTIONS(395), 1, anon_sym_DOT_DOT_DOT, - anon_sym_z, - anon_sym_QMARK, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_as, - anon_sym_is, - anon_sym_PERCENT, - anon_sym_LT_LT, - anon_sym_GT_GT, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_CARET_CARET, - anon_sym_PIPE_PIPE, - anon_sym_else, - anon_sym_EQ_GT, - [5455] = 7, - ACTIONS(3), 1, - sym_comment, - ACTIONS(480), 1, - anon_sym_EQ, - ACTIONS(482), 1, - anon_sym_COLON_COLON, - ACTIONS(484), 1, - anon_sym_LBRACE, - ACTIONS(488), 10, - anon_sym_PLUS_EQ, - anon_sym_DASH_EQ, - anon_sym_STAR_EQ, - anon_sym_SLASH_EQ, - anon_sym_PERCENT_EQ, - anon_sym_LT_LT_EQ, - anon_sym_GT_GT_EQ, - anon_sym_AMP_EQ, - anon_sym_PIPE_EQ, - anon_sym_CARET_EQ, - ACTIONS(486), 15, - anon_sym_COLON, + ACTIONS(412), 1, anon_sym_STAR, - anon_sym_PIPE, - anon_sym_DOT, - anon_sym_DOT_DOT, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_AMP, - anon_sym_SLASH, - anon_sym_PERCENT, - anon_sym_LT_LT, - anon_sym_GT_GT, - anon_sym_CARET, - anon_sym_LT, - anon_sym_GT, - ACTIONS(478), 20, - anon_sym_SEMI, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_LBRACK, - anon_sym_RBRACK, - anon_sym_DOT_DOT_DOT, - anon_sym_QMARK, - anon_sym_as, - anon_sym_is, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_CARET_CARET, - anon_sym_PIPE_PIPE, - anon_sym_else, - anon_sym_EQ_GT, - [5519] = 21, + ACTIONS(414), 1, + sym_name, + STATE(429), 1, + sym_identifier, + STATE(651), 1, + sym_fntype_attr, + ACTIONS(381), 2, + anon_sym_f32, + anon_sym_f64, + STATE(455), 2, + sym__inner_type, + sym_storage_class, + ACTIONS(377), 4, + anon_sym_rune, + anon_sym_str, + anon_sym_bool, + anon_sym_void, + STATE(430), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(428), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(379), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [5343] = 21, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, anon_sym_ATnoreturn, - ACTIONS(429), 1, + ACTIONS(371), 1, anon_sym_const, - ACTIONS(431), 1, + ACTIONS(373), 1, anon_sym_LPAREN, - ACTIONS(433), 1, + ACTIONS(375), 1, anon_sym_fn, - ACTIONS(441), 1, + ACTIONS(383), 1, anon_sym_enum, - ACTIONS(443), 1, - anon_sym_STAR, - ACTIONS(445), 1, + ACTIONS(387), 1, anon_sym_nullable, - ACTIONS(447), 1, + ACTIONS(389), 1, anon_sym_struct, - ACTIONS(449), 1, + ACTIONS(391), 1, anon_sym_union, - ACTIONS(451), 1, + ACTIONS(393), 1, anon_sym_LBRACK, - ACTIONS(453), 1, + ACTIONS(395), 1, anon_sym_DOT_DOT_DOT, - ACTIONS(455), 1, + ACTIONS(412), 1, + anon_sym_STAR, + ACTIONS(414), 1, sym_name, - STATE(326), 1, + STATE(429), 1, sym_identifier, - STATE(737), 1, + STATE(651), 1, sym_fntype_attr, - ACTIONS(439), 2, + ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, - STATE(331), 2, + STATE(420), 2, sym__inner_type, sym_storage_class, - ACTIONS(435), 4, + ACTIONS(377), 4, anon_sym_rune, anon_sym_str, anon_sym_bool, anon_sym_void, - STATE(327), 4, + STATE(430), 4, sym_integer_type, sym_floating_type, sym_enum_type, sym_pointer_type, - STATE(342), 9, + STATE(428), 9, sym_scalar_type, sym_struct_type, sym_union_type, @@ -24863,7 +24702,7 @@ static uint16_t ts_small_parse_table[] = { sym_function_type, sym_alias_type, sym_unwrapped_alias, - ACTIONS(437), 13, + ACTIONS(379), 13, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -24877,7 +24716,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [5611] = 21, + [5435] = 21, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, @@ -24904,14 +24743,14 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, ACTIONS(455), 1, sym_name, - STATE(326), 1, + STATE(327), 1, sym_identifier, - STATE(737), 1, + STATE(739), 1, sym_fntype_attr, ACTIONS(439), 2, anon_sym_f32, anon_sym_f64, - STATE(334), 2, + STATE(342), 2, sym__inner_type, sym_storage_class, ACTIONS(435), 4, @@ -24919,12 +24758,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_str, anon_sym_bool, anon_sym_void, - STATE(327), 4, + STATE(329), 4, sym_integer_type, sym_floating_type, sym_enum_type, sym_pointer_type, - STATE(342), 9, + STATE(334), 9, sym_scalar_type, sym_struct_type, sym_union_type, @@ -24948,116 +24787,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [5703] = 5, - ACTIONS(3), 1, - sym_comment, - ACTIONS(490), 1, - anon_sym_COLON_COLON, - ACTIONS(492), 1, - anon_sym_LBRACE, - ACTIONS(486), 16, - anon_sym_EQ, - anon_sym_COLON, - anon_sym_STAR, - anon_sym_PIPE, - anon_sym_DOT, - anon_sym_DOT_DOT, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_AMP, - anon_sym_SLASH, - anon_sym_PERCENT, - anon_sym_LT_LT, - anon_sym_GT_GT, - anon_sym_CARET, - anon_sym_LT, - anon_sym_GT, - ACTIONS(478), 30, - anon_sym_SEMI, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_LBRACK, - anon_sym_RBRACK, - anon_sym_DOT_DOT_DOT, - anon_sym_QMARK, - anon_sym_as, - anon_sym_is, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_CARET_CARET, - anon_sym_PIPE_PIPE, - anon_sym_else, - anon_sym_EQ_GT, - anon_sym_PLUS_EQ, - anon_sym_DASH_EQ, - anon_sym_STAR_EQ, - anon_sym_SLASH_EQ, - anon_sym_PERCENT_EQ, - anon_sym_LT_LT_EQ, - anon_sym_GT_GT_EQ, - anon_sym_AMP_EQ, - anon_sym_PIPE_EQ, - anon_sym_CARET_EQ, - [5763] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(498), 1, - anon_sym_COLON_COLON, - ACTIONS(496), 16, - anon_sym_EQ, - anon_sym_COLON, - anon_sym_STAR, - anon_sym_PIPE, - anon_sym_DOT, - anon_sym_DOT_DOT, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_AMP, - anon_sym_SLASH, - anon_sym_PERCENT, - anon_sym_LT_LT, - anon_sym_GT_GT, - anon_sym_CARET, - anon_sym_LT, - anon_sym_GT, - ACTIONS(494), 31, - anon_sym_SEMI, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_LBRACK, - anon_sym_RBRACK, - anon_sym_DOT_DOT_DOT, - anon_sym_QMARK, - anon_sym_as, - anon_sym_is, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_CARET_CARET, - anon_sym_PIPE_PIPE, - anon_sym_else, - anon_sym_EQ_GT, - anon_sym_PLUS_EQ, - anon_sym_DASH_EQ, - anon_sym_STAR_EQ, - anon_sym_SLASH_EQ, - anon_sym_PERCENT_EQ, - anon_sym_LT_LT_EQ, - anon_sym_GT_GT_EQ, - anon_sym_AMP_EQ, - anon_sym_PIPE_EQ, - anon_sym_CARET_EQ, - [5821] = 21, + [5527] = 21, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, @@ -25084,14 +24814,14 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, ACTIONS(455), 1, sym_name, - STATE(326), 1, + STATE(327), 1, sym_identifier, - STATE(737), 1, + STATE(739), 1, sym_fntype_attr, ACTIONS(439), 2, anon_sym_f32, anon_sym_f64, - STATE(337), 2, + STATE(331), 2, sym__inner_type, sym_storage_class, ACTIONS(435), 4, @@ -25099,12 +24829,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_str, anon_sym_bool, anon_sym_void, - STATE(327), 4, + STATE(329), 4, sym_integer_type, sym_floating_type, sym_enum_type, sym_pointer_type, - STATE(342), 9, + STATE(334), 9, sym_scalar_type, sym_struct_type, sym_union_type, @@ -25128,54 +24858,54 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [5913] = 21, + [5619] = 21, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, anon_sym_ATnoreturn, - ACTIONS(371), 1, + ACTIONS(429), 1, anon_sym_const, - ACTIONS(373), 1, + ACTIONS(431), 1, anon_sym_LPAREN, - ACTIONS(375), 1, + ACTIONS(433), 1, anon_sym_fn, - ACTIONS(383), 1, + ACTIONS(441), 1, anon_sym_enum, - ACTIONS(387), 1, + ACTIONS(443), 1, + anon_sym_STAR, + ACTIONS(445), 1, anon_sym_nullable, - ACTIONS(389), 1, + ACTIONS(447), 1, anon_sym_struct, - ACTIONS(391), 1, + ACTIONS(449), 1, anon_sym_union, - ACTIONS(393), 1, + ACTIONS(451), 1, anon_sym_LBRACK, - ACTIONS(395), 1, + ACTIONS(453), 1, anon_sym_DOT_DOT_DOT, - ACTIONS(412), 1, - anon_sym_STAR, - ACTIONS(414), 1, + ACTIONS(455), 1, sym_name, - STATE(428), 1, + STATE(327), 1, sym_identifier, - STATE(649), 1, + STATE(739), 1, sym_fntype_attr, - ACTIONS(381), 2, + ACTIONS(439), 2, anon_sym_f32, anon_sym_f64, - STATE(447), 2, + STATE(344), 2, sym__inner_type, sym_storage_class, - ACTIONS(377), 4, + ACTIONS(435), 4, anon_sym_rune, anon_sym_str, anon_sym_bool, anon_sym_void, - STATE(424), 4, + STATE(329), 4, sym_integer_type, sym_floating_type, sym_enum_type, sym_pointer_type, - STATE(427), 9, + STATE(334), 9, sym_scalar_type, sym_struct_type, sym_union_type, @@ -25185,7 +24915,7 @@ static uint16_t ts_small_parse_table[] = { sym_function_type, sym_alias_type, sym_unwrapped_alias, - ACTIONS(379), 13, + ACTIONS(437), 13, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -25199,10 +24929,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [6005] = 3, + [5711] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(362), 10, + ACTIONS(358), 10, anon_sym_PIPE, anon_sym_i, anon_sym_u, @@ -25213,7 +24943,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(360), 38, + ACTIONS(356), 38, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -25228,12 +24958,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_u16, anon_sym_u32, anon_sym_u64, + anon_sym_f32, + anon_sym_f64, anon_sym_STAR, anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, - anon_sym_0, - anon_sym_1, anon_sym_z, anon_sym_QMARK, anon_sym_PLUS, @@ -25252,7 +24982,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [6061] = 21, + [5767] = 21, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, @@ -25279,14 +25009,14 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, ACTIONS(455), 1, sym_name, - STATE(326), 1, + STATE(327), 1, sym_identifier, - STATE(737), 1, + STATE(739), 1, sym_fntype_attr, ACTIONS(439), 2, anon_sym_f32, anon_sym_f64, - STATE(329), 2, + STATE(339), 2, sym__inner_type, sym_storage_class, ACTIONS(435), 4, @@ -25294,12 +25024,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_str, anon_sym_bool, anon_sym_void, - STATE(327), 4, + STATE(329), 4, sym_integer_type, sym_floating_type, sym_enum_type, sym_pointer_type, - STATE(342), 9, + STATE(334), 9, sym_scalar_type, sym_struct_type, sym_union_type, @@ -25323,7 +25053,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [6153] = 21, + [5859] = 21, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, @@ -25350,14 +25080,14 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, ACTIONS(455), 1, sym_name, - STATE(326), 1, + STATE(327), 1, sym_identifier, - STATE(737), 1, + STATE(739), 1, sym_fntype_attr, ACTIONS(439), 2, anon_sym_f32, anon_sym_f64, - STATE(339), 2, + STATE(336), 2, sym__inner_type, sym_storage_class, ACTIONS(435), 4, @@ -25365,12 +25095,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_str, anon_sym_bool, anon_sym_void, - STATE(327), 4, + STATE(329), 4, sym_integer_type, sym_floating_type, sym_enum_type, sym_pointer_type, - STATE(342), 9, + STATE(334), 9, sym_scalar_type, sym_struct_type, sym_union_type, @@ -25394,7 +25124,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [6245] = 21, + [5951] = 21, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, @@ -25421,14 +25151,14 @@ static uint16_t ts_small_parse_table[] = { anon_sym_STAR, ACTIONS(414), 1, sym_name, - STATE(428), 1, + STATE(429), 1, sym_identifier, - STATE(649), 1, + STATE(651), 1, sym_fntype_attr, ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, - STATE(418), 2, + STATE(458), 2, sym__inner_type, sym_storage_class, ACTIONS(377), 4, @@ -25436,12 +25166,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_str, anon_sym_bool, anon_sym_void, - STATE(424), 4, + STATE(430), 4, sym_integer_type, sym_floating_type, sym_enum_type, sym_pointer_type, - STATE(427), 9, + STATE(428), 9, sym_scalar_type, sym_struct_type, sym_union_type, @@ -25465,7 +25195,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [6337] = 21, + [6043] = 21, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, @@ -25492,14 +25222,14 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, ACTIONS(455), 1, sym_name, - STATE(326), 1, + STATE(327), 1, sym_identifier, - STATE(737), 1, + STATE(739), 1, sym_fntype_attr, ACTIONS(439), 2, anon_sym_f32, anon_sym_f64, - STATE(323), 2, + STATE(333), 2, sym__inner_type, sym_storage_class, ACTIONS(435), 4, @@ -25507,12 +25237,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_str, anon_sym_bool, anon_sym_void, - STATE(327), 4, + STATE(329), 4, sym_integer_type, sym_floating_type, sym_enum_type, sym_pointer_type, - STATE(342), 9, + STATE(334), 9, sym_scalar_type, sym_struct_type, sym_union_type, @@ -25536,64 +25266,135 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [6429] = 21, + [6135] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(23), 1, - anon_sym_ATnoreturn, - ACTIONS(371), 1, - anon_sym_const, - ACTIONS(373), 1, + ACTIONS(270), 1, + anon_sym_DQUOTE, + STATE(197), 1, + aux_sym_string_constant_repeat1, + ACTIONS(480), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(478), 31, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, anon_sym_LPAREN, - ACTIONS(375), 1, - anon_sym_fn, - ACTIONS(383), 1, - anon_sym_enum, - ACTIONS(387), 1, - anon_sym_nullable, - ACTIONS(389), 1, - anon_sym_struct, - ACTIONS(391), 1, - anon_sym_union, - ACTIONS(393), 1, + anon_sym_RPAREN, anon_sym_LBRACK, - ACTIONS(395), 1, + anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, - ACTIONS(412), 1, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [6195] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(484), 16, + anon_sym_EQ, + anon_sym_COLON, anon_sym_STAR, - ACTIONS(414), 1, - sym_name, - STATE(428), 1, - sym_identifier, - STATE(649), 1, - sym_fntype_attr, - ACTIONS(381), 2, - anon_sym_f32, - anon_sym_f64, - STATE(435), 2, - sym__inner_type, - sym_storage_class, - ACTIONS(377), 4, - anon_sym_rune, - anon_sym_str, - anon_sym_bool, - anon_sym_void, - STATE(424), 4, - sym_integer_type, - sym_floating_type, - sym_enum_type, - sym_pointer_type, - STATE(427), 9, - sym_scalar_type, - sym_struct_type, - sym_union_type, - sym_tuple_type, - sym_tagged_union_type, - sym_slice_array_type, - sym_function_type, - sym_alias_type, - sym_unwrapped_alias, - ACTIONS(379), 13, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(482), 32, + anon_sym_SEMI, + anon_sym_COLON_COLON, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [6251] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(362), 10, + anon_sym_PIPE, + anon_sym_i, + anon_sym_u, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(360), 38, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, anon_sym_i8, anon_sym_i16, anon_sym_i32, @@ -25602,12 +25403,31 @@ static uint16_t ts_small_parse_table[] = { anon_sym_u16, anon_sym_u32, anon_sym_u64, - anon_sym_int, - anon_sym_uint, - anon_sym_size, - anon_sym_uintptr, - anon_sym_char, - [6521] = 21, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_0, + anon_sym_1, + anon_sym_z, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [6307] = 21, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, @@ -25634,14 +25454,14 @@ static uint16_t ts_small_parse_table[] = { anon_sym_STAR, ACTIONS(414), 1, sym_name, - STATE(428), 1, + STATE(429), 1, sym_identifier, - STATE(649), 1, + STATE(651), 1, sym_fntype_attr, ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, - STATE(450), 2, + STATE(442), 2, sym__inner_type, sym_storage_class, ACTIONS(377), 4, @@ -25649,12 +25469,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_str, anon_sym_bool, anon_sym_void, - STATE(424), 4, + STATE(430), 4, sym_integer_type, sym_floating_type, sym_enum_type, sym_pointer_type, - STATE(427), 9, + STATE(428), 9, sym_scalar_type, sym_struct_type, sym_union_type, @@ -25678,20 +25498,20 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [6613] = 7, + [6399] = 7, ACTIONS(3), 1, sym_comment, - ACTIONS(482), 1, + ACTIONS(465), 1, + anon_sym_DOT, + ACTIONS(490), 1, anon_sym_COLON_COLON, - ACTIONS(484), 1, + ACTIONS(492), 1, anon_sym_LBRACE, - ACTIONS(486), 1, - anon_sym_DOT, - ACTIONS(478), 3, + ACTIONS(463), 3, anon_sym_LPAREN, anon_sym_LBRACK, anon_sym_QMARK, - ACTIONS(480), 15, + ACTIONS(488), 15, anon_sym_EQ, anon_sym_COLON, anon_sym_STAR, @@ -25707,7 +25527,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(488), 27, + ACTIONS(486), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -25735,7 +25555,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [6677] = 21, + [6463] = 21, ACTIONS(3), 1, sym_comment, ACTIONS(23), 1, @@ -25762,14 +25582,14 @@ static uint16_t ts_small_parse_table[] = { anon_sym_STAR, ACTIONS(414), 1, sym_name, - STATE(428), 1, + STATE(429), 1, sym_identifier, - STATE(649), 1, + STATE(651), 1, sym_fntype_attr, ACTIONS(381), 2, anon_sym_f32, anon_sym_f64, - STATE(453), 2, + STATE(437), 2, sym__inner_type, sym_storage_class, ACTIONS(377), 4, @@ -25777,12 +25597,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_str, anon_sym_bool, anon_sym_void, - STATE(424), 4, + STATE(430), 4, sym_integer_type, sym_floating_type, sym_enum_type, sym_pointer_type, - STATE(427), 9, + STATE(428), 9, sym_scalar_type, sym_struct_type, sym_union_type, @@ -25806,66 +25626,14 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [6769] = 6, + [6555] = 4, ACTIONS(3), 1, sym_comment, - STATE(320), 1, - sym_integer_suffix, - ACTIONS(405), 2, - anon_sym_i, - anon_sym_u, - ACTIONS(354), 8, - anon_sym_PIPE, - anon_sym_DOT, - anon_sym_DOT_DOT, - anon_sym_AMP, - anon_sym_SLASH, - anon_sym_CARET, - anon_sym_LT, - anon_sym_GT, - ACTIONS(399), 9, - anon_sym_i8, - anon_sym_i16, - anon_sym_i32, - anon_sym_i64, - anon_sym_u8, - anon_sym_u16, - anon_sym_u32, - anon_sym_u64, - anon_sym_z, - ACTIONS(352), 27, - anon_sym_SEMI, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_COLON, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_STAR, - anon_sym_LBRACK, - anon_sym_RBRACK, - anon_sym_DOT_DOT_DOT, - anon_sym_QMARK, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_as, - anon_sym_is, - anon_sym_PERCENT, - anon_sym_LT_LT, - anon_sym_GT_GT, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_CARET_CARET, - anon_sym_PIPE_PIPE, - anon_sym_else, - anon_sym_EQ_GT, - [6830] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(503), 15, + ACTIONS(498), 1, + anon_sym_COLON_COLON, + ACTIONS(496), 16, anon_sym_EQ, + anon_sym_COLON, anon_sym_STAR, anon_sym_PIPE, anon_sym_DOT, @@ -25880,17 +25648,16 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(501), 32, + ACTIONS(494), 31, anon_sym_SEMI, + anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COMMA, - anon_sym_COLON, anon_sym_LPAREN, anon_sym_RPAREN, anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, - anon_sym_DQUOTE, anon_sym_QMARK, anon_sym_as, anon_sym_is, @@ -25913,11 +25680,99 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [6885] = 3, + [6613] = 21, ACTIONS(3), 1, sym_comment, - ACTIONS(507), 15, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(371), 1, + anon_sym_const, + ACTIONS(373), 1, + anon_sym_LPAREN, + ACTIONS(375), 1, + anon_sym_fn, + ACTIONS(383), 1, + anon_sym_enum, + ACTIONS(387), 1, + anon_sym_nullable, + ACTIONS(389), 1, + anon_sym_struct, + ACTIONS(391), 1, + anon_sym_union, + ACTIONS(393), 1, + anon_sym_LBRACK, + ACTIONS(395), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(412), 1, + anon_sym_STAR, + ACTIONS(414), 1, + sym_name, + STATE(429), 1, + sym_identifier, + STATE(651), 1, + sym_fntype_attr, + ACTIONS(381), 2, + anon_sym_f32, + anon_sym_f64, + STATE(438), 2, + sym__inner_type, + sym_storage_class, + ACTIONS(377), 4, + anon_sym_rune, + anon_sym_str, + anon_sym_bool, + anon_sym_void, + STATE(430), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(428), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(379), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [6705] = 7, + ACTIONS(3), 1, + sym_comment, + ACTIONS(488), 1, anon_sym_EQ, + ACTIONS(490), 1, + anon_sym_COLON_COLON, + ACTIONS(492), 1, + anon_sym_LBRACE, + ACTIONS(486), 10, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + ACTIONS(465), 15, + anon_sym_COLON, anon_sym_STAR, anon_sym_PIPE, anon_sym_DOT, @@ -25932,11 +25787,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(505), 31, + ACTIONS(463), 20, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, - anon_sym_COLON, anon_sym_LPAREN, anon_sym_RPAREN, anon_sym_LBRACK, @@ -25954,29 +25808,14 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - anon_sym_PLUS_EQ, - anon_sym_DASH_EQ, - anon_sym_STAR_EQ, - anon_sym_SLASH_EQ, - anon_sym_PERCENT_EQ, - anon_sym_LT_LT_EQ, - anon_sym_GT_GT_EQ, - anon_sym_AMP_EQ, - anon_sym_PIPE_EQ, - anon_sym_CARET_EQ, - [6939] = 5, + [6769] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(511), 1, - anon_sym_DOT, - ACTIONS(509), 3, - anon_sym_LPAREN, - anon_sym_LBRACK, - anon_sym_QMARK, - ACTIONS(480), 14, + ACTIONS(473), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, + anon_sym_DOT, anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, @@ -25988,14 +25827,18 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(488), 28, + ACTIONS(471), 32, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, anon_sym_COLON, + anon_sym_LPAREN, anon_sym_RPAREN, + anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, + anon_sym_DQUOTE, + anon_sym_QMARK, anon_sym_as, anon_sym_is, anon_sym_LT_EQ, @@ -26017,10 +25860,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [6997] = 3, + [6824] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(459), 15, + ACTIONS(503), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -26036,7 +25879,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(457), 31, + ACTIONS(501), 32, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -26046,6 +25889,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, + anon_sym_DQUOTE, anon_sym_QMARK, anon_sym_as, anon_sym_is, @@ -26068,42 +25912,52 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [7051] = 7, + [6879] = 6, ACTIONS(3), 1, sym_comment, - ACTIONS(517), 1, - anon_sym_LPAREN, - ACTIONS(519), 1, - anon_sym_LBRACK, - ACTIONS(521), 1, - anon_sym_DOT, - ACTIONS(523), 1, - anon_sym_QMARK, - ACTIONS(515), 14, - anon_sym_EQ, - anon_sym_STAR, + STATE(322), 1, + sym_integer_suffix, + ACTIONS(405), 2, + anon_sym_i, + anon_sym_u, + ACTIONS(338), 8, anon_sym_PIPE, + anon_sym_DOT, anon_sym_DOT_DOT, - anon_sym_PLUS, - anon_sym_DASH, anon_sym_AMP, anon_sym_SLASH, - anon_sym_PERCENT, - anon_sym_LT_LT, - anon_sym_GT_GT, anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(513), 28, + ACTIONS(399), 9, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_z, + ACTIONS(336), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, anon_sym_COLON, + anon_sym_LPAREN, anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, anon_sym_as, anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, anon_sym_LT_EQ, anon_sym_GT_EQ, anon_sym_EQ_EQ, @@ -26113,20 +25967,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - anon_sym_PLUS_EQ, - anon_sym_DASH_EQ, - anon_sym_STAR_EQ, - anon_sym_SLASH_EQ, - anon_sym_PERCENT_EQ, - anon_sym_LT_LT_EQ, - anon_sym_GT_GT_EQ, - anon_sym_AMP_EQ, - anon_sym_PIPE_EQ, - anon_sym_CARET_EQ, - [7113] = 3, + [6940] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(527), 15, + ACTIONS(507), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -26142,7 +25986,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(525), 31, + ACTIONS(505), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -26174,11 +26018,23 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [7167] = 3, + [6994] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(531), 15, + ACTIONS(488), 1, anon_sym_EQ, + ACTIONS(486), 10, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + ACTIONS(511), 14, anon_sym_STAR, anon_sym_PIPE, anon_sym_DOT, @@ -26193,7 +26049,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(529), 31, + ACTIONS(509), 21, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -26215,20 +26071,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - anon_sym_PLUS_EQ, - anon_sym_DASH_EQ, - anon_sym_STAR_EQ, - anon_sym_SLASH_EQ, - anon_sym_PERCENT_EQ, - anon_sym_LT_LT_EQ, - anon_sym_GT_GT_EQ, - anon_sym_AMP_EQ, - anon_sym_PIPE_EQ, - anon_sym_CARET_EQ, - [7221] = 3, + [7052] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(535), 15, + ACTIONS(515), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -26244,7 +26090,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(533), 31, + ACTIONS(513), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -26276,10 +26122,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [7275] = 3, + [7106] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(539), 15, + ACTIONS(519), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -26295,7 +26141,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(537), 31, + ACTIONS(517), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -26327,26 +26173,94 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [7329] = 3, + [7160] = 20, ACTIONS(3), 1, sym_comment, - ACTIONS(511), 15, - anon_sym_EQ, - anon_sym_STAR, - anon_sym_PIPE, - anon_sym_DOT, - anon_sym_DOT_DOT, - anon_sym_PLUS, - anon_sym_DASH, - anon_sym_AMP, - anon_sym_SLASH, - anon_sym_PERCENT, - anon_sym_LT_LT, - anon_sym_GT_GT, - anon_sym_CARET, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(373), 1, + anon_sym_LPAREN, + ACTIONS(375), 1, + anon_sym_fn, + ACTIONS(383), 1, + anon_sym_enum, + ACTIONS(387), 1, + anon_sym_nullable, + ACTIONS(389), 1, + anon_sym_struct, + ACTIONS(391), 1, + anon_sym_union, + ACTIONS(393), 1, + anon_sym_LBRACK, + ACTIONS(395), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(412), 1, + anon_sym_STAR, + ACTIONS(414), 1, + sym_name, + STATE(419), 1, + sym_storage_class, + STATE(429), 1, + sym_identifier, + STATE(651), 1, + sym_fntype_attr, + ACTIONS(381), 2, + anon_sym_f32, + anon_sym_f64, + ACTIONS(377), 4, + anon_sym_rune, + anon_sym_str, + anon_sym_bool, + anon_sym_void, + STATE(430), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(428), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(379), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [7248] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(523), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(509), 31, + ACTIONS(521), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -26378,10 +26292,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [7383] = 3, + [7302] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(543), 15, + ACTIONS(465), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -26397,7 +26311,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(541), 31, + ACTIONS(463), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -26429,10 +26343,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [7437] = 3, + [7356] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(547), 15, + ACTIONS(459), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -26448,7 +26362,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(545), 31, + ACTIONS(457), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -26480,10 +26394,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [7491] = 3, + [7410] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(551), 15, + ACTIONS(418), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -26499,7 +26413,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(549), 31, + ACTIONS(416), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -26531,10 +26445,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [7545] = 3, + [7464] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(555), 15, + ACTIONS(527), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -26550,7 +26464,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(553), 31, + ACTIONS(525), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -26582,14 +26496,19 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [7599] = 3, + [7518] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(559), 15, + ACTIONS(511), 1, + anon_sym_DOT, + ACTIONS(509), 3, + anon_sym_LPAREN, + anon_sym_LBRACK, + anon_sym_QMARK, + ACTIONS(488), 14, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, - anon_sym_DOT, anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, @@ -26601,17 +26520,14 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(557), 31, + ACTIONS(486), 28, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, anon_sym_COLON, - anon_sym_LPAREN, anon_sym_RPAREN, - anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, - anon_sym_QMARK, anon_sym_as, anon_sym_is, anon_sym_LT_EQ, @@ -26633,10 +26549,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [7653] = 3, + [7576] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(563), 15, + ACTIONS(531), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -26652,7 +26568,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(561), 31, + ACTIONS(529), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -26684,10 +26600,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [7707] = 3, + [7630] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(567), 15, + ACTIONS(535), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -26703,7 +26619,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(565), 31, + ACTIONS(533), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -26735,10 +26651,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [7761] = 3, + [7684] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(571), 15, + ACTIONS(539), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -26754,7 +26670,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(569), 31, + ACTIONS(537), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -26786,10 +26702,78 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [7815] = 3, + [7738] = 20, ACTIONS(3), 1, sym_comment, - ACTIONS(575), 15, + ACTIONS(23), 1, + anon_sym_ATnoreturn, + ACTIONS(431), 1, + anon_sym_LPAREN, + ACTIONS(433), 1, + anon_sym_fn, + ACTIONS(441), 1, + anon_sym_enum, + ACTIONS(443), 1, + anon_sym_STAR, + ACTIONS(445), 1, + anon_sym_nullable, + ACTIONS(447), 1, + anon_sym_struct, + ACTIONS(449), 1, + anon_sym_union, + ACTIONS(451), 1, + anon_sym_LBRACK, + ACTIONS(453), 1, + anon_sym_DOT_DOT_DOT, + ACTIONS(455), 1, + sym_name, + STATE(327), 1, + sym_identifier, + STATE(330), 1, + sym_storage_class, + STATE(739), 1, + sym_fntype_attr, + ACTIONS(439), 2, + anon_sym_f32, + anon_sym_f64, + ACTIONS(435), 4, + anon_sym_rune, + anon_sym_str, + anon_sym_bool, + anon_sym_void, + STATE(329), 4, + sym_integer_type, + sym_floating_type, + sym_enum_type, + sym_pointer_type, + STATE(334), 9, + sym_scalar_type, + sym_struct_type, + sym_union_type, + sym_tuple_type, + sym_tagged_union_type, + sym_slice_array_type, + sym_function_type, + sym_alias_type, + sym_unwrapped_alias, + ACTIONS(437), 13, + anon_sym_i8, + anon_sym_i16, + anon_sym_i32, + anon_sym_i64, + anon_sym_u8, + anon_sym_u16, + anon_sym_u32, + anon_sym_u64, + anon_sym_int, + anon_sym_uint, + anon_sym_size, + anon_sym_uintptr, + anon_sym_char, + [7826] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(543), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -26805,7 +26789,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(573), 31, + ACTIONS(541), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -26837,10 +26821,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [7869] = 3, + [7880] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(579), 15, + ACTIONS(547), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -26856,7 +26840,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(577), 31, + ACTIONS(545), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -26888,10 +26872,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [7923] = 3, + [7934] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(583), 15, + ACTIONS(551), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -26907,7 +26891,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(581), 31, + ACTIONS(549), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -26939,10 +26923,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [7977] = 3, + [7988] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(587), 15, + ACTIONS(555), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -26958,7 +26942,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(585), 31, + ACTIONS(553), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -26990,10 +26974,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [8031] = 3, + [8042] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(591), 15, + ACTIONS(559), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -27009,7 +26993,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(589), 31, + ACTIONS(557), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -27041,10 +27025,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [8085] = 3, + [8096] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(595), 15, + ACTIONS(563), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -27060,7 +27044,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(593), 31, + ACTIONS(561), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -27092,10 +27076,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [8139] = 3, + [8150] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(599), 15, + ACTIONS(567), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -27111,7 +27095,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(597), 31, + ACTIONS(565), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -27143,10 +27127,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [8193] = 3, + [8204] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(603), 15, + ACTIONS(571), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -27162,7 +27146,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(601), 31, + ACTIONS(569), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -27194,10 +27178,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [8247] = 3, + [8258] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(607), 15, + ACTIONS(575), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -27213,7 +27197,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(605), 31, + ACTIONS(573), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -27245,10 +27229,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [8301] = 3, + [8312] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(611), 15, + ACTIONS(579), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -27264,7 +27248,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(609), 31, + ACTIONS(577), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -27296,10 +27280,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [8355] = 3, + [8366] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(486), 15, + ACTIONS(583), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -27315,7 +27299,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(478), 31, + ACTIONS(581), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -27347,10 +27331,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [8409] = 3, + [8420] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(422), 15, + ACTIONS(587), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -27366,7 +27350,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(420), 31, + ACTIONS(585), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -27398,10 +27382,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [8463] = 3, + [8474] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(615), 15, + ACTIONS(591), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -27417,7 +27401,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(613), 31, + ACTIONS(589), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -27449,10 +27433,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [8517] = 3, + [8528] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(619), 15, + ACTIONS(595), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -27468,7 +27452,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(617), 31, + ACTIONS(593), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -27500,10 +27484,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [8571] = 3, + [8582] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(623), 15, + ACTIONS(599), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -27519,7 +27503,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(621), 31, + ACTIONS(597), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -27551,10 +27535,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [8625] = 3, + [8636] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(627), 15, + ACTIONS(603), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -27570,7 +27554,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(625), 31, + ACTIONS(601), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -27602,10 +27586,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [8679] = 3, + [8690] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(631), 15, + ACTIONS(607), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -27621,7 +27605,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(629), 31, + ACTIONS(605), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -27653,23 +27637,11 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [8733] = 5, + [8744] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(480), 1, + ACTIONS(338), 15, anon_sym_EQ, - ACTIONS(488), 10, - anon_sym_PLUS_EQ, - anon_sym_DASH_EQ, - anon_sym_STAR_EQ, - anon_sym_SLASH_EQ, - anon_sym_PERCENT_EQ, - anon_sym_LT_LT_EQ, - anon_sym_GT_GT_EQ, - anon_sym_AMP_EQ, - anon_sym_PIPE_EQ, - anon_sym_CARET_EQ, - ACTIONS(511), 14, anon_sym_STAR, anon_sym_PIPE, anon_sym_DOT, @@ -27684,7 +27656,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(509), 21, + ACTIONS(336), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -27706,15 +27678,25 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [8791] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(635), 15, - anon_sym_EQ, - anon_sym_STAR, - anon_sym_PIPE, - anon_sym_DOT, - anon_sym_DOT_DOT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [8798] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(611), 15, + anon_sym_EQ, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, anon_sym_AMP, @@ -27725,7 +27707,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(633), 31, + ACTIONS(609), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -27757,10 +27739,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [8845] = 3, + [8852] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(639), 15, + ACTIONS(615), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -27776,7 +27758,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(637), 31, + ACTIONS(613), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -27808,10 +27790,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [8899] = 3, + [8906] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(643), 15, + ACTIONS(511), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -27827,7 +27809,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(641), 31, + ACTIONS(509), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -27859,10 +27841,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [8953] = 3, + [8960] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(647), 15, + ACTIONS(619), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -27878,7 +27860,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(645), 31, + ACTIONS(617), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -27910,14 +27892,21 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [9007] = 3, + [9014] = 7, ACTIONS(3), 1, sym_comment, - ACTIONS(354), 15, + ACTIONS(625), 1, + anon_sym_LPAREN, + ACTIONS(627), 1, + anon_sym_LBRACK, + ACTIONS(629), 1, + anon_sym_DOT, + ACTIONS(631), 1, + anon_sym_QMARK, + ACTIONS(623), 14, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, - anon_sym_DOT, anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, @@ -27929,17 +27918,14 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(352), 31, + ACTIONS(621), 28, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, anon_sym_COLON, - anon_sym_LPAREN, anon_sym_RPAREN, - anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, - anon_sym_QMARK, anon_sym_as, anon_sym_is, anon_sym_LT_EQ, @@ -27961,78 +27947,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [9061] = 20, - ACTIONS(3), 1, - sym_comment, - ACTIONS(23), 1, - anon_sym_ATnoreturn, - ACTIONS(373), 1, - anon_sym_LPAREN, - ACTIONS(375), 1, - anon_sym_fn, - ACTIONS(383), 1, - anon_sym_enum, - ACTIONS(387), 1, - anon_sym_nullable, - ACTIONS(389), 1, - anon_sym_struct, - ACTIONS(391), 1, - anon_sym_union, - ACTIONS(393), 1, - anon_sym_LBRACK, - ACTIONS(395), 1, - anon_sym_DOT_DOT_DOT, - ACTIONS(412), 1, - anon_sym_STAR, - ACTIONS(414), 1, - sym_name, - STATE(428), 1, - sym_identifier, - STATE(432), 1, - sym_storage_class, - STATE(649), 1, - sym_fntype_attr, - ACTIONS(381), 2, - anon_sym_f32, - anon_sym_f64, - ACTIONS(377), 4, - anon_sym_rune, - anon_sym_str, - anon_sym_bool, - anon_sym_void, - STATE(424), 4, - sym_integer_type, - sym_floating_type, - sym_enum_type, - sym_pointer_type, - STATE(427), 9, - sym_scalar_type, - sym_struct_type, - sym_union_type, - sym_tuple_type, - sym_tagged_union_type, - sym_slice_array_type, - sym_function_type, - sym_alias_type, - sym_unwrapped_alias, - ACTIONS(379), 13, - anon_sym_i8, - anon_sym_i16, - anon_sym_i32, - anon_sym_i64, - anon_sym_u8, - anon_sym_u16, - anon_sym_u32, - anon_sym_u64, - anon_sym_int, - anon_sym_uint, - anon_sym_size, - anon_sym_uintptr, - anon_sym_char, - [9149] = 3, + [9076] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(651), 15, + ACTIONS(635), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -28048,7 +27966,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(649), 31, + ACTIONS(633), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -28080,78 +27998,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [9203] = 20, - ACTIONS(3), 1, - sym_comment, - ACTIONS(23), 1, - anon_sym_ATnoreturn, - ACTIONS(431), 1, - anon_sym_LPAREN, - ACTIONS(433), 1, - anon_sym_fn, - ACTIONS(441), 1, - anon_sym_enum, - ACTIONS(443), 1, - anon_sym_STAR, - ACTIONS(445), 1, - anon_sym_nullable, - ACTIONS(447), 1, - anon_sym_struct, - ACTIONS(449), 1, - anon_sym_union, - ACTIONS(451), 1, - anon_sym_LBRACK, - ACTIONS(453), 1, - anon_sym_DOT_DOT_DOT, - ACTIONS(455), 1, - sym_name, - STATE(326), 1, - sym_identifier, - STATE(345), 1, - sym_storage_class, - STATE(737), 1, - sym_fntype_attr, - ACTIONS(439), 2, - anon_sym_f32, - anon_sym_f64, - ACTIONS(435), 4, - anon_sym_rune, - anon_sym_str, - anon_sym_bool, - anon_sym_void, - STATE(327), 4, - sym_integer_type, - sym_floating_type, - sym_enum_type, - sym_pointer_type, - STATE(342), 9, - sym_scalar_type, - sym_struct_type, - sym_union_type, - sym_tuple_type, - sym_tagged_union_type, - sym_slice_array_type, - sym_function_type, - sym_alias_type, - sym_unwrapped_alias, - ACTIONS(437), 13, - anon_sym_i8, - anon_sym_i16, - anon_sym_i32, - anon_sym_i64, - anon_sym_u8, - anon_sym_u16, - anon_sym_u32, - anon_sym_u64, - anon_sym_int, - anon_sym_uint, - anon_sym_size, - anon_sym_uintptr, - anon_sym_char, - [9291] = 3, + [9130] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(655), 15, + ACTIONS(639), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, @@ -28167,7 +28017,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(653), 31, + ACTIONS(637), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -28199,27 +28049,14 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [9345] = 6, + [9184] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(659), 1, + ACTIONS(643), 15, anon_sym_EQ, - STATE(44), 1, - sym_assignment_op, - ACTIONS(663), 10, - anon_sym_PLUS_EQ, - anon_sym_DASH_EQ, - anon_sym_STAR_EQ, - anon_sym_SLASH_EQ, - anon_sym_PERCENT_EQ, - anon_sym_LT_LT_EQ, - anon_sym_GT_GT_EQ, - anon_sym_AMP_EQ, - anon_sym_PIPE_EQ, - anon_sym_CARET_EQ, - ACTIONS(661), 13, anon_sym_STAR, anon_sym_PIPE, + anon_sym_DOT, anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, @@ -28231,14 +28068,17 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(657), 18, + ACTIONS(641), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, anon_sym_COLON, + anon_sym_LPAREN, anon_sym_RPAREN, + anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, anon_sym_as, anon_sym_is, anon_sym_LT_EQ, @@ -28250,13 +28090,24 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [9402] = 3, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [9238] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(667), 14, + ACTIONS(647), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, + anon_sym_DOT, anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, @@ -28268,14 +28119,17 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(665), 28, + ACTIONS(645), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, anon_sym_COLON, + anon_sym_LPAREN, anon_sym_RPAREN, + anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, anon_sym_as, anon_sym_is, anon_sym_LT_EQ, @@ -28297,27 +28151,14 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [9452] = 6, + [9292] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(659), 1, + ACTIONS(651), 15, anon_sym_EQ, - STATE(51), 1, - sym_assignment_op, - ACTIONS(663), 10, - anon_sym_PLUS_EQ, - anon_sym_DASH_EQ, - anon_sym_STAR_EQ, - anon_sym_SLASH_EQ, - anon_sym_PERCENT_EQ, - anon_sym_LT_LT_EQ, - anon_sym_GT_GT_EQ, - anon_sym_AMP_EQ, - anon_sym_PIPE_EQ, - anon_sym_CARET_EQ, - ACTIONS(661), 13, anon_sym_STAR, anon_sym_PIPE, + anon_sym_DOT, anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, @@ -28329,14 +28170,17 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(657), 17, + ACTIONS(649), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, anon_sym_COLON, + anon_sym_LPAREN, anon_sym_RPAREN, + anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, anon_sym_as, anon_sym_is, anon_sym_LT_EQ, @@ -28346,14 +28190,26 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_AMP, anon_sym_CARET_CARET, anon_sym_PIPE_PIPE, + anon_sym_else, anon_sym_EQ_GT, - [9508] = 3, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [9346] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(661), 14, + ACTIONS(655), 15, anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, + anon_sym_DOT, anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, @@ -28365,14 +28221,17 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(657), 28, + ACTIONS(653), 31, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, anon_sym_COLON, + anon_sym_LPAREN, anon_sym_RPAREN, + anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, anon_sym_as, anon_sym_is, anon_sym_LT_EQ, @@ -28394,46 +28253,48 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [9558] = 7, + [9400] = 6, ACTIONS(3), 1, sym_comment, - ACTIONS(403), 1, - anon_sym_e, - STATE(270), 1, - sym_exponent, - STATE(283), 1, - sym_floating_suffix, - ACTIONS(401), 2, - anon_sym_f32, - anon_sym_f64, - ACTIONS(422), 8, + ACTIONS(659), 1, + anon_sym_EQ, + STATE(44), 1, + sym_assignment_op, + ACTIONS(663), 10, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + ACTIONS(661), 13, + anon_sym_STAR, anon_sym_PIPE, - anon_sym_DOT, anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, anon_sym_AMP, anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(420), 27, + ACTIONS(657), 18, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, anon_sym_COLON, - anon_sym_LPAREN, anon_sym_RPAREN, - anon_sym_STAR, - anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, - anon_sym_QMARK, - anon_sym_PLUS, - anon_sym_DASH, anon_sym_as, anon_sym_is, - anon_sym_PERCENT, - anon_sym_LT_LT, - anon_sym_GT_GT, anon_sym_LT_EQ, anon_sym_GT_EQ, anon_sym_EQ_EQ, @@ -28443,14 +28304,43 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [9614] = 6, + [9457] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(659), 1, + ACTIONS(661), 14, anon_sym_EQ, - STATE(98), 1, - sym_assignment_op, - ACTIONS(663), 10, + anon_sym_STAR, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(657), 28, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_as, + anon_sym_is, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, anon_sym_PLUS_EQ, anon_sym_DASH_EQ, anon_sym_STAR_EQ, @@ -28461,9 +28351,14 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - ACTIONS(661), 12, + [9507] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(667), 14, + anon_sym_EQ, anon_sym_STAR, anon_sym_PIPE, + anon_sym_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, anon_sym_AMP, @@ -28474,12 +28369,14 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(657), 15, + ACTIONS(665), 28, anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, anon_sym_COLON, anon_sym_RPAREN, anon_sym_RBRACK, - anon_sym_DOT_DOT, + anon_sym_DOT_DOT_DOT, anon_sym_as, anon_sym_is, anon_sym_LT_EQ, @@ -28490,40 +28387,59 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET_CARET, anon_sym_PIPE_PIPE, anon_sym_else, - [9667] = 3, + anon_sym_EQ_GT, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [9557] = 6, ACTIONS(3), 1, sym_comment, - ACTIONS(465), 10, - anon_sym_COLON, - anon_sym_BANG, + ACTIONS(659), 1, + anon_sym_EQ, + STATE(52), 1, + sym_assignment_op, + ACTIONS(663), 10, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + ACTIONS(661), 13, + anon_sym_STAR, anon_sym_PIPE, - anon_sym_DOT, anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, anon_sym_AMP, anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(463), 28, + ACTIONS(657), 17, anon_sym_SEMI, - anon_sym_COLON_COLON, - anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COMMA, - anon_sym_LPAREN, + anon_sym_COLON, anon_sym_RPAREN, - anon_sym_STAR, - anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, - anon_sym_QMARK, - anon_sym_PLUS, - anon_sym_DASH, anon_sym_as, anon_sym_is, - anon_sym_PERCENT, - anon_sym_LT_LT, - anon_sym_GT_GT, anon_sym_LT_EQ, anon_sym_GT_EQ, anon_sym_EQ_EQ, @@ -28531,17 +28447,20 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_AMP, anon_sym_CARET_CARET, anon_sym_PIPE_PIPE, - anon_sym_else, anon_sym_EQ_GT, - [9713] = 5, + [9613] = 7, ACTIONS(3), 1, sym_comment, - STATE(311), 1, + ACTIONS(403), 1, + anon_sym_e, + STATE(270), 1, + sym_exponent, + STATE(285), 1, sym_floating_suffix, ACTIONS(401), 2, anon_sym_f32, anon_sym_f64, - ACTIONS(459), 8, + ACTIONS(418), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -28550,7 +28469,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(457), 27, + ACTIONS(416), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -28578,12 +28497,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [9763] = 6, + [9669] = 6, ACTIONS(3), 1, sym_comment, ACTIONS(659), 1, anon_sym_EQ, - STATE(76), 1, + STATE(102), 1, sym_assignment_op, ACTIONS(663), 10, anon_sym_PLUS_EQ, @@ -28609,7 +28528,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(657), 14, + ACTIONS(657), 15, anon_sym_SEMI, anon_sym_COLON, anon_sym_RPAREN, @@ -28624,14 +28543,16 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_AMP, anon_sym_CARET_CARET, anon_sym_PIPE_PIPE, - [9815] = 5, + anon_sym_else, + [9722] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(59), 1, - anon_sym_DQUOTE, - STATE(275), 1, - aux_sym_string_constant_repeat1, - ACTIONS(469), 8, + STATE(314), 1, + sym_floating_suffix, + ACTIONS(401), 2, + anon_sym_f32, + anon_sym_f64, + ACTIONS(459), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -28640,7 +28561,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(467), 27, + ACTIONS(457), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -28668,13 +28589,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [9864] = 4, + [9772] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(669), 1, - anon_sym_COLON_COLON, - ACTIONS(496), 9, + ACTIONS(484), 10, anon_sym_COLON, + anon_sym_BANG, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -28683,8 +28603,9 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(494), 27, + ACTIONS(482), 28, anon_sym_SEMI, + anon_sym_COLON_COLON, anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COMMA, @@ -28711,41 +28632,45 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [9911] = 5, + [9818] = 6, ACTIONS(3), 1, sym_comment, - ACTIONS(482), 1, - anon_sym_COLON_COLON, - ACTIONS(484), 1, - anon_sym_LBRACE, - ACTIONS(486), 9, - anon_sym_COLON, + ACTIONS(659), 1, + anon_sym_EQ, + STATE(46), 1, + sym_assignment_op, + ACTIONS(663), 10, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + ACTIONS(661), 12, + anon_sym_STAR, anon_sym_PIPE, - anon_sym_DOT, - anon_sym_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, anon_sym_AMP, anon_sym_SLASH, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(478), 26, + ACTIONS(657), 14, anon_sym_SEMI, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_LPAREN, + anon_sym_COLON, anon_sym_RPAREN, - anon_sym_STAR, - anon_sym_LBRACK, anon_sym_RBRACK, - anon_sym_DOT_DOT_DOT, - anon_sym_QMARK, - anon_sym_PLUS, - anon_sym_DASH, + anon_sym_DOT_DOT, anon_sym_as, anon_sym_is, - anon_sym_PERCENT, - anon_sym_LT_LT, - anon_sym_GT_GT, anon_sym_LT_EQ, anon_sym_GT_EQ, anon_sym_EQ_EQ, @@ -28753,36 +28678,36 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_AMP, anon_sym_CARET_CARET, anon_sym_PIPE_PIPE, - anon_sym_else, - anon_sym_EQ_GT, - [9960] = 5, + [9870] = 7, ACTIONS(3), 1, sym_comment, - ACTIONS(672), 1, - anon_sym_DQUOTE, - STATE(275), 1, - aux_sym_string_constant_repeat1, - ACTIONS(473), 8, - anon_sym_PIPE, + ACTIONS(465), 1, anon_sym_DOT, + ACTIONS(490), 1, + anon_sym_COLON_COLON, + ACTIONS(492), 1, + anon_sym_LBRACE, + ACTIONS(463), 3, + anon_sym_LPAREN, + anon_sym_LBRACK, + anon_sym_QMARK, + ACTIONS(488), 8, + anon_sym_COLON, + anon_sym_PIPE, anon_sym_DOT_DOT, anon_sym_AMP, anon_sym_SLASH, anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(471), 27, + ACTIONS(486), 23, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, - anon_sym_COLON, - anon_sym_LPAREN, anon_sym_RPAREN, anon_sym_STAR, - anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, - anon_sym_QMARK, anon_sym_PLUS, anon_sym_DASH, anon_sym_as, @@ -28799,36 +28724,34 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [10009] = 7, + [9923] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(482), 1, + ACTIONS(490), 1, anon_sym_COLON_COLON, - ACTIONS(484), 1, + ACTIONS(492), 1, anon_sym_LBRACE, - ACTIONS(486), 1, - anon_sym_DOT, - ACTIONS(478), 3, - anon_sym_LPAREN, - anon_sym_LBRACK, - anon_sym_QMARK, - ACTIONS(480), 8, + ACTIONS(465), 9, anon_sym_COLON, anon_sym_PIPE, + anon_sym_DOT, anon_sym_DOT_DOT, anon_sym_AMP, anon_sym_SLASH, anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(488), 23, + ACTIONS(463), 26, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, + anon_sym_LPAREN, anon_sym_RPAREN, anon_sym_STAR, + anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, anon_sym_PLUS, anon_sym_DASH, anon_sym_as, @@ -28845,10 +28768,13 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [10062] = 3, + [9972] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(503), 8, + ACTIONS(669), 1, + anon_sym_COLON_COLON, + ACTIONS(496), 9, + anon_sym_COLON, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -28857,18 +28783,17 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(501), 28, + ACTIONS(494), 27, anon_sym_SEMI, + anon_sym_LBRACE, anon_sym_RBRACE, anon_sym_COMMA, - anon_sym_COLON, anon_sym_LPAREN, anon_sym_RPAREN, anon_sym_STAR, anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, - anon_sym_DQUOTE, anon_sym_QMARK, anon_sym_PLUS, anon_sym_DASH, @@ -28886,12 +28811,14 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [10106] = 4, + [10019] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(675), 1, - anon_sym_EQ, - ACTIONS(511), 8, + ACTIONS(59), 1, + anon_sym_DQUOTE, + STATE(277), 1, + aux_sym_string_constant_repeat1, + ACTIONS(480), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -28900,7 +28827,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(509), 27, + ACTIONS(478), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -28928,11 +28855,14 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [10152] = 3, + [10068] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(599), 9, - anon_sym_EQ, + ACTIONS(672), 1, + anon_sym_DQUOTE, + STATE(277), 1, + aux_sym_string_constant_repeat1, + ACTIONS(473), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -28941,7 +28871,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(597), 27, + ACTIONS(471), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -28969,11 +28899,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [10196] = 3, + [10117] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(579), 9, - anon_sym_EQ, + ACTIONS(473), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -28982,7 +28911,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(577), 27, + ACTIONS(471), 28, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -28993,6 +28922,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, + anon_sym_DQUOTE, anon_sym_QMARK, anon_sym_PLUS, anon_sym_DASH, @@ -29010,10 +28940,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [10240] = 3, + [10161] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(527), 9, + ACTIONS(555), 9, anon_sym_EQ, anon_sym_PIPE, anon_sym_DOT, @@ -29023,7 +28953,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(525), 27, + ACTIONS(553), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -29051,10 +28981,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [10284] = 3, + [10205] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(547), 8, + ACTIONS(503), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -29063,7 +28993,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(545), 27, + ACTIONS(501), 28, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -29074,6 +29004,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, + anon_sym_DQUOTE, anon_sym_QMARK, anon_sym_PLUS, anon_sym_DASH, @@ -29091,10 +29022,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [10327] = 3, + [10249] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(459), 8, + ACTIONS(675), 1, + anon_sym_EQ, + ACTIONS(511), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -29103,7 +29036,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(457), 27, + ACTIONS(509), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -29131,10 +29064,11 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [10370] = 3, + [10295] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(531), 8, + ACTIONS(587), 9, + anon_sym_EQ, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -29143,7 +29077,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(529), 27, + ACTIONS(585), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -29171,10 +29105,11 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [10413] = 3, + [10339] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(655), 8, + ACTIONS(519), 9, + anon_sym_EQ, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -29183,7 +29118,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(653), 27, + ACTIONS(517), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -29211,12 +29146,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [10456] = 4, + [10383] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(677), 1, - anon_sym_EQ, - ACTIONS(511), 8, + ACTIONS(571), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -29225,7 +29158,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(509), 26, + ACTIONS(569), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -29251,11 +29184,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_AMP, anon_sym_CARET_CARET, anon_sym_PIPE_PIPE, + anon_sym_else, anon_sym_EQ_GT, - [10501] = 3, + [10426] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(571), 8, + ACTIONS(459), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -29264,7 +29198,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(569), 27, + ACTIONS(457), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -29292,10 +29226,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [10544] = 3, + [10469] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(627), 8, + ACTIONS(639), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -29304,7 +29238,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(625), 27, + ACTIONS(637), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -29332,34 +29266,30 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [10587] = 7, + [10512] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(521), 1, - anon_sym_DOT, - ACTIONS(679), 1, - anon_sym_LPAREN, - ACTIONS(681), 1, - anon_sym_LBRACK, - ACTIONS(683), 1, - anon_sym_QMARK, - ACTIONS(515), 7, + ACTIONS(647), 8, anon_sym_PIPE, + anon_sym_DOT, anon_sym_DOT_DOT, anon_sym_AMP, anon_sym_SLASH, anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(513), 24, + ACTIONS(645), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, anon_sym_COLON, + anon_sym_LPAREN, anon_sym_RPAREN, anon_sym_STAR, + anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, anon_sym_PLUS, anon_sym_DASH, anon_sym_as, @@ -29376,10 +29306,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [10638] = 3, + [10555] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(551), 8, + ACTIONS(677), 1, + anon_sym_EQ, + ACTIONS(511), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -29388,7 +29320,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(549), 27, + ACTIONS(509), 26, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -29414,12 +29346,11 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_AMP, anon_sym_CARET_CARET, anon_sym_PIPE_PIPE, - anon_sym_else, anon_sym_EQ_GT, - [10681] = 3, + [10600] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(591), 8, + ACTIONS(611), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -29428,7 +29359,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(589), 27, + ACTIONS(609), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -29456,10 +29387,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [10724] = 3, + [10643] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(563), 8, + ACTIONS(635), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -29468,7 +29399,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(561), 27, + ACTIONS(633), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -29496,30 +29427,34 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [10767] = 3, + [10686] = 7, ACTIONS(3), 1, sym_comment, - ACTIONS(651), 8, - anon_sym_PIPE, + ACTIONS(629), 1, anon_sym_DOT, + ACTIONS(679), 1, + anon_sym_LPAREN, + ACTIONS(681), 1, + anon_sym_LBRACK, + ACTIONS(683), 1, + anon_sym_QMARK, + ACTIONS(623), 7, + anon_sym_PIPE, anon_sym_DOT_DOT, anon_sym_AMP, anon_sym_SLASH, anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(649), 27, + ACTIONS(621), 24, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, anon_sym_COLON, - anon_sym_LPAREN, anon_sym_RPAREN, anon_sym_STAR, - anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, - anon_sym_QMARK, anon_sym_PLUS, anon_sym_DASH, anon_sym_as, @@ -29536,10 +29471,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [10810] = 3, + [10737] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(543), 8, + ACTIONS(655), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -29548,7 +29483,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(541), 27, + ACTIONS(653), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -29576,10 +29511,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [10853] = 3, + [10780] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(507), 8, + ACTIONS(539), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -29588,7 +29523,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(505), 27, + ACTIONS(537), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -29616,10 +29551,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [10896] = 3, + [10823] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(607), 8, + ACTIONS(543), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -29628,7 +29563,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(605), 27, + ACTIONS(541), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -29656,10 +29591,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [10939] = 3, + [10866] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(422), 8, + ACTIONS(599), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -29668,7 +29603,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(420), 27, + ACTIONS(597), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -29696,10 +29631,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [10982] = 3, + [10909] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(354), 8, + ACTIONS(338), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -29708,7 +29643,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(352), 27, + ACTIONS(336), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -29736,10 +29671,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11025] = 3, + [10952] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(647), 8, + ACTIONS(531), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -29748,7 +29683,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(645), 27, + ACTIONS(529), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -29776,10 +29711,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11068] = 3, + [10995] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(539), 8, + ACTIONS(527), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -29788,7 +29723,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(537), 27, + ACTIONS(525), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -29816,10 +29751,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11111] = 3, + [11038] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(486), 8, + ACTIONS(515), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -29828,7 +29763,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(478), 27, + ACTIONS(513), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -29856,10 +29791,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11154] = 3, + [11081] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(595), 8, + ACTIONS(418), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -29868,7 +29803,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(593), 27, + ACTIONS(416), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -29896,10 +29831,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11197] = 3, + [11124] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(511), 8, + ACTIONS(607), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -29908,7 +29843,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(509), 27, + ACTIONS(605), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -29936,10 +29871,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11240] = 3, + [11167] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(535), 8, + ACTIONS(651), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -29948,7 +29883,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(533), 27, + ACTIONS(649), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -29976,34 +29911,30 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11283] = 7, + [11210] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(679), 1, - anon_sym_LPAREN, - ACTIONS(683), 1, - anon_sym_QMARK, - ACTIONS(685), 1, - anon_sym_LBRACK, - ACTIONS(687), 1, - anon_sym_DOT, - ACTIONS(515), 7, + ACTIONS(465), 8, anon_sym_PIPE, + anon_sym_DOT, anon_sym_DOT_DOT, anon_sym_AMP, anon_sym_SLASH, anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(513), 24, + ACTIONS(463), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, anon_sym_COLON, + anon_sym_LPAREN, anon_sym_RPAREN, anon_sym_STAR, + anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, anon_sym_PLUS, anon_sym_DASH, anon_sym_as, @@ -30020,10 +29951,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11334] = 3, + [11253] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(623), 8, + ACTIONS(615), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -30032,7 +29963,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(621), 27, + ACTIONS(613), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -30060,10 +29991,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11377] = 3, + [11296] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(615), 8, + ACTIONS(511), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -30072,7 +30003,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(613), 27, + ACTIONS(509), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -30100,10 +30031,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11420] = 3, + [11339] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(555), 8, + ACTIONS(619), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -30112,7 +30043,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(553), 27, + ACTIONS(617), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -30140,30 +30071,34 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11463] = 3, + [11382] = 7, ACTIONS(3), 1, sym_comment, - ACTIONS(559), 8, - anon_sym_PIPE, + ACTIONS(679), 1, + anon_sym_LPAREN, + ACTIONS(683), 1, + anon_sym_QMARK, + ACTIONS(685), 1, + anon_sym_LBRACK, + ACTIONS(687), 1, anon_sym_DOT, + ACTIONS(623), 7, + anon_sym_PIPE, anon_sym_DOT_DOT, anon_sym_AMP, anon_sym_SLASH, anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(557), 27, + ACTIONS(621), 24, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, anon_sym_COLON, - anon_sym_LPAREN, anon_sym_RPAREN, anon_sym_STAR, - anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, - anon_sym_QMARK, anon_sym_PLUS, anon_sym_DASH, anon_sym_as, @@ -30180,10 +30115,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11506] = 3, + [11433] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(567), 8, + ACTIONS(523), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -30192,7 +30127,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(565), 27, + ACTIONS(521), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -30220,10 +30155,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11549] = 3, + [11476] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(575), 8, + ACTIONS(551), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -30232,7 +30167,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(573), 27, + ACTIONS(549), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -30260,10 +30195,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11592] = 3, + [11519] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(643), 8, + ACTIONS(603), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -30272,7 +30207,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(641), 27, + ACTIONS(601), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -30300,32 +30235,30 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11635] = 5, + [11562] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(511), 1, - anon_sym_DOT, - ACTIONS(509), 3, - anon_sym_LPAREN, - anon_sym_LBRACK, - anon_sym_QMARK, - ACTIONS(480), 7, + ACTIONS(595), 8, anon_sym_PIPE, + anon_sym_DOT, anon_sym_DOT_DOT, anon_sym_AMP, anon_sym_SLASH, anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(488), 24, + ACTIONS(593), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, anon_sym_COLON, + anon_sym_LPAREN, anon_sym_RPAREN, anon_sym_STAR, + anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, anon_sym_PLUS, anon_sym_DASH, anon_sym_as, @@ -30342,10 +30275,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11682] = 3, + [11605] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(583), 8, + ACTIONS(643), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -30354,7 +30287,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(581), 27, + ACTIONS(641), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -30382,10 +30315,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11725] = 3, + [11648] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(619), 8, + ACTIONS(575), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -30394,7 +30327,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(617), 27, + ACTIONS(573), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -30422,10 +30355,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11768] = 3, + [11691] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(587), 8, + ACTIONS(559), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -30434,7 +30367,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(585), 27, + ACTIONS(557), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -30462,30 +30395,32 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11811] = 3, + [11734] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(639), 8, - anon_sym_PIPE, + ACTIONS(511), 1, anon_sym_DOT, + ACTIONS(509), 3, + anon_sym_LPAREN, + anon_sym_LBRACK, + anon_sym_QMARK, + ACTIONS(488), 7, + anon_sym_PIPE, anon_sym_DOT_DOT, anon_sym_AMP, anon_sym_SLASH, anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(637), 27, + ACTIONS(486), 24, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, anon_sym_COLON, - anon_sym_LPAREN, anon_sym_RPAREN, anon_sym_STAR, - anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, - anon_sym_QMARK, anon_sym_PLUS, anon_sym_DASH, anon_sym_as, @@ -30502,10 +30437,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11854] = 3, + [11781] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(603), 8, + ACTIONS(507), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -30514,7 +30449,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(601), 27, + ACTIONS(505), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -30542,10 +30477,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11897] = 3, + [11824] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(611), 8, + ACTIONS(567), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -30554,7 +30489,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(609), 27, + ACTIONS(565), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -30582,10 +30517,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11940] = 3, + [11867] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(631), 8, + ACTIONS(591), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -30594,7 +30529,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(629), 27, + ACTIONS(589), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -30622,10 +30557,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [11983] = 3, + [11910] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(635), 8, + ACTIONS(563), 8, anon_sym_PIPE, anon_sym_DOT, anon_sym_DOT_DOT, @@ -30634,7 +30569,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(633), 27, + ACTIONS(561), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -30662,29 +30597,30 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12026] = 4, + [11953] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(689), 1, - anon_sym_COLON_COLON, - ACTIONS(496), 9, - anon_sym_COLON, - anon_sym_BANG, + ACTIONS(547), 8, anon_sym_PIPE, + anon_sym_DOT, anon_sym_DOT_DOT, anon_sym_AMP, anon_sym_SLASH, anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(494), 23, + ACTIONS(545), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, anon_sym_RPAREN, anon_sym_STAR, + anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, anon_sym_PLUS, anon_sym_DASH, anon_sym_as, @@ -30701,27 +30637,30 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12069] = 3, + [11996] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(693), 8, - anon_sym_BANG, + ACTIONS(535), 8, anon_sym_PIPE, + anon_sym_DOT, anon_sym_DOT_DOT, anon_sym_AMP, anon_sym_SLASH, anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(691), 24, + ACTIONS(533), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, anon_sym_COLON, + anon_sym_LPAREN, anon_sym_RPAREN, anon_sym_STAR, + anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, anon_sym_PLUS, anon_sym_DASH, anon_sym_as, @@ -30738,27 +30677,30 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12109] = 3, + [12039] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(697), 8, - anon_sym_BANG, + ACTIONS(579), 8, anon_sym_PIPE, + anon_sym_DOT, anon_sym_DOT_DOT, anon_sym_AMP, anon_sym_SLASH, anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(695), 24, + ACTIONS(577), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, anon_sym_COLON, + anon_sym_LPAREN, anon_sym_RPAREN, anon_sym_STAR, + anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, anon_sym_PLUS, anon_sym_DASH, anon_sym_as, @@ -30775,27 +30717,30 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12149] = 3, + [12082] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(701), 8, - anon_sym_BANG, + ACTIONS(583), 8, anon_sym_PIPE, + anon_sym_DOT, anon_sym_DOT_DOT, anon_sym_AMP, anon_sym_SLASH, anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(699), 24, + ACTIONS(581), 27, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, anon_sym_COLON, + anon_sym_LPAREN, anon_sym_RPAREN, anon_sym_STAR, + anon_sym_LBRACK, anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, + anon_sym_QMARK, anon_sym_PLUS, anon_sym_DASH, anon_sym_as, @@ -30812,10 +30757,13 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12189] = 3, + [12125] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(705), 8, + ACTIONS(689), 1, + anon_sym_COLON_COLON, + ACTIONS(496), 9, + anon_sym_COLON, anon_sym_BANG, anon_sym_PIPE, anon_sym_DOT_DOT, @@ -30824,7 +30772,43 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(703), 24, + ACTIONS(494), 23, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [12168] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(693), 8, + anon_sym_EQ, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(691), 24, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -30849,10 +30833,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12229] = 3, + [12208] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(709), 8, + ACTIONS(697), 8, anon_sym_BANG, anon_sym_PIPE, anon_sym_DOT_DOT, @@ -30861,7 +30845,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(707), 24, + ACTIONS(695), 24, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -30886,29 +30870,64 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12269] = 4, + [12248] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(711), 1, - anon_sym_EQ, - ACTIONS(511), 7, + ACTIONS(701), 8, + anon_sym_BANG, anon_sym_PIPE, - anon_sym_DOT, + anon_sym_DOT_DOT, anon_sym_AMP, anon_sym_SLASH, anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(509), 24, + ACTIONS(699), 24, anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, anon_sym_COLON, - anon_sym_LPAREN, anon_sym_RPAREN, anon_sym_STAR, - anon_sym_LBRACK, anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [12288] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(705), 8, + anon_sym_BANG, + anon_sym_PIPE, anon_sym_DOT_DOT, - anon_sym_QMARK, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(703), 24, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, anon_sym_as, @@ -30924,10 +30943,11 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET_CARET, anon_sym_PIPE_PIPE, anon_sym_else, - [12311] = 3, + anon_sym_EQ_GT, + [12328] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(715), 8, + ACTIONS(709), 8, anon_sym_BANG, anon_sym_PIPE, anon_sym_DOT_DOT, @@ -30936,7 +30956,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(713), 24, + ACTIONS(707), 24, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -30961,12 +30981,11 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12351] = 4, + [12368] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(719), 1, + ACTIONS(713), 8, anon_sym_BANG, - ACTIONS(721), 7, anon_sym_PIPE, anon_sym_DOT_DOT, anon_sym_AMP, @@ -30974,7 +30993,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(717), 24, + ACTIONS(711), 24, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -30999,10 +31018,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12393] = 3, + [12408] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(725), 8, + ACTIONS(717), 8, anon_sym_BANG, anon_sym_PIPE, anon_sym_DOT_DOT, @@ -31011,7 +31030,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(723), 24, + ACTIONS(715), 24, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -31036,11 +31055,11 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12433] = 3, + [12448] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(729), 8, - anon_sym_EQ, + ACTIONS(721), 8, + anon_sym_BANG, anon_sym_PIPE, anon_sym_DOT_DOT, anon_sym_AMP, @@ -31048,7 +31067,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(727), 24, + ACTIONS(719), 24, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -31073,10 +31092,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12473] = 3, + [12488] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(733), 8, + ACTIONS(725), 8, anon_sym_BANG, anon_sym_PIPE, anon_sym_DOT_DOT, @@ -31085,7 +31104,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(731), 24, + ACTIONS(723), 24, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -31110,10 +31129,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12513] = 3, + [12528] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(737), 8, + ACTIONS(729), 8, anon_sym_BANG, anon_sym_PIPE, anon_sym_DOT_DOT, @@ -31122,7 +31141,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(735), 24, + ACTIONS(727), 24, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -31147,10 +31166,48 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12553] = 3, + [12568] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(741), 8, + ACTIONS(731), 1, + anon_sym_EQ, + ACTIONS(511), 7, + anon_sym_PIPE, + anon_sym_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(509), 24, + anon_sym_SEMI, + anon_sym_COLON, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_LBRACK, + anon_sym_RBRACK, + anon_sym_DOT_DOT, + anon_sym_QMARK, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + [12610] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(735), 8, anon_sym_BANG, anon_sym_PIPE, anon_sym_DOT_DOT, @@ -31159,7 +31216,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(739), 24, + ACTIONS(733), 24, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -31184,10 +31241,47 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12593] = 3, + [12650] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(745), 8, + ACTIONS(739), 8, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(737), 24, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_COLON, + anon_sym_RPAREN, + anon_sym_STAR, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_PLUS, + anon_sym_DASH, + anon_sym_as, + anon_sym_is, + anon_sym_PERCENT, + anon_sym_LT_LT, + anon_sym_GT_GT, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [12690] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(743), 8, anon_sym_BANG, anon_sym_PIPE, anon_sym_DOT_DOT, @@ -31196,7 +31290,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(743), 24, + ACTIONS(741), 24, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -31221,10 +31315,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12633] = 3, + [12730] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(749), 8, + ACTIONS(747), 8, anon_sym_BANG, anon_sym_PIPE, anon_sym_DOT_DOT, @@ -31233,7 +31327,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(747), 24, + ACTIONS(745), 24, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -31258,11 +31352,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12673] = 3, + [12770] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(753), 8, + ACTIONS(751), 1, anon_sym_BANG, + ACTIONS(753), 7, anon_sym_PIPE, anon_sym_DOT_DOT, anon_sym_AMP, @@ -31270,7 +31365,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(751), 24, + ACTIONS(749), 24, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -31295,7 +31390,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12713] = 3, + [12812] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(757), 8, @@ -31332,7 +31427,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12753] = 3, + [12852] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(761), 8, @@ -31369,7 +31464,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12793] = 3, + [12892] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(765), 8, @@ -31406,7 +31501,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12833] = 3, + [12932] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(769), 8, @@ -31443,7 +31538,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12873] = 3, + [12972] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(773), 8, @@ -31480,7 +31575,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12913] = 3, + [13012] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(777), 8, @@ -31517,7 +31612,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12953] = 3, + [13052] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(781), 8, @@ -31554,7 +31649,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [12993] = 3, + [13092] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(785), 8, @@ -31591,33 +31686,33 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [13033] = 6, + [13132] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(789), 1, - anon_sym_COLON, - ACTIONS(793), 1, - anon_sym_as, - ACTIONS(795), 1, - anon_sym_is, - ACTIONS(791), 7, + ACTIONS(787), 1, + anon_sym_EQ, + ACTIONS(511), 7, anon_sym_PIPE, - anon_sym_DOT_DOT, + anon_sym_DOT, anon_sym_AMP, anon_sym_SLASH, anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(787), 21, + ACTIONS(509), 23, anon_sym_SEMI, - anon_sym_RBRACE, - anon_sym_COMMA, + anon_sym_COLON, + anon_sym_LPAREN, anon_sym_RPAREN, anon_sym_STAR, + anon_sym_LBRACK, anon_sym_RBRACK, - anon_sym_DOT_DOT_DOT, + anon_sym_DOT_DOT, + anon_sym_QMARK, anon_sym_PLUS, anon_sym_DASH, + anon_sym_as, + anon_sym_is, anon_sym_PERCENT, anon_sym_LT_LT, anon_sym_GT_GT, @@ -31628,12 +31723,16 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_AMP, anon_sym_CARET_CARET, anon_sym_PIPE_PIPE, - anon_sym_else, - anon_sym_EQ_GT, - [13078] = 3, + [13173] = 6, ACTIONS(3), 1, sym_comment, - ACTIONS(799), 7, + ACTIONS(791), 1, + anon_sym_COLON, + ACTIONS(795), 1, + anon_sym_as, + ACTIONS(797), 1, + anon_sym_is, + ACTIONS(793), 7, anon_sym_PIPE, anon_sym_DOT_DOT, anon_sym_AMP, @@ -31641,19 +31740,16 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(797), 24, + ACTIONS(789), 21, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, - anon_sym_COLON, anon_sym_RPAREN, anon_sym_STAR, anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, - anon_sym_as, - anon_sym_is, anon_sym_PERCENT, anon_sym_LT_LT, anon_sym_GT_GT, @@ -31666,10 +31762,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [13117] = 3, + [13218] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(661), 7, + ACTIONS(801), 7, anon_sym_PIPE, anon_sym_DOT_DOT, anon_sym_AMP, @@ -31677,7 +31773,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(657), 24, + ACTIONS(799), 24, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -31702,7 +31798,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [13156] = 3, + [13257] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(667), 7, @@ -31738,10 +31834,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [13195] = 3, + [13296] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(803), 7, + ACTIONS(805), 7, anon_sym_PIPE, anon_sym_DOT_DOT, anon_sym_AMP, @@ -31749,7 +31845,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(801), 24, + ACTIONS(803), 24, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -31774,10 +31870,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [13234] = 3, + [13335] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(807), 7, + ACTIONS(809), 7, anon_sym_PIPE, anon_sym_DOT_DOT, anon_sym_AMP, @@ -31785,7 +31881,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(805), 24, + ACTIONS(807), 24, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -31810,10 +31906,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [13273] = 3, + [13374] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(811), 7, + ACTIONS(813), 7, anon_sym_PIPE, anon_sym_DOT_DOT, anon_sym_AMP, @@ -31821,7 +31917,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(809), 24, + ACTIONS(811), 24, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -31846,16 +31942,16 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [13312] = 6, + [13413] = 6, ACTIONS(3), 1, sym_comment, - ACTIONS(789), 1, + ACTIONS(791), 1, anon_sym_COLON, - ACTIONS(793), 1, - anon_sym_as, ACTIONS(795), 1, + anon_sym_as, + ACTIONS(797), 1, anon_sym_is, - ACTIONS(815), 7, + ACTIONS(817), 7, anon_sym_PIPE, anon_sym_DOT_DOT, anon_sym_AMP, @@ -31863,7 +31959,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(813), 21, + ACTIONS(815), 21, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -31885,29 +31981,26 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [13357] = 4, + [13458] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(817), 1, - anon_sym_EQ, - ACTIONS(511), 7, + ACTIONS(661), 7, anon_sym_PIPE, - anon_sym_DOT, + anon_sym_DOT_DOT, anon_sym_AMP, anon_sym_SLASH, anon_sym_CARET, anon_sym_LT, anon_sym_GT, - ACTIONS(509), 23, + ACTIONS(657), 24, anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, anon_sym_COLON, - anon_sym_LPAREN, anon_sym_RPAREN, anon_sym_STAR, - anon_sym_LBRACK, anon_sym_RBRACK, - anon_sym_DOT_DOT, - anon_sym_QMARK, + anon_sym_DOT_DOT_DOT, anon_sym_PLUS, anon_sym_DASH, anon_sym_as, @@ -31922,7 +32015,9 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_AMP, anon_sym_CARET_CARET, anon_sym_PIPE_PIPE, - [13398] = 6, + anon_sym_else, + anon_sym_EQ_GT, + [13497] = 6, ACTIONS(3), 1, sym_comment, ACTIONS(825), 1, @@ -31958,7 +32053,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [13440] = 5, + [13539] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(825), 1, @@ -31991,15 +32086,15 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [13478] = 4, + [13577] = 4, ACTIONS(3), 1, sym_comment, - STATE(217), 1, + STATE(219), 1, sym_hex_digits, STATE(119), 2, sym_hex_digit, aux_sym_hex_digits_repeat1, - ACTIONS(236), 22, + ACTIONS(234), 22, anon_sym_0, anon_sym_1, anon_sym_2, @@ -32022,15 +32117,15 @@ static uint16_t ts_small_parse_table[] = { anon_sym_d, anon_sym_e, anon_sym_f, - [13513] = 4, + [13612] = 4, ACTIONS(3), 1, sym_comment, STATE(159), 1, sym_hex_digits, - STATE(106), 2, + STATE(103), 2, sym_hex_digit, aux_sym_hex_digits_repeat1, - ACTIONS(209), 22, + ACTIONS(183), 22, anon_sym_0, anon_sym_1, anon_sym_2, @@ -32053,14 +32148,14 @@ static uint16_t ts_small_parse_table[] = { anon_sym_d, anon_sym_e, anon_sym_f, - [13548] = 6, + [13647] = 6, ACTIONS(3), 1, sym_comment, - ACTIONS(789), 1, + ACTIONS(791), 1, anon_sym_COLON, - ACTIONS(793), 1, - anon_sym_as, ACTIONS(795), 1, + anon_sym_as, + ACTIONS(797), 1, anon_sym_is, ACTIONS(835), 6, anon_sym_PIPE, @@ -32085,7 +32180,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [13586] = 17, + [13685] = 17, ACTIONS(3), 1, sym_comment, ACTIONS(9), 1, @@ -32102,33 +32197,33 @@ static uint16_t ts_small_parse_table[] = { anon_sym_ATnoreturn, ACTIONS(837), 1, ts_builtin_sym_end, - STATE(364), 1, + STATE(366), 1, aux_sym_declarations_repeat1, - STATE(724), 1, + STATE(727), 1, sym_declarations, - STATE(770), 1, - sym_fndec_attrs, STATE(772), 1, + sym_fndec_attrs, + STATE(774), 1, sym_declaration, ACTIONS(11), 2, anon_sym_let, anon_sym_const, - STATE(408), 2, + STATE(411), 2, sym_fndec_attr, aux_sym_fndec_attrs_repeat1, - STATE(469), 2, + STATE(479), 2, sym_decl_attr, sym_fntype_attr, ACTIONS(21), 3, anon_sym_ATfini, anon_sym_ATinit, anon_sym_ATtest, - STATE(771), 4, + STATE(773), 4, sym_global_declaration, sym_constant_declaration, sym_type_declaration, sym_function_declaration, - [13646] = 4, + [13745] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(843), 2, @@ -32157,7 +32252,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [13679] = 16, + [13778] = 16, ACTIONS(3), 1, sym_comment, ACTIONS(845), 1, @@ -32174,31 +32269,31 @@ static uint16_t ts_small_parse_table[] = { anon_sym_fn, ACTIONS(868), 1, anon_sym_ATnoreturn, - STATE(363), 1, + STATE(365), 1, aux_sym_declarations_repeat1, - STATE(770), 1, - sym_fndec_attrs, STATE(772), 1, + sym_fndec_attrs, + STATE(774), 1, sym_declaration, ACTIONS(850), 2, anon_sym_let, anon_sym_const, - STATE(408), 2, + STATE(411), 2, sym_fndec_attr, aux_sym_fndec_attrs_repeat1, - STATE(469), 2, + STATE(479), 2, sym_decl_attr, sym_fntype_attr, ACTIONS(865), 3, anon_sym_ATfini, anon_sym_ATinit, anon_sym_ATtest, - STATE(771), 4, + STATE(773), 4, sym_global_declaration, sym_constant_declaration, sym_type_declaration, sym_function_declaration, - [13736] = 16, + [13835] = 16, ACTIONS(3), 1, sym_comment, ACTIONS(9), 1, @@ -32215,31 +32310,31 @@ static uint16_t ts_small_parse_table[] = { anon_sym_ATnoreturn, ACTIONS(871), 1, ts_builtin_sym_end, - STATE(363), 1, + STATE(365), 1, aux_sym_declarations_repeat1, - STATE(770), 1, - sym_fndec_attrs, STATE(772), 1, + sym_fndec_attrs, + STATE(774), 1, sym_declaration, ACTIONS(11), 2, anon_sym_let, anon_sym_const, - STATE(408), 2, + STATE(411), 2, sym_fndec_attr, aux_sym_fndec_attrs_repeat1, - STATE(469), 2, + STATE(479), 2, sym_decl_attr, sym_fntype_attr, ACTIONS(21), 3, anon_sym_ATfini, anon_sym_ATinit, anon_sym_ATtest, - STATE(771), 4, + STATE(773), 4, sym_global_declaration, sym_constant_declaration, sym_type_declaration, sym_function_declaration, - [13793] = 4, + [13892] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(877), 1, @@ -32266,7 +32361,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [13824] = 3, + [13923] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(881), 6, @@ -32292,7 +32387,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [13853] = 4, + [13952] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(877), 1, @@ -32319,7 +32414,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [13884] = 3, + [13983] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(889), 6, @@ -32345,7 +32440,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [13913] = 4, + [14012] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(895), 1, @@ -32371,7 +32466,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [13943] = 13, + [14042] = 13, ACTIONS(3), 1, sym_comment, ACTIONS(13), 1, @@ -32384,29 +32479,29 @@ static uint16_t ts_small_parse_table[] = { anon_sym_fn, ACTIONS(23), 1, anon_sym_ATnoreturn, - STATE(759), 1, + STATE(761), 1, sym_declaration, - STATE(770), 1, + STATE(772), 1, sym_fndec_attrs, ACTIONS(11), 2, anon_sym_let, anon_sym_const, - STATE(408), 2, + STATE(411), 2, sym_fndec_attr, aux_sym_fndec_attrs_repeat1, - STATE(469), 2, + STATE(479), 2, sym_decl_attr, sym_fntype_attr, ACTIONS(21), 3, anon_sym_ATfini, anon_sym_ATinit, anon_sym_ATtest, - STATE(771), 4, + STATE(773), 4, sym_global_declaration, sym_constant_declaration, sym_type_declaration, sym_function_declaration, - [13991] = 4, + [14090] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(895), 1, @@ -32432,7 +32527,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [14021] = 4, + [14120] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(903), 1, @@ -32457,7 +32552,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [14050] = 4, + [14149] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(903), 1, @@ -32482,37 +32577,32 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [14079] = 10, + [14178] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(258), 1, - anon_sym_0x, - ACTIONS(260), 1, - anon_sym_0o, - ACTIONS(262), 1, - anon_sym_0b, - ACTIONS(264), 1, - anon_sym_0, - ACTIONS(911), 1, - sym_name, - STATE(153), 1, - sym_decimal_digits, - STATE(240), 1, - sym_integer_constant, - STATE(114), 2, - sym_decimal_digit, - aux_sym_decimal_digits_repeat1, - ACTIONS(221), 9, - anon_sym_1, - anon_sym_2, - anon_sym_3, - anon_sym_4, - anon_sym_5, - anon_sym_6, - anon_sym_7, - anon_sym_8, - anon_sym_9, - [14119] = 10, + ACTIONS(913), 1, + anon_sym_DOT_DOT, + ACTIONS(915), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(917), 2, + anon_sym_LT_EQ, + anon_sym_GT_EQ, + ACTIONS(911), 13, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_EQ_EQ, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [14208] = 10, ACTIONS(3), 1, sym_comment, ACTIONS(47), 1, @@ -32523,13 +32613,13 @@ static uint16_t ts_small_parse_table[] = { anon_sym_0b, ACTIONS(53), 1, anon_sym_0, - ACTIONS(913), 1, + ACTIONS(919), 1, sym_name, - STATE(192), 1, + STATE(178), 1, sym_decimal_digits, - STATE(291), 1, + STATE(293), 1, sym_integer_constant, - STATE(146), 2, + STATE(149), 2, sym_decimal_digit, aux_sym_decimal_digits_repeat1, ACTIONS(55), 9, @@ -32542,40 +32632,45 @@ static uint16_t ts_small_parse_table[] = { anon_sym_7, anon_sym_8, anon_sym_9, - [14159] = 5, + [14248] = 10, ACTIONS(3), 1, sym_comment, - ACTIONS(917), 1, - anon_sym_DOT_DOT, - ACTIONS(919), 2, - anon_sym_LT, - anon_sym_GT, - ACTIONS(921), 2, - anon_sym_LT_EQ, - anon_sym_GT_EQ, - ACTIONS(915), 13, - anon_sym_SEMI, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_RPAREN, - anon_sym_RBRACK, - anon_sym_DOT_DOT_DOT, - anon_sym_EQ_EQ, - anon_sym_BANG_EQ, - anon_sym_AMP_AMP, - anon_sym_CARET_CARET, - anon_sym_PIPE_PIPE, - anon_sym_else, - anon_sym_EQ_GT, - [14189] = 5, + ACTIONS(260), 1, + anon_sym_0x, + ACTIONS(262), 1, + anon_sym_0o, + ACTIONS(264), 1, + anon_sym_0b, + ACTIONS(266), 1, + anon_sym_0, + ACTIONS(921), 1, + sym_name, + STATE(154), 1, + sym_decimal_digits, + STATE(233), 1, + sym_integer_constant, + STATE(115), 2, + sym_decimal_digit, + aux_sym_decimal_digits_repeat1, + ACTIONS(228), 9, + anon_sym_1, + anon_sym_2, + anon_sym_3, + anon_sym_4, + anon_sym_5, + anon_sym_6, + anon_sym_7, + anon_sym_8, + anon_sym_9, + [14288] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(925), 1, anon_sym_DOT_DOT, - ACTIONS(919), 2, + ACTIONS(915), 2, anon_sym_LT, anon_sym_GT, - ACTIONS(921), 2, + ACTIONS(917), 2, anon_sym_LT_EQ, anon_sym_GT_EQ, ACTIONS(923), 13, @@ -32592,14 +32687,14 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [14219] = 3, + [14318] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(465), 3, + ACTIONS(484), 3, anon_sym_EQ, anon_sym_COLON, anon_sym_DOT, - ACTIONS(463), 13, + ACTIONS(482), 13, anon_sym_SEMI, anon_sym_COLON_COLON, anon_sym_LBRACE, @@ -32613,12 +32708,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, anon_sym_QMARK, anon_sym_EQ_GT, - [14243] = 4, + [14342] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(7), 1, anon_sym_use, - STATE(382), 2, + STATE(384), 2, sym_use_statement, aux_sym_imports_repeat1, ACTIONS(927), 12, @@ -32634,14 +32729,14 @@ static uint16_t ts_small_parse_table[] = { anon_sym_ATinit, anon_sym_ATtest, anon_sym_ATnoreturn, - [14268] = 5, + [14367] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(379), 1, anon_sym_uint, ACTIONS(929), 1, anon_sym_LBRACE, - STATE(660), 1, + STATE(792), 1, sym_integer_type, ACTIONS(931), 12, anon_sym_i8, @@ -32656,14 +32751,14 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [14295] = 5, + [14394] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(379), 1, anon_sym_uint, ACTIONS(933), 1, anon_sym_LBRACE, - STATE(790), 1, + STATE(662), 1, sym_integer_type, ACTIONS(931), 12, anon_sym_i8, @@ -32678,12 +32773,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_size, anon_sym_uintptr, anon_sym_char, - [14322] = 4, + [14421] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(937), 1, anon_sym_use, - STATE(382), 2, + STATE(384), 2, sym_use_statement, aux_sym_imports_repeat1, ACTIONS(935), 12, @@ -32699,7 +32794,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_ATinit, anon_sym_ATtest, anon_sym_ATnoreturn, - [14347] = 4, + [14446] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(942), 1, @@ -32719,7 +32814,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [14371] = 4, + [14470] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(948), 1, @@ -32739,15 +32834,15 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [14395] = 4, + [14494] = 4, ACTIONS(3), 1, sym_comment, - STATE(156), 1, + STATE(268), 1, sym_decimal_digits, - STATE(114), 2, + STATE(149), 2, sym_decimal_digit, aux_sym_decimal_digits_repeat1, - ACTIONS(221), 10, + ACTIONS(55), 10, anon_sym_0, anon_sym_1, anon_sym_2, @@ -32758,10 +32853,46 @@ static uint16_t ts_small_parse_table[] = { anon_sym_7, anon_sym_8, anon_sym_9, - [14418] = 2, + [14517] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(950), 1, + anon_sym_COLON_COLON, + ACTIONS(496), 2, + anon_sym_EQ, + anon_sym_COLON, + ACTIONS(494), 10, + anon_sym_SEMI, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT_DOT, + anon_sym_EQ_GT, + [14540] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(952), 13, + ts_builtin_sym_end, + anon_sym_use, + anon_sym_export, + anon_sym_let, + anon_sym_const, + anon_sym_ATsymbol, + anon_sym_def, + anon_sym_type, + anon_sym_fn, + anon_sym_ATfini, + anon_sym_ATinit, + anon_sym_ATtest, + anon_sym_ATnoreturn, + [14559] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(950), 13, + ACTIONS(954), 13, ts_builtin_sym_end, anon_sym_use, anon_sym_export, @@ -32775,15 +32906,15 @@ static uint16_t ts_small_parse_table[] = { anon_sym_ATinit, anon_sym_ATtest, anon_sym_ATnoreturn, - [14437] = 4, + [14578] = 4, ACTIONS(3), 1, sym_comment, - STATE(168), 1, + STATE(203), 1, sym_decimal_digits, - STATE(114), 2, + STATE(149), 2, sym_decimal_digit, aux_sym_decimal_digits_repeat1, - ACTIONS(221), 10, + ACTIONS(55), 10, anon_sym_0, anon_sym_1, anon_sym_2, @@ -32794,15 +32925,32 @@ static uint16_t ts_small_parse_table[] = { anon_sym_7, anon_sym_8, anon_sym_9, - [14460] = 4, + [14601] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(956), 13, + ts_builtin_sym_end, + anon_sym_use, + anon_sym_export, + anon_sym_let, + anon_sym_const, + anon_sym_ATsymbol, + anon_sym_def, + anon_sym_type, + anon_sym_fn, + anon_sym_ATfini, + anon_sym_ATinit, + anon_sym_ATtest, + anon_sym_ATnoreturn, + [14620] = 4, ACTIONS(3), 1, sym_comment, - STATE(200), 1, + STATE(166), 1, sym_decimal_digits, - STATE(146), 2, + STATE(115), 2, sym_decimal_digit, aux_sym_decimal_digits_repeat1, - ACTIONS(55), 10, + ACTIONS(228), 10, anon_sym_0, anon_sym_1, anon_sym_2, @@ -32813,15 +32961,15 @@ static uint16_t ts_small_parse_table[] = { anon_sym_7, anon_sym_8, anon_sym_9, - [14483] = 4, + [14643] = 4, ACTIONS(3), 1, sym_comment, - STATE(267), 1, + STATE(156), 1, sym_decimal_digits, - STATE(146), 2, + STATE(115), 2, sym_decimal_digit, aux_sym_decimal_digits_repeat1, - ACTIONS(55), 10, + ACTIONS(228), 10, anon_sym_0, anon_sym_1, anon_sym_2, @@ -32832,12 +32980,11 @@ static uint16_t ts_small_parse_table[] = { anon_sym_7, anon_sym_8, anon_sym_9, - [14506] = 2, + [14666] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(952), 13, + ACTIONS(958), 12, ts_builtin_sym_end, - anon_sym_use, anon_sym_export, anon_sym_let, anon_sym_const, @@ -32849,31 +32996,11 @@ static uint16_t ts_small_parse_table[] = { anon_sym_ATinit, anon_sym_ATtest, anon_sym_ATnoreturn, - [14525] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(954), 1, - anon_sym_COLON_COLON, - ACTIONS(496), 2, - anon_sym_EQ, - anon_sym_COLON, - ACTIONS(494), 10, - anon_sym_SEMI, - anon_sym_LBRACE, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_LPAREN, - anon_sym_RPAREN, - anon_sym_BANG, - anon_sym_PIPE, - anon_sym_DOT_DOT_DOT, - anon_sym_EQ_GT, - [14548] = 2, + [14684] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(956), 13, + ACTIONS(845), 12, ts_builtin_sym_end, - anon_sym_use, anon_sym_export, anon_sym_let, anon_sym_const, @@ -32885,31 +33012,14 @@ static uint16_t ts_small_parse_table[] = { anon_sym_ATinit, anon_sym_ATtest, anon_sym_ATnoreturn, - [14567] = 3, - ACTIONS(3), 1, - sym_comment, - STATE(52), 1, - sym_assignment_op, - ACTIONS(663), 11, - anon_sym_EQ, - anon_sym_PLUS_EQ, - anon_sym_DASH_EQ, - anon_sym_STAR_EQ, - anon_sym_SLASH_EQ, - anon_sym_PERCENT_EQ, - anon_sym_LT_LT_EQ, - anon_sym_GT_GT_EQ, - anon_sym_AMP_EQ, - anon_sym_PIPE_EQ, - anon_sym_CARET_EQ, - [14587] = 4, + [14702] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(960), 1, - anon_sym_DOT_DOT, ACTIONS(962), 1, + anon_sym_DOT_DOT, + ACTIONS(964), 1, anon_sym_AMP_AMP, - ACTIONS(958), 10, + ACTIONS(960), 10, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -32920,10 +33030,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [14609] = 3, + [14724] = 3, ACTIONS(3), 1, sym_comment, - STATE(45), 1, + STATE(73), 1, sym_assignment_op, ACTIONS(663), 11, anon_sym_EQ, @@ -32937,26 +33047,27 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [14629] = 2, + [14744] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(845), 12, - ts_builtin_sym_end, - anon_sym_export, - anon_sym_let, - anon_sym_const, - anon_sym_ATsymbol, - anon_sym_def, - anon_sym_type, - anon_sym_fn, - anon_sym_ATfini, - anon_sym_ATinit, - anon_sym_ATtest, - anon_sym_ATnoreturn, - [14647] = 3, + STATE(67), 1, + sym_assignment_op, + ACTIONS(663), 11, + anon_sym_EQ, + anon_sym_PLUS_EQ, + anon_sym_DASH_EQ, + anon_sym_STAR_EQ, + anon_sym_SLASH_EQ, + anon_sym_PERCENT_EQ, + anon_sym_LT_LT_EQ, + anon_sym_GT_GT_EQ, + anon_sym_AMP_EQ, + anon_sym_PIPE_EQ, + anon_sym_CARET_EQ, + [14764] = 3, ACTIONS(3), 1, sym_comment, - STATE(46), 1, + STATE(55), 1, sym_assignment_op, ACTIONS(663), 11, anon_sym_EQ, @@ -32970,14 +33081,14 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [14667] = 4, + [14784] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(962), 1, + ACTIONS(964), 1, anon_sym_AMP_AMP, - ACTIONS(966), 1, + ACTIONS(968), 1, anon_sym_DOT_DOT, - ACTIONS(964), 10, + ACTIONS(966), 10, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -32988,26 +33099,10 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [14689] = 2, - ACTIONS(3), 1, - sym_comment, - ACTIONS(968), 12, - ts_builtin_sym_end, - anon_sym_export, - anon_sym_let, - anon_sym_const, - anon_sym_ATsymbol, - anon_sym_def, - anon_sym_type, - anon_sym_fn, - anon_sym_ATfini, - anon_sym_ATinit, - anon_sym_ATtest, - anon_sym_ATnoreturn, - [14707] = 3, + [14806] = 3, ACTIONS(3), 1, sym_comment, - STATE(55), 1, + STATE(45), 1, sym_assignment_op, ACTIONS(663), 11, anon_sym_EQ, @@ -33021,24 +33116,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_AMP_EQ, anon_sym_PIPE_EQ, anon_sym_CARET_EQ, - [14727] = 4, - ACTIONS(3), 1, - sym_comment, - STATE(217), 1, - sym_octal_digits, - STATE(160), 2, - sym_octal_digit, - aux_sym_octal_digits_repeat1, - ACTIONS(364), 8, - anon_sym_0, - anon_sym_1, - anon_sym_2, - anon_sym_3, - anon_sym_4, - anon_sym_5, - anon_sym_6, - anon_sym_7, - [14748] = 4, + [14826] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(972), 1, @@ -33055,71 +33133,71 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE_PIPE, anon_sym_else, anon_sym_EQ_GT, - [14769] = 4, + [14847] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(974), 1, - anon_sym_CARET_CARET, - ACTIONS(978), 1, - anon_sym_DOT_DOT, - ACTIONS(976), 9, - anon_sym_SEMI, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_RPAREN, - anon_sym_RBRACK, - anon_sym_DOT_DOT_DOT, - anon_sym_PIPE_PIPE, - anon_sym_else, - anon_sym_EQ_GT, - [14790] = 10, + STATE(159), 1, + sym_octal_digits, + STATE(136), 2, + sym_octal_digit, + aux_sym_octal_digits_repeat1, + ACTIONS(311), 8, + anon_sym_0, + anon_sym_1, + anon_sym_2, + anon_sym_3, + anon_sym_4, + anon_sym_5, + anon_sym_6, + anon_sym_7, + [14868] = 10, ACTIONS(3), 1, sym_comment, ACTIONS(389), 1, anon_sym_struct, ACTIONS(391), 1, anon_sym_union, - ACTIONS(980), 1, + ACTIONS(976), 1, anon_sym_RBRACE, - ACTIONS(982), 1, + ACTIONS(978), 1, anon_sym_AToffset, - ACTIONS(984), 1, + ACTIONS(980), 1, sym_name, - STATE(467), 1, + STATE(476), 1, sym_offset_specifier, - STATE(565), 1, + STATE(599), 1, sym_struct_union_field, - STATE(780), 1, + STATE(783), 1, sym_struct_union_fields, - STATE(582), 3, + STATE(593), 3, sym_struct_type, sym_union_type, sym_identifier, - [14823] = 4, + [14901] = 4, ACTIONS(3), 1, sym_comment, - STATE(159), 1, - sym_octal_digits, - STATE(137), 2, - sym_octal_digit, - aux_sym_octal_digits_repeat1, - ACTIONS(311), 8, - anon_sym_0, - anon_sym_1, - anon_sym_2, - anon_sym_3, - anon_sym_4, - anon_sym_5, - anon_sym_6, - anon_sym_7, - [14844] = 5, + ACTIONS(974), 1, + anon_sym_CARET_CARET, + ACTIONS(984), 1, + anon_sym_DOT_DOT, + ACTIONS(982), 9, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [14922] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(31), 1, anon_sym_COLON, ACTIONS(79), 1, anon_sym_DOT_DOT, - STATE(443), 1, + STATE(449), 1, sym_label, ACTIONS(25), 8, anon_sym_SEMI, @@ -33130,94 +33208,109 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, anon_sym_else, anon_sym_EQ_GT, - [14867] = 9, + [14945] = 4, + ACTIONS(3), 1, + sym_comment, + STATE(219), 1, + sym_octal_digits, + STATE(160), 2, + sym_octal_digit, + aux_sym_octal_digits_repeat1, + ACTIONS(364), 8, + anon_sym_0, + anon_sym_1, + anon_sym_2, + anon_sym_3, + anon_sym_4, + anon_sym_5, + anon_sym_6, + anon_sym_7, + [14966] = 9, ACTIONS(3), 1, sym_comment, ACTIONS(389), 1, anon_sym_struct, ACTIONS(391), 1, anon_sym_union, - ACTIONS(982), 1, + ACTIONS(978), 1, anon_sym_AToffset, - ACTIONS(984), 1, + ACTIONS(980), 1, sym_name, - STATE(467), 1, + STATE(476), 1, sym_offset_specifier, - STATE(565), 1, + STATE(599), 1, sym_struct_union_field, STATE(758), 1, sym_struct_union_fields, - STATE(582), 3, + STATE(593), 3, sym_struct_type, sym_union_type, sym_identifier, - [14897] = 7, + [14996] = 7, + ACTIONS(3), 1, + sym_comment, + ACTIONS(986), 1, + anon_sym_ATsymbol, + ACTIONS(989), 1, + anon_sym_fn, + ACTIONS(994), 1, + anon_sym_ATnoreturn, + STATE(410), 2, + sym_fndec_attr, + aux_sym_fndec_attrs_repeat1, + STATE(479), 2, + sym_decl_attr, + sym_fntype_attr, + ACTIONS(991), 3, + anon_sym_ATfini, + anon_sym_ATinit, + anon_sym_ATtest, + [15022] = 7, ACTIONS(3), 1, sym_comment, ACTIONS(13), 1, anon_sym_ATsymbol, ACTIONS(23), 1, anon_sym_ATnoreturn, - ACTIONS(986), 1, + ACTIONS(997), 1, anon_sym_fn, - STATE(414), 2, + STATE(410), 2, sym_fndec_attr, aux_sym_fndec_attrs_repeat1, - STATE(469), 2, + STATE(479), 2, sym_decl_attr, sym_fntype_attr, ACTIONS(21), 3, anon_sym_ATfini, anon_sym_ATinit, anon_sym_ATtest, - [14923] = 9, - ACTIONS(3), 1, - sym_comment, - ACTIONS(389), 1, - anon_sym_struct, - ACTIONS(391), 1, - anon_sym_union, - ACTIONS(982), 1, - anon_sym_AToffset, - ACTIONS(984), 1, - sym_name, - STATE(467), 1, - sym_offset_specifier, - STATE(565), 1, - sym_struct_union_field, - STATE(666), 1, - sym_struct_union_fields, - STATE(582), 3, - sym_struct_type, - sym_union_type, - sym_identifier, - [14953] = 9, + [15048] = 9, ACTIONS(3), 1, sym_comment, ACTIONS(389), 1, anon_sym_struct, ACTIONS(391), 1, anon_sym_union, - ACTIONS(982), 1, + ACTIONS(978), 1, anon_sym_AToffset, - ACTIONS(984), 1, + ACTIONS(980), 1, sym_name, - STATE(467), 1, + STATE(476), 1, sym_offset_specifier, - STATE(565), 1, + STATE(599), 1, sym_struct_union_field, - STATE(665), 1, + STATE(764), 1, sym_struct_union_fields, - STATE(582), 3, + STATE(593), 3, sym_struct_type, sym_union_type, sym_identifier, - [14983] = 3, + [15078] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(701), 1, + ACTIONS(705), 1, anon_sym_EQ, - ACTIONS(699), 9, + ACTIONS(703), 9, anon_sym_SEMI, anon_sym_LBRACE, anon_sym_RBRACE, @@ -33227,14 +33320,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE, anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [15001] = 4, + [15096] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(990), 1, + ACTIONS(1001), 1, anon_sym_DOT_DOT, - ACTIONS(992), 1, - anon_sym_PIPE_PIPE, - ACTIONS(988), 8, + ACTIONS(999), 9, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -33242,53 +33333,37 @@ static uint16_t ts_small_parse_table[] = { anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, anon_sym_else, + anon_sym_for, anon_sym_EQ_GT, - [15021] = 9, + [15114] = 9, ACTIONS(3), 1, sym_comment, ACTIONS(389), 1, anon_sym_struct, ACTIONS(391), 1, anon_sym_union, - ACTIONS(982), 1, + ACTIONS(978), 1, anon_sym_AToffset, - ACTIONS(984), 1, + ACTIONS(980), 1, sym_name, - STATE(467), 1, + STATE(476), 1, sym_offset_specifier, - STATE(565), 1, + STATE(599), 1, sym_struct_union_field, - STATE(764), 1, + STATE(669), 1, sym_struct_union_fields, - STATE(582), 3, + STATE(593), 3, sym_struct_type, sym_union_type, sym_identifier, - [15051] = 7, - ACTIONS(3), 1, - sym_comment, - ACTIONS(994), 1, - anon_sym_ATsymbol, - ACTIONS(997), 1, - anon_sym_fn, - ACTIONS(1002), 1, - anon_sym_ATnoreturn, - STATE(414), 2, - sym_fndec_attr, - aux_sym_fndec_attrs_repeat1, - STATE(469), 2, - sym_decl_attr, - sym_fntype_attr, - ACTIONS(999), 3, - anon_sym_ATfini, - anon_sym_ATinit, - anon_sym_ATtest, - [15077] = 3, + [15144] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(1007), 1, + ACTIONS(1005), 1, anon_sym_DOT_DOT, - ACTIONS(1005), 9, + ACTIONS(1007), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1003), 8, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -33296,9 +33371,29 @@ static uint16_t ts_small_parse_table[] = { anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, anon_sym_else, - anon_sym_for, anon_sym_EQ_GT, - [15095] = 3, + [15164] = 9, + ACTIONS(3), 1, + sym_comment, + ACTIONS(389), 1, + anon_sym_struct, + ACTIONS(391), 1, + anon_sym_union, + ACTIONS(978), 1, + anon_sym_AToffset, + ACTIONS(980), 1, + sym_name, + STATE(476), 1, + sym_offset_specifier, + STATE(599), 1, + sym_struct_union_field, + STATE(668), 1, + sym_struct_union_fields, + STATE(593), 3, + sym_struct_type, + sym_union_type, + sym_identifier, + [15194] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1011), 1, @@ -33312,12 +33407,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, anon_sym_else, anon_sym_EQ_GT, - [15112] = 3, + [15211] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(733), 1, + ACTIONS(713), 1, anon_sym_EQ, - ACTIONS(731), 8, + ACTIONS(711), 8, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -33326,12 +33421,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE, anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [15129] = 3, + [15228] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(693), 1, + ACTIONS(769), 1, anon_sym_EQ, - ACTIONS(691), 8, + ACTIONS(767), 8, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -33340,22 +33435,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE, anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [15146] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(1015), 1, - anon_sym_DOT_DOT, - ACTIONS(1017), 1, - anon_sym_else, - ACTIONS(1013), 7, - anon_sym_SEMI, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_RPAREN, - anon_sym_RBRACK, - anon_sym_DOT_DOT_DOT, - anon_sym_EQ_GT, - [15165] = 3, + [15245] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(777), 1, @@ -33369,41 +33449,41 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE, anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [15182] = 3, + [15262] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(741), 1, - anon_sym_EQ, - ACTIONS(739), 8, + ACTIONS(1005), 1, + anon_sym_DOT_DOT, + ACTIONS(1003), 8, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, anon_sym_RPAREN, - anon_sym_BANG, - anon_sym_PIPE, + anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, + anon_sym_else, anon_sym_EQ_GT, - [15199] = 4, + [15279] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(1022), 1, - anon_sym_COMMA, - ACTIONS(1025), 1, + ACTIONS(1015), 1, anon_sym_DOT_DOT, - ACTIONS(1020), 7, + ACTIONS(1017), 1, + anon_sym_else, + ACTIONS(1013), 7, anon_sym_SEMI, anon_sym_RBRACE, + anon_sym_COMMA, anon_sym_RPAREN, anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, - anon_sym_else, anon_sym_EQ_GT, - [15218] = 3, + [15298] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(745), 1, + ACTIONS(721), 1, anon_sym_EQ, - ACTIONS(743), 8, + ACTIONS(719), 8, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -33412,26 +33492,26 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE, anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [15235] = 3, + [15315] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(709), 1, - anon_sym_EQ, - ACTIONS(707), 8, + ACTIONS(1022), 1, + anon_sym_DOT_DOT, + ACTIONS(1020), 8, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, anon_sym_RPAREN, - anon_sym_BANG, - anon_sym_PIPE, + anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, + anon_sym_else, anon_sym_EQ_GT, - [15252] = 3, + [15332] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(990), 1, + ACTIONS(1026), 1, anon_sym_DOT_DOT, - ACTIONS(988), 8, + ACTIONS(1024), 8, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -33440,14 +33520,14 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, anon_sym_else, anon_sym_EQ_GT, - [15269] = 4, + [15349] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(721), 1, + ACTIONS(753), 1, anon_sym_EQ, - ACTIONS(1027), 1, + ACTIONS(1028), 1, anon_sym_BANG, - ACTIONS(717), 7, + ACTIONS(749), 7, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -33455,12 +33535,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE, anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [15288] = 3, + [15368] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(769), 1, + ACTIONS(729), 1, anon_sym_EQ, - ACTIONS(767), 8, + ACTIONS(727), 8, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -33469,12 +33549,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE, anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [15305] = 3, + [15385] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(705), 1, + ACTIONS(701), 1, anon_sym_EQ, - ACTIONS(703), 8, + ACTIONS(699), 8, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -33483,26 +33563,26 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE, anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [15322] = 3, + [15402] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1031), 1, - anon_sym_DOT_DOT, - ACTIONS(1029), 8, + ACTIONS(709), 1, + anon_sym_EQ, + ACTIONS(707), 8, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, anon_sym_RPAREN, - anon_sym_RBRACK, + anon_sym_BANG, + anon_sym_PIPE, anon_sym_DOT_DOT_DOT, - anon_sym_else, anon_sym_EQ_GT, - [15339] = 3, + [15419] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1035), 1, + ACTIONS(1032), 1, anon_sym_DOT_DOT, - ACTIONS(1033), 8, + ACTIONS(1030), 8, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -33511,12 +33591,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, anon_sym_else, anon_sym_EQ_GT, - [15356] = 3, + [15436] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1039), 1, + ACTIONS(1036), 1, anon_sym_DOT_DOT, - ACTIONS(1037), 8, + ACTIONS(1034), 8, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -33525,12 +33605,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, anon_sym_else, anon_sym_EQ_GT, - [15373] = 3, + [15453] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(781), 1, + ACTIONS(739), 1, anon_sym_EQ, - ACTIONS(779), 8, + ACTIONS(737), 8, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -33539,12 +33619,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE, anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [15390] = 4, + [15470] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1015), 1, anon_sym_DOT_DOT, - ACTIONS(1041), 1, + ACTIONS(1038), 1, anon_sym_else, ACTIONS(1013), 7, anon_sym_SEMI, @@ -33554,12 +33634,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [15409] = 3, + [15489] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(773), 1, + ACTIONS(743), 1, anon_sym_EQ, - ACTIONS(771), 8, + ACTIONS(741), 8, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -33568,12 +33648,27 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE, anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [15426] = 3, + [15506] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(725), 1, + ACTIONS(1042), 1, + anon_sym_COMMA, + ACTIONS(1045), 1, + anon_sym_DOT_DOT, + ACTIONS(1040), 7, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_else, + anon_sym_EQ_GT, + [15525] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(735), 1, anon_sym_EQ, - ACTIONS(723), 8, + ACTIONS(733), 8, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -33582,21 +33677,35 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE, anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [15443] = 3, + [15542] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1045), 1, - anon_sym_DOT_DOT, - ACTIONS(1043), 8, + ACTIONS(761), 1, + anon_sym_EQ, + ACTIONS(759), 8, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, anon_sym_RPAREN, - anon_sym_RBRACK, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT_DOT, + anon_sym_EQ_GT, + [15559] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(781), 1, + anon_sym_EQ, + ACTIONS(779), 8, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_BANG, + anon_sym_PIPE, anon_sym_DOT_DOT_DOT, - anon_sym_else, anon_sym_EQ_GT, - [15460] = 3, + [15576] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1049), 1, @@ -33610,7 +33719,35 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, anon_sym_else, anon_sym_EQ_GT, - [15477] = 3, + [15593] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(773), 1, + anon_sym_EQ, + ACTIONS(771), 8, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT_DOT, + anon_sym_EQ_GT, + [15610] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(725), 1, + anon_sym_EQ, + ACTIONS(723), 8, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT_DOT, + anon_sym_EQ_GT, + [15627] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1053), 1, @@ -33624,7 +33761,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, anon_sym_else, anon_sym_EQ_GT, - [15494] = 3, + [15644] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1057), 1, @@ -33638,7 +33775,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, anon_sym_else, anon_sym_EQ_GT, - [15511] = 3, + [15661] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1061), 1, @@ -33652,7 +33789,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, anon_sym_else, anon_sym_EQ_GT, - [15528] = 3, + [15678] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1065), 1, @@ -33666,7 +33803,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, anon_sym_else, anon_sym_EQ_GT, - [15545] = 3, + [15695] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1069), 1, @@ -33680,7 +33817,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, anon_sym_else, anon_sym_EQ_GT, - [15562] = 3, + [15712] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1073), 1, @@ -33694,7 +33831,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, anon_sym_else, anon_sym_EQ_GT, - [15579] = 3, + [15729] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1077), 1, @@ -33708,7 +33845,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, anon_sym_else, anon_sym_EQ_GT, - [15596] = 3, + [15746] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1081), 1, @@ -33722,40 +33859,40 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, anon_sym_else, anon_sym_EQ_GT, - [15613] = 3, + [15763] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1085), 1, - anon_sym_DOT_DOT, - ACTIONS(1083), 8, + ACTIONS(697), 1, + anon_sym_EQ, + ACTIONS(695), 8, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, anon_sym_RPAREN, - anon_sym_RBRACK, - anon_sym_DOT_DOT_DOT, - anon_sym_else, + anon_sym_BANG, + anon_sym_PIPE, + anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [15630] = 3, + [15780] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(749), 1, - anon_sym_EQ, - ACTIONS(747), 8, + ACTIONS(1085), 1, + anon_sym_DOT_DOT, + ACTIONS(1083), 8, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, anon_sym_RPAREN, - anon_sym_BANG, - anon_sym_PIPE, + anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, + anon_sym_else, anon_sym_EQ_GT, - [15647] = 3, + [15797] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(785), 1, + ACTIONS(757), 1, anon_sym_EQ, - ACTIONS(783), 8, + ACTIONS(755), 8, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -33764,7 +33901,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE, anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [15664] = 3, + [15814] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(765), 1, @@ -33778,12 +33915,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE, anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [15681] = 3, + [15831] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(737), 1, + ACTIONS(747), 1, anon_sym_EQ, - ACTIONS(735), 8, + ACTIONS(745), 8, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -33792,7 +33929,7 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE, anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [15698] = 3, + [15848] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1089), 1, @@ -33806,26 +33943,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, anon_sym_else, anon_sym_EQ_GT, - [15715] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(715), 1, - anon_sym_EQ, - ACTIONS(713), 8, - anon_sym_SEMI, - anon_sym_RBRACE, - anon_sym_COMMA, - anon_sym_RPAREN, - anon_sym_BANG, - anon_sym_PIPE, - anon_sym_DOT_DOT_DOT, - anon_sym_EQ_GT, - [15732] = 3, + [15865] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(757), 1, + ACTIONS(785), 1, anon_sym_EQ, - ACTIONS(755), 8, + ACTIONS(783), 8, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -33834,12 +33957,12 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE, anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [15749] = 3, + [15882] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(697), 1, + ACTIONS(717), 1, anon_sym_EQ, - ACTIONS(695), 8, + ACTIONS(715), 8, anon_sym_SEMI, anon_sym_RBRACE, anon_sym_COMMA, @@ -33848,48 +33971,21 @@ static uint16_t ts_small_parse_table[] = { anon_sym_PIPE, anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [15766] = 3, + [15899] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(761), 1, - anon_sym_EQ, - ACTIONS(759), 8, - anon_sym_SEMI, - anon_sym_RBRACE, + ACTIONS(1045), 1, + anon_sym_DOT_DOT, + ACTIONS(1091), 1, anon_sym_COMMA, - anon_sym_RPAREN, - anon_sym_BANG, - anon_sym_PIPE, - anon_sym_DOT_DOT_DOT, - anon_sym_EQ_GT, - [15783] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(753), 1, - anon_sym_EQ, - ACTIONS(751), 8, + ACTIONS(1040), 6, anon_sym_SEMI, anon_sym_RBRACE, - anon_sym_COMMA, anon_sym_RPAREN, - anon_sym_BANG, - anon_sym_PIPE, + anon_sym_RBRACK, anon_sym_DOT_DOT_DOT, anon_sym_EQ_GT, - [15800] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(1091), 1, - anon_sym_COLON_COLON, - ACTIONS(494), 7, - anon_sym_SEMI, - anon_sym_LBRACE, - anon_sym_COMMA, - anon_sym_LPAREN, - anon_sym_LBRACK, - anon_sym_DOT, - anon_sym_QMARK, - [15816] = 9, + [15917] = 9, ACTIONS(3), 1, sym_comment, ACTIONS(43), 1, @@ -33898,31 +33994,30 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, ACTIONS(1096), 1, sym_name, - STATE(602), 1, + STATE(579), 1, sym_struct_literal, - STATE(606), 1, + STATE(585), 1, sym_field_value, - STATE(632), 1, + STATE(634), 1, sym_field_values, STATE(704), 1, sym_identifier, - STATE(816), 1, + STATE(818), 1, sym_struct_initializer, - [15844] = 4, + [15945] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1025), 1, - anon_sym_DOT_DOT, ACTIONS(1098), 1, - anon_sym_COMMA, - ACTIONS(1020), 6, + anon_sym_COLON_COLON, + ACTIONS(494), 7, anon_sym_SEMI, - anon_sym_RBRACE, - anon_sym_RPAREN, - anon_sym_RBRACK, - anon_sym_DOT_DOT_DOT, - anon_sym_EQ_GT, - [15862] = 9, + anon_sym_LBRACE, + anon_sym_COMMA, + anon_sym_LPAREN, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_QMARK, + [15961] = 9, ACTIONS(3), 1, sym_comment, ACTIONS(43), 1, @@ -33931,141 +34026,117 @@ static uint16_t ts_small_parse_table[] = { anon_sym_DOT_DOT_DOT, ACTIONS(1096), 1, sym_name, - STATE(602), 1, + STATE(579), 1, sym_struct_literal, - STATE(606), 1, + STATE(585), 1, sym_field_value, - STATE(632), 1, + STATE(634), 1, sym_field_values, - STATE(693), 1, + STATE(696), 1, sym_struct_initializer, STATE(704), 1, sym_identifier, - [15890] = 7, + [15989] = 8, ACTIONS(1101), 1, anon_sym_BSLASH, - ACTIONS(1104), 1, + ACTIONS(1103), 1, anon_sym_DQUOTE, - ACTIONS(1106), 1, + ACTIONS(1105), 1, aux_sym_string_char_token1, - ACTIONS(1109), 1, + ACTIONS(1107), 1, sym_comment, - STATE(523), 1, - sym_escape_sequence, - STATE(524), 1, + STATE(518), 1, sym_named_escape, - STATE(461), 2, - sym_string_char, - aux_sym_string_chars_repeat1, - [15913] = 7, - ACTIONS(1109), 1, - sym_comment, - ACTIONS(1111), 1, - anon_sym_BSLASH, - ACTIONS(1113), 1, - aux_sym_string_char_token1, - STATE(523), 1, + STATE(540), 1, sym_escape_sequence, - STATE(524), 1, - sym_named_escape, - STATE(651), 1, + STATE(652), 1, sym_string_chars, - STATE(464), 2, + STATE(466), 2, sym_string_char, aux_sym_string_chars_repeat1, - [15936] = 7, - ACTIONS(1109), 1, - sym_comment, - ACTIONS(1111), 1, + [16015] = 8, + ACTIONS(1101), 1, anon_sym_BSLASH, - ACTIONS(1113), 1, + ACTIONS(1105), 1, aux_sym_string_char_token1, - STATE(523), 1, - sym_escape_sequence, - STATE(524), 1, - sym_named_escape, - STATE(643), 1, - sym_string_chars, - STATE(464), 2, - sym_string_char, - aux_sym_string_chars_repeat1, - [15959] = 7, - ACTIONS(1109), 1, + ACTIONS(1107), 1, sym_comment, - ACTIONS(1111), 1, - anon_sym_BSLASH, - ACTIONS(1113), 1, - aux_sym_string_char_token1, - ACTIONS(1115), 1, + ACTIONS(1109), 1, anon_sym_DQUOTE, - STATE(523), 1, - sym_escape_sequence, - STATE(524), 1, + STATE(518), 1, sym_named_escape, - STATE(461), 2, + STATE(540), 1, + sym_escape_sequence, + STATE(646), 1, + sym_string_chars, + STATE(466), 2, sym_string_char, aux_sym_string_chars_repeat1, - [15982] = 8, + [16041] = 8, ACTIONS(3), 1, sym_comment, ACTIONS(43), 1, anon_sym_struct, ACTIONS(1096), 1, sym_name, - ACTIONS(1117), 1, + ACTIONS(1111), 1, anon_sym_RBRACE, - ACTIONS(1119), 1, + ACTIONS(1113), 1, anon_sym_DOT_DOT_DOT, - STATE(597), 1, + STATE(565), 1, sym_field_value, - STATE(602), 1, + STATE(579), 1, sym_struct_literal, STATE(704), 1, sym_identifier, - [16007] = 7, - ACTIONS(3), 1, + [16066] = 7, + ACTIONS(1101), 1, + anon_sym_BSLASH, + ACTIONS(1105), 1, + aux_sym_string_char_token1, + ACTIONS(1107), 1, sym_comment, - ACTIONS(43), 1, - anon_sym_struct, - ACTIONS(1096), 1, - sym_name, - ACTIONS(1121), 1, - anon_sym_RBRACE, - STATE(597), 1, - sym_field_value, - STATE(602), 1, - sym_struct_literal, - STATE(704), 1, - sym_identifier, - [16029] = 5, - ACTIONS(3), 1, + ACTIONS(1115), 1, + anon_sym_DQUOTE, + STATE(518), 1, + sym_named_escape, + STATE(540), 1, + sym_escape_sequence, + STATE(467), 2, + sym_string_char, + aux_sym_string_chars_repeat1, + [16089] = 7, + ACTIONS(1107), 1, sym_comment, - ACTIONS(389), 1, - anon_sym_struct, - ACTIONS(391), 1, - anon_sym_union, - ACTIONS(1123), 1, - sym_name, - STATE(558), 3, - sym_struct_type, - sym_union_type, - sym_identifier, - [16047] = 7, + ACTIONS(1117), 1, + anon_sym_BSLASH, + ACTIONS(1120), 1, + anon_sym_DQUOTE, + ACTIONS(1122), 1, + aux_sym_string_char_token1, + STATE(518), 1, + sym_named_escape, + STATE(540), 1, + sym_escape_sequence, + STATE(467), 2, + sym_string_char, + aux_sym_string_chars_repeat1, + [16112] = 7, ACTIONS(3), 1, sym_comment, ACTIONS(1125), 1, anon_sym_ATsymbol, ACTIONS(1127), 1, sym_name, - STATE(563), 1, + STATE(555), 1, sym_decl_attr, - STATE(587), 1, + STATE(600), 1, sym_global_binding, - STATE(754), 1, - sym_identifier, - STATE(757), 1, + STATE(657), 1, sym_global_bindings, - [16069] = 2, + STATE(756), 1, + sym_identifier, + [16134] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1129), 6, @@ -34075,2318 +34146,2346 @@ static uint16_t ts_small_parse_table[] = { anon_sym_ATinit, anon_sym_ATtest, anon_sym_ATnoreturn, - [16081] = 3, + [16146] = 7, ACTIONS(3), 1, sym_comment, - ACTIONS(1131), 1, - anon_sym_COMMA, - ACTIONS(1020), 5, - anon_sym_SEMI, - anon_sym_RPAREN, - anon_sym_RBRACK, - anon_sym_DOT_DOT, - anon_sym_else, - [16095] = 2, + ACTIONS(43), 1, + anon_sym_struct, + ACTIONS(1096), 1, + sym_name, + STATE(579), 1, + sym_struct_literal, + STATE(585), 1, + sym_field_value, + STATE(631), 1, + sym_field_values, + STATE(704), 1, + sym_identifier, + [16168] = 6, ACTIONS(3), 1, sym_comment, - ACTIONS(1133), 6, - anon_sym_ATsymbol, - anon_sym_fn, - anon_sym_ATfini, - anon_sym_ATinit, - anon_sym_ATtest, - anon_sym_ATnoreturn, - [16107] = 7, + ACTIONS(1131), 1, + anon_sym_RPAREN, + STATE(532), 1, + sym_parameter, + STATE(533), 1, + sym_parameters, + STATE(658), 1, + sym_parameter_list, + ACTIONS(1133), 2, + anon_sym__, + sym_name, + [16188] = 7, ACTIONS(3), 1, sym_comment, ACTIONS(1125), 1, anon_sym_ATsymbol, ACTIONS(1127), 1, sym_name, - STATE(563), 1, + STATE(555), 1, sym_decl_attr, - STATE(587), 1, + STATE(600), 1, sym_global_binding, - STATE(654), 1, - sym_global_bindings, - STATE(754), 1, + STATE(756), 1, sym_identifier, - [16129] = 7, + STATE(759), 1, + sym_global_bindings, + [16210] = 7, ACTIONS(3), 1, sym_comment, ACTIONS(43), 1, anon_sym_struct, ACTIONS(1096), 1, sym_name, - STATE(602), 1, + STATE(568), 1, + sym_field_values, + STATE(579), 1, sym_struct_literal, - STATE(606), 1, + STATE(585), 1, sym_field_value, - STATE(627), 1, - sym_field_values, STATE(704), 1, sym_identifier, - [16151] = 2, - ACTIONS(3), 1, - sym_comment, - ACTIONS(1135), 6, - anon_sym_ATsymbol, - anon_sym_fn, - anon_sym_ATfini, - anon_sym_ATinit, - anon_sym_ATtest, - anon_sym_ATnoreturn, - [16163] = 6, - ACTIONS(3), 1, - sym_comment, - ACTIONS(1137), 1, - anon_sym_RPAREN, - STATE(527), 1, - sym_parameters, - STATE(528), 1, - sym_parameter, - STATE(656), 1, - sym_parameter_list, - ACTIONS(1139), 2, - anon_sym__, - sym_name, - [16183] = 7, + [16232] = 7, ACTIONS(3), 1, sym_comment, ACTIONS(43), 1, anon_sym_struct, ACTIONS(1096), 1, sym_name, - ACTIONS(1141), 1, + ACTIONS(1135), 1, anon_sym_RBRACE, - STATE(597), 1, + STATE(565), 1, sym_field_value, - STATE(602), 1, + STATE(579), 1, sym_struct_literal, STATE(704), 1, sym_identifier, - [16205] = 6, + [16254] = 6, ACTIONS(3), 1, sym_comment, - ACTIONS(1143), 1, + ACTIONS(1137), 1, anon_sym_RPAREN, - STATE(527), 1, - sym_parameters, - STATE(528), 1, + STATE(532), 1, sym_parameter, - STATE(644), 1, + STATE(533), 1, + sym_parameters, + STATE(647), 1, sym_parameter_list, - ACTIONS(1139), 2, + ACTIONS(1133), 2, anon_sym__, sym_name, - [16225] = 7, + [16274] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(389), 1, + anon_sym_struct, + ACTIONS(391), 1, + anon_sym_union, + ACTIONS(1139), 1, + sym_name, + STATE(562), 3, + sym_struct_type, + sym_union_type, + sym_identifier, + [16292] = 7, ACTIONS(3), 1, sym_comment, ACTIONS(43), 1, anon_sym_struct, ACTIONS(1096), 1, sym_name, - STATE(569), 1, - sym_field_values, - STATE(602), 1, - sym_struct_literal, - STATE(606), 1, + ACTIONS(1141), 1, + anon_sym_RBRACE, + STATE(565), 1, sym_field_value, + STATE(579), 1, + sym_struct_literal, STATE(704), 1, sym_identifier, - [16247] = 3, + [16314] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1145), 1, - anon_sym_else, - ACTIONS(1013), 4, + ACTIONS(1143), 1, + anon_sym_COMMA, + ACTIONS(1040), 5, anon_sym_SEMI, anon_sym_RPAREN, anon_sym_RBRACK, anon_sym_DOT_DOT, - [16260] = 4, + anon_sym_else, + [16328] = 2, ACTIONS(3), 1, sym_comment, - STATE(217), 1, - sym_binary_digits, - ACTIONS(424), 2, - anon_sym_0, - anon_sym_1, - STATE(171), 2, - sym_binary_digit, - aux_sym_binary_digits_repeat1, - [16275] = 5, + ACTIONS(1145), 6, + anon_sym_ATsymbol, + anon_sym_fn, + anon_sym_ATfini, + anon_sym_ATinit, + anon_sym_ATtest, + anon_sym_ATnoreturn, + [16340] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1148), 1, - anon_sym_RPAREN, - ACTIONS(1150), 1, - anon_sym_DOT_DOT_DOT, - STATE(521), 1, - sym_parameter, - ACTIONS(1139), 2, - anon_sym__, - sym_name, - [16292] = 3, + ACTIONS(1147), 6, + anon_sym_ATsymbol, + anon_sym_fn, + anon_sym_ATfini, + anon_sym_ATinit, + anon_sym_ATtest, + anon_sym_ATnoreturn, + [16352] = 6, + ACTIONS(1107), 1, + sym_comment, + ACTIONS(1149), 1, + aux_sym_rune_token1, + ACTIONS(1151), 1, + anon_sym_BSLASH, + STATE(673), 1, + sym_rune, + STATE(702), 1, + sym_named_escape, + STATE(781), 1, + sym_escape_sequence, + [16371] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1152), 1, + ACTIONS(1153), 1, anon_sym_COMMA, - ACTIONS(1020), 4, + ACTIONS(1040), 4, anon_sym_SEMI, anon_sym_RPAREN, anon_sym_RBRACK, anon_sym_DOT_DOT, - [16305] = 3, + [16384] = 4, + ACTIONS(3), 1, + sym_comment, + STATE(159), 1, + sym_binary_digits, + ACTIONS(354), 2, + anon_sym_0, + anon_sym_1, + STATE(150), 2, + sym_binary_digit, + aux_sym_binary_digits_repeat1, + [16399] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1154), 1, + ACTIONS(1155), 1, anon_sym_RPAREN, ACTIONS(509), 4, anon_sym_LPAREN, anon_sym_LBRACK, anon_sym_DOT, anon_sym_QMARK, - [16318] = 3, + [16412] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(1156), 1, + ACTIONS(1157), 1, anon_sym_RPAREN, - ACTIONS(509), 4, - anon_sym_LPAREN, - anon_sym_LBRACK, - anon_sym_DOT, - anon_sym_QMARK, - [16331] = 6, - ACTIONS(1109), 1, + ACTIONS(1159), 1, + anon_sym_DOT_DOT_DOT, + STATE(528), 1, + sym_parameter, + ACTIONS(1133), 2, + anon_sym__, + sym_name, + [16429] = 3, + ACTIONS(3), 1, sym_comment, - ACTIONS(1158), 1, - aux_sym_rune_token1, - ACTIONS(1160), 1, - anon_sym_BSLASH, - STATE(670), 1, - sym_rune, - STATE(701), 1, - sym_named_escape, - STATE(784), 1, - sym_escape_sequence, - [16350] = 4, + ACTIONS(1161), 1, + anon_sym_else, + ACTIONS(1013), 4, + anon_sym_SEMI, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT, + [16442] = 4, ACTIONS(3), 1, sym_comment, - STATE(159), 1, + STATE(219), 1, sym_binary_digits, - ACTIONS(347), 2, + ACTIONS(427), 2, anon_sym_0, anon_sym_1, - STATE(144), 2, + STATE(174), 2, sym_binary_digit, aux_sym_binary_digits_repeat1, - [16365] = 3, - ACTIONS(3), 1, + [16457] = 6, + ACTIONS(1107), 1, sym_comment, - ACTIONS(1162), 1, - anon_sym_RPAREN, - ACTIONS(509), 4, - anon_sym_LPAREN, - anon_sym_LBRACK, - anon_sym_DOT, - anon_sym_QMARK, - [16378] = 3, + ACTIONS(1149), 1, + aux_sym_rune_token1, + ACTIONS(1151), 1, + anon_sym_BSLASH, + STATE(702), 1, + sym_named_escape, + STATE(781), 1, + sym_escape_sequence, + STATE(787), 1, + sym_rune, + [16476] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1164), 1, + ACTIONS(1163), 1, anon_sym_RPAREN, ACTIONS(509), 4, anon_sym_LPAREN, anon_sym_LBRACK, anon_sym_DOT, anon_sym_QMARK, - [16391] = 6, - ACTIONS(1109), 1, - sym_comment, - ACTIONS(1158), 1, - aux_sym_rune_token1, - ACTIONS(1160), 1, - anon_sym_BSLASH, - STATE(701), 1, - sym_named_escape, - STATE(784), 1, - sym_escape_sequence, - STATE(785), 1, - sym_rune, - [16410] = 3, + [16489] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1166), 1, + ACTIONS(1165), 1, anon_sym_else, ACTIONS(1013), 4, anon_sym_SEMI, anon_sym_RPAREN, anon_sym_RBRACK, anon_sym_DOT_DOT, - [16423] = 5, + [16502] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(59), 1, - anon_sym_DQUOTE, ACTIONS(1168), 1, anon_sym_RPAREN, - STATE(272), 1, - aux_sym_string_constant_repeat1, - STATE(762), 1, - sym_string_constant, - [16439] = 4, + ACTIONS(509), 4, + anon_sym_LPAREN, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_QMARK, + [16515] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(954), 1, - anon_sym_COLON_COLON, ACTIONS(1170), 1, - anon_sym_COLON, - ACTIONS(494), 2, - anon_sym_RBRACE, - anon_sym_COMMA, - [16453] = 5, + anon_sym_RPAREN, + ACTIONS(509), 4, + anon_sym_LPAREN, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_QMARK, + [16528] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1127), 1, + sym_name, + STATE(559), 1, + sym_constant_binding, + STATE(654), 1, + sym_constant_bindings, + STATE(744), 1, + sym_identifier, + [16544] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1172), 1, sym_name, - STATE(416), 1, + STATE(452), 1, sym_bindings, - STATE(422), 1, + STATE(459), 1, sym_binding, - STATE(575), 1, + STATE(619), 1, sym_binding_names, - [16469] = 5, + [16560] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(1172), 1, + ACTIONS(1174), 1, sym_name, - STATE(422), 1, + STATE(436), 1, sym_binding, - STATE(440), 1, + STATE(445), 1, sym_bindings, - STATE(575), 1, + STATE(573), 1, sym_binding_names, - [16485] = 5, + [16576] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1174), 1, sym_name, - STATE(440), 1, + STATE(452), 1, sym_bindings, - STATE(482), 1, + STATE(478), 1, sym_binding, - STATE(631), 1, + STATE(573), 1, sym_binding_names, - [16501] = 5, + [16592] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(494), 1, - anon_sym_LBRACE, - ACTIONS(954), 1, - anon_sym_COLON_COLON, ACTIONS(1176), 1, - anon_sym_EQ, + anon_sym_RBRACE, ACTIONS(1178), 1, + sym_name, + STATE(575), 1, + sym_enum_value, + STATE(786), 1, + sym_enum_values, + [16608] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(950), 1, + anon_sym_COLON_COLON, + ACTIONS(1180), 1, anon_sym_COLON, - [16517] = 5, + ACTIONS(494), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [16622] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(1172), 1, + ACTIONS(1174), 1, sym_name, - STATE(436), 1, + STATE(443), 1, sym_bindings, - STATE(470), 1, + STATE(478), 1, sym_binding, - STATE(575), 1, + STATE(573), 1, sym_binding_names, - [16533] = 5, + [16638] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1172), 1, sym_name, - STATE(416), 1, + STATE(445), 1, sym_bindings, - STATE(470), 1, + STATE(459), 1, sym_binding, - STATE(575), 1, + STATE(619), 1, + sym_binding_names, + [16654] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1127), 1, + sym_name, + STATE(559), 1, + sym_constant_binding, + STATE(744), 1, + sym_identifier, + STATE(749), 1, + sym_constant_bindings, + [16670] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1174), 1, + sym_name, + STATE(445), 1, + sym_bindings, + STATE(478), 1, + sym_binding, + STATE(573), 1, sym_binding_names, - [16549] = 5, + [16686] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(59), 1, anon_sym_DQUOTE, - ACTIONS(1180), 1, + ACTIONS(1182), 1, anon_sym_RPAREN, - STATE(272), 1, + STATE(276), 1, aux_sym_string_constant_repeat1, - STATE(687), 1, + STATE(760), 1, sym_string_constant, - [16565] = 5, - ACTIONS(3), 1, - sym_comment, - ACTIONS(679), 1, - anon_sym_LPAREN, - ACTIONS(681), 1, - anon_sym_LBRACK, - ACTIONS(683), 1, - anon_sym_QMARK, - ACTIONS(1182), 1, - anon_sym_DOT, - [16581] = 5, + [16702] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1172), 1, sym_name, - STATE(440), 1, + STATE(443), 1, sym_bindings, - STATE(470), 1, + STATE(459), 1, sym_binding, - STATE(575), 1, + STATE(619), 1, sym_binding_names, - [16597] = 5, - ACTIONS(3), 1, - sym_comment, - ACTIONS(679), 1, - anon_sym_LPAREN, - ACTIONS(683), 1, - anon_sym_QMARK, - ACTIONS(685), 1, - anon_sym_LBRACK, - ACTIONS(1184), 1, - anon_sym_DOT, - [16613] = 4, + [16718] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(954), 1, + ACTIONS(950), 1, anon_sym_COLON_COLON, - ACTIONS(1186), 1, + ACTIONS(1184), 1, anon_sym_COLON, ACTIONS(494), 2, anon_sym_BANG, anon_sym_EQ_GT, - [16627] = 5, + [16732] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(1174), 1, + ACTIONS(1127), 1, sym_name, - STATE(440), 1, - sym_bindings, - STATE(459), 1, - sym_binding, - STATE(631), 1, - sym_binding_names, - [16643] = 5, + ACTIONS(1186), 1, + anon_sym_SEMI, + STATE(697), 1, + sym_type_bindings, + STATE(738), 1, + sym_identifier, + [16748] = 5, ACTIONS(3), 1, sym_comment, ACTIONS(1174), 1, sym_name, - STATE(416), 1, - sym_bindings, - STATE(482), 1, + STATE(436), 1, sym_binding, - STATE(631), 1, + STATE(452), 1, + sym_bindings, + STATE(573), 1, sym_binding_names, - [16659] = 5, + [16764] = 5, ACTIONS(3), 1, sym_comment, + ACTIONS(494), 1, + anon_sym_LBRACE, + ACTIONS(950), 1, + anon_sym_COLON_COLON, ACTIONS(1188), 1, - anon_sym_RBRACE, + anon_sym_EQ, ACTIONS(1190), 1, - sym_name, - STATE(617), 1, - sym_enum_value, - STATE(783), 1, - sym_enum_values, - [16675] = 5, + anon_sym_COLON, + [16780] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(1174), 1, - sym_name, - STATE(436), 1, - sym_bindings, - STATE(459), 1, - sym_binding, - STATE(631), 1, - sym_binding_names, - [16691] = 5, + ACTIONS(679), 1, + anon_sym_LPAREN, + ACTIONS(681), 1, + anon_sym_LBRACK, + ACTIONS(683), 1, + anon_sym_QMARK, + ACTIONS(1192), 1, + anon_sym_DOT, + [16796] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(1172), 1, + ACTIONS(1174), 1, sym_name, - STATE(422), 1, - sym_binding, STATE(436), 1, + sym_binding, + STATE(443), 1, sym_bindings, - STATE(575), 1, + STATE(573), 1, sym_binding_names, - [16707] = 4, + [16812] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(954), 1, + ACTIONS(950), 1, anon_sym_COLON_COLON, - ACTIONS(1192), 1, + ACTIONS(1194), 1, anon_sym_COLON, ACTIONS(494), 2, anon_sym_RBRACE, anon_sym_COMMA, - [16721] = 5, + [16826] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(1174), 1, + ACTIONS(59), 1, + anon_sym_DQUOTE, + ACTIONS(1196), 1, + anon_sym_RPAREN, + STATE(276), 1, + aux_sym_string_constant_repeat1, + STATE(690), 1, + sym_string_constant, + [16842] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1172), 1, sym_name, - STATE(416), 1, + STATE(443), 1, sym_bindings, - STATE(459), 1, + STATE(482), 1, sym_binding, - STATE(631), 1, + STATE(619), 1, sym_binding_names, - [16737] = 5, + [16858] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(1127), 1, + ACTIONS(1172), 1, sym_name, - STATE(618), 1, - sym_constant_binding, - STATE(652), 1, - sym_constant_bindings, - STATE(742), 1, - sym_identifier, - [16753] = 5, - ACTIONS(3), 1, - sym_comment, - ACTIONS(1127), 1, - sym_name, - STATE(618), 1, - sym_constant_binding, - STATE(742), 1, - sym_identifier, - STATE(747), 1, - sym_constant_bindings, - [16769] = 5, - ACTIONS(3), 1, - sym_comment, - ACTIONS(1127), 1, - sym_name, - ACTIONS(1194), 1, - anon_sym_SEMI, - STATE(692), 1, - sym_type_bindings, - STATE(736), 1, - sym_identifier, - [16785] = 5, + STATE(452), 1, + sym_bindings, + STATE(482), 1, + sym_binding, + STATE(619), 1, + sym_binding_names, + [16874] = 5, ACTIONS(3), 1, sym_comment, - ACTIONS(1174), 1, + ACTIONS(1172), 1, sym_name, - STATE(436), 1, + STATE(445), 1, sym_bindings, STATE(482), 1, sym_binding, - STATE(631), 1, + STATE(619), 1, sym_binding_names, - [16801] = 3, + [16890] = 5, ACTIONS(3), 1, sym_comment, + ACTIONS(679), 1, + anon_sym_LPAREN, + ACTIONS(683), 1, + anon_sym_QMARK, + ACTIONS(685), 1, + anon_sym_LBRACK, ACTIONS(1198), 1, - anon_sym_assert, - ACTIONS(1196), 2, - anon_sym_let, - anon_sym_const, - [16812] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(1200), 1, - anon_sym_RPAREN, - ACTIONS(1202), 1, - anon_sym_PIPE, - STATE(516), 1, - aux_sym_tagged_types_repeat1, - [16825] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(1205), 1, - anon_sym_COMMA, - ACTIONS(1207), 1, - anon_sym_RBRACK, - ACTIONS(1209), 1, - anon_sym_DOT_DOT_DOT, - [16838] = 4, + anon_sym_DOT, + [16906] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(59), 1, anon_sym_DQUOTE, - STATE(272), 1, + STATE(276), 1, aux_sym_string_constant_repeat1, - STATE(711), 1, + STATE(699), 1, sym_string_constant, - [16851] = 4, - ACTIONS(3), 1, + [16919] = 2, + ACTIONS(1107), 1, sym_comment, - ACTIONS(59), 1, + ACTIONS(1200), 3, + anon_sym_BSLASH, anon_sym_DQUOTE, - STATE(272), 1, - aux_sym_string_constant_repeat1, - STATE(707), 1, - sym_string_constant, - [16864] = 3, + aux_sym_string_char_token1, + [16928] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1213), 1, - anon_sym_EQ, - ACTIONS(1211), 2, - anon_sym_SEMI, + ACTIONS(1204), 1, anon_sym_COMMA, - [16875] = 2, + ACTIONS(1202), 2, + anon_sym_EQ, + anon_sym_COLON, + [16939] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(1215), 3, - anon_sym_COMMA, - anon_sym_RPAREN, - anon_sym_DOT_DOT_DOT, - [16884] = 4, + ACTIONS(1178), 1, + sym_name, + STATE(575), 1, + sym_enum_value, + STATE(737), 1, + sym_enum_values, + [16952] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1127), 1, + sym_name, + STATE(738), 1, + sym_identifier, + STATE(743), 1, + sym_type_bindings, + [16965] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1208), 1, + anon_sym_assert, + ACTIONS(1206), 2, + anon_sym_let, + anon_sym_const, + [16976] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1208), 1, + anon_sym_assert, + ACTIONS(1210), 2, + anon_sym_let, + anon_sym_const, + [16987] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1178), 1, + sym_name, + STATE(575), 1, + sym_enum_value, + STATE(683), 1, + sym_enum_values, + [17000] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(59), 1, anon_sym_DQUOTE, - STATE(272), 1, + STATE(276), 1, aux_sym_string_constant_repeat1, - STATE(748), 1, + STATE(714), 1, sym_string_constant, - [16897] = 2, - ACTIONS(1109), 1, + [17013] = 4, + ACTIONS(3), 1, sym_comment, - ACTIONS(1217), 3, - anon_sym_BSLASH, - anon_sym_DQUOTE, - aux_sym_string_char_token1, - [16906] = 2, - ACTIONS(1109), 1, + ACTIONS(1212), 1, + anon_sym_RPAREN, + ACTIONS(1214), 1, + anon_sym_PIPE, + STATE(526), 1, + aux_sym_tagged_types_repeat1, + [17026] = 2, + ACTIONS(3), 1, sym_comment, - ACTIONS(1219), 3, - anon_sym_BSLASH, - anon_sym_DQUOTE, - aux_sym_string_char_token1, - [16915] = 4, + ACTIONS(1217), 3, + anon_sym_struct, + anon_sym_union, + sym_name, + [17035] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1221), 1, + ACTIONS(1219), 3, anon_sym_COMMA, - ACTIONS(1223), 1, anon_sym_RPAREN, - ACTIONS(1225), 1, anon_sym_DOT_DOT_DOT, - [16928] = 4, + [17044] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1190), 1, - sym_name, - STATE(617), 1, - sym_enum_value, - STATE(664), 1, - sym_enum_values, - [16941] = 4, + ACTIONS(1221), 1, + anon_sym_EQ, + ACTIONS(1223), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [17055] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(1227), 1, + ACTIONS(1204), 1, anon_sym_COMMA, + ACTIONS(1225), 1, + anon_sym_EQ, + ACTIONS(1227), 1, + anon_sym_COLON, + [17068] = 4, + ACTIONS(3), 1, + sym_comment, ACTIONS(1229), 1, - anon_sym_RPAREN, + anon_sym_COMMA, ACTIONS(1231), 1, + anon_sym_RBRACK, + ACTIONS(1233), 1, anon_sym_DOT_DOT_DOT, - [16954] = 2, + [17081] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1233), 3, + ACTIONS(1235), 3, anon_sym_COMMA, anon_sym_RPAREN, anon_sym_DOT_DOT_DOT, - [16963] = 3, + [17090] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1237), 1, - anon_sym_EQ, - ACTIONS(1235), 2, - anon_sym_SEMI, anon_sym_COMMA, - [16974] = 3, - ACTIONS(3), 1, - sym_comment, ACTIONS(1239), 1, - anon_sym_EQ, - ACTIONS(1241), 2, - anon_sym_RBRACE, - anon_sym_COMMA, - [16985] = 4, + anon_sym_RPAREN, + ACTIONS(1241), 1, + anon_sym_DOT_DOT_DOT, + [17103] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(494), 1, anon_sym_SEMI, - ACTIONS(1091), 1, + ACTIONS(1098), 1, anon_sym_COLON_COLON, ACTIONS(1243), 1, anon_sym_EQ, - [16998] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(1190), 1, - sym_name, - STATE(617), 1, - sym_enum_value, - STATE(739), 1, - sym_enum_values, - [17011] = 4, + [17116] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(59), 1, anon_sym_DQUOTE, - STATE(272), 1, + STATE(276), 1, aux_sym_string_constant_repeat1, - STATE(642), 1, + STATE(645), 1, sym_string_constant, - [17024] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(1190), 1, - sym_name, - STATE(617), 1, - sym_enum_value, - STATE(691), 1, - sym_enum_values, - [17037] = 3, + [17129] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1198), 1, - anon_sym_assert, + ACTIONS(1247), 1, + anon_sym_EQ, ACTIONS(1245), 2, - anon_sym_let, - anon_sym_const, - [17048] = 4, + anon_sym_SEMI, + anon_sym_COMMA, + [17140] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(1247), 1, - anon_sym_RBRACE, + ACTIONS(1204), 1, + anon_sym_COMMA, ACTIONS(1249), 1, - sym_name, - STATE(671), 1, - sym_name_list, - [17061] = 2, - ACTIONS(1109), 1, + anon_sym_EQ, + ACTIONS(1251), 1, + anon_sym_COLON, + [17153] = 2, + ACTIONS(1107), 1, sym_comment, - ACTIONS(1251), 3, + ACTIONS(1253), 3, anon_sym_BSLASH, anon_sym_DQUOTE, aux_sym_string_char_token1, - [17070] = 2, - ACTIONS(1109), 1, + [17162] = 2, + ACTIONS(1107), 1, sym_comment, - ACTIONS(1253), 3, + ACTIONS(1255), 3, anon_sym_BSLASH, anon_sym_DQUOTE, aux_sym_string_char_token1, - [17079] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(1257), 1, - anon_sym_COMMA, - ACTIONS(1255), 2, - anon_sym_EQ, - anon_sym_COLON, - [17090] = 4, - ACTIONS(3), 1, + [17171] = 2, + ACTIONS(1107), 1, sym_comment, - ACTIONS(1127), 1, - sym_name, - STATE(736), 1, - sym_identifier, - STATE(741), 1, - sym_type_bindings, - [17103] = 4, + ACTIONS(1257), 3, + anon_sym_BSLASH, + anon_sym_DQUOTE, + aux_sym_string_char_token1, + [17180] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(1257), 1, - anon_sym_COMMA, ACTIONS(1259), 1, - anon_sym_EQ, + anon_sym_COMMA, ACTIONS(1261), 1, - anon_sym_COLON, - [17116] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(59), 1, - anon_sym_DQUOTE, - STATE(272), 1, - aux_sym_string_constant_repeat1, - STATE(732), 1, - sym_string_constant, - [17129] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(1198), 1, - anon_sym_assert, - ACTIONS(1263), 2, - anon_sym_let, - anon_sym_const, - [17140] = 3, + anon_sym_RPAREN, + ACTIONS(1263), 1, + anon_sym_DOT_DOT_DOT, + [17193] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1198), 1, + ACTIONS(1208), 1, anon_sym_assert, ACTIONS(1265), 2, anon_sym_let, anon_sym_const, - [17151] = 4, + [17204] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1257), 1, - anon_sym_COMMA, - ACTIONS(1267), 1, - anon_sym_EQ, ACTIONS(1269), 1, - anon_sym_COLON, - [17164] = 4, + anon_sym_EQ, + ACTIONS(1267), 2, + anon_sym_SEMI, + anon_sym_COMMA, + [17215] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1271), 1, anon_sym_RPAREN, ACTIONS(1273), 1, anon_sym_PIPE, - STATE(516), 1, + STATE(545), 1, aux_sym_tagged_types_repeat1, - [17177] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(1190), 1, - sym_name, - STATE(617), 1, - sym_enum_value, - STATE(680), 1, - sym_enum_values, - [17190] = 4, - ACTIONS(3), 1, - sym_comment, - ACTIONS(59), 1, - anon_sym_DQUOTE, - STATE(272), 1, - aux_sym_string_constant_repeat1, - STATE(696), 1, - sym_string_constant, - [17203] = 4, + [17228] = 4, ACTIONS(3), 1, sym_comment, ACTIONS(1273), 1, anon_sym_PIPE, ACTIONS(1275), 1, anon_sym_RPAREN, - STATE(546), 1, + STATE(526), 1, aux_sym_tagged_types_repeat1, - [17216] = 2, + [17241] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1277), 3, - anon_sym_COMMA, - anon_sym_RPAREN, - anon_sym_DOT_DOT_DOT, - [17225] = 2, + ACTIONS(1208), 1, + anon_sym_assert, + ACTIONS(1277), 2, + anon_sym_let, + anon_sym_const, + [17252] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(1279), 3, - anon_sym_struct, - anon_sym_union, + ACTIONS(1178), 1, sym_name, - [17234] = 3, + STATE(575), 1, + sym_enum_value, + STATE(667), 1, + sym_enum_values, + [17265] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(1281), 1, + ACTIONS(1279), 1, anon_sym_RBRACE, - ACTIONS(1283), 1, - anon_sym_COMMA, - [17244] = 2, - ACTIONS(3), 1, - sym_comment, - ACTIONS(1285), 2, - anon_sym_SEMI, - anon_sym_COMMA, - [17252] = 2, + ACTIONS(1281), 1, + sym_name, + STATE(671), 1, + sym_name_list, + [17278] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(1287), 2, - anon_sym_RBRACE, - anon_sym_COMMA, - [17260] = 2, + ACTIONS(59), 1, + anon_sym_DQUOTE, + STATE(276), 1, + aux_sym_string_constant_repeat1, + STATE(748), 1, + sym_string_constant, + [17291] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(1289), 2, - anon_sym_RBRACE, - anon_sym_COMMA, - [17268] = 3, + ACTIONS(1178), 1, + sym_name, + STATE(575), 1, + sym_enum_value, + STATE(650), 1, + sym_enum_values, + [17304] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(1291), 1, - anon_sym_RBRACK, - ACTIONS(1293), 1, - anon_sym_DOT_DOT, - [17278] = 2, + ACTIONS(59), 1, + anon_sym_DQUOTE, + STATE(276), 1, + aux_sym_string_constant_repeat1, + STATE(733), 1, + sym_string_constant, + [17317] = 4, ACTIONS(3), 1, sym_comment, - ACTIONS(1295), 2, - anon_sym_RBRACE, - anon_sym_COMMA, - [17286] = 2, + ACTIONS(59), 1, + anon_sym_DQUOTE, + STATE(276), 1, + aux_sym_string_constant_repeat1, + STATE(710), 1, + sym_string_constant, + [17330] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1297), 2, - anon_sym_RBRACE, + ACTIONS(1283), 3, anon_sym_COMMA, - [17294] = 2, + anon_sym_RPAREN, + anon_sym_DOT_DOT_DOT, + [17339] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1200), 2, + ACTIONS(1157), 1, anon_sym_RPAREN, - anon_sym_PIPE, - [17302] = 3, + ACTIONS(1285), 1, + anon_sym_COMMA, + [17349] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1299), 1, + ACTIONS(1127), 1, sym_name, - STATE(598), 1, + STATE(706), 1, sym_identifier, - [17312] = 3, + [17359] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1301), 1, - sym_name, - STATE(197), 1, - sym_identifier, - [17322] = 3, + ACTIONS(1287), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [17367] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1127), 1, - sym_name, - STATE(572), 1, - sym_identifier, - [17332] = 3, + ACTIONS(1289), 1, + anon_sym_RBRACK, + ACTIONS(1291), 1, + anon_sym_DOT_DOT, + [17377] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1127), 1, + ACTIONS(1293), 1, sym_name, - STATE(703), 1, + STATE(616), 1, sym_identifier, - [17342] = 3, + [17387] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1303), 1, + ACTIONS(1295), 1, + anon_sym_SEMI, + ACTIONS(1297), 1, + anon_sym_COMMA, + [17397] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1299), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [17405] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1301), 1, anon_sym_COMMA, - ACTIONS(1305), 1, + ACTIONS(1303), 1, anon_sym_RPAREN, - [17352] = 3, + [17415] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1307), 1, + ACTIONS(1305), 2, anon_sym_RBRACE, - ACTIONS(1309), 1, anon_sym_COMMA, - [17362] = 3, + [17423] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1164), 1, - anon_sym_RPAREN, - ACTIONS(1311), 1, + ACTIONS(1307), 1, anon_sym_COMMA, - [17372] = 3, + ACTIONS(1309), 1, + anon_sym_RPAREN, + [17433] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1313), 1, + ACTIONS(1311), 1, anon_sym_COMMA, - ACTIONS(1315), 1, + ACTIONS(1313), 1, anon_sym_RPAREN, - [17382] = 2, + [17443] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1317), 2, - anon_sym_SEMI, + ACTIONS(1315), 2, + anon_sym_RBRACE, anon_sym_COMMA, - [17390] = 3, + [17451] = 3, ACTIONS(3), 1, sym_comment, + ACTIONS(1317), 1, + anon_sym_COMMA, ACTIONS(1319), 1, - anon_sym_RBRACE, + anon_sym_RPAREN, + [17461] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1155), 1, + anon_sym_RPAREN, ACTIONS(1321), 1, anon_sym_COMMA, - [17400] = 3, + [17471] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1323), 1, - anon_sym_SEMI, - ACTIONS(1325), 1, - anon_sym_EQ, - [17410] = 2, - ACTIONS(3), 1, - sym_comment, - ACTIONS(1327), 2, anon_sym_RBRACE, + ACTIONS(1325), 1, anon_sym_COMMA, - [17418] = 3, + [17481] = 3, ACTIONS(3), 1, sym_comment, + ACTIONS(1327), 1, + anon_sym_COMMA, ACTIONS(1329), 1, - anon_sym_LPAREN, - STATE(611), 1, - sym_prototype, - [17428] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(1127), 1, - sym_name, - STATE(588), 1, - sym_identifier, - [17438] = 3, + anon_sym_RPAREN, + [17491] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1331), 1, anon_sym_SEMI, ACTIONS(1333), 1, - anon_sym_RPAREN, - [17448] = 3, + anon_sym_EQ, + [17501] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1267), 1, - anon_sym_EQ, - ACTIONS(1269), 1, - anon_sym_COLON, - [17458] = 2, + ACTIONS(1335), 1, + anon_sym_LPAREN, + STATE(570), 1, + sym_prototype, + [17511] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1335), 2, - anon_sym_RBRACE, - anon_sym_COMMA, - [17466] = 3, + ACTIONS(1335), 1, + anon_sym_LPAREN, + STATE(613), 1, + sym_prototype, + [17521] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(988), 1, - anon_sym_RPAREN, - ACTIONS(1337), 1, - anon_sym_SEMI, - [17476] = 3, + ACTIONS(1249), 1, + anon_sym_EQ, + ACTIONS(1251), 1, + anon_sym_COLON, + [17531] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1340), 1, - anon_sym_COMMA, - ACTIONS(1342), 1, - anon_sym_EQ_GT, - [17486] = 3, + ACTIONS(246), 1, + anon_sym_RBRACK, + ACTIONS(1007), 1, + anon_sym_PIPE_PIPE, + [17541] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1344), 1, + ACTIONS(1337), 1, anon_sym_RBRACE, - ACTIONS(1346), 1, + ACTIONS(1339), 1, anon_sym_COMMA, - [17496] = 3, + [17551] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1348), 1, + ACTIONS(1335), 1, anon_sym_LPAREN, - STATE(433), 1, - sym_conditional_branch, - [17506] = 3, + STATE(424), 1, + sym_prototype, + [17561] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1350), 1, - anon_sym_COMMA, - ACTIONS(1352), 1, + ACTIONS(1341), 1, + anon_sym_SEMI, + ACTIONS(1343), 1, anon_sym_RPAREN, - [17516] = 2, + [17571] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1354), 2, + ACTIONS(1345), 2, anon_sym_RBRACE, anon_sym_COMMA, - [17524] = 3, + [17579] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1348), 1, - anon_sym_LPAREN, - STATE(419), 1, - sym_conditional_branch, - [17534] = 3, + ACTIONS(1347), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [17587] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1291), 1, - anon_sym_RBRACK, - ACTIONS(1356), 1, - anon_sym_DOT_DOT, - [17544] = 3, + ACTIONS(1349), 1, + anon_sym_COMMA, + ACTIONS(1351), 1, + anon_sym_RPAREN, + [17597] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1358), 1, - sym_name, - STATE(269), 1, - sym_identifier, - [17554] = 3, + ACTIONS(1353), 1, + anon_sym_COMMA, + ACTIONS(1355), 1, + anon_sym_RPAREN, + [17607] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1357), 2, + anon_sym_SEMI, + anon_sym_COMMA, + [17615] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1127), 1, sym_name, - STATE(673), 1, + STATE(571), 1, sym_identifier, - [17564] = 3, + [17625] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1360), 1, - anon_sym_SEMI, - ACTIONS(1362), 1, + ACTIONS(1359), 2, + anon_sym_RBRACE, anon_sym_COMMA, - [17574] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(1329), 1, - anon_sym_LPAREN, - STATE(570), 1, - sym_prototype, - [17584] = 2, + [17633] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1255), 2, - anon_sym_EQ, - anon_sym_COLON, - [17592] = 3, + ACTIONS(1361), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [17641] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1364), 1, + ACTIONS(1363), 1, anon_sym_COMMA, - ACTIONS(1366), 1, + ACTIONS(1365), 1, anon_sym_RPAREN, - [17602] = 3, + [17651] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1154), 1, + ACTIONS(1367), 1, + anon_sym_SEMI, + ACTIONS(1369), 1, anon_sym_RPAREN, - ACTIONS(1368), 1, - anon_sym_COMMA, - [17612] = 3, + [17661] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1293), 1, - anon_sym_DOT_DOT, - ACTIONS(1370), 1, - anon_sym_RBRACK, - [17622] = 3, + ACTIONS(1212), 2, + anon_sym_RPAREN, + anon_sym_PIPE, + [17669] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1329), 1, - anon_sym_LPAREN, - STATE(417), 1, - sym_prototype, - [17632] = 3, + ACTIONS(1003), 1, + anon_sym_RPAREN, + ACTIONS(1371), 1, + anon_sym_SEMI, + [17679] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1249), 1, + ACTIONS(1374), 1, sym_name, - STATE(657), 1, - sym_name_list, - [17642] = 3, + STATE(326), 1, + sym_identifier, + [17689] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(244), 1, - anon_sym_RBRACK, - ACTIONS(992), 1, - anon_sym_PIPE_PIPE, - [17652] = 3, + ACTIONS(1376), 2, + anon_sym_SEMI, + anon_sym_COMMA, + [17697] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(145), 1, - anon_sym_RPAREN, - ACTIONS(1372), 1, - anon_sym_COMMA, - [17662] = 2, + ACTIONS(1378), 1, + anon_sym_LPAREN, + STATE(434), 1, + sym_conditional_branch, + [17707] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1374), 2, + ACTIONS(1380), 2, anon_sym_RBRACE, anon_sym_COMMA, - [17670] = 3, + [17715] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1376), 1, - anon_sym_SEMI, - ACTIONS(1378), 1, - anon_sym_COLON_COLON, - [17680] = 3, + ACTIONS(157), 1, + anon_sym_RBRACK, + ACTIONS(1382), 1, + anon_sym_COMMA, + [17725] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1281), 1, + sym_name, + STATE(659), 1, + sym_name_list, + [17735] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1380), 1, + ACTIONS(1384), 1, anon_sym_LPAREN, - STATE(479), 1, + STATE(490), 1, sym_conditional_branch, - [17690] = 3, + [17745] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1382), 1, - anon_sym_COMMA, - ACTIONS(1384), 1, - anon_sym_RPAREN, - [17700] = 3, + ACTIONS(1378), 1, + anon_sym_LPAREN, + STATE(423), 1, + sym_conditional_branch, + [17755] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1386), 1, + ACTIONS(1386), 2, + anon_sym_SEMI, anon_sym_COMMA, - ACTIONS(1388), 1, - anon_sym_RPAREN, - [17710] = 2, + [17763] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1390), 2, + ACTIONS(1388), 1, anon_sym_RBRACE, + ACTIONS(1390), 1, anon_sym_COMMA, - [17718] = 3, + [17773] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1392), 1, - anon_sym_LPAREN, - STATE(333), 1, - sym_prototype, - [17728] = 3, - ACTIONS(3), 1, - sym_comment, + anon_sym_SEMI, ACTIONS(1394), 1, anon_sym_COMMA, - ACTIONS(1396), 1, - anon_sym_PIPE, - [17738] = 3, + [17783] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(157), 1, - anon_sym_RPAREN, - ACTIONS(1398), 1, - anon_sym_COMMA, - [17748] = 2, + ACTIONS(1384), 1, + anon_sym_LPAREN, + STATE(486), 1, + sym_conditional_branch, + [17793] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1400), 2, - anon_sym_RBRACE, - anon_sym_COMMA, - [17756] = 3, + ACTIONS(1127), 1, + sym_name, + STATE(380), 1, + sym_identifier, + [17803] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1402), 1, - sym_name, - STATE(589), 1, - sym_binding_names, - [17766] = 3, + ACTIONS(1202), 2, + anon_sym_EQ, + anon_sym_COLON, + [17811] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(292), 1, + ACTIONS(1396), 1, + anon_sym_LPAREN, + STATE(332), 1, + sym_prototype, + [17821] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(244), 1, anon_sym_RBRACK, - ACTIONS(992), 1, + ACTIONS(1007), 1, anon_sym_PIPE_PIPE, - [17776] = 3, + [17831] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1398), 1, + anon_sym_COMMA, + ACTIONS(1400), 1, + anon_sym_PIPE, + [17841] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1404), 1, + ACTIONS(1402), 2, anon_sym_RBRACE, - ACTIONS(1406), 1, anon_sym_COMMA, - [17786] = 3, + [17849] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1408), 1, - anon_sym_SEMI, - ACTIONS(1410), 1, - anon_sym_RPAREN, - [17796] = 3, + ACTIONS(1404), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [17857] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1412), 1, - anon_sym_SEMI, - ACTIONS(1414), 1, - anon_sym_EQ, - [17806] = 3, + ACTIONS(1406), 1, + sym_name, + STATE(380), 1, + sym_identifier, + [17867] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1358), 1, + ACTIONS(1127), 1, sym_name, - STATE(324), 1, + STATE(676), 1, sym_identifier, - [17816] = 3, + [17877] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1148), 1, - anon_sym_RPAREN, - ACTIONS(1416), 1, + ACTIONS(1408), 1, + anon_sym_RBRACE, + ACTIONS(1410), 1, anon_sym_COMMA, - [17826] = 3, + [17887] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1418), 1, + ACTIONS(1412), 2, + anon_sym_RBRACE, anon_sym_COMMA, - ACTIONS(1420), 1, - anon_sym_RPAREN, - [17836] = 2, + [17895] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1422), 2, + ACTIONS(1414), 1, anon_sym_SEMI, - anon_sym_COMMA, - [17844] = 3, + ACTIONS(1416), 1, + anon_sym_EQ, + [17905] = 3, + ACTIONS(1107), 1, + sym_comment, + ACTIONS(1418), 1, + aux_sym_escape_sequence_token1, + ACTIONS(1420), 1, + aux_sym_named_escape_token1, + [17915] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1422), 1, + sym_name, + STATE(209), 1, + sym_identifier, + [17925] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1424), 1, anon_sym_SEMI, ACTIONS(1426), 1, - anon_sym_COMMA, - [17854] = 3, + anon_sym_COLON_COLON, + [17935] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1428), 1, - anon_sym_RBRACE, - ACTIONS(1430), 1, - anon_sym_COMMA, - [17864] = 3, + sym_name, + STATE(603), 1, + sym_binding_names, + [17945] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1432), 1, + ACTIONS(1430), 1, anon_sym_SEMI, - ACTIONS(1434), 1, + ACTIONS(1432), 1, anon_sym_COMMA, - [17874] = 3, + [17955] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1350), 1, - anon_sym_COMMA, - ACTIONS(1436), 1, - anon_sym_RPAREN, - [17884] = 3, + ACTIONS(1225), 1, + anon_sym_EQ, + ACTIONS(1227), 1, + anon_sym_COLON, + [17965] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(161), 1, - anon_sym_RBRACK, - ACTIONS(1438), 1, + ACTIONS(1335), 1, + anon_sym_LPAREN, + STATE(441), 1, + sym_prototype, + [17975] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1168), 1, + anon_sym_RPAREN, + ACTIONS(1434), 1, anon_sym_COMMA, - [17894] = 3, + [17985] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1329), 1, - anon_sym_LPAREN, - STATE(434), 1, - sym_prototype, - [17904] = 3, + ACTIONS(161), 1, + anon_sym_RPAREN, + ACTIONS(1436), 1, + anon_sym_COMMA, + [17995] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1440), 1, + ACTIONS(1353), 1, anon_sym_COMMA, - ACTIONS(1442), 1, + ACTIONS(1438), 1, anon_sym_RPAREN, - [17914] = 3, + [18005] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1127), 1, - sym_name, - STATE(378), 1, - sym_identifier, - [17924] = 3, - ACTIONS(1109), 1, + ACTIONS(1440), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [18013] = 3, + ACTIONS(3), 1, sym_comment, + ACTIONS(1442), 1, + anon_sym_RBRACE, ACTIONS(1444), 1, - aux_sym_escape_sequence_token1, + anon_sym_COMMA, + [18023] = 3, + ACTIONS(1107), 1, + sym_comment, ACTIONS(1446), 1, + aux_sym_escape_sequence_token1, + ACTIONS(1448), 1, aux_sym_named_escape_token1, - [17934] = 3, + [18033] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1448), 1, - anon_sym_COMMA, + ACTIONS(1127), 1, + sym_name, + STATE(572), 1, + sym_identifier, + [18043] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1291), 1, + anon_sym_DOT_DOT, ACTIONS(1450), 1, - anon_sym_RPAREN, - [17944] = 2, + anon_sym_RBRACK, + [18053] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1452), 2, - anon_sym_RBRACE, + ACTIONS(1452), 1, anon_sym_COMMA, - [17952] = 3, + ACTIONS(1454), 1, + anon_sym_RPAREN, + [18063] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1454), 1, - anon_sym_RBRACE, ACTIONS(1456), 1, anon_sym_COMMA, - [17962] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(1380), 1, - anon_sym_LPAREN, - STATE(490), 1, - sym_conditional_branch, - [17972] = 2, + ACTIONS(1458), 1, + anon_sym_EQ_GT, + [18073] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1458), 2, + ACTIONS(1460), 1, anon_sym_RBRACE, + ACTIONS(1462), 1, anon_sym_COMMA, - [17980] = 3, + [18083] = 3, ACTIONS(3), 1, sym_comment, ACTIONS(1127), 1, sym_name, - STATE(454), 1, + STATE(451), 1, sym_identifier, - [17990] = 3, + [18093] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1259), 1, - anon_sym_EQ, - ACTIONS(1261), 1, - anon_sym_COLON, - [18000] = 3, + ACTIONS(1464), 1, + anon_sym_RBRACE, + ACTIONS(1466), 1, + anon_sym_COMMA, + [18103] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1460), 1, + ACTIONS(1468), 1, anon_sym_RBRACE, - ACTIONS(1462), 1, + ACTIONS(1470), 1, anon_sym_COMMA, - [18010] = 3, + [18113] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1464), 1, + ACTIONS(1472), 1, sym_name, - STATE(269), 1, + STATE(271), 1, sym_identifier, - [18020] = 2, + [18123] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1466), 2, - anon_sym_RBRACE, - anon_sym_COMMA, - [18028] = 3, - ACTIONS(3), 1, - sym_comment, - ACTIONS(1392), 1, - anon_sym_LPAREN, - STATE(343), 1, - sym_prototype, - [18038] = 3, + ACTIONS(1289), 1, + anon_sym_RBRACK, + ACTIONS(1474), 1, + anon_sym_DOT_DOT, + [18133] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1468), 1, + ACTIONS(1374), 1, sym_name, - STATE(378), 1, + STATE(271), 1, sym_identifier, - [18048] = 3, - ACTIONS(1109), 1, - sym_comment, - ACTIONS(1470), 1, - aux_sym_escape_sequence_token1, - ACTIONS(1472), 1, - aux_sym_named_escape_token1, - [18058] = 2, + [18143] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(244), 1, - anon_sym_RBRACK, - [18065] = 2, + ACTIONS(1396), 1, + anon_sym_LPAREN, + STATE(345), 1, + sym_prototype, + [18153] = 3, ACTIONS(3), 1, sym_comment, - ACTIONS(1474), 1, - anon_sym_LBRACE, - [18072] = 2, + ACTIONS(145), 1, + anon_sym_RPAREN, + ACTIONS(1476), 1, + anon_sym_COMMA, + [18163] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1476), 1, - anon_sym_STAR, - [18079] = 2, + ACTIONS(246), 1, + anon_sym_RBRACK, + [18170] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1478), 1, anon_sym_LBRACE, - [18086] = 2, + [18177] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1480), 1, - anon_sym_RPAREN, - [18093] = 2, + anon_sym_LBRACE, + [18184] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1482), 1, - anon_sym_DQUOTE, - [18100] = 2, + anon_sym_STAR, + [18191] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1484), 1, - anon_sym_RPAREN, - [18107] = 2, + anon_sym_STAR, + [18198] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1486), 1, anon_sym_RPAREN, - [18114] = 2, + [18205] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1488), 1, - anon_sym_RPAREN, - [18121] = 2, + anon_sym_DQUOTE, + [18212] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1490), 1, - anon_sym_STAR, - [18128] = 2, + anon_sym_RPAREN, + [18219] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1492), 1, - anon_sym_LPAREN, - [18135] = 2, + anon_sym_RPAREN, + [18226] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1494), 1, - anon_sym_fn, - [18142] = 2, - ACTIONS(3), 1, - sym_comment, - ACTIONS(292), 1, - anon_sym_RBRACK, - [18149] = 2, + anon_sym_RPAREN, + [18233] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1496), 1, - anon_sym_DQUOTE, - [18156] = 2, + anon_sym_RBRACE, + [18240] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1498), 1, - anon_sym_SEMI, - [18163] = 2, + anon_sym_fn, + [18247] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1500), 1, - anon_sym_EQ, - [18170] = 2, + anon_sym_DQUOTE, + [18254] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(244), 1, + anon_sym_RBRACK, + [18261] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1502), 1, anon_sym_SEMI, - [18177] = 2, + [18268] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1504), 1, - anon_sym_COLON, - [18184] = 2, + anon_sym_EQ, + [18275] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1506), 1, - anon_sym_RPAREN, - [18191] = 2, + anon_sym_COLON, + [18282] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1508), 1, - anon_sym_RBRACE, - [18198] = 2, + anon_sym_SEMI, + [18289] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1510), 1, anon_sym_RPAREN, - [18205] = 2, + [18296] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1512), 1, - anon_sym_RPAREN, - [18212] = 2, + anon_sym_RBRACE, + [18303] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1514), 1, - anon_sym_LBRACE, - [18219] = 2, + anon_sym_RPAREN, + [18310] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1516), 1, - anon_sym_LPAREN, - [18226] = 2, + anon_sym_RPAREN, + [18317] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1518), 1, anon_sym_LBRACE, - [18233] = 2, + [18324] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1520), 1, anon_sym_LPAREN, - [18240] = 2, + [18331] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1522), 1, - anon_sym_RBRACE, - [18247] = 2, + anon_sym_LBRACE, + [18338] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1524), 1, - anon_sym_RBRACE, - [18254] = 2, + anon_sym_LPAREN, + [18345] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1526), 1, - anon_sym_RBRACE, - [18261] = 2, - ACTIONS(3), 1, - sym_comment, - ACTIONS(1352), 1, - anon_sym_RPAREN, - [18268] = 2, + anon_sym_SEMI, + [18352] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1528), 1, - anon_sym_SEMI, - [18275] = 2, + anon_sym_RBRACE, + [18359] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1530), 1, - anon_sym_RBRACK, - [18282] = 2, + anon_sym_RBRACE, + [18366] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1532), 1, - anon_sym_SQUOTE, - [18289] = 2, + anon_sym_RBRACE, + [18373] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1355), 1, + anon_sym_RPAREN, + [18380] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1534), 1, anon_sym_RBRACE, - [18296] = 2, + [18387] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1536), 1, - anon_sym_LPAREN, - [18303] = 2, + anon_sym_RBRACK, + [18394] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1538), 1, - anon_sym_SEMI, - [18310] = 2, + anon_sym_SQUOTE, + [18401] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1540), 1, - sym_name, - [18317] = 2, + anon_sym_LPAREN, + [18408] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1542), 1, anon_sym_LPAREN, - [18324] = 2, + [18415] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1544), 1, - anon_sym_LPAREN, - [18331] = 2, + anon_sym_SEMI, + [18422] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1546), 1, - anon_sym_LPAREN, - [18338] = 2, - ACTIONS(3), 1, - sym_comment, - ACTIONS(1198), 1, - anon_sym_assert, - [18345] = 2, + sym_name, + [18429] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1548), 1, anon_sym_LPAREN, - [18352] = 2, + [18436] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1550), 1, - anon_sym_RBRACE, - [18359] = 2, + anon_sym_LPAREN, + [18443] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1552), 1, - anon_sym_RPAREN, - [18366] = 2, + ACTIONS(1208), 1, + anon_sym_assert, + [18450] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1554), 1, + ACTIONS(1552), 1, anon_sym_LPAREN, - [18373] = 2, + [18457] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1556), 1, + ACTIONS(1554), 1, anon_sym_LPAREN, - [18380] = 2, + [18464] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1164), 1, - anon_sym_RPAREN, - [18387] = 2, + ACTIONS(1556), 1, + anon_sym_RBRACE, + [18471] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1315), 1, + ACTIONS(1558), 1, anon_sym_RPAREN, - [18394] = 2, + [18478] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1558), 1, - sym_name, - [18401] = 2, + ACTIONS(1560), 1, + anon_sym_LPAREN, + [18485] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1305), 1, + ACTIONS(1329), 1, anon_sym_RPAREN, - [18408] = 2, + [18492] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1560), 1, + ACTIONS(1155), 1, anon_sym_RPAREN, - [18415] = 2, + [18499] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1562), 1, - anon_sym_LPAREN, - [18422] = 2, + sym_name, + [18506] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1564), 1, + anon_sym_LPAREN, + [18513] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1313), 1, anon_sym_RPAREN, - [18429] = 2, + [18520] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1566), 1, - anon_sym_RBRACE, - [18436] = 2, + anon_sym_RPAREN, + [18527] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1568), 1, - anon_sym_SEMI, - [18443] = 2, - ACTIONS(3), 1, - sym_comment, - ACTIONS(1319), 1, - anon_sym_RBRACE, - [18450] = 2, + anon_sym_LPAREN, + [18534] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1570), 1, - anon_sym_SQUOTE, - [18457] = 2, + anon_sym_RPAREN, + [18541] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1572), 1, anon_sym_SQUOTE, - [18464] = 2, + [18548] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1574), 1, - anon_sym_RPAREN, - [18471] = 2, + anon_sym_SQUOTE, + [18555] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1323), 1, + anon_sym_RBRACE, + [18562] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1576), 1, - anon_sym_RPAREN, - [18478] = 2, + anon_sym_SEMI, + [18569] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1578), 1, anon_sym_RPAREN, - [18485] = 2, + [18576] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1133), 1, - sym_name, - [18492] = 2, + ACTIONS(1580), 1, + anon_sym_RPAREN, + [18583] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(177), 1, - anon_sym_RBRACK, - [18499] = 2, + ACTIONS(1582), 1, + anon_sym_RPAREN, + [18590] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1580), 1, - anon_sym_SQUOTE, - [18506] = 2, + ACTIONS(1147), 1, + sym_name, + [18597] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1582), 1, - anon_sym_EQ, - [18513] = 2, + ACTIONS(1584), 1, + anon_sym_SQUOTE, + [18604] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1584), 1, - anon_sym_COLON, - [18520] = 2, + ACTIONS(177), 1, + anon_sym_RBRACK, + [18611] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(484), 1, + ACTIONS(492), 1, anon_sym_LBRACE, - [18527] = 2, + [18618] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1586), 1, - anon_sym_RPAREN, - [18534] = 2, + anon_sym_EQ, + [18625] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1588), 1, - anon_sym_RPAREN, - [18541] = 2, + anon_sym_COLON, + [18632] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1590), 1, - anon_sym_RPAREN, - [18548] = 2, + sym_name, + [18639] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1592), 1, - anon_sym_RBRACK, - [18555] = 2, + anon_sym_RPAREN, + [18646] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1594), 1, - sym_name, - [18562] = 2, + anon_sym_RPAREN, + [18653] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1596), 1, anon_sym_RPAREN, - [18569] = 2, + [18660] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1598), 1, - anon_sym_RPAREN, - [18576] = 2, + anon_sym_RBRACK, + [18667] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1600), 1, - anon_sym_LBRACE, - [18583] = 2, + anon_sym_LPAREN, + [18674] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1602), 1, - anon_sym_RBRACE, - [18590] = 2, + anon_sym_RPAREN, + [18681] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1604), 1, - anon_sym_EQ_GT, - [18597] = 2, + anon_sym_RPAREN, + [18688] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1606), 1, - anon_sym_EQ_GT, - [18604] = 2, + anon_sym_LBRACE, + [18695] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1608), 1, anon_sym_RBRACE, - [18611] = 2, + [18702] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1610), 1, - anon_sym_SEMI, - [18618] = 2, - ACTIONS(3), 1, - sym_comment, - ACTIONS(1460), 1, - anon_sym_RBRACE, - [18625] = 2, + anon_sym_EQ_GT, + [18709] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1612), 1, - anon_sym_LPAREN, - [18632] = 2, + anon_sym_EQ_GT, + [18716] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1614), 1, - anon_sym_LPAREN, - [18639] = 2, + anon_sym_RBRACE, + [18723] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1468), 1, + anon_sym_RBRACE, + [18730] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1616), 1, - anon_sym_RPAREN, - [18646] = 2, + anon_sym_LPAREN, + [18737] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1618), 1, anon_sym_RPAREN, - [18653] = 2, + [18744] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1620), 1, - anon_sym_RBRACE, - [18660] = 2, + anon_sym_RPAREN, + [18751] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1622), 1, - ts_builtin_sym_end, - [18667] = 2, + anon_sym_RBRACE, + [18758] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(461), 1, anon_sym_EQ_GT, - [18674] = 2, + [18765] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(290), 1, + ACTIONS(292), 1, anon_sym_EQ_GT, - [18681] = 2, + [18772] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1624), 1, - anon_sym_RBRACE, - [18688] = 2, + ts_builtin_sym_end, + [18779] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1626), 1, - anon_sym_RPAREN, - [18695] = 2, + anon_sym_RBRACE, + [18786] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1628), 1, - anon_sym_RPAREN, - [18702] = 2, + anon_sym_for, + [18793] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1630), 1, - anon_sym_for, - [18709] = 2, + anon_sym_SEMI, + [18800] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1632), 1, - anon_sym_SEMI, - [18716] = 2, + anon_sym_RPAREN, + [18807] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1634), 1, anon_sym_RPAREN, - [18723] = 2, + [18814] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1636), 1, anon_sym_RPAREN, - [18730] = 2, + [18821] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1638), 1, - anon_sym_COMMA, - [18737] = 2, + anon_sym_SEMI, + [18828] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1640), 1, - anon_sym_SEMI, - [18744] = 2, + anon_sym_RPAREN, + [18835] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1642), 1, - anon_sym_EQ, - [18751] = 2, + anon_sym_COMMA, + [18842] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1644), 1, - anon_sym_fn, - [18758] = 2, + anon_sym_RBRACE, + [18849] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1646), 1, - anon_sym_RPAREN, - [18765] = 2, + anon_sym_EQ, + [18856] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1648), 1, - anon_sym_RBRACE, - [18772] = 2, + anon_sym_fn, + [18863] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1650), 1, - anon_sym_RBRACE, - [18779] = 2, + anon_sym_RPAREN, + [18870] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1652), 1, - anon_sym_SEMI, - [18786] = 2, + anon_sym_RBRACE, + [18877] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1654), 1, - anon_sym_COLON, - [18793] = 2, + anon_sym_RBRACK, + [18884] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1656), 1, - anon_sym_RBRACK, - [18800] = 2, + anon_sym_SEMI, + [18891] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1658), 1, - anon_sym_LPAREN, - [18807] = 2, + anon_sym_COLON, + [18898] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1660), 1, anon_sym_RPAREN, - [18814] = 2, + [18905] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1154), 1, - anon_sym_RPAREN, - [18821] = 2, + ACTIONS(1662), 1, + anon_sym_LPAREN, + [18912] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1662), 1, - anon_sym_SEMI, - [18828] = 2, + ACTIONS(1168), 1, + anon_sym_RPAREN, + [18919] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1664), 1, anon_sym_RPAREN, - [18835] = 2, + [18926] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1666), 1, - anon_sym_RBRACE, - [18842] = 2, + anon_sym_SEMI, + [18933] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1668), 1, - anon_sym_RPAREN, - [18849] = 2, + anon_sym_LPAREN, + [18940] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1670), 1, - anon_sym_EQ, - [18856] = 2, + anon_sym_SEMI, + [18947] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1672), 1, - anon_sym_LPAREN, - [18863] = 2, + anon_sym_RPAREN, + [18954] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1674), 1, - anon_sym_RPAREN, - [18870] = 2, + anon_sym_EQ, + [18961] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1676), 1, - anon_sym_COLON, - [18877] = 2, + anon_sym_RPAREN, + [18968] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1678), 1, anon_sym_LBRACE, - [18884] = 2, + [18975] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1680), 1, - anon_sym_LBRACE, - [18891] = 2, + anon_sym_COLON, + [18982] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1682), 1, - anon_sym_SEMI, - [18898] = 2, + anon_sym_LBRACE, + [18989] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1684), 1, anon_sym_RBRACE, - [18905] = 2, + [18996] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1686), 1, anon_sym_SEMI, - [18912] = 2, - ACTIONS(3), 1, - sym_comment, - ACTIONS(1688), 1, - anon_sym_EQ, - [18919] = 2, + [19003] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1690), 1, - anon_sym_RBRACE, - [18926] = 2, + ACTIONS(1319), 1, + anon_sym_RPAREN, + [19010] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1366), 1, - anon_sym_RPAREN, - [18933] = 2, + ACTIONS(1688), 1, + anon_sym_SEMI, + [19017] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(175), 1, - anon_sym_RBRACK, - [18940] = 2, + ACTIONS(1690), 1, + anon_sym_EQ, + [19024] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1692), 1, anon_sym_RBRACE, - [18947] = 2, + [19031] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1436), 1, - anon_sym_RPAREN, - [18954] = 2, + ACTIONS(1694), 1, + anon_sym_RBRACE, + [19038] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1420), 1, + ACTIONS(1696), 1, anon_sym_RPAREN, - [18961] = 2, + [19045] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1694), 1, - anon_sym_RPAREN, - [18968] = 2, + ACTIONS(171), 1, + anon_sym_RBRACK, + [19052] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1696), 1, + ACTIONS(1438), 1, anon_sym_RPAREN, - [18975] = 2, + [19059] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1698), 1, - anon_sym_RPAREN, - [18982] = 2, + anon_sym_RBRACE, + [19066] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1700), 1, - anon_sym_fn, - [18989] = 2, + anon_sym_RPAREN, + [19073] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1702), 1, - anon_sym_SEMI, - [18996] = 2, + anon_sym_RPAREN, + [19080] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1704), 1, - anon_sym_SEMI, - [19003] = 2, + anon_sym_RPAREN, + [19087] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1706), 1, - anon_sym_RPAREN, - [19010] = 2, + anon_sym_fn, + [19094] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1708), 1, - anon_sym_RPAREN, - [19017] = 2, - ACTIONS(3), 1, - sym_comment, - ACTIONS(837), 1, - ts_builtin_sym_end, - [19024] = 2, + anon_sym_SEMI, + [19101] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1710), 1, - anon_sym_COMMA, - [19031] = 2, + anon_sym_SEMI, + [19108] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1712), 1, - anon_sym_RBRACK, - [19038] = 2, + anon_sym_COMMA, + [19115] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1714), 1, - anon_sym_RBRACK, - [19045] = 2, + anon_sym_RPAREN, + [19122] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1384), 1, - anon_sym_RPAREN, - [19052] = 2, + ACTIONS(837), 1, + ts_builtin_sym_end, + [19129] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1716), 1, - anon_sym_RBRACE, - [19059] = 2, + anon_sym_RBRACK, + [19136] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1718), 1, + anon_sym_RBRACK, + [19143] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1351), 1, anon_sym_RPAREN, - [19066] = 2, + [19150] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1720), 1, - ts_builtin_sym_end, - [19073] = 2, + anon_sym_SQUOTE, + [19157] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1303), 1, + anon_sym_RPAREN, + [19164] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1722), 1, anon_sym_RBRACE, - [19080] = 2, + [19171] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1724), 1, - anon_sym_SQUOTE, - [19087] = 2, + ts_builtin_sym_end, + [19178] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1726), 1, - anon_sym_SQUOTE, - [19094] = 2, + anon_sym_RPAREN, + [19185] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1728), 1, - anon_sym_LPAREN, - [19101] = 2, + anon_sym_RBRACE, + [19192] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1730), 1, - anon_sym_LPAREN, - [19108] = 2, + anon_sym_SQUOTE, + [19199] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1732), 1, - anon_sym_LBRACE, - [19115] = 2, + anon_sym_LPAREN, + [19206] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1734), 1, - anon_sym_LBRACE, - [19122] = 2, + anon_sym_LPAREN, + [19213] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1736), 1, anon_sym_LBRACE, - [19129] = 2, + [19220] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1738), 1, - anon_sym_LPAREN, - [19136] = 2, + anon_sym_LBRACE, + [19227] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1740), 1, anon_sym_LBRACE, - [19143] = 2, + [19234] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1742), 1, anon_sym_LPAREN, - [19150] = 2, + [19241] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1744), 1, - anon_sym_LPAREN, - [19157] = 2, + anon_sym_LBRACE, + [19248] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1746), 1, anon_sym_LPAREN, - [19164] = 2, + [19255] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1748), 1, anon_sym_LPAREN, - [19171] = 2, + [19262] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1750), 1, anon_sym_LPAREN, - [19178] = 2, + [19269] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1752), 1, anon_sym_LPAREN, - [19185] = 2, + [19276] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1754), 1, - anon_sym_RPAREN, - [19192] = 2, + anon_sym_LPAREN, + [19283] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1756), 1, - anon_sym_RPAREN, - [19199] = 2, + anon_sym_LPAREN, + [19290] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1758), 1, - anon_sym_LPAREN, - [19206] = 2, + anon_sym_RPAREN, + [19297] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1760), 1, - anon_sym_LPAREN, - [19213] = 2, + anon_sym_RPAREN, + [19304] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1762), 1, - anon_sym_RPAREN, - [19220] = 2, + anon_sym_LPAREN, + [19311] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1764), 1, - anon_sym_RPAREN, - [19227] = 2, + anon_sym_LPAREN, + [19318] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1766), 1, - anon_sym_LPAREN, - [19234] = 2, + anon_sym_RPAREN, + [19325] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1768), 1, - anon_sym_COMMA, - [19241] = 2, + anon_sym_RPAREN, + [19332] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1770), 1, anon_sym_LPAREN, - [19248] = 2, + [19339] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1772), 1, anon_sym_COMMA, - [19255] = 2, + [19346] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1774), 1, anon_sym_LPAREN, - [19262] = 2, + [19353] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1776), 1, - anon_sym_LPAREN, - [19269] = 2, + anon_sym_COMMA, + [19360] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1778), 1, - anon_sym_assert, - [19276] = 2, + anon_sym_LPAREN, + [19367] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1780), 1, anon_sym_LPAREN, - [19283] = 2, + [19374] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1782), 1, - anon_sym_for, - [19290] = 2, + anon_sym_assert, + [19381] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1784), 1, - anon_sym_RPAREN, - [19297] = 2, + anon_sym_LPAREN, + [19388] = 2, ACTIONS(3), 1, sym_comment, ACTIONS(1786), 1, + anon_sym_for, + [19395] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1788), 1, + anon_sym_RPAREN, + [19402] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1790), 1, anon_sym_LPAREN, - [19304] = 2, + [19409] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1454), 1, + ACTIONS(1460), 1, anon_sym_RBRACE, - [19311] = 2, + [19416] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1788), 1, + ACTIONS(1792), 1, anon_sym_for, - [19318] = 2, + [19423] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1790), 1, + ACTIONS(1794), 1, anon_sym_LPAREN, - [19325] = 2, + [19430] = 2, ACTIONS(3), 1, sym_comment, - ACTIONS(1792), 1, + ACTIONS(1796), 1, anon_sym_for, }; @@ -36395,17 +36494,17 @@ static uint32_t ts_small_parse_table_map[] = { [SMALL_STATE(141)] = 87, [SMALL_STATE(142)] = 223, [SMALL_STATE(143)] = 359, - [SMALL_STATE(144)] = 432, - [SMALL_STATE(145)] = 505, - [SMALL_STATE(146)] = 638, - [SMALL_STATE(147)] = 711, - [SMALL_STATE(148)] = 844, - [SMALL_STATE(149)] = 917, - [SMALL_STATE(150)] = 996, + [SMALL_STATE(144)] = 438, + [SMALL_STATE(145)] = 511, + [SMALL_STATE(146)] = 584, + [SMALL_STATE(147)] = 717, + [SMALL_STATE(148)] = 850, + [SMALL_STATE(149)] = 983, + [SMALL_STATE(150)] = 1056, [SMALL_STATE(151)] = 1129, [SMALL_STATE(152)] = 1259, [SMALL_STATE(153)] = 1389, - [SMALL_STATE(154)] = 1467, + [SMALL_STATE(154)] = 1519, [SMALL_STATE(155)] = 1597, [SMALL_STATE(156)] = 1727, [SMALL_STATE(157)] = 1794, @@ -36418,659 +36517,661 @@ static uint32_t ts_small_parse_table_map[] = { [SMALL_STATE(164)] = 2302, [SMALL_STATE(165)] = 2378, [SMALL_STATE(166)] = 2479, - [SMALL_STATE(167)] = 2538, - [SMALL_STATE(168)] = 2639, - [SMALL_STATE(169)] = 2706, - [SMALL_STATE(170)] = 2807, + [SMALL_STATE(167)] = 2546, + [SMALL_STATE(168)] = 2647, + [SMALL_STATE(169)] = 2748, + [SMALL_STATE(170)] = 2849, [SMALL_STATE(171)] = 2908, - [SMALL_STATE(172)] = 2970, - [SMALL_STATE(173)] = 3068, + [SMALL_STATE(172)] = 2976, + [SMALL_STATE(173)] = 3074, [SMALL_STATE(174)] = 3136, [SMALL_STATE(175)] = 3198, [SMALL_STATE(176)] = 3293, [SMALL_STATE(177)] = 3388, [SMALL_STATE(178)] = 3483, - [SMALL_STATE(179)] = 3578, - [SMALL_STATE(180)] = 3673, - [SMALL_STATE(181)] = 3768, - [SMALL_STATE(182)] = 3863, - [SMALL_STATE(183)] = 3958, - [SMALL_STATE(184)] = 4053, - [SMALL_STATE(185)] = 4148, - [SMALL_STATE(186)] = 4209, - [SMALL_STATE(187)] = 4304, - [SMALL_STATE(188)] = 4399, - [SMALL_STATE(189)] = 4494, - [SMALL_STATE(190)] = 4589, - [SMALL_STATE(191)] = 4684, - [SMALL_STATE(192)] = 4779, + [SMALL_STATE(179)] = 3550, + [SMALL_STATE(180)] = 3645, + [SMALL_STATE(181)] = 3740, + [SMALL_STATE(182)] = 3835, + [SMALL_STATE(183)] = 3930, + [SMALL_STATE(184)] = 3991, + [SMALL_STATE(185)] = 4086, + [SMALL_STATE(186)] = 4181, + [SMALL_STATE(187)] = 4276, + [SMALL_STATE(188)] = 4371, + [SMALL_STATE(189)] = 4466, + [SMALL_STATE(190)] = 4561, + [SMALL_STATE(191)] = 4656, + [SMALL_STATE(192)] = 4751, [SMALL_STATE(193)] = 4846, [SMALL_STATE(194)] = 4941, [SMALL_STATE(195)] = 5036, [SMALL_STATE(196)] = 5131, - [SMALL_STATE(197)] = 5223, - [SMALL_STATE(198)] = 5279, - [SMALL_STATE(199)] = 5339, - [SMALL_STATE(200)] = 5399, - [SMALL_STATE(201)] = 5455, - [SMALL_STATE(202)] = 5519, - [SMALL_STATE(203)] = 5611, - [SMALL_STATE(204)] = 5703, - [SMALL_STATE(205)] = 5763, - [SMALL_STATE(206)] = 5821, - [SMALL_STATE(207)] = 5913, - [SMALL_STATE(208)] = 6005, - [SMALL_STATE(209)] = 6061, - [SMALL_STATE(210)] = 6153, - [SMALL_STATE(211)] = 6245, - [SMALL_STATE(212)] = 6337, - [SMALL_STATE(213)] = 6429, - [SMALL_STATE(214)] = 6521, + [SMALL_STATE(197)] = 5191, + [SMALL_STATE(198)] = 5251, + [SMALL_STATE(199)] = 5343, + [SMALL_STATE(200)] = 5435, + [SMALL_STATE(201)] = 5527, + [SMALL_STATE(202)] = 5619, + [SMALL_STATE(203)] = 5711, + [SMALL_STATE(204)] = 5767, + [SMALL_STATE(205)] = 5859, + [SMALL_STATE(206)] = 5951, + [SMALL_STATE(207)] = 6043, + [SMALL_STATE(208)] = 6135, + [SMALL_STATE(209)] = 6195, + [SMALL_STATE(210)] = 6251, + [SMALL_STATE(211)] = 6307, + [SMALL_STATE(212)] = 6399, + [SMALL_STATE(213)] = 6463, + [SMALL_STATE(214)] = 6555, [SMALL_STATE(215)] = 6613, - [SMALL_STATE(216)] = 6677, + [SMALL_STATE(216)] = 6705, [SMALL_STATE(217)] = 6769, - [SMALL_STATE(218)] = 6830, - [SMALL_STATE(219)] = 6885, - [SMALL_STATE(220)] = 6939, - [SMALL_STATE(221)] = 6997, - [SMALL_STATE(222)] = 7051, - [SMALL_STATE(223)] = 7113, - [SMALL_STATE(224)] = 7167, - [SMALL_STATE(225)] = 7221, - [SMALL_STATE(226)] = 7275, - [SMALL_STATE(227)] = 7329, - [SMALL_STATE(228)] = 7383, - [SMALL_STATE(229)] = 7437, - [SMALL_STATE(230)] = 7491, - [SMALL_STATE(231)] = 7545, - [SMALL_STATE(232)] = 7599, - [SMALL_STATE(233)] = 7653, - [SMALL_STATE(234)] = 7707, - [SMALL_STATE(235)] = 7761, - [SMALL_STATE(236)] = 7815, - [SMALL_STATE(237)] = 7869, - [SMALL_STATE(238)] = 7923, - [SMALL_STATE(239)] = 7977, - [SMALL_STATE(240)] = 8031, - [SMALL_STATE(241)] = 8085, - [SMALL_STATE(242)] = 8139, - [SMALL_STATE(243)] = 8193, - [SMALL_STATE(244)] = 8247, - [SMALL_STATE(245)] = 8301, - [SMALL_STATE(246)] = 8355, - [SMALL_STATE(247)] = 8409, - [SMALL_STATE(248)] = 8463, - [SMALL_STATE(249)] = 8517, - [SMALL_STATE(250)] = 8571, - [SMALL_STATE(251)] = 8625, - [SMALL_STATE(252)] = 8679, - [SMALL_STATE(253)] = 8733, - [SMALL_STATE(254)] = 8791, - [SMALL_STATE(255)] = 8845, - [SMALL_STATE(256)] = 8899, - [SMALL_STATE(257)] = 8953, - [SMALL_STATE(258)] = 9007, - [SMALL_STATE(259)] = 9061, - [SMALL_STATE(260)] = 9149, - [SMALL_STATE(261)] = 9203, - [SMALL_STATE(262)] = 9291, - [SMALL_STATE(263)] = 9345, - [SMALL_STATE(264)] = 9402, - [SMALL_STATE(265)] = 9452, - [SMALL_STATE(266)] = 9508, - [SMALL_STATE(267)] = 9558, - [SMALL_STATE(268)] = 9614, - [SMALL_STATE(269)] = 9667, - [SMALL_STATE(270)] = 9713, - [SMALL_STATE(271)] = 9763, - [SMALL_STATE(272)] = 9815, - [SMALL_STATE(273)] = 9864, - [SMALL_STATE(274)] = 9911, - [SMALL_STATE(275)] = 9960, - [SMALL_STATE(276)] = 10009, - [SMALL_STATE(277)] = 10062, - [SMALL_STATE(278)] = 10106, - [SMALL_STATE(279)] = 10152, - [SMALL_STATE(280)] = 10196, - [SMALL_STATE(281)] = 10240, - [SMALL_STATE(282)] = 10284, - [SMALL_STATE(283)] = 10327, - [SMALL_STATE(284)] = 10370, - [SMALL_STATE(285)] = 10413, - [SMALL_STATE(286)] = 10456, - [SMALL_STATE(287)] = 10501, - [SMALL_STATE(288)] = 10544, - [SMALL_STATE(289)] = 10587, - [SMALL_STATE(290)] = 10638, - [SMALL_STATE(291)] = 10681, - [SMALL_STATE(292)] = 10724, - [SMALL_STATE(293)] = 10767, - [SMALL_STATE(294)] = 10810, - [SMALL_STATE(295)] = 10853, - [SMALL_STATE(296)] = 10896, - [SMALL_STATE(297)] = 10939, - [SMALL_STATE(298)] = 10982, - [SMALL_STATE(299)] = 11025, - [SMALL_STATE(300)] = 11068, - [SMALL_STATE(301)] = 11111, - [SMALL_STATE(302)] = 11154, - [SMALL_STATE(303)] = 11197, - [SMALL_STATE(304)] = 11240, - [SMALL_STATE(305)] = 11283, - [SMALL_STATE(306)] = 11334, - [SMALL_STATE(307)] = 11377, - [SMALL_STATE(308)] = 11420, - [SMALL_STATE(309)] = 11463, - [SMALL_STATE(310)] = 11506, - [SMALL_STATE(311)] = 11549, - [SMALL_STATE(312)] = 11592, - [SMALL_STATE(313)] = 11635, - [SMALL_STATE(314)] = 11682, - [SMALL_STATE(315)] = 11725, - [SMALL_STATE(316)] = 11768, - [SMALL_STATE(317)] = 11811, - [SMALL_STATE(318)] = 11854, - [SMALL_STATE(319)] = 11897, - [SMALL_STATE(320)] = 11940, - [SMALL_STATE(321)] = 11983, - [SMALL_STATE(322)] = 12026, - [SMALL_STATE(323)] = 12069, - [SMALL_STATE(324)] = 12109, - [SMALL_STATE(325)] = 12149, - [SMALL_STATE(326)] = 12189, - [SMALL_STATE(327)] = 12229, - [SMALL_STATE(328)] = 12269, - [SMALL_STATE(329)] = 12311, - [SMALL_STATE(330)] = 12351, - [SMALL_STATE(331)] = 12393, - [SMALL_STATE(332)] = 12433, - [SMALL_STATE(333)] = 12473, - [SMALL_STATE(334)] = 12513, - [SMALL_STATE(335)] = 12553, - [SMALL_STATE(336)] = 12593, - [SMALL_STATE(337)] = 12633, - [SMALL_STATE(338)] = 12673, - [SMALL_STATE(339)] = 12713, - [SMALL_STATE(340)] = 12753, - [SMALL_STATE(341)] = 12793, - [SMALL_STATE(342)] = 12833, - [SMALL_STATE(343)] = 12873, - [SMALL_STATE(344)] = 12913, - [SMALL_STATE(345)] = 12953, - [SMALL_STATE(346)] = 12993, - [SMALL_STATE(347)] = 13033, - [SMALL_STATE(348)] = 13078, - [SMALL_STATE(349)] = 13117, - [SMALL_STATE(350)] = 13156, - [SMALL_STATE(351)] = 13195, - [SMALL_STATE(352)] = 13234, - [SMALL_STATE(353)] = 13273, - [SMALL_STATE(354)] = 13312, - [SMALL_STATE(355)] = 13357, - [SMALL_STATE(356)] = 13398, - [SMALL_STATE(357)] = 13440, - [SMALL_STATE(358)] = 13478, - [SMALL_STATE(359)] = 13513, - [SMALL_STATE(360)] = 13548, - [SMALL_STATE(361)] = 13586, - [SMALL_STATE(362)] = 13646, - [SMALL_STATE(363)] = 13679, - [SMALL_STATE(364)] = 13736, - [SMALL_STATE(365)] = 13793, - [SMALL_STATE(366)] = 13824, - [SMALL_STATE(367)] = 13853, - [SMALL_STATE(368)] = 13884, - [SMALL_STATE(369)] = 13913, - [SMALL_STATE(370)] = 13943, - [SMALL_STATE(371)] = 13991, - [SMALL_STATE(372)] = 14021, - [SMALL_STATE(373)] = 14050, - [SMALL_STATE(374)] = 14079, - [SMALL_STATE(375)] = 14119, - [SMALL_STATE(376)] = 14159, - [SMALL_STATE(377)] = 14189, - [SMALL_STATE(378)] = 14219, - [SMALL_STATE(379)] = 14243, - [SMALL_STATE(380)] = 14268, - [SMALL_STATE(381)] = 14295, - [SMALL_STATE(382)] = 14322, - [SMALL_STATE(383)] = 14347, - [SMALL_STATE(384)] = 14371, - [SMALL_STATE(385)] = 14395, - [SMALL_STATE(386)] = 14418, - [SMALL_STATE(387)] = 14437, - [SMALL_STATE(388)] = 14460, - [SMALL_STATE(389)] = 14483, - [SMALL_STATE(390)] = 14506, - [SMALL_STATE(391)] = 14525, - [SMALL_STATE(392)] = 14548, - [SMALL_STATE(393)] = 14567, - [SMALL_STATE(394)] = 14587, - [SMALL_STATE(395)] = 14609, - [SMALL_STATE(396)] = 14629, - [SMALL_STATE(397)] = 14647, - [SMALL_STATE(398)] = 14667, - [SMALL_STATE(399)] = 14689, - [SMALL_STATE(400)] = 14707, - [SMALL_STATE(401)] = 14727, - [SMALL_STATE(402)] = 14748, - [SMALL_STATE(403)] = 14769, - [SMALL_STATE(404)] = 14790, - [SMALL_STATE(405)] = 14823, - [SMALL_STATE(406)] = 14844, - [SMALL_STATE(407)] = 14867, - [SMALL_STATE(408)] = 14897, - [SMALL_STATE(409)] = 14923, - [SMALL_STATE(410)] = 14953, - [SMALL_STATE(411)] = 14983, - [SMALL_STATE(412)] = 15001, - [SMALL_STATE(413)] = 15021, - [SMALL_STATE(414)] = 15051, - [SMALL_STATE(415)] = 15077, - [SMALL_STATE(416)] = 15095, - [SMALL_STATE(417)] = 15112, - [SMALL_STATE(418)] = 15129, - [SMALL_STATE(419)] = 15146, - [SMALL_STATE(420)] = 15165, - [SMALL_STATE(421)] = 15182, - [SMALL_STATE(422)] = 15199, - [SMALL_STATE(423)] = 15218, - [SMALL_STATE(424)] = 15235, - [SMALL_STATE(425)] = 15252, - [SMALL_STATE(426)] = 15269, - [SMALL_STATE(427)] = 15288, - [SMALL_STATE(428)] = 15305, - [SMALL_STATE(429)] = 15322, - [SMALL_STATE(430)] = 15339, - [SMALL_STATE(431)] = 15356, - [SMALL_STATE(432)] = 15373, - [SMALL_STATE(433)] = 15390, - [SMALL_STATE(434)] = 15409, - [SMALL_STATE(435)] = 15426, - [SMALL_STATE(436)] = 15443, - [SMALL_STATE(437)] = 15460, - [SMALL_STATE(438)] = 15477, - [SMALL_STATE(439)] = 15494, - [SMALL_STATE(440)] = 15511, - [SMALL_STATE(441)] = 15528, - [SMALL_STATE(442)] = 15545, - [SMALL_STATE(443)] = 15562, - [SMALL_STATE(444)] = 15579, - [SMALL_STATE(445)] = 15596, - [SMALL_STATE(446)] = 15613, - [SMALL_STATE(447)] = 15630, - [SMALL_STATE(448)] = 15647, - [SMALL_STATE(449)] = 15664, - [SMALL_STATE(450)] = 15681, - [SMALL_STATE(451)] = 15698, - [SMALL_STATE(452)] = 15715, - [SMALL_STATE(453)] = 15732, - [SMALL_STATE(454)] = 15749, - [SMALL_STATE(455)] = 15766, - [SMALL_STATE(456)] = 15783, - [SMALL_STATE(457)] = 15800, - [SMALL_STATE(458)] = 15816, - [SMALL_STATE(459)] = 15844, - [SMALL_STATE(460)] = 15862, - [SMALL_STATE(461)] = 15890, - [SMALL_STATE(462)] = 15913, - [SMALL_STATE(463)] = 15936, - [SMALL_STATE(464)] = 15959, - [SMALL_STATE(465)] = 15982, - [SMALL_STATE(466)] = 16007, - [SMALL_STATE(467)] = 16029, - [SMALL_STATE(468)] = 16047, - [SMALL_STATE(469)] = 16069, - [SMALL_STATE(470)] = 16081, - [SMALL_STATE(471)] = 16095, - [SMALL_STATE(472)] = 16107, - [SMALL_STATE(473)] = 16129, - [SMALL_STATE(474)] = 16151, - [SMALL_STATE(475)] = 16163, - [SMALL_STATE(476)] = 16183, - [SMALL_STATE(477)] = 16205, - [SMALL_STATE(478)] = 16225, - [SMALL_STATE(479)] = 16247, - [SMALL_STATE(480)] = 16260, - [SMALL_STATE(481)] = 16275, - [SMALL_STATE(482)] = 16292, - [SMALL_STATE(483)] = 16305, - [SMALL_STATE(484)] = 16318, - [SMALL_STATE(485)] = 16331, - [SMALL_STATE(486)] = 16350, - [SMALL_STATE(487)] = 16365, - [SMALL_STATE(488)] = 16378, - [SMALL_STATE(489)] = 16391, - [SMALL_STATE(490)] = 16410, - [SMALL_STATE(491)] = 16423, - [SMALL_STATE(492)] = 16439, - [SMALL_STATE(493)] = 16453, - [SMALL_STATE(494)] = 16469, - [SMALL_STATE(495)] = 16485, - [SMALL_STATE(496)] = 16501, - [SMALL_STATE(497)] = 16517, - [SMALL_STATE(498)] = 16533, - [SMALL_STATE(499)] = 16549, - [SMALL_STATE(500)] = 16565, - [SMALL_STATE(501)] = 16581, - [SMALL_STATE(502)] = 16597, - [SMALL_STATE(503)] = 16613, - [SMALL_STATE(504)] = 16627, - [SMALL_STATE(505)] = 16643, - [SMALL_STATE(506)] = 16659, - [SMALL_STATE(507)] = 16675, - [SMALL_STATE(508)] = 16691, - [SMALL_STATE(509)] = 16707, - [SMALL_STATE(510)] = 16721, - [SMALL_STATE(511)] = 16737, - [SMALL_STATE(512)] = 16753, - [SMALL_STATE(513)] = 16769, - [SMALL_STATE(514)] = 16785, - [SMALL_STATE(515)] = 16801, - [SMALL_STATE(516)] = 16812, - [SMALL_STATE(517)] = 16825, - [SMALL_STATE(518)] = 16838, - [SMALL_STATE(519)] = 16851, - [SMALL_STATE(520)] = 16864, - [SMALL_STATE(521)] = 16875, - [SMALL_STATE(522)] = 16884, - [SMALL_STATE(523)] = 16897, - [SMALL_STATE(524)] = 16906, - [SMALL_STATE(525)] = 16915, - [SMALL_STATE(526)] = 16928, - [SMALL_STATE(527)] = 16941, - [SMALL_STATE(528)] = 16954, - [SMALL_STATE(529)] = 16963, - [SMALL_STATE(530)] = 16974, - [SMALL_STATE(531)] = 16985, - [SMALL_STATE(532)] = 16998, - [SMALL_STATE(533)] = 17011, - [SMALL_STATE(534)] = 17024, - [SMALL_STATE(535)] = 17037, - [SMALL_STATE(536)] = 17048, - [SMALL_STATE(537)] = 17061, - [SMALL_STATE(538)] = 17070, - [SMALL_STATE(539)] = 17079, - [SMALL_STATE(540)] = 17090, - [SMALL_STATE(541)] = 17103, - [SMALL_STATE(542)] = 17116, - [SMALL_STATE(543)] = 17129, - [SMALL_STATE(544)] = 17140, - [SMALL_STATE(545)] = 17151, - [SMALL_STATE(546)] = 17164, - [SMALL_STATE(547)] = 17177, - [SMALL_STATE(548)] = 17190, - [SMALL_STATE(549)] = 17203, - [SMALL_STATE(550)] = 17216, - [SMALL_STATE(551)] = 17225, - [SMALL_STATE(552)] = 17234, - [SMALL_STATE(553)] = 17244, - [SMALL_STATE(554)] = 17252, - [SMALL_STATE(555)] = 17260, - [SMALL_STATE(556)] = 17268, - [SMALL_STATE(557)] = 17278, - [SMALL_STATE(558)] = 17286, - [SMALL_STATE(559)] = 17294, - [SMALL_STATE(560)] = 17302, - [SMALL_STATE(561)] = 17312, - [SMALL_STATE(562)] = 17322, - [SMALL_STATE(563)] = 17332, - [SMALL_STATE(564)] = 17342, - [SMALL_STATE(565)] = 17352, - [SMALL_STATE(566)] = 17362, - [SMALL_STATE(567)] = 17372, - [SMALL_STATE(568)] = 17382, - [SMALL_STATE(569)] = 17390, - [SMALL_STATE(570)] = 17400, - [SMALL_STATE(571)] = 17410, - [SMALL_STATE(572)] = 17418, - [SMALL_STATE(573)] = 17428, - [SMALL_STATE(574)] = 17438, - [SMALL_STATE(575)] = 17448, - [SMALL_STATE(576)] = 17458, - [SMALL_STATE(577)] = 17466, - [SMALL_STATE(578)] = 17476, - [SMALL_STATE(579)] = 17486, - [SMALL_STATE(580)] = 17496, - [SMALL_STATE(581)] = 17506, - [SMALL_STATE(582)] = 17516, - [SMALL_STATE(583)] = 17524, - [SMALL_STATE(584)] = 17534, - [SMALL_STATE(585)] = 17544, - [SMALL_STATE(586)] = 17554, - [SMALL_STATE(587)] = 17564, - [SMALL_STATE(588)] = 17574, - [SMALL_STATE(589)] = 17584, - [SMALL_STATE(590)] = 17592, - [SMALL_STATE(591)] = 17602, - [SMALL_STATE(592)] = 17612, - [SMALL_STATE(593)] = 17622, - [SMALL_STATE(594)] = 17632, - [SMALL_STATE(595)] = 17642, - [SMALL_STATE(596)] = 17652, - [SMALL_STATE(597)] = 17662, - [SMALL_STATE(598)] = 17670, - [SMALL_STATE(599)] = 17680, - [SMALL_STATE(600)] = 17690, - [SMALL_STATE(601)] = 17700, - [SMALL_STATE(602)] = 17710, - [SMALL_STATE(603)] = 17718, - [SMALL_STATE(604)] = 17728, - [SMALL_STATE(605)] = 17738, - [SMALL_STATE(606)] = 17748, - [SMALL_STATE(607)] = 17756, - [SMALL_STATE(608)] = 17766, - [SMALL_STATE(609)] = 17776, - [SMALL_STATE(610)] = 17786, - [SMALL_STATE(611)] = 17796, - [SMALL_STATE(612)] = 17806, - [SMALL_STATE(613)] = 17816, - [SMALL_STATE(614)] = 17826, - [SMALL_STATE(615)] = 17836, - [SMALL_STATE(616)] = 17844, - [SMALL_STATE(617)] = 17854, - [SMALL_STATE(618)] = 17864, - [SMALL_STATE(619)] = 17874, - [SMALL_STATE(620)] = 17884, - [SMALL_STATE(621)] = 17894, - [SMALL_STATE(622)] = 17904, - [SMALL_STATE(623)] = 17914, - [SMALL_STATE(624)] = 17924, - [SMALL_STATE(625)] = 17934, - [SMALL_STATE(626)] = 17944, - [SMALL_STATE(627)] = 17952, - [SMALL_STATE(628)] = 17962, - [SMALL_STATE(629)] = 17972, - [SMALL_STATE(630)] = 17980, - [SMALL_STATE(631)] = 17990, - [SMALL_STATE(632)] = 18000, - [SMALL_STATE(633)] = 18010, - [SMALL_STATE(634)] = 18020, - [SMALL_STATE(635)] = 18028, - [SMALL_STATE(636)] = 18038, - [SMALL_STATE(637)] = 18048, - [SMALL_STATE(638)] = 18058, - [SMALL_STATE(639)] = 18065, - [SMALL_STATE(640)] = 18072, - [SMALL_STATE(641)] = 18079, - [SMALL_STATE(642)] = 18086, - [SMALL_STATE(643)] = 18093, - [SMALL_STATE(644)] = 18100, - [SMALL_STATE(645)] = 18107, - [SMALL_STATE(646)] = 18114, - [SMALL_STATE(647)] = 18121, - [SMALL_STATE(648)] = 18128, - [SMALL_STATE(649)] = 18135, - [SMALL_STATE(650)] = 18142, - [SMALL_STATE(651)] = 18149, - [SMALL_STATE(652)] = 18156, - [SMALL_STATE(653)] = 18163, - [SMALL_STATE(654)] = 18170, - [SMALL_STATE(655)] = 18177, - [SMALL_STATE(656)] = 18184, - [SMALL_STATE(657)] = 18191, - [SMALL_STATE(658)] = 18198, - [SMALL_STATE(659)] = 18205, - [SMALL_STATE(660)] = 18212, - [SMALL_STATE(661)] = 18219, - [SMALL_STATE(662)] = 18226, - [SMALL_STATE(663)] = 18233, - [SMALL_STATE(664)] = 18240, - [SMALL_STATE(665)] = 18247, - [SMALL_STATE(666)] = 18254, - [SMALL_STATE(667)] = 18261, - [SMALL_STATE(668)] = 18268, - [SMALL_STATE(669)] = 18275, - [SMALL_STATE(670)] = 18282, - [SMALL_STATE(671)] = 18289, - [SMALL_STATE(672)] = 18296, - [SMALL_STATE(673)] = 18303, - [SMALL_STATE(674)] = 18310, - [SMALL_STATE(675)] = 18317, - [SMALL_STATE(676)] = 18324, - [SMALL_STATE(677)] = 18331, - [SMALL_STATE(678)] = 18338, - [SMALL_STATE(679)] = 18345, - [SMALL_STATE(680)] = 18352, - [SMALL_STATE(681)] = 18359, - [SMALL_STATE(682)] = 18366, - [SMALL_STATE(683)] = 18373, - [SMALL_STATE(684)] = 18380, - [SMALL_STATE(685)] = 18387, - [SMALL_STATE(686)] = 18394, - [SMALL_STATE(687)] = 18401, - [SMALL_STATE(688)] = 18408, - [SMALL_STATE(689)] = 18415, - [SMALL_STATE(690)] = 18422, - [SMALL_STATE(691)] = 18429, - [SMALL_STATE(692)] = 18436, - [SMALL_STATE(693)] = 18443, - [SMALL_STATE(694)] = 18450, - [SMALL_STATE(695)] = 18457, - [SMALL_STATE(696)] = 18464, - [SMALL_STATE(697)] = 18471, - [SMALL_STATE(698)] = 18478, - [SMALL_STATE(699)] = 18485, - [SMALL_STATE(700)] = 18492, - [SMALL_STATE(701)] = 18499, - [SMALL_STATE(702)] = 18506, - [SMALL_STATE(703)] = 18513, - [SMALL_STATE(704)] = 18520, - [SMALL_STATE(705)] = 18527, - [SMALL_STATE(706)] = 18534, - [SMALL_STATE(707)] = 18541, - [SMALL_STATE(708)] = 18548, - [SMALL_STATE(709)] = 18555, - [SMALL_STATE(710)] = 18562, - [SMALL_STATE(711)] = 18569, - [SMALL_STATE(712)] = 18576, - [SMALL_STATE(713)] = 18583, - [SMALL_STATE(714)] = 18590, - [SMALL_STATE(715)] = 18597, - [SMALL_STATE(716)] = 18604, - [SMALL_STATE(717)] = 18611, - [SMALL_STATE(718)] = 18618, - [SMALL_STATE(719)] = 18625, - [SMALL_STATE(720)] = 18632, - [SMALL_STATE(721)] = 18639, - [SMALL_STATE(722)] = 18646, - [SMALL_STATE(723)] = 18653, - [SMALL_STATE(724)] = 18660, - [SMALL_STATE(725)] = 18667, - [SMALL_STATE(726)] = 18674, - [SMALL_STATE(727)] = 18681, - [SMALL_STATE(728)] = 18688, - [SMALL_STATE(729)] = 18695, - [SMALL_STATE(730)] = 18702, - [SMALL_STATE(731)] = 18709, - [SMALL_STATE(732)] = 18716, - [SMALL_STATE(733)] = 18723, - [SMALL_STATE(734)] = 18730, - [SMALL_STATE(735)] = 18737, - [SMALL_STATE(736)] = 18744, - [SMALL_STATE(737)] = 18751, - [SMALL_STATE(738)] = 18758, - [SMALL_STATE(739)] = 18765, - [SMALL_STATE(740)] = 18772, - [SMALL_STATE(741)] = 18779, - [SMALL_STATE(742)] = 18786, - [SMALL_STATE(743)] = 18793, - [SMALL_STATE(744)] = 18800, - [SMALL_STATE(745)] = 18807, - [SMALL_STATE(746)] = 18814, - [SMALL_STATE(747)] = 18821, - [SMALL_STATE(748)] = 18828, - [SMALL_STATE(749)] = 18835, - [SMALL_STATE(750)] = 18842, - [SMALL_STATE(751)] = 18849, - [SMALL_STATE(752)] = 18856, - [SMALL_STATE(753)] = 18863, - [SMALL_STATE(754)] = 18870, - [SMALL_STATE(755)] = 18877, - [SMALL_STATE(756)] = 18884, - [SMALL_STATE(757)] = 18891, - [SMALL_STATE(758)] = 18898, - [SMALL_STATE(759)] = 18905, - [SMALL_STATE(760)] = 18912, - [SMALL_STATE(761)] = 18919, - [SMALL_STATE(762)] = 18926, - [SMALL_STATE(763)] = 18933, - [SMALL_STATE(764)] = 18940, - [SMALL_STATE(765)] = 18947, - [SMALL_STATE(766)] = 18954, - [SMALL_STATE(767)] = 18961, - [SMALL_STATE(768)] = 18968, - [SMALL_STATE(769)] = 18975, - [SMALL_STATE(770)] = 18982, - [SMALL_STATE(771)] = 18989, - [SMALL_STATE(772)] = 18996, - [SMALL_STATE(773)] = 19003, - [SMALL_STATE(774)] = 19010, - [SMALL_STATE(775)] = 19017, - [SMALL_STATE(776)] = 19024, - [SMALL_STATE(777)] = 19031, - [SMALL_STATE(778)] = 19038, - [SMALL_STATE(779)] = 19045, - [SMALL_STATE(780)] = 19052, - [SMALL_STATE(781)] = 19059, - [SMALL_STATE(782)] = 19066, - [SMALL_STATE(783)] = 19073, - [SMALL_STATE(784)] = 19080, - [SMALL_STATE(785)] = 19087, - [SMALL_STATE(786)] = 19094, - [SMALL_STATE(787)] = 19101, - [SMALL_STATE(788)] = 19108, - [SMALL_STATE(789)] = 19115, - [SMALL_STATE(790)] = 19122, - [SMALL_STATE(791)] = 19129, - [SMALL_STATE(792)] = 19136, - [SMALL_STATE(793)] = 19143, - [SMALL_STATE(794)] = 19150, - [SMALL_STATE(795)] = 19157, - [SMALL_STATE(796)] = 19164, - [SMALL_STATE(797)] = 19171, - [SMALL_STATE(798)] = 19178, - [SMALL_STATE(799)] = 19185, - [SMALL_STATE(800)] = 19192, - [SMALL_STATE(801)] = 19199, - [SMALL_STATE(802)] = 19206, - [SMALL_STATE(803)] = 19213, - [SMALL_STATE(804)] = 19220, - [SMALL_STATE(805)] = 19227, - [SMALL_STATE(806)] = 19234, - [SMALL_STATE(807)] = 19241, - [SMALL_STATE(808)] = 19248, - [SMALL_STATE(809)] = 19255, - [SMALL_STATE(810)] = 19262, - [SMALL_STATE(811)] = 19269, - [SMALL_STATE(812)] = 19276, - [SMALL_STATE(813)] = 19283, - [SMALL_STATE(814)] = 19290, - [SMALL_STATE(815)] = 19297, - [SMALL_STATE(816)] = 19304, - [SMALL_STATE(817)] = 19311, - [SMALL_STATE(818)] = 19318, - [SMALL_STATE(819)] = 19325, + [SMALL_STATE(218)] = 6824, + [SMALL_STATE(219)] = 6879, + [SMALL_STATE(220)] = 6940, + [SMALL_STATE(221)] = 6994, + [SMALL_STATE(222)] = 7052, + [SMALL_STATE(223)] = 7106, + [SMALL_STATE(224)] = 7160, + [SMALL_STATE(225)] = 7248, + [SMALL_STATE(226)] = 7302, + [SMALL_STATE(227)] = 7356, + [SMALL_STATE(228)] = 7410, + [SMALL_STATE(229)] = 7464, + [SMALL_STATE(230)] = 7518, + [SMALL_STATE(231)] = 7576, + [SMALL_STATE(232)] = 7630, + [SMALL_STATE(233)] = 7684, + [SMALL_STATE(234)] = 7738, + [SMALL_STATE(235)] = 7826, + [SMALL_STATE(236)] = 7880, + [SMALL_STATE(237)] = 7934, + [SMALL_STATE(238)] = 7988, + [SMALL_STATE(239)] = 8042, + [SMALL_STATE(240)] = 8096, + [SMALL_STATE(241)] = 8150, + [SMALL_STATE(242)] = 8204, + [SMALL_STATE(243)] = 8258, + [SMALL_STATE(244)] = 8312, + [SMALL_STATE(245)] = 8366, + [SMALL_STATE(246)] = 8420, + [SMALL_STATE(247)] = 8474, + [SMALL_STATE(248)] = 8528, + [SMALL_STATE(249)] = 8582, + [SMALL_STATE(250)] = 8636, + [SMALL_STATE(251)] = 8690, + [SMALL_STATE(252)] = 8744, + [SMALL_STATE(253)] = 8798, + [SMALL_STATE(254)] = 8852, + [SMALL_STATE(255)] = 8906, + [SMALL_STATE(256)] = 8960, + [SMALL_STATE(257)] = 9014, + [SMALL_STATE(258)] = 9076, + [SMALL_STATE(259)] = 9130, + [SMALL_STATE(260)] = 9184, + [SMALL_STATE(261)] = 9238, + [SMALL_STATE(262)] = 9292, + [SMALL_STATE(263)] = 9346, + [SMALL_STATE(264)] = 9400, + [SMALL_STATE(265)] = 9457, + [SMALL_STATE(266)] = 9507, + [SMALL_STATE(267)] = 9557, + [SMALL_STATE(268)] = 9613, + [SMALL_STATE(269)] = 9669, + [SMALL_STATE(270)] = 9722, + [SMALL_STATE(271)] = 9772, + [SMALL_STATE(272)] = 9818, + [SMALL_STATE(273)] = 9870, + [SMALL_STATE(274)] = 9923, + [SMALL_STATE(275)] = 9972, + [SMALL_STATE(276)] = 10019, + [SMALL_STATE(277)] = 10068, + [SMALL_STATE(278)] = 10117, + [SMALL_STATE(279)] = 10161, + [SMALL_STATE(280)] = 10205, + [SMALL_STATE(281)] = 10249, + [SMALL_STATE(282)] = 10295, + [SMALL_STATE(283)] = 10339, + [SMALL_STATE(284)] = 10383, + [SMALL_STATE(285)] = 10426, + [SMALL_STATE(286)] = 10469, + [SMALL_STATE(287)] = 10512, + [SMALL_STATE(288)] = 10555, + [SMALL_STATE(289)] = 10600, + [SMALL_STATE(290)] = 10643, + [SMALL_STATE(291)] = 10686, + [SMALL_STATE(292)] = 10737, + [SMALL_STATE(293)] = 10780, + [SMALL_STATE(294)] = 10823, + [SMALL_STATE(295)] = 10866, + [SMALL_STATE(296)] = 10909, + [SMALL_STATE(297)] = 10952, + [SMALL_STATE(298)] = 10995, + [SMALL_STATE(299)] = 11038, + [SMALL_STATE(300)] = 11081, + [SMALL_STATE(301)] = 11124, + [SMALL_STATE(302)] = 11167, + [SMALL_STATE(303)] = 11210, + [SMALL_STATE(304)] = 11253, + [SMALL_STATE(305)] = 11296, + [SMALL_STATE(306)] = 11339, + [SMALL_STATE(307)] = 11382, + [SMALL_STATE(308)] = 11433, + [SMALL_STATE(309)] = 11476, + [SMALL_STATE(310)] = 11519, + [SMALL_STATE(311)] = 11562, + [SMALL_STATE(312)] = 11605, + [SMALL_STATE(313)] = 11648, + [SMALL_STATE(314)] = 11691, + [SMALL_STATE(315)] = 11734, + [SMALL_STATE(316)] = 11781, + [SMALL_STATE(317)] = 11824, + [SMALL_STATE(318)] = 11867, + [SMALL_STATE(319)] = 11910, + [SMALL_STATE(320)] = 11953, + [SMALL_STATE(321)] = 11996, + [SMALL_STATE(322)] = 12039, + [SMALL_STATE(323)] = 12082, + [SMALL_STATE(324)] = 12125, + [SMALL_STATE(325)] = 12168, + [SMALL_STATE(326)] = 12208, + [SMALL_STATE(327)] = 12248, + [SMALL_STATE(328)] = 12288, + [SMALL_STATE(329)] = 12328, + [SMALL_STATE(330)] = 12368, + [SMALL_STATE(331)] = 12408, + [SMALL_STATE(332)] = 12448, + [SMALL_STATE(333)] = 12488, + [SMALL_STATE(334)] = 12528, + [SMALL_STATE(335)] = 12568, + [SMALL_STATE(336)] = 12610, + [SMALL_STATE(337)] = 12650, + [SMALL_STATE(338)] = 12690, + [SMALL_STATE(339)] = 12730, + [SMALL_STATE(340)] = 12770, + [SMALL_STATE(341)] = 12812, + [SMALL_STATE(342)] = 12852, + [SMALL_STATE(343)] = 12892, + [SMALL_STATE(344)] = 12932, + [SMALL_STATE(345)] = 12972, + [SMALL_STATE(346)] = 13012, + [SMALL_STATE(347)] = 13052, + [SMALL_STATE(348)] = 13092, + [SMALL_STATE(349)] = 13132, + [SMALL_STATE(350)] = 13173, + [SMALL_STATE(351)] = 13218, + [SMALL_STATE(352)] = 13257, + [SMALL_STATE(353)] = 13296, + [SMALL_STATE(354)] = 13335, + [SMALL_STATE(355)] = 13374, + [SMALL_STATE(356)] = 13413, + [SMALL_STATE(357)] = 13458, + [SMALL_STATE(358)] = 13497, + [SMALL_STATE(359)] = 13539, + [SMALL_STATE(360)] = 13577, + [SMALL_STATE(361)] = 13612, + [SMALL_STATE(362)] = 13647, + [SMALL_STATE(363)] = 13685, + [SMALL_STATE(364)] = 13745, + [SMALL_STATE(365)] = 13778, + [SMALL_STATE(366)] = 13835, + [SMALL_STATE(367)] = 13892, + [SMALL_STATE(368)] = 13923, + [SMALL_STATE(369)] = 13952, + [SMALL_STATE(370)] = 13983, + [SMALL_STATE(371)] = 14012, + [SMALL_STATE(372)] = 14042, + [SMALL_STATE(373)] = 14090, + [SMALL_STATE(374)] = 14120, + [SMALL_STATE(375)] = 14149, + [SMALL_STATE(376)] = 14178, + [SMALL_STATE(377)] = 14208, + [SMALL_STATE(378)] = 14248, + [SMALL_STATE(379)] = 14288, + [SMALL_STATE(380)] = 14318, + [SMALL_STATE(381)] = 14342, + [SMALL_STATE(382)] = 14367, + [SMALL_STATE(383)] = 14394, + [SMALL_STATE(384)] = 14421, + [SMALL_STATE(385)] = 14446, + [SMALL_STATE(386)] = 14470, + [SMALL_STATE(387)] = 14494, + [SMALL_STATE(388)] = 14517, + [SMALL_STATE(389)] = 14540, + [SMALL_STATE(390)] = 14559, + [SMALL_STATE(391)] = 14578, + [SMALL_STATE(392)] = 14601, + [SMALL_STATE(393)] = 14620, + [SMALL_STATE(394)] = 14643, + [SMALL_STATE(395)] = 14666, + [SMALL_STATE(396)] = 14684, + [SMALL_STATE(397)] = 14702, + [SMALL_STATE(398)] = 14724, + [SMALL_STATE(399)] = 14744, + [SMALL_STATE(400)] = 14764, + [SMALL_STATE(401)] = 14784, + [SMALL_STATE(402)] = 14806, + [SMALL_STATE(403)] = 14826, + [SMALL_STATE(404)] = 14847, + [SMALL_STATE(405)] = 14868, + [SMALL_STATE(406)] = 14901, + [SMALL_STATE(407)] = 14922, + [SMALL_STATE(408)] = 14945, + [SMALL_STATE(409)] = 14966, + [SMALL_STATE(410)] = 14996, + [SMALL_STATE(411)] = 15022, + [SMALL_STATE(412)] = 15048, + [SMALL_STATE(413)] = 15078, + [SMALL_STATE(414)] = 15096, + [SMALL_STATE(415)] = 15114, + [SMALL_STATE(416)] = 15144, + [SMALL_STATE(417)] = 15164, + [SMALL_STATE(418)] = 15194, + [SMALL_STATE(419)] = 15211, + [SMALL_STATE(420)] = 15228, + [SMALL_STATE(421)] = 15245, + [SMALL_STATE(422)] = 15262, + [SMALL_STATE(423)] = 15279, + [SMALL_STATE(424)] = 15298, + [SMALL_STATE(425)] = 15315, + [SMALL_STATE(426)] = 15332, + [SMALL_STATE(427)] = 15349, + [SMALL_STATE(428)] = 15368, + [SMALL_STATE(429)] = 15385, + [SMALL_STATE(430)] = 15402, + [SMALL_STATE(431)] = 15419, + [SMALL_STATE(432)] = 15436, + [SMALL_STATE(433)] = 15453, + [SMALL_STATE(434)] = 15470, + [SMALL_STATE(435)] = 15489, + [SMALL_STATE(436)] = 15506, + [SMALL_STATE(437)] = 15525, + [SMALL_STATE(438)] = 15542, + [SMALL_STATE(439)] = 15559, + [SMALL_STATE(440)] = 15576, + [SMALL_STATE(441)] = 15593, + [SMALL_STATE(442)] = 15610, + [SMALL_STATE(443)] = 15627, + [SMALL_STATE(444)] = 15644, + [SMALL_STATE(445)] = 15661, + [SMALL_STATE(446)] = 15678, + [SMALL_STATE(447)] = 15695, + [SMALL_STATE(448)] = 15712, + [SMALL_STATE(449)] = 15729, + [SMALL_STATE(450)] = 15746, + [SMALL_STATE(451)] = 15763, + [SMALL_STATE(452)] = 15780, + [SMALL_STATE(453)] = 15797, + [SMALL_STATE(454)] = 15814, + [SMALL_STATE(455)] = 15831, + [SMALL_STATE(456)] = 15848, + [SMALL_STATE(457)] = 15865, + [SMALL_STATE(458)] = 15882, + [SMALL_STATE(459)] = 15899, + [SMALL_STATE(460)] = 15917, + [SMALL_STATE(461)] = 15945, + [SMALL_STATE(462)] = 15961, + [SMALL_STATE(463)] = 15989, + [SMALL_STATE(464)] = 16015, + [SMALL_STATE(465)] = 16041, + [SMALL_STATE(466)] = 16066, + [SMALL_STATE(467)] = 16089, + [SMALL_STATE(468)] = 16112, + [SMALL_STATE(469)] = 16134, + [SMALL_STATE(470)] = 16146, + [SMALL_STATE(471)] = 16168, + [SMALL_STATE(472)] = 16188, + [SMALL_STATE(473)] = 16210, + [SMALL_STATE(474)] = 16232, + [SMALL_STATE(475)] = 16254, + [SMALL_STATE(476)] = 16274, + [SMALL_STATE(477)] = 16292, + [SMALL_STATE(478)] = 16314, + [SMALL_STATE(479)] = 16328, + [SMALL_STATE(480)] = 16340, + [SMALL_STATE(481)] = 16352, + [SMALL_STATE(482)] = 16371, + [SMALL_STATE(483)] = 16384, + [SMALL_STATE(484)] = 16399, + [SMALL_STATE(485)] = 16412, + [SMALL_STATE(486)] = 16429, + [SMALL_STATE(487)] = 16442, + [SMALL_STATE(488)] = 16457, + [SMALL_STATE(489)] = 16476, + [SMALL_STATE(490)] = 16489, + [SMALL_STATE(491)] = 16502, + [SMALL_STATE(492)] = 16515, + [SMALL_STATE(493)] = 16528, + [SMALL_STATE(494)] = 16544, + [SMALL_STATE(495)] = 16560, + [SMALL_STATE(496)] = 16576, + [SMALL_STATE(497)] = 16592, + [SMALL_STATE(498)] = 16608, + [SMALL_STATE(499)] = 16622, + [SMALL_STATE(500)] = 16638, + [SMALL_STATE(501)] = 16654, + [SMALL_STATE(502)] = 16670, + [SMALL_STATE(503)] = 16686, + [SMALL_STATE(504)] = 16702, + [SMALL_STATE(505)] = 16718, + [SMALL_STATE(506)] = 16732, + [SMALL_STATE(507)] = 16748, + [SMALL_STATE(508)] = 16764, + [SMALL_STATE(509)] = 16780, + [SMALL_STATE(510)] = 16796, + [SMALL_STATE(511)] = 16812, + [SMALL_STATE(512)] = 16826, + [SMALL_STATE(513)] = 16842, + [SMALL_STATE(514)] = 16858, + [SMALL_STATE(515)] = 16874, + [SMALL_STATE(516)] = 16890, + [SMALL_STATE(517)] = 16906, + [SMALL_STATE(518)] = 16919, + [SMALL_STATE(519)] = 16928, + [SMALL_STATE(520)] = 16939, + [SMALL_STATE(521)] = 16952, + [SMALL_STATE(522)] = 16965, + [SMALL_STATE(523)] = 16976, + [SMALL_STATE(524)] = 16987, + [SMALL_STATE(525)] = 17000, + [SMALL_STATE(526)] = 17013, + [SMALL_STATE(527)] = 17026, + [SMALL_STATE(528)] = 17035, + [SMALL_STATE(529)] = 17044, + [SMALL_STATE(530)] = 17055, + [SMALL_STATE(531)] = 17068, + [SMALL_STATE(532)] = 17081, + [SMALL_STATE(533)] = 17090, + [SMALL_STATE(534)] = 17103, + [SMALL_STATE(535)] = 17116, + [SMALL_STATE(536)] = 17129, + [SMALL_STATE(537)] = 17140, + [SMALL_STATE(538)] = 17153, + [SMALL_STATE(539)] = 17162, + [SMALL_STATE(540)] = 17171, + [SMALL_STATE(541)] = 17180, + [SMALL_STATE(542)] = 17193, + [SMALL_STATE(543)] = 17204, + [SMALL_STATE(544)] = 17215, + [SMALL_STATE(545)] = 17228, + [SMALL_STATE(546)] = 17241, + [SMALL_STATE(547)] = 17252, + [SMALL_STATE(548)] = 17265, + [SMALL_STATE(549)] = 17278, + [SMALL_STATE(550)] = 17291, + [SMALL_STATE(551)] = 17304, + [SMALL_STATE(552)] = 17317, + [SMALL_STATE(553)] = 17330, + [SMALL_STATE(554)] = 17339, + [SMALL_STATE(555)] = 17349, + [SMALL_STATE(556)] = 17359, + [SMALL_STATE(557)] = 17367, + [SMALL_STATE(558)] = 17377, + [SMALL_STATE(559)] = 17387, + [SMALL_STATE(560)] = 17397, + [SMALL_STATE(561)] = 17405, + [SMALL_STATE(562)] = 17415, + [SMALL_STATE(563)] = 17423, + [SMALL_STATE(564)] = 17433, + [SMALL_STATE(565)] = 17443, + [SMALL_STATE(566)] = 17451, + [SMALL_STATE(567)] = 17461, + [SMALL_STATE(568)] = 17471, + [SMALL_STATE(569)] = 17481, + [SMALL_STATE(570)] = 17491, + [SMALL_STATE(571)] = 17501, + [SMALL_STATE(572)] = 17511, + [SMALL_STATE(573)] = 17521, + [SMALL_STATE(574)] = 17531, + [SMALL_STATE(575)] = 17541, + [SMALL_STATE(576)] = 17551, + [SMALL_STATE(577)] = 17561, + [SMALL_STATE(578)] = 17571, + [SMALL_STATE(579)] = 17579, + [SMALL_STATE(580)] = 17587, + [SMALL_STATE(581)] = 17597, + [SMALL_STATE(582)] = 17607, + [SMALL_STATE(583)] = 17615, + [SMALL_STATE(584)] = 17625, + [SMALL_STATE(585)] = 17633, + [SMALL_STATE(586)] = 17641, + [SMALL_STATE(587)] = 17651, + [SMALL_STATE(588)] = 17661, + [SMALL_STATE(589)] = 17669, + [SMALL_STATE(590)] = 17679, + [SMALL_STATE(591)] = 17689, + [SMALL_STATE(592)] = 17697, + [SMALL_STATE(593)] = 17707, + [SMALL_STATE(594)] = 17715, + [SMALL_STATE(595)] = 17725, + [SMALL_STATE(596)] = 17735, + [SMALL_STATE(597)] = 17745, + [SMALL_STATE(598)] = 17755, + [SMALL_STATE(599)] = 17763, + [SMALL_STATE(600)] = 17773, + [SMALL_STATE(601)] = 17783, + [SMALL_STATE(602)] = 17793, + [SMALL_STATE(603)] = 17803, + [SMALL_STATE(604)] = 17811, + [SMALL_STATE(605)] = 17821, + [SMALL_STATE(606)] = 17831, + [SMALL_STATE(607)] = 17841, + [SMALL_STATE(608)] = 17849, + [SMALL_STATE(609)] = 17857, + [SMALL_STATE(610)] = 17867, + [SMALL_STATE(611)] = 17877, + [SMALL_STATE(612)] = 17887, + [SMALL_STATE(613)] = 17895, + [SMALL_STATE(614)] = 17905, + [SMALL_STATE(615)] = 17915, + [SMALL_STATE(616)] = 17925, + [SMALL_STATE(617)] = 17935, + [SMALL_STATE(618)] = 17945, + [SMALL_STATE(619)] = 17955, + [SMALL_STATE(620)] = 17965, + [SMALL_STATE(621)] = 17975, + [SMALL_STATE(622)] = 17985, + [SMALL_STATE(623)] = 17995, + [SMALL_STATE(624)] = 18005, + [SMALL_STATE(625)] = 18013, + [SMALL_STATE(626)] = 18023, + [SMALL_STATE(627)] = 18033, + [SMALL_STATE(628)] = 18043, + [SMALL_STATE(629)] = 18053, + [SMALL_STATE(630)] = 18063, + [SMALL_STATE(631)] = 18073, + [SMALL_STATE(632)] = 18083, + [SMALL_STATE(633)] = 18093, + [SMALL_STATE(634)] = 18103, + [SMALL_STATE(635)] = 18113, + [SMALL_STATE(636)] = 18123, + [SMALL_STATE(637)] = 18133, + [SMALL_STATE(638)] = 18143, + [SMALL_STATE(639)] = 18153, + [SMALL_STATE(640)] = 18163, + [SMALL_STATE(641)] = 18170, + [SMALL_STATE(642)] = 18177, + [SMALL_STATE(643)] = 18184, + [SMALL_STATE(644)] = 18191, + [SMALL_STATE(645)] = 18198, + [SMALL_STATE(646)] = 18205, + [SMALL_STATE(647)] = 18212, + [SMALL_STATE(648)] = 18219, + [SMALL_STATE(649)] = 18226, + [SMALL_STATE(650)] = 18233, + [SMALL_STATE(651)] = 18240, + [SMALL_STATE(652)] = 18247, + [SMALL_STATE(653)] = 18254, + [SMALL_STATE(654)] = 18261, + [SMALL_STATE(655)] = 18268, + [SMALL_STATE(656)] = 18275, + [SMALL_STATE(657)] = 18282, + [SMALL_STATE(658)] = 18289, + [SMALL_STATE(659)] = 18296, + [SMALL_STATE(660)] = 18303, + [SMALL_STATE(661)] = 18310, + [SMALL_STATE(662)] = 18317, + [SMALL_STATE(663)] = 18324, + [SMALL_STATE(664)] = 18331, + [SMALL_STATE(665)] = 18338, + [SMALL_STATE(666)] = 18345, + [SMALL_STATE(667)] = 18352, + [SMALL_STATE(668)] = 18359, + [SMALL_STATE(669)] = 18366, + [SMALL_STATE(670)] = 18373, + [SMALL_STATE(671)] = 18380, + [SMALL_STATE(672)] = 18387, + [SMALL_STATE(673)] = 18394, + [SMALL_STATE(674)] = 18401, + [SMALL_STATE(675)] = 18408, + [SMALL_STATE(676)] = 18415, + [SMALL_STATE(677)] = 18422, + [SMALL_STATE(678)] = 18429, + [SMALL_STATE(679)] = 18436, + [SMALL_STATE(680)] = 18443, + [SMALL_STATE(681)] = 18450, + [SMALL_STATE(682)] = 18457, + [SMALL_STATE(683)] = 18464, + [SMALL_STATE(684)] = 18471, + [SMALL_STATE(685)] = 18478, + [SMALL_STATE(686)] = 18485, + [SMALL_STATE(687)] = 18492, + [SMALL_STATE(688)] = 18499, + [SMALL_STATE(689)] = 18506, + [SMALL_STATE(690)] = 18513, + [SMALL_STATE(691)] = 18520, + [SMALL_STATE(692)] = 18527, + [SMALL_STATE(693)] = 18534, + [SMALL_STATE(694)] = 18541, + [SMALL_STATE(695)] = 18548, + [SMALL_STATE(696)] = 18555, + [SMALL_STATE(697)] = 18562, + [SMALL_STATE(698)] = 18569, + [SMALL_STATE(699)] = 18576, + [SMALL_STATE(700)] = 18583, + [SMALL_STATE(701)] = 18590, + [SMALL_STATE(702)] = 18597, + [SMALL_STATE(703)] = 18604, + [SMALL_STATE(704)] = 18611, + [SMALL_STATE(705)] = 18618, + [SMALL_STATE(706)] = 18625, + [SMALL_STATE(707)] = 18632, + [SMALL_STATE(708)] = 18639, + [SMALL_STATE(709)] = 18646, + [SMALL_STATE(710)] = 18653, + [SMALL_STATE(711)] = 18660, + [SMALL_STATE(712)] = 18667, + [SMALL_STATE(713)] = 18674, + [SMALL_STATE(714)] = 18681, + [SMALL_STATE(715)] = 18688, + [SMALL_STATE(716)] = 18695, + [SMALL_STATE(717)] = 18702, + [SMALL_STATE(718)] = 18709, + [SMALL_STATE(719)] = 18716, + [SMALL_STATE(720)] = 18723, + [SMALL_STATE(721)] = 18730, + [SMALL_STATE(722)] = 18737, + [SMALL_STATE(723)] = 18744, + [SMALL_STATE(724)] = 18751, + [SMALL_STATE(725)] = 18758, + [SMALL_STATE(726)] = 18765, + [SMALL_STATE(727)] = 18772, + [SMALL_STATE(728)] = 18779, + [SMALL_STATE(729)] = 18786, + [SMALL_STATE(730)] = 18793, + [SMALL_STATE(731)] = 18800, + [SMALL_STATE(732)] = 18807, + [SMALL_STATE(733)] = 18814, + [SMALL_STATE(734)] = 18821, + [SMALL_STATE(735)] = 18828, + [SMALL_STATE(736)] = 18835, + [SMALL_STATE(737)] = 18842, + [SMALL_STATE(738)] = 18849, + [SMALL_STATE(739)] = 18856, + [SMALL_STATE(740)] = 18863, + [SMALL_STATE(741)] = 18870, + [SMALL_STATE(742)] = 18877, + [SMALL_STATE(743)] = 18884, + [SMALL_STATE(744)] = 18891, + [SMALL_STATE(745)] = 18898, + [SMALL_STATE(746)] = 18905, + [SMALL_STATE(747)] = 18912, + [SMALL_STATE(748)] = 18919, + [SMALL_STATE(749)] = 18926, + [SMALL_STATE(750)] = 18933, + [SMALL_STATE(751)] = 18940, + [SMALL_STATE(752)] = 18947, + [SMALL_STATE(753)] = 18954, + [SMALL_STATE(754)] = 18961, + [SMALL_STATE(755)] = 18968, + [SMALL_STATE(756)] = 18975, + [SMALL_STATE(757)] = 18982, + [SMALL_STATE(758)] = 18989, + [SMALL_STATE(759)] = 18996, + [SMALL_STATE(760)] = 19003, + [SMALL_STATE(761)] = 19010, + [SMALL_STATE(762)] = 19017, + [SMALL_STATE(763)] = 19024, + [SMALL_STATE(764)] = 19031, + [SMALL_STATE(765)] = 19038, + [SMALL_STATE(766)] = 19045, + [SMALL_STATE(767)] = 19052, + [SMALL_STATE(768)] = 19059, + [SMALL_STATE(769)] = 19066, + [SMALL_STATE(770)] = 19073, + [SMALL_STATE(771)] = 19080, + [SMALL_STATE(772)] = 19087, + [SMALL_STATE(773)] = 19094, + [SMALL_STATE(774)] = 19101, + [SMALL_STATE(775)] = 19108, + [SMALL_STATE(776)] = 19115, + [SMALL_STATE(777)] = 19122, + [SMALL_STATE(778)] = 19129, + [SMALL_STATE(779)] = 19136, + [SMALL_STATE(780)] = 19143, + [SMALL_STATE(781)] = 19150, + [SMALL_STATE(782)] = 19157, + [SMALL_STATE(783)] = 19164, + [SMALL_STATE(784)] = 19171, + [SMALL_STATE(785)] = 19178, + [SMALL_STATE(786)] = 19185, + [SMALL_STATE(787)] = 19192, + [SMALL_STATE(788)] = 19199, + [SMALL_STATE(789)] = 19206, + [SMALL_STATE(790)] = 19213, + [SMALL_STATE(791)] = 19220, + [SMALL_STATE(792)] = 19227, + [SMALL_STATE(793)] = 19234, + [SMALL_STATE(794)] = 19241, + [SMALL_STATE(795)] = 19248, + [SMALL_STATE(796)] = 19255, + [SMALL_STATE(797)] = 19262, + [SMALL_STATE(798)] = 19269, + [SMALL_STATE(799)] = 19276, + [SMALL_STATE(800)] = 19283, + [SMALL_STATE(801)] = 19290, + [SMALL_STATE(802)] = 19297, + [SMALL_STATE(803)] = 19304, + [SMALL_STATE(804)] = 19311, + [SMALL_STATE(805)] = 19318, + [SMALL_STATE(806)] = 19325, + [SMALL_STATE(807)] = 19332, + [SMALL_STATE(808)] = 19339, + [SMALL_STATE(809)] = 19346, + [SMALL_STATE(810)] = 19353, + [SMALL_STATE(811)] = 19360, + [SMALL_STATE(812)] = 19367, + [SMALL_STATE(813)] = 19374, + [SMALL_STATE(814)] = 19381, + [SMALL_STATE(815)] = 19388, + [SMALL_STATE(816)] = 19395, + [SMALL_STATE(817)] = 19402, + [SMALL_STATE(818)] = 19409, + [SMALL_STATE(819)] = 19416, + [SMALL_STATE(820)] = 19423, + [SMALL_STATE(821)] = 19430, }; static TSParseActionEntry ts_parse_actions[] = { @@ -37078,153 +37179,153 @@ static TSParseActionEntry ts_parse_actions[] = { [1] = {.entry = {.count = 1, .reusable = false}}, RECOVER(), [3] = {.entry = {.count = 1, .reusable = true}}, SHIFT_EXTRA(), [5] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_unit, 0), - [7] = {.entry = {.count = 1, .reusable = true}}, SHIFT(560), - [9] = {.entry = {.count = 1, .reusable = true}}, SHIFT(370), - [11] = {.entry = {.count = 1, .reusable = true}}, SHIFT(468), - [13] = {.entry = {.count = 1, .reusable = true}}, SHIFT(807), - [15] = {.entry = {.count = 1, .reusable = true}}, SHIFT(512), - [17] = {.entry = {.count = 1, .reusable = true}}, SHIFT(540), - [19] = {.entry = {.count = 1, .reusable = true}}, SHIFT(573), - [21] = {.entry = {.count = 1, .reusable = true}}, SHIFT(469), - [23] = {.entry = {.count = 1, .reusable = true}}, SHIFT(474), + [7] = {.entry = {.count = 1, .reusable = true}}, SHIFT(558), + [9] = {.entry = {.count = 1, .reusable = true}}, SHIFT(372), + [11] = {.entry = {.count = 1, .reusable = true}}, SHIFT(472), + [13] = {.entry = {.count = 1, .reusable = true}}, SHIFT(809), + [15] = {.entry = {.count = 1, .reusable = true}}, SHIFT(501), + [17] = {.entry = {.count = 1, .reusable = true}}, SHIFT(521), + [19] = {.entry = {.count = 1, .reusable = true}}, SHIFT(583), + [21] = {.entry = {.count = 1, .reusable = true}}, SHIFT(479), + [23] = {.entry = {.count = 1, .reusable = true}}, SHIFT(469), [25] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_control_statement, 1), - [27] = {.entry = {.count = 1, .reusable = true}}, SHIFT(28), - [29] = {.entry = {.count = 1, .reusable = false}}, SHIFT(508), - [31] = {.entry = {.count = 1, .reusable = true}}, SHIFT(709), - [33] = {.entry = {.count = 1, .reusable = true}}, SHIFT(27), - [35] = {.entry = {.count = 1, .reusable = true}}, SHIFT(129), - [37] = {.entry = {.count = 1, .reusable = false}}, SHIFT(293), - [39] = {.entry = {.count = 1, .reusable = false}}, SHIFT(661), - [41] = {.entry = {.count = 1, .reusable = true}}, SHIFT(133), - [43] = {.entry = {.count = 1, .reusable = false}}, SHIFT(662), - [45] = {.entry = {.count = 1, .reusable = true}}, SHIFT(11), - [47] = {.entry = {.count = 1, .reusable = true}}, SHIFT(358), - [49] = {.entry = {.count = 1, .reusable = true}}, SHIFT(401), - [51] = {.entry = {.count = 1, .reusable = true}}, SHIFT(480), - [53] = {.entry = {.count = 1, .reusable = false}}, SHIFT(158), - [55] = {.entry = {.count = 1, .reusable = true}}, SHIFT(158), - [57] = {.entry = {.count = 1, .reusable = true}}, SHIFT(489), - [59] = {.entry = {.count = 1, .reusable = true}}, SHIFT(462), - [61] = {.entry = {.count = 1, .reusable = false}}, SHIFT(672), + [27] = {.entry = {.count = 1, .reusable = true}}, SHIFT(36), + [29] = {.entry = {.count = 1, .reusable = false}}, SHIFT(507), + [31] = {.entry = {.count = 1, .reusable = true}}, SHIFT(707), + [33] = {.entry = {.count = 1, .reusable = true}}, SHIFT(26), + [35] = {.entry = {.count = 1, .reusable = true}}, SHIFT(132), + [37] = {.entry = {.count = 1, .reusable = false}}, SHIFT(295), + [39] = {.entry = {.count = 1, .reusable = false}}, SHIFT(663), + [41] = {.entry = {.count = 1, .reusable = true}}, SHIFT(137), + [43] = {.entry = {.count = 1, .reusable = false}}, SHIFT(664), + [45] = {.entry = {.count = 1, .reusable = true}}, SHIFT(14), + [47] = {.entry = {.count = 1, .reusable = true}}, SHIFT(360), + [49] = {.entry = {.count = 1, .reusable = true}}, SHIFT(408), + [51] = {.entry = {.count = 1, .reusable = true}}, SHIFT(487), + [53] = {.entry = {.count = 1, .reusable = false}}, SHIFT(157), + [55] = {.entry = {.count = 1, .reusable = true}}, SHIFT(157), + [57] = {.entry = {.count = 1, .reusable = true}}, SHIFT(488), + [59] = {.entry = {.count = 1, .reusable = true}}, SHIFT(463), + [61] = {.entry = {.count = 1, .reusable = false}}, SHIFT(674), [63] = {.entry = {.count = 1, .reusable = false}}, SHIFT(675), - [65] = {.entry = {.count = 1, .reusable = false}}, SHIFT(676), - [67] = {.entry = {.count = 1, .reusable = false}}, SHIFT(648), - [69] = {.entry = {.count = 1, .reusable = false}}, SHIFT(677), - [71] = {.entry = {.count = 1, .reusable = false}}, SHIFT(543), - [73] = {.entry = {.count = 1, .reusable = false}}, SHIFT(679), + [65] = {.entry = {.count = 1, .reusable = false}}, SHIFT(689), + [67] = {.entry = {.count = 1, .reusable = false}}, SHIFT(678), + [69] = {.entry = {.count = 1, .reusable = false}}, SHIFT(679), + [71] = {.entry = {.count = 1, .reusable = false}}, SHIFT(542), + [73] = {.entry = {.count = 1, .reusable = false}}, SHIFT(681), [75] = {.entry = {.count = 1, .reusable = false}}, SHIFT(682), - [77] = {.entry = {.count = 1, .reusable = false}}, SHIFT(683), + [77] = {.entry = {.count = 1, .reusable = false}}, SHIFT(685), [79] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_control_statement, 1), [81] = {.entry = {.count = 1, .reusable = true}}, SHIFT(147), - [83] = {.entry = {.count = 1, .reusable = false}}, SHIFT(583), - [85] = {.entry = {.count = 1, .reusable = false}}, SHIFT(809), - [87] = {.entry = {.count = 1, .reusable = false}}, SHIFT(719), - [89] = {.entry = {.count = 1, .reusable = false}}, SHIFT(720), - [91] = {.entry = {.count = 1, .reusable = false}}, SHIFT(58), - [93] = {.entry = {.count = 1, .reusable = false}}, SHIFT(406), + [83] = {.entry = {.count = 1, .reusable = false}}, SHIFT(597), + [85] = {.entry = {.count = 1, .reusable = false}}, SHIFT(811), + [87] = {.entry = {.count = 1, .reusable = false}}, SHIFT(692), + [89] = {.entry = {.count = 1, .reusable = false}}, SHIFT(721), + [91] = {.entry = {.count = 1, .reusable = false}}, SHIFT(65), + [93] = {.entry = {.count = 1, .reusable = false}}, SHIFT(407), [95] = {.entry = {.count = 1, .reusable = false}}, SHIFT(2), - [97] = {.entry = {.count = 1, .reusable = false}}, SHIFT(205), - [99] = {.entry = {.count = 1, .reusable = false}}, SHIFT(507), - [101] = {.entry = {.count = 1, .reusable = true}}, SHIFT(138), - [103] = {.entry = {.count = 1, .reusable = false}}, SHIFT(535), - [105] = {.entry = {.count = 1, .reusable = false}}, SHIFT(580), - [107] = {.entry = {.count = 1, .reusable = false}}, SHIFT(812), + [97] = {.entry = {.count = 1, .reusable = false}}, SHIFT(214), + [99] = {.entry = {.count = 1, .reusable = false}}, SHIFT(494), + [101] = {.entry = {.count = 1, .reusable = true}}, SHIFT(135), + [103] = {.entry = {.count = 1, .reusable = false}}, SHIFT(523), + [105] = {.entry = {.count = 1, .reusable = false}}, SHIFT(592), + [107] = {.entry = {.count = 1, .reusable = false}}, SHIFT(814), [109] = {.entry = {.count = 1, .reusable = false}}, SHIFT(59), [111] = {.entry = {.count = 1, .reusable = false}}, SHIFT(3), - [113] = {.entry = {.count = 1, .reusable = false}}, SHIFT(497), - [115] = {.entry = {.count = 1, .reusable = true}}, SHIFT(132), - [117] = {.entry = {.count = 1, .reusable = false}}, SHIFT(544), - [119] = {.entry = {.count = 1, .reusable = false}}, SHIFT(599), - [121] = {.entry = {.count = 1, .reusable = false}}, SHIFT(801), - [123] = {.entry = {.count = 1, .reusable = false}}, SHIFT(56), + [113] = {.entry = {.count = 1, .reusable = false}}, SHIFT(496), + [115] = {.entry = {.count = 1, .reusable = true}}, SHIFT(130), + [117] = {.entry = {.count = 1, .reusable = false}}, SHIFT(546), + [119] = {.entry = {.count = 1, .reusable = false}}, SHIFT(596), + [121] = {.entry = {.count = 1, .reusable = false}}, SHIFT(803), + [123] = {.entry = {.count = 1, .reusable = false}}, SHIFT(61), [125] = {.entry = {.count = 1, .reusable = false}}, SHIFT(4), [127] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_switch_cases, 2), - [129] = {.entry = {.count = 1, .reusable = true}}, SHIFT(124), + [129] = {.entry = {.count = 1, .reusable = true}}, SHIFT(125), [131] = {.entry = {.count = 1, .reusable = false}}, SHIFT(514), - [133] = {.entry = {.count = 1, .reusable = true}}, SHIFT(130), - [135] = {.entry = {.count = 1, .reusable = false}}, SHIFT(515), - [137] = {.entry = {.count = 1, .reusable = false}}, SHIFT(628), - [139] = {.entry = {.count = 1, .reusable = false}}, SHIFT(689), - [141] = {.entry = {.count = 1, .reusable = false}}, SHIFT(50), + [133] = {.entry = {.count = 1, .reusable = true}}, SHIFT(128), + [135] = {.entry = {.count = 1, .reusable = false}}, SHIFT(522), + [137] = {.entry = {.count = 1, .reusable = false}}, SHIFT(601), + [139] = {.entry = {.count = 1, .reusable = false}}, SHIFT(712), + [141] = {.entry = {.count = 1, .reusable = false}}, SHIFT(92), [143] = {.entry = {.count = 1, .reusable = false}}, SHIFT(6), [145] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_append_values, 2), - [147] = {.entry = {.count = 1, .reusable = true}}, SHIFT(101), - [149] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tuple_items, 4), - [151] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_case_options, 2), - [153] = {.entry = {.count = 1, .reusable = true}}, SHIFT(284), - [155] = {.entry = {.count = 1, .reusable = true}}, SHIFT(296), - [157] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_argument_list, 2), - [159] = {.entry = {.count = 1, .reusable = true}}, SHIFT(244), - [161] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array_members, 2), - [163] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression_list, 2), - [165] = {.entry = {.count = 1, .reusable = true}}, SHIFT(224), - [167] = {.entry = {.count = 1, .reusable = true}}, SHIFT(37), - [169] = {.entry = {.count = 1, .reusable = true}}, SHIFT(281), - [171] = {.entry = {.count = 1, .reusable = true}}, SHIFT(23), - [173] = {.entry = {.count = 1, .reusable = true}}, SHIFT(223), - [175] = {.entry = {.count = 1, .reusable = true}}, SHIFT(280), - [177] = {.entry = {.count = 1, .reusable = true}}, SHIFT(237), - [179] = {.entry = {.count = 1, .reusable = true}}, SHIFT(127), - [181] = {.entry = {.count = 1, .reusable = true}}, SHIFT(212), - [183] = {.entry = {.count = 1, .reusable = false}}, SHIFT(650), - [185] = {.entry = {.count = 1, .reusable = false}}, SHIFT(678), - [187] = {.entry = {.count = 1, .reusable = false}}, SHIFT(273), - [189] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_hex_digits_repeat1, 2), - [191] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_hex_digits_repeat1, 2), - [193] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_hex_digits_repeat1, 2), SHIFT_REPEAT(107), - [196] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_hex_digits_repeat1, 2), SHIFT_REPEAT(107), - [199] = {.entry = {.count = 1, .reusable = true}}, SHIFT(122), - [201] = {.entry = {.count = 1, .reusable = true}}, SHIFT(211), - [203] = {.entry = {.count = 1, .reusable = false}}, SHIFT(638), - [205] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_hex_digits, 1), - [207] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_hex_digits, 1), - [209] = {.entry = {.count = 1, .reusable = true}}, SHIFT(107), - [211] = {.entry = {.count = 1, .reusable = false}}, SHIFT(107), + [147] = {.entry = {.count = 1, .reusable = true}}, SHIFT(76), + [149] = {.entry = {.count = 1, .reusable = true}}, SHIFT(299), + [151] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tuple_items, 4), + [153] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_case_options, 2), + [155] = {.entry = {.count = 1, .reusable = true}}, SHIFT(292), + [157] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array_members, 2), + [159] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression_list, 2), + [161] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_argument_list, 2), + [163] = {.entry = {.count = 1, .reusable = true}}, SHIFT(263), + [165] = {.entry = {.count = 1, .reusable = true}}, SHIFT(222), + [167] = {.entry = {.count = 1, .reusable = true}}, SHIFT(33), + [169] = {.entry = {.count = 1, .reusable = true}}, SHIFT(32), + [171] = {.entry = {.count = 1, .reusable = true}}, SHIFT(282), + [173] = {.entry = {.count = 1, .reusable = true}}, SHIFT(283), + [175] = {.entry = {.count = 1, .reusable = true}}, SHIFT(223), + [177] = {.entry = {.count = 1, .reusable = true}}, SHIFT(246), + [179] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_hex_digits, 1), + [181] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_hex_digits, 1), + [183] = {.entry = {.count = 1, .reusable = true}}, SHIFT(107), + [185] = {.entry = {.count = 1, .reusable = false}}, SHIFT(107), + [187] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_hex_digits_repeat1, 2), + [189] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_hex_digits_repeat1, 2), + [191] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_hex_digits_repeat1, 2), SHIFT_REPEAT(107), + [194] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_hex_digits_repeat1, 2), SHIFT_REPEAT(107), + [197] = {.entry = {.count = 1, .reusable = true}}, SHIFT(124), + [199] = {.entry = {.count = 1, .reusable = true}}, SHIFT(199), + [201] = {.entry = {.count = 1, .reusable = false}}, SHIFT(640), + [203] = {.entry = {.count = 1, .reusable = false}}, SHIFT(680), + [205] = {.entry = {.count = 1, .reusable = false}}, SHIFT(275), + [207] = {.entry = {.count = 1, .reusable = true}}, SHIFT(123), + [209] = {.entry = {.count = 1, .reusable = true}}, SHIFT(202), + [211] = {.entry = {.count = 1, .reusable = false}}, SHIFT(653), [213] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_hex_digit, 1), [215] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_hex_digit, 1), - [217] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_decimal_digits, 1), - [219] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_decimal_digits, 1), - [221] = {.entry = {.count = 1, .reusable = true}}, SHIFT(120), - [223] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_decimal_digits_repeat1, 2), - [225] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_decimal_digits_repeat1, 2), - [227] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_decimal_digits_repeat1, 2), SHIFT_REPEAT(120), - [230] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_hex_digits_repeat1, 2), SHIFT_REPEAT(123), - [233] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_hex_digits_repeat1, 2), SHIFT_REPEAT(123), - [236] = {.entry = {.count = 1, .reusable = true}}, SHIFT(123), - [238] = {.entry = {.count = 1, .reusable = false}}, SHIFT(123), - [240] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_decimal_digit, 1), - [242] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_decimal_digit, 1), - [244] = {.entry = {.count = 1, .reusable = true}}, SHIFT(216), - [246] = {.entry = {.count = 1, .reusable = true}}, SHIFT(31), - [248] = {.entry = {.count = 1, .reusable = true}}, SHIFT(134), - [250] = {.entry = {.count = 1, .reusable = false}}, SHIFT(260), - [252] = {.entry = {.count = 1, .reusable = false}}, SHIFT(791), - [254] = {.entry = {.count = 1, .reusable = false}}, SHIFT(792), - [256] = {.entry = {.count = 1, .reusable = true}}, SHIFT(21), - [258] = {.entry = {.count = 1, .reusable = true}}, SHIFT(359), - [260] = {.entry = {.count = 1, .reusable = true}}, SHIFT(405), - [262] = {.entry = {.count = 1, .reusable = true}}, SHIFT(486), - [264] = {.entry = {.count = 1, .reusable = false}}, SHIFT(120), - [266] = {.entry = {.count = 1, .reusable = true}}, SHIFT(485), - [268] = {.entry = {.count = 1, .reusable = true}}, SHIFT(463), - [270] = {.entry = {.count = 1, .reusable = false}}, SHIFT(793), - [272] = {.entry = {.count = 1, .reusable = false}}, SHIFT(818), - [274] = {.entry = {.count = 1, .reusable = false}}, SHIFT(794), - [276] = {.entry = {.count = 1, .reusable = false}}, SHIFT(795), - [278] = {.entry = {.count = 1, .reusable = false}}, SHIFT(796), - [280] = {.entry = {.count = 1, .reusable = false}}, SHIFT(811), - [282] = {.entry = {.count = 1, .reusable = false}}, SHIFT(744), - [284] = {.entry = {.count = 1, .reusable = false}}, SHIFT(797), - [286] = {.entry = {.count = 1, .reusable = false}}, SHIFT(798), - [288] = {.entry = {.count = 1, .reusable = true}}, SHIFT(150), - [290] = {.entry = {.count = 1, .reusable = true}}, SHIFT(54), - [292] = {.entry = {.count = 1, .reusable = true}}, SHIFT(210), + [217] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_decimal_digits_repeat1, 2), + [219] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_decimal_digits_repeat1, 2), + [221] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_decimal_digits_repeat1, 2), SHIFT_REPEAT(118), + [224] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_decimal_digits, 1), + [226] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_decimal_digits, 1), + [228] = {.entry = {.count = 1, .reusable = true}}, SHIFT(118), + [230] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_decimal_digit, 1), + [232] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_decimal_digit, 1), + [234] = {.entry = {.count = 1, .reusable = true}}, SHIFT(126), + [236] = {.entry = {.count = 1, .reusable = false}}, SHIFT(126), + [238] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_hex_digits_repeat1, 2), SHIFT_REPEAT(126), + [241] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_hex_digits_repeat1, 2), SHIFT_REPEAT(126), + [244] = {.entry = {.count = 1, .reusable = true}}, SHIFT(200), + [246] = {.entry = {.count = 1, .reusable = true}}, SHIFT(215), + [248] = {.entry = {.count = 1, .reusable = true}}, SHIFT(31), + [250] = {.entry = {.count = 1, .reusable = true}}, SHIFT(138), + [252] = {.entry = {.count = 1, .reusable = false}}, SHIFT(249), + [254] = {.entry = {.count = 1, .reusable = false}}, SHIFT(793), + [256] = {.entry = {.count = 1, .reusable = false}}, SHIFT(794), + [258] = {.entry = {.count = 1, .reusable = true}}, SHIFT(19), + [260] = {.entry = {.count = 1, .reusable = true}}, SHIFT(361), + [262] = {.entry = {.count = 1, .reusable = true}}, SHIFT(404), + [264] = {.entry = {.count = 1, .reusable = true}}, SHIFT(483), + [266] = {.entry = {.count = 1, .reusable = false}}, SHIFT(118), + [268] = {.entry = {.count = 1, .reusable = true}}, SHIFT(481), + [270] = {.entry = {.count = 1, .reusable = true}}, SHIFT(464), + [272] = {.entry = {.count = 1, .reusable = false}}, SHIFT(795), + [274] = {.entry = {.count = 1, .reusable = false}}, SHIFT(820), + [276] = {.entry = {.count = 1, .reusable = false}}, SHIFT(796), + [278] = {.entry = {.count = 1, .reusable = false}}, SHIFT(797), + [280] = {.entry = {.count = 1, .reusable = false}}, SHIFT(798), + [282] = {.entry = {.count = 1, .reusable = false}}, SHIFT(813), + [284] = {.entry = {.count = 1, .reusable = false}}, SHIFT(746), + [286] = {.entry = {.count = 1, .reusable = false}}, SHIFT(799), + [288] = {.entry = {.count = 1, .reusable = false}}, SHIFT(800), + [290] = {.entry = {.count = 1, .reusable = true}}, SHIFT(146), + [292] = {.entry = {.count = 1, .reusable = true}}, SHIFT(88), [294] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_octal_digits_repeat1, 2), [296] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_octal_digits_repeat1, 2), [298] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_octal_digits_repeat1, 2), SHIFT_REPEAT(139), - [301] = {.entry = {.count = 1, .reusable = true}}, SHIFT(131), - [303] = {.entry = {.count = 1, .reusable = true}}, SHIFT(145), - [305] = {.entry = {.count = 1, .reusable = false}}, SHIFT(457), + [301] = {.entry = {.count = 1, .reusable = true}}, SHIFT(133), + [303] = {.entry = {.count = 1, .reusable = true}}, SHIFT(148), + [305] = {.entry = {.count = 1, .reusable = false}}, SHIFT(461), [307] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_octal_digits, 1), [309] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_octal_digits, 1), [311] = {.entry = {.count = 1, .reusable = true}}, SHIFT(139), @@ -37232,22 +37333,22 @@ static TSParseActionEntry ts_parse_actions[] = { [315] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_octal_digit, 1), [317] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_integer_constant, 1), [319] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_integer_constant, 1), - [321] = {.entry = {.count = 1, .reusable = true}}, SHIFT(262), - [323] = {.entry = {.count = 1, .reusable = true}}, SHIFT(251), - [325] = {.entry = {.count = 1, .reusable = false}}, SHIFT(385), - [327] = {.entry = {.count = 1, .reusable = false}}, SHIFT(262), - [329] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_integer_constant, 1), SHIFT(387), - [332] = {.entry = {.count = 1, .reusable = true}}, SHIFT(135), - [334] = {.entry = {.count = 1, .reusable = true}}, SHIFT(136), - [336] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_binary_digits_repeat1, 2), - [338] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_binary_digits_repeat1, 2), - [340] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_binary_digits_repeat1, 2), SHIFT_REPEAT(157), - [343] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_binary_digits, 1), - [345] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_binary_digits, 1), - [347] = {.entry = {.count = 1, .reusable = true}}, SHIFT(157), - [349] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_decimal_digits_repeat1, 2), SHIFT_REPEAT(158), - [352] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_integer_constant, 2), - [354] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_integer_constant, 2), + [321] = {.entry = {.count = 1, .reusable = true}}, SHIFT(259), + [323] = {.entry = {.count = 1, .reusable = true}}, SHIFT(253), + [325] = {.entry = {.count = 1, .reusable = false}}, SHIFT(394), + [327] = {.entry = {.count = 1, .reusable = false}}, SHIFT(259), + [329] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_integer_constant, 1), SHIFT(393), + [332] = {.entry = {.count = 1, .reusable = true}}, SHIFT(134), + [334] = {.entry = {.count = 1, .reusable = true}}, SHIFT(131), + [336] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_integer_constant, 2), + [338] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_integer_constant, 2), + [340] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_binary_digits_repeat1, 2), + [342] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_binary_digits_repeat1, 2), + [344] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_binary_digits_repeat1, 2), SHIFT_REPEAT(158), + [347] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_decimal_digits_repeat1, 2), SHIFT_REPEAT(157), + [350] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_binary_digits, 1), + [352] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_binary_digits, 1), + [354] = {.entry = {.count = 1, .reusable = true}}, SHIFT(158), [356] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_exponent, 2), [358] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_exponent, 2), [360] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_binary_digit, 1), @@ -37255,232 +37356,232 @@ static TSParseActionEntry ts_parse_actions[] = { [364] = {.entry = {.count = 1, .reusable = true}}, SHIFT(162), [366] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_octal_digits_repeat1, 2), SHIFT_REPEAT(162), [369] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_cases, 2), - [371] = {.entry = {.count = 1, .reusable = false}}, SHIFT(259), - [373] = {.entry = {.count = 1, .reusable = true}}, SHIFT(170), - [375] = {.entry = {.count = 1, .reusable = false}}, SHIFT(621), - [377] = {.entry = {.count = 1, .reusable = false}}, SHIFT(424), - [379] = {.entry = {.count = 1, .reusable = false}}, SHIFT(411), - [381] = {.entry = {.count = 1, .reusable = false}}, SHIFT(420), - [383] = {.entry = {.count = 1, .reusable = false}}, SHIFT(380), - [385] = {.entry = {.count = 1, .reusable = true}}, SHIFT(187), - [387] = {.entry = {.count = 1, .reusable = false}}, SHIFT(647), - [389] = {.entry = {.count = 1, .reusable = false}}, SHIFT(641), - [391] = {.entry = {.count = 1, .reusable = false}}, SHIFT(639), + [371] = {.entry = {.count = 1, .reusable = false}}, SHIFT(224), + [373] = {.entry = {.count = 1, .reusable = true}}, SHIFT(169), + [375] = {.entry = {.count = 1, .reusable = false}}, SHIFT(620), + [377] = {.entry = {.count = 1, .reusable = false}}, SHIFT(430), + [379] = {.entry = {.count = 1, .reusable = false}}, SHIFT(413), + [381] = {.entry = {.count = 1, .reusable = false}}, SHIFT(421), + [383] = {.entry = {.count = 1, .reusable = false}}, SHIFT(383), + [385] = {.entry = {.count = 1, .reusable = true}}, SHIFT(189), + [387] = {.entry = {.count = 1, .reusable = false}}, SHIFT(644), + [389] = {.entry = {.count = 1, .reusable = false}}, SHIFT(642), + [391] = {.entry = {.count = 1, .reusable = false}}, SHIFT(641), [393] = {.entry = {.count = 1, .reusable = true}}, SHIFT(105), - [395] = {.entry = {.count = 1, .reusable = true}}, SHIFT(630), - [397] = {.entry = {.count = 1, .reusable = false}}, SHIFT(503), - [399] = {.entry = {.count = 1, .reusable = true}}, SHIFT(285), - [401] = {.entry = {.count = 1, .reusable = true}}, SHIFT(288), - [403] = {.entry = {.count = 1, .reusable = false}}, SHIFT(388), - [405] = {.entry = {.count = 1, .reusable = false}}, SHIFT(285), - [407] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_integer_constant, 1), SHIFT(389), + [395] = {.entry = {.count = 1, .reusable = true}}, SHIFT(632), + [397] = {.entry = {.count = 1, .reusable = false}}, SHIFT(505), + [399] = {.entry = {.count = 1, .reusable = true}}, SHIFT(286), + [401] = {.entry = {.count = 1, .reusable = true}}, SHIFT(289), + [403] = {.entry = {.count = 1, .reusable = false}}, SHIFT(391), + [405] = {.entry = {.count = 1, .reusable = false}}, SHIFT(286), + [407] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym_integer_constant, 1), SHIFT(387), [410] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tuple_types, 4), - [412] = {.entry = {.count = 1, .reusable = true}}, SHIFT(213), - [414] = {.entry = {.count = 1, .reusable = false}}, SHIFT(391), - [416] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assignment_op, 1), - [418] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assignment_op, 1), - [420] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_floating_constant, 3), - [422] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_floating_constant, 3), - [424] = {.entry = {.count = 1, .reusable = true}}, SHIFT(208), - [426] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_binary_digits_repeat1, 2), SHIFT_REPEAT(208), - [429] = {.entry = {.count = 1, .reusable = false}}, SHIFT(261), - [431] = {.entry = {.count = 1, .reusable = true}}, SHIFT(169), - [433] = {.entry = {.count = 1, .reusable = false}}, SHIFT(635), - [435] = {.entry = {.count = 1, .reusable = false}}, SHIFT(327), - [437] = {.entry = {.count = 1, .reusable = false}}, SHIFT(325), - [439] = {.entry = {.count = 1, .reusable = false}}, SHIFT(344), - [441] = {.entry = {.count = 1, .reusable = false}}, SHIFT(381), - [443] = {.entry = {.count = 1, .reusable = true}}, SHIFT(202), - [445] = {.entry = {.count = 1, .reusable = false}}, SHIFT(640), - [447] = {.entry = {.count = 1, .reusable = false}}, SHIFT(788), - [449] = {.entry = {.count = 1, .reusable = false}}, SHIFT(789), - [451] = {.entry = {.count = 1, .reusable = true}}, SHIFT(103), - [453] = {.entry = {.count = 1, .reusable = true}}, SHIFT(612), - [455] = {.entry = {.count = 1, .reusable = false}}, SHIFT(322), + [412] = {.entry = {.count = 1, .reusable = true}}, SHIFT(211), + [414] = {.entry = {.count = 1, .reusable = false}}, SHIFT(388), + [416] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_floating_constant, 3), + [418] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_floating_constant, 3), + [420] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assignment_op, 1), + [422] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assignment_op, 1), + [424] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_binary_digits_repeat1, 2), SHIFT_REPEAT(210), + [427] = {.entry = {.count = 1, .reusable = true}}, SHIFT(210), + [429] = {.entry = {.count = 1, .reusable = false}}, SHIFT(234), + [431] = {.entry = {.count = 1, .reusable = true}}, SHIFT(167), + [433] = {.entry = {.count = 1, .reusable = false}}, SHIFT(638), + [435] = {.entry = {.count = 1, .reusable = false}}, SHIFT(329), + [437] = {.entry = {.count = 1, .reusable = false}}, SHIFT(328), + [439] = {.entry = {.count = 1, .reusable = false}}, SHIFT(346), + [441] = {.entry = {.count = 1, .reusable = false}}, SHIFT(382), + [443] = {.entry = {.count = 1, .reusable = true}}, SHIFT(207), + [445] = {.entry = {.count = 1, .reusable = false}}, SHIFT(643), + [447] = {.entry = {.count = 1, .reusable = false}}, SHIFT(790), + [449] = {.entry = {.count = 1, .reusable = false}}, SHIFT(791), + [451] = {.entry = {.count = 1, .reusable = true}}, SHIFT(106), + [453] = {.entry = {.count = 1, .reusable = true}}, SHIFT(590), + [455] = {.entry = {.count = 1, .reusable = false}}, SHIFT(324), [457] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_floating_constant, 4), [459] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_floating_constant, 4), - [461] = {.entry = {.count = 1, .reusable = true}}, SHIFT(57), - [463] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_identifier, 3), - [465] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_identifier, 3), - [467] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_string_constant, 1), - [469] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_string_constant, 1), + [461] = {.entry = {.count = 1, .reusable = true}}, SHIFT(93), + [463] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_plain_expression, 1), + [465] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_plain_expression, 1), + [467] = {.entry = {.count = 1, .reusable = true}}, SHIFT(677), + [469] = {.entry = {.count = 1, .reusable = true}}, SHIFT(462), [471] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_string_constant_repeat1, 2), [473] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_string_constant_repeat1, 2), - [475] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_string_constant_repeat1, 2), SHIFT_REPEAT(463), - [478] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_plain_expression, 1), - [480] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_object_selector, 1), - [482] = {.entry = {.count = 1, .reusable = true}}, SHIFT(686), - [484] = {.entry = {.count = 1, .reusable = true}}, SHIFT(458), - [486] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_plain_expression, 1), - [488] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_object_selector, 1), - [490] = {.entry = {.count = 1, .reusable = true}}, SHIFT(674), + [475] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_string_constant_repeat1, 2), SHIFT_REPEAT(464), + [478] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_string_constant, 1), + [480] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_string_constant, 1), + [482] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_identifier, 3), + [484] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_identifier, 3), + [486] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_object_selector, 1), + [488] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_object_selector, 1), + [490] = {.entry = {.count = 1, .reusable = true}}, SHIFT(688), [492] = {.entry = {.count = 1, .reusable = true}}, SHIFT(460), [494] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_identifier, 1), [496] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_identifier, 1), - [498] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_identifier, 1), SHIFT(561), + [498] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_identifier, 1), SHIFT(615), [501] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_string_constant_repeat1, 3), [503] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_string_constant_repeat1, 3), - [505] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_length_expression, 4), - [507] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_length_expression, 4), + [505] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_allocation_expression, 6), + [507] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_allocation_expression, 6), [509] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_postfix_expression, 1), [511] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_postfix_expression, 1), - [513] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_unary_expression, 1), - [515] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_unary_expression, 1), - [517] = {.entry = {.count = 1, .reusable = true}}, SHIFT(17), - [519] = {.entry = {.count = 1, .reusable = true}}, SHIFT(22), - [521] = {.entry = {.count = 1, .reusable = false}}, SHIFT(374), - [523] = {.entry = {.count = 1, .reusable = true}}, SHIFT(256), - [525] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_slicing_expression, 4), - [527] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_slicing_expression, 4), - [529] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array_literal, 2), - [531] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array_literal, 2), - [533] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_measurement_expression, 1), - [535] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_measurement_expression, 1), - [537] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_offset_expression, 4), - [539] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_offset_expression, 4), + [513] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 3), + [515] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 3), + [517] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_slicing_expression, 4), + [519] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_slicing_expression, 4), + [521] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 4), + [523] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 4), + [525] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_offset_expression, 4), + [527] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_offset_expression, 4), + [529] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_length_expression, 4), + [531] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_length_expression, 4), + [533] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assertion_expression, 7), + [535] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assertion_expression, 7), + [537] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_access_expression, 3, .production_id = 7), + [539] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_field_access_expression, 3, .production_id = 7), [541] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assertion_expression, 4), [543] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assertion_expression, 4), - [545] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_allocation_expression, 4), - [547] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_allocation_expression, 4), - [549] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_literal, 4), - [551] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_struct_literal, 4), - [553] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_indexing_expression, 4), - [555] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_indexing_expression, 4), - [557] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_literal, 5), - [559] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_struct_literal, 5), - [561] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_size_expression, 4), - [563] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_size_expression, 4), - [565] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assertion_expression, 5), - [567] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assertion_expression, 5), - [569] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_literal, 3), - [571] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_enum_literal, 3), - [573] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_floating_constant, 5), - [575] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_floating_constant, 5), - [577] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_slicing_expression, 5), - [579] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_slicing_expression, 5), - [581] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_allocation_expression, 6), - [583] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_allocation_expression, 6), - [585] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assertion_expression, 6), - [587] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assertion_expression, 6), - [589] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_access_expression, 3, .production_id = 7), - [591] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_field_access_expression, 3, .production_id = 7), - [593] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_nested_expression, 1), - [595] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_nested_expression, 1), - [597] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_slicing_expression, 6), - [599] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_slicing_expression, 6), - [601] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_allocation_expression, 7), - [603] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_allocation_expression, 7), - [605] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 3), - [607] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 3), - [609] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assertion_expression, 7), - [611] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assertion_expression, 7), - [613] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assertion_expression, 3), - [615] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assertion_expression, 3), - [617] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_rune_constant, 3), - [619] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_rune_constant, 3), - [621] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_call_expression, 4), - [623] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_call_expression, 4), - [625] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_floating_suffix, 1), - [627] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_floating_suffix, 1), - [629] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_integer_constant, 3), - [631] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_integer_constant, 3), - [633] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array_literal, 3), - [635] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array_literal, 3), - [637] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_nested_expression, 3), - [639] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_nested_expression, 3), - [641] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_error_propagation, 2), - [643] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_error_propagation, 2), - [645] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_floating_constant, 2), - [647] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_floating_constant, 2), - [649] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_constant, 1), - [651] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_constant, 1), - [653] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_integer_suffix, 1), - [655] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_integer_suffix, 1), + [545] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_allocation_expression, 7), + [547] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_allocation_expression, 7), + [549] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_indexing_expression, 4), + [551] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_indexing_expression, 4), + [553] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_slicing_expression, 6), + [555] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_slicing_expression, 6), + [557] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_floating_constant, 5), + [559] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_floating_constant, 5), + [561] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_rune_constant, 3), + [563] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_rune_constant, 3), + [565] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assertion_expression, 6), + [567] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assertion_expression, 6), + [569] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_allocation_expression, 4), + [571] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_allocation_expression, 4), + [573] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assertion_expression, 5), + [575] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assertion_expression, 5), + [577] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_integer_constant, 3), + [579] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_integer_constant, 3), + [581] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array_literal, 3), + [583] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array_literal, 3), + [585] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_slicing_expression, 5), + [587] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_slicing_expression, 5), + [589] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_nested_expression, 3), + [591] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_nested_expression, 3), + [593] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_error_propagation, 2), + [595] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_error_propagation, 2), + [597] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_constant, 1), + [599] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_constant, 1), + [601] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assertion_expression, 3), + [603] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assertion_expression, 3), + [605] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_floating_constant, 2), + [607] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_floating_constant, 2), + [609] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_floating_suffix, 1), + [611] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_floating_suffix, 1), + [613] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_nested_expression, 1), + [615] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_nested_expression, 1), + [617] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_measurement_expression, 1), + [619] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_measurement_expression, 1), + [621] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_unary_expression, 1), + [623] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_unary_expression, 1), + [625] = {.entry = {.count = 1, .reusable = true}}, SHIFT(20), + [627] = {.entry = {.count = 1, .reusable = true}}, SHIFT(22), + [629] = {.entry = {.count = 1, .reusable = false}}, SHIFT(378), + [631] = {.entry = {.count = 1, .reusable = true}}, SHIFT(248), + [633] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_literal, 3), + [635] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_enum_literal, 3), + [637] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_integer_suffix, 1), + [639] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_integer_suffix, 1), + [641] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_literal, 5), + [643] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_struct_literal, 5), + [645] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_size_expression, 4), + [647] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_size_expression, 4), + [649] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_literal, 4), + [651] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_struct_literal, 4), + [653] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array_literal, 2), + [655] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_array_literal, 2), [657] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_unary_expression, 2, .production_id = 4), - [659] = {.entry = {.count = 1, .reusable = false}}, SHIFT(166), + [659] = {.entry = {.count = 1, .reusable = false}}, SHIFT(170), [661] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_unary_expression, 2, .production_id = 4), - [663] = {.entry = {.count = 1, .reusable = true}}, SHIFT(166), + [663] = {.entry = {.count = 1, .reusable = true}}, SHIFT(170), [665] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_unary_expression, 2, .production_id = 5), [667] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_unary_expression, 2, .production_id = 5), - [669] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_identifier, 1), SHIFT(633), - [672] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_string_constant_repeat1, 2), SHIFT_REPEAT(462), + [669] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_identifier, 1), SHIFT(635), + [672] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_string_constant_repeat1, 2), SHIFT_REPEAT(463), [675] = {.entry = {.count = 1, .reusable = false}}, SHIFT(45), [677] = {.entry = {.count = 1, .reusable = false}}, SHIFT(55), - [679] = {.entry = {.count = 1, .reusable = true}}, SHIFT(12), - [681] = {.entry = {.count = 1, .reusable = true}}, SHIFT(30), - [683] = {.entry = {.count = 1, .reusable = true}}, SHIFT(312), - [685] = {.entry = {.count = 1, .reusable = true}}, SHIFT(24), - [687] = {.entry = {.count = 1, .reusable = false}}, SHIFT(375), - [689] = {.entry = {.count = 1, .reusable = true}}, SHIFT(585), - [691] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_slice_array_type, 3), - [693] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_slice_array_type, 3), + [679] = {.entry = {.count = 1, .reusable = true}}, SHIFT(9), + [681] = {.entry = {.count = 1, .reusable = true}}, SHIFT(23), + [683] = {.entry = {.count = 1, .reusable = true}}, SHIFT(311), + [685] = {.entry = {.count = 1, .reusable = true}}, SHIFT(29), + [687] = {.entry = {.count = 1, .reusable = false}}, SHIFT(377), + [689] = {.entry = {.count = 1, .reusable = true}}, SHIFT(637), + [691] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type, 2), + [693] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type, 2), [695] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_unwrapped_alias, 2), [697] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_unwrapped_alias, 2), - [699] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_integer_type, 1), - [701] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_integer_type, 1), - [703] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_alias_type, 1), - [705] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_alias_type, 1), + [699] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_alias_type, 1), + [701] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_alias_type, 1), + [703] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_integer_type, 1), + [705] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_integer_type, 1), [707] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_scalar_type, 1), [709] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_scalar_type, 1), - [711] = {.entry = {.count = 1, .reusable = false}}, SHIFT(46), - [713] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_prototype, 4), - [715] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_prototype, 4), - [717] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type, 1), - [719] = {.entry = {.count = 1, .reusable = false}}, SHIFT(332), - [721] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type, 1), + [711] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__inner_type, 2), + [713] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__inner_type, 2), + [715] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_prototype, 4), + [717] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_prototype, 4), + [719] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_type, 3), + [721] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_type, 3), [723] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pointer_type, 2), [725] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_pointer_type, 2), - [727] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type, 2), - [729] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type, 2), - [731] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_type, 3), - [733] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_type, 3), - [735] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_prototype, 3), - [737] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_prototype, 3), - [739] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tuple_type, 3), - [741] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_tuple_type, 3), - [743] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tagged_union_type, 3), - [745] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_tagged_union_type, 3), - [747] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pointer_type, 3), - [749] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_pointer_type, 3), - [751] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_type, 5), - [753] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_enum_type, 5), - [755] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_slice_array_type, 4), - [757] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_slice_array_type, 4), - [759] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_union_type, 4), - [761] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_union_type, 4), - [763] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_type, 4), - [765] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_struct_type, 4), - [767] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_storage_class, 1), - [769] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_storage_class, 1), + [727] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_storage_class, 1), + [729] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_storage_class, 1), + [731] = {.entry = {.count = 1, .reusable = false}}, SHIFT(73), + [733] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_prototype, 3), + [735] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_prototype, 3), + [737] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tuple_type, 3), + [739] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_tuple_type, 3), + [741] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tagged_union_type, 3), + [743] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_tagged_union_type, 3), + [745] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pointer_type, 3), + [747] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_pointer_type, 3), + [749] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type, 1), + [751] = {.entry = {.count = 1, .reusable = false}}, SHIFT(325), + [753] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_type, 1), + [755] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_type, 5), + [757] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_enum_type, 5), + [759] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_slice_array_type, 4), + [761] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_slice_array_type, 4), + [763] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_union_type, 4), + [765] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_union_type, 4), + [767] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_slice_array_type, 3), + [769] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_slice_array_type, 3), [771] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_type, 2), [773] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_function_type, 2), [775] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_floating_type, 1), [777] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_floating_type, 1), - [779] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__inner_type, 2), - [781] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__inner_type, 2), + [779] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_type, 4), + [781] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_struct_type, 4), [783] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_type, 4), [785] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_enum_type, 4), - [787] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_multiplicative_expression, 1), - [789] = {.entry = {.count = 1, .reusable = true}}, SHIFT(184), - [791] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_multiplicative_expression, 1), - [793] = {.entry = {.count = 1, .reusable = true}}, SHIFT(182), - [795] = {.entry = {.count = 1, .reusable = true}}, SHIFT(181), - [797] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_cast_expression, 1), - [799] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_cast_expression, 1), - [801] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_cast_expression, 3, .production_id = 8), - [803] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_cast_expression, 3, .production_id = 8), - [805] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_cast_expression, 3, .production_id = 9), - [807] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_cast_expression, 3, .production_id = 9), - [809] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_cast_expression, 3, .production_id = 10), - [811] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_cast_expression, 3, .production_id = 10), - [813] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_multiplicative_expression, 3), - [815] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_multiplicative_expression, 3), - [817] = {.entry = {.count = 1, .reusable = false}}, SHIFT(52), + [787] = {.entry = {.count = 1, .reusable = false}}, SHIFT(67), + [789] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_multiplicative_expression, 1), + [791] = {.entry = {.count = 1, .reusable = true}}, SHIFT(184), + [793] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_multiplicative_expression, 1), + [795] = {.entry = {.count = 1, .reusable = true}}, SHIFT(179), + [797] = {.entry = {.count = 1, .reusable = true}}, SHIFT(182), + [799] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_cast_expression, 1), + [801] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_cast_expression, 1), + [803] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_cast_expression, 3, .production_id = 8), + [805] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_cast_expression, 3, .production_id = 8), + [807] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_cast_expression, 3, .production_id = 9), + [809] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_cast_expression, 3, .production_id = 9), + [811] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_cast_expression, 3, .production_id = 10), + [813] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_cast_expression, 3, .production_id = 10), + [815] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_multiplicative_expression, 3), + [817] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_multiplicative_expression, 3), [819] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_additive_expression, 1), - [821] = {.entry = {.count = 1, .reusable = true}}, SHIFT(126), + [821] = {.entry = {.count = 1, .reusable = true}}, SHIFT(127), [823] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_additive_expression, 1), - [825] = {.entry = {.count = 1, .reusable = false}}, SHIFT(126), - [827] = {.entry = {.count = 1, .reusable = true}}, SHIFT(125), + [825] = {.entry = {.count = 1, .reusable = false}}, SHIFT(127), + [827] = {.entry = {.count = 1, .reusable = true}}, SHIFT(122), [829] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_additive_expression, 3), [831] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_additive_expression, 3), [833] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_shift_expression, 3), @@ -37490,14 +37591,14 @@ static TSParseActionEntry ts_parse_actions[] = { [841] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_shift_expression, 1), [843] = {.entry = {.count = 1, .reusable = true}}, SHIFT(121), [845] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_declarations_repeat1, 2), - [847] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_declarations_repeat1, 2), SHIFT_REPEAT(370), - [850] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_declarations_repeat1, 2), SHIFT_REPEAT(468), - [853] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_declarations_repeat1, 2), SHIFT_REPEAT(807), - [856] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_declarations_repeat1, 2), SHIFT_REPEAT(512), - [859] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_declarations_repeat1, 2), SHIFT_REPEAT(540), - [862] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_declarations_repeat1, 2), SHIFT_REPEAT(573), - [865] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_declarations_repeat1, 2), SHIFT_REPEAT(469), - [868] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_declarations_repeat1, 2), SHIFT_REPEAT(474), + [847] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_declarations_repeat1, 2), SHIFT_REPEAT(372), + [850] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_declarations_repeat1, 2), SHIFT_REPEAT(472), + [853] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_declarations_repeat1, 2), SHIFT_REPEAT(809), + [856] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_declarations_repeat1, 2), SHIFT_REPEAT(501), + [859] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_declarations_repeat1, 2), SHIFT_REPEAT(521), + [862] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_declarations_repeat1, 2), SHIFT_REPEAT(583), + [865] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_declarations_repeat1, 2), SHIFT_REPEAT(479), + [868] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_declarations_repeat1, 2), SHIFT_REPEAT(469), [871] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_declarations, 1), [873] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_exclusive_or_expression, 1), [875] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_exclusive_or_expression, 1), @@ -37513,446 +37614,448 @@ static TSParseActionEntry ts_parse_actions[] = { [895] = {.entry = {.count = 1, .reusable = false}}, SHIFT(116), [897] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_inclusive_or_expression, 1), [899] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_inclusive_or_expression, 1), - [901] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_comparison_expression, 3), + [901] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_comparison_expression, 1), [903] = {.entry = {.count = 1, .reusable = false}}, SHIFT(113), - [905] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_comparison_expression, 3), - [907] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_comparison_expression, 1), - [909] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_comparison_expression, 1), - [911] = {.entry = {.count = 1, .reusable = true}}, SHIFT(240), - [913] = {.entry = {.count = 1, .reusable = true}}, SHIFT(291), - [915] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_equality_expression, 3), - [917] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_equality_expression, 3), - [919] = {.entry = {.count = 1, .reusable = false}}, SHIFT(112), - [921] = {.entry = {.count = 1, .reusable = true}}, SHIFT(112), + [905] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_comparison_expression, 1), + [907] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_comparison_expression, 3), + [909] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_comparison_expression, 3), + [911] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_equality_expression, 3), + [913] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_equality_expression, 3), + [915] = {.entry = {.count = 1, .reusable = false}}, SHIFT(112), + [917] = {.entry = {.count = 1, .reusable = true}}, SHIFT(112), + [919] = {.entry = {.count = 1, .reusable = true}}, SHIFT(293), + [921] = {.entry = {.count = 1, .reusable = true}}, SHIFT(233), [923] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_equality_expression, 1), [925] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_equality_expression, 1), [927] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_imports, 1), - [929] = {.entry = {.count = 1, .reusable = true}}, SHIFT(532), - [931] = {.entry = {.count = 1, .reusable = true}}, SHIFT(411), - [933] = {.entry = {.count = 1, .reusable = true}}, SHIFT(526), + [929] = {.entry = {.count = 1, .reusable = true}}, SHIFT(547), + [931] = {.entry = {.count = 1, .reusable = true}}, SHIFT(413), + [933] = {.entry = {.count = 1, .reusable = true}}, SHIFT(520), [935] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_imports_repeat1, 2), - [937] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_imports_repeat1, 2), SHIFT_REPEAT(560), + [937] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_imports_repeat1, 2), SHIFT_REPEAT(558), [940] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_logical_and_expression, 3), [942] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_logical_and_expression, 3), [944] = {.entry = {.count = 1, .reusable = true}}, SHIFT(111), [946] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_logical_and_expression, 1), [948] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_logical_and_expression, 1), - [950] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_use_statement, 7), + [950] = {.entry = {.count = 1, .reusable = true}}, SHIFT(602), [952] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_use_statement, 5), - [954] = {.entry = {.count = 1, .reusable = true}}, SHIFT(623), + [954] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_use_statement, 7), [956] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_use_statement, 3), - [958] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_logical_xor_expression, 3), - [960] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_logical_xor_expression, 3), - [962] = {.entry = {.count = 1, .reusable = true}}, SHIFT(110), - [964] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_logical_xor_expression, 1), - [966] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_logical_xor_expression, 1), - [968] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_declarations_repeat1, 3), - [970] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_logical_or_expression, 3), - [972] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_logical_or_expression, 3), + [958] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_declarations_repeat1, 3), + [960] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_logical_xor_expression, 3), + [962] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_logical_xor_expression, 3), + [964] = {.entry = {.count = 1, .reusable = true}}, SHIFT(110), + [966] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_logical_xor_expression, 1), + [968] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_logical_xor_expression, 1), + [970] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_logical_or_expression, 1), + [972] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_logical_or_expression, 1), [974] = {.entry = {.count = 1, .reusable = true}}, SHIFT(109), - [976] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_logical_or_expression, 1), - [978] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_logical_or_expression, 1), - [980] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_union_fields, 2), - [982] = {.entry = {.count = 1, .reusable = true}}, SHIFT(752), - [984] = {.entry = {.count = 1, .reusable = false}}, SHIFT(492), - [986] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_fndec_attrs, 1), - [988] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression, 1), - [990] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_expression, 1), - [992] = {.entry = {.count = 1, .reusable = true}}, SHIFT(108), - [994] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_fndec_attrs_repeat1, 2), SHIFT_REPEAT(807), - [997] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_fndec_attrs_repeat1, 2), - [999] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_fndec_attrs_repeat1, 2), SHIFT_REPEAT(469), - [1002] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_fndec_attrs_repeat1, 2), SHIFT_REPEAT(474), - [1005] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_label, 2), - [1007] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_label, 2), - [1009] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_bindings, 3), - [1011] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_bindings, 3), + [976] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_union_fields, 2), + [978] = {.entry = {.count = 1, .reusable = true}}, SHIFT(750), + [980] = {.entry = {.count = 1, .reusable = false}}, SHIFT(511), + [982] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_logical_or_expression, 3), + [984] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_logical_or_expression, 3), + [986] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_fndec_attrs_repeat1, 2), SHIFT_REPEAT(809), + [989] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_fndec_attrs_repeat1, 2), + [991] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_fndec_attrs_repeat1, 2), SHIFT_REPEAT(479), + [994] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_fndec_attrs_repeat1, 2), SHIFT_REPEAT(469), + [997] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_fndec_attrs, 1), + [999] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_label, 2), + [1001] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_label, 2), + [1003] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression, 1), + [1005] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_expression, 1), + [1007] = {.entry = {.count = 1, .reusable = true}}, SHIFT(108), + [1009] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_expression, 7), + [1011] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_expression, 7), [1013] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_expression, 2), [1015] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_expression, 2), [1017] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_if_expression, 2), SHIFT(43), - [1020] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_bindings, 1), - [1022] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_bindings, 1), SHIFT(493), - [1025] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_bindings, 1), - [1027] = {.entry = {.count = 1, .reusable = true}}, SHIFT(332), - [1029] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_loop, 5), - [1031] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_loop, 5), - [1033] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_conditional_branch, 4), - [1035] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_conditional_branch, 4), - [1037] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_compound_expression, 3), - [1039] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_compound_expression, 3), - [1041] = {.entry = {.count = 1, .reusable = true}}, SHIFT(41), - [1043] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_binding_list, 2), - [1045] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_binding_list, 2), - [1047] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_binding, 5), - [1049] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_binding, 5), - [1051] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_loop, 6), - [1053] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_loop, 6), - [1055] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_expression, 7), - [1057] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_match_expression, 7), + [1020] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_switch_expression, 7), + [1022] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_switch_expression, 7), + [1024] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_compound_expression, 3), + [1026] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_compound_expression, 3), + [1028] = {.entry = {.count = 1, .reusable = true}}, SHIFT(325), + [1030] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_binding, 5), + [1032] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_binding, 5), + [1034] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_loop, 6), + [1036] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_loop, 6), + [1038] = {.entry = {.count = 1, .reusable = true}}, SHIFT(51), + [1040] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_bindings, 1), + [1042] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_bindings, 1), SHIFT(510), + [1045] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_bindings, 1), + [1047] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_binding, 3), + [1049] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_binding, 3), + [1051] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_bindings, 3), + [1053] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_bindings, 3), + [1055] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assignment, 4), + [1057] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assignment, 4), [1059] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_binding_list, 3), [1061] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_binding_list, 3), - [1063] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_binding, 3), - [1065] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_binding, 3), - [1067] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_deferred_expression, 2), - [1069] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_deferred_expression, 2), - [1071] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_control_statement, 2), - [1073] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_control_statement, 2), - [1075] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assignment, 4), - [1077] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assignment, 4), - [1079] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_expression, 4), - [1081] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_expression, 4), - [1083] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_switch_expression, 7), - [1085] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_switch_expression, 7), + [1063] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_if_expression, 4), + [1065] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_if_expression, 4), + [1067] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_loop, 5), + [1069] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_for_loop, 5), + [1071] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_deferred_expression, 2), + [1073] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_deferred_expression, 2), + [1075] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_control_statement, 2), + [1077] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_control_statement, 2), + [1079] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_conditional_branch, 4), + [1081] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_conditional_branch, 4), + [1083] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_binding_list, 2), + [1085] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_binding_list, 2), [1087] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_assignment, 3), [1089] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_assignment, 3), - [1091] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_identifier, 1), SHIFT(636), - [1094] = {.entry = {.count = 1, .reusable = true}}, SHIFT(718), - [1096] = {.entry = {.count = 1, .reusable = false}}, SHIFT(496), - [1098] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_bindings, 1), SHIFT(510), - [1101] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_string_chars_repeat1, 2), SHIFT_REPEAT(624), - [1104] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_string_chars_repeat1, 2), - [1106] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_string_chars_repeat1, 2), SHIFT_REPEAT(523), - [1109] = {.entry = {.count = 1, .reusable = false}}, SHIFT_EXTRA(), - [1111] = {.entry = {.count = 1, .reusable = false}}, SHIFT(624), - [1113] = {.entry = {.count = 1, .reusable = false}}, SHIFT(523), + [1091] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_bindings, 1), SHIFT(504), + [1094] = {.entry = {.count = 1, .reusable = true}}, SHIFT(720), + [1096] = {.entry = {.count = 1, .reusable = false}}, SHIFT(508), + [1098] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_identifier, 1), SHIFT(609), + [1101] = {.entry = {.count = 1, .reusable = false}}, SHIFT(626), + [1103] = {.entry = {.count = 1, .reusable = false}}, SHIFT(278), + [1105] = {.entry = {.count = 1, .reusable = false}}, SHIFT(540), + [1107] = {.entry = {.count = 1, .reusable = false}}, SHIFT_EXTRA(), + [1109] = {.entry = {.count = 1, .reusable = false}}, SHIFT(217), + [1111] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_initializer, 2), + [1113] = {.entry = {.count = 1, .reusable = true}}, SHIFT(741), [1115] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_string_chars, 1), - [1117] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_initializer, 2), - [1119] = {.entry = {.count = 1, .reusable = true}}, SHIFT(740), - [1121] = {.entry = {.count = 1, .reusable = true}}, SHIFT(232), - [1123] = {.entry = {.count = 1, .reusable = false}}, SHIFT(509), - [1125] = {.entry = {.count = 1, .reusable = true}}, SHIFT(786), - [1127] = {.entry = {.count = 1, .reusable = true}}, SHIFT(391), - [1129] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_fndec_attr, 1), - [1131] = {.entry = {.count = 1, .reusable = true}}, SHIFT(498), - [1133] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_decl_attr, 4), - [1135] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_fntype_attr, 1), - [1137] = {.entry = {.count = 1, .reusable = true}}, SHIFT(214), - [1139] = {.entry = {.count = 1, .reusable = false}}, SHIFT(655), - [1141] = {.entry = {.count = 1, .reusable = true}}, SHIFT(309), - [1143] = {.entry = {.count = 1, .reusable = true}}, SHIFT(203), - [1145] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_if_expression, 2), SHIFT(97), - [1148] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter_list, 2), - [1150] = {.entry = {.count = 1, .reusable = true}}, SHIFT(614), - [1152] = {.entry = {.count = 1, .reusable = true}}, SHIFT(505), - [1154] = {.entry = {.count = 1, .reusable = true}}, SHIFT(282), - [1156] = {.entry = {.count = 1, .reusable = true}}, SHIFT(226), - [1158] = {.entry = {.count = 1, .reusable = false}}, SHIFT(784), - [1160] = {.entry = {.count = 1, .reusable = false}}, SHIFT(637), - [1162] = {.entry = {.count = 1, .reusable = true}}, SHIFT(300), - [1164] = {.entry = {.count = 1, .reusable = true}}, SHIFT(229), - [1166] = {.entry = {.count = 1, .reusable = true}}, SHIFT(77), - [1168] = {.entry = {.count = 1, .reusable = true}}, SHIFT(307), - [1170] = {.entry = {.count = 1, .reusable = false}}, SHIFT(195), - [1172] = {.entry = {.count = 1, .reusable = true}}, SHIFT(545), - [1174] = {.entry = {.count = 1, .reusable = true}}, SHIFT(541), - [1176] = {.entry = {.count = 1, .reusable = true}}, SHIFT(85), - [1178] = {.entry = {.count = 1, .reusable = false}}, SHIFT(178), - [1180] = {.entry = {.count = 1, .reusable = true}}, SHIFT(248), - [1182] = {.entry = {.count = 1, .reusable = true}}, SHIFT(374), - [1184] = {.entry = {.count = 1, .reusable = true}}, SHIFT(375), - [1186] = {.entry = {.count = 1, .reusable = false}}, SHIFT(180), - [1188] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_values, 2), - [1190] = {.entry = {.count = 1, .reusable = true}}, SHIFT(530), - [1192] = {.entry = {.count = 1, .reusable = false}}, SHIFT(177), - [1194] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_bindings, 4), - [1196] = {.entry = {.count = 1, .reusable = true}}, SHIFT(495), - [1198] = {.entry = {.count = 1, .reusable = true}}, SHIFT(787), - [1200] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_tagged_types_repeat1, 2), - [1202] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_tagged_types_repeat1, 2), SHIFT_REPEAT(175), - [1205] = {.entry = {.count = 1, .reusable = true}}, SHIFT(19), - [1207] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array_members, 1), - [1209] = {.entry = {.count = 1, .reusable = true}}, SHIFT(620), - [1211] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_global_binding, 3), - [1213] = {.entry = {.count = 1, .reusable = true}}, SHIFT(96), - [1215] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameters, 3), - [1217] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_string_char, 1), - [1219] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_escape_sequence, 1), - [1221] = {.entry = {.count = 1, .reusable = true}}, SHIFT(13), - [1223] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_argument_list, 1), - [1225] = {.entry = {.count = 1, .reusable = true}}, SHIFT(605), - [1227] = {.entry = {.count = 1, .reusable = true}}, SHIFT(481), - [1229] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter_list, 1), - [1231] = {.entry = {.count = 1, .reusable = true}}, SHIFT(613), - [1233] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameters, 1), - [1235] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_global_binding, 4), - [1237] = {.entry = {.count = 1, .reusable = true}}, SHIFT(68), - [1239] = {.entry = {.count = 1, .reusable = true}}, SHIFT(70), - [1241] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_value, 1), - [1243] = {.entry = {.count = 1, .reusable = true}}, SHIFT(586), - [1245] = {.entry = {.count = 1, .reusable = true}}, SHIFT(504), - [1247] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_name_list, 2), - [1249] = {.entry = {.count = 1, .reusable = true}}, SHIFT(609), - [1251] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_named_escape, 2), - [1253] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_escape_sequence, 2), - [1255] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_binding_names, 3), - [1257] = {.entry = {.count = 1, .reusable = true}}, SHIFT(607), - [1259] = {.entry = {.count = 1, .reusable = true}}, SHIFT(74), - [1261] = {.entry = {.count = 1, .reusable = true}}, SHIFT(191), - [1263] = {.entry = {.count = 1, .reusable = true}}, SHIFT(494), - [1265] = {.entry = {.count = 1, .reusable = true}}, SHIFT(501), - [1267] = {.entry = {.count = 1, .reusable = true}}, SHIFT(99), - [1269] = {.entry = {.count = 1, .reusable = true}}, SHIFT(186), - [1271] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tagged_types, 4), - [1273] = {.entry = {.count = 1, .reusable = true}}, SHIFT(175), - [1275] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tagged_types, 3), - [1277] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter, 3), - [1279] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_offset_specifier, 4), - [1281] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_cases, 1), - [1283] = {.entry = {.count = 1, .reusable = true}}, SHIFT(163), - [1285] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_constant_binding, 5), - [1287] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_value, 3), - [1289] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_value, 3), - [1291] = {.entry = {.count = 1, .reusable = true}}, SHIFT(231), - [1293] = {.entry = {.count = 1, .reusable = true}}, SHIFT(38), - [1295] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_union_field, 4), - [1297] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_union_field, 2), - [1299] = {.entry = {.count = 1, .reusable = true}}, SHIFT(531), - [1301] = {.entry = {.count = 1, .reusable = true}}, SHIFT(205), - [1303] = {.entry = {.count = 1, .reusable = true}}, SHIFT(519), - [1305] = {.entry = {.count = 1, .reusable = true}}, SHIFT(228), - [1307] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_union_fields, 1), - [1309] = {.entry = {.count = 1, .reusable = true}}, SHIFT(404), - [1311] = {.entry = {.count = 1, .reusable = true}}, SHIFT(89), - [1313] = {.entry = {.count = 1, .reusable = true}}, SHIFT(165), - [1315] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tuple_types, 3), - [1317] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_global_binding, 6), - [1319] = {.entry = {.count = 1, .reusable = true}}, SHIFT(230), - [1321] = {.entry = {.count = 1, .reusable = true}}, SHIFT(466), - [1323] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 3, .production_id = 1), - [1325] = {.entry = {.count = 1, .reusable = true}}, SHIFT(93), - [1327] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_value, 5), - [1329] = {.entry = {.count = 1, .reusable = true}}, SHIFT(475), - [1331] = {.entry = {.count = 1, .reusable = true}}, SHIFT(95), - [1333] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_predicate, 1), - [1335] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_switch_case, 3), - [1337] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_expression, 1), SHIFT(94), - [1340] = {.entry = {.count = 1, .reusable = true}}, SHIFT(10), - [1342] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_case_options, 1), - [1344] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_switch_cases, 1), - [1346] = {.entry = {.count = 1, .reusable = true}}, SHIFT(5), - [1348] = {.entry = {.count = 1, .reusable = true}}, SHIFT(100), - [1350] = {.entry = {.count = 1, .reusable = true}}, SHIFT(29), - [1352] = {.entry = {.count = 1, .reusable = true}}, SHIFT(255), - [1354] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_union_field, 1), - [1356] = {.entry = {.count = 1, .reusable = true}}, SHIFT(40), - [1358] = {.entry = {.count = 1, .reusable = true}}, SHIFT(322), - [1360] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_global_bindings, 1), - [1362] = {.entry = {.count = 1, .reusable = true}}, SHIFT(472), - [1364] = {.entry = {.count = 1, .reusable = true}}, SHIFT(522), - [1366] = {.entry = {.count = 1, .reusable = true}}, SHIFT(294), - [1368] = {.entry = {.count = 1, .reusable = true}}, SHIFT(86), - [1370] = {.entry = {.count = 1, .reusable = true}}, SHIFT(308), - [1372] = {.entry = {.count = 1, .reusable = true}}, SHIFT(722), - [1374] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_values, 3), - [1376] = {.entry = {.count = 1, .reusable = true}}, SHIFT(392), - [1378] = {.entry = {.count = 1, .reusable = true}}, SHIFT(712), - [1380] = {.entry = {.count = 1, .reusable = true}}, SHIFT(67), - [1382] = {.entry = {.count = 1, .reusable = true}}, SHIFT(9), - [1384] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tuple_items, 3), - [1386] = {.entry = {.count = 1, .reusable = true}}, SHIFT(518), - [1388] = {.entry = {.count = 1, .reusable = true}}, SHIFT(234), - [1390] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_value, 1), - [1392] = {.entry = {.count = 1, .reusable = true}}, SHIFT(477), - [1394] = {.entry = {.count = 1, .reusable = true}}, SHIFT(172), - [1396] = {.entry = {.count = 1, .reusable = true}}, SHIFT(193), - [1398] = {.entry = {.count = 1, .reusable = true}}, SHIFT(745), - [1400] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_values, 1), - [1402] = {.entry = {.count = 1, .reusable = true}}, SHIFT(539), - [1404] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_name_list, 1), - [1406] = {.entry = {.count = 1, .reusable = true}}, SHIFT(536), - [1408] = {.entry = {.count = 1, .reusable = true}}, SHIFT(62), - [1410] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_predicate, 3, .production_id = 11), - [1412] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 4, .production_id = 2), - [1414] = {.entry = {.count = 1, .reusable = true}}, SHIFT(64), - [1416] = {.entry = {.count = 1, .reusable = true}}, SHIFT(766), - [1418] = {.entry = {.count = 1, .reusable = true}}, SHIFT(814), - [1420] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter_list, 3), - [1422] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_global_binding, 5), - [1424] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_bindings, 3), - [1426] = {.entry = {.count = 1, .reusable = true}}, SHIFT(513), - [1428] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_values, 1), - [1430] = {.entry = {.count = 1, .reusable = true}}, SHIFT(506), - [1432] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_constant_bindings, 1), - [1434] = {.entry = {.count = 1, .reusable = true}}, SHIFT(511), - [1436] = {.entry = {.count = 1, .reusable = true}}, SHIFT(317), - [1438] = {.entry = {.count = 1, .reusable = true}}, SHIFT(777), - [1440] = {.entry = {.count = 1, .reusable = true}}, SHIFT(8), - [1442] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_append_values, 1), - [1444] = {.entry = {.count = 1, .reusable = true}}, SHIFT(538), - [1446] = {.entry = {.count = 1, .reusable = true}}, SHIFT(537), - [1448] = {.entry = {.count = 1, .reusable = true}}, SHIFT(542), - [1450] = {.entry = {.count = 1, .reusable = true}}, SHIFT(310), - [1452] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_case, 5), - [1454] = {.entry = {.count = 1, .reusable = true}}, SHIFT(290), - [1456] = {.entry = {.count = 1, .reusable = true}}, SHIFT(476), - [1458] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_union_field, 3), - [1460] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_initializer, 1), - [1462] = {.entry = {.count = 1, .reusable = true}}, SHIFT(465), - [1464] = {.entry = {.count = 1, .reusable = true}}, SHIFT(273), - [1466] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_case, 3), - [1468] = {.entry = {.count = 1, .reusable = true}}, SHIFT(457), - [1470] = {.entry = {.count = 1, .reusable = true}}, SHIFT(695), - [1472] = {.entry = {.count = 1, .reusable = true}}, SHIFT(694), - [1474] = {.entry = {.count = 1, .reusable = true}}, SHIFT(413), - [1476] = {.entry = {.count = 1, .reusable = true}}, SHIFT(206), - [1478] = {.entry = {.count = 1, .reusable = true}}, SHIFT(407), - [1480] = {.entry = {.count = 1, .reusable = true}}, SHIFT(699), - [1482] = {.entry = {.count = 1, .reusable = true}}, SHIFT(218), - [1484] = {.entry = {.count = 1, .reusable = true}}, SHIFT(209), - [1486] = {.entry = {.count = 1, .reusable = true}}, SHIFT(335), - [1488] = {.entry = {.count = 1, .reusable = true}}, SHIFT(336), - [1490] = {.entry = {.count = 1, .reusable = true}}, SHIFT(207), - [1492] = {.entry = {.count = 1, .reusable = true}}, SHIFT(154), - [1494] = {.entry = {.count = 1, .reusable = true}}, SHIFT(593), - [1496] = {.entry = {.count = 1, .reusable = true}}, SHIFT(277), - [1498] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_constant_bindings, 3), - [1500] = {.entry = {.count = 1, .reusable = true}}, SHIFT(90), - [1502] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_global_bindings, 3), - [1504] = {.entry = {.count = 1, .reusable = true}}, SHIFT(194), - [1506] = {.entry = {.count = 1, .reusable = true}}, SHIFT(196), - [1508] = {.entry = {.count = 1, .reusable = true}}, SHIFT(735), - [1510] = {.entry = {.count = 1, .reusable = true}}, SHIFT(421), - [1512] = {.entry = {.count = 1, .reusable = true}}, SHIFT(423), - [1514] = {.entry = {.count = 1, .reusable = true}}, SHIFT(534), - [1516] = {.entry = {.count = 1, .reusable = true}}, SHIFT(179), - [1518] = {.entry = {.count = 1, .reusable = true}}, SHIFT(473), - [1520] = {.entry = {.count = 1, .reusable = true}}, SHIFT(33), - [1522] = {.entry = {.count = 1, .reusable = true}}, SHIFT(346), - [1524] = {.entry = {.count = 1, .reusable = true}}, SHIFT(341), - [1526] = {.entry = {.count = 1, .reusable = true}}, SHIFT(340), - [1528] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6, .production_id = 6), - [1530] = {.entry = {.count = 1, .reusable = true}}, SHIFT(254), - [1532] = {.entry = {.count = 1, .reusable = true}}, SHIFT(249), + [1117] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_string_chars_repeat1, 2), SHIFT_REPEAT(626), + [1120] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_string_chars_repeat1, 2), + [1122] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_string_chars_repeat1, 2), SHIFT_REPEAT(540), + [1125] = {.entry = {.count = 1, .reusable = true}}, SHIFT(788), + [1127] = {.entry = {.count = 1, .reusable = true}}, SHIFT(388), + [1129] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_fntype_attr, 1), + [1131] = {.entry = {.count = 1, .reusable = true}}, SHIFT(213), + [1133] = {.entry = {.count = 1, .reusable = false}}, SHIFT(656), + [1135] = {.entry = {.count = 1, .reusable = true}}, SHIFT(260), + [1137] = {.entry = {.count = 1, .reusable = true}}, SHIFT(205), + [1139] = {.entry = {.count = 1, .reusable = false}}, SHIFT(498), + [1141] = {.entry = {.count = 1, .reusable = true}}, SHIFT(312), + [1143] = {.entry = {.count = 1, .reusable = true}}, SHIFT(499), + [1145] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_fndec_attr, 1), + [1147] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_decl_attr, 4), + [1149] = {.entry = {.count = 1, .reusable = false}}, SHIFT(781), + [1151] = {.entry = {.count = 1, .reusable = false}}, SHIFT(614), + [1153] = {.entry = {.count = 1, .reusable = true}}, SHIFT(513), + [1155] = {.entry = {.count = 1, .reusable = true}}, SHIFT(242), + [1157] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter_list, 2), + [1159] = {.entry = {.count = 1, .reusable = true}}, SHIFT(561), + [1161] = {.entry = {.count = 1, .reusable = true}}, SHIFT(53), + [1163] = {.entry = {.count = 1, .reusable = true}}, SHIFT(298), + [1165] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_if_expression, 2), SHIFT(101), + [1168] = {.entry = {.count = 1, .reusable = true}}, SHIFT(284), + [1170] = {.entry = {.count = 1, .reusable = true}}, SHIFT(229), + [1172] = {.entry = {.count = 1, .reusable = true}}, SHIFT(530), + [1174] = {.entry = {.count = 1, .reusable = true}}, SHIFT(537), + [1176] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_values, 2), + [1178] = {.entry = {.count = 1, .reusable = true}}, SHIFT(529), + [1180] = {.entry = {.count = 1, .reusable = false}}, SHIFT(186), + [1182] = {.entry = {.count = 1, .reusable = true}}, SHIFT(310), + [1184] = {.entry = {.count = 1, .reusable = false}}, SHIFT(181), + [1186] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_bindings, 4), + [1188] = {.entry = {.count = 1, .reusable = true}}, SHIFT(62), + [1190] = {.entry = {.count = 1, .reusable = false}}, SHIFT(187), + [1192] = {.entry = {.count = 1, .reusable = true}}, SHIFT(378), + [1194] = {.entry = {.count = 1, .reusable = false}}, SHIFT(191), + [1196] = {.entry = {.count = 1, .reusable = true}}, SHIFT(250), + [1198] = {.entry = {.count = 1, .reusable = true}}, SHIFT(377), + [1200] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_escape_sequence, 1), + [1202] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_binding_names, 3), + [1204] = {.entry = {.count = 1, .reusable = true}}, SHIFT(617), + [1206] = {.entry = {.count = 1, .reusable = true}}, SHIFT(515), + [1208] = {.entry = {.count = 1, .reusable = true}}, SHIFT(789), + [1210] = {.entry = {.count = 1, .reusable = true}}, SHIFT(500), + [1212] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_tagged_types_repeat1, 2), + [1214] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_tagged_types_repeat1, 2), SHIFT_REPEAT(177), + [1217] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_offset_specifier, 4), + [1219] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameters, 3), + [1221] = {.entry = {.count = 1, .reusable = true}}, SHIFT(89), + [1223] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_value, 1), + [1225] = {.entry = {.count = 1, .reusable = true}}, SHIFT(64), + [1227] = {.entry = {.count = 1, .reusable = true}}, SHIFT(180), + [1229] = {.entry = {.count = 1, .reusable = true}}, SHIFT(16), + [1231] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array_members, 1), + [1233] = {.entry = {.count = 1, .reusable = true}}, SHIFT(594), + [1235] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameters, 1), + [1237] = {.entry = {.count = 1, .reusable = true}}, SHIFT(485), + [1239] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter_list, 1), + [1241] = {.entry = {.count = 1, .reusable = true}}, SHIFT(554), + [1243] = {.entry = {.count = 1, .reusable = true}}, SHIFT(610), + [1245] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_global_binding, 4), + [1247] = {.entry = {.count = 1, .reusable = true}}, SHIFT(82), + [1249] = {.entry = {.count = 1, .reusable = true}}, SHIFT(100), + [1251] = {.entry = {.count = 1, .reusable = true}}, SHIFT(193), + [1253] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_named_escape, 2), + [1255] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_escape_sequence, 2), + [1257] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_string_char, 1), + [1259] = {.entry = {.count = 1, .reusable = true}}, SHIFT(18), + [1261] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_argument_list, 1), + [1263] = {.entry = {.count = 1, .reusable = true}}, SHIFT(622), + [1265] = {.entry = {.count = 1, .reusable = true}}, SHIFT(495), + [1267] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_global_binding, 3), + [1269] = {.entry = {.count = 1, .reusable = true}}, SHIFT(98), + [1271] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tagged_types, 3), + [1273] = {.entry = {.count = 1, .reusable = true}}, SHIFT(177), + [1275] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tagged_types, 4), + [1277] = {.entry = {.count = 1, .reusable = true}}, SHIFT(502), + [1279] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_name_list, 2), + [1281] = {.entry = {.count = 1, .reusable = true}}, SHIFT(611), + [1283] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter, 3), + [1285] = {.entry = {.count = 1, .reusable = true}}, SHIFT(782), + [1287] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_union_field, 3), + [1289] = {.entry = {.count = 1, .reusable = true}}, SHIFT(237), + [1291] = {.entry = {.count = 1, .reusable = true}}, SHIFT(25), + [1293] = {.entry = {.count = 1, .reusable = true}}, SHIFT(534), + [1295] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_constant_bindings, 1), + [1297] = {.entry = {.count = 1, .reusable = true}}, SHIFT(493), + [1299] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_value, 3), + [1301] = {.entry = {.count = 1, .reusable = true}}, SHIFT(816), + [1303] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter_list, 3), + [1305] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_union_field, 2), + [1307] = {.entry = {.count = 1, .reusable = true}}, SHIFT(8), + [1309] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_append_values, 1), + [1311] = {.entry = {.count = 1, .reusable = true}}, SHIFT(552), + [1313] = {.entry = {.count = 1, .reusable = true}}, SHIFT(235), + [1315] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_values, 3), + [1317] = {.entry = {.count = 1, .reusable = true}}, SHIFT(549), + [1319] = {.entry = {.count = 1, .reusable = true}}, SHIFT(294), + [1321] = {.entry = {.count = 1, .reusable = true}}, SHIFT(91), + [1323] = {.entry = {.count = 1, .reusable = true}}, SHIFT(262), + [1325] = {.entry = {.count = 1, .reusable = true}}, SHIFT(474), + [1327] = {.entry = {.count = 1, .reusable = true}}, SHIFT(165), + [1329] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tuple_types, 3), + [1331] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 3, .production_id = 1), + [1333] = {.entry = {.count = 1, .reusable = true}}, SHIFT(97), + [1335] = {.entry = {.count = 1, .reusable = true}}, SHIFT(471), + [1337] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_values, 1), + [1339] = {.entry = {.count = 1, .reusable = true}}, SHIFT(497), + [1341] = {.entry = {.count = 1, .reusable = true}}, SHIFT(87), + [1343] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_predicate, 3, .production_id = 11), + [1345] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_value, 3), + [1347] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_value, 1), + [1349] = {.entry = {.count = 1, .reusable = true}}, SHIFT(10), + [1351] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_tuple_items, 3), + [1353] = {.entry = {.count = 1, .reusable = true}}, SHIFT(24), + [1355] = {.entry = {.count = 1, .reusable = true}}, SHIFT(247), + [1357] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_global_binding, 6), + [1359] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_union_field, 4), + [1361] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_values, 1), + [1363] = {.entry = {.count = 1, .reusable = true}}, SHIFT(525), + [1365] = {.entry = {.count = 1, .reusable = true}}, SHIFT(243), + [1367] = {.entry = {.count = 1, .reusable = true}}, SHIFT(72), + [1369] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_predicate, 1), + [1371] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_expression, 1), SHIFT(71), + [1374] = {.entry = {.count = 1, .reusable = true}}, SHIFT(324), + [1376] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_constant_binding, 5), + [1378] = {.entry = {.count = 1, .reusable = true}}, SHIFT(74), + [1380] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_union_field, 1), + [1382] = {.entry = {.count = 1, .reusable = true}}, SHIFT(779), + [1384] = {.entry = {.count = 1, .reusable = true}}, SHIFT(57), + [1386] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_global_binding, 5), + [1388] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_union_fields, 1), + [1390] = {.entry = {.count = 1, .reusable = true}}, SHIFT(405), + [1392] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_global_bindings, 1), + [1394] = {.entry = {.count = 1, .reusable = true}}, SHIFT(468), + [1396] = {.entry = {.count = 1, .reusable = true}}, SHIFT(475), + [1398] = {.entry = {.count = 1, .reusable = true}}, SHIFT(172), + [1400] = {.entry = {.count = 1, .reusable = true}}, SHIFT(195), + [1402] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_case, 5), + [1404] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_case, 3), + [1406] = {.entry = {.count = 1, .reusable = true}}, SHIFT(461), + [1408] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_name_list, 1), + [1410] = {.entry = {.count = 1, .reusable = true}}, SHIFT(548), + [1412] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_switch_case, 3), + [1414] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 4, .production_id = 2), + [1416] = {.entry = {.count = 1, .reusable = true}}, SHIFT(85), + [1418] = {.entry = {.count = 1, .reusable = true}}, SHIFT(695), + [1420] = {.entry = {.count = 1, .reusable = true}}, SHIFT(694), + [1422] = {.entry = {.count = 1, .reusable = true}}, SHIFT(214), + [1424] = {.entry = {.count = 1, .reusable = true}}, SHIFT(392), + [1426] = {.entry = {.count = 1, .reusable = true}}, SHIFT(715), + [1428] = {.entry = {.count = 1, .reusable = true}}, SHIFT(519), + [1430] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_bindings, 3), + [1432] = {.entry = {.count = 1, .reusable = true}}, SHIFT(506), + [1434] = {.entry = {.count = 1, .reusable = true}}, SHIFT(63), + [1436] = {.entry = {.count = 1, .reusable = true}}, SHIFT(745), + [1438] = {.entry = {.count = 1, .reusable = true}}, SHIFT(318), + [1440] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_field_value, 5), + [1442] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_cases, 1), + [1444] = {.entry = {.count = 1, .reusable = true}}, SHIFT(163), + [1446] = {.entry = {.count = 1, .reusable = true}}, SHIFT(539), + [1448] = {.entry = {.count = 1, .reusable = true}}, SHIFT(538), + [1450] = {.entry = {.count = 1, .reusable = true}}, SHIFT(309), + [1452] = {.entry = {.count = 1, .reusable = true}}, SHIFT(551), + [1454] = {.entry = {.count = 1, .reusable = true}}, SHIFT(313), + [1456] = {.entry = {.count = 1, .reusable = true}}, SHIFT(11), + [1458] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_case_options, 1), + [1460] = {.entry = {.count = 1, .reusable = true}}, SHIFT(302), + [1462] = {.entry = {.count = 1, .reusable = true}}, SHIFT(477), + [1464] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_switch_cases, 1), + [1466] = {.entry = {.count = 1, .reusable = true}}, SHIFT(5), + [1468] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_initializer, 1), + [1470] = {.entry = {.count = 1, .reusable = true}}, SHIFT(465), + [1472] = {.entry = {.count = 1, .reusable = true}}, SHIFT(275), + [1474] = {.entry = {.count = 1, .reusable = true}}, SHIFT(40), + [1476] = {.entry = {.count = 1, .reusable = true}}, SHIFT(723), + [1478] = {.entry = {.count = 1, .reusable = true}}, SHIFT(412), + [1480] = {.entry = {.count = 1, .reusable = true}}, SHIFT(409), + [1482] = {.entry = {.count = 1, .reusable = true}}, SHIFT(204), + [1484] = {.entry = {.count = 1, .reusable = true}}, SHIFT(198), + [1486] = {.entry = {.count = 1, .reusable = true}}, SHIFT(701), + [1488] = {.entry = {.count = 1, .reusable = true}}, SHIFT(218), + [1490] = {.entry = {.count = 1, .reusable = true}}, SHIFT(201), + [1492] = {.entry = {.count = 1, .reusable = true}}, SHIFT(337), + [1494] = {.entry = {.count = 1, .reusable = true}}, SHIFT(338), + [1496] = {.entry = {.count = 1, .reusable = true}}, SHIFT(453), + [1498] = {.entry = {.count = 1, .reusable = true}}, SHIFT(576), + [1500] = {.entry = {.count = 1, .reusable = true}}, SHIFT(280), + [1502] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_constant_bindings, 3), + [1504] = {.entry = {.count = 1, .reusable = true}}, SHIFT(96), + [1506] = {.entry = {.count = 1, .reusable = true}}, SHIFT(188), + [1508] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_global_bindings, 3), + [1510] = {.entry = {.count = 1, .reusable = true}}, SHIFT(206), + [1512] = {.entry = {.count = 1, .reusable = true}}, SHIFT(734), + [1514] = {.entry = {.count = 1, .reusable = true}}, SHIFT(433), + [1516] = {.entry = {.count = 1, .reusable = true}}, SHIFT(435), + [1518] = {.entry = {.count = 1, .reusable = true}}, SHIFT(550), + [1520] = {.entry = {.count = 1, .reusable = true}}, SHIFT(192), + [1522] = {.entry = {.count = 1, .reusable = true}}, SHIFT(470), + [1524] = {.entry = {.count = 1, .reusable = true}}, SHIFT(39), + [1526] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 6, .production_id = 6), + [1528] = {.entry = {.count = 1, .reusable = true}}, SHIFT(348), + [1530] = {.entry = {.count = 1, .reusable = true}}, SHIFT(347), + [1532] = {.entry = {.count = 1, .reusable = true}}, SHIFT(343), [1534] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_name_list, 3), - [1536] = {.entry = {.count = 1, .reusable = true}}, SHIFT(82), - [1538] = {.entry = {.count = 1, .reusable = true}}, SHIFT(390), - [1540] = {.entry = {.count = 1, .reusable = true}}, SHIFT(235), + [1536] = {.entry = {.count = 1, .reusable = true}}, SHIFT(245), + [1538] = {.entry = {.count = 1, .reusable = true}}, SHIFT(240), + [1540] = {.entry = {.count = 1, .reusable = true}}, SHIFT(60), [1542] = {.entry = {.count = 1, .reusable = true}}, SHIFT(141), - [1544] = {.entry = {.count = 1, .reusable = true}}, SHIFT(81), - [1546] = {.entry = {.count = 1, .reusable = true}}, SHIFT(80), - [1548] = {.entry = {.count = 1, .reusable = true}}, SHIFT(491), - [1550] = {.entry = {.count = 1, .reusable = true}}, SHIFT(338), - [1552] = {.entry = {.count = 1, .reusable = true}}, SHIFT(233), - [1554] = {.entry = {.count = 1, .reusable = true}}, SHIFT(75), - [1556] = {.entry = {.count = 1, .reusable = true}}, SHIFT(155), - [1558] = {.entry = {.count = 1, .reusable = true}}, SHIFT(287), - [1560] = {.entry = {.count = 1, .reusable = true}}, SHIFT(219), - [1562] = {.entry = {.count = 1, .reusable = true}}, SHIFT(26), - [1564] = {.entry = {.count = 1, .reusable = true}}, SHIFT(250), - [1566] = {.entry = {.count = 1, .reusable = true}}, SHIFT(456), - [1568] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_bindings, 5), - [1570] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_named_escape, 2), - [1572] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_escape_sequence, 2), - [1574] = {.entry = {.count = 1, .reusable = true}}, SHIFT(471), - [1576] = {.entry = {.count = 1, .reusable = true}}, SHIFT(84), - [1578] = {.entry = {.count = 1, .reusable = true}}, SHIFT(292), - [1580] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_escape_sequence, 1), - [1582] = {.entry = {.count = 1, .reusable = true}}, SHIFT(79), - [1584] = {.entry = {.count = 1, .reusable = true}}, SHIFT(176), - [1586] = {.entry = {.count = 1, .reusable = true}}, SHIFT(78), - [1588] = {.entry = {.count = 1, .reusable = true}}, SHIFT(238), - [1590] = {.entry = {.count = 1, .reusable = true}}, SHIFT(239), - [1592] = {.entry = {.count = 1, .reusable = true}}, SHIFT(242), - [1594] = {.entry = {.count = 1, .reusable = true}}, SHIFT(415), - [1596] = {.entry = {.count = 1, .reusable = true}}, SHIFT(243), - [1598] = {.entry = {.count = 1, .reusable = true}}, SHIFT(245), - [1600] = {.entry = {.count = 1, .reusable = true}}, SHIFT(594), - [1602] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_cases, 3), - [1604] = {.entry = {.count = 1, .reusable = true}}, SHIFT(60), - [1606] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_case_options, 3), - [1608] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_switch_cases, 3), - [1610] = {.entry = {.count = 1, .reusable = true}}, SHIFT(20), - [1612] = {.entry = {.count = 1, .reusable = true}}, SHIFT(83), - [1614] = {.entry = {.count = 1, .reusable = true}}, SHIFT(88), - [1616] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_predicate, 5), - [1618] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_append_values, 3), - [1620] = {.entry = {.count = 1, .reusable = true}}, SHIFT(439), - [1622] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_unit, 2), - [1624] = {.entry = {.count = 1, .reusable = true}}, SHIFT(446), - [1626] = {.entry = {.count = 1, .reusable = true}}, SHIFT(72), - [1628] = {.entry = {.count = 1, .reusable = true}}, SHIFT(53), - [1630] = {.entry = {.count = 1, .reusable = true}}, SHIFT(663), - [1632] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 5, .production_id = 3), - [1634] = {.entry = {.count = 1, .reusable = true}}, SHIFT(319), - [1636] = {.entry = {.count = 1, .reusable = true}}, SHIFT(318), - [1638] = {.entry = {.count = 1, .reusable = true}}, SHIFT(16), - [1640] = {.entry = {.count = 1, .reusable = true}}, SHIFT(386), - [1642] = {.entry = {.count = 1, .reusable = true}}, SHIFT(188), - [1644] = {.entry = {.count = 1, .reusable = true}}, SHIFT(603), - [1646] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_predicate, 3, .production_id = 12), - [1648] = {.entry = {.count = 1, .reusable = true}}, SHIFT(448), - [1650] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_initializer, 3), - [1652] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 2), - [1654] = {.entry = {.count = 1, .reusable = true}}, SHIFT(189), - [1656] = {.entry = {.count = 1, .reusable = true}}, SHIFT(279), - [1658] = {.entry = {.count = 1, .reusable = true}}, SHIFT(499), + [1544] = {.entry = {.count = 1, .reusable = true}}, SHIFT(389), + [1546] = {.entry = {.count = 1, .reusable = true}}, SHIFT(258), + [1548] = {.entry = {.count = 1, .reusable = true}}, SHIFT(151), + [1550] = {.entry = {.count = 1, .reusable = true}}, SHIFT(54), + [1552] = {.entry = {.count = 1, .reusable = true}}, SHIFT(503), + [1554] = {.entry = {.count = 1, .reusable = true}}, SHIFT(50), + [1556] = {.entry = {.count = 1, .reusable = true}}, SHIFT(341), + [1558] = {.entry = {.count = 1, .reusable = true}}, SHIFT(261), + [1560] = {.entry = {.count = 1, .reusable = true}}, SHIFT(155), + [1562] = {.entry = {.count = 1, .reusable = true}}, SHIFT(290), + [1564] = {.entry = {.count = 1, .reusable = true}}, SHIFT(56), + [1566] = {.entry = {.count = 1, .reusable = true}}, SHIFT(231), + [1568] = {.entry = {.count = 1, .reusable = true}}, SHIFT(95), + [1570] = {.entry = {.count = 1, .reusable = true}}, SHIFT(225), + [1572] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_named_escape, 2), + [1574] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_escape_sequence, 2), + [1576] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_bindings, 5), + [1578] = {.entry = {.count = 1, .reusable = true}}, SHIFT(287), + [1580] = {.entry = {.count = 1, .reusable = true}}, SHIFT(480), + [1582] = {.entry = {.count = 1, .reusable = true}}, SHIFT(86), + [1584] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_escape_sequence, 1), + [1586] = {.entry = {.count = 1, .reusable = true}}, SHIFT(80), + [1588] = {.entry = {.count = 1, .reusable = true}}, SHIFT(176), + [1590] = {.entry = {.count = 1, .reusable = true}}, SHIFT(414), + [1592] = {.entry = {.count = 1, .reusable = true}}, SHIFT(79), + [1594] = {.entry = {.count = 1, .reusable = true}}, SHIFT(220), + [1596] = {.entry = {.count = 1, .reusable = true}}, SHIFT(241), + [1598] = {.entry = {.count = 1, .reusable = true}}, SHIFT(238), + [1600] = {.entry = {.count = 1, .reusable = true}}, SHIFT(28), + [1602] = {.entry = {.count = 1, .reusable = true}}, SHIFT(236), + [1604] = {.entry = {.count = 1, .reusable = true}}, SHIFT(232), + [1606] = {.entry = {.count = 1, .reusable = true}}, SHIFT(595), + [1608] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_match_cases, 3), + [1610] = {.entry = {.count = 1, .reusable = true}}, SHIFT(94), + [1612] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_case_options, 3), + [1614] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_switch_cases, 3), + [1616] = {.entry = {.count = 1, .reusable = true}}, SHIFT(99), + [1618] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_predicate, 5), + [1620] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_append_values, 3), + [1622] = {.entry = {.count = 1, .reusable = true}}, SHIFT(418), + [1624] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_unit, 2), + [1626] = {.entry = {.count = 1, .reusable = true}}, SHIFT(425), + [1628] = {.entry = {.count = 1, .reusable = true}}, SHIFT(665), + [1630] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_function_declaration, 5, .production_id = 3), + [1632] = {.entry = {.count = 1, .reusable = true}}, SHIFT(75), + [1634] = {.entry = {.count = 1, .reusable = true}}, SHIFT(58), + [1636] = {.entry = {.count = 1, .reusable = true}}, SHIFT(321), + [1638] = {.entry = {.count = 1, .reusable = true}}, SHIFT(390), + [1640] = {.entry = {.count = 1, .reusable = true}}, SHIFT(320), + [1642] = {.entry = {.count = 1, .reusable = true}}, SHIFT(15), + [1644] = {.entry = {.count = 1, .reusable = true}}, SHIFT(457), + [1646] = {.entry = {.count = 1, .reusable = true}}, SHIFT(194), + [1648] = {.entry = {.count = 1, .reusable = true}}, SHIFT(604), + [1650] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_for_predicate, 3, .production_id = 12), + [1652] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_initializer, 3), + [1654] = {.entry = {.count = 1, .reusable = true}}, SHIFT(279), + [1656] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_type_declaration, 2), + [1658] = {.entry = {.count = 1, .reusable = true}}, SHIFT(175), [1660] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_argument_list, 3), - [1662] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_constant_declaration, 2), - [1664] = {.entry = {.count = 1, .reusable = true}}, SHIFT(316), - [1666] = {.entry = {.count = 1, .reusable = true}}, SHIFT(431), - [1668] = {.entry = {.count = 1, .reusable = true}}, SHIFT(314), - [1670] = {.entry = {.count = 1, .reusable = true}}, SHIFT(65), - [1672] = {.entry = {.count = 1, .reusable = true}}, SHIFT(61), - [1674] = {.entry = {.count = 1, .reusable = true}}, SHIFT(66), - [1676] = {.entry = {.count = 1, .reusable = true}}, SHIFT(183), - [1678] = {.entry = {.count = 1, .reusable = true}}, SHIFT(167), - [1680] = {.entry = {.count = 1, .reusable = true}}, SHIFT(7), - [1682] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_global_declaration, 2), - [1684] = {.entry = {.count = 1, .reusable = true}}, SHIFT(449), - [1686] = {.entry = {.count = 1, .reusable = true}}, SHIFT(399), - [1688] = {.entry = {.count = 1, .reusable = true}}, SHIFT(102), - [1690] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression_list, 3), - [1692] = {.entry = {.count = 1, .reusable = true}}, SHIFT(455), - [1694] = {.entry = {.count = 1, .reusable = true}}, SHIFT(295), - [1696] = {.entry = {.count = 1, .reusable = true}}, SHIFT(49), - [1698] = {.entry = {.count = 1, .reusable = true}}, SHIFT(48), - [1700] = {.entry = {.count = 1, .reusable = true}}, SHIFT(562), - [1702] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_declaration, 1), - [1704] = {.entry = {.count = 1, .reusable = true}}, SHIFT(396), - [1706] = {.entry = {.count = 1, .reusable = true}}, SHIFT(306), - [1708] = {.entry = {.count = 1, .reusable = true}}, SHIFT(47), - [1710] = {.entry = {.count = 1, .reusable = true}}, SHIFT(18), - [1712] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array_members, 3), - [1714] = {.entry = {.count = 1, .reusable = true}}, SHIFT(321), - [1716] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_union_fields, 3), - [1718] = {.entry = {.count = 1, .reusable = true}}, SHIFT(551), - [1720] = {.entry = {.count = 1, .reusable = true}}, ACCEPT_INPUT(), - [1722] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_values, 3), - [1724] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_rune, 1), - [1726] = {.entry = {.count = 1, .reusable = true}}, SHIFT(315), - [1728] = {.entry = {.count = 1, .reusable = true}}, SHIFT(533), - [1730] = {.entry = {.count = 1, .reusable = true}}, SHIFT(71), - [1732] = {.entry = {.count = 1, .reusable = true}}, SHIFT(410), - [1734] = {.entry = {.count = 1, .reusable = true}}, SHIFT(409), - [1736] = {.entry = {.count = 1, .reusable = true}}, SHIFT(547), - [1738] = {.entry = {.count = 1, .reusable = true}}, SHIFT(190), - [1740] = {.entry = {.count = 1, .reusable = true}}, SHIFT(478), - [1742] = {.entry = {.count = 1, .reusable = true}}, SHIFT(63), - [1744] = {.entry = {.count = 1, .reusable = true}}, SHIFT(69), - [1746] = {.entry = {.count = 1, .reusable = true}}, SHIFT(152), - [1748] = {.entry = {.count = 1, .reusable = true}}, SHIFT(42), - [1750] = {.entry = {.count = 1, .reusable = true}}, SHIFT(73), - [1752] = {.entry = {.count = 1, .reusable = true}}, SHIFT(151), - [1754] = {.entry = {.count = 1, .reusable = true}}, SHIFT(755), - [1756] = {.entry = {.count = 1, .reusable = true}}, SHIFT(756), - [1758] = {.entry = {.count = 1, .reusable = true}}, SHIFT(32), - [1760] = {.entry = {.count = 1, .reusable = true}}, SHIFT(87), - [1762] = {.entry = {.count = 1, .reusable = true}}, SHIFT(92), - [1764] = {.entry = {.count = 1, .reusable = true}}, SHIFT(91), - [1766] = {.entry = {.count = 1, .reusable = true}}, SHIFT(34), - [1768] = {.entry = {.count = 1, .reusable = true}}, SHIFT(15), - [1770] = {.entry = {.count = 1, .reusable = true}}, SHIFT(548), - [1772] = {.entry = {.count = 1, .reusable = true}}, SHIFT(14), - [1774] = {.entry = {.count = 1, .reusable = true}}, SHIFT(35), - [1776] = {.entry = {.count = 1, .reusable = true}}, SHIFT(36), - [1778] = {.entry = {.count = 1, .reusable = true}}, SHIFT(802), - [1780] = {.entry = {.count = 1, .reusable = true}}, SHIFT(39), - [1782] = {.entry = {.count = 1, .reusable = true}}, SHIFT(805), - [1784] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter_list, 4), - [1786] = {.entry = {.count = 1, .reusable = true}}, SHIFT(25), - [1788] = {.entry = {.count = 1, .reusable = true}}, SHIFT(810), - [1790] = {.entry = {.count = 1, .reusable = true}}, SHIFT(142), - [1792] = {.entry = {.count = 1, .reusable = true}}, SHIFT(815), + [1662] = {.entry = {.count = 1, .reusable = true}}, SHIFT(512), + [1664] = {.entry = {.count = 1, .reusable = true}}, SHIFT(317), + [1666] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_constant_declaration, 2), + [1668] = {.entry = {.count = 1, .reusable = true}}, SHIFT(84), + [1670] = {.entry = {.count = 1, .reusable = true}}, SHIFT(17), + [1672] = {.entry = {.count = 1, .reusable = true}}, SHIFT(316), + [1674] = {.entry = {.count = 1, .reusable = true}}, SHIFT(83), + [1676] = {.entry = {.count = 1, .reusable = true}}, SHIFT(81), + [1678] = {.entry = {.count = 1, .reusable = true}}, SHIFT(168), + [1680] = {.entry = {.count = 1, .reusable = true}}, SHIFT(185), + [1682] = {.entry = {.count = 1, .reusable = true}}, SHIFT(7), + [1684] = {.entry = {.count = 1, .reusable = true}}, SHIFT(439), + [1686] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_global_declaration, 2), + [1688] = {.entry = {.count = 1, .reusable = true}}, SHIFT(395), + [1690] = {.entry = {.count = 1, .reusable = true}}, SHIFT(77), + [1692] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_expression_list, 3), + [1694] = {.entry = {.count = 1, .reusable = true}}, SHIFT(454), + [1696] = {.entry = {.count = 1, .reusable = true}}, SHIFT(297), + [1698] = {.entry = {.count = 1, .reusable = true}}, SHIFT(426), + [1700] = {.entry = {.count = 1, .reusable = true}}, SHIFT(308), + [1702] = {.entry = {.count = 1, .reusable = true}}, SHIFT(49), + [1704] = {.entry = {.count = 1, .reusable = true}}, SHIFT(48), + [1706] = {.entry = {.count = 1, .reusable = true}}, SHIFT(627), + [1708] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_declaration, 1), + [1710] = {.entry = {.count = 1, .reusable = true}}, SHIFT(396), + [1712] = {.entry = {.count = 1, .reusable = true}}, SHIFT(21), + [1714] = {.entry = {.count = 1, .reusable = true}}, SHIFT(47), + [1716] = {.entry = {.count = 1, .reusable = true}}, SHIFT(323), + [1718] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_array_members, 3), + [1720] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_rune, 1), + [1722] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_struct_union_fields, 3), + [1724] = {.entry = {.count = 1, .reusable = true}}, ACCEPT_INPUT(), + [1726] = {.entry = {.count = 1, .reusable = true}}, SHIFT(527), + [1728] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_enum_values, 3), + [1730] = {.entry = {.count = 1, .reusable = true}}, SHIFT(319), + [1732] = {.entry = {.count = 1, .reusable = true}}, SHIFT(535), + [1734] = {.entry = {.count = 1, .reusable = true}}, SHIFT(66), + [1736] = {.entry = {.count = 1, .reusable = true}}, SHIFT(417), + [1738] = {.entry = {.count = 1, .reusable = true}}, SHIFT(415), + [1740] = {.entry = {.count = 1, .reusable = true}}, SHIFT(524), + [1742] = {.entry = {.count = 1, .reusable = true}}, SHIFT(190), + [1744] = {.entry = {.count = 1, .reusable = true}}, SHIFT(473), + [1746] = {.entry = {.count = 1, .reusable = true}}, SHIFT(68), + [1748] = {.entry = {.count = 1, .reusable = true}}, SHIFT(41), + [1750] = {.entry = {.count = 1, .reusable = true}}, SHIFT(153), + [1752] = {.entry = {.count = 1, .reusable = true}}, SHIFT(42), + [1754] = {.entry = {.count = 1, .reusable = true}}, SHIFT(78), + [1756] = {.entry = {.count = 1, .reusable = true}}, SHIFT(152), + [1758] = {.entry = {.count = 1, .reusable = true}}, SHIFT(755), + [1760] = {.entry = {.count = 1, .reusable = true}}, SHIFT(757), + [1762] = {.entry = {.count = 1, .reusable = true}}, SHIFT(27), + [1764] = {.entry = {.count = 1, .reusable = true}}, SHIFT(90), + [1766] = {.entry = {.count = 1, .reusable = true}}, SHIFT(70), + [1768] = {.entry = {.count = 1, .reusable = true}}, SHIFT(69), + [1770] = {.entry = {.count = 1, .reusable = true}}, SHIFT(30), + [1772] = {.entry = {.count = 1, .reusable = true}}, SHIFT(13), + [1774] = {.entry = {.count = 1, .reusable = true}}, SHIFT(517), + [1776] = {.entry = {.count = 1, .reusable = true}}, SHIFT(12), + [1778] = {.entry = {.count = 1, .reusable = true}}, SHIFT(34), + [1780] = {.entry = {.count = 1, .reusable = true}}, SHIFT(35), + [1782] = {.entry = {.count = 1, .reusable = true}}, SHIFT(804), + [1784] = {.entry = {.count = 1, .reusable = true}}, SHIFT(37), + [1786] = {.entry = {.count = 1, .reusable = true}}, SHIFT(807), + [1788] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_parameter_list, 4), + [1790] = {.entry = {.count = 1, .reusable = true}}, SHIFT(38), + [1792] = {.entry = {.count = 1, .reusable = true}}, SHIFT(812), + [1794] = {.entry = {.count = 1, .reusable = true}}, SHIFT(142), + [1796] = {.entry = {.count = 1, .reusable = true}}, SHIFT(817), }; #ifdef __cplusplus From b7a496713c7aadbf31570e19bcae4537fb08ef97 Mon Sep 17 00:00:00 2001 From: ecmma Date: Wed, 14 Apr 2021 14:19:40 +0200 Subject: [PATCH 7/9] minor highlight changes --- queries/highlights.scm | 2 ++ 1 file changed, 2 insertions(+) diff --git a/queries/highlights.scm b/queries/highlights.scm index 6d78b87d4..066273481 100644 --- a/queries/highlights.scm +++ b/queries/highlights.scm @@ -90,6 +90,8 @@ ":" @delimiter ";" @delimiter +"{" @delimiter +"}" @delimiter (comment) @comment From bc26a6a949f2e0d98b7bfc437d459b250900a165 Mon Sep 17 00:00:00 2001 From: ecmma Date: Wed, 14 Apr 2021 14:38:22 +0200 Subject: [PATCH 8/9] add readme --- README.md | 14 ++++++++++++++ 1 file changed, 14 insertions(+) create mode 100644 README.md diff --git a/README.md b/README.md new file mode 100644 index 000000000..4cfe8dc69 --- /dev/null +++ b/README.md @@ -0,0 +1,14 @@ +# tree-sitter-hare +[Hare](https://harelang.org/) grammar for the popular incremental parser generator [tree-sitter](https://tree-sitter.github.io/tree-sitter/). + +**status**: the majority of sources in `examples` (Hare stdlib) is recognized fine - sources containing +`\\` in strings fail, due to them getting parsed as comments +as a consequence to tree-sitter precedence rules. + +For a list of features offered by tree-sitter refer to their site. Summarily, +one of the main features is context-aware highlight (e.g. local variables are highlighted +differently than function parameters). + +This grammar can be used in a number of editors and different situations (github +uses it, for example) - at this stage it must be inserted manually into your editor. +See, for example, [nvim-treesitter](https://github.com/nvim-treesitter/nvim-treesitter#advanced-setup). From 7ed685ae528d97def3fb8fef89ca94e688cb6def Mon Sep 17 00:00:00 2001 From: Ember Sawady Date: Sat, 10 Sep 2022 15:47:20 +0000 Subject: [PATCH 9/9] Add support for Hare --- build.rs | 5 +++++ sample_files/compare.expected | 3 +++ sample_files/hare_after.ha | 14 ++++++++++++++ sample_files/hare_before.ha | 5 +++++ src/parse/guess_language.rs | 3 +++ src/parse/tree_sitter_parser.rs | 14 ++++++++++++++ vendor/highlights/hare.scm | 1 + vendor/tree-sitter-hare-src | 1 + 8 files changed, 46 insertions(+) create mode 100644 sample_files/hare_after.ha create mode 100644 sample_files/hare_before.ha create mode 120000 vendor/highlights/hare.scm create mode 120000 vendor/tree-sitter-hare-src diff --git a/build.rs b/build.rs index 96707455d..1f44bdf4b 100644 --- a/build.rs +++ b/build.rs @@ -202,6 +202,11 @@ fn main() { src_dir: "vendor/tree-sitter-hack-src", extra_files: vec!["scanner.cc"], }, + TreeSitterParser { + name: "tree-sitter-hare", + src_dir: "vendor/tree-sitter-hare-src", + extra_files: vec![], + }, TreeSitterParser { name: "tree-sitter-haskell", src_dir: "vendor/tree-sitter-haskell-src", diff --git a/sample_files/compare.expected b/sample_files/compare.expected index 3639717e9..c173833c9 100644 --- a/sample_files/compare.expected +++ b/sample_files/compare.expected @@ -46,6 +46,9 @@ bfb410815de1fb0fd47fa078fbd8e329 - sample_files/hack_before.php sample_files/hack_after.php 50babcb945cf3b3ba12d5481a1bf8ccf - +sample_files/hare_before.ha sample_files/hare_after.ha +8edc2f3ae2eaeba7bcf328ed00398767 - + sample_files/haskell_before.hs sample_files/haskell_after.hs 324d1c9b2a04133a75b1975272ffb6ad - diff --git a/sample_files/hare_after.ha b/sample_files/hare_after.ha new file mode 100644 index 000000000..825bb24d2 --- /dev/null +++ b/sample_files/hare_after.ha @@ -0,0 +1,14 @@ +use fmt; + +export fn main() void = { + const greetings = [ + "Hello, world!", + "¡Hola Mundo!", + "Γειά σου Κόσμε!", + "Привет, мир!", + "こんにちは世界！", + ]; + for (let i = 0z; i < len(greetings); i += 1) { + fmt::println(greetings[i])!; + }; +}; diff --git a/sample_files/hare_before.ha b/sample_files/hare_before.ha new file mode 100644 index 000000000..4e405892b --- /dev/null +++ b/sample_files/hare_before.ha @@ -0,0 +1,5 @@ +use fmt; + +export fn main() void = { + fmt::println("Hello, world!"); +}; diff --git a/src/parse/guess_language.rs b/src/parse/guess_language.rs index 19fee1d03..23c3eec2c 100644 --- a/src/parse/guess_language.rs +++ b/src/parse/guess_language.rs @@ -34,6 +34,7 @@ pub enum Language { Gleam, Go, Hack, + Hare, Haskell, Hcl, Html, @@ -85,6 +86,7 @@ pub fn language_name(language: Language) -> &'static str { Gleam => "Gleam", Go => "Go", Hack => "Hack", + Hare => "Hare", Haskell => "Haskell", Hcl => "HCL", Html => "HTML", @@ -149,6 +151,7 @@ pub const LANG_EXTENSIONS: &'static [(Language, &[&str])] = &[ (Gleam, &["gleam"]), (Go, &["go"]), (Hack, &["hack", "hck", "hhi"]), + (Hare, &["ha"]), (Haskell, &["hs"]), (Hcl, &["hcl", "nomad", "tf", "tfvars", "workflow"]), (Html, &["html", "htm", "xhtml"]), diff --git a/src/parse/tree_sitter_parser.rs b/src/parse/tree_sitter_parser.rs index 92a49db1d..a6f493c4c 100644 --- a/src/parse/tree_sitter_parser.rs +++ b/src/parse/tree_sitter_parser.rs @@ -55,6 +55,7 @@ extern "C" { fn tree_sitter_elvish() -> ts::Language; fn tree_sitter_gleam() -> ts::Language; fn tree_sitter_go() -> ts::Language; + fn tree_sitter_hare() -> ts::Language; fn tree_sitter_hack() -> ts::Language; fn tree_sitter_haskell() -> ts::Language; fn tree_sitter_hcl() -> ts::Language; @@ -327,6 +328,19 @@ pub fn from_language(language: guess::Language) -> TreeSitterConfig { .unwrap(), } } + Hare => { + let language = unsafe { tree_sitter_hare() }; + TreeSitterConfig { + language, + atom_nodes: vec!["string_constant", "rune_constant"].into_iter().collect(), + delimiter_tokens: vec![("[", "]"), ("(", ")"), ("{", "}")], + highlight_query: ts::Query::new( + language, + include_str!("../../vendor/highlights/hare.scm"), + ) + .unwrap(), + } + } Haskell => { let language = unsafe { tree_sitter_haskell() }; TreeSitterConfig { diff --git a/vendor/highlights/hare.scm b/vendor/highlights/hare.scm new file mode 120000 index 000000000..c4cd781c3 --- /dev/null +++ b/vendor/highlights/hare.scm @@ -0,0 +1 @@ +../tree-sitter-hare/queries/highlights.scm \ No newline at end of file diff --git a/vendor/tree-sitter-hare-src b/vendor/tree-sitter-hare-src new file mode 120000 index 000000000..33b676a73 --- /dev/null +++ b/vendor/tree-sitter-hare-src @@ -0,0 +1 @@ +tree-sitter-hare/src/ \ No newline at end of file