public EvaluatedSignature(CallSignature call_signature, DeclarationSignature decl_signature, Scope outer_scope)
        {
            EvaluatedParameter [] parameters = new EvaluatedParameter [Math.Max(call_signature.Parameters.Length, decl_signature.Parameters.Length)];

            for (int i = 0; i < parameters.Length; i++)
            {
                DeclarationParameter decl_parameter = decl_signature.Parameters.Get(i, default_value: null);
                CallParameter        call_parameter = call_signature.Parameters.Get(i, default_value: null);

                Expression unevaluated_value = null;
                if (call_parameter != null && call_parameter.Value != null)
                {
                    unevaluated_value = call_parameter.Value;
                }
                else if (decl_parameter != null)
                {
                    unevaluated_value = decl_parameter.InitialValue;
                }
                FinalExpression evaluated_value = Interpreters.Execute(unevaluated_value, outer_scope).ResultValue;

                EvaluatedParameter evaluated_parameter = new EvaluatedParameter(
                    name: (decl_parameter?.Name ?? default),
                    evaluated_value: evaluated_value,
                    ampersand: (decl_parameter?.PassedByRef ?? false) || (call_parameter?.Ampersand ?? false),
                    is_unpack: (call_parameter?.IsUnpack ?? false)
                    );
                parameters [i] = evaluated_parameter;
            }

            Parameters = parameters.ToImmutableArray();
        }
            public InterpretedClass(ClassDeclarationExpression expression, Scope scope)
            {
                _rootscope        = scope.Root;
                _name             = expression.Name;
                _parents          = expression.Parents;
                _interfaces       = expression.Interfaces;
                _methods          = new MethodCollection();
                _fields           = new FieldCollection();
                _classes          = new ClassCollection();
                _static_variables = new VariableCollection();

                ScriptScope script_scope = null;

                scope.FindNearestScope <ScriptScope> (ss => script_scope = ss);

                foreach (ClassMethodDeclarationExpression m in expression.Methods)
                {
                    _methods.Add(new InterpretedMethod(m, script_scope));
                }

                foreach (ClassFieldDeclarationExpression f in expression.Fields)
                {
                    IVariable var = _static_variables.EnsureExists(f.Name);
                    if (f.Initializer is Expression initializer_expr)
                    {
                        var.Value = Interpreters.Execute(initializer_expr, script_scope).ResultValue;
                    }
                }
            }
示例#3
0
        public static Result Run(RequireFileExpression require, Scope scope)
        {
            string filepath_raw = Interpreters.Execute(require.FilePath, scope).ResultValue.GetStringValue();

            scope.Root.Context.RequireFile(scope, IncludePathHelper.ResolveToRelative(filepath_raw, scope));

            return(Result.NULL);
        }
        public static Result Run(ForeachExpression block, Scope scope)
        {
            Result overall_result = Result.NULL;

            int i = 0;

            while (true)
            {
                bool condition_is_true;
                if (block.IsDoWhile && i == 0)
                {
                    condition_is_true = true;
                }
                else
                {
                    // Log.Debug (block.Condition);
                    Result condition_result = Interpreters.Execute(block.Condition, scope);
                    condition_is_true = condition_result.IsTrue();
                }

                if (condition_is_true)
                {
                    try
                    {
                        Result body_result = Interpreters.Execute(block.Body, scope);
                        overall_result = body_result;
                    }
                    catch (BreakException ex)
                    {
                        // Log.Debug (ex);
                        if (ex.CountOfLoops > 1)
                        {
                            throw new BreakException(ex.CountOfLoops - 1);
                        }
                        break;
                    }
                    catch (ContinueException ex)
                    {
                        // Log.Debug (ex);
                        if (ex.CountOfLoops > 1)
                        {
                            throw new ContinueException(ex.CountOfLoops - 1);
                        }
                    }
                }
                else
                {
                    break;
                }

                i++;
            }

            return(overall_result);
        }
示例#5
0
        public static Result Run(ImmutableArray <Expression> expressions, Scope scope)
        {
            Result res = Result.NULL;

            foreach (Expression expression in expressions)
            {
                res = Interpreters.Execute(expression, scope);
                if (res.FastReturn)
                {
                    return(res);
                }
            }
            return(res);
        }
            Result IFunction.Execute(EvaluatedSignature evaluated_signature, Scope outer_scope)
            {
                FunctionScope function_scope = new FunctionScope(outer_scope, this, evaluated_signature);

                foreach (EvaluatedParameter parameter in evaluated_signature.Parameters)
                {
                    if (!parameter.Name.IsEmpty)
                    {
                        IVariable variable = function_scope.Variables.EnsureExists(parameter.Name);
                        variable.Value = parameter.EvaluatedValue;
                    }
                }

                return(Interpreters.Execute(_expression.Body, function_scope));
            }
            Result IMethod.Execute(IObject obj, IReadOnlyList <IClass> classes, EvaluatedSignature evaluated_signature, Scope outer_scope)
            {
                MethodScope function_scope = new MethodScope(outer_scope, this, evaluated_signature, obj, classes);

                foreach (EvaluatedParameter parameter in evaluated_signature.Parameters)
                {
                    if (!parameter.Name.IsEmpty)
                    {
                        IVariable variable = function_scope.Variables.EnsureExists(parameter.Name);
                        variable.Value = parameter.EvaluatedValue;
                    }
                }

                return(Interpreters.Execute(_expression.Body, function_scope));
            }
        public static Result Run(ArrayCreateExpression expression, Scope scope)
        {
            IArray arr = new ArrayStructure();

            scope.Root.Arrays.Add(arr);

            foreach (ArrayItemExpression item_expr in expression.Items)
            {
                FinalExpression key_expr   = Interpreters.Execute(item_expr.Key, scope).ResultValue;
                FinalExpression value_expr = Interpreters.Execute(item_expr.Value, scope).ResultValue;
                ArrayKey        key        = new ArrayKey(key_expr.GetStringValue());
                arr.Set(new ArrayItem(key, value_expr));
            }

            return(new Result(arr.AsExpression));
        }
示例#9
0
        public static Result Run(TryExpression block, Scope scope)
        {
            Result body_result = Result.NULL;

            Expression body_expr = block.Body;

            if (body_expr != null)
            {
                body_result = Interpreters.Execute(body_expr, scope);
            }

            Expression finally_expr = block.Finally;

            if (finally_expr != null)
            {
                Interpreters.Execute(finally_expr, scope);
            }

            return(body_result);
        }
示例#10
0
        public static Result Run(UnaryExpression expression, Scope scope)
        {
            Result value_result = Interpreters.Execute(expression.Value, scope);

            if (value_result.FastReturn)
            {
                return(value_result);
            }

            FinalExpression value = value_result.ResultValue;

            switch (expression.Operation)
            {
            case UnaryOp.CAST_STRING:
                return(new Result(new StringExpression(value.GetStringValue())));

            case UnaryOp.CAST_BOOL:
                return(new Result(new BoolExpression(value.GetBoolValue())));

            case UnaryOp.CAST_ARRAY:
                return(ArrayInterpreter.Run(new ArrayCreateExpression(ImmutableArray <ArrayItemExpression> .Empty), scope));

            case UnaryOp.CAST_OBJECT:
                return(new Result(value));

            case UnaryOp.LOGICAL_NEGATION:
                return(new Result(new BoolExpression(!value.GetBoolValue())));

            case UnaryOp.IS_EMPTY:
                return(new Result(new BoolExpression(string.IsNullOrEmpty(value.GetStringValue()))));

            case UnaryOp.AT_SIGN:
                return(new Result(value));

            default:
                Log.Error($"Unable to execute binary operation: {expression.Operation}");
                return(Result.NULL);
            }
        }
示例#11
0
        public static Result Run(ConditionalBlockExpression block, Scope scope)
        {
            foreach (BaseIfExpression if_expr in block.Ifs)
            {
                Result if_condition_result = Interpreters.Execute(if_expr.Condition, scope);

                if (if_condition_result.IsTrue())
                {
                    Result if_body_result = Interpreters.Execute(if_expr.Body, scope);
                    return(if_body_result);
                }
            }

            ElseExpression else_expr = block.Else;

            if (else_expr != null)
            {
                Result else_body_result = Interpreters.Execute(else_expr.Body, scope);
                return(else_body_result);
            }

            return(Result.NULL);
        }
示例#12
0
        public static void Resolve(ArrayAccessExpression expression, Scope scope, Action <IArray, ArrayKey> action)
        {
            FinalExpression key_expr = Interpreters.Execute(expression.Index, scope).ResultValue;
            ArrayKey        key      = new ArrayKey(key_expr.GetStringValue());

            FinalExpression array_expr = Interpreters.Execute(expression.Array, scope).ResultValue;

            if (array_expr is ArrayPointerExpression pointer)
            {
                if (pointer.Array is IArray arr)
                {
                    action(arr, key);
                }
                else
                {
                    Log.Error($"Array could not be found: {pointer.Array.Name}, key: '{key}', scope: {scope}");
                }
            }
            else
            {
                Log.Error($"Array access of key '{key}' is not performed on an array, but on: {array_expr}, scope: {scope}");
            }
        }
        public static Result Run(AssignExpression assign, Scope scope)
        {
            Result right_result = Interpreters.Execute(assign.Right, scope);

            if (right_result.FastReturn)
            {
                return(right_result);
            }

            switch (assign.Left)
            {
            case ArrayAccessExpression array_access_expression:
                ArrayInterpreter.Resolve(array_access_expression, scope, (arr, key) =>
                {
                    arr.Set(new ArrayItem(key, right_result.ResultValue));
                });
                break;

            case VariableExpression variable_expression:
                IVariable variable = scope.Variables.EnsureExists(variable_expression.Name);
                variable.Value = right_result.ResultValue;
                break;

            case StaticFieldAccessExpression static_field_access_expression:
                ClassInterpreter.Resolve(static_field_access_expression, scope, (var) =>
                {
                    var.Value = right_result.ResultValue;
                });
                break;

            default:
                Log.Error($"Cannot execute assign expression: Left Value is of unknown type {assign.Left}");
                break;
            }

            return(right_result);
        }
        public static Result Run(BinaryExpression expression, Scope scope)
        {
            Result left_result = Interpreters.Execute(expression.Left, scope);

            if (left_result.FastReturn)
            {
                return(left_result);
            }
            Result right_result = Interpreters.Execute(expression.Right, scope);

            if (right_result.FastReturn)
            {
                return(right_result);
            }

            FinalExpression left  = left_result.ResultValue;
            FinalExpression right = right_result.ResultValue;

            switch (expression.Operation)
            {
            case BinaryOp.ADD:
                if (left.GetScalarAffinity() == ScalarAffinity.DOUBLE || left.GetScalarAffinity() == ScalarAffinity.DOUBLE)
                {
                    return(new Result(new DoubleExpression(left.GetDoubleValue() + right.GetDoubleValue())));
                }
                else
                {
                    return(new Result(new LongExpression(left.GetLongValue() + right.GetLongValue())));
                }

            case BinaryOp.SUB:
                if (left.GetScalarAffinity() == ScalarAffinity.DOUBLE || left.GetScalarAffinity() == ScalarAffinity.DOUBLE)
                {
                    return(new Result(new DoubleExpression(left.GetDoubleValue() - right.GetDoubleValue())));
                }
                else
                {
                    return(new Result(new LongExpression(left.GetLongValue() - right.GetLongValue())));
                }

            case BinaryOp.MUL:
                if (left.GetScalarAffinity() == ScalarAffinity.DOUBLE || left.GetScalarAffinity() == ScalarAffinity.DOUBLE)
                {
                    return(new Result(new DoubleExpression(left.GetDoubleValue() * right.GetDoubleValue())));
                }
                else
                {
                    return(new Result(new LongExpression(left.GetLongValue() * right.GetLongValue())));
                }

            case BinaryOp.DIV:
                return(new Result(new DoubleExpression(left.GetDoubleValue() / right.GetDoubleValue())));

            case BinaryOp.CONCAT:
                Log.Debug($"concat result: left = " + left + ", right = " + right + ", concat = " + new StringExpression(left.GetStringValue() + right.GetStringValue()));
                return(new Result(new StringExpression(left.GetStringValue() + right.GetStringValue())));

            case BinaryOp.EQUAL:
                if (left.GetScalarAffinity() == ScalarAffinity.ARRAY && right.GetScalarAffinity() == ScalarAffinity.ARRAY)
                {
                    return(new Result(new BoolExpression((left as ArrayPointerExpression)?.Array?.Name == (right as ArrayPointerExpression)?.Array?.Name)));
                }
                else if (left.GetScalarAffinity() == ScalarAffinity.OBJECT && right.GetScalarAffinity() == ScalarAffinity.OBJECT)
                {
                    return(new Result(new BoolExpression((left as ObjectPointerExpression)?.Object?.Name == (right as ObjectPointerExpression)?.Object?.Name)));
                }
                else if (left.GetScalarAffinity() == ScalarAffinity.BOOL || right.GetScalarAffinity() == ScalarAffinity.BOOL)
                {
                    return(new Result(new BoolExpression(left.GetBoolValue() == right.GetBoolValue())));
                }
                else if (left.GetScalarAffinity() == ScalarAffinity.DOUBLE || right.GetScalarAffinity() == ScalarAffinity.DOUBLE)
                {
                    return(new Result(new BoolExpression(left.GetDoubleValue() == right.GetDoubleValue())));
                }
                else if (left.GetScalarAffinity() == ScalarAffinity.LONG || right.GetScalarAffinity() == ScalarAffinity.LONG)
                {
                    return(new Result(new BoolExpression(left.GetLongValue() == right.GetLongValue())));
                }
                else
                {
                    return(new Result(new BoolExpression(left.GetStringValue() == right.GetStringValue())));
                }

            case BinaryOp.IDENTICAL:
                if (left.GetScalarAffinity() == ScalarAffinity.ARRAY && right.GetScalarAffinity() == ScalarAffinity.ARRAY)
                {
                    return(new Result(new BoolExpression((left as ArrayPointerExpression)?.Array?.Name == (right as ArrayPointerExpression)?.Array?.Name)));
                }
                else if (left.GetScalarAffinity() == ScalarAffinity.OBJECT && right.GetScalarAffinity() == ScalarAffinity.OBJECT)
                {
                    return(new Result(new BoolExpression((left as ObjectPointerExpression)?.Object?.Name == (right as ObjectPointerExpression)?.Object?.Name)));
                }
                else if (left.GetScalarAffinity() == ScalarAffinity.BOOL && right.GetScalarAffinity() == ScalarAffinity.BOOL)
                {
                    return(new Result(new BoolExpression(left.GetBoolValue() == right.GetBoolValue())));
                }
                else if (left.GetScalarAffinity() == ScalarAffinity.DOUBLE && right.GetScalarAffinity() == ScalarAffinity.DOUBLE)
                {
                    return(new Result(new BoolExpression(left.GetDoubleValue() == right.GetDoubleValue())));
                }
                else if (left.GetScalarAffinity() == ScalarAffinity.LONG && right.GetScalarAffinity() == ScalarAffinity.LONG)
                {
                    return(new Result(new BoolExpression(left.GetLongValue() == right.GetLongValue())));
                }
                else if (left.GetScalarAffinity() == ScalarAffinity.NULL && right.GetScalarAffinity() == ScalarAffinity.NULL)
                {
                    return(new Result(new BoolExpression(left.GetLongValue() == right.GetLongValue())));
                }
                else if (left.GetScalarAffinity() == ScalarAffinity.STRING && right.GetScalarAffinity() == ScalarAffinity.STRING)
                {
                    return(new Result(new BoolExpression(left.GetStringValue() == right.GetStringValue())));
                }
                else
                {
                    return(new Result(new BoolExpression(false)));
                }

            case BinaryOp.LESS_THAN:
                if (left.GetScalarAffinity() == ScalarAffinity.DOUBLE || right.GetScalarAffinity() == ScalarAffinity.DOUBLE)
                {
                    return(new Result(new BoolExpression(left.GetDoubleValue() < right.GetDoubleValue())));
                }
                else if (left.GetScalarAffinity() == ScalarAffinity.LONG || right.GetScalarAffinity() == ScalarAffinity.LONG)
                {
                    return(new Result(new BoolExpression(left.GetLongValue() < right.GetLongValue())));
                }
                else
                {
                    return(new Result(new BoolExpression(left.GetStringValue().CompareTo(right.GetStringValue()) < 0)));
                }

            case BinaryOp.AND:
                return(new Result(new BoolExpression(left.GetBoolValue() && right.GetBoolValue())));

            case BinaryOp.OR:
                return(new Result(new BoolExpression(left.GetBoolValue() || right.GetBoolValue())));

            default:
                Log.Error($"Unable to execute binary operation: {expression.Operation}");
                return(Result.NULL);
            }
        }
 public static Result Run(CallParameter expression, Scope scope)
 {
     return(Interpreters.Execute(expression.Value, scope));
 }
示例#16
0
 public static Result Run(BreakExpression block, Scope scope)
 {
     throw new BreakException(Interpreters.Execute(block.CountOfLoops, scope).ResultValue.GetLongValue().Clamp(1, 1000));
 }
 public static Result Run(ReturnExpression block, Scope scope)
 {
     throw new ReturnException(Interpreters.Execute(block.ReturnValue, scope).ResultValue);
 }