/// <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, NonDefaultDebugInfoBehavior = 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)
EmitHelpers.LoadScriptEngine(generator);
this.TargetObject.GenerateCode(generator, optimizationInfo);
EmitConversion.ToAny(generator, this.TargetObject.ResultType);
generator.Call(ReflectionHelpers.TypeUtilities_EnumeratePropertyNames);
// Call IEnumerable<string>.GetEnumerator()
generator.Call(ReflectionHelpers.IEnumerable_GetEnumerator);
// 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.VariableDebugInfo);
// if (enumerator.MoveNext() == false)
// goto break-target;
generator.LoadVariable(enumerator);
generator.Call(ReflectionHelpers.IEnumerator_MoveNext);
generator.BranchIfFalse(breakTarget);
// lhs = enumerator.Current;
generator.LoadVariable(enumerator);
generator.Call(ReflectionHelpers.IEnumerator_Current);
this.Variable.GenerateSet(generator, optimizationInfo, PrimitiveType.String, false);
// Emit the body statement(s).
optimizationInfo.PushBreakOrContinueInfo(this.Labels, breakTarget, continueTarget, labelledOnly: 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 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);
// Create the scope.
this.Scope.GenerateScopeCreation(generator, optimizationInfo);
// Make sure the scope is reverted even if an exception is thrown.
generator.BeginExceptionBlock();
// Setting the InsideTryCatchOrFinally flag converts BR instructions into LEAVE
// instructions so that the finally block is executed correctly.
var previousInsideTryCatchOrFinally = optimizationInfo.InsideTryCatchOrFinally;
optimizationInfo.InsideTryCatchOrFinally = true;
// Generate code for the body statements.
this.Body.GenerateCode(generator, optimizationInfo);
// Reset the InsideTryCatchOrFinally flag.
optimizationInfo.InsideTryCatchOrFinally = previousInsideTryCatchOrFinally;
// Revert the scope.
generator.BeginFinallyBlock();
this.Scope.GenerateScopeDestruction(generator, optimizationInfo);
generator.EndExceptionBlock();
// 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);
if (this.ContributesToEvalResult == true && 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 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)
{
// Declare a variable to store the eval result.
optimizationInfo.EvalResult = generator.DeclareVariable(typeof(object));
if (this.StrictMode == true)
{
// Create a new scope.
this.InitialScope.GenerateScopeCreation(generator, optimizationInfo);
}
// Verify the scope is correct.
VerifyScope(generator);
// Initialize any declarations.
this.InitialScope.GenerateDeclarations(generator, optimizationInfo);
// Generate the main body of code.
this.AbstractSyntaxTree.GenerateCode(generator, optimizationInfo);
// Make the return value from the method the eval result.
generator.LoadVariable(optimizationInfo.EvalResult);
// If the result is null, convert it to undefined.
var end = generator.CreateLabel();
generator.Duplicate();
generator.BranchIfNotNull(end);
generator.Pop();
EmitHelpers.EmitUndefined(generator);
generator.DefineLabelPosition(end);
}
/// <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)
{
// This code is only used for untagged template literals.
// Tagged template literals are handled by FunctionCallExpression.
// Load the values array onto the stack.
generator.LoadInt32(this.Strings.Count + this.Values.Count);
generator.NewArray(typeof(string));
for (int i = 0; i < this.Strings.Count; i++)
{
// Operands for StoreArrayElement() are: an array (string[]), index (int), value (string).
// Store the string.
generator.Duplicate();
generator.LoadInt32(i * 2);
generator.LoadString(this.Strings[i]);
generator.StoreArrayElement(typeof(string));
if (i == this.Strings.Count - 1)
break;
// Store the value.
generator.Duplicate();
generator.LoadInt32(i * 2 + 1);
this.Values[i].GenerateCode(generator, optimizationInfo);
EmitConversion.ToString(generator, this.Values[i].ResultType);
generator.StoreArrayElement(typeof(string));
}
// Call String.Concat(string[])
generator.CallStatic(ReflectionHelpers.String_Concat);
}
/// <summary>
/// Deletes the reference and pushes <c>true</c> if the delete succeeded, or <c>false</c>
/// if the delete failed.
/// </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 void GenerateDelete(ILGenerator generator, OptimizationInfo optimizationInfo)
{
// Load the left-hand side and convert to an object instance.
var lhs = this.GetOperand(0);
lhs.GenerateCode(generator, optimizationInfo);
EmitConversion.ToObject(generator, lhs.ResultType);
// Load the property name and convert to a string.
var rhs = this.GetOperand(1);
if (this.OperatorType == OperatorType.MemberAccess && rhs is NameExpression)
generator.LoadString((rhs as NameExpression).Name);
else
{
rhs.GenerateCode(generator, optimizationInfo);
EmitConversion.ToString(generator, rhs.ResultType);
}
// Call Delete()
generator.LoadBoolean(optimizationInfo.StrictMode);
generator.Call(ReflectionHelpers.ObjectInstance_Delete);
// If the return value is not wanted then pop it from the stack.
//if (optimizationInfo.SuppressReturnValue == true)
// generator.Pop();
}
/// <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)
{
// Generate a new method.
this.context.GenerateCode();
// Add the generated method to the nested function list.
if (optimizationInfo.NestedFunctions == null)
optimizationInfo.NestedFunctions = new List<GeneratedMethod>();
optimizationInfo.NestedFunctions.Add(this.context.GeneratedMethod);
// Add all the nested methods to the parent list.
if (this.context.GeneratedMethod.Dependencies != null)
{
foreach (var nestedFunctionExpression in this.context.GeneratedMethod.Dependencies)
optimizationInfo.NestedFunctions.Add(nestedFunctionExpression);
}
// Store the generated method in the cache.
long generatedMethodID = GeneratedMethod.Save(this.context.GeneratedMethod);
// Create a UserDefinedFunction.
// prototype
EmitHelpers.LoadScriptEngine(generator);
generator.Call(ReflectionHelpers.ScriptEngine_Function);
generator.Call(ReflectionHelpers.FunctionInstance_InstancePrototype);
// name
generator.LoadString(this.FunctionName);
// argumentNames
generator.LoadInt32(this.ArgumentNames.Count);
generator.NewArray(typeof(string));
for (int i = 0; i < this.ArgumentNames.Count; i++)
{
generator.Duplicate();
generator.LoadInt32(i);
generator.LoadString(this.ArgumentNames[i]);
generator.StoreArrayElement(typeof(string));
}
// scope
EmitHelpers.LoadScope(generator);
// bodyText
generator.LoadString(this.BodyText);
// body
generator.LoadInt64(generatedMethodID);
generator.Call(ReflectionHelpers.GeneratedMethod_Load);
// strictMode
generator.LoadBoolean(this.context.StrictMode);
// new UserDefinedFunction(ObjectInstance prototype, string name, IList<string> argumentNames, DeclarativeScope scope, Func<Scope, object, object[], object> body, bool strictMode)
generator.NewObject(ReflectionHelpers.UserDefinedFunction_Constructor);
}
/// <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() { NonDefaultSourceSpanBehavior = true };
GenerateStartOfStatement(generator, optimizationInfo, statementLocals);
// 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 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)
{
// Initialize any function or variable declarations.
this.InitialScope.GenerateDeclarations(generator, optimizationInfo);
// Generate code for the source code.
this.AbstractSyntaxTree.GenerateCode(generator, optimizationInfo);
// Code in the global context always returns undefined.
EmitHelpers.EmitUndefined(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();
GenerateStartOfStatement(generator, optimizationInfo, statementLocals);
// Emit an unconditional branch.
// Note: the continue statement might be branching from inside a try { } or finally { }
// block to outside. EmitLongJump() handles this.
optimizationInfo.EmitLongJump(generator, optimizationInfo.GetContinueTarget(this.Label));
// 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)
{
// Get an array of comma-delimited expressions.
var items = this.Items;
for (int i = 0; i < items.Count - 1; i++)
{
// Generate code for the item, evaluating the side-effects but not producing any values.
items[i].GenerateCode(generator, optimizationInfo); //.AddFlags(OptimizationFlags.SuppressReturnValue));
generator.Pop();
}
// Generate code for the last item and return the value.
items[items.Count - 1].GenerateCode(generator, optimizationInfo);
}
/// <summary>
/// Generates CIL for the end of every 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>
/// <param name="locals"> Variables common to both GenerateStartOfStatement() and GenerateEndOfStatement(). </param>
public void GenerateEndOfStatement(ILGenerator generator, OptimizationInfo optimizationInfo, StatementLocals locals)
{
if (locals.NonDefaultBreakStatementBehavior == false && this.HasLabels == true)
{
// Revert the information needed by the break statement.
generator.DefineLabelPosition(locals.EndOfStatement);
optimizationInfo.PopBreakOrContinueInfo();
}
#if DEBUG && !SILVERLIGHT && !XBOX
// Check that the stack count is zero.
if (generator is DynamicILGenerator && ((DynamicILGenerator)generator).StackSize != locals.OriginalStackSize)
throw new InvalidOperationException("Encountered unexpected stack imbalance.");
#endif
}
/// <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(0);
generator.LoadNull();
generator.NewObject(ReflectionHelpers.JavaScriptException_Constructor_Object);
generator.Throw();
// 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);
// Inserts a breakpoint into the IL.
generator.Breakpoint();
// When the debugger stops, it stops at the first instruction after the breakpoint. By
// inserting a no-op operation the debugger will highlight the "debugger" statement
// instead of the statement after the "debugger" statement.
generator.NoOperation();
// 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 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 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;
}*/
// Emit the condition.
var condition = this.GetOperand(0);
condition.GenerateCode(generator, optimizationInfo);
// Convert the condition to a boolean.
EmitConversion.ToBool(generator, condition.ResultType);
// Branch if the condition is false.
var startOfElse = generator.CreateLabel();
generator.BranchIfFalse(startOfElse);
// Calculate the result type.
var outputType = this.ResultType;
// Emit the second operand and convert it to the result type.
var operand2 = this.GetOperand(1);
operand2.GenerateCode(generator, optimizationInfo);
EmitConversion.Convert(generator, operand2.ResultType, outputType);
// Branch to the end.
var end = generator.CreateLabel();
generator.Branch(end);
generator.DefineLabelPosition(startOfElse);
// Emit the third operand and convert it to the result type.
var operand3 = this.GetOperand(2);
operand3.GenerateCode(generator, optimizationInfo);
EmitConversion.Convert(generator, operand3.ResultType, outputType);
// Define the end label.
generator.DefineLabelPosition(end);
}
/// <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() { NonDefaultSourceSpanBehavior = true };
GenerateStartOfStatement(generator, optimizationInfo, statementLocals);
foreach (var declaration in this.Declarations)
{
if (declaration.InitExpression != null)
{
// Create a new assignment expression and generate code for it.
var initializationStatement = new ExpressionStatement(
new AssignmentExpression(this.Scope, declaration.VariableName, declaration.InitExpression));
initializationStatement.SourceSpan = declaration.SourceSpan;
initializationStatement.GenerateCode(generator, optimizationInfo);
}
}
// Generate code for the end of the statement.
GenerateEndOfStatement(generator, optimizationInfo, statementLocals);
}
/// <summary>
/// Outputs the values needed to get or set this 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>
public void DuplicateReference(ILGenerator generator, OptimizationInfo optimizationInfo)
{
string propertyName = null;
TypeOfMemberAccess memberAccessType = DetermineTypeOfMemberAccess(optimizationInfo, out propertyName);
if (memberAccessType == TypeOfMemberAccess.ArrayIndex)
{
// Array indexer
var arg1 = generator.CreateTemporaryVariable(typeof(object));
var arg2 = generator.CreateTemporaryVariable(typeof(uint));
generator.StoreVariable(arg2);
generator.StoreVariable(arg1);
generator.LoadVariable(arg1);
generator.LoadVariable(arg2);
generator.LoadVariable(arg1);
generator.LoadVariable(arg2);
generator.ReleaseTemporaryVariable(arg1);
generator.ReleaseTemporaryVariable(arg2);
}
else if (memberAccessType == TypeOfMemberAccess.Static)
{
// Named property access
generator.Duplicate();
}
else
{
// Dynamic property access
var arg1 = generator.CreateTemporaryVariable(typeof(object));
var arg2 = generator.CreateTemporaryVariable(typeof(object));
generator.StoreVariable(arg2);
generator.StoreVariable(arg1);
generator.LoadVariable(arg1);
generator.LoadVariable(arg2);
generator.LoadVariable(arg1);
generator.LoadVariable(arg2);
generator.ReleaseTemporaryVariable(arg1);
generator.ReleaseTemporaryVariable(arg2);
}
}
/// <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);
foreach (var declaration in this.Declarations)
{
if (declaration.InitExpression != null)
{
// Create a new assignment expression and generate code for it.
if (optimizationInfo.DebugDocument != null)
generator.MarkSequencePoint(optimizationInfo.DebugDocument, declaration.DebugInfo);
var initializationStatement = new ExpressionStatement(
new AssignmentExpression(this.Scope, declaration.VariableName, declaration.InitExpression));
initializationStatement.GenerateCode(generator, optimizationInfo);
}
}
// Generate code for the end of the statement.
GenerateEndOfStatement(generator, optimizationInfo, statementLocals);
}
/// <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)
{
// Allocate storage for each variable if the declarative scope object has been optimized away.
if (optimizationInfo.OptimizeDeclarativeScopes == false)
{
// Create a new declarative scope.
// parentScope
EmitHelpers.LoadScope(generator);
// declaredVariableNames
generator.LoadInt32(this.DeclaredVariableCount);
generator.NewArray(typeof(string));
int i = 0;
foreach (string variableName in this.DeclaredVariableNames)
{
generator.Duplicate();
generator.LoadInt32(i ++);
generator.LoadString(variableName);
generator.StoreArrayElement(typeof(string));
}
// DeclarativeScope.CreateRuntimeScope(parentScope, declaredVariableNames)
generator.Call(ReflectionHelpers.DeclarativeScope_CreateRuntimeScope);
// Save the new scope.
EmitHelpers.StoreScope(generator);
}
else
{
// The declarative scope can be optimized away entirely.
foreach (var variable in this.DeclaredVariables)
{
variable.Store = null;
variable.Type = PrimitiveType.Any;
}
// Indicate the scope was not created.
this.ExistsAtRuntime = false;
}
}
/// <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 abstract void GenerateCode(ILGenerator generator, OptimizationInfo optimizationInfo);
/// <summary>
/// Generates IL for the script.
/// </summary>
public void GenerateCode()
{
// Generate the abstract syntax tree if it hasn't already been generated.
if (this.AbstractSyntaxTree == null)
{
Parse();
Optimize();
}
// Initialize global code-gen information.
var optimizationInfo = new OptimizationInfo(this.Engine);
optimizationInfo.AbstractSyntaxTree = this.AbstractSyntaxTree;
optimizationInfo.StrictMode = this.StrictMode;
optimizationInfo.MethodOptimizationHints = this.MethodOptimizationHints;
ILGenerator generator;
if (this.Options.EnableDebugging == false)
{
// DynamicMethod requires full trust because of generator.LoadMethodPointer in the
// FunctionExpression class.
// Create a new dynamic method.
System.Reflection.Emit.DynamicMethod dynamicMethod;
#if !SILVERLIGHT
if (ScriptEngine.LowPrivilegeEnvironment == false)
{
// High privilege path.
dynamicMethod = new System.Reflection.Emit.DynamicMethod(
GetMethodName(), // Name of the generated method.
typeof(object), // Return type of the generated method.
GetParameterTypes(), // Parameter types of the generated method.
typeof(MethodGenerator), // Owner type.
true); // Skip visibility checks.
// TODO: Figure out why long methods give BadImageFormatException in .NET 3.5 when generated using DynamicILInfo.
if (Environment.Version.Major >= 4)
generator = new DynamicILGenerator(dynamicMethod);
else
generator = new ReflectionEmitILGenerator(dynamicMethod.GetILGenerator());
}
else
{
#endif
// Low privilege path.
dynamicMethod = new System.Reflection.Emit.DynamicMethod(
GetMethodName(), // Name of the generated method.
typeof(object), // Return type of the generated method.
GetParameterTypes()); // Parameter types of the generated method.
generator = new ReflectionEmitILGenerator(dynamicMethod.GetILGenerator());
#if !SILVERLIGHT
}
#endif
if (this.Engine.EnableILAnalysis == true)
{
// Replace the generator with one that logs.
generator = new LoggingILGenerator(generator);
}
// Generate the IL.
GenerateCode(generator, optimizationInfo);
generator.Complete();
// Create a delegate from the method.
this.GeneratedMethod = new GeneratedMethod(dynamicMethod.CreateDelegate(GetDelegate()), optimizationInfo.NestedFunctions);
}
else
{
#if WINDOWS_PHONE
throw new NotImplementedException();
#else
// Debugging or low trust path.
ScriptEngine.ReflectionEmitModuleInfo reflectionEmitInfo = this.Engine.ReflectionEmitInfo;
if (reflectionEmitInfo == null)
{
reflectionEmitInfo = new ScriptEngine.ReflectionEmitModuleInfo();
// Create a dynamic assembly and module.
reflectionEmitInfo.AssemblyBuilder = System.Threading.Thread.GetDomain().DefineDynamicAssembly(
new System.Reflection.AssemblyName("Jurassic Dynamic Assembly"), System.Reflection.Emit.AssemblyBuilderAccess.Run);
// Mark the assembly as debuggable. This must be done before the module is created.
var debuggableAttributeConstructor = typeof(System.Diagnostics.DebuggableAttribute).GetConstructor(
new Type[] { typeof(System.Diagnostics.DebuggableAttribute.DebuggingModes) });
reflectionEmitInfo.AssemblyBuilder.SetCustomAttribute(
new System.Reflection.Emit.CustomAttributeBuilder(debuggableAttributeConstructor,
new object[] {
System.Diagnostics.DebuggableAttribute.DebuggingModes.DisableOptimizations |
System.Diagnostics.DebuggableAttribute.DebuggingModes.Default }));
// Create a dynamic module.
reflectionEmitInfo.ModuleBuilder = reflectionEmitInfo.AssemblyBuilder.DefineDynamicModule("Module", this.Options.EnableDebugging);
this.Engine.ReflectionEmitInfo = reflectionEmitInfo;
}
// Create a new type to hold our method.
var typeBuilder = reflectionEmitInfo.ModuleBuilder.DefineType("JavaScriptClass" + reflectionEmitInfo.TypeCount.ToString(), System.Reflection.TypeAttributes.Public | System.Reflection.TypeAttributes.Class);
reflectionEmitInfo.TypeCount++;
// Create a method.
var methodBuilder = typeBuilder.DefineMethod(this.GetMethodName(),
System.Reflection.MethodAttributes.HideBySig | System.Reflection.MethodAttributes.Static | System.Reflection.MethodAttributes.Public,
typeof(object), GetParameterTypes());
// Generate the IL for the method.
generator = new ReflectionEmitILGenerator(methodBuilder.GetILGenerator());
if (this.Engine.EnableILAnalysis == true)
{
// Replace the generator with one that logs.
generator = new LoggingILGenerator(generator);
}
if (this.Source.Path != null && this.Options.EnableDebugging == true)
{
// Initialize the debugging information.
optimizationInfo.DebugDocument = reflectionEmitInfo.ModuleBuilder.DefineDocument(this.Source.Path, COMHelpers.LanguageType, COMHelpers.LanguageVendor, COMHelpers.DocumentType);
methodBuilder.DefineParameter(1, System.Reflection.ParameterAttributes.None, "scriptEngine");
methodBuilder.DefineParameter(2, System.Reflection.ParameterAttributes.None, "scope");
methodBuilder.DefineParameter(3, System.Reflection.ParameterAttributes.None, "thisValue");
generator.MarkSequencePoint(optimizationInfo.DebugDocument, new SourceCodeSpan(1, 1, 1, 1));
}
GenerateCode(generator, optimizationInfo);
generator.Complete();
// Bake it.
var type = typeBuilder.CreateType();
var methodInfo = type.GetMethod(this.GetMethodName());
this.GeneratedMethod = new GeneratedMethod(Delegate.CreateDelegate(GetDelegate(), methodInfo), optimizationInfo.NestedFunctions);
#endif //WINDOWS_PHONE
}
if (this.Engine.EnableILAnalysis == true)
{
// Store the disassembled IL so it can be retrieved for analysis purposes.
this.GeneratedMethod.DisassembledIL = generator.ToString();
}
}
/// <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() { NonDefaultSourceSpanBehavior = true };
GenerateStartOfStatement(generator, optimizationInfo, statementLocals);
// Unlike in .NET, in javascript there are no restrictions on what can appear inside
// try, catch and finally blocks. The one restriction which causes problems is the
// inability to jump out of .NET finally blocks. This is required when break, continue
// or return statements appear inside of a finally block. To work around this, when
// inside a finally block these instructions throw an exception instead.
// Setting the InsideTryCatchOrFinally flag converts BR instructions into LEAVE
// instructions so that the finally block is executed correctly.
var previousInsideTryCatchOrFinally = optimizationInfo.InsideTryCatchOrFinally;
optimizationInfo.InsideTryCatchOrFinally = true;
// Finally requires two exception nested blocks.
if (this.FinallyBlock != null)
generator.BeginExceptionBlock();
// Begin the exception block.
generator.BeginExceptionBlock();
// Generate code for the try block.
this.TryBlock.GenerateCode(generator, optimizationInfo);
// Generate code for the catch block.
if (this.CatchBlock != null)
{
// Begin a catch block. The exception is on the top of the stack.
generator.BeginCatchBlock(typeof(JavaScriptException));
// Create a new DeclarativeScope.
this.CatchScope.GenerateScopeCreation(generator, optimizationInfo);
// Store the error object in the variable provided.
generator.Call(ReflectionHelpers.JavaScriptException_ErrorObject);
var catchVariable = new NameExpression(this.CatchScope, this.CatchVariableName);
catchVariable.GenerateSet(generator, optimizationInfo, PrimitiveType.Any, false);
// Make sure the scope is reverted even if an exception is thrown.
generator.BeginExceptionBlock();
// Emit code for the statements within the catch block.
this.CatchBlock.GenerateCode(generator, optimizationInfo);
// Revert the scope.
generator.BeginFinallyBlock();
this.CatchScope.GenerateScopeDestruction(generator, optimizationInfo);
generator.EndExceptionBlock();
}
// Generate code for the finally block.
if (this.FinallyBlock != null)
{
generator.BeginFinallyBlock();
var branches = new List<ILLabel>();
var previousStackSize = optimizationInfo.LongJumpStackSizeThreshold;
optimizationInfo.LongJumpStackSizeThreshold = optimizationInfo.BreakOrContinueStackSize;
var previousCallback = optimizationInfo.LongJumpCallback;
optimizationInfo.LongJumpCallback = (generator2, label) =>
{
// It is not possible to branch out of a finally block - therefore instead of
// generating LEAVE instructions we throw an exception then catch it to transfer
// control out of the finally block.
generator2.LoadInt32(branches.Count);
generator2.NewObject(ReflectionHelpers.LongJumpException_Constructor);
generator2.Throw();
// Record any branches that are made within the finally code.
branches.Add(label);
};
// Emit code for the finally block.
this.FinallyBlock.GenerateCode(generator, optimizationInfo);
// End the main exception block.
generator.EndExceptionBlock();
// Begin a catch block to catch any LongJumpExceptions. The exception object is on
// the top of the stack.
generator.BeginCatchBlock(typeof(LongJumpException));
if (branches.Count > 0)
{
// switch (exception.RouteID)
// {
// case 0: goto label1;
// case 1: goto label2;
// }
ILLabel[] switchLabels = new ILLabel[branches.Count];
for (int i = 0; i < branches.Count; i++)
switchLabels[i] = generator.CreateLabel();
generator.Call(ReflectionHelpers.LongJumpException_RouteID);
generator.Switch(switchLabels);
for (int i = 0; i < branches.Count; i++)
{
generator.DefineLabelPosition(switchLabels[i]);
generator.Leave(branches[i]);
}
}
// Reset the state we clobbered.
optimizationInfo.LongJumpStackSizeThreshold = previousStackSize;
optimizationInfo.LongJumpCallback = previousCallback;
}
// End the exception block.
generator.EndExceptionBlock();
// Reset the InsideTryCatchOrFinally flag.
optimizationInfo.InsideTryCatchOrFinally = previousInsideTryCatchOrFinally;
// Generate code for the end of the statement.
GenerateEndOfStatement(generator, optimizationInfo, statementLocals);
}
/// <summary>
/// Outputs the values needed to get or set this 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>
public void DuplicateReference(ILGenerator generator, OptimizationInfo optimizationInfo)
{
// Do nothing.
}
/// <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 == true)
{
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);
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;
}
else
{
// The variable was not defined at compile time, but may have been
// introduced by an eval() statement.
if (optimizationInfo.MethodOptimizationHints.HasEval == true)
{
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);
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);
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);
// TODO: share these variables somehow.
var cacheKey = generator.DeclareVariable(typeof(object));
var cachedIndex = generator.DeclareVariable(typeof(int));
// Store the object into a temp variable.
var objectInstance = generator.DeclareVariable(PrimitiveType.Object);
generator.StoreVariable(objectInstance);
// if (__object_cacheKey != object.InlineCacheKey)
generator.LoadVariable(cacheKey);
generator.LoadVariable(objectInstance);
generator.Call(ReflectionHelpers.ObjectInstance_InlineCacheKey);
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);
}
else
{
// Set the property value if the property exists.
generator.Call(ReflectionHelpers.ObjectInstance_InlineSetPropertyValueIfExists);
// 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);
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);
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_Object);
}
else
{
// Set the property value if the property exists.
generator.Call(ReflectionHelpers.ObjectInstance_SetPropertyValueIfExists);
// 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 == true)
{
if (scopeVariable == null)
{
scopeVariable = generator.CreateTemporaryVariable(typeof(Scope));
EmitHelpers.LoadScope(generator);
}
else
{
generator.LoadVariable(scopeVariable);
}
generator.Call(ReflectionHelpers.Scope_ParentScope);
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 == true)
EmitHelpers.EmitThrow(generator, ErrorType.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>
/// 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);
generator.LoadInt32(variable.Index);
generator.LoadArrayElement(typeof(object));
}
// The variable was found - no need to search any more parent scopes.
break;
}
else
{
// The variable was not defined at compile time, but may have been
// introduced by an eval() statement.
if (optimizationInfo.MethodOptimizationHints.HasEval == true)
{
// 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);
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);
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);
// TODO: share these variables somehow.
var cacheKey = generator.DeclareVariable(typeof(object));
var cachedIndex = generator.DeclareVariable(typeof(int));
// Store the object into a temp variable.
var objectInstance = generator.DeclareVariable(PrimitiveType.Object);
generator.StoreVariable(objectInstance);
// if (__object_cacheKey != object.InlineCacheKey)
generator.LoadVariable(cacheKey);
generator.LoadVariable(objectInstance);
generator.Call(ReflectionHelpers.ObjectInstance_InlineCacheKey);
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);
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);
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);
generator.LoadString(this.Name);
generator.Call(ReflectionHelpers.ObjectInstance_GetPropertyValue_Object);
// 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 == true)
{
if (scopeVariable == null)
{
scopeVariable = generator.CreateTemporaryVariable(typeof(Scope));
EmitHelpers.LoadScope(generator);
}
else
{
generator.LoadVariable(scopeVariable);
}
generator.Call(ReflectionHelpers.Scope_ParentScope);
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 == true)
EmitHelpers.EmitThrow(generator, ErrorType.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>
/// Deletes the reference and pushes <c>true</c> if the delete succeeded, or <c>false</c>
/// if the delete failed.
/// </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 void GenerateDelete(ILGenerator generator, OptimizationInfo optimizationInfo)
{
// Deleting a variable is not allowed in strict mode.
if (optimizationInfo.StrictMode == true)
throw new JavaScriptException(optimizationInfo.Engine, ErrorType.SyntaxError, string.Format("Cannot delete {0} because deleting a variable or argument is not allowed in strict mode", this.Name), optimizationInfo.SourceSpan.StartLine, optimizationInfo.Source.Path, optimizationInfo.FunctionName);
var endOfDelete = generator.CreateLabel();
var scope = this.Scope;
ILLocalVariable scopeVariable = generator.CreateTemporaryVariable(typeof(Scope));
EmitHelpers.LoadScope(generator);
generator.StoreVariable(scopeVariable);
do
{
if (scope is DeclarativeScope)
{
var variable = scope.GetDeclaredVariable(this.Name);
if (variable != null)
{
// The variable is known at compile-time.
if (variable.Deletable == false)
{
// The variable cannot be deleted - return false.
generator.LoadBoolean(false);
}
else
{
// The variable can be deleted (it was declared inside an eval()).
// Delete the variable.
generator.LoadVariable(scopeVariable);
generator.CastClass(typeof(DeclarativeScope));
generator.LoadString(this.Name);
generator.Call(ReflectionHelpers.Scope_Delete);
}
break;
}
else
{
// The variable was not defined at compile time, but may have been
// introduced by an eval() statement.
if (optimizationInfo.MethodOptimizationHints.HasEval == true)
{
// Check the variable exists: if (scope.HasValue(variableName) == true) {
generator.LoadVariable(scopeVariable);
generator.CastClass(typeof(DeclarativeScope));
generator.LoadString(this.Name);
generator.Call(ReflectionHelpers.Scope_HasValue);
var hasValueClause = generator.CreateLabel();
generator.BranchIfFalse(hasValueClause);
// If the variable does exist, return true.
generator.LoadVariable(scopeVariable);
generator.CastClass(typeof(DeclarativeScope));
generator.LoadString(this.Name);
generator.Call(ReflectionHelpers.Scope_Delete);
generator.Branch(endOfDelete);
// }
generator.DefineLabelPosition(hasValueClause);
}
}
}
else
{
// Check if the property exists by calling scope.ScopeObject.HasProperty(propertyName)
generator.LoadVariable(scopeVariable);
generator.CastClass(typeof(ObjectScope));
generator.Call(ReflectionHelpers.ObjectScope_ScopeObject);
generator.Duplicate();
generator.LoadString(this.Name);
generator.Call(ReflectionHelpers.ObjectInstance_HasProperty);
// Jump past the delete if the property doesn't exist.
var endOfExistsCheck = generator.CreateLabel();
generator.BranchIfFalse(endOfExistsCheck);
// Call scope.ScopeObject.Delete(key, false)
generator.LoadString(this.Name);
generator.LoadBoolean(false);
generator.Call(ReflectionHelpers.ObjectInstance_Delete);
generator.Branch(endOfDelete);
generator.DefineLabelPosition(endOfExistsCheck);
generator.Pop();
// If the name is not defined, return true.
if (scope.ParentScope == null)
{
generator.LoadBoolean(true);
}
}
// Try the parent scope.
if (scope.ParentScope != null && scope.ExistsAtRuntime == true)
{
generator.LoadVariable(scopeVariable);
generator.Call(ReflectionHelpers.Scope_ParentScope);
generator.StoreVariable(scopeVariable);
}
scope = scope.ParentScope;
} while (scope != null);
// Release the temporary variable.
generator.ReleaseTemporaryVariable(scopeVariable);
// Define a label at the end.
generator.DefineLabelPosition(endOfDelete);
// Delete obviously has side-effects so we evaluate the return value then pop it from
// the stack.
//if (optimizationInfo.SuppressReturnValue == true)
// generator.Pop();
}
/// <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)
{
// NOTE: this is a get reference because assignment expressions do not call this method.
GenerateGet(generator, optimizationInfo, true);
}
