#format java
/**
 * InterpreterPattern example
 */
import java.util.*;
import java.io.*;

abstract class Node {
    public abstract void parse(Context context) throws ParseException;
}

// <program> ::= program <command list>
class ProgramNode extends Node {
    private Node commandListNode;
    public void parse(Context context) throws ParseException {
        context.skipToken("program");
        commandListNode = new CommandListNode();
        commandListNode.parse(context);
    }
    public String toString() {
        return "[program "+commandListNode+"]";
    }
}

// <command list> ::= <command>* end
class CommandListNode extends Node {
    private Vector list = new Vector();
    public void parse(Context context) throws ParseException {
        while(true) {
            if(context.currentToken() == null) {
                throw new ParseException("Missing 'end'");
            } else if(context.currentToken().equals("end")) {
                context.skipToken("end");
                break;
            } else {
                Node commandNode = new CommandNode();
                commandNode.parse(context);
                list.add(commandNode);
            }
        }
    }
    public String toString() {
        return ""+list;
    }
}

// <command> ::= <repeat command> | <primitive command>
class CommandNode extends Node {
    private Node node;
    public void parse(Context context) throws ParseException {
        if(context.currentToken().equals("repeat")) {
            node = new RepeatCommandNode();
            node.parse(context);
        } else {
            node = new PrimitiveCommandNode();
            node.parse(context);
        }
    }
    public String toString() {
        return node.toString();
    }
}

// <repeat command> ::= repeat <number> <command list>
class RepeatCommandNode extends Node {
    private int number;
    private Node commandListNode;
    public void parse(Context context) throws ParseException {
        context.skipToken("repeat");
        number = context.currentNumber();
        context.nextToken();
        commandListNode = new CommandListNode();
        commandListNode.parse(context);
    }
    public String toString() {
        return "[repeat "+number+" "+commandListNode+"]";
    }
}

// <primitive command> ::= go | right | left
class PrimitiveCommandNode extends Node {
    private String name;
    public void parse(Context context) throws ParseException {
        name = context.currentToken();
        context.skipToken(name);
        if(!name.equals("go") && !name.equals("right")
                && !name.equals("left")) {
            throw new ParseException(name +" is undefined");
        }
    }
    public String toString() {
        return name;
    }
}

class Context {
    private StringTokenizer tokenizer;
    private String currentToken;
    public Context(String text) {
        tokenizer = new StringTokenizer(text);
        nextToken();
    }
    public String nextToken() {
        if(tokenizer.hasMoreTokens()) {
            currentToken = tokenizer.nextToken();
        } else {
            currentToken = null;
        }
        return currentToken;
    }
    public String currentToken() {
        return currentToken;
    }
    public void skipToken(String token) throws ParseException {
        if(!token.equals(currentToken)) {
            throw new ParseException("Warning: "+token
                    +"is expected, but "+currentToken+" is found.");
        }
        nextToken();
    }
    public int currentNumber() throws ParseException {
        int number = 0;
        try {
            number = Integer.parseInt(currentToken);
        } catch(NumberFormatException e) {
            throw new ParseException("Warning: "+e);
        }
        return number;
    }
}

class ParseException extends Exception {
    public ParseException(String msg) {
        super(msg);
    }
}

/* 
this program needs program.txt

$ cat program.txt
program end
program go end
program go right go right go right go right end
program repeat 4 go right end end
program repeat 4 repeat 3 go right go left end right end end
*/

public class InterpreterMiniLanguage {
    public static void main(String[] args) {
        try {
            BufferedReader reader = new BufferedReader(
                    new FileReader("program.txt"));
            String text;
            while((text=reader.readLine()) != null) {
                System.out.println("text = \""+text+"\"");
                Node node = new ProgramNode();
                node.parse(new Context(text));
                System.out.println("node = "+node);
            }
        } catch(Exception e) {
            e.printStackTrace();
        }
    }
}