src/output.c

   1 /* PSPP - computes sample statistics.
   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., 51 Franklin Street, Fifth Floor, Boston, MA
  18    02110-1301, USA. */
  19
  20 #include <config.h>
  21 #include "output.h"
  22 #include "error.h"
  23 #include <stdlib.h>
  24 #include <stdio.h>
  25 #include <errno.h>
  26 #include <ctype.h>
  27 #include "alloc.h"
  28 #include "devind.h"
  29 #include "error.h"
  30 #include "filename.h"
  31 #include "htmlP.h"
  32 #include "lexer.h"
  33 #include "misc.h"
  34 #include "settings.h"
  35 #include "str.h"
  36
  37 #include "gettext.h"
  38 #define _(msgid) gettext (msgid)
  39
  40 /* FIXME? Should the output configuration format be changed to
  41    drivername:classname:devicetype:options, where devicetype is zero
  42    or more of screen, printer, listing? */
  43
  44 /* FIXME: Have the reentrancy problems been solved? */
  45
  46 /* Where the output driver name came from. */
  47 enum
  48   {
  49     OUTP_S_COMMAND_LINE,        /* Specified by the user. */
  50     OUTP_S_INIT_FILE            /* `default' or the init file. */
  51   };
  52
  53 /* Names the output drivers to be used. */
  54 struct outp_names
  55   {
  56     char *name;                 /* Name of the output driver. */
  57     int source;                 /* OUTP_S_* */
  58     struct outp_names *next, *prev;
  59   };
  60
  61 /* Defines an init file macro. */
  62 struct outp_defn
  63   {
  64     char *key;
  65     char *value;
  66     struct outp_defn *next, *prev;
  67   };
  68
  69 static struct outp_defn *outp_macros;
  70 static struct outp_names *outp_configure_vec;
  71
  72 struct outp_driver_class_list *outp_class_list;
  73 struct outp_driver *outp_driver_list;
  74
  75 char *outp_title;
  76 char *outp_subtitle;
  77
  78 /* A set of OUTP_DEV_* bits indicating the devices that are
  79    disabled. */
  80 static int disabled_devices;
  81
  82 static void destroy_driver (struct outp_driver *);
  83 static void configure_driver (char *);
  84
  85 #if GLOBAL_DEBUGGING
  86 /* This mechanism attempts to catch reentrant use of outp_driver_list. */
  87 static int iterating_driver_list;
  88
  89 #define reentrancy() msg (FE, _("Attempt to iterate driver list reentrantly."))
  90 #endif
  91
  92 /* Add a class to the class list. */
  93 static void
  94 add_class (struct outp_class *class)
  95 {
  96   struct outp_driver_class_list *new_list = xmalloc (sizeof *new_list);
  97
  98   new_list->class = class;
  99   new_list->ref_count = 0;
 100
 101   if (!outp_class_list)
 102     {
 103       outp_class_list = new_list;
 104       new_list->next = NULL;
 105     }
 106   else
 107     {
 108       new_list->next = outp_class_list;
 109       outp_class_list = new_list;
 110     }
 111 }
 112
 113 /* Finds the outp_names in outp_configure_vec with name between BP and
 114    EP exclusive. */
 115 static struct outp_names *
 116 search_names (char *bp, char *ep)
 117 {
 118   struct outp_names *n;
 119
 120   for (n = outp_configure_vec; n; n = n->next)
 121     if ((int) strlen (n->name) == ep - bp && !memcmp (n->name, bp, ep - bp))
 122       return n;
 123   return NULL;
 124 }
 125
 126 /* Deletes outp_names NAME from outp_configure_vec. */
 127 static void
 128 delete_name (struct outp_names * n)
 129 {
 130   free (n->name);
 131   if (n->prev)
 132     n->prev->next = n->next;
 133   if (n->next)
 134     n->next->prev = n->prev;
 135   if (n == outp_configure_vec)
 136     outp_configure_vec = n->next;
 137   free (n);
 138 }
 139
 140 /* Adds the name between BP and EP exclusive to list
 141    outp_configure_vec with source SOURCE. */
 142 static void
 143 add_name (char *bp, char *ep, int source)
 144 {
 145   struct outp_names *n = xmalloc (sizeof *n);
 146   n->name = xmalloc (ep - bp + 1);
 147   memcpy (n->name, bp, ep - bp);
 148   n->name[ep - bp] = 0;
 149   n->source = source;
 150   n->next = outp_configure_vec;
 151   n->prev = NULL;
 152   if (outp_configure_vec)
 153     outp_configure_vec->prev = n;
 154   outp_configure_vec = n;
 155 }
 156
 157 /* Checks that outp_configure_vec is empty, bitches & clears it if it
 158    isn't. */
 159 static void
 160 check_configure_vec (void)
 161 {
 162   struct outp_names *n;
 163
 164   for (n = outp_configure_vec; n; n = n->next)
 165     if (n->source == OUTP_S_COMMAND_LINE)
 166       msg (ME, _("Unknown output driver `%s'."), n->name);
 167     else
 168       msg (IE, _("Output driver `%s' referenced but never defined."), n->name);
 169   outp_configure_clear ();
 170 }
 171
 172 /* Searches outp_configure_vec for the name between BP and EP
 173    exclusive.  If found, it is deleted, then replaced by the names
 174    given in EP+1, if any. */
 175 static void
 176 expand_name (char *bp, char *ep)
 177 {
 178   struct outp_names *n = search_names (bp, ep);
 179   if (!n)
 180     return;
 181   delete_name (n);
 182
 183   bp = ep + 1;
 184   for (;;)
 185     {
 186       while (isspace ((unsigned char) *bp))
 187         bp++;
 188       ep = bp;
 189       while (*ep && !isspace ((unsigned char) *ep))
 190         ep++;
 191       if (bp == ep)
 192         return;
 193       if (!search_names (bp, ep))
 194         add_name (bp, ep, OUTP_S_INIT_FILE);
 195       bp = ep;
 196     }
 197 }
 198
 199 /* Looks for a macro with key KEY, and returns the corresponding value
 200    if found, or NULL if not. */
 201 static const char *
 202 find_defn_value (const char *key)
 203 {
 204   static char buf[INT_DIGITS + 1];
 205   struct outp_defn *d;
 206
 207   for (d = outp_macros; d; d = d->next)
 208     if (!strcmp (key, d->key))
 209       return d->value;
 210   if (!strcmp (key, "viewwidth"))
 211     {
 212       sprintf (buf, "%d", get_viewwidth());
 213       return buf;
 214     }
 215   else if (!strcmp (key, "viewlength"))
 216     {
 217       sprintf (buf, "%d", get_viewlength());
 218       return buf;
 219     }
 220   else
 221     return getenv (key);
 222 }
 223
 224 /* Initializes global variables. */
 225 int
 226 outp_init (void)
 227 {
 228   extern struct outp_class ascii_class;
 229 #if !NO_POSTSCRIPT
 230   extern struct outp_class postscript_class;
 231   extern struct outp_class epsf_class;
 232 #endif
 233   extern struct outp_class html_class;
 234   extern struct outp_class devind_class;
 235
 236   char def[] = "default";
 237
 238 #if !NO_HTML
 239   add_class (&html_class);
 240 #endif
 241 #if !NO_POSTSCRIPT
 242   add_class (&epsf_class);
 243   add_class (&postscript_class);
 244 #endif
 245   add_class (&devind_class);
 246   add_class (&ascii_class);
 247
 248   add_name (def, &def[strlen (def)], OUTP_S_INIT_FILE);
 249
 250   return 1;
 251 }
 252
 253 /* Deletes all the output macros. */
 254 static void
 255 delete_macros (void)
 256 {
 257   struct outp_defn *d, *next;
 258
 259   for (d = outp_macros; d; d = next)
 260     {
 261       next = d->next;
 262       free (d->key);
 263       free (d->value);
 264       free (d);
 265     }
 266 }
 267
 268 /* Reads the initialization file; initializes outp_driver_list. */
 269 int
 270 outp_read_devices (void)
 271 {
 272   int result = 0;
 273
 274   char *init_fn;
 275
 276   FILE *f = NULL;
 277   struct string line;
 278   struct file_locator where;
 279
 280 #if GLOBAL_DEBUGGING
 281   if (iterating_driver_list)
 282     reentrancy ();
 283 #endif
 284
 285   init_fn = fn_search_path (fn_getenv_default ("STAT_OUTPUT_INIT_FILE",
 286                                                "devices"),
 287                             fn_getenv_default ("STAT_OUTPUT_INIT_PATH",
 288                                                config_path),
 289                             NULL);
 290   where.filename = init_fn;
 291   where.line_number = 0;
 292   err_push_file_locator (&where);
 293
 294   ds_init (&line, 128);
 295
 296   if (init_fn == NULL)
 297     {
 298       msg (IE, _("Cannot find output initialization file.  "
 299                  "Use `-vvvv' to view search path."));
 300       goto exit;
 301     }
 302
 303   msg (VM (1), _("%s: Opening device description file..."), init_fn);
 304   f = fopen (init_fn, "r");
 305   if (f == NULL)
 306     {
 307       msg (IE, _("Opening %s: %s."), init_fn, strerror (errno));
 308       goto exit;
 309     }
 310
 311   for (;;)
 312     {
 313       char *cp;
 314
 315       if (!ds_get_config_line (f, &line, &where))
 316         {
 317           if (ferror (f))
 318             msg (ME, _("Reading %s: %s."), init_fn, strerror (errno));
 319           break;
 320         }
 321       for (cp = ds_c_str (&line); isspace ((unsigned char) *cp); cp++);
 322       if (!strncmp ("define", cp, 6) && isspace ((unsigned char) cp[6]))
 323         outp_configure_macro (&cp[7]);
 324       else if (*cp)
 325         {
 326           char *ep;
 327           for (ep = cp; *ep && *ep != ':' && *ep != '='; ep++);
 328           if (*ep == '=')
 329             expand_name (cp, ep);
 330           else if (*ep == ':')
 331             {
 332               struct outp_names *n = search_names (cp, ep);
 333               if (n)
 334                 {
 335                   configure_driver (cp);
 336                   delete_name (n);
 337                 }
 338             }
 339           else
 340             msg (IS, _("Syntax error."));
 341         }
 342     }
 343   result = 1;
 344
 345   check_configure_vec ();
 346
 347 exit:
 348   err_pop_file_locator (&where);
 349   if (f && -1 == fclose (f))
 350     msg (MW, _("Closing %s: %s."), init_fn, strerror (errno));
 351   free (init_fn);
 352   ds_destroy (&line);
 353   delete_macros ();
 354   if (outp_driver_list == NULL)
 355     msg (MW, _("No output drivers are active."));
 356
 357   if (result)
 358     msg (VM (2), _("Device definition file read successfully."));
 359   else
 360     msg (VM (1), _("Error reading device definition file."));
 361   return result;
 362 }
 363
 364 /* Clear the list of drivers to configure. */
 365 void
 366 outp_configure_clear (void)
 367 {
 368   struct outp_names *n, *next;
 369
 370   for (n = outp_configure_vec; n; n = next)
 371     {
 372       next = n->next;
 373       free (n->name);
 374       free (n);
 375     }
 376   outp_configure_vec = NULL;
 377 }
 378
 379 /* Adds the name BP to the list of drivers to configure into
 380    outp_driver_list. */
 381 void
 382 outp_configure_add (char *bp)
 383 {
 384   char *ep = &bp[strlen (bp)];
 385   if (!search_names (bp, ep))
 386     add_name (bp, ep, OUTP_S_COMMAND_LINE);
 387 }
 388
 389 /* Defines one configuration macro based on the text in BP, which
 390    should be of the form `KEY=VALUE'. */
 391 void
 392 outp_configure_macro (char *bp)
 393 {
 394   struct outp_defn *d;
 395   char *ep;
 396
 397   while (isspace ((unsigned char) *bp))
 398     bp++;
 399   ep = bp;
 400   while (*ep && !isspace ((unsigned char) *ep) && *ep != '=')
 401     ep++;
 402
 403   d = xmalloc (sizeof *d);
 404   d->key = xmalloc (ep - bp + 1);
 405   memcpy (d->key, bp, ep - bp);
 406   d->key[ep - bp] = 0;
 407
 408   /* Earlier definitions for a particular KEY override later ones. */
 409   if (find_defn_value (d->key))
 410     {
 411       free (d->key);
 412       free (d);
 413       return;
 414     }
 415
 416   if (*ep == '=')
 417     ep++;
 418   while (isspace ((unsigned char) *ep))
 419     ep++;
 420   d->value = fn_interp_vars (ep, find_defn_value);
 421   d->next = outp_macros;
 422   d->prev = NULL;
 423   if (outp_macros)
 424     outp_macros->prev = d;
 425   outp_macros = d;
 426 }
 427
 428 /* Destroys all the drivers in driver list *DL and sets *DL to
 429    NULL. */
 430 static void
 431 destroy_list (struct outp_driver ** dl)
 432 {
 433   struct outp_driver *d, *next;
 434
 435   for (d = *dl; d; d = next)
 436     {
 437       destroy_driver (d);
 438       next = d->next;
 439       free (d);
 440     }
 441   *dl = NULL;
 442 }
 443
 444 /* Closes all the output drivers. */
 445 int
 446 outp_done (void)
 447 {
 448   struct outp_driver_class_list *n = outp_class_list ;
 449 #if GLOBAL_DEBUGGING
 450   if (iterating_driver_list)
 451     reentrancy ();
 452 #endif
 453   destroy_list (&outp_driver_list);
 454
 455   while (n)
 456     {
 457       struct outp_driver_class_list *next = n->next;
 458       free(n);
 459       n = next;
 460     }
 461   outp_class_list = NULL;
 462
 463   free (outp_title);
 464   outp_title = NULL;
 465
 466   free (outp_subtitle);
 467   outp_subtitle = NULL;
 468
 469   return 1;
 470 }
 471
 472 /* Display on stdout a list of all registered driver classes. */
 473 void
 474 outp_list_classes (void)
 475 {
 476   int width = get_viewwidth();
 477   struct outp_driver_class_list *c;
 478
 479   printf (_("Driver classes:\n\t"));
 480   width -= 8;
 481   for (c = outp_class_list; c; c = c->next)
 482     {
 483       if ((int) strlen (c->class->name) + 1 > width)
 484         {
 485           printf ("\n\t");
 486           width = get_viewwidth() - 8;
 487         }
 488       else
 489         putc (' ', stdout);
 490       fputs (c->class->name, stdout);
 491     }
 492   putc('\n', stdout);
 493 }
 494
 495 static int op_token;            /* `=', 'a', 0. */
 496 static struct string op_tokstr;
 497 static char *prog;
 498
 499 /* Parses a token from prog into op_token, op_tokstr.  Sets op_token
 500    to '=' on an equals sign, to 'a' on a string or identifier token,
 501    or to 0 at end of line.  Returns the new op_token. */
 502 static int
 503 tokener (void)
 504 {
 505   if (op_token == 0)
 506     {
 507       msg (IS, _("Syntax error."));
 508       return 0;
 509     }
 510
 511   while (isspace ((unsigned char) *prog))
 512     prog++;
 513   if (!*prog)
 514     {
 515       op_token = 0;
 516       return 0;
 517     }
 518
 519   if (*prog == '=')
 520     op_token = *prog++;
 521   else
 522     {
 523       ds_clear (&op_tokstr);
 524
 525       if (*prog == '\'' || *prog == '"')
 526         {
 527           int quote = *prog++;
 528
 529           while (*prog && *prog != quote)
 530             {
 531               if (*prog != '\\')
 532                 ds_putc (&op_tokstr, *prog++);
 533               else
 534                 {
 535                   int c;
 536
 537                   prog++;
 538                   assert ((int) *prog); /* How could a line end in `\'? */
 539                   switch (*prog++)
 540                     {
 541                     case '\'':
 542                       c = '\'';
 543                       break;
 544                     case '"':
 545                       c = '"';
 546                       break;
 547                     case '?':
 548                       c = '?';
 549                       break;
 550                     case '\\':
 551                       c = '\\';
 552                       break;
 553                     case '}':
 554                       c = '}';
 555                       break;
 556                     case 'a':
 557                       c = '\a';
 558                       break;
 559                     case 'b':
 560                       c = '\b';
 561                       break;
 562                     case 'f':
 563                       c = '\f';
 564                       break;
 565                     case 'n':
 566                       c = '\n';
 567                       break;
 568                     case 'r':
 569                       c = '\r';
 570                       break;
 571                     case 't':
 572                       c = '\t';
 573                       break;
 574                     case 'v':
 575                       c = '\v';
 576                       break;
 577                     case '0':
 578                     case '1':
 579                     case '2':
 580                     case '3':
 581                     case '4':
 582                     case '5':
 583                     case '6':
 584                     case '7':
 585                       {
 586                         c = prog[-1] - '0';
 587                         while (*prog >= '0' && *prog <= '7')
 588                           c = c * 8 + *prog++ - '0';
 589                       }
 590                       break;
 591                     case 'x':
 592                     case 'X':
 593                       {
 594                         c = 0;
 595                         while (isxdigit ((unsigned char) *prog))
 596                           {
 597                             c *= 16;
 598                             if (isdigit ((unsigned char) *prog))
 599                               c += *prog - '0';
 600                             else
 601                               c += (tolower ((unsigned char) (*prog))
 602                                     - 'a' + 10);
 603                             prog++;
 604                           }
 605                       }
 606                       break;
 607                     default:
 608                       msg (IS, _("Syntax error in string constant."));
 609                       continue;
 610                     }
 611                   ds_putc (&op_tokstr, (unsigned char) c);
 612                 }
 613             }
 614           prog++;
 615         }
 616       else
 617         while (*prog && !isspace ((unsigned char) *prog) && *prog != '=')
 618           ds_putc (&op_tokstr, *prog++);
 619       op_token = 'a';
 620     }
 621
 622   return 1;
 623 }
 624
 625 /* Applies the user-specified options in string S to output driver D
 626    (at configuration time). */
 627 static void
 628 parse_options (char *s, struct outp_driver * d)
 629 {
 630   prog = s;
 631   op_token = -1;
 632
 633   ds_init (&op_tokstr, 64);
 634   while (tokener ())
 635     {
 636       char key[65];
 637
 638       if (op_token != 'a')
 639         {
 640           msg (IS, _("Syntax error in options."));
 641           break;
 642         }
 643
 644       ds_truncate (&op_tokstr, 64);
 645       strcpy (key, ds_c_str (&op_tokstr));
 646
 647       tokener ();
 648       if (op_token != '=')
 649         {
 650           msg (IS, _("Syntax error in options (`=' expected)."));
 651           break;
 652         }
 653
 654       tokener ();
 655       if (op_token != 'a')
 656         {
 657           msg (IS, _("Syntax error in options (value expected after `=')."));
 658           break;
 659         }
 660       d->class->option (d, key, &op_tokstr);
 661     }
 662   ds_destroy (&op_tokstr);
 663 }
 664
 665 /* Find the driver in outp_driver_list with name NAME. */
 666 static struct outp_driver *
 667 find_driver (char *name)
 668 {
 669   struct outp_driver *d;
 670
 671 #if GLOBAL_DEBUGGING
 672   if (iterating_driver_list)
 673     reentrancy ();
 674 #endif
 675   for (d = outp_driver_list; d; d = d->next)
 676     if (!strcmp (d->name, name))
 677       return d;
 678   return NULL;
 679 }
 680
 681 /* Tokenize string S into colon-separated fields, removing leading and
 682    trailing whitespace on tokens.  Returns a pointer to the
 683    null-terminated token, which is formed by setting a NUL character
 684    into the string.  After the first call, subsequent calls should set
 685    S to NULL.  CP should be consistent across calls.  Returns NULL
 686    after all fields have been used up.
 687
 688    FIXME: Should ignore colons inside double quotes. */
 689 static char *
 690 colon_tokenize (char *s, char **cp)
 691 {
 692   char *token;
 693
 694   if (!s)
 695     {
 696       s = *cp;
 697       if (*s == 0)
 698         return NULL;
 699     }
 700   token = s += strspn (s, " \t\v\r");
 701   *cp = strchr (s, ':');
 702   if (*cp == NULL)
 703     s = *cp = strchr (s, 0);
 704   else
 705     s = (*cp)++;
 706   while (s > token && strchr (" \t\v\r", s[-1]))
 707     s--;
 708   *s = 0;
 709   return token;
 710 }
 711
 712 /* String S is in format:
 713    DRIVERNAME:CLASSNAME:DEVICETYPE:OPTIONS
 714    Adds a driver to outp_driver_list pursuant to the specification
 715    provided.  */
 716 static void
 717 configure_driver (char *s)
 718 {
 719   char *token, *cp;
 720   struct outp_driver *d = NULL, *iter;
 721   struct outp_driver_class_list *c = NULL;
 722
 723   s = fn_interp_vars (s, find_defn_value);
 724
 725   /* Driver name. */
 726   token = colon_tokenize (s, &cp);
 727   if (!token)
 728     {
 729       msg (IS, _("Driver name expected."));
 730       goto error;
 731     }
 732
 733   d = xmalloc (sizeof *d);
 734
 735   d->class = NULL;
 736   d->name = xstrdup (token);
 737   d->driver_open = 0;
 738   d->page_open = 0;
 739
 740   d->next = d->prev = NULL;
 741
 742   d->device = OUTP_DEV_NONE;
 743
 744   d->ext = NULL;
 745
 746   /* Class name. */
 747   token = colon_tokenize (NULL, &cp);
 748   if (!token)
 749     {
 750       msg (IS, _("Class name expected."));
 751       goto error;
 752     }
 753
 754   for (c = outp_class_list; c; c = c->next)
 755     if (!strcmp (c->class->name, token))
 756       break;
 757   if (!c)
 758     {
 759       msg (IS, _("Unknown output driver class `%s'."), token);
 760       goto error;
 761     }
 762
 763   d->class = c->class;
 764   if (!c->ref_count && !d->class->open_global (d->class))
 765     {
 766       msg (IS, _("Can't initialize output driver class `%s'."),
 767            d->class->name);
 768       goto error;
 769     }
 770   c->ref_count++;
 771   if (!d->class->preopen_driver (d))
 772     {
 773       msg (IS, _("Can't initialize output driver `%s' of class `%s'."),
 774            d->name, d->class->name);
 775       goto error;
 776     }
 777
 778   /* Device types. */
 779   token = colon_tokenize (NULL, &cp);
 780   if (token)
 781     {
 782       char *sp, *type;
 783
 784       for (type = strtok_r (token, " \t\r\v", &sp); type;
 785            type = strtok_r (NULL, " \t\r\v", &sp))
 786         {
 787           if (!strcmp (type, "listing"))
 788             d->device |= OUTP_DEV_LISTING;
 789           else if (!strcmp (type, "screen"))
 790             d->device |= OUTP_DEV_SCREEN;
 791           else if (!strcmp (type, "printer"))
 792             d->device |= OUTP_DEV_PRINTER;
 793           else
 794             {
 795               msg (IS, _("Unknown device type `%s'."), type);
 796               goto error;
 797             }
 798         }
 799     }
 800
 801   /* Options. */
 802   token = colon_tokenize (NULL, &cp);
 803   if (token)
 804     parse_options (token, d);
 805   if (!d->class->postopen_driver (d))
 806     {
 807       msg (IS, _("Can't complete initialization of output driver `%s' of "
 808            "class `%s'."), d->name, d->class->name);
 809       goto error;
 810     }
 811
 812   /* Find like-named driver and delete. */
 813   iter = find_driver (d->name);
 814   if (iter)
 815     destroy_driver (iter);
 816
 817   /* Add to list. */
 818   d->next = outp_driver_list;
 819   d->prev = NULL;
 820   if (outp_driver_list)
 821     outp_driver_list->prev = d;
 822   outp_driver_list = d;
 823   goto exit;
 824
 825 error:
 826   if (d)
 827     destroy_driver (d);
 828 exit:
 829   free (s);
 830 }
 831
 832 /* Destroys output driver D. */
 833 static void
 834 destroy_driver (struct outp_driver *d)
 835 {
 836   if (d->page_open)
 837     d->class->close_page (d);
 838   if (d->class)
 839     {
 840       struct outp_driver_class_list *c;
 841
 842       if (d->driver_open)
 843         d->class->close_driver (d);
 844
 845       for (c = outp_class_list; c; c = c->next)
 846         if (c->class == d->class)
 847           break;
 848       assert (c != NULL);
 849
 850       c->ref_count--;
 851       if (c->ref_count == 0)
 852         {
 853           if (!d->class->close_global (d->class))
 854             msg (IS, _("Can't deinitialize output driver class `%s'."),
 855                  d->class->name);
 856         }
 857     }
 858   free (d->name);
 859
 860   /* Remove this driver from the global driver list. */
 861   if (d->prev)
 862     d->prev->next = d->next;
 863   if (d->next)
 864     d->next->prev = d->prev;
 865   if (d == outp_driver_list)
 866     outp_driver_list = d->next;
 867 }
 868
 869 static int
 870 option_cmp (const void *a, const void *b)
 871 {
 872   const struct outp_option *o1 = a;
 873   const struct outp_option *o2 = b;
 874   return strcmp (o1->keyword, o2->keyword);
 875 }
 876
 877 /* Tries to match S as one of the keywords in TAB, with corresponding
 878    information structure INFO.  Returns category code or 0 on failure;
 879    if category code is negative then stores subcategory in *SUBCAT. */
 880 int
 881 outp_match_keyword (const char *s, struct outp_option *tab,
 882                     struct outp_option_info *info, int *subcat)
 883 {
 884   char *cp;
 885   struct outp_option *oip;
 886
 887   /* Form hash table. */
 888   if (NULL == info->initial)
 889     {
 890       /* Count items. */
 891       int count, i;
 892       char s[256], *cp;
 893       struct outp_option *ptr[255], **oip;
 894
 895       for (count = 0; tab[count].keyword[0]; count++)
 896         ;
 897
 898       /* Sort items. */
 899       qsort (tab, count, sizeof *tab, option_cmp);
 900
 901       cp = s;
 902       oip = ptr;
 903       *cp = tab[0].keyword[0];
 904       *oip++ = &tab[0];
 905       for (i = 0; i < count; i++)
 906         if (tab[i].keyword[0] != *cp)
 907           {
 908             *++cp = tab[i].keyword[0];
 909             *oip++ = &tab[i];
 910           }
 911       *++cp = 0;
 912
 913       info->initial = xstrdup (s);
 914       info->options = xmalloc (sizeof *info->options * (cp - s));
 915       memcpy (info->options, ptr, sizeof *info->options * (cp - s));
 916     }
 917
 918   cp = info->initial;
 919   oip = *info->options;
 920
 921   if (s[0] == 0)
 922     return 0;
 923   cp = strchr (info->initial, s[0]);
 924   if (!cp)
 925     return 0;
 926 #if 0
 927   printf (_("Trying to find keyword `%s'...\n"), s);
 928 #endif
 929   oip = info->options[cp - info->initial];
 930   while (oip->keyword[0] == s[0])
 931     {
 932 #if 0
 933       printf ("- %s\n", oip->keyword);
 934 #endif
 935       if (!strcmp (s, oip->keyword))
 936         {
 937           if (oip->cat < 0)
 938             *subcat = oip->subcat;
 939           return oip->cat;
 940         }
 941       oip++;
 942     }
 943
 944   return 0;
 945 }
 946
 947 /* Encapsulate two characters in a single int. */
 948 #define TWO_CHARS(A, B)                         \
 949         ((A) + ((B)<<8))
 950
 951 /* Determines the size of a dimensional measurement and returns the
 952    size in units of 1/72000".  Units if not specified explicitly are
 953    inches for values under 50, millimeters otherwise.  Returns 0,
 954    stores NULL to *TAIL on error; otherwise returns dimension, stores
 955    address of next */
 956 int
 957 outp_evaluate_dimension (char *dimen, char **tail)
 958 {
 959   char *s = dimen;
 960   char *ptail;
 961   double value;
 962
 963   value = strtod (s, &ptail);
 964   if (ptail == s)
 965     goto lossage;
 966   if (*ptail == '-')
 967     {
 968       double b, c;
 969       s = &ptail[1];
 970       b = strtod (s, &ptail);
 971       if (b <= 0.0 || ptail == s)
 972         goto lossage;
 973       if (*ptail != '/')
 974         goto lossage;
 975       s = &ptail[1];
 976       c = strtod (s, &ptail);
 977       if (c <= 0.0 || ptail == s)
 978         goto lossage;
 979       s = ptail;
 980       if (c == 0.0)
 981         goto lossage;
 982       if (value > 0)
 983         value += b / c;
 984       else
 985         value -= b / c;
 986     }
 987   else if (*ptail == '/')
 988     {
 989       double b;
 990       s = &ptail[1];
 991       b = strtod (s, &ptail);
 992       if (b <= 0.0 || ptail == s)
 993         goto lossage;
 994       s = ptail;
 995       value /= b;
 996     }
 997   else
 998     s = ptail;
 999   if (*s == 0 || isspace ((unsigned char) *s))
1000     {
1001       if (value < 50.0)
1002         value *= 72000;
1003       else
1004         value *= 72000 / 25.4;
1005     }
1006   else
1007     {
1008       double factor;
1009
1010       /* Standard TeX units are supported. */
1011       if (*s == '"')
1012         factor = 72000, s++;
1013       else
1014         switch (TWO_CHARS (s[0], s[1]))
1015           {
1016           case TWO_CHARS ('p', 't'):
1017             factor = 72000 / 72.27;
1018             break;
1019           case TWO_CHARS ('p', 'c'):
1020             factor = 72000 / 72.27 * 12.0;
1021             break;
1022           case TWO_CHARS ('i', 'n'):
1023             factor = 72000;
1024             break;
1025           case TWO_CHARS ('b', 'p'):
1026             factor = 72000 / 72.0;
1027             break;
1028           case TWO_CHARS ('c', 'm'):
1029             factor = 72000 / 2.54;
1030             break;
1031           case TWO_CHARS ('m', 'm'):
1032             factor = 72000 / 25.4;
1033             break;
1034           case TWO_CHARS ('d', 'd'):
1035             factor = 72000 / 72.27 * 1.0700086;
1036             break;
1037           case TWO_CHARS ('c', 'c'):
1038             factor = 72000 / 72.27 * 12.840104;
1039             break;
1040           case TWO_CHARS ('s', 'p'):
1041             factor = 72000 / 72.27 / 65536.0;
1042             break;
1043           default:
1044             msg (SE, _("Unit \"%s\" is unknown in dimension \"%s\"."), s, dimen);
1045             *tail = NULL;
1046             return 0;
1047           }
1048       ptail += 2;
1049       value *= factor;
1050     }
1051   if (value <= 0.0)
1052     goto lossage;
1053   if (tail)
1054     *tail = ptail;
1055   return value + 0.5;
1056
1057 lossage:
1058   *tail = NULL;
1059   msg (SE, _("Bad dimension \"%s\"."), dimen);
1060   return 0;
1061 }
1062
1063 /* Stores the dimensions in 1/72000" units of paper identified by
1064    SIZE, which is of form `HORZ x VERT' or `HORZ by VERT' where each
1065    of HORZ and VERT are dimensions, into *H and *V.  Return nonzero on
1066    success. */
1067 static int
1068 internal_get_paper_size (char *size, int *h, int *v)
1069 {
1070   char *tail;
1071
1072   while (isspace ((unsigned char) *size))
1073     size++;
1074   *h = outp_evaluate_dimension (size, &tail);
1075   if (tail == NULL)
1076     return 0;
1077   while (isspace ((unsigned char) *tail))
1078     tail++;
1079   if (*tail == 'x')
1080     tail++;
1081   else if (*tail == 'b' && tail[1] == 'y')
1082     tail += 2;
1083   else
1084     {
1085       msg (SE, _("`x' expected in paper size `%s'."), size);
1086       return 0;
1087     }
1088   *v = outp_evaluate_dimension (tail, &tail);
1089   if (tail == NULL)
1090     return 0;
1091   while (isspace ((unsigned char) *tail))
1092     tail++;
1093   if (*tail)
1094     {
1095       msg (SE, _("Trailing garbage `%s' on paper size `%s'."), tail, size);
1096       return 0;
1097     }
1098
1099   return 1;
1100 }
1101
1102 /* Stores the dimensions, in 1/72000" units, of paper identified by
1103    SIZE into *H and *V.  SIZE may be a pair of dimensions of form `H x
1104    V', or it may be a case-insensitive paper identifier, which is
1105    looked up in the `papersize' configuration file.  Returns nonzero
1106    on success.  May modify SIZE. */
1107 /* Don't read further unless you've got a strong stomach. */
1108 int
1109 outp_get_paper_size (char *size, int *h, int *v)
1110 {
1111   struct paper_size
1112     {
1113       char *name;
1114       int use;
1115       int h, v;
1116     };
1117
1118   static struct paper_size cache[4];
1119   static int use;
1120
1121   FILE *f;
1122   char *pprsz_fn;
1123
1124   struct string line;
1125   struct file_locator where;
1126
1127   int free_it = 0;
1128   int result = 0;
1129   int min_value, min_index;
1130   char *ep;
1131   int i;
1132
1133   while (isspace ((unsigned char) *size))
1134     size++;
1135   if (isdigit ((unsigned char) *size))
1136     return internal_get_paper_size (size, h, v);
1137   ep = size;
1138   while (*ep)
1139     ep++;
1140   while (isspace ((unsigned char) *ep) && ep >= size)
1141     ep--;
1142   if (ep == size)
1143     {
1144       msg (SE, _("Paper size name must not be empty."));
1145       return 0;
1146     }
1147
1148   ep++;
1149   if (*ep)
1150     *ep = 0;
1151
1152   use++;
1153   for (i = 0; i < 4; i++)
1154     if (cache[i].name != NULL && !strcasecmp (cache[i].name, size))
1155       {
1156         *h = cache[i].h;
1157         *v = cache[i].v;
1158         cache[i].use = use;
1159         return 1;
1160       }
1161
1162   pprsz_fn = fn_search_path (fn_getenv_default ("STAT_OUTPUT_PAPERSIZE_FILE",
1163                                                 "papersize"),
1164                              fn_getenv_default ("STAT_OUTPUT_INIT_PATH",
1165                                                 config_path),
1166                              NULL);
1167
1168   where.filename = pprsz_fn;
1169   where.line_number = 0;
1170   err_push_file_locator (&where);
1171   ds_init (&line, 128);
1172
1173   if (pprsz_fn == NULL)
1174     {
1175       msg (IE, _("Cannot find `papersize' configuration file."));
1176       goto exit;
1177     }
1178
1179   msg (VM (1), _("%s: Opening paper size definition file..."), pprsz_fn);
1180   f = fopen (pprsz_fn, "r");
1181   if (!f)
1182     {
1183       msg (IE, _("Opening %s: %s."), pprsz_fn, strerror (errno));
1184       goto exit;
1185     }
1186
1187   for (;;)
1188     {
1189       char *cp, *bp, *ep;
1190
1191       if (!ds_get_config_line (f, &line, &where))
1192         {
1193           if (ferror (f))
1194             msg (ME, _("Reading %s: %s."), pprsz_fn, strerror (errno));
1195           break;
1196         }
1197       for (cp = ds_c_str (&line); isspace ((unsigned char) *cp); cp++);
1198       if (*cp == 0)
1199         continue;
1200       if (*cp != '"')
1201         goto lex_error;
1202       for (bp = ep = cp + 1; *ep && *ep != '"'; ep++);
1203       if (!*ep)
1204         goto lex_error;
1205       *ep = 0;
1206       if (0 != strcasecmp (bp, size))
1207         continue;
1208
1209       for (cp = ep + 1; isspace ((unsigned char) *cp); cp++);
1210       if (*cp == '=')
1211         {
1212           size = xmalloc (ep - bp + 1);
1213           strcpy (size, bp);
1214           free_it = 1;
1215           continue;
1216         }
1217       size = &ep[1];
1218       break;
1219
1220     lex_error:
1221       msg (IE, _("Syntax error in paper size definition."));
1222     }
1223
1224   /* We found the one we want! */
1225   result = internal_get_paper_size (size, h, v);
1226   if (result)
1227     {
1228       min_value = cache[0].use;
1229       min_index = 0;
1230       for (i = 1; i < 4; i++)
1231         if (cache[0].use < min_value)
1232           {
1233             min_value = cache[i].use;
1234             min_index = i;
1235           }
1236       free (cache[min_index].name);
1237       cache[min_index].name = xstrdup (size);
1238       cache[min_index].use = use;
1239       cache[min_index].h = *h;
1240       cache[min_index].v = *v;
1241     }
1242
1243 exit:
1244   err_pop_file_locator (&where);
1245   ds_destroy (&line);
1246   if (free_it)
1247     free (size);
1248
1249   if (result)
1250     msg (VM (2), _("Paper size definition file read successfully."));
1251   else
1252     msg (VM (1), _("Error reading paper size definition file."));
1253
1254   return result;
1255 }
1256
1257 /* If D is NULL, returns the first enabled driver if any, NULL if
1258    none.  Otherwise D must be the last driver returned by this
1259    function, in which case the next enabled driver is returned or NULL
1260    if that was the last. */
1261 struct outp_driver *
1262 outp_drivers (struct outp_driver *d)
1263 {
1264 #if GLOBAL_DEBUGGING
1265   struct outp_driver *orig_d = d;
1266 #endif
1267
1268   for (;;)
1269     {
1270       if (d == NULL)
1271         d = outp_driver_list;
1272       else
1273         d = d->next;
1274
1275       if (d == NULL
1276           || (d->driver_open
1277               && (d->device == 0
1278                   || (d->device & disabled_devices) != d->device)))
1279         break;
1280     }
1281
1282 #if GLOBAL_DEBUGGING
1283   if (d && !orig_d)
1284     {
1285       if (iterating_driver_list++)
1286         reentrancy ();
1287     }
1288   else if (orig_d && !d)
1289     {
1290       assert (iterating_driver_list == 1);
1291       iterating_driver_list = 0;
1292     }
1293 #endif
1294
1295   return d;
1296 }
1297
1298 /* Enables (if ENABLE is nonzero) or disables (if ENABLE is zero) the
1299    device(s) given in mask DEVICE. */
1300 void
1301 outp_enable_device (int enable, int device)
1302 {
1303   if (enable)
1304     disabled_devices &= ~device;
1305   else
1306     disabled_devices |= device;
1307 }
1308
1309 /* Ejects the paper on device D, if the page is not blank. */
1310 int
1311 outp_eject_page (struct outp_driver *d)
1312 {
1313   if (d->page_open == 0)
1314     return 1;
1315
1316   if (d->cp_y != 0)
1317     {
1318       d->cp_x = d->cp_y = 0;
1319
1320       if (d->class->close_page (d) == 0)
1321         msg (ME, _("Error closing page on %s device of %s class."),
1322              d->name, d->class->name);
1323       if (d->class->open_page (d) == 0)
1324         {
1325           msg (ME, _("Error opening page on %s device of %s class."),
1326                d->name, d->class->name);
1327           return 0;
1328         }
1329     }
1330   return 1;
1331 }
1332
1333 /* Returns the width of string S, in device units, when output on
1334    device D. */
1335 int
1336 outp_string_width (struct outp_driver *d, const char *s)
1337 {
1338   struct outp_text text;
1339
1340   text.options = OUTP_T_JUST_LEFT;
1341   ls_init (&text.s, (char *) s, strlen (s));
1342   d->class->text_metrics (d, &text);
1343
1344   return text.h;
1345 }