home *** CD-ROM | disk | FTP | other *** search
/ Usenet 1994 October / usenetsourcesnewsgroupsinfomagicoctober1994disk2.iso / misc / volume30 / psf3 / patch03a next >
Text File  |  1992-06-19  |  65KB  |  2,485 lines
  1. Newsgroups: comp.sources.misc
  2. From: tony@ajfcal.cuc.ab.ca (Tony Field)
  3. Subject:  v30i050:  psf3 - Postscript print filter system, Patch03a/4
  4. Message-ID: <csm-v30i050=psf3.151734@sparky.IMD.Sterling.COM>
  5. X-Md4-Signature: 9a19de9ac547b782895b878a9158ffe3
  6. Date: Sun, 14 Jun 1992 20:17:58 GMT
  7. Approved: kent@sparky.imd.sterling.com
  8.  
  9. Submitted-by: tony@ajfcal.cuc.ab.ca (Tony Field)
  10. Posting-number: Volume 30, Issue 50
  11. Archive-name: psf3/patch03a
  12. Environment: ISC, SUNOS, SYSVR3, DOS
  13. Patch-To: psf3: Volume 27, Issue 91-100
  14.  
  15.    PSF is a postscript print filter system designed to give reasonable
  16.    control over text output to a postscript printer. If desired, psf can
  17.    be installed as a filter for the lp/lpsched or lpr/lpd spooling systems.
  18.  
  19.    Printed output may be configured for:
  20.  
  21.         o  1-up, 2-up or 4-up on a page, landscape/portrait
  22.         o  fonts/point size
  23.         o  double sided printing
  24.         o  pages scaled by row and column count
  25.         o  lp banner page printing
  26.         o  reverse order printing
  27.         o  languages other than English
  28.         o  optional ISO Latin1 character encoding
  29.         o  left, right, top, bottom margin sizes
  30.         o  line clipping or left/right justified line wrap
  31.         o  page usage accounting
  32.         o  printing to a pipe for multiple filtering in a spooler
  33.            or for printing to an Apple network printer (via papif?)
  34.  
  35. This is the final set of enhancements to psf.
  36. As of this version, the following has been added:
  37.  
  38.      1. ISO-Latin1 encoding supported.
  39.      
  40.      2. Page usage accounting added (printcap "af" support)
  41.      
  42.      3. Psf can read page statistics from a serial/ethernet printer
  43.         (printcap "rw" support).
  44.      
  45.      4. If the printer supports duplex double sided printing,
  46.         the feature is invoked with -D
  47.      
  48.      5. Printing a ctl/D at eoj is not done unless psf is
  49.         printing to a printer device.
  50.      
  51.      6. the -u option to select alternate printer definition files
  52.         now works if psf is used as part of the spooler filter system.
  53.      
  54.      7. Some printer definitions in ./def have been fixed.
  55.  
  56.      8. psf can print to a pipe with the -O option.  Hopefully,
  57.         this allows printing to an apple network.  Usually, this
  58.         is installed as a print option in psfprint.def (for lpr/lpd).
  59. FTP
  60. ^^^
  61.    The current version of psf may be obtained by ftp from the
  62.    University of Calgary:
  63.    
  64.     host:      fsa.cpsc.ucalgary.ca, cpsc.ucalgary.ca or 136.159.2.1
  65.     login:     anonymous
  66.     password:  is your mail address, by convention
  67.     files:     pub/psf/psf3.5.tar.Z
  68.  
  69. These patches are applied to psf3, at patchlevel 3.  (NOTE: patchlevel 4
  70. was never posted to the net)
  71.  
  72. Apply these patch files with:
  73.  
  74.     patch -p -N < PatchXXX
  75.     
  76.  
  77.  --------------------- snip/snip --------------------------
  78.  
  79. *** net/psf.c    Sun Apr 19 13:33:26 1992
  80. --- psf.c    Tue Jun  2 02:18:45 1992
  81. ***************
  82. *** 5,53 ****
  83.   *    Print text files to postscript printer.                                    *
  84.   *                                                                            *
  85.   *    Tony Field: tony@ajfcal.cuc.ab.ca                                        *
  86.   ****************************************************************************/
  87.   /*
  88. !  * $Id: psf.c,v 3.3 1992/02/07 15:10:57 ajf Exp ajf $
  89.   */
  90.   /*    Three versions of psf can be compiled:
  91.   
  92.           psf:        postscript filter for command line use.
  93.               
  94.           psffilter:    used with lp/lpsched.  accepts command line argument.
  95.                       Input on stdin. compile with -DPSFFILTER.
  96.   
  97. !         psflpd:        used with lpr/lpd.  does not accept command line
  98. !                     arguments.  compile with -DPSFFILTER -DFORLPD
  99.    */
  100.   
  101.   #include <stdio.h>
  102.   #include <string.h>
  103.   #include <setjmp.h>
  104. ! #include <math.h>
  105. ! #include <time.h>
  106. ! #include <signal.h>
  107. ! #include "ctp.h"
  108. ! #include "patchlevel.h"
  109. ! #include "psf.h"
  110. ! #include "psfproto.h"
  111.   
  112. ! #if defined(MSDOS)  ||  defined (__MSDOS__)
  113. ! #ifndef BINDIR
  114. ! #define BINDIR "c:/bin"
  115.   #endif
  116. ! #ifndef PDEF
  117. ! #define PDEF "c:/lib/psfprint.def"
  118.   #endif
  119.   #endif
  120. - 
  121. - #ifndef PAPERTYPE
  122. - #define PAPERTYPE "letter"
  123.   #endif
  124. ! #ifndef PSFDOUB
  125. ! #define PSFDOUB "psfdoub"
  126.   #endif
  127.   
  128.   /*    set up the mechanism for underline display */
  129.   
  130.   #define SHOWU(fp,ps)    fprintf (fp, ") %d showuline\n", ps)
  131.   
  132. --- 5,56 ----
  133.   *    Print text files to postscript printer.                                    *
  134.   *                                                                            *
  135.   *    Tony Field: tony@ajfcal.cuc.ab.ca                                        *
  136.   ****************************************************************************/
  137.   /*
  138. !  * $Id: psf.c,v 3.5 1992/06/02 08:16:01 ajf Exp ajf $
  139.   */
  140.   /*    Three versions of psf can be compiled:
  141.   
  142.           psf:        postscript filter for command line use.
  143.               
  144.           psffilter:    used with lp/lpsched.  accepts command line argument.
  145.                       Input on stdin. compile with -DPSFFILTER.
  146.   
  147. !         psflpd:        like psffilter, but for lpr/lpd.
  148. !                     compile with -DPSFFILTER -DFORLPD
  149.    */
  150.   
  151.   #include <stdio.h>
  152. + #include <errno.h>
  153.   #include <string.h>
  154.   #include <setjmp.h>
  155. ! #include <sys/types.h>
  156.   
  157. ! #ifdef ISC22
  158. ! #define pid_t short
  159.   #endif
  160. ! 
  161. ! #if !defined(MSDOS)  &&  !defined(__MSDOS__)
  162. ! #include <sys/wait.h>
  163. ! #ifndef WEXITSTATUS
  164. ! #define WEXITSTATUS(stat_val) ((unsigned)(stat_val) >> 8)
  165. ! #undef WIFEXITED /* Avoid 4.3BSD incompatibility with Posix.  */
  166.   #endif
  167. + #ifndef WIFEXITED
  168. + #define WIFEXITED(stat_val) (!((stat_val) & 255))
  169.   #endif
  170.   #endif
  171. ! #include <math.h>
  172. ! #include <time.h>
  173. ! #if defined(MSDOS)  ||  defined(__MSDOS__)
  174. ! #include <process.h>
  175.   #endif
  176. + #include <signal.h>
  177. + #include "ctp.h"
  178. + #include "patchlevel.h"
  179. + #include "psf.h"
  180.   
  181.   /*    set up the mechanism for underline display */
  182.   
  183.   #define SHOWU(fp,ps)    fprintf (fp, ") %d showuline\n", ps)
  184.   
  185. ***************
  186. *** 57,76 ****
  187.   #define NORMAL        0x00        /* bitset for  print_attributes                */
  188.   #define ITALICS        0x01
  189.   #define BOLD        0x02
  190.   #define UNDERLINE    0x04        /* must be 0x04.  underline is not a font    */
  191.   
  192.   #define CTLD_EOJ    0x04        /* ctl/d is end of postscript job.            */
  193.   
  194.   /*    Paper physical dimensions.
  195.       The default paper sizes is for a NEC LC890 and is overridden in
  196.       "psfprint.def".
  197.   */
  198.   
  199.   typedef struct                     /*    measurement in point                    */
  200.   {    char    paper_name[60];        /*    name of paper size (for command line)    */
  201. !     char    paper_tray[100];    /*    postscript operator to select this tray    */
  202.       int        width;                /*    portrait point width of paper            */
  203.       int        height;                /*    portrait point height of paper            */
  204.       int        lx, ly, ux, uy;
  205.       int        left_marg;            /*    margin widths (unprintable area)        */
  206.       int        bot_marg;            /*            "                                */
  207. --- 60,84 ----
  208.   #define NORMAL        0x00        /* bitset for  print_attributes                */
  209.   #define ITALICS        0x01
  210.   #define BOLD        0x02
  211.   #define UNDERLINE    0x04        /* must be 0x04.  underline is not a font    */
  212.   
  213. + #define CTLC_CANCEL 0x03        /*    ctl/c is cancel current job                */
  214.   #define CTLD_EOJ    0x04        /* ctl/d is end of postscript job.            */
  215. + #define REQUEST_STATUS     '\024'    /* ^T */
  216. + char c_CTLC_CANCEL[] = { CTLD_EOJ, CTLC_CANCEL } ;
  217. + #define READ_ERROR    -2            /*    error cond when read from printer port    */
  218. + 
  219.   
  220.   /*    Paper physical dimensions.
  221.       The default paper sizes is for a NEC LC890 and is overridden in
  222.       "psfprint.def".
  223.   */
  224.   
  225.   typedef struct                     /*    measurement in point                    */
  226.   {    char    paper_name[60];        /*    name of paper size (for command line)    */
  227. !     char    paper_tray[200];    /*    postscript operator to select this tray    */
  228.       int        width;                /*    portrait point width of paper            */
  229.       int        height;                /*    portrait point height of paper            */
  230.       int        lx, ly, ux, uy;
  231.       int        left_marg;            /*    margin widths (unprintable area)        */
  232.       int        bot_marg;            /*            "                                */
  233. ***************
  234. *** 102,111 ****
  235. --- 110,120 ----
  236.                   "",
  237.                    0, 0,  0,  0, 0, 0, 0, 0, 0, 0 
  238.               }
  239.   };
  240.   
  241. + char    duplex_mode[200] = "\0";
  242.   char    order_default[20] = "Normal";
  243.   char    order_normal[100] = "\0";
  244.   char    order_reverse[100] = "\0";
  245.   char    *order_command = NULL;
  246.   
  247. ***************
  248. *** 122,138 ****
  249.   int        y_top_offset;            /*    offsets for each frame                    */
  250.   int        x_left_offset;
  251.   int        dx_home[4];                /*    page frame home (0,0) translations        */
  252.   int        dy_home[4];
  253.   
  254. - int        x,y;                    /* current x,y coordinate                    */
  255.   double    scale_x, scale_y;        /* scale factors for 2-up, 4-up printing    */
  256.   int        real_width;
  257.   
  258.   long    *pg_loc;                /* double side print byte ptr to %%Page:    */
  259.   int        npg_loc;                /* number of elements in pg_loc[]            */
  260.   
  261.   int        book             = 0;    /* book format: double sided                */
  262.   int        bookwork        = 0;    /* book format, 2-up print                    */
  263.   int        lines_on_page     = 60;    /* user print lines on page                    */
  264.   int        lines_total     = 0;    /* total number of lines for scale purposes    */
  265.   int        chars_on_line     = 80;    /* default number of chars on line            */
  266. --- 131,147 ----
  267.   int        y_top_offset;            /*    offsets for each frame                    */
  268.   int        x_left_offset;
  269.   int        dx_home[4];                /*    page frame home (0,0) translations        */
  270.   int        dy_home[4];
  271.   
  272.   double    scale_x, scale_y;        /* scale factors for 2-up, 4-up printing    */
  273.   int        real_width;
  274.   
  275.   long    *pg_loc;                /* double side print byte ptr to %%Page:    */
  276.   int        npg_loc;                /* number of elements in pg_loc[]            */
  277.   
  278. + int        duplex            = 0;    /* duplex mode                                */
  279.   int        book             = 0;    /* book format: double sided                */
  280.   int        bookwork        = 0;    /* book format, 2-up print                    */
  281.   int        lines_on_page     = 60;    /* user print lines on page                    */
  282.   int        lines_total     = 0;    /* total number of lines for scale purposes    */
  283.   int        chars_on_line     = 80;    /* default number of chars on line            */
  284. ***************
  285. *** 175,184 ****
  286. --- 184,194 ----
  287.   int        end_of_file        = 0;    /* end of printing file                        */
  288.   int        save_point_size ;        /* save original point size for headers        */
  289.   int        n_chars;                /*    number of characters on a line            */
  290.   int        reverse_order    = 0;    /*     print in reverse_order                    */
  291.   int        reverse_requested = 0;    /*    user option for reverse order            */
  292. + int        gen_eoj            = 0;    /*    psf: generate ctl/d on end of file        */
  293.   char    fname[100];
  294.   char    now[50];                /* time of day for page headers             */
  295.   
  296.   #ifdef HOPPER
  297.   int        hopper_available = 1;
  298. ***************
  299. *** 216,253 ****
  300.       "Helvetica-Condensed",        "Helvetica-Condensed-Oblique", "Helvetica-Condensed-Bold", "Helvetica-Condensed-BoldObl",
  301.       "ZapfChancery-MediumItalic","ZapfChancery-MediumItalic","ZapfChancery-MediumItalic","ZapfChancery-MediumItalic"
  302.   } ;
  303.   
  304.   int    fonts_used[NFONTS];
  305.   int    fonts_have[NFONTS];
  306.   unsigned char    xlate[256];            /*    translation vector     */
  307.   int        need_xlate = 0;                /*    no default xlate    */
  308.   char    copyfile[150];                /*    copy file name from psfprint.def */
  309.   
  310.   int    max_frame    = 1;        /* max number of frames in use */
  311.   int    frame        = -1;        /* current frame in use */
  312.   
  313.   FILE    *input_fp, *output_fp;
  314.   
  315.   /*    input line and input line pointer */
  316.   char    *c;
  317.   char    line[LONG_STR + 1];
  318.   char    shortline[150];
  319.   
  320.   char    *pgmname;
  321.   
  322. - void catch();
  323.   jmp_buf eof_env;
  324.   
  325.   char    *defref = NULL;
  326.   FILE    *pdef = NULL;        /*    psfprint.def file    */
  327.   
  328.   char *ascii_hex = "0123456789abcdefghijklmnopqrstuvwxyz";
  329. ! extern int atoi(), getpid();
  330.   
  331.   char *malloc();
  332.   
  333.   /****************************************************************************
  334.   *    main ()                                                                    *
  335.   ****************************************************************************/
  336.   
  337.   main (argc, argv)
  338. --- 226,292 ----
  339.       "Helvetica-Condensed",        "Helvetica-Condensed-Oblique", "Helvetica-Condensed-Bold", "Helvetica-Condensed-BoldObl",
  340.       "ZapfChancery-MediumItalic","ZapfChancery-MediumItalic","ZapfChancery-MediumItalic","ZapfChancery-MediumItalic"
  341.   } ;
  342.   
  343.   int    fonts_used[NFONTS];
  344. + int    fonts_iso[NFONTS];                /*    ioslatin1 encoded    */
  345. + 
  346. + #ifdef ISO
  347. + int    isolatin = 1;                    /*    enable ISOLatin1Encoding by default */
  348. + #else
  349. + int    isolatin = 0;                    /*    disable ISOLatin1Encoding by default */
  350. + #endif
  351. + 
  352.   int    fonts_have[NFONTS];
  353.   unsigned char    xlate[256];            /*    translation vector     */
  354.   int        need_xlate = 0;                /*    no default xlate    */
  355.   char    copyfile[150];                /*    copy file name from psfprint.def */
  356.   
  357.   int    max_frame    = 1;        /* max number of frames in use */
  358.   int    frame        = -1;        /* current frame in use */
  359.   
  360.   FILE    *input_fp, *output_fp;
  361. + char    *pipe_name;
  362.   
  363.   /*    input line and input line pointer */
  364.   char    *c;
  365.   char    line[LONG_STR + 1];
  366.   char    shortline[150];
  367.   
  368.   char    *pgmname;
  369.   
  370.   jmp_buf eof_env;
  371.   
  372.   char    *defref = NULL;
  373.   FILE    *pdef = NULL;        /*    psfprint.def file    */
  374.   
  375.   char *ascii_hex = "0123456789abcdefghijklmnopqrstuvwxyz";
  376. ! #if !defined(MSDOS)  &&  !defined(__MSDOS__)
  377. ! extern int getpid();
  378. ! #endif
  379. ! extern int atoi();
  380.   
  381.   char *malloc();
  382.   
  383. + char *account_file_name = NULL;        /*    accounting file name                */
  384. + char *host = NULL;                    /*    accounting host                        */
  385. + char *user = NULL;                    /*    accounting user                        */
  386. + int    printfd = 1;                    /*    read from stdout                    */
  387. + int    pid;                            /*    pid for accounting                    */
  388. + int    read_access = 0;                /*    spooler can read from printer, too     */
  389. + long pages_written = 0;                /*    page count if no access to printer    */
  390. + 
  391. + #ifdef __STDC__
  392. + measure *locate_pagetype(char *desired, int printerr);
  393. + #else
  394. + measure *locate_pagetype();
  395. + #endif
  396. + 
  397. + 
  398. + #include "psfproto.h"
  399. + 
  400. + 
  401.   /****************************************************************************
  402.   *    main ()                                                                    *
  403.   ****************************************************************************/
  404.   
  405.   main (argc, argv)
  406. ***************
  407. *** 255,283 ****
  408.   char    *argv[];
  409.   {    int        c, i, j, number;
  410.       extern char *optarg;
  411.       extern int    optind, getopt();
  412.       char    bookfile[100];
  413. -     char    *env_fname;            /*    environment specified output file */
  414.       char    *getenv();
  415.       int        narrow2x;
  416. !     char    alt_cmd[200];
  417.       char    *new_marg;
  418.       int        want_stats = 0;
  419.   
  420.       if ((pgmname = strrchr (argv[0], '/'))
  421.               || (pgmname = strrchr (argv[0], '\\'))
  422.               || (pgmname = strrchr (argv[0], ':')))
  423.           pgmname++;
  424.       else
  425.           pgmname = argv[0];
  426.   
  427.       copyfile[0] = 0;
  428.       for (i = 0; i < 256;  i++)            /*    initial xlate = no translation */
  429.           xlate[i] = i;
  430.       for (i = font_count;  i < NFONTS;  i++)
  431.           fonts[i] = "N/A";
  432.   
  433.       defref = NULL;
  434.       for (i = 0;  i < argc;  i++)        /*    if user sets -u alt.def */
  435.       {    if (strncmp (argv[i], "-u", 2) == 0)
  436.           {    if (strlen (argv[i]) > 2)
  437. --- 294,329 ----
  438.   char    *argv[];
  439.   {    int        c, i, j, number;
  440.       extern char *optarg;
  441.       extern int    optind, getopt();
  442.       char    bookfile[100];
  443.       char    *getenv();
  444.       int        narrow2x;
  445. !     char    *alt_cmd;
  446.       char    *new_marg;
  447.       int        want_stats = 0;
  448. +     char    alt_def_file[200];
  449. +     double    atof();
  450. +     int        modified_argv = 0;
  451. + 
  452. +     pid = getpid();
  453.   
  454.       if ((pgmname = strrchr (argv[0], '/'))
  455.               || (pgmname = strrchr (argv[0], '\\'))
  456.               || (pgmname = strrchr (argv[0], ':')))
  457.           pgmname++;
  458.       else
  459.           pgmname = argv[0];
  460.   
  461.       copyfile[0] = 0;
  462. +     pipe_name = NULL;
  463.       for (i = 0; i < 256;  i++)            /*    initial xlate = no translation */
  464.           xlate[i] = i;
  465.       for (i = font_count;  i < NFONTS;  i++)
  466.           fonts[i] = "N/A";
  467. +     for (i = 0;  i < NFONTS;  i++)
  468. +         fonts_iso[i] = 0;
  469.   
  470.       defref = NULL;
  471.       for (i = 0;  i < argc;  i++)        /*    if user sets -u alt.def */
  472.       {    if (strncmp (argv[i], "-u", 2) == 0)
  473.           {    if (strlen (argv[i]) > 2)
  474. ***************
  475. *** 292,302 ****
  476.               defref = PDEF;
  477.       }
  478.   
  479.       /*    Read the .def file if it exists    */
  480.   
  481. !     alt_cmd[0] = '\0';
  482.       if (access (defref, 0)  &&  defref != PDEF
  483.                               &&  strchr (defref, '/') == NULL  
  484.                               &&  strchr (defref, '\\') == NULL)
  485.       {    /* see if file is in same directory as PDEF */
  486.           char *c, *strrchr();
  487. --- 338,349 ----
  488.               defref = PDEF;
  489.       }
  490.   
  491.       /*    Read the .def file if it exists    */
  492.   
  493. ! redo_def:
  494. !     alt_cmd = malloc (200);
  495.       if (access (defref, 0)  &&  defref != PDEF
  496.                               &&  strchr (defref, '/') == NULL  
  497.                               &&  strchr (defref, '\\') == NULL)
  498.       {    /* see if file is in same directory as PDEF */
  499.           char *c, *strrchr();
  500. ***************
  501. *** 316,354 ****
  502.           
  503.       if ((pdef = fopen (defref, "r")) != NULL)
  504.       {    char    line_type[50];
  505.   #if defined(FORLPD)
  506.           char    *quote, *word;
  507. !         int        modified_argv = 0;
  508.   
  509.           /*    read lpd options from psfprint.def.  Format is:
  510.                   *psflpd argv0name opt1 opt2 opt3...
  511.           */            
  512.           while (fgets (alt_cmd, 200, pdef))
  513.           {    if (*alt_cmd == '#')
  514.                   continue;
  515.               alt_cmd[199] = '\0';
  516.               trim (alt_cmd);
  517. !             word = strtok (alt_cmd, " \t");
  518.               if (strcmp (word, "*psflpd") == 0)
  519. !             {    word = strtok (NULL, " \t");
  520.                   if (strcmp (word, pgmname) == 0)
  521. !                 {    argv = (char **) malloc (sizeof (char *) * 50);
  522.                       argv[0] = word;
  523.                       modified_argv = 1;
  524. !                     for (argc = 1;  word = strtok (NULL, " \t");  argc++)
  525.                       {    if (*word == '#')    /* quite on comments */
  526.                               break;
  527. !                         argv[argc] = word;
  528.                       }
  529.                       argv[argc] = NULL;
  530.                       break;
  531.                   }
  532.               }
  533.               else if (strcmp (word, "*printer") == 0)
  534.                   break;
  535.           }
  536.           if (modified_argv == 0)
  537.           {    argc = 1;
  538.               argv[1] = NULL;
  539.           }
  540.   
  541. --- 363,452 ----
  542.           
  543.       if ((pdef = fopen (defref, "r")) != NULL)
  544.       {    char    line_type[50];
  545.   #if defined(FORLPD)
  546.           char    *quote, *word;
  547. !         int        want_new_def = 0;
  548. ! 
  549. !         /*    get original host, user, and accounting file */
  550. !         
  551. !         if (modified_argv == 0)
  552. !         {
  553. !             while ((c = getopt(argc, argv, "cw:l:i:n:h:")) != -1)
  554. !             {    switch (c)
  555. !                 {
  556. !                 case 'n':    user = optarg;        break;
  557. !                 case 'h':    host = optarg;        break;
  558. !                 case 'c':
  559. !                 case 'w':
  560. !                 case 'l':
  561. !                 case 'i':    continue;
  562. !                 default: ;
  563. !                 }
  564. !             }
  565. !             if (optind == argc - 1)
  566. !                 account_file_name = argv[optind];
  567. !             else
  568. !                 account_file_name = NULL;
  569. !         }
  570.   
  571.           /*    read lpd options from psfprint.def.  Format is:
  572.                   *psflpd argv0name opt1 opt2 opt3...
  573. +             If -u is in the options, read the new def file.
  574.           */            
  575. + 
  576. +         optind = 1;         /* reset getopt for possibly new arg list */
  577.           while (fgets (alt_cmd, 200, pdef))
  578.           {    if (*alt_cmd == '#')
  579.                   continue;
  580.               alt_cmd[199] = '\0';
  581.               trim (alt_cmd);
  582. !             word = nexttok (alt_cmd, " \t'\"");
  583.               if (strcmp (word, "*psflpd") == 0)
  584. !             {    word = nexttok (NULL, " \t'\"");
  585.                   if (strcmp (word, pgmname) == 0)
  586. !                 {    /*    create a new argument vector */
  587. !                     argv = (char **) malloc (sizeof (char *) * 50);
  588.                       argv[0] = word;
  589.                       modified_argv = 1;
  590. !                     argc = 1;
  591. !                     while (word = nexttok (NULL, " \t'\""))
  592.                       {    if (*word == '#')    /* quite on comments */
  593.                               break;
  594. !                         if (strncmp (word, "-u", 2) == 0)
  595. !                         {    /*    get another .def file - but keep all
  596. !                                 provided arguments.
  597. !                             */
  598. !                             if (strlen (word) == 2)
  599. !                             {    word = nexttok (NULL, " \t'\"");
  600. !                                 if (word)
  601. !                                     strcpy (alt_def_file, word);
  602. !                                 else
  603. !                                 {    fprintf (stderr, "%s: invalid -u option\n", pgmname);
  604. !                                     exit (DISCARD_JOB);
  605. !                                 }
  606. !                             }
  607. !                             else
  608. !                                 strcpy (alt_def_file, word + 2);
  609. !                             defref = alt_def_file;
  610. !                             want_new_def = 1;
  611. !                         }
  612. !                         else
  613. !                             argv[argc++] = word;
  614.                       }
  615.                       argv[argc] = NULL;
  616.                       break;
  617.                   }
  618.               }
  619.               else if (strcmp (word, "*printer") == 0)
  620.                   break;
  621.           }
  622. +         if (want_new_def)
  623. +         {    pdef = NULL;
  624. +             fclose (pdef);
  625. +             goto redo_def;
  626. +         }
  627.           if (modified_argv == 0)
  628.           {    argc = 1;
  629.               argv[1] = NULL;
  630.           }
  631.   
  632. ***************
  633. *** 445,454 ****
  634. --- 543,558 ----
  635.                       strcpy (slots[i], line);
  636.                       j = i;
  637.                   }
  638.                   nslots = j + 1;
  639.               }
  640. +             else if (strcmp (line_type, "*duplex") == 0)
  641. +             {    for (i = 0;  i < number;  i++)
  642. +                 {    if (fgets (duplex_mode, 200, pdef) == NULL)
  643. +                         bad_file();
  644. +                 }
  645. +             }
  646.   
  647.               else if (strcmp (line_type, "*eof") == 0)
  648.                   break;
  649.               else
  650.                   bad_file();
  651. ***************
  652. *** 459,475 ****
  653.       {    for (i = 0;  i < font_count;  i++)
  654.               fonts_have[i] = 1;
  655.       }
  656.   
  657.   #ifdef PAPERTYPE
  658. !     for (i = 0;  page_types[i].paper_name[0];  i++)
  659. !     {    if (strcmp (page_types[i].paper_name, PAPERTYPE) == 0)
  660. !         {    p = &page_types[i];
  661. !             break;
  662. !         }
  663. !     }
  664. !     if (page_types[i].paper_name[0] == '\0')
  665.           p = &page_types[0];
  666.   #else
  667.       p = &page_types[0];            /* default to letter size paper    */
  668.   #endif    /* PAPERTYPE */
  669.   
  670. --- 563,574 ----
  671.       {    for (i = 0;  i < font_count;  i++)
  672.               fonts_have[i] = 1;
  673.       }
  674.   
  675.   #ifdef PAPERTYPE
  676. !     p = locate_pagetype (PAPERTYPE, 1);
  677. !     if (p == NULL)
  678.           p = &page_types[0];
  679.   #else
  680.       p = &page_types[0];            /* default to letter size paper    */
  681.   #endif    /* PAPERTYPE */
  682.   
  683. ***************
  684. *** 477,487 ****
  685.       if (argc > 1  &&  (strcmp (argv[1], "-") == 0  || strcmp (argv[1], "--") == 0))
  686.           usage();
  687.   
  688.       narrow2x = 0;
  689.       new_marg = NULL;
  690. !     while ((c = getopt(argc, argv, "124Eexhnwdvzsi:m:b:c:g:H:l:L:M:f:t:P:p:r:R:u:-?")) != -1)
  691.       {    switch (c)
  692.           {
  693.           case '1':
  694.               max_frame = 1;
  695.               break;
  696. --- 576,586 ----
  697.       if (argc > 1  &&  (strcmp (argv[1], "-") == 0  || strcmp (argv[1], "--") == 0))
  698.           usage();
  699.   
  700.       narrow2x = 0;
  701.       new_marg = NULL;
  702. !     while ((c = getopt(argc, argv, "124aEejxhInwDdvzsA:i:m:b:c:g:H:l:L:M:f:t:O:P:p:r:R:u:Y:y:-?")) != -1)
  703.       {    switch (c)
  704.           {
  705.           case '1':
  706.               max_frame = 1;
  707.               break;
  708. ***************
  709. *** 493,518 ****
  710.               break;
  711.           
  712.           case '4':
  713.               max_frame = 4;
  714.               break;
  715.               
  716.           case 'b':
  717.               if ((set_paper_bin = atoi (optarg)) > nslots)
  718.               {    if (nslots == 0)
  719. !                     fprintf (stderr, "%s: no alternate bins permitted\n", nslots);
  720.                   else
  721.                       fprintf (stderr, "%s: paper bin greater than %d\n", pgmname, nslots);
  722. !                 exit (1);
  723.               }
  724.               break;
  725.   
  726.           case 'c':
  727.               chars_on_line = atoi (optarg);
  728.               set_char_count = 1;
  729.               break;
  730.   
  731.           case 'd':
  732.               book = 1;
  733.               break;
  734.                       
  735.           case 'e':
  736. --- 592,633 ----
  737.               break;
  738.           
  739.           case '4':
  740.               max_frame = 4;
  741.               break;
  742. + 
  743. +         case 'a':
  744. +             read_access = 1;
  745. +             break;
  746.               
  747. +         case 'A':
  748. +             account_file_name = optarg;        /*    for lpsched's benifit */
  749. +             break;
  750. + 
  751.           case 'b':
  752.               if ((set_paper_bin = atoi (optarg)) > nslots)
  753.               {    if (nslots == 0)
  754. !                     fprintf (stderr, "%s: no alternate bins permitted\n", pgmname);
  755.                   else
  756.                       fprintf (stderr, "%s: paper bin greater than %d\n", pgmname, nslots);
  757. !                 exit (DISCARD_JOB);
  758.               }
  759.               break;
  760.   
  761.           case 'c':
  762.               chars_on_line = atoi (optarg);
  763.               set_char_count = 1;
  764.               break;
  765.   
  766. +         case 'D':
  767. +             duplex = 1;
  768. +             if (duplex_mode[0] == 0)
  769. +             {    fprintf (stderr, "%s: duplex mode not available\n", pgmname);
  770. +                 exit (DISCARD_JOB);
  771. +             }
  772. +             break;
  773. +     
  774.           case 'd':
  775.               book = 1;
  776.               break;
  777.                       
  778.           case 'e':
  779. ***************
  780. *** 543,561 ****
  781.                       font_number = 0;
  782.               }
  783.               break;
  784.   
  785.           case 'g':
  786. !             p = NULL;
  787. !             for (i = 0;  page_types[i].paper_name[0];  i++)
  788. !             {    if (compare (optarg, page_types[i].paper_name) == 0)
  789. !                 {    p = &page_types[i];
  790. !                     break;
  791. !                 }
  792. !             }
  793.               if (p == NULL)
  794. !                 usage ();
  795.               set_paper_tray = 1;
  796.               break;
  797.   
  798.           case 'h':
  799.               header = 1;
  800. --- 658,670 ----
  801.                       font_number = 0;
  802.               }
  803.               break;
  804.   
  805.           case 'g':
  806. !             p = locate_pagetype (optarg, 1);
  807.               if (p == NULL)
  808. !                 exit (DISCARD_JOB);
  809.               set_paper_tray = 1;
  810.               break;
  811.   
  812.           case 'h':
  813.               header = 1;
  814. ***************
  815. *** 564,589 ****
  816.           case 'H':
  817.               header = 2;
  818.               strcpy (header_text, optarg);
  819.               break;
  820.   
  821.           case 'i':
  822. !             x_user_offset = atoi (optarg) * cvt_unit (optarg) + 0.01;
  823.               break;
  824.   
  825.           case 'l':
  826.               lines_on_page = atoi (optarg);
  827.               set_line_count = 1;
  828.               break;
  829.   
  830.           case 'L':
  831.               lines_total = atoi (optarg);
  832.               set_total_count = 1;
  833.               break;
  834.   
  835.           case 'm':
  836. !             y_user_offset = atoi (optarg) * cvt_unit(optarg) + 0.01;
  837.               break;
  838.           
  839.           case 'M':
  840.               new_marg = optarg;
  841.               break;
  842. --- 673,710 ----
  843.           case 'H':
  844.               header = 2;
  845.               strcpy (header_text, optarg);
  846.               break;
  847.   
  848. +         case 'I':
  849. + #ifdef ISO
  850. +             isolatin = 0;
  851. + #else
  852. +             isolatin = 1;
  853. + #endif
  854. +             break;
  855. +     
  856.           case 'i':
  857. !             x_user_offset = atof (optarg) * cvt_unit (optarg) + 0.01;
  858.               break;
  859.   
  860.           case 'l':
  861.               lines_on_page = atoi (optarg);
  862.               set_line_count = 1;
  863.               break;
  864.   
  865. +         case 'j':
  866. +             gen_eoj = 1;
  867. +             break;
  868. +     
  869.           case 'L':
  870.               lines_total = atoi (optarg);
  871.               set_total_count = 1;
  872.               break;
  873.   
  874.           case 'm':
  875. !             y_user_offset = atof (optarg) * cvt_unit(optarg) + 0.01;
  876.               break;
  877.           
  878.           case 'M':
  879.               new_marg = optarg;
  880.               break;
  881. ***************
  882. *** 591,600 ****
  883. --- 712,725 ----
  884.           case 'n':
  885.               landscape = 0;
  886.               narrow2x = 1;
  887.               break;
  888.   
  889. +         case 'O':
  890. +             pipe_name = optarg;
  891. +             break;
  892. + 
  893.           case 'p':
  894.               point_size = atoi (optarg);
  895.               set_point_size = 1;
  896.               break;
  897.   
  898. ***************
  899. *** 633,650 ****
  900. --- 758,785 ----
  901.               
  902.           case 'x':
  903.               cross = 1;
  904.               break;
  905.   
  906. +         case 'y':
  907. +             user = optarg;
  908. +             break;
  909. +     
  910. +         case 'Y':
  911. +             host = optarg;
  912. +             break;
  913. + 
  914.           case 'z':
  915.               print_postscript = 1;
  916.               break;
  917.   
  918.           default:    usage ();
  919.               break;
  920.           }
  921.       }
  922. +     if (duplex  ||  pipe_name)        /*    cannot support book mode */
  923. +         book = 0;
  924.   
  925.       if (strncmp (order_default, "Reverse", 7) == 0)        /*    stacking sequence         */
  926.           reverse_order = 1;                                /*    "Reverse"                */
  927.       else
  928.           reverse_order = 0;                                /*    "Normal"                */
  929. ***************
  930. *** 662,680 ****
  931.       nominal_high = p->uy - p->ly + 1;                    /* for default row/col scaling */
  932.       nominal_wide = p->ux - p->lx + 1;        
  933.   
  934.       if (reverse_requested && book)
  935.       {    fprintf (stderr, "Double sided or book in reverse ordered not supported\n");
  936. !         exit (1);
  937.       }
  938.       /*    if -M specified, set the imageable area coordinates to reflect
  939.           the deisred margin size.
  940.       */
  941.       if (new_marg)
  942.       {    char *mc, *v[6];
  943.           int    iv;
  944. !         double    fact, atof();
  945.   
  946.           mc = new_marg;
  947.           iv = 1;
  948.           v[0] = mc;
  949.           while (*mc  &&  iv < 6)
  950. --- 797,815 ----
  951.       nominal_high = p->uy - p->ly + 1;                    /* for default row/col scaling */
  952.       nominal_wide = p->ux - p->lx + 1;        
  953.   
  954.       if (reverse_requested && book)
  955.       {    fprintf (stderr, "Double sided or book in reverse ordered not supported\n");
  956. !         exit (DISCARD_JOB);
  957.       }
  958.       /*    if -M specified, set the imageable area coordinates to reflect
  959.           the deisred margin size.
  960.       */
  961.       if (new_marg)
  962.       {    char *mc, *v[6];
  963.           int    iv;
  964. !         double    fact;
  965.   
  966.           mc = new_marg;
  967.           iv = 1;
  968.           v[0] = mc;
  969.           while (*mc  &&  iv < 6)
  970. ***************
  971. *** 684,694 ****
  972.               }
  973.               mc++;
  974.           }
  975.           if (iv < 4)
  976.           {    fprintf (stderr, "Must have 4 margin sizes specified\n");
  977. !             exit (1);
  978.           }
  979.           if (iv > 4)
  980.               fact = cvt_unit (v[4]);
  981.           else
  982.               fact = cvt_unit (v[3]);
  983. --- 819,829 ----
  984.               }
  985.               mc++;
  986.           }
  987.           if (iv < 4)
  988.           {    fprintf (stderr, "Must have 4 margin sizes specified\n");
  989. !             exit (DISCARD_JOB);
  990.           }
  991.           if (iv > 4)
  992.               fact = cvt_unit (v[4]);
  993.           else
  994.               fact = cvt_unit (v[3]);
  995. ***************
  996. *** 713,723 ****
  997.               if ((iv = atof (v[3]) * fact) > 0)
  998.                   p->ly = max (p->ly, (iv + 1));
  999.           }
  1000.           if (p->ux - p->lx < 200  ||  p->uy - p->ly < 200)
  1001.           {    fprintf (stderr, "Margin size is inappropriate\n");
  1002. !                 exit (1);
  1003.           }
  1004.       }
  1005.       for (i = 0;  page_types[i].paper_name[0];  i++)
  1006.       {    page_types[i].left_marg  = page_types[i].lx;
  1007.           page_types[i].bot_marg   = page_types[i].ly;
  1008. --- 848,858 ----
  1009.               if ((iv = atof (v[3]) * fact) > 0)
  1010.                   p->ly = max (p->ly, (iv + 1));
  1011.           }
  1012.           if (p->ux - p->lx < 200  ||  p->uy - p->ly < 200)
  1013.           {    fprintf (stderr, "Margin size is inappropriate\n");
  1014. !                 exit (DISCARD_JOB);
  1015.           }
  1016.       }
  1017.       for (i = 0;  page_types[i].paper_name[0];  i++)
  1018.       {    page_types[i].left_marg  = page_types[i].lx;
  1019.           page_types[i].bot_marg   = page_types[i].ly;
  1020. ***************
  1021. *** 727,737 ****
  1022.           page_types[i].x_size = page_types[i].ux - page_types[i].lx + 1;
  1023.           page_types[i].y_size = page_types[i].uy - page_types[i].ly + 1;
  1024.       }
  1025.       if (want_stats)
  1026.       {    size_display();
  1027. !         exit (1);
  1028.       }
  1029.       if (nslots <= 1)
  1030.           hopper_available = 0;
  1031.       if (reverse_order  ||  (book  &&  hopper_available))
  1032.           sprintf (bookfile, "%s%d.bok", TEMPFILE, getpid());
  1033. --- 862,872 ----
  1034.           page_types[i].x_size = page_types[i].ux - page_types[i].lx + 1;
  1035.           page_types[i].y_size = page_types[i].uy - page_types[i].ly + 1;
  1036.       }
  1037.       if (want_stats)
  1038.       {    size_display();
  1039. !         exit (DISCARD_JOB);
  1040.       }
  1041.       if (nslots <= 1)
  1042.           hopper_available = 0;
  1043.       if (reverse_order  ||  (book  &&  hopper_available))
  1044.           sprintf (bookfile, "%s%d.bok", TEMPFILE, getpid());
  1045. ***************
  1046. *** 740,787 ****
  1047.   
  1048.       if (optind >=  argc  &&  header == 1)    /* no file name header on stdin */
  1049.           header = 0;
  1050.       save_point_size = point_size;
  1051.       
  1052. !     (void)    signal (SIGINT, catch);        /*    for lpd quit */
  1053.   
  1054.   #ifdef PSFFILTER
  1055.   
  1056. !     output_fp = stdout;
  1057.       input_fp  = stdin;
  1058.       if (header == 1)
  1059.           strcpy (fname, argv[optind]);
  1060.       else
  1061.           *fname = 0;    
  1062.   
  1063.       if (fgets (line, LONG_STR, input_fp) == NULL)
  1064. !         exit (0);
  1065. !     if (tscan (line, "%!") >= 0  &&  print_postscript == 0)
  1066.       {    /*    already postscript  copy to output */
  1067.           if (fputs (line, output_fp) == EOF)
  1068. !             output_trouble (2);
  1069.           while ((i = fgetc (input_fp)) != EOF)
  1070.           {    if (fputc (i, output_fp) == EOF)
  1071. !                 output_trouble (2);
  1072.           }
  1073.       }
  1074.       else
  1075.       {    /*    standard postscript conversion for file on stdin */
  1076. ! bannerdone:
  1077.           if (font_number * 4 > font_count)
  1078.           {    fprintf (stderr,"Font number invalid....\n");
  1079.               usage ();
  1080.           }
  1081.   
  1082.           if (book  ||  reverse_order)
  1083.           {    if ((output_fp = fopen (bookfile, "w")) == NULL)
  1084.               {    fprintf (stderr, "%s: cannot create work file\n", pgmname);
  1085. !                 exit (1);
  1086.               }
  1087.               if ((pg_loc = (long *) malloc (sizeof (long) * MAX_PAGES)) == NULL)
  1088.               {    fprintf (stderr, "%s: cannot allocate enough memory\n", pgmname);
  1089. !                 exit (1);
  1090.               }
  1091.               npg_loc = 0;
  1092.           }
  1093.   
  1094.           for (i = 0;  i < NFONTS;  i++)
  1095. --- 875,948 ----
  1096.   
  1097.       if (optind >=  argc  &&  header == 1)    /* no file name header on stdin */
  1098.           header = 0;
  1099.       save_point_size = point_size;
  1100.       
  1101. !     (void)    signal (SIGINT, catch);            /*    for lpd quit */
  1102.   
  1103.   #ifdef PSFFILTER
  1104.   
  1105. !     if (pipe_name)
  1106. !     {    if ((output_fp = popen (pipe_name, "w")) == NULL)
  1107. !         {    fprintf (stderr, "%s: cannot open pipe to %s\n", pgmname, pipe_name);
  1108. !             exit (DISCARD_JOB);
  1109. !         }
  1110. !         read_access = 0;                    /*    can't read from pipe */
  1111. !     }
  1112. !     else
  1113. !         output_fp = stdout;
  1114.       input_fp  = stdin;
  1115.       if (header == 1)
  1116.           strcpy (fname, argv[optind]);
  1117.       else
  1118.           *fname = 0;    
  1119.   
  1120.       if (fgets (line, LONG_STR, input_fp) == NULL)
  1121. !         exit (JOB_IS_DONE);
  1122. !     if ((strncmp (line, "%!", 2) == 0  ||  strncmp (line, "%%!", 3) == 0)
  1123. !             &&  print_postscript == 0)
  1124.       {    /*    already postscript  copy to output */
  1125. +         char    last_char;
  1126. + 
  1127. +         if (read_access)
  1128. +             create_fork ();
  1129. + 
  1130. +         /*    attempt to force tray and bin selection */
  1131. + 
  1132. +         set_bin (set_paper_bin);
  1133. +         set_tray (set_paper_tray);
  1134. +         
  1135.           if (fputs (line, output_fp) == EOF)
  1136. !             output_trouble (DISCARD_JOB);
  1137.           while ((i = fgetc (input_fp)) != EOF)
  1138.           {    if (fputc (i, output_fp) == EOF)
  1139. !                 output_trouble (DISCARD_JOB);
  1140. !             last_char = i;
  1141.           }
  1142. +         if (last_char != CTLD_EOJ)
  1143. +             fputc (CTLD_EOJ, output_fp);
  1144. +         pages_written = -1; /* i.e. we don't know */
  1145.       }
  1146.       else
  1147.       {    /*    standard postscript conversion for file on stdin */
  1148. ! 
  1149.           if (font_number * 4 > font_count)
  1150.           {    fprintf (stderr,"Font number invalid....\n");
  1151.               usage ();
  1152.           }
  1153.   
  1154. +         if (read_access)
  1155. +             create_fork ();
  1156. + 
  1157.           if (book  ||  reverse_order)
  1158.           {    if ((output_fp = fopen (bookfile, "w")) == NULL)
  1159.               {    fprintf (stderr, "%s: cannot create work file\n", pgmname);
  1160. !                 exit (DISCARD_JOB);
  1161.               }
  1162.               if ((pg_loc = (long *) malloc (sizeof (long) * MAX_PAGES)) == NULL)
  1163.               {    fprintf (stderr, "%s: cannot allocate enough memory\n", pgmname);
  1164. !                 exit (DISCARD_JOB);
  1165.               }
  1166.               npg_loc = 0;
  1167.           }
  1168.   
  1169.           for (i = 0;  i < NFONTS;  i++)
  1170. ***************
  1171. *** 799,808 ****
  1172. --- 960,971 ----
  1173.           start_file ();
  1174.           process_file ();
  1175.           terminate_printer ();
  1176.           output_book (bookfile);
  1177.       }
  1178. +     if (read_access == 0)
  1179. +         write_accounting (pages_written, 0);
  1180.   
  1181.   #else    /* not PSFFILTER */
  1182.   
  1183.       /*    begin normal "psf" code */
  1184.   
  1185. ***************
  1186. *** 812,838 ****
  1187.       }
  1188.   
  1189.       if (book  ||  reverse_order)
  1190.       {    if ((output_fp = fopen (bookfile, "w")) == NULL)
  1191.           {    fprintf (stderr, "%s: cannot create work file\n", pgmname);
  1192. !             exit (1);
  1193.           }
  1194.           if ((pg_loc = (long *) malloc (sizeof (long) * MAX_PAGES)) == NULL)
  1195.           {    fprintf (stderr, "%s: cannot allocate enough memory\n", pgmname);
  1196. !             exit (1);
  1197.           }
  1198.           npg_loc = 0;
  1199.       }
  1200.       else    
  1201. !     {    if (env_fname = getenv ("PSFLP"))
  1202.   #if defined(MSDOS)  ||  defined (__MSDOS__)
  1203.           {    if ((output_fp = fopen (env_fname, "wt")) == NULL)
  1204.   #else
  1205.           {    if ((output_fp = fopen (env_fname, "w")) == NULL)
  1206.   #endif
  1207.               {    fprintf (stderr, "Cannot open output file %s\n", env_fname);
  1208. !                 exit (1);
  1209.               }
  1210.           }
  1211.           else
  1212.           {    output_fp = stdout;
  1213.           }
  1214. --- 975,1002 ----
  1215.       }
  1216.   
  1217.       if (book  ||  reverse_order)
  1218.       {    if ((output_fp = fopen (bookfile, "w")) == NULL)
  1219.           {    fprintf (stderr, "%s: cannot create work file\n", pgmname);
  1220. !             exit (DISCARD_JOB);
  1221.           }
  1222.           if ((pg_loc = (long *) malloc (sizeof (long) * MAX_PAGES)) == NULL)
  1223.           {    fprintf (stderr, "%s: cannot allocate enough memory\n", pgmname);
  1224. !             exit (DISCARD_JOB);
  1225.           }
  1226.           npg_loc = 0;
  1227.       }
  1228.       else    
  1229. !     {    char    *env_fname;            /*    environment specified output file */
  1230. !         if (env_fname = getenv ("PSFLP"))
  1231.   #if defined(MSDOS)  ||  defined (__MSDOS__)
  1232.           {    if ((output_fp = fopen (env_fname, "wt")) == NULL)
  1233.   #else
  1234.           {    if ((output_fp = fopen (env_fname, "w")) == NULL)
  1235.   #endif
  1236.               {    fprintf (stderr, "Cannot open output file %s\n", env_fname);
  1237. !                 exit (DISCARD_JOB);
  1238.               }
  1239.           }
  1240.           else
  1241.           {    output_fp = stdout;
  1242.           }
  1243. ***************
  1244. *** 874,886 ****
  1245.       output_book (bookfile);
  1246.       /*    end normal psf code */
  1247.   
  1248.   #endif    /* PSFFILTER */
  1249.   
  1250. !     exit (0);
  1251.   }
  1252.   
  1253.   
  1254.   /****************************************************************************
  1255.   *    cvt_unit ()                                                                *
  1256.   *    Determine the margin offset conversion factor to points.                *
  1257.   ****************************************************************************/
  1258. --- 1038,1327 ----
  1259.       output_book (bookfile);
  1260.       /*    end normal psf code */
  1261.   
  1262.   #endif    /* PSFFILTER */
  1263.   
  1264. !     exit (JOB_IS_DONE);
  1265. ! }
  1266. ! 
  1267. ! #ifdef PSFFILTER
  1268. ! 
  1269. ! /****************************************************************************
  1270. ! *    create_fork ()                                                            *
  1271. ! *    fork a child to send to printer.  parent reads from printer                *
  1272. ! ****************************************************************************/
  1273. ! 
  1274. ! void create_fork ()
  1275. ! {    int     parent;
  1276. !     long    pages_printed;
  1277. !     long    start_count;
  1278. !     int     status;
  1279. !     int        log_exit;
  1280. !     
  1281. !     request_pagecount (1);
  1282. !     if ((parent = fork ()) < 0)
  1283. !         expire ("fork");
  1284. !     if (parent)
  1285. !     {    /*    parent: read from printer port until child finishes print */
  1286. !         start_count = get_page_count ();
  1287. !         while (wait (&status) == -1)
  1288. !             if (errno != EINTR)
  1289. !                 expire ("fork wait");
  1290. !         request_pagecount (0);
  1291. !         pages_printed = get_page_count () - start_count;
  1292. !         log_exit = WIFEXITED (status) ? WEXITSTATUS (status) : DISCARD_JOB;
  1293. !         write_accounting (pages_printed, log_exit);
  1294. !         fflush (stdout);
  1295. !         fflush (stderr);
  1296. !         exit (log_exit);
  1297. !     }
  1298. !     /*    child: continue to print the job */
  1299. !     return;
  1300. ! }
  1301. ! 
  1302. ! /****************************************************************************
  1303. ! *    write_accounting ()                                                        *
  1304. ! *    send number of printed pages to accounting file. record non-zero exit    *
  1305. ! ****************************************************************************/
  1306. ! 
  1307. ! void write_accounting (pages_printed, log_exit)
  1308. ! long    pages_printed;
  1309. ! int        log_exit;
  1310. ! {    FILE    *accounting;
  1311. ! 
  1312. !     if (account_file_name == NULL)
  1313. !         return;
  1314. ! 
  1315. !     if ((accounting = fopen (account_file_name, "a")) != NULL)
  1316. !     {    if (log_exit)
  1317. !             (void) fprintf(accounting, "%ld\t%s:%s\ttermination:%d\n", pages_printed, host, user, log_exit);
  1318. !         else
  1319. !             (void) fprintf(accounting, "%ld\t%s:%s\n", pages_printed, host, user);
  1320. !         fclose (accounting);
  1321. !     }
  1322. !     else 
  1323. !     {    time_stamp();
  1324. !         perror(account_file_name);
  1325. !     }
  1326. ! }
  1327. ! 
  1328. ! /****************************************************************************
  1329. ! *    time_stamp ()                                                            *
  1330. ! *    record date stamp into error log file                                    *
  1331. ! ****************************************************************************/
  1332. ! 
  1333. ! void time_stamp()
  1334. ! {
  1335. !     int e = errno;
  1336. !     time_t clock = time((time_t *)0);
  1337. !     (void) fprintf (stderr, "%s: %.24s ", pgmname, ctime(&clock));
  1338. !     errno = e;
  1339. ! }
  1340. ! 
  1341. ! /****************************************************************************
  1342. ! *    expire ()                                                                *
  1343. ! *    create date-stamp and error message.                                    *
  1344. ! ****************************************************************************/
  1345. ! 
  1346. ! void expire(s)
  1347. ! char *s;
  1348. ! {
  1349. !     time_stamp ();
  1350. !     perror (s);
  1351. !     exit (DISCARD_JOB);
  1352. ! }
  1353. ! 
  1354. ! /****************************************************************************
  1355. ! *    getc_from_printer ()                                                    *
  1356. ! *    read a character from the printer,  return char or ERROR.                *
  1357. ! ****************************************************************************/
  1358. ! 
  1359. ! int getc_from_printer ()
  1360. ! {
  1361. !     char c;
  1362. !     int r;
  1363. !     
  1364. !     r = read (printfd, &c, 1);
  1365. !     if (r == 0)
  1366. !         return (EOF);
  1367. !     if (r == 1)
  1368. !         return (c);
  1369. !     return (READ_ERROR);        /* error during read */
  1370. ! }
  1371. ! 
  1372. ! /****************************************************************************
  1373. ! *    abort_job ()                                                            *
  1374. ! *    Abort the current printer job; don't wait for reply.                    *
  1375. ! ****************************************************************************/
  1376. ! 
  1377. ! void abort_job() 
  1378. ! {
  1379. !     (void) fwrite (c_CTLC_CANCEL, 1, sizeof(c_CTLC_CANCEL), output_fp); 
  1380. !     fflush (output_fp);
  1381. ! }
  1382. ! 
  1383. ! /****************************************************************************
  1384. ! *    abort_exit ()                                                            *
  1385. ! *    Abort the current printer job and exit.                                 *
  1386. ! ****************************************************************************/
  1387. ! 
  1388. ! void abort_exit() 
  1389. ! {    abort_job (); 
  1390. !     exit (DISCARD_JOB);
  1391. !     _exit (DISCARD_JOB);
  1392. ! }
  1393. ! 
  1394. ! /****************************************************************************
  1395. ! *    request_pagecount ()                                                    *
  1396. ! *    request page count from printer as a small postscript job.                *
  1397. ! ****************************************************************************/
  1398. ! 
  1399. ! void request_pagecount (cancel)
  1400. ! int cancel;
  1401. ! {    register int c;
  1402. !     char    pline[400];
  1403. ! 
  1404. !     if (cancel) {
  1405. !         /* Cancel any incomplete job and discard its output.  */
  1406. !         abort_job();
  1407. !         while ((c = getc_from_printer ()) != CTLD_EOJ)
  1408. !             if (c < 0)
  1409. !                 expire ("pagecount cancel");
  1410. !     }
  1411. ! 
  1412. !     sprintf (pline, "([%d] )print\n%s%s%s%s%s%s%s%s%s%c",
  1413. !                 pid,
  1414. !                 "/GetPageCount {\n",
  1415. !                 "    /str 64 string def\n",
  1416. !                 "    statusdict begin\n",
  1417. !                 "        currentdict/pagecount known {\n",
  1418. !                 "            pagecount str cvs print\n",
  1419. !                 "        } if \n",
  1420. !                 "     end %statusdict\n",
  1421. !                 "} def\n",
  1422. !                 "GetPageCount\n",
  1423. !                 CTLD_EOJ
  1424. !             );
  1425. ! 
  1426. !     c = strlen (pline);
  1427. !     if (fwrite (pline, 1, c, output_fp)  !=  c)
  1428. !         expire ("write pagecount");
  1429.   }
  1430.   
  1431. + /****************************************************************************
  1432. + *    get_page_count ()                                                        *
  1433. + *    get page count from printer.                                            *
  1434. + *    any other messages from printer are logged to the log file.                *
  1435. + ****************************************************************************/
  1436. + 
  1437. + long get_page_count ()
  1438. + {    long    pc;
  1439. +     int        c, line_start = 1;
  1440. +     char    pline[100], *p;
  1441. + 
  1442. +     (void) sprintf (pline, "[%d].", pid);
  1443. +     p = pline;
  1444. +     c = getc_from_printer ();
  1445. +     do
  1446. +     {    /* Print any false match from the last time through the loop.  */
  1447. +         fprintf (stderr, "%.*s", (int)(p - pline), pline);
  1448. + 
  1449. +         /*    sync on [ */
  1450. +         for (;  c != '[';  c = getc_from_printer ())
  1451. +         {    if (c == EOF  ||  c == READ_ERROR)
  1452. +                 expire ("read page count (1)");
  1453. +             if (c != CTLD_EOJ)
  1454. +             {    if (line_start)
  1455. +                     {    time_stamp ();
  1456. +                         line_start = 0;
  1457. +                     }
  1458. +                 fputc (c, stderr);
  1459. +                 if (c == '\n')
  1460. +                     line_start = 1;
  1461. +             }
  1462. +         }
  1463. +         
  1464. +         p = pline + 1;
  1465. +         while (1)
  1466. +         {    c = getc_from_printer();
  1467. +             if (c == READ_ERROR  ||  c == EOF)
  1468. +                 expire ("read page count error (2)");
  1469. +             if (*p == c)
  1470. +                 p++;
  1471. +             else
  1472. +                 break;
  1473. +         }
  1474. +     
  1475. +     } while (*p != '.'  ||  c != ' ');
  1476. + 
  1477. +     if (!line_start)
  1478. +         fputc ('\n', stderr);
  1479. + 
  1480. +     /*    at page count number.  get value into pc */
  1481. + 
  1482. +     pc = 0;
  1483. +     for (;;)
  1484. +     {    c = getc_from_printer ();
  1485. +         if (isdigit (c))
  1486. +             pc = pc * 10 + (c - '0');
  1487. +         else if (c == ' ')
  1488. +             continue;
  1489. +         else break;
  1490. +     }
  1491. + 
  1492. +     wait_for_eoj (c);
  1493. +     return (pc);
  1494. + }
  1495. + 
  1496. + /****************************************************************************
  1497. + *    wait_for_eoj ())                                                        *
  1498. + *    wait for the expected ctl/d eoj echo from the printer.                    *
  1499. + ****************************************************************************/
  1500. + 
  1501. + void wait_for_eoj (c)
  1502. + int        c;
  1503. + {
  1504. +     for (;  c != CTLD_EOJ;  c = getc_from_printer())
  1505. +     {    if (c == EOF || c == READ_ERROR)
  1506. +             expire ("eof not eoj");
  1507. +         if (isascii (c) == 0)
  1508. +         {    fprintf (stderr, "non-ascii char = %02x\n", c);
  1509. +             expire("pagecount cancel");
  1510. +         }
  1511. +     }
  1512. + }
  1513. + 
  1514. + #endif /* PSFFILTER */
  1515. + 
  1516. + /****************************************************************************
  1517. + *    locate_pagetype ()                                                        *
  1518. + *    look for paper type in table of available types.                        *
  1519. + ****************************************************************************/
  1520. + 
  1521. + measure    *locate_pagetype (desired, printerr)
  1522. + char    *desired;
  1523. + int        printerr;
  1524. + {    int        i;
  1525. +     measure    *p;
  1526. + 
  1527. +     p = NULL;
  1528. +     for (i = 0;  page_types[i].paper_name[0];  i++)
  1529. +     {    if (compare (page_types[i].paper_name, desired) == 0)
  1530. +         {    p = &page_types[i];
  1531. +             break;
  1532. +         }
  1533. +     }
  1534. +     if (!p)
  1535. +     {    if (printerr)
  1536. +         {    fprintf (stderr, "Unknown page type %s.  Choose from: ", desired);
  1537. +             for (i = 0;  page_types[i].paper_name[0];  i++)
  1538. +                 fprintf (stderr, " %s", page_types[i].paper_name);
  1539. +             fprintf (stderr, "\n");
  1540. +         }
  1541. +     }
  1542. +     return (p);
  1543. + }
  1544.   
  1545.   /****************************************************************************
  1546.   *    cvt_unit ()                                                                *
  1547.   *    Determine the margin offset conversion factor to points.                *
  1548.   ****************************************************************************/
  1549. ***************
  1550. *** 890,900 ****
  1551.   {    double    fact;
  1552.   
  1553.       fact = 1.0;
  1554.       while (*which)
  1555.       {
  1556. !         if (isdigit (*which))
  1557.           {    which++;
  1558.               continue;
  1559.           }
  1560.           switch (toupper (*which))
  1561.           {
  1562. --- 1331,1341 ----
  1563.   {    double    fact;
  1564.   
  1565.       fact = 1.0;
  1566.       while (*which)
  1567.       {
  1568. !         if (*which == '.'  ||  isdigit (*which))
  1569.           {    which++;
  1570.               continue;
  1571.           }
  1572.           switch (toupper (*which))
  1573.           {
  1574. ***************
  1575. *** 901,911 ****
  1576.           case 'I':    fact = 72.0;        break;        /* inches     */
  1577.           case 'C':    fact = 72.0 / 2.54;    break;        /* cm          */
  1578.           case 'P':    fact = 1.0;            break;        /* points    */
  1579.           case ',':    break;
  1580.           default :    fprintf (stderr, "invalid margin unit '%c'\n", *which);
  1581. !                     exit (1);
  1582.           }
  1583.           if (*which++ != ',')
  1584.               break;
  1585.       }
  1586.       return (fact);
  1587. --- 1342,1352 ----
  1588.           case 'I':    fact = 72.0;        break;        /* inches     */
  1589.           case 'C':    fact = 72.0 / 2.54;    break;        /* cm          */
  1590.           case 'P':    fact = 1.0;            break;        /* points    */
  1591.           case ',':    break;
  1592.           default :    fprintf (stderr, "invalid margin unit '%c'\n", *which);
  1593. !                     exit (DISCARD_JOB);
  1594.           }
  1595.           if (*which++ != ',')
  1596.               break;
  1597.       }
  1598.       return (fact);
  1599. ***************
  1600. *** 924,934 ****
  1601.   void scale_factors ()
  1602.   {    int    wide;                /*    width needed for char count            */
  1603.       int    high;                /*    points needed for line count        */
  1604.       int    n_lines;            /*    number of lines on a page            */
  1605.       int    i;
  1606. !     double    char_width, scale;
  1607.       double    char_sf, line_sf;
  1608.       
  1609.       real_width = p->width;        /* for initial axis translate only    */
  1610.   
  1611.       if (landscape)
  1612. --- 1365,1375 ----
  1613.   void scale_factors ()
  1614.   {    int    wide;                /*    width needed for char count            */
  1615.       int    high;                /*    points needed for line count        */
  1616.       int    n_lines;            /*    number of lines on a page            */
  1617.       int    i;
  1618. !     double    char_width;
  1619.       double    char_sf, line_sf;
  1620.       
  1621.       real_width = p->width;        /* for initial axis translate only    */
  1622.   
  1623.       if (landscape)
  1624. ***************
  1625. *** 1154,1175 ****
  1626.               "    grestore\n",
  1627.               "    show\n",
  1628.               "} def\n",
  1629.               "/mv {moveto} def\n");
  1630.   
  1631.       /*    add additional startup prologue code from psfprint.def
  1632.           probably for non-English language support.
  1633.       */
  1634.       if (pdef)
  1635.       {
  1636. ! #ifdef PSFILTER
  1637.            char    line[LONG_STR + 1];        /* line already has text stream           */
  1638.                                           /* Jan Fernquist (fer@gorbie.n.tvt.se) */
  1639.   #endif
  1640.           while (fgets (line, LONG_STR, pdef))
  1641.           {    if (fputs (line, output_fp) == EOF)
  1642. !                 output_trouble (2);
  1643.           }
  1644.           fclose (pdef);
  1645.           pdef = NULL;
  1646.       }
  1647.       
  1648. --- 1595,1643 ----
  1649.               "    grestore\n",
  1650.               "    show\n",
  1651.               "} def\n",
  1652.               "/mv {moveto} def\n");
  1653.   
  1654. +     /* iso font encoding
  1655. +         % Header to convert StandardEncoded fonts to ISOLatin1Encoded fonts.
  1656. +         % Written by Magnus Hammerin 920226.
  1657. +         % Copyright (c) 1992 Magnus Hammerin.
  1658. +         % You may distribute this code freely as long as this note remains intact.
  1659. + 
  1660. +         % Modification and adaption for usage with psf by Leif H (leif@ifm.liu.se)
  1661. +         %
  1662. +         % Test to see if the printer supports ISOLatin1Encoding.
  1663. + 
  1664. +         /ReEncodeISO { % <newfontname> <oldfontname> ReEncodeISO
  1665. +     */
  1666. +     if (isolatin)
  1667. +         fprintf (output_fp, "%s%s%s%s%s%s%s%s%s%s%s%s",
  1668. +             "/ReEncodeISO {\n",
  1669. +             "  /ISOLatin1Encoding where {\n",
  1670. +             "    pop\n",
  1671. +             "    findfont\n",
  1672. +             "    dup length dict begin\n",
  1673. +             "      {1 index /FID ne {def} {pop pop} ifelse} forall\n",
  1674. +             "      /Encoding ISOLatin1Encoding def\n",
  1675. +             "      currentdict\n",
  1676. +             "    end\n",
  1677. +             "    definefont pop\n",
  1678. +             "  } { pop pop } ifelse\n",
  1679. +             "} bind def\n");
  1680. + 
  1681.       /*    add additional startup prologue code from psfprint.def
  1682.           probably for non-English language support.
  1683.       */
  1684.       if (pdef)
  1685.       {
  1686. ! #ifdef PSFFILTER
  1687.            char    line[LONG_STR + 1];        /* line already has text stream           */
  1688.                                           /* Jan Fernquist (fer@gorbie.n.tvt.se) */
  1689.   #endif
  1690.           while (fgets (line, LONG_STR, pdef))
  1691.           {    if (fputs (line, output_fp) == EOF)
  1692. !                 output_trouble (DISCARD_JOB);
  1693.           }
  1694.           fclose (pdef);
  1695.           pdef = NULL;
  1696.       }
  1697.       
  1698. ***************
  1699. *** 1180,1203 ****
  1700.           {    while (1)
  1701.               {    c = fgetc (fp);
  1702.                   if (feof (fp)  ||  ferror (fp))
  1703.                       break;
  1704.                   if (fputc (c, fp) == EOF)
  1705. !                     output_trouble (2);
  1706.               }
  1707.               fclose (fp);
  1708.           }
  1709.       }
  1710.           
  1711.       fprintf (output_fp, "%%%%EndProlog\n");
  1712.   
  1713. !     if (set_paper_tray)
  1714. !         fprintf (output_fp, "%s\n", p->paper_tray);
  1715.   
  1716.       if (order_command)
  1717.           fprintf (output_fp, "%s\n", order_command);
  1718.       else if (set_paper_bin)
  1719.           fprintf (output_fp, "%s\n", slots[set_paper_bin - 1]);
  1720.   }
  1721.   
  1722.   /****************************************************************************
  1723.   *    showpage ()                                                                *
  1724. --- 1648,1694 ----
  1725.           {    while (1)
  1726.               {    c = fgetc (fp);
  1727.                   if (feof (fp)  ||  ferror (fp))
  1728.                       break;
  1729.                   if (fputc (c, fp) == EOF)
  1730. !                     output_trouble (DISCARD_JOB);
  1731.               }
  1732.               fclose (fp);
  1733.           }
  1734.       }
  1735.           
  1736.       fprintf (output_fp, "%%%%EndProlog\n");
  1737.   
  1738. !     set_tray (set_paper_tray);
  1739. !     if (duplex)
  1740. !         fprintf (output_fp, "%s\n", duplex_mode);
  1741.   
  1742.       if (order_command)
  1743.           fprintf (output_fp, "%s\n", order_command);
  1744.       else if (set_paper_bin)
  1745. +         set_bin (set_paper_bin);
  1746. + }
  1747. + 
  1748. + /****************************************************************************
  1749. + *    set_tray ()                                                                *
  1750. + ****************************************************************************/
  1751. + 
  1752. + void set_tray (set_paper_tray)
  1753. + int        set_paper_tray;
  1754. + {
  1755. +     if (set_paper_tray)
  1756. +         fprintf (output_fp, "%s\n", p->paper_tray);
  1757. + }
  1758. + 
  1759. + /****************************************************************************
  1760. + *    set_bin ()                                                                *
  1761. + ****************************************************************************/
  1762. + 
  1763. + void set_bin (set_paper_bin)
  1764. + int        set_paper_bin;
  1765. + {
  1766. +     if (set_paper_bin)
  1767.           fprintf (output_fp, "%s\n", slots[set_paper_bin - 1]);
  1768.   }
  1769.   
  1770.   /****************************************************************************
  1771.   *    showpage ()                                                                *
  1772. ***************
  1773. *** 1224,1241 ****
  1774. --- 1715,1734 ----
  1775.               ;
  1776.           if (skipping >= 0)
  1777.           {    end_of_file = 1;
  1778.               if (bookwork == 0)                /* psfdoub will re-insert this */
  1779.                   fprintf (output_fp, "showpage pg restore\n");
  1780. +             pages_written++;
  1781.               frame = 0;
  1782.               longjmp (eof_env, 1);
  1783.           }
  1784.       }
  1785.   
  1786.       if (++frame >= max_frame  ||  end_of_file)
  1787.       {    if (bookwork == 0)                    /* psfdoub will re-insert this */
  1788.               fprintf (output_fp, "showpage pg restore\n");
  1789. +         pages_written++;
  1790.           frame = 0;
  1791.       }
  1792.       if (!end_of_file)
  1793.           set_frame ();
  1794.       
  1795. ***************
  1796. *** 1353,1371 ****
  1797.       /*    psffilter already has a first line,  psf does not */
  1798.       do
  1799.   #else
  1800.       while (line_is_wrapped  ||  fgets (line, LONG_STR, input_fp) != NULL)
  1801.   #endif
  1802. !     {
  1803. !         if (*line == CTLD_EOJ)        /* printing postscript code: ^D at end    */
  1804. !             break;                    /* assume it is end of file also        */
  1805. ! 
  1806. !         if (lcount++ == 0)
  1807.           {    if ((i = tscan (line, "ta=")) >= 0)
  1808.               {    tab_size = atoi (line + i + 3);
  1809.               }
  1810.           }
  1811.   
  1812.           if (need_xlate)                /*    translate character set? */
  1813.           {    xln = (unsigned char *) line;
  1814.               while (*xln)
  1815.               {    i = *xln;
  1816. --- 1846,1872 ----
  1817.       /*    psffilter already has a first line,  psf does not */
  1818.       do
  1819.   #else
  1820.       while (line_is_wrapped  ||  fgets (line, LONG_STR, input_fp) != NULL)
  1821.   #endif
  1822. !     {    if (lcount++ == 0)
  1823.           {    if ((i = tscan (line, "ta=")) >= 0)
  1824.               {    tab_size = atoi (line + i + 3);
  1825.               }
  1826. +             if (*line == CTLD_EOJ)
  1827. +             {    /* postscript code may have leading ctl/d.  remove them */
  1828. +                 lc = line;
  1829. +                 while (*lc  && *lc == CTLD_EOJ)
  1830. +                     lc++;
  1831. +                 i = 0;
  1832. +                 do
  1833. +                 {    line[i++] = *lc;
  1834. +                 } while (*lc++);
  1835. +             }
  1836.           }
  1837. +         else if (*line == CTLD_EOJ)    /* printing postscript code: ^D at end    */
  1838. +             break;                    /* assume it is end of file also        */
  1839.   
  1840.           if (need_xlate)                /*    translate character set? */
  1841.           {    xln = (unsigned char *) line;
  1842.               while (*xln)
  1843.               {    i = *xln;
  1844. ***************
  1845. *** 1440,1450 ****
  1846.               moveto (x_coord, y_coord, 1);        /*    do gen moveto        */
  1847.   
  1848.           while (*c  && *c != '\n')
  1849.           {    if (char_type == 0)
  1850.               {    if (fputc ('(', output_fp) == EOF)
  1851. !                     output_trouble (2);
  1852.               }
  1853.               switch ((int) *c)
  1854.               {
  1855.               case ESCAPE:
  1856.                   previous_attribute = print_attribute;
  1857. --- 1941,1951 ----
  1858.               moveto (x_coord, y_coord, 1);        /*    do gen moveto        */
  1859.   
  1860.           while (*c  && *c != '\n')
  1861.           {    if (char_type == 0)
  1862.               {    if (fputc ('(', output_fp) == EOF)
  1863. !                     output_trouble (DISCARD_JOB);
  1864.               }
  1865.               switch ((int) *c)
  1866.               {
  1867.               case ESCAPE:
  1868.                   previous_attribute = print_attribute;
  1869. ***************
  1870. *** 1459,1469 ****
  1871.                       default:
  1872.                           if (char_type  &&  (previous_attribute & UNDERLINE))
  1873.                               SHOWU (output_fp, point_size);
  1874.                           else
  1875.                           {    if (fputs (")show\n", output_fp) == EOF)
  1876. !                                 output_trouble (2);
  1877.                           }
  1878.                           if (esc_type == '+'  ||  esc_type == '-')
  1879.                           {    /*    check for +/- 1/2 line feed        */
  1880.                               if (esc_type == '+')
  1881.                                   y_coord -= ((point_size + extra_space) / 2);
  1882. --- 1960,1970 ----
  1883.                       default:
  1884.                           if (char_type  &&  (previous_attribute & UNDERLINE))
  1885.                               SHOWU (output_fp, point_size);
  1886.                           else
  1887.                           {    if (fputs (")show\n", output_fp) == EOF)
  1888. !                                 output_trouble (DISCARD_JOB);
  1889.                           }
  1890.                           if (esc_type == '+'  ||  esc_type == '-')
  1891.                           {    /*    check for +/- 1/2 line feed        */
  1892.                               if (esc_type == '+')
  1893.                                   y_coord -= ((point_size + extra_space) / 2);
  1894. ***************
  1895. *** 1472,1482 ****
  1896.                               moveto (x_coord, y_coord, 1);
  1897.                               char_type = -1;
  1898.                               c++;
  1899.                               if (*c != '\n')
  1900.                               {    if (fputc ('(', output_fp) == EOF)
  1901. !                                     output_trouble (2);
  1902.                               }
  1903.                               continue;
  1904.                           }
  1905.                           else
  1906.                               findfont ();
  1907. --- 1973,1983 ----
  1908.                               moveto (x_coord, y_coord, 1);
  1909.                               char_type = -1;
  1910.                               c++;
  1911.                               if (*c != '\n')
  1912.                               {    if (fputc ('(', output_fp) == EOF)
  1913. !                                     output_trouble (DISCARD_JOB);
  1914.                               }
  1915.                               continue;
  1916.                           }
  1917.                           else
  1918.                               findfont ();
  1919. ***************
  1920. *** 1505,1523 ****
  1921.                   }
  1922.                   if (*c == '\t')
  1923.                   {    fputc (' ', output_fp);
  1924.                       while (++char_count % tab_size)
  1925.                       {    if (fputc (' ', output_fp) == EOF)
  1926. !                             output_trouble (2);
  1927.                       }
  1928.                   }
  1929.                   else
  1930.                   {    if (strchr ("\r\b\\()", *c) != NULL)
  1931.                           if (fputc ('\\', output_fp) == EOF)
  1932. !                             output_trouble (2);
  1933.                       if (fputc (*c, output_fp) == EOF)
  1934. !                         output_trouble (2);
  1935.                       char_count++;
  1936.                   }
  1937.                   break;
  1938.               }
  1939.               c++;
  1940. --- 2006,2024 ----
  1941.                   }
  1942.                   if (*c == '\t')
  1943.                   {    fputc (' ', output_fp);
  1944.                       while (++char_count % tab_size)
  1945.                       {    if (fputc (' ', output_fp) == EOF)
  1946. !                             output_trouble (DISCARD_JOB);
  1947.                       }
  1948.                   }
  1949.                   else
  1950.                   {    if (strchr ("\r\b\\()", *c) != NULL)
  1951.                           if (fputc ('\\', output_fp) == EOF)
  1952. !                             output_trouble (DISCARD_JOB);
  1953.                       if (fputc (*c, output_fp) == EOF)
  1954. !                         output_trouble (DISCARD_JOB);
  1955.                       char_count++;
  1956.                   }
  1957.                   break;
  1958.               }
  1959.               c++;
  1960. ***************
  1961. *** 1527,1537 ****
  1962.           if (char_type == 1)
  1963.           {    if (print_attribute & UNDERLINE)
  1964.                   SHOWU (output_fp, point_size);
  1965.               else
  1966.               {    if (fputs (")show\n", output_fp) == EOF)
  1967. !                     output_trouble (2);
  1968.               }
  1969.           }
  1970.   
  1971.           y_coord -= (point_size + extra_space);
  1972.           x_coord = 0;
  1973. --- 2028,2038 ----
  1974.           if (char_type == 1)
  1975.           {    if (print_attribute & UNDERLINE)
  1976.                   SHOWU (output_fp, point_size);
  1977.               else
  1978.               {    if (fputs (")show\n", output_fp) == EOF)
  1979. !                     output_trouble (DISCARD_JOB);
  1980.               }
  1981.           }
  1982.   
  1983.           y_coord -= (point_size + extra_space);
  1984.           x_coord = 0;
  1985. ***************
  1986. *** 1647,1667 ****
  1987.           fprintf (output_fp, "%d %d mv ", x + x_left_offset, y);
  1988.   }
  1989.   
  1990.   /****************************************************************************
  1991.   *    findfont ()                                                                *
  1992. ! *    generate a findfont statement                                            *
  1993.   ****************************************************************************/
  1994.   
  1995.   void findfont ()
  1996.   {    int    this;
  1997.   
  1998.       /*    remove reference to UNDERLINE.  Underline is not a font.    */
  1999.   
  2000.       this = (font_number * 4) + (print_attribute & 0x03);
  2001.       fonts_used[this] = 1;
  2002. !     fprintf (output_fp, "/%s findfont %d scalefont setfont\n", fonts[this], point_size);
  2003.   }
  2004.   
  2005.   /****************************************************************************
  2006.   *    start_file ()                                                            *
  2007.   *    Generate things that are appropriate for beginning of file processing    *
  2008. --- 2148,2183 ----
  2009.           fprintf (output_fp, "%d %d mv ", x + x_left_offset, y);
  2010.   }
  2011.   
  2012.   /****************************************************************************
  2013.   *    findfont ()                                                                *
  2014. ! *    generate a findfont statement. Do ISOLatin1 encoding if desired.        *
  2015.   ****************************************************************************/
  2016.   
  2017.   void findfont ()
  2018.   {    int    this;
  2019. +     char    new_font_name[100], *fontname;
  2020.   
  2021.       /*    remove reference to UNDERLINE.  Underline is not a font.    */
  2022.   
  2023.       this = (font_number * 4) + (print_attribute & 0x03);
  2024.       fonts_used[this] = 1;
  2025. ! 
  2026. !     if (isolatin)
  2027. !     {
  2028. !         strcpy (new_font_name, fonts[this]);
  2029. !         strcat (new_font_name, "-ISO");
  2030. !         if (fonts_iso[this] == 0)
  2031. !         {    fprintf (output_fp, "/%s /%s ReEncodeISO\n", new_font_name, fonts[this]);
  2032. !             fonts_iso[this] = 1;
  2033. !         }
  2034. !         fontname = new_font_name;
  2035. !     }
  2036. !     else
  2037. !         fontname = fonts[this];
  2038. ! 
  2039. !     fprintf (output_fp, "/%s findfont %d scalefont setfont\n", fontname, point_size);
  2040.   }
  2041.   
  2042.   /****************************************************************************
  2043.   *    start_file ()                                                            *
  2044.   *    Generate things that are appropriate for beginning of file processing    *
  2045. ***************
  2046. *** 1723,1733 ****
  2047. --- 2239,2258 ----
  2048.           for (i = 0;  i < npg_loc-1;  i++)
  2049.               fprintf (output_fp, "%%PsfPg: %d %d\n",  i, pg_loc[i]);
  2050.           fprintf (output_fp, "%%PsfPg: 9999 %d\n", pg_loc[npg_loc-1]);
  2051.           fprintf (output_fp, "%%PsfPtr: %d\n", psfptr);
  2052.       }
  2053. + #ifdef PSFFILTER
  2054.       fprintf (output_fp, "%c", CTLD_EOJ);        /* CTL/D = end job */
  2055. + #else
  2056. +     if (gen_eoj)
  2057. +         fprintf (output_fp, "%c", CTLD_EOJ);
  2058. + #ifdef CTLDALWAYS
  2059. +     if (gen_eoj == 0)
  2060. +         fprintf (output_fp, "%c", CTLD_EOJ);
  2061. + #endif
  2062. + #endif
  2063.   }
  2064.   
  2065.   /****************************************************************************
  2066.   *    draw_cross ()                                                            *
  2067.   *    Draw horizontal and vertical separation lines between pages 2/4-up        *
  2068. ***************
  2069. *** 1826,1835 ****
  2070. --- 2351,2421 ----
  2071.   #endif    /* HOPPER */
  2072.   }
  2073.   
  2074.   
  2075.   /************************************************************************
  2076. + *    nexttok()                                                            *
  2077. + *    like strtok() however assumes that quote or apostrophe delimit        *
  2078. + *    multi-word groups.                                                    *
  2079. + ************************************************************************/
  2080. + 
  2081. + char *nexttok (ss, q)
  2082. + char *ss, *q;
  2083. + {
  2084. +     static char *s;
  2085. +     char    quote_char, *start, *quote, *apostrophe;
  2086. +     
  2087. +     if (ss)
  2088. +         s = ss;
  2089. +     if (s  &&  *s)
  2090. +     {
  2091. +         /*    use quote or apostrophe delimiting? */
  2092. +     
  2093. +         quote = strchr (q, '"');
  2094. +         apostrophe = strchr (q, '\'');
  2095. +         
  2096. +         /*    skip leading quote symbols */
  2097. +         
  2098. +         quote_char = *s;
  2099. +         while (*s)
  2100. +         {    if ((quote && *s == '"')  ||  (apostrophe  &&  *s == '\''))
  2101. +             {    quote_char = *s++;
  2102. +                 break;
  2103. +             }
  2104. +             if (strchr (q, *s) == NULL)
  2105. +                 break;
  2106. +             quote_char = *s++;
  2107. +         }
  2108. +         
  2109. +         /*    skip to next quote */
  2110. +         
  2111. +         start = s;                        /*    beginning of user string */
  2112. + 
  2113. +         if (quote_char == '"' ||  quote_char == '\'')
  2114. +         {    while (*s  &&  *s != quote_char)
  2115. +                 s++;
  2116. +         }
  2117. +         else
  2118. +         {    while (*s  &&  strchr (q, *s) == NULL)
  2119. +                 s++;
  2120. +         }
  2121. +         
  2122. +         if (*s)                            /*    end of user string        */
  2123. +             *s++ = '\0';
  2124. +         else
  2125. +             s = NULL;
  2126. + 
  2127. +     }
  2128. +     else
  2129. +     {    s = NULL;
  2130. +         start = NULL;
  2131. +     }
  2132. +     return (start);
  2133. + }
  2134. + 
  2135. + 
  2136. + /************************************************************************
  2137.   *        tscan (s,t)                                                        *        
  2138.   *    look for string t in s. return -1 if t does not exits in s else        *
  2139.   *    return array position of first character match                        *
  2140.   ************************************************************************/
  2141.   
  2142. ***************
  2143. *** 1847,1860 ****
  2144.   }
  2145.   
  2146.   void get_time (t)                /*    get current time of */
  2147.   char    *t;
  2148.   {
  2149. !     long    n_time, time ();
  2150.       char    *x_time, *cc, *strchr();
  2151.   
  2152. !     n_time = time (0);            /* get time */
  2153.       x_time = ctime (&n_time);    /* convert ascii */
  2154.       if ((cc = strchr (x_time, '\n')) != NULL)
  2155.           *cc = '\0';
  2156.       strcpy (t, x_time);
  2157.   }
  2158. --- 2433,2446 ----
  2159.   }
  2160.   
  2161.   void get_time (t)                /*    get current time of */
  2162.   char    *t;
  2163.   {
  2164. !     time_t    n_time, time ();
  2165.       char    *x_time, *cc, *strchr();
  2166.   
  2167. !     n_time = time ((time_t *)0);    /* get time */
  2168.       x_time = ctime (&n_time);    /* convert ascii */
  2169.       if ((cc = strchr (x_time, '\n')) != NULL)
  2170.           *cc = '\0';
  2171.       strcpy (t, x_time);
  2172.   }
  2173. ***************
  2174. *** 1883,1921 ****
  2175.               return (UCCHAR(aa) - UCCHAR(bb));
  2176.       }
  2177.       return (0);
  2178.   }
  2179.   
  2180. - int comparen (a,b, n)            /* case insensitive compare with count limit */
  2181. - char    *a, *b;
  2182. - int        n;
  2183. - {    int    aa, bb;
  2184. - 
  2185. -     while (*a &&  n--)
  2186. -     {    aa = *a++;
  2187. -         bb = *b++;
  2188. -         if (UCCHAR (aa)  !=  UCCHAR (bb))
  2189. -             return (UCCHAR(aa) - UCCHAR(bb));
  2190. -     }
  2191. -     if (n <= 0)
  2192. -         return (0);
  2193. -     return (UCCHAR (*a) - UCCHAR (*b));
  2194. - }
  2195. - 
  2196. - int endcompare (a,b)            /* compare end of a with b */
  2197. - char    *a, *b;
  2198. - {
  2199. -     int    na, nb;
  2200. -     
  2201. -     na = strlen (a);
  2202. -     nb = strlen (b);
  2203. -     if (na > nb)
  2204. -         a += na - nb;
  2205. -     return (strcmp (a,b));
  2206. - }
  2207. - 
  2208. - 
  2209.   void trim (s)                    /*    trim trailing blanks  and \n */
  2210.   char    *s;
  2211.   {    int many;
  2212.   
  2213.       for (many = strlen (s) - 1;  many >= 0;  many--)
  2214. --- 2469,2478 ----
  2215. ***************
  2216. *** 1927,1937 ****
  2217.   }
  2218.   
  2219.   void bad_file()
  2220.   {
  2221.       fprintf (stderr, "Bad %s file\n", defref);
  2222. !     exit (1);
  2223.   }
  2224.   
  2225.   int xtoi (c)                    /*    hex character to integer     */
  2226.   int c;                            /*    any letter is a 'hex' digit */
  2227.   {
  2228. --- 2484,2494 ----
  2229.   }
  2230.   
  2231.   void bad_file()
  2232.   {
  2233.       fprintf (stderr, "Bad %s file\n", defref);
  2234. !     exit (DISCARD_JOB);
  2235.   }
  2236.   
  2237.   int xtoi (c)                    /*    hex character to integer     */
  2238.   int c;                            /*    any letter is a 'hex' digit */
  2239.   {
  2240. ***************
  2241. *** 1957,1968 ****
  2242.   ********************************************************/
  2243.   
  2244.   void catch (signo)
  2245.   int    signo;
  2246.   {
  2247.           fprintf (output_fp, "%c", CTLD_EOJ);
  2248. !         exit (0);
  2249.   }
  2250.   
  2251.   void output_trouble (rc)
  2252.   int    rc;
  2253.   {
  2254. --- 2514,2534 ----
  2255.   ********************************************************/
  2256.   
  2257.   void catch (signo)
  2258.   int    signo;
  2259.   {
  2260. + #ifdef PSFFILTER
  2261. +     abort_exit ();
  2262. + #else
  2263. +     if (gen_eoj)
  2264. +         fprintf (output_fp, "%c", CTLD_EOJ);
  2265. + #ifdef CTLDALWAYS
  2266. +     if (gen_eoj == 0)
  2267.           fprintf (output_fp, "%c", CTLD_EOJ);
  2268. ! #endif
  2269. ! #endif
  2270. !         exit (JOB_IS_DONE);
  2271.   }
  2272.   
  2273.   void output_trouble (rc)
  2274.   int    rc;
  2275.   {
  2276. ***************
  2277. *** 2038,2071 ****
  2278.   *    octal to integer                                                        *
  2279.   ****************************************************************************/
  2280.   int    otoi (s)
  2281.   char    *s;
  2282.   {
  2283. !     int        v, p, quit;
  2284.   
  2285.       v = 0;
  2286.       while (*s == ' ')
  2287.           s++;
  2288. !     quit = 0;
  2289. !     while (*s)
  2290. !     {    switch (*s)
  2291. !         {
  2292. !         case '0':    p = 0;  break;
  2293. !         case '1':    p = 1;  break;
  2294. !         case '2':    p = 2;  break;
  2295. !         case '3':    p = 3;  break;
  2296. !         case '4':    p = 4;  break;
  2297. !         case '5':    p = 5;  break;
  2298. !         case '6':    p = 6;  break;
  2299. !         case '7':    p = 7;  break;
  2300. !         default:    quit = 1;
  2301. !         }
  2302. !         if (quit)
  2303. !             break;
  2304. !         v = (v << 3) + p;
  2305. !         s++;
  2306. !     }
  2307.       return (v);
  2308.   }
  2309.   
  2310.   /****************************************************************************
  2311.   *    usage ()                                                                *
  2312. --- 2604,2621 ----
  2313.   *    octal to integer                                                        *
  2314.   ****************************************************************************/
  2315.   int    otoi (s)
  2316.   char    *s;
  2317.   {
  2318. !     int v;
  2319. !     unsigned d;
  2320.   
  2321.       v = 0;
  2322.       while (*s == ' ')
  2323.           s++;
  2324. !     while ((d = *s++ - '0')  <  8)
  2325. !         v = (v << 3) + d;
  2326.       return (v);
  2327.   }
  2328.   
  2329.   /****************************************************************************
  2330.   *    usage ()                                                                *
  2331. ***************
  2332. *** 2072,2105 ****
  2333.   ****************************************************************************/
  2334.   
  2335.   #ifdef PSFFILTER
  2336.   
  2337.   void usage ()
  2338. ! {    exit (1);
  2339.   }
  2340.   void size_display ()
  2341. ! {    exit (1);
  2342.   }
  2343.   
  2344.   #else    /* not PSFFILTER */
  2345.   
  2346.   static char *usage_text[] =
  2347.   {
  2348. !     "Usage: %s [-124dEehnswx] [-b n] [-c n] [-f n] [-g type] [-H txt] [-i n] [-l n]\n",
  2349. !     "     [-m n] [-M l,r,t,b[,pic]] [-p n] [-P n] [-R n] [-r n] [-t n] [-u f] file..",
  2350. !     "where:",
  2351.       "   -1|2|4  print 1,2,4 up (default=1)",
  2352.       "   -b n    paper bin n",
  2353.       "   -c n    print columns",
  2354.       "   -d      double sided",
  2355.       "   -e      left-justified line wrap",
  2356.       "   -E      right-justified line wrap",
  2357.       "   -f n    font number (def=0:Courier)",
  2358.       "   -g type letter legal a4 b5",
  2359.       "   -h      file name header",
  2360.       "   -H text text header",
  2361.       "   -i n[pic] indent left margin points",
  2362.       "   -l n    print lines per page",
  2363.       "   -L n    lines per page",
  2364.       "   -m n[pic] top margin points",
  2365.       "   -M xxx  set all margins",
  2366.       "   -n      portrait (narrow) format",
  2367. --- 2622,2667 ----
  2368.   ****************************************************************************/
  2369.   
  2370.   #ifdef PSFFILTER
  2371.   
  2372.   void usage ()
  2373. ! {    exit (DISCARD_JOB);
  2374.   }
  2375.   void size_display ()
  2376. ! {    exit (DISCARD_JOB);
  2377.   }
  2378.   
  2379.   #else    /* not PSFFILTER */
  2380.   
  2381.   static char *usage_text[] =
  2382.   {
  2383. ! #ifdef CTLDALWAYS
  2384. !     "Usage: %s [-124DdehIjnswx][-b n][-c n][-f n][-g type][-H txt][-i n][-l n]\n",
  2385. ! #else
  2386. !     "Usage: %s [-124DdEehInswx][-b n][-c n][-f n][-g type][-H txt][-i n][-l n]\n",
  2387. ! #endif
  2388. !     "     [-m n][-M l,r,t,b[,pic]][-p n][-P n][-R n][-r n][-t n][-u f] file..",
  2389.       "   -1|2|4  print 1,2,4 up (default=1)",
  2390.       "   -b n    paper bin n",
  2391.       "   -c n    print columns",
  2392. +     "   -D      duplex double sided",
  2393.       "   -d      double sided",
  2394.       "   -e      left-justified line wrap",
  2395.       "   -E      right-justified line wrap",
  2396.       "   -f n    font number (def=0:Courier)",
  2397.       "   -g type letter legal a4 b5",
  2398.       "   -h      file name header",
  2399.       "   -H text text header",
  2400. + #ifdef ISO
  2401. +     "   -I      disable ISOLatin1 encoding",
  2402. + #else
  2403. +     "   -I      use ISOLatin1 encoding",
  2404. + #endif
  2405.       "   -i n[pic] indent left margin points",
  2406. + #ifndef CTLDALWAYS
  2407. +     "   -j      ctl/d at end of print job",
  2408. + #endif
  2409.       "   -l n    print lines per page",
  2410.       "   -L n    lines per page",
  2411.       "   -m n[pic] top margin points",
  2412.       "   -M xxx  set all margins",
  2413.       "   -n      portrait (narrow) format",
  2414. ***************
  2415. *** 2116,2126 ****
  2416.       "   file..  name of files (or stdin)",
  2417.       "   output: stdout",
  2418.       ""
  2419.   } ;
  2420.   
  2421. ! #define TOPCOUNT 3
  2422.   
  2423.   void usage ()
  2424.   {    int        i, many, n, ff;
  2425.   
  2426.       fprintf (stderr, usage_text[0], pgmname);
  2427. --- 2678,2688 ----
  2428.       "   file..  name of files (or stdin)",
  2429.       "   output: stdout",
  2430.       ""
  2431.   } ;
  2432.   
  2433. ! #define TOPCOUNT 2
  2434.   
  2435.   void usage ()
  2436.   {    int        i, many, n, ff;
  2437.   
  2438.       fprintf (stderr, usage_text[0], pgmname);
  2439. ***************
  2440. *** 2158,2168 ****
  2441.           many += n + 3;
  2442.           fprintf (stderr,"   %s", page_types[i].paper_name);
  2443.       }
  2444.       if (ff)
  2445.           fprintf (stderr, "\n");
  2446. !     exit (1);
  2447.   }
  2448.   
  2449.   /************************************************************************
  2450.   *    size_display ()                                                        *
  2451.   *    print a table of point size, page size, line count, column count    *
  2452. --- 2720,2730 ----
  2453.           many += n + 3;
  2454.           fprintf (stderr,"   %s", page_types[i].paper_name);
  2455.       }
  2456.       if (ff)
  2457.           fprintf (stderr, "\n");
  2458. !     exit (DISCARD_JOB);
  2459.   }
  2460.   
  2461.   /************************************************************************
  2462.   *    size_display ()                                                        *
  2463.   *    print a table of point size, page size, line count, column count    *
  2464. ***************
  2465. *** 2205,2212 ****
  2466.                   fprintf (stderr, " %4d%4d", n_lines, n_chars);
  2467.               }
  2468.               fprintf (stderr, "\n");
  2469.           }
  2470.       }
  2471. !     exit (1);
  2472.   }
  2473.   #endif /* PSFFILTER */
  2474. --- 2767,2774 ----
  2475.                   fprintf (stderr, " %4d%4d", n_lines, n_chars);
  2476.               }
  2477.               fprintf (stderr, "\n");
  2478.           }
  2479.       }
  2480. !     exit (DISCARD_JOB);
  2481.   }
  2482.   #endif /* PSFFILTER */
  2483.  
  2484. exit 0 # Just in case...
  2485.