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

Updated parser/src/scanner.c to be splitted

Browse source
This commit is contained in:
Maieul BOYER 2024-09-02 17:43:53 +02:00
parent 78a595ef60
commit b2440780fb
No known key found for this signature in database
11 changed files with 415 additions and 363 deletions
Download patch file Download diff file Expand all files Collapse all files

6
parser/Filelist.parser.mk
View file

@ -32,13 +32,17 @@ node/node_relevent \
parser \
point/point_funcs1 \
point/point_funcs2 \
scanner \
scanner/advance_words \
scanner/deserialize \
scanner/heredoc \
scanner/heredoc_functions \
scanner/lifetime \
scanner/scan \
scanner/scan_concat \
scanner/scan_dollar \
scanner/scan_double_hash \
scanner/scan_varname \
scanner/scan_word \
scanner/serialize \
stack/stack_add_link \
stack/stack_funcs1 \

8
parser/include/parser/inner/scanner.h
View file

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/09/02 13:22:04 by maiboyer #+# #+# */
/* Updated: 2024/09/02 13:27:44 by maiboyer ### ########.fr */
/* Updated: 2024/09/02 17:40:15 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
@ -65,11 +65,17 @@ struct s_heredoc_scan_state
typedef bool (*t_heredoc_content_func)(struct s_heredoc_scan_state *state);
bool advance_word(TSLexer *lexer, t_string *unquoted_word);
bool check_scan_concat(t_scanner *scanner, TSLexer *lexer, const bool *valid_symbols);
bool scan(t_scanner *scanner, TSLexer *lexer, const bool *valid_symbols);
bool scan_bare_dollar(TSLexer *lexer);
bool scan_concat(t_scanner *scanner, TSLexer *lexer, const bool *valid_symbols);
bool scan_double_hash(t_scanner *scanner, TSLexer *lexer, const bool *valid_symbols);
bool scan_expansion_word(t_scanner *scanner, TSLexer *lexer, const bool *valid_symbols);
bool scan_heredoc_content(t_scanner *scanner, TSLexer *lexer, enum e_token_type middle_type, enum e_token_type end_type);
bool scan_heredoc_end(t_scanner *scanner, TSLexer *lexer);
bool scan_heredoc_end_identifier(t_heredoc *heredoc, TSLexer *lexer);
bool scan_heredoc_start(t_heredoc *heredoc, TSLexer *lexer);
bool scan_varname(t_scanner *scanner, TSLexer *lexer, const bool *valid_symbols);
void reset(t_scanner *scanner);
#endif

334
parser/src/scanner.c
View file

@ -1,334 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* scanner.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/09/01 14:17:17 by maiboyer #+# #+# */
/* Updated: 2024/09/02 16:25:19 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#include "parser/inner/scanner.h"
#include "me/char/char.h"
#include "me/mem/mem.h"
#include "me/string/string.h"
#include "me/types.h"
#include "me/vec/vec_heredoc.h"
#include "parser/inner/heredoc.h"
#include "parser/parser.h"
#include <assert.h>
bool scan(t_scanner *scanner, TSLexer *lexer, const bool *valid_symbols)
{
if (valid_symbols[CONCAT] && !valid_symbols[ERROR_RECOVERY])
{
if (!(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->result_symbol = CONCAT;
if (lexer->lookahead == '`')
{
lexer->mark_end(lexer);
lexer->advance(lexer, false);
while (lexer->lookahead != '`' && !lexer->eof(lexer))
lexer->advance(lexer, false);
if (lexer->eof(lexer))
return false;
if (lexer->lookahead == '`')
lexer->advance(lexer, false);
return me_isspace(lexer->lookahead) || lexer->eof(lexer);
}
if (lexer->lookahead == '\\')
{
lexer->mark_end(lexer);
lexer->advance(lexer, false);
if (lexer->lookahead == '"' || lexer->lookahead == '\'' || lexer->lookahead == '\\')
return true;
if (lexer->eof(lexer))
return false;
}
else
return true;
}
}
if (valid_symbols[IMMEDIATE_DOUBLE_HASH] && !valid_symbols[ERROR_RECOVERY])
{
if (lexer->lookahead == '#')
{
lexer->mark_end(lexer);
lexer->advance(lexer, false);
if (lexer->lookahead == '#')
{
lexer->advance(lexer, false);
if (lexer->lookahead != '}')
{
lexer->result_symbol = IMMEDIATE_DOUBLE_HASH;
lexer->mark_end(lexer);
return true;
}
}
}
}
if (valid_symbols[EMPTY_VALUE] &&
(me_isspace(lexer->lookahead) || lexer->eof(lexer) || lexer->lookahead == ';' || lexer->lookahead == '&'))
return (lexer->result_symbol = EMPTY_VALUE, true);
if ((valid_symbols[HEREDOC_BODY_BEGINNING] || valid_symbols[SIMPLE_HEREDOC_BODY]) && scanner->heredocs.len > 0 &&
!vec_heredoc_last(&scanner->heredocs)->started && !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))
{
t_heredoc *heredoc = vec_heredoc_last(&scanner->heredocs);
string_free(heredoc->current_leading_word);
string_free(heredoc->delimiter);
(void)vec_heredoc_pop(&scanner->heredocs, NULL);
return (lexer->result_symbol = HEREDOC_END, true);
}
if (valid_symbols[HEREDOC_CONTENT] && scanner->heredocs.len > 0 && vec_heredoc_last(&scanner->heredocs)->started &&
!valid_symbols[ERROR_RECOVERY])
return scan_heredoc_content(scanner, lexer, HEREDOC_CONTENT, HEREDOC_END);
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])
{
while (true)
{
if ((lexer->lookahead == ' ' || lexer->lookahead == '\t' || lexer->lookahead == '\r' ||
(lexer->lookahead == '\n' && !valid_symbols[NEWLINE])) &&
!valid_symbols[EXPANSION_WORD])
{
lexer->advance(lexer, true);
}
else if (lexer->lookahead == '\\')
{
lexer->advance(lexer, true);
if (lexer->eof(lexer))
{
lexer->mark_end(lexer);
lexer->result_symbol = VARIABLE_NAME;
return true;
}
if (lexer->lookahead == '\r')
lexer->advance(lexer, true);
if (lexer->lookahead == '\n')
lexer->advance(lexer, true);
else
{
if (lexer->lookahead == '\\' && valid_symbols[EXPANSION_WORD])
goto expansion_word;
return false;
}
}
else
break;
}
// no '*', '@', '?', '-', '$', '0', '_'
if (!valid_symbols[EXPANSION_WORD] && (lexer->lookahead == '*' || lexer->lookahead == '@' || lexer->lookahead == '?' ||
lexer->lookahead == '-' || lexer->lookahead == '0' || lexer->lookahead == '_'))
{
lexer->mark_end(lexer);
lexer->advance(lexer, false);
if (lexer->lookahead == '=' || lexer->lookahead == '[' || lexer->lookahead == ':' || lexer->lookahead == '-' ||
lexer->lookahead == '%' || lexer->lookahead == '#' || lexer->lookahead == '/')
return false;
if (valid_symbols[EXTGLOB_PATTERN] && me_isspace(lexer->lookahead))
{
lexer->mark_end(lexer);
lexer->result_symbol = EXTGLOB_PATTERN;
return true;
}
}
if (valid_symbols[HEREDOC_ARROW] && lexer->lookahead == '<')
{
lexer->advance(lexer, false);
if (lexer->lookahead == '<')
{
lexer->advance(lexer, false);
if (lexer->lookahead == '-')
{
lexer->advance(lexer, false);
t_heredoc heredoc = heredoc_new();
heredoc.allows_indent = true;
vec_heredoc_push(&scanner->heredocs, heredoc);
lexer->result_symbol = HEREDOC_ARROW_DASH;
}
else
{
t_heredoc heredoc = heredoc_new();
vec_heredoc_push(&scanner->heredocs, heredoc);
lexer->result_symbol = HEREDOC_ARROW;
}
return true;
}
return false;
}
bool is_number = true;
if (me_isdigit(lexer->lookahead))
lexer->advance(lexer, false);
else if (me_isalpha(lexer->lookahead) || lexer->lookahead == '_')
{
is_number = false;
lexer->advance(lexer, false);
}
else
{
if (lexer->lookahead == '{')
goto brace_start;
if (valid_symbols[EXPANSION_WORD])
goto expansion_word;
if (valid_symbols[EXTGLOB_PATTERN])
goto extglob_pattern;
return false;
}
while (true)
{
if (me_isdigit(lexer->lookahead))
lexer->advance(lexer, false);
else if (me_isalpha(lexer->lookahead) || lexer->lookahead == '_')
{
is_number = false;
lexer->advance(lexer, false);
}
else
break;
}
if (is_number && valid_symbols[FILE_DESCRIPTOR] && (lexer->lookahead == '>' || lexer->lookahead == '<'))
{
lexer->result_symbol = FILE_DESCRIPTOR;
return true;
}
if (valid_symbols[VARIABLE_NAME])
{
if (lexer->lookahead == '+')
{
lexer->mark_end(lexer);
lexer->advance(lexer, false);
if (lexer->lookahead == '=' || lexer->lookahead == ':')
{
lexer->result_symbol = VARIABLE_NAME;
return true;
}
return false;
}
if (lexer->lookahead == '/')
{
return false;
}
if (lexer->lookahead == '=' || lexer->lookahead == '[' || (lexer->lookahead == ':' && !valid_symbols[OPENING_PAREN]) ||
lexer->lookahead == '%' || (lexer->lookahead == '#' && !is_number) || lexer->lookahead == '@' || (lexer->lookahead == '-'))
{
lexer->mark_end(lexer);
lexer->result_symbol = VARIABLE_NAME;
return true;
}
if (lexer->lookahead == '?')
{
lexer->mark_end(lexer);
lexer->advance(lexer, false);
lexer->result_symbol = VARIABLE_NAME;
return me_isalpha(lexer->lookahead);
}
}
return false;
}
if (valid_symbols[BARE_DOLLAR] && !valid_symbols[ERROR_RECOVERY] && scan_bare_dollar(lexer))
return true;
extglob_pattern:
expansion_word:
if (valid_symbols[EXPANSION_WORD])
{
bool advanced_once = false;
bool advance_once_space = false;
while (true)
{
if (lexer->lookahead == '\"')
return false;
if (lexer->lookahead == '$')
{
lexer->mark_end(lexer);
lexer->advance(lexer, false);
if (lexer->lookahead == '{' || lexer->lookahead == '(' || lexer->lookahead == '\'' || me_isalnum(lexer->lookahead))
{
lexer->result_symbol = EXPANSION_WORD;
return advanced_once;
}
advanced_once = true;
}
if (lexer->lookahead == '}')
{
lexer->mark_end(lexer);
lexer->result_symbol = EXPANSION_WORD;
return advanced_once || advance_once_space;
}
if (lexer->lookahead == '(' && !(advanced_once || advance_once_space))
{
lexer->mark_end(lexer);
lexer->advance(lexer, false);
while (lexer->lookahead != ')' && !lexer->eof(lexer))
{
if (lexer->lookahead == '$')
{
lexer->mark_end(lexer);
lexer->advance(lexer, false);
if (lexer->lookahead == '{' || lexer->lookahead == '(' || lexer->lookahead == '\'' || me_isalnum(lexer->lookahead))
{
lexer->result_symbol = EXPANSION_WORD;
return advanced_once;
}
advanced_once = true;
}
else
{
advanced_once = advanced_once || !me_isspace(lexer->lookahead);
advance_once_space = advance_once_space || me_isspace(lexer->lookahead);
lexer->advance(lexer, false);
}
}
lexer->mark_end(lexer);
if (lexer->lookahead == ')')
{
advanced_once = true;
lexer->advance(lexer, false);
lexer->mark_end(lexer);
if (lexer->lookahead == '}')
return false;
}
else
return false;
}
if (lexer->lookahead == '\'')
return false;
if (lexer->eof(lexer))
return false;
advanced_once = advanced_once || !me_isspace(lexer->lookahead);
advance_once_space = advance_once_space || me_isspace(lexer->lookahead);
lexer->advance(lexer, false);
}
}
brace_start:
return false;
}

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

@ -6,15 +6,15 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/09/01 19:33:04 by maiboyer #+# #+# */
/* Updated: 2024/09/01 20:02:49 by maiboyer ### ########.fr */
/* Updated: 2024/09/02 17:31:02 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#include "parser/inner/heredoc.h"
#include "me/char/char.h"
#include "me/str/str.h"
#include "me/types.h"
#include "me/vec/vec_heredoc.h"
#include "parser/inner/heredoc.h"
#include "parser/inner/scanner.h"
#include "parser/parser.h"
@ -25,8 +25,7 @@ bool scan_heredoc_start(t_heredoc *heredoc, TSLexer *lexer)
while (me_isspace(lexer->lookahead))
lexer->advance(lexer, true);
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);
if (!found_delimiter)
return (string_clear(&heredoc->delimiter), false);
@ -41,9 +40,8 @@ bool scan_heredoc_end_identifier(t_heredoc *heredoc, TSLexer *lexer)
string_clear(&heredoc->current_leading_word);
if (heredoc->delimiter.len > 0)
{
while (lexer->lookahead != '\0' && lexer->lookahead != '\n'
&& (t_i32)heredoc->delimiter.buf[size] == lexer->lookahead
&& heredoc->current_leading_word.len < heredoc->delimiter.len)
while (lexer->lookahead != '\0' && lexer->lookahead != '\n' && (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);
lexer->advance(lexer, false);
@ -52,8 +50,7 @@ bool scan_heredoc_end_identifier(t_heredoc *heredoc, TSLexer *lexer)
}
if (heredoc->delimiter.len == 0)
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);
@ -62,15 +59,17 @@ 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_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;
t_heredoc_content_func func;
state = (struct s_heredoc_scan_state){.did_advance = false, \
.lexer = lexer, .heredoc = vec_heredoc_last(&scanner->heredocs), \
.scanner = scanner, .middle_type = middle_type, .end_type = end_type, \
state = (struct s_heredoc_scan_state){.did_advance = false,
.lexer = lexer,
.heredoc = vec_heredoc_last(&scanner->heredocs),
.scanner = scanner,
.middle_type = middle_type,
.end_type = end_type,
.return_value = false};
while (true)
{
@ -89,3 +88,15 @@ bool scan_heredoc_content(t_scanner *scanner, TSLexer *lexer,
}
return (false);
}
bool scan_heredoc_end(t_scanner *scanner, TSLexer *lexer)
{
t_heredoc *heredoc;
heredoc = vec_heredoc_last(&scanner->heredocs);
string_free(heredoc->current_leading_word);
string_free(heredoc->delimiter);
vec_heredoc_pop(&scanner->heredocs, NULL);
lexer->result_symbol = HEREDOC_END;
return (true);
}

47
parser/src/scanner/scan.c Normal file
View file

@ -0,0 +1,47 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* scan.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/09/02 17:40:46 by maiboyer #+# #+# */
/* Updated: 2024/09/02 17:41:52 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#include "me/char/char.h"
#include "parser/inner/scanner.h"
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 &&
!valid_symbols[ERROR_RECOVERY])
return (scan_heredoc_content(scanner, lexer, HEREDOC_CONTENT, HEREDOC_END));
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));
if (valid_symbols[BARE_DOLLAR] && !valid_symbols[ERROR_RECOVERY] && scan_bare_dollar(lexer))
return (true);
if (valid_symbols[EXPANSION_WORD])
return (scan_expansion_word(scanner, lexer, valid_symbols));
return (false);
}
bool scan(t_scanner *scanner, TSLexer *lexer, const bool *valid_symbols)
{
if (check_scan_concat(scanner, lexer, valid_symbols))
return (scan_concat(scanner, lexer, valid_symbols));
if (scan_double_hash(scanner, lexer, valid_symbols))
return (true);
if (valid_symbols[EMPTY_VALUE] &&
(me_isspace(lexer->lookahead) || lexer->eof(lexer) || lexer->lookahead == ';' || lexer->lookahead == '&'))
return (lexer->result_symbol = EMPTY_VALUE, true);
if ((valid_symbols[HEREDOC_BODY_BEGINNING] || valid_symbols[SIMPLE_HEREDOC_BODY]) && scanner->heredocs.len > 0 &&
!vec_heredoc_last(&scanner->heredocs)->started && !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 (scan2(scanner, lexer, valid_symbols));
}

52
parser/src/scanner/scan_concat.c Normal file
View file

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

37
parser/src/scanner/scan_double_hash.c Normal file
View file

@ -0,0 +1,37 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* scan_double_hash.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/09/02 17:32:35 by maiboyer #+# #+# */
/* Updated: 2024/09/02 17:42:43 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#include "parser/inner/scanner.h"
bool scan_double_hash(t_scanner *scanner, TSLexer *lexer, const bool *valid_symbols)
{
(void)(scanner);
if (valid_symbols[IMMEDIATE_DOUBLE_HASH] && !valid_symbols[ERROR_RECOVERY])
{
if (lexer->lookahead == '#')
{
lexer->mark_end(lexer);
lexer->advance(lexer, false);
if (lexer->lookahead == '#')
{
lexer->advance(lexer, false);
if (lexer->lookahead != '}')
{
lexer->result_symbol = IMMEDIATE_DOUBLE_HASH;
lexer->mark_end(lexer);
return (true);
}
}
}
}
return (false);
}

133
parser/src/scanner/scan_varname.c Normal file
View file

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

92
parser/src/scanner/scan_word.c Normal file
View file

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

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

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/09/01 15:06:56 by maiboyer #+# #+# */
/* Updated: 2024/09/01 19:28:24 by maiboyer ### ########.fr */
/* Updated: 2024/09/02 17:06:26 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
@ -22,6 +22,8 @@ t_error serialize_heredocs(t_scanner *scanner, t_u8 *buffer, t_u32 *size,
t_heredoc *heredoc;
heredoc = vec_heredoc_get(&scanner->heredocs, i);
if (heredoc == NULL)
return (ERROR);
if (heredoc->delimiter.len + 1 + sizeof(t_usize)
+ (*size) >= TREE_SITTER_SERIALIZATION_BUFFER_SIZE)
return (ERROR);

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

@ -6,7 +6,7 @@
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/08/31 16:50:56 by maiboyer #+# #+# */
/* Updated: 2024/08/31 16:51:36 by maiboyer ### ########.fr */
/* Updated: 2024/09/02 17:20:31 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
@ -30,6 +30,8 @@ t_stack_action summarize_stack_callback(void *payload,
i = session->summary->size - 1;
while (i + 1 > 0)
{
if (session->summary->contents == NULL)
return (SActionNone);
entry = session->summary->contents[i--];
if (entry.depth < depth)
break ;