?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
8322 nl: misleading-indentation
[unleashed/tickless.git] / usr / src / cmd / mandoc / roff.c
blob13b9439e4df92b49062efcfe1e636e6ea328521e
1 /* $Id: roff.c,v 1.284 2016/01/08 17:48:10 schwarze Exp $ */
2 /*
3 * Copyright (c) 2008-2012, 2014 Kristaps Dzonsons <kristaps@bsd.lv>
4 * Copyright (c) 2010-2015 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 #include "config.h"
19
20 #include <sys/types.h>
21
22 #include <assert.h>
23 #include <ctype.h>
24 #include <limits.h>
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28
29 #include "mandoc.h"
30 #include "mandoc_aux.h"
31 #include "roff.h"
32 #include "libmandoc.h"
33 #include "roff_int.h"
34 #include "libroff.h"
35
36 /* Maximum number of string expansions per line, to break infinite loops. */
37 #define EXPAND_LIMIT 1000
38
39 /* --- data types --------------------------------------------------------- */
40
41 enum rofft {
42 ROFF_ab,
43 ROFF_ad,
44 ROFF_af,
45 ROFF_aln,
46 ROFF_als,
47 ROFF_am,
48 ROFF_am1,
49 ROFF_ami,
50 ROFF_ami1,
51 ROFF_as,
52 ROFF_as1,
53 ROFF_asciify,
54 ROFF_backtrace,
55 ROFF_bd,
56 ROFF_bleedat,
57 ROFF_blm,
58 ROFF_box,
59 ROFF_boxa,
60 ROFF_bp,
61 ROFF_BP,
62 /* MAN_br, MDOC_br */
63 ROFF_break,
64 ROFF_breakchar,
65 ROFF_brnl,
66 ROFF_brp,
67 ROFF_brpnl,
68 ROFF_c2,
69 ROFF_cc,
70 ROFF_ce,
71 ROFF_cf,
72 ROFF_cflags,
73 ROFF_ch,
74 ROFF_char,
75 ROFF_chop,
76 ROFF_class,
77 ROFF_close,
78 ROFF_CL,
79 ROFF_color,
80 ROFF_composite,
81 ROFF_continue,
82 ROFF_cp,
83 ROFF_cropat,
84 ROFF_cs,
85 ROFF_cu,
86 ROFF_da,
87 ROFF_dch,
88 ROFF_Dd,
89 ROFF_de,
90 ROFF_de1,
91 ROFF_defcolor,
92 ROFF_dei,
93 ROFF_dei1,
94 ROFF_device,
95 ROFF_devicem,
96 ROFF_di,
97 ROFF_do,
98 ROFF_ds,
99 ROFF_ds1,
100 ROFF_dwh,
101 ROFF_dt,
102 ROFF_ec,
103 ROFF_ecr,
104 ROFF_ecs,
105 ROFF_el,
106 ROFF_em,
107 ROFF_EN,
108 ROFF_eo,
109 ROFF_EP,
110 ROFF_EQ,
111 ROFF_errprint,
112 ROFF_ev,
113 ROFF_evc,
114 ROFF_ex,
115 ROFF_fallback,
116 ROFF_fam,
117 ROFF_fc,
118 ROFF_fchar,
119 ROFF_fcolor,
120 ROFF_fdeferlig,
121 ROFF_feature,
122 /* MAN_fi; ignored in mdoc(7) */
123 ROFF_fkern,
124 ROFF_fl,
125 ROFF_flig,
126 ROFF_fp,
127 ROFF_fps,
128 ROFF_fschar,
129 ROFF_fspacewidth,
130 ROFF_fspecial,
131 /* MAN_ft; ignored in mdoc(7) */
132 ROFF_ftr,
133 ROFF_fzoom,
134 ROFF_gcolor,
135 ROFF_hc,
136 ROFF_hcode,
137 ROFF_hidechar,
138 ROFF_hla,
139 ROFF_hlm,
140 ROFF_hpf,
141 ROFF_hpfa,
142 ROFF_hpfcode,
143 ROFF_hw,
144 ROFF_hy,
145 ROFF_hylang,
146 ROFF_hylen,
147 ROFF_hym,
148 ROFF_hypp,
149 ROFF_hys,
150 ROFF_ie,
151 ROFF_if,
152 ROFF_ig,
153 /* MAN_in; ignored in mdoc(7) */
154 ROFF_index,
155 ROFF_it,
156 ROFF_itc,
157 ROFF_IX,
158 ROFF_kern,
159 ROFF_kernafter,
160 ROFF_kernbefore,
161 ROFF_kernpair,
162 ROFF_lc,
163 ROFF_lc_ctype,
164 ROFF_lds,
165 ROFF_length,
166 ROFF_letadj,
167 ROFF_lf,
168 ROFF_lg,
169 ROFF_lhang,
170 ROFF_linetabs,
171 /* MAN_ll, MDOC_ll */
172 ROFF_lnr,
173 ROFF_lnrf,
174 ROFF_lpfx,
175 ROFF_ls,
176 ROFF_lsm,
177 ROFF_lt,
178 ROFF_mc,
179 ROFF_mediasize,
180 ROFF_minss,
181 ROFF_mk,
182 ROFF_mso,
183 ROFF_na,
184 ROFF_ne,
185 /* MAN_nf; ignored in mdoc(7) */
186 ROFF_nh,
187 ROFF_nhychar,
188 ROFF_nm,
189 ROFF_nn,
190 ROFF_nop,
191 ROFF_nr,
192 ROFF_nrf,
193 ROFF_nroff,
194 ROFF_ns,
195 ROFF_nx,
196 ROFF_open,
197 ROFF_opena,
198 ROFF_os,
199 ROFF_output,
200 ROFF_padj,
201 ROFF_papersize,
202 ROFF_pc,
203 ROFF_pev,
204 ROFF_pi,
205 ROFF_PI,
206 ROFF_pl,
207 ROFF_pm,
208 ROFF_pn,
209 ROFF_pnr,
210 ROFF_po,
211 ROFF_ps,
212 ROFF_psbb,
213 ROFF_pshape,
214 ROFF_pso,
215 ROFF_ptr,
216 ROFF_pvs,
217 ROFF_rchar,
218 ROFF_rd,
219 ROFF_recursionlimit,
220 ROFF_return,
221 ROFF_rfschar,
222 ROFF_rhang,
223 ROFF_rj,
224 ROFF_rm,
225 ROFF_rn,
226 ROFF_rnn,
227 ROFF_rr,
228 ROFF_rs,
229 ROFF_rt,
230 ROFF_schar,
231 ROFF_sentchar,
232 ROFF_shc,
233 ROFF_shift,
234 ROFF_sizes,
235 ROFF_so,
236 /* MAN_sp, MDOC_sp */
237 ROFF_spacewidth,
238 ROFF_special,
239 ROFF_spreadwarn,
240 ROFF_ss,
241 ROFF_sty,
242 ROFF_substring,
243 ROFF_sv,
244 ROFF_sy,
245 ROFF_T_,
246 ROFF_ta,
247 ROFF_tc,
248 ROFF_TE,
249 ROFF_TH,
250 ROFF_ti,
251 ROFF_tkf,
252 ROFF_tl,
253 ROFF_tm,
254 ROFF_tm1,
255 ROFF_tmc,
256 ROFF_tr,
257 ROFF_track,
258 ROFF_transchar,
259 ROFF_trf,
260 ROFF_trimat,
261 ROFF_trin,
262 ROFF_trnt,
263 ROFF_troff,
264 ROFF_TS,
265 ROFF_uf,
266 ROFF_ul,
267 ROFF_unformat,
268 ROFF_unwatch,
269 ROFF_unwatchn,
270 ROFF_vpt,
271 ROFF_vs,
272 ROFF_warn,
273 ROFF_warnscale,
274 ROFF_watch,
275 ROFF_watchlength,
276 ROFF_watchn,
277 ROFF_wh,
278 ROFF_while,
279 ROFF_write,
280 ROFF_writec,
281 ROFF_writem,
282 ROFF_xflag,
283 ROFF_cblock,
284 ROFF_USERDEF,
285 ROFF_MAX
286 };
287
288 /*
289 * An incredibly-simple string buffer.
290 */
291 struct roffstr {
292 char *p; /* nil-terminated buffer */
293 size_t sz; /* saved strlen(p) */
294 };
295
296 /*
297 * A key-value roffstr pair as part of a singly-linked list.
298 */
299 struct roffkv {
300 struct roffstr key;
301 struct roffstr val;
302 struct roffkv *next; /* next in list */
303 };
304
305 /*
306 * A single number register as part of a singly-linked list.
307 */
308 struct roffreg {
309 struct roffstr key;
310 int val;
311 struct roffreg *next;
312 };
313
314 struct roff {
315 struct mparse *parse; /* parse point */
316 struct roffnode *last; /* leaf of stack */
317 int *rstack; /* stack of inverted `ie' values */
318 struct roffreg *regtab; /* number registers */
319 struct roffkv *strtab; /* user-defined strings & macros */
320 struct roffkv *xmbtab; /* multi-byte trans table (`tr') */
321 struct roffstr *xtab; /* single-byte trans table (`tr') */
322 const char *current_string; /* value of last called user macro */
323 struct tbl_node *first_tbl; /* first table parsed */
324 struct tbl_node *last_tbl; /* last table parsed */
325 struct tbl_node *tbl; /* current table being parsed */
326 struct eqn_node *last_eqn; /* last equation parsed */
327 struct eqn_node *first_eqn; /* first equation parsed */
328 struct eqn_node *eqn; /* current equation being parsed */
329 int eqn_inline; /* current equation is inline */
330 int options; /* parse options */
331 int rstacksz; /* current size limit of rstack */
332 int rstackpos; /* position in rstack */
333 int format; /* current file in mdoc or man format */
334 int argc; /* number of args of the last macro */
335 char control; /* control character */
336 };
337
338 struct roffnode {
339 enum rofft tok; /* type of node */
340 struct roffnode *parent; /* up one in stack */
341 int line; /* parse line */
342 int col; /* parse col */
343 char *name; /* node name, e.g. macro name */
344 char *end; /* end-rules: custom token */
345 int endspan; /* end-rules: next-line or infty */
346 int rule; /* current evaluation rule */
347 };
348
349 #define ROFF_ARGS struct roff *r, /* parse ctx */ \
350 enum rofft tok, /* tok of macro */ \
351 struct buf *buf, /* input buffer */ \
352 int ln, /* parse line */ \
353 int ppos, /* original pos in buffer */ \
354 int pos, /* current pos in buffer */ \
355 int *offs /* reset offset of buffer data */
356
357 typedef enum rofferr (*roffproc)(ROFF_ARGS);
358
359 struct roffmac {
360 const char *name; /* macro name */
361 roffproc proc; /* process new macro */
362 roffproc text; /* process as child text of macro */
363 roffproc sub; /* process as child of macro */
364 int flags;
365 #define ROFFMAC_STRUCT (1 << 0) /* always interpret */
366 struct roffmac *next;
367 };
368
369 struct predef {
370 const char *name; /* predefined input name */
371 const char *str; /* replacement symbol */
372 };
373
374 #define PREDEF(__name, __str) \
375 { (__name), (__str) },
376
377 /* --- function prototypes ------------------------------------------------ */
378
379 static enum rofft roffhash_find(const char *, size_t);
380 static void roffhash_init(void);
381 static void roffnode_cleanscope(struct roff *);
382 static void roffnode_pop(struct roff *);
383 static void roffnode_push(struct roff *, enum rofft,
384 const char *, int, int);
385 static enum rofferr roff_block(ROFF_ARGS);
386 static enum rofferr roff_block_text(ROFF_ARGS);
387 static enum rofferr roff_block_sub(ROFF_ARGS);
388 static enum rofferr roff_brp(ROFF_ARGS);
389 static enum rofferr roff_cblock(ROFF_ARGS);
390 static enum rofferr roff_cc(ROFF_ARGS);
391 static void roff_ccond(struct roff *, int, int);
392 static enum rofferr roff_cond(ROFF_ARGS);
393 static enum rofferr roff_cond_text(ROFF_ARGS);
394 static enum rofferr roff_cond_sub(ROFF_ARGS);
395 static enum rofferr roff_ds(ROFF_ARGS);
396 static enum rofferr roff_eqndelim(struct roff *, struct buf *, int);
397 static int roff_evalcond(struct roff *r, int, char *, int *);
398 static int roff_evalnum(struct roff *, int,
399 const char *, int *, int *, int);
400 static int roff_evalpar(struct roff *, int,
401 const char *, int *, int *, int);
402 static int roff_evalstrcond(const char *, int *);
403 static void roff_free1(struct roff *);
404 static void roff_freereg(struct roffreg *);
405 static void roff_freestr(struct roffkv *);
406 static size_t roff_getname(struct roff *, char **, int, int);
407 static int roff_getnum(const char *, int *, int *, int);
408 static int roff_getop(const char *, int *, char *);
409 static int roff_getregn(const struct roff *,
410 const char *, size_t);
411 static int roff_getregro(const struct roff *,
412 const char *name);
413 static const char *roff_getstrn(const struct roff *,
414 const char *, size_t);
415 static int roff_hasregn(const struct roff *,
416 const char *, size_t);
417 static enum rofferr roff_insec(ROFF_ARGS);
418 static enum rofferr roff_it(ROFF_ARGS);
419 static enum rofferr roff_line_ignore(ROFF_ARGS);
420 static void roff_man_alloc1(struct roff_man *);
421 static void roff_man_free1(struct roff_man *);
422 static enum rofferr roff_nr(ROFF_ARGS);
423 static enum rofft roff_parse(struct roff *, char *, int *,
424 int, int);
425 static enum rofferr roff_parsetext(struct buf *, int, int *);
426 static enum rofferr roff_res(struct roff *, struct buf *, int, int);
427 static enum rofferr roff_rm(ROFF_ARGS);
428 static enum rofferr roff_rr(ROFF_ARGS);
429 static void roff_setstr(struct roff *,
430 const char *, const char *, int);
431 static void roff_setstrn(struct roffkv **, const char *,
432 size_t, const char *, size_t, int);
433 static enum rofferr roff_so(ROFF_ARGS);
434 static enum rofferr roff_tr(ROFF_ARGS);
435 static enum rofferr roff_Dd(ROFF_ARGS);
436 static enum rofferr roff_TH(ROFF_ARGS);
437 static enum rofferr roff_TE(ROFF_ARGS);
438 static enum rofferr roff_TS(ROFF_ARGS);
439 static enum rofferr roff_EQ(ROFF_ARGS);
440 static enum rofferr roff_EN(ROFF_ARGS);
441 static enum rofferr roff_T_(ROFF_ARGS);
442 static enum rofferr roff_unsupp(ROFF_ARGS);
443 static enum rofferr roff_userdef(ROFF_ARGS);
444
445 /* --- constant data ------------------------------------------------------ */
446
447 /* See roffhash_find() */
448
449 #define ASCII_HI 126
450 #define ASCII_LO 33
451 #define HASHWIDTH (ASCII_HI - ASCII_LO + 1)
452
453 #define ROFFNUM_SCALE (1 << 0) /* Honour scaling in roff_getnum(). */
454 #define ROFFNUM_WHITE (1 << 1) /* Skip whitespace in roff_evalnum(). */
455
456 static struct roffmac *hash[HASHWIDTH];
457
458 static struct roffmac roffs[ROFF_MAX] = {
459 { "ab", roff_unsupp, NULL, NULL, 0, NULL },
460 { "ad", roff_line_ignore, NULL, NULL, 0, NULL },
461 { "af", roff_line_ignore, NULL, NULL, 0, NULL },
462 { "aln", roff_unsupp, NULL, NULL, 0, NULL },
463 { "als", roff_unsupp, NULL, NULL, 0, NULL },
464 { "am", roff_block, roff_block_text, roff_block_sub, 0, NULL },
465 { "am1", roff_block, roff_block_text, roff_block_sub, 0, NULL },
466 { "ami", roff_block, roff_block_text, roff_block_sub, 0, NULL },
467 { "ami1", roff_block, roff_block_text, roff_block_sub, 0, NULL },
468 { "as", roff_ds, NULL, NULL, 0, NULL },
469 { "as1", roff_ds, NULL, NULL, 0, NULL },
470 { "asciify", roff_unsupp, NULL, NULL, 0, NULL },
471 { "backtrace", roff_line_ignore, NULL, NULL, 0, NULL },
472 { "bd", roff_line_ignore, NULL, NULL, 0, NULL },
473 { "bleedat", roff_line_ignore, NULL, NULL, 0, NULL },
474 { "blm", roff_unsupp, NULL, NULL, 0, NULL },
475 { "box", roff_unsupp, NULL, NULL, 0, NULL },
476 { "boxa", roff_unsupp, NULL, NULL, 0, NULL },
477 { "bp", roff_line_ignore, NULL, NULL, 0, NULL },
478 { "BP", roff_unsupp, NULL, NULL, 0, NULL },
479 { "break", roff_unsupp, NULL, NULL, 0, NULL },
480 { "breakchar", roff_line_ignore, NULL, NULL, 0, NULL },
481 { "brnl", roff_line_ignore, NULL, NULL, 0, NULL },
482 { "brp", roff_brp, NULL, NULL, 0, NULL },
483 { "brpnl", roff_line_ignore, NULL, NULL, 0, NULL },
484 { "c2", roff_unsupp, NULL, NULL, 0, NULL },
485 { "cc", roff_cc, NULL, NULL, 0, NULL },
486 { "ce", roff_line_ignore, NULL, NULL, 0, NULL },
487 { "cf", roff_insec, NULL, NULL, 0, NULL },
488 { "cflags", roff_line_ignore, NULL, NULL, 0, NULL },
489 { "ch", roff_line_ignore, NULL, NULL, 0, NULL },
490 { "char", roff_unsupp, NULL, NULL, 0, NULL },
491 { "chop", roff_unsupp, NULL, NULL, 0, NULL },
492 { "class", roff_line_ignore, NULL, NULL, 0, NULL },
493 { "close", roff_insec, NULL, NULL, 0, NULL },
494 { "CL", roff_unsupp, NULL, NULL, 0, NULL },
495 { "color", roff_line_ignore, NULL, NULL, 0, NULL },
496 { "composite", roff_unsupp, NULL, NULL, 0, NULL },
497 { "continue", roff_unsupp, NULL, NULL, 0, NULL },
498 { "cp", roff_line_ignore, NULL, NULL, 0, NULL },
499 { "cropat", roff_line_ignore, NULL, NULL, 0, NULL },
500 { "cs", roff_line_ignore, NULL, NULL, 0, NULL },
501 { "cu", roff_line_ignore, NULL, NULL, 0, NULL },
502 { "da", roff_unsupp, NULL, NULL, 0, NULL },
503 { "dch", roff_unsupp, NULL, NULL, 0, NULL },
504 { "Dd", roff_Dd, NULL, NULL, 0, NULL },
505 { "de", roff_block, roff_block_text, roff_block_sub, 0, NULL },
506 { "de1", roff_block, roff_block_text, roff_block_sub, 0, NULL },
507 { "defcolor", roff_line_ignore, NULL, NULL, 0, NULL },
508 { "dei", roff_block, roff_block_text, roff_block_sub, 0, NULL },
509 { "dei1", roff_block, roff_block_text, roff_block_sub, 0, NULL },
510 { "device", roff_unsupp, NULL, NULL, 0, NULL },
511 { "devicem", roff_unsupp, NULL, NULL, 0, NULL },
512 { "di", roff_unsupp, NULL, NULL, 0, NULL },
513 { "do", roff_unsupp, NULL, NULL, 0, NULL },
514 { "ds", roff_ds, NULL, NULL, 0, NULL },
515 { "ds1", roff_ds, NULL, NULL, 0, NULL },
516 { "dwh", roff_unsupp, NULL, NULL, 0, NULL },
517 { "dt", roff_unsupp, NULL, NULL, 0, NULL },
518 { "ec", roff_unsupp, NULL, NULL, 0, NULL },
519 { "ecr", roff_unsupp, NULL, NULL, 0, NULL },
520 { "ecs", roff_unsupp, NULL, NULL, 0, NULL },
521 { "el", roff_cond, roff_cond_text, roff_cond_sub, ROFFMAC_STRUCT, NULL },
522 { "em", roff_unsupp, NULL, NULL, 0, NULL },
523 { "EN", roff_EN, NULL, NULL, 0, NULL },
524 { "eo", roff_unsupp, NULL, NULL, 0, NULL },
525 { "EP", roff_unsupp, NULL, NULL, 0, NULL },
526 { "EQ", roff_EQ, NULL, NULL, 0, NULL },
527 { "errprint", roff_line_ignore, NULL, NULL, 0, NULL },
528 { "ev", roff_unsupp, NULL, NULL, 0, NULL },
529 { "evc", roff_unsupp, NULL, NULL, 0, NULL },
530 { "ex", roff_unsupp, NULL, NULL, 0, NULL },
531 { "fallback", roff_line_ignore, NULL, NULL, 0, NULL },
532 { "fam", roff_line_ignore, NULL, NULL, 0, NULL },
533 { "fc", roff_unsupp, NULL, NULL, 0, NULL },
534 { "fchar", roff_unsupp, NULL, NULL, 0, NULL },
535 { "fcolor", roff_line_ignore, NULL, NULL, 0, NULL },
536 { "fdeferlig", roff_line_ignore, NULL, NULL, 0, NULL },
537 { "feature", roff_line_ignore, NULL, NULL, 0, NULL },
538 { "fkern", roff_line_ignore, NULL, NULL, 0, NULL },
539 { "fl", roff_line_ignore, NULL, NULL, 0, NULL },
540 { "flig", roff_line_ignore, NULL, NULL, 0, NULL },
541 { "fp", roff_line_ignore, NULL, NULL, 0, NULL },
542 { "fps", roff_line_ignore, NULL, NULL, 0, NULL },
543 { "fschar", roff_unsupp, NULL, NULL, 0, NULL },
544 { "fspacewidth", roff_line_ignore, NULL, NULL, 0, NULL },
545 { "fspecial", roff_line_ignore, NULL, NULL, 0, NULL },
546 { "ftr", roff_line_ignore, NULL, NULL, 0, NULL },
547 { "fzoom", roff_line_ignore, NULL, NULL, 0, NULL },
548 { "gcolor", roff_line_ignore, NULL, NULL, 0, NULL },
549 { "hc", roff_line_ignore, NULL, NULL, 0, NULL },
550 { "hcode", roff_line_ignore, NULL, NULL, 0, NULL },
551 { "hidechar", roff_line_ignore, NULL, NULL, 0, NULL },
552 { "hla", roff_line_ignore, NULL, NULL, 0, NULL },
553 { "hlm", roff_line_ignore, NULL, NULL, 0, NULL },
554 { "hpf", roff_line_ignore, NULL, NULL, 0, NULL },
555 { "hpfa", roff_line_ignore, NULL, NULL, 0, NULL },
556 { "hpfcode", roff_line_ignore, NULL, NULL, 0, NULL },
557 { "hw", roff_line_ignore, NULL, NULL, 0, NULL },
558 { "hy", roff_line_ignore, NULL, NULL, 0, NULL },
559 { "hylang", roff_line_ignore, NULL, NULL, 0, NULL },
560 { "hylen", roff_line_ignore, NULL, NULL, 0, NULL },
561 { "hym", roff_line_ignore, NULL, NULL, 0, NULL },
562 { "hypp", roff_line_ignore, NULL, NULL, 0, NULL },
563 { "hys", roff_line_ignore, NULL, NULL, 0, NULL },
564 { "ie", roff_cond, roff_cond_text, roff_cond_sub, ROFFMAC_STRUCT, NULL },
565 { "if", roff_cond, roff_cond_text, roff_cond_sub, ROFFMAC_STRUCT, NULL },
566 { "ig", roff_block, roff_block_text, roff_block_sub, 0, NULL },
567 { "index", roff_unsupp, NULL, NULL, 0, NULL },
568 { "it", roff_it, NULL, NULL, 0, NULL },
569 { "itc", roff_unsupp, NULL, NULL, 0, NULL },
570 { "IX", roff_line_ignore, NULL, NULL, 0, NULL },
571 { "kern", roff_line_ignore, NULL, NULL, 0, NULL },
572 { "kernafter", roff_line_ignore, NULL, NULL, 0, NULL },
573 { "kernbefore", roff_line_ignore, NULL, NULL, 0, NULL },
574 { "kernpair", roff_line_ignore, NULL, NULL, 0, NULL },
575 { "lc", roff_unsupp, NULL, NULL, 0, NULL },
576 { "lc_ctype", roff_unsupp, NULL, NULL, 0, NULL },
577 { "lds", roff_unsupp, NULL, NULL, 0, NULL },
578 { "length", roff_unsupp, NULL, NULL, 0, NULL },
579 { "letadj", roff_line_ignore, NULL, NULL, 0, NULL },
580 { "lf", roff_insec, NULL, NULL, 0, NULL },
581 { "lg", roff_line_ignore, NULL, NULL, 0, NULL },
582 { "lhang", roff_line_ignore, NULL, NULL, 0, NULL },
583 { "linetabs", roff_unsupp, NULL, NULL, 0, NULL },
584 { "lnr", roff_unsupp, NULL, NULL, 0, NULL },
585 { "lnrf", roff_unsupp, NULL, NULL, 0, NULL },
586 { "lpfx", roff_unsupp, NULL, NULL, 0, NULL },
587 { "ls", roff_line_ignore, NULL, NULL, 0, NULL },
588 { "lsm", roff_unsupp, NULL, NULL, 0, NULL },
589 { "lt", roff_line_ignore, NULL, NULL, 0, NULL },
590 { "mc", roff_line_ignore, NULL, NULL, 0, NULL },
591 { "mediasize", roff_line_ignore, NULL, NULL, 0, NULL },
592 { "minss", roff_line_ignore, NULL, NULL, 0, NULL },
593 { "mk", roff_line_ignore, NULL, NULL, 0, NULL },
594 { "mso", roff_insec, NULL, NULL, 0, NULL },
595 { "na", roff_line_ignore, NULL, NULL, 0, NULL },
596 { "ne", roff_line_ignore, NULL, NULL, 0, NULL },
597 { "nh", roff_line_ignore, NULL, NULL, 0, NULL },
598 { "nhychar", roff_line_ignore, NULL, NULL, 0, NULL },
599 { "nm", roff_unsupp, NULL, NULL, 0, NULL },
600 { "nn", roff_unsupp, NULL, NULL, 0, NULL },
601 { "nop", roff_unsupp, NULL, NULL, 0, NULL },
602 { "nr", roff_nr, NULL, NULL, 0, NULL },
603 { "nrf", roff_unsupp, NULL, NULL, 0, NULL },
604 { "nroff", roff_line_ignore, NULL, NULL, 0, NULL },
605 { "ns", roff_line_ignore, NULL, NULL, 0, NULL },
606 { "nx", roff_insec, NULL, NULL, 0, NULL },
607 { "open", roff_insec, NULL, NULL, 0, NULL },
608 { "opena", roff_insec, NULL, NULL, 0, NULL },
609 { "os", roff_line_ignore, NULL, NULL, 0, NULL },
610 { "output", roff_unsupp, NULL, NULL, 0, NULL },
611 { "padj", roff_line_ignore, NULL, NULL, 0, NULL },
612 { "papersize", roff_line_ignore, NULL, NULL, 0, NULL },
613 { "pc", roff_line_ignore, NULL, NULL, 0, NULL },
614 { "pev", roff_line_ignore, NULL, NULL, 0, NULL },
615 { "pi", roff_insec, NULL, NULL, 0, NULL },
616 { "PI", roff_unsupp, NULL, NULL, 0, NULL },
617 { "pl", roff_line_ignore, NULL, NULL, 0, NULL },
618 { "pm", roff_line_ignore, NULL, NULL, 0, NULL },
619 { "pn", roff_line_ignore, NULL, NULL, 0, NULL },
620 { "pnr", roff_line_ignore, NULL, NULL, 0, NULL },
621 { "po", roff_line_ignore, NULL, NULL, 0, NULL },
622 { "ps", roff_line_ignore, NULL, NULL, 0, NULL },
623 { "psbb", roff_unsupp, NULL, NULL, 0, NULL },
624 { "pshape", roff_unsupp, NULL, NULL, 0, NULL },
625 { "pso", roff_insec, NULL, NULL, 0, NULL },
626 { "ptr", roff_line_ignore, NULL, NULL, 0, NULL },
627 { "pvs", roff_line_ignore, NULL, NULL, 0, NULL },
628 { "rchar", roff_unsupp, NULL, NULL, 0, NULL },
629 { "rd", roff_line_ignore, NULL, NULL, 0, NULL },
630 { "recursionlimit", roff_line_ignore, NULL, NULL, 0, NULL },
631 { "return", roff_unsupp, NULL, NULL, 0, NULL },
632 { "rfschar", roff_unsupp, NULL, NULL, 0, NULL },
633 { "rhang", roff_line_ignore, NULL, NULL, 0, NULL },
634 { "rj", roff_line_ignore, NULL, NULL, 0, NULL },
635 { "rm", roff_rm, NULL, NULL, 0, NULL },
636 { "rn", roff_unsupp, NULL, NULL, 0, NULL },
637 { "rnn", roff_unsupp, NULL, NULL, 0, NULL },
638 { "rr", roff_rr, NULL, NULL, 0, NULL },
639 { "rs", roff_line_ignore, NULL, NULL, 0, NULL },
640 { "rt", roff_line_ignore, NULL, NULL, 0, NULL },
641 { "schar", roff_unsupp, NULL, NULL, 0, NULL },
642 { "sentchar", roff_line_ignore, NULL, NULL, 0, NULL },
643 { "shc", roff_line_ignore, NULL, NULL, 0, NULL },
644 { "shift", roff_unsupp, NULL, NULL, 0, NULL },
645 { "sizes", roff_line_ignore, NULL, NULL, 0, NULL },
646 { "so", roff_so, NULL, NULL, 0, NULL },
647 { "spacewidth", roff_line_ignore, NULL, NULL, 0, NULL },
648 { "special", roff_line_ignore, NULL, NULL, 0, NULL },
649 { "spreadwarn", roff_line_ignore, NULL, NULL, 0, NULL },
650 { "ss", roff_line_ignore, NULL, NULL, 0, NULL },
651 { "sty", roff_line_ignore, NULL, NULL, 0, NULL },
652 { "substring", roff_unsupp, NULL, NULL, 0, NULL },
653 { "sv", roff_line_ignore, NULL, NULL, 0, NULL },
654 { "sy", roff_insec, NULL, NULL, 0, NULL },
655 { "T&", roff_T_, NULL, NULL, 0, NULL },
656 { "ta", roff_unsupp, NULL, NULL, 0, NULL },
657 { "tc", roff_unsupp, NULL, NULL, 0, NULL },
658 { "TE", roff_TE, NULL, NULL, 0, NULL },
659 { "TH", roff_TH, NULL, NULL, 0, NULL },
660 { "ti", roff_unsupp, NULL, NULL, 0, NULL },
661 { "tkf", roff_line_ignore, NULL, NULL, 0, NULL },
662 { "tl", roff_unsupp, NULL, NULL, 0, NULL },
663 { "tm", roff_line_ignore, NULL, NULL, 0, NULL },
664 { "tm1", roff_line_ignore, NULL, NULL, 0, NULL },
665 { "tmc", roff_line_ignore, NULL, NULL, 0, NULL },
666 { "tr", roff_tr, NULL, NULL, 0, NULL },
667 { "track", roff_line_ignore, NULL, NULL, 0, NULL },
668 { "transchar", roff_line_ignore, NULL, NULL, 0, NULL },
669 { "trf", roff_insec, NULL, NULL, 0, NULL },
670 { "trimat", roff_line_ignore, NULL, NULL, 0, NULL },
671 { "trin", roff_unsupp, NULL, NULL, 0, NULL },
672 { "trnt", roff_unsupp, NULL, NULL, 0, NULL },
673 { "troff", roff_line_ignore, NULL, NULL, 0, NULL },
674 { "TS", roff_TS, NULL, NULL, 0, NULL },
675 { "uf", roff_line_ignore, NULL, NULL, 0, NULL },
676 { "ul", roff_line_ignore, NULL, NULL, 0, NULL },
677 { "unformat", roff_unsupp, NULL, NULL, 0, NULL },
678 { "unwatch", roff_line_ignore, NULL, NULL, 0, NULL },
679 { "unwatchn", roff_line_ignore, NULL, NULL, 0, NULL },
680 { "vpt", roff_line_ignore, NULL, NULL, 0, NULL },
681 { "vs", roff_line_ignore, NULL, NULL, 0, NULL },
682 { "warn", roff_line_ignore, NULL, NULL, 0, NULL },
683 { "warnscale", roff_line_ignore, NULL, NULL, 0, NULL },
684 { "watch", roff_line_ignore, NULL, NULL, 0, NULL },
685 { "watchlength", roff_line_ignore, NULL, NULL, 0, NULL },
686 { "watchn", roff_line_ignore, NULL, NULL, 0, NULL },
687 { "wh", roff_unsupp, NULL, NULL, 0, NULL },
688 { "while", roff_unsupp, NULL, NULL, 0, NULL },
689 { "write", roff_insec, NULL, NULL, 0, NULL },
690 { "writec", roff_insec, NULL, NULL, 0, NULL },
691 { "writem", roff_insec, NULL, NULL, 0, NULL },
692 { "xflag", roff_line_ignore, NULL, NULL, 0, NULL },
693 { ".", roff_cblock, NULL, NULL, 0, NULL },
694 { NULL, roff_userdef, NULL, NULL, 0, NULL },
695 };
696
697 /* not currently implemented: Ds em Eq LP Me PP pp Or Rd Sf SH */
698 const char *const __mdoc_reserved[] = {
699 "Ac", "Ad", "An", "Ao", "Ap", "Aq", "Ar", "At",
700 "Bc", "Bd", "Bf", "Bk", "Bl", "Bo", "Bq",
701 "Brc", "Bro", "Brq", "Bsx", "Bt", "Bx",
702 "Cd", "Cm", "Db", "Dc", "Dd", "Dl", "Do", "Dq",
703 "Dt", "Dv", "Dx", "D1",
704 "Ec", "Ed", "Ef", "Ek", "El", "Em",
705 "En", "Eo", "Er", "Es", "Ev", "Ex",
706 "Fa", "Fc", "Fd", "Fl", "Fn", "Fo", "Fr", "Ft", "Fx",
707 "Hf", "Ic", "In", "It", "Lb", "Li", "Lk", "Lp",
708 "Ms", "Mt", "Nd", "Nm", "No", "Ns", "Nx",
709 "Oc", "Oo", "Op", "Os", "Ot", "Ox",
710 "Pa", "Pc", "Pf", "Po", "Pp", "Pq",
711 "Qc", "Ql", "Qo", "Qq", "Re", "Rs", "Rv",
712 "Sc", "Sh", "Sm", "So", "Sq",
713 "Ss", "St", "Sx", "Sy",
714 "Ta", "Tn", "Ud", "Ux", "Va", "Vt", "Xc", "Xo", "Xr",
715 "%A", "%B", "%C", "%D", "%I", "%J", "%N", "%O",
716 "%P", "%Q", "%R", "%T", "%U", "%V",
717 NULL
718 };
719
720 /* not currently implemented: BT DE DS ME MT PT SY TQ YS */
721 const char *const __man_reserved[] = {
722 "AT", "B", "BI", "BR", "DT",
723 "EE", "EN", "EQ", "EX", "HP", "I", "IB", "IP", "IR",
724 "LP", "OP", "P", "PD", "PP",
725 "R", "RB", "RE", "RI", "RS", "SB", "SH", "SM", "SS",
726 "TE", "TH", "TP", "TS", "T&", "UC", "UE", "UR",
727 NULL
728 };
729
730 /* Array of injected predefined strings. */
731 #define PREDEFS_MAX 38
732 static const struct predef predefs[PREDEFS_MAX] = {
733 #include "predefs.in"
734 };
735
736 /* See roffhash_find() */
737 #define ROFF_HASH(p) (p[0] - ASCII_LO)
738
739 static int roffit_lines; /* number of lines to delay */
740 static char *roffit_macro; /* nil-terminated macro line */
741
742
743 /* --- request table ------------------------------------------------------ */
744
745 static void
746 roffhash_init(void)
747 {
748 struct roffmac *n;
749 int buc, i;
750
751 for (i = 0; i < (int)ROFF_USERDEF; i++) {
752 assert(roffs[i].name[0] >= ASCII_LO);
753 assert(roffs[i].name[0] <= ASCII_HI);
754
755 buc = ROFF_HASH(roffs[i].name);
756
757 if (NULL != (n = hash[buc])) {
758 for ( ; n->next; n = n->next)
759 /* Do nothing. */ ;
760 n->next = &roffs[i];
761 } else
762 hash[buc] = &roffs[i];
763 }
764 }
765
766 /*
767 * Look up a roff token by its name. Returns ROFF_MAX if no macro by
768 * the nil-terminated string name could be found.
769 */
770 static enum rofft
771 roffhash_find(const char *p, size_t s)
772 {
773 int buc;
774 struct roffmac *n;
775
776 /*
777 * libroff has an extremely simple hashtable, for the time
778 * being, which simply keys on the first character, which must
779 * be printable, then walks a chain. It works well enough until
780 * optimised.
781 */
782
783 if (p[0] < ASCII_LO || p[0] > ASCII_HI)
784 return ROFF_MAX;
785
786 buc = ROFF_HASH(p);
787
788 if (NULL == (n = hash[buc]))
789 return ROFF_MAX;
790 for ( ; n; n = n->next)
791 if (0 == strncmp(n->name, p, s) && '\0' == n->name[(int)s])
792 return (enum rofft)(n - roffs);
793
794 return ROFF_MAX;
795 }
796
797 /* --- stack of request blocks -------------------------------------------- */
798
799 /*
800 * Pop the current node off of the stack of roff instructions currently
801 * pending.
802 */
803 static void
804 roffnode_pop(struct roff *r)
805 {
806 struct roffnode *p;
807
808 assert(r->last);
809 p = r->last;
810
811 r->last = r->last->parent;
812 free(p->name);
813 free(p->end);
814 free(p);
815 }
816
817 /*
818 * Push a roff node onto the instruction stack. This must later be
819 * removed with roffnode_pop().
820 */
821 static void
822 roffnode_push(struct roff *r, enum rofft tok, const char *name,
823 int line, int col)
824 {
825 struct roffnode *p;
826
827 p = mandoc_calloc(1, sizeof(struct roffnode));
828 p->tok = tok;
829 if (name)
830 p->name = mandoc_strdup(name);
831 p->parent = r->last;
832 p->line = line;
833 p->col = col;
834 p->rule = p->parent ? p->parent->rule : 0;
835
836 r->last = p;
837 }
838
839 /* --- roff parser state data management ---------------------------------- */
840
841 static void
842 roff_free1(struct roff *r)
843 {
844 struct tbl_node *tbl;
845 struct eqn_node *e;
846 int i;
847
848 while (NULL != (tbl = r->first_tbl)) {
849 r->first_tbl = tbl->next;
850 tbl_free(tbl);
851 }
852 r->first_tbl = r->last_tbl = r->tbl = NULL;
853
854 while (NULL != (e = r->first_eqn)) {
855 r->first_eqn = e->next;
856 eqn_free(e);
857 }
858 r->first_eqn = r->last_eqn = r->eqn = NULL;
859
860 while (r->last)
861 roffnode_pop(r);
862
863 free (r->rstack);
864 r->rstack = NULL;
865 r->rstacksz = 0;
866 r->rstackpos = -1;
867
868 roff_freereg(r->regtab);
869 r->regtab = NULL;
870
871 roff_freestr(r->strtab);
872 roff_freestr(r->xmbtab);
873 r->strtab = r->xmbtab = NULL;
874
875 if (r->xtab)
876 for (i = 0; i < 128; i++)
877 free(r->xtab[i].p);
878 free(r->xtab);
879 r->xtab = NULL;
880 }
881
882 void
883 roff_reset(struct roff *r)
884 {
885
886 roff_free1(r);
887 r->format = r->options & (MPARSE_MDOC | MPARSE_MAN);
888 r->control = 0;
889 }
890
891 void
892 roff_free(struct roff *r)
893 {
894
895 roff_free1(r);
896 free(r);
897 }
898
899 struct roff *
900 roff_alloc(struct mparse *parse, int options)
901 {
902 struct roff *r;
903
904 r = mandoc_calloc(1, sizeof(struct roff));
905 r->parse = parse;
906 r->options = options;
907 r->format = options & (MPARSE_MDOC | MPARSE_MAN);
908 r->rstackpos = -1;
909
910 roffhash_init();
911
912 return r;
913 }
914
915 /* --- syntax tree state data management ---------------------------------- */
916
917 static void
918 roff_man_free1(struct roff_man *man)
919 {
920
921 if (man->first != NULL)
922 roff_node_delete(man, man->first);
923 free(man->meta.msec);
924 free(man->meta.vol);
925 free(man->meta.os);
926 free(man->meta.arch);
927 free(man->meta.title);
928 free(man->meta.name);
929 free(man->meta.date);
930 }
931
932 static void
933 roff_man_alloc1(struct roff_man *man)
934 {
935
936 memset(&man->meta, 0, sizeof(man->meta));
937 man->first = mandoc_calloc(1, sizeof(*man->first));
938 man->first->type = ROFFT_ROOT;
939 man->last = man->first;
940 man->last_es = NULL;
941 man->flags = 0;
942 man->macroset = MACROSET_NONE;
943 man->lastsec = man->lastnamed = SEC_NONE;
944 man->next = ROFF_NEXT_CHILD;
945 }
946
947 void
948 roff_man_reset(struct roff_man *man)
949 {
950
951 roff_man_free1(man);
952 roff_man_alloc1(man);
953 }
954
955 void
956 roff_man_free(struct roff_man *man)
957 {
958
959 roff_man_free1(man);
960 free(man);
961 }
962
963 struct roff_man *
964 roff_man_alloc(struct roff *roff, struct mparse *parse,
965 const char *defos, int quick)
966 {
967 struct roff_man *man;
968
969 man = mandoc_calloc(1, sizeof(*man));
970 man->parse = parse;
971 man->roff = roff;
972 man->defos = defos;
973 man->quick = quick;
974 roff_man_alloc1(man);
975 return man;
976 }
977
978 /* --- syntax tree handling ----------------------------------------------- */
979
980 struct roff_node *
981 roff_node_alloc(struct roff_man *man, int line, int pos,
982 enum roff_type type, int tok)
983 {
984 struct roff_node *n;
985
986 n = mandoc_calloc(1, sizeof(*n));
987 n->line = line;
988 n->pos = pos;
989 n->tok = tok;
990 n->type = type;
991 n->sec = man->lastsec;
992
993 if (man->flags & MDOC_SYNOPSIS)
994 n->flags |= MDOC_SYNPRETTY;
995 else
996 n->flags &= ~MDOC_SYNPRETTY;
997 if (man->flags & MDOC_NEWLINE)
998 n->flags |= MDOC_LINE;
999 man->flags &= ~MDOC_NEWLINE;
1000
1001 return n;
1002 }
1003
1004 void
1005 roff_node_append(struct roff_man *man, struct roff_node *n)
1006 {
1007
1008 switch (man->next) {
1009 case ROFF_NEXT_SIBLING:
1010 if (man->last->next != NULL) {
1011 n->next = man->last->next;
1012 man->last->next->prev = n;
1013 } else
1014 man->last->parent->last = n;
1015 man->last->next = n;
1016 n->prev = man->last;
1017 n->parent = man->last->parent;
1018 break;
1019 case ROFF_NEXT_CHILD:
1020 man->last->child = n;
1021 n->parent = man->last;
1022 n->parent->last = n;
1023 break;
1024 default:
1025 abort();
1026 }
1027 man->last = n;
1028
1029 switch (n->type) {
1030 case ROFFT_HEAD:
1031 n->parent->head = n;
1032 break;
1033 case ROFFT_BODY:
1034 if (n->end != ENDBODY_NOT)
1035 return;
1036 n->parent->body = n;
1037 break;
1038 case ROFFT_TAIL:
1039 n->parent->tail = n;
1040 break;
1041 default:
1042 return;
1043 }
1044
1045 /*
1046 * Copy over the normalised-data pointer of our parent. Not
1047 * everybody has one, but copying a null pointer is fine.
1048 */
1049
1050 n->norm = n->parent->norm;
1051 assert(n->parent->type == ROFFT_BLOCK);
1052 }
1053
1054 void
1055 roff_word_alloc(struct roff_man *man, int line, int pos, const char *word)
1056 {
1057 struct roff_node *n;
1058
1059 n = roff_node_alloc(man, line, pos, ROFFT_TEXT, TOKEN_NONE);
1060 n->string = roff_strdup(man->roff, word);
1061 roff_node_append(man, n);
1062 if (man->macroset == MACROSET_MDOC)
1063 n->flags |= MDOC_VALID | MDOC_ENDED;
1064 else
1065 n->flags |= MAN_VALID;
1066 man->next = ROFF_NEXT_SIBLING;
1067 }
1068
1069 void
1070 roff_word_append(struct roff_man *man, const char *word)
1071 {
1072 struct roff_node *n;
1073 char *addstr, *newstr;
1074
1075 n = man->last;
1076 addstr = roff_strdup(man->roff, word);
1077 mandoc_asprintf(&newstr, "%s %s", n->string, addstr);
1078 free(addstr);
1079 free(n->string);
1080 n->string = newstr;
1081 man->next = ROFF_NEXT_SIBLING;
1082 }
1083
1084 void
1085 roff_elem_alloc(struct roff_man *man, int line, int pos, int tok)
1086 {
1087 struct roff_node *n;
1088
1089 n = roff_node_alloc(man, line, pos, ROFFT_ELEM, tok);
1090 roff_node_append(man, n);
1091 man->next = ROFF_NEXT_CHILD;
1092 }
1093
1094 struct roff_node *
1095 roff_block_alloc(struct roff_man *man, int line, int pos, int tok)
1096 {
1097 struct roff_node *n;
1098
1099 n = roff_node_alloc(man, line, pos, ROFFT_BLOCK, tok);
1100 roff_node_append(man, n);
1101 man->next = ROFF_NEXT_CHILD;
1102 return n;
1103 }
1104
1105 struct roff_node *
1106 roff_head_alloc(struct roff_man *man, int line, int pos, int tok)
1107 {
1108 struct roff_node *n;
1109
1110 n = roff_node_alloc(man, line, pos, ROFFT_HEAD, tok);
1111 roff_node_append(man, n);
1112 man->next = ROFF_NEXT_CHILD;
1113 return n;
1114 }
1115
1116 struct roff_node *
1117 roff_body_alloc(struct roff_man *man, int line, int pos, int tok)
1118 {
1119 struct roff_node *n;
1120
1121 n = roff_node_alloc(man, line, pos, ROFFT_BODY, tok);
1122 roff_node_append(man, n);
1123 man->next = ROFF_NEXT_CHILD;
1124 return n;
1125 }
1126
1127 void
1128 roff_addeqn(struct roff_man *man, const struct eqn *eqn)
1129 {
1130 struct roff_node *n;
1131
1132 n = roff_node_alloc(man, eqn->ln, eqn->pos, ROFFT_EQN, TOKEN_NONE);
1133 n->eqn = eqn;
1134 if (eqn->ln > man->last->line)
1135 n->flags |= MDOC_LINE;
1136 roff_node_append(man, n);
1137 man->next = ROFF_NEXT_SIBLING;
1138 }
1139
1140 void
1141 roff_addtbl(struct roff_man *man, const struct tbl_span *tbl)
1142 {
1143 struct roff_node *n;
1144
1145 if (man->macroset == MACROSET_MAN)
1146 man_breakscope(man, TOKEN_NONE);
1147 n = roff_node_alloc(man, tbl->line, 0, ROFFT_TBL, TOKEN_NONE);
1148 n->span = tbl;
1149 roff_node_append(man, n);
1150 if (man->macroset == MACROSET_MDOC)
1151 n->flags |= MDOC_VALID | MDOC_ENDED;
1152 else
1153 n->flags |= MAN_VALID;
1154 man->next = ROFF_NEXT_SIBLING;
1155 }
1156
1157 void
1158 roff_node_unlink(struct roff_man *man, struct roff_node *n)
1159 {
1160
1161 /* Adjust siblings. */
1162
1163 if (n->prev)
1164 n->prev->next = n->next;
1165 if (n->next)
1166 n->next->prev = n->prev;
1167
1168 /* Adjust parent. */
1169
1170 if (n->parent != NULL) {
1171 if (n->parent->child == n)
1172 n->parent->child = n->next;
1173 if (n->parent->last == n)
1174 n->parent->last = n->prev;
1175 }
1176
1177 /* Adjust parse point. */
1178
1179 if (man == NULL)
1180 return;
1181 if (man->last == n) {
1182 if (n->prev == NULL) {
1183 man->last = n->parent;
1184 man->next = ROFF_NEXT_CHILD;
1185 } else {
1186 man->last = n->prev;
1187 man->next = ROFF_NEXT_SIBLING;
1188 }
1189 }
1190 if (man->first == n)
1191 man->first = NULL;
1192 }
1193
1194 void
1195 roff_node_free(struct roff_node *n)
1196 {
1197
1198 if (n->args != NULL)
1199 mdoc_argv_free(n->args);
1200 if (n->type == ROFFT_BLOCK || n->type == ROFFT_ELEM)
1201 free(n->norm);
1202 free(n->string);
1203 free(n);
1204 }
1205
1206 void
1207 roff_node_delete(struct roff_man *man, struct roff_node *n)
1208 {
1209
1210 while (n->child != NULL)
1211 roff_node_delete(man, n->child);
1212 roff_node_unlink(man, n);
1213 roff_node_free(n);
1214 }
1215
1216 void
1217 deroff(char **dest, const struct roff_node *n)
1218 {
1219 char *cp;
1220 size_t sz;
1221
1222 if (n->type != ROFFT_TEXT) {
1223 for (n = n->child; n != NULL; n = n->next)
1224 deroff(dest, n);
1225 return;
1226 }
1227
1228 /* Skip leading whitespace and escape sequences. */
1229
1230 cp = n->string;
1231 while (*cp != '\0') {
1232 if ('\\' == *cp) {
1233 cp++;
1234 mandoc_escape((const char **)&cp, NULL, NULL);
1235 } else if (isspace((unsigned char)*cp))
1236 cp++;
1237 else
1238 break;
1239 }
1240
1241 /* Skip trailing whitespace. */
1242
1243 for (sz = strlen(cp); sz; sz--)
1244 if ( ! isspace((unsigned char)cp[sz-1]))
1245 break;
1246
1247 /* Skip empty strings. */
1248
1249 if (sz == 0)
1250 return;
1251
1252 if (*dest == NULL) {
1253 *dest = mandoc_strndup(cp, sz);
1254 return;
1255 }
1256
1257 mandoc_asprintf(&cp, "%s %*s", *dest, (int)sz, cp);
1258 free(*dest);
1259 *dest = cp;
1260 }
1261
1262 /* --- main functions of the roff parser ---------------------------------- */
1263
1264 /*
1265 * In the current line, expand escape sequences that tend to get
1266 * used in numerical expressions and conditional requests.
1267 * Also check the syntax of the remaining escape sequences.
1268 */
1269 static enum rofferr
1270 roff_res(struct roff *r, struct buf *buf, int ln, int pos)
1271 {
1272 char ubuf[24]; /* buffer to print the number */
1273 const char *start; /* start of the string to process */
1274 char *stesc; /* start of an escape sequence ('\\') */
1275 const char *stnam; /* start of the name, after "[(*" */
1276 const char *cp; /* end of the name, e.g. before ']' */
1277 const char *res; /* the string to be substituted */
1278 char *nbuf; /* new buffer to copy buf->buf to */
1279 size_t maxl; /* expected length of the escape name */
1280 size_t naml; /* actual length of the escape name */
1281 enum mandoc_esc esc; /* type of the escape sequence */
1282 int inaml; /* length returned from mandoc_escape() */
1283 int expand_count; /* to avoid infinite loops */
1284 int npos; /* position in numeric expression */
1285 int arg_complete; /* argument not interrupted by eol */
1286 char term; /* character terminating the escape */
1287
1288 expand_count = 0;
1289 start = buf->buf + pos;
1290 stesc = strchr(start, '\0') - 1;
1291 while (stesc-- > start) {
1292
1293 /* Search backwards for the next backslash. */
1294
1295 if (*stesc != '\\')
1296 continue;
1297
1298 /* If it is escaped, skip it. */
1299
1300 for (cp = stesc - 1; cp >= start; cp--)
1301 if (*cp != '\\')
1302 break;
1303
1304 if ((stesc - cp) % 2 == 0) {
1305 stesc = (char *)cp;
1306 continue;
1307 }
1308
1309 /* Decide whether to expand or to check only. */
1310
1311 term = '\0';
1312 cp = stesc + 1;
1313 switch (*cp) {
1314 case '*':
1315 res = NULL;
1316 break;
1317 case 'B':
1318 case 'w':
1319 term = cp[1];
1320 /* FALLTHROUGH */
1321 case 'n':
1322 res = ubuf;
1323 break;
1324 default:
1325 esc = mandoc_escape(&cp, &stnam, &inaml);
1326 if (esc == ESCAPE_ERROR ||
1327 (esc == ESCAPE_SPECIAL &&
1328 mchars_spec2cp(stnam, inaml) < 0))
1329 mandoc_vmsg(MANDOCERR_ESC_BAD,
1330 r->parse, ln, (int)(stesc - buf->buf),
1331 "%.*s", (int)(cp - stesc), stesc);
1332 continue;
1333 }
1334
1335 if (EXPAND_LIMIT < ++expand_count) {
1336 mandoc_msg(MANDOCERR_ROFFLOOP, r->parse,
1337 ln, (int)(stesc - buf->buf), NULL);
1338 return ROFF_IGN;
1339 }
1340
1341 /*
1342 * The third character decides the length
1343 * of the name of the string or register.
1344 * Save a pointer to the name.
1345 */
1346
1347 if (term == '\0') {
1348 switch (*++cp) {
1349 case '\0':
1350 maxl = 0;
1351 break;
1352 case '(':
1353 cp++;
1354 maxl = 2;
1355 break;
1356 case '[':
1357 cp++;
1358 term = ']';
1359 maxl = 0;
1360 break;
1361 default:
1362 maxl = 1;
1363 break;
1364 }
1365 } else {
1366 cp += 2;
1367 maxl = 0;
1368 }
1369 stnam = cp;
1370
1371 /* Advance to the end of the name. */
1372
1373 naml = 0;
1374 arg_complete = 1;
1375 while (maxl == 0 || naml < maxl) {
1376 if (*cp == '\0') {
1377 mandoc_msg(MANDOCERR_ESC_BAD, r->parse,
1378 ln, (int)(stesc - buf->buf), stesc);
1379 arg_complete = 0;
1380 break;
1381 }
1382 if (maxl == 0 && *cp == term) {
1383 cp++;
1384 break;
1385 }
1386 if (*cp++ != '\\' || stesc[1] != 'w') {
1387 naml++;
1388 continue;
1389 }
1390 switch (mandoc_escape(&cp, NULL, NULL)) {
1391 case ESCAPE_SPECIAL:
1392 case ESCAPE_UNICODE:
1393 case ESCAPE_NUMBERED:
1394 case ESCAPE_OVERSTRIKE:
1395 naml++;
1396 break;
1397 default:
1398 break;
1399 }
1400 }
1401
1402 /*
1403 * Retrieve the replacement string; if it is
1404 * undefined, resume searching for escapes.
1405 */
1406
1407 switch (stesc[1]) {
1408 case '*':
1409 if (arg_complete)
1410 res = roff_getstrn(r, stnam, naml);
1411 break;
1412 case 'B':
1413 npos = 0;
1414 ubuf[0] = arg_complete &&
1415 roff_evalnum(r, ln, stnam, &npos,
1416 NULL, ROFFNUM_SCALE) &&
1417 stnam + npos + 1 == cp ? '1' : '0';
1418 ubuf[1] = '\0';
1419 break;
1420 case 'n':
1421 if (arg_complete)
1422 (void)snprintf(ubuf, sizeof(ubuf), "%d",
1423 roff_getregn(r, stnam, naml));
1424 else
1425 ubuf[0] = '\0';
1426 break;
1427 case 'w':
1428 /* use even incomplete args */
1429 (void)snprintf(ubuf, sizeof(ubuf), "%d",
1430 24 * (int)naml);
1431 break;
1432 }
1433
1434 if (res == NULL) {
1435 mandoc_vmsg(MANDOCERR_STR_UNDEF,
1436 r->parse, ln, (int)(stesc - buf->buf),
1437 "%.*s", (int)naml, stnam);
1438 res = "";
1439 } else if (buf->sz + strlen(res) > SHRT_MAX) {
1440 mandoc_msg(MANDOCERR_ROFFLOOP, r->parse,
1441 ln, (int)(stesc - buf->buf), NULL);
1442 return ROFF_IGN;
1443 }
1444
1445 /* Replace the escape sequence by the string. */
1446
1447 *stesc = '\0';
1448 buf->sz = mandoc_asprintf(&nbuf, "%s%s%s",
1449 buf->buf, res, cp) + 1;
1450
1451 /* Prepare for the next replacement. */
1452
1453 start = nbuf + pos;
1454 stesc = nbuf + (stesc - buf->buf) + strlen(res);
1455 free(buf->buf);
1456 buf->buf = nbuf;
1457 }
1458 return ROFF_CONT;
1459 }
1460
1461 /*
1462 * Process text streams.
1463 */
1464 static enum rofferr
1465 roff_parsetext(struct buf *buf, int pos, int *offs)
1466 {
1467 size_t sz;
1468 const char *start;
1469 char *p;
1470 int isz;
1471 enum mandoc_esc esc;
1472
1473 /* Spring the input line trap. */
1474
1475 if (roffit_lines == 1) {
1476 isz = mandoc_asprintf(&p, "%s\n.%s", buf->buf, roffit_macro);
1477 free(buf->buf);
1478 buf->buf = p;
1479 buf->sz = isz + 1;
1480 *offs = 0;
1481 free(roffit_macro);
1482 roffit_lines = 0;
1483 return ROFF_REPARSE;
1484 } else if (roffit_lines > 1)
1485 --roffit_lines;
1486
1487 /* Convert all breakable hyphens into ASCII_HYPH. */
1488
1489 start = p = buf->buf + pos;
1490
1491 while (*p != '\0') {
1492 sz = strcspn(p, "-\\");
1493 p += sz;
1494
1495 if (*p == '\0')
1496 break;
1497
1498 if (*p == '\\') {
1499 /* Skip over escapes. */
1500 p++;
1501 esc = mandoc_escape((const char **)&p, NULL, NULL);
1502 if (esc == ESCAPE_ERROR)
1503 break;
1504 while (*p == '-')
1505 p++;
1506 continue;
1507 } else if (p == start) {
1508 p++;
1509 continue;
1510 }
1511
1512 if (isalpha((unsigned char)p[-1]) &&
1513 isalpha((unsigned char)p[1]))
1514 *p = ASCII_HYPH;
1515 p++;
1516 }
1517 return ROFF_CONT;
1518 }
1519
1520 enum rofferr
1521 roff_parseln(struct roff *r, int ln, struct buf *buf, int *offs)
1522 {
1523 enum rofft t;
1524 enum rofferr e;
1525 int pos; /* parse point */
1526 int spos; /* saved parse point for messages */
1527 int ppos; /* original offset in buf->buf */
1528 int ctl; /* macro line (boolean) */
1529
1530 ppos = pos = *offs;
1531
1532 /* Handle in-line equation delimiters. */
1533
1534 if (r->tbl == NULL &&
1535 r->last_eqn != NULL && r->last_eqn->delim &&
1536 (r->eqn == NULL || r->eqn_inline)) {
1537 e = roff_eqndelim(r, buf, pos);
1538 if (e == ROFF_REPARSE)
1539 return e;
1540 assert(e == ROFF_CONT);
1541 }
1542
1543 /* Expand some escape sequences. */
1544
1545 e = roff_res(r, buf, ln, pos);
1546 if (e == ROFF_IGN)
1547 return e;
1548 assert(e == ROFF_CONT);
1549
1550 ctl = roff_getcontrol(r, buf->buf, &pos);
1551
1552 /*
1553 * First, if a scope is open and we're not a macro, pass the
1554 * text through the macro's filter.
1555 * Equations process all content themselves.
1556 * Tables process almost all content themselves, but we want
1557 * to warn about macros before passing it there.
1558 */
1559
1560 if (r->last != NULL && ! ctl) {
1561 t = r->last->tok;
1562 assert(roffs[t].text);
1563 e = (*roffs[t].text)(r, t, buf, ln, pos, pos, offs);
1564 assert(e == ROFF_IGN || e == ROFF_CONT);
1565 if (e != ROFF_CONT)
1566 return e;
1567 }
1568 if (r->eqn != NULL)
1569 return eqn_read(&r->eqn, ln, buf->buf, ppos, offs);
1570 if (r->tbl != NULL && ( ! ctl || buf->buf[pos] == '\0'))
1571 return tbl_read(r->tbl, ln, buf->buf, ppos);
1572 if ( ! ctl)
1573 return roff_parsetext(buf, pos, offs);
1574
1575 /* Skip empty request lines. */
1576
1577 if (buf->buf[pos] == '"') {
1578 mandoc_msg(MANDOCERR_COMMENT_BAD, r->parse,
1579 ln, pos, NULL);
1580 return ROFF_IGN;
1581 } else if (buf->buf[pos] == '\0')
1582 return ROFF_IGN;
1583
1584 /*
1585 * If a scope is open, go to the child handler for that macro,
1586 * as it may want to preprocess before doing anything with it.
1587 * Don't do so if an equation is open.
1588 */
1589
1590 if (r->last) {
1591 t = r->last->tok;
1592 assert(roffs[t].sub);
1593 return (*roffs[t].sub)(r, t, buf, ln, ppos, pos, offs);
1594 }
1595
1596 /* No scope is open. This is a new request or macro. */
1597
1598 spos = pos;
1599 t = roff_parse(r, buf->buf, &pos, ln, ppos);
1600
1601 /* Tables ignore most macros. */
1602
1603 if (r->tbl != NULL && (t == ROFF_MAX || t == ROFF_TS)) {
1604 mandoc_msg(MANDOCERR_TBLMACRO, r->parse,
1605 ln, pos, buf->buf + spos);
1606 if (t == ROFF_TS)
1607 return ROFF_IGN;
1608 while (buf->buf[pos] != '\0' && buf->buf[pos] != ' ')
1609 pos++;
1610 while (buf->buf[pos] != '\0' && buf->buf[pos] == ' ')
1611 pos++;
1612 return tbl_read(r->tbl, ln, buf->buf, pos);
1613 }
1614
1615 /*
1616 * This is neither a roff request nor a user-defined macro.
1617 * Let the standard macro set parsers handle it.
1618 */
1619
1620 if (t == ROFF_MAX)
1621 return ROFF_CONT;
1622
1623 /* Execute a roff request or a user defined macro. */
1624
1625 assert(roffs[t].proc);
1626 return (*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs);
1627 }
1628
1629 void
1630 roff_endparse(struct roff *r)
1631 {
1632
1633 if (r->last)
1634 mandoc_msg(MANDOCERR_BLK_NOEND, r->parse,
1635 r->last->line, r->last->col,
1636 roffs[r->last->tok].name);
1637
1638 if (r->eqn) {
1639 mandoc_msg(MANDOCERR_BLK_NOEND, r->parse,
1640 r->eqn->eqn.ln, r->eqn->eqn.pos, "EQ");
1641 eqn_end(&r->eqn);
1642 }
1643
1644 if (r->tbl) {
1645 mandoc_msg(MANDOCERR_BLK_NOEND, r->parse,
1646 r->tbl->line, r->tbl->pos, "TS");
1647 tbl_end(&r->tbl);
1648 }
1649 }
1650
1651 /*
1652 * Parse a roff node's type from the input buffer. This must be in the
1653 * form of ".foo xxx" in the usual way.
1654 */
1655 static enum rofft
1656 roff_parse(struct roff *r, char *buf, int *pos, int ln, int ppos)
1657 {
1658 char *cp;
1659 const char *mac;
1660 size_t maclen;
1661 enum rofft t;
1662
1663 cp = buf + *pos;
1664
1665 if ('\0' == *cp || '"' == *cp || '\t' == *cp || ' ' == *cp)
1666 return ROFF_MAX;
1667
1668 mac = cp;
1669 maclen = roff_getname(r, &cp, ln, ppos);
1670
1671 t = (r->current_string = roff_getstrn(r, mac, maclen))
1672 ? ROFF_USERDEF : roffhash_find(mac, maclen);
1673
1674 if (ROFF_MAX != t)
1675 *pos = cp - buf;
1676
1677 return t;
1678 }
1679
1680 /* --- handling of request blocks ----------------------------------------- */
1681
1682 static enum rofferr
1683 roff_cblock(ROFF_ARGS)
1684 {
1685
1686 /*
1687 * A block-close `..' should only be invoked as a child of an
1688 * ignore macro, otherwise raise a warning and just ignore it.
1689 */
1690
1691 if (r->last == NULL) {
1692 mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse,
1693 ln, ppos, "..");
1694 return ROFF_IGN;
1695 }
1696
1697 switch (r->last->tok) {
1698 case ROFF_am:
1699 /* ROFF_am1 is remapped to ROFF_am in roff_block(). */
1700 case ROFF_ami:
1701 case ROFF_de:
1702 /* ROFF_de1 is remapped to ROFF_de in roff_block(). */
1703 case ROFF_dei:
1704 case ROFF_ig:
1705 break;
1706 default:
1707 mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse,
1708 ln, ppos, "..");
1709 return ROFF_IGN;
1710 }
1711
1712 if (buf->buf[pos] != '\0')
1713 mandoc_vmsg(MANDOCERR_ARG_SKIP, r->parse, ln, pos,
1714 ".. %s", buf->buf + pos);
1715
1716 roffnode_pop(r);
1717 roffnode_cleanscope(r);
1718 return ROFF_IGN;
1719
1720 }
1721
1722 static void
1723 roffnode_cleanscope(struct roff *r)
1724 {
1725
1726 while (r->last) {
1727 if (--r->last->endspan != 0)
1728 break;
1729 roffnode_pop(r);
1730 }
1731 }
1732
1733 static void
1734 roff_ccond(struct roff *r, int ln, int ppos)
1735 {
1736
1737 if (NULL == r->last) {
1738 mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse,
1739 ln, ppos, "\\}");
1740 return;
1741 }
1742
1743 switch (r->last->tok) {
1744 case ROFF_el:
1745 case ROFF_ie:
1746 case ROFF_if:
1747 break;
1748 default:
1749 mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse,
1750 ln, ppos, "\\}");
1751 return;
1752 }
1753
1754 if (r->last->endspan > -1) {
1755 mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse,
1756 ln, ppos, "\\}");
1757 return;
1758 }
1759
1760 roffnode_pop(r);
1761 roffnode_cleanscope(r);
1762 return;
1763 }
1764
1765 static enum rofferr
1766 roff_block(ROFF_ARGS)
1767 {
1768 const char *name;
1769 char *iname, *cp;
1770 size_t namesz;
1771
1772 /* Ignore groff compatibility mode for now. */
1773
1774 if (tok == ROFF_de1)
1775 tok = ROFF_de;
1776 else if (tok == ROFF_dei1)
1777 tok = ROFF_dei;
1778 else if (tok == ROFF_am1)
1779 tok = ROFF_am;
1780 else if (tok == ROFF_ami1)
1781 tok = ROFF_ami;
1782
1783 /* Parse the macro name argument. */
1784
1785 cp = buf->buf + pos;
1786 if (tok == ROFF_ig) {
1787 iname = NULL;
1788 namesz = 0;
1789 } else {
1790 iname = cp;
1791 namesz = roff_getname(r, &cp, ln, ppos);
1792 iname[namesz] = '\0';
1793 }
1794
1795 /* Resolve the macro name argument if it is indirect. */
1796
1797 if (namesz && (tok == ROFF_dei || tok == ROFF_ami)) {
1798 if ((name = roff_getstrn(r, iname, namesz)) == NULL) {
1799 mandoc_vmsg(MANDOCERR_STR_UNDEF,
1800 r->parse, ln, (int)(iname - buf->buf),
1801 "%.*s", (int)namesz, iname);
1802 namesz = 0;
1803 } else
1804 namesz = strlen(name);
1805 } else
1806 name = iname;
1807
1808 if (namesz == 0 && tok != ROFF_ig) {
1809 mandoc_msg(MANDOCERR_REQ_EMPTY, r->parse,
1810 ln, ppos, roffs[tok].name);
1811 return ROFF_IGN;
1812 }
1813
1814 roffnode_push(r, tok, name, ln, ppos);
1815
1816 /*
1817 * At the beginning of a `de' macro, clear the existing string
1818 * with the same name, if there is one. New content will be
1819 * appended from roff_block_text() in multiline mode.
1820 */
1821
1822 if (tok == ROFF_de || tok == ROFF_dei)
1823 roff_setstrn(&r->strtab, name, namesz, "", 0, 0);
1824
1825 if (*cp == '\0')
1826 return ROFF_IGN;
1827
1828 /* Get the custom end marker. */
1829
1830 iname = cp;
1831 namesz = roff_getname(r, &cp, ln, ppos);
1832
1833 /* Resolve the end marker if it is indirect. */
1834
1835 if (namesz && (tok == ROFF_dei || tok == ROFF_ami)) {
1836 if ((name = roff_getstrn(r, iname, namesz)) == NULL) {
1837 mandoc_vmsg(MANDOCERR_STR_UNDEF,
1838 r->parse, ln, (int)(iname - buf->buf),
1839 "%.*s", (int)namesz, iname);
1840 namesz = 0;
1841 } else
1842 namesz = strlen(name);
1843 } else
1844 name = iname;
1845
1846 if (namesz)
1847 r->last->end = mandoc_strndup(name, namesz);
1848
1849 if (*cp != '\0')
1850 mandoc_vmsg(MANDOCERR_ARG_EXCESS, r->parse,
1851 ln, pos, ".%s ... %s", roffs[tok].name, cp);
1852
1853 return ROFF_IGN;
1854 }
1855
1856 static enum rofferr
1857 roff_block_sub(ROFF_ARGS)
1858 {
1859 enum rofft t;
1860 int i, j;
1861
1862 /*
1863 * First check whether a custom macro exists at this level. If
1864 * it does, then check against it. This is some of groff's
1865 * stranger behaviours. If we encountered a custom end-scope
1866 * tag and that tag also happens to be a "real" macro, then we
1867 * need to try interpreting it again as a real macro. If it's
1868 * not, then return ignore. Else continue.
1869 */
1870
1871 if (r->last->end) {
1872 for (i = pos, j = 0; r->last->end[j]; j++, i++)
1873 if (buf->buf[i] != r->last->end[j])
1874 break;
1875
1876 if (r->last->end[j] == '\0' &&
1877 (buf->buf[i] == '\0' ||
1878 buf->buf[i] == ' ' ||
1879 buf->buf[i] == '\t')) {
1880 roffnode_pop(r);
1881 roffnode_cleanscope(r);
1882
1883 while (buf->buf[i] == ' ' || buf->buf[i] == '\t')
1884 i++;
1885
1886 pos = i;
1887 if (roff_parse(r, buf->buf, &pos, ln, ppos) !=
1888 ROFF_MAX)
1889 return ROFF_RERUN;
1890 return ROFF_IGN;
1891 }
1892 }
1893
1894 /*
1895 * If we have no custom end-query or lookup failed, then try
1896 * pulling it out of the hashtable.
1897 */
1898
1899 t = roff_parse(r, buf->buf, &pos, ln, ppos);
1900
1901 if (t != ROFF_cblock) {
1902 if (tok != ROFF_ig)
1903 roff_setstr(r, r->last->name, buf->buf + ppos, 2);
1904 return ROFF_IGN;
1905 }
1906
1907 assert(roffs[t].proc);
1908 return (*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs);
1909 }
1910
1911 static enum rofferr
1912 roff_block_text(ROFF_ARGS)
1913 {
1914
1915 if (tok != ROFF_ig)
1916 roff_setstr(r, r->last->name, buf->buf + pos, 2);
1917
1918 return ROFF_IGN;
1919 }
1920
1921 static enum rofferr
1922 roff_cond_sub(ROFF_ARGS)
1923 {
1924 enum rofft t;
1925 char *ep;
1926 int rr;
1927
1928 rr = r->last->rule;
1929 roffnode_cleanscope(r);
1930 t = roff_parse(r, buf->buf, &pos, ln, ppos);
1931
1932 /*
1933 * Fully handle known macros when they are structurally
1934 * required or when the conditional evaluated to true.
1935 */
1936
1937 if ((t != ROFF_MAX) &&
1938 (rr || roffs[t].flags & ROFFMAC_STRUCT)) {
1939 assert(roffs[t].proc);
1940 return (*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs);
1941 }
1942
1943 /*
1944 * If `\}' occurs on a macro line without a preceding macro,
1945 * drop the line completely.
1946 */
1947
1948 ep = buf->buf + pos;
1949 if (ep[0] == '\\' && ep[1] == '}')
1950 rr = 0;
1951
1952 /* Always check for the closing delimiter `\}'. */
1953
1954 while ((ep = strchr(ep, '\\')) != NULL) {
1955 if (*(++ep) == '}') {
1956 *ep = '&';
1957 roff_ccond(r, ln, ep - buf->buf - 1);
1958 }
1959 if (*ep != '\0')
1960 ++ep;
1961 }
1962 return rr ? ROFF_CONT : ROFF_IGN;
1963 }
1964
1965 static enum rofferr
1966 roff_cond_text(ROFF_ARGS)
1967 {
1968 char *ep;
1969 int rr;
1970
1971 rr = r->last->rule;
1972 roffnode_cleanscope(r);
1973
1974 ep = buf->buf + pos;
1975 while ((ep = strchr(ep, '\\')) != NULL) {
1976 if (*(++ep) == '}') {
1977 *ep = '&';
1978 roff_ccond(r, ln, ep - buf->buf - 1);
1979 }
1980 if (*ep != '\0')
1981 ++ep;
1982 }
1983 return rr ? ROFF_CONT : ROFF_IGN;
1984 }
1985
1986 /* --- handling of numeric and conditional expressions -------------------- */
1987
1988 /*
1989 * Parse a single signed integer number. Stop at the first non-digit.
1990 * If there is at least one digit, return success and advance the
1991 * parse point, else return failure and let the parse point unchanged.
1992 * Ignore overflows, treat them just like the C language.
1993 */
1994 static int
1995 roff_getnum(const char *v, int *pos, int *res, int flags)
1996 {
1997 int myres, scaled, n, p;
1998
1999 if (NULL == res)
2000 res = &myres;
2001
2002 p = *pos;
2003 n = v[p] == '-';
2004 if (n || v[p] == '+')
2005 p++;
2006
2007 if (flags & ROFFNUM_WHITE)
2008 while (isspace((unsigned char)v[p]))
2009 p++;
2010
2011 for (*res = 0; isdigit((unsigned char)v[p]); p++)
2012 *res = 10 * *res + v[p] - '0';
2013 if (p == *pos + n)
2014 return 0;
2015
2016 if (n)
2017 *res = -*res;
2018
2019 /* Each number may be followed by one optional scaling unit. */
2020
2021 switch (v[p]) {
2022 case 'f':
2023 scaled = *res * 65536;
2024 break;
2025 case 'i':
2026 scaled = *res * 240;
2027 break;
2028 case 'c':
2029 scaled = *res * 240 / 2.54;
2030 break;
2031 case 'v':
2032 case 'P':
2033 scaled = *res * 40;
2034 break;
2035 case 'm':
2036 case 'n':
2037 scaled = *res * 24;
2038 break;
2039 case 'p':
2040 scaled = *res * 10 / 3;
2041 break;
2042 case 'u':
2043 scaled = *res;
2044 break;
2045 case 'M':
2046 scaled = *res * 6 / 25;
2047 break;
2048 default:
2049 scaled = *res;
2050 p--;
2051 break;
2052 }
2053 if (flags & ROFFNUM_SCALE)
2054 *res = scaled;
2055
2056 *pos = p + 1;
2057 return 1;
2058 }
2059
2060 /*
2061 * Evaluate a string comparison condition.
2062 * The first character is the delimiter.
2063 * Succeed if the string up to its second occurrence
2064 * matches the string up to its third occurence.
2065 * Advance the cursor after the third occurrence
2066 * or lacking that, to the end of the line.
2067 */
2068 static int
2069 roff_evalstrcond(const char *v, int *pos)
2070 {
2071 const char *s1, *s2, *s3;
2072 int match;
2073
2074 match = 0;
2075 s1 = v + *pos; /* initial delimiter */
2076 s2 = s1 + 1; /* for scanning the first string */
2077 s3 = strchr(s2, *s1); /* for scanning the second string */
2078
2079 if (NULL == s3) /* found no middle delimiter */
2080 goto out;
2081
2082 while ('\0' != *++s3) {
2083 if (*s2 != *s3) { /* mismatch */
2084 s3 = strchr(s3, *s1);
2085 break;
2086 }
2087 if (*s3 == *s1) { /* found the final delimiter */
2088 match = 1;
2089 break;
2090 }
2091 s2++;
2092 }
2093
2094 out:
2095 if (NULL == s3)
2096 s3 = strchr(s2, '\0');
2097 else if (*s3 != '\0')
2098 s3++;
2099 *pos = s3 - v;
2100 return match;
2101 }
2102
2103 /*
2104 * Evaluate an optionally negated single character, numerical,
2105 * or string condition.
2106 */
2107 static int
2108 roff_evalcond(struct roff *r, int ln, char *v, int *pos)
2109 {
2110 char *cp, *name;
2111 size_t sz;
2112 int number, savepos, wanttrue;
2113
2114 if ('!' == v[*pos]) {
2115 wanttrue = 0;
2116 (*pos)++;
2117 } else
2118 wanttrue = 1;
2119
2120 switch (v[*pos]) {
2121 case '\0':
2122 return 0;
2123 case 'n':
2124 case 'o':
2125 (*pos)++;
2126 return wanttrue;
2127 case 'c':
2128 case 'd':
2129 case 'e':
2130 case 't':
2131 case 'v':
2132 (*pos)++;
2133 return !wanttrue;
2134 case 'r':
2135 cp = name = v + ++*pos;
2136 sz = roff_getname(r, &cp, ln, *pos);
2137 *pos = cp - v;
2138 return (sz && roff_hasregn(r, name, sz)) == wanttrue;
2139 default:
2140 break;
2141 }
2142
2143 savepos = *pos;
2144 if (roff_evalnum(r, ln, v, pos, &number, ROFFNUM_SCALE))
2145 return (number > 0) == wanttrue;
2146 else if (*pos == savepos)
2147 return roff_evalstrcond(v, pos) == wanttrue;
2148 else
2149 return 0;
2150 }
2151
2152 static enum rofferr
2153 roff_line_ignore(ROFF_ARGS)
2154 {
2155
2156 return ROFF_IGN;
2157 }
2158
2159 static enum rofferr
2160 roff_insec(ROFF_ARGS)
2161 {
2162
2163 mandoc_msg(MANDOCERR_REQ_INSEC, r->parse,
2164 ln, ppos, roffs[tok].name);
2165 return ROFF_IGN;
2166 }
2167
2168 static enum rofferr
2169 roff_unsupp(ROFF_ARGS)
2170 {
2171
2172 mandoc_msg(MANDOCERR_REQ_UNSUPP, r->parse,
2173 ln, ppos, roffs[tok].name);
2174 return ROFF_IGN;
2175 }
2176
2177 static enum rofferr
2178 roff_cond(ROFF_ARGS)
2179 {
2180
2181 roffnode_push(r, tok, NULL, ln, ppos);
2182
2183 /*
2184 * An `.el' has no conditional body: it will consume the value
2185 * of the current rstack entry set in prior `ie' calls or
2186 * defaults to DENY.
2187 *
2188 * If we're not an `el', however, then evaluate the conditional.
2189 */
2190
2191 r->last->rule = tok == ROFF_el ?
2192 (r->rstackpos < 0 ? 0 : r->rstack[r->rstackpos--]) :
2193 roff_evalcond(r, ln, buf->buf, &pos);
2194
2195 /*
2196 * An if-else will put the NEGATION of the current evaluated
2197 * conditional into the stack of rules.
2198 */
2199
2200 if (tok == ROFF_ie) {
2201 if (r->rstackpos + 1 == r->rstacksz) {
2202 r->rstacksz += 16;
2203 r->rstack = mandoc_reallocarray(r->rstack,
2204 r->rstacksz, sizeof(int));
2205 }
2206 r->rstack[++r->rstackpos] = !r->last->rule;
2207 }
2208
2209 /* If the parent has false as its rule, then so do we. */
2210
2211 if (r->last->parent && !r->last->parent->rule)
2212 r->last->rule = 0;
2213
2214 /*
2215 * Determine scope.
2216 * If there is nothing on the line after the conditional,
2217 * not even whitespace, use next-line scope.
2218 */
2219
2220 if (buf->buf[pos] == '\0') {
2221 r->last->endspan = 2;
2222 goto out;
2223 }
2224
2225 while (buf->buf[pos] == ' ')
2226 pos++;
2227
2228 /* An opening brace requests multiline scope. */
2229
2230 if (buf->buf[pos] == '\\' && buf->buf[pos + 1] == '{') {
2231 r->last->endspan = -1;
2232 pos += 2;
2233 while (buf->buf[pos] == ' ')
2234 pos++;
2235 goto out;
2236 }
2237
2238 /*
2239 * Anything else following the conditional causes
2240 * single-line scope. Warn if the scope contains
2241 * nothing but trailing whitespace.
2242 */
2243
2244 if (buf->buf[pos] == '\0')
2245 mandoc_msg(MANDOCERR_COND_EMPTY, r->parse,
2246 ln, ppos, roffs[tok].name);
2247
2248 r->last->endspan = 1;
2249
2250 out:
2251 *offs = pos;
2252 return ROFF_RERUN;
2253 }
2254
2255 static enum rofferr
2256 roff_ds(ROFF_ARGS)
2257 {
2258 char *string;
2259 const char *name;
2260 size_t namesz;
2261
2262 /* Ignore groff compatibility mode for now. */
2263
2264 if (tok == ROFF_ds1)
2265 tok = ROFF_ds;
2266 else if (tok == ROFF_as1)
2267 tok = ROFF_as;
2268
2269 /*
2270 * The first word is the name of the string.
2271 * If it is empty or terminated by an escape sequence,
2272 * abort the `ds' request without defining anything.
2273 */
2274
2275 name = string = buf->buf + pos;
2276 if (*name == '\0')
2277 return ROFF_IGN;
2278
2279 namesz = roff_getname(r, &string, ln, pos);
2280 if (name[namesz] == '\\')
2281 return ROFF_IGN;
2282
2283 /* Read past the initial double-quote, if any. */
2284 if (*string == '"')
2285 string++;
2286
2287 /* The rest is the value. */
2288 roff_setstrn(&r->strtab, name, namesz, string, strlen(string),
2289 ROFF_as == tok);
2290 return ROFF_IGN;
2291 }
2292
2293 /*
2294 * Parse a single operator, one or two characters long.
2295 * If the operator is recognized, return success and advance the
2296 * parse point, else return failure and let the parse point unchanged.
2297 */
2298 static int
2299 roff_getop(const char *v, int *pos, char *res)
2300 {
2301
2302 *res = v[*pos];
2303
2304 switch (*res) {
2305 case '+':
2306 case '-':
2307 case '*':
2308 case '/':
2309 case '%':
2310 case '&':
2311 case ':':
2312 break;
2313 case '<':
2314 switch (v[*pos + 1]) {
2315 case '=':
2316 *res = 'l';
2317 (*pos)++;
2318 break;
2319 case '>':
2320 *res = '!';
2321 (*pos)++;
2322 break;
2323 case '?':
2324 *res = 'i';
2325 (*pos)++;
2326 break;
2327 default:
2328 break;
2329 }
2330 break;
2331 case '>':
2332 switch (v[*pos + 1]) {
2333 case '=':
2334 *res = 'g';
2335 (*pos)++;
2336 break;
2337 case '?':
2338 *res = 'a';
2339 (*pos)++;
2340 break;
2341 default:
2342 break;
2343 }
2344 break;
2345 case '=':
2346 if ('=' == v[*pos + 1])
2347 (*pos)++;
2348 break;
2349 default:
2350 return 0;
2351 }
2352 (*pos)++;
2353
2354 return *res;
2355 }
2356
2357 /*
2358 * Evaluate either a parenthesized numeric expression
2359 * or a single signed integer number.
2360 */
2361 static int
2362 roff_evalpar(struct roff *r, int ln,
2363 const char *v, int *pos, int *res, int flags)
2364 {
2365
2366 if ('(' != v[*pos])
2367 return roff_getnum(v, pos, res, flags);
2368
2369 (*pos)++;
2370 if ( ! roff_evalnum(r, ln, v, pos, res, flags | ROFFNUM_WHITE))
2371 return 0;
2372
2373 /*
2374 * Omission of the closing parenthesis
2375 * is an error in validation mode,
2376 * but ignored in evaluation mode.
2377 */
2378
2379 if (')' == v[*pos])
2380 (*pos)++;
2381 else if (NULL == res)
2382 return 0;
2383
2384 return 1;
2385 }
2386
2387 /*
2388 * Evaluate a complete numeric expression.
2389 * Proceed left to right, there is no concept of precedence.
2390 */
2391 static int
2392 roff_evalnum(struct roff *r, int ln, const char *v,
2393 int *pos, int *res, int flags)
2394 {
2395 int mypos, operand2;
2396 char operator;
2397
2398 if (NULL == pos) {
2399 mypos = 0;
2400 pos = &mypos;
2401 }
2402
2403 if (flags & ROFFNUM_WHITE)
2404 while (isspace((unsigned char)v[*pos]))
2405 (*pos)++;
2406
2407 if ( ! roff_evalpar(r, ln, v, pos, res, flags))
2408 return 0;
2409
2410 while (1) {
2411 if (flags & ROFFNUM_WHITE)
2412 while (isspace((unsigned char)v[*pos]))
2413 (*pos)++;
2414
2415 if ( ! roff_getop(v, pos, &operator))
2416 break;
2417
2418 if (flags & ROFFNUM_WHITE)
2419 while (isspace((unsigned char)v[*pos]))
2420 (*pos)++;
2421
2422 if ( ! roff_evalpar(r, ln, v, pos, &operand2, flags))
2423 return 0;
2424
2425 if (flags & ROFFNUM_WHITE)
2426 while (isspace((unsigned char)v[*pos]))
2427 (*pos)++;
2428
2429 if (NULL == res)
2430 continue;
2431
2432 switch (operator) {
2433 case '+':
2434 *res += operand2;
2435 break;
2436 case '-':
2437 *res -= operand2;
2438 break;
2439 case '*':
2440 *res *= operand2;
2441 break;
2442 case '/':
2443 if (operand2 == 0) {
2444 mandoc_msg(MANDOCERR_DIVZERO,
2445 r->parse, ln, *pos, v);
2446 *res = 0;
2447 break;
2448 }
2449 *res /= operand2;
2450 break;
2451 case '%':
2452 if (operand2 == 0) {
2453 mandoc_msg(MANDOCERR_DIVZERO,
2454 r->parse, ln, *pos, v);
2455 *res = 0;
2456 break;
2457 }
2458 *res %= operand2;
2459 break;
2460 case '<':
2461 *res = *res < operand2;
2462 break;
2463 case '>':
2464 *res = *res > operand2;
2465 break;
2466 case 'l':
2467 *res = *res <= operand2;
2468 break;
2469 case 'g':
2470 *res = *res >= operand2;
2471 break;
2472 case '=':
2473 *res = *res == operand2;
2474 break;
2475 case '!':
2476 *res = *res != operand2;
2477 break;
2478 case '&':
2479 *res = *res && operand2;
2480 break;
2481 case ':':
2482 *res = *res || operand2;
2483 break;
2484 case 'i':
2485 if (operand2 < *res)
2486 *res = operand2;
2487 break;
2488 case 'a':
2489 if (operand2 > *res)
2490 *res = operand2;
2491 break;
2492 default:
2493 abort();
2494 }
2495 }
2496 return 1;
2497 }
2498
2499 /* --- register management ------------------------------------------------ */
2500
2501 void
2502 roff_setreg(struct roff *r, const char *name, int val, char sign)
2503 {
2504 struct roffreg *reg;
2505
2506 /* Search for an existing register with the same name. */
2507 reg = r->regtab;
2508
2509 while (reg && strcmp(name, reg->key.p))
2510 reg = reg->next;
2511
2512 if (NULL == reg) {
2513 /* Create a new register. */
2514 reg = mandoc_malloc(sizeof(struct roffreg));
2515 reg->key.p = mandoc_strdup(name);
2516 reg->key.sz = strlen(name);
2517 reg->val = 0;
2518 reg->next = r->regtab;
2519 r->regtab = reg;
2520 }
2521
2522 if ('+' == sign)
2523 reg->val += val;
2524 else if ('-' == sign)
2525 reg->val -= val;
2526 else
2527 reg->val = val;
2528 }
2529
2530 /*
2531 * Handle some predefined read-only number registers.
2532 * For now, return -1 if the requested register is not predefined;
2533 * in case a predefined read-only register having the value -1
2534 * were to turn up, another special value would have to be chosen.
2535 */
2536 static int
2537 roff_getregro(const struct roff *r, const char *name)
2538 {
2539
2540 switch (*name) {
2541 case '$': /* Number of arguments of the last macro evaluated. */
2542 return r->argc;
2543 case 'A': /* ASCII approximation mode is always off. */
2544 return 0;
2545 case 'g': /* Groff compatibility mode is always on. */
2546 return 1;
2547 case 'H': /* Fixed horizontal resolution. */
2548 return 24;
2549 case 'j': /* Always adjust left margin only. */
2550 return 0;
2551 case 'T': /* Some output device is always defined. */
2552 return 1;
2553 case 'V': /* Fixed vertical resolution. */
2554 return 40;
2555 default:
2556 return -1;
2557 }
2558 }
2559
2560 int
2561 roff_getreg(const struct roff *r, const char *name)
2562 {
2563 struct roffreg *reg;
2564 int val;
2565
2566 if ('.' == name[0] && '\0' != name[1] && '\0' == name[2]) {
2567 val = roff_getregro(r, name + 1);
2568 if (-1 != val)
2569 return val;
2570 }
2571
2572 for (reg = r->regtab; reg; reg = reg->next)
2573 if (0 == strcmp(name, reg->key.p))
2574 return reg->val;
2575
2576 return 0;
2577 }
2578
2579 static int
2580 roff_getregn(const struct roff *r, const char *name, size_t len)
2581 {
2582 struct roffreg *reg;
2583 int val;
2584
2585 if ('.' == name[0] && 2 == len) {
2586 val = roff_getregro(r, name + 1);
2587 if (-1 != val)
2588 return val;
2589 }
2590
2591 for (reg = r->regtab; reg; reg = reg->next)
2592 if (len == reg->key.sz &&
2593 0 == strncmp(name, reg->key.p, len))
2594 return reg->val;
2595
2596 return 0;
2597 }
2598
2599 static int
2600 roff_hasregn(const struct roff *r, const char *name, size_t len)
2601 {
2602 struct roffreg *reg;
2603 int val;
2604
2605 if ('.' == name[0] && 2 == len) {
2606 val = roff_getregro(r, name + 1);
2607 if (-1 != val)
2608 return 1;
2609 }
2610
2611 for (reg = r->regtab; reg; reg = reg->next)
2612 if (len == reg->key.sz &&
2613 0 == strncmp(name, reg->key.p, len))
2614 return 1;
2615
2616 return 0;
2617 }
2618
2619 static void
2620 roff_freereg(struct roffreg *reg)
2621 {
2622 struct roffreg *old_reg;
2623
2624 while (NULL != reg) {
2625 free(reg->key.p);
2626 old_reg = reg;
2627 reg = reg->next;
2628 free(old_reg);
2629 }
2630 }
2631
2632 static enum rofferr
2633 roff_nr(ROFF_ARGS)
2634 {
2635 char *key, *val;
2636 size_t keysz;
2637 int iv;
2638 char sign;
2639
2640 key = val = buf->buf + pos;
2641 if (*key == '\0')
2642 return ROFF_IGN;
2643
2644 keysz = roff_getname(r, &val, ln, pos);
2645 if (key[keysz] == '\\')
2646 return ROFF_IGN;
2647 key[keysz] = '\0';
2648
2649 sign = *val;
2650 if (sign == '+' || sign == '-')
2651 val++;
2652
2653 if (roff_evalnum(r, ln, val, NULL, &iv, ROFFNUM_SCALE))
2654 roff_setreg(r, key, iv, sign);
2655
2656 return ROFF_IGN;
2657 }
2658
2659 static enum rofferr
2660 roff_rr(ROFF_ARGS)
2661 {
2662 struct roffreg *reg, **prev;
2663 char *name, *cp;
2664 size_t namesz;
2665
2666 name = cp = buf->buf + pos;
2667 if (*name == '\0')
2668 return ROFF_IGN;
2669 namesz = roff_getname(r, &cp, ln, pos);
2670 name[namesz] = '\0';
2671
2672 prev = &r->regtab;
2673 while (1) {
2674 reg = *prev;
2675 if (reg == NULL || !strcmp(name, reg->key.p))
2676 break;
2677 prev = &reg->next;
2678 }
2679 if (reg != NULL) {
2680 *prev = reg->next;
2681 free(reg->key.p);
2682 free(reg);
2683 }
2684 return ROFF_IGN;
2685 }
2686
2687 /* --- handler functions for roff requests -------------------------------- */
2688
2689 static enum rofferr
2690 roff_rm(ROFF_ARGS)
2691 {
2692 const char *name;
2693 char *cp;
2694 size_t namesz;
2695
2696 cp = buf->buf + pos;
2697 while (*cp != '\0') {
2698 name = cp;
2699 namesz = roff_getname(r, &cp, ln, (int)(cp - buf->buf));
2700 roff_setstrn(&r->strtab, name, namesz, NULL, 0, 0);
2701 if (name[namesz] == '\\')
2702 break;
2703 }
2704 return ROFF_IGN;
2705 }
2706
2707 static enum rofferr
2708 roff_it(ROFF_ARGS)
2709 {
2710 int iv;
2711
2712 /* Parse the number of lines. */
2713
2714 if ( ! roff_evalnum(r, ln, buf->buf, &pos, &iv, 0)) {
2715 mandoc_msg(MANDOCERR_IT_NONUM, r->parse,
2716 ln, ppos, buf->buf + 1);
2717 return ROFF_IGN;
2718 }
2719
2720 while (isspace((unsigned char)buf->buf[pos]))
2721 pos++;
2722
2723 /*
2724 * Arm the input line trap.
2725 * Special-casing "an-trap" is an ugly workaround to cope
2726 * with DocBook stupidly fiddling with man(7) internals.
2727 */
2728
2729 roffit_lines = iv;
2730 roffit_macro = mandoc_strdup(iv != 1 ||
2731 strcmp(buf->buf + pos, "an-trap") ?
2732 buf->buf + pos : "br");
2733 return ROFF_IGN;
2734 }
2735
2736 static enum rofferr
2737 roff_Dd(ROFF_ARGS)
2738 {
2739 const char *const *cp;
2740
2741 if ((r->options & (MPARSE_MDOC | MPARSE_QUICK)) == 0)
2742 for (cp = __mdoc_reserved; *cp; cp++)
2743 roff_setstr(r, *cp, NULL, 0);
2744
2745 if (r->format == 0)
2746 r->format = MPARSE_MDOC;
2747
2748 return ROFF_CONT;
2749 }
2750
2751 static enum rofferr
2752 roff_TH(ROFF_ARGS)
2753 {
2754 const char *const *cp;
2755
2756 if ((r->options & MPARSE_QUICK) == 0)
2757 for (cp = __man_reserved; *cp; cp++)
2758 roff_setstr(r, *cp, NULL, 0);
2759
2760 if (r->format == 0)
2761 r->format = MPARSE_MAN;
2762
2763 return ROFF_CONT;
2764 }
2765
2766 static enum rofferr
2767 roff_TE(ROFF_ARGS)
2768 {
2769
2770 if (NULL == r->tbl)
2771 mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse,
2772 ln, ppos, "TE");
2773 else if ( ! tbl_end(&r->tbl)) {
2774 free(buf->buf);
2775 buf->buf = mandoc_strdup(".sp");
2776 buf->sz = 4;
2777 return ROFF_REPARSE;
2778 }
2779 return ROFF_IGN;
2780 }
2781
2782 static enum rofferr
2783 roff_T_(ROFF_ARGS)
2784 {
2785
2786 if (NULL == r->tbl)
2787 mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse,
2788 ln, ppos, "T&");
2789 else
2790 tbl_restart(ppos, ln, r->tbl);
2791
2792 return ROFF_IGN;
2793 }
2794
2795 /*
2796 * Handle in-line equation delimiters.
2797 */
2798 static enum rofferr
2799 roff_eqndelim(struct roff *r, struct buf *buf, int pos)
2800 {
2801 char *cp1, *cp2;
2802 const char *bef_pr, *bef_nl, *mac, *aft_nl, *aft_pr;
2803
2804 /*
2805 * Outside equations, look for an opening delimiter.
2806 * If we are inside an equation, we already know it is
2807 * in-line, or this function wouldn't have been called;
2808 * so look for a closing delimiter.
2809 */
2810
2811 cp1 = buf->buf + pos;
2812 cp2 = strchr(cp1, r->eqn == NULL ?
2813 r->last_eqn->odelim : r->last_eqn->cdelim);
2814 if (cp2 == NULL)
2815 return ROFF_CONT;
2816
2817 *cp2++ = '\0';
2818 bef_pr = bef_nl = aft_nl = aft_pr = "";
2819
2820 /* Handle preceding text, protecting whitespace. */
2821
2822 if (*buf->buf != '\0') {
2823 if (r->eqn == NULL)
2824 bef_pr = "\\&";
2825 bef_nl = "\n";
2826 }
2827
2828 /*
2829 * Prepare replacing the delimiter with an equation macro
2830 * and drop leading white space from the equation.
2831 */
2832
2833 if (r->eqn == NULL) {
2834 while (*cp2 == ' ')
2835 cp2++;
2836 mac = ".EQ";
2837 } else
2838 mac = ".EN";
2839
2840 /* Handle following text, protecting whitespace. */
2841
2842 if (*cp2 != '\0') {
2843 aft_nl = "\n";
2844 if (r->eqn != NULL)
2845 aft_pr = "\\&";
2846 }
2847
2848 /* Do the actual replacement. */
2849
2850 buf->sz = mandoc_asprintf(&cp1, "%s%s%s%s%s%s%s", buf->buf,
2851 bef_pr, bef_nl, mac, aft_nl, aft_pr, cp2) + 1;
2852 free(buf->buf);
2853 buf->buf = cp1;
2854
2855 /* Toggle the in-line state of the eqn subsystem. */
2856
2857 r->eqn_inline = r->eqn == NULL;
2858 return ROFF_REPARSE;
2859 }
2860
2861 static enum rofferr
2862 roff_EQ(ROFF_ARGS)
2863 {
2864 struct eqn_node *e;
2865
2866 assert(r->eqn == NULL);
2867 e = eqn_alloc(ppos, ln, r->parse);
2868
2869 if (r->last_eqn) {
2870 r->last_eqn->next = e;
2871 e->delim = r->last_eqn->delim;
2872 e->odelim = r->last_eqn->odelim;
2873 e->cdelim = r->last_eqn->cdelim;
2874 } else
2875 r->first_eqn = r->last_eqn = e;
2876
2877 r->eqn = r->last_eqn = e;
2878
2879 if (buf->buf[pos] != '\0')
2880 mandoc_vmsg(MANDOCERR_ARG_SKIP, r->parse, ln, pos,
2881 ".EQ %s", buf->buf + pos);
2882
2883 return ROFF_IGN;
2884 }
2885
2886 static enum rofferr
2887 roff_EN(ROFF_ARGS)
2888 {
2889
2890 mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse, ln, ppos, "EN");
2891 return ROFF_IGN;
2892 }
2893
2894 static enum rofferr
2895 roff_TS(ROFF_ARGS)
2896 {
2897 struct tbl_node *tbl;
2898
2899 if (r->tbl) {
2900 mandoc_msg(MANDOCERR_BLK_BROKEN, r->parse,
2901 ln, ppos, "TS breaks TS");
2902 tbl_end(&r->tbl);
2903 }
2904
2905 tbl = tbl_alloc(ppos, ln, r->parse);
2906
2907 if (r->last_tbl)
2908 r->last_tbl->next = tbl;
2909 else
2910 r->first_tbl = r->last_tbl = tbl;
2911
2912 r->tbl = r->last_tbl = tbl;
2913 return ROFF_IGN;
2914 }
2915
2916 static enum rofferr
2917 roff_brp(ROFF_ARGS)
2918 {
2919
2920 buf->buf[pos - 1] = '\0';
2921 return ROFF_CONT;
2922 }
2923
2924 static enum rofferr
2925 roff_cc(ROFF_ARGS)
2926 {
2927 const char *p;
2928
2929 p = buf->buf + pos;
2930
2931 if (*p == '\0' || (r->control = *p++) == '.')
2932 r->control = 0;
2933
2934 if (*p != '\0')
2935 mandoc_vmsg(MANDOCERR_ARG_EXCESS, r->parse,
2936 ln, p - buf->buf, "cc ... %s", p);
2937
2938 return ROFF_IGN;
2939 }
2940
2941 static enum rofferr
2942 roff_tr(ROFF_ARGS)
2943 {
2944 const char *p, *first, *second;
2945 size_t fsz, ssz;
2946 enum mandoc_esc esc;
2947
2948 p = buf->buf + pos;
2949
2950 if (*p == '\0') {
2951 mandoc_msg(MANDOCERR_REQ_EMPTY, r->parse, ln, ppos, "tr");
2952 return ROFF_IGN;
2953 }
2954
2955 while (*p != '\0') {
2956 fsz = ssz = 1;
2957
2958 first = p++;
2959 if (*first == '\\') {
2960 esc = mandoc_escape(&p, NULL, NULL);
2961 if (esc == ESCAPE_ERROR) {
2962 mandoc_msg(MANDOCERR_ESC_BAD, r->parse,
2963 ln, (int)(p - buf->buf), first);
2964 return ROFF_IGN;
2965 }
2966 fsz = (size_t)(p - first);
2967 }
2968
2969 second = p++;
2970 if (*second == '\\') {
2971 esc = mandoc_escape(&p, NULL, NULL);
2972 if (esc == ESCAPE_ERROR) {
2973 mandoc_msg(MANDOCERR_ESC_BAD, r->parse,
2974 ln, (int)(p - buf->buf), second);
2975 return ROFF_IGN;
2976 }
2977 ssz = (size_t)(p - second);
2978 } else if (*second == '\0') {
2979 mandoc_vmsg(MANDOCERR_TR_ODD, r->parse,
2980 ln, first - buf->buf, "tr %s", first);
2981 second = " ";
2982 p--;
2983 }
2984
2985 if (fsz > 1) {
2986 roff_setstrn(&r->xmbtab, first, fsz,
2987 second, ssz, 0);
2988 continue;
2989 }
2990
2991 if (r->xtab == NULL)
2992 r->xtab = mandoc_calloc(128,
2993 sizeof(struct roffstr));
2994
2995 free(r->xtab[(int)*first].p);
2996 r->xtab[(int)*first].p = mandoc_strndup(second, ssz);
2997 r->xtab[(int)*first].sz = ssz;
2998 }
2999
3000 return ROFF_IGN;
3001 }
3002
3003 static enum rofferr
3004 roff_so(ROFF_ARGS)
3005 {
3006 char *name, *cp;
3007
3008 name = buf->buf + pos;
3009 mandoc_vmsg(MANDOCERR_SO, r->parse, ln, ppos, "so %s", name);
3010
3011 /*
3012 * Handle `so'. Be EXTREMELY careful, as we shouldn't be
3013 * opening anything that's not in our cwd or anything beneath
3014 * it. Thus, explicitly disallow traversing up the file-system
3015 * or using absolute paths.
3016 */
3017
3018 if (*name == '/' || strstr(name, "../") || strstr(name, "/..")) {
3019 mandoc_vmsg(MANDOCERR_SO_PATH, r->parse, ln, ppos,
3020 ".so %s", name);
3021 buf->sz = mandoc_asprintf(&cp,
3022 ".sp\nSee the file %s.\n.sp", name) + 1;
3023 free(buf->buf);
3024 buf->buf = cp;
3025 *offs = 0;
3026 return ROFF_REPARSE;
3027 }
3028
3029 *offs = pos;
3030 return ROFF_SO;
3031 }
3032
3033 /* --- user defined strings and macros ------------------------------------ */
3034
3035 static enum rofferr
3036 roff_userdef(ROFF_ARGS)
3037 {
3038 const char *arg[9], *ap;
3039 char *cp, *n1, *n2;
3040 int i, ib, ie;
3041 size_t asz, rsz;
3042
3043 /*
3044 * Collect pointers to macro argument strings
3045 * and NUL-terminate them.
3046 */
3047
3048 r->argc = 0;
3049 cp = buf->buf + pos;
3050 for (i = 0; i < 9; i++) {
3051 if (*cp == '\0')
3052 arg[i] = "";
3053 else {
3054 arg[i] = mandoc_getarg(r->parse, &cp, ln, &pos);
3055 r->argc = i + 1;
3056 }
3057 }
3058
3059 /*
3060 * Expand macro arguments.
3061 */
3062
3063 buf->sz = strlen(r->current_string) + 1;
3064 n1 = cp = mandoc_malloc(buf->sz);
3065 memcpy(n1, r->current_string, buf->sz);
3066 while (*cp != '\0') {
3067
3068 /* Scan ahead for the next argument invocation. */
3069
3070 if (*cp++ != '\\')
3071 continue;
3072 if (*cp++ != '$')
3073 continue;
3074 if (*cp == '*') { /* \\$* inserts all arguments */
3075 ib = 0;
3076 ie = r->argc - 1;
3077 } else { /* \\$1 .. \\$9 insert one argument */
3078 ib = ie = *cp - '1';
3079 if (ib < 0 || ib > 8)
3080 continue;
3081 }
3082 cp -= 2;
3083
3084 /*
3085 * Determine the size of the expanded argument,
3086 * taking escaping of quotes into account.
3087 */
3088
3089 asz = ie > ib ? ie - ib : 0; /* for blanks */
3090 for (i = ib; i <= ie; i++) {
3091 for (ap = arg[i]; *ap != '\0'; ap++) {
3092 asz++;
3093 if (*ap == '"')
3094 asz += 3;
3095 }
3096 }
3097 if (asz != 3) {
3098
3099 /*
3100 * Determine the size of the rest of the
3101 * unexpanded macro, including the NUL.
3102 */
3103
3104 rsz = buf->sz - (cp - n1) - 3;
3105
3106 /*
3107 * When shrinking, move before
3108 * releasing the storage.
3109 */
3110
3111 if (asz < 3)
3112 memmove(cp + asz, cp + 3, rsz);
3113
3114 /*
3115 * Resize the storage for the macro
3116 * and readjust the parse pointer.
3117 */
3118
3119 buf->sz += asz - 3;
3120 n2 = mandoc_realloc(n1, buf->sz);
3121 cp = n2 + (cp - n1);
3122 n1 = n2;
3123
3124 /*
3125 * When growing, make room
3126 * for the expanded argument.
3127 */
3128
3129 if (asz > 3)
3130 memmove(cp + asz, cp + 3, rsz);
3131 }
3132
3133 /* Copy the expanded argument, escaping quotes. */
3134
3135 n2 = cp;
3136 for (i = ib; i <= ie; i++) {
3137 for (ap = arg[i]; *ap != '\0'; ap++) {
3138 if (*ap == '"') {
3139 memcpy(n2, "\\(dq", 4);
3140 n2 += 4;
3141 } else
3142 *n2++ = *ap;
3143 }
3144 if (i < ie)
3145 *n2++ = ' ';
3146 }
3147 }
3148
3149 /*
3150 * Replace the macro invocation
3151 * by the expanded macro.
3152 */
3153
3154 free(buf->buf);
3155 buf->buf = n1;
3156 *offs = 0;
3157
3158 return buf->sz > 1 && buf->buf[buf->sz - 2] == '\n' ?
3159 ROFF_REPARSE : ROFF_APPEND;
3160 }
3161
3162 static size_t
3163 roff_getname(struct roff *r, char **cpp, int ln, int pos)
3164 {
3165 char *name, *cp;
3166 size_t namesz;
3167
3168 name = *cpp;
3169 if ('\0' == *name)
3170 return 0;
3171
3172 /* Read until end of name and terminate it with NUL. */
3173 for (cp = name; 1; cp++) {
3174 if ('\0' == *cp || ' ' == *cp) {
3175 namesz = cp - name;
3176 break;
3177 }
3178 if ('\\' != *cp)
3179 continue;
3180 namesz = cp - name;
3181 if ('{' == cp[1] || '}' == cp[1])
3182 break;
3183 cp++;
3184 if ('\\' == *cp)
3185 continue;
3186 mandoc_vmsg(MANDOCERR_NAMESC, r->parse, ln, pos,
3187 "%.*s", (int)(cp - name + 1), name);
3188 mandoc_escape((const char **)&cp, NULL, NULL);
3189 break;
3190 }
3191
3192 /* Read past spaces. */
3193 while (' ' == *cp)
3194 cp++;
3195
3196 *cpp = cp;
3197 return namesz;
3198 }
3199
3200 /*
3201 * Store *string into the user-defined string called *name.
3202 * To clear an existing entry, call with (*r, *name, NULL, 0).
3203 * append == 0: replace mode
3204 * append == 1: single-line append mode
3205 * append == 2: multiline append mode, append '\n' after each call
3206 */
3207 static void
3208 roff_setstr(struct roff *r, const char *name, const char *string,
3209 int append)
3210 {
3211
3212 roff_setstrn(&r->strtab, name, strlen(name), string,
3213 string ? strlen(string) : 0, append);
3214 }
3215
3216 static void
3217 roff_setstrn(struct roffkv **r, const char *name, size_t namesz,
3218 const char *string, size_t stringsz, int append)
3219 {
3220 struct roffkv *n;
3221 char *c;
3222 int i;
3223 size_t oldch, newch;
3224
3225 /* Search for an existing string with the same name. */
3226 n = *r;
3227
3228 while (n && (namesz != n->key.sz ||
3229 strncmp(n->key.p, name, namesz)))
3230 n = n->next;
3231
3232 if (NULL == n) {
3233 /* Create a new string table entry. */
3234 n = mandoc_malloc(sizeof(struct roffkv));
3235 n->key.p = mandoc_strndup(name, namesz);
3236 n->key.sz = namesz;
3237 n->val.p = NULL;
3238 n->val.sz = 0;
3239 n->next = *r;
3240 *r = n;
3241 } else if (0 == append) {
3242 free(n->val.p);
3243 n->val.p = NULL;
3244 n->val.sz = 0;
3245 }
3246
3247 if (NULL == string)
3248 return;
3249
3250 /*
3251 * One additional byte for the '\n' in multiline mode,
3252 * and one for the terminating '\0'.
3253 */
3254 newch = stringsz + (1 < append ? 2u : 1u);
3255
3256 if (NULL == n->val.p) {
3257 n->val.p = mandoc_malloc(newch);
3258 *n->val.p = '\0';
3259 oldch = 0;
3260 } else {
3261 oldch = n->val.sz;
3262 n->val.p = mandoc_realloc(n->val.p, oldch + newch);
3263 }
3264
3265 /* Skip existing content in the destination buffer. */
3266 c = n->val.p + (int)oldch;
3267
3268 /* Append new content to the destination buffer. */
3269 i = 0;
3270 while (i < (int)stringsz) {
3271 /*
3272 * Rudimentary roff copy mode:
3273 * Handle escaped backslashes.
3274 */
3275 if ('\\' == string[i] && '\\' == string[i + 1])
3276 i++;
3277 *c++ = string[i++];
3278 }
3279
3280 /* Append terminating bytes. */
3281 if (1 < append)
3282 *c++ = '\n';
3283
3284 *c = '\0';
3285 n->val.sz = (int)(c - n->val.p);
3286 }
3287
3288 static const char *
3289 roff_getstrn(const struct roff *r, const char *name, size_t len)
3290 {
3291 const struct roffkv *n;
3292 int i;
3293
3294 for (n = r->strtab; n; n = n->next)
3295 if (0 == strncmp(name, n->key.p, len) &&
3296 '\0' == n->key.p[(int)len])
3297 return n->val.p;
3298
3299 for (i = 0; i < PREDEFS_MAX; i++)
3300 if (0 == strncmp(name, predefs[i].name, len) &&
3301 '\0' == predefs[i].name[(int)len])
3302 return predefs[i].str;
3303
3304 return NULL;
3305 }
3306
3307 static void
3308 roff_freestr(struct roffkv *r)
3309 {
3310 struct roffkv *n, *nn;
3311
3312 for (n = r; n; n = nn) {
3313 free(n->key.p);
3314 free(n->val.p);
3315 nn = n->next;
3316 free(n);
3317 }
3318 }
3319
3320 /* --- accessors and utility functions ------------------------------------ */
3321
3322 const struct tbl_span *
3323 roff_span(const struct roff *r)
3324 {
3325
3326 return r->tbl ? tbl_span(r->tbl) : NULL;
3327 }
3328
3329 const struct eqn *
3330 roff_eqn(const struct roff *r)
3331 {
3332
3333 return r->last_eqn ? &r->last_eqn->eqn : NULL;
3334 }
3335
3336 /*
3337 * Duplicate an input string, making the appropriate character
3338 * conversations (as stipulated by `tr') along the way.
3339 * Returns a heap-allocated string with all the replacements made.
3340 */
3341 char *
3342 roff_strdup(const struct roff *r, const char *p)
3343 {
3344 const struct roffkv *cp;
3345 char *res;
3346 const char *pp;
3347 size_t ssz, sz;
3348 enum mandoc_esc esc;
3349
3350 if (NULL == r->xmbtab && NULL == r->xtab)
3351 return mandoc_strdup(p);
3352 else if ('\0' == *p)
3353 return mandoc_strdup("");
3354
3355 /*
3356 * Step through each character looking for term matches
3357 * (remember that a `tr' can be invoked with an escape, which is
3358 * a glyph but the escape is multi-character).
3359 * We only do this if the character hash has been initialised
3360 * and the string is >0 length.
3361 */
3362
3363 res = NULL;
3364 ssz = 0;
3365
3366 while ('\0' != *p) {
3367 if ('\\' != *p && r->xtab && r->xtab[(int)*p].p) {
3368 sz = r->xtab[(int)*p].sz;
3369 res = mandoc_realloc(res, ssz + sz + 1);
3370 memcpy(res + ssz, r->xtab[(int)*p].p, sz);
3371 ssz += sz;
3372 p++;
3373 continue;
3374 } else if ('\\' != *p) {
3375 res = mandoc_realloc(res, ssz + 2);
3376 res[ssz++] = *p++;
3377 continue;
3378 }
3379
3380 /* Search for term matches. */
3381 for (cp = r->xmbtab; cp; cp = cp->next)
3382 if (0 == strncmp(p, cp->key.p, cp->key.sz))
3383 break;
3384
3385 if (NULL != cp) {
3386 /*
3387 * A match has been found.
3388 * Append the match to the array and move
3389 * forward by its keysize.
3390 */
3391 res = mandoc_realloc(res,
3392 ssz + cp->val.sz + 1);
3393 memcpy(res + ssz, cp->val.p, cp->val.sz);
3394 ssz += cp->val.sz;
3395 p += (int)cp->key.sz;
3396 continue;
3397 }
3398
3399 /*
3400 * Handle escapes carefully: we need to copy
3401 * over just the escape itself, or else we might
3402 * do replacements within the escape itself.
3403 * Make sure to pass along the bogus string.
3404 */
3405 pp = p++;
3406 esc = mandoc_escape(&p, NULL, NULL);
3407 if (ESCAPE_ERROR == esc) {
3408 sz = strlen(pp);
3409 res = mandoc_realloc(res, ssz + sz + 1);
3410 memcpy(res + ssz, pp, sz);
3411 break;
3412 }
3413 /*
3414 * We bail out on bad escapes.
3415 * No need to warn: we already did so when
3416 * roff_res() was called.
3417 */
3418 sz = (int)(p - pp);
3419 res = mandoc_realloc(res, ssz + sz + 1);
3420 memcpy(res + ssz, pp, sz);
3421 ssz += sz;
3422 }
3423
3424 res[(int)ssz] = '\0';
3425 return res;
3426 }
3427
3428 int
3429 roff_getformat(const struct roff *r)
3430 {
3431
3432 return r->format;
3433 }
3434
3435 /*
3436 * Find out whether a line is a macro line or not.
3437 * If it is, adjust the current position and return one; if it isn't,
3438 * return zero and don't change the current position.
3439 * If the control character has been set with `.cc', then let that grain
3440 * precedence.
3441 * This is slighly contrary to groff, where using the non-breaking
3442 * control character when `cc' has been invoked will cause the
3443 * non-breaking macro contents to be printed verbatim.
3444 */
3445 int
3446 roff_getcontrol(const struct roff *r, const char *cp, int *ppos)
3447 {
3448 int pos;
3449
3450 pos = *ppos;
3451
3452 if (0 != r->control && cp[pos] == r->control)
3453 pos++;
3454 else if (0 != r->control)
3455 return 0;
3456 else if ('\\' == cp[pos] && '.' == cp[pos + 1])
3457 pos += 2;
3458 else if ('.' == cp[pos] || '\'' == cp[pos])
3459 pos++;
3460 else
3461 return 0;
3462
3463 while (' ' == cp[pos] || '\t' == cp[pos])
3464 pos++;
3465
3466 *ppos = pos;
3467 return 1;
3468 }
unleashed repo fork