From f5254e890b9ee9f863255fc19a150a280cdc0f80 Mon Sep 17 00:00:00 2001 From: Elwardi Date: Sat, 18 May 2024 21:27:25 +0200 Subject: [PATCH 1/8] Add support for OpenFOAM language --- build.rs | 5 +++++ sample_files/foamAfterDict | 18 ++++++++++++++++++ sample_files/foamBeforeDict | 16 ++++++++++++++++ src/parse/guess_language.rs | 8 ++++++++ src/parse/tree_sitter_parser.rs | 32 ++++++++++++++++++++++++++++++++ 5 files changed, 79 insertions(+) create mode 100644 sample_files/foamAfterDict create mode 100644 sample_files/foamBeforeDict 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/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..f102395ee3 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,12 @@ pub(crate) fn language_globs(language: Language) -> Vec { "Emakefile", ], FSharp => &["*.fs", "*.fsx", "*.fsi"], + Foam => &[ + "*Dict", + "*Properties", + "fvSolution", + "fvSchemes", + ], 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..8e66f94499 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,37 @@ 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 { From 533d6551c45f5d3189a870f22f311dd36b88975d Mon Sep 17 00:00:00 2001 From: Elwardi Date: Sun, 19 May 2024 10:49:23 +0200 Subject: [PATCH 2/8] Squashed 'vendored_parsers/tree-sitter-foam/' content from commit 04664b40c git-subtree-dir: vendored_parsers/tree-sitter-foam git-subtree-split: 04664b40c0dadb7ef37028acf3422c63271d377b --- .eslintrc.js | 20 + .github/workflows/main.yml | 34 + .github/workflows/npm-publish.yml | 39 + .gitignore | 6 + .travis.yml | 9 + Cargo.toml | 26 + LICENSE | 21 + Makefile | 44 + README.md | 41 + binding.gyp | 20 + bindings/go/bindings.go | 14 + bindings/go/bindings_test.go | 29 + bindings/go/go.mod | 14 + bindings/go/parser.c | 1 + bindings/go/scanner.c | 1 + bindings/go/tree_sitter | 1 + bindings/node/binding.cc | 28 + bindings/node/index.js | 19 + bindings/rust/README.md | 8 + bindings/rust/build.rs | 31 + bindings/rust/lib.rs | 54 + grammar.js | 254 + package.json | 41 + queries/folds.scm | 7 + queries/highlights.scm | 64 + queries/indents.scm | 11 + queries/injections.scm | 9 + queries/locals.scm | 6 + queries/textobjects.scm | 5 + queries/textsubjects-container-outer.scm | 3 + queries/textsubjects-smart.scm | 14 + src/grammar.json | 1118 ++ src/node-types.json | 916 ++ src/parser.c | 11681 +++++++++++++++++++++ src/scanner.c | 135 + src/tree_sitter/parser.h | 224 + syntax-highlighting.png | Bin 0 -> 63777 bytes test/corpus/basic_values.txt | 257 + test/corpus/dictionaries.txt | 229 + test/corpus/directives.txt | 135 + test/corpus/lists.txt | 87 + test/corpus_windows/basic_values.txt | 255 + test/corpus_windows/dictionaries.txt | 229 + test/corpus_windows/directives.txt | 135 + test/corpus_windows/lists.txt | 87 + test/highlight/example-file.foam | 104 + testOFFiles.sh | 76 + tree-sitter-foam.wasm | Bin 0 -> 48009 bytes 48 files changed, 16542 insertions(+) create mode 100644 .eslintrc.js create mode 100644 .github/workflows/main.yml create mode 100644 .github/workflows/npm-publish.yml create mode 100644 .gitignore create mode 100644 .travis.yml create mode 100644 Cargo.toml create mode 100644 LICENSE create mode 100644 Makefile create mode 100644 README.md create mode 100644 binding.gyp create mode 100644 bindings/go/bindings.go create mode 100644 bindings/go/bindings_test.go create mode 100644 bindings/go/go.mod create mode 120000 bindings/go/parser.c create mode 120000 bindings/go/scanner.c create mode 120000 bindings/go/tree_sitter create mode 100644 bindings/node/binding.cc create mode 100644 bindings/node/index.js create mode 100644 bindings/rust/README.md create mode 100644 bindings/rust/build.rs create mode 100644 bindings/rust/lib.rs create mode 100644 grammar.js create mode 100644 package.json create mode 100644 queries/folds.scm create mode 100644 queries/highlights.scm create mode 100644 queries/indents.scm create mode 100644 queries/injections.scm create mode 100644 queries/locals.scm create mode 100644 queries/textobjects.scm create mode 100644 queries/textsubjects-container-outer.scm create mode 100644 queries/textsubjects-smart.scm create mode 100644 src/grammar.json create mode 100644 src/node-types.json create mode 100644 src/parser.c create mode 100644 src/scanner.c create mode 100644 src/tree_sitter/parser.h create mode 100644 syntax-highlighting.png create mode 100644 test/corpus/basic_values.txt create mode 100644 test/corpus/dictionaries.txt create mode 100644 test/corpus/directives.txt create mode 100644 test/corpus/lists.txt create mode 100644 test/corpus_windows/basic_values.txt create mode 100644 test/corpus_windows/dictionaries.txt create mode 100644 test/corpus_windows/directives.txt create mode 100644 test/corpus_windows/lists.txt create mode 100644 test/highlight/example-file.foam create mode 100755 testOFFiles.sh create mode 100755 tree-sitter-foam.wasm diff --git a/.eslintrc.js b/.eslintrc.js new file mode 100644 index 0000000000..5b43588af7 --- /dev/null +++ b/.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/.github/workflows/main.yml b/.github/workflows/main.yml new file mode 100644 index 0000000000..eddb805b0b --- /dev/null +++ b/.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/.github/workflows/npm-publish.yml b/.github/workflows/npm-publish.yml new file mode 100644 index 0000000000..b01223f31f --- /dev/null +++ b/.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/.gitignore b/.gitignore new file mode 100644 index 0000000000..857e25ac3d --- /dev/null +++ b/.gitignore @@ -0,0 +1,6 @@ +Cargo.lock +node_modules +build +package-lock.json +/target/ +*.wasm diff --git a/.travis.yml b/.travis.yml new file mode 100644 index 0000000000..8a3a772b3d --- /dev/null +++ b/.travis.yml @@ -0,0 +1,9 @@ +language: node_js + +sudo: false + +node_js: 10 + +branches: + only: + - master diff --git a/Cargo.toml b/Cargo.toml new file mode 100644 index 0000000000..82542e8926 --- /dev/null +++ b/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/LICENSE b/LICENSE new file mode 100644 index 0000000000..bea870efb7 --- /dev/null +++ b/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/Makefile b/Makefile new file mode 100644 index 0000000000..7f47687a35 --- /dev/null +++ b/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/README.md b/README.md new file mode 100644 index 0000000000..e7f453281d --- /dev/null +++ b/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/binding.gyp b/binding.gyp new file mode 100644 index 0000000000..e750f2302f --- /dev/null +++ b/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/bindings/node/index.js b/bindings/node/index.js new file mode 100644 index 0000000000..0a5377e0fd --- /dev/null +++ b/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/bindings/rust/README.md b/bindings/rust/README.md new file mode 100644 index 0000000000..0b1b63d199 --- /dev/null +++ b/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/bindings/rust/build.rs b/bindings/rust/build.rs new file mode 100644 index 0000000000..8b51e55ab0 --- /dev/null +++ b/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/bindings/rust/lib.rs b/bindings/rust/lib.rs new file mode 100644 index 0000000000..49cd54b56f --- /dev/null +++ b/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/grammar.js b/grammar.js new file mode 100644 index 0000000000..c1630b1d27 --- /dev/null +++ b/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/package.json b/package.json new file mode 100644 index 0000000000..6a879dedeb --- /dev/null +++ b/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/queries/folds.scm b/queries/folds.scm new file mode 100644 index 0000000000..2e499c2e22 --- /dev/null +++ b/queries/folds.scm @@ -0,0 +1,7 @@ +[ + (comment) + (list) + (dict_core) +] @fold + +(code (code_body)* @fold) diff --git a/queries/highlights.scm b/queries/highlights.scm new file mode 100644 index 0000000000..3f172ffea4 --- /dev/null +++ b/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/queries/indents.scm b/queries/indents.scm new file mode 100644 index 0000000000..033700c174 --- /dev/null +++ b/queries/indents.scm @@ -0,0 +1,11 @@ +[ + "{" + "}" +] @branch + +[(dict) (key_value)] @indent + + +[ + (comment) +] @ignore diff --git a/queries/injections.scm b/queries/injections.scm new file mode 100644 index 0000000000..08d10721c5 --- /dev/null +++ b/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/queries/locals.scm b/queries/locals.scm new file mode 100644 index 0000000000..2abe743dd3 --- /dev/null +++ b/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/queries/textobjects.scm b/queries/textobjects.scm new file mode 100644 index 0000000000..c5abe52d61 --- /dev/null +++ b/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/queries/textsubjects-container-outer.scm b/queries/textsubjects-container-outer.scm new file mode 100644 index 0000000000..c0e6d27b70 --- /dev/null +++ b/queries/textsubjects-container-outer.scm @@ -0,0 +1,3 @@ +((dict) @_start @_end + (#make-range! "range" @_start @_end) +) diff --git a/queries/textsubjects-smart.scm b/queries/textsubjects-smart.scm new file mode 100644 index 0000000000..f0266b5e46 --- /dev/null +++ b/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/src/grammar.json b/src/grammar.json new file mode 100644 index 0000000000..7669203a6a --- /dev/null +++ b/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/src/node-types.json b/src/node-types.json new file mode 100644 index 0000000000..90eb468929 --- /dev/null +++ b/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/src/scanner.c b/src/scanner.c new file mode 100644 index 0000000000..8d5cfc7945 --- /dev/null +++ b/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/src/tree_sitter/parser.h b/src/tree_sitter/parser.h new file mode 100644 index 0000000000..2b14ac1046 --- /dev/null +++ b/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/syntax-highlighting.png b/syntax-highlighting.png new file mode 100644 index 0000000000000000000000000000000000000000..b19594398499542546828c31bf4e512156faadad GIT binary patch literal 63777 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 ME2$^}{bCgKUs0V1f&c&j literal 0 HcmV?d00001 diff --git a/test/corpus/basic_values.txt b/test/corpus/basic_values.txt new file mode 100644 index 0000000000..808253bb74 --- /dev/null +++ b/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/test/corpus/dictionaries.txt b/test/corpus/dictionaries.txt new file mode 100644 index 0000000000..91be70631e --- /dev/null +++ b/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