\n"); } /* Write out the index file */ static void xhtml_do_index_body(FILE *fp) { indexentry *y; int ti; if (count234(idx->entries) == 0) return; /* don't write anything at all */ fprintf(fp, "

"); xhtml_para(fp, y->text, FALSE); fprintf(fp, ": "); xi = (xhtmlindex*) y->backend_data; for (i=0; insection; i++) { xhtmlsection *sect = xi->sections[i]; if (sect) { fprintf(fp, "", sect->file->filename, sect->fragment); if (sect->para->kwtext) { xhtml_para(fp, sect->para->kwtext, FALSE); } else if (sect->para->words) { xhtml_para(fp, sect->para->words, FALSE); } fprintf(fp, ""); if (i+1nsection) { fprintf(fp, ", "); } } } fprintf(fp, "

\n"); } static void xhtml_do_index() { word temp_word = { NULL, NULL, word_Normal, 0, 0, L"Index", { NULL, 0, 0} }; FILE *fp = fopen(conf.index_filename, "w"); if (fp==NULL) fatal(err_cantopenw, conf.index_filename); xhtml_doheader(fp, &temp_word); xhtml_donavlinks(fp, NULL); xhtml_do_index_body(fp); xhtml_donavlinks(fp, NULL); xhtml_dofooter(fp); fclose(fp); } /* Output the given file. This includes whatever contents at beginning and end, etc. etc. */ static void xhtml_do_file(xhtmlfile *file) { FILE *fp = fopen(file->filename, "w"); if (fp==NULL) fatal(err_cantopenw, file->filename); if (file->sections->para->words) { xhtml_doheader(fp, file->sections->para->words); } else if (file->sections->para->kwtext) { xhtml_doheader(fp, file->sections->para->kwtext); } else { xhtml_doheader(fp, NULL); } xhtml_donavlinks(fp, file); if (file->is_leaf && conf.leaf_contains_contents && xhtml_do_contents(NULL, file)>=conf.leaf_smallest_contents) xhtml_do_contents(fp, file); xhtml_do_sections(fp, file->sections); if (!file->is_leaf) xhtml_do_naked_contents(fp, file); xhtml_donavlinks(fp, file); xhtml_dofooter(fp); fclose(fp); xhtml_last_file = file; } /* Output the top-level file. */ static void xhtml_do_top_file(xhtmlfile *file, paragraph *sourceform) { paragraph *p; int done=FALSE; FILE *fp = fopen(file->filename, "w"); if (fp==NULL) fatal(err_cantopenw, file->filename); /* Do the title -- only one allowed */ for (p = sourceform; p && !done; p = p->next) { if (p->type == para_Title) { xhtml_doheader(fp, p->words); done=TRUE; } } if (!done) xhtml_doheader(fp, NULL /* Eek! */); /* * Display the title. */ for (p = sourceform; p; p = p->next) { if (p->type == para_Title) { xhtml_heading(fp, p, FALSE); break; } } /* Do the preamble */ for (p = sourceform; p; p = p->next) { if (p->type == para_Chapter || p->type == para_Heading || p->type == para_Subsect || p->type == para_Appendix || p->type == para_UnnumberedChapter) { /* * We've found the end of the preamble. Do every normal * paragraph up to there. */ xhtml_do_paras(fp, sourceform, p, FALSE); break; } } xhtml_do_contents(fp, file); xhtml_do_sections(fp, file->sections); /* * Put the index in the top file if we're in single-file mode * (leaf-level 0). */ if (conf.leaf_level == 0 && count234(idx->entries) > 0) { fprintf(fp, "

Index

\n"); xhtml_do_index_body(fp); } xhtml_dofooter(fp); fclose(fp); } /* Convert a Unicode string to an ASCII one. '?' is * used for unmappable characters. */ static void xhtml_utostr(wchar_t *in, char **out) { int l = ustrlen(in); int i; *out = smalloc(l+1); for (i=0; i=32 && in[i]<=126) (*out)[i]=(char)in[i]; else (*out)[i]='?'; } (*out)[i]=0; } /* * Write contents for the given file, and subfiles, down to * the appropriate contents depth. Returns the number of * entries written. */ static int xhtml_do_contents(FILE *fp, xhtmlfile *file) { int level, limit, count = 0; if (!file) return 0; level = (file->sections)?(file->sections->level):(0); limit = conf.contents_depth[(level>5)?(5):(level)]; start_level = (file->is_leaf) ? (level-1) : (level); last_level = start_level; count += xhtml_do_contents_section_limit(fp, file->sections, limit); count += xhtml_do_contents_limit(fp, file->child, limit); if (fp!=NULL) { while (last_level > start_level) { last_level--; fprintf(fp, "\n"); } } return count; } /* As above, but doesn't do anything in the current file */ static int xhtml_do_naked_contents(FILE *fp, xhtmlfile *file) { int level, limit, start_level, count = 0; if (!file) return 0; level = (file->sections)?(file->sections->level):(0); limit = conf.contents_depth[(level>5)?(5):(level)]; start_level = (file->is_leaf) ? (level-1) : (level); last_level = start_level; count = xhtml_do_contents_limit(fp, file->child, limit); if (fp!=NULL) { while (last_level > start_level) { last_level--; fprintf(fp, "\n"); } } return count; } /* * Write contents for the given file, children, and siblings, down to * given limit contents depth. */ static int xhtml_do_contents_limit(FILE *fp, xhtmlfile *file, int limit) { int count = 0; while (file) { count += xhtml_do_contents_section_limit(fp, file->sections, limit); count += xhtml_do_contents_limit(fp, file->child, limit); file = file->next; } return count; } /* * Write contents entries for the given section tree, down to the * limit contents depth. */ static int xhtml_do_contents_section_deep_limit(FILE *fp, xhtmlsection *section, int limit) { int count = 0; while (section) { if (!xhtml_add_contents_entry(fp, section, limit)) return 0; else count++; count += xhtml_do_contents_section_deep_limit(fp, section->child, limit); section = section->next; } return count; } /* * Write contents entries for the given section tree, down to the * limit contents depth. */ static int xhtml_do_contents_section_limit(FILE *fp, xhtmlsection *section, int limit) { int count = 0; if (!section) return 0; xhtml_add_contents_entry(fp, section, limit); count=1; count += xhtml_do_contents_section_deep_limit(fp, section->child, limit); /* section=section->child; while (section && xhtml_add_contents_entry(fp, section, limit)) { section = section->next; }*/ return count; } /* * Add a section entry, unless we're exceeding the limit, in which * case return FALSE (otherwise return TRUE). */ static int xhtml_add_contents_entry(FILE *fp, xhtmlsection *section, int limit) { if (!section || section->level > limit) return FALSE; if (fp==NULL || section->level < 0) return TRUE; if (last_level > section->level) { while (last_level > section->level) { last_level--; fprintf(fp, "\n"); } fprintf(fp, "\n"); } else if (last_level < section->level) { assert(last_level == section->level - 1); last_level++; fprintf(fp, "

", section->file->filename, section->fragment); if (section->para->kwtext) { xhtml_para(fp, section->para->kwtext, FALSE); if (section->para->words) { fprintf(fp, ": "); } } if (section->para->words) { xhtml_para(fp, section->para->words, FALSE); } fprintf(fp, "\n"); return TRUE; } /* * Write all the sections in this file. Do all paragraphs in this section, then all * children (recursively), then go on to the next one (tail recursively). */ static void xhtml_do_sections(FILE *fp, xhtmlsection *sections) { while (sections) { currentsection = sections; xhtml_do_paras(fp, sections->para, NULL, TRUE); xhtml_do_sections(fp, sections->child); sections = sections->next; } } /* Write this list of paragraphs. Close off all lists at the end. */ static void xhtml_do_paras(FILE *fp, paragraph *p, paragraph *end, int indexable) { int last_type = -1, ptype, first=TRUE; stack lcont_stack = stk_new(); if (!p) return; /* for (; p && (xhtml_para_level(p)>limit || xhtml_para_level(p)==-1 || first); p=p->next) {*/ for (; p && p != end && (xhtml_para_level(p)==-1 || first); p=p->next) { first=FALSE; switch (ptype = p->type) { /* * Things we ignore because we've already processed them or * aren't going to touch them in this pass. */ case para_IM: case para_BR: case para_Biblio: /* only touch BiblioCited */ case para_VersionID: case para_NoCite: case para_Title: break; /* * Chapter titles. */ case para_Chapter: case para_Appendix: case para_UnnumberedChapter: xhtml_heading(fp, p, indexable); break; case para_Heading: case para_Subsect: xhtml_heading(fp, p, indexable); break; case para_Rule: fprintf(fp, "\n
\n"); break; case para_Normal: case para_Copyright: fprintf(fp, "\n
"); xhtml_para(fp, p->words, indexable); fprintf(fp, "
\n"); break; case para_LcontPush: { int *p; p = mknew(int); *p = last_type; stk_push(lcont_stack, p); last_type = para_Normal; } break; case para_LcontPop: { int *p = stk_pop(lcont_stack); assert(p); ptype = last_type = *p; sfree(p); goto closeofflist; /* ick */ } break; case para_QuotePush: fprintf(fp, "
\n"); break; case para_QuotePop: fprintf(fp, "
\n"); break; case para_Bullet: case para_NumberedList: case para_Description: case para_DescribedThing: case para_BiblioCited: if (last_type!=p->type && !(last_type==para_DescribedThing && p->type==para_Description) && !(last_type==para_Description && p->type==para_DescribedThing)) { /* start up list if necessary */ if (p->type == para_Bullet) { fprintf(fp, "
\n"); } else if (ptype == para_NumberedList) { fprintf(fp, "\n"); } else if (ptype == para_BiblioCited || ptype == para_Description || ptype == para_DescribedThing) { fprintf(fp, "\n"); } } } break; case para_Code: xhtml_codepara(fp, p->words); break; } last_type = ptype; } stk_free(lcont_stack); } /* * Output a header for this XHTML file. */ static void xhtml_doheader(FILE *fp, word *title) { fprintf(fp, "\n"); fprintf(fp, "\n\n\n"); if (title==NULL) fprintf(fp, "The thing with no name!"); else xhtml_para(fp, title, FALSE); fprintf(fp, "\n"); fprintf(fp, "\n", version); if (conf.author) fprintf(fp, "\n", conf.author); if (conf.description) fprintf(fp, "\n", conf.description); if (conf.head_end) fprintf(fp, "%ls\n", conf.head_end); fprintf(fp, "\n\n"); if (conf.body) fprintf(fp, "%ls\n", conf.body); else fprintf(fp, "\n"); if (conf.body_start) fprintf(fp, "%ls\n", conf.body_start); } /* * Output a footer for this XHTML file. */ static void xhtml_dofooter(FILE *fp) { fprintf(fp, "\n
\n\n"); if (conf.body_end) fprintf(fp, "%ls\n", conf.body_end); if (!conf.suppress_address) { fprintf(fp,"
\n"); if (conf.address_start) fprintf(fp, "%ls\n", conf.address_start); /* Do the version ID */ if (conf.include_version_id) { paragraph *p; int started = 0; for (p = sourceparas; p; p = p->next) if (p->type == para_VersionID) { xhtml_versionid(fp, p->words, started); started = 1; } } if (conf.address_end) fprintf(fp, "%ls\n", conf.address_end); fprintf(fp, "
\n"); } fprintf(fp, "\n\n\n"); } /* * Output the versionid paragraph. Typically this is a version control * ID string (such as $Id...$ in RCS). */ static void xhtml_versionid(FILE *fp, word *text, int started) { rdstringc t = { 0, 0, NULL }; rdaddc(&t, '['); /* FIXME: configurability */ xhtml_rdaddwc(&t, text, NULL, FALSE); rdaddc(&t, ']'); /* FIXME: configurability */ if (started) fprintf(fp, "
\n"); fprintf(fp, "%s\n", t.text); sfree(t.text); } /* Is this an XHTML reserved character? */ static int xhtml_reservedchar(int c) { if (c=='&' || c=='<' || c=='>' || c=='"') return TRUE; else return FALSE; } /* * Convert a wide string into valid XHTML: Anything outside ASCII will * be fixed up as an entity. Currently we don't worry about constraining the * encoded character set, which we should probably do at some point (we can * still fix up and return FALSE - see the last comment here). We also don't * currently * * Because this is only used for words, spaces are HARD spaces (any other * spaces will be word_Whitespace not word_Normal). So they become * Unless hard_spaces is FALSE, of course (code paragraphs break the above * rule). * * If `result' is non-NULL, mallocs the resulting string and stores a pointer to * it in `*result'. If `result' is NULL, merely checks whether all * characters in the string are feasible. * * Return is nonzero if all characters are OK. If not all * characters are OK but `result' is non-NULL, a result _will_ * still be generated! */ static int xhtml_convert(wchar_t *s, int maxlen, char **result, int hard_spaces) { int doing = (result != 0); int ok = TRUE; char *p = NULL; int plen = 0, psize = 0; if (maxlen <= 0) maxlen = -1; for (; *s && maxlen != 0; s++, maxlen--) { wchar_t c = *s; #define ensure_size(i) if (i>=psize) { psize = i+256; p = resize(p, psize); } if (((c == 32 && !hard_spaces) || (c > 32 && c <= 126 && !xhtml_reservedchar(c)))) { /* Char is OK. */ if (doing) { ensure_size(plen); p[plen++] = (char)c; } } else { /* Char needs fixing up. */ /* ok = FALSE; -- currently we never return FALSE; we * might want to when considering a character set for the * encoded document. */ if (doing) { if (c==32) { /* a space in a word is a hard space */ ensure_size(plen+6); /* includes space for the NUL, which is subsequently stomped on */ sprintf(p+plen, " "); plen+=6; } else { /* FIXME: entity names! */ ensure_size(plen+8); /* includes space for the NUL, which is subsequently stomped on */ plen+=sprintf(p+plen, "&#%04i;", (int)c); } } } } if (doing) { p = resize(p, plen+1); p[plen] = '\0'; *result = p; } return ok; } /* * This formats the given words as XHTML. * * `indexable', if FALSE, prohibits adding any index references. * You might use this, for example, if an index reference occurred * in a section title, to prevent phony index references when the * section title is processed in strange places such as contents * sections. */ static void xhtml_rdaddwc(rdstringc *rs, word *text, word *end, int indexable) { char *c; keyword *kwl; xhtmlsection *sect; indextag *itag; int ti; for (; text && text != end; text = text->next) { switch (text->type) { case word_HyperLink: xhtml_utostr(text->text, &c); rdaddsc(rs, ""); sfree(c); break; case word_UpperXref: case word_LowerXref: kwl = kw_lookup(keywords, text->text); if (kwl) { sect=xhtml_find_section(kwl->para); if (sect) { rdaddsc(rs, "file->filename); rdaddc(rs, '#'); rdaddsc(rs, sect->fragment); rdaddsc(rs, "\">"); } else { rdaddsc(rs, ""); error(err_whatever, "Couldn't locate cross-reference! (Probably a bibliography entry.)"); } } else { rdaddsc(rs, ""); error(err_whatever, "Couldn't locate cross-reference! (Wasn't in source file.)"); } break; case word_IndexRef: /* in theory we could make an index target here */ /* rdaddsc(rs, "text, &c); rdaddsc(rs, c); sfree(c); rdaddsc(rs, "\">");*/ /* what we _do_ need to do is to fix up the backend data * for any indexentry this points to. */ if (!indexable) break; for (ti=0; (itag = (indextag *)index234(idx->tags, ti))!=NULL; ti++) { /* FIXME: really ustricmp() and not ustrcmp()? */ if (ustricmp(itag->name, text->text)==0) { break; } } if (itag!=NULL) { if (itag->refs!=NULL) { int i; for (i=0; i
nrefs; i++) { xhtmlindex *idx_ref; indexentry *ientry; ientry = itag->refs[i]; if (ientry->backend_data==NULL) { idx_ref = (xhtmlindex*) smalloc(sizeof(xhtmlindex)); if (idx_ref==NULL) fatal(err_nomemory); idx_ref->nsection = 0; idx_ref->size = 4; idx_ref->sections = (xhtmlsection**) smalloc(idx_ref->size * sizeof(xhtmlsection*)); if (idx_ref->sections==NULL) fatal(err_nomemory); ientry->backend_data = idx_ref; } else { idx_ref = ientry->backend_data; if (idx_ref->nsection+1 > idx_ref->size) { int new_size = idx_ref->size * 2; idx_ref->sections = srealloc(idx_ref->sections, new_size * sizeof(xhtmlsection)); if (idx_ref->sections==NULL) { fatal(err_nomemory); } idx_ref->size = new_size; } } idx_ref->sections[idx_ref->nsection++] = currentsection; #if 0 #endif } } else { fatal(err_whatever, "Index tag had no entries!"); } } else { fprintf(stderr, "Looking for index entry '%ls'\n", text->text); fatal(err_whatever, "Couldn't locate index entry! (Wasn't in index.)"); } break; case word_HyperEnd: case word_XrefEnd: rdaddsc(rs, ""); 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)) rdaddsc(rs, ""); else if ((towordstyle(text->type) == word_Code || towordstyle(text->type) == word_WeakCode) && (attraux(text->aux) == attr_First || attraux(text->aux) == attr_Only)) rdaddsc(rs, ""); if (removeattr(text->type) == word_Normal) { if (xhtml_convert(text->text, 0, &c, TRUE)) /* spaces in the word are hard */ rdaddsc(rs, c); else xhtml_rdaddwc(rs, text->alt, NULL, indexable); sfree(c); } else if (removeattr(text->type) == word_WhiteSpace) { rdaddc(rs, ' '); } else if (removeattr(text->type) == word_Quote) { rdaddsc(rs, """); } if (towordstyle(text->type) == word_Emph && (attraux(text->aux) == attr_Last || attraux(text->aux) == attr_Only)) rdaddsc(rs, ""); else if ((towordstyle(text->type) == word_Code || towordstyle(text->type) == word_WeakCode) && (attraux(text->aux) == attr_Last || attraux(text->aux) == attr_Only)) rdaddsc(rs, ""); break; } } } /* Output a heading, formatted as XHTML. */ static void xhtml_heading(FILE *fp, paragraph *p, int indexable) { rdstringc t = { 0, 0, NULL }; word *tprefix = p->kwtext; word *nprefix = p->kwtext2; word *text = p->words; int level = xhtml_para_level(p); xhtmlsection *sect = xhtml_find_section(p); xhtmlheadfmt *fmt; char *fragment; if (sect) { fragment = sect->fragment; } else { if (p->type == para_Title) fragment = "title"; else { fragment = ""; /* FIXME: what else can we do? */ error(err_whatever, "Couldn't locate heading cross-reference!"); } } if (p->type == para_Title) fmt = NULL; else if (level == 1) fmt = &conf.fchapter; else if (level-1 < conf.nfsect) fmt = &conf.fsect[level-1]; else fmt = &conf.fsect[conf.nfsect-1]; if (fmt && fmt->just_numbers && nprefix) { xhtml_rdaddwc(&t, nprefix, NULL, indexable); if (fmt) { char *c; if (xhtml_convert(fmt->number_suffix, 0, &c, FALSE)) { rdaddsc(&t, c); sfree(c); } } } else if (fmt && !fmt->just_numbers && tprefix) { xhtml_rdaddwc(&t, tprefix, NULL, indexable); if (fmt) { char *c; if (xhtml_convert(fmt->number_suffix, 0, &c, FALSE)) { rdaddsc(&t, c); sfree(c); } } } xhtml_rdaddwc(&t, text, NULL, indexable); /* * If we're outputting in single-file mode, we need to lower * the level of each heading by one, because the overall * document title will be sitting right at the top as an
* and so chapters and sections should start at
. * * Even if not, the document title will come back from * xhtml_para_level() as level zero, so we must increment that * no matter what leaf_level is set to. */ if (conf.leaf_level == 0 || level == 0) level++; fprintf(fp, "%s\n", fragment, level, t.text, level); sfree(t.text); } /* Output a paragraph. Styles are handled by xhtml_rdaddwc(). * This looks pretty simple; I may have missed something ... */ static void xhtml_para(FILE *fp, word *text, int indexable) { rdstringc out = { 0, 0, NULL }; xhtml_rdaddwc(&out, text, NULL, indexable); fprintf(fp, "%s", out.text); sfree(out.text); } /* Output a code paragraph. I'm treating this as preformatted, which * may not be entirely correct. See xhtml_para() for my worries about * this being overly-simple; however I think that most of the complexity * of the text backend came entirely out of word wrapping anyway. */ static void xhtml_codepara(FILE *fp, word *text) { fprintf(fp, "
```
");
    for (; text; text = text->next) if (text->type == word_WeakCode) {
	word *here, *next;
	char *c;

	/*
	 * See if this WeakCode is followed by an Emph to indicate
	 * emphasis.
	 */
	here = text;
	if (text->next && text->next->type == word_Emph) {
	    next = text = text->next;
	} else
	    next = NULL;

	if (next) {
	    wchar_t *t, *e;
	    int n;

	    t = here->text;
	    e = next->text;

	    while (*e) {
		int ec = *e;

		for (n = 0; t[n] && e[n] && e[n] == ec; n++);
		xhtml_convert(t, n, &c, FALSE);
		fprintf(fp, "%s%s%s",
			(ec == 'i' ? "" : ec == 'b' ? "" : ""),
			c,
			(ec == 'i' ? "" : ec == 'b' ? "" : ""));
		sfree(c);

		t += n;
		e += n;
	    }

	    xhtml_convert(t, 0, &c, FALSE);
	    fprintf(fp, "%s\n", c);
	    sfree(c);
	} else {
	    xhtml_convert(here->text, 0, &c, FALSE);
	    fprintf(fp, "%s\n", c);
	    sfree(c);
	}
    }
  fprintf(fp, "
```
\n"); }

Index

* and so chapters and sections should start at