/// <summary>
/// Generates CIL for the statement.
/// </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)
{
// Generate code for the start of the statement.
var statementLocals = new StatementLocals();
GenerateStartOfStatement(generator, optimizationInfo, statementLocals);
if (this.ContributesToEvalResult && optimizationInfo.EvalResult != null)
{
// Emit the expression.
this.Expression.GenerateCode(generator, optimizationInfo);
// Store the result.
EmitConversion.ToAny(generator, this.Expression.ResultType);
generator.StoreVariable(optimizationInfo.EvalResult);
}
else
{
// Emit the expression.
this.Expression.GenerateCode(generator, optimizationInfo);
generator.Pop();
}
// Generate code for the end of the statement.
GenerateEndOfStatement(generator, optimizationInfo, statementLocals);
}
/// <summary>
/// Generates CIL for the typeof 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>
private void GenerateTypeof(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;
* }*/
var nameExperssionOperand = this.Operand as NameExpression;
if (nameExperssionOperand != null)
{
// Unresolvable references must return "undefined" rather than throw an error.
nameExperssionOperand.GenerateGet(generator, optimizationInfo, false);
}
else
{
// Emit code for resolving the value of the operand.
this.Operand.GenerateCode(generator, optimizationInfo);
}
// Convert to System.Object.
EmitConversion.ToAny(generator, this.Operand.ResultType);
// Call TypeUtilities.TypeOf(operand).
generator.Call(ReflectionHelpers.TypeUtilities_TypeOf.Value);
}
/// <summary>
/// Generates CIL for the logical operators.
/// </summary>
/// <param name="generator"> The generator to output the CIL to. </param>
/// <param name="optimizationInfo"> Information about any optimizations that should be performed. </param>
private void GenerateLogical(ILGenerator generator, OptimizationInfo optimizationInfo)
{
// Get the statically-determined types of the left and right operands.
PrimitiveType leftType = this.Left.ResultType;
PrimitiveType rightType = this.Right.ResultType;
// Load the left-hand side operand.
this.Left.GenerateCode(generator, optimizationInfo);
// Make sure the output type is consistant.
if (leftType != rightType)
{
if (PrimitiveTypeUtilities.IsNumeric(leftType) && PrimitiveTypeUtilities.IsNumeric(rightType))
{
EmitConversion.ToNumber(generator, leftType);
leftType = PrimitiveType.Number;
}
else
{
EmitConversion.ToAny(generator, leftType);
leftType = PrimitiveType.Any;
}
}
// Duplicate and convert to a Boolean.
generator.Duplicate();
EmitConversion.ToBool(generator, leftType);
// Stack contains "left, (bool)left"
var endOfIf = generator.CreateLabel();
if (this.OperatorType == OperatorType.LogicalAnd)
{
generator.BranchIfFalse(endOfIf);
}
else
{
generator.BranchIfTrue(endOfIf);
}
// Stack contains "left". Load the right-hand side operand.
generator.Pop();
this.Right.GenerateCode(generator, optimizationInfo);
// Make sure the output type is consistant.
if (leftType != rightType)
{
if (PrimitiveTypeUtilities.IsNumeric(leftType) && PrimitiveTypeUtilities.IsNumeric(rightType))
{
EmitConversion.ToNumber(generator, rightType);
}
else
{
EmitConversion.ToAny(generator, rightType);
}
}
// Define the label used above.
generator.DefineLabelPosition(endOfIf);
}
/// <summary>
/// Pops the value on the stack, converts it from one type to another, then pushes the
/// result onto the stack.
/// </summary>
/// <param name="il"> The IL generator. </param>
/// <param name="fromType"> The type to convert from. </param>
/// <param name="toType"> The type to convert to. </param>
private static void EmitTypeConversion(ILGenerator il, Type fromType, Type toType)
{
// If the source type equals the destination type, then there is nothing to do.
if (fromType == toType)
{
return;
}
// Emit for each type of argument we support.
if (toType == typeof(int))
{
EmitConversion.ToInteger(il, PrimitiveTypeUtilities.ToPrimitiveType(fromType));
}
else if (typeof(ObjectInstance).IsAssignableFrom(toType))
{
EmitConversion.Convert(il, PrimitiveTypeUtilities.ToPrimitiveType(fromType), PrimitiveType.Object);
if (toType != typeof(ObjectInstance))
{
// Convert to null if the from type isn't compatible with the to type.
// For example, if the target type is FunctionInstance and the from type is ArrayInstance, then pass null.
il.IsInstance(toType);
}
}
else
{
EmitConversion.Convert(il, PrimitiveTypeUtilities.ToPrimitiveType(fromType), PrimitiveTypeUtilities.ToPrimitiveType(toType));
}
}
/// <summary>
/// Generates CIL for the in operator.
/// </summary>
/// <param name="generator"> The generator to output the CIL to. </param>
/// <param name="optimizationInfo"> Information about any optimizations that should be performed. </param>
private void GenerateIn(ILGenerator generator, OptimizationInfo optimizationInfo)
{
// Emit the left-hand side expression and convert it to a string.
this.Left.GenerateCode(generator, optimizationInfo);
EmitConversion.ToString(generator, this.Left.ResultType);
// Store the left-hand side expression in a temporary variable.
var temp = generator.CreateTemporaryVariable(typeof(string));
generator.StoreVariable(temp);
// Emit the right-hand side expression.
this.Right.GenerateCode(generator, optimizationInfo);
EmitConversion.ToAny(generator, this.Right.ResultType);
// Check the right-hand side is a javascript object - if not, throw an exception.
generator.IsInstance(typeof(Library.ObjectInstance));
generator.Duplicate();
var endOfTypeCheck = generator.CreateLabel();
generator.BranchIfNotNull(endOfTypeCheck);
// Throw an nicely formatted exception.
var rightValue = generator.CreateTemporaryVariable(typeof(object));
generator.StoreVariable(rightValue);
EmitHelpers.LoadScriptEngine(generator);
generator.LoadString("TypeError");
generator.LoadString("The in operator expected an object, but found '{0}' instead");
generator.LoadInt32(1);
generator.NewArray(typeof(object));
generator.Duplicate();
generator.LoadInt32(0);
generator.LoadVariable(rightValue);
generator.Call(ReflectionHelpers.TypeUtilities_TypeOf.Value);
generator.StoreArrayElement(typeof(object));
generator.Call(ReflectionHelpers.String_Format.Value);
generator.LoadInt32(optimizationInfo.SourceSpan.StartLine);
generator.LoadStringOrNull(optimizationInfo.Source.Path);
generator.LoadStringOrNull(optimizationInfo.FunctionName);
generator.NewObject(ReflectionHelpers.JavaScriptException_Constructor_Error.Value);
generator.Throw();
generator.DefineLabelPosition(endOfTypeCheck);
generator.ReleaseTemporaryVariable(rightValue);
// Load the left-hand side expression from the temporary variable.
generator.LoadVariable(temp);
// Call ObjectInstance.HasProperty(object)
generator.Call(ReflectionHelpers.ObjectInstance_HasProperty.Value);
// Allow the temporary variable to be reused.
generator.ReleaseTemporaryVariable(temp);
}
/// <summary>
/// Generates code that initializes the variable and function declarations.
/// </summary>
/// <param name="generator"> The generator to output the CIL to. </param>
/// <param name="optimizationInfo"> Information about any optimizations that should be performed. </param>
internal virtual void GenerateDeclarations(ILGenerator generator, OptimizationInfo optimizationInfo)
{
// Initialize the declared variables and functions.
foreach (var variable in this.m_variables.Values)
{
// When a scope is reused, i.e. with an eval(), do not reinitialize the variables.
if (variable.Initialized)
{
continue;
}
if (variable.ValueAtTopOfScope != null)
{
// Emit the initialization code.
if (this is ObjectScope)
{
// Determine the property attributes.
var attributes = Library.PropertyAttributes.Enumerable;
if (variable.Writable)
{
attributes |= Library.PropertyAttributes.Writable;
}
if (variable.Deletable)
{
attributes |= Library.PropertyAttributes.Configurable;
}
// bool DefineProperty(string propertyName, PropertyDescriptor descriptor, bool throwOnError)
EmitHelpers.LoadScope(generator);
generator.CastClass(typeof(ObjectScope));
generator.Call(ReflectionHelpers.ObjectScope_ScopeObject.Value);
generator.LoadString(variable.Name);
variable.ValueAtTopOfScope.GenerateCode(generator, optimizationInfo);
EmitConversion.Convert(generator, variable.ValueAtTopOfScope.ResultType, PrimitiveType.Any, optimizationInfo);
generator.LoadInt32((int)attributes);
generator.NewObject(ReflectionHelpers.PropertyDescriptor_Constructor2.Value);
generator.LoadBoolean(false);
generator.Call(ReflectionHelpers.ObjectInstance_DefineProperty.Value);
generator.Pop();
}
else
{
variable.ValueAtTopOfScope.GenerateCode(generator, optimizationInfo);
var name = new NameExpression(this, variable.Name);
name.GenerateSet(generator, optimizationInfo, variable.ValueAtTopOfScope.ResultType, false);
}
// Mark the variable as having been initialized.
variable.Initialized = true;
}
}
}
/// <summary>
/// Generates CIL for the statement.
/// </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)
{
// Generate code for the start of the statement.
var statementLocals = new StatementLocals();
GenerateStartOfStatement(generator, optimizationInfo, statementLocals);
// Emit the return value.
if (this.Value == null)
{
EmitHelpers.EmitUndefined(generator);
}
else
{
this.Value.GenerateCode(generator, optimizationInfo);
EmitConversion.ToAny(generator, this.Value.ResultType);
}
// Determine if this is the last statement in the function.
bool lastStatement = optimizationInfo.AbstractSyntaxTree is BlockStatement &&
((BlockStatement)optimizationInfo.AbstractSyntaxTree).Statements.Count > 0 &&
((BlockStatement)optimizationInfo.AbstractSyntaxTree).Statements[((BlockStatement)optimizationInfo.AbstractSyntaxTree).Statements.Count - 1] == this;
// The first return statement initializes the variable that holds the return value.
if (optimizationInfo.ReturnVariable == null)
{
optimizationInfo.ReturnVariable = generator.DeclareVariable(typeof(object), "returnValue");
}
// Store the return value in a variable.
generator.StoreVariable(optimizationInfo.ReturnVariable);
// There is no need to jump to the end of the function if this is the last statement.
if (lastStatement == false)
{
// The first return statement that needs to branch creates the return label. This is
// defined in FunctionmethodGenerator.GenerateCode() at the end of the function.
if (optimizationInfo.ReturnTarget == null)
{
optimizationInfo.ReturnTarget = generator.CreateLabel();
}
// Branch to the end of the function. Note: the return statement might be branching
// from inside a try { } or finally { } block to outside. EmitLongJump() handles this.
optimizationInfo.EmitLongJump(generator, optimizationInfo.ReturnTarget);
}
// Generate code for the end of the statement.
GenerateEndOfStatement(generator, optimizationInfo, statementLocals);
}
/// <summary>
/// Generates CIL for the statement.
/// </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)
{
// Generate code for the start of the statement.
var statementLocals = new StatementLocals();
GenerateStartOfStatement(generator, optimizationInfo, statementLocals);
// Generate code for the condition and coerce to a boolean.
this.Condition.GenerateCode(generator, optimizationInfo);
EmitConversion.ToBool(generator, this.Condition.ResultType);
// We will need a label at the end of the if statement.
var endOfEverything = generator.CreateLabel();
if (this.ElseClause == null)
{
// Jump to the end if the condition is false.
generator.BranchIfFalse(endOfEverything);
// Generate code for the if clause.
this.IfClause.GenerateCode(generator, optimizationInfo);
}
else
{
// Branch to the else clause if the condition is false.
var startOfElseClause = generator.CreateLabel();
generator.BranchIfFalse(startOfElseClause);
// Generate code for the if clause.
this.IfClause.GenerateCode(generator, optimizationInfo);
// Branch to the end of the if statement.
generator.Branch(endOfEverything);
// Generate code for the else clause.
generator.DefineLabelPosition(startOfElseClause);
this.ElseClause.GenerateCode(generator, optimizationInfo);
}
// Define the label at the end of the if statement.
generator.DefineLabelPosition(endOfEverything);
// Generate code for the end of the statement.
GenerateEndOfStatement(generator, optimizationInfo, statementLocals);
}
/// <summary>
/// Generates CIL for the statement.
/// </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)
{
// Generate code for the start of the statement.
var statementLocals = new StatementLocals();
GenerateStartOfStatement(generator, optimizationInfo, statementLocals);
// Emit code to throw the given value.
this.Value.GenerateCode(generator, optimizationInfo);
EmitConversion.ToAny(generator, this.Value.ResultType);
generator.LoadInt32(optimizationInfo.SourceSpan.StartLine);
generator.LoadStringOrNull(optimizationInfo.Source.Path);
generator.LoadStringOrNull(optimizationInfo.FunctionName);
generator.NewObject(ReflectionHelpers.JavaScriptException_Constructor_Object.Value);
generator.Throw();
// Generate code for the end of the statement.
GenerateEndOfStatement(generator, optimizationInfo, statementLocals);
}
/// <summary>
/// Generates an array containing the argument values.
/// </summary>
/// <param name="generator"> The generator to output the CIL to. </param>
/// <param name="optimizationInfo"> Information about any optimizations that should be performed. </param>
internal void GenerateArgumentsArray(ILGenerator generator, OptimizationInfo optimizationInfo)
{
// Emit the arguments. The arguments operand can be non-existant, a single expression,
// or a comma-delimited list.
if (this.OperandCount < 2)
{
// No parameters passed. Create an empty array.
generator.LoadInt32(0);
generator.NewArray(typeof(object));
}
else
{
// One or more arguments.
IList <Expression> arguments;
var argumentsOperand = this.GetRawOperand(1);
if (argumentsOperand is ListExpression)
{
// Multiple parameters were passed to the function.
arguments = ((ListExpression)argumentsOperand).Items;
}
else
{
// A single parameter was passed to the function.
arguments = new List <Expression>(1)
{
argumentsOperand
};
}
// Generate an array containing the value of each argument.
generator.LoadInt32(arguments.Count);
generator.NewArray(typeof(object));
for (int i = 0; i < arguments.Count; i++)
{
generator.Duplicate();
generator.LoadInt32(i);
arguments[i].GenerateCode(generator, optimizationInfo);
EmitConversion.ToAny(generator, arguments[i].ResultType);
generator.StoreArrayElement(typeof(object));
}
}
}
/// <summary>
/// Generates code that creates a new scope.
/// </summary>
/// <param name="generator"> The generator to output the CIL to. </param>
/// <param name="optimizationInfo"> Information about any optimizations that should be performed. </param>
internal override void GenerateScopeCreation(ILGenerator generator, OptimizationInfo optimizationInfo)
{
// Create a new runtime object scope.
EmitHelpers.LoadScope(generator); // parent scope
if (this.ScopeObjectExpression == null)
{
EmitHelpers.LoadScriptEngine(generator);
generator.Call(ReflectionHelpers.ScriptEngine_Global.Value);
}
else
{
this.ScopeObjectExpression.GenerateCode(generator, optimizationInfo);
EmitConversion.ToObject(generator, this.ScopeObjectExpression.ResultType, optimizationInfo);
}
generator.LoadBoolean(this.ProvidesImplicitThisValue);
generator.LoadBoolean(this.CanDeclareVariables);
generator.Call(ReflectionHelpers.ObjectScope_CreateRuntimeScope.Value);
// Save the new scope.
EmitHelpers.StoreScope(generator);
}
/// <summary>
/// Generates CIL for the statement.
/// </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)
{
// Generate code for the start of the statement.
var statementLocals = new StatementLocals {
NonDefaultBreakStatementBehavior = true, NonDefaultSourceSpanBehavior = true
};
GenerateStartOfStatement(generator, optimizationInfo, statementLocals);
// <initializer>
// if (<condition>)
// {
// <loop body>
// <increment>
// while (true) {
// if (<condition> == false)
// break;
//
// <body statements>
//
// continue-target:
// <increment>
// }
// }
// break-target:
// Set up some labels.
var continueTarget = generator.CreateLabel();
var breakTarget1 = generator.CreateLabel();
var breakTarget2 = generator.CreateLabel();
// Emit the initialization statement.
if (this.InitStatement != null)
{
this.InitStatement.GenerateCode(generator, optimizationInfo);
}
// Check the condition and jump to the end if it is false.
if (this.CheckConditionAtEnd == false && this.ConditionStatement != null)
{
optimizationInfo.MarkSequencePoint(generator, this.ConditionStatement.SourceSpan);
this.Condition.GenerateCode(generator, optimizationInfo);
EmitConversion.ToBool(generator, this.Condition.ResultType);
generator.BranchIfFalse(breakTarget1);
}
// Emit the loop body.
optimizationInfo.PushBreakOrContinueInfo(this.Labels, breakTarget1, continueTarget, false);
this.Body.GenerateCode(generator, optimizationInfo);
optimizationInfo.PopBreakOrContinueInfo();
// Increment the loop variable.
if (this.IncrementStatement != null)
{
this.IncrementStatement.GenerateCode(generator, optimizationInfo);
}
// Strengthen the variable types.
List <KeyValuePair <Scope.DeclaredVariable, RevertInfo> > previousVariableTypes = null;
var previousInsideTryCatchOrFinally = optimizationInfo.InsideTryCatchOrFinally;
if (optimizationInfo.OptimizeInferredTypes)
{
// Keep a record of the variable types before strengthening.
previousVariableTypes = new List <KeyValuePair <Scope.DeclaredVariable, RevertInfo> >();
var typedVariables = FindTypedVariables();
foreach (var variableAndType in typedVariables)
{
var variable = variableAndType.Key;
var variableInfo = variableAndType.Value;
if (variableInfo.Conditional == false && variableInfo.Type != variable.Type)
{
// Save the previous type so we can restore it later.
var previousType = variable.Type;
previousVariableTypes.Add(new KeyValuePair <Scope.DeclaredVariable, RevertInfo>(variable, new RevertInfo {
Type = previousType, Variable = variable.Store
}));
// Load the existing value.
var nameExpression = new NameExpression(variable.Scope, variable.Name);
nameExpression.GenerateGet(generator, optimizationInfo, false);
// Store the typed value.
variable.Store = generator.DeclareVariable(variableInfo.Type, null);
variable.Type = variableInfo.Type;
nameExpression.GenerateSet(generator, optimizationInfo, previousType, false);
}
}
// The variables must be reverted even in the presence of exceptions.
if (previousVariableTypes.Count > 0)
{
generator.BeginExceptionBlock();
// Setting the InsideTryCatchOrFinally flag converts BR instructions into LEAVE
// instructions so that the finally block is executed correctly.
optimizationInfo.InsideTryCatchOrFinally = true;
}
}
// The inner loop starts here.
var startOfLoop = generator.DefineLabelPosition();
// Check the condition and jump to the end if it is false.
if (this.ConditionStatement != null)
{
optimizationInfo.MarkSequencePoint(generator, this.ConditionStatement.SourceSpan);
this.Condition.GenerateCode(generator, optimizationInfo);
EmitConversion.ToBool(generator, this.Condition.ResultType);
generator.BranchIfFalse(breakTarget2);
}
// Emit the loop body.
optimizationInfo.PushBreakOrContinueInfo(this.Labels, breakTarget2, continueTarget, false);
this.Body.GenerateCode(generator, optimizationInfo);
optimizationInfo.PopBreakOrContinueInfo();
// The continue statement jumps here.
generator.DefineLabelPosition(continueTarget);
// Increment the loop variable.
if (this.IncrementStatement != null)
{
this.IncrementStatement.GenerateCode(generator, optimizationInfo);
}
// Unconditionally branch back to the start of the loop.
generator.Branch(startOfLoop);
// Define the end of the loop (actually just after).
generator.DefineLabelPosition(breakTarget2);
// Revert the variable types.
if (previousVariableTypes != null && previousVariableTypes.Count > 0)
{
// Revert the InsideTryCatchOrFinally flag.
optimizationInfo.InsideTryCatchOrFinally = previousInsideTryCatchOrFinally;
// Revert the variable types within a finally block.
generator.BeginFinallyBlock();
foreach (var previousVariableAndType in previousVariableTypes)
{
var variable = previousVariableAndType.Key;
var variableRevertInfo = previousVariableAndType.Value;
// Load the existing value.
var nameExpression = new NameExpression(variable.Scope, variable.Name);
nameExpression.GenerateGet(generator, optimizationInfo, false);
// Store the typed value.
var previousType = variable.Type;
variable.Store = variableRevertInfo.Variable;
variable.Type = variableRevertInfo.Type;
nameExpression.GenerateSet(generator, optimizationInfo, previousType, false);
}
// End the exception block.
generator.EndExceptionBlock();
}
// Define the end of the loop (actually just after).
generator.DefineLabelPosition(breakTarget1);
// Generate code for the end of the statement.
GenerateEndOfStatement(generator, optimizationInfo, statementLocals);
}
/// <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)
{
// Check if this is a direct call to eval().
if (this.Target is NameExpression && ((NameExpression)this.Target).Name == "eval")
{
GenerateEval(generator, optimizationInfo);
return;
}
// Emit the function instance first.
ILLocalVariable targetBase = null;
var memberAccessExpressionTarget = this.Target as MemberAccessExpression;
if (memberAccessExpressionTarget != null)
{
// The function is a member access expression (e.g. "Math.cos()").
// Evaluate the left part of the member access expression.
var baseExpression = memberAccessExpressionTarget.Base;
baseExpression.GenerateCode(generator, optimizationInfo);
EmitConversion.ToAny(generator, baseExpression.ResultType);
targetBase = generator.CreateTemporaryVariable(typeof(object));
generator.StoreVariable(targetBase);
// Evaluate the right part of the member access expression.
var memberAccessExpression = new MemberAccessExpression(memberAccessExpressionTarget.Operator);
memberAccessExpression.Push(new TemporaryVariableExpression(targetBase));
memberAccessExpression.Push(memberAccessExpressionTarget.GetOperand(1));
memberAccessExpression.GenerateCode(generator, optimizationInfo);
EmitConversion.ToAny(generator, this.Target.ResultType);
}
else
{
// Something else (e.g. "eval()").
this.Target.GenerateCode(generator, optimizationInfo);
EmitConversion.ToAny(generator, this.Target.ResultType);
}
// Check the object really is a function - if not, throw an exception.
generator.IsInstance(typeof(Library.FunctionInstance));
generator.Duplicate();
var endOfTypeCheck = generator.CreateLabel();
generator.BranchIfNotNull(endOfTypeCheck);
// Throw an nicely formatted exception.
generator.Pop();
EmitHelpers.EmitThrow(generator, "TypeError", string.Format("'{0}' is not a function", this.Target));
generator.DefineLabelPosition(endOfTypeCheck);
// Pass in the path, function name and line.
generator.LoadStringOrNull(optimizationInfo.Source.Path);
generator.LoadStringOrNull(optimizationInfo.FunctionName);
generator.LoadInt32(optimizationInfo.SourceSpan.StartLine);
// Generate code to produce the "this" value. There are three cases.
if (this.Target is NameExpression)
{
// 1. The function is a name expression (e.g. "parseInt()").
// In this case this = scope.ImplicitThisValue, if there is one, otherwise undefined.
((NameExpression)this.Target).GenerateThis(generator);
}
else if (this.Target is MemberAccessExpression)
{
// 2. The function is a member access expression (e.g. "Math.cos()").
// In this case this = Math.
//var baseExpression = ((MemberAccessExpression)this.Target).Base;
//baseExpression.GenerateCode(generator, optimizationInfo);
//EmitConversion.ToAny(generator, baseExpression.ResultType);
generator.LoadVariable(targetBase);
}
else
{
// 3. Neither of the above (e.g. "(function() { return 5 })()")
// In this case this = undefined.
EmitHelpers.EmitUndefined(generator);
}
// Emit an array containing the function arguments.
GenerateArgumentsArray(generator, optimizationInfo);
// Call FunctionInstance.CallLateBound(thisValue, argumentValues)
generator.Call(ReflectionHelpers.FunctionInstance_CallWithStackTrace.Value);
// Allow reuse of the temporary variable.
if (targetBase != null)
{
generator.ReleaseTemporaryVariable(targetBase);
}
}
/// <summary>
/// Generates CIL for the addition operation.
/// </summary>
/// <param name="generator"> The generator to output the CIL to. </param>
/// <param name="optimizationInfo"> Information about any optimizations that should be performed. </param>
private void GenerateAdd(ILGenerator generator, OptimizationInfo optimizationInfo)
{
// Get the statically-determined types of the left and right operands.
PrimitiveType leftType = this.Left.ResultType;
PrimitiveType rightType = this.Right.ResultType;
// The add operator adds two strings together if at least one of the operands
// is a string, otherwise it adds two numbers.
if (PrimitiveTypeUtilities.IsString(leftType) || PrimitiveTypeUtilities.IsString(rightType))
{
// If at least one of the operands is a string, then the add operator concatenates.
// Load the left-hand side onto the stack.
this.Left.GenerateCode(generator, optimizationInfo);
// Convert the operand to a concatenated string.
EmitConversion.ToPrimitive(generator, leftType, PrimitiveTypeHint.None);
EmitConversion.ToConcatenatedString(generator, leftType);
// Load the right-hand side onto the stack.
this.Right.GenerateCode(generator, optimizationInfo);
if (rightType == PrimitiveType.String)
{
// Concatenate the two strings.
generator.Call(ReflectionHelpers.ConcatenatedString_Concatenate_String.Value);
}
else if (rightType == PrimitiveType.ConcatenatedString)
{
// Concatenate the two strings.
generator.Call(ReflectionHelpers.ConcatenatedString_Concatenate_ConcatenatedString.Value);
}
else
{
// Convert the operand to an object.
EmitConversion.ToPrimitive(generator, rightType, PrimitiveTypeHint.None);
EmitConversion.ToAny(generator, rightType);
// Concatenate the two strings.
generator.Call(ReflectionHelpers.ConcatenatedString_Concatenate_Object.Value);
}
}
else if (leftType != PrimitiveType.Any && leftType != PrimitiveType.Object &&
rightType != PrimitiveType.Any && rightType != PrimitiveType.Object)
{
// Neither of the operands are strings.
// Load the left hand side onto the stack.
this.Left.GenerateCode(generator, optimizationInfo);
// Convert the operand to a number.
EmitConversion.ToNumber(generator, leftType);
// Load the right hand side onto the stack.
this.Right.GenerateCode(generator, optimizationInfo);
// Convert the operand to a number.
EmitConversion.ToNumber(generator, rightType);
// Add the two numbers.
generator.Add();
}
else
{
// It is unknown whether the operands are strings.
// Load the left hand side onto the stack.
this.Left.GenerateCode(generator, optimizationInfo);
EmitConversion.ToAny(generator, leftType);
// Load the right hand side onto the stack.
this.Right.GenerateCode(generator, optimizationInfo);
EmitConversion.ToAny(generator, rightType);
// Add the two objects.
generator.Call(ReflectionHelpers.TypeUtilities_Add.Value);
}
}
/// <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 statement.
/// </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)
{
// Generate code for the start of the statement.
var statementLocals = new StatementLocals {
NonDefaultBreakStatementBehavior = true, NonDefaultSourceSpanBehavior = true
};
GenerateStartOfStatement(generator, optimizationInfo, statementLocals);
// Construct a loop expression.
// var enumerator = TypeUtilities.EnumeratePropertyNames(rhs).GetEnumerator();
// while (true) {
// continue-target:
// if (enumerator.MoveNext() == false)
// goto break-target;
// lhs = enumerator.Current;
//
// <body statements>
// }
// break-target:
// Call IEnumerable<string> EnumeratePropertyNames(ScriptEngine engine, object obj)
optimizationInfo.MarkSequencePoint(generator, this.TargetObjectSourceSpan);
EmitHelpers.LoadScriptEngine(generator);
this.TargetObject.GenerateCode(generator, optimizationInfo);
EmitConversion.ToAny(generator, this.TargetObject.ResultType);
generator.Call(ReflectionHelpers.TypeUtilities_EnumeratePropertyNames.Value);
// Call IEnumerable<string>.GetEnumerator()
generator.Call(ReflectionHelpers.IEnumerable_GetEnumerator.Value);
// Store the enumerator in a temporary variable.
var enumerator = generator.CreateTemporaryVariable(typeof(IEnumerator <string>));
generator.StoreVariable(enumerator);
var breakTarget = generator.CreateLabel();
var continueTarget = generator.DefineLabelPosition();
// Emit debugging information.
if (optimizationInfo.DebugDocument != null)
{
generator.MarkSequencePoint(optimizationInfo.DebugDocument, this.VariableSourceSpan);
}
// if (enumerator.MoveNext() == false)
// goto break-target;
generator.LoadVariable(enumerator);
generator.Call(ReflectionHelpers.IEnumerator_MoveNext.Value);
generator.BranchIfFalse(breakTarget);
// lhs = enumerator.Current;
generator.LoadVariable(enumerator);
generator.Call(ReflectionHelpers.IEnumerator_Current.Value);
this.Variable.GenerateSet(generator, optimizationInfo, PrimitiveType.String, false);
// Emit the body statement(s).
optimizationInfo.PushBreakOrContinueInfo(this.Labels, breakTarget, continueTarget, false);
this.Body.GenerateCode(generator, optimizationInfo);
optimizationInfo.PopBreakOrContinueInfo();
generator.Branch(continueTarget);
generator.DefineLabelPosition(breakTarget);
// Generate code for the end of the statement.
GenerateEndOfStatement(generator, optimizationInfo, statementLocals);
}
/// <summary>
/// Generates CIL for the relational operators.
/// </summary>
/// <param name="generator"> The generator to output the CIL to. </param>
/// <param name="optimizationInfo"> Information about any optimizations that should be performed. </param>
private void GenerateRelational(ILGenerator generator, OptimizationInfo optimizationInfo)
{
// Get the statically-determined types of the left and right operands.
PrimitiveType leftType = this.Left.ResultType;
PrimitiveType rightType = this.Right.ResultType;
// The relational operators compare strings if both of the operands are strings.
if (leftType == PrimitiveType.String && rightType == PrimitiveType.String)
{
// Both of the operands are strings.
// Load the left hand side operand onto the stack.
this.Left.GenerateCode(generator, optimizationInfo);
// Load the right hand side operand onto the stack.
this.Right.GenerateCode(generator, optimizationInfo);
// Compare the two strings.
generator.Call(ReflectionHelpers.String_CompareOrdinal.Value);
switch (this.OperatorType)
{
case OperatorType.LessThan:
generator.LoadInt32(0);
generator.CompareLessThan();
break;
case OperatorType.LessThanOrEqual:
generator.LoadInt32(1);
generator.CompareLessThan();
break;
case OperatorType.GreaterThan:
generator.LoadInt32(0);
generator.CompareGreaterThan();
break;
case OperatorType.GreaterThanOrEqual:
generator.LoadInt32(-1);
generator.CompareGreaterThan();
break;
}
}
else if (leftType == PrimitiveType.Int32 && rightType == PrimitiveType.Int32)
{
// Both of the operands are integers.
// Load the left hand side operand onto the stack.
this.Left.GenerateCode(generator, optimizationInfo);
// Load the right hand side operand onto the stack.
this.Right.GenerateCode(generator, optimizationInfo);
// Compare the two numbers.
switch (this.OperatorType)
{
case OperatorType.LessThan:
generator.CompareLessThan();
break;
case OperatorType.GreaterThan:
generator.CompareGreaterThan();
break;
case OperatorType.LessThanOrEqual:
// a <= b <--> (a > b) == false
generator.CompareGreaterThan();
generator.LoadBoolean(false);
generator.CompareEqual();
break;
case OperatorType.GreaterThanOrEqual:
// a >= b <--> (a < b) == false
generator.CompareLessThan();
generator.LoadBoolean(false);
generator.CompareEqual();
break;
}
}
else if (PrimitiveTypeUtilities.IsNumeric(leftType) || PrimitiveTypeUtilities.IsNumeric(rightType))
{
// At least one of the operands is a number.
// Load the left hand side operand onto the stack.
this.Left.GenerateCode(generator, optimizationInfo);
// Convert the operand to a number.
EmitConversion.ToNumber(generator, leftType);
// Load the right hand side operand onto the stack.
this.Right.GenerateCode(generator, optimizationInfo);
// Convert the operand to a number.
EmitConversion.ToNumber(generator, rightType);
// Compare the two numbers.
switch (this.OperatorType)
{
case OperatorType.LessThan:
generator.CompareLessThan();
break;
case OperatorType.GreaterThan:
generator.CompareGreaterThan();
break;
case OperatorType.LessThanOrEqual:
// a <= b <--> (a > b) == false
generator.CompareGreaterThanUnsigned();
generator.LoadBoolean(false);
generator.CompareEqual();
break;
case OperatorType.GreaterThanOrEqual:
// a >= b <--> (a < b) == false
generator.CompareLessThanUnsigned();
generator.LoadBoolean(false);
generator.CompareEqual();
break;
}
}
else
{
// It is unknown whether one of the operands is a string.
// Load the left hand side operand onto the stack.
this.Left.GenerateCode(generator, optimizationInfo);
EmitConversion.ToAny(generator, leftType);
// Load the right hand side operand onto the stack.
this.Right.GenerateCode(generator, optimizationInfo);
EmitConversion.ToAny(generator, rightType);
switch (this.OperatorType)
{
case OperatorType.LessThan:
generator.Call(ReflectionHelpers.TypeComparer_LessThan.Value);
break;
case OperatorType.LessThanOrEqual:
generator.Call(ReflectionHelpers.TypeComparer_LessThanOrEqual.Value);
break;
case OperatorType.GreaterThan:
generator.Call(ReflectionHelpers.TypeComparer_GreaterThan.Value);
break;
case OperatorType.GreaterThanOrEqual:
generator.Call(ReflectionHelpers.TypeComparer_GreaterThanOrEqual.Value);
break;
}
}
}
/// <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)
{
// Literals cannot have side-effects so if a return value is not expected then generate
// nothing.
//if (optimizationInfo.SuppressReturnValue == true)
// return;
if (this.Value is int)
{
generator.LoadInt32((int)this.Value);
}
else if (this.Value is double)
{
generator.LoadDouble((double)this.Value);
}
else if (this.Value is string)
{
generator.LoadString((string)this.Value);
}
else if (this.Value is bool)
{
generator.LoadBoolean((bool)this.Value);
}
else if (this.Value is RegularExpressionLiteral)
{
// RegExp
var sharedRegExpVariable = optimizationInfo.GetRegExpVariable(generator, (RegularExpressionLiteral)this.Value);
var label1 = generator.CreateLabel();
var label2 = generator.CreateLabel();
// if (sharedRegExp == null) {
generator.LoadVariable(sharedRegExpVariable);
generator.LoadNull();
generator.BranchIfNotEqual(label1);
// sharedRegExp = Global.RegExp.Construct(source, flags)
EmitHelpers.LoadScriptEngine(generator);
generator.Call(ReflectionHelpers.ScriptEngine_RegExp.Value);
generator.LoadString(((RegularExpressionLiteral)this.Value).Pattern);
generator.LoadString(((RegularExpressionLiteral)this.Value).Flags);
generator.Call(ReflectionHelpers.RegExp_Construct.Value);
generator.Duplicate();
generator.StoreVariable(sharedRegExpVariable);
// } else {
generator.Branch(label2);
generator.DefineLabelPosition(label1);
// Global.RegExp.Construct(sharedRegExp, flags)
EmitHelpers.LoadScriptEngine(generator);
generator.Call(ReflectionHelpers.ScriptEngine_RegExp.Value);
generator.LoadVariable(sharedRegExpVariable);
generator.LoadNull();
generator.Call(ReflectionHelpers.RegExp_Construct.Value);
// }
generator.DefineLabelPosition(label2);
}
else if (this.Value == Null.Value)
{
// Null.
EmitHelpers.EmitNull(generator);
}
else if (this.Value == Undefined.Value)
{
// Undefined.
EmitHelpers.EmitUndefined(generator);
}
else if (this.Value is List <Expression> )
{
// Construct an array literal.
var arrayLiteral = (List <Expression>) this.Value;
// Operands for ArrayConstructor.New() are: an ArrayConstructor instance (ArrayConstructor), an array (object[])
// ArrayConstructor
EmitHelpers.LoadScriptEngine(generator);
generator.Call(ReflectionHelpers.ScriptEngine_Array.Value);
// object[]
generator.LoadInt32(arrayLiteral.Count);
generator.NewArray(typeof(object));
for (int i = 0; i < arrayLiteral.Count; i++)
{
// Operands for StoreArrayElement() are: an array (object[]), index (int), value (object).
// Array
generator.Duplicate();
// Index
generator.LoadInt32(i);
// Value
var elementExpression = arrayLiteral[i];
if (elementExpression == null)
{
generator.LoadNull();
}
else
{
elementExpression.GenerateCode(generator, optimizationInfo);
EmitConversion.ToAny(generator, elementExpression.ResultType);
}
// Store the element value.
generator.StoreArrayElement(typeof(object));
}
// ArrayConstructor.New(object[])
generator.Call(ReflectionHelpers.Array_New.Value);
}
else if (this.Value is Dictionary <string, object> )
{
// This is an object literal.
var properties = (Dictionary <string, object>) this.Value;
// Create a new object.
EmitHelpers.LoadScriptEngine(generator);
generator.Call(ReflectionHelpers.ScriptEngine_Object.Value);
generator.Call(ReflectionHelpers.Object_Construct.Value);
foreach (var keyValuePair in properties)
{
string propertyName = keyValuePair.Key;
object propertyValue = keyValuePair.Value;
generator.Duplicate();
generator.LoadString(propertyName);
if (propertyValue is Expression)
{
// Add a new property to the object.
var dataPropertyValue = (Expression)propertyValue;
dataPropertyValue.GenerateCode(generator, optimizationInfo);
// Support the inferred function displayName property.
if (dataPropertyValue is FunctionExpression)
{
((FunctionExpression)dataPropertyValue).GenerateDisplayName(generator, optimizationInfo, propertyName, false);
}
EmitConversion.ToAny(generator, dataPropertyValue.ResultType);
generator.LoadBoolean(optimizationInfo.StrictMode);
generator.Call(ReflectionHelpers.ObjectInstance_SetPropertyValue_String.Value);
}
else if (propertyValue is Parser.ObjectLiteralAccessor)
{
// Add a new getter/setter to the object.
var accessorValue = (Parser.ObjectLiteralAccessor)propertyValue;
if (accessorValue.Getter != null)
{
accessorValue.Getter.GenerateCode(generator, optimizationInfo);
// Support the inferred function displayName property.
accessorValue.Getter.GenerateDisplayName(generator, optimizationInfo, "get " + propertyName, true);
EmitConversion.ToAny(generator, accessorValue.Getter.ResultType);
}
else
{
generator.LoadNull();
}
if (accessorValue.Setter != null)
{
accessorValue.Setter.GenerateCode(generator, optimizationInfo);
// Support the inferred function displayName property.
accessorValue.Setter.GenerateDisplayName(generator, optimizationInfo, "set " + propertyName, true);
EmitConversion.ToAny(generator, accessorValue.Setter.ResultType);
}
else
{
generator.LoadNull();
}
generator.LoadInt32((int)Library.PropertyAttributes.FullAccess);
generator.NewObject(ReflectionHelpers.PropertyDescriptor_Constructor3.Value);
generator.LoadBoolean(false);
generator.Call(ReflectionHelpers.ObjectInstance_DefineProperty.Value);
generator.Pop();
}
else
{
throw new InvalidOperationException("Invalid property value type in object literal.");
}
}
}
else
{
throw new NotImplementedException("Unknown literal type.");
}
}
/// <summary>
/// Stores the value on the top of the stack in the reference.
/// </summary>
/// <param name="generator"> The generator to output the CIL to. </param>
/// <param name="optimizationInfo"> Information about any optimizations that should be performed. </param>
/// <param name="valueType"> The primitive type of the value that is on the top of the stack. </param>
/// <param name="throwIfUnresolvable"> <c>true</c> to throw a ReferenceError exception if
/// the name is unresolvable; <c>false</c> to create a new property instead. </param>
public void GenerateSet(ILGenerator generator, OptimizationInfo optimizationInfo, PrimitiveType valueType, bool throwIfUnresolvable)
{
// The value is initially on the top of the stack but is stored in this variable
// at the last possible moment.
ILLocalVariable value = null;
var scope = this.Scope;
ILLocalVariable scopeVariable = null;
var endOfSet = generator.CreateLabel();
do
{
if (scope is DeclarativeScope)
{
// Get information about the variable.
var variable = scope.GetDeclaredVariable(this.Name);
if (variable != null)
{
// The variable was declared in this scope.
if (scope.ExistsAtRuntime == false)
{
// The scope has been optimized away. The value of the variable is stored
// in an ILVariable.
// Declare an IL local variable if no storage location has been allocated yet.
if (variable.Store == null)
{
variable.Store = generator.DeclareVariable(typeof(object), variable.Name);
}
if (value == null)
{
// The value to store is on the top of the stack - convert it to the
// storage type of the variable.
EmitConversion.Convert(generator, valueType, variable.Type, optimizationInfo);
}
else
{
// The value to store is in a temporary variable.
generator.LoadVariable(value);
EmitConversion.Convert(generator, PrimitiveType.Any, variable.Type, optimizationInfo);
}
// Store the value in the variable.
generator.StoreVariable(variable.Store);
}
else if (variable.Writable)
{
if (value == null)
{
// The value to store is on the top of the stack - convert it to an
// object and store it in a temporary variable.
EmitConversion.Convert(generator, valueType, PrimitiveType.Any, optimizationInfo);
value = generator.CreateTemporaryVariable(typeof(object));
generator.StoreVariable(value);
}
// scope.Values[index] = value
if (scopeVariable == null)
{
EmitHelpers.LoadScope(generator);
}
else
{
generator.LoadVariable(scopeVariable);
}
generator.CastClass(typeof(DeclarativeScope));
generator.Call(ReflectionHelpers.DeclarativeScope_Values.Value);
generator.LoadInt32(variable.Index);
generator.LoadVariable(value);
generator.StoreArrayElement(typeof(object));
}
else
{
// The variable exists, but is read-only.
// Pop the value off the stack (if it is still there).
if (value == null)
{
generator.Pop();
}
}
// The variable was found - no need to search any more parent scopes.
break;
}
// The variable was not defined at compile time, but may have been
// introduced by an eval() statement.
if (optimizationInfo.MethodOptimizationHints.HasEval)
{
if (value == null)
{
// The value to store is on the top of the stack - convert it to an
// object and store it in a temporary variable.
EmitConversion.Convert(generator, valueType, PrimitiveType.Any, optimizationInfo);
value = generator.CreateTemporaryVariable(typeof(object));
generator.StoreVariable(value);
}
// Check the variable exists: if (scope.HasValue(variableName) == true) {
if (scopeVariable == null)
{
EmitHelpers.LoadScope(generator);
}
else
{
generator.LoadVariable(scopeVariable);
}
generator.CastClass(typeof(DeclarativeScope));
generator.LoadString(this.Name);
generator.Call(ReflectionHelpers.Scope_HasValue.Value);
var hasValueClause = generator.CreateLabel();
generator.BranchIfFalse(hasValueClause);
// Set the value of the variable.
if (scopeVariable == null)
{
EmitHelpers.LoadScope(generator);
}
else
{
generator.LoadVariable(scopeVariable);
}
generator.CastClass(typeof(DeclarativeScope));
generator.LoadString(this.Name);
generator.LoadVariable(value);
generator.Call(ReflectionHelpers.Scope_SetValue.Value);
generator.Branch(endOfSet);
// }
generator.DefineLabelPosition(hasValueClause);
}
}
else
{
if (value == null)
{
// The value to store is on the top of the stack - convert it to an
// object and store it in a temporary variable.
EmitConversion.Convert(generator, valueType, PrimitiveType.Any, optimizationInfo);
value = generator.CreateTemporaryVariable(typeof(object));
generator.StoreVariable(value);
}
if (scope.ParentScope == null)
{
// Optimization: if this is the global scope, use hidden classes to
// optimize variable access.
// Global variable modification
// ----------------------------
// __object_cacheKey = null;
// __object_property_cachedIndex = 0;
// ...
// if (__object_cacheKey != object.InlineCacheKey)
// object.InlineSetPropertyValueIfExists("property", value, strictMode, out __object_property_cachedIndex, out __object_cacheKey)
// else
// object.InlinePropertyValues[__object_property_cachedIndex] = value;
// Get a reference to the global object.
if (scopeVariable == null)
{
EmitHelpers.LoadScope(generator);
}
else
{
generator.LoadVariable(scopeVariable);
}
generator.CastClass(typeof(ObjectScope));
generator.Call(ReflectionHelpers.ObjectScope_ScopeObject.Value);
// TODO: share these variables somehow.
var cacheKey = generator.DeclareVariable(typeof(object), null);
var cachedIndex = generator.DeclareVariable(typeof(int), null);
// Store the object into a temp variable.
var objectInstance = generator.DeclareVariable(PrimitiveType.Object, null);
generator.StoreVariable(objectInstance);
// if (__object_cacheKey != object.InlineCacheKey)
generator.LoadVariable(cacheKey);
generator.LoadVariable(objectInstance);
generator.Call(ReflectionHelpers.ObjectInstance_InlineCacheKey.Value);
var elseClause = generator.CreateLabel();
generator.BranchIfEqual(elseClause);
// xxx = object.InlineSetPropertyValueIfExists("property", value, strictMode, out __object_property_cachedIndex, out __object_cacheKey)
generator.LoadVariable(objectInstance);
generator.LoadString(this.Name);
generator.LoadVariable(value);
generator.LoadBoolean(optimizationInfo.StrictMode);
generator.LoadAddressOfVariable(cachedIndex);
generator.LoadAddressOfVariable(cacheKey);
if (throwIfUnresolvable == false)
{
// Set the property value unconditionally.
generator.Call(ReflectionHelpers.ObjectInstance_InlineSetPropertyValue.Value);
}
else
{
// Set the property value if the property exists.
generator.Call(ReflectionHelpers.ObjectInstance_InlineSetPropertyValueIfExists.Value);
// The return value is true if the property was defined, and false if it wasn't.
generator.BranchIfTrue(endOfSet);
}
var endOfIf = generator.CreateLabel();
generator.Branch(endOfIf);
// else
generator.DefineLabelPosition(elseClause);
// object.InlinePropertyValues[__object_property_cachedIndex] = value;
generator.LoadVariable(objectInstance);
generator.Call(ReflectionHelpers.ObjectInstance_InlinePropertyValues.Value);
generator.LoadVariable(cachedIndex);
generator.LoadVariable(value);
generator.StoreArrayElement(typeof(object));
generator.Branch(endOfSet);
// End of the if statement
generator.DefineLabelPosition(endOfIf);
}
else
{
// Slow route.
if (scopeVariable == null)
{
EmitHelpers.LoadScope(generator);
}
else
{
generator.LoadVariable(scopeVariable);
}
generator.CastClass(typeof(ObjectScope));
generator.Call(ReflectionHelpers.ObjectScope_ScopeObject.Value);
generator.LoadString(this.Name);
generator.LoadVariable(value);
generator.LoadBoolean(optimizationInfo.StrictMode);
if (scope.ParentScope == null && throwIfUnresolvable == false)
{
// Set the property value unconditionally.
generator.Call(ReflectionHelpers.ObjectInstance_SetPropertyValue_String.Value);
}
else
{
// Set the property value if the property exists.
generator.Call(ReflectionHelpers.ObjectInstance_SetPropertyValueIfExists.Value);
// The return value is true if the property was defined, and false if it wasn't.
generator.BranchIfTrue(endOfSet);
}
}
}
// Try the parent scope.
if (scope.ParentScope != null && scope.ExistsAtRuntime)
{
if (scopeVariable == null)
{
scopeVariable = generator.CreateTemporaryVariable(typeof(Scope));
EmitHelpers.LoadScope(generator);
}
else
{
generator.LoadVariable(scopeVariable);
}
generator.Call(ReflectionHelpers.Scope_ParentScope.Value);
generator.StoreVariable(scopeVariable);
}
scope = scope.ParentScope;
} while (scope != null);
// The value might be still on top of the stack.
if (value == null && scope == null)
{
generator.Pop();
}
// Throw an error if the name does not exist and throwIfUnresolvable is true.
if (scope == null && throwIfUnresolvable)
{
EmitHelpers.EmitThrow(generator, "ReferenceError", this.Name + " is not defined", optimizationInfo);
}
// Release the temporary variables.
if (value != null)
{
generator.ReleaseTemporaryVariable(value);
}
if (scopeVariable != null)
{
generator.ReleaseTemporaryVariable(scopeVariable);
}
// Define a label at the end.
generator.DefineLabelPosition(endOfSet);
}
/// <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:
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:
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;
// 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.Value);
break;
case OperatorType.StrictlyEqual:
generator.Call(ReflectionHelpers.TypeComparer_StrictEquals.Value);
break;
case OperatorType.NotEqual:
generator.Call(ReflectionHelpers.TypeComparer_Equals.Value);
generator.LoadBoolean(false);
generator.CompareEqual();
break;
case OperatorType.StrictlyNotEqual:
generator.Call(ReflectionHelpers.TypeComparer_StrictEquals.Value);
generator.LoadBoolean(false);
generator.CompareEqual();
break;
default:
throw new NotImplementedException(string.Format("Unsupported operator {0}", this.OperatorType));
}
}
/// <summary>
/// Pushes the value of the reference onto the stack.
/// </summary>
/// <param name="generator"> The generator to output the CIL to. </param>
/// <param name="optimizationInfo"> Information about any optimizations that should be performed. </param>
/// <param name="throwIfUnresolvable"> <c>true</c> to throw a ReferenceError exception if
/// the name is unresolvable; <c>false</c> to output <c>null</c> instead. </param>
public void GenerateGet(ILGenerator generator, OptimizationInfo optimizationInfo, bool throwIfUnresolvable)
{
// This method generates code to retrieve the value of a variable, given the name of
// variable and scope in which the variable is being referenced. The variable was
// not necessary declared in this scope - it might be declared in any of the parent
// scopes (together called a scope chain). The general algorithm is to start at the
// head of the chain and search backwards until the variable is found. There are
// two types of scopes: declarative scopes and object scopes. Object scopes are hard -
// it cannot be known at compile time whether the variable exists or not so runtime
// checks have to be inserted. Declarative scopes are easier - variables have to be
// declared and cannot be deleted. There is one tricky bit: new variables can be
// introduced into a declarative scope at runtime by a non-strict eval() statement.
// Even worse, variables that were introduced by means of an eval() *can* be deleted.
var scope = this.Scope;
ILLocalVariable scopeVariable = null;
var endOfGet = generator.CreateLabel();
do
{
if (scope is DeclarativeScope)
{
// The variable was declared in this scope.
var variable = scope.GetDeclaredVariable(this.Name);
if (variable != null)
{
if (scope.ExistsAtRuntime == false)
{
// The scope has been optimized away. The value of the variable is stored
// in an ILVariable.
// Declare an IL local variable if no storage location has been allocated yet.
if (variable.Store == null)
{
variable.Store = generator.DeclareVariable(typeof(object), variable.Name);
}
// Load the value from the variable.
generator.LoadVariable(variable.Store);
// Ensure that we match ResultType.
EmitConversion.Convert(generator, variable.Type, this.ResultType, optimizationInfo);
}
else
{
// scope.Values[index]
if (scopeVariable == null)
{
EmitHelpers.LoadScope(generator);
}
else
{
generator.LoadVariable(scopeVariable);
}
generator.CastClass(typeof(DeclarativeScope));
generator.Call(ReflectionHelpers.DeclarativeScope_Values.Value);
generator.LoadInt32(variable.Index);
generator.LoadArrayElement(typeof(object));
}
// The variable was found - no need to search any more parent scopes.
break;
}
// The variable was not defined at compile time, but may have been
// introduced by an eval() statement.
if (optimizationInfo.MethodOptimizationHints.HasEval)
{
// Check the variable exists: if (scope.HasValue(variableName) == true) {
if (scopeVariable == null)
{
EmitHelpers.LoadScope(generator);
}
else
{
generator.LoadVariable(scopeVariable);
}
generator.CastClass(typeof(DeclarativeScope));
generator.LoadString(this.Name);
generator.Call(ReflectionHelpers.Scope_HasValue.Value);
var hasValueClause = generator.CreateLabel();
generator.BranchIfFalse(hasValueClause);
// Load the value of the variable.
if (scopeVariable == null)
{
EmitHelpers.LoadScope(generator);
}
else
{
generator.LoadVariable(scopeVariable);
}
generator.CastClass(typeof(DeclarativeScope));
generator.LoadString(this.Name);
generator.Call(ReflectionHelpers.Scope_GetValue.Value);
generator.Branch(endOfGet);
// }
generator.DefineLabelPosition(hasValueClause);
}
}
else
{
if (scope.ParentScope == null)
{
// Global variable access
// -------------------------------------------
// __object_cacheKey = null;
// __object_property_cachedIndex = 0;
// ...
// if (__object_cacheKey != object.InlineCacheKey)
// xxx = object.InlineGetPropertyValue("variable", out __object_property_cachedIndex, out __object_cacheKey)
// else
// xxx = object.InlinePropertyValues[__object_property_cachedIndex];
// Get a reference to the global object.
if (scopeVariable == null)
{
EmitHelpers.LoadScope(generator);
}
else
{
generator.LoadVariable(scopeVariable);
}
generator.CastClass(typeof(ObjectScope));
generator.Call(ReflectionHelpers.ObjectScope_ScopeObject.Value);
// TODO: share these variables somehow.
var cacheKey = generator.DeclareVariable(typeof(object), null);
var cachedIndex = generator.DeclareVariable(typeof(int), null);
// Store the object into a temp variable.
var objectInstance = generator.DeclareVariable(PrimitiveType.Object, null);
generator.StoreVariable(objectInstance);
// if (__object_cacheKey != object.InlineCacheKey)
generator.LoadVariable(cacheKey);
generator.LoadVariable(objectInstance);
generator.Call(ReflectionHelpers.ObjectInstance_InlineCacheKey.Value);
var elseClause = generator.CreateLabel();
generator.BranchIfEqual(elseClause);
// value = object.InlineGetProperty("property", out __object_property_cachedIndex, out __object_cacheKey)
generator.LoadVariable(objectInstance);
generator.LoadString(this.Name);
generator.LoadAddressOfVariable(cachedIndex);
generator.LoadAddressOfVariable(cacheKey);
generator.Call(ReflectionHelpers.ObjectInstance_InlineGetPropertyValue.Value);
var endOfIf = generator.CreateLabel();
generator.Branch(endOfIf);
// else
generator.DefineLabelPosition(elseClause);
// value = object.InlinePropertyValues[__object_property_cachedIndex];
generator.LoadVariable(objectInstance);
generator.Call(ReflectionHelpers.ObjectInstance_InlinePropertyValues.Value);
generator.LoadVariable(cachedIndex);
generator.LoadArrayElement(typeof(object));
// End of the if statement
generator.DefineLabelPosition(endOfIf);
// Check if the value is null.
generator.Duplicate();
generator.BranchIfNotNull(endOfGet);
if (scope.ParentScope != null)
{
generator.Pop();
}
}
else
{
// Gets the value of a variable in an object scope.
if (scopeVariable == null)
{
EmitHelpers.LoadScope(generator);
}
else
{
generator.LoadVariable(scopeVariable);
}
generator.CastClass(typeof(ObjectScope));
generator.Call(ReflectionHelpers.ObjectScope_ScopeObject.Value);
generator.LoadString(this.Name);
generator.Call(ReflectionHelpers.ObjectInstance_GetPropertyValue_String.Value);
// Check if the value is null.
generator.Duplicate();
generator.BranchIfNotNull(endOfGet);
if (scope.ParentScope != null)
{
generator.Pop();
}
}
}
// Try the parent scope.
if (scope.ParentScope != null && scope.ExistsAtRuntime)
{
if (scopeVariable == null)
{
scopeVariable = generator.CreateTemporaryVariable(typeof(Scope));
EmitHelpers.LoadScope(generator);
}
else
{
generator.LoadVariable(scopeVariable);
}
generator.Call(ReflectionHelpers.Scope_ParentScope.Value);
generator.StoreVariable(scopeVariable);
}
scope = scope.ParentScope;
} while (scope != null);
// Throw an error if the name does not exist and throwIfUnresolvable is true.
if (scope == null && throwIfUnresolvable)
{
EmitHelpers.EmitThrow(generator, "ReferenceError", this.Name + " is not defined", optimizationInfo);
}
// Release the temporary variable.
if (scopeVariable != null)
{
generator.ReleaseTemporaryVariable(scopeVariable);
}
// Define a label at the end.
generator.DefineLabelPosition(endOfGet);
// Object scope references may have side-effects (because of getters) so if the value
// is to be ignored we evaluate the value then pop the value from the stack.
//if (optimizationInfo.SuppressReturnValue == true)
// generator.Pop();
}
/// <summary>
/// Generates CIL for the statement.
/// </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)
{
// Generate code for the start of the statement.
var statementLocals = new StatementLocals {
NonDefaultBreakStatementBehavior = true
};
GenerateStartOfStatement(generator, optimizationInfo, statementLocals);
// We need a label for each case clause and one for the default case.
var jumpTargets = new ILLabel[this.CaseClauses.Count];
int defaultIndex = -1;
ILLabel endOfSwitch = generator.CreateLabel();
// Generate code for the switch value.
// ReSharper disable UnusedVariable
var startOfSwitch = generator.CreateLabel();
// ReSharper restore UnusedVariable
this.Value.GenerateCode(generator, optimizationInfo);
EmitConversion.ToAny(generator, this.Value.ResultType);
// Save the switch value in a variable.
var switchValue = generator.CreateTemporaryVariable(typeof(object));
generator.StoreVariable(switchValue);
for (int i = 0; i < this.CaseClauses.Count; i++)
{
var caseClause = this.CaseClauses[i];
// Create a label for each clause.
jumpTargets[i] = generator.CreateLabel();
if (caseClause.Value == null)
{
// This is a default clause.
defaultIndex = i;
continue;
}
// TypeComparer.StrictEquals(switchValue, caseValue)
generator.LoadVariable(switchValue);
caseClause.Value.GenerateCode(generator, optimizationInfo);
EmitConversion.ToAny(generator, caseClause.Value.ResultType);
generator.Call(ReflectionHelpers.TypeComparer_StrictEquals.Value);
// if (TypeComparer.StrictEquals(switchValue, caseValue) == true)
// goto case i
generator.BranchIfTrue(jumpTargets[i]);
}
// None of the cases matched, jump to the default clause or the end of the switch.
generator.Branch(defaultIndex >= 0 ? jumpTargets[defaultIndex] : endOfSwitch);
for (int i = 0; i < this.CaseClauses.Count; i++)
{
// Define a label at the start of the case clause.
generator.DefineLabelPosition(jumpTargets[i]);
// Set up the information needed by the break statement.
optimizationInfo.PushBreakOrContinueInfo(this.Labels, endOfSwitch, null, false);
// Emit the case clause statements.
foreach (var statement in this.CaseClauses[i].BodyStatements)
{
statement.GenerateCode(generator, optimizationInfo);
}
// Revert the information needed by the break statement.
optimizationInfo.PopBreakOrContinueInfo();
}
// Define a label for the end of the switch statement.
generator.DefineLabelPosition(endOfSwitch);
// Release the switch value variable for use elsewhere.
generator.ReleaseTemporaryVariable(switchValue);
// Generate code for the end of the statement.
GenerateEndOfStatement(generator, optimizationInfo, statementLocals);
}
/// <summary>
/// Generates IL for the script.
/// </summary>
/// <param name="generator"> The generator to output the CIL to. </param>
/// <param name="optimizationInfo"> Information about any optimizations that should be performed. </param>
protected override void GenerateCode(ILGenerator generator, OptimizationInfo optimizationInfo)
{
// Method signature: object FunctionDelegate(Compiler.Scope scope, object thisObject, Library.FunctionInstance functionObject, object[] arguments)
// Initialize the scope (note: the initial scope for a function is always declarative).
this.InitialScope.GenerateScopeCreation(generator, optimizationInfo);
// Verify the scope is correct.
VerifyScope(generator);
// In ES3 the "this" value must be an object. See 10.4.3 in the spec.
if (this.StrictMode == false && this.MethodOptimizationHints.HasThis)
{
// if (thisObject == null || thisObject == Null.Value || thisObject == Undefined.Value)
EmitHelpers.LoadThis(generator);
generator.LoadNull();
generator.CompareEqual();
EmitHelpers.LoadThis(generator);
EmitHelpers.EmitNull(generator);
generator.CompareEqual();
generator.BitwiseOr();
EmitHelpers.LoadThis(generator);
EmitHelpers.EmitUndefined(generator);
generator.CompareEqual();
generator.BitwiseOr();
// {
var startOfFalse = generator.CreateLabel();
generator.BranchIfFalse(startOfFalse);
// thisObject = engine.Global;
EmitHelpers.LoadScriptEngine(generator);
generator.Call(ReflectionHelpers.ScriptEngine_Global.Value);
// } else {
var endOfIf = generator.CreateLabel();
generator.Branch(endOfIf);
generator.DefineLabelPosition(startOfFalse);
// thisObject = TypeConverter.ToObject(thisObject);
EmitHelpers.LoadThis(generator);
EmitConversion.ToObject(generator, PrimitiveType.Any, optimizationInfo);
// }
generator.DefineLabelPosition(endOfIf);
EmitHelpers.StoreThis(generator);
}
// Transfer the function name into the scope.
if (string.IsNullOrEmpty(this.Name) == false &&
this.IncludeNameInScope &&
this.ArgumentNames.Contains(this.Name) == false &&
optimizationInfo.MethodOptimizationHints.HasVariable(this.Name))
{
EmitHelpers.LoadFunction(generator);
var functionName = new NameExpression(this.InitialScope, this.Name);
functionName.GenerateSet(generator, optimizationInfo, PrimitiveType.Any, false);
}
// Transfer the arguments object into the scope.
if (this.MethodOptimizationHints.HasArguments && this.ArgumentNames.Contains("arguments") == false)
{
// prototype
EmitHelpers.LoadScriptEngine(generator);
generator.Call(ReflectionHelpers.ScriptEngine_Object.Value);
generator.Call(ReflectionHelpers.FunctionInstance_InstancePrototype.Value);
// callee
EmitHelpers.LoadFunction(generator);
generator.CastClass(typeof(Library.UserDefinedFunction));
// scope
EmitHelpers.LoadScope(generator);
generator.CastClass(typeof(DeclarativeScope));
// argumentValues
EmitHelpers.LoadArgumentsArray(generator);
generator.NewObject(ReflectionHelpers.Arguments_Constructor.Value);
var arguments = new NameExpression(this.InitialScope, "arguments");
arguments.GenerateSet(generator, optimizationInfo, PrimitiveType.Any, false);
}
// Transfer the argument values into the scope.
// Note: the arguments array can be smaller than expected.
if (this.ArgumentNames.Count > 0)
{
var endOfArguments = generator.CreateLabel();
for (int i = 0; i < this.ArgumentNames.Count; i++)
{
// Check if a duplicate argument name exists.
bool duplicate = false;
for (int j = i + 1; j < this.ArgumentNames.Count; j++)
{
if (this.ArgumentNames[i] == this.ArgumentNames[j])
{
duplicate = true;
break;
}
}
if (duplicate)
{
continue;
}
// Check if an array element exists.
EmitHelpers.LoadArgumentsArray(generator);
generator.LoadArrayLength();
generator.LoadInt32(i);
generator.BranchIfLessThanOrEqual(endOfArguments);
// Store the array element in the scope.
EmitHelpers.LoadArgumentsArray(generator);
generator.LoadInt32(i);
generator.LoadArrayElement(typeof(object));
var argument = new NameExpression(this.InitialScope, this.ArgumentNames[i]);
argument.GenerateSet(generator, optimizationInfo, PrimitiveType.Any, false);
}
generator.DefineLabelPosition(endOfArguments);
}
// Initialize any declarations.
this.InitialScope.GenerateDeclarations(generator, optimizationInfo);
//EmitHelpers.LoadScope(generator);
//EmitConversion.ToObject(generator, PrimitiveType.Any);
//generator.Pop();
// Generate code for the body of the function.
this.AbstractSyntaxTree.GenerateCode(generator, optimizationInfo);
// Define the return target - this is where the return statement jumps to.
// ReturnTarget can be null if there were no return statements.
if (optimizationInfo.ReturnTarget != null)
{
generator.DefineLabelPosition(optimizationInfo.ReturnTarget);
}
// Load the return value. If the variable is null, there were no return statements.
if (optimizationInfo.ReturnVariable != null)
{
// Return the value stored in the variable. Will be null if execution hits the end
// of the function without encountering any return statements.
generator.LoadVariable(optimizationInfo.ReturnVariable);
}
else
{
// There were no return statements - return null.
generator.LoadNull();
}
}
/// <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.Value);
generator.LoadInt32(1);
var endOfCharCheck = generator.CreateLabel();
generator.BranchIfEqual(endOfCharCheck);
EmitHelpers.EmitThrow(generator, "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.Value);
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.Value);
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.Value);
generator.DefineLabelPosition(endOfUnwrapCheck);
// Value types must be unboxed.
if (toType.IsValueType)
{
if (convertToAddress)
{
// 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);
}
}