[antlr-interest] nondeterminism question

[Klaas Hofstra]

Shmuel,

Thanks for your reply!

>I am guessing at the structure of expression
I added the complete expression grammar below.
>[..] but it seems to me that  
>range, and therefore the line in question, can't distinguish between a 
>grouped expression and a bitSpliceExpression. Does changing k, the 
>lookahead, value help.

When you say 'grouped expression', do you mean 'LPAREN expression RPAREN' ?

Because bitSliceExpression can only follow a 'primaryExpression' or 'LPAREN 
expression RPAREN!' I thought it could be distinguised from a grouped 
expression. Am I missing something?

I changed k to 3. This resulted in the following warning at the same line as 
before:

warning:nondeterminism between alts 1 and 2 of block upon
  k==1:LPAREN
  k==2:ID,LPAREN,INT,REAL,PLUS,MINUS,"not","cast"
  k==3:ID,LT,GT,LPAREN,LBRACKET,INT,REAL,"signed","unsigned","float",
            "integer","enum",DOTDOT,"and","or","nand","nor","xor","xnor",
            EQUALS,NOT_EQUALS,GTE,LTE,"sll","srl","sla","sra","rol","ror",
            PLUS,MINUS,TIMES,DIV,"mod","not","cast"

Looking at the above warning, I guess there is a problem with the expressions 
in 'range' but I don't get why.

Anyone?

TIA,

Klaas
-----------------------------------

typeDef
    : "signed"
    | "unsigned"
    | "float"
    | ("integer" ( LPAREN! range RPAREN! )? )      <= warning on this line
    ;

range 
    : expression DOTDOT! expression
    ;

expression
    : logicalExpression
    ;

logicalExpression
    : relationalExpression ((AND^ | OR^ | NAND^ | NOR^ | XOR^ | XNOR^) 
relationalExpression)*
    ;

relationalExpression
    : shiftExpression ((EQUALS^ | NOT_EQUALS^ | GT^ | GTE^ | LT^ | LTE^) 
shiftExpression)*
    ;

shiftExpression
    : addExpression ((SLL^ | SRL^ | SLA^ | SRA^ | ROL^ | ROR^) addExpression)*
    ;

addExpression
    : mulExpression ((PLUS^ | MINUS^) mulExpression)*
    ;

mulExpression
    : unaryExpression ((TIMES^ | DIV^ | MOD^) unaryExpression)*
    ;

unaryExpression
    : postFixExpression
    | PLUS^ unaryExpression
    | MINUS^ unaryExpression
    | NOT^ unaryExpression
    | "cast"! (typeSpec | ID) unaryExpression
    ;

postFixExpression
    : (primaryExpression | (LPAREN! expression RPAREN!)) (
      (bitIndexExpression) => bitIndexExpression
    | bitSliceExpression 
    | arrayIndexExpression
     )?
    ;

arrayIndexExpression
    : LBRACKET! logicalExpression RBRACKET!
    ;

bitIndexExpression
    : LPAREN! logicalExpression RPAREN!
    ;

bitSliceExpression
    : LPAREN! logicalExpression DOTDOT! logicalExpression RPAREN!
    ;

primaryExpression
    : ID | INT | REAL 
    ;

-----------------------------------