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