mirror of https://github.com/Wilfred/difftastic/
Merge commit '09dbf221d7491dc8d8839616b27c21b9c025c457'
Wilfred Hughes
commit
1dd7bbebe8
@ -0,0 +1,22 @@
|
||||
name: Fuzz Parser
|
||||
|
||||
on:
|
||||
push:
|
||||
paths:
|
||||
- src/scanner.c
|
||||
pull_request:
|
||||
paths:
|
||||
- src/scanner.c
|
||||
workflow_dispatch:
|
||||
|
||||
jobs:
|
||||
test:
|
||||
name: Parser fuzzing
|
||||
runs-on: ubuntu-latest
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
- uses: vigoux/tree-sitter-fuzz-action@v1
|
||||
with:
|
||||
language: elm
|
||||
external-scanner: src/scanner.c
|
||||
time: 60
|
||||
@ -0,0 +1,44 @@
|
||||
name: Validate that changes doesn't break elm-language-server
|
||||
|
||||
on:
|
||||
push:
|
||||
branches:
|
||||
- main
|
||||
pull_request:
|
||||
branches:
|
||||
- main
|
||||
|
||||
jobs:
|
||||
test:
|
||||
runs-on: ${{ matrix.os }}
|
||||
|
||||
strategy:
|
||||
fail-fast: false
|
||||
matrix:
|
||||
os: [ubuntu-latest]
|
||||
node-version: [18, 20]
|
||||
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
with:
|
||||
path: "tree-sitter-elm"
|
||||
- uses: actions/checkout@v4
|
||||
name: Checkout main branch of elm-language-server
|
||||
with:
|
||||
repository: "elm-tooling/elm-language-server"
|
||||
path: "elm-language-server"
|
||||
- name: Install tree-sitter dependencies and generate wasm bundle
|
||||
run: |
|
||||
cd tree-sitter-elm/
|
||||
npm i
|
||||
npm run build
|
||||
npx tree-sitter build-wasm
|
||||
mv ./tree-sitter-elm.wasm ../elm-language-server/tree-sitter-elm.wasm -f
|
||||
|
||||
- name: Install elm-language-server dependencies, compile, and run tests
|
||||
run: |
|
||||
cd elm-language-server/
|
||||
npm i
|
||||
npm run compile
|
||||
npm install -g elm-format
|
||||
npm test
|
||||
@ -0,0 +1,43 @@
|
||||
// swift-tools-version:5.3
|
||||
|
||||
import PackageDescription
|
||||
|
||||
let package = Package(
|
||||
name: "TreeSitterElm",
|
||||
platforms: [.macOS(.v10_13), .iOS(.v11)],
|
||||
products: [
|
||||
.library(name: "TreeSitterElm", targets: ["TreeSitterElm"]),
|
||||
],
|
||||
dependencies: [],
|
||||
targets: [
|
||||
.target(name: "TreeSitterElm",
|
||||
path: ".",
|
||||
exclude: [
|
||||
"binding.gyp",
|
||||
"bindings",
|
||||
"Cargo.toml",
|
||||
"docs",
|
||||
"examples",
|
||||
"grammar.js",
|
||||
"HOW_TO_RELEASE.md",
|
||||
"index.d.ts",
|
||||
"LICENSE.md",
|
||||
"package.json",
|
||||
"README.md",
|
||||
"script",
|
||||
"src/grammar.json",
|
||||
"src/node-types.json",
|
||||
"test",
|
||||
"tsconfig.json",
|
||||
],
|
||||
sources: [
|
||||
"src/parser.c",
|
||||
"src/scanner.c",
|
||||
],
|
||||
resources: [
|
||||
.copy("queries")
|
||||
],
|
||||
publicHeadersPath: "bindings/swift",
|
||||
cSettings: [.headerSearchPath("src")])
|
||||
]
|
||||
)
|
||||
@ -0,0 +1,16 @@
|
||||
#ifndef TREE_SITTER_ELM_H_
|
||||
#define TREE_SITTER_ELM_H_
|
||||
|
||||
typedef struct TSLanguage TSLanguage;
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
extern TSLanguage *tree_sitter_elm();
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif // TREE_SITTER_ELM_H_
|
||||
Binary file not shown.
File diff suppressed because one or more lines are too long
Binary file not shown.
@ -1,882 +0,0 @@
|
||||
export interface Parser {
|
||||
parse(input: string | Input, previousTree?: Tree, options?: {bufferSize?: number, includedRanges?: Range[]}): Tree;
|
||||
getLanguage(): any;
|
||||
setLanguage(language: any): void;
|
||||
getLogger(): Logger;
|
||||
setLogger(logFunc: Logger): void;
|
||||
}
|
||||
|
||||
export type Point = {
|
||||
row: number;
|
||||
column: number;
|
||||
};
|
||||
|
||||
export type Range = {
|
||||
startIndex: number,
|
||||
endIndex: number,
|
||||
startPosition: Point,
|
||||
endPosition: Point
|
||||
};
|
||||
|
||||
export type Edit = {
|
||||
startIndex: number;
|
||||
oldEndIndex: number;
|
||||
newEndIndex: number;
|
||||
startPosition: Point;
|
||||
oldEndPosition: Point;
|
||||
newEndPosition: Point;
|
||||
};
|
||||
|
||||
export type Logger = (
|
||||
message: string,
|
||||
params: {[param: string]: string},
|
||||
type: "parse" | "lex"
|
||||
) => void;
|
||||
|
||||
export interface Input {
|
||||
seek(index: number): void;
|
||||
read(): any;
|
||||
}
|
||||
|
||||
interface SyntaxNodeBase {
|
||||
tree: Tree;
|
||||
type: string;
|
||||
isNamed: boolean;
|
||||
text: string;
|
||||
startPosition: Point;
|
||||
endPosition: Point;
|
||||
startIndex: number;
|
||||
endIndex: number;
|
||||
parent: SyntaxNode | null;
|
||||
children: Array<SyntaxNode>;
|
||||
namedChildren: Array<SyntaxNode>;
|
||||
childCount: number;
|
||||
namedChildCount: number;
|
||||
firstChild: SyntaxNode | null;
|
||||
firstNamedChild: SyntaxNode | null;
|
||||
lastChild: SyntaxNode | null;
|
||||
lastNamedChild: SyntaxNode | null;
|
||||
nextSibling: SyntaxNode | null;
|
||||
nextNamedSibling: SyntaxNode | null;
|
||||
previousSibling: SyntaxNode | null;
|
||||
previousNamedSibling: SyntaxNode | null;
|
||||
|
||||
hasChanges(): boolean;
|
||||
hasError(): boolean;
|
||||
isMissing(): boolean;
|
||||
toString(): string;
|
||||
child(index: number): SyntaxNode | null;
|
||||
namedChild(index: number): SyntaxNode | null;
|
||||
firstChildForIndex(index: number): SyntaxNode | null;
|
||||
firstNamedChildForIndex(index: number): SyntaxNode | null;
|
||||
|
||||
descendantForIndex(index: number): SyntaxNode;
|
||||
descendantForIndex(startIndex: number, endIndex: number): SyntaxNode;
|
||||
namedDescendantForIndex(index: number): SyntaxNode;
|
||||
namedDescendantForIndex(startIndex: number, endIndex: number): SyntaxNode;
|
||||
descendantForPosition(position: Point): SyntaxNode;
|
||||
descendantForPosition(startPosition: Point, endPosition: Point): SyntaxNode;
|
||||
namedDescendantForPosition(position: Point): SyntaxNode;
|
||||
namedDescendantForPosition(startPosition: Point, endPosition: Point): SyntaxNode;
|
||||
descendantsOfType<T extends TypeString>(types: T | readonly T[], startPosition?: Point, endPosition?: Point): NodeOfType<T>[];
|
||||
|
||||
closest<T extends SyntaxType>(types: T | readonly T[]): NamedNode<T> | null;
|
||||
walk(): TreeCursor;
|
||||
}
|
||||
|
||||
export interface TreeCursor {
|
||||
nodeType: string;
|
||||
nodeText: string;
|
||||
nodeIsNamed: boolean;
|
||||
startPosition: Point;
|
||||
endPosition: Point;
|
||||
startIndex: number;
|
||||
endIndex: number;
|
||||
readonly currentNode: SyntaxNode
|
||||
|
||||
reset(node: SyntaxNode): void
|
||||
gotoParent(): boolean;
|
||||
gotoFirstChild(): boolean;
|
||||
gotoFirstChildForIndex(index: number): boolean;
|
||||
gotoNextSibling(): boolean;
|
||||
}
|
||||
|
||||
export interface Tree {
|
||||
readonly rootNode: SyntaxNode;
|
||||
|
||||
edit(delta: Edit): Tree;
|
||||
walk(): TreeCursor;
|
||||
getChangedRanges(other: Tree): Range[];
|
||||
getEditedRange(other: Tree): Range;
|
||||
}
|
||||
|
||||
interface NamedNodeBase extends SyntaxNodeBase {
|
||||
isNamed: true;
|
||||
}
|
||||
|
||||
/** An unnamed node with the given type string. */
|
||||
export interface UnnamedNode<T extends string = string> extends SyntaxNodeBase {
|
||||
type: T;
|
||||
isNamed: false;
|
||||
}
|
||||
|
||||
type PickNamedType<Node, T extends string> = Node extends { type: T; isNamed: true } ? Node : never;
|
||||
|
||||
type PickType<Node, T extends string> = Node extends { type: T } ? Node : never;
|
||||
|
||||
/** A named node with the given `type` string. */
|
||||
export type NamedNode<T extends SyntaxType = SyntaxType> = PickNamedType<SyntaxNode, T>;
|
||||
|
||||
/**
|
||||
* A node with the given `type` string.
|
||||
*
|
||||
* Note that this matches both named and unnamed nodes. Use `NamedNode<T>` to pick only named nodes.
|
||||
*/
|
||||
export type NodeOfType<T extends string> = PickType<SyntaxNode, T>;
|
||||
|
||||
interface TreeCursorOfType<S extends string, T extends SyntaxNodeBase> {
|
||||
nodeType: S;
|
||||
currentNode: T;
|
||||
}
|
||||
|
||||
type TreeCursorRecord = { [K in TypeString]: TreeCursorOfType<K, NodeOfType<K>> };
|
||||
|
||||
/**
|
||||
* A tree cursor whose `nodeType` correlates with `currentNode`.
|
||||
*
|
||||
* The typing becomes invalid once the underlying cursor is mutated.
|
||||
*
|
||||
* The intention is to cast a `TreeCursor` to `TypedTreeCursor` before
|
||||
* switching on `nodeType`.
|
||||
*
|
||||
* For example:
|
||||
* ```ts
|
||||
* let cursor = root.walk();
|
||||
* while (cursor.gotoNextSibling()) {
|
||||
* const c = cursor as TypedTreeCursor;
|
||||
* switch (c.nodeType) {
|
||||
* case SyntaxType.Foo: {
|
||||
* let node = c.currentNode; // Typed as FooNode.
|
||||
* break;
|
||||
* }
|
||||
* }
|
||||
* }
|
||||
* ```
|
||||
*/
|
||||
export type TypedTreeCursor = TreeCursorRecord[keyof TreeCursorRecord];
|
||||
|
||||
export interface ErrorNode extends NamedNodeBase {
|
||||
type: SyntaxType.ERROR;
|
||||
hasError(): true;
|
||||
}
|
||||
|
||||
export const enum SyntaxType {
|
||||
ERROR = "ERROR",
|
||||
AnonymousFunctionExpr = "anonymous_function_expr",
|
||||
AnythingPattern = "anything_pattern",
|
||||
AsClause = "as_clause",
|
||||
BinOpExpr = "bin_op_expr",
|
||||
BlockComment = "block_comment",
|
||||
CaseOfBranch = "case_of_branch",
|
||||
CaseOfExpr = "case_of_expr",
|
||||
CharConstantExpr = "char_constant_expr",
|
||||
ConsPattern = "cons_pattern",
|
||||
ExposedOperator = "exposed_operator",
|
||||
ExposedType = "exposed_type",
|
||||
ExposedUnionConstructors = "exposed_union_constructors",
|
||||
ExposedValue = "exposed_value",
|
||||
ExposingList = "exposing_list",
|
||||
Field = "field",
|
||||
FieldAccessExpr = "field_access_expr",
|
||||
FieldAccessorFunctionExpr = "field_accessor_function_expr",
|
||||
FieldType = "field_type",
|
||||
File = "file",
|
||||
FunctionCallExpr = "function_call_expr",
|
||||
FunctionDeclarationLeft = "function_declaration_left",
|
||||
GlslCodeExpr = "glsl_code_expr",
|
||||
IfElseExpr = "if_else_expr",
|
||||
ImportClause = "import_clause",
|
||||
InfixDeclaration = "infix_declaration",
|
||||
LetInExpr = "let_in_expr",
|
||||
ListExpr = "list_expr",
|
||||
ListPattern = "list_pattern",
|
||||
LowerPattern = "lower_pattern",
|
||||
LowerTypeName = "lower_type_name",
|
||||
ModuleDeclaration = "module_declaration",
|
||||
NegateExpr = "negate_expr",
|
||||
NullaryConstructorArgumentPattern = "nullary_constructor_argument_pattern",
|
||||
NumberConstantExpr = "number_constant_expr",
|
||||
Operator = "operator",
|
||||
OperatorAsFunctionExpr = "operator_as_function_expr",
|
||||
OperatorIdentifier = "operator_identifier",
|
||||
ParenthesizedExpr = "parenthesized_expr",
|
||||
Pattern = "pattern",
|
||||
PortAnnotation = "port_annotation",
|
||||
RecordBaseIdentifier = "record_base_identifier",
|
||||
RecordExpr = "record_expr",
|
||||
RecordPattern = "record_pattern",
|
||||
RecordType = "record_type",
|
||||
StringConstantExpr = "string_constant_expr",
|
||||
TupleExpr = "tuple_expr",
|
||||
TuplePattern = "tuple_pattern",
|
||||
TupleType = "tuple_type",
|
||||
TypeAliasDeclaration = "type_alias_declaration",
|
||||
TypeAnnotation = "type_annotation",
|
||||
TypeDeclaration = "type_declaration",
|
||||
TypeExpression = "type_expression",
|
||||
TypeRef = "type_ref",
|
||||
TypeVariable = "type_variable",
|
||||
UnionPattern = "union_pattern",
|
||||
UnionVariant = "union_variant",
|
||||
UnitExpr = "unit_expr",
|
||||
UpperCaseQid = "upper_case_qid",
|
||||
ValueDeclaration = "value_declaration",
|
||||
ValueExpr = "value_expr",
|
||||
ValueQid = "value_qid",
|
||||
Alias = "alias",
|
||||
Arrow = "arrow",
|
||||
As = "as",
|
||||
Backslash = "backslash",
|
||||
Case = "case",
|
||||
CloseChar = "close_char",
|
||||
CloseQuote = "close_quote",
|
||||
Colon = "colon",
|
||||
Dot = "dot",
|
||||
DoubleDot = "double_dot",
|
||||
Effect = "effect",
|
||||
Eq = "eq",
|
||||
Exposing = "exposing",
|
||||
GlslContent = "glsl_content",
|
||||
Import = "import",
|
||||
Infix = "infix",
|
||||
InvalidStringEscape = "invalid_string_escape",
|
||||
LineComment = "line_comment",
|
||||
LowerCaseIdentifier = "lower_case_identifier",
|
||||
Module = "module",
|
||||
NumberLiteral = "number_literal",
|
||||
Of = "of",
|
||||
OpenChar = "open_char",
|
||||
OpenQuote = "open_quote",
|
||||
Port = "port",
|
||||
RegularStringPart = "regular_string_part",
|
||||
StringEscape = "string_escape",
|
||||
Type = "type",
|
||||
Underscore = "underscore",
|
||||
UpperCaseIdentifier = "upper_case_identifier",
|
||||
Where = "where",
|
||||
}
|
||||
|
||||
export type UnnamedType =
|
||||
| "&&"
|
||||
| "("
|
||||
| ")"
|
||||
| "*"
|
||||
| "+"
|
||||
| "++"
|
||||
| ","
|
||||
| "-"
|
||||
| "-}"
|
||||
| "/"
|
||||
| "//"
|
||||
| "/="
|
||||
| "::"
|
||||
| "<"
|
||||
| "</>"
|
||||
| "<<"
|
||||
| "<="
|
||||
| "<?>"
|
||||
| "<|"
|
||||
| "=="
|
||||
| ">"
|
||||
| ">="
|
||||
| ">>"
|
||||
| "["
|
||||
| "]"
|
||||
| "^"
|
||||
| "else"
|
||||
| "if"
|
||||
| "in"
|
||||
| "let"
|
||||
| "then"
|
||||
| "{"
|
||||
| "{-"
|
||||
| "|"
|
||||
| "|."
|
||||
| "|="
|
||||
| "|>"
|
||||
| "||"
|
||||
| "}"
|
||||
;
|
||||
|
||||
export type TypeString = SyntaxType | UnnamedType;
|
||||
|
||||
export type SyntaxNode =
|
||||
| AnonymousFunctionExprNode
|
||||
| AnythingPatternNode
|
||||
| AsClauseNode
|
||||
| BinOpExprNode
|
||||
| BlockCommentNode
|
||||
| CaseOfBranchNode
|
||||
| CaseOfExprNode
|
||||
| CharConstantExprNode
|
||||
| ConsPatternNode
|
||||
| ExposedOperatorNode
|
||||
| ExposedTypeNode
|
||||
| ExposedUnionConstructorsNode
|
||||
| ExposedValueNode
|
||||
| ExposingListNode
|
||||
| FieldNode
|
||||
| FieldAccessExprNode
|
||||
| FieldAccessorFunctionExprNode
|
||||
| FieldTypeNode
|
||||
| FileNode
|
||||
| FunctionCallExprNode
|
||||
| FunctionDeclarationLeftNode
|
||||
| GlslCodeExprNode
|
||||
| IfElseExprNode
|
||||
| ImportClauseNode
|
||||
| InfixDeclarationNode
|
||||
| LetInExprNode
|
||||
| ListExprNode
|
||||
| ListPatternNode
|
||||
| LowerPatternNode
|
||||
| LowerTypeNameNode
|
||||
| ModuleDeclarationNode
|
||||
| NegateExprNode
|
||||
| NullaryConstructorArgumentPatternNode
|
||||
| NumberConstantExprNode
|
||||
| OperatorNode
|
||||
| OperatorAsFunctionExprNode
|
||||
| OperatorIdentifierNode
|
||||
| ParenthesizedExprNode
|
||||
| PatternNode
|
||||
| PortAnnotationNode
|
||||
| RecordBaseIdentifierNode
|
||||
| RecordExprNode
|
||||
| RecordPatternNode
|
||||
| RecordTypeNode
|
||||
| StringConstantExprNode
|
||||
| TupleExprNode
|
||||
| TuplePatternNode
|
||||
| TupleTypeNode
|
||||
| TypeAliasDeclarationNode
|
||||
| TypeAnnotationNode
|
||||
| TypeDeclarationNode
|
||||
| TypeExpressionNode
|
||||
| TypeRefNode
|
||||
| TypeVariableNode
|
||||
| UnionPatternNode
|
||||
| UnionVariantNode
|
||||
| UnitExprNode
|
||||
| UpperCaseQidNode
|
||||
| ValueDeclarationNode
|
||||
| ValueExprNode
|
||||
| ValueQidNode
|
||||
| UnnamedNode<"&&">
|
||||
| UnnamedNode<"(">
|
||||
| UnnamedNode<")">
|
||||
| UnnamedNode<"*">
|
||||
| UnnamedNode<"+">
|
||||
| UnnamedNode<"++">
|
||||
| UnnamedNode<",">
|
||||
| UnnamedNode<"-">
|
||||
| UnnamedNode<"-}">
|
||||
| UnnamedNode<"/">
|
||||
| UnnamedNode<"//">
|
||||
| UnnamedNode<"/=">
|
||||
| UnnamedNode<"::">
|
||||
| UnnamedNode<"<">
|
||||
| UnnamedNode<"</>">
|
||||
| UnnamedNode<"<<">
|
||||
| UnnamedNode<"<=">
|
||||
| UnnamedNode<"<?>">
|
||||
| UnnamedNode<"<|">
|
||||
| UnnamedNode<"==">
|
||||
| UnnamedNode<">">
|
||||
| UnnamedNode<">=">
|
||||
| UnnamedNode<">>">
|
||||
| UnnamedNode<"[">
|
||||
| UnnamedNode<"]">
|
||||
| UnnamedNode<"^">
|
||||
| AliasNode
|
||||
| ArrowNode
|
||||
| AsNode
|
||||
| BackslashNode
|
||||
| CaseNode
|
||||
| CloseCharNode
|
||||
| CloseQuoteNode
|
||||
| ColonNode
|
||||
| DotNode
|
||||
| DoubleDotNode
|
||||
| EffectNode
|
||||
| UnnamedNode<"else">
|
||||
| EqNode
|
||||
| ExposingNode
|
||||
| GlslContentNode
|
||||
| UnnamedNode<"if">
|
||||
| ImportNode
|
||||
| UnnamedNode<"in">
|
||||
| InfixNode
|
||||
| InvalidStringEscapeNode
|
||||
| UnnamedNode<"let">
|
||||
| LineCommentNode
|
||||
| LowerCaseIdentifierNode
|
||||
| ModuleNode
|
||||
| NumberLiteralNode
|
||||
| OfNode
|
||||
| OpenCharNode
|
||||
| OpenQuoteNode
|
||||
| PortNode
|
||||
| RegularStringPartNode
|
||||
| StringEscapeNode
|
||||
| UnnamedNode<"then">
|
||||
| TypeNode
|
||||
| UnderscoreNode
|
||||
| UpperCaseIdentifierNode
|
||||
| WhereNode
|
||||
| UnnamedNode<"{">
|
||||
| UnnamedNode<"{-">
|
||||
| UnnamedNode<"|">
|
||||
| UnnamedNode<"|.">
|
||||
| UnnamedNode<"|=">
|
||||
| UnnamedNode<"|>">
|
||||
| UnnamedNode<"||">
|
||||
| UnnamedNode<"}">
|
||||
| ErrorNode
|
||||
;
|
||||
|
||||
export interface AnonymousFunctionExprNode extends NamedNodeBase {
|
||||
type: SyntaxType.AnonymousFunctionExpr;
|
||||
exprNode: AnonymousFunctionExprNode | BinOpExprNode | CaseOfExprNode | CharConstantExprNode | FieldAccessExprNode | FieldAccessorFunctionExprNode | FunctionCallExprNode | GlslCodeExprNode | IfElseExprNode | LetInExprNode | ListExprNode | NegateExprNode | NumberConstantExprNode | OperatorAsFunctionExprNode | ParenthesizedExprNode | RecordExprNode | StringConstantExprNode | TupleExprNode | UnitExprNode | ValueExprNode;
|
||||
paramNodes: PatternNode[];
|
||||
}
|
||||
|
||||
export interface AnythingPatternNode extends NamedNodeBase {
|
||||
type: SyntaxType.AnythingPattern;
|
||||
}
|
||||
|
||||
export interface AsClauseNode extends NamedNodeBase {
|
||||
type: SyntaxType.AsClause;
|
||||
nameNode: UpperCaseIdentifierNode;
|
||||
}
|
||||
|
||||
export interface BinOpExprNode extends NamedNodeBase {
|
||||
type: SyntaxType.BinOpExpr;
|
||||
partNodes: (AnonymousFunctionExprNode | CaseOfExprNode | CharConstantExprNode | FieldAccessExprNode | FieldAccessorFunctionExprNode | FunctionCallExprNode | GlslCodeExprNode | IfElseExprNode | LetInExprNode | ListExprNode | NegateExprNode | NumberConstantExprNode | OperatorNode | OperatorAsFunctionExprNode | ParenthesizedExprNode | RecordExprNode | StringConstantExprNode | TupleExprNode | UnitExprNode | ValueExprNode)[];
|
||||
}
|
||||
|
||||
export interface BlockCommentNode extends NamedNodeBase {
|
||||
type: SyntaxType.BlockComment;
|
||||
}
|
||||
|
||||
export interface CaseOfBranchNode extends NamedNodeBase {
|
||||
type: SyntaxType.CaseOfBranch;
|
||||
exprNode: AnonymousFunctionExprNode | BinOpExprNode | CaseOfExprNode | CharConstantExprNode | FieldAccessExprNode | FieldAccessorFunctionExprNode | FunctionCallExprNode | GlslCodeExprNode | IfElseExprNode | LetInExprNode | ListExprNode | NegateExprNode | NumberConstantExprNode | OperatorAsFunctionExprNode | ParenthesizedExprNode | RecordExprNode | StringConstantExprNode | TupleExprNode | UnitExprNode | ValueExprNode;
|
||||
patternNode: PatternNode;
|
||||
}
|
||||
|
||||
export interface CaseOfExprNode extends NamedNodeBase {
|
||||
type: SyntaxType.CaseOfExpr;
|
||||
branchNodes: CaseOfBranchNode[];
|
||||
exprNode: AnonymousFunctionExprNode | BinOpExprNode | CaseOfExprNode | CharConstantExprNode | FieldAccessExprNode | FieldAccessorFunctionExprNode | FunctionCallExprNode | GlslCodeExprNode | IfElseExprNode | LetInExprNode | ListExprNode | NegateExprNode | NumberConstantExprNode | OperatorAsFunctionExprNode | ParenthesizedExprNode | RecordExprNode | StringConstantExprNode | TupleExprNode | UnitExprNode | ValueExprNode;
|
||||
}
|
||||
|
||||
export interface CharConstantExprNode extends NamedNodeBase {
|
||||
type: SyntaxType.CharConstantExpr;
|
||||
}
|
||||
|
||||
export interface ConsPatternNode extends NamedNodeBase {
|
||||
type: SyntaxType.ConsPattern;
|
||||
partNodes: (UnnamedNode<"("> | UnnamedNode<")"> | AnythingPatternNode | CharConstantExprNode | ConsPatternNode | ListPatternNode | LowerPatternNode | NumberConstantExprNode | PatternNode | RecordPatternNode | StringConstantExprNode | TuplePatternNode | UnionPatternNode | UnitExprNode)[];
|
||||
}
|
||||
|
||||
export interface ExposedOperatorNode extends NamedNodeBase {
|
||||
type: SyntaxType.ExposedOperator;
|
||||
operatorNode: OperatorIdentifierNode;
|
||||
}
|
||||
|
||||
export interface ExposedTypeNode extends NamedNodeBase {
|
||||
type: SyntaxType.ExposedType;
|
||||
}
|
||||
|
||||
export interface ExposedUnionConstructorsNode extends NamedNodeBase {
|
||||
type: SyntaxType.ExposedUnionConstructors;
|
||||
}
|
||||
|
||||
export interface ExposedValueNode extends NamedNodeBase {
|
||||
type: SyntaxType.ExposedValue;
|
||||
}
|
||||
|
||||
export interface ExposingListNode extends NamedNodeBase {
|
||||
type: SyntaxType.ExposingList;
|
||||
doubleDotNode?: DoubleDotNode;
|
||||
}
|
||||
|
||||
export interface FieldNode extends NamedNodeBase {
|
||||
type: SyntaxType.Field;
|
||||
expressionNode: AnonymousFunctionExprNode | BinOpExprNode | CaseOfExprNode | CharConstantExprNode | FieldAccessExprNode | FieldAccessorFunctionExprNode | FunctionCallExprNode | GlslCodeExprNode | IfElseExprNode | LetInExprNode | ListExprNode | NegateExprNode | NumberConstantExprNode | OperatorAsFunctionExprNode | ParenthesizedExprNode | RecordExprNode | StringConstantExprNode | TupleExprNode | UnitExprNode | ValueExprNode;
|
||||
nameNode: LowerCaseIdentifierNode;
|
||||
}
|
||||
|
||||
export interface FieldAccessExprNode extends NamedNodeBase {
|
||||
type: SyntaxType.FieldAccessExpr;
|
||||
targetNode: FieldAccessExprNode | ParenthesizedExprNode | RecordExprNode | ValueExprNode;
|
||||
}
|
||||
|
||||
export interface FieldAccessorFunctionExprNode extends NamedNodeBase {
|
||||
type: SyntaxType.FieldAccessorFunctionExpr;
|
||||
}
|
||||
|
||||
export interface FieldTypeNode extends NamedNodeBase {
|
||||
type: SyntaxType.FieldType;
|
||||
nameNode: LowerCaseIdentifierNode;
|
||||
typeExpressionNode: TypeExpressionNode;
|
||||
}
|
||||
|
||||
export interface FileNode extends NamedNodeBase {
|
||||
type: SyntaxType.File;
|
||||
moduleDeclarationNode?: ModuleDeclarationNode;
|
||||
}
|
||||
|
||||
export interface FunctionCallExprNode extends NamedNodeBase {
|
||||
type: SyntaxType.FunctionCallExpr;
|
||||
argNodes: (AnonymousFunctionExprNode | CaseOfExprNode | CharConstantExprNode | FieldAccessExprNode | FieldAccessorFunctionExprNode | GlslCodeExprNode | IfElseExprNode | LetInExprNode | ListExprNode | NegateExprNode | NumberConstantExprNode | OperatorAsFunctionExprNode | ParenthesizedExprNode | RecordExprNode | StringConstantExprNode | TupleExprNode | UnitExprNode | ValueExprNode)[];
|
||||
targetNode: FieldAccessExprNode | FieldAccessorFunctionExprNode | OperatorAsFunctionExprNode | ParenthesizedExprNode | ValueExprNode;
|
||||
}
|
||||
|
||||
export interface FunctionDeclarationLeftNode extends NamedNodeBase {
|
||||
type: SyntaxType.FunctionDeclarationLeft;
|
||||
patternNodes: (UnnamedNode<"("> | UnnamedNode<")"> | AnythingPatternNode | CharConstantExprNode | ListPatternNode | LowerPatternNode | NumberConstantExprNode | PatternNode | RecordPatternNode | StringConstantExprNode | TuplePatternNode | UnitExprNode)[];
|
||||
}
|
||||
|
||||
export interface GlslCodeExprNode extends NamedNodeBase {
|
||||
type: SyntaxType.GlslCodeExpr;
|
||||
contentNode: GlslContentNode;
|
||||
}
|
||||
|
||||
export interface IfElseExprNode extends NamedNodeBase {
|
||||
type: SyntaxType.IfElseExpr;
|
||||
exprListNodes: (AnonymousFunctionExprNode | BinOpExprNode | CaseOfExprNode | CharConstantExprNode | FieldAccessExprNode | FieldAccessorFunctionExprNode | FunctionCallExprNode | GlslCodeExprNode | IfElseExprNode | LetInExprNode | ListExprNode | NegateExprNode | NumberConstantExprNode | OperatorAsFunctionExprNode | ParenthesizedExprNode | RecordExprNode | StringConstantExprNode | TupleExprNode | UnitExprNode | ValueExprNode)[];
|
||||
}
|
||||
|
||||
export interface ImportClauseNode extends NamedNodeBase {
|
||||
type: SyntaxType.ImportClause;
|
||||
asClauseNode?: AsClauseNode;
|
||||
exposingNode?: ExposingListNode;
|
||||
moduleNameNode: UpperCaseQidNode;
|
||||
}
|
||||
|
||||
export interface InfixDeclarationNode extends NamedNodeBase {
|
||||
type: SyntaxType.InfixDeclaration;
|
||||
associativityNode: LowerCaseIdentifierNode;
|
||||
operatorNode: OperatorIdentifierNode;
|
||||
precedenceNode: NumberLiteralNode;
|
||||
}
|
||||
|
||||
export interface LetInExprNode extends NamedNodeBase {
|
||||
type: SyntaxType.LetInExpr;
|
||||
bodyNode: AnonymousFunctionExprNode | BinOpExprNode | CaseOfExprNode | CharConstantExprNode | FieldAccessExprNode | FieldAccessorFunctionExprNode | FunctionCallExprNode | GlslCodeExprNode | IfElseExprNode | LetInExprNode | ListExprNode | NegateExprNode | NumberConstantExprNode | OperatorAsFunctionExprNode | ParenthesizedExprNode | RecordExprNode | StringConstantExprNode | TupleExprNode | UnitExprNode | ValueExprNode;
|
||||
valueDeclarationNodes: ValueDeclarationNode[];
|
||||
}
|
||||
|
||||
export interface ListExprNode extends NamedNodeBase {
|
||||
type: SyntaxType.ListExpr;
|
||||
exprListNodes: (AnonymousFunctionExprNode | BinOpExprNode | CaseOfExprNode | CharConstantExprNode | FieldAccessExprNode | FieldAccessorFunctionExprNode | FunctionCallExprNode | GlslCodeExprNode | IfElseExprNode | LetInExprNode | ListExprNode | NegateExprNode | NumberConstantExprNode | OperatorAsFunctionExprNode | ParenthesizedExprNode | RecordExprNode | StringConstantExprNode | TupleExprNode | UnitExprNode | ValueExprNode)[];
|
||||
}
|
||||
|
||||
export interface ListPatternNode extends NamedNodeBase {
|
||||
type: SyntaxType.ListPattern;
|
||||
partNodes: PatternNode[];
|
||||
}
|
||||
|
||||
export interface LowerPatternNode extends NamedNodeBase {
|
||||
type: SyntaxType.LowerPattern;
|
||||
}
|
||||
|
||||
export interface LowerTypeNameNode extends NamedNodeBase {
|
||||
type: SyntaxType.LowerTypeName;
|
||||
}
|
||||
|
||||
export interface ModuleDeclarationNode extends NamedNodeBase {
|
||||
type: SyntaxType.ModuleDeclaration;
|
||||
exposingNode: ExposingListNode;
|
||||
nameNode: UpperCaseQidNode;
|
||||
}
|
||||
|
||||
export interface NegateExprNode extends NamedNodeBase {
|
||||
type: SyntaxType.NegateExpr;
|
||||
}
|
||||
|
||||
export interface NullaryConstructorArgumentPatternNode extends NamedNodeBase {
|
||||
type: SyntaxType.NullaryConstructorArgumentPattern;
|
||||
}
|
||||
|
||||
export interface NumberConstantExprNode extends NamedNodeBase {
|
||||
type: SyntaxType.NumberConstantExpr;
|
||||
}
|
||||
|
||||
export interface OperatorNode extends NamedNodeBase {
|
||||
type: SyntaxType.Operator;
|
||||
}
|
||||
|
||||
export interface OperatorAsFunctionExprNode extends NamedNodeBase {
|
||||
type: SyntaxType.OperatorAsFunctionExpr;
|
||||
operatorNode: OperatorIdentifierNode;
|
||||
}
|
||||
|
||||
export interface OperatorIdentifierNode extends NamedNodeBase {
|
||||
type: SyntaxType.OperatorIdentifier;
|
||||
}
|
||||
|
||||
export interface ParenthesizedExprNode extends NamedNodeBase {
|
||||
type: SyntaxType.ParenthesizedExpr;
|
||||
expressionNode: AnonymousFunctionExprNode | BinOpExprNode | CaseOfExprNode | CharConstantExprNode | FieldAccessExprNode | FieldAccessorFunctionExprNode | FunctionCallExprNode | GlslCodeExprNode | IfElseExprNode | LetInExprNode | ListExprNode | NegateExprNode | NumberConstantExprNode | OperatorAsFunctionExprNode | ParenthesizedExprNode | RecordExprNode | StringConstantExprNode | TupleExprNode | UnitExprNode | ValueExprNode;
|
||||
}
|
||||
|
||||
export interface PatternNode extends NamedNodeBase {
|
||||
type: SyntaxType.Pattern;
|
||||
childNode: AnythingPatternNode | CharConstantExprNode | ConsPatternNode | ListPatternNode | LowerPatternNode | NumberConstantExprNode | PatternNode | RecordPatternNode | StringConstantExprNode | TuplePatternNode | UnionPatternNode | UnitExprNode;
|
||||
patternAsNode?: LowerPatternNode;
|
||||
}
|
||||
|
||||
export interface PortAnnotationNode extends NamedNodeBase {
|
||||
type: SyntaxType.PortAnnotation;
|
||||
nameNode: LowerCaseIdentifierNode;
|
||||
typeExpressionNode: TypeExpressionNode;
|
||||
}
|
||||
|
||||
export interface RecordBaseIdentifierNode extends NamedNodeBase {
|
||||
type: SyntaxType.RecordBaseIdentifier;
|
||||
}
|
||||
|
||||
export interface RecordExprNode extends NamedNodeBase {
|
||||
type: SyntaxType.RecordExpr;
|
||||
baseRecordNode?: RecordBaseIdentifierNode;
|
||||
fieldNodes: FieldNode[];
|
||||
}
|
||||
|
||||
export interface RecordPatternNode extends NamedNodeBase {
|
||||
type: SyntaxType.RecordPattern;
|
||||
patternListNodes: LowerPatternNode[];
|
||||
}
|
||||
|
||||
export interface RecordTypeNode extends NamedNodeBase {
|
||||
type: SyntaxType.RecordType;
|
||||
baseRecordNode?: RecordBaseIdentifierNode;
|
||||
fieldTypeNodes: FieldTypeNode[];
|
||||
}
|
||||
|
||||
export interface StringConstantExprNode extends NamedNodeBase {
|
||||
type: SyntaxType.StringConstantExpr;
|
||||
}
|
||||
|
||||
export interface TupleExprNode extends NamedNodeBase {
|
||||
type: SyntaxType.TupleExpr;
|
||||
exprNodes: (AnonymousFunctionExprNode | BinOpExprNode | CaseOfExprNode | CharConstantExprNode | FieldAccessExprNode | FieldAccessorFunctionExprNode | FunctionCallExprNode | GlslCodeExprNode | IfElseExprNode | LetInExprNode | ListExprNode | NegateExprNode | NumberConstantExprNode | OperatorAsFunctionExprNode | ParenthesizedExprNode | RecordExprNode | StringConstantExprNode | TupleExprNode | UnitExprNode | ValueExprNode)[];
|
||||
}
|
||||
|
||||
export interface TuplePatternNode extends NamedNodeBase {
|
||||
type: SyntaxType.TuplePattern;
|
||||
patternNodes: PatternNode[];
|
||||
}
|
||||
|
||||
export interface TupleTypeNode extends NamedNodeBase {
|
||||
type: SyntaxType.TupleType;
|
||||
typeExpressionNodes: TypeExpressionNode[];
|
||||
unitExprNode?: UnitExprNode;
|
||||
}
|
||||
|
||||
export interface TypeAliasDeclarationNode extends NamedNodeBase {
|
||||
type: SyntaxType.TypeAliasDeclaration;
|
||||
nameNode: UpperCaseIdentifierNode;
|
||||
typeExpressionNode: TypeExpressionNode;
|
||||
typeVariableNodes: LowerTypeNameNode[];
|
||||
}
|
||||
|
||||
export interface TypeAnnotationNode extends NamedNodeBase {
|
||||
type: SyntaxType.TypeAnnotation;
|
||||
nameNode: LowerCaseIdentifierNode;
|
||||
typeExpressionNode: TypeExpressionNode;
|
||||
}
|
||||
|
||||
export interface TypeDeclarationNode extends NamedNodeBase {
|
||||
type: SyntaxType.TypeDeclaration;
|
||||
nameNode: UpperCaseIdentifierNode;
|
||||
typeNameNodes: LowerTypeNameNode[];
|
||||
unionVariantNodes: UnionVariantNode[];
|
||||
}
|
||||
|
||||
export interface TypeExpressionNode extends NamedNodeBase {
|
||||
type: SyntaxType.TypeExpression;
|
||||
partNodes: (RecordTypeNode | TupleTypeNode | TypeExpressionNode | TypeRefNode | TypeVariableNode)[];
|
||||
}
|
||||
|
||||
export interface TypeRefNode extends NamedNodeBase {
|
||||
type: SyntaxType.TypeRef;
|
||||
partNodes: (RecordTypeNode | TupleTypeNode | TypeExpressionNode | TypeRefNode | TypeVariableNode)[];
|
||||
}
|
||||
|
||||
export interface TypeVariableNode extends NamedNodeBase {
|
||||
type: SyntaxType.TypeVariable;
|
||||
}
|
||||
|
||||
export interface UnionPatternNode extends NamedNodeBase {
|
||||
type: SyntaxType.UnionPattern;
|
||||
argPatternNodes: (UnnamedNode<"("> | UnnamedNode<")"> | AnythingPatternNode | CharConstantExprNode | ListPatternNode | LowerPatternNode | NullaryConstructorArgumentPatternNode | NumberConstantExprNode | PatternNode | RecordPatternNode | StringConstantExprNode | TuplePatternNode | UnitExprNode)[];
|
||||
constructorNode: UpperCaseQidNode;
|
||||
}
|
||||
|
||||
export interface UnionVariantNode extends NamedNodeBase {
|
||||
type: SyntaxType.UnionVariant;
|
||||
nameNode: UpperCaseIdentifierNode;
|
||||
partNodes: (RecordTypeNode | TupleTypeNode | TypeExpressionNode | TypeRefNode | TypeVariableNode)[];
|
||||
}
|
||||
|
||||
export interface UnitExprNode extends NamedNodeBase {
|
||||
type: SyntaxType.UnitExpr;
|
||||
}
|
||||
|
||||
export interface UpperCaseQidNode extends NamedNodeBase {
|
||||
type: SyntaxType.UpperCaseQid;
|
||||
}
|
||||
|
||||
export interface ValueDeclarationNode extends NamedNodeBase {
|
||||
type: SyntaxType.ValueDeclaration;
|
||||
bodyNode: AnonymousFunctionExprNode | BinOpExprNode | CaseOfExprNode | CharConstantExprNode | FieldAccessExprNode | FieldAccessorFunctionExprNode | FunctionCallExprNode | GlslCodeExprNode | IfElseExprNode | LetInExprNode | ListExprNode | NegateExprNode | NumberConstantExprNode | OperatorAsFunctionExprNode | ParenthesizedExprNode | RecordExprNode | StringConstantExprNode | TupleExprNode | UnitExprNode | ValueExprNode;
|
||||
functionDeclarationLeftNode?: FunctionDeclarationLeftNode;
|
||||
patternNode?: PatternNode;
|
||||
}
|
||||
|
||||
export interface ValueExprNode extends NamedNodeBase {
|
||||
type: SyntaxType.ValueExpr;
|
||||
nameNode: UpperCaseQidNode | ValueQidNode;
|
||||
}
|
||||
|
||||
export interface ValueQidNode extends NamedNodeBase {
|
||||
type: SyntaxType.ValueQid;
|
||||
}
|
||||
|
||||
export interface AliasNode extends NamedNodeBase {
|
||||
type: SyntaxType.Alias;
|
||||
}
|
||||
|
||||
export interface ArrowNode extends NamedNodeBase {
|
||||
type: SyntaxType.Arrow;
|
||||
}
|
||||
|
||||
export interface AsNode extends NamedNodeBase {
|
||||
type: SyntaxType.As;
|
||||
}
|
||||
|
||||
export interface BackslashNode extends NamedNodeBase {
|
||||
type: SyntaxType.Backslash;
|
||||
}
|
||||
|
||||
export interface CaseNode extends NamedNodeBase {
|
||||
type: SyntaxType.Case;
|
||||
}
|
||||
|
||||
export interface CloseCharNode extends NamedNodeBase {
|
||||
type: SyntaxType.CloseChar;
|
||||
}
|
||||
|
||||
export interface CloseQuoteNode extends NamedNodeBase {
|
||||
type: SyntaxType.CloseQuote;
|
||||
}
|
||||
|
||||
export interface ColonNode extends NamedNodeBase {
|
||||
type: SyntaxType.Colon;
|
||||
}
|
||||
|
||||
export interface DotNode extends NamedNodeBase {
|
||||
type: SyntaxType.Dot;
|
||||
}
|
||||
|
||||
export interface DoubleDotNode extends NamedNodeBase {
|
||||
type: SyntaxType.DoubleDot;
|
||||
}
|
||||
|
||||
export interface EffectNode extends NamedNodeBase {
|
||||
type: SyntaxType.Effect;
|
||||
}
|
||||
|
||||
export interface EqNode extends NamedNodeBase {
|
||||
type: SyntaxType.Eq;
|
||||
}
|
||||
|
||||
export interface ExposingNode extends NamedNodeBase {
|
||||
type: SyntaxType.Exposing;
|
||||
}
|
||||
|
||||
export interface GlslContentNode extends NamedNodeBase {
|
||||
type: SyntaxType.GlslContent;
|
||||
}
|
||||
|
||||
export interface ImportNode extends NamedNodeBase {
|
||||
type: SyntaxType.Import;
|
||||
}
|
||||
|
||||
export interface InfixNode extends NamedNodeBase {
|
||||
type: SyntaxType.Infix;
|
||||
}
|
||||
|
||||
export interface InvalidStringEscapeNode extends NamedNodeBase {
|
||||
type: SyntaxType.InvalidStringEscape;
|
||||
}
|
||||
|
||||
export interface LineCommentNode extends NamedNodeBase {
|
||||
type: SyntaxType.LineComment;
|
||||
}
|
||||
|
||||
export interface LowerCaseIdentifierNode extends NamedNodeBase {
|
||||
type: SyntaxType.LowerCaseIdentifier;
|
||||
}
|
||||
|
||||
export interface ModuleNode extends NamedNodeBase {
|
||||
type: SyntaxType.Module;
|
||||
}
|
||||
|
||||
export interface NumberLiteralNode extends NamedNodeBase {
|
||||
type: SyntaxType.NumberLiteral;
|
||||
}
|
||||
|
||||
export interface OfNode extends NamedNodeBase {
|
||||
type: SyntaxType.Of;
|
||||
}
|
||||
|
||||
export interface OpenCharNode extends NamedNodeBase {
|
||||
type: SyntaxType.OpenChar;
|
||||
}
|
||||
|
||||
export interface OpenQuoteNode extends NamedNodeBase {
|
||||
type: SyntaxType.OpenQuote;
|
||||
}
|
||||
|
||||
export interface PortNode extends NamedNodeBase {
|
||||
type: SyntaxType.Port;
|
||||
}
|
||||
|
||||
export interface RegularStringPartNode extends NamedNodeBase {
|
||||
type: SyntaxType.RegularStringPart;
|
||||
}
|
||||
|
||||
export interface StringEscapeNode extends NamedNodeBase {
|
||||
type: SyntaxType.StringEscape;
|
||||
}
|
||||
|
||||
export interface TypeNode extends NamedNodeBase {
|
||||
type: SyntaxType.Type;
|
||||
}
|
||||
|
||||
export interface UnderscoreNode extends NamedNodeBase {
|
||||
type: SyntaxType.Underscore;
|
||||
}
|
||||
|
||||
export interface UpperCaseIdentifierNode extends NamedNodeBase {
|
||||
type: SyntaxType.UpperCaseIdentifier;
|
||||
}
|
||||
|
||||
export interface WhereNode extends NamedNodeBase {
|
||||
type: SyntaxType.Where;
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
@ -0,0 +1,496 @@
|
||||
#include "tree_sitter/parser.h"
|
||||
#include <assert.h>
|
||||
#include <stdint.h>
|
||||
#include <stdio.h>
|
||||
#include <string.h>
|
||||
|
||||
#define MAX(a, b) ((a) > (b) ? (a) : (b))
|
||||
|
||||
#define VEC_RESIZE(vec, _cap) \
|
||||
void *tmp = realloc((vec).data, (_cap) * sizeof((vec).data[0])); \
|
||||
assert(tmp != NULL); \
|
||||
(vec).data = tmp; \
|
||||
assert((vec).data != NULL); \
|
||||
(vec).cap = (_cap);
|
||||
|
||||
#define VEC_GROW(vec, _cap) \
|
||||
if ((vec).cap < (_cap)) { \
|
||||
VEC_RESIZE((vec), (_cap)); \
|
||||
}
|
||||
|
||||
#define VEC_PUSH(vec, el) \
|
||||
if ((vec).cap == (vec).len) { \
|
||||
VEC_RESIZE((vec), MAX(16, (vec).len * 2)); \
|
||||
} \
|
||||
(vec).data[(vec).len++] = (el);
|
||||
|
||||
#define VEC_POP(vec) (vec).len--;
|
||||
|
||||
#define VEC_BACK(vec) ((vec).data[(vec).len - 1])
|
||||
|
||||
#define VEC_FREE(vec) \
|
||||
{ \
|
||||
if ((vec).data != NULL) \
|
||||
free((vec).data); \
|
||||
}
|
||||
|
||||
#define VEC_CLEAR(vec) (vec).len = 0;
|
||||
|
||||
#define VEC_REVERSE(vec) \
|
||||
do { \
|
||||
if ((vec).len > 1) { \
|
||||
for (size_t i = 0, j = (vec).len - 1; i < j; i++, j--) { \
|
||||
uint8_t tmp = (vec).data[i]; \
|
||||
(vec).data[i] = (vec).data[j]; \
|
||||
(vec).data[j] = tmp; \
|
||||
} \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
enum TokenType {
|
||||
VIRTUAL_END_DECL,
|
||||
VIRTUAL_OPEN_SECTION,
|
||||
VIRTUAL_END_SECTION,
|
||||
MINUS_WITHOUT_TRAILING_WHITESPACE,
|
||||
GLSL_CONTENT,
|
||||
BLOCK_COMMENT_CONTENT,
|
||||
};
|
||||
|
||||
typedef struct {
|
||||
uint32_t len;
|
||||
uint32_t cap;
|
||||
uint8_t *data;
|
||||
} vec;
|
||||
|
||||
typedef struct {
|
||||
uint32_t indent_length;
|
||||
vec indents;
|
||||
vec runback;
|
||||
} Scanner;
|
||||
|
||||
static inline void advance(TSLexer *lexer) { lexer->advance(lexer, false); }
|
||||
|
||||
static inline void skip(TSLexer *lexer) { lexer->advance(lexer, true); }
|
||||
|
||||
// > You can detect error recovery in the external scanner by the fact that
|
||||
// > _all_ tokens are considered valid at once.
|
||||
// https://github.com/tree-sitter/tree-sitter/pull/1783#issuecomment-1181011411
|
||||
static bool in_error_recovery(const bool *valid_symbols) {
|
||||
return (valid_symbols[VIRTUAL_END_DECL] &&
|
||||
valid_symbols[VIRTUAL_OPEN_SECTION] &&
|
||||
valid_symbols[VIRTUAL_END_SECTION] &&
|
||||
valid_symbols[MINUS_WITHOUT_TRAILING_WHITESPACE] &&
|
||||
valid_symbols[GLSL_CONTENT] &&
|
||||
valid_symbols[BLOCK_COMMENT_CONTENT]);
|
||||
}
|
||||
|
||||
static bool is_elm_space(TSLexer *lexer) {
|
||||
return lexer->lookahead == ' ' || lexer->lookahead == '\r' ||
|
||||
lexer->lookahead == '\n';
|
||||
}
|
||||
|
||||
static int checkForIn(TSLexer *lexer, const bool *valid_symbols) {
|
||||
// Are we at the end of a let (in) declaration
|
||||
if (valid_symbols[VIRTUAL_END_SECTION] && lexer->lookahead == 'i') {
|
||||
skip(lexer);
|
||||
|
||||
if (lexer->lookahead == 'n') {
|
||||
skip(lexer);
|
||||
if (is_elm_space(lexer) || lexer->eof(lexer)) {
|
||||
return 2; // Success
|
||||
}
|
||||
return 1; // Partial
|
||||
}
|
||||
return 1; // Partial
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
static bool scan_block_comment(TSLexer *lexer) {
|
||||
lexer->mark_end(lexer);
|
||||
if (lexer->lookahead != '{') {
|
||||
return false;
|
||||
}
|
||||
|
||||
advance(lexer);
|
||||
if (lexer->lookahead != '-') {
|
||||
return false;
|
||||
}
|
||||
|
||||
advance(lexer);
|
||||
|
||||
while (true) {
|
||||
switch (lexer->lookahead) {
|
||||
case '{':
|
||||
scan_block_comment(lexer);
|
||||
break;
|
||||
case '-':
|
||||
advance(lexer);
|
||||
if (lexer->lookahead == '}') {
|
||||
advance(lexer);
|
||||
return true;
|
||||
}
|
||||
break;
|
||||
case '\0':
|
||||
return true;
|
||||
default:
|
||||
advance(lexer);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void advance_to_line_end(TSLexer *lexer) {
|
||||
while (true) {
|
||||
if (lexer->lookahead == '\n' || lexer->eof(lexer)) {
|
||||
break;
|
||||
}
|
||||
advance(lexer);
|
||||
}
|
||||
}
|
||||
|
||||
static bool scan(Scanner *scanner, TSLexer *lexer, const bool *valid_symbols) {
|
||||
if (in_error_recovery(valid_symbols)) {
|
||||
return false;
|
||||
}
|
||||
|
||||
// First handle eventual runback tokens, we saved on a previous scan op
|
||||
if (scanner->runback.len > 0 && VEC_BACK(scanner->runback) == 0 &&
|
||||
valid_symbols[VIRTUAL_END_DECL]) {
|
||||
VEC_POP(scanner->runback);
|
||||
lexer->result_symbol = VIRTUAL_END_DECL;
|
||||
return true;
|
||||
}
|
||||
if (scanner->runback.len > 0 && VEC_BACK(scanner->runback) == 1 &&
|
||||
valid_symbols[VIRTUAL_END_SECTION]) {
|
||||
VEC_POP(scanner->runback);
|
||||
lexer->result_symbol = VIRTUAL_END_SECTION;
|
||||
return true;
|
||||
}
|
||||
VEC_CLEAR(scanner->runback);
|
||||
|
||||
// Check if we have newlines and how much indentation
|
||||
bool has_newline = false;
|
||||
bool found_in = false;
|
||||
bool can_call_mark_end = true;
|
||||
lexer->mark_end(lexer);
|
||||
while (true) {
|
||||
if (lexer->lookahead == ' ' || lexer->lookahead == '\r') {
|
||||
skip(lexer);
|
||||
} else if (lexer->lookahead == '\n') {
|
||||
skip(lexer);
|
||||
has_newline = true;
|
||||
while (true) {
|
||||
if (lexer->lookahead == ' ') {
|
||||
skip(lexer);
|
||||
} else {
|
||||
scanner->indent_length = lexer->get_column(lexer);
|
||||
break;
|
||||
}
|
||||
}
|
||||
} else if (!valid_symbols[BLOCK_COMMENT_CONTENT] &&
|
||||
lexer->lookahead == '-') {
|
||||
advance(lexer);
|
||||
int32_t lookahead = lexer->lookahead;
|
||||
|
||||
// Handle minus without a whitespace for negate
|
||||
if (valid_symbols[MINUS_WITHOUT_TRAILING_WHITESPACE] &&
|
||||
((lookahead >= 'a' && lookahead <= 'z') ||
|
||||
(lookahead >= 'A' && lookahead <= 'Z') || lookahead == '(')) {
|
||||
if (can_call_mark_end) {
|
||||
lexer->result_symbol = MINUS_WITHOUT_TRAILING_WHITESPACE;
|
||||
lexer->mark_end(lexer);
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
// Scan past line comments. As far as the special token
|
||||
// types we're scanning for here are concerned line comments
|
||||
// are like whitespace. There is nothing useful to be
|
||||
// learned from, say, their indentation. So we advance past
|
||||
// them here.
|
||||
//
|
||||
// The one thing we need to keep in mind is that we should
|
||||
// not call `lexer->mark_end(lexer)` after this point, or
|
||||
// the comment will be lost.
|
||||
if (lookahead == '-' && has_newline) {
|
||||
can_call_mark_end = false;
|
||||
advance(lexer);
|
||||
advance_to_line_end(lexer);
|
||||
} else if (valid_symbols[BLOCK_COMMENT_CONTENT] &&
|
||||
lexer->lookahead == '}') {
|
||||
lexer->result_symbol = BLOCK_COMMENT_CONTENT;
|
||||
return true;
|
||||
} else {
|
||||
return false;
|
||||
}
|
||||
} else if (lexer->eof(lexer)) {
|
||||
if (valid_symbols[VIRTUAL_END_SECTION]) {
|
||||
lexer->result_symbol = VIRTUAL_END_SECTION;
|
||||
return true;
|
||||
}
|
||||
if (valid_symbols[VIRTUAL_END_DECL]) {
|
||||
lexer->result_symbol = VIRTUAL_END_DECL;
|
||||
return true;
|
||||
}
|
||||
|
||||
break;
|
||||
} else {
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (checkForIn(lexer, valid_symbols) == 2) {
|
||||
if (has_newline) {
|
||||
found_in = true;
|
||||
} else {
|
||||
lexer->result_symbol = VIRTUAL_END_SECTION;
|
||||
VEC_POP(scanner->indents);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
// Open section if the grammar lets us but only push to indent stack if
|
||||
// we go further down in the stack
|
||||
if (valid_symbols[VIRTUAL_OPEN_SECTION] && !lexer->eof(lexer)) {
|
||||
VEC_PUSH(scanner->indents, lexer->get_column(lexer));
|
||||
lexer->result_symbol = VIRTUAL_OPEN_SECTION;
|
||||
return true;
|
||||
}
|
||||
if (valid_symbols[BLOCK_COMMENT_CONTENT]) {
|
||||
if (!can_call_mark_end) {
|
||||
return false;
|
||||
}
|
||||
lexer->mark_end(lexer);
|
||||
while (true) {
|
||||
if (lexer->lookahead == '\0') {
|
||||
break;
|
||||
}
|
||||
if (lexer->lookahead != '{' && lexer->lookahead != '-') {
|
||||
advance(lexer);
|
||||
} else if (lexer->lookahead == '-') {
|
||||
lexer->mark_end(lexer);
|
||||
advance(lexer);
|
||||
if (lexer->lookahead == '}') {
|
||||
break;
|
||||
}
|
||||
} else if (scan_block_comment(lexer)) {
|
||||
lexer->mark_end(lexer);
|
||||
advance(lexer);
|
||||
if (lexer->lookahead == '-') {
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
lexer->result_symbol = BLOCK_COMMENT_CONTENT;
|
||||
return true;
|
||||
}
|
||||
if (has_newline) {
|
||||
// We had a newline now it's time to check if we need to add
|
||||
// multiple tokens to get back up to the right level
|
||||
VEC_CLEAR(scanner->runback);
|
||||
|
||||
while (scanner->indent_length <= VEC_BACK(scanner->indents)) {
|
||||
if (scanner->indent_length == VEC_BACK(scanner->indents)) {
|
||||
if (found_in) {
|
||||
VEC_PUSH(scanner->runback, 1);
|
||||
found_in = false;
|
||||
break;
|
||||
}
|
||||
// Don't insert VIRTUAL_END_DECL when there is a line
|
||||
// comment incoming
|
||||
|
||||
if (lexer->lookahead == '-') {
|
||||
skip(lexer);
|
||||
if (lexer->lookahead == '-') {
|
||||
break;
|
||||
}
|
||||
}
|
||||
// Don't insert VIRTUAL_END_DECL when there is a block
|
||||
// comment incoming
|
||||
if (lexer->lookahead == '{') {
|
||||
skip(lexer);
|
||||
if (lexer->lookahead == '-') {
|
||||
break;
|
||||
}
|
||||
}
|
||||
VEC_PUSH(scanner->runback, 0);
|
||||
break;
|
||||
}
|
||||
if (scanner->indent_length < VEC_BACK(scanner->indents)) {
|
||||
VEC_POP(scanner->indents);
|
||||
VEC_PUSH(scanner->runback, 1);
|
||||
found_in = false;
|
||||
}
|
||||
}
|
||||
|
||||
// Needed for some of the more weird cases where let is in the same
|
||||
// line as everything before the in in the next line
|
||||
if (found_in) {
|
||||
VEC_PUSH(scanner->runback, 1);
|
||||
found_in = false;
|
||||
}
|
||||
|
||||
// Our list is the wrong way around, reverse it
|
||||
VEC_REVERSE(scanner->runback);
|
||||
// Handle the first runback token if we have them, if there are more
|
||||
// they will be handled on the next scan operation
|
||||
if (scanner->runback.len > 0 && VEC_BACK(scanner->runback) == 0 &&
|
||||
valid_symbols[VIRTUAL_END_DECL]) {
|
||||
VEC_POP(scanner->runback);
|
||||
lexer->result_symbol = VIRTUAL_END_DECL;
|
||||
return true;
|
||||
}
|
||||
if (scanner->runback.len > 0 && VEC_BACK(scanner->runback) == 1 &&
|
||||
valid_symbols[VIRTUAL_END_SECTION]) {
|
||||
VEC_POP(scanner->runback);
|
||||
lexer->result_symbol = VIRTUAL_END_SECTION;
|
||||
return true;
|
||||
}
|
||||
if (lexer->eof(lexer) && valid_symbols[VIRTUAL_END_SECTION]) {
|
||||
lexer->result_symbol = VIRTUAL_END_SECTION;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
if (valid_symbols[GLSL_CONTENT]) {
|
||||
if (!can_call_mark_end) {
|
||||
return false;
|
||||
}
|
||||
lexer->result_symbol = GLSL_CONTENT;
|
||||
while (true) {
|
||||
switch (lexer->lookahead) {
|
||||
case '|':
|
||||
lexer->mark_end(lexer);
|
||||
advance(lexer);
|
||||
if (lexer->lookahead == ']') {
|
||||
advance(lexer);
|
||||
return true;
|
||||
}
|
||||
break;
|
||||
case '\0':
|
||||
lexer->mark_end(lexer);
|
||||
return true;
|
||||
default:
|
||||
advance(lexer);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
// --------------------------------------------------------------------------------------------------------
|
||||
// API
|
||||
// --------------------------------------------------------------------------------------------------------
|
||||
|
||||
/**
|
||||
* This function allocates the persistent state of the parser that is passed
|
||||
* into the other API functions.
|
||||
*/
|
||||
void *tree_sitter_elm_external_scanner_create() {
|
||||
Scanner *scanner = (Scanner *)calloc(1, sizeof(Scanner));
|
||||
return scanner;
|
||||
}
|
||||
|
||||
/**
|
||||
* Main logic entry point.
|
||||
* Since the state is a singular vector, it can just be cast and used directly.
|
||||
*/
|
||||
bool tree_sitter_elm_external_scanner_scan(void *payload, TSLexer *lexer,
|
||||
const bool *valid_symbols) {
|
||||
Scanner *scanner = (Scanner *)payload;
|
||||
return scan(scanner, lexer, valid_symbols);
|
||||
}
|
||||
|
||||
/**
|
||||
* Copy the current state to another location for later reuse.
|
||||
* This is normally more complex, but since this parser's state constists solely
|
||||
* of a vector of integers, it can just be copied.
|
||||
*/
|
||||
unsigned tree_sitter_elm_external_scanner_serialize(void *payload,
|
||||
char *buffer) {
|
||||
Scanner *scanner = (Scanner *)payload;
|
||||
size_t size = 0;
|
||||
|
||||
if (3 + scanner->indents.len + scanner->runback.len >=
|
||||
TREE_SITTER_SERIALIZATION_BUFFER_SIZE) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
size_t runback_count = scanner->runback.len;
|
||||
if (runback_count > UINT8_MAX) {
|
||||
runback_count = UINT8_MAX;
|
||||
}
|
||||
buffer[size++] = (char)runback_count;
|
||||
|
||||
if (runback_count > 0) {
|
||||
memcpy(&buffer[size], scanner->runback.data, runback_count);
|
||||
}
|
||||
size += runback_count;
|
||||
|
||||
size_t indent_length_length = sizeof(scanner->indent_length);
|
||||
buffer[size++] = (char)indent_length_length;
|
||||
if (indent_length_length > 0) {
|
||||
memcpy(&buffer[size], &scanner->indent_length, indent_length_length);
|
||||
}
|
||||
size += indent_length_length;
|
||||
|
||||
int iter = 1;
|
||||
for (; iter != scanner->indents.len &&
|
||||
size < TREE_SITTER_SERIALIZATION_BUFFER_SIZE;
|
||||
++iter) {
|
||||
buffer[size++] = (char)scanner->indents.data[iter];
|
||||
}
|
||||
|
||||
return size;
|
||||
}
|
||||
|
||||
/**
|
||||
* Load another parser state into the currently active state.
|
||||
* `payload` is the state of the previous parser execution, while `buffer` is
|
||||
* the saved state of a different position (e.g. when doing incremental
|
||||
* parsing).
|
||||
*/
|
||||
void tree_sitter_elm_external_scanner_deserialize(void *payload,
|
||||
const char *buffer,
|
||||
unsigned length) {
|
||||
Scanner *scanner = (Scanner *)payload;
|
||||
VEC_CLEAR(scanner->runback);
|
||||
VEC_CLEAR(scanner->indents);
|
||||
VEC_PUSH(scanner->indents, 0);
|
||||
|
||||
if (length == 0) {
|
||||
return;
|
||||
}
|
||||
|
||||
size_t size = 0;
|
||||
size_t runback_count = (unsigned char)buffer[size++];
|
||||
VEC_GROW(scanner->runback, runback_count)
|
||||
if (runback_count > 0) {
|
||||
memcpy(scanner->runback.data, &buffer[size], runback_count);
|
||||
scanner->runback.len = runback_count;
|
||||
size += runback_count;
|
||||
}
|
||||
|
||||
size_t indent_length_length = (unsigned char)buffer[size++];
|
||||
if (indent_length_length > 0) {
|
||||
memcpy(&scanner->indent_length, &buffer[size], indent_length_length);
|
||||
size += indent_length_length;
|
||||
}
|
||||
|
||||
for (; size < length; size++) {
|
||||
VEC_PUSH(scanner->indents, (unsigned char)buffer[size]);
|
||||
}
|
||||
assert(size == length);
|
||||
}
|
||||
|
||||
/**
|
||||
* Destroy the state.
|
||||
*/
|
||||
void tree_sitter_elm_external_scanner_destroy(void *payload) {
|
||||
Scanner *scanner = (Scanner *)payload;
|
||||
VEC_FREE(scanner->indents);
|
||||
VEC_FREE(scanner->runback);
|
||||
free(scanner);
|
||||
}
|
||||
@ -1,507 +0,0 @@
|
||||
#include <tree_sitter/parser.h>
|
||||
#include <algorithm>
|
||||
#include <vector>
|
||||
#include <string>
|
||||
#include <cwctype>
|
||||
#include <cstring>
|
||||
|
||||
namespace
|
||||
{
|
||||
|
||||
using std::string;
|
||||
using std::vector;
|
||||
|
||||
enum TokenType
|
||||
{
|
||||
VIRTUAL_END_DECL,
|
||||
VIRTUAL_OPEN_SECTION,
|
||||
VIRTUAL_END_SECTION,
|
||||
MINUS_WITHOUT_TRAILING_WHITESPACE,
|
||||
GLSL_CONTENT,
|
||||
BLOCK_COMMENT_CONTENT
|
||||
};
|
||||
|
||||
struct Scanner
|
||||
{
|
||||
Scanner() {}
|
||||
|
||||
unsigned serialize(char *buffer)
|
||||
{
|
||||
size_t i = 0;
|
||||
|
||||
size_t runback_count = runback.size();
|
||||
if (runback_count > UINT8_MAX)
|
||||
runback_count = UINT8_MAX;
|
||||
buffer[i++] = runback_count;
|
||||
|
||||
if (runback_count > 0)
|
||||
{
|
||||
memcpy(&buffer[i], runback.data(), runback_count);
|
||||
}
|
||||
i += runback_count;
|
||||
|
||||
size_t indent_length_length = sizeof(indent_length);
|
||||
buffer[i++] = indent_length_length;
|
||||
if (indent_length_length > 0)
|
||||
{
|
||||
memcpy(&buffer[i], &indent_length, indent_length_length);
|
||||
}
|
||||
i += indent_length_length;
|
||||
|
||||
vector<uint32_t>::iterator
|
||||
iter = indent_length_stack.begin() + 1,
|
||||
end = indent_length_stack.end();
|
||||
|
||||
for (; iter != end && i < TREE_SITTER_SERIALIZATION_BUFFER_SIZE; ++iter)
|
||||
{
|
||||
buffer[i++] = *iter;
|
||||
}
|
||||
|
||||
return i;
|
||||
}
|
||||
|
||||
void deserialize(const char *buffer, unsigned length)
|
||||
{
|
||||
runback.clear();
|
||||
indent_length_stack.clear();
|
||||
indent_length_stack.push_back(0);
|
||||
|
||||
if (length > 0)
|
||||
{
|
||||
size_t i = 0;
|
||||
|
||||
size_t runback_count = (uint8_t)buffer[i++];
|
||||
runback.resize(runback_count);
|
||||
if (runback_count > 0)
|
||||
{
|
||||
memcpy(runback.data(), &buffer[i], runback_count);
|
||||
}
|
||||
i += runback_count;
|
||||
|
||||
size_t indent_length_length = buffer[i++];
|
||||
if (indent_length_length > 0)
|
||||
{
|
||||
memcpy(&indent_length, &buffer[i], indent_length_length);
|
||||
}
|
||||
i += indent_length_length;
|
||||
|
||||
for (; i < length; i++)
|
||||
{
|
||||
indent_length_stack.push_back(buffer[i]);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void advance(TSLexer *lexer)
|
||||
{
|
||||
lexer->advance(lexer, false);
|
||||
}
|
||||
|
||||
void skip(TSLexer *lexer)
|
||||
{
|
||||
lexer->advance(lexer, true);
|
||||
}
|
||||
|
||||
bool isElmSpace(TSLexer *lexer)
|
||||
{
|
||||
return lexer->lookahead == ' ' || lexer->lookahead == '\r' || lexer->lookahead == '\n';
|
||||
}
|
||||
|
||||
int checkForIn(TSLexer *lexer, const bool *valid_symbols)
|
||||
{
|
||||
// Are we at the end of a let (in) declaration
|
||||
if (valid_symbols[VIRTUAL_END_SECTION] && lexer->lookahead == 'i')
|
||||
{
|
||||
skip(lexer);
|
||||
|
||||
if (lexer->lookahead == 'n')
|
||||
{
|
||||
skip(lexer);
|
||||
if (isElmSpace(lexer) || lexer->eof(lexer))
|
||||
{
|
||||
return 2; // Success
|
||||
}
|
||||
return 1; // Partial
|
||||
}
|
||||
return 1; // Partial
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
bool scan_block_comment(TSLexer *lexer)
|
||||
{
|
||||
lexer->mark_end(lexer);
|
||||
if (lexer->lookahead != '{')
|
||||
return false;
|
||||
|
||||
advance(lexer);
|
||||
if (lexer->lookahead != '-')
|
||||
return false;
|
||||
|
||||
advance(lexer);
|
||||
|
||||
while (true)
|
||||
{
|
||||
switch (lexer->lookahead)
|
||||
{
|
||||
case '{':
|
||||
scan_block_comment(lexer);
|
||||
break;
|
||||
case '-':
|
||||
advance(lexer);
|
||||
if (lexer->lookahead == '}')
|
||||
{
|
||||
advance(lexer);
|
||||
return true;
|
||||
}
|
||||
break;
|
||||
case '\0':
|
||||
return true;
|
||||
default:
|
||||
advance(lexer);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void advance_to_line_end(TSLexer *lexer)
|
||||
{
|
||||
while(true)
|
||||
{
|
||||
if (lexer->lookahead == '\n') {
|
||||
break;
|
||||
}
|
||||
else if (lexer->eof(lexer)) {
|
||||
break;
|
||||
} else {
|
||||
advance(lexer);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
bool scan(TSLexer *lexer, const bool *valid_symbols)
|
||||
{
|
||||
// First handle eventual runback tokens, we saved on a previous scan op
|
||||
if (!runback.empty() && runback.back() == 0 && valid_symbols[VIRTUAL_END_DECL])
|
||||
{
|
||||
runback.pop_back();
|
||||
lexer->result_symbol = VIRTUAL_END_DECL;
|
||||
return true;
|
||||
}
|
||||
if (!runback.empty() && runback.back() == 1 && valid_symbols[VIRTUAL_END_SECTION])
|
||||
{
|
||||
runback.pop_back();
|
||||
lexer->result_symbol = VIRTUAL_END_SECTION;
|
||||
return true;
|
||||
}
|
||||
runback.clear();
|
||||
|
||||
// Check if we have newlines and how much indentation
|
||||
bool has_newline = false;
|
||||
bool found_in = false;
|
||||
bool can_call_mark_end = true;
|
||||
lexer->mark_end(lexer);
|
||||
while (true)
|
||||
{
|
||||
if (lexer->lookahead == ' ')
|
||||
{
|
||||
skip(lexer);
|
||||
}
|
||||
else if (lexer->lookahead == '\n')
|
||||
{
|
||||
skip(lexer);
|
||||
has_newline = true;
|
||||
while (true)
|
||||
{
|
||||
if (lexer->lookahead == ' ')
|
||||
{
|
||||
skip(lexer);
|
||||
}
|
||||
else
|
||||
{
|
||||
indent_length = lexer->get_column(lexer);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
else if (!valid_symbols[BLOCK_COMMENT_CONTENT] && lexer->lookahead == '-')
|
||||
{
|
||||
|
||||
advance(lexer);
|
||||
int32_t lookahead = lexer->lookahead;
|
||||
|
||||
// Handle minus without a whitespace for negate
|
||||
if (valid_symbols[MINUS_WITHOUT_TRAILING_WHITESPACE]
|
||||
&& ((lookahead >= 'a' && lookahead <= 'z')
|
||||
|| (lookahead >= 'A' && lookahead <= 'Z')
|
||||
|| lookahead == '('))
|
||||
{
|
||||
if (can_call_mark_end)
|
||||
{
|
||||
lexer->result_symbol = MINUS_WITHOUT_TRAILING_WHITESPACE;
|
||||
lexer->mark_end(lexer);
|
||||
return true;
|
||||
}
|
||||
else {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
// Scan past line comments. As far as the special token
|
||||
// types we're scanning for here are concerned line comments
|
||||
// are like whitespace. There is nothing useful to be
|
||||
// learned from, say, their indentation. So we advance past
|
||||
// them here.
|
||||
//
|
||||
// The one thing we need to keep in mind is that we should
|
||||
// not call `lexer->mark_end(lexer)` after this point, or
|
||||
// the comment will be lost.
|
||||
else if (lookahead == '-' && has_newline)
|
||||
{
|
||||
can_call_mark_end = false;
|
||||
advance(lexer);
|
||||
advance_to_line_end(lexer);
|
||||
}
|
||||
else if (valid_symbols[BLOCK_COMMENT_CONTENT] && lexer->lookahead == '}')
|
||||
{
|
||||
lexer->result_symbol = BLOCK_COMMENT_CONTENT;
|
||||
return true;
|
||||
}
|
||||
else
|
||||
{
|
||||
return false;
|
||||
}
|
||||
}
|
||||
else if (lexer->lookahead == '\r')
|
||||
{
|
||||
skip(lexer);
|
||||
}
|
||||
else if (lexer->eof(lexer))
|
||||
{
|
||||
if (valid_symbols[VIRTUAL_END_SECTION])
|
||||
{
|
||||
lexer->result_symbol = VIRTUAL_END_SECTION;
|
||||
return true;
|
||||
}
|
||||
if (valid_symbols[VIRTUAL_END_DECL])
|
||||
{
|
||||
lexer->result_symbol = VIRTUAL_END_DECL;
|
||||
return true;
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
else
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (checkForIn(lexer, valid_symbols) == 2)
|
||||
{
|
||||
if (has_newline)
|
||||
{
|
||||
found_in = true;
|
||||
}
|
||||
else
|
||||
{
|
||||
lexer->result_symbol = VIRTUAL_END_SECTION;
|
||||
indent_length_stack.pop_back();
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
// Open section if the grammar lets us but only push to indent stack if we go further down in the stack
|
||||
if (valid_symbols[VIRTUAL_OPEN_SECTION] && !lexer->eof(lexer))
|
||||
{
|
||||
indent_length_stack.push_back(lexer->get_column(lexer));
|
||||
lexer->result_symbol = VIRTUAL_OPEN_SECTION;
|
||||
return true;
|
||||
}
|
||||
else if (valid_symbols[BLOCK_COMMENT_CONTENT])
|
||||
{
|
||||
if (!can_call_mark_end)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
lexer->mark_end(lexer);
|
||||
while (true)
|
||||
{
|
||||
if (lexer->lookahead == '\0')
|
||||
{
|
||||
break;
|
||||
}
|
||||
if (lexer->lookahead != '{' && lexer->lookahead != '-')
|
||||
{
|
||||
advance(lexer);
|
||||
}
|
||||
else if (lexer->lookahead == '-')
|
||||
{
|
||||
lexer->mark_end(lexer);
|
||||
advance(lexer);
|
||||
if (lexer->lookahead == '}')
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
else if (scan_block_comment(lexer))
|
||||
{
|
||||
lexer->mark_end(lexer);
|
||||
advance(lexer);
|
||||
if (lexer->lookahead == '-')
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
lexer->result_symbol = BLOCK_COMMENT_CONTENT;
|
||||
return true;
|
||||
}
|
||||
else if (has_newline)
|
||||
{
|
||||
// We had a newline now it's time to check if we need to add multiple tokens to get back up to the right level
|
||||
runback.clear();
|
||||
|
||||
while (indent_length <= indent_length_stack.back())
|
||||
{
|
||||
if (indent_length == indent_length_stack.back())
|
||||
{
|
||||
if (found_in)
|
||||
{
|
||||
runback.push_back(1);
|
||||
found_in = false;
|
||||
break;
|
||||
}
|
||||
// Don't insert VIRTUAL_END_DECL when there is a line comment incoming
|
||||
|
||||
if (lexer->lookahead == '-')
|
||||
{
|
||||
skip(lexer);
|
||||
if (lexer->lookahead == '-')
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
// Don't insert VIRTUAL_END_DECL when there is a block comment incoming
|
||||
if (lexer->lookahead == '{')
|
||||
{
|
||||
skip(lexer);
|
||||
if (lexer->lookahead == '-')
|
||||
{
|
||||
break;
|
||||
}
|
||||
}
|
||||
runback.push_back(0);
|
||||
break;
|
||||
}
|
||||
else if (indent_length < indent_length_stack.back())
|
||||
{
|
||||
indent_length_stack.pop_back();
|
||||
runback.push_back(1);
|
||||
found_in = false;
|
||||
}
|
||||
}
|
||||
|
||||
// Needed for some of the more weird cases where let is in the same line as everything before the in in the next line
|
||||
if (found_in)
|
||||
{
|
||||
runback.push_back(1);
|
||||
found_in = false;
|
||||
}
|
||||
|
||||
// Our list is the wrong way around, reverse it
|
||||
std::reverse(runback.begin(), runback.end());
|
||||
// Handle the first runback token if we have them, if there are more they will be handled on the next scan operation
|
||||
if (!runback.empty() && runback.back() == 0 && valid_symbols[VIRTUAL_END_DECL])
|
||||
{
|
||||
runback.pop_back();
|
||||
lexer->result_symbol = VIRTUAL_END_DECL;
|
||||
return true;
|
||||
}
|
||||
else if (!runback.empty() && runback.back() == 1 && valid_symbols[VIRTUAL_END_SECTION])
|
||||
{
|
||||
runback.pop_back();
|
||||
lexer->result_symbol = VIRTUAL_END_SECTION;
|
||||
return true;
|
||||
}
|
||||
else if (lexer->eof(lexer) && valid_symbols[VIRTUAL_END_SECTION])
|
||||
{
|
||||
lexer->result_symbol = VIRTUAL_END_SECTION;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
if (valid_symbols[GLSL_CONTENT])
|
||||
{
|
||||
if (!can_call_mark_end)
|
||||
{
|
||||
return false;
|
||||
}
|
||||
lexer->result_symbol = GLSL_CONTENT;
|
||||
while (true)
|
||||
{
|
||||
switch (lexer->lookahead)
|
||||
{
|
||||
case '|':
|
||||
lexer->mark_end(lexer);
|
||||
advance(lexer);
|
||||
if (lexer->lookahead == ']')
|
||||
{
|
||||
advance(lexer);
|
||||
return true;
|
||||
}
|
||||
break;
|
||||
case '\0':
|
||||
lexer->mark_end(lexer);
|
||||
return true;
|
||||
default:
|
||||
advance(lexer);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
// The indention of the current line
|
||||
uint32_t indent_length;
|
||||
// Our indentation stack
|
||||
vector<uint32_t> indent_length_stack;
|
||||
// Stack of 0 - for possible VIRTUAL_END_DECL or 1 - for possible VIRTUAL_END_SECTION
|
||||
vector<uint8_t> runback;
|
||||
};
|
||||
|
||||
} // namespace
|
||||
|
||||
extern "C"
|
||||
{
|
||||
|
||||
void *tree_sitter_elm_external_scanner_create()
|
||||
{
|
||||
return new Scanner();
|
||||
}
|
||||
|
||||
bool tree_sitter_elm_external_scanner_scan(void *payload, TSLexer *lexer,
|
||||
const bool *valid_symbols)
|
||||
{
|
||||
Scanner *scanner = static_cast<Scanner *>(payload);
|
||||
return scanner->scan(lexer, valid_symbols);
|
||||
}
|
||||
|
||||
unsigned tree_sitter_elm_external_scanner_serialize(void *payload, char *buffer)
|
||||
{
|
||||
Scanner *scanner = static_cast<Scanner *>(payload);
|
||||
return scanner->serialize(buffer);
|
||||
}
|
||||
|
||||
void tree_sitter_elm_external_scanner_deserialize(void *payload, const char *buffer, unsigned length)
|
||||
{
|
||||
Scanner *scanner = static_cast<Scanner *>(payload);
|
||||
scanner->deserialize(buffer, length);
|
||||
}
|
||||
|
||||
void tree_sitter_elm_external_scanner_destroy(void *payload)
|
||||
{
|
||||
Scanner *scanner = static_cast<Scanner *>(payload);
|
||||
delete scanner;
|
||||
}
|
||||
}
|
||||
Loading…
Reference in New Issue