/// <summary>
/// Process the input from the interpreter.
/// If the input is one of the interactive-mode-only commands, the command should not
/// be executed by the interpreter but will be executed by this function manually.
/// </summary>
/// <param name="input"> command line from the interactive-mode</param>
/// <returns> should the command be executed ?</returns>
internal static bool processInterpreterInput(string input)
{
switch (input)
{
case "help":
{
Global.stdoutWriteLine("All existing interactive-mode-only commands:");
// ReSharper disable once RedundantExplicitArrayCreation
foreach (string command in new string[]
{
"help", "exit", "reset_env", "clear", // base interactive-mode
"exec", "exec_info", // exec
"debug", "trace_debug", "parse_debug", // debugging (enable/disable)
"eval %expr", // expr
"var %var_name", "vars", "$%var_name", // variables
// ReSharper disable once StringLiteralTypo
"funcs", "df_funcs", // functions
"type", // ?
"trace_info", "trace_uniq_stacks", "rewind %n %var_name", "peek_trace $%traced_value", // trace
"get_context", "set_status", "set_info_null", "reset_context", // context
"scope_info", // scope
"show-settings", // settings
})
{
Global.stdoutWriteLine(" -> " + command);
}
return(false);
}
case "clear":
if (!Global.getSetting("redirect debug stout & stderr"))
{
Console.Clear();
}
return(false);
case "vars":
{
Global.stdoutWriteLine("Global Variables:");
foreach (var pair in Global.getGlobalVariables())
{
Global.stdoutWriteLine("\t" + pair.Key + " : " + pair.Value);
}
int i = 0;
Global.stdoutWriteLine("Local Scope Variables:");
foreach (var dict in Global.getCurrentDictList())
{
i++;
foreach (var pair in dict)
{
Global.stdoutWrite(new string('\t', i));
Global.stdoutWrite(pair.Key + " : ");
Global.stdoutWriteLine(pair.Value.ToString());
}
}
return(false);
}
// ReSharper disable once StringLiteralTypo
case "funcs":
{
Global.stdoutWriteLine("User defined functions:");
foreach (var pair in Functions.user_functions)
{
Global.stdoutWriteLine(" * " + pair.Key + (pair.Value.isRec() ? " : [rec] " : " : ") + "(" + pair.Value.func_args.Count + ") -> " + pair.Value.getType());
}
return(false);
}
case "df_funcs":
Global.stdoutWriteLine("Default (predefined) functions:");
foreach (var pair in Functions.functions_dict)
{
MethodInfo method = pair.Value.GetMethodInfo();
Global.stdoutWriteLine(" * " + pair.Key + " [?] : (" + method.GetParameters().Length + ") -> " + method.ReturnType);
}
return(false);
case "debug":
Global.setSetting("debug", !Global.getSetting("debug"));
return(false);
case "trace_debug":
Global.setSetting("trace debug", !Global.getSetting("trace debug"));
return(false);
case "parse_debug":
Global.setSetting("parse debug", !Global.getSetting("parse debug"));
return(false);
case "trace_info":
{
Global.stdoutWriteLine("var tracers:");
foreach (VarTracer tracer in Global.var_tracers)
{
Global.stdoutWriteLine(" - var : " + (tracer.getTracedObject() as Variable).getName());
Global.stdoutWriteLine(" - stack : " + tracer.getStackCount());
Global.stdoutWriteLine(" - updated : " + tracer.last_stack_count);
}
Global.stdoutWriteLine("func tracers:");
foreach (FuncTracer tracer in Global.func_tracers)
{
Global.stdoutWriteLine(" - func : " + tracer.getTracedObject());
Global.stdoutWriteLine(" - stack : " + tracer.getStackCount());
}
return(false);
}
case "trace_uniq_stacks":
Global.var_tracers[0].printEventStack();
return(false);
case "reset_env":
Global.resetEnv();
Global.stdoutWriteLine(" [!] Global Environment reset");
return(false);
case "get_context":
{
int status = Context.getStatus();
Context.StatusEnum status_quote = (Context.StatusEnum)status;
object info = Context.getInfo();
bool blocked = Context.isFrozen();
bool enabled = Global.getSetting("fail on context assertions");
Global.stdoutWriteLine("status : " + status);
Global.stdoutWriteLine("quote : " + status_quote);
Global.stdoutWriteLine("info : " + info);
Global.stdoutWriteLine("blocked : " + blocked);
Global.stdoutWriteLine("asserts : " + enabled);
return(false);
}
case "set_info_null":
Context.setInfo(null);
return(false);
case "reset_context":
Context.reset();
return(false);
case "type":
Global.stdoutWriteLine("type of NullVar: " + typeof(NullVar));
Global.stdoutWriteLine("type of Variable: " + typeof(Variable));
Global.stdoutWriteLine("type of Integer: " + typeof(Integer));
return(false);
case "scope_info":
Global.stdoutWriteLine("local scope depth: " + Global.getLocalScopeDepth());
Global.stdoutWriteLine("main scope depth: " + Global.getMainScopeDepth());
return(false);
case "show-settings":
foreach (var pair in Global.getSettings())
{
Global.stdoutWriteLine($" - {pair.Key} : {pair.Value}");
}
return(false);
}
if (input[0] == '$' && Global.variableExistsInCurrentScope(input.Substring(1)))
{
Global.stdoutWriteLine(Global.variableFromName(input.Substring(1)).ToString());
return(false);
}
if (input.StartsWith("set_status "))
{
int status = int.Parse(input.Substring(11));
Context.setStatus((Context.StatusEnum)status);
return(false);
}
if (input.StartsWith("eval "))
{
Variable var_ = Expression.parse(input.Substring(5));
Global.stdoutWriteLine(var_.ToString());
return(false);
}
if (input.StartsWith("var "))
{
string var_name = input.Substring(4);
var_name = StringUtils.normalizeWhiteSpaces(var_name);
if (var_name == "")
{
return(false);
}
Variable var_ = Global.variableFromName(var_name);
Global.stdoutWriteLine("name : " + var_.getName());
Global.stdoutWriteLine("type : " + var_.getTypeString());
Global.stdoutWriteLine("const : " + var_.isConst());
Global.stdoutWriteLine("assigned : " + var_.assigned);
Global.stdoutWriteLine("value : " + var_);
Global.stdoutWriteLine("traced : " + var_.isTraced());
Global.stdoutWriteLine("^ mode : " + var_.trace_mode);
if (var_ is NumericalValue value)
{
Global.stdoutWriteLine("*source : " + StringUtils.dynamic2Str(value.source_vars));
}
return(false);
}
if (input.StartsWith("rewind"))
{
string[] splitted = input.Split(' ');
if (splitted.Length == 3)
{
if (!int.TryParse(splitted[1], out int n))
{
Global.stdoutWriteLine("cannot read n");
return(false);
}
string var_name = splitted[2];
Variable var_ = Expression.parse(var_name);
if (!var_.isTraced())
{
Global.stdoutWriteLine("Variable is not traced! Use the \"trace\" instruction to start tracing variables");
return(false);
}
var_.tracer.rewind(n);
return(false);
}
Global.stdoutWriteLine("split count does not match 3");
return(false);
}
if (input.StartsWith("peek_trace"))
{
if (input.Length < 11)
{
return(false);
}
Variable var_ = Expression.parse(input.Substring(11));
if (!var_.isTraced())
{
Global.stdoutWriteLine("Variable is not traced! Use the \"trace\" instruction to start tracing variables");
return(false);
}
Alteration alter = var_.tracer.peekEvent().alter;
Global.stdoutWriteLine("name : " + alter.name);
Global.stdoutWriteLine("variable : " + alter.affected.getName());
Global.stdoutWriteLine("main value : " + StringUtils.dynamic2Str(alter.main_value));
Global.stdoutWriteLine("num minor : " + alter.minor_values.Length);
Global.stdoutWriteLine("minor values : " + StringUtils.dynamic2Str(alter.main_value));
Global.stdoutWriteLine("stack count : " + var_.tracer.getStackCount());
Global.stdoutWriteLine("updated : " + var_.tracer.last_stack_count);
return(false);
}
if (input.StartsWith("#"))
{
Global.stdoutWriteLine("Handling macro parameter");
if (!input.Contains(' '))
{
Parser.handleMacro(input.Substring(1), null);
return(false);
}
int index = input.IndexOf(' ');
// extract the key & value pair
string value = input.Substring(index);
input = input.Substring(1, index);
// purge pair
value = StringUtils.normalizeWhiteSpaces(value);
input = StringUtils.normalizeWhiteSpaces(input);
Parser.handleMacro(input, value);
return(false);
}
return(true);
}
/// <summary>
/// Applies an arithmetical or logical operation on two <see cref="Variable"/>s
/// <para/>result = (variable1) op (variable2)
/// </summary>
/// <param name="v1"> var 1</param>
/// <param name="v2"> var 2</param>
/// <param name="op"> operator (e.g. '+', '-', '&')</param>
/// <returns> result <see cref="Variable"/></returns>
/// <exception cref="AquilaExceptions.InvalidTypeError"> Invalid type with this operator</exception>
/// <exception cref="AquilaExceptions.SyntaxExceptions.SyntaxError"> Unknown operator char</exception>
private static Variable applyOperator(Variable v1, Variable v2, char op)
{
int comparison;
Debugging.print("applyOperator: ", v1.ToString(), " ", op, " ", v2.ToString(), " (", v1.getTypeString(), " ", op, " ", v2.getTypeString(), ")");
// Debugging.assert(v1.hasSameParent(v2)); // operations between same classes/subclasses
if (!v1.hasSameParent(v2))
{
if (v2.isConst())
{
if (v2 is Integer)
{
Debugging.print("Converting int to float because of const status: ", v1.ToString());
Debugging.assert(v1 is FloatVar, new AquilaExceptions.InvalidTypeError($"The type \"{v1.getTypeString()}\" was not expected. \"{v1.getTypeString()}\" expected")); // if this is not a float, operation is not permitted !
v2 = new FloatVar((float)v2.getValue());
}
}
else
{
throw new AquilaExceptions.InvalidTypeError($"The type \"{v1.getTypeString()}\" was not expected");
}
}
switch (op)
{
// arithmetic
case '+':
if (v1 is NumericalValue)
{
return(((NumericalValue)v1).addition((NumericalValue)v2));
}
else
{
throw new AquilaExceptions.InvalidTypeError($"Invalid type \"{v1.getTypeString()}\" with operator \"{op}\"");
}
case '-':
if (v1 is NumericalValue)
{
return(((NumericalValue)v1).subtraction((NumericalValue)v2));
}
else
{
throw new AquilaExceptions.InvalidTypeError($"Invalid type \"{v1.getTypeString()}\" with operator \"{op}\"");
}
case '/':
if (v1 is NumericalValue)
{
return(((NumericalValue)v1).division((NumericalValue)v2));
}
else
{
throw new AquilaExceptions.InvalidTypeError($"Invalid type \"{v1.getTypeString()}\" with operator \"{op}\"");
}
case '*':
if (v1 is NumericalValue)
{
return(((NumericalValue)v1).mult((NumericalValue)v2));
}
else
{
throw new AquilaExceptions.InvalidTypeError($"Invalid type \"{v1.getTypeString()}\" with operator \"{op}\"");
}
case '%':
if (v1 is Integer)
{
return(((Integer)v1).modulo((Integer)v2));
}
else
{
throw new AquilaExceptions.InvalidTypeError($"Invalid type \"{v1.getTypeString()}\" with operator \"{op}\"");
}
// logic
case '<':
Debugging.assert(v1 is Integer || v1 is FloatVar);
comparison = v1 is Integer
? ((Integer)v1).compare(v2 as Integer)
: ((FloatVar)v1).compare(v2 as FloatVar);
return(new BooleanVar(comparison == -1));
case '>':
Debugging.assert(v1 is Integer || v1 is FloatVar);
comparison = v1 is Integer
? ((Integer)v1).compare(v2 as Integer)
: ((FloatVar)v1).compare(v2 as FloatVar);
return(new BooleanVar(comparison == 1));
case '{':
Debugging.assert(v1 is Integer || v1 is FloatVar);
comparison = v1 is Integer
? ((Integer)v1).compare(v2 as Integer)
: ((FloatVar)v1).compare(v2 as FloatVar);
return(new BooleanVar(comparison != 1));
case '}':
Debugging.assert(v1 is Integer || v1 is FloatVar);
comparison = v1 is Integer
? ((Integer)v1).compare(v2 as Integer)
: ((FloatVar)v1).compare(v2 as FloatVar);
return(new BooleanVar(comparison != -1));
case '~':
Debugging.assert(v1 is Integer || v1 is FloatVar);
comparison = v1 is Integer
? ((Integer)v1).compare(v2 as Integer)
: ((FloatVar)v1).compare(v2 as FloatVar);
return(new BooleanVar(comparison == 0));
case ':':
Debugging.assert(v1 is Integer || v1 is FloatVar);
comparison = v1 is Integer
? ((Integer)v1).compare(v2 as Integer)
: ((FloatVar)v1).compare(v2 as FloatVar);
return(new BooleanVar(comparison != 0));
case '|':
Debugging.assert(v1 is BooleanVar);
return(((BooleanVar)v1).or((BooleanVar)v2));
case '^':
Debugging.assert(v1 is BooleanVar);
return(((BooleanVar)v1).xor((BooleanVar)v2));
case '&':
Debugging.assert(v1 is BooleanVar);
return(((BooleanVar)v1).and((BooleanVar)v2));
default:
throw new AquilaExceptions.SyntaxExceptions.SyntaxError("Unknown operand " + op);
}
}
