mandoc/html.c - diff

Return to html.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/html.c between version 1.247 and 1.263

version 1.247, 2018/12/16 00:17:02

version 1.263, 2020/02/27 22:28:13

Line 1

/* $Id$ */

* Permission to use, copy, modify, and distribute this software for any

* purpose with or without fee is hereby granted, provided that the above

Line 42

struct htmldata {

const char *name;

int flags;

#define HTML_NOSTACK (1 << 0)

#define HTML_INPHRASE (1 << 0) /* Can appear in phrasing context. */

#define HTML_AUTOCLOSE (1 << 1)

#define HTML_TOPHRASE (1 << 1) /* Establishes phrasing context. */

#define HTML_NLBEFORE (1 << 2)

#define HTML_NOSTACK (1 << 2) /* Does not have an end tag. */

#define HTML_NLBEGIN (1 << 3)

#define HTML_NLBEFORE (1 << 3) /* Output line break before opening. */

#define HTML_NLEND (1 << 4)

#define HTML_NLBEGIN (1 << 4) /* Output line break after opening. */

#define HTML_NLAFTER (1 << 5)

#define HTML_NLEND (1 << 5) /* Output line break before closing. */

#define HTML_NLAFTER (1 << 6) /* Output line break after closing. */

#define HTML_NLAROUND (HTML_NLBEFORE | HTML_NLAFTER)

#define HTML_NLINSIDE (HTML_NLBEGIN | HTML_NLEND)

#define HTML_NLALL (HTML_NLAROUND | HTML_NLINSIDE)

#define HTML_INDENT (1 << 6)

#define HTML_INDENT (1 << 7) /* Indent content by two spaces. */

#define HTML_NOINDENT (1 << 7)

#define HTML_NOINDENT (1 << 8) /* Exception: never indent content. */

};

static const struct htmldata htmltags[TAG_MAX] = {

{"html", HTML_NLALL},

{"head", HTML_NLALL | HTML_INDENT},

{"body", HTML_NLALL},

{"meta", HTML_NOSTACK | HTML_NLALL},

{"meta", HTML_NOSTACK | HTML_AUTOCLOSE | HTML_NLALL},

{"link", HTML_NOSTACK | HTML_NLALL},

{"style", HTML_NLALL | HTML_INDENT},

{"title", HTML_NLAROUND},

{"body", HTML_NLALL},

{"div", HTML_NLAROUND},

{"div", 0},

{"section", HTML_NLALL},

{"h1", HTML_NLAROUND},

{"h2", HTML_NLAROUND},

{"span", 0},

{"link", HTML_NOSTACK | HTML_AUTOCLOSE | HTML_NLALL},

{"br", HTML_NOSTACK | HTML_AUTOCLOSE | HTML_NLALL},

{"a", 0},

{"table", HTML_NLALL | HTML_INDENT},

{"tr", HTML_NLALL | HTML_INDENT},

{"td", HTML_NLAROUND},

Line 78 static const struct htmldata htmltags[TAG_MAX] = {

Line 75 static const struct htmldata htmltags[TAG_MAX] = {

{"dl", HTML_NLALL | HTML_INDENT},

{"dt", HTML_NLAROUND},

{"dd", HTML_NLAROUND | HTML_INDENT},

{"pre", HTML_NLALL | HTML_NOINDENT},

{"h1", HTML_TOPHRASE | HTML_NLAROUND},

{"var", 0},

{"h2", HTML_TOPHRASE | HTML_NLAROUND},

{"cite", 0},

{"p", HTML_TOPHRASE | HTML_NLAROUND | HTML_INDENT},

{"b", 0},

{"pre", HTML_TOPHRASE | HTML_NLALL | HTML_NOINDENT},

{"i", 0},

{"a", HTML_INPHRASE | HTML_TOPHRASE},

{"code", 0},

{"b", HTML_INPHRASE | HTML_TOPHRASE},

{"small", 0},

{"cite", HTML_INPHRASE | HTML_TOPHRASE},

{"style", HTML_NLALL | HTML_INDENT},

{"code", HTML_INPHRASE | HTML_TOPHRASE},

{"math", HTML_NLALL | HTML_INDENT},

{"i", HTML_INPHRASE | HTML_TOPHRASE},

{"small", HTML_INPHRASE | HTML_TOPHRASE},

{"span", HTML_INPHRASE | HTML_TOPHRASE},

{"var", HTML_INPHRASE | HTML_TOPHRASE},

{"br", HTML_INPHRASE | HTML_NOSTACK | HTML_NLALL},

{"mark", HTML_INPHRASE },

{"math", HTML_INPHRASE | HTML_NLALL | HTML_INDENT},

{"mrow", 0},

{"mi", 0},

{"mn", 0},

Line 108 static const struct htmldata htmltags[TAG_MAX] = {

Line 111 static const struct htmldata htmltags[TAG_MAX] = {

/* Avoid duplicate HTML id= attributes. */

static struct ohash id_unique;

static void html_reset_internal(struct html *);

static void print_byte(struct html *, char);

static void print_endword(struct html *);

static void print_indent(struct html *);

Line 117 static void print_ctag(struct html *, struct tag *);

Line 121 static void print_ctag(struct html *, struct tag *);

static int print_escape(struct html *, char);

static int print_encode(struct html *, const char *, const char *, int);

static void print_href(struct html *, const char *, const char *, int);

static void print_metaf(struct html *);

void *

Line 143 html_alloc(const struct manoutput *outopts)

Line 148 html_alloc(const struct manoutput *outopts)

return h;

}

void

static void

html_free(void *p)

html_reset_internal(struct html *h)

{

struct tag *tag;

struct html *h;

char *cp;

unsigned int slot;

h = (struct html *)p;

while ((tag = h->tag) != NULL) {

h->tag = tag->next;

free(tag);

}

free(h);

cp = ohash_first(&id_unique, &slot);

while (cp != NULL) {

free(cp);

Line 167 html_free(void *p)

Line 168 html_free(void *p)

}

void

html_reset(void *p)

{

html_reset_internal(p);

mandoc_ohash_init(&id_unique, 4, 0);

}

void

html_free(void *p)

{

html_reset_internal(p);

free(p);

}

void

print_gen_head(struct html *h)

{

struct tag *t;

Line 189 print_gen_head(struct html *h)

Line 204 print_gen_head(struct html *h)

print_endline(h);

print_text(h, "td.head-vol { text-align: center; }");

print_endline(h);

print_text(h, "div.Pp { margin: 1ex 0ex; }");

print_text(h, ".Nd, .Bf, .Op { display: inline; }");

print_endline(h);

print_text(h, "div.Nd, div.Bf, div.Op { display: inline; }");

print_text(h, ".Pa, .Ad { font-style: italic; }");

print_endline(h);

print_text(h, "span.Pa, span.Ad { font-style: italic; }");

print_text(h, ".Ms { font-weight: bold; }");

print_endline(h);

print_text(h, "span.Ms { font-weight: bold; }");

print_text(h, ".Bl-diag ");

print_endline(h);

print_text(h, "dl.Bl-diag ");

print_byte(h, '>');

print_text(h, " dt { font-weight: bold; }");

print_endline(h);

print_text(h, "code.Nm, code.Fl, code.Cm, code.Ic, "

print_text(h, "code.Nm, .Fl, .Cm, .Ic, code.In, .Fd, .Fn, .Cd "

"code.In, code.Fd, code.Fn,");

"{ font-weight: bold; font-family: inherit; }");

print_endline(h);

print_text(h, "code.Cd { font-weight: bold; "

"font-family: inherit; }");

print_tagq(h, t);

}

void

int

print_metaf(struct html *h, enum mandoc_esc deco)

html_setfont(struct html *h, enum mandoc_esc font)

{

enum htmlfont font;

switch (font) {

switch (deco) {

case ESCAPE_FONTPREV:

font = h->metal;

break;

case ESCAPE_FONTITALIC:

font = HTMLFONT_ITALIC;

break;

case ESCAPE_FONTBOLD:

font = HTMLFONT_BOLD;

break;

case ESCAPE_FONTBI:

font = HTMLFONT_BI;

break;

case ESCAPE_FONTCW:

font = HTMLFONT_CW;

case ESCAPE_FONTROMAN:

break;

case ESCAPE_FONT:

case ESCAPE_FONTROMAN:

font = ESCAPE_FONTROMAN;

font = HTMLFONT_NONE;

break;

default:

return;

return 0;

}

h->metal = h->metac;

h->metac = font;

return 1;

}

static void

print_metaf(struct html *h)

{

if (h->metaf) {

print_tagq(h, h->metaf);

h->metaf = NULL;

}

switch (h->metac) {

h->metal = h->metac;

case ESCAPE_FONTITALIC:

h->metac = font;

switch (font) {

case HTMLFONT_ITALIC:

h->metaf = print_otag(h, TAG_I, "");

break;

case HTMLFONT_BOLD:

case ESCAPE_FONTBOLD:

h->metaf = print_otag(h, TAG_B, "");

break;

case HTMLFONT_BI:

case ESCAPE_FONTBI:

h->metaf = print_otag(h, TAG_B, "");

print_otag(h, TAG_I, "");

break;

case HTMLFONT_CW:

case ESCAPE_FONTCW:

h->metaf = print_otag(h, TAG_SPAN, "c", "Li");

break;

default:

Line 265 print_metaf(struct html *h, enum mandoc_esc deco)

Line 269 print_metaf(struct html *h, enum mandoc_esc deco)

}

void

html_close_paragraph(struct html *h)

{

struct tag *this, *next;

int flags;

this = h->tag;

for (;;) {

next = this->next;

flags = htmltags[this->tag].flags;

if (flags & (HTML_INPHRASE | HTML_TOPHRASE))

print_ctag(h, this);

if ((flags & HTML_INPHRASE) == 0)

break;

this = next;

}

* ROFF_nf switches to no-fill mode, ROFF_fi to fill mode.

* TOKEN_NONE does not switch. The old mode is returned.

enum roff_tok

html_fillmode(struct html *h, enum roff_tok want)

{

struct tag *t;

enum roff_tok had;

for (t = h->tag; t != NULL; t = t->next)

if (t->tag == TAG_PRE)

break;

had = t == NULL ? ROFF_fi : ROFF_nf;

if (want != had) {

switch (want) {

case ROFF_fi:

print_tagq(h, t);

break;

case ROFF_nf:

html_close_paragraph(h);

print_otag(h, TAG_PRE, "");

break;

case TOKEN_NONE:

break;

default:

abort();

}

return had;

}

char *

html_make_id(const struct roff_node *n, int unique)

{

Line 411 print_encode(struct html *h, const char *p, const char

Line 467 print_encode(struct html *h, const char *p, const char

case ESCAPE_FONTROMAN:

if (0 == norecurse) {

h->flags |= HTML_NOSPACE;

print_metaf(h, esc);

if (html_setfont(h, esc))

print_metaf(h);

h->flags &= ~HTML_NOSPACE;

}

continue;

Line 525 print_otag(struct html *h, enum htmltag tag, const cha

Line 582 print_otag(struct html *h, enum htmltag tag, const cha

tflags = htmltags[tag].flags;

/* Flow content is not allowed in phrasing context. */

if ((tflags & HTML_INPHRASE) == 0) {

for (t = h->tag; t != NULL; t = t->next) {

if (t->closed)

continue;

assert((htmltags[t->tag].flags & HTML_TOPHRASE) == 0);

break;

}

* Always wrap phrasing elements in a paragraph

* unless already contained in some flow container;

* never put them directly into a section.

} else if (tflags & HTML_TOPHRASE && h->tag->tag == TAG_SECTION)

print_otag(h, TAG_P, "c", "Pp");

/* Push this tag onto the stack of open scopes. */

if ((tflags & HTML_NOSTACK) == 0) {

t = mandoc_malloc(sizeof(struct tag));

t->tag = tag;

t->next = h->tag;

t->refcnt = 0;

t->closed = 0;

h->tag = t;

} else

t = NULL;

Line 609 print_otag(struct html *h, enum htmltag tag, const cha

Line 687 print_otag(struct html *h, enum htmltag tag, const cha

print_encode(h, arg1, NULL, 1);

fmt++;

break;

case 'T':

print_encode(h, arg1, NULL, 1);

print_word(h, "\" title=\"");

print_encode(h, arg1, NULL, 1);

fmt++;

break;

default:

print_encode(h, arg1, NULL, 1);

break;

Line 646 print_otag(struct html *h, enum htmltag tag, const cha

Line 718 print_otag(struct html *h, enum htmltag tag, const cha

/* Accommodate for "well-formed" singleton escaping. */

if (HTML_AUTOCLOSE & htmltags[tag].flags)

if (htmltags[tag].flags & HTML_NOSTACK)

print_byte(h, '/');

print_byte(h, '>');

Line 669 print_ctag(struct html *h, struct tag *tag)

Line 741 print_ctag(struct html *h, struct tag *tag)

{

int tflags;

if (tag->closed == 0) {

* Remember to close out and nullify the current

tag->closed = 1;

* meta-font and table, if applicable.

if (tag == h->metaf)

h->metaf = NULL;

if (tag == h->metaf)

if (tag == h->tblt)

h->metaf = NULL;

h->tblt = NULL;

if (tag == h->tblt)

h->tblt = NULL;

tflags = htmltags[tag->tag].flags;

if (tflags & HTML_INDENT)

h->indent--;

if (tflags & HTML_NOINDENT)

h->noindent--;

if (tflags & HTML_NLEND)

print_endline(h);

print_indent(h);

print_byte(h, '<');

print_byte(h, '/');

print_word(h, htmltags[tag->tag].name);

print_byte(h, '>');

if (tflags & HTML_NLAFTER)

print_endline(h);

}

if (tag->refcnt == 0) {

h->tag = tag->next;

free(tag);

}

void

Line 734 print_gen_comment(struct html *h, struct roff_node *n)

Line 805 print_gen_comment(struct html *h, struct roff_node *n)

void

print_text(struct html *h, const char *word)

{

* Always wrap text in a paragraph unless already contained in

* some flow container; never put it directly into a section.

if (h->tag->tag == TAG_SECTION)

print_otag(h, TAG_P, "c", "Pp");

/* Output whitespace before this text? */

if (h->col && (h->flags & HTML_NOSPACE) == 0) {

if ( ! (HTML_KEEP & h->flags)) {

if (HTML_PREKEEP & h->flags)

Line 743 print_text(struct html *h, const char *word)

Line 824 print_text(struct html *h, const char *word)

print_word(h, " ");

}

assert(NULL == h->metaf);

switch (h->metac) {

* Print the text, optionally surrounded by HTML whitespace,

case HTMLFONT_ITALIC:

* optionally manually switching fonts before and after.

h->metaf = print_otag(h, TAG_I, "");

break;

case HTMLFONT_BOLD:

h->metaf = print_otag(h, TAG_B, "");

break;

case HTMLFONT_BI:

h->metaf = print_otag(h, TAG_B, "");

print_otag(h, TAG_I, "");

break;

case HTMLFONT_CW:

h->metaf = print_otag(h, TAG_SPAN, "c", "Li");

break;

default:

print_indent(h);

break;

}

assert(word);

assert(h->metaf == NULL);

print_metaf(h);

print_indent(h);

if ( ! print_encode(h, word, NULL, 0)) {

if ( ! (h->flags & HTML_NONOSPACE))

h->flags &= ~HTML_NOSPACE;

Line 771 print_text(struct html *h, const char *word)

Line 839 print_text(struct html *h, const char *word)

} else

h->flags |= HTML_NOSPACE | HTML_NONEWLINE;

if (h->metaf) {

if (h->metaf != NULL) {

print_tagq(h, h->metaf);

h->metaf = NULL;

}

Line 782 print_text(struct html *h, const char *word)

Line 850 print_text(struct html *h, const char *word)

void

print_tagq(struct html *h, const struct tag *until)

{

struct tag *tag;

struct tag *this, *next;

while ((tag = h->tag) != NULL) {

for (this = h->tag; this != NULL; this = next) {

print_ctag(h, tag);

next = this == until ? NULL : this->next;

if (until && tag == until)

print_ctag(h, this);

return;

}

* Close out all open elements up to but excluding suntil.

* Note that a paragraph just inside stays open together with it

* because paragraphs include subsequent phrasing content.

void

print_stagq(struct html *h, const struct tag *suntil)

{

struct tag *tag;

struct tag *this, *next;

while ((tag = h->tag) != NULL) {

for (this = h->tag; this != NULL; this = next) {

if (suntil && tag == suntil)

next = this->next;

return;

if (this == suntil || (next == suntil &&

print_ctag(h, tag);

(this->tag == TAG_P || this->tag == TAG_PRE)))

break;

print_ctag(h, this);

}

void

print_paragraph(struct html *h)

{

struct tag *t;

t = print_otag(h, TAG_DIV, "c", "Pp");

print_tagq(h, t);

}

/***********************************************************************

* Low level output functions.

* They implement line breaking using a short static buffer.

Line 904 print_indent(struct html *h)

Line 969 print_indent(struct html *h)

{

size_t i;

if (h->col)

if (h->col || h->noindent)

return;

if (h->noindent == 0) {

h->col = h->indent * 2;

for (i = 0; i < h->col; i++)

putchar(' ');

}

h->flags &= ~HTML_NOSPACE;

}

CVSweb