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

Annotation of mandoc/eqn.c, Revision 1.52

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

CVSweb