private void CompileBranchWithStringCompare(TextWriter writer, string label, bool branchIfTrue)
{
if (LeftCompiler.IsLiteral && LeftCompiler.CanCompileBoolean && IsBooleanValue(LeftCompiler.Value))
{
CompileBranchForStringVariable(writer, RightCompiler, label, LeftCompiler.BooleanValue ^ (ParentExpression.Operator.Token == Token.NotEqualTo));
}
else if (RightCompiler.IsLiteral && RightCompiler.CanCompileBoolean && IsBooleanValue(RightCompiler.Value))
{
CompileBranchForStringVariable(writer, LeftCompiler, label, RightCompiler.BooleanValue ^ (ParentExpression.Operator.Token == Token.NotEqualTo));
}
else
{
using (var tempVariables = Context.UseTempVariables())
{
string leftValue = LeftCompiler.Compile(writer, tempVariables.CreateVariable(LeftCompiler.Type));
string rightValue = RightCompiler.Compile(writer, tempVariables.CreateVariable(RightCompiler.Type));
//IEV3Variable tempResultVariable = tempVariables.CreateVariable(EV3Type.String);
//writer.WriteLine($" CALL EQ_STRING {leftValue} {rightValue} {tempResultVariable.Ev3Name}");
//writer.WriteLine($" AND8888_32 {tempResultVariable.Ev3Name} -538976289 {tempResultVariable.Ev3Name}");
//writer.WriteLine($" STRINGS COMPARE {tempResultVariable.Ev3Name} 'TRUE' {tempResultVariable.Ev3Name}");
//writer.WriteLine($" JR_{GetOperationForJump(branchIfTrue)}8 {tempResultVariable.Ev3Name} 0 {label}");
IEV3Variable tempResultVariable = tempVariables.CreateVariable(EV3Type.Float);
writer.WriteLine($" CALL EQ_STRING8 {leftValue} {rightValue} {tempResultVariable.Ev3Name}");
writer.WriteLine($" JR_{GetOperationForJump(branchIfTrue)}8 {tempResultVariable.Ev3Name} 0 {label}");
}
}
}
private void RemoveTempVariable(IEV3Variable variable)
{
if (variable is TempEV3Variable)
{
tempVariablesCurrent[variable.Type].Remove(((TempEV3Variable)variable).Id);
}
}
public override string Compile(TextWriter writer, IEV3Variable variable)
{
EV3SubDefinitionBase sub = Context.FindMethod(Value);
if (sub != null)
{
return(CompileMethodCall(writer, variable, sub));
}
AddError($"Unknown method call to {ParentExpression.FullName()}");
return("");
}
public override string Compile(TextWriter writer, IEV3Variable variable)
{
if (Type == EV3Type.StringArray && variable.Type == EV3Type.StringArray)
{
foreach (Match match in Regex.Matches(Value, @"([\d]+)=([^;']*)"))
{
writer.WriteLine($" CALL ARRAYSTORE_STRING {match.Groups[1].Value}.0 '{match.Groups[2].Value}' {variable.Ev3Name}");
}
return("");
}
return(Value);
}
public override string Compile(TextWriter writer, IEV3Variable variable)
{
if (IsLiteral)
{
return(Value);
}
else
{
string expressionValue = ParentExpression.Expression.Compiler().Compile(writer, variable);
writer.WriteLine($" MATH NEGATE {expressionValue} {variable.Ev3Name}");
return(variable.Ev3Name);
}
}
public void CompileBranchForStringVariable(TextWriter writer, IExpressionCompiler valueCompiler, string label, bool negated)
{
if (CanCompileBoolean)
{
using (var tempVariables = Context.UseTempVariables())
{
IEV3Variable tempResultVariable = tempVariables.CreateVariable(EV3Type.String);
IEV3Variable tempIsTrueVariable = tempVariables.CreateVariable(EV3Type.Float);
writer.WriteLine($" CALL IS_TRUE {valueCompiler.Compile(writer, tempResultVariable)} {tempIsTrueVariable.Ev3Name}");
writer.WriteLine($" JR_{(negated ? "EQ" : "NEQ")}8 {tempIsTrueVariable.Ev3Name} 0 {label}");
//writer.WriteLine($" STRINGS DUPLICATE {Value} {tempResultVariable.Ev3Name}");
//writer.WriteLine($" AND8888_32 {tempResultVariable.Ev3Name} -538976289 {tempResultVariable.Ev3Name}");
//writer.WriteLine($" STRINGS COMPARE {tempResultVariable.Ev3Name} 'TRUE' {tempIsTrueVariable.Ev3Name}");
//writer.WriteLine($" JR_EQ8 {tempIsTrueVariable.Ev3Name} 0 {label}");
}
}
}
public override string Compile(TextWriter writer, IEV3Variable variable)
{
using (var tempVariables = Context.UseTempVariables())
{
IExpressionCompiler indexCompiler = ParentExpression.Indexer.Compiler();
string indexValue = indexCompiler.Compile(writer, tempVariables.CreateVariable(EV3Type.Float));
if (variable.Ev3Name.Equals(Variable.Ev3Name, StringComparison.InvariantCultureIgnoreCase) ||
variable.Type != Type.BaseType())
{
variable = tempVariables.CreateVariable(Type.BaseType());
}
if (variable.Type == EV3Type.String)
{
writer.WriteLine($" CALL ARRAYGET_STRING {indexValue} {variable.Ev3Name} {Variable.Ev3Name}");
}
else
{
if (Context.DoBoundsCheck)
{
writer.WriteLine($" CALL ARRAYGET_FLOAT {indexValue} {variable.Ev3Name} {Variable.Ev3Name}");
}
else
{
if (indexCompiler.IsLiteral)
{
if (indexValue.EndsWith(".0"))
{
indexValue = indexValue.Remove(indexValue.Length - 2);
}
}
else
{
writer.WriteLine($" MOVEF_32 {indexValue} INDEX");
indexValue = "INDEX";
}
writer.WriteLine($" ARRAY_READ {Variable.Ev3Name} {indexValue} {variable.Ev3Name}");
}
}
return(variable.Ev3Name);
}
}
public override string Compile(TextWriter writer, IEV3Variable variable)
{
EV3SubDefinitionBase sub = Context.FindMethod(Value);
if (sub != null)
{
using (var tempVariables = Context.UseTempVariables())
{
if (variable.Type.IsArray() && !sub.ReturnType.IsArray())
{
variable = tempVariables.CreateVariable(variable.Type.BaseType());
}
return(sub.Compile(writer, Context, new string[0], variable.Ev3Name));
}
}
else
{
AddError($"Unknown property {ParentExpression.FullName()}");
}
return(variable.Ev3Name);
}
private string CompileMethodCall(TextWriter writer, IEV3Variable variable, EV3SubDefinitionBase sub)
{
if (sub.ParameterTypes.Count != ParentExpression.Arguments.Count)
{
AddError($"Incorrect number of parameters. Expected {sub.ParameterTypes.Count}.");
return("");
}
using (var tempVariables = Context.UseTempVariables())
{
string[] arguments = ParentExpression.Arguments
.Select(a => a.Compiler())
.Zip(sub.ParameterTypes, (c, t) => new { Compiler = c, Type = t })
.Select(c => CompileWithConvert(writer, c.Compiler, c.Type, tempVariables)).ToArray();
if (variable != null && variable.Type.IsArray() && !sub.ReturnType.IsArray())
{
variable = tempVariables.CreateVariable(variable.Type.BaseType());
}
return(sub.Compile(writer, Context, arguments, variable?.Ev3Name));
}
}
protected string CompileWithConvert(TextWriter writer, IExpressionCompiler compiler, EV3Type resultType, EV3Variables.TempVariableCreator tempVariables)
{
string value = compiler.Compile(writer, tempVariables.CreateVariable(compiler.Type));
if (compiler.Type.BaseType().IsNumber() && resultType.BaseType() == EV3Type.String)
{
if (compiler.IsLiteral)
{
return("'" + SmallBasicExtensions.FormatFloat(value) + "'");
}
else
{
IEV3Variable outputVariable = tempVariables.CreateVariable(EV3Type.String);
writer.WriteLine($" STRINGS VALUE_FORMATTED {value} '%g' 99 {outputVariable.Ev3Name}");
return(outputVariable.Ev3Name);
}
}
else
{
return(value);
}
}
public override string Compile(TextWriter writer, IEV3Variable variable)
{
return("");
}
public override void Compile(TextWriter writer, bool isRootStatement)
{
string label = Context.GetNextLabelNumber().ToString();
EV3Variable variable = Context.FindVariable(ParentStatement);
if (variable.Type == EV3Type.Unknown)
{
variable.Type = EV3Type.Float;
}
variable.IsConstant = false;
IExpressionCompiler stepCompiler = ParentStatement.StepValue == null ? null : ParentStatement.StepValue.Compiler();
using (var tempVariables = Context.UseTempVariables())
{
string initialValue = ParentStatement.InitialValue.Compiler().Compile(writer, variable);
if (initialValue != variable.Ev3Name)
{
writer.WriteLine($" MOVEF_F {initialValue} {variable.Ev3Name}");
}
writer.WriteLine($" for{label}:");
string finalValue = ParentStatement.FinalValue.Compiler().Compile(writer, tempVariables.CreateVariable(EV3Type.Float));
if (stepCompiler == null || stepCompiler.IsLiteral)
{
if (stepCompiler is NegativeExpressionCompiler)
{
writer.WriteLine($" JR_LTF {variable.Ev3Name} {finalValue} endfor{label}");
}
else
{
writer.WriteLine($" JR_GTF {variable.Ev3Name} {finalValue} endfor{label}");
}
}
else
{
string stepValue = stepCompiler.Compile(writer, tempVariables.CreateVariable(EV3Type.Float));
IEV3Variable tempStepResultVariable = tempVariables.CreateVariable(EV3Type.Float);
writer.WriteLine($" CALL LE_STEP8 {variable.Ev3Name} {finalValue} {stepValue} {tempStepResultVariable.Ev3Name}");
writer.WriteLine($" JR_EQ8 {tempStepResultVariable.Ev3Name} 0 endfor{label}");
}
}
using (var tempVariables = Context.UseTempVariables())
{
writer.WriteLine($" forbody{label}:");
ParentStatement.ForBody.Compile(writer, false);
string stepValue = stepCompiler == null ? "1.0" : stepCompiler.Compile(writer, tempVariables.CreateVariable(EV3Type.Float));
writer.WriteLine($" ADDF {variable.Ev3Name} {stepValue} {variable.Ev3Name}");
string finalValue2 = ParentStatement.FinalValue.Compiler().Compile(writer, tempVariables.CreateVariable(EV3Type.Float));
if (stepCompiler == null || stepCompiler.IsLiteral)
{
if (stepCompiler is NegativeExpressionCompiler)
{
writer.WriteLine($" JR_GTEQF {variable.Ev3Name} {finalValue2} forbody{label}");
}
else
{
writer.WriteLine($" JR_LTEQF {variable.Ev3Name} {finalValue2} forbody{label}");
}
}
else
{
IEV3Variable tempStepResultVariable = tempVariables.CreateVariable(EV3Type.Float);
writer.WriteLine($" CALL LE_STEP8 {variable.Ev3Name} {finalValue2} {stepValue} {tempStepResultVariable.Ev3Name}");
writer.WriteLine($" JR_NEQ8 {tempStepResultVariable.Ev3Name} 0 forbody{label}");
}
writer.WriteLine($" endfor{label}:");
}
}
public override string Compile(TextWriter writer, IEV3Variable variable)
{
if (IsLiteral)
{
return(Value);
}
EV3Type commonType = CalculateCommonType(LeftCompiler.Type, RightCompiler.Type);
if (commonType == EV3Type.Unknown)
{
AddError("Types of left and right side of expression don't match");
}
else
{
using (var tempVariables = Context.UseTempVariables())
{
string leftValue = CompileWithConvert(writer, LeftCompiler, commonType, tempVariables);
string rightValue = CompileWithConvert(writer, RightCompiler, commonType, tempVariables);
if (variable.Type.IsArray())
{
variable = tempVariables.CreateVariable(variable.Type.BaseType());
}
if (Type.IsNumber())
{
switch (ParentExpression.Operator.Token)
{
case Token.Addition:
writer.WriteLine($" ADDF {leftValue} {rightValue} {variable.Ev3Name}");
break;
case Token.Subtraction:
writer.WriteLine($" SUBF {leftValue} {rightValue} {variable.Ev3Name}");
break;
case Token.Division:
if (Context.DoDivisionCheck)
{
var sub = Context.FindMethod("Math.DivCheck");
if (variable.Type.IsArray() && !sub.ReturnType.IsArray())
{
variable = tempVariables.CreateVariable(variable.Type.BaseType());
}
sub.Compile(writer, Context, new string[] { leftValue, rightValue }, variable.Ev3Name);
}
else
{
writer.WriteLine($" DIVF {leftValue} {rightValue} {variable.Ev3Name}");
}
break;
case Token.Multiplication:
writer.WriteLine($" MULF {leftValue} {rightValue} {variable.Ev3Name}");
break;
}
}
else if (ParentExpression.Operator.Token == Token.Addition)
{
writer.WriteLine($" CALL TEXT.APPEND {leftValue} {rightValue} {variable.Ev3Name}");
}
return(variable.Ev3Name);
}
}
return("");
}
public override void Compile(TextWriter writer, bool isRootStatement)
{
IAssignmentExpressionCompiler variableCompiler = ParentStatement.LeftValue.Compiler <IAssignmentExpressionCompiler>();
if (variableCompiler != null)
{
EV3Variable variable = Context.FindVariable(variableCompiler.VariableName);
IExpressionCompiler valueCompiler = ParentStatement.RightValue.Compiler();
if (variable.Type == EV3Type.Unknown)
{
variable.Type = valueCompiler.Type;
if (variableCompiler.IsArray)
{
variable.Type = variable.Type.ConvertToArray();
}
}
variable.IsConstant &= isRootStatement && Context.DoOptimization && valueCompiler.IsLiteral && !variable.Type.IsArray();
if (variable.Type.IsArray())
{
if (valueCompiler is IAssignmentExpressionCompiler)
{
variable.UpdateMaxIndex(((IAssignmentExpressionCompiler)valueCompiler).Index);
}
else if (valueCompiler is LiteralExpressionCompiler)
{
variable.UpdateMaxIndex(((LiteralExpressionCompiler)valueCompiler).MaxIndex);
}
}
//Console.WriteLine($"valueCompiler.Type = {valueCompiler.Type}, variable.Type = {variable.Type}, variableCompiler.Type = {variableCompiler.Type}");
if (variableCompiler.Type.IsArray() && (valueCompiler.Type != variableCompiler.Type))
{
AddError($"Cannot assign value to array variable '{variableCompiler.VariableName}' without index");
}
else if (!variableCompiler.Type.IsArray() && valueCompiler.Type.IsArray())
{
AddError($"Cannot assign array value to non-array variable '{variableCompiler.VariableName}'");
}
else if (valueCompiler.Type == EV3Type.String && variableCompiler.Type.IsNumber())
{
AddError($"Cannot assign {valueCompiler.Type} value to {variableCompiler.Type} variable '{variableCompiler.VariableName}'");
}
else if (valueCompiler.Type.IsNumber() && variableCompiler.Type == EV3Type.String && !variable.Type.IsArray())
{
if (variable.IsConstant)
{
variable.Value = valueCompiler.Value;
}
else
{
using (var tempVariables = Context.UseTempVariables())
{
IEV3Variable tempVariable = tempVariables.CreateVariable(valueCompiler.Type);
string compiledValue = valueCompiler.Compile(writer, tempVariable);
if (string.IsNullOrEmpty(compiledValue))
{
return;
}
writer.WriteLine($" STRINGS VALUE_FORMATTED {compiledValue} '%g' 99 {variable.Ev3Name}");
}
}
}
else
{
if (variable.IsConstant)
{
variable.Value = valueCompiler.Value;
}
else
{
string compiledValue = valueCompiler.Compile(writer, variable);
if (string.IsNullOrEmpty(compiledValue))
{
return;
}
using (var tempVariables = Context.UseTempVariables())
{
if (valueCompiler.Type.IsNumber() && variable.Type == EV3Type.StringArray)
{
IEV3Variable tempVariable = tempVariables.CreateVariable(EV3Type.String);
writer.WriteLine($" STRINGS VALUE_FORMATTED {compiledValue} '%g' 99 {tempVariable.Ev3Name}");
compiledValue = tempVariable.Ev3Name;
}
variableCompiler.CompileAssignment(writer, compiledValue, variable.Ev3Name);
}
}
}
}
else
{
AddError($"Cannot assign value to this expression {ParentStatement.LeftValue}");
}
}
public abstract string Compile(TextWriter writer, IEV3Variable variable);
