wdvi

dvi-draw.c (35817B)

---

 /*========================================================================*\
 
 Copyright (c) 1990-2013  Paul Vojta
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to
 deal in the Software without restriction, including without limitation the
 rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
 sell copies of the Software, and to permit persons to whom the Software is
 furnished to do so, subject to the following conditions:
 
 The above copyright notice and this permission notice shall be included in
 all copies or substantial portions of the Software.
 
 THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 IN NO EVENT SHALL PAUL VOJTA OR ANY OTHER AUTHOR OF OR CONTRIBUTOR TO
 THIS SOFTWARE BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
 WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
 IN THE SOFTWARE.
 
 NOTE:
 	xdvi is based on prior work, as noted in the modification history
 	in xdvi.c.
 
 \*========================================================================*/
 
 #include <err.h>
 #include <ctype.h>
 #include <stdarg.h>
 
 #include "dvi-draw.h"	/* drawing_mag */
 #include "dvi-init.h"	/* page_info */
 #include "events.h"	/* do_color_change(), ... */
 #include "font.h"	/* load_ft_font() XXX more */
 #include "special.h"	/* scan_special(), ... */
 #include "util.h"	/* xfopen(), snum() */
 #include "xdvi.h"
 #include "dvi.h"
 
 
 static	struct frame	frame0;		/* dummy head of list */
 
 #define	DVI_BUFFER_LEN	512
 static	unsigned char	dvi_buffer[DVI_BUFFER_LEN];
 static	struct frame	*current_frame;
 
 /* Points to drawinf record containing current dvi file location (for update by
    geom_scan).  */
 static	struct drawinf	*dvi_pointer_frame	= NULL;
 
 /*
  *	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)
 
 BMUNIT	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
 };
 
 static	void	draw_part(struct frame *, double);
 
 /*
  *	X routines.
  */
 
 /*
  *	Put a rectangle on the screen.
  */
 
 static	void
 put_rule(int x, int y, unsigned int w, unsigned int h)
 {
 	if (x >= max_x || x + (int) w < min_x ||
 	    y >= max_y || y + (int) h < min_y)
 		return;
 
 	if (fg_active != fg_current)
 		do_color_change();
 	XFillRectangle(DISP, currwin.win, ruleGC,
 	               x - currwin.base_x, y - currwin.base_y,
 	               w ? w : 1, h ? h : 1);
 }
 
 static	void
 put_bitmap(struct bitmap *bitmap, int x, int y)
 {
 	if (debug & DBG_BITMAP)
 		printf("X(%d,%d)\n", x - currwin.base_x, y - currwin.base_y);
 
 	if (x >= max_x || x + (int) bitmap->w < min_x ||
 	    y >= max_y || y + (int) bitmap->h < min_y)
 		return;
 
 	if (fg_active != fg_current)
 		do_color_change();
 
 	image->width = bitmap->w;
 	image->height = bitmap->h;
 	image->data = bitmap->bits;
 	image->bytes_per_line = bitmap->bytes_wide;
 	XPutImage(DISP, currwin.win, foreGC, image,
 	          0, 0,
 	          x - currwin.base_x, y - currwin.base_y,
 	          bitmap->w, bitmap->h);
 	if (foreGC2)
 		XPutImage(DISP, currwin.win, foreGC2, image,
 		          0, 0,
 		          x - currwin.base_x, y - currwin.base_y,
 		          bitmap->w, bitmap->h);
 }
 
 
 static	void	shrink_glyph_grey(struct glyph *);
 
 static	void
 put_image(struct glyph *g, int x, int y)
 {
 	XImage *img = g->image2;
 
 	if (x >= max_x || x + img->width < min_x ||
 	    y >= max_y || y + img->height < min_y)
 		return;
 
 	if (g->fg != fg_current)	/* if color change since last use */
 		shrink_glyph_grey(g);
 	else if (fg_active != fg_current)	/* if GCs need updating */
 		do_color_change();
 	XPutImage(DISP, currwin.win, foreGC, img,
 	          0, 0,
 	          x - currwin.base_x, y - currwin.base_y,
 	          (unsigned int) img->width, (unsigned int) img->height);
 	if (foreGC2 != NULL) {
 		img->data = g->pixmap2_t;
 		XPutImage(DISP, currwin.win, foreGC2, img,
 		          0, 0,
 		          x - currwin.base_x, y - currwin.base_y,
 		          (unsigned int) img->width, (unsigned int) img->height);
 		img->data = g->pixmap2;
 	}
 }
 
 /*
  *	Byte reading routines for dvi file.
  */
 
 static	unsigned char
 xxone()
 {
 	if (currinf.virtual) {
 	    ++currinf.pos;
 	    return EOP;
 	}
 	currinf.end = dvi_buffer +
 		fread((char *) (currinf.pos = dvi_buffer), 1, DVI_BUFFER_LEN,
 			dvi_file);
 	return currinf.end > dvi_buffer ? *(currinf.pos)++ : EOF;
 }
 
 #define	xone()  (currinf.pos < currinf.end ? *(currinf.pos)++ : xxone())
 
 static	unsigned long
 xnum(unsigned char size)
 {
 	long x = 0;
 
 	while (size--) x = (x << 8) | xone();
 	return x;
 }
 
 static	long
 xsnum(unsigned char size)
 {
 	long	x;
 
 	x = (signed char) xone();
 
 	while (--size)
 		x = (x << 8) | xone();
 	return x;
 }
 
 #define	xsfour()	xsnum(4)
 
 static	void
 xskip(long offset)
 {
 	currinf.pos += offset;
 	if (!currinf.virtual && currinf.pos > currinf.end)
 	    (void) fseek(dvi_file, (long) (currinf.pos - currinf.end), SEEK_CUR);
 }
 
 static void __attribute__((__noreturn__))
 tell_oops(const char *message, ...)
 {
 	va_list	args;
 
 	va_start(args, message);
 	vwarnx(message, args);
 	va_end(args);
 
 	if (currinf.virtual)
 	    warnx("in virtual font '%s'", currinf.virtual->fontname);
 	else
 #define	xtell(pos)	(ftell(dvi_file) - (currinf.end - (pos)))
 	    warnx("offset %ld", xtell(currinf.pos - 1));
 	exit(1);
 }
 
 
 /*
  *	Code for debugging options.
  */
 
 static	void
 print_bitmap(struct bitmap *bitmap)
 {
 	BMUNIT		*ptr	= (BMUNIT *) bitmap->bits;
 	int		x, y, i;
 
 	if (ptr == NULL)
 		errx(1, "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 < (int) bitmap->h; ++y) {
 	    for (x = bitmap->bytes_wide; x > 0; x -= BMBYTES) {
 #ifndef	WORDS_BIGENDIAN
 		for (i = 0; i < BMBITS; ++i)
 #else
 		for (i = BMBITS - 1; i >= 0; --i)
 #endif
 		    putchar((*ptr & (1 << i)) ? '@' : ' ');
 		++ptr;
 	    }
 	    putchar('\n');
 	}
 }
 
 static	void
 print_char(unsigned char 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	const	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	const	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(unsigned char ch)
 {
 	const	char	*s;
 
 	printf("%4d %4d ", PXL_H, PXL_V);
 	if (ch <= (unsigned char) (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 <= (unsigned char) (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
  */
 
 static	char	sample_count[]	= {0, 1, 1, 2, 1, 2, 2, 3,
 				   1, 2, 2, 3, 2, 3, 3, 4};
 
 static	int
 sample(BMUNIT *bits, int bytes_wide, int bit_skip, int w, int h)
 {
 	BMUNIT	*ptr, *endp;
 	BMUNIT	*cp;
 	int	bits_left;
 	int	n, bit_shift, wid;
 
 	ptr = bits + bit_skip / BMBITS;
 	endp = ADD(bits, h * bytes_wide);
 	bits_left = w;
 #ifndef	WORDS_BIGENDIAN
 	bit_shift = bit_skip % BMBITS;
 #else
 	bit_shift = BMBITS - bit_skip % BMBITS;
 #endif
 	n = 0;
 	while (bits_left) {
 #ifndef	WORDS_BIGENDIAN
 		wid = BMBITS - bit_shift;
 #else
 		wid = bit_shift;
 #endif
 		if (wid > bits_left)
 			wid = bits_left;
 		if (wid > 4)
 			wid = 4;
 #ifdef	WORDS_BIGENDIAN
 		bit_shift -= wid;
 #endif
 		for (cp = ptr; cp < endp; cp = ADD(cp, bytes_wide))
 			n += sample_count[(*cp >> bit_shift) & bit_masks[wid]];
 #ifndef	WORDS_BIGENDIAN
 		bit_shift += wid;
 		if (bit_shift == BMBITS) {
 			bit_shift = 0;
 			++ptr;
 	    	}
 #else
 		if (bit_shift == 0) {
 			bit_shift = BMBITS;
 			++ptr;
 		}
 #endif
 		bits_left -= wid;
 	}
 	return n;
 }
 
 
 static	void
 shrink_glyph_grey(struct glyph *g)
 {
 	int		rows_left, rows, init_cols;
 	int		cols_left;
 	int		cols;
 	int		x, y;
 	long		thesample;
 	BMUNIT		*old_ptr;
 	unsigned int	size;
 	int		rtmp;
 	unsigned int	depth;
 
 	if (fg_active != fg_current)
 		do_color_change();
 
 	/* 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((int) g->bitmap.w - g->x, shrink_factor);
 	/* include row zero with the positively numbered rows */
 	rtmp = g->y + 1;
 	g->y2 = rtmp / shrink_factor;
 	rows = rtmp - g->y2 * shrink_factor;
 	if (rows <= 0) {
 		rows += shrink_factor;
 		--g->y2;
 	}
 	g->bitmap2.h = g->y2 + ROUNDUP((int) g->bitmap.h - rtmp, shrink_factor) + 1;
 
 	if (g->pixmap2 == NULL) {
 		depth = DefaultDepthOfScreen(SCRN);
 		g->image2 = XCreateImage(DISP, CopyFromParent, depth, ZPixmap, 0,
 		                         (char *) NULL, g->bitmap2.w, g->bitmap2.h,
 		                         BMBITS, 0);
 		size = g->image2->bytes_per_line * g->bitmap2.h;
 		g->pixmap2 = g->image2->data = xmalloc(size != 0 ? size : 1);
 	}
 	if (foreGC2 != NULL && g->pixmap2_t == NULL) {
 		size = g->image2->bytes_per_line * g->bitmap2.h;
 		g->pixmap2_t = xmalloc(size != 0 ? size : 1);
 	}
 
 	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,
 			                   (int) g->bitmap.w - cols_left, cols, rows);
 			XPutPixel(g->image2, x, y, pixeltbl[thesample]);
 			if (foreGC2 != NULL) {
 				g->image2->data = g->pixmap2_t;
 				XPutPixel(g->image2, x, y, pixeltbl_t[thesample]);
 				g->image2->data = g->pixmap2;
 			}
 
 			cols_left -= cols;
 			cols = shrink_factor;
 			x++;
 	    	}
 		*((char **) &old_ptr) += rows * g->bitmap.bytes_wide;
 		rows_left -= rows;
 		rows = shrink_factor;
 		y++;
 	}
 
 	while (y < (int) g->bitmap2.h) {
 		for (x = 0; x < (int) g->bitmap2.w; x++) {
 			XPutPixel(g->image2, x, y, *pixeltbl);
 			if (foreGC2 != NULL) {
 				g->image2->data = g->pixmap2_t;
 				XPutPixel(g->image2, x, y, *pixeltbl_t);
 				g->image2->data = g->pixmap2;
 			}
 		}
 	    	y++;
 	}
 
 	g->y2 = g->y / shrink_factor;
 	g->fg = fg_current;
 }
 
 /*
  *	Find font #n.
  */
 
 static	void
 change_font(unsigned long n)
 {
 	struct tn	*tnp;
 
 	if (n < currinf.tn_table_len)
 		currinf.fontp = currinf.tn_table[n];
 	else {
 		currinf.fontp = NULL;
 		for (tnp = currinf.tn_head; tnp != NULL; tnp = tnp->next)
 			if (tnp->TeXnumber == n) {
 				currinf.fontp = tnp->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.
  */
 
 void
 open_font_file(struct font *fontp)
 {
 	if (fontp->file != NULL)
 		return;
 
 	fontp->file = xfopen(fontp->filename, "r");
 	if (fontp->file == NULL)
 		errx(1, "Font file disappeared: '%s'", fontp->filename);
 }
 
 /*
  *	Read special string.
  */
 
 static	char *
 read_special(long nbytes)
 {
 	static	char	*spcl	= NULL;
 	static	long	spcl_len = -1;
 	char	*p;
 
 	if (spcl_len < nbytes) {
 		if (spcl != NULL)
 			free(spcl);
 		spcl = xmalloc((unsigned) nbytes + 1);
 		spcl_len = nbytes;
 	}
 	p = spcl;
 	for (;;) {
 		int i = currinf.end - currinf.pos;
 
 		if (i > nbytes)
 			i = nbytes;
 		bcopy((char *) currinf.pos, p, i);
 		currinf.pos += i;
 		p += i;
 		nbytes -= i;
 		if (nbytes == 0)
 			break;
 		(void) xxone();
 		--currinf.pos;
 	}
 	*p = '\0';
 	return spcl;
 }
 
 
 /*
  *	Table used for scanning.  If >= 0, then skip that many bytes.
  *	M1 means end of page, M2 means special, M3 means FNTDEF,
  *	M4 means unrecognizable, and M5 means doesn't belong here.
  */
 
 #define	M1	255
 #define	M2	254
 #define	M3	253
 #define	M4	252
 #define	M5	251
 #define	MM	251
 
 static	unsigned char	scantable[256] = {
 	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,	/* chars 0 - 127 */
 	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 	1,M4,			/* SET1,- (128,129) */
 			/* -,-,SETRULE,PUT1,-,-,-,PUTRULE,NOP,BOP (130-139) */
 	M4,M4,8,1,M4,M4,M4,8,0,44,
 	M1,0,0,1,2,3,4,0,1,2,	/* EOP,PUSH,POP,RIGHT1-4,W0M2 (140-149) */
 	3,4,0,1,2,3,4,1,2,3,	/* W3-4,X0-4,DOWN1-3 (150-159) */
 	4,0,1,2,3,4,0,1,2,3,	/* DOWN4,Y0-4,Z0-3 (160-169) */
 	4,			/* Z4 (170) */
 	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,	/* change font 171 - 234 */
 	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 	0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,
 	1,2,3,4,M2,		/* FNT1-4,XXX1 (235-239) */
 			/* XXX2-4,FNTDEF1-4,PRE,POST,POSTPOST (240-249) */
 	M2,M2,M2,M3,M3,M3,M3,M5,M5,M5,
 	0,0,M4,M4,M4,M4};	/* SREFL,EREFL,-,-,-,- (250-255) */
 
 /*
  *	This is the generic scanning routine.  It assumes that currinf, etc.
  *	are ready to go at the start of the page to be scanned.
  */
 
 static	void
 spcl_scan(void (*spcl_proc)(char *))
 {
 	unsigned char	ch;
 	unsigned char	n;
 	long	a;
 
 	for (;;) {
 	    ch = xone();
 	    n = scantable[ch];
 	    if (n < MM)
 		while (n-- != 0)
 		    (void) xone();
 	    else if (n == M1) break;	/* end of page */
 	    else switch (n) {
 		case M2:	/* special */
 		    a = xnum(ch - XXX1 + 1);
 		    if (a > 0)
 			spcl_proc(read_special(a));
 		    break;
 		case M3:	/* FNTDEF */
 		    xskip((long) (12 + ch - FNTDEF1 + 1));
 		    ch = xone();
 		    xskip((long) ch + (long) xone());
 		    break;
 		case M4:	/* unrecognizable */
 		    tell_oops("unknown op-code %d", ch);
 		    break;
 		case M5:	/* doesn't belong */
 		    tell_oops("shouldn't happen: %s encountered",
 		      dvi_table2[ch - (FNTNUM0 + 64)]);
 		    break;
 	    }
 	}
 }
 
 
 /*
  *	Size of page interval for "Scanning pages xx-xx" message.
  */
 
 #ifndef	REPORT_INCR
 #define	REPORT_INCR	50
 #endif
 
 /*
  *	Prescanning routine for dvi file.  This looks for specials like
  *	`header=' and `!'.
  */
 
 void
 prescan(void)
 {
 	int	nextreportpage;
 
 	nextreportpage = scanned_page;
 	if (fseek(dvi_file, page_info[scanned_page + 1].offset, SEEK_SET) != 0)
 		err(1, "fseek");
 	currinf.pos = currinf.end = dvi_buffer;
 
 	for (;;) {
 	    page_info[scanned_page + 1].pw = page_info[scanned_page].pw;
 	    page_info[scanned_page + 1].ph = page_info[scanned_page].ph;
 	    page_info[scanned_page + 1].ww = page_info[scanned_page].ww;
 	    page_info[scanned_page + 1].wh = page_info[scanned_page].wh;
 
 	    if (debug & DBG_PS)
 		printf("Scanning page %d\n", scanned_page + 1);
 	    if (scanned_page >= nextreportpage) {
 		nextreportpage += REPORT_INCR;
 		if (nextreportpage > current_page)
 		    nextreportpage = current_page;
 	    }
 
 	    /* No calls to read_events() occur in this case.  */
 	    spcl_scan(scan_special);
 
 	    ++scanned_page;
 	    if (scanned_page_color < scanned_page) {
 		scan_color_eop();
 		scanned_page_color = scanned_page;
 	    }
 
 	    if (scanned_page >= current_page) break;
 	}
 }
 
 /*
  *	Routines to print characters.
  */
 
 long
 set_char(unsigned char ch)
 {
 	struct glyph	*g;
 
 	if (ch > maxchar) realloc_font(currinf.fontp, ch);
 	if ((g = &currinf.fontp->glyph[ch])->bitmap.bits == NULL) {
 	    if (g->addr == 0) {
 		warnx("Character %d not defined in font '%s'", ch,
 			currinf.fontp->fontname);
 		g->addr = -1;
 		return 0L;
 	    }
 	    if (g->addr == -1)
 		return 0L;	/* previously flagged missing char */
 	    if (currinf.fontp->ft == NULL)	/* if not freetype font */
 	    {
 		open_font_file(currinf.fontp);
 		if (fseek(currinf.fontp->file, g->addr, SEEK_SET) != 0)
 			err(1, "fseek");
 	    }
 	    (*currinf.fontp->read_char)(currinf.fontp, ch);
 	    if (debug & DBG_BITMAP) print_char((unsigned char) ch, g);
 	    currinf.fontp->timestamp = ++current_timestamp;
 	}
 
 	    if (shrink_factor == 1)
 		put_bitmap(&g->bitmap, PXL_H - g->x, PXL_V - g->y);
 	    else {
 		/*
 		 * use_grey
 		 */
 		if (g->pixmap2 == NULL) {
 			shrink_glyph_grey(g);
 		}
 		put_image(g, PXL_H - g->x2, PXL_V - g->y2);
 	    }
 	return g->dvi_adv;
 }
 
 
 static	long
 set_empty_char(unsigned char ch)
 {
 	return 0;
 }
 
 
 long
 load_n_set_char(unsigned char ch)
 {
 	if (!load_font(currinf.fontp)) {	/* if not found */
 	    warnx("Character(s) will be left blank.");
 	    currinf.set_char_p = currinf.fontp->set_char_p = set_empty_char;
 	    return 0;
 	}
 	maxchar = currinf.fontp->maxchar;
 	currinf.set_char_p = currinf.fontp->set_char_p;
 	return (*currinf.set_char_p)(ch);
 }
 
 
 long
 set_vf_char(unsigned char ch)
 {
 	struct macro	*m;
 	struct drawinf	oldinfo;
 	unsigned char	oldmaxchar;
 	static	unsigned char	c;
 
 	if (ch > maxchar) realloc_virtual_font(currinf.fontp, ch);
 	if ((m = &currinf.fontp->macro[ch])->pos == NULL) {
 	    warnx("Character %d not defined in font '%s'", ch,
 		    currinf.fontp->fontname);
 	    m->pos = m->end = &c;
 	    return 0L;
 	}
 	    oldinfo = currinf;
 	    if (!currinf.virtual)
 		dvi_pointer_frame = &oldinfo;
 	    oldmaxchar = maxchar;
 	    WW = XX = YY = ZZ = 0;
 	    currinf.tn_table_len = VFTABLELEN;
 	    currinf.tn_table = currinf.fontp->vf_table;
 	    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;
 	    if (!currinf.virtual)
 		dvi_pointer_frame = &currinf;
 	    maxchar = oldmaxchar;
 	return m->dvi_adv;
 }
 
 
 
 /*
  *	set_ft_char() is used as a set_char routine to handle delayed loading
  *	of freetype fonts.  See more details in ft.c.
  */
 
 static void
 do_load_freetype_font(void)
 {
 	struct ftfont *ftp;
 
 	if (load_ft_font(currinf.fontp)) {
 		currinf.set_char_p = currinf.fontp->set_char_p = set_char;
 		return;
 	}
 
 	/* Revert to non-scalable font */
 	if (debug & DBG_OPEN)
 		printf(
 		  "Font %s is not loadable; reverting to non-scalable font\n",
 		  currinf.fontp->fontname);
 
 	ftp = currinf.fontp->ft;
 	ftp->t1->bad = True;
 	if (currinf.fontp == ftp->first_size) {
 		if (currinf.fontp->next_size == NULL) {
 			/* if this is the only size of this font face */
 			ftp->t1->ft = NULL;
 			free(ftp);
 		}
 		else {
 			struct font	*fontp2;
 
 			ftp->first_size = fontp2 = currinf.fontp->next_size;
 			/*
 			 * Opening the file might have succeeded at some other size,
 			 * so we need to transfer that information to the next
 			 * record in case it was put here.
 			 */
 			fontp2->file = currinf.fontp->file;
 			currinf.fontp->file = NULL;
 			fontp2->filename = currinf.fontp->filename;
 			currinf.fontp->filename = NULL;
 			fontp2->timestamp = currinf.fontp->timestamp;
 		}
 	}
 	else {
 		struct font *fontp2;
 
 		fontp2 = ftp->first_size;
 		while (fontp2->next_size != currinf.fontp)
 			fontp2 = fontp2->next_size;
 		fontp2->next_size = currinf.fontp->next_size;
 	}
 	currinf.fontp->ft = NULL;
 	/* The virtual font machinery will take it from here.  */
 	/* That will call load_font(), but it won't take us back to the */
 	/* freetype font, because that font will have been marked bad.  */
 	currinf.set_char_p = load_n_set_char;
 }
 
 long
 set_ft_char(unsigned char ch)
 {
 	do_load_freetype_font();
 
 	return (*currinf.set_char_p)(ch);
 }
 
 
 
 static	long
 set_no_char(unsigned char ch)
 {
 	if (currinf.virtual) {
 	    currinf.fontp = currinf.virtual->first_font;
 	    if (currinf.fontp != NULL) {
 		maxchar = currinf.fontp->maxchar;
 		currinf.set_char_p = currinf.fontp->set_char_p;
 		return (*currinf.set_char_p)(ch);
 	    }
 	}
 	tell_oops("attempt to set character of unknown font");
 }
 
 
 /*
  *	Set rule.  Arguments are coordinates of lower left corner.
  */
 
 static	void
 set_rule(int h, int w)
 {
 	put_rule(PXL_H, PXL_V - h + 1, (unsigned int) w, (unsigned int) h);
 }
 
 
 /*
  *	Interpret a sequence of dvi bytes (either the page from the dvi file,
  *	or a character from a virtual font).
  */
 
 #define	xspell_conv(n)	spell_conv0(n, current_dimconv)
 
 static	void
 draw_part(struct frame *minframe, double current_dimconv)
 {
 	unsigned char ch;
 
 	currinf.fontp = NULL;
 	currinf.set_char_p = set_no_char;
 	for (;;) {
 	    ch = xone();
 	    if (debug & DBG_DVI)
 		print_dvi(ch);
 	    if (ch <= (unsigned char) (SETCHAR0 + 127))
 		DVI_H += (*currinf.set_char_p)(ch);
 	    else if (FNTNUM0 <= ch && ch <= (unsigned char) (FNTNUM0 + 63))
 		change_font((unsigned long) (ch - FNTNUM0));
 	    else {
 		long a, b;
 
 		switch (ch) {
 		    case SET1:
 		    case PUT1:
 			a = (*currinf.set_char_p)(xone());
 			if (ch != PUT1) DVI_H += a;
 			break;
 
 		    case SETRULE:
 			/* Be careful, dvicopy outputs rules with
 			   height = 0x80000000.  We don't want any
 			   SIGFPE here. */
 			a = xsfour();
 			b = xspell_conv(xsfour());
 			if (a > 0 && b > 0)
 			    set_rule(pixel_round(xspell_conv(a)),
 				pixel_round(b));
 			DVI_H += 1 * b;
 			break;
 
 		    case PUTRULE:
 			a = xspell_conv(xsfour());
 			b = xspell_conv(xsfour());
 			if (a > 0 && b > 0)
 			    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 = xmalloc(sizeof(struct 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;
 
 
 		    case RIGHT1:
 		    case RIGHT2:
 		    case RIGHT3:
 		    case RIGHT4:
 			DVI_H += 1 * 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 += 1 * WW;
 			break;
 
 		    case X1:
 		    case X2:
 		    case X3:
 		    case X4:
 			XX = xspell_conv(xsnum(ch - X0));
 		    case X0:
 			DVI_H += 1 * 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)
 			    applicationDoSpecial(read_special(a));
 			break;
 
 		    case FNTDEF1:
 		    case FNTDEF2:
 		    case FNTDEF3:
 		    case FNTDEF4:
 			xskip((long) (12 + ch - FNTDEF1 + 1));
 			a = (long) xone();
 			xskip(a + (long) xone());
 			break;
 
 		    case SREFL:
 		    case EREFL:
 		    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(void)
 {
 	color_bottom = &fg_initial;
 	color_bot_size = 1;
 	if (page_colors != NULL && current_page > 0) {
 	    color_bottom = page_colors[current_page - 1].colorstack;
 	    color_bot_size = page_colors[current_page - 1].stacksize;
 	}
 	rcs_top = NULL;
 	set_fg_color(&color_bottom[color_bot_size - 1]);
 
 	(void) fseek(dvi_file, page_info[current_page].offset, SEEK_SET);
 
 	bzero((char *) &currinf.data, sizeof currinf.data);
 	currinf.tn_table_len = TNTABLELEN;
 	currinf.tn_table = tn_table;
 	currinf.tn_head = tn_head;
 	currinf.pos = currinf.end = dvi_buffer;
 	currinf.virtual = NULL;
 	dvi_pointer_frame = &currinf;
 	drawing_mag = (currwin.win == alt.win);
 
 	draw_part(current_frame = &frame0, dimconv);
 
 	drawing_mag = False;
 	dvi_pointer_frame = NULL;
 	currwin.win = (Window) 0;
 }
 
 
 /*
  *	General dvi scanning routines.  These are used for:
  *	    o	source special lookups and
  *	    o	finding the dimensions of links (if compiling with support for
  *		hypertext specials).
  *	This routine can be a bit slower than draw_page()/draw_part(), since
  *	it is not run that often; that is why it is a separate routine in
  *	spite of much duplication.
  *
  *	Note that it does not use a separate copy of define_font().
  */
 
 /*
  *	All calculations are done with shrink factor = 1, so we re-do some
  *	macros accordingly.  Many of these are also defined in special.c.
  */
 
 #define	xspell_conv(n)	spell_conv0(n, current_dimconv)
 #define	xpixel_conv(x)	((int) ((x) >> 16))
 #define	xpixel_round(x)	((int) ROUNDUP(x, 1 << 16))
 
 #define	G_PXL_H		xpixel_conv(currinf.data.dvi_h)
 #define	G_OFFSET_X	(offset_x << 16) + (3 << 15)
 #define	G_OFFSET_Y	(offset_y << 16) + (3 << 15)
 
 # define mane_base_x	0
 # define mane_base_y	0
 
 
 /*
  *	Used by the geometry-scanning routines.
  *	It passes pointers to routines to be called at certain
  *	points in the dvi file, and other information.
  */
 
 struct geom_info {
 	void	(*geom_box)	(struct geom_info *, char, long, long, long, long);
 	void	(*geom_special)	(struct geom_info *, const char *);
 	void	*geom_data;
 };
 
 
 /*
  *	This set of routines can be called while draw_part() is active,
  *	so the global variables must be separate.
  */
 
 static	struct frame	*geom_current_frame;
 
 static	void		geom_scan_part(struct geom_info *,
 			  struct frame *, double);
 
 /*
  *	Handle a character in geometric scanning routine.
  */
 
 static	long
 geom_do_char(g_info, ch)
 	struct geom_info	*g_info;
 	unsigned char		ch;
 {
 	if (currinf.set_char_p == set_no_char) {
 	    if (currinf.virtual == NULL
 	      || (currinf.fontp = currinf.virtual->first_font) == NULL)
 		return 0;	/* error; we'll catch it later */
 	    maxchar = currinf.fontp->maxchar;
 	    currinf.set_char_p = currinf.fontp->set_char_p;
 	}
 
 	if (currinf.set_char_p == set_empty_char)
 	    return 0;	/* error; we'll catch it later */
 
 	if (currinf.set_char_p == set_ft_char)
 	    do_load_freetype_font();
 
 	if (currinf.set_char_p == load_n_set_char) {
 	    if (ev_flags & EV_GE_NEWDOC)	/* if abort */
 		return 0;
 	    if (!load_font(currinf.fontp)) {	/* if not found */
 		if (ev_flags & EV_GE_NEWDOC)	/* if abort */
 		    return 0;
 		warnx("Character(s) will be left blank.");
 		currinf.set_char_p = currinf.fontp->set_char_p = set_empty_char;
 		return 0;
 	    }
 	    maxchar = currinf.fontp->maxchar;
 	    currinf.set_char_p = currinf.fontp->set_char_p;
 	}
 
 	if (currinf.set_char_p == set_char) {
 	    struct glyph *g;
 	    long x, y;
 
 	    if (ch > maxchar)
 		return 0;	/* catch the error later */
 	    if ((g = &currinf.fontp->glyph[ch])->bitmap.bits == NULL) {
 		if (g->addr == 0)
 		    return 0;	/* catch the error later */
 		if (g->addr == -1)
 		    return 0;	/* previously flagged missing char */
 		if (currinf.fontp->ft == NULL)
 		{
 		    open_font_file(currinf.fontp);
 		    if (fseek(currinf.fontp->file, g->addr, SEEK_SET) != 0)
 			err(1, "fseek");
 		}
 		(*currinf.fontp->read_char)(currinf.fontp, ch);
 		if (debug & DBG_BITMAP) print_char((unsigned char) ch, g);
 		currinf.fontp->timestamp = ++current_timestamp;
 	    }
 		x = G_PXL_H - g->x;
 		y = PXL_V - g->y;
 		g_info->geom_box(g_info, ch, x, y,
 		  x + g->bitmap.w, y + g->bitmap.h);
 
 	    return 1 * g->dvi_adv;
 	}
 	else if (currinf.set_char_p == set_vf_char) {
 	    struct macro	*m;
 	    struct drawinf	oldinfo;
 	    unsigned char	oldmaxchar;
 
 	    if (ch > maxchar)
 		return 0;	/* catch the error later */
 	    if ((m = &currinf.fontp->macro[ch])->pos == NULL) {
 		return 0;	/* catch the error later */
 	    }
 
 		oldinfo = currinf;
 		oldmaxchar = maxchar;
 		WW = XX = YY = ZZ = 0;
 		currinf.tn_table_len = VFTABLELEN;
 		currinf.tn_table = currinf.fontp->vf_table;
 		currinf.tn_head = currinf.fontp->vf_chain;
 		currinf.pos = m->pos;
 		currinf.end = m->end;
 		currinf.virtual = currinf.fontp;
 		geom_scan_part(g_info, geom_current_frame,
 		  currinf.fontp->dimconv);
 		currinf = oldinfo;
 		maxchar = oldmaxchar;
 	    return 1 * m->dvi_adv;
 	}
 	else {
 	    errx(1, "internal error -- currinf.set_char_p = %p",
 		currinf.set_char_p);
 	}
 }
 
 /*
  *	Do a rule in the geometry-scanning routine.
  */
 
 static	void
 geom_do_rule(g_info, h, w)
 	struct geom_info	*g_info;
 	long			h, w;
 {
 #if 0
 	long			x, y;
 
 	x = G_PXL_H;
 	y = PXL_V;
 	g_info->geom_box(g_info, x, y - xpixel_round(h) + 1,
 	  x + xpixel_round(w) - 1, y);
 #endif
 }
 
 
 /*
  *	Geometric dvi scanner work routine.  This does most of the work
  *	(a) reading from a page, and (b) executing vf macros.
  */
 
 static	void
 geom_scan_part(g_info, minframe, current_dimconv)
 	struct geom_info	*g_info;
 	struct frame		*minframe;
 	double			current_dimconv;
 {
 	unsigned char	ch;
 
 	currinf.fontp = NULL;
 	currinf.set_char_p = set_no_char;
 	for (;;) {
 	    ch = xone();
 	    if (ch <= (unsigned char) (SETCHAR0 + 127))
 		DVI_H += geom_do_char(g_info, ch);
 	    else if (FNTNUM0 <= ch && ch <= (unsigned char) (FNTNUM0 + 63))
 		change_font((unsigned long) (ch - FNTNUM0));
 	    else {
 		long	a, b;
 
 		switch (ch) {
 		    case SET1:
 		    case PUT1:
 			a = geom_do_char(g_info, xone());
 			if (ch != PUT1) DVI_H += a;
 			break;
 
 		    case SETRULE:
 			/* Be careful, dvicopy outputs rules with
 			   height = 0x80000000.  We don't want any
 			   SIGFPE here. */
 			a = xsfour();
 			b = xspell_conv(xsfour());
 			if (a >= 0 && b >= 0)
 			    geom_do_rule(g_info, xspell_conv(a), b);
 			DVI_H += 1 * b;
 			break;
 
 		    case PUTRULE:
 			a = xspell_conv(xsfour());
 			b = xspell_conv(xsfour());
 			if (a >= 0 && b >= 0)
 			    geom_do_rule(g_info, a, b);
 			break;
 
 		    case NOP:
 			break;
 
 		    case BOP:
 			xskip((long) 11 * 4);
 			DVI_H = G_OFFSET_X;
 			DVI_V = G_OFFSET_Y;
 			PXL_V = xpixel_conv(DVI_V);
 			WW = XX = YY = ZZ = 0;
 			break;
 
 		    case PUSH:
 			if (geom_current_frame->next == NULL) {
 			    struct frame *newp = xmalloc(sizeof(struct frame));
 
 			    geom_current_frame->next = newp;
 			    newp->prev = geom_current_frame;
 			    newp->next = NULL;
 			}
 			geom_current_frame = geom_current_frame->next;
 			geom_current_frame->data = currinf.data;
 			break;
 
 		    case POP:
 			if (geom_current_frame == minframe)
 			    tell_oops("more POPs than PUSHes");
 			currinf.data = geom_current_frame->data;
 			geom_current_frame = geom_current_frame->prev;
 			break;
 
 
 		    case RIGHT1:
 		    case RIGHT2:
 		    case RIGHT3:
 		    case RIGHT4:
 			DVI_H += 1 * 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 += 1 * WW;
 			break;
 
 		    case X1:
 		    case X2:
 		    case X3:
 		    case X4:
 			XX = xspell_conv(xsnum(ch - X0));
 		    case X0:
 			DVI_H += 1 * XX;
 			break;
 
 		    case DOWN1:
 		    case DOWN2:
 		    case DOWN3:
 		    case DOWN4:
 			DVI_V += xspell_conv(xsnum(ch - DOWN1 + 1));
 			PXL_V = xpixel_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 = xpixel_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 = xpixel_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) {
 			    char *str = read_special(a);
 
 			    /* process the specials we're looking for */
 			    g_info->geom_special(g_info, str);
 			}
 			break;
 
 		    case FNTDEF1:
 		    case FNTDEF2:
 		    case FNTDEF3:
 		    case FNTDEF4:
 			xskip((long) (12 + ch - FNTDEF1 + 1));
 			a = (long) xone();
 			xskip(a + (long) xone());
 			break;
 
 		    case SREFL:
 		    case EREFL:
 		    case PRE:
 		    case POST:
 		    case POSTPOST:
 		    case EOP:
 		    default:
 			return;
 
 		} /* end switch*/
 	    } /* end else (ch not a SETCHAR or FNTNUM) */
 	} /* end for */
 }
 
 /*
  *	Main scanning routine.
  */
 
 static struct frame geom_frame0;
 
 static	void
 geom_scan(g_info)
 	struct geom_info	*g_info;
 {
 	off_t		pos_save;
 	struct drawinf	currinf_save;
 	unsigned char	maxchar_save;
 
 	if (dvi_pointer_frame != NULL)
 	    pos_save = ftell(dvi_file) -
 		(dvi_pointer_frame->end - dvi_pointer_frame->pos);
 	if (fseek(dvi_file, page_info[current_page].offset, SEEK_SET) != 0)
 		err(1, "fseek");
 
 	currinf_save = currinf;
 	maxchar_save = maxchar;
 
 	bzero((char *) &currinf.data, sizeof currinf.data);
 	currinf.tn_table_len = TNTABLELEN;
 	currinf.tn_table = tn_table;
 	currinf.tn_head = tn_head;
 	currinf.pos = currinf.end = dvi_buffer;
 	currinf.virtual = NULL;
 
 	geom_scan_part(g_info, geom_current_frame = &geom_frame0, dimconv);
 
 	maxchar = maxchar_save;
 	currinf = currinf_save;
 
 	if (dvi_pointer_frame != NULL) {
 	    if (fseek(dvi_file, pos_save, SEEK_SET) != 0)
 		err(1, "fseek");
 	    dvi_pointer_frame->pos = dvi_pointer_frame->end = dvi_buffer;
 	}
 }
 
 static void
 hypertex_box(struct geom_info *g_info, char ch, long ulx, long uly, long lrx, long lry)
 {
 	struct htex_data *htex_data = g_info->geom_data;
 	int		 index;
 	long		 x, y;
 
 	if (htex_data->temp_incomplete == 0)
 		return;
 
 	index = tolower(ch) - 'a';
 	if (index < 0 || index > 26)
 		return;
 	if (htex_data->links[index] != NULL)
 		/* This character is already taken, keep looking */
 		return;
 
 	htex_data->links[index] = htex_data->temp_url;
 	htex_data->temp_url = NULL;
 	htex_data->temp_incomplete = 0;
 
 #define PAD 10
 	x = (ulx - PAD) / mane.shrinkfactor;
 	y = (uly - PAD) / mane.shrinkfactor;
 	XFillRectangle(DISP, mane.win, linkGC, x, y,
 	    (lrx + PAD) / mane.shrinkfactor - x, (lry + PAD) / mane.shrinkfactor - y);
 }
 
 static void
 hypertex_special(struct geom_info *g_info, const char *in)
 {
 	struct htex_data *htex_data = g_info->geom_data;
 	char		*str;
 
 	if (strncasecmp(in, "html:<a href=\"", 14) != 0)
 		return;
 
 	str = xstrdup(in + 14);
 	if (strtok(str, "\"") == NULL)
 		/* No closing " found. */
 		return;
 
 	if (*str == '#')
 		/* Anchor found */
 		return;
 
 	htex_data->temp_incomplete = 1;
 	htex_data->temp_url = str;
 
 	return;
 }
 
 void
 hypertex_search(struct htex_data *data)
 {
 	struct geom_info	g_info;
 
 	g_info.geom_box = hypertex_box;
 	g_info.geom_special = hypertex_special;
 	g_info.geom_data = data;
 
 	geom_scan(&g_info);
 }