i can't take this anymore (parser backup) (#5)

* backup: moments before disaster

* feat: start defining error enums

* test: start parser test setup

* test: successfully setup tests for opRel grammar rule

* test: setup tests for currently implemented fator parsing rules

* feat: fator simple array

* test: fix fator neg test

* test: fix fator neg tests

* test: start programming error messages

* test: setup error messages, todo: finish function

* test: finish error printing function

* test: fator 1d array, no expr

* test: remake error printing function

* doc: add new language spec

* test: todo: finish close bracket test

* test: complete simple array tests

* refactor: remove unused token parameter

* test: single, accept overconsuming tokens?

* doc: update README.md

* Parser object added for state persistence across calls (#4)

* fix: adjustments of operator function

* test: design for multiple token parser tests

* fix: start logic changes for token consumption

* test: finish simple array tests with new parser design

* test: finish lone factor id tests

* test: stop unit for now: try integration?

* test: start integration tests

* bug: token sign code is not persisted (garbage)

* refactor: pass parser object by reference

* feat: major union overwriting bug corrected

* test: finish invalid type test case

* test: finish no var id integration test case

* test: finish invalid array subscript declaration integration test

* test: finish invalid array declaration bracket close on array dec

* test: add invalid variable initialization test

* test: add multiple variable declaration

* test: todo: multidimensional array declaration

* test: multidimensional array declaration error

* test: invalid array openings

* test: invalid type inside array initialization

* test: finish bad array initialization case

* test: no function id in declaration

* test: function prototype opening failure

* test: invalid function prototype param type

* test: add no id case for function prototype param

* test: roll back wrong error

* test: add no valid token after type of function proto

* test: finish unclosed proto array bracket param

* test: 2d array continuation

* test: 2d array closing on proto param

* test: invalid array dimension in prot param

* doc: update README.md

* todo: replicate declVar logic with declProc

* seconds before disaster

* refactor: prot function, todo make it lmao

* refactor: prot param function for recursion

* test: colorized output for better feedback

* test: remove color, todo: recursive prot param

* test: finish recursive proto param test

* feat: update main for manual testing (i feel lost)

* feat: update main.c for manual testing feedback

* fix: incorrect def bool check that broke tests

README.md

@@ -36,6 +36,14 @@
 
 # problemas
 
+- [ ] Output colorido em testes
+- [ ] Todo ID deve ser checado pelo parser se é reservado?
+- [ ] Refactor indispensável no parser: remover erros que não serão usados
+- [ ] Refatorar testes: setup e teardown
+- [ ] Remover enums erros desnecessarias do parser
+- [X] Objeto parser com seu proprio estado (token, file, line)
+- [ ] Contador de linha esta funcionando no analisador sintatico?
+- [ ] Parser testes unitarios + integracao
 - [ ] Adicionar especificacao da linguagem `proc` e manter atualizada
 - [ ] Refactor: remover transition.h e transition.c
 - [ ] Refactor: organizar melhor as enums...

build.sh

@@ -1,9 +1,12 @@
 #!/bin/bash
 
 if [[ $1 == 'test' ]]; then
-		gcc -g ./test/*.c ./lexer/*.c -o croc
-		echo 'built test.'
+	gcc -g ./test/*.c ./lexer/*.c ./parser/*.c -o croc
+	echo 'built test.'
+elif [[ $1 == 'debug' ]]; then
+	gcc -g ./debug.c ./lexer/*.c ./parser/*.c -o croc
+	echo 'built debug.'
 else
-		gcc -g ./main.c ./lexer/*.c  -o croc
-		echo 'built main.'
+	gcc -g ./main.c ./lexer/*.c ./parser/*.c  -o croc
+	echo 'built main.'
 fi

debug.c

@@ -0,0 +1,73 @@
+#include "./lexer/lexer.h"
+#include "./lexer/printer.h"
+#include "./lexer/types.h"
+#include "./parser/parser.h"
+#include "./parser/syntax_error.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+// ANSI escape codes
+#define RESET "\033[0m"
+#define RED "\033[31m"
+#define GREEN "\033[32m"
+
+int main(int argc, char *argv[]) {
+  /*if (argc != 2) {*/
+  /*  fprintf(stderr, "Error. Usage: croc <code>\n");*/
+  /*  return EXIT_FAILURE;*/
+  /*}*/
+
+  FILE *fd;
+  int lineCount = 1;
+
+  fd = fopen("./doc/examples/code.proc", "r");
+  if (fd == NULL) {
+    fprintf(stderr, "Error opening file\n");
+    return EXIT_FAILURE;
+  }
+
+  // lexing!
+  while (true) {
+    struct Token token = lexerGetNextChar(fd, &lineCount);
+    if (token.category == END_OF_FILE) {
+      fclose(fd);
+      break;
+    }
+    // handle malformed manually to
+    // keep the printing callback simple.
+    if (token.category == MALFORMED_TOKEN) {
+      fprintf(stderr, RED "ERROR: MALFORMED TOKEN %s ON LINE %d\n" RESET, token.lexeme,
+              lineCount);
+      exit(EXIT_FAILURE);
+    }
+    printToken(token);
+    printf("\n");
+  }
+
+  printf(GREEN "Lexing successful!" RESET "\n");
+
+  int *lc;
+  int line = 1;
+  lc = &line;
+
+  fd = fopen("./doc/examples/code.proc", "r");
+  if (fd == NULL) {
+    fprintf(stderr, "Error opening file\n");
+    return EXIT_FAILURE;
+  }
+
+  // for integration tests, prog itself needs a previously initialized parser
+  // with a token too
+  struct Token token = lexerGetNextChar(fd, lc);
+  struct Parser parser = {
+      .fd = fd, .lineCount = lc, .token = token};
+
+  enum SYNTAX_ERROR error = prog(&parser);
+  if (error != NO_ERROR) {
+    printSyntaxError(error, lc);
+    exit(EXIT_FAILURE);
+  }
+
+  printf(GREEN "Parsing successful!" RESET "\n");
+}

doc/examples/code.proc

@@ -1,5 +1 @@
-var a = 80 // something
-if (a == 80) // something else
-for (int i = 0) 'a' '\n' banana '\0'
-4.4
-int a[2] = {1, 2}
+prot a -