作业五——词法分析程序的设计与实现

词法分析程序（Lexical Analyzer）要求：

- 从左至右扫描构成源程序的字符流

-  识别出有词法意义的单词（Lexemes）

-  返回单词记录（单词类别，单词本身）

-  滤掉空格

-  跳过注释

-  发现词法错误

程序结构：

输入：字符流（什么输入方式，什么数据结构保存）

处理：

–遍历（什么遍历方式）

–词法规则

输出：单词流（什么输出形式）

–二元组

单词类别：

1.标识符（10）

2.无符号数（11）

3.保留字（一词一码）

4.运算符（一词一码）

5.界符（一词一码）

单词符号	种别码	单词符号	种别码
begin	1	:	17
if	2	:=	18
then	3	<	20
while	4	<=	21
do	5	<>	22
end	6	>	23
l(l|d)*	10	>=	24
dd*	11	=	25
+	13	;	26
-	14	(	27
*	15	)	28
/	16	#	0

代码如下：

package com.bianyi_demo;

import java.io.File;
import java.io.FileReader;

public class LexicalAnalyze {
    private char ch;
    private String reservedWord[] = {"begin", "if", "then", "while", "do", "end"}; // 保留字

    // 判断是否是保留字
    boolean isReserveWord(String str) {
        for (int i = 0; i < reservedWord.length; i++) {
            if (reservedWord[i].equals(str))
                return true;
        }
        return false;
    }

    // 判断是否是字母
    boolean isLetter(char letter) {
        if ((letter >= 'a' && letter <= 'z') || (letter >= 'A' && letter <= 'Z'))
            return true;
        else
            return false;
    }

    // 判断是否是数字
    boolean isDigit(char digit) {
        if (digit >= '0' && digit <= '9')
            return true;
        else
            return false;
    }

    public void analyze(char[] chars) {
        String array = "";
        for (int i = 0; i < chars.length; i++) {
            ch = chars[i];
            array = "";

            if (ch == ' ' || ch == '	' || ch == '
' || ch == '
') {
            } else if (isLetter(ch)) {
                while ((isLetter(ch) || isDigit(ch))) {
                    array += ch;
                    ch = chars[++i];
                }
                // 回退一个字符
                i--;
                if (isReserveWord(array)) {
//                    System.out.println("这里是有显示的");
                    // 保留字
//                    System.out.println(array);
                    if (array.equals("begin")) {
                        System.out.println("(begin, 1)");
                    } else if (array.equals("if")) {
                        System.out.println("(if, 2)");
                    } else if (array.equals("then")) {
                        System.out.println("(then, 3)");
                    } else if (array.equals("while")) {
                        System.out.println("(while, 4)");
                    } else if (array.equals("do")) {
                        System.out.println("(do, 5)");
                    } else if (array.equals("end")) {
                        System.out.println("(end, 6)");
                    }
                } else {
                    if (array.equals("l(l|d)*"))
                        System.out.println("(l(l|d)*, 10)");
                    else if (array.equals("dd*"))
                        System.out.println("(dd*, 11)");
                }
            } else if (isDigit(ch) || (ch == '.')) {
                while (isDigit(ch) || (ch == '.' && isDigit(chars[++i]))) {
                    if (ch == '.')
                        i--;
                    array = array + ch;
                    ch = chars[++i];
                }
                // 属于无符号常数
                System.out.println("(" + array + ", 11)");
            } else switch (ch) {
                case '+':
                    System.out.println("(+, 13)");
                    break;
                case '-':
                    System.out.println("(-, 14)");
                    break;
                case '*':
                    System.out.println("(*, 15)");
                    break;
                case '/':
                    System.out.println("(/, 16)");
                    break;
                case '(':
                    System.out.println("((, 27)");
                    break;
                case ')':
                    System.out.println("(), 28)");
                    break;
                case '#':
                    System.out.println("(#, 0)");
                    break;
                case '=':
                    System.out.println("(=, 25)");
                    break;
                case '>': {
                    ch = chars[++i];
                    if (ch == '=')
                        System.out.println("(>=, 24)");
                    else {
                        System.out.println("（>, 23)");
                        i--;
                    }
                }
                break;
                case '<': {
                    ch = chars[++i];
                    if (ch == '=')
                        System.out.println("(<=, 21)");
                    else {
                        System.out.println("(<, 20)");
                        i--;
                    }
                }
                break;
                case ':': {
                    ch = chars[++i];
                    if (ch == '=')
                        System.out.println("(:=, 18)");
                    else {
                        System.out.println("(:, 17)");
                        i--;
                    }
                }
                break;
            }
        }
    }

    public static void main(String[] args) throws Exception {
        // 输入字符流：以txt文件的形式输入，将文件的字符读取到字符数组中去，采用遍历数组的方式，读取分类后输出
        File file = new File("./txt/analyzeTest.txt");
        FileReader reader = new FileReader(file);
        int length = (int) file.length();
        char buffer[] = new char[length + 1];
        reader.read(buffer);
        reader.close();
        new LexicalAnalyze().analyze(buffer);
    }
}

测试的文件：

程序运行结果如下图所示：