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