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

update: normed lots of stuff

Browse source
This commit is contained in:
maix0 2024-09-19 17:35:57 +02:00
parent 978636b6ef
commit 50a2f3d4be
118 changed files with 1145 additions and 1330 deletions
Download patch file Download diff file Expand all files Collapse all files

8
parser/src/language/language_field.c
View file

@ -16,7 +16,7 @@
#include "parser/language.h"
#include "parser/parser.h"
t_const_str ts_language_field_name_for_id(const TSLanguage *self, TSFieldId id)
t_const_str ts_language_field_name_for_id(const t_language *self, t_field_id id)
{
t_u32 count;
@ -27,11 +27,11 @@ t_const_str ts_language_field_name_for_id(const TSLanguage *self, TSFieldId id)
return (NULL);
}
TSFieldId ts_language_field_id_for_name(const TSLanguage *self,
t_field_id ts_language_field_id_for_name(const t_language *self,
t_const_str name, t_u32 name_length)
{
t_u16 count;
TSSymbol i;
t_symbol i;
count = (t_u16)ts_language_field_count(self);
i = 1;
@ -45,7 +45,7 @@ TSFieldId ts_language_field_id_for_name(const TSLanguage *self,
return (0);
}
void ts_language_field_map(const TSLanguage *self, t_u32 production_id,
void ts_language_field_map(const t_language *self, t_u32 production_id,
const TSFieldMapEntry **start, const TSFieldMapEntry **end)
{
TSFieldMapSlice slice;

8
parser/src/language/language_getters.c
View file

@ -13,22 +13,22 @@
#include "me/types.h"
#include "parser/language.h"
t_u32 ts_language_symbol_count(const TSLanguage *self)
t_u32 ts_language_symbol_count(const t_language *self)
{
return (self->symbol_count + self->alias_count);
}
t_u32 ts_language_state_count(const TSLanguage *self)
t_u32 ts_language_state_count(const t_language *self)
{
return (self->state_count);
}
t_u32 ts_language_version(const TSLanguage *self)
t_u32 ts_language_version(const t_language *self)
{
return (self->version);
}
t_u32 ts_language_field_count(const TSLanguage *self)
t_u32 ts_language_field_count(const t_language *self)
{
return (self->field_count);
}

10
parser/src/language/language_getters2.c
View file

@ -15,13 +15,13 @@
#include "parser/language.h"
#include "parser/parser.h"
bool ts_language_has_actions(const TSLanguage *self, TSStateId state,
TSSymbol symbol)
bool ts_language_has_actions(const t_language *self, t_state_id state,
t_symbol symbol)
{
return (ts_language_lookup(self, state, symbol) != 0);
}
const bool *ts_language_enabled_external_tokens(const TSLanguage *self,
const bool *ts_language_enabled_external_tokens(const t_language *self,
t_u32 external_scanner_state)
{
if (external_scanner_state == 0)
@ -31,7 +31,7 @@ const bool *ts_language_enabled_external_tokens(const TSLanguage *self,
+ self->external_token_count * external_scanner_state);
}
const TSSymbol *ts_language_alias_sequence(const TSLanguage *self,
const t_symbol *ts_language_alias_sequence(const t_language *self,
t_u32 production_id)
{
if (production_id)
@ -41,7 +41,7 @@ const TSSymbol *ts_language_alias_sequence(const TSLanguage *self,
return (NULL);
}
TSSymbol ts_language_alias_at(const TSLanguage *self, t_u32 production_id,
t_symbol ts_language_alias_at(const t_language *self, t_u32 production_id,
t_u32 child_index)
{
if (production_id)

20
parser/src/language/language_misc.c
View file

@ -15,8 +15,8 @@
#include "parser/language.h"
#include "parser/parser.h"
void ts_language_table_entry(const TSLanguage *self, TSStateId state,
TSSymbol symbol, TableEntry *result)
void ts_language_table_entry(const t_language *self, t_state_id state,
t_symbol symbol, TableEntry *result)
{
t_u32 action_index;
const TSParseActionEntry *entry;
@ -37,8 +37,8 @@ void ts_language_table_entry(const TSLanguage *self, TSStateId state,
}
}
TSStateId ts_language_next_state(const TSLanguage *self, TSStateId state,
TSSymbol symbol)
t_state_id ts_language_next_state(const t_language *self, t_state_id state,
t_symbol symbol)
{
t_u32 count;
const TSParseAction *actions;
@ -67,8 +67,8 @@ TSStateId ts_language_next_state(const TSLanguage *self, TSStateId state,
return (ts_language_lookup(self, state, symbol));
}
const TSParseAction *ts_language_actions(const TSLanguage *self,
TSStateId state, TSSymbol symbol, t_u32 *count)
const TSParseAction *ts_language_actions(const t_language *self,
t_state_id state, t_symbol symbol, t_u32 *count)
{
TableEntry entry;
@ -77,8 +77,8 @@ const TSParseAction *ts_language_actions(const TSLanguage *self,
return (entry.actions);
}
bool ts_language_has_reduce_action(const TSLanguage *self, TSStateId state,
TSSymbol symbol)
bool ts_language_has_reduce_action(const t_language *self, t_state_id state,
t_symbol symbol)
{
TableEntry entry;
@ -94,8 +94,8 @@ bool ts_language_has_reduce_action(const TSLanguage *self, TSStateId state,
// For 'large' parse states, this is a direct lookup. For 'small' parse
// states, this requires searching through the symbol groups to find
// the given symbol.
t_u16 ts_language_lookup(const TSLanguage *self, TSStateId state,
TSSymbol symbol)
t_u16 ts_language_lookup(const t_language *self, t_state_id state,
t_symbol symbol)
{
if (state >= self->large_state_count)
return (me_abort("we got a small parse table, which isn't supported"),

28
parser/src/language/language_symbol.c
View file

@ -16,25 +16,25 @@
#include "parser/language.h"
#include "parser/parser.h"
TSSymbolMetadata ts_language_symbol_metadata(const TSLanguage *self,
TSSymbol symbol)
t_symbol_metadata ts_language_symbol_metadata(const t_language *self,
t_symbol symbol)
{
if (symbol == ts_builtin_sym_error)
return ((TSSymbolMetadata){.visible = true, .named = true});
return ((t_symbol_metadata){.visible = true, .named = true});
else if (symbol == ts_builtin_sym_error_repeat)
return ((TSSymbolMetadata){.visible = false, .named = false});
return ((t_symbol_metadata){.visible = false, .named = false});
else
return (self->symbol_metadata[symbol]);
}
TSSymbol ts_language_public_symbol(const TSLanguage *self, TSSymbol symbol)
t_symbol ts_language_public_symbol(const t_language *self, t_symbol symbol)
{
if (symbol == ts_builtin_sym_error)
return (symbol);
return (self->public_symbol_map[symbol]);
}
t_const_str ts_language_symbol_name(const TSLanguage *self, TSSymbol symbol)
t_const_str ts_language_symbol_name(const t_language *self, t_symbol symbol)
{
if (symbol == ts_builtin_sym_error)
return ("ERROR");
@ -46,12 +46,12 @@ t_const_str ts_language_symbol_name(const TSLanguage *self, TSSymbol symbol)
return (NULL);
}
TSSymbol ts_language_symbol_for_name(const TSLanguage *self,
t_symbol ts_language_symbol_for_name(const t_language *self,
t_const_str string, t_u32 length, bool is_named)
{
TSSymbolMetadata metadata;
t_symbol_metadata metadata;
t_u16 count;
TSSymbol i;
t_symbol i;
t_const_str symbol_name;
if (str_n_compare(string, "ERROR", length))
@ -75,15 +75,15 @@ TSSymbol ts_language_symbol_for_name(const TSLanguage *self,
return (0);
}
TSSymbolType ts_language_symbol_type(const TSLanguage *self, TSSymbol symbol)
t_symbol_type ts_language_symbol_type(const t_language *self, t_symbol symbol)
{
TSSymbolMetadata metadata;
t_symbol_metadata metadata;
metadata = ts_language_symbol_metadata(self, symbol);
if (metadata.named && metadata.visible)
return (TSSymbolTypeRegular);
return (t_symbol_typeRegular);
else if (metadata.visible)
return (TSSymbolTypeAnonymous);
return (t_symbol_typeAnonymous);
else
return (TSSymbolTypeAuxiliary);
return (t_symbol_typeAuxiliary);
}

8
parser/src/language/language_symbol2.c
View file

@ -15,11 +15,11 @@
#include "parser/language.h"
#include "parser/parser.h"
void ts_language_aliases_for_symbol(const TSLanguage *self,
TSSymbol original_symbol, const TSSymbol **start, const TSSymbol **end)
void ts_language_aliases_for_symbol(const t_language *self,
t_symbol original_symbol, const t_symbol **start, const t_symbol **end)
{
t_u32 idx;
TSSymbol symbol;
t_symbol symbol;
t_u16 count;
*start = &self->public_symbol_map[original_symbol];
@ -41,7 +41,7 @@ void ts_language_aliases_for_symbol(const TSLanguage *self,
}
}
bool ts_language_is_symbol_external(const TSLanguage *self, TSSymbol symbol)
bool ts_language_is_symbol_external(const t_language *self, t_symbol symbol)
{
return (0 < symbol && symbol < self->external_token_count + 1);
}

12
parser/src/length/length_funcs1.c
View file

@ -13,30 +13,30 @@
#include "parser/length.h"
#include "parser/point.h"
bool length_is_undefined(Length length)
bool length_is_undefined(t_length length)
{
return (length.bytes == 0 && length.extent.column != 0);
}
Length length_min(Length len1, Length len2)
t_length length_min(t_length len1, t_length len2)
{
if (len1.bytes < len2.bytes)
return (len1);
return (len2);
}
Length length_add(Length len1, Length len2)
t_length length_add(t_length len1, t_length len2)
{
Length result;
t_length result;
result.bytes = len1.bytes + len2.bytes;
result.extent = point_add(len1.extent, len2.extent);
return (result);
}
Length length_sub(Length len1, Length len2)
t_length length_sub(t_length len1, t_length len2)
{
Length result;
t_length result;
result.bytes = len1.bytes - len2.bytes;
result.extent = point_sub(len1.extent, len2.extent);

6
parser/src/length/length_funcs2.c
View file

@ -13,12 +13,12 @@
#include "parser/length.h"
#include "parser/point.h"
Length length_zero(void)
t_length length_zero(void)
{
return ((Length){0, {0, 0}});
return ((t_length){0, {0, 0}});
}
Length length_saturating_sub(Length len1, Length len2)
t_length length_saturating_sub(t_length len1, t_length len2)
{
if (len1.bytes > len2.bytes)
return (length_sub(len1, len2));

4
parser/src/lex.c
View file

@ -3,7 +3,7 @@
bool ts_lex(t_lexer *lexer, t_state_id state) {
START_LEXER();
eof = lexer->data.eof((void *)lexer);
eof = lexer->funcs.eof((void *)lexer);
switch (state) {
case 0:
if (eof) ADVANCE(127);
@ -2423,7 +2423,7 @@ bool ts_lex(t_lexer *lexer, t_state_id state) {
bool ts_lex_keywords(t_lexer *lexer, t_state_id state) {
START_LEXER();
eof = lexer->data.eof((void *)lexer);
eof = lexer->funcs.eof((void *)lexer);
switch (state) {
case 0:
ACCEPT_TOKEN(ts_builtin_sym_end);

30
parser/src/lexer/lexer_advance.c
View file

@ -6,37 +6,37 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/08/31 18:06:07 by maiboyer #+# #+# */
/* Updated: 2024/08/31 18:23:07 by maiboyer ### ########.fr */
/* Updated: 2024/09/19 16:58:25 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#include "me/types.h"
#include "parser/lexer.h"
bool ts_lexer__eof(const TSLexer *_self);
t_u32 ts_lexer__get_column(TSLexer *_self);
void ts_lexer__advance(TSLexer *_self, bool skip);
bool ts_lexer__eof(const t_lexer *_self);
t_u32 ts_lexer__get_column(t_lexer *_self);
void ts_lexer__advance(t_lexer *_self, bool skip);
void ts_lexer__clear_chunk(t_lexer *self);
void ts_lexer__get_chunk(t_lexer *self);
void ts_lexer__get_lookahead(t_lexer *self);
void ts_lexer__mark_end(TSLexer *_self);
void ts_lexer__mark_end(t_lexer *_self);
void ts_lexer_advance_to_end(t_lexer *self);
void ts_lexer_goto(t_lexer *self, Length position);
void ts_lexer_goto(t_lexer *self, t_length position);
bool ts_lexer__do_advance_loop(t_lexer *self, const TSRange **current_range);
bool ts_lexer__do_advance_loop(t_lexer *self, const t_range **current_range);
void ts_lexer__do_advance_after_loop(t_lexer *self, bool skip,
const TSRange *cur);
const t_range *cur);
// Intended to be called only from functions that control logging.
void ts_lexer__do_advance(t_lexer *self, bool skip)
{
const TSRange *cur = \
const t_range *cur = \
&self->included_ranges[self->current_included_range_index];
if (self->lookahead_size)
{
self->current_position.bytes += self->lookahead_size;
if (self->data.lookahead == '\n')
if (self->funcs.lookahead == '\n')
{
self->current_position.extent.row++;
self->current_position.extent.column = 0;
@ -53,7 +53,7 @@ void ts_lexer__do_advance(t_lexer *self, bool skip)
// Advance to the next character in the source code, retrieving a new
// chunk of source code if needed.
void ts_lexer__advance(TSLexer *_self, bool skip)
void ts_lexer__advance(t_lexer *_self, bool skip)
{
t_lexer *self;
@ -63,14 +63,14 @@ void ts_lexer__advance(TSLexer *_self, bool skip)
ts_lexer__do_advance(self, skip);
}
bool ts_lexer__do_advance_loop(t_lexer *self, const TSRange **current_range)
bool ts_lexer__do_advance_loop(t_lexer *self, const t_range **current_range)
{
if (self->current_included_range_index < self->included_range_count)
self->current_included_range_index++;
if (self->current_included_range_index < self->included_range_count)
{
(*current_range)++;
self->current_position = (Length){
self->current_position = (t_length){
(*current_range)->start_byte,
(*current_range)->start_point,
};
@ -84,7 +84,7 @@ bool ts_lexer__do_advance_loop(t_lexer *self, const TSRange **current_range)
}
void ts_lexer__do_advance_after_loop(t_lexer *self, bool skip,
const TSRange *cur)
const t_range *cur)
{
if (skip)
self->token_start_position = self->current_position;
@ -99,7 +99,7 @@ void ts_lexer__do_advance_after_loop(t_lexer *self, bool skip,
else
{
ts_lexer__clear_chunk(self);
self->data.lookahead = '\0';
self->funcs.lookahead = '\0';
self->lookahead_size = 1;
}
}

10
parser/src/lexer/lexer_chunk.c
View file

@ -13,16 +13,16 @@
#include "me/types.h"
#include "parser/lexer.h"
bool ts_lexer__eof(const TSLexer *_self);
t_u32 ts_lexer__get_column(TSLexer *_self);
void ts_lexer__advance(TSLexer *_self, bool skip);
bool ts_lexer__eof(const t_lexer *_self);
t_u32 ts_lexer__get_column(t_lexer *_self);
void ts_lexer__advance(t_lexer *_self, bool skip);
void ts_lexer__do_advance(t_lexer *self, bool skip);
void ts_lexer__clear_chunk(t_lexer *self);
void ts_lexer__get_chunk(t_lexer *self);
void ts_lexer__get_lookahead(t_lexer *self);
void ts_lexer__mark_end(TSLexer *_self);
void ts_lexer__mark_end(t_lexer *_self);
void ts_lexer_advance_to_end(t_lexer *self);
void ts_lexer_goto(t_lexer *self, Length position);
void ts_lexer_goto(t_lexer *self, t_length position);
// Clear the currently stored chunk of source code, because the lexer's
// position has changed.

26
parser/src/lexer/lexer_end.c
View file

@ -6,28 +6,28 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/08/31 18:07:07 by maiboyer #+# #+# */
/* Updated: 2024/08/31 18:12:10 by maiboyer ### ########.fr */
/* Updated: 2024/09/19 16:58:53 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#include "me/types.h"
#include "parser/lexer.h"
bool ts_lexer__eof(const TSLexer *_self);
t_u32 ts_lexer__get_column(TSLexer *_self);
void ts_lexer__advance(TSLexer *_self, bool skip);
bool ts_lexer__eof(const t_lexer *_self);
t_u32 ts_lexer__get_column(t_lexer *_self);
void ts_lexer__advance(t_lexer *_self, bool skip);
void ts_lexer__do_advance(t_lexer *self, bool skip);
void ts_lexer__clear_chunk(t_lexer *self);
void ts_lexer__get_chunk(t_lexer *self);
void ts_lexer__get_lookahead(t_lexer *self);
void ts_lexer__mark_end(TSLexer *_self);
void ts_lexer__mark_end(t_lexer *_self);
void ts_lexer_advance_to_end(t_lexer *self);
void ts_lexer_goto(t_lexer *self, Length position);
void ts_lexer_goto(t_lexer *self, t_length position);
// Check if the lexer has reached EOF. This state is stored
// by setting the lexer's `current_included_range_index` such that
// it has consumed all of its available ranges.
bool ts_lexer__eof(const TSLexer *_self)
bool ts_lexer__eof(const t_lexer *_self)
{
t_lexer *self;
@ -37,14 +37,14 @@ bool ts_lexer__eof(const TSLexer *_self)
// Mark that a token match has completed. This can be called multiple
// times if a longer match is found later.
void ts_lexer__mark_end(TSLexer *_self)
void ts_lexer__mark_end(t_lexer *_self)
{
t_lexer *self;
TSRange *current_included_range;
TSRange *previous_included_range;
t_range *current_included_range;
t_range *previous_included_range;
self = (t_lexer *)_self;
if (!ts_lexer__eof(&self->data))
if (!ts_lexer__eof(self))
{
current_included_range = \
&self->included_ranges[self->current_included_range_index];
@ -52,7 +52,7 @@ void ts_lexer__mark_end(TSLexer *_self)
&& self->current_position.bytes == current_included_range->start_byte)
{
previous_included_range = current_included_range - 1;
self->token_end_position = (Length){
self->token_end_position = (t_length){
previous_included_range->end_byte,
previous_included_range->end_point,
};
@ -65,5 +65,5 @@ void ts_lexer__mark_end(TSLexer *_self)
void ts_lexer_advance_to_end(t_lexer *self)
{
while (self->chunk)
ts_lexer__advance(&self->data, false);
ts_lexer__advance(self, false);
}

12
parser/src/lexer/lexer_get_column.c
View file

@ -13,18 +13,18 @@
#include "me/types.h"
#include "parser/lexer.h"
bool ts_lexer__eof(const TSLexer *_self);
t_u32 ts_lexer__get_column(TSLexer *_self);
void ts_lexer__advance(TSLexer *_self, bool skip);
bool ts_lexer__eof(const t_lexer *_self);
t_u32 ts_lexer__get_column(t_lexer *_self);
void ts_lexer__advance(t_lexer *_self, bool skip);
void ts_lexer__do_advance(t_lexer *self, bool skip);
void ts_lexer__clear_chunk(t_lexer *self);
void ts_lexer__get_chunk(t_lexer *self);
void ts_lexer__get_lookahead(t_lexer *self);
void ts_lexer__mark_end(TSLexer *_self);
void ts_lexer__mark_end(t_lexer *_self);
void ts_lexer_advance_to_end(t_lexer *self);
void ts_lexer_goto(t_lexer *self, Length position);
void ts_lexer_goto(t_lexer *self, t_length position);
t_u32 ts_lexer__get_column(TSLexer *_self)
t_u32 ts_lexer__get_column(t_lexer *_self)
{
t_lexer *self;
t_u32 goal_byte;

30
parser/src/lexer/lexer_goto.c
View file

@ -6,32 +6,32 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/08/31 18:08:11 by maiboyer #+# #+# */
/* Updated: 2024/08/31 18:39:32 by maiboyer ### ########.fr */
/* Updated: 2024/09/19 16:59:09 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#include "me/types.h"
#include "parser/lexer.h"
bool ts_lexer__eof(const TSLexer *_self);
t_u32 ts_lexer__get_column(TSLexer *_self);
void ts_lexer__advance(TSLexer *_self, bool skip);
bool ts_lexer__eof(const t_lexer *_self);
t_u32 ts_lexer__get_column(t_lexer *_self);
void ts_lexer__advance(t_lexer *_self, bool skip);
void ts_lexer__do_advance(t_lexer *self, bool skip);
void ts_lexer__clear_chunk(t_lexer *self);
void ts_lexer__get_chunk(t_lexer *self);
void ts_lexer__get_lookahead(t_lexer *self);
void ts_lexer__mark_end(TSLexer *_self);
void ts_lexer__mark_end(t_lexer *_self);
void ts_lexer_advance_to_end(t_lexer *self);
void ts_lexer_goto(t_lexer *self, Length position);
void ts_lexer_goto(t_lexer *self, t_length position);
void ts_lexer_goto_inside_loop(t_lexer *self, bool *found_included_range,
TSRange *included_range, t_usize i);
t_range *included_range, t_usize i);
void ts_lexer_goto_after_loop(t_lexer *self, bool found_included_range);
void ts_lexer_goto(t_lexer *self, Length position)
void ts_lexer_goto(t_lexer *self, t_length position)
{
bool found_included_range;
TSRange *included_range;
t_range *included_range;
t_u32 i;
included_range = NULL;
@ -54,11 +54,11 @@ void ts_lexer_goto(t_lexer *self, Length position)
}
void ts_lexer_goto_inside_loop(t_lexer *self, bool *found_included_range,
TSRange *included_range, t_usize i)
t_range *included_range, t_usize i)
{
if (included_range->start_byte >= self->current_position.bytes)
{
self->current_position = (Length){
self->current_position = (t_length){
.bytes = included_range->start_byte,
.extent = included_range->start_point,
};
@ -69,7 +69,7 @@ void ts_lexer_goto_inside_loop(t_lexer *self, bool *found_included_range,
void ts_lexer_goto_after_loop(t_lexer *self, bool found_included_range)
{
TSRange *last_included_range;
t_range *last_included_range;
if (found_included_range)
{
@ -78,19 +78,19 @@ void ts_lexer_goto_after_loop(t_lexer *self, bool found_included_range)
+ self->chunk_size))
ts_lexer__clear_chunk(self);
self->lookahead_size = 0;
self->data.lookahead = '\0';
self->funcs.lookahead = '\0';
}
else
{
self->current_included_range_index = self->included_range_count;
last_included_range = &self->included_ranges[self->included_range_count
- 1];
self->current_position = (Length){
self->current_position = (t_length){
.bytes = last_included_range->end_byte,
.extent = last_included_range->end_point,
};
ts_lexer__clear_chunk(self);
self->lookahead_size = 1;
self->data.lookahead = '\0';
self->funcs.lookahead = '\0';
}
}

32
parser/src/lexer/lexer_lifetime.c
View file

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/08/31 17:58:01 by maiboyer #+# #+# */
/* Updated: 2024/08/31 18:25:16 by maiboyer ### ########.fr */
/* Updated: 2024/09/19 16:59:58 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
@ -15,27 +15,27 @@
#define BYTE_ORDER_MARK 0xFEFF
bool ts_lexer__eof(const TSLexer *_self);
t_u32 ts_lexer__get_column(TSLexer *_self);
void ts_lexer__advance(TSLexer *_self, bool skip);
bool ts_lexer__eof(const t_lexer *_self);
t_u32 ts_lexer__get_column(t_lexer *_self);
void ts_lexer__advance(t_lexer *_self, bool skip);
void ts_lexer__clear_chunk(t_lexer *self);
void ts_lexer__get_chunk(t_lexer *self);
void ts_lexer__get_lookahead(t_lexer *self);
void ts_lexer__mark_end(TSLexer *_self);
void ts_lexer__mark_end(t_lexer *_self);
void ts_lexer_advance_to_end(t_lexer *self);
void ts_lexer_goto(t_lexer *self, Length position);
void ts_lexer_goto(t_lexer *self, t_length position);
void ts_lexer_init(t_lexer *self)
{
static TSRange default_range = {.start_point = {\
static t_range default_range = {.start_point = {\
.row = 0, .column = 0, }, .end_point = {.row = UINT32_MAX, \
.column = UINT32_MAX, }, .start_byte = 0, .end_byte = UINT32_MAX};
*self = (t_lexer){
.data = {
.funcs = {
.advance = ts_lexer__advance,
.mark_end = ts_lexer__mark_end,
.get_column = ts_lexer__get_column,
.get_column = NULL, //ts_lexer__get_column,
.eof = ts_lexer__eof,
.lookahead = 0,
.result_symbol = 0, },
@ -49,14 +49,14 @@ void ts_lexer_init(t_lexer *self)
};
}
void ts_lexer_set_input(t_lexer *self, TSInput input)
void ts_lexer_set_input(t_lexer *self, t_input input)
{
self->input = input;
ts_lexer__clear_chunk(self);
ts_lexer_goto(self, self->current_position);
}
void ts_lexer_reset(t_lexer *self, Length position)
void ts_lexer_reset(t_lexer *self, t_length position)
{
if (position.bytes != self->current_position.bytes)
ts_lexer_goto(self, position);
@ -66,24 +66,24 @@ void ts_lexer_start(t_lexer *self)
{
self->token_start_position = self->current_position;
self->token_end_position = LENGTH_UNDEFINED;
self->data.result_symbol = 0;
self->funcs.result_symbol = 0;
self->did_get_column = false;
if (!ts_lexer__eof(&self->data))
if (!ts_lexer__eof(self))
{
if (!self->chunk_size)
ts_lexer__get_chunk(self);
if (!self->lookahead_size)
ts_lexer__get_lookahead(self);
if (self->current_position.bytes == 0
&& self->data.lookahead == BYTE_ORDER_MARK)
ts_lexer__advance(&self->data, true);
&& self->funcs.lookahead == BYTE_ORDER_MARK)
ts_lexer__advance(self, true);
}
}
void ts_lexer_finish(t_lexer *self, t_u32 *lookahead_end_byte)
{
if (length_is_undefined(self->token_end_position))
ts_lexer__mark_end(&self->data);
ts_lexer__mark_end(self);
(void)(lookahead_end_byte);
if (self->token_end_position.bytes < self->token_start_position.bytes)
self->token_start_position = self->token_end_position;

18
parser/src/lexer/lexer_lookahead.c
View file

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/08/31 18:09:03 by maiboyer #+# #+# */
/* Updated: 2024/08/31 18:09:03 by maiboyer ### ########.fr */
/* Updated: 2024/09/19 17:00:15 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
@ -14,16 +14,16 @@
#include "parser/input.h"
#include "parser/lexer.h"
bool ts_lexer__eof(const TSLexer *_self);
t_u32 ts_lexer__get_column(TSLexer *_self);
void ts_lexer__advance(TSLexer *_self, bool skip);
bool ts_lexer__eof(const t_lexer *_self);
t_u32 ts_lexer__get_column(t_lexer *_self);
void ts_lexer__advance(t_lexer *_self, bool skip);
void ts_lexer__do_advance(t_lexer *self, bool skip);
void ts_lexer__clear_chunk(t_lexer *self);
void ts_lexer__get_chunk(t_lexer *self);
void ts_lexer__get_lookahead(t_lexer *self);
void ts_lexer__mark_end(TSLexer *_self);
void ts_lexer__mark_end(t_lexer *_self);
void ts_lexer_advance_to_end(t_lexer *self);
void ts_lexer_goto(t_lexer *self, Length position);
void ts_lexer_goto(t_lexer *self, t_length position);
void ts_lexer__get_lookahead(t_lexer *self)
{
@ -36,11 +36,11 @@ void ts_lexer__get_lookahead(t_lexer *self)
if (size == 0)
{
self->lookahead_size = 1;
self->data.lookahead = '\0';
self->funcs.lookahead = '\0';
return ;
}
chunk = (const t_u8 *)self->chunk + position_in_chunk;
self->lookahead_size = ts_decode_ascii(chunk, size, &self->data.lookahead);
if (self->data.lookahead == TS_DECODE_ERROR)
self->lookahead_size = ts_decode_ascii(chunk, size, &self->funcs.lookahead);
if (self->funcs.lookahead == TS_DECODE_ERROR)
self->lookahead_size = 1;
}

18
parser/src/misc/create_language.c
View file

@ -15,9 +15,9 @@
#include "me/types.h"
#include "parser/parser.h"
// bool lex_keywords_main(TSLexer *lexer, TSStateId state);
// bool lex_normal_main(TSLexer *lexer, TSStateId state);
bool tree_sitter_sh_external_scanner_scan(void *ctx, TSLexer *lexer, \
// bool lex_keywords_main(t_lexer *lexer, t_state_id state);
// bool lex_normal_main(t_lexer *lexer, t_state_id state);
bool tree_sitter_sh_external_scanner_scan(void *ctx, t_lexer *lexer, \
const bool *ret);
void *create_external_scanner_states(void);
void *create_field_names(void);
@ -33,8 +33,8 @@ void *create_non_terminal_alias_map(void);
void *create_unique_symbols_map(void);
void *create_symbols_metadata(void);
void *create_parse_table(void);
bool ts_lex_keywords(TSLexer *lexer, TSStateId state);
bool ts_lex(TSLexer *lexer, TSStateId state);
bool ts_lex_keywords(t_lexer *lexer, t_state_id state);
bool ts_lex(t_lexer *lexer, t_state_id state);
t_u32 tree_sitter_sh_external_scanner_serialize(void *ctx, t_u8 *state);
void tree_sitter_sh_external_scanner_deserialize(void *ctx, \
const t_u8 *state, t_u32 val);
@ -54,7 +54,7 @@ static struct ExternalScannerDefinition init_scanner(void)
});
}
static void init_language(TSLanguage *language)
static void init_language(t_language *language)
{
static uint32_t empty_map[] = {0, 0, 0};
@ -78,10 +78,10 @@ static void init_language(TSLanguage *language)
language->external_scanner = init_scanner();
}
const TSLanguage *tree_sitter_sh(void)
const t_language *tree_sitter_sh(void)
{
static bool init = false;
static TSLanguage language = {
static t_language language = {
.version = LANGUAGE_VERSION,
.symbol_count = SYMBOL_COUNT,
.alias_count = ALIAS_COUNT,
@ -99,5 +99,5 @@ const TSLanguage *tree_sitter_sh(void)
init_language(&language);
init = true;
}
return ((TSLanguage *)&language);
return ((t_language *)&language);
}

2
parser/src/misc/reduce_action.c
View file

@ -14,7 +14,7 @@
#include "me/vec/vec_reduce_action.h"
void ts_reduce_action_set_add(\
ReduceActionSet *self, t_reduce_action new_action)
t_vec_reduce_action *self, t_reduce_action new_action)
{
t_reduce_action action;
t_u32 i;

14
parser/src/node/node_child.c
View file

@ -12,7 +12,7 @@
#include "parser/inner/node.h"
t_u32 ts_node_child_count(TSNode self)
t_u32 ts_node_child_count(t_node self)
{
t_subtree tree;
@ -23,7 +23,7 @@ t_u32 ts_node_child_count(TSNode self)
return (0);
}
t_u32 ts_node_named_child_count(TSNode self)
t_u32 ts_node_named_child_count(t_node self)
{
t_subtree tree;
@ -34,17 +34,17 @@ t_u32 ts_node_named_child_count(TSNode self)
return (0);
}
TSFieldId ts_node_field_id_for_child(TSNode self, t_u32 child_index)
t_field_id ts_node_field_id_for_child(t_node self, t_u32 child_index)
{
TSNode result;
t_node result;
bool did_descend;
TSFieldId inherited_field_id;
TSNode child;
t_field_id inherited_field_id;
t_node child;
t_u32 index;
NodeChildIterator iterator;
t_u32 grandchild_index;
t_u32 grandchild_count;
TSFieldId field_id;
t_field_id field_id;
result = self;
did_descend = true;

6
parser/src/node/node_child_inner.c
View file

@ -12,11 +12,11 @@
#include "parser/inner/node.h"
TSNode ts_node__child(TSNode self, t_u32 child_index, bool include_anonymous)
t_node ts_node__child(t_node self, t_u32 child_index, bool include_anonymous)
{
TSNode result;
t_node result;
bool did_descend;
TSNode child;
t_node child;
t_u32 index;
NodeChildIterator iterator;
t_u32 grandchild_index;

8
parser/src/node/node_constructor.c
View file

@ -14,16 +14,16 @@
#include "parser/length.h"
#include "parser/subtree.h"
TSNode ts_node_new(const TSTree *tree, const t_subtree *subtree, \
Length position, TSSymbol alias)
t_node ts_node_new(const t_tree *tree, const t_subtree *subtree, \
t_length position, t_symbol alias)
{
return ((TSNode){
return ((t_node){
position.bytes, position.extent.row, position.extent.column, \
alias, subtree, tree,
});
}
TSNode ts_node__null(void)
t_node ts_node__null(void)
{
return (ts_node_new(NULL, NULL, length_zero(), 0));
}

4
parser/src/node/node_fields.c
View file

@ -15,7 +15,7 @@
#include "parser/language.h"
#include "parser/tree.h"
t_const_str ts_node__field_name_from_language(TSNode self,
t_const_str ts_node__field_name_from_language(t_node self,
t_u32 structural_child_index)
{
const TSFieldMapEntry *field_map;
@ -33,7 +33,7 @@ t_const_str ts_node__field_name_from_language(TSNode self,
return (NULL);
}
TSFieldId ts_node__field_id_from_language(TSNode self,
t_field_id ts_node__field_id_from_language(t_node self,
t_u32 structural_child_index)
{
const TSFieldMapEntry *field_map;

10
parser/src/node/node_getter_funcs1.c
View file

@ -14,14 +14,14 @@
#include "parser/language.h"
#include "parser/tree.h"
bool ts_node_is_extra(TSNode self)
bool ts_node_is_extra(t_node self)
{
return (ts_subtree_extra(ts_node__subtree(self)));
}
bool ts_node_is_named(TSNode self)
bool ts_node_is_named(t_node self)
{
TSSymbol alias;
t_symbol alias;
alias = ts_node__alias(&self);
if (alias)
@ -29,12 +29,12 @@ bool ts_node_is_named(TSNode self)
return (ts_subtree_named(ts_node__subtree(self)));
}
TSNode ts_node_child(TSNode self, t_u32 child_index)
t_node ts_node_child(t_node self, t_u32 child_index)
{
return (ts_node__child(self, child_index, true));
}
TSNode ts_node_named_child(TSNode self, t_u32 child_index)
t_node ts_node_named_child(t_node self, t_u32 child_index)
{
return (ts_node__child(self, child_index, false));
}

12
parser/src/node/node_getter_funcs2.c
View file

@ -14,27 +14,27 @@
#include "parser/language.h"
#include "parser/tree.h"
t_u32 ts_node_start_byte(TSNode self)
t_u32 ts_node_start_byte(t_node self)
{
return (self.start_byte);
}
const TSLanguage *ts_node_language(TSNode self)
const t_language *ts_node_language(t_node self)
{
return (self.tree->language);
}
TSPoint ts_node_start_point(TSNode self)
t_point ts_node_start_point(t_node self)
{
return ((TSPoint){self.start_row, self.start_col});
return ((t_point){self.start_row, self.start_col});
}
t_u32 ts_node__alias(const TSNode *self)
t_u32 ts_node__alias(const t_node *self)
{
return (self->alias);
}
t_subtree ts_node__subtree(TSNode self)
t_subtree ts_node__subtree(t_node self)
{
return (*(const t_subtree *)self.id);
}

16
parser/src/node/node_getter_funcs3.c
View file

@ -14,15 +14,15 @@
#include "parser/language.h"
#include "parser/tree.h"
t_u32 ts_node_end_byte(TSNode self)
t_u32 ts_node_end_byte(t_node self)
{
return (ts_node_start_byte(self)
+ ts_subtree_size(ts_node__subtree(self)).bytes);
}
TSSymbol ts_node_symbol(TSNode self)
t_symbol ts_node_symbol(t_node self)
{
TSSymbol symbol;
t_symbol symbol;
symbol = ts_node__alias(&self);
if (!symbol)
@ -30,9 +30,9 @@ TSSymbol ts_node_symbol(TSNode self)
return (ts_language_public_symbol(self.tree->language, symbol));
}
t_const_str ts_node_type(TSNode self)
t_const_str ts_node_type(t_node self)
{
TSSymbol symbol;
t_symbol symbol;
symbol = ts_node__alias(&self);
if (!symbol)
@ -40,14 +40,14 @@ t_const_str ts_node_type(TSNode self)
return (ts_language_symbol_name(self.tree->language, symbol));
}
TSSymbol ts_node_grammar_symbol(TSNode self)
t_symbol ts_node_grammar_symbol(t_node self)
{
return (ts_subtree_symbol(ts_node__subtree(self)));
}
t_const_str ts_node_grammar_type(TSNode self)
t_const_str ts_node_grammar_type(t_node self)
{
TSSymbol symbol;
t_symbol symbol;
symbol = ts_subtree_symbol(ts_node__subtree(self));
return (ts_language_symbol_name(self.tree->language, symbol));

8
parser/src/node/node_iterator.c
View file

@ -14,10 +14,10 @@
#include "parser/language.h"
#include "parser/tree.h"
NodeChildIterator ts_node_iterate_children(const TSNode *node)
NodeChildIterator ts_node_iterate_children(const t_node *node)
{
t_subtree subtree;
const TSSymbol *alias_sequence;
const t_symbol *alias_sequence;
subtree = ts_node__subtree(*node);
if (ts_subtree_child_count(subtree) == 0)
@ -40,10 +40,10 @@ bool ts_node_child_iterator_done(NodeChildIterator *self)
return (self->child_index == self->parent->child_count);
}
bool ts_node_child_iterator_next(NodeChildIterator *self, TSNode *result)
bool ts_node_child_iterator_next(NodeChildIterator *self, t_node *result)
{
const t_subtree *child;
TSSymbol alias_symbol;
t_symbol alias_symbol;
if (!self->parent || ts_node_child_iterator_done(self))
return (false);

6
parser/src/node/node_relevent.c
View file

@ -14,9 +14,9 @@
#include "parser/language.h"
#include "parser/tree.h"
bool ts_node__is_relevant(TSNode self, bool include_anonymous)
bool ts_node__is_relevant(t_node self, bool include_anonymous)
{
TSSymbol alias;
t_symbol alias;
t_subtree tree;
tree = ts_node__subtree(self);
@ -29,7 +29,7 @@ bool ts_node__is_relevant(TSNode self, bool include_anonymous)
return (ts_subtree_visible(tree) && ts_subtree_named(tree));
}
t_u32 ts_node__relevant_child_count(TSNode self, bool include_anonymous)
t_u32 ts_node__relevant_child_count(t_node self, bool include_anonymous)
{
t_subtree tree;

6
parser/src/parser/parser_accept.c
View file

@ -6,13 +6,13 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/09/13 14:02:35 by maiboyer #+# #+# */
/* Updated: 2024/09/13 14:02:44 by maiboyer ### ########.fr */
/* Updated: 2024/09/19 17:23:29 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#include "parser/inner/parser_inner.h"
void ts_parser__accept(TSParser *self, t_stack_version version,
void ts_parser__accept(t_parser *self, t_stack_version version,
t_subtree lookahead)
{
t_u32 child_count;
@ -26,7 +26,7 @@ void ts_parser__accept(TSParser *self, t_stack_version version,
t_subtree tree;
assert(ts_subtree_is_eof(lookahead));
ts_stack_push(self->stack, version, lookahead, false, 1);
ts_stack_push(self->stack, (struct s_stack_push_arg){version, lookahead, false, 1});
pop = ts_stack_pop_all(self->stack, version);
i = 0;
while (i < pop.size)

12
parser/src/parser/parser_advance.c
View file

@ -6,15 +6,15 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/09/13 14:01:20 by maiboyer #+# #+# */
/* Updated: 2024/09/13 14:01:26 by maiboyer ### ########.fr */
/* Updated: 2024/09/19 17:24:14 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#include "parser/inner/parser_inner.h"
bool ts_parser__advance(TSParser *self, t_stack_version version)
bool ts_parser__advance(t_parser *self, t_stack_version version)
{
TSStateId state;
t_state_id state;
t_subtree mutable_lookahead;
t_subtree lookahead;
TableEntry table_entry;
@ -22,7 +22,7 @@ bool ts_parser__advance(TSParser *self, t_stack_version version)
t_u32 i;
t_stack_version last_reduction_version;
TSParseAction action;
TSStateId next_state;
t_state_id next_state;
bool is_fragile;
bool end_of_non_terminal_extra;
t_stack_version reduction_version;
@ -78,7 +78,7 @@ bool ts_parser__advance(TSParser *self, t_stack_version version)
action.reduce.dynamic_precedence,
action.reduce.production_id, is_fragile,
end_of_non_terminal_extra);
if (reduction_version != STACK_VERSION_NONE)
if (reduction_version != (t_stack_version)STACK_VERSION_NONE)
last_reduction_version = reduction_version;
i++;
}
@ -87,7 +87,7 @@ bool ts_parser__advance(TSParser *self, t_stack_version version)
if (action.type == TSParseActionTypeRecover)
return (ts_parser__recover(self, version, lookahead), true);
}
if (last_reduction_version != STACK_VERSION_NONE)
if (last_reduction_version != (t_stack_version)STACK_VERSION_NONE)
{
ts_stack_renumber_version(self->stack, last_reduction_version,
version);

12
parser/src/parser/parser_breakdown_top_of_stack.c
View file

@ -6,16 +6,16 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/09/13 13:36:06 by maiboyer #+# #+# */
/* Updated: 2024/09/13 13:36:14 by maiboyer ### ########.fr */
/* Updated: 2024/09/19 17:19:45 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#include "parser/inner/parser_inner.h"
bool ts_parser__breakdown_top_of_stack(TSParser *self,
bool ts_parser__breakdown_top_of_stack(t_parser *self,
t_stack_version version)
{
TSStateId state;
t_state_id state;
bool did_break_down;
bool pending;
t_stack_slice slice;
@ -57,15 +57,15 @@ bool ts_parser__breakdown_top_of_stack(TSParser *self,
state = ts_language_next_state(self->language, state,
ts_subtree_symbol(child));
child->ref_count++;
ts_stack_push(self->stack, slice.version, child, pending,
state);
ts_stack_push(self->stack, \
(struct s_stack_push_arg){slice.version, child, pending, state});
j++;
}
j = 1;
while (j < slice.subtrees.len)
{
tree = slice.subtrees.buffer[j];
ts_stack_push(self->stack, slice.version, tree, false, state);
ts_stack_push(self->stack, (struct s_stack_push_arg){slice.version, tree, false, state});
j++;
}
ts_subtree_release(parent);

2
parser/src/parser/parser_condense_stack.c
View file

@ -12,7 +12,7 @@
#include "parser/inner/parser_inner.h"
t_u32 ts_parser__condense_stack(TSParser *self)
t_u32 ts_parser__condense_stack(t_parser *self)
{
bool has_unpaused_version;
t_error_comparison cmp;

16
parser/src/parser/parser_do_reduction.c
View file

@ -6,14 +6,14 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/09/13 14:04:20 by maiboyer #+# #+# */
/* Updated: 2024/09/13 14:04:29 by maiboyer ### ########.fr */
/* Updated: 2024/09/19 17:21:23 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#include "parser/inner/parser_inner.h"
bool ts_parser__do_all_potential_reductions(TSParser *self,
t_stack_version starting_version, TSSymbol lookahead_symbol)
bool ts_parser__do_all_potential_reductions(t_parser *self,
t_stack_version starting_version, t_symbol lookahead_symbol)
{
t_u32 initial_version_count;
bool can_shift_lookahead_symbol;
@ -22,14 +22,14 @@ bool ts_parser__do_all_potential_reductions(TSParser *self,
t_u32 version_count;
bool merged;
t_stack_version j;
TSStateId state;
t_state_id state;
bool has_shift_action;
TSSymbol first_symbol;
TSSymbol end_symbol;
t_symbol first_symbol;
t_symbol end_symbol;
t_stack_version reduction_version;
t_reduce_action reduce_action;
t_u32 k;
TSSymbol symbol;
t_symbol symbol;
TableEntry entry;
TSParseAction action;
@ -109,7 +109,7 @@ bool ts_parser__do_all_potential_reductions(TSParser *self,
}
if (has_shift_action)
can_shift_lookahead_symbol = true;
else if (reduction_version != STACK_VERSION_NONE
else if (reduction_version != (t_stack_version)STACK_VERSION_NONE
&& i < MAX_VERSION_COUNT)
{
ts_stack_renumber_version(self->stack, reduction_version, version);

16
parser/src/parser/parser_external_scanner.c
View file

@ -6,18 +6,18 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/09/11 16:44:11 by maiboyer #+# #+# */
/* Updated: 2024/09/13 14:14:07 by maiboyer ### ########.fr */
/* Updated: 2024/09/19 17:23:41 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#include "parser/inner/parser_inner.h"
void ts_parser__external_scanner_create(TSParser *self)
void ts_parser__external_scanner_create(t_parser *self)
{
self->external_scanner_payload = self->language->external_scanner.create();
}
void ts_parser__external_scanner_destroy(TSParser *self)
void ts_parser__external_scanner_destroy(t_parser *self)
{
if (self->external_scanner_payload != NULL)
{
@ -27,7 +27,7 @@ void ts_parser__external_scanner_destroy(TSParser *self)
}
}
t_u32 ts_parser__external_scanner_serialize(TSParser *self)
t_u32 ts_parser__external_scanner_serialize(t_parser *self)
{
t_u32 length;
@ -39,7 +39,7 @@ t_u32 ts_parser__external_scanner_serialize(TSParser *self)
return (length);
}
void ts_parser__external_scanner_deserialize(TSParser *self,
void ts_parser__external_scanner_deserialize(t_parser *self,
t_subtree external_token)
{
const t_u8 *data;
@ -58,13 +58,13 @@ void ts_parser__external_scanner_deserialize(TSParser *self,
data, length);
}
bool ts_parser__external_scanner_scan(TSParser *self,
TSStateId external_lex_state)
bool ts_parser__external_scanner_scan(t_parser *self,
t_state_id external_lex_state)
{
const bool *valid_external_tokens;
valid_external_tokens = ts_language_enabled_external_tokens(self->language,
external_lex_state);
return (self->language->external_scanner.scan(\
self->external_scanner_payload, &self->lexer.data, valid_external_tokens));
self->external_scanner_payload, &self->lexer, valid_external_tokens));
}

22
parser/src/parser/parser_handle_error.c
View file

@ -6,22 +6,22 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/09/13 14:04:50 by maiboyer #+# #+# */
/* Updated: 2024/09/13 14:05:26 by maiboyer ### ########.fr */
/* Updated: 2024/09/19 17:20:50 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#include "parser/inner/parser_inner.h"
void ts_lexer__mark_end(TSLexer *_self);
void ts_lexer__mark_end(t_lexer *_self);
void ts_parser__handle_error(TSParser *self, t_stack_version version,
void ts_parser__handle_error(t_parser *self, t_stack_version version,
t_subtree lookahead)
{
Length padding;
Length position;
TSStateId state;
TSStateId state_after_missing_symbol;
TSSymbol missing_symbol;
t_length padding;
t_length position;
t_state_id state;
t_state_id state_after_missing_symbol;
t_symbol missing_symbol;
bool did_insert_missing_token;
t_stack_version v;
t_stack_version version_with_missing_tree;
@ -67,8 +67,8 @@ void ts_parser__handle_error(TSParser *self, t_stack_version version,
v);
missing_tree = ts_subtree_new_missing_leaf(missing_symbol,
padding, lookahead_bytes, self->language);
ts_stack_push(self->stack, version_with_missing_tree,
missing_tree, false, state_after_missing_symbol);
ts_stack_push(self->stack, (struct s_stack_push_arg){version_with_missing_tree,
missing_tree, false, state_after_missing_symbol});
if (ts_parser__do_all_potential_reductions(self,
version_with_missing_tree,
ts_subtree_leaf_symbol(lookahead)))
@ -80,7 +80,7 @@ void ts_parser__handle_error(TSParser *self, t_stack_version version,
missing_symbol++;
}
}
ts_stack_push(self->stack, v, NULL, false, ERROR_STATE);
ts_stack_push(self->stack, (struct s_stack_push_arg){v, NULL, false, ERROR_STATE});
if (v == version)
v = previous_version_count;
else

38
parser/src/parser/parser_lex.c
View file

@ -6,23 +6,23 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/09/13 13:54:24 by maiboyer #+# #+# */
/* Updated: 2024/09/14 14:32:56 by maiboyer ### ########.fr */
/* Updated: 2024/09/19 17:22:48 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#include "parser/inner/parser_inner.h"
t_subtree ts_parser__lex(TSParser *self, t_stack_version version,
TSStateId parse_state)
t_subtree ts_parser__lex(t_parser *self, t_stack_version version,
t_state_id parse_state)
{
Length current_position;
Length error_end_position;
Length error_start_position;
Length padding;
Length size;
Length start_position;
t_length current_position;
t_length error_end_position;
t_length error_start_position;
t_length padding;
t_length size;
t_length start_position;
TSLexMode lex_mode;
TSSymbol symbol;
t_symbol symbol;
bool called_get_column;
bool error_mode;
bool external_scanner_state_changed;
@ -87,7 +87,7 @@ t_subtree ts_parser__lex(TSParser *self, t_stack_version version,
ts_lexer_reset(&self->lexer, current_position);
}
ts_lexer_start(&self->lexer);
found_token = self->language->lex_fn(&self->lexer.data,
found_token = self->language->lex_fn(&self->lexer,
lex_mode.lex_state);
ts_lexer_finish(&self->lexer, &lookahead_end_byte);
if (found_token)
@ -104,16 +104,16 @@ t_subtree ts_parser__lex(TSParser *self, t_stack_version version,
skipped_error = true;
error_start_position = self->lexer.token_start_position;
error_end_position = self->lexer.token_start_position;
first_error_character = self->lexer.data.lookahead;
first_error_character = self->lexer.funcs.lookahead;
}
if (self->lexer.current_position.bytes == error_end_position.bytes)
{
if (self->lexer.data.eof(&self->lexer.data))
if (self->lexer.funcs.eof(&self->lexer))
{
self->lexer.data.result_symbol = ts_builtin_sym_error;
self->lexer.funcs.result_symbol = ts_builtin_sym_error;
break ;
}
self->lexer.data.advance(&self->lexer.data, false);
self->lexer.funcs.advance(&self->lexer, false);
}
error_end_position = self->lexer.current_position;
}
@ -128,7 +128,7 @@ t_subtree ts_parser__lex(TSParser *self, t_stack_version version,
else
{
is_keyword = false;
symbol = self->lexer.data.result_symbol;
symbol = self->lexer.funcs.result_symbol;
padding = length_sub(self->lexer.token_start_position, start_position);
size = length_sub(self->lexer.token_end_position,
self->lexer.token_start_position);
@ -143,12 +143,12 @@ t_subtree ts_parser__lex(TSParser *self, t_stack_version version,
end_byte = self->lexer.token_end_position.bytes;
ts_lexer_reset(&self->lexer, self->lexer.token_start_position);
ts_lexer_start(&self->lexer);
is_keyword = self->language->keyword_lex_fn(&self->lexer.data, 0);
is_keyword = self->language->keyword_lex_fn(&self->lexer, 0);
if (is_keyword && self->lexer.token_end_position.bytes == end_byte
&& ts_language_has_actions(self->language, parse_state,
self->lexer.data.result_symbol))
self->lexer.funcs.result_symbol))
{
symbol = self->lexer.data.result_symbol;
symbol = self->lexer.funcs.result_symbol;
}
}
result = ts_subtree_new_leaf((t_st_newleaf_args){symbol, padding, size, lookahead_bytes,

8
parser/src/parser/parser_lifetime.c
View file

@ -12,9 +12,9 @@
#include "parser/inner/parser_inner.h"
TSParser *ts_parser_new(TSLanguage *language)
t_parser *ts_parser_new(t_language *language)
{
TSParser *self;
t_parser *self;
self = mem_alloc(sizeof(*self));
ts_lexer_init(&self->lexer);
@ -28,7 +28,7 @@ TSParser *ts_parser_new(TSLanguage *language)
return (self);
}
void ts_parser_delete(TSParser *self)
void ts_parser_delete(t_parser *self)
{
if (!self)
return ;
@ -42,7 +42,7 @@ void ts_parser_delete(TSParser *self)
mem_free(self);
}
void ts_parser_reset(TSParser *self)
void ts_parser_reset(t_parser *self)
{
ts_parser__external_scanner_destroy(self);
ts_lexer_reset(&self->lexer, length_zero());

2
parser/src/parser/parser_outstanding_parse.c
View file

@ -12,7 +12,7 @@
#include "parser/inner/parser_inner.h"
bool ts_parser_has_outstanding_parse(TSParser *self)
bool ts_parser_has_outstanding_parse(t_parser *self)
{
return (self->external_scanner_payload || ts_stack_state(self->stack,
0) != 1 || ts_stack_node_count_since_error(self->stack, 0) != 0);

6
parser/src/parser/parser_parse.c
View file

@ -12,16 +12,16 @@
#include "parser/inner/parser_inner.h"
bool _parse_condition(TSParser *self, t_u32 *version_count,
bool _parse_condition(t_parser *self, t_u32 *version_count,
t_stack_version *version)
{
*version_count = ts_stack_version_count(self->stack);
return (*version < *version_count);
}
TSTree *ts_parser_parse(TSParser *self, TSInput input)
t_tree *ts_parser_parse(t_parser *self, t_input input)
{
TSTree *result;
t_tree *result;
t_u32 position;
t_u32 last_position;
t_u32 version_count;

6
parser/src/parser/parser_parse_str.c
View file

@ -12,7 +12,7 @@
#include "parser/inner/parser_inner.h"
const t_u8 *ts_string_input_read(void *_self, t_u32 byte, TSPoint point,
const t_u8 *ts_string_input_read(void *_self, t_u32 byte, t_point point,
t_u32 *length)
{
t_string_input *self;
@ -31,12 +31,12 @@ const t_u8 *ts_string_input_read(void *_self, t_u32 byte, TSPoint point,
}
}
TSTree *ts_parser_parse_string(TSParser *self, t_const_str string,
t_tree *ts_parser_parse_string(t_parser *self, t_const_str string,
t_u32 length)
{
t_string_input input;
input = (t_string_input){(const t_u8 *)string, length};
return (ts_parser_parse(self, \
(TSInput){&input, ts_string_input_read}));
(t_input){&input, ts_string_input_read}));
}

12
parser/src/parser/parser_recover.c
View file

@ -6,16 +6,16 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/09/13 13:46:43 by maiboyer #+# #+# */
/* Updated: 2024/09/13 13:47:27 by maiboyer ### ########.fr */
/* Updated: 2024/09/19 17:18:36 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#include "parser/inner/parser_inner.h"
void ts_parser__recover(TSParser *self, t_stack_version version,
void ts_parser__recover(t_parser *self, t_stack_version version,
t_subtree lookahead)
{
Length position;
t_length position;
bool did_recover;
bool would_merge;
t_stack_slice_array pop;
@ -123,7 +123,8 @@ void ts_parser__recover(TSParser *self, t_stack_version version,
{
children = vec_subtree_new(16, NULL);
parent = ts_subtree_new_error_node(&children, false, self->language);
ts_stack_push(self->stack, version, parent, false, 1);
ts_stack_push(self->stack, \
(struct s_stack_push_arg){version, parent, false, 1});
ts_parser__accept(self, version, lookahead);
return ;
}
@ -169,7 +170,8 @@ void ts_parser__recover(TSParser *self, t_stack_version version,
error_repeat = ts_subtree_new_node(ts_builtin_sym_error_repeat,
&pop.contents[0].subtrees, 0, self->language);
}
ts_stack_push(self->stack, version, (error_repeat), false, ERROR_STATE);
ts_stack_push(self->stack, \
(struct s_stack_push_arg){version, (error_repeat), false, ERROR_STATE});
if (ts_subtree_has_external_tokens(lookahead))
ts_stack_set_last_external_token(self->stack, version,
ts_subtree_last_external_token(lookahead));

12
parser/src/parser/parser_recover_to_tree.c
View file

@ -6,14 +6,14 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/09/13 13:48:22 by maiboyer #+# #+# */
/* Updated: 2024/09/13 13:48:25 by maiboyer ### ########.fr */
/* Updated: 2024/09/19 17:23:55 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#include "parser/inner/parser_inner.h"
bool ts_parser__recover_to_state(TSParser *self, t_stack_version version,
t_u32 depth, TSStateId goal_state)
bool ts_parser__recover_to_state(t_parser *self, t_stack_version version,
t_u32 depth, t_state_id goal_state)
{
t_stack_slice slice;
t_stack_slice_array pop;
@ -71,7 +71,7 @@ bool ts_parser__recover_to_state(TSParser *self, t_stack_version version,
{
error = ts_subtree_new_error_node(&slice.subtrees, true,
self->language);
ts_stack_push(self->stack, slice.version, error, false, goal_state);
ts_stack_push(self->stack, (struct s_stack_push_arg){slice.version, error, false, goal_state});
}
else
{
@ -81,11 +81,11 @@ bool ts_parser__recover_to_state(TSParser *self, t_stack_version version,
while (j < self->trailing_extras.len)
{
tree = self->trailing_extras.buffer[j];
ts_stack_push(self->stack, slice.version, tree, false, goal_state);
ts_stack_push(self->stack, (struct s_stack_push_arg){slice.version, tree, false, goal_state});
j++;
}
previous_version = slice.version;
i++;
}
return (previous_version != STACK_VERSION_NONE);
return (previous_version != (t_stack_version)STACK_VERSION_NONE);
}

16
parser/src/parser/parser_reduce.c
View file

@ -6,18 +6,18 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/09/13 14:03:09 by maiboyer #+# #+# */
/* Updated: 2024/09/13 14:03:18 by maiboyer ### ########.fr */
/* Updated: 2024/09/19 17:20:24 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#include "parser/inner/parser_inner.h"
t_stack_version ts_parser__reduce(TSParser *self, t_stack_version version,
TSSymbol symbol, t_u32 count, int dynamic_precedence,
t_stack_version ts_parser__reduce(t_parser *self, t_stack_version version,
t_symbol symbol, t_u32 count, int dynamic_precedence,
t_u16 production_id, bool is_fragile, bool end_of_non_terminal_extra)
{
TSStateId next_state;
TSStateId state;
t_state_id next_state;
t_state_id state;
t_stack_slice next_slice;
t_stack_slice slice;
t_stack_slice_array pop;
@ -97,12 +97,12 @@ t_stack_version ts_parser__reduce(TSParser *self, t_stack_version version,
else
parent->parse_state = state;
parent->dynamic_precedence += dynamic_precedence;
ts_stack_push(self->stack, slice_version, (parent), false, next_state);
ts_stack_push(self->stack, (struct s_stack_push_arg){slice_version, (parent), false, next_state});
j = 0;
while (j < self->trailing_extras.len)
{
ts_stack_push(self->stack, slice_version,
self->trailing_extras.buffer[j], false, next_state);
ts_stack_push(self->stack, (struct s_stack_push_arg){slice_version,
self->trailing_extras.buffer[j], false, next_state});
j++;
}
k = 0;

4
parser/src/parser/parser_select.c
View file

@ -18,7 +18,7 @@
// 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.
bool ts_parser__select_tree(TSParser *self, t_subtree left, t_subtree right)
bool ts_parser__select_tree(t_parser *self, t_subtree left, t_subtree right)
{
int comparison;
@ -45,7 +45,7 @@ bool ts_parser__select_tree(TSParser *self, t_subtree left, t_subtree right)
// Determine if a given tree's children should be replaced
// by an alternative array of children.
bool ts_parser__select_children(TSParser *self, t_subtree left,
bool ts_parser__select_children(t_parser *self, t_subtree left,
const t_vec_subtree *children)
{
t_subtree scratch_tree;

8
parser/src/parser/parser_shift.c
View file

@ -6,14 +6,14 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/09/13 13:55:29 by maiboyer #+# #+# */
/* Updated: 2024/09/13 13:55:49 by maiboyer ### ########.fr */
/* Updated: 2024/09/19 17:20:02 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#include "parser/inner/parser_inner.h"
void ts_parser__shift(TSParser *self, t_stack_version version,
TSStateId state, t_subtree lookahead, bool extra)
void ts_parser__shift(t_parser *self, t_stack_version version,
t_state_id state, t_subtree lookahead, bool extra)
{
bool is_leaf;
t_subtree result;
@ -27,7 +27,7 @@ void ts_parser__shift(TSParser *self, t_stack_version version,
ts_subtree_set_extra(&result, extra);
subtree_to_push = (result);
}
ts_stack_push(self->stack, version, subtree_to_push, !is_leaf, state);
ts_stack_push(self->stack,(struct s_stack_push_arg){ version, subtree_to_push, !is_leaf, state});
if (ts_subtree_has_external_tokens(subtree_to_push))
ts_stack_set_last_external_token(self->stack, version,
ts_subtree_last_external_token(subtree_to_push));

8
parser/src/parser/parser_versions.c
View file

@ -12,7 +12,7 @@
#include "parser/inner/parser_inner.h"
t_error_comparison ts_parser__compare_versions(TSParser *self,
t_error_comparison ts_parser__compare_versions(t_parser *self,
t_error_status a, t_error_status b)
{
(void)self;
@ -51,7 +51,7 @@ t_error_comparison ts_parser__compare_versions(TSParser *self,
return (ECNone);
}
t_error_status ts_parser__version_status(TSParser *self,
t_error_status ts_parser__version_status(t_parser *self,
t_stack_version version)
{
t_u32 cost;
@ -68,11 +68,11 @@ t_error_status ts_parser__version_status(TSParser *self,
version) == ERROR_STATE});
}
bool ts_parser__better_version_exists(TSParser *self,
bool ts_parser__better_version_exists(t_parser *self,
t_stack_version version, bool is_in_error, t_u32 cost)
{
t_error_status status_i;
Length position;
t_length position;
t_error_status status;
t_stack_version i;
t_stack_version n;

12
parser/src/point/point_funcs1.c
View file

@ -12,12 +12,12 @@
#include "parser/point.h"
TSPoint point__new(t_u32 row, t_u32 column)
t_point point__new(t_u32 row, t_u32 column)
{
return ((TSPoint){row, column});
return ((t_point){row, column});
}
TSPoint point_add(TSPoint a, TSPoint b)
t_point point_add(t_point a, t_point b)
{
if (b.row > 0)
return (point__new(a.row + b.row, b.column));
@ -25,7 +25,7 @@ TSPoint point_add(TSPoint a, TSPoint b)
return (point__new(a.row, a.column + b.column));
}
TSPoint point_sub(TSPoint a, TSPoint b)
t_point point_sub(t_point a, t_point b)
{
if (a.row > b.row)
return (point__new(a.row - b.row, a.column));
@ -33,12 +33,12 @@ TSPoint point_sub(TSPoint a, TSPoint b)
return (point__new(0, a.column - b.column));
}
bool point_lte(TSPoint a, TSPoint b)
bool point_lte(t_point a, t_point b)
{
return ((a.row < b.row) || (a.row == b.row && a.column <= b.column));
}
bool point_lt(TSPoint a, TSPoint b)
bool point_lt(t_point a, t_point b)
{
return ((a.row < b.row) || (a.row == b.row && a.column < b.column));
}

10
parser/src/point/point_funcs2.c
View file

@ -12,22 +12,22 @@
#include "parser/point.h"
bool point_gt(TSPoint a, TSPoint b)
bool point_gt(t_point a, t_point b)
{
return ((a.row > b.row) || (a.row == b.row && a.column > b.column));
}
bool point_gte(TSPoint a, TSPoint b)
bool point_gte(t_point a, t_point b)
{
return ((a.row > b.row) || (a.row == b.row && a.column >= b.column));
}
bool point_eq(TSPoint a, TSPoint b)
bool point_eq(t_point a, t_point b)
{
return (a.row == b.row && a.column == b.column);
}
TSPoint point_min(TSPoint a, TSPoint b)
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);
@ -35,7 +35,7 @@ TSPoint point_min(TSPoint a, TSPoint b)
return (b);
}
TSPoint point_max(TSPoint a, TSPoint b)
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);

34
parser/src/scanner/scan.c
View file

@ -39,16 +39,16 @@ void tree_sitter_sh_external_scanner_destroy(void *payload);
bool scan_bare_dollar(t_lexer *lexer)
{
while (me_isspace(lexer->data.lookahead) && lexer->data.lookahead != '\n'
&& !lexer->data.eof((void *)lexer))
lexer->data.advance((void *)lexer, true);
if (lexer->data.lookahead == '$')
while (me_isspace(lexer->funcs.lookahead) && lexer->funcs.lookahead != '\n'
&& !lexer->funcs.eof((void *)lexer))
lexer->funcs.advance((void *)lexer, true);
if (lexer->funcs.lookahead == '$')
{
lexer->data.advance((void *)lexer, false);
lexer->data.result_symbol = BARE_DOLLAR;
lexer->data.mark_end((void *)lexer);
return (me_isspace(lexer->data.lookahead)
|| lexer->data.eof((void *)lexer) || lexer->data.lookahead == '\"');
lexer->funcs.advance((void *)lexer, false);
lexer->funcs.result_symbol = BARE_DOLLAR;
lexer->funcs.mark_end((void *)lexer);
return (me_isspace(lexer->funcs.lookahead)
|| lexer->funcs.eof((void *)lexer) || lexer->funcs.lookahead == '\"');
}
return (false);
}
@ -62,17 +62,17 @@ bool scan_double_hash(t_scanner *scanner, t_lexer *lexer,
if (valid_symbols[IMMEDIATE_DOUBLE_HASH]
&& !(valid_symbols[ERROR_RECOVERY]))
{
if (lexer->data.lookahead == '#')
if (lexer->funcs.lookahead == '#')
{
lexer->data.mark_end((void *)lexer);
lexer->data.advance((void *)lexer, false);
if (lexer->data.lookahead == '#')
lexer->funcs.mark_end((void *)lexer);
lexer->funcs.advance((void *)lexer, false);
if (lexer->funcs.lookahead == '#')
{
lexer->data.advance((void *)lexer, false);
if (lexer->data.lookahead != '}')
lexer->funcs.advance((void *)lexer, false);
if (lexer->funcs.lookahead != '}')
{
lexer->data.result_symbol = IMMEDIATE_DOUBLE_HASH;
lexer->data.mark_end((void *)lexer);
lexer->funcs.result_symbol = IMMEDIATE_DOUBLE_HASH;
lexer->funcs.mark_end((void *)lexer);
return (true);
}
}

222
parser/src/scanner/scanner.c
View file

@ -50,15 +50,15 @@ bool scan_concat(t_scanner *scanner, t_lexer *lexer,
(void)(scanner);
(void)(lexer);
(void)(valid_symbols);
lexer->data.result_symbol = CONCAT;
if (lexer->data.lookahead == '\\')
lexer->funcs.result_symbol = CONCAT;
if (lexer->funcs.lookahead == '\\')
{
lexer->data.mark_end((void *)lexer);
lexer->data.advance((void *)lexer, false);
if (lexer->data.lookahead == '"' || lexer->data.lookahead == '\''
|| lexer->data.lookahead == '\\')
lexer->funcs.mark_end((void *)lexer);
lexer->funcs.advance((void *)lexer, false);
if (lexer->funcs.lookahead == '"' || lexer->funcs.lookahead == '\''
|| lexer->funcs.lookahead == '\\')
return (true);
if (lexer->data.eof((void *)lexer))
if (lexer->funcs.eof((void *)lexer))
return (false);
}
return (true);
@ -77,76 +77,76 @@ bool scan_advance_words(t_scanner *scanner, t_lexer *lexer,
(void)(valid_symbols);
while (true)
{
if (lexer->data.lookahead == '\"')
if (lexer->funcs.lookahead == '\"')
return (false);
if (lexer->data.lookahead == '$')
if (lexer->funcs.lookahead == '$')
{
lexer->data.mark_end((void *)lexer);
lexer->data.advance((void *)lexer, false);
if (lexer->data.lookahead == '{' || lexer->data.lookahead == '('
|| lexer->data.lookahead == '\''
|| me_isalnum(lexer->data.lookahead))
lexer->funcs.mark_end((void *)lexer);
lexer->funcs.advance((void *)lexer, false);
if (lexer->funcs.lookahead == '{' || lexer->funcs.lookahead == '('
|| lexer->funcs.lookahead == '\''
|| me_isalnum(lexer->funcs.lookahead))
{
lexer->data.result_symbol = EXPANSION_WORD;
lexer->funcs.result_symbol = EXPANSION_WORD;
return (advanced_once);
}
advanced_once = true;
}
if (lexer->data.lookahead == '}')
if (lexer->funcs.lookahead == '}')
{
lexer->data.mark_end((void *)lexer);
lexer->data.result_symbol = EXPANSION_WORD;
lexer->funcs.mark_end((void *)lexer);
lexer->funcs.result_symbol = EXPANSION_WORD;
return (advanced_once || advance_once_space);
}
if (lexer->data.lookahead == '(' && !(advanced_once
if (lexer->funcs.lookahead == '(' && !(advanced_once
|| advance_once_space))
{
lexer->data.mark_end((void *)lexer);
lexer->data.advance((void *)lexer, false);
while (lexer->data.lookahead != ')'
&& !lexer->data.eof((void *)lexer))
lexer->funcs.mark_end((void *)lexer);
lexer->funcs.advance((void *)lexer, false);
while (lexer->funcs.lookahead != ')'
&& !lexer->funcs.eof((void *)lexer))
{
if (lexer->data.lookahead == '$')
if (lexer->funcs.lookahead == '$')
{
lexer->data.mark_end((void *)lexer);
lexer->data.advance((void *)lexer, false);
if (lexer->data.lookahead == '{'
|| lexer->data.lookahead == '('
|| lexer->data.lookahead == '\''
|| me_isalnum(lexer->data.lookahead))
return (lexer->data.result_symbol = EXPANSION_WORD,
lexer->funcs.mark_end((void *)lexer);
lexer->funcs.advance((void *)lexer, false);
if (lexer->funcs.lookahead == '{'
|| lexer->funcs.lookahead == '('
|| lexer->funcs.lookahead == '\''
|| me_isalnum(lexer->funcs.lookahead))
return (lexer->funcs.result_symbol = EXPANSION_WORD,
advanced_once);
advanced_once = true;
}
else
{
advanced_once = advanced_once
|| !me_isspace(lexer->data.lookahead);
|| !me_isspace(lexer->funcs.lookahead);
advance_once_space = advance_once_space
|| me_isspace(lexer->data.lookahead);
lexer->data.advance((void *)lexer, false);
|| me_isspace(lexer->funcs.lookahead);
lexer->funcs.advance((void *)lexer, false);
}
}
lexer->data.mark_end((void *)lexer);
if (lexer->data.lookahead == ')')
lexer->funcs.mark_end((void *)lexer);
if (lexer->funcs.lookahead == ')')
{
advanced_once = true;
lexer->data.advance((void *)lexer, false);
lexer->data.mark_end((void *)lexer);
if (lexer->data.lookahead == '}')
lexer->funcs.advance((void *)lexer, false);
lexer->funcs.mark_end((void *)lexer);
if (lexer->funcs.lookahead == '}')
return (false);
}
else
return (false);
}
if (lexer->data.lookahead == '\'')
if (lexer->funcs.lookahead == '\'')
return (false);
if (lexer->data.eof((void *)lexer))
if (lexer->funcs.eof((void *)lexer))
return (false);
advanced_once = advanced_once || !me_isspace(lexer->data.lookahead);
advanced_once = advanced_once || !me_isspace(lexer->funcs.lookahead);
advance_once_space = advance_once_space
|| me_isspace(lexer->data.lookahead);
lexer->data.advance((void *)lexer, false);
|| me_isspace(lexer->funcs.lookahead);
lexer->funcs.advance((void *)lexer, false);
}
return (false);
}
@ -158,27 +158,27 @@ bool scan_literals(t_scanner *scanner, t_lexer *lexer,
while (true)
{
if ((lexer->data.lookahead == ' ' || lexer->data.lookahead == '\t'
|| lexer->data.lookahead == '\r'
|| (lexer->data.lookahead == '\n' && !valid_symbols[NEWLINE]))
if ((lexer->funcs.lookahead == ' ' || lexer->funcs.lookahead == '\t'
|| lexer->funcs.lookahead == '\r'
|| (lexer->funcs.lookahead == '\n' && !valid_symbols[NEWLINE]))
&& !valid_symbols[EXPANSION_WORD])
lexer->data.advance((void *)lexer, true);
else if (lexer->data.lookahead == '\\')
lexer->funcs.advance((void *)lexer, true);
else if (lexer->funcs.lookahead == '\\')
{
lexer->data.advance((void *)lexer, true);
if (lexer->data.eof((void *)lexer))
lexer->funcs.advance((void *)lexer, true);
if (lexer->funcs.eof((void *)lexer))
{
lexer->data.mark_end((void *)lexer);
lexer->data.result_symbol = VARIABLE_NAME;
lexer->funcs.mark_end((void *)lexer);
lexer->funcs.result_symbol = VARIABLE_NAME;
return (true);
}
if (lexer->data.lookahead == '\r')
lexer->data.advance((void *)lexer, true);
if (lexer->data.lookahead == '\n')
lexer->data.advance((void *)lexer, true);
if (lexer->funcs.lookahead == '\r')
lexer->funcs.advance((void *)lexer, true);
if (lexer->funcs.lookahead == '\n')
lexer->funcs.advance((void *)lexer, true);
else
{
if (lexer->data.lookahead == '\\'
if (lexer->funcs.lookahead == '\\'
&& valid_symbols[EXPANSION_WORD])
return (scan_advance_words(scanner, lexer, valid_symbols));
return (false);
@ -187,36 +187,36 @@ bool scan_literals(t_scanner *scanner, t_lexer *lexer,
else
break ;
}
if (!valid_symbols[EXPANSION_WORD] && (lexer->data.lookahead == '*'
|| lexer->data.lookahead == '@' || lexer->data.lookahead == '?'
|| lexer->data.lookahead == '-' || lexer->data.lookahead == '0'
|| lexer->data.lookahead == '_'))
if (!valid_symbols[EXPANSION_WORD] && (lexer->funcs.lookahead == '*'
|| lexer->funcs.lookahead == '@' || lexer->funcs.lookahead == '?'
|| lexer->funcs.lookahead == '-' || lexer->funcs.lookahead == '0'
|| lexer->funcs.lookahead == '_'))
{
lexer->data.mark_end((void *)lexer);
lexer->data.advance((void *)lexer, false);
if (lexer->data.lookahead == '=' || lexer->data.lookahead == '['
|| lexer->data.lookahead == ':' || lexer->data.lookahead == '-'
|| lexer->data.lookahead == '%' || lexer->data.lookahead == '#'
|| lexer->data.lookahead == '/')
lexer->funcs.mark_end((void *)lexer);
lexer->funcs.advance((void *)lexer, false);
if (lexer->funcs.lookahead == '=' || lexer->funcs.lookahead == '['
|| lexer->funcs.lookahead == ':' || lexer->funcs.lookahead == '-'
|| lexer->funcs.lookahead == '%' || lexer->funcs.lookahead == '#'
|| lexer->funcs.lookahead == '/')
return (false);
if (valid_symbols[EXTGLOB_PATTERN] && me_isspace(lexer->data.lookahead))
if (valid_symbols[EXTGLOB_PATTERN] && me_isspace(lexer->funcs.lookahead))
{
lexer->data.mark_end((void *)lexer);
lexer->data.result_symbol = EXTGLOB_PATTERN;
lexer->funcs.mark_end((void *)lexer);
lexer->funcs.result_symbol = EXTGLOB_PATTERN;
return (true);
}
}
is_number = true;
if (me_isdigit(lexer->data.lookahead))
lexer->data.advance((void *)lexer, false);
else if (me_isalpha(lexer->data.lookahead) || lexer->data.lookahead == '_')
if (me_isdigit(lexer->funcs.lookahead))
lexer->funcs.advance((void *)lexer, false);
else if (me_isalpha(lexer->funcs.lookahead) || lexer->funcs.lookahead == '_')
{
is_number = false;
lexer->data.advance((void *)lexer, false);
lexer->funcs.advance((void *)lexer, false);
}
else
{
if (lexer->data.lookahead == '{')
if (lexer->funcs.lookahead == '{')
return (false);
if (valid_symbols[EXPANSION_WORD])
return (scan_advance_words(scanner, lexer, valid_symbols));
@ -224,48 +224,48 @@ bool scan_literals(t_scanner *scanner, t_lexer *lexer,
}
while (true)
{
if (me_isdigit(lexer->data.lookahead))
lexer->data.advance((void *)lexer, false);
else if (me_isalpha(lexer->data.lookahead)
|| lexer->data.lookahead == '_')
if (me_isdigit(lexer->funcs.lookahead))
lexer->funcs.advance((void *)lexer, false);
else if (me_isalpha(lexer->funcs.lookahead)
|| lexer->funcs.lookahead == '_')
{
is_number = false;
lexer->data.advance((void *)lexer, false);
lexer->funcs.advance((void *)lexer, false);
}
else
break ;
}
if (is_number && valid_symbols[FILE_DESCRIPTOR]
&& (lexer->data.lookahead == '>' || lexer->data.lookahead == '<'))
return (lexer->data.result_symbol = FILE_DESCRIPTOR, true);
&& (lexer->funcs.lookahead == '>' || lexer->funcs.lookahead == '<'))
return (lexer->funcs.result_symbol = FILE_DESCRIPTOR, true);
if (valid_symbols[VARIABLE_NAME])
{
if (lexer->data.lookahead == '+')
if (lexer->funcs.lookahead == '+')
{
lexer->data.mark_end((void *)lexer);
lexer->data.advance((void *)lexer, false);
if (lexer->data.lookahead == '=' || lexer->data.lookahead == ':')
return (lexer->data.result_symbol = VARIABLE_NAME, true);
lexer->funcs.mark_end((void *)lexer);
lexer->funcs.advance((void *)lexer, false);
if (lexer->funcs.lookahead == '=' || lexer->funcs.lookahead == ':')
return (lexer->funcs.result_symbol = VARIABLE_NAME, true);
return (false);
}
if (lexer->data.lookahead == '/')
if (lexer->funcs.lookahead == '/')
return (false);
if (lexer->data.lookahead == '=' || lexer->data.lookahead == '['
|| (lexer->data.lookahead == ':' && !valid_symbols[OPENING_PAREN])
|| lexer->data.lookahead == '%' || (lexer->data.lookahead == '#'
&& !is_number) || lexer->data.lookahead == '@'
|| (lexer->data.lookahead == '-'))
if (lexer->funcs.lookahead == '=' || lexer->funcs.lookahead == '['
|| (lexer->funcs.lookahead == ':' && !valid_symbols[OPENING_PAREN])
|| lexer->funcs.lookahead == '%' || (lexer->funcs.lookahead == '#'
&& !is_number) || lexer->funcs.lookahead == '@'
|| (lexer->funcs.lookahead == '-'))
{
lexer->data.mark_end((void *)lexer);
lexer->data.result_symbol = VARIABLE_NAME;
lexer->funcs.mark_end((void *)lexer);
lexer->funcs.result_symbol = VARIABLE_NAME;
return (true);
}
if (lexer->data.lookahead == '?')
if (lexer->funcs.lookahead == '?')
{
lexer->data.mark_end((void *)lexer);
lexer->data.advance((void *)lexer, false);
lexer->data.result_symbol = VARIABLE_NAME;
return (me_isalpha(lexer->data.lookahead));
lexer->funcs.mark_end((void *)lexer);
lexer->funcs.advance((void *)lexer, false);
lexer->funcs.result_symbol = VARIABLE_NAME;
return (me_isalpha(lexer->funcs.lookahead));
}
}
return (false);
@ -274,19 +274,19 @@ bool scan_literals(t_scanner *scanner, t_lexer *lexer,
bool scan(t_scanner *scanner, t_lexer *lexer, const bool *valid_symbols)
{
if (valid_symbols[CONCAT] && !(valid_symbols[ERROR_RECOVERY])
&& (!(lexer->data.lookahead == 0 || me_isspace(lexer->data.lookahead)
|| lexer->data.lookahead == '>' || lexer->data.lookahead == '<'
|| lexer->data.lookahead == ')' || lexer->data.lookahead == '('
|| lexer->data.lookahead == ';' || lexer->data.lookahead == '&'
|| lexer->data.lookahead == '|' || lexer->data.lookahead == '{'
|| lexer->data.lookahead == '}')))
&& (!(lexer->funcs.lookahead == 0 || me_isspace(lexer->funcs.lookahead)
|| lexer->funcs.lookahead == '>' || lexer->funcs.lookahead == '<'
|| lexer->funcs.lookahead == ')' || lexer->funcs.lookahead == '('
|| lexer->funcs.lookahead == ';' || lexer->funcs.lookahead == '&'
|| lexer->funcs.lookahead == '|' || lexer->funcs.lookahead == '{'
|| lexer->funcs.lookahead == '}')))
return (scan_concat(scanner, lexer, valid_symbols));
if (scan_double_hash(scanner, lexer, valid_symbols))
return (true);
if (valid_symbols[EMPTY_VALUE] && (me_isspace(lexer->data.lookahead)
|| lexer->data.eof((void *)lexer) || lexer->data.lookahead == ';'
|| lexer->data.lookahead == '&'))
return (lexer->data.result_symbol = EMPTY_VALUE, true);
if (valid_symbols[EMPTY_VALUE] && (me_isspace(lexer->funcs.lookahead)
|| lexer->funcs.eof((void *)lexer) || lexer->funcs.lookahead == ';'
|| lexer->funcs.lookahead == '&'))
return (lexer->funcs.result_symbol = EMPTY_VALUE, true);
if ((valid_symbols[VARIABLE_NAME] || valid_symbols[FILE_DESCRIPTOR])
&& !(valid_symbols[ERROR_RECOVERY]))
return (scan_literals(scanner, lexer, valid_symbols));

28
parser/src/scanner/serialize.c
View file

@ -45,29 +45,29 @@ bool advance_word(t_lexer *lexer, t_string *unquoted_word)
empty = true;
quote = 0;
if (lexer->data.lookahead == '\'' || lexer->data.lookahead == '"')
if (lexer->funcs.lookahead == '\'' || lexer->funcs.lookahead == '"')
{
quote = lexer->data.lookahead;
lexer->data.advance((void *)lexer, false);
quote = lexer->funcs.lookahead;
lexer->funcs.advance((void *)lexer, false);
}
while (lexer->data.lookahead && !((quote && (lexer->data.lookahead == quote
|| lexer->data.lookahead == '\r'
|| lexer->data.lookahead == '\n')) || (!quote
&& me_isspace(lexer->data.lookahead))))
while (lexer->funcs.lookahead && !((quote && (lexer->funcs.lookahead == quote
|| lexer->funcs.lookahead == '\r'
|| lexer->funcs.lookahead == '\n')) || (!quote
&& me_isspace(lexer->funcs.lookahead))))
{
if (lexer->data.lookahead == '\\')
if (lexer->funcs.lookahead == '\\')
{
lexer->data.advance((void *)lexer, false);
if (!lexer->data.lookahead)
lexer->funcs.advance((void *)lexer, false);
if (!lexer->funcs.lookahead)
return (false);
}
empty = false;
string_push_char(unquoted_word, lexer->data.lookahead);
lexer->data.advance((void *)lexer, false);
string_push_char(unquoted_word, lexer->funcs.lookahead);
lexer->funcs.advance((void *)lexer, false);
}
string_push_char(unquoted_word, '\0');
if (quote && lexer->data.lookahead == quote)
lexer->data.advance((void *)lexer, false);
if (quote && lexer->funcs.lookahead == quote)
lexer->funcs.advance((void *)lexer, false);
return (!empty);
}

4
parser/src/stack/stack_add_link.c
View file

@ -10,8 +10,8 @@
/* */
/* ************************************************************************** */
#include "parser/stack.h"
#include "parser/inner/stack.h"
#include "parser/inner/stack_inner.h"
#include "parser/inner/stack_inner.h"
// In general,
// we preserve ambiguities until they are removed from the stack

4
parser/src/stack/stack_funcs1.c
View file

@ -10,8 +10,8 @@
/* */
/* ************************************************************************** */
#include "parser/stack.h"
#include "parser/inner/stack.h"
#include "parser/inner/stack_inner.h"
#include "parser/inner/stack_inner.h"
bool ts_stack_is_active(const t_stack *self, t_stack_version version)
{

4
parser/src/stack/stack_funcs2.c
View file

@ -10,8 +10,8 @@
/* */
/* ************************************************************************** */
#include "parser/stack.h"
#include "parser/inner/stack.h"
#include "parser/inner/stack_inner.h"
#include "parser/inner/stack_inner.h"
t_u32 ts_stack_error_cost(const t_stack *self, t_stack_version version)
{

4
parser/src/stack/stack_funcs3.c
View file

@ -10,8 +10,8 @@
/* */
/* ************************************************************************** */
#include "parser/stack.h"
#include "parser/inner/stack.h"
#include "parser/inner/stack_inner.h"
#include "parser/inner/stack_inner.h"
bool stack__subtree_is_equivalent(t_subtree left, t_subtree right)
{

8
parser/src/stack/stack_funcs4.c
View file

@ -10,20 +10,20 @@
/* */
/* ************************************************************************** */
#include "parser/stack.h"
#include "parser/inner/stack.h"
#include "parser/inner/stack_inner.h"
#include "parser/inner/stack_inner.h"
t_u32 ts_stack_version_count(const t_stack *self)
{
return (self->heads.size);
}
TSStateId ts_stack_state(const t_stack *self, t_stack_version version)
t_state_id ts_stack_state(const t_stack *self, t_stack_version version)
{
return (array_get(&self->heads, version)->node->state);
}
Length ts_stack_position(const t_stack *self, t_stack_version version)
t_length ts_stack_position(const t_stack *self, t_stack_version version)
{
return (array_get(&self->heads, version)->node->position);
}

4
parser/src/stack/stack_iter.c
View file

@ -11,8 +11,8 @@
/* ************************************************************************** */
#include "me/vec/vec_subtree.h"
#include "parser/inner/stack.h"
#include "parser/stack.h"
#include "parser/inner/stack_inner.h"
#include "parser/inner/stack_inner.h"
t_stack_slice_array stack__iter(t_stack *self, t_stack_version version,
t_stack_callback callback, void *payload, int goal_subtree_count)

4
parser/src/stack/stack_lifetime.c
View file

@ -10,8 +10,8 @@
/* */
/* ************************************************************************** */
#include "parser/inner/stack.h"
#include "parser/stack.h"
#include "parser/inner/stack_inner.h"
#include "parser/inner/stack_inner.h"
t_stack *ts_stack_new(void)
{

13
parser/src/stack/stack_manipulate.c
View file

@ -6,22 +6,21 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/08/31 16:50:04 by maiboyer #+# #+# */
/* Updated: 2024/08/31 17:00:34 by maiboyer ### ########.fr */
/* Updated: 2024/09/19 14:44:37 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#include "parser/inner/stack.h"
#include "parser/inner/stack_inner.h"
#include "parser/language.h"
void ts_stack_push(t_stack *self, t_stack_version version, t_subtree subtree,
bool pending, TSStateId state)
void ts_stack_push(t_stack *self, struct s_stack_push_arg args)
{
t_stack_head *head;
t_stack_node *new_node;
head = array_get(&self->heads, version);
new_node = stack_node_new(head->node, subtree, pending, state);
if (!subtree)
head = array_get(&self->heads, args.version);
new_node = stack_node_new(head->node, args.subtree, args.pending, args.state);
if (!args.subtree)
head->node_count_at_last_error = new_node->node_count;
head->node = new_node;
}

4
parser/src/stack/stack_manipulate2.c
View file

@ -11,8 +11,8 @@
/* ************************************************************************** */
#include "me/types.h"
#include "parser/stack.h"
#include "parser/inner/stack.h"
#include "parser/inner/stack_inner.h"
#include "parser/inner/stack_inner.h"
bool ts_stack_merge(t_stack *self, t_stack_version version1,
t_stack_version version2)

4
parser/src/stack/stack_manipulate3.c
View file

@ -10,8 +10,8 @@
/* */
/* ************************************************************************** */
#include "parser/stack.h"
#include "parser/inner/stack.h"
#include "parser/inner/stack_inner.h"
#include "parser/inner/stack_inner.h"
t_stack_action pop_error_callback(void *payload,
const t_stack_iterator *iterator)

6
parser/src/stack/stack_node.c
View file

@ -10,9 +10,9 @@
/* */
/* ************************************************************************** */
#include "parser/inner/stack.h"
#include "parser/inner/stack_inner.h"
#include "parser/language.h"
#include "parser/stack.h"
#include "parser/inner/stack_inner.h"
void stack_node_retain(t_stack_node *self)
{
@ -83,7 +83,7 @@ t_u32 stack__subtree_node_count(t_subtree subtree)
}
t_stack_node *stack_node_new(t_stack_node *previous_node,
t_subtree subtree, bool is_pending, TSStateId state)
t_subtree subtree, bool is_pending, t_state_id state)
{
t_stack_node *node;

6
parser/src/stack/stack_summary.c
View file

@ -10,14 +10,14 @@
/* */
/* ************************************************************************** */
#include "parser/stack.h"
#include "parser/inner/stack.h"
#include "parser/inner/stack_inner.h"
#include "parser/inner/stack_inner.h"
t_stack_action summarize_stack_callback(void *payload,
const t_stack_iterator *iterator)
{
t_summarize_stack_session *session;
TSStateId state;
t_state_id state;
t_u32 depth;
t_stack_summary_entry entry;
t_usize i;

4
parser/src/stack/stack_version.c
View file

@ -10,8 +10,8 @@
/* */
/* ************************************************************************** */
#include "parser/stack.h"
#include "parser/inner/stack.h"
#include "parser/inner/stack_inner.h"
#include "parser/inner/stack_inner.h"
void ts_stack_remove_version(t_stack *self, t_stack_version version)
{

6
parser/src/subtree/subtree_helper.c
View file

@ -13,10 +13,10 @@
#include "parser/language.h"
#include "parser/subtree.h"
void ts_subtree_set_symbol(t_subtree *self, TSSymbol symbol,
const TSLanguage *language)
void ts_subtree_set_symbol(t_subtree *self, t_symbol symbol,
const t_language *language)
{
TSSymbolMetadata metadata;
t_symbol_metadata metadata;
metadata = ts_language_symbol_metadata(language, symbol);
(*self)->symbol = symbol;

14
parser/src/subtree/subtree_new.c
View file

@ -16,10 +16,10 @@
// Create a new parent node with the given children.
//
// This takes ownership of the children array.
t_subtree ts_subtree_new_node(TSSymbol symbol, t_vec_subtree *children, \
t_u32 production_id, const TSLanguage *language)
t_subtree ts_subtree_new_node(t_symbol symbol, t_vec_subtree *children, \
t_u32 production_id, const t_language *language)
{
TSSymbolMetadata metadata;
t_symbol_metadata metadata;
bool fragile;
t_subtree data;
@ -44,7 +44,7 @@ t_subtree ts_subtree_new_node(TSSymbol symbol, t_vec_subtree *children, \
// This node is treated as 'extra'. Its children are prevented from having
// having any effect on the parse state.
t_subtree ts_subtree_new_error_node(t_vec_subtree *children, bool extra,
const TSLanguage *language)
const t_language *language)
{
t_subtree result;
@ -57,8 +57,8 @@ t_subtree ts_subtree_new_error_node(t_vec_subtree *children, bool extra,
//
// This node is treated as 'extra'. Its children are prevented from having
// having any effect on the parse state.
t_subtree ts_subtree_new_missing_leaf(TSSymbol symbol, Length padding,
t_u32 lookahead_bytes, const TSLanguage *language)
t_subtree ts_subtree_new_missing_leaf(t_symbol symbol, t_length padding,
t_u32 lookahead_bytes, const t_language *language)
{
t_subtree result;
@ -71,7 +71,7 @@ t_subtree ts_subtree_new_missing_leaf(TSSymbol symbol, Length padding,
t_subtree ts_subtree_new_leaf(t_st_newleaf_args args)
{
TSSymbolMetadata metadata;
t_symbol_metadata metadata;
bool extra;
t_subtree_data *data;

12
parser/src/subtree/subtree_summarize.c
View file

@ -14,13 +14,13 @@
#include "parser/subtree.h"
void _summarize_loop_inner1(t_subtree self, \
const TSLanguage *language, struct s_summarize_state *s);
const t_language *language, struct s_summarize_state *s);
void _summarize_loop_inner2(t_subtree self, \
const TSLanguage *language, struct s_summarize_state *s);
const t_language *language, struct s_summarize_state *s);
void _summarize_loop_inner3(t_subtree self, \
const TSLanguage *language, struct s_summarize_state *s);
const t_language *language, struct s_summarize_state *s);
void _summarize_loop_inner4(t_subtree self, \
const TSLanguage *language, struct s_summarize_state *s);
const t_language *language, struct s_summarize_state *s);
void _sumarize_end(t_subtree self, t_subtree *children)
{
@ -50,7 +50,7 @@ void _sumarize_end(t_subtree self, t_subtree *children)
}
struct s_summarize_state _init_sumnarize_state(t_subtree self,
const TSLanguage *language)
const t_language *language)
{
struct s_summarize_state s;
@ -75,7 +75,7 @@ struct s_summarize_state _init_sumnarize_state(t_subtree self,
// Assign all of the node's properties that depend on its children.
void ts_subtree_summarize_children(t_subtree self,
const TSLanguage *language)
const t_language *language)
{
struct s_summarize_state s;

8
parser/src/subtree/subtree_summarize_loop.c
View file

@ -14,7 +14,7 @@
#include "parser/subtree.h"
void _summarize_loop_inner1(t_subtree self,
const TSLanguage *language, struct s_summarize_state *s)
const t_language *language, struct s_summarize_state *s)
{
(void)(language);
s->child = s->children[s->i];
@ -39,7 +39,7 @@ void _summarize_loop_inner1(t_subtree self,
}
void _summarize_loop_inner2(t_subtree self,
const TSLanguage *language, struct s_summarize_state *s)
const t_language *language, struct s_summarize_state *s)
{
(void)(language);
if (self->symbol == ts_builtin_sym_error
@ -61,7 +61,7 @@ void _summarize_loop_inner2(t_subtree self,
}
void _summarize_loop_inner3(t_subtree self,
const TSLanguage *language, struct s_summarize_state *s)
const t_language *language, struct s_summarize_state *s)
{
(void)(language);
if (s->alias_sequence && s->alias_sequence[s->structural_index] != 0
@ -88,7 +88,7 @@ void _summarize_loop_inner3(t_subtree self,
}
void _summarize_loop_inner4(t_subtree self,
const TSLanguage *language, struct s_summarize_state *s)
const t_language *language, struct s_summarize_state *s)
{
(void)(language);
if (ts_subtree_has_external_tokens(s->child))

8
parser/src/tree/tree_funcs1.c
View file

@ -14,9 +14,9 @@
#include "parser/subtree.h"
#include "parser/tree.h"
TSTree *ts_tree_new(t_subtree root, const TSLanguage *language)
t_tree *ts_tree_new(t_subtree root, const t_language *language)
{
TSTree *result;
t_tree *result;
result = mem_alloc(sizeof(*result));
result->root = root;
@ -24,13 +24,13 @@ TSTree *ts_tree_new(t_subtree root, const TSLanguage *language)
return (result);
}
TSTree *ts_tree_copy(const TSTree *self)
t_tree *ts_tree_copy(const t_tree *self)
{
(self->root->ref_count++);
return (ts_tree_new(self->root, self->language));
}
void ts_tree_delete(TSTree *self)
void ts_tree_delete(t_tree *self)
{
if (self == NULL)
return ;

12
parser/src/tree/tree_funcs2.c
View file

@ -14,22 +14,22 @@
#include "parser/subtree.h"
#include "parser/tree.h"
TSNode ts_tree_root_node(const TSTree *self)
t_node ts_tree_root_node(const t_tree *self)
{
return (ts_node_new(self, &self->root, ts_subtree_padding(self->root), 0));
}
TSNode ts_tree_root_node_with_offset(const TSTree *self, t_u32 offset_bytes,
TSPoint offset_extent)
t_node ts_tree_root_node_with_offset(const t_tree *self, t_u32 offset_bytes,
t_point offset_extent)
{
Length offset;
t_length offset;
offset = (Length){offset_bytes, offset_extent};
offset = (t_length){offset_bytes, offset_extent};
return (ts_node_new(self, &self->root, length_add(offset,
ts_subtree_padding(self->root)), 0));
}
const TSLanguage *ts_tree_language(const TSTree *self)
const t_language *ts_tree_language(const t_tree *self)
{
return (self->language);
}