Question

Is there a way to specify that a Bison rule should NOT match if the lookahead token is a given value?

I currently have the following Bison grammar (simplified):

var_decl:
        type ident
        {
            $$ = new NVariableDeclaration(*$1, *$2);
        } |
        type ident ASSIGN_EQUAL expr
        {
            $$ = new NVariableDeclaration(*$1, *$2, $4);
        } |
        type CURVED_OPEN STAR ident CURVED_CLOSE CURVED_OPEN func_decl_args CURVED_CLOSE
        {
            $$ = new NVariableDeclaration(*(new NFunctionPointerType(*$1, *$7)) /* TODO: free this memory */, *$4);
        } |
        type CURVED_OPEN STAR ident CURVED_CLOSE CURVED_OPEN func_decl_args CURVED_CLOSE ASSIGN_EQUAL expr
        {
            $$ = new NVariableDeclaration(*(new NFunctionPointerType(*$1, *$7)) /* TODO: free this memory */, *$4, $10);
        } ;

...

deref:
        STAR ident
        {
            $$ = new NDereferenceOperator(*$<ident>2);
        } |

...

type:
        ident
        {
            $$ = new NType($<type>1->name, 0, false);
            delete $1;
        } |
        ... ;

...

expr:
        deref
        {
            $$ = $1;
        } |
        ...
        ident
        {
            $<ident>$ = $1;
        } |
        ...
        ident CURVED_OPEN call_args CURVED_CLOSE
        {
            $$ = new NMethodCall(*$1, *$3);
            delete $3;
        } |
        ...
        CURVED_OPEN expr CURVED_CLOSE
        {
            $$ = $2;
        } ;

...

call_args:
        /* empty */
        {
            $$ = new ExpressionList();
        } |
        expr
        {
            $$ = new ExpressionList();
            $$->push_back($1);
        } |
        call_args COMMA expr
        {
            $1->push_back($3);
        } ;

The problem is that when parsing:

void (*ident)(char* some_arg);

It’s seeing void (*ident) and deducing that it must be a function call instead of a function declaration. Is there a way I can tell Bison that it should favour looking ahead to match var_decl instead of reducing *ident and void into derefs and exprs?

Answer 1

any identifier can be a type

That’s exactly the problem. LALR(1) grammars for C-like languages (or languages with C-like syntax for types) need to differentiate types and other identifiers at the token level. That is, you need IDENT and TYPEIDENT be two different tokens. (You will have to feed data about identifiers from the compiler back to the tokenizer). It’s the most standard way to disambiguate the otherwise ambiguous grammar.

Update See, for instance, this ANSI C grammar for Yacc.