diff --git a/build.rs b/build.rs index 9575bafecb..88043ff451 100644 --- a/build.rs +++ b/build.rs @@ -153,6 +153,11 @@ fn main() { src_dir: "vendored_parsers/tree-sitter-erlang-src", extra_files: vec![], }, + TreeSitterParser { + name: "tree-sitter-foam", + src_dir: "vendored_parsers/tree-sitter-foam-src", + extra_files: vec!["scanner.c"], + }, TreeSitterParser { name: "tree-sitter-f-sharp", src_dir: "vendored_parsers/tree-sitter-f-sharp-src", diff --git a/manual/src/languages_supported.md b/manual/src/languages_supported.md index 4aa402c2a6..78a38e7df5 100644 --- a/manual/src/languages_supported.md +++ b/manual/src/languages_supported.md @@ -25,6 +25,7 @@ with `difft --list-languages`. | Erlang | [WhatsApp/tree-sitter-erlang](https://github.com/WhatsApp/tree-sitter-erlang) | | Emacs Lisp | [wilfred/tree-sitter-elisp](https://github.com/Wilfred/tree-sitter-elisp) | | F# | [ionide/tree-sitter-fsharp](https://github.com/ionide/tree-sitter-fsharp) | +| Foam | [FoamScience/tree-sitter-foam](https://github.com/FoamScience/tree-sitter-foam) | | Gleam | [gleam-lang/tree-sitter-gleam](https://github.com/gleam-lang/tree-sitter-gleam) | | Go | [tree-sitter/tree-sitter-go](https://github.com/tree-sitter/tree-sitter-go) | | Hack | [slackhq/tree-sitter-hack](https://github.com/slackhq/tree-sitter-hack) | diff --git a/sample_files/foamAfterDict b/sample_files/foamAfterDict new file mode 100644 index 0000000000..2f6a937ce2 --- /dev/null +++ b/sample_files/foamAfterDict @@ -0,0 +1,18 @@ +SampleDictName { + key 8; + internalField uniform (0 5.1 0); +} + +runTimeVal #calc "1/4*$SampleDictName.key"; + +phases +( + oil // Describe why oil is here + air +); + +code +#{ + // C++ comment modified + const auto a = doNothing(); +#}; diff --git a/sample_files/foamBeforeDict b/sample_files/foamBeforeDict new file mode 100644 index 0000000000..00c9783ac8 --- /dev/null +++ b/sample_files/foamBeforeDict @@ -0,0 +1,16 @@ +// OpenFOAM comment + +SampleDictName { + key 5; + internalField uniform (0 0 1.2); +} + +runTimeVal #calc "3*$SampleDictName.key"; + +phases ( oil air ); + +code +#{ + // C++ comment + const auto a = doSomething(); +#}; diff --git a/src/parse/guess_language.rs b/src/parse/guess_language.rs index e1bd590dab..15e195a922 100644 --- a/src/parse/guess_language.rs +++ b/src/parse/guess_language.rs @@ -36,6 +36,7 @@ pub(crate) enum Language { EmacsLisp, Erlang, FSharp, + Foam, Gleam, Go, Hack, @@ -128,6 +129,7 @@ pub(crate) fn language_name(language: Language) -> &'static str { Elvish => "Elvish", EmacsLisp => "Emacs Lisp", Erlang => "Erlang", + Foam => "OpenFOAM", FSharp => "F#", Gleam => "Gleam", Go => "Go", @@ -265,6 +267,13 @@ pub(crate) fn language_globs(language: Language) -> Vec { "Emakefile", ], FSharp => &["*.fs", "*.fsx", "*.fsi"], + Foam => &[ + "*Dict", + "*Properties", + "fvSolution", + "fvSchemes", + "fvOptions", + ], Gleam => &["*.gleam"], Go => &["*.go"], Hack => &["*.hack", "*.hck", "*.hhi"], diff --git a/src/parse/tree_sitter_parser.rs b/src/parse/tree_sitter_parser.rs index 3ad5bc7191..1d2dfe262b 100644 --- a/src/parse/tree_sitter_parser.rs +++ b/src/parse/tree_sitter_parser.rs @@ -78,6 +78,7 @@ extern "C" { fn tree_sitter_elvish() -> ts::Language; fn tree_sitter_erlang() -> ts::Language; fn tree_sitter_fsharp() -> ts::Language; + fn tree_sitter_foam() -> ts::Language; fn tree_sitter_gleam() -> ts::Language; fn tree_sitter_go() -> ts::Language; fn tree_sitter_hare() -> ts::Language; @@ -426,6 +427,25 @@ pub(crate) fn from_language(language: guess::Language) -> TreeSitterConfig { sub_languages: vec![], } } + Foam => { + let language = unsafe { tree_sitter_foam() }; + TreeSitterConfig { + language, + atom_nodes: vec!["identifier", "number_literal", "string_literal"] + .into_iter() + .collect(), + delimiter_tokens: vec![("(", ")"), ("{", "}"), ("[…", "]"), ("#{", "#}")], + highlight_query: ts::Query::new( + language, + include_str!("../../vendored_parsers/highlights/foam.scm"), + ) + .unwrap(), + sub_languages: vec![TreeSitterSubLanguage { + query: ts::Query::new(language, "(code (code_body) @content)").unwrap(), + parse_as: CPlusPlus, + }], + } + } Gleam => { let language = unsafe { tree_sitter_gleam() }; TreeSitterConfig { diff --git a/vendored_parsers/highlights/foam.scm b/vendored_parsers/highlights/foam.scm new file mode 120000 index 0000000000..c6d208c76f --- /dev/null +++ b/vendored_parsers/highlights/foam.scm @@ -0,0 +1 @@ +../tree-sitter-foam/queries/highlights.scm \ No newline at end of file diff --git a/vendored_parsers/tree-sitter-foam-src b/vendored_parsers/tree-sitter-foam-src new file mode 120000 index 0000000000..3288fc3a21 --- /dev/null +++ b/vendored_parsers/tree-sitter-foam-src @@ -0,0 +1 @@ +tree-sitter-foam/src \ No newline at end of file diff --git a/vendored_parsers/tree-sitter-foam/.eslintrc.js b/vendored_parsers/tree-sitter-foam/.eslintrc.js new file mode 100644 index 0000000000..5b43588af7 --- /dev/null +++ b/vendored_parsers/tree-sitter-foam/.eslintrc.js @@ -0,0 +1,20 @@ +module.exports = { + env: { + commonjs: true, + es2021: true, + }, + extends: 'google', + overrides: [ + ], + parserOptions: { + ecmaVersion: 'latest', + sourceType: 'module', + }, + rules: { + 'indent': ['error', 4, {'SwitchCase': 1}], + 'max-len': [ + 'error', + {'code': 120, 'ignoreComments': true, 'ignoreUrls': true, 'ignoreStrings': true}, + ], + }, +}; diff --git a/vendored_parsers/tree-sitter-foam/.github/workflows/main.yml b/vendored_parsers/tree-sitter-foam/.github/workflows/main.yml new file mode 100644 index 0000000000..eddb805b0b --- /dev/null +++ b/vendored_parsers/tree-sitter-foam/.github/workflows/main.yml @@ -0,0 +1,34 @@ +name: Build & Test +on: + push: + branches: + - master + pull_request: + branches: + - master +jobs: + build-and-test-on-ubuntu: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v3 + - uses: actions/setup-node@v3 + with: + node-version: 16 + - run: npm install + - run: node_modules/.bin/tree-sitter test + - uses: docker-practice/actions-setup-docker@master + - run: node_modules/.bin/tree-sitter build-wasm + - uses: actions/upload-artifact@v3 + with: + name: wasm-file + path: tree-sitter-foam.wasm + build-and-test-on-windows: + runs-on: windows-latest + steps: + - uses: actions/checkout@v3 + - uses: actions/setup-node@v3 + with: + node-version: 16 + - run: npm install + - run: mv -force test/corpus_windows/* test/corpus/ + - run: node_modules/.bin/tree-sitter test diff --git a/vendored_parsers/tree-sitter-foam/.github/workflows/npm-publish.yml b/vendored_parsers/tree-sitter-foam/.github/workflows/npm-publish.yml new file mode 100644 index 0000000000..b01223f31f --- /dev/null +++ b/vendored_parsers/tree-sitter-foam/.github/workflows/npm-publish.yml @@ -0,0 +1,39 @@ +# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created +# For more information see: https://help.github.com/actions/language-and-framework-guides/publishing-nodejs-packages + +name: Publish package to NPM + +on: + release: + types: [created] + +jobs: + publish-npm: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v2 + - uses: actions/setup-node@v2 + with: + node-version: 16 + registry-url: https://registry.npmjs.org/ + - run: npm install + - run: npm publish + env: + NODE_AUTH_TOKEN: ${{secrets.NPM_TOKEN}} + + publish-gpr: + needs: build + runs-on: ubuntu-latest + permissions: + contents: read + packages: write + steps: + - uses: actions/checkout@v2 + - uses: actions/setup-node@v2 + with: + node-version: 16 + registry-url: https://npm.pkg.github.com/ + - run: npm install + - run: npm publish + env: + NODE_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}} diff --git a/vendored_parsers/tree-sitter-foam/.gitignore b/vendored_parsers/tree-sitter-foam/.gitignore new file mode 100644 index 0000000000..857e25ac3d --- /dev/null +++ b/vendored_parsers/tree-sitter-foam/.gitignore @@ -0,0 +1,6 @@ +Cargo.lock +node_modules +build +package-lock.json +/target/ +*.wasm diff --git a/vendored_parsers/tree-sitter-foam/.travis.yml b/vendored_parsers/tree-sitter-foam/.travis.yml new file mode 100644 index 0000000000..8a3a772b3d --- /dev/null +++ b/vendored_parsers/tree-sitter-foam/.travis.yml @@ -0,0 +1,9 @@ +language: node_js + +sudo: false + +node_js: 10 + +branches: + only: + - master diff --git a/vendored_parsers/tree-sitter-foam/Cargo.toml b/vendored_parsers/tree-sitter-foam/Cargo.toml new file mode 100644 index 0000000000..82542e8926 --- /dev/null +++ b/vendored_parsers/tree-sitter-foam/Cargo.toml @@ -0,0 +1,26 @@ +[package] +name = "tree-sitter-foam" +description = "OpenFoam grammar for the tree-sitter parsing library" +version = "0.4.0" +keywords = ["incremental", "parsing", "OpenFOAM", "highlighting"] +categories = ["parsing", "text-editors"] +repository = "https://github.com/FoamScience/tree-sitter-foam" +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.20.0" + +[build-dependencies] +cc = "1.0" diff --git a/vendored_parsers/tree-sitter-foam/LICENSE b/vendored_parsers/tree-sitter-foam/LICENSE new file mode 100644 index 0000000000..bea870efb7 --- /dev/null +++ b/vendored_parsers/tree-sitter-foam/LICENSE @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2022-2023 Mohammed Elwardi Fadeli , Amaan Qureshi + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/vendored_parsers/tree-sitter-foam/Makefile b/vendored_parsers/tree-sitter-foam/Makefile new file mode 100644 index 0000000000..7f47687a35 --- /dev/null +++ b/vendored_parsers/tree-sitter-foam/Makefile @@ -0,0 +1,44 @@ +WEB_TREE_SITTER_FILES=README.md package.json tree-sitter-web.d.ts tree-sitter.js tree-sitter.wasm +TREE_SITTER_VERSION=v0.20.1 + +all: node_modules/web-tree-sitter tree-sitter-foam.wasm + +# build parser.c +src/parser.c: grammar.js + npx tree-sitter generate + +# build patched version of web-tree-sitter +node_modules/web-tree-sitter: + @rm -rf tmp/tree-sitter + @git clone \ + -c advice.detachedHead=false --quiet \ + --depth=1 --branch=$(TREE_SITTER_VERSION) \ + https://github.com/tree-sitter/tree-sitter.git \ + tmp/tree-sitter + @cp tree-sitter.patch tmp/tree-sitter/ + @>/dev/null \ + && cd tmp/tree-sitter \ + && git apply tree-sitter.patch \ + && ./script/build-wasm --debug + @mkdir -p node_modules/web-tree-sitter + @cp tmp/tree-sitter/LICENSE node_modules/web-tree-sitter + @cp $(addprefix tmp/tree-sitter/lib/binding_web/,$(WEB_TREE_SITTER_FILES)) node_modules/web-tree-sitter + @rm -rf tmp/tree-sitter + +# build web version of tree-sitter-foam +# NOTE: requires patched version of web-tree-sitter +tree-sitter-foam.wasm: src/parser.c src/scanner.c + npx tree-sitter build-wasm + +CC := cc +OURCFLAGS := -shared -fPIC -g -O0 -I src + +clean: + rm -f debug *.o *.a + +debug.so: src/parser.c src/scanner.cc + $(CC) $(OURCFLAGS) $(CFLAGS) -o parser.o src/parser.c + $(CC) $(OURCFLAGS) $(CFLAGS) -o scanner.o src/scanner.cc + $(CC) $(OURCFLAGS) $(CFLAGS) -o debug.so $(PWD)/scanner.o $(PWD)/parser.o + rm -f $(HOME)/.cache/tree-sitter/lib/foam.so + cp $(PWD)/debug.so $(HOME)/.cache/tree-sitter/lib/foam.so diff --git a/vendored_parsers/tree-sitter-foam/README.md b/vendored_parsers/tree-sitter-foam/README.md new file mode 100644 index 0000000000..e7f453281d --- /dev/null +++ b/vendored_parsers/tree-sitter-foam/README.md @@ -0,0 +1,41 @@ +# OpenFOAM grammar for Tree-Sitter + +> This project is in early phases of development; expect things to change considerably + +> DISCLAIMER: +> This offering is not approved or endorsed by OpenCFD Limited, producer and distributor +> of the OpenFOAM software and owner of the OPENFOAM® and OpenCFD® trade marks. + +![OpenFOAM dictionary syntax highlighting](syntax-highlighting.png) + +This is a generic **fail-tolerant** parser for OpenFOAM case dictionaries. +The goal is to reach a state that is "good enough" for syntax highlighting +and feasible symbols extraction. + +## Features + +- Semantic understanding of OpenFOAM IO entries (Dictionaries, key-value pairs, ... etc) +- Syntax highlighting (Targeting [nvim-treesitter](https://github.com/nvim-treesitter/nvim-treesitter) mainly) +- Highlighting of C++ code blocks and regular expressions, so if your client does not install + those parsers automatically, you might have to install them manually +- Scope-awareness is there (Per-dictionary) although not used yet +- Text-objects for dictionaries and key-value pairs to use with + [TreeSitter textobjects plugin for NeoVim](https://github.com/nvim-treesitter/nvim-treesitter-textobjects) +- Text-subjects to use with [TreeSitter textsubjects plugin for NeoVim](https://github.com/RRethy/nvim-treesitter-textsubjects) +- Expression-based folding + +## Running tests + +- Unit tests for both parsing and highlighting (Highlighting is not consistent between `tree-sitter highlight` + and `nvim-treesitter`) are executed with `tree-sitter test` + (Check the `test` folder) +- `testOFFiles.sh $FOAM_TUTORIALS` parses all OpenFOAM dictionaries in the tutorials directory + - Currently, the parser works on almost all OpenFOAM 8 and Foam-Extend 4 tutorial files + (Well, some files are faulty from source!) + +## Contributing + +- Pull requests are welcome! +- And, no I'm not going to support specific keyword highlighting + (eg. `scalarField` will never be treated in a special way) unless I find an "unattended" + way to do that. diff --git a/vendored_parsers/tree-sitter-foam/binding.gyp b/vendored_parsers/tree-sitter-foam/binding.gyp new file mode 100644 index 0000000000..e750f2302f --- /dev/null +++ b/vendored_parsers/tree-sitter-foam/binding.gyp @@ -0,0 +1,20 @@ +{ + "targets": [ + { + "target_name": "tree_sitter_foam_binding", + "include_dirs": [ + " +#include "nan.h" + +using namespace v8; + +extern "C" TSLanguage * tree_sitter_foam(); + +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_foam()); + + Nan::Set(instance, Nan::New("name").ToLocalChecked(), Nan::New("foam").ToLocalChecked()); + Nan::Set(module, Nan::New("exports").ToLocalChecked(), instance); +} + +NODE_MODULE(tree_sitter_foam_binding, Init) + +} // namespace diff --git a/vendored_parsers/tree-sitter-foam/bindings/node/index.js b/vendored_parsers/tree-sitter-foam/bindings/node/index.js new file mode 100644 index 0000000000..0a5377e0fd --- /dev/null +++ b/vendored_parsers/tree-sitter-foam/bindings/node/index.js @@ -0,0 +1,19 @@ +try { + module.exports = require("../../build/Release/tree_sitter_foam_binding"); +} catch (error1) { + if (error1.code !== 'MODULE_NOT_FOUND') { + throw error1; + } + try { + module.exports = require("../../build/Debug/tree_sitter_foam_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/vendored_parsers/tree-sitter-foam/bindings/rust/README.md b/vendored_parsers/tree-sitter-foam/bindings/rust/README.md new file mode 100644 index 0000000000..0b1b63d199 --- /dev/null +++ b/vendored_parsers/tree-sitter-foam/bindings/rust/README.md @@ -0,0 +1,8 @@ +# tree-sitter-foam + +This crate provides an OpenFOAM grammar for the [tree-sitter](https://tree-sitter.github.io/tree-sitter/) parsing library. +To use it, add to your `[dependencies]`. + +Typically, you'll want to also depend on `tree-sitter` itself, so you can +parse and highlight code using this crate. + diff --git a/vendored_parsers/tree-sitter-foam/bindings/rust/build.rs b/vendored_parsers/tree-sitter-foam/bindings/rust/build.rs new file mode 100644 index 0000000000..8b51e55ab0 --- /dev/null +++ b/vendored_parsers/tree-sitter-foam/bindings/rust/build.rs @@ -0,0 +1,31 @@ +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); + + let scanner_path = src_dir.join("scanner.c"); + c_config.file(&scanner_path); + + println!("cargo:rerun-if-changed={}", parser_path.to_str().unwrap()); + c_config.compile("parser"); + + /* + 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); + println!("cargo:rerun-if-changed={}", scanner_path.to_str().unwrap()); + cpp_config.compile("scanner"); + */ +} diff --git a/vendored_parsers/tree-sitter-foam/bindings/rust/lib.rs b/vendored_parsers/tree-sitter-foam/bindings/rust/lib.rs new file mode 100644 index 0000000000..49cd54b56f --- /dev/null +++ b/vendored_parsers/tree-sitter-foam/bindings/rust/lib.rs @@ -0,0 +1,54 @@ +//! This crate provides foam 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_foam::language()).expect("Error loading foam 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_foam() -> 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_foam() } +} + +/// 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 + +/// The source of the JavaScript tree-sitter grammar description. +pub const GRAMMAR: &'static str = include_str!("../../grammar.js"); +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 foam language"); + } +} diff --git a/vendored_parsers/tree-sitter-foam/grammar.js b/vendored_parsers/tree-sitter-foam/grammar.js new file mode 100644 index 0000000000..c1630b1d27 --- /dev/null +++ b/vendored_parsers/tree-sitter-foam/grammar.js @@ -0,0 +1,254 @@ +/** + * @file OpenFOAM grammar for tree-sitter, supports OF9 and FE4 + * @author Mohammed Elwardi Fadeli + * @author Amaan Qureshi + * @license MIT + */ + +/* eslint-disable arrow-parens */ +/* eslint-disable camelcase */ +/* eslint-disable-next-line spaced-comment */ +/// +// @ts-check + + +module.exports = grammar({ + name: 'foam', + + // Resolve conflicting rules + conflicts: $ => [ + [$._statement, $._non_uniform_list], + [$._non_uniform_list], + [$.dict], + ], + + // Tell the external scanner to figure out identifiers + externals: $ => [ + $.identifier, + $.boolean, + $._eof, + ], + + // Our extras are C's extras + extras: $ => [ + /\s/, // Treating whitespace as white space; + $.comment, // Treating comments as white space; + $.pyfoam_template, // PyFoam stuff is whitespace; + ], + + word: $ => $.identifier, + + rules: { + foam: $ => seq(repeat($._statement), $._eof), + + // Global statements in a dictionary + _statement: $ => choice( + // Canonical statements + $.preproc_call, + $.key_value, + $.dict, + + // Special support for uncommon things which may appear as statements + $._non_uniform_list, + $._uniform_list, + $.number_literal, + $.pyfoam_variable, + ), + + // OpenFOAM Dictionaries + dict: $ => seq( + field('key', choice($.identifier, $.string_literal, $.list)), + '{', + optional($.dict_core), + alias(token(prec(-1, '}')), '}'), + optional(';'), // This shouldn't be here; but oh well; FE4 tutorials had some + ), + dict_core: $ => prec.left(3, seq( + field('dict_body', repeat1(choice($._statement, seq($.macro, optional(';'))))), + )), + + // OpenFOAM Key-Value pairs + key_value: $ => seq( + field('keyword', choice($.identifier, $.string_literal)), + optional(field('value', repeat1($._value))), // Optional values + ';', + ), + + // Directives (#include*, #calc and the like, let's call them preprocessor calls) + preproc_call: $ => choice( + $._generic_preproc_call, + $._special_preproc_call, + ), + + _special_preproc_call: $ => prec(2, choice( + $._cond_preproc_call, + field('directive', token(seq('#', 'else'))), + field('directive', token(seq('#', 'endif'))), + )), + + // TODO: "diretive" does not show up as a field for "#ifeq" call + _cond_preproc_call: $ => prec.left(2, seq( + field('directive', token(seq('#', 'ifeq'))), + field('argument', seq(choice( + $.identifier, + $.macro, + $.string_literal, + ), choice( + $.identifier, + $.macro, + $.string_literal, + ), + )))), + + _generic_preproc_call: $ => prec.left(2, seq( + field('directive', seq('#', $.identifier)), + field('argument', choice( + $.preproc_call, + $.string_literal, + $.identifier, + $.macro, + $.dict_headless, + )), + optional(';'), + )), + + // OpenFOAM basic values (What commonly goes into the value part of a key-value pair) + _value: $ => prec.left(2, choice( + $.dimensions, + $.preproc_call, + $.dict, + $.list, + $.code, + $.macro, + $.boolean, + $.string_literal, + $.number_literal, + $.pyfoam_expression, + $.identifier, + )), + + // OpenFOAM dimensions data + // TODO: $.identifier is overkill; here to support [m^2 s^-2] kind of dimensions + dimensions: $ => seq( + '[', + repeat(field('dimension', choice($.identifier, $.number_literal))), + alias(token(prec(1, ']')), ']'), + ), + + // OpenFOAM list of items + list: $ => choice($._uniform_list, $._non_uniform_list), + + _uniform_list: $ => seq( + field('size', $.number_literal), + '{', + field('item', $._list_item), + alias(token(prec(-1, '}')), '}'), + ), + + _non_uniform_list: $ => seq( + optional(field('type', $.identifier)), + optional(field('size', $.number_literal)), + '(', + field('item', repeat($._list_item)), + alias(token(prec(-1, ')')), ')'), + ), + + _list_item: $ => choice( + $._value, $.dict_headless, + ), + + dict_headless: $ => seq( + '{', + field('dict_body', repeat(choice($._statement, seq($.macro, optional(';'))))), + alias(token(prec(-1, '}')), '}'), + ), + + // C++ code blocks in OpenFOAM dictionaries + // C++ Comments will be treated as white space even inside the C++ block + // which is good, protecting against #} appearing a comment and messing things up + code: $ => seq( + '#{', + optional($.code_body), + '#}', + ), + code_body: $ => repeat1(choice( + token(/([^#\n"]|#[^{}\n]|"([^"\\]|\\.)+")+/), + $.string_literal, + )), + + // OpenFOAM macros; currently, also reads file paths + macro: $ => choice($._macro_braces, $._macro_no_braces), + + _macro_braces: $ => seq( + '${', + optional($.prev_scope), + $.identifier, + token.immediate('}'), + ), + + _macro_no_braces: $ => seq( + '$', + optional($.prev_scope), + $.identifier, + ), + + // Scope indication for the reference entry + prev_scope: _ => /[:!\.\/]+/, + + // OpenFOAM boolean-like values + // boolean: _ => choice( + // 'on', + // 'off', + // 'true', + // 'false', + // 'yes', + // 'no', + // ), + + // Primitive floating number + number_literal: _ => token(seq( + /[-+]?[0-9]*\.?[0-9]+([eE][-+]?[0-9]+)?/, // "0." will not get match + token.immediate(optional('.')), // hence add a sketchy & optional "." + )), + + // C-style strings + string_literal: $ => seq( + choice('L"', 'u"', 'U"', 'u8"', '"'), + repeat(choice( + token.immediate(prec(1, /[^\\"\n]+/)), + $.escape_sequence, + )), + '"', + ), + escape_sequence: _ => token(prec(1, seq( + '\\', + choice( + /[^xuU]/, + /\d{2,3}/, + /x[0-9a-fA-F]{2,}/, + /u[0-9a-fA-F]{4}/, + /U[0-9a-fA-F]{8}/, + ), + ))), + + // C-like comments, not as good as using a real preprocessor, + // but does the job just fine + comment: _ => prec.left(4, token(choice( + seq('//', /(\\(.|\r?\n)|[^\\\n])*/), + seq( + '/*', + /[^*]*\*+([^/*][^*]*\*+)*/, + '/', + )))), + + // Basic PyFoam support + single_python_line: _ => repeat1(token.immediate(/[^\n]/)), + pyfoam_template: $ => seq(''), + pyfoam_expression: $ => seq('|-', field('code_body', $.single_python_line), '-|'), + pyfoam_variable: $ => seq('$$', field('code_body', $.single_python_line), '\n'), + + // OpenFOAM identifiers + // This pretty much matches anything a crazy programmer can thinkup for a keyword name; + // The only requirement is the 1st character, just to avoid conflicts with other rules + }, +}); diff --git a/vendored_parsers/tree-sitter-foam/package.json b/vendored_parsers/tree-sitter-foam/package.json new file mode 100644 index 0000000000..6a879dedeb --- /dev/null +++ b/vendored_parsers/tree-sitter-foam/package.json @@ -0,0 +1,41 @@ +{ + "name": "tree-sitter-foam", + "version": "0.4.0", + "description": "Tree sitter grammer for OpenFOAM dictionaries", + "main": "bindings/node", + "homepage": "https://github.com/FoamScience/tree-sitter-foam#readme", + "bugs": { + "url": "https://github.com/FoamScience/tree-sitter-foam/issues", + "email": "elwardifadeli@gmail.com" + }, + "scripts": { + "test": "echo \"No test specified\"" + }, + "keywords": [ + "OpenFOAM", + "TreeSitter" + ], + "author": "Mohammed Elwardi Fadeli", + "license": "MIT", + "dependencies": { + "nan": "^2.17.0", + "node-gyp": "^9.4.0" + }, + "devDependencies": { + "eslint": "^8.45.0", + "eslint-config-google": "^0.14.0", + "tree-sitter-cli": "^0.20.8", + "web-tree-sitter": "github:wenkokke/web-tree-sitter#dev" + }, + "tree-sitter": [ + { + "scope": "source.foam", + "file-types": [ + "foam", + "OpenFOAM" + ], + "content-regex": "FoamFile", + "injection-regex": "^(foam|OpenFOAM)$" + } + ] +} diff --git a/vendored_parsers/tree-sitter-foam/queries/folds.scm b/vendored_parsers/tree-sitter-foam/queries/folds.scm new file mode 100644 index 0000000000..2e499c2e22 --- /dev/null +++ b/vendored_parsers/tree-sitter-foam/queries/folds.scm @@ -0,0 +1,7 @@ +[ + (comment) + (list) + (dict_core) +] @fold + +(code (code_body)* @fold) diff --git a/vendored_parsers/tree-sitter-foam/queries/highlights.scm b/vendored_parsers/tree-sitter-foam/queries/highlights.scm new file mode 100644 index 0000000000..3f172ffea4 --- /dev/null +++ b/vendored_parsers/tree-sitter-foam/queries/highlights.scm @@ -0,0 +1,64 @@ +;; Comments +(comment) @comment + +;; Generic Key-value pairs and dictionary keywords +(key_value + keyword: (identifier) @function +) +(dict + key: (identifier) @type +) + +;; Macros +(macro + "$" @conditional + (prev_scope)* @conditional + (identifier)* @namespace +) + + +;; Directives +"#" @conditional +(preproc_call + directive: (identifier)* @conditional + argument: (identifier)* @namespace +) +( + (preproc_call + argument: (identifier)* @namespace + ) @conditional + (#match? @conditional "ifeq") +) + +( + (preproc_call) @conditional + (#match? @conditional "(else|endif)") +) + +;; Literals + +(number_literal) @float +(string_literal) @string +(escape_sequence) @escape +(boolean) @boolean + +;; Treat [m^2 s^-2] the same as if it was put in numbers format +(dimensions dimension: (identifier) @float) + +;; Punctuation +[ + "(" + ")" + "[" + "]" + "{" + "}" + "#{" + "#}" + ";" +] @punctuation + +;; Special identifiers + +((identifier) @attribute + (#match? @attribute "^(uniform|non-uniform|and|or)$")) diff --git a/vendored_parsers/tree-sitter-foam/queries/indents.scm b/vendored_parsers/tree-sitter-foam/queries/indents.scm new file mode 100644 index 0000000000..033700c174 --- /dev/null +++ b/vendored_parsers/tree-sitter-foam/queries/indents.scm @@ -0,0 +1,11 @@ +[ + "{" + "}" +] @branch + +[(dict) (key_value)] @indent + + +[ + (comment) +] @ignore diff --git a/vendored_parsers/tree-sitter-foam/queries/injections.scm b/vendored_parsers/tree-sitter-foam/queries/injections.scm new file mode 100644 index 0000000000..08d10721c5 --- /dev/null +++ b/vendored_parsers/tree-sitter-foam/queries/injections.scm @@ -0,0 +1,9 @@ +;; Pass code blocks to Cpp highlighter +(code (code_body) @cpp) + +;; Pass identifiers to Go highlighter (Cheating I know) +;;((identifier) @lua) + +;; Highlight regex syntax inside literal strings +((string_literal) @regex) + diff --git a/vendored_parsers/tree-sitter-foam/queries/locals.scm b/vendored_parsers/tree-sitter-foam/queries/locals.scm new file mode 100644 index 0000000000..2abe743dd3 --- /dev/null +++ b/vendored_parsers/tree-sitter-foam/queries/locals.scm @@ -0,0 +1,6 @@ +(dict) @scope + +(dict key: (_) @definition.type) + +(key_value keyword: (_) @definition.parameter) +(key_value value: (macro (identifier)*)* @reference) diff --git a/vendored_parsers/tree-sitter-foam/queries/textobjects.scm b/vendored_parsers/tree-sitter-foam/queries/textobjects.scm new file mode 100644 index 0000000000..c5abe52d61 --- /dev/null +++ b/vendored_parsers/tree-sitter-foam/queries/textobjects.scm @@ -0,0 +1,5 @@ +(dict) @class.outer +((dict_core) @class.inner) +((key_value value: _? @_start (_)* _? @parameter.inner) + (#make-range! "function.inner" @_start @parameter.inner)) @function.outer +(code (_)* @class.inner) @class.outer diff --git a/vendored_parsers/tree-sitter-foam/queries/textsubjects-container-outer.scm b/vendored_parsers/tree-sitter-foam/queries/textsubjects-container-outer.scm new file mode 100644 index 0000000000..c0e6d27b70 --- /dev/null +++ b/vendored_parsers/tree-sitter-foam/queries/textsubjects-container-outer.scm @@ -0,0 +1,3 @@ +((dict) @_start @_end + (#make-range! "range" @_start @_end) +) diff --git a/vendored_parsers/tree-sitter-foam/queries/textsubjects-smart.scm b/vendored_parsers/tree-sitter-foam/queries/textsubjects-smart.scm new file mode 100644 index 0000000000..f0266b5e46 --- /dev/null +++ b/vendored_parsers/tree-sitter-foam/queries/textsubjects-smart.scm @@ -0,0 +1,14 @@ +((comment) @_start @_end + (#make-range! "range" @_start @_end)) + +(((_) @head . (comment) @_start . (comment)+ @_end (_) @tail) + (#not-has-type? @tail "comment") + (#not-has-type? @head "comment") + (#make-range! "range" @_start @_end)) + +((key_value value: _? @_start (_)* @_end) + (#make-range! "range" @_start @_end)) + +((key_value) @_start @_end + (#make-range! "range" @_start @_end) +) diff --git a/vendored_parsers/tree-sitter-foam/src/grammar.json b/vendored_parsers/tree-sitter-foam/src/grammar.json new file mode 100644 index 0000000000..7669203a6a --- /dev/null +++ b/vendored_parsers/tree-sitter-foam/src/grammar.json @@ -0,0 +1,1118 @@ +{ + "name": "foam", + "word": "identifier", + "rules": { + "foam": { + "type": "SEQ", + "members": [ + { + "type": "REPEAT", + "content": { + "type": "SYMBOL", + "name": "_statement" + } + }, + { + "type": "SYMBOL", + "name": "_eof" + } + ] + }, + "_statement": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "preproc_call" + }, + { + "type": "SYMBOL", + "name": "key_value" + }, + { + "type": "SYMBOL", + "name": "dict" + }, + { + "type": "SYMBOL", + "name": "_non_uniform_list" + }, + { + "type": "SYMBOL", + "name": "_uniform_list" + }, + { + "type": "SYMBOL", + "name": "number_literal" + }, + { + "type": "SYMBOL", + "name": "pyfoam_variable" + } + ] + }, + "dict": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "key", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "SYMBOL", + "name": "string_literal" + }, + { + "type": "SYMBOL", + "name": "list" + } + ] + } + }, + { + "type": "STRING", + "value": "{" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "dict_core" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "ALIAS", + "content": { + "type": "TOKEN", + "content": { + "type": "PREC", + "value": -1, + "content": { + "type": "STRING", + "value": "}" + } + } + }, + "named": false, + "value": "}" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": ";" + }, + { + "type": "BLANK" + } + ] + } + ] + }, + "dict_core": { + "type": "PREC_LEFT", + "value": 3, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "dict_body", + "content": { + "type": "REPEAT1", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "_statement" + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "macro" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": ";" + }, + { + "type": "BLANK" + } + ] + } + ] + } + ] + } + } + } + ] + } + }, + "key_value": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "keyword", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "SYMBOL", + "name": "string_literal" + } + ] + } + }, + { + "type": "CHOICE", + "members": [ + { + "type": "FIELD", + "name": "value", + "content": { + "type": "REPEAT1", + "content": { + "type": "SYMBOL", + "name": "_value" + } + } + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": ";" + } + ] + }, + "preproc_call": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "_generic_preproc_call" + }, + { + "type": "SYMBOL", + "name": "_special_preproc_call" + } + ] + }, + "_special_preproc_call": { + "type": "PREC", + "value": 2, + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "_cond_preproc_call" + }, + { + "type": "FIELD", + "name": "directive", + "content": { + "type": "TOKEN", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "#" + }, + { + "type": "STRING", + "value": "else" + } + ] + } + } + }, + { + "type": "FIELD", + "name": "directive", + "content": { + "type": "TOKEN", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "#" + }, + { + "type": "STRING", + "value": "endif" + } + ] + } + } + } + ] + } + }, + "_cond_preproc_call": { + "type": "PREC_LEFT", + "value": 2, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "directive", + "content": { + "type": "TOKEN", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "#" + }, + { + "type": "STRING", + "value": "ifeq" + } + ] + } + } + }, + { + "type": "FIELD", + "name": "argument", + "content": { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "SYMBOL", + "name": "macro" + }, + { + "type": "SYMBOL", + "name": "string_literal" + } + ] + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "SYMBOL", + "name": "macro" + }, + { + "type": "SYMBOL", + "name": "string_literal" + } + ] + } + ] + } + } + ] + } + }, + "_generic_preproc_call": { + "type": "PREC_LEFT", + "value": 2, + "content": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "directive", + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "#" + }, + { + "type": "SYMBOL", + "name": "identifier" + } + ] + } + }, + { + "type": "FIELD", + "name": "argument", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "preproc_call" + }, + { + "type": "SYMBOL", + "name": "string_literal" + }, + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "SYMBOL", + "name": "macro" + }, + { + "type": "SYMBOL", + "name": "dict_headless" + } + ] + } + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": ";" + }, + { + "type": "BLANK" + } + ] + } + ] + } + }, + "_value": { + "type": "PREC_LEFT", + "value": 2, + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "dimensions" + }, + { + "type": "SYMBOL", + "name": "preproc_call" + }, + { + "type": "SYMBOL", + "name": "dict" + }, + { + "type": "SYMBOL", + "name": "list" + }, + { + "type": "SYMBOL", + "name": "code" + }, + { + "type": "SYMBOL", + "name": "macro" + }, + { + "type": "SYMBOL", + "name": "boolean" + }, + { + "type": "SYMBOL", + "name": "string_literal" + }, + { + "type": "SYMBOL", + "name": "number_literal" + }, + { + "type": "SYMBOL", + "name": "pyfoam_expression" + }, + { + "type": "SYMBOL", + "name": "identifier" + } + ] + } + }, + "dimensions": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "[" + }, + { + "type": "REPEAT", + "content": { + "type": "FIELD", + "name": "dimension", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "SYMBOL", + "name": "number_literal" + } + ] + } + } + }, + { + "type": "ALIAS", + "content": { + "type": "TOKEN", + "content": { + "type": "PREC", + "value": 1, + "content": { + "type": "STRING", + "value": "]" + } + } + }, + "named": false, + "value": "]" + } + ] + }, + "list": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "_uniform_list" + }, + { + "type": "SYMBOL", + "name": "_non_uniform_list" + } + ] + }, + "_uniform_list": { + "type": "SEQ", + "members": [ + { + "type": "FIELD", + "name": "size", + "content": { + "type": "SYMBOL", + "name": "number_literal" + } + }, + { + "type": "STRING", + "value": "{" + }, + { + "type": "FIELD", + "name": "item", + "content": { + "type": "SYMBOL", + "name": "_list_item" + } + }, + { + "type": "ALIAS", + "content": { + "type": "TOKEN", + "content": { + "type": "PREC", + "value": -1, + "content": { + "type": "STRING", + "value": "}" + } + } + }, + "named": false, + "value": "}" + } + ] + }, + "_non_uniform_list": { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "FIELD", + "name": "type", + "content": { + "type": "SYMBOL", + "name": "identifier" + } + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "CHOICE", + "members": [ + { + "type": "FIELD", + "name": "size", + "content": { + "type": "SYMBOL", + "name": "number_literal" + } + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": "(" + }, + { + "type": "FIELD", + "name": "item", + "content": { + "type": "REPEAT", + "content": { + "type": "SYMBOL", + "name": "_list_item" + } + } + }, + { + "type": "ALIAS", + "content": { + "type": "TOKEN", + "content": { + "type": "PREC", + "value": -1, + "content": { + "type": "STRING", + "value": ")" + } + } + }, + "named": false, + "value": ")" + } + ] + }, + "_list_item": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "_value" + }, + { + "type": "SYMBOL", + "name": "dict_headless" + } + ] + }, + "dict_headless": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "{" + }, + { + "type": "FIELD", + "name": "dict_body", + "content": { + "type": "REPEAT", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "_statement" + }, + { + "type": "SEQ", + "members": [ + { + "type": "SYMBOL", + "name": "macro" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": ";" + }, + { + "type": "BLANK" + } + ] + } + ] + } + ] + } + } + }, + { + "type": "ALIAS", + "content": { + "type": "TOKEN", + "content": { + "type": "PREC", + "value": -1, + "content": { + "type": "STRING", + "value": "}" + } + } + }, + "named": false, + "value": "}" + } + ] + }, + "code": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "#{" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "code_body" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "STRING", + "value": "#}" + } + ] + }, + "code_body": { + "type": "REPEAT1", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "TOKEN", + "content": { + "type": "PATTERN", + "value": "([^#\\n\"]|#[^{}\\n]|\"([^\"\\\\]|\\\\.)+\")+" + } + }, + { + "type": "SYMBOL", + "name": "string_literal" + } + ] + } + }, + "macro": { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "_macro_braces" + }, + { + "type": "SYMBOL", + "name": "_macro_no_braces" + } + ] + }, + "_macro_braces": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "${" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "prev_scope" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "IMMEDIATE_TOKEN", + "content": { + "type": "STRING", + "value": "}" + } + } + ] + }, + "_macro_no_braces": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "$" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "SYMBOL", + "name": "prev_scope" + }, + { + "type": "BLANK" + } + ] + }, + { + "type": "SYMBOL", + "name": "identifier" + } + ] + }, + "prev_scope": { + "type": "PATTERN", + "value": "[:!\\.\\/]+" + }, + "number_literal": { + "type": "TOKEN", + "content": { + "type": "SEQ", + "members": [ + { + "type": "PATTERN", + "value": "[-+]?[0-9]*\\.?[0-9]+([eE][-+]?[0-9]+)?" + }, + { + "type": "IMMEDIATE_TOKEN", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "." + }, + { + "type": "BLANK" + } + ] + } + } + ] + } + }, + "string_literal": { + "type": "SEQ", + "members": [ + { + "type": "CHOICE", + "members": [ + { + "type": "STRING", + "value": "L\"" + }, + { + "type": "STRING", + "value": "u\"" + }, + { + "type": "STRING", + "value": "U\"" + }, + { + "type": "STRING", + "value": "u8\"" + }, + { + "type": "STRING", + "value": "\"" + } + ] + }, + { + "type": "REPEAT", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "IMMEDIATE_TOKEN", + "content": { + "type": "PREC", + "value": 1, + "content": { + "type": "PATTERN", + "value": "[^\\\\\"\\n]+" + } + } + }, + { + "type": "SYMBOL", + "name": "escape_sequence" + } + ] + } + }, + { + "type": "STRING", + "value": "\"" + } + ] + }, + "escape_sequence": { + "type": "TOKEN", + "content": { + "type": "PREC", + "value": 1, + "content": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "\\" + }, + { + "type": "CHOICE", + "members": [ + { + "type": "PATTERN", + "value": "[^xuU]" + }, + { + "type": "PATTERN", + "value": "\\d{2,3}" + }, + { + "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}" + } + ] + } + ] + } + } + }, + "comment": { + "type": "PREC_LEFT", + "value": 4, + "content": { + "type": "TOKEN", + "content": { + "type": "CHOICE", + "members": [ + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "//" + }, + { + "type": "PATTERN", + "value": "(\\\\(.|\\r?\\n)|[^\\\\\\n])*" + } + ] + }, + { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "/*" + }, + { + "type": "PATTERN", + "value": "[^*]*\\*+([^/*][^*]*\\*+)*" + }, + { + "type": "STRING", + "value": "/" + } + ] + } + ] + } + } + }, + "single_python_line": { + "type": "REPEAT1", + "content": { + "type": "IMMEDIATE_TOKEN", + "content": { + "type": "PATTERN", + "value": "[^\\n]" + } + } + }, + "pyfoam_template": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "" + } + ] + }, + "pyfoam_expression": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "|-" + }, + { + "type": "FIELD", + "name": "code_body", + "content": { + "type": "SYMBOL", + "name": "single_python_line" + } + }, + { + "type": "STRING", + "value": "-|" + } + ] + }, + "pyfoam_variable": { + "type": "SEQ", + "members": [ + { + "type": "STRING", + "value": "$$" + }, + { + "type": "FIELD", + "name": "code_body", + "content": { + "type": "SYMBOL", + "name": "single_python_line" + } + }, + { + "type": "STRING", + "value": "\n" + } + ] + } + }, + "extras": [ + { + "type": "PATTERN", + "value": "\\s" + }, + { + "type": "SYMBOL", + "name": "comment" + }, + { + "type": "SYMBOL", + "name": "pyfoam_template" + } + ], + "conflicts": [ + [ + "_statement", + "_non_uniform_list" + ], + [ + "_non_uniform_list" + ], + [ + "dict" + ] + ], + "precedences": [], + "externals": [ + { + "type": "SYMBOL", + "name": "identifier" + }, + { + "type": "SYMBOL", + "name": "boolean" + }, + { + "type": "SYMBOL", + "name": "_eof" + } + ], + "inline": [], + "supertypes": [] +} + diff --git a/vendored_parsers/tree-sitter-foam/src/node-types.json b/vendored_parsers/tree-sitter-foam/src/node-types.json new file mode 100644 index 0000000000..90eb468929 --- /dev/null +++ b/vendored_parsers/tree-sitter-foam/src/node-types.json @@ -0,0 +1,916 @@ +[ + { + "type": "code", + "named": true, + "fields": {}, + "children": { + "multiple": false, + "required": false, + "types": [ + { + "type": "code_body", + "named": true + } + ] + } + }, + { + "type": "code_body", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "string_literal", + "named": true + } + ] + } + }, + { + "type": "comment", + "named": true, + "fields": {} + }, + { + "type": "dict", + "named": true, + "fields": { + "key": { + "multiple": false, + "required": true, + "types": [ + { + "type": "identifier", + "named": true + }, + { + "type": "list", + "named": true + }, + { + "type": "string_literal", + "named": true + } + ] + } + }, + "children": { + "multiple": false, + "required": false, + "types": [ + { + "type": "dict_core", + "named": true + } + ] + } + }, + { + "type": "dict_core", + "named": true, + "fields": { + "dict_body": { + "multiple": true, + "required": true, + "types": [ + { + "type": "(", + "named": false + }, + { + "type": ")", + "named": false + }, + { + "type": ";", + "named": false + }, + { + "type": "boolean", + "named": true + }, + { + "type": "code", + "named": true + }, + { + "type": "dict", + "named": true + }, + { + "type": "dict_headless", + "named": true + }, + { + "type": "dimensions", + "named": true + }, + { + "type": "identifier", + "named": true + }, + { + "type": "key_value", + "named": true + }, + { + "type": "list", + "named": true + }, + { + "type": "macro", + "named": true + }, + { + "type": "number_literal", + "named": true + }, + { + "type": "preproc_call", + "named": true + }, + { + "type": "pyfoam_expression", + "named": true + }, + { + "type": "pyfoam_variable", + "named": true + }, + { + "type": "string_literal", + "named": true + }, + { + "type": "{", + "named": false + }, + { + "type": "}", + "named": false + } + ] + }, + "item": { + "multiple": true, + "required": false, + "types": [ + { + "type": "boolean", + "named": true + }, + { + "type": "code", + "named": true + }, + { + "type": "dict", + "named": true + }, + { + "type": "dict_headless", + "named": true + }, + { + "type": "dimensions", + "named": true + }, + { + "type": "identifier", + "named": true + }, + { + "type": "list", + "named": true + }, + { + "type": "macro", + "named": true + }, + { + "type": "number_literal", + "named": true + }, + { + "type": "preproc_call", + "named": true + }, + { + "type": "pyfoam_expression", + "named": true + }, + { + "type": "string_literal", + "named": true + } + ] + }, + "size": { + "multiple": true, + "required": false, + "types": [ + { + "type": "number_literal", + "named": true + } + ] + }, + "type": { + "multiple": true, + "required": false, + "types": [ + { + "type": "identifier", + "named": true + } + ] + } + } + }, + { + "type": "dict_headless", + "named": true, + "fields": { + "dict_body": { + "multiple": true, + "required": false, + "types": [ + { + "type": "(", + "named": false + }, + { + "type": ")", + "named": false + }, + { + "type": ";", + "named": false + }, + { + "type": "boolean", + "named": true + }, + { + "type": "code", + "named": true + }, + { + "type": "dict", + "named": true + }, + { + "type": "dict_headless", + "named": true + }, + { + "type": "dimensions", + "named": true + }, + { + "type": "identifier", + "named": true + }, + { + "type": "key_value", + "named": true + }, + { + "type": "list", + "named": true + }, + { + "type": "macro", + "named": true + }, + { + "type": "number_literal", + "named": true + }, + { + "type": "preproc_call", + "named": true + }, + { + "type": "pyfoam_expression", + "named": true + }, + { + "type": "pyfoam_variable", + "named": true + }, + { + "type": "string_literal", + "named": true + }, + { + "type": "{", + "named": false + }, + { + "type": "}", + "named": false + } + ] + }, + "item": { + "multiple": true, + "required": false, + "types": [ + { + "type": "boolean", + "named": true + }, + { + "type": "code", + "named": true + }, + { + "type": "dict", + "named": true + }, + { + "type": "dict_headless", + "named": true + }, + { + "type": "dimensions", + "named": true + }, + { + "type": "identifier", + "named": true + }, + { + "type": "list", + "named": true + }, + { + "type": "macro", + "named": true + }, + { + "type": "number_literal", + "named": true + }, + { + "type": "preproc_call", + "named": true + }, + { + "type": "pyfoam_expression", + "named": true + }, + { + "type": "string_literal", + "named": true + } + ] + }, + "size": { + "multiple": true, + "required": false, + "types": [ + { + "type": "number_literal", + "named": true + } + ] + }, + "type": { + "multiple": true, + "required": false, + "types": [ + { + "type": "identifier", + "named": true + } + ] + } + } + }, + { + "type": "dimensions", + "named": true, + "fields": { + "dimension": { + "multiple": true, + "required": false, + "types": [ + { + "type": "identifier", + "named": true + }, + { + "type": "number_literal", + "named": true + } + ] + } + } + }, + { + "type": "foam", + "named": true, + "fields": { + "item": { + "multiple": true, + "required": false, + "types": [ + { + "type": "boolean", + "named": true + }, + { + "type": "code", + "named": true + }, + { + "type": "dict", + "named": true + }, + { + "type": "dict_headless", + "named": true + }, + { + "type": "dimensions", + "named": true + }, + { + "type": "identifier", + "named": true + }, + { + "type": "list", + "named": true + }, + { + "type": "macro", + "named": true + }, + { + "type": "number_literal", + "named": true + }, + { + "type": "preproc_call", + "named": true + }, + { + "type": "pyfoam_expression", + "named": true + }, + { + "type": "string_literal", + "named": true + } + ] + }, + "size": { + "multiple": true, + "required": false, + "types": [ + { + "type": "number_literal", + "named": true + } + ] + }, + "type": { + "multiple": true, + "required": false, + "types": [ + { + "type": "identifier", + "named": true + } + ] + } + }, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "dict", + "named": true + }, + { + "type": "key_value", + "named": true + }, + { + "type": "number_literal", + "named": true + }, + { + "type": "preproc_call", + "named": true + }, + { + "type": "pyfoam_variable", + "named": true + } + ] + } + }, + { + "type": "key_value", + "named": true, + "fields": { + "keyword": { + "multiple": false, + "required": true, + "types": [ + { + "type": "identifier", + "named": true + }, + { + "type": "string_literal", + "named": true + } + ] + }, + "value": { + "multiple": true, + "required": false, + "types": [ + { + "type": "boolean", + "named": true + }, + { + "type": "code", + "named": true + }, + { + "type": "dict", + "named": true + }, + { + "type": "dimensions", + "named": true + }, + { + "type": "identifier", + "named": true + }, + { + "type": "list", + "named": true + }, + { + "type": "macro", + "named": true + }, + { + "type": "number_literal", + "named": true + }, + { + "type": "preproc_call", + "named": true + }, + { + "type": "pyfoam_expression", + "named": true + }, + { + "type": "string_literal", + "named": true + } + ] + } + } + }, + { + "type": "list", + "named": true, + "fields": { + "item": { + "multiple": true, + "required": false, + "types": [ + { + "type": "boolean", + "named": true + }, + { + "type": "code", + "named": true + }, + { + "type": "dict", + "named": true + }, + { + "type": "dict_headless", + "named": true + }, + { + "type": "dimensions", + "named": true + }, + { + "type": "identifier", + "named": true + }, + { + "type": "list", + "named": true + }, + { + "type": "macro", + "named": true + }, + { + "type": "number_literal", + "named": true + }, + { + "type": "preproc_call", + "named": true + }, + { + "type": "pyfoam_expression", + "named": true + }, + { + "type": "string_literal", + "named": true + } + ] + }, + "size": { + "multiple": false, + "required": false, + "types": [ + { + "type": "number_literal", + "named": true + } + ] + }, + "type": { + "multiple": false, + "required": false, + "types": [ + { + "type": "identifier", + "named": true + } + ] + } + } + }, + { + "type": "macro", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": true, + "types": [ + { + "type": "identifier", + "named": true + }, + { + "type": "prev_scope", + "named": true + } + ] + } + }, + { + "type": "preproc_call", + "named": true, + "fields": { + "argument": { + "multiple": true, + "required": false, + "types": [ + { + "type": "dict_headless", + "named": true + }, + { + "type": "identifier", + "named": true + }, + { + "type": "macro", + "named": true + }, + { + "type": "preproc_call", + "named": true + }, + { + "type": "string_literal", + "named": true + } + ] + }, + "directive": { + "multiple": true, + "required": true, + "types": [ + { + "type": "#", + "named": false + }, + { + "type": "identifier", + "named": true + } + ] + } + } + }, + { + "type": "pyfoam_expression", + "named": true, + "fields": { + "code_body": { + "multiple": false, + "required": true, + "types": [ + { + "type": "single_python_line", + "named": true + } + ] + } + } + }, + { + "type": "pyfoam_template", + "named": true, + "fields": { + "code_body": { + "multiple": false, + "required": true, + "types": [ + { + "type": "single_python_line", + "named": true + } + ] + } + } + }, + { + "type": "pyfoam_variable", + "named": true, + "fields": { + "code_body": { + "multiple": false, + "required": true, + "types": [ + { + "type": "single_python_line", + "named": true + } + ] + } + } + }, + { + "type": "single_python_line", + "named": true, + "fields": {} + }, + { + "type": "string_literal", + "named": true, + "fields": {}, + "children": { + "multiple": true, + "required": false, + "types": [ + { + "type": "escape_sequence", + "named": true + } + ] + } + }, + { + "type": "\n", + "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": "", + [anon_sym_PIPE_DASH] = "|-", + [anon_sym_DASH_PIPE] = "-|", + [anon_sym_DOLLAR_DOLLAR] = "$$", + [anon_sym_LF] = "\n", + [sym_identifier] = "identifier", + [sym_boolean] = "boolean", + [sym__eof] = "_eof", + [sym_foam] = "foam", + [sym__statement] = "_statement", + [sym_dict] = "dict", + [sym_dict_core] = "dict_core", + [sym_key_value] = "key_value", + [sym_preproc_call] = "preproc_call", + [sym__special_preproc_call] = "_special_preproc_call", + [sym__cond_preproc_call] = "_cond_preproc_call", + [sym__generic_preproc_call] = "_generic_preproc_call", + [sym__value] = "_value", + [sym_dimensions] = "dimensions", + [sym_list] = "list", + [sym__uniform_list] = "_uniform_list", + [sym__non_uniform_list] = "_non_uniform_list", + [sym__list_item] = "_list_item", + [sym_dict_headless] = "dict_headless", + [sym_code] = "code", + [sym_code_body] = "code_body", + [sym_macro] = "macro", + [sym__macro_braces] = "_macro_braces", + [sym__macro_no_braces] = "_macro_no_braces", + [sym_string_literal] = "string_literal", + [sym_comment] = "comment", + [sym_single_python_line] = "single_python_line", + [sym_pyfoam_template] = "pyfoam_template", + [sym_pyfoam_expression] = "pyfoam_expression", + [sym_pyfoam_variable] = "pyfoam_variable", + [aux_sym_foam_repeat1] = "foam_repeat1", + [aux_sym_dict_core_repeat1] = "dict_core_repeat1", + [aux_sym_key_value_repeat1] = "key_value_repeat1", + [aux_sym_dimensions_repeat1] = "dimensions_repeat1", + [aux_sym__non_uniform_list_repeat1] = "_non_uniform_list_repeat1", + [aux_sym_code_body_repeat1] = "code_body_repeat1", + [aux_sym_string_literal_repeat1] = "string_literal_repeat1", + [aux_sym_single_python_line_repeat1] = "single_python_line_repeat1", +}; + +static const TSSymbol ts_symbol_map[] = { + [ts_builtin_sym_end] = ts_builtin_sym_end, + [anon_sym_LBRACE] = anon_sym_LBRACE, + [anon_sym_RBRACE] = anon_sym_RBRACE2, + [anon_sym_SEMI] = anon_sym_SEMI, + [aux_sym__special_preproc_call_token1] = aux_sym__special_preproc_call_token1, + [aux_sym__special_preproc_call_token2] = aux_sym__special_preproc_call_token2, + [aux_sym__cond_preproc_call_token1] = aux_sym__cond_preproc_call_token1, + [anon_sym_POUND] = anon_sym_POUND, + [anon_sym_LBRACK] = anon_sym_LBRACK, + [anon_sym_RBRACK] = anon_sym_RBRACK, + [anon_sym_LPAREN] = anon_sym_LPAREN, + [anon_sym_RPAREN] = anon_sym_RPAREN, + [anon_sym_POUND_LBRACE] = anon_sym_POUND_LBRACE, + [anon_sym_POUND_RBRACE] = anon_sym_POUND_RBRACE, + [aux_sym_code_body_token1] = aux_sym_code_body_token1, + [anon_sym_DOLLAR_LBRACE] = anon_sym_DOLLAR_LBRACE, + [anon_sym_RBRACE2] = anon_sym_RBRACE, + [anon_sym_DOLLAR] = anon_sym_DOLLAR, + [sym_prev_scope] = sym_prev_scope, + [sym_number_literal] = sym_number_literal, + [anon_sym_L_DQUOTE] = anon_sym_L_DQUOTE, + [anon_sym_u_DQUOTE] = anon_sym_u_DQUOTE, + [anon_sym_U_DQUOTE] = anon_sym_U_DQUOTE, + [anon_sym_u8_DQUOTE] = anon_sym_u8_DQUOTE, + [anon_sym_DQUOTE] = anon_sym_DQUOTE, + [aux_sym_string_literal_token1] = aux_sym_string_literal_token1, + [sym_escape_sequence] = sym_escape_sequence, + [aux_sym_comment_token1] = aux_sym_comment_token1, + [aux_sym_single_python_line_token1] = aux_sym_single_python_line_token1, + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = anon_sym_LT_BANG_DASH_DASH_LPAREN, + [anon_sym_RPAREN_DASH_DASH_GT] = anon_sym_RPAREN_DASH_DASH_GT, + [anon_sym_PIPE_DASH] = anon_sym_PIPE_DASH, + [anon_sym_DASH_PIPE] = anon_sym_DASH_PIPE, + [anon_sym_DOLLAR_DOLLAR] = anon_sym_DOLLAR_DOLLAR, + [anon_sym_LF] = anon_sym_LF, + [sym_identifier] = sym_identifier, + [sym_boolean] = sym_boolean, + [sym__eof] = sym__eof, + [sym_foam] = sym_foam, + [sym__statement] = sym__statement, + [sym_dict] = sym_dict, + [sym_dict_core] = sym_dict_core, + [sym_key_value] = sym_key_value, + [sym_preproc_call] = sym_preproc_call, + [sym__special_preproc_call] = sym__special_preproc_call, + [sym__cond_preproc_call] = sym__cond_preproc_call, + [sym__generic_preproc_call] = sym__generic_preproc_call, + [sym__value] = sym__value, + [sym_dimensions] = sym_dimensions, + [sym_list] = sym_list, + [sym__uniform_list] = sym__uniform_list, + [sym__non_uniform_list] = sym__non_uniform_list, + [sym__list_item] = sym__list_item, + [sym_dict_headless] = sym_dict_headless, + [sym_code] = sym_code, + [sym_code_body] = sym_code_body, + [sym_macro] = sym_macro, + [sym__macro_braces] = sym__macro_braces, + [sym__macro_no_braces] = sym__macro_no_braces, + [sym_string_literal] = sym_string_literal, + [sym_comment] = sym_comment, + [sym_single_python_line] = sym_single_python_line, + [sym_pyfoam_template] = sym_pyfoam_template, + [sym_pyfoam_expression] = sym_pyfoam_expression, + [sym_pyfoam_variable] = sym_pyfoam_variable, + [aux_sym_foam_repeat1] = aux_sym_foam_repeat1, + [aux_sym_dict_core_repeat1] = aux_sym_dict_core_repeat1, + [aux_sym_key_value_repeat1] = aux_sym_key_value_repeat1, + [aux_sym_dimensions_repeat1] = aux_sym_dimensions_repeat1, + [aux_sym__non_uniform_list_repeat1] = aux_sym__non_uniform_list_repeat1, + [aux_sym_code_body_repeat1] = aux_sym_code_body_repeat1, + [aux_sym_string_literal_repeat1] = aux_sym_string_literal_repeat1, + [aux_sym_single_python_line_repeat1] = aux_sym_single_python_line_repeat1, +}; + +static const TSSymbolMetadata ts_symbol_metadata[] = { + [ts_builtin_sym_end] = { + .visible = false, + .named = true, + }, + [anon_sym_LBRACE] = { + .visible = true, + .named = false, + }, + [anon_sym_RBRACE] = { + .visible = true, + .named = false, + }, + [anon_sym_SEMI] = { + .visible = true, + .named = false, + }, + [aux_sym__special_preproc_call_token1] = { + .visible = false, + .named = false, + }, + [aux_sym__special_preproc_call_token2] = { + .visible = false, + .named = false, + }, + [aux_sym__cond_preproc_call_token1] = { + .visible = false, + .named = false, + }, + [anon_sym_POUND] = { + .visible = true, + .named = false, + }, + [anon_sym_LBRACK] = { + .visible = true, + .named = false, + }, + [anon_sym_RBRACK] = { + .visible = true, + .named = false, + }, + [anon_sym_LPAREN] = { + .visible = true, + .named = false, + }, + [anon_sym_RPAREN] = { + .visible = true, + .named = false, + }, + [anon_sym_POUND_LBRACE] = { + .visible = true, + .named = false, + }, + [anon_sym_POUND_RBRACE] = { + .visible = true, + .named = false, + }, + [aux_sym_code_body_token1] = { + .visible = false, + .named = false, + }, + [anon_sym_DOLLAR_LBRACE] = { + .visible = true, + .named = false, + }, + [anon_sym_RBRACE2] = { + .visible = true, + .named = false, + }, + [anon_sym_DOLLAR] = { + .visible = true, + .named = false, + }, + [sym_prev_scope] = { + .visible = true, + .named = true, + }, + [sym_number_literal] = { + .visible = true, + .named = true, + }, + [anon_sym_L_DQUOTE] = { + .visible = true, + .named = false, + }, + [anon_sym_u_DQUOTE] = { + .visible = true, + .named = false, + }, + [anon_sym_U_DQUOTE] = { + .visible = true, + .named = false, + }, + [anon_sym_u8_DQUOTE] = { + .visible = true, + .named = false, + }, + [anon_sym_DQUOTE] = { + .visible = true, + .named = false, + }, + [aux_sym_string_literal_token1] = { + .visible = false, + .named = false, + }, + [sym_escape_sequence] = { + .visible = true, + .named = true, + }, + [aux_sym_comment_token1] = { + .visible = false, + .named = false, + }, + [aux_sym_single_python_line_token1] = { + .visible = false, + .named = false, + }, + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = { + .visible = true, + .named = false, + }, + [anon_sym_RPAREN_DASH_DASH_GT] = { + .visible = true, + .named = false, + }, + [anon_sym_PIPE_DASH] = { + .visible = true, + .named = false, + }, + [anon_sym_DASH_PIPE] = { + .visible = true, + .named = false, + }, + [anon_sym_DOLLAR_DOLLAR] = { + .visible = true, + .named = false, + }, + [anon_sym_LF] = { + .visible = true, + .named = false, + }, + [sym_identifier] = { + .visible = true, + .named = true, + }, + [sym_boolean] = { + .visible = true, + .named = true, + }, + [sym__eof] = { + .visible = false, + .named = true, + }, + [sym_foam] = { + .visible = true, + .named = true, + }, + [sym__statement] = { + .visible = false, + .named = true, + }, + [sym_dict] = { + .visible = true, + .named = true, + }, + [sym_dict_core] = { + .visible = true, + .named = true, + }, + [sym_key_value] = { + .visible = true, + .named = true, + }, + [sym_preproc_call] = { + .visible = true, + .named = true, + }, + [sym__special_preproc_call] = { + .visible = false, + .named = true, + }, + [sym__cond_preproc_call] = { + .visible = false, + .named = true, + }, + [sym__generic_preproc_call] = { + .visible = false, + .named = true, + }, + [sym__value] = { + .visible = false, + .named = true, + }, + [sym_dimensions] = { + .visible = true, + .named = true, + }, + [sym_list] = { + .visible = true, + .named = true, + }, + [sym__uniform_list] = { + .visible = false, + .named = true, + }, + [sym__non_uniform_list] = { + .visible = false, + .named = true, + }, + [sym__list_item] = { + .visible = false, + .named = true, + }, + [sym_dict_headless] = { + .visible = true, + .named = true, + }, + [sym_code] = { + .visible = true, + .named = true, + }, + [sym_code_body] = { + .visible = true, + .named = true, + }, + [sym_macro] = { + .visible = true, + .named = true, + }, + [sym__macro_braces] = { + .visible = false, + .named = true, + }, + [sym__macro_no_braces] = { + .visible = false, + .named = true, + }, + [sym_string_literal] = { + .visible = true, + .named = true, + }, + [sym_comment] = { + .visible = true, + .named = true, + }, + [sym_single_python_line] = { + .visible = true, + .named = true, + }, + [sym_pyfoam_template] = { + .visible = true, + .named = true, + }, + [sym_pyfoam_expression] = { + .visible = true, + .named = true, + }, + [sym_pyfoam_variable] = { + .visible = true, + .named = true, + }, + [aux_sym_foam_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_dict_core_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_key_value_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_dimensions_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym__non_uniform_list_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_code_body_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_string_literal_repeat1] = { + .visible = false, + .named = false, + }, + [aux_sym_single_python_line_repeat1] = { + .visible = false, + .named = false, + }, +}; + +enum { + field_argument = 1, + field_code_body = 2, + field_dict_body = 3, + field_dimension = 4, + field_directive = 5, + field_item = 6, + field_key = 7, + field_keyword = 8, + field_size = 9, + field_type = 10, + field_value = 11, +}; + +static const char * const ts_field_names[] = { + [0] = NULL, + [field_argument] = "argument", + [field_code_body] = "code_body", + [field_dict_body] = "dict_body", + [field_dimension] = "dimension", + [field_directive] = "directive", + [field_item] = "item", + [field_key] = "key", + [field_keyword] = "keyword", + [field_size] = "size", + [field_type] = "type", + [field_value] = "value", +}; + +static const TSFieldMapSlice ts_field_map_slices[PRODUCTION_ID_COUNT] = { + [1] = {.index = 0, .length = 1}, + [2] = {.index = 1, .length = 3}, + [3] = {.index = 4, .length = 1}, + [4] = {.index = 5, .length = 2}, + [5] = {.index = 7, .length = 2}, + [6] = {.index = 9, .length = 1}, + [7] = {.index = 10, .length = 6}, + [8] = {.index = 16, .length = 1}, + [9] = {.index = 17, .length = 1}, + [10] = {.index = 18, .length = 4}, + [11] = {.index = 22, .length = 1}, + [12] = {.index = 23, .length = 1}, + [13] = {.index = 24, .length = 2}, + [14] = {.index = 26, .length = 3}, + [15] = {.index = 29, .length = 3}, + [16] = {.index = 32, .length = 1}, + [17] = {.index = 33, .length = 1}, + [18] = {.index = 34, .length = 1}, + [19] = {.index = 35, .length = 2}, + [20] = {.index = 37, .length = 2}, + [21] = {.index = 39, .length = 2}, + [22] = {.index = 41, .length = 4}, + [23] = {.index = 45, .length = 2}, + [24] = {.index = 47, .length = 3}, +}; + +static const TSFieldMapEntry ts_field_map_entries[] = { + [0] = + {field_directive, 0}, + [1] = + {field_item, 0, .inherited = true}, + {field_size, 0, .inherited = true}, + {field_type, 0, .inherited = true}, + [4] = + {field_argument, 0, .inherited = true}, + [5] = + {field_argument, 0, .inherited = true}, + {field_directive, 0, .inherited = true}, + [7] = + {field_item, 0, .inherited = true}, + {field_size, 0, .inherited = true}, + [9] = + {field_keyword, 0}, + [10] = + {field_item, 0, .inherited = true}, + {field_item, 1, .inherited = true}, + {field_size, 0, .inherited = true}, + {field_size, 1, .inherited = true}, + {field_type, 0, .inherited = true}, + {field_type, 1, .inherited = true}, + [16] = + {field_code_body, 1}, + [17] = + {field_key, 0}, + [18] = + {field_dict_body, 0}, + {field_item, 0, .inherited = true}, + {field_size, 0, .inherited = true}, + {field_type, 0, .inherited = true}, + [22] = + {field_dimension, 0}, + [23] = + {field_type, 0}, + [24] = + {field_keyword, 0}, + {field_value, 1}, + [26] = + {field_argument, 1}, + {field_argument, 2}, + {field_directive, 0}, + [29] = + {field_argument, 2}, + {field_directive, 0}, + {field_directive, 1}, + [32] = + {field_item, 1}, + [33] = + {field_size, 0}, + [34] = + {field_dimension, 1, .inherited = true}, + [35] = + {field_dimension, 0, .inherited = true}, + {field_dimension, 1, .inherited = true}, + [37] = + {field_item, 2}, + {field_type, 0}, + [39] = + {field_size, 1}, + {field_type, 0}, + [41] = + {field_dict_body, 1}, + {field_item, 1, .inherited = true}, + {field_size, 1, .inherited = true}, + {field_type, 1, .inherited = true}, + [45] = + {field_item, 2}, + {field_size, 0}, + [47] = + {field_item, 3}, + {field_size, 1}, + {field_type, 0}, +}; + +static const TSSymbol ts_alias_sequences[PRODUCTION_ID_COUNT][MAX_ALIAS_SEQUENCE_LENGTH] = { + [0] = {0}, +}; + +static const uint16_t ts_non_terminal_alias_map[] = { + 0, +}; + +static const TSStateId ts_primary_state_ids[STATE_COUNT] = { + [0] = 0, + [1] = 1, + [2] = 2, + [3] = 3, + [4] = 4, + [5] = 5, + [6] = 2, + [7] = 3, + [8] = 8, + [9] = 2, + [10] = 10, + [11] = 11, + [12] = 12, + [13] = 13, + [14] = 4, + [15] = 10, + [16] = 3, + [17] = 17, + [18] = 11, + [19] = 19, + [20] = 2, + [21] = 5, + [22] = 3, + [23] = 10, + [24] = 11, + [25] = 13, + [26] = 12, + [27] = 11, + [28] = 28, + [29] = 19, + [30] = 17, + [31] = 31, + [32] = 32, + [33] = 33, + [34] = 31, + [35] = 32, + [36] = 32, + [37] = 33, + [38] = 32, + [39] = 39, + [40] = 40, + [41] = 40, + [42] = 42, + [43] = 42, + [44] = 42, + [45] = 42, + [46] = 46, + [47] = 47, + [48] = 46, + [49] = 49, + [50] = 50, + [51] = 46, + [52] = 47, + [53] = 46, + [54] = 47, + [55] = 47, + [56] = 56, + [57] = 57, + [58] = 58, + [59] = 59, + [60] = 59, + [61] = 59, + [62] = 62, + [63] = 59, + [64] = 59, + [65] = 65, + [66] = 59, + [67] = 62, + [68] = 65, + [69] = 69, + [70] = 58, + [71] = 59, + [72] = 69, + [73] = 59, + [74] = 74, + [75] = 75, + [76] = 76, + [77] = 77, + [78] = 78, + [79] = 79, + [80] = 80, + [81] = 81, + [82] = 82, + [83] = 83, + [84] = 84, + [85] = 85, + [86] = 86, + [87] = 87, + [88] = 88, + [89] = 89, + [90] = 90, + [91] = 91, + [92] = 92, + [93] = 83, + [94] = 94, + [95] = 95, + [96] = 96, + [97] = 97, + [98] = 98, + [99] = 99, + [100] = 100, + [101] = 101, + [102] = 102, + [103] = 103, + [104] = 104, + [105] = 105, + [106] = 106, + [107] = 107, + [108] = 108, + [109] = 109, + [110] = 110, + [111] = 111, + [112] = 112, + [113] = 113, + [114] = 113, + [115] = 115, + [116] = 116, + [117] = 116, + [118] = 118, + [119] = 119, + [120] = 112, + [121] = 81, + [122] = 122, + [123] = 86, + [124] = 109, + [125] = 94, + [126] = 78, + [127] = 110, + [128] = 128, + [129] = 98, + [130] = 130, + [131] = 131, + [132] = 79, + [133] = 85, + [134] = 134, + [135] = 77, + [136] = 80, + [137] = 89, + [138] = 90, + [139] = 83, + [140] = 101, + [141] = 107, + [142] = 86, + [143] = 81, + [144] = 103, + [145] = 91, + [146] = 88, + [147] = 87, + [148] = 83, + [149] = 96, + [150] = 108, + [151] = 74, + [152] = 152, + [153] = 153, + [154] = 76, + [155] = 155, + [156] = 156, + [157] = 75, + [158] = 158, + [159] = 159, + [160] = 94, + [161] = 83, + [162] = 109, + [163] = 90, + [164] = 78, + [165] = 83, + [166] = 131, + [167] = 77, + [168] = 107, + [169] = 88, + [170] = 79, + [171] = 110, + [172] = 128, + [173] = 103, + [174] = 98, + [175] = 74, + [176] = 81, + [177] = 89, + [178] = 91, + [179] = 96, + [180] = 85, + [181] = 101, + [182] = 80, + [183] = 108, + [184] = 86, + [185] = 130, + [186] = 87, + [187] = 156, + [188] = 159, + [189] = 76, + [190] = 158, + [191] = 191, + [192] = 152, + [193] = 75, + [194] = 194, + [195] = 195, + [196] = 194, + [197] = 195, + [198] = 195, + [199] = 195, + [200] = 194, + [201] = 194, + [202] = 202, + [203] = 202, + [204] = 204, + [205] = 205, + [206] = 98, + [207] = 207, + [208] = 91, + [209] = 209, + [210] = 210, + [211] = 209, + [212] = 210, + [213] = 112, + [214] = 214, + [215] = 214, + [216] = 216, + [217] = 216, + [218] = 210, + [219] = 210, + [220] = 209, + [221] = 221, + [222] = 210, + [223] = 209, + [224] = 224, + [225] = 209, + [226] = 226, + [227] = 227, + [228] = 227, + [229] = 229, + [230] = 230, + [231] = 231, + [232] = 229, + [233] = 226, + [234] = 116, + [235] = 235, + [236] = 229, + [237] = 237, + [238] = 91, + [239] = 231, + [240] = 226, + [241] = 98, + [242] = 86, + [243] = 95, + [244] = 109, + [245] = 79, + [246] = 78, + [247] = 77, + [248] = 248, + [249] = 80, + [250] = 81, + [251] = 251, + [252] = 83, + [253] = 83, + [254] = 85, + [255] = 248, + [256] = 251, + [257] = 84, + [258] = 106, + [259] = 110, + [260] = 260, + [261] = 248, + [262] = 92, + [263] = 88, + [264] = 104, + [265] = 100, + [266] = 87, + [267] = 108, + [268] = 96, + [269] = 101, + [270] = 103, + [271] = 260, + [272] = 74, + [273] = 260, + [274] = 248, + [275] = 94, + [276] = 90, + [277] = 113, + [278] = 89, + [279] = 107, + [280] = 260, + [281] = 251, + [282] = 282, + [283] = 283, + [284] = 75, + [285] = 285, + [286] = 286, + [287] = 111, + [288] = 105, + [289] = 102, + [290] = 290, + [291] = 291, + [292] = 283, + [293] = 293, + [294] = 76, + [295] = 290, + [296] = 99, + [297] = 297, + [298] = 286, + [299] = 82, + [300] = 297, + [301] = 293, + [302] = 290, + [303] = 119, + [304] = 304, + [305] = 305, + [306] = 306, + [307] = 293, + [308] = 282, + [309] = 283, + [310] = 293, + [311] = 305, + [312] = 290, + [313] = 286, + [314] = 297, + [315] = 286, + [316] = 316, + [317] = 297, + [318] = 306, + [319] = 282, + [320] = 286, + [321] = 286, + [322] = 282, + [323] = 286, + [324] = 324, + [325] = 291, + [326] = 324, + [327] = 327, + [328] = 283, + [329] = 329, + [330] = 306, + [331] = 97, + [332] = 316, + [333] = 333, + [334] = 306, + [335] = 286, + [336] = 282, + [337] = 337, + [338] = 338, +}; + +static bool ts_lex(TSLexer *lexer, TSStateId state) { + START_LEXER(); + eof = lexer->eof(lexer); + switch (state) { + case 0: + if (eof) ADVANCE(69); + if (lookahead == '"') ADVANCE(120); + if (lookahead == '#') ADVANCE(77); + if (lookahead == '$') ADVANCE(102); + if (lookahead == '(') ADVANCE(80); + if (lookahead == ')') ADVANCE(81); + if (lookahead == '+') ADVANCE(35); + if (lookahead == '-') ADVANCE(34); + if (lookahead == '.') ADVANCE(106); + if (lookahead == '/') ADVANCE(103); + if (lookahead == ';') ADVANCE(72); + if (lookahead == '<') ADVANCE(10); + if (lookahead == 'L') ADVANCE(13); + if (lookahead == 'U') ADVANCE(14); + if (lookahead == '[') ADVANCE(78); + if (lookahead == '\\') ADVANCE(39); + if (lookahead == ']') ADVANCE(79); + if (lookahead == 'u') ADVANCE(15); + if (lookahead == '{') ADVANCE(70); + if (lookahead == '|') ADVANCE(28); + if (lookahead == '}') ADVANCE(101); + if (lookahead == '!' || + lookahead == ':') ADVANCE(105); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(67) + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(108); + END_STATE(); + case 1: + if (lookahead == '\n') ADVANCE(26); + if (lookahead == '*') ADVANCE(17); + if (lookahead != 0) ADVANCE(18); + END_STATE(); + case 2: + if (lookahead == '\n') ADVANCE(138); + if (lookahead == '\r') ADVANCE(140); + if (lookahead != 0) ADVANCE(136); + END_STATE(); + case 3: + if (lookahead == '\n') SKIP(3) + if (lookahead == '"') ADVANCE(121); + if (lookahead == '#') ADVANCE(52); + if (lookahead == '/') ADVANCE(91); + if (lookahead == '<') ADVANCE(88); + if (lookahead == 'L') ADVANCE(95); + if (lookahead == 'U') ADVANCE(96); + if (lookahead == 'u') ADVANCE(97); + if (lookahead == '\t' || + lookahead == '\r' || + lookahead == ' ') ADVANCE(89); + if (lookahead != 0) ADVANCE(94); + END_STATE(); + case 4: + if (lookahead == '\n') SKIP(11) + if (lookahead == '"') ADVANCE(120); + if (lookahead == '/') ADVANCE(124); + if (lookahead == '<') ADVANCE(122); + if (lookahead == '\\') ADVANCE(39); + if (lookahead == '\t' || + lookahead == '\r' || + lookahead == ' ') ADVANCE(129); + if (lookahead != 0) ADVANCE(130); + END_STATE(); + case 5: + if (lookahead == '\n') ADVANCE(153); + if (lookahead == '/') ADVANCE(24); + if (lookahead == '<') ADVANCE(10); + if (lookahead == '\t' || + lookahead == '\r' || + lookahead == ' ') SKIP(5) + END_STATE(); + case 6: + if (lookahead == '\n') ADVANCE(153); + if (lookahead == '/') ADVANCE(144); + if (lookahead == '<') ADVANCE(143); + if (lookahead == '\t' || + lookahead == '\r' || + lookahead == ' ') ADVANCE(142); + if (lookahead != 0) ADVANCE(142); + END_STATE(); + case 7: + if (lookahead == '\n') SKIP(37) + if (lookahead == '/') ADVANCE(144); + if (lookahead == '<') ADVANCE(143); + if (lookahead == '\t' || + lookahead == '\r' || + lookahead == ' ') ADVANCE(142); + if (lookahead != 0) ADVANCE(142); + END_STATE(); + case 8: + if (lookahead == '\n') SKIP(23) + if (lookahead == ')') ADVANCE(145); + if (lookahead == '/') ADVANCE(144); + if (lookahead == '<') ADVANCE(143); + if (lookahead == '\t' || + lookahead == '\r' || + lookahead == ' ') ADVANCE(142); + if (lookahead != 0) ADVANCE(142); + END_STATE(); + case 9: + if (lookahead == '\n') SKIP(31) + if (lookahead == '-') ADVANCE(146); + if (lookahead == '/') ADVANCE(144); + if (lookahead == '<') ADVANCE(143); + if (lookahead == '\t' || + lookahead == '\r' || + lookahead == ' ') ADVANCE(142); + if (lookahead != 0) ADVANCE(142); + END_STATE(); + case 10: + if (lookahead == '!') ADVANCE(32); + END_STATE(); + case 11: + if (lookahead == '"') ADVANCE(120); + if (lookahead == '/') ADVANCE(24); + if (lookahead == '<') ADVANCE(10); + if (lookahead == '\\') ADVANCE(39); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(11) + END_STATE(); + case 12: + if (lookahead == '"') ADVANCE(26); + if (lookahead == '*') ADVANCE(17); + if (lookahead == '\\') ADVANCE(1); + if (lookahead != 0) ADVANCE(18); + END_STATE(); + case 13: + if (lookahead == '"') ADVANCE(112); + END_STATE(); + case 14: + if (lookahead == '"') ADVANCE(116); + END_STATE(); + case 15: + if (lookahead == '"') ADVANCE(114); + if (lookahead == '8') ADVANCE(16); + END_STATE(); + case 16: + if (lookahead == '"') ADVANCE(118); + END_STATE(); + case 17: + if (lookahead == '"') ADVANCE(85); + if (lookahead == '*') ADVANCE(17); + if (lookahead == '/') ADVANCE(137); + if (lookahead == '\\') ADVANCE(1); + if (lookahead != 0) ADVANCE(18); + END_STATE(); + case 18: + if (lookahead == '"') ADVANCE(85); + if (lookahead == '*') ADVANCE(17); + if (lookahead == '\\') ADVANCE(1); + if (lookahead != 0) ADVANCE(18); + END_STATE(); + case 19: + if (lookahead == '"') ADVANCE(94); + if (lookahead == '\\') ADVANCE(65); + if (lookahead != 0) ADVANCE(19); + END_STATE(); + case 20: + if (lookahead == '#') ADVANCE(51); + if (lookahead == ')') ADVANCE(33); + if (lookahead == '/') ADVANCE(24); + if (lookahead == '<') ADVANCE(10); + if (lookahead == '}') ADVANCE(101); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(21) + END_STATE(); + case 21: + if (lookahead == '#') ADVANCE(51); + if (lookahead == ')') ADVANCE(33); + if (lookahead == '/') ADVANCE(24); + if (lookahead == '<') ADVANCE(10); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(21) + END_STATE(); + case 22: + if (lookahead == '(') ADVANCE(147); + END_STATE(); + case 23: + if (lookahead == ')') ADVANCE(33); + if (lookahead == '/') ADVANCE(24); + if (lookahead == '<') ADVANCE(10); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(23) + END_STATE(); + case 24: + if (lookahead == '*') ADVANCE(26); + if (lookahead == '/') ADVANCE(138); + END_STATE(); + case 25: + if (lookahead == '*') ADVANCE(25); + if (lookahead == '/') ADVANCE(134); + if (lookahead != 0) ADVANCE(26); + END_STATE(); + case 26: + if (lookahead == '*') ADVANCE(25); + if (lookahead != 0) ADVANCE(26); + END_STATE(); + case 27: + if (lookahead == '*') ADVANCE(84); + if (lookahead == '\n' || + lookahead == '{' || + lookahead == '}') ADVANCE(26); + if (lookahead != 0) ADVANCE(85); + END_STATE(); + case 28: + if (lookahead == '-') ADVANCE(150); + END_STATE(); + case 29: + if (lookahead == '-') ADVANCE(22); + END_STATE(); + case 30: + if (lookahead == '-') ADVANCE(38); + END_STATE(); + case 31: + if (lookahead == '-') ADVANCE(50); + if (lookahead == '/') ADVANCE(24); + if (lookahead == '<') ADVANCE(10); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(31) + END_STATE(); + case 32: + if (lookahead == '-') ADVANCE(29); + END_STATE(); + case 33: + if (lookahead == '-') ADVANCE(30); + END_STATE(); + case 34: + if (lookahead == '.') ADVANCE(55); + if (lookahead == '|') ADVANCE(151); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(108); + END_STATE(); + case 35: + if (lookahead == '.') ADVANCE(55); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(108); + END_STATE(); + case 36: + if (lookahead == '/') ADVANCE(103); + if (lookahead == '<') ADVANCE(10); + if (lookahead == '!' || + lookahead == '.' || + lookahead == ':') ADVANCE(105); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(36) + END_STATE(); + case 37: + if (lookahead == '/') ADVANCE(24); + if (lookahead == '<') ADVANCE(10); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(37) + END_STATE(); + case 38: + if (lookahead == '>') ADVANCE(149); + END_STATE(); + case 39: + if (lookahead == 'U') ADVANCE(63); + if (lookahead == 'u') ADVANCE(59); + if (lookahead == 'x') ADVANCE(57); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(133); + if (lookahead != 0) ADVANCE(131); + END_STATE(); + case 40: + if (lookahead == '\\') ADVANCE(65); + if (lookahead != 0 && + lookahead != '"') ADVANCE(19); + END_STATE(); + case 41: + if (lookahead == 'd') ADVANCE(46); + END_STATE(); + case 42: + if (lookahead == 'e') ADVANCE(48); + END_STATE(); + case 43: + if (lookahead == 'e') ADVANCE(73); + END_STATE(); + case 44: + if (lookahead == 'f') ADVANCE(42); + END_STATE(); + case 45: + if (lookahead == 'f') ADVANCE(74); + END_STATE(); + case 46: + if (lookahead == 'i') ADVANCE(45); + END_STATE(); + case 47: + if (lookahead == 'l') ADVANCE(49); + if (lookahead == 'n') ADVANCE(41); + END_STATE(); + case 48: + if (lookahead == 'q') ADVANCE(75); + END_STATE(); + case 49: + if (lookahead == 's') ADVANCE(43); + END_STATE(); + case 50: + if (lookahead == '|') ADVANCE(151); + END_STATE(); + case 51: + if (lookahead == '}') ADVANCE(83); + END_STATE(); + case 52: + if (lookahead == '}') ADVANCE(83); + if (lookahead != 0 && + lookahead != '\n' && + lookahead != '{') ADVANCE(94); + END_STATE(); + case 53: + if (lookahead == '+' || + lookahead == '-') ADVANCE(54); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(110); + END_STATE(); + case 54: + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(110); + END_STATE(); + case 55: + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(109); + END_STATE(); + case 56: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(131); + END_STATE(); + case 57: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(56); + END_STATE(); + case 58: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(57); + END_STATE(); + case 59: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(58); + END_STATE(); + case 60: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(59); + END_STATE(); + case 61: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(60); + END_STATE(); + case 62: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(61); + END_STATE(); + case 63: + if (('0' <= lookahead && lookahead <= '9') || + ('A' <= lookahead && lookahead <= 'F') || + ('a' <= lookahead && lookahead <= 'f')) ADVANCE(62); + END_STATE(); + case 64: + if (lookahead != 0 && + lookahead != '\n' && + lookahead != '{' && + lookahead != '}') ADVANCE(94); + END_STATE(); + case 65: + if (lookahead != 0 && + lookahead != '\n') ADVANCE(19); + END_STATE(); + case 66: + if (lookahead != 0 && + lookahead != '\r') ADVANCE(138); + if (lookahead == '\r') ADVANCE(141); + END_STATE(); + case 67: + if (eof) ADVANCE(69); + if (lookahead == '"') ADVANCE(120); + if (lookahead == '#') ADVANCE(77); + if (lookahead == '$') ADVANCE(102); + if (lookahead == '(') ADVANCE(80); + if (lookahead == ')') ADVANCE(81); + if (lookahead == '+') ADVANCE(35); + if (lookahead == '-') ADVANCE(34); + if (lookahead == '.') ADVANCE(106); + if (lookahead == '/') ADVANCE(103); + if (lookahead == ';') ADVANCE(72); + if (lookahead == '<') ADVANCE(10); + if (lookahead == 'L') ADVANCE(13); + if (lookahead == 'U') ADVANCE(14); + if (lookahead == '[') ADVANCE(78); + if (lookahead == '\\') ADVANCE(39); + if (lookahead == ']') ADVANCE(79); + if (lookahead == 'u') ADVANCE(15); + if (lookahead == '{') ADVANCE(70); + if (lookahead == '|') ADVANCE(28); + if (lookahead == '}') ADVANCE(71); + if (lookahead == '!' || + lookahead == ':') ADVANCE(105); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(67) + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(108); + END_STATE(); + case 68: + if (eof) ADVANCE(69); + if (lookahead == '"') ADVANCE(120); + if (lookahead == '#') ADVANCE(76); + if (lookahead == '$') ADVANCE(102); + if (lookahead == '(') ADVANCE(80); + if (lookahead == ')') ADVANCE(81); + if (lookahead == '+') ADVANCE(35); + if (lookahead == '-') ADVANCE(34); + if (lookahead == '.') ADVANCE(55); + if (lookahead == '/') ADVANCE(24); + if (lookahead == ';') ADVANCE(72); + if (lookahead == '<') ADVANCE(10); + if (lookahead == 'L') ADVANCE(13); + if (lookahead == 'U') ADVANCE(14); + if (lookahead == '[') ADVANCE(78); + if (lookahead == ']') ADVANCE(79); + if (lookahead == 'u') ADVANCE(15); + if (lookahead == '{') ADVANCE(70); + if (lookahead == '|') ADVANCE(28); + if (lookahead == '}') ADVANCE(71); + if (lookahead == '\t' || + lookahead == '\n' || + lookahead == '\r' || + lookahead == ' ') SKIP(68) + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(108); + END_STATE(); + case 69: + ACCEPT_TOKEN(ts_builtin_sym_end); + END_STATE(); + case 70: + ACCEPT_TOKEN(anon_sym_LBRACE); + END_STATE(); + case 71: + ACCEPT_TOKEN(anon_sym_RBRACE); + END_STATE(); + case 72: + ACCEPT_TOKEN(anon_sym_SEMI); + END_STATE(); + case 73: + ACCEPT_TOKEN(aux_sym__special_preproc_call_token1); + END_STATE(); + case 74: + ACCEPT_TOKEN(aux_sym__special_preproc_call_token2); + END_STATE(); + case 75: + ACCEPT_TOKEN(aux_sym__cond_preproc_call_token1); + END_STATE(); + case 76: + ACCEPT_TOKEN(anon_sym_POUND); + if (lookahead == 'e') ADVANCE(47); + if (lookahead == 'i') ADVANCE(44); + if (lookahead == '{') ADVANCE(82); + END_STATE(); + case 77: + ACCEPT_TOKEN(anon_sym_POUND); + if (lookahead == 'e') ADVANCE(47); + if (lookahead == 'i') ADVANCE(44); + if (lookahead == '{') ADVANCE(82); + if (lookahead == '}') ADVANCE(83); + END_STATE(); + case 78: + ACCEPT_TOKEN(anon_sym_LBRACK); + END_STATE(); + case 79: + ACCEPT_TOKEN(anon_sym_RBRACK); + END_STATE(); + case 80: + ACCEPT_TOKEN(anon_sym_LPAREN); + END_STATE(); + case 81: + ACCEPT_TOKEN(anon_sym_RPAREN); + END_STATE(); + case 82: + ACCEPT_TOKEN(anon_sym_POUND_LBRACE); + END_STATE(); + case 83: + ACCEPT_TOKEN(anon_sym_POUND_RBRACE); + END_STATE(); + case 84: + ACCEPT_TOKEN(aux_sym_code_body_token1); + if (lookahead == '\n') ADVANCE(26); + if (lookahead == '"') ADVANCE(12); + if (lookahead == '#') ADVANCE(27); + if (lookahead == '*') ADVANCE(84); + if (lookahead == '/') ADVANCE(94); + if (lookahead != 0) ADVANCE(85); + END_STATE(); + case 85: + ACCEPT_TOKEN(aux_sym_code_body_token1); + if (lookahead == '\n') ADVANCE(26); + if (lookahead == '"') ADVANCE(12); + if (lookahead == '#') ADVANCE(27); + if (lookahead == '*') ADVANCE(84); + if (lookahead != 0) ADVANCE(85); + END_STATE(); + case 86: + ACCEPT_TOKEN(aux_sym_code_body_token1); + if (lookahead == '\n') ADVANCE(138); + if (lookahead == '\r') ADVANCE(87); + if (lookahead == '"') ADVANCE(135); + if (lookahead == '#') ADVANCE(139); + if (lookahead != 0) ADVANCE(98); + END_STATE(); + case 87: + ACCEPT_TOKEN(aux_sym_code_body_token1); + if (lookahead == '\n') ADVANCE(138); + if (lookahead == '"') ADVANCE(135); + if (lookahead == '#') ADVANCE(139); + if (lookahead == '\\') ADVANCE(86); + if (lookahead != 0) ADVANCE(98); + END_STATE(); + case 88: + ACCEPT_TOKEN(aux_sym_code_body_token1); + if (lookahead == '!') ADVANCE(93); + if (lookahead == '"') ADVANCE(40); + if (lookahead == '#') ADVANCE(64); + if (lookahead != 0 && + lookahead != '\n') ADVANCE(94); + END_STATE(); + case 89: + ACCEPT_TOKEN(aux_sym_code_body_token1); + if (lookahead == '"') ADVANCE(121); + if (lookahead == '#') ADVANCE(52); + if (lookahead == '/') ADVANCE(91); + if (lookahead == '<') ADVANCE(88); + if (lookahead == 'L') ADVANCE(95); + if (lookahead == 'U') ADVANCE(96); + if (lookahead == 'u') ADVANCE(97); + if (lookahead == '\t' || + lookahead == '\r' || + lookahead == ' ') ADVANCE(89); + if (lookahead != 0 && + lookahead != '\n') ADVANCE(94); + END_STATE(); + case 90: + ACCEPT_TOKEN(aux_sym_code_body_token1); + if (lookahead == '"') ADVANCE(40); + if (lookahead == '#') ADVANCE(64); + if (lookahead == '(') ADVANCE(148); + if (lookahead != 0 && + lookahead != '\n') ADVANCE(94); + END_STATE(); + case 91: + ACCEPT_TOKEN(aux_sym_code_body_token1); + if (lookahead == '"') ADVANCE(40); + if (lookahead == '#') ADVANCE(64); + if (lookahead == '*') ADVANCE(85); + if (lookahead == '/') ADVANCE(98); + if (lookahead != 0 && + lookahead != '\n') ADVANCE(94); + END_STATE(); + case 92: + ACCEPT_TOKEN(aux_sym_code_body_token1); + if (lookahead == '"') ADVANCE(40); + if (lookahead == '#') ADVANCE(64); + if (lookahead == '-') ADVANCE(90); + if (lookahead != 0 && + lookahead != '\n') ADVANCE(94); + END_STATE(); + case 93: + ACCEPT_TOKEN(aux_sym_code_body_token1); + if (lookahead == '"') ADVANCE(40); + if (lookahead == '#') ADVANCE(64); + if (lookahead == '-') ADVANCE(92); + if (lookahead != 0 && + lookahead != '\n') ADVANCE(94); + END_STATE(); + case 94: + ACCEPT_TOKEN(aux_sym_code_body_token1); + if (lookahead == '"') ADVANCE(40); + if (lookahead == '#') ADVANCE(64); + if (lookahead != 0 && + lookahead != '\n') ADVANCE(94); + END_STATE(); + case 95: + ACCEPT_TOKEN(aux_sym_code_body_token1); + if (lookahead == '"') ADVANCE(113); + if (lookahead == '#') ADVANCE(64); + if (lookahead != 0 && + lookahead != '\n') ADVANCE(94); + END_STATE(); + case 96: + ACCEPT_TOKEN(aux_sym_code_body_token1); + if (lookahead == '"') ADVANCE(117); + if (lookahead == '#') ADVANCE(64); + if (lookahead != 0 && + lookahead != '\n') ADVANCE(94); + END_STATE(); + case 97: + ACCEPT_TOKEN(aux_sym_code_body_token1); + if (lookahead == '"') ADVANCE(115); + if (lookahead == '#') ADVANCE(64); + if (lookahead == '8') ADVANCE(99); + if (lookahead != 0 && + lookahead != '\n') ADVANCE(94); + END_STATE(); + case 98: + ACCEPT_TOKEN(aux_sym_code_body_token1); + if (lookahead == '"') ADVANCE(135); + if (lookahead == '#') ADVANCE(139); + if (lookahead == '\\') ADVANCE(86); + if (lookahead != 0 && + lookahead != '\n') ADVANCE(98); + END_STATE(); + case 99: + ACCEPT_TOKEN(aux_sym_code_body_token1); + if (lookahead == '"') ADVANCE(119); + if (lookahead == '#') ADVANCE(64); + if (lookahead != 0 && + lookahead != '\n') ADVANCE(94); + END_STATE(); + case 100: + ACCEPT_TOKEN(anon_sym_DOLLAR_LBRACE); + END_STATE(); + case 101: + ACCEPT_TOKEN(anon_sym_RBRACE2); + END_STATE(); + case 102: + ACCEPT_TOKEN(anon_sym_DOLLAR); + if (lookahead == '$') ADVANCE(152); + if (lookahead == '{') ADVANCE(100); + END_STATE(); + case 103: + ACCEPT_TOKEN(sym_prev_scope); + if (lookahead == '*') ADVANCE(26); + if (lookahead == '/') ADVANCE(104); + if (lookahead == '!' || + lookahead == '.' || + lookahead == ':') ADVANCE(105); + END_STATE(); + case 104: + ACCEPT_TOKEN(sym_prev_scope); + if (lookahead == '\\') ADVANCE(66); + if (lookahead == '!' || + lookahead == '.' || + lookahead == '/' || + lookahead == ':') ADVANCE(104); + if (lookahead != 0 && + lookahead != '\n') ADVANCE(138); + END_STATE(); + case 105: + ACCEPT_TOKEN(sym_prev_scope); + if (lookahead == '!' || + lookahead == '.' || + lookahead == '/' || + lookahead == ':') ADVANCE(105); + END_STATE(); + case 106: + ACCEPT_TOKEN(sym_prev_scope); + if (lookahead == '!' || + lookahead == '.' || + lookahead == '/' || + lookahead == ':') ADVANCE(105); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(109); + END_STATE(); + case 107: + ACCEPT_TOKEN(sym_number_literal); + END_STATE(); + case 108: + ACCEPT_TOKEN(sym_number_literal); + if (lookahead == '.') ADVANCE(111); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(53); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(108); + END_STATE(); + case 109: + ACCEPT_TOKEN(sym_number_literal); + if (lookahead == '.') ADVANCE(107); + if (lookahead == 'E' || + lookahead == 'e') ADVANCE(53); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(109); + END_STATE(); + case 110: + ACCEPT_TOKEN(sym_number_literal); + if (lookahead == '.') ADVANCE(107); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(110); + END_STATE(); + case 111: + ACCEPT_TOKEN(sym_number_literal); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(109); + END_STATE(); + case 112: + ACCEPT_TOKEN(anon_sym_L_DQUOTE); + END_STATE(); + case 113: + ACCEPT_TOKEN(anon_sym_L_DQUOTE); + if (lookahead == '\\') ADVANCE(65); + if (lookahead != 0 && + lookahead != '"') ADVANCE(19); + END_STATE(); + case 114: + ACCEPT_TOKEN(anon_sym_u_DQUOTE); + END_STATE(); + case 115: + ACCEPT_TOKEN(anon_sym_u_DQUOTE); + if (lookahead == '\\') ADVANCE(65); + if (lookahead != 0 && + lookahead != '"') ADVANCE(19); + END_STATE(); + case 116: + ACCEPT_TOKEN(anon_sym_U_DQUOTE); + END_STATE(); + case 117: + ACCEPT_TOKEN(anon_sym_U_DQUOTE); + if (lookahead == '\\') ADVANCE(65); + if (lookahead != 0 && + lookahead != '"') ADVANCE(19); + END_STATE(); + case 118: + ACCEPT_TOKEN(anon_sym_u8_DQUOTE); + END_STATE(); + case 119: + ACCEPT_TOKEN(anon_sym_u8_DQUOTE); + if (lookahead == '\\') ADVANCE(65); + if (lookahead != 0 && + lookahead != '"') ADVANCE(19); + END_STATE(); + case 120: + ACCEPT_TOKEN(anon_sym_DQUOTE); + END_STATE(); + case 121: + ACCEPT_TOKEN(anon_sym_DQUOTE); + if (lookahead == '\\') ADVANCE(65); + if (lookahead != 0 && + lookahead != '"') ADVANCE(19); + END_STATE(); + case 122: + ACCEPT_TOKEN(aux_sym_string_literal_token1); + if (lookahead == '!') ADVANCE(128); + if (lookahead != 0 && + lookahead != '\n' && + lookahead != '"' && + lookahead != '\\') ADVANCE(130); + END_STATE(); + case 123: + ACCEPT_TOKEN(aux_sym_string_literal_token1); + if (lookahead == '(') ADVANCE(130); + if (lookahead != 0 && + lookahead != '\n' && + lookahead != '"' && + lookahead != '\\') ADVANCE(130); + END_STATE(); + case 124: + ACCEPT_TOKEN(aux_sym_string_literal_token1); + if (lookahead == '*') ADVANCE(126); + if (lookahead == '/') ADVANCE(130); + if (lookahead != 0 && + lookahead != '\n' && + lookahead != '"' && + lookahead != '\\') ADVANCE(130); + END_STATE(); + case 125: + ACCEPT_TOKEN(aux_sym_string_literal_token1); + if (lookahead == '*') ADVANCE(125); + if (lookahead == '/') ADVANCE(130); + if (lookahead != 0 && + lookahead != '\n' && + lookahead != '"' && + lookahead != '\\') ADVANCE(126); + END_STATE(); + case 126: + ACCEPT_TOKEN(aux_sym_string_literal_token1); + if (lookahead == '*') ADVANCE(125); + if (lookahead != 0 && + lookahead != '\n' && + lookahead != '"' && + lookahead != '\\') ADVANCE(126); + END_STATE(); + case 127: + ACCEPT_TOKEN(aux_sym_string_literal_token1); + if (lookahead == '-') ADVANCE(123); + if (lookahead != 0 && + lookahead != '\n' && + lookahead != '"' && + lookahead != '\\') ADVANCE(130); + END_STATE(); + case 128: + ACCEPT_TOKEN(aux_sym_string_literal_token1); + if (lookahead == '-') ADVANCE(127); + if (lookahead != 0 && + lookahead != '\n' && + lookahead != '"' && + lookahead != '\\') ADVANCE(130); + END_STATE(); + case 129: + ACCEPT_TOKEN(aux_sym_string_literal_token1); + if (lookahead == '/') ADVANCE(124); + if (lookahead == '<') ADVANCE(122); + if (lookahead == '\t' || + lookahead == '\r' || + lookahead == ' ') ADVANCE(129); + if (lookahead != 0 && + lookahead != '\n' && + lookahead != '"' && + lookahead != '\\') ADVANCE(130); + END_STATE(); + case 130: + ACCEPT_TOKEN(aux_sym_string_literal_token1); + if (lookahead != 0 && + lookahead != '\n' && + lookahead != '"' && + lookahead != '\\') ADVANCE(130); + END_STATE(); + case 131: + ACCEPT_TOKEN(sym_escape_sequence); + END_STATE(); + case 132: + ACCEPT_TOKEN(sym_escape_sequence); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(131); + END_STATE(); + case 133: + ACCEPT_TOKEN(sym_escape_sequence); + if (('0' <= lookahead && lookahead <= '9')) ADVANCE(132); + END_STATE(); + case 134: + ACCEPT_TOKEN(aux_sym_comment_token1); + END_STATE(); + case 135: + ACCEPT_TOKEN(aux_sym_comment_token1); + if (lookahead == '\n') ADVANCE(19); + if (lookahead == '"') ADVANCE(138); + if (lookahead == '\\') ADVANCE(2); + if (lookahead != 0) ADVANCE(136); + END_STATE(); + case 136: + ACCEPT_TOKEN(aux_sym_comment_token1); + if (lookahead == '\n') ADVANCE(19); + if (lookahead == '"') ADVANCE(98); + if (lookahead == '\\') ADVANCE(2); + if (lookahead != 0) ADVANCE(136); + END_STATE(); + case 137: + ACCEPT_TOKEN(aux_sym_comment_token1); + if (lookahead == '"') ADVANCE(94); + if (lookahead == '\\') ADVANCE(65); + if (lookahead != 0) ADVANCE(19); + END_STATE(); + case 138: + ACCEPT_TOKEN(aux_sym_comment_token1); + if (lookahead == '\\') ADVANCE(66); + if (lookahead != 0 && + lookahead != '\n') ADVANCE(138); + END_STATE(); + case 139: + ACCEPT_TOKEN(aux_sym_comment_token1); + if (lookahead == '\\') ADVANCE(86); + if (lookahead == '{' || + lookahead == '}') ADVANCE(138); + if (lookahead != 0 && + lookahead != '\n') ADVANCE(98); + END_STATE(); + case 140: + ACCEPT_TOKEN(aux_sym_comment_token1); + if (lookahead != 0 && + lookahead != '"' && + lookahead != '\\') ADVANCE(136); + if (lookahead == '"') ADVANCE(98); + if (lookahead == '\\') ADVANCE(2); + END_STATE(); + case 141: + ACCEPT_TOKEN(aux_sym_comment_token1); + if (lookahead != 0 && + lookahead != '\\') ADVANCE(138); + if (lookahead == '\\') ADVANCE(66); + END_STATE(); + case 142: + ACCEPT_TOKEN(aux_sym_single_python_line_token1); + END_STATE(); + case 143: + ACCEPT_TOKEN(aux_sym_single_python_line_token1); + if (lookahead == '!') ADVANCE(32); + END_STATE(); + case 144: + ACCEPT_TOKEN(aux_sym_single_python_line_token1); + if (lookahead == '*') ADVANCE(26); + if (lookahead == '/') ADVANCE(138); + END_STATE(); + case 145: + ACCEPT_TOKEN(aux_sym_single_python_line_token1); + if (lookahead == '-') ADVANCE(30); + END_STATE(); + case 146: + ACCEPT_TOKEN(aux_sym_single_python_line_token1); + if (lookahead == '|') ADVANCE(151); + END_STATE(); + case 147: + ACCEPT_TOKEN(anon_sym_LT_BANG_DASH_DASH_LPAREN); + END_STATE(); + case 148: + ACCEPT_TOKEN(anon_sym_LT_BANG_DASH_DASH_LPAREN); + if (lookahead == '"') ADVANCE(40); + if (lookahead == '#') ADVANCE(64); + if (lookahead != 0 && + lookahead != '\n') ADVANCE(94); + END_STATE(); + case 149: + ACCEPT_TOKEN(anon_sym_RPAREN_DASH_DASH_GT); + END_STATE(); + case 150: + ACCEPT_TOKEN(anon_sym_PIPE_DASH); + END_STATE(); + case 151: + ACCEPT_TOKEN(anon_sym_DASH_PIPE); + END_STATE(); + case 152: + ACCEPT_TOKEN(anon_sym_DOLLAR_DOLLAR); + END_STATE(); + case 153: + ACCEPT_TOKEN(anon_sym_LF); + if (lookahead == '\n') ADVANCE(153); + END_STATE(); + default: + return false; + } +} + +static bool ts_lex_keywords(TSLexer *lexer, TSStateId state) { + START_LEXER(); + eof = lexer->eof(lexer); + switch (state) { + case 0: + ACCEPT_TOKEN(ts_builtin_sym_end); + END_STATE(); + default: + return false; + } +} + +static const TSLexMode ts_lex_modes[STATE_COUNT] = { + [0] = {.lex_state = 0, .external_lex_state = 1}, + [1] = {.lex_state = 68, .external_lex_state = 2}, + [2] = {.lex_state = 68, .external_lex_state = 3}, + [3] = {.lex_state = 68, .external_lex_state = 3}, + [4] = {.lex_state = 68, .external_lex_state = 3}, + [5] = {.lex_state = 68, .external_lex_state = 3}, + [6] = {.lex_state = 68, .external_lex_state = 3}, + [7] = {.lex_state = 68, .external_lex_state = 3}, + [8] = {.lex_state = 68, .external_lex_state = 3}, + [9] = {.lex_state = 68, .external_lex_state = 3}, + [10] = {.lex_state = 68, .external_lex_state = 3}, + [11] = {.lex_state = 68, .external_lex_state = 3}, + [12] = {.lex_state = 68, .external_lex_state = 3}, + [13] = {.lex_state = 68, .external_lex_state = 3}, + [14] = {.lex_state = 68, .external_lex_state = 3}, + [15] = {.lex_state = 68, .external_lex_state = 3}, + [16] = {.lex_state = 68, .external_lex_state = 3}, + [17] = {.lex_state = 68, .external_lex_state = 3}, + [18] = {.lex_state = 68, .external_lex_state = 3}, + [19] = {.lex_state = 68, .external_lex_state = 3}, + [20] = {.lex_state = 68, .external_lex_state = 3}, + [21] = {.lex_state = 68, .external_lex_state = 3}, + [22] = {.lex_state = 68, .external_lex_state = 3}, + [23] = {.lex_state = 68, .external_lex_state = 3}, + [24] = {.lex_state = 68, .external_lex_state = 3}, + [25] = {.lex_state = 68, .external_lex_state = 3}, + [26] = {.lex_state = 68, .external_lex_state = 3}, + [27] = {.lex_state = 68, .external_lex_state = 3}, + [28] = {.lex_state = 68, .external_lex_state = 3}, + [29] = {.lex_state = 68, .external_lex_state = 3}, + [30] = {.lex_state = 68, .external_lex_state = 3}, + [31] = {.lex_state = 68, .external_lex_state = 3}, + [32] = {.lex_state = 68, .external_lex_state = 3}, + [33] = {.lex_state = 68, .external_lex_state = 3}, + [34] = {.lex_state = 68, .external_lex_state = 3}, + [35] = {.lex_state = 68, .external_lex_state = 3}, + [36] = {.lex_state = 68, .external_lex_state = 3}, + [37] = {.lex_state = 68, .external_lex_state = 3}, + [38] = {.lex_state = 68, .external_lex_state = 3}, + [39] = {.lex_state = 68, .external_lex_state = 3}, + [40] = {.lex_state = 68, .external_lex_state = 3}, + [41] = {.lex_state = 68, .external_lex_state = 3}, + [42] = {.lex_state = 68, .external_lex_state = 4}, + [43] = {.lex_state = 68, .external_lex_state = 4}, + [44] = {.lex_state = 68, .external_lex_state = 4}, + [45] = {.lex_state = 68, .external_lex_state = 4}, + [46] = {.lex_state = 68, .external_lex_state = 4}, + [47] = {.lex_state = 68, .external_lex_state = 4}, + [48] = {.lex_state = 68, .external_lex_state = 4}, + [49] = {.lex_state = 68, .external_lex_state = 4}, + [50] = {.lex_state = 68, .external_lex_state = 4}, + [51] = {.lex_state = 68, .external_lex_state = 4}, + [52] = {.lex_state = 68, .external_lex_state = 4}, + [53] = {.lex_state = 68, .external_lex_state = 4}, + [54] = {.lex_state = 68, .external_lex_state = 4}, + [55] = {.lex_state = 68, .external_lex_state = 4}, + [56] = {.lex_state = 68, .external_lex_state = 2}, + [57] = {.lex_state = 68, .external_lex_state = 2}, + [58] = {.lex_state = 68, .external_lex_state = 3}, + [59] = {.lex_state = 68, .external_lex_state = 4}, + [60] = {.lex_state = 68, .external_lex_state = 4}, + [61] = {.lex_state = 68, .external_lex_state = 4}, + [62] = {.lex_state = 68, .external_lex_state = 3}, + [63] = {.lex_state = 68, .external_lex_state = 4}, + [64] = {.lex_state = 68, .external_lex_state = 4}, + [65] = {.lex_state = 68, .external_lex_state = 3}, + [66] = {.lex_state = 68, .external_lex_state = 4}, + [67] = {.lex_state = 68, .external_lex_state = 1}, + [68] = {.lex_state = 68, .external_lex_state = 1}, + [69] = {.lex_state = 68, .external_lex_state = 3}, + [70] = {.lex_state = 68, .external_lex_state = 1}, + [71] = {.lex_state = 68, .external_lex_state = 4}, + [72] = {.lex_state = 68, .external_lex_state = 1}, + [73] = {.lex_state = 68, .external_lex_state = 4}, + [74] = {.lex_state = 68, .external_lex_state = 3}, + [75] = {.lex_state = 68, .external_lex_state = 3}, + [76] = {.lex_state = 68, .external_lex_state = 3}, + [77] = {.lex_state = 68, .external_lex_state = 3}, + [78] = {.lex_state = 68, .external_lex_state = 3}, + [79] = {.lex_state = 68, .external_lex_state = 3}, + [80] = {.lex_state = 68, .external_lex_state = 3}, + [81] = {.lex_state = 68, .external_lex_state = 3}, + [82] = {.lex_state = 68, .external_lex_state = 3}, + [83] = {.lex_state = 68, .external_lex_state = 3}, + [84] = {.lex_state = 68, .external_lex_state = 3}, + [85] = {.lex_state = 68, .external_lex_state = 3}, + [86] = {.lex_state = 68, .external_lex_state = 3}, + [87] = {.lex_state = 68, .external_lex_state = 3}, + [88] = {.lex_state = 68, .external_lex_state = 3}, + [89] = {.lex_state = 68, .external_lex_state = 3}, + [90] = {.lex_state = 68, .external_lex_state = 3}, + [91] = {.lex_state = 68, .external_lex_state = 3}, + [92] = {.lex_state = 68, .external_lex_state = 3}, + [93] = {.lex_state = 68, .external_lex_state = 3}, + [94] = {.lex_state = 68, .external_lex_state = 3}, + [95] = {.lex_state = 68, .external_lex_state = 3}, + [96] = {.lex_state = 68, .external_lex_state = 3}, + [97] = {.lex_state = 68, .external_lex_state = 3}, + [98] = {.lex_state = 68, .external_lex_state = 3}, + [99] = {.lex_state = 68, .external_lex_state = 3}, + [100] = {.lex_state = 68, .external_lex_state = 3}, + [101] = {.lex_state = 68, .external_lex_state = 3}, + [102] = {.lex_state = 68, .external_lex_state = 3}, + [103] = {.lex_state = 68, .external_lex_state = 3}, + [104] = {.lex_state = 68, .external_lex_state = 3}, + [105] = {.lex_state = 68, .external_lex_state = 3}, + [106] = {.lex_state = 68, .external_lex_state = 3}, + [107] = {.lex_state = 68, .external_lex_state = 3}, + [108] = {.lex_state = 68, .external_lex_state = 3}, + [109] = {.lex_state = 68, .external_lex_state = 3}, + [110] = {.lex_state = 68, .external_lex_state = 3}, + [111] = {.lex_state = 68, .external_lex_state = 3}, + [112] = {.lex_state = 68, .external_lex_state = 3}, + [113] = {.lex_state = 68, .external_lex_state = 3}, + [114] = {.lex_state = 68, .external_lex_state = 3}, + [115] = {.lex_state = 68, .external_lex_state = 3}, + [116] = {.lex_state = 68, .external_lex_state = 3}, + [117] = {.lex_state = 68, .external_lex_state = 3}, + [118] = {.lex_state = 68, .external_lex_state = 3}, + [119] = {.lex_state = 68, .external_lex_state = 3}, + [120] = {.lex_state = 68, .external_lex_state = 3}, + [121] = {.lex_state = 68, .external_lex_state = 3}, + [122] = {.lex_state = 68, .external_lex_state = 3}, + [123] = {.lex_state = 68, .external_lex_state = 3}, + [124] = {.lex_state = 68, .external_lex_state = 4}, + [125] = {.lex_state = 68, .external_lex_state = 4}, + [126] = {.lex_state = 68, .external_lex_state = 4}, + [127] = {.lex_state = 68, .external_lex_state = 4}, + [128] = {.lex_state = 68, .external_lex_state = 4}, + [129] = {.lex_state = 68, .external_lex_state = 4}, + [130] = {.lex_state = 68, .external_lex_state = 4}, + [131] = {.lex_state = 68, .external_lex_state = 4}, + [132] = {.lex_state = 68, .external_lex_state = 4}, + [133] = {.lex_state = 68, .external_lex_state = 4}, + [134] = {.lex_state = 68, .external_lex_state = 4}, + [135] = {.lex_state = 68, .external_lex_state = 4}, + [136] = {.lex_state = 68, .external_lex_state = 4}, + [137] = {.lex_state = 68, .external_lex_state = 4}, + [138] = {.lex_state = 68, .external_lex_state = 4}, + [139] = {.lex_state = 68, .external_lex_state = 4}, + [140] = {.lex_state = 68, .external_lex_state = 4}, + [141] = {.lex_state = 68, .external_lex_state = 4}, + [142] = {.lex_state = 68, .external_lex_state = 4}, + [143] = {.lex_state = 68, .external_lex_state = 4}, + [144] = {.lex_state = 68, .external_lex_state = 4}, + [145] = {.lex_state = 68, .external_lex_state = 4}, + [146] = {.lex_state = 68, .external_lex_state = 4}, + [147] = {.lex_state = 68, .external_lex_state = 4}, + [148] = {.lex_state = 68, .external_lex_state = 4}, + [149] = {.lex_state = 68, .external_lex_state = 4}, + [150] = {.lex_state = 68, .external_lex_state = 4}, + [151] = {.lex_state = 68, .external_lex_state = 4}, + [152] = {.lex_state = 68, .external_lex_state = 4}, + [153] = {.lex_state = 68, .external_lex_state = 4}, + [154] = {.lex_state = 68, .external_lex_state = 4}, + [155] = {.lex_state = 68, .external_lex_state = 4}, + [156] = {.lex_state = 68, .external_lex_state = 4}, + [157] = {.lex_state = 68, .external_lex_state = 4}, + [158] = {.lex_state = 68, .external_lex_state = 4}, + [159] = {.lex_state = 68, .external_lex_state = 4}, + [160] = {.lex_state = 68, .external_lex_state = 2}, + [161] = {.lex_state = 68, .external_lex_state = 2}, + [162] = {.lex_state = 68, .external_lex_state = 2}, + [163] = {.lex_state = 68, .external_lex_state = 2}, + [164] = {.lex_state = 68, .external_lex_state = 2}, + [165] = {.lex_state = 68, .external_lex_state = 2}, + [166] = {.lex_state = 68, .external_lex_state = 2}, + [167] = {.lex_state = 68, .external_lex_state = 2}, + [168] = {.lex_state = 68, .external_lex_state = 2}, + [169] = {.lex_state = 68, .external_lex_state = 2}, + [170] = {.lex_state = 68, .external_lex_state = 2}, + [171] = {.lex_state = 68, .external_lex_state = 2}, + [172] = {.lex_state = 68, .external_lex_state = 2}, + [173] = {.lex_state = 68, .external_lex_state = 2}, + [174] = {.lex_state = 68, .external_lex_state = 2}, + [175] = {.lex_state = 68, .external_lex_state = 2}, + [176] = {.lex_state = 68, .external_lex_state = 2}, + [177] = {.lex_state = 68, .external_lex_state = 2}, + [178] = {.lex_state = 68, .external_lex_state = 2}, + [179] = {.lex_state = 68, .external_lex_state = 2}, + [180] = {.lex_state = 68, .external_lex_state = 2}, + [181] = {.lex_state = 68, .external_lex_state = 2}, + [182] = {.lex_state = 68, .external_lex_state = 2}, + [183] = {.lex_state = 68, .external_lex_state = 2}, + [184] = {.lex_state = 68, .external_lex_state = 2}, + [185] = {.lex_state = 68, .external_lex_state = 2}, + [186] = {.lex_state = 68, .external_lex_state = 2}, + [187] = {.lex_state = 68, .external_lex_state = 2}, + [188] = {.lex_state = 68, .external_lex_state = 2}, + [189] = {.lex_state = 68, .external_lex_state = 2}, + [190] = {.lex_state = 68, .external_lex_state = 2}, + [191] = {.lex_state = 68, .external_lex_state = 2}, + [192] = {.lex_state = 68, .external_lex_state = 2}, + [193] = {.lex_state = 68, .external_lex_state = 2}, + [194] = {.lex_state = 68, .external_lex_state = 4}, + [195] = {.lex_state = 68, .external_lex_state = 4}, + [196] = {.lex_state = 68, .external_lex_state = 4}, + [197] = {.lex_state = 68, .external_lex_state = 4}, + [198] = {.lex_state = 68, .external_lex_state = 4}, + [199] = {.lex_state = 68, .external_lex_state = 4}, + [200] = {.lex_state = 68, .external_lex_state = 4}, + [201] = {.lex_state = 68, .external_lex_state = 4}, + [202] = {.lex_state = 3}, + [203] = {.lex_state = 3}, + [204] = {.lex_state = 3}, + [205] = {.lex_state = 3}, + [206] = {.lex_state = 3}, + [207] = {.lex_state = 3}, + [208] = {.lex_state = 3}, + [209] = {.lex_state = 4}, + [210] = {.lex_state = 4}, + [211] = {.lex_state = 4}, + [212] = {.lex_state = 4}, + [213] = {.lex_state = 68}, + [214] = {.lex_state = 68, .external_lex_state = 4}, + [215] = {.lex_state = 68, .external_lex_state = 4}, + [216] = {.lex_state = 68, .external_lex_state = 4}, + [217] = {.lex_state = 68, .external_lex_state = 4}, + [218] = {.lex_state = 4}, + [219] = {.lex_state = 4}, + [220] = {.lex_state = 4}, + [221] = {.lex_state = 68, .external_lex_state = 4}, + [222] = {.lex_state = 4}, + [223] = {.lex_state = 4}, + [224] = {.lex_state = 4}, + [225] = {.lex_state = 4}, + [226] = {.lex_state = 6}, + [227] = {.lex_state = 7}, + [228] = {.lex_state = 7}, + [229] = {.lex_state = 8}, + [230] = {.lex_state = 68, .external_lex_state = 4}, + [231] = {.lex_state = 7}, + [232] = {.lex_state = 9}, + [233] = {.lex_state = 9}, + [234] = {.lex_state = 68}, + [235] = {.lex_state = 4}, + [236] = {.lex_state = 6}, + [237] = {.lex_state = 7}, + [238] = {.lex_state = 68}, + [239] = {.lex_state = 7}, + [240] = {.lex_state = 8}, + [241] = {.lex_state = 68}, + [242] = {.lex_state = 68}, + [243] = {.lex_state = 68}, + [244] = {.lex_state = 68}, + [245] = {.lex_state = 68}, + [246] = {.lex_state = 68}, + [247] = {.lex_state = 68}, + [248] = {.lex_state = 36, .external_lex_state = 4}, + [249] = {.lex_state = 68}, + [250] = {.lex_state = 68}, + [251] = {.lex_state = 6}, + [252] = {.lex_state = 68}, + [253] = {.lex_state = 68}, + [254] = {.lex_state = 68}, + [255] = {.lex_state = 36, .external_lex_state = 4}, + [256] = {.lex_state = 9}, + [257] = {.lex_state = 68}, + [258] = {.lex_state = 68}, + [259] = {.lex_state = 68}, + [260] = {.lex_state = 36, .external_lex_state = 4}, + [261] = {.lex_state = 36, .external_lex_state = 4}, + [262] = {.lex_state = 68}, + [263] = {.lex_state = 68}, + [264] = {.lex_state = 68}, + [265] = {.lex_state = 68}, + [266] = {.lex_state = 68}, + [267] = {.lex_state = 68}, + [268] = {.lex_state = 68}, + [269] = {.lex_state = 68}, + [270] = {.lex_state = 68}, + [271] = {.lex_state = 36, .external_lex_state = 4}, + [272] = {.lex_state = 68}, + [273] = {.lex_state = 36, .external_lex_state = 4}, + [274] = {.lex_state = 36, .external_lex_state = 4}, + [275] = {.lex_state = 68}, + [276] = {.lex_state = 68}, + [277] = {.lex_state = 68}, + [278] = {.lex_state = 68}, + [279] = {.lex_state = 68}, + [280] = {.lex_state = 36, .external_lex_state = 4}, + [281] = {.lex_state = 8}, + [282] = {.lex_state = 68}, + [283] = {.lex_state = 20}, + [284] = {.lex_state = 68}, + [285] = {.lex_state = 20}, + [286] = {.lex_state = 68, .external_lex_state = 4}, + [287] = {.lex_state = 68}, + [288] = {.lex_state = 68}, + [289] = {.lex_state = 68}, + [290] = {.lex_state = 68}, + [291] = {.lex_state = 68}, + [292] = {.lex_state = 20}, + [293] = {.lex_state = 68, .external_lex_state = 4}, + [294] = {.lex_state = 68}, + [295] = {.lex_state = 68}, + [296] = {.lex_state = 68}, + [297] = {.lex_state = 20}, + [298] = {.lex_state = 68, .external_lex_state = 4}, + [299] = {.lex_state = 68}, + [300] = {.lex_state = 20}, + [301] = {.lex_state = 68, .external_lex_state = 4}, + [302] = {.lex_state = 68}, + [303] = {.lex_state = 68}, + [304] = {.lex_state = 68}, + [305] = {.lex_state = 68}, + [306] = {.lex_state = 68, .external_lex_state = 4}, + [307] = {.lex_state = 68, .external_lex_state = 4}, + [308] = {.lex_state = 68}, + [309] = {.lex_state = 20}, + [310] = {.lex_state = 68, .external_lex_state = 4}, + [311] = {.lex_state = 68}, + [312] = {.lex_state = 68}, + [313] = {.lex_state = 68, .external_lex_state = 4}, + [314] = {.lex_state = 20}, + [315] = {.lex_state = 68, .external_lex_state = 4}, + [316] = {.lex_state = 20}, + [317] = {.lex_state = 20}, + [318] = {.lex_state = 68, .external_lex_state = 4}, + [319] = {.lex_state = 68}, + [320] = {.lex_state = 68, .external_lex_state = 4}, + [321] = {.lex_state = 68, .external_lex_state = 4}, + [322] = {.lex_state = 68}, + [323] = {.lex_state = 68, .external_lex_state = 4}, + [324] = {.lex_state = 5}, + [325] = {.lex_state = 68}, + [326] = {.lex_state = 5}, + [327] = {.lex_state = 68}, + [328] = {.lex_state = 20}, + [329] = {.lex_state = 68}, + [330] = {.lex_state = 68, .external_lex_state = 4}, + [331] = {.lex_state = 68}, + [332] = {.lex_state = 20}, + [333] = {.lex_state = 68}, + [334] = {.lex_state = 68, .external_lex_state = 4}, + [335] = {.lex_state = 68, .external_lex_state = 4}, + [336] = {.lex_state = 68}, + [337] = {(TSStateId)(-1)}, + [338] = {(TSStateId)(-1)}, +}; + +enum { + ts_external_token_identifier = 0, + ts_external_token_boolean = 1, + ts_external_token__eof = 2, +}; + +static const TSSymbol ts_external_scanner_symbol_map[EXTERNAL_TOKEN_COUNT] = { + [ts_external_token_identifier] = sym_identifier, + [ts_external_token_boolean] = sym_boolean, + [ts_external_token__eof] = sym__eof, +}; + +static const bool ts_external_scanner_states[5][EXTERNAL_TOKEN_COUNT] = { + [1] = { + [ts_external_token_identifier] = true, + [ts_external_token_boolean] = true, + [ts_external_token__eof] = true, + }, + [2] = { + [ts_external_token_identifier] = true, + [ts_external_token__eof] = true, + }, + [3] = { + [ts_external_token_identifier] = true, + [ts_external_token_boolean] = true, + }, + [4] = { + [ts_external_token_identifier] = true, + }, +}; + +static const uint16_t ts_parse_table[LARGE_STATE_COUNT][SYMBOL_COUNT] = { + [0] = { + [sym_comment] = STATE(0), + [sym_pyfoam_template] = STATE(0), + [ts_builtin_sym_end] = ACTIONS(1), + [anon_sym_LBRACE] = ACTIONS(1), + [anon_sym_RBRACE] = ACTIONS(1), + [anon_sym_SEMI] = ACTIONS(1), + [aux_sym__special_preproc_call_token1] = ACTIONS(1), + [aux_sym__special_preproc_call_token2] = ACTIONS(1), + [aux_sym__cond_preproc_call_token1] = ACTIONS(1), + [anon_sym_POUND] = ACTIONS(1), + [anon_sym_LBRACK] = ACTIONS(1), + [anon_sym_RBRACK] = ACTIONS(1), + [anon_sym_LPAREN] = ACTIONS(1), + [anon_sym_RPAREN] = ACTIONS(1), + [anon_sym_POUND_LBRACE] = ACTIONS(1), + [anon_sym_POUND_RBRACE] = ACTIONS(1), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(1), + [anon_sym_RBRACE2] = ACTIONS(1), + [anon_sym_DOLLAR] = ACTIONS(1), + [sym_prev_scope] = ACTIONS(1), + [sym_number_literal] = ACTIONS(1), + [anon_sym_L_DQUOTE] = ACTIONS(1), + [anon_sym_u_DQUOTE] = ACTIONS(1), + [anon_sym_U_DQUOTE] = ACTIONS(1), + [anon_sym_u8_DQUOTE] = ACTIONS(1), + [anon_sym_DQUOTE] = ACTIONS(1), + [sym_escape_sequence] = ACTIONS(1), + [aux_sym_comment_token1] = ACTIONS(3), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_PIPE_DASH] = ACTIONS(1), + [anon_sym_DASH_PIPE] = ACTIONS(1), + [anon_sym_DOLLAR_DOLLAR] = ACTIONS(1), + [sym_identifier] = ACTIONS(1), + [sym_boolean] = ACTIONS(1), + [sym__eof] = ACTIONS(1), + }, + [1] = { + [sym_foam] = STATE(304), + [sym__statement] = STATE(191), + [sym_dict] = STATE(190), + [sym_key_value] = STATE(190), + [sym_preproc_call] = STATE(190), + [sym__special_preproc_call] = STATE(186), + [sym__cond_preproc_call] = STATE(183), + [sym__generic_preproc_call] = STATE(179), + [sym_list] = STATE(291), + [sym__uniform_list] = STATE(185), + [sym__non_uniform_list] = STATE(166), + [sym_string_literal] = STATE(34), + [sym_comment] = STATE(1), + [sym_pyfoam_template] = STATE(1), + [sym_pyfoam_variable] = STATE(190), + [aux_sym_foam_repeat1] = STATE(57), + [aux_sym__special_preproc_call_token1] = ACTIONS(7), + [aux_sym__special_preproc_call_token2] = ACTIONS(7), + [aux_sym__cond_preproc_call_token1] = ACTIONS(9), + [anon_sym_POUND] = ACTIONS(11), + [anon_sym_LPAREN] = ACTIONS(13), + [sym_number_literal] = ACTIONS(15), + [anon_sym_L_DQUOTE] = ACTIONS(17), + [anon_sym_u_DQUOTE] = ACTIONS(17), + [anon_sym_U_DQUOTE] = ACTIONS(17), + [anon_sym_u8_DQUOTE] = ACTIONS(17), + [anon_sym_DQUOTE] = ACTIONS(17), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_DOLLAR_DOLLAR] = ACTIONS(21), + [sym_identifier] = ACTIONS(23), + [sym__eof] = ACTIONS(25), + }, + [2] = { + [sym_dict] = STATE(97), + [sym_preproc_call] = STATE(97), + [sym__special_preproc_call] = STATE(87), + [sym__cond_preproc_call] = STATE(108), + [sym__generic_preproc_call] = STATE(96), + [sym__value] = STATE(119), + [sym_dimensions] = STATE(97), + [sym_list] = STATE(114), + [sym__uniform_list] = STATE(106), + [sym__non_uniform_list] = STATE(104), + [sym__list_item] = STATE(115), + [sym_dict_headless] = STATE(119), + [sym_code] = STATE(97), + [sym_macro] = STATE(97), + [sym__macro_braces] = STATE(101), + [sym__macro_no_braces] = STATE(101), + [sym_string_literal] = STATE(114), + [sym_comment] = STATE(2), + [sym_pyfoam_template] = STATE(2), + [sym_pyfoam_expression] = STATE(97), + [aux_sym__non_uniform_list_repeat1] = STATE(11), + [anon_sym_LBRACE] = ACTIONS(27), + [aux_sym__special_preproc_call_token1] = ACTIONS(29), + [aux_sym__special_preproc_call_token2] = ACTIONS(29), + [aux_sym__cond_preproc_call_token1] = ACTIONS(31), + [anon_sym_POUND] = ACTIONS(33), + [anon_sym_LBRACK] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_RPAREN] = ACTIONS(39), + [anon_sym_POUND_LBRACE] = ACTIONS(41), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(43), + [anon_sym_DOLLAR] = ACTIONS(45), + [sym_number_literal] = ACTIONS(47), + [anon_sym_L_DQUOTE] = ACTIONS(17), + [anon_sym_u_DQUOTE] = ACTIONS(17), + [anon_sym_U_DQUOTE] = ACTIONS(17), + [anon_sym_u8_DQUOTE] = ACTIONS(17), + [anon_sym_DQUOTE] = ACTIONS(17), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_PIPE_DASH] = ACTIONS(49), + [sym_identifier] = ACTIONS(51), + [sym_boolean] = ACTIONS(53), + }, + [3] = { + [sym_dict] = STATE(97), + [sym_preproc_call] = STATE(97), + [sym__special_preproc_call] = STATE(87), + [sym__cond_preproc_call] = STATE(108), + [sym__generic_preproc_call] = STATE(96), + [sym__value] = STATE(119), + [sym_dimensions] = STATE(97), + [sym_list] = STATE(114), + [sym__uniform_list] = STATE(106), + [sym__non_uniform_list] = STATE(104), + [sym__list_item] = STATE(115), + [sym_dict_headless] = STATE(119), + [sym_code] = STATE(97), + [sym_macro] = STATE(97), + [sym__macro_braces] = STATE(101), + [sym__macro_no_braces] = STATE(101), + [sym_string_literal] = STATE(114), + [sym_comment] = STATE(3), + [sym_pyfoam_template] = STATE(3), + [sym_pyfoam_expression] = STATE(97), + [aux_sym__non_uniform_list_repeat1] = STATE(8), + [anon_sym_LBRACE] = ACTIONS(27), + [aux_sym__special_preproc_call_token1] = ACTIONS(29), + [aux_sym__special_preproc_call_token2] = ACTIONS(29), + [aux_sym__cond_preproc_call_token1] = ACTIONS(31), + [anon_sym_POUND] = ACTIONS(33), + [anon_sym_LBRACK] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_RPAREN] = ACTIONS(55), + [anon_sym_POUND_LBRACE] = ACTIONS(41), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(43), + [anon_sym_DOLLAR] = ACTIONS(45), + [sym_number_literal] = ACTIONS(47), + [anon_sym_L_DQUOTE] = ACTIONS(17), + [anon_sym_u_DQUOTE] = ACTIONS(17), + [anon_sym_U_DQUOTE] = ACTIONS(17), + [anon_sym_u8_DQUOTE] = ACTIONS(17), + [anon_sym_DQUOTE] = ACTIONS(17), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_PIPE_DASH] = ACTIONS(49), + [sym_identifier] = ACTIONS(51), + [sym_boolean] = ACTIONS(53), + }, + [4] = { + [sym_dict] = STATE(97), + [sym_preproc_call] = STATE(97), + [sym__special_preproc_call] = STATE(87), + [sym__cond_preproc_call] = STATE(108), + [sym__generic_preproc_call] = STATE(96), + [sym__value] = STATE(119), + [sym_dimensions] = STATE(97), + [sym_list] = STATE(114), + [sym__uniform_list] = STATE(106), + [sym__non_uniform_list] = STATE(104), + [sym__list_item] = STATE(115), + [sym_dict_headless] = STATE(119), + [sym_code] = STATE(97), + [sym_macro] = STATE(97), + [sym__macro_braces] = STATE(101), + [sym__macro_no_braces] = STATE(101), + [sym_string_literal] = STATE(114), + [sym_comment] = STATE(4), + [sym_pyfoam_template] = STATE(4), + [sym_pyfoam_expression] = STATE(97), + [aux_sym__non_uniform_list_repeat1] = STATE(12), + [anon_sym_LBRACE] = ACTIONS(27), + [aux_sym__special_preproc_call_token1] = ACTIONS(29), + [aux_sym__special_preproc_call_token2] = ACTIONS(29), + [aux_sym__cond_preproc_call_token1] = ACTIONS(31), + [anon_sym_POUND] = ACTIONS(33), + [anon_sym_LBRACK] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_RPAREN] = ACTIONS(57), + [anon_sym_POUND_LBRACE] = ACTIONS(41), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(43), + [anon_sym_DOLLAR] = ACTIONS(45), + [sym_number_literal] = ACTIONS(47), + [anon_sym_L_DQUOTE] = ACTIONS(17), + [anon_sym_u_DQUOTE] = ACTIONS(17), + [anon_sym_U_DQUOTE] = ACTIONS(17), + [anon_sym_u8_DQUOTE] = ACTIONS(17), + [anon_sym_DQUOTE] = ACTIONS(17), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_PIPE_DASH] = ACTIONS(49), + [sym_identifier] = ACTIONS(51), + [sym_boolean] = ACTIONS(53), + }, + [5] = { + [sym_dict] = STATE(97), + [sym_preproc_call] = STATE(97), + [sym__special_preproc_call] = STATE(87), + [sym__cond_preproc_call] = STATE(108), + [sym__generic_preproc_call] = STATE(96), + [sym__value] = STATE(119), + [sym_dimensions] = STATE(97), + [sym_list] = STATE(114), + [sym__uniform_list] = STATE(106), + [sym__non_uniform_list] = STATE(104), + [sym__list_item] = STATE(115), + [sym_dict_headless] = STATE(119), + [sym_code] = STATE(97), + [sym_macro] = STATE(97), + [sym__macro_braces] = STATE(101), + [sym__macro_no_braces] = STATE(101), + [sym_string_literal] = STATE(114), + [sym_comment] = STATE(5), + [sym_pyfoam_template] = STATE(5), + [sym_pyfoam_expression] = STATE(97), + [aux_sym__non_uniform_list_repeat1] = STATE(8), + [anon_sym_LBRACE] = ACTIONS(27), + [aux_sym__special_preproc_call_token1] = ACTIONS(29), + [aux_sym__special_preproc_call_token2] = ACTIONS(29), + [aux_sym__cond_preproc_call_token1] = ACTIONS(31), + [anon_sym_POUND] = ACTIONS(33), + [anon_sym_LBRACK] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_RPAREN] = ACTIONS(59), + [anon_sym_POUND_LBRACE] = ACTIONS(41), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(43), + [anon_sym_DOLLAR] = ACTIONS(45), + [sym_number_literal] = ACTIONS(47), + [anon_sym_L_DQUOTE] = ACTIONS(17), + [anon_sym_u_DQUOTE] = ACTIONS(17), + [anon_sym_U_DQUOTE] = ACTIONS(17), + [anon_sym_u8_DQUOTE] = ACTIONS(17), + [anon_sym_DQUOTE] = ACTIONS(17), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_PIPE_DASH] = ACTIONS(49), + [sym_identifier] = ACTIONS(51), + [sym_boolean] = ACTIONS(53), + }, + [6] = { + [sym_dict] = STATE(97), + [sym_preproc_call] = STATE(97), + [sym__special_preproc_call] = STATE(87), + [sym__cond_preproc_call] = STATE(108), + [sym__generic_preproc_call] = STATE(96), + [sym__value] = STATE(119), + [sym_dimensions] = STATE(97), + [sym_list] = STATE(114), + [sym__uniform_list] = STATE(106), + [sym__non_uniform_list] = STATE(104), + [sym__list_item] = STATE(115), + [sym_dict_headless] = STATE(119), + [sym_code] = STATE(97), + [sym_macro] = STATE(97), + [sym__macro_braces] = STATE(101), + [sym__macro_no_braces] = STATE(101), + [sym_string_literal] = STATE(114), + [sym_comment] = STATE(6), + [sym_pyfoam_template] = STATE(6), + [sym_pyfoam_expression] = STATE(97), + [aux_sym__non_uniform_list_repeat1] = STATE(24), + [anon_sym_LBRACE] = ACTIONS(27), + [aux_sym__special_preproc_call_token1] = ACTIONS(29), + [aux_sym__special_preproc_call_token2] = ACTIONS(29), + [aux_sym__cond_preproc_call_token1] = ACTIONS(31), + [anon_sym_POUND] = ACTIONS(33), + [anon_sym_LBRACK] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_RPAREN] = ACTIONS(61), + [anon_sym_POUND_LBRACE] = ACTIONS(41), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(43), + [anon_sym_DOLLAR] = ACTIONS(45), + [sym_number_literal] = ACTIONS(47), + [anon_sym_L_DQUOTE] = ACTIONS(17), + [anon_sym_u_DQUOTE] = ACTIONS(17), + [anon_sym_U_DQUOTE] = ACTIONS(17), + [anon_sym_u8_DQUOTE] = ACTIONS(17), + [anon_sym_DQUOTE] = ACTIONS(17), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_PIPE_DASH] = ACTIONS(49), + [sym_identifier] = ACTIONS(51), + [sym_boolean] = ACTIONS(53), + }, + [7] = { + [sym_dict] = STATE(97), + [sym_preproc_call] = STATE(97), + [sym__special_preproc_call] = STATE(87), + [sym__cond_preproc_call] = STATE(108), + [sym__generic_preproc_call] = STATE(96), + [sym__value] = STATE(119), + [sym_dimensions] = STATE(97), + [sym_list] = STATE(114), + [sym__uniform_list] = STATE(106), + [sym__non_uniform_list] = STATE(104), + [sym__list_item] = STATE(115), + [sym_dict_headless] = STATE(119), + [sym_code] = STATE(97), + [sym_macro] = STATE(97), + [sym__macro_braces] = STATE(101), + [sym__macro_no_braces] = STATE(101), + [sym_string_literal] = STATE(114), + [sym_comment] = STATE(7), + [sym_pyfoam_template] = STATE(7), + [sym_pyfoam_expression] = STATE(97), + [aux_sym__non_uniform_list_repeat1] = STATE(8), + [anon_sym_LBRACE] = ACTIONS(27), + [aux_sym__special_preproc_call_token1] = ACTIONS(29), + [aux_sym__special_preproc_call_token2] = ACTIONS(29), + [aux_sym__cond_preproc_call_token1] = ACTIONS(31), + [anon_sym_POUND] = ACTIONS(33), + [anon_sym_LBRACK] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_RPAREN] = ACTIONS(63), + [anon_sym_POUND_LBRACE] = ACTIONS(41), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(43), + [anon_sym_DOLLAR] = ACTIONS(45), + [sym_number_literal] = ACTIONS(47), + [anon_sym_L_DQUOTE] = ACTIONS(17), + [anon_sym_u_DQUOTE] = ACTIONS(17), + [anon_sym_U_DQUOTE] = ACTIONS(17), + [anon_sym_u8_DQUOTE] = ACTIONS(17), + [anon_sym_DQUOTE] = ACTIONS(17), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_PIPE_DASH] = ACTIONS(49), + [sym_identifier] = ACTIONS(51), + [sym_boolean] = ACTIONS(53), + }, + [8] = { + [sym_dict] = STATE(97), + [sym_preproc_call] = STATE(97), + [sym__special_preproc_call] = STATE(87), + [sym__cond_preproc_call] = STATE(108), + [sym__generic_preproc_call] = STATE(96), + [sym__value] = STATE(119), + [sym_dimensions] = STATE(97), + [sym_list] = STATE(114), + [sym__uniform_list] = STATE(106), + [sym__non_uniform_list] = STATE(104), + [sym__list_item] = STATE(115), + [sym_dict_headless] = STATE(119), + [sym_code] = STATE(97), + [sym_macro] = STATE(97), + [sym__macro_braces] = STATE(101), + [sym__macro_no_braces] = STATE(101), + [sym_string_literal] = STATE(114), + [sym_comment] = STATE(8), + [sym_pyfoam_template] = STATE(8), + [sym_pyfoam_expression] = STATE(97), + [aux_sym__non_uniform_list_repeat1] = STATE(8), + [anon_sym_LBRACE] = ACTIONS(65), + [aux_sym__special_preproc_call_token1] = ACTIONS(68), + [aux_sym__special_preproc_call_token2] = ACTIONS(68), + [aux_sym__cond_preproc_call_token1] = ACTIONS(71), + [anon_sym_POUND] = ACTIONS(74), + [anon_sym_LBRACK] = ACTIONS(77), + [anon_sym_LPAREN] = ACTIONS(80), + [anon_sym_RPAREN] = ACTIONS(83), + [anon_sym_POUND_LBRACE] = ACTIONS(85), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(88), + [anon_sym_DOLLAR] = ACTIONS(91), + [sym_number_literal] = ACTIONS(94), + [anon_sym_L_DQUOTE] = ACTIONS(97), + [anon_sym_u_DQUOTE] = ACTIONS(97), + [anon_sym_U_DQUOTE] = ACTIONS(97), + [anon_sym_u8_DQUOTE] = ACTIONS(97), + [anon_sym_DQUOTE] = ACTIONS(97), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_PIPE_DASH] = ACTIONS(100), + [sym_identifier] = ACTIONS(103), + [sym_boolean] = ACTIONS(106), + }, + [9] = { + [sym_dict] = STATE(97), + [sym_preproc_call] = STATE(97), + [sym__special_preproc_call] = STATE(87), + [sym__cond_preproc_call] = STATE(108), + [sym__generic_preproc_call] = STATE(96), + [sym__value] = STATE(119), + [sym_dimensions] = STATE(97), + [sym_list] = STATE(114), + [sym__uniform_list] = STATE(106), + [sym__non_uniform_list] = STATE(104), + [sym__list_item] = STATE(115), + [sym_dict_headless] = STATE(119), + [sym_code] = STATE(97), + [sym_macro] = STATE(97), + [sym__macro_braces] = STATE(101), + [sym__macro_no_braces] = STATE(101), + [sym_string_literal] = STATE(114), + [sym_comment] = STATE(9), + [sym_pyfoam_template] = STATE(9), + [sym_pyfoam_expression] = STATE(97), + [aux_sym__non_uniform_list_repeat1] = STATE(27), + [anon_sym_LBRACE] = ACTIONS(27), + [aux_sym__special_preproc_call_token1] = ACTIONS(29), + [aux_sym__special_preproc_call_token2] = ACTIONS(29), + [aux_sym__cond_preproc_call_token1] = ACTIONS(31), + [anon_sym_POUND] = ACTIONS(33), + [anon_sym_LBRACK] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_RPAREN] = ACTIONS(109), + [anon_sym_POUND_LBRACE] = ACTIONS(41), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(43), + [anon_sym_DOLLAR] = ACTIONS(45), + [sym_number_literal] = ACTIONS(47), + [anon_sym_L_DQUOTE] = ACTIONS(17), + [anon_sym_u_DQUOTE] = ACTIONS(17), + [anon_sym_U_DQUOTE] = ACTIONS(17), + [anon_sym_u8_DQUOTE] = ACTIONS(17), + [anon_sym_DQUOTE] = ACTIONS(17), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_PIPE_DASH] = ACTIONS(49), + [sym_identifier] = ACTIONS(51), + [sym_boolean] = ACTIONS(53), + }, + [10] = { + [sym_dict] = STATE(97), + [sym_preproc_call] = STATE(97), + [sym__special_preproc_call] = STATE(87), + [sym__cond_preproc_call] = STATE(108), + [sym__generic_preproc_call] = STATE(96), + [sym__value] = STATE(119), + [sym_dimensions] = STATE(97), + [sym_list] = STATE(114), + [sym__uniform_list] = STATE(106), + [sym__non_uniform_list] = STATE(104), + [sym__list_item] = STATE(115), + [sym_dict_headless] = STATE(119), + [sym_code] = STATE(97), + [sym_macro] = STATE(97), + [sym__macro_braces] = STATE(101), + [sym__macro_no_braces] = STATE(101), + [sym_string_literal] = STATE(114), + [sym_comment] = STATE(10), + [sym_pyfoam_template] = STATE(10), + [sym_pyfoam_expression] = STATE(97), + [aux_sym__non_uniform_list_repeat1] = STATE(7), + [anon_sym_LBRACE] = ACTIONS(27), + [aux_sym__special_preproc_call_token1] = ACTIONS(29), + [aux_sym__special_preproc_call_token2] = ACTIONS(29), + [aux_sym__cond_preproc_call_token1] = ACTIONS(31), + [anon_sym_POUND] = ACTIONS(33), + [anon_sym_LBRACK] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_RPAREN] = ACTIONS(111), + [anon_sym_POUND_LBRACE] = ACTIONS(41), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(43), + [anon_sym_DOLLAR] = ACTIONS(45), + [sym_number_literal] = ACTIONS(47), + [anon_sym_L_DQUOTE] = ACTIONS(17), + [anon_sym_u_DQUOTE] = ACTIONS(17), + [anon_sym_U_DQUOTE] = ACTIONS(17), + [anon_sym_u8_DQUOTE] = ACTIONS(17), + [anon_sym_DQUOTE] = ACTIONS(17), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_PIPE_DASH] = ACTIONS(49), + [sym_identifier] = ACTIONS(51), + [sym_boolean] = ACTIONS(53), + }, + [11] = { + [sym_dict] = STATE(97), + [sym_preproc_call] = STATE(97), + [sym__special_preproc_call] = STATE(87), + [sym__cond_preproc_call] = STATE(108), + [sym__generic_preproc_call] = STATE(96), + [sym__value] = STATE(119), + [sym_dimensions] = STATE(97), + [sym_list] = STATE(114), + [sym__uniform_list] = STATE(106), + [sym__non_uniform_list] = STATE(104), + [sym__list_item] = STATE(115), + [sym_dict_headless] = STATE(119), + [sym_code] = STATE(97), + [sym_macro] = STATE(97), + [sym__macro_braces] = STATE(101), + [sym__macro_no_braces] = STATE(101), + [sym_string_literal] = STATE(114), + [sym_comment] = STATE(11), + [sym_pyfoam_template] = STATE(11), + [sym_pyfoam_expression] = STATE(97), + [aux_sym__non_uniform_list_repeat1] = STATE(8), + [anon_sym_LBRACE] = ACTIONS(27), + [aux_sym__special_preproc_call_token1] = ACTIONS(29), + [aux_sym__special_preproc_call_token2] = ACTIONS(29), + [aux_sym__cond_preproc_call_token1] = ACTIONS(31), + [anon_sym_POUND] = ACTIONS(33), + [anon_sym_LBRACK] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_RPAREN] = ACTIONS(113), + [anon_sym_POUND_LBRACE] = ACTIONS(41), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(43), + [anon_sym_DOLLAR] = ACTIONS(45), + [sym_number_literal] = ACTIONS(47), + [anon_sym_L_DQUOTE] = ACTIONS(17), + [anon_sym_u_DQUOTE] = ACTIONS(17), + [anon_sym_U_DQUOTE] = ACTIONS(17), + [anon_sym_u8_DQUOTE] = ACTIONS(17), + [anon_sym_DQUOTE] = ACTIONS(17), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_PIPE_DASH] = ACTIONS(49), + [sym_identifier] = ACTIONS(51), + [sym_boolean] = ACTIONS(53), + }, + [12] = { + [sym_dict] = STATE(97), + [sym_preproc_call] = STATE(97), + [sym__special_preproc_call] = STATE(87), + [sym__cond_preproc_call] = STATE(108), + [sym__generic_preproc_call] = STATE(96), + [sym__value] = STATE(119), + [sym_dimensions] = STATE(97), + [sym_list] = STATE(114), + [sym__uniform_list] = STATE(106), + [sym__non_uniform_list] = STATE(104), + [sym__list_item] = STATE(115), + [sym_dict_headless] = STATE(119), + [sym_code] = STATE(97), + [sym_macro] = STATE(97), + [sym__macro_braces] = STATE(101), + [sym__macro_no_braces] = STATE(101), + [sym_string_literal] = STATE(114), + [sym_comment] = STATE(12), + [sym_pyfoam_template] = STATE(12), + [sym_pyfoam_expression] = STATE(97), + [aux_sym__non_uniform_list_repeat1] = STATE(8), + [anon_sym_LBRACE] = ACTIONS(27), + [aux_sym__special_preproc_call_token1] = ACTIONS(29), + [aux_sym__special_preproc_call_token2] = ACTIONS(29), + [aux_sym__cond_preproc_call_token1] = ACTIONS(31), + [anon_sym_POUND] = ACTIONS(33), + [anon_sym_LBRACK] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_RPAREN] = ACTIONS(115), + [anon_sym_POUND_LBRACE] = ACTIONS(41), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(43), + [anon_sym_DOLLAR] = ACTIONS(45), + [sym_number_literal] = ACTIONS(47), + [anon_sym_L_DQUOTE] = ACTIONS(17), + [anon_sym_u_DQUOTE] = ACTIONS(17), + [anon_sym_U_DQUOTE] = ACTIONS(17), + [anon_sym_u8_DQUOTE] = ACTIONS(17), + [anon_sym_DQUOTE] = ACTIONS(17), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_PIPE_DASH] = ACTIONS(49), + [sym_identifier] = ACTIONS(51), + [sym_boolean] = ACTIONS(53), + }, + [13] = { + [sym_dict] = STATE(97), + [sym_preproc_call] = STATE(97), + [sym__special_preproc_call] = STATE(87), + [sym__cond_preproc_call] = STATE(108), + [sym__generic_preproc_call] = STATE(96), + [sym__value] = STATE(119), + [sym_dimensions] = STATE(97), + [sym_list] = STATE(114), + [sym__uniform_list] = STATE(106), + [sym__non_uniform_list] = STATE(104), + [sym__list_item] = STATE(115), + [sym_dict_headless] = STATE(119), + [sym_code] = STATE(97), + [sym_macro] = STATE(97), + [sym__macro_braces] = STATE(101), + [sym__macro_no_braces] = STATE(101), + [sym_string_literal] = STATE(114), + [sym_comment] = STATE(13), + [sym_pyfoam_template] = STATE(13), + [sym_pyfoam_expression] = STATE(97), + [aux_sym__non_uniform_list_repeat1] = STATE(8), + [anon_sym_LBRACE] = ACTIONS(27), + [aux_sym__special_preproc_call_token1] = ACTIONS(29), + [aux_sym__special_preproc_call_token2] = ACTIONS(29), + [aux_sym__cond_preproc_call_token1] = ACTIONS(31), + [anon_sym_POUND] = ACTIONS(33), + [anon_sym_LBRACK] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_RPAREN] = ACTIONS(117), + [anon_sym_POUND_LBRACE] = ACTIONS(41), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(43), + [anon_sym_DOLLAR] = ACTIONS(45), + [sym_number_literal] = ACTIONS(47), + [anon_sym_L_DQUOTE] = ACTIONS(17), + [anon_sym_u_DQUOTE] = ACTIONS(17), + [anon_sym_U_DQUOTE] = ACTIONS(17), + [anon_sym_u8_DQUOTE] = ACTIONS(17), + [anon_sym_DQUOTE] = ACTIONS(17), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_PIPE_DASH] = ACTIONS(49), + [sym_identifier] = ACTIONS(51), + [sym_boolean] = ACTIONS(53), + }, + [14] = { + [sym_dict] = STATE(97), + [sym_preproc_call] = STATE(97), + [sym__special_preproc_call] = STATE(87), + [sym__cond_preproc_call] = STATE(108), + [sym__generic_preproc_call] = STATE(96), + [sym__value] = STATE(119), + [sym_dimensions] = STATE(97), + [sym_list] = STATE(114), + [sym__uniform_list] = STATE(106), + [sym__non_uniform_list] = STATE(104), + [sym__list_item] = STATE(115), + [sym_dict_headless] = STATE(119), + [sym_code] = STATE(97), + [sym_macro] = STATE(97), + [sym__macro_braces] = STATE(101), + [sym__macro_no_braces] = STATE(101), + [sym_string_literal] = STATE(114), + [sym_comment] = STATE(14), + [sym_pyfoam_template] = STATE(14), + [sym_pyfoam_expression] = STATE(97), + [aux_sym__non_uniform_list_repeat1] = STATE(26), + [anon_sym_LBRACE] = ACTIONS(27), + [aux_sym__special_preproc_call_token1] = ACTIONS(29), + [aux_sym__special_preproc_call_token2] = ACTIONS(29), + [aux_sym__cond_preproc_call_token1] = ACTIONS(31), + [anon_sym_POUND] = ACTIONS(33), + [anon_sym_LBRACK] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_RPAREN] = ACTIONS(119), + [anon_sym_POUND_LBRACE] = ACTIONS(41), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(43), + [anon_sym_DOLLAR] = ACTIONS(45), + [sym_number_literal] = ACTIONS(47), + [anon_sym_L_DQUOTE] = ACTIONS(17), + [anon_sym_u_DQUOTE] = ACTIONS(17), + [anon_sym_U_DQUOTE] = ACTIONS(17), + [anon_sym_u8_DQUOTE] = ACTIONS(17), + [anon_sym_DQUOTE] = ACTIONS(17), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_PIPE_DASH] = ACTIONS(49), + [sym_identifier] = ACTIONS(51), + [sym_boolean] = ACTIONS(53), + }, + [15] = { + [sym_dict] = STATE(97), + [sym_preproc_call] = STATE(97), + [sym__special_preproc_call] = STATE(87), + [sym__cond_preproc_call] = STATE(108), + [sym__generic_preproc_call] = STATE(96), + [sym__value] = STATE(119), + [sym_dimensions] = STATE(97), + [sym_list] = STATE(114), + [sym__uniform_list] = STATE(106), + [sym__non_uniform_list] = STATE(104), + [sym__list_item] = STATE(115), + [sym_dict_headless] = STATE(119), + [sym_code] = STATE(97), + [sym_macro] = STATE(97), + [sym__macro_braces] = STATE(101), + [sym__macro_no_braces] = STATE(101), + [sym_string_literal] = STATE(114), + [sym_comment] = STATE(15), + [sym_pyfoam_template] = STATE(15), + [sym_pyfoam_expression] = STATE(97), + [aux_sym__non_uniform_list_repeat1] = STATE(3), + [anon_sym_LBRACE] = ACTIONS(27), + [aux_sym__special_preproc_call_token1] = ACTIONS(29), + [aux_sym__special_preproc_call_token2] = ACTIONS(29), + [aux_sym__cond_preproc_call_token1] = ACTIONS(31), + [anon_sym_POUND] = ACTIONS(33), + [anon_sym_LBRACK] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_RPAREN] = ACTIONS(121), + [anon_sym_POUND_LBRACE] = ACTIONS(41), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(43), + [anon_sym_DOLLAR] = ACTIONS(45), + [sym_number_literal] = ACTIONS(47), + [anon_sym_L_DQUOTE] = ACTIONS(17), + [anon_sym_u_DQUOTE] = ACTIONS(17), + [anon_sym_U_DQUOTE] = ACTIONS(17), + [anon_sym_u8_DQUOTE] = ACTIONS(17), + [anon_sym_DQUOTE] = ACTIONS(17), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_PIPE_DASH] = ACTIONS(49), + [sym_identifier] = ACTIONS(51), + [sym_boolean] = ACTIONS(53), + }, + [16] = { + [sym_dict] = STATE(97), + [sym_preproc_call] = STATE(97), + [sym__special_preproc_call] = STATE(87), + [sym__cond_preproc_call] = STATE(108), + [sym__generic_preproc_call] = STATE(96), + [sym__value] = STATE(119), + [sym_dimensions] = STATE(97), + [sym_list] = STATE(114), + [sym__uniform_list] = STATE(106), + [sym__non_uniform_list] = STATE(104), + [sym__list_item] = STATE(115), + [sym_dict_headless] = STATE(119), + [sym_code] = STATE(97), + [sym_macro] = STATE(97), + [sym__macro_braces] = STATE(101), + [sym__macro_no_braces] = STATE(101), + [sym_string_literal] = STATE(114), + [sym_comment] = STATE(16), + [sym_pyfoam_template] = STATE(16), + [sym_pyfoam_expression] = STATE(97), + [aux_sym__non_uniform_list_repeat1] = STATE(8), + [anon_sym_LBRACE] = ACTIONS(27), + [aux_sym__special_preproc_call_token1] = ACTIONS(29), + [aux_sym__special_preproc_call_token2] = ACTIONS(29), + [aux_sym__cond_preproc_call_token1] = ACTIONS(31), + [anon_sym_POUND] = ACTIONS(33), + [anon_sym_LBRACK] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_RPAREN] = ACTIONS(123), + [anon_sym_POUND_LBRACE] = ACTIONS(41), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(43), + [anon_sym_DOLLAR] = ACTIONS(45), + [sym_number_literal] = ACTIONS(47), + [anon_sym_L_DQUOTE] = ACTIONS(17), + [anon_sym_u_DQUOTE] = ACTIONS(17), + [anon_sym_U_DQUOTE] = ACTIONS(17), + [anon_sym_u8_DQUOTE] = ACTIONS(17), + [anon_sym_DQUOTE] = ACTIONS(17), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_PIPE_DASH] = ACTIONS(49), + [sym_identifier] = ACTIONS(51), + [sym_boolean] = ACTIONS(53), + }, + [17] = { + [sym_dict] = STATE(97), + [sym_preproc_call] = STATE(97), + [sym__special_preproc_call] = STATE(87), + [sym__cond_preproc_call] = STATE(108), + [sym__generic_preproc_call] = STATE(96), + [sym__value] = STATE(119), + [sym_dimensions] = STATE(97), + [sym_list] = STATE(114), + [sym__uniform_list] = STATE(106), + [sym__non_uniform_list] = STATE(104), + [sym__list_item] = STATE(115), + [sym_dict_headless] = STATE(119), + [sym_code] = STATE(97), + [sym_macro] = STATE(97), + [sym__macro_braces] = STATE(101), + [sym__macro_no_braces] = STATE(101), + [sym_string_literal] = STATE(114), + [sym_comment] = STATE(17), + [sym_pyfoam_template] = STATE(17), + [sym_pyfoam_expression] = STATE(97), + [aux_sym__non_uniform_list_repeat1] = STATE(8), + [anon_sym_LBRACE] = ACTIONS(27), + [aux_sym__special_preproc_call_token1] = ACTIONS(29), + [aux_sym__special_preproc_call_token2] = ACTIONS(29), + [aux_sym__cond_preproc_call_token1] = ACTIONS(31), + [anon_sym_POUND] = ACTIONS(33), + [anon_sym_LBRACK] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_RPAREN] = ACTIONS(125), + [anon_sym_POUND_LBRACE] = ACTIONS(41), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(43), + [anon_sym_DOLLAR] = ACTIONS(45), + [sym_number_literal] = ACTIONS(47), + [anon_sym_L_DQUOTE] = ACTIONS(17), + [anon_sym_u_DQUOTE] = ACTIONS(17), + [anon_sym_U_DQUOTE] = ACTIONS(17), + [anon_sym_u8_DQUOTE] = ACTIONS(17), + [anon_sym_DQUOTE] = ACTIONS(17), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_PIPE_DASH] = ACTIONS(49), + [sym_identifier] = ACTIONS(51), + [sym_boolean] = ACTIONS(53), + }, + [18] = { + [sym_dict] = STATE(97), + [sym_preproc_call] = STATE(97), + [sym__special_preproc_call] = STATE(87), + [sym__cond_preproc_call] = STATE(108), + [sym__generic_preproc_call] = STATE(96), + [sym__value] = STATE(119), + [sym_dimensions] = STATE(97), + [sym_list] = STATE(114), + [sym__uniform_list] = STATE(106), + [sym__non_uniform_list] = STATE(104), + [sym__list_item] = STATE(115), + [sym_dict_headless] = STATE(119), + [sym_code] = STATE(97), + [sym_macro] = STATE(97), + [sym__macro_braces] = STATE(101), + [sym__macro_no_braces] = STATE(101), + [sym_string_literal] = STATE(114), + [sym_comment] = STATE(18), + [sym_pyfoam_template] = STATE(18), + [sym_pyfoam_expression] = STATE(97), + [aux_sym__non_uniform_list_repeat1] = STATE(8), + [anon_sym_LBRACE] = ACTIONS(27), + [aux_sym__special_preproc_call_token1] = ACTIONS(29), + [aux_sym__special_preproc_call_token2] = ACTIONS(29), + [aux_sym__cond_preproc_call_token1] = ACTIONS(31), + [anon_sym_POUND] = ACTIONS(33), + [anon_sym_LBRACK] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_RPAREN] = ACTIONS(127), + [anon_sym_POUND_LBRACE] = ACTIONS(41), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(43), + [anon_sym_DOLLAR] = ACTIONS(45), + [sym_number_literal] = ACTIONS(47), + [anon_sym_L_DQUOTE] = ACTIONS(17), + [anon_sym_u_DQUOTE] = ACTIONS(17), + [anon_sym_U_DQUOTE] = ACTIONS(17), + [anon_sym_u8_DQUOTE] = ACTIONS(17), + [anon_sym_DQUOTE] = ACTIONS(17), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_PIPE_DASH] = ACTIONS(49), + [sym_identifier] = ACTIONS(51), + [sym_boolean] = ACTIONS(53), + }, + [19] = { + [sym_dict] = STATE(97), + [sym_preproc_call] = STATE(97), + [sym__special_preproc_call] = STATE(87), + [sym__cond_preproc_call] = STATE(108), + [sym__generic_preproc_call] = STATE(96), + [sym__value] = STATE(119), + [sym_dimensions] = STATE(97), + [sym_list] = STATE(114), + [sym__uniform_list] = STATE(106), + [sym__non_uniform_list] = STATE(104), + [sym__list_item] = STATE(115), + [sym_dict_headless] = STATE(119), + [sym_code] = STATE(97), + [sym_macro] = STATE(97), + [sym__macro_braces] = STATE(101), + [sym__macro_no_braces] = STATE(101), + [sym_string_literal] = STATE(114), + [sym_comment] = STATE(19), + [sym_pyfoam_template] = STATE(19), + [sym_pyfoam_expression] = STATE(97), + [aux_sym__non_uniform_list_repeat1] = STATE(13), + [anon_sym_LBRACE] = ACTIONS(27), + [aux_sym__special_preproc_call_token1] = ACTIONS(29), + [aux_sym__special_preproc_call_token2] = ACTIONS(29), + [aux_sym__cond_preproc_call_token1] = ACTIONS(31), + [anon_sym_POUND] = ACTIONS(33), + [anon_sym_LBRACK] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_RPAREN] = ACTIONS(129), + [anon_sym_POUND_LBRACE] = ACTIONS(41), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(43), + [anon_sym_DOLLAR] = ACTIONS(45), + [sym_number_literal] = ACTIONS(47), + [anon_sym_L_DQUOTE] = ACTIONS(17), + [anon_sym_u_DQUOTE] = ACTIONS(17), + [anon_sym_U_DQUOTE] = ACTIONS(17), + [anon_sym_u8_DQUOTE] = ACTIONS(17), + [anon_sym_DQUOTE] = ACTIONS(17), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_PIPE_DASH] = ACTIONS(49), + [sym_identifier] = ACTIONS(51), + [sym_boolean] = ACTIONS(53), + }, + [20] = { + [sym_dict] = STATE(97), + [sym_preproc_call] = STATE(97), + [sym__special_preproc_call] = STATE(87), + [sym__cond_preproc_call] = STATE(108), + [sym__generic_preproc_call] = STATE(96), + [sym__value] = STATE(119), + [sym_dimensions] = STATE(97), + [sym_list] = STATE(114), + [sym__uniform_list] = STATE(106), + [sym__non_uniform_list] = STATE(104), + [sym__list_item] = STATE(115), + [sym_dict_headless] = STATE(119), + [sym_code] = STATE(97), + [sym_macro] = STATE(97), + [sym__macro_braces] = STATE(101), + [sym__macro_no_braces] = STATE(101), + [sym_string_literal] = STATE(114), + [sym_comment] = STATE(20), + [sym_pyfoam_template] = STATE(20), + [sym_pyfoam_expression] = STATE(97), + [aux_sym__non_uniform_list_repeat1] = STATE(18), + [anon_sym_LBRACE] = ACTIONS(27), + [aux_sym__special_preproc_call_token1] = ACTIONS(29), + [aux_sym__special_preproc_call_token2] = ACTIONS(29), + [aux_sym__cond_preproc_call_token1] = ACTIONS(31), + [anon_sym_POUND] = ACTIONS(33), + [anon_sym_LBRACK] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_RPAREN] = ACTIONS(131), + [anon_sym_POUND_LBRACE] = ACTIONS(41), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(43), + [anon_sym_DOLLAR] = ACTIONS(45), + [sym_number_literal] = ACTIONS(47), + [anon_sym_L_DQUOTE] = ACTIONS(17), + [anon_sym_u_DQUOTE] = ACTIONS(17), + [anon_sym_U_DQUOTE] = ACTIONS(17), + [anon_sym_u8_DQUOTE] = ACTIONS(17), + [anon_sym_DQUOTE] = ACTIONS(17), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_PIPE_DASH] = ACTIONS(49), + [sym_identifier] = ACTIONS(51), + [sym_boolean] = ACTIONS(53), + }, + [21] = { + [sym_dict] = STATE(97), + [sym_preproc_call] = STATE(97), + [sym__special_preproc_call] = STATE(87), + [sym__cond_preproc_call] = STATE(108), + [sym__generic_preproc_call] = STATE(96), + [sym__value] = STATE(119), + [sym_dimensions] = STATE(97), + [sym_list] = STATE(114), + [sym__uniform_list] = STATE(106), + [sym__non_uniform_list] = STATE(104), + [sym__list_item] = STATE(115), + [sym_dict_headless] = STATE(119), + [sym_code] = STATE(97), + [sym_macro] = STATE(97), + [sym__macro_braces] = STATE(101), + [sym__macro_no_braces] = STATE(101), + [sym_string_literal] = STATE(114), + [sym_comment] = STATE(21), + [sym_pyfoam_template] = STATE(21), + [sym_pyfoam_expression] = STATE(97), + [aux_sym__non_uniform_list_repeat1] = STATE(8), + [anon_sym_LBRACE] = ACTIONS(27), + [aux_sym__special_preproc_call_token1] = ACTIONS(29), + [aux_sym__special_preproc_call_token2] = ACTIONS(29), + [aux_sym__cond_preproc_call_token1] = ACTIONS(31), + [anon_sym_POUND] = ACTIONS(33), + [anon_sym_LBRACK] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_RPAREN] = ACTIONS(133), + [anon_sym_POUND_LBRACE] = ACTIONS(41), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(43), + [anon_sym_DOLLAR] = ACTIONS(45), + [sym_number_literal] = ACTIONS(47), + [anon_sym_L_DQUOTE] = ACTIONS(17), + [anon_sym_u_DQUOTE] = ACTIONS(17), + [anon_sym_U_DQUOTE] = ACTIONS(17), + [anon_sym_u8_DQUOTE] = ACTIONS(17), + [anon_sym_DQUOTE] = ACTIONS(17), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_PIPE_DASH] = ACTIONS(49), + [sym_identifier] = ACTIONS(51), + [sym_boolean] = ACTIONS(53), + }, + [22] = { + [sym_dict] = STATE(97), + [sym_preproc_call] = STATE(97), + [sym__special_preproc_call] = STATE(87), + [sym__cond_preproc_call] = STATE(108), + [sym__generic_preproc_call] = STATE(96), + [sym__value] = STATE(119), + [sym_dimensions] = STATE(97), + [sym_list] = STATE(114), + [sym__uniform_list] = STATE(106), + [sym__non_uniform_list] = STATE(104), + [sym__list_item] = STATE(115), + [sym_dict_headless] = STATE(119), + [sym_code] = STATE(97), + [sym_macro] = STATE(97), + [sym__macro_braces] = STATE(101), + [sym__macro_no_braces] = STATE(101), + [sym_string_literal] = STATE(114), + [sym_comment] = STATE(22), + [sym_pyfoam_template] = STATE(22), + [sym_pyfoam_expression] = STATE(97), + [aux_sym__non_uniform_list_repeat1] = STATE(8), + [anon_sym_LBRACE] = ACTIONS(27), + [aux_sym__special_preproc_call_token1] = ACTIONS(29), + [aux_sym__special_preproc_call_token2] = ACTIONS(29), + [aux_sym__cond_preproc_call_token1] = ACTIONS(31), + [anon_sym_POUND] = ACTIONS(33), + [anon_sym_LBRACK] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_RPAREN] = ACTIONS(135), + [anon_sym_POUND_LBRACE] = ACTIONS(41), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(43), + [anon_sym_DOLLAR] = ACTIONS(45), + [sym_number_literal] = ACTIONS(47), + [anon_sym_L_DQUOTE] = ACTIONS(17), + [anon_sym_u_DQUOTE] = ACTIONS(17), + [anon_sym_U_DQUOTE] = ACTIONS(17), + [anon_sym_u8_DQUOTE] = ACTIONS(17), + [anon_sym_DQUOTE] = ACTIONS(17), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_PIPE_DASH] = ACTIONS(49), + [sym_identifier] = ACTIONS(51), + [sym_boolean] = ACTIONS(53), + }, + [23] = { + [sym_dict] = STATE(97), + [sym_preproc_call] = STATE(97), + [sym__special_preproc_call] = STATE(87), + [sym__cond_preproc_call] = STATE(108), + [sym__generic_preproc_call] = STATE(96), + [sym__value] = STATE(119), + [sym_dimensions] = STATE(97), + [sym_list] = STATE(114), + [sym__uniform_list] = STATE(106), + [sym__non_uniform_list] = STATE(104), + [sym__list_item] = STATE(115), + [sym_dict_headless] = STATE(119), + [sym_code] = STATE(97), + [sym_macro] = STATE(97), + [sym__macro_braces] = STATE(101), + [sym__macro_no_braces] = STATE(101), + [sym_string_literal] = STATE(114), + [sym_comment] = STATE(23), + [sym_pyfoam_template] = STATE(23), + [sym_pyfoam_expression] = STATE(97), + [aux_sym__non_uniform_list_repeat1] = STATE(16), + [anon_sym_LBRACE] = ACTIONS(27), + [aux_sym__special_preproc_call_token1] = ACTIONS(29), + [aux_sym__special_preproc_call_token2] = ACTIONS(29), + [aux_sym__cond_preproc_call_token1] = ACTIONS(31), + [anon_sym_POUND] = ACTIONS(33), + [anon_sym_LBRACK] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_RPAREN] = ACTIONS(137), + [anon_sym_POUND_LBRACE] = ACTIONS(41), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(43), + [anon_sym_DOLLAR] = ACTIONS(45), + [sym_number_literal] = ACTIONS(47), + [anon_sym_L_DQUOTE] = ACTIONS(17), + [anon_sym_u_DQUOTE] = ACTIONS(17), + [anon_sym_U_DQUOTE] = ACTIONS(17), + [anon_sym_u8_DQUOTE] = ACTIONS(17), + [anon_sym_DQUOTE] = ACTIONS(17), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_PIPE_DASH] = ACTIONS(49), + [sym_identifier] = ACTIONS(51), + [sym_boolean] = ACTIONS(53), + }, + [24] = { + [sym_dict] = STATE(97), + [sym_preproc_call] = STATE(97), + [sym__special_preproc_call] = STATE(87), + [sym__cond_preproc_call] = STATE(108), + [sym__generic_preproc_call] = STATE(96), + [sym__value] = STATE(119), + [sym_dimensions] = STATE(97), + [sym_list] = STATE(114), + [sym__uniform_list] = STATE(106), + [sym__non_uniform_list] = STATE(104), + [sym__list_item] = STATE(115), + [sym_dict_headless] = STATE(119), + [sym_code] = STATE(97), + [sym_macro] = STATE(97), + [sym__macro_braces] = STATE(101), + [sym__macro_no_braces] = STATE(101), + [sym_string_literal] = STATE(114), + [sym_comment] = STATE(24), + [sym_pyfoam_template] = STATE(24), + [sym_pyfoam_expression] = STATE(97), + [aux_sym__non_uniform_list_repeat1] = STATE(8), + [anon_sym_LBRACE] = ACTIONS(27), + [aux_sym__special_preproc_call_token1] = ACTIONS(29), + [aux_sym__special_preproc_call_token2] = ACTIONS(29), + [aux_sym__cond_preproc_call_token1] = ACTIONS(31), + [anon_sym_POUND] = ACTIONS(33), + [anon_sym_LBRACK] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_RPAREN] = ACTIONS(139), + [anon_sym_POUND_LBRACE] = ACTIONS(41), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(43), + [anon_sym_DOLLAR] = ACTIONS(45), + [sym_number_literal] = ACTIONS(47), + [anon_sym_L_DQUOTE] = ACTIONS(17), + [anon_sym_u_DQUOTE] = ACTIONS(17), + [anon_sym_U_DQUOTE] = ACTIONS(17), + [anon_sym_u8_DQUOTE] = ACTIONS(17), + [anon_sym_DQUOTE] = ACTIONS(17), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_PIPE_DASH] = ACTIONS(49), + [sym_identifier] = ACTIONS(51), + [sym_boolean] = ACTIONS(53), + }, + [25] = { + [sym_dict] = STATE(97), + [sym_preproc_call] = STATE(97), + [sym__special_preproc_call] = STATE(87), + [sym__cond_preproc_call] = STATE(108), + [sym__generic_preproc_call] = STATE(96), + [sym__value] = STATE(119), + [sym_dimensions] = STATE(97), + [sym_list] = STATE(114), + [sym__uniform_list] = STATE(106), + [sym__non_uniform_list] = STATE(104), + [sym__list_item] = STATE(115), + [sym_dict_headless] = STATE(119), + [sym_code] = STATE(97), + [sym_macro] = STATE(97), + [sym__macro_braces] = STATE(101), + [sym__macro_no_braces] = STATE(101), + [sym_string_literal] = STATE(114), + [sym_comment] = STATE(25), + [sym_pyfoam_template] = STATE(25), + [sym_pyfoam_expression] = STATE(97), + [aux_sym__non_uniform_list_repeat1] = STATE(8), + [anon_sym_LBRACE] = ACTIONS(27), + [aux_sym__special_preproc_call_token1] = ACTIONS(29), + [aux_sym__special_preproc_call_token2] = ACTIONS(29), + [aux_sym__cond_preproc_call_token1] = ACTIONS(31), + [anon_sym_POUND] = ACTIONS(33), + [anon_sym_LBRACK] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_RPAREN] = ACTIONS(141), + [anon_sym_POUND_LBRACE] = ACTIONS(41), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(43), + [anon_sym_DOLLAR] = ACTIONS(45), + [sym_number_literal] = ACTIONS(47), + [anon_sym_L_DQUOTE] = ACTIONS(17), + [anon_sym_u_DQUOTE] = ACTIONS(17), + [anon_sym_U_DQUOTE] = ACTIONS(17), + [anon_sym_u8_DQUOTE] = ACTIONS(17), + [anon_sym_DQUOTE] = ACTIONS(17), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_PIPE_DASH] = ACTIONS(49), + [sym_identifier] = ACTIONS(51), + [sym_boolean] = ACTIONS(53), + }, + [26] = { + [sym_dict] = STATE(97), + [sym_preproc_call] = STATE(97), + [sym__special_preproc_call] = STATE(87), + [sym__cond_preproc_call] = STATE(108), + [sym__generic_preproc_call] = STATE(96), + [sym__value] = STATE(119), + [sym_dimensions] = STATE(97), + [sym_list] = STATE(114), + [sym__uniform_list] = STATE(106), + [sym__non_uniform_list] = STATE(104), + [sym__list_item] = STATE(115), + [sym_dict_headless] = STATE(119), + [sym_code] = STATE(97), + [sym_macro] = STATE(97), + [sym__macro_braces] = STATE(101), + [sym__macro_no_braces] = STATE(101), + [sym_string_literal] = STATE(114), + [sym_comment] = STATE(26), + [sym_pyfoam_template] = STATE(26), + [sym_pyfoam_expression] = STATE(97), + [aux_sym__non_uniform_list_repeat1] = STATE(8), + [anon_sym_LBRACE] = ACTIONS(27), + [aux_sym__special_preproc_call_token1] = ACTIONS(29), + [aux_sym__special_preproc_call_token2] = ACTIONS(29), + [aux_sym__cond_preproc_call_token1] = ACTIONS(31), + [anon_sym_POUND] = ACTIONS(33), + [anon_sym_LBRACK] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_RPAREN] = ACTIONS(143), + [anon_sym_POUND_LBRACE] = ACTIONS(41), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(43), + [anon_sym_DOLLAR] = ACTIONS(45), + [sym_number_literal] = ACTIONS(47), + [anon_sym_L_DQUOTE] = ACTIONS(17), + [anon_sym_u_DQUOTE] = ACTIONS(17), + [anon_sym_U_DQUOTE] = ACTIONS(17), + [anon_sym_u8_DQUOTE] = ACTIONS(17), + [anon_sym_DQUOTE] = ACTIONS(17), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_PIPE_DASH] = ACTIONS(49), + [sym_identifier] = ACTIONS(51), + [sym_boolean] = ACTIONS(53), + }, + [27] = { + [sym_dict] = STATE(97), + [sym_preproc_call] = STATE(97), + [sym__special_preproc_call] = STATE(87), + [sym__cond_preproc_call] = STATE(108), + [sym__generic_preproc_call] = STATE(96), + [sym__value] = STATE(119), + [sym_dimensions] = STATE(97), + [sym_list] = STATE(114), + [sym__uniform_list] = STATE(106), + [sym__non_uniform_list] = STATE(104), + [sym__list_item] = STATE(115), + [sym_dict_headless] = STATE(119), + [sym_code] = STATE(97), + [sym_macro] = STATE(97), + [sym__macro_braces] = STATE(101), + [sym__macro_no_braces] = STATE(101), + [sym_string_literal] = STATE(114), + [sym_comment] = STATE(27), + [sym_pyfoam_template] = STATE(27), + [sym_pyfoam_expression] = STATE(97), + [aux_sym__non_uniform_list_repeat1] = STATE(8), + [anon_sym_LBRACE] = ACTIONS(27), + [aux_sym__special_preproc_call_token1] = ACTIONS(29), + [aux_sym__special_preproc_call_token2] = ACTIONS(29), + [aux_sym__cond_preproc_call_token1] = ACTIONS(31), + [anon_sym_POUND] = ACTIONS(33), + [anon_sym_LBRACK] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_RPAREN] = ACTIONS(145), + [anon_sym_POUND_LBRACE] = ACTIONS(41), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(43), + [anon_sym_DOLLAR] = ACTIONS(45), + [sym_number_literal] = ACTIONS(47), + [anon_sym_L_DQUOTE] = ACTIONS(17), + [anon_sym_u_DQUOTE] = ACTIONS(17), + [anon_sym_U_DQUOTE] = ACTIONS(17), + [anon_sym_u8_DQUOTE] = ACTIONS(17), + [anon_sym_DQUOTE] = ACTIONS(17), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_PIPE_DASH] = ACTIONS(49), + [sym_identifier] = ACTIONS(51), + [sym_boolean] = ACTIONS(53), + }, + [28] = { + [sym_dict] = STATE(97), + [sym_preproc_call] = STATE(97), + [sym__special_preproc_call] = STATE(87), + [sym__cond_preproc_call] = STATE(108), + [sym__generic_preproc_call] = STATE(96), + [sym__value] = STATE(119), + [sym_dimensions] = STATE(97), + [sym_list] = STATE(114), + [sym__uniform_list] = STATE(106), + [sym__non_uniform_list] = STATE(104), + [sym__list_item] = STATE(115), + [sym_dict_headless] = STATE(119), + [sym_code] = STATE(97), + [sym_macro] = STATE(97), + [sym__macro_braces] = STATE(101), + [sym__macro_no_braces] = STATE(101), + [sym_string_literal] = STATE(114), + [sym_comment] = STATE(28), + [sym_pyfoam_template] = STATE(28), + [sym_pyfoam_expression] = STATE(97), + [aux_sym__non_uniform_list_repeat1] = STATE(21), + [anon_sym_LBRACE] = ACTIONS(27), + [aux_sym__special_preproc_call_token1] = ACTIONS(29), + [aux_sym__special_preproc_call_token2] = ACTIONS(29), + [aux_sym__cond_preproc_call_token1] = ACTIONS(31), + [anon_sym_POUND] = ACTIONS(33), + [anon_sym_LBRACK] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_RPAREN] = ACTIONS(147), + [anon_sym_POUND_LBRACE] = ACTIONS(41), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(43), + [anon_sym_DOLLAR] = ACTIONS(45), + [sym_number_literal] = ACTIONS(47), + [anon_sym_L_DQUOTE] = ACTIONS(17), + [anon_sym_u_DQUOTE] = ACTIONS(17), + [anon_sym_U_DQUOTE] = ACTIONS(17), + [anon_sym_u8_DQUOTE] = ACTIONS(17), + [anon_sym_DQUOTE] = ACTIONS(17), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_PIPE_DASH] = ACTIONS(49), + [sym_identifier] = ACTIONS(51), + [sym_boolean] = ACTIONS(53), + }, + [29] = { + [sym_dict] = STATE(97), + [sym_preproc_call] = STATE(97), + [sym__special_preproc_call] = STATE(87), + [sym__cond_preproc_call] = STATE(108), + [sym__generic_preproc_call] = STATE(96), + [sym__value] = STATE(119), + [sym_dimensions] = STATE(97), + [sym_list] = STATE(114), + [sym__uniform_list] = STATE(106), + [sym__non_uniform_list] = STATE(104), + [sym__list_item] = STATE(115), + [sym_dict_headless] = STATE(119), + [sym_code] = STATE(97), + [sym_macro] = STATE(97), + [sym__macro_braces] = STATE(101), + [sym__macro_no_braces] = STATE(101), + [sym_string_literal] = STATE(114), + [sym_comment] = STATE(29), + [sym_pyfoam_template] = STATE(29), + [sym_pyfoam_expression] = STATE(97), + [aux_sym__non_uniform_list_repeat1] = STATE(25), + [anon_sym_LBRACE] = ACTIONS(27), + [aux_sym__special_preproc_call_token1] = ACTIONS(29), + [aux_sym__special_preproc_call_token2] = ACTIONS(29), + [aux_sym__cond_preproc_call_token1] = ACTIONS(31), + [anon_sym_POUND] = ACTIONS(33), + [anon_sym_LBRACK] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_RPAREN] = ACTIONS(149), + [anon_sym_POUND_LBRACE] = ACTIONS(41), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(43), + [anon_sym_DOLLAR] = ACTIONS(45), + [sym_number_literal] = ACTIONS(47), + [anon_sym_L_DQUOTE] = ACTIONS(17), + [anon_sym_u_DQUOTE] = ACTIONS(17), + [anon_sym_U_DQUOTE] = ACTIONS(17), + [anon_sym_u8_DQUOTE] = ACTIONS(17), + [anon_sym_DQUOTE] = ACTIONS(17), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_PIPE_DASH] = ACTIONS(49), + [sym_identifier] = ACTIONS(51), + [sym_boolean] = ACTIONS(53), + }, + [30] = { + [sym_dict] = STATE(97), + [sym_preproc_call] = STATE(97), + [sym__special_preproc_call] = STATE(87), + [sym__cond_preproc_call] = STATE(108), + [sym__generic_preproc_call] = STATE(96), + [sym__value] = STATE(119), + [sym_dimensions] = STATE(97), + [sym_list] = STATE(114), + [sym__uniform_list] = STATE(106), + [sym__non_uniform_list] = STATE(104), + [sym__list_item] = STATE(115), + [sym_dict_headless] = STATE(119), + [sym_code] = STATE(97), + [sym_macro] = STATE(97), + [sym__macro_braces] = STATE(101), + [sym__macro_no_braces] = STATE(101), + [sym_string_literal] = STATE(114), + [sym_comment] = STATE(30), + [sym_pyfoam_template] = STATE(30), + [sym_pyfoam_expression] = STATE(97), + [aux_sym__non_uniform_list_repeat1] = STATE(8), + [anon_sym_LBRACE] = ACTIONS(27), + [aux_sym__special_preproc_call_token1] = ACTIONS(29), + [aux_sym__special_preproc_call_token2] = ACTIONS(29), + [aux_sym__cond_preproc_call_token1] = ACTIONS(31), + [anon_sym_POUND] = ACTIONS(33), + [anon_sym_LBRACK] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_RPAREN] = ACTIONS(151), + [anon_sym_POUND_LBRACE] = ACTIONS(41), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(43), + [anon_sym_DOLLAR] = ACTIONS(45), + [sym_number_literal] = ACTIONS(47), + [anon_sym_L_DQUOTE] = ACTIONS(17), + [anon_sym_u_DQUOTE] = ACTIONS(17), + [anon_sym_U_DQUOTE] = ACTIONS(17), + [anon_sym_u8_DQUOTE] = ACTIONS(17), + [anon_sym_DQUOTE] = ACTIONS(17), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_PIPE_DASH] = ACTIONS(49), + [sym_identifier] = ACTIONS(51), + [sym_boolean] = ACTIONS(53), + }, + [31] = { + [sym_dict] = STATE(97), + [sym_preproc_call] = STATE(97), + [sym__special_preproc_call] = STATE(87), + [sym__cond_preproc_call] = STATE(108), + [sym__generic_preproc_call] = STATE(96), + [sym__value] = STATE(122), + [sym_dimensions] = STATE(97), + [sym_list] = STATE(113), + [sym__uniform_list] = STATE(106), + [sym__non_uniform_list] = STATE(104), + [sym_code] = STATE(97), + [sym_macro] = STATE(97), + [sym__macro_braces] = STATE(101), + [sym__macro_no_braces] = STATE(101), + [sym_string_literal] = STATE(113), + [sym_comment] = STATE(31), + [sym_pyfoam_template] = STATE(31), + [sym_pyfoam_expression] = STATE(97), + [aux_sym_key_value_repeat1] = STATE(41), + [anon_sym_LBRACE] = ACTIONS(153), + [anon_sym_SEMI] = ACTIONS(155), + [aux_sym__special_preproc_call_token1] = ACTIONS(29), + [aux_sym__special_preproc_call_token2] = ACTIONS(29), + [aux_sym__cond_preproc_call_token1] = ACTIONS(31), + [anon_sym_POUND] = ACTIONS(157), + [anon_sym_LBRACK] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_POUND_LBRACE] = ACTIONS(41), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(43), + [anon_sym_DOLLAR] = ACTIONS(45), + [sym_number_literal] = ACTIONS(159), + [anon_sym_L_DQUOTE] = ACTIONS(17), + [anon_sym_u_DQUOTE] = ACTIONS(17), + [anon_sym_U_DQUOTE] = ACTIONS(17), + [anon_sym_u8_DQUOTE] = ACTIONS(17), + [anon_sym_DQUOTE] = ACTIONS(17), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_PIPE_DASH] = ACTIONS(49), + [sym_identifier] = ACTIONS(161), + [sym_boolean] = ACTIONS(53), + }, + [32] = { + [sym_dict] = STATE(331), + [sym_preproc_call] = STATE(331), + [sym__special_preproc_call] = STATE(266), + [sym__cond_preproc_call] = STATE(267), + [sym__generic_preproc_call] = STATE(268), + [sym__value] = STATE(303), + [sym_dimensions] = STATE(331), + [sym_list] = STATE(277), + [sym__uniform_list] = STATE(258), + [sym__non_uniform_list] = STATE(264), + [sym__list_item] = STATE(312), + [sym_dict_headless] = STATE(303), + [sym_code] = STATE(331), + [sym_macro] = STATE(331), + [sym__macro_braces] = STATE(269), + [sym__macro_no_braces] = STATE(269), + [sym_string_literal] = STATE(277), + [sym_comment] = STATE(32), + [sym_pyfoam_template] = STATE(32), + [sym_pyfoam_expression] = STATE(331), + [anon_sym_LBRACE] = ACTIONS(163), + [aux_sym__special_preproc_call_token1] = ACTIONS(165), + [aux_sym__special_preproc_call_token2] = ACTIONS(165), + [aux_sym__cond_preproc_call_token1] = ACTIONS(167), + [anon_sym_POUND] = ACTIONS(169), + [anon_sym_LBRACK] = ACTIONS(171), + [anon_sym_LPAREN] = ACTIONS(173), + [anon_sym_POUND_LBRACE] = ACTIONS(175), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(177), + [anon_sym_DOLLAR] = ACTIONS(179), + [sym_number_literal] = ACTIONS(181), + [anon_sym_L_DQUOTE] = ACTIONS(183), + [anon_sym_u_DQUOTE] = ACTIONS(183), + [anon_sym_U_DQUOTE] = ACTIONS(183), + [anon_sym_u8_DQUOTE] = ACTIONS(183), + [anon_sym_DQUOTE] = ACTIONS(183), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_PIPE_DASH] = ACTIONS(185), + [sym_identifier] = ACTIONS(187), + [sym_boolean] = ACTIONS(189), + }, + [33] = { + [sym_dict] = STATE(97), + [sym_preproc_call] = STATE(97), + [sym__special_preproc_call] = STATE(87), + [sym__cond_preproc_call] = STATE(108), + [sym__generic_preproc_call] = STATE(96), + [sym__value] = STATE(122), + [sym_dimensions] = STATE(97), + [sym_list] = STATE(113), + [sym__uniform_list] = STATE(106), + [sym__non_uniform_list] = STATE(104), + [sym_code] = STATE(97), + [sym_macro] = STATE(97), + [sym__macro_braces] = STATE(101), + [sym__macro_no_braces] = STATE(101), + [sym_string_literal] = STATE(113), + [sym_comment] = STATE(33), + [sym_pyfoam_template] = STATE(33), + [sym_pyfoam_expression] = STATE(97), + [aux_sym_key_value_repeat1] = STATE(41), + [anon_sym_LBRACE] = ACTIONS(153), + [anon_sym_SEMI] = ACTIONS(155), + [aux_sym__special_preproc_call_token1] = ACTIONS(29), + [aux_sym__special_preproc_call_token2] = ACTIONS(29), + [aux_sym__cond_preproc_call_token1] = ACTIONS(31), + [anon_sym_POUND] = ACTIONS(157), + [anon_sym_LBRACK] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(191), + [anon_sym_POUND_LBRACE] = ACTIONS(41), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(43), + [anon_sym_DOLLAR] = ACTIONS(45), + [sym_number_literal] = ACTIONS(193), + [anon_sym_L_DQUOTE] = ACTIONS(17), + [anon_sym_u_DQUOTE] = ACTIONS(17), + [anon_sym_U_DQUOTE] = ACTIONS(17), + [anon_sym_u8_DQUOTE] = ACTIONS(17), + [anon_sym_DQUOTE] = ACTIONS(17), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_PIPE_DASH] = ACTIONS(49), + [sym_identifier] = ACTIONS(161), + [sym_boolean] = ACTIONS(53), + }, + [34] = { + [sym_dict] = STATE(97), + [sym_preproc_call] = STATE(97), + [sym__special_preproc_call] = STATE(87), + [sym__cond_preproc_call] = STATE(108), + [sym__generic_preproc_call] = STATE(96), + [sym__value] = STATE(122), + [sym_dimensions] = STATE(97), + [sym_list] = STATE(113), + [sym__uniform_list] = STATE(106), + [sym__non_uniform_list] = STATE(104), + [sym_code] = STATE(97), + [sym_macro] = STATE(97), + [sym__macro_braces] = STATE(101), + [sym__macro_no_braces] = STATE(101), + [sym_string_literal] = STATE(113), + [sym_comment] = STATE(34), + [sym_pyfoam_template] = STATE(34), + [sym_pyfoam_expression] = STATE(97), + [aux_sym_key_value_repeat1] = STATE(40), + [anon_sym_LBRACE] = ACTIONS(195), + [anon_sym_SEMI] = ACTIONS(197), + [aux_sym__special_preproc_call_token1] = ACTIONS(29), + [aux_sym__special_preproc_call_token2] = ACTIONS(29), + [aux_sym__cond_preproc_call_token1] = ACTIONS(31), + [anon_sym_POUND] = ACTIONS(157), + [anon_sym_LBRACK] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_POUND_LBRACE] = ACTIONS(41), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(43), + [anon_sym_DOLLAR] = ACTIONS(45), + [sym_number_literal] = ACTIONS(159), + [anon_sym_L_DQUOTE] = ACTIONS(17), + [anon_sym_u_DQUOTE] = ACTIONS(17), + [anon_sym_U_DQUOTE] = ACTIONS(17), + [anon_sym_u8_DQUOTE] = ACTIONS(17), + [anon_sym_DQUOTE] = ACTIONS(17), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_PIPE_DASH] = ACTIONS(49), + [sym_identifier] = ACTIONS(161), + [sym_boolean] = ACTIONS(53), + }, + [35] = { + [sym_dict] = STATE(331), + [sym_preproc_call] = STATE(331), + [sym__special_preproc_call] = STATE(266), + [sym__cond_preproc_call] = STATE(267), + [sym__generic_preproc_call] = STATE(268), + [sym__value] = STATE(303), + [sym_dimensions] = STATE(331), + [sym_list] = STATE(277), + [sym__uniform_list] = STATE(258), + [sym__non_uniform_list] = STATE(264), + [sym__list_item] = STATE(290), + [sym_dict_headless] = STATE(303), + [sym_code] = STATE(331), + [sym_macro] = STATE(331), + [sym__macro_braces] = STATE(269), + [sym__macro_no_braces] = STATE(269), + [sym_string_literal] = STATE(277), + [sym_comment] = STATE(35), + [sym_pyfoam_template] = STATE(35), + [sym_pyfoam_expression] = STATE(331), + [anon_sym_LBRACE] = ACTIONS(163), + [aux_sym__special_preproc_call_token1] = ACTIONS(165), + [aux_sym__special_preproc_call_token2] = ACTIONS(165), + [aux_sym__cond_preproc_call_token1] = ACTIONS(167), + [anon_sym_POUND] = ACTIONS(169), + [anon_sym_LBRACK] = ACTIONS(171), + [anon_sym_LPAREN] = ACTIONS(173), + [anon_sym_POUND_LBRACE] = ACTIONS(175), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(177), + [anon_sym_DOLLAR] = ACTIONS(179), + [sym_number_literal] = ACTIONS(181), + [anon_sym_L_DQUOTE] = ACTIONS(183), + [anon_sym_u_DQUOTE] = ACTIONS(183), + [anon_sym_U_DQUOTE] = ACTIONS(183), + [anon_sym_u8_DQUOTE] = ACTIONS(183), + [anon_sym_DQUOTE] = ACTIONS(183), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_PIPE_DASH] = ACTIONS(185), + [sym_identifier] = ACTIONS(187), + [sym_boolean] = ACTIONS(189), + }, + [36] = { + [sym_dict] = STATE(331), + [sym_preproc_call] = STATE(331), + [sym__special_preproc_call] = STATE(266), + [sym__cond_preproc_call] = STATE(267), + [sym__generic_preproc_call] = STATE(268), + [sym__value] = STATE(303), + [sym_dimensions] = STATE(331), + [sym_list] = STATE(277), + [sym__uniform_list] = STATE(258), + [sym__non_uniform_list] = STATE(264), + [sym__list_item] = STATE(302), + [sym_dict_headless] = STATE(303), + [sym_code] = STATE(331), + [sym_macro] = STATE(331), + [sym__macro_braces] = STATE(269), + [sym__macro_no_braces] = STATE(269), + [sym_string_literal] = STATE(277), + [sym_comment] = STATE(36), + [sym_pyfoam_template] = STATE(36), + [sym_pyfoam_expression] = STATE(331), + [anon_sym_LBRACE] = ACTIONS(163), + [aux_sym__special_preproc_call_token1] = ACTIONS(165), + [aux_sym__special_preproc_call_token2] = ACTIONS(165), + [aux_sym__cond_preproc_call_token1] = ACTIONS(167), + [anon_sym_POUND] = ACTIONS(169), + [anon_sym_LBRACK] = ACTIONS(171), + [anon_sym_LPAREN] = ACTIONS(173), + [anon_sym_POUND_LBRACE] = ACTIONS(175), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(177), + [anon_sym_DOLLAR] = ACTIONS(179), + [sym_number_literal] = ACTIONS(181), + [anon_sym_L_DQUOTE] = ACTIONS(183), + [anon_sym_u_DQUOTE] = ACTIONS(183), + [anon_sym_U_DQUOTE] = ACTIONS(183), + [anon_sym_u8_DQUOTE] = ACTIONS(183), + [anon_sym_DQUOTE] = ACTIONS(183), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_PIPE_DASH] = ACTIONS(185), + [sym_identifier] = ACTIONS(187), + [sym_boolean] = ACTIONS(189), + }, + [37] = { + [sym_dict] = STATE(97), + [sym_preproc_call] = STATE(97), + [sym__special_preproc_call] = STATE(87), + [sym__cond_preproc_call] = STATE(108), + [sym__generic_preproc_call] = STATE(96), + [sym__value] = STATE(122), + [sym_dimensions] = STATE(97), + [sym_list] = STATE(113), + [sym__uniform_list] = STATE(106), + [sym__non_uniform_list] = STATE(104), + [sym_code] = STATE(97), + [sym_macro] = STATE(97), + [sym__macro_braces] = STATE(101), + [sym__macro_no_braces] = STATE(101), + [sym_string_literal] = STATE(113), + [sym_comment] = STATE(37), + [sym_pyfoam_template] = STATE(37), + [sym_pyfoam_expression] = STATE(97), + [aux_sym_key_value_repeat1] = STATE(40), + [anon_sym_LBRACE] = ACTIONS(195), + [anon_sym_SEMI] = ACTIONS(197), + [aux_sym__special_preproc_call_token1] = ACTIONS(29), + [aux_sym__special_preproc_call_token2] = ACTIONS(29), + [aux_sym__cond_preproc_call_token1] = ACTIONS(31), + [anon_sym_POUND] = ACTIONS(157), + [anon_sym_LBRACK] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(199), + [anon_sym_POUND_LBRACE] = ACTIONS(41), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(43), + [anon_sym_DOLLAR] = ACTIONS(45), + [sym_number_literal] = ACTIONS(193), + [anon_sym_L_DQUOTE] = ACTIONS(17), + [anon_sym_u_DQUOTE] = ACTIONS(17), + [anon_sym_U_DQUOTE] = ACTIONS(17), + [anon_sym_u8_DQUOTE] = ACTIONS(17), + [anon_sym_DQUOTE] = ACTIONS(17), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_PIPE_DASH] = ACTIONS(49), + [sym_identifier] = ACTIONS(161), + [sym_boolean] = ACTIONS(53), + }, + [38] = { + [sym_dict] = STATE(331), + [sym_preproc_call] = STATE(331), + [sym__special_preproc_call] = STATE(266), + [sym__cond_preproc_call] = STATE(267), + [sym__generic_preproc_call] = STATE(268), + [sym__value] = STATE(303), + [sym_dimensions] = STATE(331), + [sym_list] = STATE(277), + [sym__uniform_list] = STATE(258), + [sym__non_uniform_list] = STATE(264), + [sym__list_item] = STATE(295), + [sym_dict_headless] = STATE(303), + [sym_code] = STATE(331), + [sym_macro] = STATE(331), + [sym__macro_braces] = STATE(269), + [sym__macro_no_braces] = STATE(269), + [sym_string_literal] = STATE(277), + [sym_comment] = STATE(38), + [sym_pyfoam_template] = STATE(38), + [sym_pyfoam_expression] = STATE(331), + [anon_sym_LBRACE] = ACTIONS(163), + [aux_sym__special_preproc_call_token1] = ACTIONS(165), + [aux_sym__special_preproc_call_token2] = ACTIONS(165), + [aux_sym__cond_preproc_call_token1] = ACTIONS(167), + [anon_sym_POUND] = ACTIONS(169), + [anon_sym_LBRACK] = ACTIONS(171), + [anon_sym_LPAREN] = ACTIONS(173), + [anon_sym_POUND_LBRACE] = ACTIONS(175), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(177), + [anon_sym_DOLLAR] = ACTIONS(179), + [sym_number_literal] = ACTIONS(181), + [anon_sym_L_DQUOTE] = ACTIONS(183), + [anon_sym_u_DQUOTE] = ACTIONS(183), + [anon_sym_U_DQUOTE] = ACTIONS(183), + [anon_sym_u8_DQUOTE] = ACTIONS(183), + [anon_sym_DQUOTE] = ACTIONS(183), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_PIPE_DASH] = ACTIONS(185), + [sym_identifier] = ACTIONS(187), + [sym_boolean] = ACTIONS(189), + }, + [39] = { + [sym_dict] = STATE(97), + [sym_preproc_call] = STATE(97), + [sym__special_preproc_call] = STATE(87), + [sym__cond_preproc_call] = STATE(108), + [sym__generic_preproc_call] = STATE(96), + [sym__value] = STATE(122), + [sym_dimensions] = STATE(97), + [sym_list] = STATE(113), + [sym__uniform_list] = STATE(106), + [sym__non_uniform_list] = STATE(104), + [sym_code] = STATE(97), + [sym_macro] = STATE(97), + [sym__macro_braces] = STATE(101), + [sym__macro_no_braces] = STATE(101), + [sym_string_literal] = STATE(113), + [sym_comment] = STATE(39), + [sym_pyfoam_template] = STATE(39), + [sym_pyfoam_expression] = STATE(97), + [aux_sym_key_value_repeat1] = STATE(39), + [anon_sym_SEMI] = ACTIONS(201), + [aux_sym__special_preproc_call_token1] = ACTIONS(203), + [aux_sym__special_preproc_call_token2] = ACTIONS(203), + [aux_sym__cond_preproc_call_token1] = ACTIONS(206), + [anon_sym_POUND] = ACTIONS(209), + [anon_sym_LBRACK] = ACTIONS(212), + [anon_sym_LPAREN] = ACTIONS(215), + [anon_sym_POUND_LBRACE] = ACTIONS(218), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(221), + [anon_sym_DOLLAR] = ACTIONS(224), + [sym_number_literal] = ACTIONS(227), + [anon_sym_L_DQUOTE] = ACTIONS(230), + [anon_sym_u_DQUOTE] = ACTIONS(230), + [anon_sym_U_DQUOTE] = ACTIONS(230), + [anon_sym_u8_DQUOTE] = ACTIONS(230), + [anon_sym_DQUOTE] = ACTIONS(230), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_PIPE_DASH] = ACTIONS(233), + [sym_identifier] = ACTIONS(236), + [sym_boolean] = ACTIONS(239), + }, + [40] = { + [sym_dict] = STATE(97), + [sym_preproc_call] = STATE(97), + [sym__special_preproc_call] = STATE(87), + [sym__cond_preproc_call] = STATE(108), + [sym__generic_preproc_call] = STATE(96), + [sym__value] = STATE(122), + [sym_dimensions] = STATE(97), + [sym_list] = STATE(113), + [sym__uniform_list] = STATE(106), + [sym__non_uniform_list] = STATE(104), + [sym_code] = STATE(97), + [sym_macro] = STATE(97), + [sym__macro_braces] = STATE(101), + [sym__macro_no_braces] = STATE(101), + [sym_string_literal] = STATE(113), + [sym_comment] = STATE(40), + [sym_pyfoam_template] = STATE(40), + [sym_pyfoam_expression] = STATE(97), + [aux_sym_key_value_repeat1] = STATE(39), + [anon_sym_SEMI] = ACTIONS(242), + [aux_sym__special_preproc_call_token1] = ACTIONS(29), + [aux_sym__special_preproc_call_token2] = ACTIONS(29), + [aux_sym__cond_preproc_call_token1] = ACTIONS(31), + [anon_sym_POUND] = ACTIONS(157), + [anon_sym_LBRACK] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_POUND_LBRACE] = ACTIONS(41), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(43), + [anon_sym_DOLLAR] = ACTIONS(45), + [sym_number_literal] = ACTIONS(159), + [anon_sym_L_DQUOTE] = ACTIONS(17), + [anon_sym_u_DQUOTE] = ACTIONS(17), + [anon_sym_U_DQUOTE] = ACTIONS(17), + [anon_sym_u8_DQUOTE] = ACTIONS(17), + [anon_sym_DQUOTE] = ACTIONS(17), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_PIPE_DASH] = ACTIONS(49), + [sym_identifier] = ACTIONS(161), + [sym_boolean] = ACTIONS(53), + }, + [41] = { + [sym_dict] = STATE(97), + [sym_preproc_call] = STATE(97), + [sym__special_preproc_call] = STATE(87), + [sym__cond_preproc_call] = STATE(108), + [sym__generic_preproc_call] = STATE(96), + [sym__value] = STATE(122), + [sym_dimensions] = STATE(97), + [sym_list] = STATE(113), + [sym__uniform_list] = STATE(106), + [sym__non_uniform_list] = STATE(104), + [sym_code] = STATE(97), + [sym_macro] = STATE(97), + [sym__macro_braces] = STATE(101), + [sym__macro_no_braces] = STATE(101), + [sym_string_literal] = STATE(113), + [sym_comment] = STATE(41), + [sym_pyfoam_template] = STATE(41), + [sym_pyfoam_expression] = STATE(97), + [aux_sym_key_value_repeat1] = STATE(39), + [anon_sym_SEMI] = ACTIONS(244), + [aux_sym__special_preproc_call_token1] = ACTIONS(29), + [aux_sym__special_preproc_call_token2] = ACTIONS(29), + [aux_sym__cond_preproc_call_token1] = ACTIONS(31), + [anon_sym_POUND] = ACTIONS(157), + [anon_sym_LBRACK] = ACTIONS(35), + [anon_sym_LPAREN] = ACTIONS(37), + [anon_sym_POUND_LBRACE] = ACTIONS(41), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(43), + [anon_sym_DOLLAR] = ACTIONS(45), + [sym_number_literal] = ACTIONS(159), + [anon_sym_L_DQUOTE] = ACTIONS(17), + [anon_sym_u_DQUOTE] = ACTIONS(17), + [anon_sym_U_DQUOTE] = ACTIONS(17), + [anon_sym_u8_DQUOTE] = ACTIONS(17), + [anon_sym_DQUOTE] = ACTIONS(17), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_PIPE_DASH] = ACTIONS(49), + [sym_identifier] = ACTIONS(161), + [sym_boolean] = ACTIONS(53), + }, + [42] = { + [sym__statement] = STATE(155), + [sym_dict] = STATE(158), + [sym_dict_core] = STATE(336), + [sym_key_value] = STATE(158), + [sym_preproc_call] = STATE(158), + [sym__special_preproc_call] = STATE(147), + [sym__cond_preproc_call] = STATE(150), + [sym__generic_preproc_call] = STATE(149), + [sym_list] = STATE(325), + [sym__uniform_list] = STATE(130), + [sym__non_uniform_list] = STATE(131), + [sym_macro] = STATE(134), + [sym__macro_braces] = STATE(140), + [sym__macro_no_braces] = STATE(140), + [sym_string_literal] = STATE(31), + [sym_comment] = STATE(42), + [sym_pyfoam_template] = STATE(42), + [sym_pyfoam_variable] = STATE(158), + [aux_sym_dict_core_repeat1] = STATE(50), + [anon_sym_RBRACE] = ACTIONS(246), + [aux_sym__special_preproc_call_token1] = ACTIONS(248), + [aux_sym__special_preproc_call_token2] = ACTIONS(248), + [aux_sym__cond_preproc_call_token1] = ACTIONS(250), + [anon_sym_POUND] = ACTIONS(252), + [anon_sym_LPAREN] = ACTIONS(254), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(256), + [anon_sym_DOLLAR] = ACTIONS(258), + [sym_number_literal] = ACTIONS(260), + [anon_sym_L_DQUOTE] = ACTIONS(17), + [anon_sym_u_DQUOTE] = ACTIONS(17), + [anon_sym_U_DQUOTE] = ACTIONS(17), + [anon_sym_u8_DQUOTE] = ACTIONS(17), + [anon_sym_DQUOTE] = ACTIONS(17), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_DOLLAR_DOLLAR] = ACTIONS(262), + [sym_identifier] = ACTIONS(264), + }, + [43] = { + [sym__statement] = STATE(155), + [sym_dict] = STATE(158), + [sym_dict_core] = STATE(308), + [sym_key_value] = STATE(158), + [sym_preproc_call] = STATE(158), + [sym__special_preproc_call] = STATE(147), + [sym__cond_preproc_call] = STATE(150), + [sym__generic_preproc_call] = STATE(149), + [sym_list] = STATE(325), + [sym__uniform_list] = STATE(130), + [sym__non_uniform_list] = STATE(131), + [sym_macro] = STATE(134), + [sym__macro_braces] = STATE(140), + [sym__macro_no_braces] = STATE(140), + [sym_string_literal] = STATE(31), + [sym_comment] = STATE(43), + [sym_pyfoam_template] = STATE(43), + [sym_pyfoam_variable] = STATE(158), + [aux_sym_dict_core_repeat1] = STATE(50), + [anon_sym_RBRACE] = ACTIONS(266), + [aux_sym__special_preproc_call_token1] = ACTIONS(248), + [aux_sym__special_preproc_call_token2] = ACTIONS(248), + [aux_sym__cond_preproc_call_token1] = ACTIONS(250), + [anon_sym_POUND] = ACTIONS(252), + [anon_sym_LPAREN] = ACTIONS(254), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(256), + [anon_sym_DOLLAR] = ACTIONS(258), + [sym_number_literal] = ACTIONS(260), + [anon_sym_L_DQUOTE] = ACTIONS(17), + [anon_sym_u_DQUOTE] = ACTIONS(17), + [anon_sym_U_DQUOTE] = ACTIONS(17), + [anon_sym_u8_DQUOTE] = ACTIONS(17), + [anon_sym_DQUOTE] = ACTIONS(17), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_DOLLAR_DOLLAR] = ACTIONS(262), + [sym_identifier] = ACTIONS(264), + }, + [44] = { + [sym__statement] = STATE(155), + [sym_dict] = STATE(158), + [sym_dict_core] = STATE(322), + [sym_key_value] = STATE(158), + [sym_preproc_call] = STATE(158), + [sym__special_preproc_call] = STATE(147), + [sym__cond_preproc_call] = STATE(150), + [sym__generic_preproc_call] = STATE(149), + [sym_list] = STATE(325), + [sym__uniform_list] = STATE(130), + [sym__non_uniform_list] = STATE(131), + [sym_macro] = STATE(134), + [sym__macro_braces] = STATE(140), + [sym__macro_no_braces] = STATE(140), + [sym_string_literal] = STATE(31), + [sym_comment] = STATE(44), + [sym_pyfoam_template] = STATE(44), + [sym_pyfoam_variable] = STATE(158), + [aux_sym_dict_core_repeat1] = STATE(50), + [anon_sym_RBRACE] = ACTIONS(268), + [aux_sym__special_preproc_call_token1] = ACTIONS(248), + [aux_sym__special_preproc_call_token2] = ACTIONS(248), + [aux_sym__cond_preproc_call_token1] = ACTIONS(250), + [anon_sym_POUND] = ACTIONS(252), + [anon_sym_LPAREN] = ACTIONS(254), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(256), + [anon_sym_DOLLAR] = ACTIONS(258), + [sym_number_literal] = ACTIONS(260), + [anon_sym_L_DQUOTE] = ACTIONS(17), + [anon_sym_u_DQUOTE] = ACTIONS(17), + [anon_sym_U_DQUOTE] = ACTIONS(17), + [anon_sym_u8_DQUOTE] = ACTIONS(17), + [anon_sym_DQUOTE] = ACTIONS(17), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_DOLLAR_DOLLAR] = ACTIONS(262), + [sym_identifier] = ACTIONS(264), + }, + [45] = { + [sym__statement] = STATE(155), + [sym_dict] = STATE(158), + [sym_dict_core] = STATE(319), + [sym_key_value] = STATE(158), + [sym_preproc_call] = STATE(158), + [sym__special_preproc_call] = STATE(147), + [sym__cond_preproc_call] = STATE(150), + [sym__generic_preproc_call] = STATE(149), + [sym_list] = STATE(325), + [sym__uniform_list] = STATE(130), + [sym__non_uniform_list] = STATE(131), + [sym_macro] = STATE(134), + [sym__macro_braces] = STATE(140), + [sym__macro_no_braces] = STATE(140), + [sym_string_literal] = STATE(31), + [sym_comment] = STATE(45), + [sym_pyfoam_template] = STATE(45), + [sym_pyfoam_variable] = STATE(158), + [aux_sym_dict_core_repeat1] = STATE(50), + [anon_sym_RBRACE] = ACTIONS(270), + [aux_sym__special_preproc_call_token1] = ACTIONS(248), + [aux_sym__special_preproc_call_token2] = ACTIONS(248), + [aux_sym__cond_preproc_call_token1] = ACTIONS(250), + [anon_sym_POUND] = ACTIONS(252), + [anon_sym_LPAREN] = ACTIONS(254), + [anon_sym_DOLLAR_LBRACE] = ACTIONS(256), + [anon_sym_DOLLAR] = ACTIONS(258), + [sym_number_literal] = ACTIONS(260), + [anon_sym_L_DQUOTE] = ACTIONS(17), + [anon_sym_u_DQUOTE] = ACTIONS(17), + [anon_sym_U_DQUOTE] = ACTIONS(17), + [anon_sym_u8_DQUOTE] = ACTIONS(17), + [anon_sym_DQUOTE] = ACTIONS(17), + [aux_sym_comment_token1] = ACTIONS(19), + [anon_sym_LT_BANG_DASH_DASH_LPAREN] = ACTIONS(5), + [anon_sym_DOLLAR_DOLLAR] = ACTIONS(262), + [sym_identifier] = ACTIONS(264), + }, +}; + +static const uint16_t ts_small_parse_table[] = { + [0] = 26, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(250), 1, + aux_sym__cond_preproc_call_token1, + ACTIONS(252), 1, + anon_sym_POUND, + ACTIONS(254), 1, + anon_sym_LPAREN, + ACTIONS(256), 1, + anon_sym_DOLLAR_LBRACE, + ACTIONS(258), 1, + anon_sym_DOLLAR, + ACTIONS(260), 1, + sym_number_literal, + ACTIONS(262), 1, + anon_sym_DOLLAR_DOLLAR, + ACTIONS(264), 1, + sym_identifier, + ACTIONS(272), 1, + anon_sym_RBRACE, + STATE(31), 1, + sym_string_literal, + STATE(49), 1, + aux_sym_dict_core_repeat1, + STATE(130), 1, + sym__uniform_list, + STATE(131), 1, + sym__non_uniform_list, + STATE(134), 1, + sym_macro, + STATE(147), 1, + sym__special_preproc_call, + STATE(149), 1, + sym__generic_preproc_call, + STATE(150), 1, + sym__cond_preproc_call, + STATE(155), 1, + sym__statement, + STATE(325), 1, + sym_list, + ACTIONS(248), 2, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + STATE(46), 2, + sym_comment, + sym_pyfoam_template, + STATE(140), 2, + sym__macro_braces, + sym__macro_no_braces, + STATE(158), 4, + sym_dict, + sym_key_value, + sym_preproc_call, + sym_pyfoam_variable, + ACTIONS(17), 5, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + [89] = 26, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(250), 1, + aux_sym__cond_preproc_call_token1, + ACTIONS(252), 1, + anon_sym_POUND, + ACTIONS(254), 1, + anon_sym_LPAREN, + ACTIONS(256), 1, + anon_sym_DOLLAR_LBRACE, + ACTIONS(258), 1, + anon_sym_DOLLAR, + ACTIONS(260), 1, + sym_number_literal, + ACTIONS(262), 1, + anon_sym_DOLLAR_DOLLAR, + ACTIONS(264), 1, + sym_identifier, + ACTIONS(274), 1, + anon_sym_RBRACE, + STATE(31), 1, + sym_string_literal, + STATE(48), 1, + aux_sym_dict_core_repeat1, + STATE(130), 1, + sym__uniform_list, + STATE(131), 1, + sym__non_uniform_list, + STATE(134), 1, + sym_macro, + STATE(147), 1, + sym__special_preproc_call, + STATE(149), 1, + sym__generic_preproc_call, + STATE(150), 1, + sym__cond_preproc_call, + STATE(155), 1, + sym__statement, + STATE(325), 1, + sym_list, + ACTIONS(248), 2, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + STATE(47), 2, + sym_comment, + sym_pyfoam_template, + STATE(140), 2, + sym__macro_braces, + sym__macro_no_braces, + STATE(158), 4, + sym_dict, + sym_key_value, + sym_preproc_call, + sym_pyfoam_variable, + ACTIONS(17), 5, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + [178] = 26, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(250), 1, + aux_sym__cond_preproc_call_token1, + ACTIONS(252), 1, + anon_sym_POUND, + ACTIONS(254), 1, + anon_sym_LPAREN, + ACTIONS(256), 1, + anon_sym_DOLLAR_LBRACE, + ACTIONS(258), 1, + anon_sym_DOLLAR, + ACTIONS(260), 1, + sym_number_literal, + ACTIONS(262), 1, + anon_sym_DOLLAR_DOLLAR, + ACTIONS(264), 1, + sym_identifier, + ACTIONS(276), 1, + anon_sym_RBRACE, + STATE(31), 1, + sym_string_literal, + STATE(49), 1, + aux_sym_dict_core_repeat1, + STATE(130), 1, + sym__uniform_list, + STATE(131), 1, + sym__non_uniform_list, + STATE(134), 1, + sym_macro, + STATE(147), 1, + sym__special_preproc_call, + STATE(149), 1, + sym__generic_preproc_call, + STATE(150), 1, + sym__cond_preproc_call, + STATE(155), 1, + sym__statement, + STATE(325), 1, + sym_list, + ACTIONS(248), 2, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + STATE(48), 2, + sym_comment, + sym_pyfoam_template, + STATE(140), 2, + sym__macro_braces, + sym__macro_no_braces, + STATE(158), 4, + sym_dict, + sym_key_value, + sym_preproc_call, + sym_pyfoam_variable, + ACTIONS(17), 5, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + [267] = 25, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(278), 1, + anon_sym_RBRACE, + ACTIONS(283), 1, + aux_sym__cond_preproc_call_token1, + ACTIONS(286), 1, + anon_sym_POUND, + ACTIONS(289), 1, + anon_sym_LPAREN, + ACTIONS(292), 1, + anon_sym_DOLLAR_LBRACE, + ACTIONS(295), 1, + anon_sym_DOLLAR, + ACTIONS(298), 1, + sym_number_literal, + ACTIONS(304), 1, + anon_sym_DOLLAR_DOLLAR, + ACTIONS(307), 1, + sym_identifier, + STATE(31), 1, + sym_string_literal, + STATE(130), 1, + sym__uniform_list, + STATE(131), 1, + sym__non_uniform_list, + STATE(134), 1, + sym_macro, + STATE(147), 1, + sym__special_preproc_call, + STATE(149), 1, + sym__generic_preproc_call, + STATE(150), 1, + sym__cond_preproc_call, + STATE(155), 1, + sym__statement, + STATE(325), 1, + sym_list, + ACTIONS(280), 2, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + STATE(140), 2, + sym__macro_braces, + sym__macro_no_braces, + STATE(49), 3, + sym_comment, + sym_pyfoam_template, + aux_sym_dict_core_repeat1, + STATE(158), 4, + sym_dict, + sym_key_value, + sym_preproc_call, + sym_pyfoam_variable, + ACTIONS(301), 5, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + [354] = 26, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(250), 1, + aux_sym__cond_preproc_call_token1, + ACTIONS(252), 1, + anon_sym_POUND, + ACTIONS(254), 1, + anon_sym_LPAREN, + ACTIONS(256), 1, + anon_sym_DOLLAR_LBRACE, + ACTIONS(258), 1, + anon_sym_DOLLAR, + ACTIONS(260), 1, + sym_number_literal, + ACTIONS(262), 1, + anon_sym_DOLLAR_DOLLAR, + ACTIONS(264), 1, + sym_identifier, + ACTIONS(310), 1, + anon_sym_RBRACE, + STATE(31), 1, + sym_string_literal, + STATE(49), 1, + aux_sym_dict_core_repeat1, + STATE(130), 1, + sym__uniform_list, + STATE(131), 1, + sym__non_uniform_list, + STATE(134), 1, + sym_macro, + STATE(147), 1, + sym__special_preproc_call, + STATE(149), 1, + sym__generic_preproc_call, + STATE(150), 1, + sym__cond_preproc_call, + STATE(155), 1, + sym__statement, + STATE(325), 1, + sym_list, + ACTIONS(248), 2, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + STATE(50), 2, + sym_comment, + sym_pyfoam_template, + STATE(140), 2, + sym__macro_braces, + sym__macro_no_braces, + STATE(158), 4, + sym_dict, + sym_key_value, + sym_preproc_call, + sym_pyfoam_variable, + ACTIONS(17), 5, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + [443] = 26, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(250), 1, + aux_sym__cond_preproc_call_token1, + ACTIONS(252), 1, + anon_sym_POUND, + ACTIONS(254), 1, + anon_sym_LPAREN, + ACTIONS(256), 1, + anon_sym_DOLLAR_LBRACE, + ACTIONS(258), 1, + anon_sym_DOLLAR, + ACTIONS(260), 1, + sym_number_literal, + ACTIONS(262), 1, + anon_sym_DOLLAR_DOLLAR, + ACTIONS(264), 1, + sym_identifier, + ACTIONS(312), 1, + anon_sym_RBRACE, + STATE(31), 1, + sym_string_literal, + STATE(49), 1, + aux_sym_dict_core_repeat1, + STATE(130), 1, + sym__uniform_list, + STATE(131), 1, + sym__non_uniform_list, + STATE(134), 1, + sym_macro, + STATE(147), 1, + sym__special_preproc_call, + STATE(149), 1, + sym__generic_preproc_call, + STATE(150), 1, + sym__cond_preproc_call, + STATE(155), 1, + sym__statement, + STATE(325), 1, + sym_list, + ACTIONS(248), 2, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + STATE(51), 2, + sym_comment, + sym_pyfoam_template, + STATE(140), 2, + sym__macro_braces, + sym__macro_no_braces, + STATE(158), 4, + sym_dict, + sym_key_value, + sym_preproc_call, + sym_pyfoam_variable, + ACTIONS(17), 5, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + [532] = 26, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(250), 1, + aux_sym__cond_preproc_call_token1, + ACTIONS(252), 1, + anon_sym_POUND, + ACTIONS(254), 1, + anon_sym_LPAREN, + ACTIONS(256), 1, + anon_sym_DOLLAR_LBRACE, + ACTIONS(258), 1, + anon_sym_DOLLAR, + ACTIONS(260), 1, + sym_number_literal, + ACTIONS(262), 1, + anon_sym_DOLLAR_DOLLAR, + ACTIONS(264), 1, + sym_identifier, + ACTIONS(314), 1, + anon_sym_RBRACE, + STATE(31), 1, + sym_string_literal, + STATE(51), 1, + aux_sym_dict_core_repeat1, + STATE(130), 1, + sym__uniform_list, + STATE(131), 1, + sym__non_uniform_list, + STATE(134), 1, + sym_macro, + STATE(147), 1, + sym__special_preproc_call, + STATE(149), 1, + sym__generic_preproc_call, + STATE(150), 1, + sym__cond_preproc_call, + STATE(155), 1, + sym__statement, + STATE(325), 1, + sym_list, + ACTIONS(248), 2, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + STATE(52), 2, + sym_comment, + sym_pyfoam_template, + STATE(140), 2, + sym__macro_braces, + sym__macro_no_braces, + STATE(158), 4, + sym_dict, + sym_key_value, + sym_preproc_call, + sym_pyfoam_variable, + ACTIONS(17), 5, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + [621] = 26, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(250), 1, + aux_sym__cond_preproc_call_token1, + ACTIONS(252), 1, + anon_sym_POUND, + ACTIONS(254), 1, + anon_sym_LPAREN, + ACTIONS(256), 1, + anon_sym_DOLLAR_LBRACE, + ACTIONS(258), 1, + anon_sym_DOLLAR, + ACTIONS(260), 1, + sym_number_literal, + ACTIONS(262), 1, + anon_sym_DOLLAR_DOLLAR, + ACTIONS(264), 1, + sym_identifier, + ACTIONS(316), 1, + anon_sym_RBRACE, + STATE(31), 1, + sym_string_literal, + STATE(49), 1, + aux_sym_dict_core_repeat1, + STATE(130), 1, + sym__uniform_list, + STATE(131), 1, + sym__non_uniform_list, + STATE(134), 1, + sym_macro, + STATE(147), 1, + sym__special_preproc_call, + STATE(149), 1, + sym__generic_preproc_call, + STATE(150), 1, + sym__cond_preproc_call, + STATE(155), 1, + sym__statement, + STATE(325), 1, + sym_list, + ACTIONS(248), 2, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + STATE(53), 2, + sym_comment, + sym_pyfoam_template, + STATE(140), 2, + sym__macro_braces, + sym__macro_no_braces, + STATE(158), 4, + sym_dict, + sym_key_value, + sym_preproc_call, + sym_pyfoam_variable, + ACTIONS(17), 5, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + [710] = 26, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(250), 1, + aux_sym__cond_preproc_call_token1, + ACTIONS(252), 1, + anon_sym_POUND, + ACTIONS(254), 1, + anon_sym_LPAREN, + ACTIONS(256), 1, + anon_sym_DOLLAR_LBRACE, + ACTIONS(258), 1, + anon_sym_DOLLAR, + ACTIONS(260), 1, + sym_number_literal, + ACTIONS(262), 1, + anon_sym_DOLLAR_DOLLAR, + ACTIONS(264), 1, + sym_identifier, + ACTIONS(318), 1, + anon_sym_RBRACE, + STATE(31), 1, + sym_string_literal, + STATE(53), 1, + aux_sym_dict_core_repeat1, + STATE(130), 1, + sym__uniform_list, + STATE(131), 1, + sym__non_uniform_list, + STATE(134), 1, + sym_macro, + STATE(147), 1, + sym__special_preproc_call, + STATE(149), 1, + sym__generic_preproc_call, + STATE(150), 1, + sym__cond_preproc_call, + STATE(155), 1, + sym__statement, + STATE(325), 1, + sym_list, + ACTIONS(248), 2, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + STATE(54), 2, + sym_comment, + sym_pyfoam_template, + STATE(140), 2, + sym__macro_braces, + sym__macro_no_braces, + STATE(158), 4, + sym_dict, + sym_key_value, + sym_preproc_call, + sym_pyfoam_variable, + ACTIONS(17), 5, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + [799] = 26, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(250), 1, + aux_sym__cond_preproc_call_token1, + ACTIONS(252), 1, + anon_sym_POUND, + ACTIONS(254), 1, + anon_sym_LPAREN, + ACTIONS(256), 1, + anon_sym_DOLLAR_LBRACE, + ACTIONS(258), 1, + anon_sym_DOLLAR, + ACTIONS(260), 1, + sym_number_literal, + ACTIONS(262), 1, + anon_sym_DOLLAR_DOLLAR, + ACTIONS(264), 1, + sym_identifier, + ACTIONS(320), 1, + anon_sym_RBRACE, + STATE(31), 1, + sym_string_literal, + STATE(46), 1, + aux_sym_dict_core_repeat1, + STATE(130), 1, + sym__uniform_list, + STATE(131), 1, + sym__non_uniform_list, + STATE(134), 1, + sym_macro, + STATE(147), 1, + sym__special_preproc_call, + STATE(149), 1, + sym__generic_preproc_call, + STATE(150), 1, + sym__cond_preproc_call, + STATE(155), 1, + sym__statement, + STATE(325), 1, + sym_list, + ACTIONS(248), 2, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + STATE(55), 2, + sym_comment, + sym_pyfoam_template, + STATE(140), 2, + sym__macro_braces, + sym__macro_no_braces, + STATE(158), 4, + sym_dict, + sym_key_value, + sym_preproc_call, + sym_pyfoam_variable, + ACTIONS(17), 5, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + [888] = 21, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(325), 1, + aux_sym__cond_preproc_call_token1, + ACTIONS(328), 1, + anon_sym_POUND, + ACTIONS(331), 1, + anon_sym_LPAREN, + ACTIONS(334), 1, + sym_number_literal, + ACTIONS(340), 1, + anon_sym_DOLLAR_DOLLAR, + ACTIONS(343), 1, + sym_identifier, + ACTIONS(346), 1, + sym__eof, + STATE(34), 1, + sym_string_literal, + STATE(166), 1, + sym__non_uniform_list, + STATE(179), 1, + sym__generic_preproc_call, + STATE(183), 1, + sym__cond_preproc_call, + STATE(185), 1, + sym__uniform_list, + STATE(186), 1, + sym__special_preproc_call, + STATE(191), 1, + sym__statement, + STATE(291), 1, + sym_list, + ACTIONS(322), 2, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + STATE(56), 3, + sym_comment, + sym_pyfoam_template, + aux_sym_foam_repeat1, + STATE(190), 4, + sym_dict, + sym_key_value, + sym_preproc_call, + sym_pyfoam_variable, + ACTIONS(337), 5, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + [962] = 22, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(9), 1, + aux_sym__cond_preproc_call_token1, + ACTIONS(11), 1, + anon_sym_POUND, + ACTIONS(13), 1, + anon_sym_LPAREN, + ACTIONS(15), 1, + sym_number_literal, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(21), 1, + anon_sym_DOLLAR_DOLLAR, + ACTIONS(23), 1, + sym_identifier, + ACTIONS(348), 1, + sym__eof, + STATE(34), 1, + sym_string_literal, + STATE(56), 1, + aux_sym_foam_repeat1, + STATE(166), 1, + sym__non_uniform_list, + STATE(179), 1, + sym__generic_preproc_call, + STATE(183), 1, + sym__cond_preproc_call, + STATE(185), 1, + sym__uniform_list, + STATE(186), 1, + sym__special_preproc_call, + STATE(191), 1, + sym__statement, + STATE(291), 1, + sym_list, + ACTIONS(7), 2, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + STATE(57), 2, + sym_comment, + sym_pyfoam_template, + STATE(190), 4, + sym_dict, + sym_key_value, + sym_preproc_call, + sym_pyfoam_variable, + ACTIONS(17), 5, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + [1038] = 7, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(353), 2, + anon_sym_RBRACE, + anon_sym_DOLLAR_DOLLAR, + ACTIONS(357), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(58), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(355), 5, + sym_boolean, + anon_sym_SEMI, + anon_sym_LBRACK, + anon_sym_POUND_LBRACE, + anon_sym_PIPE_DASH, + ACTIONS(350), 13, + sym_identifier, + anon_sym_LBRACE, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + [1079] = 16, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(9), 1, + aux_sym__cond_preproc_call_token1, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(360), 1, + anon_sym_LBRACE, + ACTIONS(362), 1, + anon_sym_POUND, + ACTIONS(364), 1, + anon_sym_DOLLAR_LBRACE, + ACTIONS(366), 1, + anon_sym_DOLLAR, + ACTIONS(370), 1, + sym_identifier, + STATE(179), 1, + sym__generic_preproc_call, + STATE(183), 1, + sym__cond_preproc_call, + STATE(186), 1, + sym__special_preproc_call, + ACTIONS(7), 2, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + STATE(59), 2, + sym_comment, + sym_pyfoam_template, + STATE(181), 2, + sym__macro_braces, + sym__macro_no_braces, + STATE(161), 4, + sym_preproc_call, + sym_dict_headless, + sym_macro, + sym_string_literal, + ACTIONS(368), 5, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + [1138] = 16, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(27), 1, + anon_sym_LBRACE, + ACTIONS(31), 1, + aux_sym__cond_preproc_call_token1, + ACTIONS(43), 1, + anon_sym_DOLLAR_LBRACE, + ACTIONS(45), 1, + anon_sym_DOLLAR, + ACTIONS(157), 1, + anon_sym_POUND, + ACTIONS(372), 1, + sym_identifier, + STATE(87), 1, + sym__special_preproc_call, + STATE(96), 1, + sym__generic_preproc_call, + STATE(108), 1, + sym__cond_preproc_call, + ACTIONS(29), 2, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + STATE(60), 2, + sym_comment, + sym_pyfoam_template, + STATE(101), 2, + sym__macro_braces, + sym__macro_no_braces, + STATE(83), 4, + sym_preproc_call, + sym_dict_headless, + sym_macro, + sym_string_literal, + ACTIONS(17), 5, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + [1197] = 16, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(250), 1, + aux_sym__cond_preproc_call_token1, + ACTIONS(256), 1, + anon_sym_DOLLAR_LBRACE, + ACTIONS(258), 1, + anon_sym_DOLLAR, + ACTIONS(374), 1, + anon_sym_LBRACE, + ACTIONS(376), 1, + anon_sym_POUND, + ACTIONS(380), 1, + sym_identifier, + STATE(147), 1, + sym__special_preproc_call, + STATE(149), 1, + sym__generic_preproc_call, + STATE(150), 1, + sym__cond_preproc_call, + ACTIONS(248), 2, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + STATE(61), 2, + sym_comment, + sym_pyfoam_template, + STATE(140), 2, + sym__macro_braces, + sym__macro_no_braces, + STATE(148), 4, + sym_preproc_call, + sym_dict_headless, + sym_macro, + sym_string_literal, + ACTIONS(378), 5, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + [1256] = 7, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(385), 2, + anon_sym_RBRACE, + anon_sym_DOLLAR_DOLLAR, + ACTIONS(389), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(62), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(387), 5, + sym_boolean, + anon_sym_SEMI, + anon_sym_LBRACK, + anon_sym_POUND_LBRACE, + anon_sym_PIPE_DASH, + ACTIONS(382), 13, + sym_identifier, + anon_sym_LBRACE, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + [1297] = 16, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(163), 1, + anon_sym_LBRACE, + ACTIONS(167), 1, + aux_sym__cond_preproc_call_token1, + ACTIONS(177), 1, + anon_sym_DOLLAR_LBRACE, + ACTIONS(179), 1, + anon_sym_DOLLAR, + ACTIONS(392), 1, + anon_sym_POUND, + ACTIONS(394), 1, + sym_identifier, + STATE(266), 1, + sym__special_preproc_call, + STATE(267), 1, + sym__cond_preproc_call, + STATE(268), 1, + sym__generic_preproc_call, + ACTIONS(165), 2, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + STATE(63), 2, + sym_comment, + sym_pyfoam_template, + STATE(269), 2, + sym__macro_braces, + sym__macro_no_braces, + STATE(253), 4, + sym_preproc_call, + sym_dict_headless, + sym_macro, + sym_string_literal, + ACTIONS(183), 5, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + [1356] = 16, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(163), 1, + anon_sym_LBRACE, + ACTIONS(167), 1, + aux_sym__cond_preproc_call_token1, + ACTIONS(177), 1, + anon_sym_DOLLAR_LBRACE, + ACTIONS(179), 1, + anon_sym_DOLLAR, + ACTIONS(392), 1, + anon_sym_POUND, + ACTIONS(396), 1, + sym_identifier, + STATE(266), 1, + sym__special_preproc_call, + STATE(267), 1, + sym__cond_preproc_call, + STATE(268), 1, + sym__generic_preproc_call, + ACTIONS(165), 2, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + STATE(64), 2, + sym_comment, + sym_pyfoam_template, + STATE(269), 2, + sym__macro_braces, + sym__macro_no_braces, + STATE(252), 4, + sym_preproc_call, + sym_dict_headless, + sym_macro, + sym_string_literal, + ACTIONS(183), 5, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + [1415] = 7, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(401), 2, + anon_sym_RBRACE, + anon_sym_DOLLAR_DOLLAR, + ACTIONS(405), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(65), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(403), 5, + sym_boolean, + anon_sym_SEMI, + anon_sym_LBRACK, + anon_sym_POUND_LBRACE, + anon_sym_PIPE_DASH, + ACTIONS(398), 13, + sym_identifier, + anon_sym_LBRACE, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + [1456] = 16, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(9), 1, + aux_sym__cond_preproc_call_token1, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(360), 1, + anon_sym_LBRACE, + ACTIONS(362), 1, + anon_sym_POUND, + ACTIONS(364), 1, + anon_sym_DOLLAR_LBRACE, + ACTIONS(366), 1, + anon_sym_DOLLAR, + ACTIONS(408), 1, + sym_identifier, + STATE(179), 1, + sym__generic_preproc_call, + STATE(183), 1, + sym__cond_preproc_call, + STATE(186), 1, + sym__special_preproc_call, + ACTIONS(7), 2, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + STATE(66), 2, + sym_comment, + sym_pyfoam_template, + STATE(181), 2, + sym__macro_braces, + sym__macro_no_braces, + STATE(165), 4, + sym_preproc_call, + sym_dict_headless, + sym_macro, + sym_string_literal, + ACTIONS(368), 5, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + [1515] = 8, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(389), 1, + anon_sym_POUND, + ACTIONS(410), 1, + anon_sym_DOLLAR, + ACTIONS(385), 2, + sym__eof, + anon_sym_DOLLAR_DOLLAR, + STATE(67), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(387), 6, + sym_boolean, + anon_sym_SEMI, + anon_sym_LBRACK, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + anon_sym_PIPE_DASH, + ACTIONS(382), 12, + sym_identifier, + anon_sym_LBRACE, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + [1558] = 8, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(405), 1, + anon_sym_POUND, + ACTIONS(412), 1, + anon_sym_DOLLAR, + ACTIONS(401), 2, + sym__eof, + anon_sym_DOLLAR_DOLLAR, + STATE(68), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(403), 6, + sym_boolean, + anon_sym_SEMI, + anon_sym_LBRACK, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + anon_sym_PIPE_DASH, + ACTIONS(398), 12, + sym_identifier, + anon_sym_LBRACE, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + [1601] = 7, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(417), 2, + anon_sym_RBRACE, + anon_sym_DOLLAR_DOLLAR, + ACTIONS(421), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(69), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(419), 5, + sym_boolean, + anon_sym_SEMI, + anon_sym_LBRACK, + anon_sym_POUND_LBRACE, + anon_sym_PIPE_DASH, + ACTIONS(414), 13, + sym_identifier, + anon_sym_LBRACE, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + [1642] = 8, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(357), 1, + anon_sym_POUND, + ACTIONS(424), 1, + anon_sym_DOLLAR, + ACTIONS(353), 2, + sym__eof, + anon_sym_DOLLAR_DOLLAR, + STATE(70), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(355), 6, + sym_boolean, + anon_sym_SEMI, + anon_sym_LBRACK, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + anon_sym_PIPE_DASH, + ACTIONS(350), 12, + sym_identifier, + anon_sym_LBRACE, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + [1685] = 16, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(27), 1, + anon_sym_LBRACE, + ACTIONS(31), 1, + aux_sym__cond_preproc_call_token1, + ACTIONS(43), 1, + anon_sym_DOLLAR_LBRACE, + ACTIONS(45), 1, + anon_sym_DOLLAR, + ACTIONS(157), 1, + anon_sym_POUND, + ACTIONS(426), 1, + sym_identifier, + STATE(87), 1, + sym__special_preproc_call, + STATE(96), 1, + sym__generic_preproc_call, + STATE(108), 1, + sym__cond_preproc_call, + ACTIONS(29), 2, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + STATE(71), 2, + sym_comment, + sym_pyfoam_template, + STATE(101), 2, + sym__macro_braces, + sym__macro_no_braces, + STATE(93), 4, + sym_preproc_call, + sym_dict_headless, + sym_macro, + sym_string_literal, + ACTIONS(17), 5, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + [1744] = 8, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(421), 1, + anon_sym_POUND, + ACTIONS(428), 1, + anon_sym_DOLLAR, + ACTIONS(417), 2, + sym__eof, + anon_sym_DOLLAR_DOLLAR, + STATE(72), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(419), 6, + sym_boolean, + anon_sym_SEMI, + anon_sym_LBRACK, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + anon_sym_PIPE_DASH, + ACTIONS(414), 12, + sym_identifier, + anon_sym_LBRACE, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + [1787] = 16, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(250), 1, + aux_sym__cond_preproc_call_token1, + ACTIONS(256), 1, + anon_sym_DOLLAR_LBRACE, + ACTIONS(258), 1, + anon_sym_DOLLAR, + ACTIONS(374), 1, + anon_sym_LBRACE, + ACTIONS(376), 1, + anon_sym_POUND, + ACTIONS(430), 1, + sym_identifier, + STATE(147), 1, + sym__special_preproc_call, + STATE(149), 1, + sym__generic_preproc_call, + STATE(150), 1, + sym__cond_preproc_call, + ACTIONS(248), 2, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + STATE(73), 2, + sym_comment, + sym_pyfoam_template, + STATE(140), 2, + sym__macro_braces, + sym__macro_no_braces, + STATE(139), 4, + sym_preproc_call, + sym_dict_headless, + sym_macro, + sym_string_literal, + ACTIONS(378), 5, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + [1846] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(434), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(74), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(432), 19, + sym_identifier, + sym_boolean, + anon_sym_LBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [1882] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(438), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(75), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(436), 19, + sym_identifier, + sym_boolean, + anon_sym_LBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [1918] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(442), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(76), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(440), 19, + sym_identifier, + sym_boolean, + anon_sym_LBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [1954] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(410), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(77), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(387), 19, + sym_identifier, + sym_boolean, + anon_sym_LBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [1990] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(446), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(78), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(444), 19, + sym_identifier, + sym_boolean, + anon_sym_LBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [2026] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(450), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(79), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(448), 19, + sym_identifier, + sym_boolean, + anon_sym_LBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [2062] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(454), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(80), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(452), 19, + sym_identifier, + sym_boolean, + anon_sym_LBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [2098] = 6, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(458), 1, + anon_sym_SEMI, + ACTIONS(460), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(81), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(456), 18, + sym_identifier, + sym_boolean, + anon_sym_LBRACE, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [2136] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(464), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(82), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(462), 19, + sym_identifier, + sym_boolean, + anon_sym_LBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [2172] = 6, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(468), 1, + anon_sym_SEMI, + ACTIONS(470), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(83), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(466), 18, + sym_identifier, + sym_boolean, + anon_sym_LBRACE, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [2210] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(472), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(84), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(385), 19, + sym_identifier, + sym_boolean, + anon_sym_LBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [2246] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(476), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(85), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(474), 19, + sym_identifier, + sym_boolean, + anon_sym_LBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [2282] = 6, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(478), 1, + anon_sym_SEMI, + ACTIONS(438), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(86), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(436), 18, + sym_identifier, + sym_boolean, + anon_sym_LBRACE, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [2320] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(482), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(87), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(480), 19, + sym_identifier, + sym_boolean, + anon_sym_LBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [2356] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(486), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(88), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(484), 19, + sym_identifier, + sym_boolean, + anon_sym_LBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [2392] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(428), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(89), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(419), 19, + sym_identifier, + sym_boolean, + anon_sym_LBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [2428] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(412), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(90), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(403), 19, + sym_identifier, + sym_boolean, + anon_sym_LBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [2464] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(490), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(91), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(488), 19, + sym_identifier, + sym_boolean, + anon_sym_LBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [2500] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(492), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(92), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(417), 19, + sym_identifier, + sym_boolean, + anon_sym_LBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [2536] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(470), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(93), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(466), 19, + sym_identifier, + sym_boolean, + anon_sym_LBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [2572] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(496), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(94), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(494), 19, + sym_identifier, + sym_boolean, + anon_sym_LBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [2608] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(498), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(95), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(353), 19, + sym_identifier, + sym_boolean, + anon_sym_LBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [2644] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(502), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(96), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(500), 19, + sym_identifier, + sym_boolean, + anon_sym_LBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [2680] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(506), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(97), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(504), 19, + sym_identifier, + sym_boolean, + anon_sym_LBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [2716] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(510), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(98), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(508), 19, + sym_identifier, + sym_boolean, + anon_sym_LBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [2752] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(514), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(99), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(512), 19, + sym_identifier, + sym_boolean, + anon_sym_LBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [2788] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(516), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(100), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(401), 19, + sym_identifier, + sym_boolean, + anon_sym_LBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [2824] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(520), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(101), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(518), 19, + sym_identifier, + sym_boolean, + anon_sym_LBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [2860] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(524), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(102), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(522), 19, + sym_identifier, + sym_boolean, + anon_sym_LBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [2896] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(424), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(103), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(355), 19, + sym_identifier, + sym_boolean, + anon_sym_LBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [2932] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(528), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(104), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(526), 19, + sym_identifier, + sym_boolean, + anon_sym_LBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [2968] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(532), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(105), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(530), 19, + sym_identifier, + sym_boolean, + anon_sym_LBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [3004] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(536), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(106), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(534), 19, + sym_identifier, + sym_boolean, + anon_sym_LBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [3040] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(540), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(107), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(538), 19, + sym_identifier, + sym_boolean, + anon_sym_LBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [3076] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(544), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(108), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(542), 19, + sym_identifier, + sym_boolean, + anon_sym_LBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [3112] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(548), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(109), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(546), 19, + sym_identifier, + sym_boolean, + anon_sym_LBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [3148] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(552), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(110), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(550), 19, + sym_identifier, + sym_boolean, + anon_sym_LBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [3184] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(556), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(111), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(554), 19, + sym_identifier, + sym_boolean, + anon_sym_LBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [3220] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(506), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(112), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(504), 18, + sym_identifier, + sym_boolean, + anon_sym_LBRACE, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [3255] = 6, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(558), 1, + anon_sym_LBRACE, + ACTIONS(506), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(113), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(504), 17, + sym_identifier, + sym_boolean, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [3292] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(506), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(114), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(504), 18, + sym_identifier, + sym_boolean, + anon_sym_LBRACE, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [3327] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(562), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(115), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(560), 18, + sym_identifier, + sym_boolean, + anon_sym_LBRACE, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [3362] = 6, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(564), 1, + anon_sym_LBRACE, + ACTIONS(506), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(116), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(504), 17, + sym_identifier, + sym_boolean, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [3399] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(506), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(117), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(504), 18, + sym_identifier, + sym_boolean, + anon_sym_LBRACE, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [3434] = 6, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(564), 1, + anon_sym_LBRACE, + ACTIONS(506), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(118), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(504), 17, + sym_identifier, + sym_boolean, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [3471] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(568), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(119), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(566), 18, + sym_identifier, + sym_boolean, + anon_sym_LBRACE, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_RPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [3506] = 6, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(558), 1, + anon_sym_LBRACE, + ACTIONS(506), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(120), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(504), 17, + sym_identifier, + sym_boolean, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [3543] = 6, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(570), 1, + anon_sym_SEMI, + ACTIONS(460), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(121), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(456), 16, + sym_identifier, + sym_boolean, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [3579] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(575), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(122), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(573), 17, + sym_identifier, + sym_boolean, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [3613] = 6, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(577), 1, + anon_sym_SEMI, + ACTIONS(438), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(123), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(436), 16, + sym_identifier, + sym_boolean, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LBRACK, + anon_sym_LPAREN, + anon_sym_POUND_LBRACE, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_PIPE_DASH, + [3649] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(548), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(124), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(546), 15, + sym_identifier, + anon_sym_RBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [3681] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(496), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(125), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(494), 15, + sym_identifier, + anon_sym_RBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [3713] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(446), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(126), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(444), 15, + sym_identifier, + anon_sym_LBRACE, + anon_sym_RBRACE, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [3745] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(552), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(127), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(550), 15, + sym_identifier, + anon_sym_RBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [3777] = 7, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(580), 1, + anon_sym_LBRACE, + ACTIONS(586), 1, + anon_sym_LPAREN, + ACTIONS(584), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(128), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(582), 13, + sym_identifier, + anon_sym_RBRACE, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [3813] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(510), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(129), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(508), 15, + sym_identifier, + anon_sym_RBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [3845] = 6, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(534), 1, + anon_sym_LBRACE, + ACTIONS(591), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(130), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(589), 14, + sym_identifier, + anon_sym_RBRACE, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [3879] = 6, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(526), 1, + anon_sym_LBRACE, + ACTIONS(595), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(131), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(593), 14, + sym_identifier, + anon_sym_RBRACE, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [3913] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(450), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(132), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(448), 15, + sym_identifier, + anon_sym_RBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [3945] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(476), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(133), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(474), 15, + sym_identifier, + anon_sym_RBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [3977] = 6, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(599), 1, + anon_sym_SEMI, + ACTIONS(601), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(134), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(597), 14, + sym_identifier, + anon_sym_RBRACE, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [4011] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(410), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(135), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(387), 15, + sym_identifier, + anon_sym_LBRACE, + anon_sym_RBRACE, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [4043] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(454), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(136), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(452), 15, + sym_identifier, + anon_sym_RBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [4075] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(428), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(137), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(419), 15, + sym_identifier, + anon_sym_LBRACE, + anon_sym_RBRACE, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [4107] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(412), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(138), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(403), 15, + sym_identifier, + anon_sym_LBRACE, + anon_sym_RBRACE, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [4139] = 6, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(603), 1, + anon_sym_SEMI, + ACTIONS(470), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(139), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(466), 14, + sym_identifier, + anon_sym_RBRACE, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [4173] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(520), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(140), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(518), 15, + sym_identifier, + anon_sym_RBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [4205] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(540), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(141), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(538), 15, + sym_identifier, + anon_sym_RBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [4237] = 6, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(605), 1, + anon_sym_SEMI, + ACTIONS(438), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(142), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(436), 14, + sym_identifier, + anon_sym_RBRACE, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [4271] = 6, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(607), 1, + anon_sym_SEMI, + ACTIONS(460), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(143), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(456), 14, + sym_identifier, + anon_sym_RBRACE, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [4305] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(424), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(144), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(355), 15, + sym_identifier, + anon_sym_LBRACE, + anon_sym_RBRACE, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [4337] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(490), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(145), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(488), 15, + sym_identifier, + anon_sym_RBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [4369] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(486), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(146), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(484), 15, + sym_identifier, + anon_sym_RBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [4401] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(482), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(147), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(480), 15, + sym_identifier, + anon_sym_RBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [4433] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(470), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(148), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(466), 15, + sym_identifier, + anon_sym_RBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [4465] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(502), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(149), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(500), 15, + sym_identifier, + anon_sym_RBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [4497] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(544), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(150), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(542), 15, + sym_identifier, + anon_sym_RBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [4529] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(434), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(151), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(432), 15, + sym_identifier, + anon_sym_RBRACE, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [4561] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(611), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(152), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(609), 14, + sym_identifier, + anon_sym_RBRACE, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [4592] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(615), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(153), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(613), 14, + sym_identifier, + anon_sym_RBRACE, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [4623] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(442), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(154), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(440), 14, + sym_identifier, + anon_sym_RBRACE, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [4654] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(619), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(155), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(617), 14, + sym_identifier, + anon_sym_RBRACE, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [4685] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(623), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(156), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(621), 14, + sym_identifier, + anon_sym_RBRACE, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [4716] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(438), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(157), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(436), 14, + sym_identifier, + anon_sym_RBRACE, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [4747] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(584), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(158), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(582), 14, + sym_identifier, + anon_sym_RBRACE, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [4778] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(627), 2, + anon_sym_POUND, + anon_sym_DOLLAR, + STATE(159), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(625), 14, + sym_identifier, + anon_sym_RBRACE, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + anon_sym_DOLLAR_LBRACE, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [4809] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(496), 1, + anon_sym_POUND, + STATE(160), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(494), 14, + sym_identifier, + sym__eof, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [4839] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(470), 1, + anon_sym_POUND, + STATE(161), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(466), 14, + sym_identifier, + sym__eof, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [4869] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(548), 1, + anon_sym_POUND, + STATE(162), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(546), 14, + sym_identifier, + sym__eof, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [4899] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(412), 1, + anon_sym_POUND, + STATE(163), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(403), 14, + sym_identifier, + sym__eof, + anon_sym_LBRACE, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [4929] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(446), 1, + anon_sym_POUND, + STATE(164), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(444), 14, + sym_identifier, + sym__eof, + anon_sym_LBRACE, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [4959] = 6, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(470), 1, + anon_sym_POUND, + ACTIONS(629), 1, + anon_sym_SEMI, + STATE(165), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(466), 13, + sym_identifier, + sym__eof, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [4991] = 6, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(526), 1, + anon_sym_LBRACE, + ACTIONS(595), 1, + anon_sym_POUND, + STATE(166), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(593), 13, + sym_identifier, + sym__eof, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [5023] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(410), 1, + anon_sym_POUND, + STATE(167), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(387), 14, + sym_identifier, + sym__eof, + anon_sym_LBRACE, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [5053] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(540), 1, + anon_sym_POUND, + STATE(168), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(538), 14, + sym_identifier, + sym__eof, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [5083] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(486), 1, + anon_sym_POUND, + STATE(169), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(484), 14, + sym_identifier, + sym__eof, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [5113] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(450), 1, + anon_sym_POUND, + STATE(170), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(448), 14, + sym_identifier, + sym__eof, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [5143] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(552), 1, + anon_sym_POUND, + STATE(171), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(550), 14, + sym_identifier, + sym__eof, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [5173] = 7, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(584), 1, + anon_sym_POUND, + ACTIONS(631), 1, + anon_sym_LBRACE, + ACTIONS(633), 1, + anon_sym_LPAREN, + STATE(172), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(582), 12, + sym_identifier, + sym__eof, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [5207] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(424), 1, + anon_sym_POUND, + STATE(173), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(355), 14, + sym_identifier, + sym__eof, + anon_sym_LBRACE, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [5237] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(510), 1, + anon_sym_POUND, + STATE(174), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(508), 14, + sym_identifier, + sym__eof, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [5267] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(434), 1, + anon_sym_POUND, + STATE(175), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(432), 14, + sym_identifier, + sym__eof, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [5297] = 6, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(460), 1, + anon_sym_POUND, + ACTIONS(636), 1, + anon_sym_SEMI, + STATE(176), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(456), 13, + sym_identifier, + sym__eof, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [5329] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(428), 1, + anon_sym_POUND, + STATE(177), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(419), 14, + sym_identifier, + sym__eof, + anon_sym_LBRACE, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [5359] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(490), 1, + anon_sym_POUND, + STATE(178), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(488), 14, + sym_identifier, + sym__eof, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [5389] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(502), 1, + anon_sym_POUND, + STATE(179), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(500), 14, + sym_identifier, + sym__eof, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [5419] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(476), 1, + anon_sym_POUND, + STATE(180), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(474), 14, + sym_identifier, + sym__eof, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [5449] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(520), 1, + anon_sym_POUND, + STATE(181), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(518), 14, + sym_identifier, + sym__eof, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [5479] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(454), 1, + anon_sym_POUND, + STATE(182), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(452), 14, + sym_identifier, + sym__eof, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [5509] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(544), 1, + anon_sym_POUND, + STATE(183), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(542), 14, + sym_identifier, + sym__eof, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [5539] = 6, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(438), 1, + anon_sym_POUND, + ACTIONS(638), 1, + anon_sym_SEMI, + STATE(184), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(436), 13, + sym_identifier, + sym__eof, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [5571] = 6, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(534), 1, + anon_sym_LBRACE, + ACTIONS(591), 1, + anon_sym_POUND, + STATE(185), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(589), 13, + sym_identifier, + sym__eof, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [5603] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(482), 1, + anon_sym_POUND, + STATE(186), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(480), 14, + sym_identifier, + sym__eof, + anon_sym_SEMI, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [5633] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(623), 1, + anon_sym_POUND, + STATE(187), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(621), 13, + sym_identifier, + sym__eof, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [5662] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(627), 1, + anon_sym_POUND, + STATE(188), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(625), 13, + sym_identifier, + sym__eof, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [5691] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(442), 1, + anon_sym_POUND, + STATE(189), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(440), 13, + sym_identifier, + sym__eof, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [5720] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(584), 1, + anon_sym_POUND, + STATE(190), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(582), 13, + sym_identifier, + sym__eof, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [5749] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(642), 1, + anon_sym_POUND, + STATE(191), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(640), 13, + sym_identifier, + sym__eof, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [5778] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(611), 1, + anon_sym_POUND, + STATE(192), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(609), 13, + sym_identifier, + sym__eof, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [5807] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(438), 1, + anon_sym_POUND, + STATE(193), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(436), 13, + sym_identifier, + sym__eof, + aux_sym__special_preproc_call_token1, + aux_sym__special_preproc_call_token2, + aux_sym__cond_preproc_call_token1, + anon_sym_LPAREN, + sym_number_literal, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + anon_sym_DOLLAR_DOLLAR, + [5836] = 9, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(256), 1, + anon_sym_DOLLAR_LBRACE, + ACTIONS(258), 1, + anon_sym_DOLLAR, + ACTIONS(644), 1, + sym_identifier, + STATE(140), 2, + sym__macro_braces, + sym__macro_no_braces, + STATE(194), 2, + sym_comment, + sym_pyfoam_template, + STATE(195), 2, + sym_macro, + sym_string_literal, + ACTIONS(378), 5, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + [5871] = 9, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(177), 1, + anon_sym_DOLLAR_LBRACE, + ACTIONS(179), 1, + anon_sym_DOLLAR, + ACTIONS(646), 1, + sym_identifier, + STATE(195), 2, + sym_comment, + sym_pyfoam_template, + STATE(269), 2, + sym__macro_braces, + sym__macro_no_braces, + STATE(275), 2, + sym_macro, + sym_string_literal, + ACTIONS(183), 5, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + [5906] = 9, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(256), 1, + anon_sym_DOLLAR_LBRACE, + ACTIONS(258), 1, + anon_sym_DOLLAR, + ACTIONS(648), 1, + sym_identifier, + STATE(140), 2, + sym__macro_braces, + sym__macro_no_braces, + STATE(196), 2, + sym_comment, + sym_pyfoam_template, + STATE(197), 2, + sym_macro, + sym_string_literal, + ACTIONS(378), 5, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + [5941] = 9, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(256), 1, + anon_sym_DOLLAR_LBRACE, + ACTIONS(258), 1, + anon_sym_DOLLAR, + ACTIONS(650), 1, + sym_identifier, + STATE(125), 2, + sym_macro, + sym_string_literal, + STATE(140), 2, + sym__macro_braces, + sym__macro_no_braces, + STATE(197), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(378), 5, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + [5976] = 9, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(43), 1, + anon_sym_DOLLAR_LBRACE, + ACTIONS(45), 1, + anon_sym_DOLLAR, + ACTIONS(652), 1, + sym_identifier, + STATE(94), 2, + sym_macro, + sym_string_literal, + STATE(101), 2, + sym__macro_braces, + sym__macro_no_braces, + STATE(198), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(17), 5, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + [6011] = 9, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(364), 1, + anon_sym_DOLLAR_LBRACE, + ACTIONS(366), 1, + anon_sym_DOLLAR, + ACTIONS(654), 1, + sym_identifier, + STATE(160), 2, + sym_macro, + sym_string_literal, + STATE(181), 2, + sym__macro_braces, + sym__macro_no_braces, + STATE(199), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(368), 5, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + [6046] = 9, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(256), 1, + anon_sym_DOLLAR_LBRACE, + ACTIONS(258), 1, + anon_sym_DOLLAR, + ACTIONS(656), 1, + sym_identifier, + STATE(140), 2, + sym__macro_braces, + sym__macro_no_braces, + STATE(199), 2, + sym_macro, + sym_string_literal, + STATE(200), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(378), 5, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + [6081] = 9, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(256), 1, + anon_sym_DOLLAR_LBRACE, + ACTIONS(258), 1, + anon_sym_DOLLAR, + ACTIONS(658), 1, + sym_identifier, + STATE(140), 2, + sym__macro_braces, + sym__macro_no_braces, + STATE(198), 2, + sym_macro, + sym_string_literal, + STATE(201), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(378), 5, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + [6116] = 9, + ACTIONS(3), 1, + aux_sym_comment_token1, + ACTIONS(660), 1, + anon_sym_POUND_RBRACE, + ACTIONS(662), 1, + aux_sym_code_body_token1, + ACTIONS(666), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + STATE(204), 1, + aux_sym_code_body_repeat1, + STATE(207), 1, + sym_string_literal, + STATE(332), 1, + sym_code_body, + STATE(202), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(664), 5, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + [6149] = 9, + ACTIONS(3), 1, + aux_sym_comment_token1, + ACTIONS(662), 1, + aux_sym_code_body_token1, + ACTIONS(666), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(668), 1, + anon_sym_POUND_RBRACE, + STATE(204), 1, + aux_sym_code_body_repeat1, + STATE(207), 1, + sym_string_literal, + STATE(316), 1, + sym_code_body, + STATE(203), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(664), 5, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + [6182] = 8, + ACTIONS(3), 1, + aux_sym_comment_token1, + ACTIONS(662), 1, + aux_sym_code_body_token1, + ACTIONS(666), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(670), 1, + anon_sym_POUND_RBRACE, + STATE(205), 1, + aux_sym_code_body_repeat1, + STATE(207), 1, + sym_string_literal, + STATE(204), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(664), 5, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + [6212] = 7, + ACTIONS(3), 1, + aux_sym_comment_token1, + ACTIONS(666), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(672), 1, + anon_sym_POUND_RBRACE, + ACTIONS(674), 1, + aux_sym_code_body_token1, + STATE(207), 1, + sym_string_literal, + STATE(205), 3, + sym_comment, + sym_pyfoam_template, + aux_sym_code_body_repeat1, + ACTIONS(677), 5, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + [6240] = 4, + ACTIONS(3), 1, + aux_sym_comment_token1, + ACTIONS(666), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + STATE(206), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(510), 7, + anon_sym_POUND_RBRACE, + aux_sym_code_body_token1, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + [6260] = 4, + ACTIONS(3), 1, + aux_sym_comment_token1, + ACTIONS(666), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + STATE(207), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(680), 7, + anon_sym_POUND_RBRACE, + aux_sym_code_body_token1, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + [6280] = 4, + ACTIONS(3), 1, + aux_sym_comment_token1, + ACTIONS(666), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + STATE(208), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(490), 7, + anon_sym_POUND_RBRACE, + aux_sym_code_body_token1, + anon_sym_L_DQUOTE, + anon_sym_u_DQUOTE, + anon_sym_U_DQUOTE, + anon_sym_u8_DQUOTE, + anon_sym_DQUOTE, + [6300] = 7, + ACTIONS(3), 1, + aux_sym_comment_token1, + ACTIONS(666), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(682), 1, + anon_sym_DQUOTE, + ACTIONS(684), 1, + aux_sym_string_literal_token1, + ACTIONS(686), 1, + sym_escape_sequence, + STATE(218), 1, + aux_sym_string_literal_repeat1, + STATE(209), 2, + sym_comment, + sym_pyfoam_template, + [6323] = 7, + ACTIONS(3), 1, + aux_sym_comment_token1, + ACTIONS(666), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(684), 1, + aux_sym_string_literal_token1, + ACTIONS(686), 1, + sym_escape_sequence, + ACTIONS(688), 1, + anon_sym_DQUOTE, + STATE(224), 1, + aux_sym_string_literal_repeat1, + STATE(210), 2, + sym_comment, + sym_pyfoam_template, + [6346] = 7, + ACTIONS(3), 1, + aux_sym_comment_token1, + ACTIONS(666), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(684), 1, + aux_sym_string_literal_token1, + ACTIONS(686), 1, + sym_escape_sequence, + ACTIONS(690), 1, + anon_sym_DQUOTE, + STATE(212), 1, + aux_sym_string_literal_repeat1, + STATE(211), 2, + sym_comment, + sym_pyfoam_template, + [6369] = 7, + ACTIONS(3), 1, + aux_sym_comment_token1, + ACTIONS(666), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(684), 1, + aux_sym_string_literal_token1, + ACTIONS(686), 1, + sym_escape_sequence, + ACTIONS(692), 1, + anon_sym_DQUOTE, + STATE(224), 1, + aux_sym_string_literal_repeat1, + STATE(212), 2, + sym_comment, + sym_pyfoam_template, + [6392] = 7, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(504), 1, + anon_sym_RBRACE, + ACTIONS(694), 1, + anon_sym_LBRACE, + ACTIONS(696), 1, + anon_sym_LPAREN, + ACTIONS(698), 1, + sym_number_literal, + STATE(213), 2, + sym_comment, + sym_pyfoam_template, + [6415] = 6, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(700), 1, + anon_sym_RBRACK, + STATE(221), 1, + aux_sym_dimensions_repeat1, + ACTIONS(702), 2, + sym_identifier, + sym_number_literal, + STATE(214), 2, + sym_comment, + sym_pyfoam_template, + [6436] = 6, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(704), 1, + anon_sym_RBRACK, + STATE(221), 1, + aux_sym_dimensions_repeat1, + ACTIONS(702), 2, + sym_identifier, + sym_number_literal, + STATE(215), 2, + sym_comment, + sym_pyfoam_template, + [6457] = 6, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(706), 1, + anon_sym_RBRACK, + STATE(214), 1, + aux_sym_dimensions_repeat1, + ACTIONS(702), 2, + sym_identifier, + sym_number_literal, + STATE(216), 2, + sym_comment, + sym_pyfoam_template, + [6478] = 6, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(708), 1, + anon_sym_RBRACK, + STATE(215), 1, + aux_sym_dimensions_repeat1, + ACTIONS(702), 2, + sym_identifier, + sym_number_literal, + STATE(217), 2, + sym_comment, + sym_pyfoam_template, + [6499] = 7, + ACTIONS(3), 1, + aux_sym_comment_token1, + ACTIONS(666), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(684), 1, + aux_sym_string_literal_token1, + ACTIONS(686), 1, + sym_escape_sequence, + ACTIONS(710), 1, + anon_sym_DQUOTE, + STATE(224), 1, + aux_sym_string_literal_repeat1, + STATE(218), 2, + sym_comment, + sym_pyfoam_template, + [6522] = 7, + ACTIONS(3), 1, + aux_sym_comment_token1, + ACTIONS(666), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(684), 1, + aux_sym_string_literal_token1, + ACTIONS(686), 1, + sym_escape_sequence, + ACTIONS(712), 1, + anon_sym_DQUOTE, + STATE(224), 1, + aux_sym_string_literal_repeat1, + STATE(219), 2, + sym_comment, + sym_pyfoam_template, + [6545] = 7, + ACTIONS(3), 1, + aux_sym_comment_token1, + ACTIONS(666), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(684), 1, + aux_sym_string_literal_token1, + ACTIONS(686), 1, + sym_escape_sequence, + ACTIONS(714), 1, + anon_sym_DQUOTE, + STATE(219), 1, + aux_sym_string_literal_repeat1, + STATE(220), 2, + sym_comment, + sym_pyfoam_template, + [6568] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(716), 1, + anon_sym_RBRACK, + ACTIONS(718), 2, + sym_identifier, + sym_number_literal, + STATE(221), 3, + sym_comment, + sym_pyfoam_template, + aux_sym_dimensions_repeat1, + [6587] = 7, + ACTIONS(3), 1, + aux_sym_comment_token1, + ACTIONS(666), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(684), 1, + aux_sym_string_literal_token1, + ACTIONS(686), 1, + sym_escape_sequence, + ACTIONS(721), 1, + anon_sym_DQUOTE, + STATE(224), 1, + aux_sym_string_literal_repeat1, + STATE(222), 2, + sym_comment, + sym_pyfoam_template, + [6610] = 7, + ACTIONS(3), 1, + aux_sym_comment_token1, + ACTIONS(666), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(684), 1, + aux_sym_string_literal_token1, + ACTIONS(686), 1, + sym_escape_sequence, + ACTIONS(723), 1, + anon_sym_DQUOTE, + STATE(210), 1, + aux_sym_string_literal_repeat1, + STATE(223), 2, + sym_comment, + sym_pyfoam_template, + [6633] = 6, + ACTIONS(3), 1, + aux_sym_comment_token1, + ACTIONS(666), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(725), 1, + anon_sym_DQUOTE, + ACTIONS(727), 1, + aux_sym_string_literal_token1, + ACTIONS(730), 1, + sym_escape_sequence, + STATE(224), 3, + sym_comment, + sym_pyfoam_template, + aux_sym_string_literal_repeat1, + [6654] = 7, + ACTIONS(3), 1, + aux_sym_comment_token1, + ACTIONS(666), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(684), 1, + aux_sym_string_literal_token1, + ACTIONS(686), 1, + sym_escape_sequence, + ACTIONS(733), 1, + anon_sym_DQUOTE, + STATE(222), 1, + aux_sym_string_literal_repeat1, + STATE(225), 2, + sym_comment, + sym_pyfoam_template, + [6677] = 5, + ACTIONS(3), 1, + aux_sym_comment_token1, + ACTIONS(666), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(735), 1, + aux_sym_single_python_line_token1, + ACTIONS(738), 1, + anon_sym_LF, + STATE(226), 3, + sym_comment, + sym_pyfoam_template, + aux_sym_single_python_line_repeat1, + [6695] = 6, + ACTIONS(3), 1, + aux_sym_comment_token1, + ACTIONS(666), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(740), 1, + aux_sym_single_python_line_token1, + STATE(236), 1, + aux_sym_single_python_line_repeat1, + STATE(326), 1, + sym_single_python_line, + STATE(227), 2, + sym_comment, + sym_pyfoam_template, + [6715] = 6, + ACTIONS(3), 1, + aux_sym_comment_token1, + ACTIONS(666), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(740), 1, + aux_sym_single_python_line_token1, + STATE(236), 1, + aux_sym_single_python_line_repeat1, + STATE(324), 1, + sym_single_python_line, + STATE(228), 2, + sym_comment, + sym_pyfoam_template, + [6735] = 6, + ACTIONS(3), 1, + aux_sym_comment_token1, + ACTIONS(666), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(742), 1, + aux_sym_single_python_line_token1, + ACTIONS(744), 1, + anon_sym_RPAREN_DASH_DASH_GT, + STATE(240), 1, + aux_sym_single_python_line_repeat1, + STATE(229), 2, + sym_comment, + sym_pyfoam_template, + [6755] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + STATE(230), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(746), 3, + sym_identifier, + anon_sym_RBRACK, + sym_number_literal, + [6771] = 6, + ACTIONS(3), 1, + aux_sym_comment_token1, + ACTIONS(666), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(748), 1, + aux_sym_single_python_line_token1, + STATE(232), 1, + aux_sym_single_python_line_repeat1, + STATE(305), 1, + sym_single_python_line, + STATE(231), 2, + sym_comment, + sym_pyfoam_template, + [6791] = 6, + ACTIONS(3), 1, + aux_sym_comment_token1, + ACTIONS(666), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(744), 1, + anon_sym_DASH_PIPE, + ACTIONS(748), 1, + aux_sym_single_python_line_token1, + STATE(233), 1, + aux_sym_single_python_line_repeat1, + STATE(232), 2, + sym_comment, + sym_pyfoam_template, + [6811] = 5, + ACTIONS(3), 1, + aux_sym_comment_token1, + ACTIONS(666), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(738), 1, + anon_sym_DASH_PIPE, + ACTIONS(750), 1, + aux_sym_single_python_line_token1, + STATE(233), 3, + sym_comment, + sym_pyfoam_template, + aux_sym_single_python_line_repeat1, + [6829] = 6, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(504), 1, + anon_sym_RBRACE, + ACTIONS(753), 1, + anon_sym_LBRACE, + ACTIONS(755), 1, + anon_sym_LPAREN, + STATE(234), 2, + sym_comment, + sym_pyfoam_template, + [6849] = 5, + ACTIONS(3), 1, + aux_sym_comment_token1, + ACTIONS(666), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(759), 1, + aux_sym_string_literal_token1, + ACTIONS(757), 2, + anon_sym_DQUOTE, + sym_escape_sequence, + STATE(235), 2, + sym_comment, + sym_pyfoam_template, + [6867] = 6, + ACTIONS(3), 1, + aux_sym_comment_token1, + ACTIONS(666), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(740), 1, + aux_sym_single_python_line_token1, + ACTIONS(744), 1, + anon_sym_LF, + STATE(226), 1, + aux_sym_single_python_line_repeat1, + STATE(236), 2, + sym_comment, + sym_pyfoam_template, + [6887] = 6, + ACTIONS(3), 1, + aux_sym_comment_token1, + ACTIONS(666), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(742), 1, + aux_sym_single_python_line_token1, + STATE(229), 1, + aux_sym_single_python_line_repeat1, + STATE(285), 1, + sym_single_python_line, + STATE(237), 2, + sym_comment, + sym_pyfoam_template, + [6907] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + STATE(238), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(488), 3, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_SEMI, + [6923] = 6, + ACTIONS(3), 1, + aux_sym_comment_token1, + ACTIONS(666), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(748), 1, + aux_sym_single_python_line_token1, + STATE(232), 1, + aux_sym_single_python_line_repeat1, + STATE(311), 1, + sym_single_python_line, + STATE(239), 2, + sym_comment, + sym_pyfoam_template, + [6943] = 5, + ACTIONS(3), 1, + aux_sym_comment_token1, + ACTIONS(666), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(738), 1, + anon_sym_RPAREN_DASH_DASH_GT, + ACTIONS(761), 1, + aux_sym_single_python_line_token1, + STATE(240), 3, + sym_comment, + sym_pyfoam_template, + aux_sym_single_python_line_repeat1, + [6961] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + STATE(241), 2, + sym_comment, + sym_pyfoam_template, + ACTIONS(508), 3, + anon_sym_LBRACE, + anon_sym_RBRACE, + anon_sym_SEMI, + [6977] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(436), 1, + anon_sym_RBRACE, + ACTIONS(764), 1, + anon_sym_SEMI, + STATE(242), 2, + sym_comment, + sym_pyfoam_template, + [6994] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(353), 2, + anon_sym_LBRACE, + anon_sym_RBRACE, + STATE(243), 2, + sym_comment, + sym_pyfoam_template, + [7009] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(546), 2, + anon_sym_RBRACE, + anon_sym_SEMI, + STATE(244), 2, + sym_comment, + sym_pyfoam_template, + [7024] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(448), 2, + anon_sym_RBRACE, + anon_sym_SEMI, + STATE(245), 2, + sym_comment, + sym_pyfoam_template, + [7039] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(444), 2, + anon_sym_LBRACE, + anon_sym_RBRACE, + STATE(246), 2, + sym_comment, + sym_pyfoam_template, + [7054] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(387), 2, + anon_sym_LBRACE, + anon_sym_RBRACE, + STATE(247), 2, + sym_comment, + sym_pyfoam_template, + [7069] = 5, + ACTIONS(3), 1, + aux_sym_comment_token1, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(766), 1, + sym_prev_scope, + ACTIONS(768), 1, + sym_identifier, + STATE(248), 2, + sym_comment, + sym_pyfoam_template, + [7086] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(452), 2, + anon_sym_RBRACE, + anon_sym_SEMI, + STATE(249), 2, + sym_comment, + sym_pyfoam_template, + [7101] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(456), 1, + anon_sym_RBRACE, + ACTIONS(770), 1, + anon_sym_SEMI, + STATE(250), 2, + sym_comment, + sym_pyfoam_template, + [7118] = 4, + ACTIONS(3), 1, + aux_sym_comment_token1, + ACTIONS(666), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(772), 2, + aux_sym_single_python_line_token1, + anon_sym_LF, + STATE(251), 2, + sym_comment, + sym_pyfoam_template, + [7133] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(466), 1, + anon_sym_RBRACE, + ACTIONS(774), 1, + anon_sym_SEMI, + STATE(252), 2, + sym_comment, + sym_pyfoam_template, + [7150] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(466), 2, + anon_sym_RBRACE, + anon_sym_SEMI, + STATE(253), 2, + sym_comment, + sym_pyfoam_template, + [7165] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(474), 2, + anon_sym_RBRACE, + anon_sym_SEMI, + STATE(254), 2, + sym_comment, + sym_pyfoam_template, + [7180] = 5, + ACTIONS(3), 1, + aux_sym_comment_token1, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(776), 1, + sym_prev_scope, + ACTIONS(778), 1, + sym_identifier, + STATE(255), 2, + sym_comment, + sym_pyfoam_template, + [7197] = 4, + ACTIONS(3), 1, + aux_sym_comment_token1, + ACTIONS(666), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(772), 2, + aux_sym_single_python_line_token1, + anon_sym_DASH_PIPE, + STATE(256), 2, + sym_comment, + sym_pyfoam_template, + [7212] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(385), 2, + anon_sym_LBRACE, + anon_sym_RBRACE, + STATE(257), 2, + sym_comment, + sym_pyfoam_template, + [7227] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(534), 2, + anon_sym_LBRACE, + anon_sym_RBRACE, + STATE(258), 2, + sym_comment, + sym_pyfoam_template, + [7242] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(550), 2, + anon_sym_RBRACE, + anon_sym_SEMI, + STATE(259), 2, + sym_comment, + sym_pyfoam_template, + [7257] = 5, + ACTIONS(3), 1, + aux_sym_comment_token1, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(780), 1, + sym_prev_scope, + ACTIONS(782), 1, + sym_identifier, + STATE(260), 2, + sym_comment, + sym_pyfoam_template, + [7274] = 5, + ACTIONS(3), 1, + aux_sym_comment_token1, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(784), 1, + sym_prev_scope, + ACTIONS(786), 1, + sym_identifier, + STATE(261), 2, + sym_comment, + sym_pyfoam_template, + [7291] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(417), 2, + anon_sym_LBRACE, + anon_sym_RBRACE, + STATE(262), 2, + sym_comment, + sym_pyfoam_template, + [7306] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(484), 2, + anon_sym_RBRACE, + anon_sym_SEMI, + STATE(263), 2, + sym_comment, + sym_pyfoam_template, + [7321] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(526), 2, + anon_sym_LBRACE, + anon_sym_RBRACE, + STATE(264), 2, + sym_comment, + sym_pyfoam_template, + [7336] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(401), 2, + anon_sym_LBRACE, + anon_sym_RBRACE, + STATE(265), 2, + sym_comment, + sym_pyfoam_template, + [7351] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(480), 2, + anon_sym_RBRACE, + anon_sym_SEMI, + STATE(266), 2, + sym_comment, + sym_pyfoam_template, + [7366] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(542), 2, + anon_sym_RBRACE, + anon_sym_SEMI, + STATE(267), 2, + sym_comment, + sym_pyfoam_template, + [7381] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(500), 2, + anon_sym_RBRACE, + anon_sym_SEMI, + STATE(268), 2, + sym_comment, + sym_pyfoam_template, + [7396] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(518), 2, + anon_sym_RBRACE, + anon_sym_SEMI, + STATE(269), 2, + sym_comment, + sym_pyfoam_template, + [7411] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(355), 2, + anon_sym_LBRACE, + anon_sym_RBRACE, + STATE(270), 2, + sym_comment, + sym_pyfoam_template, + [7426] = 5, + ACTIONS(3), 1, + aux_sym_comment_token1, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(788), 1, + sym_prev_scope, + ACTIONS(790), 1, + sym_identifier, + STATE(271), 2, + sym_comment, + sym_pyfoam_template, + [7443] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(432), 2, + anon_sym_RBRACE, + anon_sym_SEMI, + STATE(272), 2, + sym_comment, + sym_pyfoam_template, + [7458] = 5, + ACTIONS(3), 1, + aux_sym_comment_token1, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(792), 1, + sym_prev_scope, + ACTIONS(794), 1, + sym_identifier, + STATE(273), 2, + sym_comment, + sym_pyfoam_template, + [7475] = 5, + ACTIONS(3), 1, + aux_sym_comment_token1, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(796), 1, + sym_prev_scope, + ACTIONS(798), 1, + sym_identifier, + STATE(274), 2, + sym_comment, + sym_pyfoam_template, + [7492] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(494), 2, + anon_sym_RBRACE, + anon_sym_SEMI, + STATE(275), 2, + sym_comment, + sym_pyfoam_template, + [7507] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(403), 2, + anon_sym_LBRACE, + anon_sym_RBRACE, + STATE(276), 2, + sym_comment, + sym_pyfoam_template, + [7522] = 5, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(504), 1, + anon_sym_RBRACE, + ACTIONS(694), 1, + anon_sym_LBRACE, + STATE(277), 2, + sym_comment, + sym_pyfoam_template, + [7539] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(419), 2, + anon_sym_LBRACE, + anon_sym_RBRACE, + STATE(278), 2, + sym_comment, + sym_pyfoam_template, + [7554] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(538), 2, + anon_sym_RBRACE, + anon_sym_SEMI, + STATE(279), 2, + sym_comment, + sym_pyfoam_template, + [7569] = 5, + ACTIONS(3), 1, + aux_sym_comment_token1, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(800), 1, + sym_prev_scope, + ACTIONS(802), 1, + sym_identifier, + STATE(280), 2, + sym_comment, + sym_pyfoam_template, + [7586] = 4, + ACTIONS(3), 1, + aux_sym_comment_token1, + ACTIONS(666), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(772), 2, + aux_sym_single_python_line_token1, + anon_sym_RPAREN_DASH_DASH_GT, + STATE(281), 2, + sym_comment, + sym_pyfoam_template, + [7601] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(804), 1, + anon_sym_RBRACE, + STATE(282), 2, + sym_comment, + sym_pyfoam_template, + [7615] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(806), 1, + anon_sym_RBRACE2, + STATE(283), 2, + sym_comment, + sym_pyfoam_template, + [7629] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(436), 1, + anon_sym_RBRACE, + STATE(284), 2, + sym_comment, + sym_pyfoam_template, + [7643] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(808), 1, + anon_sym_RPAREN_DASH_DASH_GT, + STATE(285), 2, + sym_comment, + sym_pyfoam_template, + [7657] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(810), 1, + sym_identifier, + STATE(286), 2, + sym_comment, + sym_pyfoam_template, + [7671] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(554), 1, + anon_sym_RBRACE, + STATE(287), 2, + sym_comment, + sym_pyfoam_template, + [7685] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(530), 1, + anon_sym_RBRACE, + STATE(288), 2, + sym_comment, + sym_pyfoam_template, + [7699] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(522), 1, + anon_sym_RBRACE, + STATE(289), 2, + sym_comment, + sym_pyfoam_template, + [7713] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(812), 1, + anon_sym_RBRACE, + STATE(290), 2, + sym_comment, + sym_pyfoam_template, + [7727] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(195), 1, + anon_sym_LBRACE, + STATE(291), 2, + sym_comment, + sym_pyfoam_template, + [7741] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(814), 1, + anon_sym_RBRACE2, + STATE(292), 2, + sym_comment, + sym_pyfoam_template, + [7755] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(816), 1, + sym_identifier, + STATE(293), 2, + sym_comment, + sym_pyfoam_template, + [7769] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(440), 1, + anon_sym_RBRACE, + STATE(294), 2, + sym_comment, + sym_pyfoam_template, + [7783] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(818), 1, + anon_sym_RBRACE, + STATE(295), 2, + sym_comment, + sym_pyfoam_template, + [7797] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(512), 1, + anon_sym_RBRACE, + STATE(296), 2, + sym_comment, + sym_pyfoam_template, + [7811] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(820), 1, + anon_sym_RBRACE2, + STATE(297), 2, + sym_comment, + sym_pyfoam_template, + [7825] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(822), 1, + sym_identifier, + STATE(298), 2, + sym_comment, + sym_pyfoam_template, + [7839] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(462), 1, + anon_sym_RBRACE, + STATE(299), 2, + sym_comment, + sym_pyfoam_template, + [7853] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(824), 1, + anon_sym_RBRACE2, + STATE(300), 2, + sym_comment, + sym_pyfoam_template, + [7867] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(826), 1, + sym_identifier, + STATE(301), 2, + sym_comment, + sym_pyfoam_template, + [7881] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(828), 1, + anon_sym_RBRACE, + STATE(302), 2, + sym_comment, + sym_pyfoam_template, + [7895] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(566), 1, + anon_sym_RBRACE, + STATE(303), 2, + sym_comment, + sym_pyfoam_template, + [7909] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(830), 1, + ts_builtin_sym_end, + STATE(304), 2, + sym_comment, + sym_pyfoam_template, + [7923] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(832), 1, + anon_sym_DASH_PIPE, + STATE(305), 2, + sym_comment, + sym_pyfoam_template, + [7937] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(834), 1, + sym_identifier, + STATE(306), 2, + sym_comment, + sym_pyfoam_template, + [7951] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(836), 1, + sym_identifier, + STATE(307), 2, + sym_comment, + sym_pyfoam_template, + [7965] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(838), 1, + anon_sym_RBRACE, + STATE(308), 2, + sym_comment, + sym_pyfoam_template, + [7979] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(840), 1, + anon_sym_RBRACE2, + STATE(309), 2, + sym_comment, + sym_pyfoam_template, + [7993] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(842), 1, + sym_identifier, + STATE(310), 2, + sym_comment, + sym_pyfoam_template, + [8007] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(844), 1, + anon_sym_DASH_PIPE, + STATE(311), 2, + sym_comment, + sym_pyfoam_template, + [8021] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(846), 1, + anon_sym_RBRACE, + STATE(312), 2, + sym_comment, + sym_pyfoam_template, + [8035] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(848), 1, + sym_identifier, + STATE(313), 2, + sym_comment, + sym_pyfoam_template, + [8049] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(850), 1, + anon_sym_RBRACE2, + STATE(314), 2, + sym_comment, + sym_pyfoam_template, + [8063] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(852), 1, + sym_identifier, + STATE(315), 2, + sym_comment, + sym_pyfoam_template, + [8077] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(854), 1, + anon_sym_POUND_RBRACE, + STATE(316), 2, + sym_comment, + sym_pyfoam_template, + [8091] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(856), 1, + anon_sym_RBRACE2, + STATE(317), 2, + sym_comment, + sym_pyfoam_template, + [8105] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(858), 1, + sym_identifier, + STATE(318), 2, + sym_comment, + sym_pyfoam_template, + [8119] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(860), 1, + anon_sym_RBRACE, + STATE(319), 2, + sym_comment, + sym_pyfoam_template, + [8133] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(862), 1, + sym_identifier, + STATE(320), 2, + sym_comment, + sym_pyfoam_template, + [8147] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(864), 1, + sym_identifier, + STATE(321), 2, + sym_comment, + sym_pyfoam_template, + [8161] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(866), 1, + anon_sym_RBRACE, + STATE(322), 2, + sym_comment, + sym_pyfoam_template, + [8175] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(868), 1, + sym_identifier, + STATE(323), 2, + sym_comment, + sym_pyfoam_template, + [8189] = 4, + ACTIONS(3), 1, + aux_sym_comment_token1, + ACTIONS(666), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(870), 1, + anon_sym_LF, + STATE(324), 2, + sym_comment, + sym_pyfoam_template, + [8203] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(153), 1, + anon_sym_LBRACE, + STATE(325), 2, + sym_comment, + sym_pyfoam_template, + [8217] = 4, + ACTIONS(3), 1, + aux_sym_comment_token1, + ACTIONS(666), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(872), 1, + anon_sym_LF, + STATE(326), 2, + sym_comment, + sym_pyfoam_template, + [8231] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(874), 1, + ts_builtin_sym_end, + STATE(327), 2, + sym_comment, + sym_pyfoam_template, + [8245] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(876), 1, + anon_sym_RBRACE2, + STATE(328), 2, + sym_comment, + sym_pyfoam_template, + [8259] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(878), 1, + anon_sym_LPAREN, + STATE(329), 2, + sym_comment, + sym_pyfoam_template, + [8273] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(880), 1, + sym_identifier, + STATE(330), 2, + sym_comment, + sym_pyfoam_template, + [8287] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(504), 1, + anon_sym_RBRACE, + STATE(331), 2, + sym_comment, + sym_pyfoam_template, + [8301] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(882), 1, + anon_sym_POUND_RBRACE, + STATE(332), 2, + sym_comment, + sym_pyfoam_template, + [8315] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(884), 1, + ts_builtin_sym_end, + STATE(333), 2, + sym_comment, + sym_pyfoam_template, + [8329] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(886), 1, + sym_identifier, + STATE(334), 2, + sym_comment, + sym_pyfoam_template, + [8343] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(888), 1, + sym_identifier, + STATE(335), 2, + sym_comment, + sym_pyfoam_template, + [8357] = 4, + ACTIONS(5), 1, + anon_sym_LT_BANG_DASH_DASH_LPAREN, + ACTIONS(19), 1, + aux_sym_comment_token1, + ACTIONS(890), 1, + anon_sym_RBRACE, + STATE(336), 2, + sym_comment, + sym_pyfoam_template, + [8371] = 1, + ACTIONS(892), 1, + ts_builtin_sym_end, + [8375] = 1, + ACTIONS(894), 1, + ts_builtin_sym_end, +}; + +static const uint32_t ts_small_parse_table_map[] = { + [SMALL_STATE(46)] = 0, + [SMALL_STATE(47)] = 89, + [SMALL_STATE(48)] = 178, + [SMALL_STATE(49)] = 267, + [SMALL_STATE(50)] = 354, + [SMALL_STATE(51)] = 443, + [SMALL_STATE(52)] = 532, + [SMALL_STATE(53)] = 621, + [SMALL_STATE(54)] = 710, + [SMALL_STATE(55)] = 799, + [SMALL_STATE(56)] = 888, + [SMALL_STATE(57)] = 962, + [SMALL_STATE(58)] = 1038, + [SMALL_STATE(59)] = 1079, + [SMALL_STATE(60)] = 1138, + [SMALL_STATE(61)] = 1197, + [SMALL_STATE(62)] = 1256, + [SMALL_STATE(63)] = 1297, + [SMALL_STATE(64)] = 1356, + [SMALL_STATE(65)] = 1415, + [SMALL_STATE(66)] = 1456, + [SMALL_STATE(67)] = 1515, + [SMALL_STATE(68)] = 1558, + [SMALL_STATE(69)] = 1601, + [SMALL_STATE(70)] = 1642, + [SMALL_STATE(71)] = 1685, + [SMALL_STATE(72)] = 1744, + [SMALL_STATE(73)] = 1787, + [SMALL_STATE(74)] = 1846, + [SMALL_STATE(75)] = 1882, + [SMALL_STATE(76)] = 1918, + [SMALL_STATE(77)] = 1954, + [SMALL_STATE(78)] = 1990, + [SMALL_STATE(79)] = 2026, + [SMALL_STATE(80)] = 2062, + [SMALL_STATE(81)] = 2098, + [SMALL_STATE(82)] = 2136, + [SMALL_STATE(83)] = 2172, + [SMALL_STATE(84)] = 2210, + [SMALL_STATE(85)] = 2246, + [SMALL_STATE(86)] = 2282, + [SMALL_STATE(87)] = 2320, + [SMALL_STATE(88)] = 2356, + [SMALL_STATE(89)] = 2392, + [SMALL_STATE(90)] = 2428, + [SMALL_STATE(91)] = 2464, + [SMALL_STATE(92)] = 2500, + [SMALL_STATE(93)] = 2536, + [SMALL_STATE(94)] = 2572, + [SMALL_STATE(95)] = 2608, + [SMALL_STATE(96)] = 2644, + [SMALL_STATE(97)] = 2680, + [SMALL_STATE(98)] = 2716, + [SMALL_STATE(99)] = 2752, + [SMALL_STATE(100)] = 2788, + [SMALL_STATE(101)] = 2824, + [SMALL_STATE(102)] = 2860, + [SMALL_STATE(103)] = 2896, + [SMALL_STATE(104)] = 2932, + [SMALL_STATE(105)] = 2968, + [SMALL_STATE(106)] = 3004, + [SMALL_STATE(107)] = 3040, + [SMALL_STATE(108)] = 3076, + [SMALL_STATE(109)] = 3112, + [SMALL_STATE(110)] = 3148, + [SMALL_STATE(111)] = 3184, + [SMALL_STATE(112)] = 3220, + [SMALL_STATE(113)] = 3255, + [SMALL_STATE(114)] = 3292, + [SMALL_STATE(115)] = 3327, + [SMALL_STATE(116)] = 3362, + [SMALL_STATE(117)] = 3399, + [SMALL_STATE(118)] = 3434, + [SMALL_STATE(119)] = 3471, + [SMALL_STATE(120)] = 3506, + [SMALL_STATE(121)] = 3543, + [SMALL_STATE(122)] = 3579, + [SMALL_STATE(123)] = 3613, + [SMALL_STATE(124)] = 3649, + [SMALL_STATE(125)] = 3681, + [SMALL_STATE(126)] = 3713, + [SMALL_STATE(127)] = 3745, + [SMALL_STATE(128)] = 3777, + [SMALL_STATE(129)] = 3813, + [SMALL_STATE(130)] = 3845, + [SMALL_STATE(131)] = 3879, + [SMALL_STATE(132)] = 3913, + [SMALL_STATE(133)] = 3945, + [SMALL_STATE(134)] = 3977, + [SMALL_STATE(135)] = 4011, + [SMALL_STATE(136)] = 4043, + [SMALL_STATE(137)] = 4075, + [SMALL_STATE(138)] = 4107, + [SMALL_STATE(139)] = 4139, + [SMALL_STATE(140)] = 4173, + [SMALL_STATE(141)] = 4205, + [SMALL_STATE(142)] = 4237, + [SMALL_STATE(143)] = 4271, + [SMALL_STATE(144)] = 4305, + [SMALL_STATE(145)] = 4337, + [SMALL_STATE(146)] = 4369, + [SMALL_STATE(147)] = 4401, + [SMALL_STATE(148)] = 4433, + [SMALL_STATE(149)] = 4465, + [SMALL_STATE(150)] = 4497, + [SMALL_STATE(151)] = 4529, + [SMALL_STATE(152)] = 4561, + [SMALL_STATE(153)] = 4592, + [SMALL_STATE(154)] = 4623, + [SMALL_STATE(155)] = 4654, + [SMALL_STATE(156)] = 4685, + [SMALL_STATE(157)] = 4716, + [SMALL_STATE(158)] = 4747, + [SMALL_STATE(159)] = 4778, + [SMALL_STATE(160)] = 4809, + [SMALL_STATE(161)] = 4839, + [SMALL_STATE(162)] = 4869, + [SMALL_STATE(163)] = 4899, + [SMALL_STATE(164)] = 4929, + [SMALL_STATE(165)] = 4959, + [SMALL_STATE(166)] = 4991, + [SMALL_STATE(167)] = 5023, + [SMALL_STATE(168)] = 5053, + [SMALL_STATE(169)] = 5083, + [SMALL_STATE(170)] = 5113, + [SMALL_STATE(171)] = 5143, + [SMALL_STATE(172)] = 5173, + [SMALL_STATE(173)] = 5207, + [SMALL_STATE(174)] = 5237, + [SMALL_STATE(175)] = 5267, + [SMALL_STATE(176)] = 5297, + [SMALL_STATE(177)] = 5329, + [SMALL_STATE(178)] = 5359, + [SMALL_STATE(179)] = 5389, + [SMALL_STATE(180)] = 5419, + [SMALL_STATE(181)] = 5449, + [SMALL_STATE(182)] = 5479, + [SMALL_STATE(183)] = 5509, + [SMALL_STATE(184)] = 5539, + [SMALL_STATE(185)] = 5571, + [SMALL_STATE(186)] = 5603, + [SMALL_STATE(187)] = 5633, + [SMALL_STATE(188)] = 5662, + [SMALL_STATE(189)] = 5691, + [SMALL_STATE(190)] = 5720, + [SMALL_STATE(191)] = 5749, + [SMALL_STATE(192)] = 5778, + [SMALL_STATE(193)] = 5807, + [SMALL_STATE(194)] = 5836, + [SMALL_STATE(195)] = 5871, + [SMALL_STATE(196)] = 5906, + [SMALL_STATE(197)] = 5941, + [SMALL_STATE(198)] = 5976, + [SMALL_STATE(199)] = 6011, + [SMALL_STATE(200)] = 6046, + [SMALL_STATE(201)] = 6081, + [SMALL_STATE(202)] = 6116, + [SMALL_STATE(203)] = 6149, + [SMALL_STATE(204)] = 6182, + [SMALL_STATE(205)] = 6212, + [SMALL_STATE(206)] = 6240, + [SMALL_STATE(207)] = 6260, + [SMALL_STATE(208)] = 6280, + [SMALL_STATE(209)] = 6300, + [SMALL_STATE(210)] = 6323, + [SMALL_STATE(211)] = 6346, + [SMALL_STATE(212)] = 6369, + [SMALL_STATE(213)] = 6392, + [SMALL_STATE(214)] = 6415, + [SMALL_STATE(215)] = 6436, + [SMALL_STATE(216)] = 6457, + [SMALL_STATE(217)] = 6478, + [SMALL_STATE(218)] = 6499, + [SMALL_STATE(219)] = 6522, + [SMALL_STATE(220)] = 6545, + [SMALL_STATE(221)] = 6568, + [SMALL_STATE(222)] = 6587, + [SMALL_STATE(223)] = 6610, + [SMALL_STATE(224)] = 6633, + [SMALL_STATE(225)] = 6654, + [SMALL_STATE(226)] = 6677, + [SMALL_STATE(227)] = 6695, + [SMALL_STATE(228)] = 6715, + [SMALL_STATE(229)] = 6735, + [SMALL_STATE(230)] = 6755, + [SMALL_STATE(231)] = 6771, + [SMALL_STATE(232)] = 6791, + [SMALL_STATE(233)] = 6811, + [SMALL_STATE(234)] = 6829, + [SMALL_STATE(235)] = 6849, + [SMALL_STATE(236)] = 6867, + [SMALL_STATE(237)] = 6887, + [SMALL_STATE(238)] = 6907, + [SMALL_STATE(239)] = 6923, + [SMALL_STATE(240)] = 6943, + [SMALL_STATE(241)] = 6961, + [SMALL_STATE(242)] = 6977, + [SMALL_STATE(243)] = 6994, + [SMALL_STATE(244)] = 7009, + [SMALL_STATE(245)] = 7024, + [SMALL_STATE(246)] = 7039, + [SMALL_STATE(247)] = 7054, + [SMALL_STATE(248)] = 7069, + [SMALL_STATE(249)] = 7086, + [SMALL_STATE(250)] = 7101, + [SMALL_STATE(251)] = 7118, + [SMALL_STATE(252)] = 7133, + [SMALL_STATE(253)] = 7150, + [SMALL_STATE(254)] = 7165, + [SMALL_STATE(255)] = 7180, + [SMALL_STATE(256)] = 7197, + [SMALL_STATE(257)] = 7212, + [SMALL_STATE(258)] = 7227, + [SMALL_STATE(259)] = 7242, + [SMALL_STATE(260)] = 7257, + [SMALL_STATE(261)] = 7274, + [SMALL_STATE(262)] = 7291, + [SMALL_STATE(263)] = 7306, + [SMALL_STATE(264)] = 7321, + [SMALL_STATE(265)] = 7336, + [SMALL_STATE(266)] = 7351, + [SMALL_STATE(267)] = 7366, + [SMALL_STATE(268)] = 7381, + [SMALL_STATE(269)] = 7396, + [SMALL_STATE(270)] = 7411, + [SMALL_STATE(271)] = 7426, + [SMALL_STATE(272)] = 7443, + [SMALL_STATE(273)] = 7458, + [SMALL_STATE(274)] = 7475, + [SMALL_STATE(275)] = 7492, + [SMALL_STATE(276)] = 7507, + [SMALL_STATE(277)] = 7522, + [SMALL_STATE(278)] = 7539, + [SMALL_STATE(279)] = 7554, + [SMALL_STATE(280)] = 7569, + [SMALL_STATE(281)] = 7586, + [SMALL_STATE(282)] = 7601, + [SMALL_STATE(283)] = 7615, + [SMALL_STATE(284)] = 7629, + [SMALL_STATE(285)] = 7643, + [SMALL_STATE(286)] = 7657, + [SMALL_STATE(287)] = 7671, + [SMALL_STATE(288)] = 7685, + [SMALL_STATE(289)] = 7699, + [SMALL_STATE(290)] = 7713, + [SMALL_STATE(291)] = 7727, + [SMALL_STATE(292)] = 7741, + [SMALL_STATE(293)] = 7755, + [SMALL_STATE(294)] = 7769, + [SMALL_STATE(295)] = 7783, + [SMALL_STATE(296)] = 7797, + [SMALL_STATE(297)] = 7811, + [SMALL_STATE(298)] = 7825, + [SMALL_STATE(299)] = 7839, + [SMALL_STATE(300)] = 7853, + [SMALL_STATE(301)] = 7867, + [SMALL_STATE(302)] = 7881, + [SMALL_STATE(303)] = 7895, + [SMALL_STATE(304)] = 7909, + [SMALL_STATE(305)] = 7923, + [SMALL_STATE(306)] = 7937, + [SMALL_STATE(307)] = 7951, + [SMALL_STATE(308)] = 7965, + [SMALL_STATE(309)] = 7979, + [SMALL_STATE(310)] = 7993, + [SMALL_STATE(311)] = 8007, + [SMALL_STATE(312)] = 8021, + [SMALL_STATE(313)] = 8035, + [SMALL_STATE(314)] = 8049, + [SMALL_STATE(315)] = 8063, + [SMALL_STATE(316)] = 8077, + [SMALL_STATE(317)] = 8091, + [SMALL_STATE(318)] = 8105, + [SMALL_STATE(319)] = 8119, + [SMALL_STATE(320)] = 8133, + [SMALL_STATE(321)] = 8147, + [SMALL_STATE(322)] = 8161, + [SMALL_STATE(323)] = 8175, + [SMALL_STATE(324)] = 8189, + [SMALL_STATE(325)] = 8203, + [SMALL_STATE(326)] = 8217, + [SMALL_STATE(327)] = 8231, + [SMALL_STATE(328)] = 8245, + [SMALL_STATE(329)] = 8259, + [SMALL_STATE(330)] = 8273, + [SMALL_STATE(331)] = 8287, + [SMALL_STATE(332)] = 8301, + [SMALL_STATE(333)] = 8315, + [SMALL_STATE(334)] = 8329, + [SMALL_STATE(335)] = 8343, + [SMALL_STATE(336)] = 8357, + [SMALL_STATE(337)] = 8371, + [SMALL_STATE(338)] = 8375, +}; + +static const TSParseActionEntry ts_parse_actions[] = { + [0] = {.entry = {.count = 0, .reusable = false}}, + [1] = {.entry = {.count = 1, .reusable = false}}, RECOVER(), + [3] = {.entry = {.count = 1, .reusable = false}}, SHIFT(338), + [5] = {.entry = {.count = 1, .reusable = true}}, SHIFT(237), + [7] = {.entry = {.count = 1, .reusable = true}}, SHIFT(169), + [9] = {.entry = {.count = 1, .reusable = true}}, SHIFT(200), + [11] = {.entry = {.count = 1, .reusable = false}}, SHIFT(313), + [13] = {.entry = {.count = 1, .reusable = true}}, SHIFT(9), + [15] = {.entry = {.count = 1, .reusable = true}}, SHIFT(172), + [17] = {.entry = {.count = 1, .reusable = true}}, SHIFT(223), + [19] = {.entry = {.count = 1, .reusable = true}}, SHIFT(338), + [21] = {.entry = {.count = 1, .reusable = true}}, SHIFT(227), + [23] = {.entry = {.count = 1, .reusable = true}}, SHIFT(37), + [25] = {.entry = {.count = 1, .reusable = true}}, SHIFT(333), + [27] = {.entry = {.count = 1, .reusable = true}}, SHIFT(52), + [29] = {.entry = {.count = 1, .reusable = true}}, SHIFT(88), + [31] = {.entry = {.count = 1, .reusable = true}}, SHIFT(201), + [33] = {.entry = {.count = 1, .reusable = false}}, SHIFT(286), + [35] = {.entry = {.count = 1, .reusable = true}}, SHIFT(217), + [37] = {.entry = {.count = 1, .reusable = true}}, SHIFT(6), + [39] = {.entry = {.count = 1, .reusable = true}}, SHIFT(270), + [41] = {.entry = {.count = 1, .reusable = true}}, SHIFT(202), + [43] = {.entry = {.count = 1, .reusable = true}}, SHIFT(274), + [45] = {.entry = {.count = 1, .reusable = false}}, SHIFT(273), + [47] = {.entry = {.count = 1, .reusable = true}}, SHIFT(117), + [49] = {.entry = {.count = 1, .reusable = true}}, SHIFT(239), + [51] = {.entry = {.count = 1, .reusable = true}}, SHIFT(112), + [53] = {.entry = {.count = 1, .reusable = true}}, SHIFT(97), + [55] = {.entry = {.count = 1, .reusable = true}}, SHIFT(135), + [57] = {.entry = {.count = 1, .reusable = true}}, SHIFT(92), + [59] = {.entry = {.count = 1, .reusable = true}}, SHIFT(100), + [61] = {.entry = {.count = 1, .reusable = true}}, SHIFT(103), + [63] = {.entry = {.count = 1, .reusable = true}}, SHIFT(247), + [65] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__non_uniform_list_repeat1, 2), SHIFT_REPEAT(52), + [68] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__non_uniform_list_repeat1, 2), SHIFT_REPEAT(88), + [71] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__non_uniform_list_repeat1, 2), SHIFT_REPEAT(201), + [74] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__non_uniform_list_repeat1, 2), SHIFT_REPEAT(286), + [77] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__non_uniform_list_repeat1, 2), SHIFT_REPEAT(217), + [80] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__non_uniform_list_repeat1, 2), SHIFT_REPEAT(6), + [83] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__non_uniform_list_repeat1, 2), + [85] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__non_uniform_list_repeat1, 2), SHIFT_REPEAT(202), + [88] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__non_uniform_list_repeat1, 2), SHIFT_REPEAT(274), + [91] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym__non_uniform_list_repeat1, 2), SHIFT_REPEAT(273), + [94] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__non_uniform_list_repeat1, 2), SHIFT_REPEAT(117), + [97] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__non_uniform_list_repeat1, 2), SHIFT_REPEAT(223), + [100] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__non_uniform_list_repeat1, 2), SHIFT_REPEAT(239), + [103] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__non_uniform_list_repeat1, 2), SHIFT_REPEAT(112), + [106] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym__non_uniform_list_repeat1, 2), SHIFT_REPEAT(97), + [109] = {.entry = {.count = 1, .reusable = true}}, SHIFT(173), + [111] = {.entry = {.count = 1, .reusable = true}}, SHIFT(278), + [113] = {.entry = {.count = 1, .reusable = true}}, SHIFT(276), + [115] = {.entry = {.count = 1, .reusable = true}}, SHIFT(84), + [117] = {.entry = {.count = 1, .reusable = true}}, SHIFT(68), + [119] = {.entry = {.count = 1, .reusable = true}}, SHIFT(262), + [121] = {.entry = {.count = 1, .reusable = true}}, SHIFT(137), + [123] = {.entry = {.count = 1, .reusable = true}}, SHIFT(167), + [125] = {.entry = {.count = 1, .reusable = true}}, SHIFT(67), + [127] = {.entry = {.count = 1, .reusable = true}}, SHIFT(138), + [129] = {.entry = {.count = 1, .reusable = true}}, SHIFT(70), + [131] = {.entry = {.count = 1, .reusable = true}}, SHIFT(144), + [133] = {.entry = {.count = 1, .reusable = true}}, SHIFT(265), + [135] = {.entry = {.count = 1, .reusable = true}}, SHIFT(77), + [137] = {.entry = {.count = 1, .reusable = true}}, SHIFT(177), + [139] = {.entry = {.count = 1, .reusable = true}}, SHIFT(90), + [141] = {.entry = {.count = 1, .reusable = true}}, SHIFT(65), + [143] = {.entry = {.count = 1, .reusable = true}}, SHIFT(257), + [145] = {.entry = {.count = 1, .reusable = true}}, SHIFT(163), + [147] = {.entry = {.count = 1, .reusable = true}}, SHIFT(243), + [149] = {.entry = {.count = 1, .reusable = true}}, SHIFT(58), + [151] = {.entry = {.count = 1, .reusable = true}}, SHIFT(62), + [153] = {.entry = {.count = 1, .reusable = true}}, SHIFT(43), + [155] = {.entry = {.count = 1, .reusable = true}}, SHIFT(156), + [157] = {.entry = {.count = 1, .reusable = false}}, SHIFT(335), + [159] = {.entry = {.count = 1, .reusable = true}}, SHIFT(116), + [161] = {.entry = {.count = 1, .reusable = true}}, SHIFT(120), + [163] = {.entry = {.count = 1, .reusable = true}}, SHIFT(47), + [165] = {.entry = {.count = 1, .reusable = true}}, SHIFT(263), + [167] = {.entry = {.count = 1, .reusable = true}}, SHIFT(194), + [169] = {.entry = {.count = 1, .reusable = false}}, SHIFT(315), + [171] = {.entry = {.count = 1, .reusable = true}}, SHIFT(216), + [173] = {.entry = {.count = 1, .reusable = true}}, SHIFT(2), + [175] = {.entry = {.count = 1, .reusable = true}}, SHIFT(203), + [177] = {.entry = {.count = 1, .reusable = true}}, SHIFT(248), + [179] = {.entry = {.count = 1, .reusable = false}}, SHIFT(271), + [181] = {.entry = {.count = 1, .reusable = true}}, SHIFT(234), + [183] = {.entry = {.count = 1, .reusable = true}}, SHIFT(220), + [185] = {.entry = {.count = 1, .reusable = true}}, SHIFT(231), + [187] = {.entry = {.count = 1, .reusable = true}}, SHIFT(213), + [189] = {.entry = {.count = 1, .reusable = true}}, SHIFT(331), + [191] = {.entry = {.count = 1, .reusable = true}}, SHIFT(29), + [193] = {.entry = {.count = 1, .reusable = true}}, SHIFT(118), + [195] = {.entry = {.count = 1, .reusable = true}}, SHIFT(42), + [197] = {.entry = {.count = 1, .reusable = true}}, SHIFT(187), + [199] = {.entry = {.count = 1, .reusable = true}}, SHIFT(19), + [201] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_key_value_repeat1, 2), + [203] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_key_value_repeat1, 2), SHIFT_REPEAT(88), + [206] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_key_value_repeat1, 2), SHIFT_REPEAT(201), + [209] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_key_value_repeat1, 2), SHIFT_REPEAT(335), + [212] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_key_value_repeat1, 2), SHIFT_REPEAT(217), + [215] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_key_value_repeat1, 2), SHIFT_REPEAT(6), + [218] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_key_value_repeat1, 2), SHIFT_REPEAT(202), + [221] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_key_value_repeat1, 2), SHIFT_REPEAT(274), + [224] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_key_value_repeat1, 2), SHIFT_REPEAT(273), + [227] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_key_value_repeat1, 2), SHIFT_REPEAT(116), + [230] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_key_value_repeat1, 2), SHIFT_REPEAT(223), + [233] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_key_value_repeat1, 2), SHIFT_REPEAT(239), + [236] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_key_value_repeat1, 2), SHIFT_REPEAT(120), + [239] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_key_value_repeat1, 2), SHIFT_REPEAT(97), + [242] = {.entry = {.count = 1, .reusable = true}}, SHIFT(192), + [244] = {.entry = {.count = 1, .reusable = true}}, SHIFT(152), + [246] = {.entry = {.count = 1, .reusable = true}}, SHIFT(176), + [248] = {.entry = {.count = 1, .reusable = true}}, SHIFT(146), + [250] = {.entry = {.count = 1, .reusable = true}}, SHIFT(196), + [252] = {.entry = {.count = 1, .reusable = false}}, SHIFT(298), + [254] = {.entry = {.count = 1, .reusable = true}}, SHIFT(20), + [256] = {.entry = {.count = 1, .reusable = true}}, SHIFT(261), + [258] = {.entry = {.count = 1, .reusable = false}}, SHIFT(260), + [260] = {.entry = {.count = 1, .reusable = true}}, SHIFT(128), + [262] = {.entry = {.count = 1, .reusable = true}}, SHIFT(228), + [264] = {.entry = {.count = 1, .reusable = true}}, SHIFT(33), + [266] = {.entry = {.count = 1, .reusable = true}}, SHIFT(143), + [268] = {.entry = {.count = 1, .reusable = true}}, SHIFT(121), + [270] = {.entry = {.count = 1, .reusable = true}}, SHIFT(250), + [272] = {.entry = {.count = 1, .reusable = true}}, SHIFT(171), + [274] = {.entry = {.count = 1, .reusable = true}}, SHIFT(254), + [276] = {.entry = {.count = 1, .reusable = true}}, SHIFT(259), + [278] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_dict_core_repeat1, 2, .production_id = 7), + [280] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_dict_core_repeat1, 2, .production_id = 7), SHIFT_REPEAT(146), + [283] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_dict_core_repeat1, 2, .production_id = 7), SHIFT_REPEAT(196), + [286] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_dict_core_repeat1, 2, .production_id = 7), SHIFT_REPEAT(298), + [289] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_dict_core_repeat1, 2, .production_id = 7), SHIFT_REPEAT(20), + [292] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_dict_core_repeat1, 2, .production_id = 7), SHIFT_REPEAT(261), + [295] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_dict_core_repeat1, 2, .production_id = 7), SHIFT_REPEAT(260), + [298] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_dict_core_repeat1, 2, .production_id = 7), SHIFT_REPEAT(128), + [301] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_dict_core_repeat1, 2, .production_id = 7), SHIFT_REPEAT(223), + [304] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_dict_core_repeat1, 2, .production_id = 7), SHIFT_REPEAT(228), + [307] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_dict_core_repeat1, 2, .production_id = 7), SHIFT_REPEAT(33), + [310] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_dict_core, 1, .production_id = 10), + [312] = {.entry = {.count = 1, .reusable = true}}, SHIFT(110), + [314] = {.entry = {.count = 1, .reusable = true}}, SHIFT(85), + [316] = {.entry = {.count = 1, .reusable = true}}, SHIFT(127), + [318] = {.entry = {.count = 1, .reusable = true}}, SHIFT(133), + [320] = {.entry = {.count = 1, .reusable = true}}, SHIFT(180), + [322] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_foam_repeat1, 2, .production_id = 7), SHIFT_REPEAT(169), + [325] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_foam_repeat1, 2, .production_id = 7), SHIFT_REPEAT(200), + [328] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_foam_repeat1, 2, .production_id = 7), SHIFT_REPEAT(313), + [331] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_foam_repeat1, 2, .production_id = 7), SHIFT_REPEAT(9), + [334] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_foam_repeat1, 2, .production_id = 7), SHIFT_REPEAT(172), + [337] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_foam_repeat1, 2, .production_id = 7), SHIFT_REPEAT(223), + [340] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_foam_repeat1, 2, .production_id = 7), SHIFT_REPEAT(227), + [343] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_foam_repeat1, 2, .production_id = 7), SHIFT_REPEAT(37), + [346] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_foam_repeat1, 2, .production_id = 7), + [348] = {.entry = {.count = 1, .reusable = true}}, SHIFT(327), + [350] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__non_uniform_list, 2), REDUCE(sym__non_uniform_list, 3, .production_id = 12), + [353] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__non_uniform_list, 3, .production_id = 12), + [355] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__non_uniform_list, 2), + [357] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__non_uniform_list, 2), REDUCE(sym__non_uniform_list, 3, .production_id = 12), + [360] = {.entry = {.count = 1, .reusable = true}}, SHIFT(55), + [362] = {.entry = {.count = 1, .reusable = false}}, SHIFT(323), + [364] = {.entry = {.count = 1, .reusable = true}}, SHIFT(255), + [366] = {.entry = {.count = 1, .reusable = false}}, SHIFT(280), + [368] = {.entry = {.count = 1, .reusable = true}}, SHIFT(225), + [370] = {.entry = {.count = 1, .reusable = true}}, SHIFT(161), + [372] = {.entry = {.count = 1, .reusable = true}}, SHIFT(83), + [374] = {.entry = {.count = 1, .reusable = true}}, SHIFT(54), + [376] = {.entry = {.count = 1, .reusable = false}}, SHIFT(320), + [378] = {.entry = {.count = 1, .reusable = true}}, SHIFT(211), + [380] = {.entry = {.count = 1, .reusable = true}}, SHIFT(148), + [382] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__non_uniform_list, 4, .production_id = 23), REDUCE(sym__non_uniform_list, 5, .production_id = 24), + [385] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__non_uniform_list, 5, .production_id = 24), + [387] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__non_uniform_list, 4, .production_id = 23), + [389] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__non_uniform_list, 4, .production_id = 23), REDUCE(sym__non_uniform_list, 5, .production_id = 24), + [392] = {.entry = {.count = 1, .reusable = false}}, SHIFT(321), + [394] = {.entry = {.count = 1, .reusable = true}}, SHIFT(253), + [396] = {.entry = {.count = 1, .reusable = true}}, SHIFT(252), + [398] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__non_uniform_list, 3, .production_id = 16), REDUCE(sym__non_uniform_list, 4, .production_id = 20), + [401] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__non_uniform_list, 4, .production_id = 20), + [403] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__non_uniform_list, 3, .production_id = 16), + [405] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__non_uniform_list, 3, .production_id = 16), REDUCE(sym__non_uniform_list, 4, .production_id = 20), + [408] = {.entry = {.count = 1, .reusable = true}}, SHIFT(165), + [410] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__non_uniform_list, 4, .production_id = 23), + [412] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__non_uniform_list, 3, .production_id = 16), + [414] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__non_uniform_list, 3, .production_id = 17), REDUCE(sym__non_uniform_list, 4, .production_id = 21), + [417] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__non_uniform_list, 4, .production_id = 21), + [419] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__non_uniform_list, 3, .production_id = 17), + [421] = {.entry = {.count = 2, .reusable = false}}, REDUCE(sym__non_uniform_list, 3, .production_id = 17), REDUCE(sym__non_uniform_list, 4, .production_id = 21), + [424] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__non_uniform_list, 2), + [426] = {.entry = {.count = 1, .reusable = true}}, SHIFT(93), + [428] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__non_uniform_list, 3, .production_id = 17), + [430] = {.entry = {.count = 1, .reusable = true}}, SHIFT(139), + [432] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__macro_no_braces, 2), + [434] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__macro_no_braces, 2), + [436] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_dict, 4, .production_id = 9), + [438] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_dict, 4, .production_id = 9), + [440] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_dict, 5, .production_id = 9), + [442] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_dict, 5, .production_id = 9), + [444] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__uniform_list, 4, .production_id = 23), + [446] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__uniform_list, 4, .production_id = 23), + [448] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__generic_preproc_call, 4, .production_id = 15), + [450] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__generic_preproc_call, 4, .production_id = 15), + [452] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__macro_braces, 4), + [454] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__macro_braces, 4), + [456] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_dict, 3, .production_id = 9), + [458] = {.entry = {.count = 1, .reusable = true}}, SHIFT(75), + [460] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_dict, 3, .production_id = 9), + [462] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_dimensions, 2), + [464] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_dimensions, 2), + [466] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__generic_preproc_call, 3, .production_id = 15), + [468] = {.entry = {.count = 1, .reusable = true}}, SHIFT(79), + [470] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__generic_preproc_call, 3, .production_id = 15), + [472] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__non_uniform_list, 5, .production_id = 24), + [474] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_dict_headless, 2), + [476] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_dict_headless, 2), + [478] = {.entry = {.count = 1, .reusable = true}}, SHIFT(76), + [480] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_preproc_call, 1, .production_id = 3), + [482] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_preproc_call, 1, .production_id = 3), + [484] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__special_preproc_call, 1, .production_id = 1), + [486] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__special_preproc_call, 1, .production_id = 1), + [488] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_string_literal, 2), + [490] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_string_literal, 2), + [492] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__non_uniform_list, 4, .production_id = 21), + [494] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__cond_preproc_call, 3, .production_id = 14), + [496] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__cond_preproc_call, 3, .production_id = 14), + [498] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__non_uniform_list, 3, .production_id = 12), + [500] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_preproc_call, 1, .production_id = 4), + [502] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_preproc_call, 1, .production_id = 4), + [504] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__value, 1), + [506] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__value, 1), + [508] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_string_literal, 3), + [510] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_string_literal, 3), + [512] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_code, 2), + [514] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_code, 2), + [516] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__non_uniform_list, 4, .production_id = 20), + [518] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_macro, 1), + [520] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_macro, 1), + [522] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_dimensions, 3, .production_id = 18), + [524] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_dimensions, 3, .production_id = 18), + [526] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list, 1, .production_id = 2), + [528] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list, 1, .production_id = 2), + [530] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_code, 3), + [532] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_code, 3), + [534] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_list, 1, .production_id = 5), + [536] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_list, 1, .production_id = 5), + [538] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__macro_braces, 3), + [540] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__macro_braces, 3), + [542] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__special_preproc_call, 1, .production_id = 3), + [544] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__special_preproc_call, 1, .production_id = 3), + [546] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__macro_no_braces, 3), + [548] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__macro_no_braces, 3), + [550] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_dict_headless, 3, .production_id = 22), + [552] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_dict_headless, 3, .production_id = 22), + [554] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pyfoam_expression, 3, .production_id = 8), + [556] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_pyfoam_expression, 3, .production_id = 8), + [558] = {.entry = {.count = 1, .reusable = true}}, SHIFT(44), + [560] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym__non_uniform_list_repeat1, 1), + [562] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym__non_uniform_list_repeat1, 1), + [564] = {.entry = {.count = 1, .reusable = true}}, SHIFT(36), + [566] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__list_item, 1), + [568] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__list_item, 1), + [570] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_dict, 3, .production_id = 9), SHIFT(75), + [573] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_key_value_repeat1, 1), + [575] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_key_value_repeat1, 1), + [577] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym_dict, 4, .production_id = 9), SHIFT(76), + [580] = {.entry = {.count = 1, .reusable = true}}, SHIFT(38), + [582] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__statement, 1), + [584] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__statement, 1), + [586] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__statement, 1), SHIFT(15), + [589] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__statement, 1, .production_id = 5), + [591] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__statement, 1, .production_id = 5), + [593] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym__statement, 1, .production_id = 2), + [595] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym__statement, 1, .production_id = 2), + [597] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_dict_core_repeat1, 1), + [599] = {.entry = {.count = 1, .reusable = true}}, SHIFT(153), + [601] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_dict_core_repeat1, 1), + [603] = {.entry = {.count = 1, .reusable = true}}, SHIFT(132), + [605] = {.entry = {.count = 1, .reusable = true}}, SHIFT(154), + [607] = {.entry = {.count = 1, .reusable = true}}, SHIFT(157), + [609] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_key_value, 3, .production_id = 13), + [611] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_key_value, 3, .production_id = 13), + [613] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_dict_core_repeat1, 2), + [615] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_dict_core_repeat1, 2), + [617] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_dict_core_repeat1, 1, .production_id = 2), + [619] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_dict_core_repeat1, 1, .production_id = 2), + [621] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_key_value, 2, .production_id = 6), + [623] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_key_value, 2, .production_id = 6), + [625] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pyfoam_variable, 3, .production_id = 8), + [627] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_pyfoam_variable, 3, .production_id = 8), + [629] = {.entry = {.count = 1, .reusable = true}}, SHIFT(170), + [631] = {.entry = {.count = 1, .reusable = true}}, SHIFT(35), + [633] = {.entry = {.count = 2, .reusable = true}}, REDUCE(sym__statement, 1), SHIFT(23), + [636] = {.entry = {.count = 1, .reusable = true}}, SHIFT(193), + [638] = {.entry = {.count = 1, .reusable = true}}, SHIFT(189), + [640] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_foam_repeat1, 1, .production_id = 2), + [642] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_foam_repeat1, 1, .production_id = 2), + [644] = {.entry = {.count = 1, .reusable = true}}, SHIFT(195), + [646] = {.entry = {.count = 1, .reusable = true}}, SHIFT(275), + [648] = {.entry = {.count = 1, .reusable = true}}, SHIFT(197), + [650] = {.entry = {.count = 1, .reusable = true}}, SHIFT(125), + [652] = {.entry = {.count = 1, .reusable = true}}, SHIFT(94), + [654] = {.entry = {.count = 1, .reusable = true}}, SHIFT(160), + [656] = {.entry = {.count = 1, .reusable = true}}, SHIFT(199), + [658] = {.entry = {.count = 1, .reusable = true}}, SHIFT(198), + [660] = {.entry = {.count = 1, .reusable = false}}, SHIFT(99), + [662] = {.entry = {.count = 1, .reusable = false}}, SHIFT(207), + [664] = {.entry = {.count = 1, .reusable = false}}, SHIFT(209), + [666] = {.entry = {.count = 1, .reusable = false}}, SHIFT(237), + [668] = {.entry = {.count = 1, .reusable = false}}, SHIFT(296), + [670] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_code_body, 1), + [672] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_code_body_repeat1, 2), + [674] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_code_body_repeat1, 2), SHIFT_REPEAT(207), + [677] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_code_body_repeat1, 2), SHIFT_REPEAT(209), + [680] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_code_body_repeat1, 1), + [682] = {.entry = {.count = 1, .reusable = false}}, SHIFT(208), + [684] = {.entry = {.count = 1, .reusable = true}}, SHIFT(235), + [686] = {.entry = {.count = 1, .reusable = false}}, SHIFT(235), + [688] = {.entry = {.count = 1, .reusable = false}}, SHIFT(98), + [690] = {.entry = {.count = 1, .reusable = false}}, SHIFT(145), + [692] = {.entry = {.count = 1, .reusable = false}}, SHIFT(129), + [694] = {.entry = {.count = 1, .reusable = true}}, SHIFT(45), + [696] = {.entry = {.count = 1, .reusable = true}}, SHIFT(28), + [698] = {.entry = {.count = 1, .reusable = true}}, SHIFT(329), + [700] = {.entry = {.count = 1, .reusable = true}}, SHIFT(289), + [702] = {.entry = {.count = 1, .reusable = true}}, SHIFT(230), + [704] = {.entry = {.count = 1, .reusable = true}}, SHIFT(102), + [706] = {.entry = {.count = 1, .reusable = true}}, SHIFT(299), + [708] = {.entry = {.count = 1, .reusable = true}}, SHIFT(82), + [710] = {.entry = {.count = 1, .reusable = false}}, SHIFT(206), + [712] = {.entry = {.count = 1, .reusable = false}}, SHIFT(241), + [714] = {.entry = {.count = 1, .reusable = false}}, SHIFT(238), + [716] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_dimensions_repeat1, 2, .production_id = 19), + [718] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_dimensions_repeat1, 2, .production_id = 19), SHIFT_REPEAT(230), + [721] = {.entry = {.count = 1, .reusable = false}}, SHIFT(174), + [723] = {.entry = {.count = 1, .reusable = false}}, SHIFT(91), + [725] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_string_literal_repeat1, 2), + [727] = {.entry = {.count = 2, .reusable = true}}, REDUCE(aux_sym_string_literal_repeat1, 2), SHIFT_REPEAT(235), + [730] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_string_literal_repeat1, 2), SHIFT_REPEAT(235), + [733] = {.entry = {.count = 1, .reusable = false}}, SHIFT(178), + [735] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_single_python_line_repeat1, 2), SHIFT_REPEAT(251), + [738] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_single_python_line_repeat1, 2), + [740] = {.entry = {.count = 1, .reusable = false}}, SHIFT(251), + [742] = {.entry = {.count = 1, .reusable = false}}, SHIFT(281), + [744] = {.entry = {.count = 1, .reusable = false}}, REDUCE(sym_single_python_line, 1), + [746] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_dimensions_repeat1, 1, .production_id = 11), + [748] = {.entry = {.count = 1, .reusable = false}}, SHIFT(256), + [750] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_single_python_line_repeat1, 2), SHIFT_REPEAT(256), + [753] = {.entry = {.count = 1, .reusable = true}}, SHIFT(32), + [755] = {.entry = {.count = 1, .reusable = true}}, SHIFT(10), + [757] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_string_literal_repeat1, 1), + [759] = {.entry = {.count = 1, .reusable = true}}, REDUCE(aux_sym_string_literal_repeat1, 1), + [761] = {.entry = {.count = 2, .reusable = false}}, REDUCE(aux_sym_single_python_line_repeat1, 2), SHIFT_REPEAT(281), + [764] = {.entry = {.count = 1, .reusable = true}}, SHIFT(294), + [766] = {.entry = {.count = 1, .reusable = false}}, SHIFT(306), + [768] = {.entry = {.count = 1, .reusable = true}}, SHIFT(309), + [770] = {.entry = {.count = 1, .reusable = true}}, SHIFT(284), + [772] = {.entry = {.count = 1, .reusable = false}}, REDUCE(aux_sym_single_python_line_repeat1, 1), + [774] = {.entry = {.count = 1, .reusable = true}}, SHIFT(245), + [776] = {.entry = {.count = 1, .reusable = false}}, SHIFT(334), + [778] = {.entry = {.count = 1, .reusable = true}}, SHIFT(292), + [780] = {.entry = {.count = 1, .reusable = false}}, SHIFT(307), + [782] = {.entry = {.count = 1, .reusable = true}}, SHIFT(151), + [784] = {.entry = {.count = 1, .reusable = false}}, SHIFT(330), + [786] = {.entry = {.count = 1, .reusable = true}}, SHIFT(283), + [788] = {.entry = {.count = 1, .reusable = false}}, SHIFT(310), + [790] = {.entry = {.count = 1, .reusable = true}}, SHIFT(272), + [792] = {.entry = {.count = 1, .reusable = false}}, SHIFT(301), + [794] = {.entry = {.count = 1, .reusable = true}}, SHIFT(74), + [796] = {.entry = {.count = 1, .reusable = false}}, SHIFT(318), + [798] = {.entry = {.count = 1, .reusable = true}}, SHIFT(328), + [800] = {.entry = {.count = 1, .reusable = false}}, SHIFT(293), + [802] = {.entry = {.count = 1, .reusable = true}}, SHIFT(175), + [804] = {.entry = {.count = 1, .reusable = true}}, SHIFT(86), + [806] = {.entry = {.count = 1, .reusable = true}}, SHIFT(141), + [808] = {.entry = {.count = 1, .reusable = true}}, SHIFT(337), + [810] = {.entry = {.count = 1, .reusable = true}}, SHIFT(60), + [812] = {.entry = {.count = 1, .reusable = true}}, SHIFT(164), + [814] = {.entry = {.count = 1, .reusable = true}}, SHIFT(168), + [816] = {.entry = {.count = 1, .reusable = true}}, SHIFT(162), + [818] = {.entry = {.count = 1, .reusable = true}}, SHIFT(126), + [820] = {.entry = {.count = 1, .reusable = true}}, SHIFT(182), + [822] = {.entry = {.count = 1, .reusable = true}}, SHIFT(73), + [824] = {.entry = {.count = 1, .reusable = true}}, SHIFT(136), + [826] = {.entry = {.count = 1, .reusable = true}}, SHIFT(109), + [828] = {.entry = {.count = 1, .reusable = true}}, SHIFT(78), + [830] = {.entry = {.count = 1, .reusable = true}}, ACCEPT_INPUT(), + [832] = {.entry = {.count = 1, .reusable = true}}, SHIFT(287), + [834] = {.entry = {.count = 1, .reusable = true}}, SHIFT(314), + [836] = {.entry = {.count = 1, .reusable = true}}, SHIFT(124), + [838] = {.entry = {.count = 1, .reusable = true}}, SHIFT(142), + [840] = {.entry = {.count = 1, .reusable = true}}, SHIFT(279), + [842] = {.entry = {.count = 1, .reusable = true}}, SHIFT(244), + [844] = {.entry = {.count = 1, .reusable = true}}, SHIFT(111), + [846] = {.entry = {.count = 1, .reusable = true}}, SHIFT(246), + [848] = {.entry = {.count = 1, .reusable = true}}, SHIFT(66), + [850] = {.entry = {.count = 1, .reusable = true}}, SHIFT(249), + [852] = {.entry = {.count = 1, .reusable = true}}, SHIFT(64), + [854] = {.entry = {.count = 1, .reusable = true}}, SHIFT(288), + [856] = {.entry = {.count = 1, .reusable = true}}, SHIFT(80), + [858] = {.entry = {.count = 1, .reusable = true}}, SHIFT(317), + [860] = {.entry = {.count = 1, .reusable = true}}, SHIFT(242), + [862] = {.entry = {.count = 1, .reusable = true}}, SHIFT(61), + [864] = {.entry = {.count = 1, .reusable = true}}, SHIFT(63), + [866] = {.entry = {.count = 1, .reusable = true}}, SHIFT(123), + [868] = {.entry = {.count = 1, .reusable = true}}, SHIFT(59), + [870] = {.entry = {.count = 1, .reusable = true}}, SHIFT(159), + [872] = {.entry = {.count = 1, .reusable = true}}, SHIFT(188), + [874] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_foam, 2, .production_id = 2), + [876] = {.entry = {.count = 1, .reusable = true}}, SHIFT(107), + [878] = {.entry = {.count = 1, .reusable = true}}, SHIFT(14), + [880] = {.entry = {.count = 1, .reusable = true}}, SHIFT(300), + [882] = {.entry = {.count = 1, .reusable = true}}, SHIFT(105), + [884] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_foam, 1), + [886] = {.entry = {.count = 1, .reusable = true}}, SHIFT(297), + [888] = {.entry = {.count = 1, .reusable = true}}, SHIFT(71), + [890] = {.entry = {.count = 1, .reusable = true}}, SHIFT(184), + [892] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_pyfoam_template, 3, .production_id = 8), + [894] = {.entry = {.count = 1, .reusable = true}}, REDUCE(sym_comment, 1), +}; + +#ifdef __cplusplus +extern "C" { +#endif +void *tree_sitter_foam_external_scanner_create(void); +void tree_sitter_foam_external_scanner_destroy(void *); +bool tree_sitter_foam_external_scanner_scan(void *, TSLexer *, const bool *); +unsigned tree_sitter_foam_external_scanner_serialize(void *, char *); +void tree_sitter_foam_external_scanner_deserialize(void *, const char *, unsigned); + +#ifdef _WIN32 +#define extern __declspec(dllexport) +#endif + +extern const TSLanguage *tree_sitter_foam(void) { + static const 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 = &ts_parse_table[0][0], + .small_parse_table = ts_small_parse_table, + .small_parse_table_map = ts_small_parse_table_map, + .parse_actions = ts_parse_actions, + .symbol_names = ts_symbol_names, + .field_names = ts_field_names, + .field_map_slices = ts_field_map_slices, + .field_map_entries = ts_field_map_entries, + .symbol_metadata = ts_symbol_metadata, + .public_symbol_map = ts_symbol_map, + .alias_map = ts_non_terminal_alias_map, + .alias_sequences = &ts_alias_sequences[0][0], + .lex_modes = ts_lex_modes, + .lex_fn = ts_lex, + .keyword_lex_fn = ts_lex_keywords, + .keyword_capture_token = sym_identifier, + .external_scanner = { + &ts_external_scanner_states[0][0], + ts_external_scanner_symbol_map, + tree_sitter_foam_external_scanner_create, + tree_sitter_foam_external_scanner_destroy, + tree_sitter_foam_external_scanner_scan, + tree_sitter_foam_external_scanner_serialize, + tree_sitter_foam_external_scanner_deserialize, + }, + }; + return &language; +} +#ifdef __cplusplus +} +#endif diff --git a/vendored_parsers/tree-sitter-foam/src/scanner.c b/vendored_parsers/tree-sitter-foam/src/scanner.c new file mode 100644 index 0000000000..8d5cfc7945 --- /dev/null +++ b/vendored_parsers/tree-sitter-foam/src/scanner.c @@ -0,0 +1,135 @@ +#include +#include +#include +#include + +#include "tree_sitter/parser.h" + +/** + * This enum is mapped to the `externals` list in the grammar according to how + * they are ordered (the names are abitrary). + * + * When the `scan` function is called, the parameter `syms` contains a bool for + * each enum attribute indicating whether the parse tree at the current position + * can accept the corresponding symbol. + * + * The attribute `fail` is not part of the parse tree, it is used to indicate + * that no matching symbol was found. + * + * The meanings are: + * - identifier: OpenFOAM identifiers (keyword names) + */ +enum TokenType { + IDENTIFIER, + BOOLEAN, + END_OF_FILE, +}; + +const char *const boolean_values[] = {"on", "off", "true", "false"}; + +static void advance(TSLexer *lexer) { lexer->advance(lexer, false); } + +static void skip(TSLexer *lexer) { lexer->advance(lexer, true); } + +static bool non_identifier_char(const uint32_t chr) { + switch (chr) { + case '"': + case '\'': + case ';': + case '$': + case '#': + case ' ': + case '{': + case '}': + case '[': + case ']': + case '\t': + case '\n': + case '\r': + case '\f': + case '\v': + case '\0': + return true; + default: + return false; + } +} + +void *tree_sitter_foam_external_scanner_create() { return NULL; } + +/** + * Main logic entry point. + * Since the state is a singular vector, it can just be cast and used directly. + */ +bool tree_sitter_foam_external_scanner_scan(void *payload, TSLexer *lexer, + const bool *valid_symbols) { + int32_t nesting_level = 0; + char current_ident[6] = {0}; + + while (iswspace(lexer->lookahead) && lexer->lookahead != '\0') { + skip(lexer); + } + + if (!isalpha(lexer->lookahead) && lexer->lookahead != '_') { + if (lexer->eof(lexer)) { + lexer->result_symbol = END_OF_FILE; + return true; + } + return false; + } + + current_ident[0] = (char)lexer->lookahead; + advance(lexer); + + int idx = 1; + while (true) { + if (lexer->eof(lexer)) { + break; + } + + // Stop if: + // Not an identifier char and nesting level is 0, + // or if nesting level falls under 0 (There is an extra ")") + if (non_identifier_char(lexer->lookahead) && nesting_level == 0) { + lexer->mark_end(lexer); + break; + } + if (lexer->lookahead == '(') { + ++nesting_level; + } else if (lexer->lookahead == ')') { + --nesting_level; + if (nesting_level == -1) { + lexer->mark_end(lexer); + break; + } + } + + if (idx < 5) { + current_ident[idx++] = (char)lexer->lookahead; + for (int j = 0; j < 4; j++) { + if (strcmp(current_ident, boolean_values[j]) == 0) { + advance(lexer); + lexer->result_symbol = BOOLEAN; + return true; + } + } + } + advance(lexer); + } + + if (valid_symbols[IDENTIFIER]) { + lexer->result_symbol = IDENTIFIER; + return true; + } + return false; +} + +unsigned tree_sitter_foam_external_scanner_serialize(void *payload, + char *buffer) { + return 0; +} + +void tree_sitter_foam_external_scanner_deserialize(void *payload, char *buffer, + unsigned length) {} + +void tree_sitter_foam_external_scanner_destroy(void *payload) {} diff --git a/vendored_parsers/tree-sitter-foam/src/tree_sitter/parser.h b/vendored_parsers/tree-sitter-foam/src/tree_sitter/parser.h new file mode 100644 index 0000000000..2b14ac1046 --- /dev/null +++ b/vendored_parsers/tree-sitter-foam/src/tree_sitter/parser.h @@ -0,0 +1,224 @@ +#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 * const *symbol_names; + const char * const *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; + const TSStateId *primary_state_ids; +}; + +/* + * 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_ diff --git a/vendored_parsers/tree-sitter-foam/syntax-highlighting.png b/vendored_parsers/tree-sitter-foam/syntax-highlighting.png new file mode 100644 index 0000000000..b195943984 Binary files /dev/null and b/vendored_parsers/tree-sitter-foam/syntax-highlighting.png differ diff --git a/vendored_parsers/tree-sitter-foam/test/corpus/basic_values.txt b/vendored_parsers/tree-sitter-foam/test/corpus/basic_values.txt new file mode 100644 index 0000000000..808253bb74 --- /dev/null +++ b/vendored_parsers/tree-sitter-foam/test/corpus/basic_values.txt @@ -0,0 +1,257 @@ +================================================================================ +Comments +================================================================================ + +// Comment 1 +/* + Comment 2 +*/ + +-------------------------------------------------------------------------------- + +(foam + (comment) + (comment)) + +================================================================================ +Key-value pair with missing value +================================================================================ + +number ; +p; + +-------------------------------------------------------------------------------- + +(foam + (key_value + (identifier)) + (key_value + (identifier))) + +================================================================================ +Dimensions +================================================================================ + +dimensions [1 -1 2 0 0 0]; +dimensions [m^2 s^-2]; + +-------------------------------------------------------------------------------- + +(foam + (key_value + (identifier) + (dimensions + (number_literal) + (number_literal) + (number_literal) + (number_literal) + (number_literal) + (number_literal))) + (key_value + (identifier) + (dimensions + (identifier) + (identifier)))) + +================================================================================ +Succession of basic values +================================================================================ + +scheme gauss something 1.0; + +-------------------------------------------------------------------------------- + +(foam + (key_value + (identifier) + (identifier) + (identifier) + (number_literal))) + +================================================================================ +Literal strings with spaces/escapes +================================================================================ + +key "Cool string with spaces"; +key "Cool string\\n with spaces"; +".*Wall" 1.0; + +-------------------------------------------------------------------------------- + +(foam + (key_value + (identifier) + (string_literal)) + (key_value + (identifier) + (string_literal + (escape_sequence))) + (key_value + (string_literal) + (number_literal))) + +================================================================================ +Floating-point numbers +================================================================================ + +number 5; +number .5; +number -1.25; +number 5.0e13; +number -5.0E-13; + + +-------------------------------------------------------------------------------- + +(foam + (key_value + (identifier) + (number_literal)) + (key_value + (identifier) + (number_literal)) + (key_value + (identifier) + (number_literal)) + (key_value + (identifier) + (number_literal)) + (key_value + (identifier) + (number_literal))) + +================================================================================ +Identifiers as keywords and values +================================================================================ + +scheme Gauss1; +div(phi,U1) K; +laplacian((1|A(U+v)*D-mT),p) Gauss linear corrected; + +-------------------------------------------------------------------------------- + +(foam + (key_value + (identifier) + (identifier)) + (key_value + (identifier) + (identifier)) + (key_value + (identifier) + (identifier) + (identifier) + (identifier))) + +================================================================================ +Boolean values +================================================================================ + +option1 off; +option2 on; +option3 true; +option4 false; + +-------------------------------------------------------------------------------- + +(foam + (key_value + (identifier) + (boolean)) + (key_value + (identifier) + (boolean)) + (key_value + (identifier) + (boolean)) + (key_value + (identifier) + (boolean))) + +================================================================================ +Macros +================================================================================ + +var $PO; +var $../../some/file/path; +div(phi,U0) $..DK; +div(phi,U1) $.. DK; +div(phi,U2) $..DK Gauss; + +-------------------------------------------------------------------------------- + +(foam + (key_value + (identifier) + (macro + (identifier))) + (key_value + (identifier) + (macro + (prev_scope) + (identifier))) + (key_value + (identifier) + (macro + (prev_scope) + (identifier))) + (key_value + (identifier) + (macro + (prev_scope) + (identifier))) + (key_value + (identifier) + (macro + (prev_scope) + (identifier)) + (identifier))) + +================================================================================ +Cpp code blocks +================================================================================ + +emptyCode #{ #}; + +code +#{ + /* + This will not fail if #{ shows up here outside a string literal + #} also works as expected + */ + #include + #include "someFile.H" + + { + os << vector(-::sin($angle), 0, ::cos($angle)); + os << "#{ example #}"; + } +#}; + +codeInclude #{ #include "vector.H" #}; + +code +#{ + pointField points(30); + points[0] = point(0.5, 0, -0.5); +#}; + +-------------------------------------------------------------------------------- + +(foam + (key_value + (identifier) + (code)) + (key_value + (identifier) + (code + (comment) + (code_body))) + (key_value + (identifier) + (code + (code_body))) + (key_value + (identifier) + (code + (code_body)))) diff --git a/vendored_parsers/tree-sitter-foam/test/corpus/dictionaries.txt b/vendored_parsers/tree-sitter-foam/test/corpus/dictionaries.txt new file mode 100644 index 0000000000..91be70631e --- /dev/null +++ b/vendored_parsers/tree-sitter-foam/test/corpus/dictionaries.txt @@ -0,0 +1,229 @@ +================================================================================ +Base dictionaries with +================================================================================ + +dict +{ +} + +dict +{ + entry1 0.0; + entry2 "spaced string"; +} + +dict +{ + // Some entry + entry1 + { + param 1.0; + } + + // wall BD + ".*Wall" + { + param 5.0; + } + + $entry1; + + entry2 0.0; +} + +-------------------------------------------------------------------------------- + +(foam + (dict + (identifier)) + (dict + (identifier) + (dict_core + (key_value + (identifier) + (number_literal)) + (key_value + (identifier) + (string_literal)))) + (dict + (identifier) + (comment) + (dict_core + (dict + (identifier) + (dict_core + (key_value + (identifier) + (number_literal)))) + (comment) + (dict + (string_literal) + (dict_core + (key_value + (identifier) + (number_literal)))) + (macro + (identifier)) + (key_value + (identifier) + (number_literal))))) + +================================================================================ +Dictionary with comment after identifier +================================================================================ + +dict // description +{ + key val; +} + +-------------------------------------------------------------------------------- + +(foam + (dict + (identifier) + (comment) + (dict_core + (key_value + (identifier) + (identifier))))) + +================================================================================ +Dictionaries as parts of keyword values +================================================================================ + +default CrankNicolson ocCoeff +{ + type scale; + scale linearRamp; + duration 1.0; + value 0.9; +}; + +-------------------------------------------------------------------------------- + +(foam + (key_value + (identifier) + (identifier) + (dict + (identifier) + (dict_core + (key_value + (identifier) + (identifier)) + (key_value + (identifier) + (identifier)) + (key_value + (identifier) + (number_literal)) + (key_value + (identifier) + (number_literal)))))) + +================================================================================ +Lists of dictionaries with list-like keywords +================================================================================ + +boundary +( + inlet + { + type patch; + edgeLabels List