Qualcuno sa di un modo per eseguire il debug di grammatiche in ANTLRWorks

Question

Il modello consigliato per l'utilizzo di ANTLR consiste nel fare in modo che il parser costruisca un albero sintassi astratto e quindi costruisca tree walker (grammatiche ad albero AKA) per elaborarle.

Sto cercando di capire perché la mia grammatica dell'albero non funziona e mi piacerebbe usare il debugger di ANTLRWorks nello stesso modo in cui l'ho usato per il parser stesso. L'input per il parser è il "codice sorgente", ma l'input per un parser dell'albero è il risultato AST del parser. Non vedo come renderlo disponibile come input per testare la grammatica dell'albero.

Non è chiaro che esista un modo per testare una grammatica dell'albero in ANTLRWorks. Se può essere fatto, un puntatore nella giusta direzione sarebbe davvero apprezzato.

Answer 1

Il debugger ANTLRWorks dovrebbe funzionare correttamente con la grammatica dell'albero. Se ricordo correttamente, è necessario utilizzare lo strumento di generazione del codice ANTLR con il flag "-debug" (sto usando la destinazione Java), quindi, dove si crea l'istanza del parser dell'albero, utilizzare il costruttore di debug che accetta una porta come un argomento. Nel mio caso, la porta predefinita non funzionava, quindi ho scelto arbitrariamente 35505.

Avvia ANTLRWorks, apri la grammatica dell'albero, fai clic su "Esegui" -> "Debug remoto ...", imposta la porta sul lo stesso valore utilizzato nel costruttore per il parser dell'albero e dovresti essere in grado di connettere il debugger alla tua applicazione in esecuzione. Vedi lo ANTLR 3 Debugging FAQ per i dettagli.

[Aggiornamento] Supponendo che si sta utilizzando il bersaglio Java (di farci sapere se non è questo il caso), ecco le informazioni più dettagliate su come iniziare:

Quando si sta testando la vostra non-albero parser in ANTLRWorks, c'è un processo dietro le quinte che genera codice Java dal tuo file di grammatica, quindi usa quel codice per analizzare il tuo input. Quando si utilizza il parser nella propria applicazione, è necessario utilizzare ANTLR (in particolare, la classe org.antlr.Tool) per generare il codice Java che è possibile includere nella propria applicazione. ANTLRWorks ha un'opzione di menu per questo, che dovrebbe iniziare. Nel mio caso, ho un obiettivo nel mio file di build ant che genera il codice Java dalle mie grammatiche e inserisce quei file di origine Java in un posto dove il resto della mia applicazione può trovarli. Il mio obiettivo formica simile a questa:

<java classpath="${antlr.tool.classpath}" classname="org.antlr.Tool" failonerror="true"> 
    <arg value="-o" /> 
    <arg value="${antlr.out.dir}" /> 
    <arg value="${grammar.dir}/GrammarName.g" /> 
</java> 

La proprietà antlr.tool.classpath deve contenere stringtemplate.jar e antlr.jar, e antlr.out.dir esigenze per puntare alla directory in cui si desidera che il codice sorgente generato per andare (ad esempio, build/antlr/src/org/myorg/antlr/parser, se il parser grammatiche specificano il pacchetto org.myorg.antlr.parser).

Poi, quando si compila il resto della vostra applicazione, è possibile usare qualcosa come:

<javac destdir="${build.classes.dir}" debug="on" optimize="on" deprecation="${javac.deprecation}" source="${javac.source}" target="${javac.target}"> 
    <classpath refid="stdclasspath"/> 
    <src path="${src.dir}" /> 
    <src path="${antlr.src.dir}" /> 
</javac> 

Qui, compiliamo le nostre fonti di applicazione (in src.dir) insieme al codice ANTLR generato (in antlr.src.dir, che in questo esempio sarebbe build/antlr/src).

Per quanto riguarda l'utilizzo del codice generato nella richiesta (ad es., ANTLRWorks fuori), avrete bisogno di fare qualcosa di simile:

String sourceText = "a + b = foo"; 
ANTLRStringStream inStream = new ANTLRStringStream(sourceText); 

// your generated lexer class 
MyLexer lexer = new MyLexer(inStream); 
CommonTokenStream tokens = new CommonTokenStream(lexer); 

// your generated parser class 
MyParser parser = new MyParser(tokens); 

// run the toplevel rule (in this case, `program`) 
MyParser.program_return prog = parser.program(); 

// get the resulting AST (a CommonTree instance, in this case) 
CommonTree tree = (CommonTree) prog.getTree(); 

// run a tree parser rule on the AST 
MyTreeParser treeParser = new MyTreeParser(new CommonTreeNodeStream(tree)); 
treeParser.program(); 

vi raccomando vivamente di ottenere una copia di The Definitive ANTLR Reference se avete intenzione di utilizzare ANTLR. Tutto questo è trattato abbastanza bene, con un sacco di esempi per iniziare.

Answer 2

Se sei sicuro che l'AST che stai creando funzioni correttamente (con il debugger ANTLRWORKS), il test di tree-walking non è diverso dal test di qualsiasi altra app. Se stai emettendo il codice Java, ad esempio, usa il debugger di Eclipse per testarlo o i messaggi di registro semplici ...

Answer 3

C'è un modo per utilizzare AntlrWorks:

1. Scrivi la grammatica in AntlrWorks
2. generare il codice (questa è la stessa cosa che lanciare Antlr dalla linea di comando w/o debug)
3. Scrivi te uno stub simile a quello che è stato suggerito sul Debugging with AntlrWorks faq
4. Scrivi la tua grammatica albero
5. Select Antlrworks di debug (questa è la stessa cosa che lanciare Antlr dalla linea di comando con la de bug flag.
6. Eseguire il programma stub. Il programma bloccherà fino a quando antlrworks è collegato, in modo da poter eseguire il debug la grammatica albero
7. Torna alla antlrworks che ha la grammatica albero aperto, e di debug remoto
8. risolvere i problemi .... :)