Initial import of xtrkcad version 1:4.0.2-2

1 files changed, 2789 insertions, 0 deletions

diff --git a/app/tools/halibut/bk_paper.c b/app/tools/halibut/bk_paper.c
new file mode 100644
index 0000000..2e0289c
--- /dev/null
+++ b/app/tools/halibut/bk_paper.c
@@ -0,0 +1,2789 @@
+/*
+ * Paper printing pre-backend for Halibut.
+ * 
+ * This module does all the processing common to both PostScript
+ * and PDF output: selecting fonts, line wrapping and page breaking
+ * in accordance with font metrics, laying out the contents and
+ * index pages, generally doing all the page layout. After this,
+ * bk_ps.c and bk_pdf.c should only need to do linear translations
+ * into their literal output format.
+ */
+
+/*
+ * TODO in future work:
+ * 
+ *  - linearised PDF, perhaps?
+ * 
+ *  - I'm uncertain of whether I need to include a ToUnicode CMap
+ *    in each of my font definitions in PDF. Currently things (by
+ *    which I mean cut and paste out of acroread) seem to be
+ *    working fairly happily without it, but I don't know.
+ * 
+ *  - rather than the ugly aux_text mechanism for rendering chapter
+ *    titles, we could actually build the correct word list and
+ *    wrap it as a whole.
+ * 
+ *  - get vertical font metrics and use them to position the PDF
+ *    xref boxes more pleasantly
+ * 
+ *  - configurability
+ *     * page header and footer should be configurable; we should
+ * 	 be able to shift the page number elsewhere, and add other
+ * 	 things such as the current chapter/section title and fixed
+ * 	 text
+ *     * remove the fixed mapping from heading levels to heading
+ * 	 styles; offer a menu of styles from which the user can
+ * 	 choose at every heading level
+ *     * first-line indent in paragraphs
+ *     * fixed text: `Contents', `Index', the colon-space and full
+ * 	 stop in chapter title constructions
+ *     * configurable location of contents?
+ *     * certainly configurably _remove_ the contents, and possibly
+ * 	 also the index
+ *     * double-sided document switch?
+ * 	  + means you have two header/footer formats which
+ * 	    alternate
+ * 	  + and means that mandatory page breaks before chapter
+ * 	    titles should include a blank page if necessary to
+ * 	    start the next section to a right-hand page
+ * 
+ *  - title pages
+ * 
+ *  - ability to use Type 1 fonts without AFM files
+ *     * we need to parse the font to extract its metrics
+ * 
+ *  - character substitution for better typography?
+ *     * use real ellipsis rather than ...
+ *     * a hyphen in a word by itself might prefer to be an en-dash
+ *     * (Americans might even want a convenient way to use an
+ * 	 em-dash)
+ *     * DON'T DO ANY OF THE ABOVE WITHIN \c OR \cw!
+ *     * substituting `minus' for `hyphen' in the standard encoding
+ * 	 is probably preferable in Courier, though certainly not in
+ * 	 the main text font
+ *     * if I do do this lot, I'm rather inclined to at least try
+ * 	 to think up a configurable way to do it so that Americans
+ * 	 can do em-dash tricks without my intervention and other
+ * 	 people can do other odd things too.
+ */
+
+#include <assert.h>
+#include <stdio.h>
+#include <stdarg.h>
+#include <stdlib.h>
+
+#include "halibut.h"
+#include "paper.h"
+
+typedef struct paper_conf_Tag paper_conf;
+typedef struct paper_idx_Tag paper_idx;
+
+typedef struct {
+    font_data *fonts[NFONTS];
+    int font_size;
+} font_cfg;
+
+struct paper_conf_Tag {
+    int paper_width;
+    int paper_height;
+    int left_margin;
+    int top_margin;
+    int right_margin;
+    int bottom_margin;
+    int indent_list_bullet;
+    int indent_list_after;
+    int indent_list;
+    int indent_quote;
+    int base_leading;
+    int base_para_spacing;
+    int chapter_top_space;
+    int sect_num_left_space;
+    int chapter_underline_depth;
+    int chapter_underline_thickness;
+    int rule_thickness;
+    font_cfg fbase, fcode, ftitle, fchapter, *fsect;
+    int nfsect;
+    int contents_indent_step;
+    int contents_margin;
+    int leader_separation;
+    int index_gutter;
+    int index_cols;
+    int index_minsep;
+    int pagenum_fontsize;
+    int footer_distance;
+    wchar_t *lquote, *rquote, *bullet;
+    wchar_t *contents_text, *index_text;
+    /* These are derived from the above */
+    int base_width;
+    int page_height;
+    int index_colwidth;
+};
+
+struct paper_idx_Tag {
+    /*
+     * Word list giving the page numbers on which this index entry
+     * appears. Also the last word in the list, for ease of
+     * construction.
+     */
+    word *words;
+    word *lastword;
+    /*
+     * The last page added to the list (so we can ensure we don't
+     * add one twice).
+     */
+    page_data *lastpage;
+};
+
+enum {
+    word_PageXref = word_NotWordType + 1
+};
+
+/* Flags for render_string() */
+#define RS_NOLIG	1
+
+static font_data *make_std_font(font_list *fontlist, char const *name);
+static void wrap_paragraph(para_data *pdata, word *words,
+			   int w, int i1, int i2, paper_conf *conf);
+static page_data *page_breaks(line_data *first, line_data *last,
+			      int page_height, int ncols, int headspace);
+static int render_string(page_data *page, font_data *font, int fontsize,
+			 int x, int y, wchar_t *str, unsigned flags);
+static int render_line(line_data *ldata, int left_x, int top_y,
+		       xref_dest *dest, keywordlist *keywords, indexdata *idx,
+		       paper_conf *conf);
+static void render_para(para_data *pdata, paper_conf *conf,
+			keywordlist *keywords, indexdata *idx,
+			paragraph *index_placeholder, page_data *index_page);
+static int string_width(font_data *font, wchar_t const *string, int *errs,
+			unsigned flags);
+static int paper_width_simple(para_data *pdata, word *text, paper_conf *conf);
+static para_data *code_paragraph(int indent, word *words, paper_conf *conf);
+static para_data *rule_paragraph(int indent, paper_conf *conf);
+static void add_rect_to_page(page_data *page, int x, int y, int w, int h);
+static para_data *make_para_data(int ptype, int paux, int indent, int rmargin,
+				 word *pkwtext, word *pkwtext2, word *pwords,
+				 paper_conf *conf);
+static void standard_line_spacing(para_data *pdata, paper_conf *conf);
+static wchar_t *prepare_outline_title(word *first, wchar_t *separator,
+				      word *second);
+static word *fake_word(wchar_t *text);
+static word *fake_space_word(void);
+static word *fake_page_ref(page_data *page);
+static word *fake_end_ref(void);
+static word *prepare_contents_title(word *first, wchar_t *separator,
+				    word *second);
+static void fold_into_page(page_data *dest, page_data *src, int right_shift);
+
+static int fonts_ok(wchar_t *string, ...)
+{
+    font_data *font;
+    va_list ap;
+    int ret = TRUE;
+
+    va_start(ap, string);
+    while ( (font = va_arg(ap, font_data *)) != NULL) {
+	int errs;
+	(void) string_width(font, string, &errs, 0);
+	if (errs) {
+	    ret = FALSE;
+	    break;
+	}
+    }
+    va_end(ap);
+
+    return ret;
+}
+
+static void paper_cfg_fonts(font_data **fonts, font_list *fontlist,
+			    wchar_t *wp, filepos *fpos) {
+    font_data *f;
+    char *fn;
+    int i;
+
+    for (i = 0; i < NFONTS && *wp; i++, wp = uadv(wp)) {
+	fn = utoa_dup(wp, CS_ASCII);
+	f = make_std_font(fontlist, fn);
+	if (f)
+	    fonts[i] = f;
+	else
+	    /* FIXME: proper error */
+	    error(err_nofont, fpos, wp);
+    }
+}
+
+static paper_conf paper_configure(paragraph *source, font_list *fontlist) {
+    paragraph *p;
+    paper_conf ret;
+
+    /*
+     * Defaults.
+     */
+    ret.paper_width = 595 * UNITS_PER_PT;
+    ret.paper_height = 842 * UNITS_PER_PT;
+    ret.left_margin = 72 * UNITS_PER_PT;
+    ret.top_margin = 72 * UNITS_PER_PT;
+    ret.right_margin = 72 * UNITS_PER_PT;
+    ret.bottom_margin = 108 * UNITS_PER_PT;
+    ret.indent_list_bullet = 6 * UNITS_PER_PT;
+    ret.indent_list_after = 18 * UNITS_PER_PT;
+    ret.indent_quote = 18 * UNITS_PER_PT;
+    ret.base_leading = UNITS_PER_PT;
+    ret.base_para_spacing = 10 * UNITS_PER_PT;
+    ret.chapter_top_space = 72 * UNITS_PER_PT;
+    ret.sect_num_left_space = 12 * UNITS_PER_PT;
+    ret.chapter_underline_depth = 14 * UNITS_PER_PT;
+    ret.chapter_underline_thickness = 3 * UNITS_PER_PT;
+    ret.rule_thickness = 1 * UNITS_PER_PT;
+    ret.fbase.font_size = 12;
+    ret.fbase.fonts[FONT_NORMAL] = make_std_font(fontlist, "Times-Roman");
+    ret.fbase.fonts[FONT_EMPH] = make_std_font(fontlist, "Times-Italic");
+    ret.fbase.fonts[FONT_CODE] = make_std_font(fontlist, "Courier");
+    ret.fcode.font_size = 12;
+    ret.fcode.fonts[FONT_NORMAL] = make_std_font(fontlist, "Courier-Bold");
+    ret.fcode.fonts[FONT_EMPH] = make_std_font(fontlist, "Courier-Oblique");
+    ret.fcode.fonts[FONT_CODE] = make_std_font(fontlist, "Courier");
+    ret.ftitle.font_size = 24;
+    ret.ftitle.fonts[FONT_NORMAL] = make_std_font(fontlist, "Helvetica-Bold");
+    ret.ftitle.fonts[FONT_EMPH] =
+	make_std_font(fontlist, "Helvetica-BoldOblique");
+    ret.ftitle.fonts[FONT_CODE] = make_std_font(fontlist, "Courier-Bold");
+    ret.fchapter.font_size = 20;
+    ret.fchapter.fonts[FONT_NORMAL]= make_std_font(fontlist, "Helvetica-Bold");
+    ret.fchapter.fonts[FONT_EMPH] =
+	make_std_font(fontlist, "Helvetica-BoldOblique");
+    ret.fchapter.fonts[FONT_CODE] = make_std_font(fontlist, "Courier-Bold");
+    ret.nfsect = 3;
+    ret.fsect = snewn(ret.nfsect, font_cfg);
+    ret.fsect[0].font_size = 16;
+    ret.fsect[0].fonts[FONT_NORMAL]= make_std_font(fontlist, "Helvetica-Bold");
+    ret.fsect[0].fonts[FONT_EMPH] =
+	make_std_font(fontlist, "Helvetica-BoldOblique");
+    ret.fsect[0].fonts[FONT_CODE] = make_std_font(fontlist, "Courier-Bold");
+    ret.fsect[1].font_size = 14;
+    ret.fsect[1].fonts[FONT_NORMAL]= make_std_font(fontlist, "Helvetica-Bold");
+    ret.fsect[1].fonts[FONT_EMPH] =
+	make_std_font(fontlist, "Helvetica-BoldOblique");
+    ret.fsect[1].fonts[FONT_CODE] = make_std_font(fontlist, "Courier-Bold");
+    ret.fsect[2].font_size = 13;
+    ret.fsect[2].fonts[FONT_NORMAL]= make_std_font(fontlist, "Helvetica-Bold");
+    ret.fsect[2].fonts[FONT_EMPH] =
+	make_std_font(fontlist, "Helvetica-BoldOblique");
+    ret.fsect[2].fonts[FONT_CODE] = make_std_font(fontlist, "Courier-Bold");
+    ret.contents_indent_step = 24 * UNITS_PER_PT;
+    ret.contents_margin = 84 * UNITS_PER_PT;
+    ret.leader_separation = 12 * UNITS_PER_PT;
+    ret.index_gutter = 36 * UNITS_PER_PT;
+    ret.index_cols = 2;
+    ret.index_minsep = 18 * UNITS_PER_PT;
+    ret.pagenum_fontsize = 12;
+    ret.footer_distance = 32 * UNITS_PER_PT;
+    ret.lquote = L"\x2018\0\x2019\0'\0'\0\0";
+    ret.rquote = uadv(ret.lquote);
+    ret.bullet = L"\x2022\0-\0\0";
+    ret.contents_text = L"Contents";
+    ret.index_text = L"Index";
+
+    /*
+     * Two-pass configuration so that we can pick up global config
+     * (e.g. `quotes') before having it overridden by specific
+     * config (`paper-quotes'), irrespective of the order in which
+     * they occur.
+     */
+    for (p = source; p; p = p->next) {
+	if (p->type == para_Config) {
+	    if (!ustricmp(p->keyword, L"quotes")) {
+		if (*uadv(p->keyword) && *uadv(uadv(p->keyword))) {
+		    ret.lquote = uadv(p->keyword);
+		    ret.rquote = uadv(ret.lquote);
+		}
+	    }
+	}
+    }
+
+    for (p = source; p; p = p->next) {
+	p->private_data = NULL;
+	if (p->type == para_Config) {
+	    if (!ustricmp(p->keyword, L"paper-quotes")) {
+		if (*uadv(p->keyword) && *uadv(uadv(p->keyword))) {
+		    ret.lquote = uadv(p->keyword);
+		    ret.rquote = uadv(ret.lquote);
+		}
+	    } else if (!ustricmp(p->keyword, L"contents")) {
+		ret.contents_text = uadv(p->keyword);
+	    } else if (!ustricmp(p->keyword, L"index")) {
+		ret.index_text = uadv(p->keyword);
+	    } else if (!ustricmp(p->keyword, L"paper-bullet")) {
+		ret.bullet = uadv(p->keyword);
+	    } else if (!ustricmp(p->keyword, L"paper-page-width")) {
+		ret.paper_width =
+		    (int) 0.5 + FUNITS_PER_PT * utof(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-page-height")) {
+		ret.paper_height =
+		    (int) 0.5 + FUNITS_PER_PT * utof(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-left-margin")) {
+		ret.left_margin =
+		    (int) 0.5 + FUNITS_PER_PT * utof(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-top-margin")) {
+		ret.top_margin =
+		    (int) 0.5 + FUNITS_PER_PT * utof(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-right-margin")) {
+		ret.right_margin =
+		    (int) 0.5 + FUNITS_PER_PT * utof(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-bottom-margin")) {
+		ret.bottom_margin =
+		    (int) 0.5 + FUNITS_PER_PT * utof(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-list-indent")) {
+		ret.indent_list_bullet =
+		    (int) 0.5 + FUNITS_PER_PT * utof(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-listitem-indent")) {
+		ret.indent_list =
+		    (int) 0.5 + FUNITS_PER_PT * utof(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-quote-indent")) {
+		ret.indent_quote =
+		    (int) 0.5 + FUNITS_PER_PT * utof(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-base-leading")) {
+		ret.base_leading =
+		    (int) 0.5 + FUNITS_PER_PT * utof(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-base-para-spacing")) {
+		ret.base_para_spacing =
+		    (int) 0.5 + FUNITS_PER_PT * utof(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-chapter-top-space")) {
+		ret.chapter_top_space =
+		    (int) 0.5 + FUNITS_PER_PT * utof(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-sect-num-left-space")) {
+		ret.sect_num_left_space =
+		    (int) 0.5 + FUNITS_PER_PT * utof(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-chapter-underline-depth")) {
+		ret.chapter_underline_depth =
+		    (int) 0.5 + FUNITS_PER_PT * utof(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-chapter-underline-thickness")) {
+		ret.chapter_underline_thickness =
+		    (int) 0.5 + FUNITS_PER_PT * utof(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-rule-thickness")) {
+		ret.rule_thickness =
+		    (int) 0.5 + FUNITS_PER_PT * utof(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-contents-indent-step")) {
+		ret.contents_indent_step =
+		    (int) 0.5 + FUNITS_PER_PT * utof(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-contents-margin")) {
+		ret.contents_margin =
+		    (int) 0.5 + FUNITS_PER_PT * utof(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-leader-separation")) {
+		ret.leader_separation =
+		    (int) 0.5 + FUNITS_PER_PT * utof(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-index-gutter")) {
+		ret.index_gutter =
+		    (int) 0.5 + FUNITS_PER_PT * utof(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-index-minsep")) {
+		ret.index_minsep =
+		    (int) 0.5 + FUNITS_PER_PT * utof(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-footer-distance")) {
+		ret.footer_distance =
+		    (int) 0.5 + FUNITS_PER_PT * utof(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-base-font-size")) {
+		ret.fbase.font_size = utoi(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-index-columns")) {
+		ret.index_cols = utoi(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-pagenum-font-size")) {
+		ret.pagenum_fontsize = utoi(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-base-fonts")) {
+		paper_cfg_fonts(ret.fbase.fonts, fontlist, uadv(p->keyword),
+				&p->fpos);
+	    } else if (!ustricmp(p->keyword, L"paper-code-font-size")) {
+		ret.fcode.font_size = utoi(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-code-fonts")) {
+		paper_cfg_fonts(ret.fcode.fonts, fontlist, uadv(p->keyword),
+				&p->fpos);
+	    } else if (!ustricmp(p->keyword, L"paper-title-font-size")) {
+		ret.ftitle.font_size = utoi(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-title-fonts")) {
+		paper_cfg_fonts(ret.ftitle.fonts, fontlist, uadv(p->keyword),
+				&p->fpos);
+	    } else if (!ustricmp(p->keyword, L"paper-chapter-font-size")) {
+		ret.fchapter.font_size = utoi(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-chapter-fonts")) {
+		paper_cfg_fonts(ret.fchapter.fonts, fontlist, uadv(p->keyword),
+				&p->fpos);
+	    } else if (!ustricmp(p->keyword, L"paper-section-font-size")) {
+		wchar_t *q = uadv(p->keyword);
+		int n = 0;
+		if (uisdigit(*q)) {
+		    n = utoi(q);
+		    q = uadv(q);
+		}
+		if (n >= ret.nfsect) {
+		    int i;
+		    ret.fsect = sresize(ret.fsect, n+1, font_cfg);
+		    for (i = ret.nfsect; i <= n; i++)
+			ret.fsect[i] = ret.fsect[ret.nfsect-1];
+		    ret.nfsect = n+1;
+		}
+		ret.fsect[n].font_size = utoi(q);
+	    } else if (!ustricmp(p->keyword, L"paper-section-fonts")) {
+		wchar_t *q = uadv(p->keyword);
+		int n = 0;
+		if (uisdigit(*q)) {
+		    n = utoi(q);
+		    q = uadv(q);
+		}
+		if (n >= ret.nfsect) {
+		    int i;
+		    ret.fsect = sresize(ret.fsect, n+1, font_cfg);
+		    for (i = ret.nfsect; i <= n; i++)
+			ret.fsect[i] = ret.fsect[ret.nfsect-1];
+		    ret.nfsect = n+1;
+		}
+		paper_cfg_fonts(ret.fsect[n].fonts, fontlist, q, &p->fpos);
+	    } 
+	}
+    }
+
+    /*
+     * Set up the derived fields in the conf structure.
+     */
+
+    ret.base_width =
+	ret.paper_width - ret.left_margin - ret.right_margin;
+    ret.page_height =
+	ret.paper_height - ret.top_margin - ret.bottom_margin;
+    ret.indent_list = ret.indent_list_bullet + ret.indent_list_after;
+    ret.index_colwidth =
+	(ret.base_width - (ret.index_cols-1) * ret.index_gutter)
+	/ ret.index_cols;
+
+    /*
+     * Now process fallbacks on quote characters and bullets. We
+     * use string_width() to determine whether all of the relevant
+     * fonts contain the same character, and fall back whenever we
+     * find a character which not all of them support.
+     */
+
+    /* Quote characters need not be supported in the fixed code fonts,
+     * but must be in the title and body fonts. */
+    while (*uadv(ret.rquote) && *uadv(uadv(ret.rquote))) {
+	int n;
+	if (fonts_ok(ret.lquote,
+		     ret.fbase.fonts[FONT_NORMAL],
+		     ret.fbase.fonts[FONT_EMPH],
+		     ret.ftitle.fonts[FONT_NORMAL],
+		     ret.ftitle.fonts[FONT_EMPH],
+		     ret.fchapter.fonts[FONT_NORMAL],
+		     ret.fchapter.fonts[FONT_EMPH], NULL) &&
+	    fonts_ok(ret.rquote,
+		     ret.fbase.fonts[FONT_NORMAL],
+		     ret.fbase.fonts[FONT_EMPH],
+		     ret.ftitle.fonts[FONT_NORMAL],
+		     ret.ftitle.fonts[FONT_EMPH],
+		     ret.fchapter.fonts[FONT_NORMAL],
+		     ret.fchapter.fonts[FONT_EMPH], NULL)) {
+	    for (n = 0; n < ret.nfsect; n++)
+		if (!fonts_ok(ret.lquote,
+			      ret.fsect[n].fonts[FONT_NORMAL],
+			      ret.fsect[n].fonts[FONT_EMPH], NULL) ||
+		    !fonts_ok(ret.rquote,
+			      ret.fsect[n].fonts[FONT_NORMAL],
+			      ret.fsect[n].fonts[FONT_EMPH], NULL))
+		    break;
+	    if (n == ret.nfsect)
+		break;
+	}
+	ret.lquote = uadv(ret.rquote);
+	ret.rquote = uadv(ret.lquote);
+    }
+
+    /* The bullet character only needs to be supported in the normal body
+     * font (not even in italics). */
+    while (*ret.bullet && *uadv(ret.bullet) &&
+	   !fonts_ok(ret.bullet, ret.fbase.fonts[FONT_NORMAL], NULL))
+	ret.bullet = uadv(ret.bullet);
+
+    return ret;
+}
+
+void *paper_pre_backend(paragraph *sourceform, keywordlist *keywords,
+			indexdata *idx) {
+    paragraph *p;
+    document *doc;
+    int indent, used_contents;
+    para_data *pdata, *firstpara = NULL, *lastpara = NULL;
+    para_data *firstcont, *lastcont;
+    line_data *firstline, *lastline, *firstcontline, *lastcontline;
+    page_data *pages;
+    font_list *fontlist;
+    paper_conf *conf, ourconf;
+    int has_index;
+    int pagenum;
+    paragraph index_placeholder_para;
+    page_data *first_index_page;
+
+    init_std_fonts();
+    fontlist = snew(font_list);
+    fontlist->head = fontlist->tail = NULL;
+
+    ourconf = paper_configure(sourceform, fontlist);
+    conf = &ourconf;
+
+    /*
+     * Set up a data structure to collect page numbers for each
+     * index entry.
+     */
+    {
+	int i;
+	indexentry *entry;
+
+	has_index = FALSE;
+
+	for (i = 0; (entry = index234(idx->entries, i)) != NULL; i++) {
+	    paper_idx *pi = snew(paper_idx);
+
+	    has_index = TRUE;
+
+	    pi->words = pi->lastword = NULL;
+	    pi->lastpage = NULL;
+
+	    entry->backend_data = pi;
+	}
+    }
+
+    /*
+     * Format the contents entry for each heading.
+     */
+    {
+	word *contents_title;
+	contents_title = fake_word(conf->contents_text);
+
+	firstcont = make_para_data(para_UnnumberedChapter, 0, 0, 0,
+				   NULL, NULL, contents_title, conf);
+	lastcont = firstcont;
+	lastcont->next = NULL;
+	firstcontline = firstcont->first;
+	lastcontline = lastcont->last;
+	for (p = sourceform; p; p = p->next) {
+	    word *words;
+	    int indent;
+
+	    switch (p->type) {
+	      case para_Chapter:
+	      case para_Appendix:
+	      case para_UnnumberedChapter:
+	      case para_Heading:
+	      case para_Subsect:
+		switch (p->type) {
+		  case para_Chapter:
+		  case para_Appendix:
+		    words = prepare_contents_title(p->kwtext, L": ", p->words);
+		    indent = 0;
+		    break;
+		  case para_UnnumberedChapter:
+		    words = prepare_contents_title(NULL, NULL, p->words);
+		    indent = 0;
+		    break;
+		  case para_Heading:
+		  case para_Subsect:
+		    words = prepare_contents_title(p->kwtext2, L" ", p->words);
+		    indent = (p->aux + 1) * conf->contents_indent_step;
+		    break;
+		}
+		pdata = make_para_data(para_Normal, p->aux, indent,
+				       conf->contents_margin,
+				       NULL, NULL, words, conf);
+		pdata->next = NULL;
+		pdata->contents_entry = p;
+		lastcont->next = pdata;
+		lastcont = pdata;
+
+		/*
+		 * Link all contents line structures together into
+		 * a big list.
+		 */
+		if (pdata->first) {
+		    if (lastcontline) {
+			lastcontline->next = pdata->first;
+			pdata->first->prev = lastcontline;
+		    } else {
+			firstcontline = pdata->first;
+			pdata->first->prev = NULL;
+		    }
+		    lastcontline = pdata->last;
+		    lastcontline->next = NULL;
+		}
+
+		break;
+	    }
+	}
+
+	/*
+	 * And one extra one, for the index.
+	 */
+	if (has_index) {
+	    pdata = make_para_data(para_Normal, 0, 0,
+				   conf->contents_margin,
+				   NULL, NULL,
+				   fake_word(conf->index_text), conf);
+	    pdata->next = NULL;
+	    pdata->contents_entry = &index_placeholder_para;
+	    lastcont->next = pdata;
+	    lastcont = pdata;
+
+	    if (pdata->first) {
+		if (lastcontline) {
+		    lastcontline->next = pdata->first;
+		    pdata->first->prev = lastcontline;
+		} else {
+		    firstcontline = pdata->first;
+		    pdata->first->prev = NULL;
+		}
+		lastcontline = pdata->last;
+		lastcontline->next = NULL;
+	    }
+	}
+    }
+
+    /*
+     * Do the main paragraph formatting.
+     */
+    indent = 0;
+    used_contents = FALSE;
+    firstline = lastline = NULL;
+    for (p = sourceform; p; p = p->next) {
+	p->private_data = NULL;
+
+	switch (p->type) {
+	    /*
+	     * These paragraph types are either invisible or don't
+	     * define text in the normal sense. Either way, they
+	     * don't require wrapping.
+	     */
+	  case para_IM:
+	  case para_BR:
+	  case para_Biblio:
+	  case para_NotParaType:
+	  case para_Config:
+	  case para_VersionID:
+	  case para_NoCite:
+	    break;
+
+	    /*
+	     * These paragraph types don't require wrapping, but
+	     * they do affect the line width to which we wrap the
+	     * rest of the paragraphs, so we need to pay attention.
+	     */
+	  case para_LcontPush:
+	    indent += conf->indent_list; break;
+	  case para_LcontPop:
+	    indent -= conf->indent_list; assert(indent >= 0); break;
+	  case para_QuotePush:
+	    indent += conf->indent_quote; break;
+	  case para_QuotePop:
+	    indent -= conf->indent_quote; assert(indent >= 0); break;
+
+	    /*
+	     * This paragraph type is special. Process it
+	     * specially.
+	     */
+	  case para_Code:
+	    pdata = code_paragraph(indent, p->words, conf);
+	    p->private_data = pdata;
+	    if (pdata->first != pdata->last) {
+		pdata->first->penalty_after += 100000;
+		pdata->last->penalty_before += 100000;
+	    }
+	    break;
+
+	    /*
+	     * This paragraph is also special.
+	     */
+	  case para_Rule:
+	    pdata = rule_paragraph(indent, conf);
+	    p->private_data = pdata;
+	    break;
+
+	    /*
+	     * All of these paragraph types require wrapping in the
+	     * ordinary way. So we must supply a set of fonts, a
+	     * line width and auxiliary information (e.g. bullet
+	     * text) for each one.
+	     */
+	  case para_Chapter:
+	  case para_Appendix:
+	  case para_UnnumberedChapter:
+	  case para_Heading:
+	  case para_Subsect:
+	  case para_Normal:
+	  case para_BiblioCited:
+	  case para_Bullet:
+	  case para_NumberedList:
+	  case para_DescribedThing:
+	  case para_Description:
+	  case para_Copyright:
+	  case para_Title:
+	    pdata = make_para_data(p->type, p->aux, indent, 0,
+				   p->kwtext, p->kwtext2, p->words, conf);
+
+	    p->private_data = pdata;
+
+	    break;
+	}
+
+	if (p->private_data) {
+	    pdata = (para_data *)p->private_data;
+
+	    /*
+	     * If this is the first non-title heading, we link the
+	     * contents section in before it.
+	     */
+	    if (!used_contents && pdata->outline_level > 0) {
+		used_contents = TRUE;
+		if (lastpara)
+		    lastpara->next = firstcont;
+		else
+		    firstpara = firstcont;
+		lastpara = lastcont;
+		assert(lastpara->next == NULL);
+
+		if (lastline) {
+		    lastline->next = firstcontline;
+		    firstcontline->prev = lastline;
+		} else {
+		    firstline = firstcontline;
+		    firstcontline->prev = NULL;
+		}
+		assert(lastcontline != NULL);
+		lastline = lastcontline;
+		lastline->next = NULL;
+	    }
+
+	    /*
+	     * Link all line structures together into a big list.
+	     */
+	    if (pdata->first) {
+		if (lastline) {
+		    lastline->next = pdata->first;
+		    pdata->first->prev = lastline;
+		} else {
+		    firstline = pdata->first;
+		    pdata->first->prev = NULL;
+		}
+		lastline = pdata->last;
+		lastline->next = NULL;
+	    }
+
+	    /*
+	     * Link all paragraph structures together similarly.
+	     */
+	    pdata->next = NULL;
+	    if (lastpara)
+		lastpara->next = pdata;
+	    else
+		firstpara = pdata;
+	    lastpara = pdata;
+	}
+    }
+
+    /*
+     * Now we have an enormous linked list of every line of text in
+     * the document. Break it up into pages.
+     */
+    pages = page_breaks(firstline, lastline, conf->page_height, 0, 0);
+
+    /*
+     * Number the pages.
+     */
+    {
+	char buf[40];
+	page_data *page;
+
+	pagenum = 0;
+
+	for (page = pages; page; page = page->next) {
+	    sprintf(buf, "%d", ++pagenum);
+	    page->number = ufroma_dup(buf, CS_ASCII);
+	}
+
+	if (has_index) {
+	    first_index_page = snew(page_data);
+	    first_index_page->next = first_index_page->prev = NULL;
+	    first_index_page->first_line = NULL;
+	    first_index_page->last_line = NULL;
+	    first_index_page->first_text = first_index_page->last_text = NULL;
+	    first_index_page->first_xref = first_index_page->last_xref = NULL;
+	    first_index_page->first_rect = first_index_page->last_rect = NULL;
+
+	    /* And don't forget the as-yet-uncreated index. */
+	    sprintf(buf, "%d", ++pagenum);
+	    first_index_page->number = ufroma_dup(buf, CS_ASCII);
+	}
+    }
+
+    /*
+     * Now we're ready to actually lay out the pages. We do this by
+     * looping over _paragraphs_, since we may need to track cross-
+     * references between lines and even across pages.
+     */
+    for (pdata = firstpara; pdata; pdata = pdata->next)
+	render_para(pdata, conf, keywords, idx,
+		    &index_placeholder_para, first_index_page);
+
+    /*
+     * Now we've laid out the main body pages, we should have
+     * acquired a full set of page numbers for the index.
+     */
+    if (has_index) {
+	int i;
+	indexentry *entry;
+	word *index_title;
+	para_data *firstidx, *lastidx;
+	line_data *firstidxline, *lastidxline, *ldata;
+	page_data *ipages, *ipages2, *page;
+
+	/*
+	 * Create a set of paragraphs for the index.
+	 */
+	index_title = fake_word(conf->index_text);
+
+	firstidx = make_para_data(para_UnnumberedChapter, 0, 0, 0,
+				  NULL, NULL, index_title, conf);
+	lastidx = firstidx;
+	lastidx->next = NULL;
+	firstidxline = firstidx->first;
+	lastidxline = lastidx->last;
+	for (i = 0; (entry = index234(idx->entries, i)) != NULL; i++) {
+	    paper_idx *pi = (paper_idx *)entry->backend_data;
+	    para_data *text, *pages;
+
+	    if (!pi->words)
+		continue;
+
+	    text = make_para_data(para_Normal, 0, 0,
+				  conf->base_width - conf->index_colwidth,
+				  NULL, NULL, entry->text, conf);
+
+	    pages  = make_para_data(para_Normal, 0, 0,
+				    conf->base_width - conf->index_colwidth,
+				    NULL, NULL, pi->words, conf);
+
+	    text->justification = LEFT;
+	    pages->justification = RIGHT;
+	    text->last->space_after = pages->first->space_before =
+		conf->base_leading / 2;
+
+	    pages->last->space_after = text->first->space_before =
+		conf->base_leading;
+
+	    assert(text->first);
+	    assert(pages->first);
+	    assert(lastidxline);
+	    assert(lastidx);
+
+	    /*
+	     * If feasible, fold the two halves of the index entry
+	     * together.
+	     */
+	    if (text->last->real_shortfall + pages->first->real_shortfall >
+		conf->index_colwidth + conf->index_minsep) {
+		text->last->space_after = -1;
+		pages->first->space_before = -pages->first->line_height+1;
+	    }
+
+	    lastidx->next = text;
+	    text->next = pages;
+	    pages->next = NULL;
+	    lastidx = pages;
+
+	    /*
+	     * Link all index line structures together into
+	     * a big list.
+	     */
+	    text->last->next = pages->first;
+	    pages->first->prev = text->last;
+
+	    lastidxline->next = text->first;
+	    text->first->prev = lastidxline;
+
+	    lastidxline = pages->last;
+
+	    /*
+	     * Breaking an index entry anywhere is so bad that I
+	     * think I'm going to forbid it totally.
+	     */
+	    for (ldata = text->first; ldata && ldata->next;
+		 ldata = ldata->next) {
+		ldata->next->space_before += ldata->space_after + 1;
+		ldata->space_after = -1;
+	    }
+	}
+
+	/*
+	 * Now break the index into pages.
+	 */
+	ipages = page_breaks(firstidxline, firstidxline, conf->page_height,
+			      0, 0);
+	ipages2 = page_breaks(firstidxline->next, lastidxline,
+			     conf->page_height,
+			     conf->index_cols,
+			     firstidxline->space_before +
+			     firstidxline->line_height +
+			     firstidxline->space_after);
+
+	/*
+	 * This will have put each _column_ of the index on a
+	 * separate page, which isn't what we want. Fold the pages
+	 * back together.
+	 */
+	page = ipages2;
+	while (page) {
+	    int i;
+
+	    for (i = 1; i < conf->index_cols; i++)
+		if (page->next) {
+		    page_data *tpage;
+
+		    fold_into_page(page, page->next,
+				   i * (conf->index_colwidth +
+					conf->index_gutter));
+		    tpage = page->next;
+		    page->next = page->next->next;
+		    if (page->next)
+			page->next->prev = page;
+		    sfree(tpage);
+		}
+
+	    page = page->next;
+	}
+	/* Also fold the heading on to the same page as the index items. */
+	fold_into_page(ipages, ipages2, 0);
+	ipages->next = ipages2->next;
+	if (ipages->next)
+	    ipages->next->prev = ipages;
+	sfree(ipages2);
+	fold_into_page(first_index_page, ipages, 0);
+	first_index_page->next = ipages->next;
+	if (first_index_page->next)
+	    first_index_page->next->prev = first_index_page;
+	sfree(ipages);
+	ipages = first_index_page;
+
+	/*
+	 * Number the index pages, except the already-numbered
+	 * first one.
+	 */
+	for (page = ipages->next; page; page = page->next) {
+	    char buf[40];
+	    sprintf(buf, "%d", ++pagenum);
+	    page->number = ufroma_dup(buf, CS_ASCII);
+	}
+
+	/*
+	 * Render the index pages.
+	 */
+	for (pdata = firstidx; pdata; pdata = pdata->next)
+	    render_para(pdata, conf, keywords, idx,
+			&index_placeholder_para, first_index_page);
+
+	/*
+	 * Link the index page list on to the end of the main page
+	 * list.
+	 */
+	if (!pages)
+	    pages = ipages;
+	else {
+	    for (page = pages; page->next; page = page->next);
+	    page->next = ipages;
+	}
+
+	/*
+	 * Same with the paragraph list, which will cause the index
+	 * to be mentioned in the document outline.
+	 */
+	if (!firstpara)
+	    firstpara = firstidx;
+	else
+	    lastpara->next = firstidx;
+	lastpara = lastidx;
+    }
+
+    /*
+     * Draw the headers and footers.
+     * 
+     * FIXME: this should be fully configurable, but for the moment
+     * I'm just going to put in page numbers in the centre of a
+     * footer and leave it at that.
+     */
+    {
+	page_data *page;
+
+	for (page = pages; page; page = page->next) {
+	    int width;
+
+	    width = conf->pagenum_fontsize *
+		string_width(conf->fbase.fonts[FONT_NORMAL], page->number,
+			     NULL, 0);
+
+	    render_string(page, conf->fbase.fonts[FONT_NORMAL],
+			  conf->pagenum_fontsize,
+			  conf->left_margin + (conf->base_width - width)/2,
+			  conf->bottom_margin - conf->footer_distance,
+			  page->number, 0);
+	}
+    }
+
+    /*
+     * Start putting together the overall document structure we're
+     * going to return.
+     */
+    doc = snew(document);
+    doc->fonts = fontlist;
+    doc->pages = pages;
+    doc->paper_width = conf->paper_width;
+    doc->paper_height = conf->paper_height;
+
+    /*
+     * Collect the section heading paragraphs into a document
+     * outline. This is slightly fiddly because the Title paragraph
+     * isn't required to be at the start, although all the others
+     * must be in order.
+     */
+    {
+	int osize = 20;
+
+	doc->outline_elements = snewn(osize, outline_element);
+	doc->n_outline_elements = 0;
+
+	/* First find the title. */
+	for (pdata = firstpara; pdata; pdata = pdata->next) {
+	    if (pdata->outline_level == 0) {
+		doc->outline_elements[0].level = 0;
+		doc->outline_elements[0].pdata = pdata;
+		doc->n_outline_elements++;
+		break;
+	    }
+	}
+
+	/* Then collect the rest. */
+	for (pdata = firstpara; pdata; pdata = pdata->next) {
+	    if (pdata->outline_level > 0) {
+		if (doc->n_outline_elements >= osize) {
+		    osize += 20;
+		    doc->outline_elements =
+			sresize(doc->outline_elements, osize, outline_element);
+		}
+
+		doc->outline_elements[doc->n_outline_elements].level =
+		    pdata->outline_level;
+		doc->outline_elements[doc->n_outline_elements].pdata = pdata;
+		doc->n_outline_elements++;
+	    }
+	}
+    }
+
+    return doc;
+}
+
+static void setfont(para_data *p, font_cfg *f) {
+    int i;
+
+    for (i = 0; i < NFONTS; i++) {
+	p->fonts[i] = f->fonts[i];
+	p->sizes[i] = f->font_size;
+    }
+}
+
+static para_data *make_para_data(int ptype, int paux, int indent, int rmargin,
+				 word *pkwtext, word *pkwtext2, word *pwords,
+				 paper_conf *conf)
+{
+    para_data *pdata;
+    line_data *ldata;
+    int extra_indent, firstline_indent, aux_indent;
+    word *aux, *aux2;
+
+    pdata = snew(para_data);
+    pdata->outline_level = -1;
+    pdata->outline_title = NULL;
+    pdata->rect_type = RECT_NONE;
+    pdata->contents_entry = NULL;
+    pdata->justification = JUST;
+    pdata->extraflags = 0;
+
+    /*
+     * Choose fonts for this paragraph.
+     */
+    switch (ptype) {
+      case para_Title:
+	setfont(pdata, &conf->ftitle);
+	pdata->outline_level = 0;
+	break;
+
+      case para_Chapter:
+      case para_Appendix:
+      case para_UnnumberedChapter:
+	setfont(pdata, &conf->fchapter);
+	pdata->outline_level = 1;
+	break;
+
+      case para_Heading:
+      case para_Subsect:
+	setfont(pdata,
+		&conf->fsect[paux >= conf->nfsect ? conf->nfsect - 1 : paux]);
+	pdata->outline_level = 2 + paux;
+	break;
+
+      case para_Normal:
+      case para_BiblioCited:
+      case para_Bullet:
+      case para_NumberedList:
+      case para_DescribedThing:
+      case para_Description:
+      case para_Copyright:
+	setfont(pdata, &conf->fbase);
+	break;
+    }
+
+    /*
+     * Also select an indentation level depending on the
+     * paragraph type (list paragraphs other than
+     * para_DescribedThing need extra indent).
+     *
+     * (FIXME: Perhaps at some point we might even arrange
+     * for the user to be able to request indented first
+     * lines in paragraphs.)
+     */
+    if (ptype == para_Bullet ||
+	ptype == para_NumberedList ||
+	ptype == para_Description) {
+	extra_indent = firstline_indent = conf->indent_list;
+    } else {
+	extra_indent = firstline_indent = 0;
+    }
+
+    /*
+     * Find the auxiliary text for this paragraph.
+     */
+    aux = aux2 = NULL;
+    aux_indent = 0;
+
+    switch (ptype) {
+      case para_Chapter:
+      case para_Appendix:
+      case para_Heading:
+      case para_Subsect:
+	/*
+	 * For some heading styles (FIXME: be able to
+	 * configure which), the auxiliary text contains
+	 * the chapter number and is arranged to be
+	 * right-aligned a few points left of the primary
+	 * margin. For other styles, the auxiliary text is
+	 * the full chapter _name_ and takes up space
+	 * within the (wrapped) chapter title, meaning that
+	 * we must move the first line indent over to make
+	 * space for it.
+	 */
+	if (ptype == para_Heading || ptype == para_Subsect) {
+	    int len;
+
+	    aux = pkwtext2;
+	    len = paper_width_simple(pdata, pkwtext2, conf);
+	    aux_indent = -len - conf->sect_num_left_space;
+
+	    pdata->outline_title = 
+		prepare_outline_title(pkwtext2, L" ", pwords);
+	} else {
+	    aux = pkwtext;
+	    aux2 = fake_word(L": ");
+	    aux_indent = 0;
+
+	    firstline_indent += paper_width_simple(pdata, aux, conf);
+	    firstline_indent += paper_width_simple(pdata, aux2, conf);
+
+	    pdata->outline_title = 
+		prepare_outline_title(pkwtext, L": ", pwords);
+	}
+	break;
+
+      case para_Bullet:
+	/*
+	 * Auxiliary text consisting of a bullet.
+	 */
+	aux = fake_word(conf->bullet);
+	aux_indent = indent + conf->indent_list_bullet;
+	break;
+
+      case para_NumberedList:
+	/*
+	 * Auxiliary text consisting of the number followed
+	 * by a (FIXME: configurable) full stop.
+	 */
+	aux = pkwtext;
+	aux2 = fake_word(L".");
+	aux_indent = indent + conf->indent_list_bullet;
+	break;
+
+      case para_BiblioCited:
+	/*
+	 * Auxiliary text consisting of the bibliography
+	 * reference text, and a trailing space.
+	 */
+	aux = pkwtext;
+	aux2 = fake_word(L" ");
+	aux_indent = indent;
+	firstline_indent += paper_width_simple(pdata, aux, conf);
+	firstline_indent += paper_width_simple(pdata, aux2, conf);
+	break;
+    }
+
+    if (pdata->outline_level >= 0 && !pdata->outline_title) {
+	pdata->outline_title = 
+	    prepare_outline_title(NULL, NULL, pwords);
+    }
+
+    wrap_paragraph(pdata, pwords, conf->base_width - rmargin,
+		   indent + firstline_indent,
+		   indent + extra_indent, conf);
+
+    pdata->first->aux_text = aux;
+    pdata->first->aux_text_2 = aux2;
+    pdata->first->aux_left_indent = aux_indent;
+
+    /*
+     * Line breaking penalties.
+     */
+    switch (ptype) {
+      case para_Chapter:
+      case para_Appendix:
+      case para_Heading:
+      case para_Subsect:
+      case para_UnnumberedChapter:
+	/*
+	 * Fixed and large penalty for breaking straight
+	 * after a heading; corresponding bonus for
+	 * breaking straight before.
+	 */
+	pdata->first->penalty_before = -500000;
+	pdata->last->penalty_after = 500000;
+	for (ldata = pdata->first; ldata; ldata = ldata->next)
+	    ldata->penalty_after = 500000;
+	break;
+
+      case para_DescribedThing:
+	/*
+	 * This is treated a bit like a small heading:
+	 * there's a penalty for breaking after it (i.e.
+	 * between it and its description), and a bonus for
+	 * breaking before it (actually _between_ list
+	 * items).
+	 */
+	pdata->first->penalty_before = -200000;
+	pdata->last->penalty_after = 200000;
+	break;
+
+      default:
+	/*
+	 * Most paragraph types: widow/orphan control by
+	 * discouraging breaking one line from the end of
+	 * any paragraph.
+	 */
+	if (pdata->first != pdata->last) {
+	    pdata->first->penalty_after = 100000;
+	    pdata->last->penalty_before = 100000;
+	}
+	break;
+    }
+
+    standard_line_spacing(pdata, conf);
+
+    /*
+     * Some kinds of section heading require a page break before
+     * them and an underline after.
+     */
+    if (ptype == para_Title ||
+	ptype == para_Chapter ||
+	ptype == para_Appendix ||
+	ptype == para_UnnumberedChapter) {
+	pdata->first->page_break = TRUE;
+	pdata->first->space_before = conf->chapter_top_space;
+	pdata->last->space_after +=
+	    (conf->chapter_underline_depth +
+	     conf->chapter_underline_thickness);
+	pdata->rect_type = RECT_CHAPTER_UNDERLINE;
+    }
+
+    return pdata;
+}
+
+static void standard_line_spacing(para_data *pdata, paper_conf *conf)
+{
+    line_data *ldata;
+
+    /*
+     * Set the line spacing for each line in this paragraph.
+     */
+    for (ldata = pdata->first; ldata; ldata = ldata->next) {
+	if (ldata == pdata->first)
+	    ldata->space_before = conf->base_para_spacing / 2;
+	else
+	    ldata->space_before = conf->base_leading / 2;
+	if (ldata == pdata->last)
+	    ldata->space_after = conf->base_para_spacing / 2;
+	else
+	    ldata->space_after = conf->base_leading / 2;
+	ldata->page_break = FALSE;
+    }
+}
+
+static font_encoding *new_font_encoding(font_data *font)
+{
+    font_encoding *fe;
+    int i;
+
+    fe = snew(font_encoding);
+    fe->next = NULL;
+
+    if (font->list->tail)
+	font->list->tail->next = fe;
+    else
+	font->list->head = fe;
+    font->list->tail = fe;
+
+    fe->font = font;
+    fe->free_pos = 0x21;
+
+    for (i = 0; i < 256; i++) {
+	fe->vector[i] = NOGLYPH;
+	fe->to_unicode[i] = 0xFFFF;
+    }
+
+    return fe;
+}
+
+static subfont_map_entry *encode_glyph_at(glyph g, wchar_t u,
+					  font_encoding *fe, int pos)
+{
+    subfont_map_entry *sme = snew(subfont_map_entry);
+
+    sme->subfont = fe;
+    sme->position = pos;
+    fe->vector[pos] = g;
+    fe->to_unicode[pos] = u;
+    add234(fe->font->subfont_map, sme);
+    return sme;
+}
+
+static int new_sfmap_cmp(void *a, void *b)
+{
+    glyph ga = *(glyph *)a;
+    subfont_map_entry *sb = b;
+    glyph gb = sb->subfont->vector[sb->position];
+
+    if (ga < gb) return -1;
+    if (ga > gb) return 1;
+    return 0;
+}
+
+static subfont_map_entry *encode_glyph(glyph g, wchar_t u, font_data *font)
+{
+    subfont_map_entry *sme;
+    int c;
+
+    sme = find234(font->subfont_map, &g, new_sfmap_cmp);
+    if (sme) return sme;
+
+    /*
+     * This character is not yet in a subfont. Assign one.
+     */
+    if (font->latest_subfont->free_pos >= 0x100)
+	font->latest_subfont = new_font_encoding(font);
+
+    c = font->latest_subfont->free_pos++;
+    if (font->latest_subfont->free_pos == 0x7F)
+	font->latest_subfont->free_pos = 0xA1;
+
+    return encode_glyph_at(g, u, font->latest_subfont, c);
+}
+
+static int sfmap_cmp(void *a, void *b)
+{
+    subfont_map_entry *sa = a, *sb = b;
+    glyph ga = sa->subfont->vector[sa->position];
+    glyph gb = sb->subfont->vector[sb->position];
+
+    if (ga < gb) return -1;
+    if (ga > gb) return 1;
+    return 0;
+}
+
+int width_cmp(void *a, void *b)
+{
+    glyph_width const *wa = a, *wb = b;
+
+    if (wa->glyph < wb->glyph)
+	return -1;
+    if (wa->glyph > wb->glyph)
+	return 1;
+    return 0;
+}
+
+int kern_cmp(void *a, void *b)
+{
+    kern_pair const *ka = a, *kb = b;
+
+    if (ka->left < kb->left)
+	return -1;
+    if (ka->left > kb->left)
+	return 1;
+    if (ka->right < kb->right)
+	return -1;
+    if (ka->right > kb->right)
+	return 1;
+    return 0;
+}
+
+int lig_cmp(void *a, void *b)
+{
+    ligature const *la = a, *lb = b;
+
+    if (la->left < lb->left)
+	return -1;
+    if (la->left > lb->left)
+	return 1;
+    if (la->right < lb->right)
+	return -1;
+    if (la->right > lb->right)
+	return 1;
+    return 0;
+}
+
+static int utoglyph(font_info const *fi, wchar_t u) {
+    return (u < 0 || u > 0xFFFF ? NOGLYPH : fi->bmp[u]);
+}
+
+static font_data *make_std_font(font_list *fontlist, char const *name)
+{
+    font_info const *fi;
+    font_data *f;
+    font_encoding *fe;
+    int i;
+
+    for (fe = fontlist->head; fe; fe = fe->next)
+	if (strcmp(fe->font->info->name, name) == 0)
+	    return fe->font;
+
+    for (fi = all_fonts; fi; fi = fi->next)
+	if (strcmp(fi->name, name) == 0) break;
+    if (!fi) return NULL;
+
+    f = snew(font_data);
+
+    f->list = fontlist;
+    f->info = fi;
+    f->subfont_map = newtree234(sfmap_cmp);
+
+    /*
+     * Our first subfont will contain all of US-ASCII. This isn't
+     * really necessary - we could just create custom subfonts
+     * precisely as the whim of render_string dictated - but
+     * instinct suggests that it might be nice to have the text in
+     * the output files look _marginally_ recognisable.
+     */
+    fe = new_font_encoding(f);
+    fe->free_pos = 0xA1;	       /* only the top half is free */
+    f->latest_subfont = fe;
+
+    for (i = 0x20; i <= 0x7E; i++) {
+	glyph g = utoglyph(fi, i);
+	if (g != NOGLYPH)
+	    encode_glyph_at(g, i, fe, i);
+    }
+
+    return f;
+}
+
+/* NB: arguments are glyph numbers from font->bmp. */
+int find_width(font_data *font, glyph index)
+{
+    glyph_width wantw;
+    glyph_width const *w;
+
+    wantw.glyph = index;
+    w = find234(font->info->widths, &wantw, NULL);
+    if (!w) return 0;
+    return w->width;
+}
+
+static int find_kern(font_data *font, int lindex, int rindex)
+{
+    kern_pair wantkp;
+    kern_pair const *kp;
+
+    if (lindex == NOGLYPH || rindex == NOGLYPH)
+	return 0;
+    wantkp.left = lindex;
+    wantkp.right = rindex;
+    kp = find234(font->info->kerns, &wantkp, NULL);
+    if (kp == NULL)
+	return 0;
+    return kp->kern;
+}
+
+static int find_lig(font_data *font, int lindex, int rindex)
+{
+    ligature wantlig;
+    ligature const *lig;
+
+    if (lindex == NOGLYPH || rindex == NOGLYPH)
+	return NOGLYPH;
+    wantlig.left = lindex;
+    wantlig.right = rindex;
+    lig = find234(font->info->ligs, &wantlig, NULL);
+    if (lig == NULL)
+	return NOGLYPH;
+    return lig->lig;
+}
+
+static int string_width(font_data *font, wchar_t const *string, int *errs,
+			unsigned flags)
+{
+    int width = 0;
+    int nindex, index, oindex, lindex;
+
+    if (errs)
+	*errs = 0;
+
+    oindex = NOGLYPH;
+    index = utoglyph(font->info, *string);
+    for (; *string; string++) {
+	nindex = utoglyph(font->info, string[1]);
+
+	if (index == NOGLYPH) {
+	    if (errs)
+		*errs = 1;
+	} else {
+	    if (!(flags & RS_NOLIG) &&
+		(lindex = find_lig(font, index, nindex)) != NOGLYPH) {
+		index = lindex;
+		continue;
+	    }
+	    width += find_kern(font, oindex, index) + find_width(font, index);
+	}
+	oindex = index;
+	index = nindex;
+    }
+
+    return width;
+}
+
+static int paper_width_internal(void *vctx, word *word, int *nspaces);
+
+struct paper_width_ctx {
+    int minspacewidth;
+    para_data *pdata;
+    paper_conf *conf;
+};
+
+static int paper_width_list(void *vctx, word *text, word *end, int *nspaces) {
+    int w = 0;
+    while (text && text != end) {
+	w += paper_width_internal(vctx, text, nspaces);
+	text = text->next;
+    }
+    return w;
+}
+
+static int paper_width_internal(void *vctx, word *word, int *nspaces)
+{
+    struct paper_width_ctx *ctx = (struct paper_width_ctx *)vctx;
+    int style, type, findex, width, errs;
+    wchar_t *str;
+    unsigned flags = 0;
+
+    switch (word->type) {
+      case word_HyperLink:
+      case word_HyperEnd:
+      case word_UpperXref:
+      case word_LowerXref:
+      case word_PageXref:
+      case word_XrefEnd:
+      case word_IndexRef:
+	return 0;
+    }
+
+    style = towordstyle(word->type);
+    type = removeattr(word->type);
+
+    findex = (style == word_Normal ? FONT_NORMAL :
+	      style == word_Emph ? FONT_EMPH :
+	      FONT_CODE);
+
+    if (style == word_Code || style == word_WeakCode) flags |= RS_NOLIG;
+
+    if (type == word_Normal) {
+	str = word->text;
+    } else if (type == word_WhiteSpace) {
+	if (findex != FONT_CODE) {
+	    if (nspaces)
+		(*nspaces)++;
+	    return ctx->minspacewidth;
+	} else
+	    str = L" ";
+    } else /* if (type == word_Quote) */ {
+	if (word->aux == quote_Open)
+	    str = ctx->conf->lquote;
+	else
+	    str = ctx->conf->rquote;
+    }
+
+    width = string_width(ctx->pdata->fonts[findex], str, &errs, flags);
+
+    if (errs && word->alt)
+	return paper_width_list(vctx, word->alt, NULL, nspaces);
+    else
+	return ctx->pdata->sizes[findex] * width;
+}
+
+static int paper_width(void *vctx, word *word)
+{
+    return paper_width_internal(vctx, word, NULL);
+}
+
+static int paper_width_simple(para_data *pdata, word *text, paper_conf *conf)
+{
+    struct paper_width_ctx ctx;
+
+    ctx.pdata = pdata;
+    ctx.minspacewidth =
+	(pdata->sizes[FONT_NORMAL] *
+	 string_width(pdata->fonts[FONT_NORMAL], L" ", NULL, 0));
+    ctx.conf = conf;
+
+    return paper_width_list(&ctx, text, NULL, NULL);
+}
+
+static void wrap_paragraph(para_data *pdata, word *words,
+			   int w, int i1, int i2, paper_conf *conf)
+{
+    wrappedline *wrapping, *p;
+    int spacewidth;
+    struct paper_width_ctx ctx;
+    int line_height;
+
+    /*
+     * We're going to need to store the line height in every line
+     * structure we generate.
+     */
+    {
+	int i;
+	line_height = 0;
+	for (i = 0; i < NFONTS; i++)
+	    if (line_height < pdata->sizes[i])
+		line_height = pdata->sizes[i];
+	line_height *= UNITS_PER_PT;
+    }
+
+    spacewidth = (pdata->sizes[FONT_NORMAL] *
+		  string_width(pdata->fonts[FONT_NORMAL], L" ", NULL, 0));
+    if (spacewidth == 0) {
+	/*
+	 * A font without a space?! Disturbing. I hope this never
+	 * comes up, but I'll make a random guess anyway and set my
+	 * space width to half the point size.
+	 */
+	spacewidth = pdata->sizes[FONT_NORMAL] * UNITS_PER_PT / 2;
+    }
+
+    /*
+     * I'm going to set the _minimum_ space width to 3/5 of the
+     * standard one, and use the standard one as the optimum.
+     */
+    ctx.minspacewidth = spacewidth * 3 / 5;
+    ctx.pdata = pdata;
+    ctx.conf = conf;
+
+    wrapping = wrap_para(words, w - i1, w - i2, paper_width, &ctx, spacewidth);
+
+    /*
+     * Having done the wrapping, we now concoct a set of line_data
+     * structures.
+     */
+    pdata->first = pdata->last = NULL;
+
+    for (p = wrapping; p; p = p->next) {
+	line_data *ldata;
+	word *wd;
+	int len, wid, spaces;
+
+	ldata = snew(line_data);
+
+	ldata->pdata = pdata;
+	ldata->first = p->begin;
+	ldata->end = p->end;
+	ldata->line_height = line_height;
+
+	ldata->xpos = (p == wrapping ? i1 : i2);
+
+	if (pdata->last) {
+	    pdata->last->next = ldata;
+	    ldata->prev = pdata->last;
+	} else {
+	    pdata->first = ldata;
+	    ldata->prev = NULL;
+	}
+	ldata->next = NULL;
+	pdata->last = ldata;
+
+	spaces = 0;
+	len = paper_width_list(&ctx, ldata->first, ldata->end, &spaces);
+	wid = (p == wrapping ? w - i1 : w - i2);
+	wd = ldata->first;
+
+	ldata->hshortfall = wid - len;
+	ldata->nspaces = spaces;
+	/*
+	 * This tells us how much the space width needs to
+	 * change from _min_spacewidth. But we want to store
+	 * its difference from the _natural_ space width, to
+	 * make the text rendering easier.
+	 */
+	ldata->hshortfall += ctx.minspacewidth * spaces;
+	ldata->hshortfall -= spacewidth * spaces;
+	ldata->real_shortfall = ldata->hshortfall;
+	/*
+	 * Special case: on the last line of a paragraph, we
+	 * never stretch spaces.
+	 */
+	if (ldata->hshortfall > 0 && !p->next)
+	    ldata->hshortfall = 0;
+
+	ldata->aux_text = NULL;
+	ldata->aux_text_2 = NULL;
+	ldata->aux_left_indent = 0;
+	ldata->penalty_before = ldata->penalty_after = 0;
+    }
+
+}
+
+static page_data *page_breaks(line_data *first, line_data *last,
+			      int page_height, int ncols, int headspace)
+{
+    line_data *l, *m;
+    page_data *ph, *pt;
+    int n, n1, this_height;
+
+    /*
+     * Page breaking is done by a close analogue of the optimal
+     * paragraph wrapping algorithm used by wrap_para(). We work
+     * backwards from the end of the document line by line; for
+     * each line, we contemplate every possible number of lines we
+     * could put on a page starting with that line, determine a
+     * cost function for each one, add it to the pre-computed cost
+     * function for optimally page-breaking everything after that
+     * page, and pick the best option.
+     * 
+     * This is made slightly more complex by the fact that we have
+     * a multi-column index with a heading at the top of the
+     * _first_ page, meaning that the first _ncols_ pages must have
+     * a different length. Hence, we must do the wrapping ncols+1
+     * times over, hypothetically trying to put every subsequence
+     * on every possible page.
+     * 
+     * Since my line_data structures are only used for this
+     * purpose, I might as well just store the algorithm data
+     * directly in them.
+     */
+
+    for (l = last; l; l = l->prev) {
+	l->bestcost = snewn(ncols+1, int);
+	l->vshortfall = snewn(ncols+1, int);
+	l->text = snewn(ncols+1, int);
+	l->space = snewn(ncols+1, int);
+	l->page_last = snewn(ncols+1, line_data *);
+
+	for (n = 0; n <= ncols; n++) {
+	    int minheight, text = 0, space = 0;
+	    int cost;
+
+	    n1 = (n < ncols ? n+1 : ncols);
+	    if (n < ncols)
+		this_height = page_height - headspace;
+	    else
+		this_height = page_height;
+
+	    l->bestcost[n] = -1;
+	    for (m = l; m; m = m->next) {
+		if (m != l && m->page_break)
+		    break;	       /* we've gone as far as we can */
+
+		if (m != l) {
+		    if (m->prev->space_after > 0)
+			space += m->prev->space_after;
+		    else
+			text += m->prev->space_after;
+		}
+		if (m != l || m->page_break) {
+		    if (m->space_before > 0)
+			space += m->space_before;
+		    else
+			text += m->space_before;
+		}
+		text += m->line_height;
+		minheight = text + space;
+
+		if (m != l && minheight > this_height)
+		    break;
+
+		/*
+		 * If the space after this paragraph is _negative_
+		 * (which means the next line is folded on to this
+		 * one, which happens in the index), we absolutely
+		 * cannot break here.
+		 */
+		if (m->space_after >= 0) {
+
+		    /*
+		     * Compute the cost of this arrangement, as the
+		     * square of the amount of wasted space on the
+		     * page. Exception: if this is the last page
+		     * before a mandatory break or the document
+		     * end, we don't penalise a large blank area.
+		     */
+		    if (m != last && m->next && !m->next->page_break)
+		    {
+			int x = (this_height - minheight) / FUNITS_PER_PT *
+			    4096.0;
+			int xf;
+
+			xf = x & 0xFF;
+			x >>= 8;
+
+			cost = x*x;
+			cost += (x * xf) >> 8;
+		    } else
+			cost = 0;
+
+		    if (m != last && m->next && !m->next->page_break) {
+			cost += m->penalty_after;
+			cost += m->next->penalty_before;
+		    }
+
+		    if (m != last && m->next && !m->next->page_break)
+			cost += m->next->bestcost[n1];
+		    if (l->bestcost[n] == -1 || l->bestcost[n] > cost) {
+			/*
+			 * This is the best option yet for this
+			 * starting point.
+			 */
+			l->bestcost[n] = cost;
+			if (m != last && m->next && !m->next->page_break)
+			    l->vshortfall[n] = this_height - minheight;
+			else
+			    l->vshortfall[n] = 0;
+			l->text[n] = text;
+			l->space[n] = space;
+			l->page_last[n] = m;
+		    }
+		}
+
+		if (m == last)
+		    break;
+	    }
+	}
+    }
+
+    /*
+     * Now go through the line list forwards and assemble the
+     * actual pages.
+     */
+    ph = pt = NULL;
+
+    l = first;
+    n = 0;
+    while (l) {
+	page_data *page;
+	int text, space, head;
+
+	page = snew(page_data);
+	page->next = NULL;
+	page->prev = pt;
+	if (pt)
+	    pt->next = page;
+	else
+	    ph = page;
+	pt = page;
+
+	page->first_line = l;
+	page->last_line = l->page_last[n];
+
+	page->first_text = page->last_text = NULL;
+	page->first_xref = page->last_xref = NULL;
+	page->first_rect = page->last_rect = NULL;
+
+	/*
+	 * Now assign a y-coordinate to each line on the page.
+	 */
+	text = space = 0;
+	head = (n < ncols ? headspace : 0);
+	for (l = page->first_line; l; l = l->next) {
+	    if (l != page->first_line) {
+		if (l->prev->space_after > 0)
+		    space += l->prev->space_after;
+		else
+		    text += l->prev->space_after;
+	    }
+	    if (l != page->first_line || l->page_break) {
+		if (l->space_before > 0)
+		    space += l->space_before;
+		else
+		    text += l->space_before;
+	    }
+	    text += l->line_height;
+
+	    l->page = page;
+	    l->ypos = text + space + head;
+	    if (page->first_line->space[n]) {
+		l->ypos += space * (float)page->first_line->vshortfall[n] /
+		    page->first_line->space[n];
+	    }
+
+	    if (l == page->last_line)
+		break;
+	}
+
+	l = page->last_line;
+	if (l == last)
+	    break;
+	l = l->next;
+
+	n = (n < ncols ? n+1 : ncols);
+    }
+
+    return ph;
+}
+
+static void add_rect_to_page(page_data *page, int x, int y, int w, int h)
+{
+    rect *r = snew(rect);
+
+    r->next = NULL;
+    if (page->last_rect)
+	page->last_rect->next = r;
+    else
+	page->first_rect = r;
+    page->last_rect = r;
+
+    r->x = x;
+    r->y = y;
+    r->w = w;
+    r->h = h;
+}
+
+static void add_string_to_page(page_data *page, int x, int y,
+			       font_encoding *fe, int size, char *text,
+			       int width)
+{
+    text_fragment *frag;
+
+    frag = snew(text_fragment);
+    frag->next = NULL;
+
+    if (page->last_text)
+	page->last_text->next = frag;
+    else
+	page->first_text = frag;
+    page->last_text = frag;
+
+    frag->x = x;
+    frag->y = y;
+    frag->fe = fe;
+    frag->fontsize = size;
+    frag->text = dupstr(text);
+    frag->width = width;
+}
+
+/*
+ * Returns the updated x coordinate.
+ */
+static int render_string(page_data *page, font_data *font, int fontsize,
+			 int x, int y, wchar_t *str, unsigned flags)
+{
+    char *text;
+    int textpos, textwid, kern, nglyph, glyph, oglyph, lig;
+    font_encoding *subfont = NULL, *sf;
+    subfont_map_entry *sme;
+
+    text = snewn(1 + ustrlen(str), char);
+    textpos = textwid = 0;
+
+    glyph = NOGLYPH;
+    nglyph = utoglyph(font->info, *str);
+    while (*str) {
+	oglyph = glyph;
+	glyph = nglyph;
+	nglyph = utoglyph(font->info, str[1]);
+
+	if (glyph == NOGLYPH) {
+	    str++;
+	    continue;		       /* nothing more we can do here */
+	}
+
+	if (!(flags & RS_NOLIG) &&
+	    (lig = find_lig(font, glyph, nglyph)) != NOGLYPH) {
+	    nglyph = lig;
+	    str++;
+	    continue;
+	}
+
+	/*
+	 * Find which subfont this character is going in.
+	 */
+	sme = encode_glyph(glyph, *str, font);
+	sf = sme->subfont;
+
+	kern = find_kern(font, oglyph, glyph) * fontsize;
+
+	if (!subfont || sf != subfont || kern) {
+	    if (subfont) {
+		text[textpos] = '\0';
+		add_string_to_page(page, x, y, subfont, fontsize, text,
+				   textwid);
+		x += textwid + kern;
+	    } else {
+		assert(textpos == 0);
+	    }
+	    textpos = 0;
+	    textwid = 0;
+	    subfont = sf;
+	}
+
+	text[textpos++] = sme->position;
+	textwid += find_width(font, glyph) * fontsize;
+
+	str++;
+    }
+
+    if (textpos > 0) {
+	text[textpos] = '\0';
+	add_string_to_page(page, x, y, subfont, fontsize, text, textwid);
+	x += textwid;
+    }
+
+    return x;
+}
+
+/*
+ * Returns the updated x coordinate.
+ */
+static int render_text(page_data *page, para_data *pdata, line_data *ldata,
+		       int x, int y, word *text, word *text_end, xref **xr,
+		       int shortfall, int nspaces, int *nspace,
+		       keywordlist *keywords, indexdata *idx, paper_conf *conf)
+{
+    while (text && text != text_end) {
+	int style, type, findex, errs;
+	wchar_t *str;
+	xref_dest dest;
+	unsigned flags = 0;
+
+	switch (text->type) {
+	    /*
+	     * Start a cross-reference.
+	     */
+	  case word_HyperLink:
+	  case word_UpperXref:
+	  case word_LowerXref:
+	  case word_PageXref:
+
+	    if (text->type == word_HyperLink) {
+		dest.type = URL;
+		dest.url = utoa_dup(text->text, CS_ASCII);
+		dest.page = NULL;
+	    } else if (text->type == word_PageXref) {
+		dest.type = PAGE;
+		dest.url = NULL;
+		dest.page = (page_data *)text->private_data;
+	    } else {
+		keyword *kwl = kw_lookup(keywords, text->text);
+		para_data *pdata;
+
+		if (kwl) {
+		    assert(kwl->para->private_data);
+		    pdata = (para_data *) kwl->para->private_data;
+		    dest.type = PAGE;
+		    dest.page = pdata->first->page;
+		    dest.url = NULL;
+		} else {
+		    /*
+		     * Shouldn't happen, but *shrug*
+		     */
+		    dest.type = NONE;
+		    dest.page = NULL;
+		    dest.url = NULL;
+		}
+	    }
+	    if (dest.type != NONE) {
+		*xr = snew(xref);
+		(*xr)->dest = dest;    /* structure copy */
+		if (page->last_xref)
+		    page->last_xref->next = *xr;
+		else
+		    page->first_xref = *xr;
+		page->last_xref = *xr;
+		(*xr)->next = NULL;
+
+		/*
+		 * FIXME: Ideally we should have, and use, some
+		 * vertical font metric information here so that
+		 * our cross-ref rectangle can take account of
+		 * descenders and the font's cap height. This will
+		 * do for the moment, but it isn't ideal.
+		 */
+		(*xr)->lx = (*xr)->rx = x;
+		(*xr)->by = y;
+		(*xr)->ty = y + ldata->line_height;
+	    }
+	    goto nextword;
+	    
+	    /*
+	     * Finish extending a cross-reference box.
+	     */
+	  case word_HyperEnd:
+	  case word_XrefEnd:
+	    *xr = NULL;
+	    goto nextword;
+
+	    /*
+	     * Add the current page number to the list of pages
+	     * referenced by an index entry.
+	     */
+	  case word_IndexRef:
+	    /*
+	     * We don't create index references in contents entries.
+	     */
+	    if (!pdata->contents_entry) {
+		indextag *tag;
+		int i;
+
+		tag = index_findtag(idx, text->text);
+		if (!tag)
+		    goto nextword;
+
+		for (i = 0; i < tag->nrefs; i++) {
+		    indexentry *entry = tag->refs[i];
+		    paper_idx *pi = (paper_idx *)entry->backend_data;
+
+		    /*
+		     * If the same index term is indexed twice
+		     * within the same section, we only want to
+		     * mention it once in the index.
+		     */
+		    if (pi->lastpage != page) {
+			word **wp;
+
+			if (pi->lastword) {
+			    pi->lastword = pi->lastword->next =
+				fake_word(L",");
+			    pi->lastword = pi->lastword->next =
+				fake_space_word();
+			    wp = &pi->lastword->next;
+			} else
+			    wp = &pi->words;
+
+			pi->lastword = *wp =
+			    fake_page_ref(page);
+			pi->lastword = pi->lastword->next =
+			    fake_word(page->number);
+			pi->lastword = pi->lastword->next =
+			    fake_end_ref();
+		    }
+
+		    pi->lastpage = page;
+		}
+	    }
+	    goto nextword;
+	}
+
+	style = towordstyle(text->type);
+	type = removeattr(text->type);
+
+	findex = (style == word_Normal ? FONT_NORMAL :
+		  style == word_Emph ? FONT_EMPH :
+		  FONT_CODE);
+
+	if (style == word_Code || style == word_WeakCode) flags |= RS_NOLIG;
+	flags |= pdata->extraflags;
+
+	if (type == word_Normal) {
+	    str = text->text;
+	} else if (type == word_WhiteSpace) {
+	    x += pdata->sizes[findex] *
+		string_width(pdata->fonts[findex], L" ", NULL, 0);
+	    if (nspaces && findex != FONT_CODE) {
+		x += (*nspace+1) * shortfall / nspaces;
+		x -= *nspace * shortfall / nspaces;
+		(*nspace)++;
+	    }
+	    goto nextword;
+	} else /* if (type == word_Quote) */ {
+	    if (text->aux == quote_Open)
+		str = conf->lquote;
+	    else
+		str = conf->rquote;
+	}
+
+	(void) string_width(pdata->fonts[findex], str, &errs, flags);
+
+	if (errs && text->alt)
+	    x = render_text(page, pdata, ldata, x, y, text->alt, NULL,
+			    xr, shortfall, nspaces, nspace, keywords, idx,
+			    conf);
+	else
+	    x = render_string(page, pdata->fonts[findex],
+			      pdata->sizes[findex], x, y, str, flags);
+
+	if (*xr)
+	    (*xr)->rx = x;
+
+	nextword:
+	text = text->next;
+    }
+
+    return x;
+}
+
+/*
+ * Returns the last x position used on the line.
+ */
+static int render_line(line_data *ldata, int left_x, int top_y,
+		       xref_dest *dest, keywordlist *keywords, indexdata *idx,
+		       paper_conf *conf)
+{
+    int nspace;
+    xref *xr;
+    int ret = 0;
+    
+    if (ldata->aux_text) {
+	int x;
+	xr = NULL;
+	nspace = 0;
+	x = render_text(ldata->page, ldata->pdata, ldata,
+			left_x + ldata->aux_left_indent,
+			top_y - ldata->ypos,
+			ldata->aux_text, NULL, &xr, 0, 0, &nspace,
+			keywords, idx, conf);
+	if (ldata->aux_text_2)
+	    render_text(ldata->page, ldata->pdata, ldata,
+			x, top_y - ldata->ypos,
+			ldata->aux_text_2, NULL, &xr, 0, 0, &nspace,
+			keywords, idx, conf);
+    }
+    nspace = 0;
+
+    if (ldata->first) {
+	/*
+	 * There might be a cross-reference carried over from a
+	 * previous line.
+	 */
+	if (dest->type != NONE) {
+	    xr = snew(xref);
+	    xr->next = NULL;
+	    xr->dest = *dest;    /* structure copy */
+	    if (ldata->page->last_xref)
+		ldata->page->last_xref->next = xr;
+	    else
+		ldata->page->first_xref = xr;
+	    ldata->page->last_xref = xr;
+	    xr->lx = xr->rx = left_x + ldata->xpos;
+	    xr->by = top_y - ldata->ypos;
+	    xr->ty = top_y - ldata->ypos + ldata->line_height;
+	} else
+	    xr = NULL;
+
+	{
+	    int extra_indent, shortfall, spaces;
+	    int just = ldata->pdata->justification;
+
+	    /*
+	     * All forms of justification become JUST when we have
+	     * to squeeze the paragraph.
+	     */
+	    if (ldata->hshortfall < 0)
+		just = JUST;
+
+	    switch (just) {
+	      case JUST:
+		shortfall = ldata->hshortfall;
+		spaces = ldata->nspaces;
+		extra_indent = 0;
+		break;
+	      case LEFT:
+		shortfall = spaces = extra_indent = 0;
+		break;
+	      case RIGHT:
+		shortfall = spaces = 0;
+		extra_indent = ldata->real_shortfall;
+		break;
+	    }
+
+	    ret = render_text(ldata->page, ldata->pdata, ldata,
+			      left_x + ldata->xpos + extra_indent,
+			      top_y - ldata->ypos, ldata->first, ldata->end,
+			      &xr, shortfall, spaces, &nspace,
+			      keywords, idx, conf);
+	}
+
+	if (xr) {
+	    /*
+	     * There's a cross-reference continued on to the next line.
+	     */
+	    *dest = xr->dest;
+	} else
+	    dest->type = NONE;
+    }
+
+    return ret;
+}
+
+static void render_para(para_data *pdata, paper_conf *conf,
+			keywordlist *keywords, indexdata *idx,
+			paragraph *index_placeholder, page_data *index_page)
+{
+    int last_x;
+    xref *cxref;
+    page_data *cxref_page;
+    xref_dest dest;
+    para_data *target;
+    line_data *ldata;
+
+    dest.type = NONE;
+    cxref = NULL;
+    cxref_page = NULL;
+
+    for (ldata = pdata->first; ldata; ldata = ldata->next) {
+	/*
+	 * If this is a contents entry, we expect to have a single
+	 * enormous cross-reference rectangle covering the whole
+	 * thing. (Unless, of course, it spans multiple pages.)
+	 */
+	if (pdata->contents_entry && ldata->page != cxref_page) {
+	    cxref_page = ldata->page;
+	    cxref = snew(xref);
+	    cxref->next = NULL;
+	    cxref->dest.type = PAGE;
+	    if (pdata->contents_entry == index_placeholder) {
+		cxref->dest.page = index_page;
+	    } else {
+		assert(pdata->contents_entry->private_data);
+		target = (para_data *)pdata->contents_entry->private_data;
+		cxref->dest.page = target->first->page;
+	    }
+	    cxref->dest.url = NULL;
+	    if (ldata->page->last_xref)
+		ldata->page->last_xref->next = cxref;
+	    else
+		ldata->page->first_xref = cxref;
+	    ldata->page->last_xref = cxref;
+	    cxref->lx = conf->left_margin;
+	    cxref->rx = conf->paper_width - conf->right_margin;
+	    cxref->ty = conf->paper_height - conf->top_margin
+		- ldata->ypos + ldata->line_height;
+	}
+	if (pdata->contents_entry) {
+	    assert(cxref != NULL);
+	    cxref->by = conf->paper_height - conf->top_margin
+		- ldata->ypos;
+	}
+
+	last_x = render_line(ldata, conf->left_margin,
+			     conf->paper_height - conf->top_margin,
+			     &dest, keywords, idx, conf);
+	if (ldata == pdata->last)
+	    break;
+    }
+
+    /*
+     * If this is a contents entry, add leaders and a page
+     * number.
+     */
+    if (pdata->contents_entry) {
+	word *w;
+	wchar_t *num;
+	int wid;
+	int x;
+
+	if (pdata->contents_entry == index_placeholder) {
+	    num = index_page->number;
+	} else {
+	    assert(pdata->contents_entry->private_data);
+	    target = (para_data *)pdata->contents_entry->private_data;
+	    num = target->first->page->number;
+	}
+
+	w = fake_word(num);
+	wid = paper_width_simple(pdata, w, conf);
+	sfree(w);
+
+	for (x = 0; x < conf->base_width; x += conf->leader_separation)
+	    if (x - conf->leader_separation > last_x - conf->left_margin &&
+		x + conf->leader_separation < conf->base_width - wid)
+		render_string(pdata->last->page,
+			      pdata->fonts[FONT_NORMAL],
+			      pdata->sizes[FONT_NORMAL],
+			      conf->left_margin + x,
+			      (conf->paper_height - conf->top_margin -
+			       pdata->last->ypos), L".", 0);
+
+	render_string(pdata->last->page,
+		      pdata->fonts[FONT_NORMAL],
+		      pdata->sizes[FONT_NORMAL],
+		      conf->paper_width - conf->right_margin - wid,
+		      (conf->paper_height - conf->top_margin -
+		       pdata->last->ypos), num, 0);
+    }
+
+    /*
+     * Render any rectangle (chapter title underline or rule)
+     * that goes with this paragraph.
+     */
+    switch (pdata->rect_type) {
+      case RECT_CHAPTER_UNDERLINE:
+	add_rect_to_page(pdata->last->page,
+			 conf->left_margin,
+			 (conf->paper_height - conf->top_margin -
+			  pdata->last->ypos -
+			  conf->chapter_underline_depth),
+			 conf->base_width,
+			 conf->chapter_underline_thickness);
+	break;
+      case RECT_RULE:
+	add_rect_to_page(pdata->first->page,
+			 conf->left_margin + pdata->first->xpos,
+			 (conf->paper_height - conf->top_margin -
+			  pdata->last->ypos -
+			  pdata->last->line_height),
+			 conf->base_width - pdata->first->xpos,
+			 pdata->last->line_height);
+	break;
+      default:		       /* placate gcc */
+	break;
+    }
+}
+
+static para_data *code_paragraph(int indent, word *words, paper_conf *conf)
+{
+    para_data *pdata = snew(para_data);
+
+    /*
+     * For code paragraphs, I'm going to hack grievously and
+     * pretend the three normal fonts are the three code paragraph
+     * fonts.
+     */
+    setfont(pdata, &conf->fcode);
+
+    pdata->first = pdata->last = NULL;
+    pdata->outline_level = -1;
+    pdata->rect_type = RECT_NONE;
+    pdata->contents_entry = NULL;
+    pdata->justification = LEFT;
+    pdata->extraflags = RS_NOLIG;
+
+    for (; words; words = words->next) {
+	wchar_t *t, *e, *start;
+	word *lhead = NULL, *ltail = NULL, *w;
+	line_data *ldata;
+	int prev = -1, curr;
+
+	t = words->text;
+	if (words->next && words->next->type == word_Emph) {
+	    e = words->next->text;
+	    words = words->next;
+	} else
+	    e = NULL;
+
+	start = t;
+
+	while (*start) {
+	    while (*t) {
+		if (!e || !*e)
+		    curr = 0;
+		else if (*e == L'i')
+		    curr = 1;
+		else if (*e == L'b')
+		    curr = 2;
+		else
+		    curr = 0;
+
+		if (prev < 0)
+		    prev = curr;
+
+		if (curr != prev)
+		    break;
+
+		t++;
+		if (e && *e)
+		    e++;
+	    }
+
+	    /*
+	     * We've isolated a maximal subsequence of the line
+	     * which has the same emphasis. Form it into a word
+	     * structure.
+	     */
+	    w = snew(word);
+	    w->next = NULL;
+	    w->alt = NULL;
+	    w->type = (prev == 0 ? word_WeakCode :
+		      prev == 1 ? word_Emph : word_Normal);
+	    w->text = snewn(t-start+1, wchar_t);
+	    memcpy(w->text, start, (t-start) * sizeof(wchar_t));
+	    w->text[t-start] = '\0';
+	    w->breaks = FALSE;
+
+	    if (ltail)
+		ltail->next = w;
+	    else
+		lhead = w;
+	    ltail = w;
+
+	    start = t;
+	    prev = -1;
+	}
+
+	ldata = snew(line_data);
+
+	ldata->pdata = pdata;
+	ldata->first = lhead;
+	ldata->end = NULL;
+	ldata->line_height = conf->fcode.font_size * UNITS_PER_PT;
+
+	ldata->xpos = indent;
+
+	if (pdata->last) {
+	    pdata->last->next = ldata;
+	    ldata->prev = pdata->last;
+	} else {
+	    pdata->first = ldata;
+	    ldata->prev = NULL;
+	}
+	ldata->next = NULL;
+	pdata->last = ldata;
+
+	ldata->hshortfall = 0;
+	ldata->nspaces = 0;
+	ldata->aux_text = NULL;
+	ldata->aux_text_2 = NULL;
+	ldata->aux_left_indent = 0;
+	/* General opprobrium for breaking in a code paragraph. */
+	ldata->penalty_before = ldata->penalty_after = 50000;
+    }
+
+    standard_line_spacing(pdata, conf);
+
+    return pdata;
+}
+
+static para_data *rule_paragraph(int indent, paper_conf *conf)
+{
+    para_data *pdata = snew(para_data);
+    line_data *ldata;
+
+    ldata = snew(line_data);
+
+    ldata->pdata = pdata;
+    ldata->first = NULL;
+    ldata->end = NULL;
+    ldata->line_height = conf->rule_thickness;
+
+    ldata->xpos = indent;
+
+    ldata->prev = NULL;
+    ldata->next = NULL;
+
+    ldata->hshortfall = 0;
+    ldata->nspaces = 0;
+    ldata->aux_text = NULL;
+    ldata->aux_text_2 = NULL;
+    ldata->aux_left_indent = 0;
+
+    /*
+     * Better to break after a rule than before it
+     */
+    ldata->penalty_after += 100000;
+    ldata->penalty_before += -100000;
+
+    pdata->first = pdata->last = ldata;
+    pdata->outline_level = -1;
+    pdata->rect_type = RECT_RULE;
+    pdata->contents_entry = NULL;
+    pdata->justification = LEFT;
+    pdata->extraflags = 0;
+
+    standard_line_spacing(pdata, conf);
+
+    return pdata;
+}
+
+/*
+ * Plain-text-like formatting for outline titles.
+ */
+static void paper_rdaddw(rdstring *rs, word *text) {
+    for (; text; text = text->next) switch (text->type) {
+      case word_HyperLink:
+      case word_HyperEnd:
+      case word_UpperXref:
+      case word_LowerXref:
+      case word_XrefEnd:
+      case word_IndexRef:
+	break;
+
+      case word_Normal:
+      case word_Emph:
+      case word_Code:
+      case word_WeakCode:
+      case word_WhiteSpace:
+      case word_EmphSpace:
+      case word_CodeSpace:
+      case word_WkCodeSpace:
+      case word_Quote:
+      case word_EmphQuote:
+      case word_CodeQuote:
+      case word_WkCodeQuote:
+	assert(text->type != word_CodeQuote &&
+	       text->type != word_WkCodeQuote);
+	if (towordstyle(text->type) == word_Emph &&
+	    (attraux(text->aux) == attr_First ||
+	     attraux(text->aux) == attr_Only))
+	    rdadd(rs, L'_');	       /* FIXME: configurability */
+	else if (towordstyle(text->type) == word_Code &&
+		 (attraux(text->aux) == attr_First ||
+		  attraux(text->aux) == attr_Only))
+	    rdadd(rs, L'\'');	       /* FIXME: configurability */
+	if (removeattr(text->type) == word_Normal) {
+	    rdadds(rs, text->text);
+	} else if (removeattr(text->type) == word_WhiteSpace) {
+	    rdadd(rs, L' ');
+	} else if (removeattr(text->type) == word_Quote) {
+	    rdadd(rs, L'\'');	       /* fixme: configurability */
+	}
+	if (towordstyle(text->type) == word_Emph &&
+	    (attraux(text->aux) == attr_Last ||
+	     attraux(text->aux) == attr_Only))
+	    rdadd(rs, L'_');	       /* FIXME: configurability */
+	else if (towordstyle(text->type) == word_Code &&
+		 (attraux(text->aux) == attr_Last ||
+		  attraux(text->aux) == attr_Only))
+	    rdadd(rs, L'\'');	       /* FIXME: configurability */
+	break;
+    }
+}
+
+static wchar_t *prepare_outline_title(word *first, wchar_t *separator,
+				      word *second)
+{
+    rdstring rs = {0, 0, NULL};
+
+    if (first)
+	paper_rdaddw(&rs, first);
+    if (separator)
+	rdadds(&rs, separator);
+    if (second)
+	paper_rdaddw(&rs, second);
+
+    return rs.text;
+}
+
+static word *fake_word(wchar_t *text)
+{
+    word *ret = snew(word);
+    ret->next = NULL;
+    ret->alt = NULL;
+    ret->type = word_Normal;
+    ret->text = ustrdup(text);
+    ret->breaks = FALSE;
+    ret->aux = 0;
+    return ret;
+}
+
+static word *fake_space_word(void)
+{
+    word *ret = snew(word);
+    ret->next = NULL;
+    ret->alt = NULL;
+    ret->type = word_WhiteSpace;
+    ret->text = NULL;
+    ret->breaks = TRUE;
+    ret->aux = 0;
+    return ret;
+}
+
+static word *fake_page_ref(page_data *page)
+{
+    word *ret = snew(word);
+    ret->next = NULL;
+    ret->alt = NULL;
+    ret->type = word_PageXref;
+    ret->text = NULL;
+    ret->breaks = FALSE;
+    ret->aux = 0;
+    ret->private_data = page;
+    return ret;
+}
+
+static word *fake_end_ref(void)
+{
+    word *ret = snew(word);
+    ret->next = NULL;
+    ret->alt = NULL;
+    ret->type = word_XrefEnd;
+    ret->text = NULL;
+    ret->breaks = FALSE;
+    ret->aux = 0;
+    return ret;
+}
+
+static word *prepare_contents_title(word *first, wchar_t *separator,
+				    word *second)
+{
+    word *ret;
+    word **wptr, *w;
+
+    wptr = &ret;
+
+    if (first) {
+	w = dup_word_list(first);
+	*wptr = w;
+	while (w->next)
+	    w = w->next;
+	wptr = &w->next;
+    }
+
+    if (separator) {
+	w = fake_word(separator);
+	*wptr = w;
+	wptr = &w->next;
+    }
+
+    if (second) {
+	*wptr = dup_word_list(second);
+    }
+
+    return ret;
+}
+
+static void fold_into_page(page_data *dest, page_data *src, int right_shift)
+{
+    line_data *ldata;
+
+    if (!src->first_line)
+	return;
+
+    if (dest->last_line) {
+	dest->last_line->next = src->first_line;
+	src->first_line->prev = dest->last_line;
+    }
+    dest->last_line = src->last_line;
+
+    for (ldata = src->first_line; ldata; ldata = ldata->next) {
+	ldata->page = dest;
+	ldata->xpos += right_shift;
+
+	if (ldata == src->last_line)
+	    break;
+    }
+}