=================================================================== RCS file: /cvs/mandoc/eqn_html.c,v retrieving revision 1.5 retrieving revision 1.17 diff -u -p -r1.5 -r1.17 --- mandoc/eqn_html.c 2014/09/28 13:34:15 1.5 +++ mandoc/eqn_html.c 2017/07/14 13:32:35 1.17 @@ -1,6 +1,7 @@ -/* $Id: eqn_html.c,v 1.5 2014/09/28 13:34:15 kristaps Exp $ */ +/* $Id: eqn_html.c,v 1.17 2017/07/14 13:32:35 schwarze Exp $ */ /* - * Copyright (c) 2011 Kristaps Dzonsons + * Copyright (c) 2011, 2014 Kristaps Dzonsons + * Copyright (c) 2017 Ingo Schwarze * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above @@ -19,6 +20,7 @@ #include #include +#include #include #include #include @@ -27,183 +29,216 @@ #include "out.h" #include "html.h" -static const enum htmltag fontmap[EQNFONT__MAX] = { - TAG_SPAN, /* EQNFONT_NONE */ - TAG_SPAN, /* EQNFONT_ROMAN */ - TAG_B, /* EQNFONT_BOLD */ - TAG_B, /* EQNFONT_FAT */ - TAG_I /* EQNFONT_ITALIC */ -}; - -static const struct eqn_box * - eqn_box(struct html *, const struct eqn_box *, int); - - -void -print_eqn(struct html *p, const struct eqn *ep) +static void +eqn_box(struct html *p, const struct eqn_box *bp) { - struct htmlpair tag; - struct tag *t; + struct tag *post, *row, *cell, *t; + const struct eqn_box *child, *parent; + const char *cp; + size_t i, j, rows; + enum htmltag tag; + enum eqn_fontt font; - PAIR_CLASS_INIT(&tag, "eqn"); - t = print_otag(p, TAG_MATH, 1, &tag); - - p->flags |= HTML_NONOSPACE; - eqn_box(p, ep->root, 1); - p->flags &= ~HTML_NONOSPACE; - - print_tagq(p, t); -} - -/* - * This function is fairly brittle. - * This is because the eqn syntax doesn't play so nicely with recusive - * formats, e.g., - * foo sub bar sub baz - * ...needs to resolve into - * foo bar, baz - * In other words, we need to embed some recursive work. - * FIXME: this does NOT handle right-left associativity or precedence! - */ -static const struct eqn_box * -eqn_box(struct html *p, const struct eqn_box *bp, int next) -{ - struct tag *post, *pilet, *tmp; - struct htmlpair tag[2]; - int skiptwo; - if (NULL == bp) - return(NULL); + return; - post = pilet = NULL; - skiptwo = 0; + post = NULL; /* - * If we're a "row" under a pile, then open up the piling - * context here. - * We do this first because the pile surrounds the content of - * the contained expression. + * Special handling for a matrix, which is presented to us in + * column order, but must be printed in row-order. */ - if (NULL != bp->parent && bp->parent->pile != EQNPILE_NONE) { - pilet = print_otag(p, TAG_MTR, 0, NULL); - print_otag(p, TAG_MTD, 0, NULL); + if (EQN_MATRIX == bp->type) { + if (NULL == bp->first) + goto out; + if (bp->first->type != EQN_LIST || + bp->first->expectargs == 1) { + eqn_box(p, bp->first); + goto out; + } + if (NULL == (parent = bp->first->first)) + goto out; + /* Estimate the number of rows, first. */ + if (NULL == (child = parent->first)) + goto out; + for (rows = 0; NULL != child; rows++) + child = child->next; + /* Print row-by-row. */ + post = print_otag(p, TAG_MTABLE, ""); + for (i = 0; i < rows; i++) { + parent = bp->first->first; + row = print_otag(p, TAG_MTR, ""); + while (NULL != parent) { + child = parent->first; + for (j = 0; j < i; j++) { + if (NULL == child) + break; + child = child->next; + } + cell = print_otag(p, TAG_MTD, ""); + /* + * If we have no data for this + * particular cell, then print a + * placeholder and continue--don't puke. + */ + if (NULL != child) + eqn_box(p, child->first); + print_tagq(p, cell); + parent = parent->next; + } + print_tagq(p, row); + } + goto out; } - /* - * If we're establishing a pile, start the table mode now. - * If we've already in a pile row, then don't override "pilet", - * because we'll be closed out anyway. - */ - if (bp->pile != EQNPILE_NONE) { - tmp = print_otag(p, TAG_MTABLE, 0, NULL); - pilet = (NULL == pilet) ? tmp : pilet; - } - - /* - * Positioning. - * This is the most complicated part, and actually doesn't quite - * work (FIXME) because it doesn't account for associativity. - * Setting "post" will mean that we're only going to process a - * single or double following expression. - */ switch (bp->pos) { - case (EQNPOS_SUP): - post = print_otag(p, TAG_MSUP, 0, NULL); + case EQNPOS_TO: + post = print_otag(p, TAG_MOVER, ""); break; - case (EQNPOS_FROM): - /* FALLTHROUGH */ - case (EQNPOS_SUB): - post = print_otag(p, TAG_MSUB, 0, NULL); + case EQNPOS_SUP: + post = print_otag(p, TAG_MSUP, ""); break; - case (EQNPOS_OVER): - post = print_otag(p, TAG_MFRAC, 0, NULL); + case EQNPOS_FROM: + post = print_otag(p, TAG_MUNDER, ""); break; - case (EQNPOS_SUBSUP): - /* This requires two elements. */ - post = print_otag(p, TAG_MSUBSUP, 0, NULL); - skiptwo = 1; + case EQNPOS_SUB: + post = print_otag(p, TAG_MSUB, ""); break; + case EQNPOS_OVER: + post = print_otag(p, TAG_MFRAC, ""); + break; + case EQNPOS_FROMTO: + post = print_otag(p, TAG_MUNDEROVER, ""); + break; + case EQNPOS_SUBSUP: + post = print_otag(p, TAG_MSUBSUP, ""); + break; + case EQNPOS_SQRT: + post = print_otag(p, TAG_MSQRT, ""); + break; default: break; } - /*t = EQNFONT_NONE == bp->font ? NULL : - print_otag(p, fontmap[(int)bp->font], 0, NULL);*/ + if (bp->top || bp->bottom) { + assert(NULL == post); + if (bp->top && NULL == bp->bottom) + post = print_otag(p, TAG_MOVER, ""); + else if (bp->top && bp->bottom) + post = print_otag(p, TAG_MUNDEROVER, ""); + else if (bp->bottom) + post = print_otag(p, TAG_MUNDER, ""); + } - if (NULL != bp->text) { - assert(NULL == bp->first); - /* - * We have text. - * This can be a number, a function, a variable, or - * pretty much anything else. - * First, check for some known functions. - * If we're going to create a structural node (e.g., - * sqrt), then set the "post" variable only if it's not - * already set. - */ - if (0 == strcmp(bp->text, "sqrt")) { - tmp = print_otag(p, TAG_MSQRT, 0, NULL); - post = (NULL == post) ? tmp : post; - } else if (0 == strcmp(bp->text, "+") || - 0 == strcmp(bp->text, "-") || - 0 == strcmp(bp->text, "=") || - 0 == strcmp(bp->text, "(") || - 0 == strcmp(bp->text, ")") || - 0 == strcmp(bp->text, "/")) { - tmp = print_otag(p, TAG_MO, 0, NULL); - print_text(p, bp->text); - print_tagq(p, tmp); - } else { - tmp = print_otag(p, TAG_MI, 0, NULL); - print_text(p, bp->text); - print_tagq(p, tmp); + if (EQN_PILE == bp->type) { + assert(NULL == post); + if (bp->first != NULL && + bp->first->type == EQN_LIST && + bp->first->expectargs > 1) + post = print_otag(p, TAG_MTABLE, ""); + } else if (bp->type == EQN_LIST && bp->expectargs > 1 && + bp->parent && bp->parent->type == EQN_PILE) { + assert(NULL == post); + post = print_otag(p, TAG_MTR, ""); + print_otag(p, TAG_MTD, ""); + } + + if (bp->text != NULL) { + assert(post == NULL); + tag = TAG_MI; + cp = bp->text; + if (isdigit((unsigned char)cp[0]) || + (cp[0] == '.' && isdigit((unsigned char)cp[1]))) { + tag = TAG_MN; + while (*++cp != '\0') { + if (*cp != '.' && + isdigit((unsigned char)*cp) == 0) { + tag = TAG_MI; + break; + } + } + } else if (*cp != '\0' && isalpha((unsigned char)*cp) == 0) { + tag = TAG_MO; + while (*cp != '\0') { + if (cp[0] == '\\' && cp[1] != '\0') { + cp++; + mandoc_escape(&cp, NULL, NULL); + } else if (isalnum((unsigned char)*cp)) { + tag = TAG_MI; + break; + } else + cp++; + } } - } else if (NULL != bp->first) { - assert(NULL == bp->text); - /* - * If we're a "fenced" component (i.e., having - * brackets), then process those brackets now. - * Otherwise, introduce a dummy row (if we're not - * already in a table context). - */ - tmp = NULL; - if (NULL != bp->left || NULL != bp->right) { - PAIR_INIT(&tag[0], ATTR_OPEN, - NULL != bp->left ? bp->left : ""); - PAIR_INIT(&tag[1], ATTR_CLOSE, - NULL != bp->right ? bp->right : ""); - tmp = print_otag(p, TAG_MFENCED, 2, tag); - print_otag(p, TAG_MROW, 0, NULL); - } else if (NULL == pilet) - tmp = print_otag(p, TAG_MROW, 0, NULL); - eqn_box(p, bp->first, 1); - if (NULL != tmp) - print_tagq(p, tmp); + font = bp->font; + if (bp->text[0] != '\0' && + (((tag == TAG_MN || tag == TAG_MO) && + font == EQNFONT_ROMAN) || + (tag == TAG_MI && font == (bp->text[1] == '\0' ? + EQNFONT_ITALIC : EQNFONT_ROMAN)))) + font = EQNFONT_NONE; + switch (font) { + case EQNFONT_NONE: + post = print_otag(p, tag, ""); + break; + case EQNFONT_ROMAN: + post = print_otag(p, tag, "?", "fontstyle", "normal"); + break; + case EQNFONT_BOLD: + case EQNFONT_FAT: + post = print_otag(p, tag, "?", "fontweight", "bold"); + break; + case EQNFONT_ITALIC: + post = print_otag(p, tag, "?", "fontstyle", "italic"); + break; + default: + abort(); + } + print_text(p, bp->text); + } else if (NULL == post) { + if (NULL != bp->left || NULL != bp->right) + post = print_otag(p, TAG_MFENCED, "??", + "open", bp->left == NULL ? "" : bp->left, + "close", bp->right == NULL ? "" : bp->right); + if (NULL == post) + post = print_otag(p, TAG_MROW, ""); + else + print_otag(p, TAG_MROW, ""); } - /* - * If a positional context, invoke the "next" context. - * This is recursive and will return the end of the recursive - * chain of "next" contexts. - */ - if (NULL != post) { - bp = eqn_box(p, bp->next, 0); - if (skiptwo) - bp = eqn_box(p, bp->next, 0); - print_tagq(p, post); + eqn_box(p, bp->first); + +out: + if (NULL != bp->bottom) { + t = print_otag(p, TAG_MO, ""); + print_text(p, bp->bottom); + print_tagq(p, t); } + if (NULL != bp->top) { + t = print_otag(p, TAG_MO, ""); + print_text(p, bp->top); + print_tagq(p, t); + } - /* - * If we're being piled (either directly, in the table, or - * indirectly in a table row), then close that out. - */ - if (NULL != pilet) - print_tagq(p, pilet); + if (NULL != post) + print_tagq(p, post); - /* - * If we're normally processing, then grab the next node. - * If we're in a recursive context, then don't seek to the next - * node; further recursion has already been handled. - */ - return(next ? eqn_box(p, bp->next, 1) : bp); + eqn_box(p, bp->next); +} + +void +print_eqn(struct html *p, const struct eqn_box *bp) +{ + struct tag *t; + + if (bp->first == NULL) + return; + + t = print_otag(p, TAG_MATH, "c", "eqn"); + + p->flags |= HTML_NONOSPACE; + eqn_box(p, bp); + p->flags &= ~HTML_NONOSPACE; + + print_tagq(p, t); }