* symtab.h (struct linetable), xcoffread.c (arrange_linetable):

	Revise comments re linetable sorting.
	* buildsym.c (compare_line_numbers): Sort by pc, not by line.
	* coffread.c: Tell end_symtab to sort the line table.

	* coffread.c: Re-work a lot of the coff-specific stuff to use stuff
	in buildsym.c.  This includes coff_finish_block, coff_context_stack,
	coff_local_symbols, coff_file_symbols, coff_global_symbols,
	coff_end_symtab and coff_add_symbol_to_list.
	(read_enum_type): Deal with it now that we have a "struct pending"
	not a "struct coff_pending".

	* buildsym.c (end_symtab): Don't realloc subfile->linetable.

1 files changed, 87 insertions, 337 deletions

diff --git a/gdb/coffread.c b/gdb/coffread.c
index 8348b57..6ccf456 100644
--- a/gdb/coffread.c
+++ b/gdb/coffread.c
@@ -123,44 +123,6 @@ static unsigned	local_auxesz;
 
 static struct symbol *opaque_type_chain[HASHSIZE];
 
-/* Record the symbols defined for each context in a list.
-   We don't create a struct block for the context until we
-   know how long to make it.  */
-
-struct coff_pending
-{
-  struct coff_pending *next;
-  struct symbol *symbol;
-};
-
-/* Here are the three lists that symbols are put on.  */
-
-struct coff_pending *coff_file_symbols;	/* static at top level, and types */
-
-struct coff_pending *coff_global_symbols;  /* global functions and variables */
-
-struct coff_pending *coff_local_symbols;  /* everything local to lexical context */
-
-/* List of unclosed lexical contexts
-   (that will become blocks, eventually).  */
-
-struct coff_context_stack
-{
-  struct coff_context_stack *next;
-  struct coff_pending *locals;
-  struct pending_block *old_blocks;
-  struct symbol *name;
-  CORE_ADDR start_addr;
-  int depth;
-};
-
-struct coff_context_stack *coff_context_stack;
-
-/* Nonzero if within a function (so symbols should be local,
-   if nothing says specifically).  */
-
-int within_function;
-
 #if 0
 /* The type of the function we are currently reading in.  This is
    used by define_symbol to record the type of arguments to a function. */
@@ -229,9 +191,6 @@ decode_function_type PARAMS ((struct coff_symbol *, unsigned int,
 static struct type *
 coff_read_enum_type PARAMS ((int, int, int));
 
-static struct blockvector *
-make_blockvector PARAMS ((struct objfile *));
-
 static struct symbol *
 process_coff_symbol PARAMS ((struct coff_symbol *, union internal_auxent *,
 			     struct objfile *));
@@ -300,14 +259,6 @@ coff_start_symtab PARAMS ((void));
 static void
 coff_record_line PARAMS ((int, CORE_ADDR));
 
-static void
-coff_finish_block PARAMS ((struct symbol *, struct coff_pending **,
-			   struct pending_block *, CORE_ADDR, CORE_ADDR,
-			   struct objfile *));
-
-static void
-coff_add_symbol_to_list PARAMS ((struct symbol *, struct coff_pending **));
-
 static struct type *
 coff_alloc_type PARAMS ((int));
 
@@ -365,142 +316,6 @@ coff_alloc_type (index)
   return type;
 }
 
-/* maintain the lists of symbols and blocks */
-
-/* Add a symbol to one of the lists of symbols.  */
-static void
-coff_add_symbol_to_list (symbol, listhead)
-     struct symbol *symbol;
-     struct coff_pending **listhead;
-{
-  register struct coff_pending *link
-    = (struct coff_pending *) xmalloc (sizeof (struct coff_pending));
-
-  link->next = *listhead;
-  link->symbol = symbol;
-  *listhead = link;
-}
-
-/* Take one of the lists of symbols and make a block from it.
-   Put the block on the list of pending blocks.  */
-
-static void
-coff_finish_block (symbol, listhead, old_blocks, start, end, objfile)
-     struct symbol *symbol;
-     struct coff_pending **listhead;
-     struct pending_block *old_blocks;
-     CORE_ADDR start, end;
-     struct objfile *objfile;
-{
-  register struct coff_pending *next, *next1;
-  register struct block *block;
-  register struct pending_block *pblock;
-  struct pending_block *opblock;
-  register int i;
-
-  /* Count the length of the list of symbols.  */
-
-  for (next = *listhead, i = 0; next; next = next->next, i++);
-
-  block = (struct block *)
-	    obstack_alloc (&objfile->symbol_obstack, sizeof (struct block) + (i - 1) * sizeof (struct symbol *));
-
-  /* Copy the symbols into the block.  */
-
-  BLOCK_NSYMS (block) = i;
-  for (next = *listhead; next; next = next->next)
-    BLOCK_SYM (block, --i) = next->symbol;
-
-  BLOCK_START (block) = start;
-  BLOCK_END (block) = end;
-  BLOCK_SUPERBLOCK (block) = 0;	/* Filled in when containing block is made */
-
-  /* Put the block in as the value of the symbol that names it.  */
-
-  if (symbol)
-    {
-      SYMBOL_BLOCK_VALUE (symbol) = block;
-      BLOCK_FUNCTION (block) = symbol;
-    }
-  else
-    BLOCK_FUNCTION (block) = 0;
-
-  /* Now free the links of the list, and empty the list.  */
-
-  for (next = *listhead; next; next = next1)
-    {
-      next1 = next->next;
-      free ((PTR)next);
-    }
-  *listhead = 0;
-
-  /* Install this block as the superblock
-     of all blocks made since the start of this scope
-     that don't have superblocks yet.  */
-
-  opblock = 0;
-  for (pblock = pending_blocks; pblock != old_blocks; pblock = pblock->next)
-    {
-      if (BLOCK_SUPERBLOCK (pblock->block) == 0)
-	BLOCK_SUPERBLOCK (pblock->block) = block;
-      opblock = pblock;
-    }
-
-  /* Record this block on the list of all blocks in the file.
-     Put it after opblock, or at the beginning if opblock is 0.
-     This puts the block in the list after all its subblocks.  */
-
-  pblock = (struct pending_block *) xmalloc (sizeof (struct pending_block));
-  pblock->block = block;
-  if (opblock)
-    {
-      pblock->next = opblock->next;
-      opblock->next = pblock;
-    }
-  else
-    {
-      pblock->next = pending_blocks;
-      pending_blocks = pblock;
-    }
-}
-
-static struct blockvector *
-make_blockvector (objfile)
-     struct objfile *objfile;
-{
-  register struct pending_block *next, *next1;
-  register struct blockvector *blockvector;
-  register int i;
-
-  /* Count the length of the list of blocks.  */
-
-  for (next = pending_blocks, i = 0; next; next = next->next, i++);
-
-  blockvector = (struct blockvector *)
-		  obstack_alloc (&objfile->symbol_obstack, sizeof (struct blockvector) + (i - 1) * sizeof (struct block *));
-
-  /* Copy the blocks into the blockvector.
-     This is done in reverse order, which happens to put
-     the blocks into the proper order (ascending starting address).
-     coff_finish_block has hair to insert each block into the list
-     after its subblocks in order to make sure this is true.  */
-
-  BLOCKVECTOR_NBLOCKS (blockvector) = i;
-  for (next = pending_blocks; next; next = next->next)
-    BLOCKVECTOR_BLOCK (blockvector, --i) = next->block;
-
-  /* Now free the links of the list, and empty the list.  */
-
-  for (next = pending_blocks; next; next = next1)
-    {
-      next1 = next->next;
-      free ((PTR)next);
-    }
-  pending_blocks = 0;
-
-  return blockvector;
-}
-
 /* Manage the vector of line numbers.  */
 
 static void
@@ -531,11 +346,14 @@ coff_record_line (line, pc)
 static void
 coff_start_symtab ()
 {
-  coff_file_symbols = 0;
-  coff_global_symbols = 0;
-  coff_context_stack = 0;
-  within_function = 0;
-  last_source_file = NULL;
+  start_symtab (
+		/* We fill in the filename later.  */
+		"",
+		/* We never know the directory name for COFF.  */
+		NULL,
+		/* The start address is irrelevant, since we set
+		   last_source_start_addr in coff_end_symtab.  */
+		0);
 
   /* Initialize the source file line number information for this file.  */
 
@@ -581,87 +399,24 @@ static void
 coff_end_symtab (objfile)
      struct objfile *objfile;
 {
-  register struct symtab *symtab;
-  register struct coff_context_stack *cstk;
-  register struct blockvector *blockvector;
-  register struct linetable *lv;
+  struct symtab *symtab;
 
-  /* Finish the lexical context of the last function in the file.  */
+  last_source_start_addr = cur_src_start_addr;
 
-  if (coff_context_stack)
-    {
-      cstk = coff_context_stack;
-      coff_context_stack = 0;
-      /* Make a block for the local symbols within.  */
-      coff_finish_block (cstk->name, &coff_local_symbols, cstk->old_blocks,
-		    cstk->start_addr, cur_src_end_addr, objfile);
-      free ((PTR)cstk);
-    }
+  /* For COFF, we only have one subfile, so we can just look at
+     subfiles and not worry about there being other elements in the
+     chain.  We fill in various fields now because we didn't know them
+     before (or because doing it now is simply an artifact of how this
+     file used to be written).  */
+  subfiles->line_vector = line_vector;
+  subfiles->name = last_source_file;
 
-  /* Ignore a file that has no functions with real debugging info.  */
-  if (pending_blocks == 0 && coff_file_symbols == 0 && coff_global_symbols == 0)
-    {
-      free ((PTR)line_vector);
-      line_vector = 0;
-      line_vector_length = -1;
-      last_source_file = NULL;
-      return;
-    }
+  /* sort_pending is needed for amdcoff, at least.
+     sort_linevec is needed for the SCO compiler.  */
+  symtab = end_symtab (cur_src_end_addr, 1, 1, objfile, 0);
 
-  /* It is unfortunate that in amdcoff, pending blocks might not be ordered
-     in this stage. Especially, blocks for static functions will show up at
-     the end.  We need to sort them, so tools like `find_pc_function' and
-     `find_pc_block' can work reliably. */
-  if (pending_blocks) {
-    /* FIXME!  Remove this horrid bubble sort and use qsort!!! */
-    int swapped;
-    do {
-      struct pending_block *pb, *pbnext;
-
-      pb = pending_blocks, pbnext = pb->next;
-      swapped = 0;
-
-      while ( pbnext ) {
-
-	  /* swap blocks if unordered! */
-
-	  if (BLOCK_START(pb->block) < BLOCK_START(pbnext->block)) {
-	    struct block *tmp = pb->block;
-	    complain (&misordered_blocks_complaint, BLOCK_START (pb->block));
-	    pb->block = pbnext->block;
-	    pbnext->block = tmp;
-	    swapped = 1;
-	  }
-	  pb = pbnext;
-	  pbnext = pbnext->next;
-      }
-    } while (swapped);
-  }
-
-  /* Create the two top-level blocks for this file (STATIC_BLOCK and
-     GLOBAL_BLOCK).  */
-  coff_finish_block (0, &coff_file_symbols, 0, cur_src_start_addr, cur_src_end_addr, objfile);
-  coff_finish_block (0, &coff_global_symbols, 0, cur_src_start_addr, cur_src_end_addr, objfile);
-
-  /* Create the blockvector that points to all the file's blocks.  */
-  blockvector = make_blockvector (objfile);
-
-  /* Now create the symtab object for this source file.  */
-  symtab = allocate_symtab (last_source_file, objfile);
-
-  /* Fill in its components.  */
-  symtab->blockvector = blockvector;
-  symtab->free_code = free_linetable;
-  symtab->free_ptr = 0;
-  symtab->filename = last_source_file;
-  symtab->dirname = NULL;
-  lv = line_vector;
-  lv->nitems = line_vector_index;
-  symtab->linetable = (struct linetable *)
-    xrealloc ((char *) lv, (sizeof (struct linetable)
-		   + lv->nitems * sizeof (struct linetable_entry)));
-
-  free_named_symtabs (symtab->filename);
+  if (symtab != NULL)
+    free_named_symtabs (symtab->filename);
 
   /* Reinitialize for beginning of new file. */
   line_vector = 0;
@@ -888,7 +643,7 @@ read_coff_symtab (symtab_offset, nsyms, objfile)
      struct objfile *objfile;
 {
   FILE *stream; 
-  register struct coff_context_stack *new;
+  register struct context_stack *new;
   struct coff_symbol coff_symbol;
   register struct coff_symbol *cs = &coff_symbol;
   static struct internal_syment main_sym;
@@ -1098,41 +853,41 @@ read_coff_symtab (symtab_offset, nsyms, objfile)
 		  complain (&bf_no_aux_complaint, cs->c_symnum);
 		fcn_first_line = main_aux.x_sym.x_misc.x_lnsz.x_lnno;
 
-		new = (struct coff_context_stack *)
-		  xmalloc (sizeof (struct coff_context_stack));
-		new->depth = depth = 0;
-		new->next = 0;
-		coff_context_stack = new;
-		new->locals = 0;
-		new->old_blocks = pending_blocks;
-		new->start_addr = fcn_start_addr;
+		/* Might want to check that locals are 0 and
+		   context_stack_depth is zero, and complain if not.  */
+
+		depth = 0;
+		new = push_context (depth, fcn_start_addr);
 		fcn_cs_saved.c_name = getsymname (&fcn_sym_saved);
 		new->name = process_coff_symbol (&fcn_cs_saved,
 						 &fcn_aux_saved, objfile);
 	      }
 	    else if (STREQ (cs->c_name, ".ef"))
 	      {
-		      /* the value of .ef is the address of epilogue code;
-		       * not useful for gdb
-		       */
+		/* the value of .ef is the address of epilogue code;
+		   not useful for gdb.  */
 		/* { main_aux.x_sym.x_misc.x_lnsz.x_lnno
 			    contains number of lines to '}' */
-		new = coff_context_stack;
-		if (new == 0)
+		new = pop_context ();
+		/* Stack must be empty now.  */
+		if (context_stack_depth > 0 || new == NULL)
 		  {
 		    complain (&ef_complaint, cs->c_symnum);
 		    within_function = 0;
 		    break;
 		  }
-		if (cs->c_naux != 1) {
-		  complain (&ef_no_aux_complaint, cs->c_symnum);
-		  fcn_last_line = 0x7FFFFFFF;
-		} else {
-		  fcn_last_line = main_aux.x_sym.x_misc.x_lnsz.x_lnno;
-		}
+		if (cs->c_naux != 1)
+		  {
+		    complain (&ef_no_aux_complaint, cs->c_symnum);
+		    fcn_last_line = 0x7FFFFFFF;
+		  }
+		else
+		  {
+		    fcn_last_line = main_aux.x_sym.x_misc.x_lnsz.x_lnno;
+		  }
 		enter_linenos (fcn_line_ptr, fcn_first_line, fcn_last_line);
 
-		coff_finish_block (new->name, &coff_local_symbols, new->old_blocks,
+		finish_block (new->name, &local_symbols, new->old_blocks,
 			      new->start_addr,
 #if defined (FUNCTION_EPILOGUE_SIZE)
 			      /* This macro should be defined only on
@@ -1149,45 +904,31 @@ read_coff_symtab (symtab_offset, nsyms, objfile)
 #endif
 			      objfile
 			      );
-		coff_context_stack = 0;
 		within_function = 0;
-		free ((PTR)new);
 	      }
 	    break;
 
 	  case C_BLOCK:
 	    if (STREQ (cs->c_name, ".bb"))
 	      {
-		new = (struct coff_context_stack *)
-			    xmalloc (sizeof (struct coff_context_stack));
-		depth++;
-		new->depth = depth;
-		new->next = coff_context_stack;
-		coff_context_stack = new;
-		new->locals = coff_local_symbols;
-		new->old_blocks = pending_blocks;
-		new->start_addr = cs->c_value;
-		new->name = 0;
-		coff_local_symbols = 0;
+		push_context (++depth, cs->c_value);
 	      }
 	    else if (STREQ (cs->c_name, ".eb"))
 	      {
-		new = coff_context_stack;
-		if (new == 0 || depth != new->depth)
+		new = pop_context ();
+		if (depth-- != new->depth)
 		  {
 		    complain (&eb_complaint, (char *)symnum);
 		    break;
 		  }
-		if (coff_local_symbols && coff_context_stack->next)
+		if (local_symbols && context_stack_depth > 0)
 		  {
 		    /* Make a block for the local symbols within.  */
-		    coff_finish_block (0, &coff_local_symbols, new->old_blocks,
+		    finish_block (0, &local_symbols, new->old_blocks,
 				  new->start_addr, cs->c_value, objfile);
 		  }
-		depth--;
-		coff_local_symbols = new->locals;
-		coff_context_stack = new->next;
-		free ((PTR)new);
+		/* Now pop locals of block just finished.  */
+		local_symbols = new->locals;
 	      }
 	    break;
 
@@ -1337,9 +1078,6 @@ init_stringtab (chan, offset)
     return 0;
 
   stringtab = (char *) xmalloc (length);
-  if (stringtab == NULL)
-    return -1;
-
   memcpy (stringtab, &length, sizeof length);
   if (length == sizeof length)		/* Empty table -- just the count */
     return 0;
@@ -1435,9 +1173,6 @@ init_lineno (chan, offset, size)
   /* Allocate the desired table, plus a sentinel */
   linetab = (char *) xmalloc (size + local_linesz);
 
-  if (linetab == NULL)
-    return -1;
-
   val = myread (chan, linetab, size);
   if (val != size)
     return -1;
@@ -1626,9 +1361,9 @@ process_coff_symbol (cs, aux, objfile)
 
       SYMBOL_CLASS (sym) = LOC_BLOCK;
       if (cs->c_sclass == C_STAT)
-	coff_add_symbol_to_list (sym, &coff_file_symbols);
+	add_symbol_to_list (sym, &file_symbols);
       else if (cs->c_sclass == C_EXT)
-	coff_add_symbol_to_list (sym, &coff_global_symbols);
+	add_symbol_to_list (sym, &global_symbols);
     }
   else
     {
@@ -1640,13 +1375,13 @@ process_coff_symbol (cs, aux, objfile)
 
 	  case C_AUTO:
 	    SYMBOL_CLASS (sym) = LOC_LOCAL;
-	    coff_add_symbol_to_list (sym, &coff_local_symbols);
+	    add_symbol_to_list (sym, &local_symbols);
 	    break;
 
 	  case C_EXT:
 	    SYMBOL_CLASS (sym) = LOC_STATIC;
 	    SYMBOL_VALUE_ADDRESS (sym) = (CORE_ADDR) cs->c_value;
-	    coff_add_symbol_to_list (sym, &coff_global_symbols);
+	    add_symbol_to_list (sym, &global_symbols);
 	    break;
 
 	  case C_STAT:
@@ -1654,11 +1389,11 @@ process_coff_symbol (cs, aux, objfile)
 	    SYMBOL_VALUE_ADDRESS (sym) = (CORE_ADDR) cs->c_value;
 	    if (within_function) {
 	      /* Static symbol of local scope */
-	      coff_add_symbol_to_list (sym, &coff_local_symbols);
+	      add_symbol_to_list (sym, &local_symbols);
 	    }
 	    else {
 	      /* Static symbol at top level of file */
-	      coff_add_symbol_to_list (sym, &coff_file_symbols);
+	      add_symbol_to_list (sym, &file_symbols);
 	    }
 	    break;
 
@@ -1668,7 +1403,7 @@ process_coff_symbol (cs, aux, objfile)
 	  case C_REG:
 	    SYMBOL_CLASS (sym) = LOC_REGISTER;
 	    SYMBOL_VALUE (sym) = SDB_REG_TO_REGNUM(cs->c_value);
-	    coff_add_symbol_to_list (sym, &coff_local_symbols);
+	    add_symbol_to_list (sym, &local_symbols);
 	    break;
 
 	  case C_LABEL:
@@ -1681,7 +1416,7 @@ process_coff_symbol (cs, aux, objfile)
 	    /* Add parameter to function.  */
 	    add_param_to_type(&in_function_type,sym);
 #endif
-	    coff_add_symbol_to_list (sym, &coff_local_symbols);
+	    add_symbol_to_list (sym, &local_symbols);
 #if !defined (BELIEVE_PCC_PROMOTION) && (TARGET_BYTE_ORDER == BIG_ENDIAN)
 	    /* If PCC says a parameter is a short or a char,
 	       aligned on an int boundary, realign it to the "little end"
@@ -1700,7 +1435,7 @@ process_coff_symbol (cs, aux, objfile)
 	  case C_REGPARM:
 	    SYMBOL_CLASS (sym) = LOC_REGPARM;
 	    SYMBOL_VALUE (sym) = SDB_REG_TO_REGNUM(cs->c_value);
-	    coff_add_symbol_to_list (sym, &coff_local_symbols);
+	    add_symbol_to_list (sym, &local_symbols);
 #if !defined (BELIEVE_PCC_PROMOTION)
 	/* FIXME:  This should retain the current type, since it's just
 	   a register value.  gnu@adobe, 26Feb93 */
@@ -1741,7 +1476,7 @@ process_coff_symbol (cs, aux, objfile)
 		SYMBOL_VALUE_CHAIN (sym) = opaque_type_chain[i];
 		opaque_type_chain[i] = sym;
 	      }
-	    coff_add_symbol_to_list (sym, &coff_file_symbols);
+	    add_symbol_to_list (sym, &file_symbols);
 	    break;
 
 	  case C_STRTAG:
@@ -1760,7 +1495,7 @@ process_coff_symbol (cs, aux, objfile)
 		TYPE_TAG_NAME (SYMBOL_TYPE (sym)) =
 		  concat (SYMBOL_NAME (sym), NULL);
 
-	    coff_add_symbol_to_list (sym, &coff_file_symbols);
+	    add_symbol_to_list (sym, &file_symbols);
 	    break;
 
 	  default:
@@ -2114,21 +1849,23 @@ coff_read_enum_type (index, length, lastsym)
   register struct type *type;
   int nsyms = 0;
   int done = 0;
-  struct coff_pending **symlist;
+  struct pending **symlist;
   struct coff_symbol member_sym;
   register struct coff_symbol *ms = &member_sym;
   struct internal_syment sub_sym;
   union internal_auxent sub_aux;
-  struct coff_pending *osyms, *syms;
+  struct pending *osyms, *syms;
+  int o_nsyms;
   register int n;
   char *name;
 
   type = coff_alloc_type (index);
   if (within_function)
-    symlist = &coff_local_symbols;
+    symlist = &local_symbols;
   else
-    symlist = &coff_file_symbols;
+    symlist = &file_symbols;
   osyms = *symlist;
+  o_nsyms = osyms ? osyms->nsyms : 0;
 
   while (!done && symnum < lastsym && symnum < nlist_nsyms_global)
     {
@@ -2146,7 +1883,7 @@ coff_read_enum_type (index, length, lastsym)
 	    SYMBOL_CLASS (sym) = LOC_CONST;
 	    SYMBOL_NAMESPACE (sym) = VAR_NAMESPACE;
 	    SYMBOL_VALUE (sym) = ms->c_value;
-	    coff_add_symbol_to_list (sym, symlist);
+	    add_symbol_to_list (sym, symlist);
 	    nsyms++;
 	    break;
 
@@ -2174,15 +1911,28 @@ coff_read_enum_type (index, length, lastsym)
      The symbols can be found in the symlist that we put them on
      to cause them to be defined.  osyms contains the old value
      of that symlist; everything up to there was defined by us.  */
+  /* Note that we preserve the order of the enum constants, so
+     that in something like "enum {FOO, LAST_THING=FOO}" we print
+     FOO, not LAST_THING.  */
 
-  for (syms = *symlist, n = nsyms; syms != osyms; syms = syms->next)
+  for (syms = *symlist, n = 0; syms; syms = syms->next)
     {
-      SYMBOL_TYPE (syms->symbol) = type;
-      TYPE_FIELD_NAME (type, --n) = SYMBOL_NAME (syms->symbol);
-      TYPE_FIELD_VALUE (type, n) = 0;
-      TYPE_FIELD_BITPOS (type, n) = SYMBOL_VALUE (syms->symbol);
-      TYPE_FIELD_BITSIZE (type, n) = 0;
+      int j = 0;
+      if (syms == osyms)
+	j = o_nsyms;
+      for (; j < syms->nsyms; j++,n++)
+	{
+	  struct symbol *xsym = syms->symbol[j];
+	  SYMBOL_TYPE (xsym) = type;
+	  TYPE_FIELD_NAME (type, n) = SYMBOL_NAME (xsym);
+	  TYPE_FIELD_VALUE (type, n) = 0;
+	  TYPE_FIELD_BITPOS (type, n) = SYMBOL_VALUE (xsym);
+	  TYPE_FIELD_BITSIZE (type, n) = 0;
+	}
+      if (syms == osyms)
+	break;
     }
+
 #if 0
   /* This screws up perfectly good C programs with enums.  FIXME.  */
   /* Is this Modula-2's BOOLEAN type?  Flag it as such if so. */