private void CompileNeg(ILExpression e, ExpectType expect)
{
CompileExpression(e.Arguments[0], ExpectType.Primitive);
InterType opType = resolver.Resolve(e.InferredType, thisMethod.FullGenericArguments);
JavaPrimitiveType jp = JavaHelpers.InterTypeToJavaPrimitive(opType);
OpCodes opcode = OpCodes.ineg;
switch (jp)
{
case JavaPrimitiveType.Long: opcode = OpCodes.lneg; break;
case JavaPrimitiveType.Float: opcode = OpCodes.fneg; break;
case JavaPrimitiveType.Double: opcode = OpCodes.dneg; break;
case JavaPrimitiveType.Ref:
throw new Exception(); //TODO: normal error
}
codeGenerator.Add(opcode, null, e);
TranslateType(opType, expect, e);
}
public static JsonCommand ClearExpectBuffer(int timeout, ExpectType expect_type = ExpectType.P2P)
{
var jc = new JsonCommand(CommandType.ClearExpectBuffer, "", timeout);
jc.ExpectType = expect_type;
return(jc);
}
private void CompileBlock(ILBlock block, ExpectType expect)
{
foreach (ILNode node in block.Body)
{
CompileNode(node, expect);
}
}
public static JsonCommand ResetExpectSession(int timeout, ExpectType expect_type = ExpectType.P2P)
{
var jc = new JsonCommand(CommandType.ResetExpectSession, "", timeout);
jc.ExpectType = expect_type;
return(jc);
}
private void CompileConvR8(ILExpression e, ExpectType expect)
{
InterType gettedType = resolver.Resolve(e.Arguments[0].InferredType, thisMethod.FullGenericArguments);
JavaPrimitiveType gettedJava = JavaHelpers.InterTypeToJavaPrimitive(gettedType);
CompileExpression(e.Arguments[0], ExpectType.Any);
switch (gettedJava)
{
case JavaPrimitiveType.Bool:
case JavaPrimitiveType.Byte:
case JavaPrimitiveType.Short:
case JavaPrimitiveType.Char:
case JavaPrimitiveType.Int:
codeGenerator.Add(Java.OpCodes.i2d, e);
break;
case JavaPrimitiveType.Long:
codeGenerator.Add(Java.OpCodes.l2d, e);
break;
case JavaPrimitiveType.Float:
codeGenerator.Add(Java.OpCodes.f2d, e);
break;
case JavaPrimitiveType.Double:
break;
default:
Messages.Message(MessageCode.CantConvertType, gettedType.Fullname, "double");
return;
}
TranslateType(InterType.PrimitiveTypes[(int)PrimitiveType.Double], expect, e);
}
private void CompileBreak(ILExpression e, ExpectType expect)
{
if (Program.CompileBreak)
{
codeGenerator.Add(Java.OpCodes.breakpoint, null, e);
}
}
private void CompileLocalloc(ILExpression e, ExpectType expect)
{
Messages.Message(MessageCode.UnsafeInstruction, e.Code.ToString());
CompileExpression(e.Arguments[0], ExpectType.Primitive);
codeGenerator.AddNewArray(JavaArrayType.Byte, e);
}
private void CompileLdobj(ILExpression e, ExpectType expect)
{
InterType operand = resolver.Resolve((TypeReference)e.Operand, thisMethod.FullGenericArguments);
if ((operand.IsPrimitive) && (e.Arguments[0].Code == ILCode.Ldloc) &&
(((ILVariable)e.Arguments[0].Operand).Name == "this"))
{
//Special treatment. Value for primitive types
codeGenerator
.Add(Java.OpCodes.aload_0, null, e)
.Add(Java.OpCodes.getfield, new Java.Constants.FieldRef(
namesController.TypeNameToJava(operand.CILBoxType), "value",
namesController.GetFieldDescriptor(operand)), e);
}
else if (operand.IsValueType)
{
CompileExpression(e.Arguments[0], ExpectType.ByRef);
MethodRef getCopyRef = new MethodRef(namesController.TypeNameToJava(operand),
ClassNames.ValueTypeGetCopy, "()" + namesController.GetFieldDescriptor(operand));
codeGenerator.Add(Java.OpCodes.invokevirtual, getCopyRef, e);
}
else
{
// From ECMA-335, III.4.29
// If typeTok is not a generic parameter and either a reference type or a built-in value
// class, then the ldind instruction provides a shorthand for the ldobj instruction.
CompileLdind(e, expect);
}
}
private void CompileLogicAnd(ILExpression e, ExpectType expect)
{
string labelsSufix = rnd.Next().ToString();
string falseLabel = "false" + labelsSufix;
string exitLabel = "exit" + labelsSufix;
Java.OpCodes branch = Java.OpCodes.ifeq;
CompileExpression(e.Arguments[0], ExpectType.Primitive);
TranslateToBool(e.Arguments[0].InferredType, ref branch, e);
codeGenerator.Add(branch, falseLabel, e);
CompileExpression(e.Arguments[1], ExpectType.Primitive);
TranslateToBool(e.Arguments[1].InferredType, ref branch, e);
branch = Java.OpCodes.ifeq;
codeGenerator
.Add(branch, falseLabel, e)
.Add(Java.OpCodes.iconst_1, null, e)
.Add(Java.OpCodes._goto, exitLabel, e)
.Label(falseLabel)
.Add(Java.OpCodes.iconst_0, null, e)
.Label(exitLabel);
}
private void CompileLdcDecimal(ILExpression e, ExpectType expect)
{
decimal operand = (decimal)e.Operand;
int[] bits = decimal.GetBits(operand);
codeGenerator
.Add(OpCodes._new, new Java.Constants.Class(namesController.TypeNameToJava(ClassNames.SystemDecimal.ClassNames)), e)
.Add(OpCodes.dup, null, e)
.Add(OpCodes.iconst_4, null, e)
.AddNewArray(JavaArrayType.Int, e)
.Add(OpCodes.dup, null, e)
.Add(OpCodes.iconst_0, null, e)
.AddIntConst(bits[0], e)
.Add(OpCodes.iastore, null, e)
.Add(OpCodes.dup, null, e)
.Add(OpCodes.iconst_1, null, e)
.AddIntConst(bits[1], e)
.Add(OpCodes.iastore, null, e)
.Add(OpCodes.dup, null, e)
.Add(OpCodes.iconst_2, null, e)
.AddIntConst(bits[2], e)
.Add(OpCodes.iastore, null, e)
.Add(OpCodes.dup, null, e)
.Add(OpCodes.iconst_3, null, e)
.AddIntConst(bits[3], e)
.Add(OpCodes.iastore, null, e)
.Add(OpCodes.invokespecial, ClassNames.SystemDecimal.FromBitsCtorRef, e);
}
private void CompileLdcR4(ILExpression e, ExpectType expect)
{
float operand = (float)e.Operand;
if (operand == 0.0f)
{
codeGenerator.AddInstruction(new JavaInstruction(Java.OpCodes.fconst_0, null, e));
}
else if (operand == 1.0f)
{
codeGenerator.AddInstruction(new JavaInstruction(Java.OpCodes.fconst_1, null, e));
}
else if (operand == 2.0f)
{
codeGenerator.AddInstruction(new JavaInstruction(Java.OpCodes.fconst_2, null, e));
}
else
{
//TODO: From Java Virtual Machine Specification:
//The ldc instruction can only be used to push a value of type float taken from the float value set (§2.3.2)
//because a constant of type float in the constant pool (§4.4.4) must be taken from the float value set.
//What this means, and check this (may be NaN and Inf?)
codeGenerator.AddInstruction(new JavaInstruction(Java.OpCodes.ldc, new Java.Constants.Float(operand), e));
}
TranslateType(InterType.PrimitiveTypes[(int)PrimitiveType.Single], expect, e);
}
private void CompileLogicNot(ILExpression e, ExpectType expect)
{
CompileExpression(e.Arguments[0], ExpectType.Primitive);
// push exp
// ifeq zero
// iconst_0
// goto exit
//zero:
// iconst_1
//exit
string labelSufixes = rnd.Next().ToString();
string zeroLabel = "zero" + labelSufixes;
string exitLabel = "exit" + labelSufixes;
Java.OpCodes branch = Java.OpCodes.ifeq;
TranslateToBool(e.Arguments[0].InferredType, ref branch, e);
codeGenerator
.Add(branch, zeroLabel, e)
.Add(Java.OpCodes.iconst_0, null, e)
.Add(Java.OpCodes._goto, exitLabel, e)
.Label(zeroLabel)
.Add(Java.OpCodes.iconst_1)
.Label(exitLabel);
}
private void CompileStfld(ILExpression e, ExpectType expectType)
{
InterField operand = resolver.Resolve((FieldReference)e.Operand, thisMethod.FullGenericArguments);
bool needDup = ((e.ExpectedType != null) && (expectType != ExpectType.None));
bool boxed = operand.IsStatic && operand.IsThreadLocal;
int argIndex = 0;
if (e.Code == ILCode.Stfld)
CompileExpression(e.Arguments[argIndex++], ExpectType.Reference);
CompileExpression(e.Arguments[argIndex++], boxed ? ExpectType.Boxed : GetExpectType(operand));
if (needDup)
{
JavaPrimitiveType jp = JavaHelpers.InterTypeToJavaPrimitive(operand.FieldType);
if (e.Code == ILCode.Stfld)
{
if (jp.IsDoubleSlot())
codeGenerator.Add(Java.OpCodes.dup2_x1, null, e);
else
codeGenerator.Add(Java.OpCodes.dup_x1, null, e);
}
else
{
if (jp.IsDoubleSlot())
codeGenerator.Add(Java.OpCodes.dup2, null, e);
else
codeGenerator.Add(Java.OpCodes.dup, null, e);
}
}
CompileFieldStore(operand, e);
}
private void CompileStobj(ILExpression e, ExpectType expect)
{
InterType operand = resolver.Resolve((TypeReference)e.Operand, thisMethod.FullGenericArguments);
if (operand.IsValueType)
{
// stobj(destPtr, src) compiling to
// src.CopyTo(destPtr)
CompileExpression(e.Arguments[1], ExpectType.Any);
CompileExpression(e.Arguments[0], ExpectType.ByRef);
MethodRef copyToRef = new MethodRef(namesController.TypeNameToJava(operand),
ClassNames.ValueTypeCopyTo, "(" + namesController.GetFieldDescriptor(operand) + ")V");
bool needDup = ((e.ExpectedType != null) && (expect != ExpectType.None));
if (needDup)
{
codeGenerator.Add(Java.OpCodes.dup_x1, null, e);
}
codeGenerator.Add(Java.OpCodes.invokevirtual, copyToRef, e);
}
else
{
// From ECMA-335, III.4.29
// The stobj instruction copies the value src to the address dest. If typeTok is not
// a generic parameter and either a reference type or a built-in value class, then
// the stind instruction provides a shorthand for the stobj instruction.
CompileStind(e, expect);
}
}
private void CompileIsinst(ILExpression e, ExpectType expect)
{
InterType operand = resolver.Resolve((TypeReference)e.Operand, thisMethod.FullGenericArguments);
CompileExpression(e.Arguments[0], ExpectType.Reference);
// dup
// instanceof operand
// ifne :end
// pop
// aconst_null
//:end
// checkcast operand
string endLabel = rnd.Next().ToString() + "end";
Java.Constants.Class operandRef = new Java.Constants.Class(namesController.TypeNameToJava(GetBoxType(operand)));
codeGenerator
.Add(Java.OpCodes.dup, null, e)
.Add(Java.OpCodes.instanceof, operandRef, e)
.Add(Java.OpCodes.ifne, endLabel, e)
.Add(Java.OpCodes.pop, null, e)
.Add(Java.OpCodes.aconst_null, null, e)
.Label(endLabel)
.Add(Java.OpCodes.checkcast, operandRef, e);
}
private void CompileLdstr(ILExpression e, ExpectType expect)
{
string operand = (string)e.Operand;
codeGenerator.AddInstruction(new JavaInstruction(Java.OpCodes.ldc, new Java.Constants.String(operand), e));
TranslateType(resolver.Resolve(e.ExpectedType, thisMethod.FullGenericArguments), expect, e);
}
private void CompileCastclass(ILExpression e, ExpectType expect)
{
InterType operand = resolver.Resolve((TypeReference)e.Operand, thisMethod.FullGenericArguments);
CompileExpression(e.Arguments[0], expect);
codeGenerator.Add(Java.OpCodes.checkcast, new Java.Constants.Class(namesController.TypeNameToJava(operand)), e);
}
private void CompileLdcI8(ILExpression e, ExpectType expect)
{
long operand = (long)e.Operand;
codeGenerator.AddLongConst(operand, e);
TranslateType(InterType.PrimitiveTypes[(int)PrimitiveType.Int32], expect, e);
}
private void CompileArglist(ILExpression e, ExpectType expect)
{
codeGenerator
.Add(OpCodes._new, new Java.Constants.Class(namesController.TypeNameToJava(ClassNames.SystemRuntimeArgumentHandle.ClassName)), e)
.Add(OpCodes.dup, null, e)
.AddLoad(JavaPrimitiveType.Ref, var2Index.Where(K => K.Key.Name == ClassNames.VarArgParamName).FirstOrDefault().Value, e)
.Add(OpCodes.invokespecial, ClassNames.SystemRuntimeArgumentHandle.CtorMethodRef);
}
private void CompileValueOf(ILExpression e, ExpectType expect)
{
InterType returnType = resolver.Resolve(e.InferredType, thisMethod.FullGenericArguments);
InterType nullableType = resolver.Resolve(e.Arguments[0].InferredType, thisMethod.FullGenericArguments);
CompileExpression(e.Arguments[0], ExpectType.ByRef);
codeGenerator.Add(OpCodes.invokevirtual, new MethodRef(namesController.TypeNameToJava(nullableType),
ClassNames.SystemNullable_1.GetValueOrDefaultMethodName, "()" + namesController.GetFieldDescriptor(returnType)));
}
private void CompileAddressOf(ILExpression e, ExpectType expectType)
{
e = e.Arguments[0];
if (e.Operand is TypeReference)
{
//ValueType
CompileExpression(e, expectType);
return;
}
else if (!(e.Operand is MethodReference))
{
CompileExpression(e, ExpectType.Boxed);
return;
}
InterMethod method = resolver.Resolve((MethodReference)e.Operand, thisMethod.FullGenericArguments);
InterType operand = method.DeclaringType;
if (!operand.IsArray)
{
//Getter
if (method.ReturnParameter.Type.IsPrimitive)
{
CompileExpression(e, ExpectType.Boxed);
}
else
{
CompileExpression(e, GetExpectType(method.ReturnParameter));
}
return;
}
JavaArrayType arrType = JavaHelpers.InterTypeToJavaArrayType(operand);
string arrayByRefName = byRefController.GetArrayByRefTypeName(operand);
Java.Constants.Class arrayByRefNameClass =
new Java.Constants.Class(namesController.TypeNameToJava(arrayByRefName));
Java.Constants.MethodRef arrayByRefInitMethodRef =
byRefController.GetArrayByRefCtorMethodRef(operand);
codeGenerator
.Add(OpCodes._new, arrayByRefNameClass, e)
.Add(OpCodes.dup, null, e);
CompileExpression(e.Arguments[0], ExpectType.Reference); //array
CompileExpression(e.Arguments[1], ExpectType.Primitive); //first index
for (int i = 0; i < operand.ArrayRank - 1; i++)
{
codeGenerator.Add(Java.OpCodes.aaload, null, e);
CompileExpression(e.Arguments[i + 2], ExpectType.Primitive);
}
codeGenerator.Add(OpCodes.invokespecial, arrayByRefInitMethodRef, e);
}
private void CompileLdloca(ILExpression e, ExpectType expectType)
{
ILVariable operand = (ILVariable)e.Operand;
int varIndex = GetVarIndex(operand);
InterType operandType = resolver.Resolve(operand.Type, thisMethod.FullGenericArguments);
if (operandType.IsValueType)
{
codeGenerator.AddLoad(JavaPrimitiveType.Ref, varIndex);
return;
}
if ((operandType.IsPrimitive) && (expectType == ExpectType.Reference))
{
codeGenerator.AddLoad(JavaHelpers.InterTypeToJavaPrimitive(operandType), varIndex, e);
TranslateType(operandType, ExpectType.Boxed, e);
return;
}
string localByRefName = byRefController.GetLocalByRefTypeName(operandType);
Java.Constants.Class localByRefNameClass =
new Java.Constants.Class(namesController.TypeNameToJava(localByRefName));
Java.Constants.MethodRef localByRefInitMethodRef =
byRefController.GetLocalByRefCtorMethodRef(operandType);
Java.Constants.MethodRef getValueMethodRef =
byRefController.GetByRefGetValueMethodRef(JavaHelpers.InterTypeToJavaPrimitive(operandType));
int localRefTempVar = GetNextFreeVar(JavaPrimitiveType.Ref);
codeGenerator
.Add(OpCodes._new, localByRefNameClass, e)
.Add(OpCodes.dup, null, e)
.AddLocalVarInstruction(LocalVarInstruction.Load, JavaHelpers.InterTypeToJavaPrimitive(operandType), varIndex, e)
.Add(OpCodes.invokespecial, localByRefInitMethodRef, e)
.Add(OpCodes.dup, null, e)
.AddLocalVarInstruction(LocalVarInstruction.Store, JavaPrimitiveType.Ref, localRefTempVar, e);
RegisterLocalByRef(() =>
{
codeGenerator
.AddLocalVarInstruction(LocalVarInstruction.Load, JavaPrimitiveType.Ref, localRefTempVar, e)
.Add(OpCodes.invokevirtual, getValueMethodRef, e);
if ((!operandType.IsPrimitive) && (!operandType.IsEnum))
{
codeGenerator.Add(OpCodes.checkcast,
new Java.Constants.Class(namesController.TypeNameToJava(operandType)), e);
}
codeGenerator.AddLocalVarInstruction(LocalVarInstruction.Store, JavaHelpers.InterTypeToJavaPrimitive(operandType), varIndex, e);
FreeVar(localRefTempVar, JavaPrimitiveType.Ref);
});
//TODO: TranslateType if neeeded
}
private void CompilePostIncrement(ILExpression e, ExpectType expect)
{
int incVal = (int)e.Operand;
e = e.Arguments[0];
//TODO: PostIncrement for long and other types
if (e.Code == ILCode.Ldloca)
{
int varIndex = GetVarIndex((ILVariable)e.Operand);
codeGenerator
.AddLoad(JavaPrimitiveType.Int, varIndex, e)
.Add(OpCodes.dup, null, e)
.AddIntConst(incVal, e)
.Add(OpCodes.iadd, null, e)
.AddStore(JavaPrimitiveType.Int, varIndex, e);
}
else if (e.Code == ILCode.Ldsflda)
{
InterField operand = resolver.Resolve((FieldReference)e.Operand, thisMethod.FullGenericArguments);
CompileFieldLoad(operand, e);
codeGenerator
.Add(OpCodes.dup, null, e)
.AddIntConst(incVal, e)
.Add(OpCodes.iadd, null, e);
CompileFieldStore(operand, e);
}
else if (e.Code == ILCode.Ldflda)
{
InterField operand = resolver.Resolve((FieldReference)e.Operand, thisMethod.FullGenericArguments);
int tmpVar = GetNextFreeVar(JavaPrimitiveType.Int);
CompileExpression(e.Arguments[0], ExpectType.Reference); //this
codeGenerator.Add(OpCodes.dup, null, e);
CompileFieldLoad(operand, e);
codeGenerator
.Add(OpCodes.dup, null, e)
.AddStore(JavaPrimitiveType.Int, tmpVar, e)
.AddIntConst(incVal, e)
.Add(OpCodes.iadd, null, e);
CompileFieldStore(operand, e);
codeGenerator
.AddLoad(JavaPrimitiveType.Int, tmpVar, e);
FreeVar(tmpVar, JavaPrimitiveType.Int);
}
else
{
throw new Exception(); //TODO: another supported postincrements.
}
// See ICSharpCode.Decompiler\ILAst\PeepholeTransform.cs:IntroducePostIncrement
}
private void CompileConvTo8(ILExpression e, ExpectType expect)
{
InterType gettedType = resolver.Resolve(e.Arguments[0].InferredType, thisMethod.FullGenericArguments);
JavaPrimitiveType gettedJava = JavaHelpers.InterTypeToJavaPrimitive(gettedType);
CompileExpression(e.Arguments[0], ExpectType.Any);
bool isToUnsigned = e.Code.IsConvToUnsigned();
bool isFromUnsigned = e.Code.IsConvFromUnsigned();
bool isOvf = e.Code.IsOvf();
if (isOvf)
{
long mask = unchecked ((long)0xffffffffffffffffL);
double minValue = (double)long.MinValue;
double maxValue = (double)long.MaxValue;
if (isToUnsigned)
{
minValue = (double)ulong.MinValue;
maxValue = (double)ulong.MaxValue;
}
if ((isToUnsigned && !isFromUnsigned) || (!isToUnsigned && isFromUnsigned))
{
mask = 0x7fffffffffffffffL;
}
CompileCheckOvf(e, gettedJava, mask, minValue, maxValue);
}
switch (gettedJava)
{
case JavaPrimitiveType.Bool:
case JavaPrimitiveType.Byte:
case JavaPrimitiveType.Char:
case JavaPrimitiveType.Short:
case JavaPrimitiveType.Int:
codeGenerator.Add(OpCodes.i2l, null, e);
break;
case JavaPrimitiveType.Long:
break;
case JavaPrimitiveType.Float:
codeGenerator.Add(OpCodes.f2l, null, e);
break;
case JavaPrimitiveType.Double:
codeGenerator.Add(OpCodes.d2l, null, e);
break;
default: throw new Exception(); //TODO: Normal error
}
TranslateType(InterType.PrimitiveTypes[(int)(isToUnsigned ? PrimitiveType.UInt64 : PrimitiveType.Int64)], expect, e);
}
private void CompileInitblk(ILExpression e, ExpectType expect)
{
Messages.Message(MessageCode.UnsafeInstruction, e.Code.ToString());
CompileExpression(e.Arguments[0], ExpectType.Reference);
CompileExpression(e.Arguments[1], ExpectType.Primitive);
CompileExpression(e.Arguments[2], ExpectType.Primitive);
codeGenerator.Add(OpCodes.invokestatic, ClassNames.CIL2JavaVESInstructions.InitblkRef, e);
}
private void CompileStelem(ILExpression e, ExpectType expect)
{
TypeReference typeRef = e.Operand as TypeReference ?? e.InferredType;
InterType operand = null;
if (typeRef != null)
{
operand = resolver.Resolve(typeRef, thisMethod.FullGenericArguments);
}
else
{
switch (e.Code)
{
case ILCode.Stelem_I: operand = InterType.PrimitiveTypes[(int)(Program.AsX64 ? PrimitiveType.Int64 : PrimitiveType.Int32)]; break;
case ILCode.Stelem_I1: operand = InterType.PrimitiveTypes[(int)PrimitiveType.SByte]; break;
case ILCode.Stelem_I2: operand = InterType.PrimitiveTypes[(int)PrimitiveType.Int16]; break;
case ILCode.Stelem_I4: operand = InterType.PrimitiveTypes[(int)PrimitiveType.Int32]; break;
case ILCode.Stelem_I8: operand = InterType.PrimitiveTypes[(int)PrimitiveType.Int64]; break;
case ILCode.Stelem_R4: operand = InterType.PrimitiveTypes[(int)PrimitiveType.Single]; break;
case ILCode.Stelem_R8: operand = InterType.PrimitiveTypes[(int)PrimitiveType.Double]; break;
}
}
JavaPrimitiveType valueJPType = operand != null?JavaHelpers.InterTypeToJavaPrimitive(operand) : JavaPrimitiveType.Ref;
JavaArrayType arrType = JavaHelpers.JavaPrimitiveToArrayType(valueJPType);
ExpectType valueExpectType = operand != null?GetExpectType(operand) : ExpectType.Reference;
bool needDup = ((e.ExpectedType != null) && (expect != ExpectType.None));
CompileExpression(e.Arguments[0], ExpectType.Reference); //array
CompileExpression(e.Arguments[1], ExpectType.Primitive); //index
CompileExpression(e.Arguments[2], valueExpectType); //value
if (needDup)
{
if (valueJPType.IsDoubleSlot())
{
codeGenerator.Add(Java.OpCodes.dup2_x2, null, e);
}
else
{
codeGenerator.Add(Java.OpCodes.dup_x2, null, e);
}
}
codeGenerator.AddArrayStore(arrType, e);
}
private void CompileInitializedObject(ILExpression e, ExpectType expect)
{
if (initializedObjectsVarIndexes.Count == 0)
{
Messages.Message(MessageCode.NoInitializedObject);
}
else
{
codeGenerator.AddLoad(JavaPrimitiveType.Ref, initializedObjectsVarIndexes.Peek(), e);
}
}
private void CompileConvToNative(ILExpression e, ExpectType expect)
{
if (Program.AsX64)
{
CompileConvTo8(e, expect);
}
else
{
CompileConvTo4(e, expect);
}
}
private void CompileTernaryOp(ILExpression e, ExpectType expect)
{
ILCondition conditionNode = new ILCondition();
conditionNode.Condition = e.Arguments[0];
conditionNode.TrueBlock = new ILBlock(e.Arguments[1]);
conditionNode.FalseBlock = new ILBlock(e.Arguments[2]);
CompileCondition(conditionNode, expect);
TranslateType(resolver.Resolve(e.InferredType, thisMethod.FullGenericArguments), expect, e);
}
private void CompileLoopContinue(ILExpression e, ExpectType expect)
{
if (loopContinueLabel.Count == 0)
{
Messages.Message(MessageCode.LoopOpcodeFoundedOutsideLoop, e.Code.ToString());
}
else
{
codeGenerator.Add(OpCodes._goto, loopContinueLabel.Peek(), e);
}
}
private ExpectValueHandler(Browser browser, ExpectType expectType)
{
_browser = browser;
_expectType = expectType;
}
/// <summary>
/// Prevents a default instance of the <see cref="Text"/> class from being created.
/// </summary>
/// <param name="provider">The provider.</param>
/// <param name="manager">The manager.</param>
/// <param name="expectType">Type of the expect.</param>
private Text(AutomationProvider provider, CommandManager manager, ExpectType expectType)
: base(provider, manager)
{
_expectType = expectType;
}
