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

sadge to have to do a step backwards but it has to work

Browse source
This commit is contained in:
Maieul BOYER 2024-09-04 16:18:27 +00:00
parent d4ea200c1c
commit 92823aff80
16 changed files with 1215 additions and 897 deletions
Download patch file Download diff file Expand all files Collapse all files

29
parser/src/parser.c
View file

@ -28,8 +28,7 @@
static const t_u32 MAX_VERSION_COUNT = 4;
static const t_u32 MAX_VERSION_COUNT_OVERFLOW = 6;
static const t_u32 MAX_SUMMARY_DEPTH = 1;
static const t_u32 MAX_COST_DIFFERENCE = 16
* ERROR_COST_PER_SKIPPED_TREE;
static const t_u32 MAX_COST_DIFFERENCE = 16 * ERROR_COST_PER_SKIPPED_TREE;
typedef struct s_error_status t_error_status;
typedef enum e_error_comparison t_error_comparison;
@ -269,16 +268,16 @@ static bool ts_parser__better_version_exists(TSParser *self,
return false;
}
static bool ts_parser__call_main_lex_fn(TSParser *self, TSLexMode lex_mode)
{
return self->language->lex_fn(&self->lexer.data, lex_mode.lex_state);
}
static bool ts_parser__call_keyword_lex_fn(TSParser *self, TSLexMode lex_mode)
{
(void)(lex_mode);
return self->language->keyword_lex_fn(&self->lexer.data, 0);
}
// static bool ts_parser__call_main_lex_fn(TSParser *self, TSLexMode lex_mode)
// {
// return self->language->lex_fn(&self->lexer.data, lex_mode.lex_state);
// }
//
// static bool ts_parser__call_keyword_lex_fn(TSParser *self, TSLexMode lex_mode)
// {
// (void)(lex_mode);
// return self->language->keyword_lex_fn(&self->lexer.data, 0);
// }
static void ts_parser__external_scanner_create(TSParser *self)
{
@ -299,6 +298,7 @@ static t_u32 ts_parser__external_scanner_serialize(TSParser *self)
{
t_u32 length;
length = self->language->external_scanner.serialize(self->external_scanner_payload,
self->lexer.debug_buffer);
if (length > TREE_SITTER_SERIALIZATION_BUFFER_SIZE)
@ -319,6 +319,7 @@ static void ts_parser__external_scanner_deserialize(TSParser *self,
{
data = ts_external_scanner_state_data(&external_token->external_scanner_state);
length = external_token->external_scanner_state.length;
printf("HERE\n");
}
self->language->external_scanner.deserialize(self->external_scanner_payload,
data, length);
@ -430,7 +431,7 @@ static t_subtree ts_parser__lex(TSParser *self, t_stack_version version,
ts_lexer_reset(&self->lexer, current_position);
}
ts_lexer_start(&self->lexer);
found_token = ts_parser__call_main_lex_fn(self, lex_mode);
found_token = self->language->lex_fn(&self->lexer.data, lex_mode.lex_state);
ts_lexer_finish(&self->lexer, &lookahead_end_byte);
if (found_token)
break ;
@ -485,7 +486,7 @@ static t_subtree ts_parser__lex(TSParser *self, t_stack_version version,
end_byte = self->lexer.token_end_position.bytes;
ts_lexer_reset(&self->lexer, self->lexer.token_start_position);
ts_lexer_start(&self->lexer);
is_keyword = ts_parser__call_keyword_lex_fn(self, lex_mode);
is_keyword = self->language->keyword_lex_fn(&self->lexer.data, 0);
if (is_keyword && self->lexer.token_end_position.bytes == end_byte
&& ts_language_has_actions(self->language, parse_state,
self->lexer.data.result_symbol))

1198
parser/src/scanner.c Normal file
View file

File diff suppressed because it is too large Load diff

52
parser/src/scanner/advance_words.c
View file

@ -1,52 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* advance_words.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/09/01 19:28:19 by maiboyer #+# #+# */
/* Updated: 2024/09/01 20:10:14 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#include "me/char/char.h"
#include "me/string/string.h"
#include "me/types.h"
#include "parser/parser.h"
void advance_word_inner(TSLexer *lexer, bool *empty, t_i32 *quote)
{
*empty = true;
*quote = 0;
if (lexer->lookahead == '\'' || lexer->lookahead == '"')
{
*quote = lexer->lookahead;
lexer->advance(lexer, false);
}
}
bool advance_word(TSLexer *lexer, t_string *unquoted_word)
{
bool empty;
t_i32 quote;
advance_word_inner(lexer, &empty, &quote);
while (lexer->lookahead && !((quote && (lexer->lookahead == quote
|| lexer->lookahead == '\r' || lexer->lookahead == '\n'))
|| (!quote && (me_isspace(lexer->lookahead)))))
{
if (lexer->lookahead == '\\')
{
lexer->advance(lexer, false);
if (!lexer->lookahead)
return (false);
}
empty = false;
string_push_char(unquoted_word, lexer->lookahead);
lexer->advance(lexer, false);
}
if (quote && lexer->lookahead == quote)
lexer->advance(lexer, false);
return (!empty);
}

68
parser/src/scanner/deserialize.c
View file

@ -1,68 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* deserialize.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/09/01 15:06:56 by maiboyer #+# #+# */
/* Updated: 2024/09/01 20:08:37 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#include "me/mem/mem.h"
#include "me/types.h"
#include "me/vec/vec_heredoc.h"
#include "parser/inner/heredoc.h"
#include "parser/inner/scanner.h"
void reset(t_scanner *scanner);
void actual_reset(\
t_scanner *scanner, const t_u8 *buffer, t_usize i, t_u32 *size)
{
t_heredoc *heredoc;
t_usize delim_size;
heredoc = NULL;
if (i < scanner->heredocs.len)
heredoc = vec_heredoc_get(&scanner->heredocs, i);
else
{
vec_heredoc_push(&scanner->heredocs, heredoc_new());
heredoc = vec_heredoc_last(&scanner->heredocs);
}
heredoc->is_raw = buffer[(*size)++];
heredoc->started = buffer[(*size)++];
heredoc->allows_indent = buffer[(*size)++];
mem_copy(&delim_size, &buffer[(*size)], sizeof(t_usize));
(*size) += sizeof(t_usize);
string_reserve(&heredoc->delimiter, delim_size + 1);
heredoc->delimiter.len = delim_size - 1;
if (delim_size > 0)
{
mem_copy(heredoc->delimiter.buf, &buffer[(*size)], delim_size);
(*size) += delim_size;
}
}
void tree_sitter_sh_external_scanner_deserialize(t_scanner *scanner,
const t_u8 *buffer, t_u32 length)
{
t_u32 size;
t_u32 heredoc_count;
t_usize i;
if (length == 0)
return (reset(scanner));
size = 0;
scanner->last_glob_paren_depth = buffer[size++];
scanner->ext_was_in_double_quote = buffer[size++];
scanner->ext_saw_outside_quote = buffer[size++];
heredoc_count = (t_u8)buffer[size++];
i = 0;
while (i < heredoc_count)
actual_reset(scanner, buffer, i++, &size);
if (size != length)
me_abort("size != length");
}

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

@ -1,103 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* heredoc.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/09/01 19:33:04 by maiboyer #+# #+# */
/* Updated: 2024/09/02 17:31:02 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#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"
bool scan_heredoc_start(t_heredoc *heredoc, TSLexer *lexer)
{
bool found_delimiter;
while (me_isspace(lexer->lookahead))
lexer->advance(lexer, true);
lexer->result_symbol = HEREDOC_START;
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);
return (found_delimiter);
}
bool scan_heredoc_end_identifier(t_heredoc *heredoc, TSLexer *lexer)
{
t_i32 size;
size = 0;
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)
{
string_push_char(&heredoc->current_leading_word, lexer->lookahead);
lexer->advance(lexer, false);
size++;
}
}
if (heredoc->delimiter.len == 0)
return (false);
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_backslash(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_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)
{
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,
.return_value = false};
while (true)
{
if (lexer->lookahead == '\0')
func = scan_heredoc_content_nullbyte;
else if (lexer->lookahead == '\\')
func = scan_heredoc_content_backslash;
else if (lexer->lookahead == '$')
func = scan_heredoc_content_dollar;
else if (lexer->lookahead == '\n')
func = scan_heredoc_content_newline;
else
func = scan_heredoc_content_other;
if (func(&state))
return (state.return_value);
}
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);
}

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

@ -1,117 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* heredoc_functions.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/09/01 19:36:53 by maiboyer #+# #+# */
/* Updated: 2024/09/02 18:04:32 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#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"
bool scan_heredoc_end_identifier(t_heredoc *heredoc, TSLexer *lexer);
bool scan_heredoc_content_nullbyte(struct s_heredoc_scan_state *state)
{
if (state->lexer->eof(state->lexer) && state->did_advance)
{
reset_heredoc(state->heredoc);
state->lexer->result_symbol = state->end_type;
return (state->return_value = true, true);
}
return (state->return_value = false, true);
}
bool scan_heredoc_content_backslash(struct s_heredoc_scan_state *state)
{
state->did_advance = true;
state->lexer->advance(state->lexer, false);
state->lexer->advance(state->lexer, false);
return (false);
}
bool scan_heredoc_content_dollar(struct s_heredoc_scan_state *state)
{
if (state->heredoc->is_raw)
{
state->did_advance = true;
state->lexer->advance(state->lexer, false);
}
if (state->did_advance)
{
state->lexer->mark_end(state->lexer);
state->lexer->result_symbol = state->middle_type;
state->heredoc->started = true;
state->lexer->advance(state->lexer, false);
if (me_isalpha(state->lexer->lookahead)
|| state->lexer->lookahead == '{' || state->lexer->lookahead == '(')
return (state->return_value = true, true);
}
if (state->middle_type == HEREDOC_BODY_BEGINNING
&& state->lexer->get_column(state->lexer) == 0)
{
state->lexer->result_symbol = state->middle_type;
state->heredoc->started = true;
return (state->return_value = true, true);
}
return (state->return_value = false, true);
}
bool scan_heredoc_content_newline(struct s_heredoc_scan_state *state)
{
if (!state->did_advance)
state->lexer->advance(state->lexer, true);
else
state->lexer->advance(state->lexer, false);
state->did_advance = true;
if (state->heredoc->allows_indent)
{
while (me_isspace(state->lexer->lookahead))
state->lexer->advance(state->lexer, false);
}
state->lexer->result_symbol = state->end_type;
if (state->heredoc->started)
state->lexer->result_symbol = state->middle_type;
state->lexer->mark_end(state->lexer);
if (scan_heredoc_end_identifier(state->heredoc, state->lexer))
{
if (state->lexer->result_symbol == HEREDOC_END)
vec_heredoc_pop(&state->scanner->heredocs, NULL);
return (state->return_value = true, true);
}
return (false);
}
bool scan_heredoc_content_other(struct s_heredoc_scan_state *state)
{
if (state->lexer->get_column(state->lexer) == 0)
{
while (me_isspace(state->lexer->lookahead))
state->lexer->advance(state->lexer, !state->did_advance);
if (state->end_type != SIMPLE_HEREDOC_BODY)
{
state->lexer->result_symbol = state->middle_type;
if (scan_heredoc_end_identifier(state->heredoc, state->lexer))
return (state->return_value = true, true);
}
if (state->end_type == SIMPLE_HEREDOC_BODY)
{
state->lexer->result_symbol = state->end_type;
state->lexer->mark_end(state->lexer);
if (scan_heredoc_end_identifier(state->heredoc, state->lexer))
return (state->return_value = true, true);
}
}
state->did_advance = true;
state->lexer->advance(state->lexer, false);
return (false);
}

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

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

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

@ -1,59 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* 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));
}

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

@ -1,57 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* scan_concat.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/09/02 17:37:05 by maiboyer #+# #+# */
/* Updated: 2024/09/02 18:03:17 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 == '}')));
}

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

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

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

@ -1,38 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* scan_double_hash.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/09/02 17:32:35 by maiboyer #+# #+# */
/* Updated: 2024/09/02 18:00:13 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);
}

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

@ -1,140 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* scan_varname.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/09/02 17:26:05 by maiboyer #+# #+# */
/* Updated: 2024/09/02 18:01:41 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)
{
t_heredoc heredoc;
bool is_number;
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 ;
}
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);
heredoc = heredoc_new();
vec_heredoc_push(&scanner->heredocs, heredoc);
lexer->result_symbol = HEREDOC_ARROW;
return (true);
}
return (false);
}
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);
}

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

@ -1,97 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* scan_word.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/09/02 16:59:16 by maiboyer #+# #+# */
/* Updated: 2024/09/02 17:58:43 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;
bool advance_once_space;
advanced_once = false;
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);
}
}

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

@ -1,62 +0,0 @@
/* ************************************************************************** */
/* */
/* ::: :::::::: */
/* serialize.c :+: :+: :+: */
/* +:+ +:+ +:+ */
/* By: maiboyer <maiboyer@student.42.fr> +#+ +:+ +#+ */
/* +#+#+#+#+#+ +#+ */
/* Created: 2024/09/01 15:06:56 by maiboyer #+# #+# */
/* Updated: 2024/09/02 17:06:26 by maiboyer ### ########.fr */
/* */
/* ************************************************************************** */
#include "me/types.h"
#include "parser/array.h"
#include "parser/inner/heredoc.h"
#include "parser/inner/scanner.h"
#include "parser/parser.h"
t_error serialize_heredocs(t_scanner *scanner, t_u8 *buffer, t_u32 *size,
t_usize i)
{
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);
buffer[(*size)++] = (char)heredoc->is_raw;
buffer[(*size)++] = (char)heredoc->started;
buffer[(*size)++] = (char)heredoc->allows_indent;
heredoc->delimiter.len++;
mem_copy(&buffer[(*size)], &heredoc->delimiter.len, sizeof(t_usize));
size += sizeof(t_usize);
if (heredoc->delimiter.len > 0)
{
mem_copy(&buffer[(*size)], heredoc->delimiter.buf,
heredoc->delimiter.len);
(*size) += heredoc->delimiter.len;
}
heredoc->delimiter.len--;
return (NO_ERROR);
}
t_u32 tree_sitter_sh_external_scanner_serialize(t_scanner *scanner,
t_u8 *buffer)
{
t_u32 size;
t_usize i;
size = 0;
buffer[size++] = (char)scanner->last_glob_paren_depth;
buffer[size++] = (char)scanner->ext_was_in_double_quote;
buffer[size++] = (char)scanner->ext_saw_outside_quote;
buffer[size++] = (char)scanner->heredocs.len;
i = 0;
while (i < scanner->heredocs.len)
if (serialize_heredocs(scanner, buffer, &size, i++))
return (0);
return (size);
}