wdvi

dvi-init.c (20200B)

---

 /*========================================================================*\
 
 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 <X11/Shell.h>	/* defines XtNtitle and XtNiconName */
 
 #include "dvi-init.h"
 #include "dvi-draw.h"	/* spell_conv() */
 #include "events.h"	/* mane */
 #include "font.h"	/* struct font, struct glyph */
 #include "special.h"	/* init_prescan() */
 #include "xdvi.h"
 #include "dvi.h"
 #include "util.h"	/* xmalloc() */
 
 
 #define	PK_PRE		247
 #define	PK_ID		89
 #define	PK_MAGIC	((PK_PRE << 8) | PK_ID)
 #define	GF_PRE		247
 #define	GF_ID		131
 #define	GF_MAGIC	((GF_PRE << 8) | GF_ID)
 #define	VF_PRE		247
 #define	VF_ID_BYTE	202
 #define	VF_MAGIC	((VF_PRE << 8) | VF_ID_BYTE)
 
 
 /*
  * DVI preamble and postamble information.
  */
 static	unsigned int	dvi_unshrunk_page_w, dvi_unshrunk_page_h;
 
 /*
  *	free_vf_chain frees the vf_chain structure.
  */
 
 static	void
 free_vf_chain(struct tn *tnp)
 {
 	while (tnp != NULL) {
 	    struct tn *tnp1 = tnp->next;
 	    free((char *) tnp);
 	    tnp = tnp1;
 	}
 }
 
 
 /*
  *	Release all shrunken bitmaps for all fonts.
  */
 
 void
 reset_fonts(void)
 {
 	struct font *f;
 	struct glyph *g;
 
 	for (f = font_head; f != NULL; f = f->next) {
 		if (!(f->flags & FONT_LOADED) || (f->flags & FONT_VIRTUAL))
 			continue;
 
 		for (g = f->glyph; g <= f->glyph + f->maxchar; ++g) {
 			if (g->bitmap2.bits) {
 				free(g->bitmap2.bits);
 				g->bitmap2.bits = NULL;
 		    	}
 			if (g->pixmap2) {
 				XDestroyImage(g->image2);
 				g->pixmap2 = NULL;
 				if (g->pixmap2_t != NULL) {
 					free(g->pixmap2_t);
 					g->pixmap2_t = NULL;
 				}
 			}
 			g->fg = NULL;
 		}
 	}
 }
 
 
 
 /*
  *	Release all allocated pixels, and (in greyscale mode) invalidate
  *	all shrunken glyphs.
  */
 
 void
 reset_colors(void)
 {
 	struct font *f;
 	struct glyph *g;
 
 	while (bg_head != NULL) {
 	    struct bgrec	*bgp;
 	    struct fgrec	*fgp;
 
 	    for (fgp = bg_head->fg_head; fgp != NULL;) {
 		struct fgrec *fgp1 = fgp->next;
 		free(fgp);
 		fgp = fgp1;
 	    }
 	    bgp = bg_head->next;
 	    free(bg_head);
 	    bg_head = bgp;
 	}
 
 	/* use_grey */
 	for (f = font_head; f != NULL; f = f->next) {
 		if (!(f->flags & FONT_LOADED) || (f->flags & FONT_VIRTUAL))
 			continue;
 
 		for (g = f->glyph; g <= f->glyph + f->maxchar; ++g)
 			g->fg = NULL;
 	}
 
 	bg_current = NULL;
 	fg_active = NULL;
 }
 
 /*
  *	All of the above, plus discard all scanned information.
  */
 
 void
 full_reset_colors(void)
 {
 	if (page_colors != NULL) {
 	    int			i;
 	    const struct rgb	*last_freed = &fg_initial;
 
 	    for (i = 0; i < total_pages; ++i) {
 		if (page_colors[i].colorstack != last_freed) {
 		    last_freed = page_colors[i].colorstack;
 		    if (last_freed != NULL)
 			free((char *) last_freed);
 		}
 	    }
 	    free((char *) page_colors);
 	    page_colors = NULL;
 	}
 	reset_colors();
 }
 
 
 
 /*
  *	realloc_font allocates the font structure to contain (newsize + 1)
  *	characters.
  */
 
 void
 realloc_font(struct font *fontp, unsigned char newsize)
 {
 	struct glyph *glyph;
 
 	glyph = fontp->glyph = xrealloc(fontp->glyph,
 	    (unsigned int) (newsize + 1) * sizeof(struct glyph));
 	if (newsize > fontp->maxchar)
 	    bzero((char *) (glyph + fontp->maxchar + 1),
 		(int) (newsize - fontp->maxchar) * sizeof(struct glyph));
 	maxchar = fontp->maxchar = newsize;
 }
 
 
 /*
  *	realloc_virtual_font does the same thing for virtual fonts.
  */
 
 void
 realloc_virtual_font(struct font *fontp, unsigned char newsize)
 {
 	struct macro *macro;
 
 	macro = fontp->macro = xrealloc(fontp->macro,
 	    (unsigned int) (newsize + 1) * sizeof(struct macro));
 	if (newsize > fontp->maxchar)
 	    bzero((char *) (macro + fontp->maxchar + 1),
 		(int) (newsize - fontp->maxchar) * sizeof(struct macro));
 	maxchar = fontp->maxchar = newsize;
 }
 
 
 /*
  *	load_font locates the raster file and reads the index of characters,
  *	plus whatever other preprocessing is done (depending on the format).
  *	Returns True if successful; False if not.
  */
 
 Boolean
 load_font(struct font *fontp)
 {
 	double	fsize	= fontp->fsize;
 	int	dpi	= fsize + 0.5;
 	char	*font_found;
 	int	size_found;
 	int	magic;
 	Boolean	hushcs	= False;
 
 	if (!font_open(fontp, &font_found, &size_found)) {
 	    if (ev_flags & EV_GE_NEWDOC)
 		return False;
 	    fontp->flags |= FONT_LOADED;	/* as loaded as it'll get */
 	    warnx("can't find font '%s'.", fontp->fontname);
 	    return False;
 	}
 	fontp->flags |= FONT_LOADED;
 	if (font_found != NULL) {
 	    warnx("can't find font '%s'; using '%s' instead at %d dpi.",
 		    fontp->fontname, font_found, dpi);
 	    free(fontp->fontname);
 	    fontp->fontname = font_found;
 	    hushcs = True;
 	}
 	else if (size_found > (int) (1.002 * fsize + 0.5) ||
 		size_found < (int) (0.998 * fsize + 0.5))
 	    warnx("can't find font %s at %d dpi; using %d dpi instead.",
 		fontp->fontname, dpi, size_found);
 	fontp->timestamp = ++current_timestamp;
 	fontp->maxchar = maxchar = 255;
 	fontp->set_char_p = set_char;
 	if (fontp->ft != NULL) {	/* if freetype font */
 	    fontp->set_char_p = set_ft_char;
 	    fontp->glyph = xmalloc(256 * sizeof(struct glyph));
 	    bzero((char *) fontp->glyph, 256 * sizeof(struct glyph));
 	    return True;
 	}
 	fontp->fsize = size_found;
 	magic = two(fontp->file);
 	if (magic == PK_MAGIC) read_PK_index(fontp, hushcs);
 	else
 	    if (magic == VF_MAGIC) read_VF_index(fontp, hushcs);
 	else
 	    errx(1, "Cannot recognize format for font file '%s'",
 		fontp->filename);
 
 	if (fontp->flags & FONT_VIRTUAL) {
 	    while (maxchar > 0 && fontp->macro[maxchar].pos == NULL) --maxchar;
 	    if (maxchar < 255)
 		realloc_virtual_font(fontp, maxchar);
 	}
 	else {
 	    while (maxchar > 0 && fontp->glyph[maxchar].addr == 0) --maxchar;
 	    if (maxchar < 255)
 		realloc_font(fontp, maxchar);
 	}
 	return True;
 }
 
 
 /*
  *	MAGSTEPVALUE - If the given magnification is close to a \magstep
  *	or a \magstephalf, then return twice the number of \magsteps.
  *	Otherwise return NOMAGSTP.
  */
 
 #define	NOMAGSTP (-29999)
 #define	NOBUILD	29999
 
 static	int
 magstepvalue(float *mag)
 {
 	int	m	= 0;
 	double	fmag	= *mag;
 	double	xmag	= pixels_per_inch;
 	float	margin	= fmag * 0.002;
 
 	if (fmag < pixels_per_inch)
 	    for (;;) {
 		if (xmag - fmag < margin && -(xmag - fmag) < margin) {
 		    *mag = xmag;
 		    return m;
 		}
 		if (xmag < fmag) break;
 		xmag *= 0.9128709292;
 		--m;
 	    }
 	else
 	    for (;;) {
 		if (xmag - fmag < margin && -(xmag - fmag) < margin) {
 		    *mag = xmag;
 		    return m;
 		}
 		if (xmag > fmag) break;
 		xmag *= 1.095445115;
 		++m;
 	    }
 	return NOMAGSTP;
 }
 
 
 /*
  *	reuse_font recursively sets the flags for font structures being reused.
  */
 
 static	void
 reuse_font(struct font *fontp)
 {
 	struct font **fp;
 	struct tn *tnp;
 
 	if (fontp->flags & FONT_IN_USE) return;
 
 	fontp->flags |= FONT_IN_USE;
 	if (resource._list_fonts)
 	    printf("(reusing) %s at %d dpi\n", fontp->fontname,
 		(int) (fontp->fsize + 0.5));
 	if (fontp->flags & FONT_VIRTUAL) {
 	    for (fp = fontp->vf_table; fp < fontp->vf_table + VFTABLELEN; ++fp)
 		if (*fp != NULL) reuse_font(*fp);
 	    for (tnp = fontp->vf_chain; tnp != NULL; tnp = tnp->next)
 		reuse_font(tnp->fontp);
 	}
 }
 
 
 /*
  *      define_font reads the rest of the fntdef command and then reads in
  *      the specified pixel file, adding it to the global linked-list holding
  *      all of the fonts used in the job.
  *
  *	vfparent;		vf parent of this font, or NULL
  *	tntable;		table for low TeXnumbers
  *	tn_table_len;		length of table for TeXnumbers
  *	tn_headpp;		addr of head of list of TeXnumbers
  *	m;			magnification
  *
  *	returns NULL when a font cannot be loaded, non NULL otherwise.
  */
 struct font *
 define_font(FILE *file, unsigned char cmnd, struct font *vfparent,
 	struct font **tntable, unsigned int tn_table_len,
 	struct tn **tn_headpp, long m)
 {
 	long	k, c, s, d;
 	size_t	a, l;
 	struct font *fontp;
 	float	fsize;
 	double	scale_dimconv;
 	int	magstepval;
 	char	*n;
 	int	size;
 
 	k = num(file, (int) cmnd - FNTDEF1 + 1);
 	c = four(file);		/* checksum */
 	s = four(file);		/* scale */
 	d = four(file);		/* design */
 	a = one(file);		/* area (directory) length */
 	l = one(file);		/* font name length */
 	n = xmalloc(a + l + 1);
 	fread(n, sizeof(*n), a + l, file);
 	n[a + l] = '\0';	/* font name */
 
 	if (debug & DBG_PK)
 		printf("Define font '%s' scale=%ld design=%ld\n", n, s, d);
 
 	if (vfparent == NULL) {
 		fsize = 0.001 * s / d * m * pixels_per_inch;
 		scale_dimconv = dimconv;
 	}
 	else {
 	    /*
 	     *	The scaled size is given in units of vfparent->scale * 2 ** -20
 	     *	SPELL units, so we convert it into SPELL units by multiplying by
 	     *		vfparent->dimconv.
 	     *	The design size is given in units of 2 ** -20 pt, so we convert
 	     *	into SPELL units by multiplying by
 	     *		(pixels_per_inch * 2**16) / (72.27 * 2**20).
 	     */
 	    fsize = (72.27 * (1<<4)) * vfparent->dimconv * s / d;
 	    scale_dimconv = vfparent->dimconv;
 	}
 
 	magstepval = magstepvalue(&fsize);
 	size = fsize + 0.5;
 
 	/*
 	 * reuse font if possible
 	 */
 	for (fontp = font_head; fontp != NULL; fontp = fontp->next) {
 		if (strcmp(n, fontp->fontname) != 0 ||
 		    size != (int) (fontp->fsize + 0.5))
 			continue;
 
 		/* font already in use */
 		reuse_font(fontp);
 		free(n);
 		break;
 	}
 
 	if (fontp == NULL) {
 		/* font doesn't exist yet */
 		if (resource._list_fonts)
 			printf("%s at %d dpi\n", n, size);
 		fontp = xmalloc(sizeof(struct font));
 		fontp->fontname = n;
 		fontp->fsize = fsize;
 		fontp->magstepval = magstepval;
 		fontp->file = NULL; /* needed for virtual/freetype fonts */
 		fontp->filename = NULL;	/* needed for freetype fonts */
 		fontp->checksum = c;
 		fontp->flags = FONT_IN_USE;
 		fontp->dimconv = s * scale_dimconv / (1 << 20);
 		fontp->set_char_p = load_n_set_char;
 		fontp->ft = NULL;
 		/* spsize = scaled size of the font in spell units,
 		 *	  = scale * [vfparent->]dimconv.
 		 */
 		fontp->spsize = (vfparent != NULL ? vfparent->dimconv : dimconv) * s;
 		if (vfparent == NULL)
 			if (!load_font(fontp)) {
 				free(n);
 				free(fontp);
 				return NULL;
 			}
 		fontp->next = font_head;
 		font_head = fontp;
 	}
 
 	if (k < tn_table_len)
 		tntable[k] = fontp;
 	else {
 		struct tn *tnp;
 		tnp = xmalloc(sizeof(struct tn));
 		tnp->next = *tn_headpp;
 		*tn_headpp = tnp;
 		tnp->TeXnumber = k;
 		tnp->fontp = fontp;
 	}
 	return fontp;
 }
 
 Boolean
 dvi_magic_ok(FILE *dvi)
 {
 	if (one(dvi) != PRE)
 		/* Not a DVI file */
 		return False;
 	if (one(dvi) != 2)
 		/* Wrong version of DVI output for this program */
 		return False;
 
 	return True;
 }
 
 
 /*
  *      process_preamble reads the information in the preamble and stores
  *      it into global variables for later use.
  */
 static Boolean
 process_preamble(long *n, long *d, long *m)
 {
 	char	 comment[256 + 1];
 	size_t   k;
 
 	if (dvi_magic_ok(dvi_file) == False)
 		return False;
 	*n = four(dvi_file);		/* numerator */
 	*d = four(dvi_file);		/* denominator */
 	*m = four(dvi_file);		/* magnification */
 	dimconv = (((double) (*n) * (*m)) / ((double) (*d) * 1000.));
 	dimconv = dimconv * (((long) pixels_per_inch)<<16) / 254000;
 	tpic_conv = pixels_per_inch * (*m) / 1000000.0;
 	k = one(dvi_file);
 	fread(comment, sizeof(char), k, dvi_file);
 	comment[k] = '\0';
 
 	if (debug & DBG_DVI)
 		printf("Preamble comment '%s'\n", comment);
 
 	return True;
 }
 
 /*
  *      find_postamble locates the beginning of the postamble
  *	and leaves the file ready to start reading at that location.
  */
 #define	TMPSIZ	516	/* 4 trailer bytes + 512 junk bytes allowed */
 static Boolean
 find_postamble(void)
 {
 	long	pos;
 	unsigned char	temp[TMPSIZ];
 	unsigned char	*p;
 	unsigned char	*p1;
 	unsigned char	byte;
 
 	if (fseek(dvi_file, 0, SEEK_END) != 0)
 		err(1, "fseek");
 	pos = ftell(dvi_file) - TMPSIZ;
 	if (pos < 0) pos = 0;
 	if (fseek(dvi_file, pos, SEEK_SET) != 0)
 		err(1, "fseek");
 	p = temp + fread((char *) temp, sizeof(char), TMPSIZ, dvi_file);
 	for (;;) {
 	    p1 = p;
 	    while (p1 > temp && *(--p1) != TRAILER) ;
 	    p = p1;
 	    while (p > temp && *(--p) == TRAILER) ;
 	    if (p <= p1 - 4) break;	/* found 4 TRAILER bytes */
 	    if (p <= temp)
 		/* DVI file corrupted */
 		return False;
 	}
 	pos += p - temp;
 	byte = *p;
 	while (byte == TRAILER) {
 	    if (fseek(dvi_file, --pos, SEEK_SET) != 0)
 		err(1, "fseek");
 	    byte = one(dvi_file);
 	}
 	if (byte != 2)
 	    /* Wrong version of DVI output for this program */
 	    return False;
 	if (fseek(dvi_file, pos - 4, SEEK_SET) != 0)
 		err(1, "fseek");
 	if (fseek(dvi_file, sfour(dvi_file), SEEK_SET) != 0)
 		err(1, "fseek");
 
 	return True;
 }
 
 
 /*
  *      read_postamble reads the information in the postamble,
  *	storing it into global variables.
  *      It also takes care of reading in all of the pixel files for the fonts
  *      used in the job.
  */
 static	Boolean
 read_postamble(long *p, long n, long d, long m)
 {
 	unsigned char   cmnd;
 	Boolean		font_not_found;
 	struct font	*fontp;
 	struct font	**fontpp;
 
 	if (one(dvi_file) != POST)
 		/* Postamble doesn't begin with POST */
 		return False;
 	*p = four(dvi_file);		/* pointer to final bop (last page) */
 
 	/* Check postamble duplicates match preamble. */
 	if (n != four(dvi_file))
 		return False;
 	if (d != four(dvi_file))
 		return False;
 	if (m != four(dvi_file))
 		return False;
 
 	/* read largest box height and width */
 	dvi_unshrunk_page_h = (spell_conv(sfour(dvi_file)) >> 16) + offset_y;
 	if (dvi_unshrunk_page_h < unshrunk_paper_h)
 	    dvi_unshrunk_page_h = unshrunk_paper_h;
 	dvi_unshrunk_page_w = (spell_conv(sfour(dvi_file)) >> 16) + offset_x;
 	if (dvi_unshrunk_page_w < unshrunk_paper_w)
 	    dvi_unshrunk_page_w = unshrunk_paper_w;
 	(void) two(dvi_file);	/* max stack size */
 	total_pages = two(dvi_file);
 
 	/*
 	 * Attempt to load all fonts for the file. If one is not found,
 	 * keep searching such that we can show all fonts that are missing.
 	 */
 	font_not_found = False;
 	while (1) {
 		cmnd = one(dvi_file);
 		if (cmnd < FNTDEF1 || cmnd > FNTDEF4)
 			break;
 		if (define_font(dvi_file, cmnd, NULL, tn_table, TNTABLELEN,
 		    &tn_head, m) == NULL)
 			font_not_found = True;
 	}
 	if (font_not_found == True)
 		return False;
 	if (cmnd != POSTPOST)
 		/* Non-fntdef command found in postamble */
 		return False;
 	/*
 	 * free up fonts no longer in use
 	 */
 	fontpp = &font_head;
 	while ((fontp = *fontpp) != NULL) {
 		if (fontp->flags & FONT_IN_USE) {
 			fontpp = &fontp->next;
 			continue;
 		}
 		if (debug & DBG_PK)
 		    printf("Discarding font \"%s\" at %d dpi\n",
 			fontp->fontname, (int) (fontp->fsize + 0.5));
 		*fontpp = fontp->next;		/* remove from list */
 		free(fontp->fontname);
 		if (fontp->flags & FONT_LOADED) {
 		    if (fontp->ft != NULL) {	/* if FreeType font */
 			struct ftfont	*ft;
 
 			ft = fontp->ft;
 			if (fontp->size != NULL)
 			    FT_Done_Size(fontp->size);
 			if (fontp == ft->first_size) {
 			    if (fontp->next_size == NULL) {
 				/* if this is the only size of this font face */
 				FT_Done_Face(ft->face);
 				ft->t1->ft = NULL;
 				free(ft);
 			    }
 			    else {
 				struct font	*fp2;
 
 				ft->first_size = fp2 = fontp->next_size;
 				fp2->file = fontp->file;
 				fontp->file = NULL;
 				fp2->filename = fontp->filename;
 				fontp->filename = NULL;
 				fp2->timestamp = fontp->timestamp;
 			    }
 			}
 			else {
 			    struct font *fp2;
 
 			    fp2 = ft->first_size;
 			    while (fp2->next_size != fontp)
 				fp2 = fp2->next_size;
 			    fp2->next_size = fontp->next_size;
 			}
 		    }
 		    if (fontp->file != NULL)
 			fclose(fontp->file);
 		    if (fontp->filename != NULL)
 			free((void *) fontp->filename);
 
 		    if (fontp->flags & FONT_VIRTUAL) {
 			struct macro *m;
 
 			for (m = fontp->macro;
 				m <= fontp->macro + fontp->maxchar; ++m)
 			    if (m->free_me) free((char *) m->pos);
 			free((char *) fontp->macro);
 			free((char *) fontp->vf_table);
 			free_vf_chain(fontp->vf_chain);
 		    }
 		    else {
 			struct glyph *g;
 
 			for (g = fontp->glyph;
 				g <= fontp->glyph + fontp->maxchar; ++g) {
 			    if (g->bitmap.bits != NULL) free(g->bitmap.bits);
 			    if (g->bitmap2.bits != NULL) free(g->bitmap2.bits);
 			    if (g->pixmap2 != NULL) {
 				XDestroyImage(g->image2);
 				if (g->pixmap2_t != NULL)
 				    free(g->pixmap2_t);
 			    }
 			}
 			free((char *) fontp->glyph);
 		    }
 		    free((char *) fontp);
 		}
 	}
 	return True;
 }
 
 static	void
 prepare_pages(long p)
 {
 	int i;
 
 	page_info = xmalloc((unsigned) (total_pages + 1) * sizeof(*page_info));
 	page_info->pw = unshrunk_paper_w;
 	page_info->ph = unshrunk_paper_h;
 	page_info->ww = dvi_unshrunk_page_w;
 	page_info->wh = dvi_unshrunk_page_h;
 	++page_info;	/* this is indexed starting with -1 */
 
 	i = total_pages;
 	page_info[--i].offset = p;
 	if (fseek(dvi_file, p, SEEK_SET) != 0)
 		err(1, "fseek");
 	/*
 	 * Follow back pointers through pages in the DVI file,
 	 * storing the offsets in the page_info[].offset table.
 	 */
 	while (i > 0) {
 		if (fseek(dvi_file, (long) (1+4+(9*4)), SEEK_CUR) != 0)
 			err(1, "fseek");
 		if (fseek(dvi_file, page_info[--i].offset = four(dvi_file),
 		    SEEK_SET) != 0)
 			err(1, "fseek");
 	}
 }
 
 void
 init_page(void)
 {
 	unshrunk_page_w = page_info[current_page].ww;
 	page_w = ROUNDUP(unshrunk_page_w, mane.shrinkfactor) + 2;
 	unshrunk_page_h = page_info[current_page].wh;
 	page_h = ROUNDUP(unshrunk_page_h, mane.shrinkfactor) + 2;
 }
 
 	/* For non-toolkit compiles, this code appears in xdvi.c.  */
 
 static	void
 set_titles(void)
 {
 	char	*title_name;
 	char	*icon_name;
 	size_t	baselen;
 	Boolean	icon_name_malloced = False;
 
 	icon_name = rindex(dvi_name, '/');
 	if (icon_name != NULL) ++icon_name;
 	  else icon_name = dvi_name;
 	baselen = strlen(icon_name);
 	if (baselen > 4 && memcmp(icon_name + baselen - 4, ".dvi", 4) == 0) {
 	    /* remove the .dvi */
 	    char *p;
 
 	    baselen -= 4;
 	    p = xmalloc(baselen + 1);
 	    memcpy(p, icon_name, baselen);
 	    p[baselen] = '\0';
 	    icon_name = p;
 	    icon_name_malloced = True;
 	}
 
 	title_name = xmalloc(baselen + 8);
 	memcpy(title_name, "Xdvi:  ", 7);
 	memcpy(title_name + 7, icon_name, baselen + 1);
 
 	XtVaSetValues(top_level,
 	  XtNtitle, title_name,
 	  XtNiconName, icon_name,
 	  NULL);
 
 	free(title_name);
 	if (icon_name_malloced)
 	    free(icon_name);
 }
 
 /*
  *	init_dvi_file is the main subroutine for reading the startup
  *	information from the dvi file.
  */
 
 Boolean
 init_dvi_file(void)
 {
 	long	n, d, m, p;
 
 	if (!process_preamble(&n, &d, &m))
 		goto err;
 	if (!find_postamble())
 		goto err;
 	if (!read_postamble(&p, n, d, m))
 		goto err;
 
 	prepare_pages(p);
 	if (current_page >= total_pages)
 		current_page = total_pages - 1;
 	init_prescan();
 	set_titles();
 
 	return True;
 
 err:
 	fclose(dvi_file);
 	dvi_file = NULL;
 	return False;
 }
 
 
 /**
  **	Reload the dvi file (unconditionally).  Called only from do_pages().
  **/
 
 Boolean
 reload_dvi_file(void)
 {
 	struct font	*fontp;
 
 	if (page_info != NULL) {
 		free(page_info - 1);
 		page_info = NULL;
 		full_reset_colors();
 	}
 	bzero(tn_table, sizeof(tn_table));
 	free_vf_chain(tn_head);
 	tn_head = NULL;
 	for (fontp = font_head; fontp != NULL; fontp = fontp->next)
 	    fontp->flags &= ~FONT_IN_USE;
 
 	if (fseek(dvi_file, 0, SEEK_SET) != 0)
 		err(1, "fseek");
 	if (!init_dvi_file())
 		return False;
 	if (resource._list_fonts)
 		putchar('\n');
 
 	return True;
 }