33
ANTLR #antlr

ANTLR - RIP TutorialJavaScript-Ziel 4. Java-Ziel Standardmäßig generiert ANTLR einen Parser aus der Befehlszeile in der Java-Programmiersprache: Java -jar antlr-4.5.3-complete.jar

  • Upload
    others

  • View
    8

  • Download
    0

Embed Size (px)

Citation preview

  • ANTLR

    #antlr

  • Inhaltsverzeichnis

    Über 1

    Kapitel 1: Erste Schritte mit ANTLR 2

    Bemerkungen 2

    Versionen 2

    Examples 3

    Hallo Welt 3

    Kapitel 2: ANTLR-Ziele / Sprachlaufzeiten 5

    Examples 5

    Sprachunterstützung 5

    Python-Parser-Setup 6

    Kapitel 3: Besucher 8

    Einführung 8

    Examples 8

    Beispiel 8

    Kapitel 4: Einführung in ANTLR v3 10

    Examples 10

    Installation und Einrichtung 10

    So installieren Sie ANTLR in Eclipse 10

    Kapitel 5: Einführung in ANTLR v4 13

    Bemerkungen 13

    Examples 13

    Installation für die Befehlszeile verwenden 13

    Installation mithilfe von Build Automation-Tools 14

    Installieren Sie in Eclipse und Build Hello World 14

    ANTLR in Visual Studio 2015 installieren (mithilfe von Nuget) 16

    Testen Sie, ob alles funktioniert 19

    Kapitel 6: Lexer regelt in v4 21

    Examples 21

    Einfache Regeln 21

    Fragmente 21

  • Implizite Lexer-Regeln 22

    Prioritätsregeln 22

    Lexer-Befehle 23

    Aktionen und semantische Prädikate 24

    Kapitel 7: TestRig / grun 25

    Examples 25

    Setup TestRig 25

    Zugriff auf TestRig 25

    Grammatik mit Visual Parse Tree erstellen 26

    Kapitel 8: Zuhörer 29

    Examples 29

    Listener-Events mit Labels 29

    Credits 30

  • Über

    You can share this PDF with anyone you feel could benefit from it, downloaded the latest version from: antlr

    It is an unofficial and free ANTLR ebook created for educational purposes. All the content is extracted from Stack Overflow Documentation, which is written by many hardworking individuals at Stack Overflow. It is neither affiliated with Stack Overflow nor official ANTLR.

    The content is released under Creative Commons BY-SA, and the list of contributors to each chapter are provided in the credits section at the end of this book. Images may be copyright of their respective owners unless otherwise specified. All trademarks and registered trademarks are the property of their respective company owners.

    Use the content presented in this book at your own risk; it is not guaranteed to be correct nor accurate, please send your feedback and corrections to [email protected]

    https://riptutorial.com/de/home 1

    http://riptutorial.com/ebook/antlrhttps://archive.org/details/documentation-dump.7zmailto:[email protected]

  • Kapitel 1: Erste Schritte mit ANTLR

    Bemerkungen

    ANTLR (ANother Tool for Language Recognition) ist ein leistungsstarker Parser-Generator zum Lesen, Verarbeiten, Ausführen oder Übersetzen von strukturiertem Text oder Binärdateien. Es wird häufig verwendet, um Sprachen, Tools und Frameworks zu erstellen. ANTLR generiert aus einer Grammatik einen Parser, der Parsing-Bäume erstellen und durchlaufen kann.

    Offizielle Antlr-Website (verweist immer auf die neueste Version)•

    Antlr-Versionen Antlr besteht aus zwei großen Teilen, der Grammatik (Grammatikdateien) und den generierten Codedateien, die von der auf Zielsprache basierenden Grammatik abgeleitet werden. Die antlr-Versionen haben das Format V1.V2.V3:

    V1: Änderung in V1 bedeutet, dass eine neue Syntax von Features in Grammatikdateien eingeführt wurde

    V2: Änderung in V2 bedeutet, dass neue Funktionen oder wichtige Korrekturen in die generierten Dateien eingefügt wurden (z. B. Hinzufügen neuer Funktionen).

    V3: steht für Fehlerbehebungen oder kleinere Verbesserungen•

    Laufzeitbibliotheken und Codegenerierungsziele Das Antlr-Tool ist in Java geschrieben, kann jedoch Parser und Lexer in verschiedenen Sprachen generieren. Um den Parser und den Lexer auszuführen, benötigen Sie auch die Laufzeitbibliothek von antlr neben dem Parser- und Lexer-Code. Die unterstützte Zielsprache (und Laufzeitbibliotheken) sind folgende:

    Java•

    C #•

    Python (2 und 3)•

    JavaScript•

    Versionen

    Ausführung Veröffentlichungsdatum

    2,0 1997-05-01

    3,0 2011-01-19

    4,0 2013-01-21

    4.1 2013-07-01

    https://riptutorial.com/de/home 2

    http://www.antlr.org/

  • Ausführung Veröffentlichungsdatum

    4.2 2014-02-05

    4.2.1 2014-03-25

    4.2.2 2014-04-07

    4.3 2014-06-19

    4.4 2014-07-16

    4,5 2015-01-23

    4.5.1 2016-07-16

    4.5.2 2016-01-30

    4.5.3 2016-03-31

    4.6 2016-12-15

    4.7 2017-03-30

    Examples

    Hallo Welt

    Eine einfache Hallo-Welt-Grammatik finden Sie hier :

    // define a grammar called Hello grammar Hello; r : 'hello' ID; ID : [a-z]+ ; WS : [ \t\r\n]+ -> skip ;

    Um dieses .g4-Beispiel zu erstellen, können Sie den folgenden Befehl über das Betriebssystem / die Befehlszeile Ihres Betriebssystems ausführen:

    Java -jar antlr-4.5.3-complete.jar Hello.g4 //OR if you have setup an alias or use the recommended batch file antlr4 Hello.g4

    Das Erstellen dieses Beispiels sollte zu folgender Ausgabe im Verzeichnis "Hello.g4" führen:

    Hello.tokens1. HelloBaseListener.java2. HalloLexer.java3.

    https://riptutorial.com/de/home 3

    https://gist.github.com/mattmcd/5425206

  • HelloLexer.tokens4. HelloListener.java5. HelloParser.java6.

    Wenn Sie diese Dateien in Ihrem eigenen Projekt verwenden, müssen Sie die ANTLR-JAR-Datei mit einschließen. Um alle diese Dateien mit Java zu kompilieren, führen Sie im selben Betriebsverzeichnis oder per Pfad den folgenden Befehl aus:

    javac *.java

    Erste Schritte mit ANTLR online lesen: https://riptutorial.com/de/antlr/topic/4453/erste-schritte-mit-antlr

    https://riptutorial.com/de/home 4

    https://riptutorial.com/de/antlr/topic/4453/erste-schritte-mit-antlrhttps://riptutorial.com/de/antlr/topic/4453/erste-schritte-mit-antlr

  • Kapitel 2: ANTLR-Ziele / Sprachlaufzeiten

    Examples

    Sprachunterstützung

    ANTLR kann Parser für eine Reihe von Programmiersprachen generieren:

    C # -Ziel1. Python-Ziel2. JavaScript-Ziel3. Java-Ziel4.

    Standardmäßig generiert ANTLR einen Parser aus der Befehlszeile in der Java-Programmiersprache:

    Java -jar antlr-4.5.3-complete.jar yourGrammar.g4 //Will output a java parser

    Um die Zielsprache zu ändern, können Sie den folgenden Befehl über das OS-Terminal / die Befehlszeile ausführen:

    antlr4 -Dlanguage=Python3 yourGrammar.g4 //with alias java -jar antlr-4.5.3-complete.jar -Dlanguage=Python3 yourGrammar.g4 //without alias

    Anstatt den Parameter '-Dlanguage' jedes Mal in der Befehlszeile / im Terminal zu verwenden, um den gewünschten Parser für eine bestimmte Sprache zu erstellen, können Sie das Ziel aus Ihrer .g4-Grammatikdatei auswählen, indem Sie das Ziel in den globalen Abschnitt einschließen:

    options { language = "CSharp"; } //or options { language="Python"; }

    Um die generierte Parserausgabe zu verwenden, stellen Sie sicher, dass Sie über die ANTLR-Laufzeit für die angegebene Sprache verfügen:

    CSharp-Laufzeit1. Python 2-Laufzeit2. Python 3 Laufzeit3.

    Vollständige Anweisungen und Informationen zu ANTLR-Laufzeitbibliotheken

    https://riptutorial.com/de/home 5

    http://www.antlr.org/download/antlr-csharp-runtime-4.5.3.ziphttps://pypi.python.org/pypi/antlr4-python2-runtimehttps://pypi.python.org/pypi/antlr4-python3-runtimehttp://www.antlr.org/download.html

  • Python-Parser-Setup

    Nachdem Sie Ihre .g4-Grammatikdatei mit ANTLR.jar ausgeführt haben, sollten Sie eine Reihe von Dateien generieren lassen, z.

    1.yourGrammarNameListener.py 2.yourGrammarNameParser.py 3.yourGrammarName.tokens ...

    Um diese in einem Python-Projekt zu verwenden, schließen Sie die Python-Laufzeitumgebung in Ihrem Arbeitsbereich ein, sodass jede Anwendung, die Sie entwickeln, auf die ANTLR-Bibliothek zugreifen kann. Dazu können Sie die Laufzeit in Ihren aktuellen Projektordner extrahieren oder innerhalb Ihrer IDE in Ihre Projektabhängigkeiten importieren.

    #main.py import yourGrammarNameParser import sys #main method and entry point of application def main(argv): """Main method calling a single debugger for an input script""" parser = yourGrammarNameParser parser.parse(argv) if __name__ == '__main__': main(sys.argv)

    Dieses Setup enthält Ihren Parser und akzeptiert Eingaben von der Befehlszeile, um die Verarbeitung einer als Parameter übergebenen Datei zu ermöglichen.

    #yourGrammarNameParser.py from yourGrammarNameLexer import yourGrammarNameLexer from yourGrammarNameListener import yourGrammarNameListener from yourGrammarNameParser import yourGrammarNameParser from antlr4 import * import sys class yourGrammarNameParser(object): """ Debugger class - accepts a single input script and processes all subsequent requirements """ def __init__(self): # this method creates the class object. pass #function used to parse an input file def parse(argv): if len(sys.argv) > 1: input = FileStream(argv[1]) #read the first argument as a filestream lexer = yourGrammarNameLexer(input) #call your lexer stream = CommonTokenStream(lexer) parser = yourGrammarNameParser(stream)

    https://riptutorial.com/de/home 6

  • tree = parser.program() #start from the parser rule, however should be changed to your entry rule for your specific grammar. printer = yourGrammarNameListener(tree,input) walker = ParseTreeWalker() walker.walk(printer, tree) else: print('Error : Expected a valid file')

    Diese Dateien, die mit der ANTLR-Laufzeitumgebung und Ihren aus Ihrer Grammatikdatei generierten Dateien kombiniert werden, akzeptieren einen einzelnen Dateinamen als Argument und lesen und parsen Ihre Grammatikregeln.

    Um die Basisfunktionalität zu erweitern, sollten Sie auch den Standardlistener erweitern, um relevante Ereignisse für Token zu behandeln, die während der Laufzeit auftreten.

    ANTLR-Ziele / Sprachlaufzeiten online lesen: https://riptutorial.com/de/antlr/topic/3414/antlr-ziele---sprachlaufzeiten

    https://riptutorial.com/de/home 7

    https://riptutorial.com/de/antlr/topic/3414/antlr-ziele---sprachlaufzeitenhttps://riptutorial.com/de/antlr/topic/3414/antlr-ziele---sprachlaufzeiten

  • Kapitel 3: Besucher

    Einführung

    Was ist der Unterschied zwischen einem Zuhörer und einem Besucher? Der Unterschied zwischen Listener- und Besuchermechanismen besteht darin, dass Listenermethoden vom von ANTLR bereitgestellten Walker-Objekt aufgerufen werden, während Besuchermethoden ihren Kindern explizite Besuchsaufrufe ausführen müssen. Wenn Sie vergessen, visit () für die untergeordneten Elemente eines Knotens aufzurufen, werden diese Unterbäume nicht besucht. In besucher haben wir die möglichkeit, baum zu gehen, während Sie im hörer nur auf den baumläufer reagieren.

    Examples

    Beispiel

    Grammatikbeispiel (Beispiel 4)

    grammar Expr; prog: (expr NEWLINE)* ; expr: expr ('*'|'/') expr | expr ('+'|'-') expr | INT | '(' expr ')' ; NEWLINE : [\r\n]+ ; INT : [0-9]+ ;

    Besucher generieren

    Um einen Besucher zu generieren oder um einen Besucher für Ihre Grammatik zu deaktivieren, verwenden Sie die folgenden Flags:

    -visitor generate parse tree visitor -no-visitor don't generate parse tree visitor (default)

    Der Kommandozeilen- / Terminalbefehl zum Erstellen Ihrer Grammatik mit einem Besucher wird wie unten gezeigt in Bezug auf das ausgewählte Flag und mögliche Aliasnamen formatiert:

    java - jar antlr-4.5.3-complete.jar Expr.g4 -visitor java - jar antlr-4.5.3-complete.jar Expr.g4 -no-visitor

    Die Ausgabe wird ein Parser / Lexer mit einem Besucher bzw. keinem Besucher sein.

    Ausgabe Die Ausgabe ist in diesem Beispiel ExprBaseVisitor.java und ExprVisitor.java . Dies sind die relevanten Java-Dateien für die Implementierung der Besucherfunktionalität. Es ist oft

    https://riptutorial.com/de/home 8

  • ideal, eine neue Klasse zu erstellen und den ExprBaseVisitor zu erweitern, um neue Besucherfunktionen für jede Methode zu implementieren.

    // Generated from Expr.g4 by ANTLR 4.5.3 import org.antlr.v4.runtime.tree.AbstractParseTreeVisitor; /** * This class provides an empty implementation of {@link ExprVisitor}, * which can be extended to create a visitor which only needs to handle a subset * of the available methods. * * @param The return type of the visit operation. Use {@link Void} for * operations with no return type. */ public class ExprBaseVisitor extends AbstractParseTreeVisitor implements ExprVisitor { /** * {@inheritDoc} * *

    The default implementation returns the result of calling * {@link #visitChildren} on {@code ctx}.

    */ @Override public T visitProg(ExprParser.ProgContext ctx) { return visitChildren(ctx); } /** * {@inheritDoc} * *

    The default implementation returns the result of calling * {@link #visitChildren} on {@code ctx}.

    */ @Override public T visitExpr(ExprParser.ExprContext ctx) { return visitChildren(ctx); } }

    Besucher online lesen: https://riptutorial.com/de/antlr/topic/8211/besucher

    https://riptutorial.com/de/home 9

    https://riptutorial.com/de/antlr/topic/8211/besucher

  • Kapitel 4: Einführung in ANTLR v3

    Examples

    Installation und Einrichtung

    So installieren Sie ANTLR in Eclipse

    (Zuletzt getestet mit Indigo und ANTLR IDE 2.1.2)

    Installieren Sie Eclipse.1. Laden Sie den ANTLR-Binärdatenträger herunter , der ANTLR v2 enthält. Extrahieren Sie in ein temporäres Verzeichnis. Kopieren Sie den antlr-nn-Ordner an einen geeigneten dauerhaften Speicherort, z. B. den Ordner, in dem Eclipse installiert ist.

    2.

    Fügen Sie Eclipse eine ANTLR IDE-Aktualisierungssite hinzu.Klicken Sie in Eclipse auf Hilfe und wählen Sie Neue Software installieren.•Klicken Sie auf die Schaltfläche Hinzufügen.•Geben Sie im Fenster Repository hinzufügen für Standort http://antlrv3ide.sourceforge.net/updates ein, und geben Sie ANTLR IDE für den Namen ein. Klicken Sie auf OK, um zum Fenster Available Software zurückzukehren.

    Aktivieren Sie das Kontrollkästchen für ANTLR IDE vn.nn und klicken Sie auf, bis es installiert ist. Eclipse wird wahrscheinlich neu starten.

    3.

    Konfigurieren Sie die ANTLR-IDE.Klicken Sie im Eclipse-Hauptfenster auf Fenster und dann auf Einstellungen.•Erweitern Sie im linken Bereich ANTLR, und wählen Sie Generator aus.•Klicken Sie im rechten Fensterbereich auf die Schaltfläche Hinzufügen.•Klicken Sie im Fenster ANTLR-Paket hinzufügen auf Verzeichnis…, navigieren Sie zum Speicherort des Ordners antlr-nn und klicken Sie auf OK.

    Klicken Sie auf OK, um das Fenster ANTLR-Paket hinzufügen zu schließen.•Wählen Sie im linken Bereich Code Generator aus, und klicken Sie im rechten Bereich auf relativen Ordner "Projekt". Geben Sie einen Ordnernamen ein. Beispiele: antlr-java oder antlr-generiert.

    Wählen Sie andere Konfigurationsparameter aus, überprüfen Sie jedoch NICHT -nfa oder –dfa unter Allgemein im Gebäudefenster. Wenn diese Option aktiviert ist, werden ANTLR-Fehler verursacht, die die Generierung von Java-Dateien im Ausgabeordner verhindern.

    Klicken Sie auf OK, um das Fenster "Einstellungen" zu schließen.•

    4.

    Erstellen Sie ein neues Java-Projekt und aktivieren Sie die ANTLR-Unterstützung.Gehen Sie im Eclipse-Hauptfenster zu Datei, Neu, Java-Projekt. Klicken Sie auf Weiter, geben Sie einen Projektnamen ein und klicken Sie auf Fertig stellen.

    Um die ANTLR-Unterstützung für das Projekt zu aktivieren, klicken Sie im Paket-Explorer-Fenster (linker Bereich) mit der rechten Maustaste auf das soeben erstellte Projekt und wählen Sie Konfigurieren, In ANTLR-Projekt konvertieren.

    Fügen Sie dem Projekt die ANTLR complete-JAR-Datei hinzu: Klicken Sie mit der •

    5.

    https://riptutorial.com/de/home 10

    http://www.antlr.org/download/antlr-3.4-complete.jarhttp://www.antlr.org/download/antlr-3.4-complete.jarhttp://antlrv3ide.sourceforge.net/updates

  • rechten Maustaste auf das Projekt und wählen Sie Eigenschaften, Java-Erstellungspfad, klicken Sie auf Externe JARs hinzufügen…, navigieren Sie zur ANTLR-JAR-Datei, wählen Sie sie aus und klicken Sie auf OK. Klicken Sie auf OK, um das Eigenschaftenfenster des Projekts zu schließen.

    Erstellen Sie eine ANTLR-Grammatik.Erstellen Sie eine neue ANTLR-Grammatik: Klicken Sie mit der rechten Maustaste auf den Ordner src des Projekts, dann auf Datei, Neu, Andere, erweitern Sie ANTLR, und wählen Sie Kombinierte Grammatik aus. Klicken Sie auf Weiter, geben Sie den Namen der Grammatik ein, wählen Sie eine Option für die Sprache aus und klicken Sie auf Fertig stellen.

    Eine ".g" -Datei wird mit den ausgewählten Optionen und einer leeren Regel erstellt. Fügen Sie oben die Anweisungen options = Java, @header, @lexer :: header und @members hinzu (siehe Beispiel). Die automatische Vervollständigung ist die einfachste Möglichkeit, diese hinzuzufügen (drücken Sie die STRG-Leertaste, um die Liste der automatischen Vervollständigungen aufzurufen).

    6.

    Speichern Sie die Grammatik.Beim Speichern sollte ein Ordner mit generiertem Java-Code für die Grammatik im Projekt-Explorer angezeigt werden. Wenn dies nicht der Fall ist, stellen Sie sicher, dass die Optionen -nfa oder -dfa in den ANTLR-Einstellungen unter Allgemein im Gebäudefenster nicht aktiviert sind (Schritt 4g). [Überprüfen Sie, ob diese erforderlich sind: Markieren Sie die CLASSPATH-Umgebungsvariable, die auf Java7 zeigt, das Ihrer Eclipse-Installation (32 oder 64 Bit) entspricht, und die Windows Path-Umgebungsvariable hatte Java7 SDK.]

    Um zu vermeiden, dass Java-Fehler nicht in einen Typ aufgelöst werden können, klicken Sie mit der rechten Maustaste auf den Ordner, der den generierten Java-Code enthält. Klicken Sie dann auf Build Path (Pfad erstellen) und Als Quellordner verwenden.

    7.

    BEISPIEL KOMBINIERTE GRAMMARBEIT

    grammar test; //must match filename.g options { language = Java; } @header { //parser package pkgName; //optional import java..*; } @members { //parser // java code here } @lexer::header { //lexer package pkgName; //optional import java..*; } @lexer::members { // java code here

    https://riptutorial.com/de/home 11

  • } /*------------------------------------------------------------------ * PARSER RULES (convention is all lowercase) *------------------------------------------------------------------*/ parserule: LEXRULE; /*------------------------------------------------------------------ * LEXER RULES (convention is all uppercase) *------------------------------------------------------------------*/ LEXRULE: 'a'..'z';

    Einführung in ANTLR v3 online lesen: https://riptutorial.com/de/antlr/topic/6629/einfuhrung-in-antlr-v3

    https://riptutorial.com/de/home 12

    https://riptutorial.com/de/antlr/topic/6629/einfuhrung-in-antlr-v3https://riptutorial.com/de/antlr/topic/6629/einfuhrung-in-antlr-v3

  • Kapitel 5: Einführung in ANTLR v4

    Bemerkungen

    ANTLR v4 ist ein leistungsfähiges Werkzeug zum Erstellen neuer Programmiersprachen und zum Verarbeiten / Übersetzen von strukturiertem Text oder Binärdateien. ANTLR verwendet eine von Ihnen erstellte Grammatik, um einen Parser zu erstellen, der einen Parser-Baum (oder einen abstrakten Syntax-Baum, AST) erstellen und durchlaufen kann. Der Parser besteht aus Ausgabedateien in einer von Ihnen angegebenen Zielsprache. ANTLR v4 unterstützt mehrere Ziele, darunter Java, C #, JavaScript, Python2 und Python3. An C ++ wird derzeit gearbeitet. Für das Arbeiten in GUI-IDEs gibt es Plug-Ins für Visual Studio, Intellij, NetBeans und Eclipse.

    Allgemeine Informationen finden Sie auf der ANTLR-Website . Um sich mit ANTLR zu beschäftigen, lesen Sie das empfohlene Buch von Terrence Parr (dem Mann, der ANTLR erstellt hat) The Definitive ANTLR 4 Reference .

    Wichtige Versionsinformationen

    4.5: 22.01.15 - JavaScript-Ziel hinzugefügt und C # -Ziel aktualisiert. 4.5 Versionshinweise•4.4: 16.07.14 - Python2 und Python3 als Ziele hinzugefügt. 4.4 Versionshinweise•4.3: 18.06.14 - Wichtige Fehlerbehebungen; vorbereitet für das Hinzufügen neuer Ziele. 4.3 Versionshinweise

    4.2: 02/04/14 - Verbesserte Syntax zum Auswählen / Abgleichen von Parsing-Bäumen. 4.2 Versionshinweise

    4.1: 30.06.13 - Verbesserte Parsing-Leistung; ASTs nach PNG exportieren. 4.1 Versionshinweise

    4.0: 21.01.13 - Erstveröffentlichung.•

    Examples

    Installation für die Befehlszeile verwenden

    ANTLR wird als Java-Jar-Datei vertrieben. Sie kann hier heruntergeladen werden . Da ANTLR als JAR-Datei kompiliert wird, muss die Java-Laufzeitumgebung ausgeführt werden, wenn Sie sie nicht haben. Sie kann hier heruntergeladen werden .

    Nachdem die ANTLR-JAR-Datei heruntergeladen wurde, können Sie ANTLR auf dieselbe Weise wie jede andere JAR-Datei über die Befehlszeile ausführen:

    Java -jar antlr-4.5.3-complete.jar

    (Vorausgesetzt, Sie arbeiten in demselben Verzeichnis wie die Datei antlr-4.5.3-complete.jar).

    Dies sollte etwas ähnliches ausgeben:

    https://riptutorial.com/de/home 13

    http://www.antlr.org/https://pragprog.com/book/tpantlr2/the-definitive-antlr-4-referencehttps://github.com/antlr/antlr4/releases/tag/4.5https://github.com/antlr/antlr4/releases/tag/4.4https://github.com/antlr/antlr4/releases/tag/4.3https://github.com/antlr/antlr4/releases/tag/4.3https://github.com/antlr/antlr4/releases/tag/4.2https://github.com/antlr/antlr4/releases/tag/4.2https://github.com/antlr/antlr4/releases/tag/4.1https://github.com/antlr/antlr4/releases/tag/4.1http://www.antlr.org/download.htmlhttp://www.oracle.com/technetwork/java/javase/downloads/jre8-downloads-2133155.html

  • ANTLR Parser Generator Version 4.5.3 -o ___ specify output directory where all output is generated -lib ___ specify location of grammars, tokens files -atn generate rule augmented transition network diagrams -encoding ___ specify grammar file encoding; e.g., euc-jp -message-format ___ specify output style for messages in antlr, gnu, vs2005 -long-messages show exception details when available for errors and warnings -listener generate parse tree listener (default) -no-listener don't generate parse tree listener -visitor generate parse tree visitor -no-visitor don't generate parse tree visitor (default) -package ___ specify a package/namespace for the generated code -depend generate file dependencies -D=value set/override a grammar-level option -Werror treat warnings as errors -XdbgST launch StringTemplate visualizer on generated code -XdbgSTWait wait for STViz to close before continuing -Xforce-atn use the ATN simulator for all predictions -Xlog dump lots of logging info to antlr-timestamp.log

    Andere empfohlene Aktionen für das Setup sind:

    1. Add antlr4-complete.jar to CLASSPATH, either: Permanently: Using System Properties dialog > Environment variables > Create or append to CLASSPATH variable Temporarily, at command line: SET CLASSPATH=.;C:\Javalib\antlr4-complete.jar;%CLASSPATH% 3.Create batch commands for ANTLR Tool, TestRig in dir in PATH antlr4.bat: java org.antlr.v4.Tool %* grun.bat: java org.antlr.v4.gui.TestRig %*

    Nach dem Setup können Sie eine Anwendung mit Ihrer .g4-Grammatikdatei erstellen:

    Java -jar antlr-4.5.3-complete.jar yourGrammar.g4

    Mit dem Parameter -Dlanguage können Sie auch eine Anwendung in anderen Sprachen erstellen. Um zum Beispiel C # -Dateien zu generieren, würden Sie Folgendes tun:

    java -jar antlr-4.5.3-complete.jar yourGrammar.g4 -Dlanguage=CSharp

    Sehen Sie hier für eine vollständige Liste von vorgefertigten Grammatik ist für Programmiersprachen.

    Installation mithilfe von Build Automation-Tools

    Laden Sie die neueste Version von ANTLR herunter und extrahieren Sie sie in einen Ordner.

    Sie können auch Maven, Gradle oder ein anderes Build-Tool verwenden, um von der Laufzeit (den von den generierten Grammatiken verwendeten Klassen) org.antlr:antlr4-runtime .

    Um als Teil des Build-Prozesses automatisch den Parser in einem Maven-Projekt zu generieren, verwenden Sie das Maven-Plugin : org.antlr:antlr4 .

    Installieren Sie in Eclipse und Build Hello World

    https://riptutorial.com/de/home 14

    https://github.com/antlr/grammars-v4http://www.antlr.org/download.htmlhttp://www.antlr.org/api/maven-plugin/latest/index.html

  • (Getestet mit ANTLR 4.5.3, Eclipse Neon, ANTLR 4 IDE 0.3.5 und Java 1.8)

    Laden Sie den neuesten ANTLR herunter. Stellen Sie sicher, dass Sie das vollständige ANTLR-Java-Binärglas erhalten. Speichern Sie an einem geeigneten Ort, z. B. in dem Ordner, in dem andere Java-Bibliotheken gespeichert sind. Es spielt keine Rolle, wo.

    1.

    Installieren Sie die ANTLR-IDE in Eclipse.

    Klicken Sie im Eclipse-Menü auf "Hilfe" und wählen Sie "Eclipse Marketplace".•Geben Sie im Feld Suchen: antlr ein und klicken Sie auf Start.•Klicken Sie für ANTLR 4 IDE auf Installieren.•Klicken Sie im Fenster Confirm Selected Features auf Finish.•Wenn ein Sicherheitswarnungsfenster angezeigt wird, klicken Sie auf OK.•Starten Sie Eclipse neu.•

    2.

    Umgehen Sie den Fehler "Fehler beim Erstellen des Injektors ...".

    Beim Zugriff auf ANTLR 4-Voreinstellungen in Eclipse oder wenn die Umgebungsvariable HOME nicht festgelegt ist, tritt der folgende Fehler auf: Fehler beim Erstellen des Injektors für com.github.jknack.antlr-4ide.Antlr4 für com.github.jknack.antlr-4ide.Antlr4 .

    Stellen Sie sicher, dass die Umgebungsvariable HOME gesetzt ist. Ist dies nicht der Fall, stellen Sie es für Ihr System ein.

    Laden Sie Xtext 2.7.3 an den gleichen Ort wie antlr-nnn-complete.jar herunter.•Klicken Sie in Eclipse auf Hilfe und wählen Sie Neue Software installieren.•Klicken Sie auf Hinzufügen…, um zum Fenster Repository hinzufügen zu gelangen.•Geben Sie einen Namen ein, z. B. xtext 2.7.3, klicken Sie dann auf Archivieren…, navigieren Sie zur Xtext 2.7.3-Datei und wählen Sie sie aus. Klicken Sie anschließend auf OK.

    Klicken Sie im Installationsfenster auf die Schaltfläche Alle auswählen und anschließend zweimal auf Weiter>, und akzeptieren Sie die Lizenzvereinbarung. und klicken Sie auf Fertig stellen.

    Starten Sie Eclipse neu.•

    3.

    Teilen Sie Eclipse / Java mit, wo sich ANTLR befindet.

    Klicken Sie in Eclipse auf Fenster und wählen Sie Einstellungen.•Erweitern Sie im linken Bereich Java und Build-Pfad, und wählen Sie dann Classpath-Variablen aus.

    Klicken Sie im rechten Bereich auf Neu…, geben Sie einen Namen ein und klicken Sie auf Datei…, und navigieren Sie zu Ihrem Speicherort von antlr-nnn-complete.jar. Klicken Sie auf OK, um zum Fenster Classpath Variables zurückzukehren.

    Klicken Sie auf OK, um die Voreinstellungen zu beenden.•

    4.

    (Optional) Konfigurieren Sie das mit ANTLR IDE generierte Quellenverzeichnis.

    Klicken Sie im Eclipse-Hauptfenster auf Fenster und dann auf Einstellungen.•Erweitern Sie im linken Bereich ANTLR 4, und wählen Sie Werkzeug aus.•

    5.

    https://riptutorial.com/de/home 15

    http://www.antlr.org/download.htmlhttp://www.eclipse.org/modeling/download.php?file=/modeling/tmf/xtext/downloads/drops/2.7.3/R201411190455/tmf-xtext-Update-2.7.3.zip

  • Ändern Sie bei Bedarf das Verzeichnis, falls gewünscht. Zum Beispiel ist Java meine Zielsprache, daher verwende ich ./antlr-java.

    Klicken Sie auf OK, um das Fenster "Einstellungen" zu schließen.•

    Erstellen Sie ein ANTLR 4-Projekt.

    Gehen Sie im Eclipse-Hauptfenster zu Datei, Neu, Projekt.•Erweitern Sie im Fenster Neues Projekt Allgemein und wählen Sie ANTLR 4-Projekt aus.

    Klicken Sie auf Weiter, geben Sie einen Projektnamen ein und klicken Sie auf Fertig stellen.

    Das neue Standardprojekt enthält eine Hello.g4-Datei und erstellt automatisch das Standardprogramm "Hello World".

    Erweitern Sie im Paket-Explorer den neuen Projektordner, um die g4-Datei und einen Ordner namens target (oder den Namen, den Sie ihm in Schritt 5 gegeben haben) mit den Zielquelldateien anzuzeigen.

    6.

    ANTLR in Visual Studio 2015 installieren (mithilfe von Nuget)

    Öffnen Sie Visual Studio 2015, navigieren Sie zu Extras → Erweiterungen → Online und suchen Sie nach Antlr. Laden Sie die Erweiterung ANTLR Language Support (Erstellt von Sam Harwell) herunter und starten Sie Visual Studio neu.

    1.

    Erstellen Sie ein neues Konsolenanwendungsprojekt. Klicken Sie mit der rechten Maustaste auf Solution → Nuget Packages für Solution verwalten → Browse (Tab), suchen Sie nach Antlr4 und installieren Sie es.

    2.

    https://riptutorial.com/de/home 16

  • Fügen Sie Ihrem Projekt ein neues Element hinzu, indem Sie mit der rechten Maustaste darauf klicken. Und suchen Sie nach ANTLR4-Vorlagen.

    3.

    https://riptutorial.com/de/home 17

    https://i.stack.imgur.com/nVweD.png

  • Gehen Sie in Ihrer ANTLR-Datei (Endung .g4) auf Datei → Erweiterte Speicheroptionen und suchen Sie nach Unicode (UTF-8 ohne Signatur ) - Codepage 65001, und klicken Sie auf

    OK. Das ist es.

    4.

    https://riptutorial.com/de/home 18

    https://i.stack.imgur.com/fNaF9.pnghttps://i.stack.imgur.com/ed3Tc.png

  • Testen Sie, ob alles funktioniert

    Erstellen Sie ein kombiniertes ANTLR 4-Element und nennen Sie es Calculator.g4•Kopieren Sie den Quellcode des Rechners aus diesem Github-Projekt hier: Rechner von Tom Everett

    Ändern Sie den Grammatikrechner in den Grammatikrechner•Im Projektmappen-Explorer → Klicken Sie auf Alle Dateien anzeigen.•

    Speichern Sie das Projekt und starten Sie es•Im Projektmappen-Explorer im Ordner obj sollten Sie cs-Klassen sehen, die wie Visitor und Listener generiert wurden. Wenn dies der Fall ist, haben Sie Erfolg gehabt. Jetzt können Sie mit ANTLR in Visual Studio 2015 arbeiten.

    https://riptutorial.com/de/home 19

    https://github.com/antlr/grammars-v4/blob/master/calculator/calculator.g4https://github.com/antlr/grammars-v4/blob/master/calculator/calculator.g4https://i.stack.imgur.com/pvPV9.png

  • Einführung in ANTLR v4 online lesen: https://riptutorial.com/de/antlr/topic/2856/einfuhrung-in-antlr-v4

    https://riptutorial.com/de/home 20

    https://i.stack.imgur.com/BhkWn.pnghttps://riptutorial.com/de/antlr/topic/2856/einfuhrung-in-antlr-v4https://riptutorial.com/de/antlr/topic/2856/einfuhrung-in-antlr-v4

  • Kapitel 6: Lexer regelt in v4

    Examples

    Einfache Regeln

    Lexer-Regeln definieren Token-Typen. Ihr Name muss mit einem Großbuchstaben beginnen, um sie von den Parserregeln zu unterscheiden.

    INTEGER: [0-9]+; IDENTIFIER: [a-zA-Z_] [a-zA-Z_0-9]*; OPEN_PAREN: '('; CLOSE_PAREN: ')';

    Grundlegende Syntax:

    Syntax Bedeutung

    A Passen Sie die Lexer-Regel oder das Fragment mit dem Namen A

    AB Spiel A gefolgt von B

    (A|B) Passen Sie entweder A oder B

    'text' Wörtliches "Text" abgleichen

    A? Match A null oder einmal

    A* Spiel A null oder mehrmals

    A+ Spiel A ein- oder mehrmals

    [A-Z0-9]Stimmen Sie ein Zeichen in den definierten Bereichen ab (in diesem Beispiel zwischen AZ oder 0-9).

    'a'..'z' Alternative Syntax für einen Zeichenbereich

    ~[AZ]Negation eines Bereichs - Entspricht einem beliebigen Zeichen, das nicht im Bereich liegt

    . Stimmen Sie jedes einzelne Zeichen ab

    Fragmente

    Fragmente sind wiederverwendbare Teile von Lexer-Regeln, die nicht für sich alleine passen können. Sie müssen aus einer Lexer-Regel referenziert werden.

    https://riptutorial.com/de/home 21

  • INTEGER: DIGIT+ | '0' [Xx] HEX_DIGIT+ ; fragment DIGIT: [0-9]; fragment HEX_DIGIT: [0-9A-Fa-f];

    Implizite Lexer-Regeln

    Wenn Token wie '{' in einer Parser- Regel verwendet werden, wird eine implizite Lexer-Regel erstellt, sofern keine explizite Regel vorhanden ist.

    Mit anderen Worten, wenn Sie eine Lexer-Regel haben:

    OPEN_BRACE: '{';

    Dann sind diese beiden Parserregeln gleichwertig:

    parserRule: '{'; parserRule: OPEN_BRACE;

    Wenn die Lexer-Regel OPEN_BRACE nicht definiert ist, wird eine implizite anonyme Regel erstellt. In diesem Fall wird die implizite Regel so definiert, als wäre sie vor den anderen Regeln definiert worden : Sie hat eine höhere Priorität als andere Regeln.

    Prioritätsregeln

    Mehrere Lexer-Regeln können mit demselben Eingabetext übereinstimmen. In diesem Fall wird der Token-Typ wie folgt ausgewählt:

    Wählen Sie zuerst die Lexer-Regel aus, die der längsten Eingabe entspricht•Wenn der Text mit einem implizit definierten Token übereinstimmt (wie '{' ), verwenden Sie die implizite Regel

    Wenn mehrere Lexer-Regeln der gleichen Eingabelänge entsprechen, wählen Sie die erste Regel basierend auf der Definitionsreihenfolge aus

    Die folgende kombinierte Grammatik:

    grammar LexerPriorityRulesExample; // Parser rules randomParserRule: 'foo'; // Implicitly declared token type // Lexer rules BAR: 'bar'; IDENTIFIER: [A-Za-z]+; BAZ: 'baz';

    https://riptutorial.com/de/home 22

  • WS: [ \t\r\n]+ -> skip;

    Gegeben die folgende Eingabe:

    aaa foo bar baz barz

    Erzeugt die folgende Token-Sequenz aus dem Lexer:

    IDENTIFIER 'foo' BAR IDENTIFIER IDENTIFIER

    aaa ist vom Typ IDENTIFIER

    Nur die IDENTIFIER Regel kann diesem Token entsprechen, es gibt keine Mehrdeutigkeit.

    foo ist vom Typ 'foo'

    Der Parser Regel randomParserRule führt den impliziten 'foo' Token - Typen, die über die prioritäre ist IDENTIFIER Regel.

    bar ist vom Typ BAR

    Dieser Text stimmt mit der BAR Regel überein, die vor der IDENTIFIER Regel definiert wurde, und hat daher Vorrang.

    baz ist vom Typ IDENTIFIER

    Dieser Text entspricht der BAZ Regel, aber auch der IDENTIFIER Regel. Letzteres wird so gewählt, wie es vor BAR definiert wurde.

    Angesichts der Grammatik wird BAZ niemals in der Lage sein, Übereinstimmungen zu finden, da die IDENTIFIER Regel bereits alles abdeckt, was BAZ kann.

    barz ist vom Typ IDENTIFIER

    Die BAR Regel kann mit den ersten 3 Zeichen dieser Zeichenfolge ( bar ) übereinstimmen, aber die IDENTIFIER Regel entspricht 4 Zeichen. Da IDENTIFIER mit einem längeren Teilstring übereinstimmt, wird dieser über BAR .

    Als Faustregel sollten bestimmte Regeln vor allgemeineren Regeln definiert werden. Wenn eine Regel nur mit einer Eingabe übereinstimmen kann, die bereits von einer zuvor definierten Regel abgedeckt ist, wird sie niemals verwendet.

    Implizit definierte Regeln wie 'foo' als wären sie vor allen anderen lexer-Regeln definiert worden .

    Lexer-Befehle

    Eine Lexer-Regel kann Befehle enthalten :

    WHITESPACE: [ \r\n] -> skip;

    https://riptutorial.com/de/home 23

  • Befehle werden nach einem -> am Ende der Regel definiert.

    skip : skip den übereinstimmenden Text, es wird kein Token ausgegeben•channel(n) : Der Token wird auf einem anderen Kanal ausgegeben•type(n) : Ändert den Typ des ausgegebenen Tokens•mode(n) , pushMode(n) , popMode , more : popMode Lexer-Modi•

    Aktionen und semantische Prädikate

    Eine Lexer-Aktion ist ein Block mit beliebigem Code in der Zielsprache, umgeben von { ... } , der während des Abgleichs ausgeführt wird:

    IDENTIFIER: [A-Z]+ { log("matched rule"); };

    Ein semantisches Prädikat ist ein Block beliebigen Codes in der Zielsprache, umgeben von { ... }? , der einen booleschen Wert ergibt. Wenn der zurückgegebene Wert false ist, wird die Lexer-Regel übersprungen.

    IDENTIFIER: [A-Z]+ { identifierIsValid() }?;

    Semantische Prädikate sollten aus Leistungsgründen möglichst am Ende der Regel definiert werden.

    Lexer regelt in v4 online lesen: https://riptutorial.com/de/antlr/topic/3271/lexer-regelt-in-v4

    https://riptutorial.com/de/home 24

    https://riptutorial.com/de/antlr/topic/3271/lexer-regelt-in-v4

  • Kapitel 7: TestRig / grun

    Examples

    Setup TestRig

    ANTLR enthält ein Testtool in seiner Laufzeitbibliothek. Dieses Tool kann verwendet werden, um Informationen anzuzeigen, wie die Analyse ausgeführt wird, um die Eingabe mit definierten Regeln in Ihrer Grammatikdatei abzugleichen.

    Um dieses Tool in der ANTLR-JAR-Datei verwenden zu können, müssen Sie Ihren Systemklassenpfad einrichten, um den Zugriff auf das ANTLR-Tool und die Laufzeitbibliothek zu ermöglichen:

    export CLASSPATH=".:/usr/local/lib/antlr-4.5.3-complete.jar:$CLASSPATH"

    Hinweis: Stellen Sie sicher, dass der Punkt vor jedem Pfad steht, um sicherzustellen, dass die virtuelle Java-Maschine keine Klassen in Ihrem aktuellen Arbeitsverzeichnis anzeigt.

    Alises kann unter Linux / MAC / Unix verwendet werden, um die verwendeten Befehle zu vereinfachen:

    alias antlr4='java -jar /usr/local/lib/antlr-4.5.3-complete.jar' //or any directory where your jar is located

    Hinweis Setup auf Fenster für Aliase und Classpath - Setup kann komplizierter sein, siehe hier für mehr alle Informationen.

    Zugriff auf TestRig

    Nachdem Sie Ihren Alias eingerichtet haben, können Sie TestRig auf folgende Weise einrichten. Es wird erneut empfohlen, einen Alias zu verwenden, um die zur Durchführung der Aktion erforderliche Zeit zu reduzieren:

    alias grun='java org.antlr.v4.runtime.misc.TestRig'

    Wenn Sie unter Windows keinen Alias einrichten möchten, können Sie auf TestRig zugreifen, indem Sie den folgenden Befehl an demselben Ort ausführen wie Ihr ANTLR-JAR-Verzeichnis:

    java -cp .;antlr.4.5.3-complete.jar org.antlr.v4.runtime.misc.TestRig //or java -cp .;antlr.4.5.3-complete.jar org.antlr.v4.gui.TestRig

    Um TestRig für Ihre Grammatik auszuführen, können Sie die Parameter wie folgt für Ihre

    https://riptutorial.com/de/home 25

    https://levlaz.org/setting-up-antlr4-on-windows/

  • Grammatik übergeben:

    grun yourGrammar yourRule -tree //using the setup alias java -cp .;antlr.4.5.3-complete.jar org.antlr.v4.gui.TestRig yourGrammar YourRule -tree //on windows with no alias java -cp .;antlr.4.5.3-complete.jar org.antlr.v4.gui.TestRig yourGrammar Hello r -tree //Windows with the grammar Hello.g4 starting from the rule 'r'.

    Grammatik mit Visual Parse Tree erstellen

    Wenn Sie die -gui -gui -gui , wenn Sie eine ANTLR-Grammatik im Testgerät ausführen, wird ein Fenster mit einer visuellen Darstellung des Analysebaums -gui . Zum Beispiel:

    Angesichts der folgenden Grammatik:

    JSON.g4

    /** Taken from "The Definitive ANTLR 4 Reference" by Terence Parr */ // Derived from http://json.org grammar JSON; json : value ; object : '{' pair (',' pair)* '}' | '{' '}' ; pair : STRING ':' value ; array : '[' value (',' value)* ']' | '[' ']' ; value : STRING | NUMBER | object | array | 'true' | 'false' | 'null' ; STRING : '"' (ESC | ~ ["\\])* '"' ; fragment ESC : '\\' (["\\/bfnrt] | UNICODE) ;

    https://riptutorial.com/de/home 26

  • fragment UNICODE : 'u' HEX HEX HEX HEX ; fragment HEX : [0-9a-fA-F] ; NUMBER : '-'? INT '.' [0-9] + EXP? | '-'? INT EXP | '-'? INT ; fragment INT : '0' | [1-9] [0-9]* ; // no leading zeros fragment EXP : [Ee] [+\-]? INT ; // \- since - means "range" inside [...] WS : [ \t\n\r] + -> skip ;

    Angesichts der folgenden JSON-Datei:

    beispiel.json

    { "name": "John Doe", "age": 25, "address": { "streetAddress": "21 2nd Street", "city": "New York", "state": "NY", "postalCode": "10021-3100" }, "phoneNumbers": [ { "type": "home", "number": "212 555-1234" }, { "type": "mobile", "number": "123 456-7890" } ], "children": [], "spouse": null }

    Die folgende Syntax-Befehlszeilensyntax:

    export CLASSPATH=".:/usr/local/lib/antlr-4.0-complete.jar:$CLASSPATH" alias antlr4='java -jar /usr/local/lib/antlr-4.0-complete.jar' alias grun='java org.antlr.v4.runtime.misc.TestRig' antlr4 -o . -lib . -no-listener -no-visitor JSON.g4; javac *.java; grun JSON json -gui example.json

    https://riptutorial.com/de/home 27

  • führt zu den generierten .java- und .tokens- Dateien sowie den kompilierten .class- Dateien:

    JSON.g4 JSONLexer.class JSONListener.java JSONParser$PairContext.class JSON.tokens JSONLexer.java JSONParser$ArrayContext.class JSONParser$ValueContext.class JSONBaseListener.class JSONLexer.tokens JSONParser$JsonContext.class JSONParser.class JSONBaseListener.java JSONListener.class JSONParser$ObjectContext.class JSONParser.java

    und der folgende Parsebaum:

    TestRig / grun online lesen: https://riptutorial.com/de/antlr/topic/3270/testrig---grun

    https://riptutorial.com/de/home 28

    http://i.stack.imgur.com/oNjUt.pnghttps://riptutorial.com/de/antlr/topic/3270/testrig---grun

  • Kapitel 8: Zuhörer

    Examples

    Listener-Events mit Labels

    Das Kennzeichnen der Alternativen in einer Regel beginnt mit dem Operator # , und ANTLR weist Listener-Methoden für jedes der Alternative entsprechende Etikett an.

    Durch Angabe eines Labels für jede Alternative in der folgenden Regel:

    // Rule type : int #typeInt | short #typeShort | long #typeLong | string #typeString ; // Tokens int : 'int' ; short : 'short' ; long : 'long' ; string : 'string' ;

    Generiert die folgenden Methoden in der generierten Schnittstelle, die ParseTreeListener :

    public void enterTypeInt(TypeShortContext ctx); public void enterTypeShort(TypeIntContext ctx); public void enterTypeLong(TypeLongContext ctx); public void enterTypeString(TypeStringContext ctx);

    Zuhörer online lesen: https://riptutorial.com/de/antlr/topic/6717/zuhorer

    https://riptutorial.com/de/home 29

    http://www.antlr.org/api/Java/org/antlr/v4/runtime/tree/ParseTreeListener.htmlhttps://riptutorial.com/de/antlr/topic/6717/zuhorer

  • Credits

    S. No

    Kapitel Contributors

    1Erste Schritte mit ANTLR

    Athafoud, cb4, Community, D3181, Gábor Bakos, KvanTTT

    2ANTLR-Ziele / Sprachlaufzeiten

    D3181

    3 Besucher D3181

    4Einführung in ANTLR v3

    Athafoud, cb4

    5Einführung in ANTLR v4

    Athafoud, cb4, Community, D3181, Devid, Gábor Bakos, GRosenberg, Lucas Trzesniewski

    6 Lexer regelt in v4 Athafoud, bn., Loxley, Lucas Trzesniewski

    7 TestRig / grun bn., D3181, Lucas Trzesniewski, Pascal Le Merrer

    8 Zuhörer bn., Lucas Trzesniewski

    https://riptutorial.com/de/home 30

    https://riptutorial.com/de/contributor/2279200/athafoudhttps://riptutorial.com/de/contributor/1318479/cb4https://riptutorial.com/de/contributor/-1/communityhttps://riptutorial.com/de/contributor/6510101/d3181https://riptutorial.com/de/contributor/1502148/gabor-bakoshttps://riptutorial.com/de/contributor/1046374/kvanttthttps://riptutorial.com/de/contributor/6510101/d3181https://riptutorial.com/de/contributor/6510101/d3181https://riptutorial.com/de/contributor/2279200/athafoudhttps://riptutorial.com/de/contributor/1318479/cb4https://riptutorial.com/de/contributor/2279200/athafoudhttps://riptutorial.com/de/contributor/1318479/cb4https://riptutorial.com/de/contributor/-1/communityhttps://riptutorial.com/de/contributor/6510101/d3181https://riptutorial.com/de/contributor/1262566/devidhttps://riptutorial.com/de/contributor/1502148/gabor-bakoshttps://riptutorial.com/de/contributor/1886753/grosenberghttps://riptutorial.com/de/contributor/3764814/lucas-trzesniewskihttps://riptutorial.com/de/contributor/2279200/athafoudhttps://riptutorial.com/de/contributor/89339/bn-https://riptutorial.com/de/contributor/366385/loxleyhttps://riptutorial.com/de/contributor/3764814/lucas-trzesniewskihttps://riptutorial.com/de/contributor/89339/bn-https://riptutorial.com/de/contributor/6510101/d3181https://riptutorial.com/de/contributor/3764814/lucas-trzesniewskihttps://riptutorial.com/de/contributor/1392658/pascal-le-merrerhttps://riptutorial.com/de/contributor/89339/bn-https://riptutorial.com/de/contributor/3764814/lucas-trzesniewski

    ÜberKapitel 1: Erste Schritte mit ANTLRBemerkungenVersionenExamplesHallo Welt

    Kapitel 2: ANTLR-Ziele / SprachlaufzeitenExamplesSprachunterstützungPython-Parser-Setup

    Kapitel 3: BesucherEinführungExamplesBeispiel

    Kapitel 4: Einführung in ANTLR v3ExamplesInstallation und Einrichtung

    So installieren Sie ANTLR in Eclipse

    Kapitel 5: Einführung in ANTLR v4BemerkungenExamplesInstallation für die Befehlszeile verwendenInstallation mithilfe von Build Automation-ToolsInstallieren Sie in Eclipse und Build Hello WorldANTLR in Visual Studio 2015 installieren (mithilfe von Nuget)

    Testen Sie, ob alles funktioniert

    Kapitel 6: Lexer regelt in v4ExamplesEinfache RegelnFragmenteImplizite Lexer-RegelnPrioritätsregelnLexer-BefehleAktionen und semantische Prädikate

    Kapitel 7: TestRig / grunExamplesSetup TestRig

    Zugriff auf TestRigGrammatik mit Visual Parse Tree erstellen

    Kapitel 8: ZuhörerExamplesListener-Events mit Labels

    Credits