ANTLR
ANTLR Targets / Taal Looptijden

Taalondersteuning

ANTLR kan parsers genereren voor een aantal programmeertalen:

1. C # Target
2. Python Target
3. JavaScript-doel
4. Java-doel

ANTLR genereert standaard een parser vanaf de opdrachtregel in de programmeertaal Java:

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

Om de doeltaal te wijzigen, kunt u de volgende opdracht uitvoeren vanaf de OS-terminal / opdrachtregel:

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

In plaats van de parameter '-Dlanguage' op de opdrachtregel / terminal elke keer te gebruiken om de gewenste parser voor een specifieke taal te maken, kunt u het doel selecteren in uw .g4-grammaticabestand door het doel op te nemen in de algemene sectie:

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

Als u de gegenereerde parser-uitvoer wilt gebruiken, moet u ervoor zorgen dat u de ANTLR-runtime voor de opgegeven taal hebt:

1. CSharp looptijd
2. Python 2 looptijd
3. python 3 looptijd

Volledige instructies en informatie over ANTLR run-times bibliotheken

Python parser instellen

Na het uitvoeren van uw grammatica .g4-bestand met ANTLR.jar, zou u een aantal bestanden moeten hebben gegenereerd, zoals:

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

Om deze in een python-project te gebruiken, neemt u de Python-runtime op in uw werkruimte, zodat elke toepassing die u ontwikkelt toegang heeft tot de ANTLR-bibliotheek. Dit kan worden gedaan door de runtime in uw huidige projectmap te extraheren of deze in uw IDE te importeren in uw projectafhankelijkheden.

#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) 

Deze installatie omvat uw parser en accepteert invoer vanaf de opdrachtregel om verwerking van een doorgegeven parameter mogelijk te maken.

#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)
        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')

Deze bestanden gekoppeld aan de ANTLR-runtime en uw bestanden gegenereerd uit uw grammaticabestand accepteren een enkele bestandsnaam als argument en lezen en ontleden uw grammaticaregels.

Om de basisfunctionaliteit uit te breiden, moet u ook de standaardlistener uitbreiden om relevante gebeurtenissen af te handelen voor tokens die tijdens runtime worden aangetroffen.