pintos-os.org Git - pspp/blob - src/q2c.c

   1 /* q2c - parser generator for PSPP procedures.
   2    Copyright (C) 1997-9, 2000 Free Software Foundation, Inc.
   3    Written by Ben Pfaff <blp@gnu.org>.
   4
   5    This program is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU General Public License as
   7    published by the Free Software Foundation; either version 2 of the
   8    License, or (at your option) any later version.
   9
  10    This program is distributed in the hope that it will be useful, but
  11    WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program; if not, write to the Free Software
  17    Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  18    02111-1307, USA. */
  19
  20 #include <config.h>
  21 #include <assert.h>
  22 #include <ctype.h>
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25 #include <stdarg.h>
  26 #include <time.h>
  27 #include <errno.h>
  28 #if HAVE_UNISTD_H
  29 #include <unistd.h>
  30 #endif
  31 #include "str.h"
  32
  33 /* Brokenness. */
  34 #ifndef EXIT_SUCCESS
  35 #define EXIT_SUCCESS 0
  36 #endif
  37
  38 #ifndef EXIT_FAILURE
  39 #define EXIT_FAILURE 1
  40 #endif
  41
  42 #if !HAVE_STRERROR
  43 #include "misc/strerror.c"
  44 #endif
  45
  46 #undef DEBUGGING
  47 /*#define DEBUGGING 1*/
  48 #include "debug-print.h"
  49
  50 /* Max length of an input line. */
  51 #define MAX_LINE_LEN 1024
  52
  53 /* Max token length. */
  54 #define MAX_TOK_LEN 1024
  55
  56 /* argv[0]. */
  57 char *pgmname;
  58
  59 /* Have the input and output files been opened yet? */
  60 int is_open;
  61
  62 /* Input, output files. */
  63 FILE *in, *out;
  64
  65 /* Input, output file names. */
  66 char *ifn, *ofn;
  67
  68 /* Input, output file line number. */
  69 int ln, oln = 1;
  70
  71 /* Input line buffer, current position. */
  72 char *buf, *cp;
  73
  74 /* Token types. */
  75 enum
  76   {
  77     T_STRING = 256,     /* String literal. */
  78     T_ID = 257          /* Identifier.  */
  79   };
  80
  81 /* Current token: either one of the above, or a single character. */
  82 int token;
  83
  84 /* Token string value. */
  85 char *tokstr;
  86 \f
  87 /* Utility functions. */
  88
  89 char nullstr[] = "";
  90
  91 /* Close all open files and delete the output file, on failure. */
  92 void
  93 finish_up (void)
  94 {
  95   if (!is_open)
  96     return;
  97   is_open = 0;
  98   fclose (in);
  99   fclose (out);
 100   if (remove (ofn) == -1)
 101     fprintf (stderr, "%s: %s: remove: %s\n", pgmname, ofn, strerror (errno));
 102 }
 103
 104 #if __GNUC__ >= 2
 105 void hcf (void) __attribute__ ((noreturn));
 106 #endif
 107
 108 /* Terminate unsuccessfully. */
 109 void
 110 hcf (void)
 111 {
 112   finish_up ();
 113   exit (EXIT_FAILURE);
 114 }
 115
 116 #if __GNUC__ >= 2
 117 int fail (const char *, ...) __attribute__ ((format (printf, 1, 2)));
 118 int error (const char *, ...) __attribute__ ((format (printf, 1, 2)));
 119 #endif
 120
 121 /* Output an error message and terminate unsuccessfully. */
 122 int
 123 fail (const char *format, ...)
 124 {
 125   va_list args;
 126
 127   va_start (args, format);
 128   fprintf (stderr, "%s: ", pgmname);
 129   vfprintf (stderr, format, args);
 130   fprintf (stderr, "\n");
 131   va_end (args);
 132
 133   hcf ();
 134 }
 135
 136 /* Output a context-dependent error message and terminate
 137    unsuccessfully. */
 138 int
 139 error (const char *format,...)
 140 {
 141   va_list args;
 142
 143   va_start (args, format);
 144   fprintf (stderr, "%s:%d: (column %d) ", ifn, ln, (int) (cp - buf));
 145   vfprintf (stderr, format, args);
 146   fprintf (stderr, "\n");
 147   va_end (args);
 148
 149   hcf ();
 150 }
 151
 152 #define VME "virtual memory exhausted"
 153
 154 /* Allocate a block of SIZE bytes and return a pointer to its
 155    beginning. */
 156 void *
 157 xmalloc (size_t size)
 158 {
 159   void *vp;
 160
 161   if (size == 0)
 162     return NULL;
 163
 164   vp = malloc (size);
 165   if (!vp)
 166     fail ("xmalloc(%lu): %s", (unsigned long) size, VME);
 167
 168   return vp;
 169 }
 170
 171 /* Resize the block at PTR to size SIZE and return a pointer to the
 172    beginning of the new block. */
 173 void *
 174 xrealloc (void *ptr, size_t size)
 175 {
 176   void *vp;
 177
 178   if (!size)
 179     {
 180       if (ptr)
 181         free (ptr);
 182       return NULL;
 183     }
 184
 185   if (ptr)
 186     vp = realloc (ptr, size);
 187   else
 188     vp = malloc (size);
 189
 190   if (!vp)
 191     fail ("xrealloc(%lu): %s", (unsigned long) size, VME);
 192
 193   return vp;
 194 }
 195
 196 /* Make a dynamically allocated copy of string S and return a pointer
 197    to the first character. */
 198 char *
 199 xstrdup (const char *s)
 200 {
 201   size_t size;
 202   char *t;
 203
 204   assert (s != NULL);
 205   size = strlen (s) + 1;
 206
 207   t = malloc (size);
 208   if (!t)
 209     fail ("xstrdup(%lu): %s", (unsigned long) strlen (s), VME);
 210
 211   memcpy (t, s, size);
 212   return t;
 213 }
 214
 215 /* Returns a pointer to one of 8 static buffers.  The buffers are used
 216    in rotation. */
 217 char *
 218 get_buffer (void)
 219 {
 220   static char b[8][256];
 221   static int cb;
 222
 223   if (++cb >= 8)
 224     cb = 0;
 225
 226   return b[cb];
 227 }
 228
 229 /* Copies a string to a static buffer, converting it to lowercase in
 230    the process, and returns a pointer to the static buffer. */
 231 char *
 232 st_lower (const char *s)
 233 {
 234   char *p, *cp;
 235
 236   p = cp = get_buffer ();
 237   while (*s)
 238     *cp++ = tolower ((unsigned char) (*s++));
 239   *cp++ = '\0';
 240
 241   return p;
 242 }
 243
 244 /* Copies a string to a static buffer, converting it to uppercase in
 245    the process, and returns a pointer to the static buffer. */
 246 char *
 247 st_upper (const char *s)
 248 {
 249   char *p, *cp;
 250
 251   p = cp = get_buffer ();
 252   while (*s)
 253     *cp++ = toupper ((unsigned char) (*s++));
 254   *cp++ = '\0';
 255
 256   return p;
 257 }
 258
 259 /* Returns the address of the first non-whitespace character in S, or
 260    the address of the null terminator if none. */
 261 char *
 262 skip_ws (const char *s)
 263 {
 264   while (isspace ((unsigned char) *s))
 265     s++;
 266   return (char *) s;
 267 }
 268
 269 /* Read one line from the input file into buf.  Lines having special
 270    formats are handled specially. */
 271 int
 272 get_line (void)
 273 {
 274   ln++;
 275   if (0 == fgets (buf, MAX_LINE_LEN, in))
 276     {
 277       if (ferror (in))
 278         fail ("%s: fgets: %s", ifn, strerror (errno));
 279       return 0;
 280     }
 281
 282   cp = strchr (buf, '\n');
 283   if (cp != NULL)
 284     *cp = '\0';
 285
 286   cp = buf;
 287   return 1;
 288 }
 289 \f
 290 /* Symbol table manager. */
 291
 292 /* Symbol table entry. */
 293 typedef struct symbol symbol;
 294 struct symbol
 295   {
 296     symbol *next;               /* Next symbol in symbol table. */
 297     char *name;                 /* Symbol name. */
 298     int unique;                 /* 1=Name must be unique in this file. */
 299     int ln;                     /* Line number of definition. */
 300     int value;                  /* Symbol value. */
 301   };
 302
 303 /* Symbol table. */
 304 symbol *symtab;
 305
 306 /* Add a symbol to the symbol table having name NAME, uniqueness
 307    UNIQUE, and value VALUE.  If a symbol having the same name is found
 308    in the symbol table, its sequence number is returned and the symbol
 309    table is not modified.  Otherwise, the symbol is added and the next
 310    available sequence number is returned. */
 311 int
 312 add_symbol (const char *name, int unique, int value)
 313 {
 314   symbol *iter, *sym;
 315   int x;
 316
 317   sym = xmalloc (sizeof (symbol));
 318   sym->name = xstrdup (name);
 319   sym->unique = unique;
 320   sym->value = value;
 321   sym->next = NULL;
 322   sym->ln = ln;
 323   if (!symtab)
 324     {
 325       symtab = sym;
 326       return 1;
 327     }
 328   iter = symtab;
 329   x = 1;
 330   for (;;)
 331     {
 332       if (!strcmp (iter->name, name))
 333         {
 334           if (iter->unique)
 335             {
 336               fprintf (stderr, "%s:%d: `%s' is already defined above\n", ifn,
 337                        ln, name);
 338               fprintf (stderr, "%s:%d: location of previous definition\n", ifn,
 339                        iter->ln);
 340               hcf ();
 341             }
 342           free (sym->name);
 343           free (sym);
 344           return x;
 345         }
 346       if (!iter->next)
 347         break;
 348       iter = iter->next;
 349       x++;
 350     }
 351   iter->next = sym;
 352   return ++x;
 353 }
 354
 355 /* Finds the symbol having given sequence number X within the symbol
 356    table, and returns the associated symbol structure. */
 357 symbol *
 358 find_symbol (int x)
 359 {
 360   symbol *iter;
 361
 362   iter = symtab;
 363   while (x > 1 && iter)
 364     {
 365       iter = iter->next;
 366       x--;
 367     }
 368   assert (iter);
 369   return iter;
 370 }
 371
 372 #if DEBUGGING
 373 /* Writes a printable representation of the current token to
 374    stdout. */
 375 void
 376 dump_token (void)
 377 {
 378   switch (token)
 379     {
 380     case T_STRING:
 381       printf ("STRING\t\"%s\"\n", tokstr);
 382       break;
 383     case T_ID:
 384       printf ("ID\t%s\n", tokstr);
 385       break;
 386     default:
 387       printf ("PUNCT\t%c\n", token);
 388     }
 389 }
 390 #endif /* DEBUGGING */
 391
 392 /* Reads a token from the input file. */
 393 int
 394 lex_get (void)
 395 {
 396   /* Skip whitespace and check for end of file. */
 397   for (;;)
 398     {
 399       cp = skip_ws (cp);
 400       if (*cp != '\0')
 401         break;
 402
 403       if (!get_line ())
 404         fail ("%s: Unexpected end of file.", ifn);
 405     }
 406
 407   if (*cp == '_' || isalnum ((unsigned char) *cp))
 408     {
 409       char *dest = tokstr;
 410       token = T_ID;
 411       while (*cp == '_' || isalnum ((unsigned char) *cp))
 412         *dest++ = toupper ((unsigned char) (*cp++));
 413       *dest++ = '\0';
 414     }
 415   else if (*cp == '"')
 416     {
 417       char *dest = tokstr;
 418       token = T_STRING;
 419       cp++;
 420       while (*cp != '"' && *cp)
 421         {
 422           if (*cp == '\\')
 423             {
 424               cp++;
 425               if (!*cp)
 426                 error ("Unterminated string literal.");
 427               *dest++ = *cp++;
 428             }
 429           else
 430             *dest++ = *cp++;
 431         }
 432       *dest++ = 0;
 433       if (!*cp)
 434         error ("Unterminated string literal.");
 435       cp++;
 436     }
 437   else
 438     token = *cp++;
 439
 440 #if DEBUGGING
 441   dump_token ();
 442 #endif
 443
 444   return token;
 445 }
 446
 447 /* Force the current token to be an identifier token. */
 448 void
 449 force_id (void)
 450 {
 451   if (token != T_ID)
 452     error ("Identifier expected.");
 453 }
 454
 455 /* Force the current token to be a string token. */
 456 void
 457 force_string (void)
 458 {
 459   if (token != T_STRING)
 460     error ("String expected.");
 461 }
 462
 463 /* Checks whether the current token is the identifier S; if so, skips
 464    the token and returns 1; otherwise, returns 0. */
 465 int
 466 match_id (const char *s)
 467 {
 468   if (token == T_ID && !strcmp (tokstr, s))
 469     {
 470       lex_get ();
 471       return 1;
 472     }
 473   return 0;
 474 }
 475
 476 /* Checks whether the current token is T.  If so, skips the token and
 477    returns 1; otherwise, returns 0. */
 478 int
 479 match_token (int t)
 480 {
 481   if (token == t)
 482     {
 483       lex_get ();
 484       return 1;
 485     }
 486   return 0;
 487 }
 488
 489 /* Force the current token to be T, and skip it. */
 490 void
 491 skip_token (int t)
 492 {
 493   if (token != t)
 494     error ("`%c' expected.", t);
 495   lex_get ();
 496 }
 497 \f
 498 /* Structures. */
 499
 500 /* Some specifiers have associated values. */
 501 enum
 502   {
 503     VAL_NONE,   /* No value. */
 504     VAL_INT,    /* Integer value. */
 505     VAL_DBL     /* Floating point value. */
 506   };
 507
 508 /* For those specifiers with values, the syntax of those values. */
 509 enum
 510   {
 511     VT_PLAIN,   /* Unadorned value. */
 512     VT_PAREN    /* Value must be enclosed in parentheses. */
 513   };
 514
 515 /* Forward definition. */
 516 typedef struct specifier specifier;
 517
 518 /* A single setting. */
 519 typedef struct setting setting;
 520 struct setting
 521   {
 522     specifier *parent;  /* Owning specifier. */
 523     setting *next;      /* Next in the chain. */
 524     char *specname;     /* Name of the setting. */
 525     int con;            /* Sequence number. */
 526
 527     /* Values. */
 528     int valtype;        /* One of VT_*. */
 529     int value;          /* One of VAL_*. */
 530     int optvalue;       /* 1=value is optional, 0=value is required. */
 531     char *valname;      /* Variable name for the value. */
 532     char *restriction;  /* !=NULL: expression specifying valid values. */
 533   };
 534
 535 /* A single specifier. */
 536 struct specifier
 537   {
 538     specifier *next;    /* Next in the chain. */
 539     char *varname;      /* Variable name. */
 540     setting *s;         /* Associated settings. */
 541
 542     setting *def;       /* Default setting. */
 543     setting *omit_kw;   /* Setting for which the keyword can be omitted. */
 544
 545     int index;          /* Next array index. */
 546   };
 547
 548 /* Subcommand types. */
 549 typedef enum
 550   {
 551     SBC_PLAIN,          /* The usual case. */
 552     SBC_VARLIST,        /* Variable list. */
 553     SBC_INT,            /* Integer value. */
 554     SBC_PINT,           /* Integer inside parentheses. */
 555     SBC_DBL,            /* Floating point value. */
 556     SBC_INT_LIST,       /* List of integers (?). */
 557     SBC_DBL_LIST,       /* List of floating points (?). */
 558     SBC_CUSTOM,         /* Custom. */
 559     SBC_ARRAY,          /* Array of boolean values. */
 560     SBC_STRING,         /* String value. */
 561     SBC_VAR             /* Single variable name. */
 562   }
 563 subcommand_type;
 564
 565 /* A single subcommand. */
 566 typedef struct subcommand subcommand;
 567 struct subcommand
 568   {
 569     subcommand *next;           /* Next in the chain. */
 570     char *name;                 /* Subcommand name. */
 571     subcommand_type type;       /* One of SBC_*. */
 572     int once;                   /* 1=Subcommand may appear only once. */
 573     int narray;                 /* Index of next array element. */
 574     const char *prefix;         /* Prefix for variable and constant names. */
 575     specifier *spec;            /* Array of specifiers. */
 576
 577     /* SBC_STRING only. */
 578     char *restriction;          /* Expression restricting string length. */
 579     char *message;              /* Error message. */
 580   };
 581
 582 /* Name of the command; i.e., DESCRIPTIVES. */
 583 char *cmdname;
 584
 585 /* Short prefix for the command; i.e., `dsc_'. */
 586 char *prefix;
 587
 588 /* List of subcommands. */
 589 subcommand *subcommands;
 590
 591 /* Default subcommand if any, or NULL. */
 592 subcommand *def;
 593 \f
 594 /* Parsing. */
 595
 596 void parse_subcommands (void);
 597
 598 /* Parse an entire specification. */
 599 void
 600 parse (void)
 601 {
 602   /* Get the command name and prefix. */
 603   if (token != T_STRING && token != T_ID)
 604     error ("Command name expected.");
 605   cmdname = xstrdup (tokstr);
 606   lex_get ();
 607   skip_token ('(');
 608   force_id ();
 609   prefix = xstrdup (tokstr);
 610   lex_get ();
 611   skip_token (')');
 612   skip_token (':');
 613
 614   /* Read all the subcommands. */
 615   subcommands = NULL;
 616   def = NULL;
 617   parse_subcommands ();
 618 }
 619
 620 /* Parses a single setting into S, given subcommand information SBC
 621    and specifier information SPEC. */
 622 void
 623 parse_setting (setting *s, specifier *spec)
 624 {
 625   s->parent = spec;
 626
 627   if (match_token ('*'))
 628     {
 629       if (spec->omit_kw)
 630         error ("Cannot have two settings with omittable keywords.");
 631       else
 632         spec->omit_kw = s;
 633     }
 634
 635   if (match_token ('!'))
 636     {
 637       if (spec->def)
 638         error ("Cannot have two default settings.");
 639       else
 640         spec->def = s;
 641     }
 642
 643   force_id ();
 644   s->specname = xstrdup (tokstr);
 645   s->con = add_symbol (s->specname, 0, 0);
 646   s->value = VAL_NONE;
 647
 648   lex_get ();
 649
 650   /* Parse setting value info if necessary. */
 651   if (token != '/' && token != ';' && token != '.' && token != ',')
 652     {
 653       if (token == '(')
 654         {
 655           s->valtype = VT_PAREN;
 656           lex_get ();
 657         }
 658       else
 659         s->valtype = VT_PLAIN;
 660
 661       s->optvalue = match_token ('*');
 662
 663       if (match_id ("N"))
 664         s->value = VAL_INT;
 665       else if (match_id ("D"))
 666         s->value = VAL_DBL;
 667       else
 668         error ("`n' or `d' expected.");
 669
 670       skip_token (':');
 671
 672       force_id ();
 673       s->valname = xstrdup (tokstr);
 674       lex_get ();
 675
 676       if (token == ',')
 677         {
 678           lex_get ();
 679           force_string ();
 680           s->restriction = xstrdup (tokstr);
 681           lex_get ();
 682         }
 683       else
 684         s->restriction = NULL;
 685
 686       if (s->valtype == VT_PAREN)
 687         skip_token (')');
 688     }
 689 }
 690
 691 /* Parse a single specifier into SPEC, given subcommand information
 692    SBC. */
 693 void
 694 parse_specifier (specifier *spec, subcommand *sbc)
 695 {
 696   spec->index = 0;
 697   spec->s = NULL;
 698   spec->def = NULL;
 699   spec->omit_kw = NULL;
 700   spec->varname = NULL;
 701
 702   if (token == T_ID)
 703     {
 704       spec->varname = xstrdup (st_lower (tokstr));
 705       lex_get ();
 706     }
 707
 708   /* Handle array elements. */
 709   if (token != ':')
 710     {
 711       spec->index = sbc->narray;
 712       if (sbc->type == SBC_ARRAY)
 713         {
 714           if (token == '|')
 715             token = ',';
 716           else
 717             sbc->narray++;
 718         }
 719       spec->s = NULL;
 720       return;
 721     }
 722   skip_token (':');
 723
 724   /* Parse all the settings. */
 725   {
 726     setting **s = &spec->s;
 727
 728     for (;;)
 729       {
 730         *s = xmalloc (sizeof (setting));
 731         parse_setting (*s, spec);
 732         if (token == ',' || token == ';' || token == '.')
 733           break;
 734         skip_token ('/');
 735         s = &(*s)->next;
 736       }
 737     (*s)->next = NULL;
 738   }
 739 }
 740
 741 /* Parse a list of specifiers for subcommand SBC. */
 742 void
 743 parse_specifiers (subcommand *sbc)
 744 {
 745   specifier **spec = &sbc->spec;
 746
 747   if (token == ';' || token == '.')
 748     {
 749       *spec = NULL;
 750       return;
 751     }
 752
 753   for (;;)
 754     {
 755       *spec = xmalloc (sizeof (specifier));
 756       parse_specifier (*spec, sbc);
 757       if (token == ';' || token == '.')
 758         break;
 759       skip_token (',');
 760       spec = &(*spec)->next;
 761     }
 762   (*spec)->next = NULL;
 763 }
 764
 765 /* Parse a subcommand into SBC. */
 766 void
 767 parse_subcommand (subcommand *sbc)
 768 {
 769   if (match_token ('*'))
 770     {
 771       if (def)
 772         error ("Multiple default subcommands.");
 773       def = sbc;
 774     }
 775
 776   sbc->once = match_token ('+');
 777
 778   force_id ();
 779   sbc->name = xstrdup (tokstr);
 780   lex_get ();
 781
 782   sbc->narray = 0;
 783   sbc->type = SBC_PLAIN;
 784   sbc->spec = NULL;
 785
 786   if (match_token ('['))
 787     {
 788       force_id ();
 789       sbc->prefix = xstrdup (st_lower (tokstr));
 790       lex_get ();
 791
 792       skip_token (']');
 793       skip_token ('=');
 794
 795       sbc->type = SBC_ARRAY;
 796       parse_specifiers (sbc);
 797     }
 798   else
 799     {
 800       if (match_token ('('))
 801         {
 802           force_id ();
 803           sbc->prefix = xstrdup (st_lower (tokstr));
 804           lex_get ();
 805
 806           skip_token (')');
 807         }
 808       else
 809         sbc->prefix = "";
 810
 811       skip_token ('=');
 812
 813       if (match_id ("VAR"))
 814         sbc->type = SBC_VAR;
 815       if (match_id ("VARLIST"))
 816         {
 817           if (match_token ('('))
 818             {
 819               force_string ();
 820               sbc->message = xstrdup (tokstr);
 821               lex_get();
 822
 823               skip_token (')');
 824             }
 825           else sbc->message = NULL;
 826
 827           sbc->type = SBC_VARLIST;
 828         }
 829       else if (match_id ("INTEGER"))
 830         sbc->type = match_id ("LIST") ? SBC_INT_LIST : SBC_INT;
 831       else if (match_id ("PINT"))
 832         sbc->type = SBC_PINT;
 833       else if (match_id ("DOUBLE"))
 834         sbc->type = match_id ("LIST") ? SBC_DBL_LIST : SBC_DBL;
 835       else if (match_id ("STRING"))
 836         {
 837           sbc->type = SBC_STRING;
 838           if (token == T_STRING)
 839             {
 840               sbc->restriction = xstrdup (tokstr);
 841               lex_get ();
 842               force_string ();
 843               sbc->message = xstrdup (tokstr);
 844               lex_get ();
 845             }
 846           else
 847             sbc->restriction = NULL;
 848         }
 849       else if (match_id ("CUSTOM"))
 850         sbc->type = SBC_CUSTOM;
 851       else
 852         parse_specifiers (sbc);
 853     }
 854 }
 855
 856 /* Parse all the subcommands. */
 857 void
 858 parse_subcommands (void)
 859 {
 860   subcommand **sbc = &subcommands;
 861
 862   for (;;)
 863     {
 864       *sbc = xmalloc (sizeof (subcommand));
 865       (*sbc)->next = NULL;
 866
 867       parse_subcommand (*sbc);
 868
 869       if (token == '.')
 870         return;
 871
 872       skip_token (';');
 873       sbc = &(*sbc)->next;
 874     }
 875 }
 876 \f
 877 /* Output. */
 878
 879 #define BASE_INDENT 2           /* Starting indent. */
 880 #define INC_INDENT 2            /* Indent increment. */
 881
 882 /* Increment the indent. */
 883 #define indent() indent += INC_INDENT
 884 #define outdent() indent -= INC_INDENT
 885
 886 /* Size of the indent from the left margin. */
 887 int indent;
 888
 889 #if __GNUC__ >= 2
 890 void dump (int, const char *, ...) __attribute__ ((format (printf, 2, 3)));
 891 #endif
 892
 893 /* Write line FORMAT to the output file, formatted as with printf,
 894    indented `indent' characters from the left margin.  If INDENTION is
 895    greater than 0, indents BASE_INDENT * INDENTION characters after
 896    writing the line; if INDENTION is less than 0, dedents BASE_INDENT
 897    * INDENTION characters _before_ writing the line. */
 898 void
 899 dump (int indention, const char *format, ...)
 900 {
 901   va_list args;
 902   int i;
 903
 904   if (indention < 0)
 905     indent += BASE_INDENT * indention;
 906
 907   oln++;
 908   va_start (args, format);
 909   for (i = 0; i < indent; i++)
 910     putc (' ', out);
 911   vfprintf (out, format, args);
 912   putc ('\n', out);
 913   va_end (args);
 914
 915   if (indention > 0)
 916     indent += BASE_INDENT * indention;
 917 }
 918
 919 /* Write the structure members for specifier SPEC to the output file.
 920    SBC is the including subcommand. */
 921 void
 922 dump_specifier_vars (const specifier *spec, const subcommand *sbc)
 923 {
 924   if (spec->varname)
 925     dump (0, "long %s%s;", sbc->prefix, spec->varname);
 926
 927   {
 928     setting *s;
 929
 930     for (s = spec->s; s; s = s->next)
 931       {
 932         if (s->value != VAL_NONE)
 933           {
 934             const char *typename;
 935
 936             assert (s->value == VAL_INT || s->value == VAL_DBL);
 937             typename = s->value == VAL_INT ? "long" : "double";
 938
 939             dump (0, "%s %s%s;", typename, sbc->prefix, st_lower (s->valname));
 940           }
 941       }
 942   }
 943 }
 944
 945 /* Returns 1 if string T is a PSPP keyword, 0 otherwise. */
 946 int
 947 is_keyword (const char *t)
 948 {
 949   static const char *kw[] =
 950     {
 951       "AND", "OR", "NOT", "EQ", "GE", "GT", "LE", "LT",
 952       "NE", "ALL", "BY", "TO", "WITH", 0,
 953     };
 954   const char **cp;
 955
 956   for (cp = kw; *cp; cp++)
 957     if (!strcmp (t, *cp))
 958       return 1;
 959   return 0;
 960 }
 961
 962 /* Transforms a string NAME into a valid C identifier: makes
 963    everything lowercase and maps nonalphabetic characters to
 964    underscores.  Returns a pointer to a static buffer. */
 965 char *
 966 make_identifier (const char *name)
 967 {
 968   char *p = get_buffer ();
 969   char *cp;
 970
 971   for (cp = p; *name; name++)
 972     if (isalpha ((unsigned char) *name))
 973       *cp++ = tolower ((unsigned char) (*name));
 974     else
 975       *cp++ = '_';
 976   *cp = '\0';
 977
 978   return p;
 979 }
 980
 981 /* Writes the struct and enum declarations for the parser. */
 982 void
 983 dump_declarations (void)
 984 {
 985   indent = 0;
 986
 987   /* Write out enums for all the identifiers in the symbol table. */
 988   {
 989     int f, k;
 990     symbol *sym;
 991     char *buf = NULL;
 992
 993     /* Note the squirmings necessary to make sure that the last enum
 994        is not followed by a comma, as mandated by ANSI C89. */
 995     for (sym = symtab, f = k = 0; sym; sym = sym->next)
 996       if (!sym->unique && !is_keyword (sym->name))
 997         {
 998           if (!f)
 999             {
1000               dump (0, "/* Settings for subcommand specifiers. */");
1001               dump (1, "enum");
1002               dump (1, "{");
1003               f = 1;
1004             }
1005
1006           if (buf == NULL)
1007             buf = xmalloc (1024);
1008           else
1009             dump (0, buf);
1010
1011           if (k)
1012             sprintf (buf, "%s%s,", st_upper (prefix), sym->name);
1013           else
1014             {
1015               k = 1;
1016               sprintf (buf, "%s%s = 1000,", st_upper (prefix), sym->name);
1017             }
1018         }
1019     if (buf)
1020       {
1021         buf[strlen (buf) - 1] = 0;
1022         dump (0, buf);
1023         free (buf);
1024       }
1025     if (f)
1026       {
1027         dump (-1, "};");
1028         dump (-1, nullstr);
1029       }
1030   }
1031
1032   /* For every array subcommand, write out the associated enumerated
1033      values. */
1034   {
1035     subcommand *sbc;
1036
1037     for (sbc = subcommands; sbc; sbc = sbc->next)
1038       if (sbc->type == SBC_ARRAY && sbc->narray)
1039         {
1040           dump (0, "/* Array indices for %s subcommand. */", sbc->name);
1041
1042           dump (1, "enum");
1043           dump (1, "{");
1044
1045           {
1046             specifier *spec;
1047
1048             for (spec = sbc->spec; spec; spec = spec->next)
1049               if (!spec->s)
1050                 dump (0, "%s%s%s = %d,",
1051                       st_upper (prefix), st_upper (sbc->prefix),
1052                       st_upper (spec->varname), spec->index);
1053
1054             dump (0, "%s%scount", st_upper (prefix), st_upper (sbc->prefix));
1055
1056             dump (-1, "};");
1057             dump (-1, nullstr);
1058           }
1059         }
1060   }
1061
1062   /* Write out structure declaration. */
1063   {
1064     subcommand *sbc;
1065
1066     dump (0, "/* %s structure. */", cmdname);
1067     dump (1, "struct cmd_%s", make_identifier (cmdname));
1068     dump (1, "{");
1069     for (sbc = subcommands; sbc; sbc = sbc->next)
1070       {
1071         int f = 0;
1072
1073         if (sbc != subcommands)
1074           dump (0, nullstr);
1075
1076         dump (0, "/* %s subcommand. */", sbc->name);
1077         dump (0, "int sbc_%s;", st_lower (sbc->name));
1078
1079         switch (sbc->type)
1080           {
1081           case SBC_ARRAY:
1082           case SBC_PLAIN:
1083             {
1084               specifier *spec;
1085
1086               for (spec = sbc->spec; spec; spec = spec->next)
1087                 {
1088                   if (spec->s == 0)
1089                     {
1090                       if (sbc->type == SBC_PLAIN)
1091                         dump (0, "long int %s%s;", st_lower (sbc->prefix),
1092                               spec->varname);
1093                       else if (f == 0)
1094                         {
1095                           dump (0, "int a_%s[%d];",
1096                                 st_lower (sbc->name), sbc->narray);
1097                           f = 1;
1098                         }
1099                     }
1100                   else
1101                     dump_specifier_vars (spec, sbc);
1102                 }
1103             }
1104             break;
1105
1106           case SBC_VARLIST:
1107             dump (0, "int %sn_%s;", st_lower (sbc->prefix),
1108                   st_lower (sbc->name));
1109             dump (0, "struct variable **%sv_%s;", st_lower (sbc->prefix),
1110                   st_lower (sbc->name));
1111             break;
1112
1113           case SBC_VAR:
1114             dump (0, "struct variable *%sv_%s;", st_lower (sbc->prefix),
1115                   st_lower (sbc->name));
1116             break;
1117
1118           case SBC_STRING:
1119             dump (0, "char *s_%s;", st_lower (sbc->name));
1120             break;
1121
1122           case SBC_INT:
1123           case SBC_PINT:
1124             dump (0, "long n_%s;", st_lower (sbc->name));
1125             break;
1126
1127           default:;
1128             /* nothing */
1129           }
1130       }
1131
1132     dump (-1, "};");
1133     dump (-1, nullstr);
1134   }
1135
1136   /* Write out prototypes for custom_*() functions as necessary. */
1137   {
1138     int seen = 0;
1139     subcommand *sbc;
1140
1141     for (sbc = subcommands; sbc; sbc = sbc->next)
1142       if (sbc->type == SBC_CUSTOM)
1143         {
1144           if (!seen)
1145             {
1146               seen = 1;
1147               dump (0, "/* Prototype for custom subcommands of %s. */",
1148                     cmdname);
1149             }
1150           dump (0, "static int %scustom_%s (struct cmd_%s *);",
1151                 st_lower (prefix), st_lower (sbc->name),
1152                 make_identifier (cmdname));
1153         }
1154
1155     if (seen)
1156       dump (0, nullstr);
1157   }
1158
1159   /* Prototypes for parsing and freeing functions. */
1160   {
1161     dump (0, "/* Command parsing functions. */");
1162     dump (0, "static int parse_%s (struct cmd_%s *);",
1163           make_identifier (cmdname), make_identifier (cmdname));
1164     dump (0, "static void free_%s (struct cmd_%s *);",
1165           make_identifier (cmdname), make_identifier (cmdname));
1166     dump (0, nullstr);
1167   }
1168 }
1169
1170 /* Writes out code to initialize all the variables that need
1171    initialization for particular specifier SPEC inside subcommand SBC. */
1172 void
1173 dump_specifier_init (const specifier *spec, const subcommand *sbc)
1174 {
1175   if (spec->varname)
1176     {
1177       char s[256];
1178
1179       if (spec->def)
1180         sprintf (s, "%s%s",
1181                  st_upper (prefix), find_symbol (spec->def->con)->name);
1182       else
1183         strcpy (s, "-1");
1184       dump (0, "p->%s%s = %s;", sbc->prefix, spec->varname, s);
1185     }
1186
1187   {
1188     setting *s;
1189
1190     for (s = spec->s; s; s = s->next)
1191       {
1192         if (s->value != VAL_NONE)
1193           {
1194             const char *init;
1195
1196             assert (s->value == VAL_INT || s->value == VAL_DBL);
1197             init = s->value == VAL_INT ? "NOT_LONG" : "SYSMIS";
1198
1199             dump (0, "p->%s%s = %s;", sbc->prefix, st_lower (s->valname), init);
1200           }
1201       }
1202   }
1203 }
1204
1205 /* Write code to initialize all variables. */
1206 void
1207 dump_vars_init (void)
1208 {
1209   /* Loop through all the subcommands. */
1210   {
1211     subcommand *sbc;
1212
1213     for (sbc = subcommands; sbc; sbc = sbc->next)
1214       {
1215         int f = 0;
1216
1217         dump (0, "p->sbc_%s = 0;", st_lower (sbc->name));
1218         switch (sbc->type)
1219           {
1220           case SBC_DBL:
1221           case SBC_INT_LIST:
1222           case SBC_DBL_LIST:
1223           case SBC_CUSTOM:
1224             /* nothing */
1225             break;
1226
1227           case SBC_PLAIN:
1228           case SBC_ARRAY:
1229             {
1230               specifier *spec;
1231
1232               for (spec = sbc->spec; spec; spec = spec->next)
1233                 if (spec->s == NULL)
1234                   {
1235                     if (sbc->type == SBC_PLAIN)
1236                       dump (0, "p->%s%s = 0;", sbc->prefix, spec->varname);
1237                     else if (f == 0)
1238                       {
1239                         dump (0, "memset (p->a_%s, 0, sizeof p->a_%s);",
1240                               st_lower (sbc->name), st_lower (sbc->name));
1241                         f = 1;
1242                       }
1243                   }
1244                 else
1245                   dump_specifier_init (spec, sbc);
1246             }
1247             break;
1248
1249           case SBC_VARLIST:
1250             dump (0, "p->%sn_%s = 0;",
1251                   st_lower (sbc->prefix), st_lower (sbc->name));
1252             dump (0, "p->%sv_%s = NULL;",
1253                   st_lower (sbc->prefix), st_lower (sbc->name));
1254             break;
1255
1256           case SBC_VAR:
1257             dump (0, "p->%sv_%s = NULL;",
1258                   st_lower (sbc->prefix), st_lower (sbc->name));
1259             break;
1260
1261           case SBC_STRING:
1262             dump (0, "p->s_%s = NULL;", st_lower (sbc->name));
1263             break;
1264
1265           case SBC_INT:
1266           case SBC_PINT:
1267             dump (0, "p->n_%s = NOT_LONG;", st_lower (sbc->name));
1268             break;
1269
1270           default:
1271             assert (0);
1272           }
1273       }
1274   }
1275 }
1276
1277 /* Return a pointer to a static buffer containing an expression that
1278    will match token T. */
1279 char *
1280 make_match (const char *t)
1281 {
1282   char *s;
1283
1284   s = get_buffer ();
1285
1286   while (*t == '_')
1287     t++;
1288
1289   if (is_keyword (t))
1290     sprintf (s, "lex_match (T_%s)", t);
1291   else if (!strcmp (t, "ON") || !strcmp (t, "YES"))
1292     strcpy (s, "(lex_match_id (\"ON\") || lex_match_id (\"YES\") "
1293             "|| lex_match_id (\"TRUE\"))");
1294   else if (!strcmp (t, "OFF") || !strcmp (t, "NO"))
1295     strcpy (s, "(lex_match_id (\"OFF\") || lex_match_id (\"NO\") "
1296             "|| lex_match_id (\"FALSE\"))");
1297   else if (isdigit ((unsigned char) t[0]))
1298     sprintf (s, "lex_match_int (%s)", t);
1299   else
1300     sprintf (s, "lex_match_id (\"%s\")", t);
1301
1302   return s;
1303 }
1304
1305 /* Write out the parsing code for specifier SPEC within subcommand
1306    SBC. */
1307 void
1308 dump_specifier_parse (const specifier *spec, const subcommand *sbc)
1309 {
1310   setting *s;
1311
1312   if (spec->omit_kw && spec->omit_kw->next)
1313     error ("Omittable setting is not last setting in `%s' specifier.",
1314            spec->varname);
1315   if (spec->omit_kw && spec->omit_kw->parent->next)
1316     error ("Default specifier is not in last specifier in `%s' "
1317            "subcommand.", sbc->name);
1318
1319   for (s = spec->s; s; s = s->next)
1320     {
1321       int first = spec == sbc->spec && s == spec->s;
1322
1323       /* Match the setting's keyword. */
1324       if (spec->omit_kw == s)
1325         {
1326           if (!first)
1327             {
1328               dump (1, "else");
1329               dump (1, "{");
1330             }
1331           dump (1, "%s;", make_match (s->specname));
1332         }
1333       else
1334         dump (1, "%sif (%s)", first ? "" : "else ",
1335               make_match (s->specname));
1336
1337       /* Handle values. */
1338       if (s->value == VAL_NONE)
1339         dump (0, "p->%s%s = %s%s;", sbc->prefix, spec->varname,
1340               st_upper (prefix), find_symbol (s->con)->name);
1341       else
1342         {
1343           if (spec->omit_kw != s)
1344             dump (1, "{");
1345
1346           if (spec->varname)
1347             dump (0, "p->%s%s = %s%s;", sbc->prefix, spec->varname,
1348                   st_upper (prefix), find_symbol (s->con)->name);
1349
1350           if (s->valtype == VT_PAREN)
1351             {
1352               if (s->optvalue)
1353                 {
1354                   dump (1, "if (lex_match ('('))");
1355                   dump (1, "{");
1356                 }
1357               else
1358                 {
1359                   dump (1, "if (!lex_match ('('))");
1360                   dump (1, "{");
1361                   dump (0, "msg (SE, _(\"`(' expected after %s "
1362                         "specifier of %s subcommand.\"));",
1363                         s->specname, sbc->name);
1364                   dump (0, "goto lossage;");
1365                   dump (-1, "}");
1366                   outdent ();
1367                 }
1368             }
1369
1370           if (s->value == VAL_INT)
1371             {
1372               dump (1, "if (!lex_integer_p ())");
1373               dump (1, "{");
1374               dump (0, "msg (SE, _(\"%s specifier of %s subcommand "
1375                     "requires an integer argument.\"));",
1376                     s->specname, sbc->name);
1377               dump (0, "goto lossage;");
1378               dump (-1, "}");
1379               dump (-1, "p->%s%s = lex_integer ();",
1380                     sbc->prefix, st_lower (s->valname));
1381             }
1382           else
1383             {
1384               dump (1, "if (token != T_NUM)");
1385               dump (1, "{");
1386               dump (0, "msg (SE, _(\"Number expected after %s "
1387                     "specifier of %s subcommand.\"));",
1388                     s->specname, sbc->name);
1389               dump (0, "goto lossage;");
1390               dump (-1, "}");
1391               dump (-1, "p->%s%s = tokval;", sbc->prefix,
1392                     st_lower (s->valname));
1393             }
1394
1395           if (s->restriction)
1396             {
1397               {
1398                 char *str, *str2;
1399                 str = xmalloc (MAX_TOK_LEN);
1400                 str2 = xmalloc (MAX_TOK_LEN);
1401                 sprintf (str2, "p->%s%s", sbc->prefix, st_lower (s->valname));
1402                 sprintf (str, s->restriction, str2, str2, str2, str2,
1403                          str2, str2, str2, str2);
1404                 dump (1, "if (!(%s))", str);
1405                 free (str);
1406                 free (str2);
1407               }
1408
1409               dump (1, "{");
1410               dump (0, "msg (SE, _(\"Bad argument for %s "
1411                     "specifier of %s subcommand.\"));",
1412                     s->specname, sbc->name);
1413               dump (0, "goto lossage;");
1414               dump (-1, "}");
1415               outdent ();
1416             }
1417
1418           dump (0, "lex_get ();");
1419
1420           if (s->valtype == VT_PAREN)
1421             {
1422               dump (1, "if (!lex_match (')'))");
1423               dump (1, "{");
1424               dump (0, "msg (SE, _(\"`)' expected after argument for "
1425                     "%s specifier of %s.\"));",
1426                     s->specname, sbc->name);
1427               dump (0, "goto lossage;");
1428               dump (-1, "}");
1429               outdent ();
1430               if (s->optvalue)
1431                 {
1432                   dump (-1, "}");
1433                   outdent ();
1434                 }
1435             }
1436
1437           if (s != spec->omit_kw)
1438             dump (-1, "}");
1439         }
1440
1441       if (s == spec->omit_kw)
1442         {
1443           dump (-1, "}");
1444           outdent ();
1445         }
1446       outdent ();
1447     }
1448 }
1449
1450 /* Write out the code to parse subcommand SBC. */
1451 void
1452 dump_subcommand (const subcommand *sbc)
1453 {
1454   if (sbc->type == SBC_PLAIN || sbc->type == SBC_ARRAY)
1455     {
1456       int count;
1457
1458       dump (1, "while (token != '/' && token != '.')");
1459       dump (1, "{");
1460
1461       {
1462         specifier *spec;
1463
1464         for (count = 0, spec = sbc->spec; spec; spec = spec->next)
1465           {
1466             if (spec->s)
1467               dump_specifier_parse (spec, sbc);
1468             else
1469               {
1470                 count++;
1471                 dump (1, "%sif (%s)", spec != sbc->spec ? "else " : "",
1472                       make_match (st_upper (spec->varname)));
1473                 if (sbc->type == SBC_PLAIN)
1474                   dump (0, "p->%s%s = 1;", st_lower (sbc->prefix),
1475                         spec->varname);
1476                 else
1477                   dump (0, "p->a_%s[%s%s%s] = 1;",
1478                         st_lower (sbc->name),
1479                         st_upper (prefix), st_upper (sbc->prefix),
1480                         st_upper (spec->varname));
1481                 outdent ();
1482               }
1483           }
1484       }
1485
1486       {
1487         specifier *spec;
1488         setting *s;
1489
1490         /* This code first finds the last specifier in sbc.  Then it
1491            finds the last setting within that last specifier.  Either
1492            or both might be NULL. */
1493         spec = sbc->spec;
1494         s = NULL;
1495         if (spec)
1496           {
1497             while (spec->next)
1498               spec = spec->next;
1499             s = spec->s;
1500             if (s)
1501               while (s->next)
1502                 s = s->next;
1503           }
1504
1505         if (spec && (!spec->s || !spec->omit_kw))
1506           {
1507             dump (1, "else");
1508             dump (1, "{");
1509             dump (0, "lex_error (NULL);");
1510             dump (0, "goto lossage;");
1511             dump (-1, "}");
1512             outdent ();
1513           }
1514       }
1515
1516       dump (0, "lex_match (',');");
1517       dump (-1, "}");
1518       outdent ();
1519     }
1520   else if (sbc->type == SBC_VARLIST)
1521     {
1522       dump (1, "if (!parse_variables (NULL, &p->%sv_%s, &p->%sn_%s, "
1523             "PV_APPEND%s%s))",
1524             st_lower (sbc->prefix), st_lower (sbc->name),
1525             st_lower (sbc->prefix), st_lower (sbc->name),
1526             sbc->message ? " |" : "",
1527             sbc->message ? sbc->message : "");
1528       dump (0, "goto lossage;");
1529       outdent ();
1530     }
1531   else if (sbc->type == SBC_VAR)
1532     {
1533       dump (0, "p->%sv_%s = parse_variable ();",
1534             st_lower (sbc->prefix), st_lower (sbc->name));
1535       dump (1, "if (p->%sv_%s)",
1536             st_lower (sbc->prefix), st_lower (sbc->name));
1537       dump (0, "goto lossage;");
1538       outdent ();
1539     }
1540   else if (sbc->type == SBC_STRING)
1541     {
1542       if (sbc->restriction)
1543         {
1544           dump (1, "{");
1545           dump (0, "int x;");
1546         }
1547       dump (1, "if (!lex_force_string ())");
1548       dump (0, "return 0;");
1549       outdent ();
1550       if (sbc->restriction)
1551         {
1552           dump (0, "x = ds_length (&tokstr);");
1553           dump (1, "if (!(%s))", sbc->restriction);
1554           dump (1, "{");
1555           dump (0, "msg (SE, _(\"String for %s must be %s.\"));",
1556                 sbc->name, sbc->message);
1557           dump (0, "goto lossage;");
1558           dump (-1, "}");
1559           outdent ();
1560         }
1561       dump (0, "p->s_%s = xstrdup (ds_value (&tokstr));",
1562             st_lower (sbc->name));
1563       dump (0, "lex_get ();");
1564       if (sbc->restriction)
1565         dump (-1, "}");
1566     }
1567   else if (sbc->type == SBC_INT)
1568     {
1569       dump (1, "if (!lex_force_int ())");
1570       dump (0, "goto lossage;");
1571       dump (-1, "p->n_%s = lex_integer ();", st_lower (sbc->name));
1572     }
1573   else if (sbc->type == SBC_PINT)
1574     {
1575       dump (0, "lex_match ('(');");
1576       dump (1, "if (!lex_force_int ())");
1577       dump (0, "goto lossage;");
1578       dump (-1, "p->n_%s = lex_integer ();", st_lower (sbc->name));
1579       dump (0, "lex_match (')');");
1580     }
1581   else if (sbc->type == SBC_CUSTOM)
1582     {
1583       dump (1, "switch (%scustom_%s (p))",
1584             st_lower (prefix), st_lower (sbc->name));
1585       dump (0, "{");
1586       dump (1, "case 0:");
1587       dump (0, "goto lossage;");
1588       dump (-1, "case 1:");
1589       indent ();
1590       dump (0, "break;");
1591       dump (-1, "case 2:");
1592       indent ();
1593       dump (0, "lex_error (NULL);");
1594       dump (0, "goto lossage;");
1595       dump (-1, "default:");
1596       indent ();
1597       dump (0, "assert (0);");
1598       dump (-1, "}");
1599       outdent ();
1600     }
1601 }
1602
1603 /* Write out entire parser. */
1604 void
1605 dump_parser (void)
1606 {
1607   int f;
1608
1609   indent = 0;
1610
1611   dump (0, "static int");
1612   dump (0, "parse_%s (struct cmd_%s *p)", make_identifier (cmdname),
1613         make_identifier (cmdname));
1614   dump (1, "{");
1615
1616   dump_vars_init ();
1617
1618   dump (1, "for (;;)");
1619   dump (1, "{");
1620
1621   f = 0;
1622   if (def && (def->type == SBC_VARLIST))
1623     {
1624       if (def->type == SBC_VARLIST)
1625         dump (1, "if (token == T_ID && is_varname (tokid) && "
1626               "lex_look_ahead () != '=')");
1627       else
1628         {
1629           dump (0, "if ((token == T_ID && is_varname (tokid) && "
1630                 "lex_look_ahead () != '=')");
1631           dump (1, "     || token == T_ALL)");
1632         }
1633       dump (1, "{");
1634       dump (0, "p->sbc_%s++;", st_lower (def->name));
1635       dump (1, "if (!parse_variables (NULL, &p->%sv_%s, &p->%sn_%s, "
1636             "PV_APPEND))",
1637             st_lower (def->prefix), st_lower (def->name),
1638             st_lower (def->prefix), st_lower (def->name));
1639       dump (0, "goto lossage;");
1640       dump (-2, "}");
1641       outdent ();
1642       f = 1;
1643     }
1644   else if (def && def->type == SBC_CUSTOM)
1645     {
1646       dump (1, "switch (%scustom_%s (p))",
1647             st_lower (prefix), st_lower (def->name));
1648       dump (0, "{");
1649       dump (1, "case 0:");
1650       dump (0, "goto lossage;");
1651       dump (-1, "case 1:");
1652       indent ();
1653       dump (0, "p->sbc_%s++;", st_lower (def->name));
1654       dump (0, "continue;");
1655       dump (-1, "case 2:");
1656       indent ();
1657       dump (0, "break;");
1658       dump (-1, "default:");
1659       indent ();
1660       dump (0, "assert (0);");
1661       dump (-1, "}");
1662       outdent ();
1663     }
1664
1665   {
1666     subcommand *sbc;
1667
1668     for (sbc = subcommands; sbc; sbc = sbc->next)
1669       {
1670         dump (1, "%sif (%s)", f ? "else " : "", make_match (sbc->name));
1671         f = 1;
1672         dump (1, "{");
1673
1674         dump (0, "lex_match ('=');");
1675         dump (0, "p->sbc_%s++;", st_lower (sbc->name));
1676         if (sbc->once)
1677           {
1678             dump (1, "if (p->sbc_%s > 1)", st_lower (sbc->name));
1679             dump (1, "{");
1680             dump (0, "msg (SE, _(\"%s subcommand may be given only once.\"));",
1681                   sbc->name);
1682             dump (0, "goto lossage;");
1683             dump (-1, "}");
1684             outdent ();
1685           }
1686         dump_subcommand (sbc);
1687         dump (-1, "}");
1688         outdent ();
1689       }
1690   }
1691
1692   dump (1, "if (!lex_match ('/'))");
1693   dump (0, "break;");
1694   dump (-2, "}");
1695   outdent ();
1696   dump (0, nullstr);
1697   dump (1, "if (token != '.')");
1698   dump (1, "{");
1699   dump (0, "lex_error (_(\"expecting end of command\"));");
1700   dump (0, "goto lossage;");
1701   dump (-1, "}");
1702   dump (0, nullstr);
1703   dump (-1, "return 1;");
1704   dump (0, nullstr);
1705   dump (-1, "lossage:");
1706   indent ();
1707   dump (0, "free_%s (p);", make_identifier (cmdname));
1708   dump (0, "return 0;");
1709   dump (-1, "}");
1710   dump (0, nullstr);
1711 }
1712
1713 /* Write the output file header. */
1714 void
1715 dump_header (void)
1716 {
1717   time_t curtime;
1718   struct tm *loctime;
1719   char *timep;
1720
1721   indent = 0;
1722   curtime = time (NULL);
1723   loctime = localtime (&curtime);
1724   timep = asctime (loctime);
1725   timep[strlen (timep) - 1] = 0;
1726   dump (0,   "/* %s", ofn);
1727   dump (0, nullstr);
1728   dump (0, "   Generated by q2c from %s on %s.", ifn, timep);
1729   dump (0, "   Do not modify!");
1730   dump (0, " */");
1731   dump (0, nullstr);
1732 }
1733
1734 /* Write out commands to free variable state. */
1735 void
1736 dump_free (void)
1737 {
1738   subcommand *sbc;
1739   int used;
1740
1741   indent = 0;
1742
1743   used = 0;
1744   for (sbc = subcommands; sbc; sbc = sbc->next)
1745     if (sbc->type == SBC_STRING)
1746       used = 1;
1747
1748   dump (0, "static void");
1749   dump (0, "free_%s (struct cmd_%s *p%s)", make_identifier (cmdname),
1750         make_identifier (cmdname), used ? "" : " unused");
1751   dump (1, "{");
1752
1753   for (sbc = subcommands; sbc; sbc = sbc->next)
1754     if (sbc->type == SBC_STRING)
1755       dump (0, "free (p->s_%s);", st_lower (sbc->name));
1756
1757   dump (-1, "}");
1758 }
1759
1760 /* Returns the name of a directive found on the current input line, if
1761    any, or a null pointer if none found. */
1762 const char *
1763 recognize_directive (void)
1764 {
1765   static char directive[16];
1766   char *sp, *ep;
1767
1768   sp = skip_ws (buf);
1769   if (strncmp (sp, "/*", 2))
1770     return NULL;
1771   sp = skip_ws (sp + 2);
1772   if (*sp != '(')
1773     return NULL;
1774   sp++;
1775
1776   ep = strchr (sp, ')');
1777   if (ep == NULL)
1778     return NULL;
1779
1780   if (ep - sp > 15)
1781     ep = sp + 15;
1782   memcpy (directive, sp, ep - sp);
1783   directive[ep - sp] = '\0';
1784   return directive;
1785 }
1786
1787 int
1788 main (int argc, char *argv[])
1789 {
1790   pgmname = argv[0];
1791   if (argc != 3)
1792     fail ("Syntax: q2c input.q output.c");
1793
1794   ifn = argv[1];
1795   in = fopen (ifn, "r");
1796   if (!in)
1797     fail ("%s: open: %s.", ifn, strerror (errno));
1798
1799   ofn = argv[2];
1800   out = fopen (ofn, "w");
1801   if (!out)
1802     fail ("%s: open: %s.", ofn, strerror (errno));
1803
1804   is_open = 1;
1805   buf = xmalloc (MAX_LINE_LEN);
1806   tokstr = xmalloc (MAX_TOK_LEN);
1807
1808   dump_header ();
1809
1810   indent = 0;
1811   dump (0, "#line %d \"%s\"", ln + 1, ifn);
1812   while (get_line ())
1813     {
1814       const char *directive = recognize_directive ();
1815       if (directive == NULL)
1816         {
1817           dump (0, "%s", buf);
1818           continue;
1819         }
1820
1821       dump (0, "#line %d \"%s\"", oln - 1, ofn);
1822       if (!strcmp (directive, "specification"))
1823         {
1824           /* Skip leading slash-star line. */
1825           get_line ();
1826           lex_get ();
1827
1828           parse ();
1829
1830           /* Skip trailing star-slash line. */
1831           get_line ();
1832         }
1833       else if (!strcmp (directive, "headers"))
1834         {
1835           indent = 0;
1836
1837           dump (0, "#include <assert.h>");
1838           dump (0, "#include <stdlib.h>");
1839           dump (0, "#include \"alloc.h\"");
1840           dump (0, "#include \"error.h\"");
1841           dump (0, "#include \"lexer.h\"");
1842           dump (0, "#include \"str.h\"");
1843           dump (0, "#include \"var.h\"");
1844           dump (0, nullstr);
1845         }
1846       else if (!strcmp (directive, "declarations"))
1847         dump_declarations ();
1848       else if (!strcmp (directive, "functions"))
1849         {
1850           dump_parser ();
1851           dump_free ();
1852         }
1853       else
1854         error ("unknown directive `%s'", directive);
1855       indent = 0;
1856       dump (0, "#line %d \"%s\"", ln + 1, ifn);
1857     }
1858
1859   return EXIT_SUCCESS;
1860 }
1861