[JAVA] Lassen Sie uns Lexer (1) implementieren

Vorwort

Vielleicht funktioniert es in der oben genannten Umgebung.

Vorheriger Artikel: [Implementiere EAM] (https://qiita.com/mirror11akii/items/c72c2d2a108a9b75fccb) Erstellen Sie einen Lexer, der das als Ergebnis von EAM zurückgegebene Zeichen [] lexikalisch analysiert. Gestern gab es viele Fehler im Code, daher fühlte ich mich sehr unfähig und dachte darüber nach. Wir entschuldigen uns für die Unannehmlichkeiten. Bitte zögern Sie nicht, uns zu kontaktieren, wenn Sie Probleme haben.

Was ist Lexer?

Lexer ist ein lexikalischer Analysator. Es scheint, dass es auch Parser genannt wird, aber da Parser Parser Combinator heißt und es verwirrend wird, werde ich dies verwenden. Werfen wir einen Blick auf die Implementierung.

Implementierung

Lexer.java

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

public class Lexer {
    static String s = "";
    static List<String> l= new ArrayList<>();

    //private static List<Character> brackets = Arrays.asList('(',')','{','}','[',']');
    private static List<Character> operators = Arrays.asList('=','+','-','*','/');

    public static Type getType(final Character c){
        if(Character.isLetter(c)) return Type.alphabet;
        else if(Character.isDigit(c)) return Type.digit;
        else if(Character.isWhitespace(c)) return Type.space;
        else if(operators.contains(c)) return Type.operator;
        //else if(brackets.contains(c)) return Type.brackets;
        return Type.other;
    }
    public static void analyze(char c){
        switch (getType(c)) {
            case other:
                System.out.println("This character cannot be accepted");
                break;
            case space:
                if(s != ""){
                    l.add(s);
                    s = "";
                }
                break;
            //case bracket:
            case operator:
                if(s != ""){
                    l.add(s);
                    l.add(""+c);
                    s = "";
                    break;
                }
            case alphabet:
            case digit:
                s += c;
            default: break;
        }
    }
    public static void addString(){
        l.add(s);
    }
    public static List<String> getList(){
        return l;
    }
}

Type.java

public enum Type{
    alphabet,
    digit,
    space,
    operator,
    //bracket,
    other
}

Implementierungsbeschreibung

Nein, ich denke, es ist selbst ein schmutziger Code. Ich werde es von nun an beheben. Bitte lassen Sie mich wissen, wenn Sie eine gute Idee haben. Die Wortklammer ist in den Kommentaren zu sehen, bedeutet aber "Klammern". Es ist nervig, also habe ich es vorerst verschoben.

public static Type getType(final Character c) Finden Sie heraus, welche Zeichen Sie in diesem Teil lesen. public static void addString() Hier fügen wir der Liste das letzte Token hinzu

Lauf

EAM.java

import java.util.*;
import java.io.*;

public class EAM{
    private final FileReader fr;

    private EAM(final String s) throws IOException{
        fr = new FileReader(s);
    }
    public static char[] use(final String s,final Use<EAM,char[],IOException> u) throws IOException{
        final EAM eam = new EAM(s);
        char[] c;
        try{
            c = u.apply(eam);
        }finally{
            eam.close();
        }
        return c;
    }
    private void close() throws IOException{
        System.out.println("close()");
        fr.close();
    }
    public char[] read() throws IOException {
        char[] c = new char[100];
        int length = fr.read(c);
        return Arrays.copyOfRange(c, 0, length);
    }
}

Use.java

@FunctionalInterface
public interface Use<T,R,X extends Throwable>{
	R apply(T t) throws X;
}

Main.java

import java.io.IOException;

public class Main{
    public static void main(String[] args) throws IOException{
        char[] array = EAM.use("lib\\test.txt", eam -> eam.read());
        System.out.println("\n--EAM");
        for(char c : array){
            System.out.print(c);
            Lexer.analyze(c);
        }
        FLexer.addString();
        System.out.println( "\n--Lexer\n" + Lexer.getList());
    }
}

Ich lese mit dem vorherigen EAM. Der Inhalt der Methode ist hier und da unterschiedlich. Ich wollte char [] zurückgeben können.

Ergebnis

close()

--EAM
a = 2 + 7 * 3
log a
--Lexer
[a, =, 2, +, 7, *, 3, log, a]

Wenn es so aussieht, ist es ein Erfolg. Wenn Sie Fragen haben, wenden Sie sich bitte.