1 /* $Id: mandoc.c,v 1.104 2018/07/28 18:34:15 schwarze Exp $ */
2 /*
3 * Copyright (c) 2008-2011, 2014 Kristaps Dzonsons <kristaps@bsd.lv>
4 * Copyright (c) 2011-2015, 2017, 2018 Ingo Schwarze <schwarze@openbsd.org>
5 *
6 * Permission to use, copy, modify, and distribute this software for any
7 * purpose with or without fee is hereby granted, provided that the above
8 * copyright notice and this permission notice appear in all copies.
9 *
10 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHORS DISCLAIM ALL WARRANTIES
11 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
12 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR
13 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
14 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
15 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
16 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
17 */
18 #include "config.h"
19
20 #include <sys/types.h>
21
22 #include <assert.h>
23 #include <ctype.h>
24 #include <errno.h>
25 #include <limits.h>
26 #include <stdlib.h>
27 #include <stdio.h>
28 #include <string.h>
29 #include <time.h>
30
31 #include "mandoc_aux.h"
32 #include "mandoc.h"
33 #include "roff.h"
34 #include "libmandoc.h"
35
36 static int a2time(time_t *, const char *, const char *);
37 static char *time2a(time_t);
38
39
40 enum mandoc_esc
41 mandoc_escape(const char **end, const char **start, int *sz)
42 {
43 const char *local_start;
44 int local_sz;
45 char term;
46 enum mandoc_esc gly;
47
48 /*
49 * When the caller doesn't provide return storage,
50 * use local storage.
51 */
52
53 if (NULL == start)
54 start = &local_start;
55 if (NULL == sz)
56 sz = &local_sz;
57
58 /*
59 * Beyond the backslash, at least one input character
60 * is part of the escape sequence. With one exception
61 * (see below), that character won't be returned.
62 */
63
64 gly = ESCAPE_ERROR;
65 *start = ++*end;
66 *sz = 0;
67 term = '\0';
68
69 switch ((*start)[-1]) {
70 /*
71 * First the glyphs. There are several different forms of
72 * these, but each eventually returns a substring of the glyph
73 * name.
74 */
75 case '(':
76 gly = ESCAPE_SPECIAL;
77 *sz = 2;
78 break;
79 case '[':
80 gly = ESCAPE_SPECIAL;
81 term = ']';
82 break;
83 case 'C':
84 if ('\'' != **start)
85 return ESCAPE_ERROR;
86 *start = ++*end;
87 gly = ESCAPE_SPECIAL;
88 term = '\'';
89 break;
90
91 /*
92 * Escapes taking no arguments at all.
93 */
94 case 'd':
95 case 'u':
96 case ',':
97 case '/':
98 return ESCAPE_IGNORE;
99 case 'p':
100 return ESCAPE_BREAK;
101
102 /*
103 * The \z escape is supposed to output the following
104 * character without advancing the cursor position.
105 * Since we are mostly dealing with terminal mode,
106 * let us just skip the next character.
107 */
108 case 'z':
109 return ESCAPE_SKIPCHAR;
110
111 /*
112 * Handle all triggers matching \X(xy, \Xx, and \X[xxxx], where
113 * 'X' is the trigger. These have opaque sub-strings.
114 */
115 case 'F':
116 case 'g':
117 case 'k':
118 case 'M':
119 case 'm':
120 case 'n':
121 case 'V':
122 case 'Y':
123 gly = ESCAPE_IGNORE;
124 /* FALLTHROUGH */
125 case 'f':
126 if (ESCAPE_ERROR == gly)
127 gly = ESCAPE_FONT;
128 switch (**start) {
129 case '(':
130 *start = ++*end;
131 *sz = 2;
132 break;
133 case '[':
134 *start = ++*end;
135 term = ']';
136 break;
137 default:
138 *sz = 1;
139 break;
140 }
141 break;
142
143 /*
144 * These escapes are of the form \X'Y', where 'X' is the trigger
145 * and 'Y' is any string. These have opaque sub-strings.
146 * The \B and \w escapes are handled in roff.c, roff_res().
147 */
148 case 'A':
149 case 'b':
150 case 'D':
151 case 'R':
152 case 'X':
153 case 'Z':
154 gly = ESCAPE_IGNORE;
155 /* FALLTHROUGH */
156 case 'o':
157 if (**start == '\0')
158 return ESCAPE_ERROR;
159 if (gly == ESCAPE_ERROR)
160 gly = ESCAPE_OVERSTRIKE;
161 term = **start;
162 *start = ++*end;
163 break;
164
165 /*
166 * These escapes are of the form \X'N', where 'X' is the trigger
167 * and 'N' resolves to a numerical expression.
168 */
169 case 'h':
170 case 'H':
171 case 'L':
172 case 'l':
173 case 'S':
174 case 'v':
175 case 'x':
176 if (strchr(" %&()*+-./0123456789:<=>", **start)) {
177 if ('\0' != **start)
178 ++*end;
179 return ESCAPE_ERROR;
180 }
181 switch ((*start)[-1]) {
182 case 'h':
183 gly = ESCAPE_HORIZ;
184 break;
185 case 'l':
186 gly = ESCAPE_HLINE;
187 break;
188 default:
189 gly = ESCAPE_IGNORE;
190 break;
191 }
192 term = **start;
193 *start = ++*end;
194 break;
195
196 /*
197 * Special handling for the numbered character escape.
198 * XXX Do any other escapes need similar handling?
199 */
200 case 'N':
201 if ('\0' == **start)
202 return ESCAPE_ERROR;
203 (*end)++;
204 if (isdigit((unsigned char)**start)) {
205 *sz = 1;
206 return ESCAPE_IGNORE;
207 }
208 (*start)++;
209 while (isdigit((unsigned char)**end))
210 (*end)++;
211 *sz = *end - *start;
212 if ('\0' != **end)
213 (*end)++;
214 return ESCAPE_NUMBERED;
215
216 /*
217 * Sizes get a special category of their own.
218 */
219 case 's':
220 gly = ESCAPE_IGNORE;
221
222 /* See +/- counts as a sign. */
223 if ('+' == **end || '-' == **end || ASCII_HYPH == **end)
224 *start = ++*end;
225
226 switch (**end) {
227 case '(':
228 *start = ++*end;
229 *sz = 2;
230 break;
231 case '[':
232 *start = ++*end;
233 term = ']';
234 break;
235 case '\'':
236 *start = ++*end;
237 term = '\'';
238 break;
239 case '3':
240 case '2':
241 case '1':
242 *sz = (*end)[-1] == 's' &&
243 isdigit((unsigned char)(*end)[1]) ? 2 : 1;
244 break;
245 default:
246 *sz = 1;
247 break;
248 }
249
250 break;
251
252 /*
253 * Anything else is assumed to be a glyph.
254 * In this case, pass back the character after the backslash.
255 */
256 default:
257 gly = ESCAPE_SPECIAL;
258 *start = --*end;
259 *sz = 1;
260 break;
261 }
262
263 assert(ESCAPE_ERROR != gly);
264
265 /*
266 * Read up to the terminating character,
267 * paying attention to nested escapes.
268 */
269
270 if ('\0' != term) {
271 while (**end != term) {
272 switch (**end) {
273 case '\0':
274 return ESCAPE_ERROR;
275 case '\\':
276 (*end)++;
277 if (ESCAPE_ERROR ==
278 mandoc_escape(end, NULL, NULL))
279 return ESCAPE_ERROR;
280 break;
281 default:
282 (*end)++;
283 break;
284 }
285 }
286 *sz = (*end)++ - *start;
287 } else {
288 assert(*sz > 0);
289 if ((size_t)*sz > strlen(*start))
290 return ESCAPE_ERROR;
291 *end += *sz;
292 }
293
294 /* Run post-processors. */
295
296 switch (gly) {
297 case ESCAPE_FONT:
298 if (2 == *sz) {
299 if ('C' == **start) {
300 /*
301 * Treat constant-width font modes
302 * just like regular font modes.
303 */
304 (*start)++;
305 (*sz)--;
306 } else {
307 if ('B' == (*start)[0] && 'I' == (*start)[1])
308 gly = ESCAPE_FONTBI;
309 break;
310 }
311 } else if (1 != *sz)
312 break;
313
314 switch (**start) {
315 case '3':
316 case 'B':
317 gly = ESCAPE_FONTBOLD;
318 break;
319 case '2':
320 case 'I':
321 gly = ESCAPE_FONTITALIC;
322 break;
323 case 'P':
324 gly = ESCAPE_FONTPREV;
325 break;
326 case '1':
327 case 'R':
328 gly = ESCAPE_FONTROMAN;
329 break;
330 }
331 break;
332 case ESCAPE_SPECIAL:
333 if (1 == *sz && 'c' == **start)
334 gly = ESCAPE_NOSPACE;
335 /*
336 * Unicode escapes are defined in groff as \[u0000]
337 * to \[u10FFFF], where the contained value must be
338 * a valid Unicode codepoint. Here, however, only
339 * check the length and range.
340 */
341 if (**start != 'u' || *sz < 5 || *sz > 7)
342 break;
343 if (*sz == 7 && ((*start)[1] != '1' || (*start)[2] != '0'))
344 break;
345 if (*sz == 6 && (*start)[1] == '0')
346 break;
347 if (*sz == 5 && (*start)[1] == 'D' &&
348 strchr("89ABCDEF", (*start)[2]) != NULL)
349 break;
350 if ((int)strspn(*start + 1, "0123456789ABCDEFabcdef")
351 + 1 == *sz)
352 gly = ESCAPE_UNICODE;
353 break;
354 default:
355 break;
356 }
357
358 return gly;
359 }
360
361 /*
362 * Parse a quoted or unquoted roff-style request or macro argument.
363 * Return a pointer to the parsed argument, which is either the original
364 * pointer or advanced by one byte in case the argument is quoted.
365 * NUL-terminate the argument in place.
366 * Collapse pairs of quotes inside quoted arguments.
367 * Advance the argument pointer to the next argument,
368 * or to the NUL byte terminating the argument line.
369 */
370 char *
371 mandoc_getarg(struct mparse *parse, char **cpp, int ln, int *pos)
372 {
373 char *start, *cp;
374 int quoted, pairs, white;
375
376 /* Quoting can only start with a new word. */
377 start = *cpp;
378 quoted = 0;
379 if ('"' == *start) {
380 quoted = 1;
381 start++;
382 }
383
384 pairs = 0;
385 white = 0;
386 for (cp = start; '\0' != *cp; cp++) {
387
388 /*
389 * Move the following text left
390 * after quoted quotes and after "\\" and "\t".
391 */
392 if (pairs)
393 cp[-pairs] = cp[0];
394
395 if ('\\' == cp[0]) {
396 /*
397 * In copy mode, translate double to single
398 * backslashes and backslash-t to literal tabs.
399 */
400 switch (cp[1]) {
401 case 't':
402 cp[0] = '\t';
403 /* FALLTHROUGH */
404 case '\\':
405 pairs++;
406 cp++;
407 break;
408 case ' ':
409 /* Skip escaped blanks. */
410 if (0 == quoted)
411 cp++;
412 break;
413 default:
414 break;
415 }
416 } else if (0 == quoted) {
417 if (' ' == cp[0]) {
418 /* Unescaped blanks end unquoted args. */
419 white = 1;
420 break;
421 }
422 } else if ('"' == cp[0]) {
423 if ('"' == cp[1]) {
424 /* Quoted quotes collapse. */
425 pairs++;
426 cp++;
427 } else {
428 /* Unquoted quotes end quoted args. */
429 quoted = 2;
430 break;
431 }
432 }
433 }
434
435 /* Quoted argument without a closing quote. */
436 if (1 == quoted)
437 mandoc_msg(MANDOCERR_ARG_QUOTE, parse, ln, *pos, NULL);
438
439 /* NUL-terminate this argument and move to the next one. */
440 if (pairs)
441 cp[-pairs] = '\0';
442 if ('\0' != *cp) {
443 *cp++ = '\0';
444 while (' ' == *cp)
445 cp++;
446 }
447 *pos += (int)(cp - start) + (quoted ? 1 : 0);
448 *cpp = cp;
449
450 if ('\0' == *cp && (white || ' ' == cp[-1]))
451 mandoc_msg(MANDOCERR_SPACE_EOL, parse, ln, *pos, NULL);
452
453 return start;
454 }
455
456 static int
457 a2time(time_t *t, const char *fmt, const char *p)
458 {
459 struct tm tm;
460 char *pp;
461
462 memset(&tm, 0, sizeof(struct tm));
463
464 pp = NULL;
465 #if HAVE_STRPTIME
466 pp = strptime(p, fmt, &tm);
467 #endif
468 if (NULL != pp && '\0' == *pp) {
469 *t = mktime(&tm);
470 return 1;
471 }
472
473 return 0;
474 }
475
476 static char *
477 time2a(time_t t)
478 {
479 struct tm *tm;
480 char *buf, *p;
481 size_t ssz;
482 int isz;
483
484 tm = localtime(&t);
485 if (tm == NULL)
486 return NULL;
487
488 /*
489 * Reserve space:
490 * up to 9 characters for the month (September) + blank
491 * up to 2 characters for the day + comma + blank
492 * 4 characters for the year and a terminating '\0'
493 */
494
495 p = buf = mandoc_malloc(10 + 4 + 4 + 1);
496
497 if ((ssz = strftime(p, 10 + 1, "%B ", tm)) == 0)
498 goto fail;
499 p += (int)ssz;
500
501 /*
502 * The output format is just "%d" here, not "%2d" or "%02d".
503 * That's also the reason why we can't just format the
504 * date as a whole with "%B %e, %Y" or "%B %d, %Y".
505 * Besides, the present approach is less prone to buffer
506 * overflows, in case anybody should ever introduce the bug
507 * of looking at LC_TIME.
508 */
509
510 if ((isz = snprintf(p, 4 + 1, "%d, ", tm->tm_mday)) == -1)
511 goto fail;
512 p += isz;
513
514 if (strftime(p, 4 + 1, "%Y", tm) == 0)
515 goto fail;
516 return buf;
517
518 fail:
519 free(buf);
520 return NULL;
521 }
522
523 char *
524 mandoc_normdate(struct roff_man *man, char *in, int ln, int pos)
525 {
526 char *cp;
527 time_t t;
528
529 /* No date specified: use today's date. */
530
531 if (in == NULL || *in == '\0' || strcmp(in, "$" "Mdocdate$") == 0) {
532 mandoc_msg(MANDOCERR_DATE_MISSING, man->parse, ln, pos, NULL);
533 return time2a(time(NULL));
534 }
535
536 /* Valid mdoc(7) date format. */
537
538 if (a2time(&t, "$" "Mdocdate: %b %d %Y $", in) ||
539 a2time(&t, "%b %d, %Y", in)) {
540 cp = time2a(t);
541 if (t > time(NULL) + 86400)
542 mandoc_msg(MANDOCERR_DATE_FUTURE, man->parse,
543 ln, pos, cp);
544 else if (*in != '$' && strcmp(in, cp) != 0)
545 mandoc_msg(MANDOCERR_DATE_NORM, man->parse,
546 ln, pos, cp);
547 return cp;
548 }
549
550 /* In man(7), do not warn about the legacy format. */
551
552 if (a2time(&t, "%Y-%m-%d", in) == 0)
553 mandoc_msg(MANDOCERR_DATE_BAD, man->parse, ln, pos, in);
554 else if (t > time(NULL) + 86400)
555 mandoc_msg(MANDOCERR_DATE_FUTURE, man->parse, ln, pos, in);
556 else if (man->macroset == MACROSET_MDOC)
557 mandoc_vmsg(MANDOCERR_DATE_LEGACY, man->parse,
558 ln, pos, "Dd %s", in);
559
560 /* Use any non-mdoc(7) date verbatim. */
561
562 return mandoc_strdup(in);
563 }
564
565 int
566 mandoc_eos(const char *p, size_t sz)
567 {
568 const char *q;
569 int enclosed, found;
570
571 if (0 == sz)
572 return 0;
573
574 /*
575 * End-of-sentence recognition must include situations where
576 * some symbols, such as `)', allow prior EOS punctuation to
577 * propagate outward.
578 */
579
580 enclosed = found = 0;
581 for (q = p + (int)sz - 1; q >= p; q--) {
582 switch (*q) {
583 case '\"':
584 case '\'':
585 case ']':
586 case ')':
587 if (0 == found)
588 enclosed = 1;
589 break;
590 case '.':
591 case '!':
592 case '?':
593 found = 1;
594 break;
595 default:
596 return found &&
597 (!enclosed || isalnum((unsigned char)*q));
598 }
599 }
600
601 return found && !enclosed;
602 }
603
604 /*
605 * Convert a string to a long that may not be <0.
606 * If the string is invalid, or is less than 0, return -1.
607 */
608 int
609 mandoc_strntoi(const char *p, size_t sz, int base)
610 {
611 char buf[32];
612 char *ep;
613 long v;
614
615 if (sz > 31)
616 return -1;
617
618 memcpy(buf, p, sz);
619 buf[(int)sz] = '\0';
620
621 errno = 0;
622 v = strtol(buf, &ep, base);
623
624 if (buf[0] == '\0' || *ep != '\0')
625 return -1;
626
627 if (v > INT_MAX)
628 v = INT_MAX;
629 if (v < INT_MIN)
630 v = INT_MIN;
631
632 return (int)v;
633 }