fixing some bugs

9 files changed, 58 insertions, 20 deletions

diff --git a/Makefile b/Makefile
index 0fd74c4..d713229 100644
--- a/Makefile
+++ b/Makefile
@@ -20,9 +20,9 @@ INC_DIRS := $(SRC_DIR)
 INC_FLAGS := $(addprefix -I,$(INC_DIRS))
 
 # OP_FLAG := -Ofast
-OP_FLAG := -O3
+# OP_FLAG := -O3
 # OP_FLAG := -Oz
-# OP_FLAG := -g
+OP_FLAG := -g
 
 LINK_FLAGS := -lffi
 
diff --git a/README.md b/README.md
index ae9dd84..89e4de0 100644
--- a/README.md
+++ b/README.md
@@ -20,16 +20,15 @@ A strongly statically typed programming language with a simple and friendly synt
 * libffi (for calling C functions)
 
 # How to use ?
-## Clone the repo
+Clone the repo
 ```
 git clone https://github.com/A404M/felan
 cd felan
 ```
-## Building
+Building
 ```
 make
 ```
-## Running
 Run ./build/felan with any file which you want to run
 ```
 ./build/felan code/main.felan
diff --git a/code/basic.felan b/code/basic.felan
index 930dc5c..1e4ce2f 100644
--- a/code/basic.felan
+++ b/code/basic.felan
@@ -2,3 +2,4 @@
 @import("lib/types.felan");
 @import("lib/io.felan");
 @import("lib/memory.felan");
+@import("lib/string.felan");
diff --git a/code/lib/string.felan b/code/lib/string.felan
new file mode 100644
index 0000000..e2dacbb
--- /dev/null
+++ b/code/lib/string.felan
@@ -0,0 +1,9 @@
+@import("operator.felan");
+@import("types.felan");
+
+sub_string :: (str:string, begin:i64, end:i64) -> string {
+  result := "";
+  result.ptr = str.ptr + begin;
+  result.length = @cast(end-begin,u64);
+  return result;
+};
diff --git a/code/main.felan b/code/main.felan
index 0803589..e6d479f 100644
--- a/code/main.felan
+++ b/code/main.felan
@@ -1,10 +1,34 @@
-// @import("basic.felan");
+@import("basic.felan");
+
+t :: (comptime formatter : string) -> void {
+  i := 0;
+  in := 0;
+  opening := 0;
+  while @cast(i,u64) < formatter.length {
+    c := formatter[i];
+    if c == '{' {
+      if in == 0 {
+        opening = i+1;
+      }
+      in += 1;
+    } else if c == '}' {
+      in -= 1;
+      if in == 0{
+        str := sub_string(formatter,opening,i);
+        print(str);
+      } else if in < 0 {
+        in = 0;
+      }
+    }
+    i += 1;
+  }
+};
 
 main :: () -> void {
   a := '2';
-  @insert("a = '3';");
-  @insert("a = '5';");
+  @insert("a = '3';a = '5';");
   @putc(a);
+  // t("hello {world}");
   // @insert("print(123);");
 };
 
diff --git a/src/compiler/ast-tree.c b/src/compiler/ast-tree.c
index 28741bd..ac6801d 100644
--- a/src/compiler/ast-tree.c
+++ b/src/compiler/ast-tree.c
@@ -6031,6 +6031,7 @@ bool setTypesFunctionCall(AstTree *tree, AstTreeSetTypesHelper _helper) {
 
   if (metadata->function->token == AST_TREE_TOKEN_BUILTIN_INSERT) {
     char *code = u8ArrayToCString(metadata->parameters[0].value);
+    filePush("", code);
     LexerNodeArray lexerArray = lexer(code);
     if (lexerNodeArrayIsError(lexerArray)) {
       UNREACHABLE;
@@ -6065,8 +6066,12 @@ bool setTypesFunctionCall(AstTree *tree, AstTreeSetTypesHelper _helper) {
         };
         AstTree *astNodes[nodeArray->size];
         for (size_t i = 0; i < nodeArray->size; ++i) {
-          AstTree *tree = astTreeParse(nodeArray->data[i]);
-          if (tree == NULL || !setAllTypes(tree, newHelper, NULL, NULL)) {
+          ParserNode *node = nodeArray->data[i];
+          while (node->token == PARSER_TOKEN_SYMBOL_EOL) {
+            node = (ParserNodeSingleChildMetadata *)node->metadata;
+          }
+          AstTree *tree = astTreeParse(node);
+          if (tree == NULL) {
             return false;
           }
           astNodes[i] = tree;
@@ -6074,6 +6079,9 @@ bool setTypesFunctionCall(AstTree *tree, AstTreeSetTypesHelper _helper) {
         astTreeDestroy(*tree);
         *tree = *astNodes[0];
         free(astNodes[0]);
+        if (!setAllTypes(tree, newHelper, NULL, NULL)) {
+          return false;
+        }
         size_t parentIndex = _helper.scope->expressions_size;
         for (size_t i = 0; i < _helper.scope->expressions_size; ++i) {
           if (_helper.scope->expressions[i] == tree) {
@@ -6092,21 +6100,18 @@ bool setTypesFunctionCall(AstTree *tree, AstTreeSetTypesHelper _helper) {
             _helper.scope->expressions_size + nodeArray->size - 1;
 
         if (expression_capacity < newSize) {
-          UNREACHABLE;
           expression_capacity = newSize;
           _helper.scope->expressions = a404m_realloc(
               _helper.scope->expressions,
               expression_capacity * sizeof(*_helper.scope->expressions));
         }
 
-        for (size_t i = _helper.scope->expressions_size - 1; i > parentIndex;
-             --i) {
+        for (size_t i = newSize - 1; i > parentIndex; --i) {
           _helper.scope->expressions[i] =
               _helper.scope->expressions[i - nodeArray->size + 1];
         }
 
         for (size_t i = 1; i < nodeArray->size; ++i) {
-          UNREACHABLE;
           _helper.scope->expressions[i + parentIndex] = astNodes[i];
         }
 
@@ -6115,7 +6120,6 @@ bool setTypesFunctionCall(AstTree *tree, AstTreeSetTypesHelper _helper) {
     }
     parserNodeDelete(rootParser);
     lexerNodeArrayDestroy(lexerArray);
-    free(code);
   }
 
   return true;
diff --git a/src/compiler/lexer.h b/src/compiler/lexer.h
index 202b041..2e9807d 100644
--- a/src/compiler/lexer.h
+++ b/src/compiler/lexer.h
@@ -2,7 +2,6 @@
 
 #include "utils/type.h"
 #include <stddef.h>
-#include <stdio.h>
 
 typedef enum LexerToken {
   LEXER_TOKEN_SYMBOL_CLOSE_CURLY_BRACKET,
diff --git a/src/compiler/parser.c b/src/compiler/parser.c
index 2f36289..ed51742 100644
--- a/src/compiler/parser.c
+++ b/src/compiler/parser.c
@@ -1404,8 +1404,9 @@ ParserNode *parserString(LexerNode *node, ParserNode *parent) {
     metadata->end += 1;
   }
 
-  size_t size = metadata->end - metadata->begin;
-  metadata->begin = a404m_realloc(metadata->begin, size * (*metadata->begin));
+  const size_t size = metadata->end - metadata->begin;
+  metadata->begin =
+      a404m_realloc(metadata->begin, size * sizeof(*metadata->begin));
   metadata->end = metadata->begin + size;
 
   return node->parserNode =
diff --git a/src/runner/runner.c b/src/runner/runner.c
index 23b6d7e..012c84a 100644
--- a/src/runner/runner.c
+++ b/src/runner/runner.c
@@ -303,8 +303,8 @@ AstTree *runAstTreeBuiltin(AstTree *tree, AstTreeScope *scope,
     default:
       UNREACHABLE;
     }
-    return newAstTree(AST_TREE_TOKEN_RAW_VALUE, ret, copyAstTree(left->type), NULL,
-                      NULL);
+    return newAstTree(AST_TREE_TOKEN_RAW_VALUE, ret, copyAstTree(left->type),
+                      NULL, NULL);
   }
   case AST_TREE_TOKEN_BUILTIN_ADD: {
     AstTree *left = arguments[0];
@@ -1473,6 +1473,7 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet,
         astTreeDelete(l);
         return copyAstTree(left->value);
       } else if (l->token == AST_TREE_TOKEN_RAW_VALUE) {
+        UNREACHABLE;
         AstTree *right =
             runExpression(metadata->right, scope, shouldRet, false, isComptime,
                           breakCount, shouldContinue, false);