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

Removed some useless stuff and made some changes

Browse source
This commit is contained in:
Maieul BOYER 2024-08-31 12:18:38 +00:00
parent acb734cda0
commit e91a509d4c
17 changed files with 216 additions and 92 deletions
Download patch file Download diff file Expand all files Collapse all files

3
parser/include/parser/api.h
View file

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/07/22 13:54:54 by maiboyer #+# #+# */ /* Created: 2024/07/22 13:54:54 by maiboyer #+# #+# */
/* Updated: 2024/08/30 19:46:23 by maiboyer ### ########.fr */ /* Updated: 2024/08/31 12:10:39 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@ -86,7 +86,6 @@ typedef struct TSInput
{ {
void *payload; void *payload;
const t_u8 *(*read)(void *payload, t_u32 byte_index, TSPoint position, t_u32 *bytes_read); const t_u8 *(*read)(void *payload, t_u32 byte_index, TSPoint position, t_u32 *bytes_read);
TSInputEncoding encoding;
} TSInput; } TSInput;
typedef enum TSLogType typedef enum TSLogType

12
parser/include/parser/array.h
View file

@ -1,3 +1,15 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* array.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/08/31 12:03:22 by maiboyer #+# #+# */
/* Updated: 2024/08/31 12:03:29 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef TREE_SITTER_ARRAY_H_ #ifndef TREE_SITTER_ARRAY_H_
#define TREE_SITTER_ARRAY_H_ #define TREE_SITTER_ARRAY_H_

12
parser/include/parser/input.h
View file

@ -1,3 +1,15 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* input.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/08/31 12:03:19 by maiboyer #+# #+# */
/* Updated: 2024/08/31 12:03:29 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef INPUT_H #ifndef INPUT_H
#define INPUT_H #define INPUT_H

12
parser/include/parser/language.h
View file

@ -1,3 +1,15 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* language.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/08/31 12:03:18 by maiboyer #+# #+# */
/* Updated: 2024/08/31 12:03:29 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef LANGUAGE_H #ifndef LANGUAGE_H
#define LANGUAGE_H #define LANGUAGE_H

12
parser/include/parser/length.h
View file

@ -1,3 +1,15 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* length.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/08/31 12:03:16 by maiboyer #+# #+# */
/* Updated: 2024/08/31 12:03:29 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef LENGTH_H #ifndef LENGTH_H
#define LENGTH_H #define LENGTH_H

12
parser/include/parser/lexer.h
View file

@ -1,3 +1,15 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* lexer.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/08/31 12:03:15 by maiboyer #+# #+# */
/* Updated: 2024/08/31 12:03:29 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef LEXER_H #ifndef LEXER_H
#define LEXER_H #define LEXER_H

12
parser/include/parser/parser.h
View file

@ -1,3 +1,15 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* parser.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/08/31 12:03:13 by maiboyer #+# #+# */
/* Updated: 2024/08/31 12:03:29 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef PARSER_H #ifndef PARSER_H
#define PARSER_H #define PARSER_H

12
parser/include/parser/point.h
View file

@ -1,3 +1,15 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* point.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/08/31 12:03:10 by maiboyer #+# #+# */
/* Updated: 2024/08/31 12:03:29 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef POINT_H #ifndef POINT_H
#define POINT_H #define POINT_H

12
parser/include/parser/reduce_action.h
View file

@ -1,3 +1,15 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* reduce_action.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/08/31 12:03:09 by maiboyer #+# #+# */
/* Updated: 2024/08/31 12:03:29 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef REDUCE_ACTION_H #ifndef REDUCE_ACTION_H
#define REDUCE_ACTION_H #define REDUCE_ACTION_H

12
parser/include/parser/stack.h
View file

@ -1,3 +1,15 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* stack.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/08/31 12:03:07 by maiboyer #+# #+# */
/* Updated: 2024/08/31 12:03:08 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef PARSE_STACK_H #ifndef PARSE_STACK_H
#define PARSE_STACK_H #define PARSE_STACK_H

12
parser/include/parser/subtree.h
View file

@ -1,3 +1,15 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* subtree.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/08/31 12:03:06 by maiboyer #+# #+# */
/* Updated: 2024/08/31 12:03:06 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef SUBTREE_H #ifndef SUBTREE_H
#define SUBTREE_H #define SUBTREE_H

20
parser/include/parser/tree.h
View file

@ -1,10 +1,20 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* tree.h :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/08/31 12:03:04 by maiboyer #+# #+# */
/* Updated: 2024/08/31 12:04:05 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#ifndef TREE_H #ifndef TREE_H
#define TREE_H #define TREE_H
#include "parser/subtree.h"
#include "me/types.h" #include "me/types.h"
#include "parser/subtree.h"
typedef struct ParentCacheEntry ParentCacheEntry; typedef struct ParentCacheEntry ParentCacheEntry;
@ -12,8 +22,6 @@ struct TSTree
{ {
Subtree root; Subtree root;
const TSLanguage *language; const TSLanguage *language;
TSRange *included_ranges;
t_u32 included_range_count;
}; };
struct ParentCacheEntry struct ParentCacheEntry
@ -24,7 +32,7 @@ struct ParentCacheEntry
TSSymbol alias_symbol; TSSymbol alias_symbol;
}; };
TSTree *ts_tree_new(Subtree root, const TSLanguage *language, const TSRange *, t_u32); TSTree *ts_tree_new(Subtree root, const TSLanguage *language);
TSNode ts_node_new(const TSTree *, const Subtree *, Length, TSSymbol); TSNode ts_node_new(const TSTree *, const Subtree *, Length, TSSymbol);
#endif // TREE_H #endif // TREE_H

2
parser/src/node.c
View file

@ -63,7 +63,7 @@ static inline NodeChildIterator ts_node_iterate_children(const TSNode *node)
Subtree subtree = ts_node__subtree(*node); Subtree subtree = ts_node__subtree(*node);
if (ts_subtree_child_count(subtree) == 0) if (ts_subtree_child_count(subtree) == 0)
{ {
return (NodeChildIterator){NULL_SUBTREE, node->tree, length_zero(), 0, 0, NULL}; return (NodeChildIterator){NULL, node->tree, length_zero(), 0, 0, NULL};
} }
const TSSymbol *alias_sequence = ts_language_alias_sequence(node->tree->language, subtree->production_id); const TSSymbol *alias_sequence = ts_language_alias_sequence(node->tree->language, subtree->production_id);
return (NodeChildIterator){ return (NodeChildIterator){

139
parser/src/parser.c
View file

@ -19,6 +19,10 @@ static const t_u32 MAX_VERSION_COUNT_OVERFLOW = 1;
static const t_u32 MAX_SUMMARY_DEPTH = 1; static const t_u32 MAX_SUMMARY_DEPTH = 1;
static const t_u32 MAX_COST_DIFFERENCE = 16 * ERROR_COST_PER_SKIPPED_TREE; static const t_u32 MAX_COST_DIFFERENCE = 16 * ERROR_COST_PER_SKIPPED_TREE;
typedef struct s_error_status t_error_status;
typedef enum e_error_comparison t_error_comparison;
typedef struct s_string_input t_string_input;
struct TSParser struct TSParser
{ {
Lexer lexer; Lexer lexer;
@ -32,12 +36,10 @@ struct TSParser
void *external_scanner_payload; void *external_scanner_payload;
t_u32 accept_count; t_u32 accept_count;
t_u32 operation_count; t_u32 operation_count;
t_u32 included_range_difference_index;
bool has_scanner_error; bool has_scanner_error;
}; };
typedef struct ErrorStatus ErrorStatus; struct s_error_status
struct ErrorStatus
{ {
t_u32 cost; t_u32 cost;
t_u32 node_count; t_u32 node_count;
@ -45,40 +47,39 @@ struct ErrorStatus
bool is_in_error; bool is_in_error;
}; };
typedef enum ErrorComparison ErrorComparison; enum e_error_comparison
enum ErrorComparison
{ {
ErrorComparisonTakeLeft, ECTakeLeft,
ErrorComparisonPreferLeft, ECPreferLeft,
ErrorComparisonNone, ECNone,
ErrorComparisonPreferRight, ECPreferRight,
ErrorComparisonTakeRight, ECTakeRight,
}; };
typedef struct TSStringInput struct s_string_input
{ {
const t_u8 *string; const t_u8 *string;
t_u32 length; t_u32 length;
} TSStringInput; };
// StringInput // StringInput
static const t_u8 *ts_string_input_read(void *_self, t_u32 byte, TSPoint point, t_u32 *length) static const t_u8 *ts_string_input_read(void *_self, t_u32 byte, TSPoint point, t_u32 *length)
{ {
TSStringInput *self; t_string_input *self;
(void)point; (void)point;
self = (TSStringInput *)_self; self = (t_string_input *)_self;
if (byte >= self->length) if (byte >= self->length)
{ {
*length = 0; *length = 0;
return (const t_u8 *)""; return ((const t_u8 *)"");
} }
else else
{ {
*length = self->length - byte; *length = self->length - byte;
return self->string + byte; return (self->string + byte);
} }
} }
@ -134,18 +135,18 @@ static bool ts_parser__breakdown_top_of_stack(TSParser *self, StackVersion versi
return did_break_down; return did_break_down;
} }
static ErrorComparison ts_parser__compare_versions(TSParser *self, ErrorStatus a, ErrorStatus b) static t_error_comparison ts_parser__compare_versions(TSParser *self, t_error_status a, t_error_status b)
{ {
(void)self; (void)self;
if (!a.is_in_error && b.is_in_error) if (!a.is_in_error && b.is_in_error)
{ {
if (a.cost < b.cost) if (a.cost < b.cost)
{ {
return ErrorComparisonTakeLeft; return ECTakeLeft;
} }
else else
{ {
return ErrorComparisonPreferLeft; return ECPreferLeft;
} }
} }
@ -153,11 +154,11 @@ static ErrorComparison ts_parser__compare_versions(TSParser *self, ErrorStatus a
{ {
if (b.cost < a.cost) if (b.cost < a.cost)
{ {
return ErrorComparisonTakeRight; return ECTakeRight;
} }
else else
{ {
return ErrorComparisonPreferRight; return ECPreferRight;
} }
} }
@ -165,11 +166,11 @@ static ErrorComparison ts_parser__compare_versions(TSParser *self, ErrorStatus a
{ {
if ((b.cost - a.cost) * (1 + a.node_count) > MAX_COST_DIFFERENCE) if ((b.cost - a.cost) * (1 + a.node_count) > MAX_COST_DIFFERENCE)
{ {
return ErrorComparisonTakeLeft; return ECTakeLeft;
} }
else else
{ {
return ErrorComparisonPreferLeft; return ECPreferLeft;
} }
} }
@ -177,31 +178,31 @@ static ErrorComparison ts_parser__compare_versions(TSParser *self, ErrorStatus a
{ {
if ((a.cost - b.cost) * (1 + b.node_count) > MAX_COST_DIFFERENCE) if ((a.cost - b.cost) * (1 + b.node_count) > MAX_COST_DIFFERENCE)
{ {
return ErrorComparisonTakeRight; return ECTakeRight;
} }
else else
{ {
return ErrorComparisonPreferRight; return ECPreferRight;
} }
} }
if (a.dynamic_precedence > b.dynamic_precedence) if (a.dynamic_precedence > b.dynamic_precedence)
return ErrorComparisonPreferLeft; return ECPreferLeft;
if (b.dynamic_precedence > a.dynamic_precedence) if (b.dynamic_precedence > a.dynamic_precedence)
return ErrorComparisonPreferRight; return ECPreferRight;
return ErrorComparisonNone; return ECNone;
} }
static ErrorStatus ts_parser__version_status(TSParser *self, StackVersion version) static t_error_status ts_parser__version_status(TSParser *self, StackVersion version)
{ {
t_u32 cost = ts_stack_error_cost(self->stack, version); t_u32 cost = ts_stack_error_cost(self->stack, version);
bool is_paused = ts_stack_is_paused(self->stack, version); bool is_paused = ts_stack_is_paused(self->stack, version);
if (is_paused) if (is_paused)
cost += ERROR_COST_PER_SKIPPED_TREE; cost += ERROR_COST_PER_SKIPPED_TREE;
return (ErrorStatus){.cost = cost, return (t_error_status){.cost = cost,
.node_count = ts_stack_node_count_since_error(self->stack, version), .node_count = ts_stack_node_count_since_error(self->stack, version),
.dynamic_precedence = ts_stack_dynamic_precedence(self->stack, version), .dynamic_precedence = ts_stack_dynamic_precedence(self->stack, version),
.is_in_error = is_paused || ts_stack_state(self->stack, version) == ERROR_STATE}; .is_in_error = is_paused || ts_stack_state(self->stack, version) == ERROR_STATE};
} }
static bool ts_parser__better_version_exists(TSParser *self, StackVersion version, bool is_in_error, t_u32 cost) static bool ts_parser__better_version_exists(TSParser *self, StackVersion version, bool is_in_error, t_u32 cost)
@ -211,8 +212,8 @@ static bool ts_parser__better_version_exists(TSParser *self, StackVersion versio
return true; return true;
} }
Length position = ts_stack_position(self->stack, version); Length position = ts_stack_position(self->stack, version);
ErrorStatus status = { t_error_status status = {
.cost = cost, .cost = cost,
.is_in_error = is_in_error, .is_in_error = is_in_error,
.dynamic_precedence = ts_stack_dynamic_precedence(self->stack, version), .dynamic_precedence = ts_stack_dynamic_precedence(self->stack, version),
@ -223,12 +224,12 @@ static bool ts_parser__better_version_exists(TSParser *self, StackVersion versio
{ {
if (i == version || !ts_stack_is_active(self->stack, i) || ts_stack_position(self->stack, i).bytes < position.bytes) if (i == version || !ts_stack_is_active(self->stack, i) || ts_stack_position(self->stack, i).bytes < position.bytes)
continue; continue;
ErrorStatus status_i = ts_parser__version_status(self, i); t_error_status status_i = ts_parser__version_status(self, i);
switch (ts_parser__compare_versions(self, status, status_i)) switch (ts_parser__compare_versions(self, status, status_i))
{ {
case ErrorComparisonTakeRight: case ECTakeRight:
return true; return true;
case ErrorComparisonPreferRight: case ECPreferRight:
if (ts_stack_can_merge(self->stack, i, version)) if (ts_stack_can_merge(self->stack, i, version))
return true; return true;
break; break;
@ -305,7 +306,7 @@ static Subtree ts_parser__lex(TSParser *self, StackVersion version, TSStateId pa
{ {
TSLexMode lex_mode = self->language->lex_modes[parse_state]; TSLexMode lex_mode = self->language->lex_modes[parse_state];
if (lex_mode.lex_state == (t_u16)-1) if (lex_mode.lex_state == (t_u16)-1)
return NULL_SUBTREE; return NULL;
const Length start_position = ts_stack_position(self->stack, version); const Length start_position = ts_stack_position(self->stack, version);
const Subtree external_token = ts_stack_last_external_token(self->stack, version); const Subtree external_token = ts_stack_last_external_token(self->stack, version);
@ -333,7 +334,7 @@ static Subtree ts_parser__lex(TSParser *self, StackVersion version, TSStateId pa
ts_parser__external_scanner_deserialize(self, external_token); ts_parser__external_scanner_deserialize(self, external_token);
found_token = ts_parser__external_scanner_scan(self, lex_mode.external_lex_state); found_token = ts_parser__external_scanner_scan(self, lex_mode.external_lex_state);
if (self->has_scanner_error) if (self->has_scanner_error)
return NULL_SUBTREE; return NULL;
ts_lexer_finish(&self->lexer, &lookahead_end_byte); ts_lexer_finish(&self->lexer, &lookahead_end_byte);
if (found_token) if (found_token)
@ -660,7 +661,7 @@ static void ts_parser__accept(TSParser *self, StackVersion version, Subtree look
{ {
SubtreeArray trees = pop.contents[i].subtrees; SubtreeArray trees = pop.contents[i].subtrees;
Subtree root = NULL_SUBTREE; Subtree root = NULL;
for (t_u32 j = trees.size - 1; j + 1 > 0; j--) for (t_u32 j = trees.size - 1; j + 1 > 0; j--)
{ {
Subtree tree = trees.contents[j]; Subtree tree = trees.contents[j];
@ -1096,7 +1097,7 @@ static void ts_parser__handle_error(TSParser *self, StackVersion version, Subtre
} }
} }
ts_stack_push(self->stack, v, NULL_SUBTREE, false, ERROR_STATE); ts_stack_push(self->stack, v, NULL, false, ERROR_STATE);
v = (v == version) ? previous_version_count : v + 1; v = (v == version) ? previous_version_count : v + 1;
} }
@ -1122,7 +1123,7 @@ static bool ts_parser__advance(TSParser *self, StackVersion version, bool allow_
(void)(allow_node_reuse); (void)(allow_node_reuse);
TSStateId state = ts_stack_state(self->stack, version); TSStateId state = ts_stack_state(self->stack, version);
Subtree lookahead = NULL_SUBTREE; Subtree lookahead = NULL;
TableEntry table_entry = {.action_count = 0}; TableEntry table_entry = {.action_count = 0};
bool needs_lex = true; bool needs_lex = true;
@ -1301,7 +1302,7 @@ static t_u32 ts_parser__condense_stack(TSParser *self)
// Keep track of the minimum error cost of any stack version so // Keep track of the minimum error cost of any stack version so
// that it can be returned. // that it can be returned.
ErrorStatus status_i = ts_parser__version_status(self, i); t_error_status status_i = ts_parser__version_status(self, i);
if (!status_i.is_in_error && status_i.cost < min_error_cost) if (!status_i.is_in_error && status_i.cost < min_error_cost)
{ {
min_error_cost = status_i.cost; min_error_cost = status_i.cost;
@ -1312,18 +1313,18 @@ static t_u32 ts_parser__condense_stack(TSParser *self)
// are ordered from most promising to least promising. // are ordered from most promising to least promising.
for (StackVersion j = 0; j < i; j++) for (StackVersion j = 0; j < i; j++)
{ {
ErrorStatus status_j = ts_parser__version_status(self, j); t_error_status status_j = ts_parser__version_status(self, j);
switch (ts_parser__compare_versions(self, status_j, status_i)) switch (ts_parser__compare_versions(self, status_j, status_i))
{ {
case ErrorComparisonTakeLeft: case ECTakeLeft:
ts_stack_remove_version(self->stack, i); ts_stack_remove_version(self->stack, i);
i--; i--;
j = i; j = i;
break; break;
case ErrorComparisonPreferLeft: case ECPreferLeft:
case ErrorComparisonNone: case ECNone:
if (ts_stack_merge(self->stack, j, i)) if (ts_stack_merge(self->stack, j, i))
{ {
i--; i--;
@ -1331,7 +1332,7 @@ static t_u32 ts_parser__condense_stack(TSParser *self)
} }
break; break;
case ErrorComparisonPreferRight: case ECPreferRight:
if (ts_stack_merge(self->stack, j, i)) if (ts_stack_merge(self->stack, j, i))
{ {
i--; i--;
@ -1343,7 +1344,7 @@ static t_u32 ts_parser__condense_stack(TSParser *self)
} }
break; break;
case ErrorComparisonTakeRight: case ECTakeRight:
ts_stack_remove_version(self->stack, j); ts_stack_remove_version(self->stack, j);
i--; i--;
j--; j--;
@ -1407,12 +1408,11 @@ TSParser *ts_parser_new(void)
array_init(&self->reduce_actions); array_init(&self->reduce_actions);
array_reserve(&self->reduce_actions, 4); array_reserve(&self->reduce_actions, 4);
self->stack = ts_stack_new(); self->stack = ts_stack_new();
self->finished_tree = NULL_SUBTREE; self->finished_tree = NULL;
self->language = NULL; self->language = NULL;
self->has_scanner_error = false; self->has_scanner_error = false;
self->external_scanner_payload = NULL; self->external_scanner_payload = NULL;
self->operation_count = 0; self->operation_count = 0;
self->included_range_difference_index = 0;
return self; return self;
} }
@ -1453,7 +1453,7 @@ void ts_parser_reset(TSParser *self)
if (self->finished_tree) if (self->finished_tree)
{ {
ts_subtree_release(self->finished_tree); ts_subtree_release(self->finished_tree);
self->finished_tree = NULL_SUBTREE; self->finished_tree = NULL;
} }
self->accept_count = 0; self->accept_count = 0;
self->has_scanner_error = false; self->has_scanner_error = false;
@ -1466,18 +1466,23 @@ TSTree *ts_parser_parse(TSParser *self, TSInput input)
return NULL; return NULL;
ts_lexer_set_input(&self->lexer, input); ts_lexer_set_input(&self->lexer, input);
self->included_range_difference_index = 0; // self->included_range_difference_index = 0;
if (!ts_parser_has_outstanding_parse(self)) if (!ts_parser_has_outstanding_parse(self))
{ {
ts_parser__external_scanner_create(self); ts_parser__external_scanner_create(self);
if (self->has_scanner_error) if (self->has_scanner_error)
goto exit; {
ts_parser_reset(self);
return result;
}
} }
self->operation_count = 0; self->operation_count = 0;
t_u32 position = 0, last_position = 0, version_count = 0; t_u32 position = 0;
t_u32 last_position = 0;
t_u32 version_count = 0;
do do
{ {
for (StackVersion version = 0; version_count = ts_stack_version_count(self->stack), version < version_count; version++) for (StackVersion version = 0; version_count = ts_stack_version_count(self->stack), version < version_count; version++)
@ -1488,7 +1493,10 @@ TSTree *ts_parser_parse(TSParser *self, TSInput input)
if (!ts_parser__advance(self, version, allow_node_reuse)) if (!ts_parser__advance(self, version, allow_node_reuse))
{ {
if (self->has_scanner_error) if (self->has_scanner_error)
goto exit; {
ts_parser_reset(self);
return result;
}
return NULL; return NULL;
} }
position = ts_stack_position(self->stack, version).bytes; position = ts_stack_position(self->stack, version).bytes;
@ -1516,27 +1524,20 @@ TSTree *ts_parser_parse(TSParser *self, TSInput input)
} while (version_count != 0); } while (version_count != 0);
assert(self->finished_tree); if (self->finished_tree == NULL)
me_abort("self->finished_tree == NULL");
ts_subtree_balance(self->finished_tree, self->language); ts_subtree_balance(self->finished_tree, self->language);
result = ts_tree_new(self->finished_tree, self->language, self->lexer.included_ranges, self->lexer.included_range_count); result = ts_tree_new(self->finished_tree, self->language);
self->finished_tree = NULL_SUBTREE; self->finished_tree = NULL;
exit:
ts_parser_reset(self); ts_parser_reset(self);
return result; return result;
} }
TSTree *ts_parser_parse_string(TSParser *self, t_const_str string, t_u32 length) TSTree *ts_parser_parse_string(TSParser *self, t_const_str string, t_u32 length)
{ {
return ts_parser_parse_string_encoding(self, string, length, TSInputEncodingUTF8); t_string_input input = {(const t_u8 *)string, length};
}
TSTree *ts_parser_parse_string_encoding(TSParser *self, t_const_str string, t_u32 length, TSInputEncoding encoding)
{
TSStringInput input = {(const t_u8 *)string, length};
return ts_parser_parse(self, (TSInput){ return ts_parser_parse(self, (TSInput){
&input, &input,
ts_string_input_read, ts_string_input_read,
encoding,
}); });
} }

10
parser/src/stack.c
View file

@ -294,7 +294,7 @@ static StackVersion ts_stack__add_version(Stack *self, StackVersion original_ver
.node_count_at_last_error = self->heads.contents[original_version].node_count_at_last_error, .node_count_at_last_error = self->heads.contents[original_version].node_count_at_last_error,
.last_external_token = self->heads.contents[original_version].last_external_token, .last_external_token = self->heads.contents[original_version].last_external_token,
.status = StackStatusActive, .status = StackStatusActive,
.lookahead_when_paused = NULL_SUBTREE, .lookahead_when_paused = NULL,
}; };
array_push(&self->heads, head); array_push(&self->heads, head);
stack_node_retain(node); stack_node_retain(node);
@ -439,7 +439,7 @@ Stack *ts_stack_new(void)
array_reserve(&self->slices, 4); array_reserve(&self->slices, 4);
array_reserve(&self->iterators, 4); array_reserve(&self->iterators, 4);
self->base_node = stack_node_new(NULL, NULL_SUBTREE, false, 1); self->base_node = stack_node_new(NULL, NULL, false, 1);
ts_stack_clear(self); ts_stack_clear(self);
return self; return self;
@ -809,7 +809,7 @@ Subtree ts_stack_resume(Stack *self, StackVersion version)
assert(head->status == StackStatusPaused); assert(head->status == StackStatusPaused);
Subtree result = head->lookahead_when_paused; Subtree result = head->lookahead_when_paused;
head->status = StackStatusActive; head->status = StackStatusActive;
head->lookahead_when_paused = NULL_SUBTREE; head->lookahead_when_paused = NULL;
return result; return result;
} }
@ -824,8 +824,8 @@ void ts_stack_clear(Stack *self)
array_push(&self->heads, ((StackHead){ array_push(&self->heads, ((StackHead){
.node = self->base_node, .node = self->base_node,
.status = StackStatusActive, .status = StackStatusActive,
.last_external_token = NULL_SUBTREE, .last_external_token = NULL,
.lookahead_when_paused = NULL_SUBTREE, .lookahead_when_paused = NULL,
})); }));
} }

2
parser/src/subtree.c
View file

@ -538,7 +538,7 @@ int ts_subtree_compare(Subtree left, Subtree right)
Subtree ts_subtree_last_external_token(Subtree tree) Subtree ts_subtree_last_external_token(Subtree tree)
{ {
if (!ts_subtree_has_external_tokens(tree)) if (!ts_subtree_has_external_tokens(tree))
return NULL_SUBTREE; return NULL;
while (tree->child_count > 0) while (tree->child_count > 0)
{ {
for (t_u32 i = tree->child_count - 1; i + 1 > 0; i--) for (t_u32 i = tree->child_count - 1; i + 1 > 0; i--)

12
parser/src/tree.c
View file

@ -3,18 +3,14 @@
#include "parser/tree.h" #include "parser/tree.h"
#include "me/types.h" #include "me/types.h"
#include "parser/api.h" #include "parser/api.h"
#include "parser/array.h"
#include "parser/length.h" #include "parser/length.h"
#include "parser/point.h"
#include "parser/subtree.h" #include "parser/subtree.h"
TSTree *ts_tree_new(Subtree root, const TSLanguage *language, const TSRange *included_ranges, t_u32 included_range_count) TSTree *ts_tree_new(Subtree root, const TSLanguage *language)
{ {
(void)(included_ranges); TSTree *result;
(void)(included_range_count); result = mem_alloc(sizeof(*result));
TSTree *result = mem_alloc(sizeof(TSTree));
result->root = root; result->root = root;
result->included_ranges = NULL;
result->language = language; result->language = language;
return result; return result;
} }
@ -22,7 +18,7 @@ TSTree *ts_tree_new(Subtree root, const TSLanguage *language, const TSRange *inc
TSTree *ts_tree_copy(const TSTree *self) TSTree *ts_tree_copy(const TSTree *self)
{ {
ts_subtree_retain(self->root); ts_subtree_retain(self->root);
return ts_tree_new(self->root, self->language, self->included_ranges, self->included_range_count); return ts_tree_new(self->root, self->language);
} }
void ts_tree_delete(TSTree *self) void ts_tree_delete(TSTree *self)