home *** CD-ROM | disk | FTP | other *** search
/ The Datafile PD-CD 3 / PDCD_3.iso / tex / texsrc1 / Src / lib / c / texmf < prev    next >
Encoding:
Text File  |  1993-05-09  |  21.1 KB  |  808 lines
  1. /* Hand-coded routines for TeX or Metafont in C.  This code was (mostly)
  2.    written by Tim Morgan, drawing from other Unix ports of TeX.  */
  3.  
  4. /* Either `texd.h' or `mfd.h' will include `../common/texmf.h'.  */
  5.  
  6. /* Instantiate data in `texd.h' or `mfd.h' here.  */
  7. #define    EXTERN
  8.  
  9. #ifdef TeX
  10. #include "texd.h"
  11. #define dump_default_var TEXformatdefault
  12. #define dump_default " plain.fmt"
  13. #define dump_format " %s.fmt"
  14. #define dump_ext_length 4
  15. #define dump_default_length formatdefaultlength
  16. #define virgin_program "virtex"
  17. #define main_program texbody
  18. #define edit_value tex_edit_value
  19. #define edit_var "TEXEDIT"
  20. #else /* not TeX */
  21. #include "mfd.h"
  22. #define dump_default_var MFbasedefault
  23. #define dump_default " plain.base"
  24. #define dump_format " %s.base"
  25. #define dump_ext_length 5
  26. #define dump_default_length basedefaultlength
  27. #define virgin_program "virmf"
  28. #define main_program main_body
  29. #define edit_value mf_edit_value
  30. #define edit_var "MFEDIT"
  31. #endif /* not TeX */
  32.  
  33. #include "c-ctype.h"
  34. #include "c-pathch.h"
  35.  
  36. /* For `struct tm'.  */
  37. #include <time.h>
  38. extern struct tm *localtime ();
  39.  
  40. /* Catch interrupts.  */
  41. #include <signal.h>
  42.  
  43. #ifdef FUNNY_CORE_DUMP
  44. void funny_core_dump ();
  45. #endif
  46.  
  47. /* ridderbusch.pad@nixdorf.com says this is necessary.  */
  48. #ifdef ATARI_ST
  49. int _stksize = -1L;
  50. #endif
  51.  
  52. /* The main program, etc.  */
  53.  
  54. /* What we were invoked as and with.  */
  55. static char *program_name = NULL;
  56. static int gargc;
  57. char **gargv;
  58.  
  59.  
  60. /* The entry point: set up for reading the command line, which will
  61.    happen in `topenin', then call the main body.  */
  62.  
  63. int
  64. main (ac, av)
  65.   int ac;
  66.   char *av[];
  67. {
  68.   char custom_default[PATH_MAX];
  69.  
  70.   gargc = ac;
  71.   gargv = av;
  72.  
  73.   dump_default_var = dump_default;
  74.   dump_default_length = strlen (dump_default + 1);
  75.  
  76. #ifndef INI
  77.   if (readyalready != 314159)
  78.     {
  79.       program_name = strrchr (av[0], PATH_SEP);
  80.       if (program_name == NULL)
  81.     program_name = av[0];
  82.       else
  83.     program_name++;
  84.       if (strcmp (program_name, virgin_program) != 0)
  85.         {
  86.           /* TeX or Metafont adds the space at the end of the name.  */
  87.           (void) sprintf (custom_default, dump_format, program_name);
  88.           dump_default_var = custom_default;
  89.           dump_default_length = strlen (program_name) + dump_ext_length;
  90.         }
  91.     }
  92. #endif /* not INI */
  93.  
  94.   main_program ();
  95. } 
  96.  
  97.  
  98. /* This is supposed to ``open the terminal for input'', but what we
  99.    really do is copy command line arguments into TeX's or Metafont's
  100.    buffer, so they can handle them.  If nothing is available, or we've
  101.    been called already (and hence, gargc==0), we return with
  102.    `last=first'.  */
  103.  
  104. void
  105. topenin ()
  106. {
  107.   register int i;
  108.  
  109.   buffer[first] = 0;    /* So the first `strcat' will work.  */
  110.  
  111.   if (gargc > 1)
  112.     { /* We have command line arguments.  */
  113.       for (i = 1; i < gargc; i++)
  114.         {
  115.       (void) strcat ((char *) &buffer[first], gargv[i]);
  116.           (void) strcat ((char *) &buffer[first], " ");
  117.     }
  118.       gargc = 0;    /* Don't do this again.  */
  119.     }
  120.  
  121.   /* Find the end of the buffer.  */
  122.   for (last = first; buffer[last]; ++last)
  123.     ;
  124.  
  125.   /* Make `last' be one past the last non-blank non-formfeed character
  126.      in `buffer'.  */
  127.   for (--last; last >= first
  128.        && ISSPACE (buffer[last]) && buffer[last] != '\f'; --last) 
  129.     ;
  130.   last++;
  131.  
  132.   /* One more time, this time converting to TeX's internal character
  133.      representation.  */
  134. #ifdef NONASCII
  135.   for (i = first; i < last; i++)
  136.     buffer[i] = xord[buffer[i]];
  137. #endif
  138. }
  139.  
  140. /* All our interrupt handler has to do is set TeX's or Metafont's global
  141.    variable `interrupt'; then they will do everything needed.  */
  142.  
  143. #ifdef RISCOS
  144. RETSIGTYPE
  145. catch_interrupt (int s) 
  146. #else
  147. static RETSIGTYPE
  148. catch_interrupt ()
  149. #endif
  150. {
  151.   interrupt = 1;
  152.   (void) signal (SIGINT, catch_interrupt);
  153. }
  154.  
  155.  
  156. /* Besides getting the date and time here, we also set up the interrupt
  157.    handler, for no particularly good reason.  It's just that since the
  158.    `fix_date_and_time' routine is called early on (section 1337 in TeX,
  159.    ``Get the first line of input and prepare to start''), this is as
  160.    good a place as any.  */
  161.  
  162. void
  163. get_date_and_time (minutes, day, month, year)
  164.   integer *minutes, *day, *month, *year;
  165. {
  166.   time_t clock = time ((time_t *) 0);
  167.   struct tm *tmptr = localtime (&clock);
  168.  
  169.   *minutes = tmptr->tm_hour * 60 + tmptr->tm_min;
  170.   *day = tmptr->tm_mday;
  171.   *month = tmptr->tm_mon + 1;
  172.   *year = tmptr->tm_year + 1900;
  173.  
  174.   {
  175.     RETSIGTYPE (*old_handler) ();
  176.  
  177.     if ((old_handler = signal (SIGINT, catch_interrupt)) != SIG_DFL)
  178.       (void) signal (SIGINT, old_handler);
  179.   }
  180. }
  181.  
  182. /* I/O for TeX and Metafont.  */
  183.  
  184. /* Read a line of input as efficiently as possible while still looking
  185.    like Pascal.  We set `last' to `first' and return `false' if we get
  186.    to eof.  Otherwise, we return `true' and set last = first +
  187.    length(line except trailing whitespace).  */
  188.  
  189. boolean
  190. input_line (f)
  191.   FILE *f;
  192. {
  193.   register int i;
  194.  
  195.   last = first;
  196.  
  197.   while (last < bufsize && (i = getc (f)) != EOF && i != '\n')
  198.     buffer[last++] = i;
  199.  
  200.   if (i == EOF && last == first)
  201.       return false;
  202.  
  203.   /* We didn't get the whole line because our buffer was too small.  */
  204.   if (i != EOF && i != '\n')
  205.     {
  206.       (void) fprintf (stderr,
  207.                      "! Unable to read an entire line---bufsize=%d.\n",
  208.                      bufsize);
  209.       (void) fprintf (stderr, "Please ask a wizard to enlarge me.\n");
  210.       uexit (1);
  211.     }
  212.  
  213.   buffer[last] = ' ';
  214.   if (last >= maxbufstack)
  215.     maxbufstack = last;
  216.  
  217.   /* Trim trailing whitespace.  */
  218.   while (last > first
  219.          && isblank (buffer[last - 1]) && buffer[last - 1] != '\r')
  220.     --last;
  221.  
  222.   /* Don't bother using xord if we don't need to.  */
  223. #ifdef NONASCII
  224.   for (i = first; i <= last; i++)
  225.      buffer[i] = xord[buffer[i]];
  226. #endif
  227.  
  228.     return true;
  229. }
  230.  
  231. /* This string specifies what the `e' option does in response to an
  232.    error message.  */ 
  233. static char *edit_value = EDITOR;
  234.  
  235. /* This procedure is due to sjc@s1-c.  TeX (or Metafont) calls it when
  236.    the user types `e' in response to an error, invoking a text editor on
  237.    the erroneous source file.  FNSTART is how far into FILENAME the
  238.    actual filename starts; FNLENGTH is how long the filename is.
  239.    
  240.    See ../site.h for how to set the default, and how to override it.  */
  241.  
  242. void
  243. calledit (filename, fnstart, fnlength, linenumber)
  244.   ASCIIcode *filename;
  245.   poolpointer fnstart;
  246.   integer fnlength, linenumber;
  247. {
  248.   char *temp, *command;
  249.   char c;
  250.   int sdone, ddone, i;
  251.  
  252.   sdone = ddone = 0;
  253.   filename += fnstart;
  254.  
  255.   /* Close any open input files, since we're going to kill the job.  */
  256.   for (i = 1; i <= inopen; i++)
  257.     (void) fclose (inputfile[i]);
  258.  
  259.   /* Replace the default with the value of the appropriate environment
  260.      variable, if it's set.  */
  261.   temp = getenv (edit_var);
  262.   if (temp != NULL)
  263.     edit_value = temp;
  264.  
  265.   /* Construct the command string.  The `11' is the maximum length an
  266.      integer might be.  */
  267.   command = (string) xmalloc (strlen (edit_value) + fnlength + 11);
  268.  
  269.   /* So we can construct it as we go.  */
  270.   temp = command;
  271.  
  272.   while ((c = *edit_value++) != 0)
  273.     {
  274.       if (c == '%')
  275.         {
  276.           switch (c = *edit_value++)
  277.             {
  278.         case 'd':
  279.           if (ddone)
  280.                 {
  281.           (void) fprintf (stderr,
  282.                            "! `%%d' cannot appear twice in editor command.\n");
  283.               uexit (1);
  284.         }
  285.               (void) sprintf (temp, "%d", linenumber);
  286.               while (*temp != '\0')
  287.                 temp++;
  288.               ddone = 1;
  289.               break;
  290.  
  291.         case 's':
  292.               if (sdone)
  293.                 {
  294.               (void) fprintf(stderr,
  295.                            "! `%%s' cannot appear twice in editor command.\n");
  296.           uexit (1);
  297.         }
  298.               for (i =0; i < fnlength; i++)
  299.         *temp++ = Xchr (filename[i]);
  300.               sdone = 1;
  301.               break;
  302.  
  303.         case '\0':
  304.               *temp++ = '%';
  305.               /* Back up to the null to force termination.  */
  306.           edit_value--;
  307.           break;
  308.  
  309.         default:
  310.           *temp++ = '%';
  311.           *temp++ = c;
  312.           break;
  313.         }
  314.     }
  315.       else
  316.     *temp++ = c;
  317.     }
  318.  
  319.   *temp = 0;
  320.  
  321.   /* Execute the command.  */
  322.   if (system (command) != 0)
  323.     fprintf (stderr, "! Trouble executing `%s'.\n", command);
  324.  
  325.   /* Quit, since we found an error.  */
  326.   uexit (1);
  327. }
  328.  
  329. /* Read and write format (for TeX) or base (for Metafont) files.  In
  330.    tex.web, these files are architecture dependent; specifically,
  331.    BigEndian and LittleEndian architectures produce different files.
  332.    These routines always output BigEndian files.  This still does not
  333.    make the dump files architecture-independent, because it is possible
  334.    to make a format file that dumps a glue ratio, i.e., a floating-point
  335.    number.  Fortunately, none of the standard formats do that.  */
  336.  
  337. #if !defined (WORDS_BIGENDIAN) && !defined (NO_FMTBASE_SWAP) /* this fn */
  338.  
  339. /* This macro is always invoked as a statement.  It assumes a variable
  340.    `temp'.  */
  341.    
  342. #define SWAP(x, y) temp = (x); (x) = (y); (y) = temp;
  343.  
  344.  
  345. /* Make the NITEMS items pointed at by P, each of size SIZE, be the
  346.    opposite-endianness of whatever they are now.  */
  347.  
  348. static void
  349. swap_items (p, nitems, size)
  350.   char *p;
  351.   int nitems;
  352.   int size;
  353. {
  354.   char temp;
  355.  
  356.   /* Since `size' does not change, we can write a while loop for each
  357.      case, and avoid testing `size' for each time.  */
  358.   switch (size)
  359.     {
  360.     case 8:
  361.       while (nitems--)
  362.         {
  363.           SWAP (p[0], p[7]);
  364.           SWAP (p[1], p[6]);
  365.           SWAP (p[2], p[5]);
  366.           SWAP (p[3], p[4]);
  367.           p += size;
  368.         }
  369.       break;
  370.  
  371.     case 4:
  372.       while (nitems--)
  373.         {
  374.           SWAP (p[0], p[3]);
  375.           SWAP (p[1], p[2]);
  376.           p += size;
  377.         }
  378.       break;
  379.  
  380.     case 2:
  381.       while (nitems--)
  382.         {
  383.           SWAP (p[0], p[1]);
  384.           p += size;
  385.         }
  386.       break;
  387.  
  388.     case 1:
  389.       /* Nothing to do.  */
  390.       break;
  391.  
  392.     default:
  393.       fprintf (stderr, "! I can't (un)dump a %d byte item.\n", size);
  394.       uexit (1);
  395.   }
  396. }
  397. #endif /* not WORDS_BIGENDIAN and not NO_FMTBASE_SWAP */
  398.  
  399.  
  400. /* Here we write NITEMS items, each item being ITEM_SIZE bytes long.
  401.    The pointer to the stuff to write is P, and we write to the file
  402.    OUT_FILE.  */
  403.  
  404. void
  405. do_dump (p, item_size, nitems, out_file)
  406.   char *p;
  407.   int item_size, nitems;
  408.   FILE *out_file;
  409. {
  410. #if !defined (WORDS_BIGENDIAN) && !defined (NO_FMTBASE_SWAP)
  411.   swap_items (p, nitems, item_size);
  412. #endif
  413.  
  414.   if (fwrite (p, item_size, nitems, out_file) != nitems)
  415.     {
  416.       fprintf (stderr, "! Could not write %d %d-byte item(s).\n",
  417.                nitems, item_size);
  418.       uexit (1);
  419.     }
  420.  
  421.   /* Have to restore the old contents of memory, since some of it might
  422.      get used again.  */
  423. #if !defined (WORDS_BIGENDIAN) && !defined (NO_FMTBASE_SWAP)
  424.   swap_items (p, nitems, item_size);
  425. #endif
  426. }
  427.  
  428.  
  429. /* Here is the dual of the writing routine.  The VMS code is
  430.    from joe%ril3.decnet@hydra.tamri.com.  */
  431.  
  432. #ifdef VMS
  433. #define VMS_BLK_READ 64        /* size of reads. some controllers can't do */
  434.                 /* more than 127.  Otherwise, it's trial and */
  435.                 /* error of which is fastest. */
  436. #include <rms>
  437.   char *rms_buffer;
  438.   int bufferpointer = 0;
  439.   int bufferend = -1;        /* -1 means not opened yet */
  440.   char rms_filename[256];    /* ought to be big enuf for file name */
  441.   int filesize;            /* hommany blocks we got to read */
  442.   int block_read = 0;        /* keep track of where we are in the file */
  443.   struct FAB *fabptr;
  444.   struct RAB *rabptr;
  445. #endif
  446.  
  447. void
  448. do_undump (p, item_size, nitems, in_file)
  449.   char *p;
  450.   int item_size, nitems;
  451.   FILE *in_file;
  452. {
  453. #ifdef VMS
  454. int move;
  455. int sys$open(),sys$display(),sys$connect(),sys$read(),sys$close();
  456.   if(bufferend==-1) {
  457.     /* fmtfile is already opened with a fopen call.  this doesn't
  458.     get in the way, and is a quick way to get the full filename */
  459.     fgetname(fmtfile,rms_filename);
  460.     rms_buffer = malloc(512*VMS_BLK_READ);    /* allocate i/o buffer */
  461.     bufferend = 0;                /* end of good data */
  462.     fabptr = malloc(sizeof(struct FAB));
  463.     rabptr = malloc(sizeof(struct RAB));
  464.     *fabptr = cc$rms_fab;            /* initialize fab pointer */
  465.  
  466.     (*fabptr).fab$l_fna = rms_filename;    /* name and length of name */
  467.     (*fabptr).fab$b_fns = strlen(rms_filename);
  468.     (*fabptr).fab$b_rfm = FAB$C_STM;    /* rms-11 stream format */
  469.     (*fabptr).fab$b_fac = FAB$M_BIO | FAB$M_GET;    /* block read access */
  470.  
  471.     sys$open(fabptr);            /* open file */
  472.  
  473.     *rabptr = cc$rms_rab;            /* initialize rab pointer */
  474.     (*rabptr).rab$l_fab = fabptr;        /* this is the fab */
  475.     (*rabptr).rab$w_isi = 0;        /* probably don't need this */
  476.     (*rabptr).rab$w_usz = 512*VMS_BLK_READ;    /* read 512*blocks bytes */
  477.     (*rabptr).rab$l_ubf = rms_buffer;    /* where to put data */
  478.     (*rabptr).rab$l_rop = FAB$M_BIO;    /* block i/o */
  479.     (*rabptr).rab$l_bkt = 0;        /* read next block */
  480.  
  481.     sys$connect(rabptr);            /* connect i/o channel */
  482.     sys$display(fabptr);            /* get info about file */
  483.     filesize = (*fabptr).fab$l_alq;        /* get allocation size */
  484.  
  485.   }
  486.   for(move=0;move<item_size*nitems;) {
  487.   if (bufferpointer==bufferend) {
  488.     sys$read(rabptr);            /* read at next block pointer */
  489.     bufferend = (*rabptr).rab$w_rsz;    /* number of bytes read */
  490.     block_read+= VMS_BLK_READ;
  491.     if( block_read > filesize ) {
  492.         sys$close(fabptr);
  493.         free(rms_buffer);
  494.         free(fabptr);
  495.         free(rabptr);
  496.     }
  497.     if(bufferend == 0) {
  498.         fprintf(stderr,"! Could not read file.\n");
  499.         exit (1);
  500.     }
  501.     bufferpointer = 0;
  502.   }
  503.   if(item_size*nitems-move <= bufferend-bufferpointer) {
  504.     memcpy(&p[move],&rms_buffer[bufferpointer],item_size*nitems-move);
  505.     bufferpointer += item_size*nitems-move;
  506.     move = item_size*nitems;
  507.   } else {
  508.     memcpy(&p[move],&rms_buffer[bufferpointer],bufferend-bufferpointer);
  509.     move += bufferend - bufferpointer;
  510.     bufferpointer = bufferend;
  511.   }
  512.   }
  513. #else /* not VMS */
  514.   if (fread (p, item_size, nitems, in_file) != nitems)
  515.     {
  516.       fprintf (stderr, "! Could not read %d %d-byte item(s).\n",
  517.                nitems, item_size);
  518.       uexit (1);
  519.     }
  520.  
  521. #if !defined (WORDS_BIGENDIAN) && !defined (NO_FMTBASE_SWAP)
  522.   swap_items (p, nitems, item_size);
  523. #endif
  524. #endif /* not VMS */
  525. }
  526.  
  527. #ifdef FUNNY_CORE_DUMP
  528. /* This procedure is due to chris@mimsy.umd.edu.  It makes a core dump
  529.    without any sort of error status (abort(2) does return an error status,
  530.    so we don't want to use that).  It is used only when making a preloaded
  531.    TeX from virtex, and is triggered by a magic file name requested as
  532.    input (see `open_input', above).  */
  533.  
  534. void
  535. funny_core_dump ()
  536. {
  537.   int pid, w;
  538.   union wait status;
  539.  
  540.   switch (pid = vfork ())
  541.     {
  542.     case -1:        /* failed */
  543.       perror ("vfork");
  544.       exit (-1);
  545.       /*NOTREACHED*/
  546.  
  547.     case 0:             /* child */
  548.        (void) signal (SIGQUIT, SIG_DFL);
  549.        (void) kill (getpid (), SIGQUIT);
  550.        (void) write (2, "how did we get here?\n", 21);
  551.        _exit (1);
  552.        /*NOTREACHED*/
  553.  
  554.     default:        /* parent */
  555.       while ((w = wait (&status)) != pid && w != -1)
  556.     ;
  557.       if (status.w_coredump)
  558.     exit (0);
  559.       (void) write (2, "attempt to dump core failed\n", 28);
  560.       exit (1);
  561.     }
  562. }
  563. #endif /* FUNNY_CORE_DUMP */
  564.  
  565. #ifndef TeX
  566. /* On-line display routines for Metafont.  Here we use a dispatch table
  567.    indexed by the MFTERM or TERM environment variable to select the
  568.    graphics routines appropriate to the user's terminal.  stdout must be
  569.    connected to a terminal for us to do any graphics.  */
  570.  
  571. /* We don't want any other window routines screwing us up if we're
  572.    trying to do the trap test.  We could have written another device for
  573.    the trap test, but the terminal type conditionals in initscreen argue
  574.    against that.  */
  575.  
  576. #if defined (TRAP) || defined (INI)
  577. #undef HP2627WIN
  578. #undef SUNWIN
  579. #undef XVIEWWIN
  580. #undef TEKTRONIXWIN
  581. #undef UNITERMWIN
  582. #undef X10WIN
  583. #undef X11WIN
  584. #endif
  585.  
  586.  
  587. #ifdef HP2627WIN
  588. extern mf_hp2627_initscreen (), mf_hp2627_updatescreen ();
  589. extern mf_hp2627_blankrectangle (), mf_hp2627_paintrow ();
  590. #endif
  591.  
  592. #ifdef SUNWIN
  593. extern mf_sun_initscreen (), mf_sun_updatescreen ();
  594. extern mf_sun_blankrectangle (), mf_sun_paintrow ();
  595. #endif
  596.  
  597. #ifdef TEKTRONIXWIN
  598. extern mf_tektronix_initscreen (), mf_tektronix_updatescreen ();
  599. extern mf_tektronix_blankrectangle (), mf_tektronix_paintrow ();
  600. #endif
  601.  
  602. #ifdef UNITERMWIN
  603. extern mf_uniterm_initscreen (), mf_uniterm_updatescreen();
  604. extern mf_uniterm_blankrectangle(), mf_uniterm_paintrow();
  605. #endif
  606.  
  607. #ifdef X10WIN
  608. extern mf_x10_initscreen (), mf_x10_updatescreen ();
  609. extern mf_x10_blankrectangle (), mf_x10_paintrow ();
  610. #endif
  611.  
  612. #ifdef X11WIN
  613. extern mf_x11_initscreen (), mf_x11_updatescreen ();
  614. extern mf_x11_blankrectangle (), mf_x11_paintrow ();
  615. #endif
  616.  
  617.  
  618. /* `mfwsw' contains the dispatch tables for each terminal.  We map the
  619.    Pascal calls to the routines `init_screen', `update_screen',
  620.    `blank_rectangle', and `paint_row' into the appropriate entry point
  621.    for the specific terminal that MF is being run on.  */
  622.  
  623. struct mfwin_sw
  624. {
  625.   char *mfwsw_type;        /* Name of terminal a la TERMCAP.  */
  626.   int (*mfwsw_initscreen) ();
  627.   int (*mfwsw_updatescrn) ();
  628.   int (*mfwsw_blankrect) ();
  629.   int (*mfwsw_paintrow) ();
  630. } mfwsw[] =
  631.  
  632. /* Now we have the initializer for all the devices we support.  */
  633.  
  634. {
  635. #ifdef HP2627WIN
  636.   { "hp2627", mf_hp2627_initscreen, mf_hp2627_updatescreen,
  637.     mf_hp2627_blankrectangle, mf_hp2627_paintrow },
  638. #endif
  639.  
  640. #ifdef SUNWIN
  641.   { "sun", mf_sun_initscreen, mf_sun_updatescreen,
  642.     mf_sun_blankrectangle, mf_sun_paintrow },
  643. #endif
  644.  
  645. #ifdef TEKTRONIXWIN
  646.   { "tek", mf_tektronix_initscreen, mf_tektronix_updatescreen,
  647.     mf_tektronix_blankrectangle, mf_tektronix_paintrow },
  648. #endif
  649.  
  650. #ifdef UNITERMWIN
  651.    { "uniterm", mf_uniterm_initscreen, mf_uniterm_updatescreen,
  652.      mf_uniterm_blankrectangle, mf_uniterm_paintrow },
  653. #endif
  654.  
  655. #ifdef X10WIN
  656.   { "xterm", mf_x10_initscreen, mf_x10_updatescreen,
  657.     mf_x10_blankrectangle, mf_x10_paintrow },
  658. #endif
  659.  
  660. #ifdef X11WIN
  661.   { "xterm", mf_x11_initscreen, mf_x11_updatescreen, 
  662.     mf_x11_blankrectangle, mf_x11_paintrow },
  663. #endif
  664.  
  665. /* Finally, we must have an entry with a terminal type of NULL.  */
  666.   { NULL, NULL, NULL, NULL, NULL }
  667.  
  668. }; /* End of the array initialization.  */
  669.  
  670.  
  671. /* This is a pointer to the mfwsw[] entry that we find.  */
  672. static struct mfwin_sw *mfwp;
  673.  
  674. /* The following are routines that just jump to the correct
  675.    terminal-specific graphics code. If none of the routines in the
  676.    dispatch table exist, or they fail, we produce trap-compatible
  677.    output, i.e., the same words and punctuation that the unchanged
  678.    mf.web would produce.  */
  679.  
  680.  
  681. /* This returns true if we can do window operations, else false.  */
  682.  
  683. boolean
  684. initscreen ()
  685. {
  686. #ifndef TRAP
  687.   /* If MFTERM is set, use it.  */
  688.   char *ttytype = getenv ("MFTERM");
  689.   
  690.   if (ttytype == NULL)
  691.     { /* If DISPLAY is set, we are X11; otherwise, who knows.  */
  692.       boolean have_display = getenv ("DISPLAY") != NULL;
  693.       ttytype = have_display ? "xterm" : getenv ("TERM");
  694.     }
  695.  
  696.   /* If we don't know kind of terminal this is, or if Metafont isn't
  697.       being run interactively, don't do any online output.  */
  698.   if (ttytype == NULL 
  699. #ifndef RISCOS
  700.     || !isatty (fileno (stdout))
  701. #endif
  702.      )
  703.     return 0;
  704.  
  705.   /* Test each of the terminals given in `mfwsw' against the terminal
  706.      type, and take the first one that matches, or if the user is running
  707.      under Emacs, the first one.  */
  708.   for (mfwp = mfwsw; mfwp->mfwsw_type != NULL; mfwp++)
  709.     if (!strncmp (mfwp->mfwsw_type, ttytype, strlen (mfwp->mfwsw_type))
  710.     || !strcmp (ttytype, "emacs"))
  711.       if (mfwp->mfwsw_initscreen)
  712.     return ((*mfwp->mfwsw_initscreen) ());
  713.       else
  714.     {
  715.       fprintf (stderr,
  716.                    "! Couldn't initialize the online display for a `%s'.\n",
  717.                    ttytype);
  718.       return 1;
  719.     }
  720.   
  721.   /* The current terminal type wasn't found in any of the entries, so
  722.      silently give up, assuming that the user isn't on a terminal that
  723.      supports graphic output.  */
  724.   return 0;
  725. #else /* TRAP */
  726.   return 1;
  727. #endif /* TRAP */
  728. }
  729.  
  730.  
  731. /* Make sure everything is visible.  */
  732.  
  733. void
  734. updatescreen ()
  735. {
  736. #ifndef TRAP
  737.   if (mfwp->mfwsw_updatescrn)
  738.     ((*mfwp->mfwsw_updatescrn) ());
  739.   else
  740.     {
  741.       printf ("Updatescreen called\n");
  742.     }
  743. #else /* TRAP */
  744.   fprintf (logfile, "Calling UPDATESCREEN\n");
  745. #endif /* TRAP */
  746. }
  747.  
  748.  
  749. /* This sets the rectangle bounded by ([left,right], [top,bottom]) to
  750.    the background color.  */
  751.  
  752. void
  753. blankrectangle (left, right, top, bottom)
  754.      screencol left, right;
  755.      screenrow top, bottom;
  756. {
  757. #ifndef TRAP
  758.   if (mfwp->mfwsw_blankrect)
  759.     ((*mfwp->mfwsw_blankrect) (left, right, top, bottom));
  760.   else
  761.     {
  762.       printf ("Blankrectangle l=%d  r=%d  t=%d  b=%d\n",
  763.           left, right, top, bottom);
  764.     }
  765. #else /* TRAP */
  766.   fprintf (logfile, "\nCalling BLANKRECTANGLE(%d,%d,%d,%d)\n", left,
  767.        right, top, bottom);
  768. #endif /* TRAP */
  769. }
  770.  
  771.  
  772. /* This paints ROW, starting with the color INIT_COLOR. 
  773.    TRANSITION_VECTOR then specifies the length of the run; then we
  774.    switch colors.  This goes on for VECTOR_SIZE transitions.  */
  775.  
  776. void
  777. paintrow (row, init_color, transition_vector, vector_size)
  778.      screenrow row;
  779.      pixelcolor init_color;
  780.      transspec transition_vector;
  781.      screencol vector_size;
  782. {
  783. #ifndef TRAP
  784.   if (mfwp->mfwsw_paintrow)
  785.     ((*mfwp->mfwsw_paintrow) (row, init_color,
  786.                   transition_vector, vector_size));
  787.   else
  788.     {
  789.       printf ("Paintrow r=%d  c=%d  v=");
  790.       while (vector_size-- > 0)
  791.     printf ("%d  ", transition_vector++);
  792.       printf ("\n");
  793.     }
  794. #else /* TRAP */
  795.   unsigned k;
  796.  
  797.   fprintf (logfile, "Calling PAINTROW(%d,%d;", row, init_color);
  798.   for (k = 0; k <= vector_size; k++)
  799.     {
  800.       fprintf (logfile, "%d", transition_vector[k]);
  801.       if (k != vector_size)
  802.     fprintf (logfile, ",");
  803.     }
  804.   fprintf (logfile, ")\n");
  805. #endif /* TRAP */
  806. }
  807. #endif /* not TeX */
  808.