361 lines
8.1 KiB
C++
361 lines
8.1 KiB
C++
#include "tree_sitter/compiler.h"
|
|
#include "helpers.h"
|
|
|
|
namespace tree_sitter_examples {
|
|
|
|
static rule_ptr terminated(rule_ptr rule) {
|
|
return seq({ rule, choice({
|
|
sym("_line_break"),
|
|
str(";") }) });
|
|
}
|
|
|
|
enum {
|
|
PREC_COMMA = -1,
|
|
PREC_BLOCK = 1,
|
|
PREC_TERNARY = 2,
|
|
PREC_OR = 3,
|
|
PREC_AND = 4,
|
|
PREC_ASSIGN = 5,
|
|
PREC_REL = 5,
|
|
PREC_ADD = 6,
|
|
PREC_MULT = 7,
|
|
PREC_TYPE = 8,
|
|
PREC_NOT = 9,
|
|
PREC_SIGN = 10,
|
|
PREC_INC = 11,
|
|
PREC_SHORT_NEW = 12,
|
|
PREC_CALL = 13,
|
|
PREC_FULL_NEW = 14,
|
|
PREC_MEMBER = 15,
|
|
PREC_ARGS = 16,
|
|
};
|
|
|
|
extern const Grammar javascript{{
|
|
{ "program", repeat(sym("_statement")) },
|
|
|
|
/*
|
|
* Statements
|
|
*/
|
|
|
|
{ "_statement", choice({
|
|
sym("expression_statement"),
|
|
sym("var_declaration"),
|
|
sym("statement_block"),
|
|
sym("if_statement"),
|
|
sym("switch_statement"),
|
|
sym("for_statement"),
|
|
sym("while_statement"),
|
|
|
|
sym("for_in_statement"),
|
|
// sym("do_statement"),
|
|
|
|
sym("try_statement"),
|
|
sym("return_statement"),
|
|
sym("break_statement"),
|
|
sym("throw_statement"),
|
|
sym("delete_statement") }) },
|
|
|
|
{ "expression_statement", choice({
|
|
terminated(sym("_expression")),
|
|
seq({ err(sym("_expression")), str(";") }) }) },
|
|
|
|
{ "var_declaration", terminated(seq({
|
|
str("var"),
|
|
comma_sep1(err(choice({
|
|
sym("identifier"),
|
|
sym("var_assignment") }))) })) },
|
|
|
|
{ "statement_block", prec(PREC_BLOCK,
|
|
in_braces(err(repeat(sym("_statement"))))) },
|
|
|
|
{ "if_statement", prec_right(0, seq({
|
|
str("if"),
|
|
sym("_paren_expression"),
|
|
sym("_statement"),
|
|
optional(seq({
|
|
str("else"),
|
|
sym("_statement") })) })) },
|
|
|
|
{ "switch_statement", seq({
|
|
str("switch"),
|
|
sym("_paren_expression"),
|
|
str("{"),
|
|
repeat(choice({ sym("case"), sym("default") })),
|
|
str("}") }) },
|
|
|
|
{ "for_statement", seq({
|
|
str("for"),
|
|
str("("),
|
|
choice({
|
|
sym("var_declaration"),
|
|
seq({ sym("_expression"), str(";") }),
|
|
str(";") }),
|
|
optional(err(sym("_expression"))), str(";"),
|
|
optional(err(sym("_expression"))),
|
|
str(")"),
|
|
sym("_statement") }) },
|
|
|
|
{ "for_in_statement", seq({
|
|
str("for"),
|
|
str("("),
|
|
optional(str("var")),
|
|
sym("identifier"),
|
|
str("in"),
|
|
sym("_expression"),
|
|
str(")"),
|
|
sym("_statement") }) },
|
|
|
|
{ "while_statement", seq({
|
|
str("while"),
|
|
sym("_paren_expression"),
|
|
sym("_statement") }) },
|
|
|
|
// { "do_statement", seq({
|
|
// str("do"),
|
|
// sym("_statement"),
|
|
// str("while"),
|
|
// sym("_paren_expression") })},
|
|
|
|
{ "try_statement", seq({
|
|
str("try"),
|
|
sym("statement_block"),
|
|
optional(sym("catch")),
|
|
optional(sym("finally")) }) },
|
|
|
|
{ "return_statement", terminated(seq({
|
|
str("return"),
|
|
optional(sym("_expression")) })) },
|
|
|
|
{ "throw_statement", terminated(seq({
|
|
str("throw"),
|
|
sym("_expression") })) },
|
|
|
|
{ "break_statement", terminated(str("break")) },
|
|
|
|
{ "delete_statement", terminated(seq({
|
|
str("delete"),
|
|
choice({ sym("member_access"), sym("subscript_access") }) })) },
|
|
|
|
/*
|
|
* Statement components
|
|
*/
|
|
|
|
{ "case", seq({
|
|
str("case"),
|
|
sym("_expression"),
|
|
str(":"),
|
|
repeat(sym("_statement")) }) },
|
|
|
|
{ "default", seq({
|
|
str("default"),
|
|
str(":"),
|
|
repeat(sym("_statement")) }) },
|
|
|
|
{ "catch", seq({
|
|
str("catch"),
|
|
str("("),
|
|
err(sym("identifier")),
|
|
str(")"),
|
|
sym("statement_block") }) },
|
|
|
|
{ "finally", seq({
|
|
str("finally"),
|
|
sym("statement_block") }) },
|
|
|
|
{ "var_assignment", seq({
|
|
sym("identifier"),
|
|
str("="),
|
|
sym("_expression") }) },
|
|
|
|
{ "_paren_expression", in_parens(err(sym("_expression"))) },
|
|
|
|
/*
|
|
* Expressions
|
|
*/
|
|
|
|
{ "_expression", choice({
|
|
sym("object"),
|
|
sym("array"),
|
|
sym("function_expression"),
|
|
sym("function_call"),
|
|
sym("constructor_call"),
|
|
sym("member_access"),
|
|
sym("subscript_access"),
|
|
sym("assignment"),
|
|
sym("math_assignment"),
|
|
sym("ternary"),
|
|
sym("bool_op"),
|
|
sym("math_op"),
|
|
// sym("comma_op"),
|
|
|
|
// sym("bitwise_op"),
|
|
|
|
sym("rel_op"),
|
|
sym("type_op"),
|
|
sym("null"),
|
|
sym("number"),
|
|
sym("undefined"),
|
|
sym("regex"),
|
|
sym("string"),
|
|
sym("false"),
|
|
sym("identifier"),
|
|
sym("true"),
|
|
sym("_paren_expression") }) },
|
|
|
|
{ "object", in_braces(comma_sep(err(choice({
|
|
sym("pair"),
|
|
sym("method_definition") })))) },
|
|
|
|
{ "array", in_brackets(comma_sep(err(sym("_expression")))) },
|
|
|
|
{ "function_expression", seq({
|
|
str("function"),
|
|
optional(sym("identifier")),
|
|
str("("),
|
|
optional(sym("formal_parameters")),
|
|
str(")"),
|
|
sym("statement_block") }) },
|
|
|
|
{ "function_call", prec(PREC_CALL, seq({
|
|
sym("_expression"),
|
|
sym("arguments") })) },
|
|
|
|
{ "constructor_call", choice({
|
|
prec_right(PREC_SHORT_NEW, seq({
|
|
str("new"),
|
|
sym("_expression") })),
|
|
prec_right(PREC_MEMBER, seq({
|
|
str("new"),
|
|
sym("_expression"),
|
|
sym("arguments") })) }) },
|
|
|
|
{ "member_access", prec(PREC_MEMBER, seq({
|
|
sym("_expression"),
|
|
str("."),
|
|
sym("identifier") })) },
|
|
|
|
{ "subscript_access", prec(PREC_MEMBER, seq({
|
|
sym("_expression"),
|
|
str("["),
|
|
err(sym("_expression")),
|
|
str("]") })) },
|
|
|
|
{ "assignment", prec_right(PREC_ASSIGN, seq({
|
|
sym("_expression"),
|
|
str("="),
|
|
sym("_expression") })) },
|
|
|
|
{ "math_assignment", prec_right(PREC_ASSIGN, seq({
|
|
sym("_expression"),
|
|
choice({ str("+="), str("-="), str("*="), str("/=") }),
|
|
sym("_expression") })) },
|
|
|
|
{ "ternary", prec_right(PREC_TERNARY, seq({
|
|
sym("_expression"),
|
|
str("?"),
|
|
sym("_expression"),
|
|
str(":"),
|
|
sym("_expression") })) },
|
|
|
|
{ "bool_op", choice({
|
|
infix_op("||", "_expression", PREC_OR),
|
|
infix_op("&&", "_expression", PREC_AND),
|
|
prefix_op("!", "_expression", PREC_NOT) }) },
|
|
|
|
{ "comma_op", infix_op(",", "_expression", PREC_COMMA) },
|
|
|
|
{ "math_op", choice({
|
|
|
|
// prefix_op("+", "_expression", PREC_SIGN),
|
|
// prefix_op("-", "_expression", PREC_SIGN),
|
|
|
|
postfix_op("++", "_expression", PREC_INC),
|
|
postfix_op("--", "_expression", PREC_INC),
|
|
infix_op("*", "_expression", PREC_MULT),
|
|
infix_op("/", "_expression", PREC_MULT),
|
|
infix_op("+", "_expression", PREC_ADD),
|
|
infix_op("-", "_expression", PREC_ADD) }) },
|
|
|
|
// { "bitwise_op", choice({
|
|
// infix_op("&", "_expression", PREC_MULT),
|
|
// infix_op("|", "_expression", PREC_MULT),
|
|
// infix_op("<<", "_expression", PREC_MULT),
|
|
// infix_op(">>", "_expression", PREC_MULT) }) },
|
|
|
|
{ "rel_op", choice({
|
|
|
|
// infix_op("==", "_expression", PREC_REL),
|
|
// infix_op("!=", "_expression", PREC_REL),
|
|
// infix_op("<=", "_expression", PREC_REL),
|
|
// infix_op(">=", "_expression", PREC_REL),
|
|
|
|
infix_op("===", "_expression", PREC_REL),
|
|
infix_op("!==", "_expression", PREC_REL),
|
|
infix_op("<", "_expression", PREC_REL),
|
|
infix_op(">", "_expression", PREC_REL) }) },
|
|
|
|
{ "type_op", choice({
|
|
infix_op("in", "_expression", PREC_REL),
|
|
infix_op("instanceof", "_expression", PREC_REL),
|
|
prefix_op("typeof", "_expression", PREC_TYPE) }) },
|
|
|
|
/*
|
|
* Primitives
|
|
*/
|
|
|
|
{ "comment", token(choice({
|
|
seq({
|
|
str("/*"),
|
|
repeat(pattern("[^*]|(*[^/])")),
|
|
str("*/") }),
|
|
pattern("//[^\n]*") })) },
|
|
|
|
{ "string", token(choice({
|
|
delimited("\""),
|
|
delimited("'") })) },
|
|
|
|
{ "regex", token(seq({ delimited("/"), optional(str("g")) })) },
|
|
|
|
{ "number", pattern("\\d+(\\.\\d+)?") },
|
|
|
|
{ "identifier", pattern("[\\a_$][\\w_$]*") },
|
|
|
|
{ "null", str("null") },
|
|
{ "undefined", str("undefined") },
|
|
{ "true", str("true") },
|
|
{ "false", str("false") },
|
|
{ "_line_break", str("\n") },
|
|
|
|
/*
|
|
* Expression components
|
|
*/
|
|
|
|
{ "formal_parameters", comma_sep1(sym("identifier")) },
|
|
|
|
{ "arguments", prec(PREC_ARGS, seq({
|
|
str("("),
|
|
comma_sep(err(sym("_expression"))),
|
|
str(")") })) },
|
|
|
|
{ "pair", seq({
|
|
choice({ sym("string"), sym("identifier") }),
|
|
str(":"),
|
|
sym("_expression") }) },
|
|
|
|
{ "method_definition", seq({
|
|
sym("identifier"),
|
|
str("("),
|
|
comma_sep(sym("identifier")),
|
|
str(")"),
|
|
sym("statement_block") }) },
|
|
|
|
}, {
|
|
sym("comment"),
|
|
sym("_line_break"),
|
|
pattern("[ \t\r]"),
|
|
}, {
|
|
{ "for_in_statement", "_expression" },
|
|
{ "method_definition", "_expression" },
|
|
}};
|
|
|
|
} // namespace tree_sitter_examples
|