1 /* $Id: eqn.c,v 1.62 2017/03/11 15:43:04 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)
369 static size_t last_len;
380 if (ep->cur >= last_len)
384 /* Prevent self-definitions. */
386 if (lim >= EQN_NEST_MAX) {
387 mandoc_msg(MANDOCERR_ROFFLOOP, ep->parse,
388 ep->eqn.ln, ep->eqn.pos, NULL);
393 start = &ep->data[(int)ep->cur];
399 if (quote == *start) {
404 start = &ep->data[(int)ep->cur];
407 if ('{' == *start || '}' == *start)
410 ssz = strcspn(start + 1, " ^~\"{}\t") + 1;
411 next = start + (int)ssz;
415 next = strchr(start, quote);
418 *sz = (size_t)(next - start);
422 while (' ' == ep->data[(int)ep->cur] ||
423 '\t' == ep->data[(int)ep->cur] ||
424 '^' == ep->data[(int)ep->cur] ||
425 '~' == ep->data[(int)ep->cur])
429 mandoc_msg(MANDOCERR_ARG_QUOTE, ep->parse,
430 ep->eqn.ln, ep->eqn.pos, NULL);
431 next = strchr(start, '\0');
432 *sz = (size_t)(next - start);
436 /* Quotes aren't expanded for values. */
441 if (NULL != (def = eqn_def_find(ep, start, *sz))) {
442 diff = def->valsz - *sz;
444 if (def->valsz > *sz) {
446 ep->data = mandoc_realloc(ep->data, ep->sz + 1);
447 ep->data[ep->sz] = '\0';
448 start = &ep->data[(int)ep->rew];
451 diff = def->valsz - *sz;
452 memmove(start + *sz + diff, start + *sz,
453 (strlen(start) - *sz) + 1);
454 memcpy(start, def->val, def->valsz);
455 last_len = start - ep->data + def->valsz;
464 * Get the next delimited token using the default current quote
468 eqn_nexttok(struct eqn_node *ep, size_t *sz)
471 return eqn_next(ep, '"', sz, 1);
475 * Get next token without replacement.
478 eqn_nextrawtok(struct eqn_node *ep, size_t *sz)
481 return eqn_next(ep, '"', sz, 0);
485 * Parse a token from the stream of text.
486 * A token consists of one of the recognised eqn(7) strings.
487 * Strings are separated by delimiting marks.
488 * This returns EQN_TOK_EOF when there are no more tokens.
489 * If the token is an unrecognised string literal, then it returns
490 * EQN_TOK__MAX and sets the "p" pointer to an allocated, nil-terminated
492 * This must be later freed with free(3).
495 eqn_tok_parse(struct eqn_node *ep, char **p)
504 quoted = ep->data[ep->cur] == '"';
506 if (NULL == (start = eqn_nexttok(ep, &sz)))
511 *p = mandoc_strndup(start, sz);
515 for (i = 0; i < EQN_TOK__MAX; i++) {
516 if (NULL == eqn_toks[i])
518 if (STRNEQ(start, sz, eqn_toks[i], strlen(eqn_toks[i])))
522 if (i == EQN_TOK__MAX && NULL != p)
523 *p = mandoc_strndup(start, sz);
529 eqn_box_free(struct eqn_box *bp)
533 eqn_box_free(bp->first);
535 eqn_box_free(bp->next);
546 * Allocate a box as the last child of the parent node.
548 static struct eqn_box *
549 eqn_box_alloc(struct eqn_node *ep, struct eqn_box *parent)
553 bp = mandoc_calloc(1, sizeof(struct eqn_box));
556 bp->expectargs = UINT_MAX;
557 bp->size = ep->gsize;
559 if (NULL != parent->first) {
560 parent->last->next = bp;
561 bp->prev = parent->last;
570 * Reparent the current last node (of the current parent) under a new
571 * EQN_SUBEXPR as the first element.
572 * Then return the new parent.
573 * The new EQN_SUBEXPR will have a two-child limit.
575 static struct eqn_box *
576 eqn_box_makebinary(struct eqn_node *ep,
577 enum eqn_post pos, struct eqn_box *parent)
579 struct eqn_box *b, *newb;
581 assert(NULL != parent->last);
583 if (parent->last == parent->first)
584 parent->first = NULL;
586 parent->last = b->prev;
588 newb = eqn_box_alloc(ep, parent);
590 newb->type = EQN_SUBEXPR;
591 newb->expectargs = 2;
593 newb->first = newb->last = b;
594 newb->first->next = NULL;
600 * Parse the "delim" control statement.
603 eqn_delim(struct eqn_node *ep)
608 if ((start = eqn_nextrawtok(ep, &sz)) == NULL)
609 mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse,
610 ep->eqn.ln, ep->eqn.pos, "delim");
611 else if (strncmp(start, "off", 3) == 0)
613 else if (strncmp(start, "on", 2) == 0) {
614 if (ep->odelim && ep->cdelim)
616 } else if (start[1] != '\0') {
617 ep->odelim = start[0];
618 ep->cdelim = start[1];
624 * Undefine a previously-defined string.
627 eqn_undef(struct eqn_node *ep)
633 if ((start = eqn_nextrawtok(ep, &sz)) == NULL) {
634 mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse,
635 ep->eqn.ln, ep->eqn.pos, "undef");
638 if ((def = eqn_def_find(ep, start, sz)) == NULL)
642 def->key = def->val = NULL;
643 def->keysz = def->valsz = 0;
647 eqn_def(struct eqn_node *ep)
654 if ((start = eqn_nextrawtok(ep, &sz)) == NULL) {
655 mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse,
656 ep->eqn.ln, ep->eqn.pos, "define");
661 * Search for a key that already exists.
662 * Create a new key if none is found.
664 if (NULL == (def = eqn_def_find(ep, start, sz))) {
665 /* Find holes in string array. */
666 for (i = 0; i < (int)ep->defsz; i++)
667 if (0 == ep->defs[i].keysz)
670 if (i == (int)ep->defsz) {
672 ep->defs = mandoc_reallocarray(ep->defs,
673 ep->defsz, sizeof(struct eqn_def));
674 ep->defs[i].key = ep->defs[i].val = NULL;
679 def->key = mandoc_strndup(start, sz);
683 start = eqn_next(ep, ep->data[(int)ep->cur], &sz, 0);
685 mandoc_vmsg(MANDOCERR_REQ_EMPTY, ep->parse,
686 ep->eqn.ln, ep->eqn.pos, "define %s", def->key);
689 def->key = def->val = NULL;
690 def->keysz = def->valsz = 0;
694 def->val = mandoc_strndup(start, sz);
699 * Recursively parse an eqn(7) expression.
702 eqn_parse(struct eqn_node *ep, struct eqn_box *parent)
709 enum eqn_tok tok, subtok;
713 assert(parent != NULL);
717 * Do not add it to the high-level syntax tree.
720 if (ep->data == NULL)
724 tok = eqn_tok_parse(ep, &p);
728 case (EQN_TOK_UNDEF):
731 case (EQN_TOK_NDEFINE):
732 case (EQN_TOK_DEFINE):
735 case (EQN_TOK_TDEFINE):
736 if (eqn_nextrawtok(ep, NULL) == NULL ||
737 eqn_next(ep, ep->data[(int)ep->cur], NULL, 0) == NULL)
738 mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse,
739 ep->eqn.ln, ep->eqn.pos, "tdefine");
741 case (EQN_TOK_DELIM):
744 case (EQN_TOK_GFONT):
745 if (eqn_nextrawtok(ep, NULL) == NULL)
746 mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse,
747 ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]);
750 case (EQN_TOK_LINEUP):
755 case (EQN_TOK_UNDER):
757 case (EQN_TOK_TILDE):
760 case (EQN_TOK_DOTDOT):
761 if (parent->last == NULL) {
762 mandoc_msg(MANDOCERR_EQN_NOBOX, ep->parse,
763 ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]);
764 cur = eqn_box_alloc(ep, parent);
765 cur->type = EQN_TEXT;
766 cur->text = mandoc_strdup("");
768 parent = eqn_box_makebinary(ep, EQNPOS_NONE, parent);
769 parent->type = EQN_LISTONE;
770 parent->expectargs = 1;
772 case (EQN_TOK_DOTDOT):
773 strlcpy(sym, "\\[ad]", sizeof(sym));
776 strlcpy(sym, "\\[->]", sizeof(sym));
779 strlcpy(sym, "\\[<>]", sizeof(sym));
781 case (EQN_TOK_TILDE):
782 strlcpy(sym, "\\[a~]", sizeof(sym));
784 case (EQN_TOK_UNDER):
785 strlcpy(sym, "\\[ul]", sizeof(sym));
788 strlcpy(sym, "\\[rl]", sizeof(sym));
791 strlcpy(sym, "\\[a.]", sizeof(sym));
794 strlcpy(sym, "\\[ha]", sizeof(sym));
801 case (EQN_TOK_DOTDOT):
804 case (EQN_TOK_TILDE):
808 parent->top = mandoc_strdup(sym);
810 case (EQN_TOK_UNDER):
811 parent->bottom = mandoc_strdup(sym);
816 parent = parent->parent;
822 subtok = eqn_tok_parse(ep, NULL);
823 if (subtok != EQN_TOK__MAX) {
824 mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse,
825 ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]);
831 case (EQN_TOK_ROMAN):
832 case (EQN_TOK_ITALIC):
834 while (parent->args == parent->expectargs)
835 parent = parent->parent;
837 * These values apply to the next word or sequence of
838 * words; thus, we mark that we'll have a child with
839 * exactly one of those.
841 parent = eqn_box_alloc(ep, parent);
842 parent->type = EQN_LISTONE;
843 parent->expectargs = 1;
846 parent->font = EQNFONT_FAT;
848 case (EQN_TOK_ROMAN):
849 parent->font = EQNFONT_ROMAN;
851 case (EQN_TOK_ITALIC):
852 parent->font = EQNFONT_ITALIC;
855 parent->font = EQNFONT_BOLD;
862 case (EQN_TOK_GSIZE):
863 /* Accept two values: integral size and a single. */
864 if (NULL == (start = eqn_nexttok(ep, &sz))) {
865 mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse,
866 ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]);
869 size = mandoc_strntoi(start, sz, 10);
871 mandoc_msg(MANDOCERR_IT_NONUM, ep->parse,
872 ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]);
875 if (EQN_TOK_GSIZE == tok) {
879 parent = eqn_box_alloc(ep, parent);
880 parent->type = EQN_LISTONE;
881 parent->expectargs = 1;
889 * We have a left-right-associative expression.
890 * Repivot under a positional node, open a child scope
891 * and keep on reading.
893 if (parent->last == NULL) {
894 mandoc_msg(MANDOCERR_EQN_NOBOX, ep->parse,
895 ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]);
896 cur = eqn_box_alloc(ep, parent);
897 cur->type = EQN_TEXT;
898 cur->text = mandoc_strdup("");
900 /* Handle the "subsup" and "fromto" positions. */
901 if (EQN_TOK_SUP == tok && parent->pos == EQNPOS_SUB) {
902 parent->expectargs = 3;
903 parent->pos = EQNPOS_SUBSUP;
906 if (EQN_TOK_TO == tok && parent->pos == EQNPOS_FROM) {
907 parent->expectargs = 3;
908 parent->pos = EQNPOS_FROMTO;
927 parent = eqn_box_makebinary(ep, pos, parent);
930 while (parent->args == parent->expectargs)
931 parent = parent->parent;
933 * Accept a left-right-associative set of arguments just
934 * like sub and sup and friends but without rebalancing
937 parent = eqn_box_alloc(ep, parent);
938 parent->type = EQN_SUBEXPR;
939 parent->pos = EQNPOS_SQRT;
940 parent->expectargs = 1;
944 * We have a right-left-associative fraction.
945 * Close out anything that's currently open, then
946 * rebalance and continue reading.
948 if (parent->last == NULL) {
949 mandoc_msg(MANDOCERR_EQN_NOBOX, ep->parse,
950 ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]);
951 cur = eqn_box_alloc(ep, parent);
952 cur->type = EQN_TEXT;
953 cur->text = mandoc_strdup("");
955 while (EQN_SUBEXPR == parent->type)
956 parent = parent->parent;
957 parent = eqn_box_makebinary(ep, EQNPOS_OVER, parent);
959 case (EQN_TOK_RIGHT):
960 case (EQN_TOK_BRACE_CLOSE):
962 * Close out the existing brace.
963 * FIXME: this is a shitty sentinel: we should really
964 * have a native EQN_BRACE type or whatnot.
966 for (cur = parent; cur != NULL; cur = cur->parent)
967 if (cur->type == EQN_LIST &&
968 (tok == EQN_TOK_BRACE_CLOSE ||
972 mandoc_msg(MANDOCERR_BLK_NOTOPEN, ep->parse,
973 ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]);
977 if (EQN_TOK_RIGHT == tok) {
978 if (NULL == (start = eqn_nexttok(ep, &sz))) {
979 mandoc_msg(MANDOCERR_REQ_EMPTY,
980 ep->parse, ep->eqn.ln,
981 ep->eqn.pos, eqn_toks[tok]);
984 /* Handling depends on right/left. */
985 if (STRNEQ(start, sz, "ceiling", 7)) {
986 strlcpy(sym, "\\[rc]", sizeof(sym));
987 parent->right = mandoc_strdup(sym);
988 } else if (STRNEQ(start, sz, "floor", 5)) {
989 strlcpy(sym, "\\[rf]", sizeof(sym));
990 parent->right = mandoc_strdup(sym);
992 parent->right = mandoc_strndup(start, sz);
994 parent = parent->parent;
995 if (tok == EQN_TOK_BRACE_CLOSE &&
996 (parent->type == EQN_PILE ||
997 parent->type == EQN_MATRIX))
998 parent = parent->parent;
999 /* Close out any "singleton" lists. */
1000 while (parent->type == EQN_LISTONE &&
1001 parent->args == parent->expectargs)
1002 parent = parent->parent;
1004 case (EQN_TOK_BRACE_OPEN):
1005 case (EQN_TOK_LEFT):
1007 * If we already have something in the stack and we're
1008 * in an expression, then rewind til we're not any more
1009 * (just like with the text node).
1011 while (parent->args == parent->expectargs)
1012 parent = parent->parent;
1013 if (EQN_TOK_LEFT == tok &&
1014 (start = eqn_nexttok(ep, &sz)) == NULL) {
1015 mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse,
1016 ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]);
1019 parent = eqn_box_alloc(ep, parent);
1020 parent->type = EQN_LIST;
1021 if (EQN_TOK_LEFT == tok) {
1022 if (STRNEQ(start, sz, "ceiling", 7)) {
1023 strlcpy(sym, "\\[lc]", sizeof(sym));
1024 parent->left = mandoc_strdup(sym);
1025 } else if (STRNEQ(start, sz, "floor", 5)) {
1026 strlcpy(sym, "\\[lf]", sizeof(sym));
1027 parent->left = mandoc_strdup(sym);
1029 parent->left = mandoc_strndup(start, sz);
1032 case (EQN_TOK_PILE):
1033 case (EQN_TOK_LPILE):
1034 case (EQN_TOK_RPILE):
1035 case (EQN_TOK_CPILE):
1036 case (EQN_TOK_CCOL):
1037 case (EQN_TOK_LCOL):
1038 case (EQN_TOK_RCOL):
1039 while (parent->args == parent->expectargs)
1040 parent = parent->parent;
1041 parent = eqn_box_alloc(ep, parent);
1042 parent->type = EQN_PILE;
1043 parent->expectargs = 1;
1045 case (EQN_TOK_ABOVE):
1046 for (cur = parent; cur != NULL; cur = cur->parent)
1047 if (cur->type == EQN_PILE)
1050 mandoc_msg(MANDOCERR_IT_STRAY, ep->parse,
1051 ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]);
1054 parent = eqn_box_alloc(ep, cur);
1055 parent->type = EQN_LIST;
1057 case (EQN_TOK_MATRIX):
1058 while (parent->args == parent->expectargs)
1059 parent = parent->parent;
1060 parent = eqn_box_alloc(ep, parent);
1061 parent->type = EQN_MATRIX;
1062 parent->expectargs = 1;
1067 * TODO: make sure we're not in an open subexpression.
1071 assert(tok == EQN_TOK__MAX);
1074 * If we already have something in the stack and we're
1075 * in an expression, then rewind til we're not any more.
1077 while (parent->args == parent->expectargs)
1078 parent = parent->parent;
1079 cur = eqn_box_alloc(ep, parent);
1080 cur->type = EQN_TEXT;
1081 for (i = 0; i < EQNSYM__MAX; i++)
1082 if (0 == strcmp(eqnsyms[i].str, p)) {
1083 (void)snprintf(sym, sizeof(sym),
1084 "\\[%s]", eqnsyms[i].sym);
1085 cur->text = mandoc_strdup(sym);
1090 if (i == EQNSYM__MAX)
1093 * Post-process list status.
1095 while (parent->type == EQN_LISTONE &&
1096 parent->args == parent->expectargs)
1097 parent = parent->parent;
1104 eqn_end(struct eqn_node **epp)
1106 struct eqn_node *ep;
1111 ep->eqn.root = mandoc_calloc(1, sizeof(struct eqn_box));
1112 ep->eqn.root->expectargs = UINT_MAX;
1113 return eqn_parse(ep, ep->eqn.root);
1117 eqn_free(struct eqn_node *p)
1121 eqn_box_free(p->eqn.root);
1123 for (i = 0; i < (int)p->defsz; i++) {
1124 free(p->defs[i].key);
1125 free(p->defs[i].val);