This is pbmtopk.c in view mode; [Download] [Up]
/*
pbmtopk, adapted from "pxtopk.c by tomas rokicki" by AJCD 1/8/90
compile with: cc -o pbmtopk pbmtopk.c -lm -lpbm
*/
#include <stdio.h>
#include <math.h>
#include <ctype.h>
#include "pbm.h"
#define MAXPKCHAR 256
#define MAXOPTLINE 200
#define MAXWIDTHTAB 256
#define MAXHEIGHTTAB 16
#define MAXDEPTHTAB 16
#define MAXITALICTAB 64
#define MAXPARAMS 30
#define NAMELENGTH 80
#define round(a) ((int)(a+.5))
#define fixword(d) ((int)((double)(d)*1048576))
#define unfixword(f) ((double)(f) / 1048576)
#define fixrange(f) ((f) < 16777216 && (f) > -16777216)
#define designunits(p) ((p)*72.27/(double)resolution/unfixword(designsize))
/* character flags: in order of appearance in option files. */
#define XOFFSET 1
#define YOFFSET 2
#define HORZESC 4
#define VERTESC 8
#define TFMWIDTH 16
#define TFMHEIGHT 32
#define TFMDEPTH 64
#define TFMITALIC 128
typedef int integer ;
typedef char quarterword ;
typedef char boolean ;
typedef quarterword ASCIIcode ;
typedef quarterword eightbits ;
typedef unsigned char byte ;
integer resolution, designsize ;
char *filename[MAXPKCHAR] ;
integer xoffset[MAXPKCHAR] ;
integer yoffset[MAXPKCHAR] ;
integer horzesc[MAXPKCHAR] ;
integer vertesc[MAXPKCHAR] ;
byte tfmindex[MAXPKCHAR] ;
byte hgtindex[MAXPKCHAR] ;
byte depindex[MAXPKCHAR] ;
byte italindex[MAXPKCHAR] ;
byte charflags[MAXPKCHAR] ;
bit **bitmap ;
integer smallestch = MAXPKCHAR ;
integer largestch = -1;
integer emwidth = 0;
integer checksum ;
char *codingscheme = "GRAPHIC" ;
char *familyname = "PBM" ;
integer widthtab[MAXWIDTHTAB] = {0}; /* TFM widths */
integer numwidth = 1; /* number of entries in width table */
integer heighttab[MAXHEIGHTTAB] = {0};
integer numheight = 1;
integer depthtab[MAXDEPTHTAB] = {0};
integer numdepth = 1;
integer italictab[MAXITALICTAB] = {0};
integer numitalic = 1;
integer parameters[MAXPARAMS] = {0};
integer numparam = 0;
static ASCIIcode xord[128] ;
static char xchr[256] = {
'?', '?', '?', '?', '?', '?', '?', '?',
'?', '?', '?', '?', '?', '?', '?', '?',
'?', '?', '?', '?', '?', '?', '?', '?',
'?', '?', '?', '?', '?', '?', '?', '?',
' ', '!', '"', '#', '$', '%', '&', '\'',
'(', ')', '*', '+', ',', '-', '.', '/',
'0', '1', '2', '3', '4', '5', '6', '7',
'8', '9', ':', ';', '<', '=', '>', '?',
'@', 'A', 'B', 'C', 'D', 'E', 'F', 'G',
'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O',
'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W',
'X', 'Y', 'Z', '[', '\\', ']', '^', '_',
'`', 'a', 'b', 'c', 'd', 'e', 'f', 'g',
'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o',
'p', 'q', 'r', 's', 't', 'u', 'v', 'w',
'x', 'y', 'z', '{', '|', '}', '~', '?' };
static FILE *tfmfile, *pkfile ;
static char tfmname[NAMELENGTH+1], pkname[NAMELENGTH+1] ;
static integer pbmtopk_pkloc = 0 ;
static integer bitweight ;
static integer outputbyte ;
static integer car ;
static integer hppp ;
static integer width ;
static integer height ;
/* checksum not computed at the moment
static integer compute_checksum()
{
begin
c0:=bc; c1:=ec; c2:=bc; c3:=ec;
for c:=bc to ec do if char_wd[c]>0 then
begin
temp_width:=memory[char_wd[c]];
if design_units<>unity then
temp_width:=round((temp_width/design_units)*1048576.0);
temp_width:=temp_width + (c+4)*@'20000000; {this should be positive}
c0:=(c0+c0+temp_width) mod 255;
c1:=(c1+c1+temp_width) mod 253;
c2:=(c2+c2+temp_width) mod 251;
c3:=(c3+c3+temp_width) mod 247;
end;
header_bytes[check_sum_loc]:=c0;
header_bytes[check_sum_loc+1]:=c1;
header_bytes[check_sum_loc+2]:=c2;
header_bytes[check_sum_loc+3]:=c3;
end
}
*/
#define add_tfmwidth(v) (add_tfmtable(widthtab, &numwidth, v, MAXWIDTHTAB,\
"TFM width"))
#define add_tfmheight(v) (add_tfmtable(heighttab, &numheight, v, MAXHEIGHTTAB,\
"TFM height"))
#define add_tfmdepth(v) (add_tfmtable(depthtab, &numdepth, v, MAXDEPTHTAB,\
"TFM depth"))
#define add_tfmitalic(v) (add_tfmtable(italictab, &numitalic, v, MAXITALICTAB,\
"Italic correction"))
static byte
add_tfmtable(table, count, value, max_count, name)
integer *table, *count, value, max_count;
char *name;
{
integer i;
for (i = 0; i < *count; i++) /* search for value in tfm table */
if (table[i] == value) return (byte)i;
if (*count >= max_count)
pm_error("too many values in %s table", name) ;
if (!fixrange(value))
pm_error("%s %f for char %d out of range",
name, unfixword(value), car);
table[*count] = value ;
return (*count)++ ;
}
/* add a suffix to a filename in an allocated space */
static void pbmtopk_add_suffix(name, suffix)
char *name, *suffix ;
{
char *slash = rindex(name, '/');
char *dot = rindex(name, '.');
if ((dot && slash ? dot < slash : !dot) && strcmp(name, "-"))
strcat(name, suffix);
}
/* initialize the PK parameters */
static void initialize_pk()
{
integer i ;
pm_message("This is PBMtoPK, version 2.4") ;
for (i = 127 ; i <= 255 ; i ++) xchr[i] = '?' ;
for (i = 0 ; i <= 127 ; i ++) xord[i] = 32 ;
for (i = 32 ; i < 127 ; i ++) xord[(int)xchr[i]] = i ;
for (i = 0; i < MAXPKCHAR; i++) {
filename[i] = NULL;
charflags[i] = 0;
}
designsize = fixword(1.0) ;
}
/* write a single byte to the PK file */
static void pbmtopk_pkbyte(b)
integer b ;
{
if (b < 0) b += 256 ;
putc(b, pkfile) ;
pbmtopk_pkloc++ ;
}
/* write two bytes to the PK file */
static void pkhalfword(a)
integer a ;
{
if (a < 0) a += 65536 ;
pbmtopk_pkbyte(a >> 8) ;
pbmtopk_pkbyte(a & 255) ;
}
/* write three bytes to the PK file */
static void pkthreebytes(a)
integer a ;
{
pbmtopk_pkbyte((a>>16) & 255) ;
pbmtopk_pkbyte((a>>8) & 255) ;
pbmtopk_pkbyte(a & 255) ;
}
/* write four bytes to the PK file */
static void pkword(a)
integer a ;
{
pbmtopk_pkbyte((a>>24) & 255) ;
pbmtopk_pkbyte((a>>16) & 255) ;
pbmtopk_pkbyte((a>>8) & 255) ;
pbmtopk_pkbyte(a & 255) ;
}
/* write a nibble to the PK file */
static void pknyb(a)
integer a ;
{
if (bitweight == 16) {
outputbyte = (a<<4) ;
bitweight = 1 ;
} else {
pbmtopk_pkbyte(outputbyte + a) ;
bitweight = 16 ;
}
}
/* write preamble to PK file */
static void writepreamble()
{
integer i ;
char *comment = "PBMtoPK 2.4 output" ;
pbmtopk_pkbyte(247) ; /* PRE command */
pbmtopk_pkbyte(89) ; /* PK file type */
pbmtopk_pkbyte(strlen(comment)) ; /* output comment */
for (i = 0 ; i < strlen(comment); i++) pbmtopk_pkbyte(xord[(int)comment[i]]) ;
pkword(designsize) ; /* write designsize */
pkword(checksum) ; /* write checksum; calculate if possible */
pkword(hppp) ; /* write H pixels per point */
pkword(hppp) ; /* write V pixels per point */
}
/* write postamble to PK file, padded to word length */
static void writepostamble()
{
pbmtopk_pkbyte(245) ; /* POST command */
while (pbmtopk_pkloc % 4)
pbmtopk_pkbyte(246) ; /* pad with no-ops */
pm_message("%d bytes written to packed file.", pbmtopk_pkloc) ;
}
/* write a byte to the TFM file */
static void tfmbyte(b)
integer b ;
{
if (b < 0) b += 256 ;
putc(b, tfmfile) ;
}
/* write a half word to the TFM file */
static void tfmhalfword(a)
integer a ;
{
if (a < 0) a += 65536 ;
tfmbyte(a >> 8) ;
tfmbyte(a & 255) ;
}
/* write a word to the TFM file */
static void tfmword(a)
integer a ;
{
tfmbyte((a>>24) & 255) ;
tfmbyte((a>>16) & 255) ;
tfmbyte((a>>8) & 255) ;
tfmbyte(a & 255) ;
}
/* write the whole TFM file for the font */
static void writetfmfile()
{
integer totallength ;
integer headersize = 17;
integer i ;
if (largestch - smallestch < 0) {
largestch = 0;
smallestch = 1;
}
if (numparam < 7) /* set default parameters */
switch (numparam) {
case 0: /* slant */
parameters[numparam++] = 0 ;
case 1: /* space */
parameters[numparam++] = fixword(designunits(emwidth/3.0));
case 2: /* space_stretch */
parameters[numparam++] = fixword(unfixword(parameters[1])/2.0) ;
case 3: /* space_shrink */
parameters[numparam++] = fixword(unfixword(parameters[1])/3.0) ;
case 4: /* x_height */
parameters[numparam++] = fixword(0.45);
case 5: /* quad */
parameters[numparam++] = fixword(designunits(emwidth)) ;
case 6: /* extra_space */
parameters[numparam++] = fixword(unfixword(parameters[1])/3.0) ;
}
totallength = 6 + headersize + (largestch+1-smallestch) +
numwidth + numheight + numdepth + numitalic + numparam ;
/* lengths */
tfmhalfword(totallength) ; /* write file TFM length */
tfmhalfword(headersize) ; /* write TFM header length */
tfmhalfword(smallestch) ; /* write lowest char index */
tfmhalfword(largestch) ; /* write highest char index */
tfmhalfword(numwidth) ; /* write number of widths */
tfmhalfword(numheight) ; /* write number of heights */
tfmhalfword(numdepth) ; /* write number of depths */
tfmhalfword(numitalic) ; /* write number of italcorrs */
tfmhalfword(0) ; /* lig/kern table */
tfmhalfword(0) ; /* kern table */
tfmhalfword(0) ; /* extensible char table */
tfmhalfword(numparam) ; /* number of fontdimens */
/* header */
tfmword(checksum) ; /* write checksum */
tfmword(designsize) ; /* write designsize */
if (strlen(codingscheme) > 39) tfmbyte(39) ; /* write coding scheme len */
else tfmbyte(strlen(codingscheme)) ;
for (i = 0; i < 39; i++) /* write coding scheme */
if (*codingscheme) tfmbyte(xord[(int)(*codingscheme++)]) ;
else tfmbyte(0) ;
if (strlen(familyname) > 19) tfmbyte(19) ; /* write family length */
else tfmbyte(strlen(familyname)) ;
for (i = 0; i < 19; i++) /* write family */
if (*familyname) tfmbyte(xord[(int)(*familyname++)]) ;
else tfmbyte(0) ;
/* char_info */
for (car = smallestch; car <= largestch; car++)
if (filename[car]) { /* write character info */
tfmbyte(tfmindex[car]) ;
tfmbyte((hgtindex[car]<<4) + depindex[car]) ;
tfmbyte(italindex[car]<<2) ;
tfmbyte(0) ;
} else tfmword(0) ;
/* width table */
for (i = 0; i < numwidth; i++) tfmword(widthtab[i]) ;
/* height table */
for (i = 0; i < numheight; i++) tfmword(heighttab[i]) ;
/* depth table */
for (i = 0; i < numdepth; i++) tfmword(depthtab[i]) ;
/* italic correction table */
for (i = 0; i < numitalic; i++) tfmword(italictab[i]) ;
/* no lig_kern, kern, or exten tables */
/* fontdimen table */
for (i = 0; i < numparam; i++)
if (i && !fixrange(parameters[i]))
pm_error("parameter %d out of range (-p)", i);
else
tfmword(parameters[i]) ;
pm_message("%d bytes written to tfm file.", totallength*4) ;
}
/* read a character from a PBM file */
static void readcharacter()
{
FILE *fp;
fp = pm_openr(filename[car]);
bitmap = pbm_readpbm(fp, &width, &height) ;
pm_close(fp) ;
if ((charflags[car] & HORZESC) == 0) horzesc[car] = width ;
if ((charflags[car] & VERTESC) == 0) vertesc[car] = 0;
if ((charflags[car] & XOFFSET) == 0) xoffset[car] = 0;
if ((charflags[car] & YOFFSET) == 0) yoffset[car] = height-1;
if ((charflags[car] & TFMWIDTH) == 0)
tfmindex[car] = add_tfmwidth(fixword(designunits(width)));
if ((charflags[car] & TFMHEIGHT) == 0)
hgtindex[car] = add_tfmheight(fixword(designunits(yoffset[car]+1)));
if ((charflags[car] & TFMDEPTH) == 0)
depindex[car] = add_tfmdepth(fixword(designunits(height-1-yoffset[car])));
if ((charflags[car] & TFMITALIC) == 0) italindex[car] = 0;
if (car < smallestch) smallestch = car;
if (car > largestch) largestch = car;
if (width > emwidth) emwidth = width ;
}
/* test if two rows of the PBM are the same */
static int equal(row1, row2)
bit *row1, *row2 ;
{
integer i ;
for (i = 0; i < width; i++)
if (row1[i] != row2[i]) return (0) ;
return(1) ;
}
static void shipcharacter()
{
integer compsize ;
integer i, j, k ;
bit *zerorow, *onesrow ;
integer *repeatptr, *bitcounts ;
integer count ;
integer test ;
integer curptr, rowptr ;
integer bitval ;
integer repeatflag ;
integer colptr ;
integer currepeat ;
integer dynf ;
integer deriv[14] ;
integer bcompsize ;
boolean firston ;
integer flagbyte ;
boolean state ;
boolean on ;
integer hbit ;
integer pbit ;
boolean ron, son ;
integer rcount, scount ;
integer ri, si ;
integer max2 ;
integer predpkloc ;
integer buff ;
integer tfwid = widthtab[tfmindex[car]] ;
integer hesc = horzesc[car] ;
integer vesc = vertesc[car] ;
integer xoff = xoffset[car] ;
integer yoff = yoffset[car] ;
repeatptr =
(integer *)malloc((unsigned int)((height+1)*sizeof(integer))) ;
bitcounts =
(integer *)malloc((unsigned int)((height*width)*sizeof(integer))) ;
if (repeatptr == NULL || bitcounts == NULL)
pm_error("out of memory while allocating bit counts");
zerorow = pbm_allocrow(width) ; /* initialise plain rows */
onesrow = pbm_allocrow(width) ;
for (i = 0 ; i < width ; i++) {
zerorow[i] = PBM_WHITE ;
onesrow[i] = PBM_BLACK ;
}
for (i=0; i < height; i = k) { /* set repeat pointers */
k = i + 1;
if (!equal(bitmap[i], zerorow) && !equal(bitmap[i], onesrow)) {
while (k < height && equal(bitmap[i], bitmap[k]))
k++;
repeatptr[i] = k - i - 1;
} else {
repeatptr[i] = 0;
}
}
repeatptr[height] = 0 ;
colptr = width - 1 ;
repeatflag = currepeat = curptr = count = rowptr = 0 ;
test = PBM_WHITE ;
do {
colptr++ ;
if (colptr == width) { /* end of row, get next row */
colptr = 0 ;
rowptr = currepeat ;
if (repeatptr[currepeat] > 0) {
repeatflag = repeatptr[currepeat] ;
currepeat += repeatflag ;
rowptr += repeatflag ;
}
currepeat++ ;
}
if (rowptr >= height) bitval = -1 ;
else bitval = bitmap[rowptr][colptr] ;
if (bitval == test) count++ ; /* count repeated pixels */
else { /* end of pixel run */
bitcounts[curptr++] = count ;
if (curptr+3 >= height*width)
pm_error("out of memory while saving character counts");
count = 1 ;
test = bitval ;
if (repeatflag > 0) {
bitcounts[curptr++] = -repeatflag ;
repeatflag = 0 ;
}
}
} while (test != -1) ;
bitcounts[curptr] = 0 ;
bitcounts[curptr + 1] = 0 ;
for (i = 1 ; i <= 13 ; i ++) deriv[i] = 0 ;
i = firston = (bitcounts[0] == 0) ;
compsize = 0 ;
while (bitcounts[i] != 0) { /* calculate dyn_f */
j = bitcounts[i] ;
if (j == -1) compsize++ ;
else {
if (j < 0) {
compsize++ ;
j = -j ;
}
if (j < 209) compsize += 2 ;
else {
k = j - 193 ;
while (k >= 16) {
k >>= 4 ;
compsize += 2 ;
}
compsize++ ;
}
if (j < 14) (deriv[j])-- ;
else if (j < 209) (deriv[(223 - j) / 15])++ ;
else {
k = 16 ;
while (((k<<4) < j + 3)) k <<= 4 ;
if (j - k <= 192)
deriv[(207 - j + k) / 15] += 2 ;
}
}
i++ ;
}
bcompsize = compsize ;
dynf = 0 ;
for (i = 1 ; i <= 13 ; i ++) {
compsize += deriv[i] ;
if (compsize <= bcompsize) {
bcompsize = compsize ;
dynf = i ;
}
}
compsize = ((bcompsize + 1)>>1) ;
if ((compsize > ((height*width+7)>>3)) || (height*width == 0)) {
compsize = ((height*width+7)>>3) ;
dynf = 14 ;
}
flagbyte = (dynf<<4) ;
if (firston) flagbyte |= 8 ;
if (tfwid > 16777215 || tfwid < 0 || hesc < 0 || vesc != 0 ||
compsize > 196579 || width > 65535 || height > 65535 ||
xoff > 32767 || yoff > 32767 || xoff < -32768 || yoff < -32768) {
flagbyte |= 7 ; /* long form preamble */
pbmtopk_pkbyte(flagbyte) ;
compsize += 28 ;
pkword(compsize) ; /* char packet size */
pkword(car) ; /* character number */
predpkloc = pbmtopk_pkloc + compsize ;
pkword(tfwid) ; /* TFM width */
pkword(hesc<<16) ; /* horiz escapement */
pkword(vesc<<16) ; /* vert escapement */
pkword(width) ; /* bounding box width */
pkword(height) ; /* bounding box height */
pkword(xoff) ; /* horiz offset */
pkword(yoff) ; /* vert offset */
} else if (hesc > 255 || width > 255 || height > 255 ||
xoff > 127 || yoff > 127 || xoff < -128 ||
yoff < -128 || compsize > 1016) {
compsize += 13 ; /* extended short preamble */
flagbyte += (compsize>>16) + 4 ;
pbmtopk_pkbyte(flagbyte) ;
pkhalfword(compsize & 65535) ; /* char packet size */
pbmtopk_pkbyte(car) ; /* character number */
predpkloc = pbmtopk_pkloc + compsize ;
pkthreebytes(tfwid) ; /* TFM width */
pkhalfword(hesc) ; /* horiz escapement */
pkhalfword(width) ; /* bounding box width */
pkhalfword(height) ; /* bounding box height */
pkhalfword(xoff) ; /* horiz offset */
pkhalfword(yoff) ; /* vert offset */
} else {
compsize += 8 ; /* short form preamble */
flagbyte = flagbyte + (compsize>>8) ;
pbmtopk_pkbyte(flagbyte) ;
pbmtopk_pkbyte(compsize & 255) ; /* char packet size */
pbmtopk_pkbyte(car) ; /* character number */
predpkloc = pbmtopk_pkloc + compsize ;
pkthreebytes(tfwid) ; /* TFM width */
pbmtopk_pkbyte(hesc) ; /* horiz escapement */
pbmtopk_pkbyte(width) ; /* bounding box width */
pbmtopk_pkbyte(height) ; /* bounding box height */
pbmtopk_pkbyte(xoff) ; /* horiz offset */
pbmtopk_pkbyte(yoff) ; /* vert offset */
}
if (dynf != 14) { /* write packed character */
bitweight = 16 ;
max2 = 208 - 15 * dynf ;
i = firston ;
while (bitcounts[i] != 0) {
j = bitcounts[i] ;
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 -= max2 - 15 ;
k = 16 ;
while (k <= j) {
k <<= 4 ;
pknyb(0) ;
}
while (k > 1) {
k >>= 4 ;
pknyb(j / k) ;
j = j % k ;
}
}
}
i++ ;
}
if (bitweight != 16) pbmtopk_pkbyte(outputbyte) ;
} else { /* write bitmap character */
buff = 0 ;
pbit = 8 ;
i = firston ;
hbit = width ;
on = ! firston ;
state = 0 ;
count = repeatflag = 0 ;
while ((bitcounts[i] != 0) || state || (count > 0)) {
if (state) {
count = rcount ;
i = ri ;
on = ron ;
repeatflag-- ;
} else {
rcount = count ;
ri = i ;
ron = on ;
}
do {
if (count == 0) {
if (bitcounts[i] < 0) {
if (! state) repeatflag = -bitcounts[i] ;
i++ ;
}
count = bitcounts[i] ;
i++ ;
on = !on ;
}
if ((count >= pbit) && (pbit < hbit)) {
if (on) buff += (1 << pbit) - 1 ;
pbmtopk_pkbyte(buff) ;
buff = 0 ;
hbit -= pbit ;
count -= pbit ;
pbit = 8 ;
} else if ((count < pbit) && (count < hbit)) {
if (on) buff += (1 << pbit) - (1 << (pbit - count)) ;
pbit -= count ;
hbit -= count ;
count = 0 ;
} else {
if (on) buff += (1 << pbit) - (1 << (pbit - hbit)) ;
count -= hbit ;
pbit -= hbit ;
hbit = width ;
if (pbit == 0) {
pbmtopk_pkbyte(buff) ;
buff = 0 ;
pbit = 8 ;
}
}
} while (hbit != width) ;
if (state && (repeatflag == 0)) {
count = scount ;
i = si ;
on = son ;
state = 0 ;
} else if (! state && (repeatflag > 0)) {
scount = count ;
si = i ;
son = on ;
state = 1 ;
}
}
if (pbit != 8) pbmtopk_pkbyte(buff) ;
}
if (predpkloc != pbmtopk_pkloc)
pm_error("bad predicted character length: character %d", car);
pbm_freerow(zerorow);
pbm_freerow(onesrow);
free((char *)repeatptr);
free((char *)bitcounts);
}
/* check that character is in valid range */
static void checkchar()
{
if (car < 0 || car >= MAXPKCHAR)
pm_error("character must be in range 0 to %d", MAXPKCHAR-1) ;
}
/* read character information from an option file */
static void optionfile(name)
char *name ;
{
FILE *fp ;
char buffer[MAXOPTLINE] ;
fp = pm_openr(name);
while (!feof(fp)) {
char *here = buffer;
if (fgets(buffer, MAXOPTLINE, fp) == NULL) break ;
while (isspace(*here)) here++ ;
if (*here && *here == '=') {
if (sscanf(here+1, "%d", &car) != 1)
pm_error("bad option file line %s", buffer) ;
} else if (*here && *here != '%' && *here != '#') {
char str[NAMELENGTH] ;
integer i, n;
checkchar() ;
if (sscanf(here, "%s%n", str, &n) != 1)
pm_error("bad option file line %s", buffer) ;
filename[car] =
(char *)malloc((unsigned int)(sizeof(char)*(strlen(str)+1))) ;
if (filename[car] == NULL)
pm_error("out of memory allocating filename %s", str);
strcpy(filename[car], str) ;
for (i = 1; i < 256; i<<=1) {
here += n;
if (sscanf(here, "%s%n", str, &n) != 1) break ;
if (strcmp(str, "*")) {
charflags[car] |= i ;
switch (i) {
case XOFFSET:
xoffset[car] = atoi(str) ;
break ;
case YOFFSET:
yoffset[car] = atoi(str) ;
break ;
case HORZESC:
horzesc[car] = atoi(str) ;
break ;
case VERTESC:
vertesc[car] = atoi(str) ;
break ;
case TFMWIDTH:
tfmindex[car] = add_tfmwidth(fixword(atof(str))) ;
break ;
case TFMHEIGHT:
hgtindex[car] = add_tfmheight(fixword(atof(str))) ;
break ;
case TFMDEPTH:
depindex[car] = add_tfmdepth(fixword(atof(str))) ;
break ;
case TFMITALIC:
italindex[car] = add_tfmitalic(fixword(atof(str))) ;
break ;
}
}
}
car++ ;
}
}
pm_close(fp) ;
}
int
main(argc, argv)
int argc ;
char *argv[] ;
{
integer i, hesc, vesc, xoff, yoff, tfwid, tfdep, tfhgt, tfital ;
byte flags ;
char *usage = "pkfile[.pk] tfmfile[.tfm] dpi [-s designsize] [-p num param...]\n\
[-C codingscheme ] [-F family] [-c num | <char>]...\n\
<char> is:\n\
[-W tfmwidth] [-H tfmheight] [-D tfmdepth] [-I ital_corr] [-h horiz]\n\
[-v vert] [-x xoffset] [-y yoffset] file\n\
or:\n\
-f optfile\n" ;
pbm_init(&argc, argv);
initialize_pk() ;
if (--argc < 1) pm_usage(usage) ;
strcpy(pkname, *++argv) ;
pbmtopk_add_suffix(pkname, ".pk") ;
if (--argc < 1) pm_usage(usage) ;
strcpy(tfmname, *++argv) ;
pbmtopk_add_suffix(tfmname, ".tfm") ;
if (--argc < 1) pm_usage(usage) ;
resolution = atoi(*++argv) ;
if (resolution < 1 || resolution > 32767)
pm_error("unlikely resolution %d dpi", resolution);
car = flags = hesc = vesc = xoff = yoff = tfwid = 0;
while (++argv, --argc) {
if (argv[0][0] == '-' && argv[0][1]) {
char c, *p;
c = argv[0][1] ;
if (argv[0][2]) p = *argv + 2 ; /* set argument pointer */
else if (++argv, --argc) p = *argv ;
else pm_usage(usage) ;
switch (c) {
case 'C':
codingscheme = p;
break ;
case 'F':
familyname = p;
break ;
case 'c':
car = atoi(p) ;
break ;
case 's':
designsize = fixword(atof(p));
if (designsize < 1048576)
pm_error("design size %f out of range", unfixword(designsize));
case 'h':
hesc = atoi(p) ;
flags |= HORZESC ;
break ;
case 'v':
vesc = atoi(p) ;
flags |= VERTESC ;
break ;
case 'x':
xoff = atoi(p) ;
flags |= XOFFSET ;
break ;
case 'y':
yoff = atoi(p) ;
flags |= YOFFSET ;
break ;
case 'W':
tfwid = fixword(atof(p)) ;
flags |= TFMWIDTH ;
break ;
case 'H':
tfhgt = fixword(atof(p)) ;
flags |= TFMHEIGHT ;
break ;
case 'D':
tfdep = fixword(atof(p)) ;
flags |= TFMDEPTH ;
break ;
case 'I':
tfital = fixword(atof(p)) ;
flags |= TFMITALIC ;
break ;
case 'f':
optionfile(p) ;
break ;
case 'p':
numparam = atoi(p);
if (numparam < 1 || numparam > MAXPARAMS)
pm_error("parameter count %d out of range", numparam);
for (i=0; i<numparam; i++)
if (++argv,--argc)
parameters[i] = fixword(atof(*argv)) ;
else
pm_error("not enough parameters (-p)");
break ;
default:
pm_usage(usage) ;
}
} else {
checkchar() ;
if (flags & TFMWIDTH)
tfmindex[car] = add_tfmwidth(tfwid);
if (flags & TFMDEPTH)
depindex[car] = add_tfmdepth(tfdep);
if (flags & TFMHEIGHT)
hgtindex[car] = add_tfmheight(tfhgt);
if (flags & TFMITALIC)
italindex[car] = add_tfmitalic(tfital);
horzesc[car] = hesc ;
vertesc[car] = vesc ;
xoffset[car] = xoff ;
yoffset[car] = yoff ;
filename[car] = *argv ;
charflags[car] = flags ;
car++ ;
flags = 0;
}
}
hppp = round((resolution<<16) / 72.27) ;
pkfile = pm_openw(pkname);
tfmfile = pm_openw(tfmname);
writepreamble() ;
for (car = 0 ; car < MAXPKCHAR ; car++)
if (filename[car]) {
readcharacter() ;
shipcharacter() ;
}
writepostamble() ;
writetfmfile() ;
pm_close(pkfile) ;
pm_close(tfmfile) ;
exit(0);
}
These are the contents of the former NiCE NeXT User Group NeXTSTEP/OpenStep software archive, currently hosted by Netfuture.ch.