cpplib.h: Merge struct cpp_options into struct cpp_reader.

	* cpplib.h: Merge struct cpp_options into struct cpp_reader.
	Reorder struct cpp_options and struct cpp_reader for better
	packing.  Replace CPP_OPTIONS macro with CPP_OPTION which
	takes two args.  Change all 'char' flags to 'unsigned char'.
	Move show_column flag into struct cpp_options.  Don't
	prototype cpp_options_init.
	* cpphash.h, cpperror.c, cppexp.c, cppfiles.c, cpphash.c,
	cppinit.c, cpplex.c, cpplib.c:
	Replace CPP_OPTIONS (pfile)->whatever with
	CPP_OPTION (pfile, whatever), and likewise for
	opts = CPP_OPTIONS (pfile); ... opts->whatever;

	* cppinit.c (merge_include_chains): Take a cpp_reader *.
	Extract CPP_OPTION (pfile, pending) and work with that
	directly.
	(cpp_options_init): Delete.
	(cpp_reader_init): Turn on on-by-default options here.
	Allocate the pending structure here.
	(cl_options, enum opt_code): Define these from the same table,
	kept in a large macro.  Add -fshow-column and -fno-show-column
	options.

	* cpperror.c (v_message): If show_column is off, don't print
	the column number.

	* cppmain.c: Update for new interface.
	* fix-header.c: Likewise.

From-SVN: r32850

gcc/ChangeLog

+2000-03-31  Zack Weinberg  <zack@wolery.cumb.org>
+
+	* cpplib.h: Merge struct cpp_options into struct cpp_reader.
+	Reorder struct cpp_options and struct cpp_reader for better 
+	packing.  Replace CPP_OPTIONS macro with CPP_OPTION which
+	takes two args.  Change all 'char' flags to 'unsigned char'.
+	Move show_column flag into struct cpp_options.  Don't
+	prototype cpp_options_init.
+	* cpphash.h, cpperror.c, cppexp.c, cppfiles.c, cpphash.c,
+	cppinit.c, cpplex.c, cpplib.c:
+	Replace CPP_OPTIONS (pfile)->whatever with
+	CPP_OPTION (pfile, whatever), and likewise for
+	opts = CPP_OPTIONS (pfile); ... opts->whatever;
+
+	* cppinit.c (merge_include_chains): Take a cpp_reader *.
+	Extract CPP_OPTION (pfile, pending) and work with that
+	directly.
+	(cpp_options_init): Delete.
+	(cpp_reader_init): Turn on on-by-default options here.
+	Allocate the pending structure here.		  
+	(cl_options, enum opt_code): Define these from the same table,
+	kept in a large macro.  Add -fshow-column and -fno-show-column
+	options.
+
+	* cpperror.c (v_message): If show_column is off, don't print
+	the column number.
+
+	* cppmain.c: Update for new interface.
+	* fix-header.c: Likewise.
+
 2000-03-30  Geoff Keating  <geoffk@cygnus.com>
 
 	* config/rs6000/t-aix43 (AR_FLAGS_FOR_TARGET): Adjust for new
@@ -365,11 +395,11 @@ Tue Mar 28 08:29:46 2000  Jan Hubicka  <jh@suse.cz>
 
 2000-03-28  Neil Booth  <NeilB@earthling.net>
 
-        * cpplex.c (_cpp_read_and_prescan): Mark end of input buffer with
+	* cpplex.c (_cpp_read_and_prescan): Mark end of input buffer with
 	'\\' rather than a null character, so nulls are not special.  Fix
 	"\\\n" handling in end-of-buffer conditions.  Use trigraph map to
 	speed trigraph conversion.
-        (_cpp_init_input_buffer): Initialize trigraph map.
+	(_cpp_init_input_buffer): Initialize trigraph map.
 
 2000-03-27  Alan Modra  <alan@linuxcare.com.au>
 
@@ -4041,7 +4071,7 @@ Tue Feb 15 23:22:26 2000  Andrew Haley  <aph@cygnus.com>
 	* config/sh/sh.h: Correct comment about macros.
 
 Tue Feb 15 22:30:36 2000  J"orn Rennecke <amylaar@cygnus.co.uk>
-	                  Andrew MacLeod  <amacleod@cygnus.com>
+			  Andrew MacLeod  <amacleod@cygnus.com>
 
 	* Makefile.in (lcm.o): Depend on insn-attr.h.
 	* basic-block.h (optimize_mode_switching): Declare.
@@ -4136,7 +4166,7 @@ Tue Feb 15 22:30:36 2000  J"orn Rennecke <amylaar@cygnus.co.uk>
 	to import the frames themselves.
 
 Mon Feb 14 13:31:01 2000  Stan Cox  <scox@cygnus.com>
-	                  Jason Eckhardt  <jle@cygnus.com>
+			  Jason Eckhardt  <jle@cygnus.com>
 
 	* basic_block.h: Added prototype for reorder_basic_blocks.
 	* toplev.c: Changes to add -freorder-blocks and graph dump after

gcc/cpperror.c

@@ -121,7 +121,8 @@ v_message (pfile, is_error, file, line, col, msg, ap)
 	cpp_buf_line_and_col (ip, &line, &col);
 
       print_containing_files (pfile, ip);
-      print_file_and_line (file, line, col);
+      print_file_and_line (file, line,
+			   CPP_OPTION (pfile, show_column) ? col : 0);
     }
   else
     fprintf (stderr, "%s: ", progname);
@@ -217,7 +218,7 @@ cpp_error VPARAMS ((cpp_reader * pfile, const char *msgid, ...))
   msgid = va_arg (ap, const char *);
 #endif
 
-  if (CPP_OPTIONS (pfile)->inhibit_errors)
+  if (CPP_OPTION (pfile, inhibit_errors))
     return;
 
   v_message (pfile, 1, NULL, -1, -1, msgid, ap);
@@ -245,7 +246,7 @@ cpp_error_with_line VPARAMS ((cpp_reader *pfile, int line, int column,
   msgid = va_arg (ap, const char *);
 #endif
 
-  if (CPP_OPTIONS (pfile)->inhibit_errors)
+  if (CPP_OPTION (pfile, inhibit_errors))
     return;
 
   v_message (pfile, 1, NULL, line, column, msgid, ap);
@@ -277,7 +278,7 @@ cpp_warning VPARAMS ((cpp_reader * pfile, const char *msgid, ...))
   msgid = va_arg (ap, const char *);
 #endif
 
-  if (CPP_OPTIONS (pfile)->inhibit_warnings)
+  if (CPP_OPTION (pfile, inhibit_warnings))
     return;
 
   v_message (pfile, 0, NULL, -1, -1, msgid, ap);
@@ -305,7 +306,7 @@ cpp_warning_with_line VPARAMS ((cpp_reader * pfile, int line, int column,
   msgid = va_arg (ap, const char *);
 #endif
 
-  if (CPP_OPTIONS (pfile)->inhibit_warnings)
+  if (CPP_OPTION (pfile, inhibit_warnings))
     return;
 
   v_message (pfile, 0, NULL, line, column, msgid, ap);
@@ -328,12 +329,12 @@ cpp_pedwarn VPARAMS ((cpp_reader * pfile, const char *msgid, ...))
   msgid = va_arg (ap, const char *);
 #endif
 
-  if (CPP_OPTIONS (pfile)->pedantic_errors
-      ? CPP_OPTIONS (pfile)->inhibit_errors
-      : CPP_OPTIONS (pfile)->inhibit_warnings)
+  if (CPP_OPTION (pfile, pedantic_errors)
+      ? CPP_OPTION (pfile, inhibit_errors)
+      : CPP_OPTION (pfile, inhibit_warnings))
     return;
 
-  v_message (pfile, CPP_OPTIONS (pfile)->pedantic_errors,
+  v_message (pfile, CPP_OPTION (pfile, pedantic_errors),
 		 NULL, -1, -1, msgid, ap);
   va_end(ap);
 }
@@ -359,12 +360,12 @@ cpp_pedwarn_with_line VPARAMS ((cpp_reader * pfile, int line, int column,
   msgid = va_arg (ap, const char *);
 #endif
 
-  if (CPP_OPTIONS (pfile)->pedantic_errors
-      ? CPP_OPTIONS (pfile)->inhibit_errors
-      : CPP_OPTIONS (pfile)->inhibit_warnings)
+  if (CPP_OPTION (pfile, pedantic_errors)
+      ? CPP_OPTION (pfile, inhibit_errors)
+      : CPP_OPTION (pfile, inhibit_warnings))
     return;
 
-  v_message (pfile, CPP_OPTIONS (pfile)->pedantic_errors,
+  v_message (pfile, CPP_OPTION (pfile, pedantic_errors),
 		 NULL, line, column, msgid, ap);
   va_end(ap);
 }
@@ -396,12 +397,12 @@ cpp_pedwarn_with_file_and_line VPARAMS ((cpp_reader *pfile,
   msgid = va_arg (ap, const char *);
 #endif
 
-  if (CPP_OPTIONS (pfile)->pedantic_errors
-      ? CPP_OPTIONS (pfile)->inhibit_errors
-      : CPP_OPTIONS (pfile)->inhibit_warnings)
+  if (CPP_OPTION (pfile, pedantic_errors)
+      ? CPP_OPTION (pfile, inhibit_errors)
+      : CPP_OPTION (pfile, inhibit_warnings))
     return;
 
-  v_message (pfile, CPP_OPTIONS (pfile)->pedantic_errors,
+  v_message (pfile, CPP_OPTION (pfile, pedantic_errors),
 		 file, line, col, msgid, ap);
   va_end(ap);
 }

gcc/cppexp.c

@@ -204,7 +204,7 @@ parse_number (pfile, start, end)
       cpp_error (pfile, "invalid number in #if expression");
       goto error;
     }
-  else if (spec_long > (CPP_OPTIONS (pfile)->c89 ? 1 : 2))
+  else if (spec_long > (CPP_OPTION (pfile, c89) ? 1 : 2))
     {
       cpp_error (pfile, "too many `l' suffixes in integer constant");
       goto error;
@@ -443,7 +443,7 @@ lex (pfile, skip_evaluation)
       op.unsignedp = 0;
       op.value = 0;
 
-      if (CPP_OPTIONS (pfile)->warn_undef && !skip_evaluation)
+      if (CPP_OPTION (pfile, warn_undef) && !skip_evaluation)
 	cpp_warning (pfile, "`%.*s' is not defined",
 		     (int) (tok_end - tok_start), tok_start);
       return op;
@@ -505,7 +505,7 @@ parse_escape (pfile, string_ptr, result_mask)
       return TARGET_BS;
     case 'e':
     case 'E':
-      if (CPP_OPTIONS (pfile)->pedantic)
+      if (CPP_PEDANTIC (pfile))
 	cpp_pedwarn (pfile, "non-ANSI-standard escape sequence, `\\%c'", c);
       return TARGET_ESC;
     case 'f':

gcc/cppfiles.c

@@ -243,7 +243,7 @@ find_include_file (pfile, fname, search_start, ihash, before)
 	  name[path->nlen] = '/';
 	  strcpy (&name[path->nlen+1], fname);
 	  _cpp_simplify_pathname (name);
-	  if (CPP_OPTIONS (pfile)->remap)
+	  if (CPP_OPTION (pfile, remap))
 	    name = remap_filename (pfile, name, path);
 
 	  f = open_include_file (pfile, name);
@@ -369,7 +369,7 @@ read_name_map (pfile, dirname)
   char *name;
   FILE *f;
 
-  for (map_list_ptr = CPP_OPTIONS (pfile)->map_list; map_list_ptr;
+  for (map_list_ptr = CPP_OPTION (pfile, map_list); map_list_ptr;
        map_list_ptr = map_list_ptr->map_list_next)
     if (! strcmp (map_list_ptr->map_list_name, dirname))
       return map_list_ptr->map_list_map;
@@ -429,8 +429,8 @@ read_name_map (pfile, dirname)
       fclose (f);
     }
   
-  map_list_ptr->map_list_next = CPP_OPTIONS (pfile)->map_list;
-  CPP_OPTIONS (pfile)->map_list = map_list_ptr;
+  map_list_ptr->map_list_next = CPP_OPTION (pfile, map_list);
+  CPP_OPTION (pfile, map_list) = map_list_ptr;
 
   return map_list_ptr->map_list_map;
 }  
@@ -511,9 +511,9 @@ _cpp_execute_include (pfile, fname, len, no_reinclude, search_start)
   if (!search_start)
     {
       if (angle_brackets)
-	search_start = CPP_OPTIONS (pfile)->bracket_include;
-      else if (CPP_OPTIONS (pfile)->ignore_srcdir)
-	search_start = CPP_OPTIONS (pfile)->quote_include;
+	search_start = CPP_OPTION (pfile, bracket_include);
+      else if (CPP_OPTION (pfile, ignore_srcdir))
+	search_start = CPP_OPTION (pfile, quote_include);
       else
 	search_start = CPP_BUFFER (pfile)->actual_dir;
     }
@@ -536,7 +536,7 @@ _cpp_execute_include (pfile, fname, len, no_reinclude, search_start)
   
   if (fd == -1)
     {
-      if (CPP_OPTIONS (pfile)->print_deps_missing_files
+      if (CPP_OPTION (pfile, print_deps_missing_files)
 	  && CPP_PRINT_DEPS (pfile) > (angle_brackets ||
 				       (pfile->system_include_depth > 0)))
         {
@@ -548,10 +548,10 @@ _cpp_execute_include (pfile, fname, len, no_reinclude, search_start)
 	      struct file_name_list *ptr;
 	      /* If requested as a system header, assume it belongs in
 		 the first system header directory. */
-	      if (CPP_OPTIONS (pfile)->bracket_include)
-	        ptr = CPP_OPTIONS (pfile)->bracket_include;
+	      if (CPP_OPTION (pfile, bracket_include))
+	        ptr = CPP_OPTION (pfile, bracket_include);
 	      else
-	        ptr = CPP_OPTIONS (pfile)->quote_include;
+	        ptr = CPP_OPTION (pfile, quote_include);
 
 	      p = (char *) alloca (strlen (ptr->name)
 				   + strlen (fname) + 2);
@@ -586,7 +586,7 @@ _cpp_execute_include (pfile, fname, len, no_reinclude, search_start)
     deps_add_dep (pfile->deps, ihash->name);
 
   /* Handle -H option.  */
-  if (CPP_OPTIONS(pfile)->print_include_names)
+  if (CPP_OPTION (pfile, print_include_names))
     {
       cpp_buffer *fp = CPP_BUFFER (pfile);
       while ((fp = CPP_PREV_BUFFER (fp)) != NULL)
@@ -753,7 +753,7 @@ read_include_file (pfile, fd, ihash)
 
   /* The ->actual_dir field is only used when ignore_srcdir is not in effect;
      see do_include */
-  if (!CPP_OPTIONS (pfile)->ignore_srcdir)
+  if (!CPP_OPTION (pfile, ignore_srcdir))
     fp->actual_dir = actual_directory (pfile, ihash->name);
 
   pfile->input_stack_listing_current = 0;
@@ -819,7 +819,7 @@ actual_directory (pfile, fname)
   x = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
   x->name = dir;
   x->nlen = dlen;
-  x->next = CPP_OPTIONS (pfile)->quote_include;
+  x->next = CPP_OPTION (pfile, quote_include);
   x->alloc = pfile->actual_dirs;
   x->sysp = CPP_BUFFER (pfile)->system_header_p;
   x->name_map = NULL;

gcc/cpphash.c

@@ -406,7 +406,7 @@ collect_expansion (pfile, arglist)
 	  if (last_token == STRIZE)
 	    cpp_error (pfile, "`#' is not followed by a macro argument name");
 
-	  if (CPP_TRADITIONAL (pfile) || CPP_OPTIONS (pfile)->warn_stringify)
+	  if (CPP_TRADITIONAL (pfile) || CPP_OPTION (pfile, warn_stringify))
 	    goto maybe_trad_stringify;
 	  else
 	    goto norm;
@@ -480,7 +480,7 @@ collect_expansion (pfile, arglist)
 			     (int) argv[i].len, argv[i].name);
 		continue;
 	      }
-	    if (CPP_OPTIONS (pfile)->warn_stringify)
+	    if (CPP_OPTION (pfile, warn_stringify))
 	      cpp_warning (pfile, "macro argument `%.*s' is stringified",
 			     (int) argv[i].len, argv[i].name);
 
@@ -614,7 +614,7 @@ collect_formal_parameters (pfile)
 	      cpp_error (pfile, "duplicate macro argument name `%s'", tok);
 	      continue;
 	    }
-	  if (CPP_PEDANTIC (pfile) && CPP_OPTIONS (pfile)->c99
+	  if (CPP_PEDANTIC (pfile) && CPP_OPTION (pfile, c99)
 	      && len == sizeof "__VA_ARGS__" - 1
 	      && !strncmp (tok, "__VA_ARGS__", len))
 	    cpp_pedwarn (pfile,
@@ -661,7 +661,7 @@ collect_formal_parameters (pfile)
      those elsewhere.  */
   if (argv[argc].len == 0)
     {
-      if (CPP_PEDANTIC (pfile) && ! CPP_OPTIONS (pfile)->c99)
+      if (CPP_PEDANTIC (pfile) && ! CPP_OPTION (pfile, c99))
 	cpp_pedwarn (pfile, "C89 does not permit varargs macros");
 
       len = sizeof "__VA_ARGS__" - 1;
@@ -740,8 +740,8 @@ _cpp_create_definition (pfile, funlike)
 
   pfile->no_macro_expand++;
   pfile->parsing_define_directive++;
-  CPP_OPTIONS (pfile)->discard_comments++;
-  CPP_OPTIONS (pfile)->no_line_commands++;
+  CPP_OPTION (pfile, discard_comments)++;
+  CPP_OPTION (pfile, no_line_commands)++;
   
   if (funlike)
     {
@@ -760,15 +760,15 @@ _cpp_create_definition (pfile, funlike)
 
   pfile->no_macro_expand--;
   pfile->parsing_define_directive--;
-  CPP_OPTIONS (pfile)->discard_comments--;
-  CPP_OPTIONS (pfile)->no_line_commands--;
+  CPP_OPTION (pfile, discard_comments)--;
+  CPP_OPTION (pfile, no_line_commands)--;
   return defn;
 
  err:
   pfile->no_macro_expand--;
   pfile->parsing_define_directive--;
-  CPP_OPTIONS (pfile)->discard_comments--;
-  CPP_OPTIONS (pfile)->no_line_commands--;
+  CPP_OPTION (pfile, discard_comments)--;
+  CPP_OPTION (pfile, no_line_commands)--;
   return 0;
 }
 
@@ -1069,8 +1069,8 @@ _cpp_macroexpand (pfile, hp)
       rest_args = 0;
 
       /* Skip over the opening parenthesis.  */
-      CPP_OPTIONS (pfile)->discard_comments++;
-      CPP_OPTIONS (pfile)->no_line_commands++;
+      CPP_OPTION (pfile, discard_comments)++;
+      CPP_OPTION (pfile, no_line_commands)++;
       pfile->no_macro_expand++;
       pfile->no_directives++;
 
@@ -1102,8 +1102,8 @@ _cpp_macroexpand (pfile, hp)
 	  i++;
 	}
       while (token == CPP_COMMA);
-      CPP_OPTIONS (pfile)->discard_comments--;
-      CPP_OPTIONS (pfile)->no_line_commands--;
+      CPP_OPTION (pfile, discard_comments)--;
+      CPP_OPTION (pfile, no_line_commands)--;
       pfile->no_macro_expand--;
       pfile->no_directives--;
       if (token != CPP_RPAREN)
@@ -1457,7 +1457,7 @@ unsafe_chars (pfile, c1, c2)
       goto letter;
 
     case '$':
-      if (CPP_OPTIONS (pfile)->dollars_in_ident)
+      if (CPP_OPTION (pfile, dollars_in_ident))
 	goto letter;
       return 0;
 

gcc/cpphash.h

@@ -172,7 +172,7 @@ typedef struct ihash IHASH;
 #define IShspace	0x08	/* ' ' \t \f \v */
 #define ISspace		0x10	/* ' ' \t \f \v \n */
 
-#define _dollar_ok(x)	((x) == '$' && CPP_OPTIONS (pfile)->dollars_in_ident)
+#define _dollar_ok(x)	((x) == '$' && CPP_OPTION (pfile, dollars_in_ident))
 
 #define is_idchar(x)	((_cpp_IStable[x] & ISidnum) || _dollar_ok(x))
 #define is_idstart(x)	((_cpp_IStable[x] & ISidstart) || _dollar_ok(x))
@@ -223,10 +223,10 @@ 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)
 
-#define CPP_PRINT_DEPS(PFILE) (CPP_OPTIONS (PFILE)->print_deps)
-#define CPP_TRADITIONAL(PFILE) (CPP_OPTIONS(PFILE)->traditional)
+#define CPP_PRINT_DEPS(PFILE) CPP_OPTION (PFILE, print_deps)
+#define CPP_TRADITIONAL(PFILE) CPP_OPTION (PFILE, traditional)
 #define CPP_PEDANTIC(PFILE) \
-  (CPP_OPTIONS (PFILE)->pedantic && !CPP_BUFFER (pfile)->system_header_p)
+  (CPP_OPTION (PFILE, pedantic) && !CPP_BUFFER (pfile)->system_header_p)
 
 /* CPP_IS_MACRO_BUFFER is true if the buffer contains macro expansion.
    (Note that it is false while we're expanding macro *arguments*.) */

gcc/cppinit.c

@@ -92,7 +92,7 @@ Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.  */
    It may be overridden by the various -I and -ixxx options.
 
    #include "file" looks in the same directory as the current file,
-   then this list. 
+   then this list.
    #include <file> just looks in this list.
 
    All these directories are treated as `system' include directories
@@ -213,12 +213,12 @@ static void initialize_builtins		PARAMS ((cpp_reader *));
 static void append_include_chain	PARAMS ((cpp_reader *,
 						 struct cpp_pending *,
 						 char *, int, int));
-static void merge_include_chains	PARAMS ((struct cpp_options *));
+static void merge_include_chains	PARAMS ((cpp_reader *));
 
 static void dump_special_to_buffer	PARAMS ((cpp_reader *, const char *));
 static void initialize_dependency_output PARAMS ((cpp_reader *));
 static void initialize_standard_includes PARAMS ((cpp_reader *));
-static void new_pending_directive		PARAMS ((struct cpp_options *,
+static void new_pending_directive		PARAMS ((struct cpp_pending *,
 						 const char *,
 						 cl_directive_handler));
 #ifdef HOST_EBCDIC
@@ -243,7 +243,7 @@ enum { QUOTE = 0, BRACKET, SYSTEM, AFTER };
 #define ISTABLE unsigned char _cpp_IStable[256] = { 0 }; \
  static void init_IStable PARAMS ((void)) { \
  unsigned char *x = _cpp_IStable;
-#define END } 
+#define END }
 #define s(p, v) x[p] = v;
 #endif
 
@@ -342,7 +342,7 @@ append_include_chain (pfile, pend, dir, path, cxx_aware)
       /* Dirs that don't exist are silently ignored. */
       if (errno != ENOENT)
 	cpp_notice_from_errno (pfile, dir);
-      else if (CPP_OPTIONS (pfile)->verbose)
+      else if (CPP_OPTION (pfile, verbose))
 	fprintf (stderr, _("ignoring nonexistent directory `%s'\n"), dir);
       return;
     }
@@ -356,7 +356,7 @@ append_include_chain (pfile, pend, dir, path, cxx_aware)
   len = strlen (dir);
   if (len > pfile->max_include_len)
     pfile->max_include_len = len;
-  
+
   new = (struct file_name_list *) xmalloc (sizeof (struct file_name_list));
   new->name = dir;
   new->nlen = len;
@@ -389,22 +389,24 @@ append_include_chain (pfile, pend, dir, path, cxx_aware)
    how?) and possibly preload the include hash. */
 
 static void
-merge_include_chains (opts)
-     struct cpp_options *opts;
+merge_include_chains (pfile)
+     cpp_reader *pfile;
 {
   struct file_name_list *prev, *cur, *other;
   struct file_name_list *quote, *brack, *systm, *after;
   struct file_name_list *qtail, *btail, *stail, *atail;
 
-  qtail = opts->pending->quote_tail;
-  btail = opts->pending->brack_tail;
-  stail = opts->pending->systm_tail;
-  atail = opts->pending->after_tail;
+  struct cpp_pending *pend = CPP_OPTION (pfile, pending);
 
-  quote = opts->pending->quote_head;
-  brack = opts->pending->brack_head;
-  systm = opts->pending->systm_head;
-  after = opts->pending->after_head;
+  qtail = pend->quote_tail;
+  btail = pend->brack_tail;
+  stail = pend->systm_tail;
+  atail = pend->after_tail;
+
+  quote = pend->quote_head;
+  brack = pend->brack_head;
+  systm = pend->systm_head;
+  after = pend->after_head;
 
   /* Paste together bracket, system, and after include chains. */
   if (stail)
@@ -437,7 +439,7 @@ merge_include_chains (opts)
         if (INO_T_EQ (cur->ino, other->ino)
 	    && cur->dev == other->dev)
           {
-	    if (opts->verbose)
+	    if (CPP_OPTION (pfile, verbose))
 	      fprintf (stderr, _("ignoring duplicate directory `%s'\n"),
 		       cur->name);
 
@@ -457,7 +459,7 @@ merge_include_chains (opts)
         if (INO_T_EQ (cur->ino, other->ino)
 	    && cur->dev == other->dev)
           {
-	    if (opts->verbose)
+	    if (CPP_OPTION (pfile, verbose))
 	      fprintf (stderr, _("ignoring duplicate directory `%s'\n"),
 		       cur->name);
 
@@ -476,7 +478,7 @@ merge_include_chains (opts)
         {
 	  if (quote == qtail)
 	    {
-	      if (opts->verbose)
+	      if (CPP_OPTION (pfile, verbose))
 		fprintf (stderr, _("ignoring duplicate directory `%s'\n"),
 			 quote->name);
 
@@ -490,7 +492,7 @@ merge_include_chains (opts)
 	      while (cur->next != qtail)
 		  cur = cur->next;
 	      cur->next = brack;
-	      if (opts->verbose)
+	      if (CPP_OPTION (pfile, verbose))
 		fprintf (stderr, _("ignoring duplicate directory `%s'\n"),
 			 qtail->name);
 
@@ -504,8 +506,8 @@ merge_include_chains (opts)
   else
       quote = brack;
 
-  opts->quote_include = quote;
-  opts->bracket_include = brack;
+  CPP_OPTION (pfile, quote_include) = quote;
+  CPP_OPTION (pfile, bracket_include) = brack;
 }
 
 
@@ -528,22 +530,6 @@ dump_special_to_buffer (pfile, macro_name)
   CPP_PUTC (pfile, '\n');
 }
 
-/* Initialize a cpp_options structure. */
-void
-cpp_options_init (opts)
-     cpp_options *opts;
-{
-  memset ((char *) opts, 0, sizeof (struct cpp_options));
-
-  opts->dollars_in_ident = 1;
-  opts->cplusplus_comments = 1;
-  opts->warn_import = 1;
-  opts->discard_comments = 1;
-
-  opts->pending =
-    (struct cpp_pending *) xcalloc (1, sizeof (struct cpp_pending));
-}
-
 /* Initialize a cpp_reader structure. */
 void
 cpp_reader_init (pfile)
@@ -555,6 +541,15 @@ cpp_reader_init (pfile)
   pfile->token_buffer = (U_CHAR *) xmalloc (pfile->token_buffer_size);
   CPP_SET_WRITTEN (pfile, 0);
 
+  CPP_OPTION (pfile, dollars_in_ident) = 1;
+  CPP_OPTION (pfile, cplusplus_comments) = 1;
+  CPP_OPTION (pfile, warn_import) = 1;
+  CPP_OPTION (pfile, discard_comments) = 1;
+  CPP_OPTION (pfile, show_column) = 1;
+
+  CPP_OPTION (pfile, pending) =
+    (struct cpp_pending *) xcalloc (1, sizeof (struct cpp_pending));
+
   _cpp_init_macro_hash (pfile);
   _cpp_init_include_hash (pfile);
 }
@@ -665,7 +660,7 @@ initialize_builtins (pfile)
       hp->value.cpval = val;
       *(htab_find_slot (pfile->hashtab, (void *)hp, 1)) = hp;
 
-      if ((b->flags & DUMP) && CPP_OPTIONS (pfile)->debug_output)
+      if ((b->flags & DUMP) && CPP_OPTION (pfile, debug_output))
 	dump_special_to_buffer (pfile, b->name);
     }
 
@@ -681,24 +676,23 @@ static void
 initialize_dependency_output (pfile)
      cpp_reader *pfile;
 {
-  cpp_options *opts = CPP_OPTIONS (pfile);
   char *spec, *s, *output_file;
-  
+
   /* Either of two environment variables can specify output of deps.
      Its value is either "OUTPUT_FILE" or "OUTPUT_FILE DEPS_TARGET",
      where OUTPUT_FILE is the file to write deps info to
      and DEPS_TARGET is the target to mention in the deps.  */
 
-  if (opts->print_deps == 0)
+  if (CPP_OPTION (pfile, print_deps) == 0)
     {
       spec = getenv ("DEPENDENCIES_OUTPUT");
       if (spec)
-	opts->print_deps = 1;
+	CPP_OPTION (pfile, print_deps) = 1;
       else
 	{
 	  spec = getenv ("SUNPRO_DEPENDENCIES");
 	  if (spec)
-	    opts->print_deps = 2;
+	    CPP_OPTION (pfile, print_deps) = 2;
 	  else
 	    return;
 	}
@@ -707,33 +701,33 @@ initialize_dependency_output (pfile)
       s = strchr (spec, ' ');
       if (s)
 	{
-	  opts->deps_target = s + 1;
+	  CPP_OPTION (pfile, deps_target) = s + 1;
 	  output_file = (char *) xmalloc (s - spec + 1);
 	  memcpy (output_file, spec, s - spec);
 	  output_file[s - spec] = 0;
 	}
       else
 	{
-	  opts->deps_target = 0;
+	  CPP_OPTION (pfile, deps_target) = 0;
 	  output_file = spec;
 	}
 
-      opts->deps_file = output_file;
-      opts->print_deps_append = 1;
+      CPP_OPTION (pfile, deps_file) = output_file;
+      CPP_OPTION (pfile, print_deps_append) = 1;
     }
 
   pfile->deps = deps_init ();
 
   /* Print the expected object file name as the target of this Make-rule.  */
-  if (opts->deps_target)
-    deps_add_target (pfile->deps, opts->deps_target);
-  else if (*opts->in_fname == 0)
+  if (CPP_OPTION (pfile, deps_target))
+    deps_add_target (pfile->deps, CPP_OPTION (pfile, deps_target));
+  else if (*CPP_OPTION (pfile, in_fname) == 0)
     deps_add_target (pfile->deps, "-");
   else
-    deps_calc_target (pfile->deps, opts->in_fname);
+    deps_calc_target (pfile->deps, CPP_OPTION (pfile, in_fname));
 
-  if (opts->in_fname)
-    deps_add_dep (pfile->deps, opts->in_fname);
+  if (CPP_OPTION (pfile, in_fname))
+    deps_add_dep (pfile->deps, CPP_OPTION (pfile, in_fname));
 }
 
 /* And another subroutine.  This one sets up the standard include path.  */
@@ -741,10 +735,9 @@ static void
 initialize_standard_includes (pfile)
      cpp_reader *pfile;
 {
-  cpp_options *opts = CPP_OPTIONS (pfile);
   char *path;
   const struct default_include *p;
-  const char *specd_prefix = opts->include_prefix;
+  const char *specd_prefix = CPP_OPTION (pfile, include_prefix);
 
   /* Several environment variables may add to the include search path.
      CPATH specifies an additional list of directories to be searched
@@ -754,9 +747,9 @@ initialize_standard_includes (pfile)
 
   GET_ENV_PATH_LIST (path, "CPATH");
   if (path != 0 && *path != 0)
-    path_include (pfile, opts->pending, path, BRACKET);
+    path_include (pfile, CPP_OPTION (pfile, pending), path, BRACKET);
 
-  switch ((opts->objc << 1) + opts->cplusplus)
+  switch ((CPP_OPTION (pfile, objc) << 1) + CPP_OPTION (pfile, cplusplus))
     {
     case 0:
       GET_ENV_PATH_LIST (path, "C_INCLUDE_PATH");
@@ -772,7 +765,7 @@ initialize_standard_includes (pfile)
       break;
     }
   if (path != 0 && *path != 0)
-    path_include (pfile, opts->pending, path, SYSTEM);
+    path_include (pfile, CPP_OPTION (pfile, pending), path, SYSTEM);
 
   /* Search "translated" versions of GNU directories.
      These have /usr/local/lib/gcc... replaced by specd_prefix.  */
@@ -791,8 +784,8 @@ initialize_standard_includes (pfile)
 	{
 	  /* Some standard dirs are only for C++.  */
 	  if (!p->cplusplus
-	      || (opts->cplusplus
-		  && !opts->no_standard_cplusplus_includes))
+	      || (CPP_OPTION (pfile, cplusplus)
+		  && !CPP_OPTION (pfile, no_standard_cplusplus_includes)))
 	    {
 	      /* Does this dir start with the prefix?  */
 	      if (!strncmp (p->fname, default_prefix, default_len))
@@ -806,7 +799,7 @@ initialize_standard_includes (pfile)
 			  p->fname + default_len,
 			  flen - default_len + 1);
 
-		  append_include_chain (pfile, opts->pending,
+		  append_include_chain (pfile, CPP_OPTION (pfile, pending),
 					str, SYSTEM, p->cxx_aware);
 		}
 	    }
@@ -818,13 +811,13 @@ initialize_standard_includes (pfile)
     {
       /* Some standard dirs are only for C++.  */
       if (!p->cplusplus
-	  || (opts->cplusplus
-	      && !opts->no_standard_cplusplus_includes))
+	  || (CPP_OPTION (pfile, cplusplus)
+	      && !CPP_OPTION (pfile, no_standard_cplusplus_includes)))
 	{
 	  /* XXX Potential memory leak! */
 	  char *str = xstrdup (update_path (p->fname, p->component));
-	  append_include_chain (pfile, opts->pending, str, SYSTEM,
-				p->cxx_aware);
+	  append_include_chain (pfile, CPP_OPTION (pfile, pending),
+				str, SYSTEM, p->cxx_aware);
 	}
     }
 }
@@ -840,24 +833,24 @@ cpp_start_read (pfile, fname)
      cpp_reader *pfile;
      const char *fname;
 {
-  struct cpp_options *opts = CPP_OPTIONS (pfile);
   struct pending_option *p, *q;
 
   /* -MG doesn't select the form of output and must be specified with one of
      -M or -MM.  -MG doesn't make sense with -MD or -MMD since they don't
      inhibit compilation.  */
-  if (opts->print_deps_missing_files
-      && (opts->print_deps == 0 || !opts->no_output))
+  if (CPP_OPTION (pfile, print_deps_missing_files)
+      && (CPP_OPTION (pfile, print_deps) == 0
+	  || !CPP_OPTION (pfile, no_output)))
     {
       cpp_fatal (pfile, "-MG must be specified with one of -M or -MM");
       return 0;
     }
 
   /* Chill should not be used with -trigraphs. */
-  if (opts->chill && opts->trigraphs)
+  if (CPP_OPTION (pfile, chill) && CPP_OPTION (pfile, trigraphs))
     {
       cpp_warning (pfile, "-lang-chill and -trigraphs are mutually exclusive");
-      opts->trigraphs = 0;
+      CPP_OPTION (pfile, trigraphs) = 0;
     }
 
   /* Set this if it hasn't been set already. */
@@ -866,7 +859,7 @@ cpp_start_read (pfile, fname)
 
   /* Don't bother trying to do macro expansion if we've already done
      preprocessing.  */
-  if (opts->preprocessed)
+  if (CPP_OPTION (pfile, preprocessed))
     pfile->no_macro_expand++;
 
   /* Set up the IStable.  This doesn't do anything if we were compiled
@@ -875,21 +868,21 @@ cpp_start_read (pfile, fname)
 
   /* Set up the tables used by read_and_prescan.  */
   _cpp_init_input_buffer (pfile);
-  
+
   /* Set up the include search path now.  */
-  if (! opts->no_standard_includes)
+  if (! CPP_OPTION (pfile, no_standard_includes))
     initialize_standard_includes (pfile);
 
-  merge_include_chains (opts);
+  merge_include_chains (pfile);
 
   /* With -v, print the list of dirs to search.  */
-  if (opts->verbose)
+  if (CPP_OPTION (pfile, verbose))
     {
       struct file_name_list *l;
       fprintf (stderr, _("#include \"...\" search starts here:\n"));
-      for (l = opts->quote_include; l; l = l->next)
+      for (l = CPP_OPTION (pfile, quote_include); l; l = l->next)
 	{
-	  if (l == opts->bracket_include)
+	  if (l == CPP_OPTION (pfile, bracket_include))
 	    fprintf (stderr, _("#include <...> search starts here:\n"));
 	  fprintf (stderr, " %s\n", l->name);
 	}
@@ -898,18 +891,21 @@ cpp_start_read (pfile, fname)
 
   /* Open the main input file.  This must be done early, so we have a
      buffer to stand on.  */
-  if (opts->in_fname == NULL || *opts->in_fname == 0)
+  if (CPP_OPTION (pfile, in_fname) == NULL
+      || *CPP_OPTION (pfile, in_fname) == 0)
     {
-      opts->in_fname = fname;
-      if (opts->in_fname == NULL)
-	opts->in_fname = "";
+      CPP_OPTION (pfile, in_fname) = fname;
+      if (CPP_OPTION (pfile, in_fname) == NULL)
+	CPP_OPTION (pfile, in_fname) = "";
     }
+  if (CPP_OPTION (pfile, out_fname) == NULL)
+    CPP_OPTION (pfile, out_fname) = "";
 
   if (!cpp_read_file (pfile, fname))
     return 0;
 
   initialize_dependency_output (pfile);
-  
+
   /* -D and friends may produce output, which should be identified
      as line 0.  */
 
@@ -919,7 +915,7 @@ cpp_start_read (pfile, fname)
   initialize_builtins (pfile);
 
   /* Do -U's, -D's and -A's in the order they were seen.  */
-  p = opts->pending->directive_head;
+  p = CPP_OPTION (pfile, pending)->directive_head;
   while (p)
     {
       (*p->handler) (pfile, p->arg);
@@ -928,10 +924,10 @@ cpp_start_read (pfile, fname)
       p = q;
     }
 
-  opts->done_initializing = 1;
+  pfile->done_initializing = 1;
   CPP_BUFFER (pfile)->lineno = 1;
 
-  if (opts->preprocessed)
+  if (CPP_OPTION (pfile, preprocessed))
     /* If we've already processed this code, we want to trust the #line
        directives in the input.  But we still need to update our line
        counter accordingly.  */
@@ -943,9 +939,9 @@ cpp_start_read (pfile, fname)
   /* The -imacros files can be scanned now, but the -include files
      have to be pushed onto the include stack and processed later,
      in the main loop calling cpp_get_token.  */
-  
-  opts->no_output++;
-  p = opts->pending->imacros_head;
+
+  CPP_OPTION (pfile, no_output)++;
+  p = CPP_OPTION (pfile, pending)->imacros_head;
   while (p)
     {
       if (cpp_read_file (pfile, p->arg))
@@ -955,9 +951,9 @@ cpp_start_read (pfile, fname)
       free (p);
       p = q;
     }
-  opts->no_output--;
+  CPP_OPTION (pfile, no_output)--;
 
-  p = opts->pending->include_head;
+  p = CPP_OPTION (pfile, pending)->include_head;
   while (p)
     {
       if (cpp_read_file (pfile, p->arg))
@@ -968,8 +964,8 @@ cpp_start_read (pfile, fname)
       p = q;
     }
 
-  free (opts->pending);
-  opts->pending = NULL;
+  free (CPP_OPTION (pfile, pending));
+  CPP_OPTION (pfile, pending) = NULL;
 
   return 1;
 }
@@ -982,29 +978,30 @@ void
 cpp_finish (pfile)
      cpp_reader *pfile;
 {
-  struct cpp_options *opts = CPP_OPTIONS (pfile);
-
   if (CPP_PREV_BUFFER (CPP_BUFFER (pfile)))
     cpp_ice (pfile, "buffers still stacked in cpp_finish");
   while (CPP_BUFFER (pfile))
     cpp_pop_buffer (pfile);
 
   /* Don't write the deps file if preprocessing has failed.  */
-  if (opts->print_deps && pfile->errors == 0)
+  if (CPP_OPTION (pfile, print_deps) && pfile->errors == 0)
     {
       /* Stream on which to print the dependency information.  */
       FILE *deps_stream = 0;
-
-      const char *deps_mode = opts->print_deps_append ? "a" : "w";
-      if (opts->deps_file == 0)
+      const char *deps_mode
+	= CPP_OPTION (pfile, print_deps_append) ? "a" : "w";
+      if (CPP_OPTION (pfile, deps_file) == 0)
 	deps_stream = stdout;
-      else if ((deps_stream = fopen (opts->deps_file, deps_mode)) == 0)
-	cpp_notice_from_errno (pfile, opts->deps_file);
-
+      else
+	{
+	  deps_stream = fopen (CPP_OPTION (pfile, deps_file), deps_mode);
+	  if (deps_stream == 0)
+	    cpp_notice_from_errno (pfile, CPP_OPTION (pfile, deps_file));
+	}
       if (deps_stream)
 	{
 	  deps_write (pfile->deps, deps_stream, 72);
-	  if (opts->deps_file)
+	  if (CPP_OPTION (pfile, deps_file))
 	    {
 	      if (ferror (deps_stream) || fclose (deps_stream) != 0)
 		cpp_fatal (pfile, "I/O error on output");
@@ -1012,13 +1009,13 @@ cpp_finish (pfile)
 	}
     }
 
-  if (opts->dump_macros == dump_only)
+  if (CPP_OPTION (pfile, dump_macros) == dump_only)
     _cpp_dump_macro_hash (pfile);
 }
 
 static void
-new_pending_directive (opts, text, handler)
-     struct cpp_options *opts;
+new_pending_directive (pend, text, handler)
+     struct cpp_pending *pend;
      const char *text;
      cl_directive_handler handler;
 {
@@ -1028,34 +1025,92 @@ new_pending_directive (opts, text, handler)
   o->arg = text;
   o->next = NULL;
   o->handler = handler;
-  APPEND (opts->pending, directive, o);
+  APPEND (pend, directive, o);
 }
 
+/* Irix6 "cc -n32" and OSF4 cc have problems with char foo[] = ("string");
+   I.e. a const string initializer with parens around it.  That is
+   what N_("string") resolves to, so we make no_* be macros instead.  */
+#define no_arg N_("Argument missing after %s")
+#define no_ass N_("Assertion missing after %s")
+#define no_dir N_("Directory name missing after %s")
+#define no_fil N_("File name missing after %s")
+#define no_mac N_("Macro name missing after %s")
+#define no_pth N_("Path name missing after %s")
+
+/* This is the list of all command line options, with the leading
+   "-" removed.  It must be sorted in ASCII collating order.  */
+#define COMMAND_LINE_OPTIONS                                                  \
+  DEF_OPT("",                         0,      OPT_stdin_stdout)               \
+  DEF_OPT("$",                        0,      OPT_dollar)                     \
+  DEF_OPT("+",                        0,      OPT_plus)                       \
+  DEF_OPT("-help",                    0,      OPT__help)                      \
+  DEF_OPT("-version",                 0,      OPT__version)                   \
+  DEF_OPT("A",                        no_ass, OPT_A)                          \
+  DEF_OPT("C",                        0,      OPT_C)                          \
+  DEF_OPT("D",                        no_mac, OPT_D)                          \
+  DEF_OPT("H",                        0,      OPT_H)                          \
+  DEF_OPT("I",                        no_dir, OPT_I)                          \
+  DEF_OPT("M",                        0,      OPT_M)                          \
+  DEF_OPT("MD",                       no_fil, OPT_MD)                         \
+  DEF_OPT("MG",                       0,      OPT_MG)                         \
+  DEF_OPT("MM",                       0,      OPT_MM)                         \
+  DEF_OPT("MMD",                      no_fil, OPT_MMD)                        \
+  DEF_OPT("P",                        0,      OPT_P)                          \
+  DEF_OPT("U",                        no_mac, OPT_U)                          \
+  DEF_OPT("W",                        no_arg, OPT_W)  /* arg optional */      \
+  DEF_OPT("d",                        no_arg, OPT_d)                          \
+  DEF_OPT("fleading-underscore",      0,      OPT_fleading_underscore)        \
+  DEF_OPT("fno-leading-underscore",   0,      OPT_fno_leading_underscore)     \
+  DEF_OPT("fno-preprocessed",         0,      OPT_fno_preprocessed)           \
+  DEF_OPT("fno-show-column",          0,      OPT_fno_show_column)            \
+  DEF_OPT("fpreprocessed",            0,      OPT_fpreprocessed)              \
+  DEF_OPT("fshow-column",             0,      OPT_fshow_column)               \
+  DEF_OPT("g",                        no_arg, OPT_g)  /* arg optional */      \
+  DEF_OPT("h",                        0,      OPT_h)                          \
+  DEF_OPT("idirafter",                no_dir, OPT_idirafter)                  \
+  DEF_OPT("imacros",                  no_fil, OPT_imacros)                    \
+  DEF_OPT("include",                  no_fil, OPT_include)                    \
+  DEF_OPT("iprefix",                  no_pth, OPT_iprefix)                    \
+  DEF_OPT("isystem",                  no_dir, OPT_isystem)                    \
+  DEF_OPT("iwithprefix",              no_dir, OPT_iwithprefix)                \
+  DEF_OPT("iwithprefixbefore",        no_dir, OPT_iwithprefixbefore)          \
+  DEF_OPT("lang-asm",                 0,      OPT_lang_asm)                   \
+  DEF_OPT("lang-c",                   0,      OPT_lang_c)                     \
+  DEF_OPT("lang-c++",                 0,      OPT_lang_cplusplus)             \
+  DEF_OPT("lang-c89",                 0,      OPT_lang_c89)                   \
+  DEF_OPT("lang-chill",               0,      OPT_lang_chill)                 \
+  DEF_OPT("lang-fortran",             0,      OPT_lang_fortran)               \
+  DEF_OPT("lang-objc",                0,      OPT_lang_objc)                  \
+  DEF_OPT("lang-objc++",              0,      OPT_lang_objcplusplus)          \
+  DEF_OPT("nostdinc",                 0,      OPT_nostdinc)                   \
+  DEF_OPT("nostdinc++",               0,      OPT_nostdincplusplus)           \
+  DEF_OPT("o",                        no_fil, OPT_o)                          \
+  DEF_OPT("pedantic",                 0,      OPT_pedantic)                   \
+  DEF_OPT("pedantic-errors",          0,      OPT_pedantic_errors)            \
+  DEF_OPT("remap",                    0,      OPT_remap)                      \
+  DEF_OPT("std=c89",                  0,      OPT_std_c89)                    \
+  DEF_OPT("std=c99",                  0,      OPT_std_c99)                    \
+  DEF_OPT("std=c9x",                  0,      OPT_std_c9x)                    \
+  DEF_OPT("std=gnu89",                0,      OPT_std_gnu89)                  \
+  DEF_OPT("std=gnu99",                0,      OPT_std_gnu99)                  \
+  DEF_OPT("std=gnu9x",                0,      OPT_std_gnu9x)                  \
+  DEF_OPT("std=iso9899:1990",         0,      OPT_std_iso9899_1990)           \
+  DEF_OPT("std=iso9899:199409",       0,      OPT_std_iso9899_199409)         \
+  DEF_OPT("std=iso9899:1999",         0,      OPT_std_iso9899_1999)           \
+  DEF_OPT("std=iso9899:199x",         0,      OPT_std_iso9899_199x)           \
+  DEF_OPT("traditional",              0,      OPT_traditional)                \
+  DEF_OPT("trigraphs",                0,      OPT_trigraphs)                  \
+  DEF_OPT("v",                        0,      OPT_v)                          \
+  DEF_OPT("w",                        0,      OPT_w)
+
+#define DEF_OPT(text, msg, code) code,
 enum opt_code
 {
-  OPT_stdin_stdout = 0, OPT_dollar, OPT_plus,
-  OPT__help, OPT__version,
-  OPT_A, OPT_C, OPT_D, OPT_H, OPT_I, OPT_M,
-  OPT_MD, OPT_MG, OPT_MM, OPT_MMD,
-  OPT_P, OPT_U, OPT_W,
-  OPT_d,
-  OPT_fleading_underscore, OPT_fno_leading_underscore,
-  OPT_fpreprocessed, OPT_fno_preprocessed,
-  OPT_g, OPT_h, 
-  OPT_idirafter, OPT_imacros, OPT_include,
-  OPT_iprefix, OPT_isystem, OPT_iwithprefix, OPT_iwithprefixbefore,
-  OPT_lang_asm, OPT_lang_c, OPT_lang_cplusplus, OPT_lang_c89,
-  OPT_lang_chill, OPT_lang_fortran, OPT_lang_objc, OPT_lang_objcplusplus,
-  OPT_nostdinc, OPT_nostdincplusplus,
-  OPT_o,
-  OPT_pedantic, OPT_pedantic_errors, OPT_remap,
-  OPT_std_c89, OPT_std_c99, OPT_std_c9x, OPT_std_gnu89, OPT_std_gnu99,
-  OPT_std_gnu9x, OPT_std_iso9899_1990, OPT_std_iso9899_199409,
-  OPT_std_iso9899_1999, OPT_std_iso9899_199x,
-  OPT_traditional, OPT_trigraphs,
-  OPT_v, OPT_w,
+  COMMAND_LINE_OPTIONS
   N_OPTS
 };
+#undef DEF_OPT
 
 struct cl_option
 {
@@ -1065,89 +1120,17 @@ struct cl_option
   enum opt_code opt_code;
 };
 
-/* Irix6 "cc -n32" and OSF4 cc have problems with char foo[] = ("string");
-   I.e. a const string initializer with parens around it.  That is
-   what N_("string") resolves to, so we make no_* be macros instead.  */
-#define no_arg N_("Argument missing after `%s' option")
-#define no_ass N_("Assertion missing after `%s' option")
-#define no_dir N_("Directory name missing after `%s' option")
-#define no_fil N_("File name missing after `%s' option")
-#define no_mac N_("Macro name missing after `%s' option")
-#define no_pth N_("Path name missing after `%s' option")
-
-/* This list must be ASCII sorted. Make enum order above match this. */
-#define DEF_OPT(text, msg, code) {text, msg, sizeof(text) - 1, code}
-
+#define DEF_OPT(text, msg, code) { text, msg, sizeof(text) - 1, code },
 #ifdef HOST_EBCDIC
 static struct cl_option cl_options[] =
 #else
 static const struct cl_option cl_options[] =
 #endif
 {
-  DEF_OPT("",                         0,      OPT_stdin_stdout),
-  DEF_OPT("$",                        0,      OPT_dollar),
-  DEF_OPT("+",                        0,      OPT_plus),
-  DEF_OPT("-help",                    0,      OPT__help),
-  DEF_OPT("-version",                 0,      OPT__version),
-  DEF_OPT("A",                        no_ass, OPT_A),
-  DEF_OPT("C",                        0,      OPT_C),
-  DEF_OPT("D",                        no_mac, OPT_D),
-  DEF_OPT("H",                        0,      OPT_H),
-  DEF_OPT("I",                        no_dir, OPT_I),
-  DEF_OPT("M",                        0,      OPT_M),
-  DEF_OPT("MD",                       no_fil, OPT_MD),
-  DEF_OPT("MG",                       0,      OPT_MG),
-  DEF_OPT("MM",                       0,      OPT_MM),
-  DEF_OPT("MMD",                      no_fil, OPT_MMD),
-  DEF_OPT("P",                        0,      OPT_P),
-  DEF_OPT("U",                        no_mac, OPT_U),
-  /* NB: Immed arg only, and not reqd */
-  DEF_OPT("W",                        no_arg, OPT_W),
-  DEF_OPT("d",                        no_arg, OPT_d),
-  DEF_OPT("fleading-underscore",      0,      OPT_fleading_underscore),
-  DEF_OPT("fno-leading-underscore",   0,      OPT_fno_leading_underscore),
-  DEF_OPT("fpreprocessed",            0,      OPT_fpreprocessed),
-  DEF_OPT("fno-preprocessed",         0,      OPT_fno_preprocessed),
-  /* NB: Immed arg only, and not reqd */
-  DEF_OPT("g",                        no_arg, OPT_g),
-  DEF_OPT("h",                        0,      OPT_h),
-  DEF_OPT("idirafter",                no_dir, OPT_idirafter),
-  DEF_OPT("imacros",                  no_fil, OPT_imacros),
-  DEF_OPT("include",                  no_fil, OPT_include),
-  DEF_OPT("iprefix",                  no_pth, OPT_iprefix),
-  DEF_OPT("isystem",                  no_dir, OPT_isystem),
-  DEF_OPT("iwithprefix",              no_dir, OPT_iwithprefix),
-  DEF_OPT("iwithprefixbefore",        no_dir, OPT_iwithprefixbefore),
-  DEF_OPT("lang-asm",                 0,      OPT_lang_asm),
-  DEF_OPT("lang-c",                   0,      OPT_lang_c),
-  DEF_OPT("lang-c++",                 0,      OPT_lang_cplusplus),
-  DEF_OPT("lang-c89",                 0,      OPT_lang_c89),
-  DEF_OPT("lang-chill",               0,      OPT_lang_chill),
-  DEF_OPT("lang-fortran",             0,      OPT_lang_fortran),
-  DEF_OPT("lang-objc",                0,      OPT_lang_objc),
-  DEF_OPT("lang-objc++",              0,      OPT_lang_objcplusplus),
-  DEF_OPT("nostdinc",                 0,      OPT_nostdinc),
-  DEF_OPT("nostdinc++",               0,      OPT_nostdincplusplus),
-  DEF_OPT("o",                        no_fil, OPT_o),
-  DEF_OPT("pedantic",                 0,      OPT_pedantic),
-  DEF_OPT("pedantic-errors",          0,      OPT_pedantic_errors),
-  DEF_OPT("remap",                    0,      OPT_remap),
-  DEF_OPT("std=c89",                  0,      OPT_std_c89),
-  DEF_OPT("std=c99",                  0,      OPT_std_c99),
-  DEF_OPT("std=c9x",                  0,      OPT_std_c9x),
-  DEF_OPT("std=gnu89",                0,      OPT_std_gnu89),
-  DEF_OPT("std=gnu99",                0,      OPT_std_gnu99),
-  DEF_OPT("std=gnu9x",                0,      OPT_std_gnu9x),
-  DEF_OPT("std=iso9899:1990",         0,      OPT_std_iso9899_1990),
-  DEF_OPT("std=iso9899:199409",       0,      OPT_std_iso9899_199409),
-  DEF_OPT("std=iso9899:1999",         0,      OPT_std_iso9899_1999),
-  DEF_OPT("std=iso9899:199x",         0,      OPT_std_iso9899_199x),
-  DEF_OPT("traditional",              0,      OPT_traditional),
-  DEF_OPT("trigraphs",                0,      OPT_trigraphs),
-  DEF_OPT("v",                        0,      OPT_v),
-  DEF_OPT("w",                        0,      OPT_w)
+  COMMAND_LINE_OPTIONS
 };
 #undef DEF_OPT
+#undef COMMAND_LINE_OPTIONS
 
 /* Perform a binary search to find which, if any, option the given
    command-line matches.  Returns its index in the option array,
@@ -1171,10 +1154,10 @@ parse_option (input)
   while (mx > mn)
     {
       md = (mn + mx) / 2;
-    
+
       opt_len = cl_options[md].opt_len;
       comp = strncmp (input, cl_options[md].opt_text, opt_len);
-    
+
       if (comp > 0)
 	mn = md + 1;
       else if (comp < 0)
@@ -1223,20 +1206,17 @@ handle_option (pfile, argc, argv)
      int argc;
      char **argv;
 {
-  struct cpp_options *opts = CPP_OPTIONS (pfile);
   int i = 0;
 
   if (argv[i][0] != '-')
     {
-      if (opts->out_fname != NULL)
-	{
-	  print_help ();
-	  cpp_fatal (pfile, "Too many arguments");
-	}
-      else if (opts->in_fname != NULL)
-	opts->out_fname = argv[i];
+      if (CPP_OPTION (pfile, out_fname) != NULL)
+	cpp_fatal (pfile, "Too many arguments. Type %s --help for usage info",
+		   progname);
+      else if (CPP_OPTION (pfile, in_fname) != NULL)
+	CPP_OPTION (pfile, out_fname) = argv[i];
       else
-	opts->in_fname = argv[i];
+	CPP_OPTION (pfile, in_fname) = argv[i];
     }
   else
     {
@@ -1267,7 +1247,7 @@ handle_option (pfile, argc, argv)
 		}
 	    }
 	}
- 
+
       switch (opt_code)
 	{
 	case N_OPTS: /* shut GCC up */
@@ -1279,17 +1259,23 @@ handle_option (pfile, argc, argv)
 	  user_label_prefix = "";
 	  break;
 	case OPT_fpreprocessed:
-	  opts->preprocessed = 1;
+	  CPP_OPTION (pfile, preprocessed) = 1;
 	  break;
 	case OPT_fno_preprocessed:
-	  opts->preprocessed = 0;
+	  CPP_OPTION (pfile, preprocessed) = 0;
+	  break;
+	case OPT_fshow_column:
+	  CPP_OPTION (pfile, show_column) = 1;
+	  break;
+	case OPT_fno_show_column:
+	  CPP_OPTION (pfile, show_column) = 0;
 	  break;
 	case OPT_w:
-	  opts->inhibit_warnings = 1;
+	  CPP_OPTION (pfile, inhibit_warnings) = 1;
 	  break;
 	case OPT_g:  /* Silently ignore anything but -g3 */
 	  if (!strcmp(&argv[i][2], "3"))
-	    opts->debug_output = 1;
+	    CPP_OPTION (pfile, debug_output) = 1;
 	  break;
 	case OPT_h:
 	case OPT__help:
@@ -1301,124 +1287,156 @@ handle_option (pfile, argc, argv)
 	  exit (0);  /* XXX */
 	  break;
 	case OPT_C:
-	  opts->discard_comments = 0;
+	  CPP_OPTION (pfile, discard_comments) = 0;
 	  break;
 	case OPT_P:
-	  opts->no_line_commands = 1;
+	  CPP_OPTION (pfile, no_line_commands) = 1;
 	  break;
 	case OPT_dollar:		/* Don't include $ in identifiers.  */
-	  opts->dollars_in_ident = 0;
+	  CPP_OPTION (pfile, dollars_in_ident) = 0;
 	  break;
 	case OPT_H:
-	  opts->print_include_names = 1;
+	  CPP_OPTION (pfile, print_include_names) = 1;
 	  break;
 	case OPT_D:
-	  new_pending_directive (opts, arg, cpp_define);
+	  new_pending_directive (CPP_OPTION (pfile, pending), arg, cpp_define);
 	  break;
 	case OPT_pedantic_errors:
-	  opts->pedantic_errors = 1;
+	  CPP_OPTION (pfile, pedantic_errors) = 1;
 	  /* fall through */
 	case OPT_pedantic:
- 	  opts->pedantic = 1;
+ 	  CPP_OPTION (pfile, pedantic) = 1;
 	  break;
 	case OPT_traditional:
-	  opts->traditional = 1;
-	  opts->cplusplus_comments = 0;
-	  opts->trigraphs = 0;
-	  opts->warn_trigraphs = 0;
+	  CPP_OPTION (pfile, traditional) = 1;
+	  CPP_OPTION (pfile, cplusplus_comments) = 0;
+	  CPP_OPTION (pfile, trigraphs) = 0;
+	  CPP_OPTION (pfile, warn_trigraphs) = 0;
 	  break;
 	case OPT_trigraphs:
- 	  opts->trigraphs = 1;
+ 	  CPP_OPTION (pfile, trigraphs) = 1;
 	  break;
 	case OPT_plus:
-	  opts->cplusplus = 1;
-	  opts->cplusplus_comments = 1;
+	  CPP_OPTION (pfile, cplusplus) = 1;
+	  CPP_OPTION (pfile, cplusplus_comments) = 1;
 	  break;
 	case OPT_remap:
-	  opts->remap = 1;
+	  CPP_OPTION (pfile, remap) = 1;
 	  break;
 	case OPT_iprefix:
-	  opts->include_prefix = arg;
-	  opts->include_prefix_len = strlen (arg);
+	  CPP_OPTION (pfile, include_prefix) = arg;
+	  CPP_OPTION (pfile, include_prefix_len) = strlen (arg);
 	  break;
 	case OPT_lang_c:
-	  opts->cplusplus = 0, opts->cplusplus_comments = 1;
-	  opts->c89 = 0, opts->c99 = 1, opts->objc = 0;
+	  CPP_OPTION (pfile, cplusplus) = 0;
+	  CPP_OPTION (pfile, cplusplus_comments) = 1;
+	  CPP_OPTION (pfile, c89) = 0;
+	  CPP_OPTION (pfile, c99) = 1;
+	  CPP_OPTION (pfile, objc) = 0;
 	  break;
 	case OPT_lang_c89:
-	  opts->cplusplus = 0, opts->cplusplus_comments = 0;
-	  opts->c89 = 1, opts->c99 = 0, opts->objc = 0;
-	  opts->trigraphs = 1;
-	  new_pending_directive (opts, "__STRICT_ANSI__", cpp_define);
+	  CPP_OPTION (pfile, cplusplus) = 0;
+	  CPP_OPTION (pfile, cplusplus_comments) = 0;
+	  CPP_OPTION (pfile, c89) = 1;
+	  CPP_OPTION (pfile, c99) = 0;
+	  CPP_OPTION (pfile, objc) = 0;
+	  CPP_OPTION (pfile, trigraphs) = 1;
+	  new_pending_directive (CPP_OPTION (pfile, pending),
+				 "__STRICT_ANSI__", cpp_define);
 	  break;
 	case OPT_lang_cplusplus:
-	  opts->cplusplus = 1, opts->cplusplus_comments = 1;
-	  opts->c89 = 0, opts->c99 = 0, opts->objc = 0;
+	  CPP_OPTION (pfile, cplusplus) = 1;
+	  CPP_OPTION (pfile, cplusplus_comments) = 1;
+	  CPP_OPTION (pfile, c89) = 0;
+	  CPP_OPTION (pfile, c99) = 0;
+	  CPP_OPTION (pfile, objc) = 0;
 	  break;
 	case OPT_lang_objc:
 	case OPT_lang_objcplusplus:
-	  opts->cplusplus = opt_code == OPT_lang_objcplusplus;
-	  opts->cplusplus_comments = 1;
-	  opts->c89 = 0, opts->c99 = 0, opts->objc = 1;
+	  CPP_OPTION (pfile, cplusplus) = opt_code == OPT_lang_objcplusplus;
+	  CPP_OPTION (pfile, cplusplus_comments) = 1;
+	  CPP_OPTION (pfile, c89) = 0;
+	  CPP_OPTION (pfile, c99) = 0;
+	  CPP_OPTION (pfile, objc) = 1;
 	  break;
 	case OPT_lang_asm:
- 	  opts->lang_asm = 1;
+ 	  CPP_OPTION (pfile, lang_asm) = 1;
 	  break;
 	case OPT_lang_fortran:
- 	  opts->lang_fortran = 1, opts->cplusplus_comments = 0;
+ 	  CPP_OPTION (pfile, lang_fortran) = 1;
+	  CPP_OPTION (pfile, cplusplus_comments) = 0;
 	  break;
 	case OPT_lang_chill:
-	  opts->objc = 0, opts->cplusplus = 0;
-	  opts->chill = 1, opts->traditional = 1;
+	  CPP_OPTION (pfile, objc) = 0;
+	  CPP_OPTION (pfile, cplusplus) = 0;
+	  CPP_OPTION (pfile, chill) = 1;
+	  CPP_OPTION (pfile, traditional) = 1;
 	  break;
 	case OPT_nostdinc:
 	  /* -nostdinc causes no default include directories.
 	     You must specify all include-file directories with -I.  */
-	  opts->no_standard_includes = 1;
+	  CPP_OPTION (pfile, no_standard_includes) = 1;
 	  break;
 	case OPT_nostdincplusplus:
 	  /* -nostdinc++ causes no default C++-specific include directories. */
-	  opts->no_standard_cplusplus_includes = 1;
+	  CPP_OPTION (pfile, no_standard_cplusplus_includes) = 1;
 	  break;
 	case OPT_std_gnu89:
-	  opts->cplusplus = 0, opts->cplusplus_comments = 1;
-	  opts->c89 = 1, opts->c99 = 0, opts->objc = 0;
+	  CPP_OPTION (pfile, cplusplus) = 0;
+	  CPP_OPTION (pfile, cplusplus_comments) = 1;
+	  CPP_OPTION (pfile, c89) = 1;
+	  CPP_OPTION (pfile, c99) = 0;
+	  CPP_OPTION (pfile, objc) = 0;
 	  break;
 	case OPT_std_gnu9x:
 	case OPT_std_gnu99:
-	  opts->cplusplus = 0, opts->cplusplus_comments = 1;
-	  opts->c89 = 0, opts->c99 = 1, opts->objc = 0;
-	  new_pending_directive (opts, "__STDC_VERSION__=199901L", cpp_define);
+	  CPP_OPTION (pfile, cplusplus) = 0;
+	  CPP_OPTION (pfile, cplusplus_comments) = 1;
+	  CPP_OPTION (pfile, c89) = 0;
+	  CPP_OPTION (pfile, c99) = 1;
+	  CPP_OPTION (pfile, objc) = 0;
+	  new_pending_directive (CPP_OPTION (pfile, pending),
+				 "__STDC_VERSION__=199901L", cpp_define);
 	  break;
 	case OPT_std_iso9899_199409:
-	  new_pending_directive (opts, "__STDC_VERSION__=199409L", cpp_define);
+	  new_pending_directive (CPP_OPTION (pfile, pending),
+				 "__STDC_VERSION__=199409L", cpp_define);
 	  /* Fall through */
 	case OPT_std_iso9899_1990:
 	case OPT_std_c89:
-	  opts->cplusplus = 0, opts->cplusplus_comments = 0;
-	  opts->c89 = 1, opts->c99 = 0, opts->objc = 0;
-	  opts->trigraphs = 1;
-	  new_pending_directive (opts, "__STRICT_ANSI__", cpp_define);
+	  CPP_OPTION (pfile, cplusplus) = 0;
+	  CPP_OPTION (pfile, cplusplus_comments) = 0;
+	  CPP_OPTION (pfile, c89) = 1;
+	  CPP_OPTION (pfile, c99) = 0;
+	  CPP_OPTION (pfile, objc) = 0;
+	  CPP_OPTION (pfile, trigraphs) = 1;
+	  new_pending_directive (CPP_OPTION (pfile, pending),
+				 "__STRICT_ANSI__", cpp_define);
 	  break;
 	case OPT_std_iso9899_199x:
 	case OPT_std_iso9899_1999:
 	case OPT_std_c9x:
 	case OPT_std_c99:
-	  opts->cplusplus = 0, opts->cplusplus_comments = 1;
-	  opts->c89 = 0, opts->c99 = 1, opts->objc = 0;
-	  opts->trigraphs = 1;
-	  new_pending_directive (opts, "__STRICT_ANSI__", cpp_define);
-	  new_pending_directive (opts, "__STDC_VERSION__=199901L", cpp_define);
+	  CPP_OPTION (pfile, cplusplus) = 0;
+	  CPP_OPTION (pfile, cplusplus_comments) = 1;
+	  CPP_OPTION (pfile, c89) = 0;
+	  CPP_OPTION (pfile, c99) = 1;
+	  CPP_OPTION (pfile, objc) = 0;
+	  CPP_OPTION (pfile, trigraphs) = 1;
+	  new_pending_directive (CPP_OPTION (pfile, pending),
+				 "__STRICT_ANSI__", cpp_define);
+	  new_pending_directive (CPP_OPTION (pfile, pending),
+				 "__STDC_VERSION__=199901L", cpp_define);
 	  break;
 	case OPT_o:
-	  if (opts->out_fname != NULL)
+	  if (CPP_OPTION (pfile, out_fname) != NULL)
 	    {
 	      cpp_fatal (pfile, "Output filename specified twice");
 	      return argc;
 	    }
-	  opts->out_fname = arg;
-	  if (!strcmp (opts->out_fname, "-"))
-	    opts->out_fname = "";
+	  CPP_OPTION (pfile, out_fname) = arg;
+	  if (!strcmp (CPP_OPTION (pfile, out_fname), "-"))
+	    CPP_OPTION (pfile, out_fname) = "";
 	  break;
 	case OPT_v:
 	  fprintf (stderr, _("GNU CPP version %s (cpplib)\n"), version_string);
@@ -1426,14 +1444,14 @@ handle_option (pfile, argc, argv)
 	  TARGET_VERSION;
 #endif
 	  fputc ('\n', stderr);
-	  opts->verbose = 1;
+	  CPP_OPTION (pfile, verbose) = 1;
 	  break;
 	case OPT_stdin_stdout:
 	  /* JF handle '-' as file name meaning stdin or stdout */
-	  if (opts->in_fname == NULL)
-	    opts->in_fname = "";
-	  else if (opts->out_fname == NULL)
-	    opts->out_fname = "";
+	  if (CPP_OPTION (pfile, in_fname) == NULL)
+	    CPP_OPTION (pfile, in_fname) = "";
+	  else if (CPP_OPTION (pfile, out_fname) == NULL)
+	    CPP_OPTION (pfile, out_fname) = "";
 	  break;
 	case OPT_d:
 	  /* Args to -d specify what parts of macros to dump.
@@ -1441,22 +1459,22 @@ handle_option (pfile, argc, argv)
 	     be aimed at the compiler proper. */
  	  {
 	    char c;
- 
+
 	    while ((c = *arg++) != '\0')
  	      switch (c)
  		{
  		case 'M':
-		  opts->dump_macros = dump_only;
-		  opts->no_output = 1;
+		  CPP_OPTION (pfile, dump_macros) = dump_only;
+		  CPP_OPTION (pfile, no_output) = 1;
 		  break;
 		case 'N':
-		  opts->dump_macros = dump_names;
+		  CPP_OPTION (pfile, dump_macros) = dump_names;
 		  break;
 		case 'D':
-		  opts->dump_macros = dump_definitions;
+		  CPP_OPTION (pfile, dump_macros) = dump_definitions;
 		  break;
 		case 'I':
-		  opts->dump_includes = 1;
+		  CPP_OPTION (pfile, dump_includes) = 1;
 		  break;
 		}
 	  }
@@ -1471,27 +1489,27 @@ handle_option (pfile, argc, argv)
 	  /* ??? -MG must be specified in addition to one of -M or -MM.
 	     This can be relaxed in the future without breaking anything.
 	     The converse isn't true.  */
-       
+
 	  /* -MG isn't valid with -MD or -MMD.  This is checked for later.  */
 	case OPT_MG:
-	  opts->print_deps_missing_files = 1;
+	  CPP_OPTION (pfile, print_deps_missing_files) = 1;
 	  break;
 	case OPT_M:
 	case OPT_MD:
 	case OPT_MM:
 	case OPT_MMD:
 	  if (opt_code == OPT_M || opt_code == OPT_MD)
-	    opts->print_deps = 2;
+	    CPP_OPTION (pfile, print_deps) = 2;
  	  else
-	    opts->print_deps = 1;
+	    CPP_OPTION (pfile, print_deps) = 1;
 
 	  /* For -MD and -MMD options, write deps on file named by next arg */
 	  /* For -M and -MM, write deps on standard output
 	     and suppress the usual output.  */
 	  if (opt_code == OPT_MD || opt_code == OPT_MMD)
-	      opts->deps_file = arg;
+	      CPP_OPTION (pfile, deps_file) = arg;
  	  else
-	      opts->no_output = 1;
+	      CPP_OPTION (pfile, no_output) = 1;
 	  break;
 	case OPT_A:
 	  if (arg[0] == '-')
@@ -1508,24 +1526,26 @@ handle_option (pfile, argc, argv)
 		{
 		  struct pending_option *o1, *o2;
 
-		  o1 = opts->pending->directive_head;
+		  o1 = CPP_OPTION (pfile, pending)->directive_head;
 		  while (o1)
 		    {
 		      o2 = o1->next;
 		      free (o1);
 		      o1 = o2;
 		    }
-		  opts->pending->directive_head = NULL;
-		  opts->pending->directive_tail = NULL;
+		  CPP_OPTION (pfile, pending)->directive_head = NULL;
+		  CPP_OPTION (pfile, pending)->directive_tail = NULL;
 		}
 	      else
-		new_pending_directive (opts, arg + 1, cpp_unassert);
+		new_pending_directive (CPP_OPTION (pfile, pending),
+				       arg + 1, cpp_unassert);
 	    }
 	  else
-	    new_pending_directive (opts, arg, cpp_assert);
+	    new_pending_directive (CPP_OPTION (pfile, pending),
+				   arg, cpp_assert);
 	  break;
 	case OPT_U:
-	  new_pending_directive (opts, arg, cpp_undef);
+	  new_pending_directive (CPP_OPTION (pfile, pending), arg, cpp_undef);
 	  break;
 	case OPT_I:           /* Add directory to path for includes.  */
 	  if (!strcmp (arg, "-"))
@@ -1536,13 +1556,14 @@ handle_option (pfile, argc, argv)
 		 Don't search the directory of the present file
 		 for #include "...".  (Note that -I. -I- is not the same as
 		 the default setup; -I. uses the compiler's working dir.)  */
-	      if (! opts->ignore_srcdir)
+	      if (! CPP_OPTION (pfile, ignore_srcdir))
 		{
-		  opts->ignore_srcdir = 1;
-		  opts->pending->quote_head = opts->pending->brack_head;
-		  opts->pending->quote_tail = opts->pending->brack_tail;
-		  opts->pending->brack_head = 0;
-		  opts->pending->brack_tail = 0;
+		  struct cpp_pending *pend = CPP_OPTION (pfile, pending);
+		  pend->quote_head = pend->brack_head;
+		  pend->quote_tail = pend->brack_tail;
+		  pend->brack_head = 0;
+		  pend->brack_tail = 0;
+		  CPP_OPTION (pfile, ignore_srcdir) = 1;
 		}
 	      else
 		{
@@ -1551,13 +1572,13 @@ handle_option (pfile, argc, argv)
 		}
  	    }
  	  else
-	    append_include_chain (pfile, opts->pending,
+	    append_include_chain (pfile, CPP_OPTION (pfile, pending),
 				  xstrdup (arg), BRACKET, 0);
 	  break;
 	case OPT_isystem:
 	  /* Add directory to beginning of system include path, as a system
 	     include directory. */
-	  append_include_chain (pfile, opts->pending,
+	  append_include_chain (pfile, CPP_OPTION (pfile, pending),
 				xstrdup (arg), SYSTEM, 0);
 	  break;
 	case OPT_include:
@@ -1569,8 +1590,8 @@ handle_option (pfile, argc, argv)
 	    /* This list has to be built in reverse order so that
 	       when cpp_start_read pushes all the -include files onto
 	       the buffer stack, they will be scanned in forward order.  */
-	    o->next = opts->pending->include_head;
-	    opts->pending->include_head = o;
+	    o->next = CPP_OPTION (pfile, pending)->include_head;
+	    CPP_OPTION (pfile, pending)->include_head = o;
 	  }
 	  break;
 	case OPT_imacros:
@@ -1579,8 +1600,8 @@ handle_option (pfile, argc, argv)
 	      xmalloc (sizeof (struct pending_option));
 	    o->arg = arg;
 	    o->next = NULL;
-	    
-	    APPEND (opts->pending, imacros, o);
+
+	    APPEND (CPP_OPTION (pfile, pending), imacros, o);
 	  }
 	  break;
 	case OPT_iwithprefix:
@@ -1593,14 +1614,15 @@ handle_option (pfile, argc, argv)
 	  {
 	    char *fname;
 	    int len;
-	    
+
 	    len = strlen (arg);
- 
-	    if (opts->include_prefix != 0)
+
+	    if (CPP_OPTION (pfile, include_prefix) != 0)
 	      {
-		fname = xmalloc (opts->include_prefix_len + len + 1);
-		memcpy (fname, opts->include_prefix, opts->include_prefix_len);
-		memcpy (fname + opts->include_prefix_len, arg, len + 1);
+		size_t ipl = CPP_OPTION (pfile, include_prefix_len);
+		fname = xmalloc (ipl + len + 1);
+		memcpy (fname, CPP_OPTION (pfile, include_prefix), ipl);
+		memcpy (fname + ipl, arg, len + 1);
 	      }
 	    else
 	      {
@@ -1608,51 +1630,51 @@ handle_option (pfile, argc, argv)
 		memcpy (fname, GCC_INCLUDE_DIR, sizeof GCC_INCLUDE_DIR - 9);
 		memcpy (fname + sizeof GCC_INCLUDE_DIR - 9, arg, len + 1);
 	      }
-	    
-	    append_include_chain (pfile, opts->pending, fname, 
+
+	    append_include_chain (pfile, CPP_OPTION (pfile, pending), fname,
 			  opt_code == OPT_iwithprefix ? SYSTEM: BRACKET, 0);
 	  }
 	  break;
 	case OPT_idirafter:
 	  /* Add directory to end of path for includes.  */
-	  append_include_chain (pfile, opts->pending,
+	  append_include_chain (pfile, CPP_OPTION (pfile, pending),
 				xstrdup (arg), AFTER, 0);
 	  break;
 	case OPT_W:
 	  /* Silently ignore unrecognised options */
 	  if (!strcmp (argv[i], "-Wall"))
 	    {
-	      opts->warn_trigraphs = 1;
-	      opts->warn_comments = 1;
+	      CPP_OPTION (pfile, warn_trigraphs) = 1;
+	      CPP_OPTION (pfile, warn_comments) = 1;
 	    }
 	  else if (!strcmp (argv[i], "-Wtraditional"))
-	    opts->warn_stringify = 1;
+	    CPP_OPTION (pfile, warn_stringify) = 1;
 	  else if (!strcmp (argv[i], "-Wtrigraphs"))
-	    opts->warn_trigraphs = 1;
+	    CPP_OPTION (pfile, warn_trigraphs) = 1;
 	  else if (!strcmp (argv[i], "-Wcomment"))
-	    opts->warn_comments = 1;
+	    CPP_OPTION (pfile, warn_comments) = 1;
 	  else if (!strcmp (argv[i], "-Wcomments"))
-	    opts->warn_comments = 1;
+	    CPP_OPTION (pfile, warn_comments) = 1;
 	  else if (!strcmp (argv[i], "-Wundef"))
-	    opts->warn_undef = 1;
+	    CPP_OPTION (pfile, warn_undef) = 1;
 	  else if (!strcmp (argv[i], "-Wimport"))
-	    opts->warn_import = 1;
+	    CPP_OPTION (pfile, warn_import) = 1;
 	  else if (!strcmp (argv[i], "-Werror"))
-	    opts->warnings_are_errors = 1;
+	    CPP_OPTION (pfile, warnings_are_errors) = 1;
 	  else if (!strcmp (argv[i], "-Wno-traditional"))
-	    opts->warn_stringify = 0;
+	    CPP_OPTION (pfile, warn_stringify) = 0;
 	  else if (!strcmp (argv[i], "-Wno-trigraphs"))
-	    opts->warn_trigraphs = 0;
+	    CPP_OPTION (pfile, warn_trigraphs) = 0;
 	  else if (!strcmp (argv[i], "-Wno-comment"))
-	    opts->warn_comments = 0;
+	    CPP_OPTION (pfile, warn_comments) = 0;
 	  else if (!strcmp (argv[i], "-Wno-comments"))
-	    opts->warn_comments = 0;
+	    CPP_OPTION (pfile, warn_comments) = 0;
 	  else if (!strcmp (argv[i], "-Wno-undef"))
-	    opts->warn_undef = 0;
+	    CPP_OPTION (pfile, warn_undef) = 0;
 	  else if (!strcmp (argv[i], "-Wno-import"))
-	    opts->warn_import = 0;
+	    CPP_OPTION (pfile, warn_import) = 0;
 	  else if (!strcmp (argv[i], "-Wno-error"))
-	    opts->warnings_are_errors = 0;
+	    CPP_OPTION (pfile, warnings_are_errors) = 0;
 	  break;
  	}
     }

gcc/cpplex.c

@@ -119,7 +119,7 @@ cpp_scan_buffer (pfile)
 {
   cpp_buffer *buffer = CPP_BUFFER (pfile);
   enum cpp_token token;
-  if (CPP_OPTIONS (pfile)->no_output)
+  if (CPP_OPTION (pfile, no_output))
     {
       long old_written = CPP_WRITTEN (pfile);
       /* In no-output mode, we can ignore everything but directives.  */
@@ -193,12 +193,12 @@ cpp_expand_to_buffer (pfile, buf, length)
   ip->has_escapes = 1;
 
   /* Scan the input, create the output.  */
-  save_no_output = CPP_OPTIONS (pfile)->no_output;
-  CPP_OPTIONS (pfile)->no_output = 0;
-  CPP_OPTIONS (pfile)->no_line_commands++;
+  save_no_output = CPP_OPTION (pfile, no_output);
+  CPP_OPTION (pfile, no_output) = 0;
+  CPP_OPTION (pfile, no_line_commands)++;
   cpp_scan_buffer (pfile);
-  CPP_OPTIONS (pfile)->no_line_commands--;
-  CPP_OPTIONS (pfile)->no_output = save_no_output;
+  CPP_OPTION (pfile, no_line_commands)--;
+  CPP_OPTION (pfile, no_output) = save_no_output;
 
   CPP_NUL_TERMINATE (pfile);
 }
@@ -264,7 +264,7 @@ skip_block_comment (pfile)
       else if (c == '/' && prev_c == '*')
 	return;
       else if (c == '*' && prev_c == '/'
-	       && CPP_OPTIONS (pfile)->warn_comments)
+	       && CPP_OPTION (pfile, warn_comments))
 	cpp_warning (pfile, "`/*' within comment");
 
       prev_c = c;
@@ -294,7 +294,7 @@ skip_line_comment (pfile)
 	  /* \r cannot be a macro escape marker here. */
 	  if (!ACTIVE_MARK_P (pfile))
 	    CPP_BUMP_LINE (pfile);
-	  if (CPP_OPTIONS (pfile)->warn_comments)
+	  if (CPP_OPTION (pfile, warn_comments))
 	    cpp_warning (pfile, "backslash-newline within line comment");
 	}
     }
@@ -325,9 +325,9 @@ skip_comment (pfile, m)
 	  skip_line_comment (pfile);
 	  return ' ';
 	}
-      else if (CPP_OPTIONS (pfile)->cplusplus_comments)
+      else if (CPP_OPTION (pfile, cplusplus_comments))
 	{
-	  if (CPP_OPTIONS (pfile)->c89
+	  if (CPP_OPTION (pfile, c89)
 	      && CPP_PEDANTIC (pfile)
 	      && ! CPP_BUFFER (pfile)->warned_cplusplus_comments)
 	    {
@@ -344,7 +344,7 @@ skip_comment (pfile, m)
 	return m;
     }
   else if (m == '-' && PEEKC() == '-'
-	   && CPP_OPTIONS (pfile)->chill)
+	   && CPP_OPTION (pfile, chill))
     {
       skip_line_comment (pfile);
       return ' ';
@@ -524,8 +524,8 @@ skip_string (pfile, c)
 	     strings of either variety at end of line.  This is a
 	     kludge around not knowing where comments are in these
 	     languages.  */
-	  if (CPP_OPTIONS (pfile)->lang_fortran
-	      || CPP_OPTIONS (pfile)->lang_asm)
+	  if (CPP_OPTION (pfile, lang_fortran)
+	      || CPP_OPTION (pfile, lang_asm))
 	    {
 	      FORWARD(-1);
 	      return;
@@ -675,7 +675,6 @@ _cpp_lex_token (pfile)
 {
   register int c, c2, c3;
   enum cpp_token token;
-  struct cpp_options *opts = CPP_OPTIONS (pfile);
 
  get_next:
   c = GETC();
@@ -689,7 +688,7 @@ _cpp_lex_token (pfile)
 	goto op2;
 
     comment:
-      if (opts->discard_comments)
+      if (CPP_OPTION (pfile, discard_comments))
 	c = skip_comment (pfile, c);
       else
 	c = copy_comment (pfile, c);
@@ -698,7 +697,7 @@ _cpp_lex_token (pfile)
 	  
       /* Comments are equivalent to spaces.
 	 For -traditional, a comment is equivalent to nothing.  */
-      if (opts->traditional || !opts->discard_comments)
+      if (CPP_TRADITIONAL (pfile) || !CPP_OPTION (pfile, discard_comments))
 	return CPP_COMMENT;
       else
 	{
@@ -745,12 +744,12 @@ _cpp_lex_token (pfile)
       return c == '\'' ? CPP_CHAR : CPP_STRING;
 
     case '$':
-      if (!opts->dollars_in_ident)
+      if (!CPP_OPTION (pfile, dollars_in_ident))
 	goto randomchar;
       goto letter;
 
     case ':':
-      if (opts->cplusplus && PEEKC () == ':')
+      if (CPP_OPTION (pfile, cplusplus) && PEEKC () == ':')
 	goto op2;
       goto randomchar;
 
@@ -775,7 +774,7 @@ _cpp_lex_token (pfile)
       c2 = PEEKC ();
       if (c2 == '-')
 	{
-	  if (opts->chill)
+	  if (CPP_OPTION (pfile, chill))
 	    goto comment;  /* Chill style comment */
 	  else
 	    goto op2;
@@ -784,7 +783,7 @@ _cpp_lex_token (pfile)
 	goto op2;
       else if (c2 == '>')
 	{
-	  if (opts->cplusplus && PEEKN (1) == '*')
+	  if (CPP_OPTION (pfile, cplusplus) && PEEKN (1) == '*')
 	    {
 	      /* In C++, there's a ->* operator.  */
 	      token = CPP_OTHER;
@@ -842,7 +841,7 @@ _cpp_lex_token (pfile)
       if (c2 == '=')
 	goto op2;
       /* GNU C++ supports MIN and MAX operators <? and >?.  */
-      if (c2 != c && (!opts->cplusplus || c2 != '?'))
+      if (c2 != c && (!CPP_OPTION (pfile, cplusplus) || c2 != '?'))
 	goto randomchar;
       FORWARD(1);
       CPP_RESERVE (pfile, 4);
@@ -866,7 +865,7 @@ _cpp_lex_token (pfile)
 	}
 
       /* In C++ there's a .* operator.  */
-      if (opts->cplusplus && c2 == '*')
+      if (CPP_OPTION (pfile, cplusplus) && c2 == '*')
 	goto op2;
 
       if (c2 == '.' && PEEKN(1) == '.')
@@ -917,7 +916,7 @@ _cpp_lex_token (pfile)
 	if (!is_numchar(c) && c != '.'
 	    && ((c2 != 'e' && c2 != 'E'
 		 && ((c2 != 'p' && c2 != 'P')
-		     || CPP_OPTIONS (pfile)->c89))
+		     || CPP_OPTION (pfile, c89)))
 		|| (c != '+' && c != '-')))
 	  break;
 	FORWARD(1);
@@ -928,7 +927,7 @@ _cpp_lex_token (pfile)
     return CPP_NUMBER;
     case 'b': case 'c': case 'd': case 'h': case 'o':
     case 'B': case 'C': case 'D': case 'H': case 'O':
-      if (opts->chill && PEEKC () == '\'')
+      if (CPP_OPTION (pfile, chill) && PEEKC () == '\'')
 	{
 	  pfile->only_seen_white = 0;
 	  CPP_RESERVE (pfile, 2);
@@ -1023,7 +1022,7 @@ _cpp_lex_token (pfile)
       if (pfile->only_seen_white == 0)
 	pfile->only_seen_white = 1;
       CPP_BUMP_LINE (pfile);
-      if (! CPP_OPTIONS (pfile)->no_line_commands)
+      if (! CPP_OPTION (pfile, no_line_commands))
 	{
 	  pfile->lineno++;
 	  if (CPP_BUFFER (pfile)->lineno != pfile->lineno)
@@ -1466,12 +1465,12 @@ _cpp_read_and_prescan (pfile, fp, desc, len)
 		if (t == 0)
 		  break;
 
-		if (CPP_OPTIONS (pfile)->warn_trigraphs)
+		if (CPP_OPTION (pfile, warn_trigraphs))
 		  {
 		    unsigned long col;
 		    line_base = find_position (line_base, op, &line);
 		    col = op - line_base + 1;
-		    if (CPP_OPTIONS (pfile)->trigraphs)
+		    if (CPP_OPTION (pfile, trigraphs))
 		      cpp_warning_with_line (pfile, line, col,
 					     "trigraph ??%c converted to %c", d, t);
 		    else
@@ -1480,7 +1479,7 @@ _cpp_read_and_prescan (pfile, fp, desc, len)
 		  }
 
 		ip += 2;
-		if (CPP_OPTIONS (pfile)->trigraphs)
+		if (CPP_OPTION (pfile, trigraphs))
 		  {
 		    op[-1] = t;	    /* Overwrite '?' */
 		    if (t == '\\')
@@ -1554,7 +1553,7 @@ _cpp_init_input_buffer (pfile)
   memset (tmp, SPECCASE_EMPTY, 1 << CHAR_BIT);
   tmp['\r'] = SPECCASE_CR;
   tmp['\\'] = SPECCASE_BACKSLASH;
-  if (CPP_OPTIONS (pfile)->trigraphs || CPP_OPTIONS (pfile)->warn_trigraphs)
+  if (CPP_OPTION (pfile, trigraphs) || CPP_OPTION (pfile, warn_trigraphs))
     tmp['?'] = SPECCASE_QUESTION;
   pfile->input_speccase = tmp;
 

gcc/cpplib.c

@@ -157,11 +157,11 @@ _cpp_handle_directive (pfile)
      input (preprocessed or fed back in by the C++ frontend).  */
   if (c >= '0' && c <= '9')
     {
-      if (CPP_OPTIONS (pfile)->lang_asm)
+      if (CPP_OPTION (pfile, lang_asm))
 	return 0;
 
       if (CPP_PEDANTIC (pfile)
-	  && ! CPP_OPTIONS (pfile)->preprocessed
+	  && ! CPP_OPTION (pfile, preprocessed)
 	  && ! CPP_BUFFER (pfile)->manual_pop)
 	cpp_pedwarn (pfile, "`#' followed by integer");
       do_line (pfile);
@@ -170,7 +170,7 @@ _cpp_handle_directive (pfile)
 
   /* If we are rescanning preprocessed input, don't obey any directives
      other than # nnn.  */
-  if (CPP_OPTIONS (pfile)->preprocessed)
+  if (CPP_OPTION (pfile, preprocessed))
     return 0;
 
   /* Now find the directive name.  */
@@ -320,7 +320,7 @@ do_define (pfile)
 	ok = ! _cpp_compare_defs (pfile, def, hp->value.defn);
       /* Redefining a constant is ok with -D.  */
       else if (hp->type == T_CONST || hp->type == T_STDC)
-        ok = ! CPP_OPTIONS (pfile)->done_initializing;
+        ok = ! pfile->done_initializing;
       /* Otherwise it's not ok.  */
       else
 	ok = 0;
@@ -331,7 +331,7 @@ do_define (pfile)
 	    cpp_error (pfile, "redefining poisoned `%.*s'", len, sym);
 	  else
 	    cpp_pedwarn (pfile, "`%.*s' redefined", len, sym);
-	  if (hp->type == T_MACRO && CPP_OPTIONS (pfile)->done_initializing)
+	  if (hp->type == T_MACRO && pfile->done_initializing)
 	    {
 	      DEFINITION *d = hp->value.defn;
 	      cpp_pedwarn_with_file_and_line (pfile, d->file, d->line, d->col,
@@ -354,10 +354,10 @@ do_define (pfile)
       *slot = hp;
     }
 
-  if (CPP_OPTIONS (pfile)->debug_output
-      || CPP_OPTIONS (pfile)->dump_macros == dump_definitions)
+  if (CPP_OPTION (pfile, debug_output)
+      || CPP_OPTION (pfile, dump_macros) == dump_definitions)
     _cpp_dump_definition (pfile, sym, len, def);
-  else if (CPP_OPTIONS (pfile)->dump_macros == dump_names)
+  else if (CPP_OPTION (pfile, dump_macros) == dump_names)
     pass_thru_directive (sym, len, pfile, T_DEFINE);
 
   return 0;
@@ -376,8 +376,8 @@ _cpp_output_line_command (pfile, file_change)
   long line;
   cpp_buffer *ip;
 
-  if (CPP_OPTIONS (pfile)->no_line_commands
-      || CPP_OPTIONS (pfile)->no_output)
+  if (CPP_OPTION (pfile, no_line_commands)
+      || CPP_OPTION (pfile, no_output))
     return;
 
   ip = cpp_file_buffer (pfile);
@@ -428,7 +428,7 @@ _cpp_output_line_command (pfile, file_change)
     }
 #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_OPTION (pfile, cplusplus))
     {
       CPP_PUTC_Q (pfile, ' ');
       CPP_PUTC_Q (pfile, '4');
@@ -513,7 +513,7 @@ do_include (pfile)
   token = alloca (len + 1);
   strcpy (token, CPP_PWRITTEN (pfile));
   
-  if (CPP_OPTIONS (pfile)->dump_includes)
+  if (CPP_OPTION (pfile, dump_includes))
     pass_thru_directive (token, len, pfile, T_INCLUDE);
 
   _cpp_execute_include (pfile, token, len, 0, 0);
@@ -530,7 +530,7 @@ do_import (pfile)
   if (CPP_PEDANTIC (pfile))
     cpp_pedwarn (pfile, "ANSI C does not allow `#import'");
 
-  if (CPP_OPTIONS (pfile)->warn_import
+  if (CPP_OPTION (pfile, warn_import)
       && !CPP_BUFFER (pfile)->system_header_p && !pfile->import_warning)
     {
       pfile->import_warning = 1;
@@ -544,7 +544,7 @@ do_import (pfile)
   token = alloca (len + 1);
   strcpy (token, CPP_PWRITTEN (pfile));
   
-  if (CPP_OPTIONS (pfile)->dump_includes)
+  if (CPP_OPTION (pfile, dump_includes))
     pass_thru_directive (token, len, pfile, T_IMPORT);
 
   _cpp_execute_include (pfile, token, len, 1, 0);
@@ -568,7 +568,7 @@ do_include_next (pfile)
   token = alloca (len + 1);
   strcpy (token, CPP_PWRITTEN (pfile));
   
-  if (CPP_OPTIONS (pfile)->dump_includes)
+  if (CPP_OPTION (pfile, dump_includes))
     pass_thru_directive (token, len, pfile, T_INCLUDE_NEXT);
 
   /* For #include_next, skip in the search path past the dir in which the
@@ -782,7 +782,7 @@ do_undef (pfile)
       HASHNODE *hp = *slot;
       /* If we are generating additional info for debugging (with -g) we
 	 need to pass through all effective #undef commands.  */
-      if (CPP_OPTIONS (pfile)->debug_output)
+      if (CPP_OPTION (pfile, debug_output))
 	pass_thru_directive (name, len, pfile, T_UNDEF);
       if (hp->type == T_POISON)
 	cpp_error (pfile, "cannot undefine poisoned `%s'", hp->name);
@@ -1021,9 +1021,9 @@ do_pragma_poison (pfile)
 
   /* As a rule, don't include #pragma poison commands in output,  
      unless the user asks for them.  */
-  writeit = (CPP_OPTIONS (pfile)->debug_output
-	     || CPP_OPTIONS (pfile)->dump_macros == dump_definitions
-	     || CPP_OPTIONS (pfile)->dump_macros == dump_names);
+  writeit = (CPP_OPTION (pfile, debug_output)
+	     || CPP_OPTION (pfile, dump_macros) == dump_definitions
+	     || CPP_OPTION (pfile, dump_macros) == dump_names);
 
   for (;;)
     {
@@ -1399,7 +1399,7 @@ consider_directive_while_skipping (pfile, stack)
     }
 
     /* Don't let erroneous code go by.	*/
-    if (!CPP_OPTIONS (pfile)->lang_asm && CPP_PEDANTIC (pfile))
+    if (!CPP_OPTION (pfile, lang_asm) && CPP_PEDANTIC (pfile))
 	cpp_pedwarn (pfile, "invalid preprocessor directive name");
     return 0;
 }
@@ -1612,7 +1612,7 @@ do_assert (pfile)
   size_t blen, tlen;
   unsigned long bhash, thash;
 
-  if (CPP_PEDANTIC (pfile) && CPP_OPTIONS (pfile)->done_initializing)
+  if (CPP_PEDANTIC (pfile) && pfile->done_initializing)
     cpp_pedwarn (pfile, "ANSI C does not allow `#assert'");
 
   _cpp_skip_hspace (pfile);
@@ -1678,7 +1678,7 @@ do_unassert (pfile)
   long baselen, thislen;
   HASHNODE *base, *this, *next;
   
-  if (CPP_PEDANTIC (pfile) && CPP_OPTIONS (pfile)->done_initializing)
+  if (CPP_PEDANTIC (pfile) && pfile->done_initializing)
     cpp_pedwarn (pfile, "ANSI C does not allow `#unassert'");
 
   _cpp_skip_hspace (pfile);

gcc/cpplib.h

@@ -128,306 +128,294 @@ struct htab;
    efficiency, and partly to limit runaway recursion.  */
 #define CPP_STACK_MAX 200
 
-/* A cpp_reader encapsulates the "state" of a pre-processor run.
-   Applying cpp_get_token repeatedly yields a stream of pre-processor
-   tokens.  Usually, there is only one cpp_reader object active. */
+/* Values for opts.dump_macros.
+  dump_only means inhibit output of the preprocessed text
+             and instead output the definitions of all user-defined
+             macros in a form suitable for use as input to cccp.
+   dump_names means pass #define and the macro name through to output.
+   dump_definitions means pass the whole definition (plus #define) through
+*/
+enum { dump_none = 0, dump_only, dump_names, dump_definitions };
 
-struct cpp_reader
+/* This structure is nested inside struct cpp_reader, and
+   carries all the options visible to the command line.  */
+struct cpp_options
 {
-  cpp_buffer *buffer;
-  cpp_options *opts;
-
-  /* A buffer used for both for cpp_get_token's output, and also internally. */
-  unsigned char *token_buffer;
-  /* Allocated size of token_buffer.  CPP_RESERVE allocates space.  */
-  unsigned int token_buffer_size;
-  /* End of the written part of token_buffer. */
-  unsigned char *limit;
-
-  /* Error counter for exit code */
-  int errors;
-
-  /* Line where a newline was first seen in a string constant.  */
-  int multiline_string_line;
-
-  /* Current depth in #include directives that use <...>.  */
-  int system_include_depth;
-
-  /* Current depth of buffer stack. */
-  int buffer_stack_depth;
-
-  /* Hash table of macros and assertions.  See cpphash.c */
-  struct htab *hashtab;
-
-  /* Hash table of other included files.  See cppfiles.c */
-  struct htab *all_include_files;
-
-  /* Chain of `actual directory' file_name_list entries,
-     for "" inclusion. */
-  struct file_name_list *actual_dirs;
-
-  /* Current maximum length of directory names in the search path
-     for include files.  (Altered as we get more of them.)  */
-  unsigned int max_include_len;
-
-  struct if_stack *if_stack;
-
-  /* Nonzero means we have printed (while error reporting) a list of
-     containing files that matches the current status.  */
-  char input_stack_listing_current;
-
-  /* If non-zero, macros are not expanded.  */
-  char no_macro_expand;
-
-  /* If non-zero, directives cause a hard error.  Used when parsing
-     macro arguments.  */
-  char no_directives;
-
-  /* Print column number in error messages.  */
-  char show_column;
-
-  /* We're printed a warning recommending against using #import.  */
-  char import_warning;
-
-  /* If true, character between '<' and '>' are a single (string) token.  */
-  char parsing_include_directive;
-
-  /* If true, # introduces an assertion (see do_assert) */
-  char parsing_if_directive;
-
-  /* If true, # and ## are the STRINGIZE and TOKPASTE operators */
-  char parsing_define_directive;
-
-  /* True if escape sequences (as described for has_escapes in
-     parse_buffer) should be emitted.  */
-  char output_escapes;
-
-  /* 0: Have seen non-white-space on this line.
-     1: Only seen white space so far on this line.
-     2: Only seen white space so far in this file.  */
-  char only_seen_white;
-
-  long lineno;
-
-  struct tm *timebuf;
-
-  /* Buffer of -M output.  */
-  struct deps *deps;
-
-  /* A buffer and a table, used only by read_and_prescan (in cppfiles.c)
-     which are allocated once per cpp_reader object to keep them off the
-     stack and avoid setup costs.  */
-  unsigned char *input_buffer;
-  unsigned char *input_speccase;
-  size_t input_buffer_len;
-};
-
-#define CPP_FATAL_LIMIT 1000
-/* True if we have seen a "fatal" error. */
-#define CPP_FATAL_ERRORS(READER) ((READER)->errors >= CPP_FATAL_LIMIT)
-
-/* Macros for manipulating the token_buffer. */
+  /* Name of input and output files.  */
+  const char *in_fname;
+  const char *out_fname;
 
-/* Number of characters currently in PFILE's output buffer. */
-#define CPP_WRITTEN(PFILE) ((size_t)((PFILE)->limit - (PFILE)->token_buffer))
-#define CPP_PWRITTEN(PFILE) ((PFILE)->limit)
-#define CPP_ADJUST_WRITTEN(PFILE,DELTA) ((PFILE)->limit += (DELTA))
-#define CPP_SET_WRITTEN(PFILE,N) ((PFILE)->limit = (PFILE)->token_buffer + (N))
+  /* Pending options - -D, -U, -A, -I, -ixxx. */
+  struct cpp_pending *pending;
 
-#define CPP_OPTIONS(PFILE) ((PFILE)->opts)
-#define CPP_BUFFER(PFILE) ((PFILE)->buffer)
+  /* File name which deps are being written to.  This is 0 if deps are
+     being written to stdout.  */
+  const char *deps_file;
 
-/* Pointed to by cpp_reader.opts. */
-struct cpp_options
-{
-  const char *in_fname;
+  /* Target-name to write with the dependency information.  */
+  char *deps_target;
 
-  /* Name of output file, for error messages.  */
-  const char *out_fname;
+  /* Search paths for include files.  */
+  struct file_name_list *quote_include;	 /* First dir to search for "file" */
+  struct file_name_list *bracket_include;/* First dir to search for <file> */
 
+  /* Map between header names and file names, used only on DOS where
+     file names are limited in length.  */
   struct file_name_map_list *map_list;
 
+  /* Directory prefix that should replace `/usr/lib/gcc-lib/TARGET/VERSION'
+     in the standard include file directories.  */
+  const char *include_prefix;
+  unsigned int include_prefix_len;
+
   /* Non-0 means -v, so print the full set of include dirs.  */
-  char verbose;
+  unsigned char verbose;
 
   /* Nonzero means use extra default include directories for C++.  */
-
-  char cplusplus;
+  unsigned char cplusplus;
 
   /* Nonzero means handle cplusplus style comments */
-
-  char cplusplus_comments;
+  unsigned char cplusplus_comments;
 
   /* Nonzero means handle #import, for objective C.  */
-
-  char objc;
+  unsigned char objc;
 
   /* Nonzero means this is an assembly file, so ignore unrecognized
      directives and the "# 33" form of #line, both of which are
      probably comments.  Also, permit unbalanced ' strings (again,
      likely to be in comments).  */
-
-  char lang_asm;
+  unsigned char lang_asm;
 
   /* Nonzero means this is Fortran, and we don't know where the
      comments are, so permit unbalanced ' strings.  Unlike lang_asm,
      this does not ignore unrecognized directives.  */
+  unsigned char lang_fortran;
 
-  char lang_fortran;
-
-  /* Nonzero means handle CHILL comment syntax
-     and output CHILL string delimiter for __DATE___ etc. */
-
-  char chill;
+  /* Nonzero means handle CHILL comment syntax and output CHILL string
+     delimiters for __DATE__ etc. */
+  unsigned char chill;
 
   /* Nonzero means don't copy comments into the output file.  */
-
-  char discard_comments;
+  unsigned char discard_comments;
 
   /* Nonzero means process the ANSI trigraph sequences.  */
+  unsigned char trigraphs;
 
-  char trigraphs;
+  /* Nonzero means print the names of included files rather than the
+     preprocessed output.  1 means just the #include "...", 2 means
+     #include <...> as well.  */
+  unsigned char print_deps;
 
-  /* Nonzero means print the names of included files rather than
-     the preprocessed output.  1 means just the #include "...",
-     2 means #include <...> as well.  */
-
-  char print_deps;
-
-  /* Nonzero if missing .h files in -M output are assumed to be generated
-     files and not errors.  */
-
-  char print_deps_missing_files;
+  /* Nonzero if missing .h files in -M output are assumed to be
+     generated files and not errors.  */
+  unsigned char print_deps_missing_files;
 
   /* If true, fopen (deps_file, "a") else fopen (deps_file, "w"). */
-  char print_deps_append;
+  unsigned char print_deps_append;
 
   /* Nonzero means print names of header files (-H).  */
+  unsigned char print_include_names;
 
-  char print_include_names;
-
-  /* Nonzero means try to make failure to fit ANSI C an error.  */
-
-  char pedantic_errors;
+  /* Nonzero means cpp_pedwarn causes a hard error.  */
+  unsigned char pedantic_errors;
 
   /* Nonzero means don't print warning messages.  */
+  unsigned char inhibit_warnings;
 
-  char inhibit_warnings;
-
-  /* Nonzero means don't print error messages.  Has no option to select it,
-     but can be set by a user of cpplib (e.g. fix-header).  */
-
-  char inhibit_errors;
+  /* Nonzero means don't print error messages.  Has no option to
+     select it, but can be set by a user of cpplib (e.g. fix-header).  */
+  unsigned char inhibit_errors;
 
   /* Nonzero means warn if slash-star appears in a comment.  */
-
-  char warn_comments;
+  unsigned char warn_comments;
 
   /* Nonzero means warn if there are any trigraphs.  */
-
-  char warn_trigraphs;
+  unsigned char warn_trigraphs;
 
   /* Nonzero means warn if #import is used.  */
-
-  char warn_import;
+  unsigned char warn_import;
 
   /* Nonzero means warn if a macro argument is (or would be)
      stringified with -traditional.  */
-
-  char warn_stringify;
+  unsigned char warn_stringify;
 
   /* Nonzero means turn warnings into errors.  */
+  unsigned char warnings_are_errors;
 
-  char warnings_are_errors;
-
-  /* Nonzero causes output not to be done,
-     but directives such as #define that have side effects
-     are still obeyed.  */
-
-  char no_output;
+  /* Nonzero causes output not to be done, but directives such as
+     #define that have side effects are still obeyed.  */
+  unsigned char no_output;
 
   /* Nonzero means we should look for header.gcc files that remap file
      names.  */
-  char remap;
+  unsigned char remap;
 
   /* Nonzero means don't output line number information.  */
-  char no_line_commands;
+  unsigned char no_line_commands;
 
-  /* Nonzero means -I- has been seen,
-     so don't look for #include "foo" the source-file directory.  */
-  char ignore_srcdir;
+  /* Nonzero means -I- has been seen, so don't look for #include "foo"
+     the source-file directory.  */
+  unsigned char ignore_srcdir;
 
-  /* Zero means dollar signs are punctuation.
-     This used to be needed for conformance to the C Standard,
-     before the C Standard was corrected.  */
-  char dollars_in_ident;
+  /* Zero means dollar signs are punctuation. */
+  unsigned char dollars_in_ident;
 
   /* Nonzero means try to imitate old fashioned non-ANSI preprocessor.  */
-  char traditional;
+  unsigned char traditional;
 
   /* Nonzero means warn if undefined identifiers are evaluated in an #if.  */
-  char warn_undef;
+  unsigned char warn_undef;
 
   /* Nonzero for the 1989 C Standard, including corrigenda and amendments.  */
-  char c89;
+  unsigned char c89;
 
   /* Nonzero for the 1999 C Standard, including corrigenda and amendments.  */
-  char c99;
+  unsigned char c99;
 
   /* Nonzero means give all the error messages the ANSI standard requires.  */
-  char pedantic;
+  unsigned char pedantic;
 
   /* Nonzero means we're looking at already preprocessed code, so don't
      bother trying to do macro expansion and whatnot.  */
-  char preprocessed;
+  unsigned char preprocessed;
 
-  char done_initializing;
+  /* Nonzero disables all the standard directories for headers.  */
+  unsigned char no_standard_includes;
 
-  /* Search paths for include files.  */
-  struct file_name_list *quote_include;	 /* First dir to search for "file" */
-  struct file_name_list *bracket_include;/* First dir to search for <file> */
+  /* Nonzero disables the C++-specific standard directories for headers.  */
+  unsigned char no_standard_cplusplus_includes;
 
-  /* Directory prefix that should replace `/usr/lib/gcc-lib/TARGET/VERSION'
-     in the standard include file directories.  */
-  const char *include_prefix;
-  int include_prefix_len;
+  /* Nonzero means dump macros in some fashion - see above.  */
+  unsigned char dump_macros;
 
-  char no_standard_includes;
-  char no_standard_cplusplus_includes;
+  /* Nonzero means pass all #define and #undef directives which we
+     actually process through to the output stream.  This feature is
+     used primarily to allow cc1 to record the #defines and #undefs
+     for the sake of debuggers which understand about preprocessor
+     macros, but it may also be useful with -E to figure out how
+     symbols are defined, and where they are defined.  */
+  unsigned char debug_output;
 
-/* dump_only means inhibit output of the preprocessed text
-             and instead output the definitions of all user-defined
-             macros in a form suitable for use as input to cccp.
-   dump_names means pass #define and the macro name through to output.
-   dump_definitions means pass the whole definition (plus #define) through
-*/
+  /* Nonzero means pass #include lines through to the output.  */
+  unsigned char dump_includes;
 
-  enum {dump_none = 0, dump_only, dump_names, dump_definitions}
-     dump_macros;
+  /* Print column number in error messages.  */
+  unsigned char show_column;
+};
 
-/* Nonzero means pass all #define and #undef directives which we actually
-   process through to the output stream.  This feature is used primarily
-   to allow cc1 to record the #defines and #undefs for the sake of
-   debuggers which understand about preprocessor macros, but it may
-   also be useful with -E to figure out how symbols are defined, and
-   where they are defined.  */
-  int debug_output;
 
-  /* Nonzero means pass #include lines through to the output,
-     even if they are ifdefed out.  */
-  int dump_includes;
+/* A cpp_reader encapsulates the "state" of a pre-processor run.
+   Applying cpp_get_token repeatedly yields a stream of pre-processor
+   tokens.  Usually, there is only one cpp_reader object active. */
 
-  /* Pending options - -D, -U, -A, -I, -ixxx. */
-  struct cpp_pending *pending;
+struct cpp_reader
+{
+  cpp_buffer *buffer;
 
-  /* File name which deps are being written to.
-     This is 0 if deps are being written to stdout.  */
-  const char *deps_file;
+  /* A buffer used for both for cpp_get_token's output, and also internally. */
+  unsigned char *token_buffer;
+  /* Allocated size of token_buffer.  CPP_RESERVE allocates space.  */
+  unsigned int token_buffer_size;
+  /* End of the written part of token_buffer. */
+  unsigned char *limit;
 
-  /* Target-name to write with the dependency information.  */
-  char *deps_target;
+  /* Error counter for exit code */
+  int errors;
+
+  /* Line where a newline was first seen in a string constant.  */
+  int multiline_string_line;
+
+  /* Current depth in #include directives that use <...>.  */
+  int system_include_depth;
+
+  /* Current depth of buffer stack. */
+  int buffer_stack_depth;
+
+  /* Hash table of macros and assertions.  See cpphash.c */
+  struct htab *hashtab;
+
+  /* Hash table of other included files.  See cppfiles.c */
+  struct htab *all_include_files;
+
+  /* Chain of `actual directory' file_name_list entries,
+     for "" inclusion. */
+  struct file_name_list *actual_dirs;
+
+  /* Current maximum length of directory names in the search path
+     for include files.  (Altered as we get more of them.)  */
+  unsigned int max_include_len;
+
+  struct if_stack *if_stack;
+
+  long lineno;
+
+  struct tm *timebuf;
+
+  /* Buffer of -M output.  */
+  struct deps *deps;
+
+  /* A buffer and a table, used only by read_and_prescan (in cppfiles.c)
+     which are allocated once per cpp_reader object to keep them off the
+     stack and avoid setup costs.  */
+  unsigned char *input_buffer;
+  unsigned char *input_speccase;
+  size_t input_buffer_len;
+
+  /* User visible options.  */
+  struct cpp_options opts;
+
+  /* Nonzero means we have printed (while error reporting) a list of
+     containing files that matches the current status.  */
+  unsigned char input_stack_listing_current;
+
+  /* If non-zero, macros are not expanded.  */
+  unsigned char no_macro_expand;
+
+  /* If non-zero, directives cause a hard error.  Used when parsing
+     macro arguments.  */
+  unsigned char no_directives;
+
+  /* We're printed a warning recommending against using #import.  */
+  unsigned char import_warning;
+
+  /* If true, characters between '<' and '>' are a single (string) token.  */
+  unsigned char parsing_include_directive;
+
+  /* If true, # introduces an assertion (see do_assert) */
+  unsigned char parsing_if_directive;
+
+  /* If true, # and ## are the STRINGIZE and TOKPASTE operators */
+  unsigned char parsing_define_directive;
+
+  /* True if escape sequences (as described for has_escapes in
+     parse_buffer) should be emitted.  */
+  unsigned char output_escapes;
+
+  /* 0: Have seen non-white-space on this line.
+     1: Only seen white space so far on this line.
+     2: Only seen white space so far in this file.  */
+  unsigned char only_seen_white;
+
+  /* True after cpp_start_read completes.  Used to inhibit some
+     warnings while parsing the command line.  */
+  unsigned char done_initializing;
 };
 
+#define CPP_FATAL_LIMIT 1000
+/* True if we have seen a "fatal" error. */
+#define CPP_FATAL_ERRORS(READER) ((READER)->errors >= CPP_FATAL_LIMIT)
+
+/* Macros for manipulating the token_buffer. */
+
+/* Number of characters currently in PFILE's output buffer. */
+#define CPP_WRITTEN(PFILE) ((size_t)((PFILE)->limit - (PFILE)->token_buffer))
+#define CPP_PWRITTEN(PFILE) ((PFILE)->limit)
+#define CPP_ADJUST_WRITTEN(PFILE,DELTA) ((PFILE)->limit += (DELTA))
+#define CPP_SET_WRITTEN(PFILE,N) ((PFILE)->limit = (PFILE)->token_buffer + (N))
+
+#define CPP_OPTION(PFILE, OPTION) ((PFILE)->opts.OPTION)
+#define CPP_BUFFER(PFILE) ((PFILE)->buffer)
+
 /* Name under which this program was invoked.  */
 extern const char *progname;
 
@@ -436,7 +424,6 @@ extern enum cpp_token cpp_get_token PARAMS ((cpp_reader *));
 extern enum cpp_token cpp_get_non_space_token PARAMS ((cpp_reader *));
 
 extern void cpp_reader_init PARAMS ((cpp_reader *));
-extern void cpp_options_init PARAMS ((cpp_options *));
 extern int cpp_start_read PARAMS ((cpp_reader *, const char *));
 extern void cpp_finish PARAMS ((cpp_reader *));
 extern void cpp_cleanup PARAMS ((cpp_reader *PFILE));

gcc/cppmain.c

@@ -28,7 +28,6 @@ Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 const char *progname;
 
 cpp_reader parse_in;
-cpp_options options;
 
 
 extern int main				PARAMS ((int, char **));
@@ -38,9 +37,11 @@ main (argc, argv)
      char **argv;
 {
   char *p;
+  cpp_reader *pfile = &parse_in;
   int argi = 1;  /* Next argument to handle.  */
-  struct cpp_options *opts = &options;
   enum cpp_token kind;
+  FILE *out;
+  const char *out_fname;
 
   p = argv[0] + strlen (argv[0]);
   while (p != argv[0] && p[-1] != '/') --p;
@@ -54,47 +55,49 @@ main (argc, argv)
   (void) bindtextdomain (PACKAGE, localedir);
   (void) textdomain (PACKAGE);
 
-  cpp_reader_init (&parse_in);
-  parse_in.opts = opts;
-
-  cpp_options_init (opts);
+  cpp_reader_init (pfile);
   
-  argi += cpp_handle_options (&parse_in, argc - argi , argv + argi);
-  if (argi < argc && ! CPP_FATAL_ERRORS (&parse_in))
-    cpp_fatal (&parse_in, "Invalid option `%s'", argv[argi]);
-  if (CPP_FATAL_ERRORS (&parse_in))
+  argi += cpp_handle_options (pfile, argc - argi , argv + argi);
+  if (argi < argc && ! CPP_FATAL_ERRORS (pfile))
+    cpp_fatal (pfile, "Invalid option %s", argv[argi]);
+  if (CPP_FATAL_ERRORS (pfile))
     return (FATAL_EXIT_CODE);
-      
-  parse_in.show_column = 1;
 
-  if (! cpp_start_read (&parse_in, opts->in_fname))
+  if (! cpp_start_read (pfile, CPP_OPTION (pfile, in_fname)))
     return (FATAL_EXIT_CODE);
 
   /* Now that we know the input file is valid, open the output.  */
-
-  if (!opts->out_fname || !strcmp (opts->out_fname, ""))
-    opts->out_fname = "stdout";
-  else if (! freopen (opts->out_fname, "w", stdout))
+  out_fname = CPP_OPTION (pfile, out_fname);
+  if (*out_fname == '\0')
+    {
+      out_fname = "stdout";
+      out = stdout;
+    }
+  else
     {
-      cpp_notice_from_errno (&parse_in, opts->out_fname);
-      return (FATAL_EXIT_CODE);
+      out = fopen (out_fname, "w");
+      if (!out)
+	{
+	  cpp_notice_from_errno (pfile, CPP_OPTION (pfile, out_fname));
+	  return (FATAL_EXIT_CODE);
+	}
     }
 
-  if (! opts->no_output)
+  if (! CPP_OPTION (pfile, no_output))
     {
       do
 	{
-	  kind = cpp_get_token (&parse_in);
-	  if (CPP_WRITTEN (&parse_in) >= BUFSIZ || kind == CPP_EOF)
+	  kind = cpp_get_token (pfile);
+	  if (CPP_WRITTEN (pfile) >= BUFSIZ || kind == CPP_EOF)
 	    {
-	      size_t rem, count = CPP_WRITTEN (&parse_in);
+	      size_t rem, count = CPP_WRITTEN (pfile);
 
-	      rem = fwrite (parse_in.token_buffer, 1, count, stdout);
+	      rem = fwrite (parse_in.token_buffer, 1, count, out);
 	      if (rem < count)
 		/* Write error. */
-		cpp_notice_from_errno (&parse_in, opts->out_fname);
+		cpp_notice_from_errno (pfile, CPP_OPTION (pfile, out_fname));
 
-	      CPP_SET_WRITTEN (&parse_in, 0);
+	      CPP_SET_WRITTEN (pfile, 0);
 	    }
 	}
       while (kind != CPP_EOF);
@@ -103,19 +106,22 @@ main (argc, argv)
     {
       do
 	{
-	  cpp_scan_buffer (&parse_in);
-	  kind = cpp_get_token (&parse_in);
+	  cpp_scan_buffer (pfile);
+	  kind = cpp_get_token (pfile);
 	}
       while (kind != CPP_EOF);
-      CPP_SET_WRITTEN (&parse_in, 0);
+      CPP_SET_WRITTEN (pfile, 0);
     }
 
-  cpp_finish (&parse_in);
-  if (fwrite (parse_in.token_buffer, 1, CPP_WRITTEN (&parse_in), stdout)
-      < CPP_WRITTEN (&parse_in))
-    cpp_notice_from_errno (&parse_in, opts->out_fname);
+  cpp_finish (pfile);
+  if (fwrite (parse_in.token_buffer, 1, CPP_WRITTEN (pfile), out)
+      < CPP_WRITTEN (pfile))
+    cpp_notice_from_errno (pfile, CPP_OPTION (pfile, out_fname));
+
+  if (ferror (out) || fclose (out))
+    cpp_notice_from_errno (pfile, CPP_OPTION (pfile, out_fname));
 
-  cpp_cleanup (&parse_in);
+  cpp_cleanup (pfile);
 
   if (parse_in.errors)
     return (FATAL_EXIT_CODE);

gcc/fix-header.c

@@ -617,7 +617,6 @@ read_scan_file (in_fname, argc, argv)
      char **argv;
 {
   cpp_reader scan_in;
-  cpp_options scan_options;
   struct fn_decl *fn;
   int i;
   register struct symbol_list *cur_symbols;
@@ -625,13 +624,11 @@ read_scan_file (in_fname, argc, argv)
   obstack_init (&scan_file_obstack); 
 
   cpp_reader_init (&scan_in);
-  scan_in.opts = &scan_options;
-  cpp_options_init (&scan_options);
   /* We are going to be scanning a header file out of its proper context,
      so ignore warnings and errors.  */
-  scan_options.inhibit_warnings = 1;
-  scan_options.inhibit_errors = 1;
-  scan_options.no_line_commands = 1;
+  CPP_OPTION (&scan_in, inhibit_warnings) = 1;
+  CPP_OPTION (&scan_in, inhibit_errors) = 1;
+  CPP_OPTION (&scan_in, no_line_commands) = 1;
   i = cpp_handle_options (&scan_in, argc, argv);
   if (i < argc && ! CPP_FATAL_ERRORS (&scan_in))
     cpp_fatal (&scan_in, "Invalid option `%s'", argv[i]);