Java 实现《编译原理》简单-词法分析功能 - 程序解析

怼烎@ 2022-01-14 15:25 274阅读 0赞

### Java 实现《编译原理》简单-词法分析功能 - 程序解析 ###

简易词法分析功能

#### 要求及功能 ####

**（1）读取一个 txt 程序文件**（最后的 \# 作为结束标志，不可省去）

{ 
      int a, b;
      a = 10;
      if(a>=1){ 
        b = a + 20;
      }
    }
    #

**（2）词法识别分析表**

<table> 
 <thead> 
  <tr> 
   <th>单词类别</th> 
   <th>单词自身值</th> 
   <th>内部编码</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>关键字</td> 
   <td>int、for、while、do、return、break、continue</td> 
   <td>1</td> 
  </tr> 
  <tr> 
   <td>标识符</td> 
   <td>除关键字外的以字母开头，后跟字母、数字的字符序列</td> 
   <td>2</td> 
  </tr> 
  <tr> 
   <td>常数</td> 
   <td>无符号整型数</td> 
   <td>3</td> 
  </tr> 
  <tr> 
   <td>运算符</td> 
   <td>+、-、*、/、&gt;、&lt;、=、&gt;=、&lt;=、!=</td> 
   <td>4</td> 
  </tr> 
  <tr> 
   <td>界限符</td> 
   <td>,、;、{、}、(、)</td> 
   <td>5</td> 
  </tr> 
  <tr> 
   <td>换行符</td> 
   <td>\n</td> 
   <td>6</td> 
  </tr> 
 </tbody> 
</table>

**（3）输出结果：**

(5,{ )
    (6,\n)
    (1,int)
    (2,a)
    (5,,)
    (2,b)
    (5,;)
    (6,\n)
    (2,a)
    (4,=)
    (3,10)
    (5,;)
    (6,\n)
    (2,if)
    (5,()
    (2,a)
    (4,>=)
    (3,1)
    (5,))
    (5,{ )
    (6,\n)
    (2,b)
    (4,=)
    (2,a)
    (4,+)
    (3,20)
    (5,;)
    (6,\n)
    (5,})
    (6,\n)
    (5,})
    (6,\n)
    (0,#)

并保存成新的 txt 文件

#### 编程实现 ####

**（1）程序文件目录：**  
![在这里插入图片描述][20190613230934614.png]

**（2）Word.java 文件：**

package com.java997.analyzer.lexical;
    
    /** * <p> * 表示识别后的词实体类 * * @author XiaoPengwei * @since 2019-06-13 */
    public class Word { 
    
        /** * 种别码 */
        private int typeNum;
    
        /** * 扫描得到的词 */
        private String word;
    
        public int getTypeNum() { 
            return typeNum;
        }
    
        public void setTypeNum(int typeNum) { 
            this.typeNum = typeNum;
        }
    
        public String getWord() { 
            return word;
        }
    
        public void setWord(String word) { 
            this.word = word;
        }
    }

**（3）CodeScanner.java 文件：**

package com.java997.analyzer.lexical;
    
    /** * <p> * 字符扫描 * * @author XiaoPengwei * @since 2019-06-13 */
    public class CodeScanner { 
    
        private static String _KEY_WORD_END = "end string of string";
        private int charNum = 0;
        private Word word;
    
        private char[] input = new char[255];
        private char[] token = new char[255];
        private int p_input = 0;
        private int p_token = 0;
    
        private char ch;
    
        /** * 关键字数组 */
        private String[] rwtab = { "int", "if", "while", "do", "return", "break", "continue", _KEY_WORD_END};
    
        /** * 逻辑运算数组 */
        private String[] logicTab = { "==",">=","<=","!=", _KEY_WORD_END};
    
        public CodeScanner(char[] input) { 
            this.input = input;
        }
    
        /** * 取下一个字符 * * @return */
        public char m_getch() { 
            if (p_input < input.length) { 
                ch = input[p_input];
                p_input++;
            }
            return ch;
        }
    
        /** * 如果是标识符或者空白符就取下一个字符 */
        public void getbc() { 
            while ((ch == ' ' || ch == '\t') && p_input < input.length) { 
                ch = input[p_input];
                p_input++;
            }
        }
    
        /** * 把当前字符和原有字符串连接 */
        public void concat() { 
            token[p_token] = ch;
            p_token++;
            token[p_token] = '\0';
        }
    
        /** * 回退一个字符 */
        public void retract() { 
            p_input--;
        }
    
        /** * 判断是否为字母 * * @return boolean * @author XiaoPengwei */
        public boolean isLetter() { 
            return ch >= 'a' && ch <= 'z' || ch >= 'A' && ch <= 'Z';
        }
    
        /** * 判断是否为数字 * * @return boolean * @author XiaoPengwei */
        public boolean isDigit() { 
            return ch >= '0' && ch <= '9';
        }
    
        /** * 查看 token 中的字符串是否是关键字，是的话返回关键字种别编码，否则返回 2 * * @return */
        public int isKey() { 
            int i = 0;
            while (rwtab[i].compareTo(_KEY_WORD_END) != 0) { 
                if (rwtab[i].compareTo(new String(token).trim()) == 0) { 
                    return i + 1;
                }
                i++;
            }
            return 2;
        }
    
        /** * 可能是逻辑预算字符 * * @return */
        public Boolean isLogicChar() { 
            return ch == '>' || ch == '<'|| ch == '='|| ch == '!';
        }
    
    
        /** * 查看 token 中的字符串是否是逻辑运算符，是的话返回关键字种别编码，否则返回 2 * * @return */
        public int isLogicTab() { 
            int i = 0;
            while (logicTab[i].compareTo(_KEY_WORD_END) != 0) { 
                if (logicTab[i].compareTo(new String(token).trim()) == 0) { 
                    return i + 1;
                }
                i++;
            }
            return 4;
        }
    
        /** * 能够识别换行，单行注释和多行注释的 * 换行的种别码设置成30 * 多行注释的种别码设置成31 * * @return */
        public Word scan() { 
            token = new char[255];
            Word myWord = new Word();
            myWord.setTypeNum(10);
            myWord.setWord("");
    
            p_token = 0;
            m_getch();
            getbc();
            if (isLetter()) { 
                while (isLetter() || isDigit()) { 
                    concat();
                    m_getch();
                }
                retract();
                myWord.setTypeNum(isKey());
                myWord.setWord(new String(token).trim());
                return myWord;
            } else if (isLogicChar()) { 
                while (isLogicChar()) { 
                    concat();
                    m_getch();
                }
                retract();
                myWord.setTypeNum(4);
                myWord.setWord(new String(token).trim());
                return myWord;
            } else if (isDigit()) { 
                while (isDigit()) { 
                    concat();
                    m_getch();
                }
                retract();
                myWord.setTypeNum(3);
                myWord.setWord(new String(token).trim());
                return myWord;
            } else { 
                switch (ch) { 
                    //5
                    case ',':
                        myWord.setTypeNum(5);
                        myWord.setWord(",");
                        return myWord;
                    case ';':
                        myWord.setTypeNum(5);
                        myWord.setWord(";");
                        return myWord;
                    case '{':
                        myWord.setTypeNum(5);
                        myWord.setWord("{");
                        return myWord;
                    case '}':
                        myWord.setTypeNum(5);
                        myWord.setWord("}");
                        return myWord;
                    case '(':
                        myWord.setTypeNum(5);
                        myWord.setWord("(");
                        return myWord;
                    case ')':
                        myWord.setTypeNum(5);
                        myWord.setWord(")");
                        return myWord;
                    //4
                    case '=':
                        myWord.setTypeNum(4);
                        myWord.setWord("=");
                        return myWord;
                    case '+':
                        myWord.setTypeNum(4);
                        myWord.setWord("+");
                        return myWord;
                    case '-':
                        myWord.setTypeNum(4);
                        myWord.setWord("-");
                        return myWord;
                    case '*':
                        myWord.setTypeNum(4);
                        myWord.setWord("*");
                        return myWord;
                    case '/':
                        myWord.setTypeNum(4);
                        myWord.setWord("/");
                        return myWord;
    
                    case '\n':
                        myWord.setTypeNum(6);
                        myWord.setWord("\\n");
                        return myWord;
                    case '#':
                        myWord.setTypeNum(0);
                        myWord.setWord("#");
                        return myWord;
                    default:
                        concat();
                        myWord.setTypeNum(-1);
                        myWord.setWord("ERROR INFO: WORD = \"" + new String(token).trim() + "\"");
                        return myWord;
                }
            }
        }
    }

**（4）MainAnalyzer.java 文件：**

package com.java997.analyzer.lexical;
    
    import java.io.File;
    import java.io.FileNotFoundException;
    import java.io.FileWriter;
    import java.io.IOException;
    import java.io.Writer;
    import java.util.ArrayList;
    import java.util.Scanner;
    
    /** * <p> * 执行主程序 * * @author XiaoPengwei * @since 2019-06-13 */
    public class MainAnalyzer { 
        private File inputFile;
        private File outputFile;
        private String fileContent;
        private ArrayList<Word> list = new ArrayList<>();
    
        /** * 构造方法 * * @param input * @param output * @author XiaoPengwei */
        public MainAnalyzer(String input, String output) { 
            //实例化输入文件
            inputFile = new File(input);
    
            //实例化输出文件
            outputFile = new File(output);
        }
    
        /** * 从指定的 txt 文件中读取源程序文件内容 * * @return java.lang.String */
        public String getContent() { 
            StringBuilder stringBuilder = new StringBuilder();
            try (Scanner reader = new Scanner(inputFile)) { 
                while (reader.hasNextLine()) { 
                    String line = reader.nextLine();
                    stringBuilder.append(line + "\n");
                    System.out.println(line);
                }
                System.out.println("Successful reading of files：" + inputFile.getName());
            } catch (FileNotFoundException e) { 
                e.printStackTrace();
            }
            return fileContent = stringBuilder.toString();
        }
    
        /** * 然后扫描程序，在程序结束前将扫描到的词添加到 list 中 * 最后把扫描结果保存到指定的文件中 * * @param fileContent * @return void */
        public void analyze(String fileContent) { 
            int over = 1;
            Word word = new Word();
    
            //调用扫描程序
            CodeScanner scanner = new CodeScanner(fileContent.toCharArray());
            System.out.println("The result:");
            while (over != 0) { 
                word = scanner.scan();
                System.out.println("(" + word.getTypeNum() + "," + word.getWord() + ")");
                list.add(word);
                over = word.getTypeNum();
            }
            saveResult();
        }
    
        /** * 将结果写入到到指定文件中 * 如果文件不存在，则创建一个新的文件 * 用一个 foreach 循环将 list 中的项变成字符串写入到文件中 */
        public void saveResult() { 
    
            //创建文件
            if (!outputFile.exists()) { 
                try { 
                    outputFile.createNewFile();
                } catch (IOException e1) { 
                    e1.printStackTrace();
                }
            }
    
            //写入文件
            try (Writer writer = new FileWriter(outputFile)) { 
                for (Word word : list) { 
                    writer.write("(" + word.getTypeNum() + " ," + word.getWord() + ")\n");
                }
            } catch (IOException e) { 
                e.printStackTrace();
            }
        }
    
        public static void main(String[] args) { 
    
            //注意输入文件路径/名称必须对, 输出文件可以由程序创建
            MainAnalyzer analyzer = new MainAnalyzer("D:\\analyzer\\src\\main\\java\\com\\java997\\analyzer\\lexical\\input.txt", "D:\\analyzer\\src\\main\\java\\com\\java997\\analyzer\\lexical\\output.txt");
    
            analyzer.analyze(analyzer.getContent());
        }
    }

**（5）input.txt 文件：**

{ 
      int a, b;
      a = 10;
      if(a>=1){ 
        b = a + 20;
      }
    }
    #

#### 执行测试 ####

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9pY29kZS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70]

[20190613230934614.png]: /images/20220114/6f54eef50c9447889b04fcdf064c746b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9pY29kZS5ibG9nLmNzZG4ubmV0_size_16_color_FFFFFF_t_70]: /images/20220114/7e4dbecd3a964c41bfffeb5dbf12ac26.png