replaced putc with @putc()

7 files changed, 115 insertions, 140 deletions

diff --git a/src/compiler/ast-tree.c b/src/compiler/ast-tree.c
index 999e9eb..7ad3a8e 100644
--- a/src/compiler/ast-tree.c
+++ b/src/compiler/ast-tree.c
@@ -185,8 +185,8 @@ const char *AST_TREE_TOKEN_STRINGS[] = {
     "AST_TREE_TOKEN_BUILTIN_SMALLER",
     "AST_TREE_TOKEN_BUILTIN_GREATER_OR_EQUAL",
     "AST_TREE_TOKEN_BUILTIN_SMALLER_OR_EQUAL",
+    "AST_TREE_TOKEN_BUILTIN_PUTC",
 
-    "AST_TREE_TOKEN_KEYWORD_PUTC",
     "AST_TREE_TOKEN_KEYWORD_RETURN",
     "AST_TREE_TOKEN_KEYWORD_BREAK",
     "AST_TREE_TOKEN_KEYWORD_CONTINUE",
@@ -327,6 +327,7 @@ void astTreePrint(const AstTree *tree, int indent) {
   case AST_TREE_TOKEN_BUILTIN_SMALLER:
   case AST_TREE_TOKEN_BUILTIN_GREATER_OR_EQUAL:
   case AST_TREE_TOKEN_BUILTIN_SMALLER_OR_EQUAL:
+  case AST_TREE_TOKEN_BUILTIN_PUTC:
   case AST_TREE_TOKEN_TYPE_TYPE:
   case AST_TREE_TOKEN_TYPE_VOID:
   case AST_TREE_TOKEN_TYPE_I8:
@@ -374,7 +375,6 @@ void astTreePrint(const AstTree *tree, int indent) {
   case AST_TREE_TOKEN_OPERATOR_POINTER:
   case AST_TREE_TOKEN_OPERATOR_ADDRESS:
   case AST_TREE_TOKEN_OPERATOR_DEREFERENCE:
-  case AST_TREE_TOKEN_KEYWORD_PUTC:
   case AST_TREE_TOKEN_KEYWORD_COMPTIME: {
     AstTreeSingleChild *metadata = tree->metadata;
     printf(",\n");
@@ -753,6 +753,7 @@ void astTreeDestroy(AstTree tree) {
   case AST_TREE_TOKEN_BUILTIN_SMALLER:
   case AST_TREE_TOKEN_BUILTIN_GREATER_OR_EQUAL:
   case AST_TREE_TOKEN_BUILTIN_SMALLER_OR_EQUAL:
+  case AST_TREE_TOKEN_BUILTIN_PUTC:
   case AST_TREE_TOKEN_TYPE_TYPE:
   case AST_TREE_TOKEN_TYPE_VOID:
   case AST_TREE_TOKEN_TYPE_I8:
@@ -838,7 +839,6 @@ void astTreeDestroy(AstTree tree) {
   case AST_TREE_TOKEN_OPERATOR_POINTER:
   case AST_TREE_TOKEN_OPERATOR_ADDRESS:
   case AST_TREE_TOKEN_OPERATOR_DEREFERENCE:
-  case AST_TREE_TOKEN_KEYWORD_PUTC:
   case AST_TREE_TOKEN_KEYWORD_COMPTIME: {
     AstTreeSingleChild *metadata = tree.metadata;
     astTreeDelete(metadata);
@@ -1100,6 +1100,7 @@ AstTree *copyAstTreeBack(AstTree *tree, AstTreeVariables oldVariables[],
   case AST_TREE_TOKEN_BUILTIN_SMALLER:
   case AST_TREE_TOKEN_BUILTIN_GREATER_OR_EQUAL:
   case AST_TREE_TOKEN_BUILTIN_SMALLER_OR_EQUAL:
+  case AST_TREE_TOKEN_BUILTIN_PUTC:
     return newAstTree(tree->token, NULL,
                       copyAstTreeBack(tree->type, oldVariables, newVariables,
                                       variables_size, safetyCheck),
@@ -1322,7 +1323,6 @@ AstTree *copyAstTreeBack(AstTree *tree, AstTreeVariables oldVariables[],
   case AST_TREE_TOKEN_OPERATOR_POINTER:
   case AST_TREE_TOKEN_OPERATOR_ADDRESS:
   case AST_TREE_TOKEN_OPERATOR_DEREFERENCE:
-  case AST_TREE_TOKEN_KEYWORD_PUTC:
   case AST_TREE_TOKEN_KEYWORD_COMPTIME: {
     AstTreeSingleChild *metadata = tree->metadata;
     AstTreeSingleChild *new_metadata = copyAstTreeBack(
@@ -2050,11 +2050,11 @@ AstTreeRoot *makeAstRoot(const ParserNode *parsedRoot, char *filePath) {
       case PARSER_TOKEN_BUILTIN_SMALLER:
       case PARSER_TOKEN_BUILTIN_GREATER_OR_EQUAL:
       case PARSER_TOKEN_BUILTIN_SMALLER_OR_EQUAL:
+      case PARSER_TOKEN_BUILTIN_PUTC:
       case PARSER_TOKEN_SYMBOL_BRACKET_LEFT:
       case PARSER_TOKEN_SYMBOL_BRACKET_RIGHT:
         goto AFTER_SWITCH;
       case PARSER_TOKEN_ROOT:
-      case PARSER_TOKEN_KEYWORD_PUTC:
       case PARSER_TOKEN_KEYWORD_RETURN:
       case PARSER_TOKEN_KEYWORD_BREAK:
       case PARSER_TOKEN_KEYWORD_CONTINUE:
@@ -2172,6 +2172,8 @@ AstTree *astTreeParse(const ParserNode *parserNode) {
   case PARSER_TOKEN_BUILTIN_SMALLER_OR_EQUAL:
     return astTreeParseKeyword(parserNode,
                                AST_TREE_TOKEN_BUILTIN_SMALLER_OR_EQUAL);
+  case PARSER_TOKEN_BUILTIN_PUTC:
+    return astTreeParseKeyword(parserNode, AST_TREE_TOKEN_BUILTIN_PUTC);
   case PARSER_TOKEN_TYPE_TYPE:
     return &AST_TREE_TYPE_TYPE;
   case PARSER_TOKEN_TYPE_FUNCTION:
@@ -2238,8 +2240,6 @@ AstTree *astTreeParse(const ParserNode *parserNode) {
     return astTreeParseLoopControl(parserNode, AST_TREE_TOKEN_KEYWORD_BREAK);
   case PARSER_TOKEN_KEYWORD_CONTINUE:
     return astTreeParseLoopControl(parserNode, AST_TREE_TOKEN_KEYWORD_CONTINUE);
-  case PARSER_TOKEN_KEYWORD_PUTC:
-    return astTreeParsePutc(parserNode);
   case PARSER_TOKEN_KEYWORD_RETURN:
     return astTreeParseReturn(parserNode);
   case PARSER_TOKEN_OPERATOR_ASSIGN:
@@ -2440,7 +2440,6 @@ AstTree *astTreeParseFunction(const ParserNode *parserNode) {
     case PARSER_TOKEN_TYPE_NAMESPACE:
     case PARSER_TOKEN_TYPE_SHAPE_SHIFTER:
     case PARSER_TOKEN_TYPE_BOOL:
-    case PARSER_TOKEN_KEYWORD_PUTC:
     case PARSER_TOKEN_KEYWORD_RETURN:
     case PARSER_TOKEN_KEYWORD_BREAK:
     case PARSER_TOKEN_KEYWORD_CONTINUE:
@@ -2499,6 +2498,7 @@ AstTree *astTreeParseFunction(const ParserNode *parserNode) {
     case PARSER_TOKEN_BUILTIN_SMALLER:
     case PARSER_TOKEN_BUILTIN_GREATER_OR_EQUAL:
     case PARSER_TOKEN_BUILTIN_SMALLER_OR_EQUAL:
+    case PARSER_TOKEN_BUILTIN_PUTC:
     case PARSER_TOKEN_SYMBOL_BRACKET_LEFT:
     case PARSER_TOKEN_SYMBOL_BRACKET_RIGHT:
       printError(node->str_begin, node->str_end, "Unexpected %s",
@@ -2742,18 +2742,6 @@ AstTree *astTreeParseLoopControl(const ParserNode *parserNode,
                     parserNode->str_end);
 }
 
-AstTree *astTreeParsePutc(const ParserNode *parserNode) {
-  ParserNodeSingleChildMetadata *node_metadata = parserNode->metadata;
-
-  AstTree *operand = astTreeParse(node_metadata);
-  if (operand == NULL) {
-    return NULL;
-  }
-
-  return newAstTree(AST_TREE_TOKEN_KEYWORD_PUTC, (AstTreeSingleChild *)operand,
-                    NULL, parserNode->str_begin, parserNode->str_end);
-}
-
 AstTree *astTreeParseReturn(const ParserNode *parserNode) {
   ParserNodeReturnMetadata *node_metadata = parserNode->metadata;
 
@@ -3067,7 +3055,6 @@ AstTree *astTreeParseCurlyBracket(const ParserNode *parserNode) {
     case PARSER_TOKEN_TYPE_NAMESPACE:
     case PARSER_TOKEN_TYPE_SHAPE_SHIFTER:
     case PARSER_TOKEN_TYPE_BOOL:
-    case PARSER_TOKEN_KEYWORD_PUTC:
     case PARSER_TOKEN_KEYWORD_RETURN:
     case PARSER_TOKEN_KEYWORD_BREAK:
     case PARSER_TOKEN_KEYWORD_CONTINUE:
@@ -3126,6 +3113,7 @@ AstTree *astTreeParseCurlyBracket(const ParserNode *parserNode) {
     case PARSER_TOKEN_BUILTIN_SMALLER:
     case PARSER_TOKEN_BUILTIN_GREATER_OR_EQUAL:
     case PARSER_TOKEN_BUILTIN_SMALLER_OR_EQUAL:
+    case PARSER_TOKEN_BUILTIN_PUTC:
     case PARSER_TOKEN_SYMBOL_BRACKET_LEFT:
     case PARSER_TOKEN_SYMBOL_BRACKET_RIGHT:
       printError(node->str_begin, node->str_end, "Unexpected %s",
@@ -3346,6 +3334,7 @@ bool isConst(AstTree *tree) {
   case AST_TREE_TOKEN_BUILTIN_SMALLER:
   case AST_TREE_TOKEN_BUILTIN_GREATER_OR_EQUAL:
   case AST_TREE_TOKEN_BUILTIN_SMALLER_OR_EQUAL:
+  case AST_TREE_TOKEN_BUILTIN_PUTC:
   case AST_TREE_TOKEN_TYPE_TYPE:
   case AST_TREE_TOKEN_TYPE_FUNCTION:
   case AST_TREE_TOKEN_TYPE_VOID:
@@ -3414,7 +3403,6 @@ bool isConst(AstTree *tree) {
     return true;
   }
   case AST_TREE_TOKEN_KEYWORD_WHILE:
-  case AST_TREE_TOKEN_KEYWORD_PUTC:
   case AST_TREE_TOKEN_KEYWORD_RETURN:
   case AST_TREE_TOKEN_KEYWORD_BREAK:
   case AST_TREE_TOKEN_KEYWORD_CONTINUE:
@@ -3645,9 +3633,9 @@ AstTree *makeTypeOf(AstTree *value) {
   case AST_TREE_TOKEN_BUILTIN_SMALLER:
   case AST_TREE_TOKEN_BUILTIN_GREATER_OR_EQUAL:
   case AST_TREE_TOKEN_BUILTIN_SMALLER_OR_EQUAL:
+  case AST_TREE_TOKEN_BUILTIN_PUTC:
   case AST_TREE_TOKEN_VALUE_OBJECT:
   case AST_TREE_TOKEN_VARIABLE_DEFINE:
-  case AST_TREE_TOKEN_KEYWORD_PUTC:
   case AST_TREE_TOKEN_KEYWORD_RETURN:
   case AST_TREE_TOKEN_KEYWORD_BREAK:
   case AST_TREE_TOKEN_KEYWORD_CONTINUE:
@@ -3724,8 +3712,8 @@ bool typeIsEqualBack(const AstTree *type0, const AstTree *type1) {
   case AST_TREE_TOKEN_BUILTIN_SMALLER:
   case AST_TREE_TOKEN_BUILTIN_GREATER_OR_EQUAL:
   case AST_TREE_TOKEN_BUILTIN_SMALLER_OR_EQUAL:
+  case AST_TREE_TOKEN_BUILTIN_PUTC:
   case AST_TREE_TOKEN_FUNCTION:
-  case AST_TREE_TOKEN_KEYWORD_PUTC:
   case AST_TREE_TOKEN_KEYWORD_RETURN:
   case AST_TREE_TOKEN_KEYWORD_BREAK:
   case AST_TREE_TOKEN_KEYWORD_CONTINUE:
@@ -3892,6 +3880,7 @@ AstTree *getValue(AstTree *tree, bool copy) {
   case AST_TREE_TOKEN_BUILTIN_SMALLER:
   case AST_TREE_TOKEN_BUILTIN_GREATER_OR_EQUAL:
   case AST_TREE_TOKEN_BUILTIN_SMALLER_OR_EQUAL:
+  case AST_TREE_TOKEN_BUILTIN_PUTC:
   case AST_TREE_TOKEN_TYPE_FUNCTION:
   case AST_TREE_TOKEN_TYPE_TYPE:
   case AST_TREE_TOKEN_TYPE_VOID:
@@ -3991,7 +3980,6 @@ AstTree *getValue(AstTree *tree, bool copy) {
       return tree;
     }
   }
-  case AST_TREE_TOKEN_KEYWORD_PUTC:
   case AST_TREE_TOKEN_KEYWORD_RETURN:
   case AST_TREE_TOKEN_KEYWORD_BREAK:
   case AST_TREE_TOKEN_KEYWORD_CONTINUE:
@@ -4031,7 +4019,7 @@ bool isIntType(AstTree *type) {
   case AST_TREE_TOKEN_BUILTIN_SMALLER:
   case AST_TREE_TOKEN_BUILTIN_GREATER_OR_EQUAL:
   case AST_TREE_TOKEN_BUILTIN_SMALLER_OR_EQUAL:
-  case AST_TREE_TOKEN_KEYWORD_PUTC:
+  case AST_TREE_TOKEN_BUILTIN_PUTC:
   case AST_TREE_TOKEN_KEYWORD_RETURN:
   case AST_TREE_TOKEN_KEYWORD_BREAK:
   case AST_TREE_TOKEN_KEYWORD_CONTINUE:
@@ -4160,7 +4148,7 @@ bool isEqual(AstTree *left, AstTree *right) {
   case AST_TREE_TOKEN_BUILTIN_SMALLER:
   case AST_TREE_TOKEN_BUILTIN_GREATER_OR_EQUAL:
   case AST_TREE_TOKEN_BUILTIN_SMALLER_OR_EQUAL:
-  case AST_TREE_TOKEN_KEYWORD_PUTC:
+  case AST_TREE_TOKEN_BUILTIN_PUTC:
   case AST_TREE_TOKEN_KEYWORD_RETURN:
   case AST_TREE_TOKEN_KEYWORD_BREAK:
   case AST_TREE_TOKEN_KEYWORD_CONTINUE:
@@ -4402,8 +4390,6 @@ bool setAllTypes(AstTree *tree, AstTreeSetTypesHelper helper,
     return setTypesValueObject(tree, helper);
   case AST_TREE_TOKEN_FUNCTION:
     return setTypesFunction(tree, helper);
-  case AST_TREE_TOKEN_KEYWORD_PUTC:
-    return setTypesPutc(tree, helper);
   case AST_TREE_TOKEN_KEYWORD_RETURN:
     return setTypesReturn(tree, helper, function);
   case AST_TREE_TOKEN_KEYWORD_BREAK:
@@ -4504,6 +4490,8 @@ bool setAllTypes(AstTree *tree, AstTreeSetTypesHelper helper,
   case AST_TREE_TOKEN_BUILTIN_SMALLER_OR_EQUAL:
     return setTypesBuiltinBinaryWithRet(tree, helper, functionCall,
                                         &AST_TREE_BOOL_TYPE);
+  case AST_TREE_TOKEN_BUILTIN_PUTC:
+    return setTypesBuiltinPutc(tree, helper, functionCall);
   case AST_TREE_TOKEN_TYPE_ARRAY:
     return setTypesTypeArray(tree, helper);
   case AST_TREE_TOKEN_OPERATOR_ARRAY_ACCESS:
@@ -4799,27 +4787,6 @@ bool setTypesFunction(AstTree *tree, AstTreeSetTypesHelper _helper) {
   return true;
 }
 
-bool setTypesPutc(AstTree *tree, AstTreeSetTypesHelper _helper) {
-  AstTreeSingleChild *metadata = tree->metadata;
-  AstTreeSetTypesHelper helper = {
-      .lookingType = &AST_TREE_U8_TYPE,
-      .dependencies = _helper.dependencies,
-      .variables = _helper.variables,
-      .root = _helper.root,
-      .loops = _helper.loops,
-      .loops_size = _helper.loops_size,
-  };
-  if (!setAllTypes(metadata, helper, NULL, NULL)) {
-    return false;
-  } else if (!typeIsEqual(metadata->type, &AST_TREE_U8_TYPE)) {
-    printError(tree->str_begin, tree->str_end, "Type mismatch");
-    return false;
-  } else {
-    tree->type = &AST_TREE_VOID_TYPE;
-    return true;
-  }
-}
-
 bool setTypesReturn(AstTree *tree, AstTreeSetTypesHelper _helper,
                     AstTreeFunction *function) {
   if (function == NULL) {
@@ -6026,7 +5993,7 @@ bool setTypesBuiltinUnary(AstTree *tree, AstTreeSetTypesHelper helper,
   case AST_TREE_TOKEN_BUILTIN_SMALLER:
   case AST_TREE_TOKEN_BUILTIN_GREATER_OR_EQUAL:
   case AST_TREE_TOKEN_BUILTIN_SMALLER_OR_EQUAL:
-  case AST_TREE_TOKEN_KEYWORD_PUTC:
+  case AST_TREE_TOKEN_BUILTIN_PUTC:
   case AST_TREE_TOKEN_KEYWORD_RETURN:
   case AST_TREE_TOKEN_KEYWORD_BREAK:
   case AST_TREE_TOKEN_KEYWORD_CONTINUE:
@@ -6264,6 +6231,57 @@ bool setTypesBuiltinBinaryWithRet(AstTree *tree, AstTreeSetTypesHelper helper,
   return true;
 }
 
+bool setTypesBuiltinPutc(AstTree *tree, AstTreeSetTypesHelper helper,
+                         AstTreeFunctionCall *functionCall) {
+  (void)helper;
+  if (functionCall->parameters_size != 1) {
+    printError(tree->str_begin, tree->str_end, "Too many or too few arguments");
+    return false;
+  }
+
+  const char *str = functionCall->parameters[0].nameBegin;
+  const size_t str_size = functionCall->parameters[0].nameEnd -
+                          functionCall->parameters[0].nameBegin;
+
+  static char VALUE_STR[] = "value";
+  static size_t VALUE_STR_SIZE =
+      sizeof(VALUE_STR) / sizeof(*VALUE_STR) - sizeof(*VALUE_STR);
+
+  if (str_size != 0 && (str_size != VALUE_STR_SIZE ||
+                        !strnEquals(str, VALUE_STR, VALUE_STR_SIZE))) {
+    printError(functionCall->parameters[0].nameBegin,
+               functionCall->parameters[0].nameEnd, "Unknown parameter");
+    return false;
+  }
+
+  if (!typeIsEqual(functionCall->parameters[0].value->type, &AST_TREE_U8_TYPE)) {
+    printError(functionCall->parameters[0].nameBegin,
+               functionCall->parameters[0].nameEnd,
+               "Bad argument (must have a type of u8)");
+    return false;
+  }
+
+  AstTreeTypeFunction *type_metadata = a404m_malloc(sizeof(*type_metadata));
+  type_metadata->arguments_size = 1;
+  type_metadata->arguments = a404m_malloc(type_metadata->arguments_size *
+                                          sizeof(*type_metadata->arguments));
+
+  type_metadata->returnType = copyAstTree(&AST_TREE_VOID_TYPE);
+
+  type_metadata->arguments[0] = (AstTreeTypeFunctionArgument){
+      .type = copyAstTree(&AST_TREE_U8_TYPE),
+      .name_begin = VALUE_STR,
+      .name_end = VALUE_STR + VALUE_STR_SIZE,
+      .str_begin = NULL,
+      .str_end = NULL,
+      .isComptime = false,
+  };
+
+  tree->type = newAstTree(AST_TREE_TOKEN_TYPE_FUNCTION, type_metadata,
+                          &AST_TREE_TYPE_TYPE, NULL, NULL);
+  return true;
+}
+
 bool setTypesTypeArray(AstTree *tree, AstTreeSetTypesHelper helper) {
   AstTreeBracket *metadata = tree->metadata;
 
@@ -6765,7 +6783,7 @@ size_t getSizeOfType(AstTree *type) {
   case AST_TREE_TOKEN_BUILTIN_SMALLER:
   case AST_TREE_TOKEN_BUILTIN_GREATER_OR_EQUAL:
   case AST_TREE_TOKEN_BUILTIN_SMALLER_OR_EQUAL:
-  case AST_TREE_TOKEN_KEYWORD_PUTC:
+  case AST_TREE_TOKEN_BUILTIN_PUTC:
   case AST_TREE_TOKEN_KEYWORD_RETURN:
   case AST_TREE_TOKEN_KEYWORD_BREAK:
   case AST_TREE_TOKEN_KEYWORD_CONTINUE:
diff --git a/src/compiler/ast-tree.h b/src/compiler/ast-tree.h
index d2eaffd..6bd9973 100644
--- a/src/compiler/ast-tree.h
+++ b/src/compiler/ast-tree.h
@@ -25,9 +25,9 @@ typedef enum AstTreeToken {
   AST_TREE_TOKEN_BUILTIN_SMALLER,
   AST_TREE_TOKEN_BUILTIN_GREATER_OR_EQUAL,
   AST_TREE_TOKEN_BUILTIN_SMALLER_OR_EQUAL,
-  AST_TREE_TOKEN_BUILTIN_END = AST_TREE_TOKEN_BUILTIN_SMALLER_OR_EQUAL,
+  AST_TREE_TOKEN_BUILTIN_PUTC,
+  AST_TREE_TOKEN_BUILTIN_END = AST_TREE_TOKEN_BUILTIN_PUTC,
 
-  AST_TREE_TOKEN_KEYWORD_PUTC,
   AST_TREE_TOKEN_KEYWORD_RETURN,
   AST_TREE_TOKEN_KEYWORD_BREAK,
   AST_TREE_TOKEN_KEYWORD_CONTINUE,
@@ -367,7 +367,6 @@ AstTree *astTreeParseString(const ParserNode *parserNode);
 AstTree *astTreeParseKeyword(const ParserNode *parserNode, AstTreeToken token);
 AstTree *astTreeParseLoopControl(const ParserNode *parserNode,
                                  AstTreeToken token);
-AstTree *astTreeParsePutc(const ParserNode *parserNode);
 AstTree *astTreeParseReturn(const ParserNode *parserNode);
 AstTree *astTreeParseBinaryOperator(const ParserNode *parserNode,
                                     AstTreeToken token);
@@ -416,7 +415,6 @@ bool setTypesValueNull(AstTree *tree, AstTreeSetTypesHelper helper);
 bool setTypesValueUndefined(AstTree *tree, AstTreeSetTypesHelper helper);
 bool setTypesValueObject(AstTree *tree, AstTreeSetTypesHelper helper);
 bool setTypesFunction(AstTree *tree, AstTreeSetTypesHelper helper);
-bool setTypesPutc(AstTree *tree, AstTreeSetTypesHelper helper);
 bool setTypesReturn(AstTree *tree, AstTreeSetTypesHelper helper,
                     AstTreeFunction *function);
 bool setTypesBreak(AstTree *tree, AstTreeSetTypesHelper helper);
@@ -466,6 +464,8 @@ bool setTypesBuiltinBinary(AstTree *tree, AstTreeSetTypesHelper helper,
 bool setTypesBuiltinBinaryWithRet(AstTree *tree, AstTreeSetTypesHelper helper,
                                   AstTreeFunctionCall *functionCall,
                                   AstTree *retType);
+bool setTypesBuiltinPutc(AstTree *tree, AstTreeSetTypesHelper helper,
+                         AstTreeFunctionCall *functionCall);
 bool setTypesTypeArray(AstTree *tree, AstTreeSetTypesHelper helper);
 bool setTypesArrayAccess(AstTree *tree, AstTreeSetTypesHelper helper);
 bool setTypesAstFunction(AstTreeFunction *function,
diff --git a/src/compiler/lexer.c b/src/compiler/lexer.c
index 6804080..6b55e61 100644
--- a/src/compiler/lexer.c
+++ b/src/compiler/lexer.c
@@ -29,6 +29,7 @@ const char *LEXER_TOKEN_STRINGS[] = {
     "LEXER_TOKEN_BUILTIN_SMALLER",
     "LEXER_TOKEN_BUILTIN_GREATER_OR_EQUAL",
     "LEXER_TOKEN_BUILTIN_SMALLER_OR_EQUAL",
+    "LEXER_TOKEN_BUILTIN_PUTC",
     "LEXER_TOKEN_KEYWORD_TYPE",
     "LEXER_TOKEN_KEYWORD_VOID",
     "LEXER_TOKEN_KEYWORD_I8",
@@ -98,7 +99,6 @@ const char *LEXER_TOKEN_STRINGS[] = {
     "LEXER_TOKEN_SYMBOL_MODULO_ASSIGN",
 
     "LEXER_TOKEN_KEYWORD_RETURN",
-    "LEXER_TOKEN_KEYWORD_PUTC",
     "LEXER_TOKEN_KEYWORD_BREAK",
     "LEXER_TOKEN_KEYWORD_CONTINUE",
     "LEXER_TOKEN_KEYWORD_COMPTIME",
@@ -164,51 +164,35 @@ static const size_t LEXER_SYMBOL_SIZE =
     sizeof(LEXER_SYMBOL_TOKENS) / sizeof(*LEXER_SYMBOL_TOKENS);
 
 static const char *LEXER_KEYWORD_STRINGS[] = {
-    "type",          "void",   "i8",        "u8",   "i16",   "u16",
-    "i32",           "u32",    "i64",       "u64",
+    "type",   "void",      "i8",   "u8",    "i16",       "u16",
+    "i32",    "u32",       "i64",  "u64",
 #ifdef FLOAT_16_SUPPORT
     "f16",
 #endif
-    "f32",           "f64",    "f128",      "bool", "putc",  "return",
-    "true",          "false",  "if",        "else", "while", "comptime",
-    "null",          "struct", "undefined", "code", "lazy",  "namespace",
-    "shape_shifter", "break",  "continue",
+    "f32",    "f64",       "f128", "bool",  "return",    "true",
+    "false",  "if",        "else", "while", "comptime",  "null",
+    "struct", "undefined", "code", "lazy",  "namespace", "shape_shifter",
+    "break",  "continue",
 };
 static const LexerToken LEXER_KEYWORD_TOKENS[] = {
-    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,
-    LEXER_TOKEN_KEYWORD_U64,
+    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,       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_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_KEYWORD_CODE,
-    LEXER_TOKEN_KEYWORD_LAZY,
-    LEXER_TOKEN_KEYWORD_NAMESPACE,
-    LEXER_TOKEN_KEYWORD_SHAPE_SHIFTER,
-    LEXER_TOKEN_KEYWORD_BREAK,
-    LEXER_TOKEN_KEYWORD_CONTINUE,
+    LEXER_TOKEN_KEYWORD_F32,       LEXER_TOKEN_KEYWORD_F64,
+    LEXER_TOKEN_KEYWORD_F128,      LEXER_TOKEN_KEYWORD_BOOL,
+    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_KEYWORD_CODE,      LEXER_TOKEN_KEYWORD_LAZY,
+    LEXER_TOKEN_KEYWORD_NAMESPACE, LEXER_TOKEN_KEYWORD_SHAPE_SHIFTER,
+    LEXER_TOKEN_KEYWORD_BREAK,     LEXER_TOKEN_KEYWORD_CONTINUE,
 };
 static const size_t LEXER_KEYWORD_SIZE =
     sizeof(LEXER_KEYWORD_TOKENS) / sizeof(*LEXER_KEYWORD_TOKENS);
@@ -232,7 +216,7 @@ static const char *LEXER_BUILTIN_STRINGS[] = {
     "smaller",
     "greaterOrEqual",
     "smallerOrEqual",
-
+    "putc",
 };
 static const LexerToken LEXER_BUILTIN_TOKENS[] = {
     LEXER_TOKEN_BUILTIN_CAST,
@@ -253,6 +237,7 @@ static const LexerToken LEXER_BUILTIN_TOKENS[] = {
     LEXER_TOKEN_BUILTIN_SMALLER,
     LEXER_TOKEN_BUILTIN_GREATER_OR_EQUAL,
     LEXER_TOKEN_BUILTIN_SMALLER_OR_EQUAL,
+    LEXER_TOKEN_BUILTIN_PUTC,
 };
 static const size_t LEXER_BUILTIN_SIZE =
     sizeof(LEXER_BUILTIN_TOKENS) / sizeof(*LEXER_BUILTIN_TOKENS);
@@ -450,7 +435,6 @@ lexerPushClear(LexerNodeArray *array, size_t *array_size, char const *iter,
   case LEXER_TOKEN_KEYWORD_F64:
   case LEXER_TOKEN_KEYWORD_F128:
   case LEXER_TOKEN_KEYWORD_BOOL:
-  case LEXER_TOKEN_KEYWORD_PUTC:
   case LEXER_TOKEN_KEYWORD_RETURN:
   case LEXER_TOKEN_KEYWORD_TRUE:
   case LEXER_TOKEN_KEYWORD_FALSE:
@@ -520,6 +504,7 @@ lexerPushClear(LexerNodeArray *array, size_t *array_size, char const *iter,
   case LEXER_TOKEN_BUILTIN_SMALLER:
   case LEXER_TOKEN_BUILTIN_GREATER_OR_EQUAL:
   case LEXER_TOKEN_BUILTIN_SMALLER_OR_EQUAL:
+  case LEXER_TOKEN_BUILTIN_PUTC:
   case LEXER_TOKEN_SYMBOL_CLOSE_BRACKET:
   case LEXER_TOKEN_SYMBOL_OPEN_BRACKET:
   case LEXER_TOKEN_KEYWORD_SHAPE_SHIFTER:
diff --git a/src/compiler/lexer.h b/src/compiler/lexer.h
index 0cc19cd..925c16f 100644
--- a/src/compiler/lexer.h
+++ b/src/compiler/lexer.h
@@ -31,6 +31,7 @@ typedef enum LexerToken {
   LEXER_TOKEN_BUILTIN_SMALLER,
   LEXER_TOKEN_BUILTIN_GREATER_OR_EQUAL,
   LEXER_TOKEN_BUILTIN_SMALLER_OR_EQUAL,
+  LEXER_TOKEN_BUILTIN_PUTC,
   LEXER_TOKEN_KEYWORD_TYPE,
   LEXER_TOKEN_KEYWORD_VOID,
   LEXER_TOKEN_KEYWORD_I8,
@@ -110,7 +111,6 @@ typedef enum LexerToken {
 
   LEXER_TOKEN_KEYWORD_RETURN,
   LEXER_TOKEN_ORDER11 = LEXER_TOKEN_KEYWORD_RETURN,
-  LEXER_TOKEN_KEYWORD_PUTC,
   LEXER_TOKEN_KEYWORD_BREAK,
   LEXER_TOKEN_KEYWORD_CONTINUE,
   LEXER_TOKEN_KEYWORD_COMPTIME,
diff --git a/src/compiler/parser.c b/src/compiler/parser.c
index b7a6e46..e8772fb 100644
--- a/src/compiler/parser.c
+++ b/src/compiler/parser.c
@@ -30,6 +30,7 @@ const char *PARSER_TOKEN_STRINGS[] = {
     "PARSER_TOKEN_BUILTIN_SMALLER",
     "PARSER_TOKEN_BUILTIN_GREATER_OR_EQUAL",
     "PARSER_TOKEN_BUILTIN_SMALLER_OR_EQUAL",
+    "PARSER_TOKEN_BUILTIN_PUTC",
 
     "PARSER_TOKEN_VALUE_INT",
     "PARSER_TOKEN_VALUE_FLOAT",
@@ -59,7 +60,6 @@ const char *PARSER_TOKEN_STRINGS[] = {
     "PARSER_TOKEN_TYPE_NAMESPACE",
     "PARSER_TOKEN_TYPE_SHAPE_SHIFTER",
 
-    "PARSER_TOKEN_KEYWORD_PUTC",
     "PARSER_TOKEN_KEYWORD_BREAK",
     "PARSER_TOKEN_KEYWORD_CONTINUE",
     "PARSER_TOKEN_KEYWORD_RETURN",
@@ -260,6 +260,7 @@ void parserNodePrint(const ParserNode *node, int indent) {
   case PARSER_TOKEN_BUILTIN_SMALLER:
   case PARSER_TOKEN_BUILTIN_GREATER_OR_EQUAL:
   case PARSER_TOKEN_BUILTIN_SMALLER_OR_EQUAL:
+  case PARSER_TOKEN_BUILTIN_PUTC:
   case PARSER_TOKEN_TYPE_TYPE:
   case PARSER_TOKEN_TYPE_VOID:
   case PARSER_TOKEN_TYPE_BOOL:
@@ -341,7 +342,6 @@ void parserNodePrint(const ParserNode *node, int indent) {
   case PARSER_TOKEN_OPERATOR_DEREFERENCE:
   case PARSER_TOKEN_OPERATOR_PLUS:
   case PARSER_TOKEN_OPERATOR_MINUS:
-  case PARSER_TOKEN_KEYWORD_PUTC:
   case PARSER_TOKEN_KEYWORD_COMPTIME:
   case PARSER_TOKEN_SYMBOL_COMMA:
   case PARSER_TOKEN_SYMBOL_EOL: {
@@ -565,6 +565,7 @@ void parserNodeDelete(ParserNode *node) {
   case PARSER_TOKEN_BUILTIN_SMALLER:
   case PARSER_TOKEN_BUILTIN_GREATER_OR_EQUAL:
   case PARSER_TOKEN_BUILTIN_SMALLER_OR_EQUAL:
+  case PARSER_TOKEN_BUILTIN_PUTC:
   case PARSER_TOKEN_TYPE_TYPE:
   case PARSER_TOKEN_TYPE_VOID:
   case PARSER_TOKEN_TYPE_BOOL:
@@ -632,7 +633,6 @@ void parserNodeDelete(ParserNode *node) {
   case PARSER_TOKEN_OPERATOR_DEREFERENCE:
   case PARSER_TOKEN_OPERATOR_PLUS:
   case PARSER_TOKEN_OPERATOR_MINUS:
-  case PARSER_TOKEN_KEYWORD_PUTC:
   case PARSER_TOKEN_KEYWORD_COMPTIME:
   case PARSER_TOKEN_SYMBOL_COMMA:
   case PARSER_TOKEN_SYMBOL_EOL: {
@@ -888,6 +888,8 @@ ParserNode *parseNode(LexerNode *node, LexerNode *begin, LexerNode *end,
   case LEXER_TOKEN_BUILTIN_SMALLER_OR_EQUAL:
     return parserNoMetadata(node, parent,
                             PARSER_TOKEN_BUILTIN_SMALLER_OR_EQUAL);
+  case LEXER_TOKEN_BUILTIN_PUTC:
+    return parserNoMetadata(node, parent, PARSER_TOKEN_BUILTIN_PUTC);
   case LEXER_TOKEN_KEYWORD_TYPE:
     return parserNoMetadata(node, parent, PARSER_TOKEN_TYPE_TYPE);
   case LEXER_TOKEN_KEYWORD_VOID:
@@ -934,8 +936,6 @@ ParserNode *parseNode(LexerNode *node, LexerNode *begin, LexerNode *end,
     return parserNoMetadata(node, parent, PARSER_TOKEN_KEYWORD_BREAK);
   case LEXER_TOKEN_KEYWORD_CONTINUE:
     return parserNoMetadata(node, parent, PARSER_TOKEN_KEYWORD_CONTINUE);
-  case LEXER_TOKEN_KEYWORD_PUTC:
-    return parserPutc(node, end, parent);
   case LEXER_TOKEN_KEYWORD_RETURN:
     return parserReturn(node, end, parent);
   case LEXER_TOKEN_KEYWORD_TRUE:
@@ -1158,27 +1158,6 @@ ParserNode *parserNoMetadata(LexerNode *node, ParserNode *parent,
              newParserNode(token, node->str_begin, node->str_end, NULL, parent);
 }
 
-ParserNode *parserPutc(LexerNode *node, LexerNode *end, ParserNode *parent) {
-  LexerNode *afterNode = node + 1;
-  if (afterNode >= end) {
-    printError(node->str_begin, node->str_end, "No param");
-    return NULL;
-  } else if (afterNode->parserNode == NULL) {
-    printError(node->str_begin, node->str_end, "Bad param");
-    return NULL;
-  }
-
-  ParserNode *operand = getUntilCommonParent(afterNode->parserNode, parent);
-  if (operand == NULL) {
-    printError(node->str_begin, node->str_end, "Bad param");
-    return NULL;
-  }
-
-  return operand->parent = node->parserNode = newParserNode(
-             PARSER_TOKEN_KEYWORD_PUTC, node->str_begin, node->str_end,
-             (ParserNodeSingleChildMetadata *)operand, parent);
-}
-
 ParserNode *parserReturn(LexerNode *node, LexerNode *end, ParserNode *parent) {
   LexerNode *afterNode = node + 1;
   ParserNode *operand;
@@ -1696,6 +1675,7 @@ ParserNode *parserFunction(LexerNode *node, LexerNode *begin, LexerNode *end,
       case PARSER_TOKEN_BUILTIN_SMALLER:
       case PARSER_TOKEN_BUILTIN_GREATER_OR_EQUAL:
       case PARSER_TOKEN_BUILTIN_SMALLER_OR_EQUAL:
+      case PARSER_TOKEN_BUILTIN_PUTC:
       case PARSER_TOKEN_VALUE_INT:
       case PARSER_TOKEN_VALUE_FLOAT:
       case PARSER_TOKEN_VALUE_BOOL:
@@ -1726,7 +1706,6 @@ ParserNode *parserFunction(LexerNode *node, LexerNode *begin, LexerNode *end,
       case PARSER_TOKEN_KEYWORD_UNDEFINED:
       case PARSER_TOKEN_KEYWORD_BREAK:
       case PARSER_TOKEN_KEYWORD_CONTINUE:
-      case PARSER_TOKEN_KEYWORD_PUTC:
       case PARSER_TOKEN_KEYWORD_RETURN:
       case PARSER_TOKEN_KEYWORD_STRUCT:
       case PARSER_TOKEN_CONSTANT:
@@ -2197,6 +2176,7 @@ bool isExpression(ParserNode *node) {
   case PARSER_TOKEN_BUILTIN_SMALLER:
   case PARSER_TOKEN_BUILTIN_GREATER_OR_EQUAL:
   case PARSER_TOKEN_BUILTIN_SMALLER_OR_EQUAL:
+  case PARSER_TOKEN_BUILTIN_PUTC:
   case PARSER_TOKEN_CONSTANT:
   case PARSER_TOKEN_VARIABLE:
   case PARSER_TOKEN_SYMBOL_PARENTHESIS:
@@ -2204,7 +2184,6 @@ bool isExpression(ParserNode *node) {
   case PARSER_TOKEN_SYMBOL_BRACKET_RIGHT:
   case PARSER_TOKEN_FUNCTION_DEFINITION:
   case PARSER_TOKEN_FUNCTION_CALL:
-  case PARSER_TOKEN_KEYWORD_PUTC:
   case PARSER_TOKEN_KEYWORD_RETURN:
   case PARSER_TOKEN_OPERATOR_ACCESS:
   case PARSER_TOKEN_OPERATOR_ASSIGN:
@@ -2330,6 +2309,7 @@ bool isType(ParserNode *node) {
   case PARSER_TOKEN_BUILTIN_SMALLER:
   case PARSER_TOKEN_BUILTIN_GREATER_OR_EQUAL:
   case PARSER_TOKEN_BUILTIN_SMALLER_OR_EQUAL:
+  case PARSER_TOKEN_BUILTIN_PUTC:
   case PARSER_TOKEN_OPERATOR_ADDRESS:
   case PARSER_TOKEN_KEYWORD_NULL:
   case PARSER_TOKEN_KEYWORD_UNDEFINED:
@@ -2344,7 +2324,6 @@ bool isType(ParserNode *node) {
   case PARSER_TOKEN_VALUE_BOOL:
   case PARSER_TOKEN_VALUE_CHAR:
   case PARSER_TOKEN_VALUE_STRING:
-  case PARSER_TOKEN_KEYWORD_PUTC:
   case PARSER_TOKEN_KEYWORD_RETURN:
   case PARSER_TOKEN_KEYWORD_BREAK:
   case PARSER_TOKEN_KEYWORD_CONTINUE:
@@ -2406,6 +2385,7 @@ bool isValue(ParserNode *node) {
   case PARSER_TOKEN_BUILTIN_SMALLER:
   case PARSER_TOKEN_BUILTIN_GREATER_OR_EQUAL:
   case PARSER_TOKEN_BUILTIN_SMALLER_OR_EQUAL:
+  case PARSER_TOKEN_BUILTIN_PUTC:
   case PARSER_TOKEN_OPERATOR_ACCESS:
   case PARSER_TOKEN_OPERATOR_ASSIGN:
   case PARSER_TOKEN_OPERATOR_SUM_ASSIGN:
@@ -2468,7 +2448,6 @@ bool isValue(ParserNode *node) {
   case PARSER_TOKEN_SYMBOL_EOL:
   case PARSER_TOKEN_SYMBOL_CURLY_BRACKET:
   case PARSER_TOKEN_SYMBOL_COMMA:
-  case PARSER_TOKEN_KEYWORD_PUTC:
   case PARSER_TOKEN_KEYWORD_RETURN:
   case PARSER_TOKEN_KEYWORD_BREAK:
   case PARSER_TOKEN_KEYWORD_CONTINUE:
diff --git a/src/compiler/parser.h b/src/compiler/parser.h
index a322747..463b6a9 100644
--- a/src/compiler/parser.h
+++ b/src/compiler/parser.h
@@ -27,6 +27,7 @@ typedef enum ParserToken {
   PARSER_TOKEN_BUILTIN_SMALLER,
   PARSER_TOKEN_BUILTIN_GREATER_OR_EQUAL,
   PARSER_TOKEN_BUILTIN_SMALLER_OR_EQUAL,
+  PARSER_TOKEN_BUILTIN_PUTC,
 
   PARSER_TOKEN_VALUE_INT,
   PARSER_TOKEN_VALUE_FLOAT,
@@ -56,7 +57,6 @@ typedef enum ParserToken {
   PARSER_TOKEN_TYPE_NAMESPACE,
   PARSER_TOKEN_TYPE_SHAPE_SHIFTER,
 
-  PARSER_TOKEN_KEYWORD_PUTC,
   PARSER_TOKEN_KEYWORD_BREAK,
   PARSER_TOKEN_KEYWORD_CONTINUE,
   PARSER_TOKEN_KEYWORD_RETURN,
@@ -227,7 +227,6 @@ LexerNode *getNextLexerNodeUsingCommonParent(LexerNode *node, LexerNode *end,
 
 ParserNode *parserNoMetadata(LexerNode *node, ParserNode *parent,
                              ParserToken token);
-ParserNode *parserPutc(LexerNode *node, LexerNode *end, ParserNode *parent);
 ParserNode *parserReturn(LexerNode *node, LexerNode *end, ParserNode *parent);
 ParserNode *parserNumber(LexerNode *node, ParserNode *parent);
 ParserNode *parserChar(LexerNode *node, ParserNode *parent);
diff --git a/src/runner/runner.c b/src/runner/runner.c
index 67fc02e..e4578ec 100644
--- a/src/runner/runner.c
+++ b/src/runner/runner.c
@@ -1040,6 +1040,10 @@ AstTree *runAstTreeBuiltin(AstTree *tree, AstTreeScope *scope,
     }
     return ret;
   }
+  case AST_TREE_TOKEN_BUILTIN_PUTC: {
+    putchar((u8) * (AstTreeInt *)arguments[0]->metadata);
+    return copyAstTree(&AST_TREE_VOID_VALUE);
+  }
   case AST_TREE_TOKEN_BUILTIN_IMPORT:
   default:
   }
@@ -1050,17 +1054,6 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet,
                        bool isLeft, bool isComptime, u32 *breakCount,
                        bool *shouldContinue) {
   switch (expr->token) {
-  case AST_TREE_TOKEN_KEYWORD_PUTC: {
-    AstTreeSingleChild *metadata = expr->metadata;
-    AstTree *tree = runExpression(metadata, scope, shouldRet, false, isComptime,
-                                  breakCount, shouldContinue);
-    if (discontinue(*shouldRet, *breakCount)) {
-      return tree;
-    }
-    putchar((u8) * (AstTreeInt *)tree->metadata);
-    astTreeDelete(tree);
-    return &AST_TREE_VOID_VALUE;
-  }
   case AST_TREE_TOKEN_FUNCTION_CALL: {
     AstTreeFunctionCall *metadata = expr->metadata;
     AstTree *function =
@@ -1374,6 +1367,7 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet,
   case AST_TREE_TOKEN_BUILTIN_SMALLER:
   case AST_TREE_TOKEN_BUILTIN_GREATER_OR_EQUAL:
   case AST_TREE_TOKEN_BUILTIN_SMALLER_OR_EQUAL:
+  case AST_TREE_TOKEN_BUILTIN_PUTC:
     return copyAstTree(expr);
   case AST_TREE_TOKEN_BUILTIN_IS_COMPTIME: {
     AstTreeBool *metadata = a404m_malloc(sizeof(*metadata));