基于高级语言的词法分析实验java

词法分析是编译原理的一个重要内容，它的主要任务是将输入的源程序分割成一个一个的单词，同时识别出每个单词的类别，生成记号流作为后续语法分析的输入。在使用高级语言进行词法分析时，我们通常会使用正则表达式和有限自动机来实现。

下面是一个基于 Java 的简单词法分析器的示例代码：

import java.util.regex.*;

public class LexicalAnalyzer {
    private String input;  // 输入的源程序
    private int pos = 0;   // 当前读取到的位置

    // 定义正则表达式
    private static final Pattern ID_PATTERN = Pattern.compile("[a-zA-Z][a-zA-Z0-9]*");
    private static final Pattern NUM_PATTERN = Pattern.compile("[0-9]+");
    private static final Pattern OP_PATTERN = Pattern.compile("[+\\-*/]");

    // 构造函数
    public LexicalAnalyzer(String input) {
        this.input = input;
    }

    // 获取下一个记号
    public Token getNextToken() {
        while (pos < input.length()) {
            char c = input.charAt(pos);
            if (Character.isWhitespace(c)) {
                pos++;
                continue;  // 跳过空白字符
            }
            Matcher idMatcher = ID_PATTERN.matcher(input.substring(pos));
            if (idMatcher.lookingAt()) {
                String lexeme = idMatcher.group();
                pos += lexeme.length();
                return new Token(TokenType.ID, lexeme);
            }
            Matcher numMatcher = NUM_PATTERN.matcher(input.substring(pos));
            if (numMatcher.lookingAt()) {
                String lexeme = numMatcher.group();
                pos += lexeme.length();
                return new Token(TokenType.NUM, lexeme);
            }
            Matcher opMatcher = OP_PATTERN.matcher(input.substring(pos));
            if (opMatcher.lookingAt()) {
                String lexeme = opMatcher.group();
                pos += lexeme.length();
                return new Token(TokenType.OP, lexeme);
            }
            throw new RuntimeException("Invalid token at position " + pos);
        }
        return new Token(TokenType.EOF, "");  // 返回结束标记
    }

    // 测试代码
    public static void main(String[] args) {
        String input = "x = 1 + 2 * y";
        LexicalAnalyzer lexer = new LexicalAnalyzer(input);
        Token token;
        do {
            token = lexer.getNextToken();
            System.out.println(token);
        } while (token.getType() != TokenType.EOF);
    }
}

// 记号类型枚举
enum TokenType {
    ID,  // 标识符
    NUM,  // 数字
    OP,   // 运算符
    EOF  // 结束标记
}

// 记号类
class Token {
    private TokenType type;  // 记号类型
    private String lexeme;   // 记号对应的字符串

    public Token(TokenType type, String lexeme) {
        this.type = type;
        this.lexeme = lexeme;
    }

    public TokenType getType() {
        return type;
    }

    public String getLexeme() {
        return lexeme;
    }

    @Override
    public String toString() {
        return String.format("(%s, %s)", type, lexeme);
    }
}

在这个示例中，我们定义了三个正则表达式分别用于匹配标识符、数字和运算符。在 `getNextToken()` 方法中，我们使用 `Matcher` 类来进行匹配，如果匹配成功则返回相应的记号。如果无法匹配任何记号，则抛出异常。 `main()` 方法中我们将输入的源程序作为参数传入词法分析器，并依次输出每个记号的类型和字符串。

当我们使用 `LexicalAnalyzer` 类进行词法分析时，可以按照以下步骤进行：

1. 创建 `LexicalAnalyzer` 类的实例，将源程序作为参数传入；
2. 重复调用 `getNextToken()` 方法直到返回的记号类型为 `EOF`；
3. 对于每个记号，根据其类型进行相应的处理。

这样就完成了一个简单的基于 Java 的词法分析器。