我正在嘗試使用antlr編寫一個簡單的交互式（使用System.in作爲源語言）語言，並且我遇到了一些問題。我在網上找到的示例都使用每行週期，例如：交互式Antlr
while(readline)
result = parse(line)
doStuff(result)
但如果我寫的東西像帕斯卡爾/ SMTP /等，着有「行頭」是什麼樣子X需求量的？我知道它可以在doStuff中檢查，但我認爲它是語法的一部分。
或者如果一個命令被分成多行？我可以嘗試
while(readline)
lines.add(line)
try
result = parse(lines)
lines = []
doStuff(result)
catch
nop
但是，我也隱藏了真正的錯誤。
或者，我可以每次重新分析所有行，但：
可以這樣用ANTLR完成或者如果沒有，還有別的東西？
Dutow寫道：
或者，我可以每次重新分析所有行，但：
這將是緩慢的 有說明，我不想跑兩次 可以這樣用ANTLR完成，或者如果沒有，用別的東西？
是的，ANTLR可以做到這一點。也許不是開箱即用，但有了一些自定義代碼，它肯定是可能的。您也不需要爲它重新解析整個令牌流。
假設您想要逐行解析非常簡單的語言，其中每行是program聲明或uses聲明或statement。
應該總是以一個program聲明，其次是零點或多個uses聲明後跟零個或多個statement先從。 uses聲明不能在statement之後出現，並且不能有多於一個的program聲明。
爲簡單起見，statement只是一個簡單的賦值：a = 4或b = a。
的ANTLR語法這種語言看起來是這樣的：
grammar REPL;
parse
: programDeclaration EOF
| usesDeclaration EOF
| statement EOF
;
programDeclaration
: PROGRAM ID
;
usesDeclaration
: USES idList
;
statement
: ID '=' (INT | ID)
;
idList
: ID (',' ID)*
;
PROGRAM : 'program';
USES : 'uses';
ID : ('a'..'z' | 'A'..'Z' | '_') ('a'..'z' | 'A'..'Z' | '_' | '0'..'9')*;
INT : '0'..'9'+;
SPACE : (' ' | '\t' | '\r' | '\n') {skip();};
但是，我們需要添加一對，當然檢查。此外，默認情況下，解析器在其構造函數中使用標記流，但由於我們計劃在解析器中逐行添加標記，因此我們需要在解析器中創建一個新的構造函數。您可以分別在@parser::members { ... }或@lexer::members { ... }部分中將自定義成員添加到詞法分析器或解析器類中。我們還將添加一對布爾標誌來跟蹤是否已經發生了program聲明，並且允許uses聲明。最後，我們將添加一個process(String source)方法，該方法爲每個新行創建一個詞法分析器，並將其提供給解析器。
所有這一切都將是這樣的：
@parser::members {
boolean programDeclDone;
boolean usesDeclAllowed;
public REPLParser() {
super(null);
programDeclDone = false;
usesDeclAllowed = true;
}
public void process(String source) throws Exception {
ANTLRStringStream in = new ANTLRStringStream(source);
REPLLexer lexer = new REPLLexer(in);
CommonTokenStream tokens = new CommonTokenStream(lexer);
super.setTokenStream(tokens);
this.parse(); // the entry point of our parser
}
}
現在我們的語法裏面，我們將通過幾個gated semantic predicates檢查，如果我們按照正確的順序解析聲明。在解析某個聲明或聲明之後，我們需要翻轉某些布爾標誌來允許或者不允許從此聲明。這些布爾標誌的翻轉是通過每條規則的@after { ... }部分來完成的（並不奇怪）在之後來自該解析器規則的令牌被匹配。
您最終的語法文件現在看起來是這樣（包括一些System.out.println的用於調試）：
grammar REPL;
@parser::members {
boolean programDeclDone;
boolean usesDeclAllowed;
public REPLParser() {
super(null);
programDeclDone = false;
usesDeclAllowed = true;
}
public void process(String source) throws Exception {
ANTLRStringStream in = new ANTLRStringStream(source);
REPLLexer lexer = new REPLLexer(in);
CommonTokenStream tokens = new CommonTokenStream(lexer);
super.setTokenStream(tokens);
this.parse();
}
}
parse
: programDeclaration EOF
| {programDeclDone}? (usesDeclaration | statement) EOF
;
programDeclaration
@after{
programDeclDone = true;
}
: {!programDeclDone}? PROGRAM ID {System.out.println("\t\t\t program <- " + $ID.text);}
;
usesDeclaration
: {usesDeclAllowed}? USES idList {System.out.println("\t\t\t uses <- " + $idList.text);}
;
statement
@after{
usesDeclAllowed = false;
}
: left=ID '=' right=(INT | ID) {System.out.println("\t\t\t " + $left.text + " <- " + $right.text);}
;
idList
: ID (',' ID)*
;
PROGRAM : 'program';
USES : 'uses';
ID : ('a'..'z' | 'A'..'Z' | '_') ('a'..'z' | 'A'..'Z' | '_' | '0'..'9')*;
INT : '0'..'9'+;
SPACE : (' ' | '\t' | '\r' | '\n') {skip();};
可以測試機智以下類：
import org.antlr.runtime.*;
import java.util.Scanner;
public class Main {
public static void main(String[] args) throws Exception {
Scanner keyboard = new Scanner(System.in);
REPLParser parser = new REPLParser();
while(true) {
System.out.print("\n> ");
String input = keyboard.nextLine();
if(input.equals("quit")) {
break;
}
parser.process(input);
}
System.out.println("\nBye!");
}
}
要運行該測試類別，請執行以下操作：
# generate a lexer and parser:
java -cp antlr-3.2.jar org.antlr.Tool REPL.g
# compile all .java source files:
javac -cp antlr-3.2.jar *.java
# run the main class on Windows:
java -cp .;antlr-3.2.jar Main
# or on Linux/Mac:
java -cp .:antlr-3.2.jar Main
正如你所看到的，你只能申報一個program一次：
> program A
program <- A
> program B
line 1:0 rule programDeclaration failed predicate: {!programDeclDone}?
uses不能來statement S：
> program X
program <- X
> uses a,b,c
uses <- a,b,c
> a = 666
a <- 666
> uses d,e
line 1:0 rule usesDeclaration failed predicate: {usesDeclAllowed}?
，你必須用一個program申報開始：
> uses foo
line 1:0 rule parse failed predicate: {programDeclDone}?
如果您使用System.in作爲源（輸入流），爲什麼不只是在讀取輸入流時對它進行標記，然後解析標記呢？
你必須把它放在doStuff ....
舉例來說，如果你聲明一個函數，解析會返回一個函數吧？沒有身體，所以，這很好，因爲身體會晚點來。你會做大多數REPL所做的。
下面是如何解析來自System.in的輸入的示例，而不是先一次一行地手動解析它，並且不會在語法中造成重大損害。我正在使用ANTLR 3.4。 ANTLR 4可能已經解決了這個問題。不過，我仍然在使用ANTLR 3，也許還有其他人也有這個問題。
之前進入的解決方案，下面是我遇到的障礙不斷被輕鬆解決這個看似微不足道的問題：
CharStream得到消耗的整個流ANTLR類數據預先。顯然，交互模式（或任何其他不確定長度的流源）不能提供所有數據。BufferedTokenStream和派生類不會在跳過或離線的令牌上結束。在交互式設置中，這意味着當前語句不能結束（因此不能執行），直到下一個語句或EOF的第一個標記被使用時才使用這些類中的一個。考慮一個簡單的例子：
statement: 'verb' 'noun' ('and' 'noun')*
;
WS: //etc...
交互解析單個statement（和僅單個statement）是不可能的。必須開始下一個statement（即，在輸入中命中「動詞」），或者必須修改語法以標記語句的結尾，例如，與3210。
skip()替換$channel = HIDDEN，但它仍然是一個值得一提的限制。例如，我的語法的正常切入點是這個規則：
script
: statement* EOF -> ^(STMTS statement*)
;
我的交互式會話不能在script規則開始，因爲它不會結束，直到EOF。但是它不能從statement開始，因爲STMTS可能被我的樹解析器使用。
所以我專門推出了以下規則的交互式會話：
interactive
: statement -> ^(STMTS statement)
;
對我來說，有沒有「第一線」的規則，所以我不能說這將是多麼容易或難爲他們做類似的事情。這可能是做像這樣的規則的問題，並在交互式會話的開始執行：
interactive_start
: first_line
;
提到的第一個問題，內置的CharStream類，是我唯一的主要掛斷的侷限性。 ANTLRStringStream具有我需要的所有工作方式，所以我從我自己的CharStream課程中派生出來。假設基類的data成員讀取了所有過去的字符，因此我需要覆蓋所有訪問它的方法。然後我將直接讀取改爲呼叫（新方法）dataAt以管理從流中讀取。這基本上就是這樣。請注意，這裏的代碼可能沒有被注意到的問題，並沒有真正的錯誤處理。
public class MyInputStream extends ANTLRStringStream {
private InputStream in;
public MyInputStream(InputStream in) {
super(new char[0], 0);
this.in = in;
}
@Override
// copied almost verbatim from ANTLRStringStream
public void consume() {
if (p < n) {
charPositionInLine++;
if (dataAt(p) == '\n') {
line++;
charPositionInLine = 0;
}
p++;
}
}
@Override
// copied almost verbatim from ANTLRStringStream
public int LA(int i) {
if (i == 0) {
return 0; // undefined
}
if (i < 0) {
i++; // e.g., translate LA(-1) to use offset i=0; then data[p+0-1]
if ((p + i - 1) < 0) {
return CharStream.EOF; // invalid; no char before first char
}
}
// Read ahead
return dataAt(p + i - 1);
}
@Override
public String substring(int start, int stop) {
if (stop >= n) {
//Read ahead.
dataAt(stop);
}
return new String(data, start, stop - start + 1);
}
private int dataAt(int i) {
ensureRead(i);
if (i < n) {
return data[i];
} else {
// Nothing to read at that point.
return CharStream.EOF;
}
}
private void ensureRead(int i) {
if (i < n) {
// The data has been read.
return;
}
int distance = i - n + 1;
ensureCapacity(n + distance);
// Crude way to copy from the byte stream into the char array.
for (int pos = 0; pos < distance; ++pos) {
int read;
try {
read = in.read();
} catch (IOException e) {
// TODO handle this better.
throw new RuntimeException(e);
}
if (read < 0) {
break;
} else {
data[n++] = (char) read;
}
}
}
private void ensureCapacity(int capacity) {
if (capacity > n) {
char[] newData = new char[capacity];
System.arraycopy(data, 0, newData, 0, n);
data = newData;
}
}
}
啓動交互式會話類似於樣板解析代碼，不同的是使用了UnbufferedTokenStream和解析發生在一個循環：
MyLexer lex = new MyLexer(new MyInputStream(System.in));
TokenStream tokens = new UnbufferedTokenStream(lex);
//Handle "first line" parser rule(s) here.
while (true) {
MyParser parser = new MyParser(tokens);
//Set up the parser here.
MyParser.interactive_return r = parser.interactive();
//Do something with the return value.
//Break on some meaningful condition.
}
還是和我在一起？好的，就是這樣。 :)
做得很好。我一直在研究解析大文件的問題，並且需要一種將僞EOF標記插入到流中的方法，以便重新輸入解析器，以便解析輸入流的「塊」。這將限制解析樹的大小，我在ANTLR4中使用它來驅動解析樹監聽器。所以，'第一行和編碼模式我已經有了，而且我很難管理每個解析調用中輸入令牌空間ANTLR4會消耗多少。你所說的問題與我的密切配合。 – 2017-03-01 16:18:19
你能舉一個這樣的「看起來像X」輸入的具體例子嗎？ – 2011-02-24 22:03:13
我的意思是說，pascal程序的第一行必須是「程序X」，使用聲明（「使用x，y，z」）是可選的，但是如果指定必須在程序聲明之後。因此，在類似帕斯卡的外殼中，第一個有效表達式總是「程序x」; – Dutow 2011-02-24 22:26:43