home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 3 / goldfish_volume_3.bin / files / text / tex / pastex / source / dvips / virtualfont.c < prev   
Encoding:
C/C++ Source or Header  |  1994-09-29  |  6.9 KB  |  285 lines
  1. /*
  2.  *   Here's the code to load a VF file into memory.
  3.  *   Any resemblance between this file and loadfont.c is purely uncoincidental.
  4.  */
  5. #include "dvips.h" /* The copyright notice in that file is included too! */
  6. /*
  7.  *   These are the external routines we use.
  8.  */
  9. #ifdef AMIGA
  10. #include "virtualfont_protos.h"
  11. #include "dvips_protos.h"
  12. #include "scalewidth_protos.h"
  13. #include "search_protos.h"
  14. #include "fontdef_protos.h"
  15. #include "makefont_protos.h"
  16. #else
  17. extern void makefont() ;
  18. extern void error() ;
  19. extern integer scalewidth() ;
  20. extern FILE *search() ;
  21. extern fontdesctype *newfontdesc() ;
  22. extern fontdesctype *matchfont() ;
  23. #endif
  24. /*
  25.  *   These are the external variables we use.
  26.  */
  27. #ifdef DEBUG
  28. extern integer debug_flag;
  29. #endif  /* DEBUG */
  30. extern long bytesleft ;
  31. extern quarterword *raster ;
  32. extern char *vfpath ;
  33. extern char errbuf[200] ;
  34. extern real conv ;
  35. extern real vconv ;
  36. extern real alpha ;
  37. extern integer mag ;
  38. extern int actualdpi ;
  39. extern int vactualdpi ;
  40. extern char *nextstring, *maxstring ;
  41. extern fontdesctype *fonthead ;
  42. extern real alpha ;
  43. /*
  44.  *   Now we have some routines to get stuff from the VF file.
  45.  *   Subroutine vfbyte returns the next byte.
  46.  */
  47. static FILE *vffile ;
  48. static char name[50] ;
  49. void
  50. badvf(s)
  51.    char *s ;
  52. {
  53.    (void)sprintf(errbuf,"! Bad VF file %s: %s",name,s) ;
  54.    error(errbuf);
  55. }
  56.  
  57. shalfword
  58. vfbyte()
  59. {
  60.    register shalfword i ;
  61.  
  62.    if ((i=getc(vffile))==EOF)
  63.       badvf("unexpected eof") ;
  64.    return(i) ;
  65. }
  66.  
  67. integer
  68. vfquad()
  69. {
  70.    register integer i ;
  71.  
  72.    i = vfbyte() ;
  73.    if (i > 127)
  74.       i -= 256 ;
  75.    i = i * 256 + vfbyte() ;
  76.    i = i * 256 + vfbyte() ;
  77.    i = i * 256 + vfbyte() ;
  78.    return(i) ;
  79. }
  80.  
  81. integer
  82. vftrio()
  83. {
  84.    register integer i ;
  85.  
  86.    i = vfbyte() ;
  87.    i = i * 256 + vfbyte() ;
  88.    i = i * 256 + vfbyte() ;
  89.    return(i) ;
  90. }
  91.  
  92. Boolean
  93. vfopen(fd)
  94.         register fontdesctype *fd ;
  95. {
  96.    register char *d, *n ;
  97.  
  98.    d = fd->area ;
  99.    n = fd->name ;
  100.    if (*d==0)
  101.       d = vfpath ;
  102. #ifdef MVSXA   /* IBM: MVS/XA */
  103.    (void)sprintf(name, "vf(%s)", n) ;
  104. #else
  105.    (void)sprintf(name, "%s.vf", n) ;
  106. #endif
  107.    if (0 != (vffile=search(d, name, READBIN)))
  108.       return(1) ;
  109.    return(0) ;
  110. }
  111.  
  112. /*
  113.  * The following routine is like fontdef, but for local fontdefs in VF files.
  114.  */
  115. fontmaptype *
  116. vfontdef(s, siz)
  117.       integer s ;
  118.     int siz ;
  119. {
  120.    register integer i, j, fn ;
  121.    register fontdesctype *fp ;
  122.    register fontmaptype *cfnt ;
  123.    char *name, *area ;
  124.    integer cksum, scsize, dssize ;
  125.  
  126.    fn = vfbyte() ;
  127.    while (siz-- > 1)
  128.       fn = (fn << 8) + vfbyte() ;
  129.    cfnt = (fontmaptype *)mymalloc((integer)sizeof(fontmaptype)) ;
  130.    cfnt->fontnum = fn ;
  131.    cksum = vfquad() ;
  132.    scsize = scalewidth(s, vfquad()) ;
  133.    dssize = (integer)(alpha * (real)vfquad()) ;
  134.    i = vfbyte() ; j = vfbyte() ;
  135.    if (nextstring + i + j > maxstring)
  136.       error("! out of string space") ;
  137.    area = nextstring ;
  138.    for (; i>0; i--)
  139.       *nextstring++ = vfbyte() ;
  140.    *nextstring++ = 0 ;
  141.    name = nextstring ;
  142.    for (; j>0; j--)
  143.       *nextstring++ = vfbyte() ;
  144.    *nextstring++ = 0 ;
  145.    fp = matchfont(name, area, scsize, (char *)0) ;
  146.    if (fp) {
  147.       nextstring = name ;
  148.       fp->checksum = cksum ;
  149.    } else {
  150.       fp = newfontdesc(cksum, scsize, dssize, name, area) ;
  151.       fp->next = fonthead ;
  152.       fonthead = fp ;
  153.    }
  154.    cfnt->desc = fp ;
  155.    return (cfnt) ;
  156. }
  157.  
  158. /*
  159.  *   Now our virtualfont routine.
  160.  */
  161. Boolean
  162. virtualfont(curfnt)
  163.         register fontdesctype *curfnt ;
  164. {
  165.    register shalfword i ;
  166.    register shalfword cmd ;
  167.    register integer k ;
  168.    register integer length ;
  169.    register shalfword cc ;
  170.    register chardesctype *cd ;
  171.    integer scaledsize = curfnt->scaledsize ;
  172.    register quarterword *tempr ;
  173.    fontmaptype *fm, *newf ;
  174.  
  175.    if (!vfopen(curfnt))
  176.       return (0) ;
  177. #ifdef DEBUG
  178.    if (dd(D_FONTS))
  179.       (void)fprintf(stderr,"Loading virtual font %s at %.1fpt\n",
  180.          name, (real)scaledsize/(alpha*0x100000)) ;
  181. #endif /* DEBUG */
  182.  
  183. /*
  184.  *   We clear out some pointers:
  185.  */
  186.    for (i=0; i<256; i++) {
  187.       curfnt->chardesc[i].TFMwidth = 0 ;
  188.       curfnt->chardesc[i].packptr = NULL ;
  189.       curfnt->chardesc[i].pixelwidth = 0 ;
  190.       curfnt->chardesc[i].flags = 0 ;
  191.    }
  192.    if (vfbyte()!=247)
  193.       badvf("expected pre") ;
  194.    if (vfbyte()!=202)
  195.       badvf("wrong id byte") ;
  196.    for(i=vfbyte(); i>0; i--)
  197.       (void)vfbyte() ;
  198.    k = vfquad() ;
  199.    if (k && curfnt->checksum)
  200.       if (k!=curfnt->checksum) {
  201.          (void)sprintf(errbuf,"Checksum mismatch in font %s", name) ;
  202.          error(errbuf) ;
  203.        }
  204.    k = (integer)(alpha * (real)vfquad()) ;
  205.    if (k > curfnt->designsize + 2 || k < curfnt->designsize - 2) {
  206.       (void)sprintf(errbuf,"Design size mismatch in font %s", name) ;
  207.       error(errbuf) ;
  208.    }
  209. /*
  210.  * Now we look for font definitions.
  211.  */
  212.    fm = NULL ;
  213.    while ((cmd=vfbyte())>=243) {
  214.       if (cmd>246)
  215.          badvf("unexpected command in preamble") ;
  216.       newf = vfontdef(scaledsize, cmd-242) ;
  217.       if (fm)
  218.          fm->next = newf ;
  219.       else curfnt->localfonts = newf ;
  220.       fm = newf ;
  221.       fm->next = NULL ; /* FIFO */
  222.    }
  223. /*
  224.  *   Now we get down to the serious business of reading character definitions.
  225.  */
  226.    do {
  227.       if (cmd==242) {
  228.          length = vfquad() + 2 ;
  229.          if (length<2) badvf("negative length packet") ;
  230.          if (length>65535) badvf("packet too long") ;
  231.          cc = vfquad() ;
  232.          if (cc<0 || cc>255) badvf("character code out of range") ;
  233.          cd = curfnt->chardesc + cc ;
  234.          cd->TFMwidth = scalewidth(vfquad(), scaledsize) ;
  235.       } else {
  236.          length = cmd + 2;
  237.          cc = vfbyte() ;
  238.          cd = curfnt->chardesc + cc ;
  239.          cd->TFMwidth = scalewidth(vftrio(), scaledsize) ;
  240.       }
  241.       if (cd->TFMwidth >= 0)
  242.          cd->pixelwidth = ((integer)(conv*cd->TFMwidth+0.5)) ;
  243.       else
  244.          cd->pixelwidth = -((integer)(conv*-cd->TFMwidth+0.5)) ;
  245.       cd->flags = EXISTS ;
  246.       if (bytesleft < length) {
  247. #ifdef DEBUG
  248.           if (dd(D_MEM))
  249.              (void)fprintf(stderr,
  250. #ifdef SHORTINT
  251.                    "Allocating new raster memory (%ld req, %ld left)\n",
  252. #else
  253.                    "Allocating new raster memory (%d req, %ld left)\n",
  254. #endif
  255.                                 length, bytesleft) ;
  256. #endif /* DEBUG */
  257.           if (length > MINCHUNK) {
  258.              tempr = (quarterword *)mymalloc((integer)length) ;
  259.              bytesleft = 0 ;
  260.           } else {
  261.              raster = (quarterword *)mymalloc((integer)RASTERCHUNK) ;
  262.              tempr = raster ;
  263.              bytesleft = RASTERCHUNK - length ;
  264.              raster += length ;
  265.          }
  266.       } else {
  267.          tempr = raster ;
  268.          bytesleft -= length ;
  269.          raster += length ;
  270.       }
  271.       cd->packptr = tempr ;
  272.       length -= 2 ;
  273.       *tempr++ = length / 256 ;
  274.       *tempr++ = length % 256 ;
  275.          for (; length>0; length--)
  276.             *tempr++ = vfbyte() ;
  277.       cmd = vfbyte() ;
  278.    } while (cmd < 243) ;
  279.    if (cmd != 248)
  280.       badvf("missing postamble") ;
  281.    (void)fclose(vffile) ;
  282.    curfnt->loaded = 2 ;
  283.    return (1) ;
  284. }
  285.