xref: /titanic_41/usr/src/cmd/mandoc/mandoc.c (revision ffb8ebfab4941f959e7caea93ecfb348cfa3515e)
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