ANTLR
ANTLR-mål / språkkurser

Språkstöd

ANTLR kan generera parsers för ett antal programmeringsspråk:

1. C # Mål
2. Python Target
3. JavaScript-mål
4. Java-mål

Som standard genererar ANTLR en parser från kommandoraden på programmeringsspråket Java:

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

För att ändra målspråket kan du köra följande kommando från OS-terminalen / kommandoraden:

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

I stället för att använda parametern '-Språk' på kommandoraden / terminalen varje gång för att bygga önskad parser för ett specifikt språk kan du välja målet från din .g4-grammatikfil genom att inkludera målet i det globala avsnittet:

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

För att använda den genererade parserutgången, se till att du har ANTLR-körtiden för det angivna språket:

1. CSharp runtime
2. Python 2 körtid
3. python 3 körtid

Fullständiga instruktioner och information om ANTLR-körtidsbibliotek

Inställning av Python-parser

När du har kört din grammatik .g4-fil med ANTLR.jar bör du ha ett antal filer som genereras, som:

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

Om du vill använda dessa i ett Python-projekt inkluderar du Python-runtime i ditt arbetsområde så att alla program du utvecklar kan komma åt ANTLR-biblioteket. Detta kan göras genom att extrahera runtime till din aktuella projektmapp eller importera den inom din IDE till ditt projektberoende.

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

Denna inställning inkluderar din parser och accepterar inmatning från kommandoraden för att tillåta bearbetning av en fil som skickas som en parameter.

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

Dessa filer i kombination med ANTLR-körtiden och dina filer som genereras från din grammatikfil accepterar ett enda filnamn som ett argument och läser och analyserar dina grammatikregler.

För att utöka den grundläggande funktionaliteten bör du också utöka standardlistaren för att hantera relevanta händelser för tokens som stöter på under körning.