Subversion Repositories openrisc_2011-10-31

/* CPP Library. (Directive handling.)

   Copyright (C) 1986, 1987, 1989, 1992, 1993, 1994, 1995, 1996, 1997, 1998,

   1999, 2000, 2001, 2002, 2003, 2004, 2005,

   2007, 2008, 2009 Free Software Foundation, Inc.

   Contributed by Per Bothner, 1994-95.

   Based on CCCP program by Paul Rubin, June 1986

   Adapted to ANSI C, Richard Stallman, Jan 1987

This program is free software; you can redistribute it and/or modify it

under the terms of the GNU General Public License as published by the

Free Software Foundation; either version 3, or (at your option) any

later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

GNU General Public License for more details.

You should have received a copy of the GNU General Public License

along with this program; see the file COPYING3.  If not see

<http://www.gnu.org/licenses/>.  */

#include "config.h"

#include "system.h"

#include "cpplib.h"

#include "internal.h"

#include "mkdeps.h"

#include "obstack.h"

/* Stack of conditionals currently in progress

   (including both successful and failing conditionals).  */

struct if_stack

{

  struct if_stack *next;

  linenum_type line;            /* Line where condition started.  */

  const cpp_hashnode *mi_cmacro;/* macro name for #ifndef around entire file */

  bool skip_elses;              /* Can future #else / #elif be skipped?  */

  bool was_skipping;            /* If were skipping on entry.  */

  int type;                     /* Most recent conditional for diagnostics.  */

};

/* Contains a registered pragma or pragma namespace.  */

typedef void (*pragma_cb) (cpp_reader *);

struct pragma_entry

{

  struct pragma_entry *next;

  const cpp_hashnode *pragma;   /* Name and length.  */

  bool is_nspace;

  bool is_internal;

  bool is_deferred;

  bool allow_expansion;

  union {

    pragma_cb handler;

    struct pragma_entry *space;

    unsigned int ident;

  } u;

};

/* Values for the origin field of struct directive.  KANDR directives

   come from traditional (K&R) C.  STDC89 directives come from the

   1989 C standard.  EXTENSION directives are extensions.  */

#define KANDR           0

#define STDC89          1

#define EXTENSION       2

/* Values for the flags field of struct directive.  COND indicates a

   conditional; IF_COND an opening conditional.  INCL means to treat

   "..." and <...> as q-char and h-char sequences respectively.  IN_I

   means this directive should be handled even if -fpreprocessed is in

   effect (these are the directives with callback hooks).

   EXPAND is set on directives that are always macro-expanded.  */

#define COND            (1 << 0)

#define IF_COND         (1 << 1)

#define INCL            (1 << 2)

#define IN_I            (1 << 3)

#define EXPAND          (1 << 4)

#define DEPRECATED      (1 << 5)

/* Defines one #-directive, including how to handle it.  */

typedef void (*directive_handler) (cpp_reader *);

typedef struct directive directive;

struct directive

{

  directive_handler handler;    /* Function to handle directive.  */

  const uchar *name;            /* Name of directive.  */

  unsigned short length;        /* Length of name.  */

  unsigned char origin;         /* Origin of directive.  */

  unsigned char flags;          /* Flags describing this directive.  */

};

/* Forward declarations.  */

static void skip_rest_of_line (cpp_reader *);

static void check_eol (cpp_reader *, bool);

static void start_directive (cpp_reader *);

static void prepare_directive_trad (cpp_reader *);

static void end_directive (cpp_reader *, int);

static void directive_diagnostics (cpp_reader *, const directive *, int);

static void run_directive (cpp_reader *, int, const char *, size_t);

static char *glue_header_name (cpp_reader *);

static const char *parse_include (cpp_reader *, int *, const cpp_token ***,

                                  source_location *);

static void push_conditional (cpp_reader *, int, int, const cpp_hashnode *);

static unsigned int read_flag (cpp_reader *, unsigned int);

static bool strtolinenum (const uchar *, size_t, linenum_type *, bool *);

static void do_diagnostic (cpp_reader *, int, int);

static cpp_hashnode *lex_macro_node (cpp_reader *, bool);

static int undefine_macros (cpp_reader *, cpp_hashnode *, void *);

static void do_include_common (cpp_reader *, enum include_type);

static struct pragma_entry *lookup_pragma_entry (struct pragma_entry *,

                                                 const cpp_hashnode *);

static int count_registered_pragmas (struct pragma_entry *);

static char ** save_registered_pragmas (struct pragma_entry *, char **);

static char ** restore_registered_pragmas (cpp_reader *, struct pragma_entry *,

                                           char **);

static void do_pragma_once (cpp_reader *);

static void do_pragma_poison (cpp_reader *);

static void do_pragma_system_header (cpp_reader *);

static void do_pragma_dependency (cpp_reader *);

static void do_linemarker (cpp_reader *);

static const cpp_token *get_token_no_padding (cpp_reader *);

static const cpp_token *get__Pragma_string (cpp_reader *);

static void destringize_and_run (cpp_reader *, const cpp_string *);

static int parse_answer (cpp_reader *, struct answer **, int, source_location);

static cpp_hashnode *parse_assertion (cpp_reader *, struct answer **, int);

static struct answer ** find_answer (cpp_hashnode *, const struct answer *);

static void handle_assertion (cpp_reader *, const char *, int);

static void do_pragma_push_macro (cpp_reader *);

static void do_pragma_pop_macro (cpp_reader *);

/* This is the table of directive handlers.  It is ordered by

   frequency of occurrence; the numbers at the end are directive

   counts from all the source code I have lying around (egcs and libc

   CVS as of 1999-05-18, plus grub-0.5.91, linux-2.2.9, and

   pcmcia-cs-3.0.9).  This is no longer important as directive lookup

   is now O(1).  All extensions other than #warning, #include_next,

   and #import are deprecated.  The name is where the extension

   appears to have come from.  */

#define DIRECTIVE_TABLE                                                 \

D(define,       T_DEFINE = 0,    KANDR,     IN_I)           /* 270554 */ \

D(include,      T_INCLUDE,      KANDR,     INCL | EXPAND)  /*  52262 */ \

D(endif,        T_ENDIF,        KANDR,     COND)           /*  45855 */ \

D(ifdef,        T_IFDEF,        KANDR,     COND | IF_COND) /*  22000 */ \

D(if,           T_IF,           KANDR, COND | IF_COND | EXPAND) /*  18162 */ \

D(else,         T_ELSE,         KANDR,     COND)           /*   9863 */ \

D(ifndef,       T_IFNDEF,       KANDR,     COND | IF_COND) /*   9675 */ \

D(undef,        T_UNDEF,        KANDR,     IN_I)           /*   4837 */ \

D(line,         T_LINE,         KANDR,     EXPAND)         /*   2465 */ \

D(elif,         T_ELIF,         STDC89,    COND | EXPAND)  /*    610 */ \

D(error,        T_ERROR,        STDC89,    0)               /*    475 */ \

D(pragma,       T_PRAGMA,       STDC89,    IN_I)           /*    195 */ \

D(warning,      T_WARNING,      EXTENSION, 0)               /*     22 */ \

D(include_next, T_INCLUDE_NEXT, EXTENSION, INCL | EXPAND)  /*     19 */ \

D(ident,        T_IDENT,        EXTENSION, IN_I)           /*     11 */ \

D(import,       T_IMPORT,       EXTENSION, INCL | EXPAND)  /* 0 ObjC */ \

D(assert,       T_ASSERT,       EXTENSION, DEPRECATED)     /* 0 SVR4 */ \

D(unassert,     T_UNASSERT,     EXTENSION, DEPRECATED)     /* 0 SVR4 */ \

D(sccs,         T_SCCS,         EXTENSION, IN_I)           /* 0 SVR4? */

/* #sccs is synonymous with #ident.  */

#define do_sccs do_ident

/* Use the table to generate a series of prototypes, an enum for the

   directive names, and an array of directive handlers.  */

#define D(name, t, o, f) static void do_##name (cpp_reader *);

DIRECTIVE_TABLE

#undef D

#define D(n, tag, o, f) tag,

enum

{

  DIRECTIVE_TABLE

  N_DIRECTIVES

};

#undef D

#define D(name, t, origin, flags) \

{ do_##name, (const uchar *) #name, \

  sizeof #name - 1, origin, flags },

static const directive dtable[] =

{

DIRECTIVE_TABLE

};

#undef D

#undef DIRECTIVE_TABLE

/* Wrapper struct directive for linemarkers.

   The origin is more or less true - the original K+R cpp

   did use this notation in its preprocessed output.  */

static const directive linemarker_dir =

{

  do_linemarker, UC"#", 1, KANDR, IN_I

};

#define SEEN_EOL() (pfile->cur_token[-1].type == CPP_EOF)

/* Skip any remaining tokens in a directive.  */

static void

skip_rest_of_line (cpp_reader *pfile)

{

  /* Discard all stacked contexts.  */

  while (pfile->context->prev)

    _cpp_pop_context (pfile);

  /* Sweep up all tokens remaining on the line.  */

  if (! SEEN_EOL ())

    while (_cpp_lex_token (pfile)->type != CPP_EOF)

      ;

}

/* Ensure there are no stray tokens at the end of a directive.  If

   EXPAND is true, tokens macro-expanding to nothing are allowed.  */

static void

check_eol (cpp_reader *pfile, bool expand)

{

  if (! SEEN_EOL () && (expand

                        ? cpp_get_token (pfile)

                        : _cpp_lex_token (pfile))->type != CPP_EOF)

    cpp_error (pfile, CPP_DL_PEDWARN, "extra tokens at end of #%s directive",

               pfile->directive->name);

}

/* Ensure there are no stray tokens other than comments at the end of

   a directive, and gather the comments.  */

static const cpp_token **

check_eol_return_comments (cpp_reader *pfile)

{

  size_t c;

  size_t capacity = 8;

  const cpp_token **buf;

  buf = XNEWVEC (const cpp_token *, capacity);

  c = 0;

  if (! SEEN_EOL ())

    {

      while (1)

        {

          const cpp_token *tok;

          tok = _cpp_lex_token (pfile);

          if (tok->type == CPP_EOF)

            break;

          if (tok->type != CPP_COMMENT)

            cpp_error (pfile, CPP_DL_PEDWARN,

                       "extra tokens at end of #%s directive",

                       pfile->directive->name);

          else

            {

              if (c + 1 >= capacity)

                {

                  capacity *= 2;

                  buf = XRESIZEVEC (const cpp_token *, buf, capacity);

                }

              buf[c] = tok;

              ++c;

            }

        }

    }

  buf[c] = NULL;

  return buf;

}

/* Called when entering a directive, _Pragma or command-line directive.  */

static void

start_directive (cpp_reader *pfile)

{

  /* Setup in-directive state.  */

  pfile->state.in_directive = 1;

  pfile->state.save_comments = 0;

  pfile->directive_result.type = CPP_PADDING;

  /* Some handlers need the position of the # for diagnostics.  */

  pfile->directive_line = pfile->line_table->highest_line;

}

/* Called when leaving a directive, _Pragma or command-line directive.  */

static void

end_directive (cpp_reader *pfile, int skip_line)

{

  if (pfile->state.in_deferred_pragma)

    ;

  else if (CPP_OPTION (pfile, traditional))

    {

      /* Revert change of prepare_directive_trad.  */

      pfile->state.prevent_expansion--;

      if (pfile->directive != &dtable[T_DEFINE])

        _cpp_remove_overlay (pfile);

    }

  /* We don't skip for an assembler #.  */

  else if (skip_line)

    {

      skip_rest_of_line (pfile);

      if (!pfile->keep_tokens)

        {

          pfile->cur_run = &pfile->base_run;

          pfile->cur_token = pfile->base_run.base;

        }

    }

  /* Restore state.  */

  pfile->state.save_comments = ! CPP_OPTION (pfile, discard_comments);

  pfile->state.in_directive = 0;

  pfile->state.in_expression = 0;

  pfile->state.angled_headers = 0;

  pfile->directive = 0;

}

/* Prepare to handle the directive in pfile->directive.  */

static void

prepare_directive_trad (cpp_reader *pfile)

{

  if (pfile->directive != &dtable[T_DEFINE])

    {

      bool no_expand = (pfile->directive

                        && ! (pfile->directive->flags & EXPAND));

      bool was_skipping = pfile->state.skipping;

      pfile->state.in_expression = (pfile->directive == &dtable[T_IF]

                                    || pfile->directive == &dtable[T_ELIF]);

      if (pfile->state.in_expression)

        pfile->state.skipping = false;

      if (no_expand)

        pfile->state.prevent_expansion++;

      _cpp_scan_out_logical_line (pfile, NULL);

      if (no_expand)

        pfile->state.prevent_expansion--;

      pfile->state.skipping = was_skipping;

      _cpp_overlay_buffer (pfile, pfile->out.base,

                           pfile->out.cur - pfile->out.base);

    }

  /* Stop ISO C from expanding anything.  */

  pfile->state.prevent_expansion++;

}

/* Output diagnostics for a directive DIR.  INDENTED is nonzero if

   the '#' was indented.  */

static void

directive_diagnostics (cpp_reader *pfile, const directive *dir, int indented)

{

  /* Issue -pedantic or deprecated warnings for extensions.  We let

     -pedantic take precedence if both are applicable.  */

  if (! pfile->state.skipping)

    {

      if (dir->origin == EXTENSION

          && !(dir == &dtable[T_IMPORT] && CPP_OPTION (pfile, objc))

          && CPP_PEDANTIC (pfile))

        cpp_error (pfile, CPP_DL_PEDWARN, "#%s is a GCC extension", dir->name);

      else if (((dir->flags & DEPRECATED) != 0

                || (dir == &dtable[T_IMPORT] && !CPP_OPTION (pfile, objc)))

               && CPP_OPTION (pfile, warn_deprecated))

        cpp_error (pfile, CPP_DL_WARNING, "#%s is a deprecated GCC extension",

                   dir->name);

    }

  /* Traditionally, a directive is ignored unless its # is in

     column 1.  Therefore in code intended to work with K+R

     compilers, directives added by C89 must have their #

     indented, and directives present in traditional C must not.

     This is true even of directives in skipped conditional

     blocks.  #elif cannot be used at all.  */

  if (CPP_WTRADITIONAL (pfile))

    {

      if (dir == &dtable[T_ELIF])

        cpp_error (pfile, CPP_DL_WARNING,

                   "suggest not using #elif in traditional C");

      else if (indented && dir->origin == KANDR)

        cpp_error (pfile, CPP_DL_WARNING,

                   "traditional C ignores #%s with the # indented",

                   dir->name);

      else if (!indented && dir->origin != KANDR)

        cpp_error (pfile, CPP_DL_WARNING,

                   "suggest hiding #%s from traditional C with an indented #",

                   dir->name);

    }

}

/* Check if we have a known directive.  INDENTED is nonzero if the

   '#' of the directive was indented.  This function is in this file

   to save unnecessarily exporting dtable etc. to lex.c.  Returns

   nonzero if the line of tokens has been handled, zero if we should

   continue processing the line.  */

int

_cpp_handle_directive (cpp_reader *pfile, int indented)

{

  const directive *dir = 0;

  const cpp_token *dname;

  bool was_parsing_args = pfile->state.parsing_args;

  bool was_discarding_output = pfile->state.discarding_output;

  int skip = 1;

  if (was_discarding_output)

    pfile->state.prevent_expansion = 0;

  if (was_parsing_args)

    {

      if (CPP_OPTION (pfile, pedantic))

        cpp_error (pfile, CPP_DL_PEDWARN,

             "embedding a directive within macro arguments is not portable");

      pfile->state.parsing_args = 0;

      pfile->state.prevent_expansion = 0;

    }

  start_directive (pfile);

  dname = _cpp_lex_token (pfile);

  if (dname->type == CPP_NAME)

    {

      if (dname->val.node.node->is_directive)

        dir = &dtable[dname->val.node.node->directive_index];

    }

  /* We do not recognize the # followed by a number extension in

     assembler code.  */

  else if (dname->type == CPP_NUMBER && CPP_OPTION (pfile, lang) != CLK_ASM)

    {

      dir = &linemarker_dir;

      if (CPP_PEDANTIC (pfile) && ! CPP_OPTION (pfile, preprocessed)

          && ! pfile->state.skipping)

        cpp_error (pfile, CPP_DL_PEDWARN,

                   "style of line directive is a GCC extension");

    }

  if (dir)

    {

      /* If we have a directive that is not an opening conditional,

         invalidate any control macro.  */

      if (! (dir->flags & IF_COND))

        pfile->mi_valid = false;

      /* Kluge alert.  In order to be sure that code like this

         #define HASH #

         HASH define foo bar

         does not cause '#define foo bar' to get executed when

         compiled with -save-temps, we recognize directives in

         -fpreprocessed mode only if the # is in column 1.  macro.c

         puts a space in front of any '#' at the start of a macro.

         We exclude the -fdirectives-only case because macro expansion

         has not been performed yet, and block comments can cause spaces

         to preceed the directive.  */

      if (CPP_OPTION (pfile, preprocessed)

          && !CPP_OPTION (pfile, directives_only)

          && (indented || !(dir->flags & IN_I)))

        {

          skip = 0;

          dir = 0;

        }

      else

        {

          /* In failed conditional groups, all non-conditional

             directives are ignored.  Before doing that, whether

             skipping or not, we should lex angle-bracketed headers

             correctly, and maybe output some diagnostics.  */

          pfile->state.angled_headers = dir->flags & INCL;

          pfile->state.directive_wants_padding = dir->flags & INCL;

          if (! CPP_OPTION (pfile, preprocessed))

            directive_diagnostics (pfile, dir, indented);

          if (pfile->state.skipping && !(dir->flags & COND))

            dir = 0;

        }

    }

  else if (dname->type == CPP_EOF)

    ;   /* CPP_EOF is the "null directive".  */

  else

    {

      /* An unknown directive.  Don't complain about it in assembly

         source: we don't know where the comments are, and # may

         introduce assembler pseudo-ops.  Don't complain about invalid

         directives in skipped conditional groups (6.10 p4).  */

      if (CPP_OPTION (pfile, lang) == CLK_ASM)

        skip = 0;

      else if (!pfile->state.skipping)

        cpp_error (pfile, CPP_DL_ERROR, "invalid preprocessing directive #%s",

                   cpp_token_as_text (pfile, dname));

    }

  pfile->directive = dir;

  if (CPP_OPTION (pfile, traditional))

    prepare_directive_trad (pfile);

  if (dir)

    pfile->directive->handler (pfile);

  else if (skip == 0)

    _cpp_backup_tokens (pfile, 1);

  end_directive (pfile, skip);

  if (was_parsing_args && !pfile->state.in_deferred_pragma)

    {

      /* Restore state when within macro args.  */

      pfile->state.parsing_args = 2;

      pfile->state.prevent_expansion = 1;

    }

  if (was_discarding_output)

    pfile->state.prevent_expansion = 1;

  return skip;

}

/* Directive handler wrapper used by the command line option

   processor.  BUF is \n terminated.  */

static void

run_directive (cpp_reader *pfile, int dir_no, const char *buf, size_t count)

{

  cpp_push_buffer (pfile, (const uchar *) buf, count,

                   /* from_stage3 */ true);

  start_directive (pfile);

  /* This is a short-term fix to prevent a leading '#' being

     interpreted as a directive.  */

  _cpp_clean_line (pfile);

  pfile->directive = &dtable[dir_no];

  if (CPP_OPTION (pfile, traditional))

    prepare_directive_trad (pfile);

  pfile->directive->handler (pfile);

  end_directive (pfile, 1);

  _cpp_pop_buffer (pfile);

}

/* Checks for validity the macro name in #define, #undef, #ifdef and

   #ifndef directives.  IS_DEF_OR_UNDEF is true if this call is

   processing a #define or #undefine directive, and false

   otherwise.  */

static cpp_hashnode *

lex_macro_node (cpp_reader *pfile, bool is_def_or_undef)

{

  const cpp_token *token = _cpp_lex_token (pfile);

  /* The token immediately after #define must be an identifier.  That

     identifier may not be "defined", per C99 6.10.8p4.

     In C++, it may not be any of the "named operators" either,

     per C++98 [lex.digraph], [lex.key].

     Finally, the identifier may not have been poisoned.  (In that case

     the lexer has issued the error message for us.)  */

  if (token->type == CPP_NAME)

    {

      cpp_hashnode *node = token->val.node.node;

      if (is_def_or_undef && node == pfile->spec_nodes.n_defined)

        cpp_error (pfile, CPP_DL_ERROR,

                   "\"defined\" cannot be used as a macro name");

      else if (! (node->flags & NODE_POISONED))

        return node;

    }

  else if (token->flags & NAMED_OP)

    cpp_error (pfile, CPP_DL_ERROR,

       "\"%s\" cannot be used as a macro name as it is an operator in C++",

               NODE_NAME (token->val.node.node));

  else if (token->type == CPP_EOF)

    cpp_error (pfile, CPP_DL_ERROR, "no macro name given in #%s directive",

               pfile->directive->name);

  else

    cpp_error (pfile, CPP_DL_ERROR, "macro names must be identifiers");

  return NULL;

}

/* Process a #define directive.  Most work is done in macro.c.  */

static void

do_define (cpp_reader *pfile)

{

  cpp_hashnode *node = lex_macro_node (pfile, true);

  if (node)

    {

      /* If we have been requested to expand comments into macros,

         then re-enable saving of comments.  */

      pfile->state.save_comments =

        ! CPP_OPTION (pfile, discard_comments_in_macro_exp);

      if (pfile->cb.before_define)

        pfile->cb.before_define (pfile);

      if (_cpp_create_definition (pfile, node))

        if (pfile->cb.define)

          pfile->cb.define (pfile, pfile->directive_line, node);

      node->flags &= ~NODE_USED;

    }

}

/* Handle #undef.  Mark the identifier NT_VOID in the hash table.  */

static void

do_undef (cpp_reader *pfile)

{

  cpp_hashnode *node = lex_macro_node (pfile, true);

  if (node)

    {

      if (pfile->cb.before_define)

        pfile->cb.before_define (pfile);

      if (pfile->cb.undef)

        pfile->cb.undef (pfile, pfile->directive_line, node);

      /* 6.10.3.5 paragraph 2: [#undef] is ignored if the specified

         identifier is not currently defined as a macro name.  */

      if (node->type == NT_MACRO)

        {

          if (node->flags & NODE_WARN)

            cpp_error (pfile, CPP_DL_WARNING,

                       "undefining \"%s\"", NODE_NAME (node));

          if (CPP_OPTION (pfile, warn_unused_macros))

            _cpp_warn_if_unused_macro (pfile, node, NULL);

          _cpp_free_definition (node);

        }

    }

  check_eol (pfile, false);

}

/* Undefine a single macro/assertion/whatever.  */

static int

undefine_macros (cpp_reader *pfile ATTRIBUTE_UNUSED, cpp_hashnode *h,

                 void *data_p ATTRIBUTE_UNUSED)

{

  /* Body of _cpp_free_definition inlined here for speed.

     Macros and assertions no longer have anything to free.  */

  h->type = NT_VOID;

  h->flags &= ~(NODE_POISONED|NODE_BUILTIN|NODE_DISABLED|NODE_USED);

  return 1;

}

/* Undefine all macros and assertions.  */

void

cpp_undef_all (cpp_reader *pfile)

{

  cpp_forall_identifiers (pfile, undefine_macros, NULL);

}

/* Helper routine used by parse_include.  Reinterpret the current line

   as an h-char-sequence (< ... >); we are looking at the first token

   after the <.  Returns a malloced filename.  */

static char *

glue_header_name (cpp_reader *pfile)

{

  const cpp_token *token;

  char *buffer;

  size_t len, total_len = 0, capacity = 1024;

  /* To avoid lexed tokens overwriting our glued name, we can only

     allocate from the string pool once we've lexed everything.  */

  buffer = XNEWVEC (char, capacity);

  for (;;)

    {

      token = get_token_no_padding (pfile);

      if (token->type == CPP_GREATER)

        break;

      if (token->type == CPP_EOF)

        {

          cpp_error (pfile, CPP_DL_ERROR, "missing terminating > character");

          break;

        }

      len = cpp_token_len (token) + 2; /* Leading space, terminating \0.  */

      if (total_len + len > capacity)

        {

          capacity = (capacity + len) * 2;

          buffer = XRESIZEVEC (char, buffer, capacity);

        }

      if (token->flags & PREV_WHITE)