(基于Java)编写编译器和解释器第5A章：基于Antlr解析表达式和赋值语句及计算(连载)

本章在第3A章源代码基础上继续完善基于Antlr自动化的解析器，解释执行第5章解析的复合语句，赋值语句和表达式等相关中间码。并仿照第5章的简化标准，将一些东西简化掉，尽量能让你从最简处入手，掌握Antlr自动化构建解析器的第一步。

==>> 本章中文版源代码下载：svn co http://wci.googlecode.com/svn/branches/ch5_antlr/ 源代码使用了UTF-8编码，下载到本地请修改！

好的工具事半功倍，Antlr亦如此。antlr.org上有一个很有特色的工具antlrwors。如果使用Eclipse，可以安装插件antlrv3ide。两个工具的主要特色是可视化的创建EBNF语法，就如同你在前面章节看到的语法图一样。对于我来说，比较习惯antlrworks，它有良好的调试功能和DFA分析功能。

1 带AST构造的语法

program:
  compound_statement DOT!;
compound_statement:
  BEGIN statement_list END ->^(COMPOUND statement_list);
assignment_statement:
 ID ASSIGN expression -> ^(ASSIGN ID expression);
statement:
  compound_statement | assignment_statement;
statement_list:
  statement (SEMI statement)* SEMI? -> statement+;
expression:
  simple_expression (rel_ops^ simple_expression)?;
rel_ops:
  LT | LE | GT | GE | NOT_EQUAL;
simple_expression:
  signedterm (add_ops^ term)*;
signedterm:
  (a=PLUS | a=MINUS)? term ->{a!=null&&a.getType()==MINUS}?^(NEGATE term)->term;
add_ops:
  PLUS | MINUS | OR;
term:
  factor (mul_ops^ factor)*;
mul_ops:
  STAR | SLASH | DIV | MOD | AND;
factor:
  ID | NUMBER | STRING | NOT^ factor | LPAREN! expression RPAREN!;

目前的程序program由一个复合语句+结束的点"."组成。这个antlr语句基本与第五章的语法图5-1 和图5-2 类似。

2 计算Token值

填充第三章中关于计算常量token的值类ValueComputer，目前只对整数，字符串，浮点数token算值，算值逻辑与PascalStringToken和PascalNumberToken基本类似。

详细参见代码ValueComputer，这里不再显示。

3 引入符号表

这里复用第5章的符号表。需要使用符号表的地方有两个，一个是赋值语句的左边变量作为定义出现，另外一个是表达式中的标识符作为引用出现。在Antlr分析中，一般符号表必须要在语法树构建完成后才能进行，因为语法树构建过程中的节点是不清晰的。在Antlr中构建完AST之后，将使用Antlr树语法(Tree Grammar)去遍历语法，这个过程中我们可以加入符号表操作，也可以执行动作和生成代码。

4 执行赋值语句及计算语句

我原本想只想演示一下相关分析树，但是发现过于简单，于是就干脆执行算了，执行第5章的分析树是第6章内容，所有没有6A章了。

详细语法如下表：

tree grammar PascalVisitor;
options{
  tokenVocab=Pascal;
  ASTLabelType=PascalNode;
}
@header{
  package com.lifesting.book.wci;

  import wci.intermediate.*;
  import wci.intermediate.symtabimpl.SymTabKeyImpl;
}
@members{
  protected SymTabStack symtabStack = SymTabFactory.createSymTabStack();
  public SymTabStack getSymbolTableStack(){
    return this.symtabStack;
  }
}
program    :
  compound;
compound :
  ^(COMPOUND stmt+);
stmt:
  compound | assign;
assign:
  ^(ASSIGN i=ID e=expr){
    String var = $i.text.toLowerCase();
    SymTabEntry id_entry = symtabStack.lookup(var) ;
    if (id_entry == null)
    {
      id_entry = symtabStack.enterLocal(var);
    }
    id_entry.setAttribute(SymTabKeyImpl.DATA_VALUE,e);
  };
expr returns[Object value]:
  s=simple{value=s;}
  | ^(r=rel_ops e1=expr e2=expr){
    if (e1 instanceof Number && e2 instanceof Number){
      double de1 = ((Number)e1).doubleValue();
      double de2 = ((Number)e2).doubleValue();
      switch (r){
        case 1:
          value = de1 < de2;
          break;
        case 2:
          value = de1 <= de2;
          break;
        case 3:
          value = de1 > de2;
          break;
        case 4:
          value = de1 >= de2;
          break;
        case 5:
          value = de1 != de2;
          break;
        default:
          break;
      }
    }else{
      System.err.println("无法执行比较:"+e1+"["+r+"]"+e2);
    }
  };
simple returns[Object value]:
  s=term{value=s;}
  | ^(o=add_ops f1=negterm f2=simple)
  {
    double df1 = Double.parseDouble(f1.toString());
    if (f2 instanceof Number){
      double df2 = Double.parseDouble(f2.toString());
      switch (o)
      {
        case 1:
          value = df1+df2;
          break;
        case 2:
          value = df1-df2;
          break;
      }
    }else{
      System.err.println("不是一个数值:"+f2);
    }
  }
  | ^(o=add_ops f1=simple f2=simple){
     if (f1 instanceof Number && f2 instanceof Number){
        double df1 = Double.parseDouble(f1.toString());
        double df2 = Double.parseDouble(f2.toString());
        switch (o){
          case 1:
            value = df1+df2;
            break;
          case 2:
            value = df1-df2;
            break;
          default:
            break;
        }
     }else if (f1 instanceof Boolean && f2 instanceof Boolean){
       value= ((Boolean)f1).booleanValue() || ((Boolean)f2).booleanValue();
     }else{
       System.err.println("不能执行simple运算,f1="+f1+",f2="+f2);
     }
  };


negterm returns[Object value]:
  ^(NEGATE n=term) {
    if(n instanceof Number){
      return -Double.parseDouble(n.toString());
    }else{
      System.err.println("不是一个数值:"+n);
      value = 0.0;
    }
  };

term returns[Object value]:
  f0=factor{value=f0;}
  | ^(t=mul_ops f1=factor f2=factor){
    if (f1 instanceof Number && f2 instanceof Number){
      double df1 = Double.parseDouble(f1.toString());
      double df2 = Double.parseDouble(f2.toString());
      switch (t){
        case 1:
          value= df1*df2;
          break;
        case 2:
        case 3:
          value= df1/df2;
        case 4:
          value=df1 \% df2;
        default:
          break;
      }
    }else if (f1 instanceof Boolean && f2 instanceof Boolean){
      value= ((Boolean)f1).booleanValue() && ((Boolean)f2).booleanValue();
    }else{
      System.err.println("不能执行term运算,f1="+f1+",f2="+f2);
    }
  };

factor returns[Object value]:
  i = ID{
    String var = $i.text.toLowerCase();
    SymTabEntry id_entry = symtabStack.lookup(var);
    if (id_entry == null){
      System.err.println("使用不存在的变量:"+var);
    }else{
      value = id_entry.getAttribute(SymTabKeyImpl.DATA_VALUE);
    }
  }
  | n=NUMBER{value =((PascalAntlrToken)$n.getToken()).getValue();}
  | r=NUMBER_REAL{value = ((PascalAntlrToken)$r.getToken()).getValue();}
  | s=STRING {value =((PascalAntlrToken)$s.getToken()).getValue(); }
  | ^(NOT f=factor) {
      if (f instanceof Boolean){
        value = !((Boolean)f).booleanValue();
      }else{
        System.err.println("不是一个布尔值:"+f);
      }
    }

  | ^(NESTEXPR e = expr){
      value = e;
    };

rel_ops returns [int type]:
  LT{type =1;} | LE{type = 2;} | GT{type=3;} | GE{type=4;} | NOT_EQUAL{type=5;};
add_ops returns [int type]:
  PLUS{type=1;} | MINUS{type=2;} | OR{type=3;};
mul_ops returns [int type]:
  STAR{type = 1;} | SLASH{type=2;} | DIV{type=3;} | MOD{type=4;} | AND{type=5;};

测试程序：

public final class SimpleInterpreter {
    public static void main(String[] args) throws IOException, RecognitionException {
        //第5章示例Pascal
        InputStreamReader stream = new InputStreamReader(ShowToken.class.getResourceAsStream("/assignments.txt"));
        ANTLRReaderStream reader = new ANTLRReaderStream(stream);
        //词法分析器
        PascalLexer lexer = new PascalLexer(reader);
        CommonTokenStream token_stream = new CommonTokenStream(lexer);
        //语法分析器并带自己的TreeAdaptor，转换成自己的PascalNode
        PascalParser parser = new PascalParser(token_stream);
        parser.setTreeAdaptor(new PascalNodeAdaptor());
        program_return prog = parser.program();
        //遍历树并运算
        TreeNodeStream node_stream  = new CommonTreeNodeStream(prog.getTree());
        PascalVisitor interpreter = new PascalVisitor(node_stream);
        interpreter.program();
        SymTabStack stack = interpreter.getSymbolTableStack();
        SymTabEntry five_entry = stack.lookup("five");
        System.out.println("Five = "+five_entry.getAttribute(SymTabKeyImpl.DATA_VALUE));
        SymTabEntry str_entry = stack.lookup("str");
        System.out.println("str = "+str_entry.getAttribute(SymTabKeyImpl.DATA_VALUE));
        SymTabEntry  fahrenheit_entry = stack.lookup("fahrenheit");
        System.out.println("fahrenheit = "+fahrenheit_entry.getAttribute(SymTabKeyImpl.DATA_VALUE));
        SymTabEntry centigrade_entry = stack.lookup("centigrade");
        System.out.println("centigrade = "+centigrade_entry.getAttribute(SymTabKeyImpl.DATA_VALUE));
    }
}

最后的输出结果：

Five = 5.0
str = 'hello, world'
fahrenheit = 32.0
centigrade = 25