Tutorials

Tutorial: Lex- und Yacc-Programme unter Windows 10 mit Flex und Bison ausführen | Compilerbau

Melden

In der theoretischen Informatik und im Compilerbau sind Lex (Lexical Analyzer) und Yacc (Yet Another Compiler-Compiler) die Standardwerkzeuge, um Scanner und Parser zu erstellen. Unter modernen Systemen verwenden wir meist deren Weiterentwicklungen: Flex (Fast Lexical Analyzer) und Bison.

Dieses Tutorial führt Schritt für Schritt durch die Installation und Ausführung eines kombinierten Flex- und Bison-Programms unter Windows 10.

1. Voraussetzungen installieren

Da Lex/Flex und Yacc/Bison C-Code generieren, benötigen wir zwei Hauptbestandteile:

  1. Einen C-Compiler (wir nutzen GCC via MinGW).
  2. Die Windows-Versionen von Flex und Bison.

Schritt 1.1: MinGW (GCC Compiler) installieren

  1. Lade das MinGW-w64-Paket herunter (z. B. über SourceForge oder WinLibs).
  2. Entpacke es in einen einfachen Pfad, z. B. C:\mingw64.

Schritt 1.2: WinFlexBison herunterladen

Für Windows gibt es ein hervorragendes, portables Paket namens WinFlexBison.

  1. Lade das ZIP-Archiv von WinFlexBison (SourceForge oder GitHub) herunter.
  2. Entpacke das Archiv in einen Ordner deiner Wahl, z. B. C:\winflexbison.
  3. Wichtig: Benenne im Ordner die Dateien um, um die Standardbefehle nutzen zu können:
    • Benenne win_flex.exe in flex.exe um.
    • Benenne win_bison.exe in bison.exe um.

2. Umgebungsvariablen (PATH) einrichten

Damit die Werkzeuge in der Windows-Eingabeaufforderung (CMD) überall aufgerufen werden können, müssen deren Pfade zur Umgebungsvariable PATH hinzugefügt werden.

  1. Drücke die Windows-Taste und tippe Umgebungsvariablen ein. Wähle „Systemumgebungsvariablen bearbeiten“.
  2. Klicke unten auf Umgebungsvariablen....
  3. Wähle im unteren Bereich (Systemvariablen) die Variable Path aus und klicke auf Bearbeiten.
  4. Klicke auf Neu und füge folgende Pfade hinzu:
    • C:\mingw64\bin (oder der entsprechende Pfad zu deiner GCC-Installation)
    • C:\winflexbison
  5. Bestätige alle Fenster mit OK.

Überprüfung

Öffne eine neue Eingabeaufforderung (cmd) und teste die Installation:

gcc --version
flex --version
bison --version

Werden Versionsnummern ausgegeben, ist die Einrichtung erfolgreich abgeschlossen.

3. Ein einfaches Praxisbeispiel erstellen

Wir erstellen einen simplen Rechner, der einfache Additions- und Subtraktionsausdrücke parst. Erstelle dafür einen neuen Ordner (z. B. C:\CompilerProjekt).

3.1 Die Parser-Datei: parser.y (Bison/Yacc)

Erstelle eine Datei mit dem Namen parser.y und folgendem Inhalt:

%{
#include <stdio.h>
#include <stdlib.h>

int yylex(void);
void yyerror(const char *s);
%}

%token NUMBER
%token PLUS MINUS NEWLINE

%%

calc:
    | calc line
    ;

line:
      NEWLINE
    | expr NEWLINE { printf("Ergebnis: %d\n", $1); }
    ;

expr:
      NUMBER             { $$ = $1; }
    | expr PLUS NUMBER   { $$ = $1 + $3; }
    | expr MINUS NUMBER  { $$ = $1 - $3; }
    ;

%%

void yyerror(const char *s) {
    fprintf(stderr, "Fehler: %s\n", s);
}

int main(void) {
    printf("Rechner gestartet (Gib z. B. '5+3' ein, beenden mit Strg+C):\n");
    yyparse();
    return 0;
}

3.2 Die Lexer-Datei: lexer.l (Flex/Lex)

Erstelle im selben Ordner eine Datei mit dem Namen lexer.l:

%{
#include "parser.tab.h"
#include <stdlib.h>
%}

%option noyywrap

%%

[0-9]+      { yylval = atoi(yytext); return NUMBER; }
"+"         { return PLUS; }
"-"         { return MINUS; }
\n          { return NEWLINE; }
[ \t]       ; /* Leerzeichen ignorieren */
.           { printf("Unbekanntes Zeichen: %s\n", yytext); }

%%

4. Kompilierung und Ausführung

Öffne die Eingabeaufforderung (cmd) und navigiere in deinen Projektordner:

cd C:\CompilerProjekt

Führe die folgenden Schritte in dieser genauen Reihenfolge aus:

Schritt 4.1: Parser kompilieren (Bison)

Der Schalter -d erzeugt zusätzlich zur C-Datei den Header parser.tab.h, welcher die Token-Definitionen für Flex enthält:

bison -d parser.y

Ergebnis: Erstellt parser.tab.c und parser.tab.h.

Schritt 4.2: Lexer kompilieren (Flex)

Flex liest die Grammatik-Token und erstellt den C-Code für den Scanner:

flex lexer.l

Ergebnis: Erstellt lex.yy.c.

Schritt 4.3: C-Dateien linken und Binärdatei erstellen (GCC)

Kompiliere beide generierten C-Dateien zu einer ausführbaren Windows-Datei (.exe):

gcc parser.tab.c lex.yy.c -o mein_compiler.exe

Ergebnis: Erstellt mein_compiler.exe.

5. Das Programm testen

Starte das Programm über das Terminal:

mein_compiler.exe

Beispielinteraktion:

Rechner gestartet (Gib z. B. '5+3' ein, beenden mit Strg+C):
10+5
Ergebnis: 15
20-7
Ergebnis: 13

Du hast nun erfolgreich eine Lex- und Yacc-Entwicklungsumgebung auf Windows 10 eingerichtet und deinen ersten Compiler-Prototyp ausgeführt!

0