Ratstail91/Airport
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Updated Toy, added a couple util functions

Browse Source
This commit is contained in:
Kayne Ruse
2022-10-15 00:04:58 +01:00
parent dfcdaf3b92
commit 2eb67d9bca
9 changed files with 107 additions and 9 deletions
Download Patch File Download Diff File Expand all files Collapse all files

9
core/engine_node.c
View File

@@ -2,7 +2,7 @@
#include "memory.h"
STATIC_ASSERT(sizeof(EngineNode) == 32);
STATIC_ASSERT(sizeof(EngineNode) == 48);
STATIC_ASSERT(sizeof(EngineNodeCallback) == 8);
STATIC_ASSERT(sizeof(LiteralDictionary*) == 8);
STATIC_ASSERT(sizeof(EngineNode*) == 8);
@@ -17,6 +17,8 @@ void initEngineNode(EngineNode* node, Interpreter* interpreter, void* tb, size_t
//init
node->freeMemory = freeMemory;
node->functions = ALLOCATE(LiteralDictionary, 1);
node->parent = NULL;
node->tag = OPAQUE_TAG_ENGINE_NODE;
node->children = NULL;
node->capacity = 0;
node->count = 0;
@@ -69,6 +71,9 @@ void pushEngineNode(EngineNode* node, EngineNode* child) {
//assign
node->children[node->count++] = child;
//reverse-assign
child->parent = node;
}
void freeEngineNode(EngineNode* node) {
@@ -97,7 +102,7 @@ static void callEngineNodeLiteral(EngineNode* node, Interpreter* interpreter, Li
//if this fn exists
if (existsLiteralDictionary(node->functions, key)) {
Literal fn = getLiteralDictionary(node->functions, key);
Literal n = TO_OPAQUE_LITERAL(node, -1);
Literal n = TO_OPAQUE_LITERAL(node, node->tag);
LiteralArray arguments;
LiteralArray returns;

10
core/engine_node.h
View File

@@ -5,9 +5,10 @@
#include "literal_dictionary.h"
#include "interpreter.h"
#define OPAQUE_TAG_ENGINE_NODE 1
//forward declare
typedef struct _engineNode EngineNode;
typedef void (*EngineNodeCallback)(void*);
//the node object, which forms a tree
@@ -18,6 +19,13 @@ typedef struct _engineNode {
//toy functions, stored in a dict for flexibility
LiteralDictionary* functions;
//point to the parent
EngineNode* parent;
//my opaque type tag
int tag;
int _unused;
//use Toy's memory model
EngineNode** children;
int capacity;

76
core/lib_engine.c
View File

@@ -201,7 +201,7 @@ static int nativeLoadNode(Interpreter* interpreter, LiteralArray* arguments) {
//NOTE: initNode() must be called manually
// return the node
Literal nodeLiteral = TO_OPAQUE_LITERAL(node, -1);
Literal nodeLiteral = TO_OPAQUE_LITERAL(node, node->tag);
pushLiteralArray(&interpreter->stack, nodeLiteral);
//cleanup
@@ -397,7 +397,7 @@ static int nativeGetNode(Interpreter* interpreter, LiteralArray* arguments) {
}
EngineNode* childNode = parentNode->children[intIndex];
Literal child = TO_OPAQUE_LITERAL(childNode, -1);
Literal child = TO_OPAQUE_LITERAL(childNode, childNode->tag);
pushLiteralArray(&interpreter->stack, child);
@@ -409,6 +409,76 @@ static int nativeGetNode(Interpreter* interpreter, LiteralArray* arguments) {
return 1;
}
static int nativeGetNodeParent(Interpreter* interpreter, LiteralArray* arguments) {
//checks
if (arguments->count != 1) {
interpreter->errorOutput("Incorrect number of arguments passed to getNodeParent\n");
return -1;
}
Literal nodeLiteral = popLiteralArray(arguments);
Literal nodeIdn = nodeLiteral;
if (IS_IDENTIFIER(nodeLiteral) && parseIdentifierToValue(interpreter, &nodeLiteral)) {
freeLiteral(nodeIdn);
}
if (!IS_OPAQUE(nodeLiteral)) {
interpreter->errorOutput("Incorrect argument type passed to getNodeParent\n");
freeLiteral(nodeLiteral);
return -1;
}
//push the node
EngineNode* node = AS_OPAQUE(nodeLiteral);
EngineNode* parent = node->parent;
Literal parentLiteral = TO_NULL_LITERAL;
if (parent != NULL) {
parentLiteral = TO_OPAQUE_LITERAL(parent, parent->tag);
}
pushLiteralArray(&interpreter->stack, parentLiteral);
//cleanup
freeLiteral(parentLiteral);
freeLiteral(nodeLiteral);
return 1;
}
static int nativeGetNodeTag(Interpreter* interpreter, LiteralArray* arguments) {
//checks
if (arguments->count != 1) {
interpreter->errorOutput("Incorrect number of arguments passed to getNodeTag\n");
return -1;
}
Literal nodeLiteral = popLiteralArray(arguments);
Literal nodeIdn = nodeLiteral;
if (IS_IDENTIFIER(nodeLiteral) && parseIdentifierToValue(interpreter, &nodeLiteral)) {
freeLiteral(nodeIdn);
}
if (!IS_OPAQUE(nodeLiteral)) {
interpreter->errorOutput("Incorrect argument type passed to getNodeTag\n");
freeLiteral(nodeLiteral);
return -1;
}
//push the tag
Literal tagLiteral = TO_INTEGER_LITERAL( ((EngineNode*)AS_OPAQUE(nodeLiteral))->tag );
pushLiteralArray(&interpreter->stack, tagLiteral);
//cleanup
freeLiteral(nodeLiteral);
freeLiteral(tagLiteral);
return 1;
}
//call the hook
typedef struct Natives {
char* name;
@@ -426,6 +496,8 @@ int hookEngine(Interpreter* interpreter, Literal identifier, Literal alias) {
{"_freeChildNode", nativeFreeChildNode},
{"_pushNode", nativePushNode},
{"_getNode", nativeGetNode},
{"_getNodeParent", nativeGetNodeParent},
{"_getNodeTag", nativeGetNodeTag},
{NULL, NULL}
};

2
core/lib_render.c
View File

@@ -61,7 +61,7 @@ static int nativeLoadRenderNode(Interpreter* interpreter, LiteralArray* argument
//NOTE: initNode() must be called manually
// return the node
Literal nodeLiteral = TO_OPAQUE_LITERAL(node, -1);
Literal nodeLiteral = TO_OPAQUE_LITERAL(node, node->tag);
pushLiteralArray(&interpreter->stack, nodeLiteral);
//cleanup

2
core/render_node.c
View File

@@ -19,6 +19,8 @@ void initRenderNode(RenderNode* node, Interpreter* interpreter, void* tb, size_t
//init
node->freeMemory = freeMemory;
node->functions = ALLOCATE(LiteralDictionary, 1);
node->parent = NULL;
node->tag = OPAQUE_TAG_RENDER_NODE;
node->children = NULL;
node->capacity = 0;
node->count = 0;

9
core/render_node.h
View File

@@ -7,6 +7,8 @@
#include <SDL2/SDL.h>
#define OPAQUE_TAG_RENDER_NODE 2
typedef struct _renderNode {
//function for releasing memory
EngineNodeCallback freeMemory;
@@ -14,6 +16,13 @@ typedef struct _renderNode {
//toy functions, stored in a dict for flexibility
LiteralDictionary* functions;
//point to the parent
EngineNode* parent;
//my opaque type tag
int tag;
int _unused;
//use Toy's memory model
EngineNode** children;
int capacity;