grops/ps.cc

   1 // -*- C++ -*-
   2 /* Copyright (C) 1989, 1990, 1991, 1992 Free Software Foundation, Inc.
   3      Written by James Clark (jjc@jclark.com)
   4
   5 This file is part of groff.
   6
   7 groff is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 groff is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 for more details.
  16
  17 You should have received a copy of the GNU General Public License along
  18 with groff; see the file COPYING.  If not, write to the Free Software
  19 Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
  20
  21 #include "driver.h"
  22 #include "stringclass.h"
  23 #include "cset.h"
  24
  25 #include "ps.h"
  26
  27 static int landscape_flag = 0;
  28 static int ncopies = 1;
  29 static int linewidth = -1;
  30 // Non-zero means generate PostScript code that guesses the paper
  31 // length using the imageable area.
  32 static int guess_flag = 0;
  33
  34 // Non-zero if -b was specified on the command line.
  35 static int bflag = 0;
  36 unsigned broken_flags = 0;
  37
  38 #define DEFAULT_LINEWIDTH 40    /* in ems/1000 */
  39 #define FILL_MAX 1000
  40
  41 const char *const dict_name = "grops";
  42 const char *const defs_dict_name = "DEFS";
  43 const int DEFS_DICT_SPARE = 50;
  44
  45 double degrees(double r)
  46 {
  47   return r*180.0/M_PI;
  48 }
  49
  50 double radians(double d)
  51 {
  52   return d*M_PI/180.0;
  53 }
  54
  55 inline double transform_fill(int fill)
  56 {
  57   return 1 - fill/double(FILL_MAX);
  58 }
  59
  60 ps_output::ps_output(FILE *f, int n)
  61 : fp(f), max_line_length(n), col(0), need_space(0), fixed_point(0)
  62 {
  63 }
  64
  65 ps_output &ps_output::set_file(FILE *f)
  66 {
  67   fp = f;
  68   col = 0;
  69   return *this;
  70 }
  71
  72 ps_output &ps_output::copy_file(FILE *infp)
  73 {
  74   int c;
  75   while ((c = getc(infp)) != EOF)
  76     putc(c, fp);
  77   return *this;
  78 }
  79
  80 ps_output &ps_output::end_line()
  81 {
  82   if (col != 0) {
  83     putc('\n', fp);
  84     col = 0;
  85     need_space = 0;
  86   }
  87   return *this;
  88 }
  89
  90 ps_output &ps_output::special(const char *s)
  91 {
  92   if (s == 0 || *s == '\0')
  93     return *this;
  94   if (col != 0) {
  95     putc('\n', fp);
  96     col = 0;
  97   }
  98   fputs(s, fp);
  99   if (strchr(s, '\0')[-1] != '\n')
 100     putc('\n', fp);
 101   need_space = 0;
 102   return *this;
 103 }
 104
 105 ps_output &ps_output::simple_comment(const char *s)
 106 {
 107   if (col != 0)
 108     putc('\n', fp);
 109   putc('%', fp);
 110   putc('%', fp);
 111   fputs(s, fp);
 112   putc('\n', fp);
 113   col = 0;
 114   need_space = 0;
 115   return *this;
 116 }
 117
 118 ps_output &ps_output::begin_comment(const char *s)
 119 {
 120   if (col != 0)
 121     putc('\n', fp);
 122   putc('%', fp);
 123   putc('%', fp);
 124   fputs(s, fp);
 125   col = 2 + strlen(s);
 126   return *this;
 127 }
 128
 129 ps_output &ps_output::end_comment()
 130 {
 131   if (col != 0) {
 132     putc('\n', fp);
 133     col = 0;
 134   }
 135   need_space = 0;
 136   return *this;
 137 }
 138
 139 ps_output &ps_output::comment_arg(const char *s)
 140 {
 141   int len = strlen(s);
 142   if (col + len + 1 > max_line_length) {
 143     putc('\n', fp);
 144     fputs("%%+", fp);
 145     col = 3;
 146   }
 147   putc(' ',  fp);
 148   fputs(s, fp);
 149   col += len + 1;
 150   return *this;
 151 }
 152
 153 ps_output &ps_output::set_fixed_point(int n)
 154 {
 155   assert(n >= 0 && n <= 10);
 156   fixed_point = n;
 157   return *this;
 158 }
 159
 160 ps_output &ps_output::put_delimiter(char c)
 161 {
 162   if (col + 1 > max_line_length) {
 163     putc('\n', fp);
 164     col = 0;
 165   }
 166   putc(c, fp);
 167   col++;
 168   need_space = 0;
 169   return *this;
 170 }
 171
 172 ps_output &ps_output::put_string(const char *s, int n)
 173 {
 174   int len = 0;
 175   for (int i = 0; i < n; i++) {
 176     char c = s[i];
 177     if (isascii(c) && isprint(c)) {
 178       if (c == '(' || c == ')' || c == '\\')
 179         len += 2;
 180       else
 181         len += 1;
 182     }
 183     else
 184       len += 4;
 185   }
 186   if (len > n*2) {
 187     if (col + n*2 + 2 > max_line_length && n*2 + 2 <= max_line_length) {
 188       putc('\n', fp);
 189       col = 0;
 190     }
 191     if (col + 1 > max_line_length) {
 192       putc('\n', fp);
 193       col = 0;
 194     }
 195     putc('<', fp);
 196     col++;
 197     for (i = 0; i < n; i++) {
 198       if (col + 2 > max_line_length) {
 199         putc('\n', fp);
 200         col = 0;
 201       }
 202       fprintf(fp, "%02x", s[i] & 0377);
 203       col += 2;
 204     }
 205     putc('>', fp);
 206     col++;
 207   }
 208   else {
 209     if (col + len + 2 > max_line_length && len + 2 <= max_line_length) {
 210       putc('\n', fp);
 211       col = 0;
 212     }
 213     if (col + 2 > max_line_length) {
 214       putc('\n', fp);
 215       col = 0;
 216     }
 217     putc('(', fp);
 218     col++;
 219     for (i = 0; i < n; i++) {
 220       char c = s[i];
 221       if (isascii(c) && isprint(c)) {
 222         if (c == '(' || c == ')' || c == '\\')
 223           len = 2;
 224         else
 225           len = 1;
 226       }
 227       else
 228         len = 4;
 229       if (col + len + 1 > max_line_length) {
 230         putc('\\', fp);
 231         putc('\n', fp);
 232         col = 0;
 233       }
 234       switch (len) {
 235       case 1:
 236         putc(c, fp);
 237         break;
 238       case 2:
 239         putc('\\', fp);
 240         putc(c, fp);
 241         break;
 242       case 4:
 243         fprintf(fp, "\\%03o", c & 0377);
 244         break;
 245       default:
 246         assert(0);
 247       }
 248       col += len;
 249     }
 250     putc(')', fp);
 251     col++;
 252   }
 253   need_space = 0;
 254   return *this;
 255 }
 256
 257 ps_output &ps_output::put_number(int n)
 258 {
 259   char buf[1 + INT_DIGITS + 1];
 260   sprintf(buf, "%d", n);
 261   int len = strlen(buf);
 262   if (col > 0 && col + len + need_space > max_line_length) {
 263     putc('\n', fp);
 264     col = 0;
 265     need_space = 0;
 266   }
 267   if (need_space) {
 268     putc(' ', fp);
 269     col++;
 270   }
 271   fputs(buf, fp);
 272   col += len;
 273   need_space = 1;
 274   return *this;
 275 }
 276
 277 ps_output &ps_output::put_fix_number(int i)
 278 {
 279   const char *p = iftoa(i, fixed_point);
 280   int len = strlen(p);
 281   if (col > 0 && col + len + need_space > max_line_length) {
 282     putc('\n', fp);
 283     col = 0;
 284     need_space = 0;
 285   }
 286   if (need_space) {
 287     putc(' ', fp);
 288     col++;
 289   }
 290   fputs(p, fp);
 291   col += len;
 292   need_space = 1;
 293   return *this;
 294 }
 295
 296 ps_output &ps_output::put_float(double d)
 297 {
 298   char buf[128];
 299   sprintf(buf, "%.4f", d);
 300   int len = strlen(buf);
 301   if (col > 0 && col + len + need_space > max_line_length) {
 302     putc('\n', fp);
 303     col = 0;
 304     need_space = 0;
 305   }
 306   if (need_space) {
 307     putc(' ', fp);
 308     col++;
 309   }
 310   fputs(buf, fp);
 311   col += len;
 312   need_space = 1;
 313   return *this;
 314 }
 315
 316 ps_output &ps_output::put_symbol(const char *s)
 317 {
 318   int len = strlen(s);
 319   if (col > 0 && col + len + need_space > max_line_length) {
 320     putc('\n', fp);
 321     col = 0;
 322     need_space = 0;
 323   }
 324   if (need_space) {
 325     putc(' ', fp);
 326     col++;
 327   }
 328   fputs(s, fp);
 329   col += len;
 330   need_space = 1;
 331   return *this;
 332 }
 333
 334 ps_output &ps_output::put_literal_symbol(const char *s)
 335 {
 336   int len = strlen(s);
 337   if (col > 0 && col + len + 1 > max_line_length) {
 338     putc('\n', fp);
 339     col = 0;
 340   }
 341   putc('/', fp);
 342   fputs(s, fp);
 343   col += len + 1;
 344   need_space = 1;
 345   return *this;
 346 }
 347
 348 class ps_font : public font {
 349   ps_font(const char *);
 350 public:
 351   int encoding_index;
 352   char *encoding;
 353   char *reencoded_name;
 354   ~ps_font();
 355   void handle_unknown_font_command(const char *command, const char *arg,
 356                                    const char *filename, int lineno);
 357   static ps_font *load_ps_font(const char *);
 358 };
 359
 360 ps_font *ps_font::load_ps_font(const char *s)
 361 {
 362   ps_font *f = new ps_font(s);
 363   if (!f->load()) {
 364     delete f;
 365     return 0;
 366   }
 367   return f;
 368 }
 369
 370 ps_font::ps_font(const char *nm)
 371 : font(nm), encoding(0), reencoded_name(0), encoding_index(-1)
 372 {
 373 }
 374
 375 ps_font::~ps_font()
 376 {
 377   a_delete encoding;
 378   a_delete reencoded_name;
 379 }
 380
 381 void ps_font::handle_unknown_font_command(const char *command, const char *arg,
 382                                           const char *filename, int lineno)
 383 {
 384   if (strcmp(command, "encoding") == 0) {
 385     if (arg == 0)
 386       error_with_file_and_line(filename, lineno,
 387                                "`encoding' command requires an argument");
 388     else
 389       encoding = strsave(arg);
 390   }
 391 }
 392
 393 static void handle_unknown_desc_command(const char *command, const char *arg,
 394                                         const char *filename, int lineno)
 395 {
 396   if (strcmp(command, "broken") == 0) {
 397     if (arg == 0)
 398       error_with_file_and_line(filename, lineno,
 399                                "`broken' command requires an argument");
 400     else if (!bflag)
 401       broken_flags = atoi(arg);
 402   }
 403 }
 404
 405 struct style {
 406   font *f;
 407   int point_size;
 408   int height;
 409   int slant;
 410   style();
 411   style(font *, int, int, int);
 412   int operator==(const style &) const;
 413   int operator!=(const style &) const;
 414 };
 415
 416 style::style() : f(0)
 417 {
 418 }
 419
 420 style::style(font *p, int sz, int h, int sl)
 421 : f(p), point_size(sz), height(h), slant(sl)
 422 {
 423 }
 424
 425 int style::operator==(const style &s) const
 426 {
 427   return (f == s.f && point_size == s.point_size
 428           && height == s.height && slant == s.slant);
 429 }
 430
 431 int style::operator!=(const style &s) const
 432 {
 433   return !(*this == s);
 434 }
 435
 436 class ps_printer : public printer {
 437   FILE *tempfp;
 438   ps_output out;
 439   int res;
 440   int space_char_index;
 441   int pages_output;
 442   int paper_length;
 443   int equalise_spaces;
 444   enum { SBUF_SIZE = 256 };
 445   char sbuf[SBUF_SIZE];
 446   int sbuf_len;
 447   int sbuf_start_hpos;
 448   int sbuf_vpos;
 449   int sbuf_end_hpos;
 450   int sbuf_space_width;
 451   int sbuf_space_count;
 452   int sbuf_space_diff_count;
 453   int sbuf_space_code;
 454   int sbuf_kern;
 455   style sbuf_style;
 456   style output_style;
 457   int output_hpos;
 458   int output_vpos;
 459   int output_draw_point_size;
 460   int line_thickness;
 461   int output_line_thickness;
 462   int fill;
 463   unsigned char output_space_code;
 464   enum { MAX_DEFINED_STYLES = 50 };
 465   style defined_styles[MAX_DEFINED_STYLES];
 466   int ndefined_styles;
 467   int next_encoding_index;
 468   string defs;
 469   int ndefs;
 470   resource_manager rm;
 471   int invis_count;
 472
 473   void flush_sbuf();
 474   void set_style(const style &);
 475   void set_space_code(unsigned char c);
 476   int set_encoding_index(ps_font *);
 477   void do_exec(char *, const environment *);
 478   void do_import(char *, const environment *);
 479   void do_def(char *, const environment *);
 480   void do_mdef(char *, const environment *);
 481   void do_file(char *, const environment *);
 482   void do_invis(char *, const environment *);
 483   void do_endinvis(char *, const environment *);
 484   void set_line_thickness(const environment *);
 485   void fill_path();
 486   void encode_fonts();
 487   void define_encoding(const char *, int);
 488   void reencode_font(ps_font *);
 489 public:
 490   ps_printer();
 491   ~ps_printer();
 492   void set_char(int i, font *f, const environment *env, int w);
 493   void draw(int code, int *p, int np, const environment *env);
 494   void begin_page(int);
 495   void end_page(int);
 496   void special(char *arg, const environment *env);
 497   font *make_font(const char *);
 498   void end_of_line();
 499 };
 500
 501 ps_printer::ps_printer()
 502 : pages_output(0),
 503   sbuf_len(0),
 504   output_hpos(-1),
 505   output_vpos(-1),
 506   out(0, 79),
 507   ndefined_styles(0),
 508   next_encoding_index(0),
 509   line_thickness(-1),
 510   fill(FILL_MAX + 1),
 511   ndefs(0),
 512   invis_count(0)
 513 {
 514   tempfp = xtmpfile();
 515   out.set_file(tempfp);
 516   if (linewidth < 0)
 517     linewidth = DEFAULT_LINEWIDTH;
 518   if (font::hor != 1)
 519     fatal("horizontal resolution must be 1");
 520   if (font::vert != 1)
 521     fatal("vertical resolution must be 1");
 522   if (font::res % (font::sizescale*72) != 0)
 523     fatal("res must be a multiple of 72*sizescale");
 524   int r = font::res;
 525   int point = 0;
 526   while (r % 10 == 0) {
 527     r /= 10;
 528     point++;
 529   }
 530   res = r;
 531   out.set_fixed_point(point);
 532   space_char_index = font::name_to_index("space");
 533   paper_length = font::paperlength;
 534   if (paper_length == 0)
 535     paper_length = 11*font::res;
 536   equalise_spaces = font::res >= 72000;
 537 }
 538
 539 int ps_printer::set_encoding_index(ps_font *f)
 540 {
 541   if (f->encoding_index >= 0)
 542     return f->encoding_index;
 543   for (font_pointer_list *p = font_list; p; p = p->next)
 544     if (p->p != f) {
 545       char *encoding = ((ps_font *)p->p)->encoding;
 546       int encoding_index = ((ps_font *)p->p)->encoding_index;
 547       if (encoding != 0 && encoding_index >= 0
 548           && strcmp(f->encoding, encoding) == 0) {
 549         return f->encoding_index = encoding_index;
 550       }
 551     }
 552   return f->encoding_index = next_encoding_index++;
 553 }
 554
 555 void ps_printer::set_char(int i, font *f, const environment *env, int w)
 556 {
 557   if (i == space_char_index || invis_count > 0)
 558     return;
 559   unsigned char code = f->get_code(i);
 560   style sty(f, env->size, env->height, env->slant);
 561   if (sty.slant != 0) {
 562     if (sty.slant > 80 || sty.slant < -80) {
 563       error("silly slant `%1' degrees", sty.slant);
 564       sty.slant = 0;
 565     }
 566   }
 567   if (sbuf_len > 0) {
 568     if (sbuf_len < SBUF_SIZE
 569         && sty == sbuf_style
 570         && sbuf_vpos == env->vpos) {
 571       if (sbuf_end_hpos == env->hpos) {
 572         sbuf[sbuf_len++] = code;
 573         sbuf_end_hpos += w + sbuf_kern;
 574         return;
 575       }
 576       if (sbuf_len == 1 && sbuf_kern == 0) {
 577         sbuf_kern = env->hpos - sbuf_end_hpos;
 578         sbuf_end_hpos = env->hpos + sbuf_kern + w;
 579         sbuf[sbuf_len++] = code;
 580         return;
 581       }
 582       /* If sbuf_end_hpos - sbuf_kern == env->hpos, we are better off
 583          starting a new string. */
 584       if (sbuf_len < SBUF_SIZE - 1 && env->hpos >= sbuf_end_hpos
 585           && (sbuf_kern == 0 || sbuf_end_hpos - sbuf_kern != env->hpos)) {
 586         if (sbuf_space_code < 0) {
 587           if (f->contains(space_char_index)) {
 588             sbuf_space_code = f->get_code(space_char_index);
 589             sbuf_space_width = env->hpos - sbuf_end_hpos;
 590             sbuf_end_hpos = env->hpos + w + sbuf_kern;
 591             sbuf[sbuf_len++] = sbuf_space_code;
 592             sbuf[sbuf_len++] = code;
 593             sbuf_space_count++;
 594             return;
 595           }
 596         }
 597         else {
 598           int diff = env->hpos - sbuf_end_hpos - sbuf_space_width;
 599           if (diff == 0 || (equalise_spaces && (diff == 1 || diff == -1))) {
 600             sbuf_end_hpos = env->hpos + w + sbuf_kern;
 601             sbuf[sbuf_len++] = sbuf_space_code;
 602             sbuf[sbuf_len++] = code;
 603             sbuf_space_count++;
 604             if (diff == 1)
 605               sbuf_space_diff_count++;
 606             else if (diff == -1)
 607               sbuf_space_diff_count--;
 608             return;
 609           }
 610         }
 611       }
 612     }
 613     flush_sbuf();
 614   }
 615   sbuf_len = 1;
 616   sbuf[0] = code;
 617   sbuf_end_hpos = env->hpos + w;
 618   sbuf_start_hpos = env->hpos;
 619   sbuf_vpos = env->vpos;
 620   sbuf_style = sty;
 621   sbuf_space_code = -1;
 622   sbuf_space_width = 0;
 623   sbuf_space_count = sbuf_space_diff_count = 0;
 624   sbuf_kern = 0;
 625 }
 626
 627 int is_small_h(int n)
 628 {
 629   return n < (font::res*2)/72 && n > -(font::res*10)/72;
 630 }
 631
 632 int is_small_v(int n)
 633 {
 634   return n < (font::res*4)/72 && n > -(font::res*4)/72;
 635 }
 636
 637 static char *make_encoding_name(int encoding_index)
 638 {
 639   static char buf[3 + INT_DIGITS + 1];
 640   sprintf(buf, "ENC%d", encoding_index);
 641   return buf;
 642 }
 643
 644 const char *const WS = " \t\n\r";
 645
 646 void ps_printer::define_encoding(const char *encoding, int encoding_index)
 647 {
 648   char *vec[256];
 649   for (int i = 0; i < 256; i++)
 650     vec[i] = 0;
 651   char *path;
 652   FILE *fp = font::open_file(encoding, &path);
 653   if (fp == 0)
 654     fatal("can't open encoding file `%1'", encoding);
 655   int lineno = 1;
 656   char buf[256];
 657   while (fgets(buf, 512, fp) != 0) {
 658     char *p = buf;
 659     while (isascii(*p) && isspace(*p))
 660       p++;
 661     if (*p != '#' && *p != '\0' && (p = strtok(buf, WS)) != 0) {
 662       char *q = strtok(0, WS);
 663       int n;
 664       if (q == 0 || sscanf(q, "%d", &n) != 1 || n < 0 || n >= 256)
 665         fatal_with_file_and_line(path, lineno, "bad second field");
 666       vec[n] = new char[strlen(p) + 1];
 667       strcpy(vec[n], p);
 668     }
 669     lineno++;
 670   }
 671   a_delete path;
 672   out.put_literal_symbol(make_encoding_name(encoding_index));
 673   out.put_delimiter('[');
 674   for (i = 0; i < 256; i++) {
 675     if (vec[i] == 0)
 676       out.put_literal_symbol(".notdef");
 677     else {
 678       out.put_literal_symbol(vec[i]);
 679       a_delete vec[i];
 680     }
 681   }
 682   out.put_delimiter(']').put_symbol("def");
 683 }
 684
 685 void ps_printer::reencode_font(ps_font *f)
 686 {
 687   out.put_literal_symbol(f->reencoded_name)
 688      .put_symbol(make_encoding_name(f->encoding_index))
 689      .put_literal_symbol(f->get_internal_name())
 690      .put_symbol("RE");
 691 }
 692
 693 void ps_printer::encode_fonts()
 694 {
 695   if (next_encoding_index == 0)
 696     return;
 697   char *done_encoding = new char[next_encoding_index];
 698   for (int i = 0; i < next_encoding_index; i++)
 699     done_encoding[i] = 0;
 700   for (font_pointer_list *f = font_list; f; f = f->next) {
 701     int encoding_index = ((ps_font *)f->p)->encoding_index;
 702     if (encoding_index >= 0) {
 703       assert(encoding_index < next_encoding_index);
 704       if (!done_encoding[encoding_index]) {
 705         done_encoding[encoding_index] = 1;
 706         define_encoding(((ps_font *)f->p)->encoding, encoding_index);
 707       }
 708       reencode_font((ps_font *)f->p);
 709     }
 710   }
 711   a_delete done_encoding;
 712 }
 713
 714 void ps_printer::set_style(const style &sty)
 715 {
 716   char buf[1 + INT_DIGITS + 1];
 717   for (int i = 0; i < ndefined_styles; i++)
 718     if (sty == defined_styles[i]) {
 719       sprintf(buf, "F%d", i);
 720       out.put_symbol(buf);
 721       return;
 722     }
 723   if (ndefined_styles >= MAX_DEFINED_STYLES)
 724     ndefined_styles = 0;
 725   sprintf(buf, "F%d", ndefined_styles);
 726   out.put_literal_symbol(buf);
 727   const char *psname = sty.f->get_internal_name();
 728   if (psname == 0)
 729     fatal("no internalname specified for font `%1'", sty.f->get_name());
 730   char *encoding = ((ps_font *)sty.f)->encoding;
 731   if (encoding != 0) {
 732     char *s = ((ps_font *)sty.f)->reencoded_name;
 733     if (s == 0) {
 734       int ei = set_encoding_index((ps_font *)sty.f);
 735       char *tem = new char[strlen(psname) + 1 + INT_DIGITS + 1];
 736       sprintf(tem, "%s@%d", psname, ei);
 737       psname = tem;
 738       ((ps_font *)sty.f)->reencoded_name = tem;
 739     }
 740     else
 741       psname = s;
 742   }
 743   out.put_fix_number((font::res/(72*font::sizescale))*sty.point_size);
 744   if (sty.height != 0 || sty.slant != 0) {
 745     int h = sty.height == 0 ? sty.point_size : sty.height;
 746     h *= font::res/(72*font::sizescale);
 747     int c = int(h*tan(radians(sty.slant)) + .5);
 748     out.put_fix_number(c).put_fix_number(h).put_literal_symbol(psname)
 749        .put_symbol("MF");
 750   }
 751   else {
 752     out.put_literal_symbol(psname).put_symbol("SF");
 753   }
 754   defined_styles[ndefined_styles++] = sty;
 755 }
 756
 757 void ps_printer::set_space_code(unsigned char c)
 758 {
 759   out.put_literal_symbol("SC").put_number(c).put_symbol("def");
 760 }
 761
 762 void ps_printer::end_of_line()
 763 {
 764   flush_sbuf();
 765   // this ensures that we do an absolute motion to the beginning of a line
 766   output_vpos = output_hpos = -1;
 767 }
 768
 769 void ps_printer::flush_sbuf()
 770 {
 771   enum {
 772     NONE,
 773     RELATIVE_H,
 774     RELATIVE_V,
 775     RELATIVE_HV,
 776     ABSOLUTE
 777     } motion = NONE;
 778   int space_flag = 0;
 779   if (sbuf_len == 0)
 780     return;
 781   if (output_style != sbuf_style) {
 782     set_style(sbuf_style);
 783     output_style = sbuf_style;
 784   }
 785   int extra_space = 0;
 786   if (output_hpos < 0 || output_vpos < 0
 787       || !is_small_h(output_hpos - sbuf_start_hpos)
 788       || !is_small_v(output_vpos - sbuf_vpos))
 789     motion = ABSOLUTE;
 790   else {
 791     if (output_hpos != sbuf_start_hpos)
 792       motion = RELATIVE_H;
 793     if (output_vpos != sbuf_vpos) {
 794       if  (motion != NONE)
 795         motion = RELATIVE_HV;
 796       else
 797         motion = RELATIVE_V;
 798     }
 799   }
 800   if (sbuf_space_code >= 0) {
 801     int w = sbuf_style.f->get_width(space_char_index, sbuf_style.point_size);
 802     if (w + sbuf_kern != sbuf_space_width) {
 803       if (sbuf_space_code != output_space_code) {
 804         set_space_code(sbuf_space_code);
 805         output_space_code = sbuf_space_code;
 806       }
 807       space_flag = 1;
 808       extra_space = sbuf_space_width - w - sbuf_kern;
 809       if (sbuf_space_diff_count > sbuf_space_count/2)
 810         extra_space++;
 811       else if (sbuf_space_diff_count < -(sbuf_space_count/2))
 812         extra_space--;
 813     }
 814   }
 815   if (space_flag)
 816     out.put_fix_number(extra_space);
 817   if (sbuf_kern != 0)
 818     out.put_fix_number(sbuf_kern);
 819   out.put_string(sbuf, sbuf_len);
 820   char sym[2];
 821   sym[0] = 'A' + motion*4 + space_flag + 2*(sbuf_kern != 0);
 822   sym[1] = '\0';
 823   switch (motion) {
 824   case NONE:
 825     break;
 826   case ABSOLUTE:
 827     out.put_fix_number(sbuf_start_hpos)
 828        .put_fix_number(sbuf_vpos);
 829     break;
 830   case RELATIVE_H:
 831     out.put_fix_number(sbuf_start_hpos - output_hpos);
 832     break;
 833   case RELATIVE_V:
 834     out.put_fix_number(sbuf_vpos - output_vpos);
 835     break;
 836   case RELATIVE_HV:
 837     out.put_fix_number(sbuf_start_hpos - output_hpos)
 838        .put_fix_number(sbuf_vpos - output_vpos);
 839     break;
 840   default:
 841     assert(0);
 842   }
 843   out.put_symbol(sym);
 844   output_hpos = sbuf_end_hpos;
 845   output_vpos = sbuf_vpos;
 846   sbuf_len = 0;
 847 }
 848
 849
 850 void ps_printer::set_line_thickness(const environment *env)
 851 {
 852   if (line_thickness < 0) {
 853     if (output_draw_point_size != env->size) {
 854       // we ought to check for overflow here
 855       int lw = ((font::res/(72*font::sizescale))*linewidth*env->size)/1000;
 856       out.put_fix_number(lw).put_symbol("LW");
 857       output_draw_point_size = env->size;
 858       output_line_thickness = -1;
 859     }
 860   }
 861   else {
 862     if (output_line_thickness != line_thickness) {
 863       out.put_fix_number(line_thickness).put_symbol("LW");
 864       output_line_thickness = line_thickness;
 865       output_draw_point_size = -1;
 866     }
 867   }
 868 }
 869
 870 void ps_printer::fill_path()
 871 {
 872   if (fill > FILL_MAX)
 873     out.put_symbol("BL");
 874   else
 875     out.put_float(transform_fill(fill)).put_symbol("FL");
 876 }
 877
 878 void ps_printer::draw(int code, int *p, int np, const environment *env)
 879 {
 880   if (invis_count > 0)
 881     return;
 882   int fill_flag = 0;
 883   switch (code) {
 884   case 'C':
 885     fill_flag = 1;
 886     // fall through
 887   case 'c':
 888     // troff adds an extra argument to C
 889     if (np != 1 && !(code == 'C' && np == 2)) {
 890       error("1 argument required for circle");
 891       break;
 892     }
 893     out.put_fix_number(env->hpos + p[0]/2)
 894        .put_fix_number(env->vpos)
 895        .put_fix_number(p[0]/2)
 896        .put_symbol("DC");
 897     if (fill_flag) {
 898       fill_path();
 899     }
 900     else {
 901       set_line_thickness(env);
 902       out.put_symbol("ST");
 903     }
 904     break;
 905   case 'l':
 906     if (np != 2) {
 907       error("2 arguments required for line");
 908       break;
 909     }
 910     set_line_thickness(env);
 911     out.put_fix_number(p[0] + env->hpos)
 912        .put_fix_number(p[1] + env->vpos)
 913        .put_fix_number(env->hpos)
 914        .put_fix_number(env->vpos)
 915        .put_symbol("DL");
 916     break;
 917   case 'E':
 918     fill_flag = 1;
 919     // fall through
 920   case 'e':
 921     if (np != 2) {
 922       error("2 arguments required for ellipse");
 923       break;
 924     }
 925     out.put_fix_number(p[0])
 926        .put_fix_number(p[1])
 927        .put_fix_number(env->hpos + p[0]/2)
 928        .put_fix_number(env->vpos)
 929        .put_symbol("DE");
 930     if (fill_flag) {
 931       fill_path();
 932     }
 933     else {
 934       set_line_thickness(env);
 935       out.put_symbol("ST");
 936     }
 937     break;
 938   case 'P':
 939     fill_flag = 1;
 940     // fall through
 941   case 'p':
 942     {
 943       if (np & 1) {
 944         error("even number of arguments required for polygon");
 945         break;
 946       }
 947       if (np == 0) {
 948         error("no arguments for polygon");
 949         break;
 950       }
 951       out.put_fix_number(env->hpos)
 952          .put_fix_number(env->vpos)
 953          .put_symbol("MT");
 954       for (int i = 0; i < np; i += 2)
 955         out.put_fix_number(p[i])
 956            .put_fix_number(p[i+1])
 957            .put_symbol("RL");
 958       out.put_symbol("CL");
 959       if (fill_flag) {
 960         fill_path();
 961       }
 962       else {
 963         set_line_thickness(env);
 964         out.put_symbol("ST");
 965       }
 966       break;
 967     }
 968   case '~':
 969     {
 970       if (np & 1) {
 971         error("even number of arguments required for spline");
 972         break;
 973       }
 974       if (np == 0) {
 975         error("no arguments for spline");
 976         break;
 977       }
 978       out.put_fix_number(env->hpos)
 979          .put_fix_number(env->vpos)
 980          .put_symbol("MT");
 981       out.put_fix_number(p[0]/2)
 982          .put_fix_number(p[1]/2)
 983          .put_symbol("RL");
 984       /* tnum/tden should be between 0 and 1; the closer it is to 1
 985          the tighter the curve will be to the guiding lines; 2/3
 986          is the standard value */
 987       const int tnum = 2;
 988       const int tden = 3;
 989       for (int i = 0; i < np - 2; i += 2) {
 990         out.put_fix_number((p[i]*tnum)/(2*tden))
 991            .put_fix_number((p[i + 1]*tnum)/(2*tden))
 992            .put_fix_number(p[i]/2 + (p[i + 2]*(tden - tnum))/(2*tden))
 993            .put_fix_number(p[i + 1]/2 + (p[i + 3]*(tden - tnum))/(2*tden))
 994            .put_fix_number((p[i] - p[i]/2) + p[i + 2]/2)
 995            .put_fix_number((p[i + 1] - p[i + 1]/2) + p[i + 3]/2)
 996            .put_symbol("RC");
 997       }
 998       out.put_fix_number(p[np - 2] - p[np - 2]/2)
 999          .put_fix_number(p[np - 1] - p[np - 1]/2)
1000          .put_symbol("RL");
1001       set_line_thickness(env);
1002       out.put_symbol("ST");
1003     }
1004     break;
1005   case 'a':
1006     {
1007       if (np != 4) {
1008         error("4 arguments required for arc");
1009         break;
1010       }
1011       set_line_thickness(env);
1012       double c[2];
1013       if (adjust_arc_center(p, c))
1014         out.put_fix_number(env->hpos + int(c[0]))
1015            .put_fix_number(env->vpos + int(c[1]))
1016            .put_fix_number(int(sqrt(c[0]*c[0] + c[1]*c[1])))
1017            .put_float(degrees(atan2(-c[1], -c[0])))
1018            .put_float(degrees(atan2(p[1] + p[3] - c[1], p[0] + p[2] - c[0])))
1019            .put_symbol("DA");
1020       else
1021         out.put_fix_number(p[0] + p[2] + env->hpos)
1022            .put_fix_number(p[1] + p[3] + env->vpos)
1023            .put_fix_number(env->hpos)
1024            .put_fix_number(env->vpos)
1025            .put_symbol("DL");
1026     }
1027     break;
1028   case 't':
1029     {
1030       if (np == 0) {
1031         line_thickness = -1;
1032       }
1033       else {
1034         // troff gratuitously adds an extra 0
1035         if (np != 1 && np != 2) {
1036           error("0 or 1 argument required for thickness");
1037           break;
1038         }
1039         line_thickness = p[0];
1040       }
1041       break;
1042     }
1043   case 'f':
1044     {
1045       if (np != 1 && np != 2) {
1046         error("1 argument required for fill");
1047         break;
1048       }
1049       fill = p[0];
1050       if (fill < 0 || fill > FILL_MAX) {
1051         // This means fill with the current color.
1052         fill = FILL_MAX + 1;
1053       }
1054       break;
1055     }
1056   default:
1057     error("unrecognised drawing command `%1'", char(code));
1058     break;
1059   }
1060
1061   output_hpos = output_vpos = -1;
1062 }
1063
1064
1065 void ps_printer::begin_page(int n)
1066 {
1067   out.begin_comment("Page:").comment_arg(itoa(n));
1068   out.comment_arg(itoa(++pages_output)).end_comment();
1069   output_style.f = 0;
1070   output_space_code = 32;
1071   output_draw_point_size = -1;
1072   output_line_thickness = -1;
1073   output_hpos = output_vpos = -1;
1074   ndefined_styles = 0;
1075   out.simple_comment("BeginPageSetup");
1076   out.put_symbol("BP");
1077   out.simple_comment("EndPageSetup");
1078 }
1079
1080 void ps_printer::end_page(int)
1081 {
1082   flush_sbuf();
1083   out.put_symbol("EP");
1084   if (invis_count != 0) {
1085     error("missing `endinvis' command");
1086     invis_count = 0;
1087   }
1088 }
1089
1090 font *ps_printer::make_font(const char *nm)
1091 {
1092   return ps_font::load_ps_font(nm);
1093 }
1094
1095 ps_printer::~ps_printer()
1096 {
1097   out.simple_comment("Trailer");
1098   out.put_symbol("end");
1099   out.simple_comment("EOF");
1100   if (fseek(tempfp, 0L, 0) < 0)
1101     fatal("fseek on temporary file failed");
1102   fputs("%!PS-Adobe-3.0\n", stdout);
1103   out.set_file(stdout);
1104   {
1105     extern const char *version_string;
1106     out.begin_comment("Creator:")
1107        .comment_arg("groff")
1108        .comment_arg("version")
1109        .comment_arg(version_string)
1110        .end_comment();
1111   }
1112   for (font_pointer_list *f = font_list; f; f = f->next) {
1113     ps_font *psf = (ps_font *)(f->p);
1114     rm.need_font(psf->get_internal_name());
1115   }
1116   rm.print_header_comments(out);
1117   out.begin_comment("Pages:").comment_arg(itoa(pages_output)).end_comment();
1118   out.begin_comment("PageOrder:").comment_arg("Ascend").end_comment();
1119 #if 0
1120   fprintf(out.get_file(), "%%%%DocumentMedia: () %g %g 0 () ()\n",
1121           font::paperwidth*72.0/font::res,
1122           paper_length*72.0/font::res);
1123 #endif
1124   out.begin_comment("Orientation:")
1125      .comment_arg(landscape_flag ? "Landscape" : "Portrait")
1126      .end_comment();
1127   if (ncopies != 1) {
1128     out.end_line();
1129     fprintf(out.get_file(), "%%%%Requirements: numcopies(%d)\n", ncopies);
1130   }
1131   out.simple_comment("EndComments");
1132   out.simple_comment("BeginProlog");
1133   rm.output_prolog(out);
1134   if (!(broken_flags & NO_SETUP_SECTION)) {
1135     out.simple_comment("EndProlog");
1136     out.simple_comment("BeginSetup");
1137   }
1138   rm.document_setup(out);
1139   out.put_symbol(dict_name).put_symbol("begin");
1140   if (ndefs > 0)
1141     ndefs += DEFS_DICT_SPARE;
1142   out.put_literal_symbol(defs_dict_name)
1143      .put_number(ndefs + 1)
1144      .put_symbol("dict")
1145      .put_symbol("def");
1146   out.put_symbol(defs_dict_name)
1147      .put_symbol("begin");
1148   out.put_literal_symbol("u")
1149      .put_delimiter('{')
1150      .put_fix_number(1)
1151      .put_symbol("mul")
1152      .put_delimiter('}')
1153      .put_symbol("bind")
1154      .put_symbol("def");
1155   defs += '\0';
1156   out.special(defs.contents());
1157   out.put_symbol("end");
1158   if (ncopies != 1)
1159     out.put_literal_symbol("#copies").put_number(ncopies).put_symbol("def");
1160   out.put_literal_symbol("RES").put_number(res).put_symbol("def");
1161   out.put_literal_symbol("PL");
1162   if (guess_flag)
1163     out.put_symbol("PLG");
1164   else
1165     out.put_fix_number(paper_length);
1166   out.put_symbol("def");
1167   out.put_literal_symbol("LS")
1168      .put_symbol(landscape_flag ? "true" : "false")
1169      .put_symbol("def");
1170   encode_fonts();
1171   out.simple_comment((broken_flags & NO_SETUP_SECTION)
1172                      ? "EndProlog"
1173                      : "EndSetup");
1174   out.end_line();
1175   out.copy_file(tempfp);
1176   fclose(tempfp);
1177 }
1178
1179 void ps_printer::special(char *arg, const environment *env)
1180 {
1181   typedef void (ps_printer::*SPECIAL_PROCP)(char *, const environment *);
1182   static struct {
1183     const char *name;
1184     SPECIAL_PROCP proc;
1185   } proc_table[] = {
1186     "exec", &ps_printer::do_exec,
1187     "def", &ps_printer::do_def,
1188     "mdef", &ps_printer::do_mdef,
1189     "import", &ps_printer::do_import,
1190     "file", &ps_printer::do_file,
1191     "invis", &ps_printer::do_invis,
1192     "endinvis", &ps_printer::do_endinvis,
1193   };
1194   for (char *p = arg; *p == ' ' || *p == '\n'; p++)
1195     ;
1196   char *tag = p;
1197   for (; *p != '\0' && *p != ':' && *p != ' ' && *p != '\n'; p++)
1198     ;
1199   if (*p == '\0' || strncmp(tag, "ps", p - tag) != 0) {
1200     error("X command without `ps:' tag ignored");
1201     return;
1202   }
1203   p++;
1204   for (; *p == ' ' || *p == '\n'; p++)
1205     ;
1206   char *command = p;
1207   for (; *p != '\0' && *p != ' ' && *p != '\n'; p++)
1208     ;
1209   if (*command == '\0') {
1210     error("X command without `ps:' tag ignored");
1211     return;
1212   }
1213   for (int i = 0; i < sizeof(proc_table)/sizeof(proc_table[0]); i++)
1214     if (strncmp(command, proc_table[i].name, p - command) == 0) {
1215       (this->*(proc_table[i].proc))(p, env);
1216       return;
1217     }
1218   error("X command `%1' not recognised", command);
1219 }
1220
1221 // A conforming PostScript document must not have lines longer
1222 // than 255 characters (excluding line termination characters).
1223
1224 static int check_line_lengths(const char *p)
1225 {
1226   for (;;) {
1227     const char *end = strchr(p, '\n');
1228     if (end == 0)
1229       end = strchr(p, '\0');
1230     if (end - p > 255)
1231       return 0;
1232     if (*end == '\0')
1233       break;
1234     p = end + 1;
1235   }
1236   return 1;
1237 }
1238
1239 void ps_printer::do_exec(char *arg, const environment *env)
1240 {
1241   flush_sbuf();
1242   while (csspace(*arg))
1243     arg++;
1244   if (*arg == '\0') {
1245     error("missing argument to X exec command");
1246     return;
1247   }
1248   if (!check_line_lengths(arg)) {
1249     error("lines in X exec command must not be more than 255 characters long");
1250     return;
1251   }
1252   out.put_fix_number(env->hpos)
1253      .put_fix_number(env->vpos)
1254      .put_symbol("EBEGIN")
1255      .special(arg)
1256      .put_symbol("EEND");
1257   output_hpos = output_vpos = -1;
1258   output_style.f = 0;
1259   output_draw_point_size = -1;
1260   output_line_thickness = -1;
1261   ndefined_styles = 0;
1262   if (!ndefs)
1263     ndefs = 1;
1264 }
1265
1266 void ps_printer::do_file(char *arg, const environment *env)
1267 {
1268   flush_sbuf();
1269   while (csspace(*arg))
1270     arg++;
1271   if (*arg == '\0') {
1272     error("missing argument to X file command");
1273     return;
1274   }
1275   const char *filename = arg;
1276   do {
1277     ++arg;
1278   } while (*arg != '\0' && *arg != ' ' && *arg != '\n');
1279   out.put_fix_number(env->hpos)
1280      .put_fix_number(env->vpos)
1281      .put_symbol("EBEGIN");
1282   rm.import_file(filename, out);
1283   out.put_symbol("EEND");
1284   output_hpos = output_vpos = -1;
1285   output_style.f = 0;
1286   output_draw_point_size = -1;
1287   output_line_thickness = -1;
1288   ndefined_styles = 0;
1289   if (!ndefs)
1290     ndefs = 1;
1291 }
1292
1293 void ps_printer::do_def(char *arg, const environment *)
1294 {
1295   flush_sbuf();
1296   while (csspace(*arg))
1297     arg++;
1298   if (!check_line_lengths(arg)) {
1299     error("lines in X def command must not be more than 255 characters long");
1300     return;
1301   }
1302   defs += arg;
1303   if (*arg != '\0' && strchr(arg, '\0')[-1] != '\n')
1304     defs += '\n';
1305   ndefs++;
1306 }
1307
1308 // Like def, but the first argument says how many definitions it contains.
1309
1310 void ps_printer::do_mdef(char *arg, const environment *)
1311 {
1312   flush_sbuf();
1313   char *p;
1314   int n = (int)strtol(arg, &p, 10);
1315   if (n == 0 && p == arg) {
1316     error("first argument to X mdef must be an integer");
1317     return;
1318   }
1319   if (n < 0) {
1320     error("out of range argument `%1' to X mdef command", int(n));
1321     return;
1322   }
1323   arg = p;
1324   while (csspace(*arg))
1325     arg++;
1326   if (!check_line_lengths(arg)) {
1327     error("lines in X mdef command must not be more than 255 characters long");
1328     return;
1329   }
1330   defs += arg;
1331   if (*arg != '\0' && strchr(arg, '\0')[-1] != '\n')
1332     defs += '\n';
1333   ndefs += n;
1334 }
1335
1336 void ps_printer::do_import(char *arg, const environment *env)
1337 {
1338   flush_sbuf();
1339   while (*arg == ' ' || *arg == '\n')
1340     arg++;
1341   for (char *p = arg; *p != '\0' && *p != ' ' && *p != '\n'; p++)
1342     ;
1343   if (*p != '\0')
1344     *p++ = '\0';
1345   int parms[6];
1346   int nparms = 0;
1347   while (nparms < 6) {
1348     char *end;
1349     long n = strtol(p, &end, 10);
1350     if (n == 0 && end == p)
1351       break;
1352     parms[nparms++] = int(n);
1353     p = end;
1354   }
1355   if (csalpha(*p) && (p[1] == '\0' || p[1] == ' ' || p[1] == '\n')) {
1356     error("scaling indicators not allowed in arguments for X import command");
1357     return;
1358   }
1359   while (*p == ' ' || *p == '\n')
1360     p++;
1361   if (nparms < 5) {
1362     if (*p == '\0')
1363       error("too few arguments for X import command");
1364     else
1365       error("invalid argument `%1' for X import command", p);
1366     return;
1367   }
1368   if (*p != '\0') {
1369     error("superflous argument `%1' for X import command", p);
1370     return;
1371   }
1372   int llx = parms[0];
1373   int lly = parms[1];
1374   int urx = parms[2];
1375   int ury = parms[3];
1376   int desired_width = parms[4];
1377   int desired_height = parms[5];
1378   if (desired_width <= 0) {
1379     error("bad width argument `%1' for X import command: must be > 0",
1380           desired_width);
1381     return;
1382   }
1383   if (nparms == 6 && desired_height <= 0) {
1384     error("bad height argument `%1' for X import command: must be > 0",
1385           desired_height);
1386     return;
1387   }
1388   if (llx == urx) {
1389     error("llx and urx arguments for X import command must not be equal");
1390     return;
1391   }
1392   if (lly == ury) {
1393     error("lly and ury arguments for X import command must not be equal");
1394     return;
1395   }
1396   if (nparms == 5) {
1397     int old_wid = urx - llx;
1398     int old_ht = ury - lly;
1399     if (old_wid < 0)
1400       old_wid = -old_wid;
1401     if (old_ht < 0)
1402       old_ht = -old_ht;
1403     desired_height = int(desired_width*(double(old_ht)/double(old_wid)) + .5);
1404   }
1405   if (env->vpos - desired_height < 0)
1406     warning("top of imported graphic is above the top of the page");
1407   out.put_number(llx)
1408      .put_number(lly)
1409      .put_fix_number(desired_width)
1410      .put_number(urx - llx)
1411      .put_fix_number(-desired_height)
1412      .put_number(ury - lly)
1413      .put_fix_number(env->hpos)
1414      .put_fix_number(env->vpos)
1415      .put_symbol("PBEGIN");
1416   rm.import_file(arg, out);
1417   // do this here just in case application defines PEND
1418   out.put_symbol("end");
1419   out.put_symbol("PEND");
1420 }
1421
1422 void ps_printer::do_invis(char *, const environment *)
1423 {
1424   invis_count++;
1425 }
1426
1427 void ps_printer::do_endinvis(char *, const environment *)
1428 {
1429   if (invis_count == 0)
1430     error("unbalanced `endinvis' command");
1431   else
1432     --invis_count;
1433 }
1434
1435 printer *make_printer()
1436 {
1437   return new ps_printer;
1438 }
1439
1440 static void usage();
1441
1442 int main(int argc, char **argv)
1443 {
1444   program_name = argv[0];
1445   static char stderr_buf[BUFSIZ];
1446   setbuf(stderr, stderr_buf);
1447   int c;
1448   while ((c = getopt(argc, argv, "F:glc:w:vb:")) != EOF)
1449     switch(c) {
1450     case 'v':
1451       {
1452         extern const char *version_string;
1453         fprintf(stderr, "grops version %s\n", version_string);
1454         fflush(stderr);
1455         break;
1456       }
1457     case 'c':
1458       if (sscanf(optarg, "%d", &ncopies) != 1 || ncopies <= 0) {
1459         error("bad number of copies `%s'", optarg);
1460         ncopies = 1;
1461       }
1462       break;
1463     case 'g':
1464       guess_flag = 1;
1465       break;
1466     case 'l':
1467       landscape_flag = 1;
1468       break;
1469     case 'F':
1470       font::command_line_font_dir(optarg);
1471       break;
1472     case 'w':
1473       if (sscanf(optarg, "%d", &linewidth) != 1 || linewidth < 0) {
1474         error("bad linewidth `%s'", optarg);
1475         linewidth = -1;
1476       }
1477       break;
1478     case 'b':
1479       // XXX check this
1480       broken_flags = atoi(optarg);
1481       bflag = 1;
1482       break;
1483     case '?':
1484       usage();
1485       break;
1486     default:
1487       assert(0);
1488     }
1489   font::set_unknown_desc_command_handler(handle_unknown_desc_command);
1490   if (optind >= argc)
1491     do_file("-");
1492   else {
1493     for (int i = optind; i < argc; i++)
1494       do_file(argv[i]);
1495   }
1496   delete pr;
1497   exit(0);
1498 }
1499
1500 static void usage()
1501 {
1502   fprintf(stderr, "usage: %s [-glv] [-b n] [-c n] [-w n] [-F dir] [files ...]\n",
1503           program_name);
1504   exit(1);
1505 }