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

Updated parser to be more normed

Browse source
This commit is contained in:
Maieul BOYER 2024-09-02 18:07:55 +02:00
parent 5e091fdf85
commit 62ac9f3813
No known key found for this signature in database
16 changed files with 166 additions and 131 deletions
Download patch file Download diff file Expand all files Collapse all files

6
ast/Filelist.ast.mk
View file

@ -1,6 +1,8 @@
SRC_FILES = \ SRC_FILES = \
_here_doc_not_done \
_not_done_boucle_print \
_not_done_function \ _not_done_function \
_not_done_print \ _not_done_scripting_print \
ast_alloc/ast_alloc \ ast_alloc/ast_alloc \
ast_alloc/ast_alloc_scripting \ ast_alloc/ast_alloc_scripting \
ast_free/ast_free \ ast_free/ast_free \
@ -10,6 +12,7 @@ from_node/artihmetic_node \
from_node/boucle_node \ from_node/boucle_node \
from_node/condition_node \ from_node/condition_node \
from_node/dev_node \ from_node/dev_node \
from_node/exec_node \
from_node/expansion_node \ from_node/expansion_node \
from_node/file_node \ from_node/file_node \
from_node/from_node \ from_node/from_node \
@ -17,6 +20,7 @@ from_node/node_utils \
from_node/node_utils2 \ from_node/node_utils2 \
from_node/redirect_node \ from_node/redirect_node \
from_node/scripting_node \ from_node/scripting_node \
from_node/string_node \
print_ast/ast_print \ print_ast/ast_print \
print_ast/ast_print_arithmetic \ print_ast/ast_print_arithmetic \
print_ast/ast_print_command \ print_ast/ast_print_command \

5
parser/src/misc/external_scanner_state.c
View file

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/08/24 13:55:33 by maiboyer #+# #+# */ /* Created: 2024/08/24 13:55:33 by maiboyer #+# #+# */
/* Updated: 2024/08/31 17:38:04 by maiboyer ### ########.fr */ /* Updated: 2024/09/02 18:05:53 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@ -37,7 +37,8 @@ void ts_external_scanner_state_delete(t_external_scanner_state *self)
mem_free(self->long_data); mem_free(self->long_data);
} }
const t_u8 *ts_external_scanner_state_data(const t_external_scanner_state *self) const t_u8 *ts_external_scanner_state_data(\
const t_external_scanner_state *self)
{ {
return ((const t_u8 *)self->long_data); return ((const t_u8 *)self->long_data);
} }

5
parser/src/misc/external_scanner_state2.c
View file

@ -6,14 +6,15 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/08/31 17:37:45 by maiboyer #+# #+# */ /* Created: 2024/08/31 17:37:45 by maiboyer #+# #+# */
/* Updated: 2024/08/31 17:38:07 by maiboyer ### ########.fr */ /* Updated: 2024/09/02 18:06:09 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#include "parser/external_scanner_state.h" #include "parser/external_scanner_state.h"
#include "parser/subtree.h" #include "parser/subtree.h"
const t_external_scanner_state *ts_subtree_external_scanner_state(t_subtree self) const t_external_scanner_state *ts_subtree_external_scanner_state(\
t_subtree self)
{ {
static const t_external_scanner_state empty_state = {NULL, .length = 0}; static const t_external_scanner_state empty_state = {NULL, .length = 0};

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

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/08/31 17:14:00 by maiboyer #+# #+# */ /* Created: 2024/08/31 17:14:00 by maiboyer #+# #+# */
/* Updated: 2024/08/31 17:28:20 by maiboyer ### ########.fr */ /* Updated: 2024/09/02 18:07:07 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@ -16,7 +16,7 @@
NodeChildIterator ts_node_iterate_children(const TSNode *node) NodeChildIterator ts_node_iterate_children(const TSNode *node)
{ {
t_subtree subtree; t_subtree subtree;
const TSSymbol *alias_sequence; const TSSymbol *alias_sequence;
subtree = ts_node__subtree(*node); subtree = ts_node__subtree(*node);

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

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/08/31 17:16:53 by maiboyer #+# #+# */ /* Created: 2024/08/31 17:16:53 by maiboyer #+# #+# */
/* Updated: 2024/08/31 17:26:57 by maiboyer ### ########.fr */ /* Updated: 2024/09/02 18:07:16 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@ -17,7 +17,7 @@
bool ts_node__is_relevant(TSNode self, bool include_anonymous) bool ts_node__is_relevant(TSNode self, bool include_anonymous)
{ {
TSSymbol alias; TSSymbol alias;
t_subtree tree; t_subtree tree;
tree = ts_node__subtree(self); tree = ts_node__subtree(self);
if (include_anonymous) if (include_anonymous)

51
parser/src/scanner/heredoc.c
View file

@ -10,38 +10,40 @@
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#include "parser/inner/heredoc.h"
#include "me/char/char.h" #include "me/char/char.h"
#include "me/str/str.h" #include "me/str/str.h"
#include "me/types.h" #include "me/types.h"
#include "me/vec/vec_heredoc.h" #include "me/vec/vec_heredoc.h"
#include "parser/inner/heredoc.h"
#include "parser/inner/scanner.h" #include "parser/inner/scanner.h"
#include "parser/parser.h" #include "parser/parser.h"
bool scan_heredoc_start(t_heredoc *heredoc, TSLexer *lexer) bool scan_heredoc_start(t_heredoc *heredoc, TSLexer *lexer)
{ {
bool found_delimiter; bool found_delimiter;
while (me_isspace(lexer->lookahead)) while (me_isspace(lexer->lookahead))
lexer->advance(lexer, true); lexer->advance(lexer, true);
lexer->result_symbol = HEREDOC_START; lexer->result_symbol = HEREDOC_START;
heredoc->is_raw = lexer->lookahead == '\'' || lexer->lookahead == '"' || lexer->lookahead == '\\'; heredoc->is_raw = lexer->lookahead == '\'' || lexer->lookahead == '"'
|| lexer->lookahead == '\\';
found_delimiter = advance_word(lexer, &heredoc->delimiter); found_delimiter = advance_word(lexer, &heredoc->delimiter);
if (!found_delimiter) if (!found_delimiter)
return (string_clear(&heredoc->delimiter), false); return (string_clear(&heredoc->delimiter), false);
return (found_delimiter); return (found_delimiter);
} }
bool scan_heredoc_end_identifier(t_heredoc *heredoc, TSLexer *lexer) bool scan_heredoc_end_identifier(t_heredoc *heredoc, TSLexer *lexer)
{ {
t_i32 size; t_i32 size;
size = 0; size = 0;
string_clear(&heredoc->current_leading_word); string_clear(&heredoc->current_leading_word);
if (heredoc->delimiter.len > 0) if (heredoc->delimiter.len > 0)
{ {
while (lexer->lookahead != '\0' && lexer->lookahead != '\n' && (t_i32)heredoc->delimiter.buf[size] == lexer->lookahead && while (lexer->lookahead != '\0' && lexer->lookahead != '\n'
heredoc->current_leading_word.len < heredoc->delimiter.len) && (t_i32)heredoc->delimiter.buf[size] == lexer->lookahead
&& heredoc->current_leading_word.len < heredoc->delimiter.len)
{ {
string_push_char(&heredoc->current_leading_word, lexer->lookahead); string_push_char(&heredoc->current_leading_word, lexer->lookahead);
lexer->advance(lexer, false); lexer->advance(lexer, false);
@ -50,27 +52,26 @@ bool scan_heredoc_end_identifier(t_heredoc *heredoc, TSLexer *lexer)
} }
if (heredoc->delimiter.len == 0) if (heredoc->delimiter.len == 0)
return (false); return (false);
return (str_compare(heredoc->current_leading_word.buf, heredoc->delimiter.buf)); return (str_compare(heredoc->current_leading_word.buf,
heredoc->delimiter.buf));
} }
bool scan_heredoc_content_nullbyte(struct s_heredoc_scan_state *state); bool scan_heredoc_content_nullbyte(struct s_heredoc_scan_state *state);
bool scan_heredoc_content_backslash(struct s_heredoc_scan_state *state); bool scan_heredoc_content_backslash(struct s_heredoc_scan_state *state);
bool scan_heredoc_content_dollar(struct s_heredoc_scan_state *state); bool scan_heredoc_content_dollar(struct s_heredoc_scan_state *state);
bool scan_heredoc_content_newline(struct s_heredoc_scan_state *state); bool scan_heredoc_content_newline(struct s_heredoc_scan_state *state);
bool scan_heredoc_content_other(struct s_heredoc_scan_state *state); bool scan_heredoc_content_other(struct s_heredoc_scan_state *state);
bool scan_heredoc_content(t_scanner *scanner, TSLexer *lexer, enum e_token_type middle_type, enum e_token_type end_type) bool scan_heredoc_content(t_scanner *scanner, TSLexer *lexer,
enum e_token_type middle_type, enum e_token_type end_type)
{ {
struct s_heredoc_scan_state state; struct s_heredoc_scan_state state;
t_heredoc_content_func func; t_heredoc_content_func func;
state = (struct s_heredoc_scan_state){.did_advance = false, state = (struct s_heredoc_scan_state){.did_advance = false, .lexer = lexer,
.lexer = lexer, .heredoc = vec_heredoc_last(&scanner->heredocs), .scanner = scanner,
.heredoc = vec_heredoc_last(&scanner->heredocs), .middle_type = middle_type, .end_type = end_type,
.scanner = scanner, .return_value = false};
.middle_type = middle_type,
.end_type = end_type,
.return_value = false};
while (true) while (true)
{ {
if (lexer->lookahead == '\0') if (lexer->lookahead == '\0')
@ -89,9 +90,9 @@ bool scan_heredoc_content(t_scanner *scanner, TSLexer *lexer, enum e_token_type
return (false); return (false);
} }
bool scan_heredoc_end(t_scanner *scanner, TSLexer *lexer) bool scan_heredoc_end(t_scanner *scanner, TSLexer *lexer)
{ {
t_heredoc *heredoc; t_heredoc *heredoc;
heredoc = vec_heredoc_last(&scanner->heredocs); heredoc = vec_heredoc_last(&scanner->heredocs);
string_free(heredoc->current_leading_word); string_free(heredoc->current_leading_word);

9
parser/src/scanner/heredoc_functions.c
View file

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/09/01 19:36:53 by maiboyer #+# #+# */ /* Created: 2024/09/01 19:36:53 by maiboyer #+# #+# */
/* Updated: 2024/09/01 19:54:13 by maiboyer ### ########.fr */ /* Updated: 2024/09/02 18:04:32 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@ -96,12 +96,7 @@ bool scan_heredoc_content_other(struct s_heredoc_scan_state *state)
if (state->lexer->get_column(state->lexer) == 0) if (state->lexer->get_column(state->lexer) == 0)
{ {
while (me_isspace(state->lexer->lookahead)) while (me_isspace(state->lexer->lookahead))
{ state->lexer->advance(state->lexer, !state->did_advance);
if (state->did_advance)
state->lexer->advance(state->lexer, false);
else
state->lexer->advance(state->lexer, true);
}
if (state->end_type != SIMPLE_HEREDOC_BODY) if (state->end_type != SIMPLE_HEREDOC_BODY)
{ {
state->lexer->result_symbol = state->middle_type; state->lexer->result_symbol = state->middle_type;

17
parser/src/scanner/lifetime.c
View file

@ -6,39 +6,40 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/09/02 13:17:17 by maiboyer #+# #+# */ /* Created: 2024/09/02 13:17:17 by maiboyer #+# #+# */
/* Updated: 2024/09/02 13:18:49 by maiboyer ### ########.fr */ /* Updated: 2024/09/02 17:45:47 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#include "me/mem/mem.h" #include "me/mem/mem.h"
#include "parser/inner/scanner.h" #include "parser/inner/scanner.h"
void *tree_sitter_sh_external_scanner_create() void *tree_sitter_sh_external_scanner_create(void)
{ {
t_scanner *scanner; t_scanner *scanner;
scanner = mem_alloc(sizeof(*scanner)); scanner = mem_alloc(sizeof(*scanner));
scanner->heredocs = vec_heredoc_new(16, heredoc_free); scanner->heredocs = vec_heredoc_new(16, heredoc_free);
return (scanner); return (scanner);
} }
bool tree_sitter_sh_external_scanner_scan(void *payload, TSLexer *lexer, const bool *valid_symbols) bool tree_sitter_sh_external_scanner_scan(\
void *payload, TSLexer *lexer, const bool *valid_symbols)
{ {
t_scanner *scanner; t_scanner *scanner;
scanner = (t_scanner *)payload; scanner = (t_scanner *)payload;
return (scan(scanner, lexer, valid_symbols)); return (scan(scanner, lexer, valid_symbols));
} }
void tree_sitter_sh_external_scanner_destroy(void *payload) void tree_sitter_sh_external_scanner_destroy(void *payload)
{ {
vec_heredoc_free(((t_scanner *)payload)->heredocs); vec_heredoc_free(((t_scanner *)payload)->heredocs);
mem_free((t_scanner *)payload); mem_free((t_scanner *)payload);
} }
void reset(t_scanner *scanner) void reset(t_scanner *scanner)
{ {
t_usize i; t_usize i;
i = 0; i = 0;
while (i < scanner->heredocs.len) while (i < scanner->heredocs.len)

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

@ -13,35 +13,47 @@
#include "me/char/char.h" #include "me/char/char.h"
#include "parser/inner/scanner.h" #include "parser/inner/scanner.h"
static bool scan2(t_scanner *scanner, TSLexer *lexer, const bool *valid_symbols) static bool scan2(t_scanner *scanner, TSLexer *lexer, const bool *valid_symbols)
{ {
if (valid_symbols[HEREDOC_CONTENT] && scanner->heredocs.len > 0 && vec_heredoc_last(&scanner->heredocs)->started && if (valid_symbols[HEREDOC_CONTENT] && scanner->heredocs.len > 0
!valid_symbols[ERROR_RECOVERY]) && vec_heredoc_last(&scanner->heredocs)->started
return (scan_heredoc_content(scanner, lexer, HEREDOC_CONTENT, HEREDOC_END)); && !valid_symbols[ERROR_RECOVERY])
if (valid_symbols[HEREDOC_START] && !valid_symbols[ERROR_RECOVERY] && scanner->heredocs.len > 0) return (scan_heredoc_content(scanner, lexer, HEREDOC_CONTENT,
return (scan_heredoc_start(vec_heredoc_last(&scanner->heredocs), lexer)); HEREDOC_END));
if ((valid_symbols[VARIABLE_NAME] || valid_symbols[FILE_DESCRIPTOR] || valid_symbols[HEREDOC_ARROW]) && !valid_symbols[ERROR_RECOVERY]) if (valid_symbols[HEREDOC_START] && !valid_symbols[ERROR_RECOVERY]
&& scanner->heredocs.len > 0)
return (scan_heredoc_start(vec_heredoc_last(&scanner->heredocs),
lexer));
if ((valid_symbols[VARIABLE_NAME] || valid_symbols[FILE_DESCRIPTOR]
|| valid_symbols[HEREDOC_ARROW]) && !valid_symbols[ERROR_RECOVERY])
return (scan_varname(scanner, lexer, valid_symbols)); return (scan_varname(scanner, lexer, valid_symbols));
if (valid_symbols[BARE_DOLLAR] && !valid_symbols[ERROR_RECOVERY] && scan_bare_dollar(lexer)) if (valid_symbols[BARE_DOLLAR] && !valid_symbols[ERROR_RECOVERY]
&& scan_bare_dollar(lexer))
return (true); return (true);
if (valid_symbols[EXPANSION_WORD]) if (valid_symbols[EXPANSION_WORD])
return (scan_expansion_word(scanner, lexer, valid_symbols)); return (scan_expansion_word(scanner, lexer, valid_symbols));
return (false); return (false);
} }
bool scan(t_scanner *scanner, TSLexer *lexer, const bool *valid_symbols) bool scan(t_scanner *scanner, TSLexer *lexer, const bool *valid_symbols)
{ {
if (check_scan_concat(scanner, lexer, valid_symbols)) if (check_scan_concat(scanner, lexer, valid_symbols))
return (scan_concat(scanner, lexer, valid_symbols)); return (scan_concat(scanner, lexer, valid_symbols));
if (scan_double_hash(scanner, lexer, valid_symbols)) if (scan_double_hash(scanner, lexer, valid_symbols))
return (true); return (true);
if (valid_symbols[EMPTY_VALUE] && if (valid_symbols[EMPTY_VALUE] && (me_isspace(lexer->lookahead)
(me_isspace(lexer->lookahead) || lexer->eof(lexer) || lexer->lookahead == ';' || lexer->lookahead == '&')) || lexer->eof(lexer) || lexer->lookahead == ';'
|| lexer->lookahead == '&'))
return (lexer->result_symbol = EMPTY_VALUE, true); return (lexer->result_symbol = EMPTY_VALUE, true);
if ((valid_symbols[HEREDOC_BODY_BEGINNING] || valid_symbols[SIMPLE_HEREDOC_BODY]) && scanner->heredocs.len > 0 && if ((valid_symbols[HEREDOC_BODY_BEGINNING]
!vec_heredoc_last(&scanner->heredocs)->started && !valid_symbols[ERROR_RECOVERY]) || valid_symbols[SIMPLE_HEREDOC_BODY]) && scanner->heredocs.len > 0
return (scan_heredoc_content(scanner, lexer, HEREDOC_BODY_BEGINNING, SIMPLE_HEREDOC_BODY)); && !vec_heredoc_last(&scanner->heredocs)->started
if (valid_symbols[HEREDOC_END] && scanner->heredocs.len > 0 && scan_heredoc_end_identifier(vec_heredoc_last(&scanner->heredocs), lexer)) && !valid_symbols[ERROR_RECOVERY])
return (scan_heredoc_content(scanner, lexer, HEREDOC_BODY_BEGINNING,
SIMPLE_HEREDOC_BODY));
if (valid_symbols[HEREDOC_END] && scanner->heredocs.len > 0
&& scan_heredoc_end_identifier(vec_heredoc_last(&scanner->heredocs),
lexer))
return (scan_heredoc_end(scanner, lexer)); return (scan_heredoc_end(scanner, lexer));
return (scan2(scanner, lexer, valid_symbols)); return (scan2(scanner, lexer, valid_symbols));
} }

25
parser/src/scanner/scan_concat.c
View file

@ -6,17 +6,17 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/09/02 17:37:05 by maiboyer #+# #+# */ /* Created: 2024/09/02 17:37:05 by maiboyer #+# #+# */
/* Updated: 2024/09/02 17:42:58 by maiboyer ### ########.fr */ /* Updated: 2024/09/02 18:03:17 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#include "me/char/char.h" #include "me/char/char.h"
#include "parser/inner/scanner.h" #include "parser/inner/scanner.h"
bool scan_concat(t_scanner *scanner, TSLexer *lexer, const bool *valid_symbols) bool scan_concat(\
t_scanner *scanner, TSLexer *lexer, const bool *valid_symbols)
{ {
(void)(scanner); ((void)(scanner), (void)(valid_symbols));
(void)(valid_symbols);
lexer->result_symbol = CONCAT; lexer->result_symbol = CONCAT;
if (lexer->lookahead == '`') if (lexer->lookahead == '`')
{ {
@ -34,7 +34,8 @@ bool scan_concat(t_scanner *scanner, TSLexer *lexer, const bool *valid_symbols)
{ {
lexer->mark_end(lexer); lexer->mark_end(lexer);
lexer->advance(lexer, false); lexer->advance(lexer, false);
if (lexer->lookahead == '"' || lexer->lookahead == '\'' || lexer->lookahead == '\\') if (lexer->lookahead == '"' || lexer->lookahead == '\'' \
|| lexer->lookahead == '\\')
return (true); return (true);
if (lexer->eof(lexer)) if (lexer->eof(lexer))
return (false); return (false);
@ -42,11 +43,15 @@ bool scan_concat(t_scanner *scanner, TSLexer *lexer, const bool *valid_symbols)
return (true); return (true);
} }
bool check_scan_concat(t_scanner *scanner, TSLexer *lexer, const bool *valid_symbols) bool check_scan_concat(\
t_scanner *scanner, TSLexer *lexer, const bool *valid_symbols)
{ {
(void)(scanner); (void)(scanner);
return (valid_symbols[CONCAT] && !valid_symbols[ERROR_RECOVERY]) && return ((valid_symbols[CONCAT] && !valid_symbols[ERROR_RECOVERY]) \
(!(lexer->lookahead == 0 || me_isspace(lexer->lookahead) || lexer->lookahead == '>' || lexer->lookahead == '<' || && (!(lexer->lookahead == 0 || me_isspace(lexer->lookahead) \
lexer->lookahead == ')' || lexer->lookahead == '(' || lexer->lookahead == ';' || lexer->lookahead == '&' || || lexer->lookahead == '>' || lexer->lookahead == '<' \
lexer->lookahead == '|' || lexer->lookahead == '{' || lexer->lookahead == '}')); || lexer->lookahead == ')' || lexer->lookahead == '(' \
|| lexer->lookahead == ';' || lexer->lookahead == '&' \
|| lexer->lookahead == '|' || lexer->lookahead == '{' \
|| lexer->lookahead == '}')));
} }

10
parser/src/scanner/scan_dollar.c
View file

@ -6,23 +6,25 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/09/02 13:26:00 by maiboyer #+# #+# */ /* Created: 2024/09/02 13:26:00 by maiboyer #+# #+# */
/* Updated: 2024/09/02 13:26:32 by maiboyer ### ########.fr */ /* Updated: 2024/09/02 17:46:26 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#include "me/char/char.h" #include "me/char/char.h"
#include "parser/inner/scanner.h" #include "parser/inner/scanner.h"
bool scan_bare_dollar(TSLexer *lexer) bool scan_bare_dollar(TSLexer *lexer)
{ {
while (me_isspace(lexer->lookahead) && lexer->lookahead != '\n' && !lexer->eof(lexer)) while (me_isspace(lexer->lookahead) \
&& lexer->lookahead != '\n' && !lexer->eof(lexer))
lexer->advance(lexer, true); lexer->advance(lexer, true);
if (lexer->lookahead == '$') if (lexer->lookahead == '$')
{ {
lexer->advance(lexer, false); lexer->advance(lexer, false);
lexer->result_symbol = BARE_DOLLAR; lexer->result_symbol = BARE_DOLLAR;
lexer->mark_end(lexer); lexer->mark_end(lexer);
return (me_isspace(lexer->lookahead) || lexer->eof(lexer) || lexer->lookahead == '\"'); return (me_isspace(lexer->lookahead) \
|| lexer->eof(lexer) || lexer->lookahead == '\"');
} }
return (false); return (false);
} }

5
parser/src/scanner/scan_double_hash.c
View file

@ -6,13 +6,14 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/09/02 17:32:35 by maiboyer #+# #+# */ /* Created: 2024/09/02 17:32:35 by maiboyer #+# #+# */
/* Updated: 2024/09/02 17:42:43 by maiboyer ### ########.fr */ /* Updated: 2024/09/02 18:00:13 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#include "parser/inner/scanner.h" #include "parser/inner/scanner.h"
bool scan_double_hash(t_scanner *scanner, TSLexer *lexer, const bool *valid_symbols) bool scan_double_hash(\
t_scanner *scanner, TSLexer *lexer, const bool *valid_symbols)
{ {
(void)(scanner); (void)(scanner);
if (valid_symbols[IMMEDIATE_DOUBLE_HASH] && !valid_symbols[ERROR_RECOVERY]) if (valid_symbols[IMMEDIATE_DOUBLE_HASH] && !valid_symbols[ERROR_RECOVERY])

63
parser/src/scanner/scan_varname.c
View file

@ -6,20 +6,25 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/09/02 17:26:05 by maiboyer #+# #+# */ /* Created: 2024/09/02 17:26:05 by maiboyer #+# #+# */
/* Updated: 2024/09/02 17:28:10 by maiboyer ### ########.fr */ /* Updated: 2024/09/02 18:01:41 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#include "me/char/char.h" #include "me/char/char.h"
#include "parser/inner/scanner.h" #include "parser/inner/scanner.h"
bool scan_varname(t_scanner *scanner, TSLexer *lexer, const bool *valid_symbols) bool scan_varname(t_scanner *scanner, TSLexer *lexer,
const bool *valid_symbols)
{ {
t_heredoc heredoc;
bool is_number;
while (true) while (true)
{ {
if ((lexer->lookahead == ' ' || lexer->lookahead == '\t' || lexer->lookahead == '\r' || if ((lexer->lookahead == ' ' || lexer->lookahead == '\t'
(lexer->lookahead == '\n' && !valid_symbols[NEWLINE])) && || lexer->lookahead == '\r' || (lexer->lookahead == '\n'
!valid_symbols[EXPANSION_WORD]) && !valid_symbols[NEWLINE]))
&& !valid_symbols[EXPANSION_WORD])
lexer->advance(lexer, true); lexer->advance(lexer, true);
else if (lexer->lookahead == '\\') else if (lexer->lookahead == '\\')
{ {
@ -42,41 +47,41 @@ bool scan_varname(t_scanner *scanner, TSLexer *lexer, const bool *valid_symbols)
} }
} }
else else
break; break ;
} }
if (!valid_symbols[EXPANSION_WORD] && (lexer->lookahead == '*'
// no '*', '@', '?', '-', '$', '0', '_' || lexer->lookahead == '@' || lexer->lookahead == '?'
if (!valid_symbols[EXPANSION_WORD] && (lexer->lookahead == '*' || lexer->lookahead == '@' || lexer->lookahead == '?' || || lexer->lookahead == '-' || lexer->lookahead == '0'
lexer->lookahead == '-' || lexer->lookahead == '0' || lexer->lookahead == '_')) || lexer->lookahead == '_'))
{ {
lexer->mark_end(lexer); lexer->mark_end(lexer);
lexer->advance(lexer, false); lexer->advance(lexer, false);
if (lexer->lookahead == '=' || lexer->lookahead == '[' || lexer->lookahead == ':' || lexer->lookahead == '-' || if (lexer->lookahead == '=' || lexer->lookahead == '['
lexer->lookahead == '%' || lexer->lookahead == '#' || lexer->lookahead == '/') || lexer->lookahead == ':' || lexer->lookahead == '-'
return false; || lexer->lookahead == '%' || lexer->lookahead == '#'
|| lexer->lookahead == '/')
return (false);
if (valid_symbols[EXTGLOB_PATTERN] && me_isspace(lexer->lookahead)) if (valid_symbols[EXTGLOB_PATTERN] && me_isspace(lexer->lookahead))
{ {
lexer->mark_end(lexer); lexer->mark_end(lexer);
lexer->result_symbol = EXTGLOB_PATTERN; lexer->result_symbol = EXTGLOB_PATTERN;
return true; return (true);
} }
} }
if (valid_symbols[HEREDOC_ARROW] && lexer->lookahead == '<') if (valid_symbols[HEREDOC_ARROW] && lexer->lookahead == '<')
{ {
lexer->advance(lexer, false); lexer->advance(lexer, false);
if (lexer->lookahead == '<') if (lexer->lookahead == '<')
{ {
lexer->advance(lexer, false); lexer->advance(lexer, false);
t_heredoc heredoc = heredoc_new(); heredoc = heredoc_new();
vec_heredoc_push(&scanner->heredocs, heredoc); vec_heredoc_push(&scanner->heredocs, heredoc);
lexer->result_symbol = HEREDOC_ARROW; lexer->result_symbol = HEREDOC_ARROW;
return (true); return (true);
} }
return (false); return (false);
} }
is_number = true;
bool is_number = true;
if (me_isdigit(lexer->lookahead)) if (me_isdigit(lexer->lookahead))
lexer->advance(lexer, false); lexer->advance(lexer, false);
else if (me_isalpha(lexer->lookahead) || lexer->lookahead == '_') else if (me_isalpha(lexer->lookahead) || lexer->lookahead == '_')
@ -92,7 +97,6 @@ bool scan_varname(t_scanner *scanner, TSLexer *lexer, const bool *valid_symbols)
return (scan_expansion_word(scanner, lexer, valid_symbols)); return (scan_expansion_word(scanner, lexer, valid_symbols));
return (false); return (false);
} }
while (true) while (true)
{ {
if (me_isdigit(lexer->lookahead)) if (me_isdigit(lexer->lookahead))
@ -100,12 +104,11 @@ bool scan_varname(t_scanner *scanner, TSLexer *lexer, const bool *valid_symbols)
else if (me_isalpha(lexer->lookahead) || lexer->lookahead == '_') else if (me_isalpha(lexer->lookahead) || lexer->lookahead == '_')
is_number = (lexer->advance(lexer, false), false); is_number = (lexer->advance(lexer, false), false);
else else
break; break ;
} }
if (is_number && valid_symbols[FILE_DESCRIPTOR] && (lexer->lookahead == '>'
if (is_number && valid_symbols[FILE_DESCRIPTOR] && (lexer->lookahead == '>' || lexer->lookahead == '<')) || lexer->lookahead == '<'))
return (lexer->result_symbol = FILE_DESCRIPTOR, true); return (lexer->result_symbol = FILE_DESCRIPTOR, true);
if (valid_symbols[VARIABLE_NAME]) if (valid_symbols[VARIABLE_NAME])
{ {
if (lexer->lookahead == '+') if (lexer->lookahead == '+')
@ -114,13 +117,17 @@ bool scan_varname(t_scanner *scanner, TSLexer *lexer, const bool *valid_symbols)
lexer->advance(lexer, false); lexer->advance(lexer, false);
if (lexer->lookahead == '=' || lexer->lookahead == ':') if (lexer->lookahead == '=' || lexer->lookahead == ':')
return (lexer->result_symbol = VARIABLE_NAME, true); return (lexer->result_symbol = VARIABLE_NAME, true);
return false; return (false);
} }
if (lexer->lookahead == '/') if (lexer->lookahead == '/')
return false; return (false);
if (lexer->lookahead == '=' || lexer->lookahead == '[' || (lexer->lookahead == ':' && !valid_symbols[OPENING_PAREN]) || if (lexer->lookahead == '=' || lexer->lookahead == '['
lexer->lookahead == '%' || (lexer->lookahead == '#' && !is_number) || lexer->lookahead == '@' || (lexer->lookahead == '-')) || (lexer->lookahead == ':' && !valid_symbols[OPENING_PAREN])
return (lexer->mark_end(lexer), lexer->result_symbol = VARIABLE_NAME, true); || lexer->lookahead == '%' || (lexer->lookahead == '#'
&& !is_number) || lexer->lookahead == '@'
|| (lexer->lookahead == '-'))
return (lexer->mark_end(lexer),
lexer->result_symbol = VARIABLE_NAME, true);
if (lexer->lookahead == '?') if (lexer->lookahead == '?')
{ {
lexer->mark_end(lexer); lexer->mark_end(lexer);

43
parser/src/scanner/scan_word.c
View file

@ -6,44 +6,46 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/09/02 16:59:16 by maiboyer #+# #+# */ /* Created: 2024/09/02 16:59:16 by maiboyer #+# #+# */
/* Updated: 2024/09/02 17:22:25 by maiboyer ### ########.fr */ /* Updated: 2024/09/02 17:58:43 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
#include "me/char/char.h" #include "me/char/char.h"
#include "parser/inner/scanner.h" #include "parser/inner/scanner.h"
bool scan_expansion_word(t_scanner *scanner, TSLexer *lexer, const bool *valid_symbols) bool scan_expansion_word(t_scanner *scanner, TSLexer *lexer,
const bool *valid_symbols)
{ {
bool advanced_once = false; bool advanced_once;
bool advance_once_space = false; bool advance_once_space;
advanced_once = false;
advance_once_space = false;
(void)(scanner); (void)(scanner);
(void)(lexer); (void)(lexer);
(void)(valid_symbols); (void)(valid_symbols);
while (true) while (true)
{ {
if (lexer->lookahead == '\"') if (lexer->lookahead == '\"')
return false; return (false);
if (lexer->lookahead == '$') if (lexer->lookahead == '$')
{ {
lexer->mark_end(lexer); lexer->mark_end(lexer);
lexer->advance(lexer, false); lexer->advance(lexer, false);
if (lexer->lookahead == '{' || lexer->lookahead == '(' || lexer->lookahead == '\'' || me_isalnum(lexer->lookahead)) if (lexer->lookahead == '{' || lexer->lookahead == '('
|| lexer->lookahead == '\'' || me_isalnum(lexer->lookahead))
{ {
lexer->result_symbol = EXPANSION_WORD; lexer->result_symbol = EXPANSION_WORD;
return advanced_once; return (advanced_once);
} }
advanced_once = true; advanced_once = true;
} }
if (lexer->lookahead == '}') if (lexer->lookahead == '}')
{ {
lexer->mark_end(lexer); lexer->mark_end(lexer);
lexer->result_symbol = EXPANSION_WORD; lexer->result_symbol = EXPANSION_WORD;
return advanced_once || advance_once_space; return (advanced_once || advance_once_space);
} }
if (lexer->lookahead == '(' && !(advanced_once || advance_once_space)) if (lexer->lookahead == '(' && !(advanced_once || advance_once_space))
{ {
lexer->mark_end(lexer); lexer->mark_end(lexer);
@ -54,17 +56,21 @@ bool scan_expansion_word(t_scanner *scanner, TSLexer *lexer, const bool *valid_s
{ {
lexer->mark_end(lexer); lexer->mark_end(lexer);
lexer->advance(lexer, false); lexer->advance(lexer, false);
if (lexer->lookahead == '{' || lexer->lookahead == '(' || lexer->lookahead == '\'' || me_isalnum(lexer->lookahead)) if (lexer->lookahead == '{' || lexer->lookahead == '('
|| lexer->lookahead == '\''
|| me_isalnum(lexer->lookahead))
{ {
lexer->result_symbol = EXPANSION_WORD; lexer->result_symbol = EXPANSION_WORD;
return advanced_once; return (advanced_once);
} }
advanced_once = true; advanced_once = true;
} }
else else
{ {
advanced_once = advanced_once || !me_isspace(lexer->lookahead); advanced_once = advanced_once
advance_once_space = advance_once_space || me_isspace(lexer->lookahead); || !me_isspace(lexer->lookahead);
advance_once_space = advance_once_space
|| me_isspace(lexer->lookahead);
lexer->advance(lexer, false); lexer->advance(lexer, false);
} }
} }
@ -75,16 +81,15 @@ bool scan_expansion_word(t_scanner *scanner, TSLexer *lexer, const bool *valid_s
lexer->advance(lexer, false); lexer->advance(lexer, false);
lexer->mark_end(lexer); lexer->mark_end(lexer);
if (lexer->lookahead == '}') if (lexer->lookahead == '}')
return false; return (false);
} }
else else
return false; return (false);
} }
if (lexer->lookahead == '\'') if (lexer->lookahead == '\'')
return false; return (false);
if (lexer->eof(lexer)) if (lexer->eof(lexer))
return false; return (false);
advanced_once = advanced_once || !me_isspace(lexer->lookahead); advanced_once = advanced_once || !me_isspace(lexer->lookahead);
advance_once_space = advance_once_space || me_isspace(lexer->lookahead); advance_once_space = advance_once_space || me_isspace(lexer->lookahead);
lexer->advance(lexer, false); lexer->advance(lexer, false);

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

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/08/31 16:52:03 by maiboyer #+# #+# */ /* Created: 2024/08/31 16:52:03 by maiboyer #+# #+# */
/* Updated: 2024/08/31 16:58:37 by maiboyer ### ########.fr */ /* Updated: 2024/09/02 18:06:48 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@ -31,7 +31,7 @@ bool ts_stack_is_paused(const t_stack *self, t_stack_version version)
t_subtree ts_stack_resume(t_stack *self, t_stack_version version) t_subtree ts_stack_resume(t_stack *self, t_stack_version version)
{ {
t_stack_head *head; t_stack_head *head;
t_subtree result; t_subtree result;
head = array_get(&self->heads, version); head = array_get(&self->heads, version);
assert(head->status == SStatusPaused); assert(head->status == SStatusPaused);

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

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */ /* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */ /* +#+#+#+#+#+ +#+ */
/* Created: 2024/08/31 16:55:52 by maiboyer #+# #+# */ /* Created: 2024/08/31 16:55:52 by maiboyer #+# #+# */
/* Updated: 2024/08/31 16:56:19 by maiboyer ### ########.fr */ /* Updated: 2024/09/02 18:06:38 by maiboyer ### ########.fr */
/* */ /* */
/* ************************************************************************** */ /* ************************************************************************** */
@ -51,7 +51,7 @@ bool ts_stack_has_advanced_since_error(const t_stack *self,
{ {
const t_stack_head *head = array_get(&self->heads, version); const t_stack_head *head = array_get(&self->heads, version);
const t_stack_node *node = head->node; const t_stack_node *node = head->node;
t_subtree subtree; t_subtree subtree;
if (node->error_cost == 0) if (node->error_cost == 0)
return (true); return (true);