| sitelink1 | |
|---|---|
| sitelink2 | |
| sitelink3 | http://1 |
| extra_vars4 | ko |
| extra_vars5 | |
| extra_vars6 | sitelink1 |
Interpreter pattern
 |
This article does not cite any references or sources. Please help improve this article by adding citations to reliable sources. Unsourced material may be challenged and removed. (November 2008) |
In computer programming, the interpreter pattern is a particular design pattern. The interpreter pattern specifies how to evaluate sentences in a language. The basic idea is to have a class for each symbol (terminal or nonterminal) in a specialized computer language. The syntax tree of a sentence in the language is an instance of the composite pattern and is used to evaluate (interpret) the sentence.[1]
?
Contents[hide] |
[edit] Uses for the Interpreter pattern
- Specialized database query languages such as SQL.
- Specialized computer languages which are often used to describe communication protocols.
- Most general-purpose computer languages actually incorporate several specialized languages.
[edit] Structure
[edit] Example
 |
The Wikibook Computer Science Design Patterns has a page on the topic of |
The following Reverse Polish notation example illustrates the interpreter pattern. The grammarexpression ::= plus | minus | variable | numberdefines a language which contains reverse polish expressions like:
plus ::= expression expression '+'
minus ::= expression expression '-'
variable ::= 'a' | 'b' | 'c' | ... | 'z'
digit = '0' | '1' | ... '9'
number ::= digit | digit numbera b +Following the interpreter pattern there is a class for each grammar rule.
a b c + -
a b + c a - -
import java.util.HashMap; interface Expression { public int interpret(HashMap<String,Expression> variables); } class Number implements Expression { private int number; public Number(int number) { this.number = number; } public int interpret(HashMap<String,Expression> variables) { return number; } } class Plus implements Expression { Expression leftOperand; Expression rightOperand; public Plus(Expression left, Expression right) { leftOperand = left; rightOperand = right; } public int interpret(HashMap<String,Expression> variables) { return leftOperand.interpret(variables) + rightOperand.interpret(variables); } } class Minus implements Expression { Expression leftOperand; Expression rightOperand; public Minus(Expression left, Expression right) { leftOperand = left; rightOperand = right; } public int interpret(HashMap<String,Expression> variables) { return leftOperand.interpret(variables) - rightOperand.interpret(variables); } } class Variable implements Expression { private String name; public Variable(String name) { this.name = name; } public int interpret(HashMap<String,Expression> variables) { if(null==variables.get(name)) return 0; //Either return new Number(0). return variables.get(name).interpret(variables); } }
While the interpreter pattern does not address parsing[2] a parser is provided for completeness.
import java.util.HashMap; import java.util.Stack; class Evaluator implements Expression { private Expression syntaxTree; public Evaluator(String expression) { Stack<Expression> expressionStack = new Stack<Expression>(); for (String token : expression.split(" ")) { if (token.equals("+")) { Expression subExpression = new Plus(expressionStack.pop(), expressionStack.pop()); expressionStack.push( subExpression ); } else if (token.equals("-")) { // it's necessary remove first the right operand from the stack Expression right = expressionStack.pop(); // ..and after the left one Expression left = expressionStack.pop(); Expression subExpression = new Minus(left, right); expressionStack.push( subExpression ); } else expressionStack.push( new Variable(token) ); } syntaxTree = expressionStack.pop(); } public int interpret(HashMap<String,Expression> context) { return syntaxTree.interpret(context); } }
Finally evaluating the expression "w x z - +" with w = 5, x = 10, and z = 42.
import java.util.HashMap; public class InterpreterExample { public static void main(String[] args) { String expression = "w x z - +"; Evaluator sentence = new Evaluator(expression); HashMap<String,Expression> variables = new HashMap<String,Expression>(); variables.put("w", new Number(5)); variables.put("x", new Number(10)); variables.put("z", new Number(42)); int result = sentence.interpret(variables); System.out.println(result); } }
[edit] See also
[edit] References
- ^ Gamma, Erich; Richard Helm, Ralph Johnson, and John Vlissides (1995). Design Patterns: Elements of Reusable Object-Oriented Software. Addison-Wesley. pp. 243 ISBN 0-201-63361-2
- ^ Gamma, Erich; Richard Helm, Ralph Johnson, and John Vlissides (1995). Design Patterns: Elements of Reusable Object-Oriented Software. Addison-Wesley. pp. 247 ISBN 0-201-63361-2
