=================================================================== RCS file: /cvs/mandoc/mandoc.c,v retrieving revision 1.64 retrieving revision 1.87 diff -u -p -r1.64 -r1.87 --- mandoc/mandoc.c 2012/05/31 22:34:06 1.64 +++ mandoc/mandoc.c 2014/10/13 17:17:45 1.87 @@ -1,7 +1,7 @@ -/* $Id: mandoc.c,v 1.64 2012/05/31 22:34:06 schwarze Exp $ */ +/* $Id: mandoc.c,v 1.87 2014/10/13 17:17:45 schwarze Exp $ */ /* * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons - * Copyright (c) 2011, 2012 Ingo Schwarze + * Copyright (c) 2011, 2012, 2013, 2014 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 @@ -15,9 +15,7 @@ * 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 @@ -31,6 +29,7 @@ #include #include "mandoc.h" +#include "mandoc_aux.h" #include "libmandoc.h" #define DATESIZE 32 @@ -42,97 +41,106 @@ static char *time2a(time_t); enum mandoc_esc mandoc_escape(const char **end, const char **start, int *sz) { - char c, term; - int i, rlim; - const char *cp, *rstart; - enum mandoc_esc gly; + const char *local_start; + int local_sz; + char term; + enum mandoc_esc gly; - cp = *end; - rstart = cp; - if (start) - *start = rstart; - i = rlim = 0; + /* + * 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'; - switch ((c = cp[i++])) { + switch ((*start)[-1]) { /* * First the glyphs. There are several different forms of * these, but each eventually returns a substring of the glyph * name. */ - case ('('): + case '(': gly = ESCAPE_SPECIAL; - rlim = 2; + *sz = 2; break; - case ('['): + case '[': gly = ESCAPE_SPECIAL; - /* - * Unicode escapes are defined in groff as \[uXXXX] to - * \[u10FFFF], where the contained value must be a valid - * Unicode codepoint. Here, however, only check whether - * it's not a zero-width escape. - */ - if ('u' == cp[i] && ']' != cp[i + 1]) - gly = ESCAPE_UNICODE; term = ']'; break; - case ('C'): - if ('\'' != cp[i]) + case 'C': + if ('\'' != **start) return(ESCAPE_ERROR); + *start = ++*end; gly = ESCAPE_SPECIAL; term = '\''; break; /* + * Escapes taking no arguments at all. + */ + case 'd': + /* FALLTHROUGH */ + case 'u': + return(ESCAPE_IGNORE); + + /* * The \z escape is supposed to output the following - * character without advancing the cursor position. + * character without advancing the cursor position. * Since we are mostly dealing with terminal mode, * let us just skip the next character. */ - case ('z'): - (*end)++; + case 'z': return(ESCAPE_SKIPCHAR); /* * Handle all triggers matching \X(xy, \Xx, and \X[xxxx], where * 'X' is the trigger. These have opaque sub-strings. */ - case ('F'): + case 'F': /* FALLTHROUGH */ - case ('g'): + case 'g': /* FALLTHROUGH */ - case ('k'): + case 'k': /* FALLTHROUGH */ - case ('M'): + case 'M': /* FALLTHROUGH */ - case ('m'): + case 'm': /* FALLTHROUGH */ - case ('n'): + case 'n': /* FALLTHROUGH */ - case ('V'): + case 'V': /* FALLTHROUGH */ - case ('Y'): + case 'Y': gly = ESCAPE_IGNORE; /* FALLTHROUGH */ - case ('f'): + case 'f': if (ESCAPE_ERROR == gly) gly = ESCAPE_FONT; - - rstart= &cp[i]; - if (start) - *start = rstart; - - switch (cp[i++]) { - case ('('): - rlim = 2; + switch (**start) { + case '(': + *start = ++*end; + *sz = 2; break; - case ('['): + case '[': + *start = ++*end; term = ']'; break; default: - rlim = 1; - i--; + *sz = 1; break; } break; @@ -140,129 +148,118 @@ mandoc_escape(const char **end, const char **start, in /* * 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'): + case 'A': /* FALLTHROUGH */ - case ('b'): + case 'b': /* FALLTHROUGH */ - case ('D'): + case 'D': /* FALLTHROUGH */ - case ('o'): + case 'o': /* FALLTHROUGH */ - case ('R'): + case 'R': /* FALLTHROUGH */ - case ('X'): + case 'X': /* FALLTHROUGH */ - case ('Z'): - if ('\'' != cp[i++]) + case 'Z': + if ('\0' == **start) return(ESCAPE_ERROR); gly = ESCAPE_IGNORE; - term = '\''; + term = **start; + *start = ++*end; break; /* * These escapes are of the form \X'N', where 'X' is the trigger * and 'N' resolves to a numerical expression. */ - case ('B'): + case 'h': /* FALLTHROUGH */ - case ('h'): + case 'H': /* FALLTHROUGH */ - case ('H'): + case 'L': /* FALLTHROUGH */ - case ('L'): + case 'l': /* FALLTHROUGH */ - case ('l'): - gly = ESCAPE_NUMBERED; + case 'S': /* FALLTHROUGH */ - case ('S'): + case 'v': /* FALLTHROUGH */ - case ('v'): - /* FALLTHROUGH */ - case ('w'): - /* FALLTHROUGH */ - case ('x'): - if (ESCAPE_ERROR == gly) - gly = ESCAPE_IGNORE; - if ('\'' != cp[i++]) + case 'x': + if (strchr(" %&()*+-./0123456789:<=>", **start)) { + if ('\0' != **start) + ++*end; return(ESCAPE_ERROR); - term = '\''; + } + 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' == cp[i]) + case 'N': + if ('\0' == **start) return(ESCAPE_ERROR); - *end = &cp[++i]; - if (isdigit((unsigned char)cp[i-1])) + (*end)++; + if (isdigit((unsigned char)**start)) { + *sz = 1; return(ESCAPE_IGNORE); + } + (*start)++; while (isdigit((unsigned char)**end)) (*end)++; - if (start) - *start = &cp[i]; - if (sz) - *sz = *end - &cp[i]; + *sz = *end - *start; if ('\0' != **end) (*end)++; return(ESCAPE_NUMBERED); - /* + /* * Sizes get a special category of their own. */ - case ('s'): + case 's': gly = ESCAPE_IGNORE; - rstart = &cp[i]; - if (start) - *start = rstart; - /* See +/- counts as a sign. */ - c = cp[i]; - if ('+' == c || '-' == c || ASCII_HYPH == c) - ++i; + if ('+' == **end || '-' == **end || ASCII_HYPH == **end) + (*end)++; - switch (cp[i++]) { - case ('('): - rlim = 2; + switch (**end) { + case '(': + *start = ++*end; + *sz = 2; break; - case ('['): + case '[': + *start = ++*end; term = ']'; break; - case ('\''): + case '\'': + *start = ++*end; term = '\''; break; default: - rlim = 1; - i--; + *sz = 1; break; } - /* See +/- counts as a sign. */ - c = cp[i]; - if ('+' == c || '-' == c || ASCII_HYPH == c) - ++i; - break; /* * Anything else is assumed to be a glyph. + * In this case, pass back the character after the backslash. */ default: gly = ESCAPE_SPECIAL; - rlim = 1; - i--; + *start = --*end; + *sz = 1; break; } assert(ESCAPE_ERROR != gly); - *end = rstart = &cp[i]; - if (start) - *start = rstart; - /* * Read up to the terminating character, * paying attention to nested escapes. @@ -271,9 +268,9 @@ mandoc_escape(const char **end, const char **start, in if ('\0' != term) { while (**end != term) { switch (**end) { - case ('\0'): + case '\0': return(ESCAPE_ERROR); - case ('\\'): + case '\\': (*end)++; if (ESCAPE_ERROR == mandoc_escape(end, NULL, NULL)) @@ -284,55 +281,68 @@ mandoc_escape(const char **end, const char **start, in break; } } - rlim = (*end)++ - rstart; + *sz = (*end)++ - *start; } else { - assert(rlim > 0); - if ((size_t)rlim > strlen(rstart)) + assert(*sz > 0); + if ((size_t)*sz > strlen(*start)) return(ESCAPE_ERROR); - *end += rlim; + *end += *sz; } - if (sz) - *sz = rlim; /* Run post-processors. */ switch (gly) { - case (ESCAPE_FONT): - /* - * Pretend that the constant-width font modes are the - * same as the regular font modes. - */ - if (2 == rlim && 'C' == *rstart) - rstart++; - else if (1 != rlim) + 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; - switch (*rstart) { - case ('3'): + switch (**start) { + case '3': /* FALLTHROUGH */ - case ('B'): + case 'B': gly = ESCAPE_FONTBOLD; break; - case ('2'): + case '2': /* FALLTHROUGH */ - case ('I'): + case 'I': gly = ESCAPE_FONTITALIC; break; - case ('P'): + case 'P': gly = ESCAPE_FONTPREV; break; - case ('1'): + case '1': /* FALLTHROUGH */ - case ('R'): + case 'R': gly = ESCAPE_FONTROMAN; break; } break; - case (ESCAPE_SPECIAL): - if (1 != rlim) - break; - if ('c' == *rstart) + case ESCAPE_SPECIAL: + if (1 == *sz && 'c' == **start) gly = ESCAPE_NOSPACE; + /* + * Unicode escapes are defined in groff as \[uXXXX] + * to \[u10FFFF], where the contained value must be + * a valid Unicode codepoint. Here, however, only + * check the length and the validity of all digits. + */ + else if (*sz > 4 && *sz < 8 && **start == 'u' && + (int)strspn(*start + 1, "0123456789ABCDEFabcdef") + + 1 == *sz) + gly = ESCAPE_UNICODE; break; default: break; @@ -341,82 +351,14 @@ mandoc_escape(const char **end, const char **start, in return(gly); } -void * -mandoc_calloc(size_t num, size_t size) -{ - void *ptr; - - ptr = calloc(num, size); - if (NULL == ptr) { - perror(NULL); - exit((int)MANDOCLEVEL_SYSERR); - } - - return(ptr); -} - - -void * -mandoc_malloc(size_t size) -{ - void *ptr; - - ptr = malloc(size); - if (NULL == ptr) { - perror(NULL); - exit((int)MANDOCLEVEL_SYSERR); - } - - return(ptr); -} - - -void * -mandoc_realloc(void *ptr, size_t size) -{ - - ptr = realloc(ptr, size); - if (NULL == ptr) { - perror(NULL); - exit((int)MANDOCLEVEL_SYSERR); - } - - return(ptr); -} - -char * -mandoc_strndup(const char *ptr, size_t sz) -{ - char *p; - - p = mandoc_malloc(sz + 1); - memcpy(p, ptr, sz); - p[(int)sz] = '\0'; - return(p); -} - -char * -mandoc_strdup(const char *ptr) -{ - char *p; - - p = strdup(ptr); - if (NULL == p) { - perror(NULL); - exit((int)MANDOCLEVEL_SYSERR); - } - - return(p); -} - /* * 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. - * Null-terminate the argument in place. + * NUL-terminate the argument in place. * Collapse pairs of quotes inside quoted arguments. * Advance the argument pointer to the next argument, - * or to the null byte terminating the argument line. + * or to the NUL byte terminating the argument line. */ char * mandoc_getarg(struct mparse *parse, char **cpp, int ln, int *pos) @@ -430,22 +372,40 @@ mandoc_getarg(struct mparse *parse, char **cpp, int ln if ('"' == *start) { quoted = 1; start++; - } + } pairs = 0; white = 0; for (cp = start; '\0' != *cp; cp++) { - /* Move left after quoted quotes and escaped backslashes. */ + + /* + * Move the following text left + * after quoted quotes and after "\\" and "\t". + */ if (pairs) cp[-pairs] = cp[0]; + if ('\\' == cp[0]) { - if ('\\' == cp[1]) { - /* Poor man's copy mode. */ + /* + * 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++; - } else if (0 == quoted && ' ' == cp[1]) + break; + case ' ': /* Skip escaped blanks. */ - cp++; + if (0 == quoted) + cp++; + break; + default: + break; + } } else if (0 == quoted) { if (' ' == cp[0]) { /* Unescaped blanks end unquoted args. */ @@ -467,9 +427,9 @@ mandoc_getarg(struct mparse *parse, char **cpp, int ln /* Quoted argument without a closing quote. */ if (1 == quoted) - mandoc_msg(MANDOCERR_BADQUOTE, parse, ln, *pos, NULL); + mandoc_msg(MANDOCERR_ARG_QUOTE, parse, ln, *pos, NULL); - /* Null-terminate this argument and move to the next one. */ + /* NUL-terminate this argument and move to the next one. */ if (pairs) cp[-pairs] = '\0'; if ('\0' != *cp) { @@ -481,7 +441,7 @@ mandoc_getarg(struct mparse *parse, char **cpp, int ln *cpp = cp; if ('\0' == *cp && (white || ' ' == cp[-1])) - mandoc_msg(MANDOCERR_EOLNSPACE, parse, ln, *pos, NULL); + mandoc_msg(MANDOCERR_SPACE_EOL, parse, ln, *pos, NULL); return(start); } @@ -495,7 +455,7 @@ a2time(time_t *t, const char *fmt, const char *p) memset(&tm, 0, sizeof(struct tm)); pp = NULL; -#ifdef HAVE_STRPTIME +#if HAVE_STRPTIME pp = strptime(p, fmt, &tm); #endif if (NULL != pp && '\0' == *pp) { @@ -549,14 +509,14 @@ mandoc_normdate(struct mparse *parse, char *in, int ln if (NULL == in || '\0' == *in || 0 == strcmp(in, "$" "Mdocdate$")) { - mandoc_msg(MANDOCERR_NODATE, parse, ln, pos, NULL); + 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_BADDATE, parse, ln, pos, NULL); + mandoc_msg(MANDOCERR_DATE_BAD, parse, ln, pos, in); t = 0; } out = t ? time2a(t) : NULL; @@ -564,10 +524,10 @@ mandoc_normdate(struct mparse *parse, char *in, int ln } 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); @@ -578,24 +538,24 @@ mandoc_eos(const char *p, size_t sz, int enclosed) * propagate outward. */ - found = 0; + 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: @@ -604,32 +564,6 @@ mandoc_eos(const char *p, size_t sz, int enclosed) } return(found && !enclosed); -} - -/* - * Find out whether a line is a macro line or not. If it is, adjust the - * current position and return one; if it isn't, return zero and don't - * change the current position. - */ -int -mandoc_getcontrol(const char *cp, int *ppos) -{ - int pos; - - pos = *ppos; - - if ('\\' == cp[pos] && '.' == cp[pos + 1]) - pos += 2; - else if ('.' == cp[pos] || '\'' == cp[pos]) - pos++; - else - return(0); - - while (' ' == cp[pos] || '\t' == cp[pos]) - pos++; - - *ppos = pos; - return(1); } /*