X-Git-Url: https://pintos-os.org/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=src%2Fq2c.c;h=aaf3343c2a25e4715e1cf60cacca6c4594c40e74;hb=46cc6dd316280579f5b03dfd39d01bc7daf88df7;hp=a1bc26ba8ef042b0bec1b362a22dc9f989a3c2b4;hpb=e91248ddc41199bda0676817debf080c2b7835a1;p=pspp-builds.git

diff --git a/src/q2c.c b/src/q2c.c
index a1bc26ba..aaf3343c 100644
--- a/src/q2c.c
+++ b/src/q2c.c
@@ -30,6 +30,7 @@
 #endif
 #include "str.h"
 
+
 /* Brokenness. */
 #ifndef EXIT_SUCCESS
 #define EXIT_SUCCESS 0
@@ -99,9 +100,7 @@ finish_up (void)
     fprintf (stderr, "%s: %s: remove: %s\n", pgmname, ofn, strerror (errno));
 }
 
-#if __GNUC__ >= 2
-void hcf (void) __attribute__ ((noreturn));
-#endif
+void hcf (void) NO_RETURN;
 
 /* Terminate unsuccessfully. */
 void
@@ -111,10 +110,8 @@ hcf (void)
   exit (EXIT_FAILURE);
 }
 
-#if __GNUC__ >= 2
-int fail (const char *, ...) __attribute__ ((format (printf, 1, 2)));
-int error (const char *, ...) __attribute__ ((format (printf, 1, 2)));
-#endif
+int fail (const char *, ...) PRINTF_FORMAT (1, 2);
+int error (const char *, ...) PRINTF_FORMAT (1, 2);
 
 /* Output an error message and terminate unsuccessfully. */
 int
@@ -342,7 +339,7 @@ find_symbol (int x)
   return iter;
 }
 
-#if DEBUGGING
+#if DEBUGGING 
 /* Writes a printable representation of the current token to
    stdout. */
 void
@@ -350,6 +347,9 @@ dump_token (void)
 {
   switch (token)
     {
+    case T_TSTRING:
+      printf ("TR_STRING\t\"%s\"\n", tokstr);
+      break;
     case T_STRING:
       printf ("STRING\t\"%s\"\n", tokstr);
       break;
@@ -377,15 +377,7 @@ lex_get (void)
 	fail ("%s: Unexpected end of file.", ifn);
     }
   
-  if (*cp == '_' || isalnum ((unsigned char) *cp))
-    {
-      char *dest = tokstr;
-      token = T_ID;
-      while (*cp == '_' || isalnum ((unsigned char) *cp))
-	*dest++ = toupper ((unsigned char) (*cp++));
-      *dest++ = '\0';
-    }
-  else if (*cp == '"')
+  if (*cp == '"')
     {
       char *dest = tokstr;
       token = T_STRING;
@@ -407,6 +399,14 @@ lex_get (void)
 	error ("Unterminated string literal.");
       cp++;
     }
+  else if (*cp == '_' || isalnum ((unsigned char) *cp))
+    {
+      char *dest = tokstr;
+      token = T_ID;
+      while (*cp == '_' || isalnum ((unsigned char) *cp))
+	*dest++ = toupper ((unsigned char) (*cp++));
+      *dest++ = '\0';
+    }
   else
     token = *cp++;
   
@@ -547,11 +547,22 @@ struct subcommand
     const char *prefix;		/* Prefix for variable and constant names. */
     specifier *spec;		/* Array of specifiers. */
     
-    /* SBC_STRING only. */
+    /* SBC_STRING and SBC_INT only. */
     char *restriction;		/* Expression restricting string length. */
     char *message;		/* Error message. */
+    int translatable;           /* Error message is translatable */
   };
 
+typedef struct aux_subcommand aux_subcommand;
+struct aux_subcommand
+  {
+    aux_subcommand *next;	/* Next in the chain. */
+    char *name;			/* Subcommand name. */
+    char *value;                /* Subcommand value */
+  };
+
+static aux_subcommand *aux_subcommands ;
+
 /* Name of the command; i.e., DESCRIPTIVES. */
 char *cmdname;
 
@@ -694,6 +705,15 @@ parse_specifier (specifier *spec, subcommand *sbc)
     }
   skip_token (':');
   
+  if ( sbc->type == SBC_ARRAY && token == T_ID ) 
+    {
+	spec->varname = xstrdup (st_lower (tokstr));
+	spec->index = sbc->narray;
+	sbc->narray++;
+    }
+    
+  
+  
   /* Parse all the settings. */
   {
     setting **s = &spec->s;
@@ -755,6 +775,7 @@ parse_subcommand (subcommand *sbc)
   sbc->narray = 0;
   sbc->type = SBC_PLAIN;
   sbc->spec = NULL;
+  sbc->translatable = 0;
 
   if (match_token ('['))
     {
@@ -767,6 +788,7 @@ parse_subcommand (subcommand *sbc)
       
       sbc->type = SBC_ARRAY;
       parse_specifiers (sbc);
+
     }
   else
     {
@@ -800,11 +822,38 @@ parse_subcommand (subcommand *sbc)
 	  sbc->type = SBC_VARLIST;
 	}
       else if (match_id ("INTEGER"))
+       {
 	sbc->type = match_id ("LIST") ? SBC_INT_LIST : SBC_INT;
+        if ( token == T_STRING) 
+         {
+	      sbc->restriction = xstrdup (tokstr);
+	      lex_get ();
+              if ( match_id("N_") )
+	       {
+		skip_token('(');
+	        force_string ();
+		lex_get();
+		skip_token(')');
+		sbc->translatable = 1;
+	       }
+	      else {
+        	force_string ();
+		lex_get ();
+              }
+	      sbc->message = xstrdup (tokstr);
+         }
+	else
+	    sbc->restriction = NULL;
+       }
       else if (match_id ("PINT"))
 	sbc->type = SBC_PINT;
       else if (match_id ("DOUBLE"))
-	sbc->type = match_id ("LIST") ? SBC_DBL_LIST : SBC_DBL;
+	{
+	  if ( match_id ("LIST") )
+	    sbc->type = SBC_DBL_LIST;
+	  else
+	    sbc->type = SBC_DBL;
+	}
       else if (match_id ("STRING"))
 	{
 	  sbc->type = SBC_STRING;
@@ -859,9 +908,7 @@ parse_subcommands (void)
 /* Size of the indent from the left margin. */
 int indent;
 
-#if __GNUC__ >= 2
-void dump (int, const char *, ...) __attribute__ ((format (printf, 2, 3)));
-#endif
+void dump (int, const char *, ...) PRINTF_FORMAT (2, 3);
 
 /* Write line FORMAT to the output file, formatted as with printf,
    indented `indent' characters from the left margin.  If INDENTION is
@@ -1002,6 +1049,12 @@ dump_declarations (void)
       }
   }
 
+  /* Write out some type definitions */
+  {
+    dump (0, "#define MAXLISTS 10");
+  }
+
+
   /* For every array subcommand, write out the associated enumerated
      values. */
   {
@@ -1019,7 +1072,6 @@ dump_declarations (void)
 	    specifier *spec;
 
 	    for (spec = sbc->spec; spec; spec = spec->next)
-	      if (!spec->s)
 		dump (0, "%s%s%s = %d,",
 		      st_upper (prefix), st_upper (sbc->prefix),
 		      st_upper (spec->varname), spec->index);
@@ -1065,8 +1117,12 @@ dump_declarations (void)
 			      spec->varname);
 		      else if (f == 0)
 			{
-			  dump (0, "int a_%s[%d];", 
-				st_lower (sbc->name), sbc->narray);
+			  dump (0, "int a_%s[%s%scount];", 
+				st_lower (sbc->name), 
+				st_upper (prefix),
+				st_upper (sbc->prefix)
+				);
+
 			  f = 1;
 			}
 		    }
@@ -1094,13 +1150,24 @@ dump_declarations (void)
 
 	  case SBC_INT:
 	  case SBC_PINT:
-	    dump (0, "long n_%s;", st_lower (sbc->name));
+	    dump (0, "long n_%s[MAXLISTS];", st_lower (sbc->name));
 	    break;
 
 	  case SBC_DBL:
-	    dump (0, "double n_%s;", st_lower (sbc->name));
+	    dump (0, "double n_%s[MAXLISTS];", st_lower (sbc->name));
 	    break;
 
+	  case SBC_DBL_LIST:
+	    dump (0, "subc_list_double dl_%s[MAXLISTS];",
+		  st_lower(sbc->name));
+	    break;
+
+	  case SBC_INT_LIST:
+	    dump (0, "subc_list_int il_%s[MAXLISTS];",
+		  st_lower(sbc->name));
+	    break;
+
+
 	  default:;
 	    /* nothing */
 	  }
@@ -1181,71 +1248,96 @@ dump_specifier_init (const specifier *spec, const subcommand *sbc)
 
 /* Write code to initialize all variables. */
 static void
-dump_vars_init (void)
+dump_vars_init (int persistent)
 {
   /* Loop through all the subcommands. */
   {
     subcommand *sbc;
-
+    
     for (sbc = subcommands; sbc; sbc = sbc->next)
       {
 	int f = 0;
 	
 	dump (0, "p->sbc_%s = 0;", st_lower (sbc->name));
-	switch (sbc->type)
+	if ( ! persistent ) 
 	  {
-	  case SBC_DBL:
-	  case SBC_INT_LIST:
-	  case SBC_DBL_LIST:
-	  case SBC_CUSTOM:
-	    /* nothing */
-	    break;
+	    switch (sbc->type)
+	      {
+	      case SBC_INT_LIST:
+		break;
+
+	      case SBC_DBL_LIST:
+		dump (1, "{");
+		dump (0, "int i;");
+		dump (1, "for (i = 0; i < MAXLISTS; ++i)");
+		dump (0, "subc_list_double_create(&p->dl_%s[i]) ;",
+		      st_lower (sbc->name)
+		      );
+		dump (-2, "}");
+		break;
+
+	      case SBC_DBL:
+		dump (1, "{");
+		dump (0, "int i;");
+		dump (1, "for (i = 0; i < MAXLISTS; ++i)");
+		dump (0, "p->n_%s[i] = SYSMIS;", st_lower (sbc->name));
+		dump (-2, "}");
+		break;
+
+	      case SBC_CUSTOM:
+		/* nothing */
+		break;
 	    
-	  case SBC_PLAIN:
-	  case SBC_ARRAY:
-	    {
-	      specifier *spec;
+	      case SBC_PLAIN:
+	      case SBC_ARRAY:
+		{
+		  specifier *spec;
 	    
-	      for (spec = sbc->spec; spec; spec = spec->next)
-		if (spec->s == NULL)
-		  {
-		    if (sbc->type == SBC_PLAIN)
-		      dump (0, "p->%s%s = 0;", sbc->prefix, spec->varname);
-		    else if (f == 0)
+		  for (spec = sbc->spec; spec; spec = spec->next)
+		    if (spec->s == NULL)
 		      {
-			dump (0, "memset (p->a_%s, 0, sizeof p->a_%s);",
-			      st_lower (sbc->name), st_lower (sbc->name));
-			f = 1;
+			if (sbc->type == SBC_PLAIN)
+			  dump (0, "p->%s%s = 0;", sbc->prefix, spec->varname);
+			else if (f == 0)
+			  {
+			    dump (0, "memset (p->a_%s, 0, sizeof p->a_%s);",
+				  st_lower (sbc->name), st_lower (sbc->name));
+			    f = 1;
+			  }
 		      }
-		  }
-		else
-		  dump_specifier_init (spec, sbc);
-	    }
-	    break;
-
-	  case SBC_VARLIST:
-	    dump (0, "p->%sn_%s = 0;",
-		  st_lower (sbc->prefix), st_lower (sbc->name));
-	    dump (0, "p->%sv_%s = NULL;",
-		  st_lower (sbc->prefix), st_lower (sbc->name));
-	    break;
+		    else
+		      dump_specifier_init (spec, sbc);
+		}
+		break;
+
+	      case SBC_VARLIST:
+		dump (0, "p->%sn_%s = 0;",
+		      st_lower (sbc->prefix), st_lower (sbc->name));
+		dump (0, "p->%sv_%s = NULL;",
+		      st_lower (sbc->prefix), st_lower (sbc->name));
+		break;
 	    
-	  case SBC_VAR:
-	    dump (0, "p->%sv_%s = NULL;",
-		  st_lower (sbc->prefix), st_lower (sbc->name));
-	    break;
-
-	  case SBC_STRING:
-	    dump (0, "p->s_%s = NULL;", st_lower (sbc->name));
-	    break;
-
-	  case SBC_INT:
-	  case SBC_PINT:
-	    dump (0, "p->n_%s = NOT_LONG;", st_lower (sbc->name));
-	    break;
-
-	  default:
-	    assert (0);
+	      case SBC_VAR:
+		dump (0, "p->%sv_%s = NULL;",
+		      st_lower (sbc->prefix), st_lower (sbc->name));
+		break;
+
+	      case SBC_STRING:
+		dump (0, "p->s_%s = NULL;", st_lower (sbc->name));
+		break;
+
+	      case SBC_INT:
+	      case SBC_PINT:
+		dump (1, "{");
+		dump (0, "int i;");
+		dump (1, "for (i = 0; i < MAXLISTS; ++i)");
+		dump (0, "p->n_%s[i] = NOT_LONG;", st_lower (sbc->name));
+		dump (-2, "}");
+		break;
+
+	      default:
+		assert (0);
+	      }
 	  }
       }
   }
@@ -1311,6 +1403,7 @@ dump_specifier_parse (const specifier *spec, const subcommand *sbc)
 	dump (1, "%sif (%s)", first ? "" : "else ",
 	      make_match (s->specname));
 
+
       /* Handle values. */
       if (s->value == VAL_NONE)
 	dump (0, "p->%s%s = %s%s;", sbc->prefix, spec->varname,
@@ -1321,9 +1414,18 @@ dump_specifier_parse (const specifier *spec, const subcommand *sbc)
 	    dump (1, "{");
 	  
 	  if (spec->varname)
-	    dump (0, "p->%s%s = %s%s;", sbc->prefix, spec->varname,
-		  st_upper (prefix), find_symbol (s->con)->name);
-	  
+	    {
+	      dump (0, "p->%s%s = %s%s;", sbc->prefix, spec->varname,
+		    st_upper (prefix), find_symbol (s->con)->name);
+
+	      if ( sbc->type == SBC_ARRAY ) 
+		dump (0, "p->a_%s[%s%s%s] = 1;",
+		      st_lower (sbc->name),
+		      st_upper (prefix), st_upper (sbc->prefix),
+		      st_upper (spec->varname));
+	    }
+
+
 	  if (s->valtype == VT_PAREN)
 	    {
 	      if (s->optvalue)
@@ -1509,7 +1611,7 @@ dump_subcommand (const subcommand *sbc)
     {
       dump (0, "p->%sv_%s = parse_variable ();",
 	    st_lower (sbc->prefix), st_lower (sbc->name));
-      dump (1, "if (p->%sv_%s)",
+      dump (1, "if (!p->%sv_%s)",
 	    st_lower (sbc->prefix), st_lower (sbc->name));
       dump (0, "goto lossage;");
       outdent ();
@@ -1535,7 +1637,8 @@ dump_subcommand (const subcommand *sbc)
 	  dump (-1, "}");
 	  outdent ();
 	}
-      dump (0, "p->s_%s = xstrdup (ds_value (&tokstr));",
+      dump (0, "free(p->s_%s);", st_lower(sbc->name) );
+      dump (0, "p->s_%s = xstrdup (ds_c_str (&tokstr));",
 	    st_lower (sbc->name));
       dump (0, "lex_get ();");
       if (sbc->restriction)
@@ -1545,15 +1648,33 @@ dump_subcommand (const subcommand *sbc)
     {
       dump (1, "if (!lex_force_num ())");
       dump (0, "goto lossage;");
-      dump (-1, "p->n_%s = lex_double ();", st_lower (sbc->name));
+      dump (-1, "p->n_%s[p->sbc_%s - 1] = lex_double ();", 
+	    st_lower (sbc->name), st_lower (sbc->name) );
       dump (0, "lex_get();");
     }
   else if (sbc->type == SBC_INT)
     {
+      dump(1, "{");
+      dump(0, "int x;");
       dump (1, "if (!lex_force_int ())");
       dump (0, "goto lossage;");
-      dump (-1, "p->n_%s = lex_integer ();", st_lower (sbc->name));
+      dump (-1, "x = lex_integer ();");
       dump (0, "lex_get();");
+      if (sbc->restriction)
+       {
+	  char buf[1024];
+	  dump (1, "if (!(%s))", sbc->restriction);
+	  dump (1, "{"); 
+          sprintf(buf,sbc->message,sbc->name);
+	  if ( sbc->translatable ) 
+		  dump (0, "msg (SE, gettext(\"%s\"));",buf);
+	  else
+		  dump (0, "msg (SE, \"%s\");",buf);
+	  dump (0, "goto lossage;");
+	  dump (-1, "}");
+      }
+      dump (0, "p->n_%s[p->sbc_%s - 1] = x;", st_lower (sbc->name), st_lower(sbc->name) );
+      dump (-1,"}");
     }
   else if (sbc->type == SBC_PINT)
     {
@@ -1563,6 +1684,30 @@ dump_subcommand (const subcommand *sbc)
       dump (-1, "p->n_%s = lex_integer ();", st_lower (sbc->name));
       dump (0, "lex_match (')');");
     }
+  else if (sbc->type == SBC_DBL_LIST)
+    {
+      dump (0, "if ( p->sbc_%s > MAXLISTS)",st_lower(sbc->name));
+      dump (1, "{");
+      dump (0, "msg (SE, \"No more than %%d %s subcommands allowed\",MAXLISTS);",st_lower(sbc->name));
+      dump (0, "goto lossage;");
+      dump (-1,"}");
+
+      dump (1, "while (token != '/' && token != '.')");
+      dump (1, "{");
+      dump (0, "lex_match(',');");
+      dump (0, "if (!lex_force_num ())");
+      dump (1, "{");
+      dump (0, "goto lossage;");
+      dump (-1,"}");
+
+      dump (0, "subc_list_double_push(&p->dl_%s[p->sbc_%s-1],lex_double ());", 
+	    st_lower (sbc->name),st_lower (sbc->name)
+	    );
+
+      dump (0, "lex_get();");
+      dump (-1,"}");
+
+    }
   else if (sbc->type == SBC_CUSTOM)
     {
       dump (1, "switch (%scustom_%s (p))",
@@ -1587,7 +1732,7 @@ dump_subcommand (const subcommand *sbc)
 
 /* Write out entire parser. */
 static void
-dump_parser (void)
+dump_parser (int persistent)
 {
   int f;
 
@@ -1598,7 +1743,7 @@ dump_parser (void)
 	make_identifier (cmdname));
   dump (1, "{");
 
-  dump_vars_init ();
+  dump_vars_init (persistent);
 
   dump (1, "for (;;)");
   dump (1, "{");
@@ -1675,6 +1820,21 @@ dump_parser (void)
 	outdent ();
       }
   }
+  /* Now deal with the /ALGORITHM subcommand implicit to all commands */
+  dump(1,"else if ( get_syntax() != COMPATIBLE && lex_match_id(\"ALGORITHM\"))");
+  dump(1,"{");
+
+  dump (0, "lex_match ('=');");
+
+  dump(1,"if (lex_match_id(\"COMPATIBLE\"))");
+  dump(0,"set_cmd_algorithm(COMPATIBLE);");
+  outdent();
+  dump(1,"else if (lex_match_id(\"ENHANCED\"))");
+  dump(0,"set_cmd_algorithm(ENHANCED);");
+
+  dump (-1, "}");
+  outdent ();
+
   
   dump (1, "if (!lex_match ('/'))");
   dump (0, "break;");
@@ -1697,6 +1857,153 @@ dump_parser (void)
   dump (0, nullstr);
 }
 
+
+/* Write out the code to parse aux subcommand SBC. */
+static void
+dump_aux_subcommand (const subcommand *sbc)
+{
+  if (sbc->type == SBC_PLAIN )
+    {
+      specifier *spec;
+	
+      for (spec = sbc->spec; spec; spec = spec->next)
+	{
+	  char buf[80];
+	  sprintf(buf,"p->%s%s",st_lower(sbc->prefix),spec->varname);
+
+	  dump (0, "msg(MM,\"%s is %%s\",",sbc->name);
+	  dump (0, "(%s < 1000)?\"not set\":settings[%s - 1000]", buf, buf);
+      
+	  dump (0, ");");
+	}
+    }
+  else if (sbc->type == SBC_STRING)
+    {
+      dump (0, "msg(MM,\"%s is \\\"%%s\\\"\",p->s_%s);", sbc->name,st_lower(sbc->name) );
+    }
+  else if (sbc->type == SBC_INT)
+    {
+      dump (1, "{");
+      dump (0, "int i;");
+      dump (1, "for (i = 0; i < MAXLISTS; ++i)");
+      dump (0, "msg(MM,\"%s is %%ld\",p->n_%s[i]);", sbc->name,st_lower(sbc->name) ); 
+      outdent();
+      dump (-1, "}");
+    }
+  else if (sbc->type == SBC_CUSTOM)
+    {
+      dump (0, "aux_%scustom_%s(p);",st_lower(prefix),make_identifier(sbc->name));
+    }
+  else
+    assert(0);
+}
+
+
+
+/* Write out auxilliary parser. */
+static void
+dump_aux_parser (void)
+{
+  int f=0;
+  subcommand *sbc;
+  aux_subcommand *asbc;
+
+  /* Write out English strings for all the identifiers in the symbol table. */
+  {
+    int f, k;
+    symbol *sym;
+    char *buf = NULL;
+
+    /* Note the squirmings necessary to make sure that the last string
+       is not followed by a comma (is it necessary to do that ?? ) */
+    for (sym = symtab, f = k = 0; sym; sym = sym->next)
+      if (!sym->unique && !is_keyword (sym->name))
+	{
+	  if (!f)
+	    {
+	      dump (0, "/* Strings for subcommand specifiers. */");
+	      dump (1, "static const char *settings[]=");
+	      dump (1, "{");
+	      f = 1;
+	    }
+
+	  if (buf == NULL)
+	    buf = xmalloc (1024);
+	  else
+	    dump (0, buf);
+
+	  sprintf (buf, "\"%s\",",sym->name);
+	}
+    if (buf)
+      {
+	buf[strlen (buf) - 1] = 0;
+	dump (0, buf);
+	free (buf);
+      }
+    if (f)
+      {
+	dump (-1, "};");
+	dump (-1, nullstr);
+      }
+  }
+
+  
+  indent = 0;
+
+  dump (0, "static int");
+  dump (0, "aux_parse_%s (struct cmd_%s *p)", make_identifier (cmdname),
+	make_identifier (cmdname));
+  dump (1, "{");
+
+  dump (1, "for (;;)");
+  dump (1, "{");
+
+
+  for (sbc = subcommands; sbc; sbc = sbc->next)
+    {
+      dump (1, "%sif (%s)", f ? "else " : "", make_match (sbc->name));
+      f = 1;
+      dump (1, "{");
+
+      dump_aux_subcommand (sbc);
+
+      dump (-1, "}");
+      outdent ();
+    }
+
+  for (asbc = aux_subcommands ; asbc ; asbc = asbc->next)
+    {
+      dump (1, "%sif (%s)", f ? "else " : "", make_match (asbc->name));
+      f = 1;
+      dump (1, "{");
+      dump(0,"aux_%s();",make_identifier(asbc->value));
+      dump (-1, "}");
+      outdent ();
+    }
+  
+  dump (1, "if (!lex_match ('/'))");
+  dump (0, "break;");
+  dump (-2, "}");
+  outdent ();
+  dump (0, nullstr);
+  dump (1, "if (token != '.')");
+  dump (1, "{");
+  dump (0, "lex_error (_(\"expecting end of command\"));");
+  dump (0, "goto lossage;");
+  dump (-1, "}");
+  dump (0, nullstr);
+  dump (-1, "return 1;");
+  dump (0, nullstr);
+  dump (-1, "lossage:");
+  indent ();
+  dump (0, "free_%s (p);", make_identifier (cmdname));
+  dump (0, "return 0;");
+  dump (-1, "} /* aux_parse_%s (struct cmd_%s *p) */", 
+	make_identifier (cmdname), make_identifier (cmdname));
+  dump (0, nullstr);
+}
+
+
 /* Write the output file header. */
 static void
 dump_header (void)
@@ -1710,17 +2017,16 @@ dump_header (void)
   loctime = localtime (&curtime);
   timep = asctime (loctime);
   timep[strlen (timep) - 1] = 0;
-  dump (0,   "/* %s", ofn);
+  dump (0,   "/* %s\t\t-*- mode: c; buffer-read-only: t -*-", ofn);
   dump (0, nullstr);
   dump (0, "   Generated by q2c from %s on %s.", ifn, timep);
   dump (0, "   Do not modify!");
   dump (0, " */");
-  dump (0, nullstr);
 }
 
 /* Write out commands to free variable state. */
 static void
-dump_free (void)
+dump_free (int persistent)
 {
   subcommand *sbc;
   int used;
@@ -1728,22 +2034,51 @@ dump_free (void)
   indent = 0;
 
   used = 0;
-  for (sbc = subcommands; sbc; sbc = sbc->next)
-    if (sbc->type == SBC_STRING)
-      used = 1;
+  if ( ! persistent ) 
+    {
+      for (sbc = subcommands; sbc; sbc = sbc->next)
+	{
+	if (sbc->type == SBC_STRING)
+	  used = 1;
+	if (sbc->type == SBC_DBL_LIST)
+	  used = 1;
+	}
+
+    }
 
   dump (0, "static void");
   dump (0, "free_%s (struct cmd_%s *p%s)", make_identifier (cmdname),
-	make_identifier (cmdname), used ? "" : " unused");
+	make_identifier (cmdname), used ? "" : " UNUSED");
   dump (1, "{");
 
-  for (sbc = subcommands; sbc; sbc = sbc->next)
-    if (sbc->type == SBC_STRING)
-      dump (0, "free (p->s_%s);", st_lower (sbc->name));
+  if ( ! persistent ) 
+    {
+
+      for (sbc = subcommands; sbc; sbc = sbc->next)
+	{
+	  switch (sbc->type) 
+	    {
+	    case SBC_STRING:
+	      dump (0, "free (p->s_%s);", st_lower (sbc->name));
+	      break;
+	    case SBC_DBL_LIST:
+	      dump (0, "int i;");
+	      dump (1, "for(i = 0; i < MAXLISTS ; ++i)");
+	      dump (0, "subc_list_double_destroy(&p->dl_%s[i]);", st_lower (sbc->name));
+	      outdent();
+	      break;
+	    default:
+	      break;
+	    }
+	}
+    }
 
   dump (-1, "}");
+
 }
 
+
+
 /* Returns the name of a directive found on the current input line, if
    any, or a null pointer if none found. */
 static const char *
@@ -1771,6 +2106,8 @@ recognize_directive (void)
   return directive;
 }
   
+static void aux_parse (void);
+
 int
 main (int argc, char *argv[])
 {
@@ -1794,6 +2131,7 @@ main (int argc, char *argv[])
 
   dump_header ();
 
+
   indent = 0;
   dump (0, "#line %d \"%s\"", ln + 1, ifn);
   while (get_line ())
@@ -1805,7 +2143,7 @@ main (int argc, char *argv[])
 	  continue;
 	}
       
-      dump (0, "#line %d \"%s\"", oln - 1, ofn);
+      dump (0, "#line %d \"%s\"", oln + 1, ofn);
       if (!strcmp (directive, "specification"))
 	{
 	  /* Skip leading slash-star line. */
@@ -1821,21 +2159,33 @@ main (int argc, char *argv[])
 	{
 	  indent = 0;
 
-	  dump (0, "#include <assert.h>");
 	  dump (0, "#include <stdlib.h>");
 	  dump (0, "#include \"alloc.h\"");
 	  dump (0, "#include \"error.h\"");
 	  dump (0, "#include \"lexer.h\"");
+          dump (0, "#include \"settings.h\"");
 	  dump (0, "#include \"str.h\"");
+          dump (0, "#include \"subclist.h\"");
 	  dump (0, "#include \"var.h\"");
+
 	  dump (0, nullstr);
 	}
       else if (!strcmp (directive, "declarations"))
 	dump_declarations ();
       else if (!strcmp (directive, "functions"))
 	{
-	  dump_parser ();
-	  dump_free ();
+	  dump_parser (0);
+	  dump_free (0); 
+	}
+      else if (!strcmp (directive, "_functions"))
+	{
+	  dump_parser (1);
+	  dump_free (1); 
+	}
+      else if (!strcmp (directive, "aux_functions"))
+	{
+	  aux_parse();
+	  dump_aux_parser ();
 	}
       else
 	error ("unknown directive `%s'", directive);
@@ -1843,6 +2193,38 @@ main (int argc, char *argv[])
       dump (0, "#line %d \"%s\"", ln + 1, ifn);
     }
 
+
+
   return EXIT_SUCCESS;
 }
 
+/* Parse an entire auxilliary specification. */
+static void
+aux_parse (void)
+{
+  aux_subcommand *sbc;
+  aux_subcommand *prevsbc = 0 ;
+  get_line();
+  lex_get();
+
+  for (;;)
+    {
+	sbc = xmalloc(sizeof(aux_subcommand));
+	sbc->next = prevsbc;
+        sbc->name = xstrdup (tokstr);
+	lex_get();
+	skip_token('=');
+	sbc->value = xstrdup (tokstr);
+	lex_get();
+      if (token == '.')
+	break;
+	skip_token(';');
+	prevsbc = sbc;
+
+    }
+  /* Skip trailing star-slash line. */
+  get_line ();
+  aux_subcommands = sbc;
+}
+
+