=================================================================== RCS file: /cvs/mandoc/mandoc.c,v retrieving revision 1.23 retrieving revision 1.91 diff -u -p -r1.23 -r1.91 --- mandoc/mandoc.c 2010/07/18 17:00:26 1.23 +++ mandoc/mandoc.c 2015/01/21 20:33:25 1.91 @@ -1,191 +1,458 @@ -/* $Id: mandoc.c,v 1.23 2010/07/18 17:00:26 schwarze Exp $ */ +/* $Id: mandoc.c,v 1.91 2015/01/21 20:33:25 schwarze Exp $ */ /* - * Copyright (c) 2008, 2009, 2010 Kristaps Dzonsons + * Copyright (c) 2008-2011, 2014 Kristaps Dzonsons + * Copyright (c) 2011-2015 Ingo Schwarze * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above * copyright notice and this permission notice appear in all copies. * - * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES + * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHORS DISCLAIM ALL WARRANTIES * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF - * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR + * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. */ -#ifdef HAVE_CONFIG_H #include "config.h" -#endif #include #include #include +#include +#include #include #include #include #include #include "mandoc.h" +#include "mandoc_aux.h" #include "libmandoc.h" +#define DATESIZE 32 + static int a2time(time_t *, const char *, const char *); +static char *time2a(time_t); -int -mandoc_special(char *p) +enum mandoc_esc +mandoc_escape(const char **end, const char **start, int *sz) { - int len, i; + const char *local_start; + int local_sz; char term; - char *sv; - - len = 0; + enum mandoc_esc gly; + + /* + * When the caller doesn't provide return storage, + * use local storage. + */ + + if (NULL == start) + start = &local_start; + if (NULL == sz) + sz = &local_sz; + + /* + * Beyond the backslash, at least one input character + * is part of the escape sequence. With one exception + * (see below), that character won't be returned. + */ + + gly = ESCAPE_ERROR; + *start = ++*end; + *sz = 0; term = '\0'; - sv = p; - assert('\\' == *p); - p++; + switch ((*start)[-1]) { + /* + * First the glyphs. There are several different forms of + * these, but each eventually returns a substring of the glyph + * name. + */ + case '(': + gly = ESCAPE_SPECIAL; + *sz = 2; + break; + case '[': + gly = ESCAPE_SPECIAL; + term = ']'; + break; + case 'C': + if ('\'' != **start) + return(ESCAPE_ERROR); + *start = ++*end; + gly = ESCAPE_SPECIAL; + term = '\''; + break; - switch (*p++) { - case ('s'): - if (ASCII_HYPH == *p) - *p = '-'; - if ('+' == *p || '-' == *p) - p++; + /* + * Escapes taking no arguments at all. + */ + case 'd': + /* FALLTHROUGH */ + case 'u': + return(ESCAPE_IGNORE); - i = ('s' != *(p - 1)); + /* + * The \z escape is supposed to output the following + * character without advancing the cursor position. + * Since we are mostly dealing with terminal mode, + * let us just skip the next character. + */ + case 'z': + return(ESCAPE_SKIPCHAR); - switch (*p++) { - case ('('): - len = 2; + /* + * Handle all triggers matching \X(xy, \Xx, and \X[xxxx], where + * 'X' is the trigger. These have opaque sub-strings. + */ + case 'F': + /* FALLTHROUGH */ + case 'g': + /* FALLTHROUGH */ + case 'k': + /* FALLTHROUGH */ + case 'M': + /* FALLTHROUGH */ + case 'm': + /* FALLTHROUGH */ + case 'n': + /* FALLTHROUGH */ + case 'V': + /* FALLTHROUGH */ + case 'Y': + gly = ESCAPE_IGNORE; + /* FALLTHROUGH */ + case 'f': + if (ESCAPE_ERROR == gly) + gly = ESCAPE_FONT; + switch (**start) { + case '(': + *start = ++*end; + *sz = 2; break; - case ('['): + case '[': + *start = ++*end; term = ']'; break; - case ('\''): - term = '\''; - break; default: - len = 1; - p--; + *sz = 1; break; } + break; - if (ASCII_HYPH == *p) - *p = '-'; - if ('+' == *p || '-' == *p) { - if (i++) - return(0); - p++; - } - - if (0 == i) - return(0); + /* + * These escapes are of the form \X'Y', where 'X' is the trigger + * and 'Y' is any string. These have opaque sub-strings. + * The \B and \w escapes are handled in roff.c, roff_res(). + */ + case 'A': + /* FALLTHROUGH */ + case 'b': + /* FALLTHROUGH */ + case 'D': + /* FALLTHROUGH */ + case 'R': + /* FALLTHROUGH */ + case 'X': + /* FALLTHROUGH */ + case 'Z': + gly = ESCAPE_IGNORE; + /* FALLTHROUGH */ + case 'o': + if (**start == '\0') + return(ESCAPE_ERROR); + if (gly == ESCAPE_ERROR) + gly = ESCAPE_OVERSTRIKE; + term = **start; + *start = ++*end; break; - case ('f'): + + /* + * These escapes are of the form \X'N', where 'X' is the trigger + * and 'N' resolves to a numerical expression. + */ + case 'h': /* FALLTHROUGH */ - case ('F'): + case 'H': /* FALLTHROUGH */ - case ('*'): - switch (*p++) { - case ('('): - len = 2; + case 'L': + /* FALLTHROUGH */ + case 'l': + /* FALLTHROUGH */ + case 'S': + /* FALLTHROUGH */ + case 'v': + /* FALLTHROUGH */ + case 'x': + if (strchr(" %&()*+-./0123456789:<=>", **start)) { + if ('\0' != **start) + ++*end; + return(ESCAPE_ERROR); + } + gly = ESCAPE_IGNORE; + term = **start; + *start = ++*end; + break; + + /* + * Special handling for the numbered character escape. + * XXX Do any other escapes need similar handling? + */ + case 'N': + if ('\0' == **start) + return(ESCAPE_ERROR); + (*end)++; + if (isdigit((unsigned char)**start)) { + *sz = 1; + return(ESCAPE_IGNORE); + } + (*start)++; + while (isdigit((unsigned char)**end)) + (*end)++; + *sz = *end - *start; + if ('\0' != **end) + (*end)++; + return(ESCAPE_NUMBERED); + + /* + * Sizes get a special category of their own. + */ + case 's': + gly = ESCAPE_IGNORE; + + /* See +/- counts as a sign. */ + if ('+' == **end || '-' == **end || ASCII_HYPH == **end) + *start = ++*end; + + switch (**end) { + case '(': + *start = ++*end; + *sz = 2; break; - case ('['): + case '[': + *start = ++*end; term = ']'; break; + case '\'': + *start = ++*end; + term = '\''; + break; default: - len = 1; - p--; + *sz = 1; break; } + break; - case ('('): - len = 2; - break; - case ('['): - term = ']'; - break; + + /* + * Anything else is assumed to be a glyph. + * In this case, pass back the character after the backslash. + */ default: - len = 1; - p--; + gly = ESCAPE_SPECIAL; + *start = --*end; + *sz = 1; break; } - if (term) { - for ( ; *p && term != *p; p++) - if (ASCII_HYPH == *p) - *p = '-'; - return(*p ? p - sv : 0); - } + assert(ESCAPE_ERROR != gly); - for (i = 0; *p && i < len; i++, p++) - if (ASCII_HYPH == *p) - *p = '-'; - return(i == len ? p - sv : 0); -} + /* + * Read up to the terminating character, + * paying attention to nested escapes. + */ - -void * -mandoc_calloc(size_t num, size_t size) -{ - void *ptr; - - ptr = calloc(num, size); - if (NULL == ptr) { - perror(NULL); - exit(EXIT_FAILURE); + if ('\0' != term) { + while (**end != term) { + switch (**end) { + case '\0': + return(ESCAPE_ERROR); + case '\\': + (*end)++; + if (ESCAPE_ERROR == + mandoc_escape(end, NULL, NULL)) + return(ESCAPE_ERROR); + break; + default: + (*end)++; + break; + } + } + *sz = (*end)++ - *start; + } else { + assert(*sz > 0); + if ((size_t)*sz > strlen(*start)) + return(ESCAPE_ERROR); + *end += *sz; } - return(ptr); -} + /* Run post-processors. */ + switch (gly) { + case ESCAPE_FONT: + if (2 == *sz) { + if ('C' == **start) { + /* + * Treat constant-width font modes + * just like regular font modes. + */ + (*start)++; + (*sz)--; + } else { + if ('B' == (*start)[0] && 'I' == (*start)[1]) + gly = ESCAPE_FONTBI; + break; + } + } else if (1 != *sz) + break; -void * -mandoc_malloc(size_t size) -{ - void *ptr; - - ptr = malloc(size); - if (NULL == ptr) { - perror(NULL); - exit(EXIT_FAILURE); + switch (**start) { + case '3': + /* FALLTHROUGH */ + case 'B': + gly = ESCAPE_FONTBOLD; + break; + case '2': + /* FALLTHROUGH */ + case 'I': + gly = ESCAPE_FONTITALIC; + break; + case 'P': + gly = ESCAPE_FONTPREV; + break; + case '1': + /* FALLTHROUGH */ + case 'R': + gly = ESCAPE_FONTROMAN; + break; + } + break; + case ESCAPE_SPECIAL: + if (1 == *sz && 'c' == **start) + gly = ESCAPE_NOSPACE; + /* + * Unicode escapes are defined in groff as \[u0000] + * to \[u10FFFF], where the contained value must be + * a valid Unicode codepoint. Here, however, only + * check the length and range. + */ + if (**start != 'u' || *sz < 5 || *sz > 7) + break; + if (*sz == 7 && ((*start)[1] != '1' || (*start)[2] != '0')) + break; + if (*sz == 6 && (*start)[1] == '0') + break; + if ((int)strspn(*start + 1, "0123456789ABCDEFabcdef") + + 1 == *sz) + gly = ESCAPE_UNICODE; + break; + default: + break; } - return(ptr); + return(gly); } - -void * -mandoc_realloc(void *ptr, size_t size) +/* + * Parse a quoted or unquoted roff-style request or macro argument. + * Return a pointer to the parsed argument, which is either the original + * pointer or advanced by one byte in case the argument is quoted. + * NUL-terminate the argument in place. + * Collapse pairs of quotes inside quoted arguments. + * Advance the argument pointer to the next argument, + * or to the NUL byte terminating the argument line. + */ +char * +mandoc_getarg(struct mparse *parse, char **cpp, int ln, int *pos) { + char *start, *cp; + int quoted, pairs, white; - ptr = realloc(ptr, size); - if (NULL == ptr) { - perror(NULL); - exit(EXIT_FAILURE); + /* Quoting can only start with a new word. */ + start = *cpp; + quoted = 0; + if ('"' == *start) { + quoted = 1; + start++; } - return(ptr); -} + pairs = 0; + white = 0; + for (cp = start; '\0' != *cp; cp++) { + /* + * Move the following text left + * after quoted quotes and after "\\" and "\t". + */ + if (pairs) + cp[-pairs] = cp[0]; -char * -mandoc_strdup(const char *ptr) -{ - char *p; + if ('\\' == cp[0]) { + /* + * In copy mode, translate double to single + * backslashes and backslash-t to literal tabs. + */ + switch (cp[1]) { + case 't': + cp[0] = '\t'; + /* FALLTHROUGH */ + case '\\': + pairs++; + cp++; + break; + case ' ': + /* Skip escaped blanks. */ + if (0 == quoted) + cp++; + break; + default: + break; + } + } else if (0 == quoted) { + if (' ' == cp[0]) { + /* Unescaped blanks end unquoted args. */ + white = 1; + break; + } + } else if ('"' == cp[0]) { + if ('"' == cp[1]) { + /* Quoted quotes collapse. */ + pairs++; + cp++; + } else { + /* Unquoted quotes end quoted args. */ + quoted = 2; + break; + } + } + } - p = strdup(ptr); - if (NULL == p) { - perror(NULL); - exit(EXIT_FAILURE); + /* Quoted argument without a closing quote. */ + if (1 == quoted) + mandoc_msg(MANDOCERR_ARG_QUOTE, parse, ln, *pos, NULL); + + /* NUL-terminate this argument and move to the next one. */ + if (pairs) + cp[-pairs] = '\0'; + if ('\0' != *cp) { + *cp++ = '\0'; + while (' ' == *cp) + cp++; } + *pos += (int)(cp - start) + (quoted ? 1 : 0); + *cpp = cp; - return(p); + if ('\0' == *cp && (white || ' ' == cp[-1])) + mandoc_msg(MANDOCERR_SPACE_EOL, parse, ln, *pos, NULL); + + return(start); } - static int a2time(time_t *t, const char *fmt, const char *p) { @@ -194,7 +461,10 @@ a2time(time_t *t, const char *fmt, const char *p) memset(&tm, 0, sizeof(struct tm)); + pp = NULL; +#if HAVE_STRPTIME pp = strptime(p, fmt, &tm); +#endif if (NULL != pp && '\0' == *pp) { *t = mktime(&tm); return(1); @@ -203,47 +473,70 @@ a2time(time_t *t, const char *fmt, const char *p) return(0); } - -/* - * Convert from a manual date string (see mdoc(7) and man(7)) into a - * date according to the stipulated date type. - */ -time_t -mandoc_a2time(int flags, const char *p) +static char * +time2a(time_t t) { - time_t t; + struct tm *tm; + char *buf, *p; + size_t ssz; + int isz; - if (MTIME_MDOCDATE & flags) { - if (0 == strcmp(p, "$" "Mdocdate$")) - return(time(NULL)); - if (a2time(&t, "$" "Mdocdate: %b %d %Y $", p)) - return(t); - } + tm = localtime(&t); + if (tm == NULL) + return(NULL); - if (MTIME_CANONICAL & flags || MTIME_REDUCED & flags) - if (a2time(&t, "%b %d, %Y", p)) - return(t); + /* + * Reserve space: + * up to 9 characters for the month (September) + blank + * up to 2 characters for the day + comma + blank + * 4 characters for the year and a terminating '\0' + */ + p = buf = mandoc_malloc(10 + 4 + 4 + 1); - if (MTIME_ISO_8601 & flags) - if (a2time(&t, "%Y-%m-%d", p)) - return(t); + if (0 == (ssz = strftime(p, 10 + 1, "%B ", tm))) + goto fail; + p += (int)ssz; - if (MTIME_REDUCED & flags) { - if (a2time(&t, "%d, %Y", p)) - return(t); - if (a2time(&t, "%Y", p)) - return(t); - } + if (-1 == (isz = snprintf(p, 4 + 1, "%d, ", tm->tm_mday))) + goto fail; + p += isz; - return(0); + if (0 == strftime(p, 4 + 1, "%Y", tm)) + goto fail; + return(buf); + +fail: + free(buf); + return(NULL); } +char * +mandoc_normdate(struct mparse *parse, char *in, int ln, int pos) +{ + char *out; + time_t t; + if (NULL == in || '\0' == *in || + 0 == strcmp(in, "$" "Mdocdate$")) { + mandoc_msg(MANDOCERR_DATE_MISSING, parse, ln, pos, NULL); + time(&t); + } + else if (a2time(&t, "%Y-%m-%d", in)) + t = 0; + else if (!a2time(&t, "$" "Mdocdate: %b %d %Y $", in) && + !a2time(&t, "%b %d, %Y", in)) { + mandoc_msg(MANDOCERR_DATE_BAD, parse, ln, pos, in); + t = 0; + } + out = t ? time2a(t) : NULL; + return(out ? out : mandoc_strdup(in)); +} + int -mandoc_eos(const char *p, size_t sz, int enclosed) +mandoc_eos(const char *p, size_t sz) { - const char *q; - int found; + const char *q; + int enclosed, found; if (0 == sz) return(0); @@ -251,61 +544,64 @@ mandoc_eos(const char *p, size_t sz, int enclosed) /* * End-of-sentence recognition must include situations where * some symbols, such as `)', allow prior EOS punctuation to - * propogate outward. + * propagate outward. */ - found = 0; - for (q = p + sz - 1; q >= p; q--) { + enclosed = found = 0; + for (q = p + (int)sz - 1; q >= p; q--) { switch (*q) { - case ('\"'): + case '\"': /* FALLTHROUGH */ - case ('\''): + case '\'': /* FALLTHROUGH */ - case (']'): + case ']': /* FALLTHROUGH */ - case (')'): + case ')': if (0 == found) enclosed = 1; break; - case ('.'): + case '.': /* FALLTHROUGH */ - case ('!'): + case '!': /* FALLTHROUGH */ - case ('?'): + case '?': found = 1; break; default: - return(found && (!enclosed || isalnum(*q))); + return(found && (!enclosed || isalnum((unsigned char)*q))); } } return(found && !enclosed); } - +/* + * Convert a string to a long that may not be <0. + * If the string is invalid, or is less than 0, return -1. + */ int -mandoc_hyph(const char *start, const char *c) +mandoc_strntoi(const char *p, size_t sz, int base) { + char buf[32]; + char *ep; + long v; - /* - * Choose whether to break at a hyphenated character. We only - * do this if it's free-standing within a word. - */ + if (sz > 31) + return(-1); - /* Skip first/last character of buffer. */ - if (c == start || '\0' == *(c + 1)) - return(0); - /* Skip first/last character of word. */ - if ('\t' == *(c + 1) || '\t' == *(c - 1)) - return(0); - if (' ' == *(c + 1) || ' ' == *(c - 1)) - return(0); - /* Skip double invocations. */ - if ('-' == *(c + 1) || '-' == *(c - 1)) - return(0); - /* Skip escapes. */ - if ('\\' == *(c - 1)) - return(0); + memcpy(buf, p, sz); + buf[(int)sz] = '\0'; - return(1); + errno = 0; + v = strtol(buf, &ep, base); + + if (buf[0] == '\0' || *ep != '\0') + return(-1); + + if (v > INT_MAX) + v = INT_MAX; + if (v < INT_MIN) + v = INT_MIN; + + return((int)v); }