]> 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
If no output device was allocated because no file wanted to produce output,
[mandoc.git] / roff.c
1 /* $Id: roff.c,v 1.282 2015/10/21 23:51:11 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 n->parent->nchild++;
1028 man->last = n;
1029
1030 switch (n->type) {
1031 case ROFFT_HEAD:
1032 n->parent->head = n;
1033 break;
1034 case ROFFT_BODY:
1035 if (n->end != ENDBODY_NOT)
1036 return;
1037 n->parent->body = n;
1038 break;
1039 case ROFFT_TAIL:
1040 n->parent->tail = n;
1041 break;
1042 default:
1043 return;
1044 }
1045
1046 /*
1047 * Copy over the normalised-data pointer of our parent. Not
1048 * everybody has one, but copying a null pointer is fine.
1049 */
1050
1051 n->norm = n->parent->norm;
1052 assert(n->parent->type == ROFFT_BLOCK);
1053 }
1054
1055 void
1056 roff_word_alloc(struct roff_man *man, int line, int pos, const char *word)
1057 {
1058 struct roff_node *n;
1059
1060 n = roff_node_alloc(man, line, pos, ROFFT_TEXT, TOKEN_NONE);
1061 n->string = roff_strdup(man->roff, word);
1062 roff_node_append(man, n);
1063 if (man->macroset == MACROSET_MDOC)
1064 n->flags |= MDOC_VALID | MDOC_ENDED;
1065 else
1066 man_valid_post(man);
1067 man->next = ROFF_NEXT_SIBLING;
1068 }
1069
1070 void
1071 roff_word_append(struct roff_man *man, const char *word)
1072 {
1073 struct roff_node *n;
1074 char *addstr, *newstr;
1075
1076 n = man->last;
1077 addstr = roff_strdup(man->roff, word);
1078 mandoc_asprintf(&newstr, "%s %s", n->string, addstr);
1079 free(addstr);
1080 free(n->string);
1081 n->string = newstr;
1082 man->next = ROFF_NEXT_SIBLING;
1083 }
1084
1085 void
1086 roff_elem_alloc(struct roff_man *man, int line, int pos, int tok)
1087 {
1088 struct roff_node *n;
1089
1090 n = roff_node_alloc(man, line, pos, ROFFT_ELEM, tok);
1091 roff_node_append(man, n);
1092 man->next = ROFF_NEXT_CHILD;
1093 }
1094
1095 struct roff_node *
1096 roff_block_alloc(struct roff_man *man, int line, int pos, int tok)
1097 {
1098 struct roff_node *n;
1099
1100 n = roff_node_alloc(man, line, pos, ROFFT_BLOCK, tok);
1101 roff_node_append(man, n);
1102 man->next = ROFF_NEXT_CHILD;
1103 return n;
1104 }
1105
1106 struct roff_node *
1107 roff_head_alloc(struct roff_man *man, int line, int pos, int tok)
1108 {
1109 struct roff_node *n;
1110
1111 n = roff_node_alloc(man, line, pos, ROFFT_HEAD, tok);
1112 roff_node_append(man, n);
1113 man->next = ROFF_NEXT_CHILD;
1114 return n;
1115 }
1116
1117 struct roff_node *
1118 roff_body_alloc(struct roff_man *man, int line, int pos, int tok)
1119 {
1120 struct roff_node *n;
1121
1122 n = roff_node_alloc(man, line, pos, ROFFT_BODY, tok);
1123 roff_node_append(man, n);
1124 man->next = ROFF_NEXT_CHILD;
1125 return n;
1126 }
1127
1128 void
1129 roff_addeqn(struct roff_man *man, const struct eqn *eqn)
1130 {
1131 struct roff_node *n;
1132
1133 n = roff_node_alloc(man, eqn->ln, eqn->pos, ROFFT_EQN, TOKEN_NONE);
1134 n->eqn = eqn;
1135 if (eqn->ln > man->last->line)
1136 n->flags |= MDOC_LINE;
1137 roff_node_append(man, n);
1138 man->next = ROFF_NEXT_SIBLING;
1139 }
1140
1141 void
1142 roff_addtbl(struct roff_man *man, const struct tbl_span *tbl)
1143 {
1144 struct roff_node *n;
1145
1146 if (man->macroset == MACROSET_MAN)
1147 man_breakscope(man, TOKEN_NONE);
1148 n = roff_node_alloc(man, tbl->line, 0, ROFFT_TBL, TOKEN_NONE);
1149 n->span = tbl;
1150 roff_node_append(man, n);
1151 if (man->macroset == MACROSET_MDOC)
1152 n->flags |= MDOC_VALID | MDOC_ENDED;
1153 else
1154 man_valid_post(man);
1155 man->next = ROFF_NEXT_SIBLING;
1156 }
1157
1158 void
1159 roff_node_unlink(struct roff_man *man, struct roff_node *n)
1160 {
1161
1162 /* Adjust siblings. */
1163
1164 if (n->prev)
1165 n->prev->next = n->next;
1166 if (n->next)
1167 n->next->prev = n->prev;
1168
1169 /* Adjust parent. */
1170
1171 if (n->parent != NULL) {
1172 n->parent->nchild--;
1173 if (n->parent->child == n)
1174 n->parent->child = n->next;
1175 if (n->parent->last == n)
1176 n->parent->last = n->prev;
1177 }
1178
1179 /* Adjust parse point. */
1180
1181 if (man == NULL)
1182 return;
1183 if (man->last == n) {
1184 if (n->prev == NULL) {
1185 man->last = n->parent;
1186 man->next = ROFF_NEXT_CHILD;
1187 } else {
1188 man->last = n->prev;
1189 man->next = ROFF_NEXT_SIBLING;
1190 }
1191 }
1192 if (man->first == n)
1193 man->first = NULL;
1194 }
1195
1196 void
1197 roff_node_free(struct roff_node *n)
1198 {
1199
1200 if (n->args != NULL)
1201 mdoc_argv_free(n->args);
1202 if (n->type == ROFFT_BLOCK || n->type == ROFFT_ELEM)
1203 free(n->norm);
1204 free(n->string);
1205 free(n);
1206 }
1207
1208 void
1209 roff_node_delete(struct roff_man *man, struct roff_node *n)
1210 {
1211
1212 while (n->child != NULL)
1213 roff_node_delete(man, n->child);
1214 assert(n->nchild == 0);
1215 roff_node_unlink(man, n);
1216 roff_node_free(n);
1217 }
1218
1219 void
1220 deroff(char **dest, const struct roff_node *n)
1221 {
1222 char *cp;
1223 size_t sz;
1224
1225 if (n->type != ROFFT_TEXT) {
1226 for (n = n->child; n != NULL; n = n->next)
1227 deroff(dest, n);
1228 return;
1229 }
1230
1231 /* Skip leading whitespace and escape sequences. */
1232
1233 cp = n->string;
1234 while (*cp != '\0') {
1235 if ('\\' == *cp) {
1236 cp++;
1237 mandoc_escape((const char **)&cp, NULL, NULL);
1238 } else if (isspace((unsigned char)*cp))
1239 cp++;
1240 else
1241 break;
1242 }
1243
1244 /* Skip trailing whitespace. */
1245
1246 for (sz = strlen(cp); sz; sz--)
1247 if ( ! isspace((unsigned char)cp[sz-1]))
1248 break;
1249
1250 /* Skip empty strings. */
1251
1252 if (sz == 0)
1253 return;
1254
1255 if (*dest == NULL) {
1256 *dest = mandoc_strndup(cp, sz);
1257 return;
1258 }
1259
1260 mandoc_asprintf(&cp, "%s %*s", *dest, (int)sz, cp);
1261 free(*dest);
1262 *dest = cp;
1263 }
1264
1265 /* --- main functions of the roff parser ---------------------------------- */
1266
1267 /*
1268 * In the current line, expand escape sequences that tend to get
1269 * used in numerical expressions and conditional requests.
1270 * Also check the syntax of the remaining escape sequences.
1271 */
1272 static enum rofferr
1273 roff_res(struct roff *r, struct buf *buf, int ln, int pos)
1274 {
1275 char ubuf[24]; /* buffer to print the number */
1276 const char *start; /* start of the string to process */
1277 char *stesc; /* start of an escape sequence ('\\') */
1278 const char *stnam; /* start of the name, after "[(*" */
1279 const char *cp; /* end of the name, e.g. before ']' */
1280 const char *res; /* the string to be substituted */
1281 char *nbuf; /* new buffer to copy buf->buf to */
1282 size_t maxl; /* expected length of the escape name */
1283 size_t naml; /* actual length of the escape name */
1284 enum mandoc_esc esc; /* type of the escape sequence */
1285 int inaml; /* length returned from mandoc_escape() */
1286 int expand_count; /* to avoid infinite loops */
1287 int npos; /* position in numeric expression */
1288 int arg_complete; /* argument not interrupted by eol */
1289 char term; /* character terminating the escape */
1290
1291 expand_count = 0;
1292 start = buf->buf + pos;
1293 stesc = strchr(start, '\0') - 1;
1294 while (stesc-- > start) {
1295
1296 /* Search backwards for the next backslash. */
1297
1298 if (*stesc != '\\')
1299 continue;
1300
1301 /* If it is escaped, skip it. */
1302
1303 for (cp = stesc - 1; cp >= start; cp--)
1304 if (*cp != '\\')
1305 break;
1306
1307 if ((stesc - cp) % 2 == 0) {
1308 stesc = (char *)cp;
1309 continue;
1310 }
1311
1312 /* Decide whether to expand or to check only. */
1313
1314 term = '\0';
1315 cp = stesc + 1;
1316 switch (*cp) {
1317 case '*':
1318 res = NULL;
1319 break;
1320 case 'B':
1321 case 'w':
1322 term = cp[1];
1323 /* FALLTHROUGH */
1324 case 'n':
1325 res = ubuf;
1326 break;
1327 default:
1328 esc = mandoc_escape(&cp, &stnam, &inaml);
1329 if (esc == ESCAPE_ERROR ||
1330 (esc == ESCAPE_SPECIAL &&
1331 mchars_spec2cp(stnam, inaml) < 0))
1332 mandoc_vmsg(MANDOCERR_ESC_BAD,
1333 r->parse, ln, (int)(stesc - buf->buf),
1334 "%.*s", (int)(cp - stesc), stesc);
1335 continue;
1336 }
1337
1338 if (EXPAND_LIMIT < ++expand_count) {
1339 mandoc_msg(MANDOCERR_ROFFLOOP, r->parse,
1340 ln, (int)(stesc - buf->buf), NULL);
1341 return ROFF_IGN;
1342 }
1343
1344 /*
1345 * The third character decides the length
1346 * of the name of the string or register.
1347 * Save a pointer to the name.
1348 */
1349
1350 if (term == '\0') {
1351 switch (*++cp) {
1352 case '\0':
1353 maxl = 0;
1354 break;
1355 case '(':
1356 cp++;
1357 maxl = 2;
1358 break;
1359 case '[':
1360 cp++;
1361 term = ']';
1362 maxl = 0;
1363 break;
1364 default:
1365 maxl = 1;
1366 break;
1367 }
1368 } else {
1369 cp += 2;
1370 maxl = 0;
1371 }
1372 stnam = cp;
1373
1374 /* Advance to the end of the name. */
1375
1376 naml = 0;
1377 arg_complete = 1;
1378 while (maxl == 0 || naml < maxl) {
1379 if (*cp == '\0') {
1380 mandoc_msg(MANDOCERR_ESC_BAD, r->parse,
1381 ln, (int)(stesc - buf->buf), stesc);
1382 arg_complete = 0;
1383 break;
1384 }
1385 if (maxl == 0 && *cp == term) {
1386 cp++;
1387 break;
1388 }
1389 if (*cp++ != '\\' || stesc[1] != 'w') {
1390 naml++;
1391 continue;
1392 }
1393 switch (mandoc_escape(&cp, NULL, NULL)) {
1394 case ESCAPE_SPECIAL:
1395 case ESCAPE_UNICODE:
1396 case ESCAPE_NUMBERED:
1397 case ESCAPE_OVERSTRIKE:
1398 naml++;
1399 break;
1400 default:
1401 break;
1402 }
1403 }
1404
1405 /*
1406 * Retrieve the replacement string; if it is
1407 * undefined, resume searching for escapes.
1408 */
1409
1410 switch (stesc[1]) {
1411 case '*':
1412 if (arg_complete)
1413 res = roff_getstrn(r, stnam, naml);
1414 break;
1415 case 'B':
1416 npos = 0;
1417 ubuf[0] = arg_complete &&
1418 roff_evalnum(r, ln, stnam, &npos,
1419 NULL, ROFFNUM_SCALE) &&
1420 stnam + npos + 1 == cp ? '1' : '0';
1421 ubuf[1] = '\0';
1422 break;
1423 case 'n':
1424 if (arg_complete)
1425 (void)snprintf(ubuf, sizeof(ubuf), "%d",
1426 roff_getregn(r, stnam, naml));
1427 else
1428 ubuf[0] = '\0';
1429 break;
1430 case 'w':
1431 /* use even incomplete args */
1432 (void)snprintf(ubuf, sizeof(ubuf), "%d",
1433 24 * (int)naml);
1434 break;
1435 }
1436
1437 if (res == NULL) {
1438 mandoc_vmsg(MANDOCERR_STR_UNDEF,
1439 r->parse, ln, (int)(stesc - buf->buf),
1440 "%.*s", (int)naml, stnam);
1441 res = "";
1442 } else if (buf->sz + strlen(res) > SHRT_MAX) {
1443 mandoc_msg(MANDOCERR_ROFFLOOP, r->parse,
1444 ln, (int)(stesc - buf->buf), NULL);
1445 return ROFF_IGN;
1446 }
1447
1448 /* Replace the escape sequence by the string. */
1449
1450 *stesc = '\0';
1451 buf->sz = mandoc_asprintf(&nbuf, "%s%s%s",
1452 buf->buf, res, cp) + 1;
1453
1454 /* Prepare for the next replacement. */
1455
1456 start = nbuf + pos;
1457 stesc = nbuf + (stesc - buf->buf) + strlen(res);
1458 free(buf->buf);
1459 buf->buf = nbuf;
1460 }
1461 return ROFF_CONT;
1462 }
1463
1464 /*
1465 * Process text streams.
1466 */
1467 static enum rofferr
1468 roff_parsetext(struct buf *buf, int pos, int *offs)
1469 {
1470 size_t sz;
1471 const char *start;
1472 char *p;
1473 int isz;
1474 enum mandoc_esc esc;
1475
1476 /* Spring the input line trap. */
1477
1478 if (roffit_lines == 1) {
1479 isz = mandoc_asprintf(&p, "%s\n.%s", buf->buf, roffit_macro);
1480 free(buf->buf);
1481 buf->buf = p;
1482 buf->sz = isz + 1;
1483 *offs = 0;
1484 free(roffit_macro);
1485 roffit_lines = 0;
1486 return ROFF_REPARSE;
1487 } else if (roffit_lines > 1)
1488 --roffit_lines;
1489
1490 /* Convert all breakable hyphens into ASCII_HYPH. */
1491
1492 start = p = buf->buf + pos;
1493
1494 while (*p != '\0') {
1495 sz = strcspn(p, "-\\");
1496 p += sz;
1497
1498 if (*p == '\0')
1499 break;
1500
1501 if (*p == '\\') {
1502 /* Skip over escapes. */
1503 p++;
1504 esc = mandoc_escape((const char **)&p, NULL, NULL);
1505 if (esc == ESCAPE_ERROR)
1506 break;
1507 while (*p == '-')
1508 p++;
1509 continue;
1510 } else if (p == start) {
1511 p++;
1512 continue;
1513 }
1514
1515 if (isalpha((unsigned char)p[-1]) &&
1516 isalpha((unsigned char)p[1]))
1517 *p = ASCII_HYPH;
1518 p++;
1519 }
1520 return ROFF_CONT;
1521 }
1522
1523 enum rofferr
1524 roff_parseln(struct roff *r, int ln, struct buf *buf, int *offs)
1525 {
1526 enum rofft t;
1527 enum rofferr e;
1528 int pos; /* parse point */
1529 int spos; /* saved parse point for messages */
1530 int ppos; /* original offset in buf->buf */
1531 int ctl; /* macro line (boolean) */
1532
1533 ppos = pos = *offs;
1534
1535 /* Handle in-line equation delimiters. */
1536
1537 if (r->tbl == NULL &&
1538 r->last_eqn != NULL && r->last_eqn->delim &&
1539 (r->eqn == NULL || r->eqn_inline)) {
1540 e = roff_eqndelim(r, buf, pos);
1541 if (e == ROFF_REPARSE)
1542 return e;
1543 assert(e == ROFF_CONT);
1544 }
1545
1546 /* Expand some escape sequences. */
1547
1548 e = roff_res(r, buf, ln, pos);
1549 if (e == ROFF_IGN)
1550 return e;
1551 assert(e == ROFF_CONT);
1552
1553 ctl = roff_getcontrol(r, buf->buf, &pos);
1554
1555 /*
1556 * First, if a scope is open and we're not a macro, pass the
1557 * text through the macro's filter.
1558 * Equations process all content themselves.
1559 * Tables process almost all content themselves, but we want
1560 * to warn about macros before passing it there.
1561 */
1562
1563 if (r->last != NULL && ! ctl) {
1564 t = r->last->tok;
1565 assert(roffs[t].text);
1566 e = (*roffs[t].text)(r, t, buf, ln, pos, pos, offs);
1567 assert(e == ROFF_IGN || e == ROFF_CONT);
1568 if (e != ROFF_CONT)
1569 return e;
1570 }
1571 if (r->eqn != NULL)
1572 return eqn_read(&r->eqn, ln, buf->buf, ppos, offs);
1573 if (r->tbl != NULL && ( ! ctl || buf->buf[pos] == '\0'))
1574 return tbl_read(r->tbl, ln, buf->buf, ppos);
1575 if ( ! ctl)
1576 return roff_parsetext(buf, pos, offs);
1577
1578 /* Skip empty request lines. */
1579
1580 if (buf->buf[pos] == '"') {
1581 mandoc_msg(MANDOCERR_COMMENT_BAD, r->parse,
1582 ln, pos, NULL);
1583 return ROFF_IGN;
1584 } else if (buf->buf[pos] == '\0')
1585 return ROFF_IGN;
1586
1587 /*
1588 * If a scope is open, go to the child handler for that macro,
1589 * as it may want to preprocess before doing anything with it.
1590 * Don't do so if an equation is open.
1591 */
1592
1593 if (r->last) {
1594 t = r->last->tok;
1595 assert(roffs[t].sub);
1596 return (*roffs[t].sub)(r, t, buf, ln, ppos, pos, offs);
1597 }
1598
1599 /* No scope is open. This is a new request or macro. */
1600
1601 spos = pos;
1602 t = roff_parse(r, buf->buf, &pos, ln, ppos);
1603
1604 /* Tables ignore most macros. */
1605
1606 if (r->tbl != NULL && (t == ROFF_MAX || t == ROFF_TS)) {
1607 mandoc_msg(MANDOCERR_TBLMACRO, r->parse,
1608 ln, pos, buf->buf + spos);
1609 if (t == ROFF_TS)
1610 return ROFF_IGN;
1611 while (buf->buf[pos] != '\0' && buf->buf[pos] != ' ')
1612 pos++;
1613 while (buf->buf[pos] != '\0' && buf->buf[pos] == ' ')
1614 pos++;
1615 return tbl_read(r->tbl, ln, buf->buf, pos);
1616 }
1617
1618 /*
1619 * This is neither a roff request nor a user-defined macro.
1620 * Let the standard macro set parsers handle it.
1621 */
1622
1623 if (t == ROFF_MAX)
1624 return ROFF_CONT;
1625
1626 /* Execute a roff request or a user defined macro. */
1627
1628 assert(roffs[t].proc);
1629 return (*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs);
1630 }
1631
1632 void
1633 roff_endparse(struct roff *r)
1634 {
1635
1636 if (r->last)
1637 mandoc_msg(MANDOCERR_BLK_NOEND, r->parse,
1638 r->last->line, r->last->col,
1639 roffs[r->last->tok].name);
1640
1641 if (r->eqn) {
1642 mandoc_msg(MANDOCERR_BLK_NOEND, r->parse,
1643 r->eqn->eqn.ln, r->eqn->eqn.pos, "EQ");
1644 eqn_end(&r->eqn);
1645 }
1646
1647 if (r->tbl) {
1648 mandoc_msg(MANDOCERR_BLK_NOEND, r->parse,
1649 r->tbl->line, r->tbl->pos, "TS");
1650 tbl_end(&r->tbl);
1651 }
1652 }
1653
1654 /*
1655 * Parse a roff node's type from the input buffer. This must be in the
1656 * form of ".foo xxx" in the usual way.
1657 */
1658 static enum rofft
1659 roff_parse(struct roff *r, char *buf, int *pos, int ln, int ppos)
1660 {
1661 char *cp;
1662 const char *mac;
1663 size_t maclen;
1664 enum rofft t;
1665
1666 cp = buf + *pos;
1667
1668 if ('\0' == *cp || '"' == *cp || '\t' == *cp || ' ' == *cp)
1669 return ROFF_MAX;
1670
1671 mac = cp;
1672 maclen = roff_getname(r, &cp, ln, ppos);
1673
1674 t = (r->current_string = roff_getstrn(r, mac, maclen))
1675 ? ROFF_USERDEF : roffhash_find(mac, maclen);
1676
1677 if (ROFF_MAX != t)
1678 *pos = cp - buf;
1679
1680 return t;
1681 }
1682
1683 /* --- handling of request blocks ----------------------------------------- */
1684
1685 static enum rofferr
1686 roff_cblock(ROFF_ARGS)
1687 {
1688
1689 /*
1690 * A block-close `..' should only be invoked as a child of an
1691 * ignore macro, otherwise raise a warning and just ignore it.
1692 */
1693
1694 if (r->last == NULL) {
1695 mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse,
1696 ln, ppos, "..");
1697 return ROFF_IGN;
1698 }
1699
1700 switch (r->last->tok) {
1701 case ROFF_am:
1702 /* ROFF_am1 is remapped to ROFF_am in roff_block(). */
1703 case ROFF_ami:
1704 case ROFF_de:
1705 /* ROFF_de1 is remapped to ROFF_de in roff_block(). */
1706 case ROFF_dei:
1707 case ROFF_ig:
1708 break;
1709 default:
1710 mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse,
1711 ln, ppos, "..");
1712 return ROFF_IGN;
1713 }
1714
1715 if (buf->buf[pos] != '\0')
1716 mandoc_vmsg(MANDOCERR_ARG_SKIP, r->parse, ln, pos,
1717 ".. %s", buf->buf + pos);
1718
1719 roffnode_pop(r);
1720 roffnode_cleanscope(r);
1721 return ROFF_IGN;
1722
1723 }
1724
1725 static void
1726 roffnode_cleanscope(struct roff *r)
1727 {
1728
1729 while (r->last) {
1730 if (--r->last->endspan != 0)
1731 break;
1732 roffnode_pop(r);
1733 }
1734 }
1735
1736 static void
1737 roff_ccond(struct roff *r, int ln, int ppos)
1738 {
1739
1740 if (NULL == r->last) {
1741 mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse,
1742 ln, ppos, "\\}");
1743 return;
1744 }
1745
1746 switch (r->last->tok) {
1747 case ROFF_el:
1748 case ROFF_ie:
1749 case ROFF_if:
1750 break;
1751 default:
1752 mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse,
1753 ln, ppos, "\\}");
1754 return;
1755 }
1756
1757 if (r->last->endspan > -1) {
1758 mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse,
1759 ln, ppos, "\\}");
1760 return;
1761 }
1762
1763 roffnode_pop(r);
1764 roffnode_cleanscope(r);
1765 return;
1766 }
1767
1768 static enum rofferr
1769 roff_block(ROFF_ARGS)
1770 {
1771 const char *name;
1772 char *iname, *cp;
1773 size_t namesz;
1774
1775 /* Ignore groff compatibility mode for now. */
1776
1777 if (tok == ROFF_de1)
1778 tok = ROFF_de;
1779 else if (tok == ROFF_dei1)
1780 tok = ROFF_dei;
1781 else if (tok == ROFF_am1)
1782 tok = ROFF_am;
1783 else if (tok == ROFF_ami1)
1784 tok = ROFF_ami;
1785
1786 /* Parse the macro name argument. */
1787
1788 cp = buf->buf + pos;
1789 if (tok == ROFF_ig) {
1790 iname = NULL;
1791 namesz = 0;
1792 } else {
1793 iname = cp;
1794 namesz = roff_getname(r, &cp, ln, ppos);
1795 iname[namesz] = '\0';
1796 }
1797
1798 /* Resolve the macro name argument if it is indirect. */
1799
1800 if (namesz && (tok == ROFF_dei || tok == ROFF_ami)) {
1801 if ((name = roff_getstrn(r, iname, namesz)) == NULL) {
1802 mandoc_vmsg(MANDOCERR_STR_UNDEF,
1803 r->parse, ln, (int)(iname - buf->buf),
1804 "%.*s", (int)namesz, iname);
1805 namesz = 0;
1806 } else
1807 namesz = strlen(name);
1808 } else
1809 name = iname;
1810
1811 if (namesz == 0 && tok != ROFF_ig) {
1812 mandoc_msg(MANDOCERR_REQ_EMPTY, r->parse,
1813 ln, ppos, roffs[tok].name);
1814 return ROFF_IGN;
1815 }
1816
1817 roffnode_push(r, tok, name, ln, ppos);
1818
1819 /*
1820 * At the beginning of a `de' macro, clear the existing string
1821 * with the same name, if there is one. New content will be
1822 * appended from roff_block_text() in multiline mode.
1823 */
1824
1825 if (tok == ROFF_de || tok == ROFF_dei)
1826 roff_setstrn(&r->strtab, name, namesz, "", 0, 0);
1827
1828 if (*cp == '\0')
1829 return ROFF_IGN;
1830
1831 /* Get the custom end marker. */
1832
1833 iname = cp;
1834 namesz = roff_getname(r, &cp, ln, ppos);
1835
1836 /* Resolve the end marker if it is indirect. */
1837
1838 if (namesz && (tok == ROFF_dei || tok == ROFF_ami)) {
1839 if ((name = roff_getstrn(r, iname, namesz)) == NULL) {
1840 mandoc_vmsg(MANDOCERR_STR_UNDEF,
1841 r->parse, ln, (int)(iname - buf->buf),
1842 "%.*s", (int)namesz, iname);
1843 namesz = 0;
1844 } else
1845 namesz = strlen(name);
1846 } else
1847 name = iname;
1848
1849 if (namesz)
1850 r->last->end = mandoc_strndup(name, namesz);
1851
1852 if (*cp != '\0')
1853 mandoc_vmsg(MANDOCERR_ARG_EXCESS, r->parse,
1854 ln, pos, ".%s ... %s", roffs[tok].name, cp);
1855
1856 return ROFF_IGN;
1857 }
1858
1859 static enum rofferr
1860 roff_block_sub(ROFF_ARGS)
1861 {
1862 enum rofft t;
1863 int i, j;
1864
1865 /*
1866 * First check whether a custom macro exists at this level. If
1867 * it does, then check against it. This is some of groff's
1868 * stranger behaviours. If we encountered a custom end-scope
1869 * tag and that tag also happens to be a "real" macro, then we
1870 * need to try interpreting it again as a real macro. If it's
1871 * not, then return ignore. Else continue.
1872 */
1873
1874 if (r->last->end) {
1875 for (i = pos, j = 0; r->last->end[j]; j++, i++)
1876 if (buf->buf[i] != r->last->end[j])
1877 break;
1878
1879 if (r->last->end[j] == '\0' &&
1880 (buf->buf[i] == '\0' ||
1881 buf->buf[i] == ' ' ||
1882 buf->buf[i] == '\t')) {
1883 roffnode_pop(r);
1884 roffnode_cleanscope(r);
1885
1886 while (buf->buf[i] == ' ' || buf->buf[i] == '\t')
1887 i++;
1888
1889 pos = i;
1890 if (roff_parse(r, buf->buf, &pos, ln, ppos) !=
1891 ROFF_MAX)
1892 return ROFF_RERUN;
1893 return ROFF_IGN;
1894 }
1895 }
1896
1897 /*
1898 * If we have no custom end-query or lookup failed, then try
1899 * pulling it out of the hashtable.
1900 */
1901
1902 t = roff_parse(r, buf->buf, &pos, ln, ppos);
1903
1904 if (t != ROFF_cblock) {
1905 if (tok != ROFF_ig)
1906 roff_setstr(r, r->last->name, buf->buf + ppos, 2);
1907 return ROFF_IGN;
1908 }
1909
1910 assert(roffs[t].proc);
1911 return (*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs);
1912 }
1913
1914 static enum rofferr
1915 roff_block_text(ROFF_ARGS)
1916 {
1917
1918 if (tok != ROFF_ig)
1919 roff_setstr(r, r->last->name, buf->buf + pos, 2);
1920
1921 return ROFF_IGN;
1922 }
1923
1924 static enum rofferr
1925 roff_cond_sub(ROFF_ARGS)
1926 {
1927 enum rofft t;
1928 char *ep;
1929 int rr;
1930
1931 rr = r->last->rule;
1932 roffnode_cleanscope(r);
1933 t = roff_parse(r, buf->buf, &pos, ln, ppos);
1934
1935 /*
1936 * Fully handle known macros when they are structurally
1937 * required or when the conditional evaluated to true.
1938 */
1939
1940 if ((t != ROFF_MAX) &&
1941 (rr || roffs[t].flags & ROFFMAC_STRUCT)) {
1942 assert(roffs[t].proc);
1943 return (*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs);
1944 }
1945
1946 /*
1947 * If `\}' occurs on a macro line without a preceding macro,
1948 * drop the line completely.
1949 */
1950
1951 ep = buf->buf + pos;
1952 if (ep[0] == '\\' && ep[1] == '}')
1953 rr = 0;
1954
1955 /* Always check for the closing delimiter `\}'. */
1956
1957 while ((ep = strchr(ep, '\\')) != NULL) {
1958 if (*(++ep) == '}') {
1959 *ep = '&';
1960 roff_ccond(r, ln, ep - buf->buf - 1);
1961 }
1962 if (*ep != '\0')
1963 ++ep;
1964 }
1965 return rr ? ROFF_CONT : ROFF_IGN;
1966 }
1967
1968 static enum rofferr
1969 roff_cond_text(ROFF_ARGS)
1970 {
1971 char *ep;
1972 int rr;
1973
1974 rr = r->last->rule;
1975 roffnode_cleanscope(r);
1976
1977 ep = buf->buf + pos;
1978 while ((ep = strchr(ep, '\\')) != NULL) {
1979 if (*(++ep) == '}') {
1980 *ep = '&';
1981 roff_ccond(r, ln, ep - buf->buf - 1);
1982 }
1983 if (*ep != '\0')
1984 ++ep;
1985 }
1986 return rr ? ROFF_CONT : ROFF_IGN;
1987 }
1988
1989 /* --- handling of numeric and conditional expressions -------------------- */
1990
1991 /*
1992 * Parse a single signed integer number. Stop at the first non-digit.
1993 * If there is at least one digit, return success and advance the
1994 * parse point, else return failure and let the parse point unchanged.
1995 * Ignore overflows, treat them just like the C language.
1996 */
1997 static int
1998 roff_getnum(const char *v, int *pos, int *res, int flags)
1999 {
2000 int myres, scaled, n, p;
2001
2002 if (NULL == res)
2003 res = &myres;
2004
2005 p = *pos;
2006 n = v[p] == '-';
2007 if (n || v[p] == '+')
2008 p++;
2009
2010 if (flags & ROFFNUM_WHITE)
2011 while (isspace((unsigned char)v[p]))
2012 p++;
2013
2014 for (*res = 0; isdigit((unsigned char)v[p]); p++)
2015 *res = 10 * *res + v[p] - '0';
2016 if (p == *pos + n)
2017 return 0;
2018
2019 if (n)
2020 *res = -*res;
2021
2022 /* Each number may be followed by one optional scaling unit. */
2023
2024 switch (v[p]) {
2025 case 'f':
2026 scaled = *res * 65536;
2027 break;
2028 case 'i':
2029 scaled = *res * 240;
2030 break;
2031 case 'c':
2032 scaled = *res * 240 / 2.54;
2033 break;
2034 case 'v':
2035 case 'P':
2036 scaled = *res * 40;
2037 break;
2038 case 'm':
2039 case 'n':
2040 scaled = *res * 24;
2041 break;
2042 case 'p':
2043 scaled = *res * 10 / 3;
2044 break;
2045 case 'u':
2046 scaled = *res;
2047 break;
2048 case 'M':
2049 scaled = *res * 6 / 25;
2050 break;
2051 default:
2052 scaled = *res;
2053 p--;
2054 break;
2055 }
2056 if (flags & ROFFNUM_SCALE)
2057 *res = scaled;
2058
2059 *pos = p + 1;
2060 return 1;
2061 }
2062
2063 /*
2064 * Evaluate a string comparison condition.
2065 * The first character is the delimiter.
2066 * Succeed if the string up to its second occurrence
2067 * matches the string up to its third occurence.
2068 * Advance the cursor after the third occurrence
2069 * or lacking that, to the end of the line.
2070 */
2071 static int
2072 roff_evalstrcond(const char *v, int *pos)
2073 {
2074 const char *s1, *s2, *s3;
2075 int match;
2076
2077 match = 0;
2078 s1 = v + *pos; /* initial delimiter */
2079 s2 = s1 + 1; /* for scanning the first string */
2080 s3 = strchr(s2, *s1); /* for scanning the second string */
2081
2082 if (NULL == s3) /* found no middle delimiter */
2083 goto out;
2084
2085 while ('\0' != *++s3) {
2086 if (*s2 != *s3) { /* mismatch */
2087 s3 = strchr(s3, *s1);
2088 break;
2089 }
2090 if (*s3 == *s1) { /* found the final delimiter */
2091 match = 1;
2092 break;
2093 }
2094 s2++;
2095 }
2096
2097 out:
2098 if (NULL == s3)
2099 s3 = strchr(s2, '\0');
2100 else if (*s3 != '\0')
2101 s3++;
2102 *pos = s3 - v;
2103 return match;
2104 }
2105
2106 /*
2107 * Evaluate an optionally negated single character, numerical,
2108 * or string condition.
2109 */
2110 static int
2111 roff_evalcond(struct roff *r, int ln, char *v, int *pos)
2112 {
2113 char *cp, *name;
2114 size_t sz;
2115 int number, savepos, wanttrue;
2116
2117 if ('!' == v[*pos]) {
2118 wanttrue = 0;
2119 (*pos)++;
2120 } else
2121 wanttrue = 1;
2122
2123 switch (v[*pos]) {
2124 case '\0':
2125 return 0;
2126 case 'n':
2127 case 'o':
2128 (*pos)++;
2129 return wanttrue;
2130 case 'c':
2131 case 'd':
2132 case 'e':
2133 case 't':
2134 case 'v':
2135 (*pos)++;
2136 return !wanttrue;
2137 case 'r':
2138 cp = name = v + ++*pos;
2139 sz = roff_getname(r, &cp, ln, *pos);
2140 *pos = cp - v;
2141 return (sz && roff_hasregn(r, name, sz)) == wanttrue;
2142 default:
2143 break;
2144 }
2145
2146 savepos = *pos;
2147 if (roff_evalnum(r, ln, v, pos, &number, ROFFNUM_SCALE))
2148 return (number > 0) == wanttrue;
2149 else if (*pos == savepos)
2150 return roff_evalstrcond(v, pos) == wanttrue;
2151 else
2152 return 0;
2153 }
2154
2155 static enum rofferr
2156 roff_line_ignore(ROFF_ARGS)
2157 {
2158
2159 return ROFF_IGN;
2160 }
2161
2162 static enum rofferr
2163 roff_insec(ROFF_ARGS)
2164 {
2165
2166 mandoc_msg(MANDOCERR_REQ_INSEC, r->parse,
2167 ln, ppos, roffs[tok].name);
2168 return ROFF_IGN;
2169 }
2170
2171 static enum rofferr
2172 roff_unsupp(ROFF_ARGS)
2173 {
2174
2175 mandoc_msg(MANDOCERR_REQ_UNSUPP, r->parse,
2176 ln, ppos, roffs[tok].name);
2177 return ROFF_IGN;
2178 }
2179
2180 static enum rofferr
2181 roff_cond(ROFF_ARGS)
2182 {
2183
2184 roffnode_push(r, tok, NULL, ln, ppos);
2185
2186 /*
2187 * An `.el' has no conditional body: it will consume the value
2188 * of the current rstack entry set in prior `ie' calls or
2189 * defaults to DENY.
2190 *
2191 * If we're not an `el', however, then evaluate the conditional.
2192 */
2193
2194 r->last->rule = tok == ROFF_el ?
2195 (r->rstackpos < 0 ? 0 : r->rstack[r->rstackpos--]) :
2196 roff_evalcond(r, ln, buf->buf, &pos);
2197
2198 /*
2199 * An if-else will put the NEGATION of the current evaluated
2200 * conditional into the stack of rules.
2201 */
2202
2203 if (tok == ROFF_ie) {
2204 if (r->rstackpos + 1 == r->rstacksz) {
2205 r->rstacksz += 16;
2206 r->rstack = mandoc_reallocarray(r->rstack,
2207 r->rstacksz, sizeof(int));
2208 }
2209 r->rstack[++r->rstackpos] = !r->last->rule;
2210 }
2211
2212 /* If the parent has false as its rule, then so do we. */
2213
2214 if (r->last->parent && !r->last->parent->rule)
2215 r->last->rule = 0;
2216
2217 /*
2218 * Determine scope.
2219 * If there is nothing on the line after the conditional,
2220 * not even whitespace, use next-line scope.
2221 */
2222
2223 if (buf->buf[pos] == '\0') {
2224 r->last->endspan = 2;
2225 goto out;
2226 }
2227
2228 while (buf->buf[pos] == ' ')
2229 pos++;
2230
2231 /* An opening brace requests multiline scope. */
2232
2233 if (buf->buf[pos] == '\\' && buf->buf[pos + 1] == '{') {
2234 r->last->endspan = -1;
2235 pos += 2;
2236 while (buf->buf[pos] == ' ')
2237 pos++;
2238 goto out;
2239 }
2240
2241 /*
2242 * Anything else following the conditional causes
2243 * single-line scope. Warn if the scope contains
2244 * nothing but trailing whitespace.
2245 */
2246
2247 if (buf->buf[pos] == '\0')
2248 mandoc_msg(MANDOCERR_COND_EMPTY, r->parse,
2249 ln, ppos, roffs[tok].name);
2250
2251 r->last->endspan = 1;
2252
2253 out:
2254 *offs = pos;
2255 return ROFF_RERUN;
2256 }
2257
2258 static enum rofferr
2259 roff_ds(ROFF_ARGS)
2260 {
2261 char *string;
2262 const char *name;
2263 size_t namesz;
2264
2265 /* Ignore groff compatibility mode for now. */
2266
2267 if (tok == ROFF_ds1)
2268 tok = ROFF_ds;
2269 else if (tok == ROFF_as1)
2270 tok = ROFF_as;
2271
2272 /*
2273 * The first word is the name of the string.
2274 * If it is empty or terminated by an escape sequence,
2275 * abort the `ds' request without defining anything.
2276 */
2277
2278 name = string = buf->buf + pos;
2279 if (*name == '\0')
2280 return ROFF_IGN;
2281
2282 namesz = roff_getname(r, &string, ln, pos);
2283 if (name[namesz] == '\\')
2284 return ROFF_IGN;
2285
2286 /* Read past the initial double-quote, if any. */
2287 if (*string == '"')
2288 string++;
2289
2290 /* The rest is the value. */
2291 roff_setstrn(&r->strtab, name, namesz, string, strlen(string),
2292 ROFF_as == tok);
2293 return ROFF_IGN;
2294 }
2295
2296 /*
2297 * Parse a single operator, one or two characters long.
2298 * If the operator is recognized, return success and advance the
2299 * parse point, else return failure and let the parse point unchanged.
2300 */
2301 static int
2302 roff_getop(const char *v, int *pos, char *res)
2303 {
2304
2305 *res = v[*pos];
2306
2307 switch (*res) {
2308 case '+':
2309 case '-':
2310 case '*':
2311 case '/':
2312 case '%':
2313 case '&':
2314 case ':':
2315 break;
2316 case '<':
2317 switch (v[*pos + 1]) {
2318 case '=':
2319 *res = 'l';
2320 (*pos)++;
2321 break;
2322 case '>':
2323 *res = '!';
2324 (*pos)++;
2325 break;
2326 case '?':
2327 *res = 'i';
2328 (*pos)++;
2329 break;
2330 default:
2331 break;
2332 }
2333 break;
2334 case '>':
2335 switch (v[*pos + 1]) {
2336 case '=':
2337 *res = 'g';
2338 (*pos)++;
2339 break;
2340 case '?':
2341 *res = 'a';
2342 (*pos)++;
2343 break;
2344 default:
2345 break;
2346 }
2347 break;
2348 case '=':
2349 if ('=' == v[*pos + 1])
2350 (*pos)++;
2351 break;
2352 default:
2353 return 0;
2354 }
2355 (*pos)++;
2356
2357 return *res;
2358 }
2359
2360 /*
2361 * Evaluate either a parenthesized numeric expression
2362 * or a single signed integer number.
2363 */
2364 static int
2365 roff_evalpar(struct roff *r, int ln,
2366 const char *v, int *pos, int *res, int flags)
2367 {
2368
2369 if ('(' != v[*pos])
2370 return roff_getnum(v, pos, res, flags);
2371
2372 (*pos)++;
2373 if ( ! roff_evalnum(r, ln, v, pos, res, flags | ROFFNUM_WHITE))
2374 return 0;
2375
2376 /*
2377 * Omission of the closing parenthesis
2378 * is an error in validation mode,
2379 * but ignored in evaluation mode.
2380 */
2381
2382 if (')' == v[*pos])
2383 (*pos)++;
2384 else if (NULL == res)
2385 return 0;
2386
2387 return 1;
2388 }
2389
2390 /*
2391 * Evaluate a complete numeric expression.
2392 * Proceed left to right, there is no concept of precedence.
2393 */
2394 static int
2395 roff_evalnum(struct roff *r, int ln, const char *v,
2396 int *pos, int *res, int flags)
2397 {
2398 int mypos, operand2;
2399 char operator;
2400
2401 if (NULL == pos) {
2402 mypos = 0;
2403 pos = &mypos;
2404 }
2405
2406 if (flags & ROFFNUM_WHITE)
2407 while (isspace((unsigned char)v[*pos]))
2408 (*pos)++;
2409
2410 if ( ! roff_evalpar(r, ln, v, pos, res, flags))
2411 return 0;
2412
2413 while (1) {
2414 if (flags & ROFFNUM_WHITE)
2415 while (isspace((unsigned char)v[*pos]))
2416 (*pos)++;
2417
2418 if ( ! roff_getop(v, pos, &operator))
2419 break;
2420
2421 if (flags & ROFFNUM_WHITE)
2422 while (isspace((unsigned char)v[*pos]))
2423 (*pos)++;
2424
2425 if ( ! roff_evalpar(r, ln, v, pos, &operand2, flags))
2426 return 0;
2427
2428 if (flags & ROFFNUM_WHITE)
2429 while (isspace((unsigned char)v[*pos]))
2430 (*pos)++;
2431
2432 if (NULL == res)
2433 continue;
2434
2435 switch (operator) {
2436 case '+':
2437 *res += operand2;
2438 break;
2439 case '-':
2440 *res -= operand2;
2441 break;
2442 case '*':
2443 *res *= operand2;
2444 break;
2445 case '/':
2446 if (operand2 == 0) {
2447 mandoc_msg(MANDOCERR_DIVZERO,
2448 r->parse, ln, *pos, v);
2449 *res = 0;
2450 break;
2451 }
2452 *res /= operand2;
2453 break;
2454 case '%':
2455 if (operand2 == 0) {
2456 mandoc_msg(MANDOCERR_DIVZERO,
2457 r->parse, ln, *pos, v);
2458 *res = 0;
2459 break;
2460 }
2461 *res %= operand2;
2462 break;
2463 case '<':
2464 *res = *res < operand2;
2465 break;
2466 case '>':
2467 *res = *res > operand2;
2468 break;
2469 case 'l':
2470 *res = *res <= operand2;
2471 break;
2472 case 'g':
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 ':':
2485 *res = *res || operand2;
2486 break;
2487 case 'i':
2488 if (operand2 < *res)
2489 *res = operand2;
2490 break;
2491 case 'a':
2492 if (operand2 > *res)
2493 *res = operand2;
2494 break;
2495 default:
2496 abort();
2497 }
2498 }
2499 return 1;
2500 }
2501
2502 /* --- register management ------------------------------------------------ */
2503
2504 void
2505 roff_setreg(struct roff *r, const char *name, int val, char sign)
2506 {
2507 struct roffreg *reg;
2508
2509 /* Search for an existing register with the same name. */
2510 reg = r->regtab;
2511
2512 while (reg && strcmp(name, reg->key.p))
2513 reg = reg->next;
2514
2515 if (NULL == reg) {
2516 /* Create a new register. */
2517 reg = mandoc_malloc(sizeof(struct roffreg));
2518 reg->key.p = mandoc_strdup(name);
2519 reg->key.sz = strlen(name);
2520 reg->val = 0;
2521 reg->next = r->regtab;
2522 r->regtab = reg;
2523 }
2524
2525 if ('+' == sign)
2526 reg->val += val;
2527 else if ('-' == sign)
2528 reg->val -= val;
2529 else
2530 reg->val = val;
2531 }
2532
2533 /*
2534 * Handle some predefined read-only number registers.
2535 * For now, return -1 if the requested register is not predefined;
2536 * in case a predefined read-only register having the value -1
2537 * were to turn up, another special value would have to be chosen.
2538 */
2539 static int
2540 roff_getregro(const struct roff *r, const char *name)
2541 {
2542
2543 switch (*name) {
2544 case '$': /* Number of arguments of the last macro evaluated. */
2545 return r->argc;
2546 case 'A': /* ASCII approximation mode is always off. */
2547 return 0;
2548 case 'g': /* Groff compatibility mode is always on. */
2549 return 1;
2550 case 'H': /* Fixed horizontal resolution. */
2551 return 24;
2552 case 'j': /* Always adjust left margin only. */
2553 return 0;
2554 case 'T': /* Some output device is always defined. */
2555 return 1;
2556 case 'V': /* Fixed vertical resolution. */
2557 return 40;
2558 default:
2559 return -1;
2560 }
2561 }
2562
2563 int
2564 roff_getreg(const struct roff *r, const char *name)
2565 {
2566 struct roffreg *reg;
2567 int val;
2568
2569 if ('.' == name[0] && '\0' != name[1] && '\0' == name[2]) {
2570 val = roff_getregro(r, name + 1);
2571 if (-1 != val)
2572 return val;
2573 }
2574
2575 for (reg = r->regtab; reg; reg = reg->next)
2576 if (0 == strcmp(name, reg->key.p))
2577 return reg->val;
2578
2579 return 0;
2580 }
2581
2582 static int
2583 roff_getregn(const struct roff *r, const char *name, size_t len)
2584 {
2585 struct roffreg *reg;
2586 int val;
2587
2588 if ('.' == name[0] && 2 == len) {
2589 val = roff_getregro(r, name + 1);
2590 if (-1 != val)
2591 return val;
2592 }
2593
2594 for (reg = r->regtab; reg; reg = reg->next)
2595 if (len == reg->key.sz &&
2596 0 == strncmp(name, reg->key.p, len))
2597 return reg->val;
2598
2599 return 0;
2600 }
2601
2602 static int
2603 roff_hasregn(const struct roff *r, const char *name, size_t len)
2604 {
2605 struct roffreg *reg;
2606 int val;
2607
2608 if ('.' == name[0] && 2 == len) {
2609 val = roff_getregro(r, name + 1);
2610 if (-1 != val)
2611 return 1;
2612 }
2613
2614 for (reg = r->regtab; reg; reg = reg->next)
2615 if (len == reg->key.sz &&
2616 0 == strncmp(name, reg->key.p, len))
2617 return 1;
2618
2619 return 0;
2620 }
2621
2622 static void
2623 roff_freereg(struct roffreg *reg)
2624 {
2625 struct roffreg *old_reg;
2626
2627 while (NULL != reg) {
2628 free(reg->key.p);
2629 old_reg = reg;
2630 reg = reg->next;
2631 free(old_reg);
2632 }
2633 }
2634
2635 static enum rofferr
2636 roff_nr(ROFF_ARGS)
2637 {
2638 char *key, *val;
2639 size_t keysz;
2640 int iv;
2641 char sign;
2642
2643 key = val = buf->buf + pos;
2644 if (*key == '\0')
2645 return ROFF_IGN;
2646
2647 keysz = roff_getname(r, &val, ln, pos);
2648 if (key[keysz] == '\\')
2649 return ROFF_IGN;
2650 key[keysz] = '\0';
2651
2652 sign = *val;
2653 if (sign == '+' || sign == '-')
2654 val++;
2655
2656 if (roff_evalnum(r, ln, val, NULL, &iv, ROFFNUM_SCALE))
2657 roff_setreg(r, key, iv, sign);
2658
2659 return ROFF_IGN;
2660 }
2661
2662 static enum rofferr
2663 roff_rr(ROFF_ARGS)
2664 {
2665 struct roffreg *reg, **prev;
2666 char *name, *cp;
2667 size_t namesz;
2668
2669 name = cp = buf->buf + pos;
2670 if (*name == '\0')
2671 return ROFF_IGN;
2672 namesz = roff_getname(r, &cp, ln, pos);
2673 name[namesz] = '\0';
2674
2675 prev = &r->regtab;
2676 while (1) {
2677 reg = *prev;
2678 if (reg == NULL || !strcmp(name, reg->key.p))
2679 break;
2680 prev = &reg->next;
2681 }
2682 if (reg != NULL) {
2683 *prev = reg->next;
2684 free(reg->key.p);
2685 free(reg);
2686 }
2687 return ROFF_IGN;
2688 }
2689
2690 /* --- handler functions for roff requests -------------------------------- */
2691
2692 static enum rofferr
2693 roff_rm(ROFF_ARGS)
2694 {
2695 const char *name;
2696 char *cp;
2697 size_t namesz;
2698
2699 cp = buf->buf + pos;
2700 while (*cp != '\0') {
2701 name = cp;
2702 namesz = roff_getname(r, &cp, ln, (int)(cp - buf->buf));
2703 roff_setstrn(&r->strtab, name, namesz, NULL, 0, 0);
2704 if (name[namesz] == '\\')
2705 break;
2706 }
2707 return ROFF_IGN;
2708 }
2709
2710 static enum rofferr
2711 roff_it(ROFF_ARGS)
2712 {
2713 int iv;
2714
2715 /* Parse the number of lines. */
2716
2717 if ( ! roff_evalnum(r, ln, buf->buf, &pos, &iv, 0)) {
2718 mandoc_msg(MANDOCERR_IT_NONUM, r->parse,
2719 ln, ppos, buf->buf + 1);
2720 return ROFF_IGN;
2721 }
2722
2723 while (isspace((unsigned char)buf->buf[pos]))
2724 pos++;
2725
2726 /*
2727 * Arm the input line trap.
2728 * Special-casing "an-trap" is an ugly workaround to cope
2729 * with DocBook stupidly fiddling with man(7) internals.
2730 */
2731
2732 roffit_lines = iv;
2733 roffit_macro = mandoc_strdup(iv != 1 ||
2734 strcmp(buf->buf + pos, "an-trap") ?
2735 buf->buf + pos : "br");
2736 return ROFF_IGN;
2737 }
2738
2739 static enum rofferr
2740 roff_Dd(ROFF_ARGS)
2741 {
2742 const char *const *cp;
2743
2744 if ((r->options & (MPARSE_MDOC | MPARSE_QUICK)) == 0)
2745 for (cp = __mdoc_reserved; *cp; cp++)
2746 roff_setstr(r, *cp, NULL, 0);
2747
2748 if (r->format == 0)
2749 r->format = MPARSE_MDOC;
2750
2751 return ROFF_CONT;
2752 }
2753
2754 static enum rofferr
2755 roff_TH(ROFF_ARGS)
2756 {
2757 const char *const *cp;
2758
2759 if ((r->options & MPARSE_QUICK) == 0)
2760 for (cp = __man_reserved; *cp; cp++)
2761 roff_setstr(r, *cp, NULL, 0);
2762
2763 if (r->format == 0)
2764 r->format = MPARSE_MAN;
2765
2766 return ROFF_CONT;
2767 }
2768
2769 static enum rofferr
2770 roff_TE(ROFF_ARGS)
2771 {
2772
2773 if (NULL == r->tbl)
2774 mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse,
2775 ln, ppos, "TE");
2776 else if ( ! tbl_end(&r->tbl)) {
2777 free(buf->buf);
2778 buf->buf = mandoc_strdup(".sp");
2779 buf->sz = 4;
2780 return ROFF_REPARSE;
2781 }
2782 return ROFF_IGN;
2783 }
2784
2785 static enum rofferr
2786 roff_T_(ROFF_ARGS)
2787 {
2788
2789 if (NULL == r->tbl)
2790 mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse,
2791 ln, ppos, "T&");
2792 else
2793 tbl_restart(ppos, ln, r->tbl);
2794
2795 return ROFF_IGN;
2796 }
2797
2798 /*
2799 * Handle in-line equation delimiters.
2800 */
2801 static enum rofferr
2802 roff_eqndelim(struct roff *r, struct buf *buf, int pos)
2803 {
2804 char *cp1, *cp2;
2805 const char *bef_pr, *bef_nl, *mac, *aft_nl, *aft_pr;
2806
2807 /*
2808 * Outside equations, look for an opening delimiter.
2809 * If we are inside an equation, we already know it is
2810 * in-line, or this function wouldn't have been called;
2811 * so look for a closing delimiter.
2812 */
2813
2814 cp1 = buf->buf + pos;
2815 cp2 = strchr(cp1, r->eqn == NULL ?
2816 r->last_eqn->odelim : r->last_eqn->cdelim);
2817 if (cp2 == NULL)
2818 return ROFF_CONT;
2819
2820 *cp2++ = '\0';
2821 bef_pr = bef_nl = aft_nl = aft_pr = "";
2822
2823 /* Handle preceding text, protecting whitespace. */
2824
2825 if (*buf->buf != '\0') {
2826 if (r->eqn == NULL)
2827 bef_pr = "\\&";
2828 bef_nl = "\n";
2829 }
2830
2831 /*
2832 * Prepare replacing the delimiter with an equation macro
2833 * and drop leading white space from the equation.
2834 */
2835
2836 if (r->eqn == NULL) {
2837 while (*cp2 == ' ')
2838 cp2++;
2839 mac = ".EQ";
2840 } else
2841 mac = ".EN";
2842
2843 /* Handle following text, protecting whitespace. */
2844
2845 if (*cp2 != '\0') {
2846 aft_nl = "\n";
2847 if (r->eqn != NULL)
2848 aft_pr = "\\&";
2849 }
2850
2851 /* Do the actual replacement. */
2852
2853 buf->sz = mandoc_asprintf(&cp1, "%s%s%s%s%s%s%s", buf->buf,
2854 bef_pr, bef_nl, mac, aft_nl, aft_pr, cp2) + 1;
2855 free(buf->buf);
2856 buf->buf = cp1;
2857
2858 /* Toggle the in-line state of the eqn subsystem. */
2859
2860 r->eqn_inline = r->eqn == NULL;
2861 return ROFF_REPARSE;
2862 }
2863
2864 static enum rofferr
2865 roff_EQ(ROFF_ARGS)
2866 {
2867 struct eqn_node *e;
2868
2869 assert(r->eqn == NULL);
2870 e = eqn_alloc(ppos, ln, r->parse);
2871
2872 if (r->last_eqn) {
2873 r->last_eqn->next = e;
2874 e->delim = r->last_eqn->delim;
2875 e->odelim = r->last_eqn->odelim;
2876 e->cdelim = r->last_eqn->cdelim;
2877 } else
2878 r->first_eqn = r->last_eqn = e;
2879
2880 r->eqn = r->last_eqn = e;
2881
2882 if (buf->buf[pos] != '\0')
2883 mandoc_vmsg(MANDOCERR_ARG_SKIP, r->parse, ln, pos,
2884 ".EQ %s", buf->buf + pos);
2885
2886 return ROFF_IGN;
2887 }
2888
2889 static enum rofferr
2890 roff_EN(ROFF_ARGS)
2891 {
2892
2893 mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse, ln, ppos, "EN");
2894 return ROFF_IGN;
2895 }
2896
2897 static enum rofferr
2898 roff_TS(ROFF_ARGS)
2899 {
2900 struct tbl_node *tbl;
2901
2902 if (r->tbl) {
2903 mandoc_msg(MANDOCERR_BLK_BROKEN, r->parse,
2904 ln, ppos, "TS breaks TS");
2905 tbl_end(&r->tbl);
2906 }
2907
2908 tbl = tbl_alloc(ppos, ln, r->parse);
2909
2910 if (r->last_tbl)
2911 r->last_tbl->next = tbl;
2912 else
2913 r->first_tbl = r->last_tbl = tbl;
2914
2915 r->tbl = r->last_tbl = tbl;
2916 return ROFF_IGN;
2917 }
2918
2919 static enum rofferr
2920 roff_brp(ROFF_ARGS)
2921 {
2922
2923 buf->buf[pos - 1] = '\0';
2924 return ROFF_CONT;
2925 }
2926
2927 static enum rofferr
2928 roff_cc(ROFF_ARGS)
2929 {
2930 const char *p;
2931
2932 p = buf->buf + pos;
2933
2934 if (*p == '\0' || (r->control = *p++) == '.')
2935 r->control = 0;
2936
2937 if (*p != '\0')
2938 mandoc_vmsg(MANDOCERR_ARG_EXCESS, r->parse,
2939 ln, p - buf->buf, "cc ... %s", p);
2940
2941 return ROFF_IGN;
2942 }
2943
2944 static enum rofferr
2945 roff_tr(ROFF_ARGS)
2946 {
2947 const char *p, *first, *second;
2948 size_t fsz, ssz;
2949 enum mandoc_esc esc;
2950
2951 p = buf->buf + pos;
2952
2953 if (*p == '\0') {
2954 mandoc_msg(MANDOCERR_REQ_EMPTY, r->parse, ln, ppos, "tr");
2955 return ROFF_IGN;
2956 }
2957
2958 while (*p != '\0') {
2959 fsz = ssz = 1;
2960
2961 first = p++;
2962 if (*first == '\\') {
2963 esc = mandoc_escape(&p, NULL, NULL);
2964 if (esc == ESCAPE_ERROR) {
2965 mandoc_msg(MANDOCERR_ESC_BAD, r->parse,
2966 ln, (int)(p - buf->buf), first);
2967 return ROFF_IGN;
2968 }
2969 fsz = (size_t)(p - first);
2970 }
2971
2972 second = p++;
2973 if (*second == '\\') {
2974 esc = mandoc_escape(&p, NULL, NULL);
2975 if (esc == ESCAPE_ERROR) {
2976 mandoc_msg(MANDOCERR_ESC_BAD, r->parse,
2977 ln, (int)(p - buf->buf), second);
2978 return ROFF_IGN;
2979 }
2980 ssz = (size_t)(p - second);
2981 } else if (*second == '\0') {
2982 mandoc_vmsg(MANDOCERR_TR_ODD, r->parse,
2983 ln, first - buf->buf, "tr %s", first);
2984 second = " ";
2985 p--;
2986 }
2987
2988 if (fsz > 1) {
2989 roff_setstrn(&r->xmbtab, first, fsz,
2990 second, ssz, 0);
2991 continue;
2992 }
2993
2994 if (r->xtab == NULL)
2995 r->xtab = mandoc_calloc(128,
2996 sizeof(struct roffstr));
2997
2998 free(r->xtab[(int)*first].p);
2999 r->xtab[(int)*first].p = mandoc_strndup(second, ssz);
3000 r->xtab[(int)*first].sz = ssz;
3001 }
3002
3003 return ROFF_IGN;
3004 }
3005
3006 static enum rofferr
3007 roff_so(ROFF_ARGS)
3008 {
3009 char *name, *cp;
3010
3011 name = buf->buf + pos;
3012 mandoc_vmsg(MANDOCERR_SO, r->parse, ln, ppos, "so %s", name);
3013
3014 /*
3015 * Handle `so'. Be EXTREMELY careful, as we shouldn't be
3016 * opening anything that's not in our cwd or anything beneath
3017 * it. Thus, explicitly disallow traversing up the file-system
3018 * or using absolute paths.
3019 */
3020
3021 if (*name == '/' || strstr(name, "../") || strstr(name, "/..")) {
3022 mandoc_vmsg(MANDOCERR_SO_PATH, r->parse, ln, ppos,
3023 ".so %s", name);
3024 buf->sz = mandoc_asprintf(&cp,
3025 ".sp\nSee the file %s.\n.sp", name) + 1;
3026 free(buf->buf);
3027 buf->buf = cp;
3028 *offs = 0;
3029 return ROFF_REPARSE;
3030 }
3031
3032 *offs = pos;
3033 return ROFF_SO;
3034 }
3035
3036 /* --- user defined strings and macros ------------------------------------ */
3037
3038 static enum rofferr
3039 roff_userdef(ROFF_ARGS)
3040 {
3041 const char *arg[9], *ap;
3042 char *cp, *n1, *n2;
3043 int i, ib, ie;
3044 size_t asz, rsz;
3045
3046 /*
3047 * Collect pointers to macro argument strings
3048 * and NUL-terminate them.
3049 */
3050
3051 r->argc = 0;
3052 cp = buf->buf + pos;
3053 for (i = 0; i < 9; i++) {
3054 if (*cp == '\0')
3055 arg[i] = "";
3056 else {
3057 arg[i] = mandoc_getarg(r->parse, &cp, ln, &pos);
3058 r->argc = i + 1;
3059 }
3060 }
3061
3062 /*
3063 * Expand macro arguments.
3064 */
3065
3066 buf->sz = strlen(r->current_string) + 1;
3067 n1 = cp = mandoc_malloc(buf->sz);
3068 memcpy(n1, r->current_string, buf->sz);
3069 while (*cp != '\0') {
3070
3071 /* Scan ahead for the next argument invocation. */
3072
3073 if (*cp++ != '\\')
3074 continue;
3075 if (*cp++ != '$')
3076 continue;
3077 if (*cp == '*') { /* \\$* inserts all arguments */
3078 ib = 0;
3079 ie = r->argc - 1;
3080 } else { /* \\$1 .. \\$9 insert one argument */
3081 ib = ie = *cp - '1';
3082 if (ib < 0 || ib > 8)
3083 continue;
3084 }
3085 cp -= 2;
3086
3087 /*
3088 * Determine the size of the expanded argument,
3089 * taking escaping of quotes into account.
3090 */
3091
3092 asz = ie > ib ? ie - ib : 0; /* for blanks */
3093 for (i = ib; i <= ie; i++) {
3094 for (ap = arg[i]; *ap != '\0'; ap++) {
3095 asz++;
3096 if (*ap == '"')
3097 asz += 3;
3098 }
3099 }
3100 if (asz != 3) {
3101
3102 /*
3103 * Determine the size of the rest of the
3104 * unexpanded macro, including the NUL.
3105 */
3106
3107 rsz = buf->sz - (cp - n1) - 3;
3108
3109 /*
3110 * When shrinking, move before
3111 * releasing the storage.
3112 */
3113
3114 if (asz < 3)
3115 memmove(cp + asz, cp + 3, rsz);
3116
3117 /*
3118 * Resize the storage for the macro
3119 * and readjust the parse pointer.
3120 */
3121
3122 buf->sz += asz - 3;
3123 n2 = mandoc_realloc(n1, buf->sz);
3124 cp = n2 + (cp - n1);
3125 n1 = n2;
3126
3127 /*
3128 * When growing, make room
3129 * for the expanded argument.
3130 */
3131
3132 if (asz > 3)
3133 memmove(cp + asz, cp + 3, rsz);
3134 }
3135
3136 /* Copy the expanded argument, escaping quotes. */
3137
3138 n2 = cp;
3139 for (i = ib; i <= ie; i++) {
3140 for (ap = arg[i]; *ap != '\0'; ap++) {
3141 if (*ap == '"') {
3142 memcpy(n2, "\\(dq", 4);
3143 n2 += 4;
3144 } else
3145 *n2++ = *ap;
3146 }
3147 if (i < ie)
3148 *n2++ = ' ';
3149 }
3150 }
3151
3152 /*
3153 * Replace the macro invocation
3154 * by the expanded macro.
3155 */
3156
3157 free(buf->buf);
3158 buf->buf = n1;
3159 *offs = 0;
3160
3161 return buf->sz > 1 && buf->buf[buf->sz - 2] == '\n' ?
3162 ROFF_REPARSE : ROFF_APPEND;
3163 }
3164
3165 static size_t
3166 roff_getname(struct roff *r, char **cpp, int ln, int pos)
3167 {
3168 char *name, *cp;
3169 size_t namesz;
3170
3171 name = *cpp;
3172 if ('\0' == *name)
3173 return 0;
3174
3175 /* Read until end of name and terminate it with NUL. */
3176 for (cp = name; 1; cp++) {
3177 if ('\0' == *cp || ' ' == *cp) {
3178 namesz = cp - name;
3179 break;
3180 }
3181 if ('\\' != *cp)
3182 continue;
3183 namesz = cp - name;
3184 if ('{' == cp[1] || '}' == cp[1])
3185 break;
3186 cp++;
3187 if ('\\' == *cp)
3188 continue;
3189 mandoc_vmsg(MANDOCERR_NAMESC, r->parse, ln, pos,
3190 "%.*s", (int)(cp - name + 1), name);
3191 mandoc_escape((const char **)&cp, NULL, NULL);
3192 break;
3193 }
3194
3195 /* Read past spaces. */
3196 while (' ' == *cp)
3197 cp++;
3198
3199 *cpp = cp;
3200 return namesz;
3201 }
3202
3203 /*
3204 * Store *string into the user-defined string called *name.
3205 * To clear an existing entry, call with (*r, *name, NULL, 0).
3206 * append == 0: replace mode
3207 * append == 1: single-line append mode
3208 * append == 2: multiline append mode, append '\n' after each call
3209 */
3210 static void
3211 roff_setstr(struct roff *r, const char *name, const char *string,
3212 int append)
3213 {
3214
3215 roff_setstrn(&r->strtab, name, strlen(name), string,
3216 string ? strlen(string) : 0, append);
3217 }
3218
3219 static void
3220 roff_setstrn(struct roffkv **r, const char *name, size_t namesz,
3221 const char *string, size_t stringsz, int append)
3222 {
3223 struct roffkv *n;
3224 char *c;
3225 int i;
3226 size_t oldch, newch;
3227
3228 /* Search for an existing string with the same name. */
3229 n = *r;
3230
3231 while (n && (namesz != n->key.sz ||
3232 strncmp(n->key.p, name, namesz)))
3233 n = n->next;
3234
3235 if (NULL == n) {
3236 /* Create a new string table entry. */
3237 n = mandoc_malloc(sizeof(struct roffkv));
3238 n->key.p = mandoc_strndup(name, namesz);
3239 n->key.sz = namesz;
3240 n->val.p = NULL;
3241 n->val.sz = 0;
3242 n->next = *r;
3243 *r = n;
3244 } else if (0 == append) {
3245 free(n->val.p);
3246 n->val.p = NULL;
3247 n->val.sz = 0;
3248 }
3249
3250 if (NULL == string)
3251 return;
3252
3253 /*
3254 * One additional byte for the '\n' in multiline mode,
3255 * and one for the terminating '\0'.
3256 */
3257 newch = stringsz + (1 < append ? 2u : 1u);
3258
3259 if (NULL == n->val.p) {
3260 n->val.p = mandoc_malloc(newch);
3261 *n->val.p = '\0';
3262 oldch = 0;
3263 } else {
3264 oldch = n->val.sz;
3265 n->val.p = mandoc_realloc(n->val.p, oldch + newch);
3266 }
3267
3268 /* Skip existing content in the destination buffer. */
3269 c = n->val.p + (int)oldch;
3270
3271 /* Append new content to the destination buffer. */
3272 i = 0;
3273 while (i < (int)stringsz) {
3274 /*
3275 * Rudimentary roff copy mode:
3276 * Handle escaped backslashes.
3277 */
3278 if ('\\' == string[i] && '\\' == string[i + 1])
3279 i++;
3280 *c++ = string[i++];
3281 }
3282
3283 /* Append terminating bytes. */
3284 if (1 < append)
3285 *c++ = '\n';
3286
3287 *c = '\0';
3288 n->val.sz = (int)(c - n->val.p);
3289 }
3290
3291 static const char *
3292 roff_getstrn(const struct roff *r, const char *name, size_t len)
3293 {
3294 const struct roffkv *n;
3295 int i;
3296
3297 for (n = r->strtab; n; n = n->next)
3298 if (0 == strncmp(name, n->key.p, len) &&
3299 '\0' == n->key.p[(int)len])
3300 return n->val.p;
3301
3302 for (i = 0; i < PREDEFS_MAX; i++)
3303 if (0 == strncmp(name, predefs[i].name, len) &&
3304 '\0' == predefs[i].name[(int)len])
3305 return predefs[i].str;
3306
3307 return NULL;
3308 }
3309
3310 static void
3311 roff_freestr(struct roffkv *r)
3312 {
3313 struct roffkv *n, *nn;
3314
3315 for (n = r; n; n = nn) {
3316 free(n->key.p);
3317 free(n->val.p);
3318 nn = n->next;
3319 free(n);
3320 }
3321 }
3322
3323 /* --- accessors and utility functions ------------------------------------ */
3324
3325 const struct tbl_span *
3326 roff_span(const struct roff *r)
3327 {
3328
3329 return r->tbl ? tbl_span(r->tbl) : NULL;
3330 }
3331
3332 const struct eqn *
3333 roff_eqn(const struct roff *r)
3334 {
3335
3336 return r->last_eqn ? &r->last_eqn->eqn : NULL;
3337 }
3338
3339 /*
3340 * Duplicate an input string, making the appropriate character
3341 * conversations (as stipulated by `tr') along the way.
3342 * Returns a heap-allocated string with all the replacements made.
3343 */
3344 char *
3345 roff_strdup(const struct roff *r, const char *p)
3346 {
3347 const struct roffkv *cp;
3348 char *res;
3349 const char *pp;
3350 size_t ssz, sz;
3351 enum mandoc_esc esc;
3352
3353 if (NULL == r->xmbtab && NULL == r->xtab)
3354 return mandoc_strdup(p);
3355 else if ('\0' == *p)
3356 return mandoc_strdup("");
3357
3358 /*
3359 * Step through each character looking for term matches
3360 * (remember that a `tr' can be invoked with an escape, which is
3361 * a glyph but the escape is multi-character).
3362 * We only do this if the character hash has been initialised
3363 * and the string is >0 length.
3364 */
3365
3366 res = NULL;
3367 ssz = 0;
3368
3369 while ('\0' != *p) {
3370 if ('\\' != *p && r->xtab && r->xtab[(int)*p].p) {
3371 sz = r->xtab[(int)*p].sz;
3372 res = mandoc_realloc(res, ssz + sz + 1);
3373 memcpy(res + ssz, r->xtab[(int)*p].p, sz);
3374 ssz += sz;
3375 p++;
3376 continue;
3377 } else if ('\\' != *p) {
3378 res = mandoc_realloc(res, ssz + 2);
3379 res[ssz++] = *p++;
3380 continue;
3381 }
3382
3383 /* Search for term matches. */
3384 for (cp = r->xmbtab; cp; cp = cp->next)
3385 if (0 == strncmp(p, cp->key.p, cp->key.sz))
3386 break;
3387
3388 if (NULL != cp) {
3389 /*
3390 * A match has been found.
3391 * Append the match to the array and move
3392 * forward by its keysize.
3393 */
3394 res = mandoc_realloc(res,
3395 ssz + cp->val.sz + 1);
3396 memcpy(res + ssz, cp->val.p, cp->val.sz);
3397 ssz += cp->val.sz;
3398 p += (int)cp->key.sz;
3399 continue;
3400 }
3401
3402 /*
3403 * Handle escapes carefully: we need to copy
3404 * over just the escape itself, or else we might
3405 * do replacements within the escape itself.
3406 * Make sure to pass along the bogus string.
3407 */
3408 pp = p++;
3409 esc = mandoc_escape(&p, NULL, NULL);
3410 if (ESCAPE_ERROR == esc) {
3411 sz = strlen(pp);
3412 res = mandoc_realloc(res, ssz + sz + 1);
3413 memcpy(res + ssz, pp, sz);
3414 break;
3415 }
3416 /*
3417 * We bail out on bad escapes.
3418 * No need to warn: we already did so when
3419 * roff_res() was called.
3420 */
3421 sz = (int)(p - pp);
3422 res = mandoc_realloc(res, ssz + sz + 1);
3423 memcpy(res + ssz, pp, sz);
3424 ssz += sz;
3425 }
3426
3427 res[(int)ssz] = '\0';
3428 return res;
3429 }
3430
3431 int
3432 roff_getformat(const struct roff *r)
3433 {
3434
3435 return r->format;
3436 }
3437
3438 /*
3439 * Find out whether a line is a macro line or not.
3440 * If it is, adjust the current position and return one; if it isn't,
3441 * return zero and don't change the current position.
3442 * If the control character has been set with `.cc', then let that grain
3443 * precedence.
3444 * This is slighly contrary to groff, where using the non-breaking
3445 * control character when `cc' has been invoked will cause the
3446 * non-breaking macro contents to be printed verbatim.
3447 */
3448 int
3449 roff_getcontrol(const struct roff *r, const char *cp, int *ppos)
3450 {
3451 int pos;
3452
3453 pos = *ppos;
3454
3455 if (0 != r->control && cp[pos] == r->control)
3456 pos++;
3457 else if (0 != r->control)
3458 return 0;
3459 else if ('\\' == cp[pos] && '.' == cp[pos + 1])
3460 pos += 2;
3461 else if ('.' == cp[pos] || '\'' == cp[pos])
3462 pos++;
3463 else
3464 return 0;
3465
3466 while (' ' == cp[pos] || '\t' == cp[pos])
3467 pos++;
3468
3469 *ppos = pos;
3470 return 1;
3471 }
A git conversion mirror of mandoc.bsd.lv