]> 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
release 1.14.6
[mandoc.git] / roff.c
1 /* $Id: roff.c,v 1.378 2021/08/10 12:55:04 schwarze Exp $ */
2 /*
3 * Copyright (c) 2010-2015, 2017-2020 Ingo Schwarze <schwarze@openbsd.org>
4 * Copyright (c) 2008-2012, 2014 Kristaps Dzonsons <kristaps@bsd.lv>
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 * Implementation of the roff(7) parser for mandoc(1).
19 */
20 #include "config.h"
21
22 #include <sys/types.h>
23
24 #include <assert.h>
25 #include <ctype.h>
26 #include <limits.h>
27 #include <stddef.h>
28 #include <stdint.h>
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <string.h>
32
33 #include "mandoc_aux.h"
34 #include "mandoc_ohash.h"
35 #include "mandoc.h"
36 #include "roff.h"
37 #include "mandoc_parse.h"
38 #include "libmandoc.h"
39 #include "roff_int.h"
40 #include "tbl_parse.h"
41 #include "eqn_parse.h"
42
43 /*
44 * ASCII_ESC is used to signal from roff_getarg() to roff_expand()
45 * that an escape sequence resulted from copy-in processing and
46 * needs to be checked or interpolated. As it is used nowhere
47 * else, it is defined here rather than in a header file.
48 */
49 #define ASCII_ESC 27
50
51 /* Maximum number of string expansions per line, to break infinite loops. */
52 #define EXPAND_LIMIT 1000
53
54 /* Types of definitions of macros and strings. */
55 #define ROFFDEF_USER (1 << 1) /* User-defined. */
56 #define ROFFDEF_PRE (1 << 2) /* Predefined. */
57 #define ROFFDEF_REN (1 << 3) /* Renamed standard macro. */
58 #define ROFFDEF_STD (1 << 4) /* mdoc(7) or man(7) macro. */
59 #define ROFFDEF_ANY (ROFFDEF_USER | ROFFDEF_PRE | \
60 ROFFDEF_REN | ROFFDEF_STD)
61 #define ROFFDEF_UNDEF (1 << 5) /* Completely undefined. */
62
63 /* --- data types --------------------------------------------------------- */
64
65 /*
66 * An incredibly-simple string buffer.
67 */
68 struct roffstr {
69 char *p; /* nil-terminated buffer */
70 size_t sz; /* saved strlen(p) */
71 };
72
73 /*
74 * A key-value roffstr pair as part of a singly-linked list.
75 */
76 struct roffkv {
77 struct roffstr key;
78 struct roffstr val;
79 struct roffkv *next; /* next in list */
80 };
81
82 /*
83 * A single number register as part of a singly-linked list.
84 */
85 struct roffreg {
86 struct roffstr key;
87 int val;
88 int step;
89 struct roffreg *next;
90 };
91
92 /*
93 * Association of request and macro names with token IDs.
94 */
95 struct roffreq {
96 enum roff_tok tok;
97 char name[];
98 };
99
100 /*
101 * A macro processing context.
102 * More than one is needed when macro calls are nested.
103 */
104 struct mctx {
105 char **argv;
106 int argc;
107 int argsz;
108 };
109
110 struct roff {
111 struct roff_man *man; /* mdoc or man parser */
112 struct roffnode *last; /* leaf of stack */
113 struct mctx *mstack; /* stack of macro contexts */
114 int *rstack; /* stack of inverted `ie' values */
115 struct ohash *reqtab; /* request lookup table */
116 struct roffreg *regtab; /* number registers */
117 struct roffkv *strtab; /* user-defined strings & macros */
118 struct roffkv *rentab; /* renamed strings & macros */
119 struct roffkv *xmbtab; /* multi-byte trans table (`tr') */
120 struct roffstr *xtab; /* single-byte trans table (`tr') */
121 const char *current_string; /* value of last called user macro */
122 struct tbl_node *first_tbl; /* first table parsed */
123 struct tbl_node *last_tbl; /* last table parsed */
124 struct tbl_node *tbl; /* current table being parsed */
125 struct eqn_node *last_eqn; /* equation parser */
126 struct eqn_node *eqn; /* active equation parser */
127 int eqn_inline; /* current equation is inline */
128 int options; /* parse options */
129 int mstacksz; /* current size of mstack */
130 int mstackpos; /* position in mstack */
131 int rstacksz; /* current size limit of rstack */
132 int rstackpos; /* position in rstack */
133 int format; /* current file in mdoc or man format */
134 char control; /* control character */
135 char escape; /* escape character */
136 };
137
138 /*
139 * A macro definition, condition, or ignored block.
140 */
141 struct roffnode {
142 enum roff_tok tok; /* type of node */
143 struct roffnode *parent; /* up one in stack */
144 int line; /* parse line */
145 int col; /* parse col */
146 char *name; /* node name, e.g. macro name */
147 char *end; /* custom end macro of the block */
148 int endspan; /* scope to: 1=eol 2=next line -1=\} */
149 int rule; /* content is: 1=evaluated 0=skipped */
150 };
151
152 #define ROFF_ARGS struct roff *r, /* parse ctx */ \
153 enum roff_tok tok, /* tok of macro */ \
154 struct buf *buf, /* input buffer */ \
155 int ln, /* parse line */ \
156 int ppos, /* original pos in buffer */ \
157 int pos, /* current pos in buffer */ \
158 int *offs /* reset offset of buffer data */
159
160 typedef int (*roffproc)(ROFF_ARGS);
161
162 struct roffmac {
163 roffproc proc; /* process new macro */
164 roffproc text; /* process as child text of macro */
165 roffproc sub; /* process as child of macro */
166 int flags;
167 #define ROFFMAC_STRUCT (1 << 0) /* always interpret */
168 };
169
170 struct predef {
171 const char *name; /* predefined input name */
172 const char *str; /* replacement symbol */
173 };
174
175 #define PREDEF(__name, __str) \
176 { (__name), (__str) },
177
178 /* --- function prototypes ------------------------------------------------ */
179
180 static int roffnode_cleanscope(struct roff *);
181 static int roffnode_pop(struct roff *);
182 static void roffnode_push(struct roff *, enum roff_tok,
183 const char *, int, int);
184 static void roff_addtbl(struct roff_man *, int, struct tbl_node *);
185 static int roff_als(ROFF_ARGS);
186 static int roff_block(ROFF_ARGS);
187 static int roff_block_text(ROFF_ARGS);
188 static int roff_block_sub(ROFF_ARGS);
189 static int roff_break(ROFF_ARGS);
190 static int roff_cblock(ROFF_ARGS);
191 static int roff_cc(ROFF_ARGS);
192 static int roff_ccond(struct roff *, int, int);
193 static int roff_char(ROFF_ARGS);
194 static int roff_cond(ROFF_ARGS);
195 static int roff_cond_checkend(ROFF_ARGS);
196 static int roff_cond_text(ROFF_ARGS);
197 static int roff_cond_sub(ROFF_ARGS);
198 static int roff_ds(ROFF_ARGS);
199 static int roff_ec(ROFF_ARGS);
200 static int roff_eo(ROFF_ARGS);
201 static int roff_eqndelim(struct roff *, struct buf *, int);
202 static int roff_evalcond(struct roff *, int, char *, int *);
203 static int roff_evalnum(struct roff *, int,
204 const char *, int *, int *, int);
205 static int roff_evalpar(struct roff *, int,
206 const char *, int *, int *, int);
207 static int roff_evalstrcond(const char *, int *);
208 static int roff_expand(struct roff *, struct buf *,
209 int, int, char);
210 static void roff_free1(struct roff *);
211 static void roff_freereg(struct roffreg *);
212 static void roff_freestr(struct roffkv *);
213 static size_t roff_getname(struct roff *, char **, int, int);
214 static int roff_getnum(const char *, int *, int *, int);
215 static int roff_getop(const char *, int *, char *);
216 static int roff_getregn(struct roff *,
217 const char *, size_t, char);
218 static int roff_getregro(const struct roff *,
219 const char *name);
220 static const char *roff_getstrn(struct roff *,
221 const char *, size_t, int *);
222 static int roff_hasregn(const struct roff *,
223 const char *, size_t);
224 static int roff_insec(ROFF_ARGS);
225 static int roff_it(ROFF_ARGS);
226 static int roff_line_ignore(ROFF_ARGS);
227 static void roff_man_alloc1(struct roff_man *);
228 static void roff_man_free1(struct roff_man *);
229 static int roff_manyarg(ROFF_ARGS);
230 static int roff_noarg(ROFF_ARGS);
231 static int roff_nop(ROFF_ARGS);
232 static int roff_nr(ROFF_ARGS);
233 static int roff_onearg(ROFF_ARGS);
234 static enum roff_tok roff_parse(struct roff *, char *, int *,
235 int, int);
236 static int roff_parsetext(struct roff *, struct buf *,
237 int, int *);
238 static int roff_renamed(ROFF_ARGS);
239 static int roff_return(ROFF_ARGS);
240 static int roff_rm(ROFF_ARGS);
241 static int roff_rn(ROFF_ARGS);
242 static int roff_rr(ROFF_ARGS);
243 static void roff_setregn(struct roff *, const char *,
244 size_t, int, char, int);
245 static void roff_setstr(struct roff *,
246 const char *, const char *, int);
247 static void roff_setstrn(struct roffkv **, const char *,
248 size_t, const char *, size_t, int);
249 static int roff_shift(ROFF_ARGS);
250 static int roff_so(ROFF_ARGS);
251 static int roff_tr(ROFF_ARGS);
252 static int roff_Dd(ROFF_ARGS);
253 static int roff_TE(ROFF_ARGS);
254 static int roff_TS(ROFF_ARGS);
255 static int roff_EQ(ROFF_ARGS);
256 static int roff_EN(ROFF_ARGS);
257 static int roff_T_(ROFF_ARGS);
258 static int roff_unsupp(ROFF_ARGS);
259 static int roff_userdef(ROFF_ARGS);
260
261 /* --- constant data ------------------------------------------------------ */
262
263 #define ROFFNUM_SCALE (1 << 0) /* Honour scaling in roff_getnum(). */
264 #define ROFFNUM_WHITE (1 << 1) /* Skip whitespace in roff_evalnum(). */
265
266 const char *__roff_name[MAN_MAX + 1] = {
267 "br", "ce", "fi", "ft",
268 "ll", "mc", "nf",
269 "po", "rj", "sp",
270 "ta", "ti", NULL,
271 "ab", "ad", "af", "aln",
272 "als", "am", "am1", "ami",
273 "ami1", "as", "as1", "asciify",
274 "backtrace", "bd", "bleedat", "blm",
275 "box", "boxa", "bp", "BP",
276 "break", "breakchar", "brnl", "brp",
277 "brpnl", "c2", "cc",
278 "cf", "cflags", "ch", "char",
279 "chop", "class", "close", "CL",
280 "color", "composite", "continue", "cp",
281 "cropat", "cs", "cu", "da",
282 "dch", "Dd", "de", "de1",
283 "defcolor", "dei", "dei1", "device",
284 "devicem", "di", "do", "ds",
285 "ds1", "dwh", "dt", "ec",
286 "ecr", "ecs", "el", "em",
287 "EN", "eo", "EP", "EQ",
288 "errprint", "ev", "evc", "ex",
289 "fallback", "fam", "fc", "fchar",
290 "fcolor", "fdeferlig", "feature", "fkern",
291 "fl", "flig", "fp", "fps",
292 "fschar", "fspacewidth", "fspecial", "ftr",
293 "fzoom", "gcolor", "hc", "hcode",
294 "hidechar", "hla", "hlm", "hpf",
295 "hpfa", "hpfcode", "hw", "hy",
296 "hylang", "hylen", "hym", "hypp",
297 "hys", "ie", "if", "ig",
298 "index", "it", "itc", "IX",
299 "kern", "kernafter", "kernbefore", "kernpair",
300 "lc", "lc_ctype", "lds", "length",
301 "letadj", "lf", "lg", "lhang",
302 "linetabs", "lnr", "lnrf", "lpfx",
303 "ls", "lsm", "lt",
304 "mediasize", "minss", "mk", "mso",
305 "na", "ne", "nh", "nhychar",
306 "nm", "nn", "nop", "nr",
307 "nrf", "nroff", "ns", "nx",
308 "open", "opena", "os", "output",
309 "padj", "papersize", "pc", "pev",
310 "pi", "PI", "pl", "pm",
311 "pn", "pnr", "ps",
312 "psbb", "pshape", "pso", "ptr",
313 "pvs", "rchar", "rd", "recursionlimit",
314 "return", "rfschar", "rhang",
315 "rm", "rn", "rnn", "rr",
316 "rs", "rt", "schar", "sentchar",
317 "shc", "shift", "sizes", "so",
318 "spacewidth", "special", "spreadwarn", "ss",
319 "sty", "substring", "sv", "sy",
320 "T&", "tc", "TE",
321 "TH", "tkf", "tl",
322 "tm", "tm1", "tmc", "tr",
323 "track", "transchar", "trf", "trimat",
324 "trin", "trnt", "troff", "TS",
325 "uf", "ul", "unformat", "unwatch",
326 "unwatchn", "vpt", "vs", "warn",
327 "warnscale", "watch", "watchlength", "watchn",
328 "wh", "while", "write", "writec",
329 "writem", "xflag", ".", NULL,
330 NULL, "text",
331 "Dd", "Dt", "Os", "Sh",
332 "Ss", "Pp", "D1", "Dl",
333 "Bd", "Ed", "Bl", "El",
334 "It", "Ad", "An", "Ap",
335 "Ar", "Cd", "Cm", "Dv",
336 "Er", "Ev", "Ex", "Fa",
337 "Fd", "Fl", "Fn", "Ft",
338 "Ic", "In", "Li", "Nd",
339 "Nm", "Op", "Ot", "Pa",
340 "Rv", "St", "Va", "Vt",
341 "Xr", "%A", "%B", "%D",
342 "%I", "%J", "%N", "%O",
343 "%P", "%R", "%T", "%V",
344 "Ac", "Ao", "Aq", "At",
345 "Bc", "Bf", "Bo", "Bq",
346 "Bsx", "Bx", "Db", "Dc",
347 "Do", "Dq", "Ec", "Ef",
348 "Em", "Eo", "Fx", "Ms",
349 "No", "Ns", "Nx", "Ox",
350 "Pc", "Pf", "Po", "Pq",
351 "Qc", "Ql", "Qo", "Qq",
352 "Re", "Rs", "Sc", "So",
353 "Sq", "Sm", "Sx", "Sy",
354 "Tn", "Ux", "Xc", "Xo",
355 "Fo", "Fc", "Oo", "Oc",
356 "Bk", "Ek", "Bt", "Hf",
357 "Fr", "Ud", "Lb", "Lp",
358 "Lk", "Mt", "Brq", "Bro",
359 "Brc", "%C", "Es", "En",
360 "Dx", "%Q", "%U", "Ta",
361 "Tg", NULL,
362 "TH", "SH", "SS", "TP",
363 "TQ",
364 "LP", "PP", "P", "IP",
365 "HP", "SM", "SB", "BI",
366 "IB", "BR", "RB", "R",
367 "B", "I", "IR", "RI",
368 "RE", "RS", "DT", "UC",
369 "PD", "AT", "in",
370 "SY", "YS", "OP",
371 "EX", "EE", "UR",
372 "UE", "MT", "ME", NULL
373 };
374 const char *const *roff_name = __roff_name;
375
376 static struct roffmac roffs[TOKEN_NONE] = {
377 { roff_noarg, NULL, NULL, 0 }, /* br */
378 { roff_onearg, NULL, NULL, 0 }, /* ce */
379 { roff_noarg, NULL, NULL, 0 }, /* fi */
380 { roff_onearg, NULL, NULL, 0 }, /* ft */
381 { roff_onearg, NULL, NULL, 0 }, /* ll */
382 { roff_onearg, NULL, NULL, 0 }, /* mc */
383 { roff_noarg, NULL, NULL, 0 }, /* nf */
384 { roff_onearg, NULL, NULL, 0 }, /* po */
385 { roff_onearg, NULL, NULL, 0 }, /* rj */
386 { roff_onearg, NULL, NULL, 0 }, /* sp */
387 { roff_manyarg, NULL, NULL, 0 }, /* ta */
388 { roff_onearg, NULL, NULL, 0 }, /* ti */
389 { NULL, NULL, NULL, 0 }, /* ROFF_MAX */
390 { roff_unsupp, NULL, NULL, 0 }, /* ab */
391 { roff_line_ignore, NULL, NULL, 0 }, /* ad */
392 { roff_line_ignore, NULL, NULL, 0 }, /* af */
393 { roff_unsupp, NULL, NULL, 0 }, /* aln */
394 { roff_als, NULL, NULL, 0 }, /* als */
395 { roff_block, roff_block_text, roff_block_sub, 0 }, /* am */
396 { roff_block, roff_block_text, roff_block_sub, 0 }, /* am1 */
397 { roff_block, roff_block_text, roff_block_sub, 0 }, /* ami */
398 { roff_block, roff_block_text, roff_block_sub, 0 }, /* ami1 */
399 { roff_ds, NULL, NULL, 0 }, /* as */
400 { roff_ds, NULL, NULL, 0 }, /* as1 */
401 { roff_unsupp, NULL, NULL, 0 }, /* asciify */
402 { roff_line_ignore, NULL, NULL, 0 }, /* backtrace */
403 { roff_line_ignore, NULL, NULL, 0 }, /* bd */
404 { roff_line_ignore, NULL, NULL, 0 }, /* bleedat */
405 { roff_unsupp, NULL, NULL, 0 }, /* blm */
406 { roff_unsupp, NULL, NULL, 0 }, /* box */
407 { roff_unsupp, NULL, NULL, 0 }, /* boxa */
408 { roff_line_ignore, NULL, NULL, 0 }, /* bp */
409 { roff_unsupp, NULL, NULL, 0 }, /* BP */
410 { roff_break, NULL, NULL, 0 }, /* break */
411 { roff_line_ignore, NULL, NULL, 0 }, /* breakchar */
412 { roff_line_ignore, NULL, NULL, 0 }, /* brnl */
413 { roff_noarg, NULL, NULL, 0 }, /* brp */
414 { roff_line_ignore, NULL, NULL, 0 }, /* brpnl */
415 { roff_unsupp, NULL, NULL, 0 }, /* c2 */
416 { roff_cc, NULL, NULL, 0 }, /* cc */
417 { roff_insec, NULL, NULL, 0 }, /* cf */
418 { roff_line_ignore, NULL, NULL, 0 }, /* cflags */
419 { roff_line_ignore, NULL, NULL, 0 }, /* ch */
420 { roff_char, NULL, NULL, 0 }, /* char */
421 { roff_unsupp, NULL, NULL, 0 }, /* chop */
422 { roff_line_ignore, NULL, NULL, 0 }, /* class */
423 { roff_insec, NULL, NULL, 0 }, /* close */
424 { roff_unsupp, NULL, NULL, 0 }, /* CL */
425 { roff_line_ignore, NULL, NULL, 0 }, /* color */
426 { roff_unsupp, NULL, NULL, 0 }, /* composite */
427 { roff_unsupp, NULL, NULL, 0 }, /* continue */
428 { roff_line_ignore, NULL, NULL, 0 }, /* cp */
429 { roff_line_ignore, NULL, NULL, 0 }, /* cropat */
430 { roff_line_ignore, NULL, NULL, 0 }, /* cs */
431 { roff_line_ignore, NULL, NULL, 0 }, /* cu */
432 { roff_unsupp, NULL, NULL, 0 }, /* da */
433 { roff_unsupp, NULL, NULL, 0 }, /* dch */
434 { roff_Dd, NULL, NULL, 0 }, /* Dd */
435 { roff_block, roff_block_text, roff_block_sub, 0 }, /* de */
436 { roff_block, roff_block_text, roff_block_sub, 0 }, /* de1 */
437 { roff_line_ignore, NULL, NULL, 0 }, /* defcolor */
438 { roff_block, roff_block_text, roff_block_sub, 0 }, /* dei */
439 { roff_block, roff_block_text, roff_block_sub, 0 }, /* dei1 */
440 { roff_unsupp, NULL, NULL, 0 }, /* device */
441 { roff_unsupp, NULL, NULL, 0 }, /* devicem */
442 { roff_unsupp, NULL, NULL, 0 }, /* di */
443 { roff_unsupp, NULL, NULL, 0 }, /* do */
444 { roff_ds, NULL, NULL, 0 }, /* ds */
445 { roff_ds, NULL, NULL, 0 }, /* ds1 */
446 { roff_unsupp, NULL, NULL, 0 }, /* dwh */
447 { roff_unsupp, NULL, NULL, 0 }, /* dt */
448 { roff_ec, NULL, NULL, 0 }, /* ec */
449 { roff_unsupp, NULL, NULL, 0 }, /* ecr */
450 { roff_unsupp, NULL, NULL, 0 }, /* ecs */
451 { roff_cond, roff_cond_text, roff_cond_sub, ROFFMAC_STRUCT }, /* el */
452 { roff_unsupp, NULL, NULL, 0 }, /* em */
453 { roff_EN, NULL, NULL, 0 }, /* EN */
454 { roff_eo, NULL, NULL, 0 }, /* eo */
455 { roff_unsupp, NULL, NULL, 0 }, /* EP */
456 { roff_EQ, NULL, NULL, 0 }, /* EQ */
457 { roff_line_ignore, NULL, NULL, 0 }, /* errprint */
458 { roff_unsupp, NULL, NULL, 0 }, /* ev */
459 { roff_unsupp, NULL, NULL, 0 }, /* evc */
460 { roff_unsupp, NULL, NULL, 0 }, /* ex */
461 { roff_line_ignore, NULL, NULL, 0 }, /* fallback */
462 { roff_line_ignore, NULL, NULL, 0 }, /* fam */
463 { roff_unsupp, NULL, NULL, 0 }, /* fc */
464 { roff_unsupp, NULL, NULL, 0 }, /* fchar */
465 { roff_line_ignore, NULL, NULL, 0 }, /* fcolor */
466 { roff_line_ignore, NULL, NULL, 0 }, /* fdeferlig */
467 { roff_line_ignore, NULL, NULL, 0 }, /* feature */
468 { roff_line_ignore, NULL, NULL, 0 }, /* fkern */
469 { roff_line_ignore, NULL, NULL, 0 }, /* fl */
470 { roff_line_ignore, NULL, NULL, 0 }, /* flig */
471 { roff_line_ignore, NULL, NULL, 0 }, /* fp */
472 { roff_line_ignore, NULL, NULL, 0 }, /* fps */
473 { roff_unsupp, NULL, NULL, 0 }, /* fschar */
474 { roff_line_ignore, NULL, NULL, 0 }, /* fspacewidth */
475 { roff_line_ignore, NULL, NULL, 0 }, /* fspecial */
476 { roff_line_ignore, NULL, NULL, 0 }, /* ftr */
477 { roff_line_ignore, NULL, NULL, 0 }, /* fzoom */
478 { roff_line_ignore, NULL, NULL, 0 }, /* gcolor */
479 { roff_line_ignore, NULL, NULL, 0 }, /* hc */
480 { roff_line_ignore, NULL, NULL, 0 }, /* hcode */
481 { roff_line_ignore, NULL, NULL, 0 }, /* hidechar */
482 { roff_line_ignore, NULL, NULL, 0 }, /* hla */
483 { roff_line_ignore, NULL, NULL, 0 }, /* hlm */
484 { roff_line_ignore, NULL, NULL, 0 }, /* hpf */
485 { roff_line_ignore, NULL, NULL, 0 }, /* hpfa */
486 { roff_line_ignore, NULL, NULL, 0 }, /* hpfcode */
487 { roff_line_ignore, NULL, NULL, 0 }, /* hw */
488 { roff_line_ignore, NULL, NULL, 0 }, /* hy */
489 { roff_line_ignore, NULL, NULL, 0 }, /* hylang */
490 { roff_line_ignore, NULL, NULL, 0 }, /* hylen */
491 { roff_line_ignore, NULL, NULL, 0 }, /* hym */
492 { roff_line_ignore, NULL, NULL, 0 }, /* hypp */
493 { roff_line_ignore, NULL, NULL, 0 }, /* hys */
494 { roff_cond, roff_cond_text, roff_cond_sub, ROFFMAC_STRUCT }, /* ie */
495 { roff_cond, roff_cond_text, roff_cond_sub, ROFFMAC_STRUCT }, /* if */
496 { roff_block, roff_block_text, roff_block_sub, 0 }, /* ig */
497 { roff_unsupp, NULL, NULL, 0 }, /* index */
498 { roff_it, NULL, NULL, 0 }, /* it */
499 { roff_unsupp, NULL, NULL, 0 }, /* itc */
500 { roff_line_ignore, NULL, NULL, 0 }, /* IX */
501 { roff_line_ignore, NULL, NULL, 0 }, /* kern */
502 { roff_line_ignore, NULL, NULL, 0 }, /* kernafter */
503 { roff_line_ignore, NULL, NULL, 0 }, /* kernbefore */
504 { roff_line_ignore, NULL, NULL, 0 }, /* kernpair */
505 { roff_unsupp, NULL, NULL, 0 }, /* lc */
506 { roff_unsupp, NULL, NULL, 0 }, /* lc_ctype */
507 { roff_unsupp, NULL, NULL, 0 }, /* lds */
508 { roff_unsupp, NULL, NULL, 0 }, /* length */
509 { roff_line_ignore, NULL, NULL, 0 }, /* letadj */
510 { roff_insec, NULL, NULL, 0 }, /* lf */
511 { roff_line_ignore, NULL, NULL, 0 }, /* lg */
512 { roff_line_ignore, NULL, NULL, 0 }, /* lhang */
513 { roff_unsupp, NULL, NULL, 0 }, /* linetabs */
514 { roff_unsupp, NULL, NULL, 0 }, /* lnr */
515 { roff_unsupp, NULL, NULL, 0 }, /* lnrf */
516 { roff_unsupp, NULL, NULL, 0 }, /* lpfx */
517 { roff_line_ignore, NULL, NULL, 0 }, /* ls */
518 { roff_unsupp, NULL, NULL, 0 }, /* lsm */
519 { roff_line_ignore, NULL, NULL, 0 }, /* lt */
520 { roff_line_ignore, NULL, NULL, 0 }, /* mediasize */
521 { roff_line_ignore, NULL, NULL, 0 }, /* minss */
522 { roff_line_ignore, NULL, NULL, 0 }, /* mk */
523 { roff_insec, NULL, NULL, 0 }, /* mso */
524 { roff_line_ignore, NULL, NULL, 0 }, /* na */
525 { roff_line_ignore, NULL, NULL, 0 }, /* ne */
526 { roff_line_ignore, NULL, NULL, 0 }, /* nh */
527 { roff_line_ignore, NULL, NULL, 0 }, /* nhychar */
528 { roff_unsupp, NULL, NULL, 0 }, /* nm */
529 { roff_unsupp, NULL, NULL, 0 }, /* nn */
530 { roff_nop, NULL, NULL, 0 }, /* nop */
531 { roff_nr, NULL, NULL, 0 }, /* nr */
532 { roff_unsupp, NULL, NULL, 0 }, /* nrf */
533 { roff_line_ignore, NULL, NULL, 0 }, /* nroff */
534 { roff_line_ignore, NULL, NULL, 0 }, /* ns */
535 { roff_insec, NULL, NULL, 0 }, /* nx */
536 { roff_insec, NULL, NULL, 0 }, /* open */
537 { roff_insec, NULL, NULL, 0 }, /* opena */
538 { roff_line_ignore, NULL, NULL, 0 }, /* os */
539 { roff_unsupp, NULL, NULL, 0 }, /* output */
540 { roff_line_ignore, NULL, NULL, 0 }, /* padj */
541 { roff_line_ignore, NULL, NULL, 0 }, /* papersize */
542 { roff_line_ignore, NULL, NULL, 0 }, /* pc */
543 { roff_line_ignore, NULL, NULL, 0 }, /* pev */
544 { roff_insec, NULL, NULL, 0 }, /* pi */
545 { roff_unsupp, NULL, NULL, 0 }, /* PI */
546 { roff_line_ignore, NULL, NULL, 0 }, /* pl */
547 { roff_line_ignore, NULL, NULL, 0 }, /* pm */
548 { roff_line_ignore, NULL, NULL, 0 }, /* pn */
549 { roff_line_ignore, NULL, NULL, 0 }, /* pnr */
550 { roff_line_ignore, NULL, NULL, 0 }, /* ps */
551 { roff_unsupp, NULL, NULL, 0 }, /* psbb */
552 { roff_unsupp, NULL, NULL, 0 }, /* pshape */
553 { roff_insec, NULL, NULL, 0 }, /* pso */
554 { roff_line_ignore, NULL, NULL, 0 }, /* ptr */
555 { roff_line_ignore, NULL, NULL, 0 }, /* pvs */
556 { roff_unsupp, NULL, NULL, 0 }, /* rchar */
557 { roff_line_ignore, NULL, NULL, 0 }, /* rd */
558 { roff_line_ignore, NULL, NULL, 0 }, /* recursionlimit */
559 { roff_return, NULL, NULL, 0 }, /* return */
560 { roff_unsupp, NULL, NULL, 0 }, /* rfschar */
561 { roff_line_ignore, NULL, NULL, 0 }, /* rhang */
562 { roff_rm, NULL, NULL, 0 }, /* rm */
563 { roff_rn, NULL, NULL, 0 }, /* rn */
564 { roff_unsupp, NULL, NULL, 0 }, /* rnn */
565 { roff_rr, NULL, NULL, 0 }, /* rr */
566 { roff_line_ignore, NULL, NULL, 0 }, /* rs */
567 { roff_line_ignore, NULL, NULL, 0 }, /* rt */
568 { roff_unsupp, NULL, NULL, 0 }, /* schar */
569 { roff_line_ignore, NULL, NULL, 0 }, /* sentchar */
570 { roff_line_ignore, NULL, NULL, 0 }, /* shc */
571 { roff_shift, NULL, NULL, 0 }, /* shift */
572 { roff_line_ignore, NULL, NULL, 0 }, /* sizes */
573 { roff_so, NULL, NULL, 0 }, /* so */
574 { roff_line_ignore, NULL, NULL, 0 }, /* spacewidth */
575 { roff_line_ignore, NULL, NULL, 0 }, /* special */
576 { roff_line_ignore, NULL, NULL, 0 }, /* spreadwarn */
577 { roff_line_ignore, NULL, NULL, 0 }, /* ss */
578 { roff_line_ignore, NULL, NULL, 0 }, /* sty */
579 { roff_unsupp, NULL, NULL, 0 }, /* substring */
580 { roff_line_ignore, NULL, NULL, 0 }, /* sv */
581 { roff_insec, NULL, NULL, 0 }, /* sy */
582 { roff_T_, NULL, NULL, 0 }, /* T& */
583 { roff_unsupp, NULL, NULL, 0 }, /* tc */
584 { roff_TE, NULL, NULL, 0 }, /* TE */
585 { roff_Dd, NULL, NULL, 0 }, /* TH */
586 { roff_line_ignore, NULL, NULL, 0 }, /* tkf */
587 { roff_unsupp, NULL, NULL, 0 }, /* tl */
588 { roff_line_ignore, NULL, NULL, 0 }, /* tm */
589 { roff_line_ignore, NULL, NULL, 0 }, /* tm1 */
590 { roff_line_ignore, NULL, NULL, 0 }, /* tmc */
591 { roff_tr, NULL, NULL, 0 }, /* tr */
592 { roff_line_ignore, NULL, NULL, 0 }, /* track */
593 { roff_line_ignore, NULL, NULL, 0 }, /* transchar */
594 { roff_insec, NULL, NULL, 0 }, /* trf */
595 { roff_line_ignore, NULL, NULL, 0 }, /* trimat */
596 { roff_unsupp, NULL, NULL, 0 }, /* trin */
597 { roff_unsupp, NULL, NULL, 0 }, /* trnt */
598 { roff_line_ignore, NULL, NULL, 0 }, /* troff */
599 { roff_TS, NULL, NULL, 0 }, /* TS */
600 { roff_line_ignore, NULL, NULL, 0 }, /* uf */
601 { roff_line_ignore, NULL, NULL, 0 }, /* ul */
602 { roff_unsupp, NULL, NULL, 0 }, /* unformat */
603 { roff_line_ignore, NULL, NULL, 0 }, /* unwatch */
604 { roff_line_ignore, NULL, NULL, 0 }, /* unwatchn */
605 { roff_line_ignore, NULL, NULL, 0 }, /* vpt */
606 { roff_line_ignore, NULL, NULL, 0 }, /* vs */
607 { roff_line_ignore, NULL, NULL, 0 }, /* warn */
608 { roff_line_ignore, NULL, NULL, 0 }, /* warnscale */
609 { roff_line_ignore, NULL, NULL, 0 }, /* watch */
610 { roff_line_ignore, NULL, NULL, 0 }, /* watchlength */
611 { roff_line_ignore, NULL, NULL, 0 }, /* watchn */
612 { roff_unsupp, NULL, NULL, 0 }, /* wh */
613 { roff_cond, roff_cond_text, roff_cond_sub, ROFFMAC_STRUCT }, /*while*/
614 { roff_insec, NULL, NULL, 0 }, /* write */
615 { roff_insec, NULL, NULL, 0 }, /* writec */
616 { roff_insec, NULL, NULL, 0 }, /* writem */
617 { roff_line_ignore, NULL, NULL, 0 }, /* xflag */
618 { roff_cblock, NULL, NULL, 0 }, /* . */
619 { roff_renamed, NULL, NULL, 0 },
620 { roff_userdef, NULL, NULL, 0 }
621 };
622
623 /* Array of injected predefined strings. */
624 #define PREDEFS_MAX 38
625 static const struct predef predefs[PREDEFS_MAX] = {
626 #include "predefs.in"
627 };
628
629 static int roffce_lines; /* number of input lines to center */
630 static struct roff_node *roffce_node; /* active request */
631 static int roffit_lines; /* number of lines to delay */
632 static char *roffit_macro; /* nil-terminated macro line */
633
634
635 /* --- request table ------------------------------------------------------ */
636
637 struct ohash *
638 roffhash_alloc(enum roff_tok mintok, enum roff_tok maxtok)
639 {
640 struct ohash *htab;
641 struct roffreq *req;
642 enum roff_tok tok;
643 size_t sz;
644 unsigned int slot;
645
646 htab = mandoc_malloc(sizeof(*htab));
647 mandoc_ohash_init(htab, 8, offsetof(struct roffreq, name));
648
649 for (tok = mintok; tok < maxtok; tok++) {
650 if (roff_name[tok] == NULL)
651 continue;
652 sz = strlen(roff_name[tok]);
653 req = mandoc_malloc(sizeof(*req) + sz + 1);
654 req->tok = tok;
655 memcpy(req->name, roff_name[tok], sz + 1);
656 slot = ohash_qlookup(htab, req->name);
657 ohash_insert(htab, slot, req);
658 }
659 return htab;
660 }
661
662 void
663 roffhash_free(struct ohash *htab)
664 {
665 struct roffreq *req;
666 unsigned int slot;
667
668 if (htab == NULL)
669 return;
670 for (req = ohash_first(htab, &slot); req != NULL;
671 req = ohash_next(htab, &slot))
672 free(req);
673 ohash_delete(htab);
674 free(htab);
675 }
676
677 enum roff_tok
678 roffhash_find(struct ohash *htab, const char *name, size_t sz)
679 {
680 struct roffreq *req;
681 const char *end;
682
683 if (sz) {
684 end = name + sz;
685 req = ohash_find(htab, ohash_qlookupi(htab, name, &end));
686 } else
687 req = ohash_find(htab, ohash_qlookup(htab, name));
688 return req == NULL ? TOKEN_NONE : req->tok;
689 }
690
691 /* --- stack of request blocks -------------------------------------------- */
692
693 /*
694 * Pop the current node off of the stack of roff instructions currently
695 * pending. Return 1 if it is a loop or 0 otherwise.
696 */
697 static int
698 roffnode_pop(struct roff *r)
699 {
700 struct roffnode *p;
701 int inloop;
702
703 p = r->last;
704 inloop = p->tok == ROFF_while;
705 r->last = p->parent;
706 free(p->name);
707 free(p->end);
708 free(p);
709 return inloop;
710 }
711
712 /*
713 * Push a roff node onto the instruction stack. This must later be
714 * removed with roffnode_pop().
715 */
716 static void
717 roffnode_push(struct roff *r, enum roff_tok tok, const char *name,
718 int line, int col)
719 {
720 struct roffnode *p;
721
722 p = mandoc_calloc(1, sizeof(struct roffnode));
723 p->tok = tok;
724 if (name)
725 p->name = mandoc_strdup(name);
726 p->parent = r->last;
727 p->line = line;
728 p->col = col;
729 p->rule = p->parent ? p->parent->rule : 0;
730
731 r->last = p;
732 }
733
734 /* --- roff parser state data management ---------------------------------- */
735
736 static void
737 roff_free1(struct roff *r)
738 {
739 int i;
740
741 tbl_free(r->first_tbl);
742 r->first_tbl = r->last_tbl = r->tbl = NULL;
743
744 eqn_free(r->last_eqn);
745 r->last_eqn = r->eqn = NULL;
746
747 while (r->mstackpos >= 0)
748 roff_userret(r);
749
750 while (r->last)
751 roffnode_pop(r);
752
753 free (r->rstack);
754 r->rstack = NULL;
755 r->rstacksz = 0;
756 r->rstackpos = -1;
757
758 roff_freereg(r->regtab);
759 r->regtab = NULL;
760
761 roff_freestr(r->strtab);
762 roff_freestr(r->rentab);
763 roff_freestr(r->xmbtab);
764 r->strtab = r->rentab = r->xmbtab = NULL;
765
766 if (r->xtab)
767 for (i = 0; i < 128; i++)
768 free(r->xtab[i].p);
769 free(r->xtab);
770 r->xtab = NULL;
771 }
772
773 void
774 roff_reset(struct roff *r)
775 {
776 roff_free1(r);
777 r->options |= MPARSE_COMMENT;
778 r->format = r->options & (MPARSE_MDOC | MPARSE_MAN);
779 r->control = '\0';
780 r->escape = '\\';
781 roffce_lines = 0;
782 roffce_node = NULL;
783 roffit_lines = 0;
784 roffit_macro = NULL;
785 }
786
787 void
788 roff_free(struct roff *r)
789 {
790 int i;
791
792 roff_free1(r);
793 for (i = 0; i < r->mstacksz; i++)
794 free(r->mstack[i].argv);
795 free(r->mstack);
796 roffhash_free(r->reqtab);
797 free(r);
798 }
799
800 struct roff *
801 roff_alloc(int options)
802 {
803 struct roff *r;
804
805 r = mandoc_calloc(1, sizeof(struct roff));
806 r->reqtab = roffhash_alloc(0, ROFF_RENAMED);
807 r->options = options | MPARSE_COMMENT;
808 r->format = options & (MPARSE_MDOC | MPARSE_MAN);
809 r->mstackpos = -1;
810 r->rstackpos = -1;
811 r->escape = '\\';
812 return r;
813 }
814
815 /* --- syntax tree state data management ---------------------------------- */
816
817 static void
818 roff_man_free1(struct roff_man *man)
819 {
820 if (man->meta.first != NULL)
821 roff_node_delete(man, man->meta.first);
822 free(man->meta.msec);
823 free(man->meta.vol);
824 free(man->meta.os);
825 free(man->meta.arch);
826 free(man->meta.title);
827 free(man->meta.name);
828 free(man->meta.date);
829 free(man->meta.sodest);
830 }
831
832 void
833 roff_state_reset(struct roff_man *man)
834 {
835 man->last = man->meta.first;
836 man->last_es = NULL;
837 man->flags = 0;
838 man->lastsec = man->lastnamed = SEC_NONE;
839 man->next = ROFF_NEXT_CHILD;
840 roff_setreg(man->roff, "nS", 0, '=');
841 }
842
843 static void
844 roff_man_alloc1(struct roff_man *man)
845 {
846 memset(&man->meta, 0, sizeof(man->meta));
847 man->meta.first = mandoc_calloc(1, sizeof(*man->meta.first));
848 man->meta.first->type = ROFFT_ROOT;
849 man->meta.macroset = MACROSET_NONE;
850 roff_state_reset(man);
851 }
852
853 void
854 roff_man_reset(struct roff_man *man)
855 {
856 roff_man_free1(man);
857 roff_man_alloc1(man);
858 }
859
860 void
861 roff_man_free(struct roff_man *man)
862 {
863 roff_man_free1(man);
864 free(man);
865 }
866
867 struct roff_man *
868 roff_man_alloc(struct roff *roff, const char *os_s, int quick)
869 {
870 struct roff_man *man;
871
872 man = mandoc_calloc(1, sizeof(*man));
873 man->roff = roff;
874 man->os_s = os_s;
875 man->quick = quick;
876 roff_man_alloc1(man);
877 roff->man = man;
878 return man;
879 }
880
881 /* --- syntax tree handling ----------------------------------------------- */
882
883 struct roff_node *
884 roff_node_alloc(struct roff_man *man, int line, int pos,
885 enum roff_type type, int tok)
886 {
887 struct roff_node *n;
888
889 n = mandoc_calloc(1, sizeof(*n));
890 n->line = line;
891 n->pos = pos;
892 n->tok = tok;
893 n->type = type;
894 n->sec = man->lastsec;
895
896 if (man->flags & MDOC_SYNOPSIS)
897 n->flags |= NODE_SYNPRETTY;
898 else
899 n->flags &= ~NODE_SYNPRETTY;
900 if ((man->flags & (ROFF_NOFILL | ROFF_NONOFILL)) == ROFF_NOFILL)
901 n->flags |= NODE_NOFILL;
902 else
903 n->flags &= ~NODE_NOFILL;
904 if (man->flags & MDOC_NEWLINE)
905 n->flags |= NODE_LINE;
906 man->flags &= ~MDOC_NEWLINE;
907
908 return n;
909 }
910
911 void
912 roff_node_append(struct roff_man *man, struct roff_node *n)
913 {
914
915 switch (man->next) {
916 case ROFF_NEXT_SIBLING:
917 if (man->last->next != NULL) {
918 n->next = man->last->next;
919 man->last->next->prev = n;
920 } else
921 man->last->parent->last = n;
922 man->last->next = n;
923 n->prev = man->last;
924 n->parent = man->last->parent;
925 break;
926 case ROFF_NEXT_CHILD:
927 if (man->last->child != NULL) {
928 n->next = man->last->child;
929 man->last->child->prev = n;
930 } else
931 man->last->last = n;
932 man->last->child = n;
933 n->parent = man->last;
934 break;
935 default:
936 abort();
937 }
938 man->last = n;
939
940 switch (n->type) {
941 case ROFFT_HEAD:
942 n->parent->head = n;
943 break;
944 case ROFFT_BODY:
945 if (n->end != ENDBODY_NOT)
946 return;
947 n->parent->body = n;
948 break;
949 case ROFFT_TAIL:
950 n->parent->tail = n;
951 break;
952 default:
953 return;
954 }
955
956 /*
957 * Copy over the normalised-data pointer of our parent. Not
958 * everybody has one, but copying a null pointer is fine.
959 */
960
961 n->norm = n->parent->norm;
962 assert(n->parent->type == ROFFT_BLOCK);
963 }
964
965 void
966 roff_word_alloc(struct roff_man *man, int line, int pos, const char *word)
967 {
968 struct roff_node *n;
969
970 n = roff_node_alloc(man, line, pos, ROFFT_TEXT, TOKEN_NONE);
971 n->string = roff_strdup(man->roff, word);
972 roff_node_append(man, n);
973 n->flags |= NODE_VALID | NODE_ENDED;
974 man->next = ROFF_NEXT_SIBLING;
975 }
976
977 void
978 roff_word_append(struct roff_man *man, const char *word)
979 {
980 struct roff_node *n;
981 char *addstr, *newstr;
982
983 n = man->last;
984 addstr = roff_strdup(man->roff, word);
985 mandoc_asprintf(&newstr, "%s %s", n->string, addstr);
986 free(addstr);
987 free(n->string);
988 n->string = newstr;
989 man->next = ROFF_NEXT_SIBLING;
990 }
991
992 void
993 roff_elem_alloc(struct roff_man *man, int line, int pos, int tok)
994 {
995 struct roff_node *n;
996
997 n = roff_node_alloc(man, line, pos, ROFFT_ELEM, tok);
998 roff_node_append(man, n);
999 man->next = ROFF_NEXT_CHILD;
1000 }
1001
1002 struct roff_node *
1003 roff_block_alloc(struct roff_man *man, int line, int pos, int tok)
1004 {
1005 struct roff_node *n;
1006
1007 n = roff_node_alloc(man, line, pos, ROFFT_BLOCK, tok);
1008 roff_node_append(man, n);
1009 man->next = ROFF_NEXT_CHILD;
1010 return n;
1011 }
1012
1013 struct roff_node *
1014 roff_head_alloc(struct roff_man *man, int line, int pos, int tok)
1015 {
1016 struct roff_node *n;
1017
1018 n = roff_node_alloc(man, line, pos, ROFFT_HEAD, tok);
1019 roff_node_append(man, n);
1020 man->next = ROFF_NEXT_CHILD;
1021 return n;
1022 }
1023
1024 struct roff_node *
1025 roff_body_alloc(struct roff_man *man, int line, int pos, int tok)
1026 {
1027 struct roff_node *n;
1028
1029 n = roff_node_alloc(man, line, pos, ROFFT_BODY, tok);
1030 roff_node_append(man, n);
1031 man->next = ROFF_NEXT_CHILD;
1032 return n;
1033 }
1034
1035 static void
1036 roff_addtbl(struct roff_man *man, int line, struct tbl_node *tbl)
1037 {
1038 struct roff_node *n;
1039 struct tbl_span *span;
1040
1041 if (man->meta.macroset == MACROSET_MAN)
1042 man_breakscope(man, ROFF_TS);
1043 while ((span = tbl_span(tbl)) != NULL) {
1044 n = roff_node_alloc(man, line, 0, ROFFT_TBL, TOKEN_NONE);
1045 n->span = span;
1046 roff_node_append(man, n);
1047 n->flags |= NODE_VALID | NODE_ENDED;
1048 man->next = ROFF_NEXT_SIBLING;
1049 }
1050 }
1051
1052 void
1053 roff_node_unlink(struct roff_man *man, struct roff_node *n)
1054 {
1055
1056 /* Adjust siblings. */
1057
1058 if (n->prev)
1059 n->prev->next = n->next;
1060 if (n->next)
1061 n->next->prev = n->prev;
1062
1063 /* Adjust parent. */
1064
1065 if (n->parent != NULL) {
1066 if (n->parent->child == n)
1067 n->parent->child = n->next;
1068 if (n->parent->last == n)
1069 n->parent->last = n->prev;
1070 }
1071
1072 /* Adjust parse point. */
1073
1074 if (man == NULL)
1075 return;
1076 if (man->last == n) {
1077 if (n->prev == NULL) {
1078 man->last = n->parent;
1079 man->next = ROFF_NEXT_CHILD;
1080 } else {
1081 man->last = n->prev;
1082 man->next = ROFF_NEXT_SIBLING;
1083 }
1084 }
1085 if (man->meta.first == n)
1086 man->meta.first = NULL;
1087 }
1088
1089 void
1090 roff_node_relink(struct roff_man *man, struct roff_node *n)
1091 {
1092 roff_node_unlink(man, n);
1093 n->prev = n->next = NULL;
1094 roff_node_append(man, n);
1095 }
1096
1097 void
1098 roff_node_free(struct roff_node *n)
1099 {
1100
1101 if (n->args != NULL)
1102 mdoc_argv_free(n->args);
1103 if (n->type == ROFFT_BLOCK || n->type == ROFFT_ELEM)
1104 free(n->norm);
1105 eqn_box_free(n->eqn);
1106 free(n->string);
1107 free(n->tag);
1108 free(n);
1109 }
1110
1111 void
1112 roff_node_delete(struct roff_man *man, struct roff_node *n)
1113 {
1114
1115 while (n->child != NULL)
1116 roff_node_delete(man, n->child);
1117 roff_node_unlink(man, n);
1118 roff_node_free(n);
1119 }
1120
1121 int
1122 roff_node_transparent(struct roff_node *n)
1123 {
1124 if (n == NULL)
1125 return 0;
1126 if (n->type == ROFFT_COMMENT || n->flags & NODE_NOPRT)
1127 return 1;
1128 return roff_tok_transparent(n->tok);
1129 }
1130
1131 int
1132 roff_tok_transparent(enum roff_tok tok)
1133 {
1134 switch (tok) {
1135 case ROFF_ft:
1136 case ROFF_ll:
1137 case ROFF_mc:
1138 case ROFF_po:
1139 case ROFF_ta:
1140 case MDOC_Db:
1141 case MDOC_Es:
1142 case MDOC_Sm:
1143 case MDOC_Tg:
1144 case MAN_DT:
1145 case MAN_UC:
1146 case MAN_PD:
1147 case MAN_AT:
1148 return 1;
1149 default:
1150 return 0;
1151 }
1152 }
1153
1154 struct roff_node *
1155 roff_node_child(struct roff_node *n)
1156 {
1157 for (n = n->child; roff_node_transparent(n); n = n->next)
1158 continue;
1159 return n;
1160 }
1161
1162 struct roff_node *
1163 roff_node_prev(struct roff_node *n)
1164 {
1165 do {
1166 n = n->prev;
1167 } while (roff_node_transparent(n));
1168 return n;
1169 }
1170
1171 struct roff_node *
1172 roff_node_next(struct roff_node *n)
1173 {
1174 do {
1175 n = n->next;
1176 } while (roff_node_transparent(n));
1177 return n;
1178 }
1179
1180 void
1181 deroff(char **dest, const struct roff_node *n)
1182 {
1183 char *cp;
1184 size_t sz;
1185
1186 if (n->string == NULL) {
1187 for (n = n->child; n != NULL; n = n->next)
1188 deroff(dest, n);
1189 return;
1190 }
1191
1192 /* Skip leading whitespace. */
1193
1194 for (cp = n->string; *cp != '\0'; cp++) {
1195 if (cp[0] == '\\' && cp[1] != '\0' &&
1196 strchr(" %&0^|~", cp[1]) != NULL)
1197 cp++;
1198 else if ( ! isspace((unsigned char)*cp))
1199 break;
1200 }
1201
1202 /* Skip trailing backslash. */
1203
1204 sz = strlen(cp);
1205 if (sz > 0 && cp[sz - 1] == '\\')
1206 sz--;
1207
1208 /* Skip trailing whitespace. */
1209
1210 for (; sz; sz--)
1211 if ( ! isspace((unsigned char)cp[sz-1]))
1212 break;
1213
1214 /* Skip empty strings. */
1215
1216 if (sz == 0)
1217 return;
1218
1219 if (*dest == NULL) {
1220 *dest = mandoc_strndup(cp, sz);
1221 return;
1222 }
1223
1224 mandoc_asprintf(&cp, "%s %*s", *dest, (int)sz, cp);
1225 free(*dest);
1226 *dest = cp;
1227 }
1228
1229 /* --- main functions of the roff parser ---------------------------------- */
1230
1231 /*
1232 * In the current line, expand escape sequences that produce parsable
1233 * input text. Also check the syntax of the remaining escape sequences,
1234 * which typically produce output glyphs or change formatter state.
1235 */
1236 static int
1237 roff_expand(struct roff *r, struct buf *buf, int ln, int pos, char newesc)
1238 {
1239 struct mctx *ctx; /* current macro call context */
1240 char ubuf[24]; /* buffer to print the number */
1241 struct roff_node *n; /* used for header comments */
1242 const char *start; /* start of the string to process */
1243 char *stesc; /* start of an escape sequence ('\\') */
1244 const char *esct; /* type of esccape sequence */
1245 char *ep; /* end of comment string */
1246 const char *stnam; /* start of the name, after "[(*" */
1247 const char *cp; /* end of the name, e.g. before ']' */
1248 const char *res; /* the string to be substituted */
1249 char *nbuf; /* new buffer to copy buf->buf to */
1250 size_t maxl; /* expected length of the escape name */
1251 size_t naml; /* actual length of the escape name */
1252 size_t asz; /* length of the replacement */
1253 size_t rsz; /* length of the rest of the string */
1254 int inaml; /* length returned from mandoc_escape() */
1255 int expand_count; /* to avoid infinite loops */
1256 int npos; /* position in numeric expression */
1257 int arg_complete; /* argument not interrupted by eol */
1258 int quote_args; /* true for \\$@, false for \\$* */
1259 int done; /* no more input available */
1260 int deftype; /* type of definition to paste */
1261 int rcsid; /* kind of RCS id seen */
1262 enum mandocerr err; /* for escape sequence problems */
1263 char sign; /* increment number register */
1264 char term; /* character terminating the escape */
1265
1266 /* Search forward for comments. */
1267
1268 done = 0;
1269 start = buf->buf + pos;
1270 for (stesc = buf->buf + pos; *stesc != '\0'; stesc++) {
1271 if (stesc[0] != newesc || stesc[1] == '\0')
1272 continue;
1273 stesc++;
1274 if (*stesc != '"' && *stesc != '#')
1275 continue;
1276
1277 /* Comment found, look for RCS id. */
1278
1279 rcsid = 0;
1280 if ((cp = strstr(stesc, "$" "OpenBSD")) != NULL) {
1281 rcsid = 1 << MANDOC_OS_OPENBSD;
1282 cp += 8;
1283 } else if ((cp = strstr(stesc, "$" "NetBSD")) != NULL) {
1284 rcsid = 1 << MANDOC_OS_NETBSD;
1285 cp += 7;
1286 }
1287 if (cp != NULL &&
1288 isalnum((unsigned char)*cp) == 0 &&
1289 strchr(cp, '$') != NULL) {
1290 if (r->man->meta.rcsids & rcsid)
1291 mandoc_msg(MANDOCERR_RCS_REP, ln,
1292 (int)(stesc - buf->buf) + 1,
1293 "%s", stesc + 1);
1294 r->man->meta.rcsids |= rcsid;
1295 }
1296
1297 /* Handle trailing whitespace. */
1298
1299 ep = strchr(stesc--, '\0') - 1;
1300 if (*ep == '\n') {
1301 done = 1;
1302 ep--;
1303 }
1304 if (*ep == ' ' || *ep == '\t')
1305 mandoc_msg(MANDOCERR_SPACE_EOL,
1306 ln, (int)(ep - buf->buf), NULL);
1307
1308 /*
1309 * Save comments preceding the title macro
1310 * in the syntax tree.
1311 */
1312
1313 if (newesc != ASCII_ESC && r->options & MPARSE_COMMENT) {
1314 while (*ep == ' ' || *ep == '\t')
1315 ep--;
1316 ep[1] = '\0';
1317 n = roff_node_alloc(r->man,
1318 ln, stesc + 1 - buf->buf,
1319 ROFFT_COMMENT, TOKEN_NONE);
1320 n->string = mandoc_strdup(stesc + 2);
1321 roff_node_append(r->man, n);
1322 n->flags |= NODE_VALID | NODE_ENDED;
1323 r->man->next = ROFF_NEXT_SIBLING;
1324 }
1325
1326 /* Line continuation with comment. */
1327
1328 if (stesc[1] == '#') {
1329 *stesc = '\0';
1330 return ROFF_IGN | ROFF_APPEND;
1331 }
1332
1333 /* Discard normal comments. */
1334
1335 while (stesc > start && stesc[-1] == ' ' &&
1336 (stesc == start + 1 || stesc[-2] != '\\'))
1337 stesc--;
1338 *stesc = '\0';
1339 break;
1340 }
1341 if (stesc == start)
1342 return ROFF_CONT;
1343 stesc--;
1344
1345 /* Notice the end of the input. */
1346
1347 if (*stesc == '\n') {
1348 *stesc-- = '\0';
1349 done = 1;
1350 }
1351
1352 expand_count = 0;
1353 while (stesc >= start) {
1354 if (*stesc != newesc) {
1355
1356 /*
1357 * If we have a non-standard escape character,
1358 * escape literal backslashes because all
1359 * processing in subsequent functions uses
1360 * the standard escaping rules.
1361 */
1362
1363 if (newesc != ASCII_ESC && *stesc == '\\') {
1364 *stesc = '\0';
1365 buf->sz = mandoc_asprintf(&nbuf, "%s\\e%s",
1366 buf->buf, stesc + 1) + 1;
1367 start = nbuf + pos;
1368 stesc = nbuf + (stesc - buf->buf);
1369 free(buf->buf);
1370 buf->buf = nbuf;
1371 }
1372
1373 /* Search backwards for the next escape. */
1374
1375 stesc--;
1376 continue;
1377 }
1378
1379 /* If it is escaped, skip it. */
1380
1381 for (cp = stesc - 1; cp >= start; cp--)
1382 if (*cp != r->escape)
1383 break;
1384
1385 if ((stesc - cp) % 2 == 0) {
1386 while (stesc > cp)
1387 *stesc-- = '\\';
1388 continue;
1389 } else if (stesc[1] != '\0') {
1390 *stesc = '\\';
1391 } else {
1392 *stesc-- = '\0';
1393 if (done)
1394 continue;
1395 else
1396 return ROFF_IGN | ROFF_APPEND;
1397 }
1398
1399 /* Decide whether to expand or to check only. */
1400
1401 term = '\0';
1402 cp = stesc + 1;
1403 if (*cp == 'E')
1404 cp++;
1405 esct = cp;
1406 switch (*esct) {
1407 case '*':
1408 case '$':
1409 res = NULL;
1410 break;
1411 case 'B':
1412 case 'w':
1413 term = cp[1];
1414 /* FALLTHROUGH */
1415 case 'n':
1416 sign = cp[1];
1417 if (sign == '+' || sign == '-')
1418 cp++;
1419 res = ubuf;
1420 break;
1421 default:
1422 err = MANDOCERR_OK;
1423 switch(mandoc_escape(&cp, &stnam, &inaml)) {
1424 case ESCAPE_SPECIAL:
1425 if (mchars_spec2cp(stnam, inaml) >= 0)
1426 break;
1427 /* FALLTHROUGH */
1428 case ESCAPE_ERROR:
1429 err = MANDOCERR_ESC_BAD;
1430 break;
1431 case ESCAPE_UNDEF:
1432 err = MANDOCERR_ESC_UNDEF;
1433 break;
1434 case ESCAPE_UNSUPP:
1435 err = MANDOCERR_ESC_UNSUPP;
1436 break;
1437 default:
1438 break;
1439 }
1440 if (err != MANDOCERR_OK)
1441 mandoc_msg(err, ln, (int)(stesc - buf->buf),
1442 "%.*s", (int)(cp - stesc), stesc);
1443 stesc--;
1444 continue;
1445 }
1446
1447 if (EXPAND_LIMIT < ++expand_count) {
1448 mandoc_msg(MANDOCERR_ROFFLOOP,
1449 ln, (int)(stesc - buf->buf), NULL);
1450 return ROFF_IGN;
1451 }
1452
1453 /*
1454 * The third character decides the length
1455 * of the name of the string or register.
1456 * Save a pointer to the name.
1457 */
1458
1459 if (term == '\0') {
1460 switch (*++cp) {
1461 case '\0':
1462 maxl = 0;
1463 break;
1464 case '(':
1465 cp++;
1466 maxl = 2;
1467 break;
1468 case '[':
1469 cp++;
1470 term = ']';
1471 maxl = 0;
1472 break;
1473 default:
1474 maxl = 1;
1475 break;
1476 }
1477 } else {
1478 cp += 2;
1479 maxl = 0;
1480 }
1481 stnam = cp;
1482
1483 /* Advance to the end of the name. */
1484
1485 naml = 0;
1486 arg_complete = 1;
1487 while (maxl == 0 || naml < maxl) {
1488 if (*cp == '\0') {
1489 mandoc_msg(MANDOCERR_ESC_BAD, ln,
1490 (int)(stesc - buf->buf), "%s", stesc);
1491 arg_complete = 0;
1492 break;
1493 }
1494 if (maxl == 0 && *cp == term) {
1495 cp++;
1496 break;
1497 }
1498 if (*cp++ != '\\' || *esct != 'w') {
1499 naml++;
1500 continue;
1501 }
1502 switch (mandoc_escape(&cp, NULL, NULL)) {
1503 case ESCAPE_SPECIAL:
1504 case ESCAPE_UNICODE:
1505 case ESCAPE_NUMBERED:
1506 case ESCAPE_UNDEF:
1507 case ESCAPE_OVERSTRIKE:
1508 naml++;
1509 break;
1510 default:
1511 break;
1512 }
1513 }
1514
1515 /*
1516 * Retrieve the replacement string; if it is
1517 * undefined, resume searching for escapes.
1518 */
1519
1520 switch (*esct) {
1521 case '*':
1522 if (arg_complete) {
1523 deftype = ROFFDEF_USER | ROFFDEF_PRE;
1524 res = roff_getstrn(r, stnam, naml, &deftype);
1525
1526 /*
1527 * If not overriden, let \*(.T
1528 * through to the formatters.
1529 */
1530
1531 if (res == NULL && naml == 2 &&
1532 stnam[0] == '.' && stnam[1] == 'T') {
1533 roff_setstrn(&r->strtab,
1534 ".T", 2, NULL, 0, 0);
1535 stesc--;
1536 continue;
1537 }
1538 }
1539 break;
1540 case '$':
1541 if (r->mstackpos < 0) {
1542 mandoc_msg(MANDOCERR_ARG_UNDEF, ln,
1543 (int)(stesc - buf->buf), "%.3s", stesc);
1544 break;
1545 }
1546 ctx = r->mstack + r->mstackpos;
1547 npos = esct[1] - '1';
1548 if (npos >= 0 && npos <= 8) {
1549 res = npos < ctx->argc ?
1550 ctx->argv[npos] : "";
1551 break;
1552 }
1553 if (esct[1] == '*')
1554 quote_args = 0;
1555 else if (esct[1] == '@')
1556 quote_args = 1;
1557 else {
1558 mandoc_msg(MANDOCERR_ARG_NONUM, ln,
1559 (int)(stesc - buf->buf), "%.3s", stesc);
1560 break;
1561 }
1562 asz = 0;
1563 for (npos = 0; npos < ctx->argc; npos++) {
1564 if (npos)
1565 asz++; /* blank */
1566 if (quote_args)
1567 asz += 2; /* quotes */
1568 asz += strlen(ctx->argv[npos]);
1569 }
1570 if (asz != 3) {
1571 rsz = buf->sz - (stesc - buf->buf) - 3;
1572 if (asz < 3)
1573 memmove(stesc + asz, stesc + 3, rsz);
1574 buf->sz += asz - 3;
1575 nbuf = mandoc_realloc(buf->buf, buf->sz);
1576 start = nbuf + pos;
1577 stesc = nbuf + (stesc - buf->buf);
1578 buf->buf = nbuf;
1579 if (asz > 3)
1580 memmove(stesc + asz, stesc + 3, rsz);
1581 }
1582 for (npos = 0; npos < ctx->argc; npos++) {
1583 if (npos)
1584 *stesc++ = ' ';
1585 if (quote_args)
1586 *stesc++ = '"';
1587 cp = ctx->argv[npos];
1588 while (*cp != '\0')
1589 *stesc++ = *cp++;
1590 if (quote_args)
1591 *stesc++ = '"';
1592 }
1593 continue;
1594 case 'B':
1595 npos = 0;
1596 ubuf[0] = arg_complete &&
1597 roff_evalnum(r, ln, stnam, &npos,
1598 NULL, ROFFNUM_SCALE) &&
1599 stnam + npos + 1 == cp ? '1' : '0';
1600 ubuf[1] = '\0';
1601 break;
1602 case 'n':
1603 if (arg_complete)
1604 (void)snprintf(ubuf, sizeof(ubuf), "%d",
1605 roff_getregn(r, stnam, naml, sign));
1606 else
1607 ubuf[0] = '\0';
1608 break;
1609 case 'w':
1610 /* use even incomplete args */
1611 (void)snprintf(ubuf, sizeof(ubuf), "%d",
1612 24 * (int)naml);
1613 break;
1614 }
1615
1616 if (res == NULL) {
1617 if (*esct == '*')
1618 mandoc_msg(MANDOCERR_STR_UNDEF,
1619 ln, (int)(stesc - buf->buf),
1620 "%.*s", (int)naml, stnam);
1621 res = "";
1622 } else if (buf->sz + strlen(res) > SHRT_MAX) {
1623 mandoc_msg(MANDOCERR_ROFFLOOP,
1624 ln, (int)(stesc - buf->buf), NULL);
1625 return ROFF_IGN;
1626 }
1627
1628 /* Replace the escape sequence by the string. */
1629
1630 *stesc = '\0';
1631 buf->sz = mandoc_asprintf(&nbuf, "%s%s%s",
1632 buf->buf, res, cp) + 1;
1633
1634 /* Prepare for the next replacement. */
1635
1636 start = nbuf + pos;
1637 stesc = nbuf + (stesc - buf->buf) + strlen(res);
1638 free(buf->buf);
1639 buf->buf = nbuf;
1640 }
1641 return ROFF_CONT;
1642 }
1643
1644 /*
1645 * Parse a quoted or unquoted roff-style request or macro argument.
1646 * Return a pointer to the parsed argument, which is either the original
1647 * pointer or advanced by one byte in case the argument is quoted.
1648 * NUL-terminate the argument in place.
1649 * Collapse pairs of quotes inside quoted arguments.
1650 * Advance the argument pointer to the next argument,
1651 * or to the NUL byte terminating the argument line.
1652 */
1653 char *
1654 roff_getarg(struct roff *r, char **cpp, int ln, int *pos)
1655 {
1656 struct buf buf;
1657 char *cp, *start;
1658 int newesc, pairs, quoted, white;
1659
1660 /* Quoting can only start with a new word. */
1661 start = *cpp;
1662 quoted = 0;
1663 if ('"' == *start) {
1664 quoted = 1;
1665 start++;
1666 }
1667
1668 newesc = pairs = white = 0;
1669 for (cp = start; '\0' != *cp; cp++) {
1670
1671 /*
1672 * Move the following text left
1673 * after quoted quotes and after "\\" and "\t".
1674 */
1675 if (pairs)
1676 cp[-pairs] = cp[0];
1677
1678 if ('\\' == cp[0]) {
1679 /*
1680 * In copy mode, translate double to single
1681 * backslashes and backslash-t to literal tabs.
1682 */
1683 switch (cp[1]) {
1684 case 'a':
1685 case 't':
1686 cp[-pairs] = '\t';
1687 pairs++;
1688 cp++;
1689 break;
1690 case '\\':
1691 newesc = 1;
1692 cp[-pairs] = ASCII_ESC;
1693 pairs++;
1694 cp++;
1695 break;
1696 case ' ':
1697 /* Skip escaped blanks. */
1698 if (0 == quoted)
1699 cp++;
1700 break;
1701 default:
1702 break;
1703 }
1704 } else if (0 == quoted) {
1705 if (' ' == cp[0]) {
1706 /* Unescaped blanks end unquoted args. */
1707 white = 1;
1708 break;
1709 }
1710 } else if ('"' == cp[0]) {
1711 if ('"' == cp[1]) {
1712 /* Quoted quotes collapse. */
1713 pairs++;
1714 cp++;
1715 } else {
1716 /* Unquoted quotes end quoted args. */
1717 quoted = 2;
1718 break;
1719 }
1720 }
1721 }
1722
1723 /* Quoted argument without a closing quote. */
1724 if (1 == quoted)
1725 mandoc_msg(MANDOCERR_ARG_QUOTE, ln, *pos, NULL);
1726
1727 /* NUL-terminate this argument and move to the next one. */
1728 if (pairs)
1729 cp[-pairs] = '\0';
1730 if ('\0' != *cp) {
1731 *cp++ = '\0';
1732 while (' ' == *cp)
1733 cp++;
1734 }
1735 *pos += (int)(cp - start) + (quoted ? 1 : 0);
1736 *cpp = cp;
1737
1738 if ('\0' == *cp && (white || ' ' == cp[-1]))
1739 mandoc_msg(MANDOCERR_SPACE_EOL, ln, *pos, NULL);
1740
1741 start = mandoc_strdup(start);
1742 if (newesc == 0)
1743 return start;
1744
1745 buf.buf = start;
1746 buf.sz = strlen(start) + 1;
1747 buf.next = NULL;
1748 if (roff_expand(r, &buf, ln, 0, ASCII_ESC) & ROFF_IGN) {
1749 free(buf.buf);
1750 buf.buf = mandoc_strdup("");
1751 }
1752 return buf.buf;
1753 }
1754
1755
1756 /*
1757 * Process text streams.
1758 */
1759 static int
1760 roff_parsetext(struct roff *r, struct buf *buf, int pos, int *offs)
1761 {
1762 size_t sz;
1763 const char *start;
1764 char *p;
1765 int isz;
1766 enum mandoc_esc esc;
1767
1768 /* Spring the input line trap. */
1769
1770 if (roffit_lines == 1) {
1771 isz = mandoc_asprintf(&p, "%s\n.%s", buf->buf, roffit_macro);
1772 free(buf->buf);
1773 buf->buf = p;
1774 buf->sz = isz + 1;
1775 *offs = 0;
1776 free(roffit_macro);
1777 roffit_lines = 0;
1778 return ROFF_REPARSE;
1779 } else if (roffit_lines > 1)
1780 --roffit_lines;
1781
1782 if (roffce_node != NULL && buf->buf[pos] != '\0') {
1783 if (roffce_lines < 1) {
1784 r->man->last = roffce_node;
1785 r->man->next = ROFF_NEXT_SIBLING;
1786 roffce_lines = 0;
1787 roffce_node = NULL;
1788 } else
1789 roffce_lines--;
1790 }
1791
1792 /* Convert all breakable hyphens into ASCII_HYPH. */
1793
1794 start = p = buf->buf + pos;
1795
1796 while (*p != '\0') {
1797 sz = strcspn(p, "-\\");
1798 p += sz;
1799
1800 if (*p == '\0')
1801 break;
1802
1803 if (*p == '\\') {
1804 /* Skip over escapes. */
1805 p++;
1806 esc = mandoc_escape((const char **)&p, NULL, NULL);
1807 if (esc == ESCAPE_ERROR)
1808 break;
1809 while (*p == '-')
1810 p++;
1811 continue;
1812 } else if (p == start) {
1813 p++;
1814 continue;
1815 }
1816
1817 if (isalpha((unsigned char)p[-1]) &&
1818 isalpha((unsigned char)p[1]))
1819 *p = ASCII_HYPH;
1820 p++;
1821 }
1822 return ROFF_CONT;
1823 }
1824
1825 int
1826 roff_parseln(struct roff *r, int ln, struct buf *buf, int *offs, size_t len)
1827 {
1828 enum roff_tok t;
1829 int e;
1830 int pos; /* parse point */
1831 int spos; /* saved parse point for messages */
1832 int ppos; /* original offset in buf->buf */
1833 int ctl; /* macro line (boolean) */
1834
1835 ppos = pos = *offs;
1836
1837 if (len > 80 && r->tbl == NULL && r->eqn == NULL &&
1838 (r->man->flags & ROFF_NOFILL) == 0 &&
1839 strchr(" .\\", buf->buf[pos]) == NULL &&
1840 buf->buf[pos] != r->control &&
1841 strcspn(buf->buf, " ") < 80)
1842 mandoc_msg(MANDOCERR_TEXT_LONG, ln, (int)len - 1,
1843 "%.20s...", buf->buf + pos);
1844
1845 /* Handle in-line equation delimiters. */
1846
1847 if (r->tbl == NULL &&
1848 r->last_eqn != NULL && r->last_eqn->delim &&
1849 (r->eqn == NULL || r->eqn_inline)) {
1850 e = roff_eqndelim(r, buf, pos);
1851 if (e == ROFF_REPARSE)
1852 return e;
1853 assert(e == ROFF_CONT);
1854 }
1855
1856 /* Expand some escape sequences. */
1857
1858 e = roff_expand(r, buf, ln, pos, r->escape);
1859 if ((e & ROFF_MASK) == ROFF_IGN)
1860 return e;
1861 assert(e == ROFF_CONT);
1862
1863 ctl = roff_getcontrol(r, buf->buf, &pos);
1864
1865 /*
1866 * First, if a scope is open and we're not a macro, pass the
1867 * text through the macro's filter.
1868 * Equations process all content themselves.
1869 * Tables process almost all content themselves, but we want
1870 * to warn about macros before passing it there.
1871 */
1872
1873 if (r->last != NULL && ! ctl) {
1874 t = r->last->tok;
1875 e = (*roffs[t].text)(r, t, buf, ln, pos, pos, offs);
1876 if ((e & ROFF_MASK) == ROFF_IGN)
1877 return e;
1878 e &= ~ROFF_MASK;
1879 } else
1880 e = ROFF_IGN;
1881 if (r->eqn != NULL && strncmp(buf->buf + ppos, ".EN", 3)) {
1882 eqn_read(r->eqn, buf->buf + ppos);
1883 return e;
1884 }
1885 if (r->tbl != NULL && (ctl == 0 || buf->buf[pos] == '\0')) {
1886 tbl_read(r->tbl, ln, buf->buf, ppos);
1887 roff_addtbl(r->man, ln, r->tbl);
1888 return e;
1889 }
1890 if ( ! ctl) {
1891 r->options &= ~MPARSE_COMMENT;
1892 return roff_parsetext(r, buf, pos, offs) | e;
1893 }
1894
1895 /* Skip empty request lines. */
1896
1897 if (buf->buf[pos] == '"') {
1898 mandoc_msg(MANDOCERR_COMMENT_BAD, ln, pos, NULL);
1899 return ROFF_IGN;
1900 } else if (buf->buf[pos] == '\0')
1901 return ROFF_IGN;
1902
1903 /*
1904 * If a scope is open, go to the child handler for that macro,
1905 * as it may want to preprocess before doing anything with it.
1906 * Don't do so if an equation is open.
1907 */
1908
1909 if (r->last) {
1910 t = r->last->tok;
1911 return (*roffs[t].sub)(r, t, buf, ln, ppos, pos, offs);
1912 }
1913
1914 /* No scope is open. This is a new request or macro. */
1915
1916 r->options &= ~MPARSE_COMMENT;
1917 spos = pos;
1918 t = roff_parse(r, buf->buf, &pos, ln, ppos);
1919
1920 /* Tables ignore most macros. */
1921
1922 if (r->tbl != NULL && (t == TOKEN_NONE || t == ROFF_TS ||
1923 t == ROFF_br || t == ROFF_ce || t == ROFF_rj || t == ROFF_sp)) {
1924 mandoc_msg(MANDOCERR_TBLMACRO,
1925 ln, pos, "%s", buf->buf + spos);
1926 if (t != TOKEN_NONE)
1927 return ROFF_IGN;
1928 while (buf->buf[pos] != '\0' && buf->buf[pos] != ' ')
1929 pos++;
1930 while (buf->buf[pos] == ' ')
1931 pos++;
1932 tbl_read(r->tbl, ln, buf->buf, pos);
1933 roff_addtbl(r->man, ln, r->tbl);
1934 return ROFF_IGN;
1935 }
1936
1937 /* For now, let high level macros abort .ce mode. */
1938
1939 if (ctl && roffce_node != NULL &&
1940 (t == TOKEN_NONE || t == ROFF_Dd || t == ROFF_EQ ||
1941 t == ROFF_TH || t == ROFF_TS)) {
1942 r->man->last = roffce_node;
1943 r->man->next = ROFF_NEXT_SIBLING;
1944 roffce_lines = 0;
1945 roffce_node = NULL;
1946 }
1947
1948 /*
1949 * This is neither a roff request nor a user-defined macro.
1950 * Let the standard macro set parsers handle it.
1951 */
1952
1953 if (t == TOKEN_NONE)
1954 return ROFF_CONT;
1955
1956 /* Execute a roff request or a user defined macro. */
1957
1958 return (*roffs[t].proc)(r, t, buf, ln, spos, pos, offs);
1959 }
1960
1961 /*
1962 * Internal interface function to tell the roff parser that execution
1963 * of the current macro ended. This is required because macro
1964 * definitions usually do not end with a .return request.
1965 */
1966 void
1967 roff_userret(struct roff *r)
1968 {
1969 struct mctx *ctx;
1970 int i;
1971
1972 assert(r->mstackpos >= 0);
1973 ctx = r->mstack + r->mstackpos;
1974 for (i = 0; i < ctx->argc; i++)
1975 free(ctx->argv[i]);
1976 ctx->argc = 0;
1977 r->mstackpos--;
1978 }
1979
1980 void
1981 roff_endparse(struct roff *r)
1982 {
1983 if (r->last != NULL)
1984 mandoc_msg(MANDOCERR_BLK_NOEND, r->last->line,
1985 r->last->col, "%s", roff_name[r->last->tok]);
1986
1987 if (r->eqn != NULL) {
1988 mandoc_msg(MANDOCERR_BLK_NOEND,
1989 r->eqn->node->line, r->eqn->node->pos, "EQ");
1990 eqn_parse(r->eqn);
1991 r->eqn = NULL;
1992 }
1993
1994 if (r->tbl != NULL) {
1995 tbl_end(r->tbl, 1);
1996 r->tbl = NULL;
1997 }
1998 }
1999
2000 /*
2001 * Parse a roff node's type from the input buffer. This must be in the
2002 * form of ".foo xxx" in the usual way.
2003 */
2004 static enum roff_tok
2005 roff_parse(struct roff *r, char *buf, int *pos, int ln, int ppos)
2006 {
2007 char *cp;
2008 const char *mac;
2009 size_t maclen;
2010 int deftype;
2011 enum roff_tok t;
2012
2013 cp = buf + *pos;
2014
2015 if ('\0' == *cp || '"' == *cp || '\t' == *cp || ' ' == *cp)
2016 return TOKEN_NONE;
2017
2018 mac = cp;
2019 maclen = roff_getname(r, &cp, ln, ppos);
2020
2021 deftype = ROFFDEF_USER | ROFFDEF_REN;
2022 r->current_string = roff_getstrn(r, mac, maclen, &deftype);
2023 switch (deftype) {
2024 case ROFFDEF_USER:
2025 t = ROFF_USERDEF;
2026 break;
2027 case ROFFDEF_REN:
2028 t = ROFF_RENAMED;
2029 break;
2030 default:
2031 t = roffhash_find(r->reqtab, mac, maclen);
2032 break;
2033 }
2034 if (t != TOKEN_NONE)
2035 *pos = cp - buf;
2036 else if (deftype == ROFFDEF_UNDEF) {
2037 /* Using an undefined macro defines it to be empty. */
2038 roff_setstrn(&r->strtab, mac, maclen, "", 0, 0);
2039 roff_setstrn(&r->rentab, mac, maclen, NULL, 0, 0);
2040 }
2041 return t;
2042 }
2043
2044 /* --- handling of request blocks ----------------------------------------- */
2045
2046 /*
2047 * Close a macro definition block or an "ignore" block.
2048 */
2049 static int
2050 roff_cblock(ROFF_ARGS)
2051 {
2052 int rr;
2053
2054 if (r->last == NULL) {
2055 mandoc_msg(MANDOCERR_BLK_NOTOPEN, ln, ppos, "..");
2056 return ROFF_IGN;
2057 }
2058
2059 switch (r->last->tok) {
2060 case ROFF_am:
2061 case ROFF_ami:
2062 case ROFF_de:
2063 case ROFF_dei:
2064 case ROFF_ig:
2065 break;
2066 case ROFF_am1:
2067 case ROFF_de1:
2068 /* Remapped in roff_block(). */
2069 abort();
2070 default:
2071 mandoc_msg(MANDOCERR_BLK_NOTOPEN, ln, ppos, "..");
2072 return ROFF_IGN;
2073 }
2074
2075 roffnode_pop(r);
2076 roffnode_cleanscope(r);
2077
2078 /*
2079 * If a conditional block with braces is still open,
2080 * check for "\}" block end markers.
2081 */
2082
2083 if (r->last != NULL && r->last->endspan < 0) {
2084 rr = 1; /* If arguments follow "\}", warn about them. */
2085 roff_cond_checkend(r, tok, buf, ln, ppos, pos, &rr);
2086 }
2087
2088 if (buf->buf[pos] != '\0')
2089 mandoc_msg(MANDOCERR_ARG_SKIP, ln, pos,
2090 ".. %s", buf->buf + pos);
2091
2092 return ROFF_IGN;
2093 }
2094
2095 /*
2096 * Pop all nodes ending at the end of the current input line.
2097 * Return the number of loops ended.
2098 */
2099 static int
2100 roffnode_cleanscope(struct roff *r)
2101 {
2102 int inloop;
2103
2104 inloop = 0;
2105 while (r->last != NULL && r->last->endspan > 0) {
2106 if (--r->last->endspan != 0)
2107 break;
2108 inloop += roffnode_pop(r);
2109 }
2110 return inloop;
2111 }
2112
2113 /*
2114 * Handle the closing "\}" of a conditional block.
2115 * Apart from generating warnings, this only pops nodes.
2116 * Return the number of loops ended.
2117 */
2118 static int
2119 roff_ccond(struct roff *r, int ln, int ppos)
2120 {
2121 if (NULL == r->last) {
2122 mandoc_msg(MANDOCERR_BLK_NOTOPEN, ln, ppos, "\\}");
2123 return 0;
2124 }
2125
2126 switch (r->last->tok) {
2127 case ROFF_el:
2128 case ROFF_ie:
2129 case ROFF_if:
2130 case ROFF_while:
2131 break;
2132 default:
2133 mandoc_msg(MANDOCERR_BLK_NOTOPEN, ln, ppos, "\\}");
2134 return 0;
2135 }
2136
2137 if (r->last->endspan > -1) {
2138 mandoc_msg(MANDOCERR_BLK_NOTOPEN, ln, ppos, "\\}");
2139 return 0;
2140 }
2141
2142 return roffnode_pop(r) + roffnode_cleanscope(r);
2143 }
2144
2145 static int
2146 roff_block(ROFF_ARGS)
2147 {
2148 const char *name, *value;
2149 char *call, *cp, *iname, *rname;
2150 size_t csz, namesz, rsz;
2151 int deftype;
2152
2153 /* Ignore groff compatibility mode for now. */
2154
2155 if (tok == ROFF_de1)
2156 tok = ROFF_de;
2157 else if (tok == ROFF_dei1)
2158 tok = ROFF_dei;
2159 else if (tok == ROFF_am1)
2160 tok = ROFF_am;
2161 else if (tok == ROFF_ami1)
2162 tok = ROFF_ami;
2163
2164 /* Parse the macro name argument. */
2165
2166 cp = buf->buf + pos;
2167 if (tok == ROFF_ig) {
2168 iname = NULL;
2169 namesz = 0;
2170 } else {
2171 iname = cp;
2172 namesz = roff_getname(r, &cp, ln, ppos);
2173 iname[namesz] = '\0';
2174 }
2175
2176 /* Resolve the macro name argument if it is indirect. */
2177
2178 if (namesz && (tok == ROFF_dei || tok == ROFF_ami)) {
2179 deftype = ROFFDEF_USER;
2180 name = roff_getstrn(r, iname, namesz, &deftype);
2181 if (name == NULL) {
2182 mandoc_msg(MANDOCERR_STR_UNDEF,
2183 ln, (int)(iname - buf->buf),
2184 "%.*s", (int)namesz, iname);
2185 namesz = 0;
2186 } else
2187 namesz = strlen(name);
2188 } else
2189 name = iname;
2190
2191 if (namesz == 0 && tok != ROFF_ig) {
2192 mandoc_msg(MANDOCERR_REQ_EMPTY,
2193 ln, ppos, "%s", roff_name[tok]);
2194 return ROFF_IGN;
2195 }
2196
2197 roffnode_push(r, tok, name, ln, ppos);
2198
2199 /*
2200 * At the beginning of a `de' macro, clear the existing string
2201 * with the same name, if there is one. New content will be
2202 * appended from roff_block_text() in multiline mode.
2203 */
2204
2205 if (tok == ROFF_de || tok == ROFF_dei) {
2206 roff_setstrn(&r->strtab, name, namesz, "", 0, 0);
2207 roff_setstrn(&r->rentab, name, namesz, NULL, 0, 0);
2208 } else if (tok == ROFF_am || tok == ROFF_ami) {
2209 deftype = ROFFDEF_ANY;
2210 value = roff_getstrn(r, iname, namesz, &deftype);
2211 switch (deftype) { /* Before appending, ... */
2212 case ROFFDEF_PRE: /* copy predefined to user-defined. */
2213 roff_setstrn(&r->strtab, name, namesz,
2214 value, strlen(value), 0);
2215 break;
2216 case ROFFDEF_REN: /* call original standard macro. */
2217 csz = mandoc_asprintf(&call, ".%.*s \\$* \\\"\n",
2218 (int)strlen(value), value);
2219 roff_setstrn(&r->strtab, name, namesz, call, csz, 0);
2220 roff_setstrn(&r->rentab, name, namesz, NULL, 0, 0);
2221 free(call);
2222 break;
2223 case ROFFDEF_STD: /* rename and call standard macro. */
2224 rsz = mandoc_asprintf(&rname, "__%s_renamed", name);
2225 roff_setstrn(&r->rentab, rname, rsz, name, namesz, 0);
2226 csz = mandoc_asprintf(&call, ".%.*s \\$* \\\"\n",
2227 (int)rsz, rname);
2228 roff_setstrn(&r->strtab, name, namesz, call, csz, 0);
2229 free(call);
2230 free(rname);
2231 break;
2232 default:
2233 break;
2234 }
2235 }
2236
2237 if (*cp == '\0')
2238 return ROFF_IGN;
2239
2240 /* Get the custom end marker. */
2241
2242 iname = cp;
2243 namesz = roff_getname(r, &cp, ln, ppos);
2244
2245 /* Resolve the end marker if it is indirect. */
2246
2247 if (namesz && (tok == ROFF_dei || tok == ROFF_ami)) {
2248 deftype = ROFFDEF_USER;
2249 name = roff_getstrn(r, iname, namesz, &deftype);
2250 if (name == NULL) {
2251 mandoc_msg(MANDOCERR_STR_UNDEF,
2252 ln, (int)(iname - buf->buf),
2253 "%.*s", (int)namesz, iname);
2254 namesz = 0;
2255 } else
2256 namesz = strlen(name);
2257 } else
2258 name = iname;
2259
2260 if (namesz)
2261 r->last->end = mandoc_strndup(name, namesz);
2262
2263 if (*cp != '\0')
2264 mandoc_msg(MANDOCERR_ARG_EXCESS,
2265 ln, pos, ".%s ... %s", roff_name[tok], cp);
2266
2267 return ROFF_IGN;
2268 }
2269
2270 static int
2271 roff_block_sub(ROFF_ARGS)
2272 {
2273 enum roff_tok t;
2274 int i, j;
2275
2276 /*
2277 * First check whether a custom macro exists at this level. If
2278 * it does, then check against it. This is some of groff's
2279 * stranger behaviours. If we encountered a custom end-scope
2280 * tag and that tag also happens to be a "real" macro, then we
2281 * need to try interpreting it again as a real macro. If it's
2282 * not, then return ignore. Else continue.
2283 */
2284
2285 if (r->last->end) {
2286 for (i = pos, j = 0; r->last->end[j]; j++, i++)
2287 if (buf->buf[i] != r->last->end[j])
2288 break;
2289
2290 if (r->last->end[j] == '\0' &&
2291 (buf->buf[i] == '\0' ||
2292 buf->buf[i] == ' ' ||
2293 buf->buf[i] == '\t')) {
2294 roffnode_pop(r);
2295 roffnode_cleanscope(r);
2296
2297 while (buf->buf[i] == ' ' || buf->buf[i] == '\t')
2298 i++;
2299
2300 pos = i;
2301 if (roff_parse(r, buf->buf, &pos, ln, ppos) !=
2302 TOKEN_NONE)
2303 return ROFF_RERUN;
2304 return ROFF_IGN;
2305 }
2306 }
2307
2308 /*
2309 * If we have no custom end-query or lookup failed, then try
2310 * pulling it out of the hashtable.
2311 */
2312
2313 t = roff_parse(r, buf->buf, &pos, ln, ppos);
2314
2315 if (t != ROFF_cblock) {
2316 if (tok != ROFF_ig)
2317 roff_setstr(r, r->last->name, buf->buf + ppos, 2);
2318 return ROFF_IGN;
2319 }
2320
2321 return (*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs);
2322 }
2323
2324 static int
2325 roff_block_text(ROFF_ARGS)
2326 {
2327
2328 if (tok != ROFF_ig)
2329 roff_setstr(r, r->last->name, buf->buf + pos, 2);
2330
2331 return ROFF_IGN;
2332 }
2333
2334 /*
2335 * Check for a closing "\}" and handle it.
2336 * In this function, the final "int *offs" argument is used for
2337 * different purposes than elsewhere:
2338 * Input: *offs == 0: caller wants to discard arguments following \}
2339 * *offs == 1: caller wants to preserve text following \}
2340 * Output: *offs = 0: tell caller to discard input line
2341 * *offs = 1: tell caller to use input line
2342 */
2343 static int
2344 roff_cond_checkend(ROFF_ARGS)
2345 {
2346 char *ep;
2347 int endloop, irc, rr;
2348
2349 irc = ROFF_IGN;
2350 rr = r->last->rule;
2351 endloop = tok != ROFF_while ? ROFF_IGN :
2352 rr ? ROFF_LOOPCONT : ROFF_LOOPEXIT;
2353 if (roffnode_cleanscope(r))
2354 irc |= endloop;
2355
2356 /*
2357 * If "\}" occurs on a macro line without a preceding macro or
2358 * a text line contains nothing else, drop the line completely.
2359 */
2360
2361 ep = buf->buf + pos;
2362 if (ep[0] == '\\' && ep[1] == '}' && (ep[2] == '\0' || *offs == 0))
2363 rr = 0;
2364
2365 /*
2366 * The closing delimiter "\}" rewinds the conditional scope
2367 * but is otherwise ignored when interpreting the line.
2368 */
2369
2370 while ((ep = strchr(ep, '\\')) != NULL) {
2371 switch (ep[1]) {
2372 case '}':
2373 if (ep[2] == '\0')
2374 ep[0] = '\0';
2375 else if (rr)
2376 ep[1] = '&';
2377 else
2378 memmove(ep, ep + 2, strlen(ep + 2) + 1);
2379 if (roff_ccond(r, ln, ep - buf->buf))
2380 irc |= endloop;
2381 break;
2382 case '\0':
2383 ++ep;
2384 break;
2385 default:
2386 ep += 2;
2387 break;
2388 }
2389 }
2390 *offs = rr;
2391 return irc;
2392 }
2393
2394 /*
2395 * Parse and process a request or macro line in conditional scope.
2396 */
2397 static int
2398 roff_cond_sub(ROFF_ARGS)
2399 {
2400 struct roffnode *bl;
2401 int irc, rr;
2402 enum roff_tok t;
2403
2404 rr = 0; /* If arguments follow "\}", skip them. */
2405 irc = roff_cond_checkend(r, tok, buf, ln, ppos, pos, &rr);
2406 t = roff_parse(r, buf->buf, &pos, ln, ppos);
2407
2408 /* For now, let high level macros abort .ce mode. */
2409
2410 if (roffce_node != NULL &&
2411 (t == TOKEN_NONE || t == ROFF_Dd || t == ROFF_EQ ||
2412 t == ROFF_TH || t == ROFF_TS)) {
2413 r->man->last = roffce_node;
2414 r->man->next = ROFF_NEXT_SIBLING;
2415 roffce_lines = 0;
2416 roffce_node = NULL;
2417 }
2418
2419 /*
2420 * Fully handle known macros when they are structurally
2421 * required or when the conditional evaluated to true.
2422 */
2423
2424 if (t == ROFF_break) {
2425 if (irc & ROFF_LOOPMASK)
2426 irc = ROFF_IGN | ROFF_LOOPEXIT;
2427 else if (rr) {
2428 for (bl = r->last; bl != NULL; bl = bl->parent) {
2429 bl->rule = 0;
2430 if (bl->tok == ROFF_while)
2431 break;
2432 }
2433 }
2434 } else if (t != TOKEN_NONE &&
2435 (rr || roffs[t].flags & ROFFMAC_STRUCT))
2436 irc |= (*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs);
2437 else
2438 irc |= rr ? ROFF_CONT : ROFF_IGN;
2439 return irc;
2440 }
2441
2442 /*
2443 * Parse and process a text line in conditional scope.
2444 */
2445 static int
2446 roff_cond_text(ROFF_ARGS)
2447 {
2448 int irc, rr;
2449
2450 rr = 1; /* If arguments follow "\}", preserve them. */
2451 irc = roff_cond_checkend(r, tok, buf, ln, ppos, pos, &rr);
2452 if (rr)
2453 irc |= ROFF_CONT;
2454 return irc;
2455 }
2456
2457 /* --- handling of numeric and conditional expressions -------------------- */
2458
2459 /*
2460 * Parse a single signed integer number. Stop at the first non-digit.
2461 * If there is at least one digit, return success and advance the
2462 * parse point, else return failure and let the parse point unchanged.
2463 * Ignore overflows, treat them just like the C language.
2464 */
2465 static int
2466 roff_getnum(const char *v, int *pos, int *res, int flags)
2467 {
2468 int myres, scaled, n, p;
2469
2470 if (NULL == res)
2471 res = &myres;
2472
2473 p = *pos;
2474 n = v[p] == '-';
2475 if (n || v[p] == '+')
2476 p++;
2477
2478 if (flags & ROFFNUM_WHITE)
2479 while (isspace((unsigned char)v[p]))
2480 p++;
2481
2482 for (*res = 0; isdigit((unsigned char)v[p]); p++)
2483 *res = 10 * *res + v[p] - '0';
2484 if (p == *pos + n)
2485 return 0;
2486
2487 if (n)
2488 *res = -*res;
2489
2490 /* Each number may be followed by one optional scaling unit. */
2491
2492 switch (v[p]) {
2493 case 'f':
2494 scaled = *res * 65536;
2495 break;
2496 case 'i':
2497 scaled = *res * 240;
2498 break;
2499 case 'c':
2500 scaled = *res * 240 / 2.54;
2501 break;
2502 case 'v':
2503 case 'P':
2504 scaled = *res * 40;
2505 break;
2506 case 'm':
2507 case 'n':
2508 scaled = *res * 24;
2509 break;
2510 case 'p':
2511 scaled = *res * 10 / 3;
2512 break;
2513 case 'u':
2514 scaled = *res;
2515 break;
2516 case 'M':
2517 scaled = *res * 6 / 25;
2518 break;
2519 default:
2520 scaled = *res;
2521 p--;
2522 break;
2523 }
2524 if (flags & ROFFNUM_SCALE)
2525 *res = scaled;
2526
2527 *pos = p + 1;
2528 return 1;
2529 }
2530
2531 /*
2532 * Evaluate a string comparison condition.
2533 * The first character is the delimiter.
2534 * Succeed if the string up to its second occurrence
2535 * matches the string up to its third occurence.
2536 * Advance the cursor after the third occurrence
2537 * or lacking that, to the end of the line.
2538 */
2539 static int
2540 roff_evalstrcond(const char *v, int *pos)
2541 {
2542 const char *s1, *s2, *s3;
2543 int match;
2544
2545 match = 0;
2546 s1 = v + *pos; /* initial delimiter */
2547 s2 = s1 + 1; /* for scanning the first string */
2548 s3 = strchr(s2, *s1); /* for scanning the second string */
2549
2550 if (NULL == s3) /* found no middle delimiter */
2551 goto out;
2552
2553 while ('\0' != *++s3) {
2554 if (*s2 != *s3) { /* mismatch */
2555 s3 = strchr(s3, *s1);
2556 break;
2557 }
2558 if (*s3 == *s1) { /* found the final delimiter */
2559 match = 1;
2560 break;
2561 }
2562 s2++;
2563 }
2564
2565 out:
2566 if (NULL == s3)
2567 s3 = strchr(s2, '\0');
2568 else if (*s3 != '\0')
2569 s3++;
2570 *pos = s3 - v;
2571 return match;
2572 }
2573
2574 /*
2575 * Evaluate an optionally negated single character, numerical,
2576 * or string condition.
2577 */
2578 static int
2579 roff_evalcond(struct roff *r, int ln, char *v, int *pos)
2580 {
2581 const char *start, *end;
2582 char *cp, *name;
2583 size_t sz;
2584 int deftype, len, number, savepos, istrue, wanttrue;
2585
2586 if ('!' == v[*pos]) {
2587 wanttrue = 0;
2588 (*pos)++;
2589 } else
2590 wanttrue = 1;
2591
2592 switch (v[*pos]) {
2593 case '\0':
2594 return 0;
2595 case 'n':
2596 case 'o':
2597 (*pos)++;
2598 return wanttrue;
2599 case 'e':
2600 case 't':
2601 case 'v':
2602 (*pos)++;
2603 return !wanttrue;
2604 case 'c':
2605 do {
2606 (*pos)++;
2607 } while (v[*pos] == ' ');
2608
2609 /*
2610 * Quirk for groff compatibility:
2611 * The horizontal tab is neither available nor unavailable.
2612 */
2613
2614 if (v[*pos] == '\t') {
2615 (*pos)++;
2616 return 0;
2617 }
2618
2619 /* Printable ASCII characters are available. */
2620
2621 if (v[*pos] != '\\') {
2622 (*pos)++;
2623 return wanttrue;
2624 }
2625
2626 end = v + ++*pos;
2627 switch (mandoc_escape(&end, &start, &len)) {
2628 case ESCAPE_SPECIAL:
2629 istrue = mchars_spec2cp(start, len) != -1;
2630 break;
2631 case ESCAPE_UNICODE:
2632 istrue = 1;
2633 break;
2634 case ESCAPE_NUMBERED:
2635 istrue = mchars_num2char(start, len) != -1;
2636 break;
2637 default:
2638 istrue = !wanttrue;
2639 break;
2640 }
2641 *pos = end - v;
2642 return istrue == wanttrue;
2643 case 'd':
2644 case 'r':
2645 cp = v + *pos + 1;
2646 while (*cp == ' ')
2647 cp++;
2648 name = cp;
2649 sz = roff_getname(r, &cp, ln, cp - v);
2650 if (sz == 0)
2651 istrue = 0;
2652 else if (v[*pos] == 'r')
2653 istrue = roff_hasregn(r, name, sz);
2654 else {
2655 deftype = ROFFDEF_ANY;
2656 roff_getstrn(r, name, sz, &deftype);
2657 istrue = !!deftype;
2658 }
2659 *pos = (name + sz) - v;
2660 return istrue == wanttrue;
2661 default:
2662 break;
2663 }
2664
2665 savepos = *pos;
2666 if (roff_evalnum(r, ln, v, pos, &number, ROFFNUM_SCALE))
2667 return (number > 0) == wanttrue;
2668 else if (*pos == savepos)
2669 return roff_evalstrcond(v, pos) == wanttrue;
2670 else
2671 return 0;
2672 }
2673
2674 static int
2675 roff_line_ignore(ROFF_ARGS)
2676 {
2677
2678 return ROFF_IGN;
2679 }
2680
2681 static int
2682 roff_insec(ROFF_ARGS)
2683 {
2684
2685 mandoc_msg(MANDOCERR_REQ_INSEC, ln, ppos, "%s", roff_name[tok]);
2686 return ROFF_IGN;
2687 }
2688
2689 static int
2690 roff_unsupp(ROFF_ARGS)
2691 {
2692
2693 mandoc_msg(MANDOCERR_REQ_UNSUPP, ln, ppos, "%s", roff_name[tok]);
2694 return ROFF_IGN;
2695 }
2696
2697 static int
2698 roff_cond(ROFF_ARGS)
2699 {
2700 int irc;
2701
2702 roffnode_push(r, tok, NULL, ln, ppos);
2703
2704 /*
2705 * An `.el' has no conditional body: it will consume the value
2706 * of the current rstack entry set in prior `ie' calls or
2707 * defaults to DENY.
2708 *
2709 * If we're not an `el', however, then evaluate the conditional.
2710 */
2711
2712 r->last->rule = tok == ROFF_el ?
2713 (r->rstackpos < 0 ? 0 : r->rstack[r->rstackpos--]) :
2714 roff_evalcond(r, ln, buf->buf, &pos);
2715
2716 /*
2717 * An if-else will put the NEGATION of the current evaluated
2718 * conditional into the stack of rules.
2719 */
2720
2721 if (tok == ROFF_ie) {
2722 if (r->rstackpos + 1 == r->rstacksz) {
2723 r->rstacksz += 16;
2724 r->rstack = mandoc_reallocarray(r->rstack,
2725 r->rstacksz, sizeof(int));
2726 }
2727 r->rstack[++r->rstackpos] = !r->last->rule;
2728 }
2729
2730 /* If the parent has false as its rule, then so do we. */
2731
2732 if (r->last->parent && !r->last->parent->rule)
2733 r->last->rule = 0;
2734
2735 /*
2736 * Determine scope.
2737 * If there is nothing on the line after the conditional,
2738 * not even whitespace, use next-line scope.
2739 * Except that .while does not support next-line scope.
2740 */
2741
2742 if (buf->buf[pos] == '\0' && tok != ROFF_while) {
2743 r->last->endspan = 2;
2744 goto out;
2745 }
2746
2747 while (buf->buf[pos] == ' ')
2748 pos++;
2749
2750 /* An opening brace requests multiline scope. */
2751
2752 if (buf->buf[pos] == '\\' && buf->buf[pos + 1] == '{') {
2753 r->last->endspan = -1;
2754 pos += 2;
2755 while (buf->buf[pos] == ' ')
2756 pos++;
2757 goto out;
2758 }
2759
2760 /*
2761 * Anything else following the conditional causes
2762 * single-line scope. Warn if the scope contains
2763 * nothing but trailing whitespace.
2764 */
2765
2766 if (buf->buf[pos] == '\0')
2767 mandoc_msg(MANDOCERR_COND_EMPTY,
2768 ln, ppos, "%s", roff_name[tok]);
2769
2770 r->last->endspan = 1;
2771
2772 out:
2773 *offs = pos;
2774 irc = ROFF_RERUN;
2775 if (tok == ROFF_while)
2776 irc |= ROFF_WHILE;
2777 return irc;
2778 }
2779
2780 static int
2781 roff_ds(ROFF_ARGS)
2782 {
2783 char *string;
2784 const char *name;
2785 size_t namesz;
2786
2787 /* Ignore groff compatibility mode for now. */
2788
2789 if (tok == ROFF_ds1)
2790 tok = ROFF_ds;
2791 else if (tok == ROFF_as1)
2792 tok = ROFF_as;
2793
2794 /*
2795 * The first word is the name of the string.
2796 * If it is empty or terminated by an escape sequence,
2797 * abort the `ds' request without defining anything.
2798 */
2799
2800 name = string = buf->buf + pos;
2801 if (*name == '\0')
2802 return ROFF_IGN;
2803
2804 namesz = roff_getname(r, &string, ln, pos);
2805 switch (name[namesz]) {
2806 case '\\':
2807 return ROFF_IGN;
2808 case '\t':
2809 string = buf->buf + pos + namesz;
2810 break;
2811 default:
2812 break;
2813 }
2814
2815 /* Read past the initial double-quote, if any. */
2816 if (*string == '"')
2817 string++;
2818
2819 /* The rest is the value. */
2820 roff_setstrn(&r->strtab, name, namesz, string, strlen(string),
2821 ROFF_as == tok);
2822 roff_setstrn(&r->rentab, name, namesz, NULL, 0, 0);
2823 return ROFF_IGN;
2824 }
2825
2826 /*
2827 * Parse a single operator, one or two characters long.
2828 * If the operator is recognized, return success and advance the
2829 * parse point, else return failure and let the parse point unchanged.
2830 */
2831 static int
2832 roff_getop(const char *v, int *pos, char *res)
2833 {
2834
2835 *res = v[*pos];
2836
2837 switch (*res) {
2838 case '+':
2839 case '-':
2840 case '*':
2841 case '/':
2842 case '%':
2843 case '&':
2844 case ':':
2845 break;
2846 case '<':
2847 switch (v[*pos + 1]) {
2848 case '=':
2849 *res = 'l';
2850 (*pos)++;
2851 break;
2852 case '>':
2853 *res = '!';
2854 (*pos)++;
2855 break;
2856 case '?':
2857 *res = 'i';
2858 (*pos)++;
2859 break;
2860 default:
2861 break;
2862 }
2863 break;
2864 case '>':
2865 switch (v[*pos + 1]) {
2866 case '=':
2867 *res = 'g';
2868 (*pos)++;
2869 break;
2870 case '?':
2871 *res = 'a';
2872 (*pos)++;
2873 break;
2874 default:
2875 break;
2876 }
2877 break;
2878 case '=':
2879 if ('=' == v[*pos + 1])
2880 (*pos)++;
2881 break;
2882 default:
2883 return 0;
2884 }
2885 (*pos)++;
2886
2887 return *res;
2888 }
2889
2890 /*
2891 * Evaluate either a parenthesized numeric expression
2892 * or a single signed integer number.
2893 */
2894 static int
2895 roff_evalpar(struct roff *r, int ln,
2896 const char *v, int *pos, int *res, int flags)
2897 {
2898
2899 if ('(' != v[*pos])
2900 return roff_getnum(v, pos, res, flags);
2901
2902 (*pos)++;
2903 if ( ! roff_evalnum(r, ln, v, pos, res, flags | ROFFNUM_WHITE))
2904 return 0;
2905
2906 /*
2907 * Omission of the closing parenthesis
2908 * is an error in validation mode,
2909 * but ignored in evaluation mode.
2910 */
2911
2912 if (')' == v[*pos])
2913 (*pos)++;
2914 else if (NULL == res)
2915 return 0;
2916
2917 return 1;
2918 }
2919
2920 /*
2921 * Evaluate a complete numeric expression.
2922 * Proceed left to right, there is no concept of precedence.
2923 */
2924 static int
2925 roff_evalnum(struct roff *r, int ln, const char *v,
2926 int *pos, int *res, int flags)
2927 {
2928 int mypos, operand2;
2929 char operator;
2930
2931 if (NULL == pos) {
2932 mypos = 0;
2933 pos = &mypos;
2934 }
2935
2936 if (flags & ROFFNUM_WHITE)
2937 while (isspace((unsigned char)v[*pos]))
2938 (*pos)++;
2939
2940 if ( ! roff_evalpar(r, ln, v, pos, res, flags))
2941 return 0;
2942
2943 while (1) {
2944 if (flags & ROFFNUM_WHITE)
2945 while (isspace((unsigned char)v[*pos]))
2946 (*pos)++;
2947
2948 if ( ! roff_getop(v, pos, &operator))
2949 break;
2950
2951 if (flags & ROFFNUM_WHITE)
2952 while (isspace((unsigned char)v[*pos]))
2953 (*pos)++;
2954
2955 if ( ! roff_evalpar(r, ln, v, pos, &operand2, flags))
2956 return 0;
2957
2958 if (flags & ROFFNUM_WHITE)
2959 while (isspace((unsigned char)v[*pos]))
2960 (*pos)++;
2961
2962 if (NULL == res)
2963 continue;
2964
2965 switch (operator) {
2966 case '+':
2967 *res += operand2;
2968 break;
2969 case '-':
2970 *res -= operand2;
2971 break;
2972 case '*':
2973 *res *= operand2;
2974 break;
2975 case '/':
2976 if (operand2 == 0) {
2977 mandoc_msg(MANDOCERR_DIVZERO,
2978 ln, *pos, "%s", v);
2979 *res = 0;
2980 break;
2981 }
2982 *res /= operand2;
2983 break;
2984 case '%':
2985 if (operand2 == 0) {
2986 mandoc_msg(MANDOCERR_DIVZERO,
2987 ln, *pos, "%s", v);
2988 *res = 0;
2989 break;
2990 }
2991 *res %= operand2;
2992 break;
2993 case '<':
2994 *res = *res < operand2;
2995 break;
2996 case '>':
2997 *res = *res > operand2;
2998 break;
2999 case 'l':
3000 *res = *res <= operand2;
3001 break;
3002 case 'g':
3003 *res = *res >= operand2;
3004 break;
3005 case '=':
3006 *res = *res == operand2;
3007 break;
3008 case '!':
3009 *res = *res != operand2;
3010 break;
3011 case '&':
3012 *res = *res && operand2;
3013 break;
3014 case ':':
3015 *res = *res || operand2;
3016 break;
3017 case 'i':
3018 if (operand2 < *res)
3019 *res = operand2;
3020 break;
3021 case 'a':
3022 if (operand2 > *res)
3023 *res = operand2;
3024 break;
3025 default:
3026 abort();
3027 }
3028 }
3029 return 1;
3030 }
3031
3032 /* --- register management ------------------------------------------------ */
3033
3034 void
3035 roff_setreg(struct roff *r, const char *name, int val, char sign)
3036 {
3037 roff_setregn(r, name, strlen(name), val, sign, INT_MIN);
3038 }
3039
3040 static void
3041 roff_setregn(struct roff *r, const char *name, size_t len,
3042 int val, char sign, int step)
3043 {
3044 struct roffreg *reg;
3045
3046 /* Search for an existing register with the same name. */
3047 reg = r->regtab;
3048
3049 while (reg != NULL && (reg->key.sz != len ||
3050 strncmp(reg->key.p, name, len) != 0))
3051 reg = reg->next;
3052
3053 if (NULL == reg) {
3054 /* Create a new register. */
3055 reg = mandoc_malloc(sizeof(struct roffreg));
3056 reg->key.p = mandoc_strndup(name, len);
3057 reg->key.sz = len;
3058 reg->val = 0;
3059 reg->step = 0;
3060 reg->next = r->regtab;
3061 r->regtab = reg;
3062 }
3063
3064 if ('+' == sign)
3065 reg->val += val;
3066 else if ('-' == sign)
3067 reg->val -= val;
3068 else
3069 reg->val = val;
3070 if (step != INT_MIN)
3071 reg->step = step;
3072 }
3073
3074 /*
3075 * Handle some predefined read-only number registers.
3076 * For now, return -1 if the requested register is not predefined;
3077 * in case a predefined read-only register having the value -1
3078 * were to turn up, another special value would have to be chosen.
3079 */
3080 static int
3081 roff_getregro(const struct roff *r, const char *name)
3082 {
3083
3084 switch (*name) {
3085 case '$': /* Number of arguments of the last macro evaluated. */
3086 return r->mstackpos < 0 ? 0 : r->mstack[r->mstackpos].argc;
3087 case 'A': /* ASCII approximation mode is always off. */
3088 return 0;
3089 case 'g': /* Groff compatibility mode is always on. */
3090 return 1;
3091 case 'H': /* Fixed horizontal resolution. */
3092 return 24;
3093 case 'j': /* Always adjust left margin only. */
3094 return 0;
3095 case 'T': /* Some output device is always defined. */
3096 return 1;
3097 case 'V': /* Fixed vertical resolution. */
3098 return 40;
3099 default:
3100 return -1;
3101 }
3102 }
3103
3104 int
3105 roff_getreg(struct roff *r, const char *name)
3106 {
3107 return roff_getregn(r, name, strlen(name), '\0');
3108 }
3109
3110 static int
3111 roff_getregn(struct roff *r, const char *name, size_t len, char sign)
3112 {
3113 struct roffreg *reg;
3114 int val;
3115
3116 if ('.' == name[0] && 2 == len) {
3117 val = roff_getregro(r, name + 1);
3118 if (-1 != val)
3119 return val;
3120 }
3121
3122 for (reg = r->regtab; reg; reg = reg->next) {
3123 if (len == reg->key.sz &&
3124 0 == strncmp(name, reg->key.p, len)) {
3125 switch (sign) {
3126 case '+':
3127 reg->val += reg->step;
3128 break;
3129 case '-':
3130 reg->val -= reg->step;
3131 break;
3132 default:
3133 break;
3134 }
3135 return reg->val;
3136 }
3137 }
3138
3139 roff_setregn(r, name, len, 0, '\0', INT_MIN);
3140 return 0;
3141 }
3142
3143 static int
3144 roff_hasregn(const struct roff *r, const char *name, size_t len)
3145 {
3146 struct roffreg *reg;
3147 int val;
3148
3149 if ('.' == name[0] && 2 == len) {
3150 val = roff_getregro(r, name + 1);
3151 if (-1 != val)
3152 return 1;
3153 }
3154
3155 for (reg = r->regtab; reg; reg = reg->next)
3156 if (len == reg->key.sz &&
3157 0 == strncmp(name, reg->key.p, len))
3158 return 1;
3159
3160 return 0;
3161 }
3162
3163 static void
3164 roff_freereg(struct roffreg *reg)
3165 {
3166 struct roffreg *old_reg;
3167
3168 while (NULL != reg) {
3169 free(reg->key.p);
3170 old_reg = reg;
3171 reg = reg->next;
3172 free(old_reg);
3173 }
3174 }
3175
3176 static int
3177 roff_nr(ROFF_ARGS)
3178 {
3179 char *key, *val, *step;
3180 size_t keysz;
3181 int iv, is, len;
3182 char sign;
3183
3184 key = val = buf->buf + pos;
3185 if (*key == '\0')
3186 return ROFF_IGN;
3187
3188 keysz = roff_getname(r, &val, ln, pos);
3189 if (key[keysz] == '\\' || key[keysz] == '\t')
3190 return ROFF_IGN;
3191
3192 sign = *val;
3193 if (sign == '+' || sign == '-')
3194 val++;
3195
3196 len = 0;
3197 if (roff_evalnum(r, ln, val, &len, &iv, ROFFNUM_SCALE) == 0)
3198 return ROFF_IGN;
3199
3200 step = val + len;
3201 while (isspace((unsigned char)*step))
3202 step++;
3203 if (roff_evalnum(r, ln, step, NULL, &is, 0) == 0)
3204 is = INT_MIN;
3205
3206 roff_setregn(r, key, keysz, iv, sign, is);
3207 return ROFF_IGN;
3208 }
3209
3210 static int
3211 roff_rr(ROFF_ARGS)
3212 {
3213 struct roffreg *reg, **prev;
3214 char *name, *cp;
3215 size_t namesz;
3216
3217 name = cp = buf->buf + pos;
3218 if (*name == '\0')
3219 return ROFF_IGN;
3220 namesz = roff_getname(r, &cp, ln, pos);
3221 name[namesz] = '\0';
3222
3223 prev = &r->regtab;
3224 while (1) {
3225 reg = *prev;
3226 if (reg == NULL || !strcmp(name, reg->key.p))
3227 break;
3228 prev = &reg->next;
3229 }
3230 if (reg != NULL) {
3231 *prev = reg->next;
3232 free(reg->key.p);
3233 free(reg);
3234 }
3235 return ROFF_IGN;
3236 }
3237
3238 /* --- handler functions for roff requests -------------------------------- */
3239
3240 static int
3241 roff_rm(ROFF_ARGS)
3242 {
3243 const char *name;
3244 char *cp;
3245 size_t namesz;
3246
3247 cp = buf->buf + pos;
3248 while (*cp != '\0') {
3249 name = cp;
3250 namesz = roff_getname(r, &cp, ln, (int)(cp - buf->buf));
3251 roff_setstrn(&r->strtab, name, namesz, NULL, 0, 0);
3252 roff_setstrn(&r->rentab, name, namesz, NULL, 0, 0);
3253 if (name[namesz] == '\\' || name[namesz] == '\t')
3254 break;
3255 }
3256 return ROFF_IGN;
3257 }
3258
3259 static int
3260 roff_it(ROFF_ARGS)
3261 {
3262 int iv;
3263
3264 /* Parse the number of lines. */
3265
3266 if ( ! roff_evalnum(r, ln, buf->buf, &pos, &iv, 0)) {
3267 mandoc_msg(MANDOCERR_IT_NONUM,
3268 ln, ppos, "%s", buf->buf + 1);
3269 return ROFF_IGN;
3270 }
3271
3272 while (isspace((unsigned char)buf->buf[pos]))
3273 pos++;
3274
3275 /*
3276 * Arm the input line trap.
3277 * Special-casing "an-trap" is an ugly workaround to cope
3278 * with DocBook stupidly fiddling with man(7) internals.
3279 */
3280
3281 roffit_lines = iv;
3282 roffit_macro = mandoc_strdup(iv != 1 ||
3283 strcmp(buf->buf + pos, "an-trap") ?
3284 buf->buf + pos : "br");
3285 return ROFF_IGN;
3286 }
3287
3288 static int
3289 roff_Dd(ROFF_ARGS)
3290 {
3291 int mask;
3292 enum roff_tok t, te;
3293
3294 switch (tok) {
3295 case ROFF_Dd:
3296 tok = MDOC_Dd;
3297 te = MDOC_MAX;
3298 if (r->format == 0)
3299 r->format = MPARSE_MDOC;
3300 mask = MPARSE_MDOC | MPARSE_QUICK;
3301 break;
3302 case ROFF_TH:
3303 tok = MAN_TH;
3304 te = MAN_MAX;
3305 if (r->format == 0)
3306 r->format = MPARSE_MAN;
3307 mask = MPARSE_QUICK;
3308 break;
3309 default:
3310 abort();
3311 }
3312 if ((r->options & mask) == 0)
3313 for (t = tok; t < te; t++)
3314 roff_setstr(r, roff_name[t], NULL, 0);
3315 return ROFF_CONT;
3316 }
3317
3318 static int
3319 roff_TE(ROFF_ARGS)
3320 {
3321 r->man->flags &= ~ROFF_NONOFILL;
3322 if (r->tbl == NULL) {
3323 mandoc_msg(MANDOCERR_BLK_NOTOPEN, ln, ppos, "TE");
3324 return ROFF_IGN;
3325 }
3326 if (tbl_end(r->tbl, 0) == 0) {
3327 r->tbl = NULL;
3328 free(buf->buf);
3329 buf->buf = mandoc_strdup(".sp");
3330 buf->sz = 4;
3331 *offs = 0;
3332 return ROFF_REPARSE;
3333 }
3334 r->tbl = NULL;
3335 return ROFF_IGN;
3336 }
3337
3338 static int
3339 roff_T_(ROFF_ARGS)
3340 {
3341
3342 if (NULL == r->tbl)
3343 mandoc_msg(MANDOCERR_BLK_NOTOPEN, ln, ppos, "T&");
3344 else
3345 tbl_restart(ln, ppos, r->tbl);
3346
3347 return ROFF_IGN;
3348 }
3349
3350 /*
3351 * Handle in-line equation delimiters.
3352 */
3353 static int
3354 roff_eqndelim(struct roff *r, struct buf *buf, int pos)
3355 {
3356 char *cp1, *cp2;
3357 const char *bef_pr, *bef_nl, *mac, *aft_nl, *aft_pr;
3358
3359 /*
3360 * Outside equations, look for an opening delimiter.
3361 * If we are inside an equation, we already know it is
3362 * in-line, or this function wouldn't have been called;
3363 * so look for a closing delimiter.
3364 */
3365
3366 cp1 = buf->buf + pos;
3367 cp2 = strchr(cp1, r->eqn == NULL ?
3368 r->last_eqn->odelim : r->last_eqn->cdelim);
3369 if (cp2 == NULL)
3370 return ROFF_CONT;
3371
3372 *cp2++ = '\0';
3373 bef_pr = bef_nl = aft_nl = aft_pr = "";
3374
3375 /* Handle preceding text, protecting whitespace. */
3376
3377 if (*buf->buf != '\0') {
3378 if (r->eqn == NULL)
3379 bef_pr = "\\&";
3380 bef_nl = "\n";
3381 }
3382
3383 /*
3384 * Prepare replacing the delimiter with an equation macro
3385 * and drop leading white space from the equation.
3386 */
3387
3388 if (r->eqn == NULL) {
3389 while (*cp2 == ' ')
3390 cp2++;
3391 mac = ".EQ";
3392 } else
3393 mac = ".EN";
3394
3395 /* Handle following text, protecting whitespace. */
3396
3397 if (*cp2 != '\0') {
3398 aft_nl = "\n";
3399 if (r->eqn != NULL)
3400 aft_pr = "\\&";
3401 }
3402
3403 /* Do the actual replacement. */
3404
3405 buf->sz = mandoc_asprintf(&cp1, "%s%s%s%s%s%s%s", buf->buf,
3406 bef_pr, bef_nl, mac, aft_nl, aft_pr, cp2) + 1;
3407 free(buf->buf);
3408 buf->buf = cp1;
3409
3410 /* Toggle the in-line state of the eqn subsystem. */
3411
3412 r->eqn_inline = r->eqn == NULL;
3413 return ROFF_REPARSE;
3414 }
3415
3416 static int
3417 roff_EQ(ROFF_ARGS)
3418 {
3419 struct roff_node *n;
3420
3421 if (r->man->meta.macroset == MACROSET_MAN)
3422 man_breakscope(r->man, ROFF_EQ);
3423 n = roff_node_alloc(r->man, ln, ppos, ROFFT_EQN, TOKEN_NONE);
3424 if (ln > r->man->last->line)
3425 n->flags |= NODE_LINE;
3426 n->eqn = eqn_box_new();
3427 roff_node_append(r->man, n);
3428 r->man->next = ROFF_NEXT_SIBLING;
3429
3430 assert(r->eqn == NULL);
3431 if (r->last_eqn == NULL)
3432 r->last_eqn = eqn_alloc();
3433 else
3434 eqn_reset(r->last_eqn);
3435 r->eqn = r->last_eqn;
3436 r->eqn->node = n;
3437
3438 if (buf->buf[pos] != '\0')
3439 mandoc_msg(MANDOCERR_ARG_SKIP, ln, pos,
3440 ".EQ %s", buf->buf + pos);
3441
3442 return ROFF_IGN;
3443 }
3444
3445 static int
3446 roff_EN(ROFF_ARGS)
3447 {
3448 if (r->eqn != NULL) {
3449 eqn_parse(r->eqn);
3450 r->eqn = NULL;
3451 } else
3452 mandoc_msg(MANDOCERR_BLK_NOTOPEN, ln, ppos, "EN");
3453 if (buf->buf[pos] != '\0')
3454 mandoc_msg(MANDOCERR_ARG_SKIP, ln, pos,
3455 "EN %s", buf->buf + pos);
3456 return ROFF_IGN;
3457 }
3458
3459 static int
3460 roff_TS(ROFF_ARGS)
3461 {
3462 if (r->tbl != NULL) {
3463 mandoc_msg(MANDOCERR_BLK_BROKEN, ln, ppos, "TS breaks TS");
3464 tbl_end(r->tbl, 0);
3465 }
3466 r->man->flags |= ROFF_NONOFILL;
3467 r->tbl = tbl_alloc(ppos, ln, r->last_tbl);
3468 if (r->last_tbl == NULL)
3469 r->first_tbl = r->tbl;
3470 r->last_tbl = r->tbl;
3471 return ROFF_IGN;
3472 }
3473
3474 static int
3475 roff_noarg(ROFF_ARGS)
3476 {
3477 if (r->man->flags & (MAN_BLINE | MAN_ELINE))
3478 man_breakscope(r->man, tok);
3479 if (tok == ROFF_brp)
3480 tok = ROFF_br;
3481 roff_elem_alloc(r->man, ln, ppos, tok);
3482 if (buf->buf[pos] != '\0')
3483 mandoc_msg(MANDOCERR_ARG_SKIP, ln, pos,
3484 "%s %s", roff_name[tok], buf->buf + pos);
3485 if (tok == ROFF_nf)
3486 r->man->flags |= ROFF_NOFILL;
3487 else if (tok == ROFF_fi)
3488 r->man->flags &= ~ROFF_NOFILL;
3489 r->man->last->flags |= NODE_LINE | NODE_VALID | NODE_ENDED;
3490 r->man->next = ROFF_NEXT_SIBLING;
3491 return ROFF_IGN;
3492 }
3493
3494 static int
3495 roff_onearg(ROFF_ARGS)
3496 {
3497 struct roff_node *n;
3498 char *cp;
3499 int npos;
3500
3501 if (r->man->flags & (MAN_BLINE | MAN_ELINE) &&
3502 (tok == ROFF_ce || tok == ROFF_rj || tok == ROFF_sp ||
3503 tok == ROFF_ti))
3504 man_breakscope(r->man, tok);
3505
3506 if (roffce_node != NULL && (tok == ROFF_ce || tok == ROFF_rj)) {
3507 r->man->last = roffce_node;
3508 r->man->next = ROFF_NEXT_SIBLING;
3509 }
3510
3511 roff_elem_alloc(r->man, ln, ppos, tok);
3512 n = r->man->last;
3513
3514 cp = buf->buf + pos;
3515 if (*cp != '\0') {
3516 while (*cp != '\0' && *cp != ' ')
3517 cp++;
3518 while (*cp == ' ')
3519 *cp++ = '\0';
3520 if (*cp != '\0')
3521 mandoc_msg(MANDOCERR_ARG_EXCESS,
3522 ln, (int)(cp - buf->buf),
3523 "%s ... %s", roff_name[tok], cp);
3524 roff_word_alloc(r->man, ln, pos, buf->buf + pos);
3525 }
3526
3527 if (tok == ROFF_ce || tok == ROFF_rj) {
3528 if (r->man->last->type == ROFFT_ELEM) {
3529 roff_word_alloc(r->man, ln, pos, "1");
3530 r->man->last->flags |= NODE_NOSRC;
3531 }
3532 npos = 0;
3533 if (roff_evalnum(r, ln, r->man->last->string, &npos,
3534 &roffce_lines, 0) == 0) {
3535 mandoc_msg(MANDOCERR_CE_NONUM,
3536 ln, pos, "ce %s", buf->buf + pos);
3537 roffce_lines = 1;
3538 }
3539 if (roffce_lines < 1) {
3540 r->man->last = r->man->last->parent;
3541 roffce_node = NULL;
3542 roffce_lines = 0;
3543 } else
3544 roffce_node = r->man->last->parent;
3545 } else {
3546 n->flags |= NODE_VALID | NODE_ENDED;
3547 r->man->last = n;
3548 }
3549 n->flags |= NODE_LINE;
3550 r->man->next = ROFF_NEXT_SIBLING;
3551 return ROFF_IGN;
3552 }
3553
3554 static int
3555 roff_manyarg(ROFF_ARGS)
3556 {
3557 struct roff_node *n;
3558 char *sp, *ep;
3559
3560 roff_elem_alloc(r->man, ln, ppos, tok);
3561 n = r->man->last;
3562
3563 for (sp = ep = buf->buf + pos; *sp != '\0'; sp = ep) {
3564 while (*ep != '\0' && *ep != ' ')
3565 ep++;
3566 while (*ep == ' ')
3567 *ep++ = '\0';
3568 roff_word_alloc(r->man, ln, sp - buf->buf, sp);
3569 }
3570
3571 n->flags |= NODE_LINE | NODE_VALID | NODE_ENDED;
3572 r->man->last = n;
3573 r->man->next = ROFF_NEXT_SIBLING;
3574 return ROFF_IGN;
3575 }
3576
3577 static int
3578 roff_als(ROFF_ARGS)
3579 {
3580 char *oldn, *newn, *end, *value;
3581 size_t oldsz, newsz, valsz;
3582
3583 newn = oldn = buf->buf + pos;
3584 if (*newn == '\0')
3585 return ROFF_IGN;
3586
3587 newsz = roff_getname(r, &oldn, ln, pos);
3588 if (newn[newsz] == '\\' || newn[newsz] == '\t' || *oldn == '\0')
3589 return ROFF_IGN;
3590
3591 end = oldn;
3592 oldsz = roff_getname(r, &end, ln, oldn - buf->buf);
3593 if (oldsz == 0)
3594 return ROFF_IGN;
3595
3596 valsz = mandoc_asprintf(&value, ".%.*s \\$@\\\"\n",
3597 (int)oldsz, oldn);
3598 roff_setstrn(&r->strtab, newn, newsz, value, valsz, 0);
3599 roff_setstrn(&r->rentab, newn, newsz, NULL, 0, 0);
3600 free(value);
3601 return ROFF_IGN;
3602 }
3603
3604 /*
3605 * The .break request only makes sense inside conditionals,
3606 * and that case is already handled in roff_cond_sub().
3607 */
3608 static int
3609 roff_break(ROFF_ARGS)
3610 {
3611 mandoc_msg(MANDOCERR_BLK_NOTOPEN, ln, pos, "break");
3612 return ROFF_IGN;
3613 }
3614
3615 static int
3616 roff_cc(ROFF_ARGS)
3617 {
3618 const char *p;
3619
3620 p = buf->buf + pos;
3621
3622 if (*p == '\0' || (r->control = *p++) == '.')
3623 r->control = '\0';
3624
3625 if (*p != '\0')
3626 mandoc_msg(MANDOCERR_ARG_EXCESS,
3627 ln, p - buf->buf, "cc ... %s", p);
3628
3629 return ROFF_IGN;
3630 }
3631
3632 static int
3633 roff_char(ROFF_ARGS)
3634 {
3635 const char *p, *kp, *vp;
3636 size_t ksz, vsz;
3637 int font;
3638
3639 /* Parse the character to be replaced. */
3640
3641 kp = buf->buf + pos;
3642 p = kp + 1;
3643 if (*kp == '\0' || (*kp == '\\' &&
3644 mandoc_escape(&p, NULL, NULL) != ESCAPE_SPECIAL) ||
3645 (*p != ' ' && *p != '\0')) {
3646 mandoc_msg(MANDOCERR_CHAR_ARG, ln, pos, "char %s", kp);
3647 return ROFF_IGN;
3648 }
3649 ksz = p - kp;
3650 while (*p == ' ')
3651 p++;
3652
3653 /*
3654 * If the replacement string contains a font escape sequence,
3655 * we have to restore the font at the end.
3656 */
3657
3658 vp = p;
3659 vsz = strlen(p);
3660 font = 0;
3661 while (*p != '\0') {
3662 if (*p++ != '\\')
3663 continue;
3664 switch (mandoc_escape(&p, NULL, NULL)) {
3665 case ESCAPE_FONT:
3666 case ESCAPE_FONTROMAN:
3667 case ESCAPE_FONTITALIC:
3668 case ESCAPE_FONTBOLD:
3669 case ESCAPE_FONTBI:
3670 case ESCAPE_FONTCR:
3671 case ESCAPE_FONTCB:
3672 case ESCAPE_FONTCI:
3673 case ESCAPE_FONTPREV:
3674 font++;
3675 break;
3676 default:
3677 break;
3678 }
3679 }
3680 if (font > 1)
3681 mandoc_msg(MANDOCERR_CHAR_FONT,
3682 ln, (int)(vp - buf->buf), "%s", vp);
3683
3684 /*
3685 * Approximate the effect of .char using the .tr tables.
3686 * XXX In groff, .char and .tr interact differently.
3687 */
3688
3689 if (ksz == 1) {
3690 if (r->xtab == NULL)
3691 r->xtab = mandoc_calloc(128, sizeof(*r->xtab));
3692 assert((unsigned int)*kp < 128);
3693 free(r->xtab[(int)*kp].p);
3694 r->xtab[(int)*kp].sz = mandoc_asprintf(&r->xtab[(int)*kp].p,
3695 "%s%s", vp, font ? "\fP" : "");
3696 } else {
3697 roff_setstrn(&r->xmbtab, kp, ksz, vp, vsz, 0);
3698 if (font)
3699 roff_setstrn(&r->xmbtab, kp, ksz, "\\fP", 3, 1);
3700 }
3701 return ROFF_IGN;
3702 }
3703
3704 static int
3705 roff_ec(ROFF_ARGS)
3706 {
3707 const char *p;
3708
3709 p = buf->buf + pos;
3710 if (*p == '\0')
3711 r->escape = '\\';
3712 else {
3713 r->escape = *p;
3714 if (*++p != '\0')
3715 mandoc_msg(MANDOCERR_ARG_EXCESS, ln,
3716 (int)(p - buf->buf), "ec ... %s", p);
3717 }
3718 return ROFF_IGN;
3719 }
3720
3721 static int
3722 roff_eo(ROFF_ARGS)
3723 {
3724 r->escape = '\0';
3725 if (buf->buf[pos] != '\0')
3726 mandoc_msg(MANDOCERR_ARG_SKIP,
3727 ln, pos, "eo %s", buf->buf + pos);
3728 return ROFF_IGN;
3729 }
3730
3731 static int
3732 roff_nop(ROFF_ARGS)
3733 {
3734 while (buf->buf[pos] == ' ')
3735 pos++;
3736 *offs = pos;
3737 return ROFF_RERUN;
3738 }
3739
3740 static int
3741 roff_tr(ROFF_ARGS)
3742 {
3743 const char *p, *first, *second;
3744 size_t fsz, ssz;
3745 enum mandoc_esc esc;
3746
3747 p = buf->buf + pos;
3748
3749 if (*p == '\0') {
3750 mandoc_msg(MANDOCERR_REQ_EMPTY, ln, ppos, "tr");
3751 return ROFF_IGN;
3752 }
3753
3754 while (*p != '\0') {
3755 fsz = ssz = 1;
3756
3757 first = p++;
3758 if (*first == '\\') {
3759 esc = mandoc_escape(&p, NULL, NULL);
3760 if (esc == ESCAPE_ERROR) {
3761 mandoc_msg(MANDOCERR_ESC_BAD, ln,
3762 (int)(p - buf->buf), "%s", first);
3763 return ROFF_IGN;
3764 }
3765 fsz = (size_t)(p - first);
3766 }
3767
3768 second = p++;
3769 if (*second == '\\') {
3770 esc = mandoc_escape(&p, NULL, NULL);
3771 if (esc == ESCAPE_ERROR) {
3772 mandoc_msg(MANDOCERR_ESC_BAD, ln,
3773 (int)(p - buf->buf), "%s", second);
3774 return ROFF_IGN;
3775 }
3776 ssz = (size_t)(p - second);
3777 } else if (*second == '\0') {
3778 mandoc_msg(MANDOCERR_TR_ODD, ln,
3779 (int)(first - buf->buf), "tr %s", first);
3780 second = " ";
3781 p--;
3782 }
3783
3784 if (fsz > 1) {
3785 roff_setstrn(&r->xmbtab, first, fsz,
3786 second, ssz, 0);
3787 continue;
3788 }
3789
3790 if (r->xtab == NULL)
3791 r->xtab = mandoc_calloc(128,
3792 sizeof(struct roffstr));
3793
3794 free(r->xtab[(int)*first].p);
3795 r->xtab[(int)*first].p = mandoc_strndup(second, ssz);
3796 r->xtab[(int)*first].sz = ssz;
3797 }
3798
3799 return ROFF_IGN;
3800 }
3801
3802 /*
3803 * Implementation of the .return request.
3804 * There is no need to call roff_userret() from here.
3805 * The read module will call that after rewinding the reader stack
3806 * to the place from where the current macro was called.
3807 */
3808 static int
3809 roff_return(ROFF_ARGS)
3810 {
3811 if (r->mstackpos >= 0)
3812 return ROFF_IGN | ROFF_USERRET;
3813
3814 mandoc_msg(MANDOCERR_REQ_NOMAC, ln, ppos, "return");
3815 return ROFF_IGN;
3816 }
3817
3818 static int
3819 roff_rn(ROFF_ARGS)
3820 {
3821 const char *value;
3822 char *oldn, *newn, *end;
3823 size_t oldsz, newsz;
3824 int deftype;
3825
3826 oldn = newn = buf->buf + pos;
3827 if (*oldn == '\0')
3828 return ROFF_IGN;
3829
3830 oldsz = roff_getname(r, &newn, ln, pos);
3831 if (oldn[oldsz] == '\\' || oldn[oldsz] == '\t' || *newn == '\0')
3832 return ROFF_IGN;
3833
3834 end = newn;
3835 newsz = roff_getname(r, &end, ln, newn - buf->buf);
3836 if (newsz == 0)
3837 return ROFF_IGN;
3838
3839 deftype = ROFFDEF_ANY;
3840 value = roff_getstrn(r, oldn, oldsz, &deftype);
3841 switch (deftype) {
3842 case ROFFDEF_USER:
3843 roff_setstrn(&r->strtab, newn, newsz, value, strlen(value), 0);
3844 roff_setstrn(&r->strtab, oldn, oldsz, NULL, 0, 0);
3845 roff_setstrn(&r->rentab, newn, newsz, NULL, 0, 0);
3846 break;
3847 case ROFFDEF_PRE:
3848 roff_setstrn(&r->strtab, newn, newsz, value, strlen(value), 0);
3849 roff_setstrn(&r->rentab, newn, newsz, NULL, 0, 0);
3850 break;
3851 case ROFFDEF_REN:
3852 roff_setstrn(&r->rentab, newn, newsz, value, strlen(value), 0);
3853 roff_setstrn(&r->rentab, oldn, oldsz, NULL, 0, 0);
3854 roff_setstrn(&r->strtab, newn, newsz, NULL, 0, 0);
3855 break;
3856 case ROFFDEF_STD:
3857 roff_setstrn(&r->rentab, newn, newsz, oldn, oldsz, 0);
3858 roff_setstrn(&r->strtab, newn, newsz, NULL, 0, 0);
3859 break;
3860 default:
3861 roff_setstrn(&r->strtab, newn, newsz, NULL, 0, 0);
3862 roff_setstrn(&r->rentab, newn, newsz, NULL, 0, 0);
3863 break;
3864 }
3865 return ROFF_IGN;
3866 }
3867
3868 static int
3869 roff_shift(ROFF_ARGS)
3870 {
3871 struct mctx *ctx;
3872 int levels, i;
3873
3874 levels = 1;
3875 if (buf->buf[pos] != '\0' &&
3876 roff_evalnum(r, ln, buf->buf, &pos, &levels, 0) == 0) {
3877 mandoc_msg(MANDOCERR_CE_NONUM,
3878 ln, pos, "shift %s", buf->buf + pos);
3879 levels = 1;
3880 }
3881 if (r->mstackpos < 0) {
3882 mandoc_msg(MANDOCERR_REQ_NOMAC, ln, ppos, "shift");
3883 return ROFF_IGN;
3884 }
3885 ctx = r->mstack + r->mstackpos;
3886 if (levels > ctx->argc) {
3887 mandoc_msg(MANDOCERR_SHIFT,
3888 ln, pos, "%d, but max is %d", levels, ctx->argc);
3889 levels = ctx->argc;
3890 }
3891 if (levels == 0)
3892 return ROFF_IGN;
3893 for (i = 0; i < levels; i++)
3894 free(ctx->argv[i]);
3895 ctx->argc -= levels;
3896 for (i = 0; i < ctx->argc; i++)
3897 ctx->argv[i] = ctx->argv[i + levels];
3898 return ROFF_IGN;
3899 }
3900
3901 static int
3902 roff_so(ROFF_ARGS)
3903 {
3904 char *name, *cp;
3905
3906 name = buf->buf + pos;
3907 mandoc_msg(MANDOCERR_SO, ln, ppos, "so %s", name);
3908
3909 /*
3910 * Handle `so'. Be EXTREMELY careful, as we shouldn't be
3911 * opening anything that's not in our cwd or anything beneath
3912 * it. Thus, explicitly disallow traversing up the file-system
3913 * or using absolute paths.
3914 */
3915
3916 if (*name == '/' || strstr(name, "../") || strstr(name, "/..")) {
3917 mandoc_msg(MANDOCERR_SO_PATH, ln, ppos, ".so %s", name);
3918 buf->sz = mandoc_asprintf(&cp,
3919 ".sp\nSee the file %s.\n.sp", name) + 1;
3920 free(buf->buf);
3921 buf->buf = cp;
3922 *offs = 0;
3923 return ROFF_REPARSE;
3924 }
3925
3926 *offs = pos;
3927 return ROFF_SO;
3928 }
3929
3930 /* --- user defined strings and macros ------------------------------------ */
3931
3932 static int
3933 roff_userdef(ROFF_ARGS)
3934 {
3935 struct mctx *ctx;
3936 char *arg, *ap, *dst, *src;
3937 size_t sz;
3938
3939 /* If the macro is empty, ignore it altogether. */
3940
3941 if (*r->current_string == '\0')
3942 return ROFF_IGN;
3943
3944 /* Initialize a new macro stack context. */
3945
3946 if (++r->mstackpos == r->mstacksz) {
3947 r->mstack = mandoc_recallocarray(r->mstack,
3948 r->mstacksz, r->mstacksz + 8, sizeof(*r->mstack));
3949 r->mstacksz += 8;
3950 }
3951 ctx = r->mstack + r->mstackpos;
3952 ctx->argsz = 0;
3953 ctx->argc = 0;
3954 ctx->argv = NULL;
3955
3956 /*
3957 * Collect pointers to macro argument strings,
3958 * NUL-terminating them and escaping quotes.
3959 */
3960
3961 src = buf->buf + pos;
3962 while (*src != '\0') {
3963 if (ctx->argc == ctx->argsz) {
3964 ctx->argsz += 8;
3965 ctx->argv = mandoc_reallocarray(ctx->argv,
3966 ctx->argsz, sizeof(*ctx->argv));
3967 }
3968 arg = roff_getarg(r, &src, ln, &pos);
3969 sz = 1; /* For the terminating NUL. */
3970 for (ap = arg; *ap != '\0'; ap++)
3971 sz += *ap == '"' ? 4 : 1;
3972 ctx->argv[ctx->argc++] = dst = mandoc_malloc(sz);
3973 for (ap = arg; *ap != '\0'; ap++) {
3974 if (*ap == '"') {
3975 memcpy(dst, "\\(dq", 4);
3976 dst += 4;
3977 } else
3978 *dst++ = *ap;
3979 }
3980 *dst = '\0';
3981 free(arg);
3982 }
3983
3984 /* Replace the macro invocation by the macro definition. */
3985
3986 free(buf->buf);
3987 buf->buf = mandoc_strdup(r->current_string);
3988 buf->sz = strlen(buf->buf) + 1;
3989 *offs = 0;
3990
3991 return buf->buf[buf->sz - 2] == '\n' ?
3992 ROFF_REPARSE | ROFF_USERCALL : ROFF_IGN | ROFF_APPEND;
3993 }
3994
3995 /*
3996 * Calling a high-level macro that was renamed with .rn.
3997 * r->current_string has already been set up by roff_parse().
3998 */
3999 static int
4000 roff_renamed(ROFF_ARGS)
4001 {
4002 char *nbuf;
4003
4004 buf->sz = mandoc_asprintf(&nbuf, ".%s%s%s", r->current_string,
4005 buf->buf[pos] == '\0' ? "" : " ", buf->buf + pos) + 1;
4006 free(buf->buf);
4007 buf->buf = nbuf;
4008 *offs = 0;
4009 return ROFF_CONT;
4010 }
4011
4012 /*
4013 * Measure the length in bytes of the roff identifier at *cpp
4014 * and advance the pointer to the next word.
4015 */
4016 static size_t
4017 roff_getname(struct roff *r, char **cpp, int ln, int pos)
4018 {
4019 char *name, *cp;
4020 size_t namesz;
4021
4022 name = *cpp;
4023 if (*name == '\0')
4024 return 0;
4025
4026 /* Advance cp to the byte after the end of the name. */
4027
4028 for (cp = name; 1; cp++) {
4029 namesz = cp - name;
4030 if (*cp == '\0')
4031 break;
4032 if (*cp == ' ' || *cp == '\t') {
4033 cp++;
4034 break;
4035 }
4036 if (*cp != '\\')
4037 continue;
4038 if (cp[1] == '{' || cp[1] == '}')
4039 break;
4040 if (*++cp == '\\')
4041 continue;
4042 mandoc_msg(MANDOCERR_NAMESC, ln, pos,
4043 "%.*s", (int)(cp - name + 1), name);
4044 mandoc_escape((const char **)&cp, NULL, NULL);
4045 break;
4046 }
4047
4048 /* Read past spaces. */
4049
4050 while (*cp == ' ')
4051 cp++;
4052
4053 *cpp = cp;
4054 return namesz;
4055 }
4056
4057 /*
4058 * Store *string into the user-defined string called *name.
4059 * To clear an existing entry, call with (*r, *name, NULL, 0).
4060 * append == 0: replace mode
4061 * append == 1: single-line append mode
4062 * append == 2: multiline append mode, append '\n' after each call
4063 */
4064 static void
4065 roff_setstr(struct roff *r, const char *name, const char *string,
4066 int append)
4067 {
4068 size_t namesz;
4069
4070 namesz = strlen(name);
4071 roff_setstrn(&r->strtab, name, namesz, string,
4072 string ? strlen(string) : 0, append);
4073 roff_setstrn(&r->rentab, name, namesz, NULL, 0, 0);
4074 }
4075
4076 static void
4077 roff_setstrn(struct roffkv **r, const char *name, size_t namesz,
4078 const char *string, size_t stringsz, int append)
4079 {
4080 struct roffkv *n;
4081 char *c;
4082 int i;
4083 size_t oldch, newch;
4084
4085 /* Search for an existing string with the same name. */
4086 n = *r;
4087
4088 while (n && (namesz != n->key.sz ||
4089 strncmp(n->key.p, name, namesz)))
4090 n = n->next;
4091
4092 if (NULL == n) {
4093 /* Create a new string table entry. */
4094 n = mandoc_malloc(sizeof(struct roffkv));
4095 n->key.p = mandoc_strndup(name, namesz);
4096 n->key.sz = namesz;
4097 n->val.p = NULL;
4098 n->val.sz = 0;
4099 n->next = *r;
4100 *r = n;
4101 } else if (0 == append) {
4102 free(n->val.p);
4103 n->val.p = NULL;
4104 n->val.sz = 0;
4105 }
4106
4107 if (NULL == string)
4108 return;
4109
4110 /*
4111 * One additional byte for the '\n' in multiline mode,
4112 * and one for the terminating '\0'.
4113 */
4114 newch = stringsz + (1 < append ? 2u : 1u);
4115
4116 if (NULL == n->val.p) {
4117 n->val.p = mandoc_malloc(newch);
4118 *n->val.p = '\0';
4119 oldch = 0;
4120 } else {
4121 oldch = n->val.sz;
4122 n->val.p = mandoc_realloc(n->val.p, oldch + newch);
4123 }
4124
4125 /* Skip existing content in the destination buffer. */
4126 c = n->val.p + (int)oldch;
4127
4128 /* Append new content to the destination buffer. */
4129 i = 0;
4130 while (i < (int)stringsz) {
4131 /*
4132 * Rudimentary roff copy mode:
4133 * Handle escaped backslashes.
4134 */
4135 if ('\\' == string[i] && '\\' == string[i + 1])
4136 i++;
4137 *c++ = string[i++];
4138 }
4139
4140 /* Append terminating bytes. */
4141 if (1 < append)
4142 *c++ = '\n';
4143
4144 *c = '\0';
4145 n->val.sz = (int)(c - n->val.p);
4146 }
4147
4148 static const char *
4149 roff_getstrn(struct roff *r, const char *name, size_t len,
4150 int *deftype)
4151 {
4152 const struct roffkv *n;
4153 int found, i;
4154 enum roff_tok tok;
4155
4156 found = 0;
4157 for (n = r->strtab; n != NULL; n = n->next) {
4158 if (strncmp(name, n->key.p, len) != 0 ||
4159 n->key.p[len] != '\0' || n->val.p == NULL)
4160 continue;
4161 if (*deftype & ROFFDEF_USER) {
4162 *deftype = ROFFDEF_USER;
4163 return n->val.p;
4164 } else {
4165 found = 1;
4166 break;
4167 }
4168 }
4169 for (n = r->rentab; n != NULL; n = n->next) {
4170 if (strncmp(name, n->key.p, len) != 0 ||
4171 n->key.p[len] != '\0' || n->val.p == NULL)
4172 continue;
4173 if (*deftype & ROFFDEF_REN) {
4174 *deftype = ROFFDEF_REN;
4175 return n->val.p;
4176 } else {
4177 found = 1;
4178 break;
4179 }
4180 }
4181 for (i = 0; i < PREDEFS_MAX; i++) {
4182 if (strncmp(name, predefs[i].name, len) != 0 ||
4183 predefs[i].name[len] != '\0')
4184 continue;
4185 if (*deftype & ROFFDEF_PRE) {
4186 *deftype = ROFFDEF_PRE;
4187 return predefs[i].str;
4188 } else {
4189 found = 1;
4190 break;
4191 }
4192 }
4193 if (r->man->meta.macroset != MACROSET_MAN) {
4194 for (tok = MDOC_Dd; tok < MDOC_MAX; tok++) {
4195 if (strncmp(name, roff_name[tok], len) != 0 ||
4196 roff_name[tok][len] != '\0')
4197 continue;
4198 if (*deftype & ROFFDEF_STD) {
4199 *deftype = ROFFDEF_STD;
4200 return NULL;
4201 } else {
4202 found = 1;
4203 break;
4204 }
4205 }
4206 }
4207 if (r->man->meta.macroset != MACROSET_MDOC) {
4208 for (tok = MAN_TH; tok < MAN_MAX; tok++) {
4209 if (strncmp(name, roff_name[tok], len) != 0 ||
4210 roff_name[tok][len] != '\0')
4211 continue;
4212 if (*deftype & ROFFDEF_STD) {
4213 *deftype = ROFFDEF_STD;
4214 return NULL;
4215 } else {
4216 found = 1;
4217 break;
4218 }
4219 }
4220 }
4221
4222 if (found == 0 && *deftype != ROFFDEF_ANY) {
4223 if (*deftype & ROFFDEF_REN) {
4224 /*
4225 * This might still be a request,
4226 * so do not treat it as undefined yet.
4227 */
4228 *deftype = ROFFDEF_UNDEF;
4229 return NULL;
4230 }
4231
4232 /* Using an undefined string defines it to be empty. */
4233
4234 roff_setstrn(&r->strtab, name, len, "", 0, 0);
4235 roff_setstrn(&r->rentab, name, len, NULL, 0, 0);
4236 }
4237
4238 *deftype = 0;
4239 return NULL;
4240 }
4241
4242 static void
4243 roff_freestr(struct roffkv *r)
4244 {
4245 struct roffkv *n, *nn;
4246
4247 for (n = r; n; n = nn) {
4248 free(n->key.p);
4249 free(n->val.p);
4250 nn = n->next;
4251 free(n);
4252 }
4253 }
4254
4255 /* --- accessors and utility functions ------------------------------------ */
4256
4257 /*
4258 * Duplicate an input string, making the appropriate character
4259 * conversations (as stipulated by `tr') along the way.
4260 * Returns a heap-allocated string with all the replacements made.
4261 */
4262 char *
4263 roff_strdup(const struct roff *r, const char *p)
4264 {
4265 const struct roffkv *cp;
4266 char *res;
4267 const char *pp;
4268 size_t ssz, sz;
4269 enum mandoc_esc esc;
4270
4271 if (NULL == r->xmbtab && NULL == r->xtab)
4272 return mandoc_strdup(p);
4273 else if ('\0' == *p)
4274 return mandoc_strdup("");
4275
4276 /*
4277 * Step through each character looking for term matches
4278 * (remember that a `tr' can be invoked with an escape, which is
4279 * a glyph but the escape is multi-character).
4280 * We only do this if the character hash has been initialised
4281 * and the string is >0 length.
4282 */
4283
4284 res = NULL;
4285 ssz = 0;
4286
4287 while ('\0' != *p) {
4288 assert((unsigned int)*p < 128);
4289 if ('\\' != *p && r->xtab && r->xtab[(unsigned int)*p].p) {
4290 sz = r->xtab[(int)*p].sz;
4291 res = mandoc_realloc(res, ssz + sz + 1);
4292 memcpy(res + ssz, r->xtab[(int)*p].p, sz);
4293 ssz += sz;
4294 p++;
4295 continue;
4296 } else if ('\\' != *p) {
4297 res = mandoc_realloc(res, ssz + 2);
4298 res[ssz++] = *p++;
4299 continue;
4300 }
4301
4302 /* Search for term matches. */
4303 for (cp = r->xmbtab; cp; cp = cp->next)
4304 if (0 == strncmp(p, cp->key.p, cp->key.sz))
4305 break;
4306
4307 if (NULL != cp) {
4308 /*
4309 * A match has been found.
4310 * Append the match to the array and move
4311 * forward by its keysize.
4312 */
4313 res = mandoc_realloc(res,
4314 ssz + cp->val.sz + 1);
4315 memcpy(res + ssz, cp->val.p, cp->val.sz);
4316 ssz += cp->val.sz;
4317 p += (int)cp->key.sz;
4318 continue;
4319 }
4320
4321 /*
4322 * Handle escapes carefully: we need to copy
4323 * over just the escape itself, or else we might
4324 * do replacements within the escape itself.
4325 * Make sure to pass along the bogus string.
4326 */
4327 pp = p++;
4328 esc = mandoc_escape(&p, NULL, NULL);
4329 if (ESCAPE_ERROR == esc) {
4330 sz = strlen(pp);
4331 res = mandoc_realloc(res, ssz + sz + 1);
4332 memcpy(res + ssz, pp, sz);
4333 break;
4334 }
4335 /*
4336 * We bail out on bad escapes.
4337 * No need to warn: we already did so when
4338 * roff_expand() was called.
4339 */
4340 sz = (int)(p - pp);
4341 res = mandoc_realloc(res, ssz + sz + 1);
4342 memcpy(res + ssz, pp, sz);
4343 ssz += sz;
4344 }
4345
4346 res[(int)ssz] = '\0';
4347 return res;
4348 }
4349
4350 int
4351 roff_getformat(const struct roff *r)
4352 {
4353
4354 return r->format;
4355 }
4356
4357 /*
4358 * Find out whether a line is a macro line or not.
4359 * If it is, adjust the current position and return one; if it isn't,
4360 * return zero and don't change the current position.
4361 * If the control character has been set with `.cc', then let that grain
4362 * precedence.
4363 * This is slighly contrary to groff, where using the non-breaking
4364 * control character when `cc' has been invoked will cause the
4365 * non-breaking macro contents to be printed verbatim.
4366 */
4367 int
4368 roff_getcontrol(const struct roff *r, const char *cp, int *ppos)
4369 {
4370 int pos;
4371
4372 pos = *ppos;
4373
4374 if (r->control != '\0' && cp[pos] == r->control)
4375 pos++;
4376 else if (r->control != '\0')
4377 return 0;
4378 else if ('\\' == cp[pos] && '.' == cp[pos + 1])
4379 pos += 2;
4380 else if ('.' == cp[pos] || '\'' == cp[pos])
4381 pos++;
4382 else
4383 return 0;
4384
4385 while (' ' == cp[pos] || '\t' == cp[pos])
4386 pos++;
4387
4388 *ppos = pos;
4389 return 1;
4390 }
A git conversion mirror of mandoc.bsd.lv