From 000845ab25e238bdf97df46c3a80c56b0f3eaa38 Mon Sep 17 00:00:00 2001 From: William Bell Date: Thu, 5 Jun 2025 23:08:10 +0100 Subject: [PATCH] add do wraps --- src/dynamic_array/darray.c | 5 +- src/lexer/lex.l | 6 +- src/parser/assignable/access/access.c | 1 + src/parser/assignable/call/call.c | 12 +-- src/parser/declaration/declaration.c | 8 +- src/parser/dowrap/dowrap.c | 104 ++++++++++++++++++++++++++ src/parser/dowrap/dowrap.h | 12 +++ src/parser/parser.c | 35 ++++++--- src/parser/parser.h | 3 +- test.ar | 27 ++----- 10 files changed, 163 insertions(+), 50 deletions(-) create mode 100644 src/parser/dowrap/dowrap.c create mode 100644 src/parser/dowrap/dowrap.h diff --git a/src/dynamic_array/darray.c b/src/dynamic_array/darray.c index fda755e..b1bb365 100644 --- a/src/dynamic_array/darray.c +++ b/src/dynamic_array/darray.c @@ -61,8 +61,8 @@ void darray_pop(DArray *arr, void (*free_data)(void *)) { void *target = (char *)arr->data + (arr->size-1) * arr->element_size; free_data(target); } - - darray_resize(arr, arr->size); + + darray_resize(arr, arr->size-1); } void *darray_get(DArray *arr, size_t index) { @@ -106,4 +106,5 @@ void darray_free(DArray *arr, void (*free_data)(void *)) { arr->size = 0; arr->capacity = 0; arr->element_size = 0; + arr->resizable = false; } \ No newline at end of file diff --git a/src/lexer/lex.l b/src/lexer/lex.l index edd1586..8c62a96 100644 --- a/src/lexer/lex.l +++ b/src/lexer/lex.l @@ -86,14 +86,10 @@ int yywrap(void * unused_param) { return TOKEN_STRING; } -((([0-9]+(\.[0-9]+)?)|(\.[0-9]+))(e((\-|\+)?([0-9]+(\.[0-9]+)?)))?) { +\-?((([0-9]+(\.[0-9]+)?)|(\.[0-9]+))(e((\-|\+)?([0-9]+(\.[0-9]+)?)))?) { return TOKEN_NUMBER; } -([0-9]+\/[0-9]+) { - return TOKEN_FRACTION; -} - \n { return TOKEN_NEW_LINE; } [ \t]+ { diff --git a/src/parser/assignable/access/access.c b/src/parser/assignable/access/access.c index 31e3818..068e64d 100644 --- a/src/parser/assignable/access/access.c +++ b/src/parser/assignable/access/access.c @@ -15,6 +15,7 @@ ParsedValue *parse_access(char*file,DArray *tokens, size_t * index, ParsedValue parsedAccess->access = strcpy(checked_malloc(strlen(token->value) + 1), token->value); parsedValue->type = AST_ACCESS; parsedValue->data = parsedAccess; + (*index)++; return parsedValue; } diff --git a/src/parser/assignable/call/call.c b/src/parser/assignable/call/call.c index ff72fbb..3cb43ae 100644 --- a/src/parser/assignable/call/call.c +++ b/src/parser/assignable/call/call.c @@ -18,12 +18,7 @@ ParsedValue *parse_call(char *file, DArray *tokens, size_t *index, (*index)++; error_if_finished(file, tokens, index); Token *token = darray_get(tokens, *index); - if (token->type == TOKEN_RPAREN) { - (*index)++; - if ((*index) >= tokens->size) - return parsedValue; - token = darray_get(tokens, *index); - } else { + if (token->type != TOKEN_RPAREN) { while ((*index) < tokens->size) { skip_newlines_and_indents(tokens, index); error_if_finished(file, tokens, index); @@ -35,10 +30,6 @@ ParsedValue *parse_call(char *file, DArray *tokens, size_t *index, error_if_finished(file, tokens, index); token = darray_get(tokens, *index); if (token->type == TOKEN_RPAREN) { - (*index)++; - if ((*index) >= tokens->size) - break; - token = darray_get(tokens, *index); break; } else if (token->type != TOKEN_COMMA) { fprintf(stderr, "%s:%zu:%zu error: expected comma\n", file, token->line, @@ -49,6 +40,7 @@ ParsedValue *parse_call(char *file, DArray *tokens, size_t *index, error_if_finished(file, tokens, index); } } + (*index)++; return parsedValue; } diff --git a/src/parser/declaration/declaration.c b/src/parser/declaration/declaration.c index 64ceaa4..5767df9 100644 --- a/src/parser/declaration/declaration.c +++ b/src/parser/declaration/declaration.c @@ -12,9 +12,9 @@ ParsedValue *parse_declaration(char *file, DArray *tokens, size_t *index) { error_if_finished(file, tokens, index); Token *token = darray_get(tokens, *index); - ParsedValue *parsedValue = malloc(sizeof(ParsedValue)); + ParsedValue *parsedValue = checked_malloc(sizeof(ParsedValue)); parsedValue->type = AST_DECLARATION; - DArray *declarations = malloc(sizeof(DArray)); + DArray *declarations = checked_malloc(sizeof(DArray)); darray_init(declarations, sizeof(ParsedSingleDeclaration)); parsedValue->data = declarations; while (true) { @@ -100,6 +100,10 @@ ParsedValue *parse_declaration(char *file, DArray *tokens, size_t *index) { break; token = darray_get(tokens, *index); } + skip_newlines_and_indents(tokens, index); + if ((*index) >= tokens->size) + break; + token = darray_get(tokens, *index); if (token->type != TOKEN_COMMA) break; (*index)++; diff --git a/src/parser/dowrap/dowrap.c b/src/parser/dowrap/dowrap.c new file mode 100644 index 0000000..bf753ec --- /dev/null +++ b/src/parser/dowrap/dowrap.c @@ -0,0 +1,104 @@ +#include "../../lexer/token.h" +#include "../../memory.h" +#include "../parser.h" +#include +#include +#include +#include +#include + +char *repeat_space(size_t x) { + + char *str = checked_malloc(x + 1); // +1 for the null terminator + + memset(str, ' ', x); + str[x] = '\0'; + + return str; +} + +void free_string_dowrap(void *ptr) { + // `ptr` is a pointer to a char* + char *str = *(char **)ptr; + free(str); +} + +ParsedValue *parse_dowrap(char *file, DArray *tokens, size_t *index) { + ParsedValue *parsedValue = checked_malloc(sizeof(ParsedValue)); + parsedValue->type = AST_DOWRAP; + DArray *dowrap_parsed = checked_malloc(sizeof(DArray)); + darray_init(dowrap_parsed, sizeof(ParsedValue)); + parsedValue->data = dowrap_parsed; + (*index)++; + if ((*index) >= tokens->size) + return parsedValue; + Token *token = darray_get(tokens, *index); + if (token->type != TOKEN_NEW_LINE) { + fprintf(stderr, "%s:%zu:%zu error: syntax error\n", file, token->line, + token->column); + exit(EXIT_FAILURE); + } + size_t indent_depth = 0; + bool temp_indent_depth_toggle = false; + size_t temp_indent_depth = 0; + bool pass = false; + DArray dowrap_tokens; + darray_init(&dowrap_tokens, sizeof(Token)); + DArray to_free; + darray_init(&to_free, sizeof(char *)); + + size_t starting_index = *index; + + size_t temp_index_count = 0; + + while (!pass && ++(*index) < tokens->size) { + token = darray_get(tokens, *index); + switch (token->type) { + case TOKEN_INDENT: + temp_indent_depth_toggle = true; + if (dowrap_tokens.size == 0) { + indent_depth = strlen(token->value); + temp_indent_depth = indent_depth; + } else { + temp_indent_depth = strlen(token->value); + } + break; + case TOKEN_NEW_LINE: + temp_indent_depth = 0; + temp_indent_depth_toggle = true; + darray_push(&dowrap_tokens, token); + temp_index_count++; + break; + default: + if (temp_indent_depth < indent_depth && temp_indent_depth_toggle) { + pass = true; + break; + } + if (temp_indent_depth >= indent_depth) { + size_t indent_amount = temp_indent_depth-indent_depth; + Token indent_token; + indent_token.line = token->line; + indent_token.column = token->column; + indent_token.type = TOKEN_INDENT; + indent_token.value = repeat_space(indent_amount); + darray_push(&dowrap_tokens, &indent_token); + darray_push(&to_free, &indent_token.value); + } + temp_indent_depth_toggle = false; + temp_indent_depth = 0; + temp_index_count=0; + darray_push(&dowrap_tokens, token); + } + } + (*index)-=temp_index_count; + for (size_t i = 0; i #include #include #include #include -const char *ValueTypeNames[] = {"string", "assign", "identifier", - "number", "if statement", "access", - "call", "declaration", "null", "boolean"}; +const char *ValueTypeNames[] = { + "string", "assign", "identifier", "number", "if statement", "access", + "call", "declaration", "null", "boolean", "do wrap"}; void error_if_finished(char *file, DArray *tokens, size_t *index) { if ((*index) >= tokens->size) { @@ -78,11 +79,14 @@ ParsedValue *parse_token(char *file, DArray *tokens, size_t *index, case TOKEN_NEW_LINE: (*index)++; return NULL; - break; case TOKEN_INDENT: - fprintf(stderr, "%s:%zu:%zu error: invalid indentation\n", file, token->line, - token->column); + if (strlen(token->value) > 0) { + fprintf(stderr, "%s:%zu:%zu error: invalid indentation\n", file, + token->line, token->column); exit(EXIT_FAILURE); + } + (*index)++; + return NULL; case TOKEN_IDENTIFIER: (*index)++; output = parse_identifier(token); @@ -94,6 +98,9 @@ ParsedValue *parse_token(char *file, DArray *tokens, size_t *index, case TOKEN_LET: output = parse_declaration(file, tokens, index); break; + case TOKEN_DO: + output = parse_dowrap(file, tokens, index); + break; default: fprintf(stderr, "%s:%zu:%zu error: syntax error\n", file, token->line, token->column); @@ -131,11 +138,21 @@ ParsedValue *parse_token(char *file, DArray *tokens, size_t *index, void parser(char *file, DArray *parsed, DArray *tokens, bool inline_flag) { size_t index = 0; + bool expecting_new_line = false; while (index < tokens->size) { ParsedValue *parsed_code = parse_token(file, tokens, &index, inline_flag); if (parsed_code) { + if (expecting_new_line) { + Token *token = darray_get(tokens, index-1); + fprintf(stderr, "%s:%zu:%zu error: syntax error\n", file, token->line, + token->column); + exit(EXIT_FAILURE); + } + expecting_new_line = true; darray_push(parsed, parsed_code); free(parsed_code); + } else { + expecting_new_line = false; } } } diff --git a/src/parser/parser.h b/src/parser/parser.h index eccd2c4..c23e0cd 100644 --- a/src/parser/parser.h +++ b/src/parser/parser.h @@ -17,7 +17,8 @@ typedef enum { AST_CALL, AST_DECLARATION, AST_NULL, - AST_BOOLEAN + AST_BOOLEAN, + AST_DOWRAP } ValueType; extern const char* ValueTypeNames[]; diff --git a/test.ar b/test.ar index 24a898e..dc3865b 100644 --- a/test.ar +++ b/test.ar @@ -1,21 +1,6 @@ -let a, - b = 1, - c, - d = 42, - temp_result, - compute_area(radius) = 3.1415, - identity(x) = x, - f(x), - g(y, z), - result, - z = 0, - extremely_long_variable_name_to_test_limits, - cache_value = compute_area(5), - placeholder_fn_with_no_body(arg1, arg2, arg3), - total = identity(100), - deeply_nested_args_function(arg1, arg2, arg3, arg4, arg5), - sum = a, - another, - another_function(), - just_null_here -if (x) term.log("hello world") \ No newline at end of file +x = do + do + test + test + +term.log("hello world") \ No newline at end of file