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