add bool

6 files changed, 122 insertions, 15 deletions

diff --git a/src/compiler/ast-tree.c b/src/compiler/ast-tree.c
index ee0fe3a..1fd6dd1 100644
--- a/src/compiler/ast-tree.c
+++ b/src/compiler/ast-tree.c
@@ -25,6 +25,12 @@ AstTree AST_TREE_U64_TYPE = {
     .type = &AST_TREE_TYPE_TYPE,
 };
 
+AstTree AST_TREE_BOOL_TYPE = {
+    .token = AST_TREE_TOKEN_TYPE_BOOL,
+    .metadata = NULL,
+    .type = &AST_TREE_TYPE_TYPE,
+};
+
 AstTree AST_TREE_VOID_VALUE = {
     .token = AST_TREE_TOKEN_NONE,
     .metadata = NULL,
@@ -97,6 +103,7 @@ void astTreePrint(const AstTree *tree, int indent) {
   case AST_TREE_TOKEN_TYPE_TYPE:
   case AST_TREE_TOKEN_TYPE_VOID:
   case AST_TREE_TOKEN_TYPE_U64:
+  case AST_TREE_TOKEN_TYPE_BOOL:
   case AST_TREE_TOKEN_VARIABLE_DEFINE:
     goto RETURN_SUCCESS;
   case AST_TREE_TOKEN_KEYWORD_PRINT_U64: {
@@ -119,12 +126,16 @@ void astTreePrint(const AstTree *tree, int indent) {
     }
   }
     goto RETURN_SUCCESS;
-
   case AST_TREE_TOKEN_VALUE_U64: {
     AstTreeU64 metadata = (AstTreeU64)tree->metadata;
     printf(",value=%lu", metadata);
   }
     goto RETURN_SUCCESS;
+  case AST_TREE_TOKEN_VALUE_BOOL: {
+    AstTreeBool metadata = (AstTreeBool)tree->metadata;
+    printf(",value=%b", metadata);
+  }
+    goto RETURN_SUCCESS;
   case AST_TREE_TOKEN_TYPE_FUNCTION: {
     AstTreeTypeFunction *metadata = tree->metadata;
     printf(",\n");
@@ -230,7 +241,9 @@ void astTreeDestroy(AstTree tree) {
   case AST_TREE_TOKEN_TYPE_TYPE:
   case AST_TREE_TOKEN_TYPE_VOID:
   case AST_TREE_TOKEN_TYPE_U64:
+  case AST_TREE_TOKEN_TYPE_BOOL:
   case AST_TREE_TOKEN_VALUE_U64:
+  case AST_TREE_TOKEN_VALUE_BOOL:
   case AST_TREE_TOKEN_VARIABLE_DEFINE:
     return;
   case AST_TREE_TOKEN_KEYWORD_PRINT_U64: {
@@ -332,9 +345,14 @@ AstTree *copyAstTree(AstTree *tree) {
     return &AST_TREE_VOID_TYPE;
   case AST_TREE_TOKEN_TYPE_U64:
     return &AST_TREE_U64_TYPE;
+  case AST_TREE_TOKEN_TYPE_BOOL:
+    return &AST_TREE_BOOL_TYPE;
   case AST_TREE_TOKEN_VALUE_U64:
     return newAstTree(tree->token, (void *)(AstTreeU64)tree->metadata,
                       &AST_TREE_U64_TYPE);
+  case AST_TREE_TOKEN_VALUE_BOOL:
+    return newAstTree(tree->token, (void *)(AstTreeBool)tree->metadata,
+                      &AST_TREE_BOOL_TYPE);
   case AST_TREE_TOKEN_VARIABLE:
     return newAstTree(tree->token, tree->metadata, copyAstTree(tree->type));
   case AST_TREE_TOKEN_TYPE_FUNCTION: {
@@ -420,6 +438,7 @@ AstTreeRoot *makeAstTree(ParserNode *parsedRoot) {
     }
 
     switch (node_metadata->value->token) {
+    case PARSER_TOKEN_VALUE_BOOL:
     case PARSER_TOKEN_VALUE_U64:
     case PARSER_TOKEN_FUNCTION_DEFINITION:
       goto AFTER_SWITCH;
@@ -429,6 +448,7 @@ AstTreeRoot *makeAstTree(ParserNode *parsedRoot) {
     case PARSER_TOKEN_TYPE_FUNCTION:
     case PARSER_TOKEN_TYPE_VOID:
     case PARSER_TOKEN_TYPE_U64:
+    case PARSER_TOKEN_TYPE_BOOL:
     case PARSER_TOKEN_KEYWORD_PRINT_U64:
     case PARSER_TOKEN_KEYWORD_RETURN:
     case PARSER_TOKEN_CONSTANT:
@@ -538,6 +558,8 @@ AstTree *astTreeParse(ParserNode *parserNode, AstTreeVariables **variables,
     return &AST_TREE_VOID_TYPE;
   case PARSER_TOKEN_TYPE_U64:
     return &AST_TREE_U64_TYPE;
+  case PARSER_TOKEN_TYPE_BOOL:
+    return &AST_TREE_BOOL_TYPE;
   case PARSER_TOKEN_FUNCTION_CALL:
     return astTreeParseFunctionCall(parserNode, variables, variables_size);
   case PARSER_TOKEN_IDENTIFIER:
@@ -547,6 +569,11 @@ AstTree *astTreeParse(ParserNode *parserNode, AstTreeVariables **variables,
         AST_TREE_TOKEN_VALUE_U64,
         (void *)(AstTreeU64)(ParserNodeU64Metadata)parserNode->metadata,
         &AST_TREE_U64_TYPE);
+  case PARSER_TOKEN_VALUE_BOOL:
+    return newAstTree(
+        AST_TREE_TOKEN_VALUE_BOOL,
+        (void *)(AstTreeBool)(ParserNodeBoolMetadata)parserNode->metadata,
+        &AST_TREE_BOOL_TYPE);
   case PARSER_TOKEN_KEYWORD_PRINT_U64:
     return astTreeParsePrintU64(parserNode, variables, variables_size);
   case PARSER_TOKEN_KEYWORD_RETURN:
@@ -759,8 +786,7 @@ AstTree *astTreeParseFunctionCall(ParserNode *parserNode,
     if (param->token == PARSER_TOKEN_SYMBOL_COMMA) {
       param = (ParserNodeSingleChildMetadata *)param->metadata;
     }
-    metadata->parameters[i] =
-        astTreeParse(param, variables, variables_size);
+    metadata->parameters[i] = astTreeParse(param, variables, variables_size);
   }
 
   return newAstTree(AST_TREE_TOKEN_FUNCTION_CALL, metadata, NULL);
@@ -974,7 +1000,9 @@ AstTreeFunction *getFunction(AstTree *value) {
   case AST_TREE_TOKEN_TYPE_FUNCTION:
   case AST_TREE_TOKEN_TYPE_VOID:
   case AST_TREE_TOKEN_TYPE_U64:
+  case AST_TREE_TOKEN_TYPE_BOOL:
   case AST_TREE_TOKEN_VALUE_U64:
+  case AST_TREE_TOKEN_VALUE_BOOL:
   case AST_TREE_TOKEN_VARIABLE_DEFINE:
   case AST_TREE_TOKEN_OPERATOR_ASSIGN:
   case AST_TREE_TOKEN_OPERATOR_SUM:
@@ -992,7 +1020,9 @@ bool isConst(AstTree *value) {
   case AST_TREE_TOKEN_TYPE_FUNCTION:
   case AST_TREE_TOKEN_TYPE_VOID:
   case AST_TREE_TOKEN_TYPE_U64:
+  case AST_TREE_TOKEN_TYPE_BOOL:
   case AST_TREE_TOKEN_VALUE_U64:
+  case AST_TREE_TOKEN_VALUE_BOOL:
     return true;
   case AST_TREE_TOKEN_KEYWORD_PRINT_U64:
   case AST_TREE_TOKEN_KEYWORD_RETURN:
@@ -1017,6 +1047,7 @@ AstTree *makeTypeOf(AstTree *value) {
   case AST_TREE_TOKEN_TYPE_FUNCTION:
   case AST_TREE_TOKEN_TYPE_VOID:
   case AST_TREE_TOKEN_TYPE_U64:
+  case AST_TREE_TOKEN_TYPE_BOOL:
     return &AST_TREE_TYPE_TYPE;
   case AST_TREE_TOKEN_FUNCTION_CALL: {
     AstTreeFunctionCall *metadata = value->metadata;
@@ -1042,6 +1073,8 @@ AstTree *makeTypeOf(AstTree *value) {
   }
   case AST_TREE_TOKEN_VALUE_U64:
     return &AST_TREE_U64_TYPE;
+  case AST_TREE_TOKEN_VALUE_BOOL:
+    return &AST_TREE_BOOL_TYPE;
   case AST_TREE_TOKEN_VARIABLE: {
     AstTreeVariable *variable = value->metadata;
     return copyAstTree(variable->type);
@@ -1066,6 +1099,7 @@ bool typeIsEqual(const AstTree *type0, const AstTree *type1) {
   case AST_TREE_TOKEN_KEYWORD_PRINT_U64:
   case AST_TREE_TOKEN_KEYWORD_RETURN:
   case AST_TREE_TOKEN_VALUE_U64:
+  case AST_TREE_TOKEN_VALUE_BOOL:
   case AST_TREE_TOKEN_VARIABLE_DEFINE:
   case AST_TREE_TOKEN_OPERATOR_ASSIGN:
   case AST_TREE_TOKEN_OPERATOR_SUM:
@@ -1073,6 +1107,7 @@ bool typeIsEqual(const AstTree *type0, const AstTree *type1) {
   case AST_TREE_TOKEN_TYPE_TYPE:
   case AST_TREE_TOKEN_TYPE_VOID:
   case AST_TREE_TOKEN_TYPE_U64:
+  case AST_TREE_TOKEN_TYPE_BOOL:
     return type1->token == type0->token;
   case AST_TREE_TOKEN_TYPE_FUNCTION:
     if (type1->token != AST_TREE_TOKEN_TYPE_FUNCTION) {
@@ -1125,7 +1160,9 @@ bool setAllTypes(AstTree *tree, AstTreeFunction *function) {
   case AST_TREE_TOKEN_TYPE_TYPE:
   case AST_TREE_TOKEN_TYPE_VOID:
   case AST_TREE_TOKEN_TYPE_U64:
+  case AST_TREE_TOKEN_TYPE_BOOL:
   case AST_TREE_TOKEN_VALUE_U64:
+  case AST_TREE_TOKEN_VALUE_BOOL:
   case AST_TREE_TOKEN_VARIABLE_DEFINE:
     return true;
   case AST_TREE_TOKEN_FUNCTION:
@@ -1339,8 +1376,10 @@ bool astTreeClean(AstTree *tree) {
   case AST_TREE_TOKEN_TYPE_FUNCTION:
   case AST_TREE_TOKEN_TYPE_VOID:
   case AST_TREE_TOKEN_TYPE_U64:
+  case AST_TREE_TOKEN_TYPE_BOOL:
   case AST_TREE_TOKEN_FUNCTION_CALL:
   case AST_TREE_TOKEN_VALUE_U64:
+  case AST_TREE_TOKEN_VALUE_BOOL:
   case AST_TREE_TOKEN_VARIABLE_DEFINE:
   case AST_TREE_TOKEN_OPERATOR_ASSIGN:
   case AST_TREE_TOKEN_OPERATOR_SUM:
@@ -1416,6 +1455,8 @@ size_t astTreeTypeSize(AstTree tree) {
   switch (tree.token) {
   case AST_TREE_TOKEN_TYPE_U64:
     return 8;
+  case AST_TREE_TOKEN_TYPE_BOOL:
+    return 1;
   case AST_TREE_TOKEN_FUNCTION:
   case AST_TREE_TOKEN_KEYWORD_PRINT_U64:
   case AST_TREE_TOKEN_KEYWORD_RETURN:
@@ -1426,6 +1467,7 @@ size_t astTreeTypeSize(AstTree tree) {
   case AST_TREE_TOKEN_VARIABLE:
   case AST_TREE_TOKEN_VARIABLE_DEFINE:
   case AST_TREE_TOKEN_VALUE_U64:
+  case AST_TREE_TOKEN_VALUE_BOOL:
   case AST_TREE_TOKEN_OPERATOR_ASSIGN:
   case AST_TREE_TOKEN_OPERATOR_SUM:
   case AST_TREE_TOKEN_NONE:
diff --git a/src/compiler/ast-tree.h b/src/compiler/ast-tree.h
index 64068d3..9dd2a6a 100644
--- a/src/compiler/ast-tree.h
+++ b/src/compiler/ast-tree.h
@@ -14,11 +14,13 @@ typedef enum AstTreeToken {
   AST_TREE_TOKEN_TYPE_FUNCTION,
   AST_TREE_TOKEN_TYPE_VOID,
   AST_TREE_TOKEN_TYPE_U64,
+  AST_TREE_TOKEN_TYPE_BOOL,
 
   AST_TREE_TOKEN_FUNCTION_CALL,
   AST_TREE_TOKEN_VARIABLE,
   AST_TREE_TOKEN_VARIABLE_DEFINE,
   AST_TREE_TOKEN_VALUE_U64,
+  AST_TREE_TOKEN_VALUE_BOOL,
 
   AST_TREE_TOKEN_OPERATOR_ASSIGN,
   AST_TREE_TOKEN_OPERATOR_SUM,
@@ -82,6 +84,8 @@ typedef struct AstTreeFunctionCall {
 
 typedef uint64_t AstTreeU64;
 
+typedef bool AstTreeBool;
+
 typedef AstTree AstTreeSingleChild;
 
 typedef struct AstTreeInfix {
diff --git a/src/compiler/lexer.c b/src/compiler/lexer.c
index f4718fa..67db9c7 100644
--- a/src/compiler/lexer.c
+++ b/src/compiler/lexer.c
@@ -14,8 +14,11 @@ const char *LEXER_TOKEN_STRINGS[] = {
     "LEXER_TOKEN_KEYWORD_TYPE",
     "LEXER_TOKEN_KEYWORD_VOID",
     "LEXER_TOKEN_KEYWORD_U64",
+    "LEXER_TOKEN_KEYWORD_BOOL",
     "LEXER_TOKEN_KEYWORD_PRINT_U64",
     "LEXER_TOKEN_KEYWORD_RETURN",
+    "LEXER_TOKEN_KEYWORD_TRUE",
+    "LEXER_TOKEN_KEYWORD_FALSE",
 
     "LEXER_TOKEN_NUMBER",
 
@@ -53,12 +56,13 @@ const size_t LEXER_SYMBOL_SIZE =
     sizeof(LEXER_SYMBOL_TOKENS) / sizeof(*LEXER_SYMBOL_TOKENS);
 
 const char *LEXER_KEYWORD_STRINGS[] = {
-    "type", "void", "u64", "print_u64", "return",
+    "type", "void", "u64", "bool", "print_u64", "return", "true", "false",
 };
 const LexerToken LEXER_KEYWORD_TOKENS[] = {
-    LEXER_TOKEN_KEYWORD_TYPE,   LEXER_TOKEN_KEYWORD_VOID,
-    LEXER_TOKEN_KEYWORD_U64,    LEXER_TOKEN_KEYWORD_PRINT_U64,
-    LEXER_TOKEN_KEYWORD_RETURN,
+    LEXER_TOKEN_KEYWORD_TYPE,      LEXER_TOKEN_KEYWORD_VOID,
+    LEXER_TOKEN_KEYWORD_U64,       LEXER_TOKEN_KEYWORD_BOOL,
+    LEXER_TOKEN_KEYWORD_PRINT_U64, LEXER_TOKEN_KEYWORD_RETURN,
+    LEXER_TOKEN_KEYWORD_TRUE,      LEXER_TOKEN_KEYWORD_FALSE,
 };
 const size_t LEXER_KEYWORD_SIZE =
     sizeof(LEXER_KEYWORD_TOKENS) / sizeof(*LEXER_KEYWORD_TOKENS);
@@ -139,7 +143,7 @@ LexerNodeArray lexer(char *str) {
     } else {
     RETURN_ERROR:
       free(result.data);
-      printError("Unexpected character '%c'", iter, iter+1, c);
+      printError("Unexpected character '%c'", iter, iter + 1, c);
       return LEXER_NODE_ARRAY_ERROR;
     }
   }
@@ -178,8 +182,11 @@ void lexerPushClear(LexerNodeArray *array, size_t *array_size, char *iter,
   case LEXER_TOKEN_KEYWORD_TYPE:
   case LEXER_TOKEN_KEYWORD_VOID:
   case LEXER_TOKEN_KEYWORD_U64:
+  case LEXER_TOKEN_KEYWORD_BOOL:
   case LEXER_TOKEN_KEYWORD_PRINT_U64:
   case LEXER_TOKEN_KEYWORD_RETURN:
+  case LEXER_TOKEN_KEYWORD_TRUE:
+  case LEXER_TOKEN_KEYWORD_FALSE:
   case LEXER_TOKEN_NUMBER:
   case LEXER_TOKEN_SYMBOL_EOL:
   case LEXER_TOKEN_SYMBOL_OPEN_PARENTHESIS:
diff --git a/src/compiler/lexer.h b/src/compiler/lexer.h
index 81d6fd5..6c0660f 100644
--- a/src/compiler/lexer.h
+++ b/src/compiler/lexer.h
@@ -8,8 +8,11 @@ typedef enum LexerToken {
   LEXER_TOKEN_KEYWORD_TYPE,
   LEXER_TOKEN_KEYWORD_VOID,
   LEXER_TOKEN_KEYWORD_U64,
+  LEXER_TOKEN_KEYWORD_BOOL,
   LEXER_TOKEN_KEYWORD_PRINT_U64,
   LEXER_TOKEN_KEYWORD_RETURN,
+  LEXER_TOKEN_KEYWORD_TRUE,
+  LEXER_TOKEN_KEYWORD_FALSE,
 
   LEXER_TOKEN_NUMBER,
 
diff --git a/src/compiler/parser.c b/src/compiler/parser.c
index dce8731..d8ace78 100644
--- a/src/compiler/parser.c
+++ b/src/compiler/parser.c
@@ -15,11 +15,13 @@ const char *PARSER_TOKEN_STRINGS[] = {
     "PARSER_TOKEN_IDENTIFIER",
 
     "PARSER_TOKEN_VALUE_U64",
+    "PARSER_TOKEN_VALUE_BOOL",
 
     "PARSER_TOKEN_TYPE_TYPE",
     "PARSER_TOKEN_TYPE_FUNCTION",
     "PARSER_TOKEN_TYPE_VOID",
     "PARSER_TOKEN_TYPE_U64",
+    "PARSER_TOKEN_TYPE_BOOL",
 
     "PARSER_TOKEN_KEYWORD_PRINT_U64",
     "PARSER_TOKEN_KEYWORD_RETURN",
@@ -56,7 +58,8 @@ static constexpr ParserOrder PARSER_ORDER[] = {
         ORDER_ARRAY(LEXER_TOKEN_SYMBOL_CLOSE_PARENTHESIS,
                     LEXER_TOKEN_IDENTIFIER, LEXER_TOKEN_KEYWORD_TYPE,
                     LEXER_TOKEN_KEYWORD_VOID, LEXER_TOKEN_KEYWORD_U64,
-                    LEXER_TOKEN_NUMBER, ),
+                    LEXER_TOKEN_KEYWORD_BOOL, LEXER_TOKEN_KEYWORD_TRUE,
+                    LEXER_TOKEN_KEYWORD_FALSE, LEXER_TOKEN_NUMBER, ),
     },
     {
         .ltr = false,
@@ -118,12 +121,18 @@ void parserNodePrint(const ParserNode *node, int indent) {
   case PARSER_TOKEN_TYPE_TYPE:
   case PARSER_TOKEN_TYPE_VOID:
   case PARSER_TOKEN_TYPE_U64:
+  case PARSER_TOKEN_TYPE_BOOL:
     goto RETURN_SUCCESS;
   case PARSER_TOKEN_VALUE_U64: {
     ParserNodeU64Metadata metadata = (ParserNodeU64Metadata)node->metadata;
     printf(",operand=%lu", metadata);
   }
     goto RETURN_SUCCESS;
+  case PARSER_TOKEN_VALUE_BOOL: {
+    ParserNodeU64Metadata metadata = (ParserNodeU64Metadata)node->metadata;
+    printf(",value=%b", (ParserNodeBoolMetadata)metadata);
+  }
+    goto RETURN_SUCCESS;
   case PARSER_TOKEN_CONSTANT:
   case PARSER_TOKEN_VARIABLE: {
     const ParserNodeVariableMetadata *metadata = node->metadata;
@@ -278,7 +287,9 @@ void parserNodeDelete(ParserNode *node) {
   case PARSER_TOKEN_TYPE_TYPE:
   case PARSER_TOKEN_TYPE_VOID:
   case PARSER_TOKEN_TYPE_U64:
+  case PARSER_TOKEN_TYPE_BOOL:
   case PARSER_TOKEN_VALUE_U64:
+  case PARSER_TOKEN_VALUE_BOOL:
     goto RETURN_SUCCESS;
   case PARSER_TOKEN_CONSTANT:
   case PARSER_TOKEN_VARIABLE: {
@@ -448,10 +459,15 @@ ParserNode *parseNode(LexerNode *node, LexerNode *begin, LexerNode *end,
     return parserVoid(node, parent);
   case LEXER_TOKEN_KEYWORD_U64:
     return parserU64(node, parent);
+  case LEXER_TOKEN_KEYWORD_BOOL:
+    return parserBool(node, parent);
   case LEXER_TOKEN_KEYWORD_PRINT_U64:
     return parserPrintU64(node, end, parent);
   case LEXER_TOKEN_KEYWORD_RETURN:
     return parserReturn(node, end, parent);
+  case LEXER_TOKEN_KEYWORD_TRUE:
+  case LEXER_TOKEN_KEYWORD_FALSE:
+    return parserBoolValue(node, parent);
   case LEXER_TOKEN_SYMBOL_EOL:
     return parserEol(node, begin, parent);
   case LEXER_TOKEN_SYMBOL_CLOSE_PARENTHESIS:
@@ -509,6 +525,12 @@ ParserNode *parserU64(LexerNode *node, ParserNode *parent) {
                            node->str_end, NULL, parent);
 }
 
+ParserNode *parserBool(LexerNode *node, ParserNode *parent) {
+  return node->parserNode =
+             newParserNode(PARSER_TOKEN_TYPE_BOOL, node->str_begin,
+                           node->str_end, NULL, parent);
+}
+
 ParserNode *parserPrintU64(LexerNode *node, LexerNode *end,
                            ParserNode *parent) {
   LexerNode *afterNode = node + 1;
@@ -579,6 +601,14 @@ ParserNode *parserNumber(LexerNode *node, ParserNode *parent) {
   return node->parserNode = parserNode;
 }
 
+ParserNode *parserBoolValue(LexerNode *node, ParserNode *parent) {
+  return node->parserNode = newParserNode(
+             PARSER_TOKEN_VALUE_BOOL, node->str_begin, node->str_end,
+             (void *)(ParserNodeBoolMetadata)(node->token ==
+                                              LEXER_TOKEN_KEYWORD_TRUE),
+             parent);
+}
+
 ParserNode *parserEol(LexerNode *node, LexerNode *begin, ParserNode *parent) {
   LexerNode *nodeBefore = node - 1;
   ParserNode *parserNodeBefore;
@@ -697,11 +727,21 @@ ParserNode *parserParenthesis(LexerNode *closing, LexerNode *begin,
 
 ParserNode *parserCurlyBrackets(LexerNode *closing, LexerNode *begin,
                                 ParserNode *parent) {
+  ParserNode *parserNode = a404m_malloc(sizeof(*parserNode));
+  parserNode->parent = parent;
+  parserNode->token = PARSER_TOKEN_SYMBOL_CURLY_BRACKET;
+
   LexerNode *opening = NULL;
 
   for (LexerNode *iter = closing - 1; iter >= begin; --iter) {
-    if (iter->parserNode == NULL &&
-        iter->token == LEXER_TOKEN_SYMBOL_OPEN_CURLY_BRACKET) {
+    if (iter->parserNode != NULL) {
+      ParserNode *pNode = getUntilCommonParent(iter->parserNode, parent);
+      if (pNode == NULL) {
+        printLog("Bad node", pNode->str_begin, pNode->str_end);
+      } else {
+        pNode->parent = parserNode;
+      }
+    } else if (iter->token == LEXER_TOKEN_SYMBOL_OPEN_CURLY_BRACKET) {
       opening = iter;
       break;
     }
@@ -713,9 +753,8 @@ ParserNode *parserCurlyBrackets(LexerNode *closing, LexerNode *begin,
     return NULL;
   }
 
-  ParserNode *parserNode =
-      newParserNode(PARSER_TOKEN_SYMBOL_CURLY_BRACKET, opening->str_begin,
-                    closing->str_end, NULL, parent);
+  parserNode->str_begin = opening->str_begin,
+  parserNode->str_end = closing->str_end;
 
   opening->parserNode = parserNode;
   closing->parserNode = parserNode;
@@ -978,12 +1017,14 @@ bool isExpression(ParserNode *node) {
   case PARSER_TOKEN_OPERATOR_ASSIGN:
   case PARSER_TOKEN_OPERATOR_SUM:
   case PARSER_TOKEN_VALUE_U64:
+  case PARSER_TOKEN_VALUE_BOOL:
     return true;
   case PARSER_TOKEN_ROOT:
   case PARSER_TOKEN_TYPE_TYPE:
   case PARSER_TOKEN_TYPE_FUNCTION:
   case PARSER_TOKEN_TYPE_VOID:
   case PARSER_TOKEN_TYPE_U64:
+  case PARSER_TOKEN_TYPE_BOOL:
   case PARSER_TOKEN_SYMBOL_EOL:
   case PARSER_TOKEN_SYMBOL_CURLY_BRACKET:
   case PARSER_TOKEN_SYMBOL_COMMA:
@@ -999,6 +1040,7 @@ bool isType(ParserNode *node) {
   case PARSER_TOKEN_TYPE_FUNCTION:
   case PARSER_TOKEN_TYPE_VOID:
   case PARSER_TOKEN_TYPE_U64:
+  case PARSER_TOKEN_TYPE_BOOL:
     return true;
   case PARSER_TOKEN_IDENTIFIER:
   case PARSER_TOKEN_CONSTANT:
@@ -1011,6 +1053,7 @@ bool isType(ParserNode *node) {
   case PARSER_TOKEN_SYMBOL_COMMA:
   case PARSER_TOKEN_FUNCTION_CALL:
   case PARSER_TOKEN_VALUE_U64:
+  case PARSER_TOKEN_VALUE_BOOL:
   case PARSER_TOKEN_KEYWORD_PRINT_U64:
   case PARSER_TOKEN_KEYWORD_RETURN:
   case PARSER_TOKEN_OPERATOR_ASSIGN:
@@ -1026,6 +1069,7 @@ bool isValue(ParserNode *node) {
   case PARSER_TOKEN_FUNCTION_DEFINITION:
   case PARSER_TOKEN_FUNCTION_CALL:
   case PARSER_TOKEN_VALUE_U64:
+  case PARSER_TOKEN_VALUE_BOOL:
   case PARSER_TOKEN_IDENTIFIER:
   case PARSER_TOKEN_OPERATOR_ASSIGN:
   case PARSER_TOKEN_OPERATOR_SUM:
@@ -1034,6 +1078,7 @@ bool isValue(ParserNode *node) {
   case PARSER_TOKEN_TYPE_TYPE:
   case PARSER_TOKEN_TYPE_VOID:
   case PARSER_TOKEN_TYPE_U64:
+  case PARSER_TOKEN_TYPE_BOOL:
   case PARSER_TOKEN_CONSTANT:
   case PARSER_TOKEN_VARIABLE:
   case PARSER_TOKEN_SYMBOL_PARENTHESIS:
diff --git a/src/compiler/parser.h b/src/compiler/parser.h
index 004f14f..29a303c 100644
--- a/src/compiler/parser.h
+++ b/src/compiler/parser.h
@@ -10,11 +10,13 @@ typedef enum ParserToken {
   PARSER_TOKEN_IDENTIFIER,
 
   PARSER_TOKEN_VALUE_U64,
+  PARSER_TOKEN_VALUE_BOOL,
 
   PARSER_TOKEN_TYPE_TYPE,
   PARSER_TOKEN_TYPE_FUNCTION,
   PARSER_TOKEN_TYPE_VOID,
   PARSER_TOKEN_TYPE_U64,
+  PARSER_TOKEN_TYPE_BOOL,
 
   PARSER_TOKEN_KEYWORD_PRINT_U64,
   PARSER_TOKEN_KEYWORD_RETURN,
@@ -42,7 +44,7 @@ extern const char *PARSER_TOKEN_STRINGS[];
 typedef struct ParserOrder {
   bool ltr;
   size_t size;
-  LexerToken data[8];
+  LexerToken data[15];
 } ParserOrder;
 
 typedef struct ParserNode {
@@ -93,6 +95,8 @@ typedef struct ParserNodeReturnMetadata {
   ParserNode *value;
 } ParserNodeReturnMetadata;
 
+typedef bool ParserNodeBoolMetadata;
+
 void parserNodePrint(const ParserNode *node, int indent);
 void parserNodeDelete(ParserNode *node);
 
@@ -111,9 +115,11 @@ ParserNode *parserIdentifier(LexerNode *node, ParserNode *parent);
 ParserNode *parserType(LexerNode *node, ParserNode *parent);
 ParserNode *parserVoid(LexerNode *node, ParserNode *parent);
 ParserNode *parserU64(LexerNode *node, ParserNode *parent);
+ParserNode *parserBool(LexerNode *node, ParserNode *parent);
 ParserNode *parserPrintU64(LexerNode *node, LexerNode *end, ParserNode *parent);
 ParserNode *parserReturn(LexerNode *node, LexerNode *end, ParserNode *parent);
 ParserNode *parserNumber(LexerNode *node, ParserNode *parent);
+ParserNode *parserBoolValue(LexerNode *node, ParserNode *parent);
 ParserNode *parserEol(LexerNode *node, LexerNode *begin, ParserNode *parent);
 ParserNode *parserComma(LexerNode *node, LexerNode *begin, ParserNode *parent);
 ParserNode *parserParenthesis(LexerNode *closing, LexerNode *begin,