Re: #pragma interface/implementation broken if --enable-mapped-location

[Zack Weinberg <zack@codesourcery.com>]

"Joseph S. Myers" <jsm@polyomino.org.uk> writes:

> On Thu, 23 Sep 2004, Zack Weinberg wrote:
>
>> Alternatively, I wanted originally to defer pragmas not by
>> encapsulating the un-tokenized line in a string, but by injecting a
>> keyword (__pragma) at the beginning of the line, a semicolon at the
>> end, and tokenizing normally (but with macro expansion disabled).
>> Matt persuaded me that was hard to implement, but maybe it should be
>> revisited.
>
> That would also probably be convenient for OpenMP pragma implementation 
> for C (where the pragmas can contain expressions that need to go through 
> the parser as usual).  But for most target pragmas attempting to hook them 
> in the grammar like that would seem an excess complication; the grammar 
> would effectively just gather up a sequence of arbitrary tokens again to 
> pass to the target pragma handler.  (Bearing in mind the general 
> desirability that target pragmas share a single implementation for C and 
> C++.)

Well, remember that the way target pragma handlers work now is they
get tokens one at a time by calling c_lex.  This was always intended
to be hookable into a recursive descent parser as C++ has.  (I didn't
consider hooking target-specific pragmas into C's Yacc parser ever to
be feasible.)

My medium-term goals for the C++ front end involve bypassing c_lex and
having cpplib write its tokens directly into the big buffer that
cp/parser.c is now maintaining.  For the sake of the #pragma handlers,
it would then provide its own c_lex that is basically an exported
version of cp_lexer_consume_token.

Given all that, I think it makes sense for all pragmas to become
token sequences.  The difference between the OpenMP pragmas and the
others is just that they want to call back to the expression parser,
which is currently feasible for C++ and not for C.

> I wonder if also the check for unrecognized pragmas should be made
> before the pragma becomes any sort of token, on the basis that the C
> and C++ standards explicitly say that unknown pragmas are ignored
> (and so should be permitted anywhere in the source file, not just in
> reasonable places).  That would seem cleaner than documenting that
> all pragmas are recognized in order to give errors if they occur in
> an inconvenient place.

Suppose that cpplib, on encountering a #pragma, parsed the (namespace
and) keyword to decide what it meant.  If the #pragma was unknown, it
would then throw away the entire line.  If it was not unknown, it
would inject a CPP_PRAGMA token at the beginning of the line *in place
of* the token sequence # pragma [namespace] keyword.  The value of
this token would be a function pointer for the appropriate #pragma
handler.  I think that'd achieve both what you want and what I want,
and would also avoid doing the handler lookup twice.

Thoughts?

zw