src/devices/grolbp/lbp.cpp

   1 // -*- C++ -*-
   2 /* Copyright (C) 1994-2018 Free Software Foundation, Inc.
   3      Written by Francisco Andrés Verdú <pandres@dragonet.es> with many ideas
   4      taken from the other groff drivers.
   5
   6 This file is part of groff.
   7
   8 groff is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation, either version 3 of the License, or
  11 (at your option) any later version.
  12
  13 groff is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with this program.  If not, see <http://www.gnu.org/licenses/>. */
  20
  21 /*
  22 TODO
  23
  24  - Add X command to include bitmaps
  25 */
  26
  27 #include "driver.h"
  28 #include "lbp.h"
  29 #include "charset.h"
  30 #include "paper.h"
  31
  32 #include "nonposix.h"
  33
  34 extern "C" const char *Version_string;
  35
  36 static int user_papersize = -1;         // papersize
  37 static int orientation = -1;            // orientation
  38 static double user_paperlength = 0;     // Custom Paper size
  39 static double user_paperwidth = 0;
  40 static int ncopies = 1;                 // Number of copies
  41
  42 #define DEFAULT_LINEWIDTH_FACTOR 40     // 0.04em
  43 static int linewidth_factor = DEFAULT_LINEWIDTH_FACTOR;
  44
  45 static int set_papersize(const char *paperformat);
  46
  47 class lbp_font : public font {
  48 public:
  49   ~lbp_font();
  50   void handle_unknown_font_command(const char *command, const char *arg,
  51                                    const char *filename, int lineno);
  52   static lbp_font *load_lbp_font(const char *);
  53   char *lbpname;
  54   char is_scalable;
  55 private:
  56   lbp_font(const char *);
  57 };
  58
  59 class lbp_printer : public printer {
  60 public:
  61   lbp_printer(int, double, double);
  62   ~lbp_printer();
  63   void set_char(glyph *, font *, const environment *, int, const char *name);
  64   void draw(int code, int *p, int np, const environment *env);
  65   void begin_page(int);
  66   void end_page(int page_length);
  67   font *make_font(const char *);
  68   void end_of_line();
  69 private:
  70   void set_line_thickness(int size,const environment *env);
  71   void vdmstart();
  72   void vdmflush(); // the name vdmend was already used in lbp.h
  73   void setfillmode(int mode);
  74   void polygon( int hpos,int vpos,int np,int *p);
  75   char *font_name(const lbp_font *f, const int siz);
  76
  77   int fill_pattern;
  78   int fill_mode;
  79   int cur_hpos;
  80   int cur_vpos;
  81   lbp_font *cur_font;
  82   int cur_size;
  83   unsigned short cur_symbol_set;
  84   int line_thickness;
  85   int req_linethickness; // requested line thickness
  86   int papersize;
  87   int paperlength;      // custom paper size
  88   int paperwidth;
  89 };
  90
  91 lbp_font::lbp_font(const char *nm)
  92 : font(nm)
  93 {
  94 }
  95
  96 lbp_font::~lbp_font()
  97 {
  98 }
  99
 100 lbp_font *lbp_font::load_lbp_font(const char *s)
 101 {
 102   lbp_font *f = new lbp_font(s);
 103   f->lbpname = NULL;
 104   f->is_scalable = 1; // Default is that fonts are scalable
 105   if (!f->load()) {
 106     delete f;
 107     return 0;
 108   }
 109   return f;
 110 }
 111
 112
 113 void lbp_font::handle_unknown_font_command(const char *command,
 114                                            const char *arg,
 115                                            const char *filename, int lineno)
 116 {
 117   if (strcmp(command, "lbpname") == 0) {
 118     if (arg == 0)
 119       fatal_with_file_and_line(filename, lineno,
 120                                "'%1' command requires an argument",
 121                                command);
 122     this->lbpname = new char[strlen(arg) + 1];
 123     strcpy(this->lbpname, arg);
 124     // we recognize bitmapped fonts by the first character of its name
 125     if (arg[0] == 'N')
 126       this->is_scalable = 0;
 127     // fprintf(stderr, "Loading font \"%s\" \n", arg);
 128   }
 129   // fprintf(stderr, "Loading font  %s \"%s\" in %s at %d\n",
 130   //         command, arg, filename, lineno);
 131 }
 132
 133 static void wp54charset()
 134 {
 135   unsigned int i;
 136   lbpputs("\033[714;100;29;0;32;120.}");
 137   for (i = 0; i < sizeof(symset); i++)
 138     lbpputc(symset[i]);
 139   lbpputs("\033[100;0 D");
 140   return;
 141 }
 142
 143 lbp_printer::lbp_printer(int ps, double pw, double pl)
 144 : fill_pattern(1),
 145   fill_mode(0),
 146   cur_hpos(-1),
 147   cur_font(0),
 148   cur_size(0),
 149   cur_symbol_set(0),
 150   req_linethickness(-1)
 151 {
 152   SET_BINARY(fileno(stdout));
 153   lbpinit(stdout);
 154   lbpputs("\033c\033;\033[2&z\033[7 I\033[?32h\033[?33h\033[11h");
 155   wp54charset(); // Define the new symbol set
 156   lbpputs("\033[7 I\033[?32h\033[?33h\033[11h");
 157   // Paper size handling
 158   if (orientation < 0)
 159     orientation = 0;    // Default orientation is portrait
 160   papersize = 14;       // Default paper size is A4
 161   if (font::papersize) {
 162     papersize = set_papersize(font::papersize);
 163     paperlength = font::paperlength;
 164     paperwidth = font::paperwidth;
 165   }
 166   if (ps >= 0) {
 167     papersize = ps;
 168     paperlength = int(pl * font::res + 0.5);
 169     paperwidth = int(pw * font::res + 0.5);
 170   }
 171   if (papersize < 80)   // standard paper
 172     lbpprintf("\033[%dp", (papersize | orientation));
 173   else                  // Custom paper
 174     lbpprintf("\033[%d;%d;%dp", (papersize | orientation),
 175               paperlength, paperwidth);
 176   // Number of copies
 177   lbpprintf("\033[%dv\n", ncopies);
 178   lbpputs("\033[0u\033[1u\033P1y Grolbp\033\\");
 179   lbpmoveabs(0, 0);
 180   lbpputs("\033[0t\033[2t");
 181   lbpputs("\033('$2\033)' 1");  // Primary symbol set IBML
 182                                 // Secondary symbol set IBMR1
 183   cur_symbol_set = 0;
 184 }
 185
 186 lbp_printer::~lbp_printer()
 187 {
 188   lbpputs("\033P1y\033\\");
 189   lbpputs("\033c\033<");
 190 }
 191
 192 inline void lbp_printer::set_line_thickness(int size,const environment *env)
 193 {
 194       if (size == 0)
 195         line_thickness = 1;
 196       else {
 197         if (size < 0)
 198                 // line_thickness =
 199                 //   (env->size * (font::res/72)) * (linewidth_factor/1000)
 200                 // we ought to check for overflow
 201                 line_thickness =
 202                   env->size * linewidth_factor * font::res / 72000;
 203         else // size > 0
 204                 line_thickness = size;
 205       } // else from if (size == 0)
 206       if (line_thickness < 1)
 207         line_thickness = 1;
 208       if (vdminited())
 209         vdmlinewidth(line_thickness);
 210       req_linethickness = size; // an size requested
 211       /*  fprintf(stderr, "thickness: %d == %d, size %d, %d \n",
 212         size, line_thickness, env->size,req_linethickness); */
 213    return;
 214 } // lbp_printer::set_line_thickness
 215
 216 void lbp_printer::begin_page(int)
 217 {
 218 }
 219
 220 void lbp_printer::end_page(int)
 221 {
 222   if (vdminited())
 223     vdmflush();
 224   lbpputc('\f');
 225   cur_hpos = -1;
 226 }
 227
 228 void lbp_printer::end_of_line()
 229 {
 230   cur_hpos = -1;                // force absolute motion
 231 }
 232
 233 char *lbp_printer::font_name(const lbp_font *f, const int siz)
 234 {
 235   static char bfont_name[255];  // The resulting font name
 236   char type,    // Italic, Roman, Bold
 237        ori,     // Normal or Rotated
 238        *nam;    // The font name without other data.
 239   int cpi;      // The font size in characters per inch
 240                 // (bitmapped fonts are monospaced).
 241   /* Bitmap font selection is ugly in this printer, so don't expect
 242      this function to be elegant. */
 243   bfont_name[0] = 0x00;
 244   if (orientation)      // Landscape
 245     ori = 'R';
 246   else                  // Portrait
 247     ori = 'N';
 248   type = f->lbpname[strlen(f->lbpname) - 1];
 249   nam = new char[strlen(f->lbpname) - 2];
 250   strncpy(nam, &(f->lbpname[1]), strlen(f->lbpname) - 2);
 251   nam[strlen(f->lbpname) - 2] = 0x00;
 252   // fprintf(stderr, "Bitmap font '%s' %d %c %c \n", nam, siz, type, ori);
 253   /* Since these fonts are available only at certain sizes,
 254      10 and 17 cpi for courier,  12 and 17 cpi for elite,
 255      we adjust the resulting size. */
 256   cpi = 17;
 257   // Fortunately there are only two bitmapped fonts shipped with the printer.
 258   if (!strcasecmp(nam, "courier")) {
 259     // Courier font
 260     if (siz >= 12)
 261       cpi = 10;
 262     else cpi = 17;
 263   }
 264   if (!strcasecmp(nam, "elite")) {
 265     if (siz >= 10)
 266       cpi = 12;
 267     else cpi = 17;
 268   }
 269   // Now that we have all the data, let's generate the font name.
 270   if ((type != 'B') && (type != 'I')) // Roman font
 271     sprintf(bfont_name, "%c%s%d", ori, nam, cpi);
 272   else
 273     sprintf(bfont_name, "%c%s%d%c", ori, nam, cpi, type);
 274   return bfont_name;
 275 }
 276
 277 void lbp_printer::set_char(glyph *g, font *f, const environment *env,
 278                            int w, const char *)
 279 {
 280   int code = f->get_code(g);
 281   unsigned char ch = code & 0xff;
 282   unsigned short symbol_set = code >> 8;
 283   if (f != cur_font) {
 284     lbp_font *psf = (lbp_font *)f;
 285     // fprintf(stderr, "Loading font %s \"%d\" \n", psf->lbpname, env->size);
 286     if (psf->is_scalable) {
 287       // Scalable font selection is different from bitmaped
 288       lbpprintf("\033Pz%s.IBML\033\\\033[%d C", psf->lbpname,
 289                 (int)((env->size * font::res) / 72));
 290     }
 291     else
 292       // bitmapped font
 293       lbpprintf("\033Pz%s.IBML\033\\\n", font_name(psf, env->size));
 294     lbpputs("\033)' 1");        // Select IBML and IBMR1 symbol set
 295     cur_font = psf;
 296     cur_symbol_set = 0;
 297      // Update the line thickness if needed
 298     if ((req_linethickness < 0 ) && (env->size != cur_size))
 299         set_line_thickness(req_linethickness,env);
 300     cur_size = env->size;
 301   }
 302   if (symbol_set != cur_symbol_set) {
 303     if (cur_symbol_set == 3)
 304       // if current symbol set is Symbol we must restore the font
 305       lbpprintf("\033Pz%s.IBML\033\\\033[%d C", cur_font->lbpname,
 306                 (int)((env->size * font::res) / 72));
 307     switch (symbol_set) {
 308     case 0:
 309       lbpputs("\033('$2\033)' 1");      // Select IBML and IBMR1 symbol sets
 310       break;
 311     case 1:
 312       lbpputs("\033(d\033)' 1");        // Select wp54 symbol set
 313       break;
 314     case 2:
 315       lbpputs("\033('$2\033)'!0");      // Select IBMP symbol set
 316       break;
 317     case 3:
 318       lbpprintf("\033PzSymbol.SYML\033\\\033[%d C",
 319                 (int)((env->size * font::res) / 72));
 320       lbpputs("\033(\"!!0\033)\"!!1");  // Select symbol font
 321       break;
 322     case 4:
 323       lbpputs("\033)\"! 1\033(\"!$2");  // Select PS symbol set
 324       break;
 325     }
 326     cur_symbol_set = symbol_set;
 327   }
 328   if (env->size != cur_size) {
 329     if (!cur_font->is_scalable)
 330       lbpprintf("\033Pz%s.IBML\033\\\n", font_name(cur_font, env->size));
 331     else
 332       lbpprintf("\033[%d C", (int)((env->size * font::res) / 72));
 333     cur_size = env->size;
 334      // Update the line thickness if needed
 335     if (req_linethickness < 0 )
 336         set_line_thickness(req_linethickness,env);
 337   }
 338   if ((env->hpos != cur_hpos) || (env->vpos != cur_vpos)) {
 339     // lbpmoveabs(env->hpos - ((5 * 300) / 16), env->vpos);
 340     lbpmoveabs(env->hpos - 64, env->vpos - 64);
 341     cur_vpos = env->vpos;
 342     cur_hpos = env->hpos;
 343   }
 344   if ((ch & 0x7F) < 32)
 345     lbpputs("\033[1.v");
 346   lbpputc(ch);
 347   cur_hpos += w;
 348 }
 349
 350 void lbp_printer::vdmstart()
 351 {
 352   FILE *f;
 353   static int changed_origin = 0;
 354   errno = 0;
 355   f = tmpfile();
 356   // f = fopen("/tmp/gtmp","w+");
 357   if (f == NULL)
 358     perror("Opening temporary file");
 359   vdminit(f);
 360   if (!changed_origin) {        // we should change the origin only one time
 361     changed_origin = 1;
 362     vdmorigin(-63, 0);
 363   }
 364   vdmlinewidth(line_thickness);
 365 }
 366
 367 void
 368 lbp_printer::vdmflush()
 369 {
 370   char buffer[1024];
 371   int bytes_read = 1;
 372   vdmend();
 373   fflush(lbpoutput);
 374   /* let's copy the vdm code to the output */
 375   rewind(vdmoutput);
 376   do {
 377     bytes_read = fread(buffer, 1, sizeof(buffer), vdmoutput);
 378     bytes_read = fwrite(buffer, 1, bytes_read, lbpoutput);
 379   } while (bytes_read == sizeof(buffer));
 380   fclose(vdmoutput);    // This will also delete the file,
 381                         // since it is created by tmpfile()
 382   vdmoutput = NULL;
 383 }
 384
 385 inline void lbp_printer::setfillmode(int mode)
 386 {
 387   if (mode != fill_mode) {
 388     if (mode != 1)
 389       vdmsetfillmode(mode, 1, 0);
 390     else
 391       // To get black, we must use white inverted.
 392       vdmsetfillmode(mode, 1, 1);
 393
 394     fill_mode = mode;
 395   }
 396 }
 397
 398 inline void lbp_printer::polygon(int hpos, int vpos, int np, int *p)
 399 {
 400   int *points, i;
 401   points = new int[np + 2];
 402   points[0] = hpos;
 403   points[1] = vpos;
 404   // fprintf(stderr, "Polygon (%d,%d) ", points[0], points[1]);
 405   for (i = 0; i < np; i++)
 406     points[i + 2] = p[i];
 407   // for (i = 0; i < np; i++) fprintf(stderr, " %d ", p[i]);
 408   // fprintf(stderr, "\n");
 409   vdmpolygon((np /2) + 1, points);
 410 }
 411
 412 void lbp_printer::draw(int code, int *p, int np, const environment *env)
 413 {
 414   if ((req_linethickness < 0 ) && (env->size != cur_size))
 415                 set_line_thickness(req_linethickness,env);
 416
 417   switch (code) {
 418   case 't':
 419     if (np == 0)
 420       line_thickness = 1;
 421     else { // troff gratuitously adds an extra 0
 422       if (np != 1 && np != 2) {
 423         error("0 or 1 argument required for thickness");
 424         break;
 425       }
 426     set_line_thickness(p[0],env);
 427     }
 428     break;
 429   case 'l':     // Line
 430     if (np != 2) {
 431       error("2 arguments required for line");
 432       break;
 433     }
 434     if (!vdminited())
 435       vdmstart();
 436     vdmline(env->hpos, env->vpos, p[0], p[1]);
 437 /*     fprintf(stderr, "\nline: %d,%d - %d,%d thickness %d == %d\n",
 438              env->hpos - 64,env->vpos -64, env->hpos - 64 + p[0],
 439              env->vpos -64 + p[1], env->size, line_thickness);*/
 440     break;
 441   case 'R':     // Rule
 442     if (np != 2) {
 443       error("2 arguments required for Rule");
 444       break;
 445     }
 446     if (vdminited()) {
 447       setfillmode(fill_pattern); // Solid Rule
 448       vdmrectangle(env->hpos, env->vpos, p[0], p[1]);
 449     }
 450     else {
 451       lbpruleabs(env->hpos - 64, env->vpos -64, p[0], p[1]);
 452       cur_vpos = p[1];
 453       cur_hpos = p[0];
 454     }
 455     // fprintf(stderr, "\nrule: thickness %d == %d\n",
 456     //         env->size, line_thickness);
 457     break;
 458   case 'P':     // Filled Polygon
 459     if (!vdminited())
 460       vdmstart();
 461     setfillmode(fill_pattern);
 462     polygon(env->hpos, env->vpos, np, p);
 463     break;
 464   case 'p':     // Empty Polygon
 465     if (!vdminited())
 466       vdmstart();
 467     setfillmode(0);
 468     polygon(env->hpos, env->vpos, np, p);
 469     break;
 470   case 'C':     // Filled Circle
 471     if (!vdminited())
 472       vdmstart();
 473     // fprintf(stderr, "Circle (%d,%d) Fill %d\n",
 474     //         env->hpos, env->vpos, fill_pattern);
 475     setfillmode(fill_pattern);
 476     vdmcircle(env->hpos + (p[0]/2), env->vpos, p[0]/2);
 477     break;
 478   case 'c':     // Empty Circle
 479     if (!vdminited())
 480       vdmstart();
 481     setfillmode(0);
 482     vdmcircle(env->hpos + (p[0]/2), env->vpos, p[0]/2);
 483     break;
 484   case 'E':     // Filled Ellipse
 485     if (!vdminited())
 486       vdmstart();
 487     setfillmode(fill_pattern);
 488     vdmellipse(env->hpos + (p[0]/2), env->vpos, p[0]/2, p[1]/2, 0);
 489     break;
 490   case 'e':      // Empty Ellipse
 491     if (!vdminited())
 492       vdmstart();
 493     setfillmode(0);
 494     vdmellipse(env->hpos + (p[0]/2), env->vpos, p[0]/2, p[1]/2, 0);
 495     break;
 496   case 'a':     // Arc
 497     if (!vdminited())
 498       vdmstart();
 499     setfillmode(0);
 500     // VDM draws arcs clockwise and pic counterclockwise
 501     // We must compensate for that, exchanging the starting and
 502     // ending points
 503     vdmvarc(env->hpos + p[0], env->vpos+p[1],
 504             int(sqrt(double((p[0]*p[0]) + (p[1]*p[1])))),
 505             p[2], p[3],
 506             (-p[0]), (-p[1]), 1, 2);
 507     break;
 508   case '~':     // Spline
 509     if (!vdminited())
 510       vdmstart();
 511     setfillmode(0);
 512     vdmspline(np/2, env->hpos, env->vpos, p);
 513     break;
 514   case 'f':
 515     if (np != 1 && np != 2) {
 516       error("1 argument required for fill");
 517       break;
 518     }
 519     // fprintf(stderr, "Fill %d\n", p[0]);
 520     if ((p[0] == 1) || (p[0] >= 1000)) { // Black
 521       fill_pattern = 1;
 522       break;
 523     }
 524     if (p[0] == 0) { // White
 525       fill_pattern = 0;
 526       break;
 527     }
 528     if ((p[0] > 1) && (p[0] < 1000))
 529       {
 530         if (p[0] >= 990)  fill_pattern = -23;
 531         else if (p[0] >= 700)  fill_pattern = -28;
 532         else if (p[0] >= 500)  fill_pattern = -27;
 533         else if (p[0] >= 400)  fill_pattern = -26;
 534         else if (p[0] >= 300)  fill_pattern = -25;
 535         else if (p[0] >= 200)  fill_pattern = -22;
 536         else if (p[0] >= 100)  fill_pattern = -24;
 537         else fill_pattern = -21;
 538       }
 539     break;
 540   case 'F':
 541     // not implemented yet
 542     break;
 543   default:
 544     error("unrecognised drawing command '%1'", char(code));
 545     break;
 546   }
 547   return;
 548 }
 549
 550 font *lbp_printer::make_font(const char *nm)
 551 {
 552   return lbp_font::load_lbp_font(nm);
 553 }
 554
 555 printer *make_printer()
 556 {
 557   return new lbp_printer(user_papersize, user_paperwidth, user_paperlength);
 558 }
 559
 560 static struct {
 561   const char *name;
 562   int code;
 563 } lbp_papersizes[] =
 564   {{ "A4", 14 },
 565    { "letter", 30 },
 566    { "legal", 32 },
 567    { "executive", 40 },
 568   };
 569
 570 static int set_papersize(const char *paperformat)
 571 {
 572   unsigned int i;
 573   // First test for a standard (i.e. supported directly by the printer)
 574   // paper size
 575   for (i = 0 ; i < sizeof(lbp_papersizes) / sizeof(lbp_papersizes[0]); i++)
 576   {
 577     if (strcasecmp(lbp_papersizes[i].name,paperformat) == 0)
 578       return lbp_papersizes[i].code;
 579   }
 580   // Otherwise, we assume a custom paper size
 581   return 82;
 582 }
 583
 584 static void handle_unknown_desc_command(const char *command, const char *arg,
 585                                         const char *filename, int lineno)
 586 {
 587   // orientation command
 588   if (strcasecmp(command, "orientation") == 0) {
 589     // We give priority to command-line options
 590     if (orientation > 0)
 591       return;
 592     if (arg == 0)
 593       error_with_file_and_line(filename, lineno,
 594                                "'orientation' command requires an argument");
 595     else {
 596       if (strcasecmp(arg, "portrait") == 0)
 597         orientation = 0;
 598       else {
 599         if (strcasecmp(arg, "landscape") == 0)
 600           orientation = 1;
 601         else
 602           error_with_file_and_line(filename, lineno,
 603                                    "invalid argument to 'orientation' command");
 604       }
 605     }
 606   }
 607 }
 608
 609 static struct option long_options[] = {
 610   { "orientation", required_argument, NULL, 'o' },
 611   { "version", no_argument, NULL, 'v' },
 612   { "copies", required_argument, NULL, 'c' },
 613   { "landscape", no_argument, NULL, 'l' },
 614   { "papersize", required_argument, NULL, 'p' },
 615   { "linewidth", required_argument, NULL, 'w' },
 616   { "fontdir", required_argument, NULL, 'F' },
 617   { "help", no_argument, NULL, 'h' },
 618   { NULL, 0, 0, 0 }
 619 };
 620
 621 static void usage(FILE *stream)
 622 {
 623   fprintf(stream,
 624           "usage: %s [-lvh] [-c n] [-p paper_size] [-F dir] [-o or]\n"
 625           "       [-w width] [files ...]\n"
 626           "\n"
 627           "  -o --orientation=[portrait|landscape]\n"
 628           "  -v --version\n"
 629           "  -c --copies=numcopies\n"
 630           "  -l --landscape\n"
 631           "  -p --papersize=paper_size\n"
 632           "  -w --linewidth=width\n"
 633           "  -F --fontdir=dir\n"
 634           "  -h --help\n",
 635           program_name);
 636 }
 637
 638 int main(int argc, char **argv)
 639 {
 640   if (program_name == NULL)
 641     program_name = strsave(argv[0]);
 642   font::set_unknown_desc_command_handler(handle_unknown_desc_command);
 643   // command line parsing
 644   int c = 0;
 645   int option_index = 0;
 646   while (c >= 0) {
 647     c = getopt_long (argc, argv, "c:F:hI:lo:p:vw:",
 648                      long_options, &option_index);
 649     switch (c) {
 650     case 'F':
 651       font::command_line_font_dir(optarg);
 652       break;
 653     case 'I':
 654       // ignore include path arguments
 655       break;
 656     case 'p':
 657       {
 658         const char *s;
 659         if (!font::scan_papersize(optarg, &s,
 660                                   &user_paperlength, &user_paperwidth))
 661           error("invalid paper size '%1' ignored", optarg);
 662         else
 663           user_papersize = set_papersize(s);
 664         break;
 665       }
 666     case 'l':
 667       orientation = 1;
 668       break;
 669     case 'v':
 670       printf("GNU grolbp (groff) version %s\n", Version_string);
 671       exit(0);
 672       break;
 673     case 'o':
 674       if (strcasecmp(optarg, "portrait") == 0)
 675         orientation = 0;
 676       else {
 677         if (strcasecmp(optarg, "landscape") == 0)
 678           orientation = 1;
 679         else
 680           error("unknown orientation '%1'", optarg);
 681       }
 682       break;
 683     case 'c':
 684       {
 685         char *ptr;
 686         long n = strtol(optarg, &ptr, 10);
 687         if ((n <= 0) && (ptr == optarg))
 688           error("argument for -c must be a positive integer");
 689         else if (n <= 0 || n > 32767)
 690           error("out of range argument for -c");
 691         else
 692           ncopies = unsigned(n);
 693         break;
 694       }
 695     case 'w':
 696       {
 697         char *ptr;
 698         long n = strtol(optarg, &ptr, 10);
 699         if (n == 0 && ptr == optarg)
 700           error("argument for -w must be a non-negative integer");
 701         else if (n < 0 || n > INT_MAX)
 702           error("out of range argument for -w");
 703         else
 704           linewidth_factor = int(n);
 705         break;
 706       }
 707     case 'h':
 708       usage(stdout);
 709       exit(0);
 710       break;
 711     case '?':
 712       usage(stderr);
 713       exit(1);
 714       break;
 715     }
 716   }
 717   if (optind >= argc)
 718     do_file("-");
 719   while (optind < argc)
 720     do_file(argv[optind++]);
 721   if (lbpoutput)
 722     lbpputs("\033c\033<");
 723   return 0;
 724 }