rule: ('example\r\n' | 'example2\r\n') nextRule
example
example2
example2
example
example
example
example2
在ANTLR中,我如何制定一个规则,以任何顺序只匹配它的所有替代项一次?
“它的所有备选方案只有一次”就是规则:altA altB altC...
。这是容易的部分。要求rule
接受任何排列中的所有选项alta
、altb
、altc
等,意味着适应每一种排列。对于较小的数字,这很容易手动处理(规则:(altA altB altB altA);
)。但是没有自动的快捷方式,我知道为你自动处理所有的排列。
这里有一些方法,以防没有内置的方法,并且假设您不能放松您的需求。警告:我不知道你问题的全部范围;我不知道你的语法;我不知道你为什么想要你所要求的;我不知道您更喜欢哪一类解决方案,除了您可能喜欢它比这些选项更容易之外。
field : modifiers ID EOF;
modifiers
: PUBLIC STATIC FINAL //ABC
| PUBLIC FINAL STATIC //ACB
| STATIC PUBLIC FINAL //BAC
| STATIC FINAL PUBLIC //BCA
| FINAL PUBLIC STATIC //CAB
| FINAL STATIC PUBLIC //CBA
;
field
locals [java.util.HashSet<String> names = new java.util.HashSet<String>();]
: modifiers ID EOF;
modifiers
//Ensure that the full number of modifiers have been provided
: {$field::names.size() < 3}? modifier modifiers
| {$field::names.size() == 3}? //match nothing once we have (any) three modifiers
;
modifier
//Ensure that no duplicates have been provided
: {!$field::names.contains("public")}? PUBLIC {$field::names.add("public");}
| {!$field::names.contains("static")}? STATIC {$field::names.add("static");}
| {!$field::names.contains("final")}? FINAL {$field::names.add("final");}
;
//partial grammar
field : modifier* ID EOF; //accept any modifiers in any order
modifier
: PUBLIC
| STATIC
| FINAL
;
//snippet of calling code
//initialize lexer and parser
parser.addParseListener(new MyGrammarBaseListener() {
@Override
public void exitField(FieldContext ctx) {
// The field rule has finished. Let's verify that no modifiers
// were duplicated.
//TODO check for duplicates, ensure all modifiers are specified.
//TODO log errors accordingly.
}
});
//Call the parser.
parser.field();
语法保持干净。修饰符可以任意出现在输入中id
之前,以任何数量和顺序出现。调用代码通过它选择的任何方法执行测试,记录它想要的任何错误。
下面是一个uberexample,它将我提到的三个选项结合在一起,以便更清楚地理解我所说的内容。
grammar Modifiers;
//Hard-coded version : all the permutations are specified //
permutationField : permutationModifiers ID EOF;
permutationModifiers
: PUBLIC STATIC FINAL //ABC
| PUBLIC FINAL STATIC //ACB
| STATIC PUBLIC FINAL //BAC
| STATIC FINAL PUBLIC //BCA
| FINAL PUBLIC STATIC //CAB
| FINAL STATIC PUBLIC //CBA
;
// Predicate version : use semantic predicates to prevent duplicates and ensure all the modifiers are provided //
predicateField
locals [java.util.HashSet<String> names = new java.util.HashSet<String>();]
: predicateModifiers ID EOF;
predicateModifiers
//Ensure that the full number of modifiers have been provided
: {$predicateField::names.size() < 3}? predicateModifier predicateModifiers
| {$predicateField::names.size() == 3}? //match nothing once we have (any) three modifiers
;
predicateModifier
//Ensure that no duplicates have been provided
: {!$predicateField::names.contains("public")}? PUBLIC {$predicateField::names.add("public");}
| {!$predicateField::names.contains("static")}? STATIC {$predicateField::names.add("static");}
| {!$predicateField::names.contains("final")}? FINAL {$predicateField::names.add("final");}
;
//Listener version : test everything when the parser calls the listener //
listenerField : listenerModifier* ID EOF;
listenerModifier
: PUBLIC
| STATIC
| FINAL
;
PUBLIC : 'public';
STATIC : 'static';
FINAL : 'final';
FOO : 'foo';
ID : [a-zA-Z]+;
WS : [ \r\n\t]+ -> skip;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import org.antlr.v4.runtime.ANTLRInputStream;
import org.antlr.v4.runtime.BaseErrorListener;
import org.antlr.v4.runtime.CommonTokenStream;
import org.antlr.v4.runtime.RecognitionException;
import org.antlr.v4.runtime.Recognizer;
import org.antlr.v4.runtime.misc.Nullable;
public class ModifiersTest {
public static void main(String[] args) {
run("public static final x", "ok");
run("final static public x", "ok");
run("static public static final x", "too many modifiers");
run("static x", "missing modifiers");
run("final final x", "missing & duplicated modifiers");
}
private static void run(String code, String title) {
System.out.printf("%n---%n**Input : %s**%n%n\t%s%n%n", title, code);
System.out.println("**Permutation Output**\n");
runPermutationTest(code);
System.out.println();
System.out.println("**Predicate Output**\n");
runPredicateTest(code);
System.out.println();
System.out.println("**Listener Output**\n");
runListenerTest(code);
System.out.println();
}
private static void runPermutationTest(String code) {
ModifiersParser parser = createParser(code);
parser.permutationField();
System.out.println("\t(done)");
}
private static void runPredicateTest(String code) {
ModifiersParser parser = createParser(code);
parser.predicateField();
System.out.println("\t(done)");
}
private static void runListenerTest(String code) {
ModifiersParser parser = createParser(code);
parser.addParseListener(new ModifiersBaseListener() {
@Override
public void exitListenerField(ModifiersParser.ListenerFieldContext ctx) {
// The field rule has finished. Let's verify that no modifiers
// were duplicated.
HashSet<String> uniqueNames = new HashSet<String>();
ArrayList<String> allNames = new ArrayList<String>();
HashSet<String> expectedNames = new HashSet<String>();
expectedNames.add("public");
expectedNames.add("static");
expectedNames.add("final");
if (ctx.listenerModifier() != null && !ctx.listenerModifier().isEmpty()) {
List<ModifiersParser.ListenerModifierContext> modifiers = ctx.listenerModifier();
// Collect all the modifier names in a set.
for (ModifiersParser.ListenerModifierContext modifier : modifiers) {
uniqueNames.add(modifier.getText());
allNames.add(modifier.getText());
}
}
// Is the number of unique modifiers less than the number of
// all given modifiers? If so, then there must be duplicates.
if (uniqueNames.size() < allNames.size()) {
ArrayList<String> names = new ArrayList<String>(allNames);
for (String name : uniqueNames){
names.remove(name);
}
System.out.println("\tDetected duplicate modifiers : " + names);
} else {
System.out.println("\t(No duplicate modifiers detected)");
}
//Are we missing any expected modifiers?
if (!uniqueNames.containsAll(expectedNames)) {
ArrayList<String> names = new ArrayList<String>(expectedNames);
names.removeAll(uniqueNames);
System.out.println("\tDetected missing modifiers : " + names);
} else {
System.out.println("\t(No missing modifiers detected)");
}
}
});
parser.listenerField();
System.out.println("\t(done)");
}
private static ModifiersParser createParser(String code) {
ANTLRInputStream input = new ANTLRInputStream(code);
ModifiersLexer lexer = new ModifiersLexer(input);
ModifiersParser parser = new ModifiersParser(new CommonTokenStream(lexer));
BaseErrorListener errorListener = createErrorListener();
lexer.addErrorListener(errorListener);
parser.addErrorListener(errorListener);
return parser;
}
private static BaseErrorListener createErrorListener() {
BaseErrorListener errorListener = new BaseErrorListener() {
@Override
public void syntaxError(Recognizer<?, ?> recognizer, @Nullable Object offendingSymbol, int line,
int charPositionInLine, String msg, @Nullable RecognitionException e) {
//Print the syntax error
System.out.printf("\t%s at (%d, %d)%n", msg, line, charPositionInLine);
}
};
return errorListener;
}
}
public static final x
(done)
(done)
(No duplicate modifiers detected)
(No missing modifiers detected)
(done)
final static public x
置换输出
(done)
谓词输出
(done)
侦听器输出
(No duplicate modifiers detected)
(No missing modifiers detected)
(done)
static public static final x
extraneous input 'static' expecting 'final' at (1, 14)
(done)
no viable alternative at input 'static' at (1, 14)
(done)
Detected duplicate modifiers : [static]
(No missing modifiers detected)
(done)
static x
no viable alternative at input 'staticx' at (1, 7)
(done)
no viable alternative at input 'x' at (1, 7)
(done)
(No duplicate modifiers detected)
Detected missing modifiers : [final, public]
(done)
输入:缺少和重复的修饰符
final final x
置换输出
no viable alternative at input 'finalfinal' at (1, 6)
(done)
谓词输出
no viable alternative at input 'final' at (1, 6)
(done)
Detected duplicate modifiers : [final]
Detected missing modifiers : [static, public]
(done)
我是ANTLR的新手。我想写一个语法来解析下面的输入: 语法如下:: 当我尝试使用语法解析上述输入时,它会引发以下异常:: 第1行:0不匹配的输入'commit a1b2c3d4',应为'commit' 我已经引用了ANTLR4:不匹配的输入链接,但仍然不清楚发生了什么。
我正在使用elasticsearch从json字段进行精确短语匹配。我尝试过多种语法,比如multi_match、query_string query_string我正在使用的语法; 我也尝试了过滤器而不是查询,但是过滤器在json上没有给出任何结果。我用于过滤器的语法是; 现在的问题是; 是否可以使用elasticsearch对json执行精确匹配操作?
我刚开始使用ANTLR4。我试图为一个简单的程序编写语法规则,但我很难让它工作。 null 任何帮助都很感激!
本文向大家介绍MongoDB精确数组匹配,包括了MongoDB精确数组匹配的使用技巧和注意事项,需要的朋友参考一下 对于精确的数组匹配,只需在MongoDB中使用。让我们创建一个包含文档的集合- 在方法的帮助下显示集合中的所有文档- 这将产生以下输出- 这是对MongoDB数组匹配的查询- 这将产生以下输出-
我正在尝试创建一个Lucene4.10索引。我只想在索引中保存我放入文档的确切字符串,witout标记化。 我在用StandardAnalyzer。 我试图搜索术语“燃料箱容量”@en(包括引号),所以我试图省略它们,并在术语周围添加了另外几个引号,以便让lucene理解我正在搜索整个文本。 如果我打印查询,我会得到:3:“燃料箱容量en”,但我不想拆分@符号上的文本。 我认为我的第一个问题是St
Firebase远程配置有其他选择吗?我需要为中国市场提供一个应用程序,我不确定它是否会起作用