public override void execute()
{
setContext();
int context_integrity_check = Context.getStatusStackCount();
Debugging.print("Assignment: ", _var_name, " = ", _var_value.expr);
// set the new value
Variable variable;
try
{
variable = Expression.parse(_var_name);
}
catch (AquilaExceptions.NameError)
{
// implicit declaration
if (!Global.getSetting("implicit declaration in assignment"))
{
throw;
}
Debugging.print("Implicit declaration in Assignment!");
Declaration decl = new Declaration(line_index, _var_name.Substring(1), _var_value); // in the Assignment constructor: already check if _var_name != ""
decl.execute();
// update things 'n stuff
Global.onElementaryInstruction();
// reset Context
// Smooth Context
Context.resetUntilCountReached(context_integrity_check);
Context.reset();
return;
}
// parsing new value
Variable val = _var_value.evaluate();
Debugging.print("assigning " + _var_name + " with expr " + _var_value.expr + " with value " + val + " (2nd value assigned: " + val.assigned + ") and type: " + val.getTypeString());
// assert the new is not an unassigned (only declared) variable
val.assertAssignment();
if (variable.hasSameParent(val))
{
variable.setValue(val);
}
else
{
throw new AquilaExceptions.InvalidTypeError("You cannot change the type of your variables (" + variable.getTypeString() + " -> " + val.getTypeString() + "). This will never be supported because it would be considered bad style.");
}
// update things 'n stuff
Global.onElementaryInstruction();
// reset Context
// Smooth Context
Context.resetUntilCountReached(context_integrity_check);
Context.reset();
}
public override void execute()
{
setContext();
// get variable value
Variable variable_value = _var_expr.evaluate();
// is the value assigned ? (only relevant if other variable)
variable_value.assertAssignment();
Variable variable = Variable.fromRawValue(variable_value.getRawValue());
// keep track of source vars -> should do something generic for lots of attributes ...
if (variable is NumericalValue)
{
((NumericalValue)variable).source_vars = new Dictionary <string, NumericalValue>(((NumericalValue)variable_value).source_vars);
}
variable.setName(_var_name);
// explicit typing
if (_var_type != StringConstants.Types.AUTO_TYPE)
{
Debugging.print("checking variable explicit type");
Expression default_value = Global.default_values_by_var_type[_var_type];
Debugging.assert(variable_value.hasSameParent(default_value.evaluate())); // TypeException
}
// constant
if (_constant)
{
if (variable_value.isConst())
{
variable.setConst();
}
else
{
throw new AquilaExceptions.InvalidVariableClassifierException(
"The \"const\" cannot be used when assigning to a non-const value");
}
}
// actually declare it to its value
if (_global)
{
Global.addGlobalVariable(_var_name, variable);
}
else
{
Global.getCurrentDict()[_var_name] = variable; // overwriting is mandatory
Debugging.print("variable exists ", Global.variableExistsInCurrentScope(_var_name));
if (_assignment)
{
variable.assign(); // should not need this, but doing anyway
}
else
{
variable.assigned = false;
}
}
Debugging.print("finished declaration with value assignment: ", variable.assigned);
// automatic tracing ?
if (_assignment && Global.getSetting("auto trace"))
{
Debugging.print("Tracing variable: \"auto trace\" setting set to true");
// Does NOT work by simply doing "variable.startTracing()", and idk why
Tracing tracing_instr = new RawInstruction($"trace ${_var_name}", line_index).toInstr() as Tracing;
//Tracing tracing_instr = new Tracing(line_index, new List<Expression>{_var_expr}); // <- does not work either :(
tracing_instr.execute();
}
// update things 'n stuff
Global.onElementaryInstruction();
// reset Context
Context.reset();
}
