dvitomp fix from Akira

[mplib] / src / texk / web2c / mpdir / mpxout.w

% $Id$\r
%\r
% Copyright 2008 Taco Hoekwater.\r
%\r
% This program is free software: you can redistribute it and/or modify\r
% it under the terms of the GNU General Public License as published by\r
% the Free Software Foundation, either version 2 of the License, or\r
% (at your option) any later version.\r
%\r
% This program is distributed in the hope that it will be useful,\r
% but WITHOUT ANY WARRANTY; without even the implied warranty of\r
% MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the\r
% GNU General Public License for more details.\r
%\r
% You should have received a copy of the GNU General Public License\r
% along with this program.  If not, see <http://www.gnu.org/licenses/>.\r
\r
\def\title{Creating mpx files}\r
\def\hang{\hangindent 3em\indent\ignorespaces}\r
\def\MP{MetaPost}\r
\def\LaTeX{{\rm L\kern-.36em\raise.3ex\hbox{\sc a}\kern-.15em\r
    T\kern-.1667em\lower.7ex\hbox{E}\kern-.125emX}}\r
\r
\def\(#1){} % this is used to make section names sort themselves better\r
\def\9#1{} % this is used for sort keys in the index\r
\def\[#1]{#1.}\r
\r
\pdfoutput=1\r
\r
@* \[1] Makempx overview.\r
\r
This source file implements the makempx functionality for the new \MP.\r
It includes all of the functional code from the old standalone programs\r
\r
\item{}mpto\r
\item{}dmp\r
\item{}dvitomp\r
\item{}makempx\r
\r
combined into one, with many changes to make all of the code cooperate\r
nicely.\r
\r
@ Header files\r
\r
The local C preprocessor definitions have to come after the C includes\r
in order to prevent name clashes.\r
\r
@c\r
#include "config.h"\r
#include <stdio.h>\r
#include <stdlib.h>\r
#include <string.h>\r
#include <stdarg.h>\r
#include <assert.h>\r
#include <setjmp.h>\r
#include <errno.h> /* TODO autoconf ? */\r
/* unistd.h is needed for every non-Win32 platform, and we assume\r
 * that implies that sys/types.h is also present \r
 */\r
#ifndef WIN32\r
#include <sys/types.h>\r
#include <unistd.h>\r
#endif\r
/* processes */\r
#ifdef WIN32\r
#include <io.h>\r
#include <process.h>\r
#else\r
#if HAVE_SYS_WAIT_H\r
# include <sys/wait.h>\r
#endif\r
#ifndef WEXITSTATUS\r
# define WEXITSTATUS(stat_val) ((unsigned)(stat_val) >> 8)\r
#endif\r
#ifndef WIFEXITED\r
# define WIFEXITED(stat_val) (((stat_val) & 255) == 0)\r
#endif\r
#endif\r
/* directories */\r
#ifdef WIN32\r
#include <direct.h>\r
#else\r
#if HAVE_DIRENT_H\r
# include <dirent.h>\r
#else\r
# define dirent direct\r
# if HAVE_SYS_NDIR_H\r
#  include <sys/ndir.h>\r
# endif\r
# if HAVE_SYS_DIR_H\r
#  include <sys/dir.h>\r
# endif\r
# if HAVE_NDIR_H\r
#  include <ndir.h>\r
# endif\r
#endif\r
#endif\r
#if HAVE_SYS_STAT_H\r
#include <sys/stat.h>\r
#endif\r
#include <ctype.h>\r
#include <time.h>\r
#include <math.h>\r
#define trunc(x)   ((integer) (x))\r
#define fabs(x)    ((x)<0?(-(x)):(x))\r
#define floor(x)   ((integer) (fabs(x)))\r
#ifndef PI\r
#define PI  3.14159265358979323846\r
#endif\r
#include "avl.h"\r
#include "mpxout.h"\r
@h\r
\r
@ Data types\r
\r
From the Pascal code of DVItoMP two implicit types are inherited: |boolean| and\r
|integer|. \r
\r
The more complex datatypes are defined in the following sections. \r
\r
@d true 1\r
@d false 0\r
\r
@c\r
typedef signed int integer;\r
typedef signed int boolean;\r
@<C Data Types@>\r
@<Declarations@>\r
\r
@ The single most important data structure is the structure\r
|mpx_data|.  It contains all of the global state for a specific\r
|makempx| run. A pointer to it is passed as the first argument to just\r
about every function call.\r
\r
One of the fields is a bit special because it is so important: |mode|\r
is the decider between running \TeX\ or Troff as the typesetting\r
engine.\r
\r
@(mpxout.h@>=\r
typedef enum {\r
  mpx_tex_mode=0,\r
  mpx_troff_mode=1 \r
} mpx_modes;\r
typedef struct mpx_data * MPX;\r
\r
@ @<C Data Types@>=\r
@<Types in the outer block@>\r
typedef struct mpx_data {\r
  int mode;\r
  @<Globals@>\r
} mpx_data ;\r
\r
@ Here are some macros for common programming idioms.\r
\r
@d MAXINT 0x7FFFFF /* somewhat arbitrary */\r
\r
@d incr(A)   (A)=(A)+1 /* increase a variable by unity */\r
@d decr(A)   (A)=(A)-1 /* decrease a variable by unity */\r
\r
@ Once an MPX object is allocated, the memory it occupies needs to be\r
initialized to a usable state. This procedure gets things started\r
properly.\r
\r
This function is not allowed to run |mpx_abort| because at this\r
point the jump buffer is not yet initialized, so it should only\r
be used for things that cannot go wrong!\r
\r
@c\r
static void mpx_initialize (MPX mpx) {\r
  memset(mpx,0,sizeof(struct mpx_data));\r
  @<Set initial values@>@/\r
}\r
\r
@ A global variable |history| keeps track of what type of errors have\r
occurred with the hope that that \MP\ can be warned of any problems.\r
\r
@<Types...@>=\r
enum mpx_history_states {\r
 mpx_spotless=0, /* |history| value when no problems have been found */\r
 mpx_cksum_trouble, /* |history| value there have been font checksum mismatches */\r
 mpx_warning_given, /* |history| value after a recoverable error */\r
 mpx_fatal_error /* |history| value if processing had to be aborted */\r
};\r
\r
\r
@ @<Glob...@>=\r
int history;\r
\r
@ @<Set init...@>=\r
mpx->history=mpx_spotless;\r
\r
@ The structure has room for the names and the |FILE *| for the \r
input and output files. The most important ones are listed here,\r
the variables for the intermediate files are declared where they\r
are needed.\r
\r
@<Globals@>=\r
char *banner;\r
char *mpname;\r
FILE *mpfile;\r
char *mpxname;\r
FILE *mpxfile;\r
FILE *errfile;\r
int lnno ;           /* current line number */\r
\r
@ A set of basic reporting functions. \r
\r
@c\r
static void mpx_printf(MPX mpx, char *header, char *msg, va_list ap) {\r
  fprintf(mpx->errfile, "makempx %s: %s:", header, mpx->mpname);\r
  if (mpx->lnno!=0)\r
    fprintf(mpx->errfile, "%d:", mpx->lnno);\r
  fprintf(mpx->errfile, " ");\r
  (void)vfprintf(mpx->errfile, msg, ap);\r
  fprintf(mpx->errfile, "\n");\r
}\r
\r
@ @c\r
static void mpx_report(MPX mpx, char *msg, ...) {\r
  va_list ap;\r
  if (mpx->debug==0) return;\r
  va_start(ap, msg);\r
  mpx_printf(mpx, "debug", msg, ap);\r
  va_end(ap);\r
  if ( mpx->history < mpx_warning_given ) \r
    mpx->history=mpx_cksum_trouble;\r
}\r
 \r
@ @c\r
static void mpx_warn(MPX mpx, char *msg, ...) {\r
  va_list ap;\r
  va_start(ap, msg);\r
  mpx_printf(mpx, "warning", msg, ap);\r
  va_end(ap);\r
  if ( mpx->history < mpx_warning_given ) \r
    mpx->history=mpx_cksum_trouble;\r
}\r
\r
@ @c\r
static void mpx_error(MPX mpx, char *msg, ...) {\r
  va_list ap;\r
  va_start(ap, msg);\r
  mpx_printf(mpx, "error", msg, ap);\r
  va_end(ap);\r
  mpx->history=mpx_warning_given;\r
}\r
\r
@  The program uses a |jump_buf| to handle non-local returns, \r
this is initialized at a single spot: the start of |mp_makempx|.\r
\r
@d mpx_jump_out longjmp(mpx->jump_buf,1)\r
\r
@<Glob...@>=\r
jmp_buf jump_buf;\r
\r
@ \r
@c\r
static void mpx_abort(MPX mpx, char *msg, ...) {\r
  va_list ap;\r
  va_start(ap, msg);\r
  mpx_printf(mpx, "fatal", msg, ap);\r
  va_end(ap);\r
  mpx->history=mpx_fatal_error;\r
  mpx_erasetmp(mpx);\r
  mpx_jump_out;\r
}\r
\r
@ @<Install and test the non-local jump buffer@>=\r
if (setjmp(mpx->jump_buf) != 0) { \r
  int h = mpx->history;\r
  xfree(mpx->buf);\r
  xfree(mpx->maincmd);\r
  xfree(mpx->mpname);\r
  xfree(mpx->mpxname);\r
  xfree(mpx);\r
  return h; \r
}\r
\r
@ @c\r
static FILE *mpx_xfopen (MPX mpx, char *fname, char *fmode) {\r
  FILE *f  = fopen(fname,fmode);\r
  if (f == NULL)\r
    mpx_abort(mpx,"File open error for %s in mode %s", fname, fmode);\r
  return f;\r
}\r
static void mpx_fclose (MPX mpx, FILE *file) {\r
  (void)mpx;\r
  (void)fclose(file);\r
}\r
\r
@ \r
@d xfree(A) do { mpx_xfree(A); A=NULL; } while (0)\r
@d xrealloc(P,A,B) mpx_xrealloc(mpx,P,A,B)\r
@d xmalloc(A,B)  mpx_xmalloc(mpx,A,B)\r
@d xstrdup(A)  mpx_xstrdup(mpx,A)\r
\r
@<Declarations@>=\r
static void mpx_xfree (void *x);\r
static void *mpx_xrealloc (MPX mpx, void *p, size_t nmem, size_t size) ;\r
static void *mpx_xmalloc (MPX mpx, size_t nmem, size_t size) ;\r
static char *mpx_xstrdup(MPX mpX, const char *s);\r
\r
\r
@ The |max_size_test| guards against overflow, on the assumption that\r
|size_t| is at least 31bits wide.\r
\r
@d max_size_test 0x7FFFFFFF\r
\r
@c\r
static void mpx_xfree (void *x) {\r
  if (x!=NULL) free(x);\r
}\r
static void  *mpx_xrealloc (MPX mpx, void *p, size_t nmem, size_t size) {\r
  void *w ; \r
  if ((max_size_test/size)<nmem) {\r
    mpx_abort(mpx,"Memory size overflow");\r
  }\r
  w = realloc (p,(nmem*size));\r
  if (w==NULL) mpx_abort(mpx,"Out of Memory");\r
  return w;\r
}\r
static void  *mpx_xmalloc (MPX mpx, size_t nmem, size_t size) {\r
  void *w;\r
  if ((max_size_test/size)<nmem) {\r
    mpx_abort(mpx,"Memory size overflow");\r
  }\r
  w = malloc (nmem*size);\r
  if (w==NULL) mpx_abort(mpx,"Out of Memory");\r
  return w;\r
}\r
static char *mpx_xstrdup(MPX mpx, const char *s) {\r
  char *w; \r
  if (s==NULL)\r
    return NULL;\r
  w = strdup(s);\r
  if (w==NULL) mpx_abort(mpx,"Out of Memory");\r
  return w;\r
}\r
@* The command 'newer' became a function.\r
\r
We may have high-res timers in struct stat.  If we do, use them. \r
\r
@c\r
static int mpx_newer(char *source, char *target) {\r
    struct stat source_stat, target_stat;\r
#if HAVE_SYS_STAT_H\r
    if (stat(target, &target_stat) < 0) return 0; /* true */\r
    if (stat(source, &source_stat) < 0) return 1; /* false */\r
#if HAVE_ST_MTIM\r
    if (source_stat.st_mtim.tv_sec > target_stat.st_mtim.tv_sec || \r
         (source_stat.st_mtim.tv_sec  == target_stat.st_mtim.tv_sec && \r
          source_stat.st_mtim.tv_nsec >+ target_stat.st_mtim.tv_nsec))\r
          return 0;\r
#else\r
    if (source_stat.st_mtime >= target_stat.st_mtime)\r
          return 0;\r
#endif\r
#endif\r
    return 1;\r
}\r
\r
\r
\r
@* Extracting data from \MP\ input.\r
\r
This part of the program transforms a \MP\ input file into a \TeX\ or\r
troff input file by stripping out \.{btex}$\ldots$\.{etex} and \r
\.{verbatimtex}$\ldots$\.{etex} sections.  \r
Leading and trailing spaces and tabs are removed from the\r
extracted material and it is surrounded by the preceding and following\r
strings defined immediately below.  The input file should be given as\r
argument 1 and the resulting \TeX\ or troff file is written on standard\r
output.\r
\r
John Hobby wrote the original version, which has since been\r
extensively altered. The current implementation is a bit trickier \r
than I would like, but changing it will take careful study and \r
will likely make it run slower, so I've left it as-is for now.\r
\r
@<Globals@>=\r
int texcnt ;         /* btex..etex blocks so far */\r
int verbcnt ;        /* verbatimtex..etex blocks so far */\r
char *bb, *tt, *aa;     /* start of before, token, and after strings */\r
char *buf;      /* the input line */\r
unsigned bufsize;\r
\r
@ @<Set initial values@>=\r
mpx->bufsize = 1000;\r
\r
@ This function returns NULL on EOF, otherwise it returns |buf|. \r
\r
@c \r
static char *mpx_getline(MPX mpx, FILE *mpfile) {\r
    int c;\r
    unsigned loc = 0;\r
    if (feof(mpfile))\r
      return NULL; \r
    if (mpx->buf==NULL)\r
      mpx->buf = xmalloc(mpx->bufsize,1);\r
    while ((c = getc(mpfile)) != EOF && c != '\n' && c != '\r') {\r
      mpx->buf[loc++] = c;\r
      if (loc == mpx->bufsize) {\r
        char *temp = mpx->buf;\r
        unsigned n = mpx->bufsize + (mpx->bufsize>>4);\r
        if (n>MAXINT) \r
          mpx_abort(mpx,"Line is too long");\r
        mpx->buf = xmalloc(n,1);\r
        memcpy(mpx->buf,temp,mpx->bufsize);\r
        free(temp);\r
        mpx->bufsize = n;\r
      }\r
    }\r
    mpx->buf[loc] = 0;\r
    if (c == '\r') {\r
        c = getc(mpfile);\r
        if (c != '\n')\r
            ungetc(c, mpfile);\r
    }\r
    mpx->lnno++;\r
    return mpx->buf;\r
}\r
\r
\r
@ Return nonzero if a prefix of string $s$ matches the null-terminated string $t$\r
and the next character is not a letter or an underscore.\r
\r
@c\r
static int mpx_match_str(char *s, char *t) {\r
    while (*t != 0) {\r
        if (*s != *t)\r
            return 0;\r
        s++;       \r
        t++;    \r
    }\r
    if ((*s>= 'a' && *s<='z') || (*s>= 'A' && *s<='Z') || *s == '_')\r
        return 0;\r
    return 1;\r
}\r
\r
\r
@ This function tries to express $s$ as the concatenation of three\r
strings $b$, $t$, $a$, with the global pointers $bb$, $tt$, and $aa$ set to the\r
start of the corresponding strings.  String $t$ is either a quote mark,\r
a percent sign, or an alphabetic token \.{btex}, \.{etex}, or\r
\.{verbatimtex}.  (An alphabetic token is a maximal sequence of letters\r
and underscores.)  If there are several possible substrings $t$, we\r
choose the leftmost one.  If there is no such $t$, we set $b=s$ and return 0.\r
 \r
@c\r
static int mpx_getbta(MPX mpx, char *s) {\r
  int ok = 1;         /* zero if last character was |a-z|, |A-Z|, or |_| */\r
  mpx->bb = s;\r
  for (mpx->tt = mpx->bb; *(mpx->tt) != 0; mpx->tt++) {\r
    switch (*(mpx->tt)) {\r
    case '"':\r
    case '%':\r
        mpx->aa = mpx->tt + 1;\r
        return 1;\r
    case 'b':\r
        if (ok && mpx_match_str(mpx->tt, "btex")) {\r
        mpx->aa = mpx->tt + 4;\r
        return 1;\r
        } else\r
        ok = 0;\r
        break;\r
    case 'e':\r
        if (ok && mpx_match_str(mpx->tt, "etex")) {\r
        mpx->aa = mpx->tt + 4;\r
        return 1;\r
        } else\r
        ok = 0;\r
        break;\r
    case 'v':\r
        if (ok && mpx_match_str(mpx->tt, "verbatimtex")) {\r
        mpx->aa = mpx->tt + 11;\r
        return 1;\r
        } else\r
        ok = 0;\r
        break;\r
    default:\r
       if ((*(mpx->tt) >= 'a' && *(mpx->tt) <= 'z') ||\r
           (*(mpx->tt) >= 'A' && *(mpx->tt) <= 'Z') ||\r
           (*(mpx->tt) == '_'))\r
         ok = 0;\r
       else\r
         ok = 1;\r
     }\r
  }\r
  mpx->aa = mpx->tt;\r
  return 0;\r
}\r
\r
@ @c\r
static void mpx_copy_mpto (MPX mpx, FILE *outfile) {\r
    char *s;            /* where a string to print stops */\r
    char *t;            /* for finding start of last line */\r
    char c;\r
    char *res = NULL;\r
    do {\r
    if (*mpx->aa == 0) {\r
      if ((mpx->aa = mpx_getline(mpx,mpx->mpfile)) == NULL) {\r
        mpx_error(mpx,"btex section does not end"); \r
      }\r
    }\r
    if (mpx_getbta(mpx, mpx->aa) && *(mpx->tt) == 'e') {\r
      s = mpx->tt;\r
    } else {\r
      if (*(mpx->tt) == 'b')\r
      mpx_error(mpx,"btex in TeX mode");\r
      if (*(mpx->tt) == 'v')\r
      mpx_error(mpx,"verbatimtex in TeX mode");\r
      s = mpx->aa;\r
    }\r
    c = *s;\r
    *s = 0;\r
    if (res==NULL) {\r
      res = xmalloc(strlen(mpx->bb)+2,1);\r
      res = strncpy(res,mpx->bb,(strlen(mpx->bb)+1));\r
    } else {\r
      res = xrealloc(res,strlen(res)+strlen(mpx->bb)+2,1);\r
      res = strncat(res,mpx->bb, strlen(mpx->bb));\r
    }\r
    if (c == '\0')\r
        res = strncat(res, "\n", 1);\r
    *s = c;\r
    } while (*(mpx->tt) != 'e');\r
    /* whitespace at the end */\r
    for (s = res + strlen(res) - 1;\r
         s >= res && (*s == ' ' || *s == '\t' || *s == '\r' || *s == '\n'); s--);\r
    t = s;\r
    *(++s) = '\0';\r
    /* whitespace at the start */\r
    for (s = res;\r
         s < (res + strlen(res)) && (*s == ' ' || *s == '\t' || *s == '\r'\r
                     || *s == '\n'); s++);\r
    for (; *t != '\n' && t > s; t--);\r
    fprintf(outfile,"%s", s);\r
    /* put no |%| at end if it's only 1 line total, starting with |%|;\r
     * this covers the special case |%&format| in a single line. */\r
    if (t != s || *t != '%')\r
    fprintf(outfile,"%%");\r
    free(res);\r
}\r
\r
\r
@ Static strings for mpto\r
\r
@c\r
static const char *mpx_predoc[]  = {"", ".po 0\n"};\r
static const char *mpx_postdoc[] = { "\\end{document}\n", ""};\r
static const char *mpx_pretex1[] = { \r
    "\\gdef\\mpxshipout{\\shipout\\hbox\\bgroup%\n"\r
    "  \\setbox0=\\hbox\\bgroup}%\n"\r
    "\\gdef\\stopmpxshipout{\\egroup"\r
    "  \\dimen0=\\ht0 \\advance\\dimen0\\dp0\n"\r
    "  \\dimen1=\\ht0 \\dimen2=\\dp0\n"\r
    "  \\setbox0=\\hbox\\bgroup\n"\r
    "    \\box0\n"\r
    "    \\ifnum\\dimen0>0 \\vrule width1sp height\\dimen1 depth\\dimen2 \n"\r
    "    \\else \\vrule width1sp height1sp depth0sp\\relax\n"\r
    "    \\fi\\egroup\n"\r
    "  \\ht0=0pt \\dp0=0pt \\box0 \\egroup}\n"\r
    "\\mpxshipout%% line %d %s\n", ".lf %d %s\n" };\r
static const char *mpx_pretex[] = { "\\mpxshipout%% line %d %s\n", ".bp\n.lf %d %s\n" };\r
static const char *mpx_posttex[] = { "\n\\stopmpxshipout\n", "\n" };\r
static const char *mpx_preverb1[] = {"", ".lf %d %s\n" };    /* if very first instance */\r
static const char *mpx_preverb[] = { "%% line %d %s\n", ".lf %d %s\n"};  /* all other instances */\r
static const char *mpx_postverb[] = { "\n", "\n" } ;\r
\r
@ @c\r
static void mpx_mpto(MPX mpx, char *tmpname, char *mptexpre) {\r
    FILE *outfile;\r
    int mode      = mpx->mode;\r
    char *mpname  = mpx->mpname; \r
    if (mode==mpx_tex_mode) {\r
       TMPNAME_EXT(mpx->tex,".tex");\r
    } else {\r
       TMPNAME_EXT(mpx->tex,".i");\r
    }\r
    outfile  = mpx_xfopen(mpx,mpx->tex, "wb");\r
    if (mode==mpx_tex_mode) {\r
      FILE *fr;\r
      if ((fr = fopen(mptexpre, "r"))!= NULL) {\r
            while (mpx_getline(mpx, fr) != NULL)\r
              fputs(mpx->buf, outfile);\r
            mpx_fclose(mpx,fr);\r
      }\r
    }\r
    mpx->mpfile   = mpx_xfopen(mpx,mpname, "r");\r
    fprintf(outfile,"%s", mpx_predoc[mode]);\r
    while (mpx_getline(mpx, mpx->mpfile) != NULL)\r
        @<Do a line@>;\r
    fprintf(outfile,"%s", mpx_postdoc[mode]);\r
    mpx_fclose(mpx,mpx->mpfile);\r
    mpx_fclose(mpx,outfile);\r
    mpx->lnno = 0;\r
}\r
\r
@ \r
@<Do a line@>=\r
{\r
  mpx->aa = mpx->buf;\r
  while (mpx_getbta(mpx, mpx->aa)) {\r
    if (*(mpx->tt) == '%') {\r
      break;\r
    } else if (*(mpx->tt) == '"') {\r
      do {\r
        if (!mpx_getbta(mpx, mpx->aa))\r
          mpx_error(mpx,"string does not end");\r
      } while (*(mpx->tt) != '"');\r
    } else if (*(mpx->tt) == 'b') {\r
      if (mpx->texcnt++ == 0)\r
        fprintf(outfile,mpx_pretex1[mode], mpx->lnno, mpname);\r
      else\r
        fprintf(outfile,mpx_pretex[mode], mpx->lnno, mpname);\r
      mpx_copy_mpto(mpx, outfile);\r
      fprintf(outfile,"%s", mpx_posttex[mode]);\r
    } else if (*(mpx->tt) == 'v') {\r
      if (mpx->verbcnt++ == 0 && mpx->texcnt == 0)\r
        fprintf(outfile,mpx_preverb1[mode], mpx->lnno, mpname);\r
      else\r
        fprintf(outfile,mpx_preverb[mode], mpx->lnno, mpname);\r
      mpx_copy_mpto(mpx, outfile);\r
      fprintf(outfile,"%s", mpx_postverb[mode]);\r
    } else {\r
      mpx_error(mpx,"unmatched etex");\r
    }\r
  }\r
}\r
\r
@ @<Run |mpto| on the mp file@>=\r
mpx_mpto(mpx, tmpname, mpxopt->mptexpre)\r
\r
@* DVItoMP Processing.\r
\r
The \.{DVItoMP} program reads binary device-independent (``\.{DVI}'')\r
files that are produced by document compilers such as \TeX, and converts them\r
into a symbolic form understood by \MP.  It is loosely based on the \.{DVItype}\r
utility program that produces a more faithful symbolic form of a \.{DVI} file.\r
\r
The output file is a sequence of \MP\ picture expressions, one for every page\r
in the \.{DVI} file.  It makes no difference to \.{DVItoMP} where the \.{DVI}\r
file comes from, but it is intended to process the result of running \TeX\\r
or \LaTeX\ on the output of the extraction process that is defined above.  \r
Such a \.{DVI} file will contain one page for every \.{btex}$\ldots$\.{etex} \r
block in the original input.  Processing with \.{DVItoMP} creates a \r
corresponding sequence of \MP\ picture expressions for use as an auxiliary \r
input file.  Since \MP\ expects such files to have the extension \.{.MPX}, \r
the output of \.{DVItoMP} is sometimes called an ``\.{MPX}'' file.\r
\r
@ The following parameters can be changed at compile time to extend or\r
reduce \.{DVItoMP}'s capacity. \r
\r
TODO: dynamic reallocation\r
\r
@d virtual_space 1000000 /* maximum total bytes of typesetting commands for virtual fonts */\r
@d max_fonts 1000 /* maximum number of distinct fonts per \.{DVI} file */\r
@d max_fnums 3000 /* maximum number of fonts plus fonts local to virtual fonts */\r
@d max_widths (256*max_fonts) /* maximum number of different characters among all fonts */\r
@d line_length 79 /* maximum output line length (must be at least 60) */\r
@d stack_size 100 /* \.{DVI} files shouldn't |push| beyond this depth */\r
@d font_tolerance 0.00001\r
  /* font sizes should match to within this multiple of $2^{20}$ \.{DVI} units */\r
\r
@ If the \.{DVI} file is badly malformed, the whole process must be aborted;\r
\.{DVItoMP} will give up, after issuing an error message about the symptoms\r
that were noticed.\r
\r
@d bad_dvi(A)       mpx_abort(mpx,"Bad DVI file: " A "!")\r
@d bad_dvi_two(A,B) mpx_abort(mpx,"Bad DVI file: %s !", A, B)\r
@.Bad DVI file@>\r
\r
@* The character set.\r
\r
Like all programs written with the  \.{WEB} system, \.{DVItoMP} can be\r
used with any character set. It an identify transfrom internally, because\r
the programming for portable input-output is easier when a fixed internal\r
code is used, and because \.{DVI} files use ASCII code for file names.\r
\r
In the conversion from Pascal to C, the |xchr| array has been removed.\r
Because some systems may still want to change the input--output character\r
set, the accesses to |xchr| and |printable| are replaced by macro calls.\r
\r
@d printable(c) (isprint(c) && c < 128 && c!='"')\r
@d xchr(A) (A)\r
\r
@ @c \r
static void mpx_open_mpxfile (MPX mpx) { /* prepares to write text on |mpxfile| */\r
   mpx->mpxfile = mpx_xfopen (mpx,mpx->mpxname, "wb");\r
}\r
\r
@* Device-independent file format.\r
The format of \.{DVI} files is described in many places including\r
\.{dvitype.web} and Volume~B of D.~E. Knuth's {\sl Computers and Typesetting}.\r
This program refers to the following command codes.\r
\r
@d id_byte 2 /* identifies the kind of \.{DVI} files described here */\r
@#\r
@d set_char_0 0 /* typeset character 0 and move right */\r
@d set1 128 /* typeset a character and move right */\r
@d set_rule 132 /* typeset a rule and move right */\r
@d put1 133 /* typeset a character */\r
@d put_rule 137 /* typeset a rule */\r
@d nop 138 /* no operation */\r
@d bop 139 /* beginning of page */\r
@d eop 140 /* ending of page */\r
@d push 141 /* save the current positions */\r
@d pop 142 /* restore previous positions */\r
@d right1 143 /* move right */\r
@d w0 147 /* move right by |w| */\r
@d w1 148 /* move right and set |w| */\r
@d x0 152 /* move right by |x| */\r
@d x1 153 /* move right and set |x| */\r
@d down1 157 /* move down */\r
@d y0 161 /* move down by |y| */\r
@d y1 162 /* move down and set |y| */\r
@d z0 166 /* move down by |z| */\r
@d z1 167 /* move down and set |z| */\r
@d fnt_num_0 171 /* set current font to 0 */\r
@d fnt1 235 /* set current font */\r
@d xxx1 239 /* extension to \.{DVI} primitives */\r
@d xxx4 242 /* potentially long extension to \.{DVI} primitives */\r
@d fnt_def1 243 /* define the meaning of a font number */\r
@d pre 247 /* preamble */\r
@d post 248 /* postamble beginning */\r
@d post_post 249 /* postamble ending */\r
@d undefined_commands 250: case 251: case 252: case 253: case 254: case 255\r
\r
@* Input from binary files.\r
\r
@ The program deals with two binary file variables: |dvi_file| is the main\r
input file that we are translating into symbolic form, and |tfm_file| is\r
the current font metric file from which character-width information is\r
being read.  It is convenient to have a throw-away variable for function\r
results when reading parts of the files that are being skipped.\r
\r
@<Glob...@>=\r
FILE * dvi_file; /* the input file */\r
FILE * tfm_file; /* a font metric file */\r
FILE * vf_file; /* a virtual font file */\r
\r
@ Prepares to read packed bytes in |dvi_file|\r
@c \r
static void mpx_open_dvi_file (MPX mpx) {\r
    mpx->dvi_file = fopen(mpx->dviname,"rb");\r
    if (mpx->dvi_file==NULL)\r
      mpx_abort(mpx,"DVI generation failed");\r
}\r
\r
@ Prepares to read packed bytes in |tfm_file|\r
@c \r
static boolean mpx_open_tfm_file (MPX mpx) { \r
  mpx->tfm_file = mpx_fsearch(mpx, mpx->cur_name, mpx_tfm_format);\r
  if (mpx->tfm_file == NULL)\r
          mpx_abort(mpx,"Cannot find TFM %s", mpx->cur_name);\r
  free (mpx->cur_name); /* We |xmalloc|'d this before we got called. */\r
  return true; /* If we get here, we succeeded. */\r
}\r
\r
@ Prepares to read packed bytes in |vf_file|. \r
It's ok if the \.{VF} file doesn't exist.\r
\r
@c \r
static boolean mpx_open_vf_file (MPX mpx) {\r
  mpx->vf_file = mpx_fsearch(mpx, mpx->cur_name, mpx_vf_format);\r
  if (mpx->vf_file) {\r
    free (mpx->cur_name);\r
    return true;\r
  } \r
  return false;\r
}\r
\r
@ If you looked carefully at the preceding code, you probably asked,\r
``What is |cur_name|?'' Good question. It's a global\r
variable: |cur_name| is a string variable that will be set to the\r
current font metric file name before |open_tfm_file| or |open_vf_file|\r
is called.\r
\r
@<Glob...@>=\r
char *cur_name; /* external name */\r
\r
@ It turns out to be convenient to read four bytes at a time, when we are\r
inputting from \.{TFM} files. The input goes into global variables\r
|b0|, |b1|, |b2|, and |b3|, with |b0| getting the first byte and |b3|\r
the fourth.\r
\r
@<Glob...@>=\r
int b0, b1, b2, b3; /* four bytes input at once */\r
\r
@ The |read_tfm_word| procedure sets |b0| through |b3| to the next\r
four bytes in the current \.{TFM} file.\r
\r
@c \r
static void mpx_read_tfm_word (MPX mpx) { \r
  mpx->b0 = getc(mpx->tfm_file); \r
  mpx->b1 = getc(mpx->tfm_file);\r
  mpx->b2 = getc(mpx->tfm_file);\r
  mpx->b3 = getc(mpx->tfm_file);\r
}\r
\r
@ Input can come from from three different sources depending on the settings\r
of global variables.  When |vf_reading| is true, we read from the \.{VF} file.\r
Otherwise, input can either come directly from |dvi_file| or from a buffer\r
|cmd_buf|.  The latter case applies whenever |buf_ptr<virtual_space|.\r
\r
@<Glob...@>=\r
boolean vf_reading; /* should input come from |vf_file|? */\r
unsigned char cmd_buf[(virtual_space+1)]; /* commands for virtual characters */\r
unsigned int buf_ptr; /* |cmd_buf| index for the next byte */\r
\r
@ @<Set init...@>=\r
mpx->vf_reading=false;\r
mpx->buf_ptr=virtual_space;\r
\r
@ We shall use a set of simple functions to read the next byte or bytes from the\r
current input source. There are seven possibilities, each of which is treated\r
as a separate function in order to minimize the overhead for subroutine calls.\r
\r
@c \r
static integer mpx_get_byte (MPX mpx) { /* returns the next byte, unsigned */\r
  unsigned char b;\r
  @<Read one byte into |b|@>;\r
  return b;\r
}\r
\r
static integer mpx_signed_byte (MPX mpx) { /* returns the next byte, signed */ \r
  unsigned char b;\r
  @<Read one byte into |b|@>;\r
  return ( b<128 ? b : (b-256));\r
}\r
\r
static integer mpx_get_two_bytes (MPX mpx) { /* returns the next two bytes, unsigned */\r
  unsigned char a,b;\r
  a=0; b=0; /* for compiler warnings */\r
  @<Read two bytes into |a| and |b|@>;\r
  return (a*(int)(256)+b);\r
}\r
\r
static integer mpx_signed_pair (MPX mpx) { /* returns the next two bytes, signed */\r
  unsigned char a,b;\r
  a=0; b=0; /* for compiler warnings */\r
  @<Read two bytes into |a| and |b|@>;\r
  if ( a<128 ) return (a*256+b);\r
  else return ((a-256)*256+b);\r
}\r
\r
static integer mpx_get_three_bytes (MPX mpx) { /* returns the next three bytes, unsigned */\r
  unsigned char a,b,c;\r
  a=0; b=0; c=0; /* for compiler warnings */\r
  @<Read three bytes into |a|, |b|, and~|c|@>;\r
  return ((a*(int)(256)+b)*256+c);\r
}\r
\r
static integer mpx_signed_trio (MPX mpx) { /* returns the next three bytes, signed */\r
  unsigned char a,b,c;\r
  a=0; b=0; c=0; /* for compiler warnings */\r
  @<Read three bytes into |a|, |b|, and~|c|@>;\r
  if ( a<128 ) return ((a*(int)(256)+b)*256+c);\r
  else  return (((a-(int)(256))*256+b)*256+c);\r
}\r
\r
static integer mpx_signed_quad (MPX mpx) { /* returns the next four bytes, signed */\r
  unsigned char a,b,c,d;\r
  a=0; b=0; c=0; d=0; /* for compiler warnings */\r
  @<Read four bytes into |a|, |b|, |c|, and~|d|@>;\r
  if ( a<128 ) return (((a*(int)(256)+b)*256+c)*256+d);\r
  else return ((((a-256)*(int)(256)+b)*256+c)*256+d);\r
}\r
\r
@ @<Read one byte into |b|@>=\r
if ( mpx->vf_reading ) {\r
  b = (unsigned char)getc(mpx->vf_file);\r
} else if ( mpx->buf_ptr==virtual_space ) {\r
  b = (unsigned char)getc(mpx->dvi_file);\r
} else { \r
  b=mpx->cmd_buf[mpx->buf_ptr];\r
  incr(mpx->buf_ptr);\r
}\r
\r
@ @<Read two bytes into |a| and |b|@>=\r
if ( mpx->vf_reading ) { \r
  a = (unsigned char)getc(mpx->vf_file);\r
  b = (unsigned char)getc(mpx->vf_file);\r
} else if ( mpx->buf_ptr==virtual_space ) { \r
  a = (unsigned char)getc(mpx->dvi_file);\r
  b = (unsigned char)getc(mpx->dvi_file);\r
} else if ( mpx->buf_ptr+2>mpx->n_cmds ) {\r
  mpx_abort(mpx,"Error detected while interpreting a virtual font");\r
@.Error detected while...@>\r
} else { \r
  a=mpx->cmd_buf[mpx->buf_ptr];\r
  b=mpx->cmd_buf[mpx->buf_ptr+1];\r
  mpx->buf_ptr+=2;\r
}\r
\r
@ @<Read three bytes into |a|, |b|, and~|c|@>=\r
if ( mpx->vf_reading ) { \r
  a = (unsigned char)getc(mpx->vf_file);\r
  b = (unsigned char)getc(mpx->vf_file);\r
  c = (unsigned char)getc(mpx->vf_file);\r
} else if ( mpx->buf_ptr==virtual_space ) { \r
  a = (unsigned char)getc(mpx->dvi_file);\r
  b = (unsigned char)getc(mpx->dvi_file);\r
  c = (unsigned char)getc(mpx->dvi_file);\r
} else if ( mpx->buf_ptr+3>mpx->n_cmds ) {\r
  mpx_abort(mpx,"Error detected while interpreting a virtual font");\r
@.Error detected while...@>\r
} else { \r
  a=mpx->cmd_buf[mpx->buf_ptr];\r
  b=mpx->cmd_buf[mpx->buf_ptr+1];\r
  c=mpx->cmd_buf[mpx->buf_ptr+2];\r
  mpx->buf_ptr+=3;\r
}\r
\r
@ @<Read four bytes into |a|, |b|, |c|, and~|d|@>=\r
if ( mpx->vf_reading ) { \r
  a = (unsigned char)getc(mpx->vf_file);\r
  b = (unsigned char)getc(mpx->vf_file);\r
  c = (unsigned char)getc(mpx->vf_file);\r
  d = (unsigned char)getc(mpx->vf_file);\r
} else if ( mpx->buf_ptr==virtual_space ) { \r
  a = (unsigned char)getc(mpx->dvi_file);\r
  b = (unsigned char)getc(mpx->dvi_file);\r
  c = (unsigned char)getc(mpx->dvi_file);\r
  d = (unsigned char)getc(mpx->dvi_file);\r
} else if ( mpx->buf_ptr+4>mpx->n_cmds ) {\r
  mpx_abort(mpx,"Error detected while interpreting a virtual font");\r
@.Error detected while...@>\r
} else { \r
  a=mpx->cmd_buf[mpx->buf_ptr];\r
  b=mpx->cmd_buf[mpx->buf_ptr+1];\r
  c=mpx->cmd_buf[mpx->buf_ptr+2];\r
  d=mpx->cmd_buf[mpx->buf_ptr+3];\r
  mpx->buf_ptr+=4;\r
}\r
\r
@* Data structures for fonts.\r
\r
\.{DVI} file format does not include information about character widths, since\r
that would tend to make the files a lot longer. But a program that reads\r
a \.{DVI} file is supposed to know the widths of the characters that appear\r
in \\{set\_char} commands. Therefore \.{DVItoMP} looks at the font metric\r
(\.{TFM}) files for the fonts that are involved.\r
@.TFM {\rm files}@>\r
\r
@ For purposes of this program, the only thing we need to know about a\r
given character |c| in a non-virtual font |f| is the width.  For the font as\r
a whole, all we need is the symbolic name to use in the \.{MPX} file.\r
\r
This information appears implicitly in the following data\r
structures. The current number of fonts defined is |nf|. Each such font has\r
an internal number |f|, where |0<=f<nf|.  There is also an external number\r
that identifies the font in the \.{DVI} file.  The correspondence is\r
maintained in arrays |font_num| and |internal_num| so that |font_num[i]|\r
is the external number for |f=internal_num[i]|.\r
The external name of this font is the string that occupies |font_name[f]|.\r
The legal characters run from |font_bc[f]| to |font_ec[f]|, inclusive.\r
The \.{TFM} file can specify that some of these are invalid, but this doesn't\r
concern \.{DVItoMP} because it does not do extensive error checking.\r
The width of character~|c| in font~|f| is given by\r
|char_width(f,c)=width[info_base[f]+c]|, and |info_ptr| is the\r
first unused position of the |width| array.\r
\r
If font~|f| is a virtual font, there is a list of \.{DVI} commands for each\r
character.  These occupy consecutive positions in the |cmd_buf| array with\r
the commands for character~|c| starting at\r
|start_cmd(f,c)=cmd_ptr[info_base[f]+c]| and ending just before\r
|start_cmd(f,c+1)|.  Font numbers used when interpreting these \.{DVI}\r
commands occupy positions |fbase[f]| through |ftop[f]-1| in the |font_num|\r
table and the |internal_num| array gives the corresponding internal font\r
numbers.  If such an internal font number~|i| does not correspond to\r
some font occuring in the \.{DVI} file, then |font_num[i]| has not been\r
assigned a meaningful value; this is indicated by |local_only[i]=true|.\r
\r
If font~|f| is not virtual, then |fbase[f]=0| and |ftop[f]=0|.  The |start_cmd|\r
values are ignored in this case.\r
\r
@d char_width(A,B) mpx->width[mpx->info_base[(A)]+(B)]\r
@d start_cmd(A,B) mpx->cmd_ptr[mpx->info_base[(A)]+(B)]\r
\r
@<Glob...@>=\r
integer font_num[(max_fnums+1)]; /* external font numbers */\r
integer internal_num[(max_fnums+1)]; /* internal font numbers */\r
boolean local_only[(max_fnums+1)]; /* |font_num| meaningless? */\r
char *font_name[(max_fonts+1)]; /* starting positions of external font names */\r
double font_scaled_size[(max_fonts+1)]; /* scale factors over $2^{20}$ */\r
double font_design_size[(max_fonts+1)]; /* design sizes over $2^{20}$ */\r
integer font_check_sum[(max_fonts+1)];  /* check sum from the |font_def| */\r
integer font_bc[(max_fonts+1)]; /* beginning characters in fonts */\r
integer font_ec[(max_fonts+1)]; /* ending characters in fonts */\r
integer info_base[(max_fonts+1)]; /* index into |width| and |cmd_ptr| tables */\r
integer width[(max_widths+1)];\r
  /* character widths, in units $2^{-20}$ of design size */\r
integer fbase[(max_fonts+1)]; /* index into |font_num| for local fonts */\r
integer ftop[(max_fonts+1)];  /* |font_num| index where local fonts stop */\r
integer cmd_ptr[(max_widths+1)]; /* starting positions in |cmd_buf| */\r
unsigned int nfonts; /* the number of known fonts */\r
unsigned int vf_ptr;  /* next |font_num| entry for virtual font font tables */\r
unsigned int info_ptr; /* allocation pointer for |width| and |cmd_ptr| tables */\r
unsigned int n_cmds; /* number of occupied cells in |cmd_buf| */\r
unsigned int cur_fbase, cur_ftop;\r
  /* currently applicable part of the |font_num| table */\r
\r
@ @<Set init...@>=\r
mpx->nfonts=0; mpx->info_ptr=0; mpx->font_name[0]=0;\r
mpx->vf_ptr=max_fnums;\r
mpx->cur_fbase=0; mpx->cur_ftop=0;\r
\r
@ Printing the name of a given font is easy except that a procedure |print_char|\r
is needed to actually send an |ASCII_code| to the \.{MPX} file.\r
\r
@c @<Declare subroutines for printing strings@>@;\r
static void mpx_print_font (MPX mpx, integer f) { /* |f| is an internal font number */\r
  if ( (f<0)||(f>=(int)mpx->nfonts) ) {\r
    bad_dvi("Undefined font");\r
  } else { \r
    char *s = mpx->font_name[f];\r
    while (*s) {\r
      mpx_print_char(mpx,(unsigned char)*s);\r
      s++;\r
    }\r
  }\r
}\r
\r
@ Sometimes a font name is needed as part of an error message.\r
\r
@d font_warn(A,B)  mpx_warn (mpx,"%s %s",A,mpx->font_name[(B)])\r
@d font_error(A,B) mpx_error(mpx,"%s %s",A,mpx->font_name[(B)])\r
@d font_abort(A,B) mpx_abort(mpx,"%s %s",A,mpx->font_name[(B)])\r
\r
\r
@ When we encounter a font definition, we save the name, checksum, and size\r
information, but we don't actually read the \.{TFM} or \.{VF} file until we\r
are about to use the font.  If a matching font is not already defined, we then\r
allocate a new internal font number.\r
\r
The following subroutine does the necessary things when a \\{fnt\_def} command\r
is encountered in the \.{DVI} file or in a \.{VF} file.  It assumes that the\r
first argument has already been parsed and is given by the parameter~|e|.\r
\r
@c @<Declare a function called |match_font|@>@;\r
static void mpx_define_font (MPX mpx, integer e) { /* |e| is an external font number */\r
  integer i; /* index into |font_num| and |internal_num| */\r
  integer n; /* length of the font name and area */\r
  integer k; /* general purpose loop counter */\r
  integer x;  /* a temporary value for scaled size computation */\r
  if ( mpx->nfonts==max_fonts ) \r
    mpx_abort(mpx,"DVItoMP capacity exceeded (max fonts=%d)!", max_fonts);\r
@.DVItoMP capacity exceeded...@>\r
  @<Allocate an index |i| into the |font_num| and |internal_num| tables@>;\r
  @<Read the font parameters into position for font |nf|@>;\r
  mpx->internal_num[i]=mpx_match_font(mpx, mpx->nfonts,true);\r
  if ( mpx->internal_num[i]==(int)mpx->nfonts ) {\r
    mpx->info_base[mpx->nfonts]=max_widths; /* indicate that the info isn't loaded yet */\r
    mpx->local_only[mpx->nfonts]=mpx->vf_reading; incr(mpx->nfonts);\r
  }\r
}\r
\r
@ @<Allocate an index |i| into the |font_num| and |internal_num| tables@>=\r
if ( mpx->vf_ptr==mpx->nfonts ) \r
  mpx_abort(mpx,"DVItoMP capacity exceeded (max font numbers=%d)",  max_fnums);\r
@.DVItoMP capacity exceeded...@>\r
if ( mpx->vf_reading ) { \r
  mpx->font_num[mpx->nfonts]=0; i=mpx->vf_ptr; decr(mpx->vf_ptr);\r
} else {\r
  i=mpx->nfonts;\r
}\r
mpx->font_num[i]=e\r
\r
@ @<Read the font parameters into position for font |nf|@>=\r
mpx->font_check_sum[mpx->nfonts]=mpx_signed_quad(mpx);\r
@<Read |font_scaled_size[nf]| and |font_design_size[nf]|@>;\r
n=mpx_get_byte(mpx);  /* that is the area */\r
n=n+mpx_get_byte(mpx);\r
mpx->font_name[mpx->nfonts]=xmalloc(n+1,1);\r
for (k=0;k<n;k++)\r
   mpx->font_name[mpx->nfonts][k]=mpx_get_byte(mpx);\r
mpx->font_name[mpx->nfonts][k]=0\r
\r
@ The scaled size and design size are stored in \.{DVI} units divided by $2^{20}$.\r
The units for scaled size are a little different if we are reading a virtual\r
font, but this will be corrected when the scaled size is used.  The scaled size\r
also needs to be truncated to at most 23 significant bits in order to make\r
the character width calculation match what \TeX\ does.\r
\r
@<Read |font_scaled_size[nf]| and |font_design_size[nf]|@>=\r
x=mpx_signed_quad(mpx);\r
k=1;\r
while ( mpx->x>040000000 ) { \r
  x= x / 2; k=k+k;\r
}\r
mpx->font_scaled_size[mpx->nfonts]=x*k/1048576.0;\r
if ( mpx->vf_reading )\r
  mpx->font_design_size[mpx->nfonts]=mpx_signed_quad(mpx)*mpx->dvi_per_fix/1048576.0;\r
else mpx->font_design_size[mpx->nfonts]=mpx_signed_quad(mpx)/1048576.0;\r
\r
@ @<Glob...@>=\r
double dvi_per_fix; /* converts points scaled $2^{20}$ to \.{DVI} units */\r
\r
@ The |match_font| function tries to find a match for the font with internal\r
number~|ff|, returning |nf| or the number of the matching font.  If\r
|exact=true|, the name and scaled size should match.  Otherwise the scaled\r
size need not match but the font found must be already loaded, not just\r
defined.\r
\r
@<Declare a function called |match_font|@>=\r
static integer mpx_match_font (MPX mpx, unsigned ff, boolean  exact) {\r
  unsigned f; /* font number being tested */\r
  for (f=0; f<mpx->nfonts ; f++) {\r
    if ( f!=ff ) {\r
      @<Compare the names of fonts |f| and |ff|; |continue| if they differ@>;\r
      if ( exact ) {\r
        if ( fabs(mpx->font_scaled_size[f]-mpx->font_scaled_size[ff])<= font_tolerance ) {\r
          if ( ! mpx->vf_reading ) {\r
            if ( mpx->local_only[f] ) {\r
              mpx->font_num[f]=mpx->font_num[ff]; mpx->local_only[f]=false;\r
            } else if ( mpx->font_num[f]!=mpx->font_num[ff] ) {\r
              continue;\r
            }\r
          }\r
          break;\r
        }\r
      } else if ( mpx->info_base[f]!=max_widths ) {\r
        break;\r
      }\r
    }\r
  }\r
  if ( f<mpx->nfonts ) {\r
    @<Make sure fonts |f| and |ff| have matching design sizes and checksums@>;\r
  }\r
  return f;\r
}\r
\r
@ @<Compare the names of fonts |f| and |ff|; |continue| if they differ@>=\r
if (strcmp(mpx->font_name[f],mpx->font_name[ff]))\r
   continue\r
\r
@ @<Make sure fonts |f| and |ff| have matching design sizes and checksums@>=\r
if ( fabs(mpx->font_design_size[f]-mpx->font_design_size[ff]) > font_tolerance ) {\r
  font_error("Inconsistent design sizes given for ",ff);\r
@.Inconsistent design sizes@>\r
} else if ( mpx->font_check_sum[f]!=mpx->font_check_sum[ff] ) {\r
  font_warn("Checksum mismatch for ", ff);\r
@.Checksum mismatch@>\r
}\r
\r
@* Reading ordinary fonts.\r
An auxiliary array |in_width| is used to hold the widths as they are\r
input. The global variable |tfm_check_sum| is set to the check sum that\r
appears in the current \.{TFM} file.\r
\r
@<Glob...@>=\r
integer in_width[256]; /* \.{TFM} width data in \.{DVI} units */\r
integer tfm_check_sum; /* check sum found in |tfm_file| */\r
\r
@ Here is a procedure that absorbs the necessary information from a\r
\.{TFM} file, assuming that the file has just been successfully reset\r
so that we are ready to read its first byte. (A complete description of\r
\.{TFM} file format appears in the documentation of \.{TFtoPL} and will\r
not be repeated here.) The procedure does not check the \.{TFM} file\r
for validity, nor does it give explicit information about what is\r
wrong with a \.{TFM} file that proves to be invalid. The procedure simply\r
aborts the program if it detects anything amiss in the \.{TFM} data.\r
\r
@c \r
static void mpx_in_TFM (MPX mpx,integer f) {\r
  /* input \.{TFM} data for font |f| or abort */\r
  integer k; /* index for loops */\r
  int lh; /* length of the header data, in four-byte words */\r
  int nw; /* number of words in the width table */\r
  unsigned wp; /* new value of |info_ptr| after successful input */\r
  @<Read past the header data; |abort| if there is a problem@>;\r
  @<Store character-width indices at the end of the |width| table@>;\r
  @<Read the width values into the |in_width| table@>;\r
  @<Move the widths from |in_width| to |width|@>;\r
  mpx->fbase[f]=0; mpx->ftop[f]=0;\r
  mpx->info_ptr=wp;\r
  return;\r
}\r
\r
@ @<Read past the header...@>=\r
mpx_read_tfm_word(mpx); lh=mpx->b2*(int)(256)+mpx->b3;\r
mpx_read_tfm_word(mpx); \r
mpx->font_bc[f]=mpx->b0*(int)(256)+mpx->b1; \r
mpx->font_ec[f]=mpx->b2*(int)(256)+mpx->b3;\r
if ( mpx->font_ec[f]<mpx->font_bc[f] ) mpx->font_bc[f]=mpx->font_ec[f]+1;\r
if ( mpx->info_ptr+mpx->font_ec[f]-mpx->font_bc[f]+1>max_widths )\r
  mpx_abort(mpx,"DVItoMP capacity exceeded (width table size=%d)!",max_widths);\r
@.DVItoMP capacity exceeded...@>\r
wp=mpx->info_ptr+mpx->font_ec[f]-mpx->font_bc[f]+1;\r
mpx_read_tfm_word(mpx); nw=mpx->b0*256+mpx->b1;\r
if ( (nw==0)||(nw>256) ) \r
  font_abort("Bad TFM file for ",f);\r
@.Bad TFM file@>\r
for (k=1;k<=3+lh;k++) { \r
  if ( feof(mpx->tfm_file) )\r
    font_abort("Bad TFM file for ",f);\r
@.Bad TFM file@>\r
  mpx_read_tfm_word(mpx);\r
  if ( k==4 ) {\r
    if ( mpx->b0<128 ) \r
      mpx->tfm_check_sum=((mpx->b0*(int)(256)+mpx->b1)*256+mpx->b2)*256+mpx->b3;\r
    else \r
      mpx->tfm_check_sum=(((mpx->b0-256)*(int)(256)+mpx->b1)*256+mpx->b2)*256+mpx->b3;\r
  }\r
}\r
\r
@ @<Store character-width indices...@>=\r
if ( wp>0 ) {\r
  for (k=mpx->info_ptr;k<=(int)wp-1;k++ ) {\r
    mpx_read_tfm_word(mpx);\r
    if ( mpx->b0>nw ) \r
      font_abort("Bad TFM file for ",f);\r
@.Bad TFM file@>\r
    mpx->width[k]=mpx->b0;\r
  }\r
}\r
\r
@ No fancy width calculation is needed here because \.{DVItoMP} stores\r
widths in their raw form as multiples of the design size scaled by $2^{20}$.\r
The |font_scaled_size| entries have been computed so that the final width\r
compution can be done in floating point if enough precision is available.\r
\r
@<Read the width values into the |in_width| table@>=\r
for (k=0;k<=nw-1;k++) { \r
  mpx_read_tfm_word(mpx);\r
  if ( mpx->b0>127 ) mpx->b0=mpx->b0-256;\r
  mpx->in_width[k]=((mpx->b0*0400+mpx->b1)*0400+mpx->b2)*0400+mpx->b3;\r
}\r
\r
@ The width compution uses a scale factor |dvi_scale| that will be introduced\r
later.  It is equal to one when not typesetting a character from a virtual\r
font.  In that case, the following expressions do the width computation that is\r
so important in \.{DVItype}.  It is less important here because it is impractical\r
to guarantee precise character positioning in \MP\ output.  Nevertheless, the\r
width compution will be precise if reals have at least 46-bit mantissas and\r
|round(x-.5)| is equivalent to $\lfloor x\rfloor$.  It may be a good idea to\r
modify this computation if these conditions are not met.\r
@^system dependencies@>\r
\r
@<Width of character |c| in font |f|@>=\r
floor(mpx->dvi_scale*mpx->font_scaled_size[f]*char_width(f,c))\r
\r
@ @<Width of character |p| in font |cur_font|@>=\r
floor(mpx->dvi_scale*mpx->font_scaled_size[cur_font]*char_width(cur_font,p))\r
\r
@ @<Move the widths from |in_width| to |width|@>=\r
if ( mpx->in_width[0]!=0 )\r
  font_abort("Bad TFM file for ",f);  /* the first width should be zero */\r
@.Bad TFM file@>\r
mpx->info_base[f]=mpx->info_ptr-mpx->font_bc[f];\r
if ( wp>0 ) {\r
  for (k=mpx->info_ptr;k<=(int)wp-1;k++) {\r
    mpx->width[k]=mpx->in_width[mpx->width[k]];\r
  }\r
}\r
\r
\r
@* Reading virtual fonts.\r
\r
The |in_VF| procedure absorbs the necessary information from a \.{VF} file that\r
has just been reset so that we are ready to read the first byte.  (A complete\r
description of \.{VF} file format appears in the documention of \.{VFtoVP}).\r
Like |in_TFM|, this procedure simply aborts the program if it detects anything\r
wrong with the \.{VF} file.\r
\r
@c \r
@<Declare a function called |first_par|@>@;\r
static void mpx_in_VF (MPX mpx, integer f) {\r
  /* read \.{VF} data for font |f| or abort */\r
  integer p; /* a byte from the \.{VF} file */\r
  boolean was_vf_reading; /* old value of |vf_reading| */\r
  integer c; /* the current character code */\r
  integer limit; /* space limitations force character codes to be less than this */\r
  integer w; /* a \.{TFM} width being read */\r
  was_vf_reading=mpx->vf_reading; mpx->vf_reading=true;\r
  @<Start reading the preamble from a \.{VF} file@>;@/\r
  @<Initialize the data structures for the virtual font@>;@/\r
  p=mpx_get_byte(mpx);\r
  while ( p>=fnt_def1 ) { \r
    if ( p>fnt_def1+3 ) \r
      font_abort("Bad VF file for ",f);\r
    mpx_define_font(mpx, mpx_first_par(mpx, p));\r
    p=mpx_get_byte(mpx);\r
  }\r
  while ( p<=242 ) { \r
    if ( feof(mpx->vf_file) ) \r
      font_abort("Bad VF file for ",f);\r
    @<Read the packet length, character code, and \.{TFM} width@>;\r
    @<Store the character packet in |cmd_buf|@>;\r
    p=mpx_get_byte(mpx);\r
  }\r
  if ( p==post ) { \r
    @<Finish setting up the data structures for the new virtual font@>;\r
    mpx->vf_reading=was_vf_reading;\r
    return;\r
  }\r
}\r
\r
@ @<Start reading the preamble from a \.{VF} file@>=\r
p=mpx_get_byte(mpx);\r
if ( p!=pre ) \r
  font_abort("Bad VF file for ",f);\r
p=mpx_get_byte(mpx); /* fetch the identification byte */\r
if ( p!=202 )\r
  font_abort("Bad VF file for ",f);\r
p=mpx_get_byte(mpx); /* fetch the length of the introductory comment */\r
while ( p-->0 ) \r
  (void)mpx_get_byte(mpx);\r
mpx->tfm_check_sum=mpx_signed_quad(mpx);\r
(void)mpx_signed_quad(mpx); /* skip over the design size */\r
\r
@ @<Initialize the data structures for the virtual font@>=\r
mpx->ftop[f]=mpx->vf_ptr;\r
if ( mpx->vf_ptr==mpx->nfonts ) \r
  mpx_abort(mpx,"DVItoMP capacity exceeded (max font numbers=%d)", max_fnums);\r
@.DVItoMP capacity exceeded...@>\r
decr(mpx->vf_ptr);\r
mpx->info_base[f]=mpx->info_ptr;\r
limit=max_widths-mpx->info_base[f];@/\r
mpx->font_bc[f]=limit; mpx->font_ec[f]=0\r
\r
@ @<Read the packet length, character code, and \.{TFM} width@>=\r
if ( p==242 ) { \r
  p=mpx_signed_quad(mpx); c=mpx_signed_quad(mpx); w=mpx_signed_quad(mpx);\r
  if ( c<0 ) \r
    font_abort("Bad VF file for ",f);\r
} else { \r
  c=mpx_get_byte(mpx); w=mpx_get_three_bytes(mpx);\r
}\r
if ( c>=limit )\r
  mpx_abort(mpx,"DVItoMP capacity exceeded (max widths=%d)", max_widths);\r
@.DVItoMP capacity exceeded...@>\r
if ( c<mpx->font_bc[f] ) mpx->font_bc[f]=c;\r
if ( c>mpx->font_ec[f] ) mpx->font_ec[f]=c;\r
char_width(f,c)=w\r
\r
@ @<Store the character packet in |cmd_buf|@>=\r
if ( mpx->n_cmds+p>=virtual_space )\r
  mpx_abort(mpx,"DVItoMP capacity exceeded (virtual font space=%d)",virtual_space);\r
@.DVItoMP capacity exceeded...@>\r
start_cmd(f,c)=mpx->n_cmds;\r
while ( p>0 ) { \r
  mpx->cmd_buf[mpx->n_cmds]=mpx_get_byte(mpx);\r
  incr(mpx->n_cmds); decr(p);\r
}\r
mpx->cmd_buf[mpx->n_cmds]=eop; /* add the end-of-packet marker */\r
incr(mpx->n_cmds)\r
\r
@ There are unused |width| and |cmd_ptr| entries if |font_bc[f]>0| but it isn't\r
worthwhile to slide everything down just to save a little space.\r
\r
@<Finish setting up the data structures for the new virtual font@>=\r
mpx->fbase[f]=mpx->vf_ptr+1;\r
mpx->info_ptr=mpx->info_base[f]+mpx->font_ec[f]+1\r
\r
\r
@* Loading fonts.\r
\r
The character width information for a font is loaded when the font is selected\r
for the first time.  This information might already be loaded if the font has\r
already been used at a different scale factor.  Otherwise, we look for a \.{VF}\r
file, or failing that, a \.{TFM} file.  All this is done by the |select_font|\r
function that takes an external font number~|e| and returns the corresponding\r
internal font number with the width information loaded.\r
\r
@c \r
static integer mpx_select_font (MPX mpx, integer e) {\r
  int f; /* the internal font number */\r
  int ff; /* internal font number for an existing version */\r
  integer k; /* general purpose loop counter */\r
  @<Set |f| to the internal font number that corresponds to |e|,\r
    or |abort| if there is none@>;\r
  if ( mpx->info_base[f]==max_widths ) {\r
    ff=mpx_match_font(mpx, (unsigned)f,false);\r
    if ( ff<(int)mpx->nfonts ) {\r
      @<Make font |f| refer to the width information from font |ff|@>;\r
    } else { \r
      @<Move the \.{VF} file name into the |cur_name| string@>;\r
      if ( mpx_open_vf_file(mpx) )  {\r
        mpx_in_VF(mpx, f);\r
      } else { \r
        if ( ! mpx_open_tfm_file(mpx) )\r
          font_abort("No TFM file found for ",f);\r
@.no TFM file found@>\r
        mpx_in_TFM(mpx, f);\r
      }\r
      @<Make sure the checksum in the font file matches the one given in the\r
        |font_def| for font |f|@>;\r
    }\r
    @<Do any other initialization required for the new font |f|@>;\r
  }\r
  return f;\r
}\r
\r
@ @<Set |f| to the internal font number that corresponds to |e|,...@>=\r
if ( mpx->cur_ftop<=mpx->nfonts ) \r
  mpx->cur_ftop=mpx->nfonts;\r
mpx->font_num[mpx->cur_ftop]=e;\r
k=mpx->cur_fbase;\r
while ((mpx->font_num[k]!=e)|| mpx->local_only[k] ) incr(k);\r
if ( k==(int)mpx->cur_ftop ) \r
  mpx_abort(mpx,"Undefined font selected");\r
f=mpx->internal_num[k]\r
\r
@ @<Make font |f| refer to the width information from font |ff|@>=\r
{ \r
  mpx->font_bc[f]=mpx->font_bc[ff];\r
  mpx->font_ec[f]=mpx->font_ec[ff];\r
  mpx->info_base[f]=mpx->info_base[ff];\r
  mpx->fbase[f]=mpx->fbase[ff];\r
  mpx->ftop[f]=mpx->ftop[ff];\r
}\r
\r
@ The string |cur_name| is supposed to be set to the external name of the\r
\.{VF} file for the current font. \r
@^system dependencies@>\r
\r
@<Move the \.{VF} file name into the |cur_name| string@>=\r
mpx->cur_name = xstrdup (mpx->font_name[f])\r
\r
@ @<Make sure the checksum in the font file matches the one given in the...@>=\r
{ \r
  if ( (mpx->font_check_sum[f]!=0)&&(mpx->tfm_check_sum!=0)&&@|\r
       (mpx->font_check_sum[f]!=mpx->tfm_check_sum) ) {\r
    font_warn("Checksum mismatch for ",f);\r
@.Checksum mismatch@>\r
  }\r
}\r
\r
@* Low level output routines.\r
\r
One of the basic output operations is to write a \MP\ string expression for\r
a sequence of characters to be typeset.  The main difficulties are that such\r
strings can contain arbitrary eight-bit bytes and there is no fixed limit on\r
the length of the string that needs to be produced.  In extreme cases this\r
can lead to expressions such as\r
$$\vcenter{\r
    \hbox{\.{char7\&char15\&char31\&"?FWayzz"}}\r
    \hbox{\.{\&"zzaF"\&char15\&char3\&char31}}\r
    \hbox{\.{\&"Nxzzzzzzzwvtsqo"}}}\r
$$\r
\r
@ A global variable |state| keeps track of the output process.\r
When |state=normal| we have begun a quoted string and the next character\r
should be a printable character or a closing quote.  When |state=special|\r
the last thing printed was a ``\.{char}'' construction or a closing quote\r
and an ampersand should come next.  The starting condition |state=initial|\r
is a lot like |state=special|, except no ampersand is required.\r
\r
@d special 0 /* the |state| after printing a ``\.{char}'' expression */\r
@d normal 1 /* the |state| value in a quoted string */\r
@d initial 2 /* initial |state| */\r
\r
@<Glob...@>=\r
int state; /* controls the process of printing a string */\r
int print_col; /* there are at most this many characters on the current line */\r
\r
@ @<Set initial values@>=\r
mpx->state = initial;\r
mpx->print_col = 0;             /* there are at most this many characters on the current line */\r
\r
@ To print a string on the \.{MPX} file, initialize |print_col|, ensure that\r
|state=initial|, and pass the characters one-at-a-time to |print_char|.\r
\r
@<Declare subroutines for printing strings@>=\r
static void mpx_print_char (MPX mpx, unsigned char c) {\r
  integer l; /* number of characters to print |c| or the \.{char} expression */  \r
  if ( printable(c) ) l=1;\r
  else if ( c<10 ) l=5;\r
  else if ( c<100 ) l=6;\r
  else l=7;\r
  if ( mpx->print_col+l>line_length-2 ) { \r
    if ( mpx->state==normal ) { \r
      fprintf(mpx->mpxfile,"\""); mpx->state=special;\r
    }\r
    fprintf(mpx->mpxfile,"\n");\r
    mpx->print_col=0;\r
  }\r
  @<Print |c| and update |state| and |print_col|@>;\r
}\r
\r
@ @<Print |c| and update |state| and |print_col|@>=\r
if ( mpx->state==normal ) {\r
  if ( printable(c) ) {\r
    fprintf(mpx->mpxfile,"%c",xchr(c));\r
  } else { \r
    fprintf(mpx->mpxfile,"\"&char%d",c);\r
    mpx->print_col +=2;\r
  }\r
} else { \r
  if ( mpx->state==special ) { \r
    fprintf(mpx->mpxfile,"&");\r
    incr(mpx->print_col);\r
  }\r
  if ( printable(c) ) { \r
    fprintf(mpx->mpxfile,"\"%c",xchr(c)); \r
    incr(mpx->print_col);\r
  } else { \r
    fprintf(mpx->mpxfile,"char%d",c);\r
  }\r
}\r
mpx->print_col += l;\r
if ( printable(c) ) \r
  mpx->state=normal; \r
else \r
  mpx->state=special\r
\r
@ The |end_char_string| procedure gets the string ended properly and ensures\r
that there is room for |l| more characters on the output line.\r
\r
@<Declare subroutines for printing strings@>=\r
static void mpx_end_char_string (MPX mpx,integer l) { \r
  while ( mpx->state>special ){ \r
    fprintf(mpx->mpxfile,"\"");\r
    incr(mpx->print_col);\r
    decr(mpx->state);\r
  }\r
  if ( mpx->print_col+l>line_length ) { \r
    fprintf(mpx->mpxfile,"\n "); mpx->print_col=0;\r
  }\r
  mpx->state=initial; /* get ready to print the next string */\r
}\r
\r
@ Since |end_char_string| resets |state:=initial|, all we have to do is set\r
|state:=initial| once at the beginning.\r
\r
@<Set init...@>=\r
mpx->state=initial;\r
\r
@ Characters and rules are positioned according to global variables |h| and~|v|\r
as will be explained later.  We also need scale factors that convert quantities\r
to the right units when they are printed in the \.{MPX} file.\r
\r
Even though all variable names in the \MP\ output are made local via \.{save}\r
commands, it is still desirable to preceed them with underscores.  This makes\r
the output more likely to work when used in a macro definition, since the\r
generated variables names must not collide with formal parameters in such\r
cases.\r
\r
@<Glob...@>=\r
integer h;\r
integer v; /* the current position in \.{DVI} units */\r
double conv; /* converts \.{DVI} units to \MP\ points */\r
double mag; /* magnification factor times 1000 */\r
\r
@ @c @<Declare a procedure called |finish_last_char|@>@;\r
static void mpx_do_set_char (MPX mpx,integer f, integer c) {\r
  if ( (c<mpx->font_bc[f])||(c>mpx->font_ec[f]) )\r
    mpx_abort(mpx,"attempt to typeset invalid character %d",c);\r
@.attempt to typeset...@>\r
  if ((mpx->h!=mpx->str_h2)||(mpx->v!=mpx->str_v)||\r
      (f!=mpx->str_f)||(mpx->dvi_scale!=mpx->str_scale) ) {\r
    if ( mpx->str_f>=0 ) {\r
      mpx_finish_last_char(mpx);\r
    } else if ( ! mpx->fonts_used ) {\r
      @<Prepare to output the first character on a page@>;\r
    }\r
    if ( ! mpx->font_used[f] )\r
      @<Prepare to use font |f| for the first time on a page@>;\r
    fprintf(mpx->mpxfile,"_s("); mpx->print_col=3;@/\r
    mpx->str_scale=mpx->dvi_scale; mpx->str_f=f; \r
    mpx->str_v=mpx->v; mpx->str_h1=mpx->h;\r
  }\r
  mpx_print_char(mpx, c);\r
  mpx->str_h2=mpx->h+@<Width of character |c| in font |f|@>;\r
}\r
\r
@ @<Glob...@>=\r
boolean font_used[(max_fonts+1)]; /* has this font been used on this page? */\r
boolean fonts_used; /* has any font been used on this page? */\r
boolean rules_used; /* has any rules been set on this page? */\r
integer str_h1;\r
integer str_v; /* starting position for current output string */\r
integer str_h2; /* where the current output string ends */\r
integer str_f; /* internal font number for the current output string */\r
double str_scale; /* value of |dvi_scale| for the current output string */\r
\r
\r
@ Before using any fonts we need to define a MetaPost macro for\r
typesetting character strings. The |font_used| array is not\r
initialized until it is actually time to output a character.\r
\r
@<Declarations@>=\r
static void mpx_prepare_font_use(MPX mpx);\r
\r
@ @c\r
static void mpx_prepare_font_use(MPX mpx) {\r
  unsigned k;\r
  for (k=0; k<mpx->nfonts;k++ )\r
    mpx->font_used[k]=false;\r
  mpx->fonts_used=true;\r
  fprintf(mpx->mpxfile,"string _n[];\n");\r
  fprintf(mpx->mpxfile,"vardef _s(expr _t,_f,_m,_x,_y)(text _c)=\n");\r
  fprintf(mpx->mpxfile,\r
          "  addto _p also _t infont _f scaled _m shifted (_x,_y) _c; enddef;\n");\r
}\r
\r
@ @<Prepare to output the first character on a page@>=\r
mpx_prepare_font_use(mpx)\r
\r
\r
@ @<Do any other initialization required for the new font |f|@>=\r
mpx->font_used[f]=false;\r
\r
@ Do what is necessary when the font with internal number f is used for the\r
first time on a page.\r
\r
@<Declarations@>=\r
static void mpx_first_use(MPX mpx, int f) ;\r
\r
@ @c \r
static void mpx_first_use(MPX mpx, int f) {\r
  mpx->font_used[f]=true;\r
  fprintf(mpx->mpxfile,"_n%d=",f);\r
  mpx->print_col=6;\r
  mpx_print_font(mpx, f);\r
  mpx_end_char_string(mpx, 1);\r
  fprintf(mpx->mpxfile,";\n");\r
}\r
\r
@ @<Prepare to use font |f| for the first time on a page@>=\r
mpx_first_use(mpx,f);\r
\r
@ We maintain the invariant that |str_f=-1| when there is no output string\r
under construction.\r
\r
@<Declare a procedure called |finish_last_char|@>=\r
static void mpx_finish_last_char (MPX mpx) {\r
  double m,x,y;\r
  /* font scale factor and \MP\ coordinates of reference point */\r
  if ( mpx->str_f>=0 ) {\r
    if (mpx->mode==mpx_tex_mode) {\r
      m=mpx->str_scale*mpx->font_scaled_size[mpx->str_f]*\r
         mpx->mag/mpx->font_design_size[mpx->str_f];\r
      x=mpx->conv*mpx->str_h1; \r
      y=mpx->conv*(-mpx->str_v);\r
      if ( (fabs(x)>=4096.0)||(fabs(y)>=4096.0)||(m>=4096.0)||(m<0) ) { \r
        mpx_warn(mpx,"text is out of range");\r
        mpx_end_char_string(mpx, 60);\r
      } else {\r
        mpx_end_char_string(mpx, 40);\r
      }\r
      fprintf(mpx->mpxfile,",_n%d,%1.5f,%1.4f,%1.4f,",mpx->str_f,m,x,y);\r
      @<Print a \.{withcolor} specifier if appropriate@>@/\r
      fprintf(mpx->mpxfile,");\n");\r
    } else {\r
      m = mpx->str_size / mpx->font_design_size[mpx->str_f];\r
      x = mpx->dmp_str_h1 * mpx->unit;\r
      y = YCORR - mpx->dmp_str_v * mpx->unit;\r
      if (fabs(x) >= 4096.0 || fabs(y) >= 4096.0 || m >= 4096.0 || m < 0) {\r
        mpx_warn(mpx,"text out of range ignored");\r
        mpx_end_char_string(mpx,67);\r
      } else {\r
        mpx_end_char_string(mpx,47);\r
      }\r
      fprintf(mpx->mpxfile, ")infont n%d", mpx->font_num[mpx->str_f]);\r
      mpx_slant_and_ht(mpx);\r
      fprintf(mpx->mpxfile, ",%.5f,%.4f,%.4f);\n", (m*1.00375), x, y);\r
    }\r
    mpx->str_f=-1;\r
  }\r
}\r
\r
@ Setting rules is fairly simple.\r
\r
@c \r
static void mpx_do_set_rule (MPX mpx,integer ht, integer wd) {\r
  double xx1,yy1,xx2,yy2,ww;\r
  /* \MP\ coordinates of lower-left and upper-right corners */\r
  if ( wd==1 ) {\r
    @<Handle a special rule that determines the box size@>\r
  } else if ( (ht>0)||(wd>0) ) { \r
    if ( mpx->str_f>=0 )\r
      mpx_finish_last_char(mpx);\r
    if ( ! mpx->rules_used ) {\r
      mpx->rules_used=true;\r
      fprintf(mpx->mpxfile,\r
             "interim linecap:=0;\n"\r
             "vardef _r(expr _a,_w)(text _t) =\n"\r
             "  addto _p doublepath _a withpen pencircle scaled _w _t enddef;");\r
    }\r
    @<Make |(xx1,yy1)| and |(xx2,yy2)| then ends of the desired penstroke\r
      and |ww| the desired stroke width@>;\r
    if ( (fabs(xx1)>=4096.0)||(fabs(yy1)>=4096.0)||@|\r
        (fabs(xx2)>=4096.0)||(fabs(yy2)>=4096.0)||(ww>=4096.0) )\r
      mpx_warn(mpx,"hrule or vrule is out of range");\r
    fprintf(mpx->mpxfile,"_r((%1.4f,%1.4f)..(%1.4f,%1.4f), %1.4f,",xx1,yy1,xx2,yy2,ww);\r
    @<Print a \.{withcolor} specifier if appropriate@>@/\r
    fprintf(mpx->mpxfile,");\n");\r
  }\r
}\r
\r
@ @<Make |(xx1,yy1)| and |(xx2,yy2)| then ends of the desired penstroke...@>=\r
xx1=mpx->conv*mpx->h;\r
yy1=mpx->conv*(-mpx->v);\r
if ( wd>ht ){ \r
  xx2=xx1+mpx->conv*wd;\r
  ww=mpx->conv*ht;\r
  yy1=yy1+0.5*ww;\r
  yy2=yy1;\r
} else { \r
  yy2=yy1+mpx->conv*ht;\r
  ww=mpx->conv*wd;\r
  xx1=xx1+0.5*ww;\r
  xx2=xx1;\r
}\r
\r
@ Rules of width one dvi unit are not typeset since \.{MPtoTeX} adds an\r
extraneous rule of this width in order to allow \.{DVItoMP} to deduce the\r
dimensions of the boxes it ships out.  The box width is the left edge of the\r
last such rule; the height and depth are at the top and bottom of the rule.\r
There should be only one special rule per picture but there could be more if\r
the user tries to typeset his own one-dvi-unit rules.  In this case the\r
dimension-determining rule is the last one in the picture.\r
\r
@<Handle a special rule that determines the box size@>=\r
{ \r
  mpx->pic_wd=mpx->h; mpx->pic_dp=mpx->v; mpx->pic_ht=ht-mpx->v; \r
}\r
\r
@ @<Glob...@>=\r
integer pic_dp; integer pic_ht; integer pic_wd; /* picture dimensions from special rule */\r
\r
@ The following  initialization and clean-up is required.  We do a little more\r
initialization than is absolutely necessary since some compilers might complain\r
if the variables are uninitialized when |do_set_char| tests them.\r
\r
@c \r
static void mpx_start_picture (MPX mpx) { \r
  mpx->fonts_used=false;\r
  mpx->rules_used=false;\r
  mpx->graphics_used=false;\r
  mpx->str_f=-1;\r
  mpx->str_v=0;\r
  mpx->str_h2=0;\r
  mpx->str_scale=1.0; /* values don't matter */\r
  mpx->dmp_str_v = 0.0;\r
  mpx->dmp_str_h2 = 0.0;\r
  mpx->str_size = 0.0;\r
  fprintf(mpx->mpxfile,\r
          "begingroup save %s_p,_r,_s,_n; picture _p; _p=nullpicture;\n", \r
          (mpx->mode == mpx_tex_mode ? "" : "_C,_D,"));\r
}\r
\r
static void mpx_stop_picture (MPX mpx) {\r
  double w,h,dd; /* width, height, negative depth in PostScript points */\r
  if ( mpx->str_f>=0 )\r
    mpx_finish_last_char(mpx);\r
  if (mpx->mode==mpx_tex_mode) {\r
    @<Print a \&{setbounds} command based on picture dimensions@>;\r
  }\r
  fprintf(mpx->mpxfile,"_p endgroup\n");\r
}\r
\r
@ @<Print a \&{setbounds} command based on picture dimensions@>=\r
dd=-mpx->pic_dp*mpx->conv;\r
w=mpx->conv*mpx->pic_wd; \r
h=mpx->conv*mpx->pic_ht;\r
fprintf(mpx->mpxfile,\r
        "setbounds _p to (0,%1.4f)--(%1.4f,%1.4f)--\n" \r
        " (%1.4f,%1.4f)--(0,%1.4f)--cycle;\n",dd,w,dd,w,h,h)\r
\r
@* Translation to symbolic form.\r
\r
The main work of \.{DVItoMP} is accomplished by the |do_dvi_commands|\r
procedure, which produces the output for an entire page, assuming that the\r
|bop| command for that page has already been processed. This procedure is\r
essentially an interpretive routine that reads and acts on the \.{DVI}\r
commands.  It is also capable of executing the typesetting commands for\r
a character in a virtual font.\r
\r
@ The definition of \.{DVI} files refers to six registers,\r
$(h,v,w,x,y,z)$, which hold integer values in \.{DVI} units.\r
These units come directly from the input file except they need to be\r
rescaled when typesetting characters from a virtual font.\r
The stack of $(h,v,w,x,y,z)$ values is represented by six arrays\r
called |hstack|, \dots, |zstack|.\r
\r
@<Glob...@>=\r
integer w;integer x;integer y;integer z;\r
  /* current state values (|h| and |v| have already been declared) */\r
integer hstack[(stack_size+1)];\r
integer vstack[(stack_size+1)];\r
integer wstack[(stack_size+1)];\r
integer xstack[(stack_size+1)];\r
integer ystack[(stack_size+1)];\r
integer zstack[(stack_size+1)]; /* pushed down values in \.{DVI} units */\r
integer stk_siz; /* the current stack size */\r
double dvi_scale; /* converts units of current input source to \.{DVI} units */\r
\r
@ @<Do initialization required before starting a new page@>=\r
mpx->dvi_scale=1.0;\r
mpx->stk_siz=0;\r
mpx->h=0; mpx->v=0;\r
mpx->Xslant = 0.0; mpx->Xheight = 0.0\r
\r
@ Next, we need procedures to handle |push| and |pop| commands.\r
\r
@c @<Declare procedures to handle color commands@>\r
static void mpx_do_push (MPX mpx) {\r
  if ( mpx->stk_siz==stack_size )\r
    mpx_abort(mpx,"DVItoMP capacity exceeded (stack size=%d)",stack_size);\r
@.DVItoMP capacity exceeded...@>\r
  mpx->hstack[mpx->stk_siz]=mpx->h; \r
  mpx->vstack[mpx->stk_siz]=mpx->v; mpx->wstack[mpx->stk_siz]=mpx->w;\r
  mpx->xstack[mpx->stk_siz]=mpx->x; \r
  mpx->ystack[mpx->stk_siz]=mpx->y; mpx->zstack[mpx->stk_siz]=mpx->z;\r
  incr(mpx->stk_siz);\r
}\r
\r
static void mpx_do_pop (MPX mpx) { \r
  if ( mpx->stk_siz==0 ) \r
    bad_dvi("attempt to pop empty stack");\r
  else { \r
    decr(mpx->stk_siz);\r
    mpx->h=mpx->hstack[mpx->stk_siz]; \r
    mpx->v=mpx->vstack[mpx->stk_siz]; mpx->w=mpx->wstack[mpx->stk_siz];\r
    mpx->x=mpx->xstack[mpx->stk_siz]; \r
    mpx->y=mpx->ystack[mpx->stk_siz]; mpx->z=mpx->zstack[mpx->stk_siz];\r
  }\r
}\r
\r
@ The |set_virtual_char| procedure is mutually recursive with \r
|do_dvi_commands|.  This is really a supervisory\r
@^recursion@>\r
procedure that calls |do_set_char| or adjusts the input source to read\r
typesetting commands for a character in a virtual font.\r
\r
@c \r
static void mpx_do_dvi_commands (MPX mpx);\r
static void mpx_set_virtual_char (MPX mpx,integer f, integer c) {\r
  double old_scale; /* original value of |dvi_scale| */\r
  unsigned old_buf_ptr; /* original value of the input pointer |buf_ptr| */\r
  unsigned old_fbase,old_ftop; /* originally applicable part of the |font_num| table */\r
  if ( mpx->fbase[f]==0 )\r
    mpx_do_set_char(mpx, f,c);\r
  else { \r
    old_fbase=mpx->cur_fbase; old_ftop=mpx->cur_ftop;\r
    mpx->cur_fbase=mpx->fbase[f];\r
    mpx->cur_ftop=mpx->ftop[f];\r
    old_scale=mpx->dvi_scale;\r
    mpx->dvi_scale=mpx->dvi_scale*mpx->font_scaled_size[f];\r
    old_buf_ptr=mpx->buf_ptr;\r
    mpx->buf_ptr=start_cmd(f,c);\r
    mpx_do_push(mpx);\r
    mpx_do_dvi_commands(mpx);\r
    mpx_do_pop(mpx);@/\r
    mpx->buf_ptr=old_buf_ptr;\r
    mpx->dvi_scale=old_scale;\r
    mpx->cur_fbase=old_fbase;\r
    mpx->cur_ftop=old_ftop;\r
  }\r
}\r
\r
@ Before we get into the details of |do_dvi_commands|, it is convenient to\r
consider a simpler routine that computes the first parameter of each\r
opcode.\r
\r
@d four_cases(A) (A): case (A)+1: case (A)+2: case (A)+3\r
@d eight_cases(A) four_cases((A)): case four_cases((A)+4)\r
@d sixteen_cases(A) eight_cases((A)): case eight_cases((A)+8)\r
@d thirty_two_cases(A) sixteen_cases((A)): case sixteen_cases((A)+16)\r
@d sixty_four_cases(A) thirty_two_cases((A)): case thirty_two_cases((A)+32)\r
\r
@<Declare a function called |first_par|@>=\r
static integer mpx_first_par (MPX mpx, unsigned int o) { \r
  switch (o) {\r
  case sixty_four_cases(set_char_0):\r
  case sixty_four_cases(set_char_0+64):\r
    return (o-set_char_0);\r
    break;\r
  case set1: case put1: case fnt1: case xxx1: case fnt_def1: \r
    return mpx_get_byte(mpx);\r
    break;\r
  case set1+1: case put1+1: case fnt1+1: case xxx1+1: case fnt_def1+1: \r
    return mpx_get_two_bytes(mpx);\r
    break;\r
  case set1+2: case put1+2: case fnt1+2: case xxx1+2: case fnt_def1+2: \r
    return mpx_get_three_bytes(mpx);\r
    break;\r
  case right1: case w1: case x1: case down1: case y1: case z1: \r
    return mpx_signed_byte(mpx);\r
    break;\r
  case right1+1: case w1+1: case x1+1: case down1+1: case y1+1: case z1+1: \r
    return mpx_signed_pair(mpx);\r
    break;\r
  case right1+2: case w1+2: case x1+2: case down1+2: case y1+2: case z1+2: \r
    return mpx_signed_trio(mpx);\r
    break;\r
  case set1+3: case set_rule: case put1+3: case put_rule: \r
  case right1+3: case w1+3: case x1+3: case down1+3: case y1+3: case z1+3: \r
  case fnt1+3: case xxx1+3: case fnt_def1+3:\r
    return mpx_signed_quad(mpx);\r
    break;\r
  case nop: case bop: case eop: case push: case pop: case pre: case post:\r
  case post_post: case undefined_commands: \r
    return 0;\r
    break;\r
  case w0: return mpx->w; break;\r
  case x0: return mpx->x; break;\r
  case y0: return mpx->y; break;\r
  case z0: return mpx->z; break;\r
  case sixty_four_cases(fnt_num_0): \r
    return (o-fnt_num_0);\r
    break;\r
  }\r
  return 0; /* compiler warning */\r
}\r
\r
@ Here is the |do_dvi_commands| procedure.\r
\r
@c \r
static void mpx_do_dvi_commands (MPX mpx) {\r
  unsigned int o; /* operation code of the current command */\r
  integer p,q; /* parameters of the current command */\r
  integer cur_font; /* current internal font number */\r
  if ( (mpx->cur_fbase<mpx->cur_ftop) && (mpx->buf_ptr<virtual_space) )\r
    cur_font=mpx_select_font(mpx, mpx->font_num[mpx->cur_ftop-1]); /* select first local font */\r
  else \r
    cur_font=max_fnums+1; /* current font is undefined */\r
  mpx->w=0; mpx->x=0; mpx->y=0; mpx->z=0; /* initialize the state variables */\r
  while ( true ) {\r
    @<Translate the next command in the \.{DVI} file; |return| if it was |eop|@>;\r
  }\r
}\r
\r
@ The multiway switch in |first_par|, above, was organized by the length\r
of each command; the one in |do_dvi_commands| is organized by the semantics.\r
\r
@ @<Translate the next command...@>=\r
{ \r
  o=mpx_get_byte(mpx); \r
  p=mpx_first_par(mpx, o);\r
  if ( feof(mpx->dvi_file) ) \r
    bad_dvi("the DVI file ended prematurely");\r
@.the DVI file ended prematurely@>\r
  if ( o<set1+4 ) { /* |set_char_0| through |set_char_127|, |set1| through |set4| */\r
    if ( cur_font>max_fnums ) {\r
      if ( mpx->vf_reading )\r
        mpx_abort(mpx,"no font selected for character %d in virtual font", p);\r
      else \r
        bad_dvi_two("no font selected for character %d",p);\r
    }\r
@.no font selected@>\r
    mpx_set_virtual_char(mpx, cur_font,p);\r
    mpx->h += @<Width of character |p| in font |cur_font|@>;\r
  } else {\r
    switch(o) {\r
    case four_cases(put1): \r
      mpx_set_virtual_char(mpx, cur_font, p);\r
      break;\r
    case set_rule: \r
      q=trunc(mpx_signed_quad(mpx)*mpx->dvi_scale);\r
      mpx_do_set_rule(mpx, trunc(p*mpx->dvi_scale),q);\r
      mpx->h += q;\r
      break;\r
    case put_rule: \r
      q=trunc(mpx_signed_quad(mpx)*mpx->dvi_scale);\r
      mpx_do_set_rule(mpx, trunc(p*mpx->dvi_scale),q);\r
      break;\r
    @<Additional cases for translating \.{DVI} command |o| with\r
       first parameter |p|@>@;\r
    case undefined_commands:\r
      bad_dvi_two("undefined command %d",o);\r
@.undefined command@>\r
      break;\r
    } /* all cases have been enumerated */\r
  }\r
}\r
\r
@ @<Additional cases for translating \.{DVI} command |o|...@>=\r
case four_cases(xxx1): \r
  mpx_do_xxx(mpx, p);\r
  break;\r
case pre: case post: case post_post: \r
  bad_dvi("preamble or postamble within a page!");\r
@.preamble or postamble within a page@>\r
  break;\r
\r
@ @<Additional cases for translating \.{DVI} command |o|...@>=\r
case nop: \r
  break;\r
case bop: \r
  bad_dvi("bop occurred before eop");\r
@.bop occurred before eop@>\r
  break;\r
case eop: \r
  return;\r
  break;\r
case push: \r
  mpx_do_push(mpx);\r
  break;\r
case pop: \r
  mpx_do_pop(mpx);\r
  break;\r
\r
@ @<Additional cases for translating \.{DVI} command |o|...@>=\r
case four_cases(right1):\r
  mpx->h += trunc(p*mpx->dvi_scale);\r
  break;\r
case w0: case four_cases(w1): \r
  mpx->w = trunc(p*mpx->dvi_scale); mpx->h += mpx->w;\r
  break;\r
case x0: case four_cases(x1): \r
  mpx->x = trunc(p*mpx->dvi_scale); mpx->h += mpx->x;\r
  break;\r
case four_cases(down1):\r
  mpx->v += trunc(p*mpx->dvi_scale);\r
  break;\r
case y0: case four_cases(y1): \r
  mpx->y = trunc(p*mpx->dvi_scale); mpx->v += mpx->y;\r
  break;\r
case z0: case four_cases(z1): \r
  mpx->z = trunc(p*mpx->dvi_scale); mpx->v += mpx->z;\r
  break;\r
\r
@ @<Additional cases for translating \.{DVI} command |o|...@>=\r
case sixty_four_cases(fnt_num_0): case four_cases(fnt1):\r
  cur_font = mpx_select_font(mpx, p);\r
  break;\r
case four_cases(fnt_def1): \r
  mpx_define_font(mpx, p);\r
  break;\r
\r
@* The main program.\r
Now we are ready to put it all together. This is where \.{DVItoMP} starts,\r
and where it ends.\r
\r
@c \r
static int mpx_dvitomp (MPX mpx, char *dviname) {\r
  int k;\r
  mpx->dviname = dviname;\r
  mpx_open_dvi_file(mpx);\r
  @<Process the preamble@>;\r
  mpx_open_mpxfile(mpx);\r
  if (mpx->banner!=NULL)\r
    fprintf (mpx->mpxfile,"%s\n",mpx->banner);\r
  while ( true ) { \r
    @<Advance to the next |bop| command@>;\r
    for (k=0;k<=10;k++) \r
      (void)mpx_signed_quad(mpx);\r
    @<Do initialization required before starting a new page@>;\r
    mpx_start_picture(mpx);\r
    mpx_do_dvi_commands(mpx);\r
    if ( mpx->stk_siz!=0 )\r
      bad_dvi("stack not empty at end of page");\r
@.stack not empty...@>\r
    mpx_stop_picture(mpx);\r
    fprintf(mpx->mpxfile,"mpxbreak\n");\r
  }\r
  if ( mpx->history<=mpx_cksum_trouble )\r
    return 0;\r
  else \r
    return mpx->history;\r
}\r
\r
@ The main program needs a few global variables in order to do its work.\r
\r
@<Glob...@>=\r
integer k;integer p; /* general purpose registers */\r
integer numerator;integer denominator; /* stated conversion ratio */\r
\r
@ @<Process the preamble@>=\r
{\r
  int p;\r
  p=mpx_get_byte(mpx); /* fetch the first byte */\r
  if ( p!=pre ) \r
    bad_dvi("First byte isn""t start of preamble!");\r
@.First byte isn't...@>\r
  p=mpx_get_byte(mpx); /* fetch the identification byte */\r
  if ( p!=id_byte )\r
    mpx_warn(mpx,"identification in byte 1 should be %d!", id_byte);\r
@.identification...should be n@>\r
  @<Compute the conversion factor@>;\r
  p=mpx_get_byte(mpx); /* fetch the length of the introductory comment */\r
  while (p>0 ){ \r
    decr(p); \r
    (void)mpx_get_byte(mpx);\r
  }\r
}\r
\r
@ The conversion factor |conv| is figured as follows: There are exactly\r
|n/d| decimicrons per \.{DVI} unit, and 254000 decimicrons per inch,\r
and |resolution| pixels per inch. Then we have to adjust this\r
by the stated amount of magnification.  No such adjustment is needed for\r
|dvi_per_fix| since it is used to convert design sizes.\r
\r
@<Compute the conversion factor@>=\r
mpx->numerator=mpx_signed_quad(mpx); mpx->denominator=mpx_signed_quad(mpx);\r
if ( (mpx->numerator<=0)||(mpx->denominator<=0) )\r
  bad_dvi("bad scale ratio in preamble");\r
@.bad scale ratio@>\r
mpx->mag=mpx_signed_quad(mpx)/1000.0;\r
if ( mpx->mag<=0.0 ) \r
  bad_dvi("magnification isn't positive");\r
@.magnification isn't positive@>\r
mpx->conv=(mpx->numerator/254000.0)*(72.0/mpx->denominator)*mpx->mag;\r
mpx->dvi_per_fix=(254000.0/mpx->numerator)*(mpx->denominator/72.27)/1048576.0;\r
\r
@ @<Advance to the next |bop| command@>=\r
do {  \r
  int p;\r
  k=mpx_get_byte(mpx);\r
  if ( (k>=fnt_def1)&&(k<fnt_def1+4) ){ \r
    p=mpx_first_par(mpx, (unsigned int)k); \r
    mpx_define_font(mpx, p); k=nop;\r
  }\r
} while (k==nop);\r
if ( k==post ) \r
  break;\r
if ( k!=bop ) \r
  bad_dvi("missing bop");\r
@.missing bop@>\r
\r
\r
@ Global filenames.\r
\r
@<Global...@>=\r
char *dviname;\r
\r
@* Color support.\r
These changes support \.{dvips}-style ``\.{color push NAME}'' and\r
``\.{color pop}'' specials. We store a list of named colors, sorted by\r
name, and decorate the relevant drawing commands with ``\.{withcolor\r
(r,g,b)}'' specifiers while a color is defined.\r
\r
@ A constant bounding the size of the named-color array.\r
\r
@d max_named_colors 100 /* maximum number of distinct named colors */\r
\r
@ Then we declare a record for color types.\r
\r
@<Types...@>=\r
typedef struct named_color_record {\r
  char *name; /* color name */\r
  char *value; /* text to pass to MetaPost */\r
} named_color_record;\r
\r
@ Declare the named-color array itself.\r
\r
@<Globals@>=\r
named_color_record named_colors[(max_named_colors+1)];\r
  /* stores information about named colors, in sorted order by name */\r
integer num_named_colors; /* number of elements of |named_colors| that are valid */\r
\r
@ This function, used only during initialization, defines a named color.\r
\r
@c\r
static void mpx_def_named_color (MPX mpx, char *n, char *v) {\r
  mpx->num_named_colors++;\r
  assert(mpx->num_named_colors<max_named_colors);\r
  mpx->named_colors[mpx->num_named_colors].name = n;\r
  mpx->named_colors[mpx->num_named_colors].value = v;\r
}\r
\r
@ @<Declarations@>=\r
static void mpx_def_named_color (MPX mpx, char *n, char *v);\r
\r
@ During the initialization phase, we define values for all the named\r
colors defined in \.{colordvi.tex}. CMYK-to-RGB conversion by GhostScript.\r
\r
This list has to be sorted alphabetically!\r
\r
@<Set initial values@>=\r
mpx->num_named_colors = 0;\r
mpx_def_named_color(mpx, "Apricot", "(1.0, 0.680006, 0.480006)");\r
mpx_def_named_color(mpx, "Aquamarine", "(0.180006, 1.0, 0.7)");\r
mpx_def_named_color(mpx, "Bittersweet", "(0.760012, 0.0100122, 0.0)");\r
mpx_def_named_color(mpx, "Black", "(0.0, 0.0, 0.0)");\r
mpx_def_named_color(mpx, "Blue", "(0.0, 0.0, 1.0)");\r
mpx_def_named_color(mpx, "BlueGreen", "(0.15, 1.0, 0.669994)");\r
mpx_def_named_color(mpx, "BlueViolet", "(0.1, 0.05, 0.960012)");\r
mpx_def_named_color(mpx, "BrickRed", "(0.719994, 0.0, 0.0)");\r
mpx_def_named_color(mpx, "Brown", "(0.4, 0.0, 0.0)");\r
mpx_def_named_color(mpx, "BurntOrange", "(1.0, 0.489988, 0.0)");\r
mpx_def_named_color(mpx, "CadetBlue", "(0.380006, 0.430006, 0.769994)");\r
mpx_def_named_color(mpx, "CarnationPink", "(1.0, 0.369994, 1.0)");\r
mpx_def_named_color(mpx, "Cerulean", "(0.0600122, 0.889988, 1.0)");\r
mpx_def_named_color(mpx, "CornflowerBlue", "(0.35, 0.869994, 1.0)");\r
mpx_def_named_color(mpx, "Cyan", "(0.0, 1.0, 1.0)");\r
mpx_def_named_color(mpx, "Dandelion", "(1.0, 0.710012, 0.160012)");\r
mpx_def_named_color(mpx, "DarkOrchid", "(0.6, 0.2, 0.8)");\r
mpx_def_named_color(mpx, "Emerald", "(0.0, 1.0, 0.5)");\r
mpx_def_named_color(mpx, "ForestGreen", "(0.0, 0.880006, 0.0)");\r
mpx_def_named_color(mpx, "Fuchsia", "(0.45, 0.00998169, 0.919994)");\r
mpx_def_named_color(mpx, "Goldenrod", "(1.0, 0.9, 0.160012)");\r
mpx_def_named_color(mpx, "Gray", "(0.5, 0.5, 0.5)");\r
mpx_def_named_color(mpx, "Green", "(0.0, 1.0, 0.0)");\r
mpx_def_named_color(mpx, "GreenYellow", "(0.85, 1.0, 0.310012)");\r
mpx_def_named_color(mpx, "JungleGreen", "(0.0100122, 1.0, 0.480006)");\r
mpx_def_named_color(mpx, "Lavender", "(1.0, 0.519994, 1.0)");\r
mpx_def_named_color(mpx, "LimeGreen", "(0.5, 1.0, 0.0)");\r
mpx_def_named_color(mpx, "Magenta", "(1.0, 0.0, 1.0)");\r
mpx_def_named_color(mpx, "Mahogany", "(0.65, 0.0, 0.0)");\r
mpx_def_named_color(mpx, "Maroon", "(0.680006, 0.0, 0.0)");\r
mpx_def_named_color(mpx, "Melon", "(1.0, 0.539988, 0.5)");\r
mpx_def_named_color(mpx, "MidnightBlue", "(0.0, 0.439988, 0.569994)");\r
mpx_def_named_color(mpx, "Mulberry", "(0.640018, 0.0800061, 0.980006)");\r
mpx_def_named_color(mpx, "NavyBlue", "(0.0600122, 0.460012, 1.0)");\r
mpx_def_named_color(mpx, "OliveGreen", "(0.0, 0.6, 0.0)");\r
mpx_def_named_color(mpx, "Orange", "(1.0, 0.389988, 0.130006)");\r
mpx_def_named_color(mpx, "OrangeRed", "(1.0, 0.0, 0.5)");\r
mpx_def_named_color(mpx, "Orchid", "(0.680006, 0.360012, 1.0)");\r
mpx_def_named_color(mpx, "Peach", "(1.0, 0.5, 0.3)");\r
mpx_def_named_color(mpx, "Periwinkle", "(0.430006, 0.45, 1.0)");\r
mpx_def_named_color(mpx, "PineGreen", "(0.0, 0.75, 0.160012)");\r
mpx_def_named_color(mpx, "Plum", "(0.5, 0.0, 1.0)");\r
mpx_def_named_color(mpx, "ProcessBlue", "(0.0399878, 1.0, 1.0)");\r
mpx_def_named_color(mpx, "Purple", "(0.55, 0.139988, 1.0)");\r
mpx_def_named_color(mpx, "RawSienna", "(0.55, 0.0, 0.0)");\r
mpx_def_named_color(mpx, "Red", "(1.0, 0.0, 0.0)");\r
mpx_def_named_color(mpx, "RedOrange", "(1.0, 0.230006, 0.130006)");\r
mpx_def_named_color(mpx, "RedViolet", "(0.590018, 0.0, 0.660012)");\r
mpx_def_named_color(mpx, "Rhodamine", "(1.0, 0.180006, 1.0)");\r
mpx_def_named_color(mpx, "RoyalBlue", "(0.0, 0.5, 1.0)");\r
mpx_def_named_color(mpx, "RoyalPurple", "(0.25, 0.1, 1.0)");\r
mpx_def_named_color(mpx, "RubineRed", "(1.0, 0.0, 0.869994)");\r
mpx_def_named_color(mpx, "Salmon", "(1.0, 0.469994, 0.619994)");\r
mpx_def_named_color(mpx, "SeaGreen", "(0.310012, 1.0, 0.5)");\r
mpx_def_named_color(mpx, "Sepia", "(0.3, 0.0, 0.0)");\r
mpx_def_named_color(mpx, "SkyBlue", "(0.380006, 1.0, 0.880006)");\r
mpx_def_named_color(mpx, "SpringGreen", "(0.739988, 1.0, 0.239988)");\r
mpx_def_named_color(mpx, "Tan", "(0.860012, 0.580006, 0.439988)");\r
mpx_def_named_color(mpx, "TealBlue", "(0.119994, 0.980006, 0.640018)");\r
mpx_def_named_color(mpx, "Thistle", "(0.880006, 0.410012, 1.0)");\r
mpx_def_named_color(mpx, "Turquoise", "(0.15, 1.0, 0.8)");\r
mpx_def_named_color(mpx, "Violet", "(0.210012, 0.119994, 1.0)");\r
mpx_def_named_color(mpx, "VioletRed", "(1.0, 0.189988, 1.0)");\r
mpx_def_named_color(mpx, "White", "(1.0, 1.0, 1.0)");\r
mpx_def_named_color(mpx, "WildStrawberry", "(1.0, 0.0399878, 0.610012)");\r
mpx_def_named_color(mpx, "Yellow", "(1.0, 1.0, 0.0)");\r
mpx_def_named_color(mpx, "YellowGreen", "(0.560012, 1.0, 0.260012)");\r
mpx_def_named_color(mpx, "YellowOrange", "(1.0, 0.580006, 0.0)");\r
\r
@ Color commands get a separate warning procedure. |warn| sets |history :=\r
mpx_warning_given|, which causes a nonzero exit status; but color errors are\r
trivial and should leave the exit status zero.\r
\r
@d color_warn(A) mpx_warn(mpx,A)\r
@d color_warn_two(A,B) mpx_warn(mpx,"%s%s",A,B)\r
\r
@ The |do_xxx| procedure handles DVI specials (defined with the |xxx1...xxx4| commands).\r
\r
@d XXX_BUF 256\r
\r
@<Declare procedures to handle color commands@>=\r
static void mpx_do_xxx (MPX mpx, integer p)\r
{\r
  unsigned char buf[(XXX_BUF+1)]; /* FIXME: Fixed size buffer. */\r
  integer l, r, m, k, len;\r
  boolean  found;\r
  int bufsiz = XXX_BUF;\r
  len = 0;\r
  while ( ( p > 0) && (len < bufsiz) ) {\r
    buf[len] = mpx_get_byte(mpx);\r
    decr(p); incr(len);\r
  }\r
  @<Check whether |buf| contains a color command; if not, |goto XXXX|@>\r
  if ( p > 0 ) {\r
     color_warn("long \"color\" special ignored"); \r
     goto XXXX; \r
  }\r
  if ( @<|buf| contains a color pop command@> ) {\r
     @<Handle a color pop command@>\r
  } else if ( @<|buf| contains a color push command@> ) {\r
     @<Handle a color push command@>\r
  } else {\r
     color_warn("unknown \"color\" special ignored"); \r
     goto XXXX; \r
  }\r
XXXX: \r
  for (k = 1;k<=p;k++) (void)mpx_get_byte(mpx);\r
}\r
\r
@\r
\r
@<Check whether |buf| contains a color command; if not, |goto XXXX|@>=\r
if ( (len <= 5)\r
   || (buf[0] != 'c')\r
   || (buf[1] != 'o')\r
   || (buf[2] != 'l')\r
   || (buf[3] != 'o')\r
   || (buf[4] != 'r')\r
   || (buf[5] != ' ')\r
  ) goto XXXX;\r
\r
@ @<|buf| contains a color push command@>=\r
(len >= 11) && \r
 (buf[6] == 'p') && \r
 (buf[7] == 'u') && \r
 (buf[8] == 's') && \r
 (buf[9] == 'h') && \r
 (buf[10] == ' ')\r
\r
@ @<|buf| contains a color pop command@>=\r
(len == 9) && \r
(buf[6] == 'p') && \r
(buf[7] == 'o') && \r
(buf[8] == 'p')\r
\r
@ The \.{color push} and \.{pop} commands imply a color stack, so we need a\r
global variable to hold that stack.\r
\r
@d max_color_stack_depth 10 /* maximum depth of saved color stack */\r
\r
@ Here's the actual stack variables.\r
\r
@<Globals@>=\r
integer color_stack_depth; /* current depth of saved color stack */\r
char *color_stack[(max_color_stack_depth+1)]; /* saved color stack */\r
\r
@ Initialize the stack to empty.\r
\r
@<Set initial values@>=\r
mpx->color_stack_depth = 0;\r
\r
@ \.{color pop} just pops the stack.\r
\r
@<Handle a color pop command@>=\r
mpx_finish_last_char(mpx);\r
if (mpx->color_stack_depth > 0 ) {\r
  free(mpx->color_stack[mpx->color_stack_depth]);\r
  decr(mpx->color_stack_depth);\r
} else {\r
  color_warn("color stack underflow");\r
}\r
\r
@ \.{color push} pushes a color onto the stack.\r
\r
@<Handle a color push command@>=\r
mpx_finish_last_char(mpx);\r
if ( mpx->color_stack_depth >= max_color_stack_depth )\r
  mpx_abort(mpx,"color stack overflow");\r
incr(mpx->color_stack_depth);\r
/*  I don't know how to do string operations in Pascal.  */\r
/*  Skip over extra spaces after 'color push'.  */\r
l = 11;\r
while ( (l < len - 1) && (buf[l] == ' ') ) incr(l);\r
if ( @<|buf[l]| contains an rgb command@> ) {\r
  @<Handle a color push rgb command@>\r
} else if ( @<|buf[l]| contains a cmyk command@> ) {\r
  @<Handle a color push cmyk command@>\r
} else if ( @<|buf[l]| contains a gray command@> ) {\r
  @<Handle a color push gray command@>\r
} else {\r
  @<Handle a named color push command@>\r
}\r
\r
@ @<|buf[l]| contains an rgb command@>=\r
(l + 4 < len)\r
&& (buf[l]   == 'r')\r
&& (buf[l+1] == 'g')\r
&& (buf[l+2] == 'b')\r
&& (buf[l+3] == ' ')\r
\r
@ @<Handle a color push rgb command@>=\r
l = l + 4;\r
while ( (l < len) && (buf[l] == ' ') ) incr(l); /*  Remove spaces at end of buf  */\r
while ( (len > l) && (buf[len - 1] == ' ') ) decr(len);\r
mpx->color_stack[mpx->color_stack_depth]=xmalloc(len-l+3,1);\r
k = 0;\r
@<Copy |buf[l]| to |color_stack[color_stack_depth][k]| in tuple form@>\r
\r
@ @<|buf[l]| contains a gray command@>=\r
(l + 5 < len)\r
&& (buf[l]   == 'g')\r
&& (buf[l+1] == 'r')\r
&& (buf[l+2] == 'a')\r
&& (buf[l+3] == 'y')\r
&& (buf[l+4] == ' ')\r
\r
@ @<Handle a color push gray command@>=\r
l = l + 5;\r
while ( (l < len) && (buf[l] == ' ') ) incr(l); /*  Remove spaces at end of buf  */\r
while ( (len > l) && (buf[len - 1] == ' ') ) decr(len);\r
mpx->color_stack[mpx->color_stack_depth]=xmalloc(len-l+9,1);\r
strcpy(mpx->color_stack[mpx->color_stack_depth],"white*");\r
k = 6;\r
@<Copy |buf[l]| to |color_stack[color_stack_depth][k]| in tuple form@>\r
\r
@ @<|buf[l]| contains a cmyk command@>=\r
(l + 5 < len)\r
&& (buf[l]   == 'c')\r
&& (buf[l+1] == 'm')\r
&& (buf[l+2] == 'y')\r
&& (buf[l+3] == 'k')\r
&& (buf[l+4] == ' ')\r
\r
@ @<Handle a color push cmyk command@>=\r
l = l + 5;\r
while ( (l < len) && (buf[l] == ' ') ) incr(l);\r
/*  Remove spaces at end of buf  */\r
while ( (len > l) && (buf[len - 1] == ' ') ) decr(len);\r
mpx->color_stack[mpx->color_stack_depth]=xmalloc(len-l+7,1);\r
strcpy(mpx->color_stack[mpx->color_stack_depth],"cmyk");\r
k = 4;\r
@<Copy |buf[l]| to |color_stack[color_stack_depth][k]| in tuple form@>\r
\r
@ @<Copy |buf[l]| to |color_stack[color_stack_depth][k]| in tuple form@>=\r
mpx->color_stack[mpx->color_stack_depth][k] = '(';\r
incr(k);\r
while ( l < len ) {\r
  if ( buf[l] == ' ' ) {\r
    mpx->color_stack[mpx->color_stack_depth][k] = ',';\r
    while ( (l < len) && (buf[l] == ' ') ) incr(l);\r
    incr(k);\r
  } else {\r
    mpx->color_stack[mpx->color_stack_depth][k] = (char)buf[l];\r
    incr(l);\r
    incr(k);\r
  }\r
}\r
mpx->color_stack[mpx->color_stack_depth][k] = ')';\r
mpx->color_stack[mpx->color_stack_depth][k+1] = 0;\r
\r
@ Binary-search the |named_colors| array, then push the found color onto\r
the stack.\r
\r
@<Handle a named color push command@>=\r
for (k = l;k<=len - 1;k++) {\r
  buf[k - l] = xchr(buf[k]);\r
}\r
buf[len - l] = 0;\r
len = len - l;\r
l = 1; r = mpx->num_named_colors;\r
found = false;\r
while ( (l <= r) && ! found ) {\r
  m = (l + r) / 2; k = strcmp((char *)(buf), mpx->named_colors[m].name);\r
  if ( k == 0 ) {\r
    mpx->color_stack[mpx->color_stack_depth]=xstrdup(mpx->named_colors[m].value);\r
    found = true;\r
  } else if ( k < 0 ) {\r
    r = m - 1;\r
  } else {\r
    l = m + 1;\r
  }\r
}\r
if (! found ) {\r
   color_warn_two("non-hardcoded color \"%s\" in \"color push\" command", buf);\r
   mpx->color_stack[mpx->color_stack_depth]=xstrdup((char *)(buf));\r
}\r
\r
@ Last but not least, this code snippet prints a \.{withcolor} specifier\r
for the top of the color stack, if the stack is nonempty.\r
\r
@<Print a \.{withcolor} specifier if appropriate@>=\r
if ( mpx->color_stack_depth > 0 ) {\r
  fprintf(mpx->mpxfile," withcolor %s\n",mpx->color_stack[mpx->color_stack_depth]);\r
}\r
\r
\r
@* \[4] Dmp.\r
\r
This program reads device-independent troff output files,\r
and converts them into a symbolic form understood by MetaPost.  Some\r
of the code was borrowed from DVItoMP.  It understands all the D? graphics\r
functions that dpost does but it ignores `x X' device control functions\r
such as `x X SetColor:...', `x X BeginPath:', and `x X DrawPath:...'.\r
\r
The output file is a sequence of MetaPost picture expressions, one for every\r
page in the input file.  It makes no difference where the input file comes\r
from, but it is intended to process the result of running eqn and troff on\r
the output of MPtoTR.  Such a file contains one page for every btex...etex\r
block in the original input.  This program then creates a corresponding\r
sequence of MetaPost picture expressions for use as an auxiliary input file.\r
Since MetaPost expects such files to have the extension .mpx, the output\r
is sometimes called an `mpx' file.\r
\r
@d SHIFTS       100             /* maximum number of characters with special shifts */\r
@d MAXCHARS 256         /* character codes fall in the range 0..MAXCHARS-1 */\r
\r
@d is_specchar(c)       (!mpx->gflag && (c)<=2) /* does charcode c identify a special char? */\r
@d LWscale      0.03            /* line width for graphics as a fraction of pointsize */\r
@d YCORR 12.0           /* V coordinate of reference point in (big) points */\r
\r
@<Globals@>=\r
int next_specfnt[(max_fnums+1)];        /* used to link special fonts together */\r
int shiftchar[SHIFTS];          /* charcode of character to shift, else -1 */\r
float shifth[SHIFTS];\r
float shiftv[SHIFTS];   /* shift vals/fontsize (y is upward) */\r
int shiftptr;           /* number of entries in shift tables */\r
int shiftbase[(max_fnums+1)];           /* initial index into shifth,shiftv,shiftchar */\r
int specfnt;            /* int. num. of first special font (or FCOUNT) */\r
int *specf_tail ;       /* tail of specfnt list |(*specf_tail==FCOUNT)| */\r
float cursize;                  /* current type size in (big) points */\r
unsigned int curfont;                   /* internal number for current font */\r
float Xslant;                   /* degrees additional slant for all fonts */\r
float Xheight;                  /* yscale fonts to this height if nonzero */\r
float sizescale;                /* groff font size scaling factor */\r
int gflag;                      /* non-zero if using groff fonts */\r
float unit;             /* (big) points per troff unit (0 when unset) */\r
\r
@ @<Set initial...@>=\r
mpx->shiftptr = 0;\r
mpx->specfnt = (max_fnums+1);\r
mpx->specf_tail = &(mpx->specfnt);\r
mpx->unit = 0.0;\r
mpx->lnno = 0; /* this is a reset */\r
mpx->gflag = 0;\r
mpx->h = 0; mpx->v = 0; \r
\r
@ @(mpxout.h@>=\r
typedef char *(*mpx_file_finder)(MPX, const char *, const char *, int);\r
enum mpx_filetype {\r
  mpx_tfm_format,           /* |kpse_tfm_format| */\r
  mpx_vf_format,            /* |kpse_vf_format| */\r
  mpx_trfontmap_format,     /* |kpse_mpsupport_format| */\r
  mpx_trcharadj_format,     /* |kpse_mpsupport_format| */\r
  mpx_desc_format,          /* |kpse_troff_font_format| */\r
  mpx_fontdesc_format,      /* |kpse_troff_font_format| */\r
  mpx_specchar_format       /* |kpse_mpsupport_format| */\r
};\r
\r
@ @<Globals@>=\r
mpx_file_finder find_file;\r
\r
@ @<Declarations@>=\r
static char *mpx_find_file (MPX mpx, const char *nam, const char *mode, int ftype);\r
\r
@ @c\r
static char *mpx_find_file (MPX mpx, const char *nam, const char *mode, int ftype) {\r
  (void) mpx;\r
  if (mode[0] != 'r' || (! access (nam,R_OK)) || ftype) {  \r
     return strdup(nam);\r
  }\r
  return NULL;\r
}\r
\r
@ @<Set initial...@>=\r
mpx->find_file = mpx_find_file;\r
\r
@ @<Declarations@>=\r
static FILE *mpx_fsearch(MPX mpx, char *nam, int format);\r
\r
@ @c\r
static FILE *mpx_fsearch(MPX mpx, char *nam, int format) {\r
        FILE *f = NULL;\r
        char *fname = (mpx->find_file)(mpx, nam, "r", format);\r
        if (fname) {\r
          f = fopen(fname, "rb");\r
      mpx_report(mpx,"%p = fopen(%s,\"rb\")",f, fname);\r
        }\r
        return f;\r
}\r
\r
@ Hash tables (or rather: AVL lists)\r
\r
@ @<Types...@>=\r
typedef struct {\r
    char *name;\r
    int num;\r
} avl_entry;\r
\r
@ @c\r
static int mpx_comp_name (const void *pa, const void *pb, void *p) {\r
    (void)p;\r
    return strcmp (((const avl_entry *) pa)->name,\r
                   ((const avl_entry *) pb)->name);\r
}\r
\r
@ @c\r
static struct avl_table *mpx_avl_create (MPX mpx) {\r
   struct avl_table *t;\r
   t = avl_create(mpx_comp_name, NULL, NULL);\r
   if (t==NULL) \r
     mpx_abort(mpx, "Memory allocation failure");\r
   return t;\r
}\r
\r
\r
@ The only two operations on AVL lists are finding already existing\r
items, or interning new items. Finding is handled by explicit |avl_find| \r
calls where needed, but it is wise to have a wrapper around |avl_probe|\r
to check for memory errors.\r
\r
@c\r
static avl_entry * mpx_avl_probe(MPX mpx, struct avl_table *tab, avl_entry *p) {\r
    avl_entry *r  = (avl_entry *)avl_probe(tab,p);\r
    if (r==NULL)\r
      mpx_abort(mpx,"Memory allocation failure");\r
    return r;\r
\r
}\r
\r
\r
@ Scanning Numbers\r
\r
The standard functions atoi(), atof(), and sscanf() provide ways of reading\r
numbers from strings but they give no indication of how much of the string\r
is consumed.  These homemade versions don't parse scientific notation.\r
\r
@<Globals@>=\r
char *arg_tail;                 /* char after the number just gotten; NULL on failure */\r
\r
@ @c \r
static int mpx_get_int(MPX mpx, char *s) {\r
    register int i, d, neg;\r
    if (s == NULL)\r
          goto BAD;\r
    for (neg = 0;; s++) {\r
          if (*s == '-')\r
            neg = !neg;\r
          else if (*s != ' ' && *s != '\t')\r
            break;\r
    }\r
    if (i = *s - '0', 0 > i || i > 9)\r
          goto BAD;\r
    while (d = *++s - '0', 0 <= d && d <= 9)\r
        i = 10 * i + d;\r
    mpx->arg_tail = s;\r
    return neg ? -i : i;\r
  BAD:\r
    mpx->arg_tail = NULL;\r
    return 0;\r
}\r
\r
@ GROFF font description files use octal character codes\r
|groff_font(5)|: The code can be any integer.  If it starts with\r
a 0 it will be interpreted as octal; if it starts with  0x\r
or 0X it will be intepreted as hexadecimal.\r
\r
@c \r
static int mpx_get_int_map(MPX mpx, char *s) {\r
  register int i;\r
  if (s == NULL)\r
        goto BAD;\r
  i = strtol(s, &(mpx->arg_tail), 0);\r
  if (s == mpx->arg_tail)\r
        goto BAD;\r
  return i;\r
BAD:\r
  mpx->arg_tail = NULL;\r
  return 0;\r
}\r
\r
@ Troff output files contain few if any non-integers, but this program is\r
prepared to read floats whenever they seem reasonable; i.e., when the\r
number is not being used for character positioning.  (For non-PostScript\r
applications h and v are usually in pixels and should be integers.)\r
\r
@c \r
static float mpx_get_float(MPX mpx, char *s) {\r
  register int d, neg, digits;\r
  register float x, y;\r
  digits = 0;\r
  neg = 0; x=0.0; \r
  if (s != NULL) {\r
        for (neg = 0;; s++) {\r
      if (*s == '-')\r
                neg = !neg;\r
          else if (*s != ' ' && *s != '\t')\r
                break;\r
    }\r
        x = 0.0;\r
        while (d = *s - '0', 0 <= d && d <= 9) {\r
      x = 10.0 * x + d;\r
          digits++;\r
          s++;\r
        }\r
        if (*s == '.') {\r
          y = 1.0;\r
          while (d = *++s - '0', 0 <= d && d <= 9) {\r
            y /= 10.0;\r
                x += y * d;\r
                digits++;\r
          }\r
        }\r
  }\r
  if (digits == 0) {\r
        mpx->arg_tail = NULL;\r
        return 0.0;\r
  }\r
  mpx->arg_tail = s;\r
  return neg ? -x : x;\r
}\r
\r
@ GROFF font description files have metrics field\r
of comma-separated integers. Traditional troff\r
have a float in this position. The value is not\r
used anyway - thus just skip the value,\r
 eat all non-space chars.\r
\r
@c \r
static float mpx_get_float_map(MPX mpx, char *s) {\r
    if (s != NULL) {\r
        while (isspace(*s))\r
            s++;\r
        while (!isspace(*s) && *s)\r
            s++;\r
    }\r
    mpx->arg_tail = s;\r
    return 0;\r
}\r
\r
\r
@ Reading Initialization Files\r
\r
Read the database file, reserve internal font numbers and set\r
the |font_name| entries.  Each line in the database file contains\r
|<troff-name>\t,PostScript-name>\t<TeX-name>|\r
or just \r
|<troff-name>\t,PostScript-name>| \r
if the \TeX\ name matches the PostScript name. (|\t| means one or more tabs.)\r
\r
@<Globals@>=\r
struct avl_table *trfonts;\r
\r
@ @c\r
static void mpx_read_fmap(MPX mpx, char *dbase) {\r
    FILE *fin;\r
    avl_entry *tmp;\r
    char *nam;                  /* a font name being read */\r
    char *buf;\r
    mpx->nfonts = 0;\r
    fin = mpx_fsearch(mpx,dbase, mpx_trfontmap_format);\r
    if (fin==NULL)\r
          mpx_abort(mpx,"Cannot find %s", dbase);\r
\r
    mpx->trfonts = mpx_avl_create (mpx);\r
    while ((buf = mpx_getline(mpx,fin)) != NULL) {\r
          if (mpx->nfonts == (max_fnums+1))\r
            mpx_abort(mpx,"Need to increase max_fnums");\r
       nam = buf;    \r
       while (*buf && *buf != '\t')\r
         buf++;\r
      tmp = xmalloc(sizeof(avl_entry),1);\r
      tmp->name = nam;\r
      tmp->num = (int)mpx->nfonts++;\r
      (void)mpx_avl_probe (mpx,mpx->trfonts, tmp) ;\r
      if (*buf) {\r
        *buf = 0; buf++;\r
            do buf++; while (*buf == '\t');\r
        while (*buf && *buf != '\t'); buf++; /* skip over psname */\r
        do buf++;  while (*buf == '\t');\r
        if (*buf)\r
          nam = buf;\r
        while (*buf); buf++; \r
      }\r
      mpx->font_name[tmp->num] = xstrdup(nam);\r
          mpx->font_num[tmp->num] = -1; /* indicate font is not mounted */\r
          mpx->nfonts++;\r
    }\r
    mpx_fclose(mpx,fin);\r
}\r
\r
\r
@ Some characters need their coordinates shifted in order to agree with\r
troff's view of the world.  Logically, this information belongs in the\r
font description files but it actually resides in a PostScript prolog\r
that the troff output processor dpost reads.  Since that file is in\r
PostScript and subject to change, we read the same information from\r
a small auxiliary file that gives shift amounts relative to the font\r
size with y upward.\r
\r
GROFF NOTE:\r
The PostScript prologue in GNU groff's font directory does not\r
contain any character shift information, so the following function\r
becomes redundant.  Simply keeping an empty "trchars.adj" file\r
around will do fine without requiring any changes to this program.\r
\r
@c \r
static void mpx_read_char_adj(MPX mpx, char *adjfile) {\r
    FILE *fin;\r
    char buf[200];\r
    avl_entry tmp, *p;\r
    unsigned int i;\r
\r
    fin = mpx_fsearch(mpx,adjfile, mpx_trcharadj_format);\r
    if (fin==NULL)\r
          mpx_abort(mpx,"Cannot find %s", adjfile);\r
\r
    for (i = 0; i < mpx->nfonts; i++)\r
        mpx->shiftbase[i] = 0;\r
    while (fgets(buf, 200, fin) != NULL) {\r
        if (mpx->shiftptr == SHIFTS - 1)\r
            mpx_abort(mpx,"Need to increase SHIFTS");\r
        if (buf[0] != ' ' && buf[0] != '\t') {\r
            for (i = 0; buf[i] != '\0'; i++)\r
                  if (buf[i] == '\n')\r
                    buf[i] = '\0';\r
            mpx->shiftchar[mpx->shiftptr++] = -1;\r
        tmp.name = buf;\r
        p = (avl_entry *)avl_find (mpx->trfonts, &tmp);\r
            if (p==NULL)\r
                  mpx_abort(mpx,"%s refers to unknown font %s", adjfile, buf);\r
            mpx->shiftbase[p->num] = mpx->shiftptr;\r
        \r
        } else {\r
            mpx->shiftchar[mpx->shiftptr] = mpx_get_int(mpx,buf);\r
            mpx->shifth[mpx->shiftptr] = mpx_get_float(mpx,mpx->arg_tail);\r
            mpx->shiftv[mpx->shiftptr] = -mpx_get_float(mpx,mpx->arg_tail);\r
            if (mpx->arg_tail == NULL)\r
                mpx_abort(mpx,"Bad shift entry : \"%s\"", buf);\r
            mpx->shiftptr++;\r
        }\r
    }\r
    mpx->shiftchar[mpx->shiftptr++] = -1;\r
    mpx_fclose(mpx,fin);\r
}\r
\r
@ Read the DESC file of the troff device to gather information\r
   about sizescale and whether running under groff.\r
\r
Ignore all commands not specially handled. This relieves\r
of collecting commands without arguments here and also\r
makes the program more robust in case of future DESC\r
extensions.\r
\r
@c \r
static void mpx_read_desc(MPX mpx) {\r
    const char *const k1[] = {\r
        "res", "hor", "vert", "unitwidth", "paperwidth",\r
        "paperlength", "biggestfont", "spare2", "encoding",\r
        NULL\r
    };\r
    const char *const g1[] = {\r
        "family", "paperheight", "postpro", "prepro",\r
        "print", "image_generator", "broken",\r
        NULL\r
    };\r
    char cmd[200];\r
    FILE *fp;\r
    int i, n;\r
\r
    fp = mpx_fsearch(mpx,"DESC", mpx_desc_format);\r
    if (fp==NULL)\r
          mpx_abort(mpx,"Cannot find DESC");\r
    while (fscanf(fp, "%199s", cmd) != EOF) {\r
        if (*cmd == '#') {\r
            while ((i = getc(fp)) != EOF && i != '\n');\r
            continue;\r
        }\r
        if (strcmp(cmd, "fonts") == 0) {\r
            if (fscanf(fp, "%d", &n) != 1)\r
                return;\r
            for (i = 0; i < n; i++)\r
                if (fscanf(fp, "%*s") == EOF)\r
                    return;\r
        } else if (strcmp(cmd, "sizes") == 0) {\r
            while (fscanf(fp, "%d", &n) == 1 && n != 0);\r
        } else if (strcmp(cmd, "styles") == 0 ||\r
                   strcmp(cmd, "papersize") == 0) {\r
            mpx->gflag++;\r
            while ((i = getc(fp)) != EOF && i != '\n');\r
        } else if (strcmp(cmd, "sizescale") == 0) {\r
            if (fscanf(fp, "%d", &n) == 1)\r
                mpx->sizescale = (float)n;\r
            mpx->gflag++;\r
        } else if (strcmp(cmd, "charset") == 0) {\r
            return;\r
        } else {\r
            for (i = 0; k1[i]; i++)\r
                if (strcmp(cmd, k1[i]) == 0) {\r
                    if (fscanf(fp, "%*s") == EOF)\r
                        return;\r
                    break;\r
                }\r
            if (k1[i] == 0)\r
                for (i = 0; g1[i]; i++)\r
                    if (strcmp(cmd, g1[i]) == 0) {\r
                        if (fscanf(fp, "%*s") == EOF)\r
                            return;\r
                        mpx->gflag = 1;\r
                        break;\r
                    }\r
        }\r
    }\r
}\r
\r
\r
@ Given one line from the character description file for the font with\r
internal number f, save the appropriate data in the charcodes[f] table.\r
A return value of zero indicates a syntax error.\r
\r
GROFF:\r
GNU groff uses an extended font description file format documented\r
in |groff_font(5)|.  In order to allow parsing of groff's font files,\r
this function needs to be rewritten as follows:\r
\r
\item{1.}The `metrics' field parsed by |mpx_get_float(lin);| may include\r
   a comma-separated list of up to six decimal integers rather\r
   than just a single floating-point number.\r
\r
\item{2.}The `charcode' field parsed by |lastcode = mpx_get_int(arg_tail);|\r
   may be given either in decimal, octal, or hexadecimal format.\r
\r
@ @<Globals@>=\r
struct avl_table *charcodes[(max_fnums+1)];     /* hash tables for translating char names */\r
\r
@ @c\r
static int mpx_scan_desc_line(MPX mpx, int f, char *lin) {\r
    static int lastcode;\r
    avl_entry *tmp;\r
    char *s, *t;\r
    t = lin;\r
    while (*lin != ' ' && *lin != '\t' && *lin != '\0')\r
          lin++;\r
    s = xmalloc((size_t)(lin-t+1),1);\r
    strncpy(s,t,(size_t)(lin-t));\r
    while (*lin == ' ' || *lin == '\t')\r
          lin++;\r
    if (*lin == '"') {\r
          if (lastcode < MAXCHARS) {\r
        tmp = xmalloc(sizeof(avl_entry),1);\r
        tmp->name = s ;\r
        tmp->num = lastcode;\r
        (void)mpx_avl_probe (mpx, mpx->charcodes[f],tmp);\r
      }\r
    } else {\r
          (void) mpx_get_float_map(mpx,lin);\r
          (void) mpx_get_int(mpx,mpx->arg_tail);\r
          lastcode = mpx_get_int_map(mpx,mpx->arg_tail);\r
          if (mpx->arg_tail == NULL)\r
            return 0;\r
          if (lastcode < MAXCHARS) {\r
        tmp = xmalloc(sizeof(avl_entry),1);\r
        tmp->name = s ;\r
        tmp->num = lastcode;\r
        (void)mpx_avl_probe (mpx, mpx->charcodes[f],tmp);\r
      }\r
    }\r
    return 1;\r
}\r
\r
@ Read the font description file for the font with the given troff name\r
and update the data structures.  The result is the internal font number.\r
\r
@c \r
static int mpx_read_fontdesc(MPX mpx, char *nam) {      /* troff name */\r
    char buf[200];\r
    avl_entry tmp, *p;\r
    FILE *fin;                  /* input file */\r
    int f;                      /* internal font number */\r
\r
    if (mpx->unit == 0.0)\r
        mpx_abort(mpx, "Resolution is not set soon enough");\r
    tmp.name = nam;\r
    p = (avl_entry *)avl_find (mpx->trfonts, &tmp);\r
    if (p == NULL)\r
          mpx_abort(mpx, "Font was not in map file");\r
    f = p->num;\r
    fin = mpx_fsearch(mpx, nam, mpx_fontdesc_format);\r
    if (fin==NULL)\r
          mpx_abort(mpx,"Cannot find %s", nam);\r
    for (;;) {\r
          if (fgets(buf, 200, fin) == NULL)\r
            mpx_abort(mpx, "Description file for %s ends unexpectedly", nam);\r
          if (strncmp(buf, "special", 7) == 0) {\r
            *(mpx->specf_tail) = f;\r
            mpx->next_specfnt[f] = (max_fnums+1);\r
            mpx->specf_tail = &(mpx->next_specfnt[f]);\r
          } else if (strncmp(buf, "charset", 7) == 0)\r
            break;\r
    }\r
    mpx->charcodes[f] = mpx_avl_create (mpx);\r
    while (fgets(buf, 200, fin) != NULL)\r
          if (mpx_scan_desc_line(mpx, f, buf) == 0)\r
            mpx_abort(mpx, "%s has a bad line in its description file: %s", nam, buf);\r
    mpx_fclose(mpx,fin);\r
    return f;\r
}\r
\r
@               Page and Character Output\r
\r
@<Globals@>=\r
boolean graphics_used;          /* nonzero if any graphics seen on this page */\r
float dmp_str_h1;\r
float dmp_str_v;                /* corrected start pos for current out string */\r
float dmp_str_h2;                       /* where the current output string ends */\r
float str_size;                 /* point size for this text string */\r
\r
\r
@ Print any transformations required by the current Xslant and Xheight settings.\r
\r
@<Declarations@>=\r
static void mpx_slant_and_ht(MPX mpx);\r
\r
@ @c\r
static void mpx_slant_and_ht(MPX mpx) {\r
 int i = 0;\r
 if (mpx->Xslant != 0.0) {\r
        fprintf(mpx->mpxfile, " slanted%.5f", mpx->Xslant);\r
        i++;\r
  }\r
  if (mpx->Xheight != mpx->cursize && mpx->Xheight != 0.0 && mpx->cursize != 0.0) {\r
        fprintf(mpx->mpxfile, " yscaled%.4f", mpx->Xheight / mpx->cursize);\r
        i++;\r
  }\r
  if (i > 0)\r
        fprintf(mpx->mpxfile, "\n ");\r
}\r
\r
\r
@ Output character number c in the font with internal number f.\r
\r
@c \r
static void mpx_set_num_char(MPX mpx, int f, int c) {\r
    float hh, vv;               /* corrected versions of h, v */\r
    int i;\r
\r
    hh = mpx->h;\r
    vv = mpx->v;\r
    for (i = mpx->shiftbase[f]; mpx->shiftchar[i] >= 0; i++)\r
        if (mpx->shiftchar[i] == c) {\r
            hh += (mpx->cursize / mpx->unit) * mpx->shifth[i];\r
            vv += (mpx->cursize / mpx->unit) * mpx->shiftv[i];\r
            break;\r
        }\r
    if (hh - mpx->dmp_str_h2 >= 1.0 || mpx->dmp_str_h2 - hh >= 1.0 || \r
        vv - mpx->dmp_str_v >= 1.0 || mpx->dmp_str_v - vv >= 1.0 || \r
        f != mpx->str_f || mpx->cursize != mpx->str_size) {\r
          if (mpx->str_f >= 0)\r
            mpx_finish_last_char(mpx);\r
          else if (!mpx->fonts_used)\r
            mpx_prepare_font_use(mpx);  /* first font usage on this page */\r
          if (!mpx->font_used[f])\r
            mpx_first_use(mpx,f);       /* first use of font f on this page */\r
          fprintf(mpx->mpxfile, "_s((");\r
          mpx->print_col = 3;\r
          mpx->str_f = f;\r
          mpx->dmp_str_v = vv;\r
          mpx->dmp_str_h1 = hh;\r
          mpx->str_size = mpx->cursize;\r
    }\r
    mpx_print_char(mpx, (unsigned char)c);\r
    mpx->dmp_str_h2 = hh + char_width(f,c);\r
}\r
\r
@ Output a string. \r
\r
@c\r
static void mpx_set_string(MPX mpx, char *cname) {\r
    float hh;                   /* corrected version of h, current horisontal position */\r
\r
    if (!*cname)\r
          return;\r
    hh = mpx->h;\r
    mpx_set_num_char(mpx,(int)mpx->curfont, *cname);\r
    hh +=  char_width(mpx->curfont,(int)*cname);\r
    while (*++cname) {\r
          mpx_print_char(mpx,(unsigned char)*cname);\r
          hh += char_width(mpx->curfont,(int)*cname);\r
    }\r
    mpx->h = (double)floor(hh+0.5);\r
    mpx_finish_last_char(mpx);\r
}\r
\r
@ Special Characters\r
\r
Given the troff name of a special character, this routine finds its\r
definition and copies it to the MPX file.  It also finds the name of\r
the vardef macro and returns that name. The name should be C.<something>.\r
\r
@ \r
TH: A bit of trickery is added here for case-insensitive \r
file systems. This aliasing allows the CHARLIB directory\r
to exist on DVDs, for example.\r
It is a hack, I know. I've stuck to  names on TeXLive.\r
\r
@d test_redo_search do {\r
   if (deff==NULL)\r
         deff = mpx_fsearch(mpx, cname, mpx_specchar_format);\r
 } while (0)\r
\r
@c\r
static char *mpx_copy_spec_char(MPX mpx, char *cname) {\r
  FILE *deff;\r
  int c;\r
  char *s, *t;\r
  char specintro[] = "vardef "; /* MetaPost name follows this */\r
  unsigned k = 0;                       /* how much of specintro so far */\r
  if (strcmp(cname, "ao") == 0) {\r
        deff = mpx_fsearch(mpx, "ao.x", mpx_specchar_format);\r
        test_redo_search;\r
  } else if (strcmp(cname, "lh") == 0) {\r
        deff = mpx_fsearch(mpx, "lh.x", mpx_specchar_format);\r
        test_redo_search;\r
  } else if (strcmp(cname, "~=") == 0) {\r
        deff = mpx_fsearch(mpx, "twiddle", mpx_specchar_format);\r
        test_redo_search;\r
  } else {\r
        deff = mpx_fsearch(mpx, cname, mpx_specchar_format);\r
  }\r
  if (deff==NULL)\r
     mpx_abort(mpx, "No vardef in charlib/%s", cname);\r
\r
  while (k < (unsigned)strlen(specintro)) {\r
        if ((c = getc(deff)) == EOF)\r
            mpx_abort(mpx, "No vardef in charlib/%s", cname);\r
        putc(c, mpx->mpxfile);\r
        if (c == specintro[k])\r
          k++;\r
        else\r
          k = 0;\r
  }\r
  s = xmalloc(mpx->bufsize,1);\r
  t = s ;\r
  while ((c = getc(deff)) != '(') {\r
        if (c == EOF)\r
          mpx_abort(mpx, "vardef in charlib/%s has no arguments", cname);\r
        putc(c, mpx->mpxfile);\r
        *t++ = c;\r
  }\r
  putc(c, mpx->mpxfile);\r
  *t++ = '\0';\r
  while ((c = getc(deff)) != EOF);\r
    putc(c, mpx->mpxfile);\r
  return s;\r
}\r
\r
\r
@ When given a character name instead of a number, we need to check if\r
it is a special character and download the definition if necessary.\r
If the character is not in the current font we have to search the special\r
fonts.\r
\r
@<Globals@>=\r
struct avl_table *spec_tab;\r
\r
@ The |spec_tab| avl table combines character names with macro names. \r
\r
@<Types...@>=\r
typedef struct {\r
    char *name;\r
    char *mac;\r
} spec_entry;\r
\r
@ @c \r
static void mpx_set_char(MPX mpx, char *cname) {\r
  int f, c;\r
  avl_entry tmp, *p;\r
  spec_entry *sp;\r
\r
  if (*cname == ' ' || *cname == '\t')\r
        return;\r
  f = (int)mpx->curfont;\r
  tmp.name = cname;\r
  p = avl_find(mpx->charcodes[f], &tmp);\r
  if (p==NULL) {\r
        for (f = mpx->specfnt; f != (max_fnums+1); f = mpx->next_specfnt[f]) {\r
        p = avl_find(mpx->charcodes[f], &tmp);\r
            if (p!=NULL)\r
                  goto OUT;\r
        }\r
        mpx_abort(mpx, "There is no character %s", cname);\r
  }\r
OUT:\r
  c = p->num;\r
  if (!is_specchar(c)) {\r
        mpx_set_num_char(mpx, f, c);\r
  } else {\r
        if (mpx->str_f >= 0)\r
            mpx_finish_last_char(mpx);\r
        if (!mpx->fonts_used)\r
            mpx_prepare_font_use(mpx);\r
        if (!mpx->font_used[f])\r
            mpx_first_use(mpx, f);\r
        if (mpx->spec_tab)\r
       mpx->spec_tab = mpx_avl_create (mpx);\r
    sp = xmalloc(sizeof(spec_entry),1);\r
    sp->name = cname;\r
    sp->mac = NULL;\r
    sp  = (spec_entry *)avl_probe(mpx->spec_tab,sp);\r
    if (sp==NULL)\r
      mpx_abort(mpx,"Memory allocation failure");\r
        if (sp->mac == NULL) {\r
      sp->mac = mpx_copy_spec_char(mpx, cname); /* this won't be NULL */\r
    }\r
        fprintf(mpx->mpxfile, "_s(%s(n%d)", sp->mac, mpx->font_num[f]);\r
        mpx_slant_and_ht(mpx);\r
        fprintf(mpx->mpxfile, ",%.5f,%.4f,%.4f);\n",\r
                (mpx->cursize/mpx->font_design_size[f])*1.00375, mpx->h*mpx->unit, YCORR-mpx->v*mpx->unit);\r
  }\r
}\r
\r
@ Font Definitions\r
\r
Mount the font with troff name nam at external font number n and read any\r
necessary font files.\r
\r
@c\r
static void mpx_do_font_def(MPX mpx, int n, char *nam) {\r
  int f;\r
  unsigned k;\r
  avl_entry tmp, *p;\r
  tmp.name = nam;\r
  p = (avl_entry *) avl_find (mpx->trfonts, &tmp);\r
  if (p==NULL)\r
    mpx_abort(mpx, "Font %s was not in map file", nam);\r
  f = p->num;\r
  if ( mpx->info_base[f]==max_widths ) {\r
    mpx_read_fontdesc(mpx, nam);\r
    mpx->cur_name = xstrdup(mpx->font_name[f]);\r
    if (! mpx_open_tfm_file(mpx) )\r
      font_abort("No TFM file found for ",f);\r
@.no TFM file found@>\r
    mpx_in_TFM(mpx, f);\r
  }\r
  for (k = 0; k < mpx->nfonts; k++)\r
        if (mpx->font_num[k] == n)\r
            mpx->font_num[k] = -1;\r
  mpx->font_num[f] = n;\r
  @<Do any other initialization required for the new font |f|@>;\r
}\r
\r
\r
\r
@ Time on `makepath pencircle'\r
\r
Given the control points of a cubic Bernstein polynomial, evaluate it at t.\r
\r
@d Speed        ((float) (PI/4.0))\r
\r
@c\r
static float mpx_b_eval(const float *xx, float t) {\r
    float zz[4];\r
    register int i, j;\r
    for (i = 0; i <= 3; i++)\r
        zz[i] = xx[i];\r
    for (i = 3; i > 0; i--)\r
        for (j = 0; j < i; j++)\r
            zz[j] += t * (zz[j + 1] - zz[j]);\r
    return zz[0];\r
}\r
\r
\r
@ Find the direction angle at time t on the path `makepath pencircle'.\r
The tables below give the Bezier control points for MetaPost's cubic\r
approximation to the first octant of a unit circle.\r
\r
@c\r
static const float xx[] = { 1.0, 1.0, 0.8946431597,  0.7071067812 };\r
static const float yy[] = { 0.0, 0.2652164899, 0.5195704026, 0.7071067812 };\r
\r
@ @c\r
static float mpx_circangle(float t) {\r
    float ti;\r
    ti = floor(t);\r
    t -= ti;\r
    return (float) atan(mpx_b_eval(yy, t) / \r
                        mpx_b_eval(xx, t)) + ti * Speed;\r
}\r
\r
\r
@ Find the spline parameter where `makepath pencircle' comes closest to\r
   (cos(a)/2,sin(a)/2).\r
\r
@c\r
static float mpx_circtime(float a) {\r
    int i;\r
    float t;\r
    t = a / Speed;\r
    for (i = 2; --i >= 0;)\r
        t += (a - mpx_circangle(t)) / Speed;\r
    return t;\r
}\r
\r
\r
\r
@ Troff Graphics\r
\r
@<Globals@>=\r
float gx;\r
float gy;                       /* current point for graphics (init. (h,YCORR/mpx->unit-v) */\r
\r
@ @c \r
static void mpx_prepare_graphics(MPX mpx) {\r
\r
  fprintf(mpx->mpxfile, "vardef _D(expr _d)expr _q =\n");\r
  fprintf(mpx->mpxfile,\r
    " addto _p doublepath _q withpen pencircle scaled _d; enddef;\n");\r
  mpx->graphics_used = true;\r
}\r
\r
\r
@ This function prints the current position (gx,gy).  Then if it can read dh dv\r
from string s, it increments (gx,gy) and prints "--".  By returning the rest\r
of the string s or NULL if nothing could be read from s, it provides the\r
argument for the next iteration.\r
\r
@c \r
static char *mpx_do_line(MPX mpx, char *s) {\r
  float dh, dv;\r
\r
  fprintf(mpx->mpxfile, "(%.3f,%.3f)", mpx->gx * mpx->unit, mpx->gy * mpx->unit);\r
  dh = mpx_get_float(mpx, s);\r
  dv = mpx_get_float(mpx, mpx->arg_tail);\r
  if (mpx->arg_tail == NULL)\r
    return NULL;\r
  mpx->gx += dh;\r
  mpx->gy -= dv;\r
  fprintf(mpx->mpxfile, "--\n");\r
  return mpx->arg_tail;\r
}\r
\r
\r
@ Function |spline_seg()| reads two pairs of (dh,dv) increments and prints the\r
corresponding quadratic B-spline segment, leaving the ending point to be\r
printed next time.  The return value is the string with the first (dh,dv)\r
pair lopped off.  If only one pair of increments is found, we prepare to\r
terminate the iteration by printing last time's ending point and returning\r
NULL.\r
\r
@c \r
static char * mpx_spline_seg(MPX mpx, char *s) {\r
  float dh1, dv1, dh2, dv2;\r
\r
  dh1 = mpx_get_float(mpx, s);\r
  dv1 = mpx_get_float(mpx, mpx->arg_tail);\r
  if (mpx->arg_tail == NULL)\r
        mpx_abort(mpx, "Missing spline increments");\r
  s = mpx->arg_tail;\r
  fprintf(mpx->mpxfile, "(%.3f,%.3f)", (mpx->gx + .5 * dh1) * mpx->unit,\r
            (mpx->gy - .5 * dv1) * mpx->unit);\r
  mpx->gx += dh1;\r
  mpx->gy -= dv1;\r
  dh2 = mpx_get_float(mpx, s);\r
  dv2 = mpx_get_float(mpx, mpx->arg_tail);\r
  if (mpx->arg_tail == NULL)\r
        return NULL;\r
  fprintf(mpx->mpxfile, "..\ncontrols (%.3f,%.3f) and (%.3f,%.3f)..\n",\r
            (mpx->gx - dh1 / 6.0) * mpx->unit, (mpx->gy + dv1 / 6.0) * mpx->unit,\r
            (mpx->gx + dh2 / 6.0) * mpx->unit, (mpx->gy - dv2 / 6.0) * mpx->unit);\r
  return s;\r
}\r
\r
\r
@ Draw an ellipse with the given major and minor axes.\r
\r
@c \r
static void mpx_do_ellipse(MPX mpx, float a, float b) {\r
\r
  fprintf(mpx->mpxfile, "makepath(pencircle xscaled %.3f\n yscaled %.3f",\r
            a * mpx->unit, b * mpx->unit);\r
  fprintf(mpx->mpxfile, " shifted (%.3f,%.3f));\n", (mpx->gx + .5 * a) * mpx->unit,\r
            mpx->gy * mpx->unit);\r
  mpx->gx += a;\r
}\r
\r
\r
@ Draw a counter-clockwise arc centered at (cx,cy) with initial and final radii\r
   (ax,ay) and (bx,by) respectively.\r
\r
@c \r
static \r
void mpx_do_arc(MPX mpx, float cx, float cy, float ax, float ay, float bx, float by) {\r
  float t1, t2;\r
\r
  t1 = mpx_circtime(atan2(ay, ax));\r
  t2 = mpx_circtime(atan2(by, bx));\r
  if (t2 < t1)\r
        t2 += 8.0;\r
  fprintf(mpx->mpxfile, "subpath (%.5f,%.5f) of\n", t1, t2);\r
  fprintf(mpx->mpxfile,\r
            " makepath(pencircle scaled %.3f shifted (%.3f,%.3f));\n",\r
            2.0 * sqrt(ax * ax + ay * ay) * mpx->unit, cx * mpx->unit, cy * mpx->unit);\r
  mpx->gx = cx + bx;\r
  mpx->gy = cy + by;\r
}\r
\r
\r
\r
@ String s is everything following the initial `D' in a troff graphics command.\r
\r
@c \r
static void mpx_do_graphic(MPX mpx, char *s) {\r
  float h1, v1, h2, v2;\r
\r
  mpx_finish_last_char(mpx);\r
  /* GROFF uses Fd to set fill color for solid drawing objects to the\r
     default, so just ignore that.\r
   */\r
  if (s[0] == 'F' && s[1] == 'd')\r
        return;\r
  mpx->gx = (float) mpx->h;\r
  mpx->gy = YCORR / mpx->unit - ((float) mpx->v);\r
  if (!mpx->graphics_used)\r
        mpx_prepare_graphics(mpx);\r
  fprintf(mpx->mpxfile, "D(%.4f) ", LWscale * mpx->cursize);\r
  switch (*s++) {\r
  case 'c':\r
        h1 = mpx_get_float(mpx,s);\r
        if (mpx->arg_tail == NULL)\r
            mpx_abort(mpx,"Bad argument in %s", s-2);\r
        mpx_do_ellipse(mpx,h1, h1);\r
        break;\r
  case 'e':\r
        h1 = mpx_get_float(mpx,s);\r
        v1 = mpx_get_float(mpx,mpx->arg_tail);\r
        if (mpx->arg_tail == NULL)\r
            mpx_abort(mpx,"Bad argument in %s", s - 2);\r
        mpx_do_ellipse(mpx,h1, v1);\r
        break;\r
  case 'A':\r
        fprintf(mpx->mpxfile, "reverse ");\r
        /* fall through */\r
  case 'a':\r
        h1 = mpx_get_float(mpx,s);\r
        v1 = mpx_get_float(mpx,mpx->arg_tail);\r
        h2 = mpx_get_float(mpx,mpx->arg_tail);\r
        v2 = mpx_get_float(mpx,mpx->arg_tail);\r
        if (mpx->arg_tail == NULL)\r
            mpx_abort(mpx,"Bad argument in %s", s - 2);\r
        mpx_do_arc(mpx,mpx->gx + h1, mpx->gy - v1, -h1, v1, h2, -v2);\r
        break;\r
  case 'l':\r
  case 'p':\r
        while (s != NULL)\r
            s = mpx_do_line(mpx,s);\r
        fprintf(mpx->mpxfile, ";\n");\r
        break;\r
  case 'q':\r
        do\r
      s = mpx_spline_seg(mpx,s);\r
        while (s != NULL);\r
        fprintf(mpx->mpxfile, ";\n");\r
        break;\r
  case '~':\r
        fprintf(mpx->mpxfile, "(%.3f,%.3f)--", mpx->gx * mpx->unit, mpx->gy * mpx->unit);\r
        do\r
            s = mpx_spline_seg(mpx,s);\r
        while (s != NULL);\r
        fprintf(mpx->mpxfile, "--(%.3f,%.3f);\n", mpx->gx * mpx->unit, mpx->gy * mpx->unit);\r
    break;\r
  default:\r
        mpx_abort(mpx,"Unknown drawing function %s", s - 2);\r
  }\r
  mpx->h = (int) floor(mpx->gx + .5);\r
  mpx->v = (int) floor(YCORR / mpx->unit + .5 - mpx->gy);\r
}\r
\r
\r
\r
@ Interpreting Troff Output\r
\r
@c\r
static void mpx_change_font(MPX mpx, int f) {\r
    for (mpx->curfont = 0; mpx->curfont < mpx->nfonts; mpx->curfont++)\r
        if (mpx->font_num[mpx->curfont] == f)\r
            return;\r
    mpx_abort(mpx,"Bad font setting");\r
}\r
\r
\r
@ String s0 is everything following the initial `x' in a troff device control\r
   command.  A zero result indicates a stop command.\r
\r
@c\r
static int mpx_do_x_cmd(MPX mpx, char *s0)\r
{\r
    float x;\r
    int n;\r
    char *s;\r
\r
    s = s0;\r
    while (*s == ' ' || *s == '\t')\r
        s++;\r
    switch (*s++) {\r
    case 'r':\r
        if (mpx->unit != 0.0)\r
            mpx_abort(mpx,"Attempt to reset resolution");\r
        while (*s != ' ' && *s != '\t')\r
            s++;\r
        mpx->unit = mpx_get_float(mpx,s);\r
        if (mpx->unit <= 0.0)\r
            mpx_abort(mpx,"Bad resolution: x %s", s0);\r
        mpx->unit = 72.0 / mpx->unit;\r
        break;\r
    case 'f':\r
        while (*s != ' ' && *s != '\t')\r
            s++;\r
        n = mpx_get_int(mpx,s);\r
        if (mpx->arg_tail == NULL)\r
            mpx_abort(mpx,"Bad font def: x %s", s0);\r
        s = mpx->arg_tail;\r
        while (*s == ' ' || *s == '\t')\r
            s++;\r
        mpx_do_font_def(mpx,n, s);\r
        break;\r
    case 's':\r
        return 0;\r
    case 'H':\r
        while (*s != ' ' && *s != '\t')\r
            s++;\r
        mpx->Xheight = mpx_get_float(mpx,s);\r
        /* GROFF troff output is scaled |groff_out(5)|: \r
       The argument to the s command is in scaled\r
           points (units of points/n, where n is the argument\r
           to the sizescale command  in the DESC file.)  The\r
           argument to the x Height command is also in scaled points.\r
           sizescale for groff devps is 1000\r
         */\r
        if (mpx->sizescale != 0.0) {\r
            if (mpx->unit != 0.0)\r
                mpx->Xheight *= mpx->unit;      /* ??? */\r
            else\r
                mpx->Xheight /= mpx->sizescale;\r
        }\r
        if (mpx->Xheight == mpx->cursize)\r
            mpx->Xheight = 0.0;\r
        break;\r
    case 'S':\r
        while (*s != ' ' && *s != '\t')\r
            s++;\r
        mpx->Xslant = mpx_get_float(mpx,s) * (PI / 180.0);\r
        x = cos(mpx->Xslant);\r
        if (-1e-4 < x && x < 1e-4)\r
            mpx_abort(mpx,"Excessive slant");\r
        mpx->Xslant = sin(mpx->Xslant) / x;\r
        break;\r
    default:\r
        /* do nothing */ ;\r
    }\r
    return 1;\r
}\r
\r
\r
@ This routine reads commands from the troff output file up to and including\r
the next `p' or `x s' command.  It also calls |set_num_char()| and |set_char()|\r
to generate output when appropriate.  A zero result indicates that there\r
are no more pages to do.\r
\r
GROFF:\r
GNU groff uses an extended device-independent output file format\r
documented in |groff_out(5)|. In order to allow parsing of groff's\r
output files, this function either needs to be extended to support\r
the new command codes, or else the use of the "t" and "u" commands\r
must be disabled by removing the line "tcommand" from the DESC file\r
in the \$(prefix)/lib/groff/devps directory.\r
\r
@c\r
static int mpx_do_page (MPX mpx, FILE *trf) {\r
    char *buf;\r
    char a, *c, *cc;\r
\r
    mpx->h = mpx->v = 0;\r
    while ((buf = mpx_getline(mpx, trf)) != NULL) {\r
        mpx->lnno++;\r
        c = buf;\r
        while (*c != '\0') {\r
            switch (*c) {\r
            case ' ':\r
            case '\t':\r
            case 'w':\r
                c++;\r
                break;\r
            case 's':\r
                mpx->cursize = mpx_get_float(mpx,c + 1);\r
                /* GROFF troff output is scaled\r
                   |groff_out(5)|: The argument to the s command is in scaled\r
                   points (units of points/n, where n is the argument\r
                   to the sizescale command  in the DESC file.)  The\r
                   argument to the x Height command is also in scaled\r
                   points.\r
                   sizescale for groff devps is 1000\r
                 */\r
                if (mpx->sizescale != 0.0) {\r
                    if (mpx->unit != 0.0)\r
                        mpx->cursize *= mpx->unit;      /* ??? */\r
                    else\r
                        mpx->cursize /= mpx->sizescale;\r
                }\r
                goto iarg;\r
            case 'f':\r
                mpx_change_font(mpx, mpx_get_int(mpx,c + 1));\r
                goto iarg;\r
            case 'c':\r
                if (c[1] == '\0')\r
                    mpx_abort(mpx, "Bad c command in troff output");\r
                cc = c + 2;\r
                goto set;\r
            case 'C':\r
                cc = c;\r
                do\r
                    cc++;\r
                while (*cc != ' ' && *cc != '\t' && *cc != '\0');\r
                goto set;\r
            case 'N':\r
                mpx_set_num_char(mpx, (int)mpx->curfont, mpx_get_int(mpx,c + 1));\r
                goto iarg;\r
            case 'H':\r
                 mpx->h = mpx_get_int(mpx, c + 1);\r
                goto iarg;\r
            case 'V':\r
                 mpx->v = mpx_get_int(mpx, c + 1);\r
                goto iarg;\r
            case 'h':\r
                 mpx->h += mpx_get_int(mpx, c + 1);\r
                goto iarg;\r
            case 'v':\r
                 mpx->v += mpx_get_int(mpx, c + 1);\r
                goto iarg;\r
            case '0':\r
            case '1':\r
            case '2':\r
            case '3':\r
            case '4':\r
            case '5':\r
            case '6':\r
            case '7':\r
            case '8':\r
            case '9':\r
                if (c[1] < '0' || c[1] > '9' || c[2] == '\0')\r
                    mpx_abort(mpx, "Bad nnc command in troff output");\r
                 mpx->h += 10 * (c[0] - '0') + c[1] - '0';\r
                c++;\r
                cc = c + 2;\r
                goto set;\r
            case 'p':\r
                return 1;\r
            case 'n':\r
                (void) mpx_get_int(mpx, c + 1);\r
                (void) mpx_get_int(mpx, mpx->arg_tail);\r
                goto iarg;\r
            case 'D':\r
                mpx_do_graphic(mpx, c + 1);\r
                goto eoln;\r
            case 'x':\r
                if (!mpx_do_x_cmd(mpx, c + 1))\r
                    return 0;\r
                goto eoln;\r
            case '#':\r
                goto eoln;\r
            case 'F':\r
                /* GROFF uses this command to report filename */\r
                goto eoln;\r
            case 'm':\r
                /* GROFF uses this command to control color */\r
                goto eoln;\r
            case 'u':\r
                /* GROFF uses this command to output a word with additional\r
                   white space between characters, not implemented\r
                 */\r
                mpx_abort(mpx, "Bad command in troff output\n"\r
                     "change the DESC file for your GROFF PostScript device, remove tcommand");\r
            case 't':\r
                /* GROFF uses this command to output a word */\r
                cc = c;\r
                do\r
                    cc++;\r
                while (*cc != ' ' && *cc != '\t' && *cc != '\0');\r
                a = *cc;\r
                *cc = '\0';\r
                mpx_set_string(mpx, ++c);\r
                c = cc;\r
                *c = a;\r
                continue;\r
            default:\r
                mpx_abort(mpx, "Bad command in troff output");\r
            }\r
            continue;\r
          set:\r
        a = *cc;\r
            *cc = '\0';\r
            mpx_set_char(mpx, ++c);\r
            c = cc;\r
            *c = a;\r
            continue;\r
          iarg:\r
        c = mpx->arg_tail;\r
        }\r
      eoln:                     /* do nothing */ ;\r
    }\r
    return 0;\r
}\r
\r
\r
@ Main Dmp Program\r
\r
@d dbname "trfonts.map" /* file for table of troff \& TFM font names */\r
@d adjname "trchars.adj" /* file for character shift amounts */\r
\r
@c\r
static int mpx_dmp(MPX mpx, char *infile) {\r
    int more;\r
    FILE *trf = mpx_xfopen(mpx,infile, "r");\r
    mpx_open_mpxfile(mpx);\r
    if (mpx->banner != NULL)\r
      fprintf (mpx->mpxfile,"%s\n",mpx->banner);\r
    mpx_read_desc(mpx);\r
    mpx_read_fmap(mpx,dbname);\r
    if (!mpx->gflag)\r
          mpx_read_char_adj(mpx,adjname);\r
    if (mpx_do_page(mpx, trf)) {\r
          do {\r
        @<Do initialization required before starting a new page@>;\r
            mpx_start_picture(mpx);\r
            more = mpx_do_page(mpx,trf);\r
            mpx_stop_picture(mpx);\r
            fprintf(mpx->mpxfile, "mpxbreak\n");\r
          } while (more);\r
    }\r
    mpx_fclose(mpx,trf);\r
    mpx_fclose(mpx,mpx->mpxfile);\r
    if ( mpx->history<=mpx_cksum_trouble )\r
      return 0;\r
    else \r
      return mpx->history;\r
}\r
\r
\r
@* \[5] Makempx.\r
\r
\r
Make an MPX file from the labels in a MetaPost source file,\r
using mpto and either dvitomp (TeX) or dmp (troff).\r
\r
Started from a shell script initially based on John Hobby's original\r
version, that was then translated to C by Akira Kakuto (Aug 1997, \r
Aug 2001), and updated and largely rewritten by Taco Hoekwater (Nov 2006).\r
\r
\r
Differences between the script and this C version:\r
\r
The script trapped HUP, INT, QUIT and TERM for cleaning up \r
temporary files. This is a refinement, and not portable.\r
\r
The script put its own directory in front of the\r
executable search PATH. This is not portable either, and\r
it seems a safe bet that normal users do not have 'mpto', \r
'dvitomp', or 'dmp' commands in their path.  \r
\r
The command-line '-troff' now also accepts an optional argument.\r
\r
The troff infile for error diagnostics is renamed "mpxerr.i", \r
not plain "mpxerr".\r
\r
The original script deleted mpx*.* in the cleanup process. \r
\r
That is a bit harder in C, because it requires reading the contents \r
of the current directory.  The current program assumes that \r
opendir(), readdir() and closedir() are known everywhere where \r
the function getcwd() exists (except on WIN32, where it uses\r
|_findfirst| \& co).\r
\r
If this assumption is false, you can define |NO_GETCWD|, and makempx\r
will revert to trying to delete only a few known extensions\r
\r
There is a -debug switch, preventing the removal of tmp files\r
\r
@d TMPNAME_EXT(a,b) { strcpy(a,tmpname); strcat(a,b); }\r
\r
@c\r
\r
#define TEXERR "mpxerr.tex"\r
#define DVIERR "mpxerr.dvi"\r
#define TROFF_INERR "mpxerr.i"\r
#define TROFF_OUTERR "mpxerr.t"\r
\r
@ @c \r
static void mpx_rename (MPX mpx, char *a, char *b) {\r
  mpx_report(mpx,"renaming %s to %s",a,b); \r
  rename(a,b); \r
}\r
\r
@ @<Globals@>=\r
char tex[15] ;\r
int debug ;\r
char *progname;\r
\r
@ Cleaning up\r
@c\r
static void  mpx_default_erasetmp(MPX mpx) {\r
    char *wrk;\r
    char *p;\r
    if (mpx->mode==mpx_tex_mode) {\r
      wrk = xstrdup(mpx->tex);\r
      p = strrchr(wrk, '.');\r
      *p = '\0';  strcat(wrk, ".aux");   remove(wrk);\r
      *p = '\0';  strcat(wrk, ".pdf");   remove(wrk);\r
      *p = '\0';  strcat(wrk, ".toc");   remove(wrk);\r
      *p = '\0';  strcat(wrk, ".idx");   remove(wrk);\r
      *p = '\0';  strcat(wrk, ".ent");   remove(wrk);\r
      *p = '\0';  strcat(wrk, ".out");   remove(wrk);\r
      *p = '\0';  strcat(wrk, ".nav");   remove(wrk);\r
      *p = '\0';  strcat(wrk, ".snm");   remove(wrk);\r
      *p = '\0';  strcat(wrk, ".tui");   remove(wrk);\r
      free(wrk);\r
    }\r
}\r
\r
@ @<Declarations@>=\r
static void mpx_erasetmp(MPX mpx);\r
\r
@ @c\r
static void mpx_cleandir(MPX mpx, char *cur_path) {\r
  char *wrk, *p;\r
#ifdef _WIN32\r
  struct _finddata_t c_file;\r
  long hFile;\r
#else\r
  struct dirent *entry;\r
  DIR *d;\r
#endif\r
  wrk = xstrdup(mpx->tex);\r
  p = strrchr(wrk, '.');\r
  *p = '\0'; /* now wrk is identical to tmpname */ \r
\r
#ifdef _WIN32\r
  strcat(cur_path,"/*");\r
  if ((hFile = _findfirst (cur_path, &c_file)) == -1L) {\r
    mpx_default_erasetmp(mpx);\r
  } else {\r
    if (strstr(c_file.name,wrk)==c_file.name) \r
          remove(c_file.name);\r
        while (_findnext (hFile, &c_file) != -1L) {\r
          if (strstr(c_file.name,wrk)==c_file.name) \r
            remove(c_file.name);\r
        }\r
        _findclose (hFile); /* no more entries => close directory */\r
  }\r
#else\r
  if ((d = opendir(cur_path)) == NULL) {\r
        mpx_default_erasetmp(mpx);\r
  } else {\r
        while ((entry = readdir (d)) != NULL) {\r
      if (strstr(entry->d_name,wrk)==entry->d_name) \r
            remove(entry->d_name);\r
        }\r
    closedir(d);\r
  }\r
#endif      \r
  free(wrk);\r
}\r
\r
\r
@ It is important that |mpx_erasetmp| remains silent.\r
If it find trouble, it should just ignore it.\r
\r
The string |cur_path| is a little bit larger than needed, because that \r
allows the win32 code in |cleandir| to add the slash and asterisk for \r
globbing without having to reallocate the variable first.\r
\r
@c\r
#ifdef WIN32\r
#define GETCWD _getcwd\r
#else\r
#define GETCWD getcwd\r
#endif\r
static void mpx_erasetmp(MPX mpx) {\r
  char cur_path[1024];\r
  if (mpx->debug)\r
        return;\r
  if (mpx->tex[0] != '\0') {\r
    remove(mpx->tex);\r
    if(GETCWD(cur_path,1020) == NULL) {\r
      mpx_default_erasetmp(mpx); /* don't know where we are */\r
    } else {\r
      mpx_cleandir(mpx,cur_path);\r
    }\r
  }\r
}\r
\r
\r
@* Running the external typesetters.\r
\r
First, here is a helper for messaging.\r
\r
@c\r
static char *mpx_print_command (MPX mpx, int cmdlength, char **cmdline) {\r
  char *s, *t;\r
  int i,l;\r
  (void)mpx;\r
  l = 0;\r
  for (i = 0; i < cmdlength ; i++) {\r
     l += strlen(cmdline[i])+1;\r
  }\r
  s = xmalloc((size_t)l,1); t=s;\r
  for (i = 0; i < cmdlength ; i++) {\r
    if (i>0) *t++ = ' ';\r
    t = strcpy(t,cmdline[i]);\r
    t += strlen(cmdline[i]);\r
  }\r
  return s;\r
}\r
\r
@ This function unifies the external program calling across Posix-like and Win32\r
systems.\r
\r
@c\r
static int do_spawn (MPX mpx, char *cmd, char **options) {\r
#ifndef WIN32\r
   int retcode = -1;\r
   pid_t child;\r
   child = fork();\r
   if (child < 0) \r
     mpx_abort(mpx, "fork failed: %s", strerror(errno));\r
   if (child == 0) {\r
         if(execvp(cmd, options))\r
       mpx_abort(mpx, "exec failed: %s", strerror(errno));\r
   } else {\r
         if (wait(&retcode)==child) {\r
       retcode = (WIFEXITED(retcode) ? WEXITSTATUS(retcode) : -1);\r
     } else {\r
       mpx_abort(mpx, "wait failed: %s", strerror(errno));\r
     }  \r
   }\r
   return retcode;\r
#else\r
   (void)mpx;\r
   return spawnvp(P_WAIT, cmd, (const char **)options);\r
#endif\r
}\r
\r
@ @c\r
#ifdef WIN32\r
#define nuldev "nul"\r
#else\r
#define nuldev "/dev/null"\r
#endif\r
static int mpx_run_command(MPX mpx, char *inname, char *outname, int count, char **cmdl) {\r
    char *s;\r
    int retcode;\r
    int sav_o, sav_i; /* for I/O redirection */\r
    FILE *fr, *fw;    /* read and write streams for the command */\r
\r
    if (count < 1 || cmdl == NULL || cmdl[0] == NULL)\r
          return -1; /* return non-zero by default, signalling an error */\r
     \r
    s = mpx_print_command(mpx,count, cmdl);\r
    mpx_report(mpx,"running command %s", s);\r
    free(s);\r
    \r
    fr = mpx_xfopen(mpx,(inname ? inname : nuldev), "r");\r
    fw = mpx_xfopen(mpx,(outname ? outname : nuldev), "wb");\r
    @<Save and redirect the standard I/O@>;\r
    retcode = do_spawn(mpx,cmdl[0], cmdl);\r
    @<Restore the standard I/O@>;\r
    mpx_fclose(mpx,fr);\r
    mpx_fclose(mpx,fw);\r
    return retcode;\r
}\r
\r
@ @ Running Troff is more likely than not a series of pipes that \r
feed input to each other. Makempx does all of this itself by using\r
temporary files inbetween. That means we have to juggle about with\r
|stdin| and |stdout|.\r
\r
This is the only non-ansi C bit of makempx.\r
@^system dependencies@>\r
\r
@<Save and redirect the standard I/O@>=\r
#ifdef WIN32\r
#define DUP _dup\r
#define DUPP _dup2\r
#else\r
#define DUP dup\r
#define DUPP dup2\r
#endif\r
sav_i = DUP(fileno(stdin));\r
sav_o = DUP(fileno(stdout));\r
DUPP(fileno(fr), fileno(stdin));\r
DUPP(fileno(fw), fileno(stdout))\r
\r
@ @<Restore the standard I/O@>=\r
DUPP(sav_i, fileno(stdin));\r
close(sav_i);\r
DUPP(sav_o, fileno(stdout));\r
close(sav_o)\r
\r
@ The allocation of the array pointed to by |cmdline_addr| is of\r
course much larger than is really needed, but it will still only be a\r
few hunderd bytes at the most, and this ensures that the separate\r
parts of the |maincmd| will all fit.\r
\r
@d split_command(a,b) mpx_do_split_command(mpx,a,&b,' ')\r
@d split_pipes(a,b)   mpx_do_split_command(mpx,a,&b,'|')\r
\r
@c\r
static int\r
mpx_do_split_command(MPX mpx, char *maincmd, char ***cmdline_addr, char target) {\r
  char *piece;\r
  char *cmd;\r
  char **cmdline;\r
  size_t i;\r
  int ret = 0;\r
  int in_string = 0;\r
  if (strlen(maincmd) == 0)\r
    return 0;\r
  i = sizeof(char *)*(strlen(maincmd)+1);\r
  cmdline = xmalloc(i,1);\r
  memset(cmdline,0,i);\r
  *cmdline_addr = cmdline;\r
\r
  i = 0;\r
  while (maincmd[i] == ' ')\r
        i++;\r
  cmd = xstrdup(maincmd);\r
  piece = cmd;\r
  for (; i <= strlen(maincmd); i++) {\r
    if (in_string == 1) {\r
          if (cmd[i] == '"') {\r
            in_string = 0;\r
          }\r
        } else if (in_string == 2) {\r
          if (cmd[i] == '\'') {\r
                in_string = 0;\r
          }\r
        } else {\r
          if (cmd[i] == '"') {\r
                in_string = 1;\r
          } else if (cmd[i] == '\'') {\r
                in_string = 2;\r
          } else if (cmd[i] == target) {\r
                cmd[i] = 0;\r
                cmdline[ret++] = piece;\r
                while (i < strlen(maincmd) && cmd[(i + 1)] == ' ')\r
                    i++;\r
                piece = cmd + i + 1;\r
          }\r
        }\r
  }\r
  if (*piece) {\r
        cmdline[ret++] = piece;\r
  }\r
  return ret;\r
}\r
\r
@ @<Globals@>=\r
char *maincmd;    /* TeX command name */\r
\r
@ @c\r
static void mpx_command_cleanup (MPX mpx, char **cmdline) {\r
  (void)mpx;\r
  xfree(cmdline[0]);\r
  xfree(cmdline);\r
}\r
\r
\r
\r
@ @c\r
static void mpx_command_error (MPX mpx, int cmdlength, char **cmdline) {\r
  char *s = mpx_print_command(mpx, cmdlength, cmdline);\r
  mpx_command_cleanup(mpx, cmdline);\r
  mpx_abort(mpx, "Command failed: %s; see mpxerr.log", s);\r
}\r
\r
\r
\r
@ @(mpxout.h@>=\r
typedef struct mpx_options {\r
  int mode;\r
  char *cmd;\r
  char *mptexpre;\r
  char *mpname;\r
  char *mpxname;\r
  char *banner;\r
  int debug;\r
  mpx_file_finder find_file;\r
} mpx_options;\r
int mpx_makempx (mpx_options *mpxopt) ;\r
\r
 \r
@ \r
\r
@d ERRLOG "mpxerr.log"\r
@d MPXLOG "makempx.log"\r
\r
@c\r
int mpx_makempx (mpx_options *mpxopt) {\r
    MPX mpx;\r
    char **cmdline, **cmdbits;\r
    char infile[15];\r
    int retcode, i ;\r
    char tmpname[] = "mpXXXXXX";\r
    int cmdlength = 1;\r
    int cmdbitlength = 1;\r
    if (!mpxopt->debug) {\r
      @<Check if mp file is newer than mpxfile, exit if not@>;\r
    }\r
    mpx = malloc(sizeof(struct mpx_data));\r
    if (mpx==NULL || mpxopt->cmd==NULL || mpxopt->mpname==NULL || mpxopt->mpxname==NULL)\r
      return mpx_fatal_error;\r
    mpx_initialize(mpx);\r
    if (mpxopt->banner!=NULL)\r
      mpx->banner = mpxopt->banner;\r
    mpx->mode = mpxopt->mode;\r
    mpx->debug = mpxopt->debug;\r
    if (mpxopt->find_file!=NULL)\r
      mpx->find_file = mpxopt->find_file;\r
    if (mpxopt->cmd!=NULL)\r
      mpx->maincmd = xstrdup(mpxopt->cmd); /* valgrind says this leaks */\r
    mpx->mpname = xstrdup(mpxopt->mpname);\r
    mpx->mpxname = xstrdup(mpxopt->mpxname);\r
    @<Install and test the non-local jump buffer@>;\r
\r
    if (mpx->debug) {\r
      mpx->errfile = stderr;\r
    } else {\r
      mpx->errfile = mpx_xfopen(mpx,MPXLOG, "wb");\r
    }\r
    mpx->progname = "makempx";\r
    @<Initialize the |tmpname| variable@>;\r
    if (mpxopt->mptexpre == NULL)\r
      mpxopt->mptexpre = xstrdup("mptexpre.tex");\r
    @<Run |mpto| on the mp file@>;\r
    if (mpxopt->cmd==NULL)\r
      goto DONE;\r
    if (mpx->mode == mpx_tex_mode) {\r
      @<Run |TeX| and set up |infile| or abort@>;\r
      if (mpx_dvitomp(mpx, infile)) {\r
            mpx_rename(mpx, infile,DVIERR);\r
            if (!mpx->debug)\r
              remove(mpx->mpxname);\r
            mpx_abort(mpx, "Dvi conversion failed: %s %s\n",\r
                            DVIERR, mpx->mpxname);\r
      }\r
    } else if (mpx->mode == mpx_troff_mode) {\r
      @<Run |Troff| and set up |infile| or abort@>;\r
      if (mpx_dmp(mpx, infile)) {\r
            mpx_rename(mpx,infile, TROFF_OUTERR);\r
        mpx_rename(mpx,mpx->tex, TROFF_INERR);\r
            if (!mpx->debug)\r
              remove(mpx->mpxname);\r
            mpx_abort(mpx, "Troff conversion failed: %s %s\n",\r
                            TROFF_OUTERR, mpx->mpxname);\r
      }\r
    }\r
    mpx_fclose(mpx,mpx->mpxfile);\r
    if (!mpx->debug)\r
      mpx_fclose(mpx,mpx->errfile);\r
    if (!mpx->debug) {\r
          remove(MPXLOG);\r
          remove(ERRLOG);\r
          remove(infile);\r
    }\r
    mpx_erasetmp(mpx);\r
  DONE:\r
    retcode = mpx->history;\r
    mpx_xfree(mpx->buf);\r
    mpx_xfree(mpx->maincmd);\r
    for (i = 0; i < (int)mpx->nfonts; i++)\r
      mpx_xfree(mpx->font_name[i]);\r
    free(mpx);\r
    if (retcode == mpx_cksum_trouble)\r
       retcode = 0;\r
    return retcode;\r
}\r
\r
@ \TeX\ has to operate on an actual input file, so we have to append\r
that to the command line.\r
\r
@<Run |TeX| and set ...@>=\r
{\r
  char log[15];\r
  mpx->maincmd = xrealloc(mpx->maincmd,strlen(mpx->maincmd)+strlen(mpx->tex)+2,1);\r
  strcat(mpx->maincmd, " ");\r
  strcat(mpx->maincmd, mpx->tex);\r
  cmdlength = split_command(mpx->maincmd, cmdline);\r
\r
  retcode = mpx_run_command(mpx, NULL, NULL, cmdlength, cmdline);\r
\r
  TMPNAME_EXT(log, ".log");\r
  if (!retcode) {\r
    TMPNAME_EXT(infile, ".dvi");\r
    remove(log);\r
  } else {\r
    mpx_rename(mpx,mpx->tex, TEXERR);\r
    mpx_rename(mpx,log, ERRLOG);\r
    mpx_command_error(mpx, cmdlength, cmdline);\r
  }\r
  mpx_command_cleanup(mpx, cmdline);\r
}\r
\r
@ @<Run |Troff| and set ...@>=\r
{\r
  char *cur_in, *cur_out;\r
  char tmp_a[15], tmp_b[15];\r
  TMPNAME_EXT(tmp_a, ".t");   \r
  TMPNAME_EXT(tmp_b, ".tmp");\r
  cur_in = mpx->tex;\r
  cur_out = tmp_a;\r
\r
  /* split the command in bits */\r
  cmdbitlength = split_pipes(mpx->maincmd, cmdbits);\r
\r
  for (i = 0; i < cmdbitlength; i++) {\r
    if (cmdline!=NULL) free(cmdline);\r
    cmdlength = split_command(cmdbits[i], cmdline);\r
    retcode = mpx_run_command(mpx, cur_in, cur_out, cmdlength, cmdline);\r
            \r
    if (retcode) {\r
          mpx_rename(mpx,mpx->tex, TROFF_INERR);\r
      mpx_command_error(mpx, cmdlength, cmdline);\r
    }\r
    if (i < cmdbitlength - 1) {\r
          if (i % 2 == 0) {\r
        cur_in = tmp_a;\r
        cur_out = tmp_b;\r
          } else {\r
        cur_in = tmp_b;\r
        cur_out = tmp_a;\r
          }\r
      strcpy(infile,cur_in);\r
    }\r
  }\r
  if (tmp_a!=infile) { remove(tmp_a); }\r
  if (tmp_b!=infile) { remove(tmp_b); }\r
}\r
\r
@ If MPX file is up-to-date or if MP file does not exist, do nothing. \r
\r
@<Check if mp file is newer than mpxfile, exit if not@>=\r
if (mpx_newer(mpxopt->mpname, mpxopt->mpxname))\r
   return 0\r
\r
\r
@ \r
@<Initialize the |tmpname| variable@>=\r
#ifdef HAVE_MKSTEMP\r
    i = mkstemp(tmpname);\r
    if (i == -1) {\r
      sprintf(tmpname, "mp%06d", (int)(time(NULL) % 1000000));\r
    } else {\r
      close(i);\r
      remove(tmpname);\r
    }\r
#else\r
#ifdef HAVE_MKTEMP\r
  {\r
    char *tmpstring = mktemp(tmpname);\r
    if ((tmpstring == NULL) || strlen(tmpname) == 0) {\r
      sprintf(tmpname, "mp%06d", (int)(time(NULL) % 1000000));\r
    } else {\r
      /* this should not really be needed, but better\r
         safe than sorry. */\r
      if (tmpstring != tmpname) {\r
            i = strlen(tmpstring);\r
            if (i > 8) i = 8;\r
              strncpy(tmpname, tmpstring, i);\r
      }\r
    }\r
  }\r
#else\r
    sprintf(tmpname, "mp%06d", (int)(time(NULL) % 1000000));\r
#endif\r
#endif\r