summaryrefslogtreecommitdiff
path: root/Build/source/texk/dvipsk/loadfont.c
diff options
context:
space:
mode:
authorKarl Berry <karl@freefriends.org>2006-01-17 21:41:51 +0000
committerKarl Berry <karl@freefriends.org>2006-01-17 21:41:51 +0000
commit487ca4806cc046076293cf6cc5fbba0db282bac7 (patch)
tree847b412ab5158dd7bdd7ed7e5a4cc3fbca94be32 /Build/source/texk/dvipsk/loadfont.c
parenta3d3111bfe26b8e5f5bc6049dfb2a4ca2edc7881 (diff)
texk 1
git-svn-id: svn://tug.org/texlive/trunk@1485 c570f23f-e606-0410-a88d-b1316a301751
Diffstat (limited to 'Build/source/texk/dvipsk/loadfont.c')
-rw-r--r--Build/source/texk/dvipsk/loadfont.c524
1 files changed, 524 insertions, 0 deletions
diff --git a/Build/source/texk/dvipsk/loadfont.c b/Build/source/texk/dvipsk/loadfont.c
new file mode 100644
index 00000000000..449c74256e7
--- /dev/null
+++ b/Build/source/texk/dvipsk/loadfont.c
@@ -0,0 +1,524 @@
+/*
+ * 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 ;
+#ifdef KPATHSEA
+ int dpi_ret ;
+#else
+ int vdpi ;
+#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)
+{
+ register integer i ;
+ 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 .") ;
+ }
+}