|
public static ToInt32 ( |
||
| generator | The IL generator. | |
| fromType | PrimitiveType | The type to convert from. |
| 리턴 | void | |
/// <summary>
/// Generates CIL for the expression.
/// </summary>
/// <param name="generator"> The generator to output the CIL to. </param>
/// <param name="optimizationInfo"> Information about any optimizations that should be performed. </param>
public override void GenerateCode(ILGenerator generator, OptimizationInfo optimizationInfo)
{
// Special-case the delete operator.
if (this.OperatorType == OperatorType.Delete)
{
GenerateDelete(generator, optimizationInfo);
return;
}
// If a return value is not expected, generate only the side-effects.
/*if (optimizationInfo.SuppressReturnValue == true)
* {
* this.GenerateSideEffects(generator, optimizationInfo);
* return;
* }*/
// Special-case the typeof operator.
if (this.OperatorType == OperatorType.Typeof)
{
GenerateTypeof(generator, optimizationInfo);
return;
}
// Load the operand onto the stack.
this.Operand.GenerateCode(generator, optimizationInfo);
// Convert the operand to the correct type.
switch (this.OperatorType)
{
case OperatorType.Plus:
case OperatorType.Minus:
EmitConversion.ToNumber(generator, this.Operand.ResultType);
break;
case OperatorType.BitwiseNot:
EmitConversion.ToInt32(generator, this.Operand.ResultType);
break;
case OperatorType.LogicalNot:
EmitConversion.ToBool(generator, this.Operand.ResultType);
break;
}
// Apply the operator.
switch (this.OperatorType)
{
case OperatorType.Plus:
break;
case OperatorType.Minus:
generator.Negate();
break;
case OperatorType.BitwiseNot:
generator.BitwiseNot();
break;
case OperatorType.LogicalNot:
generator.LoadBoolean(false);
generator.CompareEqual();
break;
case OperatorType.Void:
generator.Pop();
EmitHelpers.EmitUndefined(generator);
break;
default:
throw new NotImplementedException(string.Format("Unsupported operator {0}", this.OperatorType));
}
}
/// <summary>
/// Generates CIL for the expression.
/// </summary>
/// <param name="generator"> The generator to output the CIL to. </param>
/// <param name="optimizationInfo"> Information about any optimizations that should be performed. </param>
public override void GenerateCode(ILGenerator generator, OptimizationInfo optimizationInfo)
{
// If a return value is not expected, generate only the side-effects.
/*if (optimizationInfo.SuppressReturnValue == true)
* {
* this.GenerateSideEffects(generator, optimizationInfo);
* return;
* }*/
// Special case the addition operator.
if (this.OperatorType == OperatorType.Add)
{
GenerateAdd(generator, optimizationInfo);
return;
}
// Special case the instanceof operator.
if (this.OperatorType == OperatorType.InstanceOf)
{
GenerateInstanceOf(generator, optimizationInfo);
return;
}
// Special case the in operator.
if (this.OperatorType == OperatorType.In)
{
GenerateIn(generator, optimizationInfo);
return;
}
// Special case the relational operators.
if (this.OperatorType == OperatorType.LessThan ||
this.OperatorType == OperatorType.LessThanOrEqual ||
this.OperatorType == OperatorType.GreaterThan ||
this.OperatorType == OperatorType.GreaterThanOrEqual)
{
GenerateRelational(generator, optimizationInfo);
return;
}
// Special case the logical operators.
if (this.OperatorType == OperatorType.LogicalAnd ||
this.OperatorType == OperatorType.LogicalOr)
{
GenerateLogical(generator, optimizationInfo);
return;
}
// Load the left hand side onto the stack.
this.Left.GenerateCode(generator, optimizationInfo);
// Convert the left argument.
switch (this.OperatorType)
{
// Arithmetic operations.
case OperatorType.Subtract:
case OperatorType.Multiply:
case OperatorType.Divide:
case OperatorType.Modulo:
case OperatorType.Exponentiation:
EmitConversion.ToNumber(generator, this.Left.ResultType);
break;
// Bitwise operations.
case OperatorType.BitwiseAnd:
case OperatorType.BitwiseOr:
case OperatorType.BitwiseXor:
case OperatorType.LeftShift:
case OperatorType.SignedRightShift:
case OperatorType.UnsignedRightShift:
EmitConversion.ToInt32(generator, this.Left.ResultType);
break;
// Equality operations.
case OperatorType.Equal:
case OperatorType.StrictlyEqual:
case OperatorType.NotEqual:
case OperatorType.StrictlyNotEqual:
EmitConversion.ToAny(generator, this.Left.ResultType);
break;
}
// Load the right hand side onto the stack.
this.Right.GenerateCode(generator, optimizationInfo);
// Convert the right argument.
switch (this.OperatorType)
{
// Arithmetic operations.
case OperatorType.Subtract:
case OperatorType.Multiply:
case OperatorType.Divide:
case OperatorType.Modulo:
case OperatorType.Exponentiation:
EmitConversion.ToNumber(generator, this.Right.ResultType);
break;
// Bitwise operations.
case OperatorType.BitwiseAnd:
case OperatorType.BitwiseOr:
case OperatorType.BitwiseXor:
EmitConversion.ToInt32(generator, this.Right.ResultType);
break;
case OperatorType.LeftShift:
case OperatorType.SignedRightShift:
case OperatorType.UnsignedRightShift:
EmitConversion.ToUInt32(generator, this.Right.ResultType);
generator.LoadInt32(0x1F);
generator.BitwiseAnd();
break;
// Equality operations.
case OperatorType.Equal:
case OperatorType.StrictlyEqual:
case OperatorType.NotEqual:
case OperatorType.StrictlyNotEqual:
EmitConversion.ToAny(generator, this.Right.ResultType);
break;
}
// Apply the operator.
switch (this.OperatorType)
{
// Arithmetic operations.
case OperatorType.Subtract:
generator.Subtract();
break;
case OperatorType.Multiply:
generator.Multiply();
break;
case OperatorType.Divide:
generator.Divide();
break;
case OperatorType.Modulo:
generator.Remainder();
break;
case OperatorType.Exponentiation:
generator.CallStatic(ReflectionHelpers.Math_Pow);
break;
// Bitwise operations.
case OperatorType.BitwiseAnd:
generator.BitwiseAnd();
break;
case OperatorType.BitwiseOr:
generator.BitwiseOr();
break;
case OperatorType.BitwiseXor:
generator.BitwiseXor();
break;
// Shift operations.
case OperatorType.LeftShift:
generator.ShiftLeft();
break;
case OperatorType.SignedRightShift:
generator.ShiftRight();
break;
case OperatorType.UnsignedRightShift:
generator.ShiftRightUnsigned();
EmitConversion.ToNumber(generator, PrimitiveType.UInt32);
break;
// Equality operations.
case OperatorType.Equal:
generator.Call(ReflectionHelpers.TypeComparer_Equals);
break;
case OperatorType.StrictlyEqual:
generator.Call(ReflectionHelpers.TypeComparer_StrictEquals);
break;
case OperatorType.NotEqual:
generator.Call(ReflectionHelpers.TypeComparer_Equals);
generator.LoadBoolean(false);
generator.CompareEqual();
break;
case OperatorType.StrictlyNotEqual:
generator.Call(ReflectionHelpers.TypeComparer_StrictEquals);
generator.LoadBoolean(false);
generator.CompareEqual();
break;
default:
throw new NotImplementedException(string.Format("Unsupported operator {0}", this.OperatorType));
}
}
/// <summary>
/// Pops the value on the stack, converts it from an object to the given type, then pushes
/// the result onto the stack.
/// </summary>
/// <param name="generator"> The IL generator. </param>
/// <param name="toType"> The type to convert to. </param>
/// <param name="convertToAddress"> <c>true</c> if the value is intended for use as an
/// instance pointer; <c>false</c> otherwise. </param>
internal static void EmitConversionToType(ILGenerator generator, Type toType, bool convertToAddress)
{
// Convert Null.Value to null if the target type is a reference type.
ILLabel endOfNullCheck = null;
if (toType.IsValueType == false)
{
var startOfElse = generator.CreateLabel();
endOfNullCheck = generator.CreateLabel();
generator.Duplicate();
EmitHelpers.EmitNull(generator);
generator.BranchIfNotEqual(startOfElse);
generator.Pop();
generator.LoadNull();
generator.Branch(endOfNullCheck);
generator.DefineLabelPosition(startOfElse);
}
switch (Type.GetTypeCode(toType))
{
case TypeCode.Boolean:
EmitConversion.ToBool(generator, PrimitiveType.Any);
break;
case TypeCode.Byte:
EmitConversion.ToInt32(generator, PrimitiveType.Any);
break;
case TypeCode.Char:
EmitConversion.ToString(generator, PrimitiveType.Any);
generator.Duplicate();
generator.Call(ReflectionHelpers.String_Length);
generator.LoadInt32(1);
var endOfCharCheck = generator.CreateLabel();
generator.BranchIfEqual(endOfCharCheck);
EmitHelpers.EmitThrow(generator, ErrorType.TypeError, "Cannot convert string to char - the string must be exactly one character long");
generator.DefineLabelPosition(endOfCharCheck);
generator.LoadInt32(0);
generator.Call(ReflectionHelpers.String_GetChars);
break;
case TypeCode.DBNull:
throw new NotSupportedException("DBNull is not a supported parameter type.");
case TypeCode.Decimal:
EmitConversion.ToNumber(generator, PrimitiveType.Any);
generator.NewObject(ReflectionHelpers.Decimal_Constructor_Double);
break;
case TypeCode.Double:
EmitConversion.ToNumber(generator, PrimitiveType.Any);
break;
case TypeCode.Empty:
throw new NotSupportedException("Empty is not a supported return type.");
case TypeCode.Int16:
EmitConversion.ToInt32(generator, PrimitiveType.Any);
break;
case TypeCode.Int32:
EmitConversion.ToInt32(generator, PrimitiveType.Any);
break;
case TypeCode.Int64:
EmitConversion.ToNumber(generator, PrimitiveType.Any);
generator.ConvertToInt64();
break;
case TypeCode.DateTime:
case TypeCode.Object:
// Check if the type must be unwrapped.
generator.Duplicate();
generator.IsInstance(typeof(Jurassic.Library.ClrInstanceWrapper));
var endOfUnwrapCheck = generator.CreateLabel();
generator.BranchIfFalse(endOfUnwrapCheck);
// Unwrap the wrapped instance.
generator.Call(ReflectionHelpers.ClrInstanceWrapper_GetWrappedInstance);
generator.DefineLabelPosition(endOfUnwrapCheck);
// Value types must be unboxed.
if (toType.IsValueType == true)
{
if (convertToAddress == true)
{
// Unbox.
generator.Unbox(toType);
}
else
{
// Unbox and copy to the stack.
generator.UnboxAny(toType);
}
//// Calling methods on value required the address of the value type, not the value type itself.
//if (argument.Source == BinderArgumentSource.ThisValue && argument.Type.IsValueType == true)
//{
// var temp = generator.CreateTemporaryVariable(argument.Type);
// generator.StoreVariable(temp);
// generator.LoadAddressOfVariable(temp);
// generator.ReleaseTemporaryVariable(temp);
//}
}
break;
case TypeCode.SByte:
EmitConversion.ToInt32(generator, PrimitiveType.Any);
break;
case TypeCode.Single:
EmitConversion.ToNumber(generator, PrimitiveType.Any);
break;
case TypeCode.String:
EmitConversion.ToString(generator, PrimitiveType.Any);
break;
case TypeCode.UInt16:
EmitConversion.ToInt32(generator, PrimitiveType.Any);
break;
case TypeCode.UInt32:
EmitConversion.ToUInt32(generator, PrimitiveType.Any);
break;
case TypeCode.UInt64:
EmitConversion.ToNumber(generator, PrimitiveType.Any);
generator.ConvertToUnsignedInt64();
break;
}
// Label the end of the null check.
if (toType.IsValueType == false)
{
generator.DefineLabelPosition(endOfNullCheck);
}
}
