Beispiel #1
0
 /// <summary>
 /// Build a method for setting a variable in a context.
 /// </summary>
 /// <param name="environment">
 /// <see cref="Aplus">Aplus</see>, which contains the variables.
 /// </param>
 /// <param name="contextParts">
 /// (context, variablename), as returned from <see cref="CreateContextParts"/> method.
 /// </param>
 /// <param name="value">Value to set for the provided <see cref="contextParts">variable</see>.</param>
 /// <returns>Expression tree of a Lambda expression.</returns>
 internal static DLR.Expression <Func <AType> > BuildVariableAssignMethod(Aplus environment,
                                                                          string[] contextParts, AType value)
 {
     DLR.Expression <Func <AType> > lambda = DLR.Expression.Lambda <Func <AType> >(
         DLR.Expression.Convert(
             VariableHelper.SetVariable(
                 environment,
                 DLR.Expression.Constant(environment.Context),
                 contextParts,
                 DLR.Expression.Constant(value)
                 ),
             typeof(AType)
             )
         );
     return(lambda);
 }
Beispiel #2
0
        /// <summary>
        /// Executes the <paramref name="sourceCode"/> in the <paramref name="newContext"/>.
        /// </summary>
        /// <param name="environment"></param>
        /// <param name="sourceCode">The code to execute</param>
        /// <param name="newContext">The context name to switch to before executeing the code</param>
        /// <returns>The executed source code's result</returns>
        private static AType ExecuteWithContextSwitch(Aplus environment, string sourceCode, string newContext)
        {
            AType result;

            string oldContext = environment.CurrentContext;

            environment.CurrentContext = newContext;

            DLR.Expression <Func <Aplus, AType> > lambda =
                Function.Monadic.NonScalar.Other.ExecuteFunction.BuildExecuteMethod(sourceCode, environment);

            Func <Aplus, AType> method = lambda.Compile();

            result = method(environment);

            environment.CurrentContext = oldContext;
            return(result);
        }
Beispiel #3
0
        /// <summary>
        /// Build a method for accessing a variable in a context.
        /// </summary>
        /// <param name="environment">
        /// <see cref="Aplus">Aplus</see>, which contains the variables.
        /// </param>
        /// <param name="contextParts">
        /// (context, variablename), as returned from <see cref="CreateContextParts"/> method.
        /// </param>
        /// <returns>Expression tree of a Lambda expression.</returns>
        internal static DLR.Expression <Func <AType> > BuildVariableAccessMethod(Aplus environment,
                                                                                 string[] contextParts)
        {
            DLR.Expression <Func <AType> > lambda =
                DLR.Expression.Lambda <Func <AType> >(
                    // Convert the variable to an AType
                    DLR.Expression.Dynamic(
                        environment.ConvertBinder(typeof(AType)),
                        typeof(AType),
                        // Access the variable
                        VariableHelper.GetVariable(
                            environment,
                            DLR.Expression.Constant(environment.Context),
                            contextParts
                            )
                        )
                    );

            return(lambda);
        }
Beispiel #4
0
        /// <summary>
        /// Executes the <paramref name="sourceCode"/> in the current context and catches errors (like monadic-do)
        /// </summary>
        /// <param name="environment"></param>
        /// <param name="sourcecode">The code to execute</param>
        /// <returns>
        ///  1) An AInteger if there is an error, this integer is the number of the error
        ///  2) The executed source code's result enclosed in an ABox
        /// </returns>
        private static AType ProtectedExecute(Aplus environment, string sourcecode)
        {
            AType result;

            try
            {
                DLR.Expression <Func <Aplus, AType> > lambda =
                    Function.Monadic.NonScalar.Other.ExecuteFunction.BuildExecuteMethod(sourcecode, environment);
                Func <Aplus, AType> method = lambda.Compile();

                // Enclose the result
                result = ABox.Create(method(environment));
            }
            catch (Error error)
            {
                result = AInteger.Create((int)error.ErrorType);
            }

            return(result);
        }
Beispiel #5
0
        public override AType Execute(AType argument, Aplus environment)
        {
            // Environment is required!
            Assert.NotNull(environment);

            if (argument.Type != ATypes.AChar)
            {
                throw new Error.Type(this.TypeErrorText);
            }

            if (argument.Rank > 1)
            {
                throw new Error.Rank(this.RankErrorText);
            }

            DLR.Expression <Func <Aplus, AType> > lambda = BuildExecuteMethod(argument.ToString(), environment);
            Func <Aplus, AType> method = lambda.Compile();

            AType result = method(environment);

            return(result);
        }
Beispiel #6
0
        static AipcConnection()
        {
            DLR.ParameterExpression functionParameter = DLR.Expression.Parameter(typeof(AType), "_FUNCTION_");

            DLR.ParameterExpression environmentParameter = DLR.Expression.Parameter(typeof(Aplus), "_ENVIRONMENT_");
            DLR.ParameterExpression handleParameter      = DLR.Expression.Parameter(typeof(AType), "_HANDLE_NUMBER_");
            DLR.ParameterExpression eventTypeParameter   = DLR.Expression.Parameter(typeof(AType), "_EVENT_TYPE_");
            DLR.ParameterExpression callDataParameter    = DLR.Expression.Parameter(typeof(AType), "_CALL_DATA_");

            /**
             * Build the following lambda method:
             *  (function, env, handleNumber, eventType, callData) => function(env, callData, eventType, handleNumber);
             */
            DLR.Expression <Func <AType, Aplus, AType, AType, AType, AType> > method =
                DLR.Expression.Lambda <Func <AType, Aplus, AType, AType, AType, AType> >(
                    DLR.Expression.Convert(
                        DLR.Expression.Dynamic(
                            new Binder.InvokeBinder(new DYN.CallInfo(4)),
                            typeof(object),
                            functionParameter,
                            environmentParameter,
                            callDataParameter,
                            eventTypeParameter,
                            handleParameter
                            ),
                        typeof(AType)
                        ),
                    true,
                    functionParameter,
                    environmentParameter,
                    handleParameter,
                    eventTypeParameter,
                    callDataParameter
                    );

            CallbackFunction = method.Compile();
        }
Beispiel #7
0
        internal static DLR.Expression <Func <Aplus, AType> > BuildExecuteMethod(
            string sourceCode, Aplus environment
            )
        {
            DLR.Expression codebody;
            // TODO: fix the third function info argument
            AplusCore.Compiler.AST.Node tree = Compiler.Parse.String(sourceCode, environment.LexerMode, null);

            AplusScope scope = new AplusScope(null, "__EVAL__", environment,
                                              DLR.Expression.Parameter(typeof(Aplus), "__EVAL_RUNTIME__"),
                                              DLR.Expression.Parameter(typeof(DYN.IDynamicMetaObjectProvider), "__EVAL_MODULE__"),
                                              //DLR.Expression.Parameter(typeof(Aplus), "__EVAL_ENVIRONMENT__"),
                                              DLR.Expression.Label(typeof(AType), "__EVAL_EXIT__"),
                                              isEval: true
                                              );

            if (tree == null)
            {
                codebody = DLR.Expression.Constant(null);
            }
            else if (environment.FunctionScope != null)
            {
                AplusScope functionScope = new AplusScope(scope, "__EVAL_IN_FUNCTION__",
                                                          moduleParam: DLR.Expression.Parameter(typeof(DYN.ExpandoObject), "__EVAL_FUNCTION_SCOPE__"),
                                                          returnTarget: scope.ReturnTarget,
                                                          isMethod: true
                                                          );

                codebody = DLR.Expression.Block(
                    new DLR.ParameterExpression[] {
                    //scope.RuntimeExpression,         // runtime
                    scope.ModuleExpression,              // root context
                    functionScope.ModuleExpression       // Function local scope
                },
                    //DLR.Expression.Assign(
                    //    scope.RuntimeExpression, scope.RuntimeExpression
                    //),
                    DLR.Expression.Assign(
                        scope.ModuleExpression, DLR.Expression.PropertyOrField(scope.RuntimeExpression, "Context")
                        ),
                    DLR.Expression.Assign(
                        functionScope.ModuleExpression, DLR.Expression.PropertyOrField(scope.RuntimeExpression, "FunctionScope")
                        ),
                    DLR.Expression.Label(
                        scope.ReturnTarget,
                        tree.Generate(functionScope)
                        )
                    );
            }
            else
            {
                codebody = DLR.Expression.Block(
                    new DLR.ParameterExpression[] {
                    //scope.RuntimeExpression,         // runtime
                    scope.ModuleExpression              // root context
                },
                    //DLR.Expression.Assign(
                    //   scope.RuntimeExpression, scope.RuntimeExpression
                    //),
                    DLR.Expression.Assign(
                        scope.ModuleExpression, DLR.Expression.PropertyOrField(scope.RuntimeExpression, "Context")
                        ),
                    DLR.Expression.Label(
                        scope.ReturnTarget,
                        tree.Generate(scope)
                        )
                    );
            }

            DLR.Expression <Func <Aplus, AType> > lambda = DLR.Expression.Lambda <Func <Aplus, AType> >(
                codebody,
                scope.GetRuntimeExpression()
                );

            return(lambda);
        }
 public AplusScriptCode(Aplus aplus, string code, SourceUnit sourceunit)
     : base(sourceunit)
 {
     this.aplus = aplus;
     this.lambda = ParseToLambda(code.Trim());
 }
Beispiel #9
0
 public AplusScriptCode(Aplus aplus, string code, SourceUnit sourceunit)
     : base(sourceunit)
 {
     this.aplus  = aplus;
     this.lambda = ParseToLambda(code.Trim());
 }