QVariant QEPeriodic::getDrop()
{
if( isDraggingVariable() )
return QVariant( copyVariable() );
else
return copyData();
}
QVariant QESlider::getDrop()
{
if( isDraggingVariable() )
return QVariant( copyVariable() );
else
return copyData();
}
bool stackSetByIndex (variableStack * vS, unsigned int theIndex, const variable & va) {
while (theIndex --) {
vS = vS -> next;
if (! vS) return fatal ("Index past end of stack.");
}
return copyVariable (va, vS -> thisVar);
}
int startNewFunctionNum (unsigned int funcNum, unsigned int numParamsExpected, loadedFunction * calledBy, variableStack * & vStack, bool returnSommet) {
loadedFunction * newFunc = new loadedFunction;
checkNew (newFunc);
newFunc -> originalNumber = funcNum;
loadFunctionCode (newFunc);
if (newFunc -> numArgs != (int)numParamsExpected) return fatal ("Wrong number of parameters!");
if (newFunc -> numArgs > newFunc -> numLocals) return fatal ("More arguments than local variable space!");
// Now, lets copy the parameters from the calling function's stack...
while (numParamsExpected) {
numParamsExpected --;
if (vStack == NULL) return fatal ("Corrupted file! The stack's empty and there were still parameters expected");
copyVariable (vStack -> thisVar, newFunc -> localVars[numParamsExpected]);
trimStack (vStack);
}
newFunc -> cancelMe = false;
newFunc -> timeLeft = 0;
newFunc -> returnSomething = returnSommet;
newFunc -> calledBy = calledBy;
newFunc -> stack = NULL;
newFunc -> freezerLevel = 0;
newFunc -> runThisLine = 0;
newFunc -> isSpeech = 0;
initVarNew (newFunc -> reg);
restartFunction (newFunc);
return 1;
}
QVariant QEGenericButton::getDrop()
{
if( isDraggingVariable() )
return QVariant( copyVariable() );
else
return copyData();
}
void DisassemblerView::createVariablesMenu()
{
this->_variablesmenu = new QMenu(this);
QAction* acycopyvariable = this->_variablesmenu->addAction(QIcon(":/action_icons/res/copy.png"), "Copy");
QAction* actcopyname = this->_variablesmenu->addAction(QIcon(":/action_icons/res/copy.png"), "Copy Name");
this->_variablesmenu->addSeparator();
QAction* actrename = this->_variablesmenu->addAction(QIcon(":/action_icons/res/rename.png"), "Rename");
QAction* actexportcsv = this->_variablesmenu->addAction(QIcon(":/action_icons/res/export.png"), "Export as CSV");
connect(acycopyvariable, SIGNAL(triggered()), this, SLOT(copyVariable()));
connect(actcopyname, SIGNAL(triggered()), this, SLOT(copyVariableName()));
connect(actrename, SIGNAL(triggered()), this, SLOT(renameSelectedVariable()));
connect(actexportcsv, SIGNAL(triggered()), this, SLOT(exportVariables()));
}
bool continueFunction (loadedFunction * fun) {
bool keepLooping = true;
bool advanceNow;
unsigned int param;
sludgeCommand com;
if (fun -> cancelMe) {
abortFunction (fun);
return true;
}
// if (numBIFNames) newDebug ("*** Function:", allUserFunc[fun -> originalNumber]);
//debugOut ("SLUDGER: continueFunction\n");
while (keepLooping) {
advanceNow = true;
param = fun -> compiledLines[fun -> runThisLine].param;
com = fun -> compiledLines[fun -> runThisLine].theCommand;
// fprintf (stderr, "com: %d param: %d (%s)\n", com, param,
// (com < numSludgeCommands) ? sludgeText[com] : ERROR_UNKNOWN_MCODE); fflush(stderr);
if (numBIFNames) {
setFatalInfo (
(fun -> originalNumber < numUserFunc) ? allUserFunc[fun -> originalNumber] : "Unknown user function",
(com < numSludgeCommands) ? sludgeText[com] : ERROR_UNKNOWN_MCODE);
// newDebug (
// (com < numSludgeCommands) ? sludgeText[com] : "Unknown SLUDGE machine code",
// param);
}
//debugOut ("SLUDGER: continueFunction - in da loop: %s\n", sludgeText[com]);
switch (com) {
case SLU_RETURN:
if (fun -> calledBy) {
loadedFunction * returnTo = fun -> calledBy;
if (fun -> returnSomething) copyVariable (fun -> reg, returnTo -> reg);
finishFunction (fun);
fun = returnTo;
restartFunction (fun);
} else {
finishFunction (fun);
advanceNow = false; // So we don't do anything else with "fun"
keepLooping = false; // So we drop out of the loop
}
break;
case SLU_CALLIT:
switch (fun -> reg.varType) {
case SVT_FUNC:
pauseFunction (fun);
if (numBIFNames) setFatalInfo (
(fun -> originalNumber < numUserFunc) ? allUserFunc[fun -> originalNumber] : "Unknown user function",
(fun -> reg.varData.intValue < numUserFunc) ? allUserFunc[fun -> reg.varData.intValue] : "Unknown user function");
if (! startNewFunctionNum (fun -> reg.varData.intValue, param, fun, fun -> stack)) return false;
fun = allRunningFunctions;
advanceNow = false; // So we don't do anything else with "fun"
break;
case SVT_BUILT:
{
builtReturn br = callBuiltIn (fun -> reg.varData.intValue, param, fun);
switch (br) {
case BR_ERROR:
return fatal("Unknown error. This shouldn't happen. Please notify the SLUDGE developers.");
case BR_PAUSE:
pauseFunction (fun);
// No break!
case BR_KEEP_AND_PAUSE:
keepLooping = false;
break;
case BR_ALREADY_GONE:
keepLooping = false;
advanceNow = false;
break;
case BR_CALLAFUNC:
{
int i = fun -> reg.varData.intValue;
setVariable (fun -> reg, SVT_INT, 1);
pauseFunction (fun);
if (numBIFNames) setFatalInfo (
(fun -> originalNumber < numUserFunc) ? allUserFunc[fun -> originalNumber] : "Unknown user function",
(i < numUserFunc) ? allUserFunc[i] : "Unknown user function");
if (! startNewFunctionNum (i, 0, fun, noStack, false)) return false;
fun = allRunningFunctions;
advanceNow = false; // So we don't do anything else with "fun"
}
break;
default:
break;
}
}
break;
default:
return fatal (ERROR_CALL_NONFUNCTION);
}
break;
// These all grab things and shove 'em into the register
case SLU_LOAD_NULL:
setVariable (fun -> reg, SVT_NULL, 0);
break;
case SLU_LOAD_FILE:
setVariable (fun -> reg, SVT_FILE, param);
break;
case SLU_LOAD_VALUE:
setVariable (fun -> reg, SVT_INT, param);
break;
case SLU_LOAD_LOCAL:
if (! copyVariable (fun -> localVars[param], fun -> reg)) return false;
break;
case SLU_AND:
setVariable (fun -> reg, SVT_INT, getBoolean (fun -> reg) && getBoolean (fun -> stack -> thisVar));
trimStack (fun -> stack);
break;
case SLU_OR:
setVariable (fun -> reg, SVT_INT, getBoolean (fun -> reg) || getBoolean (fun -> stack -> thisVar));
trimStack (fun -> stack);
break;
case SLU_LOAD_FUNC:
setVariable (fun -> reg, SVT_FUNC, param);
break;
case SLU_LOAD_BUILT:
setVariable (fun -> reg, SVT_BUILT, param);
break;
case SLU_LOAD_OBJTYPE:
setVariable (fun -> reg, SVT_OBJTYPE, param);
break;
case SLU_UNREG:
if (dialogValue != 1) fatal (ERROR_HACKER);
break;
case SLU_LOAD_STRING:
if (! loadStringToVar (fun -> reg, param)) {
return false;
}
break;
case SLU_INDEXGET:
case SLU_INCREMENT_INDEX:
case SLU_DECREMENT_INDEX:
switch (fun -> stack -> thisVar.varType) {
case SVT_NULL:
if (com == SLU_INDEXGET) {
setVariable (fun -> reg, SVT_NULL, 0);
trimStack (fun -> stack);
} else {
return fatal (ERROR_INCDEC_UNKNOWN);
}
break;
case SVT_FASTARRAY:
case SVT_STACK:
if (fun -> stack -> thisVar.varData.theStack -> first == NULL) {
return fatal (ERROR_INDEX_EMPTY);
} else {
int ii;
if (! getValueType (ii, SVT_INT, fun -> reg)) return false;
variable * grab = (fun -> stack -> thisVar.varType == SVT_FASTARRAY) ?
fastArrayGetByIndex (fun -> stack -> thisVar.varData.fastArray, ii)
:
stackGetByIndex (fun -> stack -> thisVar.varData.theStack -> first, ii);
trimStack (fun -> stack);
if (! grab) {
setVariable (fun -> reg, SVT_NULL, 0);
} else {
int ii;
switch (com) {
case SLU_INCREMENT_INDEX:
if (! getValueType (ii, SVT_INT, * grab)) return false;
setVariable (fun -> reg, SVT_INT, ii);
grab -> varData.intValue = ii + 1;
break;
case SLU_DECREMENT_INDEX:
if (! getValueType (ii, SVT_INT, * grab)) return false;
setVariable (fun -> reg, SVT_INT, ii);
grab -> varData.intValue = ii - 1;
break;
default:
if (! copyVariable (* grab, fun -> reg)) return false;
}
}
}
break;
default:
return fatal (ERROR_INDEX_NONSTACK);
}
break;
case SLU_INDEXSET:
switch (fun -> stack -> thisVar.varType) {
case SVT_STACK:
if (fun -> stack -> thisVar.varData.theStack -> first == NULL) {
return fatal (ERROR_INDEX_EMPTY);
} else {
int ii;
if (! getValueType (ii, SVT_INT, fun -> reg)) return false;
if (! stackSetByIndex (fun -> stack -> thisVar.varData.theStack -> first, ii, fun -> stack -> next -> thisVar)) {
return false;
}
trimStack (fun -> stack);
trimStack (fun -> stack);
}
break;
case SVT_FASTARRAY:
{
int ii;
if (! getValueType (ii, SVT_INT, fun -> reg)) return false;
variable * v = fastArrayGetByIndex (fun -> stack -> thisVar.varData.fastArray, ii);
if (v == NULL) return fatal ("Not within bounds of fast array.");
if (! copyVariable (fun -> stack -> next -> thisVar, * v)) return false;
trimStack (fun -> stack);
trimStack (fun -> stack);
}
break;
default:
return fatal (ERROR_INDEX_NONSTACK);
}
break;
// What can we do with the register? Well, we can copy it into a local
// variable, a global or onto the stack...
case SLU_INCREMENT_LOCAL:
{
int ii;
if (! getValueType (ii, SVT_INT, fun -> localVars[param])) return false;
setVariable (fun -> reg, SVT_INT, ii);
setVariable (fun -> localVars[param], SVT_INT, ii + 1);
}
break;
case SLU_INCREMENT_GLOBAL:
{
int ii;
if (! getValueType (ii, SVT_INT, globalVars[param])) return false;
setVariable (fun -> reg, SVT_INT, ii);
setVariable (globalVars[param], SVT_INT, ii + 1);
}
break;
case SLU_DECREMENT_LOCAL:
{
int ii;
if (! getValueType (ii, SVT_INT, fun -> localVars[param])) return false;
setVariable (fun -> reg, SVT_INT, ii);
setVariable (fun -> localVars[param], SVT_INT, ii - 1);
}
break;
case SLU_DECREMENT_GLOBAL:
{
int ii;
if (! getValueType (ii, SVT_INT, globalVars[param])) return false;
setVariable (fun -> reg, SVT_INT, ii);
setVariable (globalVars[param], SVT_INT, ii - 1);
}
break;
case SLU_SET_LOCAL:
if (! copyVariable (fun -> reg, fun -> localVars[param])) return false;
break;
case SLU_SET_GLOBAL:
// newDebug (" Copying TO global variable", param);
// newDebug (" Global type at the moment", globalVars[param].varType);
if (! copyVariable (fun -> reg, globalVars[param])) return false;
// newDebug (" New type", globalVars[param].varType);
break;
case SLU_LOAD_GLOBAL:
// newDebug (" Copying FROM global variable", param);
// newDebug (" Global type at the moment", globalVars[param].varType);
if (! copyVariable (globalVars[param], fun -> reg)) return false;
break;
case SLU_STACK_PUSH:
if (! addVarToStack (fun -> reg, fun -> stack)) return false;
break;
case SLU_QUICK_PUSH:
if (! addVarToStackQuick (fun -> reg, fun -> stack)) return false;
break;
case SLU_NOT:
setVariable (fun -> reg, SVT_INT, ! getBoolean (fun -> reg));
break;
case SLU_BR_ZERO:
if (! getBoolean (fun -> reg)) {
advanceNow = false;
fun -> runThisLine = param;
}
break;
case SLU_BRANCH:
advanceNow = false;
fun -> runThisLine = param;
break;
case SLU_NEGATIVE:
{
int i;
if (! getValueType (i, SVT_INT, fun -> reg)) return false;
setVariable (fun -> reg, SVT_INT, -i);
}
break;
// All these things rely on there being somet' on the stack
case SLU_MULT:
case SLU_PLUS:
case SLU_MINUS:
case SLU_MODULUS:
case SLU_DIVIDE:
case SLU_EQUALS:
case SLU_NOT_EQ:
case SLU_LESSTHAN:
case SLU_MORETHAN:
case SLU_LESS_EQUAL:
case SLU_MORE_EQUAL:
if (fun -> stack) {
int firstValue, secondValue;
switch (com) {
case SLU_PLUS:
addVariablesInSecond (fun -> stack -> thisVar, fun -> reg);
trimStack (fun -> stack);
break;
case SLU_EQUALS:
compareVariablesInSecond (fun -> stack -> thisVar, fun -> reg);
trimStack (fun -> stack);
break;
case SLU_NOT_EQ:
compareVariablesInSecond (fun -> stack -> thisVar, fun -> reg);
trimStack (fun -> stack);
fun -> reg.varData.intValue = ! fun -> reg.varData.intValue;
break;
default:
if (! getValueType (firstValue, SVT_INT, fun -> stack -> thisVar)) return false;
if (! getValueType (secondValue, SVT_INT, fun -> reg)) return false;
trimStack (fun -> stack);
switch (com) {
case SLU_MULT:
setVariable (fun -> reg, SVT_INT, firstValue * secondValue);
break;
case SLU_MINUS:
setVariable (fun -> reg, SVT_INT, firstValue - secondValue);
break;
case SLU_MODULUS:
setVariable (fun -> reg, SVT_INT, firstValue % secondValue);
break;
case SLU_DIVIDE:
setVariable (fun -> reg, SVT_INT, firstValue / secondValue);
break;
case SLU_LESSTHAN:
setVariable (fun -> reg, SVT_INT, firstValue < secondValue);
break;
case SLU_MORETHAN:
setVariable (fun -> reg, SVT_INT, firstValue > secondValue);
break;
case SLU_LESS_EQUAL:
setVariable (fun -> reg, SVT_INT, firstValue <= secondValue);
break;
case SLU_MORE_EQUAL:
setVariable (fun -> reg, SVT_INT, firstValue >= secondValue);
break;
default:
break;
}
}
} else {
return fatal (ERROR_NOSTACK);
}
break;
default:
return fatal (ERROR_UNKNOWN_CODE);
}
if (advanceNow) fun -> runThisLine ++;
}
return true;
}
void PageFrame::variableCopy(PageComponent* aComponent)
{
copyVariable(aComponent);
}
