public PostfixSelectVisitor(LE.ParameterExpression row, Func<String, IProjection> projectionCreator) { projections = new List<IProjection>(); ProjectionsPropertyNames = new List<String>(); this.projectionCreator = projectionCreator; this.row = row; }
public static MemberMemberBinding Serialize(E.MemberMemberBinding binding) { return new MemberMemberBinding() { Member = MemberRef.Serialize(binding.Member), Bindings = binding.Bindings.Select(Serialize).ToArray(), }; }
public static ElementInit Serialize(E.ElementInit elementInit) { return new ElementInit() { AddMethod = MethodRef.Serialize(elementInit.AddMethod), Arguments = elementInit.Arguments.Select(Node.Serialize).ToArray(), }; }
public override MSAst.Expression GetGlobal(MSAst.Expression globalContext, int arrayIndex, TotemVariable variable, TotemGlobal global) { return new LookupGlobalVariable( globalContext, variable.Name, variable.Kind == VariableKind.Local ); }
public static MemberListBinding Serialize(E.MemberListBinding binding) { return new MemberListBinding() { Member = MemberRef.Serialize(binding.Member), Initializers = binding.Initializers.Select(ElementInit.Serialize).ToArray(), }; }
public static MemberAssignment Serialize(E.MemberAssignment binding) { return new MemberAssignment() { Member = MemberRef.Serialize(binding.Member), Expression = Node.Serialize(binding.Expression), }; }
public GroupVisitor( LE.ParameterExpression row, Int32 currentColumnIndex) { projections = new List<IProjection>(); ProjectionsPropertyNames = new List<String>(); this.row = row; }
internal static SwitchCase Serialize(E.SwitchCase @case) { return new SwitchCase() { TestValues = @case.TestValues.Select(Node.Serialize).ToArray(), Body = Node.Serialize(@case.Body), }; }
public static SymbolDocumentInfo Serialize(E.SymbolDocumentInfo document) { return new SymbolDocumentInfo() { FileName = document.FileName, Language = document.Language, LanguageVendor = document.LanguageVendor, DocumentType = document.DocumentType, }; }
internal static LabelTarget Serialize(E.LabelTarget target) { return new LabelTarget() { Name = target.Name, Type = target.Type != typeof(void) ? TypeRef.Serialize(target.Type) : null, }; }
static MSAst.ExpressionType GetOp(MSAst.ExpressionType assignOp) { switch (assignOp) { case MSAst.ExpressionType.Assign: default: return MSAst.ExpressionType.Default; case MSAst.ExpressionType.AddAssign: return MSAst.ExpressionType.Add; case MSAst.ExpressionType.SubtractAssign: return MSAst.ExpressionType.Subtract; } }
internal static CatchBlock Serialize(E.CatchBlock handler) { return new CatchBlock() { Test = handler.Variable == null ? TypeRef.Serialize(handler.Test) : null, Variable = handler.Variable.Null(v => Node.Parameter(v)), Filter = handler.Filter.Null(e => Node.Serialize(e)), Body = Node.Serialize(handler.Body), }; }
public override MSAst.Expression GetGlobal(MSAst.Expression globalContext, int arrayIndex, TotemVariable variable, TotemGlobal global) { Assert.NotNull(global); return new TotemGlobalVariableExpression( Ast.ArrayIndex( TotemAst._globalArray, Ast.Constant(arrayIndex) ), variable, global ); }
public static MemberBinding Serialize(E.MemberBinding binding) { switch (binding.BindingType) { case E.MemberBindingType.Assignment: return MemberAssignment.Serialize((E.MemberAssignment) binding); case E.MemberBindingType.MemberBinding: return MemberMemberBinding.Serialize((E.MemberMemberBinding) binding); case E.MemberBindingType.ListBinding: return MemberListBinding.Serialize((E.MemberListBinding) binding); default: throw new ArgumentOutOfRangeException("binding.BindingType"); } }
internal override MSAst.Expression TransformSet(SourceSpan span, MSAst.Expression right, MSAst.ExpressionType op) { if (op != MSAst.ExpressionType.Default) { right = GlobalParent.Operation( typeof(object), op, this, right ); } var index = GlobalParent.SetIndex(new[] { _target, Parent.LocalContext }.Concat(_indexes).Concat(new[] { right }).ToArray()); return GlobalParent.AddDebugInfo(index, Span); }
internal override MSAst.Expression TransformSet(SourceSpan span, MSAst.Expression right, MSAst.ExpressionType op) { if (op != MSAst.ExpressionType.Default) { right = GlobalParent.Operation( typeof(object), op, this, right ); } var index = GlobalParent.Set(_name, _target, right); return GlobalParent.AddDebugInfo(index, Span); }
/*!*/ public MSAst.Expression Dynamic(DynamicMetaObjectBinder/*!*/ binder, Type/*!*/ retType, MSAst.Expression/*!*/ arg0) { if (retType == typeof(object)) { throw new NotImplementedException(); //return new TotemDynamicExpression1(binder, this, arg0); } else if (retType == typeof(bool)) { throw new NotImplementedException(); //return new TotemDynamicExpression1<bool>(binder, this, arg0); } return ReduceDynamic(binder, retType, arg0); }
private MSAst.Expression ReduceWorker(MSAst.Expression expression) { if (Parent.PrintExpressions) { MSAst.Expression printable = ConvertIfNeeded(expression, typeof(object)); if (printable.Type != typeof(string)) { printable = GlobalParent.Convert(typeof(string), ConversionResultKind.ExplicitCast, printable); } expression = Ast.Call( AstMethods.PrintExpressionValue, Parent.LocalContext, printable ); } return GlobalParent.AddDebugInfoAndVoid(expression, _expression.Span); }
public void OverloadResolution_Block1() { var scope = Context.EmptyScope; var proc = new Proc(ProcKind.Proc, null, scope, new BlockDispatcher0(BlockSignatureAttributes.None, null, 0). SetMethod(new BlockCallTarget0((x, y) => null))); var arguments = new[] { // 1.times new CallArguments(Context, MO(scope), new[] { MO(1) }, RubyCallSignature.WithScope(0)), // 1.times &nil new CallArguments(Context, MO(scope), new[] { MO(1), MO(null) }, RubyCallSignature.WithScopeAndBlock(0)), // 1.times &p new CallArguments(Context, MO(1), new[] { MO(proc) }, RubyCallSignature.WithBlock(0)), // obj.times &p new CallArguments(Context, MO("foo"), new[] { MO(proc) }, RubyCallSignature.WithBlock(0)), }; var results = new[] { "Times2", "Times1", "Times3", "Times4", }; var metaBuilder = new MetaObjectBuilder(null); for (int i = 0; i < arguments.Length; i++) { RubyOverloadResolver resolver; var methods = GetStaticMethodsStartingWith(typeof(OverloadsWithBlock), "Times"); var bindingTarget = RubyMethodGroupInfo.ResolveOverload( metaBuilder, arguments[i], "times", methods, SelfCallConvention.SelfIsParameter, false, out resolver ); Assert(bindingTarget.Success); Assert(bindingTarget.Overload.Name == results[i]); } }
private DLR.Expression BuildPickAssign(AplusScope scope, DLR.Expression value) { DyadicFunction function = (DyadicFunction)this.target; bool isValueinContext = Node.TestDyadicToken(function.Left, Grammar.Tokens.VALUEINCONTEXT); bool isValue = Node.TestMonadicToken(function.Right, Grammar.Tokens.VALUE); if (!(function.Right is Identifier || isValueinContext || isValue)) { throw new ParseException("assign pick target", false); } DLR.Expression left = function.Left.Generate(scope); scope.IsAssignment = true; DLR.Expression right = function.Right.Generate(scope); scope.IsAssignment = false; var method = DyadicFunctionInstance.Pick; DLR.Expression pickDLR = DLR.Expression.Call( DLR.Expression.Constant(method), method.GetType().GetMethod("AssignExecute"), right, left, scope.GetRuntimeExpression() ); DLR.ParameterExpression errorParam = DLR.Expression.Parameter(typeof(Error.Signal)); var flags = System.Reflection.BindingFlags.NonPublic | System.Reflection.BindingFlags.Static; DLR.ParameterExpression temp = DLR.Expression.Parameter(typeof(AType)); DLR.Expression callback = BuildCallbackCall(scope, temp); DLR.Expression presetCallback = BuildPresetCallbackCall(scope, temp); DLR.Expression result = DLR.Expression.Block( new DLR.ParameterExpression[] { temp }, DLR.Expression.Assign(scope.CallbackInfo.Path, left), DLR.Expression.Assign(temp, value), DLR.Expression.Assign(scope.AssignDone, DLR.Expression.Constant(false)), DLR.Expression.TryCatch( DLR.Expression.Block( typeof(void), DLR.Expression.Assign(temp, presetCallback), DLR.Expression.Assign(scope.AssignDone, DLR.Expression.Constant(true)) ), DLR.Expression.Catch( errorParam, DLR.Expression.Empty() ) ), DLR.Expression.IfThen( scope.AssignDone, DLR.Expression.Block( DLR.Expression.Call( typeof(Assign).GetMethod("PickAssignHelper", flags), temp, pickDLR ), callback ) ), scope.CallbackInfo.NonPresetValue ); return result; }
/// <summary> /// Build DLR expression for: (,target)[indexExpression] /// </summary> /// <param name="scope"></param> /// <param name="target"></param> /// <param name="indexExpression">The indexer expression containing the expression returned from <see cref="BuildIndicesList"/></param> /// <returns></returns> internal static DLR.Expression BuildIndexing(AplusScope scope, DLR.Expression target, DLR.Expression indexExpression) { var execute = typeof(AbstractMonadicFunction).GetMethod("Execute"); DLR.ParameterExpression indexes = DLR.Expression.Parameter(typeof(List<AType>), "_INDEX_"); // (,x) DLR.Expression raveledRight = DLR.Expression.Call( DLR.Expression.Constant(MonadicFunctionInstance.Ravel), execute, target, scope.GetRuntimeExpression() ); // (,x)[indexExpression] := .. DLR.Expression result = DLR.Expression.Convert( DLR.Expression.Block( new DLR.ParameterExpression[] { indexes }, DLR.Expression.Assign( indexes, DLR.Expression.Call( typeof(Helpers).GetMethod("BuildIndexerArray"), DLR.Expression.NewArrayInit(typeof(AType), indexExpression) ) ), DLR.Expression.Assign( scope.CallbackInfo.Index, DLR.Expression.Call( typeof(Tools).GetMethod("ConvertATypeListToAType", BindingFlags.NonPublic | BindingFlags.Static), indexes ) ), DLR.Expression.Dynamic( scope.GetRuntime().GetIndexBinder(new DYN.CallInfo(1)), typeof(object), raveledRight, indexes ) ), typeof(AType) ); return result; }
/// <summary> /// Builds DLR expression for: (iota rho argument) /// </summary> /// <param name="scope"></param> /// <param name="argument"></param> /// <returns></returns> internal static DLR.Expression BuildIndicesList(AplusScope scope, DLR.Expression argument) { DLR.ParameterExpression environment = scope.GetRuntimeExpression(); var execute = typeof(AbstractMonadicFunction).GetMethod("Execute"); // (iota rho x) DLR.Expression indexes = DLR.Expression.Call( DLR.Expression.Constant(MonadicFunctionInstance.Interval), execute, DLR.Expression.Call( DLR.Expression.Constant(MonadicFunctionInstance.Shape), execute, argument, environment ), environment ); return indexes; }
internal static DLR.Expression BuildCallbackCall(AplusScope scope, DLR.ParameterExpression valueParam) { // callback /* * CallbackItem callback; * if(CallbackManager.TryGetCallback(globalName, out callback) * { * CallbackBinder.Invoke(...); * } */ DLR.ParameterExpression callbackParameter = DLR.Expression.Parameter(typeof(CallbackItem), "__CALLBACK__"); DLR.Expression callback = DLR.Expression.Block( new DLR.ParameterExpression[] { callbackParameter }, DLR.Expression.IfThen( DLR.Expression.Call( scope.GetRuntimeExpression().Property("CallbackManager"), typeof(CallbackManager).GetMethod("TryGetCallback"), scope.CallbackInfo.QualifiedName, callbackParameter ), DLR.Expression.Dynamic( // TODO: do not instantiate the binder here new Runtime.Binder.CallbackBinder(), typeof(object), callbackParameter, scope.GetRuntimeExpression(), valueParam, scope.CallbackInfo.Index, scope.CallbackInfo.Path ) ) ); return callback; }
internal static DLR.Expression BuildPresetCallbackCall(AplusScope scope, DLR.ParameterExpression valueParam) { DLR.ParameterExpression callbackParameter = DLR.Expression.Parameter(typeof(CallbackItem), "__CALLBACK__"); DLR.Expression callback = DLR.Expression.Block( new DLR.ParameterExpression[] { callbackParameter }, DLR.Expression.Condition( DLR.Expression.Call( scope.GetRuntimeExpression().Property("CallbackManager"), typeof(CallbackManager).GetMethod("TryGetPresetCallback"), scope.CallbackInfo.QualifiedName, callbackParameter ), DLR.Expression.Dynamic( // TODO: do not instantiate the binder here new Runtime.Binder.CallbackBinder(), typeof(object), callbackParameter, scope.GetRuntimeExpression(), valueParam, scope.CallbackInfo.Index, scope.CallbackInfo.Path ).To<AType>(), (DLR.Expression)valueParam.To<AType>() ) ); return callback; }
internal static DLR.Expression GenerateIdentifierAssign( AplusScope scope, Identifier target, DLR.Expression value, bool isStrand = false, bool needCallback = true) { Aplus runtime = scope.GetRuntime(); DLR.Expression result = null; if (scope.IsMethod) { string qualifiedName = target.BuildQualifiedName(runtime.CurrentContext); // If the generation is inside of a method // check if it has the variablename as function parameter DLR.Expression functionParameter = scope.FindIdentifier(target.Name); if (functionParameter != null) { // Found variable as a function parameter, do a simple assign // the variable is already defined in AST.UserDefFunction return DLR.Expression.Assign(functionParameter, value); } DLR.Expression functionScopeParam = scope.GetModuleExpression(); DLR.Expression globalScopeParam = scope.Parent.GetModuleExpression(); switch (target.Type) { case IdentifierType.UnQualifiedName: // Need to check if we are inside an eval block: if (scope.IsEval) { // Code is inside an eval block, we behave slightly differently! #region description about what are we doing in this case // // Check if the variable exists in the function's scope // |-> Exists: set that variable's value // |-> otherwise: set the global variable's value // // if(((IDictionary<String, Object>)($FunctionScope).ContainsKey($VARIABLE)) // { // $FunctionScope.$VARIABLE = $VALUE; // } // else // { // $GlobalScope.$VARIABLE = $VALUE; // } // #endregion result = DLR.Expression.Condition( // Check if the varaible exists in the function scope DLR.Expression.Call( DLR.Expression.Convert(functionScopeParam, typeof(IDictionary<string, object>)), typeof(IDictionary<string, object>).GetMethod("ContainsKey"), DLR.Expression.Constant(target.Name) ), // found the variable in function scope, so assign a value to it DLR.Expression.Block( needCallback ? DLR.Expression.Assign(scope.CallbackInfo.QualifiedName, DLR.Expression.Constant(qualifiedName)) : (DLR.Expression)DLR.Expression.Empty(), DLR.Expression.Dynamic( runtime.SetMemberBinder(target.Name), typeof(object), functionScopeParam, value ), value ), // did NOT found the variable in the function scope // perform the assignment in the global scope BuildGlobalAssignment(scope, runtime, globalScopeParam, target, value, isStrand, needCallback) ); } else if (target.IsEnclosed) { result = BuildGlobalAssignment(scope, runtime, globalScopeParam, target, value, isStrand, needCallback); } else { // Simple case, we are inside a user defined function, but not inside an eval block result = DLR.Expression.Block( needCallback ? DLR.Expression.Assign(scope.CallbackInfo.QualifiedName, DLR.Expression.Constant(qualifiedName)) : (DLR.Expression)DLR.Expression.Empty(), DLR.Expression.Dynamic( runtime.SetMemberBinder(target.Name), typeof(object), functionScopeParam, value ) ); } break; case IdentifierType.QualifiedName: case IdentifierType.SystemName: default: // Do an assignment on the global scope result = BuildGlobalAssignment(scope, runtime, globalScopeParam, target, value, isStrand, needCallback); break; } } else { result = BuildGlobalAssignment(scope, runtime, scope.GetModuleExpression(), target, value, isStrand, needCallback); } return DLR.Expression.Convert(result, typeof(AType)); }
private static DLR.Expression GenerateIndexAssign(AplusScope scope, Indexing target, DLR.Expression value) { DLR.Expression result; if (target.IndexExpression == null) { result = DLR.Expression.Dynamic( scope.GetRuntime().SetIndexBinder(new DYN.CallInfo(0)), typeof(object), target.Item.Generate(scope), DLR.Expression.Constant(null), value ); } else { IEnumerable<DLR.Expression> indexerValues = target.IndexExpression.Items.Reverse().Select( item => { return item.Generate(scope); } ); DLR.ParameterExpression indexerParam = DLR.Expression.Parameter(typeof(List<AType>), "__INDEX__"); DLR.Expression call = DLR.Expression.Call( typeof(Helpers).GetMethod("BuildIndexerArray"), DLR.Expression.NewArrayInit(typeof(AType), indexerValues) ); Aplus runtime = scope.GetRuntime(); string qualifiedName = ((Identifier)target.Item).BuildQualifiedName(runtime.CurrentContext); DLR.ParameterExpression temp = DLR.Expression.Parameter(typeof(AType)); DLR.ParameterExpression errorParam = DLR.Expression.Parameter(typeof(Error.Signal)); DLR.Expression callback = BuildCallbackCall(scope, temp); DLR.Expression presetCallback = BuildPresetCallbackCall(scope, temp); result = DLR.Expression.Block( new DLR.ParameterExpression[] { indexerParam, temp }, DLR.Expression.Assign( indexerParam, call ), DLR.Expression.Assign( scope.CallbackInfo.Index, DLR.Expression.Call( typeof(Tools).GetMethod("ConvertATypeListToAType", BindingFlags.NonPublic | BindingFlags.Static), indexerParam ) ), DLR.Expression.Assign( scope.CallbackInfo.QualifiedName, DLR.Expression.Constant(qualifiedName) ), DLR.Expression.Assign(temp, value), DLR.Expression.Assign(scope.AssignDone, DLR.Expression.Constant(false)), DLR.Expression.TryCatch( DLR.Expression.Block( typeof(void), DLR.Expression.Assign(value, presetCallback), DLR.Expression.Assign(scope.AssignDone, DLR.Expression.Constant(true)) ), DLR.Expression.Catch( errorParam, DLR.Expression.Empty() ) ), DLR.Expression.IfThen( scope.AssignDone, DLR.Expression.Block( DLR.Expression.Dynamic( scope.GetRuntime().SetIndexBinder(new System.Dynamic.CallInfo(target.IndexExpression.Length)), typeof(object), target.Item.Generate(scope), indexerParam, value ), DLR.Expression.Assign(temp, value), callback ) ), scope.CallbackInfo.NonPresetValue ); } return DLR.Expression.Convert(result, typeof(AType)); }
/// <summary>Generates a DLR Expression for Strand assignment.</summary> /// <remarks> /// Transform this: /// (a;b;...) := ..... // don't care what is there :) /// /// to this in DLR: /// /// $__VALUES__ = (AType) .....; // ..... is a generated DLR expression now! /// /// if($__VALUES__.IsArray) // case A /// { /// if($VALUES.length != 2) // 2 the # of targets /// { /// throw new Error.Length("assign"); /// } /// /// a = disclose( ((AArray)$__VALUES__)[0] ); /// b = disclose( ((AArray)$__VALUES__)[1] ); /// ... /// } /// else // case B /// { /// // need to disclose the box /// if($__VALUES__.Type == ATypes.Box) /// { /// $__VALUES__ = disclose($__VALUES__); /// } /// a = $VALUES.Clone(); /// b = $VALUES.Clone(); /// ... /// } /// $__DependencyManager__.InvalidateDependencies(string[] { a,b, .. }) /// $__DependencyManager__.ValidateDependencies(string[] { a,b, .. }) /// </remarks> /// <param name="scope"></param> /// <param name="targets"> /// Strand containing Identifiers. /// If a node which in not an Identifier found, ParseException is thrown /// </param> /// <param name="value">The generated value which will be assigned to the targets</param> /// <returns>A generated DLR expression for strand assignment</returns> private static DLR.Expression GenerateStrandAssign(AplusScope scope, Strand targets, DLR.Expression value) { AbstractMonadicFunction disclose = MonadicFunctionInstance.Disclose; Aplus runtime = scope.GetRuntime(); DLR.ParameterExpression environment = scope.GetRuntimeExpression(); DLR.ParameterExpression valuesParam = DLR.Expression.Parameter(typeof(AType), "__VALUES__"); // for dependency evaluation List<string> targetVariables = new List<string>(); // for case A) assigns List<DLR.Expression> strand2StrandAssigns = new List<DLR.Expression>(); // for case B) assigns List<DLR.Expression> strand2ValueAssigns = new List<DLR.Expression>() { DLR.Expression.Assign( valuesParam, DLR.Expression.Call( DLR.Expression.Constant(disclose), disclose.GetType().GetMethod("Execute"), valuesParam, environment ) ) }; int indexCounter = 0; foreach (Node node in targets.Items) { if (!(node is Identifier)) { throw new ParseException("assign lhs"); } Identifier id = (Identifier)node; DLR.Expression strandValue = DLR.Expression.Call( DLR.Expression.Constant(disclose), disclose.GetType().GetMethod("Execute"), DLR.Expression.MakeIndex( valuesParam, typeof(AType).GetIndexerProperty(typeof(int)), // The indexer property which will be used new DLR.Expression[] { DLR.Expression.Constant(indexCounter, typeof(int)) } ), environment ); // case A) $TARGETS[i] = disclose($VALUES[i]) strand2StrandAssigns.Add(GenerateIdentifierAssign(scope, id, strandValue, isStrand: true)); // case B) $TARGETS[i] = $VALUE.Clone() strand2ValueAssigns.Add( GenerateIdentifierAssign( scope, id, DLR.Expression.Condition( DLR.Expression.Property(valuesParam, "IsMemoryMappedFile"), valuesParam, DLR.Expression.Call( valuesParam, typeof(AType).GetMethod("Clone") ) ), isStrand: true ) ); // gather the global variables for dependency validation/invalidation. if ((scope.IsMethod && id.IsEnclosed) || !scope.IsMethod) { targetVariables.Add(id.BuildQualifiedName(runtime.CurrentContext)); } indexCounter++; } // case A) DLR.Expression caseStrand2Strand = DLR.Expression.IfThenElse( DLR.Expression.NotEqual( DLR.Expression.PropertyOrField(valuesParam, "Length"), DLR.Expression.Constant(indexCounter, typeof(int)) ), DLR.Expression.Throw( DLR.Expression.New( typeof(Error.Length).GetConstructor(new Type[] { typeof(string) }), DLR.Expression.Constant("assign", typeof(string)) ) ), DLR.Expression.Block(strand2StrandAssigns) ); DLR.Expression dependencyManager = DLR.Expression.Property(scope.GetRuntimeExpression(), "DependencyManager"); DLR.Expression result = DLR.Expression.Block( new DLR.ParameterExpression[] { valuesParam }, DLR.Expression.Assign(valuesParam, DLR.Expression.Convert(value, typeof(AType))), DLR.Expression.IfThenElse( DLR.Expression.PropertyOrField(valuesParam, "IsArray"), // case A) caseStrand2Strand, // case B) DLR.Expression.Block(strand2ValueAssigns) ), DLR.Expression.Call( dependencyManager, typeof(DependencyManager).GetMethod("InvalidateDependencies", new Type[] { typeof(string[]) }), DLR.Expression.Constant(targetVariables.ToArray()) ), DLR.Expression.Call( dependencyManager, typeof(DependencyManager).GetMethod("ValidateDependencies"), DLR.Expression.Constant(targetVariables.ToArray()) ), valuesParam ); return DLR.Expression.Block(result, DLR.Expression.Assign(scope.CallbackInfo.NonPresetValue, value)); }
/*!*/ private static MSAst.Expression AddDefaultReturn(MSAst.Expression/*!*/ body, Type returnType) { if (body.Type == typeof(void) && returnType != typeof(void)) { body = Ast.Block(body, ConstantExpression.Undefined); } return body; }
private static DLR.Expression BuildGlobalAssignment( AplusScope scope, Aplus runtime, DLR.Expression variableContainer, Identifier target, DLR.Expression value, bool isStrand = false, bool needCallback = true ) { // Build the ET for updating the dependency DLR.Expression dependencyCall; string qualifiedName = target.BuildQualifiedName(runtime.CurrentContext); if (isStrand) { // We are inside a starnd assignment, do nothing. // Dependency update will be handled later. dependencyCall = DLR.Expression.Empty(); } else { // Otherwise build the dependency invalidation call. DLR.Expression dependencyManager = DLR.Expression.Property(scope.GetRuntimeExpression(), "DependencyManager"); dependencyCall = DLR.Expression.Call( dependencyManager, typeof(DependencyManager).GetMethod("InvalidateDependencies", new Type[] { typeof(string) }), DLR.Expression.Constant(qualifiedName) ); } DLR.ParameterExpression errorParam = DLR.Expression.Parameter(typeof(Error.Signal), "__ERRORPARAM__"); DLR.ParameterExpression valueParam = DLR.Expression.Parameter(typeof(AType), "__VALUEPARAMETER__"); scope.AssignDone = (scope.AssignDone == null) ? DLR.Expression.Parameter(typeof(bool), "__ASSIGNDONE__") : scope.AssignDone; DLR.Expression presetCallback = BuildPresetCallbackCall(scope, valueParam); DLR.Expression callback = BuildCallbackCall(scope, valueParam); DLR.Expression variableSet = DLR.Expression.Block( VariableHelper.SetVariable( runtime, variableContainer, target.CreateContextNames(runtime.CurrentContext), valueParam ), dependencyCall ); DLR.Expression codebody; if (needCallback) { codebody = DLR.Expression.Block( typeof(void), DLR.Expression.Assign(scope.CallbackInfo.QualifiedName, DLR.Expression.Constant(qualifiedName)), DLR.Expression.Assign(scope.AssignDone, DLR.Expression.Constant(false)), DLR.Expression.TryCatch( DLR.Expression.Block( typeof(void), DLR.Expression.Assign(valueParam, presetCallback), DLR.Expression.Assign(scope.AssignDone, DLR.Expression.Constant(true)) ), DLR.Expression.Catch( errorParam, DLR.Expression.Empty() ) ), DLR.Expression.IfThen( scope.AssignDone, DLR.Expression.Block( variableSet, callback ) ) ); } else { codebody = variableSet; } // value assignment DLR.Expression result = DLR.Expression.Block( new DLR.ParameterExpression[] { valueParam }, DLR.Expression.Assign(valueParam, value), codebody, valueParam ); return result; }
private void InitializeParameters(List<MSAst.Expression> init, MSAst.Expression[] parameters) { for (int i = 0; i < _parameters.Length; i++) { Parameter p = _parameters[i]; init.Add( AssignValue( GetVariableExpression(p.TotemVariable), AstUtils.LightDynamic( TotemContext.GetIndex(1), parameters[1], Ast.Constant(i) ) ) ); } }