From 7e0d46002c17bfd7dca755278fb767fa8c5a1f98 Mon Sep 17 00:00:00 2001 From: Max Brunsfeld Date: Sat, 28 Jun 2014 18:51:06 -0700 Subject: [PATCH] Rename type ts_state_id -> TSStateId --- include/tree_sitter/parser.h | 4 ++-- include/tree_sitter/parser/lr_parser.h | 10 +++++----- include/tree_sitter/parser/stack.h | 8 ++++---- spec/runtime/helpers/dummy_parser.c | 2 +- spec/runtime/helpers/dummy_parser.h | 2 +- spec/runtime/lr_parser_spec.cc | 4 ++-- spec/runtime/stack_spec.cc | 6 +++--- src/runtime/lr_parser.c | 22 +++++++++++----------- src/runtime/stack.c | 6 +++--- 9 files changed, 32 insertions(+), 32 deletions(-) diff --git a/include/tree_sitter/parser.h b/include/tree_sitter/parser.h index ff3f7b32..27a3eb1d 100644 --- a/include/tree_sitter/parser.h +++ b/include/tree_sitter/parser.h @@ -20,13 +20,13 @@ static const char *ts_symbol_names[] static const int hidden_symbol_flags[SYMBOL_COUNT] #define LEX_STATES \ -static ts_state_id ts_lex_states[STATE_COUNT] +static TSStateId ts_lex_states[STATE_COUNT] #define PARSE_TABLE \ static const ts_parse_action ts_parse_actions[STATE_COUNT][SYMBOL_COUNT] #define LEX_FN() \ -static TSTree * ts_lex(ts_lexer *lexer, ts_state_id lex_state) +static TSTree * ts_lex(ts_lexer *lexer, TSStateId lex_state) #ifdef TS_DEBUG_LEX #include diff --git a/include/tree_sitter/parser/lr_parser.h b/include/tree_sitter/parser/lr_parser.h index aac316c3..2ffa3424 100644 --- a/include/tree_sitter/parser/lr_parser.h +++ b/include/tree_sitter/parser/lr_parser.h @@ -19,7 +19,7 @@ typedef enum { typedef struct { ts_parse_action_type type; union { - ts_state_id to_state; + TSStateId to_state; struct { ts_symbol symbol; unsigned short child_count; @@ -48,15 +48,15 @@ typedef struct { size_t symbol_count; const int *hidden_symbol_flags; const ts_parse_action *parse_table; - const ts_state_id *lex_states; - TSTree * (* lex_fn)(ts_lexer *, ts_state_id); + const TSStateId *lex_states; + TSTree * (* lex_fn)(ts_lexer *, TSStateId); } config; } ts_lr_parser; ts_lr_parser * ts_lr_parser_make(size_t symbol_count, const ts_parse_action *parse_table, - const ts_state_id *lex_states, - TSTree * (* lex_fn)(ts_lexer *, ts_state_id), + const TSStateId *lex_states, + TSTree * (* lex_fn)(ts_lexer *, TSStateId), const int *hidden_symbol_flags); void ts_lr_parser_free(void *data); void ts_lr_parser_initialize(ts_lr_parser *parser, ts_input input, ts_input_edit *edit); diff --git a/include/tree_sitter/parser/stack.h b/include/tree_sitter/parser/stack.h index cbc13452..e21011ac 100644 --- a/include/tree_sitter/parser/stack.h +++ b/include/tree_sitter/parser/stack.h @@ -7,13 +7,13 @@ extern "C" { #include "tree_sitter/runtime.h" -typedef unsigned short ts_state_id; +typedef unsigned short TSStateId; typedef struct { size_t size; struct { TSTree *node; - ts_state_id state; + TSStateId state; int is_extra; } *entries; } ts_stack; @@ -22,8 +22,8 @@ ts_stack ts_stack_make(); void ts_stack_delete(ts_stack *); TSTree * ts_stack_reduce(ts_stack *stack, ts_symbol symbol, size_t immediate_child_count, const int *hidden_symbol_flags, int gather_extras); void ts_stack_shrink(ts_stack *stack, size_t new_size); -void ts_stack_push(ts_stack *stack, ts_state_id state, TSTree *node); -ts_state_id ts_stack_top_state(const ts_stack *stack); +void ts_stack_push(ts_stack *stack, TSStateId state, TSTree *node); +TSStateId ts_stack_top_state(const ts_stack *stack); TSTree * ts_stack_top_node(const ts_stack *stack); size_t ts_stack_right_position(const ts_stack *stack); diff --git a/spec/runtime/helpers/dummy_parser.c b/spec/runtime/helpers/dummy_parser.c index ab6ad770..732df726 100644 --- a/spec/runtime/helpers/dummy_parser.c +++ b/spec/runtime/helpers/dummy_parser.c @@ -17,7 +17,7 @@ const ts_parse_action parse_table[3][5] = { }, }; -const ts_state_id lex_states[3] = { +const TSStateId lex_states[3] = { [0] = 100, [1] = 101, [2] = 102, diff --git a/spec/runtime/helpers/dummy_parser.h b/spec/runtime/helpers/dummy_parser.h index c84e1b9b..fda421fa 100644 --- a/spec/runtime/helpers/dummy_parser.h +++ b/spec/runtime/helpers/dummy_parser.h @@ -17,7 +17,7 @@ struct test_parser { size_t state_count; size_t symbol_count; const ts_parse_action **parse_table; - const ts_state_id *lex_states; + const TSStateId *lex_states; const int *hidden_symbols; }; diff --git a/spec/runtime/lr_parser_spec.cc b/spec/runtime/lr_parser_spec.cc index 08adab49..ab19b961 100644 --- a/spec/runtime/lr_parser_spec.cc +++ b/spec/runtime/lr_parser_spec.cc @@ -4,10 +4,10 @@ #include "tree_sitter/parser/lr_parser.h" TSTree *lex_fn_node_to_return; -ts_state_id lex_fn_state_received; +TSStateId lex_fn_state_received; ts_lexer *lex_fn_lexer_received; -TSTree * fake_lex(ts_lexer *lexer, ts_state_id state_id) { +TSTree * fake_lex(ts_lexer *lexer, TSStateId state_id) { lex_fn_lexer_received = lexer; lex_fn_state_received = state_id; return lex_fn_node_to_return; diff --git a/spec/runtime/stack_spec.cc b/spec/runtime/stack_spec.cc index 73d155a5..27da10d1 100644 --- a/spec/runtime/stack_spec.cc +++ b/spec/runtime/stack_spec.cc @@ -53,12 +53,12 @@ describe("stacks", [&]() { ts_tree_make_leaf(sym1, 5, 1), }); - for (ts_state_id i = 0; i < 4; i++) + for (TSStateId i = 0; i < 4; i++) ts_stack_push(&stack, 10 + i, nodes[i]); }); after_each([&]() { - for (ts_state_id i = 0; i < 4; i++) + for (TSStateId i = 0; i < 4; i++) ts_tree_release(nodes[i]); free(nodes); }); @@ -120,7 +120,7 @@ describe("stacks", [&]() { }); after_each([&]() { - for (ts_state_id i = 0; i < 2; i++) + for (TSStateId i = 0; i < 2; i++) ts_tree_release(grandchildren[i]); free(grandchildren); ts_tree_release(hidden_node); diff --git a/src/runtime/lr_parser.c b/src/runtime/lr_parser.c index 6f8a3d8f..caead91b 100644 --- a/src/runtime/lr_parser.c +++ b/src/runtime/lr_parser.c @@ -5,11 +5,11 @@ * Private */ -static const ts_parse_action * actions_for_state(ts_lr_parser *parser, ts_state_id state) { +static const ts_parse_action * actions_for_state(ts_lr_parser *parser, TSStateId state) { return parser->config.parse_table + (state * parser->config.symbol_count); } -void shift(ts_lr_parser *parser, ts_state_id parse_state, int is_extra) { +void shift(ts_lr_parser *parser, TSStateId parse_state, int is_extra) { parser->lookahead->is_extra = is_extra; ts_stack_push(&parser->stack, parse_state, parser->lookahead); parser->lookahead = parser->next_lookahead; @@ -45,8 +45,8 @@ static size_t breakdown_stack(ts_lr_parser *parser, ts_input_edit *edit) { for (size_t i = 0; i < child_count && position < edit->position; i++) { TSTree *child = children[i]; - ts_state_id state = ts_stack_top_state(stack); - ts_state_id next_state = actions_for_state(parser, state)[ts_tree_symbol(child)].data.to_state; + TSStateId state = ts_stack_top_state(stack); + TSStateId next_state = actions_for_state(parser, state)[ts_tree_symbol(child)].data.to_state; ts_stack_push(stack, next_state, child); ts_tree_retain(child); position += ts_tree_total_size(child); @@ -103,10 +103,10 @@ int handle_error(ts_lr_parser *parser) { */ for (size_t j = 0; j < parser->stack.size; j++) { size_t i = parser->stack.size - 1 - j; - ts_state_id stack_state = parser->stack.entries[i].state; + TSStateId stack_state = parser->stack.entries[i].state; ts_parse_action action_on_error = actions_for_state(parser, stack_state)[ts_builtin_sym_error]; if (action_on_error.type == ts_parse_action_type_shift) { - ts_state_id state_after_error = action_on_error.data.to_state; + TSStateId state_after_error = action_on_error.data.to_state; if (actions_for_state(parser, state_after_error)[ts_tree_symbol(parser->lookahead)].type != ts_parse_action_type_error) { ts_stack_shrink(&parser->stack, i + 1); ts_stack_push(&parser->stack, state_after_error, error); @@ -133,8 +133,8 @@ TSTree * get_tree_root(ts_lr_parser *parser) { TSTree *child = immedate_children[i]; child->is_extra = 0; ts_tree_retain(child); - ts_state_id state = ts_stack_top_state(stack); - ts_state_id next_state = actions_for_state(parser, state)[ts_tree_symbol(child)].data.to_state; + TSStateId state = ts_stack_top_state(stack); + TSStateId next_state = actions_for_state(parser, state)[ts_tree_symbol(child)].data.to_state; ts_stack_push(stack, next_state, child); } @@ -148,7 +148,7 @@ TSTree * get_tree_root(ts_lr_parser *parser) { } ts_parse_action get_next_action(ts_lr_parser *parser) { - ts_state_id state = ts_stack_top_state(&parser->stack); + TSStateId state = ts_stack_top_state(&parser->stack); if (!parser->lookahead) parser->lookahead = parser->config.lex_fn(&parser->lexer, parser->config.lex_states[state]); return actions_for_state(parser, state)[ts_tree_symbol(parser->lookahead)]; @@ -160,8 +160,8 @@ ts_parse_action get_next_action(ts_lr_parser *parser) { ts_lr_parser * ts_lr_parser_make(size_t symbol_count, const ts_parse_action *parse_table, - const ts_state_id *lex_states, - TSTree * (* lex_fn)(ts_lexer *, ts_state_id), + const TSStateId *lex_states, + TSTree * (* lex_fn)(ts_lexer *, TSStateId), const int *hidden_symbol_flags) { ts_lr_parser *result = malloc(sizeof(ts_lr_parser)); *result = (ts_lr_parser) { diff --git a/src/runtime/stack.c b/src/runtime/stack.c index 77995ec6..ea9f7528 100644 --- a/src/runtime/stack.c +++ b/src/runtime/stack.c @@ -4,7 +4,7 @@ #include static size_t INITIAL_STACK_SIZE = 100; -static ts_state_id INITIAL_STATE = 0; +static TSStateId INITIAL_STATE = 0; ts_stack ts_stack_make() { ts_stack result = { @@ -19,7 +19,7 @@ void ts_stack_delete(ts_stack *stack) { free(stack->entries); } -ts_state_id ts_stack_top_state(const ts_stack *stack) { +TSStateId ts_stack_top_state(const ts_stack *stack) { if (stack->size == 0) return INITIAL_STATE; return stack->entries[stack->size - 1].state; } @@ -29,7 +29,7 @@ TSTree * ts_stack_top_node(const ts_stack *stack) { return stack->entries[stack->size - 1].node; } -void ts_stack_push(ts_stack *stack, ts_state_id state, TSTree *node) { +void ts_stack_push(ts_stack *stack, TSStateId state, TSTree *node) { stack->entries[stack->size].state = state; stack->entries[stack->size].node = node; stack->size++;