Пример #1
0
        public object Call(Interpreter interpreter, List <object> arguments)
        {
            var instance = new LoxInstance(this);

            FindMethod("init")?.Bind(instance).Call(interpreter, arguments);
            return(instance);
        }
Пример #2
0
        public LoxFunction Bind(LoxInstance instance)
        {
            var environment = new Environment(Closure);

            environment.Define("this", instance);
            return(new LoxFunction(Declaration, environment, IsInitializer));
        }
Пример #3
0
        public LoxFunction bind(LoxInstance instance)
        {
            Environment environment = new Environment(closure);

            environment.define("this", instance);
            return(new LoxFunction(declaration, environment, isInitializer, isGet));
        }
Пример #4
0
        public object visitSuperExpr(Expr.Super super)
        {
            int distance = -1;

            locals.TryGetValue(super, out distance);
            List <LoxClass> superClasses = (List <LoxClass>)environment.getAt(distance, "super");
            LoxInstance     _object      = (LoxInstance)environment.getAt(distance - 1, "this");
            LoxFunction     method       = null;
            LoxClass        foundInClass = null;

            foreach (LoxClass superClass in superClasses)
            {
                LoxFunction methodFind = superClass.findMethod(super.method.lexeme);
                if (methodFind != null)
                {
                    if (method != null)
                    {
                        throw new Exceptions.RuntimeError(super.method, "Error: Found '" + super.method.lexeme + "' in " + foundInClass.name + " and " + superClass.name + ".");
                    }
                    method       = methodFind;
                    foundInClass = superClass;
                }
            }
            if (method == null)
            {
                throw new Exceptions.RuntimeError(super.method, "Undefined property '" + super.method.lexeme + "'.");
            }
            return(method.bind(_object));
        }
Пример #5
0
        public LoxFunction Bind(LoxInstance instance)
        {
            var env = new Environment(_closure);

            env.Define("this", instance);
            return(new LoxFunction(_declaration, env, _isInitializer));
        }
Пример #6
0
        public LoxFunction Bind(LoxInstance instance, IClass superClass)
        {
            var environment = new Environment(closure);

            environment.Define("this", instance);
            environment.Define("super", superClass);
            return(new LoxFunction(declaration, environment, isInitializer));
        }
Пример #7
0
        public object Call(Interpreter interpreter, List <object> arguments)
        {
            var instance    = new LoxInstance(this);
            var initializer = FindMethod("init");

            if (initializer != null)
            {
                initializer.Bind(instance).Call(interpreter, arguments);
            }
            return(instance);
        }
Пример #8
0
        public object call(Interpreter interpreter, List <object> arguments)
        {
            LoxInstance instance    = new LoxInstance(this);
            LoxFunction initializer = methods.ContainsKey("init") ? methods["init"] : null;

            if (initializer != null)
            {
                initializer.bind(instance).call(interpreter, arguments);
            }
            return(instance);
        }
Пример #9
0
        /// <summary>
        /// When a class is called with (), we construct a new instance (aka an object) of it.
        /// </summary>
        public object Call(Interpreter interpreter, List <object> arguments)
        {
            var instance = new LoxInstance(this);

            if (methods.TryGetValue("init", out LoxFunction initializer))
            {
                initializer.Bind(instance, superclass).Call(interpreter, arguments);
            }

            return(instance);
        }
Пример #10
0
        public object call(Interpreter interpreter, List <object> arguments)
        {
            LoxInstance instance    = new LoxInstance(this);
            LoxFunction initializer = findMethod("init");

            if (initializer != null)
            {
                initializer.bind(instance).call(interpreter, arguments);
            }
            return(instance);
        }
Пример #11
0
        public object Call(Evaluator evaluator, List <object> arguments)
        {
            LoxInstance instance    = new LoxInstance(this);
            LoxFunction initializer = FindMethod("init");

            if (initializer != null)
            {
                initializer.Bind(instance).Call(evaluator, arguments);
            }

            return(instance);
        }
Пример #12
0
        public object VisitSuperExpr(Expr.Super expr)
        {
            int distance = locals[expr];

            // Find reference to the superclass and current instance ("this").
            IClass      superclass   = (IClass)environment.GetAt(distance, "super");
            LoxInstance thisInstance = (LoxInstance)environment.GetAt(distance, "this");
            // Find method from superclass.
            LoxFunction method = superclass.FindMethod(thisInstance, expr.method.lexeme);

            return(method);
        }
Пример #13
0
        private object EvaluateSuperExpression(SuperExpression expr)
        {
            int         distance   = _locals[expr];
            LoxClass    superclass = (LoxClass)_environment.GetAt(distance, new Token(TokenType.Super, "super", null, 0));
            LoxInstance obj        = (LoxInstance)_environment.GetAt(distance - 1, new Token(TokenType.This, "this", null, 0));

            var method = superclass.FindMethod(expr.Method.Lexeme);

            if (method == null)
            {
                throw new RuntimeError(expr.Method, $"Undefine property {expr.Method.Lexeme}");
            }
            return(method.Bind(obj));
        }
Пример #14
0
        public LoxFunction FindMethod(LoxInstance instance, string name)
        {
            if (methods.TryGetValue(name, out LoxFunction fun))
            {
                // Methods "this" is set to a given instance (from which instance it is accessed from).
                return(fun.Bind(instance, superclass));
            }
            if (superclass != null)
            {
                return(superclass.FindMethod(instance, name));
            }

            return(null);
        }
Пример #15
0
        public LoxFunction findMethod(LoxInstance instance, string name)
        {
            if (methods.ContainsKey(name))
            {
                return(methods[name].bind(instance));
            }

            if (superclass != null)
            {
                return(superclass.findMethod(instance, name));
            }

            return(null);
        }
Пример #16
0
        private object EvaluateSetExpression(SetExpression expr)
        {
            object obj = Evaluate(expr.Object);

            LoxInstance instance = obj as LoxInstance;

            if (instance is null)
            {
                throw new RuntimeError(expr.Name, "Only instances have fields");
            }

            object value = Evaluate(expr.Value);

            instance.Set(expr.Name, value);
            return(value);
        }
Пример #17
0
        public object VisitSuperExpr(Super expr)
        {
            int      distance   = locals[expr];
            LoxClass superclass = (LoxClass)environment.GetAt(distance, "super");

            LoxInstance obj = (LoxInstance)environment.GetAt(distance - 1, "this");

            LoxFunction method = superclass.FindMethod(expr.Method.Lexeme);

            if (method == null)
            {
                throw new RuntimeError(expr.Method, "Undefined property '" + expr.Method.Lexeme + "'.");
            }

            return(method.Bind(obj));
        }
Пример #18
0
        object Expr.IVisitor <object> .Visit(Expr.Super _super)
        {
            int      distance   = _locals[_super];
            LoxClass superclass = (LoxClass)_environment.GetAt(distance, "super");

            // "this" is always one level nearer than "super"'s environment.
            LoxInstance _object = (LoxInstance)_environment.GetAt(distance - 1, "this");

            LoxFunction method = superclass.FindMethod(_super.method.lexeme);

            if (method == null)
            {
                throw new RuntimeError(_super.method, "Undefined property '" + _super.method.lexeme + "'.");
            }

            return(method.Bind(_object));
        }
Пример #19
0
        public object visit_Super_Expr(GExpr.Super expr)
        {
            int      distance   = locals[expr];
            LoxClass superClass = (LoxClass)environment.getAt(distance, "super");
            // "this" is always 1 level nearer than "super's" environment

            LoxInstance obj = (LoxInstance)environment.getAt(distance - 1, "this");

            LoxFunction method = superClass.findMethod(obj, expr.method.lexeme);

            if (method == null)
            {
                throw new RuntimeError(expr.method, $"Undefined property '{expr.method.lexeme}'");
            }

            return(method);
        }