wraith-lang/src/identcheck.c

215 lines
6.7 KiB
C
Raw Normal View History

2021-05-07 00:16:10 +00:00
#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) {
2021-05-07 00:16:10 +00:00
IdNode *node = (IdNode*)malloc(sizeof(IdNode));
node->type = type;
node->name = strdup(name);
node->parent = parent;
2021-05-07 00:16:10 +00:00
node->childCount = 0;
node->childCapacity = 0;
node->children = 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 = realloc(node->children, sizeof(IdNode*) * node->childCapacity);
}
node->children[node->childCount] = child;
node->childCount += 1;
}
IdNode* MakeIdTree(Node *astNode, IdNode *parent) {
uint32_t i;
2021-05-07 00:16:10 +00:00
switch (astNode->syntaxKind) {
case Assignment:
return (astNode->children[0]->syntaxKind == Declaration)
? MakeIdTree(astNode->children[0], parent)
: NULL;
case IfStatement: {
Node *stmtSeq = astNode->children[1];
IdNode *ifNode = MakeIdNode(LexicalScope, "if", parent);
for (i = 0; i < stmtSeq->childCount; i++) {
AddChildToNode(ifNode, MakeIdTree(stmtSeq->children[i], ifNode));
}
return ifNode;
}
2021-05-07 00:16:10 +00:00
case IfElseStatement: {
Node *ifNode = astNode->children[0];
Node *elseStmts = astNode->children[1];
IdNode *ifElseNode = MakeIdNode(LexicalScope, "if-else", parent);
IdNode *ifBranch = MakeIdTree(ifNode, ifElseNode);
IdNode *elseBranch = MakeIdNode(LexicalScope, "else", ifElseNode);
AddChildToNode(ifElseNode, ifBranch);
AddChildToNode(ifElseNode, elseBranch);
for (i = 0; i < elseStmts->childCount; i++) {
AddChildToNode(elseBranch, MakeIdTree(elseStmts->children[i], elseBranch));
2021-05-07 00:16:10 +00:00
}
return ifElseNode;
}
case ForLoop: {
Node *loopDecl = astNode->children[0];
Node *loopBody = astNode->children[3];
IdNode *loopNode = MakeIdNode(LexicalScope, "for-loop", parent);
AddChildToNode(loopNode, MakeIdTree(loopDecl, loopNode));
for (i = 0; i < loopBody->childCount; i++) {
AddChildToNode(loopNode, MakeIdTree(loopBody->children[i], loopNode));
}
return loopNode;
2021-05-07 00:16:10 +00:00
}
2021-05-08 00:49:35 +00:00
case Declaration: {
IdNode *declNode = MakeIdNode(Variable, astNode->children[1]->value.string, parent);
declNode->typeTag = MakeTypeTag(astNode);
return declNode;
}
2021-05-07 00:16:10 +00:00
case StructDeclaration: {
Node *idNode = astNode->children[0];
Node *declsNode = astNode->children[1];
IdNode *structNode = MakeIdNode(Struct, idNode->value.string, parent);
2021-05-08 00:49:35 +00:00
structNode->typeTag = MakeTypeTag(astNode);
2021-05-07 00:16:10 +00:00
for (i = 0; i < declsNode->childCount; i++) {
AddChildToNode(structNode, MakeIdTree(declsNode->children[i], structNode));
2021-05-07 00:16:10 +00:00
}
return structNode;
}
case FunctionDeclaration: {
Node *sigNode = astNode->children[0];
Node *funcNameNode = sigNode->children[0];
Node *funcArgsNode = sigNode->children[2];
Node *bodyStatementsNode = astNode->children[1];
IdNode *funcNode = MakeIdNode(Function, funcNameNode->value.string, parent);
2021-05-08 00:49:35 +00:00
funcNode->typeTag = MakeTypeTag(astNode);
2021-05-07 00:16:10 +00:00
for (i = 0; i < funcArgsNode->childCount; i++) {
AddChildToNode(funcNode, MakeIdTree(funcArgsNode->children[i], funcNode));
2021-05-07 00:16:10 +00:00
}
for (i = 0; i < bodyStatementsNode->childCount; i++) {
AddChildToNode(funcNode, MakeIdTree(bodyStatementsNode->children[i], funcNode));
2021-05-07 00:16:10 +00:00
}
return funcNode;
}
case DeclarationSequence: {
IdNode *declSeqNode = MakeIdNode(LexicalScope, "", parent);
for (i = 0; i < astNode->childCount; i++) {
AddChildToNode(declSeqNode, MakeIdTree(astNode->children[i], declSeqNode));
}
return declSeqNode;
}
2021-05-07 00:16:10 +00:00
default:
return NULL;
}
}
void PrintIdNode(IdNode *node) {
2021-05-08 00:49:35 +00:00
if (node == NULL) {
fprintf(stderr, "wraith: Attempted to call PrintIdNode with null value.\n");
return;
}
switch(node->type) {
2021-05-08 00:49:35 +00:00
case LexicalScope:
printf("Scope (%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;
}
}
2021-05-07 00:16:10 +00:00
void PrintIdTree(IdNode *tree, uint32_t tabCount) {
2021-05-07 21:36:37 +00:00
if (tree == NULL) {
fprintf(stderr, "wraith: Attempted to call PrintIdTree on a null value.\n");
return;
}
2021-05-07 00:16:10 +00:00
uint32_t i;
for (i = 0; i < tabCount; i++) {
printf("| ");
}
PrintIdNode(tree);
2021-05-07 00:16:10 +00:00
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* FindId(IdNode *root, NodeType targetType, char *targetName) {
if (root == NULL) {
fprintf(stderr, "wraith: Attempted to call FindId 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 = 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;
}