Package sam91;

Helpers
  digit = ['0'..'9'] ;
  lcase = ['a'..'z'] ;
  ucase = ['A'..'Z'] ;
  letter = lcase | ucase ;

Tokens
  iconst = ('+'|'-'|) digit+ ;
  blank = (' '|13|10)+ ;
  if = 'if' ;
  read = 'read' ;
  print = 'print' ;
  semi = ';' ;
  assign = '=' ;
  lt = '<' ;
  gt = '>' ;
  lbra = '{' ;
  rbra = '}' ;
  lpar = '(' ;
  rpar = ')' ;
  ident = letter (letter|digit)* ;

Ignored Tokens
  blank;

Productions
  prog = {stlist} stlist
       ;
  stlist = {stat} stlist stat
         | {empty}
         ;
  stat = {assign} ident assign expr semi
       | {read}   read ident semi
       | {print}  print expr semi
       | {if}     if lpar cond rpar stat
       | {block}  lbra stlist rbra
       ;
  cond = {gt} [left]:expr gt [right]:expr
       | {lt} [left]:expr lt [right]:expr
       ;
  expr = {ident}  ident
       | {iconst} iconst
       ;

package sam91;
import sam91.parser.*;
import sam91.lexer.*;
import sam91.node.*;
import java.io.*;
import java.util.*;

public class Sam91 {
  public static void main(String[] args) throws Exception {
    Parser p = new Parser(new Lexer(new PushbackReader(
      new InputStreamReader(new FileInputStream(args[0])), 1024)));
    Start tree = p.parse();
  }
}

read x; read y;
if(x > y) { z = x; x = y; y = z; }
print x; print y;

Package sam92;

Helpers
  digit = ['0'..'9'] ;
  lcase = ['a'..'z'] ;
  ucase = ['A'..'Z'] ;
  letter = lcase | ucase ;

Tokens
  iconst = ('+'|'-'|) digit+ ;
  blank = (' '|13|10)+ ;
  if = 'if' ;
  while = 'while' ;
  read = 'read' ;
  print = 'print' ;
  semi = ';' ;
  assign = '=' ;
  add = '+' ;
  sub = '-' ;
  lt = '<' ;
  gt = '>' ;
  lbra = '{' ;
  rbra = '}' ;
  lpar = '(' ;
  rpar = ')' ;
  ident = letter (letter|digit)* ;

Ignored Tokens
  blank;

Productions
  prog = {stlist} stlist
       ;
  stlist = {stat} stlist stat
         | {empty}
         ;
  stat = {assign} ident assign expr semi
       | {read}   read ident semi
       | {print}  print expr semi
       | {if}     if lpar expr rpar stat
       | {while}  while lpar expr rpar stat
       | {block}  lbra stlist rbra
       ;
  expr = {gt}  [left]:nexp gt [right]:nexp
       | {lt}  [left]:nexp lt [right]:nexp
       | {one} nexp
       ;
  nexp = {add}  nexp add term
       | {sub}  nexp sub term
       | {term} term
       ;
  term = {ident}  ident
       | {iconst} iconst
       ;

package sam92;
import sam92.parser.*;
import sam92.lexer.*;
import sam92.node.*;
import java.io.*;
import java.util.*;

public class Sam92 {
  public static void main(String[] args) throws Exception {
    Parser p = new Parser(new Lexer(new PushbackReader(
      new InputStreamReader(new FileInputStream(args[0])), 1024)));
    Start tree = p.parse();
  }
}

package sam92;
import sam92.analysis.*;
import sam92.node.*;
import java.io.*;
import java.util.*;

class Executor extends DepthFirstAdapter {
  Scanner sc = new Scanner(System.in);
  PrintStream pr = System.out;
  HashMap vars = new HashMap();
  @Override
  public void outAIdentTerm(AIdentTerm node) {
    String s = node.getIdent().getText().intern();
    if(!vars.containsKey(s)) vars.put(s, new Integer(0));
    setOut(node, vars.get(s));
  }
  @Override
  public void outAIconstTerm(AIconstTerm node) {
    setOut(node, new Integer(node.getIconst().getText()));
  }
  @Override
  public void outATermNexp(ATermNexp node) {
    setOut(node, getOut(node.getTerm()));
  }
  @Override
  public void outAAddNexp(AAddNexp node) {
    int v = (Integer)getOut(node.getNexp()) + (Integer)getOut(node.getTerm());
    setOut(node, new Integer(v));
  }  
  @Override
  public void outASubNexp(ASubNexp node) {
    int v = (Integer)getOut(node.getNexp()) - (Integer)getOut(node.getTerm());
    setOut(node, new Integer(v));
  }
  @Override
  public void outAOneExpr(AOneExpr node) {
    setOut(node, getOut(node.getNexp()));
  }
  @Override
  public void outAGtExpr(AGtExpr node) {
    if((Integer)getOut(node.getLeft()) > (Integer)getOut(node.getRight())) {
      setOut(node, new Integer(1));
    } else {
      setOut(node, new Integer(0));
    }
  }
  @Override
  public void outALtExpr(ALtExpr node) {
    if((Integer)getOut(node.getLeft()) < (Integer)getOut(node.getRight())) {
      setOut(node, new Integer(1));
    } else {
      setOut(node, new Integer(0));
    }
  }
  @Override
  public void outAAssignStat(AAssignStat node) {
    String s = node.getIdent().getText().intern();
    vars.put(s, getOut(node.getExpr()));
  }
  @Override
  public void outAReadStat(AReadStat node) {
    String s = node.getIdent().getText().intern();
    pr.print(s + "> ");
    vars.put(s, sc.nextInt()); sc.nextLine();
  }
  @Override
  public void outAPrintStat(APrintStat node) {
    pr.println(getOut(node.getExpr()).toString());
  }
  @Override
  public void caseAIfStat(AIfStat node) {
    node.getExpr().apply(this);
    if((Integer)getOut(node.getExpr()) != 0) { node.getStat().apply(this); }
  }
  @Override
  public void caseAWhileStat(AWhileStat node) {
    while(true) {
      node.getExpr().apply(this);
      if((Integer)getOut(node.getExpr()) == 0) { return; }
      node.getStat().apply(this);
    }
  }
}

Package sam93;
Helpers
  digit = ['0'..'9'];
  lcase = ['a'..'z'];
  ucase = ['A'..'Z'];
  letter = lcase | ucase;
Tokens
  woireru = 'を入れる';
  niyomikomu = 'に読み込む';
  ni = 'に';                
  wouchidasu = 'を打ち出す';
  naraba = 'ならば';
  wojikkou = 'を実行';
  noaida = 'の間';
  gt = '>';
  lt = '<';
  add = '+';
  sub = '-';
  number = digit+;
  ident = letter (letter|digit)*;
  blank = (' ' | 10 | 13 )+;

Ignored Tokens
  blank;

Productions
  prog = {stlist} stlist
       ;
  stlist = {empty}
       | {stat} stlist stat
       ;
  stat = {assign} ident ni expr woireru
       | {read}   ident niyomikomu
       | {print}  expr wouchidasu
       | {if}     expr naraba stlist wojikkou
       | {while}  expr noaida stlist wojikkou
       ;
  expr = {term} term
       | {gt} [left]:term gt [right]:term
       | {lt} [left]:term lt [right]:term
       ;
  term = {fact} fact
       | {add}  term add fact
       | {sub}  term sub fact
       ;
  fact = {ident} ident
       | {number} number
       ;

nに読み込む
xに1を入れる
n>0の間xにx+xを入れるnにn-1を入れるを実行
xを打ち出す

package sam93;
import sam93.parser.*;
import sam93.lexer.*;
import sam93.node.*;
import java.io.*;
import java.util.*;

public class Sam93 {
  public static void main(String[] args) throws Exception {
    Parser p = new Parser(new Lexer(new PushbackReader(
      new InputStreamReader(new FileInputStream(args[0])), 1024)));
    Start tree = p.parse();
    tree.apply(new Executor());
  }
}

package sam93;
import sam93.analysis.*;
import sam93.node.*;
import java.io.*;
import java.util.*;

class Executor extends DepthFirstAdapter {
  Scanner sc = new Scanner(System.in);
  PrintStream pr = System.out;
  HashMap<String,Integer> vars = new HashMap<String,Integer>();
  @Override
  public void outAAssignStat(AAssignStat node) {
    vars.put(node.getIdent().getText(), (Integer)getOut(node.getExpr()));
  }
  @Override
  public void outAReadStat(AReadStat node) {
    String s = node.getIdent().getText();
    pr.print(s + "> "); vars.put(s, sc.nextInt()); sc.nextLine();
  }
  @Override
  public void outAPrintStat(APrintStat node) {
    pr.println(getOut(node.getExpr()).toString());
  }
  @Override
  public void caseAIfStat(AIfStat node) {
    node.getExpr().apply(this);
    if((Integer)getOut(node.getExpr()) != 0) { node.getStlist().apply(this); }
  }
  @Override
  public void caseAWhileStat(AWhileStat node) {
    while(true) {
      node.getExpr().apply(this);
      if((Integer)getOut(node.getExpr()) == 0) { break; }
      node.getStlist().apply(this);
    }
  }
  @Override
  public void outATermExpr(ATermExpr node) {
    setOut(node, getOut(node.getTerm()));
  }
  @Override
  public void outAGtExpr(AGtExpr node) {
    if((Integer)getOut(node.getLeft()) > (Integer)getOut(node.getRight())) {
      setOut(node, new Integer(1));
    } else {
      setOut(node, new Integer(0));
    }
  }
  @Override
  public void outALtExpr(ALtExpr node) {
    if((Integer)getOut(node.getLeft()) < (Integer)getOut(node.getRight())) {
      setOut(node, new Integer(1));
    } else {
      setOut(node, new Integer(0));
    }
  }
  @Override
  public void outAFactTerm(AFactTerm node) {
    setOut(node, getOut(node.getFact()));
  }
  @Override
  public void outAAddTerm(AAddTerm node) {
    int v = (Integer)getOut(node.getTerm()) + (Integer)getOut(node.getFact());
    setOut(node, new Integer(v));
  }
  @Override
  public void outASubTerm(ASubTerm node) {
    int v = (Integer)getOut(node.getTerm()) - (Integer)getOut(node.getFact());
    setOut(node, new Integer(v));
  }
  @Override
  public void outAIdentFact(AIdentFact node) {
    setOut(node, vars.get(node.getIdent().getText()));
  }
  @Override
  public void outANumberFact(ANumberFact node) {
    setOut(node, Integer.parseInt(node.getNumber().getText()));
  }
}