dvirle1.c File Reference

#include "rle_config.h"
#include <stdio.h>
#include "types.h"
#include "conv.h"
#include "dviclass.h"
#include "dvicodes.h"
#include "error.h"
#include "fio.h"
#include "font.h"
#include "gripes.h"
#include "dvistate.h"
#include "dvirle.h"

Include dependency graph for dvirle1.c:

Go to the source code of this file.

Macros
#define	InitialChars   4000 /* initial number of chars to allocate */
#define	ABS(n)   ((n) >= 0 ? (n) : -(n))
#define	maxysize   min(MaxCharHeight, 255)
#define	CHECK(cond, msg, flag)

Functions
void	ComputeCWidths (struct font *f)
void	ExpandArrays ()
void	SortPage ()
struct font *	DefineFont (char *name, i32 dvimag, i32 dvidsz)
void	BeginPage (i32 *count)
void	EndPage ()
void	DoSpecial (i32 len)
void	SetRule (int h, int w)
int	CheckChar (i32 c)
int	PageLoop ()
void	main (int argc, char **argv)

Variables
static char	rcsid [] = "$Id: dvirle1.c,v 3.0.1.3 1992/02/28 22:12:53 spencer Exp $"
char *	ProgName
char *	optarg
int	optind
char	serrbuf [ 8192 ]
const char *	DVIFileName
const char *	TeXFontDesc
int	Chars
int	MaxChars
int *	yx
int *	fcp
int *	nextyx
int *	nextfcp
int	TopEMsg
int	BottomEMsg
int	LeftEMsg
int	RightEMsg
int	RuleEMsg
int	CFlag
int	HFlag
int	SFlag
int	Debug
int	BottomMargin
int	TopMargin
int	WidestPageWidth
int	TallestPageHeight
int	PageWidth
int	PageHeight

Macro Definition Documentation

#define ABS

(

n

)

((n) >= 0 ? (n) : -(n))

Definition at line 89 of file dvirle1.c.

#define CHECK	(		cond,
			msg,
			flag
	)

Value:

if (cond) { \
		if (!flag) { \
			error(0, 0, warn, msg); \
            flag = 1; \
        } \
        goto ignore; \
    }

#define InitialChars   4000 /* initial number of chars to allocate */

Definition at line 62 of file dvirle1.c.

#define maxysize   min(MaxCharHeight, 255)

Definition at line 320 of file dvirle1.c.

Function Documentation

void BeginPage

(

i32 *

count

)

Definition at line 221 of file dvirle1.c.

{

    if (!SFlag) {
        if (nextyx)
            (void) putc(' ', stderr);
        (void) fprintf(stderr, "[%d", (int)count[0]);
        (void) fflush(stderr);
    }

    /* Chars now becomes "number of characters left" */
    Chars = MaxChars;   /* empty the arrays */
    nextyx = yx;
    nextfcp = fcp;

    TopEMsg = 0;
    BottomEMsg = 0;
    LeftEMsg = 0;
    RightEMsg = 0;
    RuleEMsg = 0;
}

int CheckChar

(

i32

c

)

Definition at line 386 of file dvirle1.c.

{
    /* this driver needs work for codes > 127 */

    if ((ui32)c > 127) {
        error(0, 0, "Warning: character code %ld too big",
            (long)c);
        return (1);
    }
    return (0);
}

void ComputeCWidths

(

struct font *

f

)

Definition at line 96 of file dvirle1.c.

{
    register struct glyph *g;
    register int i;

    for (i = 0; i < 128; i++) {
        g = GLYPH(f, i);
        if (GVALID(g))
            g->g_pixwidth = fromSP(g->g_tfmwidth);
    }
}

struct font* DefineFont	(	char *	name,
		i32	dvimag,
		i32	dvidsz
	)

Definition at line 173 of file dvirle1.c.

{
    register struct font *f;
    char *path;
    int len;
    static int next; /* dvirle2 knows that we use sequential indicies */

    if (next >= NFONTS) /* fix this later */
        error(1, 0, "too many fonts (%d) used", next);

    f = GetRasterlessFont(name, dvimag, dvidsz, "versatec", &path);
    if (f == NULL) {
        GripeCannotGetFont(name, dvimag, dvidsz, "versatec", path);
        return (NULL);
    }
    if (Debug) {
        (void) fprintf(stderr, "[%s -> %s]\n", Font_TeXName(f), path);
        (void) fflush(stderr);
    }
    if (next == 0) {
        /*
         * dvirle2 also needs the conversion factor,
         * before the first font.
         */
        PutLong(stdout, 300);   /* dots per inch */
        PutLong(stdout, ds.ds_usermag);
        PutLong(stdout, ds.ds_num);
        PutLong(stdout, ds.ds_denom);
        PutLong(stdout, ds.ds_dvimag);
    }
    putbyte(stdout, 1); /* signal another font */
    PutLong(stdout, f->f_checksum);
    PutLong(stdout, dvimag);
    PutLong(stdout, dvidsz);
    len = strlen(name);
    PutLong(stdout, len);
    (void) fputs(name, stdout);
    ComputeCWidths(f);
    f->f_un.f_int = next++;
    return (f);
}

void DoSpecial

(

i32

len

)

Definition at line 310 of file dvirle1.c.

{

    error(0, 0, "warning: ignoring \\special");
    (void) fseek(ds.ds_fp, (long) len, 1);
}

void EndPage

(

)

Definition at line 248 of file dvirle1.c.

References Chars, Debug, fcp, HFlag, MaxChars, PageHeight, PageWidth, SFlag, and yx.

{
    register int i, *y, *f, t, v, oldv;

    /* Chars now becomes "number of characters on page" */
    i = Chars = MaxChars - Chars;

    SortPage();

    if (!SFlag) {
        putc(']', stderr);
        (void) fflush(stderr);
    }
    y = yx;
    f = fcp;
    if ( HFlag )
        oldv = PageWidth;
    else
        oldv = PageHeight;
    while (--i >= 0) {
            if ( Debug > 1 )
            fprintf( stderr, "oldv: %ld, yx: %lx (%d,%d), fcp: %lx\n",
                 oldv, *y, (*y >> 16), (*y & 0xffff), *f );
        v = *y >> 16;
        t = oldv - v;
        if (*f >= 0) {  /* setting a character */
            t = (t << 16) | (*y++ & 0xffff);
            PutLong(stdout, t);
            t = *f++;
            PutLong(stdout, t); /* move down & place char */
        } else {    /* setting a rule */
            y++;
            if (t > 0) {    /* need to move down first */
                t = -t;
                PutLong(stdout, -1);
                PutLong(stdout, t);
            }
            t = *f++ & 0x7fffffff;
            PutLong(stdout, -1);
            PutLong(stdout, t); /* place rule */
        }
        oldv = v;
    }

    /* Make all pages the same length */
    if (HFlag)
        t = -PageWidth;
    else
        t = -PageHeight;
    if (t) {
        PutLong(stdout, -1);    /* move down */
        PutLong(stdout, t);
    }
    PutLong(stdout, -1);
    PutLong(stdout, 0); /* end of page */
}

void ExpandArrays

(

)

Definition at line 113 of file dvirle1.c.

References Chars, fcp, MaxChars, nextfcp, nextyx, and yx.

{
    register unsigned newsize;

    MaxChars <<= 1;
    newsize = MaxChars * sizeof *yx;
    if ((yx = (int *) realloc((char *) yx, newsize)) == NULL)
        GripeOutOfMemory(newsize, "yx array");
    if ((fcp = (int *) realloc((char *) fcp, newsize)) == NULL)
        GripeOutOfMemory(newsize, "fcp array");
    Chars = MaxChars >> 1;
    nextyx = &yx[Chars];
    nextfcp = &fcp[Chars];
    --Chars;        /* we're about to use one */
}

void main	(	int	argc,
		char **	argv
	)

Definition at line 684 of file dvirle1.c.

{
    register int c;
    register CONST_DECL char *s;
    int lmargin;
    FILE *fp = stdin;

    setbuf(stderr, serrbuf);

    ProgName = *argv;
    ds.ds_usermag = 1000;
    ds.ds_maxdrift = DefaultMaxDrift;
    DVIFileName = "`stdin'";

    while ((c = getopt(argc, argv, "cd:hm:sD")) != EOF) {
        switch (c) {

        case 'c':
            CFlag++;/* centered output */
            break;

        case 'd':   /* max drift value */
            ds.ds_maxdrift = atoi(optarg);
            break;

        case 'h':   /* horizontal output */
            HFlag++;
            break;

        case 'm':   /* magnification */
            ds.ds_usermag = atoi(optarg);
            break;

        case 's':   /* silent */
            SFlag++;
            break;

        case 'D':
            Debug++;
            break;

        case '?':
            (void) fprintf(stderr, "\
Usage: %s [-c] [-h] [-m mag] [-s] [file]\n", ProgName);
            (void) fflush(stderr);
            exit(1);
        }
    }

    if (optind < argc)
        if ((fp = fopen(DVIFileName = argv[optind], "r")) == NULL)
            error(1, -1, "can't open %s", argv[optind]);

#ifdef notdef
    if (MakeSeekable(stdin))
        error(1, 0,
            "unable to copy input to temp file (see the manual)");
#endif

    if ((TeXFontDesc = getenv(CONFENV)) == NULL)
        TeXFontDesc = "";

    c = (VERSION << 1) + (HFlag ? 1 : 0);
    putbyte(stdout, c);
    c = strlen(s = TeXFontDesc);
    PutLong(stdout, c);
    while (--c >= 0)
        putbyte(stdout, *s++);

    /* the margin offsets here are 0; margins computed later */
    DVISetState(fp, DefineFont, 300, 0, 0);
    putbyte(stdout, 0); /* Signal end of fonts. */
    TallestPageHeight = fromSP(ds.ds_maxheight);
    WidestPageWidth = fromSP(ds.ds_maxwidth);

    /*
     * The character plotter must check each character to ensure it
     * is on the page, because the widest and tallest page values from
     * the DVI file are not always accurate; so these tests do little
     * save to keep one from finding the offending object.  Accordingly,
     * I have disabled them.  20 May 1984 ACT.
     */
#ifdef notdef
    if (HFlag) {
        if (MaxPageWidth - MinimumLeftMargin < TallestPageHeight)
            error(1, 0, "text object too high!");
        if (MaxPageHeight - MinimumTopMargin < WidestPageWidth)
            error(1, 0, "text object too wide!");
    } else {        /* page height can be safely ignored */
        if (MaxPageWidth - MinimumLeftMargin < WidestPageWidth)
            error(1, 0, "text object too wide!");
    }
#endif

    /* Determine margins */
    if (CFlag) {
        lmargin = (MaxPageWidth - WidestPageWidth) >> 1;
        if (lmargin < MinimumLeftMargin) {
            lmargin = MinimumLeftMargin;
            error(0, 0, "\
cannot center (page too wide); placing flush left instead");
        }
    } else
        lmargin = HFlag ? DefaultTopMargin : DefaultLeftMargin;

    if (HFlag) {
        TopMargin = (MaxPageHeight - WidestPageWidth) >> 1;
        if (TopMargin < 0)
            TopMargin = 0;
        BottomMargin = MaxPageHeight - TopMargin - WidestPageWidth;
        if (BottomMargin < 0)
            BottomMargin = 0;
    } else {
        TopMargin = DefaultTopMargin;
        BottomMargin = DefaultBottomMargin;
    }

    PageHeight = TallestPageHeight + BottomMargin + TopMargin;
    PageWidth = WidestPageWidth + BottomMargin + TopMargin;
    if ( HFlag )
    {
        if ( PageHeight > MaxPageWidth )
        {
        fprintf( stderr,
             "Page too high (%d bits), truncated to %d bits\n",
             PageHeight, MaxPageWidth );
        PageHeight = MaxPageWidth;
        }
        PutLong(stdout, PageWidth);
        PutLong(stdout, PageHeight);
    }
    else
    {
        if ( PageWidth > MaxPageWidth )
        {
        fprintf( stderr,
             "Page too wide (%d bits), truncated to %d bits\n",
             PageWidth, MaxPageWidth );
        PageWidth = MaxPageWidth;
        }
        PutLong(stdout, PageHeight);
        PutLong(stdout, PageWidth);
    }

    /* set the `fresh page' margins */
    ds.ds_fresh.hh = lmargin;
    ds.ds_fresh.vv = TopMargin;
    ds.ds_fresh.h = toSP(ds.ds_fresh.hh);
    ds.ds_fresh.v = toSP(ds.ds_fresh.vv);

    /* Allocate arrays */
    MaxChars = InitialChars;
    if ((yx = (int *) malloc(InitialChars * sizeof *yx)) == NULL)
        GripeOutOfMemory(InitialChars * sizeof *yx, "yx array");
    if ((fcp = (int *) malloc(InitialChars * sizeof *fcp)) == NULL)
        GripeOutOfMemory(InitialChars * sizeof *fcp, "fcp array");

    while (PageLoop())
        /* void */;

    exit(0);
    /* NOTREACHED */
}

int PageLoop

(

)

Definition at line 404 of file dvirle1.c.

References BottomEMsg, Chars, HFlag, LeftEMsg, nextyx, and TopEMsg.

{
    static struct font NoFont;  /* font with zero pspace, etc */
    register int c;
    register i32 p = 0;
    register struct font *f = &NoFont;
    register FILE *fp = ds.ds_fp;
    int doingpage = 0, advance;

    static char warn[] = "\
WARNING: text object(s) run off %s of page; ignored";
#define CHECK(cond, msg, flag) \
    if (cond) { \
        if (!flag) { \
            error(0, 0, warn, msg); \
            flag = 1; \
        } \
        goto ignore; \
    }

    /*
     * This would be a `for (;;)', but that makes the function
     * crawl off the right of the screen.
     *
     * We handle ordinary characters early, as they are the
     * most common opcodes in DVI files, and doing so makes the
     * loop run faster.
     */
loop:
    c = fgetbyte(fp);
    if (DVI_IsChar(c)) {
        register struct glyph *g;
        register int ulcx, ulcy, height;

        p = c;
        advance = 1;
do_char:
        g = GLYPH(f, p);
        if (!GVALID(g)) {
            GripeBadGlyph(p, f);
            goto loop;
        }
        if (!HFlag) {
            ulcy = dvi_vv + g->g_height - g->g_yorigin;
            ulcx = dvi_hh - g->g_xorigin;
            height = g->g_height;
            CHECK(ulcy < 0, "top", TopEMsg);
            CHECK(ulcx < 0, "left", LeftEMsg);
            CHECK(ulcx + g->g_width >= MaxPageWidth,
                "right", RightEMsg);
        } else {/* rotate & translate */
            ulcy = dvi_hh + g->g_width - g->g_xorigin;
            ulcx = MaxPageWidth -
                (dvi_vv + g->g_height - g->g_yorigin);
            height = g->g_width;
            CHECK(ulcy < 0, "left", LeftEMsg);
#ifdef notdef
            CHECK(ulcy + height >= MaxPageHeight,
                "right", RightEMsg);
#endif
            CHECK(ulcx < 0, "bottom", BottomEMsg);
            CHECK(ulcx + g->g_height >= MaxPageWidth,
                "top", TopEMsg);
        }
        for (c = 0; height > 0; c++) {
            if (--Chars < 0)
                ExpandArrays();
            *nextyx++ = (ulcy << 16) | ulcx;
            *nextfcp++ = (f->f_un.f_int << FONTSHIFT) |
                ((p & CHARMASK) << CHARSHIFT) | c;
            height -= MaxCharHeight;
            ulcy += MaxCharHeight;
        }
ignore:
        if (advance) {
            dvi_h += g->g_tfmwidth;
            dvi_hh += g->g_pixwidth;
            p = fromSP(dvi_h);
            FIXDRIFT(dvi_hh, p);
        }
        goto loop;
    }

    if (c == EOF)       /* unexpected end of DVI file */
        GripeUnexpectedDVIEOF();

    /*
     * Gather up a parameter, if known.
     */
    switch (DVI_OpLen(c)) {

    case DPL_NONE:
        break;

    case DPL_SGN1:
        p = fgetbyte(fp);
        p = Sign8(p);
        break;

    case DPL_SGN2:
        fGetWord(fp, p);
        p = Sign16(p);
        break;

    case DPL_SGN3:
        fGet3Byte(fp, p);
        p = Sign24(p);
        break;

    case DPL_SGN4:
        fGetLong(fp, p);
        break;

    case DPL_UNS1:
        p = fgetbyte(fp);
        p = UnSign8(p);
        break;

    case DPL_UNS2:
        fGetWord(fp, p);
        p = UnSign16(p);
        break;

    case DPL_UNS3:
        fGet3Byte(fp, p);
        p = UnSign24(p);
        break;

    default:
        panic("DVI_OpLen(%d) = %d", c, DVI_OpLen(c));
        /* NOTREACHED */
    }

    /*
     * Now switch on the type.
     */
    switch (DVI_DT(c)) {

    case DT_SET:
        advance = 1;
        if (CheckChar(p))
            goto loop;
        goto do_char;

    case DT_PUT:
        advance = 0;
        if (CheckChar(p))
            goto loop;
        goto do_char;

    case DT_SETRULE:
        DVIRule(SetRule, 1);
        goto loop;

    case DT_PUTRULE:
        DVIRule(SetRule, 0);
        goto loop;

    case DT_NOP:
        goto loop;

    case DT_BOP:
        if (doingpage)
            GripeUnexpectedOp("BOP (already in page)");
        DVIBeginPage(BeginPage);
        doingpage = 1;
        goto loop;

    case DT_EOP:
        if (!doingpage)
            GripeUnexpectedOp("EOP (no BOP)");
        EndPage();
        return (1);

    case DT_PUSH:
        *ds.ds_sp++ = ds.ds_cur;
        goto loop;

    case DT_POP:
        ds.ds_cur = *--ds.ds_sp;
        goto loop;

    case DT_W0:
        p = dvi_w;
        goto right;

    case DT_W:
        dvi_w = p;
        goto right;

    case DT_X0:
        p = dvi_x;
        goto right;

    case DT_X:
        dvi_x = p;
        goto right;

    case DT_RIGHT:
right:
        dvi_h += p;
        if (F_SMALLH(f, p)) {
            dvi_hh += fromSP(p);
            p = fromSP(dvi_h);
            FIXDRIFT(dvi_hh, p);
        } else
            dvi_hh = fromSP(dvi_h);
        goto loop;

    case DT_Y0:
        p = dvi_y;
        goto down;

    case DT_Y:
        dvi_y = p;
        goto down;

    case DT_Z0:
        p = dvi_z;
        goto down;

    case DT_Z:
        dvi_z = p;
        goto down;

    case DT_DOWN:
down:
        dvi_v += p;
        if (F_SMALLV(f, p)) {
            dvi_vv += fromSP(p);
            p = fromSP(dvi_v);
            FIXDRIFT(dvi_vv, p);
        } else
            dvi_vv = fromSP(dvi_v);
        goto loop;

    case DT_FNTNUM:
        f = DVIFindFont((i32)(c - DVI_FNTNUM0));
        goto loop;

    case DT_FNT:
        f = DVIFindFont(p);
        goto loop;

    case DT_XXX:
        DoSpecial(p);
        goto loop;

    case DT_FNTDEF:
        SkipFontDef(fp);
        goto loop;

    case DT_PRE:
        GripeUnexpectedOp("PRE");
        /* NOTREACHED */

    case DT_POST:
        if (doingpage) {
            GripeUnexpectedOp("POST (no EOP)");
            /* NOTREACHED */
        }
        return (0);

    case DT_POSTPOST:
        GripeUnexpectedOp("POSTPOST");
        /* NOTREACHED */

    case DT_UNDEF:
        GripeUndefinedOp(c);
        /* NOTREACHED */

    default:
        panic("DVI_DT(%d) = %d", c, DVI_DT(c));
        /* NOTREACHED */
    }
    /* NOTREACHED */
}

void SetRule	(	int	h,
		int	w
	)

Definition at line 331 of file dvirle1.c.

{
    register int y;     /* temporary y value */
    register int x;     /* temporary x value */
    register int ymax;  /* bottommost (versatec-wise) y coord */
    register int xmax;  /* rightmost (versatec-wise) x coord */
    register int ymin;  /* topmost y coord */
    register int xmin;  /* leftmost x coord */
    int anybad = 0;

    if (!HFlag) {
        xmin = dvi_hh;
        ymax = dvi_vv;
        ymin = ymax - h;
        xmax = xmin + w;
    } else {
        ymin = dvi_hh;
        xmin = MaxPageWidth - dvi_vv - 1;/* ???DO I NEED -1 ANYMORE?? */
        xmax = xmin + h;
        ymax = ymin + w;
#ifdef notdef
        if (ymax > MaxPageHeight)
            ymax = MaxPageHeight, anybad++;
#endif
    }
    if (ymin < 0)
        ymin = 0, anybad++;
    if (xmin < 0)
        xmin = 0, anybad++;
    if (xmax > MaxPageWidth)
        xmax = MaxPageWidth, anybad++;
    if (anybad && !RuleEMsg) {
        error(0, 0, "WARNING: rule(s) off page edge; clipped to fit");
        RuleEMsg++;
    }
    for (y = ymax; y > ymin; y -= h) {
        for (x = xmin; x < xmax; x += w) {
            h = y - ymin;
            h = min(h, maxysize);
            w = xmax - x;
            w = min(w, 255);
            if (--Chars < 0)
                ExpandArrays();
            *nextyx++ = (y << 16) | x;
            *nextfcp++ = (1 << 31) | (x << 16) | (h << 8) | w;
        }
    }
}

void SortPage

(

)

Definition at line 134 of file dvirle1.c.

References Chars, fcp, and yx.

{
    register int i, j, k, delta, *y, *f;

    /*
     * Chars is currently the number of chars on the page, not the number
     * of chars left in the array.
     */
    y = yx;
    f = fcp;
    delta = 1;
    while (9 * delta + 4 < Chars)
        delta = 3 * delta + 1;
    while (delta > 0) {
        for (i = delta; i < Chars; i++) {
            if (y[j = i - delta] < y[i]) {
                register int t1 = y[i];
                register int t2 = f[i];

                k = i;
                do {
                    y[k] = y[j];
                    f[k] = f[j];
                    k = j;
                    j -= delta;
                } while (j >= 0 && y[j] < t1);
                y[k] = t1;
                f[k] = t2;
            }
        }
        delta /= 3;
    }
}

Variable Documentation

int BottomEMsg

Definition at line 70 of file dvirle1.c.

Referenced by PageLoop().

int BottomMargin

Definition at line 80 of file dvirle1.c.

int CFlag

Definition at line 75 of file dvirle1.c.

int Chars

Definition at line 49 of file dvirle1.c.

Referenced by EndPage(), ExpandArrays(), PageLoop(), and SortPage().

int Debug

Definition at line 78 of file dvirle1.c.

const char* DVIFileName

Definition at line 44 of file dvirle1.c.

int* fcp

Definition at line 52 of file dvirle1.c.

Referenced by EndPage(), ExpandArrays(), and SortPage().

int HFlag

Definition at line 76 of file dvirle1.c.

int LeftEMsg

Definition at line 71 of file dvirle1.c.

Referenced by PageLoop().

int MaxChars

Definition at line 50 of file dvirle1.c.

Referenced by EndPage(), and ExpandArrays().

int* nextfcp

Definition at line 54 of file dvirle1.c.

Referenced by ExpandArrays().

int* nextyx

Definition at line 53 of file dvirle1.c.

Referenced by ExpandArrays(), and PageLoop().

char* optarg

Definition at line 29 of file getopt.c.

int optind

Definition at line 30 of file getopt.c.

int PageHeight

Definition at line 85 of file dvirle1.c.

int PageWidth

Definition at line 84 of file dvirle1.c.

char* ProgName

Definition at line 37 of file dvirle1.c.

char rcsid[] = "$Id: dvirle1.c,v 3.0.1.3 1992/02/28 22:12:53 spencer Exp $"

static

Definition at line 2 of file dvirle1.c.

int RightEMsg

Definition at line 72 of file dvirle1.c.

int RuleEMsg

Definition at line 73 of file dvirle1.c.

char serrbuf[ 8192 ]

Definition at line 42 of file dvirle1.c.

int SFlag

Definition at line 77 of file dvirle1.c.

int TallestPageHeight

Definition at line 83 of file dvirle1.c.

const char* TeXFontDesc

Definition at line 46 of file dvirle1.c.

int TopEMsg

Definition at line 69 of file dvirle1.c.

Referenced by PageLoop().

int TopMargin

Definition at line 81 of file dvirle1.c.

int WidestPageWidth

Definition at line 82 of file dvirle1.c.

int* yx

Definition at line 51 of file dvirle1.c.

Referenced by EndPage(), ExpandArrays(), and SortPage().