summaryrefslogtreecommitdiff
path: root/graphics/bm2font/bm2font.c
diff options
context:
space:
mode:
authorNorbert Preining <norbert@preining.info>2019-09-02 13:46:59 +0900
committerNorbert Preining <norbert@preining.info>2019-09-02 13:46:59 +0900
commite0c6872cf40896c7be36b11dcc744620f10adf1d (patch)
tree60335e10d2f4354b0674ec22d7b53f0f8abee672 /graphics/bm2font/bm2font.c
Initial commit
Diffstat (limited to 'graphics/bm2font/bm2font.c')
-rw-r--r--graphics/bm2font/bm2font.c4932
1 files changed, 4932 insertions, 0 deletions
diff --git a/graphics/bm2font/bm2font.c b/graphics/bm2font/bm2font.c
new file mode 100644
index 0000000000..6b69597d6f
--- /dev/null
+++ b/graphics/bm2font/bm2font.c
@@ -0,0 +1,4932 @@
+/* Output from p2c, the Pascal-to-C translator */
+/* From input file "bm2font.pas" */
+
+
+/*1:*/
+
+#include "p2c.h"
+/* p2c: bm2font.pas, line 1:
+ * Note: Unexpected name "texfile" in program header [262] */
+/* p2c: bm2font.pas, line 1:
+ * Note: Unexpected name "tfmfile" in program header [262] */
+/* p2c: bm2font.pas, line 1:
+ * Note: Unexpected name "pxlfile" in program header [262] */
+/* p2c: bm2font.pas, line 1:
+ * Note: Unexpected name "bitmap" in program header [262] */
+/* p2c: bm2font.pas, line 1:
+ * Note: Unexpected name "tmpfil" in program header [262] */
+
+
+/*logfile,*/
+
+
+typedef uchar ebts;
+
+typedef short halfk;
+
+typedef long dynlong[52][129];
+typedef unsigned short dynword[52][129];
+typedef short korbyte[511];
+typedef short spreadbyte[256];
+/*55:*/
+typedef unsigned short pxlstr;
+
+typedef ebts pxla[65522L];
+/*:55*/
+/*59:*/
+typedef short pxlba[32761];
+/*:59*/
+/*91:*/
+typedef uchar dmatrix[7][7];
+
+/*:91*/
+
+
+#define maxmemsize 32760
+
+
+/*92:*/
+
+Static dmatrix ditherm = {
+ { 1, 3, 6, 10, 18, 26, 38 },
+ { 2, 4, 8, 12, 20, 28, 40 },
+ { 5, 7, 9, 14, 22, 30, 42 },
+ { 11, 13, 15, 16, 24, 32, 44 },
+ { 17, 19, 21, 23, 25, 34, 46 },
+ { 27, 29, 31, 33, 35, 36, 48 },
+ { 37, 39, 41, 43, 45, 47, 49 }
+};
+
+/*:92*/
+/*:1*/
+/*2:*/
+Static ebts hrep, vrep, xrep, yrep, patswitch, usecol, pminval, pmaxval,
+ bufsh, nextbuf, tmpcolor, invbyte, invbit, xratio, yratio;
+Static unsigned short tpal[256];
+Static long bitspsam, rowspstrip;
+Static unsigned short photoinf;
+Static short colpos;
+Static ebts pxllook[256];
+Static ebts lutone[256];
+Static ebts lutvga[256];
+Static ebts lutsl[256];
+Static double spreadcol, patref, greyunit;
+Static short greykor;
+Static short *gkorh, *gkordivp;
+Static short *spreadvals;
+Static short hktab[256];
+Static boolean cspread;
+Static unsigned short bhell[256];
+Static boolean cmyk, cyan, magenta, yellow, black, saveblack;
+Static short colcyan, colblack, colmagenta, colyellow;
+Static dmatrix colmatrix;
+Static unsigned short pxlcolor;
+Static boolean greypxl, egastretch, ledprinter, distribute, giftemp, pcxtemp;
+Static short maxcol;
+Static long usepxl, vusepxl, brightness;
+Static short greypix;
+Static ebts pattern[4][197][7];
+Static ebts ipattern[4][197][7];
+Static unsigned short tab[64][3];
+Static uchar ccol;
+Static Char cref[77];
+Static ebts b1[3000];
+Static ebts b2[3000];
+Static ebts b3[3000];
+Static ebts b4[3000];
+Static long linepos_, posbit;
+Static halfk dbuf;
+Static boolean clipon, zeroline, zerorow, nameok, fok;
+Static Char cmd[256];
+Static Char bmname[256];
+Static Char font[256];
+Static Char tmpname[256];
+Static Char fontpre[256];
+Static Char fontupc[256];
+Static ebts curpat[2];
+Static short gbufp, gbufpp;
+Static halfk pxlinlen, zeropads;
+Static short mapwidth, mapheight, maplines, freelines;
+Static long mapinlen, newwidth, newheight;
+Static short a, b, f, nf, g, ng, ly, lx, minx, maxx, i, nj, j, v, k, pk, pkn;
+Static uchar pm, pn;
+Static unsigned short pl, pb;
+Static uchar c, cb;
+Static long fh, sh, fw, sw;
+Static unsigned short lf, lh, bc, ec, nw, nh, nd, ni, nl, nk, ne, np;
+Static union {
+ uchar b[4];
+ long i;
+} cx;
+Static long checksum, dsize;
+Static long tabdsize[52];
+Static long (*width)[129], (*height)[129];
+Static unsigned short (*yoffset)[129], (*pwidth)[129], (*pheight)[129];
+Static long dirpoint[129];
+Static pxlstr pkpoint[129];
+Static long hres, vres;
+Static double truehres, truevres;
+Static long noffonts, nofchars, mincharpf;
+Static uchar charpf[53];
+/*logfile,*/
+Static FILE *texfile;
+Static FILE *bitmap, *pxlfile, *tmpfil;
+Static short filestat;
+Static unsigned short gi;
+Static boolean invert;
+Static unsigned short cv, dv, lv;
+Static Char comment[256];
+Static Char aliasname[256];
+Static boolean aliasused;
+Static double mapdiv;
+Static long pkwidth, pkheight;
+Static boolean nowhite, halfinch;
+Static pxlstr nextmemfree;
+/*25:*/
+Static ebts cutrep, outputbyte;
+Static halfk cutlen;
+Static boolean cutgrey; /*:25*/
+/*53:*/
+Static Char tfmstr[256];
+Static uchar tfmb;
+Static FILE *tfmfile;
+/*:53*/
+/*56:*/
+Static uchar *pxlbm;
+Static pxlstr pxlbmi;
+/*:56*/
+/*58:*/
+Static uchar *pkbm;
+Static short *repbm;
+Static pxlstr pkloc;
+/*:58*/
+/*62:*/
+Static short bitweight;
+/*:62*/
+/*64:*/
+Static ebts car;
+/*:64*/
+/*69:*/
+Static short cxoff, cyoff;
+/*:69*/
+/*73:*/
+Static short power[9]; /*:73*/
+/*93:*/
+Static double valinc, redval, grx, grxzero;
+Static long gradint;
+Static uchar *greymem;
+Static long pgreymem;
+Static boolean randomst, newrandom;
+Static Char texfile_NAME[_FNSIZE];
+Static Char bitmap_NAME[_FNSIZE];
+Static Char pxlfile_NAME[_FNSIZE];
+Static Char tmpfil_NAME[_FNSIZE];
+Static Char tfmfile_NAME[_FNSIZE];
+
+
+/*:93*/
+/*:2*/
+/*6:*/
+Static uchar korrlastb(i, j)
+uchar i;
+short j;
+{
+ ebts k;
+
+ k = 8 - j;
+ if (k > 0) {
+ i >>= k;
+ i <<= k;
+ }
+ return i;
+}
+
+
+/*:6*/
+/*7:*/
+Static uchar pxladd(i, j, k)
+uchar i, j;
+short k;
+{
+ i = (i << k) & 255;
+ j >>= k;
+ return (i | j);
+}
+
+
+/*:7*/
+/*8:*/
+Static unsigned short getcolor()
+{
+ halfk j, k;
+ unsigned short a, o;
+ ebts savcol, lcol, rcol, l, r;
+
+ if (cutgrey) {
+ if ((cutrep & 127) == 0) {
+ if (cutrep == 128)
+ colpos++;
+ cutrep = b1[(halfk)colpos];
+ colpos++;
+ }
+ savcol = b1[(halfk)colpos];
+ if (cutrep < 128)
+ colpos++;
+ cutrep--;
+ return savcol;
+ }
+ a = colpos;
+ colpos += bitspsam;
+ o = a + bitspsam - 1;
+ l = a & 7;
+ r = (o + 1) & 7;
+ k = o >> 3;
+ j = a >> 3;
+ lcol = b1[j];
+ rcol = b1[k];
+ if (k != j) {
+ savcol = lcol << l;
+ savcol = (savcol >> (l - r)) ^ (rcol >> (8 - r));
+ return savcol;
+ }
+ savcol = lcol << l;
+ savcol >>= l;
+ if (r > 0)
+ savcol >>= 8 - r;
+ return savcol;
+}
+
+
+/*:8*/
+/*10:*/
+Static Void sepcols(cr, cg, cb)
+uchar cr, cg, cb;
+{
+ colcyan = 255 - cr;
+ colmagenta = 255 - cg;
+ colyellow = 255 - cb;
+ if (colcyan != colmagenta || colcyan != colyellow || colmagenta != colyellow) {
+ colcyan -= colmagenta / 3;
+ if (colcyan < 0)
+ colcyan = 0;
+ colmagenta -= colyellow / 3;
+ if (colmagenta < 0)
+ colmagenta = 0;
+ }
+ colblack = colcyan;
+ if (colblack > colmagenta)
+ colblack = colmagenta;
+ if (colblack > colyellow)
+ colblack = colyellow;
+}
+
+
+/*:10*/
+/*11:*/
+Static Char *numtostr(Result, i)
+Char *Result;
+long i;
+{
+ Char nstr[256];
+
+ sprintf(nstr, "%ld", i);
+ return strcpy(Result, nstr);
+}
+
+
+/*:9*/
+/*10:*/
+Static Void korrfont()
+{
+ uchar i, j;
+
+ i = strpos2(font, "/", 1);
+ while (i > 0) {
+ strdelete((Anyptr)font, 1, i);
+ i = strpos2(font, "/", 1);
+ }
+ j = strlen(font);
+ i = strpos2(font, ".", 1);
+ if (i != 0)
+ strdelete((Anyptr)font, i, j - i + 1);
+ if (strlen(font) > 7)
+ font[7] = '\0';
+}
+
+
+/*:10*/
+/*11:*/
+Static Void whatistrue()
+{
+ hres = (long)floor(truehres + 0.5);
+ vres = (long)floor(truevres + 0.5);
+ if (halfinch) {
+ hres /= 2;
+ vres /= 2;
+ }
+ hres -= hres & 7;
+ if (hres * vres <= 262136L)
+ return;
+ if (truehres > truevres) {
+ hres = (long)sqrt(262136.0) - 31;
+ vres = (long)(hres * truevres / truehres);
+ return;
+ }
+ if (truevres > truehres) {
+ vres = (long)sqrt(262136.0) - 31;
+ hres = (long)(vres * truehres / truevres);
+ } else {
+ hres = (long)sqrt(262136.0) - 31;
+ vres = hres;
+ }
+} /*:11*/
+
+
+/*12:*/
+Static Void outfix(k)
+long k;
+{
+ short a;
+ long f;
+ char j;
+ long delta;
+ union {
+ ebts b[4];
+ long i;
+ } ax;
+ char dig[12];
+
+ ax.i = k;
+#ifdef INTEL
+ a = (long)ax.b[3] * 16 + ax.b[2] / 16;
+ f = ((ax.b[2] & 15) * 256 + ax.b[1]) * 256 + ax.b[0];
+#else
+ a = (long)ax.b[0] * 16 + ax.b[1] / 16;
+ f = ((ax.b[1] & 15) * 256 + ax.b[2]) * 256 + ax.b[3];
+#endif
+ if (a > 2047) {
+ putc('-', texfile);
+ a = 4096 - a;
+ if (f > 0) {
+ f = 1048576L - f;
+ a--;
+ }
+ }
+ j = 0;
+ do {
+ dig[j] = a % 10;
+ a /= 10;
+ j++;
+ } while (a != 0);
+ do {
+ j--;
+ fprintf(texfile, "%d", dig[j]);
+ } while (j != 0);
+ putc('.', texfile);
+ f = f * 10 + 5;
+ delta = 10;
+ do {
+ if (delta > 1048576L)
+ f += 524288L - delta / 2;
+ fprintf(texfile, "%ld", f / 1048576L);
+ f = f % 1048576L * 10;
+/* p2c: bm2font.pas, line 102:
+ * Note: Using % for possibly-negative arguments [317] */
+ delta *= 10;
+ } while (f > delta);
+}
+
+
+/*:12*/
+/*13:*/
+Static Void fileproblem()
+{
+ printf("file-error %d : ", filestat);
+ switch (filestat) {
+
+ case 2:
+ printf("file not found");
+ break;
+
+ case 3:
+ printf("path not found");
+ break;
+
+ case 4:
+ printf("too many files open");
+ break;
+
+ case 5:
+ printf("file access denied");
+ break;
+
+ case 6:
+ printf("invalid file handle");
+ break;
+
+ case 12:
+ printf("invalid file access mode");
+ break;
+
+ case 15:
+ printf("invalid drive number");
+ break;
+
+ case 101:
+ printf("disk full");
+ break;
+
+ default:
+ printf("ask a tpc guru");
+ break;
+ }
+ printf("!\n");
+ if (pcxtemp)
+/* p2c: bm2font.pas, line 112: Note: Called procedure Exec [285] */
+#ifdef MSDOS
+ Exec("del", "pcxtemp.tmp");
+#else
+ Exec("rm", "pcxtemp.tmp");
+#endif
+ if (giftemp)
+/* p2c: bm2font.pas, line 112: Note: Called procedure Exec [285] */
+#ifdef MSDOS
+ Exec("del", "giftemp.tmp");
+#else
+ Exec("rm", "giftemp.tmp");
+#endif
+ if (greypxl)
+/* p2c: bm2font.pas, line 112: Note: Called procedure Exec [285] */
+#ifdef MSDOS
+ Exec("del", tmpname);
+#else
+ Exec("rm", tmpname);
+#endif
+}
+
+
+/*:13*/
+/*14:*/
+Static Void opentempfile()
+{
+ strcpy(tmpname, "pcxtemp.tmp");
+ strcpy(tmpfil_NAME, "pcxtemp.tmp");
+ filestat = P_ioresult;
+ if (filestat == 0)
+ fok = false;
+ else
+ fok = true;
+ if (fok) {
+ printf("tempfile pcxtemp.tmp not accessable, abort\n");
+ fileproblem();
+ _Escape(0);
+ }
+ if (tmpfil != NULL)
+ tmpfil = freopen(tmpfil_NAME, "w+b", tmpfil);
+ else
+ tmpfil = fopen(tmpfil_NAME, "w+b");
+ _SETIO(tmpfil != NULL, FileNotFound);
+ filestat = P_ioresult;
+ if (filestat == 0)
+ fok = false;
+ else
+ fok = true;
+ if (!fok)
+ return;
+ printf("Unable to create pcxtmp.tmp, abort\n");
+ fileproblem();
+ _Escape(0);
+}
+
+
+/*:14*/
+/*15:*/
+Static Void picstretch()
+{
+ short FORLIM;
+
+ printf("Stretching the picture because of odd aspect ratio\n");
+ posbit = 0;
+ giftemp = true;
+ strcpy(tmpname, "giftemp.tmp");
+ strcpy(tmpfil_NAME, "giftemp.tmp");
+ filestat = P_ioresult;
+ if (filestat == 0)
+ fok = false;
+ else
+ fok = true;
+ if (fok) {
+ printf("tempfile giftemp.tmp not accessable, abort\n");
+ fileproblem();
+ _Escape(0);
+ }
+ if (tmpfil != NULL)
+ tmpfil = freopen(tmpfil_NAME, "w+b", tmpfil);
+ else
+ tmpfil = fopen(tmpfil_NAME, "w+b");
+ if (tmpfil == NULL)
+ _EscIO(FileNotFound);
+ while (!P_eof(bitmap)) {
+ fread(b1, mapinlen, 1, bitmap);
+ if (posbit == xratio) {
+ if (bitspsam == 8) {
+ FORLIM = mapinlen;
+ for (gbufp = 0; gbufp < FORLIM; gbufp++)
+ b3[gbufp] = ((unsigned)(b3[gbufp] + b1[gbufp])) >> 1;
+ } else if (bitspsam == 4) {
+ FORLIM = mapinlen;
+ for (gbufp = 0; gbufp < FORLIM; gbufp++) {
+ b = ((unsigned)((b3[gbufp] >> 4) + (b1[gbufp] >> 4))) >> 1;
+ c = ((unsigned)((b3[gbufp] & 15) + (b1[gbufp] & 15))) >> 1;
+ b3[gbufp] = (b << 4) + c;
+ }
+ }
+/* p2c: bm2font.pas, line 131:
+ * Note: Can't interpret size in BLOCKWRITE [174] */
+ _SETIO(fwrite(b3, mapinlen, 1, tmpfil) == 1, FileWriteError);
+ filestat = P_ioresult;
+ if (filestat != 0) {
+ _SETIO(printf("Error occured when writing file %s!\n", tmpname) >= 0,
+ FileWriteError);
+ fileproblem();
+ _Escape(0);
+ }
+ posbit = 0;
+ }
+ posbit++;
+ if (posbit == xratio) {
+ FORLIM = mapinlen;
+ for (gbufp = 0; gbufp < FORLIM; gbufp++)
+ b3[gbufp] = b1[gbufp];
+ }
+/* p2c: bm2font.pas, line 135:
+ * Note: Can't interpret size in BLOCKWRITE [174] */
+ _SETIO(fwrite(b1, mapinlen, 1, tmpfil) == 1, FileWriteError);
+ filestat = P_ioresult;
+ if (filestat != 0) {
+ _SETIO(printf("Error occured when writing file %s!\n", tmpname) >= 0,
+ FileWriteError);
+ fileproblem();
+ _Escape(0);
+ }
+ }
+/* p2c: bm2font.pas, line 126:
+ * Note: Can't interpret size in BLOCKREAD [174] */
+ if (bitmap != NULL)
+ fclose(bitmap);
+ bitmap = NULL;
+ if (tmpfil != NULL)
+ fclose(tmpfil);
+ tmpfil = NULL;
+ strcpy(bitmap_NAME, "giftemp.tmp");
+ if (bitmap != NULL)
+ bitmap = freopen(bitmap_NAME, "r+b", bitmap);
+ else
+ bitmap = fopen(bitmap_NAME, "r+b");
+ if (bitmap == NULL)
+ _EscIO(FileNotFound);
+ posbit = 0;
+ cutgrey = false;
+ if (pcxtemp) {
+/* p2c: bm2font.pas, line 140: Note: Called procedure Exec [285] */
+#ifdef MSDOS
+ Exec("del", "pcxtemp.tmp");
+#else
+ Exec("rm", "pcxtemp.tmp");
+#endif
+ pcxtemp = false;
+ }
+}
+
+
+/*:15*/
+/*16:*/
+Static Void scaling()
+{ /*17:*/
+ long newh, newv, counth, countv;
+ double scaleh, scalev, ledfac, repfac;
+ boolean grver, grhor, remlast;
+ short FORLIM;
+
+ if (ledprinter)
+ ledfac = 0.5;
+ else
+ ledfac = 0.0;
+ if (hrep != 1)
+ repfac = 2.0;
+ else
+ repfac = 1.0;
+ if (!greypxl) {
+ usepxl = 1;
+ vusepxl = 1;
+ bitspsam = 1;
+ }
+ if (newwidth != 0)
+ newwidth = (long)floor(
+ newwidth * truehres / 25.4 / (repfac * (usepxl + ledfac)) + 0.5);
+ if (newheight != 0)
+ newheight = (long)floor(
+ newheight * truevres / 25.4 / (repfac * (vusepxl + ledfac)) + 0.5);
+ if (newheight == 0)
+ newheight = (long)floor((double)mapheight / mapwidth * newwidth + 0.5);
+ if (newwidth == 0)
+ newwidth = (long)floor((double)mapwidth / mapheight * newheight + 0.5);
+ printf("Scaling the picture from %dx%d", mapwidth, mapheight);
+ printf(" to %ldx%ld pixels\n", newwidth, newheight);
+ grver = (newheight > mapheight);
+ grhor = (newwidth > mapwidth);
+ if (grhor)
+ scaleh = newwidth / (newwidth - mapwidth + 1.0);
+ else
+ scaleh = mapwidth / (mapwidth - newwidth + 1.0);
+ if (grver) /*:17*/
+ scalev = newheight / (newheight - mapheight + 1.0);
+ else
+ scalev = mapheight / (mapheight - newheight + 1.0);
+ /*18:*/
+ if (giftemp)
+ strcpy(tmpname, "pcxtemp.tmp");
+ else
+ strcpy(tmpname, "giftemp.tmp");
+ strcpy(tmpfil_NAME, tmpname);
+ filestat = P_ioresult;
+ if (filestat == 0)
+ fok = false;
+ else
+ fok = true;
+ if (fok) {
+ printf("tempfile %s not accessable, abort\n", tmpname);
+ fileproblem();
+ _Escape(0);
+ }
+ if (tmpfil != NULL)
+ tmpfil = freopen(tmpfil_NAME, "w+b", tmpfil);
+ else
+ tmpfil = fopen(tmpfil_NAME, "w+b");
+ if (tmpfil == NULL)
+ _EscIO(FileNotFound);
+ /*:18*/
+ pxlinlen = (halfk)(((unsigned long)(mapwidth * bitspsam + 7)) >> 3);
+ greypix = mapwidth;
+ if (cutgrey) {
+ checksum = mapheight;
+ pxlinlen = cutlen;
+ } else
+ checksum = mapheight;
+ pl = 0;
+ fseek(bitmap, posbit, 0);
+ for (pk = 0; pk <= 255; pk++)
+ lutsl[pk] = pk << (8 - bitspsam);
+ newv = 1;
+ countv = 0;
+ remlast = false;
+ do {
+ pxlinlen = fread(b1, 1, pxlinlen, bitmap);
+ colpos = 0;
+ cutrep = 0;
+ gbufpp = (newwidth * bitspsam + 7) / 8;
+ memset((Anyptr)b4, invbyte, sizeof(uchar) * 1500L);
+ FORLIM = greypix;
+ for (pk = 0; pk < FORLIM; pk++)
+ b4[pk] = getcolor();
+ if (remlast) {
+ FORLIM = greypix;
+ for (pk = 0; pk < FORLIM; pk++)
+ b4[pk] = (b2[pk] * 2 + b4[pk]) / 3;
+ remlast = false;
+ }
+ gbufp = 0;
+ cb = 0;
+/* p2c: bm2font.pas, line 172:
+ * Note: Can't interpret size in FILLCHAR [174] */
+ memset((Anyptr)b3, invbyte, (long)gbufpp);
+ newh = 1;
+ counth = 0;
+ pk = 0;
+ while (pk < greypix) { /*19:*/
+ cb = lutsl[b4[pk]];
+ dbuf = ((unsigned)gbufp) >> 3;
+ bufsh = gbufp & 7;
+ nextbuf = bufsh + bitspsam;
+ switch (bufsh) {
+
+ case 0:
+ b3[dbuf] = cb;
+ break;
+
+ default:
+ b3[dbuf] ^= cb >> bufsh;
+ if (nextbuf > 8)
+ b3[dbuf + 1] = cb << (8 - bufsh);
+ break;
+ }
+ gbufp += bitspsam;
+ pk++;
+ counth++;
+ if (counth != (long)floor(newh * scaleh + 0.5))
+ continue;
+ if (grhor) {
+ while (counth >= (long)floor(newh * scaleh + 0.5)) {
+ if (pk == greypix)
+ cb = lutsl[(b4[pk - 1] * 2 + b4[pk - 2]) / 3];
+ else
+ cb = lutsl[(b4[pk] * 2 + b4[pk - 1]) / 3];
+ dbuf = ((unsigned)gbufp) >> 3;
+ bufsh = gbufp & 7;
+ nextbuf = bufsh + bitspsam;
+ switch (bufsh) {
+
+ case 0:
+ b3[dbuf] = cb;
+ break;
+
+ default:
+ b3[dbuf] ^= cb >> bufsh;
+ if (nextbuf > 8)
+ b3[dbuf + 1] = cb << (8 - bufsh);
+ break;
+ }
+ gbufp += bitspsam;
+ counth++;
+ newh++;
+ }
+ continue;
+ }
+ while (counth == (long)floor(newh * scaleh + 0.5)) {
+ b4[pk + 1] = (b4[pk + 1] * 2 + b4[pk]) / 3;
+ pk++;
+ newh++;
+ counth++;
+ }
+ } /*:19*/
+ if (bitspsam == 1) {
+ dbuf = ((unsigned)gbufp) >> 3;
+ bufsh = gbufp & 7;
+ if (dbuf < gbufpp) {
+ cb = invbyte;
+ b3[dbuf] ^= cb >> bufsh;
+ }
+ }
+/* p2c: bm2font.pas, line 191:
+ * Note: Can't interpret size in BLOCKWRITE [174] */
+ fwrite(b3, gbufpp, 1, tmpfil);
+ checksum--; /*20:*/
+ countv++;
+ if (cutgrey)
+ pxlinlen = (halfk)(b1[pxlinlen - 1] * 256 + b1[pxlinlen - 2] + 2);
+ if (countv == (long)floor(newv * scalev + 0.5)) { /*:20*/
+ if (grver) {
+ while (countv >= (long)floor(newv * scalev + 0.5)) {
+ fwrite(b3, gbufpp, 1, tmpfil);
+ countv++;
+ newv++;
+ }
+/* p2c: bm2font.pas, line 194:
+ * Note: Can't interpret size in BLOCKWRITE [174] */
+ } else {
+ while (countv == (long)floor(newv * scalev + 0.5)) {
+ pxlinlen = fread(b1, 1, pxlinlen, bitmap);
+ colpos = 0;
+ cutrep = 0;
+ FORLIM = greypix;
+ for (pk = 0; pk < FORLIM; pk++)
+ b2[pk] = getcolor();
+ remlast = true;
+ if (checksum > 0)
+ checksum--;
+ if (cutgrey)
+ pxlinlen = (halfk)(b1[pxlinlen - 1] * 256 + b1[pxlinlen - 2] + 2);
+ newv++;
+ countv++;
+ }
+/* p2c: bm2font.pas, line 196:
+ * Note: Can't interpret size in BLOCKREAD [174] */
+ }
+ }
+ } while (checksum != 0);
+/* p2c: bm2font.pas, line 168:
+ * Note: Can't interpret size in BLOCKREAD [174] */
+ if (bitmap != NULL)
+ fclose(bitmap);
+ bitmap = NULL;
+ if (tmpfil != NULL)
+ fclose(tmpfil);
+ tmpfil = NULL; /*21:*/
+ if (giftemp) { /*:21*/
+/* p2c: bm2font.pas, line 206: Note: Called procedure Exec [285] */
+#ifdef MSDOS
+ Exec("del", "giftemp.tmp");
+#else
+ Exec("rm", "giftemp.tmp");
+#endif
+ giftemp = false;
+ pcxtemp = true;
+ } else {
+/* p2c: bm2font.pas, line 206: Note: Called procedure Exec [285] */
+#ifdef MSDOS
+ Exec("del", "pcxtemp.tmp");
+#else
+ Exec("rm", "pcxtemp.tmp");
+#endif
+ giftemp = true;
+ pcxtemp = false;
+ }
+ strcpy(bitmap_NAME, tmpname);
+ if (bitmap != NULL)
+ bitmap = freopen(bitmap_NAME, "r+b", bitmap);
+ else
+ bitmap = fopen(bitmap_NAME, "r+b");
+ if (bitmap == NULL)
+ _EscIO(FileNotFound);
+ posbit = 0;
+ cutgrey = false;
+ mapheight = newheight;
+ mapwidth = newwidth;
+ if (bitspsam == 1)
+ pxlinlen = (mapwidth + 7) / 8;
+ mapheight = (P_maxpos(bitmap)) / ((mapwidth * bitspsam + 7) / 8);
+} /*:16*/
+
+
+/* Local variables for tifint: */
+struct LOC_tifint {
+ boolean le;
+ uchar tb[3000];
+} ;
+
+/*:22*/
+/*23:*/
+Local unsigned short tifword(ba, LINK)
+unsigned short ba;
+struct LOC_tifint *LINK;
+{
+ if (LINK->le)
+ return ((unsigned short)LINK->tb[ba] + (unsigned short)LINK->tb[ba + 1] * 256);
+ else
+ return ((unsigned short)(LINK->tb[ba] * 256) +
+ (unsigned short)LINK->tb[ba + 1]);
+}
+
+Local long tiflong(ba, LINK)
+unsigned short ba;
+struct LOC_tifint *LINK;
+{
+ if (LINK->le)
+ return ((long)tifword(ba, LINK) + (long)tifword(ba + 2, LINK) * 65536L);
+ else
+ return (LINK->tb[ba] * 16777216 + LINK->tb[ba + 1] * 65536 +
+ LINK->tb[ba + 2] * 256 + (long)LINK->tb[ba + 3]);
+}
+
+Local unsigned short tiftwobyte(ba, LINK)
+unsigned short ba;
+struct LOC_tifint *LINK;
+{
+ if (LINK->le)
+ return ((unsigned short)LINK->tb[ba] + (unsigned short)LINK->tb[ba + 1] * 256);
+ else
+ return ((unsigned short)(LINK->tb[ba] * 256) +
+ (unsigned short)LINK->tb[ba + 1]);
+}
+
+
+/*22:*/
+Static Void tifint()
+{ /*:23*/
+ struct LOC_tifint V;
+ unsigned short i, j, l, m, tl;
+ long ll;
+ uchar tp;
+ boolean strips, tiffrgb;
+ unsigned short ttype;
+ long tiftemp;
+ ebts tiffbuf[3];
+ unsigned short FORLIM;
+ uchar FORLIM1;
+ unsigned short FORLIM2;
+
+ /*24:*/
+ strips = false;
+ tl = fread(V.tb, 1, sizeof(uchar) * 1199, bitmap);
+ V.le = (V.tb[1] == 'I');
+ ll = tiflong(4, &V);
+ if (ll > 900) {
+ printf("I can't digest this\n");
+ _Escape(0);
+ }
+ l = ll;
+ m = tiftwobyte(l, &V);
+ l += 2;
+ for (i = 1; i <= m; i++) {
+ j = tiftwobyte(l, &V);
+ ttype = tiftwobyte(l + 2, &V);
+ if (ttype == 3)
+ tiftemp = tifword(l + 8, &V);
+ else
+ tiftemp = tiflong(l + 8, &V);
+ switch (j) {
+
+ case 256:
+ mapwidth = tiftemp;
+ break;
+
+ case 257:
+ mapheight = tiftemp;
+ break;
+
+ case 258:
+ if (tiftemp > 1) {
+ greypxl = true;
+ bitspsam = tiftemp;
+ if (bitspsam > 8) {
+ printf("Assuming 8 greyshades\n");
+ bitspsam = 8;
+ }
+ mapdiv = 1.0;
+ FORLIM1 = bitspsam;
+ for (tp = 1; tp <= FORLIM1; tp++)
+ mapdiv *= 2;
+ mapdiv /= 16;
+ }
+ break;
+
+ case 259:
+ if (tiftemp > 1) {
+ printf("No compression supported\n");
+ _Escape(0);
+ }
+ break;
+
+ case 262:
+ photoinf = tiftemp;
+ if (photoinf > 1)
+ tiffrgb = true;
+ else
+ tiffrgb = false;
+ if (photoinf == 0)
+ invert = !invert;
+ if (invert) {
+ invbit = 0;
+ invbyte = 0;
+ } else {
+ invbit = 1;
+ invbyte = 255;
+ }
+ photoinf = 15;
+ break;
+
+ case 273:
+ if (tiflong(l + 4, &V) != 1)
+ strips = true;
+ posbit = tiftemp;
+ break;
+
+ case 277:
+ if (tiftemp == 3)
+ tiffrgb = true;
+ else
+ tiffrgb = false;
+ break;
+
+ case 278:
+ rowspstrip = tiftemp;
+ break;
+
+ case 290:
+ greyunit = 1.0;
+ FORLIM1 = tifword(l + 4, &V);
+ for (tp = 1; tp <= FORLIM1; tp++)
+ greyunit /= 10;
+ break;
+
+ case 291:
+ FORLIM1 = tiflong(l + 4, &V);
+ for (tp = 0; tp < FORLIM1; tp++)
+ tpal[tp] = V.tb[l + tp + 8];
+ break;
+ }
+ l += 12;
+ if (l >= tl) {
+ tl = fread(V.tb, 1, sizeof(uchar) * 1199, bitmap);
+ l = 0;
+ }
+ }
+ if (strips) {
+ fseek(bitmap, posbit, 0);
+ l = fread(V.tb, 1, sizeof(uchar) * 2, bitmap);
+ posbit = tiflong(0, &V);
+ }
+ if (!tiffrgb)
+ return;
+ opentempfile();
+ fseek(bitmap, posbit, 0);
+ FORLIM = mapheight;
+ for (j = 1; j <= FORLIM; j++) {
+ FORLIM2 = mapwidth;
+ for (i = 0; i < FORLIM2; i++) {
+ l = fread(tiffbuf, 1, 3, bitmap);
+ if (cmyk) {
+ sepcols(tiffbuf[0], tiffbuf[1], tiffbuf[2]);
+ if (cyan)
+ b3[i] = 255 - colcyan;
+ if (magenta)
+ b3[i] = 255 - colmagenta;
+ if (yellow)
+ b3[i] = 255 - colyellow;
+ if (black)
+ b3[i] = 255 - colblack;
+ } else
+ b3[i] = (long)floor(tiffbuf[0] * 0.287 + tiffbuf[1] * 0.589 +
+ tiffbuf[2] * 0.114 + 0.5);
+ }
+/* p2c: bm2font.pas, line 244:
+ * Note: Can't interpret size in BLOCKREAD [174] */
+/* p2c: bm2font.pas, line 257:
+ * Note: Can't interpret size in BLOCKWRITE [174] */
+ fwrite(b3, mapwidth, 1, tmpfil);
+ }
+ if (bitmap != NULL)
+ fclose(bitmap);
+ bitmap = NULL;
+ if (tmpfil != NULL)
+ fclose(tmpfil);
+ tmpfil = NULL;
+ strcpy(bitmap_NAME, "pcxtemp.tmp");
+ if (bitmap != NULL)
+ bitmap = freopen(bitmap_NAME, "r+b", bitmap);
+ else
+ bitmap = fopen(bitmap_NAME, "r+b");
+ if (bitmap == NULL)
+ _EscIO(FileNotFound);
+ posbit = 0;
+ pcxtemp = true;
+ mapinlen = mapwidth;
+}
+
+
+/*:24*/
+/*26:*/
+Static Void cutint()
+{
+ long FORLIM;
+ short FORLIM1;
+
+ pxlinlen = 8;
+/* p2c: bm2font.pas, line 241:
+ * Note: Can't interpret size in BLOCKREAD [174] */
+ pxlinlen = fread(b1, 1, pxlinlen, bitmap);
+ if (pxlinlen != 8) {
+ printf("CUT file too small!\n");
+ _Escape(0);
+ }
+ mapheight = b1[3] * 256 + b1[2];
+ mapwidth = b1[1] * 256 + b1[0];
+ photoinf = 15;
+ mapdiv = 16.0;
+ posbit = 8;
+ cutlen = b1[7] * 256 + b1[6] + 2;
+ bitspsam = 8;
+ cutgrey = true;
+ greypxl = true;
+ if (!egastretch)
+ return;
+ mapinlen = mapwidth;
+ printf("Shrinking the CUT picture because of odd aspect ratio\n");
+ giftemp = true;
+ strcpy(tmpname, "giftemp.tmp");
+ strcpy(tmpfil_NAME, "giftemp.tmp");
+ filestat = P_ioresult;
+ if (filestat == 0)
+ fok = false;
+ else
+ fok = true;
+ if (fok) {
+ printf("tempfile giftemp.tmp not accessable, abort\n");
+ fileproblem();
+ _Escape(0);
+ }
+ if (tmpfil != NULL)
+ tmpfil = freopen(tmpfil_NAME, "w+b", tmpfil);
+ else
+ tmpfil = fopen(tmpfil_NAME, "w+b");
+ if (tmpfil == NULL)
+ _EscIO(FileNotFound);
+ xratio = 2;
+ posbit = 0;
+ pxlinlen = cutlen;
+ FORLIM = mapheight;
+ for (checksum = 1; checksum <= FORLIM; checksum++) {
+ pxlinlen = fread(b1, 1, pxlinlen, bitmap);
+ colpos = 0;
+ cutrep = 0;
+ FORLIM1 = mapinlen;
+ for (pk = 0; pk < FORLIM1; pk++)
+ b2[pk] = getcolor();
+ posbit++;
+ FORLIM1 = mapinlen;
+ for (gbufp = 0; gbufp < FORLIM1; gbufp++)
+ b3[gbufp] = b2[gbufp];
+ if (posbit < xratio) {
+ _SETIO(fwrite(b2, mapinlen, 1, tmpfil) == 1, FileWriteError);
+ filestat = P_ioresult;
+ if (filestat != 0) {
+ _SETIO(printf("Error occured when writing file %s!\n", tmpname) >= 0,
+ FileWriteError);
+ fileproblem();
+ _Escape(0);
+ }
+ }
+/* p2c: bm2font.pas, line 256:
+ * Note: Can't interpret size in BLOCKWRITE [174] */
+ if (posbit > xratio) {
+ FORLIM1 = mapinlen;
+ for (gbufp = 0; gbufp < FORLIM1; gbufp++)
+ b3[gbufp] = ((unsigned)(b3[gbufp] + b2[gbufp])) >> 1;
+/* p2c: bm2font.pas, line 261:
+ * Note: Can't interpret size in BLOCKWRITE [174] */
+ _SETIO(fwrite(b3, mapinlen, 1, tmpfil) == 1, FileWriteError);
+ filestat = P_ioresult;
+ if (filestat != 0) {
+ _SETIO(printf("Error occured when writing file %s!\n", tmpname) >= 0,
+ FileWriteError);
+ fileproblem();
+ _Escape(0);
+ }
+ posbit = 0;
+ if (xratio == 2)
+ xratio = 3;
+ else
+ xratio = 2;
+ }
+ pxlinlen = (halfk)(b1[pxlinlen - 1] * 256 + b1[pxlinlen - 2] + 2);
+ }
+/* p2c: bm2font.pas, line 253:
+ * Note: Can't interpret size in BLOCKREAD [174] */
+ if (bitmap != NULL)
+ fclose(bitmap);
+ bitmap = NULL;
+ if (tmpfil != NULL)
+ fclose(tmpfil);
+ tmpfil = NULL;
+ strcpy(bitmap_NAME, "giftemp.tmp");
+ if (bitmap != NULL)
+ bitmap = freopen(bitmap_NAME, "r+b", bitmap);
+ else
+ bitmap = fopen(bitmap_NAME, "r+b");
+ if (bitmap == NULL)
+ _EscIO(FileNotFound);
+ cutgrey = false;
+ posbit = 0;
+}
+
+
+typedef unsigned short tabcode[4097];
+typedef uchar bytecod[4097];
+typedef uchar ilaced[4];
+typedef uchar ebts_;
+
+
+typedef long gifmask[13];
+
+
+/* Local variables for gifint: */
+struct LOC_gifint {
+ ilaced ioff, ijump;
+ long lvr, linepos;
+ ebts_ logvr, codesample, modus, gifshift, nextbuf, bufsh;
+ unsigned short maxcode, hh;
+ short ec, ki;
+ unsigned short hell[256];
+ ebts_ gifbuf[3000];
+ unsigned short codepos, gifinlen, gotinlen;
+ long codesav;
+ unsigned short dbuf, linebytes;
+} ;
+
+/*:27*/
+/*28:*/
+Local uchar getgif(LINK)
+struct LOC_gifint *LINK;
+{
+/* p2c: bm2font.pas, line 279:
+ * Note: Can't interpret size in BLOCKREAD [174] */
+ fread(b1, 1, 1, bitmap);
+ return (b1[0]);
+}
+
+Local Void gifout(b, LINK)
+unsigned short b;
+struct LOC_gifint *LINK;
+{
+ short i, FORLIM;
+ ebts_ ibits;
+
+ if (gbufpp < 3000)
+ b2[gbufpp] = LINK->hell[b];
+ gbufpp++;
+ if (gbufpp != LINK->hh)
+ return;
+ LINK->codepos = 0;
+/* p2c: bm2font.pas, line 282:
+ * Note: Can't interpret size in FILLCHAR [174] */
+ memset((Anyptr)LINK->gifbuf, invbyte, 3000L);
+ FORLIM = LINK->hh;
+ for (i = 0; i < FORLIM; i++) {
+ LINK->dbuf = LINK->codepos / 8;
+ LINK->bufsh = LINK->codepos & 7;
+ LINK->nextbuf = LINK->bufsh + bitspsam;
+ cb = lutsl[b2[i]];
+ if (LINK->bufsh == 0)
+ LINK->gifbuf[LINK->dbuf] = cb;
+ else {
+ LINK->gifbuf[LINK->dbuf] |= cb >> LINK->bufsh;
+ if (LINK->nextbuf > 8)
+ LINK->gifbuf[LINK->dbuf + 1] = cb << (8 - LINK->bufsh);
+ }
+ LINK->codepos += bitspsam;
+ }
+ if (LINK->modus == 1)
+ fseek(tmpfil, LINK->linepos, 0);
+ if (bitspsam == 1) {
+ i = 8 - (LINK->hh & 7);
+ if (i != 8) {
+ cb = LINK->gifbuf[LINK->dbuf] >> i;
+ cb <<= i;
+ LINK->gifbuf[LINK->dbuf] = cb;
+ cb = invbit;
+ for (ibits = 1; ibits <= i; ibits++) {
+ LINK->gifbuf[LINK->dbuf] ^= cb;
+ cb <<= 1;
+ }
+ }
+ }
+/* p2c: bm2font.pas, line 291:
+ * Note: Can't interpret size in BLOCKWRITE [174] */
+ _SETIO(fwrite(LINK->gifbuf, LINK->linebytes, 1, tmpfil) == 1,
+ FileWriteError);
+ filestat = P_ioresult;
+ if (filestat != 0) {
+ _SETIO(printf("Error occured when writing file %s!\n", tmpname) >= 0,
+ FileWriteError);
+ fileproblem();
+ _Escape(0);
+ }
+ LINK->lvr++;
+ gbufpp = 0;
+ LINK->linepos += LINK->linebytes * LINK->ijump[LINK->logvr];
+ if (LINK->linepos >= P_maxpos(tmpfil)-1) {
+ LINK->logvr++;
+ LINK->linepos = LINK->ioff[LINK->logvr] * LINK->linebytes;
+ }
+}
+
+Local unsigned short gifcode(LINK)
+struct LOC_gifint *LINK;
+{
+ unsigned short Result;
+
+ static gifmask codemask = {
+ 0, 1, 3, 7, 15, 31, 63, 127, 255, 511, 1023, 2047, 4095
+ };
+
+ long codebyte;
+
+ while (LINK->gifshift < LINK->codesample) {
+ codebyte = b1[gbufp];
+ gbufp++;
+ if (gbufp == LINK->gifinlen) {
+ LINK->gifinlen = getgif(LINK);
+/* p2c: bm2font.pas, line 303:
+ * Note: Can't interpret size in BLOCKREAD [174] */
+ LINK->gotinlen = fread(b1, 1, LINK->gifinlen, bitmap);
+ gbufp = 0;
+ if (LINK->gifinlen == 0)
+ printf("Code zero, proceeding\n");
+ if (LINK->gotinlen != LINK->gifinlen) {
+ b1[LINK->gotinlen] = LINK->ec;
+ LINK->gifinlen = LINK->gotinlen + 1;
+ }
+ }
+ LINK->codesav |= codebyte << LINK->gifshift;
+ LINK->gifshift += 8;
+ }
+ Result = LINK->codesav & codemask[LINK->codesample];
+ LINK->codesav = ((unsigned long)LINK->codesav) >> LINK->codesample;
+ LINK->gifshift -= LINK->codesample;
+ LINK->ki++;
+ if (LINK->ki > LINK->maxcode && LINK->codesample < 12) {
+ LINK->codesample++;
+ LINK->maxcode = 1 << LINK->codesample;
+ }
+ return Result;
+}
+
+
+/*:26*/
+/*27:*/
+Static Void gifint()
+{ /*:28*/
+ struct LOC_gifint V;
+
+ static ilaced ioff = {
+ 0, 4, 2, 1
+ };
+
+ static ilaced ijump = {
+ 8, 8, 4, 2
+ };
+
+ unsigned short a, g, hi, vi, vh, hr, vr;
+ short merk, ic, codegif, i;
+ ebts_ colmap, b, col, bpp;
+ ebts_ gpal[256][3];
+ unsigned short *codtab;
+ unsigned short folge, minhell, maxhell;
+ uchar *anf;
+ Char hexbyte[7];
+ short FORLIM;
+
+ /*29:*/
+ memcpy(V.ioff, ioff, sizeof(ilaced));
+ memcpy(V.ijump, ijump, sizeof(ilaced));
+ printf("Decoding GIF file\n");
+ V.logvr = 0;
+ V.codesav = 0;
+ V.lvr = 0;
+ minhell = 9999;
+ maxhell = 0;
+ codtab = (unsigned short *)Malloc(sizeof(tabcode));
+ anf = (uchar *)Malloc(sizeof(bytecod));
+ opentempfile();
+ *hexbyte = '\0';
+ for (i = 1; i <= 3; i++) {
+ sprintf(hexbyte + strlen(hexbyte), "%c", getgif(&V));
+/* p2c: bm2font.pas, line 313:
+ * Note: Possible string truncation in assignment [145] */
+ }
+ if (strcmp(hexbyte, "GIF")) {
+ printf("This file is NOT a gif file!\n");
+ _Escape(0);
+ }
+ for (i = 1; i <= 3; i++) {
+ sprintf(hexbyte + strlen(hexbyte), "%c", getgif(&V));
+/* p2c: bm2font.pas, line 315:
+ * Note: Possible string truncation in assignment [145] */
+ }
+ if (strcmp(hexbyte, "GIF87a") && strcmp(hexbyte, "GIF89a")) {
+ printf("The program only supports version 87a and 89a!\n");
+ _Escape(0);
+ }
+ b = getgif(&V);
+ hr = b;
+ b = getgif(&V);
+ hr += b * 256;
+ b = getgif(&V);
+ vr = b;
+ b = getgif(&V);
+ vr += b * 256;
+ if (hr == 640 && vr == 350) {
+ xratio = 3;
+ yratio = 4;
+ }
+ b = getgif(&V);
+ colmap = b & 128;
+ colmap >>= 7;
+ col = b & 112;
+ col >>= 4;
+ col++;
+ bitspsam = b & 7;
+ bitspsam++;
+ b = getgif(&V);
+ b = getgif(&V);
+ if (colmap == 1) { /*30:*/
+ g = 1;
+ FORLIM = bitspsam;
+ for (i = 1; i <= FORLIM; i++)
+ g *= 2;
+ for (i = 0; i < g; i++) {
+ for (j = 0; j <= 2; j++)
+ gpal[i][j] = getgif(&V);
+ if (cmyk) {
+ sepcols(gpal[i][0], gpal[i][1], gpal[i][2]);
+ if (cyan)
+ V.hell[i] = 255 - colcyan;
+ if (magenta)
+ V.hell[i] = 255 - colmagenta;
+ if (yellow)
+ V.hell[i] = 255 - colyellow;
+ if (black)
+ V.hell[i] = 255 - colblack;
+ bhell[V.hell[i]] = 255 - colblack;
+ } else
+ V.hell[i] = (long)floor(gpal[i][0] * 0.287 + gpal[i][1] * 0.589 + gpal[i]
+ [2] * 0.114 + 0.5);
+ if (V.hell[i] > maxhell)
+ maxhell = V.hell[i];
+ }
+ if (bitspsam > 1) {
+ for (i = 0; i < g; i++)
+ V.hell[i] = (long)floor((double)V.hell[i] / maxhell * (g - 1) + 0.5);
+ for (i = 0; i < g; i++)
+ bhell[i] = (long)floor((double)bhell[i] / maxhell * (g - 1) + 0.5);
+ } else {
+ V.hell[0] = 0;
+ V.hell[1] = 1;
+ bhell[0] = 0;
+ bhell[1] = 1;
+ }
+ }
+ b = getgif(&V);
+ if (b != 44) { /*31:*/
+ while (b != 44) { /*:31*/
+ b = getgif(&V);
+ switch (b) {
+
+ case 249:
+ a = getgif(&V);
+ for (g = 0; g <= a; g++)
+ b = getgif(&V);
+ break;
+
+ case 254:
+ a = getgif(&V);
+ while (a != 0) {
+ for (g = 0; g <= a; g++)
+ b = getgif(&V);
+ a = b;
+ if (P_eof(bitmap)) {
+ printf("file ended while looking for image\n");
+ _Escape(0);
+ }
+ }
+ break;
+
+ case 1:
+ case 255:
+ a = getgif(&V);
+ for (g = 1; g <= a; g++)
+ b = getgif(&V);
+ a = getgif(&V);
+ while (a != 0) {
+ for (g = 0; g <= a; g++)
+ b = getgif(&V);
+ a = b;
+ if (P_eof(bitmap)) {
+ printf("file ended while looking for image\n");
+ _Escape(0);
+ }
+ }
+ break;
+ }
+ b = getgif(&V);
+ if (P_eof(bitmap)) {
+ printf("file ended while looking for image\n");
+ _Escape(0);
+ }
+ }
+ }
+ b = getgif(&V);
+ hi = b;
+ b = getgif(&V);
+ hi += b * 256;
+ b = getgif(&V);
+ vi = b;
+ b = getgif(&V);
+ vi += b * 256;
+ b = getgif(&V);
+ V.hh = b;
+ b = getgif(&V);
+ V.hh += b * 256;
+ b = getgif(&V);
+ vh = b;
+ b = getgif(&V);
+ vh += b * 256;
+ if (V.hh != hr || vh != vr)
+ printf("No fragments supported!\n");
+ V.linebytes = (V.hh * bitspsam + (bitspsam - 1)+7) / 8;
+ if (V.linebytes > 3000) {
+ V.linebytes = 3000;
+ printf("Sorry, had to cut picture to a width of 3000 bytes\n");
+ }
+ b = getgif(&V);
+ col = b & 128;
+ col >>= 7;
+ if (col != 0) {
+ bitspsam = b & 7;
+ bitspsam++; /*30:*/
+ g = 1;
+ FORLIM = bitspsam;
+ for (i = 1; i <= FORLIM; i++)
+ g *= 2;
+ for (i = 0; i < g; i++) {
+ for (j = 0; j <= 2; j++)
+ gpal[i][j] = getgif(&V);
+ if (cmyk) {
+ sepcols(gpal[i][0], gpal[i][1], gpal[i][2]);
+ if (cyan)
+ V.hell[i] = 255 - colcyan;
+ if (magenta)
+ V.hell[i] = 255 - colmagenta;
+ if (yellow)
+ V.hell[i] = 255 - colyellow;
+ if (black)
+ V.hell[i] = 255 - colblack;
+ bhell[V.hell[i]] = 255 - colblack;
+ } else
+ V.hell[i] = (long)floor(gpal[i][0] * 0.287 + gpal[i][1] * 0.589 + gpal[i]
+ [2] * 0.114 + 0.5);
+ if (V.hell[i] > maxhell)
+ maxhell = V.hell[i];
+ }
+ for (i = 0; i < g; i++)
+ V.hell[i] = (long)floor((double)V.hell[i] / maxhell * (g - 1) + 0.5);
+ for (i = 0; i < g; i++) /*:30*/
+ bhell[i] = (long)floor((double)bhell[i] / maxhell * (g - 1) + 0.5);
+ }
+ for (pk = 0; pk <= 255; pk++)
+ lutsl[pk] = pk << (8 - bitspsam);
+ V.modus = b << 1;
+ V.modus >>= 7;
+ if (V.modus == 0)
+ printf("Image is loaded sequentially.\n");
+ else
+ printf("Interlaced mode, loading the image will take more time.\n");
+ if (V.modus != 0) {
+ memset((Anyptr)V.gifbuf, invbyte, 3000L);
+ for (i = 1; i <= vh; i++) {
+ _SETIO(fwrite(V.gifbuf, V.linebytes, 1, tmpfil) == 1, FileWriteError);
+ filestat = P_ioresult;
+ if (filestat != 0) {
+ _SETIO(printf("Error occured when writing file %s!\n", tmpname) >= 0,
+ FileWriteError);
+ fileproblem();
+ _Escape(0);
+ }
+ }
+/* p2c: bm2font.pas, line 379:
+ * Note: Can't interpret size in BLOCKWRITE [174] */
+ V.linepos = 0;
+ V.logvr = 0;
+ fseek(tmpfil, 0L, 0);
+ }
+/* p2c: bm2font.pas, line 378:
+ * Note: Can't interpret size in FILLCHAR [174] */
+ bpp = b << 5;
+ bpp >>= 5;
+ bpp++;
+ bpp = getgif(&V);
+ g = 1 << bpp;
+ ic = 1 << bpp;
+ V.ec = ic + 1;
+ V.codesample = bpp + 1;
+ V.maxcode = 1 << V.codesample;
+ for (i = 0; i <= 4095; i++)
+ codtab[i] = 4098;
+ V.ki = V.ec + 1;
+ a = 4098;
+ gbufpp = 0;
+ V.gifshift = 0;
+ V.gifinlen = getgif(&V);
+/* p2c: bm2font.pas, line 387:
+ * Note: Can't interpret size in BLOCKREAD [174] */
+ fread(b1, V.gifinlen, 1, bitmap);
+ gbufp = 0;
+ if (V.gifinlen == 0)
+ _Escape(0);
+ merk = 0; /*32:*/
+ while (V.lvr < vh) { /*:32*/
+ codegif = gifcode(&V);
+ if (codegif == V.ec) {
+ printf("End of code before gif image completed!\n");
+ V.lvr = vh;
+ continue;
+ }
+ if (codegif == ic) {
+ for (i = 0; i <= 4095; i++)
+ codtab[i] = 4098;
+ V.ki = V.ec + 1;
+ V.codesample = bpp + 1;
+ V.maxcode = 1 << V.codesample;
+ a = 4098;
+ continue;
+ }
+ if (codegif < ic)
+ gifout(codegif, &V);
+ else {
+ if (codtab[codegif] == 4098) {
+ if (codegif != V.ki - 2) {
+ printf("Bytes are mangled!\n");
+ _Escape(0);
+ }
+ folge = a;
+ merk++;
+ while (folge > ic)
+ folge = codtab[folge];
+ b3[merk] = folge;
+ anf[V.ki - 2] = folge;
+ folge = a;
+ } else
+ folge = codegif;
+ while (folge > ic && folge <= 4095) {
+ merk++;
+ b3[merk] = anf[folge];
+ folge = codtab[folge];
+ }
+ merk++;
+ b3[merk] = folge;
+ while (merk > 0) {
+ gifout(b3[merk], &V);
+ merk--;
+ }
+ }
+ if (a != 4098) {
+ codtab[V.ki - 2] = a;
+ if (codegif == V.ki - 2) {
+ folge = a;
+ while (folge > ic)
+ folge = codtab[folge];
+ anf[V.ki - 2] = folge;
+ } else {
+ folge = codegif;
+ while (folge > ic)
+ folge = codtab[folge];
+ anf[V.ki - 2] = folge;
+ }
+ }
+ a = codegif;
+ }
+ if (bitmap != NULL)
+ fclose(bitmap);
+ bitmap = NULL;
+ if (tmpfil != NULL)
+ fclose(tmpfil);
+ tmpfil = NULL;
+ if (bitspsam > 1)
+ greypxl = true;
+ mapinlen = V.linebytes;
+ strcpy(bitmap_NAME, "pcxtemp.tmp");
+ if (bitmap != NULL)
+ bitmap = freopen(bitmap_NAME, "r+b", bitmap);
+ else
+ bitmap = fopen(bitmap_NAME, "r+b");
+ if (bitmap == NULL)
+ _EscIO(FileNotFound);
+ pcxtemp = true;
+ if (egastretch) {
+ if (xratio + 1 == yratio)
+ picstretch();
+ }
+ posbit = 0;
+ mapdiv = 1.0;
+ FORLIM = bitspsam;
+ for (i = 1; i <= FORLIM; i++)
+ mapdiv *= 2;
+ mapdiv /= 16;
+}
+
+
+/*:29*/
+/*33:*/
+Static uchar getpcx()
+{
+ uchar Result;
+
+ if (gbufp == pxlinlen) {
+ gbufp = 0;
+ pxlinlen = fread(b1, 1, sizeof(uchar) * 320, bitmap);
+ }
+ Result = b1[gbufp];
+ gbufp++;
+ return Result;
+}
+
+
+/*:33*/
+/*34:*/
+Static long longpcx()
+{
+ long bl;
+ ebts pb;
+
+ pb = getpcx();
+ bl = pb;
+ pb = getpcx();
+ bl += pb * 256;
+ pb = getpcx();
+ bl += pb * 65536;
+ pb = getpcx();
+ bl += pb * 16777216;
+ return bl;
+}
+
+
+/*:34*/
+/*35:*/
+Static unsigned short wordpcx()
+{
+ unsigned short bl;
+ ebts pb;
+
+ pb = getpcx();
+ bl = pb;
+ pb = getpcx();
+ bl += pb * 256;
+ return bl;
+} /*:35*/
+
+
+/*36:*/
+Static Void pcxint()
+{
+ unsigned short i, ki, k, hi, hh, vi, vh, hr, vr, bzf;
+ ebts xb, j, b, a, col, bps, ibits, pcxver, pcxcomp;
+ ebts gpal[256][3];
+ unsigned short hell[256];
+ unsigned short FORLIM;
+ short FORLIM1;
+
+ printf("Analysing PCX file %s\n", bmname);
+ gbufp = 640;
+ pxlinlen = 640;
+ b = getpcx();
+ if (b != 10 && b != 205) {
+ printf("What a bad joke!\n");
+ printf("This is NOT a PCX file!\n");
+ _Escape(0);
+ }
+ if (b == 205)
+ printf("First byte 205, file seems to be captured!\n");
+ /*37:*/
+ pcxver = getpcx();
+ pcxcomp = getpcx();
+ bps = getpcx();
+ hi = getpcx();
+ b = getpcx();
+ hi += b * 256;
+ vi = getpcx();
+ b = getpcx();
+ vi += b * 256;
+ hh = getpcx();
+ b = getpcx();
+ hh += b * 256;
+ vh = getpcx();
+ b = getpcx();
+ vh += b * 256;
+ hr = getpcx();
+ b = getpcx();
+ hr += b * 256;
+ vr = getpcx();
+ b = getpcx();
+ vr += b * 256;
+ if (hr == 640 && vr == 350) {
+ xratio = 3;
+ yratio = 4;
+ }
+ if (hr == 320 && vr == 200) {
+ xratio = 5;
+ yratio = 6;
+ }
+ hh -= hi;
+ vh -= vi;
+ mapwidth = hh;
+ for (i = 0; i <= 15; i++) {
+ for (j = 0; j <= 2; j++)
+ gpal[i][j] = getpcx();
+ }
+ b = getpcx();
+ col = getpcx();
+ bzf = getpcx();
+ b = getpcx();
+ bzf += b * 256;
+ hh = bzf;
+ b = getpcx();
+ b = getpcx();
+ for (i = 70; i <= 127; i++)
+ b = getpcx();
+ bitspsam = bps;
+ if (col == 4) {
+ bitspsam = 4;
+ greypxl = true;
+ } else if (bps > 1) {
+ bitspsam = bps;
+ greypxl = true;
+ }
+ mapinlen = ((unsigned long)(mapwidth * bitspsam + 7)) >> 3; /*:37*/
+ /*38:*/
+ for (i = 0; i <= 15; i++) {
+ if (cmyk) {
+ sepcols(gpal[i][0], gpal[i][1], gpal[i][2]);
+ if (cyan)
+ hell[i] = 255 - colcyan;
+ if (magenta)
+ hell[i] = 255 - colmagenta;
+ if (yellow)
+ hell[i] = 255 - colyellow;
+ if (black)
+ hell[i] = 255 - colblack;
+ hell[i] /= 16;
+ if (hell[i] > 15)
+ hell[i] = 15;
+ bhell[hell[i]] = 0;
+ } else
+ hell[i] = (long)(gpal[i][0] / 16.0 * 0.287 + gpal[i][1] / 16.0 * 0.589 +
+ gpal[i][2] / 16.0 * 0.114);
+ }
+ for (i = 0; i <= 15; i++) {
+ if (hell[i] > 15)
+ hell[i] = 15;
+ }
+ for (i = 0; i <= 15; i++) {
+ if (bhell[i] > 15)
+ bhell[i] = 15;
+ }
+ opentempfile(); /*:38*/
+ if (pcxver == 5 && bitspsam > 4) { /*39:*/
+ gbufp = 640;
+ pxlinlen = 640;
+ posbit = P_maxpos(bitmap);
+ posbit -= 769;
+ fseek(bitmap, posbit, 0);
+ b = getpcx();
+ if (b != 12) {
+ printf("No valid information in 256 colors palette\n");
+ printf("Using standard 16 colors palette\n");
+ } else {
+ for (i = 0; i <= 255; i++) {
+ for (j = 0; j <= 2; j++)
+ gpal[i][j] = getpcx();
+ if (cmyk) {
+ sepcols(gpal[i][0], gpal[i][1], gpal[i][2]);
+ if (cyan)
+ hell[i] = 255 - colcyan;
+ if (magenta)
+ hell[i] = 255 - colmagenta;
+ if (yellow)
+ hell[i] = 255 - colyellow;
+ if (black)
+ hell[i] = 255 - colblack;
+ bhell[hell[i]] = 255 - colblack;
+ } else
+ hell[i] = (long)floor(gpal[i][0] * 0.287 + gpal[i][1] * 0.589 + gpal[i]
+ [2] * 0.114 + 0.5);
+ }
+ }
+ fseek(bitmap, 128L, 0);
+ gbufp = 640;
+ pxlinlen = 640;
+ }
+ /*:39*/
+ /*40:*/
+ a = 0;
+ for (i = 0; i <= vh; i++) { /*:40*/
+ FORLIM1 = mapinlen;
+ for (gbufpp = 0; gbufpp < FORLIM1; gbufpp++)
+ b3[gbufpp] = 0;
+ for (j = 0; j < col; j++) {
+ gbufpp = 0;
+ for (k = 1; k <= hh; k++) {
+ if (a == 0) {
+ b = getpcx();
+ if ((b & 0xc0) == 0xc0) {
+ a = (b & 0x3f) - 1;
+ b = getpcx();
+ }
+ } else
+ a--;
+ if (col == 4) {
+ for (ibits = 0; ibits <= 7; ibits++) {
+ ki = gbufpp * 4 + (ibits >> 1);
+ xb = b << ibits;
+ xb >>= 7;
+ xb <<= j;
+ xb <<= (1 - (ibits & 1)) << 2;
+ b3[ki] ^= xb;
+ }
+ } else {
+ b3[gbufpp] = b;
+ if (gbufpp == mapinlen - 1 && bitspsam == 1) {
+ ki = 8 - (mapwidth & 7);
+ if (ki != 8) {
+ xb = b3[gbufpp] >> ki;
+ xb <<= ki;
+ b3[gbufpp] = xb;
+ xb = invbit;
+ for (ibits = 1; ibits <= ki; ibits++) {
+ b3[gbufpp] ^= xb;
+ xb <<= 1;
+ }
+ }
+ }
+ }
+ gbufpp++;
+ }
+ }
+ if (col == 4) {
+ gbufpp = 0;
+ hi = (hh - 1) * 4 + 3;
+ for (k = 0; k <= hi; k++) {
+ b3[gbufpp] = (hell[b3[k] >> 4] << 4) + hell[b3[k] & 15];
+ gbufpp++;
+ }
+ } else if (bps == 8 && pcxver == 5) {
+ hi = hh - 1;
+ for (k = 0; k <= hi; k++)
+ b3[k] = hell[b3[k]];
+ gbufpp = hh;
+ }
+/* p2c: bm2font.pas, line 489:
+ * Note: Can't interpret size in BLOCKWRITE [174] */
+ _SETIO(fwrite(b3, mapinlen, 1, tmpfil) == 1, FileWriteError);
+ filestat = P_ioresult;
+ if (filestat != 0) {
+ _SETIO(printf("Error occured when writing file %s!\n", tmpname) >= 0,
+ FileWriteError);
+ fileproblem();
+ _Escape(0);
+ }
+ if (hr == 640 && vr == 200) {
+ _SETIO(fwrite(b3, mapinlen, 1, tmpfil) == 1, FileWriteError);
+ filestat = P_ioresult;
+ if (filestat != 0) {
+ _SETIO(printf("Error occured when writing file %s!\n", tmpname) >= 0,
+ FileWriteError);
+ fileproblem();
+ _Escape(0);
+ }
+ }
+/* p2c: bm2font.pas, line 492:
+ * Note: Can't interpret size in BLOCKWRITE [174] */
+ }
+ if (bitmap != NULL)
+ fclose(bitmap);
+ bitmap = NULL;
+ if (tmpfil != NULL)
+ fclose(tmpfil);
+ tmpfil = NULL;
+ strcpy(bitmap_NAME, "pcxtemp.tmp");
+ if (bitmap != NULL)
+ bitmap = freopen(bitmap_NAME, "rb", bitmap);
+ else
+ bitmap = fopen(bitmap_NAME, "rb");
+ if (bitmap == NULL)
+ _EscIO(FileNotFound);
+ pcxtemp = true;
+ if (egastretch) {
+ if (xratio + 1 == yratio)
+ picstretch();
+ }
+ posbit = 0;
+ mapdiv = 1.0;
+ FORLIM = bitspsam;
+ for (i = 1; i <= FORLIM; i++)
+ mapdiv *= 2;
+ mapdiv /= 16;
+}
+
+
+/* Local variables for iffint: */
+struct LOC_iffint {
+ unsigned short hi, hh, vi, vh, compr;
+ uchar a, b, col, bps;
+ uchar gpal[256][3];
+ unsigned short hell[256];
+ Char bmstr[256];
+ long bmsize, bmoff, bl;
+} ;
+
+/*:41*/
+/*42:*/
+Local long ifflong(LINK)
+struct LOC_iffint *LINK;
+{
+ ebts k;
+
+ fread(b1, 4, 1, bitmap);
+ LINK->bl = b1[0];
+ for (k = 1; k <= 3; k++)
+ LINK->bl = LINK->bl * 256 + b1[k];
+ return LINK->bl;
+}
+
+/*:42*/
+/*43:*/
+Local unsigned short iffword(LINK)
+struct LOC_iffint *LINK;
+{
+ fread(b1, 2, 1, bitmap);
+ return (b1[0] * 256 + b1[1]);
+}
+
+/*:43*/
+/*44:*/
+Local Void junkchunk(LINK)
+struct LOC_iffint *LINK;
+{
+ if (LINK->bmsize > P_maxpos(bitmap)) {
+ printf("File endend while reading junk\n");
+ _Escape(0);
+ }
+ while (LINK->bmsize > 0) {
+ fread(&LINK->b, 1, 1, bitmap);
+ LINK->bmsize--;
+ }
+/* p2c: bm2font.pas, line 509:
+ * Note: Can't interpret size in BLOCKREAD [174] */
+} /*:44*/
+
+/*45:*/
+Local Void checkchunk(LINK)
+struct LOC_iffint *LINK;
+{
+ short i, j, FORLIM;
+
+ if (!strcmp(LINK->bmstr, "BMHD")) {
+ LINK->bmsize = ifflong(LINK);
+ if (LINK->bmsize & 1)
+ LINK->bmsize++;
+ LINK->hh = iffword(LINK);
+ LINK->vh = iffword(LINK);
+ LINK->hi = iffword(LINK);
+ LINK->vi = iffword(LINK);
+/* p2c: bm2font.pas, line 513:
+ * Note: Can't interpret size in BLOCKREAD [174] */
+ fread(&LINK->bps, 1, 1, bitmap);
+/* p2c: bm2font.pas, line 513:
+ * Note: Can't interpret size in BLOCKREAD [174] */
+ fread(&LINK->b, 1, 1, bitmap);
+/* p2c: bm2font.pas, line 514:
+ * Note: Can't interpret size in BLOCKREAD [174] */
+ fread(&LINK->b, 1, 1, bitmap);
+ LINK->compr = LINK->b;
+ for (i = 1; i <= 4; i++)
+ fread(&xratio, 1, 1, bitmap);
+/* p2c: bm2font.pas, line 515:
+ * Note: Can't interpret size in BLOCKREAD [174] */
+/* p2c: bm2font.pas, line 515:
+ * Note: Can't interpret size in BLOCKREAD [174] */
+ fread(&yratio, 1, 1, bitmap);
+ LINK->bmsize -= 16;
+ junkchunk(LINK);
+ if (LINK->bps == 1) {
+ LINK->col = 1;
+ return;
+ }
+ if (LINK->bps == 4)
+ LINK->col = 15;
+ else
+ LINK->col = 255;
+ return;
+ }
+ if (!strcmp(LINK->bmstr, "CMAP")) {
+ LINK->bmsize = ifflong(LINK);
+ LINK->col = LINK->bmsize / 3 - 1;
+ FORLIM = LINK->col;
+ for (i = 0; i <= FORLIM; i++) {
+ for (j = 0; j <= 2; j++) {
+ fread(&LINK->b, 1, 1, bitmap);
+ LINK->gpal[i][j] = LINK->b;
+ }
+/* p2c: bm2font.pas, line 519:
+ * Note: Can't interpret size in BLOCKREAD [174] */
+ if (cmyk) {
+ colcyan = 255 - LINK->gpal[i][0];
+ colmagenta = 255 - LINK->gpal[i][1];
+ colyellow = 255 - LINK->gpal[i][2];
+ if (colcyan != colmagenta || colcyan != colyellow ||
+ colmagenta != colyellow) {
+ colcyan -= colmagenta / 3;
+ if (colcyan < 0)
+ colcyan = 0;
+ colmagenta -= colyellow / 3;
+ if (colmagenta < 0)
+ colmagenta = 0;
+ }
+ colblack = colcyan;
+ if (colblack > colmagenta)
+ colblack = colmagenta;
+ if (colblack > colyellow)
+ colblack = colyellow;
+ if (cyan)
+ LINK->hell[i] = 255 - colcyan;
+ if (magenta)
+ LINK->hell[i] = 255 - colmagenta;
+ if (yellow)
+ LINK->hell[i] = 255 - colyellow;
+ if (black)
+ LINK->hell[i] = 255 - colblack;
+ } else
+ LINK->hell[i] = (long)floor(LINK->gpal[i][0] * 0.287 + LINK->gpal[i]
+ [1] * 0.589 + LINK->gpal[i][2] * 0.114 + 0.5);
+ LINK->hell[i] = (long)(LINK->hell[i] / (256.0 / (LINK->col + 1)));
+ bhell[LINK->hell[i]] = (long)(255 - colblack / (256.0 / (LINK->col + 1)));
+ }
+ if (LINK->bmsize & 1)
+ fread(&LINK->b, 1, 1, bitmap);
+/* p2c: bm2font.pas, line 534:
+ * Note: Can't interpret size in BLOCKREAD [174] */
+ return;
+ }
+ if (!strcmp(LINK->bmstr, "CRNG")) {
+ LINK->bmsize = ifflong(LINK);
+ LINK->bmoff = iffword(LINK);
+ LINK->bmoff = iffword(LINK);
+ LINK->bmoff = iffword(LINK);
+/* p2c: bm2font.pas, line 536:
+ * Note: Can't interpret size in BLOCKREAD [174] */
+ fread(&LINK->b, 1, 1, bitmap);
+/* p2c: bm2font.pas, line 537:
+ * Note: Can't interpret size in BLOCKREAD [174] */
+ fread(&LINK->a, 1, 1, bitmap);
+ if (LINK->bmsize & 1)
+ fread(&LINK->b, 1, 1, bitmap);
+/* p2c: bm2font.pas, line 537:
+ * Note: Can't interpret size in BLOCKREAD [174] */
+ return;
+ }
+ LINK->bmsize = ifflong(LINK);
+ if (LINK->bmsize & 1)
+ LINK->bmsize++;
+ junkchunk(LINK);
+}
+
+
+/*:36*/
+/*41:*/
+Static Void iffint()
+{ /*:45*/
+ struct LOC_iffint V;
+ unsigned short ohh;
+ uchar cb;
+ short FORLIM, FORLIM1;
+
+ /*46:*/
+ printf("Analysing IFF file %s\n", bmname);
+ opentempfile();
+ fread(V.bmstr, 4, 1, bitmap);
+ V.bmstr[4] = '\0';
+ if (strcmp(V.bmstr, "FORM")) {
+ printf("Graphic file not stored as Interchange File Format\n");
+ _Escape(0);
+ }
+ V.bmsize = ifflong(&V) + 8;
+ if (V.bmsize != P_maxpos(bitmap)) {
+ printf("File is incomplete, should contain %ld\n", V.bmsize);
+ _Escape(0);
+ }
+ fread(V.bmstr, 4, 1, bitmap);
+ V.bmstr[4] = '\0';
+ if (strcmp(V.bmstr, "ILBM"))
+ printf("Type of file is %s, should be ILBM\n", V.bmstr);
+ fread(V.bmstr, 4, 1, bitmap);
+ V.bmstr[4] = '\0';
+ while (strcmp(V.bmstr, "BODY")) {
+ if (P_eof(bitmap)) {
+ printf("No graphics information available\n");
+ _Escape(0);
+ }
+ checkchunk(&V);
+ fread(V.bmstr, 4, 1, bitmap);
+ V.bmstr[4] = '\0';
+ }
+ V.bmsize = ifflong(&V);
+ V.hh = (V.hh * V.bps + 7) / 8;
+ ohh = V.hh;
+ if (ohh & 1)
+ ohh++;
+ FORLIM = V.vh;
+ for (i = 1; i <= FORLIM; i++) {
+ if (P_eof(bitmap)) {
+ printf("ende\n");
+ _Escape(0);
+ }
+ if (V.compr == 0)
+ fread(b3, ohh, 1, bitmap);
+ else { /*47:*/
+ gbufp = 0;
+ while (gbufp < ohh) {
+ fread(&V.b, 1, 1, bitmap);
+ V.bmoff++;
+ if (V.b < 128) {
+ V.b++;
+/* p2c: bm2font.pas, line 555:
+ * Note: Can't interpret size in BLOCKREAD [174] */
+ fread(&b3[gbufp], V.b, 1, bitmap);
+ gbufp += V.b;
+ continue;
+ }
+ if (V.b <= 128)
+ continue;
+/* p2c: bm2font.pas, line 556:
+ * Note: Can't interpret size in BLOCKREAD [174] */
+ fread(&V.a, 1, 1, bitmap);
+ V.b = 257 - V.b;
+ while (V.b > 0) {
+ b3[gbufp] = V.a;
+ gbufp++;
+ V.b--;
+ }
+ }
+/* p2c: bm2font.pas, line 554:
+ * Note: Can't interpret size in BLOCKREAD [174] */
+ } /*:47*/
+/* p2c: bm2font.pas, line 553:
+ * Note: Can't interpret size in BLOCKREAD [174] */
+ if (V.bps == 4) { /*48:*/
+ gi = 0;
+ FORLIM1 = V.hh;
+ for (gbufpp = 0; gbufpp < FORLIM1; gbufpp++)
+ b2[gbufpp] = 0;
+ V.a = 0;
+ FORLIM1 = V.hh;
+ for (gbufpp = 0; gbufpp < FORLIM1; gbufpp++) {
+ V.b = b3[gbufpp];
+ for (j = 0; j <= 3; j++) {
+ cb = V.b & 128;
+ cb >>= 3 - V.a;
+ b2[gi] ^= cb;
+ V.b <<= 1;
+ cb = V.b & 128;
+ cb >>= 7 - V.a;
+ b2[gi] ^= cb;
+ V.b <<= 1;
+ gi++;
+ }
+ if (gi >= V.hh) {
+ gi = 0;
+ V.a++;
+ }
+ }
+ FORLIM1 = V.hh;
+ for (gbufpp = 0; gbufpp < FORLIM1; gbufpp++)
+ b3[gbufpp] = b2[gbufpp];
+ gi = 0;
+ FORLIM1 = V.hh;
+ for (gbufpp = 0; gbufpp < FORLIM1; gbufpp++) {
+ b2[gi] = (V.hell[b3[gbufpp] >> 4] << 4) + V.hell[b3[gbufpp] & 15];
+ gi++;
+ } /*:48*/
+ } else if (V.bps == 8) {
+ FORLIM1 = V.hh;
+ for (gbufp = 0; gbufp < FORLIM1; gbufp++)
+ b2[gbufp] = V.hell[b3[gbufp]];
+ } else {
+ FORLIM1 = V.hh;
+ for (gbufp = 0; gbufp < FORLIM1; gbufp++)
+ b2[gbufp] = b3[gbufp];
+ }
+/* p2c: bm2font.pas, line 568:
+ * Note: Can't interpret size in BLOCKWRITE [174] */
+ _SETIO(fwrite(b2, V.hh, 1, tmpfil) == 1, FileWriteError);
+ filestat = P_ioresult;
+ if (filestat != 0) {
+ _SETIO(printf("Error occured when writing file %s!\n", tmpname) >= 0,
+ FileWriteError);
+ fileproblem();
+ _Escape(0);
+ }
+ }
+ if (bitmap != NULL)
+ fclose(bitmap);
+ bitmap = NULL;
+ if (tmpfil != NULL)
+ fclose(tmpfil);
+ tmpfil = NULL;
+ mapinlen = V.hh;
+ bitspsam = V.bps;
+ posbit = 0;
+ strcpy(bitmap_NAME, "pcxtemp.tmp");
+ if (bitmap != NULL)
+ bitmap = freopen(bitmap_NAME, "rb", bitmap);
+ else
+ bitmap = fopen(bitmap_NAME, "rb");
+ if (bitmap == NULL)
+ _EscIO(FileNotFound);
+ pcxtemp = true;
+ if (egastretch) {
+ if (xratio + 1 == yratio)
+ picstretch();
+ }
+ posbit = 0;
+ if (bitspsam > 1)
+ greypxl = true;
+ mapdiv = 1.0;
+ FORLIM = bitspsam;
+ for (i = 1; i <= FORLIM; i++)
+ mapdiv *= 2;
+ mapdiv /= 16;
+} /*:46*/
+
+
+/*49:*/
+Static Void bmpint()
+{
+ unsigned short i, k, hi, hh, hhl, vi, vh, compr, lcol;
+ uchar j, b, a, col, bps;
+ uchar gpal[256][4];
+ unsigned short hell[256];
+ Char bmstr[256];
+ long bmsize, bmoff;
+ unsigned short FORLIM;
+
+ printf("Analysing BMP file %s\n", bmname);
+ opentempfile();
+ fread(bmstr, 2, 1, bitmap);
+ bmstr[2] = '\0';
+ if (strcmp(bmstr, "BM")) {
+ printf("No windows bitmap %s\n", bmstr);
+ _Escape(0);
+ }
+ gbufp = 640;
+ pxlinlen = 640;
+ bmsize = longpcx();
+ for (i = 1; i <= 4; i++)
+ b = getpcx();
+ bmoff = longpcx();
+ bmsize = longpcx();
+ bmoff -= bmsize;
+ if (bmsize > 12) {
+ hi = longpcx();
+ vi = longpcx();
+ b = getpcx();
+ b = getpcx();
+ bps = wordpcx();
+ if (bps > 8) {
+ printf("only up to 256 colors supported\n");
+ _Escape(0);
+ }
+ hh = hi;
+ vh = vi;
+ compr = longpcx();
+ for (i = 1; i <= 4; i++)
+ b = getpcx();
+ xratio = longpcx();
+ yratio = longpcx();
+ lcol = longpcx();
+ lcol--;
+ if (col == 0) {
+ if (bps == 1)
+ col = 1;
+ else if (bps == 4)
+ col = 15;
+ else
+ col = 255;
+ }
+ col = longpcx();
+ col--;
+ } else {
+ hi = wordpcx();
+ vi = wordpcx();
+ b = getpcx();
+ b = getpcx();
+ bps = wordpcx();
+ if (bps > 8) {
+ printf("only up to 256 colors supported\n");
+ _Escape(0);
+ }
+ hh = hi;
+ vh = vi;
+ compr = 0;
+ xratio = 1;
+ yratio = 1;
+ col = 0;
+ }
+ if (lcol == 0) {
+ if (bps == 1)
+ col = 1;
+ else if (bps == 4)
+ col = 15;
+ else
+ col = 255;
+ }
+ if (bps == 1)
+ col = 1;
+ else if (bps == 4)
+ col = 15;
+ else
+ col = 255;
+ for (i = 0; i <= col; i++) {
+ if (bmsize > 12) {
+ for (j = 0; j <= 3; j++)
+ gpal[i][j] = getpcx();
+ } else {
+ for (j = 0; j <= 2; j++)
+ gpal[i][j] = getpcx();
+ }
+ if (cmyk) {
+ colcyan = 255 - gpal[i][2];
+ colmagenta = 255 - gpal[i][1];
+ colyellow = 255 - gpal[i][0];
+ if (colcyan != colmagenta || colcyan != colyellow ||
+ colmagenta != colyellow) {
+ colcyan -= colmagenta / 3;
+ if (colcyan < 0)
+ colcyan = 0;
+ colmagenta -= colyellow / 3;
+ if (colmagenta < 0)
+ colmagenta = 0;
+ }
+ colblack = colcyan;
+ if (colblack > colmagenta)
+ colblack = colmagenta;
+ if (colblack > colyellow)
+ colblack = colyellow;
+ if (cyan)
+ hell[i] = 255 - colcyan;
+ if (magenta)
+ hell[i] = 255 - colmagenta;
+ if (yellow)
+ hell[i] = 255 - colyellow;
+ if (black)
+ hell[i] = 255 - colblack;
+ hell[i] = (long)(hell[i] / (256.0 / (col + 1)));
+ bhell[hell[i]] = (long)((255 - colblack) / (256.0 / (col + 1)));
+ } else
+ hell[i] = (long)((gpal[i][2] * 0.287 + gpal[i][1] * 0.589 + gpal[i]
+ [0] * 0.114) / (256.0 / (col + 1)));
+ }
+ if (bmsize > 12)
+ bmoff -= (col + 1) * 4;
+ else
+ bmoff -= (col + 1) * 3;
+ if (compr != 0) {
+ printf("compression not supported yet\n");
+ _Escape(0);
+ }
+ hh = (hh * bps + 7) / 8;
+ hhl = (hh + 3) / 4 * 4 - 1;
+ a = 8 - ((hi * bps) & 7);
+/* p2c: bm2font.pas, line 616:
+ * Note: Suspicious mixture of sizes in FILLCHAR [173] */
+ memset((Anyptr)b3, 0, hhl + 1L);
+ for (i = 1; i <= vh; i++) { /*$I-*/
+ _SETIO(fwrite(b3, hh, 1, tmpfil) == 1, FileWriteError);
+ filestat = P_ioresult;
+ if (filestat != 0) {
+ _SETIO(printf("Error occured when writing file %s!\n", tmpname) >= 0,
+ FileWriteError);
+ fileproblem();
+ _Escape(0);
+ }
+ }
+/* p2c: bm2font.pas, line 617:
+ * Note: Can't interpret size in BLOCKWRITE [174] */
+ if (tmpfil != NULL)
+ fclose(tmpfil);
+ tmpfil = NULL;
+ if (tmpfil != NULL)
+ tmpfil = freopen(tmpfil_NAME, "w+b", tmpfil);
+ else
+ tmpfil = fopen(tmpfil_NAME, "w+b");
+ if (tmpfil == NULL)
+ _EscIO(FileNotFound);
+ bmoff = (vh - 1) * (long)hh;
+ for (i = 0; i < vh; i++) {
+ for (k = 0; k <= hhl; k++)
+ b3[k] = getpcx();
+ if (bps == 4) {
+ gi = 0;
+ for (k = 0; k < hh; k++) {
+ b2[gi] = (hell[b3[k] >> 4] << 4) + hell[b3[k] & 15];
+ gi++;
+ }
+ } else if (bps == 8) {
+ for (k = 0; k < hh; k++)
+ b2[k] = hell[b3[k]];
+ } else {
+ for (k = 0; k < hh; k++)
+ b2[k] = b3[k];
+ }
+ if (a < 8) {
+ for (k = 0; k < a; k++)
+ b2[hh - 1] ^= invbit >> k;
+ }
+ fseek(tmpfil, bmoff, 0);
+ bmoff = bmoff - (long)hh;
+/* p2c: bm2font.pas, line 629:
+ * Note: Can't interpret size in BLOCKWRITE [174] */
+ _SETIO(fwrite(b2, hh, 1, tmpfil) == 1, FileWriteError);
+ filestat = P_ioresult;
+ if (filestat != 0) {
+ _SETIO(printf("Error occured when writing file %s!\n", tmpname) >= 0,
+ FileWriteError);
+ fileproblem();
+ _Escape(0);
+ }
+ }
+ if (bitmap != NULL)
+ fclose(bitmap);
+ bitmap = NULL;
+ if (tmpfil != NULL)
+ fclose(tmpfil);
+ tmpfil = NULL;
+ mapinlen = hh;
+ posbit = 0;
+ strcpy(bitmap_NAME, "pcxtemp.tmp");
+ if (bitmap != NULL)
+ bitmap = freopen(bitmap_NAME, "rb", bitmap);
+ else
+ bitmap = fopen(bitmap_NAME, "rb");
+ if (bitmap == NULL)
+ _EscIO(FileNotFound);
+ pcxtemp = true;
+ bitspsam = bps;
+ if (bitspsam > 1)
+ greypxl = true;
+ mapdiv = 1.0;
+ FORLIM = bitspsam;
+ for (i = 1; i <= FORLIM; i++)
+ mapdiv *= 2;
+ mapdiv /= 16;
+}
+
+
+/*50:*/
+Static Void imgint()
+{
+ unsigned short i, ki, hi, hh, bzf, imgpat;
+ short vh;
+ uchar mi, cb, j, b, a, col, bps;
+ unsigned short hell[16];
+ uchar linerep;
+ unsigned short FORLIM;
+
+ printf("Analysing IMG file %s\n", bmname);
+ invert = !invert;
+ if (invert) { /*51:*/
+ invbit = 0;
+ invbyte = 0;
+ } else {
+ invbit = 1;
+ invbyte = 255;
+ }
+ hell[0] = 0;
+ hell[1] = 1;
+ hell[2] = 6;
+ hell[3] = 8;
+ hell[4] = 3;
+ hell[5] = 2;
+ hell[6] = 7;
+ hell[7] = 11;
+ hell[8] = 4;
+ hell[9] = 5;
+ hell[10] = 12;
+ hell[11] = 13;
+ hell[12] = 10;
+ hell[13] = 9;
+ hell[14] = 14;
+ hell[15] = 15;
+ opentempfile(); /*:51*/
+ gbufp = 640;
+ pxlinlen = 640;
+ a = getpcx();
+ b = getpcx();
+ if (a * 256 + b != 1) { /*52:*/
+ printf("File does not contain GEM Image File Format\n");
+ _Escape(0);
+ }
+ b = getpcx();
+ bzf = b * 256;
+ b = getpcx();
+ bzf += b;
+ b = getpcx();
+ bps = b * 256;
+ b = getpcx();
+ bps += b;
+ b = getpcx();
+ imgpat = b * 256;
+ b = getpcx();
+ imgpat += b;
+ b = getpcx();
+ xratio = b * 256;
+ b = getpcx();
+ xratio += b;
+ b = getpcx();
+ yratio = b * 256;
+ b = getpcx();
+ yratio += b;
+ if (xratio != yratio) {
+ mapdiv = (double)yratio / xratio;
+ xratio = 0;
+ yratio = 0;
+ while (xratio == yratio) {
+ xratio++;
+ yratio = (long)floor(xratio * mapdiv + 0.5);
+ }
+ }
+ b = getpcx();
+ hi = b * 256;
+ b = getpcx();
+ hi += b;
+ b = getpcx();
+ vh = b * 256;
+ b = getpcx();
+ vh += b; /*:52*/
+ hh = (hi * bps + 7) / 8;
+ if (bzf > 8) {
+ for (i = 1; i <= (bzf - 8) * 2; i++)
+ b = getpcx();
+ }
+ linerep = 0;
+ gi = 0;
+ while (vh > 0) {
+ for (gi = 0; gi <= hh; gi++)
+ b3[gi] = 0;
+ gi = 0;
+ while (gi < hh) {
+ b = getpcx();
+ if (b != 0 && b != 128) {
+ a = b & 127;
+ cb = ((unsigned)(b - a)) >> 7;
+ if (cb == 1)
+ cb = 255;
+ for (ki = 1; ki <= a; ki++) {
+ b3[gi] = cb;
+ gi++;
+ }
+ continue;
+ }
+ if (b == 128) {
+ a = getpcx();
+ for (ki = 1; ki <= a; ki++) {
+ b3[gi] = getpcx();
+ gi++;
+ }
+ continue;
+ }
+ a = getpcx();
+ if (a <= 0) {
+ b = getpcx();
+ linerep = getpcx();
+ continue;
+ }
+ for (ki = 1; ki <= imgpat; ki++)
+ b2[ki] = getpcx();
+ for (ki = 1; ki <= a; ki++) {
+ for (mi = 1; mi <= imgpat; mi++) {
+ b = b2[mi];
+ b3[gi] = b;
+ gi++;
+ }
+ }
+ }
+ if (bps == 4) { /*48:*/
+ gi = 0;
+ for (gbufpp = 0; gbufpp < hh; gbufpp++)
+ b2[gbufpp] = 0;
+ a = 0;
+ for (gbufpp = 0; gbufpp < hh; gbufpp++) {
+ b = b3[gbufpp];
+ for (j = 0; j <= 3; j++) {
+ cb = b & 128;
+ cb >>= 3 - a;
+ b2[gi] ^= cb;
+ b <<= 1;
+ cb = b & 128;
+ cb >>= 7 - a;
+ b2[gi] ^= cb;
+ b <<= 1;
+ gi++;
+ }
+ if (gi >= hh) {
+ gi = 0;
+ a++;
+ }
+ }
+ for (gbufpp = 0; gbufpp < hh; gbufpp++)
+ b3[gbufpp] = b2[gbufpp];
+ gi = 0;
+ for (gbufpp = 0; gbufpp < hh; gbufpp++) {
+ b2[gi] = (hell[b3[gbufpp] >> 4] << 4) + hell[b3[gbufpp] & 15];
+ gi++;
+ } /*:48*/
+ } else {
+ for (ki = 0; ki < hh; ki++)
+ b2[ki] = b3[ki];
+ }
+/* p2c: bm2font.pas, line 674:
+ * Note: Can't interpret size in BLOCKWRITE [174] */
+ _SETIO(fwrite(b2, hh, 1, tmpfil) == 1, FileWriteError);
+ filestat = P_ioresult;
+ if (filestat != 0) {
+ _SETIO(printf("Error occured when writing file %s!\n", tmpname) >= 0,
+ FileWriteError);
+ fileproblem();
+ _Escape(0);
+ }
+ vh--;
+ if (linerep <= 0)
+ continue;
+ for (i = 1; i <= linerep; i++) { /*$I-*/
+ _SETIO(fwrite(b2, hh, 1, tmpfil) == 1, FileWriteError);
+ filestat = P_ioresult;
+ if (filestat != 0) {
+ _SETIO(printf("Error occured when writing file %s!\n", tmpname) >= 0,
+ FileWriteError);
+ fileproblem();
+ _Escape(0);
+ }
+ }
+/* p2c: bm2font.pas, line 678:
+ * Note: Can't interpret size in BLOCKWRITE [174] */
+ vh += 1 - linerep;
+ linerep = 0;
+ }
+ if (bitmap != NULL)
+ fclose(bitmap);
+ bitmap = NULL;
+ if (tmpfil != NULL)
+ fclose(tmpfil);
+ tmpfil = NULL;
+ if (col == 4) {
+ bitspsam = 4;
+ greypxl = true;
+ } else if (bps > 1) {
+ bitspsam = bps;
+ greypxl = true;
+ }
+ mapinlen = hh;
+ posbit = 0;
+ strcpy(bitmap_NAME, "pcxtemp.tmp");
+ if (bitmap != NULL)
+ bitmap = freopen(bitmap_NAME, "rb", bitmap);
+ else
+ bitmap = fopen(bitmap_NAME, "rb");
+ if (bitmap == NULL)
+ _EscIO(FileNotFound);
+ if (egastretch) {
+ if (xratio + 1 == yratio)
+ picstretch();
+ }
+ posbit = 0;
+ pcxtemp = true;
+ mapdiv = 1.0;
+ FORLIM = bitspsam;
+ for (i = 1; i <= FORLIM; i++)
+ mapdiv *= 2;
+ mapdiv /= 16;
+}
+
+
+/*54:*/
+Static Void tfmhword(hword)
+long hword;
+{
+ union {
+ uchar b[4];
+ long i;
+ } ax;
+ short i;
+
+ ax.i = hword;
+#ifdef INTEL
+ for (i = 1; i >= 0; i--)
+ fwrite(&ax.b[i], sizeof(uchar), 1, tfmfile);
+#else
+ for (i = 2; i <= 3; i++)
+ fwrite(&ax.b[i], sizeof(uchar), 1, tfmfile);
+#endif
+}
+
+
+Static Void tfmword(lword)
+long lword;
+{
+ union {
+ uchar b[4];
+ long i;
+ } ax;
+ short i;
+
+ ax.i = lword;
+#ifdef INTEL
+ for (i = 3; i >= 0; i--)
+ fwrite(&ax.b[i], sizeof(uchar), 1, tfmfile);
+#else
+ for (i = 0; i <= 3; i++)
+ fwrite(&ax.b[i], sizeof(uchar), 1, tfmfile);
+#endif
+}
+
+
+/*:54*/
+/*57:*/
+Static Void pxlmap(lword)
+long lword;
+{
+ union {
+ ebts b[4];
+ long i;
+ } ax;
+ uchar i;
+
+ ax.i = lword;
+ for (i = 0; i <= 3; i++) {
+ pxlbm[pxlbmi] = ax.b[i];
+ pxlbmi++;
+ }
+} /*:57*/
+
+
+/*61:*/
+Static Void pkbyte(b)
+uchar b;
+{
+ pkbm[pkloc] = b;
+ pkloc++;
+}
+
+
+Static Void pkhalfword(a)
+short a;
+{
+ union {
+ ebts b[2];
+ short w;
+ } ax;
+
+ ax.w = a;
+#ifdef INTEL
+ pkbyte(ax.b[1]);
+ pkbyte(ax.b[0]);
+#else
+ pkbyte(ax.b[0]);
+ pkbyte(ax.b[1]);
+#endif
+}
+
+
+Static Void pkthreebytes(a)
+long a;
+{
+ union {
+ ebts b[4];
+ long i;
+ } ax;
+
+ ax.i = a;
+#ifdef INTEL
+ pkbyte(ax.b[2]);
+ pkbyte(ax.b[1]);
+ pkbyte(ax.b[0]);
+#else
+ pkbyte(ax.b[1]);
+ pkbyte(ax.b[2]);
+ pkbyte(ax.b[3]);
+#endif
+}
+
+
+Static Void pkword(a)
+long a;
+{
+ union {
+ ebts b[4];
+ long i;
+ } ax;
+
+ ax.i = a;
+#ifdef INTEL
+ pkbyte(ax.b[3]);
+ pkbyte(ax.b[2]);
+ pkbyte(ax.b[1]);
+ pkbyte(ax.b[0]);
+#else
+ pkbyte(ax.b[0]);
+ pkbyte(ax.b[1]);
+ pkbyte(ax.b[2]);
+ pkbyte(ax.b[3]);
+#endif
+}
+
+
+Static Void pknyb(a)
+uchar a;
+{
+ if (bitweight == 16) {
+ outputbyte = a << 4;
+ bitweight = 1;
+ } else {
+ pkbyte(outputbyte + a);
+ bitweight = 16;
+ }
+}
+
+
+/*:61*/
+/*63:*/
+Static Void writepreambl()
+{
+ short i;
+ Char nstr[256];
+
+ sprintf(nstr, "%ld", (long)floor(truehres + 0.5));
+#ifdef MSDOS
+ sprintf(cmd, "%s%c.pk", font, fontpre[nf]);
+#else
+ sprintf(cmd, "%s%c.%spk", font, fontpre[nf], nstr);
+#endif
+ strcpy(pxlfile_NAME, cmd);
+ if (pxlfile != NULL)
+ pxlfile = freopen(pxlfile_NAME, "w+b", pxlfile);
+ else
+ pxlfile = fopen(pxlfile_NAME, "w+b");
+ _SETIO(pxlfile != NULL, FileNotFound);
+ filestat = P_ioresult;
+ if (filestat == 3 || filestat == 5) {
+ strcpy(cmd, bmname);
+ sprintf(cmd + strlen(cmd), "%c.pk", fontupc[nf]);
+ strcpy(pxlfile_NAME, cmd);
+ if (pxlfile != NULL)
+ pxlfile = freopen(pxlfile_NAME, "w+b", pxlfile);
+ else
+ pxlfile = fopen(pxlfile_NAME, "w+b");
+ _SETIO(pxlfile != NULL, FileNotFound);
+ filestat = P_ioresult;
+ }
+ if (filestat == 0)
+ fok = false;
+ else
+ fok = true;
+ if (fok) {
+ printf("error occurred when ");
+ printf("allocating pkfile ");
+ puts(cmd);
+ fileproblem();
+ _Escape(0);
+ }
+ pkloc = 0;
+ pkbyte(247);
+ pkbyte(89);
+ pkbyte(14);
+ strcpy(comment, "BM2FONT output");
+ for (i = 0; i <= 13; i++)
+ pkbyte(comment[i]);
+ pkword(tabdsize[nf]);
+ pkword(checksum);
+ pkword(floor(truehres * 65536L / 72.27 + 0.5));
+ pkword(floor(truevres * 65536L / 72.27 + 0.5));
+ nextmemfree = 0;
+ printf("Packing font %s\n", cmd);
+}
+
+
+/*:63*/
+/*65:*/
+Static Void writepostamb()
+{
+ pkbyte(245);
+ while ((pkloc & 3) != 0)
+ pkbyte(246);
+/* p2c: bm2font.pas, line 781:
+ * Note: Can't interpret size in BLOCKWRITE [174] */
+ _SETIO(fwrite(pkbm, pkloc, 1, pxlfile) == 1, FileWriteError);
+ filestat = P_ioresult;
+ if (filestat != 0) {
+ _SETIO(printf("Error occured when writing font %s!\n", cmd) >= 0,
+ FileWriteError);
+ fileproblem();
+ _Escape(0);
+ }
+ if (pxlfile != NULL)
+ fclose(pxlfile);
+ pxlfile = NULL;
+ printf(" \n");
+ printf("Font %s at %ld dots per inch written\n",
+ cmd, (long)floor(truehres + 0.5));
+ nf++;
+ if (nf > 25) {
+ printf("More then 26 fonts! Giving up\n");
+ _Escape(0);
+ }
+ charpf[nf] = ng;
+ ng = 0;
+ pkloc = 0;
+}
+
+
+/*:65*/
+/*67:*/
+Static boolean equal(row1, row2)
+pxlstr row1, row2;
+{
+ short i;
+ boolean temp;
+
+ i = pkwidth;
+ temp = true;
+ while (i > 0 && temp) {
+ if (pxlbm[row1] != pxlbm[row2])
+ temp = false;
+ row1++;
+ row2++;
+ i -= 8;
+ }
+ return temp;
+}
+
+
+/*:67*/
+/*68:*/
+Static boolean equalzo(row1, row2)
+pxlstr row1;
+short row2;
+{
+ short i;
+ boolean temp;
+
+ i = pkwidth;
+ temp = true;
+ while (i > 0 && temp) {
+ if (pxlbm[row1] != (repbm[row2] & 255))
+ temp = false;
+ row1++;
+ row2++;
+ i -= 8;
+ }
+ return temp;
+}
+
+
+/*:68*/
+/*70:*/
+Static Void shipcharacte()
+{ /*:87*/
+ pxlstr crst;
+ short wwid;
+ long compsize;
+ long horesc;
+ /*72:*/
+ short l;
+ long i, j, k;
+ short rowzero, onesrow, repptr, bitcounts;
+ ebts fillbytes, longind, mixbyte, restbyte, pkshift, dshift;
+ long longtab[20];
+ /*:72*/
+ /*77:*/
+ long count;
+ short test, curptr, bit, repflag;
+ schar pkkword;
+ short bitptr, bitmod32, currepeat;
+ pxlstr endraster; /*:77*/
+ /*80:*/
+ short dynf;
+ long deriv[13];
+ long bcompsize;
+ boolean firston;
+ short flagbyte;
+ /*:80*/
+ /*87:*/
+ unsigned short max2;
+ pxlstr predpkloc;
+ short bytelength;
+
+ horesc = pwidth[f][car];
+ pkwidth = pwidth[f][car];
+ pkheight = pheight[f][car];
+ pkheight -= yoffset[f][car];
+ cxoff = 0;
+ cyoff = pkheight;
+ crst = pkpoint[car];
+ wwid = (pkwidth + 31) / 32 * 4;
+ fillbytes = wwid - (pkwidth + 7) / 8; /*71:*/
+ rowzero = nextmemfree;
+ onesrow = nextmemfree + wwid;
+ repptr = onesrow + wwid;
+ bitcounts = repptr + pkheight + 1;
+ for (i = rowzero; i < onesrow; i++)
+ repbm[i] = 0;
+ for (i = onesrow; i <= repptr - 2; i++)
+ repbm[i] = -1;
+ j = onesrow + (((unsigned long)(pkwidth + 7)) >> 3);
+ repbm[j - 1] = power[8] - power[7 - ((pkwidth + 7) & 7)];
+ for (i = j; i < repptr; i++)
+ repbm[i] = 0;
+ i = 0;
+ j = pkheight;
+ while (i < j) {
+ if (equalzo((i * wwid + crst), rowzero))
+ repbm[repptr + i] = 0;
+ else if (equalzo((i * wwid + crst), onesrow))
+ repbm[repptr + i] = 0;
+ else if (i + 1 == j)
+ repbm[repptr + i] = 0;
+ else if (equal((i * wwid + crst), (int)((i + 1) * wwid + crst)))
+ repbm[repptr + i] = 1;
+ else
+ repbm[repptr + i] = 0;
+ i++;
+ }
+ i = 0;
+ while (i < j) {
+ k = i;
+ while (repbm[repptr + k] == 1)
+ k++;
+ repbm[repptr + i] = k - i;
+ i = k + 1;
+ }
+ repbm[repptr + i] = 0; /*:71*/
+ /*75:*/
+ repflag = 0;
+ bitptr = pkwidth - 1;
+ currepeat = repptr;
+ endraster = crst + pkheight * wwid;
+ curptr = bitcounts;
+ count = 0;
+ longind = 0;
+ test = 0;
+ do { /*76:*/
+ bitptr++;
+ if (bitptr == pkwidth) {
+ bitmod32 = 0;
+ bitptr = 0;
+ if (currepeat > repptr)
+ crst += fillbytes;
+ if (repbm[currepeat] > 0) {
+ repflag = repbm[currepeat];
+ currepeat += repflag;
+ crst += wwid * repflag;
+ }
+ currepeat++;
+ }
+ bitmod32--;
+ if (bitmod32 == -1) {
+ bitmod32 = 7;
+ pkkword = pxlbm[crst];
+ crst++;
+ }
+ if (crst > endraster)
+ bit = 2;
+ else if (pkkword < 0)
+ bit = 1;
+ else
+ bit = 0;
+ pkkword <<= 1; /*:76*/
+ if (bit == test)
+ count++;
+ else {
+ if (count > 32767) {
+ longind++;
+ longtab[longind - 1] = count;
+ count = -longind - 10000;
+ }
+ repbm[curptr] = count;
+ curptr++;
+ if (curptr + 1 > maxmemsize)
+ test = 3;
+ else {
+ count = 1;
+ test = bit;
+ if (repflag > 0) {
+ repbm[curptr] = -repflag;
+ repflag = 0;
+ curptr++;
+ }
+ }
+ }
+ } while (test < 2);
+ repbm[curptr] = 0;
+ repbm[curptr + 1] = 0; /*:75*/
+ /*78:*/
+ if (test < 3) {
+ for (i = 0; i <= 12; i++)
+ deriv[i] = 0;
+ firston = (repbm[bitcounts] == 0);
+ if (firston)
+ bitcounts++;
+ i = bitcounts;
+ compsize = 0;
+ while (repbm[i] != 0) { /*79:*/
+ j = repbm[i];
+ if (j < -10000)
+ j = longtab[-j - 10001];
+ if (j == -1)
+ compsize++;
+ else {
+ if (j < 0) {
+ compsize++;
+ j = -j;
+ }
+ if (j < 209)
+ compsize += 2;
+ else {
+ k = j - 193;
+ while (k >= 16) {
+ k = ((unsigned long)k) >> 4;
+ compsize += 2;
+ }
+ compsize++;
+ }
+ if (j < 14)
+ deriv[j - 1]--;
+ else if (j < 209)
+ deriv[(223 - j) / 15 - 1]++;
+ else {
+ k = 16;
+ while (k <= ((unsigned long)(j + 2)) >> 4) {
+ k <<= 4;
+ if (k == 0) {
+ k = 32767;
+ j += 32767;
+ }
+ }
+ if (j - k <= 192)
+ deriv[(k - j + 207) / 15 - 1] += 2;
+ }
+ }
+ i++;
+ }
+ /*:79*/
+ bcompsize = compsize;
+ dynf = 0;
+ for (i = 1; i <= 13; i++) {
+ compsize += deriv[i - 1];
+ if (compsize <= bcompsize) {
+ bcompsize = compsize;
+ dynf = i;
+ }
+ }
+ compsize = (bcompsize + 1) / 2;
+ if (compsize > (pkheight * pkwidth + 7) / 8 || pkheight * pkwidth == 0) {
+ compsize = (pkheight * pkwidth + 7) / 8;
+ dynf = 14;
+ }
+ } else {
+ dynf = 14;
+ firston = (repbm[bitcounts] == 0);
+ compsize = (pkheight * pkwidth + 7) / 8;
+ }
+ if (pkloc + compsize > 65487L || ng > 127) { /*81:*/
+ writepostamb();
+ if (nf > 26) {
+ printf("Sorry, more than 26 fonts necessary, reduce bitmap\n");
+ _Escape(0);
+ }
+ writepreambl();
+ }
+ flagbyte = dynf * 16;
+ if (firston)
+ flagbyte += 8;
+ if (width[f][car] > 16777215L || width[f][car] < 0 || horesc < 0 ||
+ compsize > 196594L || pkwidth > 65535L || pkheight > 65535L ||
+ cxoff > 32767 || cyoff > 32767 || cxoff < -32768L || cyoff < -32768L)
+ { /*82:*/
+ flagbyte += 7;
+ pkbyte(flagbyte);
+ compsize += 28;
+ pkword(compsize);
+ pkword(ng);
+ predpkloc = pkloc + compsize;
+ pkword(width[f][car]);
+ pkword(horesc);
+ pkword(0);
+ pkword(pkwidth);
+ pkword(pkheight);
+ pkword(cxoff);
+ pkword(cyoff);
+ } /*:82*/
+ else if (horesc > 255 || pkwidth > 255 || pkheight > 255 || cxoff > 127 ||
+ cyoff > 127 || cxoff < -128 || cyoff < -128 || compsize > 1015) {
+ compsize += 13;
+ flagbyte += compsize / 65536L + 4;
+ pkbyte(flagbyte);
+/* p2c: bm2font.pas, line 874:
+ * Note: Using % for possibly-negative arguments [317] */
+ pkhalfword((compsize % 65536L));
+ pkbyte(ng);
+ predpkloc = pkloc + compsize;
+ pkthreebytes(width[f][car]);
+ pkhalfword(horesc);
+ pkhalfword(pkwidth);
+ pkhalfword(pkheight);
+ pkhalfword(cxoff);
+ pkhalfword(cyoff);
+ } else {
+ compsize += 8;
+ flagbyte += compsize / 256;
+ pkbyte(flagbyte);
+ pkbyte((compsize & 255));
+ pkbyte(ng);
+ predpkloc = pkloc + compsize;
+ pkthreebytes(width[f][car]);
+ pkbyte(horesc & 255);
+ pkbyte(pkwidth);
+ pkbyte(pkheight);
+ pkbyte(cxoff);
+ pkbyte(cyoff);
+ }
+ if (dynf != 14) { /*85:*/
+ bitweight = 16;
+ max2 = 208 - dynf * 15;
+ i = bitcounts;
+ while (repbm[i] != 0) {
+ j = repbm[i];
+ if (j < -10000)
+ j = longtab[-j - 10001];
+ if (j == -1)
+ pknyb(15);
+ else {
+ if (j < 0) {
+ pknyb(14);
+ j = -j;
+ }
+ if (j <= dynf)
+ pknyb(j);
+ else if (j <= max2) {
+ j += -dynf - 1;
+ pknyb(((j) >> 4) + dynf + 1);
+ pknyb((j & 15));
+ } else {
+ j += 15 - max2;
+ k = 1;
+ while (k <= ((unsigned long)j) >> 4) {
+ k <<= 4;
+ pknyb(0);
+ }
+ while (k > 0) {
+ pknyb((j / k));
+ j %= k;
+/* p2c: bm2font.pas, line 889:
+ * Note: Using % for possibly-negative arguments [317] */
+ k = ((unsigned long)k) >> 4;
+ }
+ }
+ }
+ i++;
+ }
+ if (bitweight != 16)
+ pkbyte(outputbyte);
+ } else /*86:*/
+ { /*:86*/
+ crst = pkpoint[car];
+ bytelength = (((unsigned long)(pkwidth + 7)) >> 3) - 1;
+ if ((pkwidth & 7) == 0) {
+ while (crst < endraster) {
+ for (i = 0; i <= bytelength; i++)
+ pkbyte(pxlbm[crst + i]);
+ crst += wwid;
+ }
+ } else {
+ pkshift = 0;
+ dshift = pkwidth & 7;
+ while (crst < endraster) {
+ if (pkshift == 0) {
+ for (i = 0; i < bytelength; i++)
+ pkbyte(pxlbm[crst + i]);
+ mixbyte = pxlbm[crst + bytelength];
+ } else {
+ i = crst;
+ l = pkwidth + pkshift;
+ while (l >= 8) {
+ l -= 8;
+ restbyte = pxlbm[i];
+ i++;
+ pkbyte(mixbyte + (restbyte >> pkshift));
+ mixbyte = restbyte << (8 - pkshift);
+ }
+ if (pkshift < ((pkshift + dshift) & 7))
+ mixbyte += pxlbm[i] >> pkshift;
+ }
+ crst += wwid;
+ pkshift = (pkshift + dshift) & 7;
+ }
+ if (pkshift > 0)
+ pkbyte(mixbyte);
+ }
+ }
+ /*:85*/
+ if (predpkloc != pkloc) {
+ printf("Bad predicted character length: character %d\n", car);
+ printf("pred: %uloc: %u\n", predpkloc, pkloc);
+ _Escape(0);
+ }
+ pkpoint[car] = 0; /*:78*/
+ putchar('.');
+ if (car == 79)
+ putchar('\n');
+ pwidth[nf][ng] = pwidth[f][car];
+ pheight[nf][ng] = pheight[f][car];
+ width[nf][ng] = width[f][car];
+ height[nf][ng] = height[f][car];
+ yoffset[nf][ng] = yoffset[f][car];
+ ng++;
+
+ /*84:*/
+ /*:84*/
+ /*83:*/
+ /*:83*/
+ /*:81*/
+}
+
+
+/*:70*/
+/*88:*/
+Static Void fonteject()
+{
+ short lx, FORLIM, FORLIM1, FORLIM2;
+
+ nf = 0;
+ ng = 0;
+ writepreambl();
+ while (maplines > 0) {
+ FORLIM = maxx;
+ for (k = 1; k <= FORLIM; k++) {
+ i = k - 1;
+ dirpoint[g] = pxlbmi / 4;
+ pkpoint[g] = pxlbmi;
+ linepos_ = posbit + i * hres / 8;
+ pxlinlen = (pwidth[f][g] + 7) / 8;
+ zeroline = true;
+ gi = 0;
+ FORLIM1 = pheight[f][g];
+ for (v = 1; v <= FORLIM1; v++) {
+ fseek(bitmap, linepos_, 0);
+/* p2c: bm2font.pas, line 916:
+ * Note: Can't interpret size in BLOCKREAD [174] */
+ j = fread(b1, 1, pxlinlen, bitmap);
+ FORLIM2 = pxlinlen;
+ for (lx = 0; lx < FORLIM2; lx++)
+ b2[lx] = b1[lx];
+ if (invert) {
+ FORLIM2 = pxlinlen;
+ for (lx = 0; lx < FORLIM2; lx++)
+ b2[lx] = 255 - b1[lx];
+ }
+ gi += dv;
+ if (gi >= lv)
+ gi -= cv;
+ if (invbyte == 255) {
+ FORLIM2 = pxlinlen;
+ for (lx = 0; lx < FORLIM2; lx++)
+ b1[lx] = invbyte - b1[lx];
+ }
+ lx = 0;
+ zerorow = true;
+ FORLIM2 = pxlinlen;
+ for (j = 0; j < FORLIM2; j++) {
+ if (b1[j] != 0) {
+ zerorow = false;
+ zeroline = false;
+ }
+ }
+ if (zeroline) {
+ yoffset[f][g]++;
+ if (yoffset[f][g] == pheight[f][g]) {
+ yoffset[f][g]--;
+ zerorow = false;
+ zeroline = false;
+ }
+ }
+ cx.i = 0;
+ if (!zeroline) {
+ FORLIM2 = pxlinlen;
+ for (j = 0; j < FORLIM2; j++) {
+ if (lx > 3) {
+ lx = 0;
+ pxlmap(cx.i);
+ cx.i = 0;
+ }
+ cx.b[lx] = b1[j];
+ lx++;
+ }
+ pxlmap(cx.i);
+ }
+ linepos_ += (mapwidth + 7) / 8 + zeropads;
+ }
+ i += maxx;
+ g++;
+ if (g == mincharpf) { /*89:*/
+ for (car = 0; car <= 127; car++) {
+ if (pkpoint[car] != 0)
+ shipcharacte();
+ }
+ f++;
+ g = 0;
+ pxlbmi = 4;
+ }
+ /*:89*/
+ }
+ maplines -= vres;
+ posbit += vres * ((mapwidth + 7) / 8 + zeropads);
+ }
+ if (bitmap != NULL)
+ fclose(bitmap);
+ bitmap = NULL; /*90:*/
+ for (car = 0; car <= 127; car++) {
+ if (pkpoint[car] != 0)
+ shipcharacte();
+ }
+ writepostamb();
+ noffonts = nf; /*:90*/
+}
+
+
+/*:88*/
+/*103:*/
+Static Void userhelp()
+{
+ short FORLIM, FORLIM1;
+
+ sprintf(cmd, "%s.tex", font);
+ strcpy(texfile_NAME, cmd);
+ if (texfile != NULL)
+ texfile = freopen(texfile_NAME, "w", texfile);
+ else
+ texfile = fopen(texfile_NAME, "w");
+ _SETIO(texfile != NULL, FileNotFound);
+ filestat = P_ioresult;
+ if (filestat == 0)
+ fok = false;
+ else
+ fok = true;
+ if (filestat == 5) {
+ *cmd = '\0';
+ sprintf(cmd + strlen(cmd), "%s.tex", font);
+ strcpy(texfile_NAME, cmd);
+ if (texfile != NULL)
+ texfile = freopen(texfile_NAME, "w", texfile);
+ else
+ texfile = fopen(texfile_NAME, "w");
+ _SETIO(texfile != NULL, FileNotFound);
+ filestat = P_ioresult;
+ if (filestat == 0)
+ fok = false;
+ else
+ fok = true;
+ }
+ if (fok) { /*104:*/
+ printf("%s error occured when allocating TeXfile %s\n", cmd, cmd);
+ fileproblem();
+ _Escape(0);
+ }
+ fprintf(texfile, "\\newbox\\%sbox\n", font);
+ fprintf(texfile, "\\newdimen\\%swd\n", font);
+ FORLIM = noffonts;
+ for (a = 1; a <= FORLIM; a++) {
+ fprintf(texfile, "\\font\\%s%c=%s%c at ",
+ font, fontpre[a - 1], font, fontpre[a - 1]);
+ outfix(tabdsize[a - 1]);
+ fprintf(texfile, "truept\n");
+ }
+ fprintf(texfile, "\\setbox\\%sbox=\\vbox{\\hbox{%%\n", font);
+ a = 0;
+ k = 1;
+ c = 0;
+ i = (mapwidth + hres - 1) / hres;
+ FORLIM = i;
+ for (b = 1; b <= FORLIM; b++) {
+ if (a != k) {
+ fprintf(texfile, "\\%s%c", font, fontpre[k - 1]);
+ a = k;
+ }
+ fprintf(texfile, "\\char%d", c);
+ if ((b & 7) == 0 && b != i)
+ fprintf(texfile, "%%\n");
+ c++;
+ if (c == charpf[k]) {
+ k++;
+ c = 0;
+ }
+ }
+ fprintf(texfile, "}}\n");
+ /*:104*/
+ /*105:*/
+ fprintf(texfile, "\\%swd=\\wd\\%sbox\n", font, font);
+ fprintf(texfile, "\\setbox\\%sbox=\\hbox{\\vbox{\\hsize=\\%swd\n",
+ font, font);
+ fprintf(texfile, "\\parskip=0pt\\offinterlineskip\\parindent0pt\n");
+ v = 1;
+ k = 1;
+ c = 0;
+ FORLIM = nj;
+ for (a = 0; a < FORLIM; a++) {
+ fprintf(texfile, "\\hbox{\\%s%c", font, fontpre[k - 1]);
+ v = k;
+ FORLIM1 = i;
+ for (b = 0; b < FORLIM1; b++) {
+ if (v != k) {
+ fprintf(texfile, "\\%s%c", font, fontpre[k - 1]);
+ v = k;
+ }
+ fprintf(texfile, "\\char%d", c);
+ if (((b + 1) & 7) == 0 && b + 1 != i)
+ fprintf(texfile, "%%\n");
+ c++;
+ if (c == charpf[k]) {
+ k++;
+ c = 0;
+ }
+ }
+ if (a < nj - 1)
+ fprintf(texfile, "}\n");
+ }
+ fprintf(texfile, "}}}\n");
+ fprintf(texfile, "\\ifx\\parbox\\undefined\n");
+ fprintf(texfile, " \\def\\set%s{\\box\\%sbox}\n", font, font);
+ fprintf(texfile, "\\else\n");
+ fprintf(texfile, " \\def\\set%s{\\parbox{\\wd\\%sbox}", font, font);
+ fprintf(texfile, "{\\box\\%sbox}}\n", font);
+ fprintf(texfile, "\\fi\n");
+ if (texfile != NULL)
+ fclose(texfile);
+ texfile = NULL;
+ printf("File %s written\n", cmd); /*:105*/
+}
+
+
+/*:103*/
+/*106:*/
+main(argc, argv)
+int argc;
+Char *argv[];
+{
+ short FORLIM;
+ Char STR2[256];
+ uchar FORLIM1;
+ short FORLIM2, FORLIM3;
+ uchar FORLIM4;
+
+ PASCAL_MAIN(argc, argv);
+ tfmfile = NULL;
+ tmpfil = NULL;
+ pxlfile = NULL;
+ bitmap = NULL;
+ texfile = NULL;
+ power[0] = 1;
+ for (i = 1; i <= 8; i++)
+ power[i] = power[i - 1] * 2;
+ pxlbm = (uchar *)Malloc(sizeof(pxla));
+ pkbm = (uchar *)Malloc(sizeof(pxla));
+ repbm = (short *)Malloc(sizeof(pxlba));
+ gkorh = (short *)Malloc(sizeof(korbyte));
+ gkordivp = (short *)Malloc(sizeof(korbyte));
+ spreadvals = (short *)Malloc(sizeof(spreadbyte));
+ width = (long(*)[129])Malloc(sizeof(dynlong));
+ height = (long(*)[129])Malloc(sizeof(dynlong));
+ yoffset = (unsigned short(*)[129])Malloc(sizeof(dynword));
+ pwidth = (unsigned short(*)[129])Malloc(sizeof(dynword));
+ pheight = (unsigned short(*)[129])Malloc(sizeof(dynword));
+ greymem = (uchar *)Malloc(sizeof(pxla)); /*107:*/
+ strcpy(cref, "!()+,-./0123456789:;<=>?");
+ strcat(cref, "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
+/* p2c: bm2font.pas, line 974:
+ * Note: Possible string truncation in assignment [145] */
+ strcat(cref, "abcdefghijklmnopqrstuvwxyz");
+/* p2c: bm2font.pas, line 975:
+ * Note: Possible string truncation in assignment [145] */
+ strcpy(fontupc, "ABCDEFGHIJKLMNOPQRSTUVWXYZ");
+ strcpy(fontpre, "abcdefghijklmnopqrstuvwxyz");
+ truehres = 0.0;
+ truevres = 0.0;
+ halfinch = false;
+ invert = false;
+ greypxl = false;
+ pcxtemp = false;
+ giftemp = false;
+ cutgrey = false;
+ aliasused = false;
+ cmyk = false;
+ cyan = false;
+ magenta = false;
+ yellow = false;
+ black = false;
+ saveblack = false;
+ clipon = true;
+ xratio = 0;
+ yratio = 0;
+ egastretch = true;
+ ledprinter = false;
+ distribute = true;
+ brightness = 0;
+ bitspsam = 8;
+ nowhite = true;
+ usepxl = 0;
+ vusepxl = 0;
+ hrep = 1;
+ vrep = 1;
+ valinc = 70.0;
+ gradint = 70;
+ newwidth = 0;
+ newheight = 0;
+ printf("This is BitMapTOfont, version 3.0 of january 94, via p2c\n");
+ printf("Converting Bitmap Files to TeX-Fonts\n");
+ /*assign(logfile,'test.log');rewrite(logfile);close(logfile);*/
+ /*110:*/
+ if (P_argc == 1) {
+ printf("usage is BM2FONT filename and parameters\n");
+ printf("-f<name of picture for TeX> (std filename)\n");
+ printf("-h<horizontal resolution> (pixel/inch, std 300)\n");
+ printf("-v<vertical resolution> (pixel/inch, std 300)\n");
+ printf("-l<length of mapline> (in bytes, only pure bitmaps)\n");
+ printf("-p<height of character 1 inch> (y or n, std y)\n");
+ printf("-e<stretch EGA pictures> (y or n, std y)\n");
+ printf("-i<inversion of pixels> (y or n, std n)\n");
+ printf("-g<greypixels in bitmap> (y or n, std n)\n");
+ printf("-w<let white be light grey> (y or n, std y)\n");
+ printf("-d<distribute errors> (y or n, std y)\n");
+ printf("-s<separation of grey dots> (y or n, std n)\n");
+ printf("-r<repeat each grey pixel> (y or n, std n)\n");
+ printf("-u<pixels for grey rectangle> (less 8)\n");
+ printf("-c<vert. pixels for rectangle> (less 8)\n");
+ printf("-x<bits per sample> (0 < x < 9)\n");
+ printf("-b<reduce halftone colors> (f.e. by 1, less u*c*4, std 0)\n");
+ printf("-t<gradation value> (in %%, std 70)\n");
+ printf("-z<area of gradation> (in %%, std 70)\n");
+ printf("-m<width of picture on paper> (in mm)\n");
+ printf("-n<height of picture on paper> (in mm)\n");
+ printf("-j<clip off white space> (y or n, std y)\n");
+ printf("-k<color: c,m,y or k> (std k)\n");
+ /*readln(comment);
+if length(comment)=0 then goto 9999;j:=ord(comment[0])+1;
+if j<=127 then move(comment[0],mem[prefixseg:$80],j);*/
+ goto _L9999;
+ }
+ /*:110*/
+ /*111:*/
+ for (j = 1; j < P_argc; j++) {
+ strcpy(comment, P_argv[j]);
+ if (comment[0] != '-') {
+ strcpy(font, comment);
+ if (strlen(font) < 1 || !strcmp(font, " ")) {
+ printf("give the name of your bitmap file next time\n");
+ goto _L9999;
+ }
+ } else {
+ switch (comment[1]) {
+
+ case 'h':
+ case 'H':
+ strdelete((Anyptr)comment, 1, 2);
+ i = (sscanf(comment, "%lg", &truehres) == 0);
+ break;
+
+ case 'v':
+ case 'V':
+ strdelete((Anyptr)comment, 1, 2);
+ i = (sscanf(comment, "%lg", &truevres) == 0);
+ break;
+
+ case 'l':
+ case 'L':
+ strdelete((Anyptr)comment, 1, 2);
+ i = (sscanf(comment, "%ld", &mapinlen) == 0);
+ break;
+
+ case 'm':
+ case 'M':
+ strdelete((Anyptr)comment, 1, 2);
+ i = (sscanf(comment, "%ld", &newwidth) == 0);
+ break;
+
+ case 'n':
+ case 'N':
+ strdelete((Anyptr)comment, 1, 2);
+ i = (sscanf(comment, "%ld", &newheight) == 0);
+ break;
+
+ case 'c':
+ case 'C':
+ strdelete((Anyptr)comment, 1, 2);
+ i = (sscanf(comment, "%ld", &vusepxl) == 0);
+ break;
+
+ case 'b':
+ case 'B':
+ strdelete((Anyptr)comment, 1, 2);
+ i = (sscanf(comment, "%ld", &brightness) == 0);
+ break;
+
+ case 'x':
+ case 'X':
+ strdelete((Anyptr)comment, 1, 2);
+ i = (sscanf(comment, "%ld", &bitspsam) == 0);
+ break;
+
+ case 't':
+ case 'T':
+ strdelete((Anyptr)comment, 1, 2);
+ i = (sscanf(comment, "%lg", &valinc) == 0);
+ break;
+
+ case 'z':
+ case 'Z':
+ strdelete((Anyptr)comment, 1, 2);
+ i = (sscanf(comment, "%ld", &gradint) == 0);
+ break;
+
+ case 'g':
+ case 'G':
+ strdelete((Anyptr)comment, 1, 2);
+ greypxl = (!strcmp(comment, "y") || !strcmp(comment, "Y"));
+ break;
+
+ case 'e':
+ case 'E':
+ strdelete((Anyptr)comment, 1, 2);
+ egastretch = (!strcmp(comment, "n") || !strcmp(comment, "N"));
+ egastretch = !egastretch;
+ break;
+
+ case 'd':
+ case 'D':
+ strdelete((Anyptr)comment, 1, 2);
+ distribute = (!strcmp(comment, "n") || !strcmp(comment, "N"));
+ distribute = !distribute;
+ break;
+
+ case 'f':
+ case 'F':
+ strdelete((Anyptr)comment, 1, 2);
+ strcpy(aliasname, comment);
+ aliasused = true;
+ break;
+
+ case 's':
+ case 'S':
+ strdelete((Anyptr)comment, 1, 2);
+ ledprinter = (!strcmp(comment, "y") || !strcmp(comment, "Y"));
+ break;
+
+ case 'p':
+ case 'P':
+ strdelete((Anyptr)comment, 1, 2);
+ halfinch = (!strcmp(comment, "n") || !strcmp(comment, "N"));
+ break;
+
+ case 'r':
+ case 'R':
+ strdelete((Anyptr)comment, 1, 2);
+ if (!strcmp(comment, "y")) {
+ hrep = 2;
+ vrep = 2;
+ }
+ break;
+
+ case 'w':
+ case 'W':
+ strdelete((Anyptr)comment, 1, 2);
+ nowhite = (!strcmp(comment, "n") || !strcmp(comment, "N"));
+ nowhite = !nowhite;
+ break;
+
+ case 'k':
+ case 'K':
+ strdelete((Anyptr)comment, 1, 2);
+ if (!strcmp(comment, "c") || !strcmp(comment, "N"))
+ cyan = true;
+ else if (!strcmp(comment, "m") || !strcmp(comment, "M"))
+ magenta = true;
+ else if (!strcmp(comment, "y") || !strcmp(comment, "Y"))
+ yellow = true;
+ else if (!strcmp(comment, "k") || !strcmp(comment, "K"))
+ black = true;
+ break;
+
+ case 'i':
+ case 'I':
+ strdelete((Anyptr)comment, 1, 2);
+ invert = (!strcmp(comment, "y") || !strcmp(comment, "Y"));
+ break;
+
+ case 'j':
+ case 'J':
+ strdelete((Anyptr)comment, 1, 2);
+ clipon = (!strcmp(comment, "y") || !strcmp(comment, "Y"));
+ break;
+
+ case 'u':
+ case 'U':
+ strdelete((Anyptr)comment, 1, 2);
+ i = (sscanf(comment, "%ld", &usepxl) == 0);
+ break;
+ }
+ }
+ }
+ /*:111*/
+ /*112:*/
+ if (bitspsam < 1 || bitspsam > 8)
+ bitspsam = 8;
+ if (invert) {
+ invbit = 0;
+ invbyte = 0;
+ } else {
+ invbit = 1;
+ invbyte = 255;
+ }
+ if (usepxl == 0)
+ usepxl = 2;
+ if (vusepxl == 0)
+ vusepxl = usepxl;
+ if (brightness >= usepxl * vusepxl * 4)
+ brightness = 0;
+ if (brightness != 0 && usepxl < 2)
+ brightness = 0;
+ if (valinc > 99)
+ valinc = 99.0;
+ if (valinc > 0) {
+ if (gradint == 0)
+ gradint = 1;
+ }
+ if (gradint > 99)
+ gradint = 99;
+ if (newheight < 0)
+ newheight = 0;
+ if (newwidth < 0)
+ newwidth = 0;
+ if (newwidth > 200) {
+ printf("Sorry, new width set to 200mm\n");
+ newwidth = 200;
+ }
+ if (newheight > 280) {
+ printf("Sorry, new height set to 280mm\n");
+ newheight = 280;
+ }
+ if (truehres == 0)
+ truehres = 300.0;
+ if (truevres == 0)
+ truevres = truehres;
+ cmyk = (cyan || magenta || yellow || black);
+ saveblack = (cyan || magenta || yellow); /*:112*/
+ /*:107*/
+ /*108:*/
+ for (j = 0; j <= 51; j++) {
+ for (i = 0; i <= 128; i++) {
+ pwidth[j][i] = 0;
+ width[j][i] = 0;
+ height[j][i] = 0;
+ pheight[j][i] = 0;
+ yoffset[j][i] = 0;
+ }
+ }
+ for (i = 0; i <= 128; i++)
+ dirpoint[i] = 0;
+ for (i = 0; i <= 128; i++)
+ pkpoint[i] = 0;
+ for (i = 0; i <= 52; i++)
+ charpf[i] = 0;
+ maxx = 0;
+ minx = 646;
+ mapheight = 0; /*:108*/
+ fok = true;
+ strcpy(bmname, font);
+ strcpy(bitmap_NAME, bmname);
+ if (bitmap != NULL)
+ bitmap = freopen(bitmap_NAME, "rb", bitmap);
+ else
+ bitmap = fopen(bitmap_NAME, "rb");
+ _SETIO(bitmap != NULL, FileNotFound);
+ filestat = P_ioresult;
+ if (filestat == 0)
+ fok = false;
+ else
+ fok = true;
+ if (fok) { /*113:*/
+ printf("File %s not found, abort\n", font);
+ fileproblem();
+ goto _L9999;
+ }
+ i = 1;
+ j = 0;
+ strcpy(cmd, " ");
+ while (i <= strlen(bmname)) {
+ if (bmname[i - 1] == '.')
+ j = i;
+ i++;
+ }
+ if (j > 0)
+ strsub(cmd, bmname, j + 1, (int)(strlen(bmname) - j + 1));
+ if (!strcmp(cmd, "tif") || !strcmp(cmd, "TIF") || !strcmp(cmd, "tiff") ||
+ !strcmp(cmd, "TIFF"))
+ tifint();
+ else {
+ if (!strcmp(cmd, "pcx") || !strcmp(cmd, "PCX"))
+ pcxint();
+ else if (!strcmp(cmd, "lbm") || !strcmp(cmd, "LBM") ||
+ !strcmp(cmd, "iff") || !strcmp(cmd, "IFF"))
+ iffint();
+ else if (!strcmp(cmd, "gif") || !strcmp(cmd, "GIF"))
+ gifint();
+ else if (!strcmp(cmd, "bmp") || !strcmp(cmd, "BMP"))
+ bmpint();
+ else if (!strcmp(cmd, "img") || !strcmp(cmd, "IMG"))
+ imgint();
+ else if (!strcmp(cmd, "cut") || !strcmp(cmd, "CUT"))
+ cutint();
+ else
+ posbit = 0;
+ }
+ if (aliasused) {
+ strcpy(font, aliasname);
+ strcpy(bmname, aliasname);
+ }
+ FORLIM = strlen(bmname);
+ for (i = 1; i <= FORLIM; i++) {
+ sprintf(STR2, "%c", bmname[i - 1]);
+ j = strpos2(fontpre, STR2, 1);
+ if (j != 0)
+ bmname[i - 1] = fontupc[j - 1];
+ }
+ FORLIM = strlen(font);
+ for (i = 1; i <= FORLIM; i++) {
+ sprintf(STR2, "%c", font[i - 1]);
+ j = strpos2(fontupc, STR2, 1);
+ if (j != 0)
+ font[i - 1] = fontpre[j - 1];
+ }
+ korrfont();
+ nameok = true;
+ FORLIM = strlen(font);
+ for (i = 1; i <= FORLIM; i++) {
+ if (isdigit(font[i - 1]))
+ nameok = false;
+ }
+ if (!nameok) {
+ printf("no digits allowed in name of font\n");
+ goto _L9999;
+ }
+ strcpy(bmname, font);
+ FORLIM = strlen(bmname);
+ for (i = 1; i <= FORLIM; i++) { /*:113*/
+ sprintf(STR2, "%c", bmname[i - 1]);
+ j = strpos2(fontpre, STR2, 1);
+ if (j != 0)
+ bmname[i - 1] = fontupc[j - 1];
+ }
+ /*114:*/
+ if (truehres <= 0 || truehres > 2000)
+ truehres = 300.0;
+ if (truevres <= 0 || truevres > 2000)
+ truevres = 300.0;
+ whatistrue();
+ if (hres != (long)floor(truehres + 0.5))
+ printf("maximum width of characters is %ld pixel\n", hres);
+ if (vres != (long)floor(truevres + 0.5))
+ printf("maximum height of characters is %ld pixel\n", vres);
+ if (posbit != 0)
+ pxlinlen = (halfk)((mapwidth + 7) / 8);
+ else {
+ pxlinlen = mapinlen;
+ mapwidth = pxlinlen * 8;
+ if (greypxl) /*116:*/
+ mapwidth /= bitspsam;
+ if (mapwidth < 1) {
+ printf("Width not correct!\n");
+ goto _L9999;
+ }
+ mapheight = (P_maxpos(bitmap)) / mapinlen;
+ if ((P_maxpos(bitmap)) % mapinlen > 0) {
+ printf("Remainder > 0 when dividing size of file by width!\n");
+ goto _L9999;
+ }
+/* p2c: bm2font.pas, line 1102:
+ * Note: Using % for possibly-negative arguments [317] */
+ if (greypxl) {
+ mapdiv = 1.0;
+ photoinf = 15;
+ FORLIM1 = bitspsam;
+ for (cb = 1; cb <= FORLIM1; cb++)
+ mapdiv *= 2;
+ mapdiv /= 16;
+ } /*:116*/
+ }
+ if (pxlinlen > 3000) {
+ printf("File not processable, width > 3000 bytes\n");
+ goto _L9999;
+ } /*:114*/
+ if (newwidth != 0 || newheight != 0)
+ scaling();
+ if (greypxl) { /*94:*/
+ printf("Halftone picture required\n");
+ pxlinlen = (halfk)(((unsigned long)(mapwidth * bitspsam + 7)) >> 3);
+ greypix = mapwidth;
+ mapwidth *= bitspsam; /*95:*/
+ sprintf(tmpname, "%s.tmp", font);
+ strcpy(tmpfil_NAME, tmpname);
+ filestat = P_ioresult;
+ if (filestat == 0)
+ fok = false;
+ else
+ fok = true;
+ if (fok) {
+ printf("tempfile %s not accessable, abort\n", tmpname);
+ fileproblem();
+ goto _L9999;
+ }
+ if (tmpfil != NULL)
+ tmpfil = freopen(tmpfil_NAME, "w+b", tmpfil);
+ else
+ tmpfil = fopen(tmpfil_NAME, "w+b");
+ _SETIO(tmpfil != NULL, FileNotFound);
+ filestat = P_ioresult;
+ if (filestat == 0)
+ fok = false;
+ else
+ fok = true;
+ if (fok) { /*:95*/
+ printf("Tempfile for font %s not found, abort\n", font);
+ fileproblem();
+ goto _L9999;
+ }
+ /*101:*/
+ k = 0;
+ if (usepxl != vusepxl) {
+ FORLIM = vusepxl;
+ for (i = 0; i < FORLIM; i++) {
+ FORLIM2 = usepxl;
+ for (j = 0; j < FORLIM2; j++) {
+ k++;
+ tab[k - 1][0] = i + 1;
+ tab[k - 1][1] = j + 1;
+ tab[k - 1][2] = i * i * (usepxl - 1) * (usepxl - 1) +
+ j * j * (vusepxl - 1) * (vusepxl - 1);
+ }
+ }
+ FORLIM = k;
+ for (i = 1; i <= FORLIM; i++) {
+ FORLIM2 = k;
+ for (j = i; j <= FORLIM2; j++) {
+ if (tab[i - 1][2] > tab[j - 1][2]) {
+ lx = tab[i - 1][0];
+ tab[i - 1][0] = tab[j - 1][0];
+ tab[j - 1][0] = lx;
+ lx = tab[i - 1][1];
+ tab[i - 1][1] = tab[j - 1][1];
+ tab[j - 1][1] = lx;
+ lx = tab[i - 1][2];
+ tab[i - 1][2] = tab[j - 1][2];
+ tab[j - 1][2] = lx;
+ }
+ }
+ }
+ FORLIM = k;
+ for (i = 1; i <= FORLIM; i++) {
+ lx = tab[i - 1][0];
+ ly = tab[i - 1][1];
+ ditherm[lx - 1][ly - 1] = i;
+ }
+ }
+ if (usepxl > 7)
+ usepxl = 7;
+ if (vusepxl > 7)
+ vusepxl = 7;
+ maxcol = 1;
+ cb = 0;
+ usecol = usepxl * vusepxl * 4;
+ FORLIM = bitspsam;
+ for (k = 1; k <= FORLIM; k++)
+ maxcol *= 2;
+ maxcol--;
+ for (k = 1; k <= 4; k++) {
+ for (i = 0; i <= 196; i++) {
+ for (j = 1; j <= 7; j++)
+ pattern[k - 1][i][j - 1] = 0;
+ }
+ }
+ FORLIM = vusepxl;
+ for (i = 1; i <= FORLIM; i++) {
+ FORLIM2 = usepxl;
+ for (j = 1; j <= FORLIM2; j++) {
+ if (ditherm[i - 1][j - 1] <= usecol / 4 && ditherm[i - 1][j - 1] > 0) {
+ v = (ditherm[i - 1][j - 1] - 1) * 4 + 1;
+ for (ccol = 1; ccol <= 4; ccol++) {
+ if (ccol == 1)
+ c = 1;
+ else if (ccol == 2)
+ c = 3;
+ else if (ccol == 3)
+ c = 4;
+ else
+ c = 2;
+ FORLIM3 = usecol;
+ for (k = v; k <= FORLIM3; k++) {
+ switch (c) {
+
+ case 4:
+ if (usepxl > 2 || vusepxl > 2)
+ pattern[0][k][j - 1] |= (cb + 2) << (7 - i);
+ else
+ pattern[0][k][i - 1] |= (cb + 2) << (7 - j);
+ break;
+
+ case 1:
+ pattern[1][k][vusepxl - i] |= (cb + 1) << (j - usepxl + 7);
+ break;
+
+ case 2:
+ if (usepxl > 2 || vusepxl > 2)
+ pattern[2][k][vusepxl - j] |= (cb + 2) << (7 - i);
+ else
+ pattern[2][k][vusepxl - i] |= (cb + 2) << (7 - j);
+ break;
+
+ case 3:
+ pattern[3][k][i - 1] |= (cb + 1) << (j - usepxl + 7);
+ break;
+ }
+ }
+ v++;
+ }
+ }
+ }
+ }
+ if (nowhite)
+ pattern[1][0][usepxl - 1] = 128 >> (usepxl - 1);
+ usecol -= brightness; /*:101*/
+ /*[102:]append(logfile);
+for k:=0 to usecol do begin for j:=1 to vusepxl do begin for i:=1 to 4
+do begin cb:=pattern[i,k,j];write(logfile,cb:4,' ');
+for pk:=1 to usepxl do begin if cb>127 then write(logfile,'1')else write
+(logfile,'0');cb:=cb shl 1;end;write(logfile,' ');end;
+writeln(logfile,'.');end;writeln(logfile,'---- ',k:1,' ----');end;
+close(logfile);[:102]*/
+ greypix -= greypix & 3;
+ mapwidth = greypix * bitspsam;
+ if (ledprinter)
+ gbufpp = ((long)floor(greypix * (usepxl + 0.5) + 0.5) * hrep + 7) / 8;
+ else
+ gbufpp = (greypix * usepxl * hrep + 7) / 8;
+ if (gbufpp > 1280) {
+ printf("Only up to 1280 bytes in one row allowed!\n");
+ printf("Try again by decreasing param <u> or <r=n>\n");
+ _Escape(0);
+ } /*96:*/
+ printf("Analysing and optimizing the picture\n");
+ pminval = 255;
+ pmaxval = 0;
+ if (cmyk) {
+ pminval = 0;
+ pmaxval = maxcol;
+ }
+ if (cutgrey) {
+ checksum = mapheight;
+ pxlinlen = cutlen;
+ } else
+ checksum = mapheight;
+ pl = 0;
+ fseek(bitmap, posbit, 0);
+ do {
+ pxlinlen = fread(b1, 1, pxlinlen, bitmap);
+ colpos = 0;
+ cutrep = 0;
+ FORLIM = greypix;
+ for (pk = 0; pk < FORLIM; pk++) {
+ tmpcolor = getcolor();
+ if (tmpcolor > pmaxval)
+ pmaxval = tmpcolor;
+ if (tmpcolor < pminval)
+ pminval = tmpcolor;
+ }
+ checksum--;
+ if (cutgrey)
+ pxlinlen = b1[pxlinlen - 1] * 256 + b1[pxlinlen - 2] + 2;
+ } while (checksum != 0);
+/* p2c: bm2font.pas, line 1165:
+ * Note: Can't interpret size in BLOCKREAD [174] */
+ if (pminval == pmaxval && !cmyk) {
+ printf("Only one color (value %d) used by bitmap!\n", pmaxval);
+ printf("It makes no sence to generate a picture!\n");
+ _Escape(0);
+ } /*:96*/
+ if (brightness == 0) {
+ brightness = (long)floor(
+ (maxcol - pmaxval + pminval + 1.0) * usecol / (maxcol + 1) + 0.5);
+ if (brightness > 0)
+ printf("Best result may be with parameter -b%ld !?\n", brightness);
+ }
+ printf("Dithering the picture\n");
+ memset((Anyptr)greymem, 255, sizeof(uchar) * 32761L);
+ pgreymem = 0;
+ if (cutgrey) {
+ checksum = mapheight;
+ pxlinlen = cutlen;
+ } else
+ checksum = mapheight;
+ pl = 0;
+ fseek(bitmap, posbit, 0);
+ patswitch = 4;
+ spreadcol = (maxcol + 1.0) / (pmaxval - pminval + 1);
+ patref = (double)usecol / maxcol; /*97:*/
+ for (k = 0; k <= 255; k++)
+ pxllook[k] = k;
+ if (invert) {
+ for (k = 0; k <= 255; k++)
+ pxllook[k] = 255 - k;
+ }
+ if (invert) {
+ FORLIM = pmaxval;
+ for (k = pminval; k <= FORLIM; k++)
+ pxllook[pmaxval - k + pminval] =
+ (long)floor((k - pminval) * spreadcol + 0.5);
+ invbit = 1;
+ invbyte = 255;
+ } else {
+ FORLIM = pmaxval;
+ for (k = pminval; k <= FORLIM; k++)
+ pxllook[k] = (long)floor((k - pminval) * spreadcol + 0.5);
+ }
+ FORLIM = maxcol;
+ for (k = 0; k <= FORLIM; k++)
+ lutone[k] = (long)floor((maxcol - k) * patref + 0.5);
+ if (valinc > 0) { /*98:*/
+ k = pminval;
+ pk = 0;
+ while (pk <= gradint && k <= pmaxval) {
+ pk = (long)floor(pxllook[k] * 100.0 / maxcol + 0.5);
+ k++;
+ }
+ pkn = pxllook[k - 1];
+ grxzero = pkn;
+ redval = valinc / 100;
+ FORLIM = pmaxval;
+ for (k = pminval; k <= FORLIM; k++) {
+ /*write(logfile,(pxllook[k]/maxcol):1:5
+);*/
+ grx = pxllook[k];
+ if (grx <= pkn) {
+ if (grx > 0)
+ pxllook[k] = (long)
+ floor(0.5 * grx * (exp(redval * log(grx / grxzero)) +
+ exp(-redval * log(grx / grxzero))) + 0.5);
+/* p2c: bm2font.pas, line 1353:
+ * Note: Line breaker spent 1.0 seconds, 5000 tries on line 4297 [251] */
+ }
+ /*writeln(logfile,' ',(pxllook[k]/maxcol):1:5);*/
+ } /*close(logfile);;*/
+ /*:98*/
+ }
+ /*append(logfile);*/
+ FORLIM = maxcol;
+ for (pk = 0; pk <= FORLIM; pk++)
+ hktab[pk] = (long)floor((maxcol - pk) * patref * 100 + 0.5) -
+ (long)(lutone[pk] * 100.0);
+ cspread = false;
+ if (usecol - 1 > maxcol) {
+ pk = usecol;
+ for (k = maxcol; k >= 0; k--) {
+ if (invert)
+ pk = usecol - lutone[pxllook[maxcol - k]];
+ else
+ pk = usecol - lutone[pxllook[k]];
+ while (pk >= k) {
+ lutone[pk] = lutone[pxllook[k]];
+ hktab[pk] = (long)floor(lutone[pk] * 100.0 + 0.5) -
+ (long)floor((usecol - pk) * 100.0 + 0.5);
+ lutone[pk] -= hktab[pk] / 100;
+ pk--;
+ }
+ }
+ if (invert) {
+ FORLIM = usecol;
+ for (k = 0; k <= FORLIM; k++)
+ pxllook[k] = lutone[k];
+ } else {
+ FORLIM = usecol;
+ for (k = 0; k <= FORLIM; k++)
+ pxllook[k] = usecol - lutone[k];
+ }
+ maxcol = usecol;
+ cspread = true;
+ }
+ invert = false;
+ mapdiv = (usecol + 1.0) / 16;
+ FORLIM = usecol;
+ for (k = 0; k <= FORLIM; k++)
+ lutvga[k] = (long)((usecol - k) / mapdiv);
+ for (pk = -255; pk <= 255; pk++) {
+ if (cspread)
+ gkorh[pk + 255] = (long)(pk / 2.0);
+ else
+ gkorh[pk + 255] = (long)floor(pk / 2.0 * spreadcol + 0.5);
+ if (cspread)
+ gkordivp[pk + 255] = (long)(pk / 2.0);
+ else
+ gkordivp[pk + 255] = (long)(pk / 2.0 * patref + hktab[abs(pk)] / 100.0);
+ }
+ for (pk = 0; pk <= 255; pk++) /*:97*/
+ spreadvals[pk] = (long)floor(pk * patref + 0.5);
+ do {
+ pxlinlen = fread(b1, 1, pxlinlen, bitmap);
+ colpos = 0;
+ cutrep = 0;
+ FORLIM = greypix;
+ for (pk = 0; pk < FORLIM; pk++)
+ b4[pk] = getcolor();
+ if (cspread) {
+ FORLIM = greypix;
+ for (pk = 0; pk < FORLIM; pk++)
+ b4[pk] = spreadvals[b4[pk]];
+ }
+ if (distribute) { /*99:*/
+ pk = 1;
+ pkn = 1;
+ while (pk < greypix) {
+ pkn++;
+ greykor = 0;
+ if (b4[pk] != b4[pkn]) {
+ greykor = gkorh[b4[pk] - b4[pkn] + 255];
+ greykor = gkordivp[greykor + 255];
+ }
+ if (greykor != 0) {
+ tmpcolor = lutone[pxllook[b4[pkn]]];
+ if (abs(tmpcolor + greykor) <= usecol &&
+ abs(tmpcolor + greykor) >= 0)
+ b4[pkn] += greykor;
+ }
+ pk++;
+ }
+ pk = greypix - 1;
+ pkn = pk;
+ while (pk > 0) { /*:99*/
+ pkn--;
+ greykor = 0;
+ if (b4[pk] != b4[pkn]) {
+ greykor = gkorh[b4[pk] - b4[pkn] + 255];
+ greykor = gkordivp[greykor + 255];
+ }
+ if (greykor != 0) {
+ tmpcolor = lutone[pxllook[b4[pkn]]];
+ if (abs(tmpcolor + greykor) <= usecol &&
+ abs(tmpcolor + greykor) >= 0)
+ b4[pkn] += greykor;
+ }
+ pk--;
+ }
+ }
+ FORLIM = greypix;
+ for (pk = 0; pk < FORLIM; pk++)
+ b4[pk] = lutone[pxllook[b4[pk]]];
+ FORLIM1 = vrep;
+ for (yrep = 1; yrep <= FORLIM1; yrep++) { /*100:*/
+ FORLIM = vusepxl;
+ for (k = 1; k <= FORLIM; k++) {
+ gbufp = 0;
+ cb = 0;
+ pn = 0;
+ switch (patswitch) {
+
+ case 1:
+ curpat[0] = 2;
+ curpat[1] = 3;
+ break;
+
+ case 2:
+ curpat[0] = 4;
+ curpat[1] = 1;
+ break;
+
+ case 3:
+ curpat[0] = 3;
+ curpat[1] = 2;
+ break;
+
+ case 4:
+ curpat[0] = 1;
+ curpat[1] = 4;
+ break;
+ }
+/* p2c: bm2font.pas, line 1233:
+ * Note: Can't interpret size in FILLCHAR [174] */
+ memset((Anyptr)b3, 0, (long)gbufpp);
+ FORLIM2 = greypix;
+ for (pk = 0; pk < FORLIM2; pk++) {
+ FORLIM4 = hrep;
+ for (xrep = 1; xrep <= FORLIM4; xrep++) {
+ cb = pattern[curpat[pn] - 1][b4[pk]][k - 1];
+ if (saveblack)
+ cb &= ~pattern[curpat[pn] - 1][bhell[b4[pk]]][k - 1];
+ dbuf = ((unsigned)gbufp) >> 3;
+ bufsh = gbufp & 7;
+ nextbuf = bufsh + usepxl;
+ switch (bufsh) {
+
+ case 0:
+ b3[dbuf] = cb;
+ break;
+
+ default:
+ b3[dbuf] |= cb >> bufsh;
+ if (nextbuf > 8)
+ b3[dbuf + 1] = cb << (8 - bufsh);
+ break;
+ }
+ gbufp += usepxl;
+ if (ledprinter) {
+ if (curpat[pn] == 1 || curpat[pn] == 3)
+ gbufp++;
+ }
+ pn = abs(pn - 1);
+ }
+ }
+ FORLIM2 = gbufpp;
+ for (pk = 0; pk <= FORLIM2; pk++)
+ b3[pk] = ~b3[pk];
+ if (pgreymem + gbufpp > 65522L) {
+ _SETIO(fwrite(greymem, pgreymem, 1, tmpfil) == 1, FileWriteError);
+ filestat = P_ioresult;
+ if (filestat != 0) {
+ _SETIO(printf("Error occured when writing file %s!\n", tmpname) >= 0,
+ FileWriteError);
+ fileproblem();
+ _Escape(0);
+ }
+ pgreymem = 0;
+ }
+/* p2c: bm2font.pas, line 1242:
+ * Note: Can't interpret size in BLOCKWRITE [174] */
+/* p2c: bm2font.pas, line 1245: Note: Can't interpret size in MOVE [174] */
+ memmove((Anyptr)(&greymem[pgreymem]), (Anyptr)b3, (long)gbufpp);
+ pgreymem += gbufpp;
+ }
+/* p2c: bm2font.pas, line 1246:
+ * Note: Can't interpret size in FILLCHAR [174] */
+ memset((Anyptr)b3, 255, (long)gbufpp);
+ if (ledprinter) {
+ if (patswitch == 2 || patswitch == 4) {
+ if (pgreymem + gbufpp > 65522L) {
+ _SETIO(fwrite(greymem, pgreymem, 1, tmpfil) == 1,
+ FileWriteError);
+ filestat = P_ioresult;
+ if (filestat != 0) {
+ _SETIO(printf("Error occured when writing file %s!\n",
+ tmpname) >= 0, FileWriteError);
+ fileproblem();
+ _Escape(0);
+ }
+ pgreymem = 0;
+ }
+/* p2c: bm2font.pas, line 1249:
+ * Note: Can't interpret size in BLOCKWRITE [174] */
+/* p2c: bm2font.pas, line 1252: Note: Can't interpret size in MOVE [174] */
+ memmove((Anyptr)(&greymem[pgreymem]), (Anyptr)b3, (long)gbufpp);
+ pgreymem += gbufpp;
+ } /*:100*/
+ }
+ patswitch++;
+ if (patswitch > 4)
+ patswitch = 1;
+ }
+ pm = 128;
+ pb = pl;
+ FORLIM = greypix;
+ for (pk = 0; pk < FORLIM; pk++) {
+ pxlcolor = lutvga[b4[pk]];
+ pm >>= 1;
+ if (pm == 0) {
+ pm = 128;
+ pb++;
+ }
+ }
+ pl += 80;
+ if (pl >= 38400L)
+ pl = 0;
+ checksum--;
+ if (cutgrey)
+ pxlinlen = (halfk)(b1[pxlinlen - 1] * 256 + b1[pxlinlen - 2] + 2);
+ } while (checksum != 0);
+/* p2c: bm2font.pas, line 1213:
+ * Note: Can't interpret size in BLOCKREAD [174] */
+ if (pgreymem != 0) { /*$I-*/
+ _SETIO(fwrite(greymem, pgreymem, 1, tmpfil) == 1, FileWriteError);
+ filestat = P_ioresult;
+ if (filestat != 0) {
+ _SETIO(printf("Error occured when writing file %s!\n", tmpname) >= 0,
+ FileWriteError);
+ fileproblem();
+ _Escape(0);
+ }
+ }
+/* p2c: bm2font.pas, line 1259:
+ * Note: Can't interpret size in BLOCKWRITE [174] */
+ posbit = 0;
+ if (ledprinter)
+ mapwidth = (long)floor(greypix * (usepxl + 0.5) + 0.5) * hrep;
+ else
+ mapwidth = greypix * usepxl * hrep;
+ pxlinlen = (mapwidth + 7) / 8;
+ mapinlen = pxlinlen;
+ if (ledprinter)
+ mapheight = (long)floor(mapheight * (vusepxl + 0.5) + 0.5) * vrep;
+ else
+ mapheight *= vusepxl * vrep;
+ if (tmpfil != NULL)
+ fclose(tmpfil);
+ tmpfil = NULL;
+ if (bitmap != NULL)
+ fclose(bitmap);
+ bitmap = NULL;
+ strcpy(bitmap_NAME, tmpname);
+ if (bitmap != NULL)
+ bitmap = freopen(bitmap_NAME, "r+b", bitmap);
+ else
+ bitmap = fopen(bitmap_NAME, "r+b");
+ if (bitmap == NULL)
+ _EscIO(FileNotFound);
+ }
+ mapwidth = pxlinlen * 8;
+ zeropads = 0;
+ maplines = mapheight;
+ if (clipon) /*117:*/
+ { /*115:*/
+ checksum = mapheight * ((mapwidth + 7) / 8);
+ mapheight = 0;
+ freelines = 0;
+ fseek(bitmap, posbit, 0);
+ while (checksum >= pxlinlen) {
+ fread(b1, pxlinlen, 1, bitmap);
+ mapwidth = pxlinlen * 8;
+ j = pxlinlen - 1;
+ while (b1[j] == invbyte && j >= 0)
+ j--;
+ if (j >= 0) {
+ i = 0;
+ while (b1[i] == invbyte && i <= j)
+ i++;
+ if (i < minx)
+ minx = i;
+ lx = j * 8 + 8;
+ cb = b1[j];
+ for (i = 1; i <= 8; i++) {
+ if ((cb & 1) == invbit) {
+ cb >>= 1;
+ lx--;
+ } else
+ i = 8;
+ }
+ if (lx > maxx)
+ maxx = lx;
+ freelines++;
+ mapheight += freelines;
+ freelines = 0;
+ } else if (mapheight == 0)
+ posbit += pxlinlen;
+ else
+ freelines++;
+ checksum -= pxlinlen;
+ }
+/* p2c: bm2font.pas, line 1271:
+ * Note: Can't interpret size in BLOCKREAD [174] */
+ mapwidth = maxx - minx * 8;
+ zeropads = pxlinlen - (mapwidth + 7) / 8;
+ maplines = mapheight;
+ posbit += minx; /*:115*/
+ }
+ i = (mapwidth + hres - 1) / hres;
+ j = (mapheight + vres - 1) / vres;
+ nj = j;
+ nofchars = i * j;
+ mincharpf = 515832L / (vres * ((hres + 31) / 32) * 32);
+ noffonts = (nofchars + mincharpf - 1) / mincharpf;
+ if (noffonts > 52) {
+ printf("Sorry, bitmap is too large! Giving up\n");
+ goto _L9999;
+ }
+ if (mincharpf > 128) { /*:117*/
+ mincharpf = 128;
+ noffonts = (nofchars + 127) / 128;
+ }
+ /*118:*/
+ k = 0;
+ c = 0;
+ while (mapheight > 0) { /*:118*/
+ maxx = mapwidth;
+ while (maxx > 0) {
+ if (maxx > hres)
+ pwidth[k][c] = hres;
+ else
+ pwidth[k][c] = maxx;
+ if (mapheight > vres)
+ pheight[k][c] = vres;
+ else
+ pheight[k][c] = mapheight;
+ dsize = (long)floor(vres / truehres * 72.27 * 65536L * 16 + 0.5);
+ tabdsize[k] = dsize;
+ c++;
+ if (c == mincharpf || mapheight <= vres && maxx <= hres) {
+ FORLIM1 = mincharpf;
+ for (c = 0; c < FORLIM1; c++) {
+ height[k][c] = (long)floor(pheight[k][c] / truevres * 4736286.7227 /
+ dsize * 16777215L + 0.5);
+ width[k]
+ [c] = (long)floor(pwidth[k][c] / truehres * 4736286.7227 / dsize *
+ 16777215L + 0.5);
+ }
+ k++;
+ c = 0;
+ }
+ maxx -= hres;
+ }
+ mapheight -= vres;
+ }
+ maxx = (mapwidth + hres - 1) / hres;
+ f = 0;
+ g = 0;
+ pxlbmi = 4;
+ if (fok) {
+ printf("error occurred when allocating pxlfile ");
+ puts(cmd);
+ fileproblem();
+ goto _L9999;
+ }
+ if (bitmap != NULL)
+ fclose(bitmap);
+ bitmap = NULL;
+ if (bitmap != NULL)
+ bitmap = freopen(bitmap_NAME, "rb", bitmap);
+ else
+ bitmap = fopen(bitmap_NAME, "rb");
+ if (bitmap == NULL)
+ _EscIO(FileNotFound);
+ fonteject(); /*119:*/
+ FORLIM = noffonts;
+ for (a = 0; a < FORLIM; a++) { /*:119*/
+ lh = 17;
+ bc = 0;
+ ec = 127;
+ while (pheight[a][ec] == 0) /*120:*/
+ ec--;
+ sprintf(cmd, "%s%c.tfm", font, fontpre[a]);
+ strcpy(tfmfile_NAME, cmd);
+ if (tfmfile != NULL)
+ tfmfile = freopen(tfmfile_NAME, "w+b", tfmfile);
+ else
+ tfmfile = fopen(tfmfile_NAME, "w+b");
+ _SETIO(tfmfile != NULL, FileNotFound);
+ filestat = P_ioresult;
+ if (filestat == 3 || filestat == 5) {
+ strcpy(cmd, bmname);
+ sprintf(cmd + strlen(cmd), "%c.tfm", fontupc[a]);
+ strcpy(tfmfile_NAME, cmd);
+ if (tfmfile != NULL)
+ tfmfile = freopen(tfmfile_NAME, "w+b", tfmfile);
+ else
+ tfmfile = fopen(tfmfile_NAME, "w+b");
+ _SETIO(tfmfile != NULL, FileNotFound);
+ filestat = P_ioresult;
+ }
+ if (filestat == 0)
+ fok = false;
+ else
+ fok = true;
+ if (fok) {
+ printf("error occurred when allocating tfmfile ");
+ puts(cmd);
+ fileproblem();
+ goto _L9999;
+ }
+ printf("Generating tfmfile %s\n", cmd); /*:120*/
+ dsize = (long)floor(vres / truehres * 72.27 * 65536L * 16 + 0.5);
+ tabdsize[a] = dsize;
+ FORLIM2 = ec;
+ for (k = bc; k <= FORLIM2; k++) {
+ height[a][k] = (long)floor(
+ pheight[a][k] / truevres * 4736286.7227 / dsize * 16777215L + 0.5);
+ width[a][k] = (long)floor(
+ pwidth[a][k] / truehres * 4736286.7227 / dsize * 16777215L + 0.5);
+ }
+ fh = height[a][bc];
+ fw = width[a][bc];
+ sh = fh;
+ sw = fw;
+ nw = 2;
+ nh = 2;
+ FORLIM2 = ec;
+ for (k = bc; k <= FORLIM2; k++) {
+ if (height[a][k] != 0 && height[a][k] != fh && height[a][k] != sh) {
+ sh = height[a][k];
+ nh++;
+ }
+ if (width[a][k] != 0 && width[a][k] != fw && width[a][k] != sw) {
+ sw = width[a][k];
+ nw++;
+ }
+ }
+ if (nh > 3) {
+ printf("more than 2 heights, should be impossible\n");
+ goto _L9999;
+ }
+ if (nw > 3) {
+ printf("more than 2 widths, should be impossible\n");
+ goto _L9999;
+ }
+ nd = 2;
+ ni = 2;
+ nl = 0;
+ nk = 0;
+ ne = 0;
+ np = 0;
+ lf = lh + ec - bc + nw + nh + nd + ni + nk + nl + ne + np + 7;
+ checksum = 0;
+ tfmhword(lf);
+ tfmhword(lh);
+ tfmhword(bc);
+ tfmhword(ec);
+ tfmhword(nw);
+ tfmhword(nh);
+ tfmhword(nd);
+ tfmhword(ni);
+ tfmhword(nl);
+ tfmhword(nk);
+ tfmhword(ne);
+ tfmhword(np);
+ tfmword(checksum);
+ tfmword(dsize);
+ strcpy(tfmstr, "0Graphic");
+ tfmstr[0] = '\007';
+ FORLIM2 = strlen(tfmstr);
+ for (i = 1; i <= FORLIM2; i++) {
+ tfmb = tfmstr[i - 1];
+ fwrite(&tfmb, sizeof(uchar), 1, tfmfile);
+ }
+ tfmb = 0;
+ for (i = 1; i <= 32; i++)
+ fwrite(&tfmb, sizeof(uchar), 1, tfmfile);
+ strcpy(tfmstr, "0Bitmap");
+ tfmstr[0] = '\006';
+ FORLIM2 = strlen(tfmstr);
+ for (i = 1; i <= FORLIM2; i++) {
+ tfmb = tfmstr[i - 1];
+ fwrite(&tfmb, sizeof(uchar), 1, tfmfile);
+ }
+ tfmb = 0;
+ for (i = 1; i <= 13; i++)
+ fwrite(&tfmb, sizeof(uchar), 1, tfmfile);
+ FORLIM2 = ec;
+ for (i = bc; i <= FORLIM2; i++) {
+ if (width[a][i] == 0) {
+ tfmb = 0;
+ fwrite(&tfmb, sizeof(uchar), 1, tfmfile);
+ } else if (width[a][i] == fw) {
+ tfmb = 1;
+ fwrite(&tfmb, sizeof(uchar), 1, tfmfile);
+ } else {
+ tfmb = 2;
+ fwrite(&tfmb, sizeof(uchar), 1, tfmfile);
+ }
+ if (height[a][i] == 0) {
+ tfmb = 0;
+ fwrite(&tfmb, sizeof(uchar), 1, tfmfile);
+ } else if (height[a][i] == fh) {
+ tfmb = 16;
+ fwrite(&tfmb, sizeof(uchar), 1, tfmfile);
+ } else {
+ tfmb = 32;
+ fwrite(&tfmb, sizeof(uchar), 1, tfmfile);
+ }
+ tfmhword(0L);
+ }
+ tfmword(0L);
+ tfmword(fw);
+ if (nw > 2)
+ tfmword(sw);
+ tfmword(0L);
+ tfmword(fh);
+ if (nh > 2)
+ tfmword(sh);
+ tfmword(0L);
+ tfmword(0L);
+ tfmword(0L);
+ tfmword(0L);
+ if (tfmfile != NULL)
+ fclose(tfmfile);
+ tfmfile = NULL;
+ }
+ userhelp(); /*109:*/
+ if (pcxtemp)
+/* p2c: bm2font.pas, line 1353: Note: Called procedure Exec [285] */
+#ifdef MSDOS
+ Exec("del", "pcxtemp.tmp");
+#else
+ Exec("rm", "pcxtemp.tmp");
+#endif
+ if (giftemp)
+/* p2c: bm2font.pas, line 1353: Note: Called procedure Exec [285] */
+#ifdef MSDOS
+ Exec("del", "giftemp.tmp");
+#else
+ Exec("rm", "giftemp.tmp");
+#endif
+ if (greypxl)
+/* p2c: bm2font.pas, line 1353: Note: Called procedure Exec [285] */
+#ifdef MSDOS
+ Exec("del", tmpname);
+#else
+ Exec("rm", tmpname);
+#endif
+ printf("input %s.tex into your document", font);
+ printf(" and set the picture with \\set%s\n", font); /*:109*/
+_L9999:
+ if (texfile != NULL)
+ fclose(texfile);
+ if (bitmap != NULL)
+ fclose(bitmap);
+ if (pxlfile != NULL)
+ fclose(pxlfile);
+ if (tmpfil != NULL)
+ fclose(tmpfil);
+ if (tfmfile != NULL)
+ fclose(tfmfile);
+ exit(EXIT_SUCCESS);
+} /*:106*/
+
+
+
+/* End. */