add ability to specify int type as extension

4 files changed, 157 insertions, 10 deletions

diff --git a/src/compiler/ast-tree.c b/src/compiler/ast-tree.c
index c778571..1018bfd 100644
--- a/src/compiler/ast-tree.c
+++ b/src/compiler/ast-tree.c
@@ -2452,8 +2452,7 @@ AstTree *astTreeParse(const ParserNode *parserNode) {
   case PARSER_TOKEN_IDENTIFIER:
     return astTreeParseIdentifier(parserNode);
   case PARSER_TOKEN_VALUE_INT:
-    return astTreeParseValue(parserNode, AST_TREE_TOKEN_VALUE_INT,
-                             sizeof(AstTreeInt), NULL);
+    return astTreeParseIntValue(parserNode);
   case PARSER_TOKEN_VALUE_FLOAT:
     return astTreeParseValue(parserNode, AST_TREE_TOKEN_VALUE_FLOAT,
                              sizeof(AstTreeFloat), NULL);
@@ -2956,6 +2955,67 @@ AstTree *astTreeParseValue(const ParserNode *parserNode, AstTreeToken token,
                     parserNode->str_end);
 }
 
+AstTree *astTreeParseIntValue(const ParserNode *parserNode) {
+  ParserNodeIntMetadata *node_metadata = parserNode->metadata;
+  switch (node_metadata->type) {
+  case PARSER_NODE_INT_TYPE_UNKNOWN: {
+    AstTreeInt *metadata = a404m_malloc(sizeof(*metadata));
+    *metadata = node_metadata->value;
+    return newAstTree(AST_TREE_TOKEN_VALUE_INT, metadata, NULL,
+                      parserNode->str_begin, parserNode->str_end);
+  }
+  case PARSER_NODE_INT_TYPE_I8: {
+    i8 *metadata = a404m_malloc(sizeof(*metadata));
+    *metadata = node_metadata->value;
+    return newAstTree(AST_TREE_TOKEN_RAW_VALUE, metadata, &AST_TREE_I8_TYPE,
+                      parserNode->str_begin, parserNode->str_end);
+  }
+  case PARSER_NODE_INT_TYPE_U8: {
+    u8 *metadata = a404m_malloc(sizeof(*metadata));
+    *metadata = node_metadata->value;
+    return newAstTree(AST_TREE_TOKEN_RAW_VALUE, metadata, &AST_TREE_I8_TYPE,
+                      parserNode->str_begin, parserNode->str_end);
+  }
+  case PARSER_NODE_INT_TYPE_I16: {
+    i16 *metadata = a404m_malloc(sizeof(*metadata));
+    *metadata = node_metadata->value;
+    return newAstTree(AST_TREE_TOKEN_RAW_VALUE, metadata, &AST_TREE_I16_TYPE,
+                      parserNode->str_begin, parserNode->str_end);
+  }
+  case PARSER_NODE_INT_TYPE_U16: {
+    u16 *metadata = a404m_malloc(sizeof(*metadata));
+    *metadata = node_metadata->value;
+    return newAstTree(AST_TREE_TOKEN_RAW_VALUE, metadata, &AST_TREE_I16_TYPE,
+                      parserNode->str_begin, parserNode->str_end);
+  }
+  case PARSER_NODE_INT_TYPE_I32: {
+    i32 *metadata = a404m_malloc(sizeof(*metadata));
+    *metadata = node_metadata->value;
+    return newAstTree(AST_TREE_TOKEN_RAW_VALUE, metadata, &AST_TREE_I32_TYPE,
+                      parserNode->str_begin, parserNode->str_end);
+  }
+  case PARSER_NODE_INT_TYPE_U32: {
+    u32 *metadata = a404m_malloc(sizeof(*metadata));
+    *metadata = node_metadata->value;
+    return newAstTree(AST_TREE_TOKEN_RAW_VALUE, metadata, &AST_TREE_I32_TYPE,
+                      parserNode->str_begin, parserNode->str_end);
+  }
+  case PARSER_NODE_INT_TYPE_I64: {
+    i64 *metadata = a404m_malloc(sizeof(*metadata));
+    *metadata = node_metadata->value;
+    return newAstTree(AST_TREE_TOKEN_RAW_VALUE, metadata, &AST_TREE_I64_TYPE,
+                      parserNode->str_begin, parserNode->str_end);
+  }
+  case PARSER_NODE_INT_TYPE_U64: {
+    u64 *metadata = a404m_malloc(sizeof(*metadata));
+    *metadata = node_metadata->value;
+    return newAstTree(AST_TREE_TOKEN_RAW_VALUE, metadata, &AST_TREE_I64_TYPE,
+                      parserNode->str_begin, parserNode->str_end);
+  }
+  }
+  UNREACHABLE;
+}
+
 AstTree *astTreeParseString(const ParserNode *parserNode) {
   ParserNodeStringMetadata *node_metadata = parserNode->metadata;
 
diff --git a/src/compiler/ast-tree.h b/src/compiler/ast-tree.h
index 6979201..aef4826 100644
--- a/src/compiler/ast-tree.h
+++ b/src/compiler/ast-tree.h
@@ -406,6 +406,7 @@ AstTree *astTreeParseFunctionCall(const ParserNode *parserNode);
 AstTree *astTreeParseIdentifier(const ParserNode *parserNode);
 AstTree *astTreeParseValue(const ParserNode *parserNode, AstTreeToken token,
                            size_t metadata_size, AstTree *type);
+AstTree *astTreeParseIntValue(const ParserNode *parserNode);
 AstTree *astTreeParseString(const ParserNode *parserNode);
 AstTree *astTreeParseKeyword(const ParserNode *parserNode, AstTreeToken token);
 AstTree *astTreeParseLoopControl(const ParserNode *parserNode,
diff --git a/src/compiler/parser.c b/src/compiler/parser.c
index 65fd3c9..903a8af 100644
--- a/src/compiler/parser.c
+++ b/src/compiler/parser.c
@@ -328,7 +328,7 @@ void parserNodePrint(const ParserNode *node, int indent) {
     goto RETURN_SUCCESS;
   case PARSER_TOKEN_VALUE_INT: {
     ParserNodeIntMetadata *metadata = node->metadata;
-    printf(",operand=%lld", *metadata);
+    printf(",operand=%lld,type=%d", metadata->value, metadata->type);
   }
     goto RETURN_SUCCESS;
   case PARSER_TOKEN_VALUE_FLOAT: {
@@ -343,7 +343,7 @@ void parserNodePrint(const ParserNode *node, int indent) {
     goto RETURN_SUCCESS;
   case PARSER_TOKEN_VALUE_CHAR: {
     ParserNodeCharMetadata *metadata = node->metadata;
-    printf(",value=%c", (char)*metadata);
+    printf(",value=%c", (char)metadata->value);
   }
     goto RETURN_SUCCESS;
   case PARSER_TOKEN_VALUE_STRING: {
@@ -1294,13 +1294,16 @@ ParserNode *parserNumber(LexerNode *node, ParserNode *parent) {
       switch (*(node->str_begin + 1)) {
       case 'x':
       case 'X':
-        u64 value = hexToU64(node->str_begin + 2, node->str_end, &success);
+        ParserNodeIntType type = getIntType(node->str_begin + 2, node->str_end);
+        u64 value = hexToU64(node->str_begin + 2,
+                             node->str_end - getIntTypeSize(type), &success);
         if (!success) {
           printError(node->str_begin, node->str_end, "Error in parsing number");
           return NULL;
         }
         ParserNodeIntMetadata *metadata = a404m_malloc(sizeof(*metadata));
-        *metadata = value;
+        metadata->value = value;
+        metadata->type = type;
         parserNode = newParserNode(PARSER_TOKEN_VALUE_INT, node->str_begin,
                                    node->str_end, metadata, parent);
         break;
@@ -1311,10 +1314,13 @@ ParserNode *parserNumber(LexerNode *node, ParserNode *parent) {
     }
     // fall through
   default: {
-    u64 value = decimalToU64(node->str_begin, node->str_end, &success);
+    ParserNodeIntType type = getIntType(node->str_begin, node->str_end);
+    u64 value = decimalToU64(node->str_begin,
+                             node->str_end - getIntTypeSize(type), &success);
     if (success) {
       ParserNodeIntMetadata *metadata = a404m_malloc(sizeof(*metadata));
-      *metadata = value;
+      metadata->value = value;
+      metadata->type = type;
       parserNode = newParserNode(PARSER_TOKEN_VALUE_INT, node->str_begin,
                                  node->str_end, metadata, parent);
     } else {
@@ -1355,7 +1361,8 @@ ParserNode *parserChar(LexerNode *node, ParserNode *parent) {
     printError(node->str_begin, node->str_end, "Bad character");
     goto RETURN_ERROR;
   }
-  *metadata = c;
+  metadata->value = c;
+  metadata->type = PARSER_NODE_INT_TYPE_U8;
   return node->parserNode =
              newParserNode(PARSER_TOKEN_VALUE_CHAR, node->str_begin,
                            node->str_end, metadata, parent);
@@ -2842,3 +2849,64 @@ char escapeChar(char const *begin, char const *end, bool *success) {
     return 0;
   }
 }
+
+ParserNodeIntType getIntType(char const *begin, char const *end) {
+  static const char I8[] = "i8";
+  static const size_t I8_SIZE = sizeof(I8) / sizeof(*I8) - sizeof(*I8);
+  static const char U8[] = "u8";
+  static const size_t U8_SIZE = sizeof(U8) / sizeof(*U8) - sizeof(*U8);
+  static const char I16[] = "i16";
+  static const size_t I16_SIZE = sizeof(I16) / sizeof(*I16) - sizeof(*I16);
+  static const char U16[] = "u16";
+  static const size_t U16_SIZE = sizeof(U16) / sizeof(*U16) - sizeof(*U16);
+  static const char I32[] = "i32";
+  static const size_t I32_SIZE = sizeof(I32) / sizeof(*I32) - sizeof(*I32);
+  static const char U32[] = "u32";
+  static const size_t U32_SIZE = sizeof(U32) / sizeof(*U32) - sizeof(*U32);
+  static const char I64[] = "i64";
+  static const size_t I64_SIZE = sizeof(I64) / sizeof(*I64) - sizeof(*I64);
+  static const char U64[] = "u64";
+  static const size_t U64_SIZE = sizeof(U64) / sizeof(*U64) - sizeof(*U64);
+
+  if (end - begin < 3) {
+    return PARSER_NODE_INT_TYPE_UNKNOWN;
+  }
+
+  if (strnEqualsCaseInsensitive(end - I8_SIZE, I8, I8_SIZE)) {
+    return PARSER_NODE_INT_TYPE_I8;
+  } else if (strnEqualsCaseInsensitive(end - U8_SIZE, U8, U8_SIZE)) {
+    return PARSER_NODE_INT_TYPE_U8;
+  } else if (strnEqualsCaseInsensitive(end - I16_SIZE, I16, I16_SIZE)) {
+    return PARSER_NODE_INT_TYPE_I16;
+  } else if (strnEqualsCaseInsensitive(end - U16_SIZE, U16, U16_SIZE)) {
+    return PARSER_NODE_INT_TYPE_U16;
+  } else if (strnEqualsCaseInsensitive(end - I32_SIZE, I32, I32_SIZE)) {
+    return PARSER_NODE_INT_TYPE_I32;
+  } else if (strnEqualsCaseInsensitive(end - U32_SIZE, U32, U32_SIZE)) {
+    return PARSER_NODE_INT_TYPE_U32;
+  } else if (strnEqualsCaseInsensitive(end - I64_SIZE, I64, I64_SIZE)) {
+    return PARSER_NODE_INT_TYPE_I64;
+  } else if (strnEqualsCaseInsensitive(end - U64_SIZE, U64, U64_SIZE)) {
+    return PARSER_NODE_INT_TYPE_U64;
+  } else {
+    return PARSER_NODE_INT_TYPE_UNKNOWN;
+  }
+}
+
+size_t getIntTypeSize(ParserNodeIntType type) {
+  switch (type) {
+  case PARSER_NODE_INT_TYPE_UNKNOWN:
+    return 0;
+  case PARSER_NODE_INT_TYPE_I8:
+  case PARSER_NODE_INT_TYPE_U8:
+    return 2;
+  case PARSER_NODE_INT_TYPE_I16:
+  case PARSER_NODE_INT_TYPE_U16:
+  case PARSER_NODE_INT_TYPE_I32:
+  case PARSER_NODE_INT_TYPE_U32:
+  case PARSER_NODE_INT_TYPE_I64:
+  case PARSER_NODE_INT_TYPE_U64:
+    return 3;
+  }
+  UNREACHABLE;
+}
diff --git a/src/compiler/parser.h b/src/compiler/parser.h
index fd40078..3f69454 100644
--- a/src/compiler/parser.h
+++ b/src/compiler/parser.h
@@ -176,7 +176,22 @@ typedef struct ParserNodeFunctionCall {
 
 typedef ParserNode ParserNodeSingleChildMetadata;
 
-typedef u64 ParserNodeIntMetadata;
+typedef enum ParserNodeIntType {
+  PARSER_NODE_INT_TYPE_UNKNOWN,
+  PARSER_NODE_INT_TYPE_I8,
+  PARSER_NODE_INT_TYPE_U8,
+  PARSER_NODE_INT_TYPE_I16,
+  PARSER_NODE_INT_TYPE_U16,
+  PARSER_NODE_INT_TYPE_I32,
+  PARSER_NODE_INT_TYPE_U32,
+  PARSER_NODE_INT_TYPE_I64,
+  PARSER_NODE_INT_TYPE_U64,
+} ParserNodeIntType;
+
+typedef struct ParserNodeIntMetadata {
+  u64 value;
+  ParserNodeIntType type;
+} ParserNodeIntMetadata;
 
 typedef f128 ParserNodeFloatMetadata;
 
@@ -293,3 +308,6 @@ bool isType(ParserNode *node);
 bool isValue(ParserNode *node);
 
 char escapeChar(char const *begin, char const *end, bool *success);
+
+ParserNodeIntType getIntType(char const *begin, char const *end);
+size_t getIntTypeSize(ParserNodeIntType type);