static enum eqn_rest eqn_eqn(struct eqn_node *ep, struct eqn_box *last) { struct eqn_box *bp; enum eqn_rest c; bp = eqn_box_alloc(ep, last); bp->type = EQN_SUBEXPR; while (EQN_OK == (c = eqn_box(ep, bp))) /* Spin! */ ; return(c); }
static enum eqn_rest eqn_matrix(struct eqn_node *ep, struct eqn_box *last) { struct eqn_box *bp; const char *start; size_t sz; enum eqn_rest c; bp = eqn_box_alloc(ep, last); bp->type = EQN_MATRIX; if (NULL == (start = eqn_nexttok(ep, &sz))) { EQN_MSG(MANDOCERR_EQNEOF, ep); return(EQN_ERR); } if ( ! STRNEQ(start, sz, "{", 1)) { EQN_MSG(MANDOCERR_EQNSYNT, ep); return(EQN_ERR); } while (EQN_OK == (c = eqn_box(ep, bp))) switch (bp->last->pile) { case (EQNPILE_LCOL): /* FALLTHROUGH */ case (EQNPILE_CCOL): /* FALLTHROUGH */ case (EQNPILE_RCOL): continue; default: EQN_MSG(MANDOCERR_EQNSYNT, ep); return(EQN_ERR); }; if (EQN_DESCOPE != c) { if (EQN_EOF == c) EQN_MSG(MANDOCERR_EQNEOF, ep); return(EQN_ERR); } eqn_rewind(ep); start = eqn_nexttok(ep, &sz); assert(start); if (STRNEQ(start, sz, "}", 1)) return(EQN_OK); EQN_MSG(MANDOCERR_EQNBADSCOPE, ep); return(EQN_ERR); }
static enum eqn_rest eqn_list(struct eqn_node *ep, struct eqn_box *last) { struct eqn_box *bp; const char *start; size_t sz; enum eqn_rest c; bp = eqn_box_alloc(ep, last); bp->type = EQN_LIST; if (NULL == (start = eqn_nexttok(ep, &sz))) { EQN_MSG(MANDOCERR_EQNEOF, ep); return(EQN_ERR); } if ( ! STRNEQ(start, sz, "{", 1)) { EQN_MSG(MANDOCERR_EQNSYNT, ep); return(EQN_ERR); } while (EQN_DESCOPE == (c = eqn_eqn(ep, bp))) { eqn_rewind(ep); start = eqn_nexttok(ep, &sz); assert(start); if ( ! STRNEQ(start, sz, "above", 5)) break; } if (EQN_DESCOPE != c) { if (EQN_ERR != c) EQN_MSG(MANDOCERR_EQNSCOPE, ep); return(EQN_ERR); } eqn_rewind(ep); start = eqn_nexttok(ep, &sz); assert(start); if (STRNEQ(start, sz, "}", 1)) return(EQN_OK); EQN_MSG(MANDOCERR_EQNBADSCOPE, ep); return(EQN_ERR); }
/* * Reparent the current last node (of the current parent) under a new * EQN_SUBEXPR as the first element. * Then return the new parent. * The new EQN_SUBEXPR will have a two-child limit. */ static struct eqn_box * eqn_box_makebinary(struct eqn_node *ep, enum eqn_post pos, struct eqn_box *parent) { struct eqn_box *b, *newb; assert(NULL != parent->last); b = parent->last; if (parent->last == parent->first) parent->first = NULL; parent->args--; parent->last = b->prev; b->prev = NULL; newb = eqn_box_alloc(ep, parent); newb->pos = pos; newb->type = EQN_SUBEXPR; newb->expectargs = 2; newb->args = 1; newb->first = newb->last = b; newb->first->next = NULL; b->parent = newb; return(newb); }
/* * Recursively parse an eqn(7) expression. */ static enum rofferr eqn_parse(struct eqn_node *ep, struct eqn_box *parent) { char sym[64]; struct eqn_box *cur; const char *start; char *p; size_t i, sz; enum eqn_tok tok, subtok; enum eqn_post pos; int size; assert(parent != NULL); /* * Empty equation. * Do not add it to the high-level syntax tree. */ if (ep->data == NULL) return(ROFF_IGN); next_tok: tok = eqn_tok_parse(ep, &p); this_tok: switch (tok) { case (EQN_TOK_UNDEF): eqn_undef(ep); break; case (EQN_TOK_NDEFINE): case (EQN_TOK_DEFINE): eqn_def(ep); break; case (EQN_TOK_TDEFINE): if (eqn_nextrawtok(ep, NULL) == NULL || eqn_next(ep, ep->data[(int)ep->cur], NULL, 0) == NULL) mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse, ep->eqn.ln, ep->eqn.pos, "tdefine"); break; case (EQN_TOK_DELIM): eqn_delim(ep); break; case (EQN_TOK_GFONT): if (eqn_nextrawtok(ep, NULL) == NULL) mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse, ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]); break; case (EQN_TOK_MARK): case (EQN_TOK_LINEUP): /* Ignore these. */ break; case (EQN_TOK_DYAD): case (EQN_TOK_VEC): case (EQN_TOK_UNDER): case (EQN_TOK_BAR): case (EQN_TOK_TILDE): case (EQN_TOK_HAT): case (EQN_TOK_DOT): case (EQN_TOK_DOTDOT): if (parent->last == NULL) { mandoc_msg(MANDOCERR_EQN_NOBOX, ep->parse, ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]); cur = eqn_box_alloc(ep, parent); cur->type = EQN_TEXT; cur->text = mandoc_strdup(""); } parent = eqn_box_makebinary(ep, EQNPOS_NONE, parent); parent->type = EQN_LISTONE; parent->expectargs = 1; switch (tok) { case (EQN_TOK_DOTDOT): strlcpy(sym, "\\[ad]", sizeof(sym)); break; case (EQN_TOK_VEC): strlcpy(sym, "\\[->]", sizeof(sym)); break; case (EQN_TOK_DYAD): strlcpy(sym, "\\[<>]", sizeof(sym)); break; case (EQN_TOK_TILDE): strlcpy(sym, "\\[a~]", sizeof(sym)); break; case (EQN_TOK_UNDER): strlcpy(sym, "\\[ul]", sizeof(sym)); break; case (EQN_TOK_BAR): strlcpy(sym, "\\[rl]", sizeof(sym)); break; case (EQN_TOK_DOT): strlcpy(sym, "\\[a.]", sizeof(sym)); break; case (EQN_TOK_HAT): strlcpy(sym, "\\[ha]", sizeof(sym)); break; default: abort(); } switch (tok) { case (EQN_TOK_DOTDOT): case (EQN_TOK_VEC): case (EQN_TOK_DYAD): case (EQN_TOK_TILDE): case (EQN_TOK_BAR): case (EQN_TOK_DOT): case (EQN_TOK_HAT): parent->top = mandoc_strdup(sym); break; case (EQN_TOK_UNDER): parent->bottom = mandoc_strdup(sym); break; default: abort(); } parent = parent->parent; break; case (EQN_TOK_FWD): case (EQN_TOK_BACK): case (EQN_TOK_DOWN): case (EQN_TOK_UP): subtok = eqn_tok_parse(ep, NULL); if (subtok != EQN_TOK__MAX) { mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse, ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]); tok = subtok; goto this_tok; } break; case (EQN_TOK_FAT): case (EQN_TOK_ROMAN): case (EQN_TOK_ITALIC): case (EQN_TOK_BOLD): while (parent->args == parent->expectargs) parent = parent->parent; /* * These values apply to the next word or sequence of * words; thus, we mark that we'll have a child with * exactly one of those. */ parent = eqn_box_alloc(ep, parent); parent->type = EQN_LISTONE; parent->expectargs = 1; switch (tok) { case (EQN_TOK_FAT): parent->font = EQNFONT_FAT; break; case (EQN_TOK_ROMAN): parent->font = EQNFONT_ROMAN; break; case (EQN_TOK_ITALIC): parent->font = EQNFONT_ITALIC; break; case (EQN_TOK_BOLD): parent->font = EQNFONT_BOLD; break; default: abort(); } break; case (EQN_TOK_SIZE): case (EQN_TOK_GSIZE): /* Accept two values: integral size and a single. */ if (NULL == (start = eqn_nexttok(ep, &sz))) { mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse, ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]); break; } size = mandoc_strntoi(start, sz, 10); if (-1 == size) { mandoc_msg(MANDOCERR_IT_NONUM, ep->parse, ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]); break; } if (EQN_TOK_GSIZE == tok) { ep->gsize = size; break; } parent = eqn_box_alloc(ep, parent); parent->type = EQN_LISTONE; parent->expectargs = 1; parent->size = size; break; case (EQN_TOK_FROM): case (EQN_TOK_TO): case (EQN_TOK_SUB): case (EQN_TOK_SUP): /* * We have a left-right-associative expression. * Repivot under a positional node, open a child scope * and keep on reading. */ if (parent->last == NULL) { mandoc_msg(MANDOCERR_EQN_NOBOX, ep->parse, ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]); cur = eqn_box_alloc(ep, parent); cur->type = EQN_TEXT; cur->text = mandoc_strdup(""); } /* Handle the "subsup" and "fromto" positions. */ if (EQN_TOK_SUP == tok && parent->pos == EQNPOS_SUB) { parent->expectargs = 3; parent->pos = EQNPOS_SUBSUP; break; } if (EQN_TOK_TO == tok && parent->pos == EQNPOS_FROM) { parent->expectargs = 3; parent->pos = EQNPOS_FROMTO; break; } switch (tok) { case (EQN_TOK_FROM): pos = EQNPOS_FROM; break; case (EQN_TOK_TO): pos = EQNPOS_TO; break; case (EQN_TOK_SUP): pos = EQNPOS_SUP; break; case (EQN_TOK_SUB): pos = EQNPOS_SUB; break; default: abort(); } parent = eqn_box_makebinary(ep, pos, parent); break; case (EQN_TOK_SQRT): while (parent->args == parent->expectargs) parent = parent->parent; /* * Accept a left-right-associative set of arguments just * like sub and sup and friends but without rebalancing * under a pivot. */ parent = eqn_box_alloc(ep, parent); parent->type = EQN_SUBEXPR; parent->pos = EQNPOS_SQRT; parent->expectargs = 1; break; case (EQN_TOK_OVER): /* * We have a right-left-associative fraction. * Close out anything that's currently open, then * rebalance and continue reading. */ if (parent->last == NULL) { mandoc_msg(MANDOCERR_EQN_NOBOX, ep->parse, ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]); cur = eqn_box_alloc(ep, parent); cur->type = EQN_TEXT; cur->text = mandoc_strdup(""); } while (EQN_SUBEXPR == parent->type) parent = parent->parent; parent = eqn_box_makebinary(ep, EQNPOS_OVER, parent); break; case (EQN_TOK_RIGHT): case (EQN_TOK_BRACE_CLOSE): /* * Close out the existing brace. * FIXME: this is a shitty sentinel: we should really * have a native EQN_BRACE type or whatnot. */ for (cur = parent; cur != NULL; cur = cur->parent) if (cur->type == EQN_LIST && (tok == EQN_TOK_BRACE_CLOSE || cur->left != NULL)) break; if (cur == NULL) { mandoc_msg(MANDOCERR_BLK_NOTOPEN, ep->parse, ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]); break; } parent = cur; if (EQN_TOK_RIGHT == tok) { if (NULL == (start = eqn_nexttok(ep, &sz))) { mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse, ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]); break; } /* Handling depends on right/left. */ if (STRNEQ(start, sz, "ceiling", 7)) { strlcpy(sym, "\\[rc]", sizeof(sym)); parent->right = mandoc_strdup(sym); } else if (STRNEQ(start, sz, "floor", 5)) { strlcpy(sym, "\\[rf]", sizeof(sym)); parent->right = mandoc_strdup(sym); } else parent->right = mandoc_strndup(start, sz); } parent = parent->parent; if (EQN_TOK_BRACE_CLOSE == tok && parent && (parent->type == EQN_PILE || parent->type == EQN_MATRIX)) parent = parent->parent; /* Close out any "singleton" lists. */ while (parent && parent->type == EQN_LISTONE && parent->args == parent->expectargs) parent = parent->parent; break; case (EQN_TOK_BRACE_OPEN): case (EQN_TOK_LEFT): /* * If we already have something in the stack and we're * in an expression, then rewind til we're not any more * (just like with the text node). */ while (parent->args == parent->expectargs) parent = parent->parent; if (EQN_TOK_LEFT == tok && (start = eqn_nexttok(ep, &sz)) == NULL) { mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse, ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]); break; } parent = eqn_box_alloc(ep, parent); parent->type = EQN_LIST; if (EQN_TOK_LEFT == tok) { if (STRNEQ(start, sz, "ceiling", 7)) { strlcpy(sym, "\\[lc]", sizeof(sym)); parent->left = mandoc_strdup(sym); } else if (STRNEQ(start, sz, "floor", 5)) { strlcpy(sym, "\\[lf]", sizeof(sym)); parent->left = mandoc_strdup(sym); } else parent->left = mandoc_strndup(start, sz); } break; case (EQN_TOK_PILE): case (EQN_TOK_LPILE): case (EQN_TOK_RPILE): case (EQN_TOK_CPILE): case (EQN_TOK_CCOL): case (EQN_TOK_LCOL): case (EQN_TOK_RCOL): while (parent->args == parent->expectargs) parent = parent->parent; parent = eqn_box_alloc(ep, parent); parent->type = EQN_PILE; parent->expectargs = 1; break; case (EQN_TOK_ABOVE): for (cur = parent; cur != NULL; cur = cur->parent) if (cur->type == EQN_PILE) break; if (cur == NULL) { mandoc_msg(MANDOCERR_IT_STRAY, ep->parse, ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]); break; } parent = eqn_box_alloc(ep, cur); parent->type = EQN_LIST; break; case (EQN_TOK_MATRIX): while (parent->args == parent->expectargs) parent = parent->parent; parent = eqn_box_alloc(ep, parent); parent->type = EQN_MATRIX; parent->expectargs = 1; break; case (EQN_TOK_EOF): /* * End of file! * TODO: make sure we're not in an open subexpression. */ return(ROFF_EQN); default: assert(tok == EQN_TOK__MAX); assert(NULL != p); /* * If we already have something in the stack and we're * in an expression, then rewind til we're not any more. */ while (parent->args == parent->expectargs) parent = parent->parent; cur = eqn_box_alloc(ep, parent); cur->type = EQN_TEXT; for (i = 0; i < EQNSYM__MAX; i++) if (0 == strcmp(eqnsyms[i].str, p)) { (void)snprintf(sym, sizeof(sym), "\\[%s]", eqnsyms[i].sym); cur->text = mandoc_strdup(sym); free(p); break; } if (i == EQNSYM__MAX) cur->text = p; /* * Post-process list status. */ while (parent->type == EQN_LISTONE && parent->args == parent->expectargs) parent = parent->parent; break; } goto next_tok; }
static enum eqn_rest eqn_box(struct eqn_node *ep, struct eqn_box *last) { size_t sz; const char *start; char *left; char sym[64]; enum eqn_rest c; int i, size; struct eqn_box *bp; if (NULL == (start = eqn_nexttok(ep, &sz))) return(EQN_EOF); if (STRNEQ(start, sz, "}", 1)) return(EQN_DESCOPE); else if (STRNEQ(start, sz, "right", 5)) return(EQN_DESCOPE); else if (STRNEQ(start, sz, "above", 5)) return(EQN_DESCOPE); else if (STRNEQ(start, sz, "mark", 4)) return(EQN_OK); else if (STRNEQ(start, sz, "lineup", 6)) return(EQN_OK); for (i = 0; i < (int)EQN__MAX; i++) { if ( ! EQNSTREQ(&eqnparts[i].str, start, sz)) continue; return((*eqnparts[i].fp)(ep) ? EQN_OK : EQN_ERR); } if (STRNEQ(start, sz, "{", 1)) { if (EQN_DESCOPE != (c = eqn_eqn(ep, last))) { if (EQN_ERR != c) EQN_MSG(MANDOCERR_EQNSCOPE, ep); return(EQN_ERR); } eqn_rewind(ep); start = eqn_nexttok(ep, &sz); assert(start); if (STRNEQ(start, sz, "}", 1)) return(EQN_OK); EQN_MSG(MANDOCERR_EQNBADSCOPE, ep); return(EQN_ERR); } for (i = 0; i < (int)EQNPILE__MAX; i++) { if ( ! EQNSTREQ(&eqnpiles[i], start, sz)) continue; if (EQN_OK == (c = eqn_list(ep, last))) last->last->pile = (enum eqn_pilet)i; return(c); } if (STRNEQ(start, sz, "matrix", 6)) return(eqn_matrix(ep, last)); if (STRNEQ(start, sz, "left", 4)) { if (NULL == (start = eqn_nexttok(ep, &sz))) { EQN_MSG(MANDOCERR_EQNEOF, ep); return(EQN_ERR); } left = mandoc_strndup(start, sz); c = eqn_eqn(ep, last); if (last->last) last->last->left = left; else free(left); if (EQN_DESCOPE != c) return(c); assert(last->last); eqn_rewind(ep); start = eqn_nexttok(ep, &sz); assert(start); if ( ! STRNEQ(start, sz, "right", 5)) return(EQN_DESCOPE); if (NULL == (start = eqn_nexttok(ep, &sz))) { EQN_MSG(MANDOCERR_EQNEOF, ep); return(EQN_ERR); } last->last->right = mandoc_strndup(start, sz); return(EQN_OK); } for (i = 0; i < (int)EQNPOS__MAX; i++) { if ( ! EQNSTREQ(&eqnposs[i], start, sz)) continue; if (NULL == last->last) { EQN_MSG(MANDOCERR_EQNSYNT, ep); return(EQN_ERR); } last->last->pos = (enum eqn_post)i; if (EQN_EOF == (c = eqn_box(ep, last))) { EQN_MSG(MANDOCERR_EQNEOF, ep); return(EQN_ERR); } return(c); } for (i = 0; i < (int)EQNMARK__MAX; i++) { if ( ! EQNSTREQ(&eqnmarks[i], start, sz)) continue; if (NULL == last->last) { EQN_MSG(MANDOCERR_EQNSYNT, ep); return(EQN_ERR); } last->last->mark = (enum eqn_markt)i; if (EQN_EOF == (c = eqn_box(ep, last))) { EQN_MSG(MANDOCERR_EQNEOF, ep); return(EQN_ERR); } return(c); } for (i = 0; i < (int)EQNFONT__MAX; i++) { if ( ! EQNSTREQ(&eqnfonts[i], start, sz)) continue; if (EQN_EOF == (c = eqn_box(ep, last))) { EQN_MSG(MANDOCERR_EQNEOF, ep); return(EQN_ERR); } else if (EQN_OK == c) last->last->font = (enum eqn_fontt)i; return(c); } if (STRNEQ(start, sz, "size", 4)) { if (NULL == (start = eqn_nexttok(ep, &sz))) { EQN_MSG(MANDOCERR_EQNEOF, ep); return(EQN_ERR); } size = mandoc_strntoi(start, sz, 10); if (EQN_EOF == (c = eqn_box(ep, last))) { EQN_MSG(MANDOCERR_EQNEOF, ep); return(EQN_ERR); } else if (EQN_OK != c) return(c); last->last->size = size; } bp = eqn_box_alloc(ep, last); bp->type = EQN_TEXT; for (i = 0; i < (int)EQNSYM__MAX; i++) if (EQNSTREQ(&eqnsyms[i].str, start, sz)) { sym[63] = '\0'; snprintf(sym, 62, "\\[%s]", eqnsyms[i].sym); bp->text = mandoc_strdup(sym); return(EQN_OK); } bp->text = mandoc_strndup(start, sz); return(EQN_OK); }