1 /* $Id: eqn.c,v 1.61 2016/01/08 00:50:45 schwarze Exp $ */
3 * Copyright (c) 2011, 2014 Kristaps Dzonsons <kristaps@bsd.lv>
4 * Copyright (c) 2014, 2015 Ingo Schwarze <schwarze@openbsd.org>
6 * Permission to use, copy, modify, and distribute this software for any
7 * purpose with or without fee is hereby granted, provided that the above
8 * copyright notice and this permission notice appear in all copies.
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
20 #include <sys/types.h>
30 #include "mandoc_aux.h"
31 #include "libmandoc.h"
34 #define EQN_NEST_MAX 128 /* maximum nesting of defines */
35 #define STRNEQ(p1, sz1, p2, sz2) \
36 ((sz1) == (sz2) && 0 == strncmp((p1), (p2), (sz1)))
88 static const char *eqn_toks[EQN_TOK__MAX] = {
89 "dyad", /* EQN_TOK_DYAD */
90 "vec", /* EQN_TOK_VEC */
91 "under", /* EQN_TOK_UNDER */
92 "bar", /* EQN_TOK_BAR */
93 "tilde", /* EQN_TOK_TILDE */
94 "hat", /* EQN_TOK_HAT */
95 "dot", /* EQN_TOK_DOT */
96 "dotdot", /* EQN_TOK_DOTDOT */
97 "fwd", /* EQN_TOK_FWD * */
98 "back", /* EQN_TOK_BACK */
99 "down", /* EQN_TOK_DOWN */
100 "up", /* EQN_TOK_UP */
101 "fat", /* EQN_TOK_FAT */
102 "roman", /* EQN_TOK_ROMAN */
103 "italic", /* EQN_TOK_ITALIC */
104 "bold", /* EQN_TOK_BOLD */
105 "size", /* EQN_TOK_SIZE */
106 "sub", /* EQN_TOK_SUB */
107 "sup", /* EQN_TOK_SUP */
108 "sqrt", /* EQN_TOK_SQRT */
109 "over", /* EQN_TOK_OVER */
110 "from", /* EQN_TOK_FROM */
111 "to", /* EQN_TOK_TO */
112 "{", /* EQN_TOK_BRACE_OPEN */
113 "}", /* EQN_TOK_BRACE_CLOSE */
114 "gsize", /* EQN_TOK_GSIZE */
115 "gfont", /* EQN_TOK_GFONT */
116 "mark", /* EQN_TOK_MARK */
117 "lineup", /* EQN_TOK_LINEUP */
118 "left", /* EQN_TOK_LEFT */
119 "right", /* EQN_TOK_RIGHT */
120 "pile", /* EQN_TOK_PILE */
121 "lpile", /* EQN_TOK_LPILE */
122 "rpile", /* EQN_TOK_RPILE */
123 "cpile", /* EQN_TOK_CPILE */
124 "matrix", /* EQN_TOK_MATRIX */
125 "ccol", /* EQN_TOK_CCOL */
126 "lcol", /* EQN_TOK_LCOL */
127 "rcol", /* EQN_TOK_RCOL */
128 "delim", /* EQN_TOK_DELIM */
129 "define", /* EQN_TOK_DEFINE */
130 "tdefine", /* EQN_TOK_TDEFINE */
131 "ndefine", /* EQN_TOK_NDEFINE */
132 "undef", /* EQN_TOK_UNDEF */
133 NULL, /* EQN_TOK_EOF */
134 "above", /* EQN_TOK_ABOVE */
206 static const struct eqnsym eqnsyms[EQNSYM__MAX] = {
207 { "alpha", "*a" }, /* EQNSYM_alpha */
208 { "beta", "*b" }, /* EQNSYM_beta */
209 { "chi", "*x" }, /* EQNSYM_chi */
210 { "delta", "*d" }, /* EQNSYM_delta */
211 { "epsilon", "*e" }, /* EQNSYM_epsilon */
212 { "eta", "*y" }, /* EQNSYM_eta */
213 { "gamma", "*g" }, /* EQNSYM_gamma */
214 { "iota", "*i" }, /* EQNSYM_iota */
215 { "kappa", "*k" }, /* EQNSYM_kappa */
216 { "lambda", "*l" }, /* EQNSYM_lambda */
217 { "mu", "*m" }, /* EQNSYM_mu */
218 { "nu", "*n" }, /* EQNSYM_nu */
219 { "omega", "*w" }, /* EQNSYM_omega */
220 { "omicron", "*o" }, /* EQNSYM_omicron */
221 { "phi", "*f" }, /* EQNSYM_phi */
222 { "pi", "*p" }, /* EQNSYM_pi */
223 { "psi", "*q" }, /* EQNSYM_psi */
224 { "rho", "*r" }, /* EQNSYM_rho */
225 { "sigma", "*s" }, /* EQNSYM_sigma */
226 { "tau", "*t" }, /* EQNSYM_tau */
227 { "theta", "*h" }, /* EQNSYM_theta */
228 { "upsilon", "*u" }, /* EQNSYM_upsilon */
229 { "xi", "*c" }, /* EQNSYM_xi */
230 { "zeta", "*z" }, /* EQNSYM_zeta */
231 { "DELTA", "*D" }, /* EQNSYM_DELTA */
232 { "GAMMA", "*G" }, /* EQNSYM_GAMMA */
233 { "LAMBDA", "*L" }, /* EQNSYM_LAMBDA */
234 { "OMEGA", "*W" }, /* EQNSYM_OMEGA */
235 { "PHI", "*F" }, /* EQNSYM_PHI */
236 { "PI", "*P" }, /* EQNSYM_PI */
237 { "PSI", "*Q" }, /* EQNSYM_PSI */
238 { "SIGMA", "*S" }, /* EQNSYM_SIGMA */
239 { "THETA", "*H" }, /* EQNSYM_THETA */
240 { "UPSILON", "*U" }, /* EQNSYM_UPSILON */
241 { "XI", "*C" }, /* EQNSYM_XI */
242 { "inter", "ca" }, /* EQNSYM_inter */
243 { "union", "cu" }, /* EQNSYM_union */
244 { "prod", "product" }, /* EQNSYM_prod */
245 { "int", "integral" }, /* EQNSYM_int */
246 { "sum", "sum" }, /* EQNSYM_sum */
247 { "grad", "gr" }, /* EQNSYM_grad */
248 { "del", "gr" }, /* EQNSYM_del */
249 { "times", "mu" }, /* EQNSYM_times */
250 { "cdot", "pc" }, /* EQNSYM_cdot */
251 { "nothing", "&" }, /* EQNSYM_nothing */
252 { "approx", "~~" }, /* EQNSYM_approx */
253 { "prime", "fm" }, /* EQNSYM_prime */
254 { "half", "12" }, /* EQNSYM_half */
255 { "partial", "pd" }, /* EQNSYM_partial */
256 { "inf", "if" }, /* EQNSYM_inf */
257 { ">>", ">>" }, /* EQNSYM_muchgreat */
258 { "<<", "<<" }, /* EQNSYM_muchless */
259 { "<-", "<-" }, /* EQNSYM_larrow */
260 { "->", "->" }, /* EQNSYM_rarrow */
261 { "+-", "+-" }, /* EQNSYM_pm */
262 { "!=", "!=" }, /* EQNSYM_nequal */
263 { "==", "==" }, /* EQNSYM_equiv */
264 { "<=", "<=" }, /* EQNSYM_lessequal */
265 { ">=", ">=" }, /* EQNSYM_moreequal */
266 { "-", "mi" }, /* EQNSYM_minus */
269 static struct eqn_box *eqn_box_alloc(struct eqn_node *, struct eqn_box *);
270 static void eqn_box_free(struct eqn_box *);
271 static struct eqn_box *eqn_box_makebinary(struct eqn_node *,
272 enum eqn_post, struct eqn_box *);
273 static void eqn_def(struct eqn_node *);
274 static struct eqn_def *eqn_def_find(struct eqn_node *, const char *, size_t);
275 static void eqn_delim(struct eqn_node *);
276 static const char *eqn_next(struct eqn_node *, char, size_t *, int);
277 static const char *eqn_nextrawtok(struct eqn_node *, size_t *);
278 static const char *eqn_nexttok(struct eqn_node *, size_t *);
279 static enum rofferr eqn_parse(struct eqn_node *, struct eqn_box *);
280 static enum eqn_tok eqn_tok_parse(struct eqn_node *, char **);
281 static void eqn_undef(struct eqn_node *);
285 eqn_read(struct eqn_node **epp, int ln,
286 const char *p, int pos, int *offs)
295 * If we're the terminating mark, unset our equation status and
296 * validate the full equation.
299 if (0 == strncmp(p, ".EN", 3)) {
302 while (' ' == *p || '\t' == *p)
306 mandoc_vmsg(MANDOCERR_ARG_SKIP, ep->parse,
307 ln, pos, "EN %s", p);
312 * Build up the full string, replacing all newlines with regular
316 sz = strlen(p + pos) + 1;
317 ep->data = mandoc_realloc(ep->data, ep->sz + sz + 1);
319 /* First invocation: nil terminate the string. */
325 strlcat(ep->data, p + pos, ep->sz + 1);
326 strlcat(ep->data, " ", ep->sz + 1);
331 eqn_alloc(int pos, int line, struct mparse *parse)
335 p = mandoc_calloc(1, sizeof(struct eqn_node));
340 p->gsize = EQN_DEFSIZE;
346 * Find the key "key" of the give size within our eqn-defined values.
348 static struct eqn_def *
349 eqn_def_find(struct eqn_node *ep, const char *key, size_t sz)
353 for (i = 0; i < (int)ep->defsz; i++)
354 if (ep->defs[i].keysz && STRNEQ(ep->defs[i].key,
355 ep->defs[i].keysz, key, sz))
362 * Get the next token from the input stream using the given quote
364 * Optionally make any replacements.
367 eqn_next(struct eqn_node *ep, char quote, size_t *sz, int repl)
380 /* Prevent self-definitions. */
382 if (lim >= EQN_NEST_MAX) {
383 mandoc_msg(MANDOCERR_ROFFLOOP, ep->parse,
384 ep->eqn.ln, ep->eqn.pos, NULL);
389 start = &ep->data[(int)ep->cur];
395 if (quote == *start) {
400 start = &ep->data[(int)ep->cur];
403 if ('{' == *start || '}' == *start)
406 ssz = strcspn(start + 1, " ^~\"{}\t") + 1;
407 next = start + (int)ssz;
411 next = strchr(start, quote);
414 *sz = (size_t)(next - start);
418 while (' ' == ep->data[(int)ep->cur] ||
419 '\t' == ep->data[(int)ep->cur] ||
420 '^' == ep->data[(int)ep->cur] ||
421 '~' == ep->data[(int)ep->cur])
425 mandoc_msg(MANDOCERR_ARG_QUOTE, ep->parse,
426 ep->eqn.ln, ep->eqn.pos, NULL);
427 next = strchr(start, '\0');
428 *sz = (size_t)(next - start);
432 /* Quotes aren't expanded for values. */
437 if (NULL != (def = eqn_def_find(ep, start, *sz))) {
438 diff = def->valsz - *sz;
440 if (def->valsz > *sz) {
442 ep->data = mandoc_realloc(ep->data, ep->sz + 1);
443 ep->data[ep->sz] = '\0';
444 start = &ep->data[(int)ep->rew];
447 diff = def->valsz - *sz;
448 memmove(start + *sz + diff, start + *sz,
449 (strlen(start) - *sz) + 1);
450 memcpy(start, def->val, def->valsz);
459 * Get the next delimited token using the default current quote
463 eqn_nexttok(struct eqn_node *ep, size_t *sz)
466 return eqn_next(ep, '"', sz, 1);
470 * Get next token without replacement.
473 eqn_nextrawtok(struct eqn_node *ep, size_t *sz)
476 return eqn_next(ep, '"', sz, 0);
480 * Parse a token from the stream of text.
481 * A token consists of one of the recognised eqn(7) strings.
482 * Strings are separated by delimiting marks.
483 * This returns EQN_TOK_EOF when there are no more tokens.
484 * If the token is an unrecognised string literal, then it returns
485 * EQN_TOK__MAX and sets the "p" pointer to an allocated, nil-terminated
487 * This must be later freed with free(3).
490 eqn_tok_parse(struct eqn_node *ep, char **p)
499 quoted = ep->data[ep->cur] == '"';
501 if (NULL == (start = eqn_nexttok(ep, &sz)))
506 *p = mandoc_strndup(start, sz);
510 for (i = 0; i < EQN_TOK__MAX; i++) {
511 if (NULL == eqn_toks[i])
513 if (STRNEQ(start, sz, eqn_toks[i], strlen(eqn_toks[i])))
517 if (i == EQN_TOK__MAX && NULL != p)
518 *p = mandoc_strndup(start, sz);
524 eqn_box_free(struct eqn_box *bp)
528 eqn_box_free(bp->first);
530 eqn_box_free(bp->next);
541 * Allocate a box as the last child of the parent node.
543 static struct eqn_box *
544 eqn_box_alloc(struct eqn_node *ep, struct eqn_box *parent)
548 bp = mandoc_calloc(1, sizeof(struct eqn_box));
551 bp->expectargs = UINT_MAX;
552 bp->size = ep->gsize;
554 if (NULL != parent->first) {
555 parent->last->next = bp;
556 bp->prev = parent->last;
565 * Reparent the current last node (of the current parent) under a new
566 * EQN_SUBEXPR as the first element.
567 * Then return the new parent.
568 * The new EQN_SUBEXPR will have a two-child limit.
570 static struct eqn_box *
571 eqn_box_makebinary(struct eqn_node *ep,
572 enum eqn_post pos, struct eqn_box *parent)
574 struct eqn_box *b, *newb;
576 assert(NULL != parent->last);
578 if (parent->last == parent->first)
579 parent->first = NULL;
581 parent->last = b->prev;
583 newb = eqn_box_alloc(ep, parent);
585 newb->type = EQN_SUBEXPR;
586 newb->expectargs = 2;
588 newb->first = newb->last = b;
589 newb->first->next = NULL;
595 * Parse the "delim" control statement.
598 eqn_delim(struct eqn_node *ep)
603 if ((start = eqn_nextrawtok(ep, &sz)) == NULL)
604 mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse,
605 ep->eqn.ln, ep->eqn.pos, "delim");
606 else if (strncmp(start, "off", 3) == 0)
608 else if (strncmp(start, "on", 2) == 0) {
609 if (ep->odelim && ep->cdelim)
611 } else if (start[1] != '\0') {
612 ep->odelim = start[0];
613 ep->cdelim = start[1];
619 * Undefine a previously-defined string.
622 eqn_undef(struct eqn_node *ep)
628 if ((start = eqn_nextrawtok(ep, &sz)) == NULL) {
629 mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse,
630 ep->eqn.ln, ep->eqn.pos, "undef");
633 if ((def = eqn_def_find(ep, start, sz)) == NULL)
637 def->key = def->val = NULL;
638 def->keysz = def->valsz = 0;
642 eqn_def(struct eqn_node *ep)
649 if ((start = eqn_nextrawtok(ep, &sz)) == NULL) {
650 mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse,
651 ep->eqn.ln, ep->eqn.pos, "define");
656 * Search for a key that already exists.
657 * Create a new key if none is found.
659 if (NULL == (def = eqn_def_find(ep, start, sz))) {
660 /* Find holes in string array. */
661 for (i = 0; i < (int)ep->defsz; i++)
662 if (0 == ep->defs[i].keysz)
665 if (i == (int)ep->defsz) {
667 ep->defs = mandoc_reallocarray(ep->defs,
668 ep->defsz, sizeof(struct eqn_def));
669 ep->defs[i].key = ep->defs[i].val = NULL;
674 def->key = mandoc_strndup(start, sz);
678 start = eqn_next(ep, ep->data[(int)ep->cur], &sz, 0);
680 mandoc_vmsg(MANDOCERR_REQ_EMPTY, ep->parse,
681 ep->eqn.ln, ep->eqn.pos, "define %s", def->key);
684 def->key = def->val = NULL;
685 def->keysz = def->valsz = 0;
689 def->val = mandoc_strndup(start, sz);
694 * Recursively parse an eqn(7) expression.
697 eqn_parse(struct eqn_node *ep, struct eqn_box *parent)
704 enum eqn_tok tok, subtok;
708 assert(parent != NULL);
712 * Do not add it to the high-level syntax tree.
715 if (ep->data == NULL)
719 tok = eqn_tok_parse(ep, &p);
723 case (EQN_TOK_UNDEF):
726 case (EQN_TOK_NDEFINE):
727 case (EQN_TOK_DEFINE):
730 case (EQN_TOK_TDEFINE):
731 if (eqn_nextrawtok(ep, NULL) == NULL ||
732 eqn_next(ep, ep->data[(int)ep->cur], NULL, 0) == NULL)
733 mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse,
734 ep->eqn.ln, ep->eqn.pos, "tdefine");
736 case (EQN_TOK_DELIM):
739 case (EQN_TOK_GFONT):
740 if (eqn_nextrawtok(ep, NULL) == NULL)
741 mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse,
742 ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]);
745 case (EQN_TOK_LINEUP):
750 case (EQN_TOK_UNDER):
752 case (EQN_TOK_TILDE):
755 case (EQN_TOK_DOTDOT):
756 if (parent->last == NULL) {
757 mandoc_msg(MANDOCERR_EQN_NOBOX, ep->parse,
758 ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]);
759 cur = eqn_box_alloc(ep, parent);
760 cur->type = EQN_TEXT;
761 cur->text = mandoc_strdup("");
763 parent = eqn_box_makebinary(ep, EQNPOS_NONE, parent);
764 parent->type = EQN_LISTONE;
765 parent->expectargs = 1;
767 case (EQN_TOK_DOTDOT):
768 strlcpy(sym, "\\[ad]", sizeof(sym));
771 strlcpy(sym, "\\[->]", sizeof(sym));
774 strlcpy(sym, "\\[<>]", sizeof(sym));
776 case (EQN_TOK_TILDE):
777 strlcpy(sym, "\\[a~]", sizeof(sym));
779 case (EQN_TOK_UNDER):
780 strlcpy(sym, "\\[ul]", sizeof(sym));
783 strlcpy(sym, "\\[rl]", sizeof(sym));
786 strlcpy(sym, "\\[a.]", sizeof(sym));
789 strlcpy(sym, "\\[ha]", sizeof(sym));
796 case (EQN_TOK_DOTDOT):
799 case (EQN_TOK_TILDE):
803 parent->top = mandoc_strdup(sym);
805 case (EQN_TOK_UNDER):
806 parent->bottom = mandoc_strdup(sym);
811 parent = parent->parent;
817 subtok = eqn_tok_parse(ep, NULL);
818 if (subtok != EQN_TOK__MAX) {
819 mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse,
820 ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]);
826 case (EQN_TOK_ROMAN):
827 case (EQN_TOK_ITALIC):
829 while (parent->args == parent->expectargs)
830 parent = parent->parent;
832 * These values apply to the next word or sequence of
833 * words; thus, we mark that we'll have a child with
834 * exactly one of those.
836 parent = eqn_box_alloc(ep, parent);
837 parent->type = EQN_LISTONE;
838 parent->expectargs = 1;
841 parent->font = EQNFONT_FAT;
843 case (EQN_TOK_ROMAN):
844 parent->font = EQNFONT_ROMAN;
846 case (EQN_TOK_ITALIC):
847 parent->font = EQNFONT_ITALIC;
850 parent->font = EQNFONT_BOLD;
857 case (EQN_TOK_GSIZE):
858 /* Accept two values: integral size and a single. */
859 if (NULL == (start = eqn_nexttok(ep, &sz))) {
860 mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse,
861 ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]);
864 size = mandoc_strntoi(start, sz, 10);
866 mandoc_msg(MANDOCERR_IT_NONUM, ep->parse,
867 ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]);
870 if (EQN_TOK_GSIZE == tok) {
874 parent = eqn_box_alloc(ep, parent);
875 parent->type = EQN_LISTONE;
876 parent->expectargs = 1;
884 * We have a left-right-associative expression.
885 * Repivot under a positional node, open a child scope
886 * and keep on reading.
888 if (parent->last == NULL) {
889 mandoc_msg(MANDOCERR_EQN_NOBOX, ep->parse,
890 ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]);
891 cur = eqn_box_alloc(ep, parent);
892 cur->type = EQN_TEXT;
893 cur->text = mandoc_strdup("");
895 /* Handle the "subsup" and "fromto" positions. */
896 if (EQN_TOK_SUP == tok && parent->pos == EQNPOS_SUB) {
897 parent->expectargs = 3;
898 parent->pos = EQNPOS_SUBSUP;
901 if (EQN_TOK_TO == tok && parent->pos == EQNPOS_FROM) {
902 parent->expectargs = 3;
903 parent->pos = EQNPOS_FROMTO;
922 parent = eqn_box_makebinary(ep, pos, parent);
925 while (parent->args == parent->expectargs)
926 parent = parent->parent;
928 * Accept a left-right-associative set of arguments just
929 * like sub and sup and friends but without rebalancing
932 parent = eqn_box_alloc(ep, parent);
933 parent->type = EQN_SUBEXPR;
934 parent->pos = EQNPOS_SQRT;
935 parent->expectargs = 1;
939 * We have a right-left-associative fraction.
940 * Close out anything that's currently open, then
941 * rebalance and continue reading.
943 if (parent->last == NULL) {
944 mandoc_msg(MANDOCERR_EQN_NOBOX, ep->parse,
945 ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]);
946 cur = eqn_box_alloc(ep, parent);
947 cur->type = EQN_TEXT;
948 cur->text = mandoc_strdup("");
950 while (EQN_SUBEXPR == parent->type)
951 parent = parent->parent;
952 parent = eqn_box_makebinary(ep, EQNPOS_OVER, parent);
954 case (EQN_TOK_RIGHT):
955 case (EQN_TOK_BRACE_CLOSE):
957 * Close out the existing brace.
958 * FIXME: this is a shitty sentinel: we should really
959 * have a native EQN_BRACE type or whatnot.
961 for (cur = parent; cur != NULL; cur = cur->parent)
962 if (cur->type == EQN_LIST &&
963 (tok == EQN_TOK_BRACE_CLOSE ||
967 mandoc_msg(MANDOCERR_BLK_NOTOPEN, ep->parse,
968 ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]);
972 if (EQN_TOK_RIGHT == tok) {
973 if (NULL == (start = eqn_nexttok(ep, &sz))) {
974 mandoc_msg(MANDOCERR_REQ_EMPTY,
975 ep->parse, ep->eqn.ln,
976 ep->eqn.pos, eqn_toks[tok]);
979 /* Handling depends on right/left. */
980 if (STRNEQ(start, sz, "ceiling", 7)) {
981 strlcpy(sym, "\\[rc]", sizeof(sym));
982 parent->right = mandoc_strdup(sym);
983 } else if (STRNEQ(start, sz, "floor", 5)) {
984 strlcpy(sym, "\\[rf]", sizeof(sym));
985 parent->right = mandoc_strdup(sym);
987 parent->right = mandoc_strndup(start, sz);
989 parent = parent->parent;
990 if (tok == EQN_TOK_BRACE_CLOSE &&
991 (parent->type == EQN_PILE ||
992 parent->type == EQN_MATRIX))
993 parent = parent->parent;
994 /* Close out any "singleton" lists. */
995 while (parent->type == EQN_LISTONE &&
996 parent->args == parent->expectargs)
997 parent = parent->parent;
999 case (EQN_TOK_BRACE_OPEN):
1000 case (EQN_TOK_LEFT):
1002 * If we already have something in the stack and we're
1003 * in an expression, then rewind til we're not any more
1004 * (just like with the text node).
1006 while (parent->args == parent->expectargs)
1007 parent = parent->parent;
1008 if (EQN_TOK_LEFT == tok &&
1009 (start = eqn_nexttok(ep, &sz)) == NULL) {
1010 mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse,
1011 ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]);
1014 parent = eqn_box_alloc(ep, parent);
1015 parent->type = EQN_LIST;
1016 if (EQN_TOK_LEFT == tok) {
1017 if (STRNEQ(start, sz, "ceiling", 7)) {
1018 strlcpy(sym, "\\[lc]", sizeof(sym));
1019 parent->left = mandoc_strdup(sym);
1020 } else if (STRNEQ(start, sz, "floor", 5)) {
1021 strlcpy(sym, "\\[lf]", sizeof(sym));
1022 parent->left = mandoc_strdup(sym);
1024 parent->left = mandoc_strndup(start, sz);
1027 case (EQN_TOK_PILE):
1028 case (EQN_TOK_LPILE):
1029 case (EQN_TOK_RPILE):
1030 case (EQN_TOK_CPILE):
1031 case (EQN_TOK_CCOL):
1032 case (EQN_TOK_LCOL):
1033 case (EQN_TOK_RCOL):
1034 while (parent->args == parent->expectargs)
1035 parent = parent->parent;
1036 parent = eqn_box_alloc(ep, parent);
1037 parent->type = EQN_PILE;
1038 parent->expectargs = 1;
1040 case (EQN_TOK_ABOVE):
1041 for (cur = parent; cur != NULL; cur = cur->parent)
1042 if (cur->type == EQN_PILE)
1045 mandoc_msg(MANDOCERR_IT_STRAY, ep->parse,
1046 ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]);
1049 parent = eqn_box_alloc(ep, cur);
1050 parent->type = EQN_LIST;
1052 case (EQN_TOK_MATRIX):
1053 while (parent->args == parent->expectargs)
1054 parent = parent->parent;
1055 parent = eqn_box_alloc(ep, parent);
1056 parent->type = EQN_MATRIX;
1057 parent->expectargs = 1;
1062 * TODO: make sure we're not in an open subexpression.
1066 assert(tok == EQN_TOK__MAX);
1069 * If we already have something in the stack and we're
1070 * in an expression, then rewind til we're not any more.
1072 while (parent->args == parent->expectargs)
1073 parent = parent->parent;
1074 cur = eqn_box_alloc(ep, parent);
1075 cur->type = EQN_TEXT;
1076 for (i = 0; i < EQNSYM__MAX; i++)
1077 if (0 == strcmp(eqnsyms[i].str, p)) {
1078 (void)snprintf(sym, sizeof(sym),
1079 "\\[%s]", eqnsyms[i].sym);
1080 cur->text = mandoc_strdup(sym);
1085 if (i == EQNSYM__MAX)
1088 * Post-process list status.
1090 while (parent->type == EQN_LISTONE &&
1091 parent->args == parent->expectargs)
1092 parent = parent->parent;
1099 eqn_end(struct eqn_node **epp)
1101 struct eqn_node *ep;
1106 ep->eqn.root = mandoc_calloc(1, sizeof(struct eqn_box));
1107 ep->eqn.root->expectargs = UINT_MAX;
1108 return eqn_parse(ep, ep->eqn.root);
1112 eqn_free(struct eqn_node *p)
1116 eqn_box_free(p->eqn.root);
1118 for (i = 0; i < (int)p->defsz; i++) {
1119 free(p->defs[i].key);
1120 free(p->defs[i].val);