X-Git-Url: https://git.distorted.org.uk/~mdw/sgt/halibut/blobdiff_plain/a0768d17e6e539bef946fcabf45786bd9f7b8cb3..02478c4f78199bda48514bca58e4b912cb86c737:/bk_paper.c

diff --git a/bk_paper.c b/bk_paper.c
index 9ebbbdf..eb3caf0 100644
--- a/bk_paper.c
+++ b/bk_paper.c
@@ -10,39 +10,80 @@
  */
 
 /*
- * To be done:
- * 
- *  - set up contents section now we know what sections begin on
- *    which pages
- * 
- *  - index
- * 
- *  - header/footer? Page numbers at least would be handy. Fully
- *    configurable footer can wait, though.
- * 
- * That should bring us to the same level of functionality that
- * original-Halibut had, and the same in PDF plus the obvious
- * interactive navigation features. After that, in future work:
+ * TODO in future work:
  * 
  *  - linearised PDF, perhaps?
  * 
+ *  - we should use PDFDocEncoding or Unicode for outline strings,
+ *    now that I actually know how to do them. Probably easiest if
+ *    I do this _after_ bringing in libcharset, since I can simply
+ *    supply PDFDocEncoding in there.
+ * 
  *  - 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 import other Type 1 fonts
+ *     * we need to parse the font to extract its metrics
+ *     * then we pass the font bodily to both PS and PDF so it can
+ * 	 be included in the output file
+ * 
+ *  - character substitution for better typography?
+ *     * fi, fl, ffi, ffl ligatures
+ *     * 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 "halibut.h"
 #include "paper.h"
 
 typedef struct paper_conf_Tag paper_conf;
+typedef struct paper_idx_Tag paper_idx;
 
 struct paper_conf_Tag {
     int paper_width;
@@ -52,6 +93,7 @@ struct paper_conf_Tag {
     int right_margin;
     int bottom_margin;
     int indent_list_bullet;
+    int indent_list_after;
     int indent_list;
     int indent_quote;
     int base_leading;
@@ -65,23 +107,54 @@ struct paper_conf_Tag {
     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;
     /* These are derived from the above */
     int base_width;
     int page_height;
+    int index_colwidth;
     /* Fonts used in the configuration */
     font_data *tr, *ti, *hr, *hi, *cr, *co, *cb;
 };
 
+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
+};
+
 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);
+			   int w, int i1, int i2, paper_conf *conf);
 static page_data *page_breaks(line_data *first, line_data *last,
-			      int page_height);
+			      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);
 static int render_line(line_data *ldata, int left_x, int top_y,
-		       xref_dest *dest, keywordlist *keywords);
-static int paper_width_simple(para_data *pdata, word *text);
+		       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);
+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);
@@ -92,8 +165,223 @@ 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);
+	if (errs) {
+	    ret = FALSE;
+	    break;
+	}
+    }
+    va_end(ap);
+
+    return ret;
+}
+
+static paper_conf paper_configure(paragraph *source, font_list *fontlist) {
+    paragraph *p;
+    paper_conf ret;
+
+    /*
+     * Defaults.
+     */
+    ret.paper_width = 595 * 4096;
+    ret.paper_height = 841 * 4096;
+    ret.left_margin = 72 * 4096;
+    ret.top_margin = 72 * 4096;
+    ret.right_margin = 72 * 4096;
+    ret.bottom_margin = 108 * 4096;
+    ret.indent_list_bullet = 6 * 4096;
+    ret.indent_list_after = 18 * 4096;
+    ret.indent_quote = 18 * 4096;
+    ret.base_leading = 4096;
+    ret.base_para_spacing = 10 * 4096;
+    ret.chapter_top_space = 72 * 4096;
+    ret.sect_num_left_space = 12 * 4096;
+    ret.chapter_underline_depth = 14 * 4096;
+    ret.chapter_underline_thickness = 3 * 4096;
+    ret.rule_thickness = 1 * 4096;
+    ret.base_font_size = 12;
+    ret.contents_indent_step = 24 * 4096;
+    ret.contents_margin = 84 * 4096;
+    ret.leader_separation = 12 * 4096;
+    ret.index_gutter = 36 * 4096;
+    ret.index_cols = 2;
+    ret.index_minsep = 18 * 4096;
+    ret.pagenum_fontsize = 12;
+    ret.footer_distance = 32 * 4096;
+    ret.lquote = L"\x2018\0\x2019\0'\0'\0\0";
+    ret.rquote = uadv(ret.lquote);
+    ret.bullet = L"\x2022\0-\0\0";
+
+    /*
+     * 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"paper-bullet")) {
+		ret.bullet = uadv(p->keyword);
+	    } else if (!ustricmp(p->keyword, L"paper-page-width")) {
+		ret.paper_width =
+		    (int) 0.5 + 4096.0 * utof(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-page-height")) {
+		ret.paper_height =
+		    (int) 0.5 + 4096.0 * utof(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-left-margin")) {
+		ret.left_margin =
+		    (int) 0.5 + 4096.0 * utof(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-top-margin")) {
+		ret.top_margin =
+		    (int) 0.5 + 4096.0 * utof(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-right-margin")) {
+		ret.right_margin =
+		    (int) 0.5 + 4096.0 * utof(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-bottom-margin")) {
+		ret.bottom_margin =
+		    (int) 0.5 + 4096.0 * utof(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-list-indent")) {
+		ret.indent_list_bullet =
+		    (int) 0.5 + 4096.0 * utof(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-listitem-indent")) {
+		ret.indent_list =
+		    (int) 0.5 + 4096.0 * utof(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-quote-indent")) {
+		ret.indent_quote =
+		    (int) 0.5 + 4096.0 * utof(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-base-leading")) {
+		ret.base_leading =
+		    (int) 0.5 + 4096.0 * utof(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-base-para-spacing")) {
+		ret.base_para_spacing =
+		    (int) 0.5 + 4096.0 * utof(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-chapter-top-space")) {
+		ret.chapter_top_space =
+		    (int) 0.5 + 4096.0 * utof(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-sect-num-left-space")) {
+		ret.sect_num_left_space =
+		    (int) 0.5 + 4096.0 * utof(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-chapter-underline-depth")) {
+		ret.chapter_underline_depth =
+		    (int) 0.5 + 4096.0 * utof(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-chapter-underline-thickness")) {
+		ret.chapter_underline_thickness =
+		    (int) 0.5 + 4096.0 * utof(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-rule-thickness")) {
+		ret.rule_thickness =
+		    (int) 0.5 + 4096.0 * utof(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-contents-indent-step")) {
+		ret.contents_indent_step =
+		    (int) 0.5 + 4096.0 * utof(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-contents-margin")) {
+		ret.contents_margin =
+		    (int) 0.5 + 4096.0 * utof(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-leader-separation")) {
+		ret.leader_separation =
+		    (int) 0.5 + 4096.0 * utof(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-index-gutter")) {
+		ret.index_gutter =
+		    (int) 0.5 + 4096.0 * utof(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-index-minsep")) {
+		ret.index_minsep =
+		    (int) 0.5 + 4096.0 * utof(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-footer-distance")) {
+		ret.footer_distance =
+		    (int) 0.5 + 4096.0 * utof(uadv(p->keyword));
+	    } else if (!ustricmp(p->keyword, L"paper-base-font-size")) {
+		ret.base_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));
+	    }
+	}
+    }
+
+    /*
+     * 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;
+
+    /*
+     * Set up the font structures.
+     */
+    ret.tr = make_std_font(fontlist, "Times-Roman");
+    ret.ti = make_std_font(fontlist, "Times-Italic");
+    ret.hr = make_std_font(fontlist, "Helvetica-Bold");
+    ret.hi = make_std_font(fontlist, "Helvetica-BoldOblique");
+    ret.cr = make_std_font(fontlist, "Courier");
+    ret.co = make_std_font(fontlist, "Courier-Oblique");
+    ret.cb = make_std_font(fontlist, "Courier-Bold");
+
+    /*
+     * 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)) &&
+	   (!fonts_ok(ret.lquote, ret.tr, ret.ti, ret.hr, ret.hi, NULL) ||
+	    !fonts_ok(ret.rquote, ret.tr, ret.ti, ret.hr, ret.hi, NULL))) {
+	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.tr, NULL))
+	ret.bullet = uadv(ret.bullet);
+
+    return ret;
+}
 
 void *paper_pre_backend(paragraph *sourceform, keywordlist *keywords,
 			indexdata *idx) {
@@ -102,55 +390,42 @@ void *paper_pre_backend(paragraph *sourceform, keywordlist *keywords,
     int indent, used_contents;
     para_data *pdata, *firstpara = NULL, *lastpara = NULL;
     para_data *firstcont, *lastcont;
-    line_data *ldata, *firstline, *lastline, *firstcontline, *lastcontline;
+    line_data *firstline, *lastline, *firstcontline, *lastcontline;
     page_data *pages;
     font_list *fontlist;
-    paper_conf *conf;
+    paper_conf *conf, ourconf;
+    int has_index;
+    int pagenum;
+    paragraph index_placeholder_para;
+    page_data *first_index_page;
 
-    /*
-     * FIXME: All these things ought to become configurable.
-     */
-    conf = mknew(paper_conf);
-    conf->paper_width = 595 * 4096;
-    conf->paper_height = 841 * 4096;
-    conf->left_margin = 72 * 4096;
-    conf->top_margin = 72 * 4096;
-    conf->right_margin = 72 * 4096;
-    conf->bottom_margin = 108 * 4096;
-    conf->indent_list_bullet = 6 * 4096;
-    conf->indent_list = 24 * 4096;
-    conf->indent_quote = 18 * 4096;
-    conf->base_leading = 4096;
-    conf->base_para_spacing = 10 * 4096;
-    conf->chapter_top_space = 72 * 4096;
-    conf->sect_num_left_space = 12 * 4096;
-    conf->chapter_underline_depth = 14 * 4096;
-    conf->chapter_underline_thickness = 3 * 4096;
-    conf->rule_thickness = 1 * 4096;
-    conf->base_font_size = 12;
-    conf->contents_indent_step = 24 * 4096;
-    conf->contents_margin = 84 * 4096;
-    conf->leader_separation = 12 * 4096;
-
-    conf->base_width =
-	conf->paper_width - conf->left_margin - conf->right_margin;
-    conf->page_height =
-	conf->paper_height - conf->top_margin - conf->bottom_margin;
-
-    IGNORE(idx);		       /* FIXME */
+    fontlist = snew(font_list);
+    fontlist->head = fontlist->tail = NULL;
+
+    ourconf = paper_configure(sourceform, fontlist);
+    conf = &ourconf;
 
     /*
-     * First, set up some font structures.
+     * Set up a data structure to collect page numbers for each
+     * index entry.
      */
-    fontlist = mknew(font_list);
-    fontlist->head = fontlist->tail = NULL;
-    conf->tr = make_std_font(fontlist, "Times-Roman");
-    conf->ti = make_std_font(fontlist, "Times-Italic");
-    conf->hr = make_std_font(fontlist, "Helvetica-Bold");
-    conf->hi = make_std_font(fontlist, "Helvetica-BoldOblique");
-    conf->cr = make_std_font(fontlist, "Courier");
-    conf->co = make_std_font(fontlist, "Courier-Oblique");
-    conf->cb = make_std_font(fontlist, "Courier-Bold");
+    {
+	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.
@@ -218,6 +493,31 @@ void *paper_pre_backend(paragraph *sourceform, keywordlist *keywords,
 		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(L"Index"), 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;
+	    }
+	}
     }
 
     /*
@@ -365,18 +665,34 @@ void *paper_pre_backend(paragraph *sourceform, keywordlist *keywords,
      * 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);
+    pages = page_breaks(firstline, lastline, conf->page_height, 0, 0);
 
     /*
      * Number the pages.
      */
     {
+	char buf[40];
 	page_data *page;
-	int num = 0;
+
+	pagenum = 0;
+
 	for (page = pages; page; page = page->next) {
-	    char buf[40];
-	    sprintf(buf, "%d", ++num);
-	    page->number = ufroma_dup(buf);
+	    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);
 	}
     }
 
@@ -385,116 +701,208 @@ void *paper_pre_backend(paragraph *sourceform, keywordlist *keywords,
      * looping over _paragraphs_, since we may need to track cross-
      * references between lines and even across pages.
      */
-    for (pdata = firstpara; pdata; pdata = pdata->next) {
-	int last_x;
-	xref *cxref;
-	page_data *cxref_page;
-	xref_dest dest;
-	para_data *target;
+    for (pdata = firstpara; pdata; pdata = pdata->next)
+	render_para(pdata, conf, keywords, idx,
+		    &index_placeholder_para, first_index_page);
 
-	dest.type = NONE;
-	cxref = NULL;
-	cxref_page = NULL;
+    /*
+     * 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(L"Index");
+
+	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);
 
-	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 feasible, fold the two halves of the index entry
+	     * together.
 	     */
-	    if (pdata->contents_entry && ldata->page != cxref_page) {
-		cxref_page = ldata->page;
-		cxref = mknew(xref);
-		cxref->next = NULL;
-		cxref->dest.type = PAGE;
-		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 (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;
 	    }
-	    if (pdata->contents_entry) {
-		assert(cxref != NULL);
-		cxref->by = conf->paper_height - conf->top_margin
-		    - ldata->ypos;
+
+	    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;
 	    }
+	}
 
-	    last_x = render_line(ldata, conf->left_margin,
-				 conf->paper_height - conf->top_margin,
-				 &dest, keywords);
-	    if (ldata == pdata->last)
-		break;
+	/*
+	 * 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;
 
 	/*
-	 * If this is a contents entry, add leaders and a page
-	 * number.
+	 * Number the index pages, except the already-numbered
+	 * first one.
 	 */
-	if (pdata->contents_entry) {
-	    word *w;
-	    wchar_t *num;
-	    int wid;
-	    int x;
+	for (page = ipages->next; page; page = page->next) {
+	    char buf[40];
+	    sprintf(buf, "%d", ++pagenum);
+	    page->number = ufroma_dup(buf, CS_ASCII);
+	}
 
-	    assert(pdata->contents_entry->private_data);
-	    target = (para_data *)pdata->contents_entry->private_data;
-	    num = target->first->page->number;
+	/*
+	 * Render the index pages.
+	 */
+	for (pdata = firstidx; pdata; pdata = pdata->next)
+	    render_para(pdata, conf, keywords, idx,
+			&index_placeholder_para, first_index_page);
 
-	    w = fake_word(num);
-	    wid = paper_width_simple(pdata, w);
-	    sfree(w);
-
-	    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);
-
-	    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".");
+	/*
+	 * 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;
 	}
 
 	/*
-	 * Render any rectangle (chapter title underline or rule)
-	 * that goes with this paragraph.
+	 * Same with the paragraph list, which will cause the index
+	 * to be mentioned in the document outline.
 	 */
-	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;
+	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->tr, page->number, NULL);
+
+	    render_string(page, conf->tr, conf->pagenum_fontsize,
+			  conf->left_margin + (conf->base_width - width)/2,
+			  conf->bottom_margin - conf->footer_distance,
+			  page->number);
 	}
     }
 
@@ -502,7 +910,7 @@ void *paper_pre_backend(paragraph *sourceform, keywordlist *keywords,
      * Start putting together the overall document structure we're
      * going to return.
      */
-    doc = mknew(document);
+    doc = snew(document);
     doc->fonts = fontlist;
     doc->pages = pages;
     doc->paper_width = conf->paper_width;
@@ -517,7 +925,7 @@ void *paper_pre_backend(paragraph *sourceform, keywordlist *keywords,
     {
 	int osize = 20;
 
-	doc->outline_elements = mknewa(outline_element, osize);
+	doc->outline_elements = snewn(osize, outline_element);
 	doc->n_outline_elements = 0;
 
 	/* First find the title. */
@@ -536,7 +944,7 @@ void *paper_pre_backend(paragraph *sourceform, keywordlist *keywords,
 		if (doc->n_outline_elements >= osize) {
 		    osize += 20;
 		    doc->outline_elements =
-			resize(doc->outline_elements, osize);
+			sresize(doc->outline_elements, osize, outline_element);
 		}
 
 		doc->outline_elements[doc->n_outline_elements].level =
@@ -547,8 +955,6 @@ void *paper_pre_backend(paragraph *sourceform, keywordlist *keywords,
 	}
     }
 
-    sfree(conf);
-
     return doc;
 }
 
@@ -561,11 +967,12 @@ static para_data *make_para_data(int ptype, int paux, int indent, int rmargin,
     int extra_indent, firstline_indent, aux_indent;
     word *aux, *aux2;
 
-    pdata = mknew(para_data);
+    pdata = snew(para_data);
     pdata->outline_level = -1;
     pdata->outline_title = NULL;
     pdata->rect_type = RECT_NONE;
     pdata->contents_entry = NULL;
+    pdata->justification = JUST;
 
     /*
      * Choose fonts for this paragraph.
@@ -667,7 +1074,7 @@ static para_data *make_para_data(int ptype, int paux, int indent, int rmargin,
 	    int len;
 
 	    aux = pkwtext2;
-	    len = paper_width_simple(pdata, pkwtext2);
+	    len = paper_width_simple(pdata, pkwtext2, conf);
 	    aux_indent = -len - conf->sect_num_left_space;
 
 	    pdata->outline_title = 
@@ -677,8 +1084,8 @@ static para_data *make_para_data(int ptype, int paux, int indent, int rmargin,
 	    aux2 = fake_word(L": ");
 	    aux_indent = 0;
 
-	    firstline_indent += paper_width_simple(pdata, aux);
-	    firstline_indent += paper_width_simple(pdata, aux2);
+	    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);
@@ -687,10 +1094,9 @@ static para_data *make_para_data(int ptype, int paux, int indent, int rmargin,
 
       case para_Bullet:
 	/*
-	 * Auxiliary text consisting of a bullet. (FIXME:
-	 * configurable bullet.)
+	 * Auxiliary text consisting of a bullet.
 	 */
-	aux = fake_word(L"\x2022");
+	aux = fake_word(conf->bullet);
 	aux_indent = indent + conf->indent_list_bullet;
 	break;
 
@@ -712,8 +1118,8 @@ static para_data *make_para_data(int ptype, int paux, int indent, int rmargin,
 	aux = pkwtext;
 	aux2 = fake_word(L" ");
 	aux_indent = indent;
-	firstline_indent += paper_width_simple(pdata, aux);
-	firstline_indent += paper_width_simple(pdata, aux2);
+	firstline_indent += paper_width_simple(pdata, aux, conf);
+	firstline_indent += paper_width_simple(pdata, aux2, conf);
 	break;
     }
 
@@ -724,7 +1130,7 @@ static para_data *make_para_data(int ptype, int paux, int indent, int rmargin,
 
     wrap_paragraph(pdata, pwords, conf->base_width - rmargin,
 		   indent + firstline_indent,
-		   indent + extra_indent);
+		   indent + extra_indent, conf);
 
     pdata->first->aux_text = aux;
     pdata->first->aux_text_2 = aux2;
@@ -821,7 +1227,7 @@ static font_encoding *new_font_encoding(font_data *font)
     font_encoding *fe;
     int i;
 
-    fe = mknew(font_encoding);
+    fe = snew(font_encoding);
     fe->next = NULL;
 
     if (font->list->tail)
@@ -856,14 +1262,14 @@ static font_data *make_std_font(font_list *fontlist, char const *name)
 
     for (nglyphs = 0; ps_std_glyphs[nglyphs] != NULL; nglyphs++);
 
-    f = mknew(font_data);
+    f = snew(font_data);
 
     f->list = fontlist;
     f->name = name;
     f->nglyphs = nglyphs;
     f->glyphs = ps_std_glyphs;
     f->widths = widths;
-    f->subfont_map = mknewa(subfont_map_entry, nglyphs);
+    f->subfont_map = snewn(nglyphs, subfont_map_entry);
 
     /*
      * Our first subfont will contain all of US-ASCII. This isn't
@@ -912,7 +1318,9 @@ static int string_width(font_data *font, wchar_t const *string, int *errs)
     for (; *string; string++) {
 	int index;
 
-	index = font->bmp[(unsigned short)*string];
+	index = (*string < 0 || *string > 0xFFFF ? 0xFFFF :
+		 font->bmp[*string]);
+
 	if (index == 0xFFFF) {
 	    if (errs)
 		*errs = 1;
@@ -929,6 +1337,7 @@ 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) {
@@ -951,6 +1360,7 @@ static int paper_width_internal(void *vctx, word *word, int *nspaces)
       case word_HyperEnd:
       case word_UpperXref:
       case word_LowerXref:
+      case word_PageXref:
       case word_XrefEnd:
       case word_IndexRef:
 	return 0;
@@ -974,9 +1384,9 @@ static int paper_width_internal(void *vctx, word *word, int *nspaces)
 	    str = L" ";
     } else /* if (type == word_Quote) */ {
 	if (word->aux == quote_Open)
-	    str = L"\x2018";	       /* FIXME: configurability! */
+	    str = ctx->conf->lquote;
 	else
-	    str = L"\x2019";	       /* FIXME: configurability! */
+	    str = ctx->conf->rquote;
     }
 
     width = string_width(ctx->pdata->fonts[findex], str, &errs);
@@ -992,7 +1402,7 @@ 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)
+static int paper_width_simple(para_data *pdata, word *text, paper_conf *conf)
 {
     struct paper_width_ctx ctx;
 
@@ -1000,12 +1410,13 @@ static int paper_width_simple(para_data *pdata, word *text)
     ctx.minspacewidth =
 	(pdata->sizes[FONT_NORMAL] *
 	 string_width(pdata->fonts[FONT_NORMAL], L" ", NULL));
+    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)
+			   int w, int i1, int i2, paper_conf *conf)
 {
     wrappedline *wrapping, *p;
     int spacewidth;
@@ -1042,6 +1453,7 @@ static void wrap_paragraph(para_data *pdata, word *words,
      */
     ctx.minspacewidth = spacewidth * 3 / 5;
     ctx.pdata = pdata;
+    ctx.conf = conf;
 
     wrapping = wrap_para(words, w - i1, w - i2, paper_width, &ctx, spacewidth);
 
@@ -1056,7 +1468,7 @@ static void wrap_paragraph(para_data *pdata, word *words,
 	word *wd;
 	int len, wid, spaces;
 
-	ldata = mknew(line_data);
+	ldata = snew(line_data);
 
 	ldata->pdata = pdata;
 	ldata->first = p->begin;
@@ -1090,6 +1502,7 @@ static void wrap_paragraph(para_data *pdata, word *words,
 	 */
 	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.
@@ -1106,10 +1519,11 @@ static void wrap_paragraph(para_data *pdata, word *words,
 }
 
 static page_data *page_breaks(line_data *first, line_data *last,
-			      int page_height)
+			      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
@@ -1121,70 +1535,111 @@ static page_data *page_breaks(line_data *first, line_data *last,
      * 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) {
-	int minheight, text = 0, space = 0;
-	int cost;
-
-	l->bestcost = -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)
-		space += m->prev->space_after;
-	    if (m != l || m->page_break)
-		space += m->space_before;
-	    text += m->line_height;
-	    minheight = text + space;
-
-	    if (m != l && minheight > page_height)
-		break;
+	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;
 
-	    /*
-	     * 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->next && !m->next->page_break)
-	    {
-		int x = page_height - minheight;
-		int xf;
-
-		xf = x & 0xFF;
-		x >>= 8;
-
-		cost = x*x;
-		cost += (x * xf) >> 8;
-	    } else
-		cost = 0;
-
-	    if (m->next && !m->next->page_break) {
-		cost += m->penalty_after;
-		cost += m->next->penalty_before;
-	    }
+		if (m != l && minheight > this_height)
+		    break;
 
-	    if (m->next && !m->next->page_break)
-		cost += m->next->bestcost;
-	    if (l->bestcost == -1 || l->bestcost > cost) {
 		/*
-		 * This is the best option yet for this starting
-		 * point.
+		 * 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.
 		 */
-		l->bestcost = cost;
-		if (m->next && !m->next->page_break)
-		    l->vshortfall = page_height - minheight;
-		else
-		    l->vshortfall = 0;
-		l->text = text;
-		l->space = space;
-		l->page_last = m;
+		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;
+			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;
 	    }
 	}
     }
@@ -1196,11 +1651,12 @@ static page_data *page_breaks(line_data *first, line_data *last,
     ph = pt = NULL;
 
     l = first;
+    n = 0;
     while (l) {
 	page_data *page;
-	int text, space;
+	int text, space, head;
 
-	page = mknew(page_data);
+	page = snew(page_data);
 	page->next = NULL;
 	page->prev = pt;
 	if (pt)
@@ -1210,7 +1666,7 @@ static page_data *page_breaks(line_data *first, line_data *last,
 	pt = page;
 
 	page->first_line = l;
-	page->last_line = l->page_last;
+	page->last_line = l->page_last[n];
 
 	page->first_text = page->last_text = NULL;
 	page->first_xref = page->last_xref = NULL;
@@ -1220,23 +1676,39 @@ static page_data *page_breaks(line_data *first, line_data *last,
 	 * 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)
-		space += l->prev->space_after;
-	    if (l != page->first_line || l->page_break)
-		space += l->space_before;
+	    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 +
-		space * (float)page->first_line->vshortfall /
-		page->first_line->space;
+	    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->next;
+	l = page->last_line;
+	if (l == last)
+	    break;
+	l = l->next;
+
+	n = (n < ncols ? n+1 : ncols);
     }
 
     return ph;
@@ -1244,7 +1716,7 @@ static page_data *page_breaks(line_data *first, line_data *last,
 
 static void add_rect_to_page(page_data *page, int x, int y, int w, int h)
 {
-    rect *r = mknew(rect);
+    rect *r = snew(rect);
 
     r->next = NULL;
     if (page->last_rect)
@@ -1260,11 +1732,12 @@ static void add_rect_to_page(page_data *page, int x, int y, int w, int h)
 }
 
 static void add_string_to_page(page_data *page, int x, int y,
-			       font_encoding *fe, int size, char *text)
+			       font_encoding *fe, int size, char *text,
+			       int width)
 {
     text_fragment *frag;
 
-    frag = mknew(text_fragment);
+    frag = snew(text_fragment);
     frag->next = NULL;
 
     if (page->last_text)
@@ -1278,6 +1751,7 @@ static void add_string_to_page(page_data *page, int x, int y,
     frag->fe = fe;
     frag->fontsize = size;
     frag->text = dupstr(text);
+    frag->width = width;
 }
 
 /*
@@ -1290,14 +1764,17 @@ static int render_string(page_data *page, font_data *font, int fontsize,
     int textpos, textwid, glyph;
     font_encoding *subfont = NULL, *sf;
 
-    text = mknewa(char, 1 + ustrlen(str));
+    text = snewn(1 + ustrlen(str), char);
     textpos = textwid = 0;
 
     while (*str) {
-	glyph = font->bmp[*str];
+	glyph = (*str < 0 || *str > 0xFFFF ? 0xFFFF :
+		 font->bmp[*str]);
 
-	if (glyph == 0xFFFF)
+	if (glyph == 0xFFFF) {
+	    str++;
 	    continue;		       /* nothing more we can do here */
+	}
 
 	/*
 	 * Find which subfont this character is going in.
@@ -1329,7 +1806,8 @@ static int render_string(page_data *page, font_data *font, int fontsize,
 	if (!subfont || sf != subfont) {
 	    if (subfont) {
 		text[textpos] = '\0';
-		add_string_to_page(page, x, y, subfont, fontsize, text);
+		add_string_to_page(page, x, y, subfont, fontsize, text,
+				   textwid);
 		x += textwid;
 	    } else {
 		assert(textpos == 0);
@@ -1346,7 +1824,7 @@ static int render_string(page_data *page, font_data *font, int fontsize,
 
     if (textpos > 0) {
 	text[textpos] = '\0';
-	add_string_to_page(page, x, y, subfont, fontsize, text);
+	add_string_to_page(page, x, y, subfont, fontsize, text, textwid);
 	x += textwid;
     }
 
@@ -1359,7 +1837,7 @@ static int render_string(page_data *page, font_data *font, int fontsize,
 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)
+		       keywordlist *keywords, indexdata *idx, paper_conf *conf)
 {
     while (text && text != text_end) {
 	int style, type, findex, errs;
@@ -1373,11 +1851,16 @@ static int render_text(page_data *page, para_data *pdata, line_data *ldata,
 	  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);
+		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;
@@ -1398,7 +1881,7 @@ static int render_text(page_data *page, para_data *pdata, line_data *ldata,
 		}
 	    }
 	    if (dest.type != NONE) {
-		*xr = mknew(xref);
+		*xr = snew(xref);
 		(*xr)->dest = dest;    /* structure copy */
 		if (page->last_xref)
 		    page->last_xref->next = *xr;
@@ -1428,11 +1911,55 @@ static int render_text(page_data *page, para_data *pdata, line_data *ldata,
 	    *xr = NULL;
 	    goto nextword;
 
+	    /*
+	     * Add the current page number to the list of pages
+	     * referenced by an index entry.
+	     */
 	  case word_IndexRef:
-	    goto nextword;
 	    /*
-	     * FIXME: we should do something with this.
+	     * 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);
@@ -1455,16 +1982,17 @@ static int render_text(page_data *page, para_data *pdata, line_data *ldata,
 	    goto nextword;
 	} else /* if (type == word_Quote) */ {
 	    if (text->aux == quote_Open)
-		str = L"\x2018";	       /* FIXME: configurability! */
+		str = conf->lquote;
 	    else
-		str = L"\x2019";	       /* FIXME: configurability! */
+		str = conf->rquote;
 	}
 
 	(void) string_width(pdata->fonts[findex], str, &errs);
 
 	if (errs && text->alt)
 	    x = render_text(page, pdata, ldata, x, y, text->alt, NULL,
-			    xr, shortfall, nspaces, nspace, keywords);
+			    xr, shortfall, nspaces, nspace, keywords, idx,
+			    conf);
 	else
 	    x = render_string(page, pdata->fonts[findex],
 			      pdata->sizes[findex], x, y, str);
@@ -1483,7 +2011,8 @@ static int render_text(page_data *page, para_data *pdata, line_data *ldata,
  * 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)
+		       xref_dest *dest, keywordlist *keywords, indexdata *idx,
+		       paper_conf *conf)
 {
     int nspace;
     xref *xr;
@@ -1496,11 +2025,13 @@ static int render_line(line_data *ldata, int left_x, int top_y,
 	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);
+			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);
+			ldata->aux_text_2, NULL, &xr, 0, 0, &nspace,
+			keywords, idx, conf);
     }
     nspace = 0;
 
@@ -1510,7 +2041,7 @@ static int render_line(line_data *ldata, int left_x, int top_y,
 	 * previous line.
 	 */
 	if (dest->type != NONE) {
-	    xr = mknew(xref);
+	    xr = snew(xref);
 	    xr->next = NULL;
 	    xr->dest = *dest;    /* structure copy */
 	    if (ldata->page->last_xref)
@@ -1524,11 +2055,38 @@ static int render_line(line_data *ldata, int left_x, int top_y,
 	} else
 	    xr = NULL;
 
-	ret = render_text(ldata->page, ldata->pdata, ldata,
-			  left_x + ldata->xpos,
-			  top_y - ldata->ypos, ldata->first, ldata->end, &xr,
-			  ldata->hshortfall, ldata->nspaces, &nspace,
-			  keywords);
+	{
+	    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) {
 	    /*
@@ -1542,9 +2100,134 @@ static int render_line(line_data *ldata, int left_x, int top_y,
     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".");
+
+	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);
+    }
+
+    /*
+     * 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 = mknew(para_data);
+    para_data *pdata = snew(para_data);
 
     /*
      * For code paragraphs, I'm going to hack grievously and
@@ -1553,7 +2236,7 @@ static para_data *code_paragraph(int indent, word *words, paper_conf *conf)
      */
     pdata->fonts[FONT_NORMAL] = conf->cb;
     pdata->fonts[FONT_EMPH] = conf->co;
-    pdata->fonts[FONT_CODE] = conf->cb;
+    pdata->fonts[FONT_CODE] = conf->cr;
     pdata->sizes[FONT_NORMAL] =
 	pdata->sizes[FONT_EMPH] =
 	pdata->sizes[FONT_CODE] = 12;
@@ -1562,6 +2245,7 @@ static para_data *code_paragraph(int indent, word *words, paper_conf *conf)
     pdata->outline_level = -1;
     pdata->rect_type = RECT_NONE;
     pdata->contents_entry = NULL;
+    pdata->justification = LEFT;
 
     for (; words; words = words->next) {
 	wchar_t *t, *e, *start;
@@ -1605,12 +2289,12 @@ static para_data *code_paragraph(int indent, word *words, paper_conf *conf)
 	     * which has the same emphasis. Form it into a word
 	     * structure.
 	     */
-	    w = mknew(word);
+	    w = snew(word);
 	    w->next = NULL;
 	    w->alt = NULL;
 	    w->type = (prev == 0 ? word_WeakCode :
 		      prev == 1 ? word_Emph : word_Normal);
-	    w->text = mknewa(wchar_t, t-start+1);
+	    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;
@@ -1625,7 +2309,7 @@ static para_data *code_paragraph(int indent, word *words, paper_conf *conf)
 	    prev = -1;
 	}
 
-	ldata = mknew(line_data);
+	ldata = snew(line_data);
 
 	ldata->pdata = pdata;
 	ldata->first = lhead;
@@ -1660,10 +2344,10 @@ static para_data *code_paragraph(int indent, word *words, paper_conf *conf)
 
 static para_data *rule_paragraph(int indent, paper_conf *conf)
 {
-    para_data *pdata = mknew(para_data);
+    para_data *pdata = snew(para_data);
     line_data *ldata;
 
-    ldata = mknew(line_data);
+    ldata = snew(line_data);
 
     ldata->pdata = pdata;
     ldata->first = NULL;
@@ -1691,6 +2375,7 @@ static para_data *rule_paragraph(int indent, paper_conf *conf)
     pdata->outline_level = -1;
     pdata->rect_type = RECT_RULE;
     pdata->contents_entry = NULL;
+    pdata->justification = LEFT;
 
     standard_line_spacing(pdata, conf);
 
@@ -1768,7 +2453,7 @@ static wchar_t *prepare_outline_title(word *first, wchar_t *separator,
 
 static word *fake_word(wchar_t *text)
 {
-    word *ret = mknew(word);
+    word *ret = snew(word);
     ret->next = NULL;
     ret->alt = NULL;
     ret->type = word_Normal;
@@ -1778,6 +2463,43 @@ static word *fake_word(wchar_t *text)
     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)
 {
@@ -1806,3 +2528,25 @@ static word *prepare_contents_title(word *first, wchar_t *separator,
 
     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;
+    }
+}