Integrated preprocessor.

top level:
	* Makefile.in: Remove all references to c-parse.gperf,
	c-gperf.h, and c-parse.h.  Remove -d from yacc command line
	generating c-parse.c.  Update dependencies.
	* c-parse.gperf, c-gperf.h: Delete.

	* c-common.c: Don't define parse_options, cpp_token, yy_cur,
	yy_lim, or yy_get_token.  Don't define get_directive_line if
	USE_CPPLIB.
	* c-common.h: Add multiple include guard.  Define RID values
	for every keyword in C, C++, and Objective C.  Put all the
	modifiers first.
	(struct c_fileinfo, get_fileinfo, dump_time_statistics): New.
	* c-decl.c (c_decode_option): Handle -lang-objc here.
	(print_lang_identifier): Handle C_IS_RESERVED_WORD case.
	(grokdeclarator): Adjust for new RID scheme.
	(extract_interface_info): New stub.
	* c-lang.c: Don't declare yy_cur or parse_options.
	(lang_init_options): Call cpp_init.  Don't call
	cpp_options_init.
	(lang_init): Don't call check_newline if USE_CPPLIB.

	* c-lex.c: Don't include c-parse.h.  Do include timevar.h.
	Elide lots of unnecessary code if USE_CPPLIB.  Delete code
	rendered unnecessary by new architecture.  Move routines not
	shared with C++ to c-parse.in.  Maintain a local idea of the
	line number.    Handle C++ as well as C.
	[USE_CPPLIB]: Declare and register callbacks for #ident and
	for entering/leaving files.
	(init_c_lex, c_lex): Are now the entry points to this file.
	(check_newline): Break out directive handling to
	process_directive.
	(read_ucs, is_extended_char, utf8_extend_token): Moved here
	from C++ front end.
	(readescape, parse_float): Overhaul.
	(lex_number, lex_string, lex_charconst): Break out of c_lex
	(n'ee yylex).
	(get_fileinfo, update_header_times, dump_one_header,
	dump_time_statistics): New and/or moved here from C++.
	Support per-file data needed by C++ and per-header timing
	statistics (C++ only, at the moment).
	* c-lex.h: Update prototypes.  Add multiple include guard.
	* c-tree.h (struct lang_identifier): Add rid_code field.
	(C_IS_RESERVED_WORD, C_RID_CODE): New.

	* c-parse.in: Include c-pragma.h. Remove unnecesary calls to
	reinit_parse_for_function and/or position_after_white_space.
	(save_filename, save_lineno): Look ahead before saving.
	(label -> identifier ':'): Save file and line before shifting ':'.
	(reservedwords): No need to call get_identifier.
	(init_parse, finish_parse, yyerror, yylex, yyprint,
	make_pointer_declarator): Are now here for C/ObjC.
	(rid_to_yy): Conversion table from RID constants to Yacc codes.

	* c-pragma.c: Rewrite parsing logic to fit with cpplib's
	#pragma registry.  Provide dummy implementation of that
	interface if !USE_CPPLIB.
	* c-pragma.h: Update to match.

	* flags.h: Add multiple include guard.
	(flag_detailed_statistics): Moved here from C++.
	* toplev.c: Define flag_detailed_statistics.

	* gcc.c (C specs): Use %(trad_capable_cpp) for -E|-M|-MM case
	#if USE_CPPLIB.
	* timevar.def (TV_CPP, TV_LEX): New.
	* timevar.h: Add multiple include guard.

	* objc/lang-specs.h: Use %(trad_capable_cpp) for -E|-M|-MM case
	#if USE_CPPLIB.
	* objc/objc-act.c: Don't mention yy_cur or parse_options.
	Initialize cpplib properly.  Force lineno to 0 after first
	call to check_newline.  Don't handle -lang-objc here.
	Move forget_protocol_qualifiers and remember_protocol_qualifiers here.

cp:
	* Make-lang.in, Makefile.in: Remove all references to input.c,
	gxx.gperf, and hash.h.  Add ../c-lex.o to C_OBJS.
	* gxx.gperf, hash.h, input.c: Delete.
	* lang-specs.h: Pass -lang-c++ to cc1plus so cpplib is
	initialized properly.

	* class.c (fixup_pending_inline): Take a tree, not a
	struct pending_inline *.  All callers changed.
	(init_class_processing): Set RID_PUBLIC, RID_PRIVATE,
	RID_PROTECTED entries in ridpointers[] array here.
	* decl.c (duplicate_decls): Do not refer to struct
	pending_inline.
	(record_builtin_type, init_decl_processing): Use RID_MAX not
	CP_RID_MAX.
	(grokdeclarator): Use C_IS_RESERVED_WORD.
	* decl2.c (lang_decode_option): Ignore -lang-c++ for sake of
	cpplib.
	(grok_x_components): Do not inspect pending_inlines chain.

	* cp-tree.h (struct lang_identifier): Add rid_code entry.
	(C_IS_RESERVED_WORD, C_RID_CODE, C_RID_YYCODE): New.
	(flag_no_gnu_keywords, flag_operator_names, rid_to_yy): Declare.
	(DEFARG_LENGTH, struct pending_inline, TIME_IDENTIFIER_TIME,
	TIME_IDENTIFIER_FILEINFO): Kill.
	Update prototypes.
	* lex.h: Expunge cp_rid.  Rewrite RIDBIT macros to use just a
	single 32-bit word.
	* parse.y: Call do_pending_inlines unconditionally.
	reinit_parse_for_method is now snarf_method.  fn.defpen is no
	longer necessary.  Remove unnecessary <itype> annotation on
	SCOPE.  Do not refer to end_of_file or struct pending_inline.
	* semantics.c (begin_inline_definitions): Call
	do_pending_inlines unconditionally.

	* lex.c: Remove all code now shared with C front end.
	Initialize cpplib properly if USE_CPPLIB.  Put reserved words
	into the get_identifier table.  Rewrite pragma handling to
	work with the registry.  Move code to save tokens for later
	processing to spew.c.

	* spew.c: Rewrite everything in terms of token streams instead
	of text.  Move routines here from lex.c / input.c as
	appropriate.  GC-mark trees hanging off the pending inlines
	chain.

testsuite:
	* g++.old-deja/g++.benjamin/13478.C: Put meaningful tags on
	ERROR markers.
	* g++.old-deja/g++.brendan/crash8.C: Move ERROR marker up one line.
	* gcc.dg/c99-array-nonobj-1.c: Don't expect func[] cases to fail.
	* gcc.dg/wtr-label-1.c: Don't use unconstrained .* in error regexps.
	* gcc.dg/wtr-suffix-1.c: Correct error regexps.
	* gcc.dg/cpp/unc1.c, gcc.dg/cpp/unc2.c, gcc.dg/cpp/unc3.c:
	Preprocess only.
	* gcc.dg/cpp/unc4.c: Adjust line number in dg-error line.
	* gcc.dg/noncompile/const-ll-1.c: Generalize error regexp.


git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/trunk@36216 138bc75d-0d04-0410-961f-82ee72b054a4

1 files changed, 276 insertions, 287 deletions

diff --git a/gcc/c-pragma.c b/gcc/c-pragma.c
index 3bb9a390d1a..2d6bee83874 100644
--- a/gcc/c-pragma.c
+++ b/gcc/c-pragma.c
@@ -28,9 +28,28 @@ Boston, MA 02111-1307, USA.  */
 #include "flags.h"
 #include "toplev.h"
 #include "ggc.h"
+#include "c-lex.h"
+#include "cpplib.h"
 
 #ifdef HANDLE_GENERIC_PRAGMAS
 
+#if USE_CPPLIB
+extern cpp_reader parse_in;
+#else
+struct pragma_entry;
+static struct pragma_entry *pragmas;
+
+void cpp_register_pragma PARAMS ((cpp_reader *, const char *, const char *,
+				  void (*) PARAMS ((cpp_reader *)) ));
+void cpp_register_pragma_space PARAMS ((cpp_reader *, const char *));
+#endif
+
+#define BAD(msgid) do { warning (msgid); return; } while (0)
+#define BAD2(msgid, arg) do { warning (msgid, arg); return; } while (0)
+
+#ifdef HANDLE_PRAGMA_PACK
+static void handle_pragma_pack PARAMS ((cpp_reader *));
+
 #ifdef HANDLE_PRAGMA_PACK_PUSH_POP
 typedef struct align_stack
 {
@@ -48,34 +67,19 @@ static struct align_stack * alignment_stack = NULL;
    happens, we restore the value to this, not to a value of 0 for
    maximum_field_alignment.  Value is in bits. */
 static int  default_alignment;
+#define SET_GLOBAL_ALIGNMENT(ALIGN) \
+(default_alignment = maximum_field_alignment = (ALIGN))
 
-static int  push_alignment PARAMS ((int, tree));
-static int  pop_alignment  PARAMS ((tree));
-#ifdef HANDLE_PRAGMA_PACK_PUSH_POP
+static void push_alignment PARAMS ((int, tree));
+static void pop_alignment  PARAMS ((tree));
 static void mark_align_stack PARAMS ((void *));
-#endif
 
 /* Push an alignment value onto the stack.  */
-static int
+static void
 push_alignment (alignment, id)
      int alignment;
      tree id;
 {
-  switch (alignment)
-    {
-    case 0:
-    case 1:
-    case 2:
-    case 4:
-    case 8:
-    case 16:
-      break;
-    default:
-      warning ("\
-Alignment must be a small power of two, not %d, in #pragma pack",
-	       alignment);
-      return 0;
-    }
   
   if (alignment_stack == NULL
       || alignment_stack->alignment != alignment
@@ -98,16 +102,14 @@ Alignment must be a small power of two, not %d, in #pragma pack",
       
       alignment_stack = entry;
 
-      maximum_field_alignment = alignment * BITS_PER_UNIT;
+      maximum_field_alignment = alignment;
     }
   else
     alignment_stack->num_pushes ++;
-
-  return 1;
 }
 
 /* Undo a push of an alignment onto the stack.  */
-static int
+static void
 pop_alignment (id)
      tree id;
 {
@@ -118,7 +120,7 @@ pop_alignment (id)
       warning ("\
 #pragma pack (pop) encountered without matching #pragma pack (push, <n>)"
 	       );
-      return 0;
+      return;
     }
 
   /* If we got an identifier, strip away everything above the target
@@ -145,320 +147,307 @@ pop_alignment (id)
       if (entry == NULL)
 	maximum_field_alignment = default_alignment;
       else
-	maximum_field_alignment = entry->alignment * BITS_PER_UNIT;
+	maximum_field_alignment = entry->alignment;
 
       free (alignment_stack);
 
       alignment_stack = entry;
     }
-
-  return 1;
 }
-#endif /* HANDLE_PRAGMA_PACK_PUSH_POP */
-
-/* Handle one token of a pragma directive.  TOKEN is the current token, and
-   STRING is its printable form.  Some front ends do not support generating
-   tokens, and will only pass in a STRING.  Also some front ends will reuse
-   the buffer containing STRING, so it must be copied to a local buffer if
-   it needs to be preserved.
-
-   If STRING is non-NULL, then the return value will be ignored, and there
-   will be futher calls to handle_pragma_token in order to handle the rest of
-   the line containing the #pragma directive.  If STRING is NULL, the entire
-   line has now been presented to handle_pragma_token and the return value
-   should be zero if the pragma flawed in some way, or if the pragma was not
-   recognised, and non-zero if it was successfully handled.  */
-
-int
-handle_pragma_token (string, token)
-     const char *string;
-     tree token;
+
+static void
+mark_align_stack (p)
+    void *p;
 {
-  static enum pragma_state state = ps_start;
-  static enum pragma_state type;
-#ifdef HANDLE_PRAGMA_WEAK
-  static char *name;
-  static char *value;
-#endif
-#if defined(HANDLE_PRAGMA_PACK) || defined(HANDLE_PRAGMA_PACK_PUSH_POP)
-  static unsigned int align;
-#endif
-  static tree id;
+  align_stack *a = *(align_stack **) p;
 
-  /* If we have reached the end of the #pragma directive then
-     determine what value we should return.  */
-  
-  if (string == NULL)
+  while (a)
     {
-      int ret_val = 0;
-
-      switch (type)
-	{
-	default:
-	  abort ();
-	  break;
-
-	case ps_done:
-	  /* The pragma was not recognised.  */
-	  break;
-	  
-#ifdef HANDLE_PRAGMA_PACK	  
-	case ps_pack:
-	  if (state == ps_right)
-	    {
-	      maximum_field_alignment = align * BITS_PER_UNIT;
-#ifdef HANDLE_PRAGMA_PACK_PUSH_POP
-	      default_alignment = maximum_field_alignment;
-#endif
-	      ret_val = 1;
-	    }
-	  else
-	    warning ("malformed `#pragma pack'");
-	  break;
-#endif /* HANDLE_PRAGMA_PACK */
-	  
-#ifdef HANDLE_PRAGMA_PACK_PUSH_POP
-	case ps_push:
-	  if (state == ps_right)
-	    ret_val = push_alignment (align, id);
-	  else
-	    warning ("malformed '#pragma pack(push[,id],<n>)'");
-	  break;
-	  
-	case ps_pop:
-	  if (state == ps_right)
-	    ret_val = pop_alignment (id);
-	  else
-	    warning ("malformed '#pragma pack(pop[,id])'");
-	  break;
+      ggc_mark_tree (a->id);
+      a = a->prev;
+    }
+}
+#else  /* not HANDLE_PRAGMA_PACK_PUSH_POP */
+#define SET_GLOBAL_ALIGNMENT(ALIGN) (maximum_field_alignment = (ALIGN))
+#define push_alignment(ID, N) \
+    BAD("#pragma pack(push[, id], <n>) is not supported on this target")
+#define pop_alignment(ID) \
+    BAD("#pragma pack(pop[, id], <n>) is not supported on this target")
 #endif /* HANDLE_PRAGMA_PACK_PUSH_POP */
-	  
-#ifdef HANDLE_PRAGMA_WEAK
-	case ps_weak:
-	  if (HANDLE_PRAGMA_WEAK)
-	    {
-	      if (state == ps_name)
-		ret_val = add_weak (name, NULL);
-	      else if (state == ps_value)
-		ret_val = add_weak (name, value);
-	      else
-		warning ("malformed `#pragma weak'");
-	    }
-	  else
-	    ret_val = 1; /* Ignore the pragma.  */
-	  break;
-#endif /* HANDLE_PRAGMA_WEAK */
-
-	case ps_poison:
-	  ret_val = 1;
-	  break;
-	}
 
-      type = state = ps_start;
-      id = NULL_TREE;
-      
-      return ret_val;
+/* #pragma pack ()
+   #pragma pack (N)
+   
+   #pragma pack (push, N)
+   #pragma pack (push, ID, N)
+   #pragma pack (pop)
+   #pragma pack (pop, ID) */
+static void
+handle_pragma_pack (dummy)
+     cpp_reader *dummy ATTRIBUTE_UNUSED;
+{
+  tree x, id = 0;
+  int align;
+  enum cpp_ttype token;
+  enum { set, reset, push, pop } action;
+
+  if (c_lex (&x) != CPP_OPEN_PAREN)
+    BAD ("missing '(' after '#pragma pack' - ignored");
+
+  token = c_lex (&x);
+  if (token == CPP_CLOSE_PAREN)
+    action = reset;
+  else if (token == CPP_NUMBER)
+    {
+      align = TREE_INT_CST_LOW (x);
+      action = set;
+    }
+  else if (token == CPP_NAME)
+    {
+      if (!strcmp (IDENTIFIER_POINTER (x), "push"))
+	action = push;
+      else if (!strcmp (IDENTIFIER_POINTER (x), "pop"))
+	action = pop;
+      else
+	BAD2 ("unknown action '%s' for '#pragma pack' - ignored",
+	      IDENTIFIER_POINTER (x));
     }
+  else
+    BAD ("malformed '#pragma pack' - ignored");
 
-  /* If we have been given a token, but it is not an identifier,
-     or a small constant, then something has gone wrong.  */
-  if (token)
+  token = c_lex (&x);
+  if ((action == set || action == reset) && token != CPP_CLOSE_PAREN)
+    BAD ("malformed '#pragma pack' - ignored");
+  if ((action == push || action == pop) && token != CPP_COMMA)
+    BAD2 ("malformed '#pragma pack(%s[, id], <n>)' - ignored",
+	  action == push ? "push" : "pop");
+
+  if (action == push || action == pop)
     {
-      switch (TREE_CODE (token))
+      token = c_lex (&x);
+      if (token == CPP_NAME)
 	{
-	case IDENTIFIER_NODE:
-	  break;
-	  
-	case INTEGER_CST:
-	  if (TREE_INT_CST_HIGH (token) != 0)
-	    return 0;
-	  break;
-	  
-	default:
-	  return 0;
+	  id = x;
+	  if (c_lex (&x) != CPP_COMMA)
+	    BAD2 ("malformed '#pragma pack(%s[, id], <n>)' - ignored",
+		  action == push ? "push" : "pop");
+	  token = c_lex (&x);
 	}
+      if (token == CPP_NUMBER)
+	align = TREE_INT_CST_LOW (x);
+      else
+	BAD2 ("malformed '#pragma pack(%s[, id], <n>)' - ignored",
+	      action == push ? "push" : "pop");
+
+      if (c_lex (&x) != CPP_CLOSE_PAREN)
+	BAD ("malformed '#pragma pack' - ignored");
     }
-      
-  switch (state)
+  if (c_lex (&x) != CPP_EOF)
+    warning ("junk at end of '#pragma pack'");
+
+  switch (align)
     {
-    case ps_start:
-      type = state = ps_done;
-#ifdef HANDLE_PRAGMA_PACK
-      if (strcmp (string, "pack") == 0)
-	type = state = ps_pack;
-#endif
-#ifdef HANDLE_PRAGMA_WEAK
-      if (strcmp (string, "weak") == 0)
-	type = state = ps_weak;
-#endif
-      if (strcmp (string, "poison") == 0)
-	type = state = ps_poison;
+    case 0:
+    case 1:
+    case 2:
+    case 4:
+    case 8:
+    case 16:
+      align *= BITS_PER_UNIT;
       break;
+    default:
+      BAD2 ("alignment must be a small power of two, not %d", align);
+    }
 
-#ifdef HANDLE_PRAGMA_WEAK
-    case ps_weak:
-      name = xstrdup (string);
-      state = ps_name;
-      break;
-      
-    case ps_name:
-      state = (strcmp (string, "=") ? ps_bad : ps_equals);
-      break;
+  switch (action)
+    {
+    case set:   SET_GLOBAL_ALIGNMENT (align);  break;
+    case reset: SET_GLOBAL_ALIGNMENT (0);      break;
+    case push:  push_alignment (align, id);    break;
+    case pop:   pop_alignment (id);            break;
+    }
+}
+#endif  /* HANDLE_PRAGMA_PACK */
 
-    case ps_equals:
-      value = xstrdup (string);
-      state = ps_value;
-      break;
+#ifdef HANDLE_PRAGMA_WEAK
+static void handle_pragma_weak PARAMS ((cpp_reader *));
 
-    case ps_value:
-      state = ps_bad;
-      break;
-#endif /* HANDLE_PRAGMA_WEAK */
-      
-#ifdef HANDLE_PRAGMA_PACK
-    case ps_pack:
-      state = (strcmp (string, "(") ? ps_bad : ps_left);
-      break;
+/* #pragma weak name [= value] */
+static void
+handle_pragma_weak (dummy)
+     cpp_reader *dummy ATTRIBUTE_UNUSED;
+{
+  tree name, value, x;
+  enum cpp_ttype t;
 
-    case ps_left:
+  value = 0;
 
-      if (token == NULL_TREE)
-	{
-	  /* #pragma pack () resets packing rules to their
-	     defaults.  */
-	  if (strcmp (string, ")") == 0)
-	    {
-	      align = 0;
-	      state = ps_right;
-	    }
-	  else
-	    state = ps_bad;
-	}
-      else if (TREE_CODE (token) == INTEGER_CST)
-	goto handle_align;
+  if (c_lex (&name) != CPP_NAME)
+    BAD ("malformed #pragma weak, ignored");
+  t = c_lex (&x);
+  if (t == CPP_EQ)
+    {
+      if (c_lex (&value) != CPP_NAME)
+	BAD ("malformed #pragma weak, ignored");
+      t = c_lex (&x);
+    }
+  if (t != CPP_EOF)
+    warning ("junk at end of #pragma weak");
 
-#ifdef HANDLE_PRAGMA_PACK_PUSH_POP
-      else if (TREE_CODE (token) == IDENTIFIER_NODE)
-	{
-	  if (strcmp (string, "push") == 0)
-	    type = state = ps_push;
-	  else if (strcmp (string, "pop") == 0)
-	    type = state = ps_pop;
-	  else
-	    state = ps_bad;
-	}
+  add_weak (IDENTIFIER_POINTER (name), value ? IDENTIFIER_POINTER (value) : 0);
+}
 #endif
-      else
-	state = ps_bad;
-      break;
 
-    handle_align:
-      switch (tree_log2 (token))
-	{
-	case 0:
-	case 1:
-	case 2:
-	case 3:
-	case 4:
-	  state = ps_align;
-	  align = 1 << tree_log2 (token);
-	  break;
-
-	default:
-	  state = ps_bad;
-	  break;
-	}
-      break;
+#if !USE_CPPLIB
+/* Glue version of cpplib's pragma registration and dispatch system.  */
+struct pragma_entry
+{
+  struct pragma_entry *next;
+  const char *name;
+  size_t len;
+  int isnspace;
+  union {
+    void (*handler) PARAMS ((cpp_reader *));
+    struct pragma_entry *space;
+  } u;
+};
 
-    case ps_align:
-      state = (strcmp (string, ")") ? ps_bad : ps_right);
-      break;
+void
+cpp_register_pragma_space (pfile, space)
+     cpp_reader *pfile ATTRIBUTE_UNUSED;
+     const char *space;
+{
+  struct pragma_entry *new;
+  const struct pragma_entry *p = pragmas;
+  size_t len = strlen (space);
 
-    case ps_right:
-      state = ps_bad;
-      break;
-#endif /* HANDLE_PRAGMA_PACK */
+  while (p)
+    {
+      if (p->isnspace && p->len == len && !memcmp (p->name, space, len))
+	return;
+      p = p->next;
+    }
 
-#ifdef HANDLE_PRAGMA_PACK_PUSH_POP
-    case ps_push:
-      state = (strcmp (string, ",") ? ps_bad : ps_pushcomma);
-      break;
+  new = (struct pragma_entry *) xmalloc (sizeof (struct pragma_entry));
+  new->name = space;
+  new->len = len;
+  new->isnspace = 1;
+  new->u.space = 0;
 
-    case ps_pushid:
-      state = (strcmp (string, ",") ? ps_bad : ps_pushcomma2);
-      break;
+  new->next = pragmas;
+  pragmas = new;
+}
 
-    case ps_pushcomma:
-      if (token && TREE_CODE (token) == IDENTIFIER_NODE)
+void
+cpp_register_pragma (pfile, space, name, handler)
+     cpp_reader *pfile ATTRIBUTE_UNUSED;
+     const char *space;
+     const char *name;
+     void (*handler) PARAMS ((cpp_reader *));
+{
+  struct pragma_entry **x, *new;
+  size_t len;
+
+  x = &pragmas;
+  if (space)
+    {
+      struct pragma_entry *p = pragmas;
+      len = strlen (space);
+      while (p)
 	{
-	  id = token;
-	  state = ps_pushid;
-	  break;
+	  if (p->isnspace && p->len == len && !memcmp (p->name, space, len))
+	    {
+	      x = &p->u.space;
+	      goto found;
+	    }
+	  p = p->next;
 	}
+      abort ();
+    }
 
-      /* else fall through */
-    case ps_pushcomma2:
-      if (token && TREE_CODE (token) == INTEGER_CST)
-	goto handle_align;
-      else
-	state = ps_bad;
-      break;
+ found:
+  new = (struct pragma_entry *) xmalloc (sizeof (struct pragma_entry));
+  new->name = name;
+  new->len = strlen (name);
+  new->isnspace = 0;
+  new->u.handler = handler;
 
-    case ps_pop:
-      if (strcmp (string, ",") == 0)
-	state = ps_popcomma;
-      else
-	state = (strcmp (string, ")") ? ps_bad : ps_right);
-      break;
+  new->next = *x;
+  *x = new;
+}
 
-    case ps_popcomma:
-      if (token && TREE_CODE (token) == IDENTIFIER_NODE)
-	{
-	  id = token;
-	  state = ps_align;
-	}
-      else
-	state = ps_bad;
-      break;
-#endif /* HANDLE_PRAGMA_PACK_PUSH_POP */
+/* Called from process_directive() for #pragma lines.  */
+void
+dispatch_pragma ()
+{
+  enum cpp_ttype t;
+  tree x;
+  const struct pragma_entry *p;
+  const char *name;
+  size_t len;
 
-    case ps_poison:
-      if (token && TREE_CODE (token) != IDENTIFIER_NODE)
-	state = ps_bad;
-      break;
+  p = pragmas;
 
-    case ps_bad:
-    case ps_done:
-      break;
+ new_space:
+  t = c_lex (&x);
+  if (t == CPP_EOF)
+    return;
 
-    default:
-      abort ();
+  if (t != CPP_NAME)
+    {
+      warning ("malformed #pragma directive");
+      return;
     }
 
-  return 1;
-}
-#endif /* HANDLE_GENERIC_PRAGMAS */
-
-#ifdef HANDLE_PRAGMA_PACK_PUSH_POP
-static void
-mark_align_stack (p)
-    void *p;
-{
-  align_stack *a = *(align_stack **) p;
-
-  while (a)
+  name = IDENTIFIER_POINTER (x);
+  len = IDENTIFIER_LENGTH (x);
+  while (p)
     {
-      ggc_mark_tree (a->id);
-      a = a->prev;
+      if (strlen (p->name) == len && !memcmp (p->name, name, len))
+	{
+	  if (p->isnspace)
+	    {
+	      p = p->u.space;
+	      goto new_space;
+	    }
+	  else
+	    {
+	      (*p->u.handler) (0);
+	      return;
+	    }
+	}
+      p = p->next;
     }
+
+  /* Issue a warning message if we have been asked to do so.  Ignore
+     unknown pragmas in system header file unless an explcit
+     -Wunknown-pragmas has been given. */
+  if (warn_unknown_pragmas > in_system_header)
+    warning ("ignoring pragma %s", name);
 }
+
 #endif
 
 void
 init_pragma ()
 {
+#if !USE_CPPLIB
+  cpp_reader *pfile = 0;
+#else
+  cpp_reader *pfile = &parse_in;
+#endif
+
+#ifdef HANDLE_PRAGMA_PACK
+  cpp_register_pragma (pfile, 0, "pack", handle_pragma_pack);
+#endif
+#ifdef HANDLE_PRAGMA_WEAK
+  cpp_register_pragma (pfile, 0, "weak", handle_pragma_weak);
+#endif
+
 #ifdef HANDLE_PRAGMA_PACK_PUSH_POP
   ggc_add_root (&alignment_stack, 1, sizeof(alignment_stack),
 		mark_align_stack);
 #endif
 }
+
+#endif /* HANDLE_GENERIC_PRAGMAS */