home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 3 / goldfish_volume_3.bin / files / text / tex / pastex / source / driver / show / showdvi.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-09-30  |  40.7 KB  |  1,419 lines
  1. /*
  2. **    This file generated by localize 2.9 (AmigaDOS 2.1) from showdvi.c
  3. */
  4. /*
  5.  *
  6.  * AUTHOR(s) -- Porting Postscript SUN-Version to ATARI ST
  7.  *  Robert Stabl   -- managing dvi-file, screen driver for ATARI ST
  8.  *  Georg Hessmann -- porting ATARI ST version to AMIGA 1000
  9.  *
  10.  */
  11.  
  12.  
  13. /* Change log:
  14.  *
  15.  * 26-Nov-89 (hes) -- Changelog now in file util/version.h
  16.  *                 -- v0.60
  17.  */
  18.  
  19.  
  20. /**********************************************************************/
  21. /***********************  external definitions  ***********************/
  22. /**********************************************************************/
  23.  
  24. #include "defines.h"
  25.  
  26. #define MAIN        /*    for globals.h        */
  27.  
  28. #ifdef AMIGA
  29. #define LONG_ARGS    /*    For now only the Amiga knows about GetOpt.c */
  30. #endif
  31.  
  32. #include <stdio.h>
  33. #include <ctype.h>
  34. #ifdef ANSI
  35. #  include <string.h>
  36. #  include <stdlib.h>
  37. #endif
  38.  
  39. #include "commands.h"
  40. #include "globals.h"
  41. #include "bitmap.h"
  42. #include "liste.h"
  43. #include "dvihand.h"
  44. #include "flmt.h"
  45. #include "new_font.h"
  46.  
  47. #ifdef AMIGA
  48. #  include <intuition/intuition.h>
  49. #  include <dos/dos.h>
  50. #  include "amscreen.h"
  51. #  include <clib/exec_protos.h>
  52. #  include <clib/dos_protos.h>
  53. #  include <clib/intuition_protos.h>
  54.  
  55. #ifdef AZTEC_C
  56. #  include <functions.h>
  57. #endif
  58.  
  59. #ifdef LATTICE
  60. #  include <pragmas/exec_pragmas.h>
  61. #  include <pragmas/dos_pragmas.h>
  62. #  include <pragmas/intuition_pragmas.h>
  63. #endif
  64. #endif /* AMIGA */
  65.  
  66. #include "showdvi.i"
  67. #include "globals.i"
  68. #include "liste.i"
  69. #include "gadget.i"
  70. #include "dvihand.i"
  71. #include "dospecia.i"
  72. #include "new_font.i"
  73. #include "sbitmap.i"
  74. #include "skippage.i"
  75. #include "search.i"
  76.  
  77. #ifdef ATARI
  78. #  include "atscreen.i"
  79. #  ifdef DISPLAY
  80.      extern int showbars;
  81. #  endif
  82. #endif
  83.  
  84. #ifdef AMIGA
  85. # include "amscreen.i"
  86. # include "fast_cp.i"
  87. #endif
  88.  
  89. #if defined(LONG_ARGS)
  90. #define TEX        /*    for GetOpt.h        */
  91.  
  92. #include "GetOpt.h"
  93. #include "GetOpt.i"
  94. #endif /* LONG_ARGS */
  95.  
  96.  
  97.  
  98. /*
  99.  * Fuer die locale-Library:
  100.  *
  101.  * Hier duerfen *nur* die MSG_#? Nummern eingebunden werden!
  102.  * Achtung:
  103.  * Es muss/sollte 'multiple-include' erlaubt sein!
  104.  */
  105. #include "local.i"
  106.  
  107. #undef  CATCOMP_ARRAY
  108. #undef  CATCOMP_BLOCK
  109. #undef  CATCOMP_STRINGS
  110. #define CATCOMP_NUMBERS
  111. #include "localstr.h"
  112.  
  113.  
  114.  
  115.  
  116. /** lokale Funktionen **/
  117. static int read_file        Args((DVIFILE *fp,
  118.                                       int show));
  119. static int do_command        Args((long k,
  120.                                    DVIFILE *fp,
  121.                                  long cpagep));
  122.  
  123. #if defined(LONG_ARGS)
  124. extern struct Options opt[];    /* forward deklaration wg. PrintHelp nach init_task */
  125. static void PrintHelp        Args((struct Options opt[],
  126.                     short long_hlp));
  127.  
  128. #else /* LONG_ARGS */
  129. static void PrintHelp        Args((void));
  130. static void offset_to_inch    Args((float *inch,
  131.                       float *offset,
  132.                       char *einh));
  133. static void not_a_valid_integer    Args((void));
  134. #endif /* LONG_ARGS */
  135.  
  136.  
  137. #ifdef AZTEC_C
  138. #pragma regcall( /* d0 = */ read_file(a0,d0,a1,d1))
  139. #pragma regcall( /* d0 = */ do_command(d0,a0,a1,d1))
  140. #pragma regcall( offset_to_inch(a0,a1,a2))
  141. #pragma regcall( DecodeArgs(d0,a1))
  142. #endif
  143.  
  144.  
  145.  
  146. #define EQ(a,b) (strcmp(a,b)==0)
  147. #define RESET_FL_PAGE FirstPage = -1000000L; LastPage = 1000000L;
  148.  
  149.  
  150.  
  151. /**********************************************************************/
  152. /*************************  Global Variables  *************************/
  153. /**********************************************************************/
  154.  
  155. /* see globvars.h */
  156.  
  157.  
  158. extern char *_ProgramName;
  159. extern struct WBStartup    *WBenchMsg;
  160.  
  161.  
  162.  
  163. /**********************************************************************/
  164. /*************************  Local Variables  **************************/
  165. /**********************************************************************/
  166.  
  167.  
  168. struct stack_entry {         /* stack entry */
  169.    long hh, h, vv, v, w, x, y, z;     /* what's on stack                    */
  170.  };
  171.  
  172. static struct stack_entry stack[STACKSIZE];   /* stack                */
  173.  
  174. static char ParamStr[STRSIZE];    /* used bye GetBytes()              */
  175.  
  176.  
  177.  
  178. /*********************************************************************/
  179. /**********************  read_file  **********************************/
  180. /*********************************************************************/
  181. static int read_file(DVIFILE *fp, int show)
  182. {
  183.   register int i;          /* temporary variable                       */
  184.   register int ret;        /* return code of this function             */
  185.   int command;             /* current command                          */
  186.   long count[10];          /* the 10 counters at beginning of each page*/
  187.   long cpagep=0L;          /* current page pointer                     */
  188. /*    long h_pptr; */            /* temporary filepointer              */
  189. /*    long h_page; */            /* temporary pagecounter              */
  190.   long k;                  /* temporary variable                       */
  191. /*    int SkipMode = FALSE; */   /* in skip mode flag                  */
  192.  
  193.   int sp;                  /* stack pointer                            */
  194.   long val, val2;          /* temporarys to hold command information   */
  195.   long w;                  /* current horizontal spacing               */
  196.   long x;                  /* current horizontal spacing               */
  197.   long y;                  /* current vertical spacing                 */
  198.   long z;                  /* current vertical spacing                 */
  199.  
  200.  
  201.   OffsetBitmap_X = hoffset;
  202.   OffsetBitmap_Y = voffset;
  203.  
  204.  
  205.   ret = 0;
  206.  
  207.   h = v = w = x = y = z = 0;
  208.   hh = vv = 0;
  209.   sp = 0;
  210.  
  211.  
  212.  if (fp == NULL)
  213.   {
  214.    Message(MSG_NO_FILE_GIVEN);
  215. #ifdef AMIGA
  216.    unset_dvif;
  217. #endif
  218.    while ((k = ShowPage(0)) != KOMM+4L)
  219.     {
  220.      if (k == KOMM+10L)
  221.       { return(10); }
  222.     }
  223.    return(4);
  224.   }
  225. #ifdef AMIGA
  226.  else
  227.   {
  228.    set_dvif;
  229.   }
  230. #endif
  231.  
  232.  if (ret != 10) {
  233.    Message(MSG_BUILD_BITMAP);
  234.  }
  235.  
  236.  while (ret != 3 && ret != 4 && ret != 10)
  237.   {
  238.    command = Read1Byte(fp);
  239.  
  240.    if (command >= SETC_000 && command <= SETC_127) {
  241.      SetChar((long)command, command);
  242.      if (InSearchMode && SearchRect) {
  243.        SearchFoundRect = SearchRect;
  244.      }
  245.    }
  246.    else {
  247.      if (command >= FONT_00 && command <= FONT_63) {
  248.         SetFntNum((long) (command - FONT_00));
  249.      }
  250.      else {
  251.        switch (command) {
  252.          case SET1:
  253.          case SET2:
  254.          case SET3:
  255.          case SET4:
  256.           val = NoSignExtend(fp, command-SET1+1);
  257.           SetChar(val, command);
  258.           if (InSearchMode && SearchRect) {
  259.             SearchFoundRect = SearchRect;
  260.           }
  261.           break;
  262.  
  263.          case SET_RULE:
  264.            val = Read4Byte(fp);
  265.            val2 = Read4Byte(fp);
  266.            SetRule(val, val2, 1);
  267.            break;
  268.  
  269.          case PUT1:
  270.          case PUT2:
  271.          case PUT3:
  272.          case PUT4:
  273.            val = NoSignExtend(fp,command-PUT1+1);
  274.            SetChar(val, command);
  275.            if (InSearchMode && SearchRect) {
  276.              SearchFoundRect = SearchRect;
  277.            }
  278.            break;
  279.  
  280.          case PUT_RULE:
  281.            val = Read4Byte(fp);
  282.            val2 = Read4Byte(fp);
  283.            SetRule(val, val2, 0);
  284.            break;
  285.  
  286.            case NOP:
  287.              break;
  288.  
  289.            case BOP:
  290.               cpagep = DVIftell(fp) - 1;
  291.  
  292.               for (i=0; i<=9; i++)
  293.                {
  294.                 count[i] = Read4Byte(fp);
  295.                }
  296.               ppagep = Read4Byte(fp);
  297.  
  298.               current_page = count[0];  
  299.  
  300.                            /* each new page should be marked */
  301.               if ( take_pptr(current_page, cpagep, 0L, FALSE)==0L )
  302.                {
  303.                 in_list(current_page,cpagep, 0L);
  304.                }
  305.               current_page_phy = get_phy_number(cpagep);
  306.  
  307.               h = v = w = x = y = z = 0;
  308.               hh = vv = 0;
  309.               sp = 0;
  310. #ifdef kdsjfgkfgd
  311.               if( count[0] < FirstPage || count[0] > LastPage )
  312.                {
  313.                 if (SkipMode && Reverse)
  314.                  {
  315.                   DVIfseekSet(fp, ppagep); /* one page back */
  316.                   break;
  317.                  } 
  318.                 if (!SkipMode) 
  319.                  {
  320.                   take_greater(current_page,cpagep,&h_page,&h_pptr);
  321.                   if (h_pptr != (long) NULL)
  322.                    { 
  323.                     DVIfseekSet(fp,h_pptr);
  324.                     current_page = h_page;
  325.                     SkipMode = TRUE;
  326.                     break;
  327.                     /*  Reverse = TRUE; */
  328.                    }
  329.                  }
  330.                 SkipMode = TRUE;
  331.                }
  332.               else
  333.                SkipMode = FALSE;
  334. #endif
  335.               break;
  336.  
  337.            case EOP:
  338.              if (!InSearchMode) MessageStr(NULL);        /* copyright string */
  339.  
  340.              if (InSearchMode) {
  341.                // Seite abschliessen
  342.                BMSearch('\0', 0, 0, 0, 0);
  343.                if (SearchRect) {
  344.                  SearchFoundRect = SearchRect;
  345.                 }
  346.              }
  347.  
  348.              ret = 0;            /* (hes) 20-may-91 (same_page) */
  349.              do {             /* show same page */
  350.                k=ShowPage(ret);
  351.                RESET_FL_PAGE;
  352.                ret = do_command(k,fp,cpagep);
  353.              } while (ret == 1);
  354.              if (ret != 10) {
  355.                if (!InSearchMode) Message(MSG_BUILD_BITMAP);
  356.              }
  357.              break;
  358.  
  359.            case PUSH:
  360.              if (sp >= STACKSIZE) Fatal(5, MSG_STACK_OVER);
  361.              stack[sp].hh = hh;
  362.              stack[sp].vv = vv;
  363.              stack[sp].h  = h;
  364.              stack[sp].v  = v;
  365.              stack[sp].w  = w;
  366.              stack[sp].x  = x;
  367.              stack[sp].y  = y;
  368.              stack[sp].z  = z;
  369.              sp++;
  370.              break;
  371.  
  372.            case POP:
  373.              --sp;
  374.              if (sp < 0) Fatal(5, MSG_STACK_UNDER);
  375.              hh = stack[sp].hh;
  376.              vv = stack[sp].vv;
  377.              h  = stack[sp].h;
  378.              v  = stack[sp].v;
  379.              w  = stack[sp].w;
  380.              x  = stack[sp].x;
  381.              y  = stack[sp].y;
  382.              z  = stack[sp].z;
  383.              break;
  384.  
  385.            case RIGHT1:
  386.            case RIGHT2:
  387.            case RIGHT3:
  388.            case RIGHT4:
  389.              val = SignExtend(fp,command-RIGHT1+1);
  390.              MoveOver(val);
  391.              break;
  392.  
  393.            case W0:
  394.              MoveOver(w);
  395.              break;
  396.  
  397.            case W1:
  398.            case W2:
  399.            case W3:
  400.            case W4:
  401.              w = SignExtend(fp,command-W1+1);
  402.              MoveOver(w);
  403.              break;
  404.  
  405.            case X0:
  406.              MoveOver(x);
  407.              break;
  408.  
  409.            case X1:
  410.            case X2:
  411.            case X3:
  412.            case X4:
  413.              x = SignExtend(fp,command-X1+1);
  414.              MoveOver(x);
  415.              break;
  416.  
  417.            case DOWN1:
  418.            case DOWN2:
  419.            case DOWN3:
  420.            case DOWN4:
  421.              val = SignExtend(fp,command-DOWN1+1);
  422.              MoveDown(val);
  423.              break;
  424.  
  425.            case Y0:
  426.              MoveDown(y);
  427.              break;
  428.  
  429.            case Y1:
  430.            case Y2:
  431.            case Y3:
  432.            case Y4:
  433.              y = SignExtend(fp,command-Y1+1);
  434.              MoveDown(y);
  435.              break;
  436.  
  437.            case Z0:
  438.              MoveDown(z);
  439.              break;
  440.  
  441.            case Z1:
  442.            case Z2:
  443.            case Z3:
  444.            case Z4:
  445.              z = SignExtend(fp,command-Z1+1);
  446.              MoveDown(z);
  447.              break;
  448.  
  449.            case FNT1:
  450.            case FNT2:
  451.            case FNT3:
  452.            case FNT4:
  453.              SetFntNum(NoSignExtend(fp,command-FNT1+1));
  454.              break;
  455.  
  456.            case XXX1:
  457.            case XXX2:
  458.            case XXX3:
  459.            case XXX4:
  460.         { unsigned long len = NoSignExtend(fp, command-XXX1+1);
  461.           DoSpecial(fp, len);
  462.         }
  463.         break;
  464. #ifdef OLD_DOSPECIAL
  465. /*
  466.              if (!SkipMode)
  467. */
  468.               {
  469.                k = NoSignExtend(fp,command-XXX1+1);
  470.                GetBytes(fp, ParamStr, k);
  471.                DoSpecial(ParamStr, k);
  472.               }
  473.              break;
  474. #endif
  475.  
  476.            case FNT_DEF1:
  477.            case FNT_DEF2:
  478.            case FNT_DEF3:
  479.            case FNT_DEF4:
  480.              k = NoSignExtend(fp, command-FNT_DEF1+1);
  481.              if (PreLoad   || HasBeenRead(k)  )
  482.               {
  483.                SkipFontDef ();
  484.               }
  485.              else
  486.               {
  487.                ReadFontDef (k, TRUE);
  488.               }
  489.              break;
  490.  
  491.            case PRE:
  492.              Fatal(5, MSG_PRE_IN_FILE);
  493.              break;
  494.  
  495.            case POST:
  496.              { long h_pptr;
  497.  
  498.                take_last(¤t_page,&h_pptr);
  499.                current_page_phy = get_phy_number(h_pptr);
  500.                current_page = get_page_number(current_page_phy);    // _phy added (hes) 20.07.94
  501.                DVIfseekSet(fp,h_pptr);
  502.              }
  503.              Warning(MSG_POST_IN_FILE);
  504.              break;
  505.  
  506.            case POST_POST:
  507.              Fatal(5, MSG_POST_POST);
  508.              break;
  509.  
  510.            default:
  511.                 Warning(MSG_DVI_FILE_ERROR);
  512.                 corrupt = FALSE;        /* zuruecksetzen, da nun das ganze File bekannt ist */
  513.                 max_page_number = current_page;
  514.                 Set_PgPotGadRange();
  515.                 DVIfseekSet(fp, cpagep-1L);
  516.                 ret = 0;            /* (hes) 30-may-91 */
  517.                 do { /* show same page */
  518.                   k=ShowPage(ret);        /* ret: damit ich weiss, ob ich wieder an der selben Seite bin */
  519.                   RESET_FL_PAGE;
  520.                   ret = do_command(k,fp,cpagep);
  521.                 } while (ret == 1);
  522.   
  523.                 if (ret != 10) {
  524.                   if (!InSearchMode) Message(MSG_BUILD_BITMAP);
  525.                 }
  526.              break;
  527.          }    /* switch */
  528.      }        /* else font */
  529.    }        /* else char */
  530.   }        /* end while */
  531.  return (ret);
  532. }
  533.  
  534. /*********************************************************************/
  535. /**************************** do_command *****************************/
  536. /*********************************************************************/
  537. static int do_command(long k, DVIFILE *fp,long cpagep)
  538. {
  539.   register int ret;
  540.   register int hk;
  541.   long h_pptr;                    /* temporary filepointer            */
  542.   long last_page_dvifile;         /* number of last page in dvi file  */
  543.   long first_page_dvifile;        /* number of first page in dvi file */
  544.   long cur_pag;
  545.   
  546. /***
  547.   if (k == 0) {
  548.     return 1;        / * do nothing * /
  549.   }
  550. ***/
  551.  
  552.   take_last (&last_page_dvifile, &h_pptr);
  553.   take_first(&first_page_dvifile,&h_pptr);
  554.  
  555.   ret = 0;  /* *  ret ==  0 => ok,                * 
  556.                *  ret ==  1 => show page without any changes,    *
  557.                *  ret ==  3 => load same dvi file again,    *
  558.                *  ret ==  4 => load new dvi file,        *
  559.                *  ret ==  6 => search in progress               *
  560.                *  ret == 10 => terminate program.               *        */
  561.  
  562.   if (k>= KOMM-3L)
  563.    {
  564.     hk = (int)(k-KOMM);
  565.     switch(hk)
  566.      {
  567.      case 10: /* terminate program */
  568.              { 
  569.               ret = 10;
  570.               break;
  571.              }
  572.  
  573.      case 6: /* start search */
  574.              take_greater(current_page, cpagep, &cur_pag, &h_pptr);
  575.              if (h_pptr != 0L) {                    // zyklisch suchen
  576.                 DVIfseekSet(fp, h_pptr);        /* da samma scho (meistens) */
  577.                 current_page_phy = get_phy_number(h_pptr);
  578.                 current_page = get_page_number(current_page_phy);
  579.                 //ClearBitmap();
  580.              } 
  581.              else {
  582.                 take_first(¤t_page,&h_pptr);
  583.                 current_page_phy = get_phy_number(h_pptr);
  584.                 current_page = get_page_number(current_page_phy);
  585.                 DVIfseekSet(fp,h_pptr);
  586.                 //ClearBitmap();
  587.              }
  588.              ret = 6;
  589.              break;
  590.              
  591.      case 7: /* end search...auf die Seite springen, bei der die Suche gestartet wurde */
  592.              /*              sprich alle Variablen zuruecksetzen, die geaendert wurden */
  593.              
  594.              // auf phy Seite springen
  595.              h_pptr = take_pptr(SearchFoundPage, 0L, SearchFoundPage, TRUE);
  596.              if (h_pptr) {
  597.                current_page_phy = get_phy_number(h_pptr);
  598.                current_page = get_page_number(current_page_phy);
  599.                DVIfseekSet(fp,h_pptr);
  600.                //ClearBitmap(); (nur wenn nicht selbe Seite)
  601.              }
  602.  
  603.              if (SearchFoundPage == SearchStartPage) {
  604.                ret = 1;        // selbe Seite ohne Aenderungen
  605.              }
  606.              else {
  607.                ClearBitmap();
  608.                ret = 0;
  609.              }
  610.              
  611.              break;
  612.  
  613.      case 3: /* work with new dvi file (load again) */
  614.      case 4: /* work with new dvi file */
  615.              { 
  616.               corrupt = FALSE;
  617.               free_liste();  /* deallocate page pointers */
  618.               resetfont();       /* delete font numbers      */
  619.               ret = hk;
  620.               break;
  621.              }
  622.  
  623.      case -2: /* go to begin of dvi file */ 
  624.              { 
  625.               if (current_page==get_page_number(first_page_dvifile)) 
  626.                {
  627.                 Message(MSG_ALREADY_FIRST); 
  628.                 beep();
  629.                 ret = 1;
  630.                }
  631.               else 
  632.                {
  633.                 take_first(¤t_page,&h_pptr);
  634.                 current_page_phy = get_phy_number(h_pptr);
  635.                 current_page = get_page_number(current_page_phy);
  636.                 DVIfseekSet(fp,h_pptr);
  637.                 ClearBitmap();
  638.                } 
  639.               break;
  640.              }
  641.  
  642.      case 2: /* go to end of dvi file */
  643.              {
  644.           if (corrupt) {
  645.                 long cp = cpagep;
  646.                 int endoffile = FALSE;
  647.  
  648.                 /* fseek(fp,cpagep,0); */    /* first to current page */
  649.                 while (!endoffile) {
  650.                   endoffile = skippage(fp, &cp, &ppagep, ¤t_page, ¤t_page_phy);
  651.                   if (!endoffile) {
  652.                     cpagep = cp;
  653.                   }
  654.                 }
  655.             DVIfseekSet(fp,cpagep);
  656.                 ClearBitmap();
  657.           }
  658.           else {
  659.                 if (current_page==get_page_number(last_page_dvifile))
  660.                  {
  661.                   Message(MSG_ALREADY_LAST); 
  662.                   beep();
  663.                   ret = 1;
  664.                  }
  665.                 else
  666.                  {
  667.                   take_last(¤t_page,&h_pptr);
  668.                   current_page_phy = get_phy_number(h_pptr);
  669.                   current_page = get_page_number(current_page_phy);
  670.                   DVIfseekSet(fp,h_pptr);
  671.                   ClearBitmap();
  672.                  }
  673.               }
  674.               break;
  675.              }
  676.  
  677.      case -1: /* one page back */
  678.              {
  679.                 take_less(current_page, cpagep, &cur_pag, &h_pptr);
  680.                 if (h_pptr != 0L)
  681.                  {
  682.                   DVIfseekSet(fp, h_pptr);
  683.                   current_page_phy = get_phy_number(h_pptr);
  684.                   current_page = get_page_number(current_page_phy);
  685.                   ClearBitmap();
  686.                  }
  687.                 else
  688.                  {
  689.                   Message(MSG_ALREADY_FIRST);
  690.                   beep();
  691.                   DVIfseekSet(fp, cpagep);
  692.                   ret = 1;
  693.                  }
  694.               break;
  695.              }
  696.  
  697.      case 1: /* one page forward */
  698.              {
  699.               if (!corrupt) {
  700.                 take_greater(current_page, cpagep, &cur_pag, &h_pptr);
  701.                 if (h_pptr != 0L)
  702.                  {
  703.                   /* geht nicht zur physikalisch naechsten, sondern zur *
  704.                    * logisch (Seitennummer) naechsten Seite.        */
  705.                   DVIfseekSet(fp, h_pptr);        /* da samma scho (meistens) */
  706.                   current_page_phy = get_phy_number(h_pptr);
  707.                   current_page = get_page_number(current_page_phy);
  708.                   ClearBitmap();
  709.                  }
  710.                 else
  711.                  {
  712.                   Message(MSG_ALREADY_LAST);
  713.                   beep();
  714.                   DVIfseekSet(fp, cpagep);
  715.                   ret = 1;
  716.                  }
  717.               }
  718.               else {
  719.                 ClearBitmap();
  720.               }
  721.               break;
  722.              }
  723.  
  724.        default:
  725.              break;
  726.       }
  727.      } /* end switch */
  728.     else     /* then it is a pagenumber */
  729.      {
  730.       if (corrupt) {
  731.         h_pptr = take_pptr(k, 0L, k, use_phy_number);
  732.         if (h_pptr==0L) {        /* page not marked */ 
  733.           int endoffile = FALSE;
  734.  
  735.           /* fseek(fp,cpagep,0); */    /* first to current page */
  736.           while (!endoffile && get_page_number(current_page_phy) != k) {
  737.             endoffile = skippage(fp, &cpagep, &ppagep, ¤t_page, ¤t_page_phy);
  738.           }
  739.           if (endoffile) {
  740.         Warning(MSG_PAGE_NOT_FOUND,k);
  741.           }
  742.       DVIfseekSet(fp,cpagep);
  743.         }
  744.         else {         /* page is marked */
  745.           current_page_phy = get_phy_number(h_pptr);
  746.           current_page = get_page_number(current_page_phy);
  747.           DVIfseekSet(fp,h_pptr);
  748.         }
  749.         ClearBitmap();
  750.       }
  751.       else {
  752.         k = (k < first_page_dvifile) ? first_page_dvifile : k;
  753.         k = (k > last_page_dvifile ) ? last_page_dvifile  : k;
  754.         if (k != ((use_phy_number) ? current_page_phy : get_page_number(current_page_phy)))
  755.          {
  756.           h_pptr = take_pptr(k, 0L, k, use_phy_number);
  757.           if (h_pptr==0L)         /* page not marked */ 
  758.            { 
  759.             Message(MSG_PAGE_NOT_FOUND, k);
  760.             beep();
  761.             ret = 1;        /* page k dosn't exists -> same page */
  762. #ifdef uralt
  763.             FirstPage = k;  /* go to page k */
  764.             LastPage = k;
  765.             DVIfseekSet(fp,cpagep); /* first to current page */
  766.             Reverse = (get_page_number(current_page)>k);
  767. #endif
  768.            }
  769.           else  /* page is marked */
  770.            { 
  771.             current_page_phy = get_phy_number(h_pptr);
  772.             current_page = get_page_number(current_page_phy);
  773.             DVIfseekSet(fp,h_pptr);
  774.             ClearBitmap();
  775.            }
  776.          }
  777.         else
  778.          {
  779.           ret = 1;
  780.          }
  781.        }
  782.      }
  783.   return (ret);
  784. }
  785.  
  786.  
  787. /**********************************************************************/
  788. /*******************************  main  *******************************/
  789. /**********************************************************************/
  790.  
  791. void main(int argc, char *argv[])
  792.  
  793. {
  794.   int i;                       /* command parameter; loop index        */
  795.   long h_pptr;                    /* temporary filepointer                */
  796.   long tpagep;                  /* temporary page pointer          */
  797.   long dummy;                     /* temporary variable                   */
  798.   int return_from_display;        /* what shall we do -- 10 : terminate   */
  799.                                   /*                  --  3 : change file */
  800.                                   /*                  -- -1 : first start */
  801.   int show = 1;                   /* output to screen or printer (unused) */
  802.   long l1;
  803.  
  804.     g_Logname = SHOWDVI_LOGFILE;
  805.     g_logging = -1;    /* disable it until DecodeArgs()    */
  806.  
  807.     bytesperlong = sizeof (long);
  808.     /* bitsperlong = 8 * bytesperlong; */
  809.     
  810.     landscape = FALSE;
  811.     twopage   = FALSE;
  812.     leftpage  = FALSE;
  813.     
  814.     start_specialhost = FALSE;
  815.  
  816.     resolution = RESOLUTION;
  817.     hconvresolution = hconvRESOLUTION;
  818.     vconvresolution = vconvRESOLUTION;
  819.  
  820.     MaxDviBufSize = 20*1024;    // bis zu 20k grosse DVI Files sollen komplett geladen werden
  821.  
  822.     filename[0] = '\0';
  823.     dirname[0] = '\0';
  824.  
  825.     hoffset_in_fix  = HOFFSET_IN;        /* inch */
  826.     hoffset_is_true = TRUE;            /* true inch? */
  827.     voffset_in_fix  = VOFFSET_IN;        /* inch */
  828.     voffset_is_true = TRUE;            /* true inch? */
  829.     
  830.     // -13.13: Zeigt GetOpt(), daß nichts definiert wurde
  831.     user_paper_height_in = -13.13;
  832.     user_paper_width_in  = -13.13;
  833.     
  834.     mark_fonts = FALSE;
  835.     
  836.     InSearchMode = FALSE;
  837.     SearchRect = NULL;
  838.     SearchFoundRect = NULL;
  839.  
  840.     {
  841.       struct Options * o;
  842.       o = GetOneOpt(&hoffset_in_fix, opt);
  843.       if (o) o->special = hoffset_is_true;
  844.       o = GetOneOpt(&voffset_in_fix, opt);
  845.       if (o) o->special = voffset_is_true;
  846.     }
  847.     
  848.     fontmemsize = FONTMEMSIZE;
  849.     RESET_FL_PAGE;    /* oder 0 ? */
  850.  
  851.     Enable_Abort = 1;
  852.     task_priority = 0;
  853.  
  854.     if (argc == 0) {
  855.       set_wbench;
  856.       g_progname = _ProgramName;
  857.     }
  858.     else {
  859.       unset_wbench;
  860.       g_progname = argv[0];
  861.     }
  862.  
  863.     if (init_task_name(argc, argv) == 1) {    /* set task-name and test for another showdvi */
  864.       PrintHelp(opt, TRUE);
  865.       AbortRun(0);
  866.     }
  867.     Init_ShowDVI();                /* initialisiert diverse Variablen */
  868.  
  869.     if (argc == 0) {
  870.       WBenchMsg = (struct WBStartup *)argv;
  871.     }
  872.     else {
  873.       WBenchMsg = NULL;
  874.     }
  875.  
  876.     DecodeArgs( argc, argv );
  877.  
  878. #  ifdef AMIGA
  879.  
  880.     SetShowDVIVars(filename);
  881.  
  882.     old_task_priority = (unsigned long)SetTaskPri(FindTask(NULL), task_priority);
  883.     Open_ShowDVI(dvifp != NULL);        /* oeffnet screen .... */
  884. #  endif
  885. #  ifdef ATARI
  886.     use_phy_number = FALSE;    /* use logical numbers by default */
  887.     init_screen();        /* dito */
  888. #  endif
  889.  
  890.     MessageStr(NULL);    /* Copyright-String */
  891.     LoggingStr(NULL);
  892.  
  893. #ifdef ATARI
  894.     LogTOSVersion();
  895. #endif
  896.  
  897. #if defined(BETACOPYRIGHT)
  898.     PrintBetaCopy();
  899. #endif
  900.  
  901.     current_page = 0L          /* FirstPage */;
  902.     current_page_phy = 0L;
  903.     return_from_display = -1;    /* first Start */
  904.  
  905.     init_fontmt (1);        /* we are ShowDVI */
  906.     /* ********* Main-Loop: *********** */
  907.     while (return_from_display != 10 )
  908.      {
  909.       if (!init_liste()) {
  910.         Fatal(10,MSG_NO_MEM);
  911.       }
  912.  
  913. #if 0 /* unnoetig, wird entweder in ReadPostAmble() oder weiter unten gesetzt */
  914. /* aber wenn dvifp = NULL ? */
  915.       hoffset = (int)((float)hconvresolution * hoffset_in_fix);/*hes: offset_in noch nicht definiert!*/
  916.       voffset = (int)((float)vconvresolution * voffset_in_fix);/*hes: * mag / 1000 ? */
  917. #endif
  918.  
  919.       if (abs(user_paper_width_in+13.13) > 0.01) {
  920.         paper_width = (long)((float)hconvresolution * user_paper_width_in);
  921.       }
  922.       else {
  923.         paper_width  = hconvresolution * HSIZE;        /* for !preload */
  924.       }                            /*   default    */
  925.                             /*    size      */
  926.       if (abs(user_paper_height_in+13.13) > 0.01) {
  927.         paper_height = (long)((float)vconvresolution * user_paper_height_in);
  928.       }
  929.       else {
  930.         paper_height = vconvresolution * VSIZE;
  931.       }
  932.  
  933.       if (dvifp != NULL)
  934.        {
  935.         if ((i = (int) Read1Byte(dvifp)) != PRE)
  936.          {
  937.           Fatal(5,MSG_MISSING_PRE);
  938.          }
  939.  
  940.         i = SignExtend(dvifp, 1);
  941.         if (i != DVIFORMAT)
  942.          {
  943.           Fatal(5,MSG_WRONG_DVI_TYPE,i, DVIFORMAT);
  944.          }
  945.  
  946. /* it is important that these be the very first things output !!! */
  947.  
  948.     LoggingStr("");    /* blank line */
  949.     Logging(MSG_LOADING_DVI, filename);
  950.     Message(MSG_LOADING_DVI, filename);
  951.  
  952.         tpagep = DVIftell(dvifp);
  953.  
  954.         if (ReadPostAmble(PreLoad))
  955.          {
  956.         Warning(MSG_INCOMPLETE_DVI_PRELOAD);
  957.         PreLoad = FALSE;
  958.         corrupt = TRUE;
  959.         DVIfseekSet(dvifp, tpagep);
  960.         num = NoSignExtend(dvifp, 4);
  961.         den = NoSignExtend(dvifp, 4);
  962.         mag = NoSignExtend(dvifp, 4);
  963.             hconv = DoConv(num, den, hconvresolution);
  964.             vconv = DoConv(num, den, vconvresolution);
  965.  
  966.         /* man muss beim h/v-Offset die Magnification beruecksichtigen! */       
  967.         hoffset_in = hoffset_in_fix * mag / 1000;
  968.         voffset_in = voffset_in_fix * mag / 1000;
  969.  
  970.         hoffset = (int)((float)hconvresolution * hoffset_in);
  971.         voffset = (int)((float)vconvresolution * voffset_in);
  972.  
  973.         alpha = (((double)den / 7227.0) / 0x100000) * (25400000.0 / (double) num) ;
  974.         /** fsizetol = 1 + (long)(resolution/(72270.0 * hconv)) ; **/
  975.  
  976.          }
  977.         else
  978.          {
  979.           GetFontDef(PreLoad);
  980.           DVIfseekSet(dvifp, 14L);
  981.          }
  982.         dummy = Read1Byte(dvifp);
  983.         GetBytes(dvifp, ParamStr, dummy);
  984.  
  985.         h_pptr = (long) DVIftell(dvifp);
  986.  
  987.         l1 = ppagep;
  988.         if (!corrupt)
  989.          {
  990.           dummy = 0L;        /* physical page number */
  991.           Message(MSG_SCAN_DVI_FILE);
  992.                            /* mark all pages */ 
  993.           do
  994.            {
  995.             DVIfseekSet(dvifp, l1);
  996.             if (Read1Byte(dvifp) != BOP)
  997.              {
  998.               Warning(MSG_DVI_FILE_ERROR);
  999.               break;
  1000. /*        aber das File ist doch !corrupt ?????
  1001.               Fatal(5,"Error occured within DVI file!");
  1002. */
  1003.              }
  1004.             else
  1005.              {
  1006.               dummy++;
  1007.               in_list(Read4Byte(dvifp), l1, dummy);
  1008.               GetBytes(dvifp, ParamStr, 36L);
  1009.               l1 = Read4Byte(dvifp);
  1010.              }
  1011.            }
  1012.           while (l1 != -1L);
  1013.           max_page_number = dummy;
  1014.           Set_PgPotGadRange();
  1015.           calc_phy_nr(dummy);    /* reverse the phy number */
  1016. #if defined(DEBUG)
  1017.           if (Stats) {
  1018.             print_list();
  1019.           }
  1020. #endif
  1021.          
  1022.           DVIfseekSet(dvifp, h_pptr);
  1023.          }
  1024.        }
  1025.  
  1026.       InitBitmap(paper_height, paper_width);
  1027.       MessageStr(NULL);    /* print Copyright-String */
  1028.  
  1029. #if 0 /* das war meine Version (hes)
  1030.       if (hconvresolution <= 599)    hmaxdrift = hconvresolution / 100 ;
  1031.       else if (hconvresolution < 1199)    hmaxdrift = hconvresolution / 200 + 3 ;
  1032.       else                hmaxdrift = hconvresolution / 400 + 6 ;
  1033.  
  1034.       if (vconvresolution <= 599)    vmaxdrift = vconvresolution / 100 ;
  1035.       else if (vconvresolution < 1199)    vmaxdrift = vconvresolution / 200 + 3 ;
  1036.       else                vmaxdrift = vconvresolution / 400 + 6 ;
  1037.  
  1038.       thinspace      = (long)(0.025*hconvresolution*hconv) ; /* 0.025 inches */
  1039.       vertsmallspace = (long)(0.025*vconvresolution*vconv) ; /* 0.025 inches */
  1040.       backspace      = -(long)(0.124533 * hconvresolution * hconv);
  1041.         /* vertspace  =approx.  0.8 * 10pt =  0.110696 inches */
  1042. #else    /* das ist Bernd's Version */
  1043.       if (hconvresolution < 100)    hmaxdrift = 0;
  1044.       else if (hconvresolution < 200)    hmaxdrift = 1;
  1045.       else                hmaxdrift = 2;
  1046.  
  1047.       if (vconvresolution < 100)    vmaxdrift = 0;
  1048.       else if (vconvresolution < 200)    vmaxdrift = 1;
  1049.       else                vmaxdrift = 2;
  1050.  
  1051.       /* Setup initial spaces for 10pt Font: */
  1052.         /* wordspace  =approx.  0.2 * 10pt =  0.027674 inches */
  1053.       thinspace      =  (long)(0.027674 * hconvresolution * hconv);
  1054.         /* -backspace =approx. -0.9 * 10pt = -0.124533 inches */
  1055.       backspace      = -(long)(0.124533 * hconvresolution * hconv);
  1056.         /* vertspace  =approx.  0.8 * 10pt =  0.110696 inches */
  1057.       vertsmallspace =  (long)(0.110696 * vconvresolution * vconv);
  1058. #endif
  1059.  
  1060. #ifdef PROTOCOL
  1061.       protocol ();
  1062. #endif
  1063.  
  1064.       /* go to first page (hes) */
  1065.       if (return_from_display == -1 && FirstPage != -1000000L) {
  1066.         long k = FirstPage;
  1067.         long h_pptr;                    /* temporary filepointer            */
  1068.         long last_page_dvifile;         /* number of last page in dvi file  */
  1069.         long first_page_dvifile;        /* number of first page in dvi file */
  1070.  
  1071.         take_last (&last_page_dvifile, &h_pptr);
  1072.         take_first(&first_page_dvifile,&h_pptr);
  1073.         k = (k < first_page_dvifile) ? first_page_dvifile : k;
  1074.         k = (k > last_page_dvifile ) ? last_page_dvifile  : k;
  1075.         h_pptr = take_pptr(k, 0L, k, use_phy_number);
  1076.         if (h_pptr!=0L) {        /* page marked */ 
  1077.           DVIfseekSet(dvifp, h_pptr);
  1078.           current_page_phy = get_phy_number(h_pptr);
  1079.           current_page = get_page_number(current_page_phy);
  1080.         }
  1081.       }
  1082.  
  1083.       /* holt den Pointer auf die 'current page' */
  1084.       if (return_from_display == 3) {    /* load file again */
  1085.         if (corrupt) {
  1086.           long cp;
  1087.           long current = current_page-1;
  1088.           int endoffile = FALSE;
  1089.  
  1090.           /* fseek(dvifp,cpagep,0); */    /* first to current page */
  1091.           while (!endoffile && current_page != current) {
  1092.             endoffile = skippage(dvifp, &cp, &ppagep, ¤t, ¤t_page_phy);
  1093.           }
  1094.           current_page = current;
  1095.           current_page_phy = get_phy_number(cp);
  1096.       DVIfseekSet(dvifp,cp);
  1097.         }
  1098.         else {
  1099.           long h_pptr;                    /* temporary filepointer            */
  1100.           long last_page_dvifile;         /* number of last page in dvi file  */
  1101.           long first_page_dvifile;        /* number of first page in dvi file */
  1102.  
  1103.           take_last (&last_page_dvifile, &h_pptr);
  1104.           take_first(&first_page_dvifile,&h_pptr);
  1105.  
  1106.       if (use_phy_number) {
  1107.         current_page_phy = (current_page_phy < first_page_dvifile)
  1108.                 ? first_page_dvifile : current_page_phy;
  1109.         current_page_phy = (current_page_phy > last_page_dvifile)
  1110.                 ? last_page_dvifile : current_page_phy;
  1111.         current_page = get_log_page_number(current_page_phy);
  1112.         h_pptr = take_pptr(0L, 0L, current_page_phy, TRUE);
  1113.         if (h_pptr == NULL) {
  1114.           take_first(&first_page_dvifile,&h_pptr);
  1115.           current_page = get_log_page_number(first_page_dvifile);
  1116.           current_page_phy = first_page_dvifile;
  1117.         }
  1118.       }
  1119.       else {
  1120.         current_page = (current_page < first_page_dvifile)
  1121.                 ? first_page_dvifile : current_page;
  1122.         current_page = (current_page > last_page_dvifile)
  1123.                 ? last_page_dvifile : current_page;
  1124.         h_pptr = take_pptr(current_page, 0L, 0L, FALSE);
  1125.         if (h_pptr == NULL) {
  1126.           take_first(&first_page_dvifile,&h_pptr);
  1127.           current_page_phy = get_phy_number(h_pptr);
  1128.           current_page = first_page_dvifile;
  1129.         }
  1130.       }
  1131.       DVIfseekSet(dvifp, h_pptr);
  1132.         }
  1133.       }
  1134.  
  1135.       /* ****** Show the file. ******* */
  1136.       return_from_display = read_file(dvifp, show);
  1137.  
  1138.      }  /* ***** end Main-loop ***** */
  1139.     AbortRun(0);
  1140. }
  1141.  
  1142.  
  1143.  
  1144. /*==========================================================================*/
  1145.  
  1146.  
  1147. static long help;
  1148. static char *filenameptr = NULL;
  1149. static long o_nlogging;
  1150. static char *g_paper     = NULL;
  1151.  
  1152.  
  1153. START_PARAM(opt)
  1154.   /* req?      key-name      abbrev type         variable       help-txt */
  1155.   NOREQ_PARAM ("HELP",        "?",  OPT_HELP,    &help,            MSG_OPTIONS_HELP, 0)
  1156.   NOREQ_PARAM ("FONTDir",     "-a", OPT_STRING,  &PXLpath,        MSG_OPTIONS_FONTDIR, 0)
  1157.   NOREQ_PARAM ("FONTMem",     "-b", OPT_LONG,    &fontmemsize,        MSG_OPTIONS_FONTMEM, 0)
  1158.   NOREQ_PARAM ("From",        "-f", OPT_LONG,    &FirstPage,        MSG_OPTIONS_FROM, 0)
  1159.   NOREQ_PARAM ("HOFFset",     "-h", OPT_TEX_DIM, &hoffset_in_fix,   MSG_OPTIONS_HOFFSET,MSG_OPTIONS_HVOFFSET2)
  1160.   NOREQ_PARAM ("VOFFset",     "-v", OPT_TEX_DIM, &voffset_in_fix,   MSG_OPTIONS_VOFFSET,MSG_OPTIONS_HVOFFSET2)
  1161.   NOREQ_PARAM ("WIDTH",       NULL, OPT_TEX_DIM, &user_paper_width_in,  MSG_OPTIONS_WIDTH, 0)
  1162.   NOREQ_PARAM ("HEIGHT",      NULL, OPT_TEX_DIM, &user_paper_height_in, MSG_OPTIONS_HEIGHT, 0)
  1163.   NOREQ_PARAM ("PAPERSIZE",   NULL, OPT_STRING,  &g_paper,          MSG_OPTIONS_PAPER, MSG_OPTIONS_PAPER2)
  1164.   NOREQ_PARAM ("PUBscreen",   NULL, OPT_STRING,  &ArgPubname,       MSG_OPTIONS_PUBSCREEN, 0)
  1165.   NOREQ_PARAM ("PREload",     "-p", OPT_BOOLEAN, &PreLoad,        MSG_OPTIONS_PRELOAD, 0)
  1166.   NOREQ_PARAM ("RESolution",  "-z", OPT_LONG,    &resolution,        MSG_OPTIONS_RESOLUTION, 0)
  1167.   NOREQ_PARAM ("MARK",        NULL, OPT_BOOLEAN, &mark_fonts,       MSG_OPTIONS_MARK, 0)
  1168.   NOREQ_PARAM ("STATistic",   "-s", OPT_BOOLEAN, &Stats,        MSG_OPTIONS_STATISTIC, 0)
  1169.   NOREQ_PARAM ("DEBUGStat",   "-S", OPT_BOOLEAN, &DebugStats,        MSG_OPTIONS_DEBUGSTAT, 0)
  1170.   NOREQ_PARAM ("LOGName",     NULL, OPT_STRING,  &g_Logname,        MSG_OPTIONS_LOGNAME, 0)
  1171.   NOREQ_PARAM ("NOLog",       "-l", OPT_BOOLEAN, &o_nlogging,        MSG_OPTIONS_NOLOG, 0)
  1172.   NOREQ_PARAM ("PRIOrity",    NULL, OPT_LONG,    &task_priority,    MSG_OPTIONS_PRIORITY, 0)
  1173.   NOREQ_PARAM ("SPECIALhost", NULL, OPT_BOOLEAN, &start_specialhost,MSG_OPTIONS_SPECIALHOST, 0)
  1174.   HIDDEN_PARAM("PRINTAUthor", "-c", OPT_BOOLEAN, &g_authors,        MSG_OPTIONS_PRINTAUTHOR, 0)
  1175.   NOREQ_PARAM (NULL,          NULL, OPT_OPTIONSTRING, &filenameptr, MSG_OPTIONS_DVIFILE, 0)
  1176. END_PARAM
  1177.  
  1178.  
  1179. /*-->DecodeArgs*/
  1180. /*********************************************************************/
  1181. /***************************** DecodeArgs ****************************/
  1182. /*********************************************************************/
  1183.  
  1184.  
  1185. char * DecodeArgs(int argc, char *argv[])
  1186. {
  1187.   BOOL error;
  1188.   char pri;
  1189.  
  1190.   /*----------------------------------------------------------*/
  1191.   error = GetOpt(argc, argv, "ShowDVI", !background, opt);
  1192.   /*----------------------------------------------------------*/
  1193.  
  1194.   if (error) {
  1195.     PrintHelp(opt, FALSE);
  1196.     AbortRun(5);    /* Programm Ende */
  1197.   }
  1198.   if (help) {
  1199.     PrintHelp(opt, TRUE);
  1200.     AbortRun(0);    /* Programm Ende */
  1201.   }
  1202.   
  1203.   /* Now we can check the arguments        */
  1204.   g_logging    = o_nlogging ? -1 : 0;
  1205.   if (DebugStats)    Stats = 2;    /* g_logging is not touched */
  1206.   hconvresolution = vconvresolution = resolution;
  1207.   /* fontmemsize ueberpruefen ? */
  1208.  
  1209.  
  1210.   if (g_paper) {
  1211.     int i;
  1212.     
  1213.     for (i=0; psizes[i].name; i++) {
  1214.       if (!stricmp(g_paper, psizes[i].name)) {
  1215.         // Papiergroesse *inklusive* dem Offset!
  1216.         if (abs(user_paper_width_in+13.13)  > 0.01) Warning(MSG_PAPER_WIDTH_HEIGHT_ERR, "WIDTH");
  1217.         if (abs(user_paper_height_in+13.13) > 0.01) Warning(MSG_PAPER_WIDTH_HEIGHT_ERR, "HEIGHT");
  1218.         // Offsets aufaddieren, da sie ja gleich wieder abgezogen werden
  1219.         user_paper_width_in  = psizes[i].width;
  1220.         user_paper_height_in = psizes[i].height;
  1221.         break;
  1222.       }
  1223.     }
  1224.     if (!psizes[i].name) {
  1225.       Fatal(5, MSG_UNKNOWN_PAPER_SIZE, g_paper);
  1226.     }
  1227.   }
  1228.  
  1229.  
  1230.   /* true Flags setzen */
  1231.   hoffset_is_true = GetOneOpt(&hoffset_in_fix, opt)->special;
  1232.   voffset_is_true = GetOneOpt(&voffset_in_fix, opt)->special;
  1233.  
  1234.  
  1235.   pri = (char)task_priority;
  1236.   if (task_priority > 127 || task_priority < -127) {
  1237.     task_priority = 0;
  1238.   }
  1239.   else {
  1240.     task_priority = 0;
  1241.     task_priority |= (unsigned long)((unsigned char)pri);
  1242.   }
  1243.   
  1244.   /* ToDo initialisieren ? */
  1245.  
  1246.   /* Folgender Teil ist noch Amiga spezifisch */
  1247.   if (filenameptr != NULL) {
  1248.     if (!is_dir(filenameptr)) {
  1249.       char namebuf[PATHLEN];
  1250.       BPTR lck;
  1251.       char *ptr;
  1252.  
  1253.       strcpy(namebuf, filenameptr);
  1254.       if ((ptr = strrchr(namebuf, '.')) == NULL) {
  1255.         strcat(namebuf, ".dvi");
  1256.       }
  1257.       else {
  1258.         if (stricmp(ptr, ".tex") == 0) {
  1259.           strcpy(ptr, ".dvi");    /* Ueberschreibe das '.tex' */
  1260.         }
  1261.         else {
  1262.           if (stricmp(ptr, ".dvi") != 0) {
  1263.             strcat(namebuf, ".dvi");
  1264.           }
  1265.         }
  1266.       }
  1267.  
  1268.       dvifp = NULL;
  1269.       lck = Lock(namebuf, ACCESS_READ);
  1270.       if (lck) {
  1271.         NameFromLock(lck, filename, sizeof(filename)-1);
  1272.         getdir(namebuf, dirname);
  1273.         dvifp = OpenDVI(namebuf, MaxDviBufSize);
  1274.         UnLock(lck);
  1275.       }
  1276.       if (!dvifp) {
  1277.         Warning(MSG_CANT_FIND_FILE,namebuf);
  1278.     getdir("",filename);
  1279.       }
  1280.     }
  1281.     else {     /* isdir(filenameptr)    */
  1282.       getdir(filenameptr, filename);
  1283.     }
  1284.   }
  1285.   else {     /* NULL==filenameptr    */
  1286.     getdir("",filename);    /* kein Name angegeben => nimm das aktuelle Dir. */
  1287.   }
  1288.   
  1289.   return filenameptr;
  1290. }
  1291.  
  1292.  
  1293.  
  1294.  
  1295. /*-->PrintHelp*/
  1296. /*********************************************************************/
  1297. /***************************** PrintHelp *****************************/
  1298. /*********************************************************************/
  1299.  
  1300. static void PrintHelp(struct Options opt[], short long_hlp)
  1301. {
  1302.   char hlp[140];
  1303.  
  1304.   /*Message("");*/ /*hes:wozu, NULL bringt doch die (c) Meldung ? (als Leerzeile) */
  1305.   MessageStr(NULL);
  1306.   Message(MSG_COPYRIGHT,__DATE__);
  1307.  
  1308.   sprintf(hlp, GetTeXString(MSG_USAGE), g_progname);
  1309.   GetOptShortHelp(hlp, 73, opt);
  1310.  
  1311.   if (long_hlp) {
  1312.     MessageStr("");
  1313.     GetOptHelp(opt);  
  1314.   }
  1315. }
  1316.  
  1317.  
  1318.  
  1319. /* called only by changing the dvi file (from (am/at)screen) */
  1320. void OpenNewDVI(char *filename, int theSame)
  1321. /* filename with full path and with (.dvi) extension !!!!!!! */
  1322. {
  1323.   /* theSame: ist TRUE, falls exact das selbe DVI-File neu geladen werden soll */
  1324.   /*          z.B. wenn man nur die Aufloesung aendert.                        */
  1325.   
  1326.  
  1327.   if (theSame && dvifp != NULL) {
  1328.     // wenn ein dvifp Pointer != NULL ist, so ist das File entweder
  1329.     // korrekt offen, oder aber TempClose'd. Nach TempOpen muss das File
  1330.     // also korrekt offen sein. Falls nicht TempClose'd war, so macht das nichts.
  1331.     
  1332.     TempOpenDVI(&dvifp);
  1333.     if (!dvifp) {
  1334.       Fatal(5, MSG_CANT_FIND_FILE, filename);
  1335.     }
  1336.     DVIrewind(dvifp);
  1337.   }
  1338.   else {
  1339.     if (dvifp != NULL) {
  1340.       CloseDVI(dvifp);
  1341.     }
  1342.  
  1343. #ifdef DEBUG
  1344.     if (DeBug) {
  1345.       Message("Opening DVI file: %s",filename);
  1346.     }
  1347. #endif
  1348.  
  1349.     if ((dvifp=OpenDVI(filename, MaxDviBufSize)) == NULL) {
  1350.       Fatal(5, MSG_CANT_FIND_FILE, filename);
  1351.     }
  1352.   }
  1353.  
  1354.   if (abs(user_paper_width_in+13.13) > 0.01) {
  1355.     paper_width = (long)((float)hconvresolution * user_paper_width_in);
  1356.   }
  1357.   else {
  1358.     paper_width  = hconvresolution * HSIZE;        /* for !preload */
  1359.   }                            /*   default    */
  1360.                             /*    size      */
  1361.   if (abs(user_paper_height_in+13.13) > 0.01) {
  1362.     paper_height = (long)((float)vconvresolution * user_paper_height_in);
  1363.   }
  1364.   else {
  1365.     paper_height = vconvresolution * VSIZE;
  1366.   }
  1367.  
  1368. #ifdef AMIGA
  1369.   set_ndvif;        /* new DVI-file is loaded */
  1370.   set_dvif;        /* a DVI-File is loaded */
  1371.   
  1372.   SetShowDVIVars(filename);
  1373.   Set_PgPotGadRange();
  1374. #endif
  1375. }
  1376.  
  1377.  
  1378.  
  1379.  
  1380. /*************    C O U N T E R   H A N D L I N G    ********************/
  1381. /*                                    */
  1382. /*  #define clear_counter(i)    page_counter(i,0)            */
  1383. /*  #define set_counter(i)    page_counter(i,1)            */
  1384. /*  #define take_counter(i)    page_counter(i,2)            */
  1385. /*                                    */
  1386. int page_counter(int i, int m)
  1387. {
  1388.   static int counter;
  1389.   int ret;
  1390.  
  1391.   switch (m) {
  1392.     case 0:    ret = counter;            /* loeschen    */
  1393.         counter = -1;
  1394. #ifdef AMIGA
  1395.         write_status();
  1396. #endif
  1397.         break;
  1398.     case 1:    if (counter == -1) {
  1399.               counter = i;
  1400.         }
  1401.         else {
  1402.           counter = counter * 10 + i;    /* eintragen    */
  1403.         }
  1404.         ret = counter;
  1405. #ifdef AMIGA
  1406.         write_status();
  1407. #endif
  1408.         break;
  1409.     case 2:    ret = counter;            /* abrufen    */
  1410.         break;
  1411.   }
  1412.   if (counter != -1 && counter/10000 > 0) {
  1413.     counter = counter % 10000;
  1414.     ret = counter;
  1415.   }
  1416.  
  1417.   return (ret);
  1418. }
  1419.