From 35dd18308e5501c32fb66017f89ecdc23f2ce1a1 Mon Sep 17 00:00:00 2001 From: TEC-GO Date: Fri, 9 Oct 2026 12:12:16 -0300 Subject: [PATCH] Add syntax parser and integrate lexical analysis --- .gitignore | 2 + CMakeLists.txt | 3 +- build/BL | Bin 25904 -> 39232 bytes build/CMakeFiles/BL.dir/DependInfo.cmake | 1 + build/CMakeFiles/BL.dir/build.make | 20 +- build/CMakeFiles/BL.dir/cmake_clean.cmake | 2 + build/CMakeFiles/BL.dir/link.d | 3 + build/CMakeFiles/BL.dir/link.txt | 2 +- build/CMakeFiles/BL.dir/progress.make | 1 + build/CMakeFiles/BL.dir/src/main.c.o | Bin 4384 -> 5200 bytes build/CMakeFiles/BL.dir/src/main.c.o.d | 12 +- build/CMakeFiles/Makefile2 | 6 +- build/CMakeFiles/progress.marks | 2 +- build/Makefile | 27 + include/parser.h | 18 + programa.bl | 7 +- src/main.c | 50 +- src/parser.c | 639 ++++++++++++++++++++++ 18 files changed, 766 insertions(+), 29 deletions(-) create mode 100644 include/parser.h create mode 100644 src/parser.c diff --git a/.gitignore b/.gitignore index c7f8c1d..27c79bc 100644 --- a/.gitignore +++ b/.gitignore @@ -1 +1,3 @@ .priv/ +build/ +programa.bl diff --git a/CMakeLists.txt b/CMakeLists.txt index 7a5d729..7643544 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,5 +1,5 @@ - cmake_minimum_required(VERSION 3.20) + project(BLCeti VERSION 0.1.0 LANGUAGES C) set(CMAKE_C_STANDARD 17) @@ -9,6 +9,7 @@ set(CMAKE_C_EXTENSIONS OFF) add_executable(BL src/main.c src/lexer.c + src/parser.c ) target_include_directories(BL PRIVATE include) diff --git a/build/BL b/build/BL index 5ac12605d0a2cf3082320b3265fb8ee4b8bc3df4..fa1a584d3c9ac4f17084176f76017153d344a26f 100755 GIT binary patch literal 39232 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 Zg>Z CMakeFiles/BL.dir/src/parser.c.i + +CMakeFiles/BL.dir/src/parser.c.s: cmake_force + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green "Compiling C source to assembly CMakeFiles/BL.dir/src/parser.c.s" + /usr/bin/cc $(C_DEFINES) $(C_INCLUDES) $(C_FLAGS) -S /home/benicio/Escritorio/BL-Ceti/src/parser.c -o CMakeFiles/BL.dir/src/parser.c.s + # Object files for target BL BL_OBJECTS = \ "CMakeFiles/BL.dir/src/main.c.o" \ -"CMakeFiles/BL.dir/src/lexer.c.o" +"CMakeFiles/BL.dir/src/lexer.c.o" \ +"CMakeFiles/BL.dir/src/parser.c.o" # External object files for target BL BL_EXTERNAL_OBJECTS = BL: CMakeFiles/BL.dir/src/main.c.o BL: CMakeFiles/BL.dir/src/lexer.c.o +BL: CMakeFiles/BL.dir/src/parser.c.o BL: CMakeFiles/BL.dir/build.make BL: CMakeFiles/BL.dir/compiler_depend.ts BL: CMakeFiles/BL.dir/link.txt - @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --bold --progress-dir=/home/benicio/Escritorio/BL-Ceti/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_3) "Linking C executable BL" + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --green --bold --progress-dir=/home/benicio/Escritorio/BL-Ceti/build/CMakeFiles --progress-num=$(CMAKE_PROGRESS_4) "Linking C executable BL" $(CMAKE_COMMAND) -E cmake_link_script CMakeFiles/BL.dir/link.txt --verbose=$(VERBOSE) # Rule to build all files generated by this target. diff --git a/build/CMakeFiles/BL.dir/cmake_clean.cmake b/build/CMakeFiles/BL.dir/cmake_clean.cmake index 43c2b9f..18a20d3 100644 --- a/build/CMakeFiles/BL.dir/cmake_clean.cmake +++ b/build/CMakeFiles/BL.dir/cmake_clean.cmake @@ -6,6 +6,8 @@ file(REMOVE_RECURSE "CMakeFiles/BL.dir/src/lexer.c.o.d" "CMakeFiles/BL.dir/src/main.c.o" "CMakeFiles/BL.dir/src/main.c.o.d" + "CMakeFiles/BL.dir/src/parser.c.o" + "CMakeFiles/BL.dir/src/parser.c.o.d" ) # Per-language clean rules from dependency scanning. diff --git a/build/CMakeFiles/BL.dir/link.d b/build/CMakeFiles/BL.dir/link.d index f3fe154..9671898 100644 --- a/build/CMakeFiles/BL.dir/link.d +++ b/build/CMakeFiles/BL.dir/link.d @@ -4,6 +4,7 @@ BL: \ /usr/lib/gcc/x86_64-pc-linux-gnu/16/crtbeginS.o \ CMakeFiles/BL.dir/src/main.c.o \ CMakeFiles/BL.dir/src/lexer.c.o \ + CMakeFiles/BL.dir/src/parser.c.o \ /usr/lib/gcc/x86_64-pc-linux-gnu/16/libgcc.a \ /usr/lib/gcc/x86_64-pc-linux-gnu/16/libgcc_s_asneeded.so \ /usr/lib/gcc/x86_64-pc-linux-gnu/16/libgcc_s_asneeded.so \ @@ -46,6 +47,8 @@ CMakeFiles/BL.dir/src/main.c.o: CMakeFiles/BL.dir/src/lexer.c.o: +CMakeFiles/BL.dir/src/parser.c.o: + /usr/lib/gcc/x86_64-pc-linux-gnu/16/libgcc.a: /usr/lib/gcc/x86_64-pc-linux-gnu/16/libgcc_s_asneeded.so: diff --git a/build/CMakeFiles/BL.dir/link.txt b/build/CMakeFiles/BL.dir/link.txt index e4f88a3..5517f0b 100644 --- a/build/CMakeFiles/BL.dir/link.txt +++ b/build/CMakeFiles/BL.dir/link.txt @@ -1 +1 @@ -/usr/bin/cc -Wl,--dependency-file=CMakeFiles/BL.dir/link.d CMakeFiles/BL.dir/src/main.c.o CMakeFiles/BL.dir/src/lexer.c.o -o BL +/usr/bin/cc -Wl,--dependency-file=CMakeFiles/BL.dir/link.d CMakeFiles/BL.dir/src/main.c.o CMakeFiles/BL.dir/src/lexer.c.o CMakeFiles/BL.dir/src/parser.c.o -o BL diff --git a/build/CMakeFiles/BL.dir/progress.make b/build/CMakeFiles/BL.dir/progress.make index 6a9dc74..a69a57e 100644 --- a/build/CMakeFiles/BL.dir/progress.make +++ b/build/CMakeFiles/BL.dir/progress.make @@ -1,4 +1,5 @@ CMAKE_PROGRESS_1 = 1 CMAKE_PROGRESS_2 = 2 CMAKE_PROGRESS_3 = 3 +CMAKE_PROGRESS_4 = 4 diff --git a/build/CMakeFiles/BL.dir/src/main.c.o b/build/CMakeFiles/BL.dir/src/main.c.o index 6c2fba03cfb85a50a1d78f7aa7bdc138e36b6d7c..3ef60b8d874209b4323a9bba83d76a7bd0f1f13b 100644 GIT binary patch delta 2051 zcmZ3WbU|Z+2Ga$BiCX!LD<{s9nXJbsFRH-6z_5>zfq~%#0|NuY4iND&a^fjtkR+!O zOmZ_TBNt=%0Y(M}kIuaw|Nj3^@#tnz)nEYeU4IxJ@HpNY@bCYBkZzCOsUW6DcPmJp zN9Q$<&f_mO|NZ~pqq8;Q-~ay}&3i!I`gFU#@aXn^;L*(r67_&6_v!VL@aUfEF9=N31a!B0Oip9= z=Kve#(RqCGI%aXEh<}rhGiS+O`Sbt(Ylr6AKTM^f9^I}VJem)1cyu#>LTKlo$$l)_ zlN(s%BN?20tQ7L{6^c_83QAM*6>?Hjixg6G6cUS)GcwEa^|(MT0%0_DDXAr?MY)-I ziD1o1zHT#K6EH#K6G7#K6b^HJ1c$^V z4hhCykO1Q(5GlDBYy>02YZi!Qy%36F1xR*s0*8}Oc~NFbDnnXHYEBMAZemVOe)8lk z90poRIq?OFMa8KM1*Ij$4Ds>BC5g$|@yQw4@o9;fAeEVU483BAc^xLiJMPm+Qq00TokILbk38+;9f! zy&R}Gh!R0^Xg^2*$w8l>>gPknL6itXJtBoJ1BoDM;D*M?I;c2^5=F9LFGv6yuE-uZ zgCvgZfu~5~VlZ>+|NsBb2QKMAxtoCjjd;YK>={%*1cTB+fqBirr^)UxUel zeey1TJEjcw$-nsRm;?kSTM5{4J^=ZOfq@}na-)Dbrv=oa^^*?@m~%#ef|P-Qp=5F+ GpF99a!e~wa delta 1263 zcmcbhu|R2p2GauGiCX!LnG6(1H;Qa#>vZ=VhzE1dZ#LYRCGfWcAf)i1)15=%K!iW zfBtP?s`&$B%Yl--$?D9qj6Wv3GTVxS%!4Tf8~VBgWc}o6EdGaZF=$pUlX)eDVQKiODNC zB_yYU6*4lcVTKsl3!xZhO;+TJ6e>y0$zjM%%*n}5W=Jb9$}CBp+{0xs`4pEN3rOAM zXI!for%pb|EzY=Yaw505=P{5d0|Ns{mWzRb;m>~vcz`6%gCzbPNgP@IzsVE1#SK|O zz5{!LfdS+^X{c&(s5r}QuTXK2$s9-~ zb4+IB6E_qGDTRg`vb{P`agb&ZGY4v#&16G9amjd)5Y!DI=47aBK1i0a4rFqDFGvE5 z$;*($MUdQc9x4vAaShbWTTpS3`^Avdi-H88Za@wP8Hl(X1I(Z;P=oX!65u4lJDF9$ z7@l4epejH*KzI%F^H<%|E37RogvP^!+E;jjq zpazsVNl1gU0jl%;troqJEjLb sle2{FI4#&9hHFgTC~VG|0E#aL28M-`KMI?3YJgH40|P_Jz5oCK diff --git a/build/CMakeFiles/BL.dir/src/main.c.o.d b/build/CMakeFiles/BL.dir/src/main.c.o.d index d11347e..7ba4549 100644 --- a/build/CMakeFiles/BL.dir/src/main.c.o.d +++ b/build/CMakeFiles/BL.dir/src/main.c.o.d @@ -3,11 +3,13 @@ CMakeFiles/BL.dir/src/main.c.o: \ /home/benicio/Escritorio/BL-Ceti/include/lexer.h \ /usr/lib/gcc/x86_64-pc-linux-gnu/16/include/stdbool.h \ /usr/lib/gcc/x86_64-pc-linux-gnu/16/include/stddef.h \ - /usr/include/stdio.h /usr/include/bits/libc-header-start.h \ - /usr/include/features.h /usr/include/features-time64.h \ - /usr/include/bits/wordsize.h /usr/include/bits/timesize.h \ - /usr/include/sys/cdefs.h /usr/include/bits/long-double.h \ - /usr/include/gnu/stubs.h /usr/include/gnu/stubs-64.h \ + /home/benicio/Escritorio/BL-Ceti/include/parser.h \ + /home/benicio/Escritorio/BL-Ceti/include/lexer.h /usr/include/stdio.h \ + /usr/include/bits/libc-header-start.h /usr/include/features.h \ + /usr/include/features-time64.h /usr/include/bits/wordsize.h \ + /usr/include/bits/timesize.h /usr/include/sys/cdefs.h \ + /usr/include/bits/long-double.h /usr/include/gnu/stubs.h \ + /usr/include/gnu/stubs-64.h \ /usr/lib/gcc/x86_64-pc-linux-gnu/16/include/stdarg.h \ /usr/include/bits/types.h /usr/include/bits/typesizes.h \ /usr/include/bits/time64.h /usr/include/bits/types/__fpos_t.h \ diff --git a/build/CMakeFiles/Makefile2 b/build/CMakeFiles/Makefile2 index a25fbc0..fb0bac4 100644 --- a/build/CMakeFiles/Makefile2 +++ b/build/CMakeFiles/Makefile2 @@ -85,12 +85,12 @@ clean: CMakeFiles/BL.dir/clean CMakeFiles/BL.dir/all: $(MAKE) $(MAKESILENT) -f CMakeFiles/BL.dir/build.make CMakeFiles/BL.dir/depend $(MAKE) $(MAKESILENT) -f CMakeFiles/BL.dir/build.make CMakeFiles/BL.dir/build - @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/home/benicio/Escritorio/BL-Ceti/build/CMakeFiles --progress-num=1,2,3 "Built target BL" + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/home/benicio/Escritorio/BL-Ceti/build/CMakeFiles --progress-num=1,2,3,4 "Built target BL" .PHONY : CMakeFiles/BL.dir/all # Build rule for subdir invocation for target. CMakeFiles/BL.dir/rule: cmake_check_build_system - $(CMAKE_COMMAND) -E cmake_progress_start /home/benicio/Escritorio/BL-Ceti/build/CMakeFiles 3 + $(CMAKE_COMMAND) -E cmake_progress_start /home/benicio/Escritorio/BL-Ceti/build/CMakeFiles 4 $(MAKE) $(MAKESILENT) -f CMakeFiles/Makefile2 CMakeFiles/BL.dir/all $(CMAKE_COMMAND) -E cmake_progress_start /home/benicio/Escritorio/BL-Ceti/build/CMakeFiles 0 .PHONY : CMakeFiles/BL.dir/rule @@ -102,7 +102,7 @@ BL: CMakeFiles/BL.dir/rule # codegen rule for target. CMakeFiles/BL.dir/codegen: $(MAKE) $(MAKESILENT) -f CMakeFiles/BL.dir/build.make CMakeFiles/BL.dir/codegen - @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/home/benicio/Escritorio/BL-Ceti/build/CMakeFiles --progress-num=1,2,3 "Finished codegen for target BL" + @$(CMAKE_COMMAND) -E cmake_echo_color "--switch=$(COLOR)" --progress-dir=/home/benicio/Escritorio/BL-Ceti/build/CMakeFiles --progress-num=1,2,3,4 "Finished codegen for target BL" .PHONY : CMakeFiles/BL.dir/codegen # clean rule for target. diff --git a/build/CMakeFiles/progress.marks b/build/CMakeFiles/progress.marks index 00750ed..b8626c4 100644 --- a/build/CMakeFiles/progress.marks +++ b/build/CMakeFiles/progress.marks @@ -1 +1 @@ -3 +4 diff --git a/build/Makefile b/build/Makefile index 7851de6..3ca7ff5 100644 --- a/build/Makefile +++ b/build/Makefile @@ -222,6 +222,30 @@ src/main.c.s: $(MAKE) $(MAKESILENT) -f CMakeFiles/BL.dir/build.make CMakeFiles/BL.dir/src/main.c.s .PHONY : src/main.c.s +src/parser.o: src/parser.c.o +.PHONY : src/parser.o + +# target to build an object file +src/parser.c.o: + $(MAKE) $(MAKESILENT) -f CMakeFiles/BL.dir/build.make CMakeFiles/BL.dir/src/parser.c.o +.PHONY : src/parser.c.o + +src/parser.i: src/parser.c.i +.PHONY : src/parser.i + +# target to preprocess a source file +src/parser.c.i: + $(MAKE) $(MAKESILENT) -f CMakeFiles/BL.dir/build.make CMakeFiles/BL.dir/src/parser.c.i +.PHONY : src/parser.c.i + +src/parser.s: src/parser.c.s +.PHONY : src/parser.s + +# target to generate assembly for a file +src/parser.c.s: + $(MAKE) $(MAKESILENT) -f CMakeFiles/BL.dir/build.make CMakeFiles/BL.dir/src/parser.c.s +.PHONY : src/parser.c.s + # Help Target help: @echo "The following are some of the valid targets for this Makefile:" @@ -241,6 +265,9 @@ help: @echo "... src/main.o" @echo "... src/main.i" @echo "... src/main.s" + @echo "... src/parser.o" + @echo "... src/parser.i" + @echo "... src/parser.s" .PHONY : help diff --git a/include/parser.h b/include/parser.h new file mode 100644 index 0000000..79a8036 --- /dev/null +++ b/include/parser.h @@ -0,0 +1,18 @@ +#ifndef BL_CETI_PARSER_H +#define BL_CETI_PARSER_H + +#include "lexer.h" + +#include +#include + +typedef struct { + char code[6]; + char message[160]; + size_t line; + size_t column; +} BlParseError; + +bool bl_parse(const BlToken *tokens, size_t count, BlParseError *error); + +#endif diff --git a/programa.bl b/programa.bl index ff8010d..2bd4be2 100644 --- a/programa.bl +++ b/programa.bl @@ -1,4 +1,7 @@ +cat > /tmp/bl-error.bl <<'EOF' fn main() { - let mensaje: String = "Hola desde BL-Ceti"; - print(mensaje); + let numero: Int = ; } +EOF + +./build/BL .C /tmp/bl-error.bl diff --git a/src/main.c b/src/main.c index 45af5e3..14ecfd6 100644 --- a/src/main.c +++ b/src/main.c @@ -1,5 +1,5 @@ - #include "lexer.h" +#include "parser.h" #include #include @@ -16,6 +16,7 @@ static char *read_file(const char *path, size_t *length) if (fseek(file, 0, SEEK_END) != 0) { fclose(file); + fprintf(stderr, "BL: no se pudo leer el archivo.\n"); return NULL; } @@ -23,6 +24,7 @@ static char *read_file(const char *path, size_t *length) if (size < 0 || fseek(file, 0, SEEK_SET) != 0) { fclose(file); + fprintf(stderr, "BL: no se pudo determinar el tamaño del archivo.\n"); return NULL; } @@ -46,6 +48,7 @@ static char *read_file(const char *path, size_t *length) buffer[read_count] = '\0'; *length = read_count; fclose(file); + return buffer; } @@ -54,29 +57,48 @@ static int analyze_file(const char *path) size_t length = 0; char *source = read_file(path, &length); - if (source == NULL) return 1; + if (source == NULL) { + return 1; + } - BlLexResult result = {0}; - bool success = bl_lex(source, length, &result); + BlLexResult lex_result = {0}; - if (!success) { + if (!bl_lex(source, length, &lex_result)) { fprintf(stderr, "%s:%zu:%zu: error %s: %s\n", path, - result.error.line, - result.error.column, - result.error.code, - result.error.message); - bl_lex_result_destroy(&result); + lex_result.error.line, + lex_result.error.column, + lex_result.error.code, + lex_result.error.message); + + bl_lex_result_destroy(&lex_result); free(source); return 1; } - printf("BL-Ceti: analisis lexico correcto: %s\n", path); - printf("Tokens reconocidos: %zu\n", - result.count > 0 ? result.count - 1 : 0); + BlParseError parse_error = {0}; - bl_lex_result_destroy(&result); + if (!bl_parse(lex_result.tokens, lex_result.count, &parse_error)) { + fprintf(stderr, "%s:%zu:%zu: error %s: %s\n", + path, + parse_error.line, + parse_error.column, + parse_error.code, + parse_error.message); + + bl_lex_result_destroy(&lex_result); + free(source); + return 1; + } + + printf("BL-Ceti 0.1.0: analisis correcto: %s\n", path); + printf("Tokens reconocidos: %zu\n", + lex_result.count > 0 ? lex_result.count - 1 : 0); + printf("Sintaxis: correcta\n"); + + bl_lex_result_destroy(&lex_result); free(source); + return 0; } diff --git a/src/parser.c b/src/parser.c new file mode 100644 index 0000000..0a60fc1 --- /dev/null +++ b/src/parser.c @@ -0,0 +1,639 @@ +#include "parser.h" + +#include +#include + +typedef struct { + const BlToken *tokens; + size_t count; + size_t position; + BlParseError *error; + bool failed; +} Parser; + +typedef struct { + bool identifier; + bool call; +} ExprInfo; + +static const BlToken *current(Parser *parser) +{ + if (parser->position >= parser->count) { + return &parser->tokens[parser->count - 1]; + } + + return &parser->tokens[parser->position]; +} + +static bool check(Parser *parser, BlTokenType type) +{ + return current(parser)->type == type; +} + +static const BlToken *advance(Parser *parser) +{ + const BlToken *token = current(parser); + + if (token->type != BL_EOF) { + parser->position++; + } + + return token; +} + +static bool fail_at(Parser *parser, const BlToken *token, + const char *code, const char *message) +{ + if (!parser->failed) { + parser->failed = true; + + snprintf(parser->error->code, sizeof parser->error->code, + "%s", code); + snprintf(parser->error->message, sizeof parser->error->message, + "%s", message); + + parser->error->line = token->line; + parser->error->column = token->column; + } + + return false; +} + +static bool expect(Parser *parser, BlTokenType type, + const char *message) +{ + if (check(parser, type)) { + advance(parser); + return true; + } + + return fail_at(parser, current(parser), "E1001", message); +} + +static bool parse_expression(Parser *parser, ExprInfo *info); +static bool parse_statement(Parser *parser); +static bool parse_block(Parser *parser); + +static bool parse_type(Parser *parser, bool allow_void) +{ + BlTokenType type = current(parser)->type; + + if (type == BL_INT_TYPE || + type == BL_FLOAT_TYPE || + type == BL_BOOL_TYPE || + type == BL_STRING_TYPE) { + advance(parser); + return true; + } + + if (allow_void && type == BL_VOID_TYPE) { + advance(parser); + return true; + } + + return fail_at(parser, current(parser), "E1001", + "Se esperaba un tipo valido."); +} + +static bool parse_primary(Parser *parser, ExprInfo *info) +{ + const BlToken *token = current(parser); + + info->identifier = false; + info->call = false; + + switch (token->type) { + case BL_INTEGER: + case BL_FLOAT: + case BL_STRING: + case BL_TRUE: + case BL_FALSE: + advance(parser); + return true; + + case BL_IDENTIFIER: + advance(parser); + + if (check(parser, BL_LPAREN)) { + advance(parser); + + if (!check(parser, BL_RPAREN)) { + ExprInfo argument; + + if (!parse_expression(parser, &argument)) { + return false; + } + + while (check(parser, BL_COMMA)) { + advance(parser); + + if (check(parser, BL_RPAREN)) { + break; + } + + if (!parse_expression(parser, &argument)) { + return false; + } + } + } + + if (!expect(parser, BL_RPAREN, + "Se esperaba ')' al cerrar la llamada.")) { + return false; + } + + info->call = true; + return true; + } + + info->identifier = true; + return true; + + case BL_LPAREN: { + advance(parser); + + ExprInfo inner; + + if (!parse_expression(parser, &inner)) { + return false; + } + + if (!expect(parser, BL_RPAREN, + "Se esperaba ')' en la expresion.")) { + return false; + } + + return true; + } + + default: + return fail_at(parser, token, "E1001", + "Se esperaba una expresion."); + } +} + +static bool parse_unary(Parser *parser, ExprInfo *info) +{ + if (check(parser, BL_MINUS) || check(parser, BL_NOT)) { + advance(parser); + + if (!parse_unary(parser, info)) { + return false; + } + + info->identifier = false; + info->call = false; + return true; + } + + return parse_primary(parser, info); +} + +static bool parse_cast(Parser *parser, ExprInfo *info) +{ + if (!parse_unary(parser, info)) { + return false; + } + + while (check(parser, BL_AS)) { + advance(parser); + + if (!parse_type(parser, false)) { + return false; + } + + info->identifier = false; + info->call = false; + } + + return true; +} + +static bool parse_multiplication(Parser *parser, ExprInfo *info) +{ + if (!parse_cast(parser, info)) { + return false; + } + + while (check(parser, BL_STAR) || + check(parser, BL_SLASH) || + check(parser, BL_PERCENT)) { + advance(parser); + + ExprInfo right; + + if (!parse_cast(parser, &right)) { + return false; + } + + info->identifier = false; + info->call = false; + } + + return true; +} + +static bool parse_addition(Parser *parser, ExprInfo *info) +{ + if (!parse_multiplication(parser, info)) { + return false; + } + + while (check(parser, BL_PLUS) || check(parser, BL_MINUS)) { + advance(parser); + + ExprInfo right; + + if (!parse_multiplication(parser, &right)) { + return false; + } + + info->identifier = false; + info->call = false; + } + + return true; +} + +static bool is_relational(BlTokenType type) +{ + return type == BL_LESS || + type == BL_LESS_EQUAL || + type == BL_GREATER || + type == BL_GREATER_EQUAL; +} + +static bool parse_relation(Parser *parser, ExprInfo *info) +{ + if (!parse_addition(parser, info)) { + return false; + } + + if (is_relational(current(parser)->type)) { + advance(parser); + + ExprInfo right; + + if (!parse_addition(parser, &right)) { + return false; + } + + info->identifier = false; + info->call = false; + + if (is_relational(current(parser)->type)) { + return fail_at(parser, current(parser), "E1005", + "Las comparaciones relacionales no se pueden encadenar."); + } + } + + return true; +} + +static bool parse_equality(Parser *parser, ExprInfo *info) +{ + if (!parse_relation(parser, info)) { + return false; + } + + if (check(parser, BL_EQUAL) || check(parser, BL_NOT_EQUAL)) { + advance(parser); + + ExprInfo right; + + if (!parse_relation(parser, &right)) { + return false; + } + + info->identifier = false; + info->call = false; + + if (check(parser, BL_EQUAL) || check(parser, BL_NOT_EQUAL)) { + return fail_at(parser, current(parser), "E1005", + "Las comparaciones de igualdad no se pueden encadenar."); + } + } + + return true; +} + +static bool parse_and(Parser *parser, ExprInfo *info) +{ + if (!parse_equality(parser, info)) { + return false; + } + + while (check(parser, BL_AND)) { + advance(parser); + + ExprInfo right; + + if (!parse_equality(parser, &right)) { + return false; + } + + info->identifier = false; + info->call = false; + } + + return true; +} + +static bool parse_expression(Parser *parser, ExprInfo *info) +{ + if (!parse_and(parser, info)) { + return false; + } + + while (check(parser, BL_OR)) { + advance(parser); + + ExprInfo right; + + if (!parse_and(parser, &right)) { + return false; + } + + info->identifier = false; + info->call = false; + } + + return true; +} + +static bool is_assignment_operator(BlTokenType type) +{ + return type == BL_ASSIGN || + type == BL_PLUS_ASSIGN || + type == BL_MINUS_ASSIGN || + type == BL_STAR_ASSIGN || + type == BL_SLASH_ASSIGN || + type == BL_PERCENT_ASSIGN; +} + +static bool parse_variable(Parser *parser) +{ + advance(parser); /* let o var */ + + if (!expect(parser, BL_IDENTIFIER, + "Se esperaba un nombre de variable.")) { + return false; + } + + if (check(parser, BL_COLON)) { + advance(parser); + + if (!parse_type(parser, false)) { + return false; + } + } + + if (!expect(parser, BL_ASSIGN, + "Se esperaba '=' para inicializar la variable.")) { + return false; + } + + ExprInfo value; + + if (!parse_expression(parser, &value)) { + return false; + } + + return expect(parser, BL_SEMICOLON, + "Se esperaba ';' al final de la declaracion."); +} + +static bool parse_if(Parser *parser) +{ + advance(parser); /* if */ + + ExprInfo condition; + + if (!parse_expression(parser, &condition)) { + return false; + } + + if (!parse_block(parser)) { + return false; + } + + if (check(parser, BL_ELSE)) { + advance(parser); + + if (check(parser, BL_IF)) { + return parse_if(parser); + } + + return parse_block(parser); + } + + return true; +} + +static bool parse_while(Parser *parser) +{ + advance(parser); /* while */ + + ExprInfo condition; + + if (!parse_expression(parser, &condition)) { + return false; + } + + return parse_block(parser); +} + +static bool parse_return(Parser *parser) +{ + advance(parser); /* return */ + + if (!check(parser, BL_SEMICOLON)) { + ExprInfo value; + + if (!parse_expression(parser, &value)) { + return false; + } + } + + return expect(parser, BL_SEMICOLON, + "Se esperaba ';' despues de return."); +} + +static bool parse_simple_statement(Parser *parser) +{ + ExprInfo expression; + + if (!parse_expression(parser, &expression)) { + return false; + } + + if (is_assignment_operator(current(parser)->type)) { + if (!expression.identifier) { + return fail_at(parser, current(parser), "E1006", + "El lado izquierdo de una asignacion debe ser una variable."); + } + + advance(parser); + + ExprInfo value; + + if (!parse_expression(parser, &value)) { + return false; + } + } else if (!expression.call) { + return fail_at(parser, current(parser), "E1007", + "Una sentencia de expresion debe ser una llamada a funcion."); + } + + return expect(parser, BL_SEMICOLON, + "Se esperaba ';' al final de la sentencia."); +} + +static bool parse_statement(Parser *parser) +{ + switch (current(parser)->type) { + case BL_LET: + case BL_VAR: + return parse_variable(parser); + + case BL_IF: + return parse_if(parser); + + case BL_WHILE: + return parse_while(parser); + + case BL_BREAK: + case BL_CONTINUE: + advance(parser); + return expect(parser, BL_SEMICOLON, + "Se esperaba ';' despues de la sentencia."); + + case BL_RETURN: + return parse_return(parser); + + case BL_LBRACE: + return parse_block(parser); + + case BL_IDENTIFIER: + case BL_INTEGER: + case BL_FLOAT: + case BL_STRING: + case BL_TRUE: + case BL_FALSE: + case BL_LPAREN: + case BL_MINUS: + case BL_NOT: + return parse_simple_statement(parser); + + default: + return fail_at(parser, current(parser), "E1001", + "Sentencia no valida."); + } +} + +static bool parse_block(Parser *parser) +{ + if (!expect(parser, BL_LBRACE, + "Se esperaba '{' para comenzar el bloque.")) { + return false; + } + + while (!check(parser, BL_RBRACE) && + !check(parser, BL_EOF) && + !parser->failed) { + if (!parse_statement(parser)) { + return false; + } + } + + return expect(parser, BL_RBRACE, + "Se esperaba '}' para cerrar el bloque."); +} + +static bool parse_function(Parser *parser) +{ + advance(parser); /* fn */ + + if (!expect(parser, BL_IDENTIFIER, + "Se esperaba el nombre de la funcion.")) { + return false; + } + + if (!expect(parser, BL_LPAREN, + "Se esperaba '(' despues del nombre de la funcion.")) { + return false; + } + + if (!check(parser, BL_RPAREN)) { + for (;;) { + if (!expect(parser, BL_IDENTIFIER, + "Se esperaba el nombre del parametro.")) { + return false; + } + + if (!expect(parser, BL_COLON, + "Se esperaba ':' despues del nombre del parametro.")) { + return false; + } + + if (!parse_type(parser, false)) { + return false; + } + + if (!check(parser, BL_COMMA)) { + break; + } + + advance(parser); + + if (check(parser, BL_RPAREN)) { + break; + } + } + } + + if (!expect(parser, BL_RPAREN, + "Se esperaba ')' despues de los parametros.")) { + return false; + } + + if (check(parser, BL_ARROW)) { + advance(parser); + + if (!parse_type(parser, true)) { + return false; + } + } + + return parse_block(parser); +} + +bool bl_parse(const BlToken *tokens, size_t count, BlParseError *error) +{ + if (tokens == NULL || count == 0 || error == NULL) { + return false; + } + + memset(error, 0, sizeof *error); + + Parser parser = { + .tokens = tokens, + .count = count, + .position = 0, + .error = error, + .failed = false + }; + + while (!check(&parser, BL_EOF) && !parser.failed) { + if (!check(&parser, BL_FN)) { + return fail_at(&parser, current(&parser), "E1001", + "En el nivel superior solo se permiten funciones."); + } + + if (!parse_function(&parser)) { + return false; + } + } + + return !parser.failed && check(&parser, BL_EOF); +}