Exemple #1
0
 private void CodeCall(FuncCallExpression call, List<LocalVariable> locals, List<GlobalVariable> globals, FuncParam[] parameters, ILGenerator il, List<Function> allFuncs, LocalBuilder tmpVar)
 {
     var func = FindFunc(call, allFuncs);
     foreach (var expression in call.Params)
         CodeExpression(expression, locals, globals, parameters, il, allFuncs, tmpVar);
     il.Emit(OpCodes.Call, func.Info);
 }
        void FuncCall(SyntaxNode node)
        {
            FuncCallExpression n = (FuncCallExpression)node;

            if (((IdentifierExpression)n.Reference).Identifier == "print")
            {
                foreach (var argument in n.Arguments)
                {
                    if (argument.Kind == SyntaxKind.ConstantExpression)
                    {
                        Print(((ConstantExpression)argument).Value);
                    }

                    if (argument.Kind == SyntaxKind.IdentifierExpression)
                    {
                        string s = variable[((IdentifierExpression)argument).Identifier];
                        Print(s);
                    }
                }
            }

            if (((IdentifierExpression)n.Reference).Identifier == "read")
            {
                foreach (var argument in n.Arguments)
                {
                    if (argument.Kind == SyntaxKind.ConstantExpression)
                    {
                        Read(((ConstantExpression)argument).Value);
                    }

                    if (argument.Kind == SyntaxKind.IdentifierExpression)
                    {
                        string s = variable[((IdentifierExpression)argument).Identifier];
                        Read(s);
                    }
                }
            }

            if (((IdentifierExpression)n.Reference).Identifier == "load")
            {
                foreach (var argument in n.Arguments)
                {
                    if (argument.Kind == SyntaxKind.ConstantExpression)
                    {
                        Load(((ConstantExpression)argument).Value);
                    }

                    if (argument.Kind == SyntaxKind.IdentifierExpression)
                    {
                        string s = variable[((IdentifierExpression)argument).Identifier];
                        Load(s);
                    }
                }
            }
        }
        private static IExpression TryOptimizeMathFunction(FuncCallExpression expression)
        {
            for (int i = 0; i < expression.Parameters.Length; i++)
            {
                expression.Parameters[i] = Visit(expression.Parameters[i]);
            }

            if (expression.Parameters.All(x => x is NumberExpression))
            {
                var eval = expression.Evaluate(_scope, _environment);
                return(new NumberExpression(eval));
            }

            return(expression);
        }
Exemple #4
0
 private Function FindFunc(FuncCallExpression call, List<Function> allFuncs)
 {
     var func = allFuncs.Where(x => x.Name == call.Func.Value && x.Params.Length == call.Params.Length);
     /*foreach (var function in allFuncs)
     {
         bool f = true;
         for (int i = 0; i < call.Params.Length; i++)
         {
             if (call.Params[i])
         }
     }*/
     return func.First();
 }
 public FuncCallStatement(FuncCallExpression callExpr)
 {
     this.callExpr = callExpr;
 }
 protected abstract void VisitFuncCall(FuncCallExpression expression);