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 6ee45ccd6..20320432f 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 diff --git a/vendor/tree-sitter-hare/COPYING b/vendor/tree-sitter-hare/COPYING new file mode 100644 index 000000000..73dc198f9 --- /dev/null +++ b/vendor/tree-sitter-hare/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 +. diff --git a/vendor/tree-sitter-hare/Cargo.toml b/vendor/tree-sitter-hare/Cargo.toml new file mode 100644 index 000000000..cf1a4a463 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/README.md b/vendor/tree-sitter-hare/README.md new file mode 100644 index 000000000..4cfe8dc69 --- /dev/null +++ b/vendor/tree-sitter-hare/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). diff --git a/vendor/tree-sitter-hare/binding.gyp b/vendor/tree-sitter-hare/binding.gyp new file mode 100644 index 000000000..027b4ae73 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/bindings/node/index.js b/vendor/tree-sitter-hare/bindings/node/index.js new file mode 100644 index 000000000..c8ec9f108 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/bindings/rust/build.rs b/vendor/tree-sitter-hare/bindings/rust/build.rs new file mode 100644 index 000000000..c6061f099 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/bindings/rust/lib.rs b/vendor/tree-sitter-hare/bindings/rust/lib.rs new file mode 100644 index 000000000..fe4458852 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/+aarch64.ha b/vendor/tree-sitter-hare/example/+aarch64.ha new file mode 100644 index 000000000..039c86fc2 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/+linux.ha b/vendor/tree-sitter-hare/example/+linux.ha new file mode 100644 index 000000000..8d16e2cec --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/+test.ha b/vendor/tree-sitter-hare/example/+test.ha new file mode 100644 index 000000000..90197c213 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/+x86_64.ha b/vendor/tree-sitter-hare/example/+x86_64.ha new file mode 100644 index 000000000..386aee7ec --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/abort+test.ha b/vendor/tree-sitter-hare/example/abort+test.ha new file mode 100644 index 000000000..947ff6b9a --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/abort.ha b/vendor/tree-sitter-hare/example/abort.ha new file mode 100644 index 000000000..7201b75bd --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/addr.ha b/vendor/tree-sitter-hare/example/addr.ha new file mode 100644 index 000000000..e782334e6 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/adler32.ha b/vendor/tree-sitter-hare/example/adler32.ha new file mode 100644 index 000000000..5779f8977 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/arch+aarch64.ha b/vendor/tree-sitter-hare/example/arch+aarch64.ha new file mode 100644 index 000000000..f555dc0d9 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/arch+x86_64.ha b/vendor/tree-sitter-hare/example/arch+x86_64.ha new file mode 100644 index 000000000..f555dc0d9 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/big.ha b/vendor/tree-sitter-hare/example/big.ha new file mode 100644 index 000000000..f1eec0b45 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/bits.ha b/vendor/tree-sitter-hare/example/bits.ha new file mode 100644 index 000000000..eaa7c9a38 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/buffered.ha b/vendor/tree-sitter-hare/example/buffered.ha new file mode 100644 index 000000000..2baceea29 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/chars.ha b/vendor/tree-sitter-hare/example/chars.ha new file mode 100644 index 000000000..3662c7850 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/classes.ha b/vendor/tree-sitter-hare/example/classes.ha new file mode 100644 index 000000000..d1541af95 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/cmd.ha b/vendor/tree-sitter-hare/example/cmd.ha new file mode 100644 index 000000000..e8a45010c --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/common.ha b/vendor/tree-sitter-hare/example/common.ha new file mode 100644 index 000000000..1700f6c65 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/concat.ha b/vendor/tree-sitter-hare/example/concat.ha new file mode 100644 index 000000000..14e6be57e --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/contains.ha b/vendor/tree-sitter-hare/example/contains.ha new file mode 100644 index 000000000..47dc4df57 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/context.ha b/vendor/tree-sitter-hare/example/context.ha new file mode 100644 index 000000000..9903631e0 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/copy.ha b/vendor/tree-sitter-hare/example/copy.ha new file mode 100644 index 000000000..114a6a446 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/cstring.ha b/vendor/tree-sitter-hare/example/cstring.ha new file mode 100644 index 000000000..ca8409450 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/cstrings.ha b/vendor/tree-sitter-hare/example/cstrings.ha new file mode 100644 index 000000000..4ecd04550 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/ctype.ha b/vendor/tree-sitter-hare/example/ctype.ha new file mode 100644 index 000000000..91ca79458 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/decl.ha b/vendor/tree-sitter-hare/example/decl.ha new file mode 100644 index 000000000..047e19590 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/decode.ha b/vendor/tree-sitter-hare/example/decode.ha new file mode 100644 index 000000000..add1f57a2 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/dirfdfs.ha b/vendor/tree-sitter-hare/example/dirfdfs.ha new file mode 100644 index 000000000..5a1a1ffb6 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/docs.ha b/vendor/tree-sitter-hare/example/docs.ha new file mode 100644 index 000000000..afe908f9d --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/dup.ha b/vendor/tree-sitter-hare/example/dup.ha new file mode 100644 index 000000000..71e977aa3 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/dynamic.ha b/vendor/tree-sitter-hare/example/dynamic.ha new file mode 100644 index 000000000..a4fbe6704 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/encode.ha b/vendor/tree-sitter-hare/example/encode.ha new file mode 100644 index 000000000..42046b06e --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/endian.ha b/vendor/tree-sitter-hare/example/endian.ha new file mode 100644 index 000000000..7727eb015 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/ensure.ha b/vendor/tree-sitter-hare/example/ensure.ha new file mode 100644 index 000000000..470a10d1f --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/env.ha b/vendor/tree-sitter-hare/example/env.ha new file mode 100644 index 000000000..626711ea7 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/environ.ha b/vendor/tree-sitter-hare/example/environ.ha new file mode 100644 index 000000000..849d3dc04 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/equal.ha b/vendor/tree-sitter-hare/example/equal.ha new file mode 100644 index 000000000..3a9e57355 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/errno.ha b/vendor/tree-sitter-hare/example/errno.ha new file mode 100644 index 000000000..5cc4ffab8 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/errors.ha b/vendor/tree-sitter-hare/example/errors.ha new file mode 100644 index 000000000..0e8d40a07 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/exec+linux.ha b/vendor/tree-sitter-hare/example/exec+linux.ha new file mode 100644 index 000000000..a1b0d7a0c --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/exit.ha b/vendor/tree-sitter-hare/example/exit.ha new file mode 100644 index 000000000..731b503c8 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/expr.ha b/vendor/tree-sitter-hare/example/expr.ha new file mode 100644 index 000000000..1717fcd1b --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/exprclass.ha b/vendor/tree-sitter-hare/example/exprclass.ha new file mode 100644 index 000000000..d210d054a --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/fdstream.ha b/vendor/tree-sitter-hare/example/fdstream.ha new file mode 100644 index 000000000..264c9a949 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/fixed.ha b/vendor/tree-sitter-hare/example/fixed.ha new file mode 100644 index 000000000..ada891977 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/fmt.ha b/vendor/tree-sitter-hare/example/fmt.ha new file mode 100644 index 000000000..16ef5bc2c --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/fnv.ha b/vendor/tree-sitter-hare/example/fnv.ha new file mode 100644 index 000000000..9fcae7599 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/fs.ha b/vendor/tree-sitter-hare/example/fs.ha new file mode 100644 index 000000000..b2448231f --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/ftos.ha b/vendor/tree-sitter-hare/example/ftos.ha new file mode 100644 index 000000000..232510e99 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/functions.ha b/vendor/tree-sitter-hare/example/functions.ha new file mode 100644 index 000000000..15c2f219a --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/getopts.ha b/vendor/tree-sitter-hare/example/getopts.ha new file mode 100644 index 000000000..7d479aa0f --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/getuid.ha b/vendor/tree-sitter-hare/example/getuid.ha new file mode 100644 index 000000000..da0d9ac22 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/hash.ha b/vendor/tree-sitter-hare/example/hash.ha new file mode 100644 index 000000000..48dd1459b --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/hex.ha b/vendor/tree-sitter-hare/example/hex.ha new file mode 100644 index 000000000..d1f7e5a5c --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/host+aarch64.ha b/vendor/tree-sitter-hare/example/host+aarch64.ha new file mode 100644 index 000000000..9bccdb807 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/host+x86_64.ha b/vendor/tree-sitter-hare/example/host+x86_64.ha new file mode 100644 index 000000000..9bccdb807 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/ident.ha b/vendor/tree-sitter-hare/example/ident.ha new file mode 100644 index 000000000..c8cf34b8c --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/import.ha b/vendor/tree-sitter-hare/example/import.ha new file mode 100644 index 000000000..3508a6ff0 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/index.ha b/vendor/tree-sitter-hare/example/index.ha new file mode 100644 index 000000000..3d32e18dc --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/ip.ha b/vendor/tree-sitter-hare/example/ip.ha new file mode 100644 index 000000000..8e907800f --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/iter.ha b/vendor/tree-sitter-hare/example/iter.ha new file mode 100644 index 000000000..7b8aba22f --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/itos.ha b/vendor/tree-sitter-hare/example/itos.ha new file mode 100644 index 000000000..7182f26e6 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/jmp.ha b/vendor/tree-sitter-hare/example/jmp.ha new file mode 100644 index 000000000..30712ecc6 --- /dev/null +++ b/vendor/tree-sitter-hare/example/jmp.ha @@ -0,0 +1 @@ +type arch_jmpbuf = [22]u64; diff --git a/vendor/tree-sitter-hare/example/join.ha b/vendor/tree-sitter-hare/example/join.ha new file mode 100644 index 000000000..432501b2d --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/lex.ha b/vendor/tree-sitter-hare/example/lex.ha new file mode 100644 index 000000000..759e55b73 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/limit.ha b/vendor/tree-sitter-hare/example/limit.ha new file mode 100644 index 000000000..563c01104 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/limits.ha b/vendor/tree-sitter-hare/example/limits.ha new file mode 100644 index 000000000..3fc8d302f --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/little.ha b/vendor/tree-sitter-hare/example/little.ha new file mode 100644 index 000000000..1bf79d838 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/main.ha b/vendor/tree-sitter-hare/example/main.ha new file mode 100644 index 000000000..f66c269ef --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/malloc.ha b/vendor/tree-sitter-hare/example/malloc.ha new file mode 100644 index 000000000..eac4cd2d1 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/manifest.ha b/vendor/tree-sitter-hare/example/manifest.ha new file mode 100644 index 000000000..5912bc26f --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/md5.ha b/vendor/tree-sitter-hare/example/md5.ha new file mode 100644 index 000000000..91c0e0f0e --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/memcpy.ha b/vendor/tree-sitter-hare/example/memcpy.ha new file mode 100644 index 000000000..cd63770bc --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/memset.ha b/vendor/tree-sitter-hare/example/memset.ha new file mode 100644 index 000000000..01b99465f --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/names.ha b/vendor/tree-sitter-hare/example/names.ha new file mode 100644 index 000000000..f2cc50429 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/network.ha b/vendor/tree-sitter-hare/example/network.ha new file mode 100644 index 000000000..bc7143816 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/nice+linux.ha b/vendor/tree-sitter-hare/example/nice+linux.ha new file mode 100644 index 000000000..bcfd38244 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/numeric.ha b/vendor/tree-sitter-hare/example/numeric.ha new file mode 100644 index 000000000..31710546d --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/opaque.ha b/vendor/tree-sitter-hare/example/opaque.ha new file mode 100644 index 000000000..72c7c3ca8 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/open.ha b/vendor/tree-sitter-hare/example/open.ha new file mode 100644 index 000000000..54cdfbc0e --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/ops.ha b/vendor/tree-sitter-hare/example/ops.ha new file mode 100644 index 000000000..d8e3430a6 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/parser.ha b/vendor/tree-sitter-hare/example/parser.ha new file mode 100644 index 000000000..c944fbf69 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/passwd.ha b/vendor/tree-sitter-hare/example/passwd.ha new file mode 100644 index 000000000..2ac95a8ff --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/plan.ha b/vendor/tree-sitter-hare/example/plan.ha new file mode 100644 index 000000000..a34e2d71a --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/platformstart.ha b/vendor/tree-sitter-hare/example/platformstart.ha new file mode 100644 index 000000000..69a1471bc --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/println.ha b/vendor/tree-sitter-hare/example/println.ha new file mode 100644 index 000000000..06374aad9 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/process+linux.ha b/vendor/tree-sitter-hare/example/process+linux.ha new file mode 100644 index 000000000..8f71eb4ef --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/properties.ha b/vendor/tree-sitter-hare/example/properties.ha new file mode 100644 index 000000000..ca6ff8c64 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/random.ha b/vendor/tree-sitter-hare/example/random.ha new file mode 100644 index 000000000..2d0dc1ce4 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/reverse.ha b/vendor/tree-sitter-hare/example/reverse.ha new file mode 100644 index 000000000..2caab57df --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/rt.ha b/vendor/tree-sitter-hare/example/rt.ha new file mode 100644 index 000000000..f73e791ee --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/run.ha b/vendor/tree-sitter-hare/example/run.ha new file mode 100644 index 000000000..b9eed39df --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/rune.ha b/vendor/tree-sitter-hare/example/rune.ha new file mode 100644 index 000000000..f127a3b27 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/scan.ha b/vendor/tree-sitter-hare/example/scan.ha new file mode 100644 index 000000000..78f1d48ef --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/scanner.ha b/vendor/tree-sitter-hare/example/scanner.ha new file mode 100644 index 000000000..251c988dc --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/schedule.ha b/vendor/tree-sitter-hare/example/schedule.ha new file mode 100644 index 000000000..ee5f138ab --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/search.ha b/vendor/tree-sitter-hare/example/search.ha new file mode 100644 index 000000000..1adadd562 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/segmalloc.ha b/vendor/tree-sitter-hare/example/segmalloc.ha new file mode 100644 index 000000000..2017a9f2d --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/setuid.ha b/vendor/tree-sitter-hare/example/setuid.ha new file mode 100644 index 000000000..3b33659d0 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/sha1.ha b/vendor/tree-sitter-hare/example/sha1.ha new file mode 100644 index 000000000..ffb36c842 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/sha256.ha b/vendor/tree-sitter-hare/example/sha256.ha new file mode 100644 index 000000000..a463524b6 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/sha512.ha b/vendor/tree-sitter-hare/example/sha512.ha new file mode 100644 index 000000000..f553b42c6 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/signal.ha b/vendor/tree-sitter-hare/example/signal.ha new file mode 100644 index 000000000..3331b95ed --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/socket.ha b/vendor/tree-sitter-hare/example/socket.ha new file mode 100644 index 000000000..f58dfa3b6 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/sort.ha b/vendor/tree-sitter-hare/example/sort.ha new file mode 100644 index 000000000..3fd613197 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/start+test.ha b/vendor/tree-sitter-hare/example/start+test.ha new file mode 100644 index 000000000..423e247d3 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/start.ha b/vendor/tree-sitter-hare/example/start.ha new file mode 100644 index 000000000..61319e07c --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/stat.ha b/vendor/tree-sitter-hare/example/stat.ha new file mode 100644 index 000000000..6f7ae049c --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/stdfd.ha b/vendor/tree-sitter-hare/example/stdfd.ha new file mode 100644 index 000000000..9eb6fbf5a --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/stoi.ha b/vendor/tree-sitter-hare/example/stoi.ha new file mode 100644 index 000000000..86d296606 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/stou.ha b/vendor/tree-sitter-hare/example/stou.ha new file mode 100644 index 000000000..0b3be895f --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/strcmp.ha b/vendor/tree-sitter-hare/example/strcmp.ha new file mode 100644 index 000000000..25ff287dd --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/stream.ha b/vendor/tree-sitter-hare/example/stream.ha new file mode 100644 index 000000000..034390258 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/string.ha b/vendor/tree-sitter-hare/example/string.ha new file mode 100644 index 000000000..3f4149907 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/sub.ha b/vendor/tree-sitter-hare/example/sub.ha new file mode 100644 index 000000000..ec5ec8614 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/subcmds.ha b/vendor/tree-sitter-hare/example/subcmds.ha new file mode 100644 index 000000000..ff0736715 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/suffix.ha b/vendor/tree-sitter-hare/example/suffix.ha new file mode 100644 index 000000000..d8644548e --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/syscallno+aarch64.ha b/vendor/tree-sitter-hare/example/syscallno+aarch64.ha new file mode 100644 index 000000000..23fab56ea --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/syscallno+x86_64.ha b/vendor/tree-sitter-hare/example/syscallno+x86_64.ha new file mode 100644 index 000000000..e4bea24e9 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/syscalls.ha b/vendor/tree-sitter-hare/example/syscalls.ha new file mode 100644 index 000000000..f62dd4fae --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/tee.ha b/vendor/tree-sitter-hare/example/tee.ha new file mode 100644 index 000000000..1e595eb24 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/token.ha b/vendor/tree-sitter-hare/example/token.ha new file mode 100644 index 000000000..3d3ed46e4 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/tokenize.ha b/vendor/tree-sitter-hare/example/tokenize.ha new file mode 100644 index 000000000..0b2331887 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/type.ha b/vendor/tree-sitter-hare/example/type.ha new file mode 100644 index 000000000..b277feb38 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/types.ha b/vendor/tree-sitter-hare/example/types.ha new file mode 100644 index 000000000..e206c6aa7 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/unicode.ha b/vendor/tree-sitter-hare/example/unicode.ha new file mode 100644 index 000000000..723046ad5 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/unit.ha b/vendor/tree-sitter-hare/example/unit.ha new file mode 100644 index 000000000..aa94f461b --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/utf8.ha b/vendor/tree-sitter-hare/example/utf8.ha new file mode 100644 index 000000000..273a5e9b5 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/util.ha b/vendor/tree-sitter-hare/example/util.ha new file mode 100644 index 000000000..962764b8a --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/utos.ha b/vendor/tree-sitter-hare/example/utos.ha new file mode 100644 index 000000000..0654cfb38 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/uuid.ha b/vendor/tree-sitter-hare/example/uuid.ha new file mode 100644 index 000000000..0a64798e2 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/vdso.ha b/vendor/tree-sitter-hare/example/vdso.ha new file mode 100644 index 000000000..371389194 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/void.ha b/vendor/tree-sitter-hare/example/void.ha new file mode 100644 index 000000000..13841ba69 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/xdg.ha b/vendor/tree-sitter-hare/example/xdg.ha new file mode 100644 index 000000000..29e421eff --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/example/ztos.ha b/vendor/tree-sitter-hare/example/ztos.ha new file mode 100644 index 000000000..4d0ea9f25 --- /dev/null +++ b/vendor/tree-sitter-hare/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/vendor/tree-sitter-hare/grammar.js b/vendor/tree-sitter-hare/grammar.js new file mode 100644 index 000000000..4fd59607e --- /dev/null +++ b/vendor/tree-sitter-hare/grammar.js @@ -0,0 +1,725 @@ +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', + field('name', $.identifier), field('type', $.prototype), + optional(seq('=', field('body', $.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', + 'str', + '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('"', optional($.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, field('selector', seq('.', $.name))), + seq($.postfix_expression, field('selector', seq('.', $.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/vendor/tree-sitter-hare/package.json b/vendor/tree-sitter-hare/package.json new file mode 100644 index 000000000..3ca75d25c --- /dev/null +++ b/vendor/tree-sitter-hare/package.json @@ -0,0 +1,35 @@ +{ + "name": "tree-sitter-hare", + "version": "0.0.1", + "description": "Hare grammar for tree-sitter", + "main": "bindings/node", + + "keywords": [ + "parser", + "hare" + ], + + "author": "ecmma", + "license": "GNU GPL", + + "dependencies": { + "nan": "^2.14.1" + }, + "devDependencies": { + "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" + ] + } + ] +} diff --git a/vendor/tree-sitter-hare/queries/highlights.scm b/vendor/tree-sitter-hare/queries/highlights.scm new file mode 100644 index 000000000..066273481 --- /dev/null +++ b/vendor/tree-sitter-hare/queries/highlights.scm @@ -0,0 +1,117 @@ +"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 +"{" @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/vendor/tree-sitter-hare/queries/indents.scm b/vendor/tree-sitter-hare/queries/indents.scm new file mode 100644 index 000000000..86ffc4782 --- /dev/null +++ b/vendor/tree-sitter-hare/queries/indents.scm @@ -0,0 +1,14 @@ +[ + (struct_union_fields) + (expression_list) +] @indent + + +[ + "{" + "}" +] @branch + +[ + (comment) +] @ignore diff --git a/vendor/tree-sitter-hare/queries/locals.scm b/vendor/tree-sitter-hare/queries/locals.scm new file mode 100644 index 000000000..d10a57166 --- /dev/null +++ b/vendor/tree-sitter-hare/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 diff --git a/vendor/tree-sitter-hare/src/grammar.json b/vendor/tree-sitter-hare/src/grammar.json new file mode 100644 index 000000000..135aa03ae --- /dev/null +++ b/vendor/tree-sitter-hare/src/grammar.json @@ -0,0 +1,5113 @@ +{ + "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": "FIELD", + "name": "name", + "content": { + "type": "SYMBOL", + "name": "identifier" + } + }, + { + "type": "FIELD", + "name": "type", + "content": { + "type": "SYMBOL", + "name": "prototype" + } + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "=" + }, + { + "type": "FIELD", + "name": "body", + "content": { + "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": "str" + }, + { + "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": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "string_chars" + }, + { + "type": "BLANK" + } + ] + }, + { + "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": "FIELD", + "name": "selector", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "." + }, + { + "type": "SYMBOL", + "name": "name" + } + ] + } + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "postfix_expression" + }, + { + "type": "FIELD", + "name": "selector", + "content": { + "type": "SEQ", + "members": [ + { + "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/vendor/tree-sitter-hare/src/node-types.json b/vendor/tree-sitter-hare/src/node-types.json new file mode 100644 index 000000000..acee8589a --- /dev/null +++ b/vendor/tree-sitter-hare/src/node-types.json @@ -0,0 +1,3093 @@ +[ + { + "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": { + "selector": { + "multiple": true, + "required": true, + "types": [ + { + "type": ".", + "named": false + }, + { + "type": "integer_constant", + "named": true + }, + { + "type": "name", + "named": true + } + ] + } + }, + "children": { + "multiple": false, + "required": true, + "types": [ + { + "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": { + "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": false, + "required": false, + "types": [ + { + "type": "fndec_attrs", + "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": false, + "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": "str", + "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/vendor/tree-sitter-hare/src/parser.c b/vendor/tree-sitter-hare/src/parser.c new file mode 100644 index 000000000..c44ff50e4 --- /dev/null +++ b/vendor/tree-sitter-hare/src/parser.c @@ -0,0 +1,38099 @@ +#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 822 +#define LARGE_STATE_COUNT 140 +#define SYMBOL_COUNT 284 +#define ALIAS_COUNT 0 +#define TOKEN_COUNT 145 +#define EXTERNAL_TOKEN_COUNT 0 +#define FIELD_COUNT 12 +#define MAX_ALIAS_SEQUENCE_LENGTH 7 +#define PRODUCTION_ID_COUNT 13 + +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_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[] = { + [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_str] = "str", + [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_str] = anon_sym_str, + [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_str] = { + .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_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[] = { + [0] = NULL, + [field_address] = "address", + [field_afterthought] = "afterthought", + [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", +}; + +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 = 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}, + [9] = + {field_address, 0}, + {field_argument, 1}, + [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}, + [19] = + {field_as_cast, 0}, + {field_as_cast, 1}, + {field_as_cast, 2}, + [22] = + {field_is_cast, 0}, + {field_is_cast, 1}, + {field_is_cast, 2}, + [25] = + {field_binding, 0}, + [26] = + {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(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(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); + if (lookahead == 'o') ADVANCE(122); + if (lookahead == 'r') ADVANCE(111); + if (lookahead == 's') ADVANCE(130); + if (lookahead == 't') ADVANCE(177); + if (lookahead == 'u') ADVANCE(360); + if (lookahead == 'v') ADVANCE(165); + 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' || + 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(45) + END_STATE(); + case 12: + if (lookahead == '\n') SKIP(45) + if (lookahead == '\r') SKIP(11) + END_STATE(); + case 13: + if (lookahead == '\n') SKIP(56) + END_STATE(); + case 14: + if (lookahead == '\n') SKIP(56) + 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(371); + if (lookahead == '/') ADVANCE(373); + if (lookahead == '\\') ADVANCE(368); + if (lookahead == '\t' || + lookahead == '\r' || + lookahead == ' ') ADVANCE(372); + if (lookahead != 0) ADVANCE(372); + 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(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(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' || + lookahead == ' ') SKIP(44) + END_STATE(); + case 45: + if (lookahead == '!') ADVANCE(84); + 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(12) + 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' || + lookahead == ' ') SKIP(45) + END_STATE(); + case 46: + if (lookahead == '!') ADVANCE(84); + 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(317); + if (lookahead == '^') ADVANCE(411); + if (lookahead == 'a') ADVANCE(184); + if (lookahead == 'e') ADVANCE(353); + if (lookahead == 'f') ADVANCE(77); + 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' || + lookahead == ' ') SKIP(46) + END_STATE(); + case 47: + if (lookahead == '!') ADVANCE(84); + 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(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(317); + 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(47) + END_STATE(); + case 48: + if (lookahead == '!') ADVANCE(84); + 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(416); + if (lookahead == '?') ADVANCE(392); + if (lookahead == '[') ADVANCE(316); + if (lookahead == '\\') SKIP(43) + if (lookahead == ']') ADVANCE(317); + if (lookahead == '^') ADVANCE(412); + if (lookahead == 'a') ADVANCE(184); + if (lookahead == 'e') ADVANCE(353); + if (lookahead == 'f') ADVANCE(77); + 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' || + lookahead == ' ') SKIP(48) + END_STATE(); + case 49: + if (lookahead == '!') ADVANCE(84); + 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(317); + if (lookahead == '^') ADVANCE(412); + if (lookahead == 'a') ADVANCE(184); + if (lookahead == 'e') ADVANCE(140); + if (lookahead == 'i') ADVANCE(185); + if (lookahead == '|') ADVANCE(315); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(49) + END_STATE(); + case 50: + 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(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(316); + if (lookahead == '\\') SKIP(2) + 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(588); + END_STATE(); + case 51: + 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(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(316); + if (lookahead == '\\') SKIP(4) + 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(588); + END_STATE(); + case 52: + 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(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(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(588); + END_STATE(); + case 53: + 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(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(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(588); + END_STATE(); + case 54: + 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(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(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(588); + END_STATE(); + case 55: + 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(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(316); + if (lookahead == '\\') SKIP(16) + 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(588); + END_STATE(); + case 56: + 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(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(14) + 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(588); + END_STATE(); + case 57: + if (lookahead == '"') ADVANCE(371); + if (lookahead == '/') ADVANCE(66); + if (lookahead == '\\') ADVANCE(368); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(57) + END_STATE(); + case 58: + 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(316); + if (lookahead == '\\') SKIP(22) + 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(588); + END_STATE(); + case 59: + if (lookahead == '(') ADVANCE(253); + if (lookahead == '*') ADVANCE(305); + if (lookahead == '.') ADVANCE(64); + if (lookahead == '/') ADVANCE(66); + if (lookahead == '@') ADVANCE(154); + if (lookahead == '[') ADVANCE(316); + if (lookahead == '\\') SKIP(24) + 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(588); + END_STATE(); + case 60: + if (lookahead == ')') ADVANCE(254); + if (lookahead == '.') ADVANCE(64); + if (lookahead == '/') ADVANCE(66); + if (lookahead == '\\') SKIP(37) + if (lookahead == '_') ADVANCE(319); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(60) + if (('A' <= lookahead && lookahead <= 'Z') || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 61: + if (lookahead == '.') ADVANCE(391); + END_STATE(); + case 62: + if (lookahead == '.') ADVANCE(320); + END_STATE(); + case 63: + if (lookahead == '.') ADVANCE(390); + 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(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(588); + END_STATE(); + case 66: + if (lookahead == '/') ADVANCE(589); + END_STATE(); + case 67: + if (lookahead == '/') ADVANCE(66); + 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(243); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(67) + if (('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('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(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(588); + 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(367); + if (lookahead == '\\') ADVANCE(368); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') ADVANCE(366); + if (lookahead != 0 && + 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(273); + if (lookahead == 'n') ADVANCE(194); + 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(281); + if (lookahead == 'i') ADVANCE(158); + if (lookahead == 's') ADVANCE(100); + END_STATE(); + case 74: + if (lookahead == '2') ADVANCE(277); + END_STATE(); + case 75: + if (lookahead == '2') ADVANCE(285); + END_STATE(); + case 76: + if (lookahead == '2') ADVANCE(299); + 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(257); + if (lookahead == 'o') ADVANCE(174); + END_STATE(); + case 79: + if (lookahead == '4') ADVANCE(279); + END_STATE(); + case 80: + if (lookahead == '4') ADVANCE(287); + END_STATE(); + case 81: + if (lookahead == '4') ADVANCE(301); + END_STATE(); + case 82: + if (lookahead == '6') ADVANCE(275); + END_STATE(); + case 83: + if (lookahead == '6') ADVANCE(283); + END_STATE(); + case 84: + if (lookahead == '=') ADVANCE(420); + END_STATE(); + case 85: + if (lookahead == '=') ADVANCE(419); + if (lookahead == '>') ADVANCE(432); + END_STATE(); + case 86: + if (lookahead == '>') ADVANCE(432); + 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(267); + 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(374); + END_STATE(); + case 94: + if (lookahead == 'c') ADVANCE(383); + 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(271); + END_STATE(); + case 98: + if (lookahead == 'd') ADVANCE(376); + END_STATE(); + case 99: + if (lookahead == 'e') ADVANCE(150); + END_STATE(); + case 100: + if (lookahead == 'e') ADVANCE(236); + END_STATE(); + case 101: + if (lookahead == 'e') ADVANCE(426); + END_STATE(); + case 102: + if (lookahead == 'e') ADVANCE(378); + END_STATE(); + case 103: + if (lookahead == 'e') ADVANCE(265); + END_STATE(); + case 104: + if (lookahead == 'e') ADVANCE(293); + END_STATE(); + case 105: + if (lookahead == 'e') ADVANCE(321); + END_STATE(); + case 106: + if (lookahead == 'e') ADVANCE(256); + END_STATE(); + case 107: + if (lookahead == 'e') ADVANCE(448); + 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(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(217); + if (lookahead == 't') ADVANCE(108); + END_STATE(); + case 121: + if (lookahead == 'f') ADVANCE(255); + 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(433); + END_STATE(); + case 127: + 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(219); + END_STATE(); + case 130: + if (lookahead == 'i') ADVANCE(219); + 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(259); + 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(446); + 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(269); + END_STATE(); + case 143: + if (lookahead == 'l') ADVANCE(324); + END_STATE(); + case 144: + if (lookahead == 'l') ADVANCE(252); + 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(303); + END_STATE(); + case 149: + if (lookahead == 'n') ADVANCE(189); + END_STATE(); + case 150: + if (lookahead == 'n') ADVANCE(386); + if (lookahead == 't') ADVANCE(246); + END_STATE(); + case 151: + if (lookahead == 'n') ADVANCE(310); + END_STATE(); + case 152: + if (lookahead == 'n') ADVANCE(450); + END_STATE(); + case 153: + if (lookahead == 'n') ADVANCE(262); + 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(215); + 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(428); + END_STATE(); + case 175: + if (lookahead == 'r') ADVANCE(297); + END_STATE(); + case 176: + if (lookahead == 'r') ADVANCE(295); + END_STATE(); + case 177: + if (lookahead == 'r') ADVANCE(214); + 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(217); + END_STATE(); + case 184: + if (lookahead == 's') ADVANCE(401); + END_STATE(); + case 185: + if (lookahead == 's') ADVANCE(402); + 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(289); + END_STATE(); + case 195: + if (lookahead == 't') ADVANCE(246); + END_STATE(); + case 196: + if (lookahead == 't') ADVANCE(92); + END_STATE(); + case 197: + if (lookahead == 't') ADVANCE(260); + END_STATE(); + case 198: + if (lookahead == 't') ADVANCE(261); + END_STATE(); + case 199: + if (lookahead == 't') ADVANCE(248); + END_STATE(); + case 200: + if (lookahead == 't') ADVANCE(245); + END_STATE(); + case 201: + if (lookahead == 't') ADVANCE(388); + END_STATE(); + case 202: + if (lookahead == 't') ADVANCE(308); + END_STATE(); + case 203: + if (lookahead == 't') ADVANCE(312); + END_STATE(); + case 204: + if (lookahead == 't') ADVANCE(292); + END_STATE(); + case 205: + if (lookahead == 't') ADVANCE(381); + END_STATE(); + case 206: + if (lookahead == 't') ADVANCE(213); + 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(216); + 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(178); + END_STATE(); + case 214: + if (lookahead == 'u') ADVANCE(105); + END_STATE(); + case 215: + if (lookahead == 'u') ADVANCE(107); + END_STATE(); + case 216: + if (lookahead == 'u') ADVANCE(179); + END_STATE(); + case 217: + if (lookahead == 'y') ADVANCE(147); + END_STATE(); + case 218: + if (lookahead == 'y') ADVANCE(172); + END_STATE(); + case 219: + if (lookahead == 'z') ADVANCE(104); + END_STATE(); + case 220: + if (aux_sym_named_escape_token1_character_set_1(lookahead)) ADVANCE(370); + if (lookahead == '/') ADVANCE(66); + 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(221); + 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 (lookahead != 0 && + lookahead != '\r') ADVANCE(589); + if (lookahead == '\r') ADVANCE(590); + END_STATE(); + case 230: + if (eof) ADVANCE(235); + if (lookahead == '\n') SKIP(0) + END_STATE(); + case 231: + if (eof) ADVANCE(235); + if (lookahead == '\n') SKIP(0) + if (lookahead == '\r') SKIP(230) + END_STATE(); + case 232: + if (eof) ADVANCE(235); + if (lookahead == '\n') SKIP(234) + END_STATE(); + case 233: + if (eof) ADVANCE(235); + if (lookahead == '\n') SKIP(234) + if (lookahead == '\r') SKIP(232) + END_STATE(); + case 234: + if (eof) ADVANCE(235); + if (lookahead == '!') ADVANCE(84); + 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(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); + 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(218); + if (lookahead == 'u') ADVANCE(73); + if (lookahead == '{') ADVANCE(242); + if (lookahead == '|') ADVANCE(314); + if (lookahead == '}') ADVANCE(243); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(234) + END_STATE(); + case 235: + ACCEPT_TOKEN(ts_builtin_sym_end); + END_STATE(); + case 236: + ACCEPT_TOKEN(anon_sym_use); + END_STATE(); + 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(419); + if (lookahead == '>') ADVANCE(432); + END_STATE(); + case 240: + ACCEPT_TOKEN(anon_sym_EQ); + if (lookahead == '>') ADVANCE(432); + END_STATE(); + case 241: + ACCEPT_TOKEN(anon_sym_COLON_COLON); + END_STATE(); + case 242: + ACCEPT_TOKEN(anon_sym_LBRACE); + END_STATE(); + case 243: + ACCEPT_TOKEN(anon_sym_RBRACE); + END_STATE(); + case 244: + ACCEPT_TOKEN(anon_sym_COMMA); + END_STATE(); + case 245: + ACCEPT_TOKEN(anon_sym_export); + END_STATE(); + case 246: + ACCEPT_TOKEN(anon_sym_let); + END_STATE(); + case 247: + ACCEPT_TOKEN(anon_sym_let); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 248: + ACCEPT_TOKEN(anon_sym_const); + END_STATE(); + case 249: + ACCEPT_TOKEN(anon_sym_const); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 250: + ACCEPT_TOKEN(anon_sym_COLON); + END_STATE(); + case 251: + ACCEPT_TOKEN(anon_sym_COLON); + if (lookahead == ':') ADVANCE(241); + END_STATE(); + case 252: + ACCEPT_TOKEN(anon_sym_ATsymbol); + END_STATE(); + case 253: + ACCEPT_TOKEN(anon_sym_LPAREN); + END_STATE(); + case 254: + ACCEPT_TOKEN(anon_sym_RPAREN); + END_STATE(); + case 255: + ACCEPT_TOKEN(anon_sym_def); + END_STATE(); + case 256: + ACCEPT_TOKEN(anon_sym_type); + END_STATE(); + case 257: + ACCEPT_TOKEN(anon_sym_fn); + END_STATE(); + case 258: + ACCEPT_TOKEN(anon_sym_fn); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 259: + ACCEPT_TOKEN(anon_sym_ATfini); + END_STATE(); + case 260: + ACCEPT_TOKEN(anon_sym_ATinit); + END_STATE(); + case 261: + ACCEPT_TOKEN(anon_sym_ATtest); + END_STATE(); + 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_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_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(588); + END_STATE(); + case 269: + ACCEPT_TOKEN(anon_sym_bool); + END_STATE(); + case 270: + ACCEPT_TOKEN(anon_sym_bool); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 271: + ACCEPT_TOKEN(anon_sym_void); + END_STATE(); + case 272: + ACCEPT_TOKEN(anon_sym_void); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 273: + ACCEPT_TOKEN(anon_sym_i8); + END_STATE(); + case 274: + ACCEPT_TOKEN(anon_sym_i8); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 275: + ACCEPT_TOKEN(anon_sym_i16); + END_STATE(); + case 276: + ACCEPT_TOKEN(anon_sym_i16); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 277: + ACCEPT_TOKEN(anon_sym_i32); + END_STATE(); + case 278: + ACCEPT_TOKEN(anon_sym_i32); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 279: + ACCEPT_TOKEN(anon_sym_i64); + END_STATE(); + case 280: + ACCEPT_TOKEN(anon_sym_i64); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 281: + ACCEPT_TOKEN(anon_sym_u8); + END_STATE(); + case 282: + ACCEPT_TOKEN(anon_sym_u8); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 283: + ACCEPT_TOKEN(anon_sym_u16); + END_STATE(); + case 284: + ACCEPT_TOKEN(anon_sym_u16); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 285: + ACCEPT_TOKEN(anon_sym_u32); + END_STATE(); + case 286: + ACCEPT_TOKEN(anon_sym_u32); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 287: + ACCEPT_TOKEN(anon_sym_u64); + END_STATE(); + case 288: + ACCEPT_TOKEN(anon_sym_u64); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 289: + ACCEPT_TOKEN(anon_sym_int); + END_STATE(); + case 290: + ACCEPT_TOKEN(anon_sym_int); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 291: + ACCEPT_TOKEN(anon_sym_uint); + if (lookahead == 'p') ADVANCE(575); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 292: + ACCEPT_TOKEN(anon_sym_uint); + if (lookahead == 'p') ADVANCE(208); + END_STATE(); + case 293: + ACCEPT_TOKEN(anon_sym_size); + END_STATE(); + case 294: + ACCEPT_TOKEN(anon_sym_size); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 295: + ACCEPT_TOKEN(anon_sym_uintptr); + END_STATE(); + case 296: + ACCEPT_TOKEN(anon_sym_uintptr); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 297: + ACCEPT_TOKEN(anon_sym_char); + END_STATE(); + case 298: + ACCEPT_TOKEN(anon_sym_char); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 299: + ACCEPT_TOKEN(anon_sym_f32); + END_STATE(); + case 300: + ACCEPT_TOKEN(anon_sym_f32); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 301: + ACCEPT_TOKEN(anon_sym_f64); + END_STATE(); + case 302: + ACCEPT_TOKEN(anon_sym_f64); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 303: + ACCEPT_TOKEN(anon_sym_enum); + END_STATE(); + case 304: + ACCEPT_TOKEN(anon_sym_enum); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 305: + ACCEPT_TOKEN(anon_sym_STAR); + 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(588); + END_STATE(); + case 308: + ACCEPT_TOKEN(anon_sym_struct); + END_STATE(); + case 309: + ACCEPT_TOKEN(anon_sym_struct); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 310: + ACCEPT_TOKEN(anon_sym_union); + END_STATE(); + case 311: + ACCEPT_TOKEN(anon_sym_union); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 312: + ACCEPT_TOKEN(anon_sym_AToffset); + END_STATE(); + case 313: + ACCEPT_TOKEN(anon_sym_PIPE); + END_STATE(); + case 314: + ACCEPT_TOKEN(anon_sym_PIPE); + if (lookahead == '=') ADVANCE(443); + if (lookahead == '|') ADVANCE(423); + END_STATE(); + case 315: + ACCEPT_TOKEN(anon_sym_PIPE); + if (lookahead == '|') ADVANCE(423); + END_STATE(); + case 316: + ACCEPT_TOKEN(anon_sym_LBRACK); + END_STATE(); + case 317: + 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(588); + END_STATE(); + case 320: + ACCEPT_TOKEN(anon_sym_DOT_DOT_DOT); + END_STATE(); + case 321: + ACCEPT_TOKEN(anon_sym_true); + END_STATE(); + case 322: + ACCEPT_TOKEN(anon_sym_true); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 323: + ACCEPT_TOKEN(anon_sym_false); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 324: + ACCEPT_TOKEN(anon_sym_null); + END_STATE(); + case 325: + ACCEPT_TOKEN(anon_sym_null); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 326: + ACCEPT_TOKEN(anon_sym_0x); + END_STATE(); + case 327: + ACCEPT_TOKEN(anon_sym_0o); + END_STATE(); + case 328: + ACCEPT_TOKEN(anon_sym_0b); + END_STATE(); + case 329: + ACCEPT_TOKEN(anon_sym_0); + END_STATE(); + case 330: + 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_1); + END_STATE(); + case 332: + ACCEPT_TOKEN(anon_sym_2); + END_STATE(); + case 333: + ACCEPT_TOKEN(anon_sym_3); + END_STATE(); + case 334: + ACCEPT_TOKEN(anon_sym_4); + END_STATE(); + case 335: + ACCEPT_TOKEN(anon_sym_5); + END_STATE(); + case 336: + ACCEPT_TOKEN(anon_sym_6); + END_STATE(); + case 337: + ACCEPT_TOKEN(anon_sym_7); + END_STATE(); + case 338: + ACCEPT_TOKEN(anon_sym_8); + END_STATE(); + case 339: + ACCEPT_TOKEN(anon_sym_9); + END_STATE(); + case 340: + ACCEPT_TOKEN(anon_sym_A); + END_STATE(); + case 341: + ACCEPT_TOKEN(anon_sym_B); + END_STATE(); + case 342: + ACCEPT_TOKEN(anon_sym_C); + END_STATE(); + case 343: + ACCEPT_TOKEN(anon_sym_D); + END_STATE(); + case 344: + 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(401); + END_STATE(); + case 347: + ACCEPT_TOKEN(anon_sym_a); + if (lookahead == 's') ADVANCE(401); + END_STATE(); + case 348: + ACCEPT_TOKEN(anon_sym_b); + END_STATE(); + case 349: + ACCEPT_TOKEN(anon_sym_b); + if (lookahead == 'o') ADVANCE(164); + if (lookahead == 'r') ADVANCE(109); + END_STATE(); + case 350: + ACCEPT_TOKEN(anon_sym_c); + END_STATE(); + case 351: + ACCEPT_TOKEN(anon_sym_c); + if (lookahead == 'h') ADVANCE(89); + if (lookahead == 'o') ADVANCE(149); + END_STATE(); + case 352: + ACCEPT_TOKEN(anon_sym_d); + END_STATE(); + case 353: + ACCEPT_TOKEN(anon_sym_e); + if (lookahead == 'l') ADVANCE(187); + END_STATE(); + 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 355: + ACCEPT_TOKEN(anon_sym_f); + END_STATE(); + case 356: + ACCEPT_TOKEN(anon_sym_f); + if (lookahead == 'n') ADVANCE(257); + if (lookahead == 'o') ADVANCE(174); + if (lookahead == 'r') ADVANCE(113); + 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(273); + if (lookahead == 'f') ADVANCE(424); + if (lookahead == 'n') ADVANCE(194); + if (lookahead == 's') ADVANCE(402); + END_STATE(); + 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(273); + if (lookahead == 's') ADVANCE(402); + 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(281); + END_STATE(); + 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(281); + if (lookahead == 'n') ADVANCE(134); + if (lookahead == 's') ADVANCE(100); + END_STATE(); + case 361: + ACCEPT_TOKEN(anon_sym_z); + END_STATE(); + case 362: + ACCEPT_TOKEN(anon_sym_DOT); + if (lookahead == '.') ADVANCE(391); + END_STATE(); + case 363: + ACCEPT_TOKEN(anon_sym_DOT); + if (lookahead == '.') ADVANCE(390); + END_STATE(); + case 364: + ACCEPT_TOKEN(anon_sym_DOT); + if (lookahead == '.') ADVANCE(62); + END_STATE(); + case 365: + ACCEPT_TOKEN(anon_sym_SQUOTE); + END_STATE(); + case 366: + ACCEPT_TOKEN(aux_sym_rune_token1); + END_STATE(); + case 367: + ACCEPT_TOKEN(aux_sym_rune_token1); + if (lookahead == '/') ADVANCE(589); + END_STATE(); + case 368: + ACCEPT_TOKEN(anon_sym_BSLASH); + END_STATE(); + case 369: + ACCEPT_TOKEN(aux_sym_escape_sequence_token1); + END_STATE(); + case 370: + ACCEPT_TOKEN(aux_sym_named_escape_token1); + END_STATE(); + case 371: + ACCEPT_TOKEN(anon_sym_DQUOTE); + END_STATE(); + case 372: + ACCEPT_TOKEN(aux_sym_string_char_token1); + END_STATE(); + case 373: + 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(588); + END_STATE(); + case 376: + ACCEPT_TOKEN(anon_sym_append); + END_STATE(); + case 377: + ACCEPT_TOKEN(anon_sym_append); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 378: + ACCEPT_TOKEN(anon_sym_free); + END_STATE(); + case 379: + ACCEPT_TOKEN(anon_sym_free); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 380: + ACCEPT_TOKEN(anon_sym_delete); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 381: + ACCEPT_TOKEN(anon_sym_assert); + END_STATE(); + case 382: + ACCEPT_TOKEN(anon_sym_assert); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 383: + ACCEPT_TOKEN(anon_sym_static); + END_STATE(); + case 384: + ACCEPT_TOKEN(anon_sym_static); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 385: + ACCEPT_TOKEN(anon_sym_abort); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 386: + ACCEPT_TOKEN(anon_sym_len); + END_STATE(); + case 387: + ACCEPT_TOKEN(anon_sym_len); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 388: + ACCEPT_TOKEN(anon_sym_offset); + END_STATE(); + case 389: + ACCEPT_TOKEN(anon_sym_offset); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 390: + ACCEPT_TOKEN(anon_sym_DOT_DOT); + END_STATE(); + case 391: + ACCEPT_TOKEN(anon_sym_DOT_DOT); + if (lookahead == '.') ADVANCE(320); + END_STATE(); + case 392: + ACCEPT_TOKEN(anon_sym_QMARK); + END_STATE(); + case 393: + ACCEPT_TOKEN(anon_sym_PLUS); + END_STATE(); + case 394: + ACCEPT_TOKEN(anon_sym_PLUS); + if (lookahead == '=') ADVANCE(435); + END_STATE(); + case 395: + ACCEPT_TOKEN(anon_sym_DASH); + END_STATE(); + case 396: + ACCEPT_TOKEN(anon_sym_DASH); + if (lookahead == '=') ADVANCE(436); + END_STATE(); + case 397: + ACCEPT_TOKEN(anon_sym_TILDE); + END_STATE(); + case 398: + ACCEPT_TOKEN(anon_sym_AMP); + END_STATE(); + case 399: + ACCEPT_TOKEN(anon_sym_AMP); + if (lookahead == '&') ADVANCE(421); + END_STATE(); + case 400: + ACCEPT_TOKEN(anon_sym_AMP); + if (lookahead == '&') ADVANCE(421); + if (lookahead == '=') ADVANCE(442); + END_STATE(); + case 401: + ACCEPT_TOKEN(anon_sym_as); + END_STATE(); + case 402: + ACCEPT_TOKEN(anon_sym_is); + END_STATE(); + case 403: + ACCEPT_TOKEN(anon_sym_SLASH); + if (lookahead == '/') ADVANCE(589); + END_STATE(); + case 404: + ACCEPT_TOKEN(anon_sym_SLASH); + if (lookahead == '/') ADVANCE(589); + if (lookahead == '=') ADVANCE(438); + END_STATE(); + case 405: + ACCEPT_TOKEN(anon_sym_PERCENT); + END_STATE(); + case 406: + ACCEPT_TOKEN(anon_sym_PERCENT); + if (lookahead == '=') ADVANCE(439); + END_STATE(); + case 407: + ACCEPT_TOKEN(anon_sym_LT_LT); + END_STATE(); + case 408: + ACCEPT_TOKEN(anon_sym_LT_LT); + if (lookahead == '=') ADVANCE(440); + END_STATE(); + case 409: + ACCEPT_TOKEN(anon_sym_GT_GT); + END_STATE(); + case 410: + ACCEPT_TOKEN(anon_sym_GT_GT); + if (lookahead == '=') ADVANCE(441); + END_STATE(); + case 411: + ACCEPT_TOKEN(anon_sym_CARET); + if (lookahead == '=') ADVANCE(444); + if (lookahead == '^') ADVANCE(422); + END_STATE(); + case 412: + ACCEPT_TOKEN(anon_sym_CARET); + if (lookahead == '^') ADVANCE(422); + END_STATE(); + case 413: + ACCEPT_TOKEN(anon_sym_LT); + if (lookahead == '<') ADVANCE(408); + if (lookahead == '=') ADVANCE(417); + END_STATE(); + case 414: + ACCEPT_TOKEN(anon_sym_LT); + if (lookahead == '<') ADVANCE(407); + if (lookahead == '=') ADVANCE(417); + END_STATE(); + case 415: + ACCEPT_TOKEN(anon_sym_GT); + if (lookahead == '=') ADVANCE(418); + if (lookahead == '>') ADVANCE(410); + END_STATE(); + case 416: + ACCEPT_TOKEN(anon_sym_GT); + if (lookahead == '=') ADVANCE(418); + if (lookahead == '>') ADVANCE(409); + END_STATE(); + case 417: + ACCEPT_TOKEN(anon_sym_LT_EQ); + END_STATE(); + case 418: + ACCEPT_TOKEN(anon_sym_GT_EQ); + END_STATE(); + case 419: + ACCEPT_TOKEN(anon_sym_EQ_EQ); + END_STATE(); + case 420: + ACCEPT_TOKEN(anon_sym_BANG_EQ); + END_STATE(); + case 421: + ACCEPT_TOKEN(anon_sym_AMP_AMP); + END_STATE(); + case 422: + ACCEPT_TOKEN(anon_sym_CARET_CARET); + END_STATE(); + case 423: + 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(588); + END_STATE(); + case 426: + ACCEPT_TOKEN(anon_sym_else); + END_STATE(); + case 427: + ACCEPT_TOKEN(anon_sym_else); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 428: + ACCEPT_TOKEN(anon_sym_for); + END_STATE(); + case 429: + ACCEPT_TOKEN(anon_sym_for); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 430: + ACCEPT_TOKEN(anon_sym_switch); + END_STATE(); + case 431: + ACCEPT_TOKEN(anon_sym_switch); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 432: + ACCEPT_TOKEN(anon_sym_EQ_GT); + END_STATE(); + case 433: + ACCEPT_TOKEN(anon_sym_match); + END_STATE(); + case 434: + ACCEPT_TOKEN(anon_sym_match); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 435: + ACCEPT_TOKEN(anon_sym_PLUS_EQ); + END_STATE(); + case 436: + ACCEPT_TOKEN(anon_sym_DASH_EQ); + END_STATE(); + case 437: + ACCEPT_TOKEN(anon_sym_STAR_EQ); + END_STATE(); + case 438: + ACCEPT_TOKEN(anon_sym_SLASH_EQ); + END_STATE(); + case 439: + ACCEPT_TOKEN(anon_sym_PERCENT_EQ); + END_STATE(); + case 440: + ACCEPT_TOKEN(anon_sym_LT_LT_EQ); + END_STATE(); + case 441: + ACCEPT_TOKEN(anon_sym_GT_GT_EQ); + END_STATE(); + case 442: + ACCEPT_TOKEN(anon_sym_AMP_EQ); + END_STATE(); + case 443: + ACCEPT_TOKEN(anon_sym_PIPE_EQ); + END_STATE(); + case 444: + ACCEPT_TOKEN(anon_sym_CARET_EQ); + END_STATE(); + case 445: + ACCEPT_TOKEN(anon_sym_defer); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 446: + ACCEPT_TOKEN(anon_sym_break); + END_STATE(); + case 447: + ACCEPT_TOKEN(anon_sym_break); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 448: + ACCEPT_TOKEN(anon_sym_continue); + END_STATE(); + case 449: + ACCEPT_TOKEN(anon_sym_continue); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 450: + ACCEPT_TOKEN(anon_sym_return); + END_STATE(); + case 451: + ACCEPT_TOKEN(anon_sym_return); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('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(274); + if (lookahead == 'n') ADVANCE(571); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 453: + ACCEPT_TOKEN(sym_name); + 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(588); + END_STATE(); + case 454: + ACCEPT_TOKEN(sym_name); + if (lookahead == '2') ADVANCE(300); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 455: + ACCEPT_TOKEN(sym_name); + if (lookahead == '2') ADVANCE(278); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 456: + ACCEPT_TOKEN(sym_name); + if (lookahead == '2') ADVANCE(286); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 457: + ACCEPT_TOKEN(sym_name); + 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(588); + END_STATE(); + case 458: + ACCEPT_TOKEN(sym_name); + if (lookahead == '4') ADVANCE(302); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 459: + ACCEPT_TOKEN(sym_name); + if (lookahead == '4') ADVANCE(280); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 460: + ACCEPT_TOKEN(sym_name); + if (lookahead == '4') ADVANCE(288); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 461: + ACCEPT_TOKEN(sym_name); + if (lookahead == '6') ADVANCE(276); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 462: + ACCEPT_TOKEN(sym_name); + if (lookahead == '6') ADVANCE(284); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 463: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'a') ADVANCE(565); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 464: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'a') ADVANCE(516); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 465: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'a') ADVANCE(471); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 466: + ACCEPT_TOKEN(sym_name); + 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(588); + END_STATE(); + case 467: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'a') ADVANCE(551); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 468: + ACCEPT_TOKEN(sym_name); + 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(588); + END_STATE(); + case 469: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'a') ADVANCE(526); + if (lookahead == 'r') ADVANCE(498); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('b' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 470: + ACCEPT_TOKEN(sym_name); + 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(588); + END_STATE(); + case 471: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'b') ADVANCE(524); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 472: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'c') ADVANCE(504); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 473: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'c') ADVANCE(375); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 474: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'c') ADVANCE(384); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 475: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'c') ADVANCE(505); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 476: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'c') ADVANCE(570); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 477: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'd') ADVANCE(272); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 478: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'd') ADVANCE(377); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 479: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'e') ADVANCE(502); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 480: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'e') ADVANCE(529); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 481: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'e') ADVANCE(427); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 482: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'e') ADVANCE(379); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 483: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'e') ADVANCE(294); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + 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(588); + END_STATE(); + case 485: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'e') ADVANCE(323); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 486: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'e') ADVANCE(380); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 487: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'e') ADVANCE(449); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 488: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'e') ADVANCE(266); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 489: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'e') ADVANCE(307); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 490: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'e') ADVANCE(464); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 491: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'e') ADVANCE(534); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 492: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'e') ADVANCE(573); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 493: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'e') ADVANCE(549); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 494: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'e') ADVANCE(523); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 495: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'e') ADVANCE(530); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 496: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'e') ADVANCE(576); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 497: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'e') ADVANCE(569); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 498: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'e') ADVANCE(482); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 499: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'e') ADVANCE(558); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 500: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'f') ADVANCE(425); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 501: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'f') ADVANCE(503); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 502: + ACCEPT_TOKEN(sym_name); + 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(588); + END_STATE(); + case 503: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'f') ADVANCE(564); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 504: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'h') ADVANCE(434); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 505: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'h') ADVANCE(431); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 506: + ACCEPT_TOKEN(sym_name); + 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(588); + END_STATE(); + case 507: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'h') ADVANCE(467); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 508: + ACCEPT_TOKEN(sym_name); + 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(588); + END_STATE(); + case 509: + ACCEPT_TOKEN(sym_name); + 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(588); + END_STATE(); + case 510: + ACCEPT_TOKEN(sym_name); + 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(588); + END_STATE(); + case 511: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'i') ADVANCE(477); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 512: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'i') ADVANCE(539); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 513: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'i') ADVANCE(474); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 514: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'i') ADVANCE(546); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 515: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'i') ADVANCE(577); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 516: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'k') ADVANCE(447); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 517: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'l') ADVANCE(325); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 518: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'l') ADVANCE(270); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 519: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'l') ADVANCE(542); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 520: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'l') ADVANCE(517); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 521: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'l') ADVANCE(465); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 522: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'l') ADVANCE(521); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 523: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'l') ADVANCE(496); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 524: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'l') ADVANCE(489); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 525: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'l') ADVANCE(562); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 526: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'l') ADVANCE(563); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 527: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'm') ADVANCE(304); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 528: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'n') ADVANCE(559); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 529: + ACCEPT_TOKEN(sym_name); + 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(588); + END_STATE(); + case 530: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'n') ADVANCE(387); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 531: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'n') ADVANCE(451); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 532: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'n') ADVANCE(311); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 533: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'n') ADVANCE(560); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 534: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'n') ADVANCE(478); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 535: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'n') ADVANCE(514); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 536: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'n') ADVANCE(579); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 537: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'n') ADVANCE(572); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 538: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'n') ADVANCE(488); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 539: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'n') ADVANCE(585); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 540: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'o') ADVANCE(528); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 541: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'o') ADVANCE(511); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 542: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'o') ADVANCE(473); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 543: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'o') ADVANCE(557); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 544: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'o') ADVANCE(545); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 545: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'o') ADVANCE(518); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 546: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'o') ADVANCE(532); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 547: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'p') ADVANCE(491); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 548: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'r') ADVANCE(429); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 549: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'r') ADVANCE(445); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 550: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'r') ADVANCE(268); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 551: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'r') ADVANCE(298); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 552: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'r') ADVANCE(296); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 553: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'r') ADVANCE(584); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 554: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'r') ADVANCE(490); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 555: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'r') ADVANCE(581); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 556: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'r') ADVANCE(531); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 557: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'r') ADVANCE(566); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 558: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'r') ADVANCE(568); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 559: + ACCEPT_TOKEN(sym_name); + 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(588); + END_STATE(); + case 560: + ACCEPT_TOKEN(sym_name); + if (lookahead == 's') ADVANCE(567); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 561: + ACCEPT_TOKEN(sym_name); + if (lookahead == 's') ADVANCE(499); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 562: + ACCEPT_TOKEN(sym_name); + if (lookahead == 's') ADVANCE(481); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 563: + ACCEPT_TOKEN(sym_name); + if (lookahead == 's') ADVANCE(485); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 564: + ACCEPT_TOKEN(sym_name); + if (lookahead == 's') ADVANCE(497); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 565: + ACCEPT_TOKEN(sym_name); + if (lookahead == 't') ADVANCE(472); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 566: + ACCEPT_TOKEN(sym_name); + if (lookahead == 't') ADVANCE(385); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 567: + ACCEPT_TOKEN(sym_name); + if (lookahead == 't') ADVANCE(249); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 568: + ACCEPT_TOKEN(sym_name); + if (lookahead == 't') ADVANCE(382); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 569: + ACCEPT_TOKEN(sym_name); + if (lookahead == 't') ADVANCE(389); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 570: + ACCEPT_TOKEN(sym_name); + if (lookahead == 't') ADVANCE(309); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 571: + ACCEPT_TOKEN(sym_name); + if (lookahead == 't') ADVANCE(290); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 572: + ACCEPT_TOKEN(sym_name); + if (lookahead == 't') ADVANCE(291); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 573: + ACCEPT_TOKEN(sym_name); + if (lookahead == 't') ADVANCE(582); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 574: + ACCEPT_TOKEN(sym_name); + if (lookahead == 't') ADVANCE(513); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 575: + ACCEPT_TOKEN(sym_name); + if (lookahead == 't') ADVANCE(552); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 576: + ACCEPT_TOKEN(sym_name); + if (lookahead == 't') ADVANCE(486); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 577: + ACCEPT_TOKEN(sym_name); + if (lookahead == 't') ADVANCE(475); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 578: + ACCEPT_TOKEN(sym_name); + if (lookahead == 't') ADVANCE(555); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 579: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'u') ADVANCE(527); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 580: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'u') ADVANCE(520); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 581: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'u') ADVANCE(476); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 582: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'u') ADVANCE(556); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 583: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'u') ADVANCE(538); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 584: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'u') ADVANCE(484); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('a' <= lookahead && lookahead <= 'z')) ADVANCE(588); + END_STATE(); + case 585: + ACCEPT_TOKEN(sym_name); + if (lookahead == 'u') ADVANCE(487); + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'Z') || + lookahead == '_' || + ('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(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(229); + if (lookahead != 0 && + lookahead != '\n') ADVANCE(589); + END_STATE(); + case 590: + ACCEPT_TOKEN(sym_comment); + if (lookahead != 0 && + lookahead != '\\') ADVANCE(589); + if (lookahead == '\\') ADVANCE(229); + END_STATE(); + default: + return false; + } +} + +static TSLexMode ts_lex_modes[STATE_COUNT] = { + [0] = {.lex_state = 0}, + [1] = {.lex_state = 234}, + [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 = 52}, + [13] = {.lex_state = 52}, + [14] = {.lex_state = 51}, + [15] = {.lex_state = 52}, + [16] = {.lex_state = 51}, + [17] = {.lex_state = 51}, + [18] = {.lex_state = 51}, + [19] = {.lex_state = 51}, + [20] = {.lex_state = 51}, + [21] = {.lex_state = 52}, + [22] = {.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 = 54}, + [30] = {.lex_state = 51}, + [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 = 45}, + [104] = {.lex_state = 45}, + [105] = {.lex_state = 56}, + [106] = {.lex_state = 56}, + [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 = 46}, + [119] = {.lex_state = 44}, + [120] = {.lex_state = 44}, + [121] = {.lex_state = 55}, + [122] = {.lex_state = 55}, + [123] = {.lex_state = 55}, + [124] = {.lex_state = 55}, + [125] = {.lex_state = 55}, + [126] = {.lex_state = 44}, + [127] = {.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 = 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 = 46}, + [144] = {.lex_state = 45}, + [145] = {.lex_state = 48}, + [146] = {.lex_state = 55}, + [147] = {.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 = 55}, + [154] = {.lex_state = 45}, + [155] = {.lex_state = 55}, + [156] = {.lex_state = 46}, + [157] = {.lex_state = 48}, + [158] = {.lex_state = 45}, + [159] = {.lex_state = 45}, + [160] = {.lex_state = 44}, + [161] = {.lex_state = 44}, + [162] = {.lex_state = 44}, + [163] = {.lex_state = 58}, + [164] = {.lex_state = 48}, + [165] = {.lex_state = 58}, + [166] = {.lex_state = 46}, + [167] = {.lex_state = 58}, + [168] = {.lex_state = 58}, + [169] = {.lex_state = 58}, + [170] = {.lex_state = 51}, + [171] = {.lex_state = 48}, + [172] = {.lex_state = 58}, + [173] = {.lex_state = 44}, + [174] = {.lex_state = 44}, + [175] = {.lex_state = 58}, + [176] = {.lex_state = 58}, + [177] = {.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 = 234}, + [184] = {.lex_state = 58}, + [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 = 58}, + [193] = {.lex_state = 58}, + [194] = {.lex_state = 58}, + [195] = {.lex_state = 58}, + [196] = {.lex_state = 0}, + [197] = {.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 = 48}, + [204] = {.lex_state = 58}, + [205] = {.lex_state = 58}, + [206] = {.lex_state = 58}, + [207] = {.lex_state = 58}, + [208] = {.lex_state = 0}, + [209] = {.lex_state = 0}, + [210] = {.lex_state = 44}, + [211] = {.lex_state = 58}, + [212] = {.lex_state = 0}, + [213] = {.lex_state = 58}, + [214] = {.lex_state = 0}, + [215] = {.lex_state = 58}, + [216] = {.lex_state = 0}, + [217] = {.lex_state = 0}, + [218] = {.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 = 59}, + [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 = 59}, + [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 = 0}, + [262] = {.lex_state = 0}, + [263] = {.lex_state = 0}, + [264] = {.lex_state = 0}, + [265] = {.lex_state = 0}, + [266] = {.lex_state = 0}, + [267] = {.lex_state = 0}, + [268] = {.lex_state = 48}, + [269] = {.lex_state = 47}, + [270] = {.lex_state = 48}, + [271] = {.lex_state = 44}, + [272] = {.lex_state = 47}, + [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 = 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 = 49}, + [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 = 49}, + [350] = {.lex_state = 44}, + [351] = {.lex_state = 44}, + [352] = {.lex_state = 44}, + [353] = {.lex_state = 44}, + [354] = {.lex_state = 44}, + [355] = {.lex_state = 44}, + [356] = {.lex_state = 44}, + [357] = {.lex_state = 44}, + [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 = 0}, + [365] = {.lex_state = 234}, + [366] = {.lex_state = 234}, + [367] = {.lex_state = 0}, + [368] = {.lex_state = 0}, + [369] = {.lex_state = 0}, + [370] = {.lex_state = 0}, + [371] = {.lex_state = 0}, + [372] = {.lex_state = 234}, + [373] = {.lex_state = 0}, + [374] = {.lex_state = 0}, + [375] = {.lex_state = 0}, + [376] = {.lex_state = 0}, + [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 = 234}, + [384] = {.lex_state = 234}, + [385] = {.lex_state = 0}, + [386] = {.lex_state = 0}, + [387] = {.lex_state = 234}, + [388] = {.lex_state = 52}, + [389] = {.lex_state = 234}, + [390] = {.lex_state = 234}, + [391] = {.lex_state = 234}, + [392] = {.lex_state = 234}, + [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 = 0}, + [400] = {.lex_state = 0}, + [401] = {.lex_state = 0}, + [402] = {.lex_state = 0}, + [403] = {.lex_state = 0}, + [404] = {.lex_state = 234}, + [405] = {.lex_state = 68}, + [406] = {.lex_state = 0}, + [407] = {.lex_state = 0}, + [408] = {.lex_state = 234}, + [409] = {.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 = 68}, + [416] = {.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 = 0}, + [424] = {.lex_state = 52}, + [425] = {.lex_state = 0}, + [426] = {.lex_state = 0}, + [427] = {.lex_state = 52}, + [428] = {.lex_state = 52}, + [429] = {.lex_state = 52}, + [430] = {.lex_state = 52}, + [431] = {.lex_state = 0}, + [432] = {.lex_state = 0}, + [433] = {.lex_state = 52}, + [434] = {.lex_state = 0}, + [435] = {.lex_state = 52}, + [436] = {.lex_state = 0}, + [437] = {.lex_state = 52}, + [438] = {.lex_state = 52}, + [439] = {.lex_state = 52}, + [440] = {.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 = 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 = 0}, + [457] = {.lex_state = 52}, + [458] = {.lex_state = 52}, + [459] = {.lex_state = 0}, + [460] = {.lex_state = 65}, + [461] = {.lex_state = 0}, + [462] = {.lex_state = 65}, + [463] = {.lex_state = 35}, + [464] = {.lex_state = 35}, + [465] = {.lex_state = 65}, + [466] = {.lex_state = 35}, + [467] = {.lex_state = 35}, + [468] = {.lex_state = 67}, + [469] = {.lex_state = 234}, + [470] = {.lex_state = 65}, + [471] = {.lex_state = 60}, + [472] = {.lex_state = 67}, + [473] = {.lex_state = 65}, + [474] = {.lex_state = 65}, + [475] = {.lex_state = 60}, + [476] = {.lex_state = 68}, + [477] = {.lex_state = 65}, + [478] = {.lex_state = 47}, + [479] = {.lex_state = 234}, + [480] = {.lex_state = 234}, + [481] = {.lex_state = 71}, + [482] = {.lex_state = 53}, + [483] = {.lex_state = 234}, + [484] = {.lex_state = 0}, + [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 = 67}, + [497] = {.lex_state = 67}, + [498] = {.lex_state = 0}, + [499] = {.lex_state = 67}, + [500] = {.lex_state = 67}, + [501] = {.lex_state = 67}, + [502] = {.lex_state = 67}, + [503] = {.lex_state = 0}, + [504] = {.lex_state = 67}, + [505] = {.lex_state = 50}, + [506] = {.lex_state = 67}, + [507] = {.lex_state = 67}, + [508] = {.lex_state = 0}, + [509] = {.lex_state = 0}, + [510] = {.lex_state = 67}, + [511] = {.lex_state = 0}, + [512] = {.lex_state = 0}, + [513] = {.lex_state = 67}, + [514] = {.lex_state = 67}, + [515] = {.lex_state = 67}, + [516] = {.lex_state = 0}, + [517] = {.lex_state = 0}, + [518] = {.lex_state = 35}, + [519] = {.lex_state = 0}, + [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 = 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 = 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 = 69}, + [547] = {.lex_state = 67}, + [548] = {.lex_state = 67}, + [549] = {.lex_state = 0}, + [550] = {.lex_state = 67}, + [551] = {.lex_state = 0}, + [552] = {.lex_state = 0}, + [553] = {.lex_state = 52}, + [554] = {.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 = 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}, + [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 = 0}, + [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 = 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 = 67}, + [591] = {.lex_state = 0}, + [592] = {.lex_state = 0}, + [593] = {.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 = 67}, + [603] = {.lex_state = 0}, + [604] = {.lex_state = 0}, + [605] = {.lex_state = 0}, + [606] = {.lex_state = 0}, + [607] = {.lex_state = 0}, + [608] = {.lex_state = 0}, + [609] = {.lex_state = 67}, + [610] = {.lex_state = 67}, + [611] = {.lex_state = 0}, + [612] = {.lex_state = 0}, + [613] = {.lex_state = 0}, + [614] = {.lex_state = 220}, + [615] = {.lex_state = 67}, + [616] = {.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 = 0}, + [624] = {.lex_state = 0}, + [625] = {.lex_state = 0}, + [626] = {.lex_state = 220}, + [627] = {.lex_state = 67}, + [628] = {.lex_state = 53}, + [629] = {.lex_state = 0}, + [630] = {.lex_state = 0}, + [631] = {.lex_state = 0}, + [632] = {.lex_state = 67}, + [633] = {.lex_state = 0}, + [634] = {.lex_state = 0}, + [635] = {.lex_state = 67}, + [636] = {.lex_state = 53}, + [637] = {.lex_state = 67}, + [638] = {.lex_state = 0}, + [639] = {.lex_state = 0}, + [640] = {.lex_state = 0}, + [641] = {.lex_state = 0}, + [642] = {.lex_state = 0}, + [643] = {.lex_state = 50}, + [644] = {.lex_state = 50}, + [645] = {.lex_state = 0}, + [646] = {.lex_state = 0}, + [647] = {.lex_state = 0}, + [648] = {.lex_state = 0}, + [649] = {.lex_state = 0}, + [650] = {.lex_state = 0}, + [651] = {.lex_state = 234}, + [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 = 0}, + [675] = {.lex_state = 0}, + [676] = {.lex_state = 0}, + [677] = {.lex_state = 67}, + [678] = {.lex_state = 0}, + [679] = {.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 = 0}, + [687] = {.lex_state = 0}, + [688] = {.lex_state = 67}, + [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 = 0}, + [700] = {.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 = 67}, + [708] = {.lex_state = 0}, + [709] = {.lex_state = 0}, + [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 = 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 = 0}, + [738] = {.lex_state = 0}, + [739] = {.lex_state = 234}, + [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 = 0}, + [771] = {.lex_state = 0}, + [772] = {.lex_state = 234}, + [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 = 0}, + [812] = {.lex_state = 0}, + [813] = {.lex_state = 50}, + [814] = {.lex_state = 0}, + [815] = {.lex_state = 234}, + [816] = {.lex_state = 0}, + [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] = { + [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_str] = 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(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), + [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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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), + [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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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), + [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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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), + [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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + [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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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), + [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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + [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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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(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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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(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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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), + [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), + }, + [11] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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), + [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(153), + [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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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_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), + }, + [13] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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_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), + }, + [14] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + [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(155), + [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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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_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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + [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(157), + [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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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_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_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), + }, + [18] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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_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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + [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(163), + [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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(165), + [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), + }, + [21] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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_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), + }, + [22] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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), + [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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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), + [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(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(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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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_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), + }, + [25] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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), + [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(171), + [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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + }, + [27] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + }, + [28] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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), + [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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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(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(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), + }, + [30] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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), + [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), + }, + [31] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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(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_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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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), + [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), + }, + [33] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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), + [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), + }, + [34] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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), + [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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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), + [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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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), + [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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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), + [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), + }, + [38] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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), + [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), + }, + [39] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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), + [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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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), + [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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + }, + [42] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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_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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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), + [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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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_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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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), + [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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + }, + [47] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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), + [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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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), + [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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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), + [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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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), + [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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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), + [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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + }, + [53] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + }, + [54] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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), + [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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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), + [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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + }, + [57] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + }, + [58] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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), + [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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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), + [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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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), + [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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + }, + [62] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + }, + [63] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + }, + [64] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + }, + [65] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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(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), + }, + [66] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + }, + [67] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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), + [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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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), + [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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + }, + [70] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + }, + [71] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + }, + [72] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + }, + [73] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + }, + [74] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + }, + [75] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + }, + [76] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + }, + [77] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + }, + [78] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + }, + [79] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + }, + [80] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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(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), + }, + [81] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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), + [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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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), + [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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + }, + [84] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + }, + [85] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + }, + [86] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + }, + [87] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + }, + [88] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + }, + [89] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + }, + [90] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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), + [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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + }, + [92] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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), + [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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + }, + [94] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + }, + [95] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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), + [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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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), + [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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + }, + [98] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + }, + [99] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + }, + [100] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + }, + [101] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + }, + [102] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + }, + [103] = { + [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(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(574), + [sym_identifier] = STATE(274), + [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(197), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_RBRACK] = ACTIONS(199), + [anon_sym__] = ACTIONS(201), + [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(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(205), + [sym_comment] = ACTIONS(3), + }, + [106] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(605), + [sym_identifier] = STATE(274), + [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(207), + [anon_sym_struct] = ACTIONS(43), + [anon_sym_LBRACK] = ACTIONS(45), + [anon_sym_RBRACK] = ACTIONS(209), + [anon_sym__] = ACTIONS(211), + [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(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(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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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(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(205), + [sym_comment] = ACTIONS(3), + }, + [109] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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(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(205), + [sym_comment] = ACTIONS(3), + }, + [110] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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(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(205), + [sym_comment] = ACTIONS(3), + }, + [111] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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(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(205), + [sym_comment] = ACTIONS(3), + }, + [112] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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(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(205), + [sym_comment] = ACTIONS(3), + }, + [113] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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(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(205), + [sym_comment] = ACTIONS(3), + }, + [114] = { + [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), + [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(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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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(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(205), + [sym_comment] = ACTIONS(3), + }, + [117] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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(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(205), + [sym_comment] = ACTIONS(3), + }, + [118] = { + [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), + [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_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(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] = { + [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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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(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(205), + [sym_comment] = ACTIONS(3), + }, + [122] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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(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(205), + [sym_comment] = ACTIONS(3), + }, + [123] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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(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(205), + [sym_comment] = ACTIONS(3), + }, + [124] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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), + [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(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(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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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(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(205), + [sym_comment] = ACTIONS(3), + }, + [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), + [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), + }, + [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(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(149), + [aux_sym_string_constant_repeat1] = STATE(276), + [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(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(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(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(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(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(205), + [sym_comment] = ACTIONS(3), + }, + [133] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(149), + [aux_sym_string_constant_repeat1] = STATE(276), + [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(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), + }, + [134] = { + [sym_constant] = STATE(303), + [sym_integer_constant] = STATE(295), + [sym_decimal_digits] = STATE(164), + [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(149), + [aux_sym_string_constant_repeat1] = STATE(276), + [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(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), + }, + [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), + [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), + }, + [137] = { + [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(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), + }, + [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(143), 1, + sym_exponent, + STATE(251), 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(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(203), 1, + anon_sym_static, + ACTIONS(305), 1, + sym_name, + ACTIONS(332), 1, + anon_sym_STAR, + 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(516), 1, + sym_postfix_expression, + STATE(736), 1, + sym_object_selector, + 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, + [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(203), 1, + anon_sym_static, + ACTIONS(305), 1, + sym_name, + ACTIONS(334), 1, + anon_sym_STAR, + 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(516), 1, + sym_postfix_expression, + STATE(808), 1, + sym_object_selector, + 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, + [359] = 8, + ACTIONS(3), 1, + sym_comment, + 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_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), 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, + [438] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(344), 2, + anon_sym_0, + anon_sym_1, + STATE(144), 2, + sym_binary_digit, + aux_sym_binary_digits_repeat1, + ACTIONS(342), 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(340), 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, + [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, + 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(203), 1, + anon_sym_static, + STATE(164), 1, + sym_decimal_digits, + STATE(212), 1, + sym_identifier, + STATE(266), 1, + sym_object_selector, + STATE(276), 1, + aux_sym_string_constant_repeat1, + STATE(304), 1, + sym_plain_expression, + STATE(509), 1, + sym_postfix_expression, + STATE(149), 2, + sym_decimal_digit, + aux_sym_decimal_digits_repeat1, + STATE(230), 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, + [717] = 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(203), 1, + anon_sym_static, + ACTIONS(205), 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, + [850] = 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(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(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, + 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, + 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, + [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, + 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(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, + 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, + [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(203), 1, + anon_sym_static, + ACTIONS(305), 1, + sym_name, + STATE(164), 1, + sym_decimal_digits, + STATE(274), 1, + sym_identifier, + STATE(276), 1, + aux_sym_string_constant_repeat1, + STATE(304), 1, + sym_plain_expression, + STATE(516), 1, + sym_postfix_expression, + STATE(149), 2, + sym_decimal_digit, + aux_sym_decimal_digits_repeat1, + STATE(491), 2, + sym_indexing_expression, + sym_slicing_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_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, + [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(203), 1, + anon_sym_static, + ACTIONS(305), 1, + sym_name, + STATE(164), 1, + sym_decimal_digits, + STATE(274), 1, + sym_identifier, + STATE(276), 1, + aux_sym_string_constant_repeat1, + STATE(304), 1, + sym_plain_expression, + STATE(492), 1, + sym_field_access_expression, + STATE(516), 1, + sym_postfix_expression, + STATE(149), 2, + sym_decimal_digit, + aux_sym_decimal_digits_repeat1, + 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), 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, + [1389] = 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(203), 1, + anon_sym_static, + ACTIONS(305), 1, + sym_name, + STATE(164), 1, + sym_decimal_digits, + STATE(274), 1, + sym_identifier, + STATE(276), 1, + aux_sym_string_constant_repeat1, + STATE(304), 1, + sym_plain_expression, + STATE(516), 1, + sym_postfix_expression, + STATE(149), 2, + sym_decimal_digit, + aux_sym_decimal_digits_repeat1, + STATE(484), 2, + sym_indexing_expression, + sym_slicing_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_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, + [1519] = 8, + ACTIONS(3), 1, + sym_comment, + ACTIONS(325), 1, + anon_sym_e, + STATE(159), 1, + sym_exponent, + 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(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, + [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(203), 1, + anon_sym_static, + ACTIONS(305), 1, + sym_name, + STATE(164), 1, + sym_decimal_digits, + STATE(274), 1, + sym_identifier, + STATE(276), 1, + aux_sym_string_constant_repeat1, + STATE(304), 1, + sym_plain_expression, + STATE(489), 1, + sym_field_access_expression, + STATE(516), 1, + sym_postfix_expression, + STATE(149), 2, + sym_decimal_digit, + aux_sym_decimal_digits_repeat1, + 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), 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_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, + [1794] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(232), 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(230), 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, + [1861] = 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_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, + [1928] = 6, + ACTIONS(3), 1, + sym_comment, + STATE(244), 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(338), 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(336), 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] = 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(429), 1, + sym_identifier, + STATE(625), 1, + sym_match_case, + STATE(651), 1, + sym_fntype_attr, + STATE(716), 1, + sym_match_cases, + STATE(725), 1, + sym_type, + ACTIONS(381), 2, + anon_sym_f32, + anon_sym_f64, + STATE(427), 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, + [2302] = 11, + ACTIONS(3), 1, + sym_comment, + ACTIONS(403), 1, + anon_sym_e, + ACTIONS(407), 1, + anon_sym_DOT, + STATE(171), 1, + sym_exponent, + STATE(296), 1, + sym_integer_suffix, + STATE(301), 1, + sym_floating_suffix, + ACTIONS(401), 2, + anon_sym_f32, + anon_sym_f64, + ACTIONS(405), 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(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, + [2378] = 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(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(410), 1, + anon_sym_RPAREN, + ACTIONS(412), 1, + anon_sym_STAR, + ACTIONS(414), 1, + sym_name, + STATE(429), 1, + sym_identifier, + STATE(569), 1, + sym_type, + STATE(651), 1, + sym_fntype_attr, + STATE(686), 1, + sym_tuple_types, + ACTIONS(381), 2, + anon_sym_f32, + anon_sym_f64, + STATE(427), 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, + [2479] = 7, + ACTIONS(3), 1, + sym_comment, + 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_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(416), 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, + [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(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(606), 1, + sym_type, + STATE(648), 1, + sym_tuple_types, + STATE(649), 1, + sym_tagged_types, + STATE(651), 1, + sym_fntype_attr, + ACTIONS(381), 2, + anon_sym_f32, + anon_sym_f64, + STATE(427), 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, + [2647] = 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(429), 1, + sym_identifier, + 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(427), 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, + [2748] = 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(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(606), 1, + sym_type, + STATE(651), 1, + sym_fntype_attr, + STATE(660), 1, + sym_tuple_types, + STATE(661), 1, + sym_tagged_types, + ACTIONS(381), 2, + anon_sym_f32, + anon_sym_f64, + STATE(427), 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, + [2849] = 3, + ACTIONS(3), 1, + sym_comment, + 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, + 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, + 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(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, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [2976] = 23, + 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(429), 1, + sym_identifier, + STATE(569), 1, + sym_type, + STATE(651), 1, + sym_fntype_attr, + STATE(686), 1, + sym_tuple_types, + ACTIONS(381), 2, + anon_sym_f32, + anon_sym_f64, + STATE(427), 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, + [3074] = 5, + ACTIONS(3), 1, + sym_comment, + 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, + anon_sym_DOT, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + 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, + 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, + [3136] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(427), 2, + anon_sym_0, + anon_sym_1, + STATE(173), 2, + sym_binary_digit, + aux_sym_binary_digits_repeat1, + ACTIONS(352), 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(350), 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, + [3198] = 22, + 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(429), 1, + sym_identifier, + STATE(651), 1, + sym_fntype_attr, + STATE(655), 1, + sym_type, + ACTIONS(381), 2, + anon_sym_f32, + anon_sym_f64, + STATE(427), 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, + [3293] = 22, + 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(429), 1, + sym_identifier, + STATE(536), 1, + sym_type, + STATE(651), 1, + sym_fntype_attr, + ACTIONS(381), 2, + anon_sym_f32, + anon_sym_f64, + STATE(427), 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, + [3388] = 22, + 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(429), 1, + sym_identifier, + STATE(588), 1, + sym_type, + STATE(651), 1, + sym_fntype_attr, + ACTIONS(381), 2, + anon_sym_f32, + anon_sym_f64, + STATE(427), 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, + [3483] = 8, + ACTIONS(3), 1, + sym_comment, + 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, + 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(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(354), 1, + sym_type, + STATE(739), 1, + sym_fntype_attr, + ACTIONS(439), 2, + anon_sym_f32, + anon_sym_f64, + STATE(340), 2, + sym__inner_type, + sym_storage_class, + 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, + [3645] = 22, + 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(429), 1, + sym_identifier, + STATE(651), 1, + sym_fntype_attr, + STATE(762), 1, + sym_type, + ACTIONS(381), 2, + anon_sym_f32, + anon_sym_f64, + STATE(427), 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, + [3740] = 22, + 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(429), 1, + sym_identifier, + STATE(651), 1, + sym_fntype_attr, + STATE(717), 1, + sym_type, + ACTIONS(381), 2, + anon_sym_f32, + anon_sym_f64, + STATE(427), 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, + [3835] = 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(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(355), 1, + sym_type, + STATE(739), 1, + sym_fntype_attr, + ACTIONS(439), 2, + anon_sym_f32, + anon_sym_f64, + STATE(340), 2, + sym__inner_type, + sym_storage_class, + 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, + [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, + anon_sym_ATnoreturn, + ACTIONS(429), 1, + anon_sym_const, + 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(353), 1, + sym_type, + STATE(739), 1, + sym_fntype_attr, + ACTIONS(439), 2, + anon_sym_f32, + anon_sym_f64, + STATE(340), 2, + sym__inner_type, + sym_storage_class, + 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, + [4086] = 22, + 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(429), 1, + sym_identifier, + STATE(543), 1, + sym_type, + STATE(651), 1, + sym_fntype_attr, + ACTIONS(381), 2, + anon_sym_f32, + anon_sym_f64, + STATE(427), 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, + [4181] = 22, + 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(429), 1, + sym_identifier, + STATE(584), 1, + sym_type, + STATE(651), 1, + sym_fntype_attr, + ACTIONS(381), 2, + anon_sym_f32, + anon_sym_f64, + STATE(427), 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, + [4276] = 22, + 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(429), 1, + sym_identifier, + STATE(651), 1, + sym_fntype_attr, + STATE(753), 1, + sym_type, + ACTIONS(381), 2, + anon_sym_f32, + anon_sym_f64, + STATE(427), 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, + [4371] = 22, + 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(429), 1, + sym_identifier, + STATE(553), 1, + sym_type, + STATE(651), 1, + sym_fntype_attr, + ACTIONS(381), 2, + anon_sym_f32, + anon_sym_f64, + STATE(427), 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, + [4466] = 22, + 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, + ACTIONS(461), 1, + anon_sym_EQ_GT, + STATE(429), 1, + sym_identifier, + STATE(651), 1, + sym_fntype_attr, + ACTIONS(381), 2, + anon_sym_f32, + anon_sym_f64, + STATE(442), 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, + [4561] = 22, + 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(429), 1, + sym_identifier, + STATE(651), 1, + sym_fntype_attr, + STATE(684), 1, + sym_type, + ACTIONS(381), 2, + anon_sym_f32, + anon_sym_f64, + STATE(427), 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, + [4656] = 22, + 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(429), 1, + sym_identifier, + STATE(556), 1, + sym_type, + STATE(651), 1, + sym_fntype_attr, + ACTIONS(381), 2, + anon_sym_f32, + anon_sym_f64, + STATE(427), 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, + [4751] = 22, + 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(429), 1, + sym_identifier, + STATE(651), 1, + sym_fntype_attr, + STATE(698), 1, + sym_type, + ACTIONS(381), 2, + anon_sym_f32, + anon_sym_f64, + STATE(427), 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, + [4846] = 22, + 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(429), 1, + sym_identifier, + STATE(651), 1, + sym_fntype_attr, + STATE(705), 1, + sym_type, + ACTIONS(381), 2, + anon_sym_f32, + anon_sym_f64, + STATE(427), 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, + [4941] = 22, + 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(429), 1, + sym_identifier, + STATE(618), 1, + sym_type, + STATE(651), 1, + sym_fntype_attr, + ACTIONS(381), 2, + anon_sym_f32, + anon_sym_f64, + STATE(427), 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, + [5036] = 22, + 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(429), 1, + sym_identifier, + STATE(544), 1, + sym_type, + STATE(651), 1, + sym_fntype_attr, + ACTIONS(381), 2, + anon_sym_f32, + anon_sym_f64, + STATE(427), 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, + [5131] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(467), 1, + anon_sym_COLON_COLON, + ACTIONS(469), 1, + anon_sym_LBRACE, + 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), 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, + [5191] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(475), 1, + anon_sym_DQUOTE, + STATE(197), 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, + [5251] = 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(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(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(420), 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, + [5435] = 21, + 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(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(739), 1, + sym_fntype_attr, + ACTIONS(439), 2, + anon_sym_f32, + anon_sym_f64, + STATE(342), 2, + sym__inner_type, + sym_storage_class, + 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, + [5527] = 21, + 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(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(739), 1, + sym_fntype_attr, + ACTIONS(439), 2, + anon_sym_f32, + anon_sym_f64, + STATE(331), 2, + sym__inner_type, + sym_storage_class, + 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, + [5619] = 21, + 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(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(739), 1, + sym_fntype_attr, + ACTIONS(439), 2, + anon_sym_f32, + anon_sym_f64, + STATE(344), 2, + sym__inner_type, + sym_storage_class, + 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, + [5711] = 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, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [5767] = 21, + 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(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(739), 1, + sym_fntype_attr, + ACTIONS(439), 2, + anon_sym_f32, + anon_sym_f64, + STATE(339), 2, + sym__inner_type, + sym_storage_class, + 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, + [5859] = 21, + 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(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(739), 1, + sym_fntype_attr, + ACTIONS(439), 2, + anon_sym_f32, + anon_sym_f64, + STATE(336), 2, + sym__inner_type, + sym_storage_class, + 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, + [5951] = 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(429), 1, + sym_identifier, + STATE(651), 1, + sym_fntype_attr, + ACTIONS(381), 2, + anon_sym_f32, + anon_sym_f64, + STATE(458), 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, + [6043] = 21, + 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(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(739), 1, + sym_fntype_attr, + ACTIONS(439), 2, + anon_sym_f32, + anon_sym_f64, + STATE(333), 2, + sym__inner_type, + sym_storage_class, + 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, + [6135] = 5, + ACTIONS(3), 1, + sym_comment, + 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, + 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, + [6195] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(484), 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(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, + 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, + [6307] = 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(429), 1, + sym_identifier, + STATE(651), 1, + sym_fntype_attr, + ACTIONS(381), 2, + anon_sym_f32, + anon_sym_f64, + STATE(442), 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, + [6399] = 7, + ACTIONS(3), 1, + sym_comment, + 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), 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(486), 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, + [6463] = 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(429), 1, + sym_identifier, + STATE(651), 1, + sym_fntype_attr, + ACTIONS(381), 2, + anon_sym_f32, + anon_sym_f64, + STATE(437), 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, + [6555] = 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, + [6613] = 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(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, + 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), 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, + [6769] = 3, + ACTIONS(3), 1, + sym_comment, + 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), 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, + [6824] = 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, + [6879] = 6, + ACTIONS(3), 1, + sym_comment, + 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_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(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, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [6940] = 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, + [6994] = 5, + ACTIONS(3), 1, + sym_comment, + 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, + 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, + [7052] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(515), 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(513), 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, + [7106] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(519), 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(517), 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, + [7160] = 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(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(521), 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, + [7302] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(465), 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(463), 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, + [7356] = 3, + ACTIONS(3), 1, + sym_comment, + 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, + [7410] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(418), 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(416), 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, + [7464] = 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, + [7518] = 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(488), 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(486), 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, + [7576] = 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, + [7630] = 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, + [7684] = 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, + [7738] = 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(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, + 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, + [7880] = 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, + [7934] = 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, + [7988] = 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, + [8042] = 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, + [8096] = 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, + [8150] = 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, + [8204] = 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, + [8258] = 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, + [8312] = 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, + [8366] = 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, + [8420] = 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, + [8474] = 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, + [8528] = 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, + [8582] = 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, + [8636] = 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, + [8690] = 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, + [8744] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(338), 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(336), 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, + [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, + 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, + [8852] = 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, + [8906] = 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, + [8960] = 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, + [9014] = 7, + ACTIONS(3), 1, + sym_comment, + 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_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), 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, + [9076] = 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, + [9130] = 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, + [9184] = 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, + [9238] = 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, + [9292] = 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, + [9346] = 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, + [9400] = 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, + [9457] = 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, + [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, + 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, + [9557] = 6, + ACTIONS(3), 1, + sym_comment, + 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_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, + [9613] = 7, + ACTIONS(3), 1, + sym_comment, + 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(418), 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(416), 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, + [9669] = 6, + ACTIONS(3), 1, + sym_comment, + ACTIONS(659), 1, + anon_sym_EQ, + STATE(102), 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, + [9722] = 5, + ACTIONS(3), 1, + sym_comment, + 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, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(457), 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, + [9772] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(484), 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(482), 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, + [9818] = 6, + ACTIONS(3), 1, + sym_comment, + 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_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, + [9870] = 7, + ACTIONS(3), 1, + sym_comment, + 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(486), 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, + [9923] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(490), 1, + anon_sym_COLON_COLON, + ACTIONS(492), 1, + anon_sym_LBRACE, + 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(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, + 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, + [9972] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(669), 1, + anon_sym_COLON_COLON, + ACTIONS(496), 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(494), 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, + [10019] = 5, + ACTIONS(3), 1, + sym_comment, + 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, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(478), 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, + [10068] = 5, + ACTIONS(3), 1, + sym_comment, + 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, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(471), 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, + [10117] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(473), 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(471), 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, + [10161] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(555), 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(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, + [10205] = 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, + [10249] = 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, + [10295] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(587), 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(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, + [10339] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(519), 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(517), 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, + [10383] = 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, + [10426] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(459), 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(457), 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, + [10469] = 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, + [10512] = 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, + [10555] = 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, + [10600] = 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, + [10643] = 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, + [10686] = 7, + ACTIONS(3), 1, + sym_comment, + 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(621), 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, + [10737] = 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, + [10780] = 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, + [10823] = 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, + [10866] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(599), 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(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, + [10909] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(338), 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(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, + anon_sym_BANG_EQ, + anon_sym_AMP_AMP, + anon_sym_CARET_CARET, + anon_sym_PIPE_PIPE, + anon_sym_else, + anon_sym_EQ_GT, + [10952] = 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, + [10995] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(527), 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(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, + [11038] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(515), 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), 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, + [11081] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(418), 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(416), 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, + [11124] = 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, + [11167] = 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, + [11210] = 3, + ACTIONS(3), 1, + sym_comment, + 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(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, + 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, + [11253] = 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, + [11296] = 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, + [11339] = 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, + [11382] = 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(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(621), 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, + [11433] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(523), 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(521), 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, + [11476] = 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, + [11519] = 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, + [11562] = 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, + [11605] = 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, + [11648] = 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, + [11691] = 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, + [11734] = 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(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(486), 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, + [11781] = 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, + [11824] = 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, + [11867] = 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, + [11910] = 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, + [11953] = 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, + [11996] = 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, + [12039] = 3, + ACTIONS(3), 1, + sym_comment, + 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(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, + [12082] = 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, + [12125] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(689), 1, + anon_sym_COLON_COLON, + ACTIONS(496), 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(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, + 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, + [12208] = 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, + [12248] = 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, + [12288] = 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, + [12328] = 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, + [12368] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(713), 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(711), 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, + [12408] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(717), 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(715), 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, + [12448] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(721), 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(719), 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, + [12488] = 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, + [12528] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(729), 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(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, + [12568] = 4, + ACTIONS(3), 1, + sym_comment, + 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, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(733), 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, + [12650] = 3, + ACTIONS(3), 1, + sym_comment, + 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, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(741), 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, + [12730] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(747), 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(745), 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, + [12770] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(751), 1, + anon_sym_BANG, + ACTIONS(753), 7, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(749), 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, + [12812] = 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, + [12852] = 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, + [12892] = 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, + [12932] = 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, + [12972] = 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, + [13012] = 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, + [13052] = 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, + [13092] = 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, + [13132] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(787), 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, + [13173] = 6, + ACTIONS(3), 1, + sym_comment, + 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, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(789), 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, + [13218] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(801), 7, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(799), 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, + [13257] = 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, + [13296] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(805), 7, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(803), 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, + [13335] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(809), 7, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(807), 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, + [13374] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(813), 7, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(811), 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, + [13413] = 6, + ACTIONS(3), 1, + sym_comment, + ACTIONS(791), 1, + anon_sym_COLON, + ACTIONS(795), 1, + anon_sym_as, + ACTIONS(797), 1, + anon_sym_is, + ACTIONS(817), 7, + anon_sym_PIPE, + anon_sym_DOT_DOT, + anon_sym_AMP, + anon_sym_SLASH, + anon_sym_CARET, + anon_sym_LT, + anon_sym_GT, + ACTIONS(815), 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, + [13458] = 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, + [13497] = 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, + [13539] = 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, + [13577] = 4, + ACTIONS(3), 1, + sym_comment, + STATE(219), 1, + sym_hex_digits, + STATE(119), 2, + sym_hex_digit, + aux_sym_hex_digits_repeat1, + ACTIONS(234), 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, + [13612] = 4, + ACTIONS(3), 1, + sym_comment, + STATE(159), 1, + sym_hex_digits, + STATE(103), 2, + sym_hex_digit, + aux_sym_hex_digits_repeat1, + ACTIONS(183), 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, + [13647] = 6, + ACTIONS(3), 1, + sym_comment, + ACTIONS(791), 1, + anon_sym_COLON, + ACTIONS(795), 1, + anon_sym_as, + ACTIONS(797), 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, + [13685] = 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(366), 1, + aux_sym_declarations_repeat1, + STATE(727), 1, + sym_declarations, + STATE(772), 1, + sym_fndec_attrs, + STATE(774), 1, + sym_declaration, + ACTIONS(11), 2, + anon_sym_let, + anon_sym_const, + STATE(411), 2, + sym_fndec_attr, + aux_sym_fndec_attrs_repeat1, + STATE(479), 2, + sym_decl_attr, + sym_fntype_attr, + ACTIONS(21), 3, + anon_sym_ATfini, + anon_sym_ATinit, + anon_sym_ATtest, + STATE(773), 4, + sym_global_declaration, + sym_constant_declaration, + sym_type_declaration, + sym_function_declaration, + [13745] = 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, + [13778] = 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(365), 1, + aux_sym_declarations_repeat1, + STATE(772), 1, + sym_fndec_attrs, + STATE(774), 1, + sym_declaration, + ACTIONS(850), 2, + anon_sym_let, + anon_sym_const, + STATE(411), 2, + sym_fndec_attr, + aux_sym_fndec_attrs_repeat1, + STATE(479), 2, + sym_decl_attr, + sym_fntype_attr, + ACTIONS(865), 3, + anon_sym_ATfini, + anon_sym_ATinit, + anon_sym_ATtest, + STATE(773), 4, + sym_global_declaration, + sym_constant_declaration, + sym_type_declaration, + sym_function_declaration, + [13835] = 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(365), 1, + aux_sym_declarations_repeat1, + STATE(772), 1, + sym_fndec_attrs, + STATE(774), 1, + sym_declaration, + ACTIONS(11), 2, + anon_sym_let, + anon_sym_const, + STATE(411), 2, + sym_fndec_attr, + aux_sym_fndec_attrs_repeat1, + STATE(479), 2, + sym_decl_attr, + sym_fntype_attr, + ACTIONS(21), 3, + anon_sym_ATfini, + anon_sym_ATinit, + anon_sym_ATtest, + STATE(773), 4, + sym_global_declaration, + sym_constant_declaration, + sym_type_declaration, + sym_function_declaration, + [13892] = 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, + [13923] = 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, + [13952] = 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, + [13983] = 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, + [14012] = 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, + [14042] = 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(761), 1, + sym_declaration, + STATE(772), 1, + sym_fndec_attrs, + ACTIONS(11), 2, + anon_sym_let, + anon_sym_const, + STATE(411), 2, + sym_fndec_attr, + aux_sym_fndec_attrs_repeat1, + STATE(479), 2, + sym_decl_attr, + sym_fntype_attr, + ACTIONS(21), 3, + anon_sym_ATfini, + anon_sym_ATinit, + anon_sym_ATtest, + STATE(773), 4, + sym_global_declaration, + sym_constant_declaration, + sym_type_declaration, + sym_function_declaration, + [14090] = 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, + [14120] = 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, + [14149] = 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, + [14178] = 5, + ACTIONS(3), 1, + sym_comment, + 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, + anon_sym_0x, + ACTIONS(49), 1, + anon_sym_0o, + ACTIONS(51), 1, + anon_sym_0b, + ACTIONS(53), 1, + anon_sym_0, + ACTIONS(919), 1, + sym_name, + STATE(178), 1, + sym_decimal_digits, + STATE(293), 1, + sym_integer_constant, + STATE(149), 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, + [14248] = 10, + ACTIONS(3), 1, + sym_comment, + 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(915), 2, + anon_sym_LT, + anon_sym_GT, + ACTIONS(917), 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, + [14318] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(484), 3, + anon_sym_EQ, + anon_sym_COLON, + anon_sym_DOT, + ACTIONS(482), 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, + [14342] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(7), 1, + anon_sym_use, + STATE(384), 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, + [14367] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(379), 1, + anon_sym_uint, + ACTIONS(929), 1, + anon_sym_LBRACE, + STATE(792), 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, + [14394] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(379), 1, + anon_sym_uint, + ACTIONS(933), 1, + anon_sym_LBRACE, + STATE(662), 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, + [14421] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(937), 1, + anon_sym_use, + STATE(384), 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, + [14446] = 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, + [14470] = 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, + [14494] = 4, + ACTIONS(3), 1, + sym_comment, + STATE(268), 1, + sym_decimal_digits, + STATE(149), 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, + [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(954), 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, + [14578] = 4, + ACTIONS(3), 1, + sym_comment, + STATE(203), 1, + sym_decimal_digits, + STATE(149), 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, + [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(166), 1, + sym_decimal_digits, + STATE(115), 2, + sym_decimal_digit, + aux_sym_decimal_digits_repeat1, + ACTIONS(228), 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, + [14643] = 4, + ACTIONS(3), 1, + sym_comment, + STATE(156), 1, + sym_decimal_digits, + STATE(115), 2, + sym_decimal_digit, + aux_sym_decimal_digits_repeat1, + ACTIONS(228), 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, + [14666] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(958), 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, + [14684] = 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, + [14702] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(962), 1, + anon_sym_DOT_DOT, + ACTIONS(964), 1, + anon_sym_AMP_AMP, + ACTIONS(960), 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, + [14724] = 3, + ACTIONS(3), 1, + sym_comment, + STATE(73), 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, + [14744] = 3, + ACTIONS(3), 1, + sym_comment, + 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(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, + [14784] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(964), 1, + anon_sym_AMP_AMP, + ACTIONS(968), 1, + anon_sym_DOT_DOT, + ACTIONS(966), 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, + [14806] = 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, + [14826] = 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, + [14847] = 4, + ACTIONS(3), 1, + sym_comment, + 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(976), 1, + anon_sym_RBRACE, + 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(783), 1, + sym_struct_union_fields, + STATE(593), 3, + sym_struct_type, + sym_union_type, + sym_identifier, + [14901] = 4, + ACTIONS(3), 1, + sym_comment, + 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(449), 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, + [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(978), 1, + anon_sym_AToffset, + ACTIONS(980), 1, + sym_name, + STATE(476), 1, + sym_offset_specifier, + STATE(599), 1, + sym_struct_union_field, + STATE(758), 1, + sym_struct_union_fields, + STATE(593), 3, + sym_struct_type, + sym_union_type, + sym_identifier, + [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(997), 1, + anon_sym_fn, + STATE(410), 2, + sym_fndec_attr, + aux_sym_fndec_attrs_repeat1, + STATE(479), 2, + sym_decl_attr, + sym_fntype_attr, + ACTIONS(21), 3, + anon_sym_ATfini, + anon_sym_ATinit, + anon_sym_ATtest, + [15048] = 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(764), 1, + sym_struct_union_fields, + STATE(593), 3, + sym_struct_type, + sym_union_type, + sym_identifier, + [15078] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(705), 1, + anon_sym_EQ, + ACTIONS(703), 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, + [15096] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1001), 1, + anon_sym_DOT_DOT, + ACTIONS(999), 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, + [15114] = 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(669), 1, + sym_struct_union_fields, + STATE(593), 3, + sym_struct_type, + sym_union_type, + sym_identifier, + [15144] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1005), 1, + anon_sym_DOT_DOT, + ACTIONS(1007), 1, + anon_sym_PIPE_PIPE, + ACTIONS(1003), 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, + [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, + 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, + [15211] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(713), 1, + anon_sym_EQ, + ACTIONS(711), 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, + [15228] = 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, + [15245] = 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, + [15262] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1005), 1, + anon_sym_DOT_DOT, + ACTIONS(1003), 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, + [15279] = 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, + [15298] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(721), 1, + anon_sym_EQ, + ACTIONS(719), 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, + [15315] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1022), 1, + anon_sym_DOT_DOT, + ACTIONS(1020), 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, + [15332] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1026), 1, + anon_sym_DOT_DOT, + ACTIONS(1024), 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, + [15349] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(753), 1, + anon_sym_EQ, + ACTIONS(1028), 1, + anon_sym_BANG, + ACTIONS(749), 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, + [15368] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(729), 1, + anon_sym_EQ, + ACTIONS(727), 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, + [15385] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(701), 1, + anon_sym_EQ, + ACTIONS(699), 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, + [15402] = 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, + [15419] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1032), 1, + anon_sym_DOT_DOT, + ACTIONS(1030), 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, + [15436] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1036), 1, + anon_sym_DOT_DOT, + ACTIONS(1034), 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, + [15453] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(739), 1, + anon_sym_EQ, + ACTIONS(737), 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, + [15470] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1015), 1, + anon_sym_DOT_DOT, + ACTIONS(1038), 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, + [15489] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(743), 1, + anon_sym_EQ, + ACTIONS(741), 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, + [15506] = 4, + ACTIONS(3), 1, + sym_comment, + 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(733), 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, + [15542] = 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, + [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_EQ_GT, + [15576] = 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, + [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, + 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, + [15644] = 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, + [15661] = 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, + [15678] = 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, + [15695] = 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, + [15712] = 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, + [15729] = 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, + [15746] = 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, + [15763] = 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, + [15780] = 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, + [15797] = 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, + [15814] = 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, + [15831] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(747), 1, + anon_sym_EQ, + ACTIONS(745), 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, + [15848] = 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, + [15865] = 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, + [15882] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(717), 1, + anon_sym_EQ, + ACTIONS(715), 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, + [15899] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1045), 1, + anon_sym_DOT_DOT, + ACTIONS(1091), 1, + anon_sym_COMMA, + ACTIONS(1040), 6, + anon_sym_SEMI, + anon_sym_RBRACE, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT_DOT, + anon_sym_EQ_GT, + [15917] = 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(579), 1, + sym_struct_literal, + STATE(585), 1, + sym_field_value, + STATE(634), 1, + sym_field_values, + STATE(704), 1, + sym_identifier, + STATE(818), 1, + sym_struct_initializer, + [15945] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1098), 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, + [15961] = 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(579), 1, + sym_struct_literal, + STATE(585), 1, + sym_field_value, + STATE(634), 1, + sym_field_values, + STATE(696), 1, + sym_struct_initializer, + STATE(704), 1, + sym_identifier, + [15989] = 8, + ACTIONS(1101), 1, + anon_sym_BSLASH, + ACTIONS(1103), 1, + anon_sym_DQUOTE, + ACTIONS(1105), 1, + aux_sym_string_char_token1, + ACTIONS(1107), 1, + sym_comment, + STATE(518), 1, + sym_named_escape, + STATE(540), 1, + sym_escape_sequence, + STATE(652), 1, + sym_string_chars, + STATE(466), 2, + sym_string_char, + aux_sym_string_chars_repeat1, + [16015] = 8, + ACTIONS(1101), 1, + anon_sym_BSLASH, + ACTIONS(1105), 1, + aux_sym_string_char_token1, + ACTIONS(1107), 1, + sym_comment, + ACTIONS(1109), 1, + anon_sym_DQUOTE, + STATE(518), 1, + sym_named_escape, + STATE(540), 1, + sym_escape_sequence, + STATE(646), 1, + sym_string_chars, + STATE(466), 2, + sym_string_char, + aux_sym_string_chars_repeat1, + [16041] = 8, + ACTIONS(3), 1, + sym_comment, + ACTIONS(43), 1, + anon_sym_struct, + ACTIONS(1096), 1, + sym_name, + ACTIONS(1111), 1, + anon_sym_RBRACE, + ACTIONS(1113), 1, + anon_sym_DOT_DOT_DOT, + STATE(565), 1, + sym_field_value, + STATE(579), 1, + sym_struct_literal, + STATE(704), 1, + sym_identifier, + [16066] = 7, + ACTIONS(1101), 1, + anon_sym_BSLASH, + ACTIONS(1105), 1, + aux_sym_string_char_token1, + ACTIONS(1107), 1, + sym_comment, + 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(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(555), 1, + sym_decl_attr, + STATE(600), 1, + sym_global_binding, + STATE(657), 1, + sym_global_bindings, + STATE(756), 1, + sym_identifier, + [16134] = 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, + [16146] = 7, + ACTIONS(3), 1, + sym_comment, + 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(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(555), 1, + sym_decl_attr, + STATE(600), 1, + sym_global_binding, + STATE(756), 1, + sym_identifier, + 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(568), 1, + sym_field_values, + STATE(579), 1, + sym_struct_literal, + STATE(585), 1, + sym_field_value, + STATE(704), 1, + sym_identifier, + [16232] = 7, + ACTIONS(3), 1, + sym_comment, + ACTIONS(43), 1, + anon_sym_struct, + ACTIONS(1096), 1, + sym_name, + ACTIONS(1135), 1, + anon_sym_RBRACE, + STATE(565), 1, + sym_field_value, + STATE(579), 1, + sym_struct_literal, + STATE(704), 1, + sym_identifier, + [16254] = 6, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1137), 1, + anon_sym_RPAREN, + STATE(532), 1, + sym_parameter, + STATE(533), 1, + sym_parameters, + STATE(647), 1, + sym_parameter_list, + ACTIONS(1133), 2, + anon_sym__, + sym_name, + [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, + ACTIONS(1141), 1, + anon_sym_RBRACE, + STATE(565), 1, + sym_field_value, + STATE(579), 1, + sym_struct_literal, + STATE(704), 1, + sym_identifier, + [16314] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1143), 1, + anon_sym_COMMA, + ACTIONS(1040), 5, + anon_sym_SEMI, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT, + anon_sym_else, + [16328] = 2, + ACTIONS(3), 1, + sym_comment, + 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(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(1153), 1, + anon_sym_COMMA, + ACTIONS(1040), 4, + anon_sym_SEMI, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT, + [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(1155), 1, + anon_sym_RPAREN, + ACTIONS(509), 4, + anon_sym_LPAREN, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_QMARK, + [16412] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1157), 1, + anon_sym_RPAREN, + 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(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(219), 1, + sym_binary_digits, + ACTIONS(427), 2, + anon_sym_0, + anon_sym_1, + STATE(174), 2, + sym_binary_digit, + aux_sym_binary_digits_repeat1, + [16457] = 6, + ACTIONS(1107), 1, + sym_comment, + 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(1163), 1, + anon_sym_RPAREN, + ACTIONS(509), 4, + anon_sym_LPAREN, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_QMARK, + [16489] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1165), 1, + anon_sym_else, + ACTIONS(1013), 4, + anon_sym_SEMI, + anon_sym_RPAREN, + anon_sym_RBRACK, + anon_sym_DOT_DOT, + [16502] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1168), 1, + anon_sym_RPAREN, + ACTIONS(509), 4, + anon_sym_LPAREN, + anon_sym_LBRACK, + anon_sym_DOT, + anon_sym_QMARK, + [16515] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1170), 1, + 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(452), 1, + sym_bindings, + STATE(459), 1, + sym_binding, + STATE(619), 1, + sym_binding_names, + [16560] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1174), 1, + sym_name, + STATE(436), 1, + sym_binding, + STATE(445), 1, + sym_bindings, + STATE(573), 1, + sym_binding_names, + [16576] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1174), 1, + sym_name, + STATE(452), 1, + sym_bindings, + STATE(478), 1, + sym_binding, + STATE(573), 1, + sym_binding_names, + [16592] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1176), 1, + 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, + ACTIONS(494), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [16622] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1174), 1, + sym_name, + STATE(443), 1, + sym_bindings, + STATE(478), 1, + sym_binding, + STATE(573), 1, + sym_binding_names, + [16638] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1172), 1, + sym_name, + STATE(445), 1, + sym_bindings, + STATE(459), 1, + sym_binding, + 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, + [16686] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(59), 1, + anon_sym_DQUOTE, + ACTIONS(1182), 1, + anon_sym_RPAREN, + STATE(276), 1, + aux_sym_string_constant_repeat1, + STATE(760), 1, + sym_string_constant, + [16702] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1172), 1, + sym_name, + STATE(443), 1, + sym_bindings, + STATE(459), 1, + sym_binding, + STATE(619), 1, + sym_binding_names, + [16718] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(950), 1, + anon_sym_COLON_COLON, + ACTIONS(1184), 1, + anon_sym_COLON, + ACTIONS(494), 2, + anon_sym_BANG, + anon_sym_EQ_GT, + [16732] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1127), 1, + sym_name, + 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(436), 1, + sym_binding, + STATE(452), 1, + sym_bindings, + STATE(573), 1, + sym_binding_names, + [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_EQ, + ACTIONS(1190), 1, + anon_sym_COLON, + [16780] = 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(1192), 1, + anon_sym_DOT, + [16796] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1174), 1, + sym_name, + STATE(436), 1, + sym_binding, + STATE(443), 1, + sym_bindings, + STATE(573), 1, + sym_binding_names, + [16812] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(950), 1, + anon_sym_COLON_COLON, + ACTIONS(1194), 1, + anon_sym_COLON, + ACTIONS(494), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [16826] = 5, + ACTIONS(3), 1, + sym_comment, + 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(443), 1, + sym_bindings, + STATE(482), 1, + sym_binding, + STATE(619), 1, + sym_binding_names, + [16858] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1172), 1, + sym_name, + STATE(452), 1, + sym_bindings, + STATE(482), 1, + sym_binding, + STATE(619), 1, + sym_binding_names, + [16874] = 5, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1172), 1, + sym_name, + STATE(445), 1, + sym_bindings, + STATE(482), 1, + sym_binding, + STATE(619), 1, + sym_binding_names, + [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_DOT, + [16906] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(59), 1, + anon_sym_DQUOTE, + STATE(276), 1, + aux_sym_string_constant_repeat1, + STATE(699), 1, + sym_string_constant, + [16919] = 2, + ACTIONS(1107), 1, + sym_comment, + ACTIONS(1200), 3, + anon_sym_BSLASH, + anon_sym_DQUOTE, + aux_sym_string_char_token1, + [16928] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1204), 1, + anon_sym_COMMA, + ACTIONS(1202), 2, + anon_sym_EQ, + anon_sym_COLON, + [16939] = 4, + ACTIONS(3), 1, + sym_comment, + 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(276), 1, + aux_sym_string_constant_repeat1, + STATE(714), 1, + sym_string_constant, + [17013] = 4, + ACTIONS(3), 1, + sym_comment, + 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(1217), 3, + anon_sym_struct, + anon_sym_union, + sym_name, + [17035] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1219), 3, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_DOT_DOT_DOT, + [17044] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1221), 1, + anon_sym_EQ, + ACTIONS(1223), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [17055] = 4, + ACTIONS(3), 1, + sym_comment, + 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_COMMA, + ACTIONS(1231), 1, + anon_sym_RBRACK, + ACTIONS(1233), 1, + anon_sym_DOT_DOT_DOT, + [17081] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1235), 3, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_DOT_DOT_DOT, + [17090] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1237), 1, + anon_sym_COMMA, + ACTIONS(1239), 1, + 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(1098), 1, + anon_sym_COLON_COLON, + ACTIONS(1243), 1, + anon_sym_EQ, + [17116] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(59), 1, + anon_sym_DQUOTE, + STATE(276), 1, + aux_sym_string_constant_repeat1, + STATE(645), 1, + sym_string_constant, + [17129] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1247), 1, + anon_sym_EQ, + ACTIONS(1245), 2, + anon_sym_SEMI, + anon_sym_COMMA, + [17140] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1204), 1, + anon_sym_COMMA, + ACTIONS(1249), 1, + anon_sym_EQ, + ACTIONS(1251), 1, + anon_sym_COLON, + [17153] = 2, + ACTIONS(1107), 1, + sym_comment, + ACTIONS(1253), 3, + anon_sym_BSLASH, + anon_sym_DQUOTE, + aux_sym_string_char_token1, + [17162] = 2, + ACTIONS(1107), 1, + sym_comment, + ACTIONS(1255), 3, + anon_sym_BSLASH, + anon_sym_DQUOTE, + aux_sym_string_char_token1, + [17171] = 2, + ACTIONS(1107), 1, + sym_comment, + ACTIONS(1257), 3, + anon_sym_BSLASH, + anon_sym_DQUOTE, + aux_sym_string_char_token1, + [17180] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1259), 1, + anon_sym_COMMA, + ACTIONS(1261), 1, + anon_sym_RPAREN, + ACTIONS(1263), 1, + anon_sym_DOT_DOT_DOT, + [17193] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1208), 1, + anon_sym_assert, + ACTIONS(1265), 2, + anon_sym_let, + anon_sym_const, + [17204] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1269), 1, + 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(545), 1, + aux_sym_tagged_types_repeat1, + [17228] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1273), 1, + anon_sym_PIPE, + ACTIONS(1275), 1, + anon_sym_RPAREN, + STATE(526), 1, + aux_sym_tagged_types_repeat1, + [17241] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1208), 1, + anon_sym_assert, + ACTIONS(1277), 2, + anon_sym_let, + anon_sym_const, + [17252] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1178), 1, + sym_name, + STATE(575), 1, + sym_enum_value, + STATE(667), 1, + sym_enum_values, + [17265] = 4, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1279), 1, + anon_sym_RBRACE, + ACTIONS(1281), 1, + sym_name, + STATE(671), 1, + sym_name_list, + [17278] = 4, + ACTIONS(3), 1, + sym_comment, + 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(1178), 1, + sym_name, + STATE(575), 1, + sym_enum_value, + STATE(650), 1, + sym_enum_values, + [17304] = 4, + ACTIONS(3), 1, + sym_comment, + 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(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(1283), 3, + anon_sym_COMMA, + anon_sym_RPAREN, + anon_sym_DOT_DOT_DOT, + [17339] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1157), 1, + anon_sym_RPAREN, + ACTIONS(1285), 1, + anon_sym_COMMA, + [17349] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1127), 1, + sym_name, + STATE(706), 1, + sym_identifier, + [17359] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1287), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [17367] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1289), 1, + anon_sym_RBRACK, + ACTIONS(1291), 1, + anon_sym_DOT_DOT, + [17377] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1293), 1, + sym_name, + STATE(616), 1, + sym_identifier, + [17387] = 3, + ACTIONS(3), 1, + sym_comment, + 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(1303), 1, + anon_sym_RPAREN, + [17415] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1305), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [17423] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1307), 1, + anon_sym_COMMA, + ACTIONS(1309), 1, + anon_sym_RPAREN, + [17433] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1311), 1, + anon_sym_COMMA, + ACTIONS(1313), 1, + anon_sym_RPAREN, + [17443] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1315), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [17451] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1317), 1, + anon_sym_COMMA, + ACTIONS(1319), 1, + anon_sym_RPAREN, + [17461] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1155), 1, + anon_sym_RPAREN, + ACTIONS(1321), 1, + anon_sym_COMMA, + [17471] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1323), 1, + anon_sym_RBRACE, + ACTIONS(1325), 1, + anon_sym_COMMA, + [17481] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1327), 1, + anon_sym_COMMA, + ACTIONS(1329), 1, + anon_sym_RPAREN, + [17491] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1331), 1, + anon_sym_SEMI, + ACTIONS(1333), 1, + anon_sym_EQ, + [17501] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1335), 1, + anon_sym_LPAREN, + STATE(570), 1, + sym_prototype, + [17511] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1335), 1, + anon_sym_LPAREN, + STATE(613), 1, + sym_prototype, + [17521] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1249), 1, + anon_sym_EQ, + ACTIONS(1251), 1, + anon_sym_COLON, + [17531] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(246), 1, + anon_sym_RBRACK, + ACTIONS(1007), 1, + anon_sym_PIPE_PIPE, + [17541] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1337), 1, + anon_sym_RBRACE, + ACTIONS(1339), 1, + anon_sym_COMMA, + [17551] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1335), 1, + anon_sym_LPAREN, + STATE(424), 1, + sym_prototype, + [17561] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1341), 1, + anon_sym_SEMI, + ACTIONS(1343), 1, + anon_sym_RPAREN, + [17571] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1345), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [17579] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1347), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [17587] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1349), 1, + anon_sym_COMMA, + ACTIONS(1351), 1, + anon_sym_RPAREN, + [17597] = 3, + ACTIONS(3), 1, + sym_comment, + 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(571), 1, + sym_identifier, + [17625] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1359), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [17633] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1361), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [17641] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1363), 1, + anon_sym_COMMA, + ACTIONS(1365), 1, + anon_sym_RPAREN, + [17651] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1367), 1, + anon_sym_SEMI, + ACTIONS(1369), 1, + anon_sym_RPAREN, + [17661] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1212), 2, + anon_sym_RPAREN, + anon_sym_PIPE, + [17669] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1003), 1, + anon_sym_RPAREN, + ACTIONS(1371), 1, + anon_sym_SEMI, + [17679] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1374), 1, + sym_name, + STATE(326), 1, + sym_identifier, + [17689] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1376), 2, + anon_sym_SEMI, + anon_sym_COMMA, + [17697] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1378), 1, + anon_sym_LPAREN, + STATE(434), 1, + sym_conditional_branch, + [17707] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1380), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [17715] = 3, + ACTIONS(3), 1, + sym_comment, + 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(1384), 1, + anon_sym_LPAREN, + STATE(490), 1, + sym_conditional_branch, + [17745] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1378), 1, + anon_sym_LPAREN, + STATE(423), 1, + sym_conditional_branch, + [17755] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1386), 2, + anon_sym_SEMI, + anon_sym_COMMA, + [17763] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1388), 1, + anon_sym_RBRACE, + ACTIONS(1390), 1, + anon_sym_COMMA, + [17773] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1392), 1, + anon_sym_SEMI, + ACTIONS(1394), 1, + anon_sym_COMMA, + [17783] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1384), 1, + anon_sym_LPAREN, + STATE(486), 1, + sym_conditional_branch, + [17793] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1127), 1, + sym_name, + STATE(380), 1, + sym_identifier, + [17803] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1202), 2, + anon_sym_EQ, + anon_sym_COLON, + [17811] = 3, + ACTIONS(3), 1, + sym_comment, + 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(1007), 1, + anon_sym_PIPE_PIPE, + [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(1402), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [17849] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1404), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [17857] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1406), 1, + sym_name, + STATE(380), 1, + sym_identifier, + [17867] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1127), 1, + sym_name, + STATE(676), 1, + sym_identifier, + [17877] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1408), 1, + anon_sym_RBRACE, + ACTIONS(1410), 1, + anon_sym_COMMA, + [17887] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1412), 2, + anon_sym_RBRACE, + anon_sym_COMMA, + [17895] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1414), 1, + anon_sym_SEMI, + 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_COLON_COLON, + [17935] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1428), 1, + sym_name, + STATE(603), 1, + sym_binding_names, + [17945] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1430), 1, + anon_sym_SEMI, + ACTIONS(1432), 1, + anon_sym_COMMA, + [17955] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1225), 1, + anon_sym_EQ, + ACTIONS(1227), 1, + anon_sym_COLON, + [17965] = 3, + ACTIONS(3), 1, + sym_comment, + 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, + [17985] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(161), 1, + anon_sym_RPAREN, + ACTIONS(1436), 1, + anon_sym_COMMA, + [17995] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1353), 1, + anon_sym_COMMA, + ACTIONS(1438), 1, + anon_sym_RPAREN, + [18005] = 2, + ACTIONS(3), 1, + sym_comment, + 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, + 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, + [18033] = 3, + ACTIONS(3), 1, + sym_comment, + 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_RBRACK, + [18053] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1452), 1, + anon_sym_COMMA, + ACTIONS(1454), 1, + anon_sym_RPAREN, + [18063] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1456), 1, + anon_sym_COMMA, + ACTIONS(1458), 1, + anon_sym_EQ_GT, + [18073] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1460), 1, + anon_sym_RBRACE, + ACTIONS(1462), 1, + anon_sym_COMMA, + [18083] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1127), 1, + sym_name, + STATE(451), 1, + sym_identifier, + [18093] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1464), 1, + anon_sym_RBRACE, + ACTIONS(1466), 1, + anon_sym_COMMA, + [18103] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1468), 1, + anon_sym_RBRACE, + ACTIONS(1470), 1, + anon_sym_COMMA, + [18113] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1472), 1, + sym_name, + STATE(271), 1, + sym_identifier, + [18123] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1289), 1, + anon_sym_RBRACK, + ACTIONS(1474), 1, + anon_sym_DOT_DOT, + [18133] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1374), 1, + sym_name, + STATE(271), 1, + sym_identifier, + [18143] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1396), 1, + anon_sym_LPAREN, + STATE(345), 1, + sym_prototype, + [18153] = 3, + ACTIONS(3), 1, + sym_comment, + ACTIONS(145), 1, + anon_sym_RPAREN, + ACTIONS(1476), 1, + anon_sym_COMMA, + [18163] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(246), 1, + anon_sym_RBRACK, + [18170] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1478), 1, + anon_sym_LBRACE, + [18177] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1480), 1, + anon_sym_LBRACE, + [18184] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1482), 1, + anon_sym_STAR, + [18191] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1484), 1, + anon_sym_STAR, + [18198] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1486), 1, + anon_sym_RPAREN, + [18205] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1488), 1, + anon_sym_DQUOTE, + [18212] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1490), 1, + anon_sym_RPAREN, + [18219] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1492), 1, + anon_sym_RPAREN, + [18226] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1494), 1, + anon_sym_RPAREN, + [18233] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1496), 1, + anon_sym_RBRACE, + [18240] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1498), 1, + anon_sym_fn, + [18247] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1500), 1, + 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, + [18268] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1504), 1, + anon_sym_EQ, + [18275] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1506), 1, + anon_sym_COLON, + [18282] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1508), 1, + anon_sym_SEMI, + [18289] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1510), 1, + anon_sym_RPAREN, + [18296] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1512), 1, + anon_sym_RBRACE, + [18303] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1514), 1, + anon_sym_RPAREN, + [18310] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1516), 1, + anon_sym_RPAREN, + [18317] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1518), 1, + anon_sym_LBRACE, + [18324] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1520), 1, + anon_sym_LPAREN, + [18331] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1522), 1, + anon_sym_LBRACE, + [18338] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1524), 1, + anon_sym_LPAREN, + [18345] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1526), 1, + anon_sym_SEMI, + [18352] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1528), 1, + anon_sym_RBRACE, + [18359] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1530), 1, + anon_sym_RBRACE, + [18366] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1532), 1, + 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, + [18387] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1536), 1, + anon_sym_RBRACK, + [18394] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1538), 1, + anon_sym_SQUOTE, + [18401] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1540), 1, + anon_sym_LPAREN, + [18408] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1542), 1, + anon_sym_LPAREN, + [18415] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1544), 1, + anon_sym_SEMI, + [18422] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1546), 1, + sym_name, + [18429] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1548), 1, + anon_sym_LPAREN, + [18436] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1550), 1, + anon_sym_LPAREN, + [18443] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1208), 1, + anon_sym_assert, + [18450] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1552), 1, + anon_sym_LPAREN, + [18457] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1554), 1, + anon_sym_LPAREN, + [18464] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1556), 1, + anon_sym_RBRACE, + [18471] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1558), 1, + anon_sym_RPAREN, + [18478] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1560), 1, + anon_sym_LPAREN, + [18485] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1329), 1, + anon_sym_RPAREN, + [18492] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1155), 1, + anon_sym_RPAREN, + [18499] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1562), 1, + 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, + [18520] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1566), 1, + anon_sym_RPAREN, + [18527] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1568), 1, + anon_sym_LPAREN, + [18534] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1570), 1, + anon_sym_RPAREN, + [18541] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1572), 1, + anon_sym_SQUOTE, + [18548] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1574), 1, + 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_SEMI, + [18569] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1578), 1, + anon_sym_RPAREN, + [18576] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1580), 1, + anon_sym_RPAREN, + [18583] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1582), 1, + anon_sym_RPAREN, + [18590] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1147), 1, + sym_name, + [18597] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1584), 1, + anon_sym_SQUOTE, + [18604] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(177), 1, + anon_sym_RBRACK, + [18611] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(492), 1, + anon_sym_LBRACE, + [18618] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1586), 1, + anon_sym_EQ, + [18625] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1588), 1, + anon_sym_COLON, + [18632] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1590), 1, + sym_name, + [18639] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1592), 1, + anon_sym_RPAREN, + [18646] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1594), 1, + anon_sym_RPAREN, + [18653] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1596), 1, + anon_sym_RPAREN, + [18660] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1598), 1, + anon_sym_RBRACK, + [18667] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1600), 1, + anon_sym_LPAREN, + [18674] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1602), 1, + anon_sym_RPAREN, + [18681] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1604), 1, + anon_sym_RPAREN, + [18688] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1606), 1, + anon_sym_LBRACE, + [18695] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1608), 1, + anon_sym_RBRACE, + [18702] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1610), 1, + anon_sym_EQ_GT, + [18709] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1612), 1, + anon_sym_EQ_GT, + [18716] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1614), 1, + 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_LPAREN, + [18737] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1618), 1, + anon_sym_RPAREN, + [18744] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1620), 1, + anon_sym_RPAREN, + [18751] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1622), 1, + anon_sym_RBRACE, + [18758] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(461), 1, + anon_sym_EQ_GT, + [18765] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(292), 1, + anon_sym_EQ_GT, + [18772] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1624), 1, + ts_builtin_sym_end, + [18779] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1626), 1, + anon_sym_RBRACE, + [18786] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1628), 1, + anon_sym_for, + [18793] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1630), 1, + anon_sym_SEMI, + [18800] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1632), 1, + anon_sym_RPAREN, + [18807] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1634), 1, + anon_sym_RPAREN, + [18814] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1636), 1, + anon_sym_RPAREN, + [18821] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1638), 1, + anon_sym_SEMI, + [18828] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1640), 1, + anon_sym_RPAREN, + [18835] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1642), 1, + anon_sym_COMMA, + [18842] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1644), 1, + anon_sym_RBRACE, + [18849] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1646), 1, + anon_sym_EQ, + [18856] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1648), 1, + anon_sym_fn, + [18863] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1650), 1, + anon_sym_RPAREN, + [18870] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1652), 1, + anon_sym_RBRACE, + [18877] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1654), 1, + anon_sym_RBRACK, + [18884] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1656), 1, + anon_sym_SEMI, + [18891] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1658), 1, + anon_sym_COLON, + [18898] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1660), 1, + anon_sym_RPAREN, + [18905] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1662), 1, + anon_sym_LPAREN, + [18912] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1168), 1, + anon_sym_RPAREN, + [18919] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1664), 1, + anon_sym_RPAREN, + [18926] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1666), 1, + anon_sym_SEMI, + [18933] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1668), 1, + anon_sym_LPAREN, + [18940] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1670), 1, + anon_sym_SEMI, + [18947] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1672), 1, + anon_sym_RPAREN, + [18954] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1674), 1, + anon_sym_EQ, + [18961] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1676), 1, + anon_sym_RPAREN, + [18968] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1678), 1, + anon_sym_LBRACE, + [18975] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1680), 1, + anon_sym_COLON, + [18982] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1682), 1, + anon_sym_LBRACE, + [18989] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1684), 1, + anon_sym_RBRACE, + [18996] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1686), 1, + anon_sym_SEMI, + [19003] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1319), 1, + anon_sym_RPAREN, + [19010] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1688), 1, + anon_sym_SEMI, + [19017] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1690), 1, + anon_sym_EQ, + [19024] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1692), 1, + anon_sym_RBRACE, + [19031] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1694), 1, + anon_sym_RBRACE, + [19038] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1696), 1, + anon_sym_RPAREN, + [19045] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(171), 1, + anon_sym_RBRACK, + [19052] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1438), 1, + anon_sym_RPAREN, + [19059] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1698), 1, + anon_sym_RBRACE, + [19066] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1700), 1, + anon_sym_RPAREN, + [19073] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1702), 1, + anon_sym_RPAREN, + [19080] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1704), 1, + anon_sym_RPAREN, + [19087] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1706), 1, + anon_sym_fn, + [19094] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1708), 1, + anon_sym_SEMI, + [19101] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1710), 1, + anon_sym_SEMI, + [19108] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1712), 1, + anon_sym_COMMA, + [19115] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1714), 1, + anon_sym_RPAREN, + [19122] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(837), 1, + ts_builtin_sym_end, + [19129] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1716), 1, + 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, + [19150] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1720), 1, + 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, + [19171] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1724), 1, + ts_builtin_sym_end, + [19178] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1726), 1, + anon_sym_RPAREN, + [19185] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1728), 1, + anon_sym_RBRACE, + [19192] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1730), 1, + anon_sym_SQUOTE, + [19199] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1732), 1, + anon_sym_LPAREN, + [19206] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1734), 1, + anon_sym_LPAREN, + [19213] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1736), 1, + anon_sym_LBRACE, + [19220] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1738), 1, + anon_sym_LBRACE, + [19227] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1740), 1, + anon_sym_LBRACE, + [19234] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1742), 1, + anon_sym_LPAREN, + [19241] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1744), 1, + anon_sym_LBRACE, + [19248] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1746), 1, + anon_sym_LPAREN, + [19255] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1748), 1, + anon_sym_LPAREN, + [19262] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1750), 1, + anon_sym_LPAREN, + [19269] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1752), 1, + anon_sym_LPAREN, + [19276] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1754), 1, + anon_sym_LPAREN, + [19283] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1756), 1, + anon_sym_LPAREN, + [19290] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1758), 1, + anon_sym_RPAREN, + [19297] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1760), 1, + anon_sym_RPAREN, + [19304] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1762), 1, + anon_sym_LPAREN, + [19311] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1764), 1, + anon_sym_LPAREN, + [19318] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1766), 1, + anon_sym_RPAREN, + [19325] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1768), 1, + anon_sym_RPAREN, + [19332] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1770), 1, + anon_sym_LPAREN, + [19339] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1772), 1, + anon_sym_COMMA, + [19346] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1774), 1, + anon_sym_LPAREN, + [19353] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1776), 1, + anon_sym_COMMA, + [19360] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1778), 1, + anon_sym_LPAREN, + [19367] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1780), 1, + anon_sym_LPAREN, + [19374] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1782), 1, + anon_sym_assert, + [19381] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1784), 1, + 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, + [19409] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1460), 1, + anon_sym_RBRACE, + [19416] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1792), 1, + anon_sym_for, + [19423] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1794), 1, + anon_sym_LPAREN, + [19430] = 2, + ACTIONS(3), 1, + sym_comment, + ACTIONS(1796), 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)] = 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)] = 1519, + [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)] = 2302, + [SMALL_STATE(165)] = 2378, + [SMALL_STATE(166)] = 2479, + [SMALL_STATE(167)] = 2546, + [SMALL_STATE(168)] = 2647, + [SMALL_STATE(169)] = 2748, + [SMALL_STATE(170)] = 2849, + [SMALL_STATE(171)] = 2908, + [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)] = 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)] = 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)] = 6705, + [SMALL_STATE(217)] = 6769, + [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[] = { + [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(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(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(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(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(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(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(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(125), + [131] = {.entry = {.count = 1, .reusable = false}}, SHIFT(514), + [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(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(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(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), + [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(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), + [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}}, REDUCE(sym_match_cases, 2), + [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(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(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(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(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(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_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_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, 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(170), + [661] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_unary_expression, 2, .production_id = 4), + [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(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(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_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 = 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_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_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 = 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(127), + [823] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_additive_expression, 1), + [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), + [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(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), + [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, 1), + [903] = {.entry = {.count = 1, .reusable = false}}, SHIFT(113), + [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(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(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}}, SHIFT(602), + [952] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_use_statement, 5), + [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(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_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_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_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_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 = 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(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(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}}, 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 +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/vendor/tree-sitter-hare/src/tree_sitter/parser.h b/vendor/tree-sitter-hare/src/tree_sitter/parser.h new file mode 100644 index 000000000..a3a87bd1d --- /dev/null +++ b/vendor/tree-sitter-hare/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_