|
public MarkSequencePoint ( |
||
| generator | The IL generator used to emit the sequence point. | |
| span | Jurassic.Compiler.SourceCodeSpan | The source code span. |
| Результат | void | |
/// <summary>
/// Generates CIL for the start 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 GenerateStartOfStatement(ILGenerator generator, OptimizationInfo optimizationInfo, StatementLocals locals)
{
#if DEBUG && !SILVERLIGHT
// Statements must not produce or consume any values on the stack.
if (generator is DynamicILGenerator)
{
locals.OriginalStackSize = ((DynamicILGenerator)generator).StackSize;
}
#endif
if (locals.NonDefaultBreakStatementBehavior == false && this.HasLabels == true)
{
// Set up the information needed by the break statement.
locals.EndOfStatement = generator.CreateLabel();
optimizationInfo.PushBreakOrContinueInfo(this.Labels, locals.EndOfStatement, null, labelledOnly: true);
}
// Emit debugging information.
if (locals.NonDefaultSourceSpanBehavior == false)
{
optimizationInfo.MarkSequencePoint(generator, this.SourceSpan);
}
}
/// <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;
optimizationInfo.FunctionName = this.GetStackName();
optimizationInfo.Source = this.Source;
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);
}
// Initialization code will appear to come from line 1.
optimizationInfo.MarkSequencePoint(generator, new SourceCodeSpan(1, 1, 1, 1));
// 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");
}
optimizationInfo.MarkSequencePoint(generator, 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();
}
}
//private struct RevertInfo
//{
// public PrimitiveType Type;
// public ILLocalVariable Variable;
//}
/// <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>
// start-of-loop:
// while (true) {
// if (<condition> == false)
// break;
//
// <body statements>
//
// continue-target:
// <increment>
//
// if (<condition> == false) // do {} while (condition) only.
// break;
// }
// break-target:
// Generate the scope variable if necessary.
if (this.Scope != null)
{
this.Scope.GenerateScopeCreation(generator, optimizationInfo);
}
// Emit the initialization statement.
if (this.InitStatement != null)
{
this.InitStatement.GenerateCode(generator, optimizationInfo);
}
// Set up some labels.
var continueTarget = generator.CreateLabel();
var breakTarget = generator.CreateLabel();
var startOfLoop = generator.DefineLabelPosition();
// 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(breakTarget);
}
// Emit the loop body.
optimizationInfo.PushBreakOrContinueInfo(this.Labels, breakTarget, continueTarget, labelledOnly: 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);
}
// Check the condition and jump to the end if it is false.
if (this.CheckConditionAtEnd && this.ConditionStatement != null)
{
optimizationInfo.MarkSequencePoint(generator, this.ConditionStatement.SourceSpan);
this.Condition.GenerateCode(generator, optimizationInfo);
EmitConversion.ToBool(generator, this.Condition.ResultType);
generator.BranchIfFalse(breakTarget);
}
// Unconditionally branch back to the start of the loop.
generator.Branch(startOfLoop);
// Define where the break statement jumps to.
generator.DefineLabelPosition(breakTarget);
// <initializer>
// if (<condition>)
// {
// <loop body>
// <increment>
// while (true) {
// if (<condition> == false)
// break;
//
// <body statements>
//
// continue-target:
// <increment>
// }
// }
// break-target:
// Set up some labels.
//var continueTarget1 = generator.CreateLabel();
//var continueTarget2 = 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, continueTarget1, false);
//this.Body.GenerateCode(generator, optimizationInfo);
//optimizationInfo.PopBreakOrContinueInfo();
//
//// The continue statement jumps here.
//generator.DefineLabelPosition(continueTarget1);
//
//// 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 == true)
//{
// // 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);
// 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, continueTarget2, labelledOnly: false);
//if (this.Body is BlockStatement blockStatement2)
// blockStatement2.GenerateScopeCreation = false;
//this.Body.GenerateCode(generator, optimizationInfo);
//optimizationInfo.PopBreakOrContinueInfo();
//
//// The continue statement jumps here.
//generator.DefineLabelPosition(continueTarget2);
//
//// 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 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 iterator = TypeUtilities.GetIterator(obj);
// while (true) {
// continue-target:
// if (enumerator.MoveNext() == false)
// goto break-target;
// lhs = enumerator.Current;
//
// <body statements>
// }
// break-target:
// Call: ObjectInstance GetIterator(ScriptEngine engine, ObjectInstance iterable)
// Then call: IEnumerable<object> Iterate(ScriptEngine engine, ObjectInstance iterator)
optimizationInfo.MarkSequencePoint(generator, this.TargetObjectSourceSpan);
EmitHelpers.LoadScriptEngine(generator);
this.TargetObject.GenerateCode(generator, optimizationInfo);
EmitConversion.ToAny(generator, this.TargetObject.ResultType);
generator.Call(ReflectionHelpers.TypeUtilities_ForOf);
// Call IEnumerable<object>.GetEnumerator()
generator.Call(ReflectionHelpers.IEnumerable_Object_GetEnumerator);
// Store the enumerator in a temporary variable.
var enumerator = generator.CreateTemporaryVariable(typeof(IEnumerator <object>));
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);
generator.BranchIfFalse(breakTarget);
// lhs = enumerator.Current;
this.Variable.GenerateReference(generator, optimizationInfo);
generator.LoadVariable(enumerator);
generator.Call(ReflectionHelpers.IEnumerator_Object_Current);
this.Variable.GenerateSet(generator, optimizationInfo, PrimitiveType.Any, 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 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;
optimizationInfo.FunctionName = this.GetStackName();
optimizationInfo.Source = this.Source;
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);
}
// Initialization code will appear to come from line 1.
optimizationInfo.MarkSequencePoint(generator, new SourceCodeSpan(1, 1, 1, 1));
// 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");
}
optimizationInfo.MarkSequencePoint(generator, 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 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();
optimizationInfo.AbstractSyntaxTree = this.AbstractSyntaxTree;
optimizationInfo.StrictMode = this.StrictMode;
optimizationInfo.MethodOptimizationHints = this.MethodOptimizationHints;
optimizationInfo.FunctionName = this.GetStackName();
optimizationInfo.Source = this.Source;
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 = 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.
#if USE_DYNAMIC_IL_INFO
generator = new DynamicILGenerator(dynamicMethod);
#else
generator = new ReflectionEmitILGenerator(dynamicMethod.GetILGenerator(), emitDebugInfo: false);
#endif
if (this.Options.EnableILAnalysis == true)
{
// Replace the generator with one that logs.
generator = new LoggingILGenerator(generator);
}
// Initialization code will appear to come from line 1.
optimizationInfo.MarkSequencePoint(generator, new SourceCodeSpan(1, 1, 1, 1));
// 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 ENABLE_DEBUGGING
// Debugging or low trust path.
ReflectionEmitModuleInfo reflectionEmitInfo;
System.Reflection.Emit.TypeBuilder typeBuilder;
lock (reflectionEmitInfoLock)
{
reflectionEmitInfo = ReflectionEmitInfo;
if (reflectionEmitInfo == null)
{
reflectionEmitInfo = new 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);
ReflectionEmitInfo = reflectionEmitInfo;
}
// Create a new type to hold our method.
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(), emitDebugInfo: true);
if (this.Options.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, LanguageType, LanguageVendor, DocumentType);
var parameterNames = GetParameterNames();
for (var i = 0; i < parameterNames.Length; i++)
{
methodBuilder.DefineParameter(i + 1, System.Reflection.ParameterAttributes.In, parameterNames[i]);
}
}
optimizationInfo.MarkSequencePoint(generator, 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);
#else
throw new NotImplementedException();
#endif // ENABLE_DEBUGGING
}
if (this.Options.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() { 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 == true)
{
// 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);
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, labelledOnly: 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 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);
// 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.VariableSourceSpan);
// 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 start 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 GenerateStartOfStatement(ILGenerator generator, OptimizationInfo optimizationInfo, StatementLocals locals)
{
#if DEBUG && !SILVERLIGHT
// Statements must not produce or consume any values on the stack.
if (generator is DynamicILGenerator)
locals.OriginalStackSize = ((DynamicILGenerator)generator).StackSize;
#endif
if (locals.NonDefaultBreakStatementBehavior == false && this.HasLabels == true)
{
// Set up the information needed by the break statement.
locals.EndOfStatement = generator.CreateLabel();
optimizationInfo.PushBreakOrContinueInfo(this.Labels, locals.EndOfStatement, null, labelledOnly: true);
}
// Emit debugging information.
if (locals.NonDefaultSourceSpanBehavior == false)
optimizationInfo.MarkSequencePoint(generator, this.SourceSpan);
}
/// <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);
// Call IEnumerable<string>.GetEnumerator()
generator.Call(ReflectionHelpers.IEnumerable_String_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();
// Generate the scope variable if necessary.
this.Scope.GenerateScopeCreation(generator, optimizationInfo);
// if (enumerator.MoveNext() == false)
// goto break-target;
generator.LoadVariable(enumerator);
generator.Call(ReflectionHelpers.IEnumerator_MoveNext);
generator.BranchIfFalse(breakTarget);
// lhs = enumerator.Current;
this.Variable.GenerateReference(generator, optimizationInfo);
generator.LoadVariable(enumerator);
generator.Call(ReflectionHelpers.IEnumerator_String_Current);
this.Variable.GenerateSet(generator, optimizationInfo, PrimitiveType.String);
// 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 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();
optimizationInfo.AbstractSyntaxTree = this.AbstractSyntaxTree;
optimizationInfo.StrictMode = this.StrictMode;
optimizationInfo.MethodOptimizationHints = this.MethodOptimizationHints;
optimizationInfo.FunctionName = this.GetStackName();
optimizationInfo.Source = this.Source;
// DynamicMethod requires full trust because of generator.LoadMethodPointer in the
// FunctionExpression class.
// Create a new dynamic method.
System.Reflection.Emit.DynamicMethod 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.
#if USE_DYNAMIC_IL_INFO
ILGenerator generator = new DynamicILGenerator(dynamicMethod);
#else
ILGenerator generator = new ReflectionEmitILGenerator(dynamicMethod, emitDebugInfo: false);
#endif
ILGenerator loggingILGenerator = null;
if (this.Options.EnableILAnalysis)
{
// Replace the generator with one that logs.
generator = loggingILGenerator = new LoggingILGenerator(generator);
}
#if DEBUG
// Replace the generator with one that verifies correctness.
generator = new VerifyingILGenerator(generator);
#endif
// Initialization code will appear to come from line 1.
optimizationInfo.MarkSequencePoint(generator, new SourceCodeSpan(1, 1, 1, 1));
// Generate the IL.
GenerateCode(generator, optimizationInfo);
generator.Complete();
// Create a delegate from the method.
this.GeneratedMethod = new GeneratedMethod(dynamicMethod.CreateDelegate(GetDelegate()), optimizationInfo.NestedFunctions);
if (loggingILGenerator != null)
{
// Store the disassembled IL so it can be retrieved for analysis purposes.
this.GeneratedMethod.DisassembledIL = loggingILGenerator.ToString();
}
}