Interpreter

Interpreter
By: Mahmoodreza Jahanseir
Amirkabir University of Technology Computer Engineering

Amirkabir University of Technology Computer Engineering Department Fall 2010
Intent
Given a language, define a representation for its grammar along
with an interpreter that uses the representation to interpret
sentences in the language.
2

Motivation
The Interpreter pattern describes:
 how to define a grammar for simple languages,
 represent sentences in the language,
 and interpret these sentences.
3

4
Basically the Interpreter pattern has limited area where it can be
applied. We can discuss the Interpreter pattern only in terms of
formal grammars but in this area there are better solutions that
is why it is not frequently used.
The Interpreter pattern uses a class to represent each grammar
rule.

Applicability
Use the Interpreter pattern when there is a language to interpret,
and you can represent statements in the language as abstract
syntax trees.
The Interpreter pattern works best when
1) the grammar is simple.
2) For complex grammars, the class hierarchy for the grammar becomes large
and unmanageable.
3) They can interpret expressions without building abstract syntax trees,
which can save space and possibly time.
5

Applicability (cont…)
– efficiency is not a critical concern.
2) The most efficient interpreters are usually not implemented by
interpreting parse trees directly but by first translating them into another
form.
6

Structure
7

8

Participants
 AbstractExpression
 declares an abstract Interpret operation that is common to all nodes in the
abstract syntax tree.
 TerminalExpression
 implements an Interpret operation associated with terminal symbols in the
grammar.
 an instance is required for every terminal symbol in a sentence.
 NonterminalExpression
 one such class is required for every rule R ::= R1 R2 ... Rn in the grammar.
 maintains instance variables of type AbstractExpression for each of the
symbols R1 through Rn.
9

Participants (cont…)
 implements an Interpret operation for nonterminal symbols in the
grammar. Interpret typically calls itself recursively on the variables
representing R1 through Rn.
Context
 contains information that's global to the interpreter.
Client
 builds (or is given) an abstract syntax tree representing a particular
sentence in the language that the grammar defines.
 invokes the Interpret operation.
10

Collaborations
 The client builds (or is given) the sentence as an abstract syntax
tree of NonterminalExpression and TerminalExpression instances.
Then the client initializes the context and invokes the Interpret
operation.
 Each NonterminalExpression node defines Interpret in terms of
Interpret on each subexpression. The Interpret operation of each
TerminalExpression defines the base case in the recursion.
 The Interpret operations at each node use the context to store and
access the state of the interpreter.
11

Consequences
 Benefits:
 It's easy to change and extend the grammar. Because the pattern uses classes to
represent grammar rules, you can use inheritance to change or extend the
grammar.
 Implementing the grammar is easy, too. Classes defining nodes in the abstract
syntax tree have similar implementations.
 Adding new ways to interpret expressions. The Interpreter pattern makes it easier
to evaluate an expression in a new way.
 For example, you can support pretty printing or type-checking an expression by defining a
new operation on the expression classes.
 If you keep creating new ways of interpreting an expression, then consider using the Visitor
pattern to avoid changing the grammar classes.
12

Consequences (cont…)
Liability:
 Complex grammars are hard to maintain. The Interpreter pattern
defines at least one class for every rule in the grammar. Hence
grammars containing many rules can be hard to manage and
maintain. when the grammar is very complex, other techniques such
as parser or compiler generators are more appropriate.
13

Implementation
1) Creating the abstract syntax tree.
 The Interpreter pattern doesn't explain how to create an abstract syntax tree.
 The abstract syntax tree can be created by a table-driven parser, by a hand-
crafted parser, or directly by the client.
2) Defining the Interpret operation.
 If it's common to create a new interpreter, then it's better to use the Visitor
pattern to put Interpret in a separate "visitor" object.
3) Sharing terminal symbols with the Flyweight pattern.
 Grammars whose sentences contain many occurrences of a terminal symbol
might benefit from sharing a single copy of that symbol.
14

Example
 First example is a system for manipulating and evaluating Boolean
expressions implemented in C++. The grammar is defined as follows:
 We define two operations on Boolean expressions:
1. Evaluate, evaluates a Boolean expression in a context that assigns a true or false
value to each variable.
2. Replace, produces a new Boolean expression by replacing a variable with an
expression.
15

16

17
Create an expression interface:
- Expression.java
public interface Expression
{
public boolean interpret(String context);
}

18
Create concrete classes implementing the above interface:
- TerminalExpression.java
public class TerminalExpression implements Expression
{
private String data;
public TerminalExpression(String data){
this.data = data; }
@Override public boolean interpret(String context)
{ if(context.contains(data)){ return true;
} return false;
} }

19
- OrExpression.java
public class OrExpression implements Expression {
private Expression expr1 = null;
public OrExpression(Expression expr1, Expression expr2)
{
this.expr1 = expr1;
this.expr2 = expr2;
}
@Override
public boolean interpret(String context) {
return expr1.interpret(context) || expr2.interpret(context);
} }

20
- AndExpression.java
public class AndExpression implements Expression
{
public AndExpression(Expression expr1, Expression expr2)
{
this.expr1 = expr1;
this.expr2 = expr2; }
@Override
public boolean interpret(String context) {
return expr1.interpret(context) && expr2.interpret(context);
} }

21
nterpreterPatternDemo.java
public class InterpreterPatternDemo { //Rule: Robert and John are
male public static Expression getMaleExpression(){ Expression
robert = new TerminalExpression("Robert"); Expression john = new
TerminalExpression("John"); return new OrExpression(robert, john);
} //Rule: Julie is a married women public static Expression
getMarriedWomanExpression(){ Expression julie = new
TerminalExpression("Julie"); Expression married = new
TerminalExpression("Married"); return new AndExpression(julie,
married); }

22
public static void main(String[] args)
{
Expression isMale = getMaleExpression();
Expression isMarriedWoman = getMarriedWomanExpression();
System.out.println("John is male? " +
isMale.interpret("John"));
System.out.println("Julie is a married women? " +
isMarriedWoman.interpret("Married Julie"));
} }

Example (cont…)
Replace shows how the Interpreter pattern can be used for more
than just evaluating expressions. In this case, it manipulates the
expression itself.
23

Example (cont…)
BooleanExp defines the interface for all classes that define a
Boolean expression:
public abstract class BooleanExp
{
public BooleanExp(){}
public abstract bool Evaluate(Context aContext);
public abstract BooleanExp Replace(string name, BooleanExp bExp);
public abstract BooleanExp Copy();
}
24

Example (cont…)
 The class Context defines a mapping from variables to Boolean values.
public class Context
{
Hashtable values;
public Context()
{
values = new Hashtable();
}
public bool Lookup(VariableExp varExp)
{
return(bool)values[varExp.name];
}
public void Assign(VariableExp varExp, bool bval)
{
values.Add(varExp.name, bval);
}
}
25

Example (cont…)
public class VariableExp : BooleanExp
{
public string name;
public VariableExp(string _name){name = _name;}
public override bool Evaluate(Context aContext)
{
return aContext.Lookup(this);
}
public override BooleanExp Replace(string _name, BooleanExp bExp)
{
if (_name.Equals(name))
return bExp.Copy();
else
return new VariableExp(name);
}
public override BooleanExp Copy()
{
return new VariableExp(name);
}
}
26

Example (cont…)
public class AndExp : BooleanExp
{
public BooleanExp operand1;
public BooleanExp operand2;
public VariableExp(BooleanExp op1, BooleanExp op2)
{operand1 = op1; operand2 = op2;}
public override bool Evaluate(Context aContext)
{
return operand1.Evaluate(aContext) &&
operand2.Evaluate(aContext);
}
public override BooleanExp Replace(string _name, BooleanExp bExp)
{
return new AndExp(operand1.Replace(_name, bExp),
operand2.Replace(_name, bExp));
}
public override BooleanExp Copy()
{
return new AndExp(operand1.Copy(),operand2.Copy());
}
}
27

Example (cont…)
 (true and x) or (y and (not x))
BooleanExp expression;
Context context;
VariableExp x = new VariableExp("X");
VariableExp y = new VariableExp("Y");
expression = new OrExp( new AndExp(new Constant(true), x), new AndExp(y, new
NotExp(x)) );
context.Assign(x, false);
context.Assign(y, true);
bool result = expression.Evaluate(context);
 we can replace the variable y with a new expression and then reevaluate it:
VariableExp z = new VariableExp("Z");
NotExp not_z = new NotExp(z);
BooleanExp replacement = expression.Replace("Y", not_z);
context.Assign(z, true);
result = replacement.Evaluate(context);
28

Example (cont…)
 This example illustrates an important point about the Interpreter
pattern: many kinds of operations can "interpret" a sentence.
 Evaluate fits our idea of what an interpreter should do most closely—
that is, it interprets a program or expression and returns a simple
result.
 However, Replace can be viewed as an interpreter as well. It's an
interpreter whose context is the name of the variable being replaced
along with the expression that replaces it, and whose result is a new
expression.
 Even Copy can be thought of as an interpreter with an empty context.
29

Related Patterns
 Composite : The abstract syntax tree is an instance of the Composite
pattern.
 Flyweight shows how to share terminal symbols within the abstract
syntax tree.
 Iterator : The interpreter can use an Iterator to traverse the structure.
 Visitor can be used to maintain the behavior in each node in the abstract
syntax tree in one class.
30

Q&A

Interpreter

More Related Content

What's hot (20)

Similar to Interpreter (20)

Recently uploaded (20)

Interpreter

Editor's Notes