Annotation of mandoc/eqn.c, Revision 1.21
1.21 ! kristaps 1: /* $Id: eqn.c,v 1.20 2011/07/21 23:30:39 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.17 kristaps 42: struct eqnstr {
1.8 kristaps 43: const char *name;
44: size_t sz;
45: };
46:
1.17 kristaps 47: struct eqnpart {
48: struct eqnstr str;
49: int (*fp)(struct eqn_node *);
1.16 kristaps 50: };
51:
1.8 kristaps 52: enum eqnpartt {
53: EQN_DEFINE = 0,
54: EQN_SET,
55: EQN_UNDEF,
56: EQN__MAX
57: };
58:
1.20 kristaps 59: static struct eqn_box *eqn_box_alloc(struct eqn_box *);
1.13 kristaps 60: static void eqn_box_free(struct eqn_box *);
1.12 kristaps 61: static struct eqn_def *eqn_def_find(struct eqn_node *,
62: const char *, size_t);
63: static int eqn_do_define(struct eqn_node *);
1.14 kristaps 64: static int eqn_do_set(struct eqn_node *);
1.12 kristaps 65: static int eqn_do_undef(struct eqn_node *);
66: static const char *eqn_nexttok(struct eqn_node *, size_t *);
1.14 kristaps 67: static const char *eqn_nextrawtok(struct eqn_node *, size_t *);
68: static const char *eqn_next(struct eqn_node *,
69: char, size_t *, int);
1.20 kristaps 70: static void eqn_rewind(struct eqn_node *);
71: static enum eqn_rest eqn_eqn(struct eqn_node *, struct eqn_box *);
72: static enum eqn_rest eqn_box(struct eqn_node *, struct eqn_box *);
1.6 kristaps 73:
1.8 kristaps 74: static const struct eqnpart eqnparts[EQN__MAX] = {
1.17 kristaps 75: { { "define", 6 }, eqn_do_define }, /* EQN_DEFINE */
76: { { "set", 3 }, eqn_do_set }, /* EQN_SET */
77: { { "undef", 5 }, eqn_do_undef }, /* EQN_UNDEF */
1.8 kristaps 78: };
79:
1.17 kristaps 80: static const struct eqnstr eqnmarks[EQNMARK__MAX] = {
1.16 kristaps 81: { "", 0 }, /* EQNMARK_NONE */
82: { "dot", 3 }, /* EQNMARK_DOT */
83: { "dotdot", 6 }, /* EQNMARK_DOTDOT */
84: { "hat", 3 }, /* EQNMARK_HAT */
85: { "tilde", 5 }, /* EQNMARK_TILDE */
86: { "vec", 3 }, /* EQNMARK_VEC */
87: { "dyad", 4 }, /* EQNMARK_DYAD */
88: { "bar", 3 }, /* EQNMARK_BAR */
89: { "under", 5 }, /* EQNMARK_UNDER */
90: };
91:
1.17 kristaps 92: static const struct eqnstr eqnfonts[EQNFONT__MAX] = {
1.20 kristaps 93: { "", 0 }, /* EQNFONT_NONE */
94: { "roman", 5 }, /* EQNFONT_ROMAN */
95: { "bold", 4 }, /* EQNFONT_BOLD */
96: { "italic", 6 }, /* EQNFONT_ITALIC */
1.17 kristaps 97: };
98:
1.18 kristaps 99: static const struct eqnstr eqnposs[EQNPOS__MAX] = {
1.20 kristaps 100: { "", 0 }, /* EQNPOS_NONE */
101: { "over", 4 }, /* EQNPOS_OVER */
102: { "sup", 3 }, /* EQNPOS_SUP */
103: { "sub", 3 }, /* EQNPOS_SUB */
104: { "to", 2 }, /* EQNPOS_TO */
105: { "from", 4 }, /* EQNPOS_FROM */
106: };
107:
108: static const struct eqnstr eqnpiles[EQNPILE__MAX] = {
109: { "", 0 }, /* EQNPILE_NONE */
110: { "cpile", 5 }, /* EQNPILE_CPILE */
111: { "rpile", 5 }, /* EQNPILE_RPILE */
112: { "lpile", 5 }, /* EQNPILE_LPILE */
1.18 kristaps 113: };
114:
1.1 kristaps 115: /* ARGSUSED */
116: enum rofferr
1.6 kristaps 117: eqn_read(struct eqn_node **epp, int ln,
118: const char *p, int pos, int *offs)
1.1 kristaps 119: {
1.8 kristaps 120: size_t sz;
121: struct eqn_node *ep;
1.12 kristaps 122: enum rofferr er;
123:
124: ep = *epp;
125:
126: /*
127: * If we're the terminating mark, unset our equation status and
128: * validate the full equation.
129: */
1.1 kristaps 130:
131: if (0 == strcmp(p, ".EN")) {
1.12 kristaps 132: er = eqn_end(ep);
1.1 kristaps 133: *epp = NULL;
1.12 kristaps 134: return(er);
1.1 kristaps 135: }
136:
1.12 kristaps 137: /*
138: * Build up the full string, replacing all newlines with regular
139: * whitespace.
140: */
1.6 kristaps 141:
1.12 kristaps 142: sz = strlen(p + pos) + 1;
143: ep->data = mandoc_realloc(ep->data, ep->sz + sz + 1);
1.6 kristaps 144:
1.12 kristaps 145: /* First invocation: nil terminate the string. */
1.8 kristaps 146:
1.12 kristaps 147: if (0 == ep->sz)
148: *ep->data = '\0';
1.8 kristaps 149:
1.12 kristaps 150: ep->sz += sz;
151: strlcat(ep->data, p + pos, ep->sz + 1);
152: strlcat(ep->data, " ", ep->sz + 1);
1.11 kristaps 153: return(ROFF_IGN);
154: }
155:
1.1 kristaps 156: struct eqn_node *
1.5 kristaps 157: eqn_alloc(int pos, int line, struct mparse *parse)
1.1 kristaps 158: {
159: struct eqn_node *p;
160:
161: p = mandoc_calloc(1, sizeof(struct eqn_node));
1.5 kristaps 162: p->parse = parse;
1.12 kristaps 163: p->eqn.ln = line;
1.2 kristaps 164: p->eqn.pos = pos;
1.1 kristaps 165:
166: return(p);
167: }
168:
1.12 kristaps 169: enum rofferr
170: eqn_end(struct eqn_node *ep)
171: {
1.20 kristaps 172: struct eqn_box *root;
173: enum eqn_rest c;
174:
175: ep->eqn.root = mandoc_calloc(1, sizeof(struct eqn_box));
1.13 kristaps 176:
1.20 kristaps 177: root = ep->eqn.root;
1.13 kristaps 178: root->type = EQN_ROOT;
179:
180: if (0 == ep->sz)
181: return(ROFF_IGN);
1.12 kristaps 182:
1.20 kristaps 183: if (EQN_DESCOPE == (c = eqn_eqn(ep, root))) {
184: EQN_MSG(MANDOCERR_EQNNSCOPE, ep);
185: c = EQN_ERR;
186: }
187:
188: return(EQN_EOF == c ? ROFF_EQN : ROFF_IGN);
189: }
190:
191: static enum eqn_rest
192: eqn_eqn(struct eqn_node *ep, struct eqn_box *last)
193: {
194: struct eqn_box *bp;
195: enum eqn_rest c;
196:
197: bp = eqn_box_alloc(last);
198: bp->type = EQN_SUBEXPR;
1.12 kristaps 199:
1.20 kristaps 200: while (EQN_OK == (c = eqn_box(ep, bp)))
201: /* Spin! */ ;
1.15 kristaps 202:
1.20 kristaps 203: return(c);
1.12 kristaps 204: }
205:
1.20 kristaps 206: static enum eqn_rest
207: eqn_box(struct eqn_node *ep, struct eqn_box *last)
1.1 kristaps 208: {
1.12 kristaps 209: size_t sz;
210: const char *start;
1.20 kristaps 211: char *left;
212: enum eqn_rest c;
213: int i, size;
1.13 kristaps 214: struct eqn_box *bp;
1.12 kristaps 215:
1.20 kristaps 216: if (NULL == (start = eqn_nexttok(ep, &sz)))
217: return(EQN_EOF);
218:
219: if (1 == sz && 0 == strncmp("}", start, 1))
220: return(EQN_DESCOPE);
221: else if (5 == sz && 0 == strncmp("right", start, 5))
222: return(EQN_DESCOPE);
223: else if (5 == sz && 0 == strncmp("above", start, 5))
224: return(EQN_DESCOPE);
225:
226: for (i = 0; i < (int)EQN__MAX; i++) {
227: if (eqnparts[i].str.sz != sz)
228: continue;
229: if (strncmp(eqnparts[i].str.name, start, sz))
230: continue;
231: return((*eqnparts[i].fp)(ep) ? EQN_OK : EQN_ERR);
232: }
1.15 kristaps 233:
1.20 kristaps 234: if (1 == sz && 0 == strncmp("{", start, 1)) {
235: if (EQN_DESCOPE != (c = eqn_eqn(ep, last))) {
236: if (EQN_ERR != c)
237: EQN_MSG(MANDOCERR_EQNSCOPE, ep);
238: return(EQN_ERR);
239: }
240: eqn_rewind(ep);
241: start = eqn_nexttok(ep, &sz);
242: assert(start);
243: if (1 == sz && 0 == strncmp("}", start, 1))
244: return(EQN_OK);
245: EQN_MSG(MANDOCERR_EQNBADSCOPE, ep);
246: return(EQN_ERR);
247: }
1.12 kristaps 248:
1.20 kristaps 249: for (i = 0; i < (int)EQNPILE__MAX; i++) {
250: if (eqnpiles[i].sz != sz)
1.17 kristaps 251: continue;
1.20 kristaps 252: if (strncmp(eqnpiles[i].name, start, sz))
1.17 kristaps 253: continue;
1.20 kristaps 254: if (NULL == (start = eqn_nexttok(ep, &sz))) {
255: EQN_MSG(MANDOCERR_EQNEOF, ep);
256: return(EQN_ERR);
257: }
258: if (1 != sz || strncmp("{", start, 1)) {
259: EQN_MSG(MANDOCERR_EQNSYNT, ep);
260: return(EQN_ERR);
261: }
1.21 ! kristaps 262:
! 263: while (EQN_DESCOPE == (c = eqn_eqn(ep, last))) {
! 264: assert(last->last);
! 265: last->last->pile = (enum eqn_pilet)i;
! 266: eqn_rewind(ep);
! 267: start = eqn_nexttok(ep, &sz);
! 268: assert(start);
! 269: if (5 != sz || strncmp("above", start, 5))
! 270: break;
! 271: last->last->above = 1;
1.20 kristaps 272: }
1.21 ! kristaps 273:
! 274: if (EQN_DESCOPE != c) {
1.20 kristaps 275: if (EQN_ERR != c)
276: EQN_MSG(MANDOCERR_EQNSCOPE, ep);
277: return(EQN_ERR);
278: }
1.21 ! kristaps 279:
1.20 kristaps 280: eqn_rewind(ep);
281: start = eqn_nexttok(ep, &sz);
282: assert(start);
283: if (1 == sz && 0 == strncmp("}", start, 1))
284: return(EQN_OK);
1.21 ! kristaps 285:
1.20 kristaps 286: EQN_MSG(MANDOCERR_EQNBADSCOPE, ep);
287: return(EQN_ERR);
1.18 kristaps 288: }
289:
1.20 kristaps 290: if (4 == sz && 0 == strncmp("left", start, 4)) {
291: if (NULL == (start = eqn_nexttok(ep, &sz))) {
292: EQN_MSG(MANDOCERR_EQNEOF, ep);
293: return(EQN_ERR);
294: }
295: left = mandoc_strndup(start, sz);
296: if (EQN_DESCOPE != (c = eqn_eqn(ep, last)))
297: return(c);
298: assert(last->last);
299: last->last->left = left;
300: eqn_rewind(ep);
301: start = eqn_nexttok(ep, &sz);
302: assert(start);
303: if (5 != sz || strncmp("right", start, 5))
304: return(EQN_DESCOPE);
305: if (NULL == (start = eqn_nexttok(ep, &sz))) {
306: EQN_MSG(MANDOCERR_EQNEOF, ep);
307: return(EQN_ERR);
308: }
309: last->last->right = mandoc_strndup(start, sz);
310: return(EQN_OK);
311: }
312:
313: for (i = 0; i < (int)EQNPOS__MAX; i++) {
1.18 kristaps 314: if (eqnposs[i].sz != sz)
315: continue;
316: if (strncmp(eqnposs[i].name, start, sz))
317: continue;
1.20 kristaps 318: if (NULL == last->last) {
319: EQN_MSG(MANDOCERR_EQNSYNT, ep);
320: return(EQN_ERR);
321: }
322: last->last->pos = (enum eqn_post)i;
323: if (EQN_EOF == (c = eqn_box(ep, last))) {
324: EQN_MSG(MANDOCERR_EQNEOF, ep);
325: return(EQN_ERR);
326: }
327: return(c);
1.17 kristaps 328: }
329:
1.16 kristaps 330: for (i = 0; i < (int)EQNMARK__MAX; i++) {
331: if (eqnmarks[i].sz != sz)
332: continue;
333: if (strncmp(eqnmarks[i].name, start, sz))
334: continue;
1.20 kristaps 335: if (NULL == last->last) {
336: EQN_MSG(MANDOCERR_EQNSYNT, ep);
337: return(EQN_ERR);
338: }
339: last->last->mark = (enum eqn_markt)i;
340: if (EQN_EOF == (c = eqn_box(ep, last))) {
341: EQN_MSG(MANDOCERR_EQNEOF, ep);
342: return(EQN_ERR);
343: }
344: return(c);
1.16 kristaps 345: }
1.12 kristaps 346:
1.20 kristaps 347: for (i = 0; i < (int)EQNFONT__MAX; i++) {
348: if (eqnfonts[i].sz != sz)
349: continue;
350: if (strncmp(eqnfonts[i].name, start, sz))
351: continue;
352: if (EQN_EOF == (c = eqn_box(ep, last))) {
353: EQN_MSG(MANDOCERR_EQNEOF, ep);
354: return(EQN_ERR);
355: } else if (EQN_OK == c)
356: last->last->font = (enum eqn_fontt)i;
357: return(c);
1.19 kristaps 358: }
1.15 kristaps 359:
1.20 kristaps 360: if (4 == sz && 0 == strncmp("size", start, 4)) {
361: if (NULL == (start = eqn_nexttok(ep, &sz))) {
362: EQN_MSG(MANDOCERR_EQNEOF, ep);
363: return(EQN_ERR);
364: }
365: size = mandoc_strntoi(start, sz, 10);
366: if (EQN_EOF == (c = eqn_box(ep, last))) {
367: EQN_MSG(MANDOCERR_EQNEOF, ep);
368: return(EQN_ERR);
369: } else if (EQN_OK != c)
370: return(c);
371: last->last->size = size;
1.15 kristaps 372: }
373:
1.20 kristaps 374: bp = eqn_box_alloc(last);
1.15 kristaps 375: bp->type = EQN_TEXT;
1.20 kristaps 376: bp->text = mandoc_strndup(start, sz);
377: return(EQN_OK);
1.1 kristaps 378: }
379:
380: void
381: eqn_free(struct eqn_node *p)
382: {
1.6 kristaps 383: int i;
1.1 kristaps 384:
1.13 kristaps 385: eqn_box_free(p->eqn.root);
1.6 kristaps 386:
387: for (i = 0; i < (int)p->defsz; i++) {
388: free(p->defs[i].key);
389: free(p->defs[i].val);
390: }
391:
1.12 kristaps 392: free(p->data);
1.6 kristaps 393: free(p->defs);
1.1 kristaps 394: free(p);
1.6 kristaps 395: }
396:
1.20 kristaps 397: static struct eqn_box *
398: eqn_box_alloc(struct eqn_box *parent)
399: {
400: struct eqn_box *bp;
401:
402: bp = mandoc_calloc(1, sizeof(struct eqn_box));
403: bp->parent = parent;
404: bp->size = EQN_DEFSIZE;
405:
406: if (NULL == parent->first)
407: parent->first = bp;
408: else
409: parent->last->next = bp;
410:
411: parent->last = bp;
412: return(bp);
413: }
414:
1.13 kristaps 415: static void
416: eqn_box_free(struct eqn_box *bp)
417: {
418:
1.20 kristaps 419: if (bp->first)
420: eqn_box_free(bp->first);
1.13 kristaps 421: if (bp->next)
422: eqn_box_free(bp->next);
423:
424: free(bp->text);
1.20 kristaps 425: free(bp->left);
426: free(bp->right);
1.13 kristaps 427: free(bp);
428: }
429:
1.6 kristaps 430: static const char *
1.14 kristaps 431: eqn_nextrawtok(struct eqn_node *ep, size_t *sz)
432: {
433:
434: return(eqn_next(ep, '"', sz, 0));
435: }
436:
437: static const char *
1.12 kristaps 438: eqn_nexttok(struct eqn_node *ep, size_t *sz)
439: {
440:
1.14 kristaps 441: return(eqn_next(ep, '"', sz, 1));
1.12 kristaps 442: }
443:
1.20 kristaps 444: static void
445: eqn_rewind(struct eqn_node *ep)
446: {
447:
448: ep->cur = ep->rew;
449: }
450:
1.12 kristaps 451: static const char *
1.14 kristaps 452: eqn_next(struct eqn_node *ep, char quote, size_t *sz, int repl)
1.6 kristaps 453: {
1.12 kristaps 454: char *start, *next;
455: int q, diff, lim;
1.20 kristaps 456: size_t ssz;
1.12 kristaps 457: struct eqn_def *def;
458:
459: if (NULL == sz)
460: sz = &ssz;
1.6 kristaps 461:
1.13 kristaps 462: lim = 0;
1.20 kristaps 463: ep->rew = ep->cur;
1.13 kristaps 464: again:
465: /* Prevent self-definitions. */
466:
467: if (lim >= EQN_NEST_MAX) {
468: EQN_MSG(MANDOCERR_EQNNEST, ep);
469: return(NULL);
470: }
471:
1.20 kristaps 472: ep->cur = ep->rew;
1.12 kristaps 473: start = &ep->data[(int)ep->cur];
1.6 kristaps 474: q = 0;
475:
476: if ('\0' == *start)
477: return(NULL);
478:
1.12 kristaps 479: if (quote == *start) {
480: ep->cur++;
1.6 kristaps 481: q = 1;
482: }
483:
1.12 kristaps 484: start = &ep->data[(int)ep->cur];
485: next = q ? strchr(start, quote) : strchr(start, ' ');
486:
487: if (NULL != next) {
488: *sz = (size_t)(next - start);
489: ep->cur += *sz;
1.6 kristaps 490: if (q)
1.12 kristaps 491: ep->cur++;
492: while (' ' == ep->data[(int)ep->cur])
493: ep->cur++;
1.6 kristaps 494: } else {
495: if (q)
1.12 kristaps 496: EQN_MSG(MANDOCERR_BADQUOTE, ep);
497: next = strchr(start, '\0');
498: *sz = (size_t)(next - start);
499: ep->cur += *sz;
500: }
501:
1.13 kristaps 502: /* Quotes aren't expanded for values. */
503:
1.14 kristaps 504: if (q || ! repl)
1.13 kristaps 505: return(start);
506:
1.12 kristaps 507: if (NULL != (def = eqn_def_find(ep, start, *sz))) {
508: diff = def->valsz - *sz;
509:
510: if (def->valsz > *sz) {
511: ep->sz += diff;
512: ep->data = mandoc_realloc(ep->data, ep->sz + 1);
513: ep->data[ep->sz] = '\0';
1.20 kristaps 514: start = &ep->data[(int)ep->rew];
1.12 kristaps 515: }
516:
517: diff = def->valsz - *sz;
518: memmove(start + *sz + diff, start + *sz,
519: (strlen(start) - *sz) + 1);
520: memcpy(start, def->val, def->valsz);
521: goto again;
1.6 kristaps 522: }
523:
524: return(start);
1.8 kristaps 525: }
526:
527: static int
1.14 kristaps 528: eqn_do_set(struct eqn_node *ep)
1.8 kristaps 529: {
530: const char *start;
531:
1.14 kristaps 532: if (NULL == (start = eqn_nextrawtok(ep, NULL)))
1.12 kristaps 533: EQN_MSG(MANDOCERR_EQNARGS, ep);
1.14 kristaps 534: else if (NULL == (start = eqn_nextrawtok(ep, NULL)))
1.12 kristaps 535: EQN_MSG(MANDOCERR_EQNARGS, ep);
536: else
537: return(1);
1.8 kristaps 538:
1.12 kristaps 539: return(0);
1.8 kristaps 540: }
541:
542: static int
1.12 kristaps 543: eqn_do_define(struct eqn_node *ep)
1.8 kristaps 544: {
545: const char *start;
546: size_t sz;
1.12 kristaps 547: struct eqn_def *def;
1.8 kristaps 548: int i;
549:
1.14 kristaps 550: if (NULL == (start = eqn_nextrawtok(ep, &sz))) {
1.12 kristaps 551: EQN_MSG(MANDOCERR_EQNARGS, ep);
1.8 kristaps 552: return(0);
553: }
554:
555: /*
556: * Search for a key that already exists.
1.12 kristaps 557: * Create a new key if none is found.
1.8 kristaps 558: */
559:
1.12 kristaps 560: if (NULL == (def = eqn_def_find(ep, start, sz))) {
1.8 kristaps 561: /* Find holes in string array. */
562: for (i = 0; i < (int)ep->defsz; i++)
563: if (0 == ep->defs[i].keysz)
564: break;
565:
566: if (i == (int)ep->defsz) {
567: ep->defsz++;
568: ep->defs = mandoc_realloc
569: (ep->defs, ep->defsz *
570: sizeof(struct eqn_def));
1.9 kristaps 571: ep->defs[i].key = ep->defs[i].val = NULL;
1.8 kristaps 572: }
573:
574: ep->defs[i].keysz = sz;
575: ep->defs[i].key = mandoc_realloc
576: (ep->defs[i].key, sz + 1);
577:
578: memcpy(ep->defs[i].key, start, sz);
579: ep->defs[i].key[(int)sz] = '\0';
1.12 kristaps 580: def = &ep->defs[i];
1.8 kristaps 581: }
582:
1.14 kristaps 583: start = eqn_next(ep, ep->data[(int)ep->cur], &sz, 0);
1.8 kristaps 584:
1.12 kristaps 585: if (NULL == start) {
586: EQN_MSG(MANDOCERR_EQNARGS, ep);
1.8 kristaps 587: return(0);
588: }
589:
1.12 kristaps 590: def->valsz = sz;
1.13 kristaps 591: def->val = mandoc_realloc(def->val, sz + 1);
1.12 kristaps 592: memcpy(def->val, start, sz);
593: def->val[(int)sz] = '\0';
594: return(1);
1.8 kristaps 595: }
596:
597: static int
1.12 kristaps 598: eqn_do_undef(struct eqn_node *ep)
1.8 kristaps 599: {
600: const char *start;
1.12 kristaps 601: struct eqn_def *def;
1.8 kristaps 602: size_t sz;
603:
1.14 kristaps 604: if (NULL == (start = eqn_nextrawtok(ep, &sz))) {
1.12 kristaps 605: EQN_MSG(MANDOCERR_EQNARGS, ep);
606: return(0);
607: } else if (NULL != (def = eqn_def_find(ep, start, sz)))
608: def->keysz = 0;
1.8 kristaps 609:
1.12 kristaps 610: return(1);
611: }
612:
613: static struct eqn_def *
614: eqn_def_find(struct eqn_node *ep, const char *key, size_t sz)
615: {
616: int i;
1.8 kristaps 617:
1.12 kristaps 618: for (i = 0; i < (int)ep->defsz; i++)
619: if (ep->defs[i].keysz && ep->defs[i].keysz == sz &&
620: 0 == strncmp(ep->defs[i].key, key, sz))
621: return(&ep->defs[i]);
1.8 kristaps 622:
1.12 kristaps 623: return(NULL);
1.1 kristaps 624: }
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