dvirle2.c File Reference

#include <errno.h>
#include <setjmp.h>
#include <stdio.h>
#include "types.h"
#include "conv.h"
#include "fio.h"
#include "font.h"
#include "dvirle.h"
#include "rle.h"

Include dependency graph for dvirle2.c:

Go to the source code of this file.

Macros
#define	RowsBetween(f, n)   ((n) >= (f) ? (n) - (f) : (n) - (f) + ROWS)
#define	avoiding_shifts_is_faster   /* but is it??? */

Functions
void	ReadFonts ()
void	FormFeed ()
void	ReadInput ()
void	VWriteChar ()
void	VWriteRule ()
void	DumpTopOfBand ()
void	MoveDown ()
void	WriteBuf ()
void	WriteBlanks ()
void	main (int argc, char **argv)
void	VWriteChar (unsigned char *rastp, int height, int width)
void	VWriteRule (int info)
void	MoveDown (int delta)
void	WriteBuf (unsigned char *buf, int first, int last, int cl)
void	WriteBlanks (int n)

Variables
static char	rcsid [] = "$Id: dvirle2.c,v 3.0.1.1 1992/01/21 19:26:59 spencer Exp $"
char *	ProgName
char *	optarg
int	optind
struct font *	Fonts [100]
char	TeXFontDesc [256]
int	RasterOrientation
int	DFlag
int	HFlag
int	SFlag
int	TFlag
int	Debug
unsigned char	VBuffer [600][319]
int	NewPage
int	CurRow
int	CurCol
int	FirstRow
int	LastRow
int	NLines
int	PageHeight
int	PageWidth
int	filtw = 5
int	filth = 5
int	filtfact
int	outwidth
rle_hdr	out_hdr
const char *	pic_comments []
static unsigned char	nbits [256]

Macro Definition Documentation

#define avoiding_shifts_is_faster   /* but is it??? */

#define RowsBetween	(		f,
			n
	)		((n) >= (f) ? (n) - (f) : (n) - (f) + ROWS)

Definition at line 104 of file dvirle2.c.

Function Documentation

void DumpTopOfBand

(

)

Definition at line 615 of file dvirle2.c.

References CurRow, FirstRow, and VBuffer.

{

    /*
     * To exclude CurRow, subtract one, but modularly, modularly!
     */
    WriteBuf(&VBuffer[0][0], FirstRow, CurRow ? CurRow - 1 : ROWS - 1, 1);
    FirstRow = CurRow;
}

void FormFeed

(

)

Definition at line 787 of file dvirle2.c.

References NewPage, out_hdr, and rle_puteof().

{
    if ( !NewPage )
    rle_puteof( &out_hdr );
    NewPage = 1;        /* next output will setup RLE file */
}

Here is the call graph for this function:

void main	(	int	argc,
		char **	argv
	)

Definition at line 110 of file dvirle2.c.

{
    register int c;
    register char *s;
    int dpi, usermag, num, denom, dvimag;

    ProgName = *argv;

    while ((c = getopt(argc, argv, "dstDx:y:")) != EOF) {
        switch (c) {

        case 'd':   /* output to /dev/null */
            DFlag++;
            break;

        case 's':   /* silent processing except for errors */
            SFlag++;
            break;

        case 't':   /* output to tape (not implemented) */
            TFlag++;
            error(0, 0, "tape option not yet implemented");
            break;

        case 'D':
            Debug++;
            break;

        case 'x':
            if ( optarg )
                filtw = atoi( optarg );
            break;
        case 'y':
            if ( optarg )
                filth = atoi( optarg );
            break;
        case '?':
            fprintf(stderr, "Usage: %s [-d] [-s] [-t] [file]\n",
                ProgName);
            exit(1);
        }
    }
    if (optind < argc)
        if (freopen(argv[optind], "r", stdin) == NULL)
            error(1, 0, "can't open %s", argv[optind]);

    HFlag = getchar();
    if ((HFlag >> 1) != VERSION)
        error(1, 0, "input file is not version %d", VERSION);
    HFlag &= 1;
    RasterOrientation = HFlag ? ROT_RIGHT : ROT_NORM;

    s = TeXFontDesc;
    c = GetLong(stdin);
    while (--c >= 0)
        *s++ = getchar();
    if (feof(stdin))
        (void) GetByte(stdin);  /* let GetByte do error */
    *s = 0;

    dpi = GetLong(stdin);
    usermag = GetLong(stdin);
    num = GetLong(stdin);
    denom = GetLong(stdin);
    dvimag = GetLong(stdin);
    SetConversion(dpi, usermag, num, denom, dvimag);

    fontinit(*TeXFontDesc ? TeXFontDesc : (char *) NULL);
    ReadFonts();

    PageHeight = GetLong(stdin);
    PageWidth = GetLong(stdin);

    out_hdr = *rle_hdr_init( (rle_hdr *)NULL );
    rle_names( &out_hdr, cmd_name( argv ), NULL, 0 );

    if (DFlag) {
        (void) fprintf(stderr, "Output will be discarded\n");
        (void) fflush(stderr);
        out_hdr.rle_file = fopen("/dev/null", "w");
    }

    /* Set up output file papameters */
    out_hdr.xmin = 0;
    out_hdr.xmax = outwidth = (PageWidth - 1) / filtw;
    out_hdr.ymin = 0;
    out_hdr.ymax = (PageHeight - 1) / filth;
    out_hdr.ncolors = 1;
    out_hdr.alpha = 1;
    RLE_SET_BIT( out_hdr, RLE_ALPHA );
    out_hdr.comments = pic_comments;
    rle_put_setup( &out_hdr );

    filtfact = 255.0 / (filtw * filth);

    ReadInput();

    FormFeed();     /* Write last EOF */

    if (!SFlag)
        (void) putc('\n', stderr);

    exit(0);
    /* NOTREACHED */
}

void MoveDown

(

)

void MoveDown

(

int

delta

)

Definition at line 630 of file dvirle2.c.

{

    if (delta >= ROWS - RowsBetween(FirstRow, CurRow)) {
        /*
         * Need to roll the cylinder forward.  Write out the used
         * part, and then write as many blank lines as necessary.
         */
        WriteBuf(&VBuffer[0][0], FirstRow, LastRow, 1);
        WriteBlanks(delta - RowsBetween(CurRow, LastRow) - 1);
        CurRow = LastRow = FirstRow;    /* band is now empty */
    } else {
        /*
         * Because RowsBetween returns nonnegative integers, we
         * know delta <= ROWS, so can do mod more quickly thus:
         */
        CurRow += delta;    /* result < 2*ROWS */
        if (CurRow >= ROWS)
            CurRow -= ROWS; /* now result < ROWS */
    }
}

void ReadFonts

(

)

Definition at line 224 of file dvirle2.c.

References Debug, Fonts, and SFlag.

{
    register struct font *f, **fp;
    register int c;
    register char *s;
#ifdef SPEED_HACK
    register struct glyph *g;
#endif
    i32 mag, dsize;
    char *fname;
    char nm[512];

    if (!SFlag)
        (void) fprintf(stderr, "[fonts:\n");
    fp = Fonts;
    while (GetByte(stdin) == 1) {
        (void) GetLong(stdin);  /* checksum */
        mag = GetLong(stdin);   /* magfactor */
        dsize = GetLong(stdin); /* design size */
        c = GetLong(stdin);
        s = nm;
        while (--c >= 0)
            *s++ = getchar();
        if (feof(stdin))
            (void) GetByte(stdin);  /* let GetByte do error */
        *s = 0;
        f = GetFont(nm, mag, dsize, "RLE", &fname);
        if (f == NULL) {
            GripeCannotGetFont(nm, mag, dsize, "RLE", fname);
            exit(1);
            /* NOTREACHED */
        }
        if (Debug) {
            (void) fprintf(stderr, "[%s -> %s]\n",
                Font_TeXName(f), fname);
            (void) fflush(stderr);
        }
        if (!SFlag) {
            register char *t = fname;

            s = fname;
            while (*s)
                if (*s++ == '/' && *s)
                    t = s;
            (void) fprintf(stderr, " %s\n", t);
        }
#ifdef SPEED_HACK
        for (c = 0; c < 128; c++) {
            g = GLYPH(f, c);
            if (GVALID(g))
                (void) RASTER(g, f, RasterOrientation);
        }
#endif
        *fp++ = f;
    }
    if (!SFlag)
        (void) fprintf(stderr, "]\n");
}

void ReadInput

(

)

Definition at line 288 of file dvirle2.c.

References CurCol, CurRow, Debug, FirstRow, Fonts, HFlag, LastRow, NLines, SFlag, and VBuffer.

{
    register int yx, fcp, height;

    /*
     * Loop forever.  I had a `for (;;)' but everything crept off the
     * right side of the screen. 
     */
next:
    fGetLong(stdin, yx);    /* position */
    fGetLong(stdin, fcp);   /* character, most likely */
    if ( Debug > 2 )
        fprintf( stderr, "yx:%lx, fcp:%lx\n", yx, fcp );
    if (feof(stdin))
        return;     /* done */

    /*
     * A `position' of -1 indicates either a rule or an end of page.
     * Anything else is a character.
     */
    if (yx != -1) {     /* place character */
        register struct glyph *g;
        register struct font *f;
        register int fnum;

        /*
         * Any delta-y required is stored in the upper 16 bits of yx.
         */
        if ((height = yx >> 16) != 0)
            MoveDown(height);
        /*
         * Extract the x, font, char, and part info into CurCol,
         * fnum, yx, and fcp.
         */
        CurCol = yx & 0xffff;
        fnum = fcp >> FONTSHIFT;
        yx = (fcp >> CHARSHIFT) & CHARMASK;
        fcp = fcp & PARTMASK;
        f = Fonts[fnum];    /* trusting */
        g = GLYPH(f, yx);
        if ( Debug > 1 )
            fprintf( stderr,
                 "Col:%d, Height:%d, fnum:%d, yx:%d, fcp:%d\n",
                 CurCol, height, fnum, yx, fcp );

        /*
         * In case this character does not fit, write
         * out the used part of the band.  It had better
         * fit afterward....
         */
        height = g->g_height;
        if (height >= ROWS - RowsBetween(FirstRow, CurRow))
            DumpTopOfBand();
        if (fcp)    /* cannot handle these yet */
            error(0, 0, "\
part code not implemented; skipping char %d in %s",
                yx, f->f_path);
        else if (HASRASTER(g)) {
#ifdef SPEED_HACK
            /* XXX, but saves time */
            VWriteChar(g->g_raster, height, g->g_width);
#else
            VWriteChar(RASTER(g, f, RasterOrientation),
                height, g->g_width);
#endif
        }
        goto next;  /* done with character */
    }

    /*
     * If the `character' is negative, we need to move down first,
     * possibly because this is an end-of-page.  If this is not the
     * end of the page, it must be a rule.
     */
    if (fcp < 0) {      /* move down */
        yx = -fcp;
        fGetLong(stdin, fcp);   /* junk */
        fGetLong(stdin, fcp);
        if (fcp == 0) { /* end page */
                if ( Debug > 1 )
                fprintf( stderr, "End of Page\n" );
            /* dump entire band */
            WriteBuf(&VBuffer[0][0], FirstRow, LastRow, 1);
            CurRow = LastRow = FirstRow;
            if (!HFlag) {
                WriteBlanks(yx - NLines);
                FormFeed();
            } else
                FormFeed();
            if (!SFlag)
                (void) fprintf(stderr, ".");
            NLines = 0;
            goto next;  /* all done */
        }

        MoveDown(yx);   /* must be a rule; move down by yx rows */
    }

    /*
     * At this point we have a rule to put at the current
     * position, CurRow.
     */
    height = (fcp & 0xff00) >> 8;
    /* make sure it fits */
    if (height >= ROWS - RowsBetween(FirstRow, CurRow))
        DumpTopOfBand();
    VWriteRule(fcp);
    goto next;      /* done with rule */
}

void VWriteChar

(

)

void VWriteChar	(	unsigned char *	rastp,
		int	height,
		int	width
	)

Definition at line 409 of file dvirle2.c.

{
    register unsigned char *bp; /* Output buffer pointer [r11] */
    register unsigned char *rp; /* raster pointer      [r10] */
    register int rshift;    /* right shift index       [r9]  */
    register int lshift;    /* left shift index    [r8]  */
    register int j;     /* width loop downcounter */
    register int o;     /* offset to next row in buffer */
    int row;        /* current row in buffer */
    int col;        /* column in buffer of left edge */
    int i;          /* height loop downcounter */
    int w;          /* raster width (bytes) */

    if ((rp = rastp) == NULL)
        return;     /* an all-white character */

    row = CurRow + height - 1;
    if ( row >= ROWS )
        row -= ROWS;    /* assume height <= ROWS? */
    col = CurCol >> 3;
    i = height;
    w = (width + 7) >> 3;
    o = COLUMNS + w;

#if defined(lint) || !defined(vax)
    rshift = CurCol & 7;
    lshift = 8 - rshift;
#else /* lint || !vax */
    rshift = -(CurCol & 7); /* Vax does '>>' as negative '<<' */
    lshift = 8 + rshift;
#endif /* lint || !vax */
    bp = &VBuffer[row][col];

#define avoiding_shifts_is_faster   /* but is it??? */
#ifdef avoiding_shifts_is_faster
    /*
     * One out of eight or so times, the shift values will be
     * zero.  This makes the code run faster.
     */
    if (rshift == 0) {
        while (--i >= 0) {
            j = w;
            while (--j >= 0)
                *bp++ |= *rp++;
            if (--row < 0) {
                row = ROWS - 1;
                bp = &VBuffer[ROWS - 1][col];
            } else
                bp -= o;
        }
    } else
#endif
    {
        while (--i >= 0) {
            j = w;
            while (--j >= 0) {
#if defined(lint) || !defined(vax)
                *bp++ |= (*rp & 255) >> rshift;
                *bp |= (*rp++ & 255) << lshift;
#else /* lint || !vax */
                /*
                 * THE FOLLOWING ASSEMBLY CODE IS INSERTED
                 * BECAUSE THE COMPILER CAN'T OPTIMIZE THE
                 * C CODE WORTH A DARN
                 */
                asm("   movzbl  (r10)+,r1 # *rp++ & 255");
                asm("   ashl    r9,r1,r0  # >> rshift");
                asm("   bisb2   r0,(r11)+ # *bp++ |=");
                asm("   ashl    r8,r1,r0  # << lshift");
                asm("   bisb2   r0,(r11)  # *bp |=");
#endif /* lint || !vax */
            }
            if (--row < 0) {
                row = ROWS - 1;
                bp = &VBuffer[ROWS - 1][col];
            } else
                bp -= o;
        }
    }

    j = height + CurRow - 1;/* have now set bits this far */
    if (j >= ROWS)
        j -= ROWS;  /* keep it modular */

    /*
     * There are two cases.  Either the buffer is not currently wrapped,
     * in which case the regions past LastRow or before FirstRow extend
     * it; or it is wrapped, in which case the region between LastRow
     * and FirstRow extends it:
     *
     *      case 1       case 2
     *     --------     --------
     *     |      | last  ->| XXXX |
     * first ->| XXXX |     |      |
     *     | XXXX |     |      |
     * last  ->| XXXX | first ->| XXXX |
     *     |      |     | XXXX |
     *     --------     --------
     *
     * The `X's mark the region that is in use; the blank spaces
     * mark the region that causes the `last' value to change.
     */
    if (FirstRow <= LastRow) {
        /* first case: not wrapped */
        if (j < FirstRow || j > LastRow)
            LastRow = j;
    } else {
        /* second case: wrapped */
        if (j > LastRow && j < FirstRow)
            LastRow = j;
    }
}

void VWriteRule

(

)

void VWriteRule

(

int

info

)

Definition at line 530 of file dvirle2.c.

{
    register unsigned char *bp; /* buffer pointer */
    register int j;
    register int lbits; /* bits along left */
    register int rbits; /* bits along right */
    register int o;     /* offset to next row */
    register int i;
    register int full;  /* number of 8 bit words to set */
    register int height;    /* rule height */
    register int width; /* rule width */
    register int row;
    register int col;

    i = info;
    CurCol = (i & 0x7fff0000) >> 16;
    height = ((i & 0xff00) >> 8);
    width = (i & 0xff);
    if ( Debug > 1 )
        fprintf( stderr, "Rule: Row: %d, Col:%d, height:%d, width:%d\n",
             CurRow, CurCol, height, width );
    col = CurCol >> 3;
    row = CurRow;
    j = CurCol & 7;     /* bit # of start position */
    lbits = 0xff >> j;  /* bits to set along left edge */
    /* there are 8-j bits set in lbits */
    o = 8 - j - width;
    if (o > 0) {        /* then lbits has o too many bits set */
        lbits >>= o;
        lbits <<= o;    /* puts zeros into o righthand bits */
        rbits = 0;
        full = 0;
    } else {
        i = (CurCol + width) & 7;   /* bit # of ending position */
        rbits = 0xff00 >> i;    /* bits to set along right edge */
        /* there are i bits set in rbits (well, in the low byte) */
        full = (width - i - (8 - j)) >> 3;
    }
    bp = &VBuffer[row][col];
    i = height;

    /* Often "full" is zero, which makes things faster */
    if (full) {     /* oh well */
        o = COLUMNS - full - 1;
        while (--i >= 0) {
            *bp++ |= lbits;
            for (j = full; --j >= 0;)
                *bp++ |= 0xff;
            *bp |= rbits;
            if (++row >= ROWS) {
                row = 0;
                bp = &VBuffer[0][col];
            } else
                bp += o;
        }
    } else {
        o = COLUMNS - 1;
        while (--i >= 0) {
            *bp++ |= lbits;
            *bp |= rbits;
            if (++row >= ROWS) {
                row = 0;
                bp = &VBuffer[0][col];
            } else
                bp += o;
        }
    }
    i = CurRow + height - 1;
    if (i >= ROWS)
        i -= ROWS;
    /*
     * This is another way of expressing both cases 1 and 2 in
     * VWriteChar().  I think the other way is likely to be
     * faster, and characters occur far more frequently; but this
     * is the more readable by far.
     */
    if (RowsBetween(FirstRow, LastRow) < RowsBetween(FirstRow, i))
        LastRow = i;
}

void WriteBlanks

(

)

void WriteBlanks

(

int

n

)

Definition at line 777 of file dvirle2.c.

{
    WriteBuf((unsigned char *)0, 0, n - 1, 0);
}

void WriteBuf

(

)

void WriteBuf	(	unsigned char *	buf,
		int	first,
		int	last,
		int	cl
	)

Definition at line 683 of file dvirle2.c.

{
        static unsigned char bytebuf[COLUMNS*8];
    static int filtrow = 0, sawbit = 0;
    unsigned char mask;
    unsigned char * scans[2];
    int row;
    register int bit, col;
    register unsigned char * cp, * bufp;

    if ( Debug > 1 )
        fprintf( stderr, "Writebuf( %lx, %d, %d, %d )\n",
             buf, first, last, cl );

    /* Setup RLE file if beginning of page */
    if ( NewPage )
    {
        rle_put_setup( &out_hdr );
        NewPage = 0;
    }

    scans[0] = scans[1] = bytebuf;

    if ( buf == NULL )
    {
        if ( filtrow > 0 && filtrow + last - first + 1 >= filth )
        {
        for ( col = 0; col < outwidth; col++ )
        {
            /* Why two lines?  HP compiler bug! */
            bit = bytebuf[col] * filtfact;
            bytebuf[col] = bit;
        }
        rle_putrow( &scans[1], outwidth, &out_hdr );
        for ( col = 0; col < outwidth; col++ )
            bytebuf[col] = 0;
        }
        NLines += last - first + 1;
        if ( last - first - filtrow + 1 >= filth )
        rle_skiprow( &out_hdr,
                (last - first - filtrow + 1) / filth );
        filtrow = (filtrow + last - first + 1) % filth;
        return;
    }

    if (first > last) { /* recursively do wrapped part first */
        WriteBuf(buf, first, ROWS - 1, cl);
        first = 0;
    }
    buf = &buf[first * COLUMNS];

    mask = (0xff << (8 - filtw)) & 0xff;
    for ( row = first, bufp = buf; row <= last; row++, bufp += COLUMNS )
    {
        for ( cp = bufp, col = 0, bit = 0; col < outwidth;
          col++, bit += filtw, bit >= 8 ? cp++ : cp, bit %= 8 )
        if ( (bytebuf[col] +=
              nbits[(*cp & (mask >> bit))] +
              nbits[((*(cp+1) & (mask << (8 - bit)))) & 0xff]) != 0 )
            sawbit++;

        filtrow = (filtrow + 1) % filth;

        if ( filtrow == 0 )
        {
        if ( sawbit )
        {
            for ( col = 0; col < outwidth; col++ )
            {
            bit = bytebuf[col] * filtfact;
            bytebuf[col] = bit;
            }
            rle_putrow( &scans[1], outwidth, &out_hdr );
            for ( col = 0; col < outwidth; col++ )
            bytebuf[col] = 0;
        }
        else
            rle_skiprow( &out_hdr, 1 );
        sawbit = 0;
        }
    }

    if (cl)
        bzero(buf, (unsigned) (COLUMNS * (last - first + 1)));
    NLines += last - first + 1;
}

Variable Documentation

int CurCol

Definition at line 79 of file dvirle2.c.

Referenced by ReadInput().

int CurRow

Definition at line 78 of file dvirle2.c.

Referenced by DumpTopOfBand(), and ReadInput().

int Debug

Definition at line 72 of file dvirle2.c.

int DFlag

Definition at line 68 of file dvirle2.c.

int filtfact

Definition at line 86 of file dvirle2.c.

int filth = 5

Definition at line 85 of file dvirle2.c.

int filtw = 5

Definition at line 85 of file dvirle2.c.

int FirstRow

Definition at line 80 of file dvirle2.c.

Referenced by DumpTopOfBand(), and ReadInput().

struct font* Fonts[100 ]

Definition at line 62 of file dvirle2.c.

Referenced by ReadFonts(), and ReadInput().

int HFlag

Definition at line 69 of file dvirle2.c.

Referenced by EndPage(), PageLoop(), and ReadInput().

int LastRow

Definition at line 81 of file dvirle2.c.

Referenced by ReadInput().

unsigned char nbits[256]

static

Initial value:

= {
      0,  1,  1,  2,  1,  2,  2,  3,  1,  2,  2,  3,  2,  3,  3,  4,
      1,  2,  2,  3,  2,  3,  3,  4,  2,  3,  3,  4,  3,  4,  4,  5,
      1,  2,  2,  3,  2,  3,  3,  4,  2,  3,  3,  4,  3,  4,  4,  5,
      2,  3,  3,  4,  3,  4,  4,  5,  3,  4,  4,  5,  4,  5,  5,  6,
      1,  2,  2,  3,  2,  3,  3,  4,  2,  3,  3,  4,  3,  4,  4,  5,
      2,  3,  3,  4,  3,  4,  4,  5,  3,  4,  4,  5,  4,  5,  5,  6,
      2,  3,  3,  4,  3,  4,  4,  5,  3,  4,  4,  5,  4,  5,  5,  6,
      3,  4,  4,  5,  4,  5,  5,  6,  4,  5,  5,  6,  5,  6,  6,  7,
      1,  2,  2,  3,  2,  3,  3,  4,  2,  3,  3,  4,  3,  4,  4,  5,
      2,  3,  3,  4,  3,  4,  4,  5,  3,  4,  4,  5,  4,  5,  5,  6,
      2,  3,  3,  4,  3,  4,  4,  5,  3,  4,  4,  5,  4,  5,  5,  6,
      3,  4,  4,  5,  4,  5,  5,  6,  4,  5,  5,  6,  5,  6,  6,  7,
      2,  3,  3,  4,  3,  4,  4,  5,  3,  4,  4,  5,  4,  5,  5,  6,
      3,  4,  4,  5,  4,  5,  5,  6,  4,  5,  5,  6,  5,  6,  6,  7,
      3,  4,  4,  5,  4,  5,  5,  6,  4,  5,  5,  6,  5,  6,  6,  7,
      4,  5,  5,  6,  5,  6,  6,  7,  5,  6,  6,  7,  6,  7,  7,  8
}

Definition at line 656 of file dvirle2.c.

int NewPage

Definition at line 76 of file dvirle2.c.

Referenced by FormFeed().

int NLines

Definition at line 82 of file dvirle2.c.

Referenced by ReadInput().

char* optarg

Definition at line 29 of file getopt.c.

int optind

Definition at line 30 of file getopt.c.

rle_hdr out_hdr

Definition at line 89 of file dvirle2.c.

int outwidth

Definition at line 87 of file dvirle2.c.

int PageHeight

Definition at line 83 of file dvirle2.c.

Referenced by EndPage().

int PageWidth

Definition at line 83 of file dvirle2.c.

Referenced by EndPage().

const char* pic_comments[]

Initial value:

= {
    "Creator=DVIRLE",
    "Note=Created from DVI file at 300 dots/inch",
    0
}

Definition at line 91 of file dvirle2.c.

char* ProgName

Definition at line 57 of file dvirle2.c.

int RasterOrientation

Definition at line 66 of file dvirle2.c.

char rcsid[] = "$Id: dvirle2.c,v 3.0.1.1 1992/01/21 19:26:59 spencer Exp $"

static

Definition at line 2 of file dvirle2.c.

int SFlag

Definition at line 70 of file dvirle2.c.

Referenced by EndPage(), ReadFonts(), and ReadInput().

char TeXFontDesc[256]

Definition at line 64 of file dvirle2.c.

int TFlag

Definition at line 71 of file dvirle2.c.

unsigned char VBuffer[600 ][319 ]

Definition at line 74 of file dvirle2.c.

Referenced by DumpTopOfBand(), and ReadInput().