cosmonaut
/
wraith-lang
1
0
Fork 1
Code Issues 3 Pull Requests Projects Releases Wiki Activity

Compare commits

base: cosmonaut:main
Branches Tags
cosmonaut:interfaces
cosmonaut:main
cosmonaut:ast_refactor
cosmonaut:generics
..
compare: cosmonaut:ast_refactor
Branches Tags
cosmonaut:interfaces
cosmonaut:main
cosmonaut:ast_refactor
cosmonaut:generics

No commits in common. "main" and "ast_refactor" have entirely different histories.
main ... ast_refact

18 changed files with 1375 additions and 4173 deletions
Show Stats Expand all files Collapse all files

166
.clang-format
View File

@ -1,166 +0,0 @@
---
Language: Cpp
# BasedOnStyle: LLVM
AccessModifierOffset: -2
AlignAfterOpenBracket: AlwaysBreak
AlignConsecutiveMacros: None
AlignConsecutiveAssignments: None
AlignConsecutiveBitFields: None
AlignConsecutiveDeclarations: None
AlignEscapedNewlines: Right
AlignOperands: Align
AlignTrailingComments: true
AllowAllArgumentsOnNextLine: false
AllowAllConstructorInitializersOnNextLine: true
AllowAllParametersOfDeclarationOnNextLine: false
AllowShortEnumsOnASingleLine: true
AllowShortBlocksOnASingleLine: Never
AllowShortCaseLabelsOnASingleLine: false
AllowShortFunctionsOnASingleLine: All
AllowShortLambdasOnASingleLine: All
AllowShortIfStatementsOnASingleLine: Never
AllowShortLoopsOnASingleLine: false
AlwaysBreakAfterDefinitionReturnType: None
AlwaysBreakAfterReturnType: None
AlwaysBreakBeforeMultilineStrings: false
AlwaysBreakTemplateDeclarations: MultiLine
AttributeMacros:
- __capability
BinPackArguments: false
BinPackParameters: false
BraceWrapping:
AfterCaseLabel: false
AfterClass: false
AfterControlStatement: Never
AfterEnum: false
AfterFunction: false
AfterNamespace: false
AfterObjCDeclaration: false
AfterStruct: false
AfterUnion: false
AfterExternBlock: false
BeforeCatch: false
BeforeElse: false
BeforeLambdaBody: false
BeforeWhile: false
IndentBraces: false
SplitEmptyFunction: true
SplitEmptyRecord: true
SplitEmptyNamespace: true
BreakBeforeBinaryOperators: None
BreakBeforeConceptDeclarations: true
BreakBeforeBraces: Allman
BreakBeforeInheritanceComma: false
BreakInheritanceList: BeforeColon
BreakBeforeTernaryOperators: true
BreakConstructorInitializersBeforeComma: false
BreakConstructorInitializers: BeforeColon
BreakAfterJavaFieldAnnotations: false
BreakStringLiterals: true
ColumnLimit: 80
CommentPragmas: '^ IWYU pragma:'
CompactNamespaces: false
ConstructorInitializerAllOnOneLineOrOnePerLine: false
ConstructorInitializerIndentWidth: 4
ContinuationIndentWidth: 4
Cpp11BracedListStyle: true
DeriveLineEnding: true
DerivePointerAlignment: false
DisableFormat: false
EmptyLineBeforeAccessModifier: LogicalBlock
ExperimentalAutoDetectBinPacking: false
FixNamespaceComments: true
ForEachMacros:
- foreach
- Q_FOREACH
- BOOST_FOREACH
StatementAttributeLikeMacros:
- Q_EMIT
IncludeBlocks: Preserve
IncludeCategories:
- Regex: '^"(llvm|llvm-c|clang|clang-c)/'
Priority: 2
SortPriority: 0
CaseSensitive: false
- Regex: '^(<|"(gtest|gmock|isl|json)/)'
Priority: 3
SortPriority: 0
CaseSensitive: false
- Regex: '.*'
Priority: 1
SortPriority: 0
CaseSensitive: false
IncludeIsMainRegex: '(Test)?$'
IncludeIsMainSourceRegex: ''
IndentCaseLabels: false
IndentCaseBlocks: false
IndentGotoLabels: true
IndentPPDirectives: None
IndentExternBlock: AfterExternBlock
IndentRequires: false
IndentWidth: 4
IndentWrappedFunctionNames: false
InsertTrailingCommas: None
JavaScriptQuotes: Leave
JavaScriptWrapImports: true
KeepEmptyLinesAtTheStartOfBlocks: true
MacroBlockBegin: ''
MacroBlockEnd: ''
MaxEmptyLinesToKeep: 1
NamespaceIndentation: None
ObjCBinPackProtocolList: Auto
ObjCBlockIndentWidth: 4
ObjCBreakBeforeNestedBlockParam: true
ObjCSpaceAfterProperty: false
ObjCSpaceBeforeProtocolList: true
PenaltyBreakAssignment: 2
PenaltyBreakBeforeFirstCallParameter: 19
PenaltyBreakComment: 300
PenaltyBreakFirstLessLess: 120
PenaltyBreakString: 1000
PenaltyBreakTemplateDeclaration: 10
PenaltyExcessCharacter: 1000000
PenaltyReturnTypeOnItsOwnLine: 1000000
PenaltyIndentedWhitespace: 0
PointerAlignment: Right
ReflowComments: true
SortIncludes: true
SortJavaStaticImport: Before
SortUsingDeclarations: true
SpaceAfterCStyleCast: false
SpaceAfterLogicalNot: false
SpaceAfterTemplateKeyword: true
SpaceBeforeAssignmentOperators: true
SpaceBeforeCaseColon: false
SpaceBeforeCpp11BracedList: false
SpaceBeforeCtorInitializerColon: true
SpaceBeforeInheritanceColon: true
SpaceBeforeParens: ControlStatements
SpaceAroundPointerQualifiers: Default
SpaceBeforeRangeBasedForLoopColon: true
SpaceInEmptyBlock: false
SpaceInEmptyParentheses: false
SpacesBeforeTrailingComments: 1
SpacesInAngles: false
SpacesInConditionalStatement: false
SpacesInContainerLiterals: true
SpacesInCStyleCastParentheses: false
SpacesInParentheses: false
SpacesInSquareBrackets: false
SpaceBeforeSquareBrackets: false
BitFieldColonSpacing: Both
Standard: Latest
StatementMacros:
- Q_UNUSED
- QT_REQUIRE_VERSION
TabWidth: 8
UseCRLF: false
UseTab: Never
WhitespaceSensitiveMacros:
- STRINGIZE
- PP_STRINGIZE
- BOOST_PP_STRINGIZE
- NS_SWIFT_NAME
- CF_SWIFT_NAME
...

6
CMakeLists.txt
View File

@ -41,14 +41,12 @@ add_executable(
# Source
src/ast.h
src/codegen.h
src/identcheck.h
src/parser.h
src/validation.h
src/util.h
src/ast.c
src/codegen.c
src/identcheck.c
src/parser.c
src/validation.c
src/util.c
src/main.c
# Generated code
${BISON_Parser_OUTPUTS}

13
access.w
View File

@ -1,13 +0,0 @@
struct G {
Foo(t: bool): bool {
return t;
}
}
struct Program {
static main(): int {
g: G = alloc G;
g.Foo(true);
return 0;
}
}

2
generators/wraith.lex
View File

@ -12,7 +12,6 @@
"double" return DOUBLE;
"string" return STRING;
"bool" return BOOL;
"MemoryAddress" return MEMORYADDRESS;
"struct" return STRUCT;
"return" return RETURN;
"static" return STATIC;
@ -41,7 +40,6 @@
";" return SEMICOLON;
":" return COLON;
"?" return QUESTION;
"@" return AT;
"(" return LEFT_PAREN;
")" return RIGHT_PAREN;
"[" return LEFT_BRACKET;

115
generators/wraith.y
View File

@ -25,7 +25,6 @@ extern FILE *yyin;
%token DOUBLE
%token STRING
%token BOOL
%token MEMORYADDRESS
%token STRUCT
%token RETURN
%token STATIC
@ -55,7 +54,6 @@ extern FILE *yyin;
%token SEMICOLON
%token COLON
%token QUESTION
%token AT
%token LEFT_PAREN
%token RIGHT_PAREN
%token LEFT_BRACE
@ -109,17 +107,9 @@ BaseType : VOID
{
$$ = MakePrimitiveTypeNode(Bool);
}
| MEMORYADDRESS
{
$$ = MakePrimitiveTypeNode(MemoryAddress);
}
| Identifier GenericArgumentClauseNonEmpty
{
$$ = MakeConcreteGenericTypeNode($1, $2);
}
| Identifier
{
$$ = MakeCustomTypeNode($1);
$$ = MakeCustomTypeNode(yytext);
}
| REFERENCE LESS_THAN Type GREATER_THAN
{
@ -151,40 +141,11 @@ AccessExpression : Identifier POINT AccessExpression
$$ = $1;
}
SystemCallExpression : AT Identifier
{
$$ = $2;
}
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
{
@ -196,7 +157,6 @@ PrimaryExpression : Number
}
| FunctionCallExpression
| AccessExpression
| StructInitExpression
;
UnaryExpression : BANG Expression
@ -270,13 +230,9 @@ ReturnStatement : RETURN Expression
$$ = MakeReturnVoidStatementNode();
}
FunctionCallExpression : AccessExpression GenericArgumentClause LEFT_PAREN Arguments RIGHT_PAREN
FunctionCallExpression : AccessExpression LEFT_PAREN Arguments RIGHT_PAREN
{
$$ = MakeFunctionCallExpressionNode($1, $4, $2);
}
| SystemCallExpression GenericArgumentClause LEFT_PAREN Arguments RIGHT_PAREN
{
$$ = MakeSystemCallExpressionNode($1, $4, $2);
$$ = MakeFunctionCallExpressionNode($1, $3);
}
PartialStatement : FunctionCallExpression
@ -319,11 +275,11 @@ Statements : Statement
$$ = AddStatement($1, $2);
}
Arguments : Expression
Arguments : PrimaryExpression
{
$$ = StartFunctionArgumentSequenceNode($1);
}
| Arguments COMMA Expression
| Arguments COMMA PrimaryExpression
{
$$ = AddFunctionArgumentNode($1, $3);
}
@ -351,63 +307,14 @@ Body : LEFT_BRACE Statements RIGHT_BRACE
$$ = $2;
}
GenericDeclaration : Identifier
FunctionSignature : Identifier LEFT_PAREN SignatureArguments RIGHT_PAREN COLON Type
{
$$ = MakeGenericDeclarationNode($1, NULL);
$$ = MakeFunctionSignatureNode($1, $6, $3, MakeFunctionModifiersNode(NULL, 0));
}
GenericDeclarations : GenericDeclaration
{
$$ = StartGenericDeclarationsNode($1);
}
| GenericDeclarations COMMA GenericDeclaration
{
$$ = AddGenericDeclaration($1, $3);
}
GenericDeclarationClause : LESS_THAN GenericDeclarations GREATER_THAN
{
$$ = $2;
}
|
{
$$ = MakeEmptyGenericDeclarationsNode();
}
GenericArgument : Type
{
$$ = MakeGenericArgumentNode($1);
}
GenericArguments : GenericArgument
{
$$ = StartGenericArgumentsNode($1);
}
| GenericArguments COMMA GenericArgument
{
$$ = AddGenericArgument($1, $3);
}
GenericArgumentClauseNonEmpty : LESS_THAN GenericArguments GREATER_THAN
{
$$ = $2;
}
;
GenericArgumentClause : GenericArgumentClauseNonEmpty
|
{
$$ = MakeEmptyGenericArgumentsNode();
}
FunctionSignature : Identifier GenericDeclarationClause LEFT_PAREN SignatureArguments RIGHT_PAREN COLON Type
{
$$ = MakeFunctionSignatureNode($1, $7, $4, MakeFunctionModifiersNode(NULL, 0), $2);
}
| STATIC Identifier GenericDeclarationClause LEFT_PAREN SignatureArguments RIGHT_PAREN COLON Type
| STATIC Identifier LEFT_PAREN SignatureArguments RIGHT_PAREN COLON Type
{
Node *modifier = MakeStaticNode();
$$ = MakeFunctionSignatureNode($2, $8, $5, MakeFunctionModifiersNode(&modifier, 1), $3);
$$ = MakeFunctionSignatureNode($2, $7, $4, MakeFunctionModifiersNode(&modifier, 1));
}
FunctionDeclaration : FunctionSignature Body
@ -415,9 +322,9 @@ FunctionDeclaration : FunctionSignature Body
$$ = MakeFunctionDeclarationNode($1, $2);
}
StructDeclaration : STRUCT Identifier GenericDeclarationClause LEFT_BRACE Declarations RIGHT_BRACE
StructDeclaration : STRUCT Identifier LEFT_BRACE Declarations RIGHT_BRACE
{
$$ = MakeStructDeclarationNode($2, $5, $3);
$$ = MakeStructDeclarationNode($2, $4);
}
Declaration : FunctionDeclaration

59
generic.w
View File

@ -1,59 +0,0 @@
struct Foo {
static Func2<U>(u: U) : U {
return u;
}
static Func<T>(t: T): T {
foo: T = t;
return Foo.Func2(foo);
}
}
struct MemoryBlock<T>
{
start: MemoryAddress;
capacity: uint;
AddressOf(index: uint): MemoryAddress
{
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);
}
}
struct Program {
static Main(): int {
x: int = 4;
y: int = Foo.Func(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;
}
}

15
ordering.w
View File

@ -1,15 +0,0 @@
struct Foo {
static Func(): void {
Func2();
}
static Func2(): void {
Func();
}
}
struct Program {
static main(): int {
return 0;
}
}

1142
src/ast.c
View File

File diff suppressed because it is too large Load Diff

257
src/ast.h
View File

@ -2,6 +2,7 @@
#define WRAITH_AST_H
#include <stdint.h>
#include "identcheck.h"
/* -Wpedantic nameless union/struct silencing */
#ifndef WRAITHNAMELESS
@ -19,11 +20,9 @@ typedef enum
Assignment,
BinaryExpression,
Comment,
ConcreteGenericTypeNode,
CustomTypeNode,
Declaration,
DeclarationSequence,
FieldInit,
ForLoop,
FunctionArgumentSequence,
FunctionCallExpression,
@ -31,11 +30,6 @@ typedef enum
FunctionModifiers,
FunctionSignature,
FunctionSignatureArguments,
GenericArgument,
GenericArguments,
GenericDeclaration,
GenericDeclarations,
GenericTypeNode,
Identifier,
IfStatement,
IfElseStatement,
@ -48,9 +42,6 @@ typedef enum
StaticModifier,
StringLiteral,
StructDeclaration,
StructInit,
StructInitFields,
SystemCall,
Type,
UnaryExpression
} SyntaxKind;
@ -80,8 +71,7 @@ typedef enum
UInt,
Float,
Double,
String,
MemoryAddress
String
} PrimitiveType;
typedef union
@ -90,25 +80,14 @@ typedef union
BinaryOperator binaryOperator;
} Operator;
typedef struct TypeTag TypeTag;
typedef struct ConcreteGenericTypeTag
{
char *name;
TypeTag **genericArguments;
uint32_t genericArgumentCount;
} ConcreteGenericTypeTag;
struct TypeTag
typedef struct TypeTag
{
enum Type
{
Unknown,
Primitive,
Reference,
Custom,
Generic,
ConcreteGeneric
Custom
} type;
union
{
@ -118,12 +97,8 @@ struct TypeTag
struct TypeTag *referenceType;
/* Valid when type = Custom. */
char *customType;
/* Valid when type = Generic. */
char *genericType;
/* Valid when type = ConcreteGeneric */
ConcreteGenericTypeTag concreteGenericType;
} value;
};
} TypeTag;
typedef struct Node Node;
@ -162,12 +137,6 @@ struct Node
} comment;
struct
{
char *name;
Node *genericArguments;
} concreteGenericType;
struct
{
char *name;
@ -185,12 +154,6 @@ struct Node
uint32_t count;
} declarationSequence;
struct
{
Node *identifier;
Node *expression;
} fieldInit;
struct
{
Node *declaration;
@ -209,7 +172,6 @@ struct Node
{
Node *identifier; /* FIXME: need better name */
Node *argumentSequence;
Node *genericArguments;
} functionCallExpression;
struct
@ -230,7 +192,6 @@ struct Node
Node *type;
Node *arguments;
Node *modifiers;
Node *genericDeclarations;
} functionSignature;
struct
@ -239,34 +200,6 @@ struct Node
uint32_t count;
} functionSignatureArguments;
struct
{
Node *type;
} genericArgument;
struct
{
Node **arguments;
uint32_t count;
} genericArguments;
struct
{
Node *identifier;
Node *constraint;
} genericDeclaration;
struct
{
Node **declarations;
uint32_t count;
} genericDeclarations;
struct
{
char *name;
} genericType;
struct
{
char *name;
@ -329,28 +262,8 @@ struct Node
{
Node *identifier;
Node *declarationSequence;
Node *genericDeclarations;
} structDeclaration;
struct
{
Node *type;
Node *initFields;
} structInit;
struct
{
Node **fieldInits;
uint32_t count;
} structInitFields;
struct
{
Node *identifier;
Node *argumentSequence;
Node *genericArguments;
} systemCall;
struct
{
Node *typeNode;
@ -363,74 +276,118 @@ struct Node
} unaryExpression;
};
TypeTag *typeTag;
IdNode *idLink;
};
const char* SyntaxKindString(SyntaxKind syntaxKind);
uint8_t IsPrimitiveType(Node *typeNode);
Node *MakePrimitiveTypeNode(PrimitiveType type);
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);
Node *MakeStringNode(const char *string);
Node* MakePrimitiveTypeNode(
PrimitiveType type
);
Node* MakeCustomTypeNode(
char *string
);
Node* MakeReferenceTypeNode(
Node *typeNode
);
Node* MakeTypeNode(
Node *typeNode /* can be primitive, custom, or reference */
);
Node* MakeIdentifierNode(
const char *id
);
Node* MakeNumberNode(
const char *numberString
);
Node* MakeStringNode(
const char *string
);
Node* MakeStaticNode();
Node *MakeFunctionModifiersNode(Node **pModifierNodes, uint32_t modifierCount);
Node *MakeUnaryNode(UnaryOperator operator, Node * child);
Node *MakeBinaryNode(BinaryOperator operator, Node * left, Node *right);
Node *MakeDeclarationNode(Node *typeNode, Node *identifierNode);
Node *MakeAssignmentNode(Node *left, Node *right);
Node *StartStatementSequenceNode(Node *statementNode);
Node *AddStatement(Node *statementSequenceNode, Node *statementNode);
Node *MakeReturnStatementNode(Node *expressionNode);
Node* MakeFunctionModifiersNode(
Node **pModifierNodes,
uint32_t modifierCount
);
Node* MakeUnaryNode(
UnaryOperator operator,
Node *child
);
Node* MakeBinaryNode(
BinaryOperator operator,
Node *left,
Node *right
);
Node* MakeDeclarationNode(
Node* typeNode,
Node* identifierNode
);
Node* MakeAssignmentNode(
Node *left,
Node *right
);
Node* StartStatementSequenceNode(
Node* statementNode
);
Node* AddStatement(
Node* statementSequenceNode,
Node *statementNode
);
Node* MakeReturnStatementNode(
Node *expressionNode
);
Node* MakeReturnVoidStatementNode();
Node *StartFunctionSignatureArgumentsNode(Node *argumentNode);
Node *AddFunctionSignatureArgumentNode(Node *argumentsNode, Node *argumentNode);
Node* StartFunctionSignatureArgumentsNode(
Node *argumentNode
);
Node* AddFunctionSignatureArgumentNode(
Node *argumentsNode,
Node *argumentNode
);
Node *MakeEmptyFunctionSignatureArgumentsNode();
Node* MakeFunctionSignatureNode(
Node *identifierNode,
Node* typeNode,
Node* argumentsNode,
Node *modifiersNode,
Node *genericArgumentsNode);
Node* modifiersNode
);
Node* MakeFunctionDeclarationNode(
Node* functionSignatureNode,
Node *functionBodyNode);
Node *MakeGenericDeclarationNode(Node *identifierNode, Node *constraintNode);
Node *MakeEmptyGenericDeclarationsNode();
Node *StartGenericDeclarationsNode(Node *genericDeclarationNode);
Node *AddGenericDeclaration(
Node *genericDeclarationsNode,
Node *genericDeclarationNode);
Node *MakeGenericArgumentNode(Node *typeNode);
Node *MakeEmptyGenericArgumentsNode();
Node *StartGenericArgumentsNode(Node *genericArgumentNode);
Node *AddGenericArgument(Node *genericArgumentsNode, Node *genericArgumentNode);
Node *MakeGenericTypeNode(char *name);
Node* functionBodyNode
);
Node* MakeStructDeclarationNode(
Node *identifierNode,
Node *declarationSequenceNode
);
Node* StartDeclarationSequenceNode(
Node *declarationNode
);
Node* AddDeclarationNode(
Node *declarationSequenceNode,
Node *genericArgumentsNode);
Node *StartDeclarationSequenceNode(Node *declarationNode);
Node *AddDeclarationNode(Node *declarationSequenceNode, Node *declarationNode);
Node *StartFunctionArgumentSequenceNode(Node *argumentNode);
Node *AddFunctionArgumentNode(Node *argumentSequenceNode, Node *argumentNode);
Node *declarationNode
);
Node *StartFunctionArgumentSequenceNode(
Node *argumentNode
);
Node *AddFunctionArgumentNode(
Node *argumentSequenceNode,
Node *argumentNode
);
Node *MakeEmptyFunctionArgumentSequenceNode();
Node* MakeFunctionCallExpressionNode(
Node *identifierNode,
Node *argumentSequenceNode,
Node *genericArgumentsNode);
Node *MakeSystemCallExpressionNode(
Node *identifierNode,
Node *argumentSequenceNode,
Node *genericArgumentsNode);
Node *MakeAccessExpressionNode(Node *accessee, Node *accessor);
Node *MakeAllocNode(Node *typeNode);
Node *MakeIfNode(Node *expressionNode, Node *statementSequenceNode);
Node *argumentSequenceNode
);
Node* MakeAccessExpressionNode(
Node *accessee,
Node *accessor
);
Node* MakeAllocNode(
Node *typeNode
);
Node* MakeIfNode(
Node *expressionNode,
Node *statementSequenceNode
);
Node* MakeIfElseNode(
Node *ifNode,
Node *elseNode /* can be a conditional or a statement sequence */
@ -439,29 +396,13 @@ Node *MakeForLoopNode(
Node *identifierNode,
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);
Node *statementSequenceNode
);
void PrintNode(Node *node, uint32_t tabCount);
const char* SyntaxKindString(SyntaxKind syntaxKind);
/* Helper function for applying a void function generically over the children of
* an AST node. Used for functions that need to traverse the entire tree but
* only perform operations on a subset of node types. Such functions can match
* the syntaxKinds relevant to their purpose and invoke this function in all
* other cases. */
void Recurse(Node *node, void (*func)(Node *));
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);
#endif /* WRAITH_AST_H */

2031
src/codegen.c
View File

File diff suppressed because it is too large Load Diff

379
src/identcheck.c Normal file
View File

@ -0,0 +1,379 @@
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
#include "ast.h"
#include "identcheck.h"
IdNode* MakeIdNode(NodeType type, char *name, IdNode *parent) {
IdNode *node = (IdNode*)malloc(sizeof(IdNode));
node->type = type;
node->name = strdup(name);
node->parent = parent;
node->childCount = 0;
node->childCapacity = 0;
node->children = NULL;
node->typeTag = NULL;
return node;
}
void AddChildToNode(IdNode *node, IdNode *child) {
if (child == NULL) return;
if (node->children == NULL) {
node->childCapacity = 2;
node->children = (IdNode**) malloc(sizeof(IdNode*) * node->childCapacity);
} else if (node->childCount == node->childCapacity) {
node->childCapacity *= 2;
node->children = (IdNode**) realloc(node->children, sizeof(IdNode*) * node->childCapacity);
}
node->children[node->childCount] = child;
node->childCount += 1;
}
IdNode* MakeIdTree(Node *astNode, IdNode *parent) {
uint32_t i;
IdNode *mainNode;
switch (astNode->syntaxKind) {
case AccessExpression:
AddChildToNode(parent, MakeIdTree(astNode->accessExpression.accessee, parent));
AddChildToNode(parent, MakeIdTree(astNode->accessExpression.accessor, parent));
return NULL;
case AllocExpression:
AddChildToNode(parent, MakeIdTree(astNode->allocExpression.type, parent));
return NULL;
case Assignment: {
if (astNode->assignmentStatement.left->syntaxKind == Declaration) {
return MakeIdTree(astNode->assignmentStatement.left, parent);
} else {
AddChildToNode(parent, MakeIdTree(astNode->assignmentStatement.left, parent));
AddChildToNode(parent, MakeIdTree(astNode->assignmentStatement.right, parent));
return NULL;
}
}
case BinaryExpression:
AddChildToNode(parent, MakeIdTree(astNode->binaryExpression.left, parent));
AddChildToNode(parent, MakeIdTree(astNode->binaryExpression.right, parent));
return NULL;
case Declaration: {
Node *idNode = astNode->declaration.identifier;
mainNode = MakeIdNode(Variable, idNode->identifier.name, parent);
mainNode->typeTag = MakeTypeTag(astNode);
idNode->typeTag = mainNode->typeTag;
break;
}
case DeclarationSequence: {
mainNode = MakeIdNode(UnorderedScope, "", parent);
for (i = 0; i < astNode->declarationSequence.count; i++) {
AddChildToNode(
mainNode, MakeIdTree(astNode->declarationSequence.sequence[i], mainNode));
}
break;
}
case ForLoop: {
Node *loopDecl = astNode->forLoop.declaration;
Node *loopBody = astNode->forLoop.statementSequence;
mainNode = MakeIdNode(OrderedScope, "for-loop", parent);
AddChildToNode(mainNode, MakeIdTree(loopDecl, mainNode));
AddChildToNode(mainNode, MakeIdTree(loopBody, mainNode));
break;
}
case FunctionArgumentSequence:
for (i = 0; i < astNode->functionArgumentSequence.count; i++) {
AddChildToNode(
parent, MakeIdTree(astNode->functionArgumentSequence.sequence[i], parent));
}
return NULL;
case FunctionCallExpression:
AddChildToNode(parent, MakeIdTree(astNode->functionCallExpression.identifier, parent));
AddChildToNode(
parent, MakeIdTree(astNode->functionCallExpression.argumentSequence, parent));
return NULL;
case FunctionDeclaration: {
Node *sigNode = astNode->functionDeclaration.functionSignature;
Node *idNode = sigNode->functionSignature.identifier;
char *funcName = idNode->identifier.name;
mainNode = MakeIdNode(Function, funcName, parent);
mainNode->typeTag = MakeTypeTag(astNode);
idNode->typeTag = mainNode->typeTag;
MakeIdTree(sigNode->functionSignature.arguments, mainNode);
MakeIdTree(astNode->functionDeclaration.functionBody, mainNode);
break;
}
case FunctionSignatureArguments: {
for (i = 0; i < astNode->functionSignatureArguments.count; i++) {
Node *argNode = astNode->functionSignatureArguments.sequence[i];
AddChildToNode(parent, MakeIdTree(argNode, parent));
}
return NULL;
}
case Identifier: {
char *name = astNode->identifier.name;
mainNode = MakeIdNode(Placeholder, name, parent);
IdNode *lookupNode = LookupId(mainNode, NULL, name);
if (lookupNode == NULL) {
fprintf(stderr, "wraith: Could not find IdNode for id %s\n", name);
TypeTag *tag = (TypeTag*)malloc(sizeof(TypeTag));
tag->type = Unknown;
astNode->typeTag = tag;
} else {
astNode->typeTag = lookupNode->typeTag;
}
break;
}
case IfStatement: {
Node *clause = astNode->ifStatement.expression;
Node *stmtSeq = astNode->ifStatement.statementSequence;
mainNode = MakeIdNode(OrderedScope, "if", parent);
MakeIdTree(clause, mainNode);
MakeIdTree(stmtSeq, mainNode);
break;
}
case IfElseStatement: {
Node *ifNode = astNode->ifElseStatement.ifStatement;
Node *elseStmts = astNode->ifElseStatement.elseStatement;
mainNode = MakeIdNode(OrderedScope, "if-else", parent);
IdNode *ifBranch = MakeIdTree(ifNode, mainNode);
AddChildToNode(mainNode, ifBranch);
IdNode *elseScope = MakeIdNode(OrderedScope, "else", mainNode);
MakeIdTree(elseStmts, elseScope);
AddChildToNode(mainNode, elseScope);
break;
}
case ReferenceTypeNode:
AddChildToNode(parent, MakeIdTree(astNode->referenceType.type, parent));
return NULL;
case Return:
AddChildToNode(parent, MakeIdTree(astNode->returnStatement.expression, parent));
return NULL;
case StatementSequence: {
for (i = 0; i < astNode->statementSequence.count; i++) {
Node *argNode = astNode->statementSequence.sequence[i];
AddChildToNode(parent, MakeIdTree(argNode, parent));
}
return NULL;
}
case StructDeclaration: {
Node *idNode = astNode->structDeclaration.identifier;
Node *declsNode = astNode->structDeclaration.declarationSequence;
mainNode = MakeIdNode(Struct, idNode->identifier.name, parent);
mainNode->typeTag = MakeTypeTag(astNode);
for (i = 0; i < declsNode->declarationSequence.count; i++) {
Node *decl = declsNode->declarationSequence.sequence[i];
AddChildToNode(mainNode, MakeIdTree(decl, mainNode));
}
break;
}
case Type:
AddChildToNode(parent, MakeIdTree(astNode->type.typeNode, parent));
return NULL;
case UnaryExpression:
AddChildToNode(parent, MakeIdTree(astNode->unaryExpression.child, parent));
return NULL;
case Comment:
case CustomTypeNode:
case FunctionModifiers:
case FunctionSignature:
case Number:
case PrimitiveTypeNode:
case ReturnVoid:
case StaticModifier:
case StringLiteral:
return NULL;
}
astNode->idLink = mainNode;
return mainNode;
}
void PrintIdNode(IdNode *node) {
if (node == NULL) {
fprintf(stderr, "wraith: Attempted to call PrintIdNode with null value.\n");
return;
}
switch(node->type) {
case Placeholder:
printf("Placeholder (%s)\n", node->name);
break;
case OrderedScope:
printf("OrderedScope (%s)\n", node->name);
break;
case UnorderedScope:
printf("UnorderedScope (%s)\n", node->name);
break;
case Struct:
printf("%s : %s\n", node->name, TypeTagToString(node->typeTag));
break;
case Function:
printf("%s : Function<%s>\n", node->name, TypeTagToString(node->typeTag));
break;
case Variable:
printf("%s : %s\n", node->name, TypeTagToString(node->typeTag));
break;
}
}
void PrintIdTree(IdNode *tree, uint32_t tabCount) {
if (tree == NULL) {
fprintf(stderr, "wraith: Attempted to call PrintIdTree on a null value.\n");
return;
}
uint32_t i;
for (i = 0; i < tabCount; i++) {
printf("| ");
}
PrintIdNode(tree);
for (i = 0; i < tree->childCount; i++) {
PrintIdTree(tree->children[i], tabCount + 1);
}
}
int PrintAncestors(IdNode *node) {
if (node == NULL) return -1;
int i;
int indent = 1;
indent += PrintAncestors(node->parent);
for (i = 0; i < indent; i++) {
printf(" ");
}
PrintIdNode(node);
return indent;
}
IdNode* LookdownId(IdNode *root, NodeType targetType, char *targetName) {
if (root == NULL) {
fprintf(stderr, "wraith: Attempted to call LookdownId on a null value.\n");
return NULL;
}
IdNode *result = NULL;
IdNode **frontier = (IdNode**)malloc(sizeof(IdNode*));
frontier[0] = root;
uint32_t frontierCount = 1;
while (frontierCount > 0) {
IdNode *current = frontier[0];
if (current->type == targetType && strcmp(current->name, targetName) == 0) {
result = current;
break;
}
uint32_t i;
for(i = 1; i < frontierCount; i++) {
frontier[i-1] = frontier[i];
}
size_t newSize = frontierCount + current->childCount - 1;
if (frontierCount != newSize) {
frontier = (IdNode**) realloc(frontier, sizeof(IdNode*) * newSize);
}
for (i = 0; i < current->childCount; i++) {
frontier[frontierCount + i - 1] = current->children[i];
}
frontierCount = newSize;
}
free(frontier);
return result;
}
bool ScopeHasOrdering(IdNode *node) {
switch (node->type) {
case OrderedScope:
case Function:
case Variable: /* this is only technically true */
return true;
default:
return false;
}
}
IdNode* LookupId(IdNode *node, IdNode *prev, char *target) {
if (node == NULL) {
return NULL;
}
if (strcmp(node->name, target) == 0 && node->type != Placeholder) {
return node;
}
/* If this is the start of our search, we should not attempt to look at child nodes. Only
* looking up the scope tree is valid at this point.
*
* This has the notable side-effect that this function will return NULL if you attempt to look
* up a struct's internals starting from the node representing the struct itself. This is
* because an IdNode corresponds to the location *where an identifier is first declared.* Thus,
* an identifier has no knowledge of identifiers declared "inside" of it.
*/
if (prev == NULL) {
return LookupId(node->parent, node, target);
}
/* If the current node forms an ordered scope then we want to prevent ourselves from looking
* up identifiers declared after the scope we have just come from.
*/
uint32_t idxLimit;
if (ScopeHasOrdering(node)) {
uint32_t i;
for (i = 0, idxLimit = 0; i < node->childCount; i++, idxLimit++) {
if (node->children[i] == prev) {
break;
}
}
} else {
idxLimit = node->childCount;
}
uint32_t i;
for (i = 0; i < idxLimit; i++) {
IdNode *child = node->children[i];
if (child == prev || child->type == Placeholder) {
/* Do not inspect the node we just came from or placeholders. */
continue;
}
if (strcmp(child->name, target) == 0) {
return child;
}
if (child->type == Struct) {
uint32_t j;
for (j = 0; j < child->childCount; j++) {
IdNode *grandchild = child->children[j];
if (strcmp(grandchild->name, target) == 0) {
return grandchild;
}
}
}
}
return LookupId(node->parent, node, target);
}

46
src/identcheck.h Normal file
View File

@ -0,0 +1,46 @@
/* Validates identifier usage in an AST. */
#ifndef WRAITH_IDENTCHECK_H
#define WRAITH_IDENTCHECK_H
#include <stdint.h>
#include "ast.h"
struct TypeTag;
struct Node;
typedef enum NodeType {
Placeholder,
UnorderedScope,
OrderedScope,
Struct,
Function,
Variable
} NodeType;
typedef struct IdNode {
NodeType type;
char *name;
struct TypeTag *typeTag;
struct IdNode *parent;
struct IdNode **children;
uint32_t childCount;
uint32_t childCapacity;
} IdNode;
typedef struct IdStatus {
enum StatusCode {
Valid,
} StatusCode;
} IdStatus;
IdNode* MakeIdTree(struct Node *astNode, IdNode *parent);
void PrintIdNode(IdNode *node);
void PrintIdTree(IdNode *tree, uint32_t tabCount);
int PrintAncestors(IdNode *node);
IdNode* LookdownId(IdNode *root, NodeType targetType, char *targetName);
IdNode* LookupId(IdNode *node, IdNode *prev, char* target);
#endif /* WRAITH_IDENTCHECK_H */

49
src/main.c
View File

@ -1,9 +1,9 @@
#include "../lib/dropt/dropt.h"
#include <stdlib.h>
#include "../lib/dropt/dropt.h"
#include "codegen.h"
#include "parser.h"
#include "validation.h"
#include "codegen.h"
#include "identcheck.h"
int main(int argc, char *argv[])
{
@ -14,26 +14,9 @@ int main(int argc, char *argv[])
int exitCode = EXIT_SUCCESS;
dropt_option options[] = {
{'h',
"help",
"Shows help.",
NULL,
dropt_handle_bool,
&showHelp,
dropt_attr_halt},
{'v',
"parse-verbose",
"Shows verbose parser output.",
NULL,
dropt_handle_bool,
&parseVerbose},
{'O',
"optimize",
"Sets optimization level of the output IR. Must be a value between 0 "
"and 3.",
"number",
dropt_handle_uint,
&optimizationLevel},
{ 'h', "help", "Shows help.", NULL, dropt_handle_bool, &showHelp, dropt_attr_halt },
{ 'v', "parse-verbose", "Shows verbose parser output.", NULL, dropt_handle_bool, &parseVerbose },
{ 'O', "optimize", "Sets optimization level of the output IR. Must be a value between 0 and 3.", "number", dropt_handle_uint, &optimizationLevel },
{ 0 } /* Required sentinel value. */
};
@ -53,10 +36,7 @@ int main(int argc, char *argv[])
char** rest = dropt_parse(droptContext, -1, &argv[1]);
if (dropt_get_error(droptContext) != dropt_error_none)
{
fprintf(
stderr,
"wraith: %s\n",
dropt_get_error_message(droptContext));
fprintf(stderr, "wraith: %s\n", dropt_get_error_message(droptContext));
exitCode = EXIT_FAILURE;
}
else if (showHelp)
@ -85,15 +65,12 @@ int main(int argc, char *argv[])
}
else
{
LinkParentPointers(rootNode, NULL);
/* FIXME: ValidateIdentifiers should return some sort of
error status object. */
ValidateIdentifiers(rootNode);
TagIdentifierTypes(rootNode);
ConvertCustomsToGenerics(rootNode);
PrintNode(rootNode, 0);
printf("Beginning codegen.\n");
{
IdNode *idTree = MakeIdTree(rootNode, NULL);
PrintIdTree(idTree, /*tabCount=*/0);
printf("\n");
PrintNode(rootNode, /*tabCount=*/0);
}
exitCode = Codegen(rootNode, optimizationLevel);
}
}

2
src/parser.c
View File

@ -1,7 +1,7 @@
#include <stdio.h>
#include "ast.h"
#include "y.tab.h"
#include "ast.h"
extern FILE *yyin;
extern int yydebug;

26
src/util.c
View File

@ -1,11 +1,11 @@
#include "util.h"
#include <stdlib.h>
#include <string.h>
char* strdup (const char* s)
{
size_t slen = strlen(s);
char *result = (char *)malloc(sizeof(char) * (slen + 1));
char* result = malloc(slen + 1);
if(result == NULL)
{
return NULL;
@ -14,25 +14,3 @@ char *strdup(const char *s)
memcpy(result, s, slen+1);
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;
size_t c;
while ((c = *str++))
{
hash = ((hash << 5) + hash) + c; /* hash * 33 + c */
}
return hash;
}

3
src/util.h
View File

@ -1,11 +1,8 @@
#ifndef WRAITH_UTIL_H
#define WRAITH_UTIL_H
#include <stdint.h>
#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 */

493
src/validation.c
View File

@ -1,493 +0,0 @@
#include "validation.h"
#include <stdbool.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
Node *GetIdFromStruct(Node *structDecl)
{
if (structDecl->syntaxKind != StructDeclaration)
{
fprintf(
stderr,
"wraith: Attempted to call GetIdFromStruct on node with kind: "
"%s.\n",
SyntaxKindString(structDecl->syntaxKind));
return NULL;
}
return structDecl->structDeclaration.identifier;
}
Node *GetIdFromFunction(Node *funcDecl)
{
if (funcDecl->syntaxKind != FunctionDeclaration)
{
fprintf(
stderr,
"wraith: Attempted to call GetIdFromFunction on node with kind: "
"%s.\n",
SyntaxKindString(funcDecl->syntaxKind));
return NULL;
}
Node *sig = funcDecl->functionDeclaration.functionSignature;
return sig->functionSignature.identifier;
}
Node *GetIdFromDeclaration(Node *decl)
{
if (decl->syntaxKind != Declaration)
{
fprintf(
stderr,
"wraith: Attempted to call GetIdFromDeclaration on node with kind: "
"%s.\n",
SyntaxKindString(decl->syntaxKind));
}
return decl->declaration.identifier;
}
bool AssignmentHasDeclaration(Node *assign)
{
return (
assign->syntaxKind == Assignment &&
assign->assignmentStatement.left->syntaxKind == Declaration);
}
Node *GetIdFromAssignment(Node *assign)
{
if (assign->syntaxKind != Assignment)
{
fprintf(
stderr,
"wraith: Attempted to call GetIdFromAssignment on node with kind: "
"%s.\n",
SyntaxKindString(assign->syntaxKind));
}
if (AssignmentHasDeclaration(assign))
{
return GetIdFromDeclaration(assign->assignmentStatement.left);
}
return NULL;
}
bool NodeMayHaveId(Node *node)
{
switch (node->syntaxKind)
{
case StructDeclaration:
case FunctionDeclaration:
case Declaration:
case Assignment:
return true;
default:
return false;
}
}
Node *TryGetId(Node *node)
{
switch (node->syntaxKind)
{
case Assignment:
return GetIdFromAssignment(node);
case Declaration:
return GetIdFromDeclaration(node);
case FunctionDeclaration:
return GetIdFromFunction(node);
case StructDeclaration:
return GetIdFromStruct(node);
default:
return NULL;
}
}
Node *LookupFunctionArgId(Node *funcDecl, char *target)
{
Node *args = funcDecl->functionDeclaration.functionSignature
->functionSignature.arguments;
uint32_t i;
for (i = 0; i < args->functionArgumentSequence.count; i += 1)
{
Node *arg = args->functionArgumentSequence.sequence[i];
if (arg->syntaxKind != Declaration)
{
fprintf(
stderr,
"wraith: Encountered %s node in function signature args "
"list.\n",
SyntaxKindString(arg->syntaxKind));
continue;
}
Node *argId = GetIdFromDeclaration(arg);
if (argId != NULL && strcmp(target, argId->identifier.name) == 0)
return argId;
}
return NULL;
}
Node *LookupStructInternalId(Node *structDecl, char *target)
{
Node *decls = structDecl->structDeclaration.declarationSequence;
uint32_t i;
for (i = 0; i < decls->declarationSequence.count; i += 1)
{
Node *match = TryGetId(decls->declarationSequence.sequence[i]);
if (match != NULL && strcmp(target, match->identifier.name) == 0)
return match;
}
return NULL;
}
Node *InspectNode(Node *node, char *target)
{
/* If this node may have an identifier declaration inside it, attempt to
* look up the identifier
* node itself, returning it if it matches the given target name. */
if (NodeMayHaveId(node))
{
Node *candidateId = TryGetId(node);
if (candidateId != NULL &&
strcmp(target, candidateId->identifier.name) == 0)
return candidateId;
}
/* If the candidate node was not the one we wanted, but the node node is a
* function declaration, it's possible that the identifier we want is one of
* the function's parameters rather than the function's name itself. */
if (node->syntaxKind == FunctionDeclaration)
{
Node *match = LookupFunctionArgId(node, target);
if (match != NULL)
return match;
}
/* Likewise if the node node is a struct declaration, inspect the struct's
* internals
* to see if a top-level definition is the one we're looking for. */
if (node->syntaxKind == StructDeclaration)
{
Node *match = LookupStructInternalId(node, target);
if (match != NULL)
return match;
}
return NULL;
}
/* FIXME: Handle staged lookups for AccessExpressions. */
/* FIXME: Similar to above, disallow inspection of struct internals outside of
* AccessExpressions. */
Node *LookupId(Node *current, Node *prev, char *target)
{
if (current == NULL)
return NULL;
Node *match;
/* First inspect the current node to see if it contains the target
* identifier. */
match = InspectNode(current, target);
if (match != NULL)
return match;
/* If this is the start of our search, we should not attempt to look at
* child nodes. Only looking up the AST is valid at this point.
*
* This has the notable side-effect that this function will return NULL if
* you attempt to look up a struct's internals starting from the node
* representing the struct itself. The same is true for functions. */
if (prev == NULL)
return LookupId(current->parent, current, target);
uint32_t i;
uint32_t idxLimit;
switch (current->syntaxKind)
{
case DeclarationSequence:
for (i = 0; i < current->declarationSequence.count; i += 1)
{
Node *decl = current->declarationSequence.sequence[i];
match = InspectNode(decl, target);
if (match != NULL)
return match;
}
break;
case StatementSequence:
idxLimit = current->statementSequence.count;
for (i = 0; i < current->statementSequence.count; i += 1)
{
if (current->statementSequence.sequence[i] == prev)
{
idxLimit = i;
break;
}
}
for (i = 0; i < idxLimit; i += 1)
{
Node *stmt = current->statementSequence.sequence[i];
if (stmt == prev)
break;
match = InspectNode(stmt, target);
if (match != NULL)
return match;
}
break;
}
return LookupId(current->parent, current, target);
}
/* FIXME: This function should be extended to handle multi-stage ID lookups for
* AccessExpression nodes. */
/* FIXME: Make this function return an error status object of some kind.
* A non-OK status should halt compilation. */
void ValidateIdentifiers(Node *node)
{
if (node == NULL)
return;
/* Skip over generic arguments. They contain Identifiers but are not
* actually identifiers, they declare types. */
if (node->syntaxKind == GenericDeclarations)
return;
if (node->syntaxKind != Identifier)
{
Recurse(node, *ValidateIdentifiers);
return;
}
char *name = node->identifier.name;
Node *decl = LookupId(node, NULL, name);
if (decl == NULL)
{
/* FIXME: Express this case as an error with AST information, see the
* FIXME comment above. */
fprintf(
stderr,
"wraith: Could not find definition of identifier %s.\n",
name);
}
}
/* FIXME: This function should be extended to handle multi-stage ID lookups for
* AccessExpression nodes. */
void TagIdentifierTypes(Node *node)
{
if (node == NULL)
return;
switch (node->syntaxKind)
{
case AllocExpression:
node->typeTag = MakeTypeTag(node);
break;
case Declaration:
node->declaration.identifier->typeTag = MakeTypeTag(node);
break;
case FunctionDeclaration:
node->functionDeclaration.functionSignature->functionSignature
.identifier->typeTag = MakeTypeTag(node);
break;
case StructDeclaration:
node->structDeclaration.identifier->typeTag = MakeTypeTag(node);
break;
case GenericDeclaration:
node->genericDeclaration.identifier->typeTag = MakeTypeTag(node);
break;
case Type:
node->typeTag = MakeTypeTag(node);
break;
case Identifier:
{
if (node->typeTag != NULL)
return;
char *name = node->identifier.name;
Node *declaration = LookupId(node, NULL, name);
/* FIXME: Remove this case once ValidateIdentifiers returns error status
* info and halts compilation. See ValidateIdentifiers FIXME. */
if (declaration == NULL)
{
TypeTag *tag = (TypeTag *)malloc(sizeof(TypeTag));
tag->type = Unknown;
node->typeTag = tag;
}
else
{
node->typeTag = declaration->typeTag;
}
break;
}
}
Recurse(node, *TagIdentifierTypes);
}
Node *LookupType(Node *current, char *target)
{
if (current == NULL)
return NULL;
switch (current->syntaxKind)
{
/* If we've encountered a function declaration, check to see if it's generic
* and, if so, if one of its type parameters is the target. */
case FunctionDeclaration:
{
Node *typeArgs = current->functionDeclaration.functionSignature
->functionSignature.genericDeclarations;
uint32_t i;
for (i = 0; i < typeArgs->genericDeclarations.count; i += 1)
{
Node *arg = typeArgs->genericDeclarations.declarations[i];
Node *argId = arg->genericDeclaration.identifier;
char *argName = argId->identifier.name;
/* note: return the GenericDeclaration, not the Identifier, so that
* the caller can differentiate between generics and customs. */
if (strcmp(target, argName) == 0)
{
return arg;
}
}
return LookupType(current->parent, target);
}
case StructDeclaration:
{
uint32_t i;
Node *typeArgs = current->structDeclaration.genericDeclarations;
for (i = 0; i < typeArgs->genericDeclarations.count; i += 1)
{
Node *arg = typeArgs->genericDeclarations.declarations[i];
Node *argId = arg->genericDeclaration.identifier;
char *argName = argId->identifier.name;
/* note: return the GenericDeclaration, not the Identifier, so that
* the caller can differentiate between generics and customs. */
if (strcmp(target, argName) == 0)
{
return arg;
}
}
Node *structId = GetIdFromStruct(current);
if (strcmp(target, structId->identifier.name) == 0)
{
return structId;
}
return LookupType(current->parent, target);
}
/* If we encounter a declaration sequence, search each of its children for
* struct definitions in case one of them is the target. */
case DeclarationSequence:
{
uint32_t i;
for (i = 0; i < current->declarationSequence.count; i += 1)
{
Node *decl = current->declarationSequence.sequence[i];
if (decl->syntaxKind == StructDeclaration)
{
Node *structId = GetIdFromStruct(decl);
if (strcmp(target, structId->identifier.name) == 0)
return structId;
}
}
return LookupType(current->parent, target);
}
default:
return LookupType(current->parent, target);
}
}
/* FIXME: This function should be modified to handle type parameters over
* structs. */
void ConvertCustomsToGenerics(Node *node)
{
if (node == NULL)
return;
switch (node->syntaxKind)
{
case Declaration:
{
Node *id = node->declaration.identifier;
Node *type = node->declaration.type->type.typeNode;
if (type->syntaxKind == CustomTypeNode)
{
char *target = id->typeTag->value.customType;
Node *typeLookup = LookupType(node, target);
if (typeLookup != NULL &&
typeLookup->syntaxKind == GenericDeclaration)
{
id->typeTag->type = Generic;
free(node->declaration.type);
node->declaration.type =
MakeGenericTypeNode(id->typeTag->value.genericType);
}
}
break;
}
case FunctionSignature:
{
Node *id = node->functionSignature.identifier;
Node *type = node->functionSignature.type->type.typeNode;
if (type->syntaxKind == CustomTypeNode)
{
char *target = id->typeTag->value.customType;
Node *typeLookup = LookupType(node, target);
if (typeLookup != NULL &&
typeLookup->syntaxKind == GenericDeclaration)
{
id->typeTag->type = Generic;
free(node->functionSignature.type);
node->functionSignature.type =
MakeGenericTypeNode(id->typeTag->value.genericType);
}
}
break;
}
case GenericArgument:
{
Node *typeNode = node->genericArgument.type;
if (typeNode->typeTag->type == Custom)
{
char *target = typeNode->typeTag->value.customType;
Node *typeLookup = LookupType(node, target);
if (typeLookup != NULL &&
typeLookup->syntaxKind == GenericDeclaration)
{
typeNode->typeTag->type = Generic;
}
}
break;
}
}
Recurse(node, *ConvertCustomsToGenerics);
}

10
src/validation.h
View File

@ -1,10 +0,0 @@
#ifndef WRAITH_VALIDATION_H
#define WRAITH_VALIDATION_H
#include "ast.h"
void ValidateIdentifiers(Node *node);
void TagIdentifierTypes(Node *node);
void ConvertCustomsToGenerics(Node *node);
#endif /* WRAITH_VALIDATION_H */