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