v20i032: hp2pk - HP font conversion tool, Part02/04

Steve McConnel steve at txsil.sil.org
Mon Jun 3 12:11:52 AEST 1991


Submitted-by: Steve McConnel <steve at txsil.sil.org>
Posting-number: Volume 20, Issue 32
Archive-name: hp2pk/part02

#! /bin/sh
# This is a shell archive.  Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file".  To overwrite existing
# files, type "sh file -c".  You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g..  If this archive is complete, you
# will see the following message at the end:
#		"End of archive 2 (of 4)."
# Contents:  bigendio.c fixnum.c hp2pk.lpt myalloc.c writepl.c
#   writetfm.c
# Wrapped by steve at txsil on Thu May 30 10:36:55 1991
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'bigendio.c' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'bigendio.c'\"
else
echo shar: Extracting \"'bigendio.c'\" \(5783 characters\)
sed "s/^X//" >'bigendio.c' <<'END_OF_FILE'
X/*  BIGENDIO.C - binary I/O for big-endian values
X ***************************************************************************
X *
X *	signed char get_byte(fp)
X *	FILE *fp;
X *
X *	unsigned char get_ubyte(fp)
X *	FILE *fp;
X *
X *	short get_halfword(fp)
X *	FILE *fp;
X *
X *	unsigned short get_uhalfword(fp)
X *	FILE *fp;
X *
X *	long get_3_bytes(fp)
X *	FILE *fp;
X *
X *	long get_fullword(fp)
X *	FILE *fp;
X *
X *	unsigned long get_ufullword(fp)
X *	FILE *fp;
X *
X *	void put_fullword(val, fp)
X *	long val;
X *	FILE *fp;
X *
X *	void put_3_bytes(i,fp)
X *	long i;
X *	FILE *fp;
X *
X *	void put_halfword(val, fp)
X *	short val;
X *	FILE *fp;
X *
X ***************************************************************************
X *	EDIT HISTORY
X *	19-Oct-90	Steve McConnel - finish writing generalized functions
X *	20-Oct-90	SRMc - rename some functions for consistency
X *	15-Jan-91	SRMc - fix for Macintosh Lightspeed THINK C
X *	12-Apr-91	SRMc - add coercion of long to int in putc() calls
X ***************************************************************************
X * Copyright 1990, 1991 by the Summer Institute of Linguistics, Inc.
X * All rights reserved.
X */
X#include <stdio.h>
X#ifdef THINK_C
X#define signed
X#endif
X
Xextern void exit();
X
X/****************************************************************************
X * NAME
X *    bad_eof
X * ARGUMENTS
X *    none
X * DESCRIPTION
X *    Annouce an unexpected EOF and abort the program.
X * RETURN VALUE
X *    none
X */
Xstatic void bad_eof()
X{
Xfflush(stdout);
Xfprintf(stderr, "\nUnexpected end of input file.\n");
Xexit(1);
X}
X
X/****************************************************************************
X * NAME
X *    get_byte
X * ARGUMENTS
X *    fp - input FILE pointer
X * DESCRIPTION
X *    Get a one-byte signed integer from the HP soft font file.
X * RETURN VALUE
X *    the signed 8-bit value
X */
Xsigned char get_byte(fp)
XFILE *fp;
X{
Xint b;
X
Xb = getc(fp);
Xif (b == EOF)
X    bad_eof();
Xreturn( (signed char)b );
X}
X
X/****************************************************************************
X * NAME
X *    get_ubyte
X * ARGUMENTS
X *    fp - input FILE pointer
X * DESCRIPTION
X *    Get a one-byte unsigned integer from the HP soft font file.
X * RETURN VALUE
X *    the unsigned 8-bit value
X */
Xunsigned char get_ubyte(fp)
XFILE *fp;
X{
Xint b;
X
Xb = getc(fp);
Xif (b == EOF)
X    bad_eof();
Xreturn( (unsigned char)b );
X}
X
X/****************************************************************************
X * NAME
X *    get_halfword
X * ARGUMENTS
X *    fp - input FILE pointer
X * DESCRIPTION
X *    Get a two-byte bigendian signed integer from the HP soft font file.
X * RETURN VALUE
X *    the signed 16-bit value
X */
Xshort get_halfword(fp)
XFILE *fp;
X{
Xshort i;
X
Xi = get_ubyte(fp);
Xi = (i << 8) + get_ubyte(fp);
Xreturn(i);
X}
X
X/****************************************************************************
X * NAME
X *    get_uhalfword
X * ARGUMENTS
X *    fp - input FILE pointer
X * DESCRIPTION
X *    Get a two-byte bigendian unsigned integer from the HP soft font file.
X * RETURN VALUE
X *    the unsigned 16-bit value
X */
Xunsigned short get_uhalfword(fp)
XFILE *fp;
X{
Xunsigned short i;
X
Xi = get_ubyte(fp);
Xi = (i << 8) + get_ubyte(fp);
Xreturn( i );
X}
X
X/****************************************************************************
X * NAME
X *    get_3_bytes
X * ARGUMENTS
X *    fp - input FILE pointer
X * DESCRIPTION
X *    Get a three-byte bigendian unsigned integer from the HP soft font file.
X * RETURN VALUE
X *    the 24-bit value
X */
Xlong get_3_bytes(fp)
XFILE *fp;
X{
Xlong i;
X
Xi = get_ubyte(fp);
Xi = (i << 8) + get_ubyte(fp);
Xi = (i << 8) + get_ubyte(fp);
Xreturn( i );
X}
X
X/****************************************************************************
X * NAME
X *    get_fullword
X * ARGUMENTS
X *    fp - input FILE pointer
X * DESCRIPTION
X *    Get a four-byte bigendian integer from the HP soft font file.
X * RETURN VALUE
X *    the 32-bit value
X */
Xlong get_fullword(fp)
XFILE *fp;
X{
Xlong i;
X
Xi = get_ubyte(fp);
Xi = (i << 8) + get_ubyte(fp);
Xi = (i << 8) + get_ubyte(fp);
Xi = (i << 8) + get_ubyte(fp);
Xreturn( i );
X}
X
X/****************************************************************************
X * NAME
X *    get_ufullword
X * ARGUMENTS
X *    fp - input FILE pointer
X * DESCRIPTION
X *    Get a four-byte bigendian unsigned integer from the HP soft font file.
X * RETURN VALUE
X *    the unsigned 32-bit value
X */
Xunsigned long get_ufullword(fp)
XFILE *fp;
X{
Xunsigned long i;
X
Xi = get_ubyte(fp);
Xi = (i << 8) + get_ubyte(fp);
Xi = (i << 8) + get_ubyte(fp);
Xi = (i << 8) + get_ubyte(fp);
Xreturn( i );
X}
X
X/****************************************************************************
X * NAME
X *    put_fullword
X * ARGUMENTS
X *    val - 32-bit integer to write
X *    fp  - FILE pointer
X * DESCRIPTION
X *    Write a 32-bit binary integer to a file.
X * RETURN VALUE
X *    none
X */
Xvoid put_fullword(val, fp)
Xlong val;
XFILE *fp;
X{
Xputc( (int)((val >> 24) & 0xFF), fp);
Xputc( (int)((val >> 16) & 0xFF), fp);
Xputc( (int)((val >> 8)  & 0xFF), fp);
Xputc( (int)( val        & 0xFF), fp);
X}
X
X/****************************************************************************
X * NAME
X *    put_3_bytes
X * ARGUMENTS
X *    i  - 24-bit value for output
X *    fp - output FILE pointer
X * DESCRIPTION
X *    Write a three-byte (24-bit) value to the file.
X * RETURN VALUE
X *    none
X */
Xvoid put_3_bytes(i,fp)
Xlong i;
XFILE *fp;
X{
Xputc( (int)((i >> 16) & 0xFF), fp);
Xputc( (int)((i >>  8) & 0xFF), fp);
Xputc( (int)( i        & 0xFF), fp);
X}
X
X/****************************************************************************
X * NAME
X *    put_halfword
X * ARGUMENTS
X *    val - 16-bit integer to write
X *    fp  - FILE pointer
X * DESCRIPTION
X *    Write a 16-bit binary integer to a file.
X * RETURN VALUE
X *    none
X */
Xvoid put_halfword(val, fp)
Xshort val;
XFILE *fp;
X{
Xputc( (val >> 8) & 0xFF, fp);
Xputc(  val       & 0xFF, fp);
X}
END_OF_FILE
if test 5783 -ne `wc -c <'bigendio.c'`; then
    echo shar: \"'bigendio.c'\" unpacked with wrong size!
fi
# end of 'bigendio.c'
fi
if test -f 'fixnum.c' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'fixnum.c'\"
else
echo shar: Extracting \"'fixnum.c'\" \(5176 characters\)
sed "s/^X//" >'fixnum.c' <<'END_OF_FILE'
X/*  FIXNUM.C - functions to convert between fixed-pointed numbers and strings
X ***************************************************************************
X *
X *	fixnum str_to_fixnum(str)
X *	char *str;
X *
X *	char *fixnum_to_str(x, buf, numdig)
X *	fixnum x;
X *	char buf[];
X *	int numdig;
X *
X ***************************************************************************
X *	EDIT HISTORY
X *	19-Oct-90	Steve McConnel - finish writing generalized functions
X *				that don't depend on floating point
X *	20-Oct-90	SRMc - remove I/O functions
X ***************************************************************************
X * Copyright 1990 by the Summer Institute of Linguistics, Inc.
X * All rights reserved.
X */
X#include <stdio.h>
X#include <ctype.h>
X#include "fixnum.h"
X
X/************************************************************************/
X/*			STATIC GLOBAL VARIABLES				*/
X/************************************************************************/
X
Xstatic unsigned long tenpow[10] = { 0,
X    0631463146L,	/* 0.1 */    /* Knuth, vol. 2 (2nd ed.), page 660 */
X    0050753412L,	/* 0.01 */   /* 30-bit fractions */
X    0004061116L,	/* 0.001 */	/* since we end up with 20-bit */
X    0000321556L,	/* 0.0001 */	/* fractions, these should */
X    0000024761L,	/* 0.00001 */	/* provide enough precision */
X    0000002062L,	/* 0.000001 */
X    0000000153L,	/* 0.0000001 */
X    0000000013L,	/* 0.00000001 */
X    0000000001L		/* 0.000000001 */
X    };
X
X/****************************************************************************
X * NAME
X *    str_to_fixnum
X * ARGUMENTS
X *    str - string containing fixed-point number
X * DESCRIPTION
X *    Convert ASCII character string to a fixnum binary value.
X * RETURN VALUE
X *    "fixnum" value
X */
Xfixnum str_to_fixnum(str)
Xchar *str;
X{
Xchar *p;		/* pointer into fixed-point number string */
Xlong i;			/* integer part, then entire fixnum value */
Xunsigned long f;	/* fraction part of fixnum value */
Xlong k;			/* fraction bits thrown away -- useful for rounding */
Xint neg;		/* flag negative value */
Xint log;		/* number of decimal digits processed */
X
Xfor ( p = str ; isascii(*p) && isspace(*p) ; ++p )
X    ;
Xif (*p == '-')
X    {
X    neg = 1;
X    ++p;
X    }
Xelse
X    neg = 0;
X
Xif ( !isascii(*p) || !isdigit(*p) )
X    return( 0L );
X
Xfor ( i = 0 ; isascii(*p) && isdigit(*p) ; ++p)
X    i = (i * 10) + (*p - '0');
X
Xif (i > 2047)
X    return( 0x80000000 );	/* overflow condition actually */
Xi = int_to_fixnum(i);
X
Xif (*p++ != '.')
X    return( (neg) ? -i : i );
X/*
X *  convert the fraction part of the number
X */
Xfor ( f = 0, log = 1 ; isascii(*p) && isdigit(*p) && (log < 10) ; ++log )
X    f += (*p++ - '0') * tenpow[log];
X
Xk = f & 0x000003FFL;
Xf >>= 10;	/* convert from 30-bit fraction to 20-bit fraction */
X/*
X *  merge the fraction and the integer parts
X */
Xi = i | f;
Xif (k > 0x00000200L)
X    ++i;		/* round up the LSB */
Xreturn( (neg) ? -i : i );
X}
X
X/****************************************************************************
X * NAME
X *    fixnum_to_str
X * ARGUMENTS
X *    x      - fixed-point fraction to turn into a string
X *    buf    - character array for holding fixed-point number string
X *    numdig - number of decimal places to expand (buffer must hold at
X *		least 7 more bytes for results like "-2047.xxxxxx\0")
X * DESCRIPTION
X *    Convert a fixnum binary value to an ASCII character string.
X * RETURN VALUE
X *    address of buffer (i.e., buf)
X */
Xchar *fixnum_to_str(x, buf, numdig)
Xfixnum x;
Xchar buf[];
Xint numdig;
X{
Xlong ix;
Xchar *p;
Xint j;		/* index into buf[] of last character added */
Xchar tbuf[6];	/* temporary scratch buffer */
Xint carry;	/* carry flag for rounding up the number string */
Xchar *q;	/* pointer used in shuffling result to add new top digit */
X/*
X *  check for a minus sign
X */
Xj = 0;
Xif (x < 0L)
X    {
X    buf[j++] = '-';
X    x = -x;
X    }
Xix = fixnum_to_int(x) & 0x00000FFFL;	/* handle -2048.xxx properly */
X/*
X *  work through the integer part of the number
X *  (the digits come out in reverse order with the simplest algorithm)
X */
Xfor ( p = tbuf ; ix ; ix /= 10 )
X    *p++ = (ix % 10) + '0';
Xif (p == tbuf)			/* allow for value == 0 */
X    *p++ = '0';
Xwhile ( p > tbuf )		/* put the digits in the proper order */
X    buf[j++] = (*--p);
X
Xif (numdig <= 0)
X    {
X    buf[j] = '\0';		/* no fraction wanted! */
X    return(buf);
X    }
Xbuf[j++] = '.';
X/*
X *  convert the fraction
X */
Xfor ( ix = x & 0x000FFFFFL ; numdig > 0 ; --numdig )
X    {
X    ix *= 10;
X    buf[j++] = fixnum_to_int(ix) + '0';
X    ix &= 0x000FFFFFL;
X    }
Xif (ix > 0x00080000L)
X    {
X    /*
X     *  round up.  this can be rather a pain!
X     */
X    for ( carry = 1, p = &buf[j-1] ; (p >= buf) && carry ; --p )
X	{
X	if (isdigit(*p))	/* skip over decimal point */
X	    {
X	    ++(*p);			/* add the carry bit */
X	    if (*p > '9')		/* check for overflow */
X		{
X		*p -= 10;
X		carry = 1;
X		}
X	    else
X		carry = 0;
X	    }
X	}
X    if (carry)
X	{
X	/*
X	 *  make room for adding another digit to the integer
X	 */
X	for ( p = &buf[j], q = &buf[j+1] ; p >= buf ; *q-- = *p-- )
X	    ;
X	++j;			/* add to end-of-string index */
X	if (buf[1] == '-')
X	    {
X	    buf[0] = '-';
X	    buf[1] = '1';
X	    }
X	else
X	    buf[0] = '1';
X	}
X    }
Xbuf[j] = '\0';
Xreturn(buf);
X}
END_OF_FILE
if test 5176 -ne `wc -c <'fixnum.c'`; then
    echo shar: \"'fixnum.c'\" unpacked with wrong size!
fi
# end of 'fixnum.c'
fi
if test -f 'hp2pk.lpt' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'hp2pk.lpt'\"
else
echo shar: Extracting \"'hp2pk.lpt'\" \(4883 characters\)
sed "s/^X//" >'hp2pk.lpt' <<'END_OF_FILE'
X
X
X
X     HP2PK(1L)                                               HP2PK(1L)
X
X
X
X     NAME
X          hp2pk - convert Hewlett-Packard soft fonts into TeX fonts
X
X     SYNOPSIS
X          hp2pk [-b density] [-d size] [-h] [-l pl-file[.pl]]
X                [-m magnification] [-p pk-file[.pk]] [-r {l|u}]
X                [-s space-width] [-t tfm-file[.tfm]] [-v] sfp-file[.sfp]
X
X     DESCRIPTION
X          HP2PK converts Hewlett-Packard Soft Font/Portrait (SFP) files
X          into the TFM and PK files needed by TeX.  (Okay, okay, so TeX
X          itself doesn't need PK files--the DVI driver programs associated
X          with TeX generally do!)  Only bitmap fonts, either Class 1 bitmap
X          or Class 2 compressed bitmap, are handled by HP2PK.  The program
X          cannot process Intellifont Scalable Fonts.
X
X          For all files read or written by HP2PK, an appropriate filename
X          extension is automatically appended to the filename if one is not
X          specified explicitly.
X
X     OPTIONS
X          The command line options are described below.
X
X          -b density
X               The -b option specifies the pixel density of the font in
X               dots per inch.  If this is not given on the command line,
X               HP2PK assumes a value of 300 dpi.
X
X          -d size
X               The -d option specifies the design size of the font in
X               points.  If this is not given on the command line, HP2PK
X               calculates a value from the information given in the input
X               font header, writing the computed value to the standard
X               output.
X
X          -h   The -h option causes a brief description of the command line
X               options to be written to the standard error output (normally
X               the screen).  No other action is performed when this option
X               is used.
X
X          -m magnification
X               The -m option specifies the magnification of the font.  The
X               default value is 1000, which indicates no magnification.
X
X          -l pl-file
X               The -l option specifies a Property List (PL) font metric
X               output file.  This is a human-readable form of a TeX font
X               metric file.
X
X          -p pk-file
X               The -p option specifies the font PacKed bitmap (PK) output
X               file.  If it is not given on the command line, HP2PK
X
X
X
X     Page 1                                          (printed 4/12/91)
X
X
X
X
X
X
X     HP2PK(1L)                                               HP2PK(1L)
X
X
X
X               produces a PK file with the same basic name as the input
X               file, but with a ".pk" filetype extension.
X
X          -r {l|u}
X               The -rl option specifies that only the lower 128 character
X               codes be converted and written to the output files.  The -ru
X               option specifies that only the upper 128 character codes be
X               converted, with the codes translated from the range 128-255
X               to the range 0-127.  This allows font files to be prepared
X               for antiquated DVI drivers that cannot handle 8-bit fonts.
X
X          -s space-width
X               The -s option specifies the basic width of a space character
X               in points, if none exists in the soft font.  Character code
X               32 (octal 040) is assumed to be a space character if it
X               exists.  If the space character is not defined in the font,
X               and the -s option is not used, then the width of the x
X               character (decimal code 120, octal code 170) is used.
X
X          -t tfm-file
X               The -t option specifies the TeX Font Metric (TFM) output
X               file.  If neither a TFM (-t) nor a PL (-l) file is given on
X               the command line, HP2PK produces a TFM file with the same
X               basic name as the input file, but with a ".tfm" filetype
X               extension.
X
X          -v   The -v option tells HP2PK to be more talkative as it works.
X
X     SEE ALSO
X          TFtoPL(1), PLtoTF(1), GFtoPK(1)
X
X     BUGS
X          The Hewlett-Packard Soft Font file provides neither kerning
X          nor ligature information.  It also does not supply the slant
X          information for italic fonts.  If needed, these values must
X          be supplied by editing the PL file and then running PLtoTF to
X          produce the TFM file.
X
X          The font's pixel density must be a integral number of dots per
X          inch.
X
X          Bitmaps larger than 32767 bytes are not (yet) handled.  (Such
X          a bitmap would be larger than 510 dots square!)
X
X     AUTHOR
X          Stephen McConnel (steve at txsil.sil.org)
X          Summer Institute of Linguistics
X          7500 W. Camp Wisdom Road
X          Dallas, TX 75236, U.S.A.
X
X
X
X
X
X
X     Page 2                                          (printed 4/12/91)
X
X
X
END_OF_FILE
if test 4883 -ne `wc -c <'hp2pk.lpt'`; then
    echo shar: \"'hp2pk.lpt'\" unpacked with wrong size!
fi
# end of 'hp2pk.lpt'
fi
if test -f 'myalloc.c' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'myalloc.c'\"
else
echo shar: Extracting \"'myalloc.c'\" \(5927 characters\)
sed "s/^X//" >'myalloc.c' <<'END_OF_FILE'
X/*  MYALLOC.C - "safe" memory allocation functions
X ***************************************************************************
X *
X *	char *myalloc(size)
X *	unsigned size;
X *
X *	char *mystrdup(str)
X *	char *str;
X *
X *	char *myrealloc(s,size)
X *	char *s;
X *	unsigned size;
X *
X *	char *myshrink(s)
X *	char *s;
X *
X *	void myfree(s)
X *	char *s;
X *
X *	void myalloc_fail()
X *	char myalloc_errmsg[101]
X *
X ***************************************************************************
X *	EDIT HISTORY
X *	28-Jul-88	Steve McConnel - write the original code
X *	 1-Aug-88	SRMc - delinted
X *	25-Aug-88	SRMc - regularized error messages
X *			     - change errmsg to errloc
X *	21-Oct-88	SRMc - remove register from function parameter
X *				declarations
X *			     - reorganize the file header comments
X *	10-Nov-88	SRMc - add myfree()
X *	 4-Jan-89	SRMc - fix for Microsoft C
X *	22-Mar-89	SRMc - nomem() is no longer a static function
X *	20-May-89	SRMc - remove #include "dict.h"
X *			     - change errloc to 101 rather than MAXMORPH+1
X *				bytes long (removed need for defs.h)
X *			     - rename errloc to myalloc_errmsg
X *			     - added mystrdup(),
X *			     - removed reliance on errexit()
X *	13-Jul-89	hab  - de-"lint" the source
X *	31-Jul-89	rk   - mods for MacIntosh Lightspeed's Think_C
X *	19-Oct-90	SRMc - rename file from MYALLO.C to MYALLOC.C
X *			     - fix myrealloc() to work properly
X *			     - rename nomem() to myalloc_fail()
X *	14-Jan-91	SRMc - add TURBO C patches from Thomas B. Ridgeway
X *				(ridgeway at blackbox.hacc.washington.edu)
X *	15-Jan-91	SRMc - refix for Macintosh Lightspeed THINK C
X *	 2-Mar-91	SRMc - add myshrink(), which disappeared sometime ago
X *			SRMc - revise myrealloc() to call malloc() if it's
X *				handed a NULL pointer (as in PCKFUNCS.C)
X ***************************************************************************
X * Copyright 1988, 1991 by the Summer Institute of Linguistics, Inc.
X * All rights reserved.
X */
X/*#define TURBO_C*/		/* uncomment if using MSDOS TURBO C */
X#include <stdio.h>
X
X/*#ifdef THINK_C*/
X/*#include <storage.h>*/
X/*#include <strings.h>*/
X/*#else*/
X#ifdef BSD
X#include <strings.h>
Xextern char *memset();
X#else
X#ifdef TURBO_C
X#include <mem.h>
X#define MSDOS
X#else
X#ifndef THINK_C		/* THINK C includes memxxx() functions in <string.h> */
X#include <memory.h>
X#endif
X#endif
X#include <string.h>
X#endif
Xextern char *malloc(), *realloc();
Xextern void free();
X/*#endif*/
Xextern int isatty();
Xextern void exit();
X
X/************************************************************************/
X/*			    GLOBAL VARIABLES				*/
X/************************************************************************/
X
Xchar myalloc_errmsg[101];		/* globally settable by callers */
X
X/***************************************************************************
X * NAME
X *    myalloc_fail
X * ARGUMENTS
X *    none
X * DESCRIPTION
X *    Die with an appropriate error message.
X * RETURN VALUE
X *    doesn't return!
X */
Xvoid myalloc_fail()
X{
Xif (*myalloc_errmsg)
X    {
X    fprintf(stderr,"\nALLOCATE MEMORY: No space left at: %s\n",
X							myalloc_errmsg);
X    if (!isatty(fileno(stdout)))
X	printf("\nALLOCATE MEMORY: No space left at: %s\n",
X							myalloc_errmsg);
X    }
Xelse
X    {
X    fprintf(stderr,"\nALLOCATE MEMORY: No space left\n");
X    if (!isatty(fileno(stdout)))
X	printf("\nALLOCATE MEMORY: No space left\n");
X    }
Xexit(2);
X}
X
X/***************************************************************************
X * NAME
X *    myalloc
X * ARGUMENTS
X *    size - number of bytes to allocate
X * DESCRIPTION
X *    "Safe" interface to malloc() -- abort the program with an error message
X *    if we run out of memory.
X * RETURN VALUE
X *    pointer to beginning of area allocated
X */
Xchar *myalloc(size)
Xunsigned size;
X{
Xregister char *p;
X
X#ifdef THINK_C
Xp = malloc((size_t)size);
X#else
Xp = malloc(size);
X#endif
Xif (p == (char *)NULL)
X    myalloc_fail();
Xmemset(p, 0, size);
Xreturn(p);
X}
X
X/***************************************************************************
X * NAME
X *    mystrdup
X * ARGUMENTS
X *    str - pointer to character string to duplicate
X * DESCRIPTION
X *    Create a duplicate of an existing NUL-terminated character string.
X * RETURN VALUE
X *    pointer to the newly allocated and copied duplicate
X */
Xchar *mystrdup(str)
Xchar *str;
X{
Xreturn( strcpy(myalloc((unsigned)strlen(str)+1), str) );
X}
X
X/***************************************************************************
X * NAME
X *    myrealloc
X * ARGUMENTS
X *    s    - pointer to string in allocated buffer
X *    size - new (?) size desired
X * DESCRIPTION
X *    Resize the allocated buffer to the desired size.
X *    Abort the program with an error message if we run out of memory.
X * RETURN VALUE
X *    pointer to reallocated block
X */
Xchar *myrealloc(s,size)
Xchar *s;
Xunsigned size;
X{
Xregister char *p;
X
Xif (s == NULL)
X    return( myalloc(size) );
X#ifdef THINK_C
Xp = realloc( s, (size_t)size );
X#else
Xp = realloc( s, size );
X#endif
Xif (p == (char *)NULL)
X    myalloc_fail();
Xreturn( p );
X}
X
X/***************************************************************************
X * NAME
X *    myshrink
X * ARGUMENTS
X *    s - pointer to string in overlarge allocated buffer
X * DESCRIPTION
X *    Shrink the allocated buffer to exactly fit the string.  Abort the
X *    program with an error message if we somehow run out of memory.
X * RETURN VALUE
X *    pointer to reallocated block
X */
Xchar *myshrink(s)
Xchar *s;
X{
Xregister char *p;
X
Xif (s == (char *)NULL)
X    return((char *)NULL);
Xp = realloc( s, (unsigned)strlen(s)+1 );
Xif (p == (char *)NULL)
X    myalloc_fail();
Xreturn( p );
X}
X
X/***************************************************************************
X * NAME
X *    myfree
X * ARGUMENTS
X *    s - pointer to block to deallocate
X * DESCRIPTION
X *    interface to free() -- release previously allocated memory
X * RETURN VALUE
X *    none
X */
Xvoid myfree(s)
Xchar *s;
X{
Xif (s == (char *)NULL)
X    return;		/* protect against braindead callers */
Xfree(s);
X}
END_OF_FILE
if test 5927 -ne `wc -c <'myalloc.c'`; then
    echo shar: \"'myalloc.c'\" unpacked with wrong size!
fi
# end of 'myalloc.c'
fi
if test -f 'writepl.c' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'writepl.c'\"
else
echo shar: Extracting \"'writepl.c'\" \(4328 characters\)
sed "s/^X//" >'writepl.c' <<'END_OF_FILE'
X/*  WRITEPL.C - Write data to a TeX PL font metric file
X ***************************************************************************
X *
X *	void init_pl_file(fp, program, version, time, tp)
X *	FILE *fp;
X *	char *program;
X *	char *version;
X *	char *time;
X *	struct tfm_header *tp;
X *
X *	void write_pl_entry(fp, ch_code, fmc)
X *	FILE *fp;
X *	unsigned char ch_code;
X *	struct tfm_chardata *fmc;
X *
X *	void end_pl_file(fp, tfp)
X *	FILE *fp;
X *	struct tfm_param *tfp;
X *
X ***************************************************************************
X *
X *	Sources of information for TeX font metric files:
X *
X *		The METAFONTbook by Donald E. Knuth (appendix F)
X *		PLtoTF.WEB by Donald E. Knuth, Leo Guibas, et al.
X *
X ***************************************************************************
X *	EDIT HISTORY
X *	19-Oct-90	SRMc - split out from HP2PK.C to improve modularity
X *	20-Oct-90	SRMc - remove ctime() call in init_pl_file()
X *	17-Jan-91	SRMc - put version information in PATCHLEVEL.H
X ***************************************************************************
X * Copyright 1990, 1991 by the Summer Institute of Linguistics, Inc.
X * All rights reserved.
X */
X#include <stdio.h>
X#include "patchlevel.h"
X#include "tfm.h"
X
Xextern char *fixnum_to_str();	/* from FIXNUM.C */
X
X/****************************************************************************
X * NAME
X *    init_pl_file
X * ARGUMENTS
X *    fp      - output PL FILE pointer
X *    program - program name string
X *    date    - date and time string
X *    tp      - pointer to TFM preamble structure
X * DESCRIPTION
X *    Write the initial heading of the .PL file.
X * RETURN VALUE
X *    none
X */
Xvoid init_pl_file(fp, program, date, tp)
XFILE *fp;
Xchar *program;
Xchar *date;
Xstruct tfm_header *tp;
X{
Xregister int i;
Xchar buf[16];		/* buffer for holding fixnum's string */
X
Xfprintf(fp,"(COMMENT THIS PL FILE WAS PRODUCED BY %s %d.%d.%d (%s), %s)\n",
X	program, VERSION, REVISION, PATCHLEVEL, PATCHDATE, date );
Xfprintf(fp,"(FAMILY ");
Xfor ( i = 1 ; i <= tp->tfm_fontid[0] ; ++i )
X    putc( tp->tfm_fontid[i], fp);
Xfprintf(fp,")\n");
Xfprintf(fp,"(DESIGNSIZE R %s)\n",fixnum_to_str(tp->tfm_design_size, buf, 7));
Xfprintf(fp,"(COMMENT DESIGNSIZE IS IN POINTS)\n");
Xfprintf(fp,"(COMMENT OTHER SIZES ARE MULTIPLES OF DESIGNSIZE)\n");
Xfprintf(fp,"(CHECKSUM O 0)\n");
Xfprintf(fp,"(CODINGSCHEME ");
Xfor ( i = 1 ; i <= tp->tfm_coding[0] ; ++i )
X    putc( tp->tfm_coding[i], fp);
Xfprintf(fp,")\n");
X}
X
X/****************************************************************************
X * NAME
X *    write_pl_entry
X * ARGUMENTS
X *    fp      - output PL FILE pointer
X *    ch_code - character code value
X *    fmc     - pointer to TeX font metric character info structure
X * DESCRIPTION
X *    Write the information for the current character to the .PL file.
X * RETURN VALUE
X *    none
X */
Xvoid write_pl_entry(fp, ch_code, fmc)
XFILE *fp;
Xint ch_code;
Xstruct tfm_chardata *fmc;
X{
Xchar buf[16];		/* buffer for holding fixnum's string */
X
Xfprintf(fp,"(CHARACTER D %d\n", ch_code );
Xfprintf(fp,"   (CHARWD R %s)\n", fixnum_to_str(fmc->charwd, buf, 7) );
Xfprintf(fp,"   (CHARHT R %s)\n", fixnum_to_str(fmc->charht, buf, 7) );
Xif (fmc->chardp > 0L)
X    fprintf(fp,"   (CHARDP R %s)\n", fixnum_to_str(fmc->chardp, buf, 7) );
Xif (fmc->charic > 0L)
X    fprintf(fp,"   (CHARIC R %s)\n", fixnum_to_str(fmc->charic, buf, 7) );
Xfprintf(fp,"   )\n");
X}
X
X/****************************************************************************
X * NAME
X *    end_pl_file
X * ARGUMENTS
X *    fp  - output PL FILE pointer
X *    tfp - pointer to TFM parameter structure
X * DESCRIPTION
X *    Write the tail of the .PL file.
X * RETURN VALUE
X *    none
X */
Xvoid end_pl_file(fp, tfp)
XFILE *fp;
Xstruct tfm_param *tfp;
X{
Xchar buf[16];		/* buffer for holding fixnum's string */
X
Xfprintf(fp,"(FONTDIMEN\n");
Xfprintf(fp,"   (SPACE      R  %s)\n",
X				fixnum_to_str(tfp->tfm_space,buf,7));
Xfprintf(fp,"   (STRETCH    R  %s)\n",
X				fixnum_to_str(tfp->tfm_space_stretch,buf,7));
Xfprintf(fp,"   (SHRINK     R  %s)\n",
X				fixnum_to_str(tfp->tfm_space_shrink,buf,7));
Xfprintf(fp,"   (EXTRASPACE R  %s)\n",
X				fixnum_to_str(tfp->tfm_extra_space,buf,7));
Xfprintf(fp,"   (QUAD       R  %s)\n",
X				fixnum_to_str(tfp->tfm_quad,buf,7));
Xfprintf(fp,"   (XHEIGHT    R  %s)\n",
X				fixnum_to_str(tfp->tfm_x_height,buf,7));
Xfprintf(fp,"   )\n");
X}
END_OF_FILE
if test 4328 -ne `wc -c <'writepl.c'`; then
    echo shar: \"'writepl.c'\" unpacked with wrong size!
fi
# end of 'writepl.c'
fi
if test -f 'writetfm.c' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'writetfm.c'\"
else
echo shar: Extracting \"'writetfm.c'\" \(11960 characters\)
sed "s/^X//" >'writetfm.c' <<'END_OF_FILE'
X/*  WRITETFM.C - Write all the data to a TeX TFM font metric file
X ***************************************************************************
X *
X *	void write_tfm_data(fp, tpfm, hdfm, chfm, pafm, designsize)
X *	FILE *fp;
X *	struct tfm_top      *tpfm;
X *	struct tfm_header   *hdfm;
X *	struct tfm_chardata chfm[];
X *	struct tfm_param    *pafm;
X *	fixnum designsize;
X *
X ***************************************************************************
X *
X *	Sources of information for TeX font metric files:
X *
X *		The METAFONTbook by Donald E. Knuth (appendix F)
X *		PLtoTF.WEB by Donald E. Knuth, Leo Guibas, et al.
X *
X ***************************************************************************
X *	EDIT HISTORY
X *	19-Oct-90	SRMc - split out from HP2PK.C to improve modularity
X *	20-Oct-90	SRMc - make write_tfm_data() the only externally
X *				visible function
X ***************************************************************************
X * Copyright 1990 by the Summer Institute of Linguistics, Inc.
X * All rights reserved.
X */
X#include <stdio.h>
X#include "tfm.h"
X#include "bitmap.h"
X
X/************************************************************************/
X/*			   EXTERN DECLARATIONS				*/
X/************************************************************************/
X
Xextern void put_halfword(), put_fullword();	/* from BIGENDIO.C */
Xextern char *fixnum_to_str();			/* from FIXNUM.C */
X
X/************************************************************************/
X/*			STATIC GLOBAL VARIABLES				*/
X/************************************************************************/
Xstatic long tfm_width_table[256];
Xstatic long tfm_height_table[256];
Xstatic long tfm_depth_table[256];
Xstatic long tfm_charic_table[256];
Xstatic int num_tfm_width, num_tfm_height, num_tfm_depth, num_tfm_charic;
X
X/****************************************************************************
X * NAME
X *    static insort
X * ARGUMENTS
X *    table - array of long integers
X *    size  - size of the array
X *    value - value to add to the array if not already there
X * DESCRIPTION
X *    Add a value to an array, in sorted order.
X * RETURN VALUE
X *    size of the array after (possibly) adding the value
X */
Xstatic int insort(table, size, value)
Xlong *table;
Xint size;
Xlong value;
X{
Xint i, j;
X
Xif (value == 0L)
X    return( size );		/* ignore zeros */
X
Xfor ( i = 0 ; i < size ; ++i )
X    {
X    if (table[i] == value)
X	return(size);
X    if (table[i] > value)
X	{
X	for ( j = size ; j > i ; --j)
X	    table[j] = table[j-1];	/* make room to */
X	table[i] = value;		/* insert the new value */
X	return(size+1);
X	}
X    }
Xtable[size] = value;	/* add to end of sorted table */
Xreturn( size + 1 );
X}
X
X#define labs(a) ((a >= 0) ? a : -a )
X
X/****************************************************************************
X * NAME
X *    static mindelta
X * ARGUMENTS
X *    table    - sorted array of long ints
X *    size     - size of the array
X * DESCRIPTION
X *    Find the minimum difference between adjacent entries in the array.
X * RETURN VALUE
X *    the minimum difference found (adjusted slightly for roundoff)
X */
Xstatic fixnum mindelta(table, size)
Xfixnum *table;
Xint size;
X{
Xint k;
Xfixnum min_diff;
X
Xmin_diff = 0x7FFFFFFFL;
X
Xfor ( k = 0 ; k < size-1 ; ++k )
X    {
X    if (labs(table[k+1] - table[k]) < min_diff)
X	min_diff = labs( table[k+1] - table[k] );
X    }
Xreturn( min_diff+1 );		/* adjust slightly for roundoff */
X}
X
X/****************************************************************************
X * NAME
X *    static trim_tfm_table
X * ARGUMENTS
X *    table   - array of long integers
X *    size    - size of the array
X *    max     - maximum allowable size of the array
X *    tabname - character string name of the table for error message
X *    dsize   - designsize of font (in 2**-20 points)
X * DESCRIPTION
X *    If the array is larger than allowed, throw out the minimum number of
X *    values, trying for minimum impact of the loss of precision.
X * RETURN VALUE
X *    number of entries in the reduced table
X */
Xstatic int trim_tfm_table(table, size, max, tabname, dsize)
Xlong *table;
Xint size;
Xint max;
Xchar *tabname;
Xfixnum dsize;
X{
Xlong scratch[256];
Xchar fixnumbuf[16];
Xint i;
Xint num;
Xfixnum min_d;
Xdouble d;
X
Xif (size <= max)
X    return(size);
X
Xdo  {
X    min_d = mindelta(table, size);
X    for ( num = 0, i = 0 ; i < size-1 ; ++i )
X	{
X	if ((table[i+1] - table[i]) <= min_d)
X	    {				/* split the difference */
X	    scratch[num++] = (table[i] + table[i+1]) / 2;
X	    ++i;			/* need to skip ahead in table[] */
X	    }
X	else
X	    scratch[num++] = table[i];	/* copy the original value */
X	}
X    if (i < size)
X	scratch[num++] = table[i];	/* if needed, store largest value */
X
X    size = num;
X    for ( i = 0 ; i < size ; ++i )
X	table[i] = scratch[i];
X
X    } while (size > max);
X
Xd = (min_d / 2.0) * (dsize / TWO_20th);
Xmin_d = d;
Xprintf( "TFM character %s may be rounded off by %s pt.\n",
X				tabname, fixnum_to_str(min_d, fixnumbuf, 7) );
Xreturn(size);
X}
X
X/****************************************************************************
X * NAME
X *    static table_index
X * ARGUMENTS
X *    table - array of long integers
X *    size  - size of the array
X *    value - value to search for
X * DESCRIPTION
X *    Search for the closest fit in the array to the given value.
X * RETURN VALUE
X *    index in the array of the closest fit
X */
Xstatic int table_index(table, size, value)
Xlong *table;
Xint size;
Xlong value;
X{
Xint i;
X/*
X *  first, try for exact matches
X */
Xfor ( i = 0 ; i < size ; ++i )
X    {
X    if (value == table[i])
X	return( i );
X    }
X/*
X *  now, try for closest fit
X */
Xfor ( i = 1 ; i < size-1 ; ++i )
X    {
X    if ((value > table[i]) && (value < table[i+1]))
X	{
X	if ((value < 0) && (table[i+1] > 0))
X	    return( ((value - table[i]) < -value) ? i : 0 );
X	if ((value > 0) && (table[i] < 0))
X	    return( (value < (table[i+1] - value)) ? 0 : i+1 );
X	return( ((value - table[i]) < (table[i+1] - value)) ? i : i+1 );
X	}
X    }
Xreturn(size-1);		/* largest value in table was rounded down */
X}
X
X/****************************************************************************
X * NAME
X *    static fix_tfm_data
X * ARGUMENTS
X *    chfm       - pointer to array of TFM character data structures
X *    tpfm       - pointer to TFM file top information structure
X *    designsize - font design size (used for roundoff messages)
X * DESCRIPTION
X *    Fix the TFM data in preparation for writing the file.
X *    This involves squeezing the character metric arrays to no more
X *    than their maximum sizes prior to converting character metric values
X *    into table indices.
X * RETURN VALUE
X *    none
X */
Xstatic void fix_tfm_data(chfm, tpfm, designsize)
Xstruct tfm_chardata chfm[];
Xstruct tfm_top *tpfm;
Xfixnum designsize;
X{
Xint i;
Xlong idx;
X/*
X *  ensure the character metric tables are no larger than allowed
X */
Xnum_tfm_width = num_tfm_height = num_tfm_depth = num_tfm_charic = 0;
Xfor ( i = 0 ; i < 256 ; ++i )
X    {
X    num_tfm_width  = insort(&tfm_width_table[1], num_tfm_width,
X				chfm[i].charwd);
X    num_tfm_height = insort(&tfm_height_table[1],num_tfm_height,
X				chfm[i].charht);
X    num_tfm_depth  = insort(&tfm_depth_table[1], num_tfm_depth,
X				chfm[i].chardp);
X    num_tfm_charic = insort(&tfm_charic_table[1],num_tfm_charic,
X				chfm[i].charic);
X    }
Xnum_tfm_width  = trim_tfm_table( &tfm_width_table[1],  num_tfm_width,
X			MAX_TFM_WIDTH-1,  "widths", designsize);
Xnum_tfm_height = trim_tfm_table( &tfm_height_table[1], num_tfm_height,
X			MAX_TFM_HEIGHT-1, "heights", designsize);
Xnum_tfm_depth  = trim_tfm_table( &tfm_depth_table[1],  num_tfm_depth,
X			MAX_TFM_DEPTH-1,  "depths", designsize );
Xnum_tfm_charic = trim_tfm_table( &tfm_charic_table[1], num_tfm_charic,
X			MAX_TFM_CHARIC-1, "italic corrections", designsize );
Xtfm_width_table[0]  = 0L;	++num_tfm_width;
Xtfm_height_table[0] = 0L;	++num_tfm_height;
Xtfm_depth_table[0]  = 0L;	++num_tfm_depth;
Xtfm_charic_table[0] = 0L;	++num_tfm_charic;
X/*
X *  convert the character data
X */
Xfor ( i = tpfm->tfm_bc ; i <= tpfm->tfm_ec ; ++i )
X    {
X    idx = (long)table_index(tfm_width_table, num_tfm_width, chfm[i].charwd);
X    chfm[i].char_info  = (idx << 24) & 0xFF000000L;
X
X    idx = (long)table_index(tfm_height_table,num_tfm_height,chfm[i].charht);
X    chfm[i].char_info |= (idx << 20) & 0x00F00000L;
X
X    idx = (long)table_index(tfm_depth_table, num_tfm_depth, chfm[i].chardp);
X    chfm[i].char_info |= (idx << 16) & 0x000F0000L;
X
X    idx = (long)table_index(tfm_charic_table,num_tfm_charic,chfm[i].charic);
X    chfm[i].char_info |= (idx << 10) & 0x0000FC00L;
X    }
X/*
X *  store the TFM file description data
X */
Xtpfm->tfm_lf = 6 +		/* length of the entire file, in words */
X		(tpfm->tfm_ec - tpfm->tfm_bc + 1) +
X		num_tfm_width + num_tfm_height + num_tfm_depth +
X		num_tfm_charic + 18 + 7;
Xtpfm->tfm_lh = 18;		/* length of the header data, in words */
Xtpfm->tfm_nw = num_tfm_width;	/* number of words in the width table */
Xtpfm->tfm_nh = num_tfm_height;	/* number of words in the height table */
Xtpfm->tfm_nd = num_tfm_depth;	/* number of words in the depth table */
Xtpfm->tfm_ni = num_tfm_charic;	/* number of words in the italic corr. table */
Xtpfm->tfm_nl = 0;		/* number of words in the lig/kern table */
Xtpfm->tfm_nk = 0;		/* number of words in the kern table */
Xtpfm->tfm_ne = 0;		/* number of words in the exten. char. table */
Xtpfm->tfm_np = 7;		/* number of font parameter words */
X}
X
X/****************************************************************************
X * NAME
X *    write_tfm_data
X * ARGUMENTS
X *    fp - FILE pointer
X *    tpfm - pointer to TFM file top information structure
X *    hdfm - pointer to TFM file header structure
X *    chfm - pointer to array of TFM character data structures
X *    pafm - pointer to TFM parameter structure
X *    designsize - font design size (used for roundoff messages)
X * DESCRIPTION
X *    Write the TFM data to a file.
X * RETURN VALUE
X *    none
X */
Xvoid write_tfm_data(fp, tpfm, hdfm, chfm, pafm, designsize)
XFILE *fp;
Xstruct tfm_top      *tpfm;
Xstruct tfm_header   *hdfm;
Xstruct tfm_chardata chfm[];
Xstruct tfm_param    *pafm;
Xfixnum designsize;
X{
Xint i;
X/*
X *  fix the TFM character data
X */
Xfix_tfm_data(chfm, tpfm, designsize);
X/*
X *  write the TFM file description info
X */
Xput_halfword( tpfm->tfm_lf, fp );
Xput_halfword( tpfm->tfm_lh, fp );
Xput_halfword( tpfm->tfm_bc, fp );
Xput_halfword( tpfm->tfm_ec, fp );
Xput_halfword( tpfm->tfm_nw, fp );
Xput_halfword( tpfm->tfm_nh, fp );
Xput_halfword( tpfm->tfm_nd, fp );
Xput_halfword( tpfm->tfm_ni, fp );
Xput_halfword( tpfm->tfm_nl, fp );
Xput_halfword( tpfm->tfm_nk, fp );
Xput_halfword( tpfm->tfm_ne, fp );
Xput_halfword( tpfm->tfm_np, fp );
X/*
X *  write the TFM File Header
X */
Xput_fullword( hdfm->tfm_checksum, fp );
Xput_fullword( hdfm->tfm_design_size, fp );
Xfor ( i = 0 ; i < 40 ; ++i )
X    putc( hdfm->tfm_coding[i], fp );
Xfor ( i = 0 ; i < 20 ; ++i )
X    putc( hdfm->tfm_fontid[i], fp );
Xputc( hdfm->tfm_7bitsafe, fp );
Xputc( hdfm->tfm_unused[0], fp );
Xputc( hdfm->tfm_unused[1], fp );
Xputc( hdfm->tfm_face, fp );
X/*
X *  write the TFM Character Data
X */
Xfor ( i = tpfm->tfm_bc ; i <= tpfm->tfm_ec ; ++i )
X    {
X    put_fullword( chfm[i].char_info, fp );
X    }
X/*
X *  write the TFM Character widths table
X */
Xfor ( i = 0 ; i < num_tfm_width ; ++i )
X    put_fullword( tfm_width_table[i], fp );
X/*
X *  write the TFM Character heights table
X */
Xfor ( i = 0 ; i < num_tfm_height ; ++i )
X    put_fullword( tfm_height_table[i], fp );
X/*
X *  write the TFM Character depths table
X */
Xfor ( i = 0 ; i < num_tfm_depth ; ++i )
X    put_fullword( tfm_depth_table[i], fp );
X/*
X *  write the TFM Character italic corrections table
X */
Xfor ( i = 0 ; i < num_tfm_charic ; ++i )
X    put_fullword( tfm_charic_table[i], fp );
X/*
X *  write the TFM Font Parameters
X */
Xput_fullword( pafm->tfm_slant, fp );
Xput_fullword( pafm->tfm_space, fp );
Xput_fullword( pafm->tfm_space_stretch, fp );
Xput_fullword( pafm->tfm_space_shrink, fp );
Xput_fullword( pafm->tfm_x_height, fp );
Xput_fullword( pafm->tfm_quad, fp );
Xput_fullword( pafm->tfm_extra_space, fp );
X}
END_OF_FILE
if test 11960 -ne `wc -c <'writetfm.c'`; then
    echo shar: \"'writetfm.c'\" unpacked with wrong size!
fi
# end of 'writetfm.c'
fi
echo shar: End of archive 2 \(of 4\).
cp /dev/null ark2isdone
MISSING=""
for I in 1 2 3 4 ; do
    if test ! -f ark${I}isdone ; then
	MISSING="${MISSING} ${I}"
    fi
done
if test "${MISSING}" = "" ; then
    echo You have unpacked all 4 archives.
    rm -f ark[1-9]isdone
else
    echo You still need to unpack the following archives:
    echo "        " ${MISSING}
fi
##  End of shell archive.
exit 0

exit 0 # Just in case...
-- 
Kent Landfield                   INTERNET: kent at sparky.IMD.Sterling.COM
Sterling Software, IMD           UUCP:     uunet!sparky!kent
Phone:    (402) 291-8300         FAX:      (402) 291-4362
Please send comp.sources.misc-related mail to kent at uunet.uu.net.



More information about the Comp.sources.misc mailing list