traxys/tree-sitter
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge pull request #16 from maxbrunsfeld/incremental-reuse-fixes-take-3

Browse source 
Fix two more types of incorrect node reuse during incremental parsing
This commit is contained in:
Max Brunsfeld 2015-12-17 13:54:23 -08:00
commit da115d81a4
27 changed files with 59058 additions and 61094 deletions
Download patch file Download diff file Expand all files Collapse all files

46
include/tree_sitter/parser.h
View file

@ -27,6 +27,7 @@ typedef struct {
bool visible : 1;
bool named : 1;
bool extra : 1;
bool structural : 1;
} TSSymbolMetadata;
typedef struct TSLexer {
@ -55,15 +56,11 @@ typedef struct TSLexer {
typedef enum {
TSParseActionTypeError = 1,
TSParseActionTypeShift,
TSParseActionTypeShiftExtra,
TSParseActionTypeReduce,
TSParseActionTypeReduceExtra,
TSParseActionTypeReduceFragile,
TSParseActionTypeAccept,
} TSParseActionType;
typedef struct {
TSParseActionType type;
union {
TSStateId to_state;
struct {
@ -71,6 +68,10 @@ typedef struct {
unsigned short child_count;
};
} data;
TSParseActionType type : 3;
bool extra : 1;
bool fragile : 1;
bool can_hide_split : 1;
} TSParseAction;
struct TSLanguage {
@ -136,29 +137,32 @@ struct TSLanguage {
} \
}
#define SHIFT(to_state_value) \
{ \
.type = TSParseActionTypeShift, .data = {.to_state = to_state_value } \
enum {
FRAGILE = 1,
CAN_HIDE_SPLIT = 2,
};
#define SHIFT(to_state_value, flags) \
{ \
.type = TSParseActionTypeShift, \
.can_hide_split = (flags & CAN_HIDE_SPLIT) != 0, \
.data = {.to_state = to_state_value } \
}
#define SHIFT_EXTRA() \
{ .type = TSParseActionTypeShiftExtra }
{ .type = TSParseActionTypeShift, .extra = true }
#define REDUCE_EXTRA(symbol_val) \
{ \
.type = TSParseActionTypeReduceExtra, .data = {.symbol = symbol_val } \
#define REDUCE_EXTRA(symbol_val) \
{ \
.type = TSParseActionTypeReduce, .extra = true, \
.data = {.symbol = symbol_val, .child_count = 1 } \
}
#define REDUCE(symbol_val, child_count_val) \
{ \
.type = TSParseActionTypeReduce, \
.data = {.symbol = symbol_val, .child_count = child_count_val } \
}
#define REDUCE_FRAGILE(symbol_val, child_count_val) \
{ \
.type = TSParseActionTypeReduceFragile, \
.data = {.symbol = symbol_val, .child_count = child_count_val } \
#define REDUCE(symbol_val, child_count_val, flags) \
{ \
.type = TSParseActionTypeReduce, .fragile = (flags & FRAGILE) != 0, \
.can_hide_split = (flags & CAN_HIDE_SPLIT) != 0, \
.data = {.symbol = symbol_val, .child_count = child_count_val } \
}
#define ACCEPT_INPUT() \

5
spec/compiler/helpers/stream_methods.cc
View file

@ -74,11 +74,6 @@ ostream &operator<<(ostream &stream, const ParseAction &action) {
case ParseActionTypeShift:
return stream << string("#<shift state:") << to_string(action.state_index) <<
string(" precedence:") << action.precedence_range << ">";
case ParseActionTypeShiftExtra:
return stream << string("#<shift_extra");
case ParseActionTypeReduceExtra:
return stream << "#<reduce_extra sym:" << action.symbol <<
string(" precedence:") << to_string(action.precedence_range.min) << ">";
case ParseActionTypeReduce:
return stream << ("#<reduce sym" + to_string(action.symbol.index) + " " +
to_string(action.consumed_symbol_count) + ">");

26
spec/fixtures/parsers/anonymous_tokens.c vendored
View file

@ -22,13 +22,13 @@ static const char *ts_symbol_names[] = {
};
static const TSSymbolMetadata ts_symbol_metadata[SYMBOL_COUNT] = {
[sym_program] = {.visible = true, .named = true, .extra = false},
[ts_builtin_sym_error] = {.visible = true, .named = true, .extra = true},
[ts_builtin_sym_end] = {.visible = false, .named = false, .extra = false},
[anon_sym_LF] = {.visible = true, .named = false, .extra = false},
[anon_sym_CR] = {.visible = true, .named = false, .extra = false},
[aux_sym_SLASH_BSLASHd_SLASH] = {.visible = false, .named = false, .extra = false},
[anon_sym_DQUOTEhello_DQUOTE] = {.visible = true, .named = false, .extra = false},
[sym_program] = {.visible = true, .named = true, .structural = true, .extra = false},
[ts_builtin_sym_error] = {.visible = true, .named = true, .structural = false, .extra = false},
[ts_builtin_sym_end] = {.visible = false, .named = false, .structural = true, .extra = false},
[anon_sym_LF] = {.visible = true, .named = false, .structural = true, .extra = false},
[anon_sym_CR] = {.visible = true, .named = false, .structural = true, .extra = false},
[aux_sym_SLASH_BSLASHd_SLASH] = {.visible = false, .named = false, .structural = true, .extra = false},
[anon_sym_DQUOTEhello_DQUOTE] = {.visible = true, .named = false, .structural = true, .extra = false},
};
static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
@ -148,17 +148,17 @@ static TSStateId ts_lex_states[STATE_COUNT] = {
static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
[0] = {
[sym_program] = ACTIONS(SHIFT(1)),
[anon_sym_LF] = ACTIONS(SHIFT(2)),
[anon_sym_CR] = ACTIONS(SHIFT(2)),
[aux_sym_SLASH_BSLASHd_SLASH] = ACTIONS(SHIFT(2)),
[anon_sym_DQUOTEhello_DQUOTE] = ACTIONS(SHIFT(2)),
[sym_program] = ACTIONS(SHIFT(1, 0)),
[anon_sym_LF] = ACTIONS(SHIFT(2, 0)),
[anon_sym_CR] = ACTIONS(SHIFT(2, 0)),
[aux_sym_SLASH_BSLASHd_SLASH] = ACTIONS(SHIFT(2, 0)),
[anon_sym_DQUOTEhello_DQUOTE] = ACTIONS(SHIFT(2, 0)),
},
[1] = {
[ts_builtin_sym_end] = ACTIONS(ACCEPT_INPUT()),
},
[2] = {
[ts_builtin_sym_end] = ACTIONS(REDUCE(sym_program, 1)),
[ts_builtin_sym_end] = ACTIONS(REDUCE(sym_program, 1, 0)),
},
};

514
spec/fixtures/parsers/arithmetic.c vendored
View file

@ -48,26 +48,26 @@ static const char *ts_symbol_names[] = {
};
static const TSSymbolMetadata ts_symbol_metadata[SYMBOL_COUNT] = {
[sym_program] = {.visible = true, .named = true, .extra = false},
[sym__expression] = {.visible = false, .named = false, .extra = false},
[sym_sum] = {.visible = true, .named = true, .extra = false},
[sym_difference] = {.visible = true, .named = true, .extra = false},
[sym_product] = {.visible = true, .named = true, .extra = false},
[sym_quotient] = {.visible = true, .named = true, .extra = false},
[sym_exponent] = {.visible = true, .named = true, .extra = false},
[sym_group] = {.visible = true, .named = true, .extra = false},
[ts_builtin_sym_error] = {.visible = true, .named = true, .extra = false},
[ts_builtin_sym_end] = {.visible = false, .named = false, .extra = false},
[anon_sym_PLUS] = {.visible = true, .named = false, .extra = false},
[anon_sym_DASH] = {.visible = true, .named = false, .extra = false},
[anon_sym_STAR] = {.visible = true, .named = false, .extra = false},
[anon_sym_SLASH] = {.visible = true, .named = false, .extra = false},
[anon_sym_CARET] = {.visible = true, .named = false, .extra = false},
[anon_sym_LPAREN] = {.visible = true, .named = false, .extra = false},
[anon_sym_RPAREN] = {.visible = true, .named = false, .extra = false},
[sym_number] = {.visible = true, .named = true, .extra = false},
[sym_variable] = {.visible = true, .named = true, .extra = false},
[sym_comment] = {.visible = true, .named = true, .extra = true},
[sym_program] = {.visible = true, .named = true, .structural = true, .extra = false},
[sym__expression] = {.visible = false, .named = false, .structural = true, .extra = false},
[sym_sum] = {.visible = true, .named = true, .structural = true, .extra = false},
[sym_difference] = {.visible = true, .named = true, .structural = true, .extra = false},
[sym_product] = {.visible = true, .named = true, .structural = true, .extra = false},
[sym_quotient] = {.visible = true, .named = true, .structural = true, .extra = false},
[sym_exponent] = {.visible = true, .named = true, .structural = true, .extra = false},
[sym_group] = {.visible = true, .named = true, .structural = true, .extra = false},
[ts_builtin_sym_error] = {.visible = true, .named = true, .structural = true, .extra = false},
[ts_builtin_sym_end] = {.visible = false, .named = false, .structural = true, .extra = false},
[anon_sym_PLUS] = {.visible = true, .named = false, .structural = true, .extra = false},
[anon_sym_DASH] = {.visible = true, .named = false, .structural = true, .extra = false},
[anon_sym_STAR] = {.visible = true, .named = false, .structural = true, .extra = false},
[anon_sym_SLASH] = {.visible = true, .named = false, .structural = true, .extra = false},
[anon_sym_CARET] = {.visible = true, .named = false, .structural = true, .extra = false},
[anon_sym_LPAREN] = {.visible = true, .named = false, .structural = true, .extra = false},
[anon_sym_RPAREN] = {.visible = true, .named = false, .structural = true, .extra = false},
[sym_number] = {.visible = true, .named = true, .structural = true, .extra = false},
[sym_variable] = {.visible = true, .named = true, .structural = true, .extra = false},
[sym_comment] = {.visible = true, .named = true, .structural = false, .extra = true},
};
static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
@ -306,17 +306,17 @@ static TSStateId ts_lex_states[STATE_COUNT] = {
static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
[0] = {
[sym_program] = ACTIONS(SHIFT(1)),
[sym__expression] = ACTIONS(SHIFT(2)),
[sym_sum] = ACTIONS(SHIFT(3)),
[sym_difference] = ACTIONS(SHIFT(3)),
[sym_product] = ACTIONS(SHIFT(3)),
[sym_quotient] = ACTIONS(SHIFT(3)),
[sym_exponent] = ACTIONS(SHIFT(3)),
[sym_group] = ACTIONS(SHIFT(3)),
[anon_sym_LPAREN] = ACTIONS(SHIFT(4)),
[sym_number] = ACTIONS(SHIFT(3)),
[sym_variable] = ACTIONS(SHIFT(3)),
[sym_program] = ACTIONS(SHIFT(1, 0)),
[sym__expression] = ACTIONS(SHIFT(2, 0)),
[sym_sum] = ACTIONS(SHIFT(3, 0)),
[sym_difference] = ACTIONS(SHIFT(3, 0)),
[sym_product] = ACTIONS(SHIFT(3, 0)),
[sym_quotient] = ACTIONS(SHIFT(3, 0)),
[sym_exponent] = ACTIONS(SHIFT(3, 0)),
[sym_group] = ACTIONS(SHIFT(3, 0)),
[anon_sym_LPAREN] = ACTIONS(SHIFT(4, 0)),
[sym_number] = ACTIONS(SHIFT(3, 0)),
[sym_variable] = ACTIONS(SHIFT(3, 0)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
},
[1] = {
@ -324,322 +324,322 @@ static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
},
[2] = {
[ts_builtin_sym_end] = ACTIONS(REDUCE(sym_program, 1)),
[anon_sym_PLUS] = ACTIONS(SHIFT(23)),
[anon_sym_DASH] = ACTIONS(SHIFT(24)),
[anon_sym_STAR] = ACTIONS(SHIFT(25)),
[anon_sym_SLASH] = ACTIONS(SHIFT(26)),
[anon_sym_CARET] = ACTIONS(SHIFT(27)),
[ts_builtin_sym_end] = ACTIONS(REDUCE(sym_program, 1, 0)),
[anon_sym_PLUS] = ACTIONS(SHIFT(23, 0)),
[anon_sym_DASH] = ACTIONS(SHIFT(24, 0)),
[anon_sym_STAR] = ACTIONS(SHIFT(25, 0)),
[anon_sym_SLASH] = ACTIONS(SHIFT(26, 0)),
[anon_sym_CARET] = ACTIONS(SHIFT(27, 0)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
},
[3] = {
[ts_builtin_sym_end] = ACTIONS(REDUCE(sym__expression, 1)),
[anon_sym_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
[anon_sym_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
[anon_sym_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
[anon_sym_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
[anon_sym_CARET] = ACTIONS(REDUCE(sym__expression, 1)),
[ts_builtin_sym_end] = ACTIONS(REDUCE(sym__expression, 1, 0)),
[anon_sym_PLUS] = ACTIONS(REDUCE(sym__expression, 1, 0)),
[anon_sym_DASH] = ACTIONS(REDUCE(sym__expression, 1, 0)),
[anon_sym_STAR] = ACTIONS(REDUCE(sym__expression, 1, 0)),
[anon_sym_SLASH] = ACTIONS(REDUCE(sym__expression, 1, 0)),
[anon_sym_CARET] = ACTIONS(REDUCE(sym__expression, 1, 0)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
},
[4] = {
[sym__expression] = ACTIONS(SHIFT(5)),
[sym_sum] = ACTIONS(SHIFT(6)),
[sym_difference] = ACTIONS(SHIFT(6)),
[sym_product] = ACTIONS(SHIFT(6)),
[sym_quotient] = ACTIONS(SHIFT(6)),
[sym_exponent] = ACTIONS(SHIFT(6)),
[sym_group] = ACTIONS(SHIFT(6)),
[ts_builtin_sym_error] = ACTIONS(SHIFT(7)),
[anon_sym_LPAREN] = ACTIONS(SHIFT(8)),
[sym_number] = ACTIONS(SHIFT(6)),
[sym_variable] = ACTIONS(SHIFT(6)),
[sym__expression] = ACTIONS(SHIFT(5, 0)),
[sym_sum] = ACTIONS(SHIFT(6, 0)),
[sym_difference] = ACTIONS(SHIFT(6, 0)),
[sym_product] = ACTIONS(SHIFT(6, 0)),
[sym_quotient] = ACTIONS(SHIFT(6, 0)),
[sym_exponent] = ACTIONS(SHIFT(6, 0)),
[sym_group] = ACTIONS(SHIFT(6, 0)),
[ts_builtin_sym_error] = ACTIONS(SHIFT(7, 0)),
[anon_sym_LPAREN] = ACTIONS(SHIFT(8, 0)),
[sym_number] = ACTIONS(SHIFT(6, 0)),
[sym_variable] = ACTIONS(SHIFT(6, 0)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
},
[5] = {
[anon_sym_PLUS] = ACTIONS(SHIFT(12)),
[anon_sym_DASH] = ACTIONS(SHIFT(13)),
[anon_sym_STAR] = ACTIONS(SHIFT(14)),
[anon_sym_SLASH] = ACTIONS(SHIFT(15)),
[anon_sym_CARET] = ACTIONS(SHIFT(16)),
[anon_sym_RPAREN] = ACTIONS(SHIFT(22)),
[anon_sym_PLUS] = ACTIONS(SHIFT(12, 0)),
[anon_sym_DASH] = ACTIONS(SHIFT(13, 0)),
[anon_sym_STAR] = ACTIONS(SHIFT(14, 0)),
[anon_sym_SLASH] = ACTIONS(SHIFT(15, 0)),
[anon_sym_CARET] = ACTIONS(SHIFT(16, 0)),
[anon_sym_RPAREN] = ACTIONS(SHIFT(22, 0)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
},
[6] = {
[anon_sym_PLUS] = ACTIONS(REDUCE(sym__expression, 1)),
[anon_sym_DASH] = ACTIONS(REDUCE(sym__expression, 1)),
[anon_sym_STAR] = ACTIONS(REDUCE(sym__expression, 1)),
[anon_sym_SLASH] = ACTIONS(REDUCE(sym__expression, 1)),
[anon_sym_CARET] = ACTIONS(REDUCE(sym__expression, 1)),
[anon_sym_RPAREN] = ACTIONS(REDUCE(sym__expression, 1)),
[anon_sym_PLUS] = ACTIONS(REDUCE(sym__expression, 1, 0)),
[anon_sym_DASH] = ACTIONS(REDUCE(sym__expression, 1, 0)),
[anon_sym_STAR] = ACTIONS(REDUCE(sym__expression, 1, 0)),
[anon_sym_SLASH] = ACTIONS(REDUCE(sym__expression, 1, 0)),
[anon_sym_CARET] = ACTIONS(REDUCE(sym__expression, 1, 0)),
[anon_sym_RPAREN] = ACTIONS(REDUCE(sym__expression, 1, 0)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
},
[7] = {
[anon_sym_RPAREN] = ACTIONS(SHIFT(22)),
[anon_sym_RPAREN] = ACTIONS(SHIFT(22, 0)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
},
[8] = {
[sym__expression] = ACTIONS(SHIFT(9)),
[sym_sum] = ACTIONS(SHIFT(6)),
[sym_difference] = ACTIONS(SHIFT(6)),
[sym_product] = ACTIONS(SHIFT(6)),
[sym_quotient] = ACTIONS(SHIFT(6)),
[sym_exponent] = ACTIONS(SHIFT(6)),
[sym_group] = ACTIONS(SHIFT(6)),
[ts_builtin_sym_error] = ACTIONS(SHIFT(10)),
[anon_sym_LPAREN] = ACTIONS(SHIFT(8)),
[sym_number] = ACTIONS(SHIFT(6)),
[sym_variable] = ACTIONS(SHIFT(6)),
[sym__expression] = ACTIONS(SHIFT(9, 0)),
[sym_sum] = ACTIONS(SHIFT(6, 0)),
[sym_difference] = ACTIONS(SHIFT(6, 0)),
[sym_product] = ACTIONS(SHIFT(6, 0)),
[sym_quotient] = ACTIONS(SHIFT(6, 0)),
[sym_exponent] = ACTIONS(SHIFT(6, 0)),
[sym_group] = ACTIONS(SHIFT(6, 0)),
[ts_builtin_sym_error] = ACTIONS(SHIFT(10, 0)),
[anon_sym_LPAREN] = ACTIONS(SHIFT(8, 0)),
[sym_number] = ACTIONS(SHIFT(6, 0)),
[sym_variable] = ACTIONS(SHIFT(6, 0)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
},
[9] = {
[anon_sym_PLUS] = ACTIONS(SHIFT(12)),
[anon_sym_DASH] = ACTIONS(SHIFT(13)),
[anon_sym_STAR] = ACTIONS(SHIFT(14)),
[anon_sym_SLASH] = ACTIONS(SHIFT(15)),
[anon_sym_CARET] = ACTIONS(SHIFT(16)),
[anon_sym_RPAREN] = ACTIONS(SHIFT(11)),
[anon_sym_PLUS] = ACTIONS(SHIFT(12, 0)),
[anon_sym_DASH] = ACTIONS(SHIFT(13, 0)),
[anon_sym_STAR] = ACTIONS(SHIFT(14, 0)),
[anon_sym_SLASH] = ACTIONS(SHIFT(15, 0)),
[anon_sym_CARET] = ACTIONS(SHIFT(16, 0)),
[anon_sym_RPAREN] = ACTIONS(SHIFT(11, 0)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
},
[10] = {
[anon_sym_RPAREN] = ACTIONS(SHIFT(11)),
[anon_sym_RPAREN] = ACTIONS(SHIFT(11, 0)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
},
[11] = {
[anon_sym_PLUS] = ACTIONS(REDUCE(sym_group, 3)),
[anon_sym_DASH] = ACTIONS(REDUCE(sym_group, 3)),
[anon_sym_STAR] = ACTIONS(REDUCE(sym_group, 3)),
[anon_sym_SLASH] = ACTIONS(REDUCE(sym_group, 3)),
[anon_sym_CARET] = ACTIONS(REDUCE(sym_group, 3)),
[anon_sym_RPAREN] = ACTIONS(REDUCE(sym_group, 3)),
[anon_sym_PLUS] = ACTIONS(REDUCE(sym_group, 3, 0)),
[anon_sym_DASH] = ACTIONS(REDUCE(sym_group, 3, 0)),
[anon_sym_STAR] = ACTIONS(REDUCE(sym_group, 3, 0)),
[anon_sym_SLASH] = ACTIONS(REDUCE(sym_group, 3, 0)),
[anon_sym_CARET] = ACTIONS(REDUCE(sym_group, 3, 0)),
[anon_sym_RPAREN] = ACTIONS(REDUCE(sym_group, 3, 0)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
},
[12] = {
[sym__expression] = ACTIONS(SHIFT(21)),
[sym_sum] = ACTIONS(SHIFT(6)),
[sym_difference] = ACTIONS(SHIFT(6)),
[sym_product] = ACTIONS(SHIFT(6)),
[sym_quotient] = ACTIONS(SHIFT(6)),
[sym_exponent] = ACTIONS(SHIFT(6)),
[sym_group] = ACTIONS(SHIFT(6)),
[anon_sym_LPAREN] = ACTIONS(SHIFT(8)),
[sym_number] = ACTIONS(SHIFT(6)),
[sym_variable] = ACTIONS(SHIFT(6)),
[sym__expression] = ACTIONS(SHIFT(21, 0)),
[sym_sum] = ACTIONS(SHIFT(6, 0)),
[sym_difference] = ACTIONS(SHIFT(6, 0)),
[sym_product] = ACTIONS(SHIFT(6, 0)),
[sym_quotient] = ACTIONS(SHIFT(6, 0)),
[sym_exponent] = ACTIONS(SHIFT(6, 0)),
[sym_group] = ACTIONS(SHIFT(6, 0)),
[anon_sym_LPAREN] = ACTIONS(SHIFT(8, 0)),
[sym_number] = ACTIONS(SHIFT(6, 0)),
[sym_variable] = ACTIONS(SHIFT(6, 0)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
},
[13] = {
[sym__expression] = ACTIONS(SHIFT(20)),
[sym_sum] = ACTIONS(SHIFT(6)),
[sym_difference] = ACTIONS(SHIFT(6)),
[sym_product] = ACTIONS(SHIFT(6)),
[sym_quotient] = ACTIONS(SHIFT(6)),
[sym_exponent] = ACTIONS(SHIFT(6)),
[sym_group] = ACTIONS(SHIFT(6)),
[anon_sym_LPAREN] = ACTIONS(SHIFT(8)),
[sym_number] = ACTIONS(SHIFT(6)),
[sym_variable] = ACTIONS(SHIFT(6)),
[sym__expression] = ACTIONS(SHIFT(20, 0)),
[sym_sum] = ACTIONS(SHIFT(6, 0)),
[sym_difference] = ACTIONS(SHIFT(6, 0)),
[sym_product] = ACTIONS(SHIFT(6, 0)),
[sym_quotient] = ACTIONS(SHIFT(6, 0)),
[sym_exponent] = ACTIONS(SHIFT(6, 0)),
[sym_group] = ACTIONS(SHIFT(6, 0)),
[anon_sym_LPAREN] = ACTIONS(SHIFT(8, 0)),
[sym_number] = ACTIONS(SHIFT(6, 0)),
[sym_variable] = ACTIONS(SHIFT(6, 0)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
},
[14] = {
[sym__expression] = ACTIONS(SHIFT(19)),
[sym_sum] = ACTIONS(SHIFT(6)),
[sym_difference] = ACTIONS(SHIFT(6)),
[sym_product] = ACTIONS(SHIFT(6)),
[sym_quotient] = ACTIONS(SHIFT(6)),
[sym_exponent] = ACTIONS(SHIFT(6)),
[sym_group] = ACTIONS(SHIFT(6)),
[anon_sym_LPAREN] = ACTIONS(SHIFT(8)),
[sym_number] = ACTIONS(SHIFT(6)),
[sym_variable] = ACTIONS(SHIFT(6)),
[sym__expression] = ACTIONS(SHIFT(19, 0)),
[sym_sum] = ACTIONS(SHIFT(6, 0)),
[sym_difference] = ACTIONS(SHIFT(6, 0)),
[sym_product] = ACTIONS(SHIFT(6, 0)),
[sym_quotient] = ACTIONS(SHIFT(6, 0)),
[sym_exponent] = ACTIONS(SHIFT(6, 0)),
[sym_group] = ACTIONS(SHIFT(6, 0)),
[anon_sym_LPAREN] = ACTIONS(SHIFT(8, 0)),
[sym_number] = ACTIONS(SHIFT(6, 0)),
[sym_variable] = ACTIONS(SHIFT(6, 0)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
},
[15] = {
[sym__expression] = ACTIONS(SHIFT(18)),
[sym_sum] = ACTIONS(SHIFT(6)),
[sym_difference] = ACTIONS(SHIFT(6)),
[sym_product] = ACTIONS(SHIFT(6)),
[sym_quotient] = ACTIONS(SHIFT(6)),
[sym_exponent] = ACTIONS(SHIFT(6)),
[sym_group] = ACTIONS(SHIFT(6)),
[anon_sym_LPAREN] = ACTIONS(SHIFT(8)),
[sym_number] = ACTIONS(SHIFT(6)),
[sym_variable] = ACTIONS(SHIFT(6)),
[sym__expression] = ACTIONS(SHIFT(18, 0)),
[sym_sum] = ACTIONS(SHIFT(6, 0)),
[sym_difference] = ACTIONS(SHIFT(6, 0)),
[sym_product] = ACTIONS(SHIFT(6, 0)),
[sym_quotient] = ACTIONS(SHIFT(6, 0)),
[sym_exponent] = ACTIONS(SHIFT(6, 0)),
[sym_group] = ACTIONS(SHIFT(6, 0)),
[anon_sym_LPAREN] = ACTIONS(SHIFT(8, 0)),
[sym_number] = ACTIONS(SHIFT(6, 0)),
[sym_variable] = ACTIONS(SHIFT(6, 0)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
},
[16] = {
[sym__expression] = ACTIONS(SHIFT(17)),
[sym_sum] = ACTIONS(SHIFT(6)),
[sym_difference] = ACTIONS(SHIFT(6)),
[sym_product] = ACTIONS(SHIFT(6)),
[sym_quotient] = ACTIONS(SHIFT(6)),
[sym_exponent] = ACTIONS(SHIFT(6)),
[sym_group] = ACTIONS(SHIFT(6)),
[anon_sym_LPAREN] = ACTIONS(SHIFT(8)),
[sym_number] = ACTIONS(SHIFT(6)),
[sym_variable] = ACTIONS(SHIFT(6)),
[sym__expression] = ACTIONS(SHIFT(17, 0)),
[sym_sum] = ACTIONS(SHIFT(6, 0)),
[sym_difference] = ACTIONS(SHIFT(6, 0)),
[sym_product] = ACTIONS(SHIFT(6, 0)),
[sym_quotient] = ACTIONS(SHIFT(6, 0)),
[sym_exponent] = ACTIONS(SHIFT(6, 0)),
[sym_group] = ACTIONS(SHIFT(6, 0)),
[anon_sym_LPAREN] = ACTIONS(SHIFT(8, 0)),
[sym_number] = ACTIONS(SHIFT(6, 0)),
[sym_variable] = ACTIONS(SHIFT(6, 0)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
},
[17] = {
[anon_sym_PLUS] = ACTIONS(REDUCE(sym_exponent, 3)),
[anon_sym_DASH] = ACTIONS(REDUCE(sym_exponent, 3)),
[anon_sym_STAR] = ACTIONS(REDUCE(sym_exponent, 3)),
[anon_sym_SLASH] = ACTIONS(REDUCE(sym_exponent, 3)),
[anon_sym_CARET] = ACTIONS(REDUCE(sym_exponent, 3)),
[anon_sym_RPAREN] = ACTIONS(REDUCE(sym_exponent, 3)),
[anon_sym_PLUS] = ACTIONS(REDUCE(sym_exponent, 3, 0)),
[anon_sym_DASH] = ACTIONS(REDUCE(sym_exponent, 3, 0)),
[anon_sym_STAR] = ACTIONS(REDUCE(sym_exponent, 3, 0)),
[anon_sym_SLASH] = ACTIONS(REDUCE(sym_exponent, 3, 0)),
[anon_sym_CARET] = ACTIONS(REDUCE(sym_exponent, 3, 0)),
[anon_sym_RPAREN] = ACTIONS(REDUCE(sym_exponent, 3, 0)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
},
[18] = {
[anon_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_quotient, 3)),
[anon_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_quotient, 3)),
[anon_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_quotient, 3)),
[anon_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_quotient, 3)),
[anon_sym_CARET] = ACTIONS(SHIFT(16)),
[anon_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_quotient, 3)),
[anon_sym_PLUS] = ACTIONS(REDUCE(sym_quotient, 3, FRAGILE)),
[anon_sym_DASH] = ACTIONS(REDUCE(sym_quotient, 3, FRAGILE)),
[anon_sym_STAR] = ACTIONS(REDUCE(sym_quotient, 3, FRAGILE)),
[anon_sym_SLASH] = ACTIONS(REDUCE(sym_quotient, 3, FRAGILE)),
[anon_sym_CARET] = ACTIONS(SHIFT(16, 0)),
[anon_sym_RPAREN] = ACTIONS(REDUCE(sym_quotient, 3, FRAGILE)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
},
[19] = {
[anon_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_product, 3)),
[anon_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_product, 3)),
[anon_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_product, 3)),
[anon_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_product, 3)),
[anon_sym_CARET] = ACTIONS(SHIFT(16)),
[anon_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_product, 3)),
[anon_sym_PLUS] = ACTIONS(REDUCE(sym_product, 3, FRAGILE)),
[anon_sym_DASH] = ACTIONS(REDUCE(sym_product, 3, FRAGILE)),
[anon_sym_STAR] = ACTIONS(REDUCE(sym_product, 3, FRAGILE)),
[anon_sym_SLASH] = ACTIONS(REDUCE(sym_product, 3, FRAGILE)),
[anon_sym_CARET] = ACTIONS(SHIFT(16, 0)),
[anon_sym_RPAREN] = ACTIONS(REDUCE(sym_product, 3, FRAGILE)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
},
[20] = {
[anon_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_difference, 3)),
[anon_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_difference, 3)),
[anon_sym_STAR] = ACTIONS(SHIFT(14)),
[anon_sym_SLASH] = ACTIONS(SHIFT(15)),
[anon_sym_CARET] = ACTIONS(SHIFT(16)),
[anon_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_difference, 3)),
[anon_sym_PLUS] = ACTIONS(REDUCE(sym_difference, 3, FRAGILE)),
[anon_sym_DASH] = ACTIONS(REDUCE(sym_difference, 3, FRAGILE)),
[anon_sym_STAR] = ACTIONS(SHIFT(14, 0)),
[anon_sym_SLASH] = ACTIONS(SHIFT(15, 0)),
[anon_sym_CARET] = ACTIONS(SHIFT(16, 0)),
[anon_sym_RPAREN] = ACTIONS(REDUCE(sym_difference, 3, FRAGILE)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
},
[21] = {
[anon_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_sum, 3)),
[anon_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_sum, 3)),
[anon_sym_STAR] = ACTIONS(SHIFT(14)),
[anon_sym_SLASH] = ACTIONS(SHIFT(15)),
[anon_sym_CARET] = ACTIONS(SHIFT(16)),
[anon_sym_RPAREN] = ACTIONS(REDUCE_FRAGILE(sym_sum, 3)),
[anon_sym_PLUS] = ACTIONS(REDUCE(sym_sum, 3, FRAGILE)),
[anon_sym_DASH] = ACTIONS(REDUCE(sym_sum, 3, FRAGILE)),
[anon_sym_STAR] = ACTIONS(SHIFT(14, 0)),
[anon_sym_SLASH] = ACTIONS(SHIFT(15, 0)),
[anon_sym_CARET] = ACTIONS(SHIFT(16, 0)),
[anon_sym_RPAREN] = ACTIONS(REDUCE(sym_sum, 3, FRAGILE)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
},
[22] = {
[ts_builtin_sym_end] = ACTIONS(REDUCE(sym_group, 3)),
[anon_sym_PLUS] = ACTIONS(REDUCE(sym_group, 3)),
[anon_sym_DASH] = ACTIONS(REDUCE(sym_group, 3)),
[anon_sym_STAR] = ACTIONS(REDUCE(sym_group, 3)),
[anon_sym_SLASH] = ACTIONS(REDUCE(sym_group, 3)),
[anon_sym_CARET] = ACTIONS(REDUCE(sym_group, 3)),
[ts_builtin_sym_end] = ACTIONS(REDUCE(sym_group, 3, 0)),
[anon_sym_PLUS] = ACTIONS(REDUCE(sym_group, 3, 0)),
[anon_sym_DASH] = ACTIONS(REDUCE(sym_group, 3, 0)),
[anon_sym_STAR] = ACTIONS(REDUCE(sym_group, 3, 0)),
[anon_sym_SLASH] = ACTIONS(REDUCE(sym_group, 3, 0)),
[anon_sym_CARET] = ACTIONS(REDUCE(sym_group, 3, 0)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
},
[23] = {
[sym__expression] = ACTIONS(SHIFT(32)),
[sym_sum] = ACTIONS(SHIFT(3)),
[sym_difference] = ACTIONS(SHIFT(3)),
[sym_product] = ACTIONS(SHIFT(3)),
[sym_quotient] = ACTIONS(SHIFT(3)),
[sym_exponent] = ACTIONS(SHIFT(3)),
[sym_group] = ACTIONS(SHIFT(3)),
[anon_sym_LPAREN] = ACTIONS(SHIFT(4)),
[sym_number] = ACTIONS(SHIFT(3)),
[sym_variable] = ACTIONS(SHIFT(3)),
[sym__expression] = ACTIONS(SHIFT(32, 0)),
[sym_sum] = ACTIONS(SHIFT(3, 0)),
[sym_difference] = ACTIONS(SHIFT(3, 0)),
[sym_product] = ACTIONS(SHIFT(3, 0)),
[sym_quotient] = ACTIONS(SHIFT(3, 0)),
[sym_exponent] = ACTIONS(SHIFT(3, 0)),
[sym_group] = ACTIONS(SHIFT(3, 0)),
[anon_sym_LPAREN] = ACTIONS(SHIFT(4, 0)),
[sym_number] = ACTIONS(SHIFT(3, 0)),
[sym_variable] = ACTIONS(SHIFT(3, 0)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
},
[24] = {
[sym__expression] = ACTIONS(SHIFT(31)),
[sym_sum] = ACTIONS(SHIFT(3)),
[sym_difference] = ACTIONS(SHIFT(3)),
[sym_product] = ACTIONS(SHIFT(3)),
[sym_quotient] = ACTIONS(SHIFT(3)),
[sym_exponent] = ACTIONS(SHIFT(3)),
[sym_group] = ACTIONS(SHIFT(3)),
[anon_sym_LPAREN] = ACTIONS(SHIFT(4)),
[sym_number] = ACTIONS(SHIFT(3)),
[sym_variable] = ACTIONS(SHIFT(3)),
[sym__expression] = ACTIONS(SHIFT(31, 0)),
[sym_sum] = ACTIONS(SHIFT(3, 0)),
[sym_difference] = ACTIONS(SHIFT(3, 0)),
[sym_product] = ACTIONS(SHIFT(3, 0)),
[sym_quotient] = ACTIONS(SHIFT(3, 0)),
[sym_exponent] = ACTIONS(SHIFT(3, 0)),
[sym_group] = ACTIONS(SHIFT(3, 0)),
[anon_sym_LPAREN] = ACTIONS(SHIFT(4, 0)),
[sym_number] = ACTIONS(SHIFT(3, 0)),
[sym_variable] = ACTIONS(SHIFT(3, 0)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
},
[25] = {
[sym__expression] = ACTIONS(SHIFT(30)),
[sym_sum] = ACTIONS(SHIFT(3)),
[sym_difference] = ACTIONS(SHIFT(3)),
[sym_product] = ACTIONS(SHIFT(3)),
[sym_quotient] = ACTIONS(SHIFT(3)),
[sym_exponent] = ACTIONS(SHIFT(3)),
[sym_group] = ACTIONS(SHIFT(3)),
[anon_sym_LPAREN] = ACTIONS(SHIFT(4)),
[sym_number] = ACTIONS(SHIFT(3)),
[sym_variable] = ACTIONS(SHIFT(3)),
[sym__expression] = ACTIONS(SHIFT(30, 0)),
[sym_sum] = ACTIONS(SHIFT(3, 0)),
[sym_difference] = ACTIONS(SHIFT(3, 0)),
[sym_product] = ACTIONS(SHIFT(3, 0)),
[sym_quotient] = ACTIONS(SHIFT(3, 0)),
[sym_exponent] = ACTIONS(SHIFT(3, 0)),
[sym_group] = ACTIONS(SHIFT(3, 0)),
[anon_sym_LPAREN] = ACTIONS(SHIFT(4, 0)),
[sym_number] = ACTIONS(SHIFT(3, 0)),
[sym_variable] = ACTIONS(SHIFT(3, 0)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
},
[26] = {
[sym__expression] = ACTIONS(SHIFT(29)),
[sym_sum] = ACTIONS(SHIFT(3)),
[sym_difference] = ACTIONS(SHIFT(3)),
[sym_product] = ACTIONS(SHIFT(3)),
[sym_quotient] = ACTIONS(SHIFT(3)),
[sym_exponent] = ACTIONS(SHIFT(3)),
[sym_group] = ACTIONS(SHIFT(3)),
[anon_sym_LPAREN] = ACTIONS(SHIFT(4)),
[sym_number] = ACTIONS(SHIFT(3)),
[sym_variable] = ACTIONS(SHIFT(3)),
[sym__expression] = ACTIONS(SHIFT(29, 0)),
[sym_sum] = ACTIONS(SHIFT(3, 0)),
[sym_difference] = ACTIONS(SHIFT(3, 0)),
[sym_product] = ACTIONS(SHIFT(3, 0)),
[sym_quotient] = ACTIONS(SHIFT(3, 0)),
[sym_exponent] = ACTIONS(SHIFT(3, 0)),
[sym_group] = ACTIONS(SHIFT(3, 0)),
[anon_sym_LPAREN] = ACTIONS(SHIFT(4, 0)),
[sym_number] = ACTIONS(SHIFT(3, 0)),
[sym_variable] = ACTIONS(SHIFT(3, 0)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
},
[27] = {
[sym__expression] = ACTIONS(SHIFT(28)),
[sym_sum] = ACTIONS(SHIFT(3)),
[sym_difference] = ACTIONS(SHIFT(3)),
[sym_product] = ACTIONS(SHIFT(3)),
[sym_quotient] = ACTIONS(SHIFT(3)),
[sym_exponent] = ACTIONS(SHIFT(3)),
[sym_group] = ACTIONS(SHIFT(3)),
[anon_sym_LPAREN] = ACTIONS(SHIFT(4)),
[sym_number] = ACTIONS(SHIFT(3)),
[sym_variable] = ACTIONS(SHIFT(3)),
[sym__expression] = ACTIONS(SHIFT(28, 0)),
[sym_sum] = ACTIONS(SHIFT(3, 0)),
[sym_difference] = ACTIONS(SHIFT(3, 0)),
[sym_product] = ACTIONS(SHIFT(3, 0)),
[sym_quotient] = ACTIONS(SHIFT(3, 0)),
[sym_exponent] = ACTIONS(SHIFT(3, 0)),
[sym_group] = ACTIONS(SHIFT(3, 0)),
[anon_sym_LPAREN] = ACTIONS(SHIFT(4, 0)),
[sym_number] = ACTIONS(SHIFT(3, 0)),
[sym_variable] = ACTIONS(SHIFT(3, 0)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
},
[28] = {
[ts_builtin_sym_end] = ACTIONS(REDUCE(sym_exponent, 3)),
[anon_sym_PLUS] = ACTIONS(REDUCE(sym_exponent, 3)),
[anon_sym_DASH] = ACTIONS(REDUCE(sym_exponent, 3)),
[anon_sym_STAR] = ACTIONS(REDUCE(sym_exponent, 3)),
[anon_sym_SLASH] = ACTIONS(REDUCE(sym_exponent, 3)),
[anon_sym_CARET] = ACTIONS(REDUCE(sym_exponent, 3)),
[ts_builtin_sym_end] = ACTIONS(REDUCE(sym_exponent, 3, 0)),
[anon_sym_PLUS] = ACTIONS(REDUCE(sym_exponent, 3, 0)),
[anon_sym_DASH] = ACTIONS(REDUCE(sym_exponent, 3, 0)),
[anon_sym_STAR] = ACTIONS(REDUCE(sym_exponent, 3, 0)),
[anon_sym_SLASH] = ACTIONS(REDUCE(sym_exponent, 3, 0)),
[anon_sym_CARET] = ACTIONS(REDUCE(sym_exponent, 3, 0)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
},
[29] = {
[ts_builtin_sym_end] = ACTIONS(REDUCE_FRAGILE(sym_quotient, 3)),
[anon_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_quotient, 3)),
[anon_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_quotient, 3)),
[anon_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_quotient, 3)),
[anon_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_quotient, 3)),
[anon_sym_CARET] = ACTIONS(SHIFT(27)),
[ts_builtin_sym_end] = ACTIONS(REDUCE(sym_quotient, 3, FRAGILE)),
[anon_sym_PLUS] = ACTIONS(REDUCE(sym_quotient, 3, FRAGILE)),
[anon_sym_DASH] = ACTIONS(REDUCE(sym_quotient, 3, FRAGILE)),
[anon_sym_STAR] = ACTIONS(REDUCE(sym_quotient, 3, FRAGILE)),
[anon_sym_SLASH] = ACTIONS(REDUCE(sym_quotient, 3, FRAGILE)),
[anon_sym_CARET] = ACTIONS(SHIFT(27, 0)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
},
[30] = {
[ts_builtin_sym_end] = ACTIONS(REDUCE_FRAGILE(sym_product, 3)),
[anon_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_product, 3)),
[anon_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_product, 3)),
[anon_sym_STAR] = ACTIONS(REDUCE_FRAGILE(sym_product, 3)),
[anon_sym_SLASH] = ACTIONS(REDUCE_FRAGILE(sym_product, 3)),
[anon_sym_CARET] = ACTIONS(SHIFT(27)),
[ts_builtin_sym_end] = ACTIONS(REDUCE(sym_product, 3, FRAGILE)),
[anon_sym_PLUS] = ACTIONS(REDUCE(sym_product, 3, FRAGILE)),
[anon_sym_DASH] = ACTIONS(REDUCE(sym_product, 3, FRAGILE)),
[anon_sym_STAR] = ACTIONS(REDUCE(sym_product, 3, FRAGILE)),
[anon_sym_SLASH] = ACTIONS(REDUCE(sym_product, 3, FRAGILE)),
[anon_sym_CARET] = ACTIONS(SHIFT(27, 0)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
},
[31] = {
[ts_builtin_sym_end] = ACTIONS(REDUCE_FRAGILE(sym_difference, 3)),
[anon_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_difference, 3)),
[anon_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_difference, 3)),
[anon_sym_STAR] = ACTIONS(SHIFT(25)),
[anon_sym_SLASH] = ACTIONS(SHIFT(26)),
[anon_sym_CARET] = ACTIONS(SHIFT(27)),
[ts_builtin_sym_end] = ACTIONS(REDUCE(sym_difference, 3, FRAGILE)),
[anon_sym_PLUS] = ACTIONS(REDUCE(sym_difference, 3, FRAGILE)),
[anon_sym_DASH] = ACTIONS(REDUCE(sym_difference, 3, FRAGILE)),
[anon_sym_STAR] = ACTIONS(SHIFT(25, 0)),
[anon_sym_SLASH] = ACTIONS(SHIFT(26, 0)),
[anon_sym_CARET] = ACTIONS(SHIFT(27, 0)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
},
[32] = {
[ts_builtin_sym_end] = ACTIONS(REDUCE_FRAGILE(sym_sum, 3)),
[anon_sym_PLUS] = ACTIONS(REDUCE_FRAGILE(sym_sum, 3)),
[anon_sym_DASH] = ACTIONS(REDUCE_FRAGILE(sym_sum, 3)),
[anon_sym_STAR] = ACTIONS(SHIFT(25)),
[anon_sym_SLASH] = ACTIONS(SHIFT(26)),
[anon_sym_CARET] = ACTIONS(SHIFT(27)),
[ts_builtin_sym_end] = ACTIONS(REDUCE(sym_sum, 3, FRAGILE)),
[anon_sym_PLUS] = ACTIONS(REDUCE(sym_sum, 3, FRAGILE)),
[anon_sym_DASH] = ACTIONS(REDUCE(sym_sum, 3, FRAGILE)),
[anon_sym_STAR] = ACTIONS(SHIFT(25, 0)),
[anon_sym_SLASH] = ACTIONS(SHIFT(26, 0)),
[anon_sym_CARET] = ACTIONS(SHIFT(27, 0)),
[sym_comment] = ACTIONS(SHIFT_EXTRA()),
},
};

8514
spec/fixtures/parsers/c.c vendored
View file

File diff suppressed because it is too large Load diff

6348
spec/fixtures/parsers/cpp.c vendored
View file

File diff suppressed because it is too large Load diff

7865
spec/fixtures/parsers/golang.c vendored
View file

File diff suppressed because it is too large Load diff

95991
spec/fixtures/parsers/javascript.c vendored
View file

File diff suppressed because it is too large Load diff

482
spec/fixtures/parsers/json.c vendored
View file

@ -44,24 +44,24 @@ static const char *ts_symbol_names[] = {
};
static const TSSymbolMetadata ts_symbol_metadata[SYMBOL_COUNT] = {
[sym__value] = {.visible = false, .named = false, .extra = false},
[sym_object] = {.visible = true, .named = true, .extra = false},
[sym_array] = {.visible = true, .named = true, .extra = false},
[aux_sym_object_repeat1] = {.visible = false, .named = false, .extra = false},
[aux_sym_array_repeat1] = {.visible = false, .named = false, .extra = false},
[ts_builtin_sym_error] = {.visible = true, .named = true, .extra = false},
[ts_builtin_sym_end] = {.visible = false, .named = false, .extra = false},
[anon_sym_LBRACE] = {.visible = true, .named = false, .extra = false},
[anon_sym_COLON] = {.visible = true, .named = false, .extra = false},
[anon_sym_COMMA] = {.visible = true, .named = false, .extra = false},
[anon_sym_RBRACE] = {.visible = true, .named = false, .extra = false},
[anon_sym_LBRACK] = {.visible = true, .named = false, .extra = false},
[anon_sym_RBRACK] = {.visible = true, .named = false, .extra = false},
[sym_string] = {.visible = true, .named = true, .extra = false},
[sym_number] = {.visible = true, .named = true, .extra = false},
[sym_null] = {.visible = true, .named = true, .extra = false},
[sym_true] = {.visible = true, .named = true, .extra = false},
[sym_false] = {.visible = true, .named = true, .extra = false},
[sym__value] = {.visible = false, .named = false, .structural = true, .extra = false},
[sym_object] = {.visible = true, .named = true, .structural = true, .extra = false},
[sym_array] = {.visible = true, .named = true, .structural = true, .extra = false},
[aux_sym_object_repeat1] = {.visible = false, .named = false, .structural = true, .extra = false},
[aux_sym_array_repeat1] = {.visible = false, .named = false, .structural = true, .extra = false},
[ts_builtin_sym_error] = {.visible = true, .named = true, .structural = true, .extra = false},
[ts_builtin_sym_end] = {.visible = false, .named = false, .structural = true, .extra = false},
[anon_sym_LBRACE] = {.visible = true, .named = false, .structural = true, .extra = false},
[anon_sym_COLON] = {.visible = true, .named = false, .structural = true, .extra = false},
[anon_sym_COMMA] = {.visible = true, .named = false, .structural = true, .extra = false},
[anon_sym_RBRACE] = {.visible = true, .named = false, .structural = true, .extra = false},
[anon_sym_LBRACK] = {.visible = true, .named = false, .structural = true, .extra = false},
[anon_sym_RBRACK] = {.visible = true, .named = false, .structural = true, .extra = false},
[sym_string] = {.visible = true, .named = true, .structural = true, .extra = false},
[sym_number] = {.visible = true, .named = true, .structural = true, .extra = false},
[sym_null] = {.visible = true, .named = true, .structural = true, .extra = false},
[sym_true] = {.visible = true, .named = true, .structural = true, .extra = false},
[sym_false] = {.visible = true, .named = true, .structural = true, .extra = false},
};
static TSTree *ts_lex(TSLexer *lexer, TSStateId lex_state) {
@ -451,366 +451,366 @@ static TSStateId ts_lex_states[STATE_COUNT] = {
static const TSParseAction *ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] = {
[0] = {
[sym__value] = ACTIONS(SHIFT(1)),
[sym_object] = ACTIONS(SHIFT(2)),
[sym_array] = ACTIONS(SHIFT(2)),
[anon_sym_LBRACE] = ACTIONS(SHIFT(3)),
[anon_sym_LBRACK] = ACTIONS(SHIFT(4)),
[sym_string] = ACTIONS(SHIFT(2)),
[sym_number] = ACTIONS(SHIFT(2)),
[sym_null] = ACTIONS(SHIFT(2)),
[sym_true] = ACTIONS(SHIFT(2)),
[sym_false] = ACTIONS(SHIFT(2)),
[sym__value] = ACTIONS(SHIFT(1, 0)),
[sym_object] = ACTIONS(SHIFT(2, 0)),
[sym_array] = ACTIONS(SHIFT(2, 0)),
[anon_sym_LBRACE] = ACTIONS(SHIFT(3, 0)),
[anon_sym_LBRACK] = ACTIONS(SHIFT(4, 0)),
[sym_string] = ACTIONS(SHIFT(2, 0)),
[sym_number] = ACTIONS(SHIFT(2, 0)),
[sym_null] = ACTIONS(SHIFT(2, 0)),
[sym_true] = ACTIONS(SHIFT(2, 0)),
[sym_false] = ACTIONS(SHIFT(2, 0)),
},
[1] = {
[ts_builtin_sym_end] = ACTIONS(ACCEPT_INPUT()),
},
[2] = {
[ts_builtin_sym_end] = ACTIONS(REDUCE(sym__value, 1)),
[ts_builtin_sym_end] = ACTIONS(REDUCE(sym__value, 1, 0)),
},
[3] = {
[ts_builtin_sym_error] = ACTIONS(SHIFT(58)),
[anon_sym_RBRACE] = ACTIONS(SHIFT(59)),
[sym_string] = ACTIONS(SHIFT(60)),
[ts_builtin_sym_error] = ACTIONS(SHIFT(58, 0)),
[anon_sym_RBRACE] = ACTIONS(SHIFT(59, 0)),
[sym_string] = ACTIONS(SHIFT(60, 0)),
},
[4] = {
[sym__value] = ACTIONS(SHIFT(5)),
[sym_object] = ACTIONS(SHIFT(6)),
[sym_array] = ACTIONS(SHIFT(6)),
[ts_builtin_sym_error] = ACTIONS(SHIFT(5)),
[anon_sym_LBRACE] = ACTIONS(SHIFT(7)),
[anon_sym_LBRACK] = ACTIONS(SHIFT(8)),
[anon_sym_RBRACK] = ACTIONS(SHIFT(9)),
[sym_string] = ACTIONS(SHIFT(6)),
[sym_number] = ACTIONS(SHIFT(6)),
[sym_null] = ACTIONS(SHIFT(6)),
[sym_true] = ACTIONS(SHIFT(6)),
[sym_false] = ACTIONS(SHIFT(6)),
[sym__value] = ACTIONS(SHIFT(5, 0)),
[sym_object] = ACTIONS(SHIFT(6, 0)),
[sym_array] = ACTIONS(SHIFT(6, 0)),
[ts_builtin_sym_error] = ACTIONS(SHIFT(5, 0)),
[anon_sym_LBRACE] = ACTIONS(SHIFT(7, 0)),
[anon_sym_LBRACK] = ACTIONS(SHIFT(8, 0)),
[anon_sym_RBRACK] = ACTIONS(SHIFT(9, 0)),
[sym_string] = ACTIONS(SHIFT(6, 0)),
[sym_number] = ACTIONS(SHIFT(6, 0)),
[sym_null] = ACTIONS(SHIFT(6, 0)),
[sym_true] = ACTIONS(SHIFT(6, 0)),
[sym_false] = ACTIONS(SHIFT(6, 0)),
},
[5] = {
[aux_sym_array_repeat1] = ACTIONS(SHIFT(55)),
[anon_sym_COMMA] = ACTIONS(SHIFT(13)),
[anon_sym_RBRACK] = ACTIONS(SHIFT(56)),
[aux_sym_array_repeat1] = ACTIONS(SHIFT(55, 0)),
[anon_sym_COMMA] = ACTIONS(SHIFT(13, 0)),
[anon_sym_RBRACK] = ACTIONS(SHIFT(56, 0)),
},
[6] = {
[aux_sym_array_repeat1] = ACTIONS(REDUCE(sym__value, 1)),
[anon_sym_COMMA] = ACTIONS(REDUCE(sym__value, 1)),
[anon_sym_RBRACK] = ACTIONS(REDUCE(sym__value, 1)),
[aux_sym_array_repeat1] = ACTIONS(REDUCE(sym__value, 1, 0)),
[anon_sym_COMMA] = ACTIONS(REDUCE(sym__value, 1, 0)),
[anon_sym_RBRACK] = ACTIONS(REDUCE(sym__value, 1, 0)),
},
[7] = {
[ts_builtin_sym_error] = ACTIONS(SHIFT(18)),
[anon_sym_RBRACE] = ACTIONS(SHIFT(19)),
[sym_string] = ACTIONS(SHIFT(20)),
[ts_builtin_sym_error] = ACTIONS(SHIFT(18, 0)),
[anon_sym_RBRACE] = ACTIONS(SHIFT(19, 0)),
[sym_string] = ACTIONS(SHIFT(20, 0)),
},
[8] = {
[sym__value] = ACTIONS(SHIFT(10)),
[sym_object] = ACTIONS(SHIFT(6)),
[sym_array] = ACTIONS(SHIFT(6)),
[ts_builtin_sym_error] = ACTIONS(SHIFT(10)),
[anon_sym_LBRACE] = ACTIONS(SHIFT(7)),
[anon_sym_LBRACK] = ACTIONS(SHIFT(8)),
[anon_sym_RBRACK] = ACTIONS(SHIFT(11)),
[sym_string] = ACTIONS(SHIFT(6)),
[sym_number] = ACTIONS(SHIFT(6)),
[sym_null] = ACTIONS(SHIFT(6)),
[sym_true] = ACTIONS(SHIFT(6)),
[sym_false] = ACTIONS(SHIFT(6)),
[sym__value] = ACTIONS(SHIFT(10, 0)),
[sym_object] = ACTIONS(SHIFT(6, 0)),
[sym_array] = ACTIONS(SHIFT(6, 0)),
[ts_builtin_sym_error] = ACTIONS(SHIFT(10, 0)),
[anon_sym_LBRACE] = ACTIONS(SHIFT(7, 0)),
[anon_sym_LBRACK] = ACTIONS(SHIFT(8, 0)),
[anon_sym_RBRACK] = ACTIONS(SHIFT(11, 0)),
[sym_string] = ACTIONS(SHIFT(6, 0)),
[sym_number] = ACTIONS(SHIFT(6, 0)),
[sym_null] = ACTIONS(SHIFT(6, 0)),
[sym_true] = ACTIONS(SHIFT(6, 0)),
[sym_false] = ACTIONS(SHIFT(6, 0)),
},
[9] = {
[ts_builtin_sym_end] = ACTIONS(REDUCE(sym_array, 2)),
[ts_builtin_sym_end] = ACTIONS(REDUCE(sym_array, 2, 0)),
},
[10] = {
[aux_sym_array_repeat1] = ACTIONS(SHIFT(12)),
[anon_sym_COMMA] = ACTIONS(SHIFT(13)),
[anon_sym_RBRACK] = ACTIONS(SHIFT(14)),
[aux_sym_array_repeat1] = ACTIONS(SHIFT(12, 0)),
[anon_sym_COMMA] = ACTIONS(SHIFT(13, 0)),
[anon_sym_RBRACK] = ACTIONS(SHIFT(14, 0)),
},
[11] = {
[aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_array, 2)),
[anon_sym_COMMA] = ACTIONS(REDUCE(sym_array, 2)),
[anon_sym_RBRACK] = ACTIONS(REDUCE(sym_array, 2)),
[aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_array, 2, 0)),
[anon_sym_COMMA] = ACTIONS(REDUCE(sym_array, 2, 0)),
[anon_sym_RBRACK] = ACTIONS(REDUCE(sym_array, 2, 0)),
},
[12] = {
[anon_sym_RBRACK] = ACTIONS(SHIFT(17)),
[anon_sym_RBRACK] = ACTIONS(SHIFT(17, 0)),
},
[13] = {
[sym__value] = ACTIONS(SHIFT(15)),
[sym_object] = ACTIONS(SHIFT(6)),
[sym_array] = ACTIONS(SHIFT(6)),
[ts_builtin_sym_error] = ACTIONS(SHIFT(15)),
[anon_sym_LBRACE] = ACTIONS(SHIFT(7)),
[anon_sym_LBRACK] = ACTIONS(SHIFT(8)),
[sym_string] = ACTIONS(SHIFT(6)),
[sym_number] = ACTIONS(SHIFT(6)),
[sym_null] = ACTIONS(SHIFT(6)),
[sym_true] = ACTIONS(SHIFT(6)),
[sym_false] = ACTIONS(SHIFT(6)),
[sym__value] = ACTIONS(SHIFT(15, 0)),
[sym_object] = ACTIONS(SHIFT(6, 0)),
[sym_array] = ACTIONS(SHIFT(6, 0)),
[ts_builtin_sym_error] = ACTIONS(SHIFT(15, 0)),
[anon_sym_LBRACE] = ACTIONS(SHIFT(7, 0)),
[anon_sym_LBRACK] = ACTIONS(SHIFT(8, 0)),
[sym_string] = ACTIONS(SHIFT(6, 0)),
[sym_number] = ACTIONS(SHIFT(6, 0)),
[sym_null] = ACTIONS(SHIFT(6, 0)),
[sym_true] = ACTIONS(SHIFT(6, 0)),
[sym_false] = ACTIONS(SHIFT(6, 0)),
},
[14] = {
[aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_array, 3)),
[anon_sym_COMMA] = ACTIONS(REDUCE(sym_array, 3)),
[anon_sym_RBRACK] = ACTIONS(REDUCE(sym_array, 3)),
[aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_array, 3, 0)),
[anon_sym_COMMA] = ACTIONS(REDUCE(sym_array, 3, 0)),
[anon_sym_RBRACK] = ACTIONS(REDUCE(sym_array, 3, 0)),
},
[15] = {
[aux_sym_array_repeat1] = ACTIONS(SHIFT(16)),
[anon_sym_COMMA] = ACTIONS(SHIFT(13)),
[anon_sym_RBRACK] = ACTIONS(REDUCE(aux_sym_array_repeat1, 2)),
[aux_sym_array_repeat1] = ACTIONS(SHIFT(16, 0)),
[anon_sym_COMMA] = ACTIONS(SHIFT(13, 0)),
[anon_sym_RBRACK] = ACTIONS(REDUCE(aux_sym_array_repeat1, 2, 0)),
},
[16] = {
[anon_sym_RBRACK] = ACTIONS(REDUCE(aux_sym_array_repeat1, 3)),
[anon_sym_RBRACK] = ACTIONS(REDUCE(aux_sym_array_repeat1, 3, 0)),
},
[17] = {
[aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_array, 4)),
[anon_sym_COMMA] = ACTIONS(REDUCE(sym_array, 4)),
[anon_sym_RBRACK] = ACTIONS(REDUCE(sym_array, 4)),
[aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_array, 4, 0)),
[anon_sym_COMMA] = ACTIONS(REDUCE(sym_array, 4, 0)),
[anon_sym_RBRACK] = ACTIONS(REDUCE(sym_array, 4, 0)),
},
[18] = {
[aux_sym_object_repeat1] = ACTIONS(SHIFT(52)),
[anon_sym_COMMA] = ACTIONS(SHIFT(37)),
[anon_sym_RBRACE] = ACTIONS(SHIFT(53)),
[aux_sym_object_repeat1] = ACTIONS(SHIFT(52, 0)),
[anon_sym_COMMA] = ACTIONS(SHIFT(37, 0)),
[anon_sym_RBRACE] = ACTIONS(SHIFT(53, 0)),
},
[19] = {
[aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_object, 2)),
[anon_sym_COMMA] = ACTIONS(REDUCE(sym_object, 2)),
[anon_sym_RBRACK] = ACTIONS(REDUCE(sym_object, 2)),
[aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_object, 2, 0)),
[anon_sym_COMMA] = ACTIONS(REDUCE(sym_object, 2, 0)),
[anon_sym_RBRACK] = ACTIONS(REDUCE(sym_object, 2, 0)),
},
[20] = {
[anon_sym_COLON] = ACTIONS(SHIFT(21)),
[anon_sym_COLON] = ACTIONS(SHIFT(21, 0)),
},
[21] = {
[sym__value] = ACTIONS(SHIFT(22)),
[sym_object] = ACTIONS(SHIFT(23)),
[sym_array] = ACTIONS(SHIFT(23)),
[anon_sym_LBRACE] = ACTIONS(SHIFT(24)),
[anon_sym_LBRACK] = ACTIONS(SHIFT(25)),
[sym_string] = ACTIONS(SHIFT(23)),
[sym_number] = ACTIONS(SHIFT(23)),
[sym_null] = ACTIONS(SHIFT(23)),
[sym_true] = ACTIONS(SHIFT(23)),
[sym_false] = ACTIONS(SHIFT(23)),
[sym__value] = ACTIONS(SHIFT(22, 0)),
[sym_object] = ACTIONS(SHIFT(23, 0)),
[sym_array] = ACTIONS(SHIFT(23, 0)),
[anon_sym_LBRACE] = ACTIONS(SHIFT(24, 0)),
[anon_sym_LBRACK] = ACTIONS(SHIFT(25, 0)),
[sym_string] = ACTIONS(SHIFT(23, 0)),
[sym_number] = ACTIONS(SHIFT(23, 0)),
[sym_null] = ACTIONS(SHIFT(23, 0)),
[sym_true] = ACTIONS(SHIFT(23, 0)),
[sym_false] = ACTIONS(SHIFT(23, 0)),
},
[22] = {
[aux_sym_object_repeat1] = ACTIONS(SHIFT(49)),
[anon_sym_COMMA] = ACTIONS(SHIFT(37)),
[anon_sym_RBRACE] = ACTIONS(SHIFT(50)),
[aux_sym_object_repeat1] = ACTIONS(SHIFT(49, 0)),
[anon_sym_COMMA] = ACTIONS(SHIFT(37, 0)),
[anon_sym_RBRACE] = ACTIONS(SHIFT(50, 0)),
},
[23] = {
[aux_sym_object_repeat1] = ACTIONS(REDUCE(sym__value, 1)),
[anon_sym_COMMA] = ACTIONS(REDUCE(sym__value, 1)),
[anon_sym_RBRACE] = ACTIONS(REDUCE(sym__value, 1)),
[aux_sym_object_repeat1] = ACTIONS(REDUCE(sym__value, 1, 0)),
[anon_sym_COMMA] = ACTIONS(REDUCE(sym__value, 1, 0)),
[anon_sym_RBRACE] = ACTIONS(REDUCE(sym__value, 1, 0)),
},
[24] = {
[ts_builtin_sym_error] = ACTIONS(SHIFT(31)),
[anon_sym_RBRACE] = ACTIONS(SHIFT(32)),
[sym_string] = ACTIONS(SHIFT(33)),
[ts_builtin_sym_error] = ACTIONS(SHIFT(31, 0)),
[anon_sym_RBRACE] = ACTIONS(SHIFT(32, 0)),
[sym_string] = ACTIONS(SHIFT(33, 0)),
},
[25] = {
[sym__value] = ACTIONS(SHIFT(26)),
[sym_object] = ACTIONS(SHIFT(6)),
[sym_array] = ACTIONS(SHIFT(6)),
[ts_builtin_sym_error] = ACTIONS(SHIFT(26)),
[anon_sym_LBRACE] = ACTIONS(SHIFT(7)),
[anon_sym_LBRACK] = ACTIONS(SHIFT(8)),
[anon_sym_RBRACK] = ACTIONS(SHIFT(27)),
[sym_string] = ACTIONS(SHIFT(6)),
[sym_number] = ACTIONS(SHIFT(6)),
[sym_null] = ACTIONS(SHIFT(6)),
[sym_true] = ACTIONS(SHIFT(6)),
[sym_false] = ACTIONS(SHIFT(6)),
[sym__value] = ACTIONS(SHIFT(26, 0)),
[sym_object] = ACTIONS(SHIFT(6, 0)),
[sym_array] = ACTIONS(SHIFT(6, 0)),
[ts_builtin_sym_error] = ACTIONS(SHIFT(26, 0)),
[anon_sym_LBRACE] = ACTIONS(SHIFT(7, 0)),
[anon_sym_LBRACK] = ACTIONS(SHIFT(8, 0)),
[anon_sym_RBRACK] = ACTIONS(SHIFT(27, 0)),
[sym_string] = ACTIONS(SHIFT(6, 0)),
[sym_number] = ACTIONS(SHIFT(6, 0)),
[sym_null] = ACTIONS(SHIFT(6, 0)),
[sym_true] = ACTIONS(SHIFT(6, 0)),
[sym_false] = ACTIONS(SHIFT(6, 0)),
},
[26] = {
[aux_sym_array_repeat1] = ACTIONS(SHIFT(28)),
[anon_sym_COMMA] = ACTIONS(SHIFT(13)),
[anon_sym_RBRACK] = ACTIONS(SHIFT(29)),
[aux_sym_array_repeat1] = ACTIONS(SHIFT(28, 0)),
[anon_sym_COMMA] = ACTIONS(SHIFT(13, 0)),
[anon_sym_RBRACK] = ACTIONS(SHIFT(29, 0)),
},
[27] = {
[aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_array, 2)),
[anon_sym_COMMA] = ACTIONS(REDUCE(sym_array, 2)),
[anon_sym_RBRACE] = ACTIONS(REDUCE(sym_array, 2)),
[aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_array, 2, 0)),
[anon_sym_COMMA] = ACTIONS(REDUCE(sym_array, 2, 0)),
[anon_sym_RBRACE] = ACTIONS(REDUCE(sym_array, 2, 0)),
},
[28] = {
[anon_sym_RBRACK] = ACTIONS(SHIFT(30)),
[anon_sym_RBRACK] = ACTIONS(SHIFT(30, 0)),
},
[29] = {
[aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_array, 3)),
[anon_sym_COMMA] = ACTIONS(REDUCE(sym_array, 3)),
[anon_sym_RBRACE] = ACTIONS(REDUCE(sym_array, 3)),
[aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_array, 3, 0)),
[anon_sym_COMMA] = ACTIONS(REDUCE(sym_array, 3, 0)),
[anon_sym_RBRACE] = ACTIONS(REDUCE(sym_array, 3, 0)),
},
[30] = {
[aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_array, 4)),
[anon_sym_COMMA] = ACTIONS(REDUCE(sym_array, 4)),
[anon_sym_RBRACE] = ACTIONS(REDUCE(sym_array, 4)),
[aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_array, 4, 0)),
[anon_sym_COMMA] = ACTIONS(REDUCE(sym_array, 4, 0)),
[anon_sym_RBRACE] = ACTIONS(REDUCE(sym_array, 4, 0)),
},
[31] = {
[aux_sym_object_repeat1] = ACTIONS(SHIFT(46)),
[anon_sym_COMMA] = ACTIONS(SHIFT(37)),
[anon_sym_RBRACE] = ACTIONS(SHIFT(47)),
[aux_sym_object_repeat1] = ACTIONS(SHIFT(46, 0)),
[anon_sym_COMMA] = ACTIONS(SHIFT(37, 0)),
[anon_sym_RBRACE] = ACTIONS(SHIFT(47, 0)),
},
[32] = {
[aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_object, 2)),
[anon_sym_COMMA] = ACTIONS(REDUCE(sym_object, 2)),
[anon_sym_RBRACE] = ACTIONS(REDUCE(sym_object, 2)),
[aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_object, 2, 0)),
[anon_sym_COMMA] = ACTIONS(REDUCE(sym_object, 2, 0)),
[anon_sym_RBRACE] = ACTIONS(REDUCE(sym_object, 2, 0)),
},
[33] = {
[anon_sym_COLON] = ACTIONS(SHIFT(34)),
[anon_sym_COLON] = ACTIONS(SHIFT(34, 0)),
},
[34] = {
[sym__value] = ACTIONS(SHIFT(35)),
[sym_object] = ACTIONS(SHIFT(23)),
[sym_array] = ACTIONS(SHIFT(23)),
[anon_sym_LBRACE] = ACTIONS(SHIFT(24)),
[anon_sym_LBRACK] = ACTIONS(SHIFT(25)),
[sym_string] = ACTIONS(SHIFT(23)),
[sym_number] = ACTIONS(SHIFT(23)),
[sym_null] = ACTIONS(SHIFT(23)),
[sym_true] = ACTIONS(SHIFT(23)),
[sym_false] = ACTIONS(SHIFT(23)),
[sym__value] = ACTIONS(SHIFT(35, 0)),
[sym_object] = ACTIONS(SHIFT(23, 0)),
[sym_array] = ACTIONS(SHIFT(23, 0)),
[anon_sym_LBRACE] = ACTIONS(SHIFT(24, 0)),
[anon_sym_LBRACK] = ACTIONS(SHIFT(25, 0)),
[sym_string] = ACTIONS(SHIFT(23, 0)),
[sym_number] = ACTIONS(SHIFT(23, 0)),
[sym_null] = ACTIONS(SHIFT(23, 0)),
[sym_true] = ACTIONS(SHIFT(23, 0)),
[sym_false] = ACTIONS(SHIFT(23, 0)),
},
[35] = {
[aux_sym_object_repeat1] = ACTIONS(SHIFT(36)),
[anon_sym_COMMA] = ACTIONS(SHIFT(37)),
[anon_sym_RBRACE] = ACTIONS(SHIFT(38)),
[aux_sym_object_repeat1] = ACTIONS(SHIFT(36, 0)),
[anon_sym_COMMA] = ACTIONS(SHIFT(37, 0)),
[anon_sym_RBRACE] = ACTIONS(SHIFT(38, 0)),
},
[36] = {
[anon_sym_RBRACE] = ACTIONS(SHIFT(45)),
[anon_sym_RBRACE] = ACTIONS(SHIFT(45, 0)),
},
[37] = {
[ts_builtin_sym_error] = ACTIONS(SHIFT(39)),
[sym_string] = ACTIONS(SHIFT(40)),
[ts_builtin_sym_error] = ACTIONS(SHIFT(39, 0)),
[sym_string] = ACTIONS(SHIFT(40, 0)),
},
[38] = {
[aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_object, 5)),
[anon_sym_COMMA] = ACTIONS(REDUCE(sym_object, 5)),
[anon_sym_RBRACE] = ACTIONS(REDUCE(sym_object, 5)),
[aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_object, 5, 0)),
[anon_sym_COMMA] = ACTIONS(REDUCE(sym_object, 5, 0)),
[anon_sym_RBRACE] = ACTIONS(REDUCE(sym_object, 5, 0)),
},
[39] = {
[aux_sym_object_repeat1] = ACTIONS(SHIFT(44)),
[anon_sym_COMMA] = ACTIONS(SHIFT(37)),
[anon_sym_RBRACE] = ACTIONS(REDUCE(aux_sym_object_repeat1, 2)),
[aux_sym_object_repeat1] = ACTIONS(SHIFT(44, 0)),
[anon_sym_COMMA] = ACTIONS(SHIFT(37, 0)),
[anon_sym_RBRACE] = ACTIONS(REDUCE(aux_sym_object_repeat1, 2, 0)),
},
[40] = {
[anon_sym_COLON] = ACTIONS(SHIFT(41)),
[anon_sym_COLON] = ACTIONS(SHIFT(41, 0)),
},
[41] = {
[sym__value] = ACTIONS(SHIFT(42)),
[sym_object] = ACTIONS(SHIFT(23)),
[sym_array] = ACTIONS(SHIFT(23)),
[anon_sym_LBRACE] = ACTIONS(SHIFT(24)),
[anon_sym_LBRACK] = ACTIONS(SHIFT(25)),
[sym_string] = ACTIONS(SHIFT(23)),
[sym_number] = ACTIONS(SHIFT(23)),
[sym_null] = ACTIONS(SHIFT(23)),
[sym_true] = ACTIONS(SHIFT(23)),
[sym_false] = ACTIONS(SHIFT(23)),
[sym__value] = ACTIONS(SHIFT(42, 0)),
[sym_object] = ACTIONS(SHIFT(23, 0)),
[sym_array] = ACTIONS(SHIFT(23, 0)),
[anon_sym_LBRACE] = ACTIONS(SHIFT(24, 0)),
[anon_sym_LBRACK] = ACTIONS(SHIFT(25, 0)),
[sym_string] = ACTIONS(SHIFT(23, 0)),
[sym_number] = ACTIONS(SHIFT(23, 0)),
[sym_null] = ACTIONS(SHIFT(23, 0)),
[sym_true] = ACTIONS(SHIFT(23, 0)),
[sym_false] = ACTIONS(SHIFT(23, 0)),
},
[42] = {
[aux_sym_object_repeat1] = ACTIONS(SHIFT(43)),
[anon_sym_COMMA] = ACTIONS(SHIFT(37)),
[anon_sym_RBRACE] = ACTIONS(REDUCE(aux_sym_object_repeat1, 4)),
[aux_sym_object_repeat1] = ACTIONS(SHIFT(43, 0)),
[anon_sym_COMMA] = ACTIONS(SHIFT(37, 0)),
[anon_sym_RBRACE] = ACTIONS(REDUCE(aux_sym_object_repeat1, 4, 0)),
},
[43] = {
[anon_sym_RBRACE] = ACTIONS(REDUCE(aux_sym_object_repeat1, 5)),
[anon_sym_RBRACE] = ACTIONS(REDUCE(aux_sym_object_repeat1, 5, 0)),
},
[44] = {
[anon_sym_RBRACE] = ACTIONS(REDUCE(aux_sym_object_repeat1, 3)),
[anon_sym_RBRACE] = ACTIONS(REDUCE(aux_sym_object_repeat1, 3, 0)),
},
[45] = {
[aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_object, 6)),
[anon_sym_COMMA] = ACTIONS(REDUCE(sym_object, 6)),
[anon_sym_RBRACE] = ACTIONS(REDUCE(sym_object, 6)),
[aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_object, 6, 0)),
[anon_sym_COMMA] = ACTIONS(REDUCE(sym_object, 6, 0)),
[anon_sym_RBRACE] = ACTIONS(REDUCE(sym_object, 6, 0)),
},
[46] = {
[anon_sym_RBRACE] = ACTIONS(SHIFT(48)),
[anon_sym_RBRACE] = ACTIONS(SHIFT(48, 0)),
},
[47] = {
[aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_object, 3)),
[anon_sym_COMMA] = ACTIONS(REDUCE(sym_object, 3)),
[anon_sym_RBRACE] = ACTIONS(REDUCE(sym_object, 3)),
[aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_object, 3, 0)),
[anon_sym_COMMA] = ACTIONS(REDUCE(sym_object, 3, 0)),
[anon_sym_RBRACE] = ACTIONS(REDUCE(sym_object, 3, 0)),
},
[48] = {
[aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_object, 4)),
[anon_sym_COMMA] = ACTIONS(REDUCE(sym_object, 4)),
[anon_sym_RBRACE] = ACTIONS(REDUCE(sym_object, 4)),
[aux_sym_object_repeat1] = ACTIONS(REDUCE(sym_object, 4, 0)),
[anon_sym_COMMA] = ACTIONS(REDUCE(sym_object, 4, 0)),
[anon_sym_RBRACE] = ACTIONS(REDUCE(sym_object, 4, 0)),
},
[49] = {
[anon_sym_RBRACE] = ACTIONS(SHIFT(51)),
[anon_sym_RBRACE] = ACTIONS(SHIFT(51, 0)),
},
[50] = {
[aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_object, 5)),
[anon_sym_COMMA] = ACTIONS(REDUCE(sym_object, 5)),
[anon_sym_RBRACK] = ACTIONS(REDUCE(sym_object, 5)),
[aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_object, 5, 0)),
[anon_sym_COMMA] = ACTIONS(REDUCE(sym_object, 5, 0)),
[anon_sym_RBRACK] = ACTIONS(REDUCE(sym_object, 5, 0)),
},
[51] = {
[aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_object, 6)),
[anon_sym_COMMA] = ACTIONS(REDUCE(sym_object, 6)),
[anon_sym_RBRACK] = ACTIONS(REDUCE(sym_object, 6)),
[aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_object, 6, 0)),
[anon_sym_COMMA] = ACTIONS(REDUCE(sym_object, 6, 0)),
[anon_sym_RBRACK] = ACTIONS(REDUCE(sym_object, 6, 0)),
},
[52] = {
[anon_sym_RBRACE] = ACTIONS(SHIFT(54)),
[anon_sym_RBRACE] = ACTIONS(SHIFT(54, 0)),
},
[53] = {
[aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_object, 3)),
[anon_sym_COMMA] = ACTIONS(REDUCE(sym_object, 3)),
[anon_sym_RBRACK] = ACTIONS(REDUCE(sym_object, 3)),
[aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_object, 3, 0)),
[anon_sym_COMMA] = ACTIONS(REDUCE(sym_object, 3, 0)),
[anon_sym_RBRACK] = ACTIONS(REDUCE(sym_object, 3, 0)),
},
[54] = {
[aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_object, 4)),
[anon_sym_COMMA] = ACTIONS(REDUCE(sym_object, 4)),
[anon_sym_RBRACK] = ACTIONS(REDUCE(sym_object, 4)),
[aux_sym_array_repeat1] = ACTIONS(REDUCE(sym_object, 4, 0)),
[anon_sym_COMMA] = ACTIONS(REDUCE(sym_object, 4, 0)),
[anon_sym_RBRACK] = ACTIONS(REDUCE(sym_object, 4, 0)),
},
[55] = {
[anon_sym_RBRACK] = ACTIONS(SHIFT(57)),
[anon_sym_RBRACK] = ACTIONS(SHIFT(57, 0)),
},
[56] = {
[ts_builtin_sym_end] = ACTIONS(REDUCE(sym_array, 3)),
[ts_builtin_sym_end] = ACTIONS(REDUCE(sym_array, 3, 0)),
},
[57] = {
[ts_builtin_sym_end] = ACTIONS(REDUCE(sym_array, 4)),
[ts_builtin_sym_end] = ACTIONS(REDUCE(sym_array, 4, 0)),
},
[58] = {
[aux_sym_object_repeat1] = ACTIONS(SHIFT(66)),
[anon_sym_COMMA] = ACTIONS(SHIFT(37)),
[anon_sym_RBRACE] = ACTIONS(SHIFT(67)),
[aux_sym_object_repeat1] = ACTIONS(SHIFT(66, 0)),
[anon_sym_COMMA] = ACTIONS(SHIFT(37, 0)),
[anon_sym_RBRACE] = ACTIONS(SHIFT(67, 0)),
},
[59] = {
[ts_builtin_sym_end] = ACTIONS(REDUCE(sym_object, 2)),
[ts_builtin_sym_end] = ACTIONS(REDUCE(sym_object, 2, 0)),
},
[60] = {
[anon_sym_COLON] = ACTIONS(SHIFT(61)),
[anon_sym_COLON] = ACTIONS(SHIFT(61, 0)),
},
[61] = {
[sym__value] = ACTIONS(SHIFT(62)),
[sym_object] = ACTIONS(SHIFT(23)),
[sym_array] = ACTIONS(SHIFT(23)),
[anon_sym_LBRACE] = ACTIONS(SHIFT(24)),
[anon_sym_LBRACK] = ACTIONS(SHIFT(25)),
[sym_string] = ACTIONS(SHIFT(23)),
[sym_number] = ACTIONS(SHIFT(23)),
[sym_null] = ACTIONS(SHIFT(23)),
[sym_true] = ACTIONS(SHIFT(23)),
[sym_false] = ACTIONS(SHIFT(23)),
[sym__value] = ACTIONS(SHIFT(62, 0)),
[sym_object] = ACTIONS(SHIFT(23, 0)),
[sym_array] = ACTIONS(SHIFT(23, 0)),
[anon_sym_LBRACE] = ACTIONS(SHIFT(24, 0)),
[anon_sym_LBRACK] = ACTIONS(SHIFT(25, 0)),
[sym_string] = ACTIONS(SHIFT(23, 0)),
[sym_number] = ACTIONS(SHIFT(23, 0)),
[sym_null] = ACTIONS(SHIFT(23, 0)),
[sym_true] = ACTIONS(SHIFT(23, 0)),
[sym_false] = ACTIONS(SHIFT(23, 0)),
},
[62] = {
[aux_sym_object_repeat1] = ACTIONS(SHIFT(63)),
[anon_sym_COMMA] = ACTIONS(SHIFT(37)),
[anon_sym_RBRACE] = ACTIONS(SHIFT(64)),
[aux_sym_object_repeat1] = ACTIONS(SHIFT(63, 0)),
[anon_sym_COMMA] = ACTIONS(SHIFT(37, 0)),
[anon_sym_RBRACE] = ACTIONS(SHIFT(64, 0)),
},
[63] = {
[anon_sym_RBRACE] = ACTIONS(SHIFT(65)),
[anon_sym_RBRACE] = ACTIONS(SHIFT(65, 0)),
},
[64] = {
[ts_builtin_sym_end] = ACTIONS(REDUCE(sym_object, 5)),
[ts_builtin_sym_end] = ACTIONS(REDUCE(sym_object, 5, 0)),
},
[65] = {
[ts_builtin_sym_end] = ACTIONS(REDUCE(sym_object, 6)),
[ts_builtin_sym_end] = ACTIONS(REDUCE(sym_object, 6, 0)),
},
[66] = {
[anon_sym_RBRACE] = ACTIONS(SHIFT(68)),
[anon_sym_RBRACE] = ACTIONS(SHIFT(68, 0)),
},
[67] = {
[ts_builtin_sym_end] = ACTIONS(REDUCE(sym_object, 3)),
[ts_builtin_sym_end] = ACTIONS(REDUCE(sym_object, 3, 0)),
},
[68] = {
[ts_builtin_sym_end] = ACTIONS(REDUCE(sym_object, 4)),
[ts_builtin_sym_end] = ACTIONS(REDUCE(sym_object, 4, 0)),
},
};

2
spec/runtime/document_spec.cc
View file

@ -135,7 +135,7 @@ describe("Document", [&]() {
AssertThat(debugger->messages, Contains("new_parse"));
AssertThat(debugger->messages, Contains("lookahead char:'['"));
AssertThat(debugger->messages, Contains("reduce sym:array, child_count:4"));
AssertThat(debugger->messages, Contains("reduce sym:array, child_count:4, fragile:false"));
AssertThat(debugger->messages, Contains("accept"));
});

8
spec/runtime/stack_spec.cc
View file

@ -40,15 +40,15 @@ describe("Stack", [&]() {
TSTree *trees[tree_count];
TreeSelectionSpy tree_selection_spy{0, NULL, {NULL, NULL}};
TSLength tree_len = {2, 3, 0, 3};
TSSymbolMetadata metadata = {true, true, true};
TSSymbolMetadata metadata = {true, true, true, true};
before_each([&]() {
before_each([&]() {
stack = ts_stack_new();
ts_stack_set_tree_selection_callback(stack, {
ts_stack_set_tree_selection_callback(stack,
&tree_selection_spy,
tree_selection_spy_callback
});
);
for (size_t i = 0; i < tree_count; i++)
trees[i] = ts_tree_make_leaf(i, ts_length_zero(), tree_len, {});

4
spec/runtime/tree_spec.cc
View file

@ -27,8 +27,8 @@ static const char *names[] = {
describe("Tree", []() {
TSTree *tree1, *tree2, *parent1;
TSSymbolMetadata visible = {true, true, false};
TSSymbolMetadata invisible = {false, false, false};
TSSymbolMetadata visible = {true, true, false, true};
TSSymbolMetadata invisible = {false, false, false, true};
before_each([&]() {
tree1 = ts_tree_make_leaf(cat, {2, 1, 0, 1}, {5, 4, 0, 4}, visible);

0
src/compiler/associativity.h
View file

6
src/compiler/build_tables/build_lex_table.cc
View file

@ -159,13 +159,9 @@ class LexTableBuilder {
void mark_fragile_tokens() {
for (LexState &state : lex_table.states)
if (state.default_action.type == LexActionTypeAccept)
if (has_fragile_token(state.default_action.symbol))
if (conflict_manager.fragile_tokens.count(state.default_action.symbol))
state.default_action.type = LexActionTypeAcceptFragile;
}
bool has_fragile_token(const Symbol &symbol) {
return conflict_manager.fragile_tokens.find(symbol) != conflict_manager.fragile_tokens.end();
}
};
LexTable build_lex_table(ParseTable *table, const LexicalGrammar &grammar) {

44
src/compiler/build_tables/build_parse_table.cc
View file

@ -79,7 +79,7 @@ class ParseTableBuilder {
add_reduce_extra_actions(state);
}
mark_fragile_reductions();
mark_fragile_actions();
remove_duplicate_states();
parse_table.symbols.insert({ rules::ERROR(), {} });
@ -134,9 +134,9 @@ class ParseTableBuilder {
}
void add_shift_extra_actions(ParseStateId state_id) {
ParseAction action = ParseAction::ShiftExtra();
for (const Symbol &ubiquitous_symbol : grammar.ubiquitous_tokens)
add_action(state_id, ubiquitous_symbol, ParseAction::ShiftExtra(),
null_item_set);
add_action(state_id, ubiquitous_symbol, action, null_item_set);
}
void add_reduce_extra_actions(ParseStateId state_id) {
@ -148,7 +148,7 @@ class ParseTableBuilder {
continue;
for (const ParseAction &action : actions_for_symbol->second)
if (action.type == ParseActionTypeShift) {
if (action.type == ParseActionTypeShift && !action.extra) {
size_t dest_state_id = action.state_index;
ParseAction reduce_extra = ParseAction::ReduceExtra(ubiquitous_symbol);
for (const auto &pair : state.actions)
@ -157,14 +157,36 @@ class ParseTableBuilder {
}
}
void mark_fragile_reductions() {
void mark_fragile_actions() {
for (ParseState &state : parse_table.states) {
set<Symbol> symbols_with_multiple_actions;
for (auto &entry : state.actions) {
if (entry.second.size() > 1)
symbols_with_multiple_actions.insert(entry.first);
for (ParseAction &action : entry.second) {
if (action.type == ParseActionTypeReduce) {
if (action.type == ParseActionTypeReduce && !action.extra) {
if (has_fragile_production(action.production))
action.type = ParseActionTypeReduceFragile;
action.fragile = true;
action.production = NULL;
action.precedence_range = PrecedenceRange();
action.associativity = rules::AssociativityNone;
}
}
}
if (!symbols_with_multiple_actions.empty()) {
for (auto &entry : state.actions) {
if (!entry.first.is_token) {
set<Symbol> first_set = get_first_set(entry.first);
for (const Symbol &symbol : symbols_with_multiple_actions) {
if (first_set.count(symbol)) {
entry.second[0].can_hide_split = true;
break;
}
}
}
}
}
@ -175,6 +197,7 @@ class ParseTableBuilder {
bool done = false;
while (!done) {
done = true;
map<ParseStateId, ParseStateId> replacements;
for (size_t i = 0, size = parse_table.states.size(); i < size; i++) {
for (size_t j = 0; j < i; j++) {
@ -210,9 +233,8 @@ class ParseTableBuilder {
}
}
for (auto replacement = replacements.rbegin(); replacement != replacements.rend(); ++replacement) {
parse_table.states.erase(parse_table.states.begin() + replacement->first);
}
for (auto i = replacements.rbegin(); i != replacements.rend(); ++i)
parse_table.states.erase(parse_table.states.begin() + i->first);
}
}
@ -282,7 +304,7 @@ class ParseTableBuilder {
if (item.step_index > 0) {
set<Symbol> first_set = get_first_set(next_symbol);
if (first_set.find(lookahead) != first_set.end()) {
if (first_set.count(lookahead)) {
involved_symbols.insert(item.lhs());
core_shift_items.insert(item);
}

2
src/compiler/build_tables/lex_item_transitions.cc
View file

@ -75,7 +75,7 @@ class LexItemTransitions : public rules::RuleFn<void> {
map<rules::MetadataKey, int> activate_precedence(
map<rules::MetadataKey, int> metadata) {
if (metadata.find(rules::PRECEDENCE) != metadata.end())
if (metadata.count(rules::PRECEDENCE))
metadata.insert({ rules::IS_ACTIVE, 1 });
return metadata;
}

10
src/compiler/build_tables/parse_conflict_manager.cc
View file

@ -22,12 +22,12 @@ pair<bool, ConflictType> ParseConflictManager::resolve(
switch (old_action.type) {
case ParseActionTypeError:
case ParseActionTypeShiftExtra:
case ParseActionTypeReduceExtra:
return { true, ConflictTypeNone };
case ParseActionTypeShift:
if (new_action.type == ParseActionTypeReduce) {
if (new_action.extra)
return { false, ConflictTypeNone };
int min_precedence = old_action.precedence_range.min;
int max_precedence = old_action.precedence_range.max;
int new_precedence = new_action.precedence_range.max;
@ -54,6 +54,12 @@ pair<bool, ConflictType> ParseConflictManager::resolve(
}
case ParseActionTypeReduce:
if (new_action.extra)
return { false, ConflictTypeNone };
if (old_action.extra)
return { true, ConflictTypeNone };
if (new_action.extra)
return { false, ConflictTypeNone };
if (new_action.type == ParseActionTypeReduce) {
int old_precedence = old_action.precedence_range.min;
int new_precedence = new_action.precedence_range.min;

5
src/compiler/build_tables/parse_item.cc
View file

@ -21,8 +21,7 @@ ParseItem::ParseItem(const Symbol &lhs, const Production &production,
bool ParseItem::operator==(const ParseItem &other) const {
return ((variable_index == other.variable_index) &&
(step_index == other.step_index) &&
(production == other.production));
(step_index == other.step_index) && (production == other.production));
}
bool ParseItem::operator<(const ParseItem &other) const {
@ -75,7 +74,7 @@ rules::Associativity ParseItem::associativity() const {
size_t ParseItem::Hash::operator()(const ParseItem &item) const {
size_t result = hash<int>()(item.variable_index);
result ^= hash<unsigned int>()(item.step_index);
result ^= hash<void *>()((void *)item.production);
result ^= hash<const void *>()(static_cast<const void *>(item.production));
return result;
}

48
src/compiler/generate_code/c_code.cc
View file

@ -166,9 +166,16 @@ class CCodeGenerator {
add(", ");
if (entry.second.structural)
add(".extra = false");
add(".structural = true");
else
add(".structural = false");
add(", ");
if (syntax_grammar.ubiquitous_tokens.count(symbol))
add(".extra = true");
else
add(".extra = false");
add("},");
}
@ -322,21 +329,23 @@ class CCodeGenerator {
add("ACCEPT_INPUT()");
break;
case ParseActionTypeShift:
add("SHIFT(" + to_string(action.state_index) + ")");
break;
case ParseActionTypeShiftExtra:
add("SHIFT_EXTRA()");
break;
case ParseActionTypeReduceFragile:
add("REDUCE_FRAGILE(" + symbol_id(action.symbol) + ", " +
to_string(action.consumed_symbol_count) + ")");
if (action.extra) {
add("SHIFT_EXTRA()");
} else {
add("SHIFT(" + to_string(action.state_index) + ", ");
add_action_flags(action);
add(")");
}
break;
case ParseActionTypeReduce:
add("REDUCE(" + symbol_id(action.symbol) + ", " +
to_string(action.consumed_symbol_count) + ")");
break;
case ParseActionTypeReduceExtra:
add("REDUCE_EXTRA(" + symbol_id(action.symbol) + ")");
if (action.extra) {
add("REDUCE_EXTRA(" + symbol_id(action.symbol) + ")");
} else {
add("REDUCE(" + symbol_id(action.symbol) + ", " +
to_string(action.consumed_symbol_count) + ", ");
add_action_flags(action);
add(")");
}
break;
default: {}
}
@ -344,6 +353,17 @@ class CCodeGenerator {
}
}
void add_action_flags(const ParseAction &action) {
if (action.fragile && action.can_hide_split)
add("FRAGILE|CAN_HIDE_SPLIT");
else if (action.fragile)
add("FRAGILE");
else if (action.can_hide_split)
add("CAN_HIDE_SPLIT");
else
add("0");
}
// Helper functions
string lex_state_index(size_t i) {

49
src/compiler/parse_table.cc
View file

@ -17,6 +17,9 @@ ParseAction::ParseAction(ParseActionType type, ParseStateId state_index,
rules::Associativity associativity,
const Production *production)
: type(type),
extra(false),
fragile(false),
can_hide_split(false),
symbol(symbol),
state_index(state_index),
consumed_symbol_count(consumed_symbol_count),
@ -26,6 +29,9 @@ ParseAction::ParseAction(ParseActionType type, ParseStateId state_index,
ParseAction::ParseAction()
: type(ParseActionTypeError),
extra(false),
fragile(false),
can_hide_split(false),
symbol(Symbol(-1)),
state_index(-1),
consumed_symbol_count(0),
@ -49,14 +55,17 @@ ParseAction ParseAction::Shift(ParseStateId state_index,
ParseAction ParseAction::ShiftExtra() {
ParseAction action;
action.type = ParseActionTypeShiftExtra;
action.type = ParseActionTypeShift;
action.extra = true;
return action;
}
ParseAction ParseAction::ReduceExtra(Symbol symbol) {
ParseAction action;
action.type = ParseActionTypeReduceExtra;
action.type = ParseActionTypeReduce;
action.extra = true;
action.symbol = symbol;
action.consumed_symbol_count = 1;
return action;
}
@ -69,13 +78,11 @@ ParseAction ParseAction::Reduce(Symbol symbol, size_t consumed_symbol_count,
}
bool ParseAction::operator==(const ParseAction &other) const {
return (
type == other.type &&
symbol == other.symbol &&
state_index == other.state_index &&
production == other.production &&
consumed_symbol_count == other.consumed_symbol_count
);
return (type == other.type && extra == other.extra &&
fragile == other.fragile && can_hide_split == other.can_hide_split &&
symbol == other.symbol && state_index == other.state_index &&
production == other.production &&
consumed_symbol_count == other.consumed_symbol_count);
}
bool ParseAction::operator<(const ParseAction &other) const {
@ -83,6 +90,18 @@ bool ParseAction::operator<(const ParseAction &other) const {
return true;
if (other.type < type)
return false;
if (extra && !other.extra)
return true;
if (other.extra && !extra)
return false;
if (fragile && !other.fragile)
return true;
if (other.fragile && !fragile)
return false;
if (can_hide_split && !other.can_hide_split)
return true;
if (other.can_hide_split && !can_hide_split)
return false;
if (symbol < other.symbol)
return true;
if (other.symbol < symbol)
@ -121,16 +140,20 @@ ParseStateId ParseTable::add_state() {
ParseAction &ParseTable::set_action(ParseStateId id, Symbol symbol,
ParseAction action) {
bool structural = action.type != ParseActionTypeShiftExtra;
symbols[symbol].structural += structural;
if (action.extra)
symbols[symbol];
else
symbols[symbol].structural = true;
states[id].actions[symbol] = vector<ParseAction>({ action });
return *states[id].actions[symbol].begin();
}
ParseAction &ParseTable::add_action(ParseStateId id, Symbol symbol,
ParseAction action) {
bool structural = action.type != ParseActionTypeShiftExtra;
symbols[symbol].structural += structural;
if (action.extra)
symbols[symbol];
else
symbols[symbol].structural = true;
states[id].actions[symbol].push_back(action);
return *states[id].actions[symbol].rbegin();
}

9
src/compiler/parse_table.h
View file

@ -17,10 +17,6 @@ typedef uint64_t ParseStateId;
typedef enum {
ParseActionTypeError,
ParseActionTypeReduceExtra,
ParseActionTypeReduceFragile,
ParseActionTypeShiftExtra,
ParseActionTypeShift,
ParseActionTypeReduce,
ParseActionTypeAccept,
@ -45,6 +41,9 @@ class ParseAction {
bool operator<(const ParseAction &) const;
ParseActionType type;
bool extra;
bool fragile;
bool can_hide_split;
rules::Symbol symbol;
ParseStateId state_index;
size_t consumed_symbol_count;
@ -64,6 +63,8 @@ struct hash<tree_sitter::ParseAction> {
hash<tree_sitter::rules::Symbol>()(action.symbol) ^
hash<size_t>()(action.state_index) ^
hash<size_t>()(action.consumed_symbol_count) ^
hash<bool>()(action.extra) ^ hash<bool>()(action.fragile) ^
hash<bool>()(action.can_hide_split) ^
hash<int>()(action.associativity) ^
hash<int>()(action.precedence_range.min) ^
hash<int>()(action.precedence_range.max) ^

3
src/compiler/prepare_grammar/flatten_grammar.cc
View file

@ -81,7 +81,8 @@ SyntaxGrammar flatten_grammar(const InitialSyntaxGrammar &grammar) {
vector<Production> productions;
for (const rule_ptr &rule_component : extract_choices(variable.rule)) {
Production production = FlattenRule().flatten(rule_component);
if (std::find(productions.begin(), productions.end(), production) == productions.end())
if (std::find(productions.begin(), productions.end(), production) ==
productions.end())
productions.push_back(production);
}
result.variables.push_back(

4
src/compiler/syntax_grammar.cc
View file

@ -21,9 +21,7 @@ SyntaxVariable::SyntaxVariable(const string &name, VariableType type,
ProductionStep::ProductionStep(const rules::Symbol &symbol, int precedence,
rules::Associativity associativity)
: symbol(symbol),
precedence(precedence),
associativity(associativity) {}
: symbol(symbol), precedence(precedence), associativity(associativity) {}
bool ProductionStep::operator==(const ProductionStep &other) const {
return symbol == other.symbol && precedence == other.precedence &&

130
src/runtime/parser.c
View file

@ -23,6 +23,8 @@
#define SYM_NAME(sym) self->language->symbol_names[sym]
#define BOOL_STRING(value) (value ? "true" : "false")
typedef struct {
TSTree *reusable_subtree;
size_t reusable_subtree_pos;
@ -46,7 +48,8 @@ static void ts_parser__breakdown_top_of_stack(TSParser *self, int head) {
StackPopResult *first_result = vector_get(&pop_results, 0);
TSTree **removed_trees = first_result->trees;
TSTree *parent = removed_trees[0];
LOG("breakdown_pop sym:%s, size:%lu", SYM_NAME(parent->symbol), ts_tree_total_size(parent).chars);
LOG("breakdown_pop sym:%s, size:%lu", SYM_NAME(parent->symbol),
ts_tree_total_size(parent).chars);
for (size_t i = 0; i < pop_results.size; i++) {
StackPopResult *pop_result = vector_get(&pop_results, i);
@ -58,23 +61,23 @@ static void ts_parser__breakdown_top_of_stack(TSParser *self, int head) {
for (size_t j = 0; j < parent->child_count; j++) {
last_child = parent->children[j];
if (!last_child->options.extra) {
TSParseAction action = ts_language_last_action(self->language, state, last_child->symbol);
TSParseAction action =
ts_language_last_action(self->language, state, last_child->symbol);
assert(action.type == TSParseActionTypeShift);
state = action.data.to_state;
}
LOG("breakdown_push sym:%s, size:%lu", SYM_NAME(last_child->symbol), ts_tree_total_size(last_child).chars);
merged = ts_stack_push(self->stack, pop_result->head_index, state, last_child);
LOG("breakdown_push sym:%s, size:%lu", SYM_NAME(last_child->symbol),
ts_tree_total_size(last_child).chars);
merged =
ts_stack_push(self->stack, pop_result->head_index, state, last_child);
}
for (size_t j = 1, count = pop_result->tree_count; j < count; j++) {
merged = ts_stack_push(self->stack, pop_result->head_index, state, pop_result->trees[j]);
}
for (size_t j = 1, count = pop_result->tree_count; j < count; j++)
merged = ts_stack_push(self->stack, pop_result->head_index, state,
pop_result->trees[j]);
if (i == 0)
assert(!merged);
else
assert(merged);
assert((i == 0) ^ merged);
}
free(removed_trees);
@ -115,12 +118,13 @@ static void ts_parser__pop_reusable_subtree(LookaheadState *state) {
}
static bool ts_parser__can_reuse(TSParser *self, int head, TSTree *subtree) {
if (!subtree || subtree->symbol == ts_builtin_sym_error || ts_tree_is_fragile(subtree))
if (!subtree || subtree->symbol == ts_builtin_sym_error ||
ts_tree_is_fragile(subtree))
return false;
TSStateId state = ts_stack_top_state(self->stack, head);
const TSParseAction *action =
ts_language_actions(self->language, state, subtree->symbol);
return action->type != TSParseActionTypeError;
return action->type != TSParseActionTypeError && !action->can_hide_split;
}
/*
@ -155,7 +159,8 @@ static TSTree *ts_parser__get_next_lookahead(TSParser *self, int head) {
LOG("breakdown_extra sym:%s", SYM_NAME(state->reusable_subtree->symbol));
can_reuse = false;
} else if (!ts_parser__can_reuse(self, head, state->reusable_subtree)) {
LOG("breakdown_non_reusable sym:%s", SYM_NAME(state->reusable_subtree->symbol));
LOG("breakdown_non_reusable sym:%s",
SYM_NAME(state->reusable_subtree->symbol));
can_reuse = false;
}
@ -196,10 +201,12 @@ static TSTree *ts_parser__select_tree(void *data, TSTree *left, TSTree *right) {
TSParser *self = data;
int comparison = ts_tree_compare(left, right);
if (comparison <= 0) {
LOG("select tree:%s, over_tree:%s", SYM_NAME(left->symbol), SYM_NAME(right->symbol));
LOG("select tree:%s, over_tree:%s", SYM_NAME(left->symbol),
SYM_NAME(right->symbol));
return left;
} else {
LOG("select tree:%s, over_tree:%s", SYM_NAME(right->symbol), SYM_NAME(left->symbol));
LOG("select tree:%s, over_tree:%s", SYM_NAME(right->symbol),
SYM_NAME(left->symbol));
return right;
}
}
@ -208,8 +215,10 @@ static TSTree *ts_parser__select_tree(void *data, TSTree *left, TSTree *right) {
* Parse Actions
*/
static bool ts_parser__shift(TSParser *self, int head,
TSStateId parse_state, TSTree *lookahead) {
static bool ts_parser__shift(TSParser *self, int head, TSStateId parse_state,
TSTree *lookahead) {
if (self->language->symbol_metadata[lookahead->symbol].extra)
ts_tree_set_fragile(lookahead);
if (ts_stack_push(self->stack, head, parse_state, lookahead)) {
LOG("merge head:%d", head);
vector_erase(&self->lookahead_states, head);
@ -222,14 +231,15 @@ static bool ts_parser__shift(TSParser *self, int head,
static bool ts_parser__shift_extra(TSParser *self, int head, TSStateId state,
TSTree *lookahead) {
TSSymbolMetadata metadata = self->language->symbol_metadata[lookahead->symbol];
if (!metadata.extra && ts_stack_head_count(self->stack) > 1)
if (metadata.structural && ts_stack_head_count(self->stack) > 1)
lookahead = ts_tree_make_copy(lookahead);
ts_tree_set_extra(lookahead);
return ts_parser__shift(self, head, state, lookahead);
}
static bool ts_parser__reduce(TSParser *self, int head, TSSymbol symbol,
int child_count, bool extra, bool count_extra) {
int child_count, bool extra, bool fragile,
bool count_extra) {
vector_clear(&self->reduce_parents);
const TSSymbolMetadata *all_metadata = self->language->symbol_metadata;
TSSymbolMetadata metadata = all_metadata[symbol];
@ -357,25 +367,21 @@ static bool ts_parser__reduce(TSParser *self, int head, TSSymbol symbol,
}
}
return removed_heads < revealed_heads;
}
static bool ts_parser__reduce_fragile(TSParser *self, int head, TSSymbol symbol,
size_t child_count) {
bool result = ts_parser__reduce(self, head, symbol, child_count, false, false);
if (result)
if (fragile) {
for (size_t i = 0; i < self->reduce_parents.size; i++) {
TSTree **parent = vector_get(&self->reduce_parents, i);
ts_tree_set_fragile_left(*parent);
ts_tree_set_fragile_right(*parent);
}
return result;
}
return removed_heads < revealed_heads;
}
static void ts_parser__reduce_error(TSParser *self, int head,
size_t child_count, TSTree *lookahead) {
bool result = ts_parser__reduce(self, head, ts_builtin_sym_error, child_count,
false, true);
false, false, true);
if (result) {
TSTree **parent = vector_back(&self->reduce_parents);
StackEntry *stack_entry = ts_stack_head(self->stack, head);
@ -453,9 +459,8 @@ static void ts_parser__start(TSParser *self, TSInput input,
ts_lexer_set_input(&self->lexer, input);
ts_stack_clear(self->stack);
ts_stack_set_tree_selection_callback(self->stack, (TreeSelectionCallback){
self, ts_parser__select_tree,
});
ts_stack_set_tree_selection_callback(self->stack, self,
ts_parser__select_tree);
LookaheadState lookahead_state = {
.reusable_subtree = previous_tree,
@ -502,7 +507,7 @@ static TSTree *ts_parser__finish(TSParser *self, int finished_stack_head) {
* lookahead symbol is consumed.
*/
static bool ts_parser__consume_lookahead(TSParser *self, int head,
TSTree *lookahead) {
TSTree *lookahead) {
for (;;) {
TSStateId state = ts_stack_top_state(self->stack, head);
const TSParseAction *next_action =
@ -527,7 +532,8 @@ static bool ts_parser__consume_lookahead(TSParser *self, int head,
LOG("split_action from_head:%d, new_head:%d", head, current_head);
}
LookaheadState *lookahead_state = vector_get(&self->lookahead_states, current_head);
LookaheadState *lookahead_state =
vector_get(&self->lookahead_states, current_head);
// TODO: Remove this by making a separate symbol for errors returned from
// the lexer.
@ -554,40 +560,33 @@ static bool ts_parser__consume_lookahead(TSParser *self, int head,
}
case TSParseActionTypeShift:
LOG("shift state:%u", action.data.to_state);
lookahead_state->is_verifying = (lookahead->child_count > 0);
return ts_parser__shift(self, current_head, action.data.to_state,
lookahead);
case TSParseActionTypeShiftExtra:
LOG("shift_extra");
return ts_parser__shift_extra(self, current_head, state, lookahead);
if (action.extra) {
LOG("shift_extra");
return ts_parser__shift_extra(self, current_head, state, lookahead);
} else {
LOG("shift state:%u", action.data.to_state);
lookahead_state->is_verifying = (lookahead->child_count > 0);
return ts_parser__shift(self, current_head, action.data.to_state,
lookahead);
}
case TSParseActionTypeReduce:
LOG("reduce sym:%s, child_count:%u", SYM_NAME(action.data.symbol),
action.data.child_count);
lookahead_state->is_verifying = false;
if (!ts_parser__reduce(self, current_head, action.data.symbol,
action.data.child_count, false, false))
if (!next_action)
return false;
break;
case TSParseActionTypeReduceExtra:
LOG("reduce_extra sym:%s", SYM_NAME(action.data.symbol));
lookahead_state->is_verifying = false;
ts_parser__reduce(self, current_head, action.data.symbol, 1,
true, false);
break;
case TSParseActionTypeReduceFragile:
LOG("reduce_fragile sym:%s, count:%u", SYM_NAME(action.data.symbol),
action.data.child_count);
lookahead_state->is_verifying = false;
if (!ts_parser__reduce_fragile(self, current_head, action.data.symbol,
action.data.child_count))
if (!next_action)
return false;
if (action.extra) {
LOG("reduce_extra sym:%s", SYM_NAME(action.data.symbol));
ts_parser__reduce(self, current_head, action.data.symbol, 1, true,
false, false);
} else {
LOG("reduce sym:%s, child_count:%u, fragile:%s",
SYM_NAME(action.data.symbol), action.data.child_count,
BOOL_STRING(action.fragile));
if (!ts_parser__reduce(self, current_head, action.data.symbol,
action.data.child_count, false,
action.fragile, false))
if (!next_action)
return false;
}
break;
case TSParseActionTypeAccept:
@ -642,7 +641,8 @@ TSTree *ts_parser_parse(TSParser *self, TSInput input, TSTree *previous_tree) {
ts_stack_head_count(self->stack),
ts_stack_top_state(self->stack, head), position.chars);
if (!ts_parser__can_reuse(self, head, lookahead) || position.chars != last_position.chars) {
if (!ts_parser__can_reuse(self, head, lookahead) ||
position.chars != last_position.chars) {
TSTree *reused_lookahead = ts_parser__get_next_lookahead(self, head);
if (ts_parser__can_reuse(self, head, reused_lookahead)) {
lookahead = reused_lookahead;

24
src/runtime/stack.c
View file

@ -22,7 +22,8 @@ struct Stack {
int head_capacity;
Vector pop_results;
Vector pop_paths;
TreeSelectionCallback tree_selection_callback;
void *tree_selection_payload;
TreeSelectionFunction tree_selection_function;
};
typedef struct {
@ -46,7 +47,8 @@ Stack *ts_stack_new() {
.heads = calloc(INITIAL_HEAD_CAPACITY, sizeof(StackNode *)),
.head_count = 1,
.head_capacity = INITIAL_HEAD_CAPACITY,
.tree_selection_callback = {NULL, ts_stack__default_tree_selection},
.tree_selection_payload = NULL,
.tree_selection_function = ts_stack__default_tree_selection,
.pop_results = vector_new(sizeof(StackPopResult), 4),
.pop_paths = vector_new(sizeof(PopPath), 4),
};
@ -152,8 +154,8 @@ static void ts_stack__add_node_successor(Stack *self, StackNode *node,
if (successor->entry.state == new_successor->entry.state) {
if (successor->entry.tree != new_successor->entry.tree) {
successor->entry.tree = self->tree_selection_callback.callback(
self->tree_selection_callback.data, successor->entry.tree,
successor->entry.tree = self->tree_selection_function(
self->tree_selection_payload, successor->entry.tree,
new_successor->entry.tree);
ts_tree_retain(successor->entry.tree);
}
@ -207,8 +209,8 @@ static bool ts_stack__merge_head(Stack *self, int head_index, TSStateId state,
if (head->entry.state == state &&
ts_length_eq(head->entry.position, position)) {
if (head->entry.tree != tree) {
head->entry.tree = self->tree_selection_callback.callback(
self->tree_selection_callback.data, head->entry.tree, tree);
head->entry.tree = self->tree_selection_function(
self->tree_selection_payload, head->entry.tree, tree);
ts_tree_retain(head->entry.tree);
}
ts_stack__add_node_successor(self, head, self->heads[head_index]);
@ -237,8 +239,8 @@ bool ts_stack_push(Stack *self, int head_index, TSStateId state, TSTree *tree) {
void ts_stack_add_alternative(Stack *self, int head_index, TSTree *tree) {
assert(head_index < self->head_count);
StackEntry *entry = &self->heads[head_index]->entry;
entry->tree = self->tree_selection_callback.callback(
self->tree_selection_callback.data, entry->tree, tree);
entry->tree = self->tree_selection_function(self->tree_selection_payload,
entry->tree, tree);
}
int ts_stack_split(Stack *self, int head_index) {
@ -356,6 +358,8 @@ void ts_stack_clear(Stack *self) {
self->heads[0] = NULL;
}
void ts_stack_set_tree_selection_callback(Stack *self, TreeSelectionCallback callback) {
self->tree_selection_callback = callback;
void ts_stack_set_tree_selection_callback(Stack *self, void *payload,
TreeSelectionFunction function) {
self->tree_selection_payload = payload;
self->tree_selection_function = function;
}

8
src/runtime/stack.h
View file

@ -22,10 +22,7 @@ typedef struct {
int head_index;
} StackPopResult;
typedef struct {
void *data;
TSTree *(*callback)(void *, TSTree *, TSTree *);
} TreeSelectionCallback;
typedef TSTree *(*TreeSelectionFunction)(void *, TSTree *, TSTree *);
/*
* Create a parse stack.
@ -117,7 +114,8 @@ void ts_stack_remove_head(Stack *, int head);
*/
void ts_stack_clear(Stack *);
void ts_stack_set_tree_selection_callback(Stack *, TreeSelectionCallback);
void ts_stack_set_tree_selection_callback(Stack *, void *,
TreeSelectionFunction);
#ifdef __cplusplus
}

5
src/runtime/tree.h
View file

@ -90,6 +90,11 @@ static inline void ts_tree_set_fragile_right(TSTree *tree) {
tree->options.fragile_right = true;
}
static inline void ts_tree_set_fragile(TSTree *tree) {
ts_tree_set_fragile_left(tree);
ts_tree_set_fragile_right(tree);
}
static inline bool ts_tree_is_fragile_left(const TSTree *tree) {
return tree->options.fragile_left;
}