fix: remove duplicates from symbol table, forbid var redeclarations (#21)

**Description**

This PR modifies the symbol table creation logic by:
- Storing the table as a global variable in the form of a Vec, every
time we parse a symbol we push it to this vector
- If compilation is successful or we exit with an error we first dump
the table into a file
- When parsing the variable declarations inside `init {}` if we find a
symbol that is already in the table we exit with an error.
This PR also modifies the parsing of negative floats and integers:
- The enum variants `NumberNegativeInt` and `NumberNegativeInt` were
removed in favor of using i64 and f32 to store negatives.

Author: LeanSerra

inputs/test.txt

@@ -6,9 +6,13 @@ init {
     #+ Ejemplo de una variable mal declarada +#
     #+ fecha : date +#
     #+ h : foat +#
+
+    #+ Ejemplo de error por redeclaracion de variable +#
+    #+ a1: int +#
 }
 
 a1 := -125
+b2 := -125
 b2 := a1
 
 c33 := 5.34

src/context.rs

@@ -1,11 +1,18 @@
 use std::{
     cell::RefCell,
+    fmt::Display,
     fs::{File, OpenOptions, read_to_string},
     io::{self, Read, Seek, Write},
+    ops::Range,
     path::PathBuf,
 };
 use thiserror::Error;
 
+use crate::{
+    grammar_actions::{DataType, TokenFloatLiteral, TokenIntLiteral, TokenStringLiteral},
+    grammar_lexer::log_error,
+};
+
 #[derive(Debug, Error)]
 pub enum CompilerError {
     #[error("Parser internal error: {0:?}")]
@@ -25,6 +32,7 @@ thread_local! {
     pub static LEXER_FILE: RefCell<Option<File>> = const { RefCell::new(None) };
     pub static PARSER_FILE: RefCell<Option<File>> = const { RefCell::new(None) };
     pub static SYMBOL_TABLE_FILE: RefCell<Option<File>> = const { RefCell::new(None) };
+    pub static SYMBOL_TABLE: RefCell<Vec<SymbolTableElement>> = const { RefCell::new(Vec::new())}
 }
 
 pub fn set_source_file_path(path: PathBuf) {
@@ -95,15 +103,34 @@ pub fn open_symbol_table_file() -> Result<(), io::Error> {
     })
 }
 
-pub fn write_to_symbol_table_file(line: &str) -> Result<(), io::Error> {
+pub fn dump_symbol_table_to_file() -> Result<(), io::Error> {
     SYMBOL_TABLE_FILE.with(|f| {
         if let Some(mut file) = f.borrow_mut().as_ref() {
-            writeln!(file, "{line}")?;
+            for symbol in SYMBOL_TABLE.take() {
+                writeln!(file, "{symbol}")?;
+            }
         }
         Ok(())
     })
 }
 
+pub fn log_error_and_exit(
+    pos: Range<usize>,
+    error: CompilerError,
+    offset: usize,
+    trace: bool,
+) -> ! {
+    dump_symbol_table_to_file().expect("Failed to write symbol table");
+    log_error(
+        pos,
+        error,
+        offset,
+        &read_source_to_string().expect("Failed to print error location"),
+        trace,
+    );
+    std::process::exit(1)
+}
+
 pub fn read_source_to_string() -> Result<String, CompilerError> {
     SOURCE_CODE_PATH.with(|f| {
         if let Some(path) = f.borrow().as_ref() {
@@ -134,3 +161,79 @@ pub fn read_parser_file_to_string() -> Result<String, CompilerError> {
         }
     })
 }
+
+#[derive(Clone, Debug)]
+pub enum SymbolTableElement {
+    VarDeclaration(String, DataType, usize),
+    IntLiteral(TokenIntLiteral),
+    FloatLiteral(TokenFloatLiteral),
+    StringLiteral(TokenStringLiteral),
+}
+
+impl Display for SymbolTableElement {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::FloatLiteral(float) => write!(
+                f,
+                "{}|CONST_FLOAT|{}|{}",
+                float.original,
+                float.original,
+                float.original.len()
+            )?,
+            Self::IntLiteral(int) => {
+                write!(f, "{}|CONST_INT|{}|{}", int, int, int.to_string().len())?
+            }
+            Self::StringLiteral(string) => {
+                write!(f, "{}|CONST_STRING|{}|{}", string, string, string.len())?
+            }
+            Self::VarDeclaration(token, r#type, length) => {
+                write!(f, "{}|{}|-|{}", token, r#type, length)?
+            }
+        };
+        Ok(())
+    }
+}
+
+impl PartialEq for SymbolTableElement {
+    fn eq(&self, other: &Self) -> bool {
+        match (self, other) {
+            (Self::FloatLiteral(token0), Self::FloatLiteral(token1)) => token0 == token1,
+            (Self::IntLiteral(token0), Self::IntLiteral(token1)) => token0 == token1,
+            (Self::StringLiteral(token0), Self::StringLiteral(token1)) => token0 == token1,
+            (Self::VarDeclaration(token0, _, _), Self::VarDeclaration(token1, _, _)) => {
+                token0 == token1
+            }
+            _ => false,
+        }
+    }
+}
+
+impl From<TokenIntLiteral> for SymbolTableElement {
+    fn from(value: TokenIntLiteral) -> Self {
+        Self::IntLiteral(value)
+    }
+}
+
+impl From<TokenFloatLiteral> for SymbolTableElement {
+    fn from(value: TokenFloatLiteral) -> Self {
+        Self::FloatLiteral(value)
+    }
+}
+
+impl From<TokenStringLiteral> for SymbolTableElement {
+    fn from(value: TokenStringLiteral) -> Self {
+        Self::StringLiteral(value)
+    }
+}
+pub fn push_to_symbol_table(item: SymbolTableElement) {
+    SYMBOL_TABLE.with(|table| {
+        // Avoid pushing duplicate symbols to the symbol table
+        if !symbol_exists(&item) {
+            table.borrow_mut().push(item);
+        }
+    })
+}
+
+pub fn symbol_exists(item: &SymbolTableElement) -> bool {
+    SYMBOL_TABLE.with(|table| table.borrow().contains(item))
+}