solstice/v2
Archived
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Add all the other inequalities

Browse Source
This commit is contained in:
Maxwell
2026-02-28 10:25:26 +11:00
parent 8756dd08c8
commit fbddd9a199
3 changed files with 526 additions and 1 deletions
Download Patch File Download Diff File Expand all files Collapse all files

198
src/codegen/codegen.c
View File

@@ -97,7 +97,8 @@ ResultType(SolsType, charptr) getNodeType(SolsNode* node, SolsScope* scope) {
}
return Success(SolsType, charptr, type.as.success);
}
case SNT_OP_EQUAL: {
case SNT_OP_EQUAL:
case SNT_OP_INEQUAL: {
if (node->children.count < 2) {
return Error(SolsType, charptr, "Not enough children to determine type");
}
@@ -128,6 +129,32 @@ ResultType(SolsType, charptr) getNodeType(SolsNode* node, SolsScope* scope) {
return Error(SolsType, charptr, "");
}
case SNT_OP_GREATER:
case SNT_OP_LESSER:
case SNT_OP_EQGREATER:
case SNT_OP_EQLESSER: {
if (node->children.count < 2) {
return Error(SolsType, charptr, "Not enough children to determine type");
}
ResultType(SolsType, charptr) leftType = getNodeType(&node->children.at[0], scope);
if (leftType.error) {
return Error(SolsType, charptr, leftType.as.error);
}
ResultType(SolsType, charptr) rightType = getNodeType(&node->children.at[1], scope);
if (rightType.error) {
return Error(SolsType, charptr, rightType.as.error);
}
if (!(leftType.as.success.type == STT_INT || leftType.as.success.type == STT_DOUBLE)) {
return Error(SolsType, charptr, "Cannot compare with left type");
}
if (!(rightType.as.success.type == STT_INT || rightType.as.success.type == STT_DOUBLE)) {
return Error(SolsType, charptr, "Cannot compare with right type");
}
return Success(SolsType, charptr, STT_BOOL);
}
case SNT_LITERAL: {
switch (node->as.literal.type) {
case SLT_INT: {
@@ -363,6 +390,170 @@ static inline ResultType(GroundProgram, charptr) generateEqualNode(SolsNode* nod
return Success(GroundProgram, charptr, gp);
}
static inline ResultType(GroundProgram, charptr) generateInequalNode(SolsNode* node, SolsScope* scope) {
if (node->children.count < 2) {
return Error(GroundProgram, charptr, "inequal requires arguments");
}
// Use this function for type checking
ResultType(SolsType, charptr) type = getNodeType(node, scope);
if (type.error) {
return Error(GroundProgram, charptr, type.as.error);
}
GroundProgram gp = groundCreateProgram();
GroundInstruction add = groundCreateInstruction(INEQUAL);
groundAddReferenceToInstruction(&add, node->children.at[0].accessArg);
groundAddReferenceToInstruction(&add, node->children.at[1].accessArg);
char* tmpId = malloc(sizeof(char) * 64);
if (tmpId == NULL) {
return Error(GroundProgram, charptr, "Failed to allocate memory for temporary identifier in inequal");
}
snprintf(tmpId, 64, "__SOLS_TMP_INEQUAL_%zu", scope->tmpCounter++);
groundAddReferenceToInstruction(&add, groundCreateReference(DIRREF, tmpId));
node->accessArg = groundCreateReference(VALREF, tmpId);
groundAddInstructionToProgram(&gp, add);
return Success(GroundProgram, charptr, gp);
}
static inline ResultType(GroundProgram, charptr) generateGreaterNode(SolsNode* node, SolsScope* scope) {
if (node->children.count < 2) {
return Error(GroundProgram, charptr, "greater requires arguments");
}
// Use this function for type checking
ResultType(SolsType, charptr) type = getNodeType(node, scope);
if (type.error) {
return Error(GroundProgram, charptr, type.as.error);
}
GroundProgram gp = groundCreateProgram();
GroundInstruction add = groundCreateInstruction(GREATER);
groundAddReferenceToInstruction(&add, node->children.at[0].accessArg);
groundAddReferenceToInstruction(&add, node->children.at[1].accessArg);
char* tmpId = malloc(sizeof(char) * 64);
if (tmpId == NULL) {
return Error(GroundProgram, charptr, "Failed to allocate memory for temporary identifier in greater");
}
snprintf(tmpId, 64, "__SOLS_TMP_GREATER_%zu", scope->tmpCounter++);
groundAddReferenceToInstruction(&add, groundCreateReference(DIRREF, tmpId));
node->accessArg = groundCreateReference(VALREF, tmpId);
groundAddInstructionToProgram(&gp, add);
return Success(GroundProgram, charptr, gp);
}
static inline ResultType(GroundProgram, charptr) generateEqGreaterNode(SolsNode* node, SolsScope* scope) {
if (node->children.count < 2) {
return Error(GroundProgram, charptr, "eqgreater requires arguments");
}
// Use this function for type checking
ResultType(SolsType, charptr) type = getNodeType(node, scope);
if (type.error) {
return Error(GroundProgram, charptr, type.as.error);
}
GroundProgram gp = groundCreateProgram();
GroundInstruction add = groundCreateInstruction(LESSER);
groundAddReferenceToInstruction(&add, node->children.at[0].accessArg);
groundAddReferenceToInstruction(&add, node->children.at[1].accessArg);
char* tmpId = malloc(sizeof(char) * 64);
if (tmpId == NULL) {
return Error(GroundProgram, charptr, "Failed to allocate memory for temporary identifier in eqgreater");
}
snprintf(tmpId, 64, "__SOLS_TMP_EQGREATER_%zu", scope->tmpCounter++);
groundAddReferenceToInstruction(&add, groundCreateReference(DIRREF, tmpId));
node->accessArg = groundCreateReference(VALREF, tmpId);
groundAddInstructionToProgram(&gp, add);
GroundInstruction not = groundCreateInstruction(NOT);
groundAddReferenceToInstruction(&not, groundCreateReference(VALREF, tmpId));
groundAddReferenceToInstruction(&not, groundCreateReference(DIRREF, tmpId));
groundAddInstructionToProgram(&gp, not);
return Success(GroundProgram, charptr, gp);
}
static inline ResultType(GroundProgram, charptr) generateLesserNode(SolsNode* node, SolsScope* scope) {
if (node->children.count < 2) {
return Error(GroundProgram, charptr, "lesser requires arguments");
}
// Use this function for type checking
ResultType(SolsType, charptr) type = getNodeType(node, scope);
if (type.error) {
return Error(GroundProgram, charptr, type.as.error);
}
GroundProgram gp = groundCreateProgram();
GroundInstruction add = groundCreateInstruction(LESSER);
groundAddReferenceToInstruction(&add, node->children.at[0].accessArg);
groundAddReferenceToInstruction(&add, node->children.at[1].accessArg);
char* tmpId = malloc(sizeof(char) * 64);
if (tmpId == NULL) {
return Error(GroundProgram, charptr, "Failed to allocate memory for temporary identifier in lesser");
}
snprintf(tmpId, 64, "__SOLS_TMP_LESSER_%zu", scope->tmpCounter++);
groundAddReferenceToInstruction(&add, groundCreateReference(DIRREF, tmpId));
node->accessArg = groundCreateReference(VALREF, tmpId);
groundAddInstructionToProgram(&gp, add);
return Success(GroundProgram, charptr, gp);
}
static inline ResultType(GroundProgram, charptr) generateEqLesserNode(SolsNode* node, SolsScope* scope) {
if (node->children.count < 2) {
return Error(GroundProgram, charptr, "eqlesser requires arguments");
}
// Use this function for type checking
ResultType(SolsType, charptr) type = getNodeType(node, scope);
if (type.error) {
return Error(GroundProgram, charptr, type.as.error);
}
GroundProgram gp = groundCreateProgram();
GroundInstruction add = groundCreateInstruction(GREATER);
groundAddReferenceToInstruction(&add, node->children.at[0].accessArg);
groundAddReferenceToInstruction(&add, node->children.at[1].accessArg);
char* tmpId = malloc(sizeof(char) * 64);
if (tmpId == NULL) {
return Error(GroundProgram, charptr, "Failed to allocate memory for temporary identifier in eqlesser");
}
snprintf(tmpId, 64, "__SOLS_TMP_LESSER_%zu", scope->tmpCounter++);
groundAddReferenceToInstruction(&add, groundCreateReference(DIRREF, tmpId));
node->accessArg = groundCreateReference(VALREF, tmpId);
groundAddInstructionToProgram(&gp, add);
GroundInstruction not = groundCreateInstruction(NOT);
groundAddReferenceToInstruction(&not, groundCreateReference(VALREF, tmpId));
groundAddReferenceToInstruction(&not, groundCreateReference(DIRREF, tmpId));
groundAddInstructionToProgram(&gp, not);
return Success(GroundProgram, charptr, gp);
}
ResultType(GroundProgram, charptr) generateCode(SolsNode* node, SolsScope* scope) {
GroundProgram program = groundCreateProgram();
@@ -388,6 +579,11 @@ ResultType(GroundProgram, charptr) generateCode(SolsNode* node, SolsScope* scope
case SNT_OP_MUL: generate(Mul);
case SNT_OP_DIV: generate(Div);
case SNT_OP_EQUAL: generate(Equal);
case SNT_OP_INEQUAL: generate(Inequal);
case SNT_OP_GREATER: generate(Greater);
case SNT_OP_EQGREATER: generate(EqGreater);
case SNT_OP_LESSER: generate(Lesser);
case SNT_OP_EQLESSER: generate(EqLesser);
}
return Success(GroundProgram, charptr, program);
}