Compare commits
No commits in common. "main" and "ast_refactor" have entirely different histories.
main
...
ast_refact
166
.clang-format
166
.clang-format
|
|
@ -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
|
|
||||||
...
|
|
||||||
|
|
||||||
|
|
@ -41,14 +41,12 @@ add_executable(
|
||||||
# Source
|
# Source
|
||||||
src/ast.h
|
src/ast.h
|
||||||
src/codegen.h
|
src/codegen.h
|
||||||
|
src/identcheck.h
|
||||||
src/parser.h
|
src/parser.h
|
||||||
src/validation.h
|
|
||||||
src/util.h
|
|
||||||
src/ast.c
|
src/ast.c
|
||||||
src/codegen.c
|
src/codegen.c
|
||||||
|
src/identcheck.c
|
||||||
src/parser.c
|
src/parser.c
|
||||||
src/validation.c
|
|
||||||
src/util.c
|
|
||||||
src/main.c
|
src/main.c
|
||||||
# Generated code
|
# Generated code
|
||||||
${BISON_Parser_OUTPUTS}
|
${BISON_Parser_OUTPUTS}
|
||||||
|
|
|
||||||
13
access.w
13
access.w
|
|
@ -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;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
@ -54,8 +54,6 @@ struct Program
|
||||||
myStruct.myInt = 4;
|
myStruct.myInt = 4;
|
||||||
}
|
}
|
||||||
|
|
||||||
Console.PrintLine("%i", myStruct.myInt);
|
return myStruct.myInt;
|
||||||
|
|
||||||
return 0;
|
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -12,7 +12,6 @@
|
||||||
"double" return DOUBLE;
|
"double" return DOUBLE;
|
||||||
"string" return STRING;
|
"string" return STRING;
|
||||||
"bool" return BOOL;
|
"bool" return BOOL;
|
||||||
"MemoryAddress" return MEMORYADDRESS;
|
|
||||||
"struct" return STRUCT;
|
"struct" return STRUCT;
|
||||||
"return" return RETURN;
|
"return" return RETURN;
|
||||||
"static" return STATIC;
|
"static" return STATIC;
|
||||||
|
|
@ -41,7 +40,6 @@
|
||||||
";" return SEMICOLON;
|
";" return SEMICOLON;
|
||||||
":" return COLON;
|
":" return COLON;
|
||||||
"?" return QUESTION;
|
"?" return QUESTION;
|
||||||
"@" return AT;
|
|
||||||
"(" return LEFT_PAREN;
|
"(" return LEFT_PAREN;
|
||||||
")" return RIGHT_PAREN;
|
")" return RIGHT_PAREN;
|
||||||
"[" return LEFT_BRACKET;
|
"[" return LEFT_BRACKET;
|
||||||
|
|
|
||||||
|
|
@ -25,7 +25,6 @@ extern FILE *yyin;
|
||||||
%token DOUBLE
|
%token DOUBLE
|
||||||
%token STRING
|
%token STRING
|
||||||
%token BOOL
|
%token BOOL
|
||||||
%token MEMORYADDRESS
|
|
||||||
%token STRUCT
|
%token STRUCT
|
||||||
%token RETURN
|
%token RETURN
|
||||||
%token STATIC
|
%token STATIC
|
||||||
|
|
@ -55,7 +54,6 @@ extern FILE *yyin;
|
||||||
%token SEMICOLON
|
%token SEMICOLON
|
||||||
%token COLON
|
%token COLON
|
||||||
%token QUESTION
|
%token QUESTION
|
||||||
%token AT
|
|
||||||
%token LEFT_PAREN
|
%token LEFT_PAREN
|
||||||
%token RIGHT_PAREN
|
%token RIGHT_PAREN
|
||||||
%token LEFT_BRACE
|
%token LEFT_BRACE
|
||||||
|
|
@ -109,17 +107,9 @@ BaseType : VOID
|
||||||
{
|
{
|
||||||
$$ = MakePrimitiveTypeNode(Bool);
|
$$ = MakePrimitiveTypeNode(Bool);
|
||||||
}
|
}
|
||||||
| MEMORYADDRESS
|
|
||||||
{
|
|
||||||
$$ = MakePrimitiveTypeNode(MemoryAddress);
|
|
||||||
}
|
|
||||||
| Identifier GenericArgumentClauseNonEmpty
|
|
||||||
{
|
|
||||||
$$ = MakeConcreteGenericTypeNode($1, $2);
|
|
||||||
}
|
|
||||||
| Identifier
|
| Identifier
|
||||||
{
|
{
|
||||||
$$ = MakeCustomTypeNode($1);
|
$$ = MakeCustomTypeNode(yytext);
|
||||||
}
|
}
|
||||||
| REFERENCE LESS_THAN Type GREATER_THAN
|
| REFERENCE LESS_THAN Type GREATER_THAN
|
||||||
{
|
{
|
||||||
|
|
@ -151,40 +141,11 @@ AccessExpression : Identifier POINT AccessExpression
|
||||||
$$ = $1;
|
$$ = $1;
|
||||||
}
|
}
|
||||||
|
|
||||||
SystemCallExpression : AT Identifier
|
|
||||||
{
|
|
||||||
$$ = $2;
|
|
||||||
}
|
|
||||||
|
|
||||||
Number : NUMBER
|
Number : NUMBER
|
||||||
{
|
{
|
||||||
$$ = MakeNumberNode(yytext);
|
$$ = 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
|
PrimaryExpression : Number
|
||||||
| STRING_LITERAL
|
| STRING_LITERAL
|
||||||
{
|
{
|
||||||
|
|
@ -196,7 +157,6 @@ PrimaryExpression : Number
|
||||||
}
|
}
|
||||||
| FunctionCallExpression
|
| FunctionCallExpression
|
||||||
| AccessExpression
|
| AccessExpression
|
||||||
| StructInitExpression
|
|
||||||
;
|
;
|
||||||
|
|
||||||
UnaryExpression : BANG Expression
|
UnaryExpression : BANG Expression
|
||||||
|
|
@ -270,13 +230,9 @@ ReturnStatement : RETURN Expression
|
||||||
$$ = MakeReturnVoidStatementNode();
|
$$ = MakeReturnVoidStatementNode();
|
||||||
}
|
}
|
||||||
|
|
||||||
FunctionCallExpression : AccessExpression GenericArgumentClause LEFT_PAREN Arguments RIGHT_PAREN
|
FunctionCallExpression : AccessExpression LEFT_PAREN Arguments RIGHT_PAREN
|
||||||
{
|
{
|
||||||
$$ = MakeFunctionCallExpressionNode($1, $4, $2);
|
$$ = MakeFunctionCallExpressionNode($1, $3);
|
||||||
}
|
|
||||||
| SystemCallExpression GenericArgumentClause LEFT_PAREN Arguments RIGHT_PAREN
|
|
||||||
{
|
|
||||||
$$ = MakeSystemCallExpressionNode($1, $4, $2);
|
|
||||||
}
|
}
|
||||||
|
|
||||||
PartialStatement : FunctionCallExpression
|
PartialStatement : FunctionCallExpression
|
||||||
|
|
@ -319,11 +275,11 @@ Statements : Statement
|
||||||
$$ = AddStatement($1, $2);
|
$$ = AddStatement($1, $2);
|
||||||
}
|
}
|
||||||
|
|
||||||
Arguments : Expression
|
Arguments : PrimaryExpression
|
||||||
{
|
{
|
||||||
$$ = StartFunctionArgumentSequenceNode($1);
|
$$ = StartFunctionArgumentSequenceNode($1);
|
||||||
}
|
}
|
||||||
| Arguments COMMA Expression
|
| Arguments COMMA PrimaryExpression
|
||||||
{
|
{
|
||||||
$$ = AddFunctionArgumentNode($1, $3);
|
$$ = AddFunctionArgumentNode($1, $3);
|
||||||
}
|
}
|
||||||
|
|
@ -351,63 +307,14 @@ Body : LEFT_BRACE Statements RIGHT_BRACE
|
||||||
$$ = $2;
|
$$ = $2;
|
||||||
}
|
}
|
||||||
|
|
||||||
GenericDeclaration : Identifier
|
FunctionSignature : Identifier LEFT_PAREN SignatureArguments RIGHT_PAREN COLON Type
|
||||||
{
|
{
|
||||||
$$ = MakeGenericDeclarationNode($1, NULL);
|
$$ = MakeFunctionSignatureNode($1, $6, $3, MakeFunctionModifiersNode(NULL, 0));
|
||||||
}
|
}
|
||||||
|
| STATIC Identifier LEFT_PAREN SignatureArguments RIGHT_PAREN COLON Type
|
||||||
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
|
|
||||||
{
|
{
|
||||||
Node *modifier = MakeStaticNode();
|
Node *modifier = MakeStaticNode();
|
||||||
$$ = MakeFunctionSignatureNode($2, $8, $5, MakeFunctionModifiersNode(&modifier, 1), $3);
|
$$ = MakeFunctionSignatureNode($2, $7, $4, MakeFunctionModifiersNode(&modifier, 1));
|
||||||
}
|
}
|
||||||
|
|
||||||
FunctionDeclaration : FunctionSignature Body
|
FunctionDeclaration : FunctionSignature Body
|
||||||
|
|
@ -415,9 +322,9 @@ FunctionDeclaration : FunctionSignature Body
|
||||||
$$ = MakeFunctionDeclarationNode($1, $2);
|
$$ = 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
|
Declaration : FunctionDeclaration
|
||||||
|
|
|
||||||
59
generic.w
59
generic.w
|
|
@ -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
15
ordering.w
|
|
@ -1,15 +0,0 @@
|
||||||
struct Foo {
|
|
||||||
static Func(): void {
|
|
||||||
Func2();
|
|
||||||
}
|
|
||||||
|
|
||||||
static Func2(): void {
|
|
||||||
Func();
|
|
||||||
}
|
|
||||||
}
|
|
||||||
|
|
||||||
struct Program {
|
|
||||||
static main(): int {
|
|
||||||
return 0;
|
|
||||||
}
|
|
||||||
}
|
|
||||||
289
src/ast.h
289
src/ast.h
|
|
@ -2,6 +2,7 @@
|
||||||
#define WRAITH_AST_H
|
#define WRAITH_AST_H
|
||||||
|
|
||||||
#include <stdint.h>
|
#include <stdint.h>
|
||||||
|
#include "identcheck.h"
|
||||||
|
|
||||||
/* -Wpedantic nameless union/struct silencing */
|
/* -Wpedantic nameless union/struct silencing */
|
||||||
#ifndef WRAITHNAMELESS
|
#ifndef WRAITHNAMELESS
|
||||||
|
|
@ -19,11 +20,9 @@ typedef enum
|
||||||
Assignment,
|
Assignment,
|
||||||
BinaryExpression,
|
BinaryExpression,
|
||||||
Comment,
|
Comment,
|
||||||
ConcreteGenericTypeNode,
|
|
||||||
CustomTypeNode,
|
CustomTypeNode,
|
||||||
Declaration,
|
Declaration,
|
||||||
DeclarationSequence,
|
DeclarationSequence,
|
||||||
FieldInit,
|
|
||||||
ForLoop,
|
ForLoop,
|
||||||
FunctionArgumentSequence,
|
FunctionArgumentSequence,
|
||||||
FunctionCallExpression,
|
FunctionCallExpression,
|
||||||
|
|
@ -31,11 +30,6 @@ typedef enum
|
||||||
FunctionModifiers,
|
FunctionModifiers,
|
||||||
FunctionSignature,
|
FunctionSignature,
|
||||||
FunctionSignatureArguments,
|
FunctionSignatureArguments,
|
||||||
GenericArgument,
|
|
||||||
GenericArguments,
|
|
||||||
GenericDeclaration,
|
|
||||||
GenericDeclarations,
|
|
||||||
GenericTypeNode,
|
|
||||||
Identifier,
|
Identifier,
|
||||||
IfStatement,
|
IfStatement,
|
||||||
IfElseStatement,
|
IfElseStatement,
|
||||||
|
|
@ -48,9 +42,6 @@ typedef enum
|
||||||
StaticModifier,
|
StaticModifier,
|
||||||
StringLiteral,
|
StringLiteral,
|
||||||
StructDeclaration,
|
StructDeclaration,
|
||||||
StructInit,
|
|
||||||
StructInitFields,
|
|
||||||
SystemCall,
|
|
||||||
Type,
|
Type,
|
||||||
UnaryExpression
|
UnaryExpression
|
||||||
} SyntaxKind;
|
} SyntaxKind;
|
||||||
|
|
@ -80,8 +71,7 @@ typedef enum
|
||||||
UInt,
|
UInt,
|
||||||
Float,
|
Float,
|
||||||
Double,
|
Double,
|
||||||
String,
|
String
|
||||||
MemoryAddress
|
|
||||||
} PrimitiveType;
|
} PrimitiveType;
|
||||||
|
|
||||||
typedef union
|
typedef union
|
||||||
|
|
@ -90,25 +80,14 @@ typedef union
|
||||||
BinaryOperator binaryOperator;
|
BinaryOperator binaryOperator;
|
||||||
} Operator;
|
} Operator;
|
||||||
|
|
||||||
typedef struct TypeTag TypeTag;
|
typedef struct TypeTag
|
||||||
|
|
||||||
typedef struct ConcreteGenericTypeTag
|
|
||||||
{
|
|
||||||
char *name;
|
|
||||||
TypeTag **genericArguments;
|
|
||||||
uint32_t genericArgumentCount;
|
|
||||||
} ConcreteGenericTypeTag;
|
|
||||||
|
|
||||||
struct TypeTag
|
|
||||||
{
|
{
|
||||||
enum Type
|
enum Type
|
||||||
{
|
{
|
||||||
Unknown,
|
Unknown,
|
||||||
Primitive,
|
Primitive,
|
||||||
Reference,
|
Reference,
|
||||||
Custom,
|
Custom
|
||||||
Generic,
|
|
||||||
ConcreteGeneric
|
|
||||||
} type;
|
} type;
|
||||||
union
|
union
|
||||||
{
|
{
|
||||||
|
|
@ -118,12 +97,8 @@ struct TypeTag
|
||||||
struct TypeTag *referenceType;
|
struct TypeTag *referenceType;
|
||||||
/* Valid when type = Custom. */
|
/* Valid when type = Custom. */
|
||||||
char *customType;
|
char *customType;
|
||||||
/* Valid when type = Generic. */
|
|
||||||
char *genericType;
|
|
||||||
/* Valid when type = ConcreteGeneric */
|
|
||||||
ConcreteGenericTypeTag concreteGenericType;
|
|
||||||
} value;
|
} value;
|
||||||
};
|
} TypeTag;
|
||||||
|
|
||||||
typedef struct Node Node;
|
typedef struct Node Node;
|
||||||
|
|
||||||
|
|
@ -162,12 +137,6 @@ struct Node
|
||||||
|
|
||||||
} comment;
|
} comment;
|
||||||
|
|
||||||
struct
|
|
||||||
{
|
|
||||||
char *name;
|
|
||||||
Node *genericArguments;
|
|
||||||
} concreteGenericType;
|
|
||||||
|
|
||||||
struct
|
struct
|
||||||
{
|
{
|
||||||
char *name;
|
char *name;
|
||||||
|
|
@ -185,12 +154,6 @@ struct Node
|
||||||
uint32_t count;
|
uint32_t count;
|
||||||
} declarationSequence;
|
} declarationSequence;
|
||||||
|
|
||||||
struct
|
|
||||||
{
|
|
||||||
Node *identifier;
|
|
||||||
Node *expression;
|
|
||||||
} fieldInit;
|
|
||||||
|
|
||||||
struct
|
struct
|
||||||
{
|
{
|
||||||
Node *declaration;
|
Node *declaration;
|
||||||
|
|
@ -209,7 +172,6 @@ struct Node
|
||||||
{
|
{
|
||||||
Node *identifier; /* FIXME: need better name */
|
Node *identifier; /* FIXME: need better name */
|
||||||
Node *argumentSequence;
|
Node *argumentSequence;
|
||||||
Node *genericArguments;
|
|
||||||
} functionCallExpression;
|
} functionCallExpression;
|
||||||
|
|
||||||
struct
|
struct
|
||||||
|
|
@ -230,7 +192,6 @@ struct Node
|
||||||
Node *type;
|
Node *type;
|
||||||
Node *arguments;
|
Node *arguments;
|
||||||
Node *modifiers;
|
Node *modifiers;
|
||||||
Node *genericDeclarations;
|
|
||||||
} functionSignature;
|
} functionSignature;
|
||||||
|
|
||||||
struct
|
struct
|
||||||
|
|
@ -239,34 +200,6 @@ struct Node
|
||||||
uint32_t count;
|
uint32_t count;
|
||||||
} functionSignatureArguments;
|
} 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
|
struct
|
||||||
{
|
{
|
||||||
char *name;
|
char *name;
|
||||||
|
|
@ -329,28 +262,8 @@ struct Node
|
||||||
{
|
{
|
||||||
Node *identifier;
|
Node *identifier;
|
||||||
Node *declarationSequence;
|
Node *declarationSequence;
|
||||||
Node *genericDeclarations;
|
|
||||||
} structDeclaration;
|
} structDeclaration;
|
||||||
|
|
||||||
struct
|
|
||||||
{
|
|
||||||
Node *type;
|
|
||||||
Node *initFields;
|
|
||||||
} structInit;
|
|
||||||
|
|
||||||
struct
|
|
||||||
{
|
|
||||||
Node **fieldInits;
|
|
||||||
uint32_t count;
|
|
||||||
} structInitFields;
|
|
||||||
|
|
||||||
struct
|
|
||||||
{
|
|
||||||
Node *identifier;
|
|
||||||
Node *argumentSequence;
|
|
||||||
Node *genericArguments;
|
|
||||||
} systemCall;
|
|
||||||
|
|
||||||
struct
|
struct
|
||||||
{
|
{
|
||||||
Node *typeNode;
|
Node *typeNode;
|
||||||
|
|
@ -363,105 +276,133 @@ struct Node
|
||||||
} unaryExpression;
|
} unaryExpression;
|
||||||
};
|
};
|
||||||
TypeTag *typeTag;
|
TypeTag *typeTag;
|
||||||
|
IdNode *idLink;
|
||||||
};
|
};
|
||||||
|
|
||||||
const char *SyntaxKindString(SyntaxKind syntaxKind);
|
const char* SyntaxKindString(SyntaxKind syntaxKind);
|
||||||
|
|
||||||
uint8_t IsPrimitiveType(Node *typeNode);
|
uint8_t IsPrimitiveType(Node *typeNode);
|
||||||
Node *MakePrimitiveTypeNode(PrimitiveType type);
|
Node* MakePrimitiveTypeNode(
|
||||||
Node *MakeCustomTypeNode(Node *identifierNode);
|
PrimitiveType type
|
||||||
Node *MakeReferenceTypeNode(Node *typeNode);
|
);
|
||||||
Node *MakeConcreteGenericTypeNode(
|
Node* MakeCustomTypeNode(
|
||||||
Node *identifierNode,
|
char *string
|
||||||
Node *genericArgumentsNode);
|
);
|
||||||
Node *MakeTypeNode(Node *typeNode);
|
Node* MakeReferenceTypeNode(
|
||||||
Node *MakeIdentifierNode(const char *id);
|
Node *typeNode
|
||||||
Node *MakeNumberNode(const char *numberString);
|
);
|
||||||
Node *MakeStringNode(const char *string);
|
Node* MakeTypeNode(
|
||||||
Node *MakeStaticNode();
|
Node *typeNode /* can be primitive, custom, or reference */
|
||||||
Node *MakeFunctionModifiersNode(Node **pModifierNodes, uint32_t modifierCount);
|
);
|
||||||
Node *MakeUnaryNode(UnaryOperator operator, Node * child);
|
Node* MakeIdentifierNode(
|
||||||
Node *MakeBinaryNode(BinaryOperator operator, Node * left, Node *right);
|
const char *id
|
||||||
Node *MakeDeclarationNode(Node *typeNode, Node *identifierNode);
|
);
|
||||||
Node *MakeAssignmentNode(Node *left, Node *right);
|
Node* MakeNumberNode(
|
||||||
Node *StartStatementSequenceNode(Node *statementNode);
|
const char *numberString
|
||||||
Node *AddStatement(Node *statementSequenceNode, Node *statementNode);
|
);
|
||||||
Node *MakeReturnStatementNode(Node *expressionNode);
|
Node* MakeStringNode(
|
||||||
Node *MakeReturnVoidStatementNode();
|
const char *string
|
||||||
Node *StartFunctionSignatureArgumentsNode(Node *argumentNode);
|
);
|
||||||
Node *AddFunctionSignatureArgumentNode(Node *argumentsNode, Node *argumentNode);
|
Node* MakeStaticNode();
|
||||||
Node *MakeEmptyFunctionSignatureArgumentsNode();
|
Node* MakeFunctionModifiersNode(
|
||||||
Node *MakeFunctionSignatureNode(
|
Node **pModifierNodes,
|
||||||
Node *identifierNode,
|
uint32_t modifierCount
|
||||||
Node *typeNode,
|
);
|
||||||
|
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 *argumentsNode,
|
||||||
Node *modifiersNode,
|
Node *argumentNode
|
||||||
Node *genericArgumentsNode);
|
);
|
||||||
Node *MakeFunctionDeclarationNode(
|
Node *MakeEmptyFunctionSignatureArgumentsNode();
|
||||||
Node *functionSignatureNode,
|
Node* MakeFunctionSignatureNode(
|
||||||
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 *MakeStructDeclarationNode(
|
|
||||||
Node *identifierNode,
|
Node *identifierNode,
|
||||||
|
Node* typeNode,
|
||||||
|
Node* argumentsNode,
|
||||||
|
Node* modifiersNode
|
||||||
|
);
|
||||||
|
Node* MakeFunctionDeclarationNode(
|
||||||
|
Node* functionSignatureNode,
|
||||||
|
Node* functionBodyNode
|
||||||
|
);
|
||||||
|
Node* MakeStructDeclarationNode(
|
||||||
|
Node *identifierNode,
|
||||||
|
Node *declarationSequenceNode
|
||||||
|
);
|
||||||
|
Node* StartDeclarationSequenceNode(
|
||||||
|
Node *declarationNode
|
||||||
|
);
|
||||||
|
Node* AddDeclarationNode(
|
||||||
Node *declarationSequenceNode,
|
Node *declarationSequenceNode,
|
||||||
Node *genericArgumentsNode);
|
Node *declarationNode
|
||||||
Node *StartDeclarationSequenceNode(Node *declarationNode);
|
);
|
||||||
Node *AddDeclarationNode(Node *declarationSequenceNode, Node *declarationNode);
|
Node *StartFunctionArgumentSequenceNode(
|
||||||
Node *StartFunctionArgumentSequenceNode(Node *argumentNode);
|
Node *argumentNode
|
||||||
Node *AddFunctionArgumentNode(Node *argumentSequenceNode, Node *argumentNode);
|
);
|
||||||
|
Node *AddFunctionArgumentNode(
|
||||||
|
Node *argumentSequenceNode,
|
||||||
|
Node *argumentNode
|
||||||
|
);
|
||||||
Node *MakeEmptyFunctionArgumentSequenceNode();
|
Node *MakeEmptyFunctionArgumentSequenceNode();
|
||||||
Node *MakeFunctionCallExpressionNode(
|
Node* MakeFunctionCallExpressionNode(
|
||||||
Node *identifierNode,
|
Node *identifierNode,
|
||||||
Node *argumentSequenceNode,
|
Node *argumentSequenceNode
|
||||||
Node *genericArgumentsNode);
|
);
|
||||||
Node *MakeSystemCallExpressionNode(
|
Node* MakeAccessExpressionNode(
|
||||||
Node *identifierNode,
|
Node *accessee,
|
||||||
Node *argumentSequenceNode,
|
Node *accessor
|
||||||
Node *genericArgumentsNode);
|
);
|
||||||
Node *MakeAccessExpressionNode(Node *accessee, Node *accessor);
|
Node* MakeAllocNode(
|
||||||
Node *MakeAllocNode(Node *typeNode);
|
Node *typeNode
|
||||||
Node *MakeIfNode(Node *expressionNode, Node *statementSequenceNode);
|
);
|
||||||
Node *MakeIfElseNode(
|
Node* MakeIfNode(
|
||||||
|
Node *expressionNode,
|
||||||
|
Node *statementSequenceNode
|
||||||
|
);
|
||||||
|
Node* MakeIfElseNode(
|
||||||
Node *ifNode,
|
Node *ifNode,
|
||||||
Node *elseNode /* can be a conditional or a statement sequence */
|
Node *elseNode /* can be a conditional or a statement sequence */
|
||||||
);
|
);
|
||||||
Node *MakeForLoopNode(
|
Node* MakeForLoopNode(
|
||||||
Node *identifierNode,
|
Node *identifierNode,
|
||||||
Node *startNumberNode,
|
Node *startNumberNode,
|
||||||
Node *endNumberNode,
|
Node *endNumberNode,
|
||||||
Node *statementSequenceNode);
|
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);
|
void PrintNode(Node *node, uint32_t tabCount);
|
||||||
const char *SyntaxKindString(SyntaxKind syntaxKind);
|
const char* SyntaxKindString(SyntaxKind syntaxKind);
|
||||||
|
|
||||||
/* Helper function for applying a void function generically over the children of
|
TypeTag* MakeTypeTag(Node *node);
|
||||||
* an AST node. Used for functions that need to traverse the entire tree but
|
char* TypeTagToString(TypeTag *tag);
|
||||||
* 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 */
|
#endif /* WRAITH_AST_H */
|
||||||
|
|
|
||||||
2237
src/codegen.c
2237
src/codegen.c
File diff suppressed because it is too large
Load Diff
|
|
@ -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);
|
||||||
|
}
|
||||||
|
|
@ -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 */
|
||||||
53
src/main.c
53
src/main.c
|
|
@ -1,9 +1,9 @@
|
||||||
#include "../lib/dropt/dropt.h"
|
|
||||||
#include <stdlib.h>
|
#include <stdlib.h>
|
||||||
|
#include "../lib/dropt/dropt.h"
|
||||||
|
|
||||||
#include "codegen.h"
|
|
||||||
#include "parser.h"
|
#include "parser.h"
|
||||||
#include "validation.h"
|
#include "codegen.h"
|
||||||
|
#include "identcheck.h"
|
||||||
|
|
||||||
int main(int argc, char *argv[])
|
int main(int argc, char *argv[])
|
||||||
{
|
{
|
||||||
|
|
@ -14,27 +14,10 @@ int main(int argc, char *argv[])
|
||||||
int exitCode = EXIT_SUCCESS;
|
int exitCode = EXIT_SUCCESS;
|
||||||
|
|
||||||
dropt_option options[] = {
|
dropt_option options[] = {
|
||||||
{'h',
|
{ 'h', "help", "Shows help.", NULL, dropt_handle_bool, &showHelp, dropt_attr_halt },
|
||||||
"help",
|
{ 'v', "parse-verbose", "Shows verbose parser output.", NULL, dropt_handle_bool, &parseVerbose },
|
||||||
"Shows help.",
|
{ 'O', "optimize", "Sets optimization level of the output IR. Must be a value between 0 and 3.", "number", dropt_handle_uint, &optimizationLevel },
|
||||||
NULL,
|
{ 0 } /* Required sentinel value. */
|
||||||
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. */
|
|
||||||
};
|
};
|
||||||
|
|
||||||
dropt_context *droptContext = dropt_new_context(options);
|
dropt_context *droptContext = dropt_new_context(options);
|
||||||
|
|
@ -50,13 +33,10 @@ int main(int argc, char *argv[])
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
char **rest = dropt_parse(droptContext, -1, &argv[1]);
|
char** rest = dropt_parse(droptContext, -1, &argv[1]);
|
||||||
if (dropt_get_error(droptContext) != dropt_error_none)
|
if (dropt_get_error(droptContext) != dropt_error_none)
|
||||||
{
|
{
|
||||||
fprintf(
|
fprintf(stderr, "wraith: %s\n", dropt_get_error_message(droptContext));
|
||||||
stderr,
|
|
||||||
"wraith: %s\n",
|
|
||||||
dropt_get_error_message(droptContext));
|
|
||||||
exitCode = EXIT_FAILURE;
|
exitCode = EXIT_FAILURE;
|
||||||
}
|
}
|
||||||
else if (showHelp)
|
else if (showHelp)
|
||||||
|
|
@ -85,15 +65,12 @@ int main(int argc, char *argv[])
|
||||||
}
|
}
|
||||||
else
|
else
|
||||||
{
|
{
|
||||||
LinkParentPointers(rootNode, NULL);
|
{
|
||||||
/* FIXME: ValidateIdentifiers should return some sort of
|
IdNode *idTree = MakeIdTree(rootNode, NULL);
|
||||||
error status object. */
|
PrintIdTree(idTree, /*tabCount=*/0);
|
||||||
ValidateIdentifiers(rootNode);
|
printf("\n");
|
||||||
TagIdentifierTypes(rootNode);
|
PrintNode(rootNode, /*tabCount=*/0);
|
||||||
ConvertCustomsToGenerics(rootNode);
|
}
|
||||||
PrintNode(rootNode, 0);
|
|
||||||
|
|
||||||
printf("Beginning codegen.\n");
|
|
||||||
exitCode = Codegen(rootNode, optimizationLevel);
|
exitCode = Codegen(rootNode, optimizationLevel);
|
||||||
}
|
}
|
||||||
}
|
}
|
||||||
|
|
|
||||||
|
|
@ -1,7 +1,7 @@
|
||||||
#include <stdio.h>
|
#include <stdio.h>
|
||||||
|
|
||||||
#include "ast.h"
|
|
||||||
#include "y.tab.h"
|
#include "y.tab.h"
|
||||||
|
#include "ast.h"
|
||||||
|
|
||||||
extern FILE *yyin;
|
extern FILE *yyin;
|
||||||
extern int yydebug;
|
extern int yydebug;
|
||||||
|
|
|
||||||
42
src/util.c
42
src/util.c
|
|
@ -1,38 +1,16 @@
|
||||||
#include "util.h"
|
#include "util.h"
|
||||||
|
|
||||||
#include <stdlib.h>
|
#include <string.h>
|
||||||
|
|
||||||
char *strdup(const char *s)
|
char* strdup (const char* s)
|
||||||
{
|
{
|
||||||
size_t slen = strlen(s);
|
size_t slen = strlen(s);
|
||||||
char *result = (char *)malloc(sizeof(char) * (slen + 1));
|
char* result = malloc(slen + 1);
|
||||||
if (result == NULL)
|
if(result == NULL)
|
||||||
{
|
{
|
||||||
return NULL;
|
return NULL;
|
||||||
}
|
}
|
||||||
|
|
||||||
memcpy(result, s, slen + 1);
|
memcpy(result, s, slen+1);
|
||||||
return result;
|
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;
|
|
||||||
}
|
}
|
||||||
|
|
@ -1,11 +1,8 @@
|
||||||
#ifndef WRAITH_UTIL_H
|
#ifndef WRAITH_UTIL_H
|
||||||
#define WRAITH_UTIL_H
|
#define WRAITH_UTIL_H
|
||||||
|
|
||||||
#include <stdint.h>
|
|
||||||
#include <string.h>
|
#include <string.h>
|
||||||
|
|
||||||
char *strdup(const char *s);
|
char* strdup (const char* s);
|
||||||
char *w_strcat(char *s, char *s2);
|
|
||||||
uint64_t str_hash(char *str);
|
|
||||||
|
|
||||||
#endif /* WRAITH_UTIL_H */
|
#endif /* WRAITH_UTIL_H */
|
||||||
|
|
|
||||||
493
src/validation.c
493
src/validation.c
|
|
@ -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);
|
|
||||||
}
|
|
||||||
|
|
@ -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 */
|
|
||||||
Loading…
Reference in New Issue