-/* $Id: eqn_html.c,v 1.7 2014/09/28 20:14:20 kristaps Exp $ */
+/* $Id: eqn_html.c,v 1.19 2019/03/17 18:21:45 schwarze Exp $ */
/*
- * Copyright (c) 2011 Kristaps Dzonsons <kristaps@bsd.lv>
+ * Copyright (c) 2011, 2014 Kristaps Dzonsons <kristaps@bsd.lv>
+ * Copyright (c) 2017 Ingo Schwarze <schwarze@openbsd.org>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
#include <sys/types.h>
#include <assert.h>
+#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "mandoc.h"
+#include "roff.h"
+#include "eqn.h"
#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)
-{
- struct htmlpair tag;
- struct tag *t;
-
- 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
- * <msub> foo <msub> bar, baz </msub> </msub>
- * 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)
+static void
+eqn_box(struct html *p, const struct eqn_box *bp)
{
- struct tag *post, *pilet, *tmp;
- struct htmlpair tag[2];
- int skiptwo;
+ 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;
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 (NULL != bp->parent && bp->parent->type == EQN_MATRIX) {
- pilet = print_otag(p, TAG_MTABLE, 0, NULL);
- print_otag(p, TAG_MTR, 0, NULL);
- print_otag(p, TAG_MTD, 0, NULL);
- }
-
- /*
- * 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;
+ 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;
}
- /*
- * 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_TO):
- post = print_otag(p, TAG_MOVER, 0, NULL);
+ case EQNPOS_TO:
+ post = print_otag(p, TAG_MOVER, "");
+ break;
+ case EQNPOS_SUP:
+ post = print_otag(p, TAG_MSUP, "");
break;
- case (EQNPOS_SUP):
- post = print_otag(p, TAG_MSUP, 0, NULL);
+ case EQNPOS_FROM:
+ post = print_otag(p, TAG_MUNDER, "");
break;
- case (EQNPOS_FROM):
- post = print_otag(p, TAG_MUNDER, 0, NULL);
+ case EQNPOS_SUB:
+ post = print_otag(p, TAG_MSUB, "");
break;
- case (EQNPOS_SUB):
- post = print_otag(p, TAG_MSUB, 0, NULL);
+ case EQNPOS_OVER:
+ post = print_otag(p, TAG_MFRAC, "");
break;
- case (EQNPOS_OVER):
- post = print_otag(p, TAG_MFRAC, 0, NULL);
+ case EQNPOS_FROMTO:
+ post = print_otag(p, TAG_MUNDEROVER, "");
break;
- case (EQNPOS_FROMTO):
- post = print_otag(p, TAG_MUNDEROVER, 0, NULL);
- skiptwo = 1;
+ case EQNPOS_SUBSUP:
+ post = print_otag(p, TAG_MSUBSUP, "");
break;
- case (EQNPOS_SUBSUP):
- post = print_otag(p, TAG_MSUBSUP, 0, NULL);
- skiptwo = 1;
+ 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 (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 (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 (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);
}
git.ckatri.com / mandoc.git / blobdiff