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

lil shit

Browse source
This commit is contained in:
Maieul BOYER 2024-06-20 14:38:22 +02:00
parent 1d069092a2
commit c6e426f235
No known key found for this signature in database
9 changed files with 511 additions and 294 deletions
Download patch file Download diff file Expand all files Collapse all files

10
ast/include/ast/ast.h
View file

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/06/11 14:23:40 by maiboyer #+# #+# */
/* Updated: 2024/06/17 13:27:23 by maiboyer ### ########.fr */
/* Updated: 2024/06/20 14:23:59 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
@ -52,9 +52,10 @@ enum e_ast_node_kind
AST_COMPOUND_STATEMENT = S_AST_COMPOUND_COMMAND | 0x0013,
AST_IF = S_AST_COMPOUND_COMMAND | 0x0014,
AST_PIPELINE = S_AST_COMPOUND_COMMAND | 0x00015,
AST_SUBSHELL = S_AST_COMPOUND_COMMAND | 0x00016,
AST_UNTIL = S_AST_COMPOUND_COMMAND | 0x0017,
AST_WHILE = S_AST_COMPOUND_COMMAND | 0x0018,
AST_PROGRAM = S_AST_COMPOUND_COMMAND | 0x0016,
AST_SUBSHELL = S_AST_COMPOUND_COMMAND | 0x00017,
AST_UNTIL = S_AST_COMPOUND_COMMAND | 0x0018,
AST_WHILE = S_AST_COMPOUND_COMMAND | 0x0019,
};
union u_ast_node_data {
@ -75,6 +76,7 @@ union u_ast_node_data {
t_ast_if if_;
t_ast_list list;
t_ast_pipeline pipeline;
t_ast_program program;
t_ast_raw_string raw_string;
t_ast_string string;
t_ast_subshell subshell;

63
ast/include/ast/ast_forward_def.h
View file

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/06/11 14:24:24 by maiboyer #+# #+# */
/* Updated: 2024/06/11 14:24:25 by maiboyer ### ########.fr */
/* Updated: 2024/06/20 14:22:36 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
@ -17,47 +17,48 @@ typedef enum e_ast_node_kind t_ast_node_kind;
typedef enum e_ast_word_kind t_ast_word_kind;
typedef enum e_ast_list_kind t_ast_list_kind;
typedef enum e_ast_expansion_operator t_ast_expansion_operator;
typedef enum e_ast_terminator_kind t_ast_terminator_kind;
typedef union u_ast_node_data t_ast_node_data;
typedef struct s_ast_node *t_ast_node;
typedef struct s_ast_arithmetic_expansion t_ast_arithmetic_expansion;
typedef struct s_ast_case_item t_ast_case_item;
typedef struct s_ast_case t_ast_case;
typedef struct s_ast_case_item t_ast_case_item;
typedef struct s_ast_case t_ast_case;
typedef struct s_ast_command_substitution t_ast_command_substitution;
typedef struct s_ast_command t_ast_command;
typedef struct s_ast_compound_statement t_ast_compound_statement;
typedef struct s_ast_elif t_ast_elif;
typedef struct s_ast_else t_ast_else;
typedef struct s_ast_empty t_ast_empty;
typedef struct s_ast_expansion t_ast_expansion;
typedef struct s_ast_file_redirection t_ast_file_redirection;
typedef struct s_ast_for t_ast_for;
typedef struct s_ast_function_definition t_ast_function_definition;
typedef struct s_ast_heredoc_redirection t_ast_heredoc_redirection;
typedef struct s_ast_if t_ast_if;
typedef struct s_ast_list t_ast_list;
typedef struct s_ast_pipeline t_ast_pipeline;
typedef struct s_ast_raw_string t_ast_raw_string;
typedef struct s_ast_string t_ast_string;
typedef struct s_ast_subshell t_ast_subshell;
typedef struct s_ast_until t_ast_until;
typedef struct s_ast_variable_assignment t_ast_variable_assignment;
typedef struct s_ast_while t_ast_while;
typedef struct s_ast_word t_ast_word;
typedef struct s_ast_command t_ast_command;
typedef struct s_ast_compound_statement t_ast_compound_statement;
typedef struct s_ast_elif t_ast_elif;
typedef struct s_ast_else t_ast_else;
typedef struct s_ast_empty t_ast_empty;
typedef struct s_ast_expansion t_ast_expansion;
typedef struct s_ast_file_redirection t_ast_file_redirection;
typedef struct s_ast_for t_ast_for;
typedef struct s_ast_function_definition t_ast_function_definition;
typedef struct s_ast_heredoc_redirection t_ast_heredoc_redirection;
typedef struct s_ast_if t_ast_if;
typedef struct s_ast_list t_ast_list;
typedef struct s_ast_pipeline t_ast_pipeline;
typedef struct s_ast_program t_ast_program;
typedef struct s_ast_raw_string t_ast_raw_string;
typedef struct s_ast_string t_ast_string;
typedef struct s_ast_subshell t_ast_subshell;
typedef struct s_ast_until t_ast_until;
typedef struct s_ast_variable_assignment t_ast_variable_assignment;
typedef struct s_ast_while t_ast_while;
typedef struct s_ast_word t_ast_word;
/*
t_ast_arithmetic_expansion arithmetic_expansion;
t_ast_case_item case_item;
t_ast_case case;
t_ast_case_item case_item;
t_ast_case case;
t_ast_command_substitution command_substitution;
t_ast_command command;
t_ast_command command;
t_ast_compound_statement compound_statement;
t_ast_elif elif;
t_ast_else else;
t_ast_empty empty;
t_ast_elif elif;
t_ast_else else;
t_ast_empty empty;
t_ast_expansion expansion;
t_ast_file_redirection file_redirection;
t_ast_for for;
@ -65,6 +66,7 @@ t_ast_function_definition function_definition;
t_ast_heredoc_redirection heredoc_redirection;
t_ast_if if;
t_ast_list list;
t_ast_program program;
t_ast_pipeline pipeline;
t_ast_raw_string raw_string;
t_ast_string string;
@ -92,6 +94,7 @@ AST_FUNCTION_DEFINITION,
AST_HEREDOC_REDIRECTION,
AST_IF,
AST_LIST,
AST_PROGRAM,
AST_PIPELINE,
AST_RAW_STRING,
AST_STRING,

90
ast/include/ast/ast_raw_structs.h
View file

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/06/14 17:46:58 by maiboyer #+# #+# */
/* Updated: 2024/06/14 17:46:58 by maiboyer ### ########.fr */
/* Updated: 2024/06/20 14:29:55 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
@ -38,10 +38,6 @@
ast_statement_not_subshell == ast_statement - subshell
*/
struct s_ast_empty
{
};
enum e_ast_list_kind
{
AST_LIST_AND,
@ -55,6 +51,38 @@ enum e_ast_word_kind
AST_WORD_DOUBLE_QUOTED,
};
enum e_ast_terminator_kind
{
AST_TERM_NONE,
AST_TERM_NEWLINE,
AST_TERM_DOUBLE_SEMI,
AST_TERM_SEMI,
AST_TERM_FORK,
};
enum e_ast_expansion_operator
{
E_OP_NONE = 0, // ${var}
E_OP_DEFAULT, // ${var-word}
E_OP_ASSIGN_DEFAULT, // ${var=word}
E_OP_ERROR, // ${var?word}
E_OP_ALTERNATE, // ${var+word}
E_OP_DEFAULT_COLON, // ${var:-word}
E_OP_ASSIGN_DEFAULT_COLON, // ${var:=word}
E_OP_ERROR_COLON, // ${var:?word}
E_OP_ALTERNATE_COLON, // ${var:+word}
E_OP_LENGTH, // ${#var}
E_OP_SMALLEST_PREFIX, // ${var#pattern}
E_OP_LARGEST_PREFIX, // ${var##pattern}
E_OP_SMALLEST_SUFFIX, // ${var%pattern}
E_OP_LARGEST_SUFFIX, // ${var%%pattern}
};
struct s_ast_empty
{
};
struct s_ast_raw_string
{
t_str str;
@ -93,17 +121,19 @@ struct s_ast_word
struct s_ast_command
{
t_vec_ast prefixes;
t_vec_ast cmd_word;
t_vec_ast suffixes;
t_vec_ast prefixes;
t_vec_ast cmd_word;
t_vec_ast suffixes;
t_ast_terminator_kind term;
};
struct s_ast_if
{
t_vec_ast condition;
t_vec_ast then;
t_vec_ast elif_;
t_ast_node else_;
t_vec_ast condition;
t_vec_ast then;
t_vec_ast elif_;
t_ast_node else_;
t_ast_terminator_kind term;
};
struct s_ast_elif
@ -132,14 +162,16 @@ struct s_ast_for
struct s_ast_case
{
t_ast_node word;
t_vec_ast cases;
t_ast_node word;
t_vec_ast cases;
t_ast_terminator_kind term;
};
struct s_ast_case_item
{
t_vec_ast pattern;
t_vec_ast body;
t_vec_ast pattern;
t_vec_ast body;
t_ast_terminator_kind term;
};
struct s_ast_until
@ -161,7 +193,8 @@ struct s_ast_subshell
struct s_ast_compound_statement
{
t_vec_ast body;
t_vec_ast body;
t_ast_terminator_kind term;
};
struct s_ast_variable_assignment
@ -182,25 +215,6 @@ struct s_ast_heredoc_redirection
t_ast_node delimiter;
};
enum e_ast_expansion_operator
{
E_OP_NONE = 0, // ${var}
E_OP_DEFAULT, // ${var-word}
E_OP_ASSIGN_DEFAULT, // ${var=word}
E_OP_ERROR, // ${var?word}
E_OP_ALTERNATE, // ${var+word}
E_OP_DEFAULT_COLON, // ${var:-word}
E_OP_ASSIGN_DEFAULT_COLON, // ${var:=word}
E_OP_ERROR_COLON, // ${var:?word}
E_OP_ALTERNATE_COLON, // ${var:+word}
E_OP_LENGTH, // ${#var}
E_OP_SMALLEST_PREFIX, // ${var#pattern}
E_OP_LARGEST_PREFIX, // ${var##pattern}
E_OP_SMALLEST_SUFFIX, // ${var%pattern}
E_OP_LARGEST_SUFFIX, // ${var%%pattern}
};
struct s_ast_expansion
{
t_str var_name;
@ -218,4 +232,8 @@ struct s_ast_command_substitution
t_ast_node cmd;
};
struct s_ast_program {
t_vec_ast body;
};
#endif /* AST_RAW_STRUCTS_H */

235
ast/src/from_node.c
View file

@ -6,14 +6,16 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/06/17 12:41:56 by maiboyer #+# #+# */
/* Updated: 2024/06/18 17:17:34 by maiboyer ### ########.fr */
/* Updated: 2024/06/20 14:38:08 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#include "ast/ast.h"
#include "gmr/field_identifiers.h"
#include "gmr/symbols.h"
#include "me/mem/mem.h"
#include "me/types.h"
#include "me/vec/vec_ast.h"
#include "parser/api.h"
/*
@ -69,83 +71,196 @@ sym_while_statement
sym_word
*/
// t_error build_sym_word(t_parse_node *node, t_ast_node *out);
void free_ast(t_ast_node elem)
{
}
t_error build_sym_arithmetic_binary_expression(t_parse_node *self, t_ast_node *out);
t_error build_sym_arithmetic_expansion(t_parse_node *self, t_ast_node *out);
t_error build_sym_arithmetic_literal(t_parse_node *self, t_ast_node *out);
t_error build_sym_arithmetic_parenthesized_expression(t_parse_node *self, t_ast_node *out);
t_error build_sym_arithmetic_postfix_expression(t_parse_node *self, t_ast_node *out);
t_error build_sym_arithmetic_ternary_expression(t_parse_node *self, t_ast_node *out);
t_error build_sym_arithmetic_unary_expression(t_parse_node *self, t_ast_node *out);
t_error build_sym_case_item(t_parse_node *self, t_ast_node *out);
t_error build_sym_case_statement(t_parse_node *self, t_ast_node *out);
t_error build_sym_command(t_parse_node *self, t_ast_node *out);
t_error build_sym_command_name(t_parse_node *self, t_ast_node *out);
t_error build_sym_command_substitution(t_parse_node *self, t_ast_node *out);
t_error build_sym_comment(t_parse_node *self, t_ast_node *out);
t_error build_sym_compound_statement(t_parse_node *self, t_ast_node *out);
t_error build_sym_concatenation(t_parse_node *self, t_ast_node *out);
t_error build_sym_do_group(t_parse_node *self, t_ast_node *out);
t_error build_sym_elif_clause(t_parse_node *self, t_ast_node *out);
t_error build_sym_else_clause(t_parse_node *self, t_ast_node *out);
t_error build_sym_expansion(t_parse_node *self, t_ast_node *out);
t_error build_sym_expansion_expression(t_parse_node *self, t_ast_node *out);
t_error build_sym_expansion_regex(t_parse_node *self, t_ast_node *out);
t_error build_sym_extglob_pattern(t_parse_node *self, t_ast_node *out);
t_error build_sym_file_descriptor(t_parse_node *self, t_ast_node *out);
t_error build_sym_file_redirect(t_parse_node *self, t_ast_node *out);
t_error build_sym_for_statement(t_parse_node *self, t_ast_node *out);
t_error build_sym_function_definition(t_parse_node *self, t_ast_node *out);
t_error build_sym_heredoc_body(t_parse_node *self, t_ast_node *out);
t_error build_sym_heredoc_content(t_parse_node *self, t_ast_node *out);
t_error build_sym_heredoc_end(t_parse_node *self, t_ast_node *out);
t_error build_sym_heredoc_redirect(t_parse_node *self, t_ast_node *out);
t_error build_sym_heredoc_start(t_parse_node *self, t_ast_node *out);
t_error build_sym_if_statement(t_parse_node *self, t_ast_node *out);
t_error build_sym_list(t_parse_node *self, t_ast_node *out);
t_error build_sym_negated_command(t_parse_node *self, t_ast_node *out);
t_error build_sym_number(t_parse_node *self, t_ast_node *out);
t_error build_sym_pipeline(t_parse_node *self, t_ast_node *out);
t_error build_sym_program(t_parse_node *self, t_ast_node *out);
t_error build_sym_raw_string(t_parse_node *self, t_ast_node *out);
t_error build_sym_redirected_statement(t_parse_node *self, t_ast_node *out);
t_error build_sym_regex(t_parse_node *self, t_ast_node *out);
t_error build_sym_simple_expansion(t_parse_node *self, t_ast_node *out);
t_error build_sym_simple_heredoc_body(t_parse_node *self, t_ast_node *out);
t_error build_sym_string(t_parse_node *self, t_ast_node *out);
t_error build_sym_string_content(t_parse_node *self, t_ast_node *out);
t_error build_sym_subshell(t_parse_node *self, t_ast_node *out);
t_error build_sym_variable_assignment(t_parse_node *self, t_ast_node *out);
t_error build_sym_variable_assignments(t_parse_node *self, t_ast_node *out);
t_error build_sym_variable_name(t_parse_node *self, t_ast_node *out);
t_error build_sym_while_statement(t_parse_node *self, t_ast_node *out);
t_error build_sym_word(t_parse_node *self, t_ast_node *out);
t_ast_node alloc_ast(t_ast_node_kind kind)
{
t_ast_node ret;
t_error build_sym_program(t_parse_node *self, t_ast_node *out)
ret = mem_alloc(sizeof(*ret));
ret->kind = kind;
if (kind == AST_ARITHMETIC_EXPANSION)
{
ret->data.arithmetic_expansion.expr = NULL;
}
else if (kind == AST_CASE)
{
ret->data.case_.word = NULL;
ret->data.case_.cases = vec_ast_new(16, free_ast);
ret->data.case_.term = AST_TERM_NONE;
}
else if (kind == AST_CASE_ITEM)
{
ret->data.case_item.term = AST_TERM_NONE;
ret->data.case_item.pattern = vec_ast_new(16, free_ast);
ret->data.case_item.body = vec_ast_new(16, free_ast);
}
else if (kind == AST_COMMAND)
{
ret->data.command.term = AST_TERM_NONE;
ret->data.command.cmd_word = vec_ast_new(16, free_ast);
ret->data.command.prefixes = vec_ast_new(16, free_ast);
ret->data.command.suffixes = vec_ast_new(16, free_ast);
}
else if (kind == AST_COMMAND_SUBSTITUTION)
{
ret->data.command_substitution.cmd = NULL;
}
else if (kind == AST_COMPOUND_STATEMENT)
{
}
else if (kind == AST_ELIF)
{
}
else if (kind == AST_ELSE)
{
}
else if (kind == AST_EMPTY)
{
}
else if (kind == AST_EXPANSION)
{
}
else if (kind == AST_FILE_REDIRECTION)
{
}
else if (kind == AST_FOR)
{
}
else if (kind == AST_FUNCTION_DEFINITION)
{
}
else if (kind == AST_HEREDOC_REDIRECTION)
{
}
else if (kind == AST_IF)
{
}
else if (kind == AST_LIST)
{
}
else if (kind == AST_PIPELINE)
{
}
else if (kind == AST_PROGRAM)
{
}
else if (kind == AST_RAW_STRING)
{
}
else if (kind == AST_STRING)
{
}
else if (kind == AST_SUBSHELL)
{
}
else if (kind == AST_UNTIL)
{
}
else if (kind == AST_VARIABLE_ASSIGNMENT)
{
}
else if (kind == AST_WHILE)
{
}
else if (kind == AST_WORD)
{
}
return (ret);
}
t_error from_node(t_parse_node node, t_ast_node *out);
t_error build_sym_arithmetic_binary_expression(t_parse_node self, t_ast_node *out);
t_error build_sym_arithmetic_expansion(t_parse_node self, t_ast_node *out);
t_error build_sym_arithmetic_literal(t_parse_node self, t_ast_node *out);
t_error build_sym_arithmetic_parenthesized_expression(t_parse_node self, t_ast_node *out);
t_error build_sym_arithmetic_postfix_expression(t_parse_node self, t_ast_node *out);
t_error build_sym_arithmetic_ternary_expression(t_parse_node self, t_ast_node *out);
t_error build_sym_arithmetic_unary_expression(t_parse_node self, t_ast_node *out);
t_error build_sym_case_item(t_parse_node self, t_ast_node *out);
t_error build_sym_case_statement(t_parse_node self, t_ast_node *out);
t_error build_sym_command(t_parse_node self, t_ast_node *out);
t_error build_sym_command_name(t_parse_node self, t_ast_node *out);
t_error build_sym_command_substitution(t_parse_node self, t_ast_node *out);
t_error build_sym_comment(t_parse_node self, t_ast_node *out);
t_error build_sym_compound_statement(t_parse_node self, t_ast_node *out);
t_error build_sym_concatenation(t_parse_node self, t_ast_node *out);
t_error build_sym_do_group(t_parse_node self, t_ast_node *out);
t_error build_sym_elif_clause(t_parse_node self, t_ast_node *out);
t_error build_sym_else_clause(t_parse_node self, t_ast_node *out);
t_error build_sym_expansion(t_parse_node self, t_ast_node *out);
t_error build_sym_expansion_expression(t_parse_node self, t_ast_node *out);
t_error build_sym_expansion_regex(t_parse_node self, t_ast_node *out);
t_error build_sym_extglob_pattern(t_parse_node self, t_ast_node *out);
t_error build_sym_file_descriptor(t_parse_node self, t_ast_node *out);
t_error build_sym_file_redirect(t_parse_node self, t_ast_node *out);
t_error build_sym_for_statement(t_parse_node self, t_ast_node *out);
t_error build_sym_function_definition(t_parse_node self, t_ast_node *out);
t_error build_sym_heredoc_body(t_parse_node self, t_ast_node *out);
t_error build_sym_heredoc_content(t_parse_node self, t_ast_node *out);
t_error build_sym_heredoc_end(t_parse_node self, t_ast_node *out);
t_error build_sym_heredoc_redirect(t_parse_node self, t_ast_node *out);
t_error build_sym_heredoc_start(t_parse_node self, t_ast_node *out);
t_error build_sym_if_statement(t_parse_node self, t_ast_node *out);
t_error build_sym_list(t_parse_node self, t_ast_node *out);
t_error build_sym_negated_command(t_parse_node self, t_ast_node *out);
t_error build_sym_number(t_parse_node self, t_ast_node *out);
t_error build_sym_pipeline(t_parse_node self, t_ast_node *out);
t_error build_sym_program(t_parse_node self, t_ast_node *out);
t_error build_sym_raw_string(t_parse_node self, t_ast_node *out);
t_error build_sym_redirected_statement(t_parse_node self, t_ast_node *out);
t_error build_sym_regex(t_parse_node self, t_ast_node *out);
t_error build_sym_simple_expansion(t_parse_node self, t_ast_node *out);
t_error build_sym_simple_heredoc_body(t_parse_node self, t_ast_node *out);
t_error build_sym_string(t_parse_node self, t_ast_node *out);
t_error build_sym_string_content(t_parse_node self, t_ast_node *out);
t_error build_sym_subshell(t_parse_node self, t_ast_node *out);
t_error build_sym_variable_assignment(t_parse_node self, t_ast_node *out);
t_error build_sym_variable_assignments(t_parse_node self, t_ast_node *out);
t_error build_sym_variable_name(t_parse_node self, t_ast_node *out);
t_error build_sym_while_statement(t_parse_node self, t_ast_node *out);
t_error build_sym_word(t_parse_node self, t_ast_node *out);
t_error build_sym_program(t_parse_node self, t_ast_node *out)
{
t_ast_node ret;
t_usize i;
t_ast_node temp;
if (self == NULL || out == NULL)
if (out == NULL)
return (ERROR);
if (ts_node_grammar_symbol(*self) != sym_program)
if (ts_node_grammar_symbol(self) != sym_program)
return (ERROR);
ret = mem_alloc(sizeof(*ret));
ret = alloc_node(AST_PROGRAM);
i = 0;
ret->kind = AST_COMPOUND_STATEMENT;
while (i < ts_node_child_count(*self))
while (i < ts_node_named_child_count(self))
{
i++;
if (i < ts_node_named_child_count(self))
{
if (from_node(ts_node_named_child(self, i)))
return (free_node(ret), ERROR);
i++;
}
if (i < ts_node_named_child_count(self) && ts_node_field_id_for_child(self, i) == field_terminator)
{
i++;
}
}
return (*out = ret, NO_ERROR);
return (mem_free(ret), ERROR);
}
t_error from_node(t_parse_node *node, t_ast_node *out)
t_error from_node(t_parse_node node, t_ast_node *out)
{
if (node == NULL || out == NULL)
if (out == NULL)
return (ERROR);
return (build_sym_word(node, out));

106
ast/src/not_done_function.c
View file

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/06/17 13:04:32 by maiboyer #+# #+# */
/* Updated: 2024/06/17 13:09:53 by maiboyer ### ########.fr */
/* Updated: 2024/06/20 14:11:07 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
@ -16,61 +16,61 @@
#include "me/types.h"
#include <stdio.h>
t_error _build_not_finished(t_parse_node *node, t_ast_node *out)
t_error _build_not_finished(t_parse_node node, t_ast_node *out)
{
(void)(node);
(void)(out);
printf("building undefined symbol '%s'\n", node->kind_str);
printf("building undefined symbol '%s'\n", ts_node_grammar_type(node));
return (ERROR);
}
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_arithmetic_binary_expression(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_arithmetic_expansion(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_arithmetic_literal(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_arithmetic_parenthesized_expression(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_arithmetic_postfix_expression(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_arithmetic_ternary_expression(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_arithmetic_unary_expression(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_case_item(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_case_statement(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_command(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_command_name(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_command_substitution(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_comment(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_compound_statement(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_concatenation(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_do_group(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_elif_clause(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_else_clause(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_expansion(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_expansion_expression(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_expansion_regex(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_extglob_pattern(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_file_descriptor(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_file_redirect(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_for_statement(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_function_definition(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_heredoc_body(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_heredoc_content(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_heredoc_end(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_heredoc_redirect(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_heredoc_start(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_if_statement(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_list(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_negated_command(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_number(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_pipeline(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_program(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_raw_string(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_redirected_statement(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_regex(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_simple_expansion(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_simple_heredoc_body(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_string(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_string_content(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_subshell(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_variable_assignment(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_variable_assignments(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_variable_name(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_while_statement(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_word(t_parse_node *self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_arithmetic_binary_expression(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_arithmetic_expansion(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_arithmetic_literal(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_arithmetic_parenthesized_expression(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_arithmetic_postfix_expression(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_arithmetic_ternary_expression(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_arithmetic_unary_expression(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_case_item(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_case_statement(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_command(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_command_name(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_command_substitution(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_comment(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_compound_statement(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_concatenation(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_do_group(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_elif_clause(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_else_clause(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_expansion(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_expansion_expression(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_expansion_regex(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_extglob_pattern(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_file_descriptor(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_file_redirect(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_for_statement(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_function_definition(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_heredoc_body(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_heredoc_content(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_heredoc_end(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_heredoc_redirect(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_heredoc_start(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_if_statement(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_list(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_negated_command(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_number(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_pipeline(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_program(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_raw_string(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_redirected_statement(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_regex(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_simple_expansion(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_simple_heredoc_body(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_string(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_string_content(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_subshell(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_variable_assignment(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_variable_assignments(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_variable_name(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_while_statement(t_parse_node self, t_ast_node *out);
t_error __attribute__((weak, alias("_build_not_finished"))) build_sym_word(t_parse_node self, t_ast_node *out);

264
parser/src/combined.c
View file

@ -52,8 +52,8 @@ bool ts_range_array_intersects(const t_range_array *self, unsigned start_index,
return false;
}
void ts_range_array_get_changed_ranges(const t_parse_range *old_ranges, unsigned old_range_count, const t_parse_range *new_ranges, unsigned new_range_count,
t_range_array *differences)
void ts_range_array_get_changed_ranges(const t_parse_range *old_ranges, unsigned old_range_count, const t_parse_range *new_ranges,
unsigned new_range_count, t_range_array *differences)
{
unsigned new_index = 0;
unsigned old_index = 0;
@ -391,8 +391,8 @@ static inline void iterator_print_state(t_iterator *self)
t_point start = iterator_start_position(self).extent;
t_point end = iterator_end_position(self).extent;
const char *name = ts_language_symbol_name(self->language, ts_subtree_symbol(*entry.subtree));
printf("(%-25s %s\t depth:%u [%u, %u] - [%u, %u])", name, self->in_padding ? "(p)" : " ", self->visible_depth, start.row + 1, start.column, end.row + 1,
end.column);
printf("(%-25s %s\t depth:%u [%u, %u] - [%u, %u])", name, self->in_padding ? "(p)" : " ", self->visible_depth, start.row + 1,
start.column, end.row + 1, end.column);
}
#endif
@ -435,8 +435,8 @@ unsigned ts_subtree_get_changed_ranges(const t_subtree *old_tree, const t_subtre
// Even if the two subtrees appear to be identical, they could differ
// internally if they contain a range of text that was previously
// excluded from the parse, and is now included, or vice-versa.
if (comparison == IteratorMatches &&
ts_range_array_intersects(included_range_differences, included_range_difference_index, position.bytes, iterator_end_position(&old_iter).bytes))
if (comparison == IteratorMatches && ts_range_array_intersects(included_range_differences, included_range_difference_index,
position.bytes, iterator_end_position(&old_iter).bytes))
{
comparison = IteratorMayDiffer;
}
@ -902,7 +902,8 @@ static void ts_lexer_goto(t_lexer *self, t_length position)
{
// If the current position is outside of the current chunk of text,
// then clear out the current chunk of text.
if (self->chunk && (self->current_position.bytes < self->chunk_start || self->current_position.bytes >= self->chunk_start + self->chunk_size))
if (self->chunk &&
(self->current_position.bytes < self->chunk_start || self->current_position.bytes >= self->chunk_start + self->chunk_size))
{
ts_lexer__clear_chunk(self);
}
@ -1593,7 +1594,8 @@ static inline t_parse_node ts_node__first_child_for_byte(t_parse_node self, uint
return ts_node__null();
}
static inline t_parse_node ts_node__descendant_for_byte_range(t_parse_node self, uint32_t range_start, uint32_t range_end, bool include_anonymous)
static inline t_parse_node ts_node__descendant_for_byte_range(t_parse_node self, uint32_t range_start, uint32_t range_end,
bool include_anonymous)
{
t_parse_node node = self;
t_parse_node last_visible_node = self;
@ -1634,7 +1636,8 @@ static inline t_parse_node ts_node__descendant_for_byte_range(t_parse_node self,
return last_visible_node;
}
static inline t_parse_node ts_node__descendant_for_point_range(t_parse_node self, t_point range_start, t_point range_end, bool include_anonymous)
static inline t_parse_node ts_node__descendant_for_point_range(t_parse_node self, t_point range_start, t_point range_end,
bool include_anonymous)
{
t_parse_node node = self;
t_parse_node last_visible_node = self;
@ -1722,8 +1725,8 @@ const char *ts_node_grammar_type(t_parse_node self)
char *ts_node_string(t_parse_node self)
{
t_symbol alias_symbol = ts_node__alias(&self);
return ts_subtree_string(ts_node__subtree(self), alias_symbol, ts_language_symbol_metadata(self.tree->language, alias_symbol).visible, self.tree->language,
false);
return ts_subtree_string(ts_node__subtree(self), alias_symbol, ts_language_symbol_metadata(self.tree->language, alias_symbol).visible,
self.tree->language, false);
}
bool ts_node_eq(t_parse_node self, t_parse_node other)
@ -1937,6 +1940,20 @@ static inline const char *ts_node__field_name_from_language(t_parse_node self, u
return NULL;
}
static inline t_field_id ts_node__field_id_from_language(t_parse_node self, uint32_t structural_child_index)
{
const t_field_map_entry *field_map, *field_map_end;
ts_language_field_map(self.tree->language, ts_node__subtree(self).ptr->production_id, &field_map, &field_map_end);
for (; field_map != field_map_end; field_map++)
{
if (!field_map->inherited && field_map->child_index == structural_child_index)
{
return field_map->field_id;
}
}
return 0;
}
const char *ts_node_field_name_for_child(t_parse_node self, uint32_t child_index)
{
t_parse_node result = self;
@ -1990,6 +2007,56 @@ const char *ts_node_field_name_for_child(t_parse_node self, uint32_t child_index
return NULL;
}
t_field_id ts_node_field_id_for_child(t_parse_node self, uint32_t child_index)
{
t_parse_node result = self;
bool did_descend = true;
t_field_id inherited_field_name = 0;
while (did_descend)
{
did_descend = false;
t_parse_node child;
uint32_t index = 0;
t_node_child_iterator iterator = ts_node_iterate_children(&result);
while (ts_node_child_iterator_next(&iterator, &child))
{
if (ts_node__is_relevant(child, true))
{
if (index == child_index)
{
if (ts_node_is_extra(child))
return 0;
t_field_id field_name = ts_node__field_id_from_language(result, iterator.structural_child_index - 1);
if (field_name)
return field_name;
return inherited_field_name;
}
index++;
}
else
{
uint32_t grandchild_index = child_index - index;
uint32_t grandchild_count = ts_node__relevant_child_count(child, true);
if (grandchild_index < grandchild_count)
{
t_field_id field_name = ts_node__field_id_from_language(result, iterator.structural_child_index - 1);
if (field_name)
inherited_field_name = field_name;
did_descend = true;
result = child;
child_index = grandchild_index;
break;
}
index += grandchild_count;
}
}
}
return 0;
}
t_parse_node ts_node_child_by_field_name(t_parse_node self, const char *name, uint32_t name_length)
{
t_field_id field_id = ts_language_field_id_for_name(self.tree->language, name, name_length);
@ -2441,8 +2508,8 @@ static t_subtree ts_parser__lex(t_first_parser *self, t_stack_version version, t
if (found_token)
{
external_scanner_state_len = ts_parser__external_scanner_serialize(self);
external_scanner_state_changed =
!ts_external_scanner_state_eq(ts_subtree_external_scanner_state(external_token), self->lexer.debug_buffer, external_scanner_state_len);
external_scanner_state_changed = !ts_external_scanner_state_eq(ts_subtree_external_scanner_state(external_token),
self->lexer.debug_buffer, external_scanner_state_len);
// When recovering from an error, ignore any zero-length
// external tokens unless they have changed the external
@ -2543,8 +2610,8 @@ static t_subtree ts_parser__lex(t_first_parser *self, t_stack_version version, t
}
}
result = ts_subtree_new_leaf(&self->tree_pool, symbol, padding, size, lookahead_bytes, parse_state, found_external_token, called_get_column, is_keyword,
self->language);
result = ts_subtree_new_leaf(&self->tree_pool, symbol, padding, size, lookahead_bytes, parse_state, found_external_token,
called_get_column, is_keyword, self->language);
if (found_external_token)
{
@ -2556,10 +2623,12 @@ static t_subtree ts_parser__lex(t_first_parser *self, t_stack_version version, t
return result;
}
static t_subtree ts_parser__get_cached_token(t_first_parser *self, t_state_id state, size_t position, t_subtree last_external_token, t_table_entry *table_entry)
static t_subtree ts_parser__get_cached_token(t_first_parser *self, t_state_id state, size_t position, t_subtree last_external_token,
t_table_entry *table_entry)
{
t_token_cache *cache = &self->token_cache;
if (cache->token.ptr && cache->byte_index == position && ts_subtree_external_scanner_state_eq(cache->last_external_token, last_external_token))
if (cache->token.ptr && cache->byte_index == position &&
ts_subtree_external_scanner_state_eq(cache->last_external_token, last_external_token))
{
ts_language_table_entry(self->language, state, ts_subtree_symbol(cache->token), table_entry);
if (ts_parser__can_reuse_first_leaf(self, state, cache->token, table_entry))
@ -2589,11 +2658,12 @@ static void ts_parser__set_cached_token(t_first_parser *self, uint32_t byte_inde
static bool ts_parser__has_included_range_difference(const t_first_parser *self, uint32_t start_position, uint32_t end_position)
{
return ts_range_array_intersects(&self->included_range_differences, self->included_range_difference_index, start_position, end_position);
return ts_range_array_intersects(&self->included_range_differences, self->included_range_difference_index, start_position,
end_position);
}
static t_subtree ts_parser__reuse_node(t_first_parser *self, t_stack_version version, t_state_id *state, uint32_t position, t_subtree last_external_token,
t_table_entry *table_entry)
static t_subtree ts_parser__reuse_node(t_first_parser *self, t_stack_version version, t_state_id *state, uint32_t position,
t_subtree last_external_token, t_table_entry *table_entry)
{
t_subtree result;
while ((result = reusable_node_tree(&self->reusable_node)).ptr)
@ -2756,8 +2826,8 @@ static void ts_parser__shift(t_first_parser *self, t_stack_version version, t_st
}
}
static t_stack_version ts_parser__reduce(t_first_parser *self, t_stack_version version, t_symbol symbol, uint32_t count, int dynamic_precedence,
uint16_t production_id, bool is_fragile, bool end_of_non_terminal_extra)
static t_stack_version ts_parser__reduce(t_first_parser *self, t_stack_version version, t_symbol symbol, uint32_t count,
int dynamic_precedence, uint16_t production_id, bool is_fragile, bool end_of_non_terminal_extra)
{
uint32_t initial_version_count = ts_stack_version_count(self->stack);
@ -3000,7 +3070,8 @@ static bool ts_parser__do_all_potential_reductions(t_first_parser *self, t_stack
{
t_reduce_action action = self->reduce_actions.contents[j];
reduction_version = ts_parser__reduce(self, version, action.symbol, action.count, action.dynamic_precedence, action.production_id, true, false);
reduction_version =
ts_parser__reduce(self, version, action.symbol, action.count, action.dynamic_precedence, action.production_id, true, false);
}
if (has_shift_action)
@ -3312,7 +3383,8 @@ static void ts_parser__handle_error(t_first_parser *self, t_stack_version versio
uint32_t lookahead_bytes = ts_subtree_total_bytes(lookahead) + ts_subtree_lookahead_bytes(lookahead);
t_stack_version version_with_missing_tree = ts_stack_copy_version(self->stack, v);
t_subtree missing_tree = ts_subtree_new_missing_leaf(&self->tree_pool, missing_symbol, padding, lookahead_bytes, self->language);
t_subtree missing_tree =
ts_subtree_new_missing_leaf(&self->tree_pool, missing_symbol, padding, lookahead_bytes, self->language);
ts_stack_push(self->stack, 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)))
@ -4024,7 +4096,8 @@ static void stream_scan_identifier(t_stream *stream)
do
{
stream_advance(stream);
} while (me_isalnum(stream->next) || stream->next == '_' || stream->next == '-' || stream->next == '.' || stream->next == '?' || stream->next == '!');
} while (me_isalnum(stream->next) || stream->next == '_' || stream->next == '-' || stream->next == '.' || stream->next == '?' ||
stream->next == '!');
}
static uint32_t stream_offset(t_stream *self)
@ -4637,7 +4710,8 @@ static inline t_analysis_state *analysis_state_pool__clone_or_reuse(t_analysis_s
//
// The caller retains ownership of the passed-in memory. However, the clone that
// is created by this function will be managed by the state set.
static inline void analysis_state_set__insert_sorted(t_analysis_state_set *self, t_analysis_state_set *pool, t_analysis_state *borrowed_item)
static inline void analysis_state_set__insert_sorted(t_analysis_state_set *self, t_analysis_state_set *pool,
t_analysis_state *borrowed_item)
{
unsigned index, exists;
array_search_sorted_with(self, analysis_state__compare, &borrowed_item, &index, &exists);
@ -4843,8 +4917,8 @@ static void ts_query__perform_analysis(t_parse_query *self, const t_analysis_sub
printf(" %3u: step: %u, stack: [", j, state->step_index);
for (unsigned k = 0; k < state->depth; k++)
{
printf(" {%s, child: %u, state: %4u", self->language->symbol_names[state->stack[k].parent_symbol], state->stack[k].child_index,
state->stack[k].parse_state);
printf(" {%s, child: %u, state: %4u", self->language->symbol_names[state->stack[k].parent_symbol],
state->stack[k].child_index, state->stack[k].parse_state);
if (state->stack[k].field_id)
printf(", field: %s", self->language->field_names[state->stack[k].field_id]);
if (state->stack[k].done)
@ -4971,7 +5045,9 @@ static void ts_query__perform_analysis(t_parse_query *self, const t_analysis_sub
// Use the subgraph to determine what alias and field will
// eventually be applied to this child node.
t_symbol alias = ts_language_alias_at(self->language, node->production_id, child_index);
t_symbol visible_symbol = alias ? alias : self->language->symbol_metadata[sym].visible ? self->language->public_symbol_map[sym] : 0;
t_symbol visible_symbol = alias ? alias
: self->language->symbol_metadata[sym].visible ? self->language->public_symbol_map[sym]
: 0;
t_field_id field_id = parent_field_id;
if (!field_id)
{
@ -5566,8 +5642,8 @@ static bool ts_query__analyze_patterns(t_parse_query *self, unsigned *error_offs
printf(" %u: {symbol: %s, field: %s, depth: %u, "
"parent_pattern_guaranteed: %d, root_pattern_guaranteed: %d}\n",
i, (step->symbol == WILDCARD_SYMBOL) ? "ANY" : ts_language_symbol_name(self->language, step->symbol),
(step->field ? ts_language_field_name_for_id(self->language, step->field) : "-"), step->depth, step->parent_pattern_guaranteed,
step->root_pattern_guaranteed);
(step->field ? ts_language_field_name_for_id(self->language, step->field) : "-"), step->depth,
step->parent_pattern_guaranteed, step->root_pattern_guaranteed);
}
}
#endif
@ -6374,7 +6450,8 @@ static t_query_error ts_query__parse_pattern(t_parse_query *self, t_stream *stre
return 0;
}
t_parse_query *ts_query_new(const t_language *language, const char *source, uint32_t source_len, uint32_t *error_offset, t_query_error *error_type)
t_parse_query *ts_query_new(const t_language *language, const char *source, uint32_t source_len, uint32_t *error_offset,
t_query_error *error_type)
{
t_parse_query *self = malloc(sizeof(t_parse_query));
@ -6473,8 +6550,9 @@ t_parse_query *ts_query_new(const t_language *language, const char *source, uint
}
}
ts_query__pattern_map_insert(self, step->symbol,
(t_pattern_entry){.step_index = start_step_index, .pattern_index = pattern_index, .is_rooted = is_rooted});
ts_query__pattern_map_insert(
self, step->symbol,
(t_pattern_entry){.step_index = start_step_index, .pattern_index = pattern_index, .is_rooted = is_rooted});
if (step->symbol == WILDCARD_SYMBOL)
{
self->wildcard_root_pattern_count++;
@ -6796,8 +6874,8 @@ void ts_query_cursor_set_point_range(t_query_cursor *self, t_point start_point,
// Search through all of the in-progress states, and find the captured
// node that occurs earliest in the document.
static bool ts_query_cursor__first_in_progress_capture(t_query_cursor *self, uint32_t *state_index, uint32_t *byte_offset, uint32_t *pattern_index,
bool *root_pattern_guaranteed)
static bool ts_query_cursor__first_in_progress_capture(t_query_cursor *self, uint32_t *state_index, uint32_t *byte_offset,
uint32_t *pattern_index, bool *root_pattern_guaranteed)
{
bool result = false;
*state_index = UINT32_MAX;
@ -6867,8 +6945,8 @@ int ts_query_cursor__compare_nodes(t_parse_node left, t_parse_node right)
}
// Determine if either state contains a superset of the other state's captures.
void ts_query_cursor__compare_captures(t_query_cursor *self, t_query_state *left_state, t_query_state *right_state, bool *left_contains_right,
bool *right_contains_left)
void ts_query_cursor__compare_captures(t_query_cursor *self, t_query_state *left_state, t_query_state *right_state,
bool *left_contains_right, bool *right_contains_left)
{
const t_capture_list *left_captures = capture_list_pool_get(&self->capture_list_pool, left_state->capture_list_id);
const t_capture_list *right_captures = capture_list_pool_get(&self->capture_list_pool, right_state->capture_list_id);
@ -7002,7 +7080,8 @@ static t_capture_list *ts_query_cursor__prepare_to_capture(t_query_cursor *self,
{
self->did_exceed_match_limit = true;
uint32_t state_index, byte_offset, pattern_index;
if (ts_query_cursor__first_in_progress_capture(self, &state_index, &byte_offset, &pattern_index, NULL) && state_index != state_index_to_preserve)
if (ts_query_cursor__first_in_progress_capture(self, &state_index, &byte_offset, &pattern_index, NULL) &&
state_index != state_index_to_preserve)
{
LOG(" abandon state. index:%u, pattern:%u, offset:%u.\n", state_index, pattern_index, byte_offset);
t_query_state *other_state = &self->states.contents[state_index];
@ -7224,14 +7303,14 @@ static inline bool ts_query_cursor__advance(t_query_cursor *self, bool stop_on_d
// Get the properties of the current node.
t_parse_node node = ts_tree_cursor_current_node(&self->cursor);
t_parse_node parent_node = ts_tree_cursor_parent_node(&self->cursor);
bool parent_precedes_range = !ts_node_is_null(parent_node) &&
(ts_node_end_byte(parent_node) <= self->start_byte || point_lte(ts_node_end_point(parent_node), self->start_point));
bool parent_follows_range = !ts_node_is_null(parent_node) &&
(ts_node_start_byte(parent_node) >= self->end_byte || point_gte(ts_node_start_point(parent_node), self->end_point));
bool node_precedes_range =
parent_precedes_range || (ts_node_end_byte(node) <= self->start_byte || point_lte(ts_node_end_point(node), self->start_point));
bool node_follows_range =
parent_follows_range || (ts_node_start_byte(node) >= self->end_byte || point_gte(ts_node_start_point(node), self->end_point));
bool parent_precedes_range = !ts_node_is_null(parent_node) && (ts_node_end_byte(parent_node) <= self->start_byte ||
point_lte(ts_node_end_point(parent_node), self->start_point));
bool parent_follows_range = !ts_node_is_null(parent_node) && (ts_node_start_byte(parent_node) >= self->end_byte ||
point_gte(ts_node_start_point(parent_node), self->end_point));
bool node_precedes_range = parent_precedes_range || (ts_node_end_byte(node) <= self->start_byte ||
point_lte(ts_node_end_point(node), self->start_point));
bool node_follows_range = parent_follows_range ||
(ts_node_start_byte(node) >= self->end_byte || point_gte(ts_node_start_point(node), self->end_point));
bool parent_intersects_range = !parent_precedes_range && !parent_follows_range;
bool node_intersects_range = !node_precedes_range && !node_follows_range;
@ -7249,8 +7328,8 @@ static inline bool ts_query_cursor__advance(t_query_cursor *self, bool stop_on_d
&can_have_later_siblings_with_this_field, supertypes, &supertype_count);
LOG("enter node. depth:%u, type:%s, field:%s, row:%u "
"state_count:%u, finished_state_count:%u\n",
self->depth, ts_node_type(node), ts_language_field_name_for_id(self->query->language, field_id), ts_node_start_point(node).row,
self->states.size, self->finished_states.size);
self->depth, ts_node_type(node), ts_language_field_name_for_id(self->query->language, field_id),
ts_node_start_point(node).row, self->states.size, self->finished_states.size);
bool node_is_error = symbol == ts_builtin_sym_error;
bool parent_is_error = !ts_node_is_null(parent_node) && ts_node_symbol(parent_node) == ts_builtin_sym_error;
@ -7441,7 +7520,8 @@ static inline bool ts_query_cursor__advance(t_query_cursor *self, bool stop_on_d
do
{
skipped_wildcard_step--;
} while (skipped_wildcard_step->is_dead_end || skipped_wildcard_step->is_pass_through || skipped_wildcard_step->depth > 0);
} while (skipped_wildcard_step->is_dead_end || skipped_wildcard_step->is_pass_through ||
skipped_wildcard_step->depth > 0);
if (skipped_wildcard_step->capture_ids[0] != NONE)
{
LOG(" capture wildcard parent\n");
@ -7514,7 +7594,8 @@ static inline bool ts_query_cursor__advance(t_query_cursor *self, bool stop_on_d
LOG(" split state for branch. pattern:%u, "
"from_step:%u, to_step:%u, immediate:%d, "
"capture_count: %u\n",
copy->pattern_index, copy->step_index, next_step->alternative_index, next_step->alternative_is_immediate,
copy->pattern_index, copy->step_index, next_step->alternative_index,
next_step->alternative_is_immediate,
capture_list_pool_get(&self->capture_list_pool, copy->capture_list_id)->size);
end_index++;
copy_count++;
@ -7701,8 +7782,8 @@ bool ts_query_cursor_next_capture(t_query_cursor *self, t_query_match *match, ui
uint32_t first_unfinished_pattern_index;
uint32_t first_unfinished_state_index;
bool first_unfinished_state_is_definite = false;
ts_query_cursor__first_in_progress_capture(self, &first_unfinished_state_index, &first_unfinished_capture_byte, &first_unfinished_pattern_index,
&first_unfinished_state_is_definite);
ts_query_cursor__first_in_progress_capture(self, &first_unfinished_state_index, &first_unfinished_capture_byte,
&first_unfinished_pattern_index, &first_unfinished_state_is_definite);
// Then find the earliest capture in a finished match. It must occur
// before the first capture in an *unfinished* match.
@ -7724,7 +7805,8 @@ bool ts_query_cursor_next_capture(t_query_cursor *self, t_query_match *match, ui
t_parse_node node = captures->contents[state->consumed_capture_count].node;
bool node_precedes_range = (ts_node_end_byte(node) <= self->start_byte || point_lte(ts_node_end_point(node), self->start_point));
bool node_precedes_range =
(ts_node_end_byte(node) <= self->start_byte || point_lte(ts_node_end_point(node), self->start_point));
bool node_follows_range = (ts_node_start_byte(node) >= self->end_byte || point_gte(ts_node_start_point(node), self->end_point));
bool node_outside_of_range = node_precedes_range || node_follows_range;
@ -7865,7 +7947,8 @@ static uint32_t stack__subtree_node_count(t_subtree subtree)
return count;
}
static t_stack_node *stack_node_new(t_stack_node *previous_node, t_subtree subtree, bool is_pending, t_state_id state, t_stack_node_array *pool)
static t_stack_node *stack_node_new(t_stack_node *previous_node, t_subtree subtree, bool is_pending, t_state_id state,
t_stack_node_array *pool)
{
t_stack_node *node = pool->size > 0 ? array_pop(pool) : malloc(sizeof(t_stack_node));
*node = (t_stack_node){.ref_count = 1, .link_count = 0, .state = state};
@ -7916,9 +7999,9 @@ static bool stack__subtree_is_equivalent(t_subtree left, t_subtree right)
if (ts_subtree_error_cost(left) > 0 && ts_subtree_error_cost(right) > 0)
return true;
return (ts_subtree_padding(left).bytes == ts_subtree_padding(right).bytes && ts_subtree_size(left).bytes == ts_subtree_size(right).bytes &&
ts_subtree_child_count(left) == ts_subtree_child_count(right) && ts_subtree_extra(left) == ts_subtree_extra(right) &&
ts_subtree_external_scanner_state_eq(left, right));
return (ts_subtree_padding(left).bytes == ts_subtree_padding(right).bytes &&
ts_subtree_size(left).bytes == ts_subtree_size(right).bytes && ts_subtree_child_count(left) == ts_subtree_child_count(right) &&
ts_subtree_extra(left) == ts_subtree_extra(right) && ts_subtree_external_scanner_state_eq(left, right));
}
static void stack_node_add_link(t_stack_node *self, t_stack_link link, t_subtree_pool *subtree_pool)
@ -8046,7 +8129,8 @@ static void ts_stack__add_slice(t_stack *self, t_stack_version original_version,
array_push(&self->slices, slice);
}
static t_stack_slice_array stack__iter(t_stack *self, t_stack_version version, t_stack_callback callback, void *payload, int goal_subtree_count)
static t_stack_slice_array stack__iter(t_stack *self, t_stack_version version, t_stack_callback callback, void *payload,
int goal_subtree_count)
{
array_clear(&self->slices);
array_clear(&self->iterators);
@ -8729,12 +8813,13 @@ static void ts_subtree_pool_free(t_subtree_pool *self, t_subtree_heap_data *tree
static inline bool ts_subtree_can_inline(t_length padding, t_length size, uint32_t lookahead_bytes)
{
return padding.bytes < TS_MAX_INLINE_TREE_LENGTH && padding.extent.row < 16 && padding.extent.column < TS_MAX_INLINE_TREE_LENGTH && size.extent.row == 0 &&
size.extent.column < TS_MAX_INLINE_TREE_LENGTH && lookahead_bytes < 16;
return padding.bytes < TS_MAX_INLINE_TREE_LENGTH && padding.extent.row < 16 && padding.extent.column < TS_MAX_INLINE_TREE_LENGTH &&
size.extent.row == 0 && size.extent.column < TS_MAX_INLINE_TREE_LENGTH && lookahead_bytes < 16;
}
t_subtree ts_subtree_new_leaf(t_subtree_pool *pool, t_symbol symbol, t_length padding, t_length size, uint32_t lookahead_bytes, t_state_id parse_state,
bool has_external_tokens, bool depends_on_column, bool is_keyword, const t_language *language)
t_subtree ts_subtree_new_leaf(t_subtree_pool *pool, t_symbol symbol, t_length padding, t_length size, uint32_t lookahead_bytes,
t_state_id parse_state, bool has_external_tokens, bool depends_on_column, bool is_keyword,
const t_language *language)
{
t_symbol_metadata metadata = ts_language_symbol_metadata(language, symbol);
bool extra = symbol == ts_builtin_sym_end;
@ -8805,10 +8890,11 @@ void ts_subtree_set_symbol(t_mutable_subtree *self, t_symbol symbol, const t_lan
}
}
t_subtree ts_subtree_new_error(t_subtree_pool *pool, int32_t lookahead_char, t_length padding, t_length size, uint32_t bytes_scanned, t_state_id parse_state,
const t_language *language)
t_subtree ts_subtree_new_error(t_subtree_pool *pool, int32_t lookahead_char, t_length padding, t_length size, uint32_t bytes_scanned,
t_state_id parse_state, const t_language *language)
{
t_subtree result = ts_subtree_new_leaf(pool, ts_builtin_sym_error, padding, size, bytes_scanned, parse_state, false, false, false, language);
t_subtree result =
ts_subtree_new_leaf(pool, ts_builtin_sym_error, padding, size, bytes_scanned, parse_state, false, false, false, language);
t_subtree_heap_data *data = (t_subtree_heap_data *)result.ptr;
data->fragile_left = true;
data->fragile_right = true;
@ -8871,7 +8957,8 @@ static void ts_subtree__compress(t_mutable_subtree self, unsigned count, const t
break;
t_mutable_subtree grandchild = ts_subtree_to_mut_unsafe(ts_subtree_children(child)[0]);
if (grandchild.data.is_inline || grandchild.ptr->child_count < 2 || grandchild.ptr->ref_count > 1 || grandchild.ptr->symbol != symbol)
if (grandchild.data.is_inline || grandchild.ptr->child_count < 2 || grandchild.ptr->ref_count > 1 ||
grandchild.ptr->symbol != symbol)
break;
ts_subtree_children(tree)[0] = ts_subtree_from_mut(grandchild);
@ -9045,8 +9132,8 @@ void ts_subtree_summarize_children(t_mutable_subtree self, const t_language *lan
if (self.ptr->symbol == ts_builtin_sym_error || self.ptr->symbol == ts_builtin_sym_error_repeat)
{
self.ptr->error_cost +=
ERROR_COST_PER_RECOVERY + ERROR_COST_PER_SKIPPED_CHAR * self.ptr->size.bytes + ERROR_COST_PER_SKIPPED_LINE * self.ptr->size.extent.row;
self.ptr->error_cost += ERROR_COST_PER_RECOVERY + ERROR_COST_PER_SKIPPED_CHAR * self.ptr->size.bytes +
ERROR_COST_PER_SKIPPED_LINE * self.ptr->size.extent.row;
}
if (self.ptr->child_count > 0)
@ -9128,7 +9215,8 @@ t_subtree ts_subtree_new_error_node(t_subtree_array *children, bool extra, const
//
// 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(t_subtree_pool *pool, t_symbol symbol, t_length padding, uint32_t lookahead_bytes, const t_language *language)
t_subtree ts_subtree_new_missing_leaf(t_subtree_pool *pool, t_symbol symbol, t_length padding, uint32_t lookahead_bytes,
const t_language *language)
{
t_subtree result = ts_subtree_new_leaf(pool, symbol, padding, length_zero(), lookahead_bytes, 0, false, false, false, language);
if (result.data.is_inline)
@ -9425,8 +9513,8 @@ t_subtree ts_subtree_last_external_token(t_subtree tree)
static const char *const ROOT_FIELD = "__ROOT__";
static size_t ts_subtree__write_to_string(t_subtree self, char *string, size_t limit, const t_language *language, bool include_all, t_symbol alias_symbol,
bool alias_is_named, const char *field_name)
static size_t ts_subtree__write_to_string(t_subtree self, char *string, size_t limit, const t_language *language, bool include_all,
t_symbol alias_symbol, bool alias_is_named, const char *field_name)
{
(void)(self);
(void)(string);
@ -9571,11 +9659,12 @@ t_parse_range *ts_tree_get_changed_ranges(const t_first_tree *old_tree, const t_
ts_tree_cursor_init(&cursor2, ts_tree_root_node(new_tree));
t_range_array included_range_differences = array_new();
ts_range_array_get_changed_ranges(old_tree->included_ranges, old_tree->included_range_count, new_tree->included_ranges, new_tree->included_range_count,
&included_range_differences);
ts_range_array_get_changed_ranges(old_tree->included_ranges, old_tree->included_range_count, new_tree->included_ranges,
new_tree->included_range_count, &included_range_differences);
t_parse_range *result;
*length = ts_subtree_get_changed_ranges(&old_tree->root, &new_tree->root, &cursor1, &cursor2, old_tree->language, &included_range_differences, &result);
*length = ts_subtree_get_changed_ranges(&old_tree->root, &new_tree->root, &cursor1, &cursor2, old_tree->language,
&included_range_differences, &result);
array_delete(&included_range_differences);
array_delete(&cursor1.stack);
@ -9944,7 +10033,8 @@ int64_t ts_tree_cursor_goto_first_child_for_point(t_tree_cursor *self, t_point g
return ts_tree_cursor_goto_first_child_for_byte_and_point(self, 0, goal_point);
}
t_tree_cursor_step ts_tree_cursor_goto_sibling_internal(t_tree_cursor *_self, bool (*advance)(t_cursor_child_iterator *, t_tree_cursor_entry *, bool *))
t_tree_cursor_step ts_tree_cursor_goto_sibling_internal(t_tree_cursor *_self,
bool (*advance)(t_cursor_child_iterator *, t_tree_cursor_entry *, bool *))
{
t_tree_cursor *self = (t_tree_cursor *)_self;
uint32_t initial_size = self->stack.size;
@ -10077,8 +10167,8 @@ void ts_tree_cursor_goto_descendant(t_tree_cursor *_self, uint32_t goal_descenda
{
uint32_t i = self->stack.size - 1;
t_tree_cursor_entry *entry = &self->stack.contents[i];
uint32_t next_descendant_index =
entry->descendant_index + (ts_tree_cursor_is_entry_visible(self, i) ? 1 : 0) + ts_subtree_visible_descendant_count(*entry->subtree);
uint32_t next_descendant_index = entry->descendant_index + (ts_tree_cursor_is_entry_visible(self, i) ? 1 : 0) +
ts_subtree_visible_descendant_count(*entry->subtree);
if ((entry->descendant_index <= goal_descendant_index) && (next_descendant_index > goal_descendant_index))
{
break;
@ -10140,15 +10230,17 @@ t_parse_node ts_tree_cursor_current_node(const t_tree_cursor *_self)
if (self->stack.size > 1 && !ts_subtree_extra(*last_entry->subtree))
{
t_tree_cursor_entry *parent_entry = &self->stack.contents[self->stack.size - 2];
alias_symbol = ts_language_alias_at(self->tree->language, parent_entry->subtree->ptr->production_id, last_entry->structural_child_index);
alias_symbol =
ts_language_alias_at(self->tree->language, parent_entry->subtree->ptr->production_id, last_entry->structural_child_index);
}
return ts_node_new(self->tree, last_entry->subtree, last_entry->position, alias_symbol);
}
// Private - Get various facts about the current node that are needed
// when executing tree queries.
void ts_tree_cursor_current_status(const t_tree_cursor *_self, t_field_id *field_id, bool *has_later_siblings, bool *has_later_named_siblings,
bool *can_have_later_siblings_with_this_field, t_symbol *supertypes, unsigned *supertype_count)
void ts_tree_cursor_current_status(const t_tree_cursor *_self, t_field_id *field_id, bool *has_later_siblings,
bool *has_later_named_siblings, bool *can_have_later_siblings_with_this_field, t_symbol *supertypes,
unsigned *supertype_count)
{
const t_tree_cursor *self = (const t_tree_cursor *)_self;
unsigned max_supertypes = *supertype_count;
@ -10167,8 +10259,8 @@ void ts_tree_cursor_current_status(const t_tree_cursor *_self, t_field_id *field
const t_symbol *alias_sequence = ts_language_alias_sequence(self->tree->language, parent_entry->subtree->ptr->production_id);
#define subtree_symbol(subtree, structural_child_index) \
((!ts_subtree_extra(subtree) && alias_sequence && alias_sequence[structural_child_index]) ? alias_sequence[structural_child_index] \
#define subtree_symbol(subtree, structural_child_index) \
((!ts_subtree_extra(subtree) && alias_sequence && alias_sequence[structural_child_index]) ? alias_sequence[structural_child_index] \
: ts_subtree_symbol(subtree))
// Stop walking up when a visible ancestor is found.
@ -10194,7 +10286,8 @@ void ts_tree_cursor_current_status(const t_tree_cursor *_self, t_field_id *field
for (unsigned j = entry->child_index + 1; j < sibling_count; j++)
{
t_subtree sibling = ts_subtree_children(*parent_entry->subtree)[j];
t_symbol_metadata sibling_metadata = ts_language_symbol_metadata(self->tree->language, subtree_symbol(sibling, structural_child_index));
t_symbol_metadata sibling_metadata =
ts_language_symbol_metadata(self->tree->language, subtree_symbol(sibling, structural_child_index));
if (sibling_metadata.visible)
{
*has_later_siblings = true;
@ -10284,7 +10377,8 @@ t_parse_node ts_tree_cursor_parent_node(const t_tree_cursor *_self)
if (i > 0)
{
t_tree_cursor_entry *parent_entry = &self->stack.contents[i - 1];
alias_symbol = ts_language_alias_at(self->tree->language, parent_entry->subtree->ptr->production_id, entry->structural_child_index);
alias_symbol =
ts_language_alias_at(self->tree->language, parent_entry->subtree->ptr->production_id, entry->structural_child_index);
is_visible = (alias_symbol != 0) || ts_subtree_visible(*entry->subtree);
}
if (is_visible)

1
parser/src/combined.h
View file

@ -77,6 +77,7 @@ void ts_node_edit(t_parse_node *self, const t_input_edit *edit);
t_u32 ts_node_end_byte(t_parse_node self);
t_point ts_node_end_point(t_parse_node self);
bool ts_node_eq(t_parse_node self, t_parse_node other);
t_field_id ts_node_field_id_for_child(t_parse_node self, t_u32 child_index);
const char *ts_node_field_name_for_child(t_parse_node self, t_u32 child_index);
t_parse_node ts_node_first_child_for_byte(t_parse_node self, t_u32 byte);
t_parse_node ts_node_first_named_child_for_byte(t_parse_node self, t_u32 byte);

26
sources/main.c
View file

@ -6,7 +6,7 @@
/* By: rparodi <rparodi@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/03/28 14:40:38 by rparodi #+# #+# */
/* Updated: 2024/06/17 13:27:16 by maiboyer ### ########.fr */
/* Updated: 2024/06/19 13:45:53 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
@ -30,23 +30,14 @@
#include "ast/ast.h"
t_error from_node();
t_first_parser *ts_parser_new();
void ts_tree_delete(t_first_tree *);
t_parse_node ts_tree_root_node(t_first_tree *);
t_first_tree *ts_parser_parse_string(t_first_parser *, t_first_tree *oldtree,
t_const_str input, t_usize len);
void ts_parser_delete(t_first_parser *self);
void ts_parser_set_language(t_first_parser *self, t_language *lang);
t_error from_node(t_parse_node *node, t_ast_node *out);
// Foutre envp dans env
// Chaque elemenet d'envp split au premier =
// cle avant le =
// data apres le =
t_error split_str_first(t_const_str s, char splitter, t_str *before,
t_str *after)
t_error split_str_first(t_const_str s, char splitter, t_str *before, t_str *after)
{
t_usize i;
@ -106,8 +97,7 @@ void print_node_data(t_node *t, t_usize depth)
idx = 0;
if (t->kind == 7)
return;
printf("\x1b[%im[%s](%lu)\x1b[0m", t->field_str == NULL ? 90 : 32,
t->field_str == NULL ? "nil" : t->field_str, t->field);
printf("\x1b[%im[%s](%lu)\x1b[0m", t->field_str == NULL ? 90 : 32, t->field_str == NULL ? "nil" : t->field_str, t->field);
while (idx++ < depth + 1)
printf("\t");
idx = 0;
@ -121,9 +111,13 @@ t_node parse_to_nodes(t_first_parser *parser, t_const_str input)
t_first_tree *tree;
t_parse_node node;
t_node ret;
t_ast_node out;
tree = ts_parser_parse_string(parser, NULL, input, str_len(input));
node = ts_tree_root_node(tree);
if (from_node(&node, &out))
printf("Error when building node\n");
(void)(out);
ret = build_node(node, input);
ts_tree_delete(tree);
return (ret);
@ -156,11 +150,9 @@ void print_node_concat(t_node *self)
void exec_shcat(t_utils *shcat)
{
t_i32 ret;
t_ast_node out;
t_i32 ret;
print_node_data(&shcat->current_node, 0);
from_node(&shcat->current_node, &out);
handle_program(&shcat->current_node, shcat, &ret);
free_node(shcat->current_node);
(void)ret;

10
sources/node/node.c
View file

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/04/28 18:36:40 by maiboyer #+# #+# */
/* Updated: 2024/06/09 20:53:16 by maiboyer ### ########.fr */
/* Updated: 2024/06/19 13:38:50 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
@ -16,15 +16,7 @@
#include "parser/api.h"
#include <stdio.h>
t_const_str ts_node_field_name_for_child(t_parse_node self, t_u32 child_index);
t_const_str ts_node_type(t_parse_node self);
t_node build_node(t_parse_node current, t_const_str input);
t_parse_node ts_node_named_child(t_parse_node parent, t_usize idx);
t_symbol ts_node_symbol(t_parse_node self);
t_u32 ts_node_end_byte(t_parse_node self);
t_u32 ts_node_named_child_count(t_parse_node self);
t_u32 ts_node_start_byte(t_parse_node self);
t_u64 ts_language_field_id_for_name(t_language *lang, t_const_str name, t_u64 name_len);
t_language *tree_sitter_bash(void);