major set building
Co-authored-by: SirTalksalot75 <SirTalksalot75@users.noreply.github.com> Co-authored-by: servostar <Servostar@users.noreply.github.com>
This commit is contained in:
parent
4d33c81c3f
commit
d0b1d367d5
|
|
@ -3,6 +3,8 @@
|
|||
//
|
||||
|
||||
#include <io/files.h>
|
||||
#include <stdarg.h>
|
||||
#include <stdio.h>
|
||||
#include <sys/log.h>
|
||||
#include <assert.h>
|
||||
#include <sys/col.h>
|
||||
|
|
@ -79,7 +81,7 @@ static void custom_fgets(char *buffer, size_t n, FILE *stream) {
|
|||
}
|
||||
}
|
||||
|
||||
void print_diagnostic(ModuleFile *file, TokenLocation *location, Message kind, const char *message) {
|
||||
void print_diagnostic(ModuleFile *file, TokenLocation *location, Message kind, const char *message, ...) {
|
||||
assert(file->handle != NULL);
|
||||
assert(location != NULL);
|
||||
assert(message != NULL);
|
||||
|
|
@ -117,8 +119,16 @@ void print_diagnostic(ModuleFile *file, TokenLocation *location, Message kind, c
|
|||
|
||||
const char *absolute_path = get_absolute_path(file->path);
|
||||
|
||||
printf("%s%s:%ld:%s %s%s:%s %s\n", BOLD, absolute_path, location->line_start, RESET, accent_color, kind_text, RESET,
|
||||
message);
|
||||
printf("%s%s:%ld:%s %s%s:%s ", BOLD, absolute_path, location->line_start, RESET, accent_color, kind_text, RESET);
|
||||
|
||||
va_list args;
|
||||
va_start(args, format);
|
||||
|
||||
vprintf(message, args);
|
||||
|
||||
va_end(args);
|
||||
|
||||
printf("\n");
|
||||
|
||||
free((void *) absolute_path);
|
||||
|
||||
|
|
|
|||
|
|
@ -92,7 +92,7 @@ TokenLocation empty_location(void);
|
|||
* @param message
|
||||
*/
|
||||
[[gnu::nonnull(1), gnu::nonnull(2)]]
|
||||
void print_diagnostic(ModuleFile *file, TokenLocation *location, Message kind, const char *message);
|
||||
void print_diagnostic(ModuleFile *file, TokenLocation *location, Message kind, const char *message, ...);
|
||||
|
||||
[[gnu::nonnull(2)]]
|
||||
/**
|
||||
|
|
|
|||
468
src/set/set.c
468
src/set/set.c
|
|
@ -1,5 +1,5 @@
|
|||
#include "io/files.h"
|
||||
#include "yacc/parser.tab.h"
|
||||
#include <io/files.h>
|
||||
#include <yacc/parser.tab.h>
|
||||
#include <complex.h>
|
||||
#include <stdio.h>
|
||||
#include <ast/ast.h>
|
||||
|
|
@ -11,9 +11,17 @@
|
|||
#include <assert.h>
|
||||
#include <set/set.h>
|
||||
|
||||
GHashTable *declaredComposites = NULL;//pointer to composites with names,
|
||||
GHashTable *declaredBoxes = NULL;//pointer to typeboxes
|
||||
GArray *Scope = NULL;//list of hashtables. last Hashtable is current depth of program. hashtable key: ident, value: Variable* to var
|
||||
//
|
||||
// .--.
|
||||
// | '----------. .
|
||||
// > | ~ ~ ~ ~ ~ .o O
|
||||
// | .----------' o
|
||||
// `--'
|
||||
//
|
||||
|
||||
static GHashTable *declaredComposites = NULL;//pointer to composites with names
|
||||
static GHashTable *declaredBoxes = NULL;//pointer to typeboxes
|
||||
static GArray *Scope = NULL;//list of hashtables. last Hashtable is current depth of program. hashtable key: ident, value: Variable* to var
|
||||
|
||||
const Type ShortShortUnsingedIntType = {
|
||||
.kind = TypeKindComposite,
|
||||
|
|
@ -264,9 +272,15 @@ int get_type_impl(AST_NODE_PTR currentNode, Type** type) {
|
|||
}
|
||||
|
||||
StorageQualifier Qualifier_from_string(const char *str) {
|
||||
if (!strncmp(str, "local", 5)) return Local;
|
||||
if (!strncmp(str, "static", 6)) return Static;
|
||||
if (!strncmp(str, "global", 6)) return Global;
|
||||
assert(str != NULL);
|
||||
|
||||
if (strcmp(str, "local") == 0)
|
||||
return Local;
|
||||
if (strcmp(str, "static") == 0)
|
||||
return Static;
|
||||
if (strcmp(str, "global") == 0)
|
||||
return Global;
|
||||
|
||||
PANIC("Provided string is not a storagequalifier: %s", str);
|
||||
}
|
||||
|
||||
|
|
@ -316,42 +330,99 @@ int createDecl(AST_NODE_PTR currentNode, GArray** variables) {
|
|||
return status;
|
||||
}
|
||||
|
||||
Expression* createExpression(AST_NODE_PTR currentNode);
|
||||
|
||||
int createDef(AST_NODE_PTR currentNode, GArray** variables) {
|
||||
assert(variables != NULL);
|
||||
assert(currentNode != NULL);
|
||||
assert(currentNode->kind == AST_Def);
|
||||
|
||||
DEBUG("create definition");
|
||||
|
||||
AST_NODE_PTR declaration = currentNode->children[currentNode->child_count - 1];
|
||||
AST_NODE_PTR declaration = currentNode->children[0];
|
||||
AST_NODE_PTR expression = currentNode->children[1];
|
||||
AST_NODE_PTR ident_list = currentNode->children[0]->children[currentNode->child_count - 1];
|
||||
|
||||
*variables = g_array_new(FALSE, FALSE, sizeof(Variable*));
|
||||
|
||||
VariableDeclaration decl;
|
||||
VariableDefiniton def;
|
||||
def.nodePtr = currentNode;
|
||||
|
||||
Variable* variable = malloc(sizeof(Variable));
|
||||
variable->kind = VariableKindDefinition;
|
||||
variable->nodePtr = currentNode;
|
||||
variable->name = declaration->children[1]->value;
|
||||
variable->impl.definiton= def;
|
||||
g_array_append_val(*variables, variable);
|
||||
|
||||
int status = SEMANTIC_OK;
|
||||
|
||||
DEBUG("Child Count: %i", currentNode->child_count);
|
||||
for (size_t i = 0; i < currentNode->child_count; i++){
|
||||
|
||||
switch(currentNode->children[i]->kind) {
|
||||
case AST_Decl:
|
||||
DEBUG("Child Count: %i", declaration->child_count);
|
||||
for (size_t i = 0; i < declaration->children[i]->child_count; i++){
|
||||
switch(declaration->children[i]->kind) {
|
||||
case AST_Storage:
|
||||
DEBUG("fill Qualifier");
|
||||
decl.qualifier = Qualifier_from_string(currentNode->children[i]->value);
|
||||
break;
|
||||
case AST_Type:
|
||||
DEBUG("fill Type");
|
||||
status = get_type_impl(currentNode->children[i], &decl.type);
|
||||
break;
|
||||
case AST_IdentList:
|
||||
break;
|
||||
default:
|
||||
PANIC("invalid node type: %ld", currentNode->children[i]->kind);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
def.declaration = decl;
|
||||
Expression * name = createExpression(expression);
|
||||
if (name == NULL){
|
||||
status = SEMANTIC_OK;
|
||||
}
|
||||
def.initializer = name;
|
||||
|
||||
|
||||
for(size_t i = 0; i < ident_list->child_count; i++) {
|
||||
Variable* variable = malloc(sizeof(Variable));
|
||||
|
||||
variable->kind = VariableKindDefinition;
|
||||
variable->nodePtr = currentNode;
|
||||
variable->name = ident_list->children[i]->value;
|
||||
variable->impl.definiton = def;
|
||||
g_array_append_val(*variables, variable);
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
//int: a,b,c = 5
|
||||
//
|
||||
//GArray.data:
|
||||
// 1. Variable
|
||||
// kind = VariableKindDefinition;
|
||||
// name = a;
|
||||
// impl.definition:
|
||||
// initilizer:
|
||||
// createExpression(...)
|
||||
// decl:
|
||||
// qulifier:
|
||||
// type:
|
||||
// pointer
|
||||
//
|
||||
//
|
||||
// 2. Variable
|
||||
// kind = VariableKindDefinition;
|
||||
// name = b;
|
||||
// impl.definition:
|
||||
// initilizer: 5
|
||||
// decl:
|
||||
// qulifier:
|
||||
// type:
|
||||
// pointer
|
||||
// .
|
||||
// .
|
||||
// .
|
||||
//
|
||||
|
||||
|
||||
|
||||
|
||||
int getVariableFromScope(const char* name, Variable** variable) {
|
||||
assert(name != NULL);
|
||||
assert(variable != NULL);
|
||||
|
|
@ -413,17 +484,23 @@ TypeValue createTypeValue(AST_NODE_PTR currentNode){
|
|||
return value;
|
||||
}
|
||||
|
||||
static inline void* clone(int size, void* ptr) {
|
||||
char* data = malloc(size);
|
||||
memcpy(data, ptr, size);
|
||||
return data;
|
||||
}
|
||||
|
||||
#define CLONE(x) clone(sizeof(x), (void*)&(x))
|
||||
|
||||
TypeValue createString(AST_NODE_PTR currentNode) {
|
||||
TypeValue value;
|
||||
Type *type = (Type*) &StringLiteralType;
|
||||
Type *type = CLONE(StringLiteralType);
|
||||
value.type = type;
|
||||
value.nodePtr = currentNode;
|
||||
value.value = currentNode->value;
|
||||
return value;
|
||||
}
|
||||
|
||||
Expression* createExpression(AST_NODE_PTR currentNode);
|
||||
|
||||
Type* createTypeFromOperands(Type* LeftOperandType, Type* RightOperandType, AST_NODE_PTR currentNode) {
|
||||
Type *result = malloc(sizeof(Type));
|
||||
result->nodePtr = currentNode;
|
||||
|
|
@ -650,7 +727,7 @@ int createBoolNotOperation(Expression *ParentExpression, AST_NODE_PTR currentNod
|
|||
//fill Operand
|
||||
Expression* expression = createExpression(currentNode->children[0]);
|
||||
if(NULL == expression){
|
||||
return 1;
|
||||
return SEMANTIC_ERROR;
|
||||
}
|
||||
g_array_append_val(ParentExpression->impl.operation.operands , expression);
|
||||
|
||||
|
|
@ -660,35 +737,38 @@ int createBoolNotOperation(Expression *ParentExpression, AST_NODE_PTR currentNod
|
|||
|
||||
Type* result = malloc(sizeof(Type));
|
||||
result->nodePtr = currentNode;
|
||||
|
||||
if (Operand->kind == TypeKindBox || Operand->kind == TypeKindReference) {
|
||||
return 1;
|
||||
print_diagnostic(current_file, &Operand->nodePtr->location, Error, "Operand must be a variant of primitive type int");
|
||||
return SEMANTIC_ERROR;
|
||||
}
|
||||
|
||||
if (Operand->kind == TypeKindPrimitive) {
|
||||
if (Operand->impl.primitive == Float) {
|
||||
return 1;
|
||||
print_diagnostic(current_file, &Operand->nodePtr->location, Error, "Operand must be a variant of primitive type int");
|
||||
return SEMANTIC_ERROR;
|
||||
}
|
||||
result->kind = Operand->kind;
|
||||
result->impl = Operand->impl;
|
||||
|
||||
} else if(Operand->kind == TypeKindComposite) {
|
||||
if (Operand->impl.composite.primitive == Float) {
|
||||
return 1;
|
||||
print_diagnostic(current_file, &Operand->nodePtr->location, Error, "Operand must be a variant of primitive type int");
|
||||
return SEMANTIC_ERROR;
|
||||
}
|
||||
result->kind = Operand->kind;
|
||||
result->impl = Operand->impl;
|
||||
}
|
||||
|
||||
ParentExpression->result = result;
|
||||
return 0;
|
||||
return SEMANTIC_OK;
|
||||
}
|
||||
|
||||
bool isScaleEqual(double leftScale, double rightScale) {
|
||||
int leftIntScale =(int)(leftScale *4);
|
||||
int rightIntScale =(int)(rightScale *4);
|
||||
int leftIntScale = (int) (leftScale * BASE_BYTES);
|
||||
int rightIntScale = (int) (rightScale * BASE_BYTES);
|
||||
|
||||
if (leftIntScale == rightIntScale){
|
||||
return TRUE;
|
||||
}
|
||||
return FALSE;
|
||||
return leftIntScale == rightIntScale;
|
||||
}
|
||||
|
||||
int createBitOperation(Expression* ParentExpression, AST_NODE_PTR currentNode) {
|
||||
|
|
@ -699,70 +779,110 @@ int createBitOperation(Expression* ParentExpression, AST_NODE_PTR currentNode){
|
|||
// fill Operands
|
||||
for (size_t i = 0; i < currentNode->child_count; i++) {
|
||||
Expression* expression = createExpression(currentNode->children[i]);
|
||||
|
||||
if(NULL == expression) {
|
||||
return 1;
|
||||
}
|
||||
g_array_append_val(ParentExpression->impl.operation.operands , expression);
|
||||
return SEMANTIC_ERROR;
|
||||
}
|
||||
|
||||
g_array_append_val(ParentExpression->impl.operation.operands , expression);
|
||||
}
|
||||
|
||||
switch (currentNode->kind) {
|
||||
case AST_BitAnd:
|
||||
ParentExpression->impl.operation.impl.bitwise = BitwiseAnd;
|
||||
break;
|
||||
case AST_BitOr:
|
||||
ParentExpression->impl.operation.impl.bitwise = BitwiseOr;
|
||||
break;
|
||||
case AST_BitXor:
|
||||
ParentExpression->impl.operation.impl.bitwise = BitwiseXor;
|
||||
break;
|
||||
default:
|
||||
PANIC("Current node is not an bitwise operater");
|
||||
break;
|
||||
}
|
||||
|
||||
|
||||
Type *result = malloc(sizeof(Type));
|
||||
result->nodePtr = currentNode;
|
||||
|
||||
Type* LeftOperandType = ((Expression**) ParentExpression->impl.operation.operands->data)[0]->result;
|
||||
Type* RightOperandType = ((Expression**) ParentExpression->impl.operation.operands->data)[1]->result;
|
||||
Expression* lhs = ((Expression**) ParentExpression->impl.operation.operands->data)[0];
|
||||
Expression* rhs = ((Expression**) ParentExpression->impl.operation.operands->data)[1];
|
||||
|
||||
Type* LeftOperandType = lhs->result;
|
||||
Type* RightOperandType = rhs->result;
|
||||
|
||||
//should not be a box or a reference
|
||||
if (LeftOperandType->kind != TypeKindPrimitive && LeftOperandType->kind != TypeKindComposite) {
|
||||
return 1;
|
||||
print_diagnostic(current_file, &lhs->nodePtr->location, Error, "Must be a type variant of int");
|
||||
return SEMANTIC_ERROR;
|
||||
}
|
||||
|
||||
if (RightOperandType->kind != TypeKindPrimitive && RightOperandType->kind != TypeKindComposite) {
|
||||
return 1;
|
||||
print_diagnostic(current_file, &rhs->nodePtr->location, Error, "Must be a type variant of int");
|
||||
return SEMANTIC_ERROR;
|
||||
}
|
||||
|
||||
if (LeftOperandType->kind == TypeKindPrimitive && RightOperandType->kind == TypeKindPrimitive) {
|
||||
if(LeftOperandType->impl.primitive == Float || RightOperandType->impl.primitive == Float){
|
||||
return 1;
|
||||
|
||||
if (LeftOperandType->impl.primitive == Float) {
|
||||
print_diagnostic(current_file, &lhs->nodePtr->location, Error, "Must be a type variant of int");
|
||||
return SEMANTIC_ERROR;
|
||||
}
|
||||
|
||||
if (RightOperandType->impl.primitive == Float) {
|
||||
print_diagnostic(current_file, &rhs->nodePtr->location, Error, "Must be a type variant of int");
|
||||
return SEMANTIC_ERROR;
|
||||
}
|
||||
|
||||
result->kind = TypeKindPrimitive;
|
||||
result->impl.primitive = Int;
|
||||
|
||||
} else if (LeftOperandType->kind == TypeKindPrimitive && RightOperandType->kind == TypeKindComposite) {
|
||||
if(LeftOperandType->impl.primitive == Float || RightOperandType->impl.composite.primitive == Float){
|
||||
return 1;
|
||||
|
||||
if (LeftOperandType->impl.primitive == Float) {
|
||||
print_diagnostic(current_file, &lhs->nodePtr->location, Error, "Must be a type variant of int");
|
||||
return SEMANTIC_ERROR;
|
||||
}
|
||||
if((int)RightOperandType->impl.composite.scale != 1){
|
||||
return 1;
|
||||
|
||||
if (RightOperandType->impl.composite.primitive == Float) {
|
||||
print_diagnostic(current_file, &rhs->nodePtr->location, Error, "Must be a type variant of int");
|
||||
return SEMANTIC_ERROR;
|
||||
}
|
||||
|
||||
result->kind = TypeKindPrimitive;
|
||||
result->impl.primitive = Int;
|
||||
|
||||
}else if (LeftOperandType->kind == TypeKindComposite && RightOperandType->kind == TypeKindPrimitive) {
|
||||
if(LeftOperandType->impl.composite.primitive == Float || RightOperandType->impl.primitive == Float){
|
||||
return 1;
|
||||
|
||||
if (LeftOperandType->impl.composite.primitive == Float) {
|
||||
print_diagnostic(current_file, &lhs->nodePtr->location, Error, "Must be a type variant of int");
|
||||
return SEMANTIC_ERROR;
|
||||
}
|
||||
if((int)LeftOperandType->impl.composite.scale != 1){
|
||||
return 1;
|
||||
|
||||
if (RightOperandType->impl.primitive == Float) {
|
||||
print_diagnostic(current_file, &rhs->nodePtr->location, Error, "Must be a type variant of int");
|
||||
return SEMANTIC_ERROR;
|
||||
}
|
||||
|
||||
result->kind = TypeKindPrimitive;
|
||||
result->impl.primitive = Int;
|
||||
} else {
|
||||
if(LeftOperandType->impl.composite.primitive == Float || RightOperandType->impl.composite.primitive == Float){
|
||||
return 1;
|
||||
|
||||
if (RightOperandType->impl.composite.primitive == Float) {
|
||||
print_diagnostic(current_file, &rhs->nodePtr->location, Error, "Must be a type variant of int");
|
||||
return SEMANTIC_ERROR;
|
||||
}
|
||||
|
||||
if (LeftOperandType->impl.composite.primitive == Float) {
|
||||
print_diagnostic(current_file, &lhs->nodePtr->location, Error, "Must be a type variant of int");
|
||||
return SEMANTIC_ERROR;
|
||||
}
|
||||
|
||||
if (!isScaleEqual(LeftOperandType->impl.composite.scale, RightOperandType->impl.composite.scale)) {
|
||||
return 1;
|
||||
print_diagnostic(current_file, ¤tNode->location, Error, "Operands must be of equal size");
|
||||
return SEMANTIC_ERROR;
|
||||
}
|
||||
|
||||
result->kind = TypeKindComposite;
|
||||
result->impl.composite.nodePtr = currentNode;
|
||||
result->impl.composite.scale = LeftOperandType->impl.composite.scale;
|
||||
|
|
@ -781,7 +901,7 @@ int createBitNotOperation(Expression* ParentExpression, AST_NODE_PTR currentNode
|
|||
//fill Operand
|
||||
Expression* expression = createExpression(currentNode->children[0]);
|
||||
if(NULL == expression){
|
||||
return 1;
|
||||
return SEMANTIC_ERROR;
|
||||
}
|
||||
g_array_append_val(ParentExpression->impl.operation.operands , expression);
|
||||
|
||||
|
|
@ -792,17 +912,22 @@ int createBitNotOperation(Expression* ParentExpression, AST_NODE_PTR currentNode
|
|||
Type* result = malloc(sizeof(Type));
|
||||
result->nodePtr = currentNode;
|
||||
|
||||
|
||||
if (Operand->kind == TypeKindPrimitive) {
|
||||
|
||||
if (Operand->impl.primitive == Float) {
|
||||
print_diagnostic(current_file, &Operand->nodePtr->location, Error, "Operand type must be a variant of int");
|
||||
return SEMANTIC_ERROR;
|
||||
}
|
||||
|
||||
result->kind = TypeKindPrimitive;
|
||||
result->impl.primitive = Int;
|
||||
}else if(Operand->kind == TypeKindComposite) {
|
||||
|
||||
if (Operand->impl.composite.primitive == Float) {
|
||||
print_diagnostic(current_file, &Operand->nodePtr->location, Error, "Operand type must be a variant of int");
|
||||
return SEMANTIC_ERROR;
|
||||
}
|
||||
|
||||
result->kind = TypeKindComposite;
|
||||
result->impl.composite.nodePtr = currentNode;
|
||||
result->impl.composite.primitive = Int;
|
||||
|
|
@ -811,12 +936,12 @@ int createBitNotOperation(Expression* ParentExpression, AST_NODE_PTR currentNode
|
|||
}
|
||||
|
||||
ParentExpression->result = result;
|
||||
|
||||
return SEMANTIC_OK;
|
||||
}
|
||||
|
||||
GArray* getBoxMember(Type* currentBoxType, GArray *names) {
|
||||
|
||||
|
||||
GArray *members = g_array_new(FALSE, FALSE, sizeof(BoxMember));
|
||||
GHashTable* memberList = currentBoxType->impl.box.member;
|
||||
|
||||
|
|
@ -850,6 +975,7 @@ int createBoxAccess(Expression* ParentExpression,AST_NODE_PTR currentNode) {
|
|||
int status = getVariableFromScope(boxname, &boxVariable);
|
||||
|
||||
if(status == SEMANTIC_ERROR){
|
||||
print_diagnostic(current_file, ¤tNode->children[0]->location, Error, "Variable of name `%s` does not exist");
|
||||
return SEMANTIC_ERROR;
|
||||
}
|
||||
Type* boxType;
|
||||
|
|
@ -865,6 +991,7 @@ int createBoxAccess(Expression* ParentExpression,AST_NODE_PTR currentNode) {
|
|||
if (boxType->kind != TypeKindBox) {
|
||||
return SEMANTIC_ERROR;
|
||||
}
|
||||
|
||||
// filling boxAccess variable
|
||||
ParentExpression->impl.variable->kind = VariableKindBoxMember;
|
||||
ParentExpression->impl.variable->nodePtr = currentNode;
|
||||
|
|
@ -876,8 +1003,16 @@ int createBoxAccess(Expression* ParentExpression,AST_NODE_PTR currentNode) {
|
|||
|
||||
//first one is the box itself
|
||||
GArray* names = malloc(sizeof(GArray));
|
||||
if(currentNode->kind == AST_IdentList){
|
||||
for (size_t i = 1; i < currentNode->child_count; i++){
|
||||
g_array_append_val(names, currentNode->children[1]->value);
|
||||
g_array_append_val(names, currentNode->children[i]->value);
|
||||
}
|
||||
}else if(currentNode->kind == AST_List){
|
||||
for (size_t i = 1; i < currentNode->children[1]->child_count; i++){
|
||||
g_array_append_val(names, currentNode->children[1]->children[i]->value);
|
||||
}
|
||||
}else{
|
||||
PANIC("current Node is not an Access");
|
||||
}
|
||||
|
||||
GArray * boxMember = getBoxMember(boxType, names);
|
||||
|
|
@ -887,6 +1022,50 @@ int createBoxAccess(Expression* ParentExpression,AST_NODE_PTR currentNode) {
|
|||
|
||||
}
|
||||
|
||||
int createTypeCast(Expression* ParentExpression, AST_NODE_PTR currentNode){
|
||||
ParentExpression->impl.typecast.nodePtr = currentNode;
|
||||
|
||||
ParentExpression->impl.typecast.operand = createExpression(currentNode->children[0]);
|
||||
if (ParentExpression->impl.typecast.operand == NULL){
|
||||
return SEMANTIC_ERROR;
|
||||
}
|
||||
|
||||
Type* target = malloc(sizeof(Type));
|
||||
int status = get_type_impl(currentNode->children[1], &target);
|
||||
if (status) {
|
||||
print_diagnostic(current_file, ¤tNode->children[1]->location, Error, "Unknown type");
|
||||
return SEMANTIC_ERROR;
|
||||
}
|
||||
ParentExpression->impl.typecast.targetType = target;
|
||||
ParentExpression->result = target;
|
||||
|
||||
return SEMANTIC_OK;
|
||||
}
|
||||
|
||||
int createTransmute(Expression* ParentExpression, AST_NODE_PTR currentNode){
|
||||
ParentExpression->impl.transmute.nodePtr = currentNode;
|
||||
ParentExpression->impl.transmute.operand = createExpression(currentNode->children[0]);
|
||||
|
||||
if (ParentExpression->impl.transmute.operand == NULL){
|
||||
return SEMANTIC_ERROR;
|
||||
}
|
||||
|
||||
Type* target = malloc(sizeof(Type));
|
||||
int status = get_type_impl(currentNode->children[1], &target);
|
||||
if (status){
|
||||
print_diagnostic(current_file, ¤tNode->children[1]->location, Error, "Unknown type");
|
||||
return SEMANTIC_ERROR;
|
||||
}
|
||||
|
||||
ParentExpression->impl.typecast.targetType = target;
|
||||
ParentExpression->result = target;
|
||||
|
||||
return SEMANTIC_OK;
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
Expression *createExpression(AST_NODE_PTR currentNode){
|
||||
Expression *expression = malloc(sizeof(Expression));
|
||||
expression->nodePtr = currentNode;
|
||||
|
|
@ -908,6 +1087,7 @@ Expression *createExpression(AST_NODE_PTR currentNode){
|
|||
int status = getVariableFromScope(currentNode->value, &expression->impl.variable );
|
||||
if(status == SEMANTIC_ERROR){
|
||||
DEBUG("Identifier is not in current scope");
|
||||
print_diagnostic(current_file, ¤tNode->location, Error, "Variable not found");
|
||||
return NULL;
|
||||
}
|
||||
switch (expression->impl.variable->kind) {
|
||||
|
|
@ -975,16 +1155,24 @@ Expression *createExpression(AST_NODE_PTR currentNode){
|
|||
break;
|
||||
|
||||
case AST_IdentList:
|
||||
expression->kind = ExpressionKindVariable;
|
||||
|
||||
//Box Accsess
|
||||
case AST_List:
|
||||
// Box Self Access
|
||||
case AST_Typekind:
|
||||
expression->kind = ExpressionKindVariable;
|
||||
if(createBoxAccess(expression, currentNode)){
|
||||
return NULL;
|
||||
}
|
||||
break;
|
||||
case AST_Typecast:
|
||||
expression->kind = ExpressionKindTypeCast;
|
||||
if(createTypeCast(expression, currentNode)){
|
||||
return NULL;
|
||||
}
|
||||
break;
|
||||
case AST_Transmute:
|
||||
|
||||
|
||||
|
||||
expression->kind = ExpressionKindTransmute;
|
||||
if(createTransmute(expression, currentNode)){
|
||||
return NULL;
|
||||
}
|
||||
break;
|
||||
default:
|
||||
PANIC("Node is not an expression but from kind: %i", currentNode->kind);
|
||||
break;
|
||||
|
|
@ -993,10 +1181,152 @@ Expression *createExpression(AST_NODE_PTR currentNode){
|
|||
}
|
||||
|
||||
|
||||
int createAssign(Statement* ParentStatement, AST_NODE_PTR currentNode){
|
||||
Assignment assign;
|
||||
assign.nodePtr = currentNode;
|
||||
const char* varName = currentNode->children[0]->value;
|
||||
|
||||
int status = getVariableFromScope(varName, &assign.variable);
|
||||
if(status){
|
||||
return SEMANTIC_ERROR;
|
||||
}
|
||||
|
||||
assign.value = createExpression(currentNode->children[1]);
|
||||
if(assign.value == NULL){
|
||||
return SEMANTIC_ERROR;
|
||||
}
|
||||
|
||||
ParentStatement->impl.assignment = assign;
|
||||
return SEMANTIC_ERROR;
|
||||
}
|
||||
Statement *createStatement(AST_NODE_PTR currentNode);
|
||||
|
||||
int createWhile(Statement * ParentStatement, AST_NODE_PTR currentNode){
|
||||
assert(ParentExpression == NULL);
|
||||
assert(currentNode == NULL);
|
||||
assert(currentNode->kind == AST_While);
|
||||
|
||||
While whileStruct;
|
||||
whileStruct.nodePtr = currentNode;
|
||||
whileStruct.conditon = createExpression(currentNode->children[0]);
|
||||
if(NULL == whileStruct.conditon){
|
||||
return SEMANTIC_ERROR;
|
||||
}
|
||||
AST_NODE_PTR statementList = currentNode->children[1];
|
||||
whileStruct.block.nodePtr = statementList;
|
||||
|
||||
for(size_t i = 0; i < statementList->child_count; i++){
|
||||
Statement* statement = createStatement(statementList->children[i]);
|
||||
if (NULL == statement) {
|
||||
return SEMANTIC_ERROR;
|
||||
}
|
||||
g_array_append_val(whileStruct.block.statemnts, statement);
|
||||
}
|
||||
ParentStatement->impl.whileLoop = whileStruct;
|
||||
|
||||
return SEMANTIC_OK;
|
||||
}
|
||||
|
||||
int fillBlock(Block * block,AST_NODE_PTR currentNode){
|
||||
block->nodePtr = currentNode;
|
||||
|
||||
for(size_t i = 0; i < currentNode->child_count; i++){
|
||||
Statement* statement = createStatement(currentNode->children[i]);
|
||||
if(statement == NULL){
|
||||
return SEMANTIC_ERROR;
|
||||
}
|
||||
g_array_append_val(block->statemnts,statement);
|
||||
}
|
||||
return SEMANTIC_OK;
|
||||
}
|
||||
|
||||
int createIf(Branch* Parentbranch, AST_NODE_PTR currentNode){
|
||||
If ifbranch;
|
||||
ifbranch.nodePtr = currentNode;
|
||||
|
||||
Expression* expression = createExpression(currentNode->children[0]);
|
||||
if (NULL == expression) {
|
||||
return SEMANTIC_ERROR;
|
||||
}
|
||||
ifbranch.conditon = expression;
|
||||
int status = fillBlock(&ifbranch.block, currentNode->children[1]);
|
||||
|
||||
}
|
||||
|
||||
int createBranch(Statement* ParentStatement,AST_NODE_PTR currentNode){
|
||||
Branch Branch;
|
||||
|
||||
for (size_t i = 0; i < currentNode->child_count; i++ ){
|
||||
switch (currentNode->children[i]->kind){
|
||||
case AST_If:
|
||||
createIf(&Branch, currentNode->children[i]);
|
||||
case AST_IfElse:
|
||||
case AST_Else:
|
||||
default:
|
||||
PANIC("current node is not part of a Branch")
|
||||
break;
|
||||
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
Statement *createStatement(AST_NODE_PTR currentNode){
|
||||
Statement* statement = malloc(sizeof(Statement));
|
||||
statement->nodePtr = currentNode;
|
||||
|
||||
switch(currentNode->kind){
|
||||
case AST_Decl:
|
||||
statement->kind = StatementKindDeclaration;
|
||||
|
||||
case AST_Def:
|
||||
statement->kind = StatementKindDefinition;
|
||||
case AST_While:
|
||||
statement->kind = StatementKindWhile;
|
||||
if(createWhile(statement, currentNode)){
|
||||
return NULL;
|
||||
}
|
||||
case AST_Stmt:
|
||||
statement->kind = StatementKindBranch;
|
||||
//ifbrnches:
|
||||
|
||||
case AST_Assign:
|
||||
statement->kind = StatementKindAssignment;
|
||||
if(createAssign(statement, currentNode)){
|
||||
return NULL;
|
||||
}
|
||||
case AST_Call:
|
||||
//both funcall and boxfuncall
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
|
||||
|
||||
Function *createFunction(AST_NODE_PTR currentNode){
|
||||
|
||||
}
|
||||
|
||||
BoxType *createBox(AST_NODE_PTR currentNode){
|
||||
BoxType * box = malloc(sizeof(BoxType));
|
||||
|
||||
box->nodePtr = currentNode;
|
||||
|
||||
//
|
||||
//box
|
||||
// name
|
||||
// list
|
||||
// decl
|
||||
// def // change BoxMember to have an
|
||||
// fun //create static function
|
||||
// a.b(dsadsadas)
|
||||
|
||||
|
||||
|
||||
}
|
||||
|
||||
Module *create_set(AST_NODE_PTR currentNode){
|
||||
DEBUG("create root Module");
|
||||
|
|
@ -1053,7 +1383,9 @@ Module *create_set(AST_NODE_PTR currentNode){
|
|||
break;
|
||||
}
|
||||
case AST_Box:
|
||||
|
||||
case AST_Fun:
|
||||
case AST_Typedef:
|
||||
case AST_Import:
|
||||
DEBUG("create Import");
|
||||
g_array_append_val(imports, currentNode->children[i]->value);
|
||||
|
|
|
|||
|
|
@ -5,6 +5,9 @@
|
|||
#include <glib.h>
|
||||
#include <ast/ast.h>
|
||||
|
||||
// with of primitive types (int/float) in bytes
|
||||
#define BASE_BYTES 4
|
||||
|
||||
/**
|
||||
* @brief Primitive types form the basis of all other types.
|
||||
*
|
||||
|
|
@ -36,7 +39,7 @@ typedef enum Sign_t {
|
|||
typedef double Scale;
|
||||
|
||||
/**
|
||||
* @brief A composite type is an extended definiton of a primitive type.
|
||||
* @brief A composite type is an extended definition of a primitive type.
|
||||
*
|
||||
*/
|
||||
typedef struct CompositeType_t {
|
||||
|
|
@ -124,7 +127,7 @@ typedef struct Typedefine_t {
|
|||
|
||||
|
||||
/**
|
||||
* @brief Reprents the value of type. Can be used to definitons, initialization and for expressions contants.
|
||||
* @brief Reprents the value of type. Can be used to definitions, initialization and for expressions contants.
|
||||
*
|
||||
*/
|
||||
typedef struct TypeValue_t {
|
||||
|
|
@ -183,7 +186,7 @@ typedef enum ParameterKind_t {
|
|||
} ParameterKind;
|
||||
|
||||
/**
|
||||
* @brief A parameter can either be a declaration or a definiton
|
||||
* @brief A parameter can either be a declaration or a definition
|
||||
*
|
||||
*/
|
||||
typedef struct Parameter_t {
|
||||
|
|
@ -245,7 +248,7 @@ typedef struct VariableDeclaration_t {
|
|||
} VariableDeclaration;
|
||||
|
||||
/**
|
||||
* @brief Definiton of a variable
|
||||
* @brief Definition of a variable
|
||||
*
|
||||
* @attention NOTE: The types of the initializer and the declaration must be equal
|
||||
*
|
||||
|
|
@ -455,7 +458,7 @@ typedef struct Block_t {
|
|||
// '------------------------------------------------'
|
||||
|
||||
typedef struct While_t {
|
||||
Expression conditon;
|
||||
Expression *conditon;
|
||||
Block block;
|
||||
AST_NODE_PTR nodePtr;
|
||||
} While;
|
||||
|
|
@ -465,13 +468,13 @@ typedef struct While_t {
|
|||
// '------------------------------------------------'
|
||||
|
||||
typedef struct If_t {
|
||||
Expression conditon;
|
||||
Expression *conditon;
|
||||
Block block;
|
||||
AST_NODE_PTR nodePtr;
|
||||
} If;
|
||||
|
||||
typedef struct ElseIf_t {
|
||||
Expression conditon;
|
||||
Expression *conditon;
|
||||
Block block;
|
||||
AST_NODE_PTR nodePtr;
|
||||
} ElseIf;
|
||||
|
|
@ -495,7 +498,7 @@ typedef struct Branch_t {
|
|||
|
||||
typedef struct Assignment_t {
|
||||
Variable* variable;
|
||||
Expression value;
|
||||
Expression* value;
|
||||
AST_NODE_PTR nodePtr;
|
||||
} Assignment;
|
||||
|
||||
|
|
@ -504,7 +507,9 @@ typedef enum StatementKind_t {
|
|||
StatementKindFunctionBoxCall,
|
||||
StatementKindWhile,
|
||||
StatementKindBranch,
|
||||
StatementKindAssignment
|
||||
StatementKindAssignment,
|
||||
StatementKindDeclaration,
|
||||
StatementKindDefinition
|
||||
} StatementKind;
|
||||
|
||||
typedef struct Statement_t {
|
||||
|
|
@ -515,6 +520,7 @@ typedef struct Statement_t {
|
|||
While whileLoop;
|
||||
Branch branch;
|
||||
Assignment assignment;
|
||||
Variable variable;
|
||||
} impl;
|
||||
AST_NODE_PTR nodePtr;
|
||||
} Statement;
|
||||
|
|
|
|||
Loading…
Reference in New Issue