mirror of https://github.com/Wilfred/difftastic/
Use tree-sitter-yaml from crates.io
Wilfred Hughes
parent
dda64336e6
commit
dfcb26c7af
@ -1,51 +0,0 @@
|
||||
;; Taken from nvim-treesitter, under Apache license.
|
||||
;; Upstream URL:https://github.com/nvim-treesitter/nvim-treesitter/blob/master/queries/yaml/highlights.scm
|
||||
|
||||
(boolean_scalar) @boolean
|
||||
(null_scalar) @constant.builtin
|
||||
(double_quote_scalar) @string
|
||||
(single_quote_scalar) @string
|
||||
(block_scalar) @string
|
||||
(string_scalar) @string
|
||||
(escape_sequence) @string.escape
|
||||
(integer_scalar) @number
|
||||
(float_scalar) @number
|
||||
(comment) @comment
|
||||
(anchor_name) @type
|
||||
(alias_name) @type
|
||||
(tag) @type
|
||||
(yaml_directive) @keyword
|
||||
(ERROR) @error
|
||||
|
||||
(block_mapping_pair
|
||||
key: (flow_node [(double_quote_scalar) (single_quote_scalar)] @field))
|
||||
(block_mapping_pair
|
||||
key: (flow_node (plain_scalar (string_scalar) @field)))
|
||||
|
||||
(flow_mapping
|
||||
(_ key: (flow_node [(double_quote_scalar) (single_quote_scalar)] @field)))
|
||||
(flow_mapping
|
||||
(_ key: (flow_node (plain_scalar (string_scalar) @field))))
|
||||
|
||||
[
|
||||
","
|
||||
"-"
|
||||
":"
|
||||
">"
|
||||
"?"
|
||||
"|"
|
||||
] @punctuation.delimiter
|
||||
|
||||
[
|
||||
"["
|
||||
"]"
|
||||
"{"
|
||||
"}"
|
||||
] @punctuation.bracket
|
||||
|
||||
[
|
||||
"*"
|
||||
"&"
|
||||
"---"
|
||||
"..."
|
||||
] @punctuation.special
|
||||
@ -1 +0,0 @@
|
||||
tree-sitter-yaml/src
|
||||
@ -1,12 +0,0 @@
|
||||
root = true
|
||||
|
||||
[*]
|
||||
charset = utf-8
|
||||
end_of_line = lf
|
||||
indent_size = 2
|
||||
indent_style = space
|
||||
insert_final_newline = true
|
||||
trim_trailing_whitespace = true
|
||||
|
||||
[corpus/*]
|
||||
trim_trailing_whitespace = false
|
||||
@ -1,7 +0,0 @@
|
||||
* text eol=lf
|
||||
*.wasm binary
|
||||
|
||||
/src/** linguist-generated
|
||||
/src/scanner.cc linguist-generated=false
|
||||
/index.js linguist-generated
|
||||
/binding.gyp linguist-detectable=false
|
||||
@ -1,5 +0,0 @@
|
||||
/build
|
||||
/node_modules
|
||||
|
||||
/bindings/rust
|
||||
/Cargo.toml
|
||||
@ -1,8 +0,0 @@
|
||||
[submodule "tree-sitter"]
|
||||
path = tree-sitter
|
||||
url = https://github.com/ikatyang/tree-sitter
|
||||
branch = v0.19.3-custom
|
||||
[submodule "yaml-test-suite"]
|
||||
path = yaml-test-suite
|
||||
url = https://github.com/yaml/yaml-test-suite
|
||||
branch = data
|
||||
@ -1,13 +0,0 @@
|
||||
language: rust
|
||||
|
||||
rust:
|
||||
- stable
|
||||
|
||||
script:
|
||||
- if [ ! -d "./tree-sitter/target/release" ]; then bash ./scripts/setup-tree-sitter.sh; fi
|
||||
- ./tree-sitter/target/release/tree-sitter test
|
||||
|
||||
cache:
|
||||
cargo: true
|
||||
directories:
|
||||
- ./tree-sitter
|
||||
@ -1,69 +0,0 @@
|
||||
# Changelog
|
||||
|
||||
All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
|
||||
|
||||
# [0.5.0](https://github.com/ikatyang/tree-sitter-yaml/compare/v0.4.1...v0.5.0) (2021-04-18)
|
||||
|
||||
|
||||
### Features
|
||||
|
||||
* expose `anchor_name`, `alias_name`, `&`, and `*` ([#24](https://github.com/ikatyang/tree-sitter-yaml/issues/24)) ([b77b438](https://github.com/ikatyang/tree-sitter-yaml/commit/b77b438))
|
||||
|
||||
|
||||
|
||||
## [0.4.1](https://github.com/ikatyang/tree-sitter-yaml/compare/v0.4.0...v0.4.1) (2021-03-21)
|
||||
|
||||
|
||||
### Bug Fixes
|
||||
|
||||
* add missing binding.gyp ([#21](https://github.com/ikatyang/tree-sitter-yaml/issues/21)) ([5976a87](https://github.com/ikatyang/tree-sitter-yaml/commit/5976a87))
|
||||
|
||||
|
||||
|
||||
# [0.4.0](https://github.com/ikatyang/tree-sitter-yaml/compare/v0.3.1...v0.4.0) (2021-03-14)
|
||||
|
||||
|
||||
### ⚠ BREAKING CHANGES
|
||||
|
||||
* require tree-sitter 0.19+
|
||||
|
||||
|
||||
### Features
|
||||
|
||||
* upgrade to tree-sitter@0.19.3 ([#19](https://github.com/ikatyang/tree-sitter-yaml/issues/19)) ([32689b6](https://github.com/ikatyang/tree-sitter-yaml/commit/32689b6))
|
||||
|
||||
|
||||
|
||||
## [0.3.1](https://github.com/ikatyang/tree-sitter-yaml/compare/v0.3.0...v0.3.1) (2021-01-01)
|
||||
|
||||
|
||||
### Bug Fixes
|
||||
|
||||
* avoid accessing unowned memory ([#17](https://github.com/ikatyang/tree-sitter-yaml/issues/17)) ([45ecb42](https://github.com/ikatyang/tree-sitter-yaml/commit/45ecb42))
|
||||
|
||||
|
||||
|
||||
# [0.3.0](https://github.com/ikatyang/tree-sitter-yaml/compare/v0.2.0...v0.3.0) (2020-10-04)
|
||||
|
||||
|
||||
### Features
|
||||
|
||||
* support core schema ([#13](https://github.com/ikatyang/tree-sitter-yaml/issues/13)) ([6d74a6b](https://github.com/ikatyang/tree-sitter-yaml/commit/6d74a6b))
|
||||
|
||||
|
||||
|
||||
# [0.2.0](https://github.com/ikatyang/tree-sitter-yaml/compare/v0.1.0...v0.2.0) (2020-09-28)
|
||||
|
||||
|
||||
### Features
|
||||
|
||||
* expose literal tokens as anonymous nodes ([#11](https://github.com/ikatyang/tree-sitter-yaml/issues/11)) ([f75b1f9](https://github.com/ikatyang/tree-sitter-yaml/commit/f75b1f9))
|
||||
|
||||
|
||||
|
||||
## 0.1.0 (2019-08-31)
|
||||
|
||||
|
||||
### Features
|
||||
|
||||
* initial implementation ([f45f18f](https://github.com/ikatyang/tree-sitter-yaml/commit/f45f18f))
|
||||
@ -1,21 +0,0 @@
|
||||
The MIT License (MIT)
|
||||
|
||||
Copyright (c) Ika <ikatyang@gmail.com> (https://github.com/ikatyang)
|
||||
|
||||
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.
|
||||
@ -1,53 +0,0 @@
|
||||
# tree-sitter-yaml
|
||||
|
||||
[](https://www.npmjs.com/package/tree-sitter-yaml)
|
||||
[](https://travis-ci.com/ikatyang/tree-sitter-yaml/builds)
|
||||
|
||||
YAML ([YAML Spec v1.2](https://yaml.org/spec/1.2/spec.html)) grammar for [tree-sitter](https://github.com/tree-sitter/tree-sitter)
|
||||
|
||||
[Changelog](https://github.com/ikatyang/tree-sitter-yaml/blob/master/CHANGELOG.md)
|
||||
|
||||
## Install
|
||||
|
||||
```sh
|
||||
npm install tree-sitter-yaml tree-sitter
|
||||
```
|
||||
|
||||
## Usage
|
||||
|
||||
```js
|
||||
const Parser = require("tree-sitter");
|
||||
const YAML = require("tree-sitter-yaml");
|
||||
|
||||
const parser = new Parser();
|
||||
parser.setLanguage(YAML);
|
||||
|
||||
const sourceCode = `
|
||||
!!map
|
||||
hello: &anchor
|
||||
- world
|
||||
`;
|
||||
|
||||
const tree = parser.parse(sourceCode);
|
||||
console.log(tree.rootNode.toString());
|
||||
// (stream
|
||||
// (document
|
||||
// (block_node
|
||||
// (tag)
|
||||
// (block_mapping
|
||||
// (block_mapping_pair
|
||||
// key: (flow_node
|
||||
// (plain_scalar
|
||||
// (string_scalar)))
|
||||
// value: (block_node
|
||||
// (anchor)
|
||||
// (block_sequence
|
||||
// (block_sequence_item
|
||||
// (flow_node
|
||||
// (plain_scalar
|
||||
// (string_scalar)))))))))))
|
||||
```
|
||||
|
||||
## License
|
||||
|
||||
MIT © [Ika](https://github.com/ikatyang)
|
||||
@ -1,19 +0,0 @@
|
||||
{
|
||||
"targets": [
|
||||
{
|
||||
"target_name": "tree_sitter_yaml_binding",
|
||||
"include_dirs": [
|
||||
"<!(node -e \"require('nan')\")",
|
||||
"src"
|
||||
],
|
||||
"sources": [
|
||||
"bindings/node/binding.cc",
|
||||
"src/parser.c",
|
||||
"src/scanner.cc",
|
||||
],
|
||||
"cflags_c": [
|
||||
"-std=c99",
|
||||
]
|
||||
}
|
||||
]
|
||||
}
|
||||
@ -1,28 +0,0 @@
|
||||
#include "tree_sitter/parser.h"
|
||||
#include <node.h>
|
||||
#include "nan.h"
|
||||
|
||||
using namespace v8;
|
||||
|
||||
extern "C" TSLanguage * tree_sitter_yaml();
|
||||
|
||||
namespace {
|
||||
|
||||
NAN_METHOD(New) {}
|
||||
|
||||
void Init(Local<Object> exports, Local<Object> module) {
|
||||
Local<FunctionTemplate> tpl = Nan::New<FunctionTemplate>(New);
|
||||
tpl->SetClassName(Nan::New("Language").ToLocalChecked());
|
||||
tpl->InstanceTemplate()->SetInternalFieldCount(1);
|
||||
|
||||
Local<Function> constructor = Nan::GetFunction(tpl).ToLocalChecked();
|
||||
Local<Object> instance = constructor->NewInstance(Nan::GetCurrentContext()).ToLocalChecked();
|
||||
Nan::SetInternalFieldPointer(instance, 0, tree_sitter_yaml());
|
||||
|
||||
Nan::Set(instance, Nan::New("name").ToLocalChecked(), Nan::New("yaml").ToLocalChecked());
|
||||
Nan::Set(module, Nan::New("exports").ToLocalChecked(), instance);
|
||||
}
|
||||
|
||||
NODE_MODULE(tree_sitter_yaml_binding, Init)
|
||||
|
||||
} // namespace
|
||||
@ -1,19 +0,0 @@
|
||||
try {
|
||||
module.exports = require("../../build/Release/tree_sitter_yaml_binding");
|
||||
} catch (error1) {
|
||||
if (error1.code !== 'MODULE_NOT_FOUND') {
|
||||
throw error1;
|
||||
}
|
||||
try {
|
||||
module.exports = require("../../build/Debug/tree_sitter_yaml_binding");
|
||||
} catch (error2) {
|
||||
if (error2.code !== 'MODULE_NOT_FOUND') {
|
||||
throw error2;
|
||||
}
|
||||
throw error1
|
||||
}
|
||||
}
|
||||
|
||||
try {
|
||||
module.exports.nodeTypeInfo = require("../../src/node-types.json");
|
||||
} catch (_) {}
|
||||
@ -1,354 +0,0 @@
|
||||
================================================================================
|
||||
Example 10.4. !!null Examples
|
||||
================================================================================
|
||||
!!null null: value for null key
|
||||
key with null value: !!null null
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
|
||||
(stream
|
||||
(document
|
||||
(block_node
|
||||
(block_mapping
|
||||
(block_mapping_pair
|
||||
key: (flow_node
|
||||
(tag)
|
||||
(plain_scalar
|
||||
(null_scalar)))
|
||||
value: (flow_node
|
||||
(plain_scalar
|
||||
(string_scalar))))
|
||||
(block_mapping_pair
|
||||
key: (flow_node
|
||||
(plain_scalar
|
||||
(string_scalar)))
|
||||
value: (flow_node
|
||||
(tag)
|
||||
(plain_scalar
|
||||
(null_scalar))))))))
|
||||
|
||||
================================================================================
|
||||
Example 10.5. !!bool Examples
|
||||
================================================================================
|
||||
YAML is a superset of JSON: !!bool true
|
||||
Pluto is a planet: !!bool false
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
|
||||
(stream
|
||||
(document
|
||||
(block_node
|
||||
(block_mapping
|
||||
(block_mapping_pair
|
||||
key: (flow_node
|
||||
(plain_scalar
|
||||
(string_scalar)))
|
||||
value: (flow_node
|
||||
(tag)
|
||||
(plain_scalar
|
||||
(boolean_scalar))))
|
||||
(block_mapping_pair
|
||||
key: (flow_node
|
||||
(plain_scalar
|
||||
(string_scalar)))
|
||||
value: (flow_node
|
||||
(tag)
|
||||
(plain_scalar
|
||||
(boolean_scalar))))))))
|
||||
|
||||
================================================================================
|
||||
Example 10.6. !!int Examples
|
||||
================================================================================
|
||||
negative: !!int -12
|
||||
zero: !!int 0
|
||||
positive: !!int 34
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
|
||||
(stream
|
||||
(document
|
||||
(block_node
|
||||
(block_mapping
|
||||
(block_mapping_pair
|
||||
key: (flow_node
|
||||
(plain_scalar
|
||||
(string_scalar)))
|
||||
value: (flow_node
|
||||
(tag)
|
||||
(plain_scalar
|
||||
(integer_scalar))))
|
||||
(block_mapping_pair
|
||||
key: (flow_node
|
||||
(plain_scalar
|
||||
(string_scalar)))
|
||||
value: (flow_node
|
||||
(tag)
|
||||
(plain_scalar
|
||||
(integer_scalar))))
|
||||
(block_mapping_pair
|
||||
key: (flow_node
|
||||
(plain_scalar
|
||||
(string_scalar)))
|
||||
value: (flow_node
|
||||
(tag)
|
||||
(plain_scalar
|
||||
(integer_scalar))))))))
|
||||
|
||||
================================================================================
|
||||
Example 10.7. !!float Examples
|
||||
================================================================================
|
||||
negative: !!float -1
|
||||
zero: !!float 0
|
||||
positive: !!float 2.3e4
|
||||
infinity: !!float .inf
|
||||
not a number: !!float .nan
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
|
||||
(stream
|
||||
(document
|
||||
(block_node
|
||||
(block_mapping
|
||||
(block_mapping_pair
|
||||
key: (flow_node
|
||||
(plain_scalar
|
||||
(string_scalar)))
|
||||
value: (flow_node
|
||||
(tag)
|
||||
(plain_scalar
|
||||
(integer_scalar))))
|
||||
(block_mapping_pair
|
||||
key: (flow_node
|
||||
(plain_scalar
|
||||
(string_scalar)))
|
||||
value: (flow_node
|
||||
(tag)
|
||||
(plain_scalar
|
||||
(integer_scalar))))
|
||||
(block_mapping_pair
|
||||
key: (flow_node
|
||||
(plain_scalar
|
||||
(string_scalar)))
|
||||
value: (flow_node
|
||||
(tag)
|
||||
(plain_scalar
|
||||
(float_scalar))))
|
||||
(block_mapping_pair
|
||||
key: (flow_node
|
||||
(plain_scalar
|
||||
(string_scalar)))
|
||||
value: (flow_node
|
||||
(tag)
|
||||
(plain_scalar
|
||||
(float_scalar))))
|
||||
(block_mapping_pair
|
||||
key: (flow_node
|
||||
(plain_scalar
|
||||
(string_scalar)))
|
||||
value: (flow_node
|
||||
(tag)
|
||||
(plain_scalar
|
||||
(float_scalar))))))))
|
||||
|
||||
================================================================================
|
||||
Example 10.8. JSON Tag Resolution
|
||||
================================================================================
|
||||
A null: null
|
||||
Booleans: [ true, false ]
|
||||
Integers: [ 0, -0, 3, -19 ]
|
||||
Floats: [ 0., -0.0, 12e03, -2E+05 ]
|
||||
Invalid: [ True, Null, 0o7, 0x3A, +12.3 ]
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
|
||||
(stream
|
||||
(document
|
||||
(block_node
|
||||
(block_mapping
|
||||
(block_mapping_pair
|
||||
key: (flow_node
|
||||
(plain_scalar
|
||||
(string_scalar)))
|
||||
value: (flow_node
|
||||
(plain_scalar
|
||||
(null_scalar))))
|
||||
(block_mapping_pair
|
||||
key: (flow_node
|
||||
(plain_scalar
|
||||
(string_scalar)))
|
||||
value: (flow_node
|
||||
(flow_sequence
|
||||
(flow_node
|
||||
(plain_scalar
|
||||
(boolean_scalar)))
|
||||
(flow_node
|
||||
(plain_scalar
|
||||
(boolean_scalar))))))
|
||||
(block_mapping_pair
|
||||
key: (flow_node
|
||||
(plain_scalar
|
||||
(string_scalar)))
|
||||
value: (flow_node
|
||||
(flow_sequence
|
||||
(flow_node
|
||||
(plain_scalar
|
||||
(integer_scalar)))
|
||||
(flow_node
|
||||
(plain_scalar
|
||||
(integer_scalar)))
|
||||
(flow_node
|
||||
(plain_scalar
|
||||
(integer_scalar)))
|
||||
(flow_node
|
||||
(plain_scalar
|
||||
(integer_scalar))))))
|
||||
(block_mapping_pair
|
||||
key: (flow_node
|
||||
(plain_scalar
|
||||
(string_scalar)))
|
||||
value: (flow_node
|
||||
(flow_sequence
|
||||
(flow_node
|
||||
(plain_scalar
|
||||
(float_scalar)))
|
||||
(flow_node
|
||||
(plain_scalar
|
||||
(float_scalar)))
|
||||
(flow_node
|
||||
(plain_scalar
|
||||
(float_scalar)))
|
||||
(flow_node
|
||||
(plain_scalar
|
||||
(float_scalar))))))
|
||||
(block_mapping_pair
|
||||
key: (flow_node
|
||||
(plain_scalar
|
||||
(string_scalar)))
|
||||
value: (flow_node
|
||||
(flow_sequence
|
||||
(flow_node
|
||||
(plain_scalar
|
||||
(boolean_scalar)))
|
||||
(flow_node
|
||||
(plain_scalar
|
||||
(null_scalar)))
|
||||
(flow_node
|
||||
(plain_scalar
|
||||
(integer_scalar)))
|
||||
(flow_node
|
||||
(plain_scalar
|
||||
(integer_scalar)))
|
||||
(flow_node
|
||||
(plain_scalar
|
||||
(float_scalar))))))))))
|
||||
|
||||
================================================================================
|
||||
Example 10.9. Core Tag Resolution
|
||||
================================================================================
|
||||
A null: null
|
||||
Also a null: # Empty
|
||||
Not a null: ""
|
||||
Booleans: [ true, True, false, FALSE ]
|
||||
Integers: [ 0, 0o7, 0x3A, -19 ]
|
||||
Floats: [ 0., -0.0, .5, +12e03, -2E+05 ]
|
||||
Also floats: [ .inf, -.Inf, +.INF, .NAN ]
|
||||
|
||||
--------------------------------------------------------------------------------
|
||||
|
||||
(stream
|
||||
(document
|
||||
(block_node
|
||||
(block_mapping
|
||||
(block_mapping_pair
|
||||
key: (flow_node
|
||||
(plain_scalar
|
||||
(string_scalar)))
|
||||
value: (flow_node
|
||||
(plain_scalar
|
||||
(null_scalar))))
|
||||
(block_mapping_pair
|
||||
key: (flow_node
|
||||
(plain_scalar
|
||||
(string_scalar))))
|
||||
(comment)
|
||||
(block_mapping_pair
|
||||
key: (flow_node
|
||||
(plain_scalar
|
||||
(string_scalar)))
|
||||
value: (flow_node
|
||||
(double_quote_scalar)))
|
||||
(block_mapping_pair
|
||||
key: (flow_node
|
||||
(plain_scalar
|
||||
(string_scalar)))
|
||||
value: (flow_node
|
||||
(flow_sequence
|
||||
(flow_node
|
||||
(plain_scalar
|
||||
(boolean_scalar)))
|
||||
(flow_node
|
||||
(plain_scalar
|
||||
(boolean_scalar)))
|
||||
(flow_node
|
||||
(plain_scalar
|
||||
(boolean_scalar)))
|
||||
(flow_node
|
||||
(plain_scalar
|
||||
(boolean_scalar))))))
|
||||
(block_mapping_pair
|
||||
key: (flow_node
|
||||
(plain_scalar
|
||||
(string_scalar)))
|
||||
value: (flow_node
|
||||
(flow_sequence
|
||||
(flow_node
|
||||
(plain_scalar
|
||||
(integer_scalar)))
|
||||
(flow_node
|
||||
(plain_scalar
|
||||
(integer_scalar)))
|
||||
(flow_node
|
||||
(plain_scalar
|
||||
(integer_scalar)))
|
||||
(flow_node
|
||||
(plain_scalar
|
||||
(integer_scalar))))))
|
||||
(block_mapping_pair
|
||||
key: (flow_node
|
||||
(plain_scalar
|
||||
(string_scalar)))
|
||||
value: (flow_node
|
||||
(flow_sequence
|
||||
(flow_node
|
||||
(plain_scalar
|
||||
(float_scalar)))
|
||||
(flow_node
|
||||
(plain_scalar
|
||||
(float_scalar)))
|
||||
(flow_node
|
||||
(plain_scalar
|
||||
(float_scalar)))
|
||||
(flow_node
|
||||
(plain_scalar
|
||||
(float_scalar)))
|
||||
(flow_node
|
||||
(plain_scalar
|
||||
(float_scalar))))))
|
||||
(block_mapping_pair
|
||||
key: (flow_node
|
||||
(plain_scalar
|
||||
(string_scalar)))
|
||||
value: (flow_node
|
||||
(flow_sequence
|
||||
(flow_node
|
||||
(plain_scalar
|
||||
(float_scalar)))
|
||||
(flow_node
|
||||
(plain_scalar
|
||||
(float_scalar)))
|
||||
(flow_node
|
||||
(plain_scalar
|
||||
(float_scalar)))
|
||||
(flow_node
|
||||
(plain_scalar
|
||||
(float_scalar))))))))))
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,21 +0,0 @@
|
||||
The MIT License (MIT)
|
||||
|
||||
Copyright (c) 2018 Max Brunsfeld
|
||||
|
||||
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.
|
||||
@ -1,469 +0,0 @@
|
||||
let tree;
|
||||
|
||||
(async () => {
|
||||
const CAPTURE_REGEX = /@\s*([\w\._-]+)/g;
|
||||
const COLORS_BY_INDEX = [
|
||||
'blue',
|
||||
'chocolate',
|
||||
'darkblue',
|
||||
'darkcyan',
|
||||
'darkgreen',
|
||||
'darkred',
|
||||
'darkslategray',
|
||||
'dimgray',
|
||||
'green',
|
||||
'indigo',
|
||||
'navy',
|
||||
'red',
|
||||
'sienna',
|
||||
];
|
||||
|
||||
const scriptURL = document.currentScript.getAttribute('src');
|
||||
|
||||
const codeInput = document.getElementById('code-input');
|
||||
const languageSelect = document.getElementById('language-select');
|
||||
const loggingCheckbox = document.getElementById('logging-checkbox');
|
||||
const outputContainer = document.getElementById('output-container');
|
||||
const outputContainerScroll = document.getElementById('output-container-scroll');
|
||||
const playgroundContainer = document.getElementById('playground-container');
|
||||
const queryCheckbox = document.getElementById('query-checkbox');
|
||||
const queryContainer = document.getElementById('query-container');
|
||||
const queryInput = document.getElementById('query-input');
|
||||
const updateTimeSpan = document.getElementById('update-time');
|
||||
const languagesByName = {};
|
||||
|
||||
loadState();
|
||||
|
||||
await TreeSitter.init();
|
||||
|
||||
const parser = new TreeSitter();
|
||||
const codeEditor = CodeMirror.fromTextArea(codeInput, {
|
||||
lineNumbers: true,
|
||||
showCursorWhenSelecting: true
|
||||
});
|
||||
|
||||
const queryEditor = CodeMirror.fromTextArea(queryInput, {
|
||||
lineNumbers: true,
|
||||
showCursorWhenSelecting: true
|
||||
});
|
||||
|
||||
const cluster = new Clusterize({
|
||||
rows: [],
|
||||
noDataText: null,
|
||||
contentElem: outputContainer,
|
||||
scrollElem: outputContainerScroll
|
||||
});
|
||||
const renderTreeOnCodeChange = debounce(renderTree, 50);
|
||||
const saveStateOnChange = debounce(saveState, 2000);
|
||||
const runTreeQueryOnChange = debounce(runTreeQuery, 50);
|
||||
|
||||
let languageName = languageSelect.value;
|
||||
let treeRows = null;
|
||||
let treeRowHighlightedIndex = -1;
|
||||
let parseCount = 0;
|
||||
let isRendering = 0;
|
||||
let query;
|
||||
|
||||
codeEditor.on('changes', handleCodeChange);
|
||||
codeEditor.on('viewportChange', runTreeQueryOnChange);
|
||||
codeEditor.on('cursorActivity', debounce(handleCursorMovement, 150));
|
||||
queryEditor.on('changes', debounce(handleQueryChange, 150));
|
||||
|
||||
loggingCheckbox.addEventListener('change', handleLoggingChange);
|
||||
queryCheckbox.addEventListener('change', handleQueryEnableChange);
|
||||
languageSelect.addEventListener('change', handleLanguageChange);
|
||||
outputContainer.addEventListener('click', handleTreeClick);
|
||||
|
||||
handleQueryEnableChange();
|
||||
await handleLanguageChange()
|
||||
|
||||
playgroundContainer.style.visibility = 'visible';
|
||||
|
||||
async function handleLanguageChange() {
|
||||
const newLanguageName = languageSelect.value;
|
||||
if (!languagesByName[newLanguageName]) {
|
||||
const url = `${LANGUAGE_BASE_URL}/tree-sitter-${newLanguageName}.wasm`
|
||||
languageSelect.disabled = true;
|
||||
try {
|
||||
languagesByName[newLanguageName] = await TreeSitter.Language.load(url);
|
||||
} catch (e) {
|
||||
console.error(e);
|
||||
languageSelect.value = languageName;
|
||||
return
|
||||
} finally {
|
||||
languageSelect.disabled = false;
|
||||
}
|
||||
}
|
||||
|
||||
tree = null;
|
||||
languageName = newLanguageName;
|
||||
parser.setLanguage(languagesByName[newLanguageName]);
|
||||
handleCodeChange();
|
||||
handleQueryChange();
|
||||
}
|
||||
|
||||
async function handleCodeChange(editor, changes) {
|
||||
const newText = codeEditor.getValue();
|
||||
const edits = tree && changes && changes.map(treeEditForEditorChange);
|
||||
|
||||
const start = performance.now();
|
||||
if (edits) {
|
||||
for (const edit of edits) {
|
||||
tree.edit(edit);
|
||||
}
|
||||
}
|
||||
const newTree = parser.parse(newText, tree);
|
||||
const duration = (performance.now() - start).toFixed(1);
|
||||
|
||||
updateTimeSpan.innerText = `${duration} ms`;
|
||||
if (tree) tree.delete();
|
||||
tree = newTree;
|
||||
parseCount++;
|
||||
renderTreeOnCodeChange();
|
||||
runTreeQueryOnChange();
|
||||
saveStateOnChange();
|
||||
}
|
||||
|
||||
async function renderTree() {
|
||||
isRendering++;
|
||||
const cursor = tree.walk();
|
||||
|
||||
let currentRenderCount = parseCount;
|
||||
let row = '';
|
||||
let rows = [];
|
||||
let finishedRow = false;
|
||||
let visitedChildren = false;
|
||||
let indentLevel = 0;
|
||||
|
||||
for (let i = 0;; i++) {
|
||||
if (i > 0 && i % 10000 === 0) {
|
||||
await new Promise(r => setTimeout(r, 0));
|
||||
if (parseCount !== currentRenderCount) {
|
||||
cursor.delete();
|
||||
isRendering--;
|
||||
return;
|
||||
}
|
||||
}
|
||||
|
||||
let displayName;
|
||||
if (cursor.nodeIsMissing) {
|
||||
displayName = `MISSING ${cursor.nodeType}`
|
||||
} else if (cursor.nodeIsNamed) {
|
||||
displayName = cursor.nodeType;
|
||||
}
|
||||
|
||||
if (visitedChildren) {
|
||||
if (displayName) {
|
||||
finishedRow = true;
|
||||
}
|
||||
|
||||
if (cursor.gotoNextSibling()) {
|
||||
visitedChildren = false;
|
||||
} else if (cursor.gotoParent()) {
|
||||
visitedChildren = true;
|
||||
indentLevel--;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
if (displayName) {
|
||||
if (finishedRow) {
|
||||
row += '</div>';
|
||||
rows.push(row);
|
||||
finishedRow = false;
|
||||
}
|
||||
const start = cursor.startPosition;
|
||||
const end = cursor.endPosition;
|
||||
const id = cursor.nodeId;
|
||||
let fieldName = cursor.currentFieldName();
|
||||
if (fieldName) {
|
||||
fieldName += ': ';
|
||||
} else {
|
||||
fieldName = '';
|
||||
}
|
||||
row = `<div>${' '.repeat(indentLevel)}${fieldName}<a class='plain' href="#" data-id=${id} data-range="${start.row},${start.column},${end.row},${end.column}">${displayName}</a> [${start.row}, ${start.column}] - [${end.row}, ${end.column}])`;
|
||||
finishedRow = true;
|
||||
}
|
||||
|
||||
if (cursor.gotoFirstChild()) {
|
||||
visitedChildren = false;
|
||||
indentLevel++;
|
||||
} else {
|
||||
visitedChildren = true;
|
||||
}
|
||||
}
|
||||
}
|
||||
if (finishedRow) {
|
||||
row += '</div>';
|
||||
rows.push(row);
|
||||
}
|
||||
|
||||
cursor.delete();
|
||||
cluster.update(rows);
|
||||
treeRows = rows;
|
||||
isRendering--;
|
||||
handleCursorMovement();
|
||||
}
|
||||
|
||||
function runTreeQuery(_, startRow, endRow) {
|
||||
if (endRow == null) {
|
||||
const viewport = codeEditor.getViewport();
|
||||
startRow = viewport.from;
|
||||
endRow = viewport.to;
|
||||
}
|
||||
|
||||
codeEditor.operation(() => {
|
||||
const marks = codeEditor.getAllMarks();
|
||||
marks.forEach(m => m.clear());
|
||||
|
||||
if (tree && query) {
|
||||
const captures = query.captures(
|
||||
tree.rootNode,
|
||||
{row: startRow, column: 0},
|
||||
{row: endRow, column: 0},
|
||||
);
|
||||
let lastNodeId;
|
||||
for (const {name, node} of captures) {
|
||||
if (node.id === lastNodeId) continue;
|
||||
lastNodeId = node.id;
|
||||
const {startPosition, endPosition} = node;
|
||||
codeEditor.markText(
|
||||
{line: startPosition.row, ch: startPosition.column},
|
||||
{line: endPosition.row, ch: endPosition.column},
|
||||
{
|
||||
inclusiveLeft: true,
|
||||
inclusiveRight: true,
|
||||
css: `color: ${colorForCaptureName(name)}`
|
||||
}
|
||||
);
|
||||
}
|
||||
}
|
||||
});
|
||||
}
|
||||
|
||||
function handleQueryChange() {
|
||||
if (query) {
|
||||
query.delete();
|
||||
query.deleted = true;
|
||||
query = null;
|
||||
}
|
||||
|
||||
queryEditor.operation(() => {
|
||||
queryEditor.getAllMarks().forEach(m => m.clear());
|
||||
if (!queryCheckbox.checked) return;
|
||||
|
||||
const queryText = queryEditor.getValue();
|
||||
|
||||
try {
|
||||
query = parser.getLanguage().query(queryText);
|
||||
let match;
|
||||
|
||||
let row = 0;
|
||||
queryEditor.eachLine((line) => {
|
||||
while (match = CAPTURE_REGEX.exec(line.text)) {
|
||||
queryEditor.markText(
|
||||
{line: row, ch: match.index},
|
||||
{line: row, ch: match.index + match[0].length},
|
||||
{
|
||||
inclusiveLeft: true,
|
||||
inclusiveRight: true,
|
||||
css: `color: ${colorForCaptureName(match[1])}`
|
||||
}
|
||||
);
|
||||
}
|
||||
row++;
|
||||
});
|
||||
} catch (error) {
|
||||
const startPosition = queryEditor.posFromIndex(error.index);
|
||||
const endPosition = {
|
||||
line: startPosition.line,
|
||||
ch: startPosition.ch + (error.length || Infinity)
|
||||
};
|
||||
|
||||
if (error.index === queryText.length) {
|
||||
if (startPosition.ch > 0) {
|
||||
startPosition.ch--;
|
||||
} else if (startPosition.row > 0) {
|
||||
startPosition.row--;
|
||||
startPosition.column = Infinity;
|
||||
}
|
||||
}
|
||||
|
||||
queryEditor.markText(
|
||||
startPosition,
|
||||
endPosition,
|
||||
{
|
||||
className: 'query-error',
|
||||
inclusiveLeft: true,
|
||||
inclusiveRight: true,
|
||||
attributes: {title: error.message}
|
||||
}
|
||||
);
|
||||
}
|
||||
});
|
||||
|
||||
runTreeQuery();
|
||||
saveQueryState();
|
||||
}
|
||||
|
||||
function handleCursorMovement() {
|
||||
if (isRendering) return;
|
||||
|
||||
const selection = codeEditor.getDoc().listSelections()[0];
|
||||
let start = {row: selection.anchor.line, column: selection.anchor.ch};
|
||||
let end = {row: selection.head.line, column: selection.head.ch};
|
||||
if (
|
||||
start.row > end.row ||
|
||||
(
|
||||
start.row === end.row &&
|
||||
start.column > end.column
|
||||
)
|
||||
) {
|
||||
let swap = end;
|
||||
end = start;
|
||||
start = swap;
|
||||
}
|
||||
const node = tree.rootNode.namedDescendantForPosition(start, end);
|
||||
if (treeRows) {
|
||||
if (treeRowHighlightedIndex !== -1) {
|
||||
const row = treeRows[treeRowHighlightedIndex];
|
||||
if (row) treeRows[treeRowHighlightedIndex] = row.replace('highlighted', 'plain');
|
||||
}
|
||||
treeRowHighlightedIndex = treeRows.findIndex(row => row.includes(`data-id=${node.id}`));
|
||||
if (treeRowHighlightedIndex !== -1) {
|
||||
const row = treeRows[treeRowHighlightedIndex];
|
||||
if (row) treeRows[treeRowHighlightedIndex] = row.replace('plain', 'highlighted');
|
||||
}
|
||||
cluster.update(treeRows);
|
||||
const lineHeight = cluster.options.item_height;
|
||||
const scrollTop = outputContainerScroll.scrollTop;
|
||||
const containerHeight = outputContainerScroll.clientHeight;
|
||||
const offset = treeRowHighlightedIndex * lineHeight;
|
||||
if (scrollTop > offset - 20) {
|
||||
$(outputContainerScroll).animate({scrollTop: offset - 20}, 150);
|
||||
} else if (scrollTop < offset + lineHeight + 40 - containerHeight) {
|
||||
$(outputContainerScroll).animate({scrollTop: offset - containerHeight + 40}, 150);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
function handleTreeClick(event) {
|
||||
if (event.target.tagName === 'A') {
|
||||
event.preventDefault();
|
||||
const [startRow, startColumn, endRow, endColumn] = event
|
||||
.target
|
||||
.dataset
|
||||
.range
|
||||
.split(',')
|
||||
.map(n => parseInt(n));
|
||||
codeEditor.focus();
|
||||
codeEditor.setSelection(
|
||||
{line: startRow, ch: startColumn},
|
||||
{line: endRow, ch: endColumn}
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
function handleLoggingChange() {
|
||||
if (loggingCheckbox.checked) {
|
||||
parser.setLogger((message, lexing) => {
|
||||
if (lexing) {
|
||||
console.log(" ", message)
|
||||
} else {
|
||||
console.log(message)
|
||||
}
|
||||
});
|
||||
} else {
|
||||
parser.setLogger(null);
|
||||
}
|
||||
}
|
||||
|
||||
function handleQueryEnableChange() {
|
||||
if (queryCheckbox.checked) {
|
||||
queryContainer.style.visibility = '';
|
||||
queryContainer.style.position = '';
|
||||
} else {
|
||||
queryContainer.style.visibility = 'hidden';
|
||||
queryContainer.style.position = 'absolute';
|
||||
}
|
||||
handleQueryChange();
|
||||
}
|
||||
|
||||
function treeEditForEditorChange(change) {
|
||||
const oldLineCount = change.removed.length;
|
||||
const newLineCount = change.text.length;
|
||||
const lastLineLength = change.text[newLineCount - 1].length;
|
||||
|
||||
const startPosition = {row: change.from.line, column: change.from.ch};
|
||||
const oldEndPosition = {row: change.to.line, column: change.to.ch};
|
||||
const newEndPosition = {
|
||||
row: startPosition.row + newLineCount - 1,
|
||||
column: newLineCount === 1
|
||||
? startPosition.column + lastLineLength
|
||||
: lastLineLength
|
||||
};
|
||||
|
||||
const startIndex = codeEditor.indexFromPos(change.from);
|
||||
let newEndIndex = startIndex + newLineCount - 1;
|
||||
let oldEndIndex = startIndex + oldLineCount - 1;
|
||||
for (let i = 0; i < newLineCount; i++) newEndIndex += change.text[i].length;
|
||||
for (let i = 0; i < oldLineCount; i++) oldEndIndex += change.removed[i].length;
|
||||
|
||||
return {
|
||||
startIndex, oldEndIndex, newEndIndex,
|
||||
startPosition, oldEndPosition, newEndPosition
|
||||
};
|
||||
}
|
||||
|
||||
function colorForCaptureName(capture) {
|
||||
const id = query.captureNames.indexOf(capture);
|
||||
return COLORS_BY_INDEX[id % COLORS_BY_INDEX.length];
|
||||
}
|
||||
|
||||
function getLocalStorageItem(key) {
|
||||
return localStorage.getItem(`${document.title}:${key}`);
|
||||
}
|
||||
|
||||
function setLocalStorageItem(key, value) {
|
||||
localStorage.setItem(`${document.title}:${key}`, value);
|
||||
}
|
||||
|
||||
function loadState() {
|
||||
const language = getLocalStorageItem("language");
|
||||
const sourceCode = getLocalStorageItem("sourceCode");
|
||||
const query = getLocalStorageItem("query");
|
||||
const queryEnabled = getLocalStorageItem("queryEnabled");
|
||||
if (language != null && sourceCode != null && query != null) {
|
||||
queryInput.value = query;
|
||||
codeInput.value = sourceCode;
|
||||
languageSelect.value = language;
|
||||
queryCheckbox.checked = (queryEnabled === 'true');
|
||||
}
|
||||
}
|
||||
|
||||
function saveState() {
|
||||
setLocalStorageItem("language", languageSelect.value);
|
||||
setLocalStorageItem("sourceCode", codeEditor.getValue());
|
||||
saveQueryState();
|
||||
}
|
||||
|
||||
function saveQueryState() {
|
||||
setLocalStorageItem("queryEnabled", queryCheckbox.checked);
|
||||
setLocalStorageItem("query", queryEditor.getValue());
|
||||
}
|
||||
|
||||
function debounce(func, wait, immediate) {
|
||||
var timeout;
|
||||
return function() {
|
||||
var context = this, args = arguments;
|
||||
var later = function() {
|
||||
timeout = null;
|
||||
if (!immediate) func.apply(context, args);
|
||||
};
|
||||
var callNow = immediate && !timeout;
|
||||
clearTimeout(timeout);
|
||||
timeout = setTimeout(later, wait);
|
||||
if (callNow) func.apply(context, args);
|
||||
};
|
||||
}
|
||||
})();
|
||||
File diff suppressed because one or more lines are too long
Binary file not shown.
@ -1,21 +0,0 @@
|
||||
The MIT License (MIT)
|
||||
|
||||
Copyright (c) 2018 Max Brunsfeld
|
||||
|
||||
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.
|
||||
File diff suppressed because one or more lines are too long
Binary file not shown.
@ -1,124 +0,0 @@
|
||||
<!DOCTYPE html>
|
||||
<html>
|
||||
|
||||
<head>
|
||||
<meta http-equiv="Content-Type" content="text/html;charset=utf-8" />
|
||||
<meta name="viewport" content="width=device-width, initial-scale=1.0, maximum-scale=1.0, user-scalable=no">
|
||||
<link rel="stylesheet" href="assets/tree-sitter-playground-0.19.3/style.css" media="screen" type="text/css">
|
||||
<title>Tree-sitter YAML Playground</title>
|
||||
</head>
|
||||
|
||||
<body>
|
||||
<div id="container">
|
||||
<main id="main-content">
|
||||
<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/codemirror/5.45.0/codemirror.min.css">
|
||||
<link rel="stylesheet" href="https://cdnjs.cloudflare.com/ajax/libs/clusterize.js/0.18.0/clusterize.min.css">
|
||||
<style>
|
||||
.version {
|
||||
font-size: 0.5em;
|
||||
}
|
||||
.credit {
|
||||
font-style: italic;
|
||||
margin-top: 20px;
|
||||
text-align: center;
|
||||
}
|
||||
</style>
|
||||
|
||||
<h1><a href="https://github.com/ikatyang/tree-sitter-yaml">Tree-sitter YAML</a> <span class="version">v0.5.0</span></h1>
|
||||
|
||||
<div id="playground-container" style="visibility: hidden;">
|
||||
|
||||
<h4>Code</h4>
|
||||
<select id="language-select">
|
||||
<option value="yaml" selected="selected">YAML</option>
|
||||
</select>
|
||||
|
||||
<input id="logging-checkbox" type="checkbox"></input>
|
||||
<label for="logging-checkbox">Log</label>
|
||||
|
||||
<input id="query-checkbox" type="checkbox"></input>
|
||||
<label for="query-checkbox">Query</label>
|
||||
|
||||
<textarea id="code-input">
|
||||
</textarea>
|
||||
|
||||
<div id="query-container" style="visibility: hidden; position: absolute;">
|
||||
<h4>Query</h4>
|
||||
<textarea id="query-input"></textarea>
|
||||
</div>
|
||||
|
||||
<h4>Tree</h4>
|
||||
<span id="update-time"></span>
|
||||
<div id="output-container-scroll">
|
||||
<pre id="output-container" class="highlight"></pre>
|
||||
</div>
|
||||
|
||||
</div>
|
||||
|
||||
<div class="credit">
|
||||
This playground was modified from <a href="https://tree-sitter.github.io/tree-sitter/playground">the official Tree-sitter Playground</a>.
|
||||
</div>
|
||||
|
||||
<script src="https://cdnjs.cloudflare.com/ajax/libs/codemirror/5.45.0/codemirror.min.js"></script>
|
||||
|
||||
<script>LANGUAGE_BASE_URL = "assets/tree-sitter-yaml-0.5.0";</script>
|
||||
<script src="assets/web-tree-sitter-0.19.3/tree-sitter.js"></script>
|
||||
|
||||
<script src="https://cdnjs.cloudflare.com/ajax/libs/clusterize.js/0.18.0/clusterize.min.js"></script>
|
||||
<script src="assets/tree-sitter-playground-0.19.3/playground.js"></script>
|
||||
|
||||
<script>
|
||||
((codeExample, queryExample) => {
|
||||
const handle = setInterval(() => {
|
||||
const $codeEditor = document.querySelector('.CodeMirror');
|
||||
const $queryEditor = document.querySelector('#query-container .CodeMirror');
|
||||
const $queryCheckbox = document.querySelector('#query-checkbox');
|
||||
if ($codeEditor && $queryEditor) {
|
||||
$codeEditor.CodeMirror.setValue(codeExample);
|
||||
if (queryExample) {
|
||||
$queryEditor.CodeMirror.setValue(queryExample);
|
||||
if (!$queryCheckbox.checked) $queryCheckbox.click();
|
||||
}
|
||||
clearInterval(handle);
|
||||
}
|
||||
}, 500);
|
||||
})(`---
|
||||
invoice: 34843
|
||||
date : 2001-01-23
|
||||
bill-to: &id001
|
||||
given : Chris
|
||||
family : Dumars
|
||||
address:
|
||||
lines: |
|
||||
458 Walkman Dr.
|
||||
Suite #292
|
||||
city : Royal Oak
|
||||
state : MI
|
||||
postal : 48046
|
||||
ship-to: *id001
|
||||
product:
|
||||
- sku : BL394D
|
||||
quantity : 4
|
||||
description : Basketball
|
||||
price : 450.00
|
||||
- sku : BL4438H
|
||||
quantity : 1
|
||||
description : Super Hoop
|
||||
price : 2392.00
|
||||
tax : 251.42
|
||||
total: 4443.52
|
||||
comments: >
|
||||
Late afternoon is best.
|
||||
Backup contact is Nancy
|
||||
Billsmer @ 338-4338.`, ``);
|
||||
</script>
|
||||
|
||||
</main>
|
||||
</div>
|
||||
</body>
|
||||
</html>
|
||||
|
||||
<script
|
||||
src="https://code.jquery.com/jquery-3.3.1.min.js"
|
||||
crossorigin="anonymous">
|
||||
</script>
|
||||
@ -1,25 +0,0 @@
|
||||
// Ref: https://yaml.org/spec/1.2/spec.html#schema/core/
|
||||
|
||||
module.exports = grammar({
|
||||
name: "schema",
|
||||
extras: $ => [],
|
||||
rules: {
|
||||
pln: $ => choice($.nul, $.bol, $.int, $.flt),
|
||||
nul: $ => /~|null|Null|NULL/,
|
||||
bol: $ => /true|True|TRUE|false|False|FALSE/,
|
||||
int: $ => or([
|
||||
/[-+]?[0-9]+/, // base 10
|
||||
/0o[0-7]+/, // base 8
|
||||
/0x[0-9a-fA-F]+/, // base 16
|
||||
]),
|
||||
flt: $ => or([
|
||||
/[-+]?(\.[0-9]+|[0-9]+(\.[0-9]*)?)([eE][-+]?[0-9]+)?/, // number
|
||||
/[-+]?(\.inf|\.Inf|\.INF)/, // infinity
|
||||
/(\.nan|\.NaN|\.NAN)/, // not a number
|
||||
]),
|
||||
},
|
||||
});
|
||||
|
||||
function or(regexList) {
|
||||
return new RegExp(regexList.map(regex => `(${regex.source})`).join('|'));
|
||||
}
|
||||
@ -1,604 +0,0 @@
|
||||
module.exports = grammar({
|
||||
name: "yaml",
|
||||
|
||||
externals: $ => [
|
||||
$._eof,
|
||||
|
||||
// s = starts at column 0 in the current or following row
|
||||
// r = starts with 0 or more s_white in the current row
|
||||
// br = starts with more than `current_indent` s_white in the following row
|
||||
// b = starts with `current_indent` s_white in the following row
|
||||
// bl = starts with `parent_indent` or less s_white in the following row
|
||||
$._s_dir_yml_bgn, $._r_dir_yml_ver, // %YAML 1.2
|
||||
$._s_dir_tag_bgn, $._r_dir_tag_hdl, $._r_dir_tag_pfx, // %TAG !yaml! tag:yaml.org,2002:
|
||||
$._s_dir_rsv_bgn, $._r_dir_rsv_prm, // %FOO bar baz
|
||||
$._s_drs_end, // ---
|
||||
$._s_doc_end, // ...
|
||||
$._r_blk_seq_bgn, $._br_blk_seq_bgn, $._b_blk_seq_bgn, // -
|
||||
$._r_blk_key_bgn, $._br_blk_key_bgn, $._b_blk_key_bgn, // ?
|
||||
$._r_blk_val_bgn, $._br_blk_val_bgn, $._b_blk_val_bgn, // :
|
||||
$._r_blk_imp_bgn, // : (implicit)
|
||||
$._r_blk_lit_bgn, $._br_blk_lit_bgn, // |
|
||||
$._r_blk_fld_bgn, $._br_blk_fld_bgn, // >
|
||||
$._br_blk_str_ctn, // block scalar content
|
||||
$._r_flw_seq_bgn, $._br_flw_seq_bgn, $._b_flw_seq_bgn, // [
|
||||
$._r_flw_seq_end, $._br_flw_seq_end, // ]
|
||||
$._r_flw_map_bgn, $._br_flw_map_bgn, $._b_flw_map_bgn, // {
|
||||
$._r_flw_map_end, $._br_flw_map_end, // }
|
||||
$._r_flw_sep_bgn, $._br_flw_sep_bgn, // ,
|
||||
$._r_flw_key_bgn, $._br_flw_key_bgn, // ?
|
||||
$._r_flw_jsv_bgn, $._br_flw_jsv_bgn, // : (json key)
|
||||
$._r_flw_njv_bgn, $._br_flw_njv_bgn, // : (non-json key)
|
||||
$._r_dqt_str_bgn, $._br_dqt_str_bgn, $._b_dqt_str_bgn, // " (start)
|
||||
$._r_dqt_str_ctn, $._br_dqt_str_ctn, // double quote scalar content
|
||||
$._r_dqt_esc_nwl, $._br_dqt_esc_nwl, // escape newline
|
||||
$._r_dqt_esc_seq, $._br_dqt_esc_seq, // escape sequence
|
||||
$._r_dqt_str_end, $._br_dqt_str_end, // " (end)
|
||||
$._r_sqt_str_bgn, $._br_sqt_str_bgn, $._b_sqt_str_bgn, // ' (start)
|
||||
$._r_sqt_str_ctn, $._br_sqt_str_ctn, // single quote scalar content
|
||||
$._r_sqt_esc_sqt, $._br_sqt_esc_sqt, // ''
|
||||
$._r_sqt_str_end, $._br_sqt_str_end, // ' (end)
|
||||
|
||||
// plain scalar (singleline in block/flow)
|
||||
$._r_sgl_pln_nul_blk, $._br_sgl_pln_nul_blk, $._b_sgl_pln_nul_blk, $._r_sgl_pln_nul_flw, $._br_sgl_pln_nul_flw,
|
||||
$._r_sgl_pln_bol_blk, $._br_sgl_pln_bol_blk, $._b_sgl_pln_bol_blk, $._r_sgl_pln_bol_flw, $._br_sgl_pln_bol_flw,
|
||||
$._r_sgl_pln_int_blk, $._br_sgl_pln_int_blk, $._b_sgl_pln_int_blk, $._r_sgl_pln_int_flw, $._br_sgl_pln_int_flw,
|
||||
$._r_sgl_pln_flt_blk, $._br_sgl_pln_flt_blk, $._b_sgl_pln_flt_blk, $._r_sgl_pln_flt_flw, $._br_sgl_pln_flt_flw,
|
||||
$._r_sgl_pln_str_blk, $._br_sgl_pln_str_blk, $._b_sgl_pln_str_blk, $._r_sgl_pln_str_flw, $._br_sgl_pln_str_flw,
|
||||
|
||||
// plain scalar (multiline in block/flow)
|
||||
$._r_mtl_pln_str_blk, $._br_mtl_pln_str_blk,
|
||||
$._r_mtl_pln_str_flw, $._br_mtl_pln_str_flw,
|
||||
|
||||
$._r_tag, $._br_tag, $._b_tag, // !tag
|
||||
$._r_acr_bgn, $._br_acr_bgn, $._b_acr_bgn, $._r_acr_ctn, // &id
|
||||
$._r_als_bgn, $._br_als_bgn, $._b_als_bgn, $._r_als_ctn, // *id
|
||||
|
||||
$._bl,
|
||||
$.comment,
|
||||
],
|
||||
|
||||
extras: $ => [$.comment],
|
||||
|
||||
conflicts: $ => [
|
||||
[$._r_prp, $._r_sgl_prp],
|
||||
[$._br_prp, $._br_sgl_prp],
|
||||
[$._flw_seq_tal, $._sgl_flw_seq_tal],
|
||||
[$._flw_map_tal, $._sgl_flw_map_tal],
|
||||
[$._flw_ann_par_tal, $._sgl_flw_ann_par_tal],
|
||||
[$._r_flw_seq_itm, $._r_sgl_flw_col_itm],
|
||||
[$._r_flw_map_itm, $._r_sgl_flw_col_itm],
|
||||
[$._r_flw_njl_ann_par, $._r_sgl_flw_njl_ann_par],
|
||||
[$._r_flw_exp_par, $._r_sgl_flw_exp_par],
|
||||
[$._r_dqt_str, $._r_sgl_dqt_str],
|
||||
[$._r_sqt_str, $._r_sgl_sqt_str],
|
||||
[$._r_pln_flw_val, $._r_sgl_pln_flw_val],
|
||||
|
||||
/**
|
||||
* (_r_prp _r_acr • _br_tag)
|
||||
*
|
||||
* &str
|
||||
* !!str a
|
||||
*
|
||||
* (_r_prp _r_acr) • _br_tag
|
||||
*
|
||||
* &map
|
||||
* !!str a: 1
|
||||
*/
|
||||
[$._r_prp],
|
||||
[$._br_prp],
|
||||
],
|
||||
|
||||
inline: $ => [
|
||||
$._r_pln_blk,
|
||||
$._br_pln_blk,
|
||||
$._r_pln_flw,
|
||||
$._br_pln_flw,
|
||||
$._r_blk_seq_val,
|
||||
$._r_blk_map_val,
|
||||
$._r_flw_val_blk,
|
||||
$._br_flw_val_blk,
|
||||
$._r_sgl_flw_val_blk,
|
||||
$._br_sgl_flw_val_blk,
|
||||
$._b_sgl_flw_val_blk,
|
||||
$._r_flw_val_flw,
|
||||
$._br_flw_val_flw,
|
||||
$._r_sgl_flw_val_flw,
|
||||
$._r_flw_jsl_val,
|
||||
$._br_flw_jsl_val,
|
||||
$._r_sgl_flw_jsl_val,
|
||||
$._br_sgl_flw_jsl_val,
|
||||
$._b_sgl_flw_jsl_val,
|
||||
$._r_flw_njl_val_blk,
|
||||
$._br_flw_njl_val_blk,
|
||||
$._r_sgl_flw_njl_val_blk,
|
||||
$._br_sgl_flw_njl_val_blk,
|
||||
$._b_sgl_flw_njl_val_blk,
|
||||
$._r_flw_njl_val_flw,
|
||||
$._br_flw_njl_val_flw,
|
||||
$._r_sgl_flw_njl_val_flw,
|
||||
],
|
||||
|
||||
rules: {
|
||||
stream: $ => seq(optional(choice(
|
||||
seq(
|
||||
choice($._bgn_imp_doc, $._drs_doc, $._exp_doc),
|
||||
optional(choice($._doc_w_bgn_w_end_seq, $._doc_w_bgn_wo_end_seq))),
|
||||
seq(
|
||||
choice($._bgn_imp_doc_end, $._drs_doc_end, $._exp_doc_end, $._doc_end),
|
||||
optional(choice($._doc_w_bgn_w_end_seq, $._doc_w_bgn_wo_end_seq, $._doc_wo_bgn_w_end_seq, $._doc_wo_bgn_wo_end_seq))),
|
||||
)), $._eof),
|
||||
|
||||
_doc_w_bgn_w_end_seq: $ => seq($._doc_w_bgn_w_end, optional(choice($._doc_w_bgn_w_end_seq, $._doc_w_bgn_wo_end_seq, $._doc_wo_bgn_w_end_seq, $._doc_wo_bgn_wo_end_seq))),
|
||||
_doc_w_bgn_wo_end_seq: $ => seq($._doc_w_bgn_wo_end, optional(choice($._doc_w_bgn_w_end_seq, $._doc_w_bgn_wo_end_seq))),
|
||||
_doc_wo_bgn_w_end_seq: $ => seq($._doc_wo_bgn_w_end, optional(choice($._doc_w_bgn_w_end_seq, $._doc_w_bgn_wo_end_seq, $._doc_wo_bgn_w_end_seq, $._doc_wo_bgn_wo_end_seq))),
|
||||
_doc_wo_bgn_wo_end_seq: $ => seq($._doc_wo_bgn_wo_end, optional(choice($._doc_w_bgn_w_end_seq, $._doc_w_bgn_wo_end_seq))),
|
||||
|
||||
_doc_w_bgn_w_end: $ => choice($._exp_doc_end, $._doc_end),
|
||||
_doc_w_bgn_wo_end: $ => $._exp_doc,
|
||||
_doc_wo_bgn_w_end: $ => choice($._drs_doc_end, $._imp_doc_end),
|
||||
_doc_wo_bgn_wo_end: $ => choice($._drs_doc, $._imp_doc),
|
||||
|
||||
// document
|
||||
|
||||
_bgn_imp_doc: $ => choice($._exp_doc_tal, $._r_blk_seq_r_val, $._r_blk_map_r_val),
|
||||
_drs_doc: $ => seq(repeat1($._s_dir), $._exp_doc),
|
||||
_exp_doc: $ => seq($._s_drs_end, optional($._exp_doc_tal)),
|
||||
_imp_doc: $ => choice($._br_blk_seq_val, $._br_blk_map_val, $._br_blk_str_val, $._br_flw_val_blk),
|
||||
|
||||
_drs_doc_end: $ => prec(1, seq($._drs_doc, $._s_doc_end)),
|
||||
_exp_doc_end: $ => prec(1, seq($._exp_doc, $._s_doc_end)),
|
||||
_imp_doc_end: $ => prec(1, seq($._imp_doc, $._s_doc_end)),
|
||||
_bgn_imp_doc_end: $ => prec(1, seq($._bgn_imp_doc, $._s_doc_end)),
|
||||
_doc_end: $ => $._s_doc_end,
|
||||
|
||||
_exp_doc_tal: $ => choice($._r_blk_seq_br_val, $._br_blk_seq_val, $._r_blk_map_br_val, $._br_blk_map_val, $._r_blk_str_val, $._br_blk_str_val, $._r_flw_val_blk, $._br_flw_val_blk),
|
||||
|
||||
// directive
|
||||
|
||||
_s_dir: $ => choice($._s_dir_yml, $._s_dir_tag, $._s_dir_rsv),
|
||||
|
||||
_s_dir_yml: $ => seq($._s_dir_yml_bgn, $._r_dir_yml_ver),
|
||||
_s_dir_tag: $ => seq($._s_dir_tag_bgn, $._r_dir_tag_hdl, $._r_dir_tag_pfx),
|
||||
_s_dir_rsv: $ => seq($._s_dir_rsv_bgn, repeat($._r_dir_rsv_prm)),
|
||||
|
||||
// property
|
||||
|
||||
_r_prp_val: $ => $._r_prp,
|
||||
_br_prp_val: $ => $._br_prp,
|
||||
|
||||
_r_sgl_prp_val: $ => $._r_sgl_prp,
|
||||
_br_sgl_prp_val: $ => $._br_sgl_prp,
|
||||
_b_sgl_prp_val: $ => $._b_sgl_prp,
|
||||
|
||||
_r_prp: $ => choice(seq($._r_acr, optional(choice($._r_tag, $._br_tag))), seq($._r_tag, optional(choice($._r_acr, $._br_acr)))),
|
||||
_br_prp: $ => choice(seq($._br_acr, optional(choice($._r_tag, $._br_tag))), seq($._br_tag, optional(choice($._r_acr, $._br_acr)))),
|
||||
|
||||
_r_sgl_prp: $ => choice(seq($._r_acr, optional($._r_tag)), seq($._r_tag, optional($._r_acr))),
|
||||
_br_sgl_prp: $ => choice(seq($._br_acr, optional($._r_tag)), seq($._br_tag, optional($._r_acr))),
|
||||
_b_sgl_prp: $ => choice(seq($._b_acr, optional($._r_tag)), seq($._b_tag, optional($._r_acr))),
|
||||
|
||||
// block sequence
|
||||
|
||||
_r_blk_seq_val: $ => choice($._r_blk_seq_r_val, $._r_blk_seq_br_val),
|
||||
_r_blk_seq_r_val: $ => $._r_blk_seq,
|
||||
_r_blk_seq_br_val: $ => seq($._r_prp, $._br_blk_seq),
|
||||
_br_blk_seq_val: $ => choice($._br_blk_seq, seq($._br_prp, $._br_blk_seq)),
|
||||
|
||||
_r_blk_seq_spc_val: $ => seq($._r_prp, $._b_blk_seq_spc),
|
||||
_br_blk_seq_spc_val: $ => seq($._br_prp, $._b_blk_seq_spc),
|
||||
_b_blk_seq_spc_val: $ => $._b_blk_seq_spc,
|
||||
|
||||
_r_blk_seq: $ => seq($._r_blk_seq_itm, repeat($._b_blk_seq_itm), $._bl),
|
||||
_br_blk_seq: $ => seq($._br_blk_seq_itm, repeat($._b_blk_seq_itm), $._bl),
|
||||
|
||||
_b_blk_seq_spc: $ => seq(repeat1($._b_blk_seq_itm), $._bl),
|
||||
|
||||
_r_blk_seq_itm: $ => seq($._r_blk_seq_bgn, optional($._blk_seq_itm_tal)),
|
||||
_br_blk_seq_itm: $ => seq($._br_blk_seq_bgn, optional($._blk_seq_itm_tal)),
|
||||
_b_blk_seq_itm: $ => seq($._b_blk_seq_bgn, optional($._blk_seq_itm_tal)),
|
||||
|
||||
_blk_seq_itm_tal: $ => choice($._r_blk_seq_val, $._br_blk_seq_val, $._r_blk_map_val, $._br_blk_map_val, $._r_blk_str_val, $._br_blk_str_val, $._r_flw_val_blk, $._br_flw_val_blk),
|
||||
|
||||
// block mapping
|
||||
|
||||
_r_blk_map_val: $ => choice($._r_blk_map_r_val, $._r_blk_map_br_val),
|
||||
_r_blk_map_r_val: $ => $._r_blk_map,
|
||||
_r_blk_map_br_val: $ => seq($._r_prp, $._br_blk_map),
|
||||
_br_blk_map_val: $ => choice($._br_blk_map, seq($._br_prp, $._br_blk_map)),
|
||||
|
||||
_r_blk_map: $ => seq($._r_blk_map_itm, repeat($._b_blk_map_itm), $._bl),
|
||||
_br_blk_map: $ => seq($._br_blk_map_itm, repeat($._b_blk_map_itm), $._bl),
|
||||
|
||||
_r_blk_map_itm: $ => choice($._r_blk_exp_itm, $._r_blk_imp_itm),
|
||||
_br_blk_map_itm: $ => choice($._br_blk_exp_itm, $._br_blk_imp_itm),
|
||||
_b_blk_map_itm: $ => choice($._b_blk_exp_itm, $._b_blk_imp_itm),
|
||||
|
||||
_r_blk_exp_itm: $ => prec.right(choice(seq($._r_blk_key_itm, optional($._b_blk_val_itm)), $._r_blk_val_itm)),
|
||||
_br_blk_exp_itm: $ => prec.right(choice(seq($._br_blk_key_itm, optional($._b_blk_val_itm)), $._br_blk_val_itm)),
|
||||
_b_blk_exp_itm: $ => prec.right(choice(seq($._b_blk_key_itm, optional($._b_blk_val_itm)), $._b_blk_val_itm)),
|
||||
|
||||
_r_blk_key_itm: $ => seq($._r_blk_key_bgn, optional(field("key", $._blk_exp_itm_tal))),
|
||||
_br_blk_key_itm: $ => seq($._br_blk_key_bgn, optional(field("key", $._blk_exp_itm_tal))),
|
||||
_b_blk_key_itm: $ => seq($._b_blk_key_bgn, optional(field("key", $._blk_exp_itm_tal))),
|
||||
|
||||
_r_blk_val_itm: $ => seq($._r_blk_val_bgn, optional(field("value", $._blk_exp_itm_tal))),
|
||||
_br_blk_val_itm: $ => seq($._br_blk_val_bgn, optional(field("value", $._blk_exp_itm_tal))),
|
||||
_b_blk_val_itm: $ => seq($._b_blk_val_bgn, optional(field("value", $._blk_exp_itm_tal))),
|
||||
|
||||
_r_blk_imp_itm: $ => seq(field("key", $._r_sgl_flw_val_blk), $._blk_imp_itm_tal),
|
||||
_br_blk_imp_itm: $ => seq(field("key", $._br_sgl_flw_val_blk), $._blk_imp_itm_tal),
|
||||
_b_blk_imp_itm: $ => seq(field("key", $._b_sgl_flw_val_blk), $._blk_imp_itm_tal),
|
||||
|
||||
_blk_exp_itm_tal: $ => choice($._blk_seq_itm_tal, $._r_blk_seq_spc_val, $._br_blk_seq_spc_val, $._b_blk_seq_spc_val),
|
||||
_blk_imp_itm_tal: $ => seq($._r_blk_imp_bgn, optional(field("value", choice($._r_blk_seq_br_val, $._br_blk_seq_val, $._r_blk_seq_spc_val, $._br_blk_seq_spc_val, $._b_blk_seq_spc_val, $._r_blk_map_br_val, $._br_blk_map_val, $._r_blk_str_val, $._br_blk_str_val, $._r_flw_val_blk, $._br_flw_val_blk)))),
|
||||
|
||||
// block scalar
|
||||
|
||||
_r_blk_str_val: $ => choice($._r_blk_str, seq($._r_prp, choice($._r_blk_str, $._br_blk_str))),
|
||||
_br_blk_str_val: $ => choice($._br_blk_str, seq($._br_prp, choice($._r_blk_str, $._br_blk_str))),
|
||||
|
||||
_r_blk_str: $ => seq(choice($._r_blk_lit_bgn, $._r_blk_fld_bgn), repeat($._br_blk_str_ctn), $._bl),
|
||||
_br_blk_str: $ => seq(choice($._br_blk_lit_bgn, $._br_blk_fld_bgn), repeat($._br_blk_str_ctn), $._bl),
|
||||
|
||||
// flow value in block
|
||||
|
||||
_r_flw_val_blk: $ => choice($._r_flw_jsl_val, $._r_flw_njl_val_blk),
|
||||
_br_flw_val_blk: $ => choice($._br_flw_jsl_val, $._br_flw_njl_val_blk),
|
||||
|
||||
_r_sgl_flw_val_blk: $ => choice($._r_sgl_flw_jsl_val, $._r_sgl_flw_njl_val_blk),
|
||||
_br_sgl_flw_val_blk: $ => choice($._br_sgl_flw_jsl_val, $._br_sgl_flw_njl_val_blk),
|
||||
_b_sgl_flw_val_blk: $ => choice($._b_sgl_flw_jsl_val, $._b_sgl_flw_njl_val_blk),
|
||||
|
||||
// flow value in flow
|
||||
|
||||
_r_flw_val_flw: $ => choice($._r_flw_jsl_val, $._r_flw_njl_val_flw),
|
||||
_br_flw_val_flw: $ => choice($._br_flw_jsl_val, $._br_flw_njl_val_flw),
|
||||
|
||||
_r_sgl_flw_val_flw: $ => choice($._r_sgl_flw_jsl_val, $._r_sgl_flw_njl_val_flw),
|
||||
|
||||
// json-like flow value
|
||||
|
||||
_r_flw_jsl_val: $ => choice($._r_flw_seq_val, $._r_flw_map_val, $._r_dqt_str_val, $._r_sqt_str_val),
|
||||
_br_flw_jsl_val: $ => choice($._br_flw_seq_val, $._br_flw_map_val, $._br_dqt_str_val, $._br_sqt_str_val),
|
||||
|
||||
_r_sgl_flw_jsl_val: $ => choice($._r_sgl_flw_seq_val, $._r_sgl_flw_map_val, $._r_sgl_dqt_str_val, $._r_sgl_sqt_str_val),
|
||||
_br_sgl_flw_jsl_val: $ => choice($._br_sgl_flw_seq_val, $._br_sgl_flw_map_val, $._br_sgl_dqt_str_val, $._br_sgl_sqt_str_val),
|
||||
_b_sgl_flw_jsl_val: $ => choice($._b_sgl_flw_seq_val, $._b_sgl_flw_map_val, $._b_sgl_dqt_str_val, $._b_sgl_sqt_str_val),
|
||||
|
||||
// non-json-like flow value in block
|
||||
|
||||
_r_flw_njl_val_blk: $ => choice($._r_als_val, $._r_prp_val, $._r_pln_blk_val),
|
||||
_br_flw_njl_val_blk: $ => choice($._br_als_val, $._br_prp_val, $._br_pln_blk_val),
|
||||
|
||||
_r_sgl_flw_njl_val_blk: $ => choice($._r_als_val, $._r_sgl_prp_val, $._r_sgl_pln_blk_val),
|
||||
_br_sgl_flw_njl_val_blk: $ => choice($._br_als_val, $._br_sgl_prp_val, $._br_sgl_pln_blk_val),
|
||||
_b_sgl_flw_njl_val_blk: $ => choice($._b_als_val, $._b_sgl_prp_val, $._b_sgl_pln_blk_val),
|
||||
|
||||
// non-json-like flow value in flow
|
||||
|
||||
_r_flw_njl_val_flw: $ => choice($._r_als_val, $._r_prp_val, $._r_pln_flw_val),
|
||||
_br_flw_njl_val_flw: $ => choice($._br_als_val, $._br_prp_val, $._br_pln_flw_val),
|
||||
|
||||
_r_sgl_flw_njl_val_flw: $ => choice($._r_als_val, $._r_sgl_prp_val, $._r_sgl_pln_flw_val),
|
||||
|
||||
// flow sequence
|
||||
|
||||
_r_flw_seq_val: $ => choice($._r_flw_seq, seq($._r_prp, choice($._r_flw_seq, $._br_flw_seq))),
|
||||
_br_flw_seq_val: $ => choice($._br_flw_seq, seq($._br_prp, choice($._r_flw_seq, $._br_flw_seq))),
|
||||
|
||||
_r_sgl_flw_seq_val: $ => choice($._r_sgl_flw_seq, seq($._r_sgl_prp, $._r_sgl_flw_seq)),
|
||||
_br_sgl_flw_seq_val: $ => choice($._br_sgl_flw_seq, seq($._br_sgl_prp, $._r_sgl_flw_seq)),
|
||||
_b_sgl_flw_seq_val: $ => choice($._b_sgl_flw_seq, seq($._b_sgl_prp, $._r_sgl_flw_seq)),
|
||||
|
||||
_r_flw_seq: $ => seq($._r_flw_seq_bgn, $._flw_seq_tal),
|
||||
_br_flw_seq: $ => seq($._br_flw_seq_bgn, $._flw_seq_tal),
|
||||
|
||||
_r_sgl_flw_seq: $ => seq($._r_flw_seq_bgn, $._sgl_flw_seq_tal),
|
||||
_br_sgl_flw_seq: $ => seq($._br_flw_seq_bgn, $._sgl_flw_seq_tal),
|
||||
_b_sgl_flw_seq: $ => seq($._b_flw_seq_bgn, $._sgl_flw_seq_tal),
|
||||
|
||||
_flw_seq_tal: $ => seq(optional(choice($._r_flw_seq_dat, $._br_flw_seq_dat)), choice($._r_flw_seq_end, $._br_flw_seq_end)),
|
||||
_sgl_flw_seq_tal: $ => seq(optional($._r_sgl_flw_col_dat), $._r_flw_seq_end),
|
||||
|
||||
// flow mapping
|
||||
|
||||
_r_flw_map_val: $ => choice($._r_flw_map, seq($._r_prp, choice($._r_flw_map, $._br_flw_map))),
|
||||
_br_flw_map_val: $ => choice($._br_flw_map, seq($._br_prp, choice($._r_flw_map, $._br_flw_map))),
|
||||
|
||||
_r_sgl_flw_map_val: $ => choice($._r_sgl_flw_map, seq($._r_sgl_prp, $._r_sgl_flw_map)),
|
||||
_br_sgl_flw_map_val: $ => choice($._br_sgl_flw_map, seq($._br_sgl_prp, $._r_sgl_flw_map)),
|
||||
_b_sgl_flw_map_val: $ => choice($._b_sgl_flw_map, seq($._b_sgl_prp, $._r_sgl_flw_map)),
|
||||
|
||||
_r_flw_map: $ => seq($._r_flw_map_bgn, $._flw_map_tal),
|
||||
_br_flw_map: $ => seq($._br_flw_map_bgn, $._flw_map_tal),
|
||||
|
||||
_r_sgl_flw_map: $ => seq($._r_flw_map_bgn, $._sgl_flw_map_tal),
|
||||
_br_sgl_flw_map: $ => seq($._br_flw_map_bgn, $._sgl_flw_map_tal),
|
||||
_b_sgl_flw_map: $ => seq($._b_flw_map_bgn, $._sgl_flw_map_tal),
|
||||
|
||||
_flw_map_tal: $ => seq(optional(choice($._r_flw_map_dat, $._br_flw_map_dat)), choice($._r_flw_map_end, $._br_flw_map_end)),
|
||||
_sgl_flw_map_tal: $ => seq(optional($._r_sgl_flw_col_dat), $._r_flw_map_end),
|
||||
|
||||
// flow collection data
|
||||
|
||||
_r_flw_seq_dat: $ => seq($._r_flw_seq_itm, repeat($._flw_seq_dat_rpt), optional(choice($._r_flw_sep_bgn, $._br_flw_sep_bgn))),
|
||||
_br_flw_seq_dat: $ => seq($._br_flw_seq_itm, repeat($._flw_seq_dat_rpt), optional(choice($._r_flw_sep_bgn, $._br_flw_sep_bgn))),
|
||||
|
||||
_r_flw_map_dat: $ => seq($._r_flw_map_itm, repeat($._flw_map_dat_rpt), optional(choice($._r_flw_sep_bgn, $._br_flw_sep_bgn))),
|
||||
_br_flw_map_dat: $ => seq($._br_flw_map_itm, repeat($._flw_map_dat_rpt), optional(choice($._r_flw_sep_bgn, $._br_flw_sep_bgn))),
|
||||
|
||||
_r_sgl_flw_col_dat: $ => seq($._r_sgl_flw_col_itm, repeat($._sgl_flw_col_dat_rpt), optional($._r_flw_sep_bgn)),
|
||||
|
||||
_flw_seq_dat_rpt: $ => seq(choice($._r_flw_sep_bgn, $._br_flw_sep_bgn), choice($._r_flw_seq_itm, $._br_flw_seq_itm)),
|
||||
_flw_map_dat_rpt: $ => seq(choice($._r_flw_sep_bgn, $._br_flw_sep_bgn), choice($._r_flw_map_itm, $._br_flw_map_itm)),
|
||||
|
||||
_sgl_flw_col_dat_rpt: $ => seq($._r_flw_sep_bgn, $._r_sgl_flw_col_itm),
|
||||
|
||||
// flow collection item
|
||||
|
||||
_r_flw_seq_itm: $ => choice($._r_flw_val_flw, $._r_flw_exp_par, $._r_flw_imp_r_par, $._r_flw_njl_ann_par),
|
||||
_br_flw_seq_itm: $ => choice($._br_flw_val_flw, $._br_flw_exp_par, $._br_flw_imp_r_par, $._br_flw_njl_ann_par),
|
||||
|
||||
_r_flw_map_itm: $ => choice($._r_flw_val_flw, $._r_flw_exp_par, $._r_flw_imp_r_par, $._r_flw_imp_br_par, $._r_flw_njl_ann_par),
|
||||
_br_flw_map_itm: $ => choice($._br_flw_val_flw, $._br_flw_exp_par, $._br_flw_imp_r_par, $._br_flw_imp_br_par, $._br_flw_njl_ann_par),
|
||||
|
||||
_r_sgl_flw_col_itm: $ => choice($._r_sgl_flw_val_flw, $._r_sgl_flw_exp_par, $._r_sgl_flw_imp_par, $._r_sgl_flw_njl_ann_par),
|
||||
|
||||
// explicit flow pair
|
||||
|
||||
_r_flw_exp_par: $ => seq($._r_flw_key_bgn, optional(choice($._r_flw_imp_r_par, $._r_flw_imp_br_par, $._br_flw_imp_r_par, $._br_flw_imp_br_par))),
|
||||
_br_flw_exp_par: $ => seq($._br_flw_key_bgn, optional(choice($._r_flw_imp_r_par, $._r_flw_imp_br_par, $._br_flw_imp_r_par, $._br_flw_imp_br_par))),
|
||||
|
||||
_r_sgl_flw_exp_par: $ => seq($._r_flw_key_bgn, optional($._r_sgl_flw_imp_par)),
|
||||
|
||||
// implicit flow pair
|
||||
|
||||
_r_flw_imp_r_par: $ => choice(seq(field("key", $._r_flw_jsl_val), $._r_flw_jsl_ann_par), seq(field("key", $._r_flw_njl_val_flw), $._r_flw_njl_ann_par)),
|
||||
_r_flw_imp_br_par: $ => choice(seq(field("key", $._r_flw_jsl_val), $._br_flw_jsl_ann_par), seq(field("key", $._r_flw_njl_val_flw), $._br_flw_njl_ann_par)),
|
||||
_br_flw_imp_r_par: $ => choice(seq(field("key", $._br_flw_jsl_val), $._r_flw_jsl_ann_par), seq(field("key", $._br_flw_njl_val_flw), $._r_flw_njl_ann_par)),
|
||||
_br_flw_imp_br_par: $ => choice(seq(field("key", $._br_flw_jsl_val), $._br_flw_jsl_ann_par), seq(field("key", $._br_flw_njl_val_flw), $._br_flw_njl_ann_par)),
|
||||
|
||||
_r_sgl_flw_imp_par: $ => choice(seq(field("key", $._r_sgl_flw_jsl_val), $._r_sgl_flw_jsl_ann_par), seq(field("key", $._r_sgl_flw_njl_val_flw), $._r_sgl_flw_njl_ann_par)),
|
||||
|
||||
// anonymous flow pair
|
||||
|
||||
_r_flw_jsl_ann_par: $ => seq($._r_flw_jsv_bgn, optional(field("value", $._flw_ann_par_tal))),
|
||||
_br_flw_jsl_ann_par: $ => seq($._br_flw_jsv_bgn, optional(field("value", $._flw_ann_par_tal))),
|
||||
|
||||
_r_sgl_flw_jsl_ann_par: $ => seq($._r_flw_jsv_bgn, optional(field("value", $._sgl_flw_ann_par_tal))),
|
||||
|
||||
_r_flw_njl_ann_par: $ => seq($._r_flw_njv_bgn, optional(field("value", $._flw_ann_par_tal))),
|
||||
_br_flw_njl_ann_par: $ => seq($._br_flw_njv_bgn, optional(field("value", $._flw_ann_par_tal))),
|
||||
|
||||
_r_sgl_flw_njl_ann_par: $ => seq($._r_flw_njv_bgn, optional(field("value", $._sgl_flw_ann_par_tal))),
|
||||
|
||||
_flw_ann_par_tal: $ => choice($._r_flw_val_flw, $._br_flw_val_flw),
|
||||
_sgl_flw_ann_par_tal: $ => $._r_sgl_flw_val_flw,
|
||||
|
||||
// double quote scalar
|
||||
|
||||
_r_dqt_str_val: $ => choice($._r_dqt_str, seq($._r_prp, choice($._r_dqt_str, $._br_dqt_str))),
|
||||
_br_dqt_str_val: $ => choice($._br_dqt_str, seq($._br_prp, choice($._r_dqt_str, $._br_dqt_str))),
|
||||
|
||||
_r_sgl_dqt_str_val: $ => choice($._r_sgl_dqt_str, seq($._r_sgl_prp, $._r_sgl_dqt_str)),
|
||||
_br_sgl_dqt_str_val: $ => choice($._br_sgl_dqt_str, seq($._br_sgl_prp, $._r_sgl_dqt_str)),
|
||||
_b_sgl_dqt_str_val: $ => choice($._b_sgl_dqt_str, seq($._b_sgl_prp, $._r_sgl_dqt_str)),
|
||||
|
||||
_r_dqt_str: $ => seq($._r_dqt_str_bgn, optional($._r_sgl_dqt_ctn), optional($._r_dqt_esc_nwl), repeat($._br_mtl_dqt_ctn), choice($._r_dqt_str_end, $._br_dqt_str_end)),
|
||||
_br_dqt_str: $ => seq($._br_dqt_str_bgn, optional($._r_sgl_dqt_ctn), optional($._r_dqt_esc_nwl), repeat($._br_mtl_dqt_ctn), choice($._r_dqt_str_end, $._br_dqt_str_end)),
|
||||
|
||||
_r_sgl_dqt_str: $ => seq($._r_dqt_str_bgn, optional($._r_sgl_dqt_ctn), $._r_dqt_str_end),
|
||||
_br_sgl_dqt_str: $ => seq($._br_dqt_str_bgn, optional($._r_sgl_dqt_ctn), $._r_dqt_str_end),
|
||||
_b_sgl_dqt_str: $ => seq($._b_dqt_str_bgn, optional($._r_sgl_dqt_ctn), $._r_dqt_str_end),
|
||||
|
||||
_r_sgl_dqt_ctn: $ => repeat1(choice($._r_dqt_str_ctn, $._r_dqt_esc_seq)),
|
||||
_br_mtl_dqt_ctn: $ => choice($._br_dqt_esc_nwl, seq(choice($._br_dqt_str_ctn, $._br_dqt_esc_seq), repeat(choice($._r_dqt_str_ctn, $._r_dqt_esc_seq)), optional($._r_dqt_esc_nwl))),
|
||||
|
||||
// single quote scalar
|
||||
|
||||
_r_sqt_str_val: $ => choice($._r_sqt_str, seq($._r_prp, choice($._r_sqt_str, $._br_sqt_str))),
|
||||
_br_sqt_str_val: $ => choice($._br_sqt_str, seq($._br_prp, choice($._r_sqt_str, $._br_sqt_str))),
|
||||
|
||||
_r_sgl_sqt_str_val: $ => choice($._r_sgl_sqt_str, seq($._r_sgl_prp, $._r_sgl_sqt_str)),
|
||||
_br_sgl_sqt_str_val: $ => choice($._br_sgl_sqt_str, seq($._br_sgl_prp, $._r_sgl_sqt_str)),
|
||||
_b_sgl_sqt_str_val: $ => choice($._b_sgl_sqt_str, seq($._b_sgl_prp, $._r_sgl_sqt_str)),
|
||||
|
||||
_r_sqt_str: $ => seq($._r_sqt_str_bgn, optional($._r_sgl_sqt_ctn), repeat($._br_mtl_sqt_ctn), choice($._r_sqt_str_end, $._br_sqt_str_end)),
|
||||
_br_sqt_str: $ => seq($._br_sqt_str_bgn, optional($._r_sgl_sqt_ctn), repeat($._br_mtl_sqt_ctn), choice($._r_sqt_str_end, $._br_sqt_str_end)),
|
||||
|
||||
_r_sgl_sqt_str: $ => seq($._r_sqt_str_bgn, optional($._r_sgl_sqt_ctn), $._r_sqt_str_end),
|
||||
_br_sgl_sqt_str: $ => seq($._br_sqt_str_bgn, optional($._r_sgl_sqt_ctn), $._r_sqt_str_end),
|
||||
_b_sgl_sqt_str: $ => seq($._b_sqt_str_bgn, optional($._r_sgl_sqt_ctn), $._r_sqt_str_end),
|
||||
|
||||
_r_sgl_sqt_ctn: $ => repeat1(choice($._r_sqt_str_ctn, $._r_sqt_esc_sqt)),
|
||||
_br_mtl_sqt_ctn: $ => seq(choice($._br_sqt_str_ctn, $._br_sqt_esc_sqt), repeat(choice($._r_sqt_str_ctn, $._r_sqt_esc_sqt))),
|
||||
|
||||
// plain scalar in block
|
||||
|
||||
_r_pln_blk_val: $ => choice($._r_pln_blk, seq($._r_prp, choice($._r_pln_blk, $._br_pln_blk))),
|
||||
_br_pln_blk_val: $ => choice($._br_pln_blk, seq($._br_prp, choice($._r_pln_blk, $._br_pln_blk))),
|
||||
|
||||
_r_sgl_pln_blk_val: $ => choice($._r_sgl_pln_blk, seq($._r_sgl_prp, $._r_sgl_pln_blk)),
|
||||
_br_sgl_pln_blk_val: $ => choice($._br_sgl_pln_blk, seq($._br_sgl_prp, $._r_sgl_pln_blk)),
|
||||
_b_sgl_pln_blk_val: $ => choice($._b_sgl_pln_blk, seq($._b_sgl_prp, $._r_sgl_pln_blk)),
|
||||
|
||||
_r_pln_blk: $ => choice($._r_sgl_pln_blk, $._r_mtl_pln_blk),
|
||||
_br_pln_blk: $ => choice($._br_sgl_pln_blk, $._br_mtl_pln_blk),
|
||||
|
||||
// plain scalar in flow
|
||||
|
||||
_r_pln_flw_val: $ => choice($._r_pln_flw, seq($._r_prp, choice($._r_pln_flw, $._br_pln_flw))),
|
||||
_br_pln_flw_val: $ => choice($._br_pln_flw, seq($._br_prp, choice($._r_pln_flw, $._br_pln_flw))),
|
||||
|
||||
_r_sgl_pln_flw_val: $ => choice($._r_sgl_pln_flw, seq($._r_sgl_prp, $._r_sgl_pln_flw)),
|
||||
|
||||
_r_pln_flw: $ => choice($._r_sgl_pln_flw, $._r_mtl_pln_flw),
|
||||
_br_pln_flw: $ => choice($._br_sgl_pln_flw, $._br_mtl_pln_flw),
|
||||
|
||||
// plain scalar schema
|
||||
|
||||
_r_sgl_pln_blk: $ => choice($._r_sgl_pln_nul_blk, $._r_sgl_pln_bol_blk, $._r_sgl_pln_int_blk, $._r_sgl_pln_flt_blk, $._r_sgl_pln_str_blk),
|
||||
_br_sgl_pln_blk: $ => choice($._br_sgl_pln_nul_blk, $._br_sgl_pln_bol_blk, $._br_sgl_pln_int_blk, $._br_sgl_pln_flt_blk, $._br_sgl_pln_str_blk),
|
||||
_b_sgl_pln_blk: $ => choice($._b_sgl_pln_nul_blk, $._b_sgl_pln_bol_blk, $._b_sgl_pln_int_blk, $._b_sgl_pln_flt_blk, $._b_sgl_pln_str_blk),
|
||||
_r_sgl_pln_flw: $ => choice($._r_sgl_pln_nul_flw, $._r_sgl_pln_bol_flw, $._r_sgl_pln_int_flw, $._r_sgl_pln_flt_flw, $._r_sgl_pln_str_flw),
|
||||
_br_sgl_pln_flw: $ => choice($._br_sgl_pln_nul_flw, $._br_sgl_pln_bol_flw, $._br_sgl_pln_int_flw, $._br_sgl_pln_flt_flw, $._br_sgl_pln_str_flw),
|
||||
|
||||
_r_mtl_pln_blk: $ => $._r_mtl_pln_str_blk,
|
||||
_br_mtl_pln_blk: $ => $._br_mtl_pln_str_blk,
|
||||
_r_mtl_pln_flw: $ => $._r_mtl_pln_str_flw,
|
||||
_br_mtl_pln_flw: $ => $._br_mtl_pln_str_flw,
|
||||
|
||||
// alias
|
||||
|
||||
_r_als_val: $ => $._r_als,
|
||||
_br_als_val: $ => $._br_als,
|
||||
_b_als_val: $ => $._b_als,
|
||||
|
||||
_r_als: $ => seq($._r_als_bgn, $._r_als_ctn),
|
||||
_br_als: $ => seq($._br_als_bgn, $._r_als_ctn),
|
||||
_b_als: $ => seq($._b_als_bgn, $._r_als_ctn),
|
||||
|
||||
// anchor
|
||||
|
||||
_r_acr: $ => seq($._r_acr_bgn, $._r_acr_ctn),
|
||||
_br_acr: $ => seq($._br_acr_bgn, $._r_acr_ctn),
|
||||
_b_acr: $ => seq($._b_acr_bgn, $._r_acr_ctn),
|
||||
},
|
||||
});
|
||||
|
||||
module.exports = global_alias(global_alias(module.exports, {
|
||||
..._("yaml_directive", "_s_dir_yml"),
|
||||
..._("yaml_version", "_r_dir_yml_ver"),
|
||||
..._("tag_directive", "_s_dir_tag"),
|
||||
..._("tag_handle", "_r_dir_tag_hdl"),
|
||||
..._("tag_prefix", "_r_dir_tag_pfx"),
|
||||
..._("reserved_directive", "_s_dir_rsv"),
|
||||
..._("directive_name", "_s_dir_rsv_bgn"),
|
||||
..._("directive_parameter", "_r_dir_rsv_prm"),
|
||||
..._("flow_node", "_r_prp_val", "_br_prp_val", "_r_sgl_prp_val", "_br_sgl_prp_val", "_b_sgl_prp_val"),
|
||||
..._("tag", "_r_tag", "_br_tag", "_b_tag"),
|
||||
..._("anchor", "_r_acr", "_br_acr", "_b_acr"),
|
||||
..._("anchor_name", "_r_acr_ctn"),
|
||||
..._("flow_node", "_r_als_val", "_br_als_val", "_b_als_val"),
|
||||
..._("alias", "_r_als", "_br_als", "_b_als"),
|
||||
..._("alias_name", "_r_als_ctn"),
|
||||
..._("document", "_bgn_imp_doc", "_imp_doc"),
|
||||
..._(["document"], "_drs_doc", "_exp_doc", "_doc_end",
|
||||
"_bgn_imp_doc_end", "_drs_doc_end", "_exp_doc_end", "_imp_doc_end"),
|
||||
..._("block_node", "_r_blk_seq_r_val", "_r_blk_seq_br_val", "_br_blk_seq_val", "_r_blk_seq_spc_val", "_br_blk_seq_spc_val", "_b_blk_seq_spc_val"),
|
||||
..._("block_node", "_r_blk_map_r_val", "_r_blk_map_br_val", "_br_blk_map_val"),
|
||||
..._("block_node", "_r_blk_str_val", "_br_blk_str_val"),
|
||||
..._("block_sequence", "_r_blk_seq", "_br_blk_seq", "_b_blk_seq_spc"),
|
||||
..._("block_mapping", "_r_blk_map", "_br_blk_map"),
|
||||
..._("block_scalar", "_r_blk_str", "_br_blk_str"),
|
||||
..._("block_sequence_item", "_r_blk_seq_itm", "_br_blk_seq_itm", "_b_blk_seq_itm"),
|
||||
..._("block_mapping_pair", "_r_blk_exp_itm", "_br_blk_exp_itm", "_b_blk_exp_itm"),
|
||||
..._("block_mapping_pair", "_r_blk_imp_itm", "_br_blk_imp_itm", "_b_blk_imp_itm"),
|
||||
..._("flow_node", "_r_flw_seq_val", "_br_flw_seq_val", "_r_sgl_flw_seq_val", "_br_sgl_flw_seq_val", "_b_sgl_flw_seq_val"),
|
||||
..._("flow_node", "_r_flw_map_val", "_br_flw_map_val", "_r_sgl_flw_map_val", "_br_sgl_flw_map_val", "_b_sgl_flw_map_val"),
|
||||
..._("flow_sequence", "_r_flw_seq", "_br_flw_seq", "_r_sgl_flw_seq", "_br_sgl_flw_seq", "_b_sgl_flw_seq"),
|
||||
..._("flow_mapping", "_r_flw_map", "_br_flw_map", "_r_sgl_flw_map", "_br_sgl_flw_map", "_b_sgl_flw_map"),
|
||||
..._(["flow_pair"], "_r_flw_exp_par", "_br_flw_exp_par", "_r_sgl_flw_exp_par",
|
||||
"_r_flw_imp_r_par", "_r_flw_imp_br_par", "_br_flw_imp_r_par", "_br_flw_imp_br_par", "_r_sgl_flw_imp_par",
|
||||
"_r_flw_njl_ann_par", "_br_flw_njl_ann_par", "_r_sgl_flw_njl_ann_par"),
|
||||
..._("flow_node", "_r_dqt_str_val", "_br_dqt_str_val", "_r_sgl_dqt_str_val", "_br_sgl_dqt_str_val", "_b_sgl_dqt_str_val"),
|
||||
..._("flow_node", "_r_sqt_str_val", "_br_sqt_str_val", "_r_sgl_sqt_str_val", "_br_sgl_sqt_str_val", "_b_sgl_sqt_str_val"),
|
||||
..._("flow_node", "_r_pln_blk_val", "_br_pln_blk_val", "_r_sgl_pln_blk_val", "_br_sgl_pln_blk_val", "_b_sgl_pln_blk_val",
|
||||
"_r_pln_flw_val", "_br_pln_flw_val", "_r_sgl_pln_flw_val"),
|
||||
..._("double_quote_scalar", "_r_dqt_str", "_br_dqt_str", "_r_sgl_dqt_str", "_br_sgl_dqt_str", "_b_sgl_dqt_str"),
|
||||
..._("single_quote_scalar", "_r_sqt_str", "_br_sqt_str", "_r_sgl_sqt_str", "_br_sgl_sqt_str", "_b_sgl_sqt_str"),
|
||||
..._("plain_scalar", "_r_mtl_pln_blk", "_br_mtl_pln_blk", "_r_sgl_pln_blk", "_br_sgl_pln_blk", "_b_sgl_pln_blk",
|
||||
"_r_mtl_pln_flw", "_br_mtl_pln_flw", "_r_sgl_pln_flw", "_br_sgl_pln_flw"),
|
||||
..._("escape_sequence", "_r_dqt_esc_nwl", "_br_dqt_esc_nwl",
|
||||
"_r_dqt_esc_seq", "_br_dqt_esc_seq",
|
||||
"_r_sqt_esc_sqt", "_br_sqt_esc_sqt"),
|
||||
..._("null_scalar", "_r_sgl_pln_nul_blk", "_br_sgl_pln_nul_blk", "_b_sgl_pln_nul_blk", "_r_sgl_pln_nul_flw", "_br_sgl_pln_nul_flw"),
|
||||
..._("boolean_scalar", "_r_sgl_pln_bol_blk", "_br_sgl_pln_bol_blk", "_b_sgl_pln_bol_blk", "_r_sgl_pln_bol_flw", "_br_sgl_pln_bol_flw"),
|
||||
..._("integer_scalar", "_r_sgl_pln_int_blk", "_br_sgl_pln_int_blk", "_b_sgl_pln_int_blk", "_r_sgl_pln_int_flw", "_br_sgl_pln_int_flw"),
|
||||
..._("float_scalar", "_r_sgl_pln_flt_blk", "_br_sgl_pln_flt_blk", "_b_sgl_pln_flt_blk", "_r_sgl_pln_flt_flw", "_br_sgl_pln_flt_flw"),
|
||||
..._("string_scalar", "_r_sgl_pln_str_blk", "_br_sgl_pln_str_blk", "_b_sgl_pln_str_blk", "_r_sgl_pln_str_flw", "_br_sgl_pln_str_flw",
|
||||
"_r_mtl_pln_str_blk", "_br_mtl_pln_str_blk", "_r_mtl_pln_str_flw", "_br_mtl_pln_str_flw"),
|
||||
}), {
|
||||
..._("---", "_s_drs_end"),
|
||||
..._("...", "_s_doc_end"),
|
||||
..._("-", "_r_blk_seq_bgn", "_br_blk_seq_bgn", "_b_blk_seq_bgn"),
|
||||
..._("?", "_r_blk_key_bgn", "_br_blk_key_bgn", "_b_blk_key_bgn"),
|
||||
..._(":", "_r_blk_val_bgn", "_br_blk_val_bgn", "_b_blk_val_bgn"),
|
||||
..._(":", "_r_blk_imp_bgn"),
|
||||
..._("|", "_r_blk_lit_bgn", "_br_blk_lit_bgn"),
|
||||
..._(">", "_r_blk_fld_bgn", "_br_blk_fld_bgn"),
|
||||
..._("[", "_r_flw_seq_bgn", "_br_flw_seq_bgn", "_b_flw_seq_bgn"),
|
||||
..._("]", "_r_flw_seq_end", "_br_flw_seq_end"),
|
||||
..._("{", "_r_flw_map_bgn", "_br_flw_map_bgn", "_b_flw_map_bgn"),
|
||||
..._("}", "_r_flw_map_end", "_br_flw_map_end"),
|
||||
..._(",", "_r_flw_sep_bgn", "_br_flw_sep_bgn"),
|
||||
..._("?", "_r_flw_key_bgn", "_br_flw_key_bgn"),
|
||||
..._(":", "_r_flw_jsv_bgn", "_br_flw_jsv_bgn"),
|
||||
..._(":", "_r_flw_njv_bgn", "_br_flw_njv_bgn"),
|
||||
..._("\"", "_r_dqt_str_bgn", "_br_dqt_str_bgn", "_b_dqt_str_bgn"),
|
||||
..._("\"", "_r_dqt_str_end", "_br_dqt_str_end"),
|
||||
..._("'", "_r_sqt_str_bgn", "_br_sqt_str_bgn", "_b_sqt_str_bgn"),
|
||||
..._("'", "_r_sqt_str_end", "_br_sqt_str_end"),
|
||||
..._("*", "_r_als_bgn", "_br_als_bgn", "_b_als_bgn"),
|
||||
..._("&", "_r_acr_bgn", "_br_acr_bgn", "_b_acr_bgn"),
|
||||
});
|
||||
|
||||
function _(alias_value, ...rule_names) {
|
||||
const alias_content = {};
|
||||
if (typeof alias_value === "string") {
|
||||
alias_content.name = alias_value;
|
||||
} else if (Array.isArray(alias_value)) {
|
||||
alias_content.name = alias_value[0];
|
||||
alias_content.shallow = true;
|
||||
} else {
|
||||
throw new Error(`Unexpected value ${JSON.stringify(alias_value)}`);
|
||||
}
|
||||
const alias_map = {};
|
||||
for (const rule_name of rule_names) {
|
||||
alias_map[rule_name] = alias_content;
|
||||
}
|
||||
return alias_map;
|
||||
}
|
||||
|
||||
function global_alias(grammar_json, alias_map) {
|
||||
const new_rules = {};
|
||||
const new_grammar = { ...grammar_json, rules: new_rules };
|
||||
const checklist = Object.fromEntries(Object.entries(alias_map).map(([k, v]) => [k, 0]));
|
||||
for (const [rule_name, rule] of Object.entries(grammar_json.rules)) {
|
||||
new_rules[rule_name] = rule_name in alias_map && alias_map[rule_name].shallow
|
||||
? rule
|
||||
: recursive_alias(rule, alias_map, checklist);
|
||||
}
|
||||
for (const [rule_name, counter] of Object.entries(checklist)) {
|
||||
if (counter === 0) {
|
||||
console.warn(`warning: global_alias for ${JSON.stringify(rule_name)} is not used.`);
|
||||
}
|
||||
}
|
||||
return new_grammar;
|
||||
}
|
||||
|
||||
function recursive_alias(rule, alias_map, checklist) {
|
||||
switch (rule.type) {
|
||||
case "CHOICE":
|
||||
case "SEQ":
|
||||
return { ...rule, members: rule.members.map(member => recursive_alias(member, alias_map, checklist)) };
|
||||
case "REPEAT":
|
||||
case "REPEAT1":
|
||||
case "FIELD":
|
||||
case "PREC":
|
||||
case "PREC_RIGHT":
|
||||
return { ...rule, content: recursive_alias(rule.content, alias_map, checklist) };
|
||||
case "SYMBOL":
|
||||
if (rule.name in alias_map) {
|
||||
checklist[rule.name]++;
|
||||
const alias = alias_map[rule.name].name;
|
||||
return { type: "ALIAS", content: rule, named: /[a-z]/i.test(alias), value: alias };
|
||||
}
|
||||
case "BLANK":
|
||||
case "ALIAS":
|
||||
return rule;
|
||||
default:
|
||||
throw new Error(`Unexpected rule type ${JSON.stringify(rule.type)}`);
|
||||
}
|
||||
}
|
||||
@ -1,44 +0,0 @@
|
||||
{
|
||||
"name": "tree-sitter-yaml",
|
||||
"version": "0.5.0",
|
||||
"description": "YAML grammar for tree-sitter",
|
||||
"keywords": [
|
||||
"parser",
|
||||
"lexer"
|
||||
],
|
||||
"main": "bindings/node",
|
||||
"repository": "https://github.com/ikatyang/tree-sitter-yaml",
|
||||
"homepage": "https://github.com/ikatyang/tree-sitter-yaml#readme",
|
||||
"author": {
|
||||
"name": "Ika",
|
||||
"email": "ikatyang@gmail.com",
|
||||
"url": "https://github.com/ikatyang"
|
||||
},
|
||||
"license": "MIT",
|
||||
"scripts": {
|
||||
"test": "yarn tree-sitter test",
|
||||
"prepack": "bash ./scripts/update-schema.sh && yarn tree-sitter generate",
|
||||
"release": "standard-version --commit-all",
|
||||
"tree-sitter": "./tree-sitter/target/release/tree-sitter"
|
||||
},
|
||||
"standard-version": {
|
||||
"preset": "angular",
|
||||
"scripts": {
|
||||
"postbump": "rm -r docs && node scripts/generate-playground.js && git add docs"
|
||||
}
|
||||
},
|
||||
"dependencies": {
|
||||
"nan": "^2.14.0"
|
||||
},
|
||||
"devDependencies": {
|
||||
"get-stdin": "^8.0.0",
|
||||
"natural-orderby": "2.0.3",
|
||||
"standard-version": "7.0.0"
|
||||
},
|
||||
"files": [
|
||||
"/src/",
|
||||
"/bindings/node/",
|
||||
"/binding.gyp",
|
||||
"/grammar.js"
|
||||
]
|
||||
}
|
||||
@ -1,36 +0,0 @@
|
||||
const generatePlayground = require("../tree-sitter/script/generate-playground");
|
||||
|
||||
generatePlayground("docs", {
|
||||
name: "YAML",
|
||||
example: `
|
||||
---
|
||||
invoice: 34843
|
||||
date : 2001-01-23
|
||||
bill-to: &id001
|
||||
given : Chris
|
||||
family : Dumars
|
||||
address:
|
||||
lines: |
|
||||
458 Walkman Dr.
|
||||
Suite #292
|
||||
city : Royal Oak
|
||||
state : MI
|
||||
postal : 48046
|
||||
ship-to: *id001
|
||||
product:
|
||||
- sku : BL394D
|
||||
quantity : 4
|
||||
description : Basketball
|
||||
price : 450.00
|
||||
- sku : BL4438H
|
||||
quantity : 1
|
||||
description : Super Hoop
|
||||
price : 2392.00
|
||||
tax : 251.42
|
||||
total: 4443.52
|
||||
comments: >
|
||||
Late afternoon is best.
|
||||
Backup contact is Nancy
|
||||
Billsmer @ 338-4338.
|
||||
`.trim()
|
||||
});
|
||||
@ -1,4 +0,0 @@
|
||||
git submodule update --init
|
||||
cd tree-sitter
|
||||
./script/build-wasm
|
||||
cargo build --release
|
||||
@ -1,85 +0,0 @@
|
||||
const fs = require("fs");
|
||||
const path = require("path");
|
||||
const getStdin = require("get-stdin");
|
||||
|
||||
const STATE_FREEZE = -1;
|
||||
|
||||
getStdin().then(stdin => {
|
||||
const cases = extractCases(stdin);
|
||||
const enums = ["RS_STR"];
|
||||
const content = "switch (sch_stt) " + block([
|
||||
`case ${STATE_FREEZE}:\n break;`,
|
||||
cases
|
||||
.map(([key, { content }]) => `${(key === "default" ? "default:" : `case ${key}:`)}\n${indent(content)}`)
|
||||
.join("\n END_STATE();\n")
|
||||
.replace(/ADVANCE\((\d+)\);/g, (_, state) => {
|
||||
const stateCase = cases.find(([key]) => key === state);
|
||||
if (stateCase) {
|
||||
const [, { acceptToken }] = stateCase;
|
||||
if (acceptToken) {
|
||||
return `{${acceptToken} return ${state};}`;
|
||||
}
|
||||
}
|
||||
return `{*rlt_sch = RS_STR; return ${state};}`;
|
||||
})
|
||||
.replace("ACCEPT_TOKEN(ts_builtin_sym_end);", "assert(false);")
|
||||
.replace(/ACCEPT_TOKEN\((\w+)\);/g, (_, name) => {
|
||||
const newName = "RS_" + name.replace("sym_", "").toUpperCase();
|
||||
if (!enums.includes(newName)) {
|
||||
enums.push(newName);
|
||||
}
|
||||
return `*rlt_sch = ${newName};`;
|
||||
})
|
||||
.replace(/END_STATE\(\);/g, `break;`)
|
||||
.replace("return false;", `*rlt_sch = RS_STR;\n return ${STATE_FREEZE};`)
|
||||
.replace(/lookahead/g, "cur_chr"),
|
||||
]);
|
||||
fs.writeFileSync(
|
||||
path.resolve(__dirname, "../src/schema.generated.cc"),
|
||||
[
|
||||
`#include <cassert>`,
|
||||
`namespace tree_sitter_yaml {`,
|
||||
`const int8_t SCH_STT_FRZ = ${STATE_FREEZE};`,
|
||||
`enum ResultSchema ${block(enums.map((k) => `${k},`))};`,
|
||||
`int8_t adv_sch_stt(int8_t sch_stt, int32_t cur_chr, ResultSchema *rlt_sch) ${block([
|
||||
content,
|
||||
`if (cur_chr != '\\r' && cur_chr != '\\n' && cur_chr != ' ' && cur_chr != 0) *rlt_sch = RS_STR;`,
|
||||
`return ${STATE_FREEZE};`,
|
||||
])}`,
|
||||
`}`,
|
||||
].join("\n\n"),
|
||||
);
|
||||
});
|
||||
|
||||
function extractCases(stdin) {
|
||||
const MAIN_SIGNATURE = "static bool ts_lex(TSLexer *lexer, TSStateId state) {";
|
||||
const SWITCH_CASE = "switch (state) {\n";
|
||||
const startIndex = stdin.indexOf(SWITCH_CASE, stdin.indexOf(MAIN_SIGNATURE)) + SWITCH_CASE.length;
|
||||
const endIndex = stdin.indexOf("}\n}", startIndex);
|
||||
const content = stdin.slice(startIndex, endIndex).replace(/^\s*if \(eof\).+\n/mg, "").trimEnd();
|
||||
return dedent(dedent(content)).split("END_STATE();").map(text => {
|
||||
const index = text.indexOf(":\n");
|
||||
const key = text.slice(0, index).trim().replace(/^case /, "");
|
||||
const content = dedent(text.slice(index + 2)).trim();
|
||||
const matchAcceptToken = content.match(/^ACCEPT_TOKEN\(\w+\);/);
|
||||
const acceptToken = matchAcceptToken && matchAcceptToken[0];
|
||||
const hasAcceptTokenOnly = acceptToken && acceptToken.length === content.length;
|
||||
return [key, { content, acceptToken, hasAcceptTokenOnly }];
|
||||
});
|
||||
}
|
||||
|
||||
function block(contents) {
|
||||
return `{\n${indent(contents)}\n}`;
|
||||
}
|
||||
|
||||
function lines(contents) {
|
||||
return [].concat(contents).join("\n").split("\n");
|
||||
}
|
||||
|
||||
function indent(contents) {
|
||||
return lines(contents).map(x => " ".repeat(2) + x).join("\n");
|
||||
}
|
||||
|
||||
function dedent(contents) {
|
||||
return lines(contents).map(x => x.replace(/^ /mg, "")).join("\n");
|
||||
}
|
||||
@ -1,11 +0,0 @@
|
||||
cd $(dirname "$0")/..
|
||||
|
||||
ROOT_DIR=$PWD
|
||||
TREE_SITTER_CLI="$ROOT_DIR/tree-sitter/target/release/tree-sitter"
|
||||
SCHEMA_GRAMMAR="$ROOT_DIR/grammar-schema.js"
|
||||
TEMP_DIR=$(mktemp -d)
|
||||
|
||||
cd $TEMP_DIR
|
||||
cp $SCHEMA_GRAMMAR grammar.js
|
||||
$TREE_SITTER_CLI generate
|
||||
cat $TEMP_DIR/src/parser.c | node $ROOT_DIR/scripts/update-schema.js
|
||||
@ -1,51 +0,0 @@
|
||||
const fs = require("fs");
|
||||
const { orderBy } = require("natural-orderby");
|
||||
const path = require("path");
|
||||
|
||||
const testSuiteDirname = "./yaml-test-suite";
|
||||
const whitelistForValidTest = [
|
||||
"Duplicate YAML directive", // semantic error
|
||||
"Missing space in YAML directive", // https://github.com/yaml/yaml-test-suite/issues/38
|
||||
"Tag shorthand used in documents but only defined in the first", // semantic error
|
||||
];
|
||||
|
||||
const testCases = {};
|
||||
const testTagsDirname = path.join(testSuiteDirname, "tags");
|
||||
for (const tagName of fs.readdirSync(testTagsDirname)) {
|
||||
const testTagDirname = path.join(testTagsDirname, tagName);
|
||||
for (const testCaseId of fs.readdirSync(testTagDirname)) {
|
||||
const dirname = path.join(testSuiteDirname, testCaseId);
|
||||
const title = fs.readFileSync(path.join(dirname, "==="), "utf8").trim();
|
||||
const content = fs.readFileSync(path.join(dirname, "in.yaml"), "utf8");
|
||||
const isInvalid =
|
||||
fs.existsSync(path.join(dirname, "error")) &&
|
||||
whitelistForValidTest.indexOf(title) === -1;
|
||||
testCases[isInvalid ? `${title} [INVALID]` : title] = {
|
||||
input: content,
|
||||
output: "()",
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
const finalTestCases = {};
|
||||
for (const title of orderBy(Object.keys(testCases))) {
|
||||
finalTestCases[title] = testCases[title];
|
||||
}
|
||||
|
||||
fs.writeFileSync(
|
||||
"./corpus/spec.txt",
|
||||
Object.entries(finalTestCases)
|
||||
.map(([title, { input, output }]) =>
|
||||
[
|
||||
"=".repeat(80),
|
||||
title,
|
||||
"=".repeat(80),
|
||||
input,
|
||||
"-".repeat(80),
|
||||
"",
|
||||
output.trim(),
|
||||
""
|
||||
].join("\n")
|
||||
)
|
||||
.join("\n")
|
||||
);
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,542 +0,0 @@
|
||||
[
|
||||
{
|
||||
"type": "alias",
|
||||
"named": true,
|
||||
"fields": {},
|
||||
"children": {
|
||||
"multiple": false,
|
||||
"required": true,
|
||||
"types": [
|
||||
{
|
||||
"type": "alias_name",
|
||||
"named": true
|
||||
}
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "anchor",
|
||||
"named": true,
|
||||
"fields": {},
|
||||
"children": {
|
||||
"multiple": false,
|
||||
"required": true,
|
||||
"types": [
|
||||
{
|
||||
"type": "anchor_name",
|
||||
"named": true
|
||||
}
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "block_mapping",
|
||||
"named": true,
|
||||
"fields": {},
|
||||
"children": {
|
||||
"multiple": true,
|
||||
"required": true,
|
||||
"types": [
|
||||
{
|
||||
"type": "block_mapping_pair",
|
||||
"named": true
|
||||
}
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "block_mapping_pair",
|
||||
"named": true,
|
||||
"fields": {
|
||||
"key": {
|
||||
"multiple": false,
|
||||
"required": false,
|
||||
"types": [
|
||||
{
|
||||
"type": "block_node",
|
||||
"named": true
|
||||
},
|
||||
{
|
||||
"type": "flow_node",
|
||||
"named": true
|
||||
}
|
||||
]
|
||||
},
|
||||
"value": {
|
||||
"multiple": false,
|
||||
"required": false,
|
||||
"types": [
|
||||
{
|
||||
"type": "block_node",
|
||||
"named": true
|
||||
},
|
||||
{
|
||||
"type": "flow_node",
|
||||
"named": true
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "block_node",
|
||||
"named": true,
|
||||
"fields": {},
|
||||
"children": {
|
||||
"multiple": true,
|
||||
"required": true,
|
||||
"types": [
|
||||
{
|
||||
"type": "anchor",
|
||||
"named": true
|
||||
},
|
||||
{
|
||||
"type": "block_mapping",
|
||||
"named": true
|
||||
},
|
||||
{
|
||||
"type": "block_scalar",
|
||||
"named": true
|
||||
},
|
||||
{
|
||||
"type": "block_sequence",
|
||||
"named": true
|
||||
},
|
||||
{
|
||||
"type": "tag",
|
||||
"named": true
|
||||
}
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "block_scalar",
|
||||
"named": true,
|
||||
"fields": {}
|
||||
},
|
||||
{
|
||||
"type": "block_sequence",
|
||||
"named": true,
|
||||
"fields": {},
|
||||
"children": {
|
||||
"multiple": true,
|
||||
"required": true,
|
||||
"types": [
|
||||
{
|
||||
"type": "block_sequence_item",
|
||||
"named": true
|
||||
}
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "block_sequence_item",
|
||||
"named": true,
|
||||
"fields": {},
|
||||
"children": {
|
||||
"multiple": false,
|
||||
"required": false,
|
||||
"types": [
|
||||
{
|
||||
"type": "block_node",
|
||||
"named": true
|
||||
},
|
||||
{
|
||||
"type": "flow_node",
|
||||
"named": true
|
||||
}
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "document",
|
||||
"named": true,
|
||||
"fields": {},
|
||||
"children": {
|
||||
"multiple": true,
|
||||
"required": false,
|
||||
"types": [
|
||||
{
|
||||
"type": "block_node",
|
||||
"named": true
|
||||
},
|
||||
{
|
||||
"type": "flow_node",
|
||||
"named": true
|
||||
},
|
||||
{
|
||||
"type": "reserved_directive",
|
||||
"named": true
|
||||
},
|
||||
{
|
||||
"type": "tag_directive",
|
||||
"named": true
|
||||
},
|
||||
{
|
||||
"type": "yaml_directive",
|
||||
"named": true
|
||||
}
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "double_quote_scalar",
|
||||
"named": true,
|
||||
"fields": {},
|
||||
"children": {
|
||||
"multiple": true,
|
||||
"required": false,
|
||||
"types": [
|
||||
{
|
||||
"type": "escape_sequence",
|
||||
"named": true
|
||||
}
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "flow_mapping",
|
||||
"named": true,
|
||||
"fields": {},
|
||||
"children": {
|
||||
"multiple": true,
|
||||
"required": false,
|
||||
"types": [
|
||||
{
|
||||
"type": "flow_node",
|
||||
"named": true
|
||||
},
|
||||
{
|
||||
"type": "flow_pair",
|
||||
"named": true
|
||||
}
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "flow_node",
|
||||
"named": true,
|
||||
"fields": {},
|
||||
"children": {
|
||||
"multiple": true,
|
||||
"required": true,
|
||||
"types": [
|
||||
{
|
||||
"type": "alias",
|
||||
"named": true
|
||||
},
|
||||
{
|
||||
"type": "anchor",
|
||||
"named": true
|
||||
},
|
||||
{
|
||||
"type": "double_quote_scalar",
|
||||
"named": true
|
||||
},
|
||||
{
|
||||
"type": "flow_mapping",
|
||||
"named": true
|
||||
},
|
||||
{
|
||||
"type": "flow_sequence",
|
||||
"named": true
|
||||
},
|
||||
{
|
||||
"type": "plain_scalar",
|
||||
"named": true
|
||||
},
|
||||
{
|
||||
"type": "single_quote_scalar",
|
||||
"named": true
|
||||
},
|
||||
{
|
||||
"type": "tag",
|
||||
"named": true
|
||||
}
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "flow_pair",
|
||||
"named": true,
|
||||
"fields": {
|
||||
"key": {
|
||||
"multiple": false,
|
||||
"required": false,
|
||||
"types": [
|
||||
{
|
||||
"type": "flow_node",
|
||||
"named": true
|
||||
}
|
||||
]
|
||||
},
|
||||
"value": {
|
||||
"multiple": false,
|
||||
"required": false,
|
||||
"types": [
|
||||
{
|
||||
"type": "flow_node",
|
||||
"named": true
|
||||
}
|
||||
]
|
||||
}
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "flow_sequence",
|
||||
"named": true,
|
||||
"fields": {},
|
||||
"children": {
|
||||
"multiple": true,
|
||||
"required": false,
|
||||
"types": [
|
||||
{
|
||||
"type": "flow_node",
|
||||
"named": true
|
||||
},
|
||||
{
|
||||
"type": "flow_pair",
|
||||
"named": true
|
||||
}
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "plain_scalar",
|
||||
"named": true,
|
||||
"fields": {},
|
||||
"children": {
|
||||
"multiple": false,
|
||||
"required": true,
|
||||
"types": [
|
||||
{
|
||||
"type": "boolean_scalar",
|
||||
"named": true
|
||||
},
|
||||
{
|
||||
"type": "float_scalar",
|
||||
"named": true
|
||||
},
|
||||
{
|
||||
"type": "integer_scalar",
|
||||
"named": true
|
||||
},
|
||||
{
|
||||
"type": "null_scalar",
|
||||
"named": true
|
||||
},
|
||||
{
|
||||
"type": "string_scalar",
|
||||
"named": true
|
||||
}
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "reserved_directive",
|
||||
"named": true,
|
||||
"fields": {},
|
||||
"children": {
|
||||
"multiple": true,
|
||||
"required": true,
|
||||
"types": [
|
||||
{
|
||||
"type": "directive_name",
|
||||
"named": true
|
||||
},
|
||||
{
|
||||
"type": "directive_parameter",
|
||||
"named": true
|
||||
}
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "single_quote_scalar",
|
||||
"named": true,
|
||||
"fields": {},
|
||||
"children": {
|
||||
"multiple": true,
|
||||
"required": false,
|
||||
"types": [
|
||||
{
|
||||
"type": "escape_sequence",
|
||||
"named": true
|
||||
}
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "stream",
|
||||
"named": true,
|
||||
"fields": {},
|
||||
"children": {
|
||||
"multiple": true,
|
||||
"required": false,
|
||||
"types": [
|
||||
{
|
||||
"type": "document",
|
||||
"named": true
|
||||
}
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "tag_directive",
|
||||
"named": true,
|
||||
"fields": {},
|
||||
"children": {
|
||||
"multiple": true,
|
||||
"required": true,
|
||||
"types": [
|
||||
{
|
||||
"type": "tag_handle",
|
||||
"named": true
|
||||
},
|
||||
{
|
||||
"type": "tag_prefix",
|
||||
"named": true
|
||||
}
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "yaml_directive",
|
||||
"named": true,
|
||||
"fields": {},
|
||||
"children": {
|
||||
"multiple": false,
|
||||
"required": true,
|
||||
"types": [
|
||||
{
|
||||
"type": "yaml_version",
|
||||
"named": true
|
||||
}
|
||||
]
|
||||
}
|
||||
},
|
||||
{
|
||||
"type": "\"",
|
||||
"named": false
|
||||
},
|
||||
{
|
||||
"type": "&",
|
||||
"named": false
|
||||
},
|
||||
{
|
||||
"type": "'",
|
||||
"named": false
|
||||
},
|
||||
{
|
||||
"type": "*",
|
||||
"named": false
|
||||
},
|
||||
{
|
||||
"type": ",",
|
||||
"named": false
|
||||
},
|
||||
{
|
||||
"type": "-",
|
||||
"named": false
|
||||
},
|
||||
{
|
||||
"type": "---",
|
||||
"named": false
|
||||
},
|
||||
{
|
||||
"type": "...",
|
||||
"named": false
|
||||
},
|
||||
{
|
||||
"type": ":",
|
||||
"named": false
|
||||
},
|
||||
{
|
||||
"type": ">",
|
||||
"named": false
|
||||
},
|
||||
{
|
||||
"type": "?",
|
||||
"named": false
|
||||
},
|
||||
{
|
||||
"type": "[",
|
||||
"named": false
|
||||
},
|
||||
{
|
||||
"type": "]",
|
||||
"named": false
|
||||
},
|
||||
{
|
||||
"type": "alias_name",
|
||||
"named": true
|
||||
},
|
||||
{
|
||||
"type": "anchor_name",
|
||||
"named": true
|
||||
},
|
||||
{
|
||||
"type": "boolean_scalar",
|
||||
"named": true
|
||||
},
|
||||
{
|
||||
"type": "comment",
|
||||
"named": true
|
||||
},
|
||||
{
|
||||
"type": "directive_name",
|
||||
"named": true
|
||||
},
|
||||
{
|
||||
"type": "directive_parameter",
|
||||
"named": true
|
||||
},
|
||||
{
|
||||
"type": "escape_sequence",
|
||||
"named": true
|
||||
},
|
||||
{
|
||||
"type": "float_scalar",
|
||||
"named": true
|
||||
},
|
||||
{
|
||||
"type": "integer_scalar",
|
||||
"named": true
|
||||
},
|
||||
{
|
||||
"type": "null_scalar",
|
||||
"named": true
|
||||
},
|
||||
{
|
||||
"type": "string_scalar",
|
||||
"named": true
|
||||
},
|
||||
{
|
||||
"type": "tag",
|
||||
"named": true
|
||||
},
|
||||
{
|
||||
"type": "tag_handle",
|
||||
"named": true
|
||||
},
|
||||
{
|
||||
"type": "tag_prefix",
|
||||
"named": true
|
||||
},
|
||||
{
|
||||
"type": "yaml_version",
|
||||
"named": true
|
||||
},
|
||||
{
|
||||
"type": "{",
|
||||
"named": false
|
||||
},
|
||||
{
|
||||
"type": "|",
|
||||
"named": false
|
||||
},
|
||||
{
|
||||
"type": "}",
|
||||
"named": false
|
||||
}
|
||||
]
|
||||
File diff suppressed because it is too large
Load Diff
@ -1,979 +0,0 @@
|
||||
#include <tree_sitter/parser.h>
|
||||
#include <vector>
|
||||
|
||||
// tree-sitter does not support multiple files for external scanner
|
||||
#include "./schema.generated.cc"
|
||||
|
||||
namespace {
|
||||
|
||||
using std::vector;
|
||||
using namespace tree_sitter_yaml;
|
||||
|
||||
enum TokenType {
|
||||
END_OF_FILE,
|
||||
|
||||
S_DIR_YML_BGN, R_DIR_YML_VER,
|
||||
S_DIR_TAG_BGN, R_DIR_TAG_HDL, R_DIR_TAG_PFX,
|
||||
S_DIR_RSV_BGN, R_DIR_RSV_PRM,
|
||||
S_DRS_END,
|
||||
S_DOC_END,
|
||||
R_BLK_SEQ_BGN, BR_BLK_SEQ_BGN, B_BLK_SEQ_BGN,
|
||||
R_BLK_KEY_BGN, BR_BLK_KEY_BGN, B_BLK_KEY_BGN,
|
||||
R_BLK_VAL_BGN, BR_BLK_VAL_BGN, B_BLK_VAL_BGN,
|
||||
R_BLK_IMP_BGN,
|
||||
R_BLK_LIT_BGN, BR_BLK_LIT_BGN,
|
||||
R_BLK_FLD_BGN, BR_BLK_FLD_BGN,
|
||||
BR_BLK_STR_CTN,
|
||||
R_FLW_SEQ_BGN, BR_FLW_SEQ_BGN, B_FLW_SEQ_BGN,
|
||||
R_FLW_SEQ_END, BR_FLW_SEQ_END,
|
||||
R_FLW_MAP_BGN, BR_FLW_MAP_BGN, B_FLW_MAP_BGN,
|
||||
R_FLW_MAP_END, BR_FLW_MAP_END,
|
||||
R_FLW_SEP_BGN, BR_FLW_SEP_BGN,
|
||||
R_FLW_KEY_BGN, BR_FLW_KEY_BGN,
|
||||
R_FLW_JSV_BGN, BR_FLW_JSV_BGN,
|
||||
R_FLW_NJV_BGN, BR_FLW_NJV_BGN,
|
||||
R_DQT_STR_BGN, BR_DQT_STR_BGN, B_DQT_STR_BGN,
|
||||
R_DQT_STR_CTN, BR_DQT_STR_CTN,
|
||||
R_DQT_ESC_NWL, BR_DQT_ESC_NWL,
|
||||
R_DQT_ESC_SEQ, BR_DQT_ESC_SEQ,
|
||||
R_DQT_STR_END, BR_DQT_STR_END,
|
||||
R_SQT_STR_BGN, BR_SQT_STR_BGN, B_SQT_STR_BGN,
|
||||
R_SQT_STR_CTN, BR_SQT_STR_CTN,
|
||||
R_SQT_ESC_SQT, BR_SQT_ESC_SQT,
|
||||
R_SQT_STR_END, BR_SQT_STR_END,
|
||||
|
||||
R_SGL_PLN_NUL_BLK, BR_SGL_PLN_NUL_BLK, B_SGL_PLN_NUL_BLK, R_SGL_PLN_NUL_FLW, BR_SGL_PLN_NUL_FLW,
|
||||
R_SGL_PLN_BOL_BLK, BR_SGL_PLN_BOL_BLK, B_SGL_PLN_BOL_BLK, R_SGL_PLN_BOL_FLW, BR_SGL_PLN_BOL_FLW,
|
||||
R_SGL_PLN_INT_BLK, BR_SGL_PLN_INT_BLK, B_SGL_PLN_INT_BLK, R_SGL_PLN_INT_FLW, BR_SGL_PLN_INT_FLW,
|
||||
R_SGL_PLN_FLT_BLK, BR_SGL_PLN_FLT_BLK, B_SGL_PLN_FLT_BLK, R_SGL_PLN_FLT_FLW, BR_SGL_PLN_FLT_FLW,
|
||||
R_SGL_PLN_STR_BLK, BR_SGL_PLN_STR_BLK, B_SGL_PLN_STR_BLK, R_SGL_PLN_STR_FLW, BR_SGL_PLN_STR_FLW,
|
||||
|
||||
R_MTL_PLN_STR_BLK, BR_MTL_PLN_STR_BLK,
|
||||
R_MTL_PLN_STR_FLW, BR_MTL_PLN_STR_FLW,
|
||||
|
||||
R_TAG, BR_TAG, B_TAG,
|
||||
R_ACR_BGN, BR_ACR_BGN, B_ACR_BGN, R_ACR_CTN,
|
||||
R_ALS_BGN, BR_ALS_BGN, B_ALS_BGN, R_ALS_CTN,
|
||||
|
||||
BL,
|
||||
COMMENT,
|
||||
};
|
||||
|
||||
#define ADV() adv(lexer)
|
||||
#define ADV_NWL() adv_nwl(lexer)
|
||||
#define SKP() skp(lexer)
|
||||
#define SKP_NWL() skp_nwl(lexer)
|
||||
#define MRK_END() mrk_end(lexer)
|
||||
#define LKA lexer->lookahead
|
||||
#define VLD valid_symbols
|
||||
|
||||
#define SCN_SUCC 1
|
||||
#define SCN_STOP 0
|
||||
#define SCN_FAIL -1
|
||||
|
||||
#define IND_ROT 'r'
|
||||
#define IND_MAP 'm'
|
||||
#define IND_SEQ 'q'
|
||||
#define IND_STR 's'
|
||||
|
||||
#define RET_SYM(RESULT_SYMBOL) { \
|
||||
flush(); \
|
||||
lexer->result_symbol = RESULT_SYMBOL; \
|
||||
return true; \
|
||||
}
|
||||
|
||||
#define POP_IND() { \
|
||||
/* incorrect status caused by error recovering */ \
|
||||
if (ind_typ_stk.size() == 1) { \
|
||||
return false; \
|
||||
} \
|
||||
pop_ind(); \
|
||||
}
|
||||
#define PUSH_IND(TYP, LEN) push_ind(TYP, LEN)
|
||||
#define PUSH_BGN_IND(TYP) { \
|
||||
if (has_tab_ind) return false; \
|
||||
push_ind(TYP, bgn_col); \
|
||||
}
|
||||
#define MAY_PUSH_IMP_IND(TYP) { \
|
||||
if (cur_ind != blk_imp_col) { \
|
||||
if (blk_imp_tab) return false; \
|
||||
push_ind(IND_MAP, blk_imp_col); \
|
||||
} \
|
||||
}
|
||||
#define MAY_PUSH_SPC_SEQ_IND() { \
|
||||
if (cur_ind_typ == IND_MAP) { \
|
||||
push_ind(IND_SEQ, bgn_col); \
|
||||
} \
|
||||
}
|
||||
#define MAY_UPD_IMP_COL() { \
|
||||
if (blk_imp_row != bgn_row) { \
|
||||
blk_imp_row = bgn_row; \
|
||||
blk_imp_col = bgn_col; \
|
||||
blk_imp_tab = has_tab_ind; \
|
||||
} \
|
||||
}
|
||||
#define UPD_SCH_STT() { \
|
||||
sch_stt = adv_sch_stt(sch_stt, cur_chr, &rlt_sch); \
|
||||
}
|
||||
#define SGL_PLN_SYM(POS, CTX) ( \
|
||||
rlt_sch == RS_NUL ? POS##_SGL_PLN_NUL_##CTX : \
|
||||
rlt_sch == RS_BOL ? POS##_SGL_PLN_BOL_##CTX : \
|
||||
rlt_sch == RS_INT ? POS##_SGL_PLN_INT_##CTX : \
|
||||
rlt_sch == RS_FLT ? POS##_SGL_PLN_FLT_##CTX : \
|
||||
POS##_SGL_PLN_STR_##CTX \
|
||||
)
|
||||
|
||||
struct Scanner {
|
||||
int16_t row;
|
||||
int16_t col;
|
||||
int16_t blk_imp_row;
|
||||
int16_t blk_imp_col;
|
||||
int16_t blk_imp_tab;
|
||||
vector<int16_t> ind_typ_stk;
|
||||
vector<int16_t> ind_len_stk;
|
||||
|
||||
// temp
|
||||
int16_t end_row;
|
||||
int16_t end_col;
|
||||
int16_t cur_row;
|
||||
int16_t cur_col;
|
||||
int32_t cur_chr;
|
||||
int8_t sch_stt;
|
||||
ResultSchema rlt_sch;
|
||||
|
||||
Scanner() {
|
||||
deserialize(NULL, 0);
|
||||
}
|
||||
|
||||
unsigned serialize(char *buffer) {
|
||||
size_t i = 0;
|
||||
buffer[i++] = row;
|
||||
buffer[i++] = col;
|
||||
buffer[i++] = blk_imp_row;
|
||||
buffer[i++] = blk_imp_col;
|
||||
buffer[i++] = blk_imp_tab;
|
||||
vector<int16_t>::iterator
|
||||
typ_itr = ind_typ_stk.begin() + 1,
|
||||
typ_end = ind_typ_stk.end(),
|
||||
len_itr = ind_len_stk.begin() + 1;
|
||||
for (; typ_itr != typ_end && i < TREE_SITTER_SERIALIZATION_BUFFER_SIZE; ++typ_itr, ++len_itr) {
|
||||
buffer[i++] = *typ_itr;
|
||||
buffer[i++] = *len_itr;
|
||||
}
|
||||
return i;
|
||||
}
|
||||
|
||||
void deserialize(const char *buffer, unsigned length) {
|
||||
row = 0;
|
||||
col = 0;
|
||||
blk_imp_row = -1;
|
||||
blk_imp_col = -1;
|
||||
blk_imp_tab = 0;
|
||||
ind_typ_stk.clear();
|
||||
ind_typ_stk.push_back(IND_ROT);
|
||||
ind_len_stk.clear();
|
||||
ind_len_stk.push_back(-1);
|
||||
if (length > 0) {
|
||||
size_t i = 0;
|
||||
row = buffer[i++];
|
||||
col = buffer[i++];
|
||||
blk_imp_row = buffer[i++];
|
||||
blk_imp_col = buffer[i++];
|
||||
blk_imp_tab = buffer[i++];
|
||||
while (i < length) {
|
||||
ind_typ_stk.push_back(buffer[i++]);
|
||||
ind_len_stk.push_back(buffer[i++]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void adv(TSLexer *lexer) {
|
||||
cur_col++;
|
||||
cur_chr = lexer->lookahead;
|
||||
lexer->advance(lexer, false);
|
||||
}
|
||||
|
||||
void adv_nwl(TSLexer *lexer) {
|
||||
cur_row++;
|
||||
cur_col = 0;
|
||||
cur_chr = lexer->lookahead;
|
||||
lexer->advance(lexer, false);
|
||||
}
|
||||
|
||||
void skp(TSLexer *lexer) {
|
||||
cur_col++;
|
||||
cur_chr = lexer->lookahead;
|
||||
lexer->advance(lexer, true);
|
||||
}
|
||||
|
||||
void skp_nwl(TSLexer *lexer) {
|
||||
cur_row++;
|
||||
cur_col = 0;
|
||||
cur_chr = lexer->lookahead;
|
||||
lexer->advance(lexer, true);
|
||||
}
|
||||
|
||||
void mrk_end(TSLexer *lexer) {
|
||||
end_row = cur_row;
|
||||
end_col = cur_col;
|
||||
lexer->mark_end(lexer);
|
||||
}
|
||||
|
||||
void init() {
|
||||
cur_row = row;
|
||||
cur_col = col;
|
||||
cur_chr = 0;
|
||||
sch_stt = 0;
|
||||
rlt_sch = RS_STR;
|
||||
}
|
||||
|
||||
void flush() {
|
||||
row = end_row;
|
||||
col = end_col;
|
||||
}
|
||||
|
||||
void pop_ind() {
|
||||
ind_len_stk.pop_back();
|
||||
ind_typ_stk.pop_back();
|
||||
}
|
||||
|
||||
void push_ind(int16_t typ, int16_t len) {
|
||||
ind_len_stk.push_back(len);
|
||||
ind_typ_stk.push_back(typ);
|
||||
}
|
||||
|
||||
bool is_wsp(int32_t c) {
|
||||
return c == ' ' || c == '\t';
|
||||
}
|
||||
|
||||
bool is_nwl(int32_t c) {
|
||||
return c == '\r' || c == '\n';
|
||||
}
|
||||
|
||||
bool is_wht(int32_t c) {
|
||||
return is_wsp(c) || is_nwl(c) || c == 0;
|
||||
}
|
||||
|
||||
bool is_ns_dec_digit(int32_t c) {
|
||||
return c >= '0' && c <= '9';
|
||||
}
|
||||
|
||||
bool is_ns_hex_digit(int32_t c) {
|
||||
return is_ns_dec_digit(c)
|
||||
|| (c >= 'a' && c <= 'f')
|
||||
|| (c >= 'A' && c <= 'F');
|
||||
}
|
||||
|
||||
bool is_ns_word_char(int32_t c) {
|
||||
return c == '-'
|
||||
|| (c >= '0' && c <= '9')
|
||||
|| (c >= 'a' && c <= 'z')
|
||||
|| (c >= 'A' && c <= 'Z');
|
||||
}
|
||||
|
||||
bool is_nb_json(int32_t c) {
|
||||
return c == 0x09 || (c >= 0x20 && c <= 0x10ffff);
|
||||
}
|
||||
|
||||
bool is_nb_double_char(int32_t c) {
|
||||
return is_nb_json(c) && c != '\\' && c != '"';
|
||||
}
|
||||
|
||||
bool is_nb_single_char(int32_t c) {
|
||||
return is_nb_json(c) && c != '\'';
|
||||
}
|
||||
|
||||
bool is_ns_char(int32_t c) {
|
||||
return (c >= 0x21 && c <= 0x7e)
|
||||
|| c == 0x85
|
||||
|| (c >= 0xa0 && c <= 0xd7ff)
|
||||
|| (c >= 0xe000 && c <= 0xfefe)
|
||||
|| (c >= 0xff00 && c <= 0xfffd)
|
||||
|| (c >= 0x10000 && c <= 0x10ffff);
|
||||
}
|
||||
|
||||
bool is_c_indicator(int32_t c) {
|
||||
return c == '-' || c == '?' || c == ':' || c == ',' || c == '[' || c == ']' || c == '{' || c == '}'
|
||||
|| c == '#' || c == '&' || c == '*' || c == '!' || c == '|' || c == '>' || c == '\'' || c == '"'
|
||||
|| c == '%' || c == '@' || c == '`';
|
||||
}
|
||||
|
||||
bool is_c_flow_indicator(int32_t c) {
|
||||
return c == ',' || c == '[' || c == ']' || c == '{' || c == '}';
|
||||
}
|
||||
|
||||
bool is_plain_safe_in_block(int32_t c) {
|
||||
return is_ns_char(c);
|
||||
}
|
||||
|
||||
bool is_plain_safe_in_flow(int32_t c) {
|
||||
return is_ns_char(c) && !is_c_flow_indicator(c);
|
||||
}
|
||||
|
||||
bool is_ns_uri_char(int32_t c) {
|
||||
return is_ns_word_char(c)
|
||||
|| c == '#' || c == ';' || c == '/' || c == '?' || c == ':' || c == '@' || c == '&'
|
||||
|| c == '=' || c == '+' || c == '$' || c == ',' || c == '_' || c == '.' || c == '!'
|
||||
|| c == '~' || c == '*' || c == '\'' || c == '(' || c == ')' || c == '[' || c == ']';
|
||||
}
|
||||
|
||||
bool is_ns_tag_char(int32_t c) {
|
||||
return is_ns_word_char(c)
|
||||
|| c == '#' || c == ';' || c == '/' || c == '?' || c == ':' || c == '@' || c == '&'
|
||||
|| c == '=' || c == '+' || c == '$' || c == '_' || c == '.'
|
||||
|| c == '~' || c == '*' || c == '\'' || c == '(' || c == ')';
|
||||
}
|
||||
|
||||
bool is_ns_anchor_char(int32_t c) {
|
||||
return is_ns_char(c) && !is_c_flow_indicator(c);
|
||||
}
|
||||
|
||||
char scn_uri_esc(TSLexer *lexer) {
|
||||
if (LKA != '%') return SCN_STOP;
|
||||
MRK_END();
|
||||
ADV();
|
||||
if (!is_ns_hex_digit(LKA)) return SCN_FAIL;
|
||||
ADV();
|
||||
if (!is_ns_hex_digit(LKA)) return SCN_FAIL;
|
||||
ADV();
|
||||
return SCN_SUCC;
|
||||
}
|
||||
|
||||
char scn_ns_uri_char(TSLexer *lexer) {
|
||||
if (is_ns_uri_char(LKA)) {ADV(); return SCN_SUCC;}
|
||||
return scn_uri_esc(lexer);
|
||||
}
|
||||
|
||||
char scn_ns_tag_char(TSLexer *lexer) {
|
||||
if (is_ns_tag_char(LKA)) {ADV(); return SCN_SUCC;}
|
||||
return scn_uri_esc(lexer);
|
||||
}
|
||||
|
||||
bool scn_dir_bgn(TSLexer *lexer) {
|
||||
ADV();
|
||||
if (LKA == 'Y') {
|
||||
ADV();
|
||||
if (LKA == 'A') {
|
||||
ADV();
|
||||
if (LKA == 'M') {
|
||||
ADV();
|
||||
if (LKA == 'L') {
|
||||
ADV();
|
||||
if (is_wht(LKA)) {
|
||||
MRK_END();
|
||||
RET_SYM(S_DIR_YML_BGN);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} else if (LKA == 'T') {
|
||||
ADV();
|
||||
if (LKA == 'A') {
|
||||
ADV();
|
||||
if (LKA == 'G') {
|
||||
ADV();
|
||||
if (is_wht(LKA)) {
|
||||
MRK_END();
|
||||
RET_SYM(S_DIR_TAG_BGN);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
for (;;) {
|
||||
if (!is_ns_char(LKA)) break;
|
||||
ADV();
|
||||
}
|
||||
if (cur_col > 1 && is_wht(LKA)) {
|
||||
MRK_END();
|
||||
RET_SYM(S_DIR_RSV_BGN);
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool scn_dir_yml_ver(TSLexer *lexer, TSSymbol result_symbol) {
|
||||
uint16_t n1 = 0;
|
||||
uint16_t n2 = 0;
|
||||
while (is_ns_dec_digit(LKA)) {ADV();n1++;}
|
||||
if (LKA != '.') return false;
|
||||
ADV();
|
||||
while (is_ns_dec_digit(LKA)) {ADV();n2++;}
|
||||
if (n1 == 0 || n2 == 0) return false;
|
||||
MRK_END();
|
||||
RET_SYM(result_symbol);
|
||||
}
|
||||
|
||||
bool scn_tag_hdl_tal(TSLexer *lexer) {
|
||||
if (LKA == '!') {ADV();return true;}
|
||||
uint16_t n = 0;
|
||||
while (is_ns_word_char(LKA)) {ADV();n++;}
|
||||
if (n == 0) return true;
|
||||
if (LKA == '!') {ADV();return true;}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool scn_dir_tag_hdl(TSLexer *lexer, TSSymbol result_symbol) {
|
||||
if (LKA == '!') {
|
||||
ADV();
|
||||
if (scn_tag_hdl_tal(lexer)) {MRK_END();RET_SYM(result_symbol);}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool scn_dir_tag_pfx(TSLexer *lexer, TSSymbol result_symbol) {
|
||||
if (LKA == '!') ADV();
|
||||
else if (scn_ns_tag_char(lexer) == SCN_SUCC);
|
||||
else return false;
|
||||
for (;;) {
|
||||
switch (scn_ns_uri_char(lexer)) {
|
||||
case SCN_STOP:
|
||||
MRK_END();
|
||||
case SCN_FAIL:
|
||||
RET_SYM(result_symbol);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool scn_dir_rsv_prm(TSLexer *lexer, TSSymbol result_symbol) {
|
||||
if (!is_ns_char(LKA)) return false;
|
||||
ADV();
|
||||
while (is_ns_char(LKA)) ADV();
|
||||
MRK_END();
|
||||
RET_SYM(result_symbol);
|
||||
}
|
||||
|
||||
bool scn_tag(TSLexer *lexer, TSSymbol result_symbol) {
|
||||
if (LKA != '!') return false;
|
||||
ADV();
|
||||
if (is_wht(LKA)) {MRK_END();RET_SYM(result_symbol);}
|
||||
if (LKA == '<') {
|
||||
ADV();
|
||||
if (scn_ns_uri_char(lexer) != SCN_SUCC) return false;
|
||||
for (;;) {
|
||||
switch (scn_ns_uri_char(lexer)) {
|
||||
case SCN_STOP:
|
||||
if (LKA == '>') {
|
||||
ADV();
|
||||
MRK_END();
|
||||
RET_SYM(result_symbol);
|
||||
}
|
||||
case SCN_FAIL:
|
||||
return false;
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if (scn_tag_hdl_tal(lexer) && scn_ns_tag_char(lexer) != SCN_SUCC) return false;
|
||||
for (;;) {
|
||||
switch (scn_ns_tag_char(lexer)) {
|
||||
case SCN_STOP:
|
||||
MRK_END();
|
||||
case SCN_FAIL:
|
||||
RET_SYM(result_symbol);
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
bool scn_acr_bgn(TSLexer *lexer, TSSymbol result_symbol) {
|
||||
if (LKA != '&') return false;
|
||||
ADV();
|
||||
if (!is_ns_anchor_char(LKA)) return false;
|
||||
MRK_END();
|
||||
RET_SYM(result_symbol);
|
||||
}
|
||||
|
||||
bool scn_acr_ctn(TSLexer *lexer, TSSymbol result_symbol) {
|
||||
while (is_ns_anchor_char(LKA)) ADV();
|
||||
MRK_END();
|
||||
RET_SYM(result_symbol);
|
||||
}
|
||||
|
||||
bool scn_als_bgn(TSLexer *lexer, TSSymbol result_symbol) {
|
||||
if (LKA != '*') return false;
|
||||
ADV();
|
||||
if (!is_ns_anchor_char(LKA)) return false;
|
||||
MRK_END();
|
||||
RET_SYM(result_symbol);
|
||||
}
|
||||
|
||||
bool scn_als_ctn(TSLexer *lexer, TSSymbol result_symbol) {
|
||||
while (is_ns_anchor_char(LKA)) ADV();
|
||||
MRK_END();
|
||||
RET_SYM(result_symbol);
|
||||
}
|
||||
|
||||
bool scn_dqt_esc_seq(TSLexer *lexer, TSSymbol result_symbol) {
|
||||
uint16_t i;
|
||||
switch (LKA) {
|
||||
case '0': case 'a': case 'b': case 't': case '\t': case 'n': case 'v':
|
||||
case 'r': case 'e': case ' ': case '"': case '/': case '\\': case 'N':
|
||||
case '_': case 'L': case 'P':
|
||||
ADV();
|
||||
break;
|
||||
case 'U':
|
||||
ADV();
|
||||
for (i = 0; i < 8; i++) if (is_ns_hex_digit(LKA)) ADV(); else return false;
|
||||
break;
|
||||
case 'u':
|
||||
ADV();
|
||||
for (i = 0; i < 4; i++) if (is_ns_hex_digit(LKA)) ADV(); else return false;
|
||||
break;
|
||||
case 'x':
|
||||
ADV();
|
||||
for (i = 0; i < 2; i++) if (is_ns_hex_digit(LKA)) ADV(); else return false;
|
||||
break;
|
||||
default:
|
||||
return false;
|
||||
}
|
||||
MRK_END();
|
||||
RET_SYM(result_symbol);
|
||||
}
|
||||
|
||||
bool scn_dqt_str_cnt(TSLexer *lexer, TSSymbol result_symbol) {
|
||||
if (!is_nb_double_char(LKA)) return false;
|
||||
if (cur_col == 0 && scn_drs_doc_end(lexer)) {
|
||||
MRK_END();
|
||||
RET_SYM(cur_chr == '-' ? S_DRS_END : S_DOC_END);
|
||||
} else ADV();
|
||||
while (is_nb_double_char(LKA)) ADV();
|
||||
MRK_END();
|
||||
RET_SYM(result_symbol);
|
||||
}
|
||||
|
||||
bool scn_sqt_str_cnt(TSLexer *lexer, TSSymbol result_symbol) {
|
||||
if (!is_nb_single_char(LKA)) return false;
|
||||
if (cur_col == 0 && scn_drs_doc_end(lexer)) {
|
||||
MRK_END();
|
||||
RET_SYM(cur_chr == '-' ? S_DRS_END : S_DOC_END);
|
||||
} else ADV();
|
||||
while (is_nb_single_char(LKA)) ADV();
|
||||
MRK_END();
|
||||
RET_SYM(result_symbol);
|
||||
}
|
||||
|
||||
bool scn_blk_str_bgn(TSLexer *lexer, TSSymbol result_symbol) {
|
||||
if (LKA != '|' && LKA != '>') return false;
|
||||
ADV();
|
||||
int16_t cur_ind = ind_len_stk.back();
|
||||
int16_t ind = -1;
|
||||
if (LKA >= '1' && LKA <= '9') {
|
||||
ind = LKA - '1';
|
||||
ADV();
|
||||
if (LKA == '+' || LKA == '-') {
|
||||
ADV();
|
||||
}
|
||||
} else if (LKA == '+' || LKA == '-') {
|
||||
ADV();
|
||||
if (LKA >= '1' && LKA <= '9') {
|
||||
ind = LKA - '1';
|
||||
ADV();
|
||||
}
|
||||
}
|
||||
if (!is_wht(LKA)) return false;
|
||||
MRK_END();
|
||||
if (ind != -1) ind += cur_ind;
|
||||
else {
|
||||
ind = cur_ind;
|
||||
while (is_wsp(LKA)) ADV();
|
||||
if (LKA == '#') {
|
||||
ADV();
|
||||
while (!is_nwl(LKA) && LKA != 0) ADV();
|
||||
}
|
||||
if (is_nwl(LKA)) ADV_NWL();
|
||||
while (LKA != 0) {
|
||||
if (LKA == ' ') ADV();
|
||||
else if (is_nwl(LKA)) {
|
||||
if (cur_col - 1 < ind) break;
|
||||
ind = cur_col - 1;
|
||||
ADV_NWL();
|
||||
} else {
|
||||
if (cur_col - 1 > ind) ind = cur_col - 1;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
PUSH_IND(IND_STR, ind);
|
||||
RET_SYM(result_symbol);
|
||||
}
|
||||
|
||||
bool scn_blk_str_cnt(TSLexer *lexer, TSSymbol result_symbol) {
|
||||
if (!is_ns_char(LKA)) return false;
|
||||
if (cur_col == 0 && scn_drs_doc_end(lexer)) {POP_IND();RET_SYM(BL);}
|
||||
else ADV();
|
||||
MRK_END();
|
||||
for (;;) {
|
||||
if (is_ns_char(LKA)) {
|
||||
ADV();
|
||||
while (is_ns_char(LKA)) ADV();
|
||||
MRK_END();
|
||||
}
|
||||
if (is_wsp(LKA)) {
|
||||
ADV();
|
||||
while (is_wsp(LKA)) ADV();
|
||||
} else break;
|
||||
}
|
||||
RET_SYM(result_symbol);
|
||||
}
|
||||
|
||||
char scn_pln_cnt(TSLexer *lexer, bool (Scanner::*is_plain_safe)(int32_t)) {
|
||||
bool is_cur_saf = (this->*is_plain_safe)(cur_chr);
|
||||
bool is_lka_wsp = is_wsp(LKA);
|
||||
bool is_lka_saf = (this->*is_plain_safe)(LKA);
|
||||
if (is_lka_saf || is_lka_wsp) {
|
||||
for (;;) {
|
||||
if (is_lka_saf && LKA != '#' && LKA != ':') {ADV();MRK_END();UPD_SCH_STT();}
|
||||
else if (is_cur_saf && LKA == '#') {ADV();MRK_END();UPD_SCH_STT();}
|
||||
else if (is_lka_wsp) {ADV();UPD_SCH_STT();}
|
||||
else if (LKA == ':') ADV(); // check later
|
||||
else break;
|
||||
|
||||
is_cur_saf = is_lka_saf;
|
||||
is_lka_wsp = is_wsp(LKA);
|
||||
is_lka_saf = (this->*is_plain_safe)(LKA);
|
||||
|
||||
if (cur_chr == ':') {
|
||||
if (is_lka_saf) {MRK_END();UPD_SCH_STT();}
|
||||
else return SCN_FAIL;
|
||||
}
|
||||
}
|
||||
} else return SCN_STOP;
|
||||
return SCN_SUCC;
|
||||
}
|
||||
|
||||
bool scn_drs_doc_end(TSLexer *lexer) {
|
||||
if (LKA != '-' && LKA != '.') return false;
|
||||
int32_t delimeter = LKA;
|
||||
ADV();
|
||||
if (LKA == delimeter) {
|
||||
ADV();
|
||||
if (LKA == delimeter) {
|
||||
ADV();
|
||||
if (is_wht(LKA)) return true;
|
||||
}
|
||||
}
|
||||
MRK_END();
|
||||
return false;
|
||||
}
|
||||
|
||||
bool scan(TSLexer *lexer, const bool *valid_symbols) {
|
||||
init();
|
||||
MRK_END();
|
||||
|
||||
bool allow_comment = !(VLD[R_DQT_STR_CTN] || VLD[BR_DQT_STR_CTN] || VLD[R_SQT_STR_CTN] || VLD[BR_SQT_STR_CTN]);
|
||||
|
||||
vector<int16_t>::reverse_iterator ind_ptr = ind_len_stk.rbegin();
|
||||
vector<int16_t>::reverse_iterator ind_end = ind_len_stk.rend();
|
||||
int16_t cur_ind = *ind_ptr++;
|
||||
int16_t prt_ind = ind_ptr == ind_end ? -1 : *ind_ptr;
|
||||
int16_t cur_ind_typ = ind_typ_stk.back();
|
||||
|
||||
bool has_tab_ind = false;
|
||||
int16_t leading_spaces = 0;
|
||||
|
||||
for (;;) {
|
||||
if (LKA == ' ') {
|
||||
if (!has_tab_ind) leading_spaces++;
|
||||
SKP();
|
||||
} else if (LKA == '\t') {
|
||||
has_tab_ind = true;
|
||||
SKP();
|
||||
} else if (is_nwl(LKA)) {
|
||||
has_tab_ind = false;
|
||||
leading_spaces = 0;
|
||||
SKP_NWL();
|
||||
} else if (allow_comment && LKA == '#') {
|
||||
if (VLD[BR_BLK_STR_CTN] && VLD[BL] && cur_col <= cur_ind) {POP_IND();RET_SYM(BL);}
|
||||
if (
|
||||
VLD[BR_BLK_STR_CTN]
|
||||
? cur_row == row
|
||||
: cur_col == 0 || cur_row != row || cur_col > col
|
||||
) {
|
||||
ADV();
|
||||
while (!is_nwl(LKA) && LKA != 0) ADV();
|
||||
MRK_END();
|
||||
RET_SYM(COMMENT);
|
||||
} else break;
|
||||
} else break;
|
||||
}
|
||||
|
||||
if (LKA == 0) {
|
||||
if (VLD[BL]) {MRK_END();POP_IND();RET_SYM(BL)}
|
||||
if (VLD[END_OF_FILE]) {MRK_END();RET_SYM(END_OF_FILE)}
|
||||
return false;
|
||||
}
|
||||
|
||||
int16_t bgn_row = cur_row;
|
||||
int16_t bgn_col = cur_col;
|
||||
int32_t bgn_chr = LKA;
|
||||
|
||||
if (VLD[BL] && bgn_col <= cur_ind && !has_tab_ind) {
|
||||
if (
|
||||
cur_ind == prt_ind && cur_ind_typ == IND_SEQ
|
||||
? bgn_col < cur_ind || LKA != '-'
|
||||
: bgn_col <= prt_ind || cur_ind_typ == IND_STR
|
||||
) {POP_IND();RET_SYM(BL);}
|
||||
}
|
||||
|
||||
bool has_nwl = cur_row > row;
|
||||
bool is_r = !has_nwl;
|
||||
bool is_br = has_nwl && leading_spaces > cur_ind;
|
||||
bool is_b = has_nwl && leading_spaces == cur_ind && !has_tab_ind;
|
||||
bool is_s = bgn_col == 0;
|
||||
|
||||
if (VLD[R_DIR_YML_VER] && is_r) return scn_dir_yml_ver(lexer, R_DIR_YML_VER);
|
||||
if (VLD[R_DIR_TAG_HDL] && is_r) return scn_dir_tag_hdl(lexer, R_DIR_TAG_HDL);
|
||||
if (VLD[R_DIR_TAG_PFX] && is_r) return scn_dir_tag_pfx(lexer, R_DIR_TAG_PFX);
|
||||
if (VLD[R_DIR_RSV_PRM] && is_r) return scn_dir_rsv_prm(lexer, R_DIR_RSV_PRM);
|
||||
if (VLD[BR_BLK_STR_CTN] && is_br && scn_blk_str_cnt(lexer, BR_BLK_STR_CTN)) return true;
|
||||
|
||||
if (
|
||||
(VLD[R_DQT_STR_CTN] && is_r && scn_dqt_str_cnt(lexer, R_DQT_STR_CTN))
|
||||
|| (VLD[BR_DQT_STR_CTN] && is_br && scn_dqt_str_cnt(lexer, BR_DQT_STR_CTN))
|
||||
) return true;
|
||||
|
||||
if (
|
||||
(VLD[R_SQT_STR_CTN] && is_r && scn_sqt_str_cnt(lexer, R_SQT_STR_CTN))
|
||||
|| (VLD[BR_SQT_STR_CTN] && is_br && scn_sqt_str_cnt(lexer, BR_SQT_STR_CTN))
|
||||
) return true;
|
||||
|
||||
if (VLD[R_ACR_CTN] && is_r) return scn_acr_ctn(lexer, R_ACR_CTN);
|
||||
if (VLD[R_ALS_CTN] && is_r) return scn_als_ctn(lexer, R_ALS_CTN);
|
||||
|
||||
if (LKA == '%') {
|
||||
if (VLD[S_DIR_YML_BGN] && is_s) return scn_dir_bgn(lexer);
|
||||
} else if (LKA == '*') {
|
||||
if (VLD[R_ALS_BGN] && is_r) {MAY_UPD_IMP_COL();return scn_als_bgn(lexer, R_ALS_BGN);}
|
||||
if (VLD[BR_ALS_BGN] && is_br) {MAY_UPD_IMP_COL();return scn_als_bgn(lexer, BR_ALS_BGN);}
|
||||
if (VLD[B_ALS_BGN] && is_b) {MAY_UPD_IMP_COL();return scn_als_bgn(lexer, B_ALS_BGN);}
|
||||
} else if (LKA == '&') {
|
||||
if (VLD[R_ACR_BGN] && is_r) {MAY_UPD_IMP_COL();return scn_acr_bgn(lexer, R_ACR_BGN);}
|
||||
if (VLD[BR_ACR_BGN] && is_br) {MAY_UPD_IMP_COL();return scn_acr_bgn(lexer, BR_ACR_BGN);}
|
||||
if (VLD[B_ACR_BGN] && is_b) {MAY_UPD_IMP_COL();return scn_acr_bgn(lexer, B_ACR_BGN);}
|
||||
} else if (LKA == '!') {
|
||||
if (VLD[R_TAG] && is_r) {MAY_UPD_IMP_COL();return scn_tag(lexer, R_TAG);}
|
||||
if (VLD[BR_TAG] && is_br) {MAY_UPD_IMP_COL();return scn_tag(lexer, BR_TAG);}
|
||||
if (VLD[B_TAG] && is_b) {MAY_UPD_IMP_COL();return scn_tag(lexer, B_TAG);}
|
||||
} else if (LKA == '[') {
|
||||
if (VLD[R_FLW_SEQ_BGN] && is_r) {MAY_UPD_IMP_COL();ADV();MRK_END();RET_SYM(R_FLW_SEQ_BGN)}
|
||||
if (VLD[BR_FLW_SEQ_BGN] && is_br) {MAY_UPD_IMP_COL();ADV();MRK_END();RET_SYM(BR_FLW_SEQ_BGN)}
|
||||
if (VLD[B_FLW_SEQ_BGN] && is_b) {MAY_UPD_IMP_COL();ADV();MRK_END();RET_SYM(B_FLW_SEQ_BGN)}
|
||||
} else if (LKA == ']') {
|
||||
if (VLD[R_FLW_SEQ_END] && is_r) {ADV();MRK_END();RET_SYM(R_FLW_SEQ_END)}
|
||||
if (VLD[BR_FLW_SEQ_END] && is_br) {ADV();MRK_END();RET_SYM(BR_FLW_SEQ_END)}
|
||||
} else if (LKA == '{') {
|
||||
if (VLD[R_FLW_MAP_BGN] && is_r) {MAY_UPD_IMP_COL();ADV();MRK_END();RET_SYM(R_FLW_MAP_BGN)}
|
||||
if (VLD[BR_FLW_MAP_BGN] && is_br) {MAY_UPD_IMP_COL();ADV();MRK_END();RET_SYM(BR_FLW_MAP_BGN)}
|
||||
if (VLD[B_FLW_MAP_BGN] && is_b) {MAY_UPD_IMP_COL();ADV();MRK_END();RET_SYM(B_FLW_MAP_BGN)}
|
||||
} else if (LKA == '}') {
|
||||
if (VLD[R_FLW_MAP_END] && is_r) {ADV();MRK_END();RET_SYM(R_FLW_MAP_END)}
|
||||
if (VLD[BR_FLW_MAP_END] && is_br) {ADV();MRK_END();RET_SYM(BR_FLW_MAP_END)}
|
||||
} else if (LKA == ',') {
|
||||
if (VLD[R_FLW_SEP_BGN] && is_r) {ADV();MRK_END();RET_SYM(R_FLW_SEP_BGN)}
|
||||
if (VLD[BR_FLW_SEP_BGN] && is_br) {ADV();MRK_END();RET_SYM(BR_FLW_SEP_BGN)}
|
||||
} else if (LKA == '"') {
|
||||
if (VLD[R_DQT_STR_BGN] && is_r) {MAY_UPD_IMP_COL();ADV();MRK_END();RET_SYM(R_DQT_STR_BGN)}
|
||||
if (VLD[BR_DQT_STR_BGN] && is_br) {MAY_UPD_IMP_COL();ADV();MRK_END();RET_SYM(BR_DQT_STR_BGN)}
|
||||
if (VLD[B_DQT_STR_BGN] && is_b) {MAY_UPD_IMP_COL();ADV();MRK_END();RET_SYM(B_DQT_STR_BGN)}
|
||||
if (VLD[R_DQT_STR_END] && is_r) {ADV();MRK_END();RET_SYM(R_DQT_STR_END)}
|
||||
if (VLD[BR_DQT_STR_END] && is_br) {ADV();MRK_END();RET_SYM(BR_DQT_STR_END)}
|
||||
} else if (LKA == '\'') {
|
||||
if (VLD[R_SQT_STR_BGN] && is_r) {MAY_UPD_IMP_COL();ADV();MRK_END();RET_SYM(R_SQT_STR_BGN)}
|
||||
if (VLD[BR_SQT_STR_BGN] && is_br) {MAY_UPD_IMP_COL();ADV();MRK_END();RET_SYM(BR_SQT_STR_BGN)}
|
||||
if (VLD[B_SQT_STR_BGN] && is_b) {MAY_UPD_IMP_COL();ADV();MRK_END();RET_SYM(B_SQT_STR_BGN)}
|
||||
if (VLD[R_SQT_STR_END] && is_r) {
|
||||
ADV();
|
||||
if (LKA == '\'') {ADV();MRK_END();RET_SYM(R_SQT_ESC_SQT)}
|
||||
else {MRK_END();RET_SYM(R_SQT_STR_END)}
|
||||
}
|
||||
if (VLD[BR_SQT_STR_END] && is_br) {
|
||||
ADV();
|
||||
if (LKA == '\'') {ADV();MRK_END();RET_SYM(BR_SQT_ESC_SQT)}
|
||||
else {MRK_END();RET_SYM(BR_SQT_STR_END)}
|
||||
}
|
||||
} else if (LKA == '?') {
|
||||
bool is_r_blk_key_bgn = VLD[R_BLK_KEY_BGN] && is_r;
|
||||
bool is_br_blk_key_bgn = VLD[BR_BLK_KEY_BGN] && is_br;
|
||||
bool is_b_blk_key_bgn = VLD[B_BLK_KEY_BGN] && is_b;
|
||||
bool is_r_flw_key_bgn = VLD[R_FLW_KEY_BGN] && is_r;
|
||||
bool is_br_flw_key_bgn = VLD[BR_FLW_KEY_BGN] && is_br;
|
||||
if (is_r_blk_key_bgn || is_br_blk_key_bgn || is_b_blk_key_bgn || is_r_flw_key_bgn || is_br_flw_key_bgn) {
|
||||
ADV();
|
||||
if (is_wht(LKA)) {
|
||||
MRK_END();
|
||||
if (is_r_blk_key_bgn) {PUSH_BGN_IND(IND_MAP);RET_SYM(R_BLK_KEY_BGN);}
|
||||
if (is_br_blk_key_bgn) {PUSH_BGN_IND(IND_MAP);RET_SYM(BR_BLK_KEY_BGN);}
|
||||
if (is_b_blk_key_bgn) RET_SYM(B_BLK_KEY_BGN);
|
||||
if (is_r_flw_key_bgn) RET_SYM(R_FLW_KEY_BGN);
|
||||
if (is_br_flw_key_bgn) RET_SYM(BR_FLW_KEY_BGN);
|
||||
}
|
||||
}
|
||||
} else if (LKA == ':') {
|
||||
if (VLD[R_FLW_JSV_BGN] && is_r) {ADV();MRK_END();RET_SYM(R_FLW_JSV_BGN);}
|
||||
if (VLD[BR_FLW_JSV_BGN] && is_br) {ADV();MRK_END();RET_SYM(BR_FLW_JSV_BGN);}
|
||||
bool is_r_blk_val_bgn = VLD[R_BLK_VAL_BGN] && is_r;
|
||||
bool is_br_blk_val_bgn = VLD[BR_BLK_VAL_BGN] && is_br;
|
||||
bool is_b_blk_val_bgn = VLD[B_BLK_VAL_BGN] && is_b;
|
||||
bool is_r_blk_imp_bgn = VLD[R_BLK_IMP_BGN] && is_r;
|
||||
bool is_r_flw_njv_bgn = VLD[R_FLW_NJV_BGN] && is_r;
|
||||
bool is_br_flw_njv_bgn = VLD[BR_FLW_NJV_BGN] && is_br;
|
||||
if (is_r_blk_val_bgn || is_br_blk_val_bgn || is_b_blk_val_bgn || is_r_blk_imp_bgn || is_r_flw_njv_bgn || is_br_flw_njv_bgn) {
|
||||
ADV();
|
||||
bool is_lka_wht = is_wht(LKA);
|
||||
if (is_lka_wht) {
|
||||
if (is_r_blk_val_bgn) {PUSH_BGN_IND(IND_MAP);MRK_END();RET_SYM(R_BLK_VAL_BGN);}
|
||||
if (is_br_blk_val_bgn) {PUSH_BGN_IND(IND_MAP);MRK_END();RET_SYM(BR_BLK_VAL_BGN);}
|
||||
if (is_b_blk_val_bgn) {MRK_END();RET_SYM(B_BLK_VAL_BGN);}
|
||||
if (is_r_blk_imp_bgn) {MAY_PUSH_IMP_IND();MRK_END();RET_SYM(R_BLK_IMP_BGN);}
|
||||
}
|
||||
if (is_lka_wht || LKA == ',' || LKA == ']' || LKA == '}') {
|
||||
if (is_r_flw_njv_bgn) {MRK_END();RET_SYM(R_FLW_NJV_BGN);}
|
||||
if (is_br_flw_njv_bgn) {MRK_END();RET_SYM(BR_FLW_NJV_BGN);}
|
||||
}
|
||||
}
|
||||
} else if (LKA == '-') {
|
||||
bool is_r_blk_seq_bgn = VLD[R_BLK_SEQ_BGN] && is_r;
|
||||
bool is_br_blk_seq_bgn = VLD[BR_BLK_SEQ_BGN] && is_br;
|
||||
bool is_b_blk_seq_bgn = VLD[B_BLK_SEQ_BGN] && is_b;
|
||||
bool is_s_drs_end = is_s;
|
||||
if (is_r_blk_seq_bgn || is_br_blk_seq_bgn || is_b_blk_seq_bgn || is_s_drs_end) {
|
||||
ADV();
|
||||
if (is_wht(LKA)) {
|
||||
if (is_r_blk_seq_bgn) {PUSH_BGN_IND(IND_SEQ);MRK_END();RET_SYM(R_BLK_SEQ_BGN)}
|
||||
if (is_br_blk_seq_bgn) {PUSH_BGN_IND(IND_SEQ);MRK_END();RET_SYM(BR_BLK_SEQ_BGN)}
|
||||
if (is_b_blk_seq_bgn) {MAY_PUSH_SPC_SEQ_IND();MRK_END();RET_SYM(B_BLK_SEQ_BGN)}
|
||||
} else if (LKA == '-' && is_s_drs_end) {
|
||||
ADV();
|
||||
if (LKA == '-') {
|
||||
ADV();
|
||||
if (is_wht(LKA)) {
|
||||
if (VLD[BL]) {POP_IND();RET_SYM(BL);}
|
||||
MRK_END();
|
||||
RET_SYM(S_DRS_END);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} else if (LKA == '.') {
|
||||
if (is_s) {
|
||||
ADV();
|
||||
if (LKA == '.') {
|
||||
ADV();
|
||||
if (LKA == '.') {
|
||||
ADV();
|
||||
if (is_wht(LKA)) {
|
||||
if (VLD[BL]) {POP_IND();RET_SYM(BL);}
|
||||
MRK_END();
|
||||
RET_SYM(S_DOC_END);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} else if (LKA == '\\') {
|
||||
bool is_r_dqt_esc_nwl = VLD[R_DQT_ESC_NWL] && is_r;
|
||||
bool is_br_dqt_esc_nwl = VLD[BR_DQT_ESC_NWL] && is_br;
|
||||
bool is_r_dqt_esc_seq = VLD[R_DQT_ESC_SEQ] && is_r;
|
||||
bool is_br_dqt_esc_seq = VLD[BR_DQT_ESC_SEQ] && is_br;
|
||||
if (is_r_dqt_esc_nwl || is_br_dqt_esc_nwl || is_r_dqt_esc_seq || is_br_dqt_esc_seq) {
|
||||
ADV();
|
||||
if (is_nwl(LKA)) {
|
||||
if (is_r_dqt_esc_nwl) {MRK_END();RET_SYM(R_DQT_ESC_NWL)}
|
||||
if (is_br_dqt_esc_nwl) {MRK_END();RET_SYM(BR_DQT_ESC_NWL)}
|
||||
}
|
||||
if (is_r_dqt_esc_seq) return scn_dqt_esc_seq(lexer, R_DQT_ESC_SEQ);
|
||||
if (is_br_dqt_esc_seq) return scn_dqt_esc_seq(lexer, BR_DQT_ESC_SEQ);
|
||||
return false;
|
||||
}
|
||||
} else if (LKA == '|') {
|
||||
if (VLD[R_BLK_LIT_BGN] && is_r) return scn_blk_str_bgn(lexer, R_BLK_LIT_BGN);
|
||||
if (VLD[BR_BLK_LIT_BGN] && is_br) return scn_blk_str_bgn(lexer, BR_BLK_LIT_BGN);
|
||||
} else if (LKA == '>') {
|
||||
if (VLD[R_BLK_FLD_BGN] && is_r) return scn_blk_str_bgn(lexer, R_BLK_FLD_BGN);
|
||||
if (VLD[BR_BLK_FLD_BGN] && is_br) return scn_blk_str_bgn(lexer, BR_BLK_FLD_BGN);
|
||||
}
|
||||
|
||||
bool maybe_sgl_pln_blk = (VLD[R_SGL_PLN_STR_BLK] && is_r) || (VLD[BR_SGL_PLN_STR_BLK] && is_br) || (VLD[B_SGL_PLN_STR_BLK] && is_b);
|
||||
bool maybe_sgl_pln_flw = (VLD[R_SGL_PLN_STR_FLW] && is_r) || (VLD[BR_SGL_PLN_STR_FLW] && is_br);
|
||||
bool maybe_mtl_pln_blk = (VLD[R_MTL_PLN_STR_BLK] && is_r) || (VLD[BR_MTL_PLN_STR_BLK] && is_br);
|
||||
bool maybe_mtl_pln_flw = (VLD[R_MTL_PLN_STR_FLW] && is_r) || (VLD[BR_MTL_PLN_STR_FLW] && is_br);
|
||||
|
||||
if (maybe_sgl_pln_blk || maybe_sgl_pln_flw || maybe_mtl_pln_blk || maybe_mtl_pln_flw) {
|
||||
bool is_in_blk = maybe_sgl_pln_blk || maybe_mtl_pln_blk;
|
||||
bool (Scanner::*is_plain_safe)(int32_t) = is_in_blk ? &Scanner::is_plain_safe_in_block : &Scanner::is_plain_safe_in_flow;
|
||||
if (cur_col - bgn_col == 0) ADV();
|
||||
if (cur_col - bgn_col == 1) {
|
||||
bool is_plain_first =
|
||||
(is_ns_char(bgn_chr) && !is_c_indicator(bgn_chr))
|
||||
|| ((bgn_chr == '-' || bgn_chr == '?' || bgn_chr == ':')
|
||||
&& (this->*is_plain_safe)(LKA));
|
||||
if (!is_plain_first) return false;
|
||||
UPD_SCH_STT();
|
||||
} else {
|
||||
// no need to check the following cases:
|
||||
// ..X
|
||||
// ...X
|
||||
// --X
|
||||
// ---X
|
||||
// X: lookahead
|
||||
sch_stt = SCH_STT_FRZ; // must be RS_STR
|
||||
}
|
||||
|
||||
MRK_END();
|
||||
|
||||
for (;;) {
|
||||
if (!is_nwl(LKA)) {
|
||||
if (scn_pln_cnt(lexer, is_plain_safe) != SCN_SUCC) break;
|
||||
}
|
||||
if (LKA == 0 || !is_nwl(LKA)) break;
|
||||
for (;;) {
|
||||
if (is_nwl(LKA)) ADV_NWL();
|
||||
else if (is_wsp(LKA)) ADV();
|
||||
else break;
|
||||
}
|
||||
if (LKA == 0 || cur_col <= cur_ind) break;
|
||||
if (cur_col == 0 && scn_drs_doc_end(lexer)) break;
|
||||
}
|
||||
|
||||
if (end_row == bgn_row) {
|
||||
if (maybe_sgl_pln_blk) {MAY_UPD_IMP_COL();RET_SYM(is_r ? SGL_PLN_SYM(R, BLK) : is_br ? SGL_PLN_SYM(BR, BLK) : SGL_PLN_SYM(B, BLK));}
|
||||
if (maybe_sgl_pln_flw) RET_SYM(is_r ? SGL_PLN_SYM(R, FLW) : SGL_PLN_SYM(BR, FLW));
|
||||
} else {
|
||||
if (maybe_mtl_pln_blk) {MAY_UPD_IMP_COL();RET_SYM(is_r ? R_MTL_PLN_STR_BLK : BR_MTL_PLN_STR_BLK);}
|
||||
if (maybe_mtl_pln_flw) RET_SYM(is_r ? R_MTL_PLN_STR_FLW : BR_MTL_PLN_STR_FLW);
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
};
|
||||
|
||||
}
|
||||
|
||||
extern "C" {
|
||||
|
||||
void *tree_sitter_yaml_external_scanner_create() {
|
||||
return new Scanner();
|
||||
}
|
||||
|
||||
void tree_sitter_yaml_external_scanner_destroy(void *payload) {
|
||||
Scanner *scanner = static_cast<Scanner *>(payload);
|
||||
delete scanner;
|
||||
}
|
||||
|
||||
unsigned tree_sitter_yaml_external_scanner_serialize(void *payload, char *buffer) {
|
||||
Scanner *scanner = static_cast<Scanner *>(payload);
|
||||
return scanner->serialize(buffer);
|
||||
}
|
||||
|
||||
void tree_sitter_yaml_external_scanner_deserialize(void *payload, const char *buffer, unsigned length) {
|
||||
Scanner *scanner = static_cast<Scanner *>(payload);
|
||||
scanner->deserialize(buffer, length);
|
||||
}
|
||||
|
||||
bool tree_sitter_yaml_external_scanner_scan(void *payload, TSLexer *lexer, const bool *valid_symbols) {
|
||||
Scanner *scanner = static_cast<Scanner *>(payload);
|
||||
return scanner->scan(lexer, valid_symbols);
|
||||
}
|
||||
|
||||
}
|
||||
@ -1,204 +0,0 @@
|
||||
#include <cassert>
|
||||
|
||||
namespace tree_sitter_yaml {
|
||||
|
||||
const int8_t SCH_STT_FRZ = -1;
|
||||
|
||||
enum ResultSchema {
|
||||
RS_STR,
|
||||
RS_INT,
|
||||
RS_NUL,
|
||||
RS_BOL,
|
||||
RS_FLT,
|
||||
};
|
||||
|
||||
int8_t adv_sch_stt(int8_t sch_stt, int32_t cur_chr, ResultSchema *rlt_sch) {
|
||||
switch (sch_stt) {
|
||||
case -1:
|
||||
break;
|
||||
case 0:
|
||||
if (cur_chr == '.') {*rlt_sch = RS_STR; return 6;}
|
||||
if (cur_chr == '0') {*rlt_sch = RS_INT; return 37;}
|
||||
if (cur_chr == 'F') {*rlt_sch = RS_STR; return 2;}
|
||||
if (cur_chr == 'N') {*rlt_sch = RS_STR; return 16;}
|
||||
if (cur_chr == 'T') {*rlt_sch = RS_STR; return 13;}
|
||||
if (cur_chr == 'f') {*rlt_sch = RS_STR; return 17;}
|
||||
if (cur_chr == 'n') {*rlt_sch = RS_STR; return 29;}
|
||||
if (cur_chr == 't') {*rlt_sch = RS_STR; return 26;}
|
||||
if (cur_chr == '~') {*rlt_sch = RS_NUL; return 35;}
|
||||
if (cur_chr == '+' ||
|
||||
cur_chr == '-') {*rlt_sch = RS_STR; return 1;}
|
||||
if (('1' <= cur_chr && cur_chr <= '9')) {*rlt_sch = RS_INT; return 38;}
|
||||
break;
|
||||
case 1:
|
||||
if (cur_chr == '.') {*rlt_sch = RS_STR; return 7;}
|
||||
if (('0' <= cur_chr && cur_chr <= '9')) {*rlt_sch = RS_INT; return 38;}
|
||||
break;
|
||||
case 2:
|
||||
if (cur_chr == 'A') {*rlt_sch = RS_STR; return 9;}
|
||||
if (cur_chr == 'a') {*rlt_sch = RS_STR; return 22;}
|
||||
break;
|
||||
case 3:
|
||||
if (cur_chr == 'A') {*rlt_sch = RS_STR; return 12;}
|
||||
if (cur_chr == 'a') {*rlt_sch = RS_STR; return 12;}
|
||||
break;
|
||||
case 4:
|
||||
if (cur_chr == 'E') {*rlt_sch = RS_BOL; return 36;}
|
||||
break;
|
||||
case 5:
|
||||
if (cur_chr == 'F') {*rlt_sch = RS_FLT; return 41;}
|
||||
break;
|
||||
case 6:
|
||||
if (cur_chr == 'I') {*rlt_sch = RS_STR; return 11;}
|
||||
if (cur_chr == 'N') {*rlt_sch = RS_STR; return 3;}
|
||||
if (cur_chr == 'i') {*rlt_sch = RS_STR; return 24;}
|
||||
if (cur_chr == 'n') {*rlt_sch = RS_STR; return 18;}
|
||||
if (('0' <= cur_chr && cur_chr <= '9')) {*rlt_sch = RS_FLT; return 42;}
|
||||
break;
|
||||
case 7:
|
||||
if (cur_chr == 'I') {*rlt_sch = RS_STR; return 11;}
|
||||
if (cur_chr == 'i') {*rlt_sch = RS_STR; return 24;}
|
||||
if (('0' <= cur_chr && cur_chr <= '9')) {*rlt_sch = RS_FLT; return 42;}
|
||||
break;
|
||||
case 8:
|
||||
if (cur_chr == 'L') {*rlt_sch = RS_NUL; return 35;}
|
||||
break;
|
||||
case 9:
|
||||
if (cur_chr == 'L') {*rlt_sch = RS_STR; return 14;}
|
||||
break;
|
||||
case 10:
|
||||
if (cur_chr == 'L') {*rlt_sch = RS_STR; return 8;}
|
||||
break;
|
||||
case 11:
|
||||
if (cur_chr == 'N') {*rlt_sch = RS_STR; return 5;}
|
||||
if (cur_chr == 'n') {*rlt_sch = RS_STR; return 20;}
|
||||
break;
|
||||
case 12:
|
||||
if (cur_chr == 'N') {*rlt_sch = RS_FLT; return 41;}
|
||||
break;
|
||||
case 13:
|
||||
if (cur_chr == 'R') {*rlt_sch = RS_STR; return 15;}
|
||||
if (cur_chr == 'r') {*rlt_sch = RS_STR; return 28;}
|
||||
break;
|
||||
case 14:
|
||||
if (cur_chr == 'S') {*rlt_sch = RS_STR; return 4;}
|
||||
break;
|
||||
case 15:
|
||||
if (cur_chr == 'U') {*rlt_sch = RS_STR; return 4;}
|
||||
break;
|
||||
case 16:
|
||||
if (cur_chr == 'U') {*rlt_sch = RS_STR; return 10;}
|
||||
if (cur_chr == 'u') {*rlt_sch = RS_STR; return 23;}
|
||||
break;
|
||||
case 17:
|
||||
if (cur_chr == 'a') {*rlt_sch = RS_STR; return 22;}
|
||||
break;
|
||||
case 18:
|
||||
if (cur_chr == 'a') {*rlt_sch = RS_STR; return 25;}
|
||||
break;
|
||||
case 19:
|
||||
if (cur_chr == 'e') {*rlt_sch = RS_BOL; return 36;}
|
||||
break;
|
||||
case 20:
|
||||
if (cur_chr == 'f') {*rlt_sch = RS_FLT; return 41;}
|
||||
break;
|
||||
case 21:
|
||||
if (cur_chr == 'l') {*rlt_sch = RS_NUL; return 35;}
|
||||
break;
|
||||
case 22:
|
||||
if (cur_chr == 'l') {*rlt_sch = RS_STR; return 27;}
|
||||
break;
|
||||
case 23:
|
||||
if (cur_chr == 'l') {*rlt_sch = RS_STR; return 21;}
|
||||
break;
|
||||
case 24:
|
||||
if (cur_chr == 'n') {*rlt_sch = RS_STR; return 20;}
|
||||
break;
|
||||
case 25:
|
||||
if (cur_chr == 'n') {*rlt_sch = RS_FLT; return 41;}
|
||||
break;
|
||||
case 26:
|
||||
if (cur_chr == 'r') {*rlt_sch = RS_STR; return 28;}
|
||||
break;
|
||||
case 27:
|
||||
if (cur_chr == 's') {*rlt_sch = RS_STR; return 19;}
|
||||
break;
|
||||
case 28:
|
||||
if (cur_chr == 'u') {*rlt_sch = RS_STR; return 19;}
|
||||
break;
|
||||
case 29:
|
||||
if (cur_chr == 'u') {*rlt_sch = RS_STR; return 23;}
|
||||
break;
|
||||
case 30:
|
||||
if (cur_chr == '+' ||
|
||||
cur_chr == '-') {*rlt_sch = RS_STR; return 32;}
|
||||
if (('0' <= cur_chr && cur_chr <= '9')) {*rlt_sch = RS_FLT; return 43;}
|
||||
break;
|
||||
case 31:
|
||||
if (('0' <= cur_chr && cur_chr <= '7')) {*rlt_sch = RS_INT; return 39;}
|
||||
break;
|
||||
case 32:
|
||||
if (('0' <= cur_chr && cur_chr <= '9')) {*rlt_sch = RS_FLT; return 43;}
|
||||
break;
|
||||
case 33:
|
||||
if (('0' <= cur_chr && cur_chr <= '9') ||
|
||||
('A' <= cur_chr && cur_chr <= 'F') ||
|
||||
('a' <= cur_chr && cur_chr <= 'f')) {*rlt_sch = RS_INT; return 40;}
|
||||
break;
|
||||
case 34:
|
||||
assert(false);
|
||||
break;
|
||||
case 35:
|
||||
*rlt_sch = RS_NUL;
|
||||
break;
|
||||
case 36:
|
||||
*rlt_sch = RS_BOL;
|
||||
break;
|
||||
case 37:
|
||||
*rlt_sch = RS_INT;
|
||||
if (cur_chr == '.') {*rlt_sch = RS_FLT; return 42;}
|
||||
if (cur_chr == 'o') {*rlt_sch = RS_STR; return 31;}
|
||||
if (cur_chr == 'x') {*rlt_sch = RS_STR; return 33;}
|
||||
if (cur_chr == 'E' ||
|
||||
cur_chr == 'e') {*rlt_sch = RS_STR; return 30;}
|
||||
if (('0' <= cur_chr && cur_chr <= '9')) {*rlt_sch = RS_INT; return 38;}
|
||||
break;
|
||||
case 38:
|
||||
*rlt_sch = RS_INT;
|
||||
if (cur_chr == '.') {*rlt_sch = RS_FLT; return 42;}
|
||||
if (cur_chr == 'E' ||
|
||||
cur_chr == 'e') {*rlt_sch = RS_STR; return 30;}
|
||||
if (('0' <= cur_chr && cur_chr <= '9')) {*rlt_sch = RS_INT; return 38;}
|
||||
break;
|
||||
case 39:
|
||||
*rlt_sch = RS_INT;
|
||||
if (('0' <= cur_chr && cur_chr <= '7')) {*rlt_sch = RS_INT; return 39;}
|
||||
break;
|
||||
case 40:
|
||||
*rlt_sch = RS_INT;
|
||||
if (('0' <= cur_chr && cur_chr <= '9') ||
|
||||
('A' <= cur_chr && cur_chr <= 'F') ||
|
||||
('a' <= cur_chr && cur_chr <= 'f')) {*rlt_sch = RS_INT; return 40;}
|
||||
break;
|
||||
case 41:
|
||||
*rlt_sch = RS_FLT;
|
||||
break;
|
||||
case 42:
|
||||
*rlt_sch = RS_FLT;
|
||||
if (cur_chr == 'E' ||
|
||||
cur_chr == 'e') {*rlt_sch = RS_STR; return 30;}
|
||||
if (('0' <= cur_chr && cur_chr <= '9')) {*rlt_sch = RS_FLT; return 42;}
|
||||
break;
|
||||
case 43:
|
||||
*rlt_sch = RS_FLT;
|
||||
if (('0' <= cur_chr && cur_chr <= '9')) {*rlt_sch = RS_FLT; return 43;}
|
||||
break;
|
||||
default:
|
||||
*rlt_sch = RS_STR;
|
||||
return -1;
|
||||
}
|
||||
if (cur_chr != '\r' && cur_chr != '\n' && cur_chr != ' ' && cur_chr != 0) *rlt_sch = RS_STR;
|
||||
return -1;
|
||||
}
|
||||
|
||||
}
|
||||
@ -1,223 +0,0 @@
|
||||
#ifndef TREE_SITTER_PARSER_H_
|
||||
#define TREE_SITTER_PARSER_H_
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
#include <stdbool.h>
|
||||
#include <stdint.h>
|
||||
#include <stdlib.h>
|
||||
|
||||
#define ts_builtin_sym_error ((TSSymbol)-1)
|
||||
#define ts_builtin_sym_end 0
|
||||
#define TREE_SITTER_SERIALIZATION_BUFFER_SIZE 1024
|
||||
|
||||
typedef uint16_t TSStateId;
|
||||
|
||||
#ifndef TREE_SITTER_API_H_
|
||||
typedef uint16_t TSSymbol;
|
||||
typedef uint16_t TSFieldId;
|
||||
typedef struct TSLanguage TSLanguage;
|
||||
#endif
|
||||
|
||||
typedef struct {
|
||||
TSFieldId field_id;
|
||||
uint8_t child_index;
|
||||
bool inherited;
|
||||
} TSFieldMapEntry;
|
||||
|
||||
typedef struct {
|
||||
uint16_t index;
|
||||
uint16_t length;
|
||||
} TSFieldMapSlice;
|
||||
|
||||
typedef struct {
|
||||
bool visible;
|
||||
bool named;
|
||||
bool supertype;
|
||||
} TSSymbolMetadata;
|
||||
|
||||
typedef struct TSLexer TSLexer;
|
||||
|
||||
struct TSLexer {
|
||||
int32_t lookahead;
|
||||
TSSymbol result_symbol;
|
||||
void (*advance)(TSLexer *, bool);
|
||||
void (*mark_end)(TSLexer *);
|
||||
uint32_t (*get_column)(TSLexer *);
|
||||
bool (*is_at_included_range_start)(const TSLexer *);
|
||||
bool (*eof)(const TSLexer *);
|
||||
};
|
||||
|
||||
typedef enum {
|
||||
TSParseActionTypeShift,
|
||||
TSParseActionTypeReduce,
|
||||
TSParseActionTypeAccept,
|
||||
TSParseActionTypeRecover,
|
||||
} TSParseActionType;
|
||||
|
||||
typedef union {
|
||||
struct {
|
||||
uint8_t type;
|
||||
TSStateId state;
|
||||
bool extra;
|
||||
bool repetition;
|
||||
} shift;
|
||||
struct {
|
||||
uint8_t type;
|
||||
uint8_t child_count;
|
||||
TSSymbol symbol;
|
||||
int16_t dynamic_precedence;
|
||||
uint16_t production_id;
|
||||
} reduce;
|
||||
uint8_t type;
|
||||
} TSParseAction;
|
||||
|
||||
typedef struct {
|
||||
uint16_t lex_state;
|
||||
uint16_t external_lex_state;
|
||||
} TSLexMode;
|
||||
|
||||
typedef union {
|
||||
TSParseAction action;
|
||||
struct {
|
||||
uint8_t count;
|
||||
bool reusable;
|
||||
} entry;
|
||||
} TSParseActionEntry;
|
||||
|
||||
struct TSLanguage {
|
||||
uint32_t version;
|
||||
uint32_t symbol_count;
|
||||
uint32_t alias_count;
|
||||
uint32_t token_count;
|
||||
uint32_t external_token_count;
|
||||
uint32_t state_count;
|
||||
uint32_t large_state_count;
|
||||
uint32_t production_id_count;
|
||||
uint32_t field_count;
|
||||
uint16_t max_alias_sequence_length;
|
||||
const uint16_t *parse_table;
|
||||
const uint16_t *small_parse_table;
|
||||
const uint32_t *small_parse_table_map;
|
||||
const TSParseActionEntry *parse_actions;
|
||||
const char **symbol_names;
|
||||
const char **field_names;
|
||||
const TSFieldMapSlice *field_map_slices;
|
||||
const TSFieldMapEntry *field_map_entries;
|
||||
const TSSymbolMetadata *symbol_metadata;
|
||||
const TSSymbol *public_symbol_map;
|
||||
const uint16_t *alias_map;
|
||||
const TSSymbol *alias_sequences;
|
||||
const TSLexMode *lex_modes;
|
||||
bool (*lex_fn)(TSLexer *, TSStateId);
|
||||
bool (*keyword_lex_fn)(TSLexer *, TSStateId);
|
||||
TSSymbol keyword_capture_token;
|
||||
struct {
|
||||
const bool *states;
|
||||
const TSSymbol *symbol_map;
|
||||
void *(*create)(void);
|
||||
void (*destroy)(void *);
|
||||
bool (*scan)(void *, TSLexer *, const bool *symbol_whitelist);
|
||||
unsigned (*serialize)(void *, char *);
|
||||
void (*deserialize)(void *, const char *, unsigned);
|
||||
} external_scanner;
|
||||
};
|
||||
|
||||
/*
|
||||
* Lexer Macros
|
||||
*/
|
||||
|
||||
#define START_LEXER() \
|
||||
bool result = false; \
|
||||
bool skip = false; \
|
||||
bool eof = false; \
|
||||
int32_t lookahead; \
|
||||
goto start; \
|
||||
next_state: \
|
||||
lexer->advance(lexer, skip); \
|
||||
start: \
|
||||
skip = false; \
|
||||
lookahead = lexer->lookahead;
|
||||
|
||||
#define ADVANCE(state_value) \
|
||||
{ \
|
||||
state = state_value; \
|
||||
goto next_state; \
|
||||
}
|
||||
|
||||
#define SKIP(state_value) \
|
||||
{ \
|
||||
skip = true; \
|
||||
state = state_value; \
|
||||
goto next_state; \
|
||||
}
|
||||
|
||||
#define ACCEPT_TOKEN(symbol_value) \
|
||||
result = true; \
|
||||
lexer->result_symbol = symbol_value; \
|
||||
lexer->mark_end(lexer);
|
||||
|
||||
#define END_STATE() return result;
|
||||
|
||||
/*
|
||||
* Parse Table Macros
|
||||
*/
|
||||
|
||||
#define SMALL_STATE(id) id - LARGE_STATE_COUNT
|
||||
|
||||
#define STATE(id) id
|
||||
|
||||
#define ACTIONS(id) id
|
||||
|
||||
#define SHIFT(state_value) \
|
||||
{{ \
|
||||
.shift = { \
|
||||
.type = TSParseActionTypeShift, \
|
||||
.state = state_value \
|
||||
} \
|
||||
}}
|
||||
|
||||
#define SHIFT_REPEAT(state_value) \
|
||||
{{ \
|
||||
.shift = { \
|
||||
.type = TSParseActionTypeShift, \
|
||||
.state = state_value, \
|
||||
.repetition = true \
|
||||
} \
|
||||
}}
|
||||
|
||||
#define SHIFT_EXTRA() \
|
||||
{{ \
|
||||
.shift = { \
|
||||
.type = TSParseActionTypeShift, \
|
||||
.extra = true \
|
||||
} \
|
||||
}}
|
||||
|
||||
#define REDUCE(symbol_val, child_count_val, ...) \
|
||||
{{ \
|
||||
.reduce = { \
|
||||
.type = TSParseActionTypeReduce, \
|
||||
.symbol = symbol_val, \
|
||||
.child_count = child_count_val, \
|
||||
__VA_ARGS__ \
|
||||
}, \
|
||||
}}
|
||||
|
||||
#define RECOVER() \
|
||||
{{ \
|
||||
.type = TSParseActionTypeRecover \
|
||||
}}
|
||||
|
||||
#define ACCEPT_INPUT() \
|
||||
{{ \
|
||||
.type = TSParseActionTypeAccept \
|
||||
}}
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // TREE_SITTER_PARSER_H_
|
||||
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue