|
public static ToPropertyKey ( |
||
| generator | The IL generator. | |
| fromType | PrimitiveType | The type to convert from. |
| return | void | |
/// <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, optimizationInfo);
// 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.ToPropertyKey(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 in operator.
/// </summary>
/// <param name="generator"> The generator to output the CIL to. </param>
/// <param name="optimizationInfo"> Information about any optimizations that should be performed. </param>
private void GenerateIn(ILGenerator generator, OptimizationInfo optimizationInfo)
{
// Emit the left-hand side expression and convert it to a string.
this.Left.GenerateCode(generator, optimizationInfo);
EmitConversion.ToPropertyKey(generator, this.Left.ResultType);
// Store the left-hand side expression in a temporary variable.
var temp = generator.CreateTemporaryVariable(typeof(object));
generator.StoreVariable(temp);
// Emit the right-hand side expression.
this.Right.GenerateCode(generator, optimizationInfo);
EmitConversion.ToAny(generator, this.Right.ResultType);
// Check the right-hand side is a javascript object - if not, throw an exception.
generator.Duplicate();
generator.IsInstance(typeof(ObjectInstance));
var endOfTypeCheck = generator.CreateLabel();
generator.BranchIfTrue(endOfTypeCheck);
// Throw an nicely formatted exception.
var rightValue = generator.CreateTemporaryVariable(typeof(object));
generator.StoreVariable(rightValue);
generator.LoadEnumValue(ErrorType.TypeError);
generator.LoadString("The in operator expected an object, but found '{0}' instead");
generator.LoadInt32(1);
generator.NewArray(typeof(object));
generator.Duplicate();
generator.LoadInt32(0);
generator.LoadVariable(rightValue);
generator.Call(ReflectionHelpers.TypeUtilities_TypeOf);
generator.StoreArrayElement(typeof(object));
generator.Call(ReflectionHelpers.String_Format);
generator.LoadInt32(optimizationInfo.SourceSpan.StartLine);
generator.LoadStringOrNull(optimizationInfo.Source.Path);
generator.LoadStringOrNull(optimizationInfo.FunctionName);
generator.NewObject(ReflectionHelpers.JavaScriptException_Constructor_Error);
generator.Throw();
generator.DefineLabelPosition(endOfTypeCheck);
generator.ReleaseTemporaryVariable(rightValue);
generator.ReinterpretCast(typeof(ObjectInstance));
// Load the left-hand side expression from the temporary variable.
generator.LoadVariable(temp);
// Call ObjectInstance.HasProperty(object)
generator.Call(ReflectionHelpers.ObjectInstance_HasProperty);
// Allow the temporary variable to be reused.
generator.ReleaseTemporaryVariable(temp);
}
/// <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 GenerateReference(ILGenerator generator, OptimizationInfo optimizationInfo)
{
string propertyName = null;
TypeOfMemberAccess memberAccessType = DetermineTypeOfMemberAccess(optimizationInfo, out propertyName);
if (memberAccessType == TypeOfMemberAccess.ArrayIndex)
{
// Array indexer
// -------------
// 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, optimizationInfo);
// Load the right-hand side and convert to a uint32.
var rhs = this.GetOperand(1);
rhs.GenerateCode(generator, optimizationInfo);
EmitConversion.ToUInt32(generator, rhs.ResultType);
}
else if (memberAccessType == TypeOfMemberAccess.Static)
{
// Named property access (e.g. x = y.property or x = y['property'])
// ----------------------------------------------------------------
// 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, optimizationInfo);
}
else
{
// Dynamic property access
// -----------------------
// 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, optimizationInfo);
// Load the value and convert it to a property key.
var rhs = this.GetOperand(1);
rhs.GenerateCode(generator, optimizationInfo);
EmitConversion.ToPropertyKey(generator, rhs.ResultType);
}
}
/// <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);
if (lhs is SuperExpression)
{
// Deleting a super reference is not allowed.
EmitHelpers.EmitThrow(generator, ErrorType.ReferenceError, "Unsupported reference to 'super'.");
generator.LoadNull(); // Extraneous, but helps with verification.
return;
}
lhs.GenerateCode(generator, optimizationInfo);
EmitConversion.ToObject(generator, lhs.ResultType, optimizationInfo);
// Load the property name and convert to a string.
var rhs = this.GetOperand(1);
if (this.OperatorType == OperatorType.MemberAccess)
{
// delete a.b
if (rhs is NameExpression nameExpession)
{
generator.LoadString(nameExpession.Name);
}
else
{
throw new SyntaxErrorException("Invalid member access", optimizationInfo.SourceSpan.StartLine, optimizationInfo.Source.Path, optimizationInfo.FunctionName);
}
}
else
{
// delete a['1']
rhs.GenerateCode(generator, optimizationInfo);
EmitConversion.ToPropertyKey(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)
{
// Literals cannot have side-effects so if a return value is not expected then generate
// nothing.
//if (optimizationInfo.SuppressReturnValue == true)
// return;
if (this.Value is int)
{
generator.LoadInt32((int)this.Value);
}
else if (this.Value is double)
{
generator.LoadDouble((double)this.Value);
}
else if (this.Value is string)
{
generator.LoadString((string)this.Value);
}
else if (this.Value is bool)
{
generator.LoadBoolean((bool)this.Value);
}
else if (this.Value is RegularExpressionLiteral)
{
// RegExp
var sharedRegExpVariable = optimizationInfo.GetRegExpVariable(generator, (RegularExpressionLiteral)this.Value);
var label1 = generator.CreateLabel();
var label2 = generator.CreateLabel();
// if (sharedRegExp == null) {
generator.LoadVariable(sharedRegExpVariable);
generator.LoadNull();
generator.BranchIfNotEqual(label1);
// sharedRegExp = Global.RegExp.Construct(source, flags)
EmitHelpers.LoadScriptEngine(generator);
generator.Call(ReflectionHelpers.ScriptEngine_RegExp);
generator.LoadString(((RegularExpressionLiteral)this.Value).Pattern);
generator.LoadString(((RegularExpressionLiteral)this.Value).Flags);
generator.Call(ReflectionHelpers.RegExp_Construct);
generator.Duplicate();
generator.StoreVariable(sharedRegExpVariable);
// } else {
generator.Branch(label2);
generator.DefineLabelPosition(label1);
// Global.RegExp.Construct(sharedRegExp, flags)
EmitHelpers.LoadScriptEngine(generator);
generator.Call(ReflectionHelpers.ScriptEngine_RegExp);
generator.LoadVariable(sharedRegExpVariable);
generator.LoadNull();
generator.Call(ReflectionHelpers.RegExp_Construct);
// }
generator.DefineLabelPosition(label2);
}
else if (this.Value == Null.Value)
{
// Null.
EmitHelpers.EmitNull(generator);
}
else if (this.Value == Undefined.Value)
{
// Undefined.
EmitHelpers.EmitUndefined(generator);
}
else if (this.Value is List <Expression> )
{
// Construct an array literal.
var arrayLiteral = (List <Expression>) this.Value;
// Operands for ArrayConstructor.New() are: an ArrayConstructor instance (ArrayConstructor), an array (object[])
// ArrayConstructor
EmitHelpers.LoadScriptEngine(generator);
generator.Call(ReflectionHelpers.ScriptEngine_Array);
// object[]
generator.LoadInt32(arrayLiteral.Count);
generator.NewArray(typeof(object));
for (int i = 0; i < arrayLiteral.Count; i++)
{
// Operands for StoreArrayElement() are: an array (object[]), index (int), value (object).
// Array
generator.Duplicate();
// Index
generator.LoadInt32(i);
// Value
var elementExpression = arrayLiteral[i];
if (elementExpression == null)
{
generator.LoadNull();
}
else
{
elementExpression.GenerateCode(generator, optimizationInfo);
EmitConversion.ToAny(generator, elementExpression.ResultType);
}
// Store the element value.
generator.StoreArrayElement(typeof(object));
}
// ArrayConstructor.New(object[])
generator.Call(ReflectionHelpers.Array_New);
}
else if (this.Value is List <KeyValuePair <Expression, Expression> > )
{
// This is an object literal.
var properties = (List <KeyValuePair <Expression, Expression> >) this.Value;
// Create a new object.
EmitHelpers.LoadScriptEngine(generator);
generator.Call(ReflectionHelpers.ScriptEngine_Object);
generator.Call(ReflectionHelpers.Object_Construct);
foreach (var keyValuePair in properties)
{
Expression propertyName = keyValuePair.Key;
Expression propertyValue = keyValuePair.Value;
generator.Duplicate();
// The key can be a property name or an expression that evaluates to a name.
propertyName.GenerateCode(generator, optimizationInfo);
EmitConversion.ToPropertyKey(generator, propertyName.ResultType);
var functionValue = propertyValue as FunctionExpression;
if (functionValue != null && functionValue.DeclarationType == FunctionDeclarationType.Getter)
{
// Add a getter to the object.
functionValue.GenerateCode(generator, optimizationInfo);
// Support the inferred function displayName property.
if (propertyName is LiteralExpression && ((LiteralExpression)propertyName).Value is string)
{
functionValue.GenerateDisplayName(generator, optimizationInfo, "get " + (string)((LiteralExpression)propertyName).Value, true);
}
generator.Call(ReflectionHelpers.ReflectionHelpers_SetObjectLiteralGetter);
}
else if (functionValue != null && functionValue.DeclarationType == FunctionDeclarationType.Setter)
{
// Add a setter to the object.
functionValue.GenerateCode(generator, optimizationInfo);
// Support the inferred function displayName property.
if (propertyName is LiteralExpression && ((LiteralExpression)propertyName).Value is string)
{
functionValue.GenerateDisplayName(generator, optimizationInfo, "set " + (string)((LiteralExpression)propertyName).Value, true);
}
generator.Call(ReflectionHelpers.ReflectionHelpers_SetObjectLiteralSetter);
}
else
{
// Add a new property to the object.
propertyValue.GenerateCode(generator, optimizationInfo);
// Support the inferred function displayName property.
if (propertyValue is FunctionExpression && propertyName is LiteralExpression && ((LiteralExpression)propertyName).Value is string)
{
((FunctionExpression)propertyValue).GenerateDisplayName(generator, optimizationInfo, (string)((LiteralExpression)propertyName).Value, false);
}
EmitConversion.ToAny(generator, propertyValue.ResultType);
generator.Call(ReflectionHelpers.ReflectionHelpers_SetObjectLiteralValue);
}
}
}
else
{
throw new NotImplementedException("Unknown literal type.");
}
}
/// <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 the class was named, then we need to create a new scope to hold the name.
if (Name != null)
{
Scope.GenerateScopeCreation(generator, optimizationInfo);
}
// engine
EmitHelpers.LoadScriptEngine(generator);
// name
generator.LoadStringOrNull(this.Name);
// extends
if (Extends == null)
{
generator.LoadNull();
}
else
{
Extends.GenerateCode(generator, optimizationInfo);
EmitConversion.ToAny(generator, Extends.ResultType);
}
// constructor
if (Constructor == null)
{
generator.LoadNull();
}
else
{
Constructor.GenerateCode(generator, optimizationInfo);
}
// ConstructClass(ScriptEngine engine, string name, object extends, FunctionInstance constructor)
generator.CallStatic(ReflectionHelpers.ReflectionHelpers_ConstructClass);
// Create a variable to hold the container instance value.
var containerVariable = generator.CreateTemporaryVariable(typeof(ObjectInstance));
foreach (var member in this.Members)
{
// class.InstancePrototype
generator.Duplicate();
if (!member.Name.IsStatic)
{
generator.Call(ReflectionHelpers.FunctionInstance_InstancePrototype);
}
// Store this in a variable so that FunctionExpression.GenerateCode can retrieve it.
generator.Duplicate();
generator.StoreVariable(containerVariable);
// The key can be a property name or an expression that evaluates to a name.
if (member.Name.HasStaticName)
{
generator.LoadString(member.Name.StaticName);
}
else
{
member.Name.ComputedName.GenerateCode(generator, optimizationInfo);
EmitConversion.ToPropertyKey(generator, member.Name.ComputedName.ResultType);
}
// Emit the function value.
member.ContainerVariable = containerVariable;
member.GenerateCode(generator, optimizationInfo);
member.ContainerVariable = null;
if (member.Name.IsGetter)
{
// Add a getter to the object.
generator.Call(ReflectionHelpers.ReflectionHelpers_SetClassGetter);
}
else if (member.Name.IsSetter)
{
// Add a setter to the object.
generator.Call(ReflectionHelpers.ReflectionHelpers_SetClassSetter);
}
else
{
// Add a new property to the object.
generator.Call(ReflectionHelpers.ReflectionHelpers_SetClassValue);
}
}
// Release the variable that we created above.
generator.ReleaseTemporaryVariable(containerVariable);
// Store the class name in the scope.
if (Name != null)
{
generator.Duplicate();
new NameExpression(Scope, Name).GenerateSet(generator, optimizationInfo, PrimitiveType.Object);
}
}
/// <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)
{
string propertyName = null;
bool isArrayIndex = false;
// Right-hand-side can be a property name (a.b)
if (this.OperatorType == OperatorType.MemberAccess)
{
var rhs = this.GetOperand(1) as NameExpression;
if (rhs == null)
{
throw new JavaScriptException(optimizationInfo.Engine, ErrorType.SyntaxError, "Invalid member access", optimizationInfo.SourceSpan.StartLine, optimizationInfo.Source.Path, optimizationInfo.FunctionName);
}
propertyName = rhs.Name;
}
// Or a constant indexer (a['b'])
if (this.OperatorType == OperatorType.Index)
{
var rhs = this.GetOperand(1) as LiteralExpression;
if (rhs != null && (PrimitiveTypeUtilities.IsNumeric(rhs.ResultType) || rhs.ResultType == PrimitiveType.String))
{
propertyName = TypeConverter.ToString(rhs.Value);
// Or a array index (a[0])
if (rhs.ResultType == PrimitiveType.Int32 || (propertyName != null && Library.ArrayInstance.ParseArrayIndex(propertyName) != uint.MaxValue))
{
isArrayIndex = true;
}
}
}
if (isArrayIndex == true)
{
// Array indexer
// -------------
// xxx = object[index]
// 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, optimizationInfo);
// Load the right-hand side and convert to a uint32.
var rhs = this.GetOperand(1);
rhs.GenerateCode(generator, optimizationInfo);
EmitConversion.ToUInt32(generator, rhs.ResultType);
// Call the indexer.
generator.Call(ReflectionHelpers.ObjectInstance_GetPropertyValue_Int);
}
else if (propertyName != null)
{
//// 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);
//// Call Get(string)
//generator.LoadString(propertyName);
//generator.Call(ReflectionHelpers.ObjectInstance_GetPropertyValue_String);
// Named property access (e.g. x = y.property)
// -------------------------------------------
// __object_cacheKey = null;
// __object_property_cachedIndex = 0;
// ...
// if (__object_cacheKey != object.InlineCacheKey)
// xxx = object.InlineGetPropertyValue("property", out __object_property_cachedIndex, out __object_cacheKey)
// else
// xxx = object.InlinePropertyValues[__object_property_cachedIndex];
// 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, optimizationInfo);
// 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(propertyName);
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);
}
else
{
// Dynamic property access
// -----------------------
// xxx = object.Get(x)
// 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, optimizationInfo);
// Load the value and convert it to a property key.
var rhs = this.GetOperand(1);
rhs.GenerateCode(generator, optimizationInfo);
EmitConversion.ToPropertyKey(generator, rhs.ResultType);
// Call Get(object)
generator.Call(ReflectionHelpers.ObjectInstance_GetPropertyValue_Object);
}
}
/// <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)
{
// Create a new object.
EmitHelpers.LoadScriptEngine(generator);
generator.Call(ReflectionHelpers.ScriptEngine_Object);
generator.Call(ReflectionHelpers.Object_Construct);
// Create a variable to hold the container instance value.
var containerVariable = generator.CreateTemporaryVariable(typeof(ObjectInstance));
generator.Duplicate();
generator.StoreVariable(containerVariable);
foreach (var property in this.Properties)
{
generator.Duplicate();
// The key can be a property name or an expression that evaluates to a name.
if (property.Name.HasStaticName)
{
generator.LoadString(property.Name.StaticName);
}
else
{
property.Name.ComputedName.GenerateCode(generator, optimizationInfo);
EmitConversion.ToPropertyKey(generator, property.Name.ComputedName.ResultType);
}
// Emit the property value.
if (property.Value is FunctionExpression functionExpression)
{
functionExpression.ContainerVariable = containerVariable;
property.Value.GenerateCode(generator, optimizationInfo);
generator.ReinterpretCast(typeof(UserDefinedFunction));
functionExpression.ContainerVariable = null;
}
else
{
property.Value.GenerateCode(generator, optimizationInfo);
EmitConversion.ToAny(generator, property.Value.ResultType);
}
if (property.Name.IsGetter)
{
// Add a getter to the object.
generator.Call(ReflectionHelpers.ReflectionHelpers_SetObjectLiteralGetter);
}
else if (property.Name.IsSetter)
{
// Add a setter to the object.
generator.Call(ReflectionHelpers.ReflectionHelpers_SetObjectLiteralSetter);
}
else
{
// Add a new property to the object.
generator.Call(ReflectionHelpers.ReflectionHelpers_SetObjectLiteralValue);
}
}
// Release the variable that we created above.
generator.ReleaseTemporaryVariable(containerVariable);
}