home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 3 / goldfish_volume_3.bin / files / text / tex / pastex / source / driver / print / dviprint.c next >
Encoding:
C/C++ Source or Header  |  1994-09-30  |  42.5 KB  |  1,406 lines
  1. /*
  2. **    This file generated by localize 2.9 (AmigaDOS 2.1) from dviprint.c
  3. */
  4. /*
  5.  *
  6.  * AUTHOR(s) -- Porting SUN-Version to ATARI ST / AMIGA
  7.  *  Robert Stabl   -- managing dvi-file, hardcopy for NEC P6
  8.  *  Georg Hessmann -- porting ATARI ST version to AMIGA 1000   
  9.  */
  10.  
  11.  
  12.  
  13. /* Change log:
  14.  *
  15.  * 15-Mar-88 (rbs) -- ported sun version to atari st
  16.  *                 -- v3.00
  17.  * 06-Apr-88 (rbs) -- v3.12
  18.  * 30-Apr-88 (rbs) -- v3.13 
  19.  * 31-May-88 (rbs) -- v3.14
  20.  * 04-Jul-88 (hes) / (rbs) -- ported atari version to amiga
  21.  *                 -- v3.20
  22.  * 26-Nov-89 (hes) -- Change log now in file util/version.h
  23.  *                 -- v0.60
  24.  */
  25.  
  26.  
  27.  
  28. /**********************************************************************/
  29. /***********************  external definitions  ***********************/
  30. /**********************************************************************/
  31.  
  32. #define MAIN        /*    for globals.h        */
  33.  
  34. #ifdef AMIGA
  35. /*    For now only the Amiga knows about GetOpt.c    */
  36. #define LONG_ARGS
  37. #define TEX        /*    for GetOpt.h        */
  38. #endif
  39.  
  40. #include "defines.h"
  41.  
  42. #include <stdio.h>
  43. #include <ctype.h>
  44. #ifdef ANSI
  45. #  include <stdlib.h>
  46. #  include <string.h>
  47. #endif
  48.  
  49. #include "globals.h"
  50.  
  51. #ifdef AMIGA
  52. #  include <signal.h>
  53. #  include <exec/types.h>
  54. #  include <exec/exec.h>
  55. #  include <exec/ports.h>
  56. #  include <devices/printer.h>
  57. extern struct ExecBase        *SysBase;
  58. #  include <clib/exec_protos.h>
  59. #  include <clib/dos_protos.h>
  60. #  include <pragmas/exec_pragmas.h>
  61. #  include <pragmas/dos_pragmas.h>
  62. #endif
  63.  
  64. #ifdef AZTEC_C
  65. #  include <functions.h>
  66. #endif
  67.  
  68. #include "commands.h"
  69. #include "dvihand.h"
  70. #include "flmt.h"
  71. #include "new_font.h"
  72. #include "bitmap.h"
  73. #ifdef LONG_ARGS
  74. #  include "GetOpt.h"
  75. #endif
  76. #ifdef AMIGA
  77. #  include "amprint.h"
  78. #endif
  79.  
  80.  
  81. #include "dviprint.i"
  82. #include "newhard.i"
  83. #include "new_font.i"
  84. #include "globals.i"
  85. #include "dvihand.i"
  86. #include "dospecia.i"
  87. #include "bitmap.i"
  88. #include "muiprint.i"
  89.  
  90. #ifdef LONG_ARGS
  91. #  include "GetOpt.i"
  92. #  include "PrintOpt.i"
  93. #  include "prhelp.i"
  94. #endif
  95.  
  96. #ifdef AMIGA
  97. #  include "fast_cp.i"
  98. #  include "amprint.i"
  99. #  include "amprhelp.i"
  100. #endif
  101. #ifdef ATARI
  102. #  include "atscreen.i"
  103. #endif
  104.  
  105.  
  106. /*
  107.  * Fuer die locale-Library:
  108.  *
  109.  * Hier duerfen *nur* die MSG_#? Nummern eingebunden werden!
  110.  * Achtung:
  111.  * Es muss/sollte 'multiple-include' erlaubt sein!
  112.  */
  113. #include "local.i"
  114.  
  115. #undef  CATCOMP_ARRAY
  116. #undef  CATCOMP_BLOCK
  117. #undef  CATCOMP_STRINGS
  118. #define CATCOMP_NUMBERS
  119. #include "localstr.h"
  120.  
  121.  
  122.  
  123. #define EQ(a,b) (strcmp(a,b)==0)
  124.  
  125.  
  126. /**********************************************************************/
  127. /*************************  lokale Funktionen *************************/
  128. /**********************************************************************/
  129.  
  130. #ifndef LONG_ARGS
  131. static void PrintHelp        Args((void));
  132. static void not_a_valid_integer    Args((void));
  133. static void offset_to_inch    Args((double *inch,
  134.                       float *offset,
  135.                       char *einh));
  136. static void DecodeArgs        Args((int argc,
  137.                                       char **argv));
  138.  
  139. #ifdef AZTEC_C
  140. #pragma regcall ( offset_to_inch (a0,a1,a2) )
  141. #pragma regcall ( DecodeArgs (d0,a1) )
  142. #endif
  143. #endif /* LONG_ARGS */
  144.  
  145.  
  146. /**********************************************************************/
  147. /*************************  Global Variables  *************************/
  148. /**********************************************************************/
  149.  
  150. /*    See globvars.h        */
  151.  
  152. extern struct bitmap    map;
  153.  
  154. extern struct WBStartup    *WBenchMsg;
  155. int __buffsize = 2048;    // setze fuer jedes File ein etwas groeseren Buffer
  156.  
  157.  
  158. struct stack_entry {  /* stack entry */
  159.     long hh, h, vv, v, w, x, y, z;  /* what's on stack */
  160. };
  161.  
  162. static struct stack_entry stack[STACKSIZE];    /* stack        */
  163. static char ParamStr[STRSIZE];            /* used by GetBytes()    */
  164.  
  165.  
  166. /**********************************************************************/
  167. /*******************************  main  *******************************/
  168. /**********************************************************************/
  169. void main(int argc, char *argv[])
  170. {
  171.  
  172.     int command;            /* current command                       */
  173.     long count[10];         /* the 10 counters at begining of each page */
  174.     long cpagep;            /* current page pointer                  */
  175.     long leftpagep;         /* left page pointer for twopage         */
  176.     long tpagep;        /* temporary page pointer             */
  177.     register int i;         /* command parameter; loop index         */
  178.     long k;                 /* temporary parameter                   */
  179.     int SkipMode = FALSE;   /* in skip mode flag                     */
  180.     int sp;                 /* stack pointer                         */
  181.     long val, val2;          /* temporarys to hold command information*/
  182.     long w;                  /* current horizontal spacing            */
  183.     long x;                  /* current horizontal spacing            */
  184.     long y;                  /* current vertical spacing              */
  185.     long z;                  /* current vertical spacing              */
  186.     int Pass;                /* actual Pass                           */
  187.     int is_first_print_page; /* used for FormFeed              */
  188.  
  189.     /*    Initialize the non NULL Variables    */
  190.     g_logging =    -1;    /* disable it until DecodeArgs()    */
  191.     g_Logname =    DVIPRINT_LOGFILE;
  192.  
  193. #ifdef ATARI
  194.     g_progname = "dviprint"; /* (rbs)  -- changed for atari st */
  195. #else
  196. #  ifdef AMIGA
  197.     Enable_Abort = 1;
  198.     task_priority = 0;
  199.     check_background();
  200.     if (argc) {
  201.       g_progname = argv[0];
  202.       WBenchMsg = NULL;
  203.     }
  204.     else {
  205.       g_progname = "DVIprint";
  206.       WBenchMsg = (struct WBStartup *)argv;
  207.     }
  208. #  else
  209.     g_progname = argv[0];
  210. #  endif
  211. #endif
  212.  
  213.     /* defaults */
  214.     MaxDviBufSize = 0;    // ueberhaupt kein Caching
  215.     ncopies    = 1;
  216.     last_form_feed = TRUE;        /* a formfeed at the last page?    */
  217.     is_first_print_page = TRUE;
  218.     nr_printed_pages = 0;
  219.     bytesperlong = sizeof (long);
  220.  
  221.     // -13.13: Zeigt GetOpt(), daß nichts definiert wurde
  222.     user_paper_height_in = -13.13;
  223.     user_paper_width_in  = -13.13;
  224.     
  225.     start_specialhost = FALSE;
  226.     
  227.  
  228.     DecodeArgs( argc, argv );
  229.  
  230.     WarningStr(NULL);    /* print copyright string */
  231.  
  232.     
  233. #if defined(BETACOPYRIGHT)
  234.     PrintBetaCopy();
  235. #endif
  236.  
  237. #ifdef AMIGA
  238.     old_task_priority = (unsigned long)SetTaskPri(FindTask(NULL), task_priority);
  239. #endif
  240.  
  241.     /* Set resolution for quality and printer */
  242.     { int save_hresolution = hconvresolution;
  243.       int save_vresolution = vconvresolution;
  244.       int save_resolution = resolution;    /* ist == 0 falls -z xxx/yyy angegeben wurde */
  245.  
  246.       (void)SetupPrinterPara(o_printer_name, draft, !o_optimize);
  247.  
  248.       if (save_hresolution != 0) {    /* -z option are given */
  249.         if (save_resolution == 0) {     /* -z hhh/vvv */
  250.           /* hier wird die dpi unveraendert uebernommen */
  251.           resolution      = hconvresolution = save_hresolution;
  252.           vconvresolution = save_vresolution;
  253.         }
  254.         else {                /* -z ddd */
  255.           /* hier wird die Aufloesung dem Drucker angepasst */
  256.           /* halte Ratio zwischen h und v ein */
  257.           resolution        = save_hresolution;
  258.           vconvresolution = (int)((long)save_hresolution * (long)vconvresolution / (long)hconvresolution);
  259.           hconvresolution = save_hresolution;
  260.         }
  261.       }
  262.     }
  263.  
  264.     hoffset = (int)((double)hconvresolution * hoffset_in);
  265.     voffset = (int)((double)vconvresolution * voffset_in);
  266.  
  267. #ifdef DEBUG
  268.     if (DeBug) {
  269.       printf("hoffset in inch: %f, hoffset in pixel: %d\n",hoffset_in,hoffset);
  270.       printf("voffset in inch: %f, voffset in pixel: %d\n",voffset_in,voffset);
  271.     }
  272. #endif
  273.  
  274.     if (abs(user_paper_width_in+13.13) > 0.01) {
  275.       paper_width = (long)((float)hconvresolution * user_paper_width_in);
  276.     }
  277.     else {
  278.       paper_width  = hconvresolution * HSIZE;        /* for !preload */
  279.     }                            /*   default    */
  280.                             /*    size      */
  281.     if (abs(user_paper_height_in+13.13) > 0.01) {
  282.       paper_height = (long)((float)vconvresolution * user_paper_height_in);
  283.     }
  284.     else {
  285.       paper_height = vconvresolution * VSIZE;
  286.     }
  287.                             
  288.     
  289. #ifdef ATARI
  290.     LogTOSVersion();
  291. #endif
  292.  
  293.     /*    Hier wird nun die .dvi Datei analysiert.    */
  294.  
  295.     if ('\0' == *filename)
  296.       Fatal(5,MSG_NO_DVI_FILENAME);
  297.     else if ((dvifp=OpenDVI(filename, MaxDviBufSize)) == NULL) {
  298.       Fatal(5,MSG_CANT_OPEN_DVI_FILE,(char *)filename);
  299.     }
  300.  
  301.     Pass=0;
  302.  
  303.     init_fontmt (0);    /* we are DVIPRINT */
  304.  
  305.     Logging(MSG_LOADING_DVI, filename);
  306.  
  307.     if ((i = (int) NoSignExtend(dvifp, 1)) != PRE)  {
  308.         Fatal(5, MSG_MISSING_PRE);
  309.     }
  310.  
  311.     i = SignExtend(dvifp, 1);
  312.     if (i != DVIFORMAT)  {
  313.         Fatal(5,MSG_WRONG_DVI_TYPE, i, DVIFORMAT);
  314.     }
  315.  
  316. /* it is important that these be the very first things output !!! */
  317.  
  318.  
  319. #ifdef DEBUG
  320.     if (DeBug)
  321.      {
  322.       Message("Title: %s\n", filename);
  323.       Message("Creator: %s\n", g_progname);
  324.       if ( ncopies > 1 )
  325.         {
  326.          Message("%d @copies\n", ncopies);
  327.         }
  328.      }
  329. #endif        
  330.     tpagep = DVIftell(dvifp);
  331.  
  332.     if (Reverse) {
  333.       if (ReadPostAmble(PreLoad))
  334.        {
  335.         Warning(MSG_INCOMPLETE_DVI_REVERSE);
  336.         Reverse = FALSE;
  337.         if (PreLoad)
  338.          {
  339.           Warning(MSG_INCOMPLETE_DVI_PRELOAD);
  340.           PreLoad = FALSE;
  341.          }
  342.         DVIfseekSet(dvifp, tpagep);
  343.         num = NoSignExtend(dvifp, 4);
  344.         den = NoSignExtend(dvifp, 4);
  345.         mag = NoSignExtend(dvifp, 4);
  346.         k = NoSignExtend(dvifp, 1);
  347.         GetBytes(dvifp, ParamStr, k);
  348.        }
  349.       else
  350.        {
  351.         if (PreLoad) {
  352.           GetFontDef(1);
  353.         }
  354.         DVIfseekSet(dvifp, ppagep);
  355.        }
  356.     }
  357.     else {
  358.        if (PreLoad) {
  359.          if (ReadPostAmble(TRUE))
  360.           {
  361.            Warning(MSG_INCOMPLETE_DVI_PRELOAD);
  362.            PreLoad = FALSE;
  363.            DVIfseekSet(dvifp, tpagep);
  364.            num = NoSignExtend(dvifp, 4);
  365.            den = NoSignExtend(dvifp, 4);
  366.            mag = NoSignExtend(dvifp, 4);
  367.           }
  368.          else
  369.           {
  370.             GetFontDef(1);
  371.             DVIfseekSet(dvifp, 14L);
  372.           }
  373.         }
  374.        else 
  375.         {
  376.          if (ReadPostAmble(FALSE)) 
  377.           {
  378.             /* DVI file not complete */
  379.             Warning(MSG_INCOMPLETE_DVI);
  380.             DVIfseekSet(dvifp, tpagep);
  381.             num = NoSignExtend(dvifp, 4);
  382.             den = NoSignExtend(dvifp, 4);
  383.             mag = NoSignExtend(dvifp, 4);
  384.           }
  385.          DVIfseekSet(dvifp, 14L);
  386.         }
  387.         k = NoSignExtend(dvifp, 1);
  388.         GetBytes(dvifp, ParamStr, k);
  389.     }
  390.     
  391.     if (Reverse) {
  392.       current_page_phy = NumOfPages; // letzte Seite
  393.     }
  394.     else {
  395.       current_page_phy = 1; // erste Seite
  396.     }
  397.         
  398.     hconv = DoConv(num, den, hconvresolution);
  399.     vconv = DoConv(num, den, vconvresolution);
  400.     alpha = (((double)den / 7227.0) / 0x100000) * (25400000.0 / (double) num) ;
  401.     
  402.     if (landscape) {
  403.       /*
  404.        * Die paper_height und paper_width werden in ReadPostAmble() gesetzt.
  405.        * Bei Landscape muss das aber umgeaendert werden. Dort muss der voffset
  406.        * an die rechte Seite gesetzt werden und der hoffset nach oben.
  407.        * Also wird nun noch etwas an den Werten nachtraeglich rumgefummelt.
  408.        * Direkt in ReadPostAmble() geht's leider nicht, da dvihand.c *keine*
  409.        * ShowDVI/DVIprint Abhaengigkeiten bekommen soll.
  410.        * Bei paper_heigh kommt voff weg und hoff dazu,
  411.        * bei paper_width kommt (1in-hoff) dazu und (1in-voff) weg.
  412.        */
  413.       
  414.       paper_height += hoffset - voffset;
  415.       //paper_width  += (hconvresolution - hoffset) - (vconvresolution - voffset);
  416.       paper_width  -= hoffset;    // das wurde schon frueher mal addiert
  417.       
  418.       if (!twopage) paper_width += voffset;
  419.     }
  420.  
  421.     if (twopage) {
  422.       // linke Seite + rechte Seite + Mitte + unterer Rand (fix 1in) + oberer Rand (voff)
  423.       InitBitmap(paper_height, 2 * paper_width + moffset + vconvresolution + voffset);
  424.     }
  425.     else {
  426.       InitBitmap(paper_height, paper_width);
  427.     }
  428.  
  429. #ifdef PROTOCOL
  430.     protocol ();
  431. #endif
  432.  
  433. #if 0 /* das war meine Version (hes)
  434.     if (hconvresolution <= 599)        hmaxdrift = hconvresolution / 100 ;
  435.     else if (hconvresolution < 1199)    hmaxdrift = hconvresolution / 200 + 3 ;
  436.     else                hmaxdrift = hconvresolution / 400 + 6 ;
  437.  
  438.     if (vconvresolution <= 599)        vmaxdrift = vconvresolution / 100 ;
  439.     else if (vconvresolution < 1199)    vmaxdrift = vconvresolution / 200 + 3 ;
  440.     else                vmaxdrift = vconvresolution / 400 + 6 ;
  441.  
  442.     thinspace      = (long)(0.025*hconvresolution*hconv) ; /* 0.025 inches */
  443.     vertsmallspace = (long)(0.025*vconvresolution*vconv) ; /* 0.025 inches */
  444. #else    /* das ist Bernd's Version */
  445.       if (hconvresolution < 100)    hmaxdrift = 0;
  446.       else if (hconvresolution < 200)    hmaxdrift = 1;
  447.       else                hmaxdrift = 2;
  448.  
  449.       if (vconvresolution < 100)    vmaxdrift = 0;
  450.       else if (vconvresolution < 200)    vmaxdrift = 1;
  451.       else                vmaxdrift = 2;
  452.  
  453.       /* Setup initial spaces for 10pt Font: */
  454.         /* wordspace  =approx.  0.2 * 10pt =  0.027674 inches */
  455.       thinspace      =  (long)(0.027674 * hconvresolution * hconv);
  456.         /* -backspace =approx. -0.9 * 10pt = -0.124533 inches */
  457.       backspace      = -(long)(0.124533 * hconvresolution * hconv);
  458.         /* vertspace  =approx.  0.8 * 10pt =  0.110696 inches */
  459.       vertsmallspace =  (long)(0.110696 * vconvresolution * vconv);
  460. #endif
  461.  
  462.     PrepareHardcopies();
  463.  
  464.     /*    Hier werden nun einzelne Seiten gedruckt.    */
  465.  
  466.     h = v = w = x = y = z = 0;
  467.     hh = vv = 0;
  468.     sp = 0;
  469.  
  470.  
  471.     while (TRUE) {
  472.  
  473.      command=NoSignExtend(dvifp, 1);
  474.  
  475.      if (command >= SETC_000 && command <= SETC_127) {
  476.       if (!SkipMode) { 
  477.         SetChar((long) command, command);
  478.        } 
  479.      }
  480.      else {
  481.       if (command >= FONT_00 && command <= FONT_63) {
  482.     if (!SkipMode) {
  483.           SetFntNum((long) (command - FONT_00));
  484.         } 
  485.       }
  486.       else {
  487.        if (command <= POP) {
  488.         switch (command)  {
  489.          case SET1:case SET2:case SET3:case SET4:
  490.             val = NoSignExtend(dvifp, command-SET1+1);
  491.             if (!SkipMode) SetChar(val, command);
  492.             break;
  493.  
  494.          case SET_RULE:
  495.             val = NoSignExtend(dvifp, 4);
  496.             val2 = NoSignExtend(dvifp, 4);
  497.             if (!SkipMode) SetRule(val, val2, 1);
  498.             break;
  499.  
  500.          case PUT1:case PUT2:case PUT3:case PUT4:
  501.             val = NoSignExtend(dvifp,command-PUT1+1);
  502.             if (!SkipMode) SetChar(val, command);
  503.             break;
  504.  
  505.          case PUT_RULE:
  506.             val = NoSignExtend(dvifp, 4);
  507.             val2 = NoSignExtend(dvifp, 4);
  508.             if (!SkipMode) SetRule(val, val2, 0);
  509.             break;
  510.  
  511.          case NOP:
  512.             break;
  513.  
  514.          case BOP:
  515.             cpagep = DVIftell(dvifp) - 1;
  516.  
  517.         if (twopage) {
  518.               if (leftpage) {
  519.  
  520.             leftpagep = cpagep;    /* for twopage mode */
  521.             
  522.             // die linke Seite ist die unterere 
  523.             if (landscape) {
  524.               OffsetBitmap_X = vconvresolution; // map.width - 2 * paper_width - moffset - voffset;
  525.               OffsetBitmap_Y = hoffset;
  526.             }
  527.             else {
  528.               OffsetBitmap_X = hoffset;
  529.               OffsetBitmap_Y = voffset;
  530.             }
  531.           }
  532.           else {
  533.             // rechte Seite
  534.             if (landscape) {
  535.               OffsetBitmap_X = vconvresolution + paper_width + moffset; // map.width - paper_width - voffset;
  536.                 OffsetBitmap_Y = hoffset;
  537.             }
  538.             else {
  539.               OffsetBitmap_X = paper_width + moffset;
  540.                 OffsetBitmap_Y = voffset;
  541.             }
  542.           }
  543.         }
  544.         else {
  545.           // !twopage
  546.  
  547.           if (landscape) {
  548.             OffsetBitmap_X = hconvresolution;
  549.             OffsetBitmap_Y = hoffset;
  550.           }
  551.           else {
  552.             OffsetBitmap_X = hoffset;
  553.             OffsetBitmap_Y = voffset;
  554.           }
  555.         }
  556.  
  557.         // printf("map w: %ld, pw: %ld, OX: %ld, OY: %ld, h: %ld, v: %ld, m: %ld\n", map.width, paper_width, OffsetBitmap_X, OffsetBitmap_Y, hoffset, voffset, moffset);
  558.  
  559.             for (i=0; i<=9; i++)
  560.                 count[i] = NoSignExtend(dvifp, 4);
  561.             ppagep = NoSignExtend(dvifp, 4);
  562.  
  563.             CurrentPage = count[0];
  564.  
  565.             h = v = w = x = y = z = 0;
  566.             hh = vv = 0;
  567.             sp = 0;
  568.             
  569.             {
  570.               long TmpPage = (PhyPageNumbers) ? current_page_phy : CurrentPage;
  571.               
  572.               SkipMode = FALSE;
  573.               
  574.               if (TmpPage < FirstPage || TmpPage > LastPage) {
  575.                 SkipMode = TRUE;
  576.               }
  577.               else {
  578.                 if (twopage) {
  579.                   // zwei Seiten auf ein Blatt...also (un)gerade hat eine etwas andere Bedeutung
  580.                   int tp = TmpPage & 3;
  581.  
  582.                   switch (print_page_numbers) {
  583.                     case 1:                    /* nur ungerade Seiten */
  584.                       if (tp == 0 || tp == 3) SkipMode = TRUE;
  585.                       break;
  586.                     case 2:                    /* nur gerade Seiten */
  587.                       if (tp == 1 || tp == 2) SkipMode = TRUE;
  588.                       break;
  589.                   }
  590.                 }
  591.                 else {
  592.                   switch (print_page_numbers) {
  593.                     case 1:                    /* nur ungerade Seiten */
  594.                       if (!(TmpPage & 1)) SkipMode = TRUE;
  595.                       break;
  596.                     case 2:                    /* nur gerade Seiten */
  597.                       if (TmpPage & 1) SkipMode = TRUE;
  598.                       break;
  599.                   }
  600.                 }
  601.               }
  602.             }
  603.  
  604.             if( !SkipMode ) 
  605.              {
  606.               if( !g_quiet && Pass==0)
  607.                { 
  608.                 if (!usegui) MessageStr("[%ld]", count[0] );        // im GUI ist das uninteressant!
  609.         MUISetWorkCurPage((PhyPageNumbers) ? current_page_phy: count[0]);
  610.  
  611.                 if (!is_first_print_page && !(twopage && !leftpage)) {
  612.                   FormFeed();
  613.                 }
  614.                 else {
  615.                   is_first_print_page = FALSE;
  616.                 }
  617.                }
  618.              }
  619.             break;
  620.  
  621.          case EOP:
  622.             i = 1;
  623.  
  624.             if (!SkipMode) {
  625.             
  626.               if (twopage && leftpage) {
  627.                 // die rechte Seite muss noch aufgebaut werden, bevor es was zu drucken gibt 
  628.  
  629.                 leftpage = FALSE;
  630.  
  631.                 // hier muesste noch der Offset fuer die rechte Seite gesetzt werden!
  632.                 // Nachtrag: Dies wird nun in BOP gemacht!
  633.                 // ABER: Es muss auch die linke Seite gedruckt werden, wenn es die letzte ist!
  634.                 // Wie testen wir, ob das nun die letzte Seite ist??
  635.                 // Antwort: In POST wird getestet, ob wir auf der rechten Seite sind...
  636.                 break;
  637.               }
  638.               else {
  639.                 leftpage = TRUE;
  640.               }
  641.  
  642.               if ((i=PrintPage()) == 0) {    // RETURN == 1 : fertig, == 0 : weitere Durchgänge nötig
  643.                  Pass = 1;        // noch nicht fertig, weitere Durchgaenge folgen
  644.                  // ACHTUNG: Pass ist hier *lokal* und nimmt nur die Werte 0 und 1 an!
  645.                  // Die eigentliche Pass Anzahl wird nur in bitmap.c bestimmt!!!
  646.                  if (twopage) DVIfseekSet(dvifp,(long) leftpagep);
  647.                  else         DVIfseekSet(dvifp,(long) cpagep);
  648.               }
  649.             }
  650.  
  651.             if (i != 0) {
  652.                Pass = 0;
  653.                
  654.                if (Reverse) current_page_phy--;
  655.                else         current_page_phy++;
  656.                
  657.                if (!SkipMode) NrOfPagesToPrint--;    // wieder eine Seite gedruckt
  658.  
  659.         /*
  660.          *  War's das, oder sollen noch mehr Seiten gedruckt werden?
  661.          *  Abbruch-Abfrage, damits schneller geht.
  662.          */
  663.                if ((NrOfPagesToPrint == 0) || 
  664.            (Reverse && PhyPageNumbers && current_page_phy < FirstPage) ||
  665.            (!Reverse && PhyPageNumbers && current_page_phy > LastPage)) {
  666.  
  667.                  if (last_form_feed) {
  668.                    FormFeed();
  669.                  }
  670.               EndHardcopies();
  671.                  AbortRun(0);
  672.                  /* never reached */
  673.                }
  674.  
  675.                if( Reverse ) 
  676.                 { 
  677.                   if (ppagep > 0L)
  678.                     DVIfseekSet(dvifp, ppagep);
  679.                   else {
  680.                     if (last_form_feed) {
  681.                       FormFeed();
  682.                     }
  683.             EndHardcopies();
  684.                     AbortRun(0);
  685.                   }
  686.                 }
  687.             }   
  688.             break;
  689.  
  690.          case PUSH:
  691.             if (sp >= STACKSIZE)
  692.                 Fatal(5, MSG_STACK_OVER);
  693.             stack[sp].hh = hh;
  694.             stack[sp].vv = vv;
  695.             stack[sp].h  = h;
  696.             stack[sp].v  = v;
  697.             stack[sp].w  = w;
  698.             stack[sp].x  = x;
  699.             stack[sp].y  = y;
  700.             stack[sp].z  = z;
  701.             sp++;
  702.             break;
  703.  
  704.          case POP:
  705.             --sp;
  706.             if (sp < 0)
  707.                 Fatal(5, MSG_STACK_UNDER);
  708.             hh = stack[sp].hh;
  709.             vv = stack[sp].vv;
  710.             h  = stack[sp].h;
  711.             v  = stack[sp].v;
  712.             w  = stack[sp].w;
  713.             x  = stack[sp].x;
  714.             y  = stack[sp].y;
  715.             z  = stack[sp].z;
  716.             break;
  717.  
  718.          default:
  719. /*
  720.  *              ** Fatal(5, "%d is an undefined command", command);
  721.  */
  722.         if (!Pass)
  723.          {
  724.            Warning(MSG_INCOMPLETE_DVI);
  725.           }
  726.                 //i = 1;
  727.                 if (!SkipMode)
  728.                  {
  729.                   if ((i=PrintPage()) == 0)
  730.                    {
  731.                     Pass = 1;
  732.                     DVIfseekSet(dvifp,(long) cpagep);
  733.                    }
  734.                   else
  735.                    {
  736.                     if (last_form_feed) {
  737.                       FormFeed();
  738.                     }
  739.             EndHardcopies();
  740.                     AbortRun(1);
  741.                    }
  742.                  }
  743.                 else
  744.                  {
  745.                   if (last_form_feed) {
  746.                     FormFeed();
  747.                   }
  748.           EndHardcopies();
  749.                   AbortRun(1);
  750.                  }
  751.                 break;
  752.          }    /* end switch */
  753.         }    /* end if <= POP */
  754.     else {
  755.  
  756.      switch (command) {
  757.           case RIGHT1:
  758.       case RIGHT2:
  759.       case RIGHT3:
  760.       case RIGHT4:
  761.             val = SignExtend(dvifp,command-RIGHT1+1);
  762.             if (!SkipMode) MoveOver(val);
  763.             break;
  764.  
  765.           case W0:
  766.             if (!SkipMode) MoveOver(w);
  767.             break;
  768.  
  769.           case W1:
  770.       case W2:
  771.       case W3:
  772.       case W4:
  773.             w = SignExtend(dvifp,command-W1+1);
  774.             if (!SkipMode) MoveOver(w);
  775.             break;
  776.  
  777.           case X0:
  778.             if (!SkipMode) MoveOver(x);
  779.             break;
  780.  
  781.           case X1:
  782.       case X2:
  783.       case X3:
  784.       case X4:
  785.             x = SignExtend(dvifp,command-X1+1);
  786.             if (!SkipMode) MoveOver(x);
  787.             break;
  788.  
  789.           case DOWN1:
  790.       case DOWN2:
  791.       case DOWN3:
  792.       case DOWN4:
  793.             val = SignExtend(dvifp,command-DOWN1+1);
  794.             if (!SkipMode) MoveDown(val);
  795.             break;
  796.  
  797.           case Y0:
  798.             if (!SkipMode) MoveDown(y);
  799.             break;
  800.  
  801.           case Y1:
  802.       case Y2:
  803.       case Y3:
  804.       case Y4:
  805.             y = SignExtend(dvifp,command-Y1+1);
  806.             if (!SkipMode) MoveDown(y);
  807.             break;
  808.  
  809.           case Z0:
  810.             if (!SkipMode) MoveDown(z);
  811.             break;
  812.  
  813.           case Z1:
  814.       case Z2:
  815.       case Z3:
  816.       case Z4:
  817.             z = SignExtend(dvifp,command-Z1+1);
  818.             if (!SkipMode) MoveDown(z);
  819.             break;
  820.  
  821.           case FNT1:
  822.       case FNT2:
  823.       case FNT3:
  824.       case FNT4:
  825.             if (!SkipMode) {
  826.                 SetFntNum(NoSignExtend(dvifp,command-FNT1+1));
  827.                 }
  828.             break;
  829.  
  830.           case XXX1:
  831.       case XXX2:
  832.       case XXX3:
  833.       case XXX4:
  834.         { unsigned long len = NoSignExtend(dvifp, command-XXX1+1);
  835.           if (SkipMode) {
  836.             SkipDoSpecial(dvifp, len);
  837.           }
  838.           else {
  839.             DoSpecial(dvifp, len);
  840.           }
  841.         }
  842.         break;
  843. #ifdef OLD_DOSPECIAL
  844.             k = NoSignExtend(dvifp,command-XXX1+1);
  845.             GetBytes(dvifp, ParamStr, k);
  846.             if (!SkipMode) {
  847.           DoSpecial(ParamStr, k);
  848.         }
  849.             break;
  850. #endif
  851.  
  852.           case FNT_DEF1:
  853.       case FNT_DEF2:
  854.       case FNT_DEF3:
  855.       case FNT_DEF4:
  856.             k = NoSignExtend(dvifp, command-FNT_DEF1+1);
  857.             if (PreLoad   || HasBeenRead(k)  )
  858.             {
  859.                 SkipFontDef ();
  860.             }
  861.             else
  862.             {
  863.                 ReadFontDef (k, !SkipMode);
  864.             }
  865.             break;
  866.  
  867.           case PRE:
  868.             Fatal(5, MSG_PRE_IN_FILE);
  869.             break;
  870.  
  871.           case POST:
  872.             if (!leftpage && twopage) {
  873.               // linke Seite wurde erstellt, File ist zu Ende --> linke Seite muss noch gedruckt werden!
  874.               if (PrintPage() == 0) {
  875.                  Pass = 1;        // noch nicht fertig, weitere Durchgaenge folgen (??)
  876.                  // ACHTUNG: Pass ist hier *lokal* und nimmt nur die Werte 0 und 1 an!
  877.                  // Die eigentliche Pass Anzahl wird nur in bitmap.c bestimmt!!!
  878.                  leftpage = TRUE;    // und wieder die linke Seite...
  879.                  DVIfseekSet(dvifp,(long) leftpagep);
  880.          break;
  881.               }
  882.             }
  883.             if (last_form_feed) {
  884.               FormFeed();
  885.             }
  886.         EndHardcopies();
  887.             AbortRun(0);
  888.             break;
  889.  
  890.           case POST_POST:
  891.             Fatal(5, MSG_POST_IN_FILE);
  892.             break;
  893.  
  894.           default:
  895.                 Fatal(5, MSG_UNDEFINED_DVI_COMMAND, command);
  896.             break;
  897.  
  898.          }    /* end switch */
  899.         }    /* end else <= POP */
  900.       }        /* end else font */
  901.      }        /* end else char */
  902.     }         /* while TRUE */
  903.  
  904. }
  905.  
  906.  
  907. #ifndef LONG_ARGS
  908. /*-->PrintHelp*/
  909. /*********************************************************************/
  910. /***************************** PrintHelp *****************************/
  911. /*********************************************************************/
  912.  
  913. static void PrintHelp(void)
  914. {
  915.       Message(NULL);
  916. #ifdef AMIGA
  917.       Warning("(c)Copyright 1990-91, (hes/rbs) , All rights reserved. %s",__DATE__);
  918. #else
  919.       Warning("(c)Copyright 1988-90, (hes/rbs) , All rights reserved. %s",__DATE__);
  920. #endif
  921.       Warning("usage: %s [-?] [-a fontarea] [-b bytes] [-m bytes] [-1] [-2]",g_progname);
  922. #ifdef AMIGA
  923.       Warning("\t\t[-f page] [-t page] [-z dpi] [-o {0|1|2|3}] [-O density");
  924.       Warning("\t\t[-d {0|1|2|3|4|5|6|7|8|9}] [-u] [-g] [-i] [-x] [-r] [-p]");
  925.       Warning("\t\t[-q] [-e bytes] [-l] [-s] [-S] [-h offset] [-v offset]");
  926.       Warning("\t\t[-T] [-> file]");    /* only temporary */
  927.       Warning("\t\tdvifile");
  928. #else
  929.       Warning("\t\t[-f page] [-t page] [-z dpi] [-o {0|1|2|3}] [-d {0|1|2|3|4|5|6|7|8|9}]");
  930.       Warning("\t\t[-u] [-g] [-x] [-r] [-p] [-q] [-l] [-s]");
  931.       Warning("\t\t[-h offset] [-v offset] dvifile");
  932. #endif
  933.       Warning("\t\t  where offset = real number{pt|pc|in|bp|cm|mm|dd|cc}");
  934.       Warning("\t-?   this help,");
  935. #ifdef NAJA
  936.       Warning("\t-c   the authors,");         
  937. #endif
  938.       Warning("\t-a   additional directory for the fontlibs and pk-files,");         
  939.       Warning("\t-b   size of the memory for the fonts (def.: %ld bytes),",FONTMEMSIZE);
  940.       Warning("\t-m   maximum size of the memory for the bitmap (def.: %ld bytes),",MAXBITMAPSIZE);
  941. #ifdef AMIGA
  942.       Warning("\t-e   size of the two printer-buffers (def.: %ld bytes),",BUFFLEN);
  943. #endif
  944.       Warning("\t-f   start at page,");
  945.       Warning("\t-t   stop at page,");
  946.       Warning("\t-1   print only the odd page numbers,");
  947.       Warning("\t-2   print only the even page numbers,");
  948.       Warning("\t-h   horizontal offset (def.: %.2fin),",hoffset_in_fix);
  949.       Warning("\t-v   vertical offset (def.: %.2fin),",voffset_in_fix);
  950. /**   Warning("\t-n   number of copies,"); **/
  951.       Warning("\t-d   printer type, one of the following numbers:");
  952. #ifdef ATARI
  953.       Warning("\t\t%d: Atari Laser Printer SLM 804",SLM804);
  954. #else
  955.       Warning("\t\t%d: generic (preferences) printer",GENERIC_PRINTER);
  956.       Warning("\t\t    (use -O to set your printer resolution/density)");
  957. #endif
  958.       Warning("\t\t%d: NEC P6/P7 (24 pins)",NEC_P6);
  959.       Warning("\t\t%d: NEC P6/P7 (24 pins) (no 'ESC $' skips) ",NEC_P6_NOO);
  960.       Warning("\t\t%d: HP DeskJet",DESKJET);
  961.       Warning("\t\t%d: HP DeskJet (only PCL level III)",DESKJET_NOO);
  962.       Warning("\t\t%d: Epson FX (9 pins)",EPSON_X);
  963.       Warning("\t\t%d: Epson FX (9 pins) (no 'ESC $', with spaces)",EPSON_X_NO);
  964.       Warning("\t\t%d: Epson FX (9 pins) (no 'ESC $', only gfx)",EPSON_X_NOO);
  965.       Warning("\t\t%d: Epson LQ (24 pins)",EPSON_LQ);
  966.       Warning("\t\t%d: Epson LQ (24 pins) (no 'ESC $')",EPSON_LQ_NOO);
  967.       Warning("\t\tdefault is: %d",DEFAULT_PRINTER);
  968.       Warning("\t-o   printing quality (0: high quality, 1: draft),");
  969.       Warning("\t\tonly for HP DeskJet (2: cheap hq, 3: cheap draft),");
  970.       Warning("\t\tdefault is: %d",DEFAULT_QUALITY);
  971. #ifdef AMIGA
  972.       Warning("\t-O   printing quality for the generic printer (density 1-7),");
  973.       Warning("\t\tdefault is: entry of your preferences");
  974. #endif
  975.       Warning("\t-u   print bidirectional (default unidirectional),");
  976.       Warning("\t-g   print in landscape modus (only for HP DeskJet and NEC P6/P7),");
  977. #ifdef AMIGA
  978.       Warning("\t-i   print pages to an IFF-file");
  979. #endif
  980.       Warning("\t-x   no form feed at the end of last page,");
  981.       Warning("\t-r   print in reverse order,");
  982.       Warning("\t-z   resolution (of the bitmap) in dpi (e.g. -z 100 or -z 180/360),");
  983.       Warning("\t\tthis doesn't set the printer resolution!! (use -d option)");
  984.       Warning("\t-p   preload fonts,");
  985.       Warning("\t-q   quiet,");
  986.       Warning("\t-s   print statistics into logfile,");
  987. #ifdef AMIGA
  988.       Warning("\t-S   same as -s, but close the logfile after every line (for debug),");
  989.       Warning("\t-T   turbo-mode for very fast printers (needs under 1.3 puffer.device),");
  990.       Warning("\t\t(The puffer.device is not jet finished!)");
  991.       Warning("\t->   output to file not to the printer,");
  992. #endif
  993.       Warning("\t-l   no logfile.");
  994. }
  995.  
  996. static void not_a_valid_integer(void)
  997. {
  998.    PrintHelp();
  999.    fprintf(stderr,"** Argument is not a valid (long) integer\n"); 
  1000.    AbortRun(5);
  1001. }
  1002.  
  1003. static void offset_to_inch(double *inch, float *offset, char *einh)
  1004. {
  1005.   double temp;
  1006.  
  1007.   /** einh == pt|pc|in|bp|cm|mm|dd|cc  !! einh : word alignment !! **/
  1008.   switch (*((short*)einh)) {
  1009.     case 0x7074:        /* pt */
  1010.     temp = (double)*offset / 72.27;
  1011.     break;
  1012.     case 0x7063:        /* pc */
  1013.     temp = (double)*offset / 6.0225;
  1014.     break;
  1015.     case 0x696e:        /* in */
  1016.     temp = (double)*offset;
  1017.     break;
  1018.     case 0x6270:        /* bp */
  1019.     temp = (double)*offset / 72.0;
  1020.     break;
  1021.     case 0x636d:        /* cm */
  1022.     temp = (double)*offset / 2.5322;
  1023.     break;
  1024.     case 0x6d6d:        /* mm */
  1025.     temp = (double)*offset / 25.322;
  1026.     break;
  1027.     case 0x6464:        /* dd */
  1028.     temp = (double)*offset / 67.3467;
  1029.     break;
  1030.     case 0x6363:        /* cc */
  1031.     temp = (double)*offset / 5.6146;
  1032.     break;
  1033.     default    :
  1034.     PrintHelp();
  1035.     fprintf(stderr,"** Argument '%2s' is not a valid unit\n",einh);
  1036.     AbortRun(5);
  1037.     break;
  1038.   }
  1039.   *inch = temp;
  1040. }
  1041.  
  1042.  
  1043. /*-->DecodeArgs*/
  1044. /*********************************************************************/
  1045. /***************************** DecodeArgs ****************************/
  1046. /*********************************************************************/
  1047.  
  1048. static void
  1049. DecodeArgs(int argc, char *argv[])
  1050. {
  1051.     int argind;             /* argument index for flags              */
  1052.     char curarea[STRSIZE];  /* current file area                     */
  1053.     char curname[STRSIZE];  /* current file name                     */
  1054.     char *tcp, *tcp1;       /* temporary character pointers          */
  1055.     char einh[4];        /* Einheit  !! word alignment !!         */
  1056.     float offset;
  1057.  
  1058.     /* set defaults */
  1059.     hoffset_in_fix = HOFFSET_IN;
  1060.     voffset_in_fix = VOFFSET_IN;
  1061.  
  1062.     if (argc == 1) {
  1063.       PrintHelp();
  1064.       AbortRun(0);
  1065.     }
  1066.  
  1067.     argind = 1;
  1068.     while (argind < argc) {
  1069.         tcp = argv[argind];
  1070.         if (*tcp == '-')
  1071.             switch(*++tcp) {
  1072.  
  1073.         case '?':
  1074.            PrintHelp();
  1075.            AbortRun(0);
  1076.            break;    /* never reached */
  1077.         case 'c':
  1078.             g_authors = 1;
  1079.                break;
  1080.                 case 'a':       /* a selects different pxl font area */
  1081.                     PXLpath = argv[++argind];
  1082.                     break;
  1083.                     
  1084.                 case 'b':
  1085.                     if( ++argind >= argc || 
  1086.                         sscanf(argv[argind], "%ld", &fontmemsize) != 1 )
  1087.                           {
  1088.                not_a_valid_integer();
  1089.                           }
  1090.                     break;
  1091.                     
  1092. #ifdef DEBUG
  1093.                 case 'D':       /* d selects DeBug output */
  1094.                     DeBug = TRUE;
  1095.                     break;
  1096. #endif
  1097.  
  1098.                 case 'f':       /* next arg is starting pagenumber */
  1099.                     if( ++argind >= argc || sscanf(argv[argind], "%d", &FirstPage) != 1 ) {
  1100.                not_a_valid_integer();
  1101.                     }
  1102.                     break;
  1103.  
  1104.         case '1':    /* print only the odd page numbers */
  1105.             print_page_numbers = 1;
  1106.             break;
  1107.  
  1108.         case '2':    /* print only the even page numbers */
  1109.             print_page_numbers = 2;
  1110.             break;
  1111.  
  1112.                 case 'z':       /* next arg is dpi */
  1113.             { char *ptr;
  1114.               int res;
  1115.               
  1116.               if (++argind >= argc) {
  1117.                not_a_valid_integer();
  1118.               }
  1119.               if ((ptr = strchr(argv[argind],'/')) != NULL) {
  1120.                 /* -z hor/vert */
  1121.                 *ptr = '\0';
  1122.                 if (sscanf(argv[argind], "%d", &res) != 1 ) {
  1123.                not_a_valid_integer();
  1124.                         }
  1125.                         /* resolution = bleibt 0 um xx/yy von dd unterscheiden zu koennen! */
  1126.             hconvresolution = res;
  1127.                 if (sscanf(ptr+1, "%d", &res) != 1 ) {
  1128.                not_a_valid_integer();
  1129.                         }
  1130.                         vconvresolution = res;
  1131.               }
  1132.               else {
  1133.                 if (sscanf(argv[argind], "%d", &res) != 1 ) {
  1134.                not_a_valid_integer();
  1135.                         }
  1136.                         resolution = hconvresolution = vconvresolution = res;
  1137.               }
  1138.                     }
  1139.                     break;
  1140.                 
  1141.                 case 'h':       /* next arg is value for horizontal offset */
  1142.                     if( ++argind >= argc || sscanf(argv[argind], "%f%2s", &offset, einh) != 2 ) {
  1143.             PrintHelp();
  1144.             fprintf(stderr,"** Argument is not a valid offset\n"); 
  1145.             AbortRun(5);
  1146.                     }
  1147.                     offset_to_inch(&hoffset_in_fix,&offset,einh);
  1148.                     break;
  1149.                 
  1150.                 case 'l':       /* l prohibits logging of errors */
  1151.                     g_logging = -1;
  1152.                     break;
  1153.  
  1154.                 case 'm':       /* next arg is maxbitmapsize */
  1155.                     if( ++argind >= argc || sscanf(argv[argind], "%ld", &maxbitmapsize) != 1 ) {
  1156.                not_a_valid_integer();
  1157.                     }
  1158.                     if (maxbitmapsize != 0L && maxbitmapsize < MINBITMAPSIZE) {
  1159.               PrintHelp();
  1160.               Warning("** not a valid value, minimum is %ld or 0 for unlimited size.",
  1161.                 MINBITMAPSIZE);
  1162.               AbortRun(5);
  1163.                     }
  1164.                     break;    
  1165.  
  1166. #ifdef NOT_YET_IMPLEMENTED
  1167.                 case 'n':       /* next arg is number of copies to print */
  1168.                     if( ++argind >= argc || sscanf(argv[argind], "%d", &ncopies) != 1 ) {
  1169.                not_a_valid_integer();
  1170.                     }
  1171.                     break;    
  1172. #endif
  1173.  
  1174.                 case 'o':       /* next arg is quality for printer output */
  1175.                     if( ++argind >= argc || sscanf(argv[argind], "%d", &draft) != 1 ) {
  1176.                not_a_valid_integer();
  1177.                     }
  1178.                     if (!(draft == HIGH_Q || draft == DRAFT ||
  1179.               draft == HIGH_Q_CHEAP || draft == DRAFT_CHEAP)) {
  1180.                       fprintf(stderr,"** -o %d is not in [0,3]\n", draft);
  1181.                     }
  1182.                     break;    
  1183.  
  1184.                 case 'O':       /* next arg is quality for printer output */
  1185.                     if( ++argind >= argc || sscanf(argv[argind], "%d", &o_density) != 1 ) {
  1186.                not_a_valid_integer();
  1187.                     }
  1188.                     if (!(o_density>0 && o_density<8)) {
  1189.                       fprintf(stderr,"** -O %d is not in [1,7]\n", o_density);
  1190.                     }
  1191.                     break;    
  1192.  
  1193.                 case 'd':       /* next arg is the printer-type */
  1194.                     if( ++argind >= argc || sscanf(argv[argind], "%d", &printer_type) != 1 ) {
  1195.             not_a_valid_integer();
  1196.                     }
  1197. #ifdef ATARI
  1198.                     if (!(printer_type == NEC_P6 || printer_type == NEC_P6_NOO ||
  1199.               printer_type == DESKJET || printer_type == DESKJET_NOO ||
  1200.               printer_type == EPSON_X || printer_type == EPSON_X_NOO || printer_type == EPSON_X_NO ||
  1201.               printer_type == EPSON_LQ || printer_type == EPSON_LQ_NOO ||
  1202.               printer_type == SLM804 )) {
  1203.                       fprintf(stderr,"** -d %d is not in [0-%d]\n",printer_type,HIGHPRNTYPES);
  1204.                       AbortRun(5);
  1205.                     }
  1206. #else
  1207.                     if (!(printer_type == NEC_P6 || printer_type == NEC_P6_NOO ||
  1208.               printer_type == DESKJET || printer_type == DESKJET_NOO ||
  1209.               printer_type == EPSON_X || printer_type == EPSON_X_NOO || printer_type == EPSON_X_NO ||
  1210.               printer_type == EPSON_LQ || printer_type == EPSON_LQ_NOO ||
  1211.               printer_type == GENERIC_PRINTER)) {
  1212.                       fprintf(stderr,"** -d %d is not in [0-%d]\n",printer_type,HIGHPRNTYPES);
  1213.                       AbortRun(5);
  1214.                     }
  1215. #endif
  1216.                     break;
  1217.  
  1218.                 case 'u':       /* print bidirectional */
  1219.                     unidirect = 0;
  1220.                     break;
  1221.  
  1222.                 case 'p':       /* p enables pre-font loading */
  1223.                     PreLoad = TRUE;
  1224.                     /* Reverse = FALSE; */   /* must then process in forward order */
  1225.                     break;
  1226.  
  1227.                 case 'q':       /* quiet operation */
  1228.                     g_quiet = TRUE;
  1229.                     break;
  1230.  
  1231.                 case 'r':       /* process pages in reverse order */
  1232.                     Reverse = TRUE;
  1233.                     PreLoad = TRUE;
  1234.                     break;
  1235.  
  1236.                 case 's':       /* print statistics */
  1237.                     Stats = 1;
  1238.                     break;
  1239.                      
  1240.                 case 'S':       /* print statistics (and close the file) */
  1241.                     Stats = 2;
  1242.                     break;
  1243.                      
  1244.                 case 'g':       /* print in landscape modus */
  1245.                     landscape = TRUE;
  1246.                     full_page_in_ram = TRUE;
  1247.                     break;
  1248.  
  1249.                 case 'x':       /* no form feed at the last page */
  1250.                     last_form_feed = FALSE;
  1251.                     break;
  1252.                      
  1253.                 case 't':       /* next arg is ending pagenumber */
  1254.                     if( ++argind >= argc || sscanf(argv[argind], "%d", &LastPage) != 1 ) {
  1255.                not_a_valid_integer();
  1256.                     }
  1257.                     break;
  1258.                     
  1259.                 case 'v':       /* next arg is value for vertical offset */
  1260.                    if( ++argind >= argc || sscanf(argv[argind], "%f%2s", &offset, einh) != 2 ) {
  1261.             PrintHelp();
  1262.             fprintf(stderr,"** Argument is not a valid offset\n"); 
  1263.             AbortRun(5);
  1264.                     }
  1265.                     offset_to_inch(&voffset_in_fix,&offset,einh);
  1266.                     break;
  1267.                 
  1268. #ifdef AMIGA                    
  1269.                 case 'e':       /* size of the printer-buffer */
  1270.                     if( ++argind >= argc || sscanf(argv[argind], "%d", &bufflen) != 1 ) {
  1271.                not_a_valid_integer();
  1272.                     }
  1273.                     break;
  1274.                      
  1275.                 case 'i':       /* print to IFF file */
  1276.                     iffprint = TRUE;
  1277.                     full_page_in_ram = TRUE;
  1278.                     break;    
  1279.  
  1280.                 case 'T':       /* TURBO Mode */
  1281.                     turbo_mode = TRUE;
  1282.                     break;
  1283.  
  1284.                 case '>':       /* save output to a file */
  1285.             output_to_file = TRUE;
  1286.             output_file_name = strdup(argv[++argind]);
  1287.                     break;
  1288. #endif
  1289.                     
  1290.                 default:
  1291.             PrintHelp();
  1292.                     fprintf(stderr,"** %c is not a legal flag\n", *tcp);
  1293.             AbortRun(5);
  1294.                 }
  1295.  
  1296.         else  
  1297.          {
  1298.             tcp = strrchr(argv[argind], 
  1299. #ifdef ATARI 
  1300.                                       '\\'    /* split into directory + file name */
  1301. #else
  1302.                                       '/'    /* split into directory + file name */
  1303. #endif
  1304.                         );
  1305.             if (tcp == NULL)  {
  1306.                 curarea[0] = '\0';
  1307.                 tcp = argv[argind];
  1308.                 }
  1309.             else  {
  1310.                 strcpy(curarea, argv[argind]);
  1311.                 curarea[tcp-argv[argind]+1] = '\0';
  1312.                 tcp += 1;
  1313.                 }
  1314.         
  1315.             strcpy(curname, tcp);
  1316.             tcp1 = strrchr(curname, '.');   /* split into file name + extension */
  1317.             if (tcp1 == NULL) {
  1318.                 strcpy(rootname, curname);
  1319.                 strcat(curname, ".dvi");
  1320.                 }
  1321.             else {
  1322.                 *tcp1 = '\0';
  1323.                 strcpy(rootname, curname);
  1324.                 *tcp1 = '.';
  1325.                 }
  1326.         
  1327.             strcpy(filename, curarea);
  1328.             strcat(filename, curname);
  1329.         
  1330.             if ((dvifp=OpenDVI(filename, MaxDviBufSize)) == NULL)  
  1331.              {
  1332.               fprintf(stderr,"%s: can't find DVI file \"%s\"\n\n", g_progname, filename);
  1333.               AbortRun(5);
  1334.              }
  1335.  
  1336.         strcpy(g_Logname, DVIPRINT_LOGFILE);
  1337.  
  1338.             if (g_logging==1)
  1339.               if ((g_logfp = fopen(g_Logname,"w")) == NULL)
  1340.                {
  1341.                 fprintf(stderr,"\n");
  1342.                 fprintf(stderr,"%s: can't open LOG-file \"%s\"\n\n", g_progname, g_Logname);
  1343.                 AbortRun(1);
  1344.                }
  1345.                 
  1346.             break;
  1347.         }
  1348.         argind++;
  1349.         }
  1350.  
  1351.     if (dvifp == NULL)  {
  1352.     fprintf(stderr, "** found no dvifile!\n");
  1353.     AbortRun(5);
  1354.    }
  1355.    if (printer_type != DESKJET && printer_type != DESKJET_NOO && 
  1356.         (draft == HIGH_Q_CHEAP || draft == DRAFT_CHEAP)) {
  1357.     fprintf(stderr, "** cheap modus only allowed for HP DeskJet!\n");
  1358.     AbortRun(5);
  1359.    }
  1360. #if 0
  1361.    if (printer_type == DESKJET_NOO && draft != HIGH_Q) {
  1362.        fprintf(stderr, "** this print modus works only in high quality modus!\n");
  1363.     AbortRun(5);
  1364.    }
  1365. #endif
  1366.    if ((printer_type == EPSON_X || printer_type == EPSON_X_NO || printer_type == EPSON_X_NOO || 
  1367. #ifdef ATARI
  1368.     printer_type == SLM804
  1369. #else
  1370.     printer_type == GENERIC_PRINTER
  1371. #endif
  1372.     ) && landscape) {
  1373.     fprintf(stderr, "** landscape modus don't work with this printer!\n");
  1374.     AbortRun(5);
  1375.    }
  1376. #ifdef AMIGA
  1377.    if (printer_type != GENERIC_PRINTER && o_density != 0) {
  1378.      fprintf(stderr, "*** -O option is only useful with the generic printer (-d 0)!\n");
  1379.    }
  1380.    if (iffprint) {
  1381.      if (turbo_mode) {
  1382.        fprintf(stderr, "*** print to IFF file in \"turbo\" mode is senseless!\n");
  1383.        AbortRun(5);
  1384.      }
  1385. #if 0
  1386.      if (output_to_file) {
  1387.        fprintf(stderr, "*** only one is possible: print to IFF file or redirection to a file!\n");
  1388.        AbortRun(5);
  1389.      }
  1390. #endif
  1391.    }
  1392.    if (output_to_file && turbo_mode) {
  1393.      fprintf(stderr, "*** output to a file in \"turbo\" mode is senseless!\n");
  1394.      AbortRun(5);
  1395.    }
  1396.    if (output_to_file && printer_type == GENERIC_PRINTER) {
  1397.      fprintf(stderr, "*** output to a file with generic-printer isn't possible!\n");
  1398.      fprintf(stderr, "    Use the 'cmd' utility.\n");
  1399.      AbortRun(5);
  1400.    }
  1401.    
  1402. #endif
  1403. }
  1404.  
  1405. #endif /* LONG_ARGS */
  1406.