raphael/minishell
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Merge into master my changes (#3)

Browse source 
* WIP

* Compiling!

* moved some more headers

* removed src/point.h

* Update

* fixed some stuff
This commit is contained in:
Maix0 2024-04-30 16:23:02 +02:00 • committed by GitHub
parent 24d122dc54
commit f51a071d03
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
33 changed files with 805 additions and 339 deletions
Download patch file Download diff file Expand all files Collapse all files

11
parser/src/error_costs.h
View file

@ -1,11 +0,0 @@
#ifndef TREE_SITTER_ERROR_COSTS_H_
#define TREE_SITTER_ERROR_COSTS_H_
#define ERROR_STATE 0
#define ERROR_COST_PER_RECOVERY 500
#define ERROR_COST_PER_MISSING_TREE 110
#define ERROR_COST_PER_SKIPPED_TREE 100
#define ERROR_COST_PER_SKIPPED_LINE 30
#define ERROR_COST_PER_SKIPPED_CHAR 1
#endif

16
parser/src/language.c
View file

@ -30,7 +30,7 @@ void ts_language_table_entry(
const t_language *self,
t_state_id state,
t_symbol symbol,
TableEntry *result
t_table_entry *result
) {
if (symbol == ts_builtin_sym_error || symbol == ts_builtin_sym_error_repeat) {
result->action_count = 0;
@ -171,7 +171,7 @@ t_field_id ts_language_field_id_for_name(
t_lookahead_iterator *ts_lookahead_iterator_new(const t_language *self, t_state_id state) {
if (state >= self->state_count) return NULL;
LookaheadIterator *iterator = malloc(sizeof(LookaheadIterator));
t_lookahead_iterator *iterator = malloc(sizeof(t_lookahead_iterator));
*iterator = ts_language_lookaheads(self, state);
return (t_lookahead_iterator *)iterator;
}
@ -181,35 +181,35 @@ void ts_lookahead_iterator_delete(t_lookahead_iterator *self) {
}
bool ts_lookahead_iterator_reset_state(t_lookahead_iterator * self, t_state_id state) {
LookaheadIterator *iterator = (LookaheadIterator *)self;
t_lookahead_iterator *iterator = (t_lookahead_iterator *)self;
if (state >= iterator->language->state_count) return false;
*iterator = ts_language_lookaheads(iterator->language, state);
return true;
}
const t_language *ts_lookahead_iterator_language(const t_lookahead_iterator *self) {
const LookaheadIterator *iterator = (const LookaheadIterator *)self;
const t_lookahead_iterator *iterator = (const t_lookahead_iterator *)self;
return iterator->language;
}
bool ts_lookahead_iterator_reset(t_lookahead_iterator *self, const t_language *language, t_state_id state) {
if (state >= language->state_count) return false;
LookaheadIterator *iterator = (LookaheadIterator *)self;
t_lookahead_iterator *iterator = (t_lookahead_iterator *)self;
*iterator = ts_language_lookaheads(language, state);
return true;
}
bool ts_lookahead_iterator_next(t_lookahead_iterator *self) {
LookaheadIterator *iterator = (LookaheadIterator *)self;
t_lookahead_iterator *iterator = (t_lookahead_iterator *)self;
return ts_lookahead_iterator__next(iterator);
}
t_symbol ts_lookahead_iterator_current_symbol(const t_lookahead_iterator *self) {
const LookaheadIterator *iterator = (const LookaheadIterator *)self;
const t_lookahead_iterator *iterator = (const t_lookahead_iterator *)self;
return iterator->symbol;
}
const char *ts_lookahead_iterator_current_symbol_name(const t_lookahead_iterator *self) {
const LookaheadIterator *iterator = (const LookaheadIterator *)self;
const t_lookahead_iterator *iterator = (const t_lookahead_iterator *)self;
return ts_language_symbol_name(iterator->language, iterator->symbol);
}

29
parser/src/language.h
View file

@ -1,7 +1,6 @@
#ifndef TREE_SITTER_LANGUAGE_H_
#define TREE_SITTER_LANGUAGE_H_
#include "./parser.h"
#include "./subtree.h"
#include "parser/types/types_parse_action_type.h"
#include "parser/types/types_state_id.h"
@ -12,14 +11,14 @@
#define LANGUAGE_VERSION_WITH_PRIMARY_STATES 14
#define LANGUAGE_VERSION_USABLE_VIA_WASM 13
typedef struct
typedef struct s_table_entry
{
const t_parse_actions *actions;
t_u32 action_count;
bool is_reusable;
} TableEntry;
} t_table_entry;
typedef struct
typedef struct s_lookahead_iterator
{
const t_language *language;
const t_u16 *data;
@ -34,17 +33,17 @@ typedef struct
t_symbol symbol;
t_state_id next_state;
t_u16 action_count;
} LookaheadIterator;
} t_lookahead_iterator;
void ts_language_table_entry(const t_language *, t_state_id, t_symbol,
TableEntry *);
t_table_entry *);
t_symbol_metadata ts_language_symbol_metadata(const t_language *, t_symbol);
t_symbol ts_language_public_symbol(const t_language *, t_symbol);
t_state_id ts_language_next_state(const t_language *self, t_state_id state,
t_symbol symbol);
t_symbol symbol);
static inline bool ts_language_is_symbol_external(const t_language *self,
t_symbol symbol)
@ -54,10 +53,10 @@ static inline bool ts_language_is_symbol_external(const t_language *self,
static inline const t_parse_actions *ts_language_actions(const t_language *self,
t_state_id state,
t_symbol symbol,
t_u32 *count)
t_symbol symbol,
t_u32 *count)
{
TableEntry entry;
t_table_entry entry;
ts_language_table_entry(self, state, symbol, &entry);
*count = entry.action_count;
return entry.actions;
@ -67,7 +66,7 @@ static inline bool ts_language_has_reduce_action(const t_language *self,
t_state_id state,
t_symbol symbol)
{
TableEntry entry;
t_table_entry entry;
ts_language_table_entry(self, state, symbol, &entry);
return entry.action_count > 0 && entry.actions[0].type == ActionTypeReduce;
}
@ -118,8 +117,8 @@ static inline bool ts_language_has_actions(const t_language *self,
// all possible symbols and checking the parse table for each one.
// For 'small' parse states, this exploits the structure of the
// table to only visit the valid symbols.
static inline LookaheadIterator ts_language_lookaheads(const t_language *self,
t_state_id state)
static inline t_lookahead_iterator ts_language_lookaheads(
const t_language *self, t_state_id state)
{
bool is_small_state = state >= self->large_state_count;
const t_u16 *data;
@ -137,7 +136,7 @@ static inline LookaheadIterator ts_language_lookaheads(const t_language *self,
{
data = &self->parse_table[state * self->symbol_count] - 1;
}
return (LookaheadIterator){
return (t_lookahead_iterator){
.language = self,
.data = data,
.group_end = group_end,
@ -148,7 +147,7 @@ static inline LookaheadIterator ts_language_lookaheads(const t_language *self,
};
}
static inline bool ts_lookahead_iterator__next(LookaheadIterator *self)
static inline bool ts_lookahead_iterator__next(t_lookahead_iterator *self)
{
// For small parse states, valid symbols are listed explicitly,
// grouped by their value. There's no need to look up the actions

2
parser/src/lexer.c
View file

@ -1,4 +1,4 @@
#include "./lexer.h"
#include "parser/lexer.h"
#include "parser/parser_length.h"
#include "./subtree.h"
#include <stdint.h>

60
parser/src/lexer.h
View file

@ -1,60 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* lexer.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/29 16:17:29 by maiboyer #+# #+# */
/* Updated: 2024/04/29 16:55:37 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef TREE_SITTER_LEXER_H_
#define TREE_SITTER_LEXER_H_
#include "parser/parser_length.h"
#include "./parser.h"
#include "./subtree.h"
#include "parser/api.h"
#include "me/types.h"
#include "parser/types/types_lexer.h"
#define TREE_SITTER_SERIALIZATION_BUFFER_SIZE 1024
typedef struct s_liblexer
{
t_lexer data;
t_parse_length current_position;
t_parse_length token_start_position;
t_parse_length token_end_position;
t_parser_range *included_ranges;
const char *chunk;
t_parse_input input;
t_parse_logger logger;
t_u32 included_range_count;
t_u32 current_included_range_index;
t_u32 chunk_start;
t_u32 chunk_size;
t_u32 lookahead_size;
bool did_get_column;
char debug_buffer[TREE_SITTER_SERIALIZATION_BUFFER_SIZE];
} t_liblexer;
void ts_lexer_init(t_liblexer *);
void ts_lexer_delete(t_liblexer *);
void ts_lexer_set_input(t_liblexer *, t_parse_input);
void ts_lexer_reset(t_liblexer *, t_parse_length);
void ts_lexer_start(t_liblexer *);
void ts_lexer_finish(t_liblexer *, t_i32 *);
void ts_lexer_advance_to_end(t_liblexer *);
void ts_lexer_mark_end(t_liblexer *);
bool ts_lexer_set_included_ranges(t_liblexer *self,
const t_parser_range *ranges, t_u32 count);
t_parser_range *ts_lexer_included_ranges(const t_liblexer *self, t_u32 *count);
#endif // TREE_SITTER_LEXER_H_

173
parser/src/parser.c
View file

@ -1,15 +1,9 @@
#include "./array.h"
#include "./error_costs.h"
#include "./language.h"
#include "parser/parser_length.h"
#include "./lexer.h"
#include "./reduce_action.h"
#include "./reusable_node.h"
#include "./stack.h"
#include "./subtree.h"
#include "./tree.h"
#include "parser/api.h"
#include <assert.h>
#include <inttypes.h>
#include <limits.h>
@ -18,6 +12,12 @@
#include <time.h>
#include "me/vec/vec_parser_range.h"
#include "me/vec/vec_reduce_action.h"
#include "parser/api.h"
#include "parser/error_costs.h"
#include "parser/lexer.h"
#include "parser/parser_length.h"
#include "parser/reduce_action.h"
#include "parser/types/types_language.h"
typedef t_u64 t_duration;
@ -117,7 +117,7 @@ typedef struct s_parser
SubtreePool tree_pool;
const t_language *language;
void *wasm_store;
ReduceActionSet reduce_actions;
t_vec_reduce_action reduce_actions;
Subtree finished_tree;
SubtreeArray trailing_extras;
SubtreeArray trailing_extras2;
@ -157,13 +157,13 @@ typedef enum e_error_comparison
typedef struct s_string_input
{
const char *string;
t_u32 length;
t_u32 length;
} t_string_input;
// StringInput
static const char *ts_string_inpt_read(void *_self, t_u32 byte,
t_point point, t_u32 *length)
static const char *ts_string_inpt_read(void *_self, t_u32 byte, t_point point,
t_u32 *length)
{
(void)point;
t_string_input *self = (t_string_input *)_self;
@ -219,7 +219,7 @@ static bool ts_parser__breakdown_top_of_stack(t_parser *self,
for (t_u32 i = 0; i < pop.size; i++)
{
StackSlice slice = pop.contents[i];
t_state_id state = ts_stack_state(self->stack, slice.version);
t_state_id state = ts_stack_state(self->stack, slice.version);
Subtree parent = *array_front(&slice.subtrees);
for (t_u32 j = 0, n = ts_subtree_child_count(parent); j < n; j++)
@ -367,7 +367,7 @@ static bool ts_parser__better_version_exists(t_parser *self,
return true;
}
t_parse_length position = ts_stack_position(self->stack, version);
t_parse_length position = ts_stack_position(self->stack, version);
t_error_status status = {
.cost = cost,
.is_in_error = is_in_error,
@ -440,7 +440,7 @@ static void ts_parser__external_scanner_deserialize(t_parser *self,
Subtree external_token)
{
const char *data = NULL;
t_u32 length = 0;
t_u32 length = 0;
if (external_token.ptr)
{
data = ts_external_scanner_state_data(
@ -452,7 +452,7 @@ static void ts_parser__external_scanner_deserialize(t_parser *self,
data, length);
}
static bool ts_parser__external_scanner_scan(t_parser *self,
static bool ts_parser__external_scanner_scan(t_parser *self,
t_state_id external_lex_state)
{
const bool *valid_external_tokens =
@ -463,12 +463,12 @@ static bool ts_parser__external_scanner_scan(t_parser *self,
}
static bool ts_parser__can_reuse_first_leaf(t_parser *self, t_state_id state,
Subtree tree,
TableEntry *table_entry)
Subtree tree,
t_table_entry *table_entry)
{
t_lex_modes current_lex_mode = self->language->lex_modes[state];
t_symbol leaf_symbol = ts_subtree_leaf_symbol(tree);
t_state_id leaf_state = ts_subtree_leaf_parse_state(tree);
t_symbol leaf_symbol = ts_subtree_leaf_symbol(tree);
t_state_id leaf_state = ts_subtree_leaf_parse_state(tree);
t_lex_modes leaf_lex_mode = self->language->lex_modes[leaf_state];
// At the end of a non-terminal extra node, the lexer normally returns
@ -506,25 +506,26 @@ static Subtree ts_parser__lex(t_parser *self, StackVersion version,
return NULL_SUBTREE;
}
const t_parse_length start_position = ts_stack_position(self->stack, version);
const t_parse_length start_position =
ts_stack_position(self->stack, version);
const Subtree external_token =
ts_stack_last_external_token(self->stack, version);
bool found_external_token = false;
bool error_mode = parse_state == ERROR_STATE;
bool skipped_error = false;
bool called_get_column = false;
t_i32 first_error_character = 0;
t_parse_length error_start_position = length_zero();
t_parse_length error_end_position = length_zero();
t_i32 lookahead_end_byte = 0;
t_i32 external_scanner_state_len = 0;
bool external_scanner_state_changed = false;
bool found_external_token = false;
bool error_mode = parse_state == ERROR_STATE;
bool skipped_error = false;
bool called_get_column = false;
t_i32 first_error_character = 0;
t_parse_length error_start_position = length_zero();
t_parse_length error_end_position = length_zero();
t_i32 lookahead_end_byte = 0;
t_i32 external_scanner_state_len = 0;
bool external_scanner_state_changed = false;
bool found_token;
ts_lexer_reset(&self->lexer, start_position);
for (;;)
{
bool found_token = false;
t_parse_length current_position = self->lexer.current_position;
if (lex_mode.external_lex_state != 0)
@ -626,23 +627,24 @@ static Subtree ts_parser__lex(t_parser *self, StackVersion version,
Subtree result;
if (skipped_error)
{
t_parse_length padding = length_sub(error_start_position, start_position);
t_parse_length size = length_sub(error_end_position, error_start_position);
t_u32 lookahead_bytes =
lookahead_end_byte - error_end_position.bytes;
t_parse_length padding =
length_sub(error_start_position, start_position);
t_parse_length size =
length_sub(error_end_position, error_start_position);
t_u32 lookahead_bytes = lookahead_end_byte - error_end_position.bytes;
result = ts_subtree_new_error(&self->tree_pool, first_error_character,
padding, size, lookahead_bytes,
parse_state, self->language);
}
else
{
bool is_keyword = false;
t_symbol symbol = self->lexer.data.result_symbol;
t_parse_length padding =
bool is_keyword = false;
t_symbol symbol = self->lexer.data.result_symbol;
t_parse_length padding =
length_sub(self->lexer.token_start_position, start_position);
t_parse_length size = length_sub(self->lexer.token_end_position,
self->lexer.token_start_position);
t_u32 lookahead_bytes =
t_parse_length size = length_sub(self->lexer.token_end_position,
self->lexer.token_start_position);
t_u32 lookahead_bytes =
lookahead_end_byte - self->lexer.token_end_position.bytes;
if (found_external_token)
@ -688,9 +690,9 @@ static Subtree ts_parser__lex(t_parser *self, StackVersion version,
}
static Subtree ts_parser__get_cached_token(t_parser *self, t_state_id state,
size_t position,
Subtree last_external_token,
TableEntry *table_entry)
size_t position,
Subtree last_external_token,
t_table_entry *table_entry)
{
t_token_cache *cache = &self->token_cache;
if (cache->token.ptr && cache->byte_index == position &&
@ -729,8 +731,8 @@ static void ts_parser__set_cached_token(t_parser *self, t_u32 byte_index,
static Subtree ts_parser__reuse_node(t_parser *self, StackVersion version,
t_state_id *state, t_u32 position,
Subtree last_external_token,
TableEntry *table_entry)
Subtree last_external_token,
t_table_entry *table_entry)
{
Subtree result;
while ((result = reusable_node_tree(&self->reusable_node)).ptr)
@ -823,7 +825,8 @@ static Subtree ts_parser__reuse_node(t_parser *self, StackVersion version,
// The decision is based on the trees' error costs (if any), their dynamic
// precedence, and finally, as a default, by a recursive comparison of the
// trees' symbols.
static bool ts_parser__select_parse_tree(t_parser *self, Subtree left, Subtree right)
static bool ts_parser__select_parse_tree(t_parser *self, Subtree left,
Subtree right)
{
if (!left.ptr)
return true;
@ -901,7 +904,7 @@ static bool ts_parser__select_children(t_parser *self, Subtree left,
ts_subtree_symbol(left), &self->scratch_trees, 0, self->language);
return ts_parser__select_parse_tree(self, left,
ts_subtree_from_mut(scratch_tree));
ts_subtree_from_mut(scratch_tree));
}
static void ts_parser__shift(t_parser *self, StackVersion version,
@ -928,7 +931,7 @@ static void ts_parser__shift(t_parser *self, StackVersion version,
static StackVersion ts_parser__reduce(t_parser *self, StackVersion version,
t_symbol symbol, t_u32 count,
int dynamic_precedence,
int dynamic_precedence,
t_u16 production_id, bool is_fragile,
bool end_of_non_terminal_extra)
{
@ -940,7 +943,7 @@ static StackVersion ts_parser__reduce(t_parser *self, StackVersion version,
// contain the popped children, and push it onto the stack in place of the
// children.
StackSliceArray pop = ts_stack_pop_count(self->stack, version, count);
t_u32 removed_version_count = 0;
t_u32 removed_version_count = 0;
for (t_u32 i = 0; i < pop.size; i++)
{
StackSlice slice = pop.contents[i];
@ -1074,7 +1077,7 @@ static void ts_parser__accept(t_parser *self, StackVersion version,
if (!ts_subtree_extra(tree))
{
assert(!tree.data.is_inline);
t_u32 child_count = ts_subtree_child_count(tree);
t_u32 child_count = ts_subtree_child_count(tree);
const Subtree *children = ts_subtree_children(tree);
for (t_u32 k = 0; k < child_count; k++)
{
@ -1140,8 +1143,8 @@ static bool ts_parser__do_all_potential_reductions(
continue;
t_state_id state = ts_stack_state(self->stack, version);
bool has_shift_action = false;
array_clear(&self->reduce_actions);
bool has_shift_action = false;
self->reduce_actions.len = 0;
t_symbol first_symbol, end_symbol;
if (lookahead_symbol != 0)
@ -1157,7 +1160,7 @@ static bool ts_parser__do_all_potential_reductions(
for (t_symbol symbol = first_symbol; symbol < end_symbol; symbol++)
{
TableEntry entry;
t_table_entry entry;
ts_language_table_entry(self->language, state, symbol, &entry);
for (t_u32 j = 0; j < entry.action_count; j++)
{
@ -1173,7 +1176,7 @@ static bool ts_parser__do_all_potential_reductions(
if (action.reduce.child_count > 0)
ts_reduce_action_set_add(
&self->reduce_actions,
(ReduceAction){
(t_reduce_action){
.symbol = action.reduce.symbol,
.count = action.reduce.child_count,
.dynamic_precedence =
@ -1188,9 +1191,9 @@ static bool ts_parser__do_all_potential_reductions(
}
StackVersion reduction_version = STACK_VERSION_NONE;
for (t_u32 j = 0; j < self->reduce_actions.size; j++)
for (t_u32 j = 0; j < self->reduce_actions.len; j++)
{
ReduceAction action = self->reduce_actions.contents[j];
t_reduce_action action = self->reduce_actions.buffer[j];
reduction_version = ts_parser__reduce(
self, version, action.symbol, action.count,
@ -1255,8 +1258,8 @@ static bool ts_parser__recover_to_state(t_parser *self, StackVersion version,
if (error_trees.size > 0)
{
assert(error_trees.size == 1);
Subtree error_tree = error_trees.contents[0];
t_u32 error_child_count = ts_subtree_child_count(error_tree);
Subtree error_tree = error_trees.contents[0];
t_u32 error_child_count = ts_subtree_child_count(error_tree);
if (error_child_count > 0)
{
array_splice(&slice.subtrees, 0, 0, error_child_count,
@ -1298,11 +1301,11 @@ static bool ts_parser__recover_to_state(t_parser *self, StackVersion version,
static void ts_parser__recover(t_parser *self, StackVersion version,
Subtree lookahead)
{
bool did_recover = false;
unsigned previous_version_count = ts_stack_version_count(self->stack);
t_parse_length position = ts_stack_position(self->stack, version);
StackSummary *summary = ts_stack_get_summary(self->stack, version);
unsigned node_count_since_error =
bool did_recover = false;
unsigned previous_version_count = ts_stack_version_count(self->stack);
t_parse_length position = ts_stack_position(self->stack, version);
StackSummary *summary = ts_stack_get_summary(self->stack, version);
unsigned node_count_since_error =
ts_stack_node_count_since_error(self->stack, version);
unsigned current_error_cost = ts_stack_error_cost(self->stack, version);
@ -1440,7 +1443,7 @@ static void ts_parser__recover(t_parser *self, StackVersion version,
// If the current lookahead token is an extra token, mark it as extra. This
// means it won't be counted in error cost calculations.
unsigned n;
unsigned n;
const t_parse_actions *actions = ts_language_actions(
self->language, 1, ts_subtree_symbol(lookahead), &n);
if (n > 0 && actions[n - 1].type == ActionTypeShift &&
@ -1514,8 +1517,8 @@ static void ts_parser__handle_error(t_parser *self, StackVersion version,
// lookahead. After skipping one or more invalid tokens, the parser might
// find a token that would have allowed a reduction to take place.
ts_parser__do_all_potential_reductions(self, version, 0);
t_u32 version_count = ts_stack_version_count(self->stack);
t_parse_length position = ts_stack_position(self->stack, version);
t_u32 version_count = ts_stack_version_count(self->stack);
t_parse_length position = ts_stack_position(self->stack, version);
// Push a discontinuity onto the stack. Merge all of the stack versions that
// were created in the previous step.
@ -1610,13 +1613,13 @@ static bool ts_parser__advance(t_parser *self, StackVersion version,
bool allow_node_reuse)
{
t_state_id state = ts_stack_state(self->stack, version);
t_u32 position = ts_stack_position(self->stack, version).bytes;
Subtree last_external_token =
t_u32 position = ts_stack_position(self->stack, version).bytes;
Subtree last_external_token =
ts_stack_last_external_token(self->stack, version);
bool did_reuse = true;
Subtree lookahead = NULL_SUBTREE;
TableEntry table_entry = {.action_count = 0};
bool did_reuse = true;
Subtree lookahead = NULL_SUBTREE;
t_table_entry table_entry = {.action_count = 0};
// If possible, reuse a node from the previous syntax tree.
if (allow_node_reuse)
@ -1980,8 +1983,7 @@ t_parser *ts_parser_new(void)
{
t_parser *self = calloc(1, sizeof(t_parser));
ts_lexer_init(&self->lexer);
array_init(&self->reduce_actions);
array_reserve(&self->reduce_actions, 4);
self->reduce_actions = vec_reduce_action_new(4, NULL);
self->tree_pool = ts_subtree_pool_new(32);
self->stack = ts_stack_new(&self->tree_pool);
self->finished_tree = NULL_SUBTREE;
@ -2008,14 +2010,10 @@ void ts_parser_delete(t_parser *self)
ts_parser_set_language(self, NULL);
ts_stack_delete(self->stack);
if (self->reduce_actions.contents)
{
array_delete(&self->reduce_actions);
}
if (self->reduce_actions.buffer)
vec_reduce_action_free(self->reduce_actions);
if (self->included_range_differences.buffer)
{
array_delete(&self->included_range_differences);
}
if (self->old_tree.ptr)
{
ts_subtree_release(&self->tree_pool, self->old_tree);
@ -2113,7 +2111,7 @@ bool ts_parser_set_included_ranges(t_parser *self, const t_parser_range *ranges,
}
const t_parser_range *ts_parser_included_ranges(const t_parser *self,
t_u32 *count)
t_u32 *count)
{
return ts_lexer_included_ranges(&self->lexer, count);
}
@ -2141,7 +2139,8 @@ void ts_parser_reset(t_parser *self)
self->has_scanner_error = false;
}
t_parse_tree *ts_parser_parse(t_parser *self, const t_parse_tree *old_tree, t_parse_input input)
t_parse_tree *ts_parser_parse(t_parser *self, const t_parse_tree *old_tree,
t_parse_input input)
{
t_parse_tree *result = NULL;
old_tree = NULL;
@ -2254,16 +2253,18 @@ exit:
return result;
}
t_parse_tree *ts_parser_parse_string(t_parser *self, const t_parse_tree *old_tree,
const char *string, t_u32 length)
t_parse_tree *ts_parser_parse_string(t_parser *self,
const t_parse_tree *old_tree,
const char *string, t_u32 length)
{
return ts_parser_parse_string_encoding(self, old_tree, string, length,
InputEncoding8);
}
t_parse_tree *ts_parser_parse_string_encoding(t_parser *self, const t_parse_tree *old_tree,
const char *string, t_u32 length,
t_input_encoding encoding)
t_parse_tree *ts_parser_parse_string_encoding(t_parser *self,
const t_parse_tree *old_tree,
const char *string, t_u32 length,
t_input_encoding encoding)
{
t_string_input input = {string, length};
return ts_parser_parse(self, old_tree,

62
parser/src/point.h
View file

@ -1,62 +0,0 @@
#ifndef TREE_SITTER_POINT_H_
#define TREE_SITTER_POINT_H_
#include "parser/api.h"
#define POINT_ZERO ((t_point) {0, 0})
#define POINT_MAX ((t_point) {UINT32_MAX, UINT32_MAX})
static inline t_point point__new(unsigned row, unsigned column) {
t_point result = {row, column};
return result;
}
static inline t_point point_add(t_point a, t_point b) {
if (b.row > 0)
return point__new(a.row + b.row, b.column);
else
return point__new(a.row, a.column + b.column);
}
static inline t_point point_sub(t_point a, t_point b) {
if (a.row > b.row)
return point__new(a.row - b.row, a.column);
else
return point__new(0, a.column - b.column);
}
static inline bool point_lte(t_point a, t_point b) {
return (a.row < b.row) || (a.row == b.row && a.column <= b.column);
}
static inline bool point_lt(t_point a, t_point b) {
return (a.row < b.row) || (a.row == b.row && a.column < b.column);
}
static inline bool point_gt(t_point a, t_point b) {
return (a.row > b.row) || (a.row == b.row && a.column > b.column);
}
static inline bool point_gte(t_point a, t_point b) {
return (a.row > b.row) || (a.row == b.row && a.column >= b.column);
}
static inline bool point_eq(t_point a, t_point b) {
return a.row == b.row && a.column == b.column;
}
static inline t_point point_min(t_point a, t_point b) {
if (a.row < b.row || (a.row == b.row && a.column < b.column))
return a;
else
return b;
}
static inline t_point point_max(t_point a, t_point b) {
if (a.row > b.row || (a.row == b.row && a.column > b.column))
return a;
else
return b;
}
#endif

34
parser/src/reduce_action.h
View file

@ -1,34 +0,0 @@
#ifndef TREE_SITTER_REDUCE_ACTION_H_
#define TREE_SITTER_REDUCE_ACTION_H_
#ifdef __cplusplus
extern "C" {
#endif
#include "./array.h"
#include "parser/api.h"
typedef struct {
t_u32 count;
t_symbol symbol;
int dynamic_precedence;
unsigned short production_id;
} ReduceAction;
typedef Array(ReduceAction) ReduceActionSet;
static inline void ts_reduce_action_set_add(ReduceActionSet *self,
ReduceAction new_action) {
for (t_u32 i = 0; i < self->size; i++) {
ReduceAction action = self->contents[i];
if (action.symbol == new_action.symbol && action.count == new_action.count)
return;
}
array_push(self, new_action);
}
#ifdef __cplusplus
}
#endif
#endif // TREE_SITTER_REDUCE_ACTION_H_

2
parser/src/stack.h
View file

@ -7,7 +7,7 @@ extern "C" {
#include "./array.h"
#include "./subtree.h"
#include "./error_costs.h"
#include "parser/error_costs.h"
#include <stdio.h>
typedef struct Stack Stack;

2
parser/src/subtree.c
View file

@ -7,7 +7,7 @@
#include "./array.h"
#include "./error_costs.h"
#include "parser/error_costs.h"
#include "./language.h"
#include "parser/parser_length.h"
#include "./subtree.h"

3
parser/src/subtree.h
View file

@ -5,9 +5,8 @@
#include "parser/types/types_symbol.h"
#include "./array.h"
#include "./error_costs.h"
#include "parser/error_costs.h"
#include "parser/parser_length.h"
#include "./parser.h"
#include "parser/api.h"
#include <limits.h>
#include <stdbool.h>

4
parser/src/tree.c
View file

@ -66,7 +66,7 @@ void ts_tree_edit(t_parse_tree *self, const t_input_edit *edit) {
);
if (range->end_byte < edit->new_end_byte) {
range->end_byte = UINT32_MAX;
range->end_point = POINT_MAX;
range->end_point = point_val_max();
}
}
} else if (range->end_byte > edit->start_byte) {
@ -81,7 +81,7 @@ void ts_tree_edit(t_parse_tree *self, const t_input_edit *edit) {
);
if (range->start_byte < edit->new_end_byte) {
range->start_byte = UINT32_MAX;
range->start_point = POINT_MAX;
range->start_point = point_val_max();
}
} else if (range->start_byte > edit->start_byte) {
range->start_byte = edit->start_byte;

38
parser/src/tree.h
View file

@ -3,29 +3,25 @@
#include "./subtree.h"
#ifdef __cplusplus
extern "C" {
#endif
typedef struct {
const Subtree *child;
const Subtree *parent;
t_parse_length position;
t_symbol alias_symbol;
typedef struct
{
const Subtree *child;
const Subtree *parent;
t_parse_length position;
t_symbol alias_symbol;
} ParentCacheEntry;
struct t_parse_tree {
Subtree root;
const t_language *language;
t_parser_range *included_ranges;
unsigned included_range_count;
struct s_parse_tree
{
Subtree root;
const t_language *language;
t_parser_range *included_ranges;
t_u32 included_range_count;
};
t_parse_tree *ts_tree_new(Subtree root, const t_language *language, const t_parser_range *, unsigned);
t_parse_node ts_node_new(const t_parse_tree *, const Subtree *, t_parse_length, t_symbol);
t_parse_tree *ts_tree_new(Subtree root, const t_language *language,
const t_parser_range *, t_u32);
t_parse_node ts_node_new(const t_parse_tree *, const Subtree *, t_parse_length,
t_symbol);
#ifdef __cplusplus
}
#endif
#endif // TREE_SITTER_TREE_H_
#endif // TREE_SITTER_TREE_H_

2
parser/src/tree_cursor.c
View file

@ -299,7 +299,7 @@ static inline t_i64 ts_tree_cursor_goto_first_child_for_byte_and_point(
}
t_i64 ts_tree_cursor_goto_first_child_for_byte(t_parse_tree_cursor *self, t_u32 goal_byte) {
return ts_tree_cursor_goto_first_child_for_byte_and_point(self, goal_byte, POINT_ZERO);
return ts_tree_cursor_goto_first_child_for_byte_and_point(self, goal_byte, point_val_zero());
}
t_i64 ts_tree_cursor_goto_first_child_for_point(t_parse_tree_cursor *self, t_point goal_point) {