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

Rename type ts_state_id -> TSStateId

Browse source
This commit is contained in:
Max Brunsfeld 2014-06-28 18:51:06 -07:00
parent 5f59de72a8
commit 7e0d46002c
9 changed files with 32 additions and 32 deletions
Download patch file Download diff file Expand all files Collapse all files

4
include/tree_sitter/parser.h
View file

@ -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 <stdio.h>

10
include/tree_sitter/parser/lr_parser.h
View file

@ -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);

8
include/tree_sitter/parser/stack.h
View file

@ -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);

2
spec/runtime/helpers/dummy_parser.c
View file

@ -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,

2
spec/runtime/helpers/dummy_parser.h
View file

@ -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;
};

4
spec/runtime/lr_parser_spec.cc
View file

@ -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;

6
spec/runtime/stack_spec.cc
View file

@ -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);

22
src/runtime/lr_parser.c
View file

@ -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) {

6
src/runtime/stack.c
View file

@ -4,7 +4,7 @@
#include <string.h>
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++;