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

Annotation of mandoc/eqn.c, Revision 1.34

1.34    ! kristaps    1: /*     $Id: eqn.c,v 1.33 2011/07/23 12:08:43 kristaps Exp $ */
1.1       kristaps    2: /*
                      3:  * Copyright (c) 2011 Kristaps Dzonsons <kristaps@bsd.lv>
                      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: #ifdef HAVE_CONFIG_H
                     18: #include "config.h"
                     19: #endif
                     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"
                     29: #include "libmandoc.h"
                     30: #include "libroff.h"
                     31:
1.11      kristaps   32: #define        EQN_NEST_MAX     128 /* maximum nesting of defines */
1.12      kristaps   33: #define        EQN_MSG(t, x)    mandoc_msg((t), (x)->parse, (x)->eqn.ln, (x)->eqn.pos, NULL)
1.8       kristaps   34:
1.20      kristaps   35: enum   eqn_rest {
                     36:        EQN_DESCOPE,
                     37:        EQN_ERR,
                     38:        EQN_OK,
                     39:        EQN_EOF
                     40: };
                     41:
1.27      kristaps   42: enum   eqn_symt {
                     43:        EQNSYM_alpha,
                     44:        EQNSYM_beta,
                     45:        EQNSYM_chi,
                     46:        EQNSYM_delta,
                     47:        EQNSYM_epsilon,
                     48:        EQNSYM_eta,
                     49:        EQNSYM_gamma,
                     50:        EQNSYM_iota,
                     51:        EQNSYM_kappa,
                     52:        EQNSYM_lambda,
                     53:        EQNSYM_mu,
                     54:        EQNSYM_nu,
                     55:        EQNSYM_omega,
                     56:        EQNSYM_omicron,
                     57:        EQNSYM_phi,
                     58:        EQNSYM_pi,
                     59:        EQNSYM_ps,
                     60:        EQNSYM_rho,
                     61:        EQNSYM_sigma,
                     62:        EQNSYM_tau,
                     63:        EQNSYM_theta,
                     64:        EQNSYM_upsilon,
                     65:        EQNSYM_xi,
                     66:        EQNSYM_zeta,
                     67:        EQNSYM_DELTA,
                     68:        EQNSYM_GAMMA,
                     69:        EQNSYM_LAMBDA,
                     70:        EQNSYM_OMEGA,
                     71:        EQNSYM_PHI,
                     72:        EQNSYM_PI,
                     73:        EQNSYM_PSI,
                     74:        EQNSYM_SIGMA,
                     75:        EQNSYM_THETA,
                     76:        EQNSYM_UPSILON,
                     77:        EQNSYM_XI,
1.28      kristaps   78:        EQNSYM_inter,
                     79:        EQNSYM_union,
                     80:        EQNSYM_prod,
                     81:        EQNSYM_int,
                     82:        EQNSYM_sum,
                     83:        EQNSYM_grad,
                     84:        EQNSYM_del,
                     85:        EQNSYM_times,
                     86:        EQNSYM_cdot,
                     87:        EQNSYM_nothing,
                     88:        EQNSYM_approx,
                     89:        EQNSYM_prime,
                     90:        EQNSYM_half,
                     91:        EQNSYM_partial,
                     92:        EQNSYM_inf,
                     93:        EQNSYM_muchgreat,
                     94:        EQNSYM_muchless,
                     95:        EQNSYM_larrow,
                     96:        EQNSYM_rarrow,
                     97:        EQNSYM_pm,
                     98:        EQNSYM_nequal,
                     99:        EQNSYM_equiv,
                    100:        EQNSYM_lessequal,
                    101:        EQNSYM_moreequal,
1.27      kristaps  102:        EQNSYM__MAX
                    103: };
                    104:
1.17      kristaps  105: struct eqnstr {
1.8       kristaps  106:        const char      *name;
                    107:        size_t           sz;
                    108: };
                    109:
1.24      kristaps  110: #define        STRNEQ(p1, sz1, p2, sz2) \
1.25      kristaps  111:        ((sz1) == (sz2) && 0 == strncmp((p1), (p2), (sz1)))
1.24      kristaps  112: #define        EQNSTREQ(x, p, sz) \
                    113:        STRNEQ((x)->name, (x)->sz, (p), (sz))
                    114:
1.17      kristaps  115: struct eqnpart {
                    116:        struct eqnstr    str;
                    117:        int             (*fp)(struct eqn_node *);
1.16      kristaps  118: };
                    119:
1.27      kristaps  120: struct eqnsym {
                    121:        struct eqnstr    str;
1.28      kristaps  122:        const char      *sym;
1.27      kristaps  123: };
                    124:
1.8       kristaps  125: enum   eqnpartt {
                    126:        EQN_DEFINE = 0,
                    127:        EQN_SET,
                    128:        EQN_UNDEF,
1.30      kristaps  129:        EQN_GFONT,
1.29      kristaps  130:        EQN_GSIZE,
1.33      kristaps  131:        EQN_BACK,
                    132:        EQN_FWD,
                    133:        EQN_UP,
                    134:        EQN_DOWN,
1.8       kristaps  135:        EQN__MAX
                    136: };
                    137:
1.23      kristaps  138: static enum eqn_rest    eqn_box(struct eqn_node *, struct eqn_box *);
1.29      kristaps  139: static struct eqn_box  *eqn_box_alloc(struct eqn_node *,
                    140:                                struct eqn_box *);
1.13      kristaps  141: static void             eqn_box_free(struct eqn_box *);
1.12      kristaps  142: static struct eqn_def  *eqn_def_find(struct eqn_node *,
                    143:                                const char *, size_t);
1.30      kristaps  144: static int              eqn_do_gfont(struct eqn_node *);
1.29      kristaps  145: static int              eqn_do_gsize(struct eqn_node *);
1.12      kristaps  146: static int              eqn_do_define(struct eqn_node *);
1.33      kristaps  147: static int              eqn_do_ign1(struct eqn_node *);
                    148: static int              eqn_do_ign2(struct eqn_node *);
1.12      kristaps  149: static int              eqn_do_undef(struct eqn_node *);
1.23      kristaps  150: static enum eqn_rest    eqn_eqn(struct eqn_node *, struct eqn_box *);
                    151: static enum eqn_rest    eqn_list(struct eqn_node *, struct eqn_box *);
1.32      kristaps  152: static enum eqn_rest    eqn_matrix(struct eqn_node *, struct eqn_box *);
1.12      kristaps  153: static const char      *eqn_nexttok(struct eqn_node *, size_t *);
1.14      kristaps  154: static const char      *eqn_nextrawtok(struct eqn_node *, size_t *);
                    155: static const char      *eqn_next(struct eqn_node *,
                    156:                                char, size_t *, int);
1.20      kristaps  157: static void             eqn_rewind(struct eqn_node *);
1.6       kristaps  158:
1.8       kristaps  159: static const struct eqnpart eqnparts[EQN__MAX] = {
1.17      kristaps  160:        { { "define", 6 }, eqn_do_define }, /* EQN_DEFINE */
1.33      kristaps  161:        { { "set", 3 }, eqn_do_ign2 }, /* EQN_SET */
1.17      kristaps  162:        { { "undef", 5 }, eqn_do_undef }, /* EQN_UNDEF */
1.30      kristaps  163:        { { "gfont", 5 }, eqn_do_gfont }, /* EQN_GFONT */
                    164:        { { "gsize", 5 }, eqn_do_gsize }, /* EQN_GSIZE */
1.33      kristaps  165:        { { "back", 4 }, eqn_do_ign1 }, /* EQN_BACK */
                    166:        { { "fwd", 3 }, eqn_do_ign1 }, /* EQN_FWD */
                    167:        { { "up", 2 }, eqn_do_ign1 }, /* EQN_UP */
                    168:        { { "down", 4 }, eqn_do_ign1 }, /* EQN_DOWN */
1.8       kristaps  169: };
                    170:
1.17      kristaps  171: static const struct eqnstr eqnmarks[EQNMARK__MAX] = {
1.16      kristaps  172:        { "", 0 }, /* EQNMARK_NONE */
                    173:        { "dot", 3 }, /* EQNMARK_DOT */
                    174:        { "dotdot", 6 }, /* EQNMARK_DOTDOT */
                    175:        { "hat", 3 }, /* EQNMARK_HAT */
                    176:        { "tilde", 5 }, /* EQNMARK_TILDE */
                    177:        { "vec", 3 }, /* EQNMARK_VEC */
                    178:        { "dyad", 4 }, /* EQNMARK_DYAD */
                    179:        { "bar", 3 }, /* EQNMARK_BAR */
                    180:        { "under", 5 }, /* EQNMARK_UNDER */
                    181: };
                    182:
1.17      kristaps  183: static const struct eqnstr eqnfonts[EQNFONT__MAX] = {
1.20      kristaps  184:        { "", 0 }, /* EQNFONT_NONE */
                    185:        { "roman", 5 }, /* EQNFONT_ROMAN */
                    186:        { "bold", 4 }, /* EQNFONT_BOLD */
1.34    ! kristaps  187:        { "fat", 3 }, /* EQNFONT_FAT */
1.20      kristaps  188:        { "italic", 6 }, /* EQNFONT_ITALIC */
1.17      kristaps  189: };
                    190:
1.18      kristaps  191: static const struct eqnstr eqnposs[EQNPOS__MAX] = {
1.20      kristaps  192:        { "", 0 }, /* EQNPOS_NONE */
                    193:        { "over", 4 }, /* EQNPOS_OVER */
                    194:        { "sup", 3 }, /* EQNPOS_SUP */
                    195:        { "sub", 3 }, /* EQNPOS_SUB */
                    196:        { "to", 2 }, /* EQNPOS_TO */
                    197:        { "from", 4 }, /* EQNPOS_FROM */
                    198: };
                    199:
                    200: static const struct eqnstr eqnpiles[EQNPILE__MAX] = {
                    201:        { "", 0 }, /* EQNPILE_NONE */
                    202:        { "cpile", 5 }, /* EQNPILE_CPILE */
                    203:        { "rpile", 5 }, /* EQNPILE_RPILE */
                    204:        { "lpile", 5 }, /* EQNPILE_LPILE */
1.32      kristaps  205:        { "ccol", 4 }, /* EQNPILE_CCOL */
                    206:        { "rcol", 4 }, /* EQNPILE_RCOL */
                    207:        { "lcol", 4 }, /* EQNPILE_LCOL */
1.18      kristaps  208: };
                    209:
1.27      kristaps  210: static const struct eqnsym eqnsyms[EQNSYM__MAX] = {
1.28      kristaps  211:        { { "alpha", 5 }, "*a" }, /* EQNSYM_alpha */
                    212:        { { "beta", 4 }, "*b" }, /* EQNSYM_beta */
                    213:        { { "chi", 3 }, "*x" }, /* EQNSYM_chi */
                    214:        { { "delta", 5 }, "*d" }, /* EQNSYM_delta */
                    215:        { { "epsilon", 7 }, "*e" }, /* EQNSYM_epsilon */
                    216:        { { "eta", 3 }, "*y" }, /* EQNSYM_eta */
                    217:        { { "gamma", 5 }, "*g" }, /* EQNSYM_gamma */
                    218:        { { "iota", 4 }, "*i" }, /* EQNSYM_iota */
                    219:        { { "kappa", 5 }, "*k" }, /* EQNSYM_kappa */
                    220:        { { "lambda", 6 }, "*l" }, /* EQNSYM_lambda */
                    221:        { { "mu", 2 }, "*m" }, /* EQNSYM_mu */
                    222:        { { "nu", 2 }, "*n" }, /* EQNSYM_nu */
                    223:        { { "omega", 5 }, "*w" }, /* EQNSYM_omega */
                    224:        { { "omicron", 7 }, "*o" }, /* EQNSYM_omicron */
                    225:        { { "phi", 3 }, "*f" }, /* EQNSYM_phi */
                    226:        { { "pi", 2 }, "*p" }, /* EQNSYM_pi */
                    227:        { { "psi", 2 }, "*q" }, /* EQNSYM_psi */
                    228:        { { "rho", 3 }, "*r" }, /* EQNSYM_rho */
                    229:        { { "sigma", 5 }, "*s" }, /* EQNSYM_sigma */
                    230:        { { "tau", 3 }, "*t" }, /* EQNSYM_tau */
                    231:        { { "theta", 5 }, "*h" }, /* EQNSYM_theta */
                    232:        { { "upsilon", 7 }, "*u" }, /* EQNSYM_upsilon */
                    233:        { { "xi", 2 }, "*c" }, /* EQNSYM_xi */
                    234:        { { "zeta", 4 }, "*z" }, /* EQNSYM_zeta */
                    235:        { { "DELTA", 5 }, "*D" }, /* EQNSYM_DELTA */
                    236:        { { "GAMMA", 5 }, "*G" }, /* EQNSYM_GAMMA */
                    237:        { { "LAMBDA", 6 }, "*L" }, /* EQNSYM_LAMBDA */
                    238:        { { "OMEGA", 5 }, "*W" }, /* EQNSYM_OMEGA */
                    239:        { { "PHI", 3 }, "*F" }, /* EQNSYM_PHI */
                    240:        { { "PI", 2 }, "*P" }, /* EQNSYM_PI */
                    241:        { { "PSI", 3 }, "*Q" }, /* EQNSYM_PSI */
                    242:        { { "SIGMA", 5 }, "*S" }, /* EQNSYM_SIGMA */
                    243:        { { "THETA", 5 }, "*H" }, /* EQNSYM_THETA */
                    244:        { { "UPSILON", 7 }, "*U" }, /* EQNSYM_UPSILON */
                    245:        { { "XI", 2 }, "*C" }, /* EQNSYM_XI */
                    246:        { { "inter", 5 }, "ca" }, /* EQNSYM_inter */
                    247:        { { "union", 5 }, "cu" }, /* EQNSYM_union */
                    248:        { { "prod", 4 }, "product" }, /* EQNSYM_prod */
                    249:        { { "int", 3 }, "integral" }, /* EQNSYM_int */
                    250:        { { "sum", 3 }, "sum" }, /* EQNSYM_sum */
                    251:        { { "grad", 4 }, "gr" }, /* EQNSYM_grad */
                    252:        { { "del", 3 }, "gr" }, /* EQNSYM_del */
                    253:        { { "times", 5 }, "mu" }, /* EQNSYM_times */
                    254:        { { "cdot", 4 }, "pc" }, /* EQNSYM_cdot */
                    255:        { { "nothing", 7 }, "&" }, /* EQNSYM_nothing */
                    256:        { { "approx", 6 }, "~~" }, /* EQNSYM_approx */
                    257:        { { "prime", 5 }, "aq" }, /* EQNSYM_prime */
                    258:        { { "half", 4 }, "12" }, /* EQNSYM_half */
                    259:        { { "partial", 7 }, "pd" }, /* EQNSYM_partial */
                    260:        { { "inf", 3 }, "if" }, /* EQNSYM_inf */
                    261:        { { ">>", 2 }, ">>" }, /* EQNSYM_muchgreat */
                    262:        { { "<<", 2 }, "<<" }, /* EQNSYM_muchless */
                    263:        { { "<-", 2 }, "<-" }, /* EQNSYM_larrow */
                    264:        { { "->", 2 }, "->" }, /* EQNSYM_rarrow */
                    265:        { { "+-", 2 }, "+-" }, /* EQNSYM_pm */
                    266:        { { "!=", 2 }, "!=" }, /* EQNSYM_nequal */
                    267:        { { "==", 2 }, "==" }, /* EQNSYM_equiv */
                    268:        { { "<=", 2 }, "<=" }, /* EQNSYM_lessequal */
                    269:        { { ">=", 2 }, ">=" }, /* EQNSYM_moreequal */
1.27      kristaps  270: };
                    271:
1.1       kristaps  272: /* ARGSUSED */
                    273: enum rofferr
1.6       kristaps  274: eqn_read(struct eqn_node **epp, int ln,
                    275:                const char *p, int pos, int *offs)
1.1       kristaps  276: {
1.8       kristaps  277:        size_t           sz;
                    278:        struct eqn_node *ep;
1.12      kristaps  279:        enum rofferr     er;
                    280:
                    281:        ep = *epp;
                    282:
                    283:        /*
                    284:         * If we're the terminating mark, unset our equation status and
                    285:         * validate the full equation.
                    286:         */
1.1       kristaps  287:
                    288:        if (0 == strcmp(p, ".EN")) {
1.12      kristaps  289:                er = eqn_end(ep);
1.1       kristaps  290:                *epp = NULL;
1.12      kristaps  291:                return(er);
1.1       kristaps  292:        }
                    293:
1.12      kristaps  294:        /*
                    295:         * Build up the full string, replacing all newlines with regular
                    296:         * whitespace.
                    297:         */
1.6       kristaps  298:
1.12      kristaps  299:        sz = strlen(p + pos) + 1;
                    300:        ep->data = mandoc_realloc(ep->data, ep->sz + sz + 1);
1.6       kristaps  301:
1.12      kristaps  302:        /* First invocation: nil terminate the string. */
1.8       kristaps  303:
1.12      kristaps  304:        if (0 == ep->sz)
                    305:                *ep->data = '\0';
1.8       kristaps  306:
1.12      kristaps  307:        ep->sz += sz;
                    308:        strlcat(ep->data, p + pos, ep->sz + 1);
                    309:        strlcat(ep->data, " ", ep->sz + 1);
1.11      kristaps  310:        return(ROFF_IGN);
                    311: }
                    312:
1.1       kristaps  313: struct eqn_node *
1.5       kristaps  314: eqn_alloc(int pos, int line, struct mparse *parse)
1.1       kristaps  315: {
                    316:        struct eqn_node *p;
                    317:
                    318:        p = mandoc_calloc(1, sizeof(struct eqn_node));
1.5       kristaps  319:        p->parse = parse;
1.12      kristaps  320:        p->eqn.ln = line;
1.2       kristaps  321:        p->eqn.pos = pos;
1.29      kristaps  322:        p->gsize = EQN_DEFSIZE;
1.1       kristaps  323:
                    324:        return(p);
                    325: }
                    326:
1.12      kristaps  327: enum rofferr
                    328: eqn_end(struct eqn_node *ep)
                    329: {
1.20      kristaps  330:        struct eqn_box  *root;
                    331:        enum eqn_rest    c;
                    332:
                    333:        ep->eqn.root = mandoc_calloc(1, sizeof(struct eqn_box));
1.13      kristaps  334:
1.20      kristaps  335:        root = ep->eqn.root;
1.13      kristaps  336:        root->type = EQN_ROOT;
                    337:
                    338:        if (0 == ep->sz)
                    339:                return(ROFF_IGN);
1.12      kristaps  340:
1.20      kristaps  341:        if (EQN_DESCOPE == (c = eqn_eqn(ep, root))) {
                    342:                EQN_MSG(MANDOCERR_EQNNSCOPE, ep);
                    343:                c = EQN_ERR;
                    344:        }
                    345:
                    346:        return(EQN_EOF == c ? ROFF_EQN : ROFF_IGN);
                    347: }
                    348:
                    349: static enum eqn_rest
                    350: eqn_eqn(struct eqn_node *ep, struct eqn_box *last)
                    351: {
                    352:        struct eqn_box  *bp;
                    353:        enum eqn_rest    c;
                    354:
1.29      kristaps  355:        bp = eqn_box_alloc(ep, last);
1.20      kristaps  356:        bp->type = EQN_SUBEXPR;
1.12      kristaps  357:
1.20      kristaps  358:        while (EQN_OK == (c = eqn_box(ep, bp)))
                    359:                /* Spin! */ ;
1.15      kristaps  360:
1.20      kristaps  361:        return(c);
1.12      kristaps  362: }
                    363:
1.20      kristaps  364: static enum eqn_rest
1.32      kristaps  365: eqn_matrix(struct eqn_node *ep, struct eqn_box *last)
                    366: {
                    367:        struct eqn_box  *bp;
                    368:        const char      *start;
                    369:        size_t           sz;
                    370:        enum eqn_rest    c;
                    371:
                    372:        bp = eqn_box_alloc(ep, last);
                    373:        bp->type = EQN_MATRIX;
                    374:
                    375:        if (NULL == (start = eqn_nexttok(ep, &sz))) {
                    376:                EQN_MSG(MANDOCERR_EQNEOF, ep);
                    377:                return(EQN_ERR);
                    378:        }
                    379:        if ( ! STRNEQ(start, sz, "{", 1)) {
                    380:                EQN_MSG(MANDOCERR_EQNSYNT, ep);
                    381:                return(EQN_ERR);
                    382:        }
                    383:
                    384:        while (EQN_OK == (c = eqn_box(ep, bp)))
                    385:                switch (bp->last->pile) {
                    386:                case (EQNPILE_LCOL):
                    387:                        /* FALLTHROUGH */
                    388:                case (EQNPILE_CCOL):
                    389:                        /* FALLTHROUGH */
                    390:                case (EQNPILE_RCOL):
                    391:                        continue;
                    392:                default:
                    393:                        EQN_MSG(MANDOCERR_EQNSYNT, ep);
                    394:                        return(EQN_ERR);
                    395:                };
                    396:
                    397:        if (EQN_DESCOPE != c) {
                    398:                if (EQN_EOF == c)
                    399:                        EQN_MSG(MANDOCERR_EQNEOF, ep);
                    400:                return(EQN_ERR);
                    401:        }
                    402:
                    403:        eqn_rewind(ep);
                    404:        start = eqn_nexttok(ep, &sz);
                    405:        assert(start);
                    406:        if (STRNEQ(start, sz, "}", 1))
                    407:                return(EQN_OK);
                    408:
                    409:        EQN_MSG(MANDOCERR_EQNBADSCOPE, ep);
                    410:        return(EQN_ERR);
                    411: }
                    412:
                    413: static enum eqn_rest
1.23      kristaps  414: eqn_list(struct eqn_node *ep, struct eqn_box *last)
                    415: {
                    416:        struct eqn_box  *bp;
                    417:        const char      *start;
                    418:        size_t           sz;
                    419:        enum eqn_rest    c;
                    420:
1.29      kristaps  421:        bp = eqn_box_alloc(ep, last);
1.23      kristaps  422:        bp->type = EQN_LIST;
                    423:
                    424:        if (NULL == (start = eqn_nexttok(ep, &sz))) {
                    425:                EQN_MSG(MANDOCERR_EQNEOF, ep);
                    426:                return(EQN_ERR);
                    427:        }
1.24      kristaps  428:        if ( ! STRNEQ(start, sz, "{", 1)) {
1.23      kristaps  429:                EQN_MSG(MANDOCERR_EQNSYNT, ep);
                    430:                return(EQN_ERR);
                    431:        }
                    432:
                    433:        while (EQN_DESCOPE == (c = eqn_eqn(ep, bp))) {
                    434:                eqn_rewind(ep);
                    435:                start = eqn_nexttok(ep, &sz);
                    436:                assert(start);
1.24      kristaps  437:                if ( ! STRNEQ(start, sz, "above", 5))
1.23      kristaps  438:                        break;
                    439:        }
                    440:
                    441:        if (EQN_DESCOPE != c) {
                    442:                if (EQN_ERR != c)
                    443:                        EQN_MSG(MANDOCERR_EQNSCOPE, ep);
                    444:                return(EQN_ERR);
                    445:        }
                    446:
                    447:        eqn_rewind(ep);
                    448:        start = eqn_nexttok(ep, &sz);
                    449:        assert(start);
1.24      kristaps  450:        if (STRNEQ(start, sz, "}", 1))
1.23      kristaps  451:                return(EQN_OK);
                    452:
                    453:        EQN_MSG(MANDOCERR_EQNBADSCOPE, ep);
                    454:        return(EQN_ERR);
                    455: }
                    456:
                    457: static enum eqn_rest
1.20      kristaps  458: eqn_box(struct eqn_node *ep, struct eqn_box *last)
1.1       kristaps  459: {
1.12      kristaps  460:        size_t           sz;
                    461:        const char      *start;
1.20      kristaps  462:        char            *left;
1.28      kristaps  463:        char             sym[64];
1.20      kristaps  464:        enum eqn_rest    c;
                    465:        int              i, size;
1.13      kristaps  466:        struct eqn_box  *bp;
1.12      kristaps  467:
1.20      kristaps  468:        if (NULL == (start = eqn_nexttok(ep, &sz)))
                    469:                return(EQN_EOF);
                    470:
1.24      kristaps  471:        if (STRNEQ(start, sz, "}", 1))
1.20      kristaps  472:                return(EQN_DESCOPE);
1.24      kristaps  473:        else if (STRNEQ(start, sz, "right", 5))
1.20      kristaps  474:                return(EQN_DESCOPE);
1.24      kristaps  475:        else if (STRNEQ(start, sz, "above", 5))
1.20      kristaps  476:                return(EQN_DESCOPE);
1.33      kristaps  477:        else if (STRNEQ(start, sz, "mark", 4))
                    478:                return(EQN_OK);
                    479:        else if (STRNEQ(start, sz, "lineup", 6))
                    480:                return(EQN_OK);
1.20      kristaps  481:
                    482:        for (i = 0; i < (int)EQN__MAX; i++) {
1.24      kristaps  483:                if ( ! EQNSTREQ(&eqnparts[i].str, start, sz))
1.20      kristaps  484:                        continue;
                    485:                return((*eqnparts[i].fp)(ep) ? EQN_OK : EQN_ERR);
                    486:        }
1.15      kristaps  487:
1.24      kristaps  488:        if (STRNEQ(start, sz, "{", 1)) {
1.20      kristaps  489:                if (EQN_DESCOPE != (c = eqn_eqn(ep, last))) {
                    490:                        if (EQN_ERR != c)
                    491:                                EQN_MSG(MANDOCERR_EQNSCOPE, ep);
                    492:                        return(EQN_ERR);
                    493:                }
                    494:                eqn_rewind(ep);
                    495:                start = eqn_nexttok(ep, &sz);
                    496:                assert(start);
1.24      kristaps  497:                if (STRNEQ(start, sz, "}", 1))
1.20      kristaps  498:                        return(EQN_OK);
                    499:                EQN_MSG(MANDOCERR_EQNBADSCOPE, ep);
                    500:                return(EQN_ERR);
                    501:        }
1.12      kristaps  502:
1.20      kristaps  503:        for (i = 0; i < (int)EQNPILE__MAX; i++) {
1.24      kristaps  504:                if ( ! EQNSTREQ(&eqnpiles[i], start, sz))
1.17      kristaps  505:                        continue;
1.23      kristaps  506:                if (EQN_OK == (c = eqn_list(ep, last)))
1.21      kristaps  507:                        last->last->pile = (enum eqn_pilet)i;
1.23      kristaps  508:                return(c);
1.18      kristaps  509:        }
1.32      kristaps  510:
                    511:        if (STRNEQ(start, sz, "matrix", 6))
                    512:                return(eqn_matrix(ep, last));
1.18      kristaps  513:
1.24      kristaps  514:        if (STRNEQ(start, sz, "left", 4)) {
1.20      kristaps  515:                if (NULL == (start = eqn_nexttok(ep, &sz))) {
                    516:                        EQN_MSG(MANDOCERR_EQNEOF, ep);
                    517:                        return(EQN_ERR);
                    518:                }
                    519:                left = mandoc_strndup(start, sz);
1.26      kristaps  520:                c = eqn_eqn(ep, last);
                    521:                if (last->last)
                    522:                        last->last->left = left;
                    523:                else
                    524:                        free(left);
                    525:                if (EQN_DESCOPE != c)
1.20      kristaps  526:                        return(c);
                    527:                assert(last->last);
                    528:                eqn_rewind(ep);
                    529:                start = eqn_nexttok(ep, &sz);
                    530:                assert(start);
1.26      kristaps  531:                if ( ! STRNEQ(start, sz, "right", 5))
1.20      kristaps  532:                        return(EQN_DESCOPE);
                    533:                if (NULL == (start = eqn_nexttok(ep, &sz))) {
                    534:                        EQN_MSG(MANDOCERR_EQNEOF, ep);
                    535:                        return(EQN_ERR);
                    536:                }
                    537:                last->last->right = mandoc_strndup(start, sz);
                    538:                return(EQN_OK);
                    539:        }
                    540:
                    541:        for (i = 0; i < (int)EQNPOS__MAX; i++) {
1.24      kristaps  542:                if ( ! EQNSTREQ(&eqnposs[i], start, sz))
1.18      kristaps  543:                        continue;
1.20      kristaps  544:                if (NULL == last->last) {
                    545:                        EQN_MSG(MANDOCERR_EQNSYNT, ep);
                    546:                        return(EQN_ERR);
                    547:                }
                    548:                last->last->pos = (enum eqn_post)i;
                    549:                if (EQN_EOF == (c = eqn_box(ep, last))) {
                    550:                        EQN_MSG(MANDOCERR_EQNEOF, ep);
                    551:                        return(EQN_ERR);
                    552:                }
                    553:                return(c);
1.17      kristaps  554:        }
                    555:
1.16      kristaps  556:        for (i = 0; i < (int)EQNMARK__MAX; i++) {
1.24      kristaps  557:                if ( ! EQNSTREQ(&eqnmarks[i], start, sz))
1.16      kristaps  558:                        continue;
1.20      kristaps  559:                if (NULL == last->last) {
                    560:                        EQN_MSG(MANDOCERR_EQNSYNT, ep);
                    561:                        return(EQN_ERR);
                    562:                }
                    563:                last->last->mark = (enum eqn_markt)i;
                    564:                if (EQN_EOF == (c = eqn_box(ep, last))) {
                    565:                        EQN_MSG(MANDOCERR_EQNEOF, ep);
                    566:                        return(EQN_ERR);
                    567:                }
                    568:                return(c);
1.16      kristaps  569:        }
1.12      kristaps  570:
1.20      kristaps  571:        for (i = 0; i < (int)EQNFONT__MAX; i++) {
1.24      kristaps  572:                if ( ! EQNSTREQ(&eqnfonts[i], start, sz))
1.20      kristaps  573:                        continue;
                    574:                if (EQN_EOF == (c = eqn_box(ep, last))) {
                    575:                        EQN_MSG(MANDOCERR_EQNEOF, ep);
                    576:                        return(EQN_ERR);
                    577:                } else if (EQN_OK == c)
                    578:                        last->last->font = (enum eqn_fontt)i;
                    579:                return(c);
1.19      kristaps  580:        }
1.15      kristaps  581:
1.24      kristaps  582:        if (STRNEQ(start, sz, "size", 4)) {
1.20      kristaps  583:                if (NULL == (start = eqn_nexttok(ep, &sz))) {
                    584:                        EQN_MSG(MANDOCERR_EQNEOF, ep);
                    585:                        return(EQN_ERR);
                    586:                }
                    587:                size = mandoc_strntoi(start, sz, 10);
                    588:                if (EQN_EOF == (c = eqn_box(ep, last))) {
                    589:                        EQN_MSG(MANDOCERR_EQNEOF, ep);
                    590:                        return(EQN_ERR);
                    591:                } else if (EQN_OK != c)
                    592:                        return(c);
                    593:                last->last->size = size;
1.15      kristaps  594:        }
                    595:
1.29      kristaps  596:        bp = eqn_box_alloc(ep, last);
1.15      kristaps  597:        bp->type = EQN_TEXT;
1.27      kristaps  598:        for (i = 0; i < (int)EQNSYM__MAX; i++)
                    599:                if (EQNSTREQ(&eqnsyms[i].str, start, sz)) {
1.28      kristaps  600:                        sym[63] = '\0';
                    601:                        snprintf(sym, 62, "\\[%s]", eqnsyms[i].sym);
1.27      kristaps  602:                        bp->text = mandoc_strdup(sym);
                    603:                        return(EQN_OK);
                    604:                }
                    605:
1.20      kristaps  606:        bp->text = mandoc_strndup(start, sz);
                    607:        return(EQN_OK);
1.1       kristaps  608: }
                    609:
                    610: void
                    611: eqn_free(struct eqn_node *p)
                    612: {
1.6       kristaps  613:        int              i;
1.1       kristaps  614:
1.13      kristaps  615:        eqn_box_free(p->eqn.root);
1.6       kristaps  616:
                    617:        for (i = 0; i < (int)p->defsz; i++) {
                    618:                free(p->defs[i].key);
                    619:                free(p->defs[i].val);
                    620:        }
                    621:
1.12      kristaps  622:        free(p->data);
1.6       kristaps  623:        free(p->defs);
1.1       kristaps  624:        free(p);
1.6       kristaps  625: }
                    626:
1.20      kristaps  627: static struct eqn_box *
1.29      kristaps  628: eqn_box_alloc(struct eqn_node *ep, struct eqn_box *parent)
1.20      kristaps  629: {
                    630:        struct eqn_box  *bp;
                    631:
                    632:        bp = mandoc_calloc(1, sizeof(struct eqn_box));
                    633:        bp->parent = parent;
1.29      kristaps  634:        bp->size = ep->gsize;
1.20      kristaps  635:
                    636:        if (NULL == parent->first)
                    637:                parent->first = bp;
                    638:        else
                    639:                parent->last->next = bp;
                    640:
                    641:        parent->last = bp;
                    642:        return(bp);
                    643: }
                    644:
1.13      kristaps  645: static void
                    646: eqn_box_free(struct eqn_box *bp)
                    647: {
                    648:
1.20      kristaps  649:        if (bp->first)
                    650:                eqn_box_free(bp->first);
1.13      kristaps  651:        if (bp->next)
                    652:                eqn_box_free(bp->next);
                    653:
                    654:        free(bp->text);
1.20      kristaps  655:        free(bp->left);
                    656:        free(bp->right);
1.13      kristaps  657:        free(bp);
                    658: }
                    659:
1.6       kristaps  660: static const char *
1.14      kristaps  661: eqn_nextrawtok(struct eqn_node *ep, size_t *sz)
                    662: {
                    663:
                    664:        return(eqn_next(ep, '"', sz, 0));
                    665: }
                    666:
                    667: static const char *
1.12      kristaps  668: eqn_nexttok(struct eqn_node *ep, size_t *sz)
                    669: {
                    670:
1.14      kristaps  671:        return(eqn_next(ep, '"', sz, 1));
1.12      kristaps  672: }
                    673:
1.20      kristaps  674: static void
                    675: eqn_rewind(struct eqn_node *ep)
                    676: {
                    677:
                    678:        ep->cur = ep->rew;
                    679: }
                    680:
1.12      kristaps  681: static const char *
1.14      kristaps  682: eqn_next(struct eqn_node *ep, char quote, size_t *sz, int repl)
1.6       kristaps  683: {
1.12      kristaps  684:        char            *start, *next;
                    685:        int              q, diff, lim;
1.22      kristaps  686:        size_t           ssz, dummy;
1.12      kristaps  687:        struct eqn_def  *def;
                    688:
                    689:        if (NULL == sz)
1.22      kristaps  690:                sz = &dummy;
1.6       kristaps  691:
1.13      kristaps  692:        lim = 0;
1.20      kristaps  693:        ep->rew = ep->cur;
1.13      kristaps  694: again:
                    695:        /* Prevent self-definitions. */
                    696:
                    697:        if (lim >= EQN_NEST_MAX) {
                    698:                EQN_MSG(MANDOCERR_EQNNEST, ep);
                    699:                return(NULL);
                    700:        }
                    701:
1.20      kristaps  702:        ep->cur = ep->rew;
1.12      kristaps  703:        start = &ep->data[(int)ep->cur];
1.6       kristaps  704:        q = 0;
                    705:
                    706:        if ('\0' == *start)
                    707:                return(NULL);
                    708:
1.12      kristaps  709:        if (quote == *start) {
                    710:                ep->cur++;
1.6       kristaps  711:                q = 1;
                    712:        }
                    713:
1.12      kristaps  714:        start = &ep->data[(int)ep->cur];
1.22      kristaps  715:
                    716:        if ( ! q) {
                    717:                if ('{' == *start || '}' == *start)
                    718:                        ssz = 1;
                    719:                else
1.31      kristaps  720:                        ssz = strcspn(start + 1, " ^~\"{}\t") + 1;
1.22      kristaps  721:                next = start + (int)ssz;
                    722:                if ('\0' == *next)
                    723:                        next = NULL;
                    724:        } else
                    725:                next = strchr(start, quote);
1.12      kristaps  726:
                    727:        if (NULL != next) {
                    728:                *sz = (size_t)(next - start);
                    729:                ep->cur += *sz;
1.6       kristaps  730:                if (q)
1.12      kristaps  731:                        ep->cur++;
1.22      kristaps  732:                while (' ' == ep->data[(int)ep->cur] ||
                    733:                                '\t' == ep->data[(int)ep->cur] ||
1.31      kristaps  734:                                '^' == ep->data[(int)ep->cur] ||
1.22      kristaps  735:                                '~' == ep->data[(int)ep->cur])
1.12      kristaps  736:                        ep->cur++;
1.6       kristaps  737:        } else {
                    738:                if (q)
1.12      kristaps  739:                        EQN_MSG(MANDOCERR_BADQUOTE, ep);
                    740:                next = strchr(start, '\0');
                    741:                *sz = (size_t)(next - start);
                    742:                ep->cur += *sz;
                    743:        }
                    744:
1.13      kristaps  745:        /* Quotes aren't expanded for values. */
                    746:
1.14      kristaps  747:        if (q || ! repl)
1.13      kristaps  748:                return(start);
                    749:
1.12      kristaps  750:        if (NULL != (def = eqn_def_find(ep, start, *sz))) {
                    751:                diff = def->valsz - *sz;
                    752:
                    753:                if (def->valsz > *sz) {
                    754:                        ep->sz += diff;
                    755:                        ep->data = mandoc_realloc(ep->data, ep->sz + 1);
                    756:                        ep->data[ep->sz] = '\0';
1.20      kristaps  757:                        start = &ep->data[(int)ep->rew];
1.12      kristaps  758:                }
                    759:
                    760:                diff = def->valsz - *sz;
                    761:                memmove(start + *sz + diff, start + *sz,
                    762:                                (strlen(start) - *sz) + 1);
                    763:                memcpy(start, def->val, def->valsz);
                    764:                goto again;
1.6       kristaps  765:        }
                    766:
                    767:        return(start);
1.8       kristaps  768: }
                    769:
                    770: static int
1.33      kristaps  771: eqn_do_ign1(struct eqn_node *ep)
                    772: {
                    773:        const char      *start;
                    774:
                    775:        if (NULL == (start = eqn_nextrawtok(ep, NULL)))
                    776:                EQN_MSG(MANDOCERR_EQNEOF, ep);
                    777:        else
                    778:                return(1);
                    779:
                    780:        return(0);
                    781: }
                    782:
                    783: static int
                    784: eqn_do_ign2(struct eqn_node *ep)
1.8       kristaps  785: {
                    786:        const char      *start;
                    787:
1.14      kristaps  788:        if (NULL == (start = eqn_nextrawtok(ep, NULL)))
1.29      kristaps  789:                EQN_MSG(MANDOCERR_EQNEOF, ep);
1.14      kristaps  790:        else if (NULL == (start = eqn_nextrawtok(ep, NULL)))
1.29      kristaps  791:                EQN_MSG(MANDOCERR_EQNEOF, ep);
1.12      kristaps  792:        else
                    793:                return(1);
1.8       kristaps  794:
1.12      kristaps  795:        return(0);
1.8       kristaps  796: }
                    797:
                    798: static int
1.12      kristaps  799: eqn_do_define(struct eqn_node *ep)
1.8       kristaps  800: {
                    801:        const char      *start;
                    802:        size_t           sz;
1.12      kristaps  803:        struct eqn_def  *def;
1.8       kristaps  804:        int              i;
                    805:
1.14      kristaps  806:        if (NULL == (start = eqn_nextrawtok(ep, &sz))) {
1.29      kristaps  807:                EQN_MSG(MANDOCERR_EQNEOF, ep);
1.8       kristaps  808:                return(0);
                    809:        }
                    810:
                    811:        /*
                    812:         * Search for a key that already exists.
1.12      kristaps  813:         * Create a new key if none is found.
1.8       kristaps  814:         */
                    815:
1.12      kristaps  816:        if (NULL == (def = eqn_def_find(ep, start, sz))) {
1.8       kristaps  817:                /* Find holes in string array. */
                    818:                for (i = 0; i < (int)ep->defsz; i++)
                    819:                        if (0 == ep->defs[i].keysz)
                    820:                                break;
                    821:
                    822:                if (i == (int)ep->defsz) {
                    823:                        ep->defsz++;
                    824:                        ep->defs = mandoc_realloc
                    825:                                (ep->defs, ep->defsz *
                    826:                                 sizeof(struct eqn_def));
1.9       kristaps  827:                        ep->defs[i].key = ep->defs[i].val = NULL;
1.8       kristaps  828:                }
                    829:
                    830:                ep->defs[i].keysz = sz;
                    831:                ep->defs[i].key = mandoc_realloc
                    832:                        (ep->defs[i].key, sz + 1);
                    833:
                    834:                memcpy(ep->defs[i].key, start, sz);
                    835:                ep->defs[i].key[(int)sz] = '\0';
1.12      kristaps  836:                def = &ep->defs[i];
1.8       kristaps  837:        }
                    838:
1.14      kristaps  839:        start = eqn_next(ep, ep->data[(int)ep->cur], &sz, 0);
1.8       kristaps  840:
1.12      kristaps  841:        if (NULL == start) {
1.29      kristaps  842:                EQN_MSG(MANDOCERR_EQNEOF, ep);
1.8       kristaps  843:                return(0);
                    844:        }
                    845:
1.12      kristaps  846:        def->valsz = sz;
1.13      kristaps  847:        def->val = mandoc_realloc(def->val, sz + 1);
1.12      kristaps  848:        memcpy(def->val, start, sz);
                    849:        def->val[(int)sz] = '\0';
1.30      kristaps  850:        return(1);
                    851: }
                    852:
                    853: static int
                    854: eqn_do_gfont(struct eqn_node *ep)
                    855: {
                    856:        const char      *start;
                    857:
                    858:        if (NULL == (start = eqn_nextrawtok(ep, NULL))) {
                    859:                EQN_MSG(MANDOCERR_EQNEOF, ep);
                    860:                return(0);
                    861:        }
1.12      kristaps  862:        return(1);
1.8       kristaps  863: }
                    864:
                    865: static int
1.29      kristaps  866: eqn_do_gsize(struct eqn_node *ep)
                    867: {
                    868:        const char      *start;
                    869:        size_t           sz;
                    870:
                    871:        if (NULL == (start = eqn_nextrawtok(ep, &sz))) {
                    872:                EQN_MSG(MANDOCERR_EQNEOF, ep);
                    873:                return(0);
                    874:        }
                    875:
                    876:        ep->gsize = mandoc_strntoi(start, sz, 10);
                    877:        return(1);
                    878: }
                    879:
                    880: static int
1.12      kristaps  881: eqn_do_undef(struct eqn_node *ep)
1.8       kristaps  882: {
                    883:        const char      *start;
1.12      kristaps  884:        struct eqn_def  *def;
1.8       kristaps  885:        size_t           sz;
                    886:
1.14      kristaps  887:        if (NULL == (start = eqn_nextrawtok(ep, &sz))) {
1.29      kristaps  888:                EQN_MSG(MANDOCERR_EQNEOF, ep);
1.12      kristaps  889:                return(0);
                    890:        } else if (NULL != (def = eqn_def_find(ep, start, sz)))
                    891:                def->keysz = 0;
1.8       kristaps  892:
1.12      kristaps  893:        return(1);
                    894: }
                    895:
                    896: static struct eqn_def *
                    897: eqn_def_find(struct eqn_node *ep, const char *key, size_t sz)
                    898: {
                    899:        int              i;
1.8       kristaps  900:
1.12      kristaps  901:        for (i = 0; i < (int)ep->defsz; i++)
1.24      kristaps  902:                if (ep->defs[i].keysz && STRNEQ(ep->defs[i].key,
                    903:                                        ep->defs[i].keysz, key, sz))
1.12      kristaps  904:                        return(&ep->defs[i]);
1.8       kristaps  905:
1.12      kristaps  906:        return(NULL);
1.1       kristaps  907: }

CVSweb