aboutsummaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/compiler/ast-tree.c66
-rw-r--r--src/compiler/ast-tree.h9
-rw-r--r--src/runner/runner.c217
-rw-r--r--src/runner/runner.h2
4 files changed, 163 insertions, 131 deletions
diff --git a/src/compiler/ast-tree.c b/src/compiler/ast-tree.c
index e9d6430..7f7720d 100644
--- a/src/compiler/ast-tree.c
+++ b/src/compiler/ast-tree.c
@@ -461,14 +461,11 @@ void astTreePrint(const AstTree *tree, int indent) {
for (int i = 0; i < indent; ++i)
printf(" ");
printf("[");
- for (size_t i = 0; i < metadata->variables.size; ++i) {
- AstTreeVariable *variable = metadata->variables.data[i];
+ for (size_t i = 0; i < metadata->items_size; ++i) {
+ AstTreeObjectItem item = metadata->items[i];
for (int i = 0; i < indent + 1; ++i)
printf(" ");
- printf("{name=%.*s,value=\n",
- (int)(variable->name_end - variable->name_begin),
- variable->name_begin);
- astTreePrint(variable->value, indent + 2);
+ astTreePrint(item.value, indent + 2);
printf(",\n");
}
for (int i = 0; i < indent; ++i)
@@ -905,11 +902,11 @@ void astTreeDestroy(AstTree tree) {
}
case AST_TREE_TOKEN_VALUE_OBJECT: {
AstTreeObject *metadata = tree.metadata;
- for (size_t i = 0; i < metadata->variables.size; ++i) {
- AstTreeVariable *variable = metadata->variables.data[i];
- astTreeVariableDelete(variable);
+ for (size_t i = 0; i < metadata->items_size; ++i) {
+ AstTreeObjectItem item = metadata->items[i];
+ astTreeDelete(item.value);
}
- free(metadata->variables.data);
+ free(metadata->items);
free(metadata);
return;
}
@@ -1305,9 +1302,15 @@ AstTree *copyAstTreeBack(AstTree *tree, AstTreeVariables oldVariables[],
AstTreeObject *metadata = tree->metadata;
AstTreeObject *newMetadata = a404m_malloc(sizeof(*newMetadata));
- newMetadata->variables =
- copyAstTreeVariables(metadata->variables, oldVariables, newVariables,
- variables_size, safetyCheck);
+ newMetadata->items_size = metadata->items_size;
+ newMetadata->items =
+ a404m_malloc(newMetadata->items_size * sizeof(*newMetadata->items));
+
+ for (size_t i = 0; i < newMetadata->items_size; ++i) {
+ newMetadata->items[i].value =
+ copyAstTreeBack(metadata->items[i].value, oldVariables, newVariables,
+ variables_size, safetyCheck);
+ }
return newAstTree(tree->token, newMetadata,
copyAstTreeBack(tree->type, oldVariables, newVariables,
@@ -3017,24 +3020,33 @@ AstTree *astTreeParseString(const ParserNode *parserNode) {
ParserNodeStringMetadata *node_metadata = parserNode->metadata;
const size_t size = node_metadata->end - node_metadata->begin;
- AstTreeRawValue *metadata = a404m_malloc(size * sizeof(u8));
- memcpy(metadata, node_metadata->begin, size);
+ AstTreeObject *metadata = a404m_malloc(sizeof(*metadata));
+ metadata->items_size = size;
+ metadata->items =
+ a404m_malloc(metadata->items_size * sizeof(*metadata->items));
+
+ for (size_t i = 0; i < size; ++i) {
+ u8 *value = a404m_malloc(sizeof(*value));
+ *value = node_metadata->begin[i];
+ metadata->items[i].value = newAstTree(AST_TREE_TOKEN_RAW_VALUE, value,
+ &AST_TREE_U8_TYPE, NULL, NULL);
+ }
AstTreeBracket *type_metadata = a404m_malloc(sizeof(*type_metadata));
type_metadata->operand = &AST_TREE_U8_TYPE;
- AstTreeRawValue *parameter_metadata =
- a404m_malloc(getSizeOfType(&AST_TREE_U64_TYPE));
- *(u64 *)parameter_metadata = size;
- AstTree *parameter = newAstTree(AST_TREE_TOKEN_RAW_VALUE, parameter_metadata,
- &AST_TREE_U64_TYPE, NULL, NULL);
-
type_metadata->parameters.size = 1;
type_metadata->parameters.data = a404m_malloc(
type_metadata->parameters.size * sizeof(*type_metadata->parameters.data));
- type_metadata->parameters.data[0] = parameter;
- return newAstTree(AST_TREE_TOKEN_RAW_VALUE, metadata,
+ u64 *parameter_metadata = a404m_malloc(sizeof(*parameter_metadata));
+ *parameter_metadata = size;
+
+ type_metadata->parameters.data[0] =
+ newAstTree(AST_TREE_TOKEN_RAW_VALUE, parameter_metadata,
+ &AST_TREE_U64_TYPE, NULL, NULL);
+
+ return newAstTree(AST_TREE_TOKEN_VALUE_OBJECT, metadata,
newAstTree(AST_TREE_TOKEN_TYPE_ARRAY, type_metadata,
&AST_TREE_TYPE_TYPE, NULL, NULL),
parserNode->str_begin, parserNode->str_end);
@@ -8186,11 +8198,11 @@ char *u8ArrayToCString(AstTree *tree) {
return newValue;
} else if (tree->token == AST_TREE_TOKEN_VALUE_OBJECT) {
AstTreeObject *object = tree->metadata;
- char *str = a404m_malloc((object->variables.size + 1) * sizeof(*str));
- for (size_t i = 0; i < object->variables.size; ++i) {
- str[i] = *(AstTreeInt *)object->variables.data[i]->value->metadata;
+ char *str = a404m_malloc((object->items_size + 1) * sizeof(*str));
+ for (size_t i = 0; i < object->items_size; ++i) {
+ str[i] = *(u8 *)object->items[i].value->metadata;
}
- str[object->variables.size] = '\0';
+ str[object->items_size] = '\0';
return str;
}
UNREACHABLE;
diff --git a/src/compiler/ast-tree.h b/src/compiler/ast-tree.h
index 364263e..73f4462 100644
--- a/src/compiler/ast-tree.h
+++ b/src/compiler/ast-tree.h
@@ -246,8 +246,13 @@ typedef f128 AstTreeFloat;
typedef bool AstTreeBool;
+typedef struct AstTreeObjectItem {
+ AstTree *value;
+} AstTreeObjectItem;
+
typedef struct AstTreeObject {
- AstTreeVariables variables;
+ AstTreeObjectItem *items;
+ size_t items_size;
} AstTreeObject;
typedef AstTree AstTreeSingleChild;
@@ -414,7 +419,7 @@ AstTree *astTreeParseLoopControl(const ParserNode *parserNode,
AstTreeToken token);
AstTree *astTreeParseReturn(const ParserNode *parserNode);
AstTree *astTreeParseAssignOperator(const ParserNode *parserNode,
- AstTreeToken token);
+ AstTreeToken token);
AstTree *astTreeParseBinaryOperator(const ParserNode *parserNode,
AstTreeToken token);
AstTree *astTreeParseUnaryOperator(const ParserNode *parserNode,
diff --git a/src/runner/runner.c b/src/runner/runner.c
index 59e1889..d493236 100644
--- a/src/runner/runner.c
+++ b/src/runner/runner.c
@@ -1242,25 +1242,11 @@ AstTree *runAstTreeBuiltin(AstTree *tree, AstTreeScope *scope,
AstTree *count = arguments[0];
AstTree *type = arguments[1];
- size_t stackAllocation_capacity =
- a404m_malloc_usable_size(scope->stackAllocation) /
- sizeof(*scope->stackAllocation);
- if (scope->stackAllocation_size == stackAllocation_capacity) {
- stackAllocation_capacity += stackAllocation_capacity / 2 + 1;
- scope->stackAllocation = a404m_realloc(
- scope->stackAllocation,
- stackAllocation_capacity * sizeof(*scope->stackAllocation));
- }
-
const size_t sizeOfType = getSizeOfType(type);
const size_t size = *(u64 *)count->metadata * sizeOfType;
- scope->stackAllocation[scope->stackAllocation_size] = a404m_malloc(size);
- // memset(scope->stackAllocation[scope->stackAllocation_size], 0, size);
AstTreeRawValue *value = a404m_malloc(sizeof(void *));
- *(void **)value = scope->stackAllocation[scope->stackAllocation_size];
-
- scope->stackAllocation_size += 1;
+ *(void **)value = stackAlloc(size, scope);
AstTreeTypeFunction *tree_type = tree->type->metadata;
@@ -1752,72 +1738,74 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet,
}
if (tree->token == AST_TREE_TOKEN_VARIABLE) {
UNREACHABLE;
- AstTreeVariable *variable = tree->metadata;
- astTreeDelete(tree);
- if (variable->type->token == AST_TREE_TOKEN_TYPE_ARRAY) {
- AstTreeBracket *array_metadata = variable->type->metadata;
- if (metadata->member.index != 0) {
+ /*
+ AstTreeVariable *variable = tree->metadata;
+ astTreeDelete(tree);
+ if (variable->type->token == AST_TREE_TOKEN_TYPE_ARRAY) {
+ AstTreeBracket *array_metadata = variable->type->metadata;
+ if (metadata->member.index != 0) {
+ UNREACHABLE;
+ } else if (variable->value->token == AST_TREE_TOKEN_VALUE_UNDEFINED) {
+ if (array_metadata->parameters.size == 0) {
UNREACHABLE;
- } else if (variable->value->token == AST_TREE_TOKEN_VALUE_UNDEFINED) {
- if (array_metadata->parameters.size == 0) {
+ } else {
+ AstTree *sizeTree = runExpression(
+ array_metadata->parameters.data[0], scope, shouldRet, false,
+ isComptime, breakCount, shouldContinue, false);
+ if (discontinue(*shouldRet, *breakCount)) {
+ return sizeTree;
+ }
+ if (sizeTree->token != AST_TREE_TOKEN_VALUE_INT) {
UNREACHABLE;
} else {
- AstTree *sizeTree = runExpression(
- array_metadata->parameters.data[0], scope, shouldRet, false,
- isComptime, breakCount, shouldContinue, false);
- if (discontinue(*shouldRet, *breakCount)) {
- return sizeTree;
- }
- if (sizeTree->token != AST_TREE_TOKEN_VALUE_INT) {
- UNREACHABLE;
- } else {
- return sizeTree;
- }
+ return sizeTree;
}
- } else if (variable->value->token == AST_TREE_TOKEN_VALUE_OBJECT) {
- AstTreeObject *object = variable->value->metadata;
- AstTreeInt *res_metadata = a404m_malloc(sizeof(*res_metadata));
- *res_metadata = object->variables.size;
- return newAstTree(AST_TREE_TOKEN_VALUE_INT, res_metadata,
- &AST_TREE_U64_TYPE, NULL, NULL);
- }
- } else if (variable->type->token == AST_TREE_TOKEN_KEYWORD_STRUCT) {
- if (variable->value->token == AST_TREE_TOKEN_VALUE_UNDEFINED) {
- AstTreeStruct *struc = variable->type->metadata;
- AstTreeObject *newMetadata = a404m_malloc(sizeof(*newMetadata));
-
- newMetadata->variables =
- copyAstTreeVariables(struc->variables, NULL, NULL, 0, false);
-
- for (size_t i = 0; i < newMetadata->variables.size; ++i) {
- AstTreeVariable *member = newMetadata->variables.data[i];
- if (!member->isConst) {
- runnerVariableSetValue(member,
- newAstTree(AST_TREE_TOKEN_VALUE_UNDEFINED,
- NULL, copyAstTree(member->type),
- variable->value->str_begin,
- variable->value->str_end),
- scope);
- }
- }
-
- runnerVariableSetValue(
- variable,
- newAstTree(AST_TREE_TOKEN_VALUE_OBJECT, newMetadata,
- copyAstTree(variable->type),
- variable->value->str_begin, variable->value->str_end),
- scope);
}
+ } else if (variable->value->token == AST_TREE_TOKEN_VALUE_OBJECT) {
AstTreeObject *object = variable->value->metadata;
- AstTreeVariable *var = object->variables.data[metadata->member.index];
- if (isLeft) {
- return newAstTree(AST_TREE_TOKEN_VARIABLE, var,
- copyAstTree(var->type), var->name_begin,
- var->name_end);
- } else {
- return copyAstTree(var->value);
+ AstTreeInt *res_metadata = a404m_malloc(sizeof(*res_metadata));
+ *res_metadata = object->variables.size;
+ return newAstTree(AST_TREE_TOKEN_VALUE_INT, res_metadata,
+ &AST_TREE_U64_TYPE, NULL, NULL);
+ }
+ } else if (variable->type->token == AST_TREE_TOKEN_KEYWORD_STRUCT) {
+ if (variable->value->token == AST_TREE_TOKEN_VALUE_UNDEFINED) {
+ AstTreeStruct *struc = variable->type->metadata;
+ AstTreeObject *newMetadata = a404m_malloc(sizeof(*newMetadata));
+
+ newMetadata->variables =
+ copyAstTreeVariables(struc->variables, NULL, NULL, 0, false);
+
+ for (size_t i = 0; i < newMetadata->variables.size; ++i) {
+ AstTreeVariable *member = newMetadata->variables.data[i];
+ if (!member->isConst) {
+ runnerVariableSetValue(member,
+ newAstTree(AST_TREE_TOKEN_VALUE_UNDEFINED,
+ NULL, copyAstTree(member->type),
+ variable->value->str_begin,
+ variable->value->str_end),
+ scope);
+ }
}
+
+ runnerVariableSetValue(
+ variable,
+ newAstTree(AST_TREE_TOKEN_VALUE_OBJECT, newMetadata,
+ copyAstTree(variable->type),
+ variable->value->str_begin, variable->value->str_end),
+ scope);
}
+ AstTreeObject *object = variable->value->metadata;
+ AstTreeVariable *var = object->variables.data[metadata->member.index];
+ if (isLeft) {
+ return newAstTree(AST_TREE_TOKEN_VARIABLE, var,
+ copyAstTree(var->type), var->name_begin,
+ var->name_end);
+ } else {
+ return copyAstTree(var->value);
+ }
+ }
+ */
UNREACHABLE;
} else if (tree->token == AST_TREE_TOKEN_RAW_VALUE) {
if (tree->type->token == AST_TREE_TOKEN_TYPE_ARRAY) {
@@ -1826,8 +1814,8 @@ AstTree *runExpression(AstTree *expr, AstTreeScope *scope, bool *shouldRet,
u64 *value = a404m_malloc(sizeof(*value));
*value = tree_value[metadata->member.index];
astTreeDelete(tree);
- return newAstTree(AST_TREE_TOKEN_RAW_VALUE, value, copyAstTree(expr->type),
- NULL, NULL);
+ return newAstTree(AST_TREE_TOKEN_RAW_VALUE, value,
+ copyAstTree(expr->type), NULL, NULL);
}
size_t index = 0;
AstTreeStruct *type = tree->type->metadata;
@@ -1955,16 +1943,6 @@ AstTree *toRawValue(AstTree *value, AstTreeScope *scope) {
AstTreeBracket *bracket = value->type->metadata;
- size_t stackAllocation_capacity =
- a404m_malloc_usable_size(scope->stackAllocation) /
- sizeof(*scope->stackAllocation);
- if (scope->stackAllocation_size == stackAllocation_capacity) {
- stackAllocation_capacity += stackAllocation_capacity / 2 + 1;
- scope->stackAllocation = a404m_realloc(
- scope->stackAllocation,
- stackAllocation_capacity * sizeof(*scope->stackAllocation));
- }
-
if (bracket->parameters.size != 1) {
UNREACHABLE;
}
@@ -1972,13 +1950,9 @@ AstTree *toRawValue(AstTree *value, AstTreeScope *scope) {
const size_t sizeOfType = getSizeOfType(bracket->operand);
const size_t size =
*(u64 *)bracket->parameters.data[0]->metadata * sizeOfType;
- scope->stackAllocation[scope->stackAllocation_size] = a404m_malloc(size);
- // memset(scope->stackAllocation[scope->stackAllocation_size], 0, size);
- array->data = scope->stackAllocation[scope->stackAllocation_size];
+ array->data = stackAlloc(size, scope);
array->size = *(u64 *)bracket->parameters.data[0]->metadata;
-
- scope->stackAllocation_size += 1;
} else {
size = getSizeOfType(value->type);
rawValue = a404m_malloc(size);
@@ -2021,21 +1995,43 @@ AstTree *toRawValue(AstTree *value, AstTreeScope *scope) {
value->str_end);
}
case AST_TREE_TOKEN_VALUE_OBJECT: {
- NOT_IMPLEMENTED;
const size_t size = getSizeOfType(value->type);
- AstTreeRawValue *rawValue = a404m_malloc(size);
+ AstTreeRawValue *rawValue = a404m_malloc(sizeof(void *) + sizeof(u64));
AstTreeObject *object = value->metadata;
- size_t filledSize = 0;
- for (size_t i = 0; i < object->variables.size; ++i) {
- AstTreeVariable *variable = object->variables.data[i];
- AstTree *variableValue = toRawValue(variable->value, scope);
- size_t variableValueSize = getSizeOfType(variableValue);
- if (variableValue == NULL) {
- NOT_IMPLEMENTED;
+ if (value->type->token == AST_TREE_TOKEN_TYPE_ARRAY) {
+ u8 *ptr = stackAlloc(size, scope);
+ ((u64 *)rawValue)[0] = (u64)ptr;
+ ((u64 *)rawValue)[1] = size;
+
+ size_t filledSize = 0;
+ for (size_t i = 0; i < object->items_size; ++i) {
+ AstTreeObjectItem item = object->items[i];
+ AstTree *itemValue = toRawValue(item.value, scope);
+ if (itemValue == NULL) {
+ itemValue = item.value;
+ }
+ size_t valueSize = getSizeOfType(itemValue->type);
+ memcpy(ptr + filledSize, itemValue->metadata, valueSize);
+ filledSize += valueSize;
+ if (itemValue != item.value) {
+ astTreeDelete(itemValue);
+ }
+ }
+ } else {
+ size_t filledSize = 0;
+ for (size_t i = 0; i < object->items_size; ++i) {
+ AstTreeObjectItem item = object->items[i];
+ AstTree *itemValue = toRawValue(item.value, scope);
+ if (itemValue == NULL) {
+ itemValue = item.value;
+ }
+ size_t valueSize = getSizeOfType(itemValue->type);
+ memcpy((u8 *)rawValue + filledSize, itemValue->metadata, valueSize);
+ filledSize += valueSize;
+ if (itemValue != item.value) {
+ astTreeDelete(itemValue);
+ }
}
- memcpy((u8 *)rawValue + filledSize, variableValue->metadata,
- variableValueSize);
- astTreeDelete(variableValue);
}
return newAstTree(AST_TREE_TOKEN_RAW_VALUE, rawValue,
copyAstTree(value->type), value->str_begin,
@@ -2508,3 +2504,20 @@ void deleteFFIType(ffi_type *type) {
free(type);
}
}
+
+void *stackAlloc(size_t size, AstTreeScope *scope) {
+ size_t stackAllocation_capacity =
+ a404m_malloc_usable_size(scope->stackAllocation) /
+ sizeof(*scope->stackAllocation);
+ if (scope->stackAllocation_size == stackAllocation_capacity) {
+ stackAllocation_capacity += stackAllocation_capacity / 2 + 1;
+ scope->stackAllocation = a404m_realloc(scope->stackAllocation,
+ stackAllocation_capacity *
+ sizeof(*scope->stackAllocation));
+ }
+
+ scope->stackAllocation[scope->stackAllocation_size] = a404m_malloc(size);
+ scope->stackAllocation_size += 1;
+
+ return scope->stackAllocation[scope->stackAllocation_size - 1];
+}
diff --git a/src/runner/runner.h b/src/runner/runner.h
index 16103cc..f4b6277 100644
--- a/src/runner/runner.h
+++ b/src/runner/runner.h
@@ -38,3 +38,5 @@ AstTree *castTo(AstTree *value, AstTree *to);
ffi_type *toFFIType(AstTree *type);
void deleteFFIType(ffi_type *type);
+
+void *stackAlloc(size_t size, AstTreeScope *scope);
generated by cgit v1.2.3 (git 2.39.1) at 2025-06-08 05:02:41 +0000