CbC/CbC_gcc: libcpp/macro.c comparison

comparison libcpp/macro.c @ 145:1830386684a0

gcc-9.2.0

author	anatofuz
date	Thu, 13 Feb 2020 11:34:05 +0900
parents	84e7813d76e9
children

comparison

equal deleted inserted replaced

-:84e7813d76e9
+:1830386684a0
 /* Part of CPP library.  (Macro and #define handling.)
-Copyright (C) 1986-2018 Free Software Foundation, Inc.
+Copyright (C) 1986-2020 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
 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.  */
-source_location *virt_locs;	/* Where virtual locations for
+location_t *virt_locs;	/* Where virtual locations for
 				   unexpanded tokens are stored.  */
-source_location *expanded_virt_locs; /* Where virtual locations for
+location_t *expanded_virt_locs; /* Where virtual locations for
 					  expanded tokens are
 					  stored.  */
 };
 /* The kind of macro tokens which the instance of
 /* 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 source_location *location_ptr;
+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
 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.  */
-source_location m_paste_location;
+location_t m_paste_location;
 /* Location of the __VA_OPT__ token.  */
-source_location m_location;
+location_t m_location;
 };
 /* Macro expansion.  */
 static int enter_macro_context (cpp_reader *, cpp_hashnode *,
-				const cpp_token *, source_location);
+				const cpp_token *, location_t);
 static int builtin_macro (cpp_reader *, cpp_hashnode *,
-			  source_location, source_location);
+			  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 *, source_location *,
+					  _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 void expand_arg (cpp_reader *, macro_arg *);
 static const cpp_token *new_string_token (cpp_reader *, uchar *, unsigned int);
 static const cpp_token *stringify_arg (cpp_reader *, macro_arg *);
 static void paste_all_tokens (cpp_reader *, const cpp_token *);
-static bool paste_tokens (cpp_reader *, source_location,
+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 *,
-			   source_location, size_t,
+			   location_t, size_t,
 			   enum macro_arg_token_kind,
 			   bool);
-static const source_location *get_arg_token_location (const macro_arg *,
+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,
-					   source_location **virt_location);
+					   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 source_location macro_arg_token_iter_get_location
+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,
-				   source_location **);
+				   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 **,
-source_location *,
+location_t *,
 const cpp_token *,
-source_location,
+location_t,
-source_location,
+location_t,
 const line_map_macro *,
 unsigned int);
 static const cpp_token **tokens_buff_add_token (_cpp_buff *,
-						source_location *,
+						location_t *,
 						const cpp_token *,
-						source_location,
+						location_t,
-						source_location,
+						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 *, source_location);
+			  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 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 **,
-					     source_location *);
+					     location_t *);
-static const cpp_token* cpp_get_token_1 (cpp_reader *, source_location *);
+static const cpp_token* cpp_get_token_1 (cpp_reader *, location_t *);
 static cpp_hashnode* macro_of_context (cpp_context *context);
 static bool in_macro_expansion_p (cpp_reader *pfile);
 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)
 /* 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,
-			 source_location loc)
+			 location_t loc)
 {
 const uchar *result = NULL;
 linenum_type number = 1;
 switch (node->value.builtin)
 break;
 case BT_HAS_ATTRIBUTE:
 number = pfile->cb.has_attribute (pfile);
 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;
 }
 if (result == NULL)
 {
 /* 21 bytes holds all NUL-terminated unsigned 64-bit numbers.  */
 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,
-	       source_location loc, source_location expand_loc)
+	       location_t loc, location_t expand_loc)
 {
 const uchar *buf;
 size_t len;
 char *nbuf;
 {
 /* 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.  */
-source_location *virt_locs = NULL;
+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,
 /* 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, source_location location,
+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;
 /* Set pfile->cur_token as required by _cpp_lex_direct.  */
 pfile->cur_token = _cpp_temp_token (pfile);
 lhs = _cpp_lex_direct (pfile);
 if (pfile->buffer->cur != pfile->buffer->rlimit)
 {
-source_location saved_loc = lhs->src_loc;
+location_t saved_loc = lhs->src_loc;
 _cpp_pop_buffer (pfile);
 _cpp_backup_tokens (pfile, 1);
 *lhsend = '\0';
 static void
 paste_all_tokens (cpp_reader *pfile, const cpp_token *lhs)
 {
 const cpp_token *rhs = NULL;
 cpp_context *context = pfile->context;
-source_location virt_loc = 0;
+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)))
 while (rhs->flags & PASTE_LEFT);
 /* Put the resulting token in its own context.  */
 if (context->tokens_kind == TOKENS_KIND_EXTENDED)
 {
-source_location *virt_locs = NULL;
+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,
 _cpp_buff *buff, *base_buff;
 cpp_macro *macro;
 macro_arg *args, *arg;
 const cpp_token *token;
 unsigned int argc;
-source_location virt_loc;
+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++;
 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 (source_location,
+	  arg->virt_locs = XNEWVEC (location_t,
 				    virt_locs_capacity);
 	}
 for (;;)
 	{
 	    }
 	  if (track_macro_expansion_p
 	      && (ntokens + 2 > virt_locs_capacity))
 	    {
 	      virt_locs_capacity += ARG_TOKENS_EXTENT;
-	      arg->virt_locs = XRESIZEVEC (source_location,
+	      arg->virt_locs = XRESIZEVEC (location_t,
 					   arg->virt_locs,
 					   virt_locs_capacity);
 	    }
 	  token = cpp_get_token_1 (pfile, &virt_loc);
 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, source_location location)
+		     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;
 	  if (CPP_OPTION (pfile, track_macro_expansion))
 	    {
 	      unsigned int i;
 	      const cpp_token *src = macro->exp.tokens;
 	      const line_map_macro *map;
-	      source_location *virt_locs = NULL;
+	      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
 }
 pfile->about_to_expand_macro_p = false;
 /* Handle built-in macros and the _Pragma operator.  */
 {
-source_location expand_loc;
+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.  */
 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,
-	       source_location location, size_t index,
+	       location_t location, size_t index,
 	       enum macro_arg_token_kind kind,
 	       bool track_macro_exp_p)
 {
 const cpp_token **token_ptr;
-source_location *loc = NULL;
+location_t *loc = NULL;
 token_ptr =
 arg_token_ptr_at (arg, index, kind,
 		      track_macro_exp_p ? &loc : NULL);
 *token_ptr = token;
 }
 /* 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 source_location *
+static const location_t *
 get_arg_token_location (const macro_arg *arg,
 			enum macro_arg_token_kind kind)
 {
-const source_location *loc = NULL;
+const location_t *loc = NULL;
 const cpp_token **token_ptr =
-arg_token_ptr_at (arg, 0, kind, (source_location **) &loc);
+arg_token_ptr_at (arg, 0, kind, (location_t **) &loc);
 if (token_ptr == NULL)
 return NULL;
 return loc;
 -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,
-		  source_location **virt_location)
+		  location_t **virt_location)
 {
 const cpp_token **tokens_ptr = NULL;
 switch (kind)
 {
 	*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 =
-	  (source_location *) &tokens_ptr[index]->src_loc;
+	  (location_t *) &tokens_ptr[index]->src_loc;
 }
 return &tokens_ptr[index];
 }
 /* Initialize an iterator so that it iterates over the tokens of a
 return NULL;
 return *it->token_ptr;
 }
 /* Return the location of the token pointed to by the iterator.*/
-static source_location
+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)
 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, source_location expansion_point_loc)
+	      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;
-source_location *virt_locs = 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
 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 (source_location).
+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);
 the current macro.  */
 static void
 push_extended_tokens_context (cpp_reader *pfile,
 			      cpp_hashnode *macro,
 			      _cpp_buff *token_buff,
-			      source_location *virt_locs,
+			      location_t *virt_locs,
 			      const cpp_token **first,
 			      unsigned int count)
 {
 cpp_context *context;
 macro_context *m;
 *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,
-		 source_location **virt_locs)
+		 location_t **virt_locs)
 {
 size_t tokens_size = len * sizeof (cpp_token *);
-size_t locs_size = len * sizeof (source_location);
+size_t locs_size = len * sizeof (location_t);
 if (virt_locs != NULL)
-*virt_locs = XNEWVEC (source_location, locs_size);
+*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*.  */
 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,
-			  source_location *virt_loc_dest,
+			  location_t *virt_loc_dest,
 			  const cpp_token *token,
-			  source_location virt_loc,
+			  location_t virt_loc,
-			  source_location parm_def_loc,
+			  location_t parm_def_loc,
 			  const line_map_macro *map,
 			  unsigned int macro_token_index)
 {
-source_location macro_loc = virt_loc;
+location_t macro_loc = virt_loc;
 const cpp_token **result;
 if (virt_loc_dest)
 {
 /* -ftrack-macro-expansion is on.  */
 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,
-		       source_location *virt_locs,
+		       location_t *virt_locs,
 		       const cpp_token *token,
-		       source_location virt_loc,
+		       location_t virt_loc,
-		       source_location parm_def_loc,
+		       location_t parm_def_loc,
 		       const line_map_macro *map,
 		       unsigned int macro_token_index)
 {
 const cpp_token **result;
-source_location *virt_loc_dest = NULL;
+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))
 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 (source_location, capacity);
+arg->expanded_virt_locs = XNEWVEC (location_t, capacity);
 }
 /* If necessary, enlarge ARG->expanded to so that it can contain SIZE
 tokens.  */
 *expanded_capacity = size;
 if (CPP_OPTION (pfile, track_macro_expansion))
 {
 if (arg->expanded_virt_locs == NULL)
-	arg->expanded_virt_locs = XNEWVEC (source_location, size);
+	arg->expanded_virt_locs = XNEWVEC (location_t, size);
 else
-	arg->expanded_virt_locs = XRESIZEVEC (source_location,
+	arg->expanded_virt_locs = XRESIZEVEC (location_t,
 					      arg->expanded_virt_locs,
 					      size);
 }
 }
 			 arg->first, arg->count + 1);
 for (;;)
 {
 const cpp_token *token;
-source_location location;
+location_t location;
 ensure_expanded_arg_room (pfile, arg, arg->expanded_count + 1,
 				&capacity);
 token = cpp_get_token_1 (pfile, &location);
 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,
-				 source_location *location)
+				 location_t *location)
 {
 cpp_context *c = pfile->context;
 if ((c)->tokens_kind == TOKENS_KIND_DIRECT)
 {
 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 source_location
+static inline location_t
-maybe_adjust_loc_for_trad_cpp (cpp_reader *pfile, source_location location)
+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;
 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, source_location *location)
+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.  */
-source_location virt_loc = 0;
+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;
 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, source_location *loc)
+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
 }
 }
 /* #define directive parsing and handling.  */
-/* Returns nonzero if a macro redefinition warning is required.  */
+/* Returns true if a macro redefinition warning is required.  */
 static bool
 warn_of_redefinition (cpp_reader *pfile, cpp_hashnode *node,
 		      const cpp_macro *macro2)
 {
-unsigned int i;
 /* 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,
 || macro1->fun_like != macro2->fun_like
 || macro1->variadic != macro2->variadic)
 return true;
 /* Check parameter spellings.  */
-for (i = 0; i < macro1->paramc; i++)
+for (unsigned i = macro1->paramc; i--; )
 if (macro1->parm.params[i] != macro2->parm.params[i])
 return true;
 /* Check the replacement text or tokens.  */
-if (CPP_OPTION (pfile, traditional))
+if (macro1->kind == cmk_traditional)
 return _cpp_expansions_different_trad (macro1, macro2);
 if (macro1->count != macro2->count)
 return true;
-for (i = 0; i < macro1->count; i++)
+for (unsigned i= macro1->count; i--; )
 if (!_cpp_equiv_tokens (&macro1->exp.tokens[i], &macro2->exp.tokens[i]))
 return true;
 return false;
 }
 macro = (cpp_macro *)_cpp_commit_buff
 (pfile, sizeof (cpp_macro) - sizeof (cpp_token)
 + sizeof (cpp_token) * macro->count);
-/* Clear whitespace on first token for warn_of_redefinition().  */
+/* Clear whitespace on first token.  */
 if (macro->count)
 macro->exp.tokens[0].flags &= ~PREV_WHITE;
 if (num_extra_tokens)
 {
 }
 *buffer = '\0';
 return pfile->macro_buffer;
 }
-/* Get the line at which the macro was defined.  */
-source_location
-cpp_macro_definition_location (cpp_hashnode *node)
-{
-return node->value.macro->line;
-}

Mercurial > hg > CbC > CbC_gcc

comparison libcpp/macro.c @ 145:1830386684a0