/*
* DVI previewer for X.
*
* Eric Cooper, CMU, September 1985.
*
* Code derived from dvi-imagen.c.
*
* Modification history:
* 1/1986       Modified for X.10       --Bob Scheifler, MIT LCS.
* 7/1988       Modified for X.11       --Mark Eichin, MIT
* 12/1988      Added 'R' option, toolkit, magnifying glass
*                                      --Paul Vojta, UC Berkeley.
* 2/1989       Added tpic support      --Jeffrey Lee, U of Toronto
* 4/1989       Modified for System V   --Donald Richardson, Clarkson Univ.
* 3/1990       Added VMS support       --Scott Allendorf, U of Iowa
* 7/1990       Added reflection mode   --Michael Pak, Hebrew U of Jerusalem
* 1/1992       Added greyscale code    --Till Brychcy, Techn. Univ. Muenchen
*                                        and Lee Hetherington, MIT
*
*      Compilation options:
*      SYSV    compile for System V
*      VMS     compile for VMS
*      X10     compile for X10
*      NOTOOL  compile without toolkit (X11 only)
*      BUTTONS compile with buttons on the side of the window (needs toolkit)
*      MSBITFIRST      store bitmaps internally with most significant bit first
*      BMSHORT store bitmaps in shorts instead of bytes
*      BMLONG  store bitmaps in longs instead of bytes
*      ALTFONT default for -altfont option
*      A4      use European size paper
*      TEXXET  support reflection dvi codes (right-to-left typesetting)
*      GREY    use grey levels to shrink fonts
*/

#include <ctype.h>
#include "xdvi.h"
#include "dvi.h"

#ifndef X_NOT_STDC_ENV
#include <stdlib.h>
#endif

#if     NeedVarargsPrototypes           /* this is for tell_oops */
#include <stdarg.h>
#else
#include <varargs.h>
#endif

#ifdef  DOPRNT  /* define this if vfprintf gives you trouble */
#define vfprintf(stream, message, args) _doprnt(message, args, stream)
#endif

static  struct frame    frame0;         /* dummy head of list */
#ifdef  TEXXET
static  struct frame    *scan_frame;    /* head frame for scanning */
#endif

#ifndef DVI_BUFFER_LEN
#define DVI_BUFFER_LEN  512
#endif

static  ubyte   dvi_buffer[DVI_BUFFER_LEN];
static  struct frame    *current_frame;

#ifndef TEXXET
#define DIR     1
#else
#define DIR     currinf.dir
#endif

/*
*      Explanation of the following constant:
*      offset_[xy]   << 16:    margin (defaults to one inch)
*      shrink_factor << 16:    one pixel page border
*      shrink_factor << 15:    rounding for pixel_conv
*/
#define OFFSET_X        (offset_x << 16) + (shrink_factor * 3 << 15)
#define OFFSET_Y        (offset_y << 16) + (shrink_factor * 3 << 15)

#ifndef BMLONG
#ifndef BMSHORT
unsigned char   bit_masks[9] = {
       0x0,    0x1,    0x3,    0x7,
       0xf,    0x1f,   0x3f,   0x7f,
       0xff
};
#else   /* BMSHORT */
unsigned short  bit_masks[17] = {
       0x0,    0x1,    0x3,    0x7,
       0xf,    0x1f,   0x3f,   0x7f,
       0xff,   0x1ff,  0x3ff,  0x7ff,
       0xfff,  0x1fff, 0x3fff, 0x7fff,
       0xffff
};
#endif  /* BMSHORT */
#else   /* BMLONG */
unsigned long   bit_masks[33] = {
       0x0,            0x1,            0x3,            0x7,
       0xf,            0x1f,           0x3f,           0x7f,
       0xff,           0x1ff,          0x3ff,          0x7ff,
       0xfff,          0x1fff,         0x3fff,         0x7fff,
       0xffff,         0x1ffff,        0x3ffff,        0x7ffff,
       0xfffff,        0x1fffff,       0x3fffff,       0x7fffff,
       0xffffff,       0x1ffffff,      0x3ffffff,      0x7ffffff,
       0xfffffff,      0x1fffffff,     0x3fffffff,     0x7fffffff,
       0xffffffff
};
#endif  /* BMLONG */

#ifdef  VMS
#define off_t   int
#endif
extern  off_t   lseek();

#ifndef SEEK_SET        /* if <unistd.h> is not provided (or for <X11R5) */
#define SEEK_SET        0
#define SEEK_CUR        1
#define SEEK_END        2
#endif

static  void    draw_part();

/*
*      Byte reading routines for dvi file.
*/

#define xtell(pos)      (lseek(fileno(dvi_file), 0L, SEEK_CUR) - \
                           (currinf.end - (pos)))

static  ubyte
xxone()
{
       if (currinf.virtual) {
           ++currinf.pos;
           return EOP;
       }
       currinf.end = dvi_buffer +
           read(fileno(dvi_file), (char *) (currinf.pos = dvi_buffer),
               DVI_BUFFER_LEN);
       return currinf.end > dvi_buffer ? *(currinf.pos)++ : EOF;
}

#define xone()  (currinf.pos < currinf.end ? *(currinf.pos)++ : xxone())

static  unsigned long
xnum(size)
       register ubyte size;
{
       register long x = 0;

       while (size--) x = (x << 8) | xone();
       return x;
}

static  long
xsnum(size)
       register ubyte size;
{
       register long x;

#ifdef  __STDC__
       x = (signed char) xone();
#else
       x = xone();
       if (x & 0x80) x -= 0x100;
#endif
       while (--size) x = (x << 8) | xone();
       return x;
}

#define xsfour()        xsnum(4)

static  void
xskip(offset)
       long    offset;
{
       currinf.pos += offset;
       if (!currinf.virtual && currinf.pos > currinf.end)
           (void) lseek(fileno(dvi_file), (long) (currinf.pos - currinf.end),
               SEEK_CUR);
}

#if     NeedVarargsPrototypes
static  NORETURN void
tell_oops(_Xconst char *message, ...)
#else
/* VARARGS */
static  NORETURN void
tell_oops(va_alist)
       va_dcl
#endif
{
#if     !NeedVarargsPrototypes
       _Xconst char *message;
#endif
       va_list args;

       Fprintf(stderr, "%s: ", prog);
#if     NeedVarargsPrototypes
       va_start(args, message);
#else
       va_start(args);
       message = va_arg(args, _Xconst char *);
#endif
       (void) vfprintf(stderr, message, args);
       va_end(args);
       if (currinf.virtual)
           Fprintf(stderr, " in virtual font %s\n", currinf.virtual->fontname);
       else
           Fprintf(stderr, ", offset %ld\n", xtell(currinf.pos - 1));
       exit(1);
}


/*
*      Code for debugging options.
*/

static  void
print_bitmap(bitmap)
       register struct bitmap *bitmap;
{
       register BMUNIT *ptr = (BMUNIT *) bitmap->bits;
       register int x, y, i;

       if (ptr == NULL) oops("print_bitmap called with null pointer.");
       Printf("w = %d, h = %d, bytes wide = %d\n",
           bitmap->w, bitmap->h, bitmap->bytes_wide);
       for (y = 0; y < bitmap->h; ++y) {
           for (x = bitmap->bytes_wide; x > 0; x -= BYTES_PER_BMUNIT) {
#ifndef MSBITFIRST
               for (i = 0; i < BITS_PER_BMUNIT; ++i)
#else
               for (i = BITS_PER_BMUNIT - 1; i >= 0; --i)
#endif
                   Putchar((*ptr & (1 << i)) ? '@' : ' ');
               ++ptr;
           }
           Putchar('\n');
       }
}

static  void
print_char(ch, g)
       ubyte ch;
       struct glyph *g;
{
       Printf("char %d", ch);
       if (isprint(ch))
           Printf(" (%c)", ch);
       Putchar('\n');
       Printf("x = %d, y = %d, dvi = %ld\n", g->x, g->y, g->dvi_adv);
       print_bitmap(&g->bitmap);
}

static  _Xconst char    *dvi_table1[] = {
       "SET1", NULL, NULL, NULL, "SETRULE", "PUT1", NULL, NULL,
       NULL, "PUTRULE", "NOP", "BOP", "EOP", "PUSH", "POP", "RIGHT1",
       "RIGHT2", "RIGHT3", "RIGHT4", "W0", "W1", "W2", "W3", "W4",
       "X0", "X1", "X2", "X3", "X4", "DOWN1", "DOWN2", "DOWN3",
       "DOWN4", "Y0", "Y1", "Y2", "Y3", "Y4", "Z0", "Z1",
       "Z2", "Z3", "Z4"};

static  _Xconst char    *dvi_table2[] = {
       "FNT1", "FNT2", "FNT3", "FNT4", "XXX1", "XXX2", "XXX3", "XXX4",
       "FNTDEF1", "FNTDEF2", "FNTDEF3", "FNTDEF4", "PRE", "POST", "POSTPOST",
       "SREFL", "EREFL", NULL, NULL, NULL, NULL};

static  void
print_dvi(ch)
       ubyte ch;
{
       _Xconst char    *s;

       Printf("%4d %4d ", PXL_H, PXL_V);
       if (ch <= SETCHAR0 + 127) {
           Printf("SETCHAR%-3d", ch - SETCHAR0);
           if (isprint(ch))
               Printf(" (%c)", ch);
           Putchar('\n');
           return;
       }
       else if (ch < FNTNUM0) s = dvi_table1[ch - 128];
       else if (ch <= FNTNUM0 + 63) {
           Printf("FNTNUM%d\n", ch - FNTNUM0);
           return;
       }
       else s = dvi_table2[ch - (FNTNUM0 + 64)];
       if (s) Puts(s);
       else
           tell_oops("unknown op-code %d", ch);
}


/*
*      Count the number of set bits in a given region of the bitmap
*/

char    sample_count[]  = {0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4};

static  int
sample(bits, bytes_wide, bit_skip, w, h)
       BMUNIT  *bits;
       int     bytes_wide, bit_skip, w, h;
{
       BMUNIT  *ptr, *endp;
       register BMUNIT *cp;
       int     bits_left;
       register int n, bit_shift, wid;

       ptr = bits + bit_skip / BITS_PER_BMUNIT;
       endp = ADD(bits, h * bytes_wide);
       bits_left = w;
#ifndef MSBITFIRST
       bit_shift = bit_skip % BITS_PER_BMUNIT;
#else
       bit_shift = BITS_PER_BMUNIT - bit_skip % BITS_PER_BMUNIT;
#endif
       n = 0;
       while (bits_left) {
#ifndef MSBITFIRST
           wid = BITS_PER_BMUNIT - bit_shift;
#else
           wid = bit_shift;
#endif
           if (wid > bits_left) wid = bits_left;
           if (wid > 4) wid = 4;
#ifdef  MSBITFIRST
           bit_shift -= wid;
#endif
           for (cp = ptr; cp < endp; cp = ADD(cp, bytes_wide))
               n += sample_count[(*cp >> bit_shift) & bit_masks[wid]];
#ifndef MSBITFIRST
           bit_shift += wid;
           if (bit_shift == BITS_PER_BMUNIT) {
               bit_shift = 0;
               ++ptr;
           }
#else
           if (bit_shift == 0) {
               bit_shift = BITS_PER_BMUNIT;
               ++ptr;
           }
#endif
           bits_left -= wid;
       }
       return n;
}

#ifdef  GREY
static  void
shrink_glyph_grey(g)
       register struct glyph *g;
{
       int     rows_left, rows, init_cols, cols_left;
       register int    cols;
       int     x, y;
       long    thesample;
       BMUNIT  *old_ptr;

       /* These machinations ensure that the character is shrunk according to
          its hot point, rather than its upper left-hand corner. */
       g->x2 = g->x / shrink_factor;
       init_cols = g->x - g->x2 * shrink_factor;
       if (init_cols <= 0) init_cols += shrink_factor;
       else ++g->x2;
       g->bitmap2.w = g->x2 + ROUNDUP(g->bitmap.w - g->x, shrink_factor);
       /* include row zero with the positively numbered rows */
       cols = g->y + 1; /* spare register variable */
       g->y2 = cols / shrink_factor;
       rows = cols - g->y2 * shrink_factor;
       if (rows <= 0) {
           rows += shrink_factor;
           --g->y2;
       }
       g->bitmap2.h = g->y2 + ROUNDUP(g->bitmap.h - cols, shrink_factor) + 1;

       g->image2 = XCreateImage(DISP, DefaultVisualOfScreen(SCRN),
                                DefaultDepthOfScreen(SCRN),
                                ZPixmap, 0, (char *) NULL,
                                g->bitmap2.w, g->bitmap2.h,
                                BITS_PER_BMUNIT, 0);
       g->pixmap2 = g->image2->data = xmalloc((unsigned)
                       g->image2->bytes_per_line * g->bitmap2.h,
                       "character pixmap");

       old_ptr = (BMUNIT *) g->bitmap.bits;
       rows_left = g->bitmap.h;
       y = 0;
       while (rows_left) {
           x = 0;
           if (rows > rows_left) rows = rows_left;
           cols_left = g->bitmap.w;
           cols = init_cols;
           while (cols_left) {
               if (cols > cols_left) cols = cols_left;

               thesample = sample(old_ptr, g->bitmap.bytes_wide,
                       g->bitmap.w - cols_left, cols, rows);
               XPutPixel(g->image2, x, y, pixeltbl[thesample]);

               cols_left -= cols;
               cols = shrink_factor;
               x++;
           }
           *((char **) &old_ptr) += rows * g->bitmap.bytes_wide;
           rows_left -= rows;
           rows = shrink_factor;
           y++;
       }

       while (y < g->bitmap2.h) {
           for (x = 0; x < g->bitmap2.w; x++)
               XPutPixel(g->image2, x, y, *pixeltbl);
           y++;
       }

       g->y2 = g->y / shrink_factor;
}
#endif  /* GREY */

static  void
shrink_glyph(g)
       register struct glyph *g;
{
       int shrunk_bytes_wide, shrunk_height;
       int rows_left, rows, init_cols, cols_left;
       register int cols;
       BMUNIT *old_ptr, *new_ptr;
       register BMUNIT m, *cp;
       int min_sample = shrink_factor * shrink_factor * density / 100;

       /* These machinations ensure that the character is shrunk according to
          its hot point, rather than its upper left-hand corner. */
       g->x2 = g->x / shrink_factor;
       init_cols = g->x - g->x2 * shrink_factor;
       if (init_cols <= 0) init_cols += shrink_factor;
       else ++g->x2;
       g->bitmap2.w = g->x2 + ROUNDUP(g->bitmap.w - g->x, shrink_factor);
       /* include row zero with the positively numbered rows */
       cols = g->y + 1; /* spare register variable */
       g->y2 = cols / shrink_factor;
       rows = cols - g->y2 * shrink_factor;
       if (rows <= 0) {
           rows += shrink_factor;
           --g->y2;
       }
       g->bitmap2.h = shrunk_height = g->y2 +
           ROUNDUP(g->bitmap.h - cols, shrink_factor) + 1;
       alloc_bitmap(&g->bitmap2);
       old_ptr = (BMUNIT *) g->bitmap.bits;
       new_ptr = (BMUNIT *) g->bitmap2.bits;
       shrunk_bytes_wide = g->bitmap2.bytes_wide;
       rows_left = g->bitmap.h;
       bzero((char *) new_ptr, shrunk_bytes_wide * shrunk_height);
       while (rows_left) {
           if (rows > rows_left) rows = rows_left;
           cols_left = g->bitmap.w;
#ifndef MSBITFIRST
           m = (1 << 0);
#else
           m = (1 << (BITS_PER_BMUNIT-1));
#endif
           cp = new_ptr;
           cols = init_cols;
           while (cols_left) {
               if (cols > cols_left) cols = cols_left;
               if (sample(old_ptr, g->bitmap.bytes_wide,
                       g->bitmap.w - cols_left, cols, rows) >= min_sample)
                   *cp |= m;
#ifndef MSBITFIRST
               if (m == (BMUNIT)(1 << (BITS_PER_BMUNIT-1))) {
                   m = (1 << 0);
                   ++cp;
               }
               else m <<= 1;
#else
               if (m == (1 << 0)) {
                   m = (1 << (BITS_PER_BMUNIT-1));
                   ++cp;
               }
               else m >>= 1;
#endif
               cols_left -= cols;
               cols = shrink_factor;
           }
           *((char **) &new_ptr) += shrunk_bytes_wide;
           *((char **) &old_ptr) += rows * g->bitmap.bytes_wide;
           rows_left -= rows;
           rows = shrink_factor;
       }
       g->y2 = g->y / shrink_factor;
       if (debug & DBG_BITMAP)
           print_bitmap(&g->bitmap2);
}

/*
*      Find font #n.
*/

static  void
change_font(n)
       unsigned long n;
{
       register struct tn *tnp;

       currinf.fontp = NULL;
       for (tnp = currinf.tn_head; tnp != NULL; tnp = tnp->next)
           if (tnp->TeXnumber == n) {
               currinf.fontp = tnp->fontp;
               if (!(currinf.fontp->flags & FONT_LOADED))
                   load_font(currinf.fontp);
               break;
           }
       if (currinf.fontp == NULL) tell_oops("non-existent font #%d", n);
       maxchar = currinf.fontp->maxchar;
       currinf.set_char_p = currinf.fontp->set_char_p;
}


/*
*      Open a font file.
*/

static  void
open_font_file(fontp)
       struct font *fontp;
{
       if (fontp->file == NULL) {
           fontp->file = xfopen(fontp->filename);
           if (fontp->file == NULL)
               oops("Font file disappeared:  %s", fontp->filename);
       }
}


/*
*      Routines to print characters.
*/

#ifndef TEXXET
#define ERRVAL  0L
#else
#define ERRVAL
#endif

#ifndef TEXXET
long
set_char(ch)
#else
void
set_char(cmd, ch)
       WIDEARG(ubyte, int)     cmd;
#endif
       WIDEARG(ubyte, int)     ch;
{
       register struct glyph *g;
#ifdef  TEXXET
       long    dvi_h_sav;
#endif

       if (ch > maxchar) realloc_font(currinf.fontp, WIDEARG(,(int)) ch);
       if ((g = &currinf.fontp->glyph[ch])->bitmap.bits == NULL) {
           if (g->addr == 0) {
               if (!hush_chars)
                   Fprintf(stderr, "Character %d not defined in font %s\n", ch,
                       currinf.fontp->fontname);
               g->addr = -1;
               return ERRVAL;
           }
           if (g->addr == -1)
               return ERRVAL;  /* previously flagged missing char */
           open_font_file(currinf.fontp);
           Fseek(currinf.fontp->file, g->addr, 0);
           (*currinf.fontp->read_char)(currinf.fontp, ch);
           if (debug & DBG_BITMAP) print_char((ubyte) ch, g);
           currinf.fontp->timestamp = ++current_timestamp;
       }

#ifdef  TEXXET
       dvi_h_sav = DVI_H;
       if (currinf.dir < 0) DVI_H -= g->dvi_adv;
       if (scan_frame == NULL) {
#endif
           if (shrink_factor == 1)
               put_bitmap(&g->bitmap, PXL_H - g->x, PXL_V - g->y);
           else {
#ifdef  GREY
               if (use_grey) {
                   if (g->pixmap2 == NULL) {
                       shrink_glyph_grey(g);
                   }
                   put_image(g->image2, PXL_H - g->x2, PXL_V - g->y2);
               } else {
                   if (g->bitmap2.bits == NULL) {
                       shrink_glyph(g);
                   }
                   put_bitmap(&g->bitmap2, PXL_H - g->x2, PXL_V - g->y2);
               }
#else
               if (g->bitmap2.bits == NULL) {
                   shrink_glyph(g);
               }
               put_bitmap(&g->bitmap2, PXL_H - g->x2, PXL_V - g->y2);
#endif
           }
#ifndef TEXXET
       return g->dvi_adv;
#else
       }
       if (cmd == PUT1)
           DVI_H = dvi_h_sav;
       else
           if (currinf.dir > 0) DVI_H += g->dvi_adv;
#endif
}


#ifndef TEXXET
long
set_vf_char(ch)
#else
void
set_vf_char(cmd, ch)
       WIDEARG(ubyte, int)     cmd;
#endif
       WIDEARG(ubyte, int)     ch;
{
       register struct macro *m;
       struct drawinf  oldinfo;
       ubyte   oldmaxchar;
       static  ubyte   c;
#ifdef  TEXXET
       long    dvi_h_sav;
#endif

       if (ch > maxchar) realloc_virtual_font(currinf.fontp, ch);
       if ((m = &currinf.fontp->macro[ch])->pos == NULL) {
           if (!hush_chars)
               Fprintf(stderr, "Character %d not defined in font %s\n", ch,
                   currinf.fontp->fontname);
           m->pos = m->end = &c;
           return ERRVAL;
       }
#ifdef  TEXXET
       dvi_h_sav = DVI_H;
       if (currinf.dir < 0) DVI_H -= m->dvi_adv;
       if (scan_frame == NULL) {
#endif
           oldinfo = currinf;
           oldmaxchar = maxchar;
           WW = XX = YY = ZZ = 0;
           currinf.tn_head = currinf.fontp->vf_chain;
           currinf.pos = m->pos;
           currinf.end = m->end;
           currinf.virtual = currinf.fontp;
           draw_part(current_frame, currinf.fontp->dimconv);
           if (currinf.pos != currinf.end + 1)
               tell_oops("virtual character macro does not end correctly");
           currinf = oldinfo;
           maxchar = oldmaxchar;
#ifndef TEXXET
       return m->dvi_adv;
#else
       }
       if (cmd == PUT1)
           DVI_H = dvi_h_sav;
       else
           if (currinf.dir > 0) DVI_H += m->dvi_adv;
#endif
}


#ifndef TEXXET
static  long
set_no_char(ch)
#else
static  void
set_no_char(cmd, ch)
       ubyte   cmd;
#endif
       ubyte   ch;
{
       if (currinf.virtual) {
           currinf.fontp = currinf.virtual->first_font;
           if (currinf.fontp != NULL) {
               if (!(currinf.fontp->flags & FONT_LOADED))
                   load_font(currinf.fontp);
               maxchar = currinf.fontp->maxchar;
               currinf.set_char_p = currinf.fontp->set_char_p;
#ifndef TEXXET
               return (*currinf.set_char_p)(ch);
#else
               (*currinf.set_char_p)(cmd, ch);
               return;
#endif
           }
       }
       tell_oops("attempt to set character of unknown font");
       /* NOTREACHED */
}


/*
*      Set rule.  Arguments are coordinates of lower left corner.
*/

static  void
set_rule(h, w)
       int h, w;
{
#ifndef TEXXET
       put_rectangle(PXL_H, PXL_V - h + 1, w, h, False);
#else
       put_rectangle(PXL_H - (currinf.dir < 0 ? w - 1 : 0), PXL_V - h + 1,
           w, h, False);
#endif
}

static  void
put_border(w, h)
       int w, h;
{
       put_rectangle(0, 0, w, 1, True);        /* top */
       put_rectangle(w, 0, 1, h, True);        /* right */
       put_rectangle(1, h, w, 1, True);        /* bottom */
       put_rectangle(0, 1, 1, h, True);        /* left */
}

static  void
special(nbytes)
       long    nbytes;
{
       static  char    *cmd    = NULL;
       static  long    cmdlen  = -1;
       char    *p;

       if (cmdlen < nbytes) {
           if (cmd) free(cmd);
           cmd = xmalloc((unsigned) nbytes + 1, "special");
           cmdlen = nbytes;
       }
       p = cmd;
       for (;;) {
           int i = currinf.end - currinf.pos;

           if (i > nbytes) i = nbytes;
           bcopy((_Xconst char *) currinf.pos, p, i);
           currinf.pos += i;
           p += i;
           nbytes -= i;
           if (nbytes == 0) break;
           (void) xxone();
           --(currinf.pos);
       }
       *p = '\0';
       applicationDoSpecial(cmd);
}

#define xspell_conv(n)  spell_conv0(n, current_dimconv)

static  void
draw_part(minframe, current_dimconv)
       struct frame    *minframe;
       double          current_dimconv;
{
       ubyte ch;
#ifdef  TEXXET
       struct drawinf  oldinfo;
       ubyte   oldmaxchar;
       off_t   file_pos;
       int     refl_count;
#endif

       currinf.fontp = NULL;
       currinf.set_char_p = set_no_char;
#ifdef  TEXXET
       currinf.dir = 1;
       scan_frame = NULL;      /* indicates we're not scanning */
#endif
       for (;;) {
           ch = xone();
           if (debug & DBG_DVI)
               print_dvi(ch);
           if (ch <= SETCHAR0 + 127)
#ifndef TEXXET
               DVI_H += (*currinf.set_char_p)(ch);
#else
               (*currinf.set_char_p)(ch, ch);
#endif
           else if (FNTNUM0 <= ch && ch <= FNTNUM0 + 63)
               change_font((unsigned long) (ch - FNTNUM0));
           else {
               long a, b;

               switch (ch) {
                   case SET1:
                   case PUT1:
#ifndef TEXXET
                       a = (*currinf.set_char_p)(xone());
                       if (ch != PUT1) DVI_H += a;
#else
                       (*currinf.set_char_p)(ch, xone());
#endif
                       break;

                   case SETRULE:
                       /* Be careful, dvicopy outputs rules with
                          height = 0x80000000.  We don't want any
                          SIGFPE here. */
                       a = xsfour();
                       b = xspell_conv(xsfour());
#ifndef TEXXET
                       if (a > 0 && b > 0)
#else
                       if (a > 0 && b > 0 && scan_frame == NULL)
#endif
                           set_rule(pixel_round(xspell_conv(a)),
                               pixel_round(b));
                       DVI_H += DIR * b;
                       break;

                   case PUTRULE:
                       a = xspell_conv(xsfour());
                       b = xspell_conv(xsfour());
#ifndef TEXXET
                       if (a > 0 && b > 0)
#else
                       if (a > 0 && b > 0 && scan_frame == NULL)
#endif
                           set_rule(pixel_round(a), pixel_round(b));
                       break;

                   case NOP:
                       break;

                   case BOP:
                       xskip((long) 11 * 4);
                       DVI_H = OFFSET_X;
                       DVI_V = OFFSET_Y;
                       PXL_V = pixel_conv(DVI_V);
                       WW = XX = YY = ZZ = 0;
                       break;

                   case EOP:
                       if (current_frame != minframe)
                           tell_oops("stack not empty at EOP");
                       return;

                   case PUSH:
                       if (current_frame->next == NULL) {
                           struct frame *newp = (struct frame *)
                               xmalloc(sizeof(struct frame), "stack frame");
                           current_frame->next = newp;
                           newp->prev = current_frame;
                           newp->next = NULL;
                       }
                       current_frame = current_frame->next;
                       current_frame->data = currinf.data;
                       break;

                   case POP:
                       if (current_frame == minframe)
                           tell_oops("more POPs than PUSHes");
                       currinf.data = current_frame->data;
                       current_frame = current_frame->prev;
                       break;

#ifdef  TEXXET
                   case SREFL:
                       if (scan_frame == NULL) {
                           /* we're not scanning:  save some info. */
                           oldinfo = currinf;
                           oldmaxchar = maxchar;
                           if (!currinf.virtual)
                               file_pos = xtell(currinf.pos);
                           scan_frame = current_frame; /* now we're scanning */
                           refl_count = 0;
                           break;
                       }
                       /* we are scanning */
                       if (current_frame == scan_frame) ++refl_count;
                       break;

                   case EREFL:
                       if (scan_frame != NULL) {       /* if we're scanning */
                           if (current_frame == scan_frame && --refl_count < 0)
                           {
                               /* we've hit the end of our scan */
                               scan_frame = NULL;
                               /* first:  push */
                               if (current_frame->next == NULL) {
                                   struct frame *newp = (struct frame *)
                                       xmalloc(sizeof(struct frame),
                                           "stack frame");
                                   current_frame->next = newp;
                                   newp->prev = current_frame;
                                   newp->next = NULL;
                               }
                               current_frame = current_frame->next;
                               current_frame->data = currinf.data;
                               /* next:  restore old file position, XX, etc. */
                               if (!currinf.virtual) {
                                   off_t bgn_pos = xtell(dvi_buffer);

                                   if (file_pos >= bgn_pos) {
                                       oldinfo.pos = dvi_buffer
                                           + (file_pos - bgn_pos);
                                       oldinfo.end = currinf.end;
                                   }
                                   else {
                                       (void) lseek(fileno(dvi_file), file_pos,
                                           SEEK_SET);
                                       oldinfo.pos = oldinfo.end;
                                   }
                               }
                               currinf = oldinfo;
                               maxchar = oldmaxchar;
                               /* and then:  recover position info. */
                               DVI_H = current_frame->data.dvi_h;
                               DVI_V = current_frame->data.dvi_v;
                               PXL_V = current_frame->data.pxl_v;
                               /* and finally, reverse direction */
                               currinf.dir = -currinf.dir;
                           }
                           break;
                       }
                       /* we're not scanning, */
                       /* so just reverse direction and then pop */
                       currinf.dir = -currinf.dir;
                       currinf.data = current_frame->data;
                       current_frame = current_frame->prev;
                       break;
#endif  /* TEXXET */

                   case RIGHT1:
                   case RIGHT2:
                   case RIGHT3:
                   case RIGHT4:
                       DVI_H += DIR * xspell_conv(xsnum(ch - RIGHT1 + 1));
                       break;

                   case W1:
                   case W2:
                   case W3:
                   case W4:
                       WW = xspell_conv(xsnum(ch - W0));
                   case W0:
                       DVI_H += DIR * WW;
                       break;

                   case X1:
                   case X2:
                   case X3:
                   case X4:
                       XX = xspell_conv(xsnum(ch - X0));
                   case X0:
                       DVI_H += DIR * XX;
                       break;

                   case DOWN1:
                   case DOWN2:
                   case DOWN3:
                   case DOWN4:
                       DVI_V += xspell_conv(xsnum(ch - DOWN1 + 1));
                       PXL_V = pixel_conv(DVI_V);
                       break;

                   case Y1:
                   case Y2:
                   case Y3:
                   case Y4:
                       YY = xspell_conv(xsnum(ch - Y0));
                   case Y0:
                       DVI_V += YY;
                       PXL_V = pixel_conv(DVI_V);
                       break;

                   case Z1:
                   case Z2:
                   case Z3:
                   case Z4:
                       ZZ = xspell_conv(xsnum(ch - Z0));
                   case Z0:
                       DVI_V += ZZ;
                       PXL_V = pixel_conv(DVI_V);
                       break;

                   case FNT1:
                   case FNT2:
                   case FNT3:
                   case FNT4:
                       change_font(xnum(ch - FNT1 + 1));
                       break;

                   case XXX1:
                   case XXX2:
                   case XXX3:
                   case XXX4:
                       a = xnum(ch - XXX1 + 1);
                       if (a > 0)
                           special(a);
                       break;

                   case FNTDEF1:
                   case FNTDEF2:
                   case FNTDEF3:
                   case FNTDEF4:
                       xskip((long) (12 + ch - FNTDEF1 + 1));
                       xskip((long) xone() + (long) xone());
                       break;

#ifndef TEXXET
                   case SREFL:
                   case EREFL:
#endif
                   case PRE:
                   case POST:
                   case POSTPOST:
                       tell_oops("shouldn't happen: %s encountered",
                               dvi_table2[ch - (FNTNUM0 + 64)]);
                       break;

                   default:
                       tell_oops("unknown op-code %d", ch);
               } /* end switch*/
           } /* end else (ch not a SETCHAR or FNTNUM) */
       } /* end for */
}

#undef  xspell_conv

void
draw_page()
{
       /* Check for changes in dvi file. */
       if (!check_dvi_file()) return;

       put_border(ROUNDUP(unshrunk_paper_w, shrink_factor) + 1,
           ROUNDUP(unshrunk_paper_h, shrink_factor) + 1);

       (void) lseek(fileno(dvi_file), page_offset[current_page], SEEK_SET);

       bzero((char *) &currinf.data, sizeof(currinf.data));
       currinf.tn_head = tn_head;
       currinf.pos = currinf.end = dvi_buffer;
       currinf.virtual = NULL;
       draw_part(current_frame = &frame0, dimconv);
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.