New subject: tools/widl: Split expr_int_const off from expr

2 Jul 2009

2009/6/28 Gerald Pfeifer &lt;gerald(a)pfeifer.com&gt;om>:
...
  diff --git a/tools/widl/parser.y
b/tools/widl/parser.y
 index c2f1abc..01aa060 100644
 --- a/tools/widl/parser.y
 +++ b/tools/widl/parser.y
 @@ -622,56 +633,54 @@ m_expr:                                           { $$ =
make_expr(EXPR_VOID); }
        | expr
        ;

 -expr:    aNUM                                  { $$ = make_exprl(EXPR_NUM, $1); }
 -       | aHEXNUM                               { $$ = make_exprl(EXPR_HEXNUM, $1); }
 +expr:  expr_int_const
        | aDOUBLE                               { $$ = make_exprd(EXPR_DOUBLE, $1); }
 +       | '-' aDOUBLE                           { $$ = make_exprd(EXPR_DOUBLE,
-($2)); } 
This is covered by the production for the binary minus operator that
already exists, so I'm not sure what you're trying to achieve here.

...
         | tFALSE                                { $$ =
make_exprl(EXPR_TRUEFALSE, 0); }
 -       | tNULL                                 { $$ = make_exprl(EXPR_NUM, 0); }
        | tTRUE                                 { $$ = make_exprl(EXPR_TRUEFALSE, 1); }
        | aSTRING                               { $$ = make_exprs(EXPR_STRLIT, $1); }
        | aWSTRING                              { $$ = make_exprs(EXPR_WSTRLIT, $1); }
 -       | aIDENTIFIER                           { $$ = make_exprs(EXPR_IDENTIFIER, $1);
}
        | expr '?' expr ':' expr                { $$ =
make_expr3(EXPR_COND, $1, $3, $5); }
        | expr LOGICALOR expr                   { $$ = make_expr2(EXPR_LOGOR, $1, $3); }
        | expr LOGICALAND expr                  { $$ = make_expr2(EXPR_LOGAND, $1, $3); }
 -       | expr '|' expr                         { $$ = make_expr2(EXPR_OR , $1,
$3); }
 -       | expr '^' expr                         { $$ = make_expr2(EXPR_XOR, $1,
$3); }
 -       | expr '&' expr                         { $$ = make_expr2(EXPR_AND,
$1, $3); }
        | expr EQUALITY expr                    { $$ = make_expr2(EXPR_EQUALITY, $1, $3);
}
        | expr INEQUALITY expr                  { $$ = make_expr2(EXPR_INEQUALITY, $1,
$3); }
        | expr '>' expr                         { $$ = make_expr2(EXPR_GTR, $1,
$3); }
        | expr '<' expr                         { $$ = make_expr2(EXPR_LESS,
$1, $3); }
        | expr GREATEREQUAL expr                { $$ = make_expr2(EXPR_GTREQL, $1, $3); }
        | expr LESSEQUAL expr                   { $$ = make_expr2(EXPR_LESSEQL, $1, $3);
}
 -       | expr SHL expr                         { $$ = make_expr2(EXPR_SHL, $1, $3); }
 -       | expr SHR expr                         { $$ = make_expr2(EXPR_SHR, $1, $3); }
 -       | expr '+' expr                         { $$ = make_expr2(EXPR_ADD, $1,
$3); }
 -       | expr '-' expr                         { $$ = make_expr2(EXPR_SUB, $1,
$3); }
 -       | expr '%' expr                         { $$ = make_expr2(EXPR_MOD, $1,
$3); }
 -       | expr '*' expr                         { $$ = make_expr2(EXPR_MUL, $1,
$3); }
 -       | expr '/' expr                         { $$ = make_expr2(EXPR_DIV, $1,
$3); }
        | '!' expr                              { $$ = make_expr1(EXPR_LOGNOT,
$2); }
 -       | '~' expr                              { $$ = make_expr1(EXPR_NOT, $2);
}
 -       | '+' expr %prec POS                    { $$ = make_expr1(EXPR_POS, $2);
}
 -       | '-' expr %prec NEG                    { $$ = make_expr1(EXPR_NEG, $2);
}
        | '&' expr %prec ADDRESSOF              { $$ =
make_expr1(EXPR_ADDRESSOF, $2); }
        | '*' expr %prec PPTR                   { $$ = make_expr1(EXPR_PPTR, $2);
}
        | expr MEMBERPTR aIDENTIFIER            { $$ = make_expr2(EXPR_MEMBER,
make_expr1(EXPR_PPTR, $1), make_exprs(EXPR_IDENTIFIER, $3)); }
        | expr '.' aIDENTIFIER                  { $$ = make_expr2(EXPR_MEMBER, $1,
make_exprs(EXPR_IDENTIFIER, $3)); }
        | '(' type ')' expr %prec CAST          { $$ =
make_exprt(EXPR_CAST, $2, $4); }
 -       | tSIZEOF '(' type ')'                  { $$ =
make_exprt(EXPR_SIZEOF, $3, NULL); }
        | expr '[' expr ']'                     { $$ =
make_expr2(EXPR_ARRAY, $1, $3); }
 -       | '(' expr ')'                          { $$ = $2; }
        ;

  expr_list_int_const: expr_int_const            { $$ = append_expr( NULL, $1 ); }
        | expr_list_int_const ',' expr_int_const        { $$ = append_expr( $1, $3
); }
        ;

 -expr_int_const: expr                           { $$ = $1;
 -                                                 if (!$$->is_const)
 -                                                     error_loc("expression is not
an integer constant\n");
 -                                               }
 +expr_int_const: aNUM                           { $$ = make_exprl(EXPR_NUM, $1); }
 +       | aHEXNUM                               { $$ = make_exprl(EXPR_HEXNUM, $1); }
 +       | tNULL                                 { $$ = make_exprl(EXPR_NUM, 0); }
 +       | aIDENTIFIER                           { $$ = make_exprs(EXPR_IDENTIFIER, $1); }

aIDENTIFIER isn't necessarily a constant expression.

...
  +       | '~' expr_int_const                  
 { $$ = make_expr1(EXPR_NOT, $2); }
 +       | '+' expr_int_const %prec POS          { $$ = make_expr1(EXPR_POS, $2);
}
 +       | '-' expr_int_const %prec NEG          { $$ = make_expr1(EXPR_NEG, $2);
}
 +       | expr_int_const SHL expr_int_const     { $$ = make_expr2(EXPR_SHL, $1, $3); }
 +       | expr_int_const SHR expr_int_const     { $$ = make_expr2(EXPR_SHR, $1, $3); }
 +       | expr_int_const '+' expr_int_const     { $$ = make_expr2(EXPR_ADD, $1,
$3); }
 +       | expr_int_const '-' expr_int_const     { $$ = make_expr2(EXPR_SUB, $1,
$3); }
 +       | expr_int_const '%' expr_int_const     { $$ = make_expr2(EXPR_MOD, $1,
$3); }
 +       | expr_int_const '*' expr_int_const     { $$ = make_expr2(EXPR_MUL, $1,
$3); }
 +       | expr_int_const '/' expr_int_const     { $$ = make_expr2(EXPR_DIV, $1,
$3); }
 +       | expr_int_const '|' expr_int_const     { $$ = make_expr2(EXPR_OR , $1,
$3); }
 +       | expr_int_const '^' expr_int_const     { $$ = make_expr2(EXPR_XOR, $1,
$3); }
 +       | expr_int_const '&' expr_int_const     { $$ = make_expr2(EXPR_AND,
$1, $3); } 
Using "expr_int_const" instead of "expr" here prevents a many forms
of
expressions from being parsed.

...
  +       | tSIZEOF '(' type ')'        
         { $$ = make_exprt(EXPR_SIZEOF, $3, NULL); }
 +       | '(' expr ')'                          { $$ = $2; }
        ;

  expr_const: expr                               { $$ = $1; 
It looks like you'll have to find another way of fixing the issue you
are trying to fix.

-- 
Rob Shearman

Re: tools/widl: Split expr_int_const off from expr