定义规则以匹配特定模式的AntLR

Question

我是antLR的新手，到目前为止，我可以完成所需的工作。但我很惊讶于定义一个规则来匹配特定的模式。我有以下语法文件

grammar ExpEvalDateParser;



@header {
package com.validationframework;
import com.validationframework.ExpressionBuilder;
import java.util.Calendar;
}


@members {
    private final ExpressionBuilder expressionBuilder = new ExpressionBuilder();
}


/**
 * Parser Rules
 */

ruleString returns [java.lang.String resultExpression]:
       (
         EOF
         |(ruleOperandExpression|ruleOperatorExpression)*

       )
{ resultExpression =expressionBuilder.getExpression(); }
;


ruleOperandExpression :
        fieldEnclosure+ fieldOperand {expressionBuilder.getFieldResponse(Integer.parseInt(!$fieldOperand.text.equals("")?$fieldOperand.text:0));} fieldEnclosure+
;

ruleOperatorExpression:

 ruleOperator {expressionBuilder.addOperand($ruleOperator.text);}
 ;

fieldEnclosure : ENCLOSUREOPEN |ENCLOSURECLOSE;

ENCLOSUREOPEN :'[';

ENCLOSURECLOSE:']';

fieldOperand :
NUMERIC ;

NUMERIC: ('0'..'9')+  ;


ruleOperator :

 LT
 | GT
 | GTE
 | LTE
 | EQ
 | NEQ
;

LT : '<';
GT : '>';
LTE : '<=';
GTE: '>=';
EQ : '==';
NEQ:'!=';

NEWLINE         : '\r'? '\n'        ->channel(HIDDEN) ;
WS              : (' '|'\t')+       ->channel(HIDDEN) ;

我希望我的ruleOperandExpression是10左右

我的ruleOperandExpression定义如下

fieldEnclosure+ fieldOperand {expressionBuilder.getFieldResponse(Integer.parseInt(!$fieldOperand.text.equals("")?$fieldOperand.text:0));} fieldEnclosure+

但是当我在我的android代码中执行规则时，它接受[以及this [10和[]。我希望规则只匹配10。请让我知道如何实现这一点！

==================================Updated Grammer===============================

grammar ExpEvalDateParser;



@header {
package com.validationframework;
import com.validationframework.ExpressionBuilder;
import java.util.Calendar;
}


@members {
    private final ExpressionBuilder expressionBuilder = new ExpressionBuilder();
}


/**
 * Parser Rules
 */

ruleString returns [java.lang.String resultExpression]:
       (
         EOF
         |(logicalGrouping|ruleOperandExpression|ruleOperatorExpression|fieldOperand|numberLiteral)*

       )
{ resultExpression =expressionBuilder.getExpression(); }
;

logicalGrouping :
(PARANTHESISOPEN {expressionBuilder.addOperand("(");}|PARANTHESISCLOSE {expressionBuilder.addOperand(")");})
;


ruleOperandExpression :
        ENCLOSUREOPEN+ fieldOperand+ ENCLOSURECLOSE+ {expressionBuilder.getFieldResponse(Integer.parseInt(!$fieldOperand.text.equals("")?$fieldOperand.text:"0"));}
;

ruleOperatorExpression:
ruleOperator
 ;

fieldEnclosure : (ENCLOSUREOPEN |ENCLOSURECLOSE);

ENCLOSUREOPEN :'[';

ENCLOSURECLOSE:']';

fieldOperand :
NUMERIC ;

numberLiteral:
NUMERIC ;

NUMERIC: ('0'..'9')+  ;


ruleOperator :

 LT {expressionBuilder.addOperand("<");}
 | GT {expressionBuilder.addOperand(">");}
 | GTE {expressionBuilder.addOperand("<=");}
 | LTE {expressionBuilder.addOperand(">=");}
 | EQ {expressionBuilder.addOperand("==");}
 | NEQ {expressionBuilder.addOperand("!=");}
 |isEqualTo
 |isGreaterThan
 |isGreaterThanOrEqualTo
 |isLessThan
 |isLessThanOrEqualTo
 |isNotEqualTo
 |isAfter
 |isAfterOrEqualTo
 |isBefore
 |isBeforeOrEqualTo
 |trueVal
 |falseVal
 |ADD {expressionBuilder.addOperand("+");}
 |MULTIPLY{expressionBuilder.addOperand("*");}
 |SUBSTRACT{expressionBuilder.addOperand("-");}
 |DEVIDE{expressionBuilder.addOperand("/");}
 //|is
 //|isNot
 //|contains
 //|doesNotContain
 //|startsWith
 //|doesNotStartWith
 //|endsWith
 //|doesNotEndWith
;

LT : '<' ;
GT : '>' ;
LTE : '<=' ;
GTE: '>=' ;
EQ : '==' ;
NEQ:'!=' ;

PARANTHESISOPEN:'(' ;
PARANTHESISCLOSE:')'{expressionBuilder.addOperand(")");};

NEWLINE         : '\r'? '\n'        ->channel(HIDDEN) ;
WS              : (' '|'\t')+       ->channel(HIDDEN) ;

isEqualTo: I S E Q U A L T O {expressionBuilder.addOperand("==");};

isGreaterThan : I S G R E A T E R T H A N {expressionBuilder.addOperand(">");};

isGreaterThanOrEqualTo:I S G R E A T E R T H A N O R E Q U A L T O{expressionBuilder.addOperand(">=");};

isLessThan:I S L E S S T H A N {expressionBuilder.addOperand("<");};

isLessThanOrEqualTo:I S L E S S T H A N O R E Q U A L T O {expressionBuilder.addOperand("<=");};
//hasNoValue:H A S N O V A L U E {expressionBuilder.addOperand('>');};
//hasAnyValue:H A S A N Y V A L U E {expressionBuilder.addOperand('>');};
isNotEqualTo:I S N O T E Q U A L T O {expressionBuilder.addOperand("!=");};

isAfter: I S  A F T E R {expressionBuilder.addOperand(">");};

isAfterOrEqualTo:I S A F T E R O R E Q U A L T O {expressionBuilder.addOperand(">=");};

isBefore:I S B E F O R E {expressionBuilder.addOperand("<");};

isBeforeOrEqualTo:I S B E F O R E O R E Q U A L T O {expressionBuilder.addOperand("<=");};

trueVal:T R U E {expressionBuilder.addOperand("==1.0");};

falseVal:F A L S E {expressionBuilder.addOperand("==0.0");};

//is:I S {expressionBuilder.addOperand('equals');};

//isNot:I S N O T {expressionBuilder.addOperand('notEquals');};

//contains:C O N T A I N S {expressionBuilder.addOperand('contains');};

//doesNotContain:D O E S N O T C O N T A I N S {expressionBuilder.addOperand('!contains');};

//startsWith:S T A R T S W I T H {expressionBuilder.addOperand('startsWith');};

//doesNotStartWith:D O E S N O T S T A R T W I T H{expressionBuilder.addOperand('!startWith');};

//endsWith:E N D S W I T H{expressionBuilder.addOperand('endsWith');};

//doesNotEndWith:D O E S N O T E N D S W I T H{expressionBuilder.addOperand('!endsWith');};

//hasNoValue:H A S N O V A L U E{expressionBuilder.addOperand('==');};
//hasAnyValue:H A S A N Y V A L U E;


A: 'A'|'a' ;
B: 'B'|'b' ;
C: 'C'|'c' ;
D: 'D'|'d' ;
E: 'E'|'e' ;
F: 'F'|'f' ;
G: 'G'|'g' ;
H: 'H'|'h' ;
I: 'I'|'i' ;
J: 'J'|'j' ;
K: 'K'|'k' ;
L: 'L'|'l' ;
M: 'M'|'m' ;
N: 'N'|'n' ;
O: 'O'|'o' ;
P: 'P'|'p' ;
Q: 'Q'|'q' ;
R: 'R'|'r' ;
S: 'S'|'s' ;
T: 'T'|'t' ;
U: 'U'|'u' ;
V: 'V'|'v' ;
W: 'W'|'w' ;
X: 'X'|'x' ;
Y: 'Y'|'y' ;
Z: 'Z'|'z' ;

ADD : '+';
SUBSTRACT : '-';
MULTIPLY:'*';
DEVIDE :'/';

Answer 1

你确定ANTLR真的接受你的输入吗？默认情况下，ANTLR会尝试从错误中恢复，并且可能会“意外”地执行进程中的一些Java代码。参见DefaultErrorStrategy。因此，代码的执行并不是被接受的可靠指标。

除了DefaultErrorStrategy陷阱之外，在我看来，识别[10]的简单方法如下所示。

ruleOperandExpression : ENCLOSUREOPEN fieldOperand ENCLOSURECLOSE {...your code...};

这不接受[10，如下面的解析树所示。

​

​

您的规则还接受]10[、]10]和[10[，而上面的规则不接受。如果这些不寻常的模式也是有效的，我建议您提供一些关于您试图解析的内容的更多细节。