internal protected override Expression ToExpression(OverloadResolver resolver, RestrictedArguments args, bool[] hasBeenUsed) { if (_tmp == null) { _tmp = resolver.GetTemporary(_elementType, "outParam"); } Debug.Assert(!hasBeenUsed[Index]); hasBeenUsed[Index] = true; Expression arg = args.GetObject(Index).Expression; return(Expression.Condition( Expression.TypeIs(arg, Type), Expression.Assign( _tmp, Expression.Field( AstUtils.Convert(arg, Type), Type.GetField("Value") ) ), Expression.Throw( Expression.Call( new Func <Type, object, Exception>(RuntimeHelpers.MakeIncorrectBoxTypeError).Method, AstUtils.Constant(_elementType), AstUtils.Convert(arg, typeof(object)) ), _elementType ) )); }
public override Expression ToExpression(OverloadResolver resolver, RestrictedArguments args, bool[] hasBeenUsed) { if (_isRef) { return(_tmp ?? (_tmp = resolver.GetTemporary(_parameterType, "outParam"))); } return(GetDefaultValue()); }
internal protected override Expression ToExpression(OverloadResolver resolver, RestrictedArguments args, bool[] hasBeenUsed) { if (_tmp == null) { _tmp = resolver.GetTemporary(Type, "outParam"); } return(Ast.Block(Ast.Assign(_tmp, base.ToExpression(resolver, args, hasBeenUsed)), _tmp)); }
private Expression[] GetArgumentExpressions(RestrictedArguments restrictedArgs, out bool[] usageMarkers, out Expression[] spilledArgs) { int minPriority = Int32.MaxValue; int maxPriority = Int32.MinValue; foreach (ArgBuilder ab in _argBuilders) { minPriority = System.Math.Min(minPriority, ab.Priority); maxPriority = System.Math.Max(maxPriority, ab.Priority); } var args = new Expression[_argBuilders.Count]; Expression[] actualArgs = null; usageMarkers = new bool[restrictedArgs.Length]; for (int priority = minPriority; priority <= maxPriority; priority++) { for (int i = 0; i < _argBuilders.Count; i++) { if (_argBuilders[i].Priority == priority) { args[i] = _argBuilders[i].ToExpression(_resolver, restrictedArgs, usageMarkers); // see if this has a temp that needs to be passed as the actual argument Expression byref = _argBuilders[i].ByRefArgument; if (byref != null) { if (actualArgs == null) { actualArgs = new Expression[_argBuilders.Count]; } actualArgs[i] = byref; } } } } if (actualArgs != null) { for (int i = 0; i < args.Length; i++) { if (args[i] != null && actualArgs[i] == null) { actualArgs[i] = _resolver.GetTemporary(args[i].Type, null); args[i] = Expression.Assign(actualArgs[i], args[i]); } } spilledArgs = RemoveNulls(args); return(RemoveNulls(actualArgs)); } spilledArgs = null; return(RemoveNulls(args)); }
internal override Expression ToExpression(OverloadResolver resolver, IList <ArgBuilder> builders, RestrictedArguments args, Expression ret) { List <Expression> sets = new List <Expression>(); ParameterExpression tmp = resolver.GetTemporary(ret.Type, "val"); sets.Add( Ast.Assign(tmp, ret) ); for (int i = 0; i < _indexesUsed.Length; i++) { Expression value = args.GetObject(args.Length - _kwArgCount + _indexesUsed[i]).Expression; PropertyInfo pi; FieldInfo fi; if ((fi = _membersSet[i] as FieldInfo) != null) { if (!fi.IsLiteral && !fi.IsInitOnly) { sets.Add( Ast.Assign( Ast.Field(tmp, fi), ConvertToHelper(resolver, value, fi.FieldType) ) ); } else { // call a helper which throws the error but "returns object" sets.Add( Ast.Convert( Ast.Call( typeof(ScriptingRuntimeHelpers).GetMethod("ReadOnlyAssignError"), AstUtils.Constant(true), AstUtils.Constant(fi.Name) ), fi.FieldType ) ); } } else if ((pi = _membersSet[i] as PropertyInfo) != null) { if (pi.GetSetMethod(_privateBinding) != null) { sets.Add( Ast.Assign( Ast.Property(tmp, pi), ConvertToHelper(resolver, value, pi.PropertyType) ) ); } else { // call a helper which throws the error but "returns object" sets.Add( Ast.Convert( Ast.Call( typeof(ScriptingRuntimeHelpers).GetMethod("ReadOnlyAssignError"), AstUtils.Constant(false), AstUtils.Constant(pi.Name) ), pi.PropertyType ) ); } } } sets.Add( tmp ); Expression newCall = Ast.Block( sets.ToArray() ); return(_builder.ToExpression(resolver, builders, args, newCall)); }
internal protected override Expression ToExpression(OverloadResolver resolver, RestrictedArguments args, bool[] hasBeenUsed) { var actualArgs = resolver.GetActualArguments(); int splatIndex = actualArgs.SplatIndex; int collapsedCount = actualArgs.CollapsedCount; int firstSplatted = actualArgs.FirstSplattedArg; var result = new Expression[2 + _expandedCount + (collapsedCount > 0 ? 2 : 0)]; var arrayVariable = resolver.GetTemporary(_elementType.MakeArrayType(), "a"); int e = 0; result[e++] = Ast.Assign(arrayVariable, Ast.NewArrayBounds(_elementType, Ast.Constant(_expandedCount + collapsedCount))); int itemIndex = 0; int i = _start; while (true) { // inject loop copying collapsed items: if (i == splatIndex) { var indexVariable = resolver.GetTemporary(typeof(int), "t"); // for (int t = 0; t <= {collapsedCount}; t++) { // a[{itemIndex} + t] = CONVERT<ElementType>(list.get_Item({splatIndex - firstSplatted} + t)) // } result[e++] = Ast.Assign(indexVariable, AstUtils.Constant(0)); result[e++] = AstUtils.Loop( Ast.LessThan(indexVariable, Ast.Constant(collapsedCount)), // TODO: not implemented in the old interpreter // Ast.PostIncrementAssign(indexVariable), Ast.Assign(indexVariable, Ast.Add(indexVariable, AstUtils.Constant(1))), Ast.Assign( Ast.ArrayAccess(arrayVariable, Ast.Add(AstUtils.Constant(itemIndex), indexVariable)), resolver.Convert( new DynamicMetaObject( resolver.GetSplattedItemExpression(Ast.Add(AstUtils.Constant(splatIndex - firstSplatted), indexVariable)), BindingRestrictions.Empty ), null, ParameterInfo, _elementType ) ), null ); itemIndex += collapsedCount; } if (i >= _start + _expandedCount) { break; } Debug.Assert(!hasBeenUsed[i]); hasBeenUsed[i] = true; result[e++] = Ast.Assign( Ast.ArrayAccess(arrayVariable, AstUtils.Constant(itemIndex++)), resolver.Convert(args.GetObject(i), args.GetType(i), ParameterInfo, _elementType) ); i++; } result[e++] = arrayVariable; Debug.Assert(e == result.Length); return(Ast.Block(result)); }