Added pushing tokens to the stack

SLS_C/include/sls/interpreter.h

@@ -45,7 +45,7 @@ typedef struct StackItem {
         uint8_t u8;
         float f32;
         double f64;
-        char character;
+        uint8_t character;
         Boolean boolean;
         TokenString token_string;
     };

SLS_C/src/interpreter.c

@@ -40,7 +40,113 @@ static TokenString *hash_table_get_funcs(const HashTable *ht, SlsStr key, TokenS
 }
 
 static Boolean push_token(InterpreterState *interpreter_state, Token token) {
+    StackType type;
+    switch (token.type) {
+    case TOKEN_EOF:
+        return TRUE;
+    case TOKEN_IDENTIFIER:
+        type = STACK_IDENTIFIER;
+        break;
+    case TOKEN_INTEGER:
+        switch (token.integer_literal.type) {
+        case INTEGER_I64:
+            type = STACK_I64;
+            break;
+        case INTEGER_I32:
+            type = STACK_I32;
+            break;
+        case INTEGER_I16:
+            type = STACK_I16;
+            break;
+        case INTEGER_I8:
+            type = STACK_I8;
+            break;
+        case INTEGER_U64:
+            type = STACK_U64;
+            break;
+        case INTEGER_U32:
+            type = STACK_U32;
+            break;
+        case INTEGER_U16:
+            type = STACK_U16;
+            break;
+        case INTEGER_U8:
+            type = STACK_U8;
+            break;
+        }
+        break;
+    case TOKEN_FLOAT:
+        type = STACK_FLOAT;
+        break;
+    case TOKEN_DOUBLE:
+        type = STACK_DOUBLE;
+        break;
+    case TOKEN_CHARACTER:
+        type = STACK_CHARACTER;
+        break;
+    case TOKEN_STRING:
+        return FALSE;
+    case TOKEN_BOOLEAN:
+        type = STACK_BOOLEAN;
+        break;
+    case TOKEN_ARRAY:
+        return FALSE;
+    case TOKEN_TOKEN_STRING:
+        type = STACK_TOKEN_STRING;
+        break;
+    case TOKEN_TYPE_TUPLE:
+        return FALSE;
+    }
 
+    StackItem *item = (StackItem *)malloc(sizeof(StackItem));
+    item->type = type;
+    item->next = interpreter_state->stack;
+    interpreter_state->stack = item;
+
+    switch (type) {
+    case STACK_IDENTIFIER:
+        item->identifier = token.identifier;
+        break;
+    case STACK_I64:
+        item->i64 = (int64_t)token.integer_literal.value;
+        break;
+    case STACK_I32:
+        item->i32 = (int32_t)token.integer_literal.value;
+        break;
+    case STACK_I16:
+        item->i16 = (int16_t)token.integer_literal.value;
+        break;
+    case STACK_I8:
+        item->i8 = (int8_t)token.integer_literal.value;
+        break;
+    case STACK_U64:
+        item->u64 = (uint64_t)token.integer_literal.value;
+        break;
+    case STACK_U32:
+        item->u32 = (uint32_t)token.integer_literal.value;
+        break;
+    case STACK_U16:
+        item->u16 = (uint16_t)token.integer_literal.value;
+        break;
+    case STACK_U8:
+        item->u8 = (uint8_t)token.integer_literal.value;
+        break;
+    case STACK_FLOAT:
+        item->f32 = token.float_literal;
+        break;
+    case STACK_DOUBLE:
+        item->f64 = token.double_literal;
+        break;
+    case STACK_CHARACTER:
+        item->character = token.character_literal;
+        break;
+    case STACK_BOOLEAN:
+        item->boolean = token.boolean_literal;
+        break;
+    case STACK_TOKEN_STRING:
+        item->token_string = copy_token_string(token.token_string);
+        break;
+    }
 }
 
 static Boolean execute_func(InterpreterState *interpreter_state, SlsStr key) {

SLS_C/src/repl.c

@@ -28,7 +28,7 @@ int repl(int argc, char *argv[]) {
     LexerInfo lexer_info;
     InterpreterState *interpreter_state = interpreter_create();
     char buf[256];
-    while (fgets(buf, sizeof buf, stdin)) {
+    while (fgets(buf, sizeof(buf), stdin)) {
         size_t len = strlen(buf);
         if (len && buf[len - 1] == '\n') buf[len - 1] = '\0';
         if (strncmp(buf, "#exit", 5) == 0) {
@@ -36,7 +36,7 @@ int repl(int argc, char *argv[]) {
             return 0;
         }
 
-        SlsStr code = sls_str_malloc(buf, sizeof buf);
+        SlsStr code = sls_str_malloc(buf, sizeof(buf));
         init_lexer(&lexer_info, REPL_FILE_NAME, code);
         LexerResult result = lexical_analysis(&lexer_info);
         if (result.type == SLS_ERROR) {