[BACK]Return to eqn.c CVS log [TXT][DIR] Up to [cvsweb.bsd.lv] / mandoc

Annotation of mandoc/eqn.c, Revision 1.75

1.75    ! schwarze    1: /*     $Id: eqn.c,v 1.74 2017/07/06 00:19:54 schwarze Exp $ */
1.1       kristaps    2: /*
1.51      schwarze    3:  * Copyright (c) 2011, 2014 Kristaps Dzonsons <kristaps@bsd.lv>
1.64      schwarze    4:  * Copyright (c) 2014, 2015, 2017 Ingo Schwarze <schwarze@openbsd.org>
1.1       kristaps    5:  *
                      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.
                      9:  *
                     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.
                     17:  */
                     18: #include "config.h"
1.45      schwarze   19:
                     20: #include <sys/types.h>
1.1       kristaps   21:
                     22: #include <assert.h>
1.66      schwarze   23: #include <ctype.h>
1.19      kristaps   24: #include <limits.h>
1.1       kristaps   25: #include <stdio.h>
                     26: #include <stdlib.h>
                     27: #include <string.h>
                     28: #include <time.h>
                     29:
                     30: #include "mandoc.h"
1.39      schwarze   31: #include "mandoc_aux.h"
1.1       kristaps   32: #include "libmandoc.h"
                     33: #include "libroff.h"
                     34:
1.11      kristaps   35: #define        EQN_NEST_MAX     128 /* maximum nesting of defines */
1.48      kristaps   36: #define        STRNEQ(p1, sz1, p2, sz2) \
                     37:        ((sz1) == (sz2) && 0 == strncmp((p1), (p2), (sz1)))
1.8       kristaps   38:
1.48      kristaps   39: enum   eqn_tok {
                     40:        EQN_TOK_DYAD = 0,
                     41:        EQN_TOK_VEC,
                     42:        EQN_TOK_UNDER,
                     43:        EQN_TOK_BAR,
                     44:        EQN_TOK_TILDE,
                     45:        EQN_TOK_HAT,
                     46:        EQN_TOK_DOT,
                     47:        EQN_TOK_DOTDOT,
                     48:        EQN_TOK_FWD,
                     49:        EQN_TOK_BACK,
                     50:        EQN_TOK_DOWN,
                     51:        EQN_TOK_UP,
                     52:        EQN_TOK_FAT,
                     53:        EQN_TOK_ROMAN,
                     54:        EQN_TOK_ITALIC,
                     55:        EQN_TOK_BOLD,
                     56:        EQN_TOK_SIZE,
                     57:        EQN_TOK_SUB,
                     58:        EQN_TOK_SUP,
                     59:        EQN_TOK_SQRT,
                     60:        EQN_TOK_OVER,
                     61:        EQN_TOK_FROM,
                     62:        EQN_TOK_TO,
                     63:        EQN_TOK_BRACE_OPEN,
                     64:        EQN_TOK_BRACE_CLOSE,
                     65:        EQN_TOK_GSIZE,
                     66:        EQN_TOK_GFONT,
                     67:        EQN_TOK_MARK,
                     68:        EQN_TOK_LINEUP,
                     69:        EQN_TOK_LEFT,
                     70:        EQN_TOK_RIGHT,
                     71:        EQN_TOK_PILE,
                     72:        EQN_TOK_LPILE,
                     73:        EQN_TOK_RPILE,
                     74:        EQN_TOK_CPILE,
                     75:        EQN_TOK_MATRIX,
                     76:        EQN_TOK_CCOL,
                     77:        EQN_TOK_LCOL,
                     78:        EQN_TOK_RCOL,
                     79:        EQN_TOK_DELIM,
                     80:        EQN_TOK_DEFINE,
                     81:        EQN_TOK_TDEFINE,
                     82:        EQN_TOK_NDEFINE,
                     83:        EQN_TOK_UNDEF,
                     84:        EQN_TOK_ABOVE,
1.64      schwarze   85:        EQN_TOK__MAX,
                     86:        EQN_TOK_FUNC,
1.67      schwarze   87:        EQN_TOK_QUOTED,
                     88:        EQN_TOK_SYM,
1.64      schwarze   89:        EQN_TOK_EOF
1.48      kristaps   90: };
                     91:
                     92: static const char *eqn_toks[EQN_TOK__MAX] = {
                     93:        "dyad", /* EQN_TOK_DYAD */
                     94:        "vec", /* EQN_TOK_VEC */
                     95:        "under", /* EQN_TOK_UNDER */
                     96:        "bar", /* EQN_TOK_BAR */
                     97:        "tilde", /* EQN_TOK_TILDE */
                     98:        "hat", /* EQN_TOK_HAT */
                     99:        "dot", /* EQN_TOK_DOT */
                    100:        "dotdot", /* EQN_TOK_DOTDOT */
                    101:        "fwd", /* EQN_TOK_FWD * */
                    102:        "back", /* EQN_TOK_BACK */
                    103:        "down", /* EQN_TOK_DOWN */
                    104:        "up", /* EQN_TOK_UP */
                    105:        "fat", /* EQN_TOK_FAT */
                    106:        "roman", /* EQN_TOK_ROMAN */
                    107:        "italic", /* EQN_TOK_ITALIC */
                    108:        "bold", /* EQN_TOK_BOLD */
                    109:        "size", /* EQN_TOK_SIZE */
                    110:        "sub", /* EQN_TOK_SUB */
                    111:        "sup", /* EQN_TOK_SUP */
                    112:        "sqrt", /* EQN_TOK_SQRT */
                    113:        "over", /* EQN_TOK_OVER */
                    114:        "from", /* EQN_TOK_FROM */
                    115:        "to", /* EQN_TOK_TO */
                    116:        "{", /* EQN_TOK_BRACE_OPEN */
                    117:        "}", /* EQN_TOK_BRACE_CLOSE */
                    118:        "gsize", /* EQN_TOK_GSIZE */
                    119:        "gfont", /* EQN_TOK_GFONT */
                    120:        "mark", /* EQN_TOK_MARK */
                    121:        "lineup", /* EQN_TOK_LINEUP */
                    122:        "left", /* EQN_TOK_LEFT */
                    123:        "right", /* EQN_TOK_RIGHT */
                    124:        "pile", /* EQN_TOK_PILE */
                    125:        "lpile", /* EQN_TOK_LPILE */
                    126:        "rpile", /* EQN_TOK_RPILE */
                    127:        "cpile", /* EQN_TOK_CPILE */
                    128:        "matrix", /* EQN_TOK_MATRIX */
                    129:        "ccol", /* EQN_TOK_CCOL */
                    130:        "lcol", /* EQN_TOK_LCOL */
                    131:        "rcol", /* EQN_TOK_RCOL */
                    132:        "delim", /* EQN_TOK_DELIM */
                    133:        "define", /* EQN_TOK_DEFINE */
                    134:        "tdefine", /* EQN_TOK_TDEFINE */
                    135:        "ndefine", /* EQN_TOK_NDEFINE */
                    136:        "undef", /* EQN_TOK_UNDEF */
                    137:        "above", /* EQN_TOK_ABOVE */
1.20      kristaps  138: };
                    139:
1.64      schwarze  140: static const char *const eqn_func[] = {
                    141:        "acos", "acsc", "and",  "arc",  "asec", "asin", "atan",
                    142:        "cos",  "cosh", "coth", "csc",  "det",  "exp",  "for",
                    143:        "if",   "lim",  "ln",   "log",  "max",  "min",
                    144:        "sec",  "sin",  "sinh", "tan",  "tanh", "Im",   "Re",
                    145: };
                    146:
1.27      kristaps  147: enum   eqn_symt {
1.71      schwarze  148:        EQNSYM_alpha = 0,
1.27      kristaps  149:        EQNSYM_beta,
                    150:        EQNSYM_chi,
                    151:        EQNSYM_delta,
                    152:        EQNSYM_epsilon,
                    153:        EQNSYM_eta,
                    154:        EQNSYM_gamma,
                    155:        EQNSYM_iota,
                    156:        EQNSYM_kappa,
                    157:        EQNSYM_lambda,
                    158:        EQNSYM_mu,
                    159:        EQNSYM_nu,
                    160:        EQNSYM_omega,
                    161:        EQNSYM_omicron,
                    162:        EQNSYM_phi,
                    163:        EQNSYM_pi,
                    164:        EQNSYM_ps,
                    165:        EQNSYM_rho,
                    166:        EQNSYM_sigma,
                    167:        EQNSYM_tau,
                    168:        EQNSYM_theta,
                    169:        EQNSYM_upsilon,
                    170:        EQNSYM_xi,
                    171:        EQNSYM_zeta,
                    172:        EQNSYM_DELTA,
                    173:        EQNSYM_GAMMA,
                    174:        EQNSYM_LAMBDA,
                    175:        EQNSYM_OMEGA,
                    176:        EQNSYM_PHI,
                    177:        EQNSYM_PI,
                    178:        EQNSYM_PSI,
                    179:        EQNSYM_SIGMA,
                    180:        EQNSYM_THETA,
                    181:        EQNSYM_UPSILON,
                    182:        EQNSYM_XI,
1.28      kristaps  183:        EQNSYM_inter,
                    184:        EQNSYM_union,
                    185:        EQNSYM_prod,
                    186:        EQNSYM_int,
                    187:        EQNSYM_sum,
                    188:        EQNSYM_grad,
                    189:        EQNSYM_del,
                    190:        EQNSYM_times,
                    191:        EQNSYM_cdot,
                    192:        EQNSYM_nothing,
                    193:        EQNSYM_approx,
                    194:        EQNSYM_prime,
                    195:        EQNSYM_half,
                    196:        EQNSYM_partial,
                    197:        EQNSYM_inf,
                    198:        EQNSYM_muchgreat,
                    199:        EQNSYM_muchless,
                    200:        EQNSYM_larrow,
                    201:        EQNSYM_rarrow,
                    202:        EQNSYM_pm,
                    203:        EQNSYM_nequal,
                    204:        EQNSYM_equiv,
                    205:        EQNSYM_lessequal,
                    206:        EQNSYM_moreequal,
1.58      schwarze  207:        EQNSYM_minus,
1.27      kristaps  208:        EQNSYM__MAX
                    209: };
                    210:
                    211: struct eqnsym {
1.48      kristaps  212:        const char      *str;
1.28      kristaps  213:        const char      *sym;
1.27      kristaps  214: };
                    215:
                    216: static const struct eqnsym eqnsyms[EQNSYM__MAX] = {
1.48      kristaps  217:        { "alpha", "*a" }, /* EQNSYM_alpha */
                    218:        { "beta", "*b" }, /* EQNSYM_beta */
                    219:        { "chi", "*x" }, /* EQNSYM_chi */
                    220:        { "delta", "*d" }, /* EQNSYM_delta */
                    221:        { "epsilon", "*e" }, /* EQNSYM_epsilon */
                    222:        { "eta", "*y" }, /* EQNSYM_eta */
                    223:        { "gamma", "*g" }, /* EQNSYM_gamma */
                    224:        { "iota", "*i" }, /* EQNSYM_iota */
                    225:        { "kappa", "*k" }, /* EQNSYM_kappa */
                    226:        { "lambda", "*l" }, /* EQNSYM_lambda */
                    227:        { "mu", "*m" }, /* EQNSYM_mu */
                    228:        { "nu", "*n" }, /* EQNSYM_nu */
                    229:        { "omega", "*w" }, /* EQNSYM_omega */
                    230:        { "omicron", "*o" }, /* EQNSYM_omicron */
                    231:        { "phi", "*f" }, /* EQNSYM_phi */
                    232:        { "pi", "*p" }, /* EQNSYM_pi */
                    233:        { "psi", "*q" }, /* EQNSYM_psi */
                    234:        { "rho", "*r" }, /* EQNSYM_rho */
                    235:        { "sigma", "*s" }, /* EQNSYM_sigma */
                    236:        { "tau", "*t" }, /* EQNSYM_tau */
                    237:        { "theta", "*h" }, /* EQNSYM_theta */
                    238:        { "upsilon", "*u" }, /* EQNSYM_upsilon */
                    239:        { "xi", "*c" }, /* EQNSYM_xi */
                    240:        { "zeta", "*z" }, /* EQNSYM_zeta */
                    241:        { "DELTA", "*D" }, /* EQNSYM_DELTA */
                    242:        { "GAMMA", "*G" }, /* EQNSYM_GAMMA */
                    243:        { "LAMBDA", "*L" }, /* EQNSYM_LAMBDA */
                    244:        { "OMEGA", "*W" }, /* EQNSYM_OMEGA */
                    245:        { "PHI", "*F" }, /* EQNSYM_PHI */
                    246:        { "PI", "*P" }, /* EQNSYM_PI */
                    247:        { "PSI", "*Q" }, /* EQNSYM_PSI */
                    248:        { "SIGMA", "*S" }, /* EQNSYM_SIGMA */
                    249:        { "THETA", "*H" }, /* EQNSYM_THETA */
                    250:        { "UPSILON", "*U" }, /* EQNSYM_UPSILON */
                    251:        { "XI", "*C" }, /* EQNSYM_XI */
                    252:        { "inter", "ca" }, /* EQNSYM_inter */
                    253:        { "union", "cu" }, /* EQNSYM_union */
                    254:        { "prod", "product" }, /* EQNSYM_prod */
                    255:        { "int", "integral" }, /* EQNSYM_int */
                    256:        { "sum", "sum" }, /* EQNSYM_sum */
                    257:        { "grad", "gr" }, /* EQNSYM_grad */
                    258:        { "del", "gr" }, /* EQNSYM_del */
                    259:        { "times", "mu" }, /* EQNSYM_times */
                    260:        { "cdot", "pc" }, /* EQNSYM_cdot */
                    261:        { "nothing", "&" }, /* EQNSYM_nothing */
                    262:        { "approx", "~~" }, /* EQNSYM_approx */
1.58      schwarze  263:        { "prime", "fm" }, /* EQNSYM_prime */
1.48      kristaps  264:        { "half", "12" }, /* EQNSYM_half */
                    265:        { "partial", "pd" }, /* EQNSYM_partial */
                    266:        { "inf", "if" }, /* EQNSYM_inf */
                    267:        { ">>", ">>" }, /* EQNSYM_muchgreat */
                    268:        { "<<", "<<" }, /* EQNSYM_muchless */
                    269:        { "<-", "<-" }, /* EQNSYM_larrow */
                    270:        { "->", "->" }, /* EQNSYM_rarrow */
                    271:        { "+-", "+-" }, /* EQNSYM_pm */
                    272:        { "!=", "!=" }, /* EQNSYM_nequal */
                    273:        { "==", "==" }, /* EQNSYM_equiv */
                    274:        { "<=", "<=" }, /* EQNSYM_lessequal */
                    275:        { ">=", ">=" }, /* EQNSYM_moreequal */
1.58      schwarze  276:        { "-", "mi" }, /* EQNSYM_minus */
1.27      kristaps  277: };
                    278:
1.71      schwarze  279: enum   parse_mode {
                    280:        MODE_QUOTED,
                    281:        MODE_NOSUB,
                    282:        MODE_SUB,
                    283:        MODE_TOK
                    284: };
                    285:
1.57      schwarze  286: static struct eqn_box  *eqn_box_alloc(struct eqn_node *, struct eqn_box *);
                    287: static void             eqn_box_free(struct eqn_box *);
                    288: static struct eqn_box  *eqn_box_makebinary(struct eqn_node *,
1.75    ! schwarze  289:                                struct eqn_box *);
1.57      schwarze  290: static void             eqn_def(struct eqn_node *);
1.71      schwarze  291: static struct eqn_def  *eqn_def_find(struct eqn_node *);
1.57      schwarze  292: static void             eqn_delim(struct eqn_node *);
1.71      schwarze  293: static enum eqn_tok     eqn_next(struct eqn_node *, enum parse_mode);
1.57      schwarze  294: static enum rofferr     eqn_parse(struct eqn_node *, struct eqn_box *);
                    295: static void             eqn_undef(struct eqn_node *);
                    296:
                    297:
1.1       kristaps  298: enum rofferr
1.40      schwarze  299: eqn_read(struct eqn_node **epp, int ln,
1.6       kristaps  300:                const char *p, int pos, int *offs)
1.1       kristaps  301: {
1.8       kristaps  302:        size_t           sz;
                    303:        struct eqn_node *ep;
1.12      kristaps  304:        enum rofferr     er;
                    305:
                    306:        ep = *epp;
                    307:
                    308:        /*
                    309:         * If we're the terminating mark, unset our equation status and
                    310:         * validate the full equation.
                    311:         */
1.1       kristaps  312:
1.35      kristaps  313:        if (0 == strncmp(p, ".EN", 3)) {
1.38      kristaps  314:                er = eqn_end(epp);
1.35      kristaps  315:                p += 3;
                    316:                while (' ' == *p || '\t' == *p)
                    317:                        p++;
1.40      schwarze  318:                if ('\0' == *p)
1.59      schwarze  319:                        return er;
1.43      schwarze  320:                mandoc_vmsg(MANDOCERR_ARG_SKIP, ep->parse,
                    321:                    ln, pos, "EN %s", p);
1.59      schwarze  322:                return er;
1.1       kristaps  323:        }
                    324:
1.12      kristaps  325:        /*
                    326:         * Build up the full string, replacing all newlines with regular
                    327:         * whitespace.
                    328:         */
1.6       kristaps  329:
1.12      kristaps  330:        sz = strlen(p + pos) + 1;
                    331:        ep->data = mandoc_realloc(ep->data, ep->sz + sz + 1);
1.6       kristaps  332:
1.12      kristaps  333:        /* First invocation: nil terminate the string. */
1.8       kristaps  334:
1.12      kristaps  335:        if (0 == ep->sz)
                    336:                *ep->data = '\0';
1.8       kristaps  337:
1.12      kristaps  338:        ep->sz += sz;
                    339:        strlcat(ep->data, p + pos, ep->sz + 1);
                    340:        strlcat(ep->data, " ", ep->sz + 1);
1.59      schwarze  341:        return ROFF_IGN;
1.11      kristaps  342: }
                    343:
1.1       kristaps  344: struct eqn_node *
1.55      schwarze  345: eqn_alloc(int pos, int line, struct mparse *parse)
1.1       kristaps  346: {
                    347:        struct eqn_node *p;
                    348:
                    349:        p = mandoc_calloc(1, sizeof(struct eqn_node));
1.36      kristaps  350:
1.5       kristaps  351:        p->parse = parse;
1.12      kristaps  352:        p->eqn.ln = line;
1.2       kristaps  353:        p->eqn.pos = pos;
1.29      kristaps  354:        p->gsize = EQN_DEFSIZE;
1.1       kristaps  355:
1.59      schwarze  356:        return p;
1.1       kristaps  357: }
                    358:
1.48      kristaps  359: /*
                    360:  * Find the key "key" of the give size within our eqn-defined values.
                    361:  */
                    362: static struct eqn_def *
1.71      schwarze  363: eqn_def_find(struct eqn_node *ep)
1.1       kristaps  364: {
1.6       kristaps  365:        int              i;
1.1       kristaps  366:
1.48      kristaps  367:        for (i = 0; i < (int)ep->defsz; i++)
                    368:                if (ep->defs[i].keysz && STRNEQ(ep->defs[i].key,
1.71      schwarze  369:                    ep->defs[i].keysz, ep->start, ep->toksz))
1.59      schwarze  370:                        return &ep->defs[i];
1.6       kristaps  371:
1.59      schwarze  372:        return NULL;
1.20      kristaps  373: }
                    374:
1.48      kristaps  375: /*
1.71      schwarze  376:  * Parse a token from the input text.  The modes are:
                    377:  * MODE_QUOTED: Use *ep->start as the delimiter; the token ends
                    378:  *   before its next occurence.  Do not interpret the token in any
                    379:  *   way and return EQN_TOK_QUOTED.  All other modes behave like
                    380:  *   MODE_QUOTED when *ep->start is '"'.
                    381:  * MODE_NOSUB: If *ep->start is a curly brace, the token ends after it;
                    382:  *   otherwise, it ends before the next whitespace or brace.
                    383:  *   Do not interpret the token and return EQN_TOK__MAX.
                    384:  * MODE_SUB: Like MODE_NOSUB, but try to interpret the token as an
                    385:  *   alias created with define.  If it is an alias, replace it with
                    386:  *   its string value and reparse.
                    387:  * MODE_TOK: Like MODE_SUB, but also check the token against the list
                    388:  *   of tokens, and if there is a match, return that token.  Otherwise,
                    389:  *   if the token matches a symbol, return EQN_TOK_SYM; if it matches
                    390:  *   a function name, EQN_TOK_FUNC, or else EQN_TOK__MAX.  Except for
                    391:  *   a token match, *ep->start is set to an allocated string that the
                    392:  *   caller is expected to free.
                    393:  * All modes skip whitespace following the end of the token.
1.48      kristaps  394:  */
1.71      schwarze  395: static enum eqn_tok
                    396: eqn_next(struct eqn_node *ep, enum parse_mode mode)
1.6       kristaps  397: {
1.71      schwarze  398:        static int       last_len, lim;
1.62      schwarze  399:
1.12      kristaps  400:        struct eqn_def  *def;
1.71      schwarze  401:        size_t           start;
                    402:        int              diff, i, quoted;
                    403:        enum eqn_tok     tok;
1.12      kristaps  404:
1.71      schwarze  405:        /*
                    406:         * Reset the recursion counter after advancing
                    407:         * beyond the end of the previous substitution.
                    408:         */
                    409:        if (ep->end - ep->data >= last_len)
1.62      schwarze  410:                lim = 0;
1.13      kristaps  411:
1.71      schwarze  412:        ep->start = ep->end;
                    413:        quoted = mode == MODE_QUOTED;
                    414:        for (;;) {
                    415:                switch (*ep->start) {
                    416:                case '\0':
                    417:                        ep->toksz = 0;
                    418:                        return EQN_TOK_EOF;
                    419:                case '"':
                    420:                        quoted = 1;
                    421:                        break;
                    422:                default:
                    423:                        break;
                    424:                }
                    425:                if (quoted) {
                    426:                        ep->end = strchr(ep->start + 1, *ep->start);
                    427:                        ep->start++;  /* Skip opening quote. */
                    428:                        if (ep->end == NULL) {
                    429:                                mandoc_msg(MANDOCERR_ARG_QUOTE, ep->parse,
                    430:                                    ep->eqn.ln, ep->eqn.pos, NULL);
                    431:                                ep->end = strchr(ep->start, '\0');
                    432:                        }
                    433:                } else {
                    434:                        ep->end = ep->start + 1;
                    435:                        if (*ep->start != '{' && *ep->start != '}')
                    436:                                ep->end += strcspn(ep->end, " ^~\"{}\t");
                    437:                }
                    438:                ep->toksz = ep->end - ep->start;
                    439:                if (quoted && *ep->end != '\0')
                    440:                        ep->end++;  /* Skip closing quote. */
                    441:                while (*ep->end != '\0' && strchr(" \t^~", *ep->end) != NULL)
                    442:                        ep->end++;
                    443:                if (quoted)  /* Cannot return, may have to strndup. */
                    444:                        break;
                    445:                if (mode == MODE_NOSUB)
                    446:                        return EQN_TOK__MAX;
                    447:                if ((def = eqn_def_find(ep)) == NULL)
                    448:                        break;
                    449:                if (++lim > EQN_NEST_MAX) {
                    450:                        mandoc_msg(MANDOCERR_ROFFLOOP, ep->parse,
1.57      schwarze  451:                            ep->eqn.ln, ep->eqn.pos, NULL);
1.71      schwarze  452:                        return EQN_TOK_EOF;
                    453:                }
1.12      kristaps  454:
1.71      schwarze  455:                /* Replace a defined name with its string value. */
                    456:                if ((diff = def->valsz - ep->toksz) > 0) {
                    457:                        start = ep->start - ep->data;
1.12      kristaps  458:                        ep->sz += diff;
                    459:                        ep->data = mandoc_realloc(ep->data, ep->sz + 1);
1.71      schwarze  460:                        ep->start = ep->data + start;
1.12      kristaps  461:                }
1.71      schwarze  462:                if (diff)
                    463:                        memmove(ep->start + def->valsz, ep->start + ep->toksz,
                    464:                            strlen(ep->start + ep->toksz) + 1);
                    465:                memcpy(ep->start, def->val, def->valsz);
                    466:                last_len = ep->start - ep->data + def->valsz;
1.6       kristaps  467:        }
1.71      schwarze  468:        if (mode != MODE_TOK)
                    469:                return quoted ? EQN_TOK_QUOTED : EQN_TOK__MAX;
1.53      schwarze  470:        if (quoted) {
1.71      schwarze  471:                ep->start = mandoc_strndup(ep->start, ep->toksz);
1.67      schwarze  472:                return EQN_TOK_QUOTED;
1.53      schwarze  473:        }
1.71      schwarze  474:        for (tok = 0; tok < EQN_TOK__MAX; tok++)
                    475:                if (STRNEQ(ep->start, ep->toksz,
                    476:                    eqn_toks[tok], strlen(eqn_toks[tok])))
                    477:                        return tok;
1.48      kristaps  478:
1.65      schwarze  479:        for (i = 0; i < EQNSYM__MAX; i++) {
1.71      schwarze  480:                if (STRNEQ(ep->start, ep->toksz,
1.65      schwarze  481:                    eqnsyms[i].str, strlen(eqnsyms[i].str))) {
1.71      schwarze  482:                        mandoc_asprintf(&ep->start,
                    483:                            "\\[%s]", eqnsyms[i].sym);
1.67      schwarze  484:                        return EQN_TOK_SYM;
1.65      schwarze  485:                }
                    486:        }
1.71      schwarze  487:        ep->start = mandoc_strndup(ep->start, ep->toksz);
                    488:        for (i = 0; i < (int)(sizeof(eqn_func)/sizeof(*eqn_func)); i++)
                    489:                if (STRNEQ(ep->start, ep->toksz,
                    490:                    eqn_func[i], strlen(eqn_func[i])))
1.64      schwarze  491:                        return EQN_TOK_FUNC;
                    492:        return EQN_TOK__MAX;
1.48      kristaps  493: }
                    494:
                    495: static void
                    496: eqn_box_free(struct eqn_box *bp)
1.33      kristaps  497: {
                    498:
1.48      kristaps  499:        if (bp->first)
                    500:                eqn_box_free(bp->first);
                    501:        if (bp->next)
                    502:                eqn_box_free(bp->next);
1.33      kristaps  503:
1.48      kristaps  504:        free(bp->text);
                    505:        free(bp->left);
                    506:        free(bp->right);
                    507:        free(bp->top);
                    508:        free(bp->bottom);
                    509:        free(bp);
1.33      kristaps  510: }
                    511:
1.48      kristaps  512: /*
                    513:  * Allocate a box as the last child of the parent node.
                    514:  */
                    515: static struct eqn_box *
                    516: eqn_box_alloc(struct eqn_node *ep, struct eqn_box *parent)
1.8       kristaps  517: {
1.48      kristaps  518:        struct eqn_box  *bp;
                    519:
                    520:        bp = mandoc_calloc(1, sizeof(struct eqn_box));
                    521:        bp->parent = parent;
                    522:        bp->parent->args++;
                    523:        bp->expectargs = UINT_MAX;
1.68      schwarze  524:        bp->font = bp->parent->font;
1.48      kristaps  525:        bp->size = ep->gsize;
                    526:
                    527:        if (NULL != parent->first) {
                    528:                parent->last->next = bp;
                    529:                bp->prev = parent->last;
                    530:        } else
                    531:                parent->first = bp;
                    532:
                    533:        parent->last = bp;
1.59      schwarze  534:        return bp;
1.48      kristaps  535: }
1.8       kristaps  536:
1.48      kristaps  537: /*
                    538:  * Reparent the current last node (of the current parent) under a new
                    539:  * EQN_SUBEXPR as the first element.
                    540:  * Then return the new parent.
                    541:  * The new EQN_SUBEXPR will have a two-child limit.
                    542:  */
                    543: static struct eqn_box *
1.75    ! schwarze  544: eqn_box_makebinary(struct eqn_node *ep, struct eqn_box *parent)
1.48      kristaps  545: {
                    546:        struct eqn_box  *b, *newb;
1.36      kristaps  547:
1.48      kristaps  548:        assert(NULL != parent->last);
                    549:        b = parent->last;
                    550:        if (parent->last == parent->first)
                    551:                parent->first = NULL;
                    552:        parent->args--;
                    553:        parent->last = b->prev;
                    554:        b->prev = NULL;
                    555:        newb = eqn_box_alloc(ep, parent);
                    556:        newb->type = EQN_SUBEXPR;
                    557:        newb->expectargs = 2;
                    558:        newb->args = 1;
                    559:        newb->first = newb->last = b;
                    560:        newb->first->next = NULL;
                    561:        b->parent = newb;
1.59      schwarze  562:        return newb;
1.36      kristaps  563: }
                    564:
1.48      kristaps  565: /*
1.54      schwarze  566:  * Parse the "delim" control statement.
                    567:  */
                    568: static void
                    569: eqn_delim(struct eqn_node *ep)
                    570: {
1.71      schwarze  571:        if (ep->end[0] == '\0' || ep->end[1] == '\0') {
1.54      schwarze  572:                mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse,
                    573:                    ep->eqn.ln, ep->eqn.pos, "delim");
1.71      schwarze  574:                if (ep->end[0] != '\0')
                    575:                        ep->end++;
                    576:        } else if (strncmp(ep->end, "off", 3) == 0) {
1.54      schwarze  577:                ep->delim = 0;
1.71      schwarze  578:                ep->end += 3;
                    579:        } else if (strncmp(ep->end, "on", 2) == 0) {
1.54      schwarze  580:                if (ep->odelim && ep->cdelim)
                    581:                        ep->delim = 1;
1.71      schwarze  582:                ep->end += 2;
                    583:        } else {
                    584:                ep->odelim = *ep->end++;
                    585:                ep->cdelim = *ep->end++;
1.54      schwarze  586:                ep->delim = 1;
                    587:        }
                    588: }
                    589:
                    590: /*
1.48      kristaps  591:  * Undefine a previously-defined string.
                    592:  */
1.57      schwarze  593: static void
1.48      kristaps  594: eqn_undef(struct eqn_node *ep)
1.36      kristaps  595: {
1.48      kristaps  596:        struct eqn_def  *def;
1.36      kristaps  597:
1.71      schwarze  598:        if (eqn_next(ep, MODE_NOSUB) == EQN_TOK_EOF) {
1.57      schwarze  599:                mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse,
                    600:                    ep->eqn.ln, ep->eqn.pos, "undef");
                    601:                return;
                    602:        }
1.71      schwarze  603:        if ((def = eqn_def_find(ep)) == NULL)
1.57      schwarze  604:                return;
                    605:        free(def->key);
                    606:        free(def->val);
                    607:        def->key = def->val = NULL;
                    608:        def->keysz = def->valsz = 0;
1.8       kristaps  609: }
                    610:
1.57      schwarze  611: static void
1.48      kristaps  612: eqn_def(struct eqn_node *ep)
1.8       kristaps  613: {
1.12      kristaps  614:        struct eqn_def  *def;
1.8       kristaps  615:        int              i;
                    616:
1.71      schwarze  617:        if (eqn_next(ep, MODE_NOSUB) == EQN_TOK_EOF) {
1.57      schwarze  618:                mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse,
                    619:                    ep->eqn.ln, ep->eqn.pos, "define");
                    620:                return;
1.8       kristaps  621:        }
                    622:
1.40      schwarze  623:        /*
                    624:         * Search for a key that already exists.
1.12      kristaps  625:         * Create a new key if none is found.
1.8       kristaps  626:         */
1.71      schwarze  627:        if ((def = eqn_def_find(ep)) == NULL) {
1.8       kristaps  628:                /* Find holes in string array. */
                    629:                for (i = 0; i < (int)ep->defsz; i++)
                    630:                        if (0 == ep->defs[i].keysz)
                    631:                                break;
                    632:
                    633:                if (i == (int)ep->defsz) {
                    634:                        ep->defsz++;
1.42      schwarze  635:                        ep->defs = mandoc_reallocarray(ep->defs,
                    636:                            ep->defsz, sizeof(struct eqn_def));
1.9       kristaps  637:                        ep->defs[i].key = ep->defs[i].val = NULL;
1.8       kristaps  638:                }
                    639:
1.57      schwarze  640:                def = ep->defs + i;
                    641:                free(def->key);
1.71      schwarze  642:                def->key = mandoc_strndup(ep->start, ep->toksz);
                    643:                def->keysz = ep->toksz;
1.8       kristaps  644:        }
                    645:
1.71      schwarze  646:        if (eqn_next(ep, MODE_QUOTED) == EQN_TOK_EOF) {
1.57      schwarze  647:                mandoc_vmsg(MANDOCERR_REQ_EMPTY, ep->parse,
                    648:                    ep->eqn.ln, ep->eqn.pos, "define %s", def->key);
                    649:                free(def->key);
                    650:                free(def->val);
                    651:                def->key = def->val = NULL;
                    652:                def->keysz = def->valsz = 0;
                    653:                return;
1.8       kristaps  654:        }
1.57      schwarze  655:        free(def->val);
1.71      schwarze  656:        def->val = mandoc_strndup(ep->start, ep->toksz);
                    657:        def->valsz = ep->toksz;
1.30      kristaps  658: }
                    659:
1.48      kristaps  660: /*
                    661:  * Recursively parse an eqn(7) expression.
                    662:  */
1.57      schwarze  663: static enum rofferr
1.48      kristaps  664: eqn_parse(struct eqn_node *ep, struct eqn_box *parent)
1.30      kristaps  665: {
1.70      schwarze  666:        struct eqn_box  *cur, *nbox, *split;
1.71      schwarze  667:        const char      *cp, *cpn;
1.48      kristaps  668:        char            *p;
1.71      schwarze  669:        enum eqn_tok     tok;
1.68      schwarze  670:        enum { CCL_LET, CCL_DIG, CCL_PUN } ccl, ccln;
1.57      schwarze  671:        int              size;
1.30      kristaps  672:
1.56      schwarze  673:        assert(parent != NULL);
1.57      schwarze  674:
                    675:        /*
                    676:         * Empty equation.
                    677:         * Do not add it to the high-level syntax tree.
                    678:         */
                    679:
1.56      schwarze  680:        if (ep->data == NULL)
1.59      schwarze  681:                return ROFF_IGN;
1.51      schwarze  682:
1.72      schwarze  683:        ep->start = ep->end = ep->data + strspn(ep->data, " ^~");
1.71      schwarze  684:
1.52      schwarze  685: next_tok:
1.71      schwarze  686:        tok = eqn_next(ep, MODE_TOK);
1.52      schwarze  687:        switch (tok) {
1.63      schwarze  688:        case EQN_TOK_UNDEF:
1.57      schwarze  689:                eqn_undef(ep);
1.48      kristaps  690:                break;
1.63      schwarze  691:        case EQN_TOK_NDEFINE:
                    692:        case EQN_TOK_DEFINE:
1.57      schwarze  693:                eqn_def(ep);
1.48      kristaps  694:                break;
1.63      schwarze  695:        case EQN_TOK_TDEFINE:
1.71      schwarze  696:                if (eqn_next(ep, MODE_NOSUB) == EQN_TOK_EOF ||
                    697:                    eqn_next(ep, MODE_QUOTED) == EQN_TOK_EOF)
1.57      schwarze  698:                        mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse,
                    699:                            ep->eqn.ln, ep->eqn.pos, "tdefine");
1.48      kristaps  700:                break;
1.63      schwarze  701:        case EQN_TOK_DELIM:
1.54      schwarze  702:                eqn_delim(ep);
                    703:                break;
1.63      schwarze  704:        case EQN_TOK_GFONT:
1.71      schwarze  705:                if (eqn_next(ep, MODE_SUB) == EQN_TOK_EOF)
1.52      schwarze  706:                        mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse,
                    707:                            ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]);
1.48      kristaps  708:                break;
1.63      schwarze  709:        case EQN_TOK_MARK:
                    710:        case EQN_TOK_LINEUP:
1.48      kristaps  711:                /* Ignore these. */
                    712:                break;
1.63      schwarze  713:        case EQN_TOK_DYAD:
                    714:        case EQN_TOK_VEC:
                    715:        case EQN_TOK_UNDER:
                    716:        case EQN_TOK_BAR:
                    717:        case EQN_TOK_TILDE:
                    718:        case EQN_TOK_HAT:
                    719:        case EQN_TOK_DOT:
                    720:        case EQN_TOK_DOTDOT:
1.52      schwarze  721:                if (parent->last == NULL) {
                    722:                        mandoc_msg(MANDOCERR_EQN_NOBOX, ep->parse,
                    723:                            ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]);
                    724:                        cur = eqn_box_alloc(ep, parent);
                    725:                        cur->type = EQN_TEXT;
                    726:                        cur->text = mandoc_strdup("");
1.48      kristaps  727:                }
1.75    ! schwarze  728:                parent = eqn_box_makebinary(ep, parent);
1.73      schwarze  729:                parent->type = EQN_LIST;
1.48      kristaps  730:                parent->expectargs = 1;
1.68      schwarze  731:                parent->font = EQNFONT_ROMAN;
1.48      kristaps  732:                switch (tok) {
1.63      schwarze  733:                case EQN_TOK_DOTDOT:
1.71      schwarze  734:                        parent->top = mandoc_strdup("\\[ad]");
1.48      kristaps  735:                        break;
1.63      schwarze  736:                case EQN_TOK_VEC:
1.71      schwarze  737:                        parent->top = mandoc_strdup("\\[->]");
1.48      kristaps  738:                        break;
1.63      schwarze  739:                case EQN_TOK_DYAD:
1.71      schwarze  740:                        parent->top = mandoc_strdup("\\[<>]");
1.48      kristaps  741:                        break;
1.63      schwarze  742:                case EQN_TOK_TILDE:
1.71      schwarze  743:                        parent->top = mandoc_strdup("\\[a~]");
1.48      kristaps  744:                        break;
1.63      schwarze  745:                case EQN_TOK_UNDER:
1.71      schwarze  746:                        parent->bottom = mandoc_strdup("\\[ul]");
1.48      kristaps  747:                        break;
1.63      schwarze  748:                case EQN_TOK_BAR:
1.71      schwarze  749:                        parent->top = mandoc_strdup("\\[rl]");
1.48      kristaps  750:                        break;
1.63      schwarze  751:                case EQN_TOK_DOT:
1.71      schwarze  752:                        parent->top = mandoc_strdup("\\[a.]");
1.48      kristaps  753:                        break;
1.63      schwarze  754:                case EQN_TOK_HAT:
1.71      schwarze  755:                        parent->top = mandoc_strdup("\\[ha]");
1.48      kristaps  756:                        break;
                    757:                default:
                    758:                        abort();
                    759:                }
                    760:                parent = parent->parent;
                    761:                break;
1.63      schwarze  762:        case EQN_TOK_FWD:
                    763:        case EQN_TOK_BACK:
                    764:        case EQN_TOK_DOWN:
                    765:        case EQN_TOK_UP:
1.71      schwarze  766:                if (eqn_next(ep, MODE_SUB) == EQN_TOK_EOF)
1.52      schwarze  767:                        mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse,
                    768:                            ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]);
1.48      kristaps  769:                break;
1.63      schwarze  770:        case EQN_TOK_FAT:
                    771:        case EQN_TOK_ROMAN:
                    772:        case EQN_TOK_ITALIC:
                    773:        case EQN_TOK_BOLD:
1.48      kristaps  774:                while (parent->args == parent->expectargs)
1.52      schwarze  775:                        parent = parent->parent;
1.48      kristaps  776:                /*
                    777:                 * These values apply to the next word or sequence of
                    778:                 * words; thus, we mark that we'll have a child with
                    779:                 * exactly one of those.
                    780:                 */
                    781:                parent = eqn_box_alloc(ep, parent);
1.73      schwarze  782:                parent->type = EQN_LIST;
1.48      kristaps  783:                parent->expectargs = 1;
                    784:                switch (tok) {
1.63      schwarze  785:                case EQN_TOK_FAT:
1.48      kristaps  786:                        parent->font = EQNFONT_FAT;
                    787:                        break;
1.63      schwarze  788:                case EQN_TOK_ROMAN:
1.48      kristaps  789:                        parent->font = EQNFONT_ROMAN;
                    790:                        break;
1.63      schwarze  791:                case EQN_TOK_ITALIC:
1.48      kristaps  792:                        parent->font = EQNFONT_ITALIC;
                    793:                        break;
1.63      schwarze  794:                case EQN_TOK_BOLD:
1.48      kristaps  795:                        parent->font = EQNFONT_BOLD;
                    796:                        break;
                    797:                default:
                    798:                        abort();
                    799:                }
                    800:                break;
1.63      schwarze  801:        case EQN_TOK_SIZE:
                    802:        case EQN_TOK_GSIZE:
1.48      kristaps  803:                /* Accept two values: integral size and a single. */
1.71      schwarze  804:                if (eqn_next(ep, MODE_SUB) == EQN_TOK_EOF) {
1.52      schwarze  805:                        mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse,
                    806:                            ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]);
                    807:                        break;
1.48      kristaps  808:                }
1.71      schwarze  809:                size = mandoc_strntoi(ep->start, ep->toksz, 10);
1.48      kristaps  810:                if (-1 == size) {
1.52      schwarze  811:                        mandoc_msg(MANDOCERR_IT_NONUM, ep->parse,
                    812:                            ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]);
                    813:                        break;
1.48      kristaps  814:                }
                    815:                if (EQN_TOK_GSIZE == tok) {
                    816:                        ep->gsize = size;
                    817:                        break;
                    818:                }
1.74      schwarze  819:                while (parent->args == parent->expectargs)
                    820:                        parent = parent->parent;
1.48      kristaps  821:                parent = eqn_box_alloc(ep, parent);
1.73      schwarze  822:                parent->type = EQN_LIST;
1.48      kristaps  823:                parent->expectargs = 1;
                    824:                parent->size = size;
                    825:                break;
1.63      schwarze  826:        case EQN_TOK_FROM:
                    827:        case EQN_TOK_TO:
                    828:        case EQN_TOK_SUB:
                    829:        case EQN_TOK_SUP:
1.48      kristaps  830:                /*
                    831:                 * We have a left-right-associative expression.
                    832:                 * Repivot under a positional node, open a child scope
                    833:                 * and keep on reading.
                    834:                 */
1.52      schwarze  835:                if (parent->last == NULL) {
                    836:                        mandoc_msg(MANDOCERR_EQN_NOBOX, ep->parse,
                    837:                            ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]);
                    838:                        cur = eqn_box_alloc(ep, parent);
                    839:                        cur->type = EQN_TEXT;
                    840:                        cur->text = mandoc_strdup("");
1.48      kristaps  841:                }
1.74      schwarze  842:                while (parent->expectargs == 1 && parent->args == 1)
                    843:                        parent = parent->parent;
                    844:                if (tok == EQN_TOK_FROM || tok == EQN_TOK_TO)  {
                    845:                        for (cur = parent; cur != NULL; cur = cur->parent)
                    846:                                if (cur->pos == EQNPOS_SUB ||
                    847:                                    cur->pos == EQNPOS_SUP ||
                    848:                                    cur->pos == EQNPOS_SUBSUP ||
                    849:                                    cur->pos == EQNPOS_SQRT ||
                    850:                                    cur->pos == EQNPOS_OVER)
                    851:                                        break;
                    852:                        if (cur != NULL)
                    853:                                parent = cur->parent;
                    854:                }
                    855:                if (tok == EQN_TOK_SUP && parent->pos == EQNPOS_SUB) {
1.48      kristaps  856:                        parent->expectargs = 3;
                    857:                        parent->pos = EQNPOS_SUBSUP;
                    858:                        break;
                    859:                }
1.74      schwarze  860:                if (tok == EQN_TOK_TO && parent->pos == EQNPOS_FROM) {
1.48      kristaps  861:                        parent->expectargs = 3;
                    862:                        parent->pos = EQNPOS_FROMTO;
                    863:                        break;
                    864:                }
1.75    ! schwarze  865:                parent = eqn_box_makebinary(ep, parent);
1.48      kristaps  866:                switch (tok) {
1.63      schwarze  867:                case EQN_TOK_FROM:
1.75    ! schwarze  868:                        parent->pos = EQNPOS_FROM;
1.48      kristaps  869:                        break;
1.63      schwarze  870:                case EQN_TOK_TO:
1.75    ! schwarze  871:                        parent->pos = EQNPOS_TO;
1.48      kristaps  872:                        break;
1.63      schwarze  873:                case EQN_TOK_SUP:
1.75    ! schwarze  874:                        parent->pos = EQNPOS_SUP;
1.48      kristaps  875:                        break;
1.63      schwarze  876:                case EQN_TOK_SUB:
1.75    ! schwarze  877:                        parent->pos = EQNPOS_SUB;
1.48      kristaps  878:                        break;
                    879:                default:
                    880:                        abort();
                    881:                }
                    882:                break;
1.63      schwarze  883:        case EQN_TOK_SQRT:
1.48      kristaps  884:                while (parent->args == parent->expectargs)
1.52      schwarze  885:                        parent = parent->parent;
1.51      schwarze  886:                /*
1.48      kristaps  887:                 * Accept a left-right-associative set of arguments just
                    888:                 * like sub and sup and friends but without rebalancing
                    889:                 * under a pivot.
                    890:                 */
                    891:                parent = eqn_box_alloc(ep, parent);
                    892:                parent->type = EQN_SUBEXPR;
                    893:                parent->pos = EQNPOS_SQRT;
                    894:                parent->expectargs = 1;
                    895:                break;
1.63      schwarze  896:        case EQN_TOK_OVER:
1.48      kristaps  897:                /*
                    898:                 * We have a right-left-associative fraction.
                    899:                 * Close out anything that's currently open, then
                    900:                 * rebalance and continue reading.
                    901:                 */
1.52      schwarze  902:                if (parent->last == NULL) {
                    903:                        mandoc_msg(MANDOCERR_EQN_NOBOX, ep->parse,
                    904:                            ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]);
                    905:                        cur = eqn_box_alloc(ep, parent);
                    906:                        cur->type = EQN_TEXT;
                    907:                        cur->text = mandoc_strdup("");
1.48      kristaps  908:                }
1.74      schwarze  909:                while (parent->args == parent->expectargs)
                    910:                        parent = parent->parent;
1.48      kristaps  911:                while (EQN_SUBEXPR == parent->type)
1.52      schwarze  912:                        parent = parent->parent;
1.75    ! schwarze  913:                parent = eqn_box_makebinary(ep, parent);
        !           914:                parent->pos = EQNPOS_OVER;
1.48      kristaps  915:                break;
1.63      schwarze  916:        case EQN_TOK_RIGHT:
                    917:        case EQN_TOK_BRACE_CLOSE:
1.48      kristaps  918:                /*
                    919:                 * Close out the existing brace.
                    920:                 * FIXME: this is a shitty sentinel: we should really
                    921:                 * have a native EQN_BRACE type or whatnot.
                    922:                 */
1.52      schwarze  923:                for (cur = parent; cur != NULL; cur = cur->parent)
                    924:                        if (cur->type == EQN_LIST &&
1.73      schwarze  925:                            cur->expectargs > 1 &&
1.52      schwarze  926:                            (tok == EQN_TOK_BRACE_CLOSE ||
                    927:                             cur->left != NULL))
                    928:                                break;
                    929:                if (cur == NULL) {
                    930:                        mandoc_msg(MANDOCERR_BLK_NOTOPEN, ep->parse,
                    931:                            ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]);
                    932:                        break;
                    933:                }
                    934:                parent = cur;
1.48      kristaps  935:                if (EQN_TOK_RIGHT == tok) {
1.71      schwarze  936:                        if (eqn_next(ep, MODE_SUB) == EQN_TOK_EOF) {
1.52      schwarze  937:                                mandoc_msg(MANDOCERR_REQ_EMPTY,
                    938:                                    ep->parse, ep->eqn.ln,
                    939:                                    ep->eqn.pos, eqn_toks[tok]);
                    940:                                break;
1.48      kristaps  941:                        }
                    942:                        /* Handling depends on right/left. */
1.71      schwarze  943:                        if (STRNEQ(ep->start, ep->toksz, "ceiling", 7))
                    944:                                parent->right = mandoc_strdup("\\[rc]");
                    945:                        else if (STRNEQ(ep->start, ep->toksz, "floor", 5))
                    946:                                parent->right = mandoc_strdup("\\[rf]");
                    947:                        else
                    948:                                parent->right =
                    949:                                    mandoc_strndup(ep->start, ep->toksz);
1.48      kristaps  950:                }
1.52      schwarze  951:                parent = parent->parent;
1.61      schwarze  952:                if (tok == EQN_TOK_BRACE_CLOSE &&
1.51      schwarze  953:                    (parent->type == EQN_PILE ||
                    954:                     parent->type == EQN_MATRIX))
1.48      kristaps  955:                        parent = parent->parent;
                    956:                /* Close out any "singleton" lists. */
1.73      schwarze  957:                while (parent->type == EQN_LIST &&
                    958:                    parent->expectargs == 1 &&
                    959:                    parent->args == 1)
1.52      schwarze  960:                        parent = parent->parent;
1.48      kristaps  961:                break;
1.63      schwarze  962:        case EQN_TOK_BRACE_OPEN:
                    963:        case EQN_TOK_LEFT:
1.48      kristaps  964:                /*
                    965:                 * If we already have something in the stack and we're
                    966:                 * in an expression, then rewind til we're not any more
                    967:                 * (just like with the text node).
                    968:                 */
                    969:                while (parent->args == parent->expectargs)
1.52      schwarze  970:                        parent = parent->parent;
                    971:                if (EQN_TOK_LEFT == tok &&
1.71      schwarze  972:                    eqn_next(ep, MODE_SUB) == EQN_TOK_EOF) {
1.52      schwarze  973:                        mandoc_msg(MANDOCERR_REQ_EMPTY, ep->parse,
                    974:                            ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]);
                    975:                        break;
                    976:                }
1.48      kristaps  977:                parent = eqn_box_alloc(ep, parent);
                    978:                parent->type = EQN_LIST;
                    979:                if (EQN_TOK_LEFT == tok) {
1.71      schwarze  980:                        if (STRNEQ(ep->start, ep->toksz, "ceiling", 7))
                    981:                                parent->left = mandoc_strdup("\\[lc]");
                    982:                        else if (STRNEQ(ep->start, ep->toksz, "floor", 5))
                    983:                                parent->left = mandoc_strdup("\\[lf]");
                    984:                        else
                    985:                                parent->left =
                    986:                                    mandoc_strndup(ep->start, ep->toksz);
1.48      kristaps  987:                }
                    988:                break;
1.63      schwarze  989:        case EQN_TOK_PILE:
                    990:        case EQN_TOK_LPILE:
                    991:        case EQN_TOK_RPILE:
                    992:        case EQN_TOK_CPILE:
                    993:        case EQN_TOK_CCOL:
                    994:        case EQN_TOK_LCOL:
                    995:        case EQN_TOK_RCOL:
1.48      kristaps  996:                while (parent->args == parent->expectargs)
1.52      schwarze  997:                        parent = parent->parent;
1.48      kristaps  998:                parent = eqn_box_alloc(ep, parent);
                    999:                parent->type = EQN_PILE;
1.52      schwarze 1000:                parent->expectargs = 1;
1.48      kristaps 1001:                break;
1.63      schwarze 1002:        case EQN_TOK_ABOVE:
1.52      schwarze 1003:                for (cur = parent; cur != NULL; cur = cur->parent)
                   1004:                        if (cur->type == EQN_PILE)
                   1005:                                break;
                   1006:                if (cur == NULL) {
                   1007:                        mandoc_msg(MANDOCERR_IT_STRAY, ep->parse,
                   1008:                            ep->eqn.ln, ep->eqn.pos, eqn_toks[tok]);
                   1009:                        break;
                   1010:                }
                   1011:                parent = eqn_box_alloc(ep, cur);
1.48      kristaps 1012:                parent->type = EQN_LIST;
                   1013:                break;
1.63      schwarze 1014:        case EQN_TOK_MATRIX:
1.48      kristaps 1015:                while (parent->args == parent->expectargs)
1.52      schwarze 1016:                        parent = parent->parent;
1.48      kristaps 1017:                parent = eqn_box_alloc(ep, parent);
                   1018:                parent->type = EQN_MATRIX;
1.52      schwarze 1019:                parent->expectargs = 1;
1.48      kristaps 1020:                break;
1.63      schwarze 1021:        case EQN_TOK_EOF:
1.48      kristaps 1022:                /*
1.51      schwarze 1023:                 * End of file!
1.48      kristaps 1024:                 * TODO: make sure we're not in an open subexpression.
                   1025:                 */
1.59      schwarze 1026:                return ROFF_EQN;
1.67      schwarze 1027:        case EQN_TOK__MAX:
1.64      schwarze 1028:        case EQN_TOK_FUNC:
1.67      schwarze 1029:        case EQN_TOK_QUOTED:
                   1030:        case EQN_TOK_SYM:
1.71      schwarze 1031:                p = ep->start;
1.64      schwarze 1032:                assert(p != NULL);
1.48      kristaps 1033:                /*
                   1034:                 * If we already have something in the stack and we're
                   1035:                 * in an expression, then rewind til we're not any more.
                   1036:                 */
                   1037:                while (parent->args == parent->expectargs)
1.52      schwarze 1038:                        parent = parent->parent;
1.48      kristaps 1039:                cur = eqn_box_alloc(ep, parent);
                   1040:                cur->type = EQN_TEXT;
1.65      schwarze 1041:                cur->text = p;
1.68      schwarze 1042:                switch (tok) {
                   1043:                case EQN_TOK_FUNC:
                   1044:                        cur->font = EQNFONT_ROMAN;
                   1045:                        break;
                   1046:                case EQN_TOK_QUOTED:
                   1047:                        if (cur->font == EQNFONT_NONE)
1.67      schwarze 1048:                                cur->font = EQNFONT_ITALIC;
1.68      schwarze 1049:                        break;
                   1050:                case EQN_TOK_SYM:
                   1051:                        break;
                   1052:                default:
                   1053:                        if (cur->font != EQNFONT_NONE || *p == '\0')
1.67      schwarze 1054:                                break;
1.68      schwarze 1055:                        cpn = p - 1;
                   1056:                        ccln = CCL_LET;
1.70      schwarze 1057:                        split = NULL;
1.66      schwarze 1058:                        for (;;) {
1.68      schwarze 1059:                                /* Advance to next character. */
                   1060:                                cp = cpn++;
                   1061:                                ccl = ccln;
                   1062:                                ccln = isalpha((unsigned char)*cpn) ? CCL_LET :
                   1063:                                    isdigit((unsigned char)*cpn) ||
                   1064:                                    (*cpn == '.' && (ccl == CCL_DIG ||
                   1065:                                     isdigit((unsigned char)cpn[1]))) ?
                   1066:                                    CCL_DIG : CCL_PUN;
                   1067:                                /* No boundary before first character. */
                   1068:                                if (cp < p)
                   1069:                                        continue;
                   1070:                                cur->font = ccl == CCL_LET ?
                   1071:                                    EQNFONT_ITALIC : EQNFONT_ROMAN;
1.66      schwarze 1072:                                if (*cp == '\\')
                   1073:                                        mandoc_escape(&cpn, NULL, NULL);
1.68      schwarze 1074:                                /* No boundary after last character. */
1.66      schwarze 1075:                                if (*cpn == '\0')
                   1076:                                        break;
1.68      schwarze 1077:                                if (ccln == ccl)
1.66      schwarze 1078:                                        continue;
1.69      schwarze 1079:                                /* Boundary found, split the text. */
                   1080:                                if (parent->args == parent->expectargs) {
                   1081:                                        /* Remove the text from the tree. */
                   1082:                                        if (cur->prev == NULL)
                   1083:                                                parent->first = cur->next;
                   1084:                                        else
                   1085:                                                cur->prev->next = NULL;
                   1086:                                        parent->last = cur->prev;
                   1087:                                        parent->args--;
                   1088:                                        /* Set up a list instead. */
1.70      schwarze 1089:                                        split = eqn_box_alloc(ep, parent);
                   1090:                                        split->type = EQN_LIST;
1.69      schwarze 1091:                                        /* Insert the word into the list. */
1.70      schwarze 1092:                                        split->first = split->last = cur;
                   1093:                                        cur->parent = split;
1.69      schwarze 1094:                                        cur->prev = NULL;
1.70      schwarze 1095:                                        parent = split;
1.69      schwarze 1096:                                }
                   1097:                                /* Append a new text box. */
1.66      schwarze 1098:                                nbox = eqn_box_alloc(ep, parent);
                   1099:                                nbox->type = EQN_TEXT;
                   1100:                                nbox->text = mandoc_strdup(cpn);
1.68      schwarze 1101:                                /* Truncate the old box. */
1.66      schwarze 1102:                                p = mandoc_strndup(cur->text,
                   1103:                                    cpn - cur->text);
                   1104:                                free(cur->text);
                   1105:                                cur->text = p;
1.68      schwarze 1106:                                /* Setup to process the new box. */
1.66      schwarze 1107:                                cur = nbox;
1.68      schwarze 1108:                                p = nbox->text;
                   1109:                                cpn = p - 1;
                   1110:                                ccln = CCL_LET;
1.66      schwarze 1111:                        }
1.70      schwarze 1112:                        if (split != NULL)
                   1113:                                parent = split->parent;
1.68      schwarze 1114:                        break;
                   1115:                }
1.48      kristaps 1116:                break;
1.64      schwarze 1117:        default:
                   1118:                abort();
1.40      schwarze 1119:        }
1.52      schwarze 1120:        goto next_tok;
1.29      kristaps 1121: }
                   1122:
1.48      kristaps 1123: enum rofferr
1.51      schwarze 1124: eqn_end(struct eqn_node **epp)
1.8       kristaps 1125: {
1.48      kristaps 1126:        struct eqn_node *ep;
1.8       kristaps 1127:
1.48      kristaps 1128:        ep = *epp;
                   1129:        *epp = NULL;
1.8       kristaps 1130:
1.48      kristaps 1131:        ep->eqn.root = mandoc_calloc(1, sizeof(struct eqn_box));
                   1132:        ep->eqn.root->expectargs = UINT_MAX;
1.59      schwarze 1133:        return eqn_parse(ep, ep->eqn.root);
1.12      kristaps 1134: }
                   1135:
1.48      kristaps 1136: void
                   1137: eqn_free(struct eqn_node *p)
1.12      kristaps 1138: {
                   1139:        int              i;
1.8       kristaps 1140:
1.48      kristaps 1141:        eqn_box_free(p->eqn.root);
                   1142:
                   1143:        for (i = 0; i < (int)p->defsz; i++) {
                   1144:                free(p->defs[i].key);
                   1145:                free(p->defs[i].val);
                   1146:        }
1.8       kristaps 1147:
1.48      kristaps 1148:        free(p->data);
                   1149:        free(p->defs);
                   1150:        free(p);
1.1       kristaps 1151: }

CVSweb