[JAVA] Implémentons Lexer (1)

Préface

Peut-être que cela fonctionne dans l'environnement ci-dessus.

Article précédent: [Mettre en œuvre EAM] (https://qiita.com/mirror11akii/items/c72c2d2a108a9b75fccb) Créez un Lexer qui analyse lexicalement le char [] renvoyé suite à EAM. Hier, il y avait beaucoup de failles dans le code, donc j'ai ressenti un manque de capacité et j'ai réfléchi dessus. Nous nous excusons pour le dérangement. N'hésitez pas à nous contacter en cas de problème.

Qu'est-ce que Lexer

Lexer est un analyseur lexical. Il semble qu'il s'appelle également Parser, mais comme Parser s'appelle Parser Combinator et que cela devient déroutant, je vais l'utiliser. Jetons un coup d'œil à l'implémentation.

la mise en oeuvre

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
}

Description de la mise en œuvre

Non, je pense que c'est moi-même un code sale. Je vais le réparer à partir de maintenant. Faites-moi savoir si vous avez une bonne idée. Le mot crochet peut être vu dans les commentaires, mais cela signifie "parenthèse". C'est ennuyeux, alors je remets ça pour le moment.

public static Type getType(final Character c) Découvrez quels sont les personnages que vous lisez dans cette partie. public static void addString() Ici, nous ajoutons le dernier jeton à la liste

Courir

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());
    }
}

Je lis en utilisant le précédent EAM. Le contenu de la méthode est différent ici et là. Je voulais pouvoir renvoyer char [].

résultat

close()

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

Si ça ressemble à ça, c'est un succès. Si vous avez des questions, n'hésitez pas à demander.