[antlr-interest] operator precedence and k=1

Boris Koprinarov bkoprinarov at googlemail.com
Sun Sep 6 10:57:58 PDT 2009


Hi,

I am writing a tree grammar for Lua. In the language is defended operator
precedence. The table looks like this:

  or

  and

  <     >     <=    >=    ~=    ==

  ..

  +     -

  *     /     %

  not   #     - (unary)

And here are my rules:

exp

                :              logicalOrExpression;





// level 7 - " OR "

logicalOrExpression

                : logicalAndExpression ( 'or' logicalAndExpression )+
->^(BINOP logicalAndExpression( OR logicalAndExpression)+ )

                | logicalAndExpression;

// level 6 - " AND, NOT "



logicalAndExpression

                : likeExpression ( AND likeExpression )+ -> ^(BINOP
likeExpression (AND likeExpression)+)

                | likeExpression;



// level 5 - " <     >     <=    >=    ~=    == "



likeExpression

                :              conExpression (LESS conExpression)+ ->
^(BINOP conExpression (LESS conExpression)+)

                |             conExpression (MORE conExpression)+ -> ^(BINOP
conExpression (MORE conExpression)+)

                |             conExpression (LESSEQ conExpression)+ ->
^(BINOP conExpression (LESSEQ conExpression)+)

                |             conExpression (MOREEQ conExpression)+ ->
^(BINOP conExpression (MOREEQ conExpression)+)

                |             conExpression (NOTBINEQ conExpression)+ ->
^(BINOP conExpression (NOTBINEQ conExpression)+)

                |             conExpression (BINEQ conExpression)+ ->
^(BINOP conExpression (BINEQ conExpression)+)

                |             conExpression;



// level 6 - ".."

conExpression

                :              additiveExpression (BINEQ
additiveExpression)+ -> ^(BINOP additiveExpression (STRCON
additiveExpression)+)

                |             additiveExpression;



// level 7 - " + -"

additiveExpression

                :              multiplyExpression (ADD multiplyExpression)+
-> ^(BINOP_ADD multiplyExpression ( multiplyExpression)+)

                |             multiplyExpression (SUB multiplyExpression)+
-> ^(BINOP multiplyExpression (SUB multiplyExpression)+)

                |             multiplyExpression;

// level 8 - "*     /     % "

multiplyExpression

                :              unaryExpression (MUL unaryExpression)+ ->
^(BINOP unaryExpression (MUL unaryExpression)+)

                |             unaryExpression (DIV unaryExpression)+ ->
^(BINOP unaryExpression (DIV unaryExpression)+)

                |             unaryExpression (ABS unaryExpression)+ ->
^(BINOP unaryExpression (ABS unaryExpression)+)

                |             unaryExpression ;

// level 9 - unary operators "not   #     -"

unaryExpression

                :              ('not' powExpression)+ -> ^(UOP ^(UNOT
powExpression)+)

                |             (USUB powExpression)+ -> ^(UOP ^(UNOT
powExpression)+)

                |             (ULEN powExpression)+ -> ^(UOP ^(UNOT
powExpression)+)

                |             powExpression;

// level 10 - "^"

powExpression

                :              primaryExpression (POW primaryExpression)+ ->
^(BINOP primaryExpression (POW primaryExpression)+)

                |             primaryExpression;



When I build my parser I need the option k = 1 or my PC gets out of memory.
Is there a better and elegant way to solve this problem?

Regards

Boris Koprinarov
-------------- next part --------------
An HTML attachment was scrubbed...
URL: http://www.antlr.org/pipermail/antlr-interest/attachments/20090906/dbf52c5f/attachment.html 


More information about the antlr-interest mailing list