I am now trying to understand how to do the CST->AST transformations for my 
grammer.  I was starting with just trying to transform the expression section 
of my grammar (trying to follow the sample in 
http://nat.truemesh.com/archives/000531.html) 

I have a CST section that looks like:


  expression {-> expression} =
     {plus}   [left]:expression plus   [right]:term {->New 
expression.add(left.expression,right.expression)}
   | {minus}  [left]:expression minus  [right]:term {->New 
expression.subtract(left.expression,right.expression)}
   | {mod}    [left]:expression modulo [right]:term {->New 
expression.modulo(left.expression,right.expression)}
   | {term}   term {->term.expression}
   ;

  term {-> expression} = 
     {mult}   [left]:term star  [right]:expon  {->New 
expression.multiply(left.expression,right.expression)}
   | {div}    [left]:term slash [right]:expon  {->New 
expression.divide(left.expression,right.expression)} 
   | {expon}  expon {-> expon.expression} 
   ;

  expon {-> expression} = 
     {expon}  [left]:expon  power [right]:factor {->New 
expression.power(left.expression,right.expression)}
   | {factor} factor                             {-> factor.expression}
   ;

  factor {-> expression } =
      {unary}        number {-> number.expression}
    | {expression}  l_par expression r_par                   {-> 
expression.expression}
    ;
  number {->expression} = 
       {float}    unop? [literal]:floating_point_literal  {->New 
expression.unary(unop.expression,literal)} 
   ;
                     
  unop {-> expression} = {plus}  plus 
                       | {minus} minus          // negate
                     ;


and my AST section looks like:

Abstract Syntax Tree

  expression = {add}        [left]:expression [right]:expression
             | {subtract}   [left]:expression [right]:expression
             | {multiply}   [left]:expression [right]:expression
             | {divide}     [left]:expression [right]:expression
             | {power}      [left]:expression [right]:expression
             | {modulo}     [left]:expression [right]:expression
             | {unary}      unop?  expression
            
             
              ;
   
   unop = 
               {plus}  plus 
             | {minus} minus            // negate
             ;


The problem is that when I run this I get the following error from SableCC:
Verifying production transform identifiers.
Verifying ast alternatives transform identifiers.
java.lang.RuntimeException: [576,82] expecting #PUnop?# when #PExpression?# was 
found
        at org.sablecc.sablecc.ResolveTransformIds.error10(Unknown Source)
        at org.sablecc.sablecc.ResolveTransformIds.checkTypeCompability(Unknown 
Source)
        at org.sablecc.sablecc.ResolveTransformIds.outANewTerm(Unknown Source)

I must have specified something incorrectly, but not sure what.  It feels like 
I should not have needed to put the "unop" section in the AST, but I couldn't 
figure out how not to do that (SableCC would tell me that PUnop was undefined, 
etc. if I didn't)

Thanks!

Roger




-- 
See Exclusive Video: Hollywood Life's 5th Annual Style Awards
http://www.hollywoodlife.net/Awards.aspx?AwardsID=style2008


_______________________________________________
SableCC-Discussion mailing list
[email protected]
http://lists.sablecc.org/listinfo/sablecc-discussion

Reply via email to