Subversion Repositories openrisc_2011-10-31

/* Part of CPP library.  (Macro and #define handling.)

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

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

   2006, 2007, 2008, 2009 Free Software Foundation, Inc.

   Written by Per Bothner, 1994.

   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/>.

 In other words, you are welcome to use, share and improve this program.

 You are forbidden to forbid anyone else to use, share and improve

 what you give them.   Help stamp out software-hoarding!  */

#include "config.h"

#include "system.h"

#include "cpplib.h"

#include "internal.h"

typedef struct macro_arg macro_arg;

struct macro_arg

{

  const cpp_token **first;      /* First token in unexpanded argument.  */

  const cpp_token **expanded;   /* Macro-expanded argument.  */

  const cpp_token *stringified; /* Stringified argument.  */

  unsigned int count;           /* # of tokens in argument.  */

  unsigned int expanded_count;  /* # of tokens in expanded argument.  */

};

/* Macro expansion.  */

static int enter_macro_context (cpp_reader *, cpp_hashnode *,

                                const cpp_token *);

static int builtin_macro (cpp_reader *, cpp_hashnode *);

static void push_ptoken_context (cpp_reader *, cpp_hashnode *, _cpp_buff *,

                                 const cpp_token **, unsigned int);

static _cpp_buff *collect_args (cpp_reader *, const cpp_hashnode *,

                                _cpp_buff **);

static cpp_context *next_context (cpp_reader *);

static const cpp_token *padding_token (cpp_reader *, const cpp_token *);

static void expand_arg (cpp_reader *, macro_arg *);

static const cpp_token *new_string_token (cpp_reader *, uchar *, unsigned int);

static const cpp_token *stringify_arg (cpp_reader *, macro_arg *);

static void paste_all_tokens (cpp_reader *, const cpp_token *);

static bool paste_tokens (cpp_reader *, const cpp_token **, const cpp_token *);

static void replace_args (cpp_reader *, cpp_hashnode *, cpp_macro *,

                          macro_arg *);

static _cpp_buff *funlike_invocation_p (cpp_reader *, cpp_hashnode *,

                                        _cpp_buff **);

static bool create_iso_definition (cpp_reader *, cpp_macro *);

/* #define directive parsing and handling.  */

static cpp_token *alloc_expansion_token (cpp_reader *, cpp_macro *);

static cpp_token *lex_expansion_token (cpp_reader *, cpp_macro *);

static bool warn_of_redefinition (cpp_reader *, const cpp_hashnode *,

                                  const cpp_macro *);

static bool parse_params (cpp_reader *, cpp_macro *);

static void check_trad_stringification (cpp_reader *, const cpp_macro *,

                                        const cpp_string *);

/* Emits a warning if NODE is a macro defined in the main file that

   has not been used.  */

int

_cpp_warn_if_unused_macro (cpp_reader *pfile, cpp_hashnode *node,

                           void *v ATTRIBUTE_UNUSED)

{

  if (node->type == NT_MACRO && !(node->flags & NODE_BUILTIN))

    {

      cpp_macro *macro = node->value.macro;

      if (!macro->used

          && MAIN_FILE_P (linemap_lookup (pfile->line_table, macro->line)))

        cpp_error_with_line (pfile, CPP_DL_WARNING, macro->line, 0,

                             "macro \"%s\" is not used", NODE_NAME (node));

    }

  return 1;

}

/* Allocates and returns a CPP_STRING token, containing TEXT of length

   LEN, after null-terminating it.  TEXT must be in permanent storage.  */

static const cpp_token *

new_string_token (cpp_reader *pfile, unsigned char *text, unsigned int len)

{

  cpp_token *token = _cpp_temp_token (pfile);

  text[len] = '\0';

  token->type = CPP_STRING;

  token->val.str.len = len;

  token->val.str.text = text;

  token->flags = 0;

  return token;

}

static const char * const monthnames[] =

{

  "Jan", "Feb", "Mar", "Apr", "May", "Jun",

  "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"

};

/* Helper function for builtin_macro.  Returns the text generated by

   a builtin macro. */

const uchar *

_cpp_builtin_macro_text (cpp_reader *pfile, cpp_hashnode *node)

{

  const struct line_map *map;

  const uchar *result = NULL;

  linenum_type number = 1;

  switch (node->value.builtin)

    {

    default:

      cpp_error (pfile, CPP_DL_ICE, "invalid built-in macro \"%s\"",

                 NODE_NAME (node));

      break;

    case BT_TIMESTAMP:

      {

        cpp_buffer *pbuffer = cpp_get_buffer (pfile);

        if (pbuffer->timestamp == NULL)

          {

            /* Initialize timestamp value of the assotiated file. */

            struct _cpp_file *file = cpp_get_file (pbuffer);

            if (file)

              {

                /* Generate __TIMESTAMP__ string, that represents

                   the date and time of the last modification

                   of the current source file. The string constant

                   looks like "Sun Sep 16 01:03:52 1973".  */

                struct tm *tb = NULL;

                struct stat *st = _cpp_get_file_stat (file);

                if (st)

                  tb = localtime (&st->st_mtime);

                if (tb)

                  {

                    char *str = asctime (tb);

                    size_t len = strlen (str);

                    unsigned char *buf = _cpp_unaligned_alloc (pfile, len + 2);

                    buf[0] = '"';

                    strcpy ((char *) buf + 1, str);

                    buf[len] = '"';

                    pbuffer->timestamp = buf;

                  }

                else

                  {

                    cpp_errno (pfile, CPP_DL_WARNING,

                        "could not determine file timestamp");

                    pbuffer->timestamp = UC"\"??? ??? ?? ??:??:?? ????\"";

                  }

              }

          }

        result = pbuffer->timestamp;

      }

      break;

    case BT_FILE:

    case BT_BASE_FILE:

      {

        unsigned int len;

        const char *name;

        uchar *buf;

        map = linemap_lookup (pfile->line_table, pfile->line_table->highest_line);

        if (node->value.builtin == BT_BASE_FILE)

          while (! MAIN_FILE_P (map))

            map = INCLUDED_FROM (pfile->line_table, map);

        name = map->to_file;

        len = strlen (name);

        buf = _cpp_unaligned_alloc (pfile, len * 2 + 3);

        result = buf;

        *buf = '"';

        buf = cpp_quote_string (buf + 1, (const unsigned char *) name, len);

        *buf++ = '"';

        *buf = '\0';

      }

      break;

    case BT_INCLUDE_LEVEL:

      /* The line map depth counts the primary source as level 1, but

         historically __INCLUDE_DEPTH__ has called the primary source

         level 0.  */

      number = pfile->line_table->depth - 1;

      break;

    case BT_SPECLINE:

      map = &pfile->line_table->maps[pfile->line_table->used-1];

      /* If __LINE__ is embedded in a macro, it must expand to the

         line of the macro's invocation, not its definition.

         Otherwise things like assert() will not work properly.  */

      number = SOURCE_LINE (map,

                            CPP_OPTION (pfile, traditional)

                            ? pfile->line_table->highest_line

                            : pfile->cur_token[-1].src_loc);

      break;

      /* __STDC__ has the value 1 under normal circumstances.

         However, if (a) we are in a system header, (b) the option

         stdc_0_in_system_headers is true (set by target config), and

         (c) we are not in strictly conforming mode, then it has the

         value 0.  (b) and (c) are already checked in cpp_init_builtins.  */

    case BT_STDC:

      if (cpp_in_system_header (pfile))

        number = 0;

      else

        number = 1;

      break;

    case BT_DATE:

    case BT_TIME:

      if (pfile->date == NULL)

        {

          /* Allocate __DATE__ and __TIME__ strings from permanent

             storage.  We only do this once, and don't generate them

             at init time, because time() and localtime() are very

             slow on some systems.  */

          time_t tt;

          struct tm *tb = NULL;

          /* (time_t) -1 is a legitimate value for "number of seconds

             since the Epoch", so we have to do a little dance to

             distinguish that from a genuine error.  */

          errno = 0;

          tt = time(NULL);

          if (tt != (time_t)-1 || errno == 0)

            tb = localtime (&tt);

          if (tb)

            {

              pfile->date = _cpp_unaligned_alloc (pfile,

                                                  sizeof ("\"Oct 11 1347\""));

              sprintf ((char *) pfile->date, "\"%s %2d %4d\"",

                       monthnames[tb->tm_mon], tb->tm_mday,

                       tb->tm_year + 1900);

              pfile->time = _cpp_unaligned_alloc (pfile,

                                                  sizeof ("\"12:34:56\""));

              sprintf ((char *) pfile->time, "\"%02d:%02d:%02d\"",

                       tb->tm_hour, tb->tm_min, tb->tm_sec);

            }

          else

            {

              cpp_errno (pfile, CPP_DL_WARNING,

                         "could not determine date and time");

              pfile->date = UC"\"??? ?? ????\"";

              pfile->time = UC"\"??:??:??\"";

            }

        }

      if (node->value.builtin == BT_DATE)

        result = pfile->date;

      else

        result = pfile->time;

      break;

    case BT_COUNTER:

      if (CPP_OPTION (pfile, directives_only) && pfile->state.in_directive)

        cpp_error (pfile, CPP_DL_ERROR,

            "__COUNTER__ expanded inside directive with -fdirectives-only");

      number = pfile->counter++;

      break;

    }

  if (result == NULL)

    {

      /* 21 bytes holds all NUL-terminated unsigned 64-bit numbers.  */

      result = _cpp_unaligned_alloc (pfile, 21);

      sprintf ((char *) result, "%u", number);

    }

  return result;

}

/* Convert builtin macros like __FILE__ to a token and push it on the

   context stack.  Also handles _Pragma, for which a new token may not

   be created.  Returns 1 if it generates a new token context, 0 to

   return the token to the caller.  */

static int

builtin_macro (cpp_reader *pfile, cpp_hashnode *node)

{

  const uchar *buf;

  size_t len;

  char *nbuf;

  if (node->value.builtin == BT_PRAGMA)

    {

      /* Don't interpret _Pragma within directives.  The standard is

         not clear on this, but to me this makes most sense.  */

      if (pfile->state.in_directive)

        return 0;

      return _cpp_do__Pragma (pfile);

    }

  buf = _cpp_builtin_macro_text (pfile, node);

  len = ustrlen (buf);

  nbuf = (char *) alloca (len + 1);

  memcpy (nbuf, buf, len);

  nbuf[len]='\n';

  cpp_push_buffer (pfile, (uchar *) nbuf, len, /* from_stage3 */ true);

  _cpp_clean_line (pfile);

  /* Set pfile->cur_token as required by _cpp_lex_direct.  */

  pfile->cur_token = _cpp_temp_token (pfile);

  _cpp_push_token_context (pfile, NULL, _cpp_lex_direct (pfile), 1);

  if (pfile->buffer->cur != pfile->buffer->rlimit)

    cpp_error (pfile, CPP_DL_ICE, "invalid built-in macro \"%s\"",

               NODE_NAME (node));

  _cpp_pop_buffer (pfile);

  return 1;

}

/* Copies SRC, of length LEN, to DEST, adding backslashes before all

   backslashes and double quotes. DEST must be of sufficient size.

   Returns a pointer to the end of the string.  */

uchar *

cpp_quote_string (uchar *dest, const uchar *src, unsigned int len)

{

  while (len--)

    {

      uchar c = *src++;

      if (c == '\\' || c == '"')

        {

          *dest++ = '\\';

          *dest++ = c;

        }

      else

          *dest++ = c;

    }

  return dest;

}

/* Convert a token sequence ARG to a single string token according to

   the rules of the ISO C #-operator.  */

static const cpp_token *

stringify_arg (cpp_reader *pfile, macro_arg *arg)

{

  unsigned char *dest;

  unsigned int i, escape_it, backslash_count = 0;

  const cpp_token *source = NULL;

  size_t len;

  if (BUFF_ROOM (pfile->u_buff) < 3)

    _cpp_extend_buff (pfile, &pfile->u_buff, 3);

  dest = BUFF_FRONT (pfile->u_buff);

  *dest++ = '"';

  /* Loop, reading in the argument's tokens.  */

  for (i = 0; i < arg->count; i++)

    {

      const cpp_token *token = arg->first[i];

      if (token->type == CPP_PADDING)

        {

          if (source == NULL

              || (!(source->flags & PREV_WHITE)

                  && token->val.source == NULL))

            source = token->val.source;

          continue;

        }

      escape_it = (token->type == CPP_STRING || token->type == CPP_CHAR

                   || token->type == CPP_WSTRING || token->type == CPP_WCHAR

                   || token->type == CPP_STRING32 || token->type == CPP_CHAR32

                   || token->type == CPP_STRING16 || token->type == CPP_CHAR16

                   || token->type == CPP_UTF8STRING);

      /* Room for each char being written in octal, initial space and

         final quote and NUL.  */

      len = cpp_token_len (token);

      if (escape_it)

        len *= 4;

      len += 3;

      if ((size_t) (BUFF_LIMIT (pfile->u_buff) - dest) < len)

        {

          size_t len_so_far = dest - BUFF_FRONT (pfile->u_buff);

          _cpp_extend_buff (pfile, &pfile->u_buff, len);

          dest = BUFF_FRONT (pfile->u_buff) + len_so_far;

        }

      /* Leading white space?  */

      if (dest - 1 != BUFF_FRONT (pfile->u_buff))

        {

          if (source == NULL)

            source = token;

          if (source->flags & PREV_WHITE)

            *dest++ = ' ';

        }

      source = NULL;

      if (escape_it)

        {

          _cpp_buff *buff = _cpp_get_buff (pfile, len);

          unsigned char *buf = BUFF_FRONT (buff);

          len = cpp_spell_token (pfile, token, buf, true) - buf;

          dest = cpp_quote_string (dest, buf, len);

          _cpp_release_buff (pfile, buff);

        }

      else

        dest = cpp_spell_token (pfile, token, dest, true);

      if (token->type == CPP_OTHER && token->val.str.text[0] == '\\')

        backslash_count++;

      else

        backslash_count = 0;

    }

  /* Ignore the final \ of invalid string literals.  */

  if (backslash_count & 1)

    {

      cpp_error (pfile, CPP_DL_WARNING,

                 "invalid string literal, ignoring final '\\'");

      dest--;

    }

  /* Commit the memory, including NUL, and return the token.  */

  *dest++ = '"';

  len = dest - BUFF_FRONT (pfile->u_buff);

  BUFF_FRONT (pfile->u_buff) = dest + 1;

  return new_string_token (pfile, dest - len, len);

}

/* Try to paste two tokens.  On success, return nonzero.  In any

   case, PLHS is updated to point to the pasted token, which is

   guaranteed to not have the PASTE_LEFT flag set.  */

static bool

paste_tokens (cpp_reader *pfile, const cpp_token **plhs, const cpp_token *rhs)

{

  unsigned char *buf, *end, *lhsend;

  cpp_token *lhs;

  unsigned int len;

  len = cpp_token_len (*plhs) + cpp_token_len (rhs) + 1;

  buf = (unsigned char *) alloca (len);

  end = lhsend = cpp_spell_token (pfile, *plhs, buf, false);

  /* Avoid comment headers, since they are still processed in stage 3.

     It is simpler to insert a space here, rather than modifying the

     lexer to ignore comments in some circumstances.  Simply returning

     false doesn't work, since we want to clear the PASTE_LEFT flag.  */

  if ((*plhs)->type == CPP_DIV && rhs->type != CPP_EQ)

    *end++ = ' ';

  /* In one obscure case we might see padding here.  */

  if (rhs->type != CPP_PADDING)

    end = cpp_spell_token (pfile, rhs, end, false);

  *end = '\n';

  cpp_push_buffer (pfile, buf, end - buf, /* from_stage3 */ true);

  _cpp_clean_line (pfile);

  /* Set pfile->cur_token as required by _cpp_lex_direct.  */

  pfile->cur_token = _cpp_temp_token (pfile);

  lhs = _cpp_lex_direct (pfile);

  if (pfile->buffer->cur != pfile->buffer->rlimit)

    {

      source_location saved_loc = lhs->src_loc;

      _cpp_pop_buffer (pfile);

      _cpp_backup_tokens (pfile, 1);

      *lhsend = '\0';

      /* We have to remove the PASTE_LEFT flag from the old lhs, but

         we want to keep the new location.  */

      *lhs = **plhs;

      *plhs = lhs;

      lhs->src_loc = saved_loc;

      lhs->flags &= ~PASTE_LEFT;

      /* Mandatory error for all apart from assembler.  */

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

        cpp_error (pfile, CPP_DL_ERROR,

         "pasting \"%s\" and \"%s\" does not give a valid preprocessing token",

                   buf, cpp_token_as_text (pfile, rhs));

      return false;

    }

  *plhs = lhs;

  _cpp_pop_buffer (pfile);

  return true;

}

/* Handles an arbitrarily long sequence of ## operators, with initial

   operand LHS.  This implementation is left-associative,

   non-recursive, and finishes a paste before handling succeeding

   ones.  If a paste fails, we back up to the RHS of the failing ##

   operator before pushing the context containing the result of prior

   successful pastes, with the effect that the RHS appears in the

   output stream after the pasted LHS normally.  */

static void

paste_all_tokens (cpp_reader *pfile, const cpp_token *lhs)

{

  const cpp_token *rhs;

  cpp_context *context = pfile->context;

  do

    {

      /* Take the token directly from the current context.  We can do

         this, because we are in the replacement list of either an

         object-like macro, or a function-like macro with arguments

         inserted.  In either case, the constraints to #define

         guarantee we have at least one more token.  */

      if (context->direct_p)

        rhs = FIRST (context).token++;

      else

        rhs = *FIRST (context).ptoken++;

      if (rhs->type == CPP_PADDING)

        {

          if (rhs->flags & PASTE_LEFT)

            abort ();

        }

      if (!paste_tokens (pfile, &lhs, rhs))

        break;

    }

  while (rhs->flags & PASTE_LEFT);

  /* Put the resulting token in its own context.  */

  _cpp_push_token_context (pfile, NULL, lhs, 1);

}

/* Returns TRUE if the number of arguments ARGC supplied in an

   invocation of the MACRO referenced by NODE is valid.  An empty

   invocation to a macro with no parameters should pass ARGC as zero.

   Note that MACRO cannot necessarily be deduced from NODE, in case

   NODE was redefined whilst collecting arguments.  */

bool

_cpp_arguments_ok (cpp_reader *pfile, cpp_macro *macro, const cpp_hashnode *node, unsigned int argc)

{

  if (argc == macro->paramc)

    return true;

  if (argc < macro->paramc)

    {

      /* As an extension, a rest argument is allowed to not appear in

         the invocation at all.

         e.g. #define debug(format, args...) something

         debug("string");

         This is exactly the same as if there had been an empty rest

         argument - debug("string", ).  */

      if (argc + 1 == macro->paramc && macro->variadic)

        {

          if (CPP_PEDANTIC (pfile) && ! macro->syshdr)

            cpp_error (pfile, CPP_DL_PEDWARN,

                       "ISO C99 requires rest arguments to be used");

          return true;

        }

      cpp_error (pfile, CPP_DL_ERROR,

                 "macro \"%s\" requires %u arguments, but only %u given",

                 NODE_NAME (node), macro->paramc, argc);

    }

  else

    cpp_error (pfile, CPP_DL_ERROR,

               "macro \"%s\" passed %u arguments, but takes just %u",

               NODE_NAME (node), argc, macro->paramc);

  return false;

}

/* Reads and returns the arguments to a function-like macro

   invocation.  Assumes the opening parenthesis has been processed.

   If there is an error, emits an appropriate diagnostic and returns

   NULL.  Each argument is terminated by a CPP_EOF token, for the

   future benefit of expand_arg().  If there are any deferred

   #pragma directives among macro arguments, store pointers to the

   CPP_PRAGMA ... CPP_PRAGMA_EOL tokens into *PRAGMA_BUFF buffer.  */

static _cpp_buff *

collect_args (cpp_reader *pfile, const cpp_hashnode *node,

              _cpp_buff **pragma_buff)

{

  _cpp_buff *buff, *base_buff;

  cpp_macro *macro;

  macro_arg *args, *arg;

  const cpp_token *token;

  unsigned int argc;

  macro = node->value.macro;

  if (macro->paramc)

    argc = macro->paramc;

  else

    argc = 1;

  buff = _cpp_get_buff (pfile, argc * (50 * sizeof (cpp_token *)

                                       + sizeof (macro_arg)));

  base_buff = buff;

  args = (macro_arg *) buff->base;

  memset (args, 0, argc * sizeof (macro_arg));

  buff->cur = (unsigned char *) &args[argc];

  arg = args, argc = 0;

  /* Collect the tokens making up each argument.  We don't yet know

     how many arguments have been supplied, whether too many or too

     few.  Hence the slightly bizarre usage of "argc" and "arg".  */

  do

    {

      unsigned int paren_depth = 0;

      unsigned int ntokens = 0;

      argc++;

      arg->first = (const cpp_token **) buff->cur;

      for (;;)

        {

          /* Require space for 2 new tokens (including a CPP_EOF).  */

          if ((unsigned char *) &arg->first[ntokens + 2] > buff->limit)

            {

              buff = _cpp_append_extend_buff (pfile, buff,

                                              1000 * sizeof (cpp_token *));

              arg->first = (const cpp_token **) buff->cur;

            }

          token = cpp_get_token (pfile);

          if (token->type == CPP_PADDING)

            {

              /* Drop leading padding.  */

              if (ntokens == 0)

                continue;

            }

          else if (token->type == CPP_OPEN_PAREN)

            paren_depth++;

          else if (token->type == CPP_CLOSE_PAREN)

            {

              if (paren_depth-- == 0)

                break;

            }

          else if (token->type == CPP_COMMA)

            {

              /* A comma does not terminate an argument within

                 parentheses or as part of a variable argument.  */

              if (paren_depth == 0

                  && ! (macro->variadic && argc == macro->paramc))

                break;

            }

          else if (token->type == CPP_EOF

                   || (token->type == CPP_HASH && token->flags & BOL))

            break;

          else if (token->type == CPP_PRAGMA)

            {

              cpp_token *newtok = _cpp_temp_token (pfile);