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