]> git.cameronkatri.com Git - mandoc.git/blob - roff.c
git.ckatri.com / mandoc.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
Rudimentary implementation of the .it request (input line trap).
[mandoc.git] / roff.c
1 /* $Id: roff.c,v 1.178 2013/07/13 12:52:07 schwarze Exp $ */
2 /*
3 * Copyright (c) 2010, 2011, 2012 Kristaps Dzonsons <kristaps@bsd.lv>
4 * Copyright (c) 2010, 2011, 2012, 2013 Ingo Schwarze <schwarze@openbsd.org>
5 *
6 * Permission to use, copy, modify, and distribute this software for any
7 * purpose with or without fee is hereby granted, provided that the above
8 * copyright notice and this permission notice appear in all copies.
9 *
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHORS DISCLAIM ALL WARRANTIES
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 */
18 #ifdef HAVE_CONFIG_H
19 #include "config.h"
20 #endif
21
22 #include <assert.h>
23 #include <ctype.h>
24 #include <stdio.h>
25 #include <stdlib.h>
26 #include <string.h>
27
28 #include "mandoc.h"
29 #include "libroff.h"
30 #include "libmandoc.h"
31
32 /* Maximum number of nested if-else conditionals. */
33 #define RSTACK_MAX 128
34
35 /* Maximum number of string expansions per line, to break infinite loops. */
36 #define EXPAND_LIMIT 1000
37
38 enum rofft {
39 ROFF_ad,
40 ROFF_am,
41 ROFF_ami,
42 ROFF_am1,
43 ROFF_cc,
44 ROFF_de,
45 ROFF_dei,
46 ROFF_de1,
47 ROFF_ds,
48 ROFF_el,
49 ROFF_hy,
50 ROFF_ie,
51 ROFF_if,
52 ROFF_ig,
53 ROFF_it,
54 ROFF_ne,
55 ROFF_nh,
56 ROFF_nr,
57 ROFF_ns,
58 ROFF_ps,
59 ROFF_rm,
60 ROFF_so,
61 ROFF_ta,
62 ROFF_tr,
63 ROFF_Dd,
64 ROFF_TH,
65 ROFF_TS,
66 ROFF_TE,
67 ROFF_T_,
68 ROFF_EQ,
69 ROFF_EN,
70 ROFF_cblock,
71 ROFF_ccond,
72 ROFF_USERDEF,
73 ROFF_MAX
74 };
75
76 enum roffrule {
77 ROFFRULE_ALLOW,
78 ROFFRULE_DENY
79 };
80
81 /*
82 * A single register entity. If "set" is zero, the value of the
83 * register should be the default one, which is per-register.
84 * Registers are assumed to be unsigned ints for now.
85 */
86 struct reg {
87 int set; /* whether set or not */
88 unsigned int u; /* unsigned integer */
89 };
90
91 /*
92 * An incredibly-simple string buffer.
93 */
94 struct roffstr {
95 char *p; /* nil-terminated buffer */
96 size_t sz; /* saved strlen(p) */
97 };
98
99 /*
100 * A key-value roffstr pair as part of a singly-linked list.
101 */
102 struct roffkv {
103 struct roffstr key;
104 struct roffstr val;
105 struct roffkv *next; /* next in list */
106 };
107
108 struct roff {
109 enum mparset parsetype; /* requested parse type */
110 struct mparse *parse; /* parse point */
111 struct roffnode *last; /* leaf of stack */
112 enum roffrule rstack[RSTACK_MAX]; /* stack of !`ie' rules */
113 char control; /* control character */
114 int rstackpos; /* position in rstack */
115 struct reg regs[REG__MAX];
116 struct roffkv *strtab; /* user-defined strings & macros */
117 struct roffkv *xmbtab; /* multi-byte trans table (`tr') */
118 struct roffstr *xtab; /* single-byte trans table (`tr') */
119 const char *current_string; /* value of last called user macro */
120 struct tbl_node *first_tbl; /* first table parsed */
121 struct tbl_node *last_tbl; /* last table parsed */
122 struct tbl_node *tbl; /* current table being parsed */
123 struct eqn_node *last_eqn; /* last equation parsed */
124 struct eqn_node *first_eqn; /* first equation parsed */
125 struct eqn_node *eqn; /* current equation being parsed */
126 };
127
128 struct roffnode {
129 enum rofft tok; /* type of node */
130 struct roffnode *parent; /* up one in stack */
131 int line; /* parse line */
132 int col; /* parse col */
133 char *name; /* node name, e.g. macro name */
134 char *end; /* end-rules: custom token */
135 int endspan; /* end-rules: next-line or infty */
136 enum roffrule rule; /* current evaluation rule */
137 };
138
139 #define ROFF_ARGS struct roff *r, /* parse ctx */ \
140 enum rofft tok, /* tok of macro */ \
141 char **bufp, /* input buffer */ \
142 size_t *szp, /* size of input buffer */ \
143 int ln, /* parse line */ \
144 int ppos, /* original pos in buffer */ \
145 int pos, /* current pos in buffer */ \
146 int *offs /* reset offset of buffer data */
147
148 typedef enum rofferr (*roffproc)(ROFF_ARGS);
149
150 struct roffmac {
151 const char *name; /* macro name */
152 roffproc proc; /* process new macro */
153 roffproc text; /* process as child text of macro */
154 roffproc sub; /* process as child of macro */
155 int flags;
156 #define ROFFMAC_STRUCT (1 << 0) /* always interpret */
157 struct roffmac *next;
158 };
159
160 struct predef {
161 const char *name; /* predefined input name */
162 const char *str; /* replacement symbol */
163 };
164
165 #define PREDEF(__name, __str) \
166 { (__name), (__str) },
167
168 static enum rofft roffhash_find(const char *, size_t);
169 static void roffhash_init(void);
170 static void roffnode_cleanscope(struct roff *);
171 static void roffnode_pop(struct roff *);
172 static void roffnode_push(struct roff *, enum rofft,
173 const char *, int, int);
174 static enum rofferr roff_block(ROFF_ARGS);
175 static enum rofferr roff_block_text(ROFF_ARGS);
176 static enum rofferr roff_block_sub(ROFF_ARGS);
177 static enum rofferr roff_cblock(ROFF_ARGS);
178 static enum rofferr roff_cc(ROFF_ARGS);
179 static enum rofferr roff_ccond(ROFF_ARGS);
180 static enum rofferr roff_cond(ROFF_ARGS);
181 static enum rofferr roff_cond_text(ROFF_ARGS);
182 static enum rofferr roff_cond_sub(ROFF_ARGS);
183 static enum rofferr roff_ds(ROFF_ARGS);
184 static enum roffrule roff_evalcond(const char *, int *);
185 static void roff_free1(struct roff *);
186 static void roff_freestr(struct roffkv *);
187 static char *roff_getname(struct roff *, char **, int, int);
188 static const char *roff_getstrn(const struct roff *,
189 const char *, size_t);
190 static enum rofferr roff_it(ROFF_ARGS);
191 static enum rofferr roff_line_ignore(ROFF_ARGS);
192 static enum rofferr roff_nr(ROFF_ARGS);
193 static void roff_openeqn(struct roff *, const char *,
194 int, int, const char *);
195 static enum rofft roff_parse(struct roff *, const char *, int *);
196 static enum rofferr roff_parsetext(char **, size_t *, int, int *);
197 static enum rofferr roff_res(struct roff *,
198 char **, size_t *, int, int);
199 static enum rofferr roff_rm(ROFF_ARGS);
200 static void roff_setstr(struct roff *,
201 const char *, const char *, int);
202 static void roff_setstrn(struct roffkv **, const char *,
203 size_t, const char *, size_t, int);
204 static enum rofferr roff_so(ROFF_ARGS);
205 static enum rofferr roff_tr(ROFF_ARGS);
206 static enum rofferr roff_Dd(ROFF_ARGS);
207 static enum rofferr roff_TH(ROFF_ARGS);
208 static enum rofferr roff_TE(ROFF_ARGS);
209 static enum rofferr roff_TS(ROFF_ARGS);
210 static enum rofferr roff_EQ(ROFF_ARGS);
211 static enum rofferr roff_EN(ROFF_ARGS);
212 static enum rofferr roff_T_(ROFF_ARGS);
213 static enum rofferr roff_userdef(ROFF_ARGS);
214
215 /* See roffhash_find() */
216
217 #define ASCII_HI 126
218 #define ASCII_LO 33
219 #define HASHWIDTH (ASCII_HI - ASCII_LO + 1)
220
221 static struct roffmac *hash[HASHWIDTH];
222
223 static struct roffmac roffs[ROFF_MAX] = {
224 { "ad", roff_line_ignore, NULL, NULL, 0, NULL },
225 { "am", roff_block, roff_block_text, roff_block_sub, 0, NULL },
226 { "ami", roff_block, roff_block_text, roff_block_sub, 0, NULL },
227 { "am1", roff_block, roff_block_text, roff_block_sub, 0, NULL },
228 { "cc", roff_cc, NULL, NULL, 0, NULL },
229 { "de", roff_block, roff_block_text, roff_block_sub, 0, NULL },
230 { "dei", roff_block, roff_block_text, roff_block_sub, 0, NULL },
231 { "de1", roff_block, roff_block_text, roff_block_sub, 0, NULL },
232 { "ds", roff_ds, NULL, NULL, 0, NULL },
233 { "el", roff_cond, roff_cond_text, roff_cond_sub, ROFFMAC_STRUCT, NULL },
234 { "hy", roff_line_ignore, NULL, NULL, 0, NULL },
235 { "ie", roff_cond, roff_cond_text, roff_cond_sub, ROFFMAC_STRUCT, NULL },
236 { "if", roff_cond, roff_cond_text, roff_cond_sub, ROFFMAC_STRUCT, NULL },
237 { "ig", roff_block, roff_block_text, roff_block_sub, 0, NULL },
238 { "it", roff_it, NULL, NULL, 0, NULL },
239 { "ne", roff_line_ignore, NULL, NULL, 0, NULL },
240 { "nh", roff_line_ignore, NULL, NULL, 0, NULL },
241 { "nr", roff_nr, NULL, NULL, 0, NULL },
242 { "ns", roff_line_ignore, NULL, NULL, 0, NULL },
243 { "ps", roff_line_ignore, NULL, NULL, 0, NULL },
244 { "rm", roff_rm, NULL, NULL, 0, NULL },
245 { "so", roff_so, NULL, NULL, 0, NULL },
246 { "ta", roff_line_ignore, NULL, NULL, 0, NULL },
247 { "tr", roff_tr, NULL, NULL, 0, NULL },
248 { "Dd", roff_Dd, NULL, NULL, 0, NULL },
249 { "TH", roff_TH, NULL, NULL, 0, NULL },
250 { "TS", roff_TS, NULL, NULL, 0, NULL },
251 { "TE", roff_TE, NULL, NULL, 0, NULL },
252 { "T&", roff_T_, NULL, NULL, 0, NULL },
253 { "EQ", roff_EQ, NULL, NULL, 0, NULL },
254 { "EN", roff_EN, NULL, NULL, 0, NULL },
255 { ".", roff_cblock, NULL, NULL, 0, NULL },
256 { "\\}", roff_ccond, NULL, NULL, 0, NULL },
257 { NULL, roff_userdef, NULL, NULL, 0, NULL },
258 };
259
260 const char *const __mdoc_reserved[] = {
261 "Ac", "Ad", "An", "Ao", "Ap", "Aq", "Ar", "At",
262 "Bc", "Bd", "Bf", "Bk", "Bl", "Bo", "Bq",
263 "Brc", "Bro", "Brq", "Bsx", "Bt", "Bx",
264 "Cd", "Cm", "Db", "Dc", "Dd", "Dl", "Do", "Dq",
265 "Ds", "Dt", "Dv", "Dx", "D1",
266 "Ec", "Ed", "Ef", "Ek", "El", "Em", "em",
267 "En", "Eo", "Eq", "Er", "Es", "Ev", "Ex",
268 "Fa", "Fc", "Fd", "Fl", "Fn", "Fo", "Fr", "Ft", "Fx",
269 "Hf", "Ic", "In", "It", "Lb", "Li", "Lk", "Lp", "LP",
270 "Me", "Ms", "Mt", "Nd", "Nm", "No", "Ns", "Nx",
271 "Oc", "Oo", "Op", "Os", "Ot", "Ox",
272 "Pa", "Pc", "Pf", "Po", "Pp", "PP", "pp", "Pq",
273 "Qc", "Ql", "Qo", "Qq", "Or", "Rd", "Re", "Rs", "Rv",
274 "Sc", "Sf", "Sh", "SH", "Sm", "So", "Sq",
275 "Ss", "St", "Sx", "Sy",
276 "Ta", "Tn", "Ud", "Ux", "Va", "Vt", "Xc", "Xo", "Xr",
277 "%A", "%B", "%D", "%I", "%J", "%N", "%O",
278 "%P", "%Q", "%R", "%T", "%U", "%V",
279 NULL
280 };
281
282 const char *const __man_reserved[] = {
283 "AT", "B", "BI", "BR", "BT", "DE", "DS", "DT",
284 "EE", "EN", "EQ", "EX", "HF", "HP", "I", "IB", "IP", "IR",
285 "LP", "ME", "MT", "OP", "P", "PD", "PP", "PT",
286 "R", "RB", "RE", "RI", "RS", "SB", "SH", "SM", "SS", "SY",
287 "TE", "TH", "TP", "TQ", "TS", "T&", "UC", "UE", "UR", "YS",
288 NULL
289 };
290
291 /* Array of injected predefined strings. */
292 #define PREDEFS_MAX 38
293 static const struct predef predefs[PREDEFS_MAX] = {
294 #include "predefs.in"
295 };
296
297 /* See roffhash_find() */
298 #define ROFF_HASH(p) (p[0] - ASCII_LO)
299
300 static int roffit_lines; /* number of lines to delay */
301 static char *roffit_macro; /* nil-terminated macro line */
302
303 static void
304 roffhash_init(void)
305 {
306 struct roffmac *n;
307 int buc, i;
308
309 for (i = 0; i < (int)ROFF_USERDEF; i++) {
310 assert(roffs[i].name[0] >= ASCII_LO);
311 assert(roffs[i].name[0] <= ASCII_HI);
312
313 buc = ROFF_HASH(roffs[i].name);
314
315 if (NULL != (n = hash[buc])) {
316 for ( ; n->next; n = n->next)
317 /* Do nothing. */ ;
318 n->next = &roffs[i];
319 } else
320 hash[buc] = &roffs[i];
321 }
322 }
323
324 /*
325 * Look up a roff token by its name. Returns ROFF_MAX if no macro by
326 * the nil-terminated string name could be found.
327 */
328 static enum rofft
329 roffhash_find(const char *p, size_t s)
330 {
331 int buc;
332 struct roffmac *n;
333
334 /*
335 * libroff has an extremely simple hashtable, for the time
336 * being, which simply keys on the first character, which must
337 * be printable, then walks a chain. It works well enough until
338 * optimised.
339 */
340
341 if (p[0] < ASCII_LO || p[0] > ASCII_HI)
342 return(ROFF_MAX);
343
344 buc = ROFF_HASH(p);
345
346 if (NULL == (n = hash[buc]))
347 return(ROFF_MAX);
348 for ( ; n; n = n->next)
349 if (0 == strncmp(n->name, p, s) && '\0' == n->name[(int)s])
350 return((enum rofft)(n - roffs));
351
352 return(ROFF_MAX);
353 }
354
355
356 /*
357 * Pop the current node off of the stack of roff instructions currently
358 * pending.
359 */
360 static void
361 roffnode_pop(struct roff *r)
362 {
363 struct roffnode *p;
364
365 assert(r->last);
366 p = r->last;
367
368 r->last = r->last->parent;
369 free(p->name);
370 free(p->end);
371 free(p);
372 }
373
374
375 /*
376 * Push a roff node onto the instruction stack. This must later be
377 * removed with roffnode_pop().
378 */
379 static void
380 roffnode_push(struct roff *r, enum rofft tok, const char *name,
381 int line, int col)
382 {
383 struct roffnode *p;
384
385 p = mandoc_calloc(1, sizeof(struct roffnode));
386 p->tok = tok;
387 if (name)
388 p->name = mandoc_strdup(name);
389 p->parent = r->last;
390 p->line = line;
391 p->col = col;
392 p->rule = p->parent ? p->parent->rule : ROFFRULE_DENY;
393
394 r->last = p;
395 }
396
397
398 static void
399 roff_free1(struct roff *r)
400 {
401 struct tbl_node *tbl;
402 struct eqn_node *e;
403 int i;
404
405 while (NULL != (tbl = r->first_tbl)) {
406 r->first_tbl = tbl->next;
407 tbl_free(tbl);
408 }
409
410 r->first_tbl = r->last_tbl = r->tbl = NULL;
411
412 while (NULL != (e = r->first_eqn)) {
413 r->first_eqn = e->next;
414 eqn_free(e);
415 }
416
417 r->first_eqn = r->last_eqn = r->eqn = NULL;
418
419 while (r->last)
420 roffnode_pop(r);
421
422 roff_freestr(r->strtab);
423 roff_freestr(r->xmbtab);
424
425 r->strtab = r->xmbtab = NULL;
426
427 if (r->xtab)
428 for (i = 0; i < 128; i++)
429 free(r->xtab[i].p);
430
431 free(r->xtab);
432 r->xtab = NULL;
433 }
434
435 void
436 roff_reset(struct roff *r)
437 {
438 int i;
439
440 roff_free1(r);
441
442 r->control = 0;
443 memset(&r->regs, 0, sizeof(struct reg) * REG__MAX);
444
445 for (i = 0; i < PREDEFS_MAX; i++)
446 roff_setstr(r, predefs[i].name, predefs[i].str, 0);
447 }
448
449
450 void
451 roff_free(struct roff *r)
452 {
453
454 roff_free1(r);
455 free(r);
456 }
457
458
459 struct roff *
460 roff_alloc(enum mparset type, struct mparse *parse)
461 {
462 struct roff *r;
463 int i;
464
465 r = mandoc_calloc(1, sizeof(struct roff));
466 r->parsetype = type;
467 r->parse = parse;
468 r->rstackpos = -1;
469
470 roffhash_init();
471
472 for (i = 0; i < PREDEFS_MAX; i++)
473 roff_setstr(r, predefs[i].name, predefs[i].str, 0);
474
475 return(r);
476 }
477
478 /*
479 * Pre-filter each and every line for reserved words (one beginning with
480 * `\*', e.g., `\*(ab'). These must be handled before the actual line
481 * is processed.
482 * This also checks the syntax of regular escapes.
483 */
484 static enum rofferr
485 roff_res(struct roff *r, char **bufp, size_t *szp, int ln, int pos)
486 {
487 enum mandoc_esc esc;
488 const char *stesc; /* start of an escape sequence ('\\') */
489 const char *stnam; /* start of the name, after "[(*" */
490 const char *cp; /* end of the name, e.g. before ']' */
491 const char *res; /* the string to be substituted */
492 int i, maxl, expand_count;
493 size_t nsz;
494 char *n;
495
496 expand_count = 0;
497
498 again:
499 cp = *bufp + pos;
500 while (NULL != (cp = strchr(cp, '\\'))) {
501 stesc = cp++;
502
503 /*
504 * The second character must be an asterisk.
505 * If it isn't, skip it anyway: It is escaped,
506 * so it can't start another escape sequence.
507 */
508
509 if ('\0' == *cp)
510 return(ROFF_CONT);
511
512 if ('*' != *cp) {
513 res = cp;
514 esc = mandoc_escape(&cp, NULL, NULL);
515 if (ESCAPE_ERROR != esc)
516 continue;
517 cp = res;
518 mandoc_msg
519 (MANDOCERR_BADESCAPE, r->parse,
520 ln, (int)(stesc - *bufp), NULL);
521 return(ROFF_CONT);
522 }
523
524 cp++;
525
526 /*
527 * The third character decides the length
528 * of the name of the string.
529 * Save a pointer to the name.
530 */
531
532 switch (*cp) {
533 case ('\0'):
534 return(ROFF_CONT);
535 case ('('):
536 cp++;
537 maxl = 2;
538 break;
539 case ('['):
540 cp++;
541 maxl = 0;
542 break;
543 default:
544 maxl = 1;
545 break;
546 }
547 stnam = cp;
548
549 /* Advance to the end of the name. */
550
551 for (i = 0; 0 == maxl || i < maxl; i++, cp++) {
552 if ('\0' == *cp) {
553 mandoc_msg
554 (MANDOCERR_BADESCAPE,
555 r->parse, ln,
556 (int)(stesc - *bufp), NULL);
557 return(ROFF_CONT);
558 }
559 if (0 == maxl && ']' == *cp)
560 break;
561 }
562
563 /*
564 * Retrieve the replacement string; if it is
565 * undefined, resume searching for escapes.
566 */
567
568 res = roff_getstrn(r, stnam, (size_t)i);
569
570 if (NULL == res) {
571 mandoc_msg
572 (MANDOCERR_BADESCAPE, r->parse,
573 ln, (int)(stesc - *bufp), NULL);
574 res = "";
575 }
576
577 /* Replace the escape sequence by the string. */
578
579 pos = stesc - *bufp;
580
581 nsz = *szp + strlen(res) + 1;
582 n = mandoc_malloc(nsz);
583
584 strlcpy(n, *bufp, (size_t)(stesc - *bufp + 1));
585 strlcat(n, res, nsz);
586 strlcat(n, cp + (maxl ? 0 : 1), nsz);
587
588 free(*bufp);
589
590 *bufp = n;
591 *szp = nsz;
592
593 if (EXPAND_LIMIT >= ++expand_count)
594 goto again;
595
596 /* Just leave the string unexpanded. */
597 mandoc_msg(MANDOCERR_ROFFLOOP, r->parse, ln, pos, NULL);
598 return(ROFF_IGN);
599 }
600 return(ROFF_CONT);
601 }
602
603 /*
604 * Process text streams:
605 * Convert all breakable hyphens into ASCII_HYPH.
606 * Decrement and spring input line trap.
607 */
608 static enum rofferr
609 roff_parsetext(char **bufp, size_t *szp, int pos, int *offs)
610 {
611 size_t sz;
612 const char *start;
613 char *p;
614 int isz;
615 enum mandoc_esc esc;
616
617 start = p = *bufp + pos;
618
619 while ('\0' != *p) {
620 sz = strcspn(p, "-\\");
621 p += sz;
622
623 if ('\0' == *p)
624 break;
625
626 if ('\\' == *p) {
627 /* Skip over escapes. */
628 p++;
629 esc = mandoc_escape
630 ((const char **)&p, NULL, NULL);
631 if (ESCAPE_ERROR == esc)
632 break;
633 continue;
634 } else if (p == start) {
635 p++;
636 continue;
637 }
638
639 if (isalpha((unsigned char)p[-1]) &&
640 isalpha((unsigned char)p[1]))
641 *p = ASCII_HYPH;
642 p++;
643 }
644
645 /* Spring the input line trap. */
646 if (1 == roffit_lines) {
647 isz = asprintf(&p, "%s\n.%s", *bufp, roffit_macro);
648 if (-1 == isz) {
649 perror(NULL);
650 exit((int)MANDOCLEVEL_SYSERR);
651 }
652 free(*bufp);
653 *bufp = p;
654 *szp = isz + 1;
655 *offs = 0;
656 free(roffit_macro);
657 roffit_lines = 0;
658 return(ROFF_REPARSE);
659 } else if (1 < roffit_lines)
660 --roffit_lines;
661 return(ROFF_CONT);
662 }
663
664 enum rofferr
665 roff_parseln(struct roff *r, int ln, char **bufp,
666 size_t *szp, int pos, int *offs)
667 {
668 enum rofft t;
669 enum rofferr e;
670 int ppos, ctl;
671
672 /*
673 * Run the reserved-word filter only if we have some reserved
674 * words to fill in.
675 */
676
677 e = roff_res(r, bufp, szp, ln, pos);
678 if (ROFF_IGN == e)
679 return(e);
680 assert(ROFF_CONT == e);
681
682 ppos = pos;
683 ctl = roff_getcontrol(r, *bufp, &pos);
684
685 /*
686 * First, if a scope is open and we're not a macro, pass the
687 * text through the macro's filter. If a scope isn't open and
688 * we're not a macro, just let it through.
689 * Finally, if there's an equation scope open, divert it into it
690 * no matter our state.
691 */
692
693 if (r->last && ! ctl) {
694 t = r->last->tok;
695 assert(roffs[t].text);
696 e = (*roffs[t].text)
697 (r, t, bufp, szp, ln, pos, pos, offs);
698 assert(ROFF_IGN == e || ROFF_CONT == e);
699 if (ROFF_CONT != e)
700 return(e);
701 if (r->eqn)
702 return(eqn_read(&r->eqn, ln, *bufp, pos, offs));
703 if (r->tbl)
704 return(tbl_read(r->tbl, ln, *bufp, pos));
705 return(roff_parsetext(bufp, szp, pos, offs));
706 } else if ( ! ctl) {
707 if (r->eqn)
708 return(eqn_read(&r->eqn, ln, *bufp, pos, offs));
709 if (r->tbl)
710 return(tbl_read(r->tbl, ln, *bufp, pos));
711 return(roff_parsetext(bufp, szp, pos, offs));
712 } else if (r->eqn)
713 return(eqn_read(&r->eqn, ln, *bufp, ppos, offs));
714
715 /*
716 * If a scope is open, go to the child handler for that macro,
717 * as it may want to preprocess before doing anything with it.
718 * Don't do so if an equation is open.
719 */
720
721 if (r->last) {
722 t = r->last->tok;
723 assert(roffs[t].sub);
724 return((*roffs[t].sub)
725 (r, t, bufp, szp,
726 ln, ppos, pos, offs));
727 }
728
729 /*
730 * Lastly, as we've no scope open, try to look up and execute
731 * the new macro. If no macro is found, simply return and let
732 * the compilers handle it.
733 */
734
735 if (ROFF_MAX == (t = roff_parse(r, *bufp, &pos)))
736 return(ROFF_CONT);
737
738 assert(roffs[t].proc);
739 return((*roffs[t].proc)
740 (r, t, bufp, szp,
741 ln, ppos, pos, offs));
742 }
743
744
745 void
746 roff_endparse(struct roff *r)
747 {
748
749 if (r->last)
750 mandoc_msg(MANDOCERR_SCOPEEXIT, r->parse,
751 r->last->line, r->last->col, NULL);
752
753 if (r->eqn) {
754 mandoc_msg(MANDOCERR_SCOPEEXIT, r->parse,
755 r->eqn->eqn.ln, r->eqn->eqn.pos, NULL);
756 eqn_end(&r->eqn);
757 }
758
759 if (r->tbl) {
760 mandoc_msg(MANDOCERR_SCOPEEXIT, r->parse,
761 r->tbl->line, r->tbl->pos, NULL);
762 tbl_end(&r->tbl);
763 }
764 }
765
766 /*
767 * Parse a roff node's type from the input buffer. This must be in the
768 * form of ".foo xxx" in the usual way.
769 */
770 static enum rofft
771 roff_parse(struct roff *r, const char *buf, int *pos)
772 {
773 const char *mac;
774 size_t maclen;
775 enum rofft t;
776
777 if ('\0' == buf[*pos] || '"' == buf[*pos] ||
778 '\t' == buf[*pos] || ' ' == buf[*pos])
779 return(ROFF_MAX);
780
781 /*
782 * We stop the macro parse at an escape, tab, space, or nil.
783 * However, `\}' is also a valid macro, so make sure we don't
784 * clobber it by seeing the `\' as the end of token.
785 */
786
787 mac = buf + *pos;
788 maclen = strcspn(mac + 1, " \\\t\0") + 1;
789
790 t = (r->current_string = roff_getstrn(r, mac, maclen))
791 ? ROFF_USERDEF : roffhash_find(mac, maclen);
792
793 *pos += (int)maclen;
794
795 while (buf[*pos] && ' ' == buf[*pos])
796 (*pos)++;
797
798 return(t);
799 }
800
801 /* ARGSUSED */
802 static enum rofferr
803 roff_cblock(ROFF_ARGS)
804 {
805
806 /*
807 * A block-close `..' should only be invoked as a child of an
808 * ignore macro, otherwise raise a warning and just ignore it.
809 */
810
811 if (NULL == r->last) {
812 mandoc_msg(MANDOCERR_NOSCOPE, r->parse, ln, ppos, NULL);
813 return(ROFF_IGN);
814 }
815
816 switch (r->last->tok) {
817 case (ROFF_am):
818 /* FALLTHROUGH */
819 case (ROFF_ami):
820 /* FALLTHROUGH */
821 case (ROFF_am1):
822 /* FALLTHROUGH */
823 case (ROFF_de):
824 /* ROFF_de1 is remapped to ROFF_de in roff_block(). */
825 /* FALLTHROUGH */
826 case (ROFF_dei):
827 /* FALLTHROUGH */
828 case (ROFF_ig):
829 break;
830 default:
831 mandoc_msg(MANDOCERR_NOSCOPE, r->parse, ln, ppos, NULL);
832 return(ROFF_IGN);
833 }
834
835 if ((*bufp)[pos])
836 mandoc_msg(MANDOCERR_ARGSLOST, r->parse, ln, pos, NULL);
837
838 roffnode_pop(r);
839 roffnode_cleanscope(r);
840 return(ROFF_IGN);
841
842 }
843
844
845 static void
846 roffnode_cleanscope(struct roff *r)
847 {
848
849 while (r->last) {
850 if (--r->last->endspan != 0)
851 break;
852 roffnode_pop(r);
853 }
854 }
855
856
857 /* ARGSUSED */
858 static enum rofferr
859 roff_ccond(ROFF_ARGS)
860 {
861
862 if (NULL == r->last) {
863 mandoc_msg(MANDOCERR_NOSCOPE, r->parse, ln, ppos, NULL);
864 return(ROFF_IGN);
865 }
866
867 switch (r->last->tok) {
868 case (ROFF_el):
869 /* FALLTHROUGH */
870 case (ROFF_ie):
871 /* FALLTHROUGH */
872 case (ROFF_if):
873 break;
874 default:
875 mandoc_msg(MANDOCERR_NOSCOPE, r->parse, ln, ppos, NULL);
876 return(ROFF_IGN);
877 }
878
879 if (r->last->endspan > -1) {
880 mandoc_msg(MANDOCERR_NOSCOPE, r->parse, ln, ppos, NULL);
881 return(ROFF_IGN);
882 }
883
884 if ((*bufp)[pos])
885 mandoc_msg(MANDOCERR_ARGSLOST, r->parse, ln, pos, NULL);
886
887 roffnode_pop(r);
888 roffnode_cleanscope(r);
889 return(ROFF_IGN);
890 }
891
892
893 /* ARGSUSED */
894 static enum rofferr
895 roff_block(ROFF_ARGS)
896 {
897 int sv;
898 size_t sz;
899 char *name;
900
901 name = NULL;
902
903 if (ROFF_ig != tok) {
904 if ('\0' == (*bufp)[pos]) {
905 mandoc_msg(MANDOCERR_NOARGS, r->parse, ln, ppos, NULL);
906 return(ROFF_IGN);
907 }
908
909 /*
910 * Re-write `de1', since we don't really care about
911 * groff's strange compatibility mode, into `de'.
912 */
913
914 if (ROFF_de1 == tok)
915 tok = ROFF_de;
916 if (ROFF_de == tok)
917 name = *bufp + pos;
918 else
919 mandoc_msg(MANDOCERR_REQUEST, r->parse, ln, ppos,
920 roffs[tok].name);
921
922 while ((*bufp)[pos] && ! isspace((unsigned char)(*bufp)[pos]))
923 pos++;
924
925 while (isspace((unsigned char)(*bufp)[pos]))
926 (*bufp)[pos++] = '\0';
927 }
928
929 roffnode_push(r, tok, name, ln, ppos);
930
931 /*
932 * At the beginning of a `de' macro, clear the existing string
933 * with the same name, if there is one. New content will be
934 * added from roff_block_text() in multiline mode.
935 */
936
937 if (ROFF_de == tok)
938 roff_setstr(r, name, "", 0);
939
940 if ('\0' == (*bufp)[pos])
941 return(ROFF_IGN);
942
943 /* If present, process the custom end-of-line marker. */
944
945 sv = pos;
946 while ((*bufp)[pos] && ! isspace((unsigned char)(*bufp)[pos]))
947 pos++;
948
949 /*
950 * Note: groff does NOT like escape characters in the input.
951 * Instead of detecting this, we're just going to let it fly and
952 * to hell with it.
953 */
954
955 assert(pos > sv);
956 sz = (size_t)(pos - sv);
957
958 if (1 == sz && '.' == (*bufp)[sv])
959 return(ROFF_IGN);
960
961 r->last->end = mandoc_malloc(sz + 1);
962
963 memcpy(r->last->end, *bufp + sv, sz);
964 r->last->end[(int)sz] = '\0';
965
966 if ((*bufp)[pos])
967 mandoc_msg(MANDOCERR_ARGSLOST, r->parse, ln, pos, NULL);
968
969 return(ROFF_IGN);
970 }
971
972
973 /* ARGSUSED */
974 static enum rofferr
975 roff_block_sub(ROFF_ARGS)
976 {
977 enum rofft t;
978 int i, j;
979
980 /*
981 * First check whether a custom macro exists at this level. If
982 * it does, then check against it. This is some of groff's
983 * stranger behaviours. If we encountered a custom end-scope
984 * tag and that tag also happens to be a "real" macro, then we
985 * need to try interpreting it again as a real macro. If it's
986 * not, then return ignore. Else continue.
987 */
988
989 if (r->last->end) {
990 for (i = pos, j = 0; r->last->end[j]; j++, i++)
991 if ((*bufp)[i] != r->last->end[j])
992 break;
993
994 if ('\0' == r->last->end[j] &&
995 ('\0' == (*bufp)[i] ||
996 ' ' == (*bufp)[i] ||
997 '\t' == (*bufp)[i])) {
998 roffnode_pop(r);
999 roffnode_cleanscope(r);
1000
1001 while (' ' == (*bufp)[i] || '\t' == (*bufp)[i])
1002 i++;
1003
1004 pos = i;
1005 if (ROFF_MAX != roff_parse(r, *bufp, &pos))
1006 return(ROFF_RERUN);
1007 return(ROFF_IGN);
1008 }
1009 }
1010
1011 /*
1012 * If we have no custom end-query or lookup failed, then try
1013 * pulling it out of the hashtable.
1014 */
1015
1016 t = roff_parse(r, *bufp, &pos);
1017
1018 /*
1019 * Macros other than block-end are only significant
1020 * in `de' blocks; elsewhere, simply throw them away.
1021 */
1022 if (ROFF_cblock != t) {
1023 if (ROFF_de == tok)
1024 roff_setstr(r, r->last->name, *bufp + ppos, 1);
1025 return(ROFF_IGN);
1026 }
1027
1028 assert(roffs[t].proc);
1029 return((*roffs[t].proc)(r, t, bufp, szp,
1030 ln, ppos, pos, offs));
1031 }
1032
1033
1034 /* ARGSUSED */
1035 static enum rofferr
1036 roff_block_text(ROFF_ARGS)
1037 {
1038
1039 if (ROFF_de == tok)
1040 roff_setstr(r, r->last->name, *bufp + pos, 1);
1041
1042 return(ROFF_IGN);
1043 }
1044
1045
1046 /* ARGSUSED */
1047 static enum rofferr
1048 roff_cond_sub(ROFF_ARGS)
1049 {
1050 enum rofft t;
1051 enum roffrule rr;
1052 char *ep;
1053
1054 rr = r->last->rule;
1055 roffnode_cleanscope(r);
1056 t = roff_parse(r, *bufp, &pos);
1057
1058 /*
1059 * Fully handle known macros when they are structurally
1060 * required or when the conditional evaluated to true.
1061 */
1062
1063 if ((ROFF_MAX != t) &&
1064 (ROFF_ccond == t || ROFFRULE_ALLOW == rr ||
1065 ROFFMAC_STRUCT & roffs[t].flags)) {
1066 assert(roffs[t].proc);
1067 return((*roffs[t].proc)(r, t, bufp, szp,
1068 ln, ppos, pos, offs));
1069 }
1070
1071 /* Always check for the closing delimiter `\}'. */
1072
1073 ep = &(*bufp)[pos];
1074 while (NULL != (ep = strchr(ep, '\\'))) {
1075 if ('}' != *(++ep))
1076 continue;
1077
1078 /*
1079 * If we're at the end of line, then just chop
1080 * off the \} and resize the buffer.
1081 * If we aren't, then convert it to spaces.
1082 */
1083
1084 if ('\0' == *(ep + 1)) {
1085 *--ep = '\0';
1086 *szp -= 2;
1087 } else
1088 *(ep - 1) = *ep = ' ';
1089
1090 roff_ccond(r, ROFF_ccond, bufp, szp,
1091 ln, pos, pos + 2, offs);
1092 break;
1093 }
1094 return(ROFFRULE_DENY == rr ? ROFF_IGN : ROFF_CONT);
1095 }
1096
1097 /* ARGSUSED */
1098 static enum rofferr
1099 roff_cond_text(ROFF_ARGS)
1100 {
1101 char *ep;
1102 enum roffrule rr;
1103
1104 rr = r->last->rule;
1105 roffnode_cleanscope(r);
1106
1107 ep = &(*bufp)[pos];
1108 for ( ; NULL != (ep = strchr(ep, '\\')); ep++) {
1109 ep++;
1110 if ('}' != *ep)
1111 continue;
1112 *ep = '&';
1113 roff_ccond(r, ROFF_ccond, bufp, szp,
1114 ln, pos, pos + 2, offs);
1115 }
1116 return(ROFFRULE_DENY == rr ? ROFF_IGN : ROFF_CONT);
1117 }
1118
1119 static enum roffrule
1120 roff_evalcond(const char *v, int *pos)
1121 {
1122
1123 switch (v[*pos]) {
1124 case ('n'):
1125 (*pos)++;
1126 return(ROFFRULE_ALLOW);
1127 case ('e'):
1128 /* FALLTHROUGH */
1129 case ('o'):
1130 /* FALLTHROUGH */
1131 case ('t'):
1132 (*pos)++;
1133 return(ROFFRULE_DENY);
1134 default:
1135 break;
1136 }
1137
1138 while (v[*pos] && ' ' != v[*pos])
1139 (*pos)++;
1140 return(ROFFRULE_DENY);
1141 }
1142
1143 /* ARGSUSED */
1144 static enum rofferr
1145 roff_line_ignore(ROFF_ARGS)
1146 {
1147
1148 return(ROFF_IGN);
1149 }
1150
1151 /* ARGSUSED */
1152 static enum rofferr
1153 roff_cond(ROFF_ARGS)
1154 {
1155
1156 roffnode_push(r, tok, NULL, ln, ppos);
1157
1158 /*
1159 * An `.el' has no conditional body: it will consume the value
1160 * of the current rstack entry set in prior `ie' calls or
1161 * defaults to DENY.
1162 *
1163 * If we're not an `el', however, then evaluate the conditional.
1164 */
1165
1166 r->last->rule = ROFF_el == tok ?
1167 (r->rstackpos < 0 ?
1168 ROFFRULE_DENY : r->rstack[r->rstackpos--]) :
1169 roff_evalcond(*bufp, &pos);
1170
1171 /*
1172 * An if-else will put the NEGATION of the current evaluated
1173 * conditional into the stack of rules.
1174 */
1175
1176 if (ROFF_ie == tok) {
1177 if (r->rstackpos == RSTACK_MAX - 1) {
1178 mandoc_msg(MANDOCERR_MEM,
1179 r->parse, ln, ppos, NULL);
1180 return(ROFF_ERR);
1181 }
1182 r->rstack[++r->rstackpos] =
1183 ROFFRULE_DENY == r->last->rule ?
1184 ROFFRULE_ALLOW : ROFFRULE_DENY;
1185 }
1186
1187 /* If the parent has false as its rule, then so do we. */
1188
1189 if (r->last->parent && ROFFRULE_DENY == r->last->parent->rule)
1190 r->last->rule = ROFFRULE_DENY;
1191
1192 /*
1193 * Determine scope.
1194 * If there is nothing on the line after the conditional,
1195 * not even whitespace, use next-line scope.
1196 */
1197
1198 if ('\0' == (*bufp)[pos]) {
1199 r->last->endspan = 2;
1200 goto out;
1201 }
1202
1203 while (' ' == (*bufp)[pos])
1204 pos++;
1205
1206 /* An opening brace requests multiline scope. */
1207
1208 if ('\\' == (*bufp)[pos] && '{' == (*bufp)[pos + 1]) {
1209 r->last->endspan = -1;
1210 pos += 2;
1211 goto out;
1212 }
1213
1214 /*
1215 * Anything else following the conditional causes
1216 * single-line scope. Warn if the scope contains
1217 * nothing but trailing whitespace.
1218 */
1219
1220 if ('\0' == (*bufp)[pos])
1221 mandoc_msg(MANDOCERR_NOARGS, r->parse, ln, ppos, NULL);
1222
1223 r->last->endspan = 1;
1224
1225 out:
1226 *offs = pos;
1227 return(ROFF_RERUN);
1228 }
1229
1230
1231 /* ARGSUSED */
1232 static enum rofferr
1233 roff_ds(ROFF_ARGS)
1234 {
1235 char *name, *string;
1236
1237 /*
1238 * A symbol is named by the first word following the macro
1239 * invocation up to a space. Its value is anything after the
1240 * name's trailing whitespace and optional double-quote. Thus,
1241 *
1242 * [.ds foo "bar " ]
1243 *
1244 * will have `bar " ' as its value.
1245 */
1246
1247 string = *bufp + pos;
1248 name = roff_getname(r, &string, ln, pos);
1249 if ('\0' == *name)
1250 return(ROFF_IGN);
1251
1252 /* Read past initial double-quote. */
1253 if ('"' == *string)
1254 string++;
1255
1256 /* The rest is the value. */
1257 roff_setstr(r, name, string, 0);
1258 return(ROFF_IGN);
1259 }
1260
1261 int
1262 roff_regisset(const struct roff *r, enum regs reg)
1263 {
1264
1265 return(r->regs[(int)reg].set);
1266 }
1267
1268 unsigned int
1269 roff_regget(const struct roff *r, enum regs reg)
1270 {
1271
1272 return(r->regs[(int)reg].u);
1273 }
1274
1275 void
1276 roff_regunset(struct roff *r, enum regs reg)
1277 {
1278
1279 r->regs[(int)reg].set = 0;
1280 }
1281
1282 /* ARGSUSED */
1283 static enum rofferr
1284 roff_nr(ROFF_ARGS)
1285 {
1286 const char *key;
1287 char *val;
1288 int iv;
1289
1290 val = *bufp + pos;
1291 key = roff_getname(r, &val, ln, pos);
1292
1293 if (0 == strcmp(key, "nS")) {
1294 r->regs[(int)REG_nS].set = 1;
1295 if ((iv = mandoc_strntoi(val, strlen(val), 10)) >= 0)
1296 r->regs[(int)REG_nS].u = (unsigned)iv;
1297 else
1298 r->regs[(int)REG_nS].u = 0u;
1299 }
1300
1301 return(ROFF_IGN);
1302 }
1303
1304 /* ARGSUSED */
1305 static enum rofferr
1306 roff_rm(ROFF_ARGS)
1307 {
1308 const char *name;
1309 char *cp;
1310
1311 cp = *bufp + pos;
1312 while ('\0' != *cp) {
1313 name = roff_getname(r, &cp, ln, (int)(cp - *bufp));
1314 if ('\0' != *name)
1315 roff_setstr(r, name, NULL, 0);
1316 }
1317 return(ROFF_IGN);
1318 }
1319
1320 /* ARGSUSED */
1321 static enum rofferr
1322 roff_it(ROFF_ARGS)
1323 {
1324 char *cp;
1325 size_t len;
1326 int iv;
1327
1328 /* Parse the number of lines. */
1329 cp = *bufp + pos;
1330 len = strcspn(cp, " \t");
1331 cp[len] = '\0';
1332 if ((iv = mandoc_strntoi(cp, len, 10)) <= 0) {
1333 mandoc_msg(MANDOCERR_NUMERIC, r->parse,
1334 ln, ppos, *bufp + 1);
1335 return(ROFF_IGN);
1336 }
1337 cp += len + 1;
1338
1339 /* Arm the input line trap. */
1340 roffit_lines = iv;
1341 roffit_macro = mandoc_strdup(cp);
1342 return(ROFF_IGN);
1343 }
1344
1345 /* ARGSUSED */
1346 static enum rofferr
1347 roff_Dd(ROFF_ARGS)
1348 {
1349 const char *const *cp;
1350
1351 if (MPARSE_MDOC != r->parsetype)
1352 for (cp = __mdoc_reserved; *cp; cp++)
1353 roff_setstr(r, *cp, NULL, 0);
1354
1355 return(ROFF_CONT);
1356 }
1357
1358 /* ARGSUSED */
1359 static enum rofferr
1360 roff_TH(ROFF_ARGS)
1361 {
1362 const char *const *cp;
1363
1364 if (MPARSE_MDOC != r->parsetype)
1365 for (cp = __man_reserved; *cp; cp++)
1366 roff_setstr(r, *cp, NULL, 0);
1367
1368 return(ROFF_CONT);
1369 }
1370
1371 /* ARGSUSED */
1372 static enum rofferr
1373 roff_TE(ROFF_ARGS)
1374 {
1375
1376 if (NULL == r->tbl)
1377 mandoc_msg(MANDOCERR_NOSCOPE, r->parse, ln, ppos, NULL);
1378 else
1379 tbl_end(&r->tbl);
1380
1381 return(ROFF_IGN);
1382 }
1383
1384 /* ARGSUSED */
1385 static enum rofferr
1386 roff_T_(ROFF_ARGS)
1387 {
1388
1389 if (NULL == r->tbl)
1390 mandoc_msg(MANDOCERR_NOSCOPE, r->parse, ln, ppos, NULL);
1391 else
1392 tbl_restart(ppos, ln, r->tbl);
1393
1394 return(ROFF_IGN);
1395 }
1396
1397 #if 0
1398 static int
1399 roff_closeeqn(struct roff *r)
1400 {
1401
1402 return(r->eqn && ROFF_EQN == eqn_end(&r->eqn) ? 1 : 0);
1403 }
1404 #endif
1405
1406 static void
1407 roff_openeqn(struct roff *r, const char *name, int line,
1408 int offs, const char *buf)
1409 {
1410 struct eqn_node *e;
1411 int poff;
1412
1413 assert(NULL == r->eqn);
1414 e = eqn_alloc(name, offs, line, r->parse);
1415
1416 if (r->last_eqn)
1417 r->last_eqn->next = e;
1418 else
1419 r->first_eqn = r->last_eqn = e;
1420
1421 r->eqn = r->last_eqn = e;
1422
1423 if (buf) {
1424 poff = 0;
1425 eqn_read(&r->eqn, line, buf, offs, &poff);
1426 }
1427 }
1428
1429 /* ARGSUSED */
1430 static enum rofferr
1431 roff_EQ(ROFF_ARGS)
1432 {
1433
1434 roff_openeqn(r, *bufp + pos, ln, ppos, NULL);
1435 return(ROFF_IGN);
1436 }
1437
1438 /* ARGSUSED */
1439 static enum rofferr
1440 roff_EN(ROFF_ARGS)
1441 {
1442
1443 mandoc_msg(MANDOCERR_NOSCOPE, r->parse, ln, ppos, NULL);
1444 return(ROFF_IGN);
1445 }
1446
1447 /* ARGSUSED */
1448 static enum rofferr
1449 roff_TS(ROFF_ARGS)
1450 {
1451 struct tbl_node *tbl;
1452
1453 if (r->tbl) {
1454 mandoc_msg(MANDOCERR_SCOPEBROKEN, r->parse, ln, ppos, NULL);
1455 tbl_end(&r->tbl);
1456 }
1457
1458 tbl = tbl_alloc(ppos, ln, r->parse);
1459
1460 if (r->last_tbl)
1461 r->last_tbl->next = tbl;
1462 else
1463 r->first_tbl = r->last_tbl = tbl;
1464
1465 r->tbl = r->last_tbl = tbl;
1466 return(ROFF_IGN);
1467 }
1468
1469 /* ARGSUSED */
1470 static enum rofferr
1471 roff_cc(ROFF_ARGS)
1472 {
1473 const char *p;
1474
1475 p = *bufp + pos;
1476
1477 if ('\0' == *p || '.' == (r->control = *p++))
1478 r->control = 0;
1479
1480 if ('\0' != *p)
1481 mandoc_msg(MANDOCERR_ARGCOUNT, r->parse, ln, ppos, NULL);
1482
1483 return(ROFF_IGN);
1484 }
1485
1486 /* ARGSUSED */
1487 static enum rofferr
1488 roff_tr(ROFF_ARGS)
1489 {
1490 const char *p, *first, *second;
1491 size_t fsz, ssz;
1492 enum mandoc_esc esc;
1493
1494 p = *bufp + pos;
1495
1496 if ('\0' == *p) {
1497 mandoc_msg(MANDOCERR_ARGCOUNT, r->parse, ln, ppos, NULL);
1498 return(ROFF_IGN);
1499 }
1500
1501 while ('\0' != *p) {
1502 fsz = ssz = 1;
1503
1504 first = p++;
1505 if ('\\' == *first) {
1506 esc = mandoc_escape(&p, NULL, NULL);
1507 if (ESCAPE_ERROR == esc) {
1508 mandoc_msg
1509 (MANDOCERR_BADESCAPE, r->parse,
1510 ln, (int)(p - *bufp), NULL);
1511 return(ROFF_IGN);
1512 }
1513 fsz = (size_t)(p - first);
1514 }
1515
1516 second = p++;
1517 if ('\\' == *second) {
1518 esc = mandoc_escape(&p, NULL, NULL);
1519 if (ESCAPE_ERROR == esc) {
1520 mandoc_msg
1521 (MANDOCERR_BADESCAPE, r->parse,
1522 ln, (int)(p - *bufp), NULL);
1523 return(ROFF_IGN);
1524 }
1525 ssz = (size_t)(p - second);
1526 } else if ('\0' == *second) {
1527 mandoc_msg(MANDOCERR_ARGCOUNT, r->parse,
1528 ln, (int)(p - *bufp), NULL);
1529 second = " ";
1530 p--;
1531 }
1532
1533 if (fsz > 1) {
1534 roff_setstrn(&r->xmbtab, first,
1535 fsz, second, ssz, 0);
1536 continue;
1537 }
1538
1539 if (NULL == r->xtab)
1540 r->xtab = mandoc_calloc
1541 (128, sizeof(struct roffstr));
1542
1543 free(r->xtab[(int)*first].p);
1544 r->xtab[(int)*first].p = mandoc_strndup(second, ssz);
1545 r->xtab[(int)*first].sz = ssz;
1546 }
1547
1548 return(ROFF_IGN);
1549 }
1550
1551 /* ARGSUSED */
1552 static enum rofferr
1553 roff_so(ROFF_ARGS)
1554 {
1555 char *name;
1556
1557 mandoc_msg(MANDOCERR_SO, r->parse, ln, ppos, NULL);
1558
1559 /*
1560 * Handle `so'. Be EXTREMELY careful, as we shouldn't be
1561 * opening anything that's not in our cwd or anything beneath
1562 * it. Thus, explicitly disallow traversing up the file-system
1563 * or using absolute paths.
1564 */
1565
1566 name = *bufp + pos;
1567 if ('/' == *name || strstr(name, "../") || strstr(name, "/..")) {
1568 mandoc_msg(MANDOCERR_SOPATH, r->parse, ln, pos, NULL);
1569 return(ROFF_ERR);
1570 }
1571
1572 *offs = pos;
1573 return(ROFF_SO);
1574 }
1575
1576 /* ARGSUSED */
1577 static enum rofferr
1578 roff_userdef(ROFF_ARGS)
1579 {
1580 const char *arg[9];
1581 char *cp, *n1, *n2;
1582 int i;
1583
1584 /*
1585 * Collect pointers to macro argument strings
1586 * and null-terminate them.
1587 */
1588 cp = *bufp + pos;
1589 for (i = 0; i < 9; i++)
1590 arg[i] = '\0' == *cp ? "" :
1591 mandoc_getarg(r->parse, &cp, ln, &pos);
1592
1593 /*
1594 * Expand macro arguments.
1595 */
1596 *szp = 0;
1597 n1 = cp = mandoc_strdup(r->current_string);
1598 while (NULL != (cp = strstr(cp, "\\$"))) {
1599 i = cp[2] - '1';
1600 if (0 > i || 8 < i) {
1601 /* Not an argument invocation. */
1602 cp += 2;
1603 continue;
1604 }
1605
1606 *szp = strlen(n1) - 3 + strlen(arg[i]) + 1;
1607 n2 = mandoc_malloc(*szp);
1608
1609 strlcpy(n2, n1, (size_t)(cp - n1 + 1));
1610 strlcat(n2, arg[i], *szp);
1611 strlcat(n2, cp + 3, *szp);
1612
1613 cp = n2 + (cp - n1);
1614 free(n1);
1615 n1 = n2;
1616 }
1617
1618 /*
1619 * Replace the macro invocation
1620 * by the expanded macro.
1621 */
1622 free(*bufp);
1623 *bufp = n1;
1624 if (0 == *szp)
1625 *szp = strlen(*bufp) + 1;
1626
1627 return(*szp > 1 && '\n' == (*bufp)[(int)*szp - 2] ?
1628 ROFF_REPARSE : ROFF_APPEND);
1629 }
1630
1631 static char *
1632 roff_getname(struct roff *r, char **cpp, int ln, int pos)
1633 {
1634 char *name, *cp;
1635
1636 name = *cpp;
1637 if ('\0' == *name)
1638 return(name);
1639
1640 /* Read until end of name. */
1641 for (cp = name; '\0' != *cp && ' ' != *cp; cp++) {
1642 if ('\\' != *cp)
1643 continue;
1644 cp++;
1645 if ('\\' == *cp)
1646 continue;
1647 mandoc_msg(MANDOCERR_NAMESC, r->parse, ln, pos, NULL);
1648 *cp = '\0';
1649 name = cp;
1650 }
1651
1652 /* Nil-terminate name. */
1653 if ('\0' != *cp)
1654 *(cp++) = '\0';
1655
1656 /* Read past spaces. */
1657 while (' ' == *cp)
1658 cp++;
1659
1660 *cpp = cp;
1661 return(name);
1662 }
1663
1664 /*
1665 * Store *string into the user-defined string called *name.
1666 * In multiline mode, append to an existing entry and append '\n';
1667 * else replace the existing entry, if there is one.
1668 * To clear an existing entry, call with (*r, *name, NULL, 0).
1669 */
1670 static void
1671 roff_setstr(struct roff *r, const char *name, const char *string,
1672 int multiline)
1673 {
1674
1675 roff_setstrn(&r->strtab, name, strlen(name), string,
1676 string ? strlen(string) : 0, multiline);
1677 }
1678
1679 static void
1680 roff_setstrn(struct roffkv **r, const char *name, size_t namesz,
1681 const char *string, size_t stringsz, int multiline)
1682 {
1683 struct roffkv *n;
1684 char *c;
1685 int i;
1686 size_t oldch, newch;
1687
1688 /* Search for an existing string with the same name. */
1689 n = *r;
1690
1691 while (n && strcmp(name, n->key.p))
1692 n = n->next;
1693
1694 if (NULL == n) {
1695 /* Create a new string table entry. */
1696 n = mandoc_malloc(sizeof(struct roffkv));
1697 n->key.p = mandoc_strndup(name, namesz);
1698 n->key.sz = namesz;
1699 n->val.p = NULL;
1700 n->val.sz = 0;
1701 n->next = *r;
1702 *r = n;
1703 } else if (0 == multiline) {
1704 /* In multiline mode, append; else replace. */
1705 free(n->val.p);
1706 n->val.p = NULL;
1707 n->val.sz = 0;
1708 }
1709
1710 if (NULL == string)
1711 return;
1712
1713 /*
1714 * One additional byte for the '\n' in multiline mode,
1715 * and one for the terminating '\0'.
1716 */
1717 newch = stringsz + (multiline ? 2u : 1u);
1718
1719 if (NULL == n->val.p) {
1720 n->val.p = mandoc_malloc(newch);
1721 *n->val.p = '\0';
1722 oldch = 0;
1723 } else {
1724 oldch = n->val.sz;
1725 n->val.p = mandoc_realloc(n->val.p, oldch + newch);
1726 }
1727
1728 /* Skip existing content in the destination buffer. */
1729 c = n->val.p + (int)oldch;
1730
1731 /* Append new content to the destination buffer. */
1732 i = 0;
1733 while (i < (int)stringsz) {
1734 /*
1735 * Rudimentary roff copy mode:
1736 * Handle escaped backslashes.
1737 */
1738 if ('\\' == string[i] && '\\' == string[i + 1])
1739 i++;
1740 *c++ = string[i++];
1741 }
1742
1743 /* Append terminating bytes. */
1744 if (multiline)
1745 *c++ = '\n';
1746
1747 *c = '\0';
1748 n->val.sz = (int)(c - n->val.p);
1749 }
1750
1751 static const char *
1752 roff_getstrn(const struct roff *r, const char *name, size_t len)
1753 {
1754 const struct roffkv *n;
1755
1756 for (n = r->strtab; n; n = n->next)
1757 if (0 == strncmp(name, n->key.p, len) &&
1758 '\0' == n->key.p[(int)len])
1759 return(n->val.p);
1760
1761 return(NULL);
1762 }
1763
1764 static void
1765 roff_freestr(struct roffkv *r)
1766 {
1767 struct roffkv *n, *nn;
1768
1769 for (n = r; n; n = nn) {
1770 free(n->key.p);
1771 free(n->val.p);
1772 nn = n->next;
1773 free(n);
1774 }
1775 }
1776
1777 const struct tbl_span *
1778 roff_span(const struct roff *r)
1779 {
1780
1781 return(r->tbl ? tbl_span(r->tbl) : NULL);
1782 }
1783
1784 const struct eqn *
1785 roff_eqn(const struct roff *r)
1786 {
1787
1788 return(r->last_eqn ? &r->last_eqn->eqn : NULL);
1789 }
1790
1791 /*
1792 * Duplicate an input string, making the appropriate character
1793 * conversations (as stipulated by `tr') along the way.
1794 * Returns a heap-allocated string with all the replacements made.
1795 */
1796 char *
1797 roff_strdup(const struct roff *r, const char *p)
1798 {
1799 const struct roffkv *cp;
1800 char *res;
1801 const char *pp;
1802 size_t ssz, sz;
1803 enum mandoc_esc esc;
1804
1805 if (NULL == r->xmbtab && NULL == r->xtab)
1806 return(mandoc_strdup(p));
1807 else if ('\0' == *p)
1808 return(mandoc_strdup(""));
1809
1810 /*
1811 * Step through each character looking for term matches
1812 * (remember that a `tr' can be invoked with an escape, which is
1813 * a glyph but the escape is multi-character).
1814 * We only do this if the character hash has been initialised
1815 * and the string is >0 length.
1816 */
1817
1818 res = NULL;
1819 ssz = 0;
1820
1821 while ('\0' != *p) {
1822 if ('\\' != *p && r->xtab && r->xtab[(int)*p].p) {
1823 sz = r->xtab[(int)*p].sz;
1824 res = mandoc_realloc(res, ssz + sz + 1);
1825 memcpy(res + ssz, r->xtab[(int)*p].p, sz);
1826 ssz += sz;
1827 p++;
1828 continue;
1829 } else if ('\\' != *p) {
1830 res = mandoc_realloc(res, ssz + 2);
1831 res[ssz++] = *p++;
1832 continue;
1833 }
1834
1835 /* Search for term matches. */
1836 for (cp = r->xmbtab; cp; cp = cp->next)
1837 if (0 == strncmp(p, cp->key.p, cp->key.sz))
1838 break;
1839
1840 if (NULL != cp) {
1841 /*
1842 * A match has been found.
1843 * Append the match to the array and move
1844 * forward by its keysize.
1845 */
1846 res = mandoc_realloc
1847 (res, ssz + cp->val.sz + 1);
1848 memcpy(res + ssz, cp->val.p, cp->val.sz);
1849 ssz += cp->val.sz;
1850 p += (int)cp->key.sz;
1851 continue;
1852 }
1853
1854 /*
1855 * Handle escapes carefully: we need to copy
1856 * over just the escape itself, or else we might
1857 * do replacements within the escape itself.
1858 * Make sure to pass along the bogus string.
1859 */
1860 pp = p++;
1861 esc = mandoc_escape(&p, NULL, NULL);
1862 if (ESCAPE_ERROR == esc) {
1863 sz = strlen(pp);
1864 res = mandoc_realloc(res, ssz + sz + 1);
1865 memcpy(res + ssz, pp, sz);
1866 break;
1867 }
1868 /*
1869 * We bail out on bad escapes.
1870 * No need to warn: we already did so when
1871 * roff_res() was called.
1872 */
1873 sz = (int)(p - pp);
1874 res = mandoc_realloc(res, ssz + sz + 1);
1875 memcpy(res + ssz, pp, sz);
1876 ssz += sz;
1877 }
1878
1879 res[(int)ssz] = '\0';
1880 return(res);
1881 }
1882
1883 /*
1884 * Find out whether a line is a macro line or not.
1885 * If it is, adjust the current position and return one; if it isn't,
1886 * return zero and don't change the current position.
1887 * If the control character has been set with `.cc', then let that grain
1888 * precedence.
1889 * This is slighly contrary to groff, where using the non-breaking
1890 * control character when `cc' has been invoked will cause the
1891 * non-breaking macro contents to be printed verbatim.
1892 */
1893 int
1894 roff_getcontrol(const struct roff *r, const char *cp, int *ppos)
1895 {
1896 int pos;
1897
1898 pos = *ppos;
1899
1900 if (0 != r->control && cp[pos] == r->control)
1901 pos++;
1902 else if (0 != r->control)
1903 return(0);
1904 else if ('\\' == cp[pos] && '.' == cp[pos + 1])
1905 pos += 2;
1906 else if ('.' == cp[pos] || '\'' == cp[pos])
1907 pos++;
1908 else
1909 return(0);
1910
1911 while (' ' == cp[pos] || '\t' == cp[pos])
1912 pos++;
1913
1914 *ppos = pos;
1915 return(1);
1916 }
A git conversion mirror of mandoc.bsd.lv