+++ /dev/null
-/* Part of CPP library. (Macro and #define handling.)
- Copyright (C) 1986-2022 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! */
-
-#pragma GCC diagnostic ignored "-Wparentheses"
-
-
-#include "config.h"
-#include "system.h"
-#include "cpplib.h"
-#include "internal.h"
-
-// RT extension
-static const uchar *evaluate_TO_ARG_LIST(cpp_reader *pfile);
-
-
-typedef struct macro_arg macro_arg;
-/* This structure represents the tokens of a macro argument. These
- tokens can be macro themselves, in which case they can be either
- expanded or unexpanded. When they are expanded, this data
- structure keeps both the expanded and unexpanded forms. */
-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. */
- location_t *virt_locs; /* Where virtual locations for
- unexpanded tokens are stored. */
- location_t *expanded_virt_locs; /* Where virtual locations for
- expanded tokens are
- stored. */
-};
-
-/* The kind of macro tokens which the instance of
- macro_arg_token_iter is supposed to iterate over. */
-enum macro_arg_token_kind {
- MACRO_ARG_TOKEN_NORMAL,
- /* This is a macro argument token that got transformed into a string
- literal, e.g. #foo. */
- MACRO_ARG_TOKEN_STRINGIFIED,
- /* This is a token resulting from the expansion of a macro
- argument that was itself a macro. */
- MACRO_ARG_TOKEN_EXPANDED
-};
-
-/* An iterator over tokens coming from a function-like macro
- argument. */
-typedef struct macro_arg_token_iter macro_arg_token_iter;
-struct macro_arg_token_iter
-{
- /* Whether or not -ftrack-macro-expansion is used. */
- bool track_macro_exp_p;
- /* The kind of token over which we are supposed to iterate. */
- enum macro_arg_token_kind kind;
- /* A pointer to the current token pointed to by the iterator. */
- const cpp_token **token_ptr;
- /* A pointer to the "full" location of the current token. If
- -ftrack-macro-expansion is used this location tracks loci across
- macro expansion. */
- const location_t *location_ptr;
-#if CHECKING_P
- /* The number of times the iterator went forward. This useful only
- when checking is enabled. */
- size_t num_forwards;
-#endif
-};
-
-/* Saved data about an identifier being used as a macro argument
- name. */
-struct macro_arg_saved_data {
- /* The canonical (UTF-8) spelling of this identifier. */
- cpp_hashnode *canonical_node;
- /* The previous value & type of this identifier. */
- union _cpp_hashnode_value value;
- node_type type;
-};
-
-static const char *vaopt_paste_error =
- N_("'##' cannot appear at either end of __VA_OPT__");
-
-static void expand_arg (cpp_reader *, macro_arg *);
-
-/* A class for tracking __VA_OPT__ state while iterating over a
- sequence of tokens. This is used during both macro definition and
- expansion. */
-class vaopt_state {
-
- public:
-
- enum update_type
- {
- ERROR,
- DROP,
- INCLUDE,
- BEGIN,
- END
- };
-
- /* Initialize the state tracker. ANY_ARGS is true if variable
- arguments were provided to the macro invocation. */
- vaopt_state (cpp_reader *pfile, bool is_variadic, macro_arg *arg)
- : m_pfile (pfile),
- m_arg (arg),
- m_variadic (is_variadic),
- m_last_was_paste (false),
- m_stringify (false),
- m_state (0),
- m_paste_location (0),
- m_location (0),
- m_update (ERROR)
- {
- }
-
- /* Given a token, update the state of this tracker and return a
- boolean indicating whether the token should be be included in the
- expansion. */
- update_type update (const cpp_token *token)
- {
- /* If the macro isn't variadic, just don't bother. */
- if (!m_variadic)
- return INCLUDE;
-
- if (token->type == CPP_NAME
- && token->val.node.node == m_pfile->spec_nodes.n__VA_OPT__)
- {
- if (m_state > 0)
- {
- cpp_error_at (m_pfile, CPP_DL_ERROR, token->src_loc,
- "__VA_OPT__ may not appear in a __VA_OPT__");
- return ERROR;
- }
- ++m_state;
- m_location = token->src_loc;
- m_stringify = (token->flags & STRINGIFY_ARG) != 0;
- return BEGIN;
- }
- else if (m_state == 1)
- {
- if (token->type != CPP_OPEN_PAREN)
- {
- cpp_error_at (m_pfile, CPP_DL_ERROR, m_location,
- "__VA_OPT__ must be followed by an "
- "open parenthesis");
- return ERROR;
- }
- ++m_state;
- if (m_update == ERROR)
- {
- if (m_arg == NULL)
- m_update = INCLUDE;
- else
- {
- m_update = DROP;
- if (!m_arg->expanded)
- expand_arg (m_pfile, m_arg);
- for (unsigned idx = 0; idx < m_arg->expanded_count; ++idx)
- if (m_arg->expanded[idx]->type != CPP_PADDING)
- {
- m_update = INCLUDE;
- break;
- }
- }
- }
- return DROP;
- }
- else if (m_state >= 2)
- {
- if (m_state == 2 && token->type == CPP_PASTE)
- {
- cpp_error_at (m_pfile, CPP_DL_ERROR, token->src_loc,
- vaopt_paste_error);
- return ERROR;
- }
- /* Advance states before further considering this token, in
- case we see a close paren immediately after the open
- paren. */
- if (m_state == 2)
- ++m_state;
-
- bool was_paste = m_last_was_paste;
- m_last_was_paste = false;
- if (token->type == CPP_PASTE)
- {
- m_last_was_paste = true;
- m_paste_location = token->src_loc;
- }
- else if (token->type == CPP_OPEN_PAREN)
- ++m_state;
- else if (token->type == CPP_CLOSE_PAREN)
- {
- --m_state;
- if (m_state == 2)
- {
- /* Saw the final paren. */
- m_state = 0;
-
- if (was_paste)
- {
- cpp_error_at (m_pfile, CPP_DL_ERROR, token->src_loc,
- vaopt_paste_error);
- return ERROR;
- }
-
- return END;
- }
- }
- return m_update;
- }
-
- /* Nothing to do with __VA_OPT__. */
- return INCLUDE;
- }
-
- /* Ensure that any __VA_OPT__ was completed. If ok, return true.
- Otherwise, issue an error and return false. */
- bool completed ()
- {
- if (m_variadic && m_state != 0)
- cpp_error_at (m_pfile, CPP_DL_ERROR, m_location,
- "unterminated __VA_OPT__");
- return m_state == 0;
- }
-
- /* Return true for # __VA_OPT__. */
- bool stringify () const
- {
- return m_stringify;
- }
-
- private:
-
- /* The cpp_reader. */
- cpp_reader *m_pfile;
-
- /* The __VA_ARGS__ argument. */
- macro_arg *m_arg;
-
- /* True if the macro is variadic. */
- bool m_variadic;
- /* If true, the previous token was ##. This is used to detect when
- a paste occurs at the end of the sequence. */
- bool m_last_was_paste;
- /* True for #__VA_OPT__. */
- bool m_stringify;
-
- /* The state variable:
- 0 means not parsing
- 1 means __VA_OPT__ seen, looking for "("
- 2 means "(" seen (so the next token can't be "##")
- >= 3 means looking for ")", the number encodes the paren depth. */
- int m_state;
-
- /* The location of the paste token. */
- location_t m_paste_location;
-
- /* Location of the __VA_OPT__ token. */
- location_t m_location;
-
- /* If __VA_ARGS__ substitutes to no preprocessing tokens,
- INCLUDE, otherwise DROP. ERROR when unknown yet. */
- update_type m_update;
-};
-
-/* Macro expansion. */
-
-static cpp_macro *get_deferred_or_lazy_macro (cpp_reader *, cpp_hashnode *,
- location_t);
-static int enter_macro_context (cpp_reader *, cpp_hashnode *,
- const cpp_token *, location_t);
-static int builtin_macro (cpp_reader *, cpp_hashnode *,
- location_t, location_t);
-static void push_ptoken_context (cpp_reader *, cpp_hashnode *, _cpp_buff *,
- const cpp_token **, unsigned int);
-static void push_extended_tokens_context (cpp_reader *, cpp_hashnode *,
- _cpp_buff *, location_t *,
- const cpp_token **, unsigned int);
-static _cpp_buff *collect_args (cpp_reader *, const cpp_hashnode *,
- _cpp_buff **, unsigned *);
-static cpp_context *next_context (cpp_reader *);
-static const cpp_token *padding_token (cpp_reader *, const cpp_token *);
-static const cpp_token *new_string_token (cpp_reader *, uchar *, unsigned int);
-static const cpp_token *stringify_arg (cpp_reader *, const cpp_token **,
- unsigned int);
-static void paste_all_tokens (cpp_reader *, const cpp_token *);
-static bool paste_tokens (cpp_reader *, location_t,
- const cpp_token **, const cpp_token *);
-static void alloc_expanded_arg_mem (cpp_reader *, macro_arg *, size_t);
-static void ensure_expanded_arg_room (cpp_reader *, macro_arg *, size_t, size_t *);
-static void delete_macro_args (_cpp_buff*, unsigned num_args);
-static void set_arg_token (macro_arg *, const cpp_token *,
- location_t, size_t,
- enum macro_arg_token_kind,
- bool);
-static const location_t *get_arg_token_location (const macro_arg *,
- enum macro_arg_token_kind);
-static const cpp_token **arg_token_ptr_at (const macro_arg *,
- size_t,
- enum macro_arg_token_kind,
- location_t **virt_location);
-
-static void macro_arg_token_iter_init (macro_arg_token_iter *, bool,
- enum macro_arg_token_kind,
- const macro_arg *,
- const cpp_token **);
-static const cpp_token *macro_arg_token_iter_get_token
-(const macro_arg_token_iter *it);
-static location_t macro_arg_token_iter_get_location
-(const macro_arg_token_iter *);
-static void macro_arg_token_iter_forward (macro_arg_token_iter *);
-static _cpp_buff *tokens_buff_new (cpp_reader *, size_t,
- location_t **);
-static size_t tokens_buff_count (_cpp_buff *);
-static const cpp_token **tokens_buff_last_token_ptr (_cpp_buff *);
-static inline const cpp_token **tokens_buff_put_token_to (const cpp_token **,
- location_t *,
- const cpp_token *,
- location_t,
- location_t,
- const line_map_macro *,
- unsigned int);
-
-static const cpp_token **tokens_buff_add_token (_cpp_buff *,
- location_t *,
- const cpp_token *,
- location_t,
- location_t,
- const line_map_macro *,
- unsigned int);
-static inline void tokens_buff_remove_last_token (_cpp_buff *);
-static void replace_args (cpp_reader *, cpp_hashnode *, cpp_macro *,
- macro_arg *, location_t);
-static _cpp_buff *funlike_invocation_p (cpp_reader *, cpp_hashnode *,
- _cpp_buff **, unsigned *);
-static cpp_macro *create_iso_definition (cpp_reader *);
-
-/* #define directive parsing and handling. */
-
-static cpp_macro *lex_expansion_token (cpp_reader *, cpp_macro *);
-static bool parse_params (cpp_reader *, unsigned *, bool *);
-static void check_trad_stringification (cpp_reader *, const cpp_macro *,
- const cpp_string *);
-static bool reached_end_of_context (cpp_context *);
-static void consume_next_token_from_context (cpp_reader *pfile,
- const cpp_token **,
- location_t *);
-static const cpp_token* cpp_get_token_1 (cpp_reader *, location_t *);
-
-static cpp_hashnode* macro_of_context (cpp_context *context);
-
-/* Statistical counter tracking the number of macros that got
- expanded. */
-unsigned num_expanded_macros_counter = 0;
-/* Statistical counter tracking the total number tokens resulting
- from macro expansion. */
-unsigned num_macro_tokens_counter = 0;
-
-/* Wrapper around cpp_get_token to skip CPP_PADDING tokens
- and not consume CPP_EOF. */
-static const cpp_token *
-cpp_get_token_no_padding (cpp_reader *pfile)
-{
- for (;;)
- {
- const cpp_token *ret = cpp_peek_token (pfile, 0);
- if (ret->type == CPP_EOF)
- return ret;
- ret = cpp_get_token (pfile);
- if (ret->type != CPP_PADDING)
- return ret;
- }
-}
-
-/* Handle meeting "__has_include" builtin macro. */
-
-static int
-builtin_has_include (cpp_reader *pfile, cpp_hashnode *op, bool has_next)
-{
- int result = 0;
-
- if (!pfile->state.in_directive)
- cpp_error (pfile, CPP_DL_ERROR,
- "\"%s\" used outside of preprocessing directive",
- NODE_NAME (op));
-
- pfile->state.angled_headers = true;
- const cpp_token *token = cpp_get_token_no_padding (pfile);
- bool paren = token->type == CPP_OPEN_PAREN;
- if (paren)
- token = cpp_get_token_no_padding (pfile);
- else
- cpp_error (pfile, CPP_DL_ERROR,
- "missing '(' before \"%s\" operand", NODE_NAME (op));
- pfile->state.angled_headers = false;
-
- bool bracket = token->type != CPP_STRING;
- char *fname = NULL;
- if (token->type == CPP_STRING || token->type == CPP_HEADER_NAME)
- {
- fname = XNEWVEC (char, token->val.str.len - 1);
- memcpy (fname, token->val.str.text + 1, token->val.str.len - 2);
- fname[token->val.str.len - 2] = '\0';
- }
- else if (token->type == CPP_LESS)
- fname = _cpp_bracket_include (pfile);
- else
- cpp_error (pfile, CPP_DL_ERROR,
- "operator \"%s\" requires a header-name", NODE_NAME (op));
-
- if (fname)
- {
- /* Do not do the lookup if we're skipping, that's unnecessary
- IO. */
- if (!pfile->state.skip_eval
- && _cpp_has_header (pfile, fname, bracket,
- has_next ? IT_INCLUDE_NEXT : IT_INCLUDE))
- result = 1;
-
- XDELETEVEC (fname);
- }
-
- if (paren
- && cpp_get_token_no_padding (pfile)->type != CPP_CLOSE_PAREN)
- cpp_error (pfile, CPP_DL_ERROR,
- "missing ')' after \"%s\" operand", NODE_NAME (op));
-
- return result;
-}
-
-/* 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 (cpp_user_macro_p (node))
- {
- cpp_macro *macro = node->value.macro;
-
- if (!macro->used
- && MAIN_FILE_P (linemap_check_ordinary
- (linemap_lookup (pfile->line_table,
- macro->line))))
- cpp_warning_with_line (pfile, CPP_W_UNUSED_MACROS, 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,
- location_t loc)
-{
- 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:
- {
- if (CPP_OPTION (pfile, warn_date_time))
- cpp_warning (pfile, CPP_W_DATE_TIME, "macro \"%s\" might prevent "
- "reproducible builds", NODE_NAME (node));
-
- 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_FILE_NAME:
- case BT_BASE_FILE:
- {
- unsigned int len;
- const char *name;
- uchar *buf;
-
- if (node->value.builtin == BT_FILE
- || node->value.builtin == BT_FILE_NAME)
- {
- name = linemap_get_expansion_filename (pfile->line_table,
- pfile->line_table->highest_line);
- if ((node->value.builtin == BT_FILE_NAME) && name)
- name = lbasename (name);
- }
- else
- {
- name = _cpp_get_file_name (pfile->main_file);
- if (!name)
- abort ();
- }
- if (pfile->cb.remap_filename)
- name = pfile->cb.remap_filename (name);
- 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:
- /* 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.
- See WG14 N1911, WG21 N4220 sec 6.5, and PR 61861. */
- if (CPP_OPTION (pfile, traditional))
- loc = pfile->line_table->highest_line;
- else
- loc = linemap_resolve_location (pfile->line_table, loc,
- LRK_MACRO_EXPANSION_POINT, NULL);
- number = linemap_get_expansion_line (pfile->line_table, 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 (CPP_OPTION (pfile, warn_date_time))
- cpp_warning (pfile, CPP_W_DATE_TIME, "macro \"%s\" might prevent "
- "reproducible builds", NODE_NAME (node));
- 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;
- auto kind = cpp_get_date (pfile, &tt);
-
- if (kind == CPP_time_kind::UNKNOWN)
- {
- cpp_errno (pfile, CPP_DL_WARNING,
- "could not determine date and time");
-
- pfile->date = UC"\"??? ?? ????\"";
- pfile->time = UC"\"??:??:??\"";
- }
- else
- {
- struct tm *tb = (kind == CPP_time_kind::FIXED
- ? gmtime : localtime) (&tt);
-
- 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);
- }
- }
-
- 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_directiveg)
- cpp_error (pfile, CPP_DL_ERROR,
- "__COUNTER__ expanded inside directive with -fdirectives-only");
- number = pfile->counter++;
- break;
-
- case BT_HAS_ATTRIBUTE:
- number = pfile->cb.has_attribute (pfile, false);
- break;
-
- case BT_HAS_STD_ATTRIBUTE:
- number = pfile->cb.has_attribute (pfile, true);
- break;
-
- case BT_HAS_BUILTIN:
- number = pfile->cb.has_builtin (pfile);
- break;
-
- case BT_HAS_INCLUDE:
- case BT_HAS_INCLUDE_NEXT:
- number = builtin_has_include (pfile, node,
- node->value.builtin == BT_HAS_INCLUDE_NEXT);
- break;
-
- case BT_RT_CAT:
- result = evaluate_RT_CAT(pfile);
- 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;
-}
-
-/* Get an idempotent date. Either the cached value, the value from
- source epoch, or failing that, the value from time(2). Use this
- during compilation so that every time stamp is the same. */
-CPP_time_kind
-cpp_get_date (cpp_reader *pfile, time_t *result)
-{
- if (!pfile->time_stamp_kind)
- {
- int kind = 0;
- if (pfile->cb.get_source_date_epoch)
- {
- /* Try reading the fixed epoch. */
- pfile->time_stamp = pfile->cb.get_source_date_epoch (pfile);
- if (pfile->time_stamp != time_t (-1))
- kind = int (CPP_time_kind::FIXED);
- }
-
- if (!kind)
- {
- /* Pedantically time_t (-1) is a legitimate value for
- "number of seconds since the Epoch". It is a silly
- time. */
- errno = 0;
- pfile->time_stamp = time (nullptr);
- /* Annoyingly a library could legally set errno and return a
- valid time! Bad library! */
- if (pfile->time_stamp == time_t (-1) && errno)
- kind = errno;
- else
- kind = int (CPP_time_kind::DYNAMIC);
- }
-
- pfile->time_stamp_kind = kind;
- }
-
- *result = pfile->time_stamp;
- if (pfile->time_stamp_kind >= 0)
- {
- errno = pfile->time_stamp_kind;
- return CPP_time_kind::UNKNOWN;
- }
-
- return CPP_time_kind (pfile->time_stamp_kind);
-}
-
-/* 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. LOC is the location of the expansion
- point of the macro. */
-static int
-builtin_macro (cpp_reader *pfile, cpp_hashnode *node,
- location_t loc, location_t expand_loc)
-{
- 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.
- Similarly, don't interpret _Pragma inside expand_args, we might
- need to stringize it later on. */
- if (pfile->state.in_directive || pfile->state.ignore__Pragma)
- return 0;
-
- return _cpp_do__Pragma (pfile, loc);
- }
-
- buf = _cpp_builtin_macro_text (pfile, node, expand_loc);
- 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_token *token = _cpp_lex_direct (pfile);
- /* We should point to the expansion point of the builtin macro. */
- token->src_loc = loc;
- if (pfile->context->tokens_kind == TOKENS_KIND_EXTENDED)
- {
- /* We are tracking tokens resulting from macro expansion.
- Create a macro line map and generate a virtual location for
- the token resulting from the expansion of the built-in
- macro. */
- location_t *virt_locs = NULL;
- _cpp_buff *token_buf = tokens_buff_new (pfile, 1, &virt_locs);
- const line_map_macro * map =
- linemap_enter_macro (pfile->line_table, node, loc, 1);
- tokens_buff_add_token (token_buf, virt_locs, token,
- pfile->line_table->builtin_location,
- pfile->line_table->builtin_location,
- map, /*macro_token_index=*/0);
- push_extended_tokens_context (pfile, node, token_buf, virt_locs,
- (const cpp_token **)token_buf->base,
- 1);
- }
- else
- _cpp_push_token_context (pfile, NULL, token, 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++;
-
- switch (c)
- {
- case '\n':
- /* Naked LF can appear in raw string literals */
- c = 'n';
- /* FALLTHROUGH */
-
- case '\\':
- case '"':
- *dest++ = '\\';
- /* FALLTHROUGH */
-
- default:
- *dest++ = c;
- }
- }
-
- return dest;
-}
-
-/* Convert a token sequence FIRST to FIRST+COUNT-1 to a single string token
- according to the rules of the ISO C #-operator. */
-static const cpp_token *
-stringify_arg (cpp_reader *pfile, const cpp_token **first, unsigned int count)
-{
- 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 < count; i++)
- {
- const cpp_token *token = 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 || token->type == CPP_UTF8CHAR
- || cpp_userdef_string_p (token->type)
- || cpp_userdef_char_p (token->type));
-
- /* 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. LOCATION is
- the virtual location used for error reporting. */
-static bool
-paste_tokens (cpp_reader *pfile, location_t location,
- 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) + 2;
- buf = (unsigned char *) alloca (len);
- end = lhsend = cpp_spell_token (pfile, *plhs, buf, true);
-
- /* 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, true);
- *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)
- {
- location_t saved_loc = lhs->src_loc;
-
- _cpp_pop_buffer (pfile);
-
- unsigned char *rhsstart = lhsend;
- if ((*plhs)->type == CPP_DIV && rhs->type != CPP_EQ)
- rhsstart++;
-
- /* 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_with_line (pfile, CPP_DL_ERROR, location, 0,
- "pasting \"%.*s\" and \"%.*s\" does not give "
- "a valid preprocessing token",
- (int) (lhsend - buf), buf,
- (int) (end - rhsstart), rhsstart);
- return false;
- }
-
- lhs->flags |= (*plhs)->flags & (PREV_WHITE | PREV_FALLTHROUGH);
- *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 = NULL;
- cpp_context *context = pfile->context;
- location_t virt_loc = 0;
-
- /* We are expanding a macro and we must have been called on a token
- that appears at the left hand side of a ## operator. */
- if (macro_of_context (pfile->context) == NULL
- || (!(lhs->flags & PASTE_LEFT)))
- abort ();
-
- if (context->tokens_kind == TOKENS_KIND_EXTENDED)
- /* The caller must have called consume_next_token_from_context
- right before calling us. That has incremented the pointer to
- the current virtual location. So it now points to the location
- of the token that comes right after *LHS. We want the
- resulting pasted token to have the location of the current
- *LHS, though. */
- virt_loc = context->c.mc->cur_virt_loc[-1];
- else
- /* We are not tracking macro expansion. So the best virtual
- location we can get here is the expansion point of the macro we
- are currently expanding. */
- virt_loc = pfile->invocation_location;
-
- 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->tokens_kind == TOKENS_KIND_DIRECT)
- rhs = FIRST (context).token++;
- else if (context->tokens_kind == TOKENS_KIND_INDIRECT)
- rhs = *FIRST (context).ptoken++;
- else if (context->tokens_kind == TOKENS_KIND_EXTENDED)
- {
- /* So we are in presence of an extended token context, which
- means that each token in this context has a virtual
- location attached to it. So let's not forget to update
- the pointer to the current virtual location of the
- current token when we update the pointer to the current
- token */
-
- rhs = *FIRST (context).ptoken++;
- /* context->c.mc must be non-null, as if we were not in a
- macro context, context->tokens_kind could not be equal to
- TOKENS_KIND_EXTENDED. */
- context->c.mc->cur_virt_loc++;
- }
-
- if (rhs->type == CPP_PADDING)
- {
- if (rhs->flags & PASTE_LEFT)
- abort ();
- }
- if (!paste_tokens (pfile, virt_loc, &lhs, rhs))
- {
- _cpp_backup_tokens (pfile, 1);
- break;
- }
- }
- while (rhs->flags & PASTE_LEFT);
-
- /* Put the resulting token in its own context. */
- if (context->tokens_kind == TOKENS_KIND_EXTENDED)
- {
- location_t *virt_locs = NULL;
- _cpp_buff *token_buf = tokens_buff_new (pfile, 1, &virt_locs);
- tokens_buff_add_token (token_buf, virt_locs, lhs,
- virt_loc, 0, NULL, 0);
- push_extended_tokens_context (pfile, context->c.mc->macro_node,
- token_buf, virt_locs,
- (const cpp_token **)token_buf->base, 1);
- }
- else
- _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)
- {
- /* In C++20 (here the va_opt flag is used), and also as a GNU
- extension, variadic arguments are 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 an empty variadic list had been
- supplied - debug("string", ). */
-
- if (argc + 1 == macro->paramc && macro->variadic)
- {
- if (CPP_PEDANTIC (pfile) && ! macro->syshdr
- && ! CPP_OPTION (pfile, va_opt))
- {
- if (CPP_OPTION (pfile, cplusplus))
- cpp_error (pfile, CPP_DL_PEDWARN,
- "ISO C++11 requires at least one argument "
- "for the \"...\" in a variadic macro");
- else
- cpp_error (pfile, CPP_DL_PEDWARN,
- "ISO C99 requires at least one argument "
- "for the \"...\" in a variadic macro");
- }
- 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);
-
- if (macro->line > RESERVED_LOCATION_COUNT)
- cpp_error_at (pfile, CPP_DL_NOTE, macro->line, "macro \"%s\" defined here",
- NODE_NAME (node));
-
- 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.
-
- What is returned is the buffer that contains the memory allocated
- to hold the macro arguments. NODE is the name of the macro this
- function is dealing with. If NUM_ARGS is non-NULL, *NUM_ARGS is
- set to the actual number of macro arguments allocated in the
- returned buffer. */
-static _cpp_buff *
-collect_args (cpp_reader *pfile, const cpp_hashnode *node,
- _cpp_buff **pragma_buff, unsigned *num_args)
-{
- _cpp_buff *buff, *base_buff;
- cpp_macro *macro;
- macro_arg *args, *arg;
- const cpp_token *token;
- unsigned int argc;
- location_t virt_loc;
- bool track_macro_expansion_p = CPP_OPTION (pfile, track_macro_expansion);
- unsigned num_args_alloced = 0;
-
- macro = node->value.macro;
- if (macro->paramc)
- argc = macro->paramc;
- else
- argc = 1;
-
-#define DEFAULT_NUM_TOKENS_PER_MACRO_ARG 50
-#define ARG_TOKENS_EXTENT 1000
-
- buff = _cpp_get_buff (pfile, argc * (DEFAULT_NUM_TOKENS_PER_MACRO_ARG
- * 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;
- unsigned virt_locs_capacity = DEFAULT_NUM_TOKENS_PER_MACRO_ARG;
- num_args_alloced++;
-
- argc++;
- arg->first = (const cpp_token **) buff->cur;
- if (track_macro_expansion_p)
- {
- virt_locs_capacity = DEFAULT_NUM_TOKENS_PER_MACRO_ARG;
- arg->virt_locs = XNEWVEC (location_t,
- virt_locs_capacity);
- }
-
- 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,
- ARG_TOKENS_EXTENT
- * sizeof (cpp_token *));
- arg->first = (const cpp_token **) buff->cur;
- }
- if (track_macro_expansion_p
- && (ntokens + 2 > virt_locs_capacity))
- {
- virt_locs_capacity += ARG_TOKENS_EXTENT;
- arg->virt_locs = XRESIZEVEC (location_t,
- arg->virt_locs,
- virt_locs_capacity);
- }
-
- token = cpp_get_token_1 (pfile, &virt_loc);
-
- 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 && !(token->flags & PRAGMA_OP))
- {
- cpp_token *newtok = _cpp_temp_token (pfile);
-
- /* CPP_PRAGMA token lives in directive_result, which will
- be overwritten on the next directive. */
- *newtok = *token;
- token = newtok;
- do
- {
- if (*pragma_buff == NULL
- || BUFF_ROOM (*pragma_buff) < sizeof (cpp_token *))
- {
- _cpp_buff *next;
- if (*pragma_buff == NULL)
- *pragma_buff
- = _cpp_get_buff (pfile, 32 * sizeof (cpp_token *));
- else
- {
- next = *pragma_buff;
- *pragma_buff
- = _cpp_get_buff (pfile,
- (BUFF_FRONT (*pragma_buff)
- - (*pragma_buff)->base) * 2);
- (*pragma_buff)->next = next;
- }
- }
- *(const cpp_token **) BUFF_FRONT (*pragma_buff) = token;
- BUFF_FRONT (*pragma_buff) += sizeof (cpp_token *);
- if (token->type == CPP_PRAGMA_EOL)
- break;
- token = cpp_get_token_1 (pfile, &virt_loc);
- }
- while (token->type != CPP_EOF);
-
- /* In deferred pragmas parsing_args and prevent_expansion
- had been changed, reset it. */
- pfile->state.parsing_args = 2;
- pfile->state.prevent_expansion = 1;
-
- if (token->type == CPP_EOF)
- break;
- else
- continue;
- }
- set_arg_token (arg, token, virt_loc,
- ntokens, MACRO_ARG_TOKEN_NORMAL,
- CPP_OPTION (pfile, track_macro_expansion));
- ntokens++;
- }
-
- /* Drop trailing padding. */
- while (ntokens > 0 && arg->first[ntokens - 1]->type == CPP_PADDING)
- ntokens--;
-
- arg->count = ntokens;
- /* Append an EOF to mark end-of-argument. */
- set_arg_token (arg, &pfile->endarg, token->src_loc,
- ntokens, MACRO_ARG_TOKEN_NORMAL,
- CPP_OPTION (pfile, track_macro_expansion));
-
- /* Terminate the argument. Excess arguments loop back and
- overwrite the final legitimate argument, before failing. */
- if (argc <= macro->paramc)
- {
- buff->cur = (unsigned char *) &arg->first[ntokens + 1];
- if (argc != macro->paramc)
- arg++;
- }
- }
- while (token->type != CPP_CLOSE_PAREN && token->type != CPP_EOF);
-
- if (token->type == CPP_EOF)
- {
- /* Unless the EOF is marking the end of an argument, it's a fake
- one from the end of a file that _cpp_clean_line will not have
- advanced past. */
- if (token == &pfile->endarg)
- _cpp_backup_tokens (pfile, 1);
- cpp_error (pfile, CPP_DL_ERROR,
- "unterminated argument list invoking macro \"%s\"",
- NODE_NAME (node));
- }
- else
- {
- /* A single empty argument is counted as no argument. */
- if (argc == 1 && macro->paramc == 0 && args[0].count == 0)
- argc = 0;
- if (_cpp_arguments_ok (pfile, macro, node, argc))
- {
- /* GCC has special semantics for , ## b where b is a varargs
- parameter: we remove the comma if b was omitted entirely.
- If b was merely an empty argument, the comma is retained.
- If the macro takes just one (varargs) parameter, then we
- retain the comma only if we are standards conforming.
-
- If FIRST is NULL replace_args () swallows the comma. */
- if (macro->variadic && (argc < macro->paramc
- || (argc == 1 && args[0].count == 0
- && !CPP_OPTION (pfile, std))))
- args[macro->paramc - 1].first = NULL;
- if (num_args)
- *num_args = num_args_alloced;
- return base_buff;
- }
- }
-
- /* An error occurred. */
- _cpp_release_buff (pfile, base_buff);
- return NULL;
-}
-
-/* Search for an opening parenthesis to the macro of NODE, in such a
- way that, if none is found, we don't lose the information in any
- intervening padding tokens. If we find the parenthesis, collect
- the arguments and return the buffer containing them. PRAGMA_BUFF
- argument is the same as in collect_args. If NUM_ARGS is non-NULL,
- *NUM_ARGS is set to the number of arguments contained in the
- returned buffer. */
-static _cpp_buff *
-funlike_invocation_p (cpp_reader *pfile, cpp_hashnode *node,
- _cpp_buff **pragma_buff, unsigned *num_args)
-{
- const cpp_token *token, *padding = NULL;
-
- for (;;)
- {
- token = cpp_get_token (pfile);
- if (token->type != CPP_PADDING)
- break;
- gcc_assert ((token->flags & PREV_WHITE) == 0);
- if (padding == NULL
- || padding->val.source == NULL
- || (!(padding->val.source->flags & PREV_WHITE)
- && token->val.source == NULL))
- padding = token;
- }
-
- if (token->type == CPP_OPEN_PAREN)
- {
- pfile->state.parsing_args = 2;
- return collect_args (pfile, node, pragma_buff, num_args);
- }
-
- /* Back up. A CPP_EOF is either an EOF from an argument we're
- expanding, or a fake one from lex_direct. We want to backup the
- former, but not the latter. We may have skipped padding, in
- which case backing up more than one token when expanding macros
- is in general too difficult. We re-insert it in its own
- context. */
- if (token->type != CPP_EOF || token == &pfile->endarg)
- {
- _cpp_backup_tokens (pfile, 1);
- if (padding)
- _cpp_push_token_context (pfile, NULL, padding, 1);
- }
-
- return NULL;
-}
-
-/* Return the real number of tokens in the expansion of MACRO. */
-static inline unsigned int
-macro_real_token_count (const cpp_macro *macro)
-{
- if (__builtin_expect (!macro->extra_tokens, true))
- return macro->count;
-
- for (unsigned i = macro->count; i--;)
- if (macro->exp.tokens[i].type != CPP_PASTE)
- return i + 1;
-
- return 0;
-}
-
-/* Push the context of a macro with hash entry NODE onto the context
- stack. If we can successfully expand the macro, we push a context
- containing its yet-to-be-rescanned replacement list and return one.
- If there were additionally any unexpanded deferred #pragma
- directives among macro arguments, push another context containing
- the pragma tokens before the yet-to-be-rescanned replacement list
- and return two. Otherwise, we don't push a context and return
- zero. LOCATION is the location of the expansion point of the
- macro. */
-static int
-enter_macro_context (cpp_reader *pfile, cpp_hashnode *node,
- const cpp_token *result, location_t location)
-{
- /* The presence of a macro invalidates a file's controlling macro. */
- pfile->mi_valid = false;
-
- pfile->state.angled_headers = false;
-
- /* From here to when we push the context for the macro later down
- this function, we need to flag the fact that we are about to
- expand a macro. This is useful when -ftrack-macro-expansion is
- turned off. In that case, we need to record the location of the
- expansion point of the top-most macro we are about to to expand,
- into pfile->invocation_location. But we must not record any such
- location once the process of expanding the macro starts; that is,
- we must not do that recording between now and later down this
- function where set this flag to FALSE. */
- pfile->about_to_expand_macro_p = true;
-
- if (cpp_user_macro_p (node))
- {
- cpp_macro *macro = node->value.macro;
- _cpp_buff *pragma_buff = NULL;
-
- if (macro->fun_like)
- {
- _cpp_buff *buff;
- unsigned num_args = 0;
-
- pfile->state.prevent_expansion++;
- pfile->keep_tokens++;
- pfile->state.parsing_args = 1;
- buff = funlike_invocation_p (pfile, node, &pragma_buff,
- &num_args);
- pfile->state.parsing_args = 0;
- pfile->keep_tokens--;
- pfile->state.prevent_expansion--;
-
- if (buff == NULL)
- {
- if (CPP_WTRADITIONAL (pfile) && ! node->value.macro->syshdr)
- cpp_warning (pfile, CPP_W_TRADITIONAL,
- "function-like macro \"%s\" must be used with arguments in traditional C",
- NODE_NAME (node));
-
- if (pragma_buff)
- _cpp_release_buff (pfile, pragma_buff);
-
- pfile->about_to_expand_macro_p = false;
- return 0;
- }
-
- if (macro->paramc > 0)
- replace_args (pfile, node, macro,
- (macro_arg *) buff->base,
- location);
- /* Free the memory used by the arguments of this
- function-like macro. This memory has been allocated by
- funlike_invocation_p and by replace_args. */
- delete_macro_args (buff, num_args);
- }
-
- /* Disable the macro within its expansion. */
- node->flags |= NODE_DISABLED;
-
- /* Laziness can only affect the expansion tokens of the macro,
- not its fun-likeness or parameters. */
- _cpp_maybe_notify_macro_use (pfile, node, location);
- if (pfile->cb.used)
- pfile->cb.used (pfile, location, node);
-
- macro->used = 1;
-
- if (macro->paramc == 0)
- {
- unsigned tokens_count = macro_real_token_count (macro);
- if (CPP_OPTION (pfile, track_macro_expansion))
- {
- unsigned int i;
- const cpp_token *src = macro->exp.tokens;
- const line_map_macro *map;
- location_t *virt_locs = NULL;
- _cpp_buff *macro_tokens
- = tokens_buff_new (pfile, tokens_count, &virt_locs);
-
- /* Create a macro map to record the locations of the
- tokens that are involved in the expansion. LOCATION
- is the location of the macro expansion point. */
- map = linemap_enter_macro (pfile->line_table,
- node, location, tokens_count);
- for (i = 0; i < tokens_count; ++i)
- {
- tokens_buff_add_token (macro_tokens, virt_locs,
- src, src->src_loc,
- src->src_loc, map, i);
- ++src;
- }
- push_extended_tokens_context (pfile, node,
- macro_tokens,
- virt_locs,
- (const cpp_token **)
- macro_tokens->base,
- tokens_count);
- }
- else
- _cpp_push_token_context (pfile, node, macro->exp.tokens,
- tokens_count);
- num_macro_tokens_counter += tokens_count;
- }
-
- if (pragma_buff)
- {
- if (!pfile->state.in_directive)
- _cpp_push_token_context (pfile, NULL,
- padding_token (pfile, result), 1);
- do
- {
- unsigned tokens_count;
- _cpp_buff *tail = pragma_buff->next;
- pragma_buff->next = NULL;
- tokens_count = ((const cpp_token **) BUFF_FRONT (pragma_buff)
- - (const cpp_token **) pragma_buff->base);
- push_ptoken_context (pfile, NULL, pragma_buff,
- (const cpp_token **) pragma_buff->base,
- tokens_count);
- pragma_buff = tail;
- if (!CPP_OPTION (pfile, track_macro_expansion))
- num_macro_tokens_counter += tokens_count;
-
- }
- while (pragma_buff != NULL);
- pfile->about_to_expand_macro_p = false;
- return 2;
- }
-
- pfile->about_to_expand_macro_p = false;
- return 1;
- }
-
- pfile->about_to_expand_macro_p = false;
- /* Handle built-in macros and the _Pragma operator. */
- {
- location_t expand_loc;
-
- if (/* The top-level macro invocation that triggered the expansion
- we are looking at is with a function-like user macro ... */
- cpp_fun_like_macro_p (pfile->top_most_macro_node)
- /* ... and we are tracking the macro expansion. */
- && CPP_OPTION (pfile, track_macro_expansion))
- /* Then the location of the end of the macro invocation is the
- location of the expansion point of this macro. */
- expand_loc = location;
- else
- /* Otherwise, the location of the end of the macro invocation is
- the location of the expansion point of that top-level macro
- invocation. */
- expand_loc = pfile->invocation_location;
-
- return builtin_macro (pfile, node, location, expand_loc);
- }
-}
-
-/* De-allocate the memory used by BUFF which is an array of instances
- of macro_arg. NUM_ARGS is the number of instances of macro_arg
- present in BUFF. */
-static void
-delete_macro_args (_cpp_buff *buff, unsigned num_args)
-{
- macro_arg *macro_args;
- unsigned i;
-
- if (buff == NULL)
- return;
-
- macro_args = (macro_arg *) buff->base;
-
- /* Walk instances of macro_arg to free their expanded tokens as well
- as their macro_arg::virt_locs members. */
- for (i = 0; i < num_args; ++i)
- {
- if (macro_args[i].expanded)
- {
- free (macro_args[i].expanded);
- macro_args[i].expanded = NULL;
- }
- if (macro_args[i].virt_locs)
- {
- free (macro_args[i].virt_locs);
- macro_args[i].virt_locs = NULL;
- }
- if (macro_args[i].expanded_virt_locs)
- {
- free (macro_args[i].expanded_virt_locs);
- macro_args[i].expanded_virt_locs = NULL;
- }
- }
- _cpp_free_buff (buff);
-}
-
-/* Set the INDEXth token of the macro argument ARG. TOKEN is the token
- to set, LOCATION is its virtual location. "Virtual" location means
- the location that encodes loci across macro expansion. Otherwise
- it has to be TOKEN->SRC_LOC. KIND is the kind of tokens the
- argument ARG is supposed to contain. Note that ARG must be
- tailored so that it has enough room to contain INDEX + 1 numbers of
- tokens, at least. */
-static void
-set_arg_token (macro_arg *arg, const cpp_token *token,
- location_t location, size_t index,
- enum macro_arg_token_kind kind,
- bool track_macro_exp_p)
-{
- const cpp_token **token_ptr;
- location_t *loc = NULL;
-
- token_ptr =
- arg_token_ptr_at (arg, index, kind,
- track_macro_exp_p ? &loc : NULL);
- *token_ptr = token;
-
- if (loc != NULL)
- {
- /* We can't set the location of a stringified argument
- token and we can't set any location if we aren't tracking
- macro expansion locations. */
- gcc_checking_assert (kind != MACRO_ARG_TOKEN_STRINGIFIED
- && track_macro_exp_p);
- *loc = location;
- }
-}
-
-/* Get the pointer to the location of the argument token of the
- function-like macro argument ARG. This function must be called
- only when we -ftrack-macro-expansion is on. */
-static const location_t *
-get_arg_token_location (const macro_arg *arg,
- enum macro_arg_token_kind kind)
-{
- const location_t *loc = NULL;
- const cpp_token **token_ptr =
- arg_token_ptr_at (arg, 0, kind, (location_t **) &loc);
-
- if (token_ptr == NULL)
- return NULL;
-
- return loc;
-}
-
-/* Return the pointer to the INDEXth token of the macro argument ARG.
- KIND specifies the kind of token the macro argument ARG contains.
- If VIRT_LOCATION is non NULL, *VIRT_LOCATION is set to the address
- of the virtual location of the returned token if the
- -ftrack-macro-expansion flag is on; otherwise, it's set to the
- spelling location of the returned token. */
-static const cpp_token **
-arg_token_ptr_at (const macro_arg *arg, size_t index,
- enum macro_arg_token_kind kind,
- location_t **virt_location)
-{
- const cpp_token **tokens_ptr = NULL;
-
- switch (kind)
- {
- case MACRO_ARG_TOKEN_NORMAL:
- tokens_ptr = arg->first;
- break;
- case MACRO_ARG_TOKEN_STRINGIFIED:
- tokens_ptr = (const cpp_token **) &arg->stringified;
- break;
- case MACRO_ARG_TOKEN_EXPANDED:
- tokens_ptr = arg->expanded;
- break;
- }
-
- if (tokens_ptr == NULL)
- /* This can happen for e.g, an empty token argument to a
- funtion-like macro. */
- return tokens_ptr;
-
- if (virt_location)
- {
- if (kind == MACRO_ARG_TOKEN_NORMAL)
- *virt_location = &arg->virt_locs[index];
- else if (kind == MACRO_ARG_TOKEN_EXPANDED)
- *virt_location = &arg->expanded_virt_locs[index];
- else if (kind == MACRO_ARG_TOKEN_STRINGIFIED)
- *virt_location =
- (location_t *) &tokens_ptr[index]->src_loc;
- }
- return &tokens_ptr[index];
-}
-
-/* Initialize an iterator so that it iterates over the tokens of a
- function-like macro argument. KIND is the kind of tokens we want
- ITER to iterate over. TOKEN_PTR points the first token ITER will
- iterate over. */
-static void
-macro_arg_token_iter_init (macro_arg_token_iter *iter,
- bool track_macro_exp_p,
- enum macro_arg_token_kind kind,
- const macro_arg *arg,
- const cpp_token **token_ptr)
-{
- iter->track_macro_exp_p = track_macro_exp_p;
- iter->kind = kind;
- iter->token_ptr = token_ptr;
- /* Unconditionally initialize this so that the compiler doesn't warn
- about iter->location_ptr being possibly uninitialized later after
- this code has been inlined somewhere. */
- iter->location_ptr = NULL;
- if (track_macro_exp_p)
- iter->location_ptr = get_arg_token_location (arg, kind);
-#if CHECKING_P
- iter->num_forwards = 0;
- if (track_macro_exp_p
- && token_ptr != NULL
- && iter->location_ptr == NULL)
- abort ();
-#endif
-}
-
-/* Move the iterator one token forward. Note that if IT was
- initialized on an argument that has a stringified token, moving it
- forward doesn't make sense as a stringified token is essentially one
- string. */
-static void
-macro_arg_token_iter_forward (macro_arg_token_iter *it)
-{
- switch (it->kind)
- {
- case MACRO_ARG_TOKEN_NORMAL:
- case MACRO_ARG_TOKEN_EXPANDED:
- it->token_ptr++;
- if (it->track_macro_exp_p)
- it->location_ptr++;
- break;
- case MACRO_ARG_TOKEN_STRINGIFIED:
-#if CHECKING_P
- if (it->num_forwards > 0)
- abort ();
-#endif
- break;
- }
-
-#if CHECKING_P
- it->num_forwards++;
-#endif
-}
-
-/* Return the token pointed to by the iterator. */
-static const cpp_token *
-macro_arg_token_iter_get_token (const macro_arg_token_iter *it)
-{
-#if CHECKING_P
- if (it->kind == MACRO_ARG_TOKEN_STRINGIFIED
- && it->num_forwards > 0)
- abort ();
-#endif
- if (it->token_ptr == NULL)
- return NULL;
- return *it->token_ptr;
-}
-
-/* Return the location of the token pointed to by the iterator.*/
-static location_t
-macro_arg_token_iter_get_location (const macro_arg_token_iter *it)
-{
-#if CHECKING_P
- if (it->kind == MACRO_ARG_TOKEN_STRINGIFIED
- && it->num_forwards > 0)
- abort ();
-#endif
- if (it->track_macro_exp_p)
- return *it->location_ptr;
- else
- return (*it->token_ptr)->src_loc;
-}
-
-/* Return the index of a token [resulting from macro expansion] inside
- the total list of tokens resulting from a given macro
- expansion. The index can be different depending on whether if we
- want each tokens resulting from function-like macro arguments
- expansion to have a different location or not.
-
- E.g, consider this function-like macro:
-
- #define M(x) x - 3
-
- Then consider us "calling" it (and thus expanding it) like:
-
- M(1+4)
-
- It will be expanded into:
-
- 1+4-3
-
- Let's consider the case of the token '4'.
-
- Its index can be 2 (it's the third token of the set of tokens
- resulting from the expansion) or it can be 0 if we consider that
- all tokens resulting from the expansion of the argument "1+2" have
- the same index, which is 0. In this later case, the index of token
- '-' would then be 1 and the index of token '3' would be 2.
-
- The later case is useful to use less memory e.g, for the case of
- the user using the option -ftrack-macro-expansion=1.
-
- ABSOLUTE_TOKEN_INDEX is the index of the macro argument token we
- are interested in. CUR_REPLACEMENT_TOKEN is the token of the macro
- parameter (inside the macro replacement list) that corresponds to
- the macro argument for which ABSOLUTE_TOKEN_INDEX is a token index
- of.
-
- If we refer to the example above, for the '4' argument token,
- ABSOLUTE_TOKEN_INDEX would be set to 2, and CUR_REPLACEMENT_TOKEN
- would be set to the token 'x', in the replacement list "x - 3" of
- macro M.
-
- This is a subroutine of replace_args. */
-inline static unsigned
-expanded_token_index (cpp_reader *pfile, cpp_macro *macro,
- const cpp_token *cur_replacement_token,
- unsigned absolute_token_index)
-{
- if (CPP_OPTION (pfile, track_macro_expansion) > 1)
- return absolute_token_index;
- return cur_replacement_token - macro->exp.tokens;
-}
-
-/* Copy whether PASTE_LEFT is set from SRC to *PASTE_FLAG. */
-
-static void
-copy_paste_flag (cpp_reader *pfile, const cpp_token **paste_flag,
- const cpp_token *src)
-{
- cpp_token *token = _cpp_temp_token (pfile);
- token->type = (*paste_flag)->type;
- token->val = (*paste_flag)->val;
- if (src->flags & PASTE_LEFT)
- token->flags = (*paste_flag)->flags | PASTE_LEFT;
- else
- token->flags = (*paste_flag)->flags & ~PASTE_LEFT;
- *paste_flag = token;
-}
-
-/* True IFF the last token emitted into BUFF (if any) is PTR. */
-
-static bool
-last_token_is (_cpp_buff *buff, const cpp_token **ptr)
-{
- return (ptr && tokens_buff_last_token_ptr (buff) == ptr);
-}
-
-/* Replace the parameters in a function-like macro of NODE with the
- actual ARGS, and place the result in a newly pushed token context.
- Expand each argument before replacing, unless it is operated upon
- by the # or ## operators. EXPANSION_POINT_LOC is the location of
- the expansion point of the macro. E.g, the location of the
- function-like macro invocation. */
-static void
-replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro,
- macro_arg *args, location_t expansion_point_loc)
-{
- unsigned int i, total;
- const cpp_token *src, *limit;
- const cpp_token **first = NULL;
- macro_arg *arg;
- _cpp_buff *buff = NULL;
- location_t *virt_locs = NULL;
- unsigned int exp_count;
- const line_map_macro *map = NULL;
- int track_macro_exp;
-
- /* First, fully macro-expand arguments, calculating the number of
- tokens in the final expansion as we go. The ordering of the if
- statements below is subtle; we must handle stringification before
- pasting. */
-
- /* EXP_COUNT is the number of tokens in the macro replacement
- list. TOTAL is the number of tokens /after/ macro parameters
- have been replaced by their arguments. */
- exp_count = macro_real_token_count (macro);
- total = exp_count;
- limit = macro->exp.tokens + exp_count;
-
- for (src = macro->exp.tokens; src < limit; src++)
- if (src->type == CPP_MACRO_ARG)
- {
- /* Leading and trailing padding tokens. */
- total += 2;
- /* Account for leading and padding tokens in exp_count too.
- This is going to be important later down this function,
- when we want to handle the case of (track_macro_exp <
- 2). */
- exp_count += 2;
-
- /* We have an argument. If it is not being stringified or
- pasted it is macro-replaced before insertion. */
- arg = &args[src->val.macro_arg.arg_no - 1];
-
- if (src->flags & STRINGIFY_ARG)
- {
- if (!arg->stringified)
- arg->stringified = stringify_arg (pfile, arg->first, arg->count);
- }
- else if ((src->flags & PASTE_LEFT)
- || (src != macro->exp.tokens && (src[-1].flags & PASTE_LEFT)))
- total += arg->count - 1;
- else
- {
- if (!arg->expanded)
- expand_arg (pfile, arg);
- total += arg->expanded_count - 1;
- }
- }
-
- /* When the compiler is called with the -ftrack-macro-expansion
- flag, we need to keep track of the location of each token that
- results from macro expansion.
-
- A token resulting from macro expansion is not a new token. It is
- simply the same token as the token coming from the macro
- definition. The new things that are allocated are the buffer
- that holds the tokens resulting from macro expansion and a new
- location that records many things like the locus of the expansion
- point as well as the original locus inside the definition of the
- macro. This location is called a virtual location.
-
- So the buffer BUFF holds a set of cpp_token*, and the buffer
- VIRT_LOCS holds the virtual locations of the tokens held by BUFF.
-
- Both of these two buffers are going to be hung off of the macro
- context, when the latter is pushed. The memory allocated to
- store the tokens and their locations is going to be freed once
- the context of macro expansion is popped.
-
- As far as tokens are concerned, the memory overhead of
- -ftrack-macro-expansion is proportional to the number of
- macros that get expanded multiplied by sizeof (location_t).
- The good news is that extra memory gets freed when the macro
- context is freed, i.e shortly after the macro got expanded. */
-
- /* Is the -ftrack-macro-expansion flag in effect? */
- track_macro_exp = CPP_OPTION (pfile, track_macro_expansion);
-
- /* Now allocate memory space for tokens and locations resulting from
- the macro expansion, copy the tokens and replace the arguments.
- This memory must be freed when the context of the macro MACRO is
- popped. */
- buff = tokens_buff_new (pfile, total, track_macro_exp ? &virt_locs : NULL);
-
- first = (const cpp_token **) buff->base;
-
- /* Create a macro map to record the locations of the tokens that are
- involved in the expansion. Note that the expansion point is set
- to the location of the closing parenthesis. Otherwise, the
- subsequent map created for the first token that comes after the
- macro map might have a wrong line number. That would lead to
- tokens with wrong line numbers after the macro expansion. This
- adds up to the memory overhead of the -ftrack-macro-expansion
- flag; for every macro that is expanded, a "macro map" is
- created. */
- if (track_macro_exp)
- {
- int num_macro_tokens = total;
- if (track_macro_exp < 2)
- /* Then the number of macro tokens won't take in account the
- fact that function-like macro arguments can expand to
- multiple tokens. This is to save memory at the expense of
- accuracy.
-
- Suppose we have #define SQUARE(A) A * A
-
- And then we do SQUARE(2+3)
-
- Then the tokens 2, +, 3, will have the same location,
- saying they come from the expansion of the argument A. */
- num_macro_tokens = exp_count;
- map = linemap_enter_macro (pfile->line_table, node,
- expansion_point_loc,
- num_macro_tokens);
- }
- i = 0;
- vaopt_state vaopt_tracker (pfile, macro->variadic, &args[macro->paramc - 1]);
- const cpp_token **vaopt_start = NULL;
- for (src = macro->exp.tokens; src < limit; src++)
- {
- unsigned int arg_tokens_count;
- macro_arg_token_iter from;
- const cpp_token **paste_flag = NULL;
- const cpp_token **tmp_token_ptr;
-
- /* __VA_OPT__ handling. */
- vaopt_state::update_type vostate = vaopt_tracker.update (src);
- if (__builtin_expect (vostate != vaopt_state::INCLUDE, false))
- {
- if (vostate == vaopt_state::BEGIN)
- {
- /* Padding on the left of __VA_OPT__ (unless RHS of ##). */
- if (src != macro->exp.tokens && !(src[-1].flags & PASTE_LEFT))
- {
- const cpp_token *t = padding_token (pfile, src);
- unsigned index = expanded_token_index (pfile, macro, src, i);
- /* Allocate a virtual location for the padding token and
- append the token and its location to BUFF and
- VIRT_LOCS. */
- tokens_buff_add_token (buff, virt_locs, t,
- t->src_loc, t->src_loc,
- map, index);
- }
- vaopt_start = tokens_buff_last_token_ptr (buff);
- }
- else if (vostate == vaopt_state::END)
- {
- const cpp_token **start = vaopt_start;
- vaopt_start = NULL;
-
- paste_flag = tokens_buff_last_token_ptr (buff);
-
- if (vaopt_tracker.stringify ())
- {
- unsigned int count
- = start ? paste_flag - start : tokens_buff_count (buff);
- const cpp_token **first
- = start ? start + 1
- : (const cpp_token **) (buff->base);
- unsigned int i, j;
-
- /* Paste any tokens that need to be pasted before calling
- stringify_arg, because stringify_arg uses pfile->u_buff
- which paste_tokens can use as well. */
- for (i = 0, j = 0; i < count; i++, j++)
- {
- const cpp_token *token = first[i];
-
- if (token->flags & PASTE_LEFT)
- {
- location_t virt_loc = pfile->invocation_location;
- const cpp_token *rhs;
- do
- {
- if (i == count)
- abort ();
- rhs = first[++i];
- if (!paste_tokens (pfile, virt_loc, &token, rhs))
- {
- --i;
- break;
- }
- }
- while (rhs->flags & PASTE_LEFT);
- }
-
- first[j] = token;
- }
- if (j != i)
- {
- while (i-- != j)
- tokens_buff_remove_last_token (buff);
- count = j;
- }
-
- const cpp_token *t = stringify_arg (pfile, first, count);
- while (count--)
- tokens_buff_remove_last_token (buff);
- if (src->flags & PASTE_LEFT)
- copy_paste_flag (pfile, &t, src);
- tokens_buff_add_token (buff, virt_locs,
- t, t->src_loc, t->src_loc,
- NULL, 0);
- continue;
- }
- if (start && paste_flag == start && (*start)->flags & PASTE_LEFT)
- /* If __VA_OPT__ expands to nothing (either because __VA_ARGS__
- is empty or because it is __VA_OPT__() ), drop PASTE_LEFT
- flag from previous token. */
- copy_paste_flag (pfile, start, &pfile->avoid_paste);
- if (src->flags & PASTE_LEFT)
- {
- /* Don't avoid paste after all. */
- while (paste_flag && paste_flag != start
- && *paste_flag == &pfile->avoid_paste)
- {
- tokens_buff_remove_last_token (buff);
- paste_flag = tokens_buff_last_token_ptr (buff);
- }
-
- /* With a non-empty __VA_OPT__ on the LHS of ##, the last
- token should be flagged PASTE_LEFT. */
- if (paste_flag && (*paste_flag)->type != CPP_PADDING)
- copy_paste_flag (pfile, paste_flag, src);
- }
- else
- {
- /* Otherwise, avoid paste on RHS, __VA_OPT__(c)d or
- __VA_OPT__(c)__VA_OPT__(d). */
- const cpp_token *t = &pfile->avoid_paste;
- tokens_buff_add_token (buff, virt_locs,
- t, t->src_loc, t->src_loc,
- NULL, 0);
- }
- }
- continue;
- }
-
- if (src->type != CPP_MACRO_ARG)
- {
- /* Allocate a virtual location for token SRC, and add that
- token and its virtual location into the buffers BUFF and
- VIRT_LOCS. */
- unsigned index = expanded_token_index (pfile, macro, src, i);
- tokens_buff_add_token (buff, virt_locs, src,
- src->src_loc, src->src_loc,
- map, index);
- i += 1;
- continue;
- }
-
- paste_flag = 0;
- arg = &args[src->val.macro_arg.arg_no - 1];
- /* SRC is a macro parameter that we need to replace with its
- corresponding argument. So at some point we'll need to
- iterate over the tokens of the macro argument and copy them
- into the "place" now holding the correspondig macro
- parameter. We are going to use the iterator type
- macro_argo_token_iter to handle that iterating. The 'if'
- below is to initialize the iterator depending on the type of
- tokens the macro argument has. It also does some adjustment
- related to padding tokens and some pasting corner cases. */
- if (src->flags & STRINGIFY_ARG)
- {
- arg_tokens_count = 1;
- macro_arg_token_iter_init (&from,
- CPP_OPTION (pfile,
- track_macro_expansion),
- MACRO_ARG_TOKEN_STRINGIFIED,
- arg, &arg->stringified);
- }
- else if (src->flags & PASTE_LEFT)
- {
- arg_tokens_count = arg->count;
- macro_arg_token_iter_init (&from,
- CPP_OPTION (pfile,
- track_macro_expansion),
- MACRO_ARG_TOKEN_NORMAL,
- arg, arg->first);
- }
- else if (src != macro->exp.tokens && (src[-1].flags & PASTE_LEFT))
- {
- int num_toks;
- arg_tokens_count = arg->count;
- macro_arg_token_iter_init (&from,
- CPP_OPTION (pfile,
- track_macro_expansion),
- MACRO_ARG_TOKEN_NORMAL,
- arg, arg->first);
-
- num_toks = tokens_buff_count (buff);
-
- if (num_toks != 0)
- {
- /* So the current parameter token is pasted to the previous
- token in the replacement list. Let's look at what
- we have as previous and current arguments. */
-
- /* This is the previous argument's token ... */
- tmp_token_ptr = tokens_buff_last_token_ptr (buff);
-
- if ((*tmp_token_ptr)->type == CPP_COMMA
- && macro->variadic
- && src->val.macro_arg.arg_no == macro->paramc)
- {
- /* ... which is a comma; and the current parameter
- is the last parameter of a variadic function-like
- macro. If the argument to the current last
- parameter is NULL, then swallow the comma,
- otherwise drop the paste flag. */
- if (macro_arg_token_iter_get_token (&from) == NULL)
- tokens_buff_remove_last_token (buff);
- else
- paste_flag = tmp_token_ptr;
- }
- /* Remove the paste flag if the RHS is a placemarker. */
- else if (arg_tokens_count == 0)
- paste_flag = tmp_token_ptr;
- }
- }
- else
- {
- arg_tokens_count = arg->expanded_count;
- macro_arg_token_iter_init (&from,
- CPP_OPTION (pfile,
- track_macro_expansion),
- MACRO_ARG_TOKEN_EXPANDED,
- arg, arg->expanded);
-
- if (last_token_is (buff, vaopt_start))
- {
- /* We're expanding an arg at the beginning of __VA_OPT__.
- Skip padding. */
- while (arg_tokens_count)
- {
- const cpp_token *t = macro_arg_token_iter_get_token (&from);
- if (t->type != CPP_PADDING)
- break;
- macro_arg_token_iter_forward (&from);
- --arg_tokens_count;
- }
- }
- }
-
- /* Padding on the left of an argument (unless RHS of ##). */
- if ((!pfile->state.in_directive || pfile->state.directive_wants_padding)
- && src != macro->exp.tokens
- && !(src[-1].flags & PASTE_LEFT)
- && !last_token_is (buff, vaopt_start))
- {
- const cpp_token *t = padding_token (pfile, src);
- unsigned index = expanded_token_index (pfile, macro, src, i);
- /* Allocate a virtual location for the padding token and
- append the token and its location to BUFF and
- VIRT_LOCS. */
- tokens_buff_add_token (buff, virt_locs, t,
- t->src_loc, t->src_loc,
- map, index);
- }
-
- if (arg_tokens_count)
- {
- /* So now we've got the number of tokens that make up the
- argument that is going to replace the current parameter
- in the macro's replacement list. */
- unsigned int j;
- for (j = 0; j < arg_tokens_count; ++j)
- {
- /* So if track_macro_exp is < 2, the user wants to
- save extra memory while tracking macro expansion
- locations. So in that case here is what we do:
-
- Suppose we have #define SQUARE(A) A * A
-
- And then we do SQUARE(2+3)
-
- Then the tokens 2, +, 3, will have the same location,
- saying they come from the expansion of the argument
- A.
-
- So that means we are going to ignore the COUNT tokens
- resulting from the expansion of the current macro
- argument. In other words all the ARG_TOKENS_COUNT tokens
- resulting from the expansion of the macro argument will
- have the index I. Normally, each of those tokens should
- have index I+J. */
- unsigned token_index = i;
- unsigned index;
- if (track_macro_exp > 1)
- token_index += j;
-
- index = expanded_token_index (pfile, macro, src, token_index);
- const cpp_token *tok = macro_arg_token_iter_get_token (&from);
- tokens_buff_add_token (buff, virt_locs, tok,
- macro_arg_token_iter_get_location (&from),
- src->src_loc, map, index);
- macro_arg_token_iter_forward (&from);
- }
-
- /* With a non-empty argument on the LHS of ##, the last
- token should be flagged PASTE_LEFT. */
- if (src->flags & PASTE_LEFT)
- paste_flag
- = (const cpp_token **) tokens_buff_last_token_ptr (buff);
- }
- else if (CPP_PEDANTIC (pfile) && ! CPP_OPTION (pfile, c99)
- && ! macro->syshdr && ! _cpp_in_system_header (pfile))
- {
- if (CPP_OPTION (pfile, cplusplus))
- cpp_pedwarning (pfile, CPP_W_PEDANTIC,
- "invoking macro %s argument %d: "
- "empty macro arguments are undefined"
- " in ISO C++98",
- NODE_NAME (node), src->val.macro_arg.arg_no);
- else if (CPP_OPTION (pfile, cpp_warn_c90_c99_compat))
- cpp_pedwarning (pfile,
- CPP_OPTION (pfile, cpp_warn_c90_c99_compat) > 0
- ? CPP_W_C90_C99_COMPAT : CPP_W_PEDANTIC,
- "invoking macro %s argument %d: "
- "empty macro arguments are undefined"
- " in ISO C90",
- NODE_NAME (node), src->val.macro_arg.arg_no);
- }
- else if (CPP_OPTION (pfile, cpp_warn_c90_c99_compat) > 0
- && ! CPP_OPTION (pfile, cplusplus)
- && ! macro->syshdr && ! _cpp_in_system_header (pfile))
- cpp_warning (pfile, CPP_W_C90_C99_COMPAT,
- "invoking macro %s argument %d: "
- "empty macro arguments are undefined"
- " in ISO C90",
- NODE_NAME (node), src->val.macro_arg.arg_no);
-
- /* Avoid paste on RHS (even case count == 0). */
- if (!pfile->state.in_directive && !(src->flags & PASTE_LEFT))
- {
- const cpp_token *t = &pfile->avoid_paste;
- tokens_buff_add_token (buff, virt_locs,
- t, t->src_loc, t->src_loc,
- NULL, 0);
- }
-
- /* Add a new paste flag, or remove an unwanted one. */
- if (paste_flag)
- copy_paste_flag (pfile, paste_flag, src);
-
- i += arg_tokens_count;
- }
-
- if (track_macro_exp)
- push_extended_tokens_context (pfile, node, buff, virt_locs, first,
- tokens_buff_count (buff));
- else
- push_ptoken_context (pfile, node, buff, first,
- tokens_buff_count (buff));
-
- num_macro_tokens_counter += tokens_buff_count (buff);
-}
-
-/* Return a special padding token, with padding inherited from SOURCE. */
-static const cpp_token *
-padding_token (cpp_reader *pfile, const cpp_token *source)
-{
- cpp_token *result = _cpp_temp_token (pfile);
-
- result->type = CPP_PADDING;
-
- /* Data in GCed data structures cannot be made const so far, so we
- need a cast here. */
- result->val.source = (cpp_token *) source;
- result->flags = 0;
- return result;
-}
-
-/* Get a new uninitialized context. Create a new one if we cannot
- re-use an old one. */
-static cpp_context *
-next_context (cpp_reader *pfile)
-{
- cpp_context *result = pfile->context->next;
-
- if (result == 0)
- {
- result = XNEW (cpp_context);
- memset (result, 0, sizeof (cpp_context));
- result->prev = pfile->context;
- result->next = 0;
- pfile->context->next = result;
- }
-
- pfile->context = result;
- return result;
-}
-
-/* Push a list of pointers to tokens. */
-static void
-push_ptoken_context (cpp_reader *pfile, cpp_hashnode *macro, _cpp_buff *buff,
- const cpp_token **first, unsigned int count)
-{
- cpp_context *context = next_context (pfile);
-
- context->tokens_kind = TOKENS_KIND_INDIRECT;
- context->c.macro = macro;
- context->buff = buff;
- FIRST (context).ptoken = first;
- LAST (context).ptoken = first + count;
-}
-
-/* Push a list of tokens.
-
- A NULL macro means that we should continue the current macro
- expansion, in essence. That means that if we are currently in a
- macro expansion context, we'll make the new pfile->context refer to
- the current macro. */
-void
-_cpp_push_token_context (cpp_reader *pfile, cpp_hashnode *macro,
- const cpp_token *first, unsigned int count)
-{
- cpp_context *context;
-
- if (macro == NULL)
- macro = macro_of_context (pfile->context);
-
- context = next_context (pfile);
- context->tokens_kind = TOKENS_KIND_DIRECT;
- context->c.macro = macro;
- context->buff = NULL;
- FIRST (context).token = first;
- LAST (context).token = first + count;
-}
-
-/* Build a context containing a list of tokens as well as their
- virtual locations and push it. TOKENS_BUFF is the buffer that
- contains the tokens pointed to by FIRST. If TOKENS_BUFF is
- non-NULL, it means that the context owns it, meaning that
- _cpp_pop_context will free it as well as VIRT_LOCS_BUFF that
- contains the virtual locations.
-
- A NULL macro means that we should continue the current macro
- expansion, in essence. That means that if we are currently in a
- macro expansion context, we'll make the new pfile->context refer to
- the current macro. */
-static void
-push_extended_tokens_context (cpp_reader *pfile,
- cpp_hashnode *macro,
- _cpp_buff *token_buff,
- location_t *virt_locs,
- const cpp_token **first,
- unsigned int count)
-{
- cpp_context *context;
- macro_context *m;
-
- if (macro == NULL)
- macro = macro_of_context (pfile->context);
-
- context = next_context (pfile);
- context->tokens_kind = TOKENS_KIND_EXTENDED;
- context->buff = token_buff;
-
- m = XNEW (macro_context);
- m->macro_node = macro;
- m->virt_locs = virt_locs;
- m->cur_virt_loc = virt_locs;
- context->c.mc = m;
- FIRST (context).ptoken = first;
- LAST (context).ptoken = first + count;
-}
-
-/* Push a traditional macro's replacement text. */
-void
-_cpp_push_text_context (cpp_reader *pfile, cpp_hashnode *macro,
- const uchar *start, size_t len)
-{
- cpp_context *context = next_context (pfile);
-
- context->tokens_kind = TOKENS_KIND_DIRECT;
- context->c.macro = macro;
- context->buff = NULL;
- CUR (context) = start;
- RLIMIT (context) = start + len;
- macro->flags |= NODE_DISABLED;
-}
-
-/* Creates a buffer that holds tokens a.k.a "token buffer", usually
- for the purpose of storing them on a cpp_context. If VIRT_LOCS is
- non-null (which means that -ftrack-macro-expansion is on),
- *VIRT_LOCS is set to a newly allocated buffer that is supposed to
- hold the virtual locations of the tokens resulting from macro
- expansion. */
-static _cpp_buff*
-tokens_buff_new (cpp_reader *pfile, size_t len,
- location_t **virt_locs)
-{
- size_t tokens_size = len * sizeof (cpp_token *);
- size_t locs_size = len * sizeof (location_t);
-
- if (virt_locs != NULL)
- *virt_locs = XNEWVEC (location_t, locs_size);
- return _cpp_get_buff (pfile, tokens_size);
-}
-
-/* Returns the number of tokens contained in a token buffer. The
- buffer holds a set of cpp_token*. */
-static size_t
-tokens_buff_count (_cpp_buff *buff)
-{
- return (BUFF_FRONT (buff) - buff->base) / sizeof (cpp_token *);
-}
-
-/* Return a pointer to the last token contained in the token buffer
- BUFF. */
-static const cpp_token **
-tokens_buff_last_token_ptr (_cpp_buff *buff)
-{
- if (BUFF_FRONT (buff) == buff->base)
- return NULL;
- return &((const cpp_token **) BUFF_FRONT (buff))[-1];
-}
-
-/* Remove the last token contained in the token buffer TOKENS_BUFF.
- If VIRT_LOCS_BUFF is non-NULL, it should point at the buffer
- containing the virtual locations of the tokens in TOKENS_BUFF; in
- which case the function updates that buffer as well. */
-static inline void
-tokens_buff_remove_last_token (_cpp_buff *tokens_buff)
-
-{
- if (BUFF_FRONT (tokens_buff) > tokens_buff->base)
- BUFF_FRONT (tokens_buff) =
- (unsigned char *) &((cpp_token **) BUFF_FRONT (tokens_buff))[-1];
-}
-
-/* Insert a token into the token buffer at the position pointed to by
- DEST. Note that the buffer is not enlarged so the previous token
- that was at *DEST is overwritten. VIRT_LOC_DEST, if non-null,
- means -ftrack-macro-expansion is effect; it then points to where to
- insert the virtual location of TOKEN. TOKEN is the token to
- insert. VIRT_LOC is the virtual location of the token, i.e, the
- location possibly encoding its locus across macro expansion. If
- TOKEN is an argument of a function-like macro (inside a macro
- replacement list), PARM_DEF_LOC is the spelling location of the
- macro parameter that TOKEN is replacing, in the replacement list of
- the macro. If TOKEN is not an argument of a function-like macro or
- if it doesn't come from a macro expansion, then VIRT_LOC can just
- be set to the same value as PARM_DEF_LOC. If MAP is non null, it
- means TOKEN comes from a macro expansion and MAP is the macro map
- associated to the macro. MACRO_TOKEN_INDEX points to the index of
- the token in the macro map; it is not considered if MAP is NULL.
-
- Upon successful completion this function returns the a pointer to
- the position of the token coming right after the insertion
- point. */
-static inline const cpp_token **
-tokens_buff_put_token_to (const cpp_token **dest,
- location_t *virt_loc_dest,
- const cpp_token *token,
- location_t virt_loc,
- location_t parm_def_loc,
- const line_map_macro *map,
- unsigned int macro_token_index)
-{
- location_t macro_loc = virt_loc;
- const cpp_token **result;
-
- if (virt_loc_dest)
- {
- /* -ftrack-macro-expansion is on. */
- if (map)
- macro_loc = linemap_add_macro_token (map, macro_token_index,
- virt_loc, parm_def_loc);
- *virt_loc_dest = macro_loc;
- }
- *dest = token;
- result = &dest[1];
-
- return result;
-}
-
-/* Adds a token at the end of the tokens contained in BUFFER. Note
- that this function doesn't enlarge BUFFER when the number of tokens
- reaches BUFFER's size; it aborts in that situation.
-
- TOKEN is the token to append. VIRT_LOC is the virtual location of
- the token, i.e, the location possibly encoding its locus across
- macro expansion. If TOKEN is an argument of a function-like macro
- (inside a macro replacement list), PARM_DEF_LOC is the location of
- the macro parameter that TOKEN is replacing. If TOKEN doesn't come
- from a macro expansion, then VIRT_LOC can just be set to the same
- value as PARM_DEF_LOC. If MAP is non null, it means TOKEN comes
- from a macro expansion and MAP is the macro map associated to the
- macro. MACRO_TOKEN_INDEX points to the index of the token in the
- macro map; It is not considered if MAP is NULL. If VIRT_LOCS is
- non-null, it means -ftrack-macro-expansion is on; in which case
- this function adds the virtual location DEF_LOC to the VIRT_LOCS
- array, at the same index as the one of TOKEN in BUFFER. Upon
- successful completion this function returns the a pointer to the
- position of the token coming right after the insertion point. */
-static const cpp_token **
-tokens_buff_add_token (_cpp_buff *buffer,
- location_t *virt_locs,
- const cpp_token *token,
- location_t virt_loc,
- location_t parm_def_loc,
- const line_map_macro *map,
- unsigned int macro_token_index)
-{
- const cpp_token **result;
- location_t *virt_loc_dest = NULL;
- unsigned token_index =
- (BUFF_FRONT (buffer) - buffer->base) / sizeof (cpp_token *);
-
- /* Abort if we pass the end the buffer. */
- if (BUFF_FRONT (buffer) > BUFF_LIMIT (buffer))
- abort ();
-
- if (virt_locs != NULL)
- virt_loc_dest = &virt_locs[token_index];
-
- result =
- tokens_buff_put_token_to ((const cpp_token **) BUFF_FRONT (buffer),
- virt_loc_dest, token, virt_loc, parm_def_loc,
- map, macro_token_index);
-
- BUFF_FRONT (buffer) = (unsigned char *) result;
- return result;
-}
-
-/* Allocate space for the function-like macro argument ARG to store
- the tokens resulting from the macro-expansion of the tokens that
- make up ARG itself. That space is allocated in ARG->expanded and
- needs to be freed using free. */
-static void
-alloc_expanded_arg_mem (cpp_reader *pfile, macro_arg *arg, size_t capacity)
-{
- gcc_checking_assert (arg->expanded == NULL
- && arg->expanded_virt_locs == NULL);
-
- arg->expanded = XNEWVEC (const cpp_token *, capacity);
- if (CPP_OPTION (pfile, track_macro_expansion))
- arg->expanded_virt_locs = XNEWVEC (location_t, capacity);
-
-}
-
-/* If necessary, enlarge ARG->expanded to so that it can contain SIZE
- tokens. */
-static void
-ensure_expanded_arg_room (cpp_reader *pfile, macro_arg *arg,
- size_t size, size_t *expanded_capacity)
-{
- if (size <= *expanded_capacity)
- return;
-
- size *= 2;
-
- arg->expanded =
- XRESIZEVEC (const cpp_token *, arg->expanded, size);
- *expanded_capacity = size;
-
- if (CPP_OPTION (pfile, track_macro_expansion))
- {
- if (arg->expanded_virt_locs == NULL)
- arg->expanded_virt_locs = XNEWVEC (location_t, size);
- else
- arg->expanded_virt_locs = XRESIZEVEC (location_t,
- arg->expanded_virt_locs,
- size);
- }
-}
-
-/*
- Expand an argument ARG before replacing parameters in a
- function-like macro. This works by pushing a context with the
- argument's tokens, and then expanding that into a temporary buffer
- as if it were a normal part of the token stream. collect_args()
- has terminated the argument's tokens with a CPP_EOF so that we know
- when we have fully expanded the argument.
- */
-static void
-expand_arg (cpp_reader *pfile, macro_arg *arg)
-{
- size_t capacity;
- bool saved_warn_trad;
- bool track_macro_exp_p = CPP_OPTION (pfile, track_macro_expansion);
- bool saved_ignore__Pragma;
-
- if (arg->count == 0
- || arg->expanded != NULL)
- return;
-
- /* Don't warn about funlike macros when pre-expanding. */
- saved_warn_trad = CPP_WTRADITIONAL (pfile);
- CPP_WTRADITIONAL (pfile) = 0;
-
- /* Loop, reading in the tokens of the argument. */
- capacity = 256;
- alloc_expanded_arg_mem (pfile, arg, capacity);
-
- if (track_macro_exp_p)
- push_extended_tokens_context (pfile, NULL, NULL,
- arg->virt_locs,
- arg->first,
- arg->count + 1);
- else
- push_ptoken_context (pfile, NULL, NULL,
- arg->first, arg->count + 1);
-
- saved_ignore__Pragma = pfile->state.ignore__Pragma;
- pfile->state.ignore__Pragma = 1;
-
- for (;;)
- {
- const cpp_token *token;
- location_t location;
-
- ensure_expanded_arg_room (pfile, arg, arg->expanded_count + 1,
- &capacity);
-
- token = cpp_get_token_1 (pfile, &location);
-
- if (token->type == CPP_EOF)
- break;
-
- set_arg_token (arg, token, location,
- arg->expanded_count, MACRO_ARG_TOKEN_EXPANDED,
- CPP_OPTION (pfile, track_macro_expansion));
- arg->expanded_count++;
- }
-
- _cpp_pop_context (pfile);
-
- CPP_WTRADITIONAL (pfile) = saved_warn_trad;
- pfile->state.ignore__Pragma = saved_ignore__Pragma;
-}
-
-/* Returns the macro associated to the current context if we are in
- the context a macro expansion, NULL otherwise. */
-static cpp_hashnode*
-macro_of_context (cpp_context *context)
-{
- if (context == NULL)
- return NULL;
-
- return (context->tokens_kind == TOKENS_KIND_EXTENDED)
- ? context->c.mc->macro_node
- : context->c.macro;
-}
-
-/* Return TRUE iff we are expanding a macro or are about to start
- expanding one. If we are effectively expanding a macro, the
- function macro_of_context returns a pointer to the macro being
- expanded. */
-static bool
-in_macro_expansion_p (cpp_reader *pfile)
-{
- if (pfile == NULL)
- return false;
-
- return (pfile->about_to_expand_macro_p
- || macro_of_context (pfile->context));
-}
-
-/* Pop the current context off the stack, re-enabling the macro if the
- context represented a macro's replacement list. Initially the
- context structure was not freed so that we can re-use it later, but
- now we do free it to reduce peak memory consumption. */
-void
-_cpp_pop_context (cpp_reader *pfile)
-{
- cpp_context *context = pfile->context;
-
- /* We should not be popping the base context. */
- gcc_assert (context != &pfile->base_context);
-
- if (context->c.macro)
- {
- cpp_hashnode *macro;
- if (context->tokens_kind == TOKENS_KIND_EXTENDED)
- {
- macro_context *mc = context->c.mc;
- macro = mc->macro_node;
- /* If context->buff is set, it means the life time of tokens
- is bound to the life time of this context; so we must
- free the tokens; that means we must free the virtual
- locations of these tokens too. */
- if (context->buff && mc->virt_locs)
- {
- free (mc->virt_locs);
- mc->virt_locs = NULL;
- }
- free (mc);
- context->c.mc = NULL;
- }
- else
- macro = context->c.macro;
-
- /* Beware that MACRO can be NULL in cases like when we are
- called from expand_arg. In those cases, a dummy context with
- tokens is pushed just for the purpose of walking them using
- cpp_get_token_1. In that case, no 'macro' field is set into
- the dummy context. */
- if (macro != NULL
- /* Several contiguous macro expansion contexts can be
- associated to the same macro; that means it's the same
- macro expansion that spans across all these (sub)
- contexts. So we should re-enable an expansion-disabled
- macro only when we are sure we are really out of that
- macro expansion. */
- && macro_of_context (context->prev) != macro)
- macro->flags &= ~NODE_DISABLED;
-
- if (macro == pfile->top_most_macro_node && context->prev == NULL)
- /* We are popping the context of the top-most macro node. */
- pfile->top_most_macro_node = NULL;
- }
-
- if (context->buff)
- {
- /* Decrease memory peak consumption by freeing the memory used
- by the context. */
- _cpp_free_buff (context->buff);
- }
-
- pfile->context = context->prev;
- /* decrease peak memory consumption by feeing the context. */
- pfile->context->next = NULL;
- free (context);
-}
-
-/* Return TRUE if we reached the end of the set of tokens stored in
- CONTEXT, FALSE otherwise. */
-static inline bool
-reached_end_of_context (cpp_context *context)
-{
- if (context->tokens_kind == TOKENS_KIND_DIRECT)
- return FIRST (context).token == LAST (context).token;
- else if (context->tokens_kind == TOKENS_KIND_INDIRECT
- || context->tokens_kind == TOKENS_KIND_EXTENDED)
- return FIRST (context).ptoken == LAST (context).ptoken;
- else
- abort ();
-}
-
-/* Consume the next token contained in the current context of PFILE,
- and return it in *TOKEN. It's "full location" is returned in
- *LOCATION. If -ftrack-macro-location is in effeect, fFull location"
- means the location encoding the locus of the token across macro
- expansion; otherwise it's just is the "normal" location of the
- token which (*TOKEN)->src_loc. */
-static inline void
-consume_next_token_from_context (cpp_reader *pfile,
- const cpp_token ** token,
- location_t *location)
-{
- cpp_context *c = pfile->context;
-
- if ((c)->tokens_kind == TOKENS_KIND_DIRECT)
- {
- *token = FIRST (c).token;
- *location = (*token)->src_loc;
- FIRST (c).token++;
- }
- else if ((c)->tokens_kind == TOKENS_KIND_INDIRECT)
- {
- *token = *FIRST (c).ptoken;
- *location = (*token)->src_loc;
- FIRST (c).ptoken++;
- }
- else if ((c)->tokens_kind == TOKENS_KIND_EXTENDED)
- {
- macro_context *m = c->c.mc;
- *token = *FIRST (c).ptoken;
- if (m->virt_locs)
- {
- *location = *m->cur_virt_loc;
- m->cur_virt_loc++;
- }
- else
- *location = (*token)->src_loc;
- FIRST (c).ptoken++;
- }
- else
- abort ();
-}
-
-/* In the traditional mode of the preprocessor, if we are currently in
- a directive, the location of a token must be the location of the
- start of the directive line. This function returns the proper
- location if we are in the traditional mode, and just returns
- LOCATION otherwise. */
-
-static inline location_t
-maybe_adjust_loc_for_trad_cpp (cpp_reader *pfile, location_t location)
-{
- if (CPP_OPTION (pfile, traditional))
- {
- if (pfile->state.in_directive)
- return pfile->directive_line;
- }
- return location;
-}
-
-/* Routine to get a token as well as its location.
-
- Macro expansions and directives are transparently handled,
- including entering included files. Thus tokens are post-macro
- expansion, and after any intervening directives. External callers
- see CPP_EOF only at EOF. Internal callers also see it when meeting
- a directive inside a macro call, when at the end of a directive and
- state.in_directive is still 1, and at the end of argument
- pre-expansion.
-
- LOC is an out parameter; *LOC is set to the location "as expected
- by the user". Please read the comment of
- cpp_get_token_with_location to learn more about the meaning of this
- location. */
-static const cpp_token*
-cpp_get_token_1 (cpp_reader *pfile, location_t *location)
-{
- const cpp_token *result;
- /* This token is a virtual token that either encodes a location
- related to macro expansion or a spelling location. */
- location_t virt_loc = 0;
- /* pfile->about_to_expand_macro_p can be overriden by indirect calls
- to functions that push macro contexts. So let's save it so that
- we can restore it when we are about to leave this routine. */
- bool saved_about_to_expand_macro = pfile->about_to_expand_macro_p;
-
- for (;;)
- {
- cpp_hashnode *node;
- cpp_context *context = pfile->context;
-
- /* Context->prev == 0 <=> base context. */
- if (!context->prev)
- {
- result = _cpp_lex_token (pfile);
- virt_loc = result->src_loc;
- }
- else if (!reached_end_of_context (context))
- {
- consume_next_token_from_context (pfile, &result,
- &virt_loc);
- if (result->flags & PASTE_LEFT)
- {
- paste_all_tokens (pfile, result);
- if (pfile->state.in_directive)
- continue;
- result = padding_token (pfile, result);
- goto out;
- }
- }
- else
- {
- if (pfile->context->c.macro)
- ++num_expanded_macros_counter;
- _cpp_pop_context (pfile);
- if (pfile->state.in_directive)
- continue;
- result = &pfile->avoid_paste;
- goto out;
- }
-
- if (pfile->state.in_directive && result->type == CPP_COMMENT)
- continue;
-
- if (result->type != CPP_NAME)
- break;
-
- node = result->val.node.node;
-
- if (node->type == NT_VOID || (result->flags & NO_EXPAND))
- break;
-
- if (!(node->flags & NODE_USED)
- && node->type == NT_USER_MACRO
- && !node->value.macro
- && !cpp_get_deferred_macro (pfile, node, result->src_loc))
- break;
-
- if (!(node->flags & NODE_DISABLED))
- {
- int ret = 0;
- /* If not in a macro context, and we're going to start an
- expansion, record the location and the top level macro
- about to be expanded. */
- if (!in_macro_expansion_p (pfile))
- {
- pfile->invocation_location = result->src_loc;
- pfile->top_most_macro_node = node;
- }
- if (pfile->state.prevent_expansion)
- break;
-
- /* Conditional macros require that a predicate be evaluated
- first. */
- if ((node->flags & NODE_CONDITIONAL) != 0)
- {
- if (pfile->cb.macro_to_expand)
- {
- bool whitespace_after;
- const cpp_token *peek_tok = cpp_peek_token (pfile, 0);
-
- whitespace_after = (peek_tok->type == CPP_PADDING
- || (peek_tok->flags & PREV_WHITE));
- node = pfile->cb.macro_to_expand (pfile, result);
- if (node)
- ret = enter_macro_context (pfile, node, result, virt_loc);
- else if (whitespace_after)
- {
- /* If macro_to_expand hook returned NULL and it
- ate some tokens, see if we don't need to add
- a padding token in between this and the
- next token. */
- peek_tok = cpp_peek_token (pfile, 0);
- if (peek_tok->type != CPP_PADDING
- && (peek_tok->flags & PREV_WHITE) == 0)
- _cpp_push_token_context (pfile, NULL,
- padding_token (pfile,
- peek_tok), 1);
- }
- }
- }
- else
- ret = enter_macro_context (pfile, node, result, virt_loc);
- if (ret)
- {
- if (pfile->state.in_directive || ret == 2)
- continue;
- result = padding_token (pfile, result);
- goto out;
- }
- }
- else
- {
- /* Flag this token as always unexpandable. FIXME: move this
- to collect_args()?. */
- cpp_token *t = _cpp_temp_token (pfile);
- t->type = result->type;
- t->flags = result->flags | NO_EXPAND;
- t->val = result->val;
- result = t;
- }
-
- break;
- }
-
- out:
- if (location != NULL)
- {
- if (virt_loc == 0)
- virt_loc = result->src_loc;
- *location = virt_loc;
-
- if (!CPP_OPTION (pfile, track_macro_expansion)
- && macro_of_context (pfile->context) != NULL)
- /* We are in a macro expansion context, are not tracking
- virtual location, but were asked to report the location
- of the expansion point of the macro being expanded. */
- *location = pfile->invocation_location;
-
- *location = maybe_adjust_loc_for_trad_cpp (pfile, *location);
- }
-
- pfile->about_to_expand_macro_p = saved_about_to_expand_macro;
-
- if (pfile->state.directive_file_token
- && !pfile->state.parsing_args
- && !(result->type == CPP_PADDING || result->type == CPP_COMMENT)
- && !(15 & --pfile->state.directive_file_token))
- {
- /* Do header-name frobbery. Concatenate < ... > as approprate.
- Do header search if needed, and finally drop the outer <> or
- "". */
- pfile->state.angled_headers = false;
-
- /* Do angle-header reconstitution. Then do include searching.
- We'll always end up with a ""-quoted header-name in that
- case. If searching finds nothing, we emit a diagnostic and
- an empty string. */
- size_t len = 0;
- char *fname = NULL;
-
- cpp_token *tmp = _cpp_temp_token (pfile);
- *tmp = *result;
-
- tmp->type = CPP_HEADER_NAME;
- bool need_search = !pfile->state.directive_file_token;
- pfile->state.directive_file_token = 0;
-
- bool angle = result->type != CPP_STRING;
- if (result->type == CPP_HEADER_NAME
- || (result->type == CPP_STRING && result->val.str.text[0] != 'R'))
- {
- len = result->val.str.len - 2;
- fname = XNEWVEC (char, len + 1);
- memcpy (fname, result->val.str.text + 1, len);
- fname[len] = 0;
- }
- else if (result->type == CPP_LESS)
- fname = _cpp_bracket_include (pfile);
-
- if (fname)
- {
- /* We have a header-name. Look it up. This will emit an
- unfound diagnostic. Canonicalize the found name. */
- const char *found = fname;
-
- if (need_search)
- {
- found = _cpp_find_header_unit (pfile, fname, angle, tmp->src_loc);
- if (!found)
- found = "";
- len = strlen (found);
- }
- /* Force a leading './' if it's not absolute. */
- bool dotme = (found[0] == '.' ? !IS_DIR_SEPARATOR (found[1])
- : found[0] && !IS_ABSOLUTE_PATH (found));
-
- if (BUFF_ROOM (pfile->u_buff) < len + 1 + dotme * 2)
- _cpp_extend_buff (pfile, &pfile->u_buff, len + 1 + dotme * 2);
- unsigned char *buf = BUFF_FRONT (pfile->u_buff);
- size_t pos = 0;
-
- if (dotme)
- {
- buf[pos++] = '.';
- /* Apparently '/' is unconditional. */
- buf[pos++] = '/';
- }
- memcpy (&buf[pos], found, len);
- pos += len;
- buf[pos] = 0;
-
- tmp->val.str.len = pos;
- tmp->val.str.text = buf;
-
- tmp->type = CPP_HEADER_NAME;
- XDELETEVEC (fname);
-
- result = tmp;
- }
- }
-
- return result;
-}
-
-/* External routine to get a token. Also used nearly everywhere
- internally, except for places where we know we can safely call
- _cpp_lex_token directly, such as lexing a directive name.
-
- Macro expansions and directives are transparently handled,
- including entering included files. Thus tokens are post-macro
- expansion, and after any intervening directives. External callers
- see CPP_EOF only at EOF. Internal callers also see it when meeting
- a directive inside a macro call, when at the end of a directive and
- state.in_directive is still 1, and at the end of argument
- pre-expansion. */
-const cpp_token *
-cpp_get_token (cpp_reader *pfile)
-{
- return cpp_get_token_1 (pfile, NULL);
-}
-
-/* Like cpp_get_token, but also returns a virtual token location
- separate from the spelling location carried by the returned token.
-
- LOC is an out parameter; *LOC is set to the location "as expected
- by the user". This matters when a token results from macro
- expansion; in that case the token's spelling location indicates the
- locus of the token in the definition of the macro but *LOC
- virtually encodes all the other meaningful locuses associated to
- the token.
-
- What? virtual location? Yes, virtual location.
-
- If the token results from macro expansion and if macro expansion
- location tracking is enabled its virtual location encodes (at the
- same time):
-
- - the spelling location of the token
-
- - the locus of the macro expansion point
-
- - the locus of the point where the token got instantiated as part
- of the macro expansion process.
-
- You have to use the linemap API to get the locus you are interested
- in from a given virtual location.
-
- Note however that virtual locations are not necessarily ordered for
- relations '<' and '>'. One must use the function
- linemap_location_before_p instead of using the relational operator
- '<'.
-
- If macro expansion tracking is off and if the token results from
- macro expansion the virtual location is the expansion point of the
- macro that got expanded.
-
- When the token doesn't result from macro expansion, the virtual
- location is just the same thing as its spelling location. */
-
-const cpp_token *
-cpp_get_token_with_location (cpp_reader *pfile, location_t *loc)
-{
- return cpp_get_token_1 (pfile, loc);
-}
-
-/* Returns true if we're expanding an object-like macro that was
- defined in a system header. Just checks the macro at the top of
- the stack. Used for diagnostic suppression.
- Also return true for builtin macros. */
-int
-cpp_sys_macro_p (cpp_reader *pfile)
-{
- cpp_hashnode *node = NULL;
-
- if (pfile->context->tokens_kind == TOKENS_KIND_EXTENDED)
- node = pfile->context->c.mc->macro_node;
- else
- node = pfile->context->c.macro;
-
- if (!node)
- return false;
- if (cpp_builtin_macro_p (node))
- return true;
- return node->value.macro && node->value.macro->syshdr;
-}
-
-/* Read each token in, until end of the current file. Directives are
- transparently processed. */
-void
-cpp_scan_nooutput (cpp_reader *pfile)
-{
- /* Request a CPP_EOF token at the end of this file, rather than
- transparently continuing with the including file. */
- pfile->buffer->return_at_eof = true;
-
- pfile->state.discarding_output++;
- pfile->state.prevent_expansion++;
-
- if (CPP_OPTION (pfile, traditional))
- while (_cpp_read_logical_line_trad (pfile))
- ;
- else
- while (cpp_get_token (pfile)->type != CPP_EOF)
- ;
-
- pfile->state.discarding_output--;
- pfile->state.prevent_expansion--;
-}
-
-/* Step back one or more tokens obtained from the lexer. */
-void
-_cpp_backup_tokens_direct (cpp_reader *pfile, unsigned int count)
-{
- pfile->lookaheads += count;
- while (count--)
- {
- pfile->cur_token--;
- if (pfile->cur_token == pfile->cur_run->base
- /* Possible with -fpreprocessed and no leading #line. */
- && pfile->cur_run->prev != NULL)
- {
- pfile->cur_run = pfile->cur_run->prev;
- pfile->cur_token = pfile->cur_run->limit;
- }
- }
-}
-
-/* Step back one (or more) tokens. Can only step back more than 1 if
- they are from the lexer, and not from macro expansion. */
-void
-_cpp_backup_tokens (cpp_reader *pfile, unsigned int count)
-{
- if (pfile->context->prev == NULL)
- _cpp_backup_tokens_direct (pfile, count);
- else
- {
- if (count != 1)
- abort ();
- if (pfile->context->tokens_kind == TOKENS_KIND_DIRECT)
- FIRST (pfile->context).token--;
- else if (pfile->context->tokens_kind == TOKENS_KIND_INDIRECT)
- FIRST (pfile->context).ptoken--;
- else if (pfile->context->tokens_kind == TOKENS_KIND_EXTENDED)
- {
- FIRST (pfile->context).ptoken--;
- if (pfile->context->c.macro)
- {
- macro_context *m = pfile->context->c.mc;
- m->cur_virt_loc--;
- gcc_checking_assert (m->cur_virt_loc >= m->virt_locs);
- }
- else
- abort ();
- }
- else
- abort ();
- }
-}
-
-/* #define directive parsing and handling. */
-
-/* Returns true if a macro redefinition warning is required. */
-static bool
-warn_of_redefinition (cpp_reader *pfile, cpp_hashnode *node,
- const cpp_macro *macro2)
-{
- /* Some redefinitions need to be warned about regardless. */
- if (node->flags & NODE_WARN)
- return true;
-
- /* Suppress warnings for builtins that lack the NODE_WARN flag,
- unless Wbuiltin-macro-redefined. */
- if (cpp_builtin_macro_p (node))
- return CPP_OPTION (pfile, warn_builtin_macro_redefined);
-
- /* Redefinitions of conditional (context-sensitive) macros, on
- the other hand, must be allowed silently. */
- if (node->flags & NODE_CONDITIONAL)
- return false;
-
- if (cpp_macro *macro1 = get_deferred_or_lazy_macro (pfile, node, macro2->line))
- return cpp_compare_macros (macro1, macro2);
- return false;
-}
-
-/* Return TRUE if MACRO1 and MACRO2 differ. */
-
-bool
-cpp_compare_macros (const cpp_macro *macro1, const cpp_macro *macro2)
-{
- /* Redefinition of a macro is allowed if and only if the old and new
- definitions are the same. (6.10.3 paragraph 2). */
-
- /* Don't check count here as it can be different in valid
- traditional redefinitions with just whitespace differences. */
- if (macro1->paramc != macro2->paramc
- || macro1->fun_like != macro2->fun_like
- || macro1->variadic != macro2->variadic)
- return true;
-
- /* Check parameter spellings. */
- for (unsigned i = macro1->paramc; i--; )
- if (macro1->parm.params[i] != macro2->parm.params[i])
- return true;
-
- /* Check the replacement text or tokens. */
- if (macro1->kind == cmk_traditional)
- return _cpp_expansions_different_trad (macro1, macro2);
-
- if (macro1->count != macro2->count)
- return true;
-
- for (unsigned i= macro1->count; i--; )
- if (!_cpp_equiv_tokens (¯o1->exp.tokens[i], ¯o2->exp.tokens[i]))
- return true;
-
- return false;
-}
-
-/* Free the definition of hashnode H. */
-void
-_cpp_free_definition (cpp_hashnode *h)
-{
- /* Macros and assertions no longer have anything to free. */
- h->type = NT_VOID;
- h->value.answers = NULL;
- h->flags &= ~(NODE_DISABLED | NODE_USED);
-}
-
-/* Save parameter NODE (spelling SPELLING) to the parameter list of
- macro MACRO. Returns true on success, false on failure. */
-bool
-_cpp_save_parameter (cpp_reader *pfile, unsigned n, cpp_hashnode *node,
- cpp_hashnode *spelling)
-{
- /* Constraint 6.10.3.6 - duplicate parameter names. */
- if (node->type == NT_MACRO_ARG)
- {
- cpp_error (pfile, CPP_DL_ERROR, "duplicate macro parameter \"%s\"",
- NODE_NAME (node));
- return false;
- }
-
- unsigned len = (n + 1) * sizeof (struct macro_arg_saved_data);
- if (len > pfile->macro_buffer_len)
- {
- pfile->macro_buffer
- = XRESIZEVEC (unsigned char, pfile->macro_buffer, len);
- pfile->macro_buffer_len = len;
- }
-
- macro_arg_saved_data *saved = (macro_arg_saved_data *)pfile->macro_buffer;
- saved[n].canonical_node = node;
- saved[n].value = node->value;
- saved[n].type = node->type;
-
- void *base = _cpp_reserve_room (pfile, n * sizeof (cpp_hashnode *),
- sizeof (cpp_hashnode *));
- ((cpp_hashnode **)base)[n] = spelling;
-
- /* Morph into a macro arg. */
- node->type = NT_MACRO_ARG;
- /* Index is 1 based. */
- node->value.arg_index = n + 1;
-
- return true;
-}
-
-/* Restore the parameters to their previous state. */
-void
-_cpp_unsave_parameters (cpp_reader *pfile, unsigned n)
-{
- /* Clear the fast argument lookup indices. */
- while (n--)
- {
- struct macro_arg_saved_data *save =
- &((struct macro_arg_saved_data *) pfile->macro_buffer)[n];
-
- struct cpp_hashnode *node = save->canonical_node;
- node->type = save->type;
- node->value = save->value;
- }
-}
-
-/* Check the syntax of the parameters in a MACRO definition. Return
- false on failure. Set *N_PTR and *VARADIC_PTR as appropriate.
- '(' ')'
- '(' parm-list ',' last-parm ')'
- '(' last-parm ')'
- parm-list: name
- | parm-list, name
- last-parm: name
- | name '...'
- | '...'
-*/
-
-static bool
-parse_params (cpp_reader *pfile, unsigned *n_ptr, bool *varadic_ptr)
-{
- unsigned nparms = 0;
- bool ok = false;
-
- for (bool prev_ident = false;;)
- {
- const cpp_token *token = _cpp_lex_token (pfile);
-
- switch (token->type)
- {
- case CPP_COMMENT:
- /* Allow/ignore comments in parameter lists if we are
- preserving comments in macro expansions. */
- if (!CPP_OPTION (pfile, discard_comments_in_macro_exp))
- break;
-
- /* FALLTHRU */
- default:
- bad:
- {
- const char *const msgs[5] =
- {
- N_("expected parameter name, found \"%s\""),
- N_("expected ',' or ')', found \"%s\""),
- N_("expected parameter name before end of line"),
- N_("expected ')' before end of line"),
- N_("expected ')' after \"...\"")
- };
- unsigned ix = prev_ident;
- const unsigned char *as_text = NULL;
- if (*varadic_ptr)
- ix = 4;
- else if (token->type == CPP_EOF)
- ix += 2;
- else
- as_text = cpp_token_as_text (pfile, token);
- cpp_error (pfile, CPP_DL_ERROR, msgs[ix], as_text);
- }
- goto out;
-
- case CPP_NAME:
- if (prev_ident || *varadic_ptr)
- goto bad;
- prev_ident = true;
-
- if (!_cpp_save_parameter (pfile, nparms, token->val.node.node,
- token->val.node.spelling))
- goto out;
- nparms++;
- break;
-
- case CPP_CLOSE_PAREN:
- if (prev_ident || !nparms || *varadic_ptr)
- {
- ok = true;
- goto out;
- }
-
- /* FALLTHRU */
- case CPP_COMMA:
- if (!prev_ident || *varadic_ptr)
- goto bad;
- prev_ident = false;
- break;
-
- case CPP_ELLIPSIS:
- if (*varadic_ptr)
- goto bad;
- *varadic_ptr = true;
- if (!prev_ident)
- {
- /* An ISO bare ellipsis. */
- _cpp_save_parameter (pfile, nparms,
- pfile->spec_nodes.n__VA_ARGS__,
- pfile->spec_nodes.n__VA_ARGS__);
- nparms++;
- pfile->state.va_args_ok = 1;
- if (! CPP_OPTION (pfile, c99)
- && CPP_OPTION (pfile, cpp_pedantic)
- && CPP_OPTION (pfile, warn_variadic_macros))
- cpp_pedwarning
- (pfile, CPP_W_VARIADIC_MACROS,
- CPP_OPTION (pfile, cplusplus)
- ? N_("anonymous variadic macros were introduced in C++11")
- : N_("anonymous variadic macros were introduced in C99"));
- else if (CPP_OPTION (pfile, cpp_warn_c90_c99_compat) > 0
- && ! CPP_OPTION (pfile, cplusplus))
- cpp_error (pfile, CPP_DL_WARNING,
- "anonymous variadic macros were introduced in C99");
- }
- else if (CPP_OPTION (pfile, cpp_pedantic)
- && CPP_OPTION (pfile, warn_variadic_macros))
- cpp_pedwarning (pfile, CPP_W_VARIADIC_MACROS,
- CPP_OPTION (pfile, cplusplus)
- ? N_("ISO C++ does not permit named variadic macros")
- : N_("ISO C does not permit named variadic macros"));
- break;
- }
- }
-
- out:
- *n_ptr = nparms;
-
- return ok;
-}
-
-/* Lex a token from the expansion of MACRO, but mark parameters as we
- find them and warn of traditional stringification. */
-static cpp_macro *
-lex_expansion_token (cpp_reader *pfile, cpp_macro *macro)
-{
- macro = (cpp_macro *)_cpp_reserve_room (pfile,
- sizeof (cpp_macro) - sizeof (cpp_token)
- + macro->count * sizeof (cpp_token),
- sizeof (cpp_token));
- cpp_token *saved_cur_token = pfile->cur_token;
- pfile->cur_token = ¯o->exp.tokens[macro->count];
- cpp_token *token = _cpp_lex_direct (pfile);
- pfile->cur_token = saved_cur_token;
-
- /* Is this a parameter? */
- if (token->type == CPP_NAME && token->val.node.node->type == NT_MACRO_ARG)
- {
- /* Morph into a parameter reference. */
- cpp_hashnode *spelling = token->val.node.spelling;
- token->type = CPP_MACRO_ARG;
- token->val.macro_arg.arg_no = token->val.node.node->value.arg_index;
- token->val.macro_arg.spelling = spelling;
- }
- else if (CPP_WTRADITIONAL (pfile) && macro->paramc > 0
- && (token->type == CPP_STRING || token->type == CPP_CHAR))
- check_trad_stringification (pfile, macro, &token->val.str);
-
- return macro;
-}
-
-static cpp_macro *
-create_iso_definition (cpp_reader *pfile)
-{
- bool following_paste_op = false;
- const char *paste_op_error_msg =
- N_("'##' cannot appear at either end of a macro expansion");
- unsigned int num_extra_tokens = 0;
- unsigned nparms = 0;
- cpp_hashnode **params = NULL;
- bool varadic = false;
- bool ok = false;
- cpp_macro *macro = NULL;
-
- /* Look at the first token, to see if this is a function-like
- macro. */
- cpp_token first;
- cpp_token *saved_cur_token = pfile->cur_token;
- pfile->cur_token = &first;
- cpp_token *token = _cpp_lex_direct (pfile);
- pfile->cur_token = saved_cur_token;
-
- if (token->flags & PREV_WHITE)
- /* Preceeded by space, must be part of expansion. */;
- else if (token->type == CPP_OPEN_PAREN)
- {
- /* An open-paren, get a parameter list. */
- if (!parse_params (pfile, &nparms, &varadic))
- goto out;
-
- params = (cpp_hashnode **)_cpp_commit_buff
- (pfile, sizeof (cpp_hashnode *) * nparms);
- token = NULL;
- }
- else if (token->type != CPP_EOF
- && !(token->type == CPP_COMMENT
- && ! CPP_OPTION (pfile, discard_comments_in_macro_exp)))
- {
- /* While ISO C99 requires whitespace before replacement text
- in a macro definition, ISO C90 with TC1 allows characters
- from the basic source character set there. */
- if (CPP_OPTION (pfile, c99))
- cpp_error (pfile, CPP_DL_PEDWARN,
- CPP_OPTION (pfile, cplusplus)
- ? N_("ISO C++11 requires whitespace after the macro name")
- : N_("ISO C99 requires whitespace after the macro name"));
- else
- {
- enum cpp_diagnostic_level warntype = CPP_DL_WARNING;
- switch (token->type)
- {
- case CPP_ATSIGN:
- case CPP_AT_NAME:
- case CPP_OBJC_STRING:
- /* '@' is not in basic character set. */
- warntype = CPP_DL_PEDWARN;
- break;
- case CPP_OTHER:
- /* Basic character set sans letters, digits and _. */
- if (strchr ("!\"#%&'()*+,-./:;<=>?[\\]^{|}~",
- token->val.str.text[0]) == NULL)
- warntype = CPP_DL_PEDWARN;
- break;
- default:
- /* All other tokens start with a character from basic
- character set. */
- break;
- }
- cpp_error (pfile, warntype,
- "missing whitespace after the macro name");
- }
- }
-
- macro = _cpp_new_macro (pfile, cmk_macro,
- _cpp_reserve_room (pfile, 0, sizeof (cpp_macro)));
-
- if (!token)
- {
- macro->variadic = varadic;
- macro->paramc = nparms;
- macro->parm.params = params;
- macro->fun_like = true;
- }
- else
- {
- /* Preserve the token we peeked, there is already a single slot for it. */
- macro->exp.tokens[0] = *token;
- token = ¯o->exp.tokens[0];
- macro->count = 1;
- }
-
- for (vaopt_state vaopt_tracker (pfile, macro->variadic, NULL);; token = NULL)
- {
- if (!token)
- {
- macro = lex_expansion_token (pfile, macro);
- token = ¯o->exp.tokens[macro->count++];
- }
-
- /* Check the stringifying # constraint 6.10.3.2.1 of
- function-like macros when lexing the subsequent token. */
- if (macro->count > 1 && token[-1].type == CPP_HASH && macro->fun_like)
- {
- if (token->type == CPP_MACRO_ARG
- || (macro->variadic
- && token->type == CPP_NAME
- && token->val.node.node == pfile->spec_nodes.n__VA_OPT__))
- {
- if (token->flags & PREV_WHITE)
- token->flags |= SP_PREV_WHITE;
- if (token[-1].flags & DIGRAPH)
- token->flags |= SP_DIGRAPH;
- token->flags &= ~PREV_WHITE;
- token->flags |= STRINGIFY_ARG;
- token->flags |= token[-1].flags & PREV_WHITE;
- token[-1] = token[0];
- macro->count--;
- }
- /* Let assembler get away with murder. */
- else if (CPP_OPTION (pfile, lang) != CLK_ASM)
- {
- cpp_error (pfile, CPP_DL_ERROR,
- "'#' is not followed by a macro parameter");
- goto out;
- }
- }
-
- if (token->type == CPP_EOF)
- {
- /* Paste operator constraint 6.10.3.3.1:
- Token-paste ##, can appear in both object-like and
- function-like macros, but not at the end. */
- if (following_paste_op)
- {
- cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg);
- goto out;
- }
- if (!vaopt_tracker.completed ())
- goto out;
- break;
- }
-
- /* Paste operator constraint 6.10.3.3.1. */
- if (token->type == CPP_PASTE)
- {
- /* Token-paste ##, can appear in both object-like and
- function-like macros, but not at the beginning. */
- if (macro->count == 1)
- {
- cpp_error (pfile, CPP_DL_ERROR, paste_op_error_msg);
- goto out;
- }
-
- if (following_paste_op)
- {
- /* Consecutive paste operators. This one will be moved
- to the end. */
- num_extra_tokens++;
- token->val.token_no = macro->count - 1;
- }
- else
- {
- /* Drop the paste operator. */
- --macro->count;
- token[-1].flags |= PASTE_LEFT;
- if (token->flags & DIGRAPH)
- token[-1].flags |= SP_DIGRAPH;
- if (token->flags & PREV_WHITE)
- token[-1].flags |= SP_PREV_WHITE;
- }
- following_paste_op = true;
- }
- else
- following_paste_op = false;
-
- if (vaopt_tracker.update (token) == vaopt_state::ERROR)
- goto out;
- }
-
- /* We're committed to winning now. */
- ok = true;
-
- /* Don't count the CPP_EOF. */
- macro->count--;
-
- macro = (cpp_macro *)_cpp_commit_buff
- (pfile, sizeof (cpp_macro) - sizeof (cpp_token)
- + sizeof (cpp_token) * macro->count);
-
- /* Clear whitespace on first token. */
- if (macro->count)
- macro->exp.tokens[0].flags &= ~PREV_WHITE;
-
- if (num_extra_tokens)
- {
- /* Place second and subsequent ## or %:%: tokens in sequences of
- consecutive such tokens at the end of the list to preserve
- information about where they appear, how they are spelt and
- whether they are preceded by whitespace without otherwise
- interfering with macro expansion. Remember, this is
- extremely rare, so efficiency is not a priority. */
- cpp_token *temp = (cpp_token *)_cpp_reserve_room
- (pfile, 0, num_extra_tokens * sizeof (cpp_token));
- unsigned extra_ix = 0, norm_ix = 0;
- cpp_token *exp = macro->exp.tokens;
- for (unsigned ix = 0; ix != macro->count; ix++)
- if (exp[ix].type == CPP_PASTE)
- temp[extra_ix++] = exp[ix];
- else
- exp[norm_ix++] = exp[ix];
- memcpy (&exp[norm_ix], temp, num_extra_tokens * sizeof (cpp_token));
-
- /* Record there are extra tokens. */
- macro->extra_tokens = 1;
- }
-
- out:
- pfile->state.va_args_ok = 0;
- _cpp_unsave_parameters (pfile, nparms);
-
- return ok ? macro : NULL;
-}
-
-cpp_macro *
-_cpp_new_macro (cpp_reader *pfile, cpp_macro_kind kind, void *placement)
-{
- cpp_macro *macro = (cpp_macro *) placement;
-
- /* Zero init all the fields. This'll tell the compiler know all the
- following inits are writing a virgin object. */
- memset (macro, 0, offsetof (cpp_macro, exp));
-
- macro->line = pfile->directive_line;
- macro->parm.params = 0;
- macro->lazy = 0;
- macro->paramc = 0;
- macro->variadic = 0;
- macro->used = !CPP_OPTION (pfile, warn_unused_macros);
- macro->count = 0;
- macro->fun_like = 0;
- macro->imported_p = false;
- macro->extra_tokens = 0;
- /* To suppress some diagnostics. */
- macro->syshdr = pfile->buffer && pfile->buffer->sysp != 0;
-
- macro->kind = kind;
-
- return macro;
-}
-
-/* Parse a macro and save its expansion. Returns nonzero on success. */
-bool
-_cpp_create_definition (cpp_reader *pfile, cpp_hashnode *node)
-{
- cpp_macro *macro;
-
- if (CPP_OPTION (pfile, traditional))
- macro = _cpp_create_trad_definition (pfile);
- else
- macro = create_iso_definition (pfile);
-
- if (!macro)
- return false;
-
- if (cpp_macro_p (node))
- {
- if (CPP_OPTION (pfile, warn_unused_macros))
- _cpp_warn_if_unused_macro (pfile, node, NULL);
-
- if (warn_of_redefinition (pfile, node, macro))
- {
- const enum cpp_warning_reason reason
- = (cpp_builtin_macro_p (node) && !(node->flags & NODE_WARN))
- ? CPP_W_BUILTIN_MACRO_REDEFINED : CPP_W_NONE;
-
- bool warned =
- cpp_pedwarning_with_line (pfile, reason,
- pfile->directive_line, 0,
- "\"%s\" redefined", NODE_NAME (node));
-
- if (warned && cpp_user_macro_p (node))
- cpp_error_with_line (pfile, CPP_DL_NOTE,
- node->value.macro->line, 0,
- "this is the location of the previous definition");
- }
- _cpp_free_definition (node);
- }
-
- /* Enter definition in hash table. */
- node->type = NT_USER_MACRO;
- node->value.macro = macro;
- if (! ustrncmp (NODE_NAME (node), DSC ("__STDC_"))
- && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_FORMAT_MACROS")
- /* __STDC_LIMIT_MACROS and __STDC_CONSTANT_MACROS are mentioned
- in the C standard, as something that one must use in C++.
- However DR#593 and C++11 indicate that they play no role in C++.
- We special-case them anyway. */
- && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_LIMIT_MACROS")
- && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_CONSTANT_MACROS"))
- node->flags |= NODE_WARN;
-
- /* If user defines one of the conditional macros, remove the
- conditional flag */
- node->flags &= ~NODE_CONDITIONAL;
-
- return true;
-}
-
-extern void
-cpp_define_lazily (cpp_reader *pfile, cpp_hashnode *node, unsigned num)
-{
- cpp_macro *macro = node->value.macro;
-
- gcc_checking_assert (pfile->cb.user_lazy_macro && macro && num < UCHAR_MAX);
-
- macro->lazy = num + 1;
-}
-
-/* NODE is a deferred macro, resolve it, returning the definition
- (which may be NULL). */
-cpp_macro *
-cpp_get_deferred_macro (cpp_reader *pfile, cpp_hashnode *node,
- location_t loc)
-{
- gcc_checking_assert (node->type == NT_USER_MACRO);
-
- node->value.macro = pfile->cb.user_deferred_macro (pfile, loc, node);
-
- if (!node->value.macro)
- node->type = NT_VOID;
-
- return node->value.macro;
-}
-
-static cpp_macro *
-get_deferred_or_lazy_macro (cpp_reader *pfile, cpp_hashnode *node,
- location_t loc)
-{
- cpp_macro *macro = node->value.macro;
- if (!macro)
- {
- macro = cpp_get_deferred_macro (pfile, node, loc);
- gcc_checking_assert (!macro || !macro->lazy);
- }
- else if (macro->lazy)
- {
- pfile->cb.user_lazy_macro (pfile, macro, macro->lazy - 1);
- macro->lazy = 0;
- }
-
- return macro;
-}
-
-/* Notify the use of NODE in a macro-aware context (i.e. expanding it,
- or testing its existance). Also applies any lazy definition.
- Return FALSE if the macro isn't really there. */
-
-extern bool
-_cpp_notify_macro_use (cpp_reader *pfile, cpp_hashnode *node,
- location_t loc)
-{
- node->flags |= NODE_USED;
- switch (node->type)
- {
- case NT_USER_MACRO:
- if (!get_deferred_or_lazy_macro (pfile, node, loc))
- return false;
- /* FALLTHROUGH. */
-
- case NT_BUILTIN_MACRO:
- if (pfile->cb.used_define)
- pfile->cb.used_define (pfile, loc, node);
- break;
-
- case NT_VOID:
- if (pfile->cb.used_undef)
- pfile->cb.used_undef (pfile, loc, node);
- break;
-
- default:
- abort ();
- }
-
- return true;
-}
-
-/* Warn if a token in STRING matches one of a function-like MACRO's
- parameters. */
-static void
-check_trad_stringification (cpp_reader *pfile, const cpp_macro *macro,
- const cpp_string *string)
-{
- unsigned int i, len;
- const uchar *p, *q, *limit;
-
- /* Loop over the string. */
- limit = string->text + string->len - 1;
- for (p = string->text + 1; p < limit; p = q)
- {
- /* Find the start of an identifier. */
- while (p < limit && !is_idstart (*p))
- p++;
-
- /* Find the end of the identifier. */
- q = p;
- while (q < limit && is_idchar (*q))
- q++;
-
- len = q - p;
-
- /* Loop over the function macro arguments to see if the
- identifier inside the string matches one of them. */
- for (i = 0; i < macro->paramc; i++)
- {
- const cpp_hashnode *node = macro->parm.params[i];
-
- if (NODE_LEN (node) == len
- && !memcmp (p, NODE_NAME (node), len))
- {
- cpp_warning (pfile, CPP_W_TRADITIONAL,
- "macro argument \"%s\" would be stringified in traditional C",
- NODE_NAME (node));
- break;
- }
- }
- }
-}
-
-/* Returns the name, arguments and expansion of a macro, in a format
- suitable to be read back in again, and therefore also for DWARF 2
- debugging info. e.g. "PASTE(X, Y) X ## Y", or "MACNAME EXPANSION".
- Caller is expected to generate the "#define" bit if needed. The
- returned text is temporary, and automatically freed later. */
-const unsigned char *
-cpp_macro_definition (cpp_reader *pfile, cpp_hashnode *node)
-{
- gcc_checking_assert (cpp_user_macro_p (node));
-
- if (const cpp_macro *macro = get_deferred_or_lazy_macro (pfile, node, 0))
- return cpp_macro_definition (pfile, node, macro);
- return NULL;
-}
-
-const unsigned char *
-cpp_macro_definition (cpp_reader *pfile, cpp_hashnode *node,
- const cpp_macro *macro)
-{
- unsigned int i, len;
- unsigned char *buffer;
-
- /* Calculate length. */
- len = NODE_LEN (node) * 10 + 2; /* ' ' and NUL. */
- if (macro->fun_like)
- {
- len += 4; /* "()" plus possible final ".." of named
- varargs (we have + 1 below). */
- for (i = 0; i < macro->paramc; i++)
- len += NODE_LEN (macro->parm.params[i]) + 1; /* "," */
- }
-
- /* This should match below where we fill in the buffer. */
- if (CPP_OPTION (pfile, traditional))
- len += _cpp_replacement_text_len (macro);
- else
- {
- unsigned int count = macro_real_token_count (macro);
- for (i = 0; i < count; i++)
- {
- const cpp_token *token = ¯o->exp.tokens[i];
-
- if (token->type == CPP_MACRO_ARG)
- len += NODE_LEN (token->val.macro_arg.spelling);
- else
- len += cpp_token_len (token);
-
- if (token->flags & STRINGIFY_ARG)
- len++; /* "#" */
- if (token->flags & PASTE_LEFT)
- len += 3; /* " ##" */
- if (token->flags & PREV_WHITE)
- len++; /* " " */
- }
- }
-
- if (len > pfile->macro_buffer_len)
- {
- pfile->macro_buffer = XRESIZEVEC (unsigned char,
- pfile->macro_buffer, len);
- pfile->macro_buffer_len = len;
- }
-
- /* Fill in the buffer. Start with the macro name. */
- buffer = pfile->macro_buffer;
- buffer = _cpp_spell_ident_ucns (buffer, node);
-
- /* Parameter names. */
- if (macro->fun_like)
- {
- *buffer++ = '(';
- for (i = 0; i < macro->paramc; i++)
- {
- cpp_hashnode *param = macro->parm.params[i];
-
- if (param != pfile->spec_nodes.n__VA_ARGS__)
- {
- memcpy (buffer, NODE_NAME (param), NODE_LEN (param));
- buffer += NODE_LEN (param);
- }
-
- if (i + 1 < macro->paramc)
- /* Don't emit a space after the comma here; we're trying
- to emit a Dwarf-friendly definition, and the Dwarf spec
- forbids spaces in the argument list. */
- *buffer++ = ',';
- else if (macro->variadic)
- *buffer++ = '.', *buffer++ = '.', *buffer++ = '.';
- }
- *buffer++ = ')';
- }
-
- /* The Dwarf spec requires a space after the macro name, even if the
- definition is the empty string. */
- *buffer++ = ' ';
-
- if (CPP_OPTION (pfile, traditional))
- buffer = _cpp_copy_replacement_text (macro, buffer);
- else if (macro->count)
- /* Expansion tokens. */
- {
- unsigned int count = macro_real_token_count (macro);
- for (i = 0; i < count; i++)
- {
- const cpp_token *token = ¯o->exp.tokens[i];
-
- if (token->flags & PREV_WHITE)
- *buffer++ = ' ';
- if (token->flags & STRINGIFY_ARG)
- *buffer++ = '#';
-
- if (token->type == CPP_MACRO_ARG)
- {
- memcpy (buffer,
- NODE_NAME (token->val.macro_arg.spelling),
- NODE_LEN (token->val.macro_arg.spelling));
- buffer += NODE_LEN (token->val.macro_arg.spelling);
- }
- else
- buffer = cpp_spell_token (pfile, token, buffer, true);
-
- if (token->flags & PASTE_LEFT)
- {
- *buffer++ = ' ';
- *buffer++ = '#';
- *buffer++ = '#';
- /* Next has PREV_WHITE; see _cpp_create_definition. */
- }
- }
- }
-
- *buffer = '\0';
- return pfile->macro_buffer;
-}
-
-
-/*--------------------------------------------------------------------------------
- RT extensions
---------------------------------------------------------------------------------*/
-
-/*--------------------------------------------------------------------------------
- shared declarations
-*/
-
- typedef enum parse_clause_status {
- PCS_COMPLETE // Clause completely parsed
- ,PCS_ERR_EXPECTED_OPEN_DELIM // Failed to find expected opening '('
- ,PCS_ERR_UNEXPECTED_EOF // Hit real EOF before matching ')'
- ,PCS_ERR_PASTE_AT_END // Trailing '##' paste operator
- ,PCS_ERR_HASH_NOT_FOLLOWED_BY_ARG // '#' not followed by macro parameter
- ,PCS_ERR_VAOPT_STATE_INVALID // __VA_OPT__ or variadic tracking error
- ,PCS_ERR_EOF_FETCH_FAILED // Failed to fetch next line after EOF
- ,PCS_ERR_UNKNOWN // Fallback error (should not occur)
- ,PCS_ERR_STATUS_NOT_SET // function did not set the status
- } parse_clause_status;
-
-
-/*--------------------------------------------------------------------------------
- debug helpers
-*/
-
- #define DebugParseClause 1
- #define DebugAssign 1
- #define DebugRTMacro 1
-
- #define DebugHelpers 1
-
- #if DebugHelpers
-
- static const char *
- ttype_to_text(enum cpp_ttype ttype)
- {
- switch (ttype)
- {
- case CPP_EOF: return "EOF";
- case CPP_PADDING: return "PADDING";
- case CPP_COMMENT: return "COMMENT";
- // case CPP_HSPACE: return "HSPACE";
- // case CPP_VSPACE: return "VSPACE";
- case CPP_OTHER: return "OTHER";
- case CPP_OPEN_PAREN: return "OPEN_PAREN";
- case CPP_CLOSE_PAREN: return "CLOSE_PAREN";
- case CPP_OPEN_SQUARE: return "OPEN_SQUARE";
- case CPP_CLOSE_SQUARE: return "CLOSE_SQUARE";
- case CPP_OPEN_BRACE: return "OPEN_BRACE";
- case CPP_CLOSE_BRACE: return "CLOSE_BRACE";
- case CPP_COMMA: return "COMMA";
- case CPP_SEMICOLON: return "SEMICOLON";
- case CPP_ELLIPSIS: return "ELLIPSIS";
- case CPP_NAME: return "NAME";
- case CPP_NUMBER: return "NUMBER";
- case CPP_CHAR: return "CHAR";
- case CPP_STRING: return "STRING";
- case CPP_HEADER_NAME: return "HEADER_NAME";
- case CPP_PLUS: return "PLUS";
- case CPP_MINUS: return "MINUS";
- case CPP_MULT: return "MULT";
- case CPP_DIV: return "DIV";
- case CPP_MOD: return "MOD";
- case CPP_AND: return "AND";
- case CPP_OR: return "OR";
- case CPP_XOR: return "XOR";
- case CPP_NOT: return "NOT";
- case CPP_LSHIFT: return "LSHIFT";
- case CPP_RSHIFT: return "RSHIFT";
- case CPP_EQ: return "EQ";
- // case CPP_NE: return "NE";
- // case CPP_LE: return "LE";
- // case CPP_GE: return "GE";
- // case CPP_LT: return "LT";
- // case CPP_GT: return "GT";
- case CPP_ATSIGN: return "@";
- case CPP_PLUS_EQ: return "PLUS_EQ";
- case CPP_MINUS_EQ: return "MINUS_EQ";
- case CPP_MULT_EQ: return "MULT_EQ";
- case CPP_DIV_EQ: return "DIV_EQ";
- case CPP_MOD_EQ: return "MOD_EQ";
- case CPP_AND_EQ: return "AND_EQ";
- case CPP_OR_EQ: return "OR_EQ";
- case CPP_XOR_EQ: return "XOR_EQ";
- case CPP_LSHIFT_EQ: return "LSHIFT_EQ";
- case CPP_RSHIFT_EQ: return "RSHIFT_EQ";
- // case CPP_CONDITIONAL: return "CONDITIONAL";
- case CPP_COLON: return "COLON";
- case CPP_DEREF: return "DEREF";
- case CPP_DOT: return "DOT";
- case CPP_DEREF_STAR: return "DEREF_STAR";
- case CPP_DOT_STAR: return "DOT_STAR";
- // case CPP_INCREMENT: return "INCREMENT";
- // case CPP_DECREMENT: return "DECREMENT";
- default: return "<unknown-ttype>";
- }
- }
-
- static void
- print_ttype(enum cpp_ttype ttype){
- fprintf(stderr, "%s (%d)", ttype_to_text(ttype), ttype);
- }
-
- const char *cpp_token_as_text(const cpp_token *token){
- static char buffer[256];
-
- switch (token->type)
- {
- case CPP_NAME:
- snprintf(buffer, sizeof(buffer), "CPP_NAME: '%s'",
- NODE_NAME(token->val.node.node));
- break;
-
- case CPP_NUMBER:
- case CPP_STRING:
- case CPP_CHAR:
- case CPP_HEADER_NAME:
- snprintf(buffer, sizeof(buffer), "'%.*s'",
- token->val.str.len,
- token->val.str.text);
- break;
-
- case CPP_EOF:
- return "<EOF>";
- case CPP_OTHER:
- return "<OTHER>";
- case CPP_OPEN_PAREN:
- return "'('";
- case CPP_CLOSE_PAREN:
- return "')'";
- case CPP_COMMA:
- return "','";
- case CPP_SEMICOLON:
- return "';'";
- case CPP_PLUS:
- return "'+'";
- case CPP_MINUS:
- return "'-'";
- case CPP_MULT:
- return "'*'";
- case CPP_DIV:
- return "'/'";
- case CPP_MOD:
- return "'%'";
- case CPP_MACRO_ARG:
- snprintf(
- buffer
- ,sizeof(buffer)
- ,"CPP_MACRO_ARG: '%s'"
- ,NODE_NAME(token->val.macro_arg.spelling)
- );
- break;
- case CPP_PADDING: return "<PADDING>";
- case CPP_COMMENT: return "<COMMENT>";
- case CPP_HASH: return "'#'";
- case CPP_PASTE: return "'##'";
- case CPP_ELLIPSIS: return "'...'";
- case CPP_COLON: return "':'";
- case CPP_OPEN_SQUARE: return "'['";
- case CPP_CLOSE_SQUARE: return "']'";
- case CPP_OPEN_BRACE: return "'{'";
- case CPP_CLOSE_BRACE: return "'}'";
- case CPP_DOT: return "'.'";
- case CPP_DEREF: return "'->'";
- case CPP_SCOPE: return "'::'";
- case CPP_DOT_STAR: return "'.*'";
- case CPP_DEREF_STAR: return "'->*'";
- case CPP_PRAGMA: return "<_Pragma>";
- case CPP_KEYWORD: return "<keyword>";
-
- default:
- snprintf(buffer, sizeof(buffer), "<unknown type %d>", token->type);
- break;
- }
-
- // Append token flags if any are set
- if (token->flags & (PREV_WHITE | DIGRAPH | STRINGIFY_ARG |
- PASTE_LEFT | NAMED_OP | BOL | PURE_ZERO |
- SP_DIGRAPH | SP_PREV_WHITE | NO_EXPAND | PRAGMA_OP))
- {
- size_t len = strlen(buffer);
- snprintf(buffer + len, sizeof(buffer) - len, " [flags:");
-
- if (token->flags & PREV_WHITE)
- strncat(buffer, " PREV_WHITE", sizeof(buffer) - strlen(buffer) - 1);
- if (token->flags & DIGRAPH)
- strncat(buffer, " DIGRAPH", sizeof(buffer) - strlen(buffer) - 1);
- if (token->flags & STRINGIFY_ARG)
- strncat(buffer, " STRINGIFY", sizeof(buffer) - strlen(buffer) - 1);
- if (token->flags & PASTE_LEFT)
- strncat(buffer, " ##L", sizeof(buffer) - strlen(buffer) - 1);
- if (token->flags & NAMED_OP)
- strncat(buffer, " NAMED_OP", sizeof(buffer) - strlen(buffer) - 1);
- if (token->flags & BOL)
- strncat(buffer, " BOL", sizeof(buffer) - strlen(buffer) - 1);
- if (token->flags & PURE_ZERO)
- strncat(buffer, " ZERO", sizeof(buffer) - strlen(buffer) - 1);
- if (token->flags & SP_DIGRAPH)
- strncat(buffer, " ##DIGRAPH", sizeof(buffer) - strlen(buffer) - 1);
- if (token->flags & SP_PREV_WHITE)
- strncat(buffer, " SP_WHITE", sizeof(buffer) - strlen(buffer) - 1);
- if (token->flags & NO_EXPAND)
- strncat(buffer, " NO_EXPAND", sizeof(buffer) - strlen(buffer) - 1);
- if (token->flags & PRAGMA_OP)
- strncat(buffer, " _Pragma", sizeof(buffer) - strlen(buffer) - 1);
-
- strncat(buffer, " ]", sizeof(buffer) - strlen(buffer) - 1);
- }
-
- return buffer;
- }
-
- void print_token_list(const cpp_token *tokens ,size_t count){
- for (size_t i = 0; i < count; ++i)
- fprintf( stderr ,"[%zu] %s\n" ,i , cpp_token_as_text(&tokens[i]) );
- }
-
- void print_parse_clause_status(enum parse_clause_status status){
- const char *message = NULL;
- switch (status)
- {
- case PCS_COMPLETE:
- message = "parse_clause status is OK";
- break;
- case PCS_ERR_EXPECTED_OPEN_DELIM:
- message = "expected opening delimiter such as '(' but did not find it.";
- break;
- case PCS_ERR_UNEXPECTED_EOF:
- message = "unexpected EOF before closing ')'.";
- break;
- case PCS_ERR_PASTE_AT_END:
- message = "paste operator '##' appeared at the beginning or end of macro body.";
- break;
- case PCS_ERR_HASH_NOT_FOLLOWED_BY_ARG:
- message = "'#' was not followed by a valid macro parameter.";
- break;
- case PCS_ERR_VAOPT_STATE_INVALID:
- message = "invalid __VA_OPT__ tracking state.";
- break;
- case PCS_ERR_EOF_FETCH_FAILED:
- message = "_cpp_get_fresh_line() failed to fetch next line.";
- break;
- case PCS_ERR_STATUS_NOT_SET:
- message = "Internal Error, status was not set";
- break;
- case PCS_ERR_UNKNOWN:
- default:
- message = "unknown or unhandled error.";
- break;
- }
- fprintf(stderr, "%s\n", message);
- }
-
- // a helper function for probing where the parser thinks it is in the source
- void debug_peek_token (cpp_reader *pfile){
- const cpp_token *tok = _cpp_lex_token(pfile);
-
- cpp_error_with_line(
- pfile,
- CPP_DL_ERROR,
- tok->src_loc,
- 0,
- "DEBUG: next token is: `%s`",
- (const char *) cpp_token_as_text(tok)
- );
-
- _cpp_backup_tokens (pfile, 1);
-
- }
-
-#endif
-
-/*--------------------------------------------------------------------------------
- Parse a clause
-
- clause ::= "(" literal? ")"
- | "[" expr? "]"
- | tokens_to_eol ;
-
- literal ::= ; sequence parsed into tokens, no expansion
- expr ::= ; sequence parsed into tokens with recursive expansion of each token
- tokens_to_eol ::= ; all tokens until logical end-of-line (including multi-line with `\`)
-
- Notes:
- - The first two forms are explicitly delimited with parentheses or brackets,
- and may be empty (e.g., `()` or `[]`). Newlines are taken as white space.
- - The third form is implicit: it consumes all remaining tokens on the directive line.
- This is typical for simple macro bodies (e.g., in `#define NAME body`).
-
-*/
-
-
-/*
- Caller sees an open parenthesis or other open delimiter, and calls this.
-
- This parses tokens until seeing the closing delimiter.
-
- delimiter_matching == true: balances opening and closing delimiter types while searching for the balanced closing delimiter.
-
- paren_matching == false; terminating delimiter is CPP_EOF - which to the lexer will be end of the line. (That is how the cpp_reader does it.)
-
- comma_list: when true, the comma becomes an alias for the final closing delimiter. For
- balanced delimiters only a comma at level 0 is a terminating delimiter.
-
-*/
-
-
-static enum parse_clause_status
-parse_clause_expand(cpp_reader *pfile,
- cpp_macro *macro,
- bool delimiter_matching,
- enum cpp_ttype opening,
- enum cpp_ttype closing,
- bool comma_list,
- location_t *src_loc_pt,
- cpp_ttype *terminator_out)
-{
- #if DebugParseClause
- fprintf(stderr, ">> parse_clause_expand\n");
- fprintf(stderr, " delimiter_matching: %s\n", delimiter_matching ? "true" : "false");
- fprintf(stderr, " opening token: %s (%d)\n", ttype_to_text(opening), opening);
- fprintf(stderr, " closing token: %s (%d)\n", ttype_to_text(closing), closing);
- fprintf(stderr, " comma_list: %s\n", comma_list ? "true" : "false");
- fprintf(stderr, " src_loc_pt: %p\n", (void *)src_loc_pt);
- #endif
-
- int nesting_depth = 1;
- const cpp_token *token;
-
- for(;;){
-
- /* get a token
- */
- // why not use cpp_get_token? or cpp_get_token_no_padding?
- token = cpp_get_token_1 (pfile, src_loc_pt);
- // this is necessary for the name expr, but does it impact potential other uses of parse_clause? Another flag for this perhaps?
- if(token->type == CPP_PADDING) continue;
- macro = (cpp_macro *)_cpp_reserve_room(
- pfile,
- sizeof(cpp_macro) + macro->count * sizeof(cpp_token),
- sizeof(cpp_token)
- );
- macro->exp.tokens[macro->count] = *token;
- #if DebugParseClause
- fprintf( stderr, "token: %s\n", cpp_token_as_text(token) );
- #endif
-
- // lexer supports line macros by inserting CPP_EOF at line ends
- if(delimiter_matching && token->type == CPP_EOF){
- #if DebugParseClause
- fprintf( stderr, "CPP_EOF during parse with parentheses matching \n");
- #endif
- if(!_cpp_get_fresh_line(pfile)){
- return PCS_ERR_EOF_FETCH_FAILED;
- }
- continue;
- }
-
- /* parentheses matching overhead
- */
- if(delimiter_matching){
-
- if (token->type == opening) {
- nesting_depth++;
- }
- else if (token->type == closing) {
- nesting_depth--;
- if (nesting_depth < 0) {
- cpp_error(pfile, CPP_DL_ERROR, "unmatched closing delimiter");
- return PCS_ERR_UNEXPECTED_EOF;
- }
- }
-
- #if DebugParseClause
- if( token->type == opening || token->type == closing){
- fprintf( stderr, "new nesting_depth: %d\n", nesting_depth);
- }
- #endif
- }
-
-
- /* Determine if routine has lexed the final macro body token and should exit.
- */
- bool terminted_by_matched_delimiter =
- delimiter_matching
- && nesting_depth == 0
- && (token->type == closing || comma_list && token->type == CPP_COMMA)
- ;
-
- bool terminated_by_EOL =
- !delimiter_matching
- && (token->type == CPP_EOF || comma_list && token->type == CPP_COMMA)
- ;
-
- if(terminted_by_matched_delimiter || terminated_by_EOL){
- if(terminator_out) *terminator_out = token->type;
- return PCS_COMPLETE;
- }
-
- // commit the new token
- macro->count++;
-
- }// end for next token loop
-
-}
-
-bool cgls_flag = false;
-
-/*
- See notes on parse_clause_expand
-
- This is the same but tokens in the clause are not expanded.
-
- The end case tests here probably need to badded to parse_clause_expand also.
- Perhaps expansion can be another mode bit to be sent int.
-
- I would have been better perhaps to send in a pointer to a token allocation,
- instead of to a src_loc, and and terminal type.
-*/
-static enum parse_clause_status parse_clause_literal(
- cpp_reader *pfile
- ,cpp_macro *macro
- ,bool delimiter_matching
- ,enum cpp_ttype opening
- ,enum cpp_ttype closing
- ,bool comma_list
- ,location_t *src_loc_pt
- ,cpp_ttype *terminator_out
- ,unsigned int *num_extra_tokens_out
-){
- #if DebugParseClause
- fprintf(stderr, ">> parse_clause_literal\n");
- fprintf(stderr, " delimiter_matching: %s\n", delimiter_matching ? "true" : "false");
- fprintf(stderr, " opening token: %s (%d)\n", ttype_to_text(opening), opening);
- fprintf(stderr, " closing token: %s (%d)\n", ttype_to_text(closing), closing);
- fprintf(stderr, " comma_list: %s\n", comma_list ? "true" : "false");
- fprintf(stderr, " src_loc_pt: %p\n", (void *)src_loc_pt);
- #endif
-
- bool following_paste_op = false;
- unsigned int num_extra_tokens = 0;
- int nesting_depth = 1;
- cpp_token *lex_token;
- const char *paste_op_error_msg =
- N_("'##' cannot appear at either end of a macro expansion");
-
-
- for(vaopt_state vaopt_tracker (pfile, macro->variadic, NULL);;){
-
- /* get a token
- */
- // first parses lex_token onto `macro->exp.tokens[macro->count]`
- // then pulls the token off of `macro->exp.tokens[macro->count]`
- // reassigns macro due to possible macro->exp.tokens buffer expansion
- macro = lex_expansion_token(pfile, macro);
- lex_token = ¯o->exp.tokens[macro->count];
- *src_loc_pt = lex_token->src_loc;
- #if DebugParseClause
- fprintf( stderr, "lex_token: %s\n", cpp_token_as_text(lex_token) );
- #endif
-
- // lexer will insert CPP_EOF at the end of each line, because cpp originally only did line macros.
- if(delimiter_matching && lex_token->type == CPP_EOF){
- #if DebugParseClause
- fprintf( stderr, "CPP_EOF during parse with parentheses matching \n");
- #endif
- if(!_cpp_get_fresh_line(pfile)){
- return PCS_ERR_EOF_FETCH_FAILED;
- }
- continue;
- }
-
- /* tag macro args
- */
- if (macro->count > 1 && lex_token[-1].type == CPP_HASH && macro->fun_like)
- {
- if (lex_token->type == CPP_MACRO_ARG
- || (macro->variadic
- && lex_token->type == CPP_NAME
- && lex_token->val.node.node == pfile->spec_nodes.n__VA_OPT__))
- {
- if (lex_token->flags & PREV_WHITE)
- lex_token->flags |= SP_PREV_WHITE;
- if (lex_token[-1].flags & DIGRAPH)
- lex_token->flags |= SP_DIGRAPH;
- lex_token->flags &= ~PREV_WHITE;
- lex_token->flags |= STRINGIFY_ARG;
- lex_token->flags |= lex_token[-1].flags & PREV_WHITE;
- lex_token[-1] = lex_token[0];
- macro->count--;
- }
- else if (CPP_OPTION (pfile, lang) != CLK_ASM)
- {
- cpp_error(pfile, CPP_DL_ERROR,
- "'#' is not followed by a macro parameter");
- return PCS_ERR_HASH_NOT_FOLLOWED_BY_ARG;
- }
- }
-
- /* paste end cases
- */
- if (lex_token->type == CPP_PASTE)
- {
- if (macro->count == 0)
- {
- cpp_error(pfile, CPP_DL_ERROR, paste_op_error_msg);
- return PCS_ERR_PASTE_AT_END; // the font end of the buffer
- }
-
- if (following_paste_op)
- {
- num_extra_tokens++;
- lex_token->val.token_no = macro->count - 1;
- }
- else
- {
- --macro->count;
- lex_token[-1].flags |= PASTE_LEFT;
- if (lex_token->flags & DIGRAPH)
- lex_token[-1].flags |= SP_DIGRAPH;
- if (lex_token->flags & PREV_WHITE)
- lex_token[-1].flags |= SP_PREV_WHITE;
- }
- following_paste_op = true;
- }
- else{
- following_paste_op = false;
- }
-
- /* parentheses matching overhead
- */
- if(delimiter_matching){
-
- if (lex_token->type == opening) {
- nesting_depth++;
- }
- else if (lex_token->type == closing) {
- nesting_depth--;
- if (nesting_depth < 0) {
- cpp_error(pfile, CPP_DL_ERROR, "unmatched closing delimiter");
- return PCS_ERR_UNEXPECTED_EOF;
- }
- }
-
- #if DebugParseClause
- if( lex_token->type == opening || lex_token->type == closing){
- fprintf( stderr, "new nesting_depth: %d\n", nesting_depth);
- }
- #endif
- }
-
- /* Determine if routine has lexed the final macro body token and should exit.
- */
- bool terminated_by_matched_delimiter =
- delimiter_matching
- && nesting_depth == 0
- && (lex_token->type == closing || comma_list && lex_token->type == CPP_COMMA)
- ;
-
- bool terminated_by_EOL =
- !delimiter_matching
- && (lex_token->type == CPP_EOF || comma_list && lex_token->type == CPP_COMMA)
- ;
-
- if(terminated_by_matched_delimiter || terminated_by_EOL){
-
- if(following_paste_op){
- cpp_error(pfile, CPP_DL_ERROR, paste_op_error_msg);
- return PCS_ERR_PASTE_AT_END;
- }
- if (vaopt_tracker.update(lex_token) == vaopt_state::ERROR){
- return PCS_ERR_VAOPT_STATE_INVALID;
- }
- if( !vaopt_tracker.completed() ){
- return PCS_ERR_VAOPT_STATE_INVALID;
- }
-
- if(num_extra_tokens_out) *num_extra_tokens_out = num_extra_tokens;
- if(terminator_out) *terminator_out = lex_token->type;
- return PCS_COMPLETE;
- }
-
- // commit the new token
- macro->count++;
-
- }// end for next token loop
-
-}
-
-/*
- The opening paren has been parsed, this completes parsing the clause.
-
- Given a cpp_macro and cpp_reader reference.
- Returns the body tokens in `macro->exp.tokens`.
-
- The macro need not have been committed.
-*/
-
-static enum parse_clause_status parse_clause_balanced(
- cpp_reader *pfile
- ,cpp_macro *macro
- ,enum cpp_ttype opening
- ,enum cpp_ttype closing
- ,bool expand
- ,bool comma_list
- ,location_t *src_loc_pt
- ,cpp_ttype *terminator_out
- ,unsigned int *num_extra_tokens_out
-){
- #if DebugParseClause
- fprintf(stderr, ">> parse_clause_balanced\n");
- fprintf(stderr, " opening token: %s (%d)\n", ttype_to_text(opening), opening);
- fprintf(stderr, " closing token: %s (%d)\n", ttype_to_text(closing), closing);
- fprintf(stderr, " comma_list: %s\n", comma_list ? "true" : "false");
- fprintf(stderr, " expand: %s\n", expand ? "true" : "false");
- fprintf(stderr, " src_loc_pt: %p\n", (void *)src_loc_pt);
- #endif
-
- /* check for opening paren
- */
- const cpp_token *token = _cpp_lex_token(pfile);
- *src_loc_pt = token->src_loc;
- #if DebugParseClause
- fprintf(stderr, "checking if token is opening: %s" ,cpp_token_as_text(token));
- #endif
-
- if( token->type != opening ){
- _cpp_backup_tokens(pfile, 1);
- return PCS_ERR_EXPECTED_OPEN_DELIM;
- }
-
- /* complete the parse
- */
-
- // make comma an alias for the terminating delimiter
- // this gets passed on directly to parse_clause_{literal,expand}
- bool delimiter_matching = true;
-
- int saved_keep_tokens = pfile->keep_tokens;
- int saved_in_directive = pfile->state.in_directive;
- pfile->keep_tokens = 1;
- pfile->state.in_directive = 0;
-
- parse_clause_status status;
- if(expand){
- status = parse_clause_expand
- (pfile
- ,macro
- ,delimiter_matching
- ,opening ,closing
- ,comma_list
- ,src_loc_pt
- ,terminator_out
- );
- if(num_extra_tokens_out) *num_extra_tokens_out = 0;
- #if DebugParseClause
- fprintf(stderr, ">> parse_clause_balanced expand status:");
- print_parse_clause_status(status);
- #endif
- }else{
- status = parse_clause_literal
- (pfile
- ,macro
- ,delimiter_matching
- ,opening ,closing
- ,comma_list
- ,src_loc_pt
- ,terminator_out
- ,num_extra_tokens_out
- );
- #if DebugParseClause
- fprintf(stderr, ">> parse_clause_balanced literal status:");
- print_parse_clause_status(status);
- #endif
- }
-
- // Restore parser state
- pfile->keep_tokens = saved_keep_tokens;
- pfile->state.in_directive = saved_in_directive;
-
- #if DebugParseClause
- fprintf(stderr, ">> parse_clause_balanced final returning status:");
- print_parse_clause_status(status);
- #endif
- return status;
-}
-
-typedef enum PCPSO_choice{
- PCPSO_unknown = 0
- ,PCPSO_paren
- ,PCPSO_square
-} PCPSO_choice;
-
-parse_clause_status parse_clause_paren_square_option(
- cpp_reader *pfile
- ,cpp_macro *macro
- ,PCPSO_choice *choice
- ,bool comma_list
- ,location_t *src_loc_pt
- ,cpp_ttype *terminator_out
- ,unsigned int *num_extra_tokens_out
-){
- #if DebugParseClause
- fprintf(stderr, ">> parse_clause_paren_square_option\n");
- fprintf(stderr, " comma_list: %s\n", comma_list ? "true" : "false");
- fprintf(stderr, " src_loc_pt: %p\n", (void *)src_loc_pt);
- #endif
-
- *choice = PCPSO_unknown;
-
- parse_clause_status status = parse_clause_balanced
- (pfile
- ,macro
- ,CPP_OPEN_PAREN
- ,CPP_CLOSE_PAREN
- ,false // no expand
- ,comma_list
- ,src_loc_pt
- ,terminator_out
- ,num_extra_tokens_out
- );
-
- if(status != PCS_ERR_EXPECTED_OPEN_DELIM){
- *choice = PCPSO_paren;
- return status;
- }
-
- status = parse_clause_balanced
- (pfile
- ,macro
- ,CPP_OPEN_SQUARE
- ,CPP_CLOSE_SQUARE
- ,true // expand
- ,comma_list
- ,src_loc_pt
- ,terminator_out
- ,num_extra_tokens_out
- );
-
- if(status == PCS_ERR_EXPECTED_OPEN_DELIM){
- #if DebugParseClause
- fprintf(stderr, ">> parse_clause_paren_square_option early returning status:");
- print_parse_clause_status(PCS_ERR_EXPECTED_OPEN_DELIM);
- #endif
- return PCS_ERR_EXPECTED_OPEN_DELIM;
- }
-
- *choice = PCPSO_square;
-
- #if DebugParseClause
- fprintf(stderr, ">> parse_clause_paren_square_option final returning status:");
- print_parse_clause_status(status);
- #endif
- return status;
-}
-
-/*
-The prior clause parse terminated in a comma. For parsing a comma list of clauses.
-*/
-static enum parse_clause_status parse_clause_comma_continue(
-){
- return PCS_ERR_UNKNOWN;
-}
-
-/*
- Check if a collected macro body reduces to a single identifier token.
-
- Preconditions:
- - macro is non-null
- - macro->exp.tokens has been populated (e.g., via parse_clause)
- - macro->count is valid
-
- Returns:
- - cpp_hashnode* if valid (i.e., single CPP_NAME token)
- - NULL if invalid, and emits error message
-
-
-Note in do_define in directives.cc there is some logic related to callbacks and warning if trying to redefine a built-in macro. That should be integrated here.
-
-
-*/
-static cpp_hashnode *
-name_clause_is_name(cpp_reader *pfile, const cpp_macro *macro)
-{
- if (!macro || macro->count != 1)
- {
- cpp_error(pfile, CPP_DL_ERROR,
- "expected exactly one token in assign name expression, got %u",
- macro ? macro->count : 0);
- return NULL;
- }
-
- const cpp_token *tok = ¯o->exp.tokens[0];
-
- if (tok->type != CPP_NAME)
- {
- cpp_error(pfile, CPP_DL_ERROR,
- "expected identifier in assign name expression, got: %s",
- cpp_token_as_text(tok));
- return NULL;
- }
-
- return tok->val.node.node;
-}
-
-
-/*--------------------------------------------------------------------------------
- `#assign` directive RT extension
-
- called from directives.cc::do_assign()
-
-*/
-
-bool _cpp_create_assign(cpp_reader *pfile){
-
- parse_clause_status status;
- location_t src_loc;
- unsigned int num_extra_tokens = 0;
- PCPSO_choice choice;
-
- /* Parse name clause into a temporary macro.
-
- This macro will not be committed, so it will be overwritten on the next _cpp_new_macro call.
- */
- cpp_macro *name_macro = _cpp_new_macro(
- pfile
- ,cmk_macro
- ,_cpp_reserve_room( pfile, 0, sizeof(cpp_macro) )
- );
- name_macro->variadic = false;
- name_macro->paramc = 0;
- name_macro->parm.params = NULL;
- name_macro->fun_like = false;
-
- status = parse_clause_paren_square_option(
- pfile
- ,name_macro
- ,&choice
- ,false // not a commas list
- ,&src_loc
- ,NULL // don't need to know the terminator
- ,&num_extra_tokens
- );
-
-
- #if DebugAssign
- fprintf(stderr,"name_macro->count: %d\n" ,name_macro->count);
- fprintf(stderr,"assign directive name tokens:\n");
- print_token_list(name_macro->exp.tokens ,name_macro->count);
- #endif
-
- /* The name clause must be either a literally valid name, or it must expand into
- a valid name, depending if the programmer used () or [].
- If valid, keep the name node.
- */
- cpp_hashnode *name_node = name_clause_is_name(pfile ,name_macro);
- if(name_node){
- #if DebugAssign
- fprintf(
- stderr
- ,"assign macro name: '%.*s'\n"
- ,(int) NODE_LEN(name_node)
- ,NODE_NAME(name_node)
- );
- #endif
- }else{
- #if DebugAssign
- fprintf(stderr, "node is not a name\n");
- #endif
- return false;
- }
-
- /* Unpaint name_node
-
- There are three scenarios where name_node will already exist in the symbol table
- before the name clause of `#assign` is evaluated:
-
- 1. A macro definition already exists for name_node, and the name clause
- is not expanded (i.e., it was delineated with '()').
-
- 2. A macro definition exists, and the name clause *is* expanded (i.e., it
- was delineated with '[]'), but name_node was painted and thus skipped
- during expansion.
-
- 3. A macro definition exists and was not painted initially, but the name
- clause expands recursively to itself (e.g., `list -> list`), resulting
- in name_node being painted *during* the name clause evaluation.
-
- After the name clause is parsed, the body clause might be expanded. If so,
- name_node must not be painted — this ensures that it will expand at least once. This enables patterns like:
-
- #assign ()(list)(list second)
-
- ...to work even if 'list' was painted prior to entering #assign.
-
- If the macro recurs during evaluation of the body clause, it will be automatically painted by the expansion engine, as usual.
-
- Note also: upon exit from this routine, the newly created macro will *not* be painted. Its disabled flag will remain clear.
-
- Consequently, for a recursive macro, assign can be called repeatedly to get 'one more level' of evaluation upon each call.
- */
- if (cpp_macro_p(name_node)) {
- name_node->flags &= ~NODE_DISABLED;
- }
-
- /* create a new macro and put the #assign body clause in it
- */
- cpp_macro *body_macro = _cpp_new_macro(
- pfile
- ,cmk_macro
- ,_cpp_reserve_room( pfile, 0, sizeof(cpp_macro) )
- );
- body_macro->variadic = false;
- body_macro->paramc = 0;
- body_macro->parm.params = NULL;
- body_macro->fun_like = false;
-
- status = parse_clause_paren_square_option(
- pfile
- ,body_macro
- ,&choice
- ,false // not a commas list
- ,&src_loc
- ,NULL // don't need to know the terminator
- ,&num_extra_tokens
- );
- #if DebugAssign
- fprintf(stderr,"assign directive body tokens:\n");
- print_token_list(body_macro->exp.tokens ,body_macro->count);
- #endif
-
-
- cpp_macro *assign_macro = (cpp_macro *)_cpp_commit_buff(
- pfile
- ,sizeof(cpp_macro) - sizeof(cpp_token) + sizeof(cpp_token) * body_macro->count
- );
- assign_macro->count = body_macro->count;
- memcpy(
- assign_macro->exp.tokens
- ,body_macro->exp.tokens
- ,sizeof(cpp_token) * body_macro->count
- );
- body_macro->variadic = false;
- body_macro->paramc = 0;
- body_macro->parm.params = NULL;
- body_macro->fun_like = false;
-
- /* Install the assign macro under name_node.
-
- If name_node previously had a macro definition, discard it.
- Then install the new macro, and clear any disabled flag.
-
- This ensures the assigned macro can be expanded immediately,
- even if it appeared in its own body clause and was painted.
- */
- name_node->flags &= ~NODE_USED;
-
- if (cpp_macro_p(name_node)) {
- // There is no mechanism in libcpp to free the memory taken by a committed macro, but wec an cast it adrift.
- name_node->value.macro = NULL;
- }
- name_node->type = NT_USER_MACRO;
- name_node->value.macro = assign_macro;
- name_node->flags &= ~NODE_DISABLED;
-
- /* all done
- */
- #if DebugAssign
- fprintf(
- stderr
- ,"macro '%.*s' assigned successfully.\n\n"
- ,(int) NODE_LEN(name_node)
- ,NODE_NAME(name_node)
- );
- #endif
-
- return true;
-
-}
-
-/*--------------------------------------------------------------------------------
- `#macro` directive RT extension
-
- Given a pfile, returns a macro definition.
-
- #macro name (parameter [,parameter] ...) (body_expr)
- #macro name () (body_expr)
-
- Upon entry, the name was already been parsed in directives.cc::do_macro, so the next token will be the opening paren of the parameter list.
-
- Thi code is similar to `_cpp_create_definition` though uses paren blancing around the body, instead of requiring the macro body be on a single line.
-
- The cpp_macro struct is defined in cpplib.h: `struct GTY(()) cpp_macro {` it has a flexible array field in a union as a last member: cpp_token tokens[1];
-
- This code was derived from create_iso_definition(). The break out portions shared
- with create_macro_definition code should be shared with the main code, so that there
- is only one place for edits.
-
-*/
-static cpp_macro *create_rt_macro (cpp_reader *pfile){
-
- #if DebugRTMacro
- fprintf(stderr,"entering create_rt_macro\n");
- #endif
-
- unsigned int num_extra_tokens = 0;
- unsigned paramc = 0;
- cpp_hashnode **params = NULL;
- bool varadic = false;
- bool ok = false;
- cpp_macro *macro = NULL;
- parse_clause_status status;
-
- /* parse parameter list
-
- after parse_parms runs, the next token returned by pfile will be subsequent to the parameter list, e.g.:
- 7 | #macro Q(f ,...) printf(f ,__VA_ARGS__)
- | ^~~~~~
- */
- const cpp_token *token = _cpp_lex_token(pfile);
- location_t src_loc = token->src_loc;
-
- if(token->type != CPP_OPEN_PAREN){
- cpp_error_with_line(
- pfile
- ,CPP_DL_ERROR
- ,src_loc
- ,0
- ,"expected '(' to open arguments list, but found: %s"
- ,cpp_token_as_text(token)
- );
- goto out;
- }
-
- if( !parse_params(pfile, ¶mc, &varadic) ) goto out;
-
- // finalizes the reserved room, otherwise it will be reused on the next reserve room call.
- params = (cpp_hashnode **)_cpp_commit_buff( pfile, sizeof (cpp_hashnode *) * paramc );
- token = NULL;
-
- /* parse body macro
-
- A macro struct instance is variable size, due to tokens added to the macro.exp.tokens
- during parse, and possible reallocations.
-
- Function like macros will later need space to hold parameter values.
- */
- macro = _cpp_new_macro(
- pfile
- ,cmk_macro
- ,_cpp_reserve_room( pfile, 0, sizeof(cpp_macro) )
- );
- // used by parse_clause_literal
- macro->variadic = varadic;
- macro->paramc = paramc;
- macro->parm.params = params;
- macro->fun_like = true;
-
- PCPSO_choice choice;
- status = parse_clause_paren_square_option(
- pfile
- ,macro
- ,&choice
- ,false // not a commas list
- ,&src_loc
- ,NULL // don't need to know the terminator
- ,&num_extra_tokens
- );
- if( status != PCS_COMPLETE ){
- fprintf(stderr, "parse_paren_clause returned: ");
- print_parse_clause_status(status);
- goto out;
- }
-
- #if DebugRTMacro
- fprintf(stderr,"rt_macro directive body tokens:\n");
- print_token_list(macro->exp.tokens ,macro->count);
- #endif
-
- // commit the macro, attach the parameter list
- ok = true;
- macro = (cpp_macro *)_cpp_commit_buff(
- pfile
- ,
- sizeof (cpp_macro)
- - sizeof (cpp_token)
- + sizeof (cpp_token) * macro->count
- + sizeof(cpp_hashnode *) * paramc
- );
- macro->variadic = varadic;
- macro->paramc = paramc;
- macro->parm.params = params;
- macro->fun_like = true;
-
- /* some end cases we must clean up
- */
- /*
- It might be that the first token of the macro body was preceded by white space, so
- the white space flag is set. However, upon expansion, there might not be a white
- space before said token, so the following code clears the flag.
- */
- if (macro->count)
- macro->exp.tokens[0].flags &= ~PREV_WHITE;
-
- /*
- Identifies consecutive ## tokens (a.k.a. CPP_PASTE) that were invalid or ambiguous,
-
- Removes them from the main macro body,
-
- Stashes them at the end of the tokens[] array in the same memory,
-
- Sets macro->extra_tokens = 1 to signal their presence.
- */
- if (num_extra_tokens)
- {
- /* Place second and subsequent ## or %:%: tokens in sequences of
- consecutive such tokens at the end of the list to preserve
- information about where they appear, how they are spelt and
- whether they are preceded by whitespace without otherwise
- interfering with macro expansion. Remember, this is
- extremely rare, so efficiency is not a priority. */
- cpp_token *temp = (cpp_token *)_cpp_reserve_room
- (pfile, 0, num_extra_tokens * sizeof (cpp_token));
- unsigned extra_ix = 0, norm_ix = 0;
- cpp_token *exp = macro->exp.tokens;
- for (unsigned ix = 0; ix != macro->count; ix++)
- if (exp[ix].type == CPP_PASTE)
- temp[extra_ix++] = exp[ix];
- else
- exp[norm_ix++] = exp[ix];
- memcpy (&exp[norm_ix], temp, num_extra_tokens * sizeof (cpp_token));
-
- /* Record there are extra tokens. */
- macro->extra_tokens = 1;
- }
-
- out:
-
- /*
- - This resets a flag in the parser’s state machine, pfile.
- - The field `va_args_ok` tracks whether the current macro body is allowed to reference `__VA_ARGS__` (or more precisely, `__VA_OPT__`).
- - It's set **while parsing a macro body** that might use variadic logic — particularly in `vaopt_state` tracking.
-
- Resetting it here ensures that future macros aren't accidentally parsed under the assumption that variadic substitution is valid.
- */
- pfile->state.va_args_ok = 0;
-
- /*
- Earlier we did:
- if (!parse_params(pfile, ¶mc, &variadic)) goto out;
- This cleans up temporary memory used by parse_params.
- */
- _cpp_unsave_parameters (pfile, paramc);
-
- return ok ? macro : NULL;
-
-}
-
-/*
- called from directives.cc:: do_macro
-*/
-bool
-_cpp_create_rt_macro(cpp_reader *pfile, cpp_hashnode *node){
-
- #if DebugRTMacro
- fprintf(stderr,"entering _cpp_create_macro\n");
- #endif
-
- cpp_macro *macro;
- macro = create_rt_macro (pfile);
-
- if (!macro)
- return false;
-
- if (cpp_macro_p (node))
- {
- if (CPP_OPTION (pfile, warn_unused_macros))
- _cpp_warn_if_unused_macro (pfile, node, NULL);
-
- if (warn_of_redefinition (pfile, node, macro))
- {
- const enum cpp_warning_reason reason
- = (cpp_builtin_macro_p (node) && !(node->flags & NODE_WARN))
- ? CPP_W_BUILTIN_MACRO_REDEFINED : CPP_W_NONE;
-
- bool warned =
- cpp_pedwarning_with_line (pfile, reason,
- pfile->directive_line, 0,
- "\"%s\" redefined", NODE_NAME (node));
-
- if (warned && cpp_user_macro_p (node))
- cpp_error_with_line (pfile, CPP_DL_NOTE,
- node->value.macro->line, 0,
- "this is the location of the previous definition");
- }
- _cpp_free_definition (node);
- }
-
- /* Enter definition in hash table. */
- node->type = NT_USER_MACRO;
- node->value.macro = macro;
- if (! ustrncmp (NODE_NAME (node), DSC ("__STDC_"))
- && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_FORMAT_MACROS")
- /* __STDC_LIMIT_MACROS and __STDC_CONSTANT_MACROS are mentioned
- in the C standard, as something that one must use in C++.
- However DR#593 and C++11 indicate that they play no role in C++.
- We special-case them anyway. */
- && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_LIMIT_MACROS")
- && ustrcmp (NODE_NAME (node), (const uchar *) "__STDC_CONSTANT_MACROS"))
- node->flags |= NODE_WARN;
-
- /* If user defines one of the conditional macros, remove the
- conditional flag */
- node->flags &= ~NODE_CONDITIONAL;
-
- return true;
-}
-
-/*--------------------------------------------------------------------------------
- builtin RT_CAT macro RT extension
-
-*/
-
-static const uchar *evaluate_RT_CAT(cpp_reader *pfile){
- return UC"XY";
-}
--- /dev/null
+/* Definitions for CPP library.
+ Copyright (C) 1995-2022 Free Software Foundation, Inc.
+ Written by Per Bothner, 1994-95.
+
+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! */
+#ifndef LIBCPP_CPPLIB_H
+#define LIBCPP_CPPLIB_H
+
+#include <sys/types.h>
+#include "symtab.h"
+#include "line-map.h"
+
+typedef struct cpp_reader cpp_reader;
+typedef struct cpp_buffer cpp_buffer;
+typedef struct cpp_options cpp_options;
+typedef struct cpp_token cpp_token;
+typedef struct cpp_string cpp_string;
+typedef struct cpp_hashnode cpp_hashnode;
+typedef struct cpp_macro cpp_macro;
+typedef struct cpp_callbacks cpp_callbacks;
+typedef struct cpp_dir cpp_dir;
+
+struct _cpp_file;
+
+/* The first three groups, apart from '=', can appear in preprocessor
+ expressions (+= and -= are used to indicate unary + and - resp.).
+ This allows a lookup table to be implemented in _cpp_parse_expr.
+
+ The first group, to CPP_LAST_EQ, can be immediately followed by an
+ '='. The lexer needs operators ending in '=', like ">>=", to be in
+ the same order as their counterparts without the '=', like ">>".
+
+ See the cpp_operator table optab in expr.cc if you change the order or
+ add or remove anything in the first group. */
+
+#define TTYPE_TABLE \
+ OP(EQ, "=") \
+ OP(NOT, "!") \
+ OP(GREATER, ">") /* compare */ \
+ OP(LESS, "<") \
+ OP(PLUS, "+") /* math */ \
+ OP(MINUS, "-") \
+ OP(MULT, "*") \
+ OP(DIV, "/") \
+ OP(MOD, "%") \
+ OP(AND, "&") /* bit ops */ \
+ OP(OR, "|") \
+ OP(XOR, "^") \
+ OP(RSHIFT, ">>") \
+ OP(LSHIFT, "<<") \
+ \
+ OP(COMPL, "~") \
+ OP(AND_AND, "&&") /* logical */ \
+ OP(OR_OR, "||") \
+ OP(QUERY, "?") \
+ OP(COLON, ":") \
+ OP(COMMA, ",") /* grouping */ \
+ OP(OPEN_PAREN, "(") \
+ OP(CLOSE_PAREN, ")") \
+ TK(EOF, NONE) \
+ OP(EQ_EQ, "==") /* compare */ \
+ OP(NOT_EQ, "!=") \
+ OP(GREATER_EQ, ">=") \
+ OP(LESS_EQ, "<=") \
+ OP(SPACESHIP, "<=>") \
+ \
+ /* These two are unary + / - in preprocessor expressions. */ \
+ OP(PLUS_EQ, "+=") /* math */ \
+ OP(MINUS_EQ, "-=") \
+ \
+ OP(MULT_EQ, "*=") \
+ OP(DIV_EQ, "/=") \
+ OP(MOD_EQ, "%=") \
+ OP(AND_EQ, "&=") /* bit ops */ \
+ OP(OR_EQ, "|=") \
+ OP(XOR_EQ, "^=") \
+ OP(RSHIFT_EQ, ">>=") \
+ OP(LSHIFT_EQ, "<<=") \
+ /* Digraphs together, beginning with CPP_FIRST_DIGRAPH. */ \
+ OP(HASH, "#") /* digraphs */ \
+ OP(PASTE, "##") \
+ OP(OPEN_SQUARE, "[") \
+ OP(CLOSE_SQUARE, "]") \
+ OP(OPEN_BRACE, "{") \
+ OP(CLOSE_BRACE, "}") \
+ /* The remainder of the punctuation. Order is not significant. */ \
+ OP(SEMICOLON, ";") /* structure */ \
+ OP(ELLIPSIS, "...") \
+ OP(PLUS_PLUS, "++") /* increment */ \
+ OP(MINUS_MINUS, "--") \
+ OP(DEREF, "->") /* accessors */ \
+ OP(DOT, ".") \
+ OP(SCOPE, "::") \
+ OP(DEREF_STAR, "->*") \
+ OP(DOT_STAR, ".*") \
+ OP(ATSIGN, "@") /* used in Objective-C */ \
+ \
+ TK(NAME, IDENT) /* word */ \
+ TK(AT_NAME, IDENT) /* @word - Objective-C */ \
+ TK(NUMBER, LITERAL) /* 34_be+ta */ \
+ \
+ TK(CHAR, LITERAL) /* 'char' */ \
+ TK(WCHAR, LITERAL) /* L'char' */ \
+ TK(CHAR16, LITERAL) /* u'char' */ \
+ TK(CHAR32, LITERAL) /* U'char' */ \
+ TK(UTF8CHAR, LITERAL) /* u8'char' */ \
+ TK(OTHER, LITERAL) /* stray punctuation */ \
+ \
+ TK(STRING, LITERAL) /* "string" */ \
+ TK(WSTRING, LITERAL) /* L"string" */ \
+ TK(STRING16, LITERAL) /* u"string" */ \
+ TK(STRING32, LITERAL) /* U"string" */ \
+ TK(UTF8STRING, LITERAL) /* u8"string" */ \
+ TK(OBJC_STRING, LITERAL) /* @"string" - Objective-C */ \
+ TK(HEADER_NAME, LITERAL) /* <stdio.h> in #include */ \
+ \
+ TK(CHAR_USERDEF, LITERAL) /* 'char'_suffix - C++-0x */ \
+ TK(WCHAR_USERDEF, LITERAL) /* L'char'_suffix - C++-0x */ \
+ TK(CHAR16_USERDEF, LITERAL) /* u'char'_suffix - C++-0x */ \
+ TK(CHAR32_USERDEF, LITERAL) /* U'char'_suffix - C++-0x */ \
+ TK(UTF8CHAR_USERDEF, LITERAL) /* u8'char'_suffix - C++-0x */ \
+ TK(STRING_USERDEF, LITERAL) /* "string"_suffix - C++-0x */ \
+ TK(WSTRING_USERDEF, LITERAL) /* L"string"_suffix - C++-0x */ \
+ TK(STRING16_USERDEF, LITERAL) /* u"string"_suffix - C++-0x */ \
+ TK(STRING32_USERDEF, LITERAL) /* U"string"_suffix - C++-0x */ \
+ TK(UTF8STRING_USERDEF,LITERAL) /* u8"string"_suffix - C++-0x */ \
+ \
+ TK(COMMENT, LITERAL) /* Only if output comments. */ \
+ /* SPELL_LITERAL happens to DTRT. */ \
+ TK(MACRO_ARG, NONE) /* Macro argument. */ \
+ TK(PRAGMA, NONE) /* Only for deferred pragmas. */ \
+ TK(PRAGMA_EOL, NONE) /* End-of-line for deferred pragmas. */ \
+ TK(PADDING, NONE) /* Whitespace for -E. */
+
+#define OP(e, s) CPP_ ## e,
+#define TK(e, s) CPP_ ## e,
+enum cpp_ttype
+{
+ TTYPE_TABLE
+ N_TTYPES,
+
+ /* A token type for keywords, as opposed to ordinary identifiers. */
+ CPP_KEYWORD,
+
+ /* Positions in the table. */
+ CPP_LAST_EQ = CPP_LSHIFT,
+ CPP_FIRST_DIGRAPH = CPP_HASH,
+ CPP_LAST_PUNCTUATOR= CPP_ATSIGN,
+ CPP_LAST_CPP_OP = CPP_LESS_EQ
+};
+#undef OP
+#undef TK
+
+/* C language kind, used when calling cpp_create_reader. */
+enum c_lang {CLK_GNUC89 = 0, CLK_GNUC99, CLK_GNUC11, CLK_GNUC17, CLK_GNUC2X,
+ CLK_STDC89, CLK_STDC94, CLK_STDC99, CLK_STDC11, CLK_STDC17,
+ CLK_STDC2X,
+ CLK_GNUCXX, CLK_CXX98, CLK_GNUCXX11, CLK_CXX11,
+ CLK_GNUCXX14, CLK_CXX14, CLK_GNUCXX17, CLK_CXX17,
+ CLK_GNUCXX20, CLK_CXX20, CLK_GNUCXX23, CLK_CXX23,
+ CLK_ASM};
+
+/* Payload of a NUMBER, STRING, CHAR or COMMENT token. */
+struct GTY(()) cpp_string {
+ unsigned int len;
+ const unsigned char *text;
+};
+
+/* Flags for the cpp_token structure. */
+#define PREV_WHITE (1 << 0) /* If whitespace before this token. */
+#define DIGRAPH (1 << 1) /* If it was a digraph. */
+#define STRINGIFY_ARG (1 << 2) /* If macro argument to be stringified. */
+#define PASTE_LEFT (1 << 3) /* If on LHS of a ## operator. */
+#define NAMED_OP (1 << 4) /* C++ named operators. */
+#define PREV_FALLTHROUGH (1 << 5) /* On a token preceeded by FALLTHROUGH
+ comment. */
+#define BOL (1 << 6) /* Token at beginning of line. */
+#define PURE_ZERO (1 << 7) /* Single 0 digit, used by the C++ frontend,
+ set in c-lex.cc. */
+#define COLON_SCOPE PURE_ZERO /* Adjacent colons in C < 23. */
+#define SP_DIGRAPH (1 << 8) /* # or ## token was a digraph. */
+#define SP_PREV_WHITE (1 << 9) /* If whitespace before a ##
+ operator, or before this token
+ after a # operator. */
+#define NO_EXPAND (1 << 10) /* Do not macro-expand this token. */
+#define PRAGMA_OP (1 << 11) /* _Pragma token. */
+
+/* Specify which field, if any, of the cpp_token union is used. */
+
+enum cpp_token_fld_kind {
+ CPP_TOKEN_FLD_NODE,
+ CPP_TOKEN_FLD_SOURCE,
+ CPP_TOKEN_FLD_STR,
+ CPP_TOKEN_FLD_ARG_NO,
+ CPP_TOKEN_FLD_TOKEN_NO,
+ CPP_TOKEN_FLD_PRAGMA,
+ CPP_TOKEN_FLD_NONE
+};
+
+/* A macro argument in the cpp_token union. */
+struct GTY(()) cpp_macro_arg {
+ /* Argument number. */
+ unsigned int arg_no;
+ /* The original spelling of the macro argument token. */
+ cpp_hashnode *
+ GTY ((nested_ptr (union tree_node,
+ "%h ? CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT (%h)) : NULL",
+ "%h ? HT_IDENT_TO_GCC_IDENT (HT_NODE (%h)) : NULL")))
+ spelling;
+};
+
+/* An identifier in the cpp_token union. */
+struct GTY(()) cpp_identifier {
+ /* The canonical (UTF-8) spelling of the identifier. */
+ cpp_hashnode *
+ GTY ((nested_ptr (union tree_node,
+ "%h ? CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT (%h)) : NULL",
+ "%h ? HT_IDENT_TO_GCC_IDENT (HT_NODE (%h)) : NULL")))
+ node;
+ /* The original spelling of the identifier. */
+ cpp_hashnode *
+ GTY ((nested_ptr (union tree_node,
+ "%h ? CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT (%h)) : NULL",
+ "%h ? HT_IDENT_TO_GCC_IDENT (HT_NODE (%h)) : NULL")))
+ spelling;
+};
+
+/* A preprocessing token. This has been carefully packed and should
+ occupy 16 bytes on 32-bit hosts and 24 bytes on 64-bit hosts. */
+struct GTY(()) cpp_token {
+
+ /* Location of first char of token, together with range of full token. */
+ location_t src_loc;
+
+ ENUM_BITFIELD(cpp_ttype) type : CHAR_BIT; /* token type */
+ unsigned short flags; /* flags - see above */
+
+ union cpp_token_u
+ {
+ /* An identifier. */
+ struct cpp_identifier GTY ((tag ("CPP_TOKEN_FLD_NODE"))) node;
+
+ /* Inherit padding from this token. */
+ cpp_token * GTY ((tag ("CPP_TOKEN_FLD_SOURCE"))) source;
+
+ /* A string, or number. */
+ struct cpp_string GTY ((tag ("CPP_TOKEN_FLD_STR"))) str;
+
+ /* Argument no. (and original spelling) for a CPP_MACRO_ARG. */
+ struct cpp_macro_arg GTY ((tag ("CPP_TOKEN_FLD_ARG_NO"))) macro_arg;
+
+ /* Original token no. for a CPP_PASTE (from a sequence of
+ consecutive paste tokens in a macro expansion). */
+ unsigned int GTY ((tag ("CPP_TOKEN_FLD_TOKEN_NO"))) token_no;
+
+ /* Caller-supplied identifier for a CPP_PRAGMA. */
+ unsigned int GTY ((tag ("CPP_TOKEN_FLD_PRAGMA"))) pragma;
+ } GTY ((desc ("cpp_token_val_index (&%1)"))) val;
+};
+
+/* Say which field is in use. */
+extern enum cpp_token_fld_kind cpp_token_val_index (const cpp_token *tok);
+
+/* A type wide enough to hold any multibyte source character.
+ cpplib's character constant interpreter requires an unsigned type.
+ Also, a typedef for the signed equivalent.
+ The width of this type is capped at 32 bits; there do exist targets
+ where wchar_t is 64 bits, but only in a non-default mode, and there
+ would be no meaningful interpretation for a wchar_t value greater
+ than 2^32 anyway -- the widest wide-character encoding around is
+ ISO 10646, which stops at 2^31. */
+#if CHAR_BIT * SIZEOF_INT >= 32
+# define CPPCHAR_SIGNED_T int
+#elif CHAR_BIT * SIZEOF_LONG >= 32
+# define CPPCHAR_SIGNED_T long
+#else
+# error "Cannot find a least-32-bit signed integer type"
+#endif
+typedef unsigned CPPCHAR_SIGNED_T cppchar_t;
+typedef CPPCHAR_SIGNED_T cppchar_signed_t;
+
+/* Style of header dependencies to generate. */
+enum cpp_deps_style { DEPS_NONE = 0, DEPS_USER, DEPS_SYSTEM };
+
+/* The possible normalization levels, from most restrictive to least. */
+enum cpp_normalize_level {
+ /* In NFKC. */
+ normalized_KC = 0,
+ /* In NFC. */
+ normalized_C,
+ /* In NFC, except for subsequences where being in NFC would make
+ the identifier invalid. */
+ normalized_identifier_C,
+ /* Not normalized at all. */
+ normalized_none
+};
+
+enum cpp_main_search
+{
+ CMS_none, /* A regular source file. */
+ CMS_header, /* Is a directly-specified header file (eg PCH or
+ header-unit). */
+ CMS_user, /* Search the user INCLUDE path. */
+ CMS_system, /* Search the system INCLUDE path. */
+};
+
+/* The possible bidirectional control characters checking levels. */
+enum cpp_bidirectional_level {
+ /* No checking. */
+ bidirectional_none = 0,
+ /* Only detect unpaired uses of bidirectional control characters. */
+ bidirectional_unpaired = 1,
+ /* Detect any use of bidirectional control characters. */
+ bidirectional_any = 2,
+ /* Also warn about UCNs. */
+ bidirectional_ucn = 4
+};
+
+/* This structure is nested inside struct cpp_reader, and
+ carries all the options visible to the command line. */
+struct cpp_options
+{
+ /* The language we're preprocessing. */
+ enum c_lang lang;
+
+ /* Nonzero means use extra default include directories for C++. */
+ unsigned char cplusplus;
+
+ /* Nonzero means handle cplusplus style comments. */
+ unsigned char cplusplus_comments;
+
+ /* Nonzero means define __OBJC__, treat @ as a special token, use
+ the OBJC[PLUS]_INCLUDE_PATH environment variable, and allow
+ "#import". */
+ unsigned char objc;
+
+ /* Nonzero means don't copy comments into the output file. */
+ unsigned char discard_comments;
+
+ /* Nonzero means don't copy comments into the output file during
+ macro expansion. */
+ unsigned char discard_comments_in_macro_exp;
+
+ /* Nonzero means process the ISO trigraph sequences. */
+ unsigned char trigraphs;
+
+ /* Nonzero means process the ISO digraph sequences. */
+ unsigned char digraphs;
+
+ /* Nonzero means to allow hexadecimal floats and LL suffixes. */
+ unsigned char extended_numbers;
+
+ /* Nonzero means process u/U prefix literals (UTF-16/32). */
+ unsigned char uliterals;
+
+ /* Nonzero means process u8 prefixed character literals (UTF-8). */
+ unsigned char utf8_char_literals;
+
+ /* Nonzero means process r/R raw strings. If this is set, uliterals
+ must be set as well. */
+ unsigned char rliterals;
+
+ /* Nonzero means print names of header files (-H). */
+ unsigned char print_include_names;
+
+ /* Nonzero means complain about deprecated features. */
+ unsigned char cpp_warn_deprecated;
+
+ /* Nonzero means warn if slash-star appears in a comment. */
+ unsigned char warn_comments;
+
+ /* Nonzero means to warn about __DATA__, __TIME__ and __TIMESTAMP__ usage. */
+ unsigned char warn_date_time;
+
+ /* Nonzero means warn if a user-supplied include directory does not
+ exist. */
+ unsigned char warn_missing_include_dirs;
+
+ /* Nonzero means warn if there are any trigraphs. */
+ unsigned char warn_trigraphs;
+
+ /* Nonzero means warn about multicharacter charconsts. */
+ unsigned char warn_multichar;
+
+ /* Nonzero means warn about various incompatibilities with
+ traditional C. */
+ unsigned char cpp_warn_traditional;
+
+ /* Nonzero means warn about long long numeric constants. */
+ unsigned char cpp_warn_long_long;
+
+ /* Nonzero means warn about text after an #endif (or #else). */
+ unsigned char warn_endif_labels;
+
+ /* Nonzero means warn about implicit sign changes owing to integer
+ promotions. */
+ unsigned char warn_num_sign_change;
+
+ /* Zero means don't warn about __VA_ARGS__ usage in c89 pedantic mode.
+ Presumably the usage is protected by the appropriate #ifdef. */
+ unsigned char warn_variadic_macros;
+
+ /* Nonzero means warn about builtin macros that are redefined or
+ explicitly undefined. */
+ unsigned char warn_builtin_macro_redefined;
+
+ /* Different -Wimplicit-fallthrough= levels. */
+ unsigned char cpp_warn_implicit_fallthrough;
+
+ /* Nonzero means we should look for header.gcc files that remap file
+ names. */
+ unsigned char remap;
+
+ /* Zero means dollar signs are punctuation. */
+ unsigned char dollars_in_ident;
+
+ /* Nonzero means UCNs are accepted in identifiers. */
+ unsigned char extended_identifiers;
+
+ /* True if we should warn about dollars in identifiers or numbers
+ for this translation unit. */
+ unsigned char warn_dollars;
+
+ /* Nonzero means warn if undefined identifiers are evaluated in an #if. */
+ unsigned char warn_undef;
+
+ /* Nonzero means warn if "defined" is encountered in a place other than
+ an #if. */
+ unsigned char warn_expansion_to_defined;
+
+ /* Nonzero means warn of unused macros from the main file. */
+ unsigned char warn_unused_macros;
+
+ /* Nonzero for the 1999 C Standard, including corrigenda and amendments. */
+ unsigned char c99;
+
+ /* Nonzero if we are conforming to a specific C or C++ standard. */
+ unsigned char std;
+
+ /* Nonzero means give all the error messages the ANSI standard requires. */
+ unsigned char cpp_pedantic;
+
+ /* Nonzero means we're looking at already preprocessed code, so don't
+ bother trying to do macro expansion and whatnot. */
+ unsigned char preprocessed;
+
+ /* Nonzero means we are going to emit debugging logs during
+ preprocessing. */
+ unsigned char debug;
+
+ /* Nonzero means we are tracking locations of tokens involved in
+ macro expansion. 1 Means we track the location in degraded mode
+ where we do not track locations of tokens resulting from the
+ expansion of arguments of function-like macro. 2 Means we do
+ track all macro expansions. This last option is the one that
+ consumes the highest amount of memory. */
+ unsigned char track_macro_expansion;
+
+ /* Nonzero means handle C++ alternate operator names. */
+ unsigned char operator_names;
+
+ /* Nonzero means warn about use of C++ alternate operator names. */
+ unsigned char warn_cxx_operator_names;
+
+ /* True for traditional preprocessing. */
+ unsigned char traditional;
+
+ /* Nonzero for C++ 2011 Standard user-defined literals. */
+ unsigned char user_literals;
+
+ /* Nonzero means warn when a string or character literal is followed by a
+ ud-suffix which does not beging with an underscore. */
+ unsigned char warn_literal_suffix;
+
+ /* Nonzero means interpret imaginary, fixed-point, or other gnu extension
+ literal number suffixes as user-defined literal number suffixes. */
+ unsigned char ext_numeric_literals;
+
+ /* Nonzero means extended identifiers allow the characters specified
+ in C11. */
+ unsigned char c11_identifiers;
+
+ /* Nonzero for C++ 2014 Standard binary constants. */
+ unsigned char binary_constants;
+
+ /* Nonzero for C++ 2014 Standard digit separators. */
+ unsigned char digit_separators;
+
+ /* Nonzero for C2X decimal floating-point constants. */
+ unsigned char dfp_constants;
+
+ /* Nonzero for C++20 __VA_OPT__ feature. */
+ unsigned char va_opt;
+
+ /* Nonzero for the '::' token. */
+ unsigned char scope;
+
+ /* Nonzero for the '#elifdef' and '#elifndef' directives. */
+ unsigned char elifdef;
+
+ /* Nonzero means tokenize C++20 module directives. */
+ unsigned char module_directives;
+
+ /* Nonzero for C++23 size_t literals. */
+ unsigned char size_t_literals;
+
+ /* Holds the name of the target (execution) character set. */
+ const char *narrow_charset;
+
+ /* Holds the name of the target wide character set. */
+ const char *wide_charset;
+
+ /* Holds the name of the input character set. */
+ const char *input_charset;
+
+ /* The minimum permitted level of normalization before a warning
+ is generated. See enum cpp_normalize_level. */
+ int warn_normalize;
+
+ /* True to warn about precompiled header files we couldn't use. */
+ bool warn_invalid_pch;
+
+ /* True if dependencies should be restored from a precompiled header. */
+ bool restore_pch_deps;
+
+ /* True if warn about differences between C90 and C99. */
+ signed char cpp_warn_c90_c99_compat;
+
+ /* True if warn about differences between C11 and C2X. */
+ signed char cpp_warn_c11_c2x_compat;
+
+ /* True if warn about differences between C++98 and C++11. */
+ bool cpp_warn_cxx11_compat;
+
+ /* Nonzero if bidirectional control characters checking is on. See enum
+ cpp_bidirectional_level. */
+ unsigned char cpp_warn_bidirectional;
+
+ /* Dependency generation. */
+ struct
+ {
+ /* Style of header dependencies to generate. */
+ enum cpp_deps_style style;
+
+ /* Assume missing files are generated files. */
+ bool missing_files;
+
+ /* Generate phony targets for each dependency apart from the first
+ one. */
+ bool phony_targets;
+
+ /* Generate dependency info for modules. */
+ bool modules;
+
+ /* If true, no dependency is generated on the main file. */
+ bool ignore_main_file;
+
+ /* If true, intend to use the preprocessor output (e.g., for compilation)
+ in addition to the dependency info. */
+ bool need_preprocessor_output;
+ } deps;
+
+ /* Target-specific features set by the front end or client. */
+
+ /* Precision for target CPP arithmetic, target characters, target
+ ints and target wide characters, respectively. */
+ size_t precision, char_precision, int_precision, wchar_precision;
+
+ /* True means chars (wide chars) are unsigned. */
+ bool unsigned_char, unsigned_wchar;
+
+ /* True if the most significant byte in a word has the lowest
+ address in memory. */
+ bool bytes_big_endian;
+
+ /* Nonzero means __STDC__ should have the value 0 in system headers. */
+ unsigned char stdc_0_in_system_headers;
+
+ /* True disables tokenization outside of preprocessing directives. */
+ bool directives_only;
+
+ /* True enables canonicalization of system header file paths. */
+ bool canonical_system_headers;
+
+ /* The maximum depth of the nested #include. */
+ unsigned int max_include_depth;
+
+ cpp_main_search main_search : 8;
+};
+
+/* Diagnostic levels. To get a diagnostic without associating a
+ position in the translation unit with it, use cpp_error_with_line
+ with a line number of zero. */
+
+enum cpp_diagnostic_level {
+ /* Warning, an error with -Werror. */
+ CPP_DL_WARNING = 0,
+ /* Same as CPP_DL_WARNING, except it is not suppressed in system headers. */
+ CPP_DL_WARNING_SYSHDR,
+ /* Warning, an error with -pedantic-errors or -Werror. */
+ CPP_DL_PEDWARN,
+ /* An error. */
+ CPP_DL_ERROR,
+ /* An internal consistency check failed. Prints "internal error: ",
+ otherwise the same as CPP_DL_ERROR. */
+ CPP_DL_ICE,
+ /* An informative note following a warning. */
+ CPP_DL_NOTE,
+ /* A fatal error. */
+ CPP_DL_FATAL
+};
+
+/* Warning reason codes. Use a reason code of CPP_W_NONE for unclassified
+ warnings and diagnostics that are not warnings. */
+
+enum cpp_warning_reason {
+ CPP_W_NONE = 0,
+ CPP_W_DEPRECATED,
+ CPP_W_COMMENTS,
+ CPP_W_MISSING_INCLUDE_DIRS,
+ CPP_W_TRIGRAPHS,
+ CPP_W_MULTICHAR,
+ CPP_W_TRADITIONAL,
+ CPP_W_LONG_LONG,
+ CPP_W_ENDIF_LABELS,
+ CPP_W_NUM_SIGN_CHANGE,
+ CPP_W_VARIADIC_MACROS,
+ CPP_W_BUILTIN_MACRO_REDEFINED,
+ CPP_W_DOLLARS,
+ CPP_W_UNDEF,
+ CPP_W_UNUSED_MACROS,
+ CPP_W_CXX_OPERATOR_NAMES,
+ CPP_W_NORMALIZE,
+ CPP_W_INVALID_PCH,
+ CPP_W_WARNING_DIRECTIVE,
+ CPP_W_LITERAL_SUFFIX,
+ CPP_W_SIZE_T_LITERALS,
+ CPP_W_DATE_TIME,
+ CPP_W_PEDANTIC,
+ CPP_W_C90_C99_COMPAT,
+ CPP_W_C11_C2X_COMPAT,
+ CPP_W_CXX11_COMPAT,
+ CPP_W_EXPANSION_TO_DEFINED,
+ CPP_W_BIDIRECTIONAL
+};
+
+/* Callback for header lookup for HEADER, which is the name of a
+ source file. It is used as a method of last resort to find headers
+ that are not otherwise found during the normal include processing.
+ The return value is the malloced name of a header to try and open,
+ if any, or NULL otherwise. This callback is called only if the
+ header is otherwise unfound. */
+typedef const char *(*missing_header_cb)(cpp_reader *, const char *header, cpp_dir **);
+
+/* Call backs to cpplib client. */
+struct cpp_callbacks
+{
+ /* Called when a new line of preprocessed output is started. */
+ void (*line_change) (cpp_reader *, const cpp_token *, int);
+
+ /* Called when switching to/from a new file.
+ The line_map is for the new file. It is NULL if there is no new file.
+ (In C this happens when done with <built-in>+<command line> and also
+ when done with a main file.) This can be used for resource cleanup. */
+ void (*file_change) (cpp_reader *, const line_map_ordinary *);
+
+ void (*dir_change) (cpp_reader *, const char *);
+ void (*include) (cpp_reader *, location_t, const unsigned char *,
+ const char *, int, const cpp_token **);
+ void (*define) (cpp_reader *, location_t, cpp_hashnode *);
+ void (*undef) (cpp_reader *, location_t, cpp_hashnode *);
+ void (*ident) (cpp_reader *, location_t, const cpp_string *);
+ void (*def_pragma) (cpp_reader *, location_t);
+ int (*valid_pch) (cpp_reader *, const char *, int);
+ void (*read_pch) (cpp_reader *, const char *, int, const char *);
+ missing_header_cb missing_header;
+
+ /* Context-sensitive macro support. Returns macro (if any) that should
+ be expanded. */
+ cpp_hashnode * (*macro_to_expand) (cpp_reader *, const cpp_token *);
+
+ /* Called to emit a diagnostic. This callback receives the
+ translated message. */
+ bool (*diagnostic) (cpp_reader *,
+ enum cpp_diagnostic_level,
+ enum cpp_warning_reason,
+ rich_location *,
+ const char *, va_list *)
+ ATTRIBUTE_FPTR_PRINTF(5,0);
+
+ /* Callbacks for when a macro is expanded, or tested (whether
+ defined or not at the time) in #ifdef, #ifndef or "defined". */
+ void (*used_define) (cpp_reader *, location_t, cpp_hashnode *);
+ void (*used_undef) (cpp_reader *, location_t, cpp_hashnode *);
+ /* Called before #define and #undef or other macro definition
+ changes are processed. */
+ void (*before_define) (cpp_reader *);
+ /* Called whenever a macro is expanded or tested.
+ Second argument is the location of the start of the current expansion. */
+ void (*used) (cpp_reader *, location_t, cpp_hashnode *);
+
+ /* Callback to identify whether an attribute exists. */
+ int (*has_attribute) (cpp_reader *, bool);
+
+ /* Callback to determine whether a built-in function is recognized. */
+ int (*has_builtin) (cpp_reader *);
+
+ /* Callback that can change a user lazy into normal macro. */
+ void (*user_lazy_macro) (cpp_reader *, cpp_macro *, unsigned);
+
+ /* Callback to handle deferred cpp_macros. */
+ cpp_macro *(*user_deferred_macro) (cpp_reader *, location_t, cpp_hashnode *);
+
+ /* Callback to parse SOURCE_DATE_EPOCH from environment. */
+ time_t (*get_source_date_epoch) (cpp_reader *);
+
+ /* Callback for providing suggestions for misspelled directives. */
+ const char *(*get_suggestion) (cpp_reader *, const char *, const char *const *);
+
+ /* Callback for when a comment is encountered, giving the location
+ of the opening slash, a pointer to the content (which is not
+ necessarily 0-terminated), and the length of the content.
+ The content contains the opening slash-star (or slash-slash),
+ and for C-style comments contains the closing star-slash. For
+ C++-style comments it does not include the terminating newline. */
+ void (*comment) (cpp_reader *, location_t, const unsigned char *,
+ size_t);
+
+ /* Callback for filename remapping in __FILE__ and __BASE_FILE__ macro
+ expansions. */
+ const char *(*remap_filename) (const char*);
+
+ /* Maybe translate a #include into something else. Return a
+ cpp_buffer containing the translation if translating. */
+ char *(*translate_include) (cpp_reader *, line_maps *, location_t,
+ const char *path);
+};
+
+#ifdef VMS
+#define INO_T_CPP ino_t ino[3]
+#elif defined (_AIX) && SIZEOF_INO_T == 4
+#define INO_T_CPP ino64_t ino
+#else
+#define INO_T_CPP ino_t ino
+#endif
+
+#if defined (_AIX) && SIZEOF_DEV_T == 4
+#define DEV_T_CPP dev64_t dev
+#else
+#define DEV_T_CPP dev_t dev
+#endif
+
+/* Chain of directories to look for include files in. */
+struct cpp_dir
+{
+ /* NULL-terminated singly-linked list. */
+ struct cpp_dir *next;
+
+ /* NAME of the directory, NUL-terminated. */
+ char *name;
+ unsigned int len;
+
+ /* One if a system header, two if a system header that has extern
+ "C" guards for C++. */
+ unsigned char sysp;
+
+ /* Is this a user-supplied directory? */
+ bool user_supplied_p;
+
+ /* The canonicalized NAME as determined by lrealpath. This field
+ is only used by hosts that lack reliable inode numbers. */
+ char *canonical_name;
+
+ /* Mapping of file names for this directory for MS-DOS and related
+ platforms. A NULL-terminated array of (from, to) pairs. */
+ const char **name_map;
+
+ /* Routine to construct pathname, given the search path name and the
+ HEADER we are trying to find, return a constructed pathname to
+ try and open. If this is NULL, the constructed pathname is as
+ constructed by append_file_to_dir. */
+ char *(*construct) (const char *header, cpp_dir *dir);
+
+ /* The C front end uses these to recognize duplicated
+ directories in the search path. */
+ INO_T_CPP;
+ DEV_T_CPP;
+};
+
+/* The kind of the cpp_macro. */
+enum cpp_macro_kind {
+ cmk_macro, /* An ISO macro (token expansion). */
+ cmk_assert, /* An assertion. */
+ cmk_traditional /* A traditional macro (text expansion). */
+};
+
+/* Each macro definition is recorded in a cpp_macro structure.
+ Variadic macros cannot occur with traditional cpp. */
+struct GTY(()) cpp_macro {
+ union cpp_parm_u
+ {
+ /* Parameters, if any. If parameter names use extended identifiers,
+ the original spelling of those identifiers, not the canonical
+ UTF-8 spelling, goes here. */
+ cpp_hashnode ** GTY ((tag ("false"),
+ nested_ptr (union tree_node,
+ "%h ? CPP_HASHNODE (GCC_IDENT_TO_HT_IDENT (%h)) : NULL",
+ "%h ? HT_IDENT_TO_GCC_IDENT (HT_NODE (%h)) : NULL"),
+ length ("%1.paramc"))) params;
+
+ /* If this is an assertion, the next one in the chain. */
+ cpp_macro *GTY ((tag ("true"))) next;
+ } GTY ((desc ("%1.kind == cmk_assert"))) parm;
+
+ /* Definition line number. */
+ location_t line;
+
+ /* Number of tokens in body, or bytes for traditional macros. */
+ /* Do we really need 2^32-1 range here? */
+ unsigned int count;
+
+ /* Number of parameters. */
+ unsigned short paramc;
+
+ /* Non-zero if this is a user-lazy macro, value provided by user. */
+ unsigned char lazy;
+
+ /* The kind of this macro (ISO, trad or assert) */
+ unsigned kind : 2;
+
+ /* If a function-like macro. */
+ unsigned int fun_like : 1;
+
+ /* If a variadic macro. */
+ unsigned int variadic : 1;
+
+ /* If macro defined in system header. */
+ unsigned int syshdr : 1;
+
+ /* Nonzero if it has been expanded or had its existence tested. */
+ unsigned int used : 1;
+
+ /* Indicate whether the tokens include extra CPP_PASTE tokens at the
+ end to track invalid redefinitions with consecutive CPP_PASTE
+ tokens. */
+ unsigned int extra_tokens : 1;
+
+ /* Imported C++20 macro (from a header unit). */
+ unsigned int imported_p : 1;
+
+ /* 0 bits spare (32-bit). 32 on 64-bit target. */
+
+ union cpp_exp_u
+ {
+ /* Trailing array of replacement tokens (ISO), or assertion body value. */
+ cpp_token GTY ((tag ("false"), length ("%1.count"))) tokens[1];
+
+ /* Pointer to replacement text (traditional). See comment at top
+ of cpptrad.c for how traditional function-like macros are
+ encoded. */
+ const unsigned char *GTY ((tag ("true"))) text;
+ } GTY ((desc ("%1.kind == cmk_traditional"))) exp;
+};
+
+/* Poisoned identifiers are flagged NODE_POISONED. NODE_OPERATOR (C++
+ only) indicates an identifier that behaves like an operator such as
+ "xor". NODE_DIAGNOSTIC is for speed in lex_token: it indicates a
+ diagnostic may be required for this node. Currently this only
+ applies to __VA_ARGS__, poisoned identifiers, and -Wc++-compat
+ warnings about NODE_OPERATOR. */
+
+/* Hash node flags. */
+#define NODE_OPERATOR (1 << 0) /* C++ named operator. */
+#define NODE_POISONED (1 << 1) /* Poisoned identifier. */
+#define NODE_DIAGNOSTIC (1 << 2) /* Possible diagnostic when lexed. */
+#define NODE_WARN (1 << 3) /* Warn if redefined or undefined. */
+#define NODE_DISABLED (1 << 4) /* A disabled macro. */
+#define NODE_USED (1 << 5) /* Dumped with -dU. */
+#define NODE_CONDITIONAL (1 << 6) /* Conditional macro */
+#define NODE_WARN_OPERATOR (1 << 7) /* Warn about C++ named operator. */
+#define NODE_MODULE (1 << 8) /* C++-20 module-related name. */
+
+/* Different flavors of hash node. */
+enum node_type
+{
+ NT_VOID = 0, /* Maybe an assert? */
+ NT_MACRO_ARG, /* A macro arg. */
+ NT_USER_MACRO, /* A user macro. */
+ NT_BUILTIN_MACRO, /* A builtin macro. */
+ NT_MACRO_MASK = NT_USER_MACRO /* Mask for either macro kind. */
+};
+
+/* Different flavors of builtin macro. _Pragma is an operator, but we
+ handle it with the builtin code for efficiency reasons. */
+enum cpp_builtin_type
+{
+ BT_SPECLINE = 0, /* `__LINE__' */
+ BT_DATE, /* `__DATE__' */
+ BT_FILE, /* `__FILE__' */
+ BT_FILE_NAME, /* `__FILE_NAME__' */
+ BT_BASE_FILE, /* `__BASE_FILE__' */
+ BT_INCLUDE_LEVEL, /* `__INCLUDE_LEVEL__' */
+ BT_TIME, /* `__TIME__' */
+ BT_STDC, /* `__STDC__' */
+ BT_PRAGMA, /* `_Pragma' operator */
+ BT_TIMESTAMP, /* `__TIMESTAMP__' */
+ BT_COUNTER, /* `__COUNTER__' */
+ BT_HAS_ATTRIBUTE, /* `__has_attribute(x)' */
+ BT_HAS_STD_ATTRIBUTE, /* `__has_c_attribute(x)' */
+ BT_HAS_BUILTIN, /* `__has_builtin(x)' */
+ BT_HAS_INCLUDE, /* `__has_include(x)' */
+ BT_HAS_INCLUDE_NEXT, /* `__has_include_next(x)' */
+
+ // RT Extension
+ BT_RT_ASSIGN,
+ BT_RT_TO_ARG_LIST,
+ BT_RT_TO_TOKEN_LIST,
+ BT_RT_FIRST,
+ BT_RT_REST,
+ BT_RT_MAP,
+ BT_RT_AL_MAP,
+ BT_RT_IF,
+ BT_RT_NOT,
+ BT_RT_AND,
+ BT_RT_OR,
+ BT_RT_IS_IDENTIFIER,
+ BT_RT_IS_NAME,
+ BT_RT_PASTE
+};
+
+#define CPP_HASHNODE(HNODE) ((cpp_hashnode *) (HNODE))
+#define HT_NODE(NODE) (&(NODE)->ident)
+#define NODE_LEN(NODE) HT_LEN (HT_NODE (NODE))
+#define NODE_NAME(NODE) HT_STR (HT_NODE (NODE))
+
+/* The common part of an identifier node shared amongst all 3 C front
+ ends. Also used to store CPP identifiers, which are a superset of
+ identifiers in the grammatical sense. */
+
+union GTY(()) _cpp_hashnode_value {
+ /* Assert (maybe NULL) */
+ cpp_macro * GTY((tag ("NT_VOID"))) answers;
+ /* Macro (maybe NULL) */
+ cpp_macro * GTY((tag ("NT_USER_MACRO"))) macro;
+ /* Code for a builtin macro. */
+ enum cpp_builtin_type GTY ((tag ("NT_BUILTIN_MACRO"))) builtin;
+ /* Macro argument index. */
+ unsigned short GTY ((tag ("NT_MACRO_ARG"))) arg_index;
+};
+
+struct GTY(()) cpp_hashnode {
+ struct ht_identifier ident;
+ unsigned int is_directive : 1;
+ unsigned int directive_index : 7; /* If is_directive,
+ then index into directive table.
+ Otherwise, a NODE_OPERATOR. */
+ unsigned int rid_code : 8; /* Rid code - for front ends. */
+ unsigned int flags : 9; /* CPP flags. */
+ ENUM_BITFIELD(node_type) type : 2; /* CPP node type. */
+
+ /* 5 bits spare. */
+
+ /* The deferred cookie is applicable to NT_USER_MACRO or NT_VOID.
+ The latter for when a macro had a prevailing undef.
+ On a 64-bit system there would be 32-bits of padding to the value
+ field. So placing the deferred index here is not costly. */
+ unsigned deferred; /* Deferred cookie */
+
+ union _cpp_hashnode_value GTY ((desc ("%1.type"))) value;
+};
+
+/* A class for iterating through the source locations within a
+ string token (before escapes are interpreted, and before
+ concatenation). */
+
+class cpp_string_location_reader {
+ public:
+ cpp_string_location_reader (location_t src_loc,
+ line_maps *line_table);
+
+ source_range get_next ();
+
+ private:
+ location_t m_loc;
+ int m_offset_per_column;
+};
+
+/* A class for storing the source ranges of all of the characters within
+ a string literal, after escapes are interpreted, and after
+ concatenation.
+
+ This is not GTY-marked, as instances are intended to be temporary. */
+
+class cpp_substring_ranges
+{
+ public:
+ cpp_substring_ranges ();
+ ~cpp_substring_ranges ();
+
+ int get_num_ranges () const { return m_num_ranges; }
+ source_range get_range (int idx) const
+ {
+ linemap_assert (idx < m_num_ranges);
+ return m_ranges[idx];
+ }
+
+ void add_range (source_range range);
+ void add_n_ranges (int num, cpp_string_location_reader &loc_reader);
+
+ private:
+ source_range *m_ranges;
+ int m_num_ranges;
+ int m_alloc_ranges;
+};
+
+/* Call this first to get a handle to pass to other functions.
+
+ If you want cpplib to manage its own hashtable, pass in a NULL
+ pointer. Otherwise you should pass in an initialized hash table
+ that cpplib will share; this technique is used by the C front
+ ends. */
+extern cpp_reader *cpp_create_reader (enum c_lang, struct ht *,
+ class line_maps *);
+
+/* Reset the cpp_reader's line_map. This is only used after reading a
+ PCH file. */
+extern void cpp_set_line_map (cpp_reader *, class line_maps *);
+
+/* Call this to change the selected language standard (e.g. because of
+ command line options). */
+extern void cpp_set_lang (cpp_reader *, enum c_lang);
+
+/* Set the include paths. */
+extern void cpp_set_include_chains (cpp_reader *, cpp_dir *, cpp_dir *, int);
+
+/* Call these to get pointers to the options, callback, and deps
+ structures for a given reader. These pointers are good until you
+ call cpp_finish on that reader. You can either edit the callbacks
+ through the pointer returned from cpp_get_callbacks, or set them
+ with cpp_set_callbacks. */
+extern cpp_options *cpp_get_options (cpp_reader *) ATTRIBUTE_PURE;
+extern cpp_callbacks *cpp_get_callbacks (cpp_reader *) ATTRIBUTE_PURE;
+extern void cpp_set_callbacks (cpp_reader *, cpp_callbacks *);
+extern class mkdeps *cpp_get_deps (cpp_reader *) ATTRIBUTE_PURE;
+
+extern const char *cpp_probe_header_unit (cpp_reader *, const char *file,
+ bool angle_p, location_t);
+
+/* Call these to get name data about the various compile-time
+ charsets. */
+extern const char *cpp_get_narrow_charset_name (cpp_reader *) ATTRIBUTE_PURE;
+extern const char *cpp_get_wide_charset_name (cpp_reader *) ATTRIBUTE_PURE;
+
+/* This function reads the file, but does not start preprocessing. It
+ returns the name of the original file; this is the same as the
+ input file, except for preprocessed input. This will generate at
+ least one file change callback, and possibly a line change callback
+ too. If there was an error opening the file, it returns NULL. */
+extern const char *cpp_read_main_file (cpp_reader *, const char *,
+ bool injecting = false);
+extern location_t cpp_main_loc (const cpp_reader *);
+
+/* Adjust for the main file to be an include. */
+extern void cpp_retrofit_as_include (cpp_reader *);
+
+/* Set up built-ins with special behavior. Use cpp_init_builtins()
+ instead unless your know what you are doing. */
+extern void cpp_init_special_builtins (cpp_reader *);
+
+/* Set up built-ins like __FILE__. */
+extern void cpp_init_builtins (cpp_reader *, int);
+
+/* This is called after options have been parsed, and partially
+ processed. */
+extern void cpp_post_options (cpp_reader *);
+
+/* Set up translation to the target character set. */
+extern void cpp_init_iconv (cpp_reader *);
+
+/* Call this to finish preprocessing. If you requested dependency
+ generation, pass an open stream to write the information to,
+ otherwise NULL. It is your responsibility to close the stream. */
+extern void cpp_finish (cpp_reader *, FILE *deps_stream);
+
+/* Call this to release the handle at the end of preprocessing. Any
+ use of the handle after this function returns is invalid. */
+extern void cpp_destroy (cpp_reader *);
+
+extern unsigned int cpp_token_len (const cpp_token *);
+extern unsigned char *cpp_token_as_text (cpp_reader *, const cpp_token *);
+extern unsigned char *cpp_spell_token (cpp_reader *, const cpp_token *,
+ unsigned char *, bool);
+extern void cpp_register_pragma (cpp_reader *, const char *, const char *,
+ void (*) (cpp_reader *), bool);
+extern void cpp_register_deferred_pragma (cpp_reader *, const char *,
+ const char *, unsigned, bool, bool);
+extern int cpp_avoid_paste (cpp_reader *, const cpp_token *,
+ const cpp_token *);
+extern const cpp_token *cpp_get_token (cpp_reader *);
+extern const cpp_token *cpp_get_token_with_location (cpp_reader *,
+ location_t *);
+inline bool cpp_user_macro_p (const cpp_hashnode *node)
+{
+ return node->type == NT_USER_MACRO;
+}
+inline bool cpp_builtin_macro_p (const cpp_hashnode *node)
+{
+ return node->type == NT_BUILTIN_MACRO;
+}
+inline bool cpp_macro_p (const cpp_hashnode *node)
+{
+ return node->type & NT_MACRO_MASK;
+}
+inline cpp_macro *cpp_set_deferred_macro (cpp_hashnode *node,
+ cpp_macro *forced = NULL)
+{
+ cpp_macro *old = node->value.macro;
+
+ node->value.macro = forced;
+ node->type = NT_USER_MACRO;
+ node->flags &= ~NODE_USED;
+
+ return old;
+}
+cpp_macro *cpp_get_deferred_macro (cpp_reader *, cpp_hashnode *, location_t);
+
+/* Returns true if NODE is a function-like user macro. */
+inline bool cpp_fun_like_macro_p (cpp_hashnode *node)
+{
+ return cpp_user_macro_p (node) && node->value.macro->fun_like;
+}
+
+extern const unsigned char *cpp_macro_definition (cpp_reader *, cpp_hashnode *);
+extern const unsigned char *cpp_macro_definition (cpp_reader *, cpp_hashnode *,
+ const cpp_macro *);
+inline location_t cpp_macro_definition_location (cpp_hashnode *node)
+{
+ const cpp_macro *macro = node->value.macro;
+ return macro ? macro->line : 0;
+}
+/* Return an idempotent time stamp (possibly from SOURCE_DATE_EPOCH). */
+enum class CPP_time_kind
+{
+ FIXED = -1, /* Fixed time via source epoch. */
+ DYNAMIC = -2, /* Dynamic via time(2). */
+ UNKNOWN = -3 /* Wibbly wobbly, timey wimey. */
+};
+extern CPP_time_kind cpp_get_date (cpp_reader *, time_t *);
+
+extern void _cpp_backup_tokens (cpp_reader *, unsigned int);
+extern const cpp_token *cpp_peek_token (cpp_reader *, int);
+
+/* Evaluate a CPP_*CHAR* token. */
+extern cppchar_t cpp_interpret_charconst (cpp_reader *, const cpp_token *,
+ unsigned int *, int *);
+/* Evaluate a vector of CPP_*STRING* tokens. */
+extern bool cpp_interpret_string (cpp_reader *,
+ const cpp_string *, size_t,
+ cpp_string *, enum cpp_ttype);
+extern const char *cpp_interpret_string_ranges (cpp_reader *pfile,
+ const cpp_string *from,
+ cpp_string_location_reader *,
+ size_t count,
+ cpp_substring_ranges *out,
+ enum cpp_ttype type);
+extern bool cpp_interpret_string_notranslate (cpp_reader *,
+ const cpp_string *, size_t,
+ cpp_string *, enum cpp_ttype);
+
+/* Convert a host character constant to the execution character set. */
+extern cppchar_t cpp_host_to_exec_charset (cpp_reader *, cppchar_t);
+
+/* Used to register macros and assertions, perhaps from the command line.
+ The text is the same as the command line argument. */
+extern void cpp_define (cpp_reader *, const char *);
+extern void cpp_define_unused (cpp_reader *, const char *);
+extern void cpp_define_formatted (cpp_reader *pfile,
+ const char *fmt, ...) ATTRIBUTE_PRINTF_2;
+extern void cpp_define_formatted_unused (cpp_reader *pfile,
+ const char *fmt,
+ ...) ATTRIBUTE_PRINTF_2;
+extern void cpp_assert (cpp_reader *, const char *);
+extern void cpp_undef (cpp_reader *, const char *);
+extern void cpp_unassert (cpp_reader *, const char *);
+
+/* Mark a node as a lazily defined macro. */
+extern void cpp_define_lazily (cpp_reader *, cpp_hashnode *node, unsigned N);
+
+/* Undefine all macros and assertions. */
+extern void cpp_undef_all (cpp_reader *);
+
+extern cpp_buffer *cpp_push_buffer (cpp_reader *, const unsigned char *,
+ size_t, int);
+extern int cpp_defined (cpp_reader *, const unsigned char *, int);
+
+/* A preprocessing number. Code assumes that any unused high bits of
+ the double integer are set to zero. */
+
+/* This type has to be equal to unsigned HOST_WIDE_INT, see
+ gcc/c-family/c-lex.cc. */
+typedef uint64_t cpp_num_part;
+typedef struct cpp_num cpp_num;
+struct cpp_num
+{
+ cpp_num_part high;
+ cpp_num_part low;
+ bool unsignedp; /* True if value should be treated as unsigned. */
+ bool overflow; /* True if the most recent calculation overflowed. */
+};
+
+/* cpplib provides two interfaces for interpretation of preprocessing
+ numbers.
+
+ cpp_classify_number categorizes numeric constants according to
+ their field (integer, floating point, or invalid), radix (decimal,
+ octal, hexadecimal), and type suffixes. */
+
+#define CPP_N_CATEGORY 0x000F
+#define CPP_N_INVALID 0x0000
+#define CPP_N_INTEGER 0x0001
+#define CPP_N_FLOATING 0x0002
+
+#define CPP_N_WIDTH 0x00F0
+#define CPP_N_SMALL 0x0010 /* int, float, short _Fract/Accum */
+#define CPP_N_MEDIUM 0x0020 /* long, double, long _Fract/_Accum. */
+#define CPP_N_LARGE 0x0040 /* long long, long double,
+ long long _Fract/Accum. */
+
+#define CPP_N_WIDTH_MD 0xF0000 /* machine defined. */
+#define CPP_N_MD_W 0x10000
+#define CPP_N_MD_Q 0x20000
+
+#define CPP_N_RADIX 0x0F00
+#define CPP_N_DECIMAL 0x0100
+#define CPP_N_HEX 0x0200
+#define CPP_N_OCTAL 0x0400
+#define CPP_N_BINARY 0x0800
+
+#define CPP_N_UNSIGNED 0x1000 /* Properties. */
+#define CPP_N_IMAGINARY 0x2000
+#define CPP_N_DFLOAT 0x4000
+#define CPP_N_DEFAULT 0x8000
+
+#define CPP_N_FRACT 0x100000 /* Fract types. */
+#define CPP_N_ACCUM 0x200000 /* Accum types. */
+#define CPP_N_FLOATN 0x400000 /* _FloatN types. */
+#define CPP_N_FLOATNX 0x800000 /* _FloatNx types. */
+
+#define CPP_N_USERDEF 0x1000000 /* C++11 user-defined literal. */
+
+#define CPP_N_SIZE_T 0x2000000 /* C++23 size_t literal. */
+
+#define CPP_N_WIDTH_FLOATN_NX 0xF0000000 /* _FloatN / _FloatNx value
+ of N, divided by 16. */
+#define CPP_FLOATN_SHIFT 24
+#define CPP_FLOATN_MAX 0xF0
+
+/* Classify a CPP_NUMBER token. The return value is a combination of
+ the flags from the above sets. */
+extern unsigned cpp_classify_number (cpp_reader *, const cpp_token *,
+ const char **, location_t);
+
+/* Return the classification flags for a float suffix. */
+extern unsigned int cpp_interpret_float_suffix (cpp_reader *, const char *,
+ size_t);
+
+/* Return the classification flags for an int suffix. */
+extern unsigned int cpp_interpret_int_suffix (cpp_reader *, const char *,
+ size_t);
+
+/* Evaluate a token classified as category CPP_N_INTEGER. */
+extern cpp_num cpp_interpret_integer (cpp_reader *, const cpp_token *,
+ unsigned int);
+
+/* Sign extend a number, with PRECISION significant bits and all
+ others assumed clear, to fill out a cpp_num structure. */
+cpp_num cpp_num_sign_extend (cpp_num, size_t);
+
+/* Output a diagnostic of some kind. */
+extern bool cpp_error (cpp_reader *, enum cpp_diagnostic_level,
+ const char *msgid, ...)
+ ATTRIBUTE_PRINTF_3;
+extern bool cpp_warning (cpp_reader *, enum cpp_warning_reason,
+ const char *msgid, ...)
+ ATTRIBUTE_PRINTF_3;
+extern bool cpp_pedwarning (cpp_reader *, enum cpp_warning_reason,
+ const char *msgid, ...)
+ ATTRIBUTE_PRINTF_3;
+extern bool cpp_warning_syshdr (cpp_reader *, enum cpp_warning_reason reason,
+ const char *msgid, ...)
+ ATTRIBUTE_PRINTF_3;
+
+/* As their counterparts above, but use RICHLOC. */
+extern bool cpp_warning_at (cpp_reader *, enum cpp_warning_reason,
+ rich_location *richloc, const char *msgid, ...)
+ ATTRIBUTE_PRINTF_4;
+extern bool cpp_pedwarning_at (cpp_reader *, enum cpp_warning_reason,
+ rich_location *richloc, const char *msgid, ...)
+ ATTRIBUTE_PRINTF_4;
+
+/* Output a diagnostic with "MSGID: " preceding the
+ error string of errno. No location is printed. */
+extern bool cpp_errno (cpp_reader *, enum cpp_diagnostic_level,
+ const char *msgid);
+/* Similarly, but with "FILENAME: " instead of "MSGID: ", where
+ the filename is not localized. */
+extern bool cpp_errno_filename (cpp_reader *, enum cpp_diagnostic_level,
+ const char *filename, location_t loc);
+
+/* Same as cpp_error, except additionally specifies a position as a
+ (translation unit) physical line and physical column. If the line is
+ zero, then no location is printed. */
+extern bool cpp_error_with_line (cpp_reader *, enum cpp_diagnostic_level,
+ location_t, unsigned,
+ const char *msgid, ...)
+ ATTRIBUTE_PRINTF_5;
+extern bool cpp_warning_with_line (cpp_reader *, enum cpp_warning_reason,
+ location_t, unsigned,
+ const char *msgid, ...)
+ ATTRIBUTE_PRINTF_5;
+extern bool cpp_pedwarning_with_line (cpp_reader *, enum cpp_warning_reason,
+ location_t, unsigned,
+ const char *msgid, ...)
+ ATTRIBUTE_PRINTF_5;
+extern bool cpp_warning_with_line_syshdr (cpp_reader *, enum cpp_warning_reason,
+ location_t, unsigned,
+ const char *msgid, ...)
+ ATTRIBUTE_PRINTF_5;
+
+extern bool cpp_error_at (cpp_reader * pfile, enum cpp_diagnostic_level,
+ location_t src_loc, const char *msgid, ...)
+ ATTRIBUTE_PRINTF_4;
+
+extern bool cpp_error_at (cpp_reader * pfile, enum cpp_diagnostic_level,
+ rich_location *richloc, const char *msgid, ...)
+ ATTRIBUTE_PRINTF_4;
+
+/* In lex.cc */
+extern int cpp_ideq (const cpp_token *, const char *);
+extern void cpp_output_line (cpp_reader *, FILE *);
+extern unsigned char *cpp_output_line_to_string (cpp_reader *,
+ const unsigned char *);
+extern const unsigned char *cpp_alloc_token_string
+ (cpp_reader *, const unsigned char *, unsigned);
+extern void cpp_output_token (const cpp_token *, FILE *);
+extern const char *cpp_type2name (enum cpp_ttype, unsigned char flags);
+/* Returns the value of an escape sequence, truncated to the correct
+ target precision. PSTR points to the input pointer, which is just
+ after the backslash. LIMIT is how much text we have. WIDE is true
+ if the escape sequence is part of a wide character constant or
+ string literal. Handles all relevant diagnostics. */
+extern cppchar_t cpp_parse_escape (cpp_reader *, const unsigned char ** pstr,
+ const unsigned char *limit, int wide);
+
+/* Structure used to hold a comment block at a given location in the
+ source code. */
+
+typedef struct
+{
+ /* Text of the comment including the terminators. */
+ char *comment;
+
+ /* source location for the given comment. */
+ location_t sloc;
+} cpp_comment;
+
+/* Structure holding all comments for a given cpp_reader. */
+
+typedef struct
+{
+ /* table of comment entries. */
+ cpp_comment *entries;
+
+ /* number of actual entries entered in the table. */
+ int count;
+
+ /* number of entries allocated currently. */
+ int allocated;
+} cpp_comment_table;
+
+/* Returns the table of comments encountered by the preprocessor. This
+ table is only populated when pfile->state.save_comments is true. */
+extern cpp_comment_table *cpp_get_comments (cpp_reader *);
+
+/* In hash.c */
+
+/* Lookup an identifier in the hashtable. Puts the identifier in the
+ table if it is not already there. */
+extern cpp_hashnode *cpp_lookup (cpp_reader *, const unsigned char *,
+ unsigned int);
+
+typedef int (*cpp_cb) (cpp_reader *, cpp_hashnode *, void *);
+extern void cpp_forall_identifiers (cpp_reader *, cpp_cb, void *);
+
+/* In macro.cc */
+extern void cpp_scan_nooutput (cpp_reader *);
+extern int cpp_sys_macro_p (cpp_reader *);
+extern unsigned char *cpp_quote_string (unsigned char *, const unsigned char *,
+ unsigned int);
+extern bool cpp_compare_macros (const cpp_macro *macro1,
+ const cpp_macro *macro2);
+
+/* In files.cc */
+extern bool cpp_included (cpp_reader *, const char *);
+extern bool cpp_included_before (cpp_reader *, const char *, location_t);
+extern void cpp_make_system_header (cpp_reader *, int, int);
+extern bool cpp_push_include (cpp_reader *, const char *);
+extern bool cpp_push_default_include (cpp_reader *, const char *);
+extern void cpp_change_file (cpp_reader *, enum lc_reason, const char *);
+extern const char *cpp_get_path (struct _cpp_file *);
+extern cpp_dir *cpp_get_dir (struct _cpp_file *);
+extern cpp_buffer *cpp_get_buffer (cpp_reader *);
+extern struct _cpp_file *cpp_get_file (cpp_buffer *);
+extern cpp_buffer *cpp_get_prev (cpp_buffer *);
+extern void cpp_clear_file_cache (cpp_reader *);
+
+/* cpp_get_converted_source returns the contents of the given file, as it exists
+ after cpplib has read it and converted it from the input charset to the
+ source charset. Return struct will be zero-filled if the data could not be
+ read for any reason. The data starts at the DATA pointer, but the TO_FREE
+ pointer is what should be passed to free(), as there may be an offset. */
+struct cpp_converted_source
+{
+ char *to_free;
+ char *data;
+ size_t len;
+};
+cpp_converted_source cpp_get_converted_source (const char *fname,
+ const char *input_charset);
+
+/* In pch.cc */
+struct save_macro_data;
+extern int cpp_save_state (cpp_reader *, FILE *);
+extern int cpp_write_pch_deps (cpp_reader *, FILE *);
+extern int cpp_write_pch_state (cpp_reader *, FILE *);
+extern int cpp_valid_state (cpp_reader *, const char *, int);
+extern void cpp_prepare_state (cpp_reader *, struct save_macro_data **);
+extern int cpp_read_state (cpp_reader *, const char *, FILE *,
+ struct save_macro_data *);
+
+/* In lex.cc */
+extern void cpp_force_token_locations (cpp_reader *, location_t);
+extern void cpp_stop_forcing_token_locations (cpp_reader *);
+enum CPP_DO_task
+{
+ CPP_DO_print,
+ CPP_DO_location,
+ CPP_DO_token
+};
+
+extern void cpp_directive_only_process (cpp_reader *pfile,
+ void *data,
+ void (*cb) (cpp_reader *,
+ CPP_DO_task,
+ void *data, ...));
+
+/* In expr.cc */
+extern enum cpp_ttype cpp_userdef_string_remove_type
+ (enum cpp_ttype type);
+extern enum cpp_ttype cpp_userdef_string_add_type
+ (enum cpp_ttype type);
+extern enum cpp_ttype cpp_userdef_char_remove_type
+ (enum cpp_ttype type);
+extern enum cpp_ttype cpp_userdef_char_add_type
+ (enum cpp_ttype type);
+extern bool cpp_userdef_string_p
+ (enum cpp_ttype type);
+extern bool cpp_userdef_char_p
+ (enum cpp_ttype type);
+extern const char * cpp_get_userdef_suffix
+ (const cpp_token *);
+
+/* In charset.cc */
+
+/* The result of attempting to decode a run of UTF-8 bytes. */
+
+struct cpp_decoded_char
+{
+ const char *m_start_byte;
+ const char *m_next_byte;
+
+ bool m_valid_ch;
+ cppchar_t m_ch;
+};
+
+/* Information for mapping between code points and display columns.
+
+ This is a tabstop value, along with a callback for getting the
+ widths of characters. Normally this callback is cpp_wcwidth, but we
+ support other schemes for escaping non-ASCII unicode as a series of
+ ASCII chars when printing the user's source code in diagnostic-show-locus.cc
+
+ For example, consider:
+ - the Unicode character U+03C0 "GREEK SMALL LETTER PI" (UTF-8: 0xCF 0x80)
+ - the Unicode character U+1F642 "SLIGHTLY SMILING FACE"
+ (UTF-8: 0xF0 0x9F 0x99 0x82)
+ - the byte 0xBF (a stray trailing byte of a UTF-8 character)
+ Normally U+03C0 would occupy one display column, U+1F642
+ would occupy two display columns, and the stray byte would be
+ printed verbatim as one display column.
+
+ However when escaping them as unicode code points as "<U+03C0>"
+ and "<U+1F642>" they occupy 8 and 9 display columns respectively,
+ and when escaping them as bytes as "<CF><80>" and "<F0><9F><99><82>"
+ they occupy 8 and 16 display columns respectively. In both cases
+ the stray byte is escaped to <BF> as 4 display columns. */
+
+struct cpp_char_column_policy
+{
+ cpp_char_column_policy (int tabstop,
+ int (*width_cb) (cppchar_t c))
+ : m_tabstop (tabstop),
+ m_undecoded_byte_width (1),
+ m_width_cb (width_cb)
+ {}
+
+ int m_tabstop;
+ /* Width in display columns of a stray byte that isn't decodable
+ as UTF-8. */
+ int m_undecoded_byte_width;
+ int (*m_width_cb) (cppchar_t c);
+};
+
+/* A class to manage the state while converting a UTF-8 sequence to cppchar_t
+ and computing the display width one character at a time. */
+class cpp_display_width_computation {
+ public:
+ cpp_display_width_computation (const char *data, int data_length,
+ const cpp_char_column_policy &policy);
+ const char *next_byte () const { return m_next; }
+ int bytes_processed () const { return m_next - m_begin; }
+ int bytes_left () const { return m_bytes_left; }
+ bool done () const { return !bytes_left (); }
+ int display_cols_processed () const { return m_display_cols; }
+
+ int process_next_codepoint (cpp_decoded_char *out);
+ int advance_display_cols (int n);
+
+ private:
+ const char *const m_begin;
+ const char *m_next;
+ size_t m_bytes_left;
+ const cpp_char_column_policy &m_policy;
+ int m_display_cols;
+};
+
+/* Convenience functions that are simple use cases for class
+ cpp_display_width_computation. Tab characters will be expanded to spaces
+ as determined by POLICY.m_tabstop, and non-printable-ASCII characters
+ will be escaped as per POLICY. */
+
+int cpp_byte_column_to_display_column (const char *data, int data_length,
+ int column,
+ const cpp_char_column_policy &policy);
+inline int cpp_display_width (const char *data, int data_length,
+ const cpp_char_column_policy &policy)
+{
+ return cpp_byte_column_to_display_column (data, data_length, data_length,
+ policy);
+}
+int cpp_display_column_to_byte_column (const char *data, int data_length,
+ int display_col,
+ const cpp_char_column_policy &policy);
+int cpp_wcwidth (cppchar_t c);
+
+bool cpp_input_conversion_is_trivial (const char *input_charset);
+int cpp_check_utf8_bom (const char *data, size_t data_length);
+
+#endif /* ! LIBCPP_CPPLIB_H */
projects / RT-gcc / commitdiff