traxys/tree-sitter
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
tree-sitter/examples/parsers/javascript.c

3513 lines
117 KiB
C
Raw Normal View History

Start work on javascript grammar
2014-03-24 09:14:29 -07:00
#include "tree_sitter/parser.h"
Clean up parser macros more
2014-03-26 12:52:31 -07:00
STATE_COUNT = 239;
SYMBOL_COUNT = 42;
Start work on javascript grammar
2014-03-24 09:14:29 -07:00
enum {
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
ts_sym__else = 2,
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ts_sym__function = 3,
ts_sym__if = 4,
ts_sym__terminator = 5,
ts_sym__var = 6,
ts_sym_array = 7,
ts_sym_assignment = 8,
ts_sym_expression = 9,
ts_sym_false = 10,
ts_sym_formal_parameters = 11,
ts_sym_function_call = 12,
ts_sym_function_expression = 13,
ts_sym_identifier = 14,
ts_sym_if_statement = 15,
ts_sym_literal = 16,
ts_sym_null = 17,
ts_sym_number = 18,
ts_sym_object = 19,
ts_sym_program = 20,
ts_sym_statement = 21,
ts_sym_statement_block = 22,
ts_sym_string = 23,
ts_sym_true = 24,
ts_aux_sym_repeat_helper1 = 25,
ts_aux_sym_repeat_helper2 = 26,
ts_aux_sym_repeat_helper3 = 27,
ts_aux_sym_repeat_helper4 = 28,
ts_aux_sym_repeat_helper5 = 29,
ts_aux_sym_repeat_helper6 = 30,
ts_aux_sym_token1 = 31,
ts_aux_sym_token10 = 32,
ts_aux_sym_token11 = 33,
ts_aux_sym_token2 = 34,
ts_aux_sym_token3 = 35,
ts_aux_sym_token4 = 36,
ts_aux_sym_token5 = 37,
ts_aux_sym_token6 = 38,
ts_aux_sym_token7 = 39,
ts_aux_sym_token8 = 40,
ts_aux_sym_token9 = 41,
Start work on javascript grammar
2014-03-24 09:14:29 -07:00
};
SYMBOL_NAMES = {
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
"error",
"end",
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
"_else",
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
"_function",
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
"_if",
Remove public hidden symbol function Now, you can't a particular occurrence of a symbol in a grammar. You can only hide a symbol globally (right now, by beginning its name with an underscore).
2014-03-25 08:16:26 -07:00
"_terminator",
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
"_var",
Start work on javascript grammar
2014-03-24 09:14:29 -07:00
"array",
"assignment",
"expression",
"false",
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
"formal_parameters",
"function_call",
"function_expression",
Start work on javascript grammar
2014-03-24 09:14:29 -07:00
"identifier",
Add if statements to javascript grammar
2014-03-24 19:18:20 -07:00
"if_statement",
Start work on javascript grammar
2014-03-24 09:14:29 -07:00
"literal",
"null",
"number",
"object",
"program",
"statement",
Add if statements to javascript grammar
2014-03-24 19:18:20 -07:00
"statement_block",
Start work on javascript grammar
2014-03-24 09:14:29 -07:00
"string",
"true",
"repeat_helper1",
"repeat_helper2",
"repeat_helper3",
"repeat_helper4",
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
"repeat_helper5",
"repeat_helper6",
Start work on javascript grammar
2014-03-24 09:14:29 -07:00
"token1",
"token10",
"token11",
"token2",
"token3",
"token4",
"token5",
"token6",
"token7",
"token8",
"token9",
};
Clean up parser macros more
2014-03-26 12:52:31 -07:00
HIDDEN_SYMBOLS = {
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
[ts_sym__else] = 1,
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[ts_sym__function] = 1,
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
[ts_sym__if] = 1,
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
[ts_sym__terminator] = 1,
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
[ts_sym__var] = 1,
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
[ts_aux_sym_repeat_helper1] = 1,
[ts_aux_sym_repeat_helper2] = 1,
[ts_aux_sym_repeat_helper3] = 1,
[ts_aux_sym_repeat_helper4] = 1,
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[ts_aux_sym_repeat_helper5] = 1,
[ts_aux_sym_repeat_helper6] = 1,
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
[ts_aux_sym_token1] = 1,
[ts_aux_sym_token10] = 1,
[ts_aux_sym_token11] = 1,
[ts_aux_sym_token2] = 1,
[ts_aux_sym_token3] = 1,
[ts_aux_sym_token4] = 1,
[ts_aux_sym_token5] = 1,
[ts_aux_sym_token6] = 1,
[ts_aux_sym_token7] = 1,
[ts_aux_sym_token8] = 1,
[ts_aux_sym_token9] = 1,
Remove reduction-specific collapse flags in favor of globally hidden symbols
2014-03-25 09:05:55 -07:00
};
Start work on javascript grammar
2014-03-24 09:14:29 -07:00
LEX_FN() {
START_LEXER();
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
switch (lex_state) {
Start work on javascript grammar
2014-03-24 09:14:29 -07:00
case 0:
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if (lookahead == '\n')
Start work on javascript grammar
2014-03-24 09:14:29 -07:00
ADVANCE(1);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if (lookahead == ';')
ADVANCE(2);
Start work on javascript grammar
2014-03-24 09:14:29 -07:00
LEX_ERROR();
case 1:
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ACCEPT_TOKEN(ts_aux_sym_token2);
Start work on javascript grammar
2014-03-24 09:14:29 -07:00
case 2:
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ACCEPT_TOKEN(ts_aux_sym_token1);
case 3:
if (lookahead == ')')
ADVANCE(4);
LEX_ERROR();
case 4:
ACCEPT_TOKEN(ts_aux_sym_token4);
case 5:
if (lookahead == ')')
ADVANCE(4);
if (lookahead == ',')
ADVANCE(6);
LEX_ERROR();
case 6:
ACCEPT_TOKEN(ts_aux_sym_token8);
case 7:
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == '\"')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(8);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if ((lookahead == '$') ||
('A' <= lookahead && lookahead <= 'Z') ||
(lookahead == '_') ||
('a' <= lookahead && lookahead <= 'e') ||
('g' <= lookahead && lookahead <= 'h') ||
('j' <= lookahead && lookahead <= 'm') ||
('o' <= lookahead && lookahead <= 's') ||
(lookahead == 'u') ||
('w' <= lookahead && lookahead <= 'z'))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(18);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if ('0' <= lookahead && lookahead <= '9')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(20);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == '[')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(25);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == 'f')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(26);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if ('g' <= lookahead && lookahead <= 'f')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(49);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == 'i')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(50);
if ('j' <= lookahead && lookahead <= 'i')
ADVANCE(53);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == 'n')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(54);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if ('o' <= lookahead && lookahead <= 'n')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(61);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == 't')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(62);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if ('u' <= lookahead && lookahead <= 't')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(69);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == 'v')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(70);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
if ('w' <= lookahead && lookahead <= 'v')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(75);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
if (lookahead == '{')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(76);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
if (lookahead == '}')
ADVANCE(77);
Start work on javascript grammar
2014-03-24 09:14:29 -07:00
LEX_ERROR();
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
case 8:
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (!((lookahead == '\"') ||
(lookahead == '\\')))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(9);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == '\\')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(15);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (']' <= lookahead && lookahead <= '\\')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(17);
Start work on javascript grammar
2014-03-24 09:14:29 -07:00
LEX_ERROR();
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 9:
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (!((lookahead == '\"') ||
(lookahead == '\\')))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(10);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == '\"')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(11);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == '\\')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(12);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (']' <= lookahead && lookahead <= '\\')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(14);
Start work on javascript grammar
2014-03-24 09:14:29 -07:00
LEX_ERROR();
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 10:
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (!((lookahead == '\"') ||
(lookahead == '\\')))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(10);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == '\"')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(11);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == '\\')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(12);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (']' <= lookahead && lookahead <= '\\')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(14);
Start work on javascript grammar
2014-03-24 09:14:29 -07:00
LEX_ERROR();
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 11:
Start work on javascript grammar
2014-03-24 09:14:29 -07:00
ACCEPT_TOKEN(ts_sym_string);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 12:
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (!((lookahead == '\"') ||
(lookahead == '\\')))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(10);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == '\"')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(13);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if ('#' <= lookahead && lookahead <= '\"')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(10);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == '\\')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(12);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (']' <= lookahead && lookahead <= '\\')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(14);
Start work on javascript grammar
2014-03-24 09:14:29 -07:00
LEX_ERROR();
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 13:
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (!((lookahead == '\"') ||
(lookahead == '\\')))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(10);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == '\"')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(11);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == '\\')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(12);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (']' <= lookahead && lookahead <= '\\')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(14);
Start work on javascript grammar
2014-03-24 09:14:29 -07:00
ACCEPT_TOKEN(ts_sym_string);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 14:
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == '\"')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(10);
Start work on javascript grammar
2014-03-24 09:14:29 -07:00
LEX_ERROR();
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 15:
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (!((lookahead == '\"') ||
(lookahead == '\\')))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(10);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == '\"')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(16);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if ('#' <= lookahead && lookahead <= '\"')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(9);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == '\\')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(12);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (']' <= lookahead && lookahead <= '\\')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(14);
Start work on javascript grammar
2014-03-24 09:14:29 -07:00
LEX_ERROR();
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 16:
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (!((lookahead == '\"') ||
(lookahead == '\\')))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(10);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == '\"')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(11);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == '\\')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(12);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (']' <= lookahead && lookahead <= '\\')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(14);
Start work on javascript grammar
2014-03-24 09:14:29 -07:00
ACCEPT_TOKEN(ts_sym_string);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 17:
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == '\"')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(9);
Start work on javascript grammar
2014-03-24 09:14:29 -07:00
LEX_ERROR();
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 18:
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if ((lookahead == '$') ||
('A' <= lookahead && lookahead <= 'Z') ||
(lookahead == '_') ||
('a' <= lookahead && lookahead <= 'z'))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(19);
Add if statements to javascript grammar
2014-03-24 19:18:20 -07:00
ACCEPT_TOKEN(ts_sym_identifier);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 19:
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if ((lookahead == '$') ||
('A' <= lookahead && lookahead <= 'Z') ||
(lookahead == '_') ||
('a' <= lookahead && lookahead <= 'z'))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(19);
Add if statements to javascript grammar
2014-03-24 19:18:20 -07:00
ACCEPT_TOKEN(ts_sym_identifier);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 20:
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == '.')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(21);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if ('0' <= lookahead && lookahead <= '9')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(24);
Start work on javascript grammar
2014-03-24 09:14:29 -07:00
ACCEPT_TOKEN(ts_sym_number);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 21:
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if ('0' <= lookahead && lookahead <= '9')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(22);
Remove public hidden symbol function Now, you can't a particular occurrence of a symbol in a grammar. You can only hide a symbol globally (right now, by beginning its name with an underscore).
2014-03-25 08:16:26 -07:00
LEX_ERROR();
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 22:
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if ('0' <= lookahead && lookahead <= '9')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(23);
Remove public hidden symbol function Now, you can't a particular occurrence of a symbol in a grammar. You can only hide a symbol globally (right now, by beginning its name with an underscore).
2014-03-25 08:16:26 -07:00
ACCEPT_TOKEN(ts_sym_number);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 23:
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if ('0' <= lookahead && lookahead <= '9')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(23);
Start work on javascript grammar
2014-03-24 09:14:29 -07:00
ACCEPT_TOKEN(ts_sym_number);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 24:
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == '.')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(21);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if ('0' <= lookahead && lookahead <= '9')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(24);
Start work on javascript grammar
2014-03-24 09:14:29 -07:00
ACCEPT_TOKEN(ts_sym_number);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 25:
Add if statements to javascript grammar
2014-03-24 19:18:20 -07:00
ACCEPT_TOKEN(ts_aux_sym_token10);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 26:
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if ((lookahead == '$') ||
('A' <= lookahead && lookahead <= 'Z') ||
(lookahead == '_') ||
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
('b' <= lookahead && lookahead <= 't') ||
('v' <= lookahead && lookahead <= 'z'))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(19);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == 'a')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(31);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if (lookahead == 'u')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(35);
if ('v' <= lookahead && lookahead <= 'u')
ADVANCE(48);
Add if statements to javascript grammar
2014-03-24 19:18:20 -07:00
ACCEPT_TOKEN(ts_sym_identifier);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 27:
if (lookahead == 'l')
ADVANCE(28);
LEX_ERROR();
case 28:
if (lookahead == 's')
ADVANCE(29);
LEX_ERROR();
case 29:
if (lookahead == 'e')
ADVANCE(30);
LEX_ERROR();
case 30:
ACCEPT_TOKEN(ts_sym_false);
case 31:
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if ((lookahead == '$') ||
('A' <= lookahead && lookahead <= 'Z') ||
(lookahead == '_') ||
('a' <= lookahead && lookahead <= 'k') ||
('m' <= lookahead && lookahead <= 'z'))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(19);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == 'l')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(32);
if ('m' <= lookahead && lookahead <= 'l')
ADVANCE(28);
Add if statements to javascript grammar
2014-03-24 19:18:20 -07:00
ACCEPT_TOKEN(ts_sym_identifier);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 32:
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if ((lookahead == '$') ||
('A' <= lookahead && lookahead <= 'Z') ||
(lookahead == '_') ||
('a' <= lookahead && lookahead <= 'r') ||
('t' <= lookahead && lookahead <= 'z'))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(19);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == 's')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(33);
if ('t' <= lookahead && lookahead <= 's')
ADVANCE(29);
Add if statements to javascript grammar
2014-03-24 19:18:20 -07:00
ACCEPT_TOKEN(ts_sym_identifier);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 33:
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if ((lookahead == '$') ||
('A' <= lookahead && lookahead <= 'Z') ||
(lookahead == '_') ||
('a' <= lookahead && lookahead <= 'd') ||
('f' <= lookahead && lookahead <= 'z'))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(19);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == 'e')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(34);
if ('f' <= lookahead && lookahead <= 'e')
ADVANCE(30);
Add if statements to javascript grammar
2014-03-24 19:18:20 -07:00
ACCEPT_TOKEN(ts_sym_identifier);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 34:
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if ((lookahead == '$') ||
('A' <= lookahead && lookahead <= 'Z') ||
(lookahead == '_') ||
('a' <= lookahead && lookahead <= 'z'))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(19);
Add if statements to javascript grammar
2014-03-24 19:18:20 -07:00
ACCEPT_TOKEN(ts_sym_identifier);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 35:
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if ((lookahead == '$') ||
('A' <= lookahead && lookahead <= 'Z') ||
(lookahead == '_') ||
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
('a' <= lookahead && lookahead <= 'm') ||
('o' <= lookahead && lookahead <= 'z'))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(19);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if (lookahead == 'n')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(36);
if ('o' <= lookahead && lookahead <= 'n')
ADVANCE(47);
Add if statements to javascript grammar
2014-03-24 19:18:20 -07:00
ACCEPT_TOKEN(ts_sym_identifier);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 36:
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if ((lookahead == '$') ||
('A' <= lookahead && lookahead <= 'Z') ||
(lookahead == '_') ||
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
('a' <= lookahead && lookahead <= 'b') ||
('d' <= lookahead && lookahead <= 'z'))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(19);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if (lookahead == 'c')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(37);
if ('d' <= lookahead && lookahead <= 'c')
ADVANCE(46);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ACCEPT_TOKEN(ts_sym_identifier);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 37:
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if ((lookahead == '$') ||
('A' <= lookahead && lookahead <= 'Z') ||
(lookahead == '_') ||
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
('a' <= lookahead && lookahead <= 's') ||
('u' <= lookahead && lookahead <= 'z'))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(19);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if (lookahead == 't')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(38);
if ('u' <= lookahead && lookahead <= 't')
ADVANCE(45);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ACCEPT_TOKEN(ts_sym_identifier);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 38:
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if ((lookahead == '$') ||
('A' <= lookahead && lookahead <= 'Z') ||
(lookahead == '_') ||
('a' <= lookahead && lookahead <= 'h') ||
('j' <= lookahead && lookahead <= 'z'))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(19);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if (lookahead == 'i')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(39);
if ('j' <= lookahead && lookahead <= 'i')
ADVANCE(44);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ACCEPT_TOKEN(ts_sym_identifier);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 39:
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if ((lookahead == '$') ||
('A' <= lookahead && lookahead <= 'Z') ||
(lookahead == '_') ||
('a' <= lookahead && lookahead <= 'n') ||
('p' <= lookahead && lookahead <= 'z'))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(19);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if (lookahead == 'o')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(40);
if ('p' <= lookahead && lookahead <= 'o')
ADVANCE(43);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ACCEPT_TOKEN(ts_sym_identifier);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 40:
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if ((lookahead == '$') ||
('A' <= lookahead && lookahead <= 'Z') ||
(lookahead == '_') ||
('a' <= lookahead && lookahead <= 'm') ||
('o' <= lookahead && lookahead <= 'z'))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(19);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if (lookahead == 'n')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(41);
if ('o' <= lookahead && lookahead <= 'n')
ADVANCE(42);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ACCEPT_TOKEN(ts_sym_identifier);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 41:
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if ((lookahead == '$') ||
('A' <= lookahead && lookahead <= 'Z') ||
(lookahead == '_') ||
('a' <= lookahead && lookahead <= 'z'))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(19);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ACCEPT_TOKEN(ts_sym__function);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 42:
ACCEPT_TOKEN(ts_sym__function);
case 43:
if (lookahead == 'n')
ADVANCE(42);
LEX_ERROR();
case 44:
if (lookahead == 'o')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(43);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
LEX_ERROR();
case 45:
if (lookahead == 'i')
ADVANCE(44);
LEX_ERROR();
case 46:
if (lookahead == 't')
ADVANCE(45);
LEX_ERROR();
case 47:
if (lookahead == 'c')
ADVANCE(46);
LEX_ERROR();
case 48:
if (lookahead == 'n')
ADVANCE(47);
LEX_ERROR();
case 49:
if (lookahead == 'a')
ADVANCE(27);
LEX_ERROR();
case 50:
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if ((lookahead == '$') ||
('A' <= lookahead && lookahead <= 'Z') ||
(lookahead == '_') ||
('a' <= lookahead && lookahead <= 'e') ||
('g' <= lookahead && lookahead <= 'z'))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(19);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if (lookahead == 'f')
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
ADVANCE(51);
if ('g' <= lookahead && lookahead <= 'f')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(52);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ACCEPT_TOKEN(ts_sym_identifier);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 51:
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if ((lookahead == '$') ||
('A' <= lookahead && lookahead <= 'Z') ||
(lookahead == '_') ||
('a' <= lookahead && lookahead <= 'z'))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(19);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ACCEPT_TOKEN(ts_sym__if);
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
case 52:
ACCEPT_TOKEN(ts_sym__if);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 53:
if (lookahead == 'f')
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
ADVANCE(52);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
LEX_ERROR();
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
case 54:
if ((lookahead == '$') ||
('A' <= lookahead && lookahead <= 'Z') ||
(lookahead == '_') ||
('a' <= lookahead && lookahead <= 't') ||
('v' <= lookahead && lookahead <= 'z'))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(19);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if (lookahead == 'u')
ADVANCE(55);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if ('v' <= lookahead && lookahead <= 'u')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(60);
Add if statements to javascript grammar
2014-03-24 19:18:20 -07:00
ACCEPT_TOKEN(ts_sym_identifier);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
case 55:
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if ((lookahead == '$') ||
('A' <= lookahead && lookahead <= 'Z') ||
(lookahead == '_') ||
('a' <= lookahead && lookahead <= 'k') ||
('m' <= lookahead && lookahead <= 'z'))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(19);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == 'l')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(56);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if ('m' <= lookahead && lookahead <= 'l')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(59);
Add if statements to javascript grammar
2014-03-24 19:18:20 -07:00
ACCEPT_TOKEN(ts_sym_identifier);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
case 56:
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if ((lookahead == '$') ||
('A' <= lookahead && lookahead <= 'Z') ||
(lookahead == '_') ||
('a' <= lookahead && lookahead <= 'k') ||
('m' <= lookahead && lookahead <= 'z'))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(19);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == 'l')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(57);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if ('m' <= lookahead && lookahead <= 'l')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(58);
Add if statements to javascript grammar
2014-03-24 19:18:20 -07:00
ACCEPT_TOKEN(ts_sym_identifier);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
case 57:
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if ((lookahead == '$') ||
('A' <= lookahead && lookahead <= 'Z') ||
(lookahead == '_') ||
('a' <= lookahead && lookahead <= 'z'))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(19);
Add if statements to javascript grammar
2014-03-24 19:18:20 -07:00
ACCEPT_TOKEN(ts_sym_identifier);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
case 58:
Add if statements to javascript grammar
2014-03-24 19:18:20 -07:00
ACCEPT_TOKEN(ts_sym_null);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
case 59:
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == 'l')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(58);
Add if statements to javascript grammar
2014-03-24 19:18:20 -07:00
LEX_ERROR();
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
case 60:
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == 'l')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(59);
Add if statements to javascript grammar
2014-03-24 19:18:20 -07:00
LEX_ERROR();
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
case 61:
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == 'u')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(60);
Start work on javascript grammar
2014-03-24 09:14:29 -07:00
LEX_ERROR();
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
case 62:
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if ((lookahead == '$') ||
('A' <= lookahead && lookahead <= 'Z') ||
(lookahead == '_') ||
('a' <= lookahead && lookahead <= 'q') ||
('s' <= lookahead && lookahead <= 'z'))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(19);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == 'r')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(66);
Add if statements to javascript grammar
2014-03-24 19:18:20 -07:00
ACCEPT_TOKEN(ts_sym_identifier);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
case 63:
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
if (lookahead == 'u')
ADVANCE(64);
LEX_ERROR();
case 64:
if (lookahead == 'e')
ADVANCE(65);
LEX_ERROR();
case 65:
ACCEPT_TOKEN(ts_sym_true);
case 66:
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if ((lookahead == '$') ||
('A' <= lookahead && lookahead <= 'Z') ||
(lookahead == '_') ||
('a' <= lookahead && lookahead <= 't') ||
('v' <= lookahead && lookahead <= 'z'))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(19);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == 'u')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(67);
Add if statements to javascript grammar
2014-03-24 19:18:20 -07:00
ACCEPT_TOKEN(ts_sym_identifier);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 67:
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if ((lookahead == '$') ||
('A' <= lookahead && lookahead <= 'Z') ||
(lookahead == '_') ||
('a' <= lookahead && lookahead <= 'd') ||
('f' <= lookahead && lookahead <= 'z'))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(19);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == 'e')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(68);
Add if statements to javascript grammar
2014-03-24 19:18:20 -07:00
ACCEPT_TOKEN(ts_sym_identifier);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 68:
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if ((lookahead == '$') ||
('A' <= lookahead && lookahead <= 'Z') ||
(lookahead == '_') ||
('a' <= lookahead && lookahead <= 'z'))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(19);
Add if statements to javascript grammar
2014-03-24 19:18:20 -07:00
ACCEPT_TOKEN(ts_sym_identifier);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
case 69:
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == 'r')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(63);
Start work on javascript grammar
2014-03-24 09:14:29 -07:00
LEX_ERROR();
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
case 70:
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if ((lookahead == '$') ||
('A' <= lookahead && lookahead <= 'Z') ||
(lookahead == '_') ||
('b' <= lookahead && lookahead <= 'z'))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(19);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == 'a')
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
ADVANCE(73);
Add if statements to javascript grammar
2014-03-24 19:18:20 -07:00
ACCEPT_TOKEN(ts_sym_identifier);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
case 71:
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
if (lookahead == 'r')
ADVANCE(72);
LEX_ERROR();
case 72:
ACCEPT_TOKEN(ts_sym__var);
case 73:
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if ((lookahead == '$') ||
('A' <= lookahead && lookahead <= 'Z') ||
(lookahead == '_') ||
('a' <= lookahead && lookahead <= 'q') ||
('s' <= lookahead && lookahead <= 'z'))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(19);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == 'r')
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
ADVANCE(74);
Add if statements to javascript grammar
2014-03-24 19:18:20 -07:00
ACCEPT_TOKEN(ts_sym_identifier);
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
case 74:
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if ((lookahead == '$') ||
('A' <= lookahead && lookahead <= 'Z') ||
(lookahead == '_') ||
('a' <= lookahead && lookahead <= 'z'))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(19);
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
ACCEPT_TOKEN(ts_sym__var);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
case 75:
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
if (lookahead == 'a')
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
ADVANCE(71);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
LEX_ERROR();
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
case 76:
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ACCEPT_TOKEN(ts_aux_sym_token5);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
case 77:
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ACCEPT_TOKEN(ts_aux_sym_token6);
case 78:
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if (lookahead == '}')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(77);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
LEX_ERROR();
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 79:
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if (lookahead == ',')
ADVANCE(6);
if (lookahead == ']')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(80);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
LEX_ERROR();
case 80:
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ACCEPT_TOKEN(ts_aux_sym_token11);
case 81:
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if (lookahead == ',')
ADVANCE(6);
if (lookahead == '}')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(77);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
LEX_ERROR();
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 82:
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if (lookahead == '{')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(76);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
LEX_ERROR();
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 83:
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if ((lookahead == '$') ||
('A' <= lookahead && lookahead <= 'Z') ||
(lookahead == '_') ||
('a' <= lookahead && lookahead <= 'z'))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(18);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
LEX_ERROR();
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 84:
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if ((lookahead == '$') ||
('A' <= lookahead && lookahead <= 'Z') ||
(lookahead == '_') ||
('a' <= lookahead && lookahead <= 'z'))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(18);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if (lookahead == ')')
ADVANCE(4);
LEX_ERROR();
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 85:
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if (lookahead == '(')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(86);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
LEX_ERROR();
case 86:
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ACCEPT_TOKEN(ts_aux_sym_token3);
case 87:
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if (lookahead == ']')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(80);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
LEX_ERROR();
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 88:
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == '\"')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(8);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if ((lookahead == '$') ||
('A' <= lookahead && lookahead <= 'Z') ||
(lookahead == '_') ||
('a' <= lookahead && lookahead <= 'e') ||
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
('g' <= lookahead && lookahead <= 'm') ||
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
('o' <= lookahead && lookahead <= 's') ||
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
('u' <= lookahead && lookahead <= 'z'))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(18);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if ('0' <= lookahead && lookahead <= '9')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(20);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == '[')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(25);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == 'f')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(26);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if ('g' <= lookahead && lookahead <= 'f')
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
ADVANCE(89);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == 'n')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(54);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == 't')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(62);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == '{')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(76);
Start work on javascript grammar
2014-03-24 09:14:29 -07:00
LEX_ERROR();
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 89:
if ((lookahead == '$') ||
('A' <= lookahead && lookahead <= 'Z') ||
(lookahead == '_') ||
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
('b' <= lookahead && lookahead <= 'z'))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(19);
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
if (lookahead == 'a')
ADVANCE(31);
if ('b' <= lookahead && lookahead <= 'a')
ADVANCE(27);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ACCEPT_TOKEN(ts_sym_identifier);
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
case 90:
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if (lookahead == ':')
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
ADVANCE(91);
Remove public hidden symbol function Now, you can't a particular occurrence of a symbol in a grammar. You can only hide a symbol globally (right now, by beginning its name with an underscore).
2014-03-25 08:16:26 -07:00
LEX_ERROR();
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
case 91:
Store grammars' rules in vectors, not maps This way, we can keep of the order in which the rules were given, for resolving reduce/reduce conflicts.
2014-03-24 13:05:04 -07:00
ACCEPT_TOKEN(ts_aux_sym_token9);
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
case 92:
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if (lookahead == '\"')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(8);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == '}')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(77);
Add if statements to javascript grammar
2014-03-24 19:18:20 -07:00
LEX_ERROR();
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
case 93:
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == '\"')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(8);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if ((lookahead == '$') ||
('A' <= lookahead && lookahead <= 'Z') ||
(lookahead == '_') ||
('a' <= lookahead && lookahead <= 'e') ||
('g' <= lookahead && lookahead <= 'm') ||
('o' <= lookahead && lookahead <= 's') ||
('u' <= lookahead && lookahead <= 'z'))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(18);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if ('0' <= lookahead && lookahead <= '9')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(20);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == '[')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(25);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == ']')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(80);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == 'f')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(26);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if ('g' <= lookahead && lookahead <= 'f')
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
ADVANCE(89);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == 'n')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(54);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == 't')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(62);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == '{')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(76);
Store grammars' rules in vectors, not maps This way, we can keep of the order in which the rules were given, for resolving reduce/reduce conflicts.
2014-03-24 13:05:04 -07:00
LEX_ERROR();
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
case 94:
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == '\"')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(8);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if ((lookahead == '$') ||
('A' <= lookahead && lookahead <= 'Z') ||
(lookahead == '_') ||
('a' <= lookahead && lookahead <= 'e') ||
('g' <= lookahead && lookahead <= 'm') ||
('o' <= lookahead && lookahead <= 's') ||
('u' <= lookahead && lookahead <= 'z'))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(18);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if (lookahead == ')')
ADVANCE(4);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if ('0' <= lookahead && lookahead <= '9')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(20);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == '[')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(25);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == 'f')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(26);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if ('g' <= lookahead && lookahead <= 'f')
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
ADVANCE(89);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == 'n')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(54);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == 't')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(62);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == '{')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(76);
Add if statements to javascript grammar
2014-03-24 19:18:20 -07:00
LEX_ERROR();
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
case 95:
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if (lookahead == '(')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(86);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if (lookahead == ',')
ADVANCE(6);
if (lookahead == ']')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(80);
Add if statements to javascript grammar
2014-03-24 19:18:20 -07:00
LEX_ERROR();
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
case 96:
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if (lookahead == '(')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(86);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if (lookahead == ')')
ADVANCE(4);
if (lookahead == ',')
ADVANCE(6);
LEX_ERROR();
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
case 97:
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if (lookahead == '(')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(86);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if (lookahead == ',')
ADVANCE(6);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == '}')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(77);
Add if statements to javascript grammar
2014-03-24 19:18:20 -07:00
LEX_ERROR();
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
case 98:
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == '\"')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(8);
Add if statements to javascript grammar
2014-03-24 19:18:20 -07:00
LEX_ERROR();
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
case 99:
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if (lookahead == '\n')
ADVANCE(1);
if (lookahead == ':')
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
ADVANCE(91);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if (lookahead == ';')
ADVANCE(2);
Add if statements to javascript grammar
2014-03-24 19:18:20 -07:00
LEX_ERROR();
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
case 100:
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if (lookahead == '\n')
ADVANCE(1);
if (lookahead == '(')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(86);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if (lookahead == ';')
ADVANCE(2);
Add if statements to javascript grammar
2014-03-24 19:18:20 -07:00
LEX_ERROR();
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
case 101:
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if (lookahead == '=')
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
ADVANCE(102);
Start work on javascript grammar
2014-03-24 09:14:29 -07:00
LEX_ERROR();
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
case 102:
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ACCEPT_TOKEN(ts_aux_sym_token7);
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
case 103:
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
if (lookahead == '\"')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(8);
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
if ((lookahead == '$') ||
('A' <= lookahead && lookahead <= 'Z') ||
(lookahead == '_') ||
('a' <= lookahead && lookahead <= 'd') ||
('g' <= lookahead && lookahead <= 'h') ||
('j' <= lookahead && lookahead <= 'm') ||
('o' <= lookahead && lookahead <= 's') ||
(lookahead == 'u') ||
('w' <= lookahead && lookahead <= 'z'))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(18);
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
if ('0' <= lookahead && lookahead <= '9')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(20);
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
if (lookahead == '[')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(25);
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
if (lookahead == 'e')
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
ADVANCE(108);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
if ('f' <= lookahead && lookahead <= 'e')
ADVANCE(112);
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
if (lookahead == 'f')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(26);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if ('g' <= lookahead && lookahead <= 'f')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(49);
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
if (lookahead == 'i')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(50);
if ('j' <= lookahead && lookahead <= 'i')
ADVANCE(53);
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
if (lookahead == 'n')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(54);
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
if ('o' <= lookahead && lookahead <= 'n')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(61);
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
if (lookahead == 't')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(62);
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
if ('u' <= lookahead && lookahead <= 't')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(69);
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
if (lookahead == 'v')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(70);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
if ('w' <= lookahead && lookahead <= 'v')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(75);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
if (lookahead == '{')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(76);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
if (lookahead == '}')
ADVANCE(77);
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
LEX_ERROR();
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
case 104:
if (lookahead == 'l')
ADVANCE(105);
LEX_ERROR();
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
case 105:
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
if (lookahead == 's')
ADVANCE(106);
LEX_ERROR();
case 106:
if (lookahead == 'e')
ADVANCE(107);
LEX_ERROR();
case 107:
ACCEPT_TOKEN(ts_sym__else);
case 108:
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
if ((lookahead == '$') ||
('A' <= lookahead && lookahead <= 'Z') ||
(lookahead == '_') ||
('a' <= lookahead && lookahead <= 'k') ||
('m' <= lookahead && lookahead <= 'z'))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(19);
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
if (lookahead == 'l')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(109);
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
ACCEPT_TOKEN(ts_sym_identifier);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 109:
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
if ((lookahead == '$') ||
('A' <= lookahead && lookahead <= 'Z') ||
(lookahead == '_') ||
('a' <= lookahead && lookahead <= 'r') ||
('t' <= lookahead && lookahead <= 'z'))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(19);
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
if (lookahead == 's')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(110);
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
ACCEPT_TOKEN(ts_sym_identifier);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 110:
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
if ((lookahead == '$') ||
('A' <= lookahead && lookahead <= 'Z') ||
(lookahead == '_') ||
('a' <= lookahead && lookahead <= 'd') ||
('f' <= lookahead && lookahead <= 'z'))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(19);
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
if (lookahead == 'e')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(111);
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
ACCEPT_TOKEN(ts_sym_identifier);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 111:
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
if ((lookahead == '$') ||
('A' <= lookahead && lookahead <= 'Z') ||
(lookahead == '_') ||
('a' <= lookahead && lookahead <= 'z'))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(19);
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
ACCEPT_TOKEN(ts_sym__else);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 112:
if (lookahead == 'l')
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
ADVANCE(105);
if (lookahead == 'u')
ADVANCE(48);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
LEX_ERROR();
case 113:
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if (lookahead == '\"')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(8);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if ((lookahead == '$') ||
('A' <= lookahead && lookahead <= 'Z') ||
(lookahead == '_') ||
('a' <= lookahead && lookahead <= 'e') ||
('g' <= lookahead && lookahead <= 'h') ||
('j' <= lookahead && lookahead <= 'm') ||
('o' <= lookahead && lookahead <= 's') ||
(lookahead == 'u') ||
('w' <= lookahead && lookahead <= 'z'))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(18);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if ('0' <= lookahead && lookahead <= '9')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(20);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if (lookahead == '[')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(25);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if (lookahead == 'f')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(26);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if ('g' <= lookahead && lookahead <= 'f')
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
ADVANCE(49);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if (lookahead == 'i')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(50);
if ('j' <= lookahead && lookahead <= 'i')
ADVANCE(53);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if (lookahead == 'n')
ADVANCE(54);
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
if ('o' <= lookahead && lookahead <= 'n')
ADVANCE(61);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if (lookahead == 't')
ADVANCE(62);
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
if ('u' <= lookahead && lookahead <= 't')
ADVANCE(69);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if (lookahead == 'v')
ADVANCE(70);
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
if ('w' <= lookahead && lookahead <= 'v')
ADVANCE(75);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if (lookahead == '{')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(76);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
LEX_ERROR();
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
case 114:
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
if (lookahead == '(')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(86);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if (lookahead == ')')
ADVANCE(4);
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
LEX_ERROR();
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
case 115:
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
if (lookahead == '\"')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(8);
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
if ((lookahead == '$') ||
('A' <= lookahead && lookahead <= 'Z') ||
(lookahead == '_') ||
('a' <= lookahead && lookahead <= 'd') ||
('g' <= lookahead && lookahead <= 'h') ||
('j' <= lookahead && lookahead <= 'm') ||
('o' <= lookahead && lookahead <= 's') ||
(lookahead == 'u') ||
('w' <= lookahead && lookahead <= 'z'))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(18);
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
if ('0' <= lookahead && lookahead <= '9')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(20);
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
if (lookahead == '[')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(25);
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
if (lookahead == 'e')
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
ADVANCE(108);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
if ('f' <= lookahead && lookahead <= 'e')
ADVANCE(112);
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
if (lookahead == 'f')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(26);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if ('g' <= lookahead && lookahead <= 'f')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(49);
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
if (lookahead == 'i')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(50);
if ('j' <= lookahead && lookahead <= 'i')
ADVANCE(53);
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
if (lookahead == 'n')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(54);
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
if ('o' <= lookahead && lookahead <= 'n')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(61);
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
if (lookahead == 't')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(62);
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
if ('u' <= lookahead && lookahead <= 't')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(69);
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
if (lookahead == 'v')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(70);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
if ('w' <= lookahead && lookahead <= 'v')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(75);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
if (lookahead == '{')
ADVANCE(76);
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
LEX_ERROR();
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
case 116:
Add if statements to javascript grammar
2014-03-24 19:18:20 -07:00
LEX_ERROR();
Start work on javascript grammar
2014-03-24 09:14:29 -07:00
case ts_lex_state_error:
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == '\n')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(1);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == '\"')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(8);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if ((lookahead == '$') ||
('A' <= lookahead && lookahead <= 'Z') ||
(lookahead == '_') ||
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
('a' <= lookahead && lookahead <= 'd') ||
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
('g' <= lookahead && lookahead <= 'h') ||
('j' <= lookahead && lookahead <= 'm') ||
('o' <= lookahead && lookahead <= 's') ||
(lookahead == 'u') ||
('w' <= lookahead && lookahead <= 'z'))
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(18);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == '(')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(86);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == ')')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(4);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == ',')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(6);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if ('0' <= lookahead && lookahead <= '9')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(20);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == ':')
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
ADVANCE(91);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == ';')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(2);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == '=')
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
ADVANCE(102);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == '[')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(25);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == ']')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(80);
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
if (lookahead == 'e')
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
ADVANCE(108);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == 'f')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(26);
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
if ('g' <= lookahead && lookahead <= 'f')
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
ADVANCE(89);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == 'i')
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
ADVANCE(50);
if ('j' <= lookahead && lookahead <= 'i')
ADVANCE(53);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == 'n')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(54);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == 't')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(62);
Clean up macros in parser.h
2014-03-25 19:51:34 -07:00
if (lookahead == 'v')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(70);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
if ('w' <= lookahead && lookahead <= 'v')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(75);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
if (lookahead == '{')
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
ADVANCE(76);
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
if (lookahead == '}')
ADVANCE(77);
Start work on javascript grammar
2014-03-24 09:14:29 -07:00
LEX_ERROR();
default:
LEX_PANIC();
}
}
Clean up parser macros more
2014-03-26 12:52:31 -07:00
LEX_STATES = {
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[0] = 113,
[1] = 83,
[2] = 85,
[3] = 82,
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
[4] = 0,
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[5] = 7,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[6] = 85,
[7] = 88,
[8] = 83,
[9] = 85,
[10] = 82,
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[11] = 3,
[12] = 7,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[13] = 83,
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
[14] = 101,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[15] = 88,
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[16] = 0,
[17] = 0,
[18] = 0,
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
[19] = 100,
[20] = 94,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[21] = 83,
[22] = 85,
[23] = 82,
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[24] = 5,
[25] = 7,
[26] = 0,
[27] = 7,
[28] = 7,
[29] = 7,
[30] = 7,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[31] = 78,
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
[32] = 93,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[33] = 83,
[34] = 85,
[35] = 82,
[36] = 79,
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[37] = 7,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[38] = 78,
[39] = 79,
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[40] = 7,
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
[41] = 99,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[42] = 88,
[43] = 83,
[44] = 85,
[45] = 82,
[46] = 81,
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[47] = 7,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[48] = 78,
[49] = 81,
[50] = 84,
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[51] = 5,
[52] = 3,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[53] = 82,
[54] = 83,
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[55] = 5,
[56] = 3,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[57] = 82,
[58] = 81,
[59] = 81,
[60] = 78,
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[61] = 0,
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
[62] = 98,
[63] = 90,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[64] = 88,
[65] = 81,
[66] = 78,
[67] = 81,
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
[68] = 97,
[69] = 94,
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[70] = 5,
[71] = 5,
[72] = 3,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[73] = 81,
[74] = 88,
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[75] = 5,
[76] = 3,
[77] = 5,
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
[78] = 96,
[79] = 94,
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[80] = 5,
[81] = 3,
[82] = 5,
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
[83] = 93,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[84] = 79,
[85] = 79,
[86] = 87,
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[87] = 5,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[88] = 88,
[89] = 79,
[90] = 87,
[91] = 79,
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
[92] = 95,
[93] = 94,
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[94] = 5,
[95] = 3,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[96] = 79,
[97] = 79,
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
[98] = 92,
[99] = 90,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[100] = 88,
[101] = 81,
[102] = 78,
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[103] = 5,
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
[104] = 93,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[105] = 79,
[106] = 87,
[107] = 81,
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
[108] = 93,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[109] = 79,
[110] = 87,
[111] = 79,
[112] = 79,
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
[113] = 92,
[114] = 90,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[115] = 88,
[116] = 81,
[117] = 78,
[118] = 79,
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
[119] = 92,
[120] = 90,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[121] = 88,
[122] = 81,
[123] = 78,
[124] = 81,
[125] = 81,
[126] = 81,
[127] = 78,
[128] = 81,
[129] = 79,
[130] = 81,
[131] = 78,
[132] = 79,
[133] = 81,
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[134] = 5,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[135] = 81,
[136] = 78,
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[137] = 5,
[138] = 5,
[139] = 5,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[140] = 81,
[141] = 81,
[142] = 78,
[143] = 78,
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[144] = 7,
[145] = 0,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[146] = 81,
[147] = 78,
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[148] = 0,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[149] = 79,
[150] = 87,
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[151] = 0,
[152] = 0,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[153] = 78,
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[154] = 5,
[155] = 5,
[156] = 3,
[157] = 0,
[158] = 0,
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
[159] = 92,
[160] = 90,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[161] = 78,
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[162] = 3,
[163] = 3,
[164] = 3,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[165] = 113,
[166] = 85,
[167] = 88,
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[168] = 3,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[169] = 113,
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[170] = 0,
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
[171] = 103,
[172] = 103,
[173] = 103,
[174] = 103,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[175] = 113,
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
[176] = 103,
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[177] = 7,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[178] = 78,
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
[179] = 103,
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[180] = 3,
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
[181] = 114,
[182] = 94,
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[183] = 5,
[184] = 3,
[185] = 3,
[186] = 3,
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
[187] = 93,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[188] = 79,
[189] = 87,
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[190] = 3,
[191] = 3,
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
[192] = 92,
[193] = 90,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[194] = 88,
[195] = 81,
[196] = 78,
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[197] = 3,
[198] = 3,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[199] = 81,
[200] = 78,
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[201] = 3,
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
[202] = 103,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[203] = 113,
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[204] = 7,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[205] = 78,
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[206] = 0,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[207] = 85,
[208] = 88,
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[209] = 3,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[210] = 113,
[211] = 85,
[212] = 88,
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[213] = 3,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[214] = 113,
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[215] = 0,
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
[216] = 115,
[217] = 115,
[218] = 115,
[219] = 115,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[220] = 113,
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
[221] = 115,
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[222] = 7,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[223] = 78,
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
[224] = 115,
[225] = 115,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[226] = 113,
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[227] = 0,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[228] = 113,
[229] = 113,
[230] = 113,
[231] = 113,
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[232] = 7,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[233] = 78,
[234] = 113,
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
[235] = 116,
Remove ordering of parse and lex items Using an unordered_map and unordered_set to store these speeds up grammar compilation significantly. The ordering method on items was using the rules' .to_string method to compute the order, which was not a meaningful comparison, and was probably slow.
2014-03-26 13:13:20 -07:00
[236] = 113,
Remove unused consumed_symbols vector from parse items
2014-03-26 21:02:53 -07:00
[237] = 116,
[238] = 116,
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
};
Clean up parser macros more
2014-03-26 12:52:31 -07:00
PARSE_TABLE = {
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
[0] = {
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[ts_sym__function] = SHIFT(1),
[ts_sym__if] = SHIFT(207),
[ts_sym__var] = SHIFT(13),
[ts_sym_array] = SHIFT(16),
[ts_sym_assignment] = SHIFT(227),
[ts_sym_expression] = SHIFT(227),
[ts_sym_false] = SHIFT(16),
[ts_sym_function_call] = SHIFT(18),
[ts_sym_function_expression] = SHIFT(18),
[ts_sym_identifier] = SHIFT(19),
[ts_sym_if_statement] = SHIFT(230),
[ts_sym_literal] = SHIFT(18),
[ts_sym_null] = SHIFT(16),
[ts_sym_number] = SHIFT(16),
[ts_sym_object] = SHIFT(16),
[ts_sym_program] = SHIFT(235),
[ts_sym_statement] = SHIFT(236),
[ts_sym_statement_block] = SHIFT(230),
[ts_sym_string] = SHIFT(16),
[ts_sym_true] = SHIFT(16),
[ts_aux_sym_repeat_helper1] = SHIFT(238),
[ts_aux_sym_token10] = SHIFT(32),
[ts_aux_sym_token5] = SHIFT(232),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
[ts_builtin_sym_end] = REDUCE(ts_aux_sym_repeat_helper1, 0),
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[1] = {
[ts_sym_identifier] = SHIFT(2),
},
[2] = {
[ts_sym_formal_parameters] = SHIFT(3),
[ts_aux_sym_token3] = SHIFT(50),
},
[3] = {
[ts_sym_statement_block] = SHIFT(4),
[ts_aux_sym_token5] = SHIFT(5),
},
[4] = {
[ts_aux_sym_token1] = REDUCE(ts_sym_function_expression, 4),
[ts_aux_sym_token2] = REDUCE(ts_sym_function_expression, 4),
},
[5] = {
[ts_sym__function] = SHIFT(1),
[ts_sym__if] = SHIFT(6),
[ts_sym__var] = SHIFT(13),
[ts_sym_array] = SHIFT(16),
[ts_sym_assignment] = SHIFT(26),
[ts_sym_expression] = SHIFT(26),
[ts_sym_false] = SHIFT(16),
[ts_sym_function_call] = SHIFT(18),
[ts_sym_function_expression] = SHIFT(18),
[ts_sym_identifier] = SHIFT(19),
[ts_sym_if_statement] = SHIFT(29),
[ts_sym_literal] = SHIFT(18),
[ts_sym_null] = SHIFT(16),
[ts_sym_number] = SHIFT(16),
[ts_sym_object] = SHIFT(16),
[ts_sym_statement] = SHIFT(30),
[ts_sym_statement_block] = SHIFT(29),
[ts_sym_string] = SHIFT(16),
[ts_sym_true] = SHIFT(16),
[ts_aux_sym_repeat_helper2] = SHIFT(205),
[ts_aux_sym_token10] = SHIFT(32),
[ts_aux_sym_token5] = SHIFT(40),
[ts_aux_sym_token6] = REDUCE(ts_aux_sym_repeat_helper2, 0),
},
[6] = {
[ts_aux_sym_token3] = SHIFT(7),
},
[7] = {
[ts_sym__function] = SHIFT(8),
[ts_sym_array] = SHIFT(163),
[ts_sym_expression] = SHIFT(164),
[ts_sym_false] = SHIFT(163),
[ts_sym_function_call] = SHIFT(180),
[ts_sym_function_expression] = SHIFT(180),
[ts_sym_identifier] = SHIFT(181),
[ts_sym_literal] = SHIFT(180),
[ts_sym_null] = SHIFT(163),
[ts_sym_number] = SHIFT(163),
[ts_sym_object] = SHIFT(163),
[ts_sym_string] = SHIFT(163),
[ts_sym_true] = SHIFT(163),
[ts_aux_sym_token10] = SHIFT(187),
[ts_aux_sym_token5] = SHIFT(192),
},
[8] = {
[ts_sym_identifier] = SHIFT(9),
},
[9] = {
[ts_sym_formal_parameters] = SHIFT(10),
[ts_aux_sym_token3] = SHIFT(50),
},
[10] = {
[ts_sym_statement_block] = SHIFT(11),
[ts_aux_sym_token5] = SHIFT(12),
},
[11] = {
[ts_aux_sym_token4] = REDUCE(ts_sym_function_expression, 4),
},
[12] = {
[ts_sym__function] = SHIFT(1),
[ts_sym__if] = SHIFT(6),
[ts_sym__var] = SHIFT(13),
[ts_sym_array] = SHIFT(16),
[ts_sym_assignment] = SHIFT(26),
[ts_sym_expression] = SHIFT(26),
[ts_sym_false] = SHIFT(16),
[ts_sym_function_call] = SHIFT(18),
[ts_sym_function_expression] = SHIFT(18),
[ts_sym_identifier] = SHIFT(19),
[ts_sym_if_statement] = SHIFT(29),
[ts_sym_literal] = SHIFT(18),
[ts_sym_null] = SHIFT(16),
[ts_sym_number] = SHIFT(16),
[ts_sym_object] = SHIFT(16),
[ts_sym_statement] = SHIFT(30),
[ts_sym_statement_block] = SHIFT(29),
[ts_sym_string] = SHIFT(16),
[ts_sym_true] = SHIFT(16),
[ts_aux_sym_repeat_helper2] = SHIFT(161),
[ts_aux_sym_token10] = SHIFT(32),
[ts_aux_sym_token5] = SHIFT(40),
[ts_aux_sym_token6] = REDUCE(ts_aux_sym_repeat_helper2, 0),
},
[13] = {
[ts_sym_identifier] = SHIFT(14),
},
[14] = {
[ts_aux_sym_token7] = SHIFT(15),
},
[15] = {
[ts_sym__function] = SHIFT(1),
[ts_sym_array] = SHIFT(16),
[ts_sym_expression] = SHIFT(17),
[ts_sym_false] = SHIFT(16),
[ts_sym_function_call] = SHIFT(18),
[ts_sym_function_expression] = SHIFT(18),
[ts_sym_identifier] = SHIFT(19),
[ts_sym_literal] = SHIFT(18),
[ts_sym_null] = SHIFT(16),
[ts_sym_number] = SHIFT(16),
[ts_sym_object] = SHIFT(16),
[ts_sym_string] = SHIFT(16),
[ts_sym_true] = SHIFT(16),
[ts_aux_sym_token10] = SHIFT(32),
[ts_aux_sym_token5] = SHIFT(159),
},
[16] = {
[ts_aux_sym_token1] = REDUCE(ts_sym_literal, 1),
[ts_aux_sym_token2] = REDUCE(ts_sym_literal, 1),
},
[17] = {
[ts_aux_sym_token1] = REDUCE(ts_sym_assignment, 4),
[ts_aux_sym_token2] = REDUCE(ts_sym_assignment, 4),
},
[18] = {
[ts_aux_sym_token1] = REDUCE(ts_sym_expression, 1),
[ts_aux_sym_token2] = REDUCE(ts_sym_expression, 1),
},
[19] = {
[ts_aux_sym_token1] = REDUCE(ts_sym_expression, 1),
[ts_aux_sym_token2] = REDUCE(ts_sym_expression, 1),
[ts_aux_sym_token3] = SHIFT(20),
},
[20] = {
[ts_sym__function] = SHIFT(21),
[ts_sym_array] = SHIFT(70),
[ts_sym_expression] = SHIFT(155),
[ts_sym_false] = SHIFT(70),
[ts_sym_function_call] = SHIFT(77),
[ts_sym_function_expression] = SHIFT(77),
[ts_sym_identifier] = SHIFT(78),
[ts_sym_literal] = SHIFT(77),
[ts_sym_null] = SHIFT(70),
[ts_sym_number] = SHIFT(70),
[ts_sym_object] = SHIFT(70),
[ts_sym_string] = SHIFT(70),
[ts_sym_true] = SHIFT(70),
[ts_aux_sym_token10] = SHIFT(83),
[ts_aux_sym_token4] = SHIFT(158),
[ts_aux_sym_token5] = SHIFT(98),
},
[21] = {
[ts_sym_identifier] = SHIFT(22),
},
[22] = {
[ts_sym_formal_parameters] = SHIFT(23),
[ts_aux_sym_token3] = SHIFT(50),
},
[23] = {
[ts_sym_statement_block] = SHIFT(24),
[ts_aux_sym_token5] = SHIFT(25),
},
[24] = {
[ts_aux_sym_token4] = REDUCE(ts_sym_function_expression, 4),
[ts_aux_sym_token8] = REDUCE(ts_sym_function_expression, 4),
},
[25] = {
[ts_sym__function] = SHIFT(1),
[ts_sym__if] = SHIFT(6),
[ts_sym__var] = SHIFT(13),
[ts_sym_array] = SHIFT(16),
[ts_sym_assignment] = SHIFT(26),
[ts_sym_expression] = SHIFT(26),
[ts_sym_false] = SHIFT(16),
[ts_sym_function_call] = SHIFT(18),
[ts_sym_function_expression] = SHIFT(18),
[ts_sym_identifier] = SHIFT(19),
[ts_sym_if_statement] = SHIFT(29),
[ts_sym_literal] = SHIFT(18),
[ts_sym_null] = SHIFT(16),
[ts_sym_number] = SHIFT(16),
[ts_sym_object] = SHIFT(16),
[ts_sym_statement] = SHIFT(30),
[ts_sym_statement_block] = SHIFT(29),
[ts_sym_string] = SHIFT(16),
[ts_sym_true] = SHIFT(16),
[ts_aux_sym_repeat_helper2] = SHIFT(153),
[ts_aux_sym_token10] = SHIFT(32),
[ts_aux_sym_token5] = SHIFT(40),
[ts_aux_sym_token6] = REDUCE(ts_aux_sym_repeat_helper2, 0),
},
[26] = {
[ts_sym__terminator] = SHIFT(27),
[ts_aux_sym_token1] = SHIFT(28),
[ts_aux_sym_token2] = SHIFT(28),
},
[27] = {
[ts_sym__function] = REDUCE(ts_sym_statement, 2),
[ts_sym__if] = REDUCE(ts_sym_statement, 2),
[ts_sym__var] = REDUCE(ts_sym_statement, 2),
[ts_sym_false] = REDUCE(ts_sym_statement, 2),
[ts_sym_identifier] = REDUCE(ts_sym_statement, 2),
[ts_sym_null] = REDUCE(ts_sym_statement, 2),
[ts_sym_number] = REDUCE(ts_sym_statement, 2),
[ts_sym_string] = REDUCE(ts_sym_statement, 2),
[ts_sym_true] = REDUCE(ts_sym_statement, 2),
[ts_aux_sym_token10] = REDUCE(ts_sym_statement, 2),
[ts_aux_sym_token5] = REDUCE(ts_sym_statement, 2),
[ts_aux_sym_token6] = REDUCE(ts_sym_statement, 2),
},
[28] = {
[ts_sym__function] = REDUCE(ts_sym__terminator, 1),
[ts_sym__if] = REDUCE(ts_sym__terminator, 1),
[ts_sym__var] = REDUCE(ts_sym__terminator, 1),
[ts_sym_false] = REDUCE(ts_sym__terminator, 1),
[ts_sym_identifier] = REDUCE(ts_sym__terminator, 1),
[ts_sym_null] = REDUCE(ts_sym__terminator, 1),
[ts_sym_number] = REDUCE(ts_sym__terminator, 1),
[ts_sym_string] = REDUCE(ts_sym__terminator, 1),
[ts_sym_true] = REDUCE(ts_sym__terminator, 1),
[ts_aux_sym_token10] = REDUCE(ts_sym__terminator, 1),
[ts_aux_sym_token5] = REDUCE(ts_sym__terminator, 1),
[ts_aux_sym_token6] = REDUCE(ts_sym__terminator, 1),
},
[29] = {
[ts_sym__function] = REDUCE(ts_sym_statement, 1),
[ts_sym__if] = REDUCE(ts_sym_statement, 1),
[ts_sym__var] = REDUCE(ts_sym_statement, 1),
[ts_sym_false] = REDUCE(ts_sym_statement, 1),
[ts_sym_identifier] = REDUCE(ts_sym_statement, 1),
[ts_sym_null] = REDUCE(ts_sym_statement, 1),
[ts_sym_number] = REDUCE(ts_sym_statement, 1),
[ts_sym_string] = REDUCE(ts_sym_statement, 1),
[ts_sym_true] = REDUCE(ts_sym_statement, 1),
[ts_aux_sym_token10] = REDUCE(ts_sym_statement, 1),
[ts_aux_sym_token5] = REDUCE(ts_sym_statement, 1),
[ts_aux_sym_token6] = REDUCE(ts_sym_statement, 1),
},
[30] = {
[ts_sym__function] = SHIFT(1),
[ts_sym__if] = SHIFT(6),
[ts_sym__var] = SHIFT(13),
[ts_sym_array] = SHIFT(16),
[ts_sym_assignment] = SHIFT(26),
[ts_sym_expression] = SHIFT(26),
[ts_sym_false] = SHIFT(16),
[ts_sym_function_call] = SHIFT(18),
[ts_sym_function_expression] = SHIFT(18),
[ts_sym_identifier] = SHIFT(19),
[ts_sym_if_statement] = SHIFT(29),
[ts_sym_literal] = SHIFT(18),
[ts_sym_null] = SHIFT(16),
[ts_sym_number] = SHIFT(16),
[ts_sym_object] = SHIFT(16),
[ts_sym_statement] = SHIFT(30),
[ts_sym_statement_block] = SHIFT(29),
[ts_sym_string] = SHIFT(16),
[ts_sym_true] = SHIFT(16),
[ts_aux_sym_repeat_helper2] = SHIFT(31),
[ts_aux_sym_token10] = SHIFT(32),
[ts_aux_sym_token5] = SHIFT(40),
[ts_aux_sym_token6] = REDUCE(ts_aux_sym_repeat_helper2, 0),
},
[31] = {
[ts_aux_sym_token6] = REDUCE(ts_aux_sym_repeat_helper2, 2),
},
[32] = {
[ts_sym__function] = SHIFT(33),
[ts_sym_array] = SHIFT(84),
[ts_sym_expression] = SHIFT(149),
[ts_sym_false] = SHIFT(84),
[ts_sym_function_call] = SHIFT(91),
[ts_sym_function_expression] = SHIFT(91),
[ts_sym_identifier] = SHIFT(92),
[ts_sym_literal] = SHIFT(91),
[ts_sym_null] = SHIFT(84),
[ts_sym_number] = SHIFT(84),
[ts_sym_object] = SHIFT(84),
[ts_sym_string] = SHIFT(84),
[ts_sym_true] = SHIFT(84),
[ts_aux_sym_token10] = SHIFT(108),
[ts_aux_sym_token11] = SHIFT(152),
[ts_aux_sym_token5] = SHIFT(113),
[ts_builtin_sym_error] = SHIFT(149),
},
[33] = {
[ts_sym_identifier] = SHIFT(34),
},
[34] = {
[ts_sym_formal_parameters] = SHIFT(35),
[ts_aux_sym_token3] = SHIFT(50),
},
[35] = {
[ts_sym_statement_block] = SHIFT(36),
[ts_aux_sym_token5] = SHIFT(37),
},
[36] = {
[ts_aux_sym_token11] = REDUCE(ts_sym_function_expression, 4),
[ts_aux_sym_token8] = REDUCE(ts_sym_function_expression, 4),
},
[37] = {
[ts_sym__function] = SHIFT(1),
[ts_sym__if] = SHIFT(6),
[ts_sym__var] = SHIFT(13),
[ts_sym_array] = SHIFT(16),
[ts_sym_assignment] = SHIFT(26),
[ts_sym_expression] = SHIFT(26),
[ts_sym_false] = SHIFT(16),
[ts_sym_function_call] = SHIFT(18),
[ts_sym_function_expression] = SHIFT(18),
[ts_sym_identifier] = SHIFT(19),
[ts_sym_if_statement] = SHIFT(29),
[ts_sym_literal] = SHIFT(18),
[ts_sym_null] = SHIFT(16),
[ts_sym_number] = SHIFT(16),
[ts_sym_object] = SHIFT(16),
[ts_sym_statement] = SHIFT(30),
[ts_sym_statement_block] = SHIFT(29),
[ts_sym_string] = SHIFT(16),
[ts_sym_true] = SHIFT(16),
[ts_aux_sym_repeat_helper2] = SHIFT(38),
[ts_aux_sym_token10] = SHIFT(32),
[ts_aux_sym_token5] = SHIFT(40),
[ts_aux_sym_token6] = REDUCE(ts_aux_sym_repeat_helper2, 0),
},
[38] = {
[ts_aux_sym_token6] = SHIFT(39),
},
[39] = {
[ts_aux_sym_token11] = REDUCE(ts_sym_statement_block, 3),
[ts_aux_sym_token8] = REDUCE(ts_sym_statement_block, 3),
},
[40] = {
[ts_sym__function] = SHIFT(1),
[ts_sym__if] = SHIFT(6),
[ts_sym__var] = SHIFT(13),
[ts_sym_array] = SHIFT(16),
[ts_sym_assignment] = SHIFT(26),
[ts_sym_expression] = SHIFT(26),
[ts_sym_false] = SHIFT(16),
[ts_sym_function_call] = SHIFT(18),
[ts_sym_function_expression] = SHIFT(18),
[ts_sym_identifier] = SHIFT(19),
[ts_sym_if_statement] = SHIFT(29),
[ts_sym_literal] = SHIFT(18),
[ts_sym_null] = SHIFT(16),
[ts_sym_number] = SHIFT(16),
[ts_sym_object] = SHIFT(16),
[ts_sym_statement] = SHIFT(30),
[ts_sym_statement_block] = SHIFT(29),
[ts_sym_string] = SHIFT(41),
[ts_sym_true] = SHIFT(16),
[ts_aux_sym_repeat_helper2] = SHIFT(143),
[ts_aux_sym_token10] = SHIFT(32),
[ts_aux_sym_token5] = SHIFT(40),
[ts_aux_sym_token6] = SHIFT(145),
[ts_builtin_sym_error] = SHIFT(146),
},
[41] = {
[ts_aux_sym_token1] = REDUCE(ts_sym_literal, 1),
[ts_aux_sym_token2] = REDUCE(ts_sym_literal, 1),
[ts_aux_sym_token9] = SHIFT(42),
},
[42] = {
[ts_sym__function] = SHIFT(43),
[ts_sym_array] = SHIFT(58),
[ts_sym_expression] = SHIFT(59),
[ts_sym_false] = SHIFT(58),
[ts_sym_function_call] = SHIFT(67),
[ts_sym_function_expression] = SHIFT(67),
[ts_sym_identifier] = SHIFT(68),
[ts_sym_literal] = SHIFT(67),
[ts_sym_null] = SHIFT(58),
[ts_sym_number] = SHIFT(58),
[ts_sym_object] = SHIFT(58),
[ts_sym_string] = SHIFT(58),
[ts_sym_true] = SHIFT(58),
[ts_aux_sym_token10] = SHIFT(104),
[ts_aux_sym_token5] = SHIFT(119),
},
[43] = {
[ts_sym_identifier] = SHIFT(44),
},
[44] = {
[ts_sym_formal_parameters] = SHIFT(45),
[ts_aux_sym_token3] = SHIFT(50),
},
[45] = {
[ts_sym_statement_block] = SHIFT(46),
[ts_aux_sym_token5] = SHIFT(47),
},
[46] = {
[ts_aux_sym_token6] = REDUCE(ts_sym_function_expression, 4),
[ts_aux_sym_token8] = REDUCE(ts_sym_function_expression, 4),
},
[47] = {
[ts_sym__function] = SHIFT(1),
[ts_sym__if] = SHIFT(6),
[ts_sym__var] = SHIFT(13),
[ts_sym_array] = SHIFT(16),
[ts_sym_assignment] = SHIFT(26),
[ts_sym_expression] = SHIFT(26),
[ts_sym_false] = SHIFT(16),
[ts_sym_function_call] = SHIFT(18),
[ts_sym_function_expression] = SHIFT(18),
[ts_sym_identifier] = SHIFT(19),
[ts_sym_if_statement] = SHIFT(29),
[ts_sym_literal] = SHIFT(18),
[ts_sym_null] = SHIFT(16),
[ts_sym_number] = SHIFT(16),
[ts_sym_object] = SHIFT(16),
[ts_sym_statement] = SHIFT(30),
[ts_sym_statement_block] = SHIFT(29),
[ts_sym_string] = SHIFT(16),
[ts_sym_true] = SHIFT(16),
[ts_aux_sym_repeat_helper2] = SHIFT(48),
[ts_aux_sym_token10] = SHIFT(32),
[ts_aux_sym_token5] = SHIFT(40),
[ts_aux_sym_token6] = REDUCE(ts_aux_sym_repeat_helper2, 0),
},
[48] = {
[ts_aux_sym_token6] = SHIFT(49),
},
[49] = {
[ts_aux_sym_token6] = REDUCE(ts_sym_statement_block, 3),
[ts_aux_sym_token8] = REDUCE(ts_sym_statement_block, 3),
},
[50] = {
[ts_sym_identifier] = SHIFT(51),
[ts_aux_sym_token4] = SHIFT(57),
},
[51] = {
[ts_aux_sym_repeat_helper4] = SHIFT(52),
[ts_aux_sym_token4] = REDUCE(ts_aux_sym_repeat_helper4, 0),
[ts_aux_sym_token8] = SHIFT(54),
},
[52] = {
[ts_aux_sym_token4] = SHIFT(53),
},
[53] = {
[ts_aux_sym_token5] = REDUCE(ts_sym_formal_parameters, 4),
},
[54] = {
[ts_sym_identifier] = SHIFT(55),
},
[55] = {
[ts_aux_sym_repeat_helper4] = SHIFT(56),
[ts_aux_sym_token4] = REDUCE(ts_aux_sym_repeat_helper4, 0),
[ts_aux_sym_token8] = SHIFT(54),
},
[56] = {
[ts_aux_sym_token4] = REDUCE(ts_aux_sym_repeat_helper4, 3),
},
[57] = {
[ts_aux_sym_token5] = REDUCE(ts_sym_formal_parameters, 2),
},
[58] = {
[ts_aux_sym_token6] = REDUCE(ts_sym_literal, 1),
[ts_aux_sym_token8] = REDUCE(ts_sym_literal, 1),
},
[59] = {
[ts_aux_sym_repeat_helper5] = SHIFT(60),
[ts_aux_sym_token6] = REDUCE(ts_aux_sym_repeat_helper5, 0),
[ts_aux_sym_token8] = SHIFT(62),
},
[60] = {
[ts_aux_sym_token6] = SHIFT(61),
},
[61] = {
[ts_aux_sym_token1] = REDUCE(ts_sym_object, 6),
[ts_aux_sym_token2] = REDUCE(ts_sym_object, 6),
},
[62] = {
[ts_sym_string] = SHIFT(63),
[ts_builtin_sym_error] = SHIFT(141),
},
[63] = {
[ts_aux_sym_token9] = SHIFT(64),
},
[64] = {
[ts_sym__function] = SHIFT(43),
[ts_sym_array] = SHIFT(58),
[ts_sym_expression] = SHIFT(65),
[ts_sym_false] = SHIFT(58),
[ts_sym_function_call] = SHIFT(67),
[ts_sym_function_expression] = SHIFT(67),
[ts_sym_identifier] = SHIFT(68),
[ts_sym_literal] = SHIFT(67),
[ts_sym_null] = SHIFT(58),
[ts_sym_number] = SHIFT(58),
[ts_sym_object] = SHIFT(58),
[ts_sym_string] = SHIFT(58),
[ts_sym_true] = SHIFT(58),
[ts_aux_sym_token10] = SHIFT(104),
[ts_aux_sym_token5] = SHIFT(119),
},
[65] = {
[ts_aux_sym_repeat_helper5] = SHIFT(66),
[ts_aux_sym_token6] = REDUCE(ts_aux_sym_repeat_helper5, 0),
[ts_aux_sym_token8] = SHIFT(62),
},
[66] = {
[ts_aux_sym_token6] = REDUCE(ts_aux_sym_repeat_helper5, 5),
},
[67] = {
[ts_aux_sym_token6] = REDUCE(ts_sym_expression, 1),
[ts_aux_sym_token8] = REDUCE(ts_sym_expression, 1),
},
[68] = {
[ts_aux_sym_token3] = SHIFT(69),
[ts_aux_sym_token6] = REDUCE(ts_sym_expression, 1),
[ts_aux_sym_token8] = REDUCE(ts_sym_expression, 1),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[69] = {
[ts_sym__function] = SHIFT(21),
[ts_sym_array] = SHIFT(70),
[ts_sym_expression] = SHIFT(71),
[ts_sym_false] = SHIFT(70),
[ts_sym_function_call] = SHIFT(77),
[ts_sym_function_expression] = SHIFT(77),
[ts_sym_identifier] = SHIFT(78),
[ts_sym_literal] = SHIFT(77),
[ts_sym_null] = SHIFT(70),
[ts_sym_number] = SHIFT(70),
[ts_sym_object] = SHIFT(70),
[ts_sym_string] = SHIFT(70),
[ts_sym_true] = SHIFT(70),
[ts_aux_sym_token10] = SHIFT(83),
[ts_aux_sym_token4] = SHIFT(140),
[ts_aux_sym_token5] = SHIFT(98),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[70] = {
[ts_aux_sym_token4] = REDUCE(ts_sym_literal, 1),
[ts_aux_sym_token8] = REDUCE(ts_sym_literal, 1),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[71] = {
[ts_aux_sym_repeat_helper3] = SHIFT(72),
[ts_aux_sym_token4] = REDUCE(ts_aux_sym_repeat_helper3, 0),
[ts_aux_sym_token8] = SHIFT(74),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[72] = {
[ts_aux_sym_token4] = SHIFT(73),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[73] = {
[ts_aux_sym_token6] = REDUCE(ts_sym_function_call, 5),
[ts_aux_sym_token8] = REDUCE(ts_sym_function_call, 5),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[74] = {
[ts_sym__function] = SHIFT(21),
[ts_sym_array] = SHIFT(70),
[ts_sym_expression] = SHIFT(75),
[ts_sym_false] = SHIFT(70),
[ts_sym_function_call] = SHIFT(77),
[ts_sym_function_expression] = SHIFT(77),
[ts_sym_identifier] = SHIFT(78),
[ts_sym_literal] = SHIFT(77),
[ts_sym_null] = SHIFT(70),
[ts_sym_number] = SHIFT(70),
[ts_sym_object] = SHIFT(70),
[ts_sym_string] = SHIFT(70),
[ts_sym_true] = SHIFT(70),
[ts_aux_sym_token10] = SHIFT(83),
[ts_aux_sym_token5] = SHIFT(98),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[75] = {
[ts_aux_sym_repeat_helper3] = SHIFT(76),
[ts_aux_sym_token4] = REDUCE(ts_aux_sym_repeat_helper3, 0),
[ts_aux_sym_token8] = SHIFT(74),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[76] = {
[ts_aux_sym_token4] = REDUCE(ts_aux_sym_repeat_helper3, 3),
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[77] = {
[ts_aux_sym_token4] = REDUCE(ts_sym_expression, 1),
[ts_aux_sym_token8] = REDUCE(ts_sym_expression, 1),
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[78] = {
[ts_aux_sym_token3] = SHIFT(79),
[ts_aux_sym_token4] = REDUCE(ts_sym_expression, 1),
[ts_aux_sym_token8] = REDUCE(ts_sym_expression, 1),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[79] = {
[ts_sym__function] = SHIFT(21),
[ts_sym_array] = SHIFT(70),
[ts_sym_expression] = SHIFT(80),
[ts_sym_false] = SHIFT(70),
[ts_sym_function_call] = SHIFT(77),
[ts_sym_function_expression] = SHIFT(77),
[ts_sym_identifier] = SHIFT(78),
[ts_sym_literal] = SHIFT(77),
[ts_sym_null] = SHIFT(70),
[ts_sym_number] = SHIFT(70),
[ts_sym_object] = SHIFT(70),
[ts_sym_string] = SHIFT(70),
[ts_sym_true] = SHIFT(70),
[ts_aux_sym_token10] = SHIFT(83),
[ts_aux_sym_token4] = SHIFT(139),
[ts_aux_sym_token5] = SHIFT(98),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[80] = {
[ts_aux_sym_repeat_helper3] = SHIFT(81),
[ts_aux_sym_token4] = REDUCE(ts_aux_sym_repeat_helper3, 0),
[ts_aux_sym_token8] = SHIFT(74),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[81] = {
[ts_aux_sym_token4] = SHIFT(82),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[82] = {
[ts_aux_sym_token4] = REDUCE(ts_sym_function_call, 5),
[ts_aux_sym_token8] = REDUCE(ts_sym_function_call, 5),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[83] = {
[ts_sym__function] = SHIFT(33),
[ts_sym_array] = SHIFT(84),
[ts_sym_expression] = SHIFT(85),
[ts_sym_false] = SHIFT(84),
[ts_sym_function_call] = SHIFT(91),
[ts_sym_function_expression] = SHIFT(91),
[ts_sym_identifier] = SHIFT(92),
[ts_sym_literal] = SHIFT(91),
[ts_sym_null] = SHIFT(84),
[ts_sym_number] = SHIFT(84),
[ts_sym_object] = SHIFT(84),
[ts_sym_string] = SHIFT(84),
[ts_sym_true] = SHIFT(84),
[ts_aux_sym_token10] = SHIFT(108),
[ts_aux_sym_token11] = SHIFT(138),
[ts_aux_sym_token5] = SHIFT(113),
[ts_builtin_sym_error] = SHIFT(85),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[84] = {
[ts_aux_sym_token11] = REDUCE(ts_sym_literal, 1),
[ts_aux_sym_token8] = REDUCE(ts_sym_literal, 1),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[85] = {
[ts_aux_sym_repeat_helper6] = SHIFT(86),
[ts_aux_sym_token11] = REDUCE(ts_aux_sym_repeat_helper6, 0),
[ts_aux_sym_token8] = SHIFT(88),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[86] = {
[ts_aux_sym_token11] = SHIFT(87),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[87] = {
[ts_aux_sym_token4] = REDUCE(ts_sym_array, 4),
[ts_aux_sym_token8] = REDUCE(ts_sym_array, 4),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[88] = {
[ts_sym__function] = SHIFT(33),
[ts_sym_array] = SHIFT(84),
[ts_sym_expression] = SHIFT(89),
[ts_sym_false] = SHIFT(84),
[ts_sym_function_call] = SHIFT(91),
[ts_sym_function_expression] = SHIFT(91),
[ts_sym_identifier] = SHIFT(92),
[ts_sym_literal] = SHIFT(91),
[ts_sym_null] = SHIFT(84),
[ts_sym_number] = SHIFT(84),
[ts_sym_object] = SHIFT(84),
[ts_sym_string] = SHIFT(84),
[ts_sym_true] = SHIFT(84),
[ts_aux_sym_token10] = SHIFT(108),
[ts_aux_sym_token5] = SHIFT(113),
[ts_builtin_sym_error] = SHIFT(89),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[89] = {
[ts_aux_sym_repeat_helper6] = SHIFT(90),
[ts_aux_sym_token11] = REDUCE(ts_aux_sym_repeat_helper6, 0),
[ts_aux_sym_token8] = SHIFT(88),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[90] = {
[ts_aux_sym_token11] = REDUCE(ts_aux_sym_repeat_helper6, 3),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[91] = {
[ts_aux_sym_token11] = REDUCE(ts_sym_expression, 1),
[ts_aux_sym_token8] = REDUCE(ts_sym_expression, 1),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[92] = {
[ts_aux_sym_token11] = REDUCE(ts_sym_expression, 1),
[ts_aux_sym_token3] = SHIFT(93),
[ts_aux_sym_token8] = REDUCE(ts_sym_expression, 1),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[93] = {
[ts_sym__function] = SHIFT(21),
[ts_sym_array] = SHIFT(70),
[ts_sym_expression] = SHIFT(94),
[ts_sym_false] = SHIFT(70),
[ts_sym_function_call] = SHIFT(77),
[ts_sym_function_expression] = SHIFT(77),
[ts_sym_identifier] = SHIFT(78),
[ts_sym_literal] = SHIFT(77),
[ts_sym_null] = SHIFT(70),
[ts_sym_number] = SHIFT(70),
[ts_sym_object] = SHIFT(70),
[ts_sym_string] = SHIFT(70),
[ts_sym_true] = SHIFT(70),
[ts_aux_sym_token10] = SHIFT(83),
[ts_aux_sym_token4] = SHIFT(97),
[ts_aux_sym_token5] = SHIFT(98),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[94] = {
[ts_aux_sym_repeat_helper3] = SHIFT(95),
[ts_aux_sym_token4] = REDUCE(ts_aux_sym_repeat_helper3, 0),
[ts_aux_sym_token8] = SHIFT(74),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[95] = {
[ts_aux_sym_token4] = SHIFT(96),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[96] = {
[ts_aux_sym_token11] = REDUCE(ts_sym_function_call, 5),
[ts_aux_sym_token8] = REDUCE(ts_sym_function_call, 5),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[97] = {
[ts_aux_sym_token11] = REDUCE(ts_sym_function_call, 3),
[ts_aux_sym_token8] = REDUCE(ts_sym_function_call, 3),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[98] = {
[ts_sym_string] = SHIFT(99),
[ts_aux_sym_token6] = SHIFT(134),
[ts_builtin_sym_error] = SHIFT(135),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[99] = {
[ts_aux_sym_token9] = SHIFT(100),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[100] = {
[ts_sym__function] = SHIFT(43),
[ts_sym_array] = SHIFT(58),
[ts_sym_expression] = SHIFT(101),
[ts_sym_false] = SHIFT(58),
[ts_sym_function_call] = SHIFT(67),
[ts_sym_function_expression] = SHIFT(67),
[ts_sym_identifier] = SHIFT(68),
[ts_sym_literal] = SHIFT(67),
[ts_sym_null] = SHIFT(58),
[ts_sym_number] = SHIFT(58),
[ts_sym_object] = SHIFT(58),
[ts_sym_string] = SHIFT(58),
[ts_sym_true] = SHIFT(58),
[ts_aux_sym_token10] = SHIFT(104),
[ts_aux_sym_token5] = SHIFT(119),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[101] = {
[ts_aux_sym_repeat_helper5] = SHIFT(102),
[ts_aux_sym_token6] = REDUCE(ts_aux_sym_repeat_helper5, 0),
[ts_aux_sym_token8] = SHIFT(62),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[102] = {
[ts_aux_sym_token6] = SHIFT(103),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[103] = {
[ts_aux_sym_token4] = REDUCE(ts_sym_object, 6),
[ts_aux_sym_token8] = REDUCE(ts_sym_object, 6),
},
[104] = {
[ts_sym__function] = SHIFT(33),
[ts_sym_array] = SHIFT(84),
[ts_sym_expression] = SHIFT(105),
[ts_sym_false] = SHIFT(84),
[ts_sym_function_call] = SHIFT(91),
[ts_sym_function_expression] = SHIFT(91),
[ts_sym_identifier] = SHIFT(92),
[ts_sym_literal] = SHIFT(91),
[ts_sym_null] = SHIFT(84),
[ts_sym_number] = SHIFT(84),
[ts_sym_object] = SHIFT(84),
[ts_sym_string] = SHIFT(84),
[ts_sym_true] = SHIFT(84),
[ts_aux_sym_token10] = SHIFT(108),
[ts_aux_sym_token11] = SHIFT(133),
[ts_aux_sym_token5] = SHIFT(113),
[ts_builtin_sym_error] = SHIFT(105),
},
[105] = {
[ts_aux_sym_repeat_helper6] = SHIFT(106),
[ts_aux_sym_token11] = REDUCE(ts_aux_sym_repeat_helper6, 0),
[ts_aux_sym_token8] = SHIFT(88),
},
[106] = {
[ts_aux_sym_token11] = SHIFT(107),
},
[107] = {
[ts_aux_sym_token6] = REDUCE(ts_sym_array, 4),
[ts_aux_sym_token8] = REDUCE(ts_sym_array, 4),
},
[108] = {
[ts_sym__function] = SHIFT(33),
[ts_sym_array] = SHIFT(84),
[ts_sym_expression] = SHIFT(109),
[ts_sym_false] = SHIFT(84),
[ts_sym_function_call] = SHIFT(91),
[ts_sym_function_expression] = SHIFT(91),
[ts_sym_identifier] = SHIFT(92),
[ts_sym_literal] = SHIFT(91),
[ts_sym_null] = SHIFT(84),
[ts_sym_number] = SHIFT(84),
[ts_sym_object] = SHIFT(84),
[ts_sym_string] = SHIFT(84),
[ts_sym_true] = SHIFT(84),
[ts_aux_sym_token10] = SHIFT(108),
[ts_aux_sym_token11] = SHIFT(112),
[ts_aux_sym_token5] = SHIFT(113),
[ts_builtin_sym_error] = SHIFT(109),
},
[109] = {
[ts_aux_sym_repeat_helper6] = SHIFT(110),
[ts_aux_sym_token11] = REDUCE(ts_aux_sym_repeat_helper6, 0),
[ts_aux_sym_token8] = SHIFT(88),
},
[110] = {
[ts_aux_sym_token11] = SHIFT(111),
},
[111] = {
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
[ts_aux_sym_token11] = REDUCE(ts_sym_array, 4),
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[ts_aux_sym_token8] = REDUCE(ts_sym_array, 4),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[112] = {
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
[ts_aux_sym_token11] = REDUCE(ts_sym_array, 2),
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[ts_aux_sym_token8] = REDUCE(ts_sym_array, 2),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[113] = {
[ts_sym_string] = SHIFT(114),
[ts_aux_sym_token6] = SHIFT(129),
[ts_builtin_sym_error] = SHIFT(130),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[114] = {
[ts_aux_sym_token9] = SHIFT(115),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[115] = {
[ts_sym__function] = SHIFT(43),
[ts_sym_array] = SHIFT(58),
[ts_sym_expression] = SHIFT(116),
[ts_sym_false] = SHIFT(58),
[ts_sym_function_call] = SHIFT(67),
[ts_sym_function_expression] = SHIFT(67),
[ts_sym_identifier] = SHIFT(68),
[ts_sym_literal] = SHIFT(67),
[ts_sym_null] = SHIFT(58),
[ts_sym_number] = SHIFT(58),
[ts_sym_object] = SHIFT(58),
[ts_sym_string] = SHIFT(58),
[ts_sym_true] = SHIFT(58),
[ts_aux_sym_token10] = SHIFT(104),
[ts_aux_sym_token5] = SHIFT(119),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[116] = {
[ts_aux_sym_repeat_helper5] = SHIFT(117),
[ts_aux_sym_token6] = REDUCE(ts_aux_sym_repeat_helper5, 0),
[ts_aux_sym_token8] = SHIFT(62),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[117] = {
[ts_aux_sym_token6] = SHIFT(118),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[118] = {
[ts_aux_sym_token11] = REDUCE(ts_sym_object, 6),
[ts_aux_sym_token8] = REDUCE(ts_sym_object, 6),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[119] = {
[ts_sym_string] = SHIFT(120),
[ts_aux_sym_token6] = SHIFT(125),
[ts_builtin_sym_error] = SHIFT(126),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[120] = {
[ts_aux_sym_token9] = SHIFT(121),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[121] = {
[ts_sym__function] = SHIFT(43),
[ts_sym_array] = SHIFT(58),
[ts_sym_expression] = SHIFT(122),
[ts_sym_false] = SHIFT(58),
[ts_sym_function_call] = SHIFT(67),
[ts_sym_function_expression] = SHIFT(67),
[ts_sym_identifier] = SHIFT(68),
[ts_sym_literal] = SHIFT(67),
[ts_sym_null] = SHIFT(58),
[ts_sym_number] = SHIFT(58),
[ts_sym_object] = SHIFT(58),
[ts_sym_string] = SHIFT(58),
[ts_sym_true] = SHIFT(58),
[ts_aux_sym_token10] = SHIFT(104),
[ts_aux_sym_token5] = SHIFT(119),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[122] = {
[ts_aux_sym_repeat_helper5] = SHIFT(123),
[ts_aux_sym_token6] = REDUCE(ts_aux_sym_repeat_helper5, 0),
[ts_aux_sym_token8] = SHIFT(62),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[123] = {
[ts_aux_sym_token6] = SHIFT(124),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[124] = {
[ts_aux_sym_token6] = REDUCE(ts_sym_object, 6),
[ts_aux_sym_token8] = REDUCE(ts_sym_object, 6),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[125] = {
[ts_aux_sym_token6] = REDUCE(ts_sym_object, 2),
[ts_aux_sym_token8] = REDUCE(ts_sym_object, 2),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[126] = {
[ts_aux_sym_repeat_helper5] = SHIFT(127),
[ts_aux_sym_token6] = REDUCE(ts_aux_sym_repeat_helper5, 0),
[ts_aux_sym_token8] = SHIFT(62),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[127] = {
[ts_aux_sym_token6] = SHIFT(128),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[128] = {
[ts_aux_sym_token6] = REDUCE(ts_sym_object, 4),
[ts_aux_sym_token8] = REDUCE(ts_sym_object, 4),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[129] = {
[ts_aux_sym_token11] = REDUCE(ts_sym_object, 2),
[ts_aux_sym_token8] = REDUCE(ts_sym_object, 2),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[130] = {
[ts_aux_sym_repeat_helper5] = SHIFT(131),
[ts_aux_sym_token6] = REDUCE(ts_aux_sym_repeat_helper5, 0),
[ts_aux_sym_token8] = SHIFT(62),
},
[131] = {
[ts_aux_sym_token6] = SHIFT(132),
},
[132] = {
[ts_aux_sym_token11] = REDUCE(ts_sym_object, 4),
[ts_aux_sym_token8] = REDUCE(ts_sym_object, 4),
},
[133] = {
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
[ts_aux_sym_token6] = REDUCE(ts_sym_array, 2),
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[ts_aux_sym_token8] = REDUCE(ts_sym_array, 2),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[134] = {
[ts_aux_sym_token4] = REDUCE(ts_sym_object, 2),
[ts_aux_sym_token8] = REDUCE(ts_sym_object, 2),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[135] = {
[ts_aux_sym_repeat_helper5] = SHIFT(136),
[ts_aux_sym_token6] = REDUCE(ts_aux_sym_repeat_helper5, 0),
[ts_aux_sym_token8] = SHIFT(62),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[136] = {
[ts_aux_sym_token6] = SHIFT(137),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[137] = {
[ts_aux_sym_token4] = REDUCE(ts_sym_object, 4),
[ts_aux_sym_token8] = REDUCE(ts_sym_object, 4),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[138] = {
[ts_aux_sym_token4] = REDUCE(ts_sym_array, 2),
[ts_aux_sym_token8] = REDUCE(ts_sym_array, 2),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[139] = {
[ts_aux_sym_token4] = REDUCE(ts_sym_function_call, 3),
[ts_aux_sym_token8] = REDUCE(ts_sym_function_call, 3),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[140] = {
[ts_aux_sym_token6] = REDUCE(ts_sym_function_call, 3),
[ts_aux_sym_token8] = REDUCE(ts_sym_function_call, 3),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[141] = {
[ts_aux_sym_repeat_helper5] = SHIFT(142),
[ts_aux_sym_token6] = REDUCE(ts_aux_sym_repeat_helper5, 0),
[ts_aux_sym_token8] = SHIFT(62),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[142] = {
[ts_aux_sym_token6] = REDUCE(ts_aux_sym_repeat_helper5, 3),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[143] = {
[ts_aux_sym_token6] = SHIFT(144),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[144] = {
[ts_sym__function] = REDUCE(ts_sym_statement_block, 3),
[ts_sym__if] = REDUCE(ts_sym_statement_block, 3),
[ts_sym__var] = REDUCE(ts_sym_statement_block, 3),
[ts_sym_false] = REDUCE(ts_sym_statement_block, 3),
[ts_sym_identifier] = REDUCE(ts_sym_statement_block, 3),
[ts_sym_null] = REDUCE(ts_sym_statement_block, 3),
[ts_sym_number] = REDUCE(ts_sym_statement_block, 3),
[ts_sym_string] = REDUCE(ts_sym_statement_block, 3),
[ts_sym_true] = REDUCE(ts_sym_statement_block, 3),
[ts_aux_sym_token10] = REDUCE(ts_sym_statement_block, 3),
[ts_aux_sym_token5] = REDUCE(ts_sym_statement_block, 3),
[ts_aux_sym_token6] = REDUCE(ts_sym_statement_block, 3),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[145] = {
[ts_aux_sym_token1] = REDUCE(ts_sym_object, 2),
[ts_aux_sym_token2] = REDUCE(ts_sym_object, 2),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[146] = {
[ts_aux_sym_repeat_helper5] = SHIFT(147),
[ts_aux_sym_token6] = REDUCE(ts_aux_sym_repeat_helper5, 0),
[ts_aux_sym_token8] = SHIFT(62),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[147] = {
[ts_aux_sym_token6] = SHIFT(148),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[148] = {
[ts_aux_sym_token1] = REDUCE(ts_sym_object, 4),
[ts_aux_sym_token2] = REDUCE(ts_sym_object, 4),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[149] = {
[ts_aux_sym_repeat_helper6] = SHIFT(150),
[ts_aux_sym_token11] = REDUCE(ts_aux_sym_repeat_helper6, 0),
[ts_aux_sym_token8] = SHIFT(88),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[150] = {
[ts_aux_sym_token11] = SHIFT(151),
},
[151] = {
[ts_aux_sym_token1] = REDUCE(ts_sym_array, 4),
[ts_aux_sym_token2] = REDUCE(ts_sym_array, 4),
},
[152] = {
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
[ts_aux_sym_token1] = REDUCE(ts_sym_array, 2),
[ts_aux_sym_token2] = REDUCE(ts_sym_array, 2),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[153] = {
[ts_aux_sym_token6] = SHIFT(154),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[154] = {
[ts_aux_sym_token4] = REDUCE(ts_sym_statement_block, 3),
[ts_aux_sym_token8] = REDUCE(ts_sym_statement_block, 3),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[155] = {
[ts_aux_sym_repeat_helper3] = SHIFT(156),
[ts_aux_sym_token4] = REDUCE(ts_aux_sym_repeat_helper3, 0),
[ts_aux_sym_token8] = SHIFT(74),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[156] = {
[ts_aux_sym_token4] = SHIFT(157),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[157] = {
[ts_aux_sym_token1] = REDUCE(ts_sym_function_call, 5),
[ts_aux_sym_token2] = REDUCE(ts_sym_function_call, 5),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[158] = {
[ts_aux_sym_token1] = REDUCE(ts_sym_function_call, 3),
[ts_aux_sym_token2] = REDUCE(ts_sym_function_call, 3),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[159] = {
[ts_sym_string] = SHIFT(160),
[ts_aux_sym_token6] = SHIFT(145),
[ts_builtin_sym_error] = SHIFT(146),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[160] = {
[ts_aux_sym_token9] = SHIFT(42),
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[161] = {
[ts_aux_sym_token6] = SHIFT(162),
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[162] = {
[ts_aux_sym_token4] = REDUCE(ts_sym_statement_block, 3),
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[163] = {
[ts_aux_sym_token4] = REDUCE(ts_sym_literal, 1),
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[164] = {
[ts_aux_sym_token4] = SHIFT(165),
},
[165] = {
[ts_sym__function] = SHIFT(1),
[ts_sym__if] = SHIFT(166),
[ts_sym__var] = SHIFT(13),
[ts_sym_array] = SHIFT(16),
[ts_sym_assignment] = SHIFT(170),
[ts_sym_expression] = SHIFT(170),
[ts_sym_false] = SHIFT(16),
[ts_sym_function_call] = SHIFT(18),
[ts_sym_function_expression] = SHIFT(18),
[ts_sym_identifier] = SHIFT(19),
[ts_sym_if_statement] = SHIFT(173),
[ts_sym_literal] = SHIFT(18),
[ts_sym_null] = SHIFT(16),
[ts_sym_number] = SHIFT(16),
[ts_sym_object] = SHIFT(16),
[ts_sym_statement] = SHIFT(202),
[ts_sym_statement_block] = SHIFT(173),
[ts_sym_string] = SHIFT(16),
[ts_sym_true] = SHIFT(16),
[ts_aux_sym_token10] = SHIFT(32),
[ts_aux_sym_token5] = SHIFT(177),
},
[166] = {
[ts_aux_sym_token3] = SHIFT(167),
},
[167] = {
[ts_sym__function] = SHIFT(8),
[ts_sym_array] = SHIFT(163),
[ts_sym_expression] = SHIFT(168),
[ts_sym_false] = SHIFT(163),
[ts_sym_function_call] = SHIFT(180),
[ts_sym_function_expression] = SHIFT(180),
[ts_sym_identifier] = SHIFT(181),
[ts_sym_literal] = SHIFT(180),
[ts_sym_null] = SHIFT(163),
[ts_sym_number] = SHIFT(163),
[ts_sym_object] = SHIFT(163),
[ts_sym_string] = SHIFT(163),
[ts_sym_true] = SHIFT(163),
[ts_aux_sym_token10] = SHIFT(187),
[ts_aux_sym_token5] = SHIFT(192),
},
[168] = {
[ts_aux_sym_token4] = SHIFT(169),
},
[169] = {
[ts_sym__function] = SHIFT(1),
[ts_sym__if] = SHIFT(166),
[ts_sym__var] = SHIFT(13),
[ts_sym_array] = SHIFT(16),
[ts_sym_assignment] = SHIFT(170),
[ts_sym_expression] = SHIFT(170),
[ts_sym_false] = SHIFT(16),
[ts_sym_function_call] = SHIFT(18),
[ts_sym_function_expression] = SHIFT(18),
[ts_sym_identifier] = SHIFT(19),
[ts_sym_if_statement] = SHIFT(173),
[ts_sym_literal] = SHIFT(18),
[ts_sym_null] = SHIFT(16),
[ts_sym_number] = SHIFT(16),
[ts_sym_object] = SHIFT(16),
[ts_sym_statement] = SHIFT(174),
[ts_sym_statement_block] = SHIFT(173),
[ts_sym_string] = SHIFT(16),
[ts_sym_true] = SHIFT(16),
[ts_aux_sym_token10] = SHIFT(32),
[ts_aux_sym_token5] = SHIFT(177),
},
[170] = {
[ts_sym__terminator] = SHIFT(171),
[ts_aux_sym_token1] = SHIFT(172),
[ts_aux_sym_token2] = SHIFT(172),
},
[171] = {
[ts_sym__else] = REDUCE(ts_sym_statement, 2),
[ts_sym__function] = REDUCE(ts_sym_statement, 2),
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
[ts_sym__if] = REDUCE(ts_sym_statement, 2),
[ts_sym__var] = REDUCE(ts_sym_statement, 2),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
[ts_sym_false] = REDUCE(ts_sym_statement, 2),
[ts_sym_identifier] = REDUCE(ts_sym_statement, 2),
[ts_sym_null] = REDUCE(ts_sym_statement, 2),
[ts_sym_number] = REDUCE(ts_sym_statement, 2),
[ts_sym_string] = REDUCE(ts_sym_statement, 2),
[ts_sym_true] = REDUCE(ts_sym_statement, 2),
[ts_aux_sym_token10] = REDUCE(ts_sym_statement, 2),
[ts_aux_sym_token5] = REDUCE(ts_sym_statement, 2),
[ts_aux_sym_token6] = REDUCE(ts_sym_statement, 2),
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[172] = {
[ts_sym__else] = REDUCE(ts_sym__terminator, 1),
[ts_sym__function] = REDUCE(ts_sym__terminator, 1),
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
[ts_sym__if] = REDUCE(ts_sym__terminator, 1),
[ts_sym__var] = REDUCE(ts_sym__terminator, 1),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
[ts_sym_false] = REDUCE(ts_sym__terminator, 1),
[ts_sym_identifier] = REDUCE(ts_sym__terminator, 1),
[ts_sym_null] = REDUCE(ts_sym__terminator, 1),
[ts_sym_number] = REDUCE(ts_sym__terminator, 1),
[ts_sym_string] = REDUCE(ts_sym__terminator, 1),
[ts_sym_true] = REDUCE(ts_sym__terminator, 1),
[ts_aux_sym_token10] = REDUCE(ts_sym__terminator, 1),
[ts_aux_sym_token5] = REDUCE(ts_sym__terminator, 1),
[ts_aux_sym_token6] = REDUCE(ts_sym__terminator, 1),
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[173] = {
[ts_sym__else] = REDUCE(ts_sym_statement, 1),
[ts_sym__function] = REDUCE(ts_sym_statement, 1),
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
[ts_sym__if] = REDUCE(ts_sym_statement, 1),
[ts_sym__var] = REDUCE(ts_sym_statement, 1),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
[ts_sym_false] = REDUCE(ts_sym_statement, 1),
[ts_sym_identifier] = REDUCE(ts_sym_statement, 1),
[ts_sym_null] = REDUCE(ts_sym_statement, 1),
[ts_sym_number] = REDUCE(ts_sym_statement, 1),
[ts_sym_string] = REDUCE(ts_sym_statement, 1),
[ts_sym_true] = REDUCE(ts_sym_statement, 1),
[ts_aux_sym_token10] = REDUCE(ts_sym_statement, 1),
[ts_aux_sym_token5] = REDUCE(ts_sym_statement, 1),
[ts_aux_sym_token6] = REDUCE(ts_sym_statement, 1),
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[174] = {
[ts_sym__else] = SHIFT(175),
[ts_sym__function] = REDUCE(ts_sym_if_statement, 5),
[ts_sym__if] = REDUCE(ts_sym_if_statement, 5),
[ts_sym__var] = REDUCE(ts_sym_if_statement, 5),
[ts_sym_false] = REDUCE(ts_sym_if_statement, 5),
[ts_sym_identifier] = REDUCE(ts_sym_if_statement, 5),
[ts_sym_null] = REDUCE(ts_sym_if_statement, 5),
[ts_sym_number] = REDUCE(ts_sym_if_statement, 5),
[ts_sym_string] = REDUCE(ts_sym_if_statement, 5),
[ts_sym_true] = REDUCE(ts_sym_if_statement, 5),
[ts_aux_sym_token10] = REDUCE(ts_sym_if_statement, 5),
[ts_aux_sym_token5] = REDUCE(ts_sym_if_statement, 5),
[ts_aux_sym_token6] = REDUCE(ts_sym_if_statement, 5),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[175] = {
[ts_sym__function] = SHIFT(1),
[ts_sym__if] = SHIFT(166),
[ts_sym__var] = SHIFT(13),
[ts_sym_array] = SHIFT(16),
[ts_sym_assignment] = SHIFT(170),
[ts_sym_expression] = SHIFT(170),
[ts_sym_false] = SHIFT(16),
[ts_sym_function_call] = SHIFT(18),
[ts_sym_function_expression] = SHIFT(18),
[ts_sym_identifier] = SHIFT(19),
[ts_sym_if_statement] = SHIFT(173),
[ts_sym_literal] = SHIFT(18),
[ts_sym_null] = SHIFT(16),
[ts_sym_number] = SHIFT(16),
[ts_sym_object] = SHIFT(16),
[ts_sym_statement] = SHIFT(176),
[ts_sym_statement_block] = SHIFT(173),
[ts_sym_string] = SHIFT(16),
[ts_sym_true] = SHIFT(16),
[ts_aux_sym_token10] = SHIFT(32),
[ts_aux_sym_token5] = SHIFT(177),
},
[176] = {
[ts_sym__else] = REDUCE(ts_sym_if_statement, 7),
[ts_sym__function] = REDUCE(ts_sym_if_statement, 7),
[ts_sym__if] = REDUCE(ts_sym_if_statement, 7),
[ts_sym__var] = REDUCE(ts_sym_if_statement, 7),
[ts_sym_false] = REDUCE(ts_sym_if_statement, 7),
[ts_sym_identifier] = REDUCE(ts_sym_if_statement, 7),
[ts_sym_null] = REDUCE(ts_sym_if_statement, 7),
[ts_sym_number] = REDUCE(ts_sym_if_statement, 7),
[ts_sym_string] = REDUCE(ts_sym_if_statement, 7),
[ts_sym_true] = REDUCE(ts_sym_if_statement, 7),
[ts_aux_sym_token10] = REDUCE(ts_sym_if_statement, 7),
[ts_aux_sym_token5] = REDUCE(ts_sym_if_statement, 7),
[ts_aux_sym_token6] = REDUCE(ts_sym_if_statement, 7),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[177] = {
[ts_sym__function] = SHIFT(1),
[ts_sym__if] = SHIFT(6),
[ts_sym__var] = SHIFT(13),
[ts_sym_array] = SHIFT(16),
[ts_sym_assignment] = SHIFT(26),
[ts_sym_expression] = SHIFT(26),
[ts_sym_false] = SHIFT(16),
[ts_sym_function_call] = SHIFT(18),
[ts_sym_function_expression] = SHIFT(18),
[ts_sym_identifier] = SHIFT(19),
[ts_sym_if_statement] = SHIFT(29),
[ts_sym_literal] = SHIFT(18),
[ts_sym_null] = SHIFT(16),
[ts_sym_number] = SHIFT(16),
[ts_sym_object] = SHIFT(16),
[ts_sym_statement] = SHIFT(30),
[ts_sym_statement_block] = SHIFT(29),
[ts_sym_string] = SHIFT(41),
[ts_sym_true] = SHIFT(16),
[ts_aux_sym_repeat_helper2] = SHIFT(178),
[ts_aux_sym_token10] = SHIFT(32),
[ts_aux_sym_token5] = SHIFT(40),
[ts_aux_sym_token6] = SHIFT(145),
[ts_builtin_sym_error] = SHIFT(146),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[178] = {
[ts_aux_sym_token6] = SHIFT(179),
},
[179] = {
[ts_sym__else] = REDUCE(ts_sym_statement_block, 3),
[ts_sym__function] = REDUCE(ts_sym_statement_block, 3),
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
[ts_sym__if] = REDUCE(ts_sym_statement_block, 3),
[ts_sym__var] = REDUCE(ts_sym_statement_block, 3),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
[ts_sym_false] = REDUCE(ts_sym_statement_block, 3),
[ts_sym_identifier] = REDUCE(ts_sym_statement_block, 3),
[ts_sym_null] = REDUCE(ts_sym_statement_block, 3),
[ts_sym_number] = REDUCE(ts_sym_statement_block, 3),
[ts_sym_string] = REDUCE(ts_sym_statement_block, 3),
[ts_sym_true] = REDUCE(ts_sym_statement_block, 3),
[ts_aux_sym_token10] = REDUCE(ts_sym_statement_block, 3),
[ts_aux_sym_token5] = REDUCE(ts_sym_statement_block, 3),
[ts_aux_sym_token6] = REDUCE(ts_sym_statement_block, 3),
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[180] = {
[ts_aux_sym_token4] = REDUCE(ts_sym_expression, 1),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[181] = {
[ts_aux_sym_token3] = SHIFT(182),
[ts_aux_sym_token4] = REDUCE(ts_sym_expression, 1),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[182] = {
[ts_sym__function] = SHIFT(21),
[ts_sym_array] = SHIFT(70),
[ts_sym_expression] = SHIFT(183),
[ts_sym_false] = SHIFT(70),
[ts_sym_function_call] = SHIFT(77),
[ts_sym_function_expression] = SHIFT(77),
[ts_sym_identifier] = SHIFT(78),
[ts_sym_literal] = SHIFT(77),
[ts_sym_null] = SHIFT(70),
[ts_sym_number] = SHIFT(70),
[ts_sym_object] = SHIFT(70),
[ts_sym_string] = SHIFT(70),
[ts_sym_true] = SHIFT(70),
[ts_aux_sym_token10] = SHIFT(83),
[ts_aux_sym_token4] = SHIFT(186),
[ts_aux_sym_token5] = SHIFT(98),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[183] = {
[ts_aux_sym_repeat_helper3] = SHIFT(184),
[ts_aux_sym_token4] = REDUCE(ts_aux_sym_repeat_helper3, 0),
[ts_aux_sym_token8] = SHIFT(74),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[184] = {
[ts_aux_sym_token4] = SHIFT(185),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[185] = {
[ts_aux_sym_token4] = REDUCE(ts_sym_function_call, 5),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[186] = {
[ts_aux_sym_token4] = REDUCE(ts_sym_function_call, 3),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[187] = {
[ts_sym__function] = SHIFT(33),
[ts_sym_array] = SHIFT(84),
[ts_sym_expression] = SHIFT(188),
[ts_sym_false] = SHIFT(84),
[ts_sym_function_call] = SHIFT(91),
[ts_sym_function_expression] = SHIFT(91),
[ts_sym_identifier] = SHIFT(92),
[ts_sym_literal] = SHIFT(91),
[ts_sym_null] = SHIFT(84),
[ts_sym_number] = SHIFT(84),
[ts_sym_object] = SHIFT(84),
[ts_sym_string] = SHIFT(84),
[ts_sym_true] = SHIFT(84),
[ts_aux_sym_token10] = SHIFT(108),
[ts_aux_sym_token11] = SHIFT(191),
[ts_aux_sym_token5] = SHIFT(113),
[ts_builtin_sym_error] = SHIFT(188),
},
[188] = {
[ts_aux_sym_repeat_helper6] = SHIFT(189),
[ts_aux_sym_token11] = REDUCE(ts_aux_sym_repeat_helper6, 0),
[ts_aux_sym_token8] = SHIFT(88),
},
[189] = {
[ts_aux_sym_token11] = SHIFT(190),
},
[190] = {
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
[ts_aux_sym_token4] = REDUCE(ts_sym_array, 4),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[191] = {
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
[ts_aux_sym_token4] = REDUCE(ts_sym_array, 2),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[192] = {
[ts_sym_string] = SHIFT(193),
[ts_aux_sym_token6] = SHIFT(198),
[ts_builtin_sym_error] = SHIFT(199),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[193] = {
[ts_aux_sym_token9] = SHIFT(194),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[194] = {
[ts_sym__function] = SHIFT(43),
[ts_sym_array] = SHIFT(58),
[ts_sym_expression] = SHIFT(195),
[ts_sym_false] = SHIFT(58),
[ts_sym_function_call] = SHIFT(67),
[ts_sym_function_expression] = SHIFT(67),
[ts_sym_identifier] = SHIFT(68),
[ts_sym_literal] = SHIFT(67),
[ts_sym_null] = SHIFT(58),
[ts_sym_number] = SHIFT(58),
[ts_sym_object] = SHIFT(58),
[ts_sym_string] = SHIFT(58),
[ts_sym_true] = SHIFT(58),
[ts_aux_sym_token10] = SHIFT(104),
[ts_aux_sym_token5] = SHIFT(119),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[195] = {
[ts_aux_sym_repeat_helper5] = SHIFT(196),
[ts_aux_sym_token6] = REDUCE(ts_aux_sym_repeat_helper5, 0),
[ts_aux_sym_token8] = SHIFT(62),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[196] = {
[ts_aux_sym_token6] = SHIFT(197),
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[197] = {
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
[ts_aux_sym_token4] = REDUCE(ts_sym_object, 6),
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[198] = {
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
[ts_aux_sym_token4] = REDUCE(ts_sym_object, 2),
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[199] = {
[ts_aux_sym_repeat_helper5] = SHIFT(200),
[ts_aux_sym_token6] = REDUCE(ts_aux_sym_repeat_helper5, 0),
[ts_aux_sym_token8] = SHIFT(62),
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[200] = {
[ts_aux_sym_token6] = SHIFT(201),
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[201] = {
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
[ts_aux_sym_token4] = REDUCE(ts_sym_object, 4),
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[202] = {
[ts_sym__else] = SHIFT(203),
[ts_sym__function] = REDUCE(ts_sym_if_statement, 5),
[ts_sym__if] = REDUCE(ts_sym_if_statement, 5),
[ts_sym__var] = REDUCE(ts_sym_if_statement, 5),
[ts_sym_false] = REDUCE(ts_sym_if_statement, 5),
[ts_sym_identifier] = REDUCE(ts_sym_if_statement, 5),
[ts_sym_null] = REDUCE(ts_sym_if_statement, 5),
[ts_sym_number] = REDUCE(ts_sym_if_statement, 5),
[ts_sym_string] = REDUCE(ts_sym_if_statement, 5),
[ts_sym_true] = REDUCE(ts_sym_if_statement, 5),
[ts_aux_sym_token10] = REDUCE(ts_sym_if_statement, 5),
[ts_aux_sym_token5] = REDUCE(ts_sym_if_statement, 5),
[ts_aux_sym_token6] = REDUCE(ts_sym_if_statement, 5),
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[203] = {
[ts_sym__function] = SHIFT(1),
[ts_sym__if] = SHIFT(6),
[ts_sym__var] = SHIFT(13),
[ts_sym_array] = SHIFT(16),
[ts_sym_assignment] = SHIFT(26),
[ts_sym_expression] = SHIFT(26),
[ts_sym_false] = SHIFT(16),
[ts_sym_function_call] = SHIFT(18),
[ts_sym_function_expression] = SHIFT(18),
[ts_sym_identifier] = SHIFT(19),
[ts_sym_if_statement] = SHIFT(29),
[ts_sym_literal] = SHIFT(18),
[ts_sym_null] = SHIFT(16),
[ts_sym_number] = SHIFT(16),
[ts_sym_object] = SHIFT(16),
[ts_sym_statement] = SHIFT(204),
[ts_sym_statement_block] = SHIFT(29),
[ts_sym_string] = SHIFT(16),
[ts_sym_true] = SHIFT(16),
[ts_aux_sym_token10] = SHIFT(32),
[ts_aux_sym_token5] = SHIFT(40),
},
[204] = {
[ts_sym__function] = REDUCE(ts_sym_if_statement, 7),
[ts_sym__if] = REDUCE(ts_sym_if_statement, 7),
[ts_sym__var] = REDUCE(ts_sym_if_statement, 7),
[ts_sym_false] = REDUCE(ts_sym_if_statement, 7),
[ts_sym_identifier] = REDUCE(ts_sym_if_statement, 7),
[ts_sym_null] = REDUCE(ts_sym_if_statement, 7),
[ts_sym_number] = REDUCE(ts_sym_if_statement, 7),
[ts_sym_string] = REDUCE(ts_sym_if_statement, 7),
[ts_sym_true] = REDUCE(ts_sym_if_statement, 7),
[ts_aux_sym_token10] = REDUCE(ts_sym_if_statement, 7),
[ts_aux_sym_token5] = REDUCE(ts_sym_if_statement, 7),
[ts_aux_sym_token6] = REDUCE(ts_sym_if_statement, 7),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[205] = {
[ts_aux_sym_token6] = SHIFT(206),
},
[206] = {
[ts_aux_sym_token1] = REDUCE(ts_sym_statement_block, 3),
[ts_aux_sym_token2] = REDUCE(ts_sym_statement_block, 3),
},
[207] = {
[ts_aux_sym_token3] = SHIFT(208),
},
[208] = {
[ts_sym__function] = SHIFT(8),
[ts_sym_array] = SHIFT(163),
[ts_sym_expression] = SHIFT(209),
[ts_sym_false] = SHIFT(163),
[ts_sym_function_call] = SHIFT(180),
[ts_sym_function_expression] = SHIFT(180),
[ts_sym_identifier] = SHIFT(181),
[ts_sym_literal] = SHIFT(180),
[ts_sym_null] = SHIFT(163),
[ts_sym_number] = SHIFT(163),
[ts_sym_object] = SHIFT(163),
[ts_sym_string] = SHIFT(163),
[ts_sym_true] = SHIFT(163),
[ts_aux_sym_token10] = SHIFT(187),
[ts_aux_sym_token5] = SHIFT(192),
},
[209] = {
[ts_aux_sym_token4] = SHIFT(210),
},
[210] = {
[ts_sym__function] = SHIFT(1),
[ts_sym__if] = SHIFT(211),
[ts_sym__var] = SHIFT(13),
[ts_sym_array] = SHIFT(16),
[ts_sym_assignment] = SHIFT(215),
[ts_sym_expression] = SHIFT(215),
[ts_sym_false] = SHIFT(16),
[ts_sym_function_call] = SHIFT(18),
[ts_sym_function_expression] = SHIFT(18),
[ts_sym_identifier] = SHIFT(19),
[ts_sym_if_statement] = SHIFT(218),
[ts_sym_literal] = SHIFT(18),
[ts_sym_null] = SHIFT(16),
[ts_sym_number] = SHIFT(16),
[ts_sym_object] = SHIFT(16),
[ts_sym_statement] = SHIFT(225),
[ts_sym_statement_block] = SHIFT(218),
[ts_sym_string] = SHIFT(16),
[ts_sym_true] = SHIFT(16),
[ts_aux_sym_token10] = SHIFT(32),
[ts_aux_sym_token5] = SHIFT(222),
},
[211] = {
[ts_aux_sym_token3] = SHIFT(212),
},
[212] = {
[ts_sym__function] = SHIFT(8),
[ts_sym_array] = SHIFT(163),
[ts_sym_expression] = SHIFT(213),
[ts_sym_false] = SHIFT(163),
[ts_sym_function_call] = SHIFT(180),
[ts_sym_function_expression] = SHIFT(180),
[ts_sym_identifier] = SHIFT(181),
[ts_sym_literal] = SHIFT(180),
[ts_sym_null] = SHIFT(163),
[ts_sym_number] = SHIFT(163),
[ts_sym_object] = SHIFT(163),
[ts_sym_string] = SHIFT(163),
[ts_sym_true] = SHIFT(163),
[ts_aux_sym_token10] = SHIFT(187),
[ts_aux_sym_token5] = SHIFT(192),
},
[213] = {
[ts_aux_sym_token4] = SHIFT(214),
},
[214] = {
[ts_sym__function] = SHIFT(1),
[ts_sym__if] = SHIFT(211),
[ts_sym__var] = SHIFT(13),
[ts_sym_array] = SHIFT(16),
[ts_sym_assignment] = SHIFT(215),
[ts_sym_expression] = SHIFT(215),
[ts_sym_false] = SHIFT(16),
[ts_sym_function_call] = SHIFT(18),
[ts_sym_function_expression] = SHIFT(18),
[ts_sym_identifier] = SHIFT(19),
[ts_sym_if_statement] = SHIFT(218),
[ts_sym_literal] = SHIFT(18),
[ts_sym_null] = SHIFT(16),
[ts_sym_number] = SHIFT(16),
[ts_sym_object] = SHIFT(16),
[ts_sym_statement] = SHIFT(219),
[ts_sym_statement_block] = SHIFT(218),
[ts_sym_string] = SHIFT(16),
[ts_sym_true] = SHIFT(16),
[ts_aux_sym_token10] = SHIFT(32),
[ts_aux_sym_token5] = SHIFT(222),
},
[215] = {
[ts_sym__terminator] = SHIFT(216),
[ts_aux_sym_token1] = SHIFT(217),
[ts_aux_sym_token2] = SHIFT(217),
},
[216] = {
[ts_sym__else] = REDUCE(ts_sym_statement, 2),
[ts_sym__function] = REDUCE(ts_sym_statement, 2),
[ts_sym__if] = REDUCE(ts_sym_statement, 2),
[ts_sym__var] = REDUCE(ts_sym_statement, 2),
[ts_sym_false] = REDUCE(ts_sym_statement, 2),
[ts_sym_identifier] = REDUCE(ts_sym_statement, 2),
[ts_sym_null] = REDUCE(ts_sym_statement, 2),
[ts_sym_number] = REDUCE(ts_sym_statement, 2),
[ts_sym_string] = REDUCE(ts_sym_statement, 2),
[ts_sym_true] = REDUCE(ts_sym_statement, 2),
[ts_aux_sym_token10] = REDUCE(ts_sym_statement, 2),
[ts_aux_sym_token5] = REDUCE(ts_sym_statement, 2),
[ts_builtin_sym_end] = REDUCE(ts_sym_statement, 2),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[217] = {
[ts_sym__else] = REDUCE(ts_sym__terminator, 1),
[ts_sym__function] = REDUCE(ts_sym__terminator, 1),
[ts_sym__if] = REDUCE(ts_sym__terminator, 1),
[ts_sym__var] = REDUCE(ts_sym__terminator, 1),
[ts_sym_false] = REDUCE(ts_sym__terminator, 1),
[ts_sym_identifier] = REDUCE(ts_sym__terminator, 1),
[ts_sym_null] = REDUCE(ts_sym__terminator, 1),
[ts_sym_number] = REDUCE(ts_sym__terminator, 1),
[ts_sym_string] = REDUCE(ts_sym__terminator, 1),
[ts_sym_true] = REDUCE(ts_sym__terminator, 1),
[ts_aux_sym_token10] = REDUCE(ts_sym__terminator, 1),
[ts_aux_sym_token5] = REDUCE(ts_sym__terminator, 1),
[ts_builtin_sym_end] = REDUCE(ts_sym__terminator, 1),
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[218] = {
[ts_sym__else] = REDUCE(ts_sym_statement, 1),
[ts_sym__function] = REDUCE(ts_sym_statement, 1),
[ts_sym__if] = REDUCE(ts_sym_statement, 1),
[ts_sym__var] = REDUCE(ts_sym_statement, 1),
[ts_sym_false] = REDUCE(ts_sym_statement, 1),
[ts_sym_identifier] = REDUCE(ts_sym_statement, 1),
[ts_sym_null] = REDUCE(ts_sym_statement, 1),
[ts_sym_number] = REDUCE(ts_sym_statement, 1),
[ts_sym_string] = REDUCE(ts_sym_statement, 1),
[ts_sym_true] = REDUCE(ts_sym_statement, 1),
[ts_aux_sym_token10] = REDUCE(ts_sym_statement, 1),
[ts_aux_sym_token5] = REDUCE(ts_sym_statement, 1),
[ts_builtin_sym_end] = REDUCE(ts_sym_statement, 1),
},
[219] = {
[ts_sym__else] = SHIFT(220),
[ts_sym__function] = REDUCE(ts_sym_if_statement, 5),
[ts_sym__if] = REDUCE(ts_sym_if_statement, 5),
[ts_sym__var] = REDUCE(ts_sym_if_statement, 5),
[ts_sym_false] = REDUCE(ts_sym_if_statement, 5),
[ts_sym_identifier] = REDUCE(ts_sym_if_statement, 5),
[ts_sym_null] = REDUCE(ts_sym_if_statement, 5),
[ts_sym_number] = REDUCE(ts_sym_if_statement, 5),
[ts_sym_string] = REDUCE(ts_sym_if_statement, 5),
[ts_sym_true] = REDUCE(ts_sym_if_statement, 5),
[ts_aux_sym_token10] = REDUCE(ts_sym_if_statement, 5),
[ts_aux_sym_token5] = REDUCE(ts_sym_if_statement, 5),
[ts_builtin_sym_end] = REDUCE(ts_sym_if_statement, 5),
},
[220] = {
[ts_sym__function] = SHIFT(1),
[ts_sym__if] = SHIFT(211),
[ts_sym__var] = SHIFT(13),
[ts_sym_array] = SHIFT(16),
[ts_sym_assignment] = SHIFT(215),
[ts_sym_expression] = SHIFT(215),
[ts_sym_false] = SHIFT(16),
[ts_sym_function_call] = SHIFT(18),
[ts_sym_function_expression] = SHIFT(18),
[ts_sym_identifier] = SHIFT(19),
[ts_sym_if_statement] = SHIFT(218),
[ts_sym_literal] = SHIFT(18),
[ts_sym_null] = SHIFT(16),
[ts_sym_number] = SHIFT(16),
[ts_sym_object] = SHIFT(16),
[ts_sym_statement] = SHIFT(221),
[ts_sym_statement_block] = SHIFT(218),
[ts_sym_string] = SHIFT(16),
[ts_sym_true] = SHIFT(16),
[ts_aux_sym_token10] = SHIFT(32),
[ts_aux_sym_token5] = SHIFT(222),
},
[221] = {
[ts_sym__else] = REDUCE(ts_sym_if_statement, 7),
[ts_sym__function] = REDUCE(ts_sym_if_statement, 7),
[ts_sym__if] = REDUCE(ts_sym_if_statement, 7),
[ts_sym__var] = REDUCE(ts_sym_if_statement, 7),
[ts_sym_false] = REDUCE(ts_sym_if_statement, 7),
[ts_sym_identifier] = REDUCE(ts_sym_if_statement, 7),
[ts_sym_null] = REDUCE(ts_sym_if_statement, 7),
[ts_sym_number] = REDUCE(ts_sym_if_statement, 7),
[ts_sym_string] = REDUCE(ts_sym_if_statement, 7),
[ts_sym_true] = REDUCE(ts_sym_if_statement, 7),
[ts_aux_sym_token10] = REDUCE(ts_sym_if_statement, 7),
[ts_aux_sym_token5] = REDUCE(ts_sym_if_statement, 7),
[ts_builtin_sym_end] = REDUCE(ts_sym_if_statement, 7),
},
[222] = {
[ts_sym__function] = SHIFT(1),
[ts_sym__if] = SHIFT(6),
[ts_sym__var] = SHIFT(13),
[ts_sym_array] = SHIFT(16),
[ts_sym_assignment] = SHIFT(26),
[ts_sym_expression] = SHIFT(26),
[ts_sym_false] = SHIFT(16),
[ts_sym_function_call] = SHIFT(18),
[ts_sym_function_expression] = SHIFT(18),
[ts_sym_identifier] = SHIFT(19),
[ts_sym_if_statement] = SHIFT(29),
[ts_sym_literal] = SHIFT(18),
[ts_sym_null] = SHIFT(16),
[ts_sym_number] = SHIFT(16),
[ts_sym_object] = SHIFT(16),
[ts_sym_statement] = SHIFT(30),
[ts_sym_statement_block] = SHIFT(29),
[ts_sym_string] = SHIFT(41),
[ts_sym_true] = SHIFT(16),
[ts_aux_sym_repeat_helper2] = SHIFT(223),
[ts_aux_sym_token10] = SHIFT(32),
[ts_aux_sym_token5] = SHIFT(40),
[ts_aux_sym_token6] = SHIFT(145),
[ts_builtin_sym_error] = SHIFT(146),
},
[223] = {
[ts_aux_sym_token6] = SHIFT(224),
},
[224] = {
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
[ts_sym__else] = REDUCE(ts_sym_statement_block, 3),
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[ts_sym__function] = REDUCE(ts_sym_statement_block, 3),
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
[ts_sym__if] = REDUCE(ts_sym_statement_block, 3),
[ts_sym__var] = REDUCE(ts_sym_statement_block, 3),
[ts_sym_false] = REDUCE(ts_sym_statement_block, 3),
[ts_sym_identifier] = REDUCE(ts_sym_statement_block, 3),
[ts_sym_null] = REDUCE(ts_sym_statement_block, 3),
[ts_sym_number] = REDUCE(ts_sym_statement_block, 3),
[ts_sym_string] = REDUCE(ts_sym_statement_block, 3),
[ts_sym_true] = REDUCE(ts_sym_statement_block, 3),
[ts_aux_sym_token10] = REDUCE(ts_sym_statement_block, 3),
[ts_aux_sym_token5] = REDUCE(ts_sym_statement_block, 3),
[ts_builtin_sym_end] = REDUCE(ts_sym_statement_block, 3),
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[225] = {
[ts_sym__else] = SHIFT(226),
[ts_sym__function] = REDUCE(ts_sym_if_statement, 5),
[ts_sym__if] = REDUCE(ts_sym_if_statement, 5),
[ts_sym__var] = REDUCE(ts_sym_if_statement, 5),
[ts_sym_false] = REDUCE(ts_sym_if_statement, 5),
[ts_sym_identifier] = REDUCE(ts_sym_if_statement, 5),
[ts_sym_null] = REDUCE(ts_sym_if_statement, 5),
[ts_sym_number] = REDUCE(ts_sym_if_statement, 5),
[ts_sym_string] = REDUCE(ts_sym_if_statement, 5),
[ts_sym_true] = REDUCE(ts_sym_if_statement, 5),
[ts_aux_sym_token10] = REDUCE(ts_sym_if_statement, 5),
[ts_aux_sym_token5] = REDUCE(ts_sym_if_statement, 5),
[ts_builtin_sym_end] = REDUCE(ts_sym_if_statement, 5),
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[226] = {
[ts_sym__function] = SHIFT(1),
[ts_sym__if] = SHIFT(207),
[ts_sym__var] = SHIFT(13),
[ts_sym_array] = SHIFT(16),
[ts_sym_assignment] = SHIFT(227),
[ts_sym_expression] = SHIFT(227),
[ts_sym_false] = SHIFT(16),
[ts_sym_function_call] = SHIFT(18),
[ts_sym_function_expression] = SHIFT(18),
[ts_sym_identifier] = SHIFT(19),
[ts_sym_if_statement] = SHIFT(230),
[ts_sym_literal] = SHIFT(18),
[ts_sym_null] = SHIFT(16),
[ts_sym_number] = SHIFT(16),
[ts_sym_object] = SHIFT(16),
[ts_sym_statement] = SHIFT(231),
[ts_sym_statement_block] = SHIFT(230),
[ts_sym_string] = SHIFT(16),
[ts_sym_true] = SHIFT(16),
[ts_aux_sym_token10] = SHIFT(32),
[ts_aux_sym_token5] = SHIFT(232),
},
[227] = {
[ts_sym__terminator] = SHIFT(228),
[ts_aux_sym_token1] = SHIFT(229),
[ts_aux_sym_token2] = SHIFT(229),
},
[228] = {
[ts_sym__function] = REDUCE(ts_sym_statement, 2),
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
[ts_sym__if] = REDUCE(ts_sym_statement, 2),
[ts_sym__var] = REDUCE(ts_sym_statement, 2),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
[ts_sym_false] = REDUCE(ts_sym_statement, 2),
[ts_sym_identifier] = REDUCE(ts_sym_statement, 2),
[ts_sym_null] = REDUCE(ts_sym_statement, 2),
[ts_sym_number] = REDUCE(ts_sym_statement, 2),
[ts_sym_string] = REDUCE(ts_sym_statement, 2),
[ts_sym_true] = REDUCE(ts_sym_statement, 2),
[ts_aux_sym_token10] = REDUCE(ts_sym_statement, 2),
[ts_aux_sym_token5] = REDUCE(ts_sym_statement, 2),
[ts_builtin_sym_end] = REDUCE(ts_sym_statement, 2),
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[229] = {
[ts_sym__function] = REDUCE(ts_sym__terminator, 1),
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
[ts_sym__if] = REDUCE(ts_sym__terminator, 1),
[ts_sym__var] = REDUCE(ts_sym__terminator, 1),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
[ts_sym_false] = REDUCE(ts_sym__terminator, 1),
[ts_sym_identifier] = REDUCE(ts_sym__terminator, 1),
[ts_sym_null] = REDUCE(ts_sym__terminator, 1),
[ts_sym_number] = REDUCE(ts_sym__terminator, 1),
[ts_sym_string] = REDUCE(ts_sym__terminator, 1),
[ts_sym_true] = REDUCE(ts_sym__terminator, 1),
[ts_aux_sym_token10] = REDUCE(ts_sym__terminator, 1),
[ts_aux_sym_token5] = REDUCE(ts_sym__terminator, 1),
[ts_builtin_sym_end] = REDUCE(ts_sym__terminator, 1),
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[230] = {
[ts_sym__function] = REDUCE(ts_sym_statement, 1),
Add else blocks to javascript grammar
2014-03-25 23:40:53 -07:00
[ts_sym__if] = REDUCE(ts_sym_statement, 1),
[ts_sym__var] = REDUCE(ts_sym_statement, 1),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
[ts_sym_false] = REDUCE(ts_sym_statement, 1),
[ts_sym_identifier] = REDUCE(ts_sym_statement, 1),
[ts_sym_null] = REDUCE(ts_sym_statement, 1),
[ts_sym_number] = REDUCE(ts_sym_statement, 1),
[ts_sym_string] = REDUCE(ts_sym_statement, 1),
[ts_sym_true] = REDUCE(ts_sym_statement, 1),
[ts_aux_sym_token10] = REDUCE(ts_sym_statement, 1),
[ts_aux_sym_token5] = REDUCE(ts_sym_statement, 1),
[ts_builtin_sym_end] = REDUCE(ts_sym_statement, 1),
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[231] = {
[ts_sym__function] = REDUCE(ts_sym_if_statement, 7),
[ts_sym__if] = REDUCE(ts_sym_if_statement, 7),
[ts_sym__var] = REDUCE(ts_sym_if_statement, 7),
[ts_sym_false] = REDUCE(ts_sym_if_statement, 7),
[ts_sym_identifier] = REDUCE(ts_sym_if_statement, 7),
[ts_sym_null] = REDUCE(ts_sym_if_statement, 7),
[ts_sym_number] = REDUCE(ts_sym_if_statement, 7),
[ts_sym_string] = REDUCE(ts_sym_if_statement, 7),
[ts_sym_true] = REDUCE(ts_sym_if_statement, 7),
[ts_aux_sym_token10] = REDUCE(ts_sym_if_statement, 7),
[ts_aux_sym_token5] = REDUCE(ts_sym_if_statement, 7),
[ts_builtin_sym_end] = REDUCE(ts_sym_if_statement, 7),
},
[232] = {
[ts_sym__function] = SHIFT(1),
[ts_sym__if] = SHIFT(6),
[ts_sym__var] = SHIFT(13),
[ts_sym_array] = SHIFT(16),
[ts_sym_assignment] = SHIFT(26),
[ts_sym_expression] = SHIFT(26),
[ts_sym_false] = SHIFT(16),
[ts_sym_function_call] = SHIFT(18),
[ts_sym_function_expression] = SHIFT(18),
[ts_sym_identifier] = SHIFT(19),
[ts_sym_if_statement] = SHIFT(29),
[ts_sym_literal] = SHIFT(18),
[ts_sym_null] = SHIFT(16),
[ts_sym_number] = SHIFT(16),
[ts_sym_object] = SHIFT(16),
[ts_sym_statement] = SHIFT(30),
[ts_sym_statement_block] = SHIFT(29),
[ts_sym_string] = SHIFT(41),
[ts_sym_true] = SHIFT(16),
[ts_aux_sym_repeat_helper2] = SHIFT(233),
[ts_aux_sym_token10] = SHIFT(32),
[ts_aux_sym_token5] = SHIFT(40),
[ts_aux_sym_token6] = SHIFT(145),
[ts_builtin_sym_error] = SHIFT(146),
},
[233] = {
[ts_aux_sym_token6] = SHIFT(234),
},
[234] = {
[ts_sym__function] = REDUCE(ts_sym_statement_block, 3),
[ts_sym__if] = REDUCE(ts_sym_statement_block, 3),
[ts_sym__var] = REDUCE(ts_sym_statement_block, 3),
[ts_sym_false] = REDUCE(ts_sym_statement_block, 3),
[ts_sym_identifier] = REDUCE(ts_sym_statement_block, 3),
[ts_sym_null] = REDUCE(ts_sym_statement_block, 3),
[ts_sym_number] = REDUCE(ts_sym_statement_block, 3),
[ts_sym_string] = REDUCE(ts_sym_statement_block, 3),
[ts_sym_true] = REDUCE(ts_sym_statement_block, 3),
[ts_aux_sym_token10] = REDUCE(ts_sym_statement_block, 3),
[ts_aux_sym_token5] = REDUCE(ts_sym_statement_block, 3),
[ts_builtin_sym_end] = REDUCE(ts_sym_statement_block, 3),
},
[235] = {
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
[ts_builtin_sym_end] = ACCEPT_INPUT(),
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[236] = {
[ts_sym__function] = SHIFT(1),
[ts_sym__if] = SHIFT(207),
[ts_sym__var] = SHIFT(13),
[ts_sym_array] = SHIFT(16),
[ts_sym_assignment] = SHIFT(227),
[ts_sym_expression] = SHIFT(227),
[ts_sym_false] = SHIFT(16),
[ts_sym_function_call] = SHIFT(18),
[ts_sym_function_expression] = SHIFT(18),
[ts_sym_identifier] = SHIFT(19),
[ts_sym_if_statement] = SHIFT(230),
[ts_sym_literal] = SHIFT(18),
[ts_sym_null] = SHIFT(16),
[ts_sym_number] = SHIFT(16),
[ts_sym_object] = SHIFT(16),
[ts_sym_statement] = SHIFT(236),
[ts_sym_statement_block] = SHIFT(230),
[ts_sym_string] = SHIFT(16),
[ts_sym_true] = SHIFT(16),
[ts_aux_sym_repeat_helper1] = SHIFT(237),
[ts_aux_sym_token10] = SHIFT(32),
[ts_aux_sym_token5] = SHIFT(232),
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
[ts_builtin_sym_end] = REDUCE(ts_aux_sym_repeat_helper1, 0),
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[237] = {
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
[ts_builtin_sym_end] = REDUCE(ts_aux_sym_repeat_helper1, 2),
},
Add more features to javascript grammar
2014-03-26 08:23:13 -07:00
[238] = {
Construct entire parse table statically This removes the need for the 'init_parse_table' function, which was not really thread safe
2014-03-25 19:34:17 -07:00
[ts_builtin_sym_end] = REDUCE(ts_sym_program, 1),
},
};
Start work on javascript grammar
2014-03-24 09:14:29 -07:00
EXPORT_PARSER(ts_parser_javascript);
Reference in a new issue Copy permalink