Matlab interpreter mode

Interpreter pattern (Interperter), a given language, a language grammar defines and establishes an interpreter to interpret the language sentences, the actual development of EL expression or a regular expression interpreter designed for this model . FIG pattern which is structured as follows. As used herein, matlab language, using an interpreter mode to achieve postfix expression parsing .

Context.m (environment class, contains information other than global interpreter)

classdef Context < handle
    properties
        variables = containers.Map();
    end  
    methods
        function put(obj,var,expr)
            obj.variables(char(var)) = expr;
        end
        function expr = lookup(obj,var)
            if(obj.variables.isKey(char(var)))
                expr = obj.variables(char(var));
            else
                expr = Expression.empty();
            end
        end
    end
end

Expression.m (abstract expression)

classdef Expression < handle & matlab.mixin.Heterogeneous 
    methods(Abstract)
        interpret(obj,ctx);
    end
end

Plus.m (nonterminal expressions, addition type)

classdef Plus < Expression
    properties
        left;
        right;
    end
    methods
        function obj = Plus(left,right)
            obj.left = left;
            obj.right = right;
        end
        function res = interpret(obj,ctx)
           res = obj.left.interpret(ctx) + obj.right.interpret(ctx);
        end
    end
end

Minus.m (non-terminal expression, subtraction category)

classdef Minus < Expression
    properties
        left;
        right;
    end
    methods
        function obj = Minus(left,right)
            obj.left = left;
            obj.right = right;
        end
        function res = interpret(obj,ctx)
           res = obj.left.interpret(ctx) - obj.right.interpret(ctx);
        end
    end
end

Variable.m (non-terminal expression, variable category)

classdef Variable < Expression
    properties
        name
    end
    methods
        function obj = Variable(name)
            obj.name = name;
        end
        function res = interpret(obj,ctx)
            if(isempty(ctx.lookup(obj.name)))
                res  = 0;
            else
                res = ctx.lookup(obj.name).interpret(ctx);
            end
        end
    end
end

Number.m (end expressions, digital category)

classdef Number < Expression
    properties
        number
    end
    methods
        function obj = Number(number)
            obj.number = number;
        end
        function number = interpret(obj,~)
            number = obj.number;
        end
    end
end

Evaluator.m (non-terminal expression based parse inlet) 

classdef Evaluator < Expression
    properties
        syntaxTree
    end
    methods
        function obj = Evaluator(expr)
            exprs = Expression.empty();
            tokens = expr.split(" ");
            for i=1:length(tokens)
                switch(tokens(i))
                    case "+"
                        subexpr = Plus(exprs(end-1),exprs(end));
                        exprs = exprs(1:end-2);
                        exprs(end + 1) = subexpr;
                    case "-"
                        subexpr = Minus(exprs(end-1),exprs(end));
                        exprs = exprs(1:end-2);
                        exprs(end + 1) = subexpr;
                    otherwise
                        exprs(end + 1) = Variable(tokens(i)); 
                end    
            end
            obj.syntaxTree = exprs(end);
        end        
        function res = interpret(obj,ctx)
            res = obj.syntaxTree.interpret(ctx);
        end
    end
end

test.m (test code)

expr = "w x z + -";
ctx = Context();
ctx.put("w",Number(5));
ctx.put("x",Number(6));
ctx.put("z",Number(4));
eva = Evaluator(expr);
res = eva.interpret(ctx);
disp(res);

References:

https://www.jianshu.com/p/0e7e26bbe204

https://www.cnblogs.com/chenpi/p/5222496.html