Worked on interpreter

SLS_C/include/sls/interpreter.h

@@ -54,11 +54,11 @@ typedef struct StackItem {
 
 typedef struct {
     StackItem *stack;
-    HashTable functions;
+    HashTable *functions;
 } InterpreterState;
 
+void execute(InterpreterState *interpreter_state, LexerTokenResult *token);
 InterpreterState *interpreter_create();
-void execute(InterpreterState *interpreter, LexerTokenResult *token);
-void interpreter_delete(InterpreterState *interpreter);
+void interpreter_delete(InterpreterState *interpreter_state);
 
 #endif // SLS_INTERPRETER_H

SLS_C/include/sls/lexer.h

@@ -157,6 +157,7 @@ typedef struct {
 TokenString copy_token_string(TokenString token_string);
 void init_lexer(LexerInfo *lexer_info, SlsStr filename, SlsStr source_code);
 LexerTokenResult *get_token(LexerTokenResult *head, size_t i);
+void clean_token_string(TokenString token_string);
 void clean_token_result(LexerTokenResult *head);
 LexerResult lexical_analysis(LexerInfo *lexer_info);
 

SLS_C/src/interpreter.c

@@ -6,6 +6,9 @@
 #include "sls/string.h"
 #include "sls/interpreter.h"
 #include "sls/lexer.h"
+#include "sls/hash_table.h"
+
+static const size_t HASH_TABLE_BUCKET_COUNT = 256;
 
 const char *STACK_TYPES_NAMES[] = {
     "Identifier",
@@ -33,3 +36,29 @@ static Boolean hash_table_put_funcs(HashTable *ht, SlsStr key, TokenString *item
 static TokenString* hash_table_get_funcs(const HashTable *ht, SlsStr key, TokenString *default_item) {
     return (TokenString*)hash_table_get(ht, key, (void *)default_item);
 }
+
+void execute(InterpreterState *interpreter_state, LexerTokenResult *token) {
+    
+}
+
+InterpreterState *interpreter_create() {
+    InterpreterState *interpreter_state = (InterpreterState *)malloc(sizeof(InterpreterState));
+    interpreter_state->stack = NULL;
+    interpreter_state->functions = init_hash_table(HASH_TABLE_BUCKET_COUNT);
+
+    return interpreter_state;
+}
+
+static void clean_stack(StackItem *item) {
+    if (item == NULL) return;
+    if (item->type == STACK_TOKEN_STRING)
+        clean_token_string(item->token_string);
+    clean_stack(item->next);
+    free(item);
+}
+
+void interpreter_delete(InterpreterState *interpreter_state) {
+    clean_stack(interpreter_state->stack);
+    del_hash_table(interpreter_state->functions);
+    free(interpreter_state);
+}

SLS_C/src/lexer.c

@@ -907,7 +907,7 @@ static LexerResult lexer_next(LexerInfo *lexer_info) {
     return lexer_error(lexer_info, error_msg, start, start_line);
 }
 
-static void clean_token_string(TokenString token_string) {
+void clean_token_string(TokenString token_string) {
     if (token_string.tokens == NULL) return;
     for (size_t i = 0; i < token_string.length; i++) {
         if (token_string.tokens[i].type == TOKEN_STRING)

SLS_C/src/repl.c

@@ -24,14 +24,15 @@ int repl(int argc, char *argv[]) {
     print_version();
     printf("===== YREA SLS REPL =====\n");
     printf("Type `#exit` to exit.\n");
+    fflush(stdout);
 
     LexerInfo lexer_info;
     InterpreterState *interpreter_state = interpreter_create();
     char buf[BUFFER_SIZE];
-    while (fgets(buf, sizeof buf, stdin)) {
+    while (fgets(buf, BUFFER_SIZE, stdin)) {
         size_t len = strlen(buf);
         if (len && buf[len - 1] == '\n') buf[len - 1] = '\0';
-        if (strncmp("#exit", buf, BUFFER_SIZE) == 0) {
+        if (strncmp(buf, "#exit", 5) == 0) {
             interpreter_delete(interpreter_state);
             return 0;
         }
@@ -41,6 +42,7 @@ int repl(int argc, char *argv[]) {
         LexerResult result = lexical_analysis(&lexer_info);
         if (result.type == SLS_ERROR) {
             printf("%s\n", result.error.message.str);
+            sls_str_free(&result.error.message);
         } else {
             LexerTokenResult *head = result.result;
             while (head) {
@@ -51,6 +53,7 @@ int repl(int argc, char *argv[]) {
                     execute(interpreter_state, head);
                 head = head->next;
             }
+            clean_token_result(result.result);
         }
         sls_str_free(&code);
     }