[antlr-interest] I am not understanding tree grammar - please help

Arnar Birgisson ArnarB at oddi.is
Tue Jan 4 01:38:14 PST 2005


Hi there,

You could have your treeparer-rules return values. Like this:

constantValue returns [Object r]
   : i:INTLIT { r = Integer.valueOf(i.getText()); }
   | s:STRING_LITERAL { r = s.getText(); }
   ;

... and ...

addingExpression returns [Object r]
   : #(PLUS op1:multiplyingExpression op2:multiplyingExpression)
          { r = YourClassWithStaticMethods.sum(a, b); }
  |  #(MINUS op3:multiplyingExpression op4:multiplyingExpression)
          { r = YourClassWithStaticMethods.subtract(a, b); }
   etc.

Look at http://www.antlr.org/doc/metalang.html#_bb12 for reference.

Happy new year everyone!

Arnar


>>> "John MccLain" <jmcclain at tcshealthcare.com> 01/03 7:26  >>>
What I want to do is fairly straight forward.

I have a grammar (see below) which builds my AST. The AST nodes are
function
identifiers, logical comparators (e.g., <,>,etc.) and math operators
(e.g.,
+, -, etc..) The children of these nodes are parameters to the
operation
being performed.
All I want to do is create an action for each AST node that takes the
node's
children (parameters) and calls a java function with those parameters.
What
I need to do is walk the tree, replaceing each AST node with the result
of
the function call in its action. The goal is to return the final result
into
the root node, and then print out that node.

Can I do this with ANTLR tree grammar, and if so, how (code/psuedocode
would
be appreciated)???? Are there any tutorials for this kind of
treewalking????

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

class P extends Parser;
options {buildAST=true;}

class P extends Parser;
options {buildAST=true;}

prog: expression EOF;

procedureCallStatement
  : IDENT^ (actualParameters)?
  ;

actualParameters
  : LPAREN! (expression (COMMA! expression)*)? RPAREN!
  ;

expression
  : relationalExpression (("AND"^|"OR"^) relationalExpression)*
  ;

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

addingExpression
  : multiplyingExpression ((PLUS^|MINUS^) multiplyingExpression)*
  ;

multiplyingExpression
  : signExpression ((TIMES^|DIV^|"mod"^) signExpression)*
  ;

signExpression
  : ((PLUS^|MINUS^))* booleanNegationExpression
  ;

booleanNegationExpression
  : ("not"^)* primitiveElement
  ;

primitiveElement
  :
  constantValue
  | LPAREN! expression RPAREN!
  | procedureCallStatement
  ;

constantValue
  : INTLIT
  | STRING_LITERAL
  ;

 class L extends Lexer;

options {
  charVocabulary = '\0'..'\377';
  testLiterals=false;    // don't automatically test for literals
  k=2;                   // two characters of lookahead
}

// Literals
protected DIGIT : '0'..'9'
{System.out.println("1" + getText());};

INTLIT  :  (DIGIT)+
{System.out.println("2" + getText());};
CHARLIT : '\''! . '\''!
{System.out.println("3" + getText());};

// string literals
STRING_LITERAL
  : '"'!
    ( '"' '"'!
    | ~('"'|'\n'|'\r')
    )*
    ( '"'!
    | // nothing -- write error message
    )
{System.out.println("4" + getText());};


// Keywords are literals in the parser grammar

// Operators
DOT        : '.'   ;
BECOMES    : ":="  ;
COLON      : ':'   ;
SEMI       : ';'   ;
COMMA      : ','   ;
EQUALS     : '='   ;
LBRACKET   : '['   ;
RBRACKET   : ']'   ;
DOTDOT     : ".."  ;
LPAREN     : '('
{System.out.println("5" + getText());};
RPAREN     : ')'
{System.out.println("6" + getText());};
NOT_EQUALS : "/="  ;
LT         : '<'
{System.out.println("7" + getText());};
LTE        : "<="  ;
GT         : '>'   ;
GTE        : ">="  ;
PLUS       : '+'
{System.out.println("8" + getText());};
MINUS      : '-'   ;
TIMES      : '*'   ;
DIV        : '/'   ;



// Whitespace -- ignored
WS
  : ( ' '
    | '\t'
    | '\f'

    // handle newlines
    | ( "\r\n"  // Evil DOS
      | '\r'    // Macintosh
      | '\n'    // Unix (the right way)
      )
      { newline(); }
    )
    { $setType(Token.SKIP); }
  ;


// an identifier.  Note that testLiterals is set to true!  This means
// that after we match the rule, we look in the literals table to see
// if it's a literal or really an identifer
IDENT
  options {testLiterals=true;}
  : ('a'..'z'|'A'..'Z') ('a'..'z'|'A'..'Z'|'0'..'9')*
{System.out.println("10" + getText());};


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



John McClain
Senior Software Engineer
TCS Healthcare
jmcclain at tcshealthcare.com 
(530)886-1700x235
"Before you criticize someone, walk a mile in their shoes.
That way, you'll be a mile from them, and you'll have their shoes."



More information about the antlr-interest mailing list