Faire un analyseur lexical

vous n'avez besoin ni D'ANTLR ni du livre du Dragon pour écrire un simple analyseur lexical à la main. Même les analyseurs lexicaux pour les langages plus complets (comme Java) ne sont pas très compliqués à écrire à la main. Évidemment, si vous avez une tâche industrielle, vous pourriez vouloir considérer des outils de force industrielle comme ANTLR ou une variante de lex, mais pour le plaisir d'apprendre comment l'analyse lexicale fonctionne, écrire une à la main serait probablement un exercice utile. Je suppose que c'est le cas, puisque vous avez dit tu es encore un débutant.

voici un analyseur lexical simple, écrit en Java, pour un sous-ensemble D'un langage Scheme-like, que j'ai écrit après avoir vu cette question. Je pense que le code est relativement facile à comprendre même si vous n'avez jamais vu une lexer avant, simplement parce que briser un flux de caractères (dans ce cas a String) dans un flux de jetons (dans ce cas, un List<Token>) n'est pas si difficile. Si vous avez des questions je peux essayer d'expliquer plus en profondeur.

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

Exemple utilisation:

~/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

une fois que vous aurez écrit un ou deux lexers simples comme celui-ci, vous aurez une assez bonne idée de la façon dont ce problème se décompose. Il serait alors intéressant d'explorer comment utiliser des outils automatisés comme lex. La théorie qui sous-tend les matchers basés sur l'expression régulière n'est pas trop difficile, mais il faut un certain temps pour bien la comprendre. Je pense que l'écriture de lexers à la main motive cette étude et vous aide à aborder le problème mieux que de plonger dans la théorie derrière convertir expressions régulières à automate fini (D'abord NFA, puis NFA à DFAs), etc... glisser dans cette théorie peut être beaucoup à prendre à la fois, et il est facile de se dépasser.

personnellement, alors que le livre du Dragon est bon et très complet, la couverture pourrait ne pas être la plus facile à comprendre parce qu'il vise à être complet, pas nécessairement accessible. Vous pourriez vouloir essayer quelques autres compilateur textes avant d'ouvrir le Dragon livre. Voici quelques livres gratuits, qui ont assez bonne introduction de la couverture, à mon humble avis:

http://www.ethoberon.ethz.ch/WirthPubl/CBEAll.pdf

http://www.diku.dk / ~ torbenm / Basics/

quelques articles sur la mise en oeuvre des expressions régulières (l'analyse lexicale automatisée utilise habituellement des expressions régulières)

http://swtch.com/~rsc / regexp/

j'espère que ça aide. Bonne chance.