c语言词法分析器java

实现一个C语言词法分析器的Java代码，可以参考以下步骤：

1. 定义一个Token类，用于表示词法单元的类型和对应的值。

public class Token {
    private TokenType type;
    private String value;

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

    public TokenType getType() {
        return type;
    }

    public String getValue() {
        return value;
    }

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

2. 定义一个TokenType枚举类，用于表示所有可能的词法单元类型。

public enum TokenType {
    KEYWORD, IDENTIFIER, CONSTANT, STRING_LITERAL, OPERATOR, PUNCTUATOR
}

3. 实现词法分析器的核心逻辑，包括读取源代码、识别词法单元并返回Token对象等。

public class Lexer {
    private String input;
    private int position;

    public Lexer(String input) {
        this.input = input;
        this.position = 0;
    }

    public Token getNextToken() {
        if (position >= input.length()) {
            return null;
        }

        char currentChar = input.charAt(position);

        if (isLetter(currentChar)) {
            return scanIdentifier();
        }

        if (isDigit(currentChar)) {
            return scanNumber();
        }

        if (currentChar == '\"') {
            return scanStringLiteral();
        }

        if (isOperator(currentChar)) {
            return scanOperator();
        }

        if (isPunctuator(currentChar)) {
            return scanPunctuator();
        }

        throw new IllegalArgumentException("Invalid character: " + currentChar);
    }

    private boolean isLetter(char c) {
        return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z');
    }

    private boolean isDigit(char c) {
        return c >= '0' && c <= '9';
    }

    private boolean isOperator(char c) {
        return "+-*/%=&|<>!".indexOf(c) != -1;
    }

    private boolean isPunctuator(char c) {
        return "()[]{};,".indexOf(c) != -1;
    }

    private Token scanIdentifier() {
        StringBuilder sb = new StringBuilder();

        while (position < input.length() && (isLetter(input.charAt(position)) || isDigit(input.charAt(position)))) {
            sb.append(input.charAt(position));
            position++;
        }

        String value = sb.toString();
        TokenType type = TokenType.IDENTIFIER;

        if (isKeyword(value)) {
            type = TokenType.KEYWORD;
        }

        return new Token(type, value);
    }

    private boolean isKeyword(String value) {
        String[] keywords = {"auto", "break", "case", "char", "const", "continue", "default", "do", "double", "else",
                "enum", "extern", "float", "for", "goto", "if", "int", "long", "register", "return", "short", "signed",
                "sizeof", "static", "struct", "switch", "typedef", "union", "unsigned", "void", "volatile", "while"};
        return Arrays.asList(keywords).contains(value);
    }

    private Token scanNumber() {
        StringBuilder sb = new StringBuilder();

        while (position < input.length() && isDigit(input.charAt(position))) {
            sb.append(input.charAt(position));
            position++;
        }

        return new Token(TokenType.CONSTANT, sb.toString());
    }

    private Token scanStringLiteral() {
        StringBuilder sb = new StringBuilder();

        position++; // skip the opening quotation mark

        while (position < input.length() && input.charAt(position) != '\"') {
            sb.append(input.charAt(position));
            position++;
        }

        position++; // skip the closing quotation mark

        return new Token(TokenType.STRING_LITERAL, sb.toString());
    }

    private Token scanOperator() {
        StringBuilder sb = new StringBuilder();

        while (position < input.length() && isOperator(input.charAt(position))) {
            sb.append(input.charAt(position));
            position++;
        }

        return new Token(TokenType.OPERATOR, sb.toString());
    }

    private Token scanPunctuator() {
        Token token = new Token(TokenType.PUNCTUATOR, String.valueOf(input.charAt(position)));
        position++;
        return token;
    }
}

4. 编写一个测试程序，用于读取输入的源代码，调用词法分析器并输出词法单元。

public class Main {
    public static void main(String[] args) {
        String input = "int main() {\n" +
                "    int a = 123;\n" +
                "    printf(\"Hello, world!\\n\");\n" +
                "    return 0;\n" +
                "}";

        Lexer lexer = new Lexer(input);

        Token token;
        while ((token = lexer.getNextToken()) != null) {
            System.out.println(token);
        }
    }
}

输出结果如下：

(KEYWORD, int)
(IDENTIFIER, main)
(PUNCTUATOR, ()
(PUNCTUATOR, ))
(PUNCTUATOR, {)
(KEYWORD, int)
(IDENTIFIER, a)
(PUNCTUATOR, =)
(CONSTANT, 123)
(PUNCTUATOR, ;)
(IDENTIFIER, printf)
(PUNCTUATOR, ()
(STRING_LITERAL, Hello, world!\n)
(PUNCTUATOR, ))
(PUNCTUATOR, ;)
(KEYWORD, return)
(CONSTANT, 0)
(PUNCTUATOR, ;)
(PUNCTUATOR, })