From 41bf2bece8c89040aa0b01df2ad436b55443eda9 Mon Sep 17 00:00:00 2001 From: cosmonaut Date: Fri, 14 May 2021 11:53:09 -0700 Subject: [PATCH] some minor style revisions --- src/ast.h | 12 ++++++------ src/identcheck.c | 48 +++++++++++++++++++++++++----------------------- src/identcheck.h | 5 ++--- 3 files changed, 33 insertions(+), 32 deletions(-) diff --git a/src/ast.h b/src/ast.h index 4da2d11..9c1312f 100644 --- a/src/ast.h +++ b/src/ast.h @@ -74,20 +74,20 @@ typedef union typedef struct TypeTag { - enum Type + enum Type { Unknown, Primitive, Reference, Custom } type; - union + union { - // Valid when type = Primitive. + /* Valid when type = Primitive. */ PrimitiveType primitiveType; - // Valid when type = Reference. + /* Valid when type = Reference. */ struct TypeTag *referenceType; - // Valid when type = Custom. + /* Valid when type = Custom. */ char *customType; } value; } TypeTag; @@ -108,7 +108,7 @@ typedef struct Node uint64_t number; } value; PrimitiveType primitiveType; - TypeTag *typeTag; + TypeTag *typeTag; IdNode *idLink; } Node; diff --git a/src/identcheck.c b/src/identcheck.c index ced9e0a..6fe0ec4 100644 --- a/src/identcheck.c +++ b/src/identcheck.c @@ -24,10 +24,10 @@ void AddChildToNode(IdNode *node, IdNode *child) { if (node->children == NULL) { node->childCapacity = 2; - node->children = (IdNode**)malloc(sizeof(IdNode*) * node->childCapacity); + 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 = (IdNode**) realloc(node->children, sizeof(IdNode*) * node->childCapacity); } node->children[node->childCount] = child; @@ -167,20 +167,20 @@ void PrintIdNode(IdNode *node) { case Placeholder: printf("Placeholder (%s)\n", node->name); break; - case OrderedScope: - printf("OrderedScope (%s)\n", node->name); + case OrderedScope: + printf("OrderedScope (%s)\n", node->name); break; - case UnorderedScope: - printf("UnorderedScope (%s)\n", node->name); + case UnorderedScope: + printf("UnorderedScope (%s)\n", node->name); break; case Struct: - printf("%s : %s\n", node->name, TypeTagToString(node->typeTag)); + 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)); + case Variable: + printf("%s : %s\n", node->name, TypeTagToString(node->typeTag)); break; } } @@ -242,7 +242,7 @@ IdNode* LookdownId(IdNode *root, NodeType targetType, char *targetName) { } size_t newSize = frontierCount + current->childCount - 1; if (frontierCount != newSize) { - frontier = realloc(frontier, sizeof(IdNode*) * newSize); + frontier = (IdNode**) realloc(frontier, sizeof(IdNode*) * newSize); } for (i = 0; i < current->childCount; i++) { frontier[frontierCount + i - 1] = current->children[i]; @@ -258,7 +258,7 @@ bool ScopeHasOrdering(IdNode *node) { switch (node->type) { case OrderedScope: case Function: - case Variable: // this is only technically true + case Variable: /* this is only technically true */ return true; default: return false; @@ -274,20 +274,22 @@ IdNode* LookupId(IdNode *node, IdNode *prev, char *target) { 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 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 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. if (ScopeHasOrdering(node)) { uint32_t i; for (i = 0, idxLimit = 0; i < node->childCount; i++, idxLimit++) { @@ -303,13 +305,13 @@ IdNode* LookupId(IdNode *node, IdNode *prev, char *target) { 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. + /* 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; @@ -317,7 +319,7 @@ IdNode* LookupId(IdNode *node, IdNode *prev, char *target) { IdNode *grandchild = child->children[j]; if (strcmp(grandchild->name, target) == 0) { return grandchild; - } + } } } } diff --git a/src/identcheck.h b/src/identcheck.h index 9b57858..2c75262 100644 --- a/src/identcheck.h +++ b/src/identcheck.h @@ -1,4 +1,5 @@ -// Validates identifier usage in an AST. +/* Validates identifier usage in an AST. */ + #ifndef WRAITH_IDENTCHECK_H #define WRAITH_IDENTCHECK_H @@ -42,6 +43,4 @@ int PrintAncestors(IdNode *node); IdNode* LookdownId(IdNode *root, NodeType targetType, char *targetName); IdNode* LookupId(IdNode *node, IdNode *prev, char* target); -//IdStatus CheckIds(Node *root); - #endif /* WRAITH_IDENTCHECK_H */