/*
 *   Here's the code to load a PK file into memory.
 *   Individual bitmaps won't be unpacked until they prove to be needed.
 */
#include "dvips.h" /* The copyright notice in that file is included too! */
#ifdef OS2
#include <stdlib.h>
#endif
#ifdef KPATHSEA
#include <kpathsea/c-pathmx.h>
#include <kpathsea/tex-glyph.h>
#include <kpathsea/tex-make.h>
#include <kpathsea/lib.h>
#ifndef MAXPATHLEN
#define MAXPATHLEN (256)
#endif
#else
#if defined(SYSV) || defined(VMS) || (defined(MSDOS) && !defined(__DJGPP__)) || defined(OS2) || defined(ATARIST)
#define MAXPATHLEN (256)
#else
#include <sys/param.h>          /* for MAXPATHLEN */
#endif
#endif
/*
 *   These are the external routines we use.
 */
#include "protos.h"
/*
 *   These are the external variables we use.
 */
#ifdef DEBUG
extern integer debug_flag;
#endif  /* DEBUG */
extern long bytesleft ;
extern quarterword *raster ;
extern real conv ;
extern int actualdpi, vactualdpi ;
extern real alpha ;
#ifndef KPATHSEA
extern char *pkpath ;
#endif
char errbuf[200] ;
int lastresortsizes[40] ;
extern integer fsizetol ;
extern Boolean nosmallchars ;
extern Boolean compressed ;
extern Boolean dopprescan ;
#ifdef FONTLIB
extern Boolean flib ;
#endif
/*
 *   Now we have some routines to get stuff from the PK file.
 *   Subroutine pkbyte returns the next byte.
 */
FILE *pkfile ;
char name[MAXPATHLEN] ;
void
badpk P1C(char *, s)
{
   (void)sprintf(errbuf,"! Bad PK file %s: %s",name,s) ;
   error(errbuf);
}

shalfword
pkbyte P1H(void)
{
   register shalfword i ;

   if ((i=getc(pkfile))==EOF)
      badpk("unexpected eof") ;
   return(i) ;
}

integer
pkquad P1H(void)
{
   register integer i ;

   i = pkbyte() ;
   if (i > 127)
      i -= 256 ;
   i = i * 256 + pkbyte() ;
   i = i * 256 + pkbyte() ;
   i = i * 256 + pkbyte() ;
   return(i) ;
}

integer
pktrio P1H(void)
{
   register integer i ;

   i = pkbyte() ;
   i = i * 256 + pkbyte() ;
   i = i * 256 + pkbyte() ;
   return(i) ;
}


/*
 *   pkopen opens the pk file.  This is system dependent.  We work really
 *   hard to open some sort of PK file.
 */
#ifdef VMCMS /* IBM: VM/CMS - we let DVIPS EXEC handle this after
                             the DVIPS MODULE has finished to avoid
                             complications with system calls. */
int dontmakefont = 0 ;
#else
#ifdef MVSXA /* IBM: MVS/XA - we let system administrator handle this on
                            MVS/XA since some printers can't get to user
                             fonts anyway */
int dontmakefont = 1 ;
#else
int dontmakefont = 0 ; /* if makefont fails once we won't try again */
#endif  /* IBM: VM/CMS */
#endif

void
lectureuser P1H(void) {
   static int userwarned = 0 ;

   if (! userwarned) {
      error("Such scaling will generate extremely poor output.") ;
      userwarned = 1 ;
   }
}
Boolean
pkopen P1C(register fontdesctype *, fd)
{
   register char *d, *n ;
   char *name_ret ;
   int vdpi ;
#ifdef KPATHSEA
   int dpi_ret ;
#endif
   d = fd->area ;
   n = fd->name ;
#ifndef KPATHSEA
   if (*d==0)
      d = pkpath ;
#endif
#ifdef FONTLIB
   if (*(fd->area) == 0) {
      int del ;
      for (del=0; del<=RES_TOLERANCE(fd->dpi); del=del>0?-del:-del+1) {
        if ((pkfile=flisearch(n, fd->dpi + del)) != (FILE *)NULL )
          return(1);
      }
   }
#endif
   {
#ifdef KPATHSEA
     char *this_name = concat (d, n);

     pkfile=pksearch(pkpath, this_name, READBIN, fd->dpi, &name_ret, &dpi_ret);

     if (!pkfile || !FILESTRCASEEQ (this_name, name_ret))
       {
        if (!pkfile)
         (void)sprintf(errbuf,
            "Font %s%s not found, characters will be left blank.",
            fd->area, n) ;
        else
          sprintf(errbuf, "Font %s%s not found,  using %s instead.",
            fd->area, n, name_ret) ;
         dontmakefont = 1;
         error(errbuf) ;
       }
     else if (!kpse_bitmap_tolerance ((double) dpi_ret, (double) fd->dpi))
       {
           fd->loadeddpi = dpi_ret ;
           fd->alreadyscaled = 0 ;
           (void)sprintf(errbuf,
                   "Font %s at %d not found; scaling %d instead.",
                                     n, fd->dpi, dpi_ret) ;
           error(errbuf) ;
           lectureuser() ;
       }

     if (this_name != name_ret)
       free (this_name);
       
     return pkfile != NULL;
   }
#else
      int del ;
      for (del=0; del<=RES_TOLERANCE(fd->dpi); del=del>0?-del:-del+1) {
         if (actualdpi == vactualdpi) {
            vdpi = 0 ;
         } else {
            vdpi = (2 * ((long)vactualdpi) * (fd->dpi + del) + actualdpi)
                                                       / (2 * actualdpi) ;
         }
#ifdef MVSXA
         (void)sprintf(name, "pk%d(%s)", fd->dpi + del, n) ;
#else
         (void)sprintf(name, "%s.%dpk", n, fd->dpi + del) ;
#endif
         if (0 != (pkfile=pksearch(d, name, READBIN, n, fd->dpi + del, vdpi)))
            return(1) ;
      }
   }
   if (d == pkpath) {
      if (actualdpi == vactualdpi) {
         vdpi = 0 ;
      } else {
         vdpi = (2 * ((long)vactualdpi) * fd->dpi + actualdpi)
                                                    / (2 * actualdpi) ;
      }
#ifdef MVSXA
      (void)sprintf(name, "pk%d(%s)", fd->dpi, n) ;
#else
      (void)sprintf(name, "%s.%dpk", n, fd->dpi) ;
#endif
      makefont(n, (int)fd->dpi, DPI) ;
      if (dontmakefont == 0 &&
          (pkfile = pksearch(d, name, READBIN, n, fd->dpi, vdpi)))
               return(1) ;
#ifndef MSDOS
#ifdef OS2
   if (_osmode == OS2_MODE)
      dontmakefont = 1;       /* failed so don't try again under OS/2, 
                                 but do try for MSDOS */
#else
#ifndef ATARIST
      dontmakefont = 1 ;
#endif
#endif
#endif
   }
/*
 *   If nothing above worked, then we get desparate.  We attempt to
 *   open the stupid font at one of a small set of predefined sizes,
 *   and then use PostScript scaling to generate the correct size.
 *
 *   We much prefer scaling up to scaling down, since scaling down
 *   can omit character features, so we try the larger sizes first,
 *   and then work down.
 */
   {
      int i, j ;

      if (lastresortsizes[0] && fd->dpi < 30000) {
         for (i=0; lastresortsizes[i] < fd->dpi; i++) ;
         for (j = i-1; j >= 0; j--) {
            if (actualdpi == vactualdpi) {
               vdpi = 0 ;
            } else {
               vdpi = (2 * ((long)vactualdpi) * lastresortsizes[j] + actualdpi)
                                                       / (2 * actualdpi) ;
            }
#ifdef MVSXA
            (void)sprintf(name, "pk%d(%s)", lastresortsizes[j], n) ;
#else
            (void)sprintf(name, "%s.%dpk", n, lastresortsizes[j]) ;
#endif
#ifdef FONTLIB
            if (0 != (pkfile=flisearch(n,(halfword)lastresortsizes[j]))
             || 0 != (pkfile=pksearch(d, name, READBIN, n,
                         (halfword)lastresortsizes[j], vdpi))) {
#else
            if (0 != (pkfile=pksearch(d, name, READBIN, n,
                         (halfword)lastresortsizes[j], vdpi))) {
#endif
               fd->loadeddpi = lastresortsizes[j] ;
               fd->alreadyscaled = 0 ;
               (void)sprintf(errbuf,
                       "Font %s at %d dpi not found; scaling %d instead.",
                                         n, fd->dpi, lastresortsizes[j]) ;
               error(errbuf) ;
               lectureuser() ;
               return 1 ;
            }
         }
         for (j = i; lastresortsizes[j] < 30000; j++) {
            if (actualdpi == vactualdpi) {
               vdpi = 0 ;
            } else {
               vdpi = (2 * ((long)vactualdpi) * lastresortsizes[j] + actualdpi)
                                                       / (2 * actualdpi) ;
            }
            (void)sprintf(name, "%s.%dpk", n, lastresortsizes[j]) ;
#ifdef FONTLIB
            if (0 != (pkfile=flisearch(n, (halfword)lastresortsizes[j]))
                || 0 != (pkfile=pksearch(d, name, READBIN, n,
                             (halfword)lastresortsizes[j], vdpi))) {
#else
            if (0 != (pkfile=pksearch(d, name, READBIN, n,
                            (halfword)lastresortsizes[j], vdpi))) {
#endif
               fd->loadeddpi = lastresortsizes[j] ;
               fd->alreadyscaled = 0 ;
               (void)sprintf(errbuf,
                       "Font %s at %d dpi not found; scaling %d instead.",
                                         name, fd->dpi, lastresortsizes[j]) ;
               error(errbuf) ;
               lectureuser() ;
               return 1 ;
            }
         }
      }
   }
#ifdef MVSXA
   (void)sprintf(name, "%s.pk%d", n, fd->dpi) ;
#else
   (void)sprintf(name, "%s.%dpk", n, fd->dpi) ;
#endif
   (void)sprintf(errbuf,
      "Font %s%s not found, characters will be left blank.",
      fd->area, name) ;
   error(errbuf) ;
   return(0) ;
#endif /* KPATHSEA */
}

/*
 *   Now our loadfont routine.  We return an integer indicating the
 *   highest character code in the font, so we know how much space
 *   to reserve for the character.  (It's returned in the font
 *   structure, along with everything else.)
 */
void
loadfont P1C(register fontdesctype *, curfnt)
{
#ifdef Omega
   register integer i ;
#else
   register shalfword i ;
#endif
   register shalfword cmd ;
   register integer k ;
   register integer length = 0 ;
   register shalfword cc = 0 ;
   register integer scaledsize = curfnt->scaledsize ;
   register quarterword *tempr ;
   register chardesctype *cd = 0 ;
   int maxcc = 0 ;
   int munged = 0 ;
/*
 *   We clear out some pointers:
 */
   if (curfnt->loaded == 3) {
      for (i=0; i<256; i++) {
         curfnt->chardesc[i].TFMwidth = 0 ;
         curfnt->chardesc[i].packptr = NULL ;
         curfnt->chardesc[i].pixelwidth = 0 ;
         curfnt->chardesc[i].flags &= EXISTS ;
         curfnt->chardesc[i].flags2 = 0 ;
      }
   } else {
      for (i=0; i<256; i++) {
         curfnt->chardesc[i].TFMwidth = 0 ;
         curfnt->chardesc[i].packptr = NULL ;
         curfnt->chardesc[i].pixelwidth = 0 ;
         curfnt->chardesc[i].flags = 0 ;
         curfnt->chardesc[i].flags2 = 0 ;
      }
   }
   curfnt->maxchars = 256 ; /* just in case we return before the end */
   if (!pkopen(curfnt)) {
      tfmload(curfnt) ;
      return ;
   }
#ifdef DEBUG
   if (dd(D_FONTS))
      (void)fprintf(stderr,"Loading pk font %s at %.1fpt\n",
         curfnt->name, (real)scaledsize/(alpha*0x100000)) ;
#endif /* DEBUG */
   if (pkbyte()!=247)
      badpk("expected pre") ;
   if (pkbyte()!=89)
      badpk("wrong id byte") ;
   for(i=pkbyte(); i>0; i--)
      (void)pkbyte() ;
   k = (integer)(alpha * (real)pkquad()) ;
   if (k > curfnt->designsize + fsizetol ||
       k < curfnt->designsize - fsizetol) {
      (void)sprintf(errbuf,"Design size mismatch in font %s", curfnt->name) ;
      error(errbuf) ;
   }
   k = pkquad() ;
   if (k && curfnt->checksum)
      if (k!=curfnt->checksum) {
         (void)sprintf(errbuf,"Checksum mismatch in font %s", curfnt->name) ;
         error(errbuf) ;
       }
   k = pkquad() ; /* assume that hppp is correct in the PK file */
   k = pkquad() ; /* assume that vppp is correct in the PK file */
/*
 *   Now we get down to the serious business of reading character definitions.
 */
   while ((cmd=pkbyte())!=245) {
      if (cmd < 240) {
         switch (cmd & 7) {
case 0: case 1: case 2: case 3:
            length = (cmd & 7) * 256 + pkbyte() - 3 ;
            cc = pkbyte() ;
            cd = curfnt->chardesc+cc ;
            if (nosmallchars || curfnt->dpi != curfnt->loadeddpi)
               cd->flags |= BIGCHAR ;
            cd->TFMwidth = scalewidth(pktrio(), scaledsize) ;
            cd->pixelwidth = pkbyte() ;
            break ;
case 4: case 5: case 6:
            length = (cmd & 3) * 65536L + pkbyte() * 256L ;
            length = length + pkbyte() - 4L ;
            cc = pkbyte() ;
            cd = curfnt->chardesc+cc ;
            cd->TFMwidth = scalewidth(pktrio(), scaledsize) ;
            cd->flags |= BIGCHAR ;
            i = pkbyte() ;
            cd->pixelwidth = i * 256 + pkbyte() ;
            break ;
case 7:
            length = pkquad() - 11 ;
            cc = pkquad() ;
            if (cc<0 || cc>255) badpk("character code out of range") ;
            cd = curfnt->chardesc + cc ;
            cd->flags |= BIGCHAR ;
            cd->TFMwidth = scalewidth(pkquad(), scaledsize) ;
            cd->pixelwidth = (pkquad() + 32768) >> 16 ;
            k = pkquad() ;
         }
         if (cd->pixelwidth == 0 && cd->TFMwidth != 0) {
            if (cd->TFMwidth > 0)
               k = (integer)(cd->TFMwidth * conv + 0.5) ;
            else
               k = -(integer)(-cd->TFMwidth * conv + 0.5) ;
            if (k != 0) {
               cd->pixelwidth = k ;
               munged++ ;
            }
         }
         if (length <= 0)
            badpk("packet length too small") ;
         if (dopprescan && ((cd->flags & EXISTS) == 0)) {
            for (length--; length>0; length--)
               (void)pkbyte() ;
         } else {
            if (cc > maxcc)
               maxcc = cc ;
            if (bytesleft < length || (length > MINCHUNK && compressed)) {
#ifdef DEBUG
                if (dd(D_MEM))
                   (void)fprintf(stderr,
#ifdef SHORTINT
                      "Allocating new raster memory (%ld req, %ld left)\n",
                                   length, bytesleft) ;
#else
                      "Allocating new raster memory (%d req, %d left)\n",
                                   (int)length, (int)bytesleft) ;
#endif
#endif /* DEBUG */
                if (length > MINCHUNK) {
                   tempr = (quarterword *)mymalloc((integer)length) ;
                } else {
                   raster = (quarterword *)mymalloc((integer)RASTERCHUNK) ;
                   tempr = raster ;
                   bytesleft = RASTERCHUNK - length ;
                   raster += length ;
               }
            } else {
               tempr = raster ;
               bytesleft -= length ;
               raster += length ;
            }
            cd->packptr = tempr ;
            *tempr++ = cmd ;
            for (length--; length>0; length--)
               *tempr++ = pkbyte() ;
         }
         cd->flags2 |= EXISTS ;
      } else {
         k = 0 ;
         switch (cmd) {
case 243:
            k = pkbyte() ;
            if (k > 127)
               k -= 256 ;
case 242:
            k = k * 256 + pkbyte() ;
case 241:
            k = k * 256 + pkbyte() ;
case 240:
            k = k * 256 + pkbyte() ;
            while (k-- > 0)
               i = pkbyte() ;
            break ;
case 244:
            k = pkquad() ;
            break ;
case 246:
            break ;
default:
            badpk("! unexpected command") ;
         }
      }
   }
#ifdef FONTLIB
   if (flib)
      flib = 0 ;
   else
#endif
   (void)fclose(pkfile) ;
   curfnt->loaded = 1 ;
   curfnt->maxchars = maxcc + 1 ;
   if (munged > 0) {
      static int seen = 0 ;
      sprintf(errbuf,
          "Font %s at %d dpi has most likely been made improperly;",
           curfnt->name, curfnt->dpi) ;
      error(errbuf) ;
      if (seen)
         return ;
      seen = 1 ;
      sprintf(errbuf,
     "%d characters have 0 escapements but non-trivial TFM widths.", munged) ;
      error(errbuf) ;
      error(
          "I'm stumbling along as best I can, but I recommend regenerating") ;
      error(
          "these fonts; the problem is probably that they are non-CM fonts") ;
      error(
          "(such as circle10 or line10) created with a MF with the CM base") ;
      error("preloaded .") ;
   }
}
