cpphash.c (CPP_IS_MACRO_BUFFER, [...]): Delete.

	* cpphash.c (CPP_IS_MACRO_BUFFER, FORWARD, PEEKC): Delete.
	(macro_cleanup): No need to cast pbuf->macro.
	(collect_expansion): Use _cpp_get_define_token.  Goto done if
	it returns VSPACE.  Remove check for trailing space after
	CPP_COMMENT.
	(_cpp_create_definition): Don't diddle flags here.  Return
	directly on error.
	(unsafe_chars): Handle c1 being EOF.
	(push_macro_expansion): Use unsafe_chars for both accidental-paste
	checks.  Don't push the buffer till after we're done with
	them.
	* cpplex.c (PEEKBUF, GETBUF, FORWARDBUF): New.
	(PEEKN, FORWARD, GETC, PEEKC): Use them.
	(cpp_push_buffer): Don't set new->alimit.  Set new->mark
	appropriately.
	(_cpp_parse_assertion): Don't NUL terminate.
	(_cpp_lex_token): Fix -traditional macro handling.  Don't skip
	hspace before calling _cpp_parse_assertion.  Remove all sets
	of only_seen_white. Treat '\f' as hspace.  Don't do anything
	special with '\n' here.
	(maybe_macroexpand): Handle T_EMPTY hash entries without
	pushing a buffer at all.
	(cpp_get_token): Handle clearing only_seen_white here.  Handle
	incrementing the line number here.  Clear
	potential_control_macro as well as only_seen_white, if
	appropriate.
	(cpp_get_non_space_token): Don't eat CPP_POP tokens.
	(_cpp_get_define_token): New function, basically like
	_cpp_get_directive_token was but doesn't eat horizontal space.
	Don't do anything with only_seen_white here.
	(_cpp_get_directive_token): Just call _cpp_get_define_token
	repeatedly till it returns non-hspace.

	* cpplib.c (PEEKN, FORWARD, GETC, PEEKC): Delete.
	(conditional_skip, skip_if_group): Return int.
	(DIRECTIVE_TABLE): Change origin of all conditional directives
	to "COND".
	(TRAD_DIRECT_P): New macro.
	(_cpp_handle_directive): Use _cpp_get_directive_token.  Issue
	an error for a bogus directive, unless -lang-asm.  Use
	TRAD_DIRECT_P. Loop calling handler functions till one returns
	zero.
	(get_macro_name): Don't diddle flags here.
	(do_define): Diddle flags here.  Use _cpp_get_directive_token.
	Create T_EMPTY nodes for #define macro /* nothing */.
	(do_undef): Don't copy the name.  Use _cpp_get_directive_token.
	Use hp->name when calling pass_thru_directive.
	(do_if, do_else, do_elif, do_ifdef, do_ifndef, conditional_skip):
	Return the result of conditional_skip and/or skip_if_group.
	Don't call _cpp_output_line_command.
	(consider_directive_while_skipping): Use _cpp_get_directive_token.
	Issue -Wtraditional warnings as appropriate.  Don't complain
	about unrecognized directives.  If we are to stop skipping,
	return the number of the directive that ended the skip.
	(skip_if_group): Use _cpp_get_directive_token.  Turn off macro
	expansion and line commands while skipping.  Return the result
	of consider_directive_while_skipping, if nonzero.
	(do_endif): Just set potential_control_macro here.
	(validate_else): Use _cpp_get_directive_token.
	(do_assert, do_unassert): Don't save pointers into the
	token_buffer across calls to the lexer.  Use
	_cpp_get_directive_token.

	* cpplib.h (cpp_buffer): Remove alimit and colno.  Make mark a
	pointer, not an offset.  Replace 'data', which was a generic
	pointer, with 'macro', which points to a struct hashnode.
	(cpp_reader): Add 'potential_control_macro' pointer.
	* cpphash.h (T_UNUSED): Replace with T_EMPTY.
	(CPP_BUF_GET, CPP_FORWARD): Delete.
	(CPP_IN_COLUMN_1, ADJACENT_TO_MARK): New macros.
	(CPP_IS_MACRO_BUFFER, CPP_SET_BUF_MARK, CPP_GOTO_BUF_MARK,
	ACTIVE_MARK_P): Update.
	(_cpp_get_define_token): New internal function.
	* cppfiles.c (read_include_file): Don't set fp->alimit or fp->colno.

From-SVN: r32965

1 files changed, 20 insertions, 9 deletions

diff --git a/gcc/cpphash.h b/gcc/cpphash.h
index 3d0a147..abf0d2b 100644
--- a/gcc/cpphash.h
+++ b/gcc/cpphash.h
@@ -98,7 +98,7 @@ enum node_type
   T_MACRO,	   /* macro defined by `#define' */
   T_DISABLED,	   /* macro temporarily turned off for rescan */
   T_POISON,	   /* macro defined with `#pragma poison' */
-  T_UNUSED	   /* Used for something not defined.  */
+  T_EMPTY	   /* macro defined to nothing */
 };
 
 /* different kinds of things that can appear in the value field
@@ -192,11 +192,11 @@ extern unsigned char _cpp_IStable[256];
 
 /* Macros.  */
 
+/* One character lookahead in the input buffer.  Note that if this
+   returns EOF, it does *not* necessarily mean the file's end has been
+   reached.  */
 #define CPP_BUF_PEEK(BUFFER) \
   ((BUFFER)->cur < (BUFFER)->rlimit ? *(BUFFER)->cur : EOF)
-#define CPP_BUF_GET(BUFFER) \
-  ((BUFFER)->cur < (BUFFER)->rlimit ? *(BUFFER)->cur++ : EOF)
-#define CPP_FORWARD(BUFFER, N) ((BUFFER)->cur += (N))
 
 /* Make sure PFILE->token_buffer has space for at least N more characters. */
 #define CPP_RESERVE(PFILE, N) \
@@ -223,6 +223,11 @@ extern unsigned char _cpp_IStable[256];
 #define CPP_BUMP_LINE(PFILE) CPP_BUMP_BUFFER_LINE(CPP_BUFFER(PFILE))
 #define CPP_PREV_BUFFER(BUFFER) ((BUFFER)->prev)
 
+/* Are we in column 1 right now?  Used mainly for -traditional handling
+   of directives.  */
+#define CPP_IN_COLUMN_1(PFILE) \
+(CPP_BUFFER (PFILE)->cur - CPP_BUFFER (PFILE)->line_base == 1)
+
 #define CPP_PRINT_DEPS(PFILE) CPP_OPTION (PFILE, print_deps)
 #define CPP_TRADITIONAL(PFILE) CPP_OPTION (PFILE, traditional)
 #define CPP_PEDANTIC(PFILE) \
@@ -232,7 +237,7 @@ extern unsigned char _cpp_IStable[256];
 
 /* CPP_IS_MACRO_BUFFER is true if the buffer contains macro expansion.
    (Note that it is false while we're expanding macro *arguments*.) */
-#define CPP_IS_MACRO_BUFFER(PBUF) ((PBUF)->data != NULL)
+#define CPP_IS_MACRO_BUFFER(PBUF) ((PBUF)->macro != NULL)
 
 /* Remember the current position of PFILE so it may be returned to
    after looking ahead a bit.
@@ -241,14 +246,18 @@ extern unsigned char _cpp_IStable[256];
    may not forget about it and continue parsing.  You may not pop a
    buffer with an active mark.  You may not call CPP_BUMP_LINE while a
    mark is active.  */
-#define CPP_SET_BUF_MARK(IP)   ((IP)->mark = (IP)->cur - (IP)->buf)
-#define CPP_GOTO_BUF_MARK(IP)  ((IP)->cur = (IP)->buf + (IP)->mark, \
-				(IP)->mark = -1)
+#define CPP_SET_BUF_MARK(IP)   ((IP)->mark = (IP)->cur)
+#define CPP_GOTO_BUF_MARK(IP)  ((IP)->cur = (IP)->mark,	(IP)->mark = 0)
 #define CPP_SET_MARK(PFILE)  CPP_SET_BUF_MARK(CPP_BUFFER(PFILE))
 #define CPP_GOTO_MARK(PFILE) CPP_GOTO_BUF_MARK(CPP_BUFFER(PFILE))
 
 /* ACTIVE_MARK_P is true if there's a live mark in the buffer.  */
-#define ACTIVE_MARK_P(PFILE) (CPP_BUFFER (PFILE)->mark != -1)
+#define ACTIVE_MARK_P(PFILE) (CPP_BUFFER (PFILE)->mark != 0)
+
+/* Are mark and point adjacent characters?  Used mostly to deal with
+   the somewhat annoying semantic of #define.  */
+#define ADJACENT_TO_MARK(PFILE) \
+ (CPP_BUFFER(PFILE)->cur - CPP_BUFFER(PFILE)->mark == 1)
 
 /* Last arg to output_line_command.  */
 enum file_change_code {same_file, rename_file, enter_file, leave_file};
@@ -296,6 +305,8 @@ extern void _cpp_init_input_buffer	PARAMS ((cpp_reader *));
 extern void _cpp_grow_token_buffer	PARAMS ((cpp_reader *, long));
 extern enum cpp_token _cpp_get_directive_token
 					PARAMS ((cpp_reader *));
+extern enum cpp_token _cpp_get_define_token
+					PARAMS ((cpp_reader *));
 
 /* In cpplib.c */
 extern int _cpp_handle_directive	PARAMS ((cpp_reader *));