public override object VisitInteger_expr([NotNull] scheme_langParser.Integer_exprContext context)
{
int result_reg = PopLastParamReg();
CommandSetVariable cmd = new CommandSetVariable(GetRegName(result_reg), context.integer().GetText());
currentFunc.AddCommand(cmd, expression_index);
return(base.VisitInteger_expr(context));
}
public override object VisitLogical_const_expr([NotNull] scheme_langParser.Logical_const_exprContext context)
{
int param = PopLastParamReg();
string logical_const = context.logical_const().GetText();
CommandSetVariable cmd = new CommandSetVariable(GetRegName(param), logical_const);
currentFunc.AddCommand(cmd, expression_index);
return(base.VisitLogical_const_expr(context));
}
public override object VisitObject_atom([NotNull] scheme_langParser.Object_atomContext context)
{
int result_reg = PopLastParamReg();
string objName = context.object_name().GetText();
VariableManager.CheckValueValidity(objName, this, context.object_name());
CommandSetVariable cmd = new CommandSetVariable(GetRegName(result_reg), objName);
currentFunc.AddCommand(cmd, expression_index);
return(base.VisitObject_atom(context));
}
public override object VisitVariable_expr([NotNull] scheme_langParser.Variable_exprContext context)
{
//variable_expr can also be 'of' expression, in that case we do nothing here
if (context.variable_name() != null)
{
int result_reg = PopLastParamReg();
string varName = context.variable_name().GetText();
VariableManager.CheckValueValidity(varName, this, context.variable_name());
CommandSetVariable cmd = new CommandSetVariable(GetRegName(result_reg), varName);
currentFunc.AddCommand(cmd, expression_index);
}
return(base.VisitVariable_expr(context));
}
/* String const expression */
public override object VisitString_const_expr([NotNull] scheme_langParser.String_const_exprContext context)
{
int result_reg = PopLastParamReg();
string string_const_name = context.string_const().GetText();
if (Config.GetStringConstByName(string_const_name) == null)
{
Errors.Add(new ErrorDescriptor($"String const '{string_const_name}' does not exist.", context));
}
CommandSetVariable cmd = new CommandSetVariable(GetRegName(result_reg), string_const_name);
currentFunc.AddCommand(cmd, expression_index);
return(base.VisitString_const_expr(context));
}
public override object VisitCmd_set_var([NotNull] scheme_langParser.Cmd_set_varContext context)
{
string varName = context.variable_name().GetText();
if (!VariableManager.IsVariable(varName, Scheme))
{
Errors.Add(new ErrorDescriptor($"Variable '{varName}' is not recognized.", context.variable_name()));
}
CommandSetVariable cmd = new CommandSetVariable(varName, GetRegName(0));
currentFunc.AddCommand(cmd);
SetNewExpression(1);
return(base.VisitCmd_set_var(context));
}
public override object VisitBody_variable_definition([NotNull] scheme_langParser.Body_variable_definitionContext context)
{
//Add predefined variable to scheme
var variable_definition = context.variable_definition();
string type = variable_definition?.variable_type()?.GetText();
string name = variable_definition?.variable_name()?.GetText();
if (type == null || name == null)
{
return(base.VisitBody_variable_definition(context));
}
if (!VariableManager.IsTypeValid(type, Config))
{
Errors.Add(new ErrorDescriptor($"Type '{type}' is not recognized.", variable_definition.variable_type()));
}
if (CompiledScheme.GetVariableByName(name) != null || CompiledScheme.GetParameterByName(name) != null)
{
Errors.Add(new ErrorDescriptor($"Variable or parameter '{name}' already exists.", variable_definition.variable_name()));
if (variable_definition.EQUALS() != null)
{
SetNewExpression(1);
}
return(base.VisitBody_variable_definition(context));
}
ObjectVariable variable = new ObjectVariable(type, name, null);
if (variable != null)
{
CompiledScheme.AddVariable(variable);
CommandSetVariable cmd = new CommandSetVariable(variable_definition.variable_name().GetText(), GetRegName(0));
currentFunc.AddCommand(cmd);
SetNewExpression(1);
}
return(base.VisitBody_variable_definition(context));
}
public static void SolveSimpleValueRegs(SchemeFunction function)
{
//We iterate commands
//If we find a SET(<reg>, <simple value>) command, we
// //remove this SET command
// //Iterate over the subsequent commands in the base block
// //If we find any command with input <reg> we change it to <simple value>
// //If we find any command with output <reg> we stop and goto 1. (continuing from the SET command we found)
var commands = function.Commands;
HashSet <int> removableIndexes = new HashSet <int>();
for (int i = 0; i < commands.Count; ++i)
{
ISchemeCommand cmd = commands[i];
if (cmd is CommandSetVariable)
{
CommandSetVariable cmdSet = (CommandSetVariable)cmd;
string targetVar = cmdSet.GetVariableName();
string value = cmdSet.GetValue();
if (SchemeExecutor.IsRegister(targetVar))
{
removableIndexes.Add(i);
for (int i2 = i + 1; i2 < commands.Count; ++i2)
{
ISchemeCommand cmd2 = commands[i2];
cmd2.ChangeInputs(targetVar, value);
if (cmd2 is CommandJumpBase || cmd2.HasOutput(targetVar))
{
break;
}
}
}
}
}
RemoveCommandsAt(function, removableIndexes);
}
public override object VisitCmd_create_var([NotNull] scheme_langParser.Cmd_create_varContext context)
{
var var_def = context.variable_definition();
string var_type = var_def.variable_type()?.GetText();
string var_name = var_def.variable_name()?.GetText();
if (var_type == null || var_name == null)
{
if (var_def.EQUALS() != null)
{
SetNewExpression(1);
}
return(base.VisitCmd_create_var(context));
}
if (!VariableManager.IsTypeValid(var_type, Config))
{
Errors.Add(new ErrorDescriptor($"Type '{var_type}' is not recognized.", var_def.variable_type()));
}
VariableManager.CheckNewVariable(var_name, this, var_def.variable_name());
CommandCreateVariable create_cmd = new CommandCreateVariable(var_type, var_name);
currentFunc.AddCommand(create_cmd);
if (var_def.EQUALS() != null)
{
CommandSetVariable cmd = new CommandSetVariable(var_name, GetRegName(0));
currentFunc.AddCommand(cmd);
SetNewExpression(1);
}
return(base.VisitCmd_create_var(context));
}
public static void SolveRegisterBuffers(SchemeFunction function)
{
// if an operation stores its result in a register <reg>, and it is followed by a SET(<var>, <reg>) command
// we delete the SET command and set the opperation's output to <var>
// we iterate over the following commands and change any <reg> to <var>
// we stop if <reg> is set again or we leave the block
var commands = function.Commands;
HashSet <int> removableIndexes = new HashSet <int>();
for (int i = 0; i < commands.Count; ++i)
{
ISchemeCommand cmd = commands[i];
var outputs = cmd.GetOutputs();
if (outputs == null)
{
continue;
}
// check if any output is a register
foreach (var reg in outputs)
{
if (SchemeExecutor.IsRegister(reg))
{
string variable = null;
for (int j = i + 1; j < commands.Count; ++j)
{
ISchemeCommand cmd2 = commands[j];
if (cmd2 is CommandJumpBase)
{
break; // break if we leave the block
}
if (cmd2.HasOutput(reg))
{
break; // break if the register is set again
}
if (cmd2 is CommandSetVariable && cmd2.HasInput(reg))
{
CommandSetVariable setCmd = (CommandSetVariable)cmd2;
variable = setCmd.GetVariableName();
if (SchemeExecutor.IsRegister(variable))
{
variable = null;
}
else
{
cmd.ChangeOutput(reg, variable);
removableIndexes.Add(j);
}
}
if (variable != null && cmd2.HasInput(reg))
{
cmd2.ChangeInputs(reg, variable);
}
}
}
}
}
RemoveCommandsAt(function, removableIndexes);
}
