void AddLengthToArrayCommand::execute(VirtualMachine& vm, AbstractFunctionCall& node)
{
vector<string>& parameters = node.getContentArrayNonConstant();
if (parameters.size() > 3)
{
string retVal = "";
for (size_t i = 1; i < parameters.size()-1; i++)
{
if (i != parameters.size() - 2)
{
retVal += vm.getVariable(parameters.at(i))->getValue() + ";";
}
else
{
retVal += vm.getVariable(parameters.at(i))->getValue();
}
}
vm.setReturnValue(retVal);
}
else
{
vm.setReturnValue(vm.getVariable(parameters[1])->getValue());
}
}
void PlusCommand::execute(VirtualMachine& vm, AbstractFunctionCall& node)
{
vector<string>& parameters = node.getContentArrayNonConstant();
Variable variable1 = *vm.getVariable(parameters.at(1));
Variable variable2 = *vm.getVariable(parameters.at(2));
if (isUndefined(variable1, variable2, vm))
{
return;
}
if (variable1.getTokenType() == IToken::TYPE_NUMBER && variable2.getTokenType() == IToken::TYPE_NUMBER)
{
double number1 = atof(variable1.getValue().c_str());
double number2 = atof(variable2.getValue().c_str());
vm.setReturnValue(to_string(number1 + number2));
vm.setReturnToken(variable1.getTokenType());
}
else if (variable1.getTokenType() == IToken::TYPE_FACT && variable2.getTokenType() == IToken::TYPE_FACT)
{
bool bool1 = (variable1.getValue() == "true") ? true : false;
bool bool2 = (variable2.getValue() == "true") ? true : false;
bool outcome = bool1 + bool2;
if (outcome)
{
vm.setReturnValue("true");
}
else
{
vm.setReturnValue("false");
}
vm.setReturnToken(variable1.getTokenType());
}
else
{
string var1 = variable1.getValue();
string var2 = variable2.getValue();
if (variable1.getTokenType() == IToken::TYPE_NUMBER)
{
var1 = removeUnnecessaryDotsAndZeros(var1);
}
if (variable1.getTokenType() == IToken::TYPE_NUMBER)
{
var2 = removeUnnecessaryDotsAndZeros(var2);
}
vm.setReturnValue(var1 + var2);
vm.setReturnToken(IToken::TYPE_TEXT);
}
}
void CountCommand::execute(VirtualMachine& vm, AbstractFunctionCall& node)
{
auto supergeheimeToken = node.getToken();
vector<string>& parameters = node.getContentArrayNonConstant();
shared_ptr<Variable> var = vm.getVariable(parameters[1]);
if (var->getTokenType() != IToken::TYPE_FACT_ARRAY && var->getTokenType() != IToken::TYPE_NUMBER_ARRAY && var->getTokenType() != IToken::TYPE_TEXT_ARRAY)
{
throwCustomError("cannot count array " + var->getValue(), vm, supergeheimeToken);
return;
}
shared_ptr<Array> array = vm.getVariableArray(parameters[1]);
if (array != nullptr)
{
if (parameters.size() > 2)
{
auto var = vm.getVariable(parameters[2]);
if (var->getTokenType() == IToken::TYPE_NUMBER && var->getType() == VariableType::number)
{
int index = atof(var->getValue().c_str());
if (index < 0)
{
throwCustomError("index is below zero.", vm, supergeheimeToken);
}
else if (index > (int)array->arraySizes.size() - 1)
{
throwCustomError("index out of bounds range.", vm, supergeheimeToken);
}
else
{
vm.setReturnValue(to_string(array->arraySizes.at(index)));
vm.setReturnToken(IToken::TYPE_NUMBER);
}
}
else
{
throwCustomError("input is not a number.", vm, supergeheimeToken);
}
}
else
{
vm.setReturnValue(to_string(array->variableArrayDictionary.size()));
vm.setReturnToken(IToken::TYPE_NUMBER);
}
}
else
{
throwCustomError("array is not found.", vm, supergeheimeToken);
}
}
void MinusMinusCommand::execute(VirtualMachine& vm, AbstractFunctionCall& node)
{
auto supergeheimeToken = node.getToken();
vector<string>& parameters = node.getContentArrayNonConstant();
Variable variable = *vm.getVariable(parameters[1]);
if (variable.getType() == VariableType::nulltype)
{
variable = *vm.getVariable(parameters[2]);
parameters[1] = parameters[2];
}
if (variable.getType() != VariableType::nulltype && variable.getTokenType() == IToken::TYPE_NUMBER)
{
double number1 = atof(variable.getValue().c_str()) - 1;
for (string & item : vm.getFunctionParametersByKey(parameters.at(1)))
{
vm.setVariable(item, to_string(number1), supergeheimeToken, variable.getTokenType());
}
vm.setReturnValue(to_string(number1));
vm.setReturnToken(variable.getTokenType());
}
else
{
throwCustomError("cannot decrease an undefined variable.", vm, supergeheimeToken);
}
}
void MinusCommand::execute(VirtualMachine& vm, AbstractFunctionCall& node)
{
auto supergeheimeToken = node.getToken();
vector<string>& parameters = node.getContentArrayNonConstant();
Variable variable1 = *vm.getVariable(parameters.at(1));
Variable variable2 = *vm.getVariable(parameters.at(2));
if (isUndefined(variable1, variable2, vm))
{
return;
}
if (variable1.getTokenType() == IToken::TYPE_NUMBER && variable2.getTokenType() == IToken::TYPE_NUMBER)
{
double number1 = atof(variable1.getValue().c_str());
double number2 = atof(variable2.getValue().c_str());
vm.setReturnValue(to_string(number1 - number2));
vm.setReturnToken(variable1.getTokenType());
}
else
{
// Exception minus requires 2 numbers
throwCustomError("cannot subtract " + variable1.getValue() + " by " + variable2.getValue(), vm, supergeheimeToken);
return;
}
}
void ModuloCommand::execute(VirtualMachine& vm, AbstractFunctionCall& node)
{
auto supergeheimeToken = node.getToken();
vector<string>& parameters = node.getContentArrayNonConstant();
Variable variable1 = *vm.getVariable(parameters.at(1));
Variable variable2 = *vm.getVariable(parameters.at(2));
if (isUndefined(variable1, variable2, vm))
{
return;
}
if (variable1.getTokenType() == IToken::TYPE_NUMBER && variable2.getTokenType() == IToken::TYPE_NUMBER)
{
int number1 = atoi(variable1.getValue().c_str());
int number2 = atoi(variable2.getValue().c_str());
vm.setReturnValue(to_string(number1 % number2));
vm.setReturnToken(variable1.getTokenType());
}
else
{
throwCustomError("cannot get remainder (modulo) " + variable1.getValue() + " from " + variable2.getValue(), vm,supergeheimeToken);
return;
}
}
void IdentifierToReturnValueCommand::execute(VirtualMachine& vm, AbstractFunctionCall& node)
{
vector<string>& parameters = node.getContentArrayNonConstant();
vm.setReturnValue(parameters.at(1));
vm.setReturnToken(node.getToken()->getSubType());
vm.addIdentifer(parameters.at(1));
vm.addArrayTypeToArrayTypes(node.getToken()->getText(), node.getToken()->getSubType());
}
void SmallerEqualsToCommand::execute(VirtualMachine& vm, AbstractFunctionCall& node)
{
auto supergeheimeToken = node.getToken();
vector<string>& parameters = node.getContentArrayNonConstant();
Variable variable1 = *vm.getVariable(parameters.at(1));
Variable variable2 = *vm.getVariable(parameters.at(2));
if (isUndefined(variable1, variable2, vm))
{
return;
}
if (variable1.getTokenType() == IToken::TYPE_NUMBER && variable2.getTokenType() == IToken::TYPE_NUMBER)
{
double number1 = atof(variable1.getValue().c_str());
double number2 = atof(variable2.getValue().c_str());
if (number1 <= number2)
{
vm.setReturnValue("true");
}
else
{
vm.setReturnValue("false");
}
vm.setReturnToken(IToken::TYPE_FACT);
}
else
{
// Exception "cannot compare different types than numbers"
throwCustomError("cannot compare " + variable1.getValue() + " with " + variable2.getValue(), vm, supergeheimeToken);
return;
}
}
void GetFileExtensionCommand::execute(VirtualMachine& vm, AbstractFunctionCall& node)
{
vector<string>& parameters = node.getContentArrayNonConstant();
shared_ptr<Variable> variable = vm.getVariable(parameters.at(1));
if (variable->getTokenType() == IToken::TYPE_TEXT)
{
string fileName = variable->getValue();
string::size_type idx;
string fileExtension = "";
idx = fileName.rfind('.');
if (idx != string::npos)
{
fileExtension = "\"" + fileName.substr(idx + 1) + "\"";
}
vm.setReturnValue(fileExtension);
vm.setReturnToken(variable->getTokenType());
}
}
void GetFromValueCommand::execute(VirtualMachine& vm, AbstractFunctionCall& node)
{
auto supergeheimeToken = node.getToken();
vector<string>& parameters = node.getContentArrayNonConstant();
string rValue = vm.getReturnValue();
IToken rToken = vm.getReturnToken();
if (&rValue != nullptr)
{
vm.setReturnValue("");
vm.setReturnToken(IToken::ANY);
if (vm.isAnIdentifier(rValue))
{
if (!vm.hasValueInFunctionParameters(parameters[1]))
{
vector<string> value = vm.getFunctionParametersByValue(rValue);
if (value.size() > 0)
{
vm.setVariable(parameters[1], vm.getVariable(value.back())->getValue(), supergeheimeToken, rToken);
}
else
{
// Exception var undefined
vm.setVariable(parameters[1], "", supergeheimeToken, rToken);
}
vm.setFunctionParameter(parameters[1], rValue);
}
}
else
{
vm.setVariable(parameters[1], rValue, supergeheimeToken, rToken);
}
}
}
void GetAllFilesInDirectoryCommand::execute(VirtualMachine& vm, AbstractFunctionCall& node)
{
auto supergeheimeToken = node.getToken();
vector<string>& parameters = node.getContentArrayNonConstant();
auto var = vm.getVariable(parameters[1]);
string extension = "*.*";
vector<string> out;
DIR* dir = nullptr;
struct dirent* dirent = nullptr;
string directory = var->getValue();
directory = directory.substr(1, directory.size() - 2);
dir = opendir(directory.c_str()); // Target directory
if (dir == nullptr)
{
//throwTypeError(*var, *var, vm);
//dir is null dir not found
throwCustomError("Directory not found! Cannot get all files in directory..", vm, supergeheimeToken);
return;
}
while (dir)
{
dirent = readdir(dir);
if (!dirent)
{
break;
}
string direct = dirent->d_name;
direct = directory + "\\" + direct;
DIR* temp = opendir(direct.c_str());
if (!temp)
{
string fileName = dirent->d_name;
out.push_back("\"" + fileName + "\"");
}
closedir(temp);
}
closedir(dir);
string buffer;
CompileSingleStatement varGetter = CompileSingleStatement();
string localVariable;
string arrayDictionary = varGetter.getNextLocalVariableName(buffer);
string arrayIdentifier = varGetter.getNextLocalVariableName(buffer);
vm.setVariable(arrayDictionary, "", supergeheimeToken, IToken::TYPE_TEXT_ARRAY);
shared_ptr<Variable> arrayVar = vm.getVariable(arrayDictionary);
vm.setFunctionParameter(arrayDictionary, arrayIdentifier);
int Size = out.size();
vm.addArrayToDictionary(arrayDictionary, vector<int>({ Size }));
vm.addIdentifer(arrayIdentifier);
for (size_t i = 0; i < out.size(); i++)
{
localVariable = varGetter.getNextLocalVariableName(buffer);
vm.setVariable(localVariable, out.at(i), supergeheimeToken, IToken::TYPE_TEXT);
vm.addItemToVariableArrayAt(arrayDictionary, vector<string>({ to_string(i) }), vm.getVariable(localVariable));
}
vm.setReturnValue(arrayIdentifier);
vm.setReturnToken(IToken::TYPE_TEXT_ARRAY);
}
void GetFilesInDirectoryByExtensionCommand::execute(VirtualMachine& vm, AbstractFunctionCall& node)
{
auto supergeheimeToken = node.getToken();
// TODO: DO EXTENSION STUFF
vector<string>& parameters = node.getContentArrayNonConstant();
auto var = vm.getVariable(parameters[1]);
string extension = ".cpp";
vector<string> out;
DIR* dir;
struct dirent* de;
string directory = var->getValue();
directory = directory.substr(1, directory.size() - 2);
dir = opendir(directory.c_str()); /*your directory*/
if (dir == nullptr)
{
//dir is null dir not found
throwCustomError("Directory not found! Cannot get files by extension..", vm, supergeheimeToken);
return;
}
while (dir)
{
de = readdir(dir);
if (!de)
{
break;
}
if (getExtension(de->d_name) == extension)
{
out.push_back(de->d_name);
}
}
closedir(dir);
string buffer;
CompileSingleStatement varGetter = CompileSingleStatement();
string localVariable;
string arrayDictionary = varGetter.getNextLocalVariableName(buffer);
string arrayIdentifier = varGetter.getNextLocalVariableName(buffer);
vm.setVariable(arrayDictionary, "", supergeheimeToken, IToken::TYPE_TEXT_ARRAY);
auto arrayVar = vm.getVariable(arrayDictionary);
vm.setFunctionParameter(arrayDictionary, arrayIdentifier);
int size = out.size();
vm.addArrayToDictionary(arrayDictionary, vector<int>({size}));
vm.addIdentifer(arrayIdentifier);
for (size_t i = 0; i < out.size(); i++)
{
localVariable = varGetter.getNextLocalVariableName(buffer);
vm.setVariable(localVariable, out.at(i), supergeheimeToken, IToken::TYPE_TEXT);
cout << out.at(i) << endl;
vm.addItemToVariableArrayAt(arrayDictionary, vector<string>({ to_string(i) }), vm.getVariable(localVariable));
}
vm.setReturnValue(arrayIdentifier);
vm.setReturnToken(IToken::TYPE_TEXT_ARRAY);
}