mandoc/mandoc.c - diff

Return to mandoc.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/mandoc.c between version 1.76 and 1.97

version 1.76, 2014/03/23 11:25:26

version 1.97, 2015/10/15 23:35:55

Line 1

/* $Id$ */

* Permission to use, copy, modify, and distribute this software for any

* purpose with or without fee is hereby granted, provided that the above

Line 15

* 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 <sys/types.h>

Line 34

Line 32

#include "mandoc_aux.h"

#include "libmandoc.h"

#define DATESIZE 32

static int a2time(time_t *, const char *, const char *);

static char *time2a(time_t);

Line 46 mandoc_escape(const char **end, const char **start, in

Line 42 mandoc_escape(const char **end, const char **start, in

const char *local_start;

int local_sz;

char term;

enum mandoc_esc gly;

* When the caller doesn't provide return storage,

Line 75 mandoc_escape(const char **end, const char **start, in

Line 71 mandoc_escape(const char **end, const char **start, in

* these, but each eventually returns a substring of the glyph

* name.

case ('('):

case '(':

gly = ESCAPE_SPECIAL;

*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' == (*start)[0] && ']' != (*start)[1])

gly = ESCAPE_UNICODE;

term = ']';

break;

case ('C'):

case 'C':

if ('\'' != **start)

return(ESCAPE_ERROR);

return ESCAPE_ERROR;

*start = ++*end;

if ('u' == (*start)[0] && '\'' != (*start)[1])

gly = ESCAPE_SPECIAL;

gly = ESCAPE_UNICODE;

else

gly = ESCAPE_SPECIAL;

term = '\'';

break;

* Escapes taking no arguments at all.

case ('d'):

case 'd':

/* FALLTHROUGH */

case 'u':

case ('u'):

case ',':

return(ESCAPE_IGNORE);

case '/':

return ESCAPE_IGNORE;

* 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'):

case 'z':

return(ESCAPE_SKIPCHAR);

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'):

case 'k':

/* FALLTHROUGH */

case 'M':

case ('k'):

case 'm':

/* FALLTHROUGH */

case 'n':

case ('M'):

case 'V':

/* FALLTHROUGH */

case 'Y':

case ('m'):

/* FALLTHROUGH */

case ('n'):

/* FALLTHROUGH */

case ('V'):

/* FALLTHROUGH */

case ('Y'):

gly = ESCAPE_IGNORE;

/* FALLTHROUGH */

case ('f'):

case 'f':

if (ESCAPE_ERROR == gly)

gly = ESCAPE_FONT;

switch (**start) {

case ('('):

case '(':

*start = ++*end;

*sz = 2;

break;

case ('['):

case '[':

*start = ++*end;

term = ']';

break;

Line 161 mandoc_escape(const char **end, const char **start, in

Line 140 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'):

case 'D':

/* FALLTHROUGH */

case 'R':

case ('B'):

case 'X':

/* FALLTHROUGH */

case 'Z':

case ('D'):

/* FALLTHROUGH */

case ('o'):

/* FALLTHROUGH */

case ('R'):

/* FALLTHROUGH */

case ('w'):

/* FALLTHROUGH */

case ('X'):

/* FALLTHROUGH */

case ('Z'):

if ('\'' != **start)

return(ESCAPE_ERROR);

gly = ESCAPE_IGNORE;

/* FALLTHROUGH */

case 'o':

if (**start == '\0')

return ESCAPE_ERROR;

if (gly == ESCAPE_ERROR)

gly = ESCAPE_OVERSTRIKE;

term = **start;

*start = ++*end;

term = '\'';

break;

* These escapes are of the form \X'N', where 'X' is the trigger

* and 'N' resolves to a numerical expression.

case ('h'):

case 'h':

/* FALLTHROUGH */

case 'H':

case ('H'):

case 'L':

/* FALLTHROUGH */

case 'l':

case ('L'):

case 'S':

/* FALLTHROUGH */

case 'v':

case ('l'):

case 'x':

/* FALLTHROUGH */

if (strchr(" %&()*+-./0123456789:<=>", **start)) {

case ('S'):

if ('\0' != **start)

/* FALLTHROUGH */

++*end;

case ('v'):

return ESCAPE_ERROR;

/* FALLTHROUGH */

}

case ('x'):

if ('\'' != **start)

return(ESCAPE_ERROR);

gly = ESCAPE_IGNORE;

term = **start;

*start = ++*end;

term = '\'';

break;

* Special handling for the numbered character escape.

* XXX Do any other escapes need similar handling?

case ('N'):

case 'N':

if ('\0' == **start)

return(ESCAPE_ERROR);

return ESCAPE_ERROR;

(*end)++;

if (isdigit((unsigned char)**start)) {

*sz = 1;

return(ESCAPE_IGNORE);

return ESCAPE_IGNORE;

}

(*start)++;

while (isdigit((unsigned char)**end))

Line 228 mandoc_escape(const char **end, const char **start, in

Line 198 mandoc_escape(const char **end, const char **start, in

*sz = *end - *start;

if ('\0' != **end)

(*end)++;

return(ESCAPE_NUMBERED);

return ESCAPE_NUMBERED;

* Sizes get a special category of their own.

case ('s'):

case 's':

gly = ESCAPE_IGNORE;

/* See +/- counts as a sign. */

if ('+' == **end || '-' == **end || ASCII_HYPH == **end)

(*end)++;

*start = ++*end;

switch (**end) {

case ('('):

case '(':

*start = ++*end;

*sz = 2;

break;

case ('['):

case '[':

*start = ++*end;

term = ']';

break;

case ('\''):

case '\'':

*start = ++*end;

term = '\'';

break;

case '3':

case '2':

case '1':

*sz = (*end)[-1] == 's' &&

isdigit((unsigned char)(*end)[1]) ? 2 : 1;

break;

default:

*sz = 1;

break;

Line 281 mandoc_escape(const char **end, const char **start, in

Line 257 mandoc_escape(const char **end, const char **start, in

if ('\0' != term) {

while (**end != term) {

switch (**end) {

case ('\0'):

case '\0':

return(ESCAPE_ERROR);

return ESCAPE_ERROR;

case ('\\'):

case '\\':

(*end)++;

if (ESCAPE_ERROR ==

mandoc_escape(end, NULL, NULL))

return(ESCAPE_ERROR);

return ESCAPE_ERROR;

break;

default:

(*end)++;

Line 298 mandoc_escape(const char **end, const char **start, in

Line 274 mandoc_escape(const char **end, const char **start, in

} else {

assert(*sz > 0);

if ((size_t)*sz > strlen(*start))

return(ESCAPE_ERROR);

return ESCAPE_ERROR;

*end += *sz;

}

/* Run post-processors. */

switch (gly) {

case (ESCAPE_FONT):

case ESCAPE_FONT:

if (2 == *sz) {

if ('C' == **start) {

Line 323 mandoc_escape(const char **end, const char **start, in

Line 299 mandoc_escape(const char **end, const char **start, in

break;

switch (**start) {

case ('3'):

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):

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 (*sz == 5 && (*start)[1] == 'D' &&

strchr("89ABCDEF", (*start)[2]) != NULL)

break;

if ((int)strspn(*start + 1, "0123456789ABCDEFabcdef")

+ 1 == *sz)

gly = ESCAPE_UNICODE;

break;

default:

break;

}

return(gly);

return gly;

}

Line 375 mandoc_getarg(struct mparse *parse, char **cpp, int ln

Line 366 mandoc_getarg(struct mparse *parse, char **cpp, int ln

if ('"' == *start) {

quoted = 1;

start++;

}

pairs = 0;

white = 0;

Line 394 mandoc_getarg(struct mparse *parse, char **cpp, int ln

Line 385 mandoc_getarg(struct mparse *parse, char **cpp, int ln

* backslashes and backslash-t to literal tabs.

switch (cp[1]) {

case ('t'):

case 't':

cp[0] = '\t';

/* FALLTHROUGH */

case ('\\'):

case '\\':

pairs++;

cp++;

break;

case (' '):

case ' ':

/* Skip escaped blanks. */

if (0 == quoted)

cp++;

Line 430 mandoc_getarg(struct mparse *parse, char **cpp, int ln

Line 421 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);

/* NUL-terminate this argument and move to the next one. */

if (pairs)

Line 444 mandoc_getarg(struct mparse *parse, char **cpp, int ln

Line 435 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);

return start;

}

static int

Line 458 a2time(time_t *t, const char *fmt, const char *p)

Line 449 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) {

*t = mktime(&tm);

return(1);

return 1;

}

return(0);

return 0;

}

static char *

Line 478 time2a(time_t t)

Line 469 time2a(time_t t)

int isz;

tm = localtime(&t);

if (tm == NULL)

return NULL;

* Reserve space:

Line 497 time2a(time_t t)

Line 490 time2a(time_t t)

if (0 == strftime(p, 4 + 1, "%Y", tm))

goto fail;

return(buf);

return buf;

fail:

free(buf);

return(NULL);

return NULL;

}

char *

Line 512 mandoc_normdate(struct mparse *parse, char *in, int ln

Line 505 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;

return(out ? out : mandoc_strdup(in));

return out ? out : mandoc_strdup(in);

}

int

Line 533 mandoc_eos(const char *p, size_t sz)

Line 526 mandoc_eos(const char *p, size_t sz)

int enclosed, found;

if (0 == sz)

return(0);

return 0;

* End-of-sentence recognition must include situations where

Line 544 mandoc_eos(const char *p, size_t sz)

Line 537 mandoc_eos(const char *p, size_t sz)

enclosed = found = 0;

for (q = p + (int)sz - 1; q >= p; q--) {

switch (*q) {

case ('\"'):

case '\"':

/* FALLTHROUGH */

case '\'':

case ('\''):

case ']':

/* FALLTHROUGH */

case ')':

case (']'):

/* FALLTHROUGH */

case (')'):

if (0 == found)

enclosed = 1;

break;

case ('.'):

case '.':

/* FALLTHROUGH */

case '!':

case ('!'):

case '?':

/* FALLTHROUGH */

case ('?'):

found = 1;

break;

default:

return(found && (!enclosed || isalnum((unsigned char)*q)));

return found &&

(!enclosed || isalnum((unsigned char)*q));

}

return(found && !enclosed);

return found && !enclosed;

}

Line 581 mandoc_strntoi(const char *p, size_t sz, int base)

Line 570 mandoc_strntoi(const char *p, size_t sz, int base)

long v;

if (sz > 31)

return(-1);

return -1;

memcpy(buf, p, sz);

buf[(int)sz] = '\0';

Line 590 mandoc_strntoi(const char *p, size_t sz, int base)

Line 579 mandoc_strntoi(const char *p, size_t sz, int base)

v = strtol(buf, &ep, base);

if (buf[0] == '\0' || *ep != '\0')

return(-1);

return -1;

if (v > INT_MAX)

v = INT_MAX;

if (v < INT_MIN)

v = INT_MIN;

return((int)v);

return (int)v;

}

CVSweb