java 制作词法分析器

z0qdvdin  于 2022-12-25  发布在  Java
关注(0)|答案(6)|浏览(138)

我现在正在使用一个词法分析器程序，我使用的是Java。我一直在研究这个问题的答案，但直到现在我还没有找到任何答案。下面是我的问题：
输入：

System.out.println ("Hello World");

预期输出：

Lexeme----------------------Token

System [Key_Word]

.       [Object_Accessor]

out   [Key_Word]

. [Object_Accessor]

println  [Key_Word]

(  [left_Parenthesis]

"Hello World"    [String_Literal]

)   [right_Parenthesis]

;  [statement_separator]

我还是一个初学者，所以我希望你们能帮助我。谢谢。

Java

6条答案

按热度按时间
qco9c6ql

qco9c6ql1#

手工编写简单的词法分析器既不需要ANTLR也不需要Dragon book，即使是更完整语言的词法分析器也是如此（像Java）手工编写并不是非常复杂。显然，如果你有一个工业任务，你可能想考虑像ANTLR或一些lex变体这样的工业强度工具，但是为了学习词法分析是如何工作的，手写可能会被证明是一个有用的练习。我想是这样的，因为你说你还是个初学者。
这是一个简单的词法分析器，用Java编写，针对Scheme类语言的一个子集，是我在看到这个问题后编写的，我认为代码相对容易理解，即使你以前从未见过词法分析器，仅仅是因为打断一串字符（在本例中为String）转换为令牌流（在本例中为List<Token>）并不难，如果您有疑问，我可以尝试更深入地解释。

import java.util.List;
import java.util.ArrayList;

/*
 * Lexical analyzer for Scheme-like minilanguage:
 * (define (foo x) (bar (baz x)))
 */
public class Lexer {
    public static enum Type {
        // This Scheme-like language has three token types:
        // open parens, close parens, and an "atom" type
        LPAREN, RPAREN, ATOM;
    }
    public static class Token {
        public final Type t;
        public final String c; // contents mainly for atom tokens
        // could have column and line number fields too, for reporting errors later
        public Token(Type t, String c) {
            this.t = t;
            this.c = c;
        }
        public String toString() {
            if(t == Type.ATOM) {
                return "ATOM<" + c + ">";
            }
            return t.toString();
        }
    }

    /*
     * Given a String, and an index, get the atom starting at that index
     */
    public static String getAtom(String s, int i) {
        int j = i;
        for( ; j < s.length(); ) {
            if(Character.isLetter(s.charAt(j))) {
                j++;
            } else {
                return s.substring(i, j);
            }
        }
        return s.substring(i, j);
    }

    public static List<Token> lex(String input) {
        List<Token> result = new ArrayList<Token>();
        for(int i = 0; i < input.length(); ) {
            switch(input.charAt(i)) {
            case '(':
                result.add(new Token(Type.LPAREN, "("));
                i++;
                break;
            case ')':
                result.add(new Token(Type.RPAREN, ")"));
                i++;
                break;
            default:
                if(Character.isWhitespace(input.charAt(i))) {
                    i++;
                } else {
                    String atom = getAtom(input, i);
                    i += atom.length();
                    result.add(new Token(Type.ATOM, atom));
                }
                break;
            }
        }
        return result;
    }

    public static void main(String[] args) {
        if(args.length < 1) {
            System.out.println("Usage: java Lexer \"((some Scheme) (code to) lex)\".");
            return;
        }
        List<Token> tokens = lex(args[0]);
        for(Token t : tokens) {
            System.out.println(t);
        }
    }
}

使用示例：

~/code/scratch $ java Lexer ""
~/code/scratch $ java Lexer "("
LPAREN
~/code/scratch $ java Lexer "()"
LPAREN
RPAREN
~/code/scratch $ java Lexer "(foo)"
LPAREN
ATOM<foo>
RPAREN
~/code/scratch $ java Lexer "(foo bar)"
LPAREN
ATOM<foo>
ATOM<bar>
RPAREN
~/code/scratch $ java Lexer "(foo (bar))"
LPAREN
ATOM<foo>
LPAREN
ATOM<bar>
RPAREN
RPAREN

一旦你写了一两个这样的简单的lexer，你就会对这个问题如何分解有一个很好的了解。然后探索如何使用像lex这样的自动化工具会很有趣。基于正则表达式的匹配器背后的理论并不太难。但要完全理解还需要一段时间。我认为手工编写词法分析器可以激发学习的动力，并帮助您更好地掌握问题，而不是深入研究将正则表达式转换为有限自动化的理论（首先是NFA，然后是NFA到DFA），等等...涉足那个理论可能会一次接受很多东西，而且很容易被淹没。
就个人而言，尽管Dragon Book很好，而且非常全面，但其覆盖范围可能不是最容易理解的，因为它的目标是完整，而不一定是可访问的。在打开Dragon Book之前，您可能需要尝试一些其他的编译器文本。这里有一些免费的书籍，它们有相当不错的介绍性覆盖范围，恕我直言：
http://www.ethoberon.ethz.ch/WirthPubl/CBEAll.pdf
http://www.diku.dk/~torbenm/Basics/
一些关于正则表达式实现的文章（自动词法分析通常使用正则表达式）
http://swtch.com/~rsc/regexp/

赞(0）分享  回复(0）举报  2022-12-25
hjzp0vay

hjzp0vay2#

ANTLR 4将使用Java.g4参考语法来执行此操作。根据您希望Unicode转义序列的处理与语言规范的紧密程度，您有两个选项。

编辑：这个语法生成的标记的名称与您的表稍有不同。

  • 您的Key_Word令牌为Identifier
  • 您的Object_Accessor令牌为DOT
  • 您的left_Parenthesis令牌为LPAREN
  • 您的String_Literal令牌为StringLiteral
  • 您的right_Parenthesis令牌为RPAREN
  • 您的statement_separator令牌为SEMI
赞(0）分享  回复(0）举报  2022-12-25
9lowa7mx

9lowa7mx3#

词法分析本身就是一个主题，通常与编译器设计和分析有关。在编写代码之前，你应该先阅读它。我最喜欢的关于这个主题的书是Dragon，它会给予你一个很好的编译器设计介绍，甚至提供了所有编译器阶段的伪代码，你可以很容易地将其翻译成Java并从那里转移。
简而言之，主要思想是使用有限状态机解析输入，并将其划分为属于特定类的标记（例如，在您所需的输出中的括号或关键字）。状态机构建过程实际上是此分析的唯一困难部分，Dragon Book将为您提供对此事情的深入了解。

赞(0）分享  回复(0）举报  2022-12-25
798qvoo8

798qvoo84#

你可以使用像Lex & Bison这样的C库或者Antlr这样的Java库。词法分析可以通过制作自动机来完成。我给你举个小例子：
假设你需要标记一个字符串，其中关键字（语言）是{'echo', '.', ' ', 'end')，我所说的关键字是指语言只包含以下关键字。

echo .
end .

我的lexer应该输出

echo ECHO
 SPACE
. DOT
end END
 SPACE
. DOT

现在，要为这样一个记号生成器构建自动机，我可以这样开始

->(SPACE) (Back)
 |   
(S)-------------E->C->H->O->(ECHO) (Back)
 |              |
 .->(DOT)(Back)  ->N->D ->(END) (Back to Start)

上图可能很糟糕，但是你有一个用S表示的开始状态，现在你使用E并进入其他状态，现在你期望N或C分别出现在END和ECHO中。你不断地使用字符并在这个简单的有限状态机中到达不同的状态。最终，你到达某个Emit状态，例如在消耗了E，N，D您到达END的emit状态，它发出令牌，然后您返回到start状态。此循环将一直持续，直到您有字符流进入令牌化器。对于无效字符，您可以根据设计抛出错误或忽略。

赞(0）分享  回复(0）举报  2022-12-25
jmo0nnb3

jmo0nnb35#

CookCC（https://github.com/coconut2015/cookcc）为Java生成一个非常快、小、零依赖的词法分析器。

赞(0）分享  回复(0）举报  2022-12-25
bpsygsoo

bpsygsoo6#

编写一个程序来制作一个简单的词法分析器，它将从给定的字符流中构建一个符号表。您需要读取一个名为“input.txt”的文件来收集所有字符。为简单起见，输入文件将是一个没有头文件和方法的C/Java/Python程序（主程序的主体）。然后你将识别所有的数值，标识符，关键字，数学运算符，逻辑运算符和其他[distinct]。2更多细节请看例子。3你可以假设，每个关键字后面都有一个空格。

#include<stdio.h>
    #include<stdlib.h>
    #include<string.h>

    int main(){
    /* By Ashik Rabbani
    Daffodil International University,CSE43 */
    keyword_check();
    identifier_check();
    math_operator_check();
    logical_operator_check();
    numerical_check();
    others_check();

        return 0;
    }

    void math_operator_check()
    {

        char ch, string_input[15], operators[] = "+-*/%";
        FILE *fp;
        char tr[20];
        int i,j=0;

        fp = fopen("input.txt","r");

        if(fp == NULL){
            printf("error while opening the file\n");
            exit(0);
        }
       printf("\nMath Operators : ");
        while((ch = fgetc(fp)) != EOF){
               for(i = 0; i < 6; ++i){
                   if(ch == operators[i])
                       printf("%c ", ch);

               }
               }
                printf("\n");


        fclose(fp);
    }

    void logical_operator_check()
    {

        char ch, string_input[15], operators[] = "&&||<>";
        FILE *fp;
        char tr[20];
        int i,j=0;

        fp = fopen("input.txt","r");

        if(fp == NULL){
            printf("error while opening the file\n");
            exit(0);
        }
       printf("\nLogical Operators : ");
        while((ch = fgetc(fp)) != EOF){
               for(i = 0; i < 6; ++i){
                   if(ch == operators[i])
                       printf("%c ", ch);

               }
               }
                printf("\n");


        fclose(fp);
    }

    void numerical_check()
    {

        char ch, string_input[15], operators[] ={'0','1','2','3','4','5','6','7','8','9'};
        FILE *fp;

        int i,j=0;

        fp = fopen("input.txt","r");

        if(fp == NULL){
            printf("error while opening the file\n");
            exit(0);
        }
       printf("\nNumerical Values : ");
        while((ch = fgetc(fp)) != EOF){
               for(i = 0; i < 6; ++i){
                   if(ch == operators[i])
                       printf("%c ", ch);

               }
               }
                printf("\n");


        fclose(fp);
    }

    void others_check()
    {
        char ch, string_input[15], symbols[] = "(){}[]";
        FILE *fp;
        char tr[20];
        int i,j=0;

        fp = fopen("input.txt","r");

        if(fp == NULL){
            printf("error while opening the file\n");
            exit(0);
        }
       printf("\nOthers : ");
        while((ch = fgetc(fp)) != EOF){
               for(i = 0; i < 6; ++i){
                   if(ch == symbols[i])
                       printf("%c ", ch);

               }
               }
               printf("\n");


        fclose(fp);
    }

    void identifier_check()
    {
        char ch, string_input[15];
        FILE *fp;
    char    operators[] ={'0','1','2','3','4','5','6','7','8','9'};
        int i,j=0;

        fp = fopen("input.txt","r");

        if(fp == NULL){
            printf("error while opening the file\n");
            exit(0);
        }

        printf("\nIdentifiers : ");
        while((ch = fgetc(fp)) != EOF){

               if(isalnum(ch)){
                   string_input[j++] = ch;
               }
               else if((ch == ' ' || ch == '\n') && (j != 0)){
                       string_input[j] = '\0';
                       j = 0;

                       if(isKeyword(string_input) == 1)
                       {

                       }

                       else
                           printf("%s ", string_input);
               }

               }

                printf("\n");

        fclose(fp);
    }

    int isKeyword(char string_input[]){
        char keywords[32][10] = {"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"};
        int i, flag = 0;

        for(i = 0; i < 32; ++i){
            if(strcmp(keywords[i], string_input) == 0){
                flag = 1;
                break;
            }
        }

        return flag;
    }

    void keyword_check()
    {

        char ch, string_input[15], operators[] = "+-*/%=";
        FILE *fp;
        char tr[20];
        int i,j=0;

        printf(" Token Identification using C \n By Ashik-E-Rabbani \n 161-15-7093\n\n");

        fp = fopen("input.txt","r");

        if(fp == NULL){
            printf("error while opening the file\n");
            exit(0);
        }

        printf("\nKeywords : ");
        while((ch = fgetc(fp)) != EOF){

               if(isalnum(ch)){
                   string_input[j++] = ch;
               }
               else if((ch == ' ' || ch == '\n') && (j != 0)){
                       string_input[j] = '\0';
                       j = 0;

                       if(isKeyword(string_input) == 1)
                           printf("%s ", string_input);

               }

               }

     printf("\n");

        fclose(fp);
    }
赞(0）分享  回复(0）举报  2022-12-25
我来回答

相关问题

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新问答

    更多
    • 蜀ICP备2022004421号-2 NULL123 https://www.null123.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com