changed the way of parsing order finding to speed it up

6 files changed, 140 insertions, 126 deletions

diff --git a/Makefile b/Makefile
index f7e5e58..9cbdb2b 100644
--- a/Makefile
+++ b/Makefile
@@ -19,9 +19,9 @@ NC := \033[0m
 INC_DIRS := $(SRC_DIR)
 INC_FLAGS := $(addprefix -I,$(INC_DIRS))
 
-# CFLAGS := $(INC_FLAGS) -Wall -Wextra -std=gnu23 -O3
+CFLAGS := $(INC_FLAGS) -Wall -Wextra -std=gnu23 -O3
 # CFLAGS := $(INC_FLAGS) -Wall -Wextra -std=gnu23 -Oz
-CFLAGS := $(INC_FLAGS) -Wall -Wextra -std=gnu23 -g
+# CFLAGS := $(INC_FLAGS) -Wall -Wextra -std=gnu23 -g
 
 EXEC_FILE := $(BUILD_DIR)/$(PROJECT_NAME)
 
diff --git a/src/compiler/lexer.c b/src/compiler/lexer.c
index bba8ee5..71a8572 100644
--- a/src/compiler/lexer.c
+++ b/src/compiler/lexer.c
@@ -9,8 +9,10 @@
 #include <stdlib.h>
 
 const char *LEXER_TOKEN_STRINGS[] = {
-    "LEXER_TOKEN_IDENTIFIER",
+    "LEXER_TOKEN_SYMBOL_CLOSE_CURLY_BRACKET",
 
+    "LEXER_TOKEN_SYMBOL_CLOSE_PARENTHESIS",
+    "LEXER_TOKEN_IDENTIFIER",
     "LEXER_TOKEN_KEYWORD_TYPE",
     "LEXER_TOKEN_KEYWORD_VOID",
     "LEXER_TOKEN_KEYWORD_I8",
@@ -20,61 +22,70 @@ const char *LEXER_TOKEN_STRINGS[] = {
     "LEXER_TOKEN_KEYWORD_I32",
     "LEXER_TOKEN_KEYWORD_U32",
     "LEXER_TOKEN_KEYWORD_I64",
-    "LEXER_TOKEN_KEYWORD_U64",
 #ifdef FLOAT_16_SUPPORT
     "LEXER_TOKEN_KEYWORD_F16",
 #endif
     "LEXER_TOKEN_KEYWORD_F32",
     "LEXER_TOKEN_KEYWORD_F64",
     "LEXER_TOKEN_KEYWORD_F128",
+    "LEXER_TOKEN_KEYWORD_U64",
     "LEXER_TOKEN_KEYWORD_BOOL",
-    "LEXER_TOKEN_KEYWORD_PUTC",
-    "LEXER_TOKEN_KEYWORD_RETURN",
     "LEXER_TOKEN_KEYWORD_TRUE",
     "LEXER_TOKEN_KEYWORD_FALSE",
-    "LEXER_TOKEN_KEYWORD_IF",
-    "LEXER_TOKEN_KEYWORD_ELSE",
-    "LEXER_TOKEN_KEYWORD_WHILE",
-    "LEXER_TOKEN_KEYWORD_COMPTIME",
     "LEXER_TOKEN_KEYWORD_NULL",
-    "LEXER_TOKEN_KEYWORD_STRUCT",
-    "LEXER_TOKEN_KEYWORD_UNDEFINED",
-
     "LEXER_TOKEN_NUMBER",
     "LEXER_TOKEN_CHAR",
+    "LEXER_TOKEN_KEYWORD_UNDEFINED",
 
-    "LEXER_TOKEN_SYMBOL",
-    "LEXER_TOKEN_SYMBOL_EOL",
-    "LEXER_TOKEN_SYMBOL_OPEN_PARENTHESIS",
-    "LEXER_TOKEN_SYMBOL_CLOSE_PARENTHESIS",
-    "LEXER_TOKEN_SYMBOL_OPEN_CURLY_BRACKET",
-    "LEXER_TOKEN_SYMBOL_CLOSE_CURLY_BRACKET",
     "LEXER_TOKEN_SYMBOL_FUNCTION_ARROW",
-    "LEXER_TOKEN_SYMBOL_COLON",
-    "LEXER_TOKEN_SYMBOL_ASSIGN",
-    "LEXER_TOKEN_SYMBOL_SUM_ASSIGN",
-    "LEXER_TOKEN_SYMBOL_SUB_ASSIGN",
-    "LEXER_TOKEN_SYMBOL_MULTIPLY_ASSIGN",
-    "LEXER_TOKEN_SYMBOL_DIVIDE_ASSIGN",
-    "LEXER_TOKEN_SYMBOL_MODULO_ASSIGN",
-    "LEXER_TOKEN_SYMBOL_COMMA",
+    "LEXER_TOKEN_SYMBOL_POINTER",
+    "LEXER_TOKEN_KEYWORD_STRUCT",
+
+    "LEXER_TOKEN_SYMBOL_DEREFERENCE",
+    "LEXER_TOKEN_SYMBOL_ACCESS",
+
     "LEXER_TOKEN_SYMBOL_PLUS",
     "LEXER_TOKEN_SYMBOL_MINUS",
-    "LEXER_TOKEN_SYMBOL_SUM",
-    "LEXER_TOKEN_SYMBOL_SUB",
+    "LEXER_TOKEN_SYMBOL_ADDRESS",
+
     "LEXER_TOKEN_SYMBOL_MULTIPLY",
     "LEXER_TOKEN_SYMBOL_DIVIDE",
     "LEXER_TOKEN_SYMBOL_MODULO",
+
+    "LEXER_TOKEN_SYMBOL_SUM",
+    "LEXER_TOKEN_SYMBOL_SUB",
+
     "LEXER_TOKEN_SYMBOL_EQUAL",
     "LEXER_TOKEN_SYMBOL_NOT_EQUAL",
     "LEXER_TOKEN_SYMBOL_GREATER",
     "LEXER_TOKEN_SYMBOL_SMALLER",
     "LEXER_TOKEN_SYMBOL_GREATER_OR_EQUAL",
     "LEXER_TOKEN_SYMBOL_SMALLER_OR_EQUAL",
-    "LEXER_TOKEN_SYMBOL_POINTER",
-    "LEXER_TOKEN_SYMBOL_ADDRESS",
-    "LEXER_TOKEN_SYMBOL_DEREFERENCE",
-    "LEXER_TOKEN_SYMBOL_ACCESS",
+
+    "LEXER_TOKEN_SYMBOL_COLON",
+
+    "LEXER_TOKEN_SYMBOL_ASSIGN",
+    "LEXER_TOKEN_SYMBOL_SUM_ASSIGN",
+    "LEXER_TOKEN_SYMBOL_SUB_ASSIGN",
+    "LEXER_TOKEN_SYMBOL_MULTIPLY_ASSIGN",
+    "LEXER_TOKEN_SYMBOL_DIVIDE_ASSIGN",
+    "LEXER_TOKEN_SYMBOL_MODULO_ASSIGN",
+
+    "LEXER_TOKEN_KEYWORD_RETURN",
+    "LEXER_TOKEN_KEYWORD_PUTC",
+    "LEXER_TOKEN_KEYWORD_COMPTIME",
+
+    "LEXER_TOKEN_SYMBOL_EOL",
+    "LEXER_TOKEN_SYMBOL_COMMA",
+
+    "LEXER_TOKEN_KEYWORD_IF",
+    "LEXER_TOKEN_KEYWORD_WHILE",
+
+    "LEXER_TOKEN_KEYWORD_ELSE",
+
+    "LEXER_TOKEN_SYMBOL",
+    "LEXER_TOKEN_SYMBOL_OPEN_PARENTHESIS",
+    "LEXER_TOKEN_SYMBOL_OPEN_CURLY_BRACKET",
 
     "LEXER_TOKEN_NONE",
 };
diff --git a/src/compiler/lexer.h b/src/compiler/lexer.h
index 80cd914..352e044 100644
--- a/src/compiler/lexer.h
+++ b/src/compiler/lexer.h
@@ -4,8 +4,13 @@
 #include <stddef.h>
 
 typedef enum LexerToken {
-  LEXER_TOKEN_IDENTIFIER,
+  LEXER_TOKEN_SYMBOL_CLOSE_CURLY_BRACKET,
+
+  LEXER_TOKEN_ORDER0 = LEXER_TOKEN_SYMBOL_CLOSE_CURLY_BRACKET,
 
+  LEXER_TOKEN_SYMBOL_CLOSE_PARENTHESIS,
+  LEXER_TOKEN_ORDER1 = LEXER_TOKEN_SYMBOL_CLOSE_PARENTHESIS,
+  LEXER_TOKEN_IDENTIFIER,
   LEXER_TOKEN_KEYWORD_TYPE,
   LEXER_TOKEN_KEYWORD_VOID,
   LEXER_TOKEN_KEYWORD_I8,
@@ -15,61 +20,82 @@ typedef enum LexerToken {
   LEXER_TOKEN_KEYWORD_I32,
   LEXER_TOKEN_KEYWORD_U32,
   LEXER_TOKEN_KEYWORD_I64,
-  LEXER_TOKEN_KEYWORD_U64,
 #ifdef FLOAT_16_SUPPORT
   LEXER_TOKEN_KEYWORD_F16,
 #endif
   LEXER_TOKEN_KEYWORD_F32,
   LEXER_TOKEN_KEYWORD_F64,
   LEXER_TOKEN_KEYWORD_F128,
+  LEXER_TOKEN_KEYWORD_U64,
   LEXER_TOKEN_KEYWORD_BOOL,
-  LEXER_TOKEN_KEYWORD_PUTC,
-  LEXER_TOKEN_KEYWORD_RETURN,
   LEXER_TOKEN_KEYWORD_TRUE,
   LEXER_TOKEN_KEYWORD_FALSE,
-  LEXER_TOKEN_KEYWORD_IF,
-  LEXER_TOKEN_KEYWORD_ELSE,
-  LEXER_TOKEN_KEYWORD_WHILE,
-  LEXER_TOKEN_KEYWORD_COMPTIME,
   LEXER_TOKEN_KEYWORD_NULL,
-  LEXER_TOKEN_KEYWORD_STRUCT,
-  LEXER_TOKEN_KEYWORD_UNDEFINED,
-
   LEXER_TOKEN_NUMBER,
   LEXER_TOKEN_CHAR,
+  LEXER_TOKEN_KEYWORD_UNDEFINED,
 
-  LEXER_TOKEN_SYMBOL,
-  LEXER_TOKEN_SYMBOL_EOL,
-  LEXER_TOKEN_SYMBOL_OPEN_PARENTHESIS,
-  LEXER_TOKEN_SYMBOL_CLOSE_PARENTHESIS,
-  LEXER_TOKEN_SYMBOL_OPEN_CURLY_BRACKET,
-  LEXER_TOKEN_SYMBOL_CLOSE_CURLY_BRACKET,
   LEXER_TOKEN_SYMBOL_FUNCTION_ARROW,
-  LEXER_TOKEN_SYMBOL_COLON,
-  LEXER_TOKEN_SYMBOL_ASSIGN,
-  LEXER_TOKEN_SYMBOL_SUM_ASSIGN,
-  LEXER_TOKEN_SYMBOL_SUB_ASSIGN,
-  LEXER_TOKEN_SYMBOL_MULTIPLY_ASSIGN,
-  LEXER_TOKEN_SYMBOL_DIVIDE_ASSIGN,
-  LEXER_TOKEN_SYMBOL_MODULO_ASSIGN,
-  LEXER_TOKEN_SYMBOL_COMMA,
+  LEXER_TOKEN_ORDER2 = LEXER_TOKEN_SYMBOL_FUNCTION_ARROW,
+  LEXER_TOKEN_SYMBOL_POINTER,
+  LEXER_TOKEN_KEYWORD_STRUCT,
+
+  LEXER_TOKEN_SYMBOL_DEREFERENCE,
+  LEXER_TOKEN_ORDER3 = LEXER_TOKEN_SYMBOL_DEREFERENCE,
+  LEXER_TOKEN_SYMBOL_ACCESS,
+
   LEXER_TOKEN_SYMBOL_PLUS,
+  LEXER_TOKEN_ORDER4 = LEXER_TOKEN_SYMBOL_PLUS,
   LEXER_TOKEN_SYMBOL_MINUS,
-  LEXER_TOKEN_SYMBOL_SUM,
-  LEXER_TOKEN_SYMBOL_SUB,
+  LEXER_TOKEN_SYMBOL_ADDRESS,
+
   LEXER_TOKEN_SYMBOL_MULTIPLY,
+  LEXER_TOKEN_ORDER5 = LEXER_TOKEN_SYMBOL_MULTIPLY,
   LEXER_TOKEN_SYMBOL_DIVIDE,
   LEXER_TOKEN_SYMBOL_MODULO,
+
+  LEXER_TOKEN_SYMBOL_SUM,
+  LEXER_TOKEN_ORDER6 = LEXER_TOKEN_SYMBOL_SUM,
+  LEXER_TOKEN_SYMBOL_SUB,
+
   LEXER_TOKEN_SYMBOL_EQUAL,
+  LEXER_TOKEN_ORDER7 = LEXER_TOKEN_SYMBOL_EQUAL,
   LEXER_TOKEN_SYMBOL_NOT_EQUAL,
   LEXER_TOKEN_SYMBOL_GREATER,
   LEXER_TOKEN_SYMBOL_SMALLER,
   LEXER_TOKEN_SYMBOL_GREATER_OR_EQUAL,
   LEXER_TOKEN_SYMBOL_SMALLER_OR_EQUAL,
-  LEXER_TOKEN_SYMBOL_POINTER,
-  LEXER_TOKEN_SYMBOL_ADDRESS,
-  LEXER_TOKEN_SYMBOL_DEREFERENCE,
-  LEXER_TOKEN_SYMBOL_ACCESS,
+
+  LEXER_TOKEN_SYMBOL_COLON,
+  LEXER_TOKEN_ORDER8 = LEXER_TOKEN_SYMBOL_COLON,
+
+  LEXER_TOKEN_SYMBOL_ASSIGN,
+  LEXER_TOKEN_ORDER9 = LEXER_TOKEN_SYMBOL_ASSIGN,
+  LEXER_TOKEN_SYMBOL_SUM_ASSIGN,
+  LEXER_TOKEN_SYMBOL_SUB_ASSIGN,
+  LEXER_TOKEN_SYMBOL_MULTIPLY_ASSIGN,
+  LEXER_TOKEN_SYMBOL_DIVIDE_ASSIGN,
+  LEXER_TOKEN_SYMBOL_MODULO_ASSIGN,
+
+  LEXER_TOKEN_KEYWORD_RETURN,
+  LEXER_TOKEN_ORDER10 = LEXER_TOKEN_KEYWORD_RETURN,
+  LEXER_TOKEN_KEYWORD_PUTC,
+  LEXER_TOKEN_KEYWORD_COMPTIME,
+
+  LEXER_TOKEN_SYMBOL_EOL,
+  LEXER_TOKEN_ORDER11 = LEXER_TOKEN_SYMBOL_EOL,
+  LEXER_TOKEN_SYMBOL_COMMA,
+
+  LEXER_TOKEN_KEYWORD_IF,
+  LEXER_TOKEN_ORDER12 = LEXER_TOKEN_KEYWORD_IF,
+  LEXER_TOKEN_KEYWORD_WHILE,
+
+  LEXER_TOKEN_KEYWORD_ELSE,
+  LEXER_TOKEN_END_ORDERS = LEXER_TOKEN_KEYWORD_ELSE,
+
+  LEXER_TOKEN_SYMBOL,
+  LEXER_TOKEN_SYMBOL_OPEN_PARENTHESIS,
+  LEXER_TOKEN_SYMBOL_OPEN_CURLY_BRACKET,
 
   LEXER_TOKEN_NONE,
 } LexerToken;
diff --git a/src/compiler/parser.c b/src/compiler/parser.c
index 0146650..5a0d00b 100644
--- a/src/compiler/parser.c
+++ b/src/compiler/parser.c
@@ -86,88 +86,71 @@ const char *PARSER_TOKEN_STRINGS[] = {
     "PARSER_TOKEN_NONE",
 };
 
-#define ORDER_ARRAY(...)                                                       \
-  .size = sizeof((LexerToken[]){__VA_ARGS__}) / sizeof(LexerToken),            \
-  .data = {__VA_ARGS__}
-
 static const ParserOrder PARSER_ORDER[] = {
     {
         .ltr = true,
-        ORDER_ARRAY(LEXER_TOKEN_SYMBOL_CLOSE_CURLY_BRACKET, ),
+        .begin = LEXER_TOKEN_ORDER0,
+        .end = LEXER_TOKEN_ORDER1,
     },
     {
         .ltr = true,
-        ORDER_ARRAY(LEXER_TOKEN_SYMBOL_CLOSE_PARENTHESIS,
-                    LEXER_TOKEN_IDENTIFIER, LEXER_TOKEN_KEYWORD_TYPE,
-                    LEXER_TOKEN_KEYWORD_VOID, LEXER_TOKEN_KEYWORD_I8,
-                    LEXER_TOKEN_KEYWORD_U8, LEXER_TOKEN_KEYWORD_I16,
-                    LEXER_TOKEN_KEYWORD_U16, LEXER_TOKEN_KEYWORD_I32,
-                    LEXER_TOKEN_KEYWORD_U32, LEXER_TOKEN_KEYWORD_I64,
-#ifdef FLOAT_16_SUPPORT
-                    LEXER_TOKEN_KEYWORD_F16,
-#endif
-                    LEXER_TOKEN_KEYWORD_F32, LEXER_TOKEN_KEYWORD_F64,
-                    LEXER_TOKEN_KEYWORD_F128, LEXER_TOKEN_KEYWORD_U64,
-                    LEXER_TOKEN_KEYWORD_BOOL, LEXER_TOKEN_KEYWORD_TRUE,
-                    LEXER_TOKEN_KEYWORD_FALSE, LEXER_TOKEN_KEYWORD_NULL,
-                    LEXER_TOKEN_NUMBER, LEXER_TOKEN_CHAR,
-                    LEXER_TOKEN_KEYWORD_UNDEFINED, ),
+        .begin = LEXER_TOKEN_ORDER1,
+        .end = LEXER_TOKEN_ORDER2,
     },
     {
         .ltr = false,
-        ORDER_ARRAY(LEXER_TOKEN_SYMBOL_FUNCTION_ARROW,
-                    LEXER_TOKEN_SYMBOL_POINTER, LEXER_TOKEN_KEYWORD_STRUCT, ),
+        .begin = LEXER_TOKEN_ORDER2,
+        .end = LEXER_TOKEN_ORDER3,
     },
     {
         .ltr = true,
-        ORDER_ARRAY(LEXER_TOKEN_SYMBOL_DEREFERENCE,
-                    LEXER_TOKEN_SYMBOL_ACCESS, ),
+        .begin = LEXER_TOKEN_ORDER3,
+        .end = LEXER_TOKEN_ORDER4,
     },
     {
         .ltr = false,
-        ORDER_ARRAY(LEXER_TOKEN_SYMBOL_PLUS, LEXER_TOKEN_SYMBOL_MINUS,
-                    LEXER_TOKEN_SYMBOL_ADDRESS, ),
+        .begin = LEXER_TOKEN_ORDER4,
+        .end = LEXER_TOKEN_ORDER5,
     },
     {
         .ltr = true,
-        ORDER_ARRAY(LEXER_TOKEN_SYMBOL_MULTIPLY, LEXER_TOKEN_SYMBOL_DIVIDE,
-                    LEXER_TOKEN_SYMBOL_MODULO, ),
+        .begin = LEXER_TOKEN_ORDER5,
+        .end = LEXER_TOKEN_ORDER6,
     },
     {
         .ltr = true,
-        ORDER_ARRAY(LEXER_TOKEN_SYMBOL_SUM, LEXER_TOKEN_SYMBOL_SUB, ),
+        .begin = LEXER_TOKEN_ORDER6,
+        .end = LEXER_TOKEN_ORDER7,
     },
     {
         .ltr = true,
-        ORDER_ARRAY(LEXER_TOKEN_SYMBOL_EQUAL, LEXER_TOKEN_SYMBOL_NOT_EQUAL,
-                    LEXER_TOKEN_SYMBOL_GREATER, LEXER_TOKEN_SYMBOL_SMALLER,
-                    LEXER_TOKEN_SYMBOL_GREATER_OR_EQUAL,
-                    LEXER_TOKEN_SYMBOL_SMALLER_OR_EQUAL, ),
+        .begin = LEXER_TOKEN_ORDER7,
+        .end = LEXER_TOKEN_ORDER8,
     },
     {
         .ltr = true,
-        ORDER_ARRAY(LEXER_TOKEN_SYMBOL_COLON, ),
+        .begin = LEXER_TOKEN_ORDER8,
+        .end = LEXER_TOKEN_ORDER9,
     },
     {
         .ltr = false,
-        ORDER_ARRAY(LEXER_TOKEN_SYMBOL_ASSIGN, LEXER_TOKEN_SYMBOL_SUM_ASSIGN,
-                    LEXER_TOKEN_SYMBOL_SUB_ASSIGN,
-                    LEXER_TOKEN_SYMBOL_MULTIPLY_ASSIGN,
-                    LEXER_TOKEN_SYMBOL_DIVIDE_ASSIGN,
-                    LEXER_TOKEN_SYMBOL_MODULO_ASSIGN, ),
+        .begin = LEXER_TOKEN_ORDER9,
+        .end = LEXER_TOKEN_ORDER10,
     },
     {
         .ltr = false,
-        ORDER_ARRAY(LEXER_TOKEN_KEYWORD_RETURN, LEXER_TOKEN_KEYWORD_PUTC,
-                    LEXER_TOKEN_KEYWORD_COMPTIME, ),
+        .begin = LEXER_TOKEN_ORDER10,
+        .end = LEXER_TOKEN_ORDER11,
     },
     {
         .ltr = true,
-        ORDER_ARRAY(LEXER_TOKEN_SYMBOL_EOL, LEXER_TOKEN_SYMBOL_COMMA, ),
+        .begin = LEXER_TOKEN_ORDER11,
+        .end = LEXER_TOKEN_ORDER12,
     },
     {
         .ltr = false,
-        ORDER_ARRAY(LEXER_TOKEN_KEYWORD_IF, LEXER_TOKEN_KEYWORD_WHILE, ),
+        .begin = LEXER_TOKEN_ORDER12,
+        .end = LEXER_TOKEN_END_ORDERS,
     },
 };
 
@@ -640,19 +623,12 @@ bool parserNodeArray(LexerNode *begin, LexerNode *end, ParserNode *parent) {
 
     for (LexerNode *iter = orders.ltr ? begin : end - 1;
          iter < end && iter >= begin; orders.ltr ? ++iter : --iter) {
-
-      if (iter->parserNode != NULL) {
-        continue;
-      }
-
-      for (size_t order_index = 0; order_index < orders.size; ++order_index) {
-        const LexerToken order = orders.data[order_index];
-        if (iter->token == order) {
-          bool conti = false;
-          ParserNode *parserNode = parseNode(iter, begin, end, parent, &conti);
-          if (parserNode == NULL && !conti) {
-            goto RETURN_ERROR;
-          }
+      if (iter->parserNode == NULL && orders.begin <= iter->token &&
+          iter->token < orders.end) {
+        bool conti = false;
+        ParserNode *parserNode = parseNode(iter, begin, end, parent, &conti);
+        if (parserNode == NULL && !conti) {
+          goto RETURN_ERROR;
         }
       }
     }
diff --git a/src/compiler/parser.h b/src/compiler/parser.h
index e55ee22..91147ea 100644
--- a/src/compiler/parser.h
+++ b/src/compiler/parser.h
@@ -86,8 +86,8 @@ extern const char *PARSER_TOKEN_STRINGS[];
 
 typedef struct ParserOrder {
   bool ltr;
-  size_t size;
-  LexerToken data[23];
+  LexerToken begin;
+  LexerToken end;
 } ParserOrder;
 
 typedef struct ParserNode {
diff --git a/src/main.c b/src/main.c
index d693f88..6694521 100644
--- a/src/main.c
+++ b/src/main.c
@@ -6,7 +6,7 @@
 #include <time.h>
 
 // #define PRINT_COMPILE_TREE
-// #define PRINT_STATISTICS
+#define PRINT_STATISTICS
 
 #ifdef PRINT_STATISTICS
 static struct timespec diff(struct timespec end, struct timespec start) {
@@ -30,19 +30,20 @@ static struct timespec add(struct timespec left, struct timespec right) {
 }
 
 static void printTime(struct timespec time) {
-  printf("%02ld:%02ld.%09ldns", time.tv_sec / 60, time.tv_sec % 60, time.tv_nsec);
+  printf("%02ld:%02ld.%09ldns", time.tv_sec / 60, time.tv_sec % 60,
+         time.tv_nsec);
 }
 #endif
 
 static int runWithoutRead(char *code) {
 #ifdef PRINT_STATISTICS
   struct timespec start, end;
-  clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &start);
   struct timespec lexTime;
   struct timespec parseTime;
   struct timespec astTime;
   struct timespec runTime;
   struct timespec totalTime = {0};
+  clock_gettime(CLOCK_PROCESS_CPUTIME_ID, &start);
 #endif
   LexerNodeArray lexed = lexer(code);
   if (lexerNodeArrayIsError(lexed)) {
@@ -108,7 +109,7 @@ static int runWithoutRead(char *code) {
 #endif
 
 #ifdef PRINT_STATISTICS
-  printf("\nlexTime:   ");
+  printf("----\nlexTime:   ");
   printTime(lexTime);
   printf("\nparseTime: ");
   printTime(parseTime);