", conf.nav_attrs);
} else
{
fprintf(fp, ">");
}
if (xhtml_last_file == NULL)
{
fprintf(fp, "Previous | ");
} else
{
fprintf(fp, "Previous | ", xhtml_last_file->filename);
}
fprintf(fp, "Contents | ");
if (file != NULL)
{ /* otherwise we're doing nav links for the index */
if (xhtml_next_file == NULL)
xhtml_next_file = file->child;
if (xhtml_next_file == NULL)
xhtml_next_file = file->next;
if (xhtml_next_file == NULL)
xhtml_next_file = file->parent->next;
}
if (xhtml_next_file == NULL)
{
if (file == NULL)
{ /* index, so no next file */
fprintf(fp, "Next ");
} else
{
fprintf(fp, "Next", xhtml_index_filename);
}
} else
{
fprintf(fp, "Next", xhtml_next_file->filename);
}
fprintf(fp, "\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, "\n");
/* iterate over idx->entries using the tree functions and display everything */
for (ti = 0; (y = (indexentry *) index234(idx->entries, ti)) != NULL;
ti++)
{
if (y->backend_data)
{
int i;
xhtmlindex *xi;
fprintf(fp, "- ");
xhtml_para(fp, y->text);
fprintf(fp, "
\n- ");
xi = (xhtmlindex *) y->backend_data;
for (i = 0; i < xi->nsection; 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);
} else if (sect->para->words)
{
xhtml_para(fp, sect->para->words);
}
fprintf(fp, "");
if (i + 1 < xi->nsection)
{
fprintf(fp, ", ");
}
}
}
fprintf(fp, "
\n");
}
}
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(xhtml_index_filename, "w");
if (fp == NULL)
fatal(err_cantopenw, xhtml_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);
break;
}
}
/* Do the preamble and copyright */
for (p = sourceform; p; p = p->next)
{
if (p->type == para_Preamble)
{
fprintf(fp, "");
xhtml_para(fp, p->words);
fprintf(fp, "
\n");
}
}
for (p = sourceform; p; p = p->next)
{
if (p->type == para_Copyright)
{
fprintf(fp, "");
xhtml_para(fp, p->words);
fprintf(fp, "
\n");
}
}
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 < l; i++)
{
if (in[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, 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_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;
while (last_level > section->level)
{
last_level--;
fprintf(fp, "\n");
}
while (last_level < section->level)
{
last_level++;
fprintf(fp, "\n");
}
fprintf(fp, "- ");
fprintf(fp, "",
(section->para->type == para_Chapter
|| section->para->type ==
para_Appendix) ? "class=\"btitle\" " : "",
section->file->filename,
(section->para->type == para_Chapter) ? "" : section->fragment);
if (section->para->type == para_Chapter
|| section->para->type == para_Appendix)
fprintf(fp, "");
if ((section->para->type != para_Heading
&& section->para->type != para_Subsect) || (section->para->kwtext
&& !section->para->
words))
{
xhtml_para(fp, section->para->kwtext);
if (section->para->words)
fprintf(fp, ": ");
}
if (section->para->type == para_Chapter
|| section->para->type == para_Appendix)
fprintf(fp, "");
if (section->para->words)
{
xhtml_para(fp, section->para->words);
}
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);
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)
{
int last_type = -1, first = TRUE;
if (!p)
return;
/* for (; p && (xhtml_para_level(p)>limit || xhtml_para_level(p)==-1 || first); p=p->next) {*/
for (; p && (xhtml_para_level(p) == -1 || first); p = p->next)
{
first = FALSE;
switch (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_Copyright:
case para_Preamble:
case para_NoCite:
case para_Title:
break;
/*
* Chapter titles.
*/
case para_Chapter:
case para_Appendix:
case para_UnnumberedChapter:
xhtml_heading(fp, p);
break;
case para_Heading:
case para_Subsect:
xhtml_heading(fp, p);
break;
case para_Rule:
fprintf(fp, "\n
\n");
break;
case para_Normal:
fprintf(fp, "\n");
xhtml_para(fp, p->words);
fprintf(fp, "
\n");
break;
case para_Bullet:
case para_NumberedList:
case para_BiblioCited:
if (last_type != p->type)
{
/* start up list if necessary */
if (p->type == para_Bullet)
{
fprintf(fp, "\n");
} else if (p->type == para_NumberedList)
{
fprintf(fp, "\n");
} else if (p->type == para_BiblioCited)
{
fprintf(fp, "\n");
}
}
if (p->type == para_Bullet || p->type == para_NumberedList)
fprintf(fp, "
- ");
else if (p->type == para_BiblioCited)
{
fprintf(fp, "
- ");
xhtml_para(fp, p->kwtext);
fprintf(fp, "
\n- ");
}
xhtml_para(fp, p->words);
if (p->type == para_BiblioCited)
{
fprintf(fp, "
\n");
} else if (p->type == para_Bullet || p->type == para_NumberedList)
{
fprintf(fp, " ");
}
if (p->type == para_Bullet || p->type == para_NumberedList
|| p->type == para_BiblioCited)
/* close off list if necessary */
{
paragraph *p2 = p->next;
int close_off = FALSE;
/* if (p2 && (xhtml_para_level(p2)>limit || xhtml_para_level(p2)==-1)) {*/
if (p2 && xhtml_para_level(p2) == -1)
{
if (p2->type != p->type)
close_off = TRUE;
} else
{
close_off = TRUE;
}
if (close_off)
{
if (p->type == para_Bullet)
{
fprintf(fp, "
\n");
} else if (p->type == para_NumberedList)
{
fprintf(fp, "\n");
} else if (p->type == para_BiblioCited)
{
fprintf(fp, "\n");
}
}
}
break;
case para_Code:
xhtml_codepara(fp, p->words);
break;
}
last_type = p->type;
}
}
/*
* 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, "Documentation");
else
xhtml_para(fp, title);
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);
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, char **result, int hard_spaces)
{
int doing = (result != 0);
int ok = TRUE;
char *p = NULL;
int plen = 0, psize = 0;
for (; *s; s++)
{
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 + 7); /* includes space for the NUL, which is subsequently stomped on */
sprintf(p + plen, " ");
plen += 6;
} else
{
switch (c)
{
case '&':
ensure_size(plen + 6); /* includes space for the NUL, which is subsequently stomped on */
plen += sprintf(p + plen, "&");
break;
case '"':
ensure_size(plen + 7); /* includes space for the NUL, which is subsequently stomped on */
plen += sprintf(p + plen, """);
break;
case '<':
if (plen > 1 && *(s - 1) == '\\' && *(s - 2) == '\\')
{
ensure_size(--plen);
p[plen - 1] = (char) c;
p[plen] = 0;
} else
{
ensure_size(plen + 5); /* includes space for the NUL, which is subsequently stomped on */
plen += sprintf(p + plen, "<");
}
break;
case '>':
if (plen > 1 && *(s - 1) == '\\' && *(s - 2) == '\\')
{
ensure_size(--plen);
p[plen - 1] = (char) c;
p[plen] = 0;
} else
{
ensure_size(plen + 5); /* includes space for the NUL, which is subsequently stomped on */
plen += sprintf(p + plen, ">");
}
break;
default:
ensure_size(plen + 8); /* includes space for the NUL, which is subsequently stomped on */
plen += sprintf(p + plen, "&#%04i;", (int) c);
break;
}
}
}
}
}
if (doing)
{
p = resize(p, plen + 1);
p[plen] = '\0';
*result = p;
}
return ok;
}
/*
* This formats the given words as XHTML.
*/
static void xhtml_rdaddwc(rdstringc * rs, word * text, word * end)
{
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:
case word_FreeTextXref:
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.
*/
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 < itag->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)
{
static int dont_convert = 0;
if (dont_convert)
{
char buf[2] = " ";
dont_convert = 0;
wchar_t *s = text->text;
for (; *s; s++)
{
buf[0] = (char) *s;
rdaddsc(rs, buf);
}
buf[0] = 0;
rdaddsc(rs, buf);
} else
{
if (*text->text == '\\' && text->next
&& text->next->text && (*text->next->text == '&'
|| *text->next->text == '<'
|| *text->next->text == '>'
|| *text->next->text == '"'))
dont_convert = 1;
else
{
if (xhtml_convert(text->text, &c, TRUE)) /* spaces in the word are hard */
rdaddsc(rs, c);
else
xhtml_rdaddwc(rs, text->alt, NULL);
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)
{
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);
if (fmt)
{
char *c;
if (xhtml_convert(fmt->number_suffix, &c, FALSE))
{
rdaddsc(&t, c);
sfree(c);
}
}
} else if (fmt && !fmt->just_numbers && tprefix)
{
xhtml_rdaddwc(&t, tprefix, NULL);
if (fmt)
{
char *c;
if (xhtml_convert(fmt->number_suffix, &c, FALSE))
{
rdaddsc(&t, c);
sfree(c);
}
}
}
xhtml_rdaddwc(&t, text, NULL);
/*
* 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)
{
rdstringc out = { 0, 0, NULL };
xhtml_rdaddwc(&out, text, NULL);
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)
{
char *c;
xhtml_convert(text->text, &c, FALSE);
fprintf(fp, "%s\n", c);
sfree(c);
}
fprintf(fp, "\n");
}