ANTLR
Obiettivi ANTLR / Runtime linguistici

Supporto linguistico

ANTLR è in grado di generare parser per un numero di linguaggi di programmazione:

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

Di default ANTLR genererà un parser da linea di comando nel linguaggio di programmazione Java:

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

Per cambiare la lingua di destinazione è possibile eseguire il seguente comando dal terminale OS / riga di comando:

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

Anziché utilizzare il parametro "-Dlanguage" sulla riga di comando / terminale ogni volta per creare il parser desiderato per una lingua specifica, è possibile selezionare il target all'interno del file grammaticg .g4 includendo il target all'interno della sezione globale:

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

Per utilizzare l'output del parser generato assicurati di avere il runtime ANTLR per la lingua specificata:

1. Runtime CSharp
2. Python 2 runtime
3. python 3 runtime

Istruzioni e informazioni complete sulle librerie dei tempi di esecuzione di ANTLR

Impostazione del parser Python

Dopo aver eseguito il file .g4 di grammatica con ANTLR.jar dovresti avere un numero di file generati come:

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

Per utilizzarli in un progetto python includere il runtime Python nel proprio spazio di lavoro in modo che qualsiasi applicazione che si sta sviluppando possa accedere alla libreria ANTLR. Questo può essere fatto estraendo il runtime nella cartella del progetto corrente o importandolo all'interno dell'IDE nelle dipendenze del progetto.

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

Questa configurazione include il parser e accetta l'input dalla riga di comando per consentire l'elaborazione di un file passato come parametro.

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

Questi file accoppiati con il runtime ANTLR e i file generati dal tuo file di grammatica accetteranno un singolo nome file come argomento e leggeranno e analizzeranno le tue regole grammaticali.

Per estendere la funzionalità di base, è necessario espandere anche il listener predefinito per gestire gli eventi rilevanti per i token rilevati durante il runtime.