DiamondNether90/ground_fork
1
0
Fork 0
forked from ground/ground
Code Pull Requests Activity

Compare commits

base: DiamondNether90:9cbe546e8a220bee464f87f6c8792c404ceb8ea1
Branches Tags
DiamondNether90:master ground:master
DiamondNether90:0.0.2 DiamondNether90:0.0.1 ground:0.0.1 ground:0.0.2
..
compare: DiamondNether90:master
Branches Tags
DiamondNether90:master ground:master
DiamondNether90:0.0.2 DiamondNether90:0.0.1 ground:0.0.1 ground:0.0.2

2 Commits
9cbe546e8a ... master

Author SHA1 Message Date
Maxwell Jeffress
9e329968d1 Error types, print lists, better fn calling 2025-09-13 15:47:24 +10:00
Maxwell
e56c560514 Merge pull request 'Add Error Function' (#18) from DiamondNether90/ground_fork:master into master 
Reviewed-on: max/ground#18
 2025-09-12 12:05:05 +10:00
5 changed files with 198 additions and 104 deletions
Expand all files Collapse all files

172
src/main.cpp
View File

@@ -78,8 +78,7 @@ enum class Instructions {
Getstrcharat, Getstrsize, Getstrcharat, Getstrsize,
Stoi, Stod, Tostring, Stoi, Stod, Tostring,
Fun, Return, Endfun, Pusharg, Call, Local, Fun, Return, Endfun, Pusharg, Call, Local,
Use, Extern, Use, Extern, Error, Catch, Try, Exception
Error
}; };
/* /*
@@ -370,8 +369,8 @@ Literal groundValueToLiteral(const GroundValue& gv) {
Takes a string (which is a debug message) and prints it to the console, letting the Takes a string (which is a debug message) and prints it to the console, letting the
user know what went wrong with the program. user know what went wrong with the program.
*/ */
void error(string in, int exitc = 1) { void error(string in, string errCode = "syntaxError", int exitc = 1) {
cout << "\033[31mError: \033[39m" << in << endl; cout << "\033[31m" + errCode + ": \033[39m" << in << endl;
exit(exitc); exit(exitc);
} }
@@ -485,6 +484,7 @@ Types getLitType(Literal in) {
if (holds_alternative<bool>(in.val)) return Types::Bool; if (holds_alternative<bool>(in.val)) return Types::Bool;
if (holds_alternative<string>(in.val)) return Types::String; if (holds_alternative<string>(in.val)) return Types::String;
if (holds_alternative<char>(in.val)) return Types::Char; if (holds_alternative<char>(in.val)) return Types::Char;
if (holds_alternative<List>(in.val)) return Types::List;
error("Literal for some reason has a weird type. This is not an issue with your program, but an issue with the Ground interpreter."); error("Literal for some reason has a weird type. This is not an issue with your program, but an issue with the Ground interpreter.");
return Types::Int; return Types::Int;
} }
@@ -595,7 +595,42 @@ Literal exec(vector<Instruction> in, bool executingFunction) {
cout << get<char>(get<Literal>(l.args[0]).val); cout << get<char>(get<Literal>(l.args[0]).val);
} }
else { else {
error("Couldn't print that"); error("Couldn't print that", "printError");
}
} else if (holds_alternative<ListRef>(l.args[0])) {
if (variables.find(get<ListRef>(l.args[0]).listName) != variables.end()) {
List list = get<List>(variables[get<ListRef>(l.args[0]).listName].val);
cout << "[";
for (int l = 0; l < list.val.size(); l++) {
if (holds_alternative<string>(list.val[l].val)) {
cout << '"' << get<string>(list.val[l].val) << '"';
}
else if (holds_alternative<int>(list.val[l].val)) {
cout << get<int>(list.val[l].val);
}
else if (holds_alternative<double>(list.val[l].val)) {
cout << get<double>(list.val[l].val);
}
else if (holds_alternative<bool>(list.val[l].val)) {
if (get<bool>(list.val[l].val) == true) {
cout << "true";
} else {
cout << "false";
}
}
else if (holds_alternative<char>(list.val[l].val)) {
cout << '\'' << get<char>(list.val[l].val) << '\'';
}
else {
error("Couldn't print that", "printError");
}
if (l != list.val.size() - 1) {
cout << ", ";
}
}
cout << "]";
} else {
error("Couldn't find list named " + get<ListRef>(l.args[0]).listName);
} }
} else { } else {
error("Argument of stdlnout must be a value (literal or a value reference)"); error("Argument of stdlnout must be a value (literal or a value reference)");
@@ -631,30 +666,78 @@ Literal exec(vector<Instruction> in, bool executingFunction) {
cout << get<char>(get<Literal>(l.args[0]).val) << endl; cout << get<char>(get<Literal>(l.args[0]).val) << endl;
} }
else { else {
error("Couldn't print that"); error("Couldn't print that", "printError");
}
} else if (holds_alternative<ListRef>(l.args[0])) {
if (variables.find(get<ListRef>(l.args[0]).listName) != variables.end()) {
List list = get<List>(variables[get<ListRef>(l.args[0]).listName].val);
cout << "[";
for (int l = 0; l < list.val.size(); l++) {
if (holds_alternative<string>(list.val[l].val)) {
cout << '"' << get<string>(list.val[l].val) << '"';
}
else if (holds_alternative<int>(list.val[l].val)) {
cout << get<int>(list.val[l].val);
}
else if (holds_alternative<double>(list.val[l].val)) {
cout << get<double>(list.val[l].val);
}
else if (holds_alternative<bool>(list.val[l].val)) {
if (get<bool>(list.val[l].val) == true) {
cout << "true";
} else {
cout << "false";
}
}
else if (holds_alternative<char>(list.val[l].val)) {
cout << '\'' << get<char>(list.val[l].val) << '\'';
}
else {
error("Couldn't print that", "printError");
}
if (l != list.val.size() - 1) {
cout << ", ";
}
}
cout << "]" << endl;
} else {
error("Couldn't find list named " + get<ListRef>(l.args[0]).listName);
} }
} else { } else {
error("Argument of stdlnout must be a value (literal or a value reference)"); error("Argument of stdlnout must be a value (literal or a value reference) or a list reference");
} }
break; break;
/* /*
error instruction error instruction
This instruction outputs a custom error message. This instruction outputs a custom error message.
*/ */
case Instructions::Error: case Instructions::Error:
if (l.args.size() < 1) { if (l.args.size() < 2) {
error("Could not find argument for Error inbuilt"); error("Could not find arguments for Error inbuilt");
} }
if (holds_alternative<Literal>(l.args[0])) { if (holds_alternative<Literal>(l.args[0])) {
if (holds_alternative<string>(get<Literal>(l.args[0]).val)) { if (holds_alternative<string>(get<Literal>(l.args[0]).val) && holds_alternative<string>(get<Literal>(l.args[1]).val)) {
error(get<string>(get<Literal>(l.args[0]).val)); error(get<string>(get<Literal>(l.args[0]).val), get<string>(get<Literal>(l.args[1]).val));
} else { } else {
error("Argument of error must be a string"); error("Argument of error must be a string");
} }
} else { } else {
error("Argument of error must be a string");
} }
break; break;
/*
catch instruction
This instruction ensures that errors in programs are caught and dealt with appropriately.
*/
case Instructions::Catch:
if (l.args.size() < 2) {
error("Could not find all arguments for Catch inbuilt");
}
if (holds_alternative<Literal>(l.args[0])) {
if (holds_alternative<string>(get<Literal>(l.args[0]).val)) {
}
}
/* /*
set instruction set instruction
This instruction sets a variable to a provided value. This instruction sets a variable to a provided value.
@@ -756,7 +839,7 @@ Literal exec(vector<Instruction> in, bool executingFunction) {
bool existed = variables.count(var.varName) > 0; bool existed = variables.count(var.varName) > 0;
variables[var.varName] = get<List>(variables[listref.listName].val).val[ref]; variables[var.varName] = get<List>(variables[listref.listName].val).val[ref];
} else { } else {
error("Index " + to_string(ref) + " out of range of list " + listref.listName); error("Index " + to_string(ref) + " out of range of list " + listref.listName, "rangeError");
} }
} else { } else {
error("Found a normal variable in place of a list"); error("Found a normal variable in place of a list");
@@ -812,7 +895,7 @@ Literal exec(vector<Instruction> in, bool executingFunction) {
bool existed = variables.count(var.varName) > 0; bool existed = variables.count(var.varName) > 0;
variables[var.varName] = newLit; variables[var.varName] = newLit;
} else { } else {
error("Index " + to_string(ref) + " out of range of string " + instr); error("Index " + to_string(ref) + " out of range of string " + instr, "rangeError");
} }
} }
break; break;
@@ -857,7 +940,7 @@ Literal exec(vector<Instruction> in, bool executingFunction) {
tmpList.val[ref] = value; tmpList.val[ref] = value;
variables[listref.listName].val = tmpList; variables[listref.listName].val = tmpList;
} else { } else {
error("Index " + to_string(ref) + " out of range of list " + listref.listName); error("Index " + to_string(ref) + " out of range of list " + listref.listName, "rangeError");
} }
} }
} else { } else {
@@ -1006,7 +1089,7 @@ Literal exec(vector<Instruction> in, bool executingFunction) {
bool existed = variables.count(ref.varName) > 0; bool existed = variables.count(ref.varName) > 0;
variables[ref.varName] = newLit; variables[ref.varName] = newLit;
} else { } else {
error("Cannot convert the value " + toConv + " to an int"); error("Cannot convert the value " + toConv + " to an int", "conversionError");
} }
} }
break; break;
@@ -1045,7 +1128,7 @@ Literal exec(vector<Instruction> in, bool executingFunction) {
bool existed = variables.count(ref.varName) > 0; bool existed = variables.count(ref.varName) > 0;
variables[ref.varName] = newLit; variables[ref.varName] = newLit;
} else { } else {
error("Cannot convert the value " + toConv + " to a decimal"); error("Cannot convert the value " + toConv + " to a decimal", "conversionError");
} }
} }
break; break;
@@ -1167,7 +1250,7 @@ Literal exec(vector<Instruction> in, bool executingFunction) {
} else if (holds_alternative<char>(left.val) && holds_alternative<char>(right.val)) { } else if (holds_alternative<char>(left.val) && holds_alternative<char>(right.val)) {
final.val = string().append(&get<char>(left.val)).append(&get<char>(right.val)); final.val = string().append(&get<char>(left.val)).append(&get<char>(right.val));
} else { } else {
error("Cannot add those two values"); error("Cannot add those two values", "mathError");
} }
bool existed = variables.count(varRef.varName) > 0; bool existed = variables.count(varRef.varName) > 0;
@@ -1217,7 +1300,7 @@ Literal exec(vector<Instruction> in, bool executingFunction) {
} else if (holds_alternative<double>(left.val) && holds_alternative<int>(right.val)) { } else if (holds_alternative<double>(left.val) && holds_alternative<int>(right.val)) {
final.val = get<double>(left.val) - double(get<int>(right.val)); final.val = get<double>(left.val) - double(get<int>(right.val));
} else { } else {
error("Cannot subtract those two values"); error("Cannot subtract those two values", "mathError");
} }
bool existed = variables.count(varRef.varName) > 0; bool existed = variables.count(varRef.varName) > 0;
@@ -1267,7 +1350,7 @@ Literal exec(vector<Instruction> in, bool executingFunction) {
} else if (holds_alternative<double>(left.val) && holds_alternative<int>(right.val)) { } else if (holds_alternative<double>(left.val) && holds_alternative<int>(right.val)) {
final.val = get<double>(left.val) * double(get<int>(right.val)); final.val = get<double>(left.val) * double(get<int>(right.val));
} else { } else {
error("Cannot multiply those two values"); error("Cannot multiply those two values", "mathError");
} }
bool existed = variables.count(varRef.varName) > 0; bool existed = variables.count(varRef.varName) > 0;
@@ -1310,12 +1393,12 @@ Literal exec(vector<Instruction> in, bool executingFunction) {
// Ensure we aren't dividing by zero // Ensure we aren't dividing by zero
if (holds_alternative<int>(right.val)) { if (holds_alternative<int>(right.val)) {
if (get<int>(right.val) == 0) { if (get<int>(right.val) == 0) {
error("Division by zero is not allowed"); error("Division by zero is not allowed", "divisionByZeroError");
} }
} }
if (holds_alternative<double>(right.val)) { if (holds_alternative<double>(right.val)) {
if (get<double>(right.val) == 0) { if (get<double>(right.val) == 0) {
error("Division by zero is not allowed"); error("Division by zero is not allowed", "divisionByZeroError");
} }
} }
@@ -1329,7 +1412,7 @@ Literal exec(vector<Instruction> in, bool executingFunction) {
} else if (holds_alternative<double>(left.val) && holds_alternative<int>(right.val)) { } else if (holds_alternative<double>(left.val) && holds_alternative<int>(right.val)) {
final.val = get<double>(left.val) / double(get<int>(right.val)); final.val = get<double>(left.val) / double(get<int>(right.val));
} else { } else {
error("Cannot divide those two values"); error("Cannot divide those two values", "mathError");
} }
bool existed = variables.count(varRef.varName) > 0; bool existed = variables.count(varRef.varName) > 0;
@@ -1385,7 +1468,7 @@ Literal exec(vector<Instruction> in, bool executingFunction) {
} else if (holds_alternative<bool>(left.val) && holds_alternative<bool>(right.val)) { } else if (holds_alternative<bool>(left.val) && holds_alternative<bool>(right.val)) {
final.val = get<bool>(left.val) == get<bool>(right.val); final.val = get<bool>(left.val) == get<bool>(right.val);
} else { } else {
error("Cannot equal those two values"); error("Cannot equal those two values", "comparisonError");
} }
bool existed = variables.count(varRef.varName) > 0; bool existed = variables.count(varRef.varName) > 0;
@@ -1441,7 +1524,7 @@ Literal exec(vector<Instruction> in, bool executingFunction) {
} else if (holds_alternative<bool>(left.val) && holds_alternative<bool>(right.val)) { } else if (holds_alternative<bool>(left.val) && holds_alternative<bool>(right.val)) {
final.val = get<bool>(left.val) != get<bool>(right.val); final.val = get<bool>(left.val) != get<bool>(right.val);
} else { } else {
error("Cannot inequal those two values"); error("Cannot inequal those two values", "comparisonError");
} }
bool existed = variables.count(varRef.varName) > 0; bool existed = variables.count(varRef.varName) > 0;
@@ -1530,7 +1613,7 @@ Literal exec(vector<Instruction> in, bool executingFunction) {
} else if (holds_alternative<bool>(left.val) && holds_alternative<bool>(right.val)) { } else if (holds_alternative<bool>(left.val) && holds_alternative<bool>(right.val)) {
final.val = get<bool>(left.val) > get<bool>(right.val); final.val = get<bool>(left.val) > get<bool>(right.val);
} else { } else {
error("Cannot greater those two values"); error("Cannot greater those two values", "comparisonError");
} }
bool existed = variables.count(varRef.varName) > 0; bool existed = variables.count(varRef.varName) > 0;
@@ -1586,7 +1669,7 @@ Literal exec(vector<Instruction> in, bool executingFunction) {
} else if (holds_alternative<bool>(left.val) && holds_alternative<bool>(right.val)) { } else if (holds_alternative<bool>(left.val) && holds_alternative<bool>(right.val)) {
final.val = get<bool>(left.val) < get<bool>(right.val); final.val = get<bool>(left.val) < get<bool>(right.val);
} else { } else {
error("Cannot lesser those two values"); error("Cannot lesser those two values", "comparisonError");
} }
bool existed = variables.count(varRef.varName) > 0; bool existed = variables.count(varRef.varName) > 0;
@@ -1693,7 +1776,7 @@ Literal exec(vector<Instruction> in, bool executingFunction) {
variables[ref.varName].val = "char"; variables[ref.varName].val = "char";
break; break;
default: default:
error("Could not get type?? This should never be reached. Please report this issue"); error("Could not get type?? This should never be reached. Please report this issue", "undefinedError");
break; break;
} }
@@ -1913,7 +1996,7 @@ Literal exec(vector<Instruction> in, bool executingFunction) {
// Type checking - now with error reporting // Type checking - now with error reporting
if (arg.type != getLitType(fnArgs[m])) { if (arg.type != getLitType(fnArgs[m])) {
error("Function " + ref.fnName + " argument " + to_string(m + 1) + error("Function " + ref.fnName + " argument " + to_string(m + 1) +
" type mismatch. Expected type does not match provided argument type."); " type mismatch. Expected type does not match provided argument type.", "typeError");
} }
// Create the variable // Create the variable
@@ -1976,11 +2059,11 @@ Literal exec(vector<Instruction> in, bool executingFunction) {
string groundLibsDir = getenv("GROUND_LIBS"); string groundLibsDir = getenv("GROUND_LIBS");
if (filesystem::exists(useName)) { if (filesystem::exists(useName)) {
// no need to do anything here
} else if (groundLibsDir != "" && filesystem::exists(groundLibsDir + useName)) { } else if (groundLibsDir != "" && filesystem::exists(groundLibsDir + useName + ".grnd")) {
useName = groundLibsDir + useName; useName = groundLibsDir + useName + ".grnd";
} else { } else {
error("Could not find external Ground library in $GROUND_LIBS or current directory."); error("Could not find external Ground library in $GROUND_LIBS (currently set to " + groundLibsDir +") or current directory.", "libraryError");
} }
ifstream file(useName); ifstream file(useName);
@@ -2055,13 +2138,13 @@ Literal exec(vector<Instruction> in, bool executingFunction) {
if (!found) { if (!found) {
error("Could not find external library: " + fullLibName + error("Could not find external library: " + fullLibName +
" (searched current directory and GROUND_LIBS)"); " (searched current directory and GROUND_LIBS)", "libraryError");
} }
// Try to open the library // Try to open the library
void* handle = DLOPEN(libPath.c_str()); void* handle = DLOPEN(libPath.c_str());
if (!handle) { if (!handle) {
error("Failed to load library " + libPath + ": " + string(DLERROR())); error("Failed to load library " + libPath + ": " + string(DLERROR()), "libraryError");
} }
// Store handle for cleanup later // Store handle for cleanup later
@@ -2075,7 +2158,7 @@ Literal exec(vector<Instruction> in, bool executingFunction) {
GetFunctionFunc getFunction = (GetFunctionFunc)DLSYM(handle, "ground_get_function"); GetFunctionFunc getFunction = (GetFunctionFunc)DLSYM(handle, "ground_get_function");
if (!getFunctions || !getFunction) { if (!getFunctions || !getFunction) {
error("Library " + libName + " is not Ground-compatible (missing required functions: ground_get_functions or ground_get_function)"); error("Library " + libName + " is not Ground-compatible (missing required functions: ground_get_functions or ground_get_function)", "libraryError");
} }
// Optional initialization // Optional initialization
@@ -2098,12 +2181,12 @@ Literal exec(vector<Instruction> in, bool executingFunction) {
externalFunctions[libName + ":" + string(functionNames[i])] = funcPtr; externalFunctions[libName + ":" + string(functionNames[i])] = funcPtr;
functionCount++; functionCount++;
} else { } else {
error("Failed to get function pointer for: " + string(functionNames[i])); error("Failed to get function pointer for: " + string(functionNames[i]), "libraryError");
} }
} }
if (functionCount == 0) { if (functionCount == 0) {
error("No functions were loaded from library: " + libName); error("No functions were loaded from library: " + libName, "libraryError");
} }
} }
break; break;
@@ -2248,10 +2331,19 @@ vector<Instruction> parser(vector<vector<string>> in) {
newInst.isLabel = true; newInst.isLabel = true;
newInst.label.id = i.substr(1); newInst.label.id = i.substr(1);
} }
else if (isFunction(i)){
newInst.inst = Instructions::Call;
FunctionRef newFnRef;
newFnRef.fnName = i.substr(1);
newInst.args.push_back(newFnRef);
}
else if (i == "stdin") newInst.inst = Instructions::Stdin; else if (i == "stdin") newInst.inst = Instructions::Stdin;
else if (i == "stdout") newInst.inst = Instructions::Stdout; else if (i == "stdout") newInst.inst = Instructions::Stdout;
else if (i == "stdlnout") newInst.inst = Instructions::Stdlnout; else if (i == "stdlnout") newInst.inst = Instructions::Stdlnout;
else if (i == "error") newInst.inst = Instructions::Error; else if (i == "error") newInst.inst = Instructions::Error;
else if (i == "try") newInst.inst = Instructions::Try;
else if (i == "catch") newInst.inst = Instructions::Catch;
else if (i == "exception") newInst.inst = Instructions::Exception;
else if (i == "jump") newInst.inst = Instructions::Jump; else if (i == "jump") newInst.inst = Instructions::Jump;
else if (i == "if") newInst.inst = Instructions::If; else if (i == "if") newInst.inst = Instructions::If;
else if (i == "add") newInst.inst = Instructions::Add; else if (i == "add") newInst.inst = Instructions::Add;
@@ -2315,7 +2407,7 @@ vector<Instruction> parser(vector<vector<string>> in) {
else if (type == "int") newType.type = Types::Int; else if (type == "int") newType.type = Types::Int;
else if (type == "bool") newType.type = Types::Bool; else if (type == "bool") newType.type = Types::Bool;
else if (type == "list") newType.type = Types::List; else if (type == "list") newType.type = Types::List;
else error("Ground could not find type. This is an error with the interpreter, not your code. This line of code should never be reached."); else error("Ground could not find type. This is an error with the interpreter, not your code. This line of code should never be reached.", "undefinedError");
newInst.args.push_back(newType); newInst.args.push_back(newType);
} }
break; break;
@@ -2386,7 +2478,7 @@ vector<Instruction> parser(vector<vector<string>> in) {
} }
break; break;
default: default:
error("This type should not be obtained in normal execution"); error("This type should not be obtained in normal execution", "undefinedError");
break; break;
} }
} }

2
tests/error.grnd
View File

@@ -1 +1 @@
error "Hello, world!" error "Hello, world!" "sillyError"

2
tests/functions.grnd
View File

@@ -14,7 +14,7 @@ fun -bool !jumpy
return true return true
endfun endfun
call !jumpy &tmp !jumpy &tmp
stdlnout "I called a function" stdlnout "I called a function"

1
tests/lists.grnd
View File

@@ -1,5 +1,6 @@
# A cool list # A cool list
setlist *favWords "hello" "there" "general" "kenobi" setlist *favWords "hello" "there" "general" "kenobi"
stdlnout *favWords
set &count 0 set &count 0
set &passedThrough true set &passedThrough true

5
tests/to1000.grnd
View File

@@ -1,5 +1,6 @@
set &var 0 set &var 0
@jump
add 1 $var &var add 1 $var &var
stdlnout $var stdlnout $var
greater 1000 $var &cond greater 10000 $var &cond
if $cond %2 if $cond %jump