这学期开始上计算机专业最难（据说是公认的）的一门课程——编译原理。还好，老师很有经验并且教得很用心。用的教材是《编译原理及实践》，寒假时上了豆瓣看了一下评论，据说是英文原版比中译版读起来还要通顺易懂，于是就借来英文版《Compiler Construction：Principle and Practice》，还真的不是那么难读懂，给我入门刚刚好。=) 

可是，第一节课老师才跟大家说“这本教材翻译得有点难懂，有能力的同学尽量读英文版。”噢，其他同学们其实早就买了中译版，老师这才如此建议...

---------------------------------------正文---------------------------------- 

按照第二章“Scanning”其实就是“词法分析 lexical analysis”的样例，需要将以下程序作为样例输入，进行词法分析获得一个个的Token及其可能的对应类别，例如保留字、特殊符号、数值、标识符等等。 

样例输入 sample.tny (.tny是教材中使用的称为Tiny语言的后缀）：

 

 
  
  1. { Sample program 
  2.   in TINY language - 
  3.   computes factorial 
  4. } 
  5. read x; { input an integer } 
  6. if 0 < x then { don't compute if x <= 0 } 
  7.   fact := 1; 
  8.   repeat 
  9.     fact := fact * x; 
  10.     x := x - 1 
  11.   until x = 0; 
  12.   write fact  { output factorial of x } 
  13. end 
 
  
 教材中要求的输出结果如下：
 
  
 
  
当时还没认真学习到用有限自动机（DFA）等等概念，自己先照着教材的样例输出用自己的傻瓜化办法实现一下，“追求”的目标是样例输出要和教材的一样（当然不能打印每一个句子啦）。下面是我的做法。 
 
  
★ 以下是在程序实现代码中使用Java的正则表达式功能，并对Tiny源程序代码做了一定的前提条件所完成的 Tiny 语言，其实就是模仿教材中的最终输出文件解析出每一个 Token。 
 
  
思路：
 
  
 
  
默认每个Token之间都以空格“ ”隔开，因此可用Java中的正则表达式将每一行依此规律拆分为一个个Token，然后再对每一个Token进行类别匹配（也用到正则表达式），最后按类别打印输出。以下实现但是不能够处理多行注释的问题。
 
  
sample1.tny
 
  
词法分析7 2011-03-29
 
  
  样例输出如下：
 
  
词法分析8 2011-03-29 
 
  
代码实现：
 
  
 
  
  1. package lexical_analysis; 
  2.  
  3. import java.io.BufferedReader; 
  4. import java.io.FileReader; 
  5. import java.util.regex.Pattern; 
  6.  
  7. /** 
  8.  * 假设 Tiny 源程序每个 Token 都用“空格”分开，因此可以简单地实现： 
  9.  * 每次读取源程序的一整行，使用Java中的正则表达式以“空格”提取出来， 
  10.  * 再对比“词汇表”以确定每一个 Token 的类别、属性(Attribute)。 
  11.  *  
  12.  * @author liguihao 
  13.  */ 
  14. public class SimpleLexicalAnalyser { 
  15.      
  16.     // 保留字 
  17.     private String [] reservedWords = new String[] {"read", "if", 
  18.                                                     "then", "repeat",  
  19.                                                     "until", "write", "end"}; 
  20.     // 数学运算符 
  21.     private String [] arithmeticSymbols = new String[] {"+", "-", "*", "/",  
  22.                                                         "%", ":=", "=", "<", 
  23.                                                         ">", "<=", ">="}; 
  24.     // 源程序文件输入流 
  25.     private BufferedReader sourceFile; 
  26.     // 代码行数 
  27.     private int lineCount = 0; 
  28.      
  29.      
  30.     public SimpleLexicalAnalyser(String sourceFilePath) throws Exception { 
  31.          
  32.         // 创建并加载源程序文件输入流 
  33.         this.sourceFile = new BufferedReader(new FileReader(sourceFilePath)); 
  34.     } 
  35.      
  36.     /** 
  37.      * 逐行扫描源程序代码 
  38.      * @throws Exception 
  39.      */ 
  40.     public void scan() throws Exception { 
  41.         String sourceLine = ""; 
  42.         String[] tokens; 
  43.          
  44.         while((sourceLine = this.sourceFile.readLine()) != null) { 
  45.             lineCount++; 
  46.             System.out.printf("%d: %s\n", lineCount, sourceLine); 
  47.             // 获取每一行的Token集合 
  48.             tokens = this.getTokens(sourceLine); 
  49.              
  50.             int size = tokens.length; 
  51.             for(int i = 0; i < size; i++) { 
  52.                  
  53.                 if(isArithmeticSymbol(tokens[i])) {     // 数学运算符         
  54.                     System.out.println("    " + lineCount + ": " + tokens[i]); 
  55.                 } else if(isReservedWord(tokens[i])) {  // 保留字 
  56.                     System.out.println("    " + lineCount + ": " + "reserved word: " + tokens[i]); 
  57.                 } else if(";".equals(tokens[i])) {      // 行结束符,即分号 
  58.                     System.out.println("    " + lineCount + ": " + tokens[i]); 
  59.                 }  else if(isID(tokens[i])) {           // 自定义标识符ID 
  60.                     System.out.println("    " + lineCount + ": " + "ID, name= " + tokens[i]); 
  61.                 } else if(isNum(tokens[i])) {           // 数值NUM 
  62.                     System.out.println("    " + lineCount + ": " + "NUM, val= " + tokens[i]); 
  63.                 } else if("{".equals(tokens[i])) {      // 行注释符，即左大括号{ 
  64.                     break;      // 直接跳过行注释 
  65.                 } 
  66.                  
  67.                 // 源程序文件结束符 
  68.                 if("end".equals(tokens[i])) { 
  69.                     lineCount++; 
  70.                     System.out.printf("%2d: %s\n", lineCount, "EOF"); 
  71.                     break; 
  72.                 } 
  73.             } 
  74.         } 
  75.     } 
  76.      
  77.     /** 
  78.      * 用“空格Space”正则表达式将每一行源代码拆分成单个Token的集合 
  79.      */ 
  80.     public String[] getTokens(String sourceLine) { 
  81.         Pattern pattern = Pattern.compile(" "); 
  82.         return pattern.split(sourceLine); 
  83.     } 
  84.      
  85.     /** 
  86.      * 判断是否为“保留字” 
  87.      * @param token 
  88.      * @return 
  89.      */ 
  90.     private boolean isReservedWord(String token) { 
  91.         int size = this.reservedWords.length; 
  92.         for(int i = 0; i < size; i++) { 
  93.             if(token.equals(reservedWords[i])) { 
  94.                 return true; 
  95.             } 
  96.         } 
  97.         return false; 
  98.     } 
  99.      
  100.     /** 
  101.      * 判断是否为“数学运算符” 
  102.      * @param token 
  103.      * @return 
  104.      */ 
  105.     private boolean isArithmeticSymbol(String token) { 
  106.         int size = this.arithmeticSymbols.length; 
  107.         for(int i = 0; i < size; i++) { 
  108.             if(token.equals(arithmeticSymbols[i])) { 
  109.                 return true; 
  110.             } 
  111.         } 
  112.         return false; 
  113.     } 
  114.      
  115.     /** 
  116.      * 判断是否为“数值NUM” 
  117.      * @param token 
  118.      * @return 
  119.      */ 
  120.     private boolean isNum(String token) { 
  121.         boolean flag = Pattern.matches("[a-zA-Z]+?", token); 
  122.         return flag; 
  123.     } 
  124.      
  125.     /** 
  126.      * 判断是否为“ID” 
  127.      * @param token 
  128.      * @return 
  129.      */ 
  130.     private boolean isID(String token) { 
  131.         boolean flag = Pattern.matches("\\d+?", token); 
  132.         return flag; 
  133.     } 
  134.      
  135.     /** 
  136.      * “词法分析程序”的启动入口 
  137.      * @param args 
  138.      */ 
  139.     public static void main(String[] args) throws Exception { 
  140.          
  141.         String sourceFilePath = "sample1.tny"; 
  142.         SimpleLexicalAnalyser lexicalAnalyser = new SimpleLexicalAnalyser(sourceFilePath); 
  143.         lexicalAnalyser.scan(); 
  144.     } 
  145. }