generators/wraith.y

@@ -113,9 +113,13 @@ BaseType                : VOID
                         {
                             $$ = MakePrimitiveTypeNode(MemoryAddress);
                         }
+                        | Identifier GenericArgumentClauseNonEmpty
+                        {
+                            $$ = MakeConcreteGenericTypeNode($1, $2);
+                        }
                         | Identifier
                         {
-                            $$ = MakeCustomTypeNode(yytext);
+                            $$ = MakeCustomTypeNode($1);
                         }
                         | REFERENCE LESS_THAN Type GREATER_THAN
                         {
@@ -157,6 +161,30 @@ Number                  : NUMBER
                             $$ = MakeNumberNode(yytext);
                         }
 
+FieldInit               : Identifier COLON Expression
+                        {
+                            $$ = MakeFieldInitNode($1, $3);
+                        }
+
+StructInitFields        : FieldInit
+                        {
+                            $$ = StartStructInitFieldsNode($1);
+                        }
+                        | StructInitFields COMMA FieldInit
+                        {
+                            $$ = AddFieldInitNode($1, $3);
+                        }
+                        |
+                        {
+                            $$ = MakeEmptyFieldInitNode();
+                        }
+                        ;
+
+StructInitExpression    : Type LEFT_BRACE StructInitFields RIGHT_BRACE
+                        {
+                            $$ = MakeStructInitExpressionNode($1, $3);
+                        }
+
 PrimaryExpression       : Number
                         | STRING_LITERAL
                         {
@@ -168,6 +196,7 @@ PrimaryExpression       : Number
                         }
                         | FunctionCallExpression
                         | AccessExpression
+                        | StructInitExpression
                         ;
 
 UnaryExpression         : BANG Expression
@@ -290,11 +319,11 @@ Statements              : Statement
                             $$ = AddStatement($1, $2);
                         }
 
-Arguments               : PrimaryExpression
+Arguments               : Expression
                         {
                             $$ = StartFunctionArgumentSequenceNode($1);
                         }
-                        | Arguments COMMA PrimaryExpression
+                        | Arguments COMMA Expression
                         {
                             $$ = AddFunctionArgumentNode($1, $3);
                         }
@@ -359,11 +388,13 @@ GenericArguments        : GenericArgument
                             $$ = AddGenericArgument($1, $3);
                         }
 
-
-GenericArgumentClause   : LESS_THAN GenericArguments GREATER_THAN
+GenericArgumentClauseNonEmpty   : LESS_THAN GenericArguments GREATER_THAN
                                 {
                                     $$ = $2;
                                 }
+                                ;
+
+GenericArgumentClause   : GenericArgumentClauseNonEmpty
                         |
                         {
                             $$ = MakeEmptyGenericArgumentsNode();

generic.w

@@ -14,9 +14,24 @@ struct MemoryBlock<T>
 	start: MemoryAddress;
 	capacity: uint;
 
-	AddressOf(count: uint): MemoryAddress
+	AddressOf(index: uint): MemoryAddress
     {
-        return start + (count * @sizeof<T>());
+        return start + (index * @sizeof<T>());
+    }
+
+    Get(index: uint): T
+    {
+        return @dereference<T>(AddressOf(index));
+    }
+
+    Set(index: uint, value: T): void
+    {
+        @memcpy(AddressOf(index), @addr(value), @sizeof<T>());
+    }
+
+    Free(): void
+    {
+        @free(start);
     }
 }
 
@@ -24,8 +39,21 @@ struct Program {
     static Main(): int {
         x: int = 4;
         y: int = Foo.Func(x);
-        addr: MemoryAddress = @malloc(y);
-        @free(addr);
-        return x;
+        block: MemoryBlock<int> = MemoryBlock<int>
+        {
+            capacity: y,
+            start: @malloc(y * @sizeof<int>())
+        };
+        block.Set(0, 5);
+        block.Set(1, 3);
+        block.Set(2, 9);
+        block.Set(3, 100);
+        Console.PrintLine("%p", block.start);
+        Console.PrintLine("%i", block.Get(0));
+        Console.PrintLine("%i", block.Get(1));
+        Console.PrintLine("%i", block.Get(2));
+        Console.PrintLine("%i", block.Get(3));
+        block.Free();
+        return 0;
     }
 }

src/ast.c

@@ -19,6 +19,8 @@ const char *SyntaxKindString(SyntaxKind syntaxKind)
         return "BinaryExpression";
     case Comment:
         return "Comment";
+    case ConcreteGenericTypeNode:
+        return "ConcreteGenericTypeNode";
     case CustomTypeNode:
         return "CustomTypeNode";
     case Declaration:
@@ -27,6 +29,8 @@ const char *SyntaxKindString(SyntaxKind syntaxKind)
         return "ForLoop";
     case DeclarationSequence:
         return "DeclarationSequence";
+    case FieldInit:
+        return "FieldInit";
     case FunctionArgumentSequence:
         return "FunctionArgumentSequence";
     case FunctionCallExpression:
@@ -71,6 +75,10 @@ const char *SyntaxKindString(SyntaxKind syntaxKind)
         return "StringLiteral";
     case StructDeclaration:
         return "StructDeclaration";
+    case StructInit:
+        return "StructInit";
+    case StructInitFields:
+        return "StructInitFields";
     case SystemCall:
         return "SystemCall";
     case Type:
@@ -95,11 +103,12 @@ Node *MakePrimitiveTypeNode(PrimitiveType type)
     return node;
 }
 
-Node *MakeCustomTypeNode(char *name)
+Node *MakeCustomTypeNode(Node *identifierNode)
 {
     Node *node = (Node *)malloc(sizeof(Node));
     node->syntaxKind = CustomTypeNode;
-    node->customType.name = strdup(name);
+    node->customType.name = strdup(identifierNode->identifier.name);
+    free(identifierNode);
     return node;
 }
 
@@ -111,6 +120,18 @@ Node *MakeReferenceTypeNode(Node *typeNode)
     return node;
 }
 
+Node *MakeConcreteGenericTypeNode(
+    Node *identifierNode,
+    Node *genericArgumentsNode)
+{
+    Node *node = (Node *)malloc(sizeof(Node));
+    node->syntaxKind = ConcreteGenericTypeNode;
+    node->concreteGenericType.name = strdup(identifierNode->identifier.name);
+    node->concreteGenericType.genericArguments = genericArgumentsNode;
+    free(identifierNode);
+    return node;
+}
+
 Node *MakeTypeNode(Node *typeNode)
 {
     Node *node = (Node *)malloc(sizeof(Node));
@@ -542,6 +563,55 @@ Node *MakeForLoopNode(
     return node;
 }
 
+Node *MakeFieldInitNode(Node *identifierNode, Node *expressionNode)
+{
+    Node *node = (Node *)malloc(sizeof(Node));
+    node->syntaxKind = FieldInit;
+    node->fieldInit.identifier = identifierNode;
+    node->fieldInit.expression = expressionNode;
+    return node;
+}
+
+Node *StartStructInitFieldsNode(Node *fieldInitNode)
+{
+    Node *node = (Node *)malloc(sizeof(Node));
+    node->syntaxKind = StructInitFields;
+    node->structInitFields.fieldInits = (Node **)malloc(sizeof(Node *));
+    node->structInitFields.fieldInits[0] = fieldInitNode;
+    node->structInitFields.count = 1;
+    return node;
+}
+
+Node *AddFieldInitNode(Node *structInitFieldsNode, Node *fieldInitNode)
+{
+    structInitFieldsNode->structInitFields.fieldInits = realloc(
+        structInitFieldsNode->structInitFields.fieldInits,
+        sizeof(Node *) * (structInitFieldsNode->structInitFields.count + 1));
+    structInitFieldsNode->structInitFields
+        .fieldInits[structInitFieldsNode->structInitFields.count] =
+        fieldInitNode;
+    structInitFieldsNode->structInitFields.count += 1;
+    return structInitFieldsNode;
+}
+
+Node *MakeEmptyFieldInitNode()
+{
+    Node *node = (Node *)malloc(sizeof(Node));
+    node->syntaxKind = StructInitFields;
+    node->structInitFields.fieldInits = NULL;
+    node->structInitFields.count = 0;
+    return node;
+}
+
+Node *MakeStructInitExpressionNode(Node *typeNode, Node *structInitFieldsNode)
+{
+    Node *node = (Node *)malloc(sizeof(Node));
+    node->syntaxKind = StructInit;
+    node->structInit.type = typeNode;
+    node->structInit.initFields = structInitFieldsNode;
+    return node;
+}
+
 static const char *PrimitiveTypeToString(PrimitiveType type)
 {
     switch (type)
@@ -624,6 +694,11 @@ void PrintNode(Node *node, uint32_t tabCount)
         PrintNode(node->binaryExpression.right, tabCount + 1);
         return;
 
+    case ConcreteGenericTypeNode:
+        printf("%s\n", node->concreteGenericType.name);
+        PrintNode(node->concreteGenericType.genericArguments, tabCount + 1);
+        return;
+
     case CustomTypeNode:
         printf("%s\n", node->customType.name);
         return;
@@ -642,6 +717,12 @@ void PrintNode(Node *node, uint32_t tabCount)
         }
         return;
 
+    case FieldInit:
+        printf("\n");
+        PrintNode(node->fieldInit.identifier, tabCount + 1);
+        PrintNode(node->fieldInit.expression, tabCount + 1);
+        return;
+
     case ForLoop:
         printf("\n");
         PrintNode(node->forLoop.declaration, tabCount + 1);
@@ -797,6 +878,20 @@ void PrintNode(Node *node, uint32_t tabCount)
         PrintNode(node->structDeclaration.declarationSequence, tabCount + 1);
         return;
 
+    case StructInit:
+        printf("\n");
+        PrintNode(node->structInit.type, tabCount + 1);
+        PrintNode(node->structInit.initFields, tabCount + 1);
+        return;
+
+    case StructInitFields:
+        printf("\n");
+        for (i = 0; i < node->structInitFields.count; i += 1)
+        {
+            PrintNode(node->structInitFields.fieldInits[i], tabCount + 1);
+        }
+        return;
+
     case SystemCall:
         printf("\n");
         PrintNode(node->systemCall.identifier, tabCount + 1);
@@ -843,6 +938,10 @@ void Recurse(Node *node, void (*func)(Node *))
     case Comment:
         return;
 
+    case ConcreteGenericTypeNode:
+        func(node->concreteGenericType.genericArguments);
+        return;
+
     case CustomTypeNode:
         return;
 
@@ -858,6 +957,11 @@ void Recurse(Node *node, void (*func)(Node *))
         }
         return;
 
+    case FieldInit:
+        func(node->fieldInit.identifier);
+        func(node->fieldInit.expression);
+        return;
+
     case ForLoop:
         func(node->forLoop.declaration);
         func(node->forLoop.startNumber);
@@ -979,6 +1083,18 @@ void Recurse(Node *node, void (*func)(Node *))
         func(node->structDeclaration.declarationSequence);
         return;
 
+    case StructInit:
+        func(node->structInit.type);
+        func(node->structInit.initFields);
+        return;
+
+    case StructInitFields:
+        for (i = 0; i < node->structInitFields.count; i += 1)
+        {
+            func(node->structInitFields.fieldInits[i]);
+        }
+        return;
+
     case SystemCall:
         func(node->systemCall.identifier);
         func(node->systemCall.argumentSequence);
@@ -1004,6 +1120,8 @@ void Recurse(Node *node, void (*func)(Node *))
 
 TypeTag *MakeTypeTag(Node *node)
 {
+    uint32_t i;
+
     if (node == NULL)
     {
         fprintf(
@@ -1034,6 +1152,28 @@ TypeTag *MakeTypeTag(Node *node)
         tag->value.customType = strdup(node->customType.name);
         break;
 
+    case ConcreteGenericTypeNode:
+        tag->type = ConcreteGeneric;
+        tag->value.concreteGenericType.name =
+            strdup(node->concreteGenericType.name);
+        tag->value.concreteGenericType.genericArgumentCount =
+            node->concreteGenericType.genericArguments->genericArguments.count;
+        tag->value.concreteGenericType.genericArguments = malloc(
+            sizeof(TypeTag *) *
+            tag->value.concreteGenericType.genericArgumentCount);
+
+        for (i = 0;
+             i <
+             node->concreteGenericType.genericArguments->genericArguments.count;
+             i += 1)
+        {
+            tag->value.concreteGenericType.genericArguments[i] = MakeTypeTag(
+                node->concreteGenericType.genericArguments->genericArguments
+                    .arguments[i]
+                    ->genericArgument.type);
+        }
+        break;
+
     case Declaration:
         tag = MakeTypeTag(node->declaration.type);
         break;
@@ -1078,6 +1218,8 @@ TypeTag *MakeTypeTag(Node *node)
 
 char *TypeTagToString(TypeTag *tag)
 {
+    uint32_t i;
+
     if (tag == NULL)
     {
         fprintf(
@@ -1114,6 +1256,64 @@ char *TypeTagToString(TypeTag *tag)
         sprintf(result, "Generic<%s>", tag->value.genericType);
         return result;
     }
+
+    case ConcreteGeneric:
+    {
+        char *result = strdup(tag->value.concreteGenericType.name);
+        uint32_t len = strlen(result);
+        len += 2;
+        result = realloc(result, sizeof(char) * len);
+        strcat(result, "<");
+
+        for (i = 0; i < tag->value.concreteGenericType.genericArgumentCount;
+             i += 1)
+        {
+            char *inner = TypeTagToString(
+                tag->value.concreteGenericType.genericArguments[i]);
+            len += strlen(inner);
+            result = realloc(result, sizeof(char) * (len + 3));
+            if (i != tag->value.concreteGenericType.genericArgumentCount - 1)
+            {
+                strcat(result, ", ");
+            }
+            strcat(result, inner);
+        }
+        result = realloc(result, sizeof(char) * (len + 1));
+        strcat(result, ">");
+        return result;
+    }
+    }
+}
+
+uint8_t TypeTagEqual(TypeTag *typeTagA, TypeTag *typeTagB)
+{
+    if (typeTagA->type != typeTagB->type)
+    {
+        return 0;
+    }
+
+    switch (typeTagA->type)
+    {
+    case Primitive:
+        return typeTagA->value.primitiveType == typeTagB->value.primitiveType;
+
+    case Reference:
+        return TypeTagEqual(
+            typeTagA->value.referenceType,
+            typeTagB->value.referenceType);
+
+    case Custom:
+        return strcmp(typeTagA->value.customType, typeTagB->value.customType) ==
+               0;
+
+    case Generic:
+        return strcmp(
+                   typeTagA->value.genericType,
+                   typeTagB->value.genericType) == 0;
+
+    default:
+        fprintf(stderr, "Invalid type comparison!");
+        return 0;
     }
 }
 
@@ -1164,6 +1364,11 @@ void LinkParentPointers(Node *node, Node *prev)
         }
         return;
 
+    case FieldInit:
+        LinkParentPointers(node->fieldInit.identifier, node);
+        LinkParentPointers(node->fieldInit.expression, node);
+        return;
+
     case ForLoop:
         LinkParentPointers(node->forLoop.declaration, node);
         LinkParentPointers(node->forLoop.startNumber, node);
@@ -1288,6 +1493,18 @@ void LinkParentPointers(Node *node, Node *prev)
         LinkParentPointers(node->structDeclaration.declarationSequence, node);
         return;
 
+    case StructInit:
+        LinkParentPointers(node->structInit.type, node);
+        LinkParentPointers(node->structInit.initFields, node);
+        return;
+
+    case StructInitFields:
+        for (i = 0; i < node->structInitFields.count; i += 1)
+        {
+            LinkParentPointers(node->structInitFields.fieldInits[i], node);
+        }
+        return;
+
     case SystemCall:
         LinkParentPointers(node->systemCall.identifier, node);
         LinkParentPointers(node->systemCall.argumentSequence, node);

src/ast.h

@@ -19,9 +19,11 @@ typedef enum
     Assignment,
     BinaryExpression,
     Comment,
+    ConcreteGenericTypeNode,
     CustomTypeNode,
     Declaration,
     DeclarationSequence,
+    FieldInit,
     ForLoop,
     FunctionArgumentSequence,
     FunctionCallExpression,
@@ -46,6 +48,8 @@ typedef enum
     StaticModifier,
     StringLiteral,
     StructDeclaration,
+    StructInit,
+    StructInitFields,
     SystemCall,
     Type,
     UnaryExpression
@@ -86,7 +90,16 @@ typedef union
     BinaryOperator binaryOperator;
 } Operator;
 
-typedef struct TypeTag
+typedef struct TypeTag TypeTag;
+
+typedef struct ConcreteGenericTypeTag
+{
+    char *name;
+    TypeTag **genericArguments;
+    uint32_t genericArgumentCount;
+} ConcreteGenericTypeTag;
+
+struct TypeTag
 {
     enum Type
     {
@@ -94,7 +107,8 @@ typedef struct TypeTag
         Primitive,
         Reference,
         Custom,
-        Generic
+        Generic,
+        ConcreteGeneric
     } type;
     union
     {
@@ -106,8 +120,10 @@ typedef struct TypeTag
         char *customType;
         /* Valid when type = Generic. */
         char *genericType;
+        /* Valid when type = ConcreteGeneric */
+        ConcreteGenericTypeTag concreteGenericType;
     } value;
-} TypeTag;
+};
 
 typedef struct Node Node;
 
@@ -146,6 +162,12 @@ struct Node
 
         } comment;
 
+        struct
+        {
+            char *name;
+            Node *genericArguments;
+        } concreteGenericType;
+
         struct
         {
             char *name;
@@ -163,6 +185,12 @@ struct Node
             uint32_t count;
         } declarationSequence;
 
+        struct
+        {
+            Node *identifier;
+            Node *expression;
+        } fieldInit;
+
         struct
         {
             Node *declaration;
@@ -304,6 +332,18 @@ struct Node
             Node *genericDeclarations;
         } structDeclaration;
 
+        struct
+        {
+            Node *type;
+            Node *initFields;
+        } structInit;
+
+        struct
+        {
+            Node **fieldInits;
+            uint32_t count;
+        } structInitFields;
+
         struct
         {
             Node *identifier;
@@ -329,8 +369,11 @@ const char *SyntaxKindString(SyntaxKind syntaxKind);
 
 uint8_t IsPrimitiveType(Node *typeNode);
 Node *MakePrimitiveTypeNode(PrimitiveType type);
-Node *MakeCustomTypeNode(char *string);
+Node *MakeCustomTypeNode(Node *identifierNode);
 Node *MakeReferenceTypeNode(Node *typeNode);
+Node *MakeConcreteGenericTypeNode(
+    Node *identifierNode,
+    Node *genericArgumentsNode);
 Node *MakeTypeNode(Node *typeNode);
 Node *MakeIdentifierNode(const char *id);
 Node *MakeNumberNode(const char *numberString);
@@ -397,6 +440,11 @@ Node *MakeForLoopNode(
     Node *startNumberNode,
     Node *endNumberNode,
     Node *statementSequenceNode);
+Node *MakeFieldInitNode(Node *identifierNode, Node *expressionNode);
+Node *StartStructInitFieldsNode(Node *fieldInitNode);
+Node *AddFieldInitNode(Node *structInitFieldsNode, Node *fieldInitNode);
+Node *MakeEmptyFieldInitNode();
+Node *MakeStructInitExpressionNode(Node *typeNode, Node *structInitFieldsNode);
 
 void PrintNode(Node *node, uint32_t tabCount);
 const char *SyntaxKindString(SyntaxKind syntaxKind);
@@ -412,6 +460,7 @@ void LinkParentPointers(Node *node, Node *prev);
 
 TypeTag *MakeTypeTag(Node *node);
 char *TypeTagToString(TypeTag *tag);
+uint8_t TypeTagEqual(TypeTag *typeTagA, TypeTag *typeTagB);
 
 Node *LookupIdNode(Node *current, Node *prev, char *target);
 

src/util.c

@@ -5,7 +5,7 @@
 char *strdup(const char *s)
 {
     size_t slen = strlen(s);
-    char *result = (char *)malloc(slen + 1);
+    char *result = (char *)malloc(sizeof(char) * (slen + 1));
     if (result == NULL)
     {
         return NULL;
@@ -15,6 +15,15 @@ char *strdup(const char *s)
     return result;
 }
 
+char *w_strcat(char *s, char *s2)
+{
+    size_t slen = strlen(s);
+    size_t slen2 = strlen(s2);
+    s = realloc(s, sizeof(char) * (slen + slen2 + 1));
+    strcat(s, s2);
+    return s;
+}
+
 uint64_t str_hash(char *str)
 {
     uint64_t hash = 5381;

src/util.h

@@ -5,6 +5,7 @@
 #include <string.h>
 
 char *strdup(const char *s);
+char *w_strcat(char *s, char *s2);
 uint64_t str_hash(char *str);
 
 #endif /* WRAITH_UTIL_H */