cppfiles.c (read_and_prescan): Map backslash-newline to '\r' (which cannot…

cppfiles.c (read_and_prescan): Map backslash-newline to '\r' (which cannot otherwise appear in the processed...

1999-03-16 16:06 -0500  Zack Weinberg  <zack@rabi.columbia.edu>
	* cppfiles.c (read_and_prescan): Map backslash-newline to '\r'
	(which cannot otherwise appear in the processed buffer) and
	move it out of tokens that it appears in the middle of.
	Improve performance.
	(find_position): New function.
	* cpplib.c: \r (one character) indicates backslash
	newline, not \\\n (two characters).  It cannot appear in the
	middle of a token.  Call CPP_BUMP_LINE (pfile) whenever
	parsing moves past \n or \r.  Increment pfile->lineno whenever
	a \n is placed into token_buffer.  Only one mark can exist at
	a time, and CPP_BUMP_LINE must not be used while it is
	active.  It is automatically cleared by cpp_pop_buffer and
	parse_goto_mark.  \r is not in is_hor_space or is_space.
	(NEWLINE_FIX, NEWLINE_FIX1, adjust_position,
	update_position, count_newlines, parse_move_mark): Removed.
	(parse_string, copy_comment): New functions.
	(parse_name): Returns void.
	(parse_set_mark, parse_clear_mark, parse_goto_mark): Take only
	one argument, a cpp_reader *.  Change for new marking scheme.
	(skip_comment): Handle CHILL line comments too.  Second
	argument is now first character of comment marker; all callers
	changed.  Issue error for unterminated block comment here.
	(cpp_skip_hspace): Recognize CHILL comments.
	(copy_rest_of_line): Likewise.  Call skip_comment and
	parse_string directly, don't go through cpp_get_token.  Emit
	"/**/" for block comments if -traditional (create_definition
	needs this).
	(do_define): Don't play with put_out_comments.
	(cpp_push_buffer): Initialize ->mark to -1.
	(cpp_buf_line_and_col): Just read out the values in the buffer
	structure.
	(output_line_command): Use cpp_buf_line_and_col.  Fix
	formatting.  Remove stale code.
	(cpp_get_token): Break out string parsing code to
	parse_string.  Use skip_comment for CHILL comments too.  Use
	copy_comment for put_out_comments instead of dinking with
	marks.  Remove stale code.  Don't call output_line_command
	unless it's necessary.
	* cpplib.h (parse_marker): Removed.
	(struct cpp_buffer): line_base is now a unsigned char *; add
	`mark' [long], remove `marks' [struct parse_marker *].
	(parse_set_mark, parse_clear_mark, parse_goto_mark): Update
	prototypes.
	(CPP_BUMP_LINE, CPP_BUMP_BUFFER_LINE): New macros.
	* cppinit.c (is_hor_space, is_space): '\r' is not considered
	whitespace.
	* cppexp.c (cpp_parse_expression): Use cpp_skip_hspace, not
	SKIP_WHITE_SPACE.
	* cpphash.c (macarg): Disable line commands while expanding.

From-SVN: r25802

gcc/ChangeLog

+1999-03-16 16:06 -0500  Zack Weinberg  <zack@rabi.columbia.edu>
+
+	* cppfiles.c (read_and_prescan): Map backslash-newline to '\r'
+	(which cannot otherwise appear in the processed buffer) and
+	move it out of tokens that it appears in the middle of.
+	Improve performance.
+	(find_position): New function.
+
+	* cpplib.c: \r (one character) indicates backslash
+	newline, not \\\n (two characters).  It cannot appear in the
+	middle of a token.  Call CPP_BUMP_LINE (pfile) whenever
+	parsing moves past \n or \r.  Increment pfile->lineno whenever
+	a \n is placed into token_buffer.  Only one mark can exist at
+	a time, and CPP_BUMP_LINE must not be used while it is
+	active.  It is automatically cleared by cpp_pop_buffer and
+	parse_goto_mark.  \r is not in is_hor_space or is_space.
+
+	(NEWLINE_FIX, NEWLINE_FIX1, adjust_position,
+	update_position, count_newlines, parse_move_mark): Removed.
+	(parse_string, copy_comment): New functions.
+	(parse_name): Returns void.
+	(parse_set_mark, parse_clear_mark, parse_goto_mark): Take only
+	one argument, a cpp_reader *.  Change for new marking scheme.
+	(skip_comment): Handle CHILL line comments too.  Second
+	argument is now first character of comment marker; all callers
+	changed.  Issue error for unterminated block comment here.
+	(cpp_skip_hspace): Recognize CHILL comments.
+	(copy_rest_of_line): Likewise.  Call skip_comment and
+	parse_string directly, don't go through cpp_get_token.  Emit
+	"/**/" for block comments if -traditional (create_definition
+	needs this).
+	(do_define): Don't play with put_out_comments.
+	(cpp_push_buffer): Initialize ->mark to -1.
+	(cpp_buf_line_and_col): Just read out the values in the buffer
+	structure.
+	(output_line_command): Use cpp_buf_line_and_col.  Fix
+	formatting.  Remove stale code.
+	(cpp_get_token): Break out string parsing code to
+	parse_string.  Use skip_comment for CHILL comments too.  Use
+	copy_comment for put_out_comments instead of dinking with
+	marks.  Remove stale code.  Don't call output_line_command
+	unless it's necessary.
+
+	* cpplib.h (parse_marker): Removed.
+	(struct cpp_buffer): line_base is now a unsigned char *; add
+	`mark' [long], remove `marks' [struct parse_marker *].
+	(parse_set_mark, parse_clear_mark, parse_goto_mark): Update
+	prototypes.
+	(CPP_BUMP_LINE, CPP_BUMP_BUFFER_LINE): New macros.
+	* cppinit.c (is_hor_space, is_space): '\r' is not considered
+	whitespace.
+	* cppexp.c (cpp_parse_expression): Use cpp_skip_hspace, not
+	SKIP_WHITE_SPACE.
+	* cpphash.c (macarg): Disable line commands while expanding.
+
 Tue Mar 16 11:30:19 1999  Gavin Romig-Koch  <gavin@cygnus.com>
 
 	* c-lex.c (yylex) : Remove warning for integer literals being

gcc/cppexp.c

@@ -101,8 +101,6 @@ static HOST_WIDEST_INT right_shift PARAMS ((cpp_reader *, HOST_WIDEST_INT, int,
 #define SKIP_OPERAND 8
 /*#define UNSIGNEDP 16*/
 
-#define SKIP_WHITE_SPACE(p) do { while (is_hor_space[*p]) p++; } while (0)
-
 struct operation {
     short op;
     char rprio; /* Priority of op (relative to it right operand).  */
@@ -444,12 +442,12 @@ cpp_lex (pfile, skip_evaluation)
 	  cpp_buffer *ip = CPP_BUFFER (pfile);
 	  U_CHAR *tok;
 
-	  SKIP_WHITE_SPACE (ip->cur);
+	  cpp_skip_hspace (pfile);
 	  if (*ip->cur == '(')
 	    {
 	      paren++;
 	      ip->cur++;			/* Skip over the paren */
-	      SKIP_WHITE_SPACE (ip->cur);
+	      cpp_skip_hspace (pfile);
 	    }
 
 	  if (!is_idstart[*ip->cur])
@@ -460,7 +458,7 @@ cpp_lex (pfile, skip_evaluation)
 	  while (is_idchar[*ip->cur])
 	    ++ip->cur;
 	  len = ip->cur - tok;
-	  SKIP_WHITE_SPACE (ip->cur);
+	  cpp_skip_hspace (pfile);
 	  if (paren)
 	    {
 	      if (*ip->cur != ')')

gcc/cppfiles.c

@@ -757,15 +757,51 @@ actual_directory (pfile, fname)
   return x;
 }
 
-/* Read the entire contents of file DESC into buffer BUF, convert end-of-line
-   markers to canonical form, and convert trigraphs if enabled.  Also, make
-   sure there is a newline at the end of the file.  LEN is how much room we
-   have to start with (this can be expanded if necessary).
-   Returns -1 on failure, or the actual length of the data to be scanned.
+/* Almost but not quite the same as adjust_position in cpplib.c.
+   Used only by read_and_prescan. */
+static void
+find_position (start, limit, linep, colp)
+     U_CHAR *start;
+     U_CHAR *limit;
+     long *linep;
+     long *colp;
+{
+  long line = *linep, col = 0;
+  while (start < limit)
+    {
+      U_CHAR ch = *start++;
+      if (ch == '\n' || ch == '\r')
+	line++, col = 1;
+      else
+	col++;
+    }
+  *linep = line, *colp = col;
+}
 
-   N.B. This function has been rearranged to out-of-line the uncommon cases
-   as much as possible; this is important to prevent it from being a
-   performance bottleneck.  */
+/* Read the entire contents of file DESC into buffer BUF.  LEN is how
+   much memory to allocate initially; more will be allocated if
+   necessary.  Convert end-of-line markers (\n, \r, \r\n, \n\r) to
+   canonical form (\n).  If enabled, convert and/or warn about
+   trigraphs.  Convert backslash-newline to a one-character escape
+   (\r) and remove it from "embarrassing" places (i.e. the middle of a
+   token).  If there is no newline at the end of the file, add one and
+   warn.  Returns -1 on failure, or the actual length of the data to
+   be scanned.
+
+   This function does a lot of work, and can be a serious performance
+   bottleneck.  It has been tuned heavily; make sure you understand it
+   before hacking.  The common case - no trigraphs, Unix style line
+   breaks, backslash-newline set off by whitespace, newline at EOF -
+   has been optimized at the expense of the others.  The performance
+   penalty for DOS style line breaks (\r\n) is about 15%.
+   
+   Warnings lose particularly heavily since we have to determine the
+   line number, which involves scanning from the beginning of the file
+   or from the last warning.  The penalty for the absence of a newline
+   at the end of reload1.c is about 60%.  (reload1.c is 329k.)
+
+   If your file has more than one kind of end-of-line marker, you
+   will get messed-up line numbering.  */
 
 static long
 read_and_prescan (pfile, fp, desc, len)
@@ -774,29 +810,47 @@ read_and_prescan (pfile, fp, desc, len)
      int desc;
      size_t len;
 {
-  U_CHAR *buf = (U_CHAR *) xmalloc (len);
+  U_CHAR *buf = xmalloc (len);
   U_CHAR *ip, *op, *line_base;
   U_CHAR *ibase;
-  unsigned int line;
+  unsigned int line, deferred_newlines;
   int count;
   size_t offset;
-  /* 4096 bytes of buffer proper, 2 to detect running off the end without
-     address arithmetic all the time, and 2 for pushback in the case there's
-     a potential trigraph or end-of-line digraph at the end of a block. */
-#define INTERMED_BUFFER_SIZE 4096
-  U_CHAR intermed[INTERMED_BUFFER_SIZE + 2 + 2];
+  /* PIPE_BUF bytes of buffer proper, 2 to detect running off the end
+     without address arithmetic all the time, and 2 for pushback in
+     the case there's a potential trigraph or end-of-line digraph at
+     the end of a block. */
+  U_CHAR intermed[PIPE_BUF + 2 + 2];
+
+  /* Table of characters that can't be handled in the inner loop.
+     Keep these contiguous to optimize the performance of the code generated
+     for the switch that uses them.  */
+  #define SPECCASE_EMPTY     0
+  #define SPECCASE_NUL       1
+  #define SPECCASE_CR        2
+  #define SPECCASE_BACKSLASH 3
+  #define SPECCASE_QUESTION  4
+  U_CHAR speccase[256];
 
   offset = 0;
   op = buf;
   line_base = buf;
   line = 1;
   ibase = intermed + 2;
+  deferred_newlines = 0;
+
+  memset (speccase, SPECCASE_EMPTY, sizeof (speccase));
+  speccase['\0'] = SPECCASE_NUL;
+  speccase['\r'] = SPECCASE_CR;
+  speccase['\\'] = SPECCASE_BACKSLASH;
+  if (CPP_OPTIONS (pfile)->trigraphs || CPP_OPTIONS (pfile)->warn_trigraphs)
+    speccase['?'] = SPECCASE_QUESTION;
 
   for (;;)
     {
     read_next:
 
-      count = read (desc, intermed + 2, INTERMED_BUFFER_SIZE);
+      count = read (desc, intermed + 2, PIPE_BUF);
       if (count < 0)
 	goto error;
       else if (count == 0)
@@ -827,48 +881,102 @@ read_and_prescan (pfile, fp, desc, len)
 
       for (;;)
 	{
-	  unsigned int c;
-	  c = *ip++;
-	  switch (c)
+	  unsigned int span = 0;
+
+	  /* Deal with \-newline in the middle of a token. */
+	  if (deferred_newlines)
 	    {
-	      /* The default case is at the top so gcc will realize
-		 it's the common case, and leave c in a register.
-	         Also, cache utilization is a little better this way. */
-	    default:
-	      *op++ = c;
-	      break;
+	      while (speccase[ip[span]] == SPECCASE_EMPTY
+		     && ip[span] != '\n'
+		     && ip[span] != '\t'
+		     && ip[span] != ' ')
+		span++;
+	      memcpy (op, ip, span);
+	      op += span;
+	      ip += span;
+	      if (*ip == '\n' || *ip == '\t'
+		  || *ip == ' ' || *ip == ' ')
+		while (deferred_newlines)
+		  deferred_newlines--, *op++ = '\r';
+	      span = 0;
+	    }
+
+	  /* Copy as much as we can without special treatment. */
+	  while (speccase[ip[span]] == SPECCASE_EMPTY) span++;
+	  memcpy (op, ip, span);
+	  op += span;
+	  ip += span;
 
-	    case '\0':
+	  switch (speccase[*ip++])
+	    {
+	    case SPECCASE_NUL:  /* \0 */
+	      ibase[-1] = op[-1];
 	      goto read_next;
-	    case '\r':
-	      if (*ip == '\n') ip++;
+
+	    case SPECCASE_CR:  /* \r */
+	      if (*ip == '\n')
+		ip++;
 	      else if (*ip == '\0')
 		{
 		  --ibase;
 		  intermed[1] = '\r';
 		  goto read_next;
 		}
+	      else if (ip[-2] == '\n')
+		continue;
 	      *op++ = '\n';
-	      line++;
-	      line_base = op;
 	      break;
 
-	    case '\n':
+	    case SPECCASE_BACKSLASH:  /* \ */
+	    backslash:
+	    {
+	      /* If we're at the end of the intermediate buffer,
+		 we have to shift the backslash down to the start
+		 and come back next pass. */
+	      if (*ip == '\0')
+		{
+		  --ibase;
+		  intermed[1] = '\\';
+		  goto read_next;
+		}
+	      else if (*ip == '\n')
+		{
+		  ip++;
 		  if (*ip == '\r') ip++;
+		  if (*ip == '\n' || *ip == '\t' || *ip == ' ')
+		    *op++ = '\r';
+		  else if (op[-1] == '\t' || op[-1] == ' '
+			   || op[-1] == '\r' || op[-1] == '\n')
+		    *op++ = '\r';
+		  else
+		    deferred_newlines++;
+		  line++;
+		  line_base = op;
+		}
+	      else if (*ip == '\r')
+		{
+		  ip++;
+		  if (*ip == '\n') ip++;
 		  else if (*ip == '\0')
 		    {
-		  --ibase;
-		  intermed[1] = '\n';
+		      ibase -= 2;
+		      intermed[0] = '\\';
+		      intermed[1] = '\r';
 		      goto read_next;
 		    }
-	      *op++ = '\n';
+		  else if (*ip == '\r' || *ip == '\t' || *ip == ' ')
+		    *op++ = '\r';
+		  else
+		    deferred_newlines++;
 		  line++;
 		  line_base = op;
+		}
+	      else
+		*op++ = '\\';
+	    }
 	    break;
 
-	    case '?':
-	      if (CPP_OPTIONS (pfile)->trigraphs
-		  || CPP_OPTIONS (pfile)->warn_trigraphs)
+	    case SPECCASE_QUESTION: /* ? */
 	      {
 		unsigned int d;
 		/* If we're at the end of the intermediate buffer,
@@ -900,10 +1008,20 @@ read_and_prescan (pfile, fp, desc, len)
 		  }
 
 		if (CPP_OPTIONS (pfile)->warn_trigraphs)
-		    cpp_warning_with_line (pfile, line, op-line_base,
+		  {
+		    long col;
+		    find_position (line_base, op, &line, &col);
+		    line_base = op - col;
+		    cpp_warning_with_line (pfile, line, col,
 					   "trigraph ??%c encountered", d);
+		  }
 		if (CPP_OPTIONS (pfile)->trigraphs)
+		  {
+		    if (trigraph_table[d] == '\\')
+		      goto backslash;
+		    else
 		      *op++ = trigraph_table[d];
+		  }
 		else
 		  {
 		    *op++ = '?';
@@ -912,8 +1030,6 @@ read_and_prescan (pfile, fp, desc, len)
 		  }
 		ip += 2;
 	      }
-	      else
-		*op++ = c;
 	    }
 	}
     }
@@ -922,47 +1038,48 @@ read_and_prescan (pfile, fp, desc, len)
     return 0;
 
   /* Deal with pushed-back chars at true EOF.
-     If two chars were pushed back, they must both be ?'s.
-     If one was, it might be ?, \r, or \n, and \r needs to
-     become \n.
+     This may be any of:  ?? ? \ \r \n \\r \\n.
+     \r must become \n, \\r or \\n must become \r.
      We know we have space already. */
   if (ibase == intermed)
     {
+      if (*ibase == '?')
+	{
 	  *op++ = '?';
 	  *op++ = '?';
 	}
+      else
+	*op++ = '\r';
+    }
   else if (ibase == intermed + 1)
     {
-      if (*ibase == '?')
-	*op++ = '?';
-      else
+      if (*ibase == '\r')
 	*op++ = '\n';
+      else
+	*op++ = *ibase;
     }
 
-  if (op[-1] != '\n' || op[-2] == '\\')
+  if (op[-1] != '\n')
     {
-      if (CPP_PEDANTIC (pfile))
-	cpp_pedwarn_with_line (pfile, line, op - line_base,
-			       "no newline at end of file");
-      if (offset + 2 > len)
+      long col;
+      find_position (line_base, op, &line, &col);
+      cpp_warning_with_line (pfile, line, col, "no newline at end of file\n");
+      if (offset + 1 > len)
 	{
-	  len += 2;
-	  if (offset + 2 > len)
+	  len += 1;
+	  if (offset + 1 > len)
 	    goto too_big;
 	  buf = (U_CHAR *) xrealloc (buf, len);
 	  op = buf + offset;
 	}
-      if (op[-1] == '\\')
-	*op++ = '\n';
       *op++ = '\n';
     }
 
-  fp->buf =
-    (U_CHAR *) ((len - offset < 20) ? (PTR) buf : xrealloc (buf, op - buf));
+  fp->buf = ((len - offset < 20) ? buf : (U_CHAR *)xrealloc (buf, op - buf));
   return op - buf;
 
  too_big:
-  cpp_error (pfile, "file is too large");
+  cpp_error (pfile, "file is too large (>%lu bytes)\n", (unsigned long)offset);
   free (buf);
   return -1;
 

gcc/cpphash.c

@@ -787,6 +787,7 @@ macarg (pfile, rest_args)
   /* Try to parse as much of the argument as exists at this
      input stack level.  */
   pfile->no_macro_expand++;
+  CPP_OPTIONS (pfile)->no_line_commands++;
   for (;;)
     {
       token = cpp_get_token (pfile);
@@ -824,6 +825,7 @@ macarg (pfile, rest_args)
 
 done:
   CPP_OPTIONS (pfile)->put_out_comments = save_put_out_comments;
+  CPP_OPTIONS (pfile)->no_line_commands--;
   pfile->no_macro_expand--;
 
   return token;

gcc/cppinit.c

@@ -255,15 +255,16 @@ U_CHAR is_idstart[256] =
   ['_']  = 1,
 };
 
-/* Table to tell if a character is horizontal space. */
+/* Table to tell if a character is horizontal space.
+   \r is magical, so it is not in here.  */
 U_CHAR is_hor_space[256] =
 {
-  [' '] = 1, ['\t'] = 1, ['\v'] = 1, ['\f'] = 1, ['\r'] = 1
+  [' '] = 1, ['\t'] = 1, ['\v'] = 1, ['\f'] = 1,
 };
 /* table to tell if a character is horizontal or vertical space.  */
 U_CHAR is_space[256] =
 {
-  [' '] = 1, ['\t'] = 1, ['\v'] = 1, ['\f'] = 1, ['\r'] = 1, ['\n'] = 1,
+  [' '] = 1, ['\t'] = 1, ['\v'] = 1, ['\f'] = 1, ['\n'] = 1,
 };
 /* Table to handle trigraph conversion, which occurs before all other
    processing, everywhere in the file.  (This is necessary since one
@@ -362,14 +363,12 @@ initialize_char_syntax (dollar_in_ident)
   is_hor_space['\t'] = 1;
   is_hor_space['\v'] = 1;
   is_hor_space['\f'] = 1;
-  is_hor_space['\r'] = 1;
 
   is_space[' '] = 1;
   is_space['\t'] = 1;
   is_space['\v'] = 1;
   is_space['\f'] = 1;
   is_space['\n'] = 1;
-  is_space['\r'] = 1;
 
   /* trigraph conversion */
   trigraph_table['='] = '#';  trigraph_table[')'] = ']';

gcc/cpplib.c

@@ -36,21 +36,6 @@ Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
    (Note that it is false while we're expanding macro *arguments*.) */
 #define CPP_IS_MACRO_BUFFER(PBUF) ((PBUF)->data != NULL)
 
-/* Move all backslash-newline pairs out of embarrassing places.
-   Exchange all such pairs following BP
-   with any potentially-embarrassing characters that follow them.
-   Potentially-embarrassing characters are / and *
-   (because a backslash-newline inside a comment delimiter
-   would cause it not to be recognized).  */
-
-#define NEWLINE_FIX \
-  do {while (PEEKC() == '\\' && PEEKN(1) == '\n') FORWARD(2); } while(0)
-
-/* Same, but assume we've already read the potential '\\' into C.  */
-#define NEWLINE_FIX1(C) do { \
-    while ((C) == '\\' && PEEKC() == '\n') { FORWARD(1); (C) = GETC(); }\
-  } while(0)
-
 /* Forward declarations.  */
 
 static char *my_strerror		PROTO ((int));
@@ -60,7 +45,10 @@ static HOST_WIDEST_INT eval_if_expression	PROTO ((cpp_reader *));
 static void conditional_skip		PROTO ((cpp_reader *, int,
 						enum node_type, U_CHAR *));
 static void skip_if_group		PROTO ((cpp_reader *));
-static int parse_name                   PARAMS ((cpp_reader *, int));
+
+static void parse_name			PARAMS ((cpp_reader *, int));
+static void parse_string		PARAMS ((cpp_reader *, int));
+static int parse_assertion		PARAMS ((cpp_reader *));
 
 /* External declarations.  */
 
@@ -245,106 +233,188 @@ null_cleanup (pbuf, pfile)
   return 0;
 }
 
-/* Assuming we have read '/'.
-   If this is the start of a comment (followed by '*' or '/'),
-   skip to the end of the comment, and return ' '.
-   Return EOF if we reached the end of file before the end of the comment.
-   If not the start of a comment, return '/'.  */
+/* Skip a comment - C, C++, or Chill style.  M is the first character
+   of the comment marker.  If this really is a comment, skip to its
+   end and return ' '.  If we hit end-of-file before end-of-comment,
+   return EOF.  If this is not a comment, return M (which will be
+   '/' or '-').  */
 
 static int
-skip_comment (pfile, linep)
+skip_comment (pfile, m)
      cpp_reader *pfile;
-     long *linep;
+     int m;
 {
-  int c = 0;
-  while (PEEKC() == '\\' && PEEKN(1) == '\n')
-    {
-      if (linep)
-	(*linep)++;
-      FORWARD(2);
-    }
-  if (PEEKC() == '*')
+  if (m == '/' && PEEKC() == '*')
     {
+      int c, prev_c = -1;
+      long line, col;
+      
       FORWARD(1);
+      cpp_buf_line_and_col (CPP_BUFFER (pfile), &line, &col);
       for (;;)
 	{
-	  int prev_c = c;
 	  c = GETC ();
 	  if (c == EOF)
-	    return EOF;
-	  while (c == '\\' && PEEKC() == '\n')
 	    {
-	      if (linep)
-		(*linep)++;
-	      FORWARD(1), c = GETC();
+	      cpp_error_with_line (pfile, line, col, "unterminated comment");
+	      return EOF;
 	    }
-	  if (prev_c == '*' && c == '/')
+	  else if (c == '\n' || c == '\r')
+	    CPP_BUMP_LINE (pfile);
+	  else if (c == '/' && prev_c == '*')
 	    return ' ';
-	  if (c == '\n' && linep)
-	    (*linep)++;
+	  else if (c == '*' && prev_c == '/'
+		   && CPP_OPTIONS (pfile)->warn_comments)
+	    cpp_warning (pfile, "`/*' within comment");
+
+	  prev_c = c;
 	}
     }
-  else if (PEEKC() == '/' && CPP_OPTIONS (pfile)->cplusplus_comments)
+  else if ((m == '/' && PEEKC() == '/'
+	    && CPP_OPTIONS (pfile)->cplusplus_comments)
+	   || (m == '-' && PEEKC() == '-'
+	       && CPP_OPTIONS (pfile)->chill))
     {
       FORWARD(1);
       for (;;)
 	{
-	  c = GETC ();
+	  int c = GETC ();
 	  if (c == EOF)
 	    return ' '; /* Allow // to be terminated by EOF.  */
-	  while (c == '\\' && PEEKC() == '\n')
+	      if (c == '\n')
+		{
+		  /* Don't consider final '\n' to be part of comment.  */
+		  FORWARD(-1);
+		  return ' ';
+		}
+	      else if (c == '\r')
+		CPP_BUMP_LINE (pfile);
+	}
+    }
+  else
+    return m;
+}
+
+/* Identical to skip_comment except that it copies the comment into the
+   token_buffer.  This is used if put_out_comments.  */
+static int
+copy_comment (pfile, m)
+     cpp_reader *pfile;
+     int m;
+{
+  if (m == '/' && PEEKC() == '*')
     {
+      int c, prev_c = -1;
+      long line, col;
+
+      CPP_PUTC (pfile, '/');
+      CPP_PUTC (pfile, '*');
       FORWARD(1);
-	      c = GETC();
-	      if (linep)
-		(*linep)++;
+      cpp_buf_line_and_col (CPP_BUFFER (pfile), &line, &col);
+      for (;;)
+	{
+	  c = GETC ();
+	  if (c == EOF)
+	    {
+	      cpp_error_with_line (pfile, line, col, "unterminated comment");
+	      /* We must pretend this was a legitimate comment, so that the
+		 output in token_buffer is not passed back tagged CPP_POP. */
+	      return ' ';
 	    }
+	  else if (c == '\r')
+	    {
+	      CPP_BUMP_LINE (pfile);
+	      continue;
+	    }
+
+	  CPP_PUTC (pfile, c);
 	  if (c == '\n')
 	    {
+	      pfile->lineno++;
+	      CPP_BUMP_LINE (pfile);
+	    }
+	  else if (c == '/' && prev_c == '*')
+	    return ' ';
+	  else if (c == '*' && prev_c == '/'
+		   && CPP_OPTIONS (pfile)->warn_comments)
+	    cpp_warning (pfile, "`/*' within comment");
+
+	  prev_c = c;
+	}
+    }
+  else if ((m == '/' && PEEKC() == '/'
+	    && CPP_OPTIONS (pfile)->cplusplus_comments)
+	   || (m == '-' && PEEKC() == '-'
+	       && CPP_OPTIONS (pfile)->chill))
+    {
+      CPP_PUTC (pfile, m);
+      CPP_PUTC (pfile, m);
+      FORWARD(1);
+      for (;;)
+	{
+	  int c = GETC ();
+	  if (c == EOF)
+	    return ' '; /* Allow line comments to be terminated by EOF. */
+	  else if (c == '\n')
+	    {
 	      /* Don't consider final '\n' to be part of comment.  */
 	      FORWARD(-1);
 	      return ' ';
 	    }
+	  else if (c == '\r')
+	    CPP_BUMP_LINE (pfile);
+
+	  CPP_PUTC (pfile, c);
 	}
     }
   else
-    return '/';
+    return m;
 }
 
+
 /* Skip whitespace \-newline and comments.  Does not macro-expand.  */
 
 void
 cpp_skip_hspace (pfile)
      cpp_reader *pfile;
 {
+  int c;
   while (1)
     {
-      int c = PEEKC();
+      c = GETC();
       if (c == EOF)
-	return; /* FIXME */
-      if (is_hor_space[c])
+	return;
+      else if (is_hor_space[c])
 	{
 	  if ((c == '\f' || c == '\v') && CPP_PEDANTIC (pfile))
 	    cpp_pedwarn (pfile, "%s in preprocessing directive",
 			 c == '\f' ? "formfeed" : "vertical tab");
-	  FORWARD(1);
 	}
-      else if (c == '/')
+      else if (c == '\r')
+	{
+	  CPP_BUFFER (pfile)->lineno++;
+	}
+      else if (c == '/' || c == '-')
+	{
+	  c = skip_comment (pfile, c);
+	  if (c == EOF)
+	    return;
+	  else if (c != ' ')
 	    {
-	  FORWARD (1);
-	  c = skip_comment (pfile, NULL);
-	  if (c == '/')
 	      FORWARD(-1);
-	  if (c == EOF || c == '/')
 	      return;
 	    }
-      else if (c == '\\' && PEEKN(1) == '\n') {
-	FORWARD(2);
 	}
       else if (c == '@' && CPP_BUFFER (pfile)->has_escapes
-	       && is_hor_space[PEEKN(1)])
-	FORWARD(2);
-      else return;
+	       && PEEKC() == ' ')
+	{
+	  FORWARD(1);
+	}
+      else
+	{
+	  FORWARD(-1);
+	  return;
+	}
     }
 }
 
@@ -355,30 +425,36 @@ static void
 copy_rest_of_line (pfile)
      cpp_reader *pfile;
 {
-  struct cpp_options *opts = CPP_OPTIONS (pfile);
   for (;;)
     {
       int c = GETC();
-      int nextc;
       switch (c)
 	{
+	case '\n':
+	  FORWARD(-1);
 	case EOF:
-	  goto end_directive;
-	case '\\':
-	  if (PEEKC() == '\n')
-	    {
-	      FORWARD (1);
+	  CPP_NUL_TERMINATE (pfile);
+	  return;
+
+	case '\r':
+	  CPP_BUFFER (pfile)->lineno++;
 	  continue;
-	    }
 	case '\'':
 	case '\"':
-	  goto scan_directive_token;
-	  break;
+	  parse_string (pfile, c);
+	  continue;
 	case '/':
-	  nextc = PEEKC();
-	  if (nextc == '*' || (opts->cplusplus_comments && nextc == '/'))
-	    goto scan_directive_token;
+	  if (PEEKC() == '*' && CPP_TRADITIONAL (pfile))
+	    {
+	      CPP_PUTS (pfile, "/**/", 4);
+	      skip_comment (pfile, c);
+	      continue;
+	    }
+	  /* else fall through */
+	case '-':
+	  c = skip_comment (pfile, c);
 	  break;
+
 	case '\f':
 	case '\v':
 	  if (CPP_PEDANTIC (pfile))
@@ -386,20 +462,15 @@ copy_rest_of_line (pfile)
 			 c == '\f' ? "formfeed" : "vertical tab");
 	  break;
 
-	case '\n':
-	  FORWARD(-1);
-	  goto end_directive;
-	scan_directive_token:
-	  FORWARD(-1);
-	  cpp_get_token (pfile);
-	  continue;
 	}
       CPP_PUTC (pfile, c);
     }
- end_directive: ;
-  CPP_NUL_TERMINATE (pfile);
 }
 
+/* FIXME: It is almost definitely a performance win to make this do
+   the scan itself.  >75% of calls to copy_r_o_l are from here or
+   skip_if_group, which means the common case is to copy stuff into the
+   token_buffer only to discard it.  */
 void
 skip_rest_of_line (pfile)
      cpp_reader *pfile;
@@ -415,7 +486,8 @@ skip_rest_of_line (pfile)
 static int
 handle_directive (pfile)
      cpp_reader *pfile;
-{ int c;
+{
+  int c;
   register struct directive *kt;
   int ident_length;
   U_CHAR *ident;
@@ -590,16 +662,11 @@ do_define (pfile, keyword)
   int hashcode;
   MACRODEF mdef;
   HASHNODE *hp;
-  int save_put_out_comments;
   long here;
   U_CHAR *macro, *buf, *end;
 
   here = CPP_WRITTEN (pfile);
-  
-  save_put_out_comments = CPP_OPTIONS (pfile)->put_out_comments;
-  CPP_OPTIONS (pfile)->put_out_comments = CPP_TRADITIONAL (pfile);
   copy_rest_of_line (pfile);
-  CPP_OPTIONS (pfile)->put_out_comments = save_put_out_comments;
 
   /* Copy out the line so we can pop the token buffer. */
   buf = pfile->token_buffer + here;
@@ -696,6 +763,7 @@ cpp_push_buffer (pfile, buffer, length)
   new->buf = new->cur = buffer;
   new->alimit = new->rlimit = buffer + length;
   new->prev = buf;
+  new->mark = -1;
 
   CPP_BUFFER (pfile) = new;
   return new;
@@ -781,58 +849,21 @@ cpp_expand_to_buffer (pfile, buf, length)
   CPP_NUL_TERMINATE (pfile);
 }
 
-static void
-adjust_position (buf, limit, linep, colp)
-     U_CHAR *buf;
-     U_CHAR *limit;
-     long *linep;
-     long *colp;
-{
-  while (buf < limit)
-    {
-      U_CHAR ch = *buf++;
-      if (ch == '\n')
-	(*linep)++, (*colp) = 1;
-      else
-	(*colp)++;
-    }
-}
-
-/* Move line_base forward, updating lineno and colno.  */
-
-static void
-update_position (pbuf)
-     register cpp_buffer *pbuf;
-{
-  unsigned char *old_pos = pbuf->buf + pbuf->line_base;
-  unsigned char *new_pos = pbuf->cur;
-  register struct parse_marker *mark;
-  for (mark = pbuf->marks;  mark != NULL; mark = mark->next)
-    {
-      if (pbuf->buf + mark->position < new_pos)
-	new_pos = pbuf->buf + mark->position;
-    }
-  pbuf->line_base += new_pos - old_pos;
-  adjust_position (old_pos, new_pos, &pbuf->lineno, &pbuf->colno);
-}
-
 void
 cpp_buf_line_and_col (pbuf, linep, colp)
      register cpp_buffer *pbuf;
      long *linep, *colp;
 {
-  long dummy;
-  if (colp == NULL)
-    colp = &dummy;
   if (pbuf)
     {
       *linep = pbuf->lineno;
-      *colp = pbuf->colno;
-      adjust_position (pbuf->buf + pbuf->line_base, pbuf->cur, linep, colp);
+      if (colp)
+	*colp = pbuf->cur - pbuf->line_base;
     }
   else
     {
       *linep = 0;
+      if (colp)
 	*colp = 0;
     }
 }
@@ -851,21 +882,6 @@ cpp_file_buffer (pfile)
   return NULL;
 }
 
-static long
-count_newlines (buf, limit)
-     register U_CHAR *buf;
-     register U_CHAR *limit;
-{
-  register long count = 0;
-  while (buf < limit)
-    {
-      U_CHAR ch = *buf++;
-      if (ch == '\n')
-	count++;
-    }
-  return count;
-}
-
 /*
  * write out a #line command, for instance, after an #include file.
  * If CONDITIONAL is nonzero, we can omit the #line if it would
@@ -886,28 +902,24 @@ output_line_command (pfile, conditional, file_change)
   if (ip->fname == NULL)
     return;
 
-  update_position (ip);
-
   if (CPP_OPTIONS (pfile)->no_line_commands
       || CPP_OPTIONS (pfile)->no_output)
     return;
 
-  line = CPP_BUFFER (pfile)->lineno;
-  col = CPP_BUFFER (pfile)->colno;
-  adjust_position (CPP_LINE_BASE (ip), ip->cur, &line, &col);
-
-  if (CPP_OPTIONS (pfile)->no_line_commands)
-    return;
+  cpp_buf_line_and_col (CPP_BUFFER (pfile), &line, &col);
 
-  if (conditional) {
+  if (conditional)
+    {
       if (line == pfile->lineno)
 	return;
 
       /* If the inherited line number is a little too small,
 	 output some newlines instead of a #line command.  */
-    if (line > pfile->lineno && line < pfile->lineno + 8) {
+      if (line > pfile->lineno && line < pfile->lineno + 8)
+	{
 	  CPP_RESERVE (pfile, 20);
-      while (line > pfile->lineno) {
+	  while (line > pfile->lineno)
+	    {
 	      CPP_PUTC_Q (pfile, '\n');
 	      pfile->lineno++;
 	    }
@@ -915,41 +927,28 @@ output_line_command (pfile, conditional, file_change)
 	}
     }
 
-#if 0
-  /* Don't output a line number of 0 if we can help it.  */
-  if (ip->lineno == 0 && ip->bufp - ip->buf < ip->length
-      && *ip->bufp == '\n') {
-    ip->lineno++;
-    ip->bufp++;
-  }
-#endif
-
   CPP_RESERVE (pfile, 4 * strlen (ip->nominal_fname) + 50);
-  {
-#ifdef OUTPUT_LINE_COMMANDS
-    static char sharp_line[] = "#line ";
-#else
-    static char sharp_line[] = "# ";
-#endif
-    CPP_PUTS_Q (pfile, sharp_line, sizeof(sharp_line)-1);
-  }
+  CPP_PUTS_Q (pfile, "# ", 2);
 
   sprintf ((char *) CPP_PWRITTEN (pfile), "%ld ", line);
   CPP_ADJUST_WRITTEN (pfile, strlen (CPP_PWRITTEN (pfile)));
 
   quote_string (pfile, ip->nominal_fname); 
-  if (file_change != same_file) {
+  if (file_change != same_file)
+    {
       CPP_PUTC_Q (pfile, ' ');
       CPP_PUTC_Q (pfile, file_change == enter_file ? '1' : '2');
     }
   /* Tell cc1 if following text comes from a system header file.  */
-  if (ip->system_header_p) {
+  if (ip->system_header_p)
+    {
       CPP_PUTC_Q (pfile, ' ');
       CPP_PUTC_Q (pfile, '3');
     }
 #ifndef NO_IMPLICIT_EXTERN_C
   /* Tell cc1plus if following text should be treated as C.  */
-  if (ip->system_header_p == 2 && CPP_OPTIONS (pfile)->cplusplus) {
+  if (ip->system_header_p == 2 && CPP_OPTIONS (pfile)->cplusplus)
+    {
       CPP_PUTC_Q (pfile, ' ');
       CPP_PUTC_Q (pfile, '4');
     }
@@ -1886,6 +1885,7 @@ skip_if_group (pfile)
 	{
 	  if (CPP_OPTIONS (pfile)->output_conditionals)
 	    CPP_PUTC (pfile, c);
+	  CPP_BUMP_LINE (pfile);
 	  continue;
 	}
       else if (c == '#')
@@ -1915,7 +1915,11 @@ skip_if_group (pfile)
 	{
 	  /* \n */
 	  if (CPP_OPTIONS (pfile)->output_conditionals)
+	    {
 	      CPP_PUTC (pfile, c);
+	      pfile->lineno++;
+	    }
+	  CPP_BUMP_LINE (pfile);
 	}
     }	  
 
@@ -1998,10 +2002,9 @@ do_endif (pfile, keyword)
 	{
 	  /* This #endif matched a #ifndef at the start of the file.
 	     See if it is at the end of the file.  */
-	  struct parse_marker start_mark;
 	  int c;
 
-	  parse_set_mark (&start_mark, pfile);
+	  parse_set_mark (pfile);
 
 	  for (;;)
 	    {
@@ -2010,8 +2013,7 @@ do_endif (pfile, keyword)
 	      if (c != '\n')
 		break;
 	    }
-	  parse_goto_mark (&start_mark, pfile);
-	  parse_clear_mark (&start_mark);
+	  parse_goto_mark (pfile);
 
 	  if (c == EOF)
 	    {
@@ -2057,8 +2059,6 @@ cpp_get_token (pfile)
      cpp_reader *pfile;
 {
   register int c, c2, c3;
-  long old_written;
-  long start_line, start_column;
   enum cpp_token token;
   struct cpp_options *opts = CPP_OPTIONS (pfile);
 
@@ -2099,68 +2099,27 @@ cpp_get_token (pfile)
     {
       switch (c)
 	{
-	  long newlines;
-	  struct parse_marker start_mark;
 	case '/':
 	  if (PEEKC () == '=')
 	    goto op2;
+
+	comment:
 	  if (opts->put_out_comments)
-	    parse_set_mark (&start_mark, pfile);
-	  newlines = 0;
-	  cpp_buf_line_and_col (cpp_file_buffer (pfile),
-				&start_line, &start_column);
-	  c = skip_comment (pfile, &newlines);
-	  if (opts->put_out_comments && (c == '/' || c == EOF))
-	    parse_clear_mark (&start_mark);
-	  if (c == '/')
-	    goto randomchar;
+	    c = copy_comment (pfile, c);
+	  else
+	    c = skip_comment (pfile, c);
 	  if (c == EOF)
-	    {
-	      cpp_error_with_line (pfile, start_line, start_column,
-				   "unterminated comment");
 	    goto handle_eof;
-	    }
-	  c = '/';  /* Initial letter of comment.  */
-	return_comment:
+	  else if (c != ' ')
+	    goto randomchar;
+	  
 	  /* Comments are equivalent to spaces.
 	     For -traditional, a comment is equivalent to nothing.  */
-	  if (opts->put_out_comments)
-	    {
-	      cpp_buffer *pbuf = CPP_BUFFER (pfile);
-	      U_CHAR *start = pbuf->buf + start_mark.position;
-	      int len = pbuf->cur - start;
-	      CPP_RESERVE(pfile, 1 + len);
-	      CPP_PUTC_Q (pfile, c);
-	      CPP_PUTS_Q (pfile, start, len);
-	      pfile->lineno += newlines;
-	      parse_clear_mark (&start_mark);
+	  if (opts->traditional || opts->put_out_comments)
 	    return CPP_COMMENT;
-	    }
-	  else if (CPP_TRADITIONAL (pfile))
-	    {
-	      return CPP_COMMENT;
-	    }
 	  else
 	    {
-#if 0
-	      /* This may not work if cpp_get_token is called recursively,
-		 since many places look for horizontal space.  */
-	      if (newlines)
-		{
-		  /* Copy the newlines into the output buffer, in order to
-		     avoid the pain of a #line every time a multiline comment
-		     is seen.  */
-		  CPP_RESERVE(pfile, newlines);
-		  while (--newlines >= 0)
-		    {
-		      CPP_PUTC_Q (pfile, '\n');
-		      pfile->lineno++;
-		    }
-		  return CPP_VSPACE;
-		}
-#endif
-	      CPP_RESERVE(pfile, 1);
-	      CPP_PUTC_Q (pfile, ' ');
+	      CPP_PUTC (pfile, c);
 	      return CPP_HSPACE;
 	    }
 #if 0
@@ -2218,91 +2177,7 @@ cpp_get_token (pfile)
 	case '\"':
 	case '\'':
 	string:
-	  /* A single quoted string is treated like a double -- some
-	     programs (e.g., troff) are perverse this way */
-	  cpp_buf_line_and_col (cpp_file_buffer (pfile),
-				&start_line, &start_column);
-	  old_written = CPP_WRITTEN (pfile);
-	  CPP_PUTC (pfile, c);
-	  while (1)
-	    {
-	      int cc = GETC();
-	      if (cc == EOF)
-		{
-		  if (CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
-		    {
-		      /* try harder: this string crosses a macro expansion
-			 boundary.  This can happen naturally if -traditional.
-			 Otherwise, only -D can make a macro with an unmatched
-			 quote.  */
-			cpp_pop_buffer (pfile);
-			continue;
-		    }
-		  if (!CPP_TRADITIONAL (pfile))
-		    {
-		      cpp_error_with_line (pfile, start_line, start_column,
-			      "unterminated string or character constant");
-		      if (pfile->multiline_string_line != start_line
-			  && pfile->multiline_string_line != 0)
-			cpp_error_with_line (pfile,
-					     pfile->multiline_string_line, -1,
-			       "possible real start of unterminated constant");
-		      pfile->multiline_string_line = 0;
-		    }
-		  break;
-		}
-	      CPP_PUTC (pfile, cc);
-	      switch (cc)
-		{
-		case '\n':
-		  /* Traditionally, end of line ends a string constant with
-		 no error.  So exit the loop and record the new line.  */
-		  if (CPP_TRADITIONAL (pfile))
-		    goto while2end;
-		  if (c == '\'')
-		    {
-		      cpp_error_with_line (pfile, start_line, start_column,
-					   "unterminated character constant");
-		      goto while2end;
-		    }
-		  if (CPP_PEDANTIC (pfile)
-		      && pfile->multiline_string_line == 0)
-		    {
-		      cpp_pedwarn_with_line (pfile, start_line, start_column,
-			       "string constant runs past end of line");
-		    }
-		  if (pfile->multiline_string_line == 0)
-		    pfile->multiline_string_line = start_line;
-		  break;
-		
-		case '\\':
-		  cc = GETC();
-		  if (cc == '\n')
-		    {
-		      /* Backslash newline is replaced by nothing at all.  */
-		      CPP_ADJUST_WRITTEN (pfile, -1);
-		      pfile->lineno++;
-		    }
-		  else
-		    {
-		      /* ANSI stupidly requires that in \\ the second \
-			 is *not* prevented from combining with a newline.  */
-		      NEWLINE_FIX1(cc);
-		      if (cc != EOF)
-			CPP_PUTC (pfile, cc);
-		    }
-		  break;
-
-		case '\"':
-		case '\'':
-		  if (cc == c)
-		    goto while2end;
-		  break;
-		}
-	    }
-	while2end:
-	  pfile->lineno += count_newlines (pfile->token_buffer + old_written,
-					   CPP_PWRITTEN (pfile));
+	  parse_string (pfile, c);
 	  pfile->only_seen_white = 0;
 	  return c == '\'' ? CPP_CHAR : CPP_STRING;
 
@@ -2319,7 +2194,6 @@ cpp_get_token (pfile)
 	case '&':
 	case '+':
 	case '|':
-	  NEWLINE_FIX;
 	  c2 = PEEKC ();
 	  if (c2 == c || c2 == '=')
 	    goto op2;
@@ -2330,35 +2204,14 @@ cpp_get_token (pfile)
 	case '%':
 	case '=':
 	case '^':
-	  NEWLINE_FIX;
 	  if (PEEKC () == '=')
 	    goto op2;
 	  goto randomchar;
 
 	case '-':
-	  NEWLINE_FIX;
 	  c2 = PEEKC ();
 	  if (c2 == '-' && opts->chill)
-	    {
-	      /* Chill style comment */
-	      if (opts->put_out_comments)
-		parse_set_mark (&start_mark, pfile);
-	      FORWARD(1);  /* Skip second '-'.  */
-	      for (;;)
-		{
-		  c = GETC ();
-		  if (c == EOF)
-		    break;
-		  if (c == '\n')
-		    {
-		      /* Don't consider final '\n' to be part of comment.  */
-		      FORWARD(-1);
-		      break;
-		    }
-		}
-	      c = '-';
-	      goto return_comment;
-	    }
+	    goto comment;  /* Chill style comment */
 	  if (c2 == '-' || c2 == '=' || c2 == '>')
 	    goto op2;
 	  goto randomchar;
@@ -2372,19 +2225,23 @@ cpp_get_token (pfile)
 		  if (c == '>')
 		    break;
 		  c = GETC ();
-		  NEWLINE_FIX1 (c);
 		  if (c == '\n' || c == EOF)
 		    {
 		      cpp_error (pfile,
 				 "missing '>' in `#include <FILENAME>'");
 		      break;
 		    }
+		  else if (c == '\r')
+		    {
+		      /* Backslash newline is replaced by nothing. */
+		      CPP_ADJUST_WRITTEN (pfile, -1);
+		      CPP_BUMP_LINE (pfile);
+		    }
 		}
 	      return CPP_STRING;
 	    }
 	  /* else fall through */
 	case '>':
-	  NEWLINE_FIX;
 	  c2 = PEEKC ();
 	  if (c2 == '=')
 	    goto op2;
@@ -2394,7 +2251,6 @@ cpp_get_token (pfile)
 	  CPP_RESERVE (pfile, 4);
 	  CPP_PUTC (pfile, c);
 	  CPP_PUTC (pfile, c2);
-	  NEWLINE_FIX;
 	  c3 = PEEKC ();
 	  if (c3 == '=')
 	    CPP_PUTC_Q (pfile, GETC ());
@@ -2413,7 +2269,7 @@ cpp_get_token (pfile)
 		  parse_name (pfile, GETC ());
 		  return CPP_NAME;
 		}
-	      else if (is_space [c])
+	      else if (c == ' ')
 		{
 		  CPP_RESERVE (pfile, 2);
 		  if (pfile->output_escapes)
@@ -2430,7 +2286,6 @@ cpp_get_token (pfile)
 	  goto randomchar;
 
 	case '.':
-	  NEWLINE_FIX;
 	  c2 = PEEKC ();
 	  if (ISDIGIT(c2))
 	    {
@@ -2439,7 +2294,6 @@ cpp_get_token (pfile)
 	      c = GETC ();
 	      goto number;
 	    }
-	  /* FIXME - misses the case "..\\\n." */
 	  if (c2 == '.' && PEEKN(1) == '.')
 	    {
 	      CPP_RESERVE(pfile, 4);
@@ -2456,7 +2310,6 @@ cpp_get_token (pfile)
 	op2:
 	  token = CPP_OTHER;
 	  pfile->only_seen_white = 0;
-        op2any:
 	  CPP_RESERVE(pfile, 3);
 	  CPP_PUTC_Q (pfile, c);
 	  CPP_PUTC_Q (pfile, GETC ());
@@ -2464,7 +2317,6 @@ cpp_get_token (pfile)
 	  return token;
 
 	case 'L':
-	  NEWLINE_FIX;
 	  c2 = PEEKC ();
 	  if ((c2 == '\'' || c2 == '\"') && !CPP_TRADITIONAL (pfile))
 	    {
@@ -2482,7 +2334,6 @@ cpp_get_token (pfile)
 	    {
 	      CPP_RESERVE (pfile, 2);
 	      CPP_PUTC_Q (pfile, c);
-	      NEWLINE_FIX;
 	      c = PEEKC ();
 	      if (c == EOF)
 		break;
@@ -2512,14 +2363,7 @@ cpp_get_token (pfile)
 		  if (c == EOF)
 		    goto chill_number_eof;
 		  if (!is_idchar[c])
-		    {
-		      if (c == '\\' && PEEKC() == '\n')
-			{
-			  FORWARD(2);
-			  continue;
-			}
 		    break;
-		    }
 		  CPP_PUTC (pfile, c);
 		}
 	      if (c == '\'')
@@ -2584,10 +2428,9 @@ cpp_get_token (pfile)
 	       decide this is not a macro call and leave things that way.  */
 	    if (hp->type == T_MACRO && hp->value.defn->nargs >= 0)
 	    {
-	      struct parse_marker macro_mark;
 	      int is_macro_call, macbuf_whitespace = 0;
 
-	      parse_set_mark (&macro_mark, pfile);
+	      parse_set_mark (pfile);
 	      for (;;)
 		{
 		  cpp_skip_hspace (pfile);
@@ -2603,14 +2446,15 @@ cpp_get_token (pfile)
                     {
                       if (CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
                         {
-                          if (macro_mark.position !=
+                          if (CPP_BUFFER (pfile)->mark !=
                               (CPP_BUFFER (pfile)->cur
                                - CPP_BUFFER (pfile)->buf))
                              macbuf_whitespace = 1;
 
-                          parse_clear_mark (&macro_mark);
+			  /* The mark goes away automatically when
+			     the buffer is popped. */
                           cpp_pop_buffer (pfile);
-                          parse_set_mark (&macro_mark, pfile);
+                          parse_set_mark (pfile);
                         }
                       else
                         break;
@@ -2618,11 +2462,12 @@ cpp_get_token (pfile)
 		}
 	      if (!is_macro_call)
                 {
-                  parse_goto_mark (&macro_mark, pfile);
+                  parse_goto_mark (pfile);
                   if (macbuf_whitespace)
                     CPP_PUTC (pfile, ' ');
                 }
-	      parse_clear_mark (&macro_mark);
+	      else
+		parse_clear_mark (pfile);
 	      if (!is_macro_call)
 		return CPP_NAME;
 	    }
@@ -2634,7 +2479,7 @@ cpp_get_token (pfile)
 	  }
 	  goto get_next;
 
-	case ' ':  case '\t':  case '\v':  case '\r':
+	case ' ':  case '\t':  case '\v':
 	  for (;;)
 	    {
 	      CPP_PUTC (pfile, c);
@@ -2646,17 +2491,20 @@ cpp_get_token (pfile)
 	  return CPP_HSPACE;
 
         case '\\':
-	  c2 = PEEKC ();
-	  if (c2 != '\n')
 	  goto randomchar;
-	  token = CPP_HSPACE;
-	  goto op2any;
+
+	case '\r':
+	  /* Backslash newline is ignored. */
+	  CPP_BUMP_LINE (pfile);
+	  goto get_next;
 
 	case '\n':
 	  CPP_PUTC (pfile, c);
 	  if (pfile->only_seen_white == 0)
 	    pfile->only_seen_white = 1;
+	  CPP_BUMP_LINE (pfile);
 	  pfile->lineno++;
+	  if (CPP_BUFFER (pfile)->lineno != pfile->lineno)
 	    output_line_command (pfile, 1, same_file);
 	  return CPP_VSPACE;
 
@@ -2697,19 +2545,15 @@ cpp_get_non_space_token (pfile)
 
 /* Parse an identifier starting with C.  */
 
-static int
+static void
 parse_name (pfile, c)
-     cpp_reader *pfile; int c;
+     cpp_reader *pfile;
+     int c;
 {
   for (;;)
   {
       if (! is_idchar[c])
       {
-	  if (c == '\\' && PEEKC() == '\n')
-	  {
-	      FORWARD(2);
-	      continue;
-	  }
 	  FORWARD (-1);
 	  break;
       }
@@ -2724,7 +2568,95 @@ parse_name (pfile, c)
 	break;
   }
   CPP_NUL_TERMINATE_Q (pfile);
-  return 1;
+  return;
+}
+
+/* Parse a string starting with C.  A single quoted string is treated
+   like a double -- some programs (e.g., troff) are perverse this way.
+   (However, a single quoted string is not allowed to extend over
+   multiple lines.  */
+static void
+parse_string (pfile, c)
+     cpp_reader *pfile;
+     int c;
+{
+  long start_line, start_column;
+  
+  cpp_buf_line_and_col (cpp_file_buffer (pfile), &start_line, &start_column);
+
+  CPP_PUTC (pfile, c);
+  while (1)
+    {
+      int cc = GETC();
+      if (cc == EOF)
+	{
+	  if (CPP_IS_MACRO_BUFFER (CPP_BUFFER (pfile)))
+	    {
+	      /* try harder: this string crosses a macro expansion
+		 boundary.  This can happen naturally if -traditional.
+		 Otherwise, only -D can make a macro with an unmatched
+		 quote.  */
+	      cpp_pop_buffer (pfile);
+	      continue;
+	    }
+	  if (!CPP_TRADITIONAL (pfile))
+	    {
+	      cpp_error_with_line (pfile, start_line, start_column,
+				 "unterminated string or character constant");
+	      if (pfile->multiline_string_line != start_line
+		  && pfile->multiline_string_line != 0)
+		cpp_error_with_line (pfile,
+				     pfile->multiline_string_line, -1,
+			       "possible real start of unterminated constant");
+	      pfile->multiline_string_line = 0;
+	    }
+	  break;
+	}
+      CPP_PUTC (pfile, cc);
+      switch (cc)
+	{
+	case '\n':
+	  CPP_BUMP_LINE (pfile);
+	  pfile->lineno++;
+	  /* Traditionally, end of line ends a string constant with
+	     no error.  */
+	  if (CPP_TRADITIONAL (pfile))
+	    return;
+	  /* Character constants may not extend over multiple lines.  */
+	  if (c == '\'')
+	    {
+	      cpp_error_with_line (pfile, start_line, start_column,
+				   "unterminated character constant");
+	      return;
+	    }
+	  if (CPP_PEDANTIC (pfile) && pfile->multiline_string_line == 0)
+	    {
+	      cpp_pedwarn_with_line (pfile, start_line, start_column,
+				     "string constant runs past end of line");
+	    }
+	  if (pfile->multiline_string_line == 0)
+	    pfile->multiline_string_line = start_line;
+	  break;
+
+	case '\r':
+	  /* Backslash newline is replaced by nothing at all.  */
+	  CPP_ADJUST_WRITTEN (pfile, -1);
+	  CPP_BUMP_LINE (pfile);
+	  break;
+
+	case '\\':
+	  cc = GETC();
+	  if (cc != EOF)
+	    CPP_PUTC (pfile, cc);
+	  break;
+
+	case '\"':
+	case '\'':
+	  if (cc == c)
+	    return;
+	  break;
+	}
+    }
 }
 
 /* Read an assertion into the token buffer, converting to
@@ -2752,7 +2684,7 @@ parse_assertion (pfile)
   c = PEEKC();
   if (c != '(')
     {
-      if (is_hor_space[c])
+      if (is_hor_space[c] || c == '\r')
 	cpp_skip_hspace (pfile);
       c = PEEKC();
     }
@@ -2772,17 +2704,17 @@ parse_assertion (pfile)
 	      dropwhite = 1;
 	    }
 	}
-      else if (c == '\\' && PEEKC() == '\n')
-	FORWARD(1);
       else if (c == '\n' || c == EOF)
 	{
 	  if (c == '\n') FORWARD(-1);
 	  cpp_error (pfile, "un-terminated assertion answer");
 	  return 0;
 	}
+      else if (c == '\r')
+	CPP_BUMP_LINE (pfile);
       else
 	{
-	  CPP_PUTC(pfile, c);
+	  CPP_PUTC (pfile, c);
 	  dropwhite = 0;
 	}
     }
@@ -2795,9 +2727,9 @@ parse_assertion (pfile)
       return 0;
     }
   else
-    CPP_PUTC(pfile, ')');
+    CPP_PUTC (pfile, ')');
 
-  CPP_NUL_TERMINATE(pfile);
+  CPP_NUL_TERMINATE (pfile);
   return 2;
 }
 
@@ -2971,61 +2903,49 @@ cpp_read_check_assertion (pfile)
   return result;
 }
 
-/* Initialize PMARK to remember the current position of PFILE.  */
+/* Remember the current position of PFILE.  */
 
 void
-parse_set_mark (pmark, pfile)
-     struct parse_marker *pmark;
+parse_set_mark (pfile)
      cpp_reader *pfile;
 {
-  cpp_buffer *pbuf = CPP_BUFFER (pfile);
-  pmark->next = pbuf->marks;
-  pbuf->marks = pmark;
-  pmark->buf = pbuf;
-  pmark->position = pbuf->cur - pbuf->buf;
-}
-
-/* Cleanup PMARK - we no longer need it.  */
+  cpp_buffer *ip = CPP_BUFFER (pfile);
+  if (ip->mark != -1)
+      cpp_fatal (pfile,
+		 "cpp internal error: ip->mark != -1 in parse_set_mark");
 
-void
-parse_clear_mark (pmark)
-     struct parse_marker *pmark;
-{
-  struct parse_marker **pp = &pmark->buf->marks;
-  for (; ; pp = &(*pp)->next) {
-    if (*pp == NULL) abort ();
-    if (*pp == pmark) break;
-  }
-  *pp = pmark->next;
+  ip->mark = ip->cur - ip->buf;
 }
 
-/* Backup the current position of PFILE to that saved in PMARK.  */
+/* Clear the current mark - we no longer need it.  */
 
 void
-parse_goto_mark (pmark, pfile)
-     struct parse_marker *pmark;
+parse_clear_mark (pfile)
      cpp_reader *pfile;
 {
-  cpp_buffer *pbuf = CPP_BUFFER (pfile);
-  if (pbuf != pmark->buf)
-    cpp_fatal (pfile, "internal error %s", "parse_goto_mark");
-  pbuf->cur = pbuf->buf + pmark->position;
+  cpp_buffer *ip = CPP_BUFFER (pfile);
+  if (ip->mark == -1)
+      cpp_fatal (pfile,
+		 "cpp internal error: ip->mark == -1 in parse_clear_mark");
+
+  ip->mark = -1;
 }
 
-/* Reset PMARK to point to the current position of PFILE.  (Same
-   as parse_clear_mark (PMARK), parse_set_mark (PMARK, PFILE) but faster.  */
+/* Backup the current position of PFILE to that saved in its mark,
+   and clear the mark.  */
 
 void
-parse_move_mark (pmark, pfile)
-     struct parse_marker *pmark;
+parse_goto_mark (pfile)
      cpp_reader *pfile;
 {
-  cpp_buffer *pbuf = CPP_BUFFER (pfile);
-  if (pbuf != pmark->buf)
-    cpp_fatal (pfile, "internal error %s", "parse_move_mark");
-  pmark->position = pbuf->cur - pbuf->buf;
-}
+  cpp_buffer *ip = CPP_BUFFER (pfile);
+  if (ip->mark == -1)
+      cpp_fatal (pfile,
+		 "cpp internal error: ip->mark == -1 in parse_goto_mark");
 
+  ip->cur = ip->buf + ip->mark;
+  ip->mark = -1;
+}
 
 void
 cpp_print_file_and_line (pfile)

gcc/cpplib.h

@@ -72,19 +72,9 @@ enum cpp_token {
 typedef enum cpp_token (*parse_underflow_t) PARAMS((cpp_reader *));
 typedef int (*parse_cleanup_t) PARAMS((cpp_buffer *, cpp_reader *));
 
-/* A parse_marker indicates a previous position,
-   which we can backtrack to. */
-
-struct parse_marker {
-  cpp_buffer *buf;
-  struct parse_marker *next;
-  int position;
-};
-
-extern void parse_set_mark PARAMS ((struct parse_marker *, cpp_reader *));
-extern void parse_clear_mark PARAMS ((struct parse_marker *));
-extern void parse_goto_mark PARAMS((struct parse_marker *, cpp_reader *));
-extern void parse_move_mark PARAMS((struct parse_marker *, cpp_reader *));
+extern void parse_set_mark	PARAMS ((cpp_reader *));
+extern void parse_clear_mark	PARAMS ((cpp_reader *));
+extern void parse_goto_mark	PARAMS ((cpp_reader *));
 
 extern int cpp_handle_option PARAMS ((cpp_reader *, int, char **));
 extern int cpp_handle_options PARAMS ((cpp_reader *, int, char **));
@@ -95,15 +85,13 @@ extern enum cpp_token cpp_get_non_space_token PARAMS ((cpp_reader *));
 /* This frees resources used by PFILE. */
 extern void cpp_cleanup PARAMS ((cpp_reader *PFILE));
 
-/* If we have a huge buffer, may need to cache more recent counts */
-#define CPP_LINE_BASE(BUF) ((BUF)->buf + (BUF)->line_base)
-
 struct cpp_buffer
 {
   unsigned char *cur;	 /* current position */
   unsigned char *rlimit; /* end of valid data */
   unsigned char *buf;	 /* entire buffer */
   unsigned char *alimit; /* end of allocated buffer */
+  unsigned char *line_base; /* start of current line */
 
   struct cpp_buffer *prev;
 
@@ -120,13 +108,13 @@ struct cpp_buffer
      to record control macros. */
   struct include_hash *ihash;
 
-  long line_base;
   long lineno; /* Line number at CPP_LINE_BASE. */
   long colno; /* Column number at CPP_LINE_BASE. */
+  long mark;  /* Saved position for lengthy backtrack. */
   parse_underflow_t underflow;
   parse_cleanup_t cleanup;
   void *data;
-  struct parse_marker *marks;
+  
   /* Value of if_stack at start of this file.
      Used to prohibit unmatched #endif (etc) in an include file.  */
   struct if_stack *if_stack;
@@ -289,8 +277,12 @@ struct cpp_reader
 #define CPP_ADJUST_WRITTEN(PFILE,DELTA) ((PFILE)->limit += (DELTA))
 #define CPP_SET_WRITTEN(PFILE,N) ((PFILE)->limit = (PFILE)->token_buffer + (N))
 
-#define CPP_OPTIONS(PFILE) ((PFILE)->opts)
+/* Advance the current line by one. */
+#define CPP_BUMP_BUFFER_LINE(PBUF) ((PBUF)->lineno++,\
+				    (PBUF)->line_base = (PBUF)->cur)
+#define CPP_BUMP_LINE(PFILE) CPP_BUMP_BUFFER_LINE(CPP_BUFFER(PFILE))
 
+#define CPP_OPTIONS(PFILE) ((PFILE)->opts)
 #define CPP_BUFFER(PFILE) ((PFILE)->buffer)
 #define CPP_PREV_BUFFER(BUFFER) ((BUFFER)->prev)
 /* The bottom of the buffer stack. */