=================================================================== RCS file: /cvs/mandoc/roff.c,v retrieving revision 1.198 retrieving revision 1.204 diff -u -p -r1.198 -r1.204 --- mandoc/roff.c 2014/03/08 04:43:54 1.198 +++ mandoc/roff.c 2014/04/07 15:07:13 1.204 @@ -1,4 +1,4 @@ -/* $Id: roff.c,v 1.198 2014/03/08 04:43:54 schwarze Exp $ */ +/* $Id: roff.c,v 1.204 2014/04/07 15:07:13 schwarze Exp $ */ /* * Copyright (c) 2010, 2011, 2012 Kristaps Dzonsons * Copyright (c) 2010-2014 Ingo Schwarze @@ -26,6 +26,7 @@ #include #include "mandoc.h" +#include "mandoc_aux.h" #include "libroff.h" #include "libmandoc.h" @@ -61,6 +62,7 @@ enum rofft { ROFF_ns, ROFF_ps, ROFF_rm, + ROFF_rr, ROFF_so, ROFF_ta, ROFF_tr, @@ -103,9 +105,8 @@ struct roffreg { }; struct roff { - enum mparset parsetype; /* requested parse type */ struct mparse *parse; /* parse point */ - int quick; /* skip standard macro deletion */ + int options; /* parse options */ struct roffnode *last; /* leaf of stack */ int rstack[RSTACK_MAX]; /* stack of !`ie' rules */ char control; /* control character */ @@ -180,6 +181,8 @@ static enum rofferr roff_cond_text(ROFF_ARGS); static enum rofferr roff_cond_sub(ROFF_ARGS); static enum rofferr roff_ds(ROFF_ARGS); static int roff_evalcond(const char *, int *); +static int roff_evalnum(const char *, int *, int *, int); +static int roff_evalpar(const char *, int *, int *); static int roff_evalstrcond(const char *, int *); static void roff_free1(struct roff *); static void roff_freereg(struct roffreg *); @@ -202,6 +205,7 @@ static enum rofferr roff_parsetext(char **, size_t *, static enum rofferr roff_res(struct roff *, char **, size_t *, int, int); static enum rofferr roff_rm(ROFF_ARGS); +static enum rofferr roff_rr(ROFF_ARGS); static void roff_setstr(struct roff *, const char *, const char *, int); static void roff_setstrn(struct roffkv **, const char *, @@ -251,6 +255,7 @@ static struct roffmac roffs[ROFF_MAX] = { { "ns", roff_line_ignore, NULL, NULL, 0, NULL }, { "ps", roff_line_ignore, NULL, NULL, 0, NULL }, { "rm", roff_rm, NULL, NULL, 0, NULL }, + { "rr", roff_rr, NULL, NULL, 0, NULL }, { "so", roff_so, NULL, NULL, 0, NULL }, { "ta", roff_line_ignore, NULL, NULL, 0, NULL }, { "tr", roff_tr, NULL, NULL, 0, NULL }, @@ -265,34 +270,36 @@ static struct roffmac roffs[ROFF_MAX] = { { NULL, roff_userdef, NULL, NULL, 0, NULL }, }; +/* not currently implemented: Ds em Eq LP Me PP pp Or Rd Sf SH */ const char *const __mdoc_reserved[] = { "Ac", "Ad", "An", "Ao", "Ap", "Aq", "Ar", "At", "Bc", "Bd", "Bf", "Bk", "Bl", "Bo", "Bq", "Brc", "Bro", "Brq", "Bsx", "Bt", "Bx", "Cd", "Cm", "Db", "Dc", "Dd", "Dl", "Do", "Dq", - "Ds", "Dt", "Dv", "Dx", "D1", - "Ec", "Ed", "Ef", "Ek", "El", "Em", "em", - "En", "Eo", "Eq", "Er", "Es", "Ev", "Ex", + "Dt", "Dv", "Dx", "D1", + "Ec", "Ed", "Ef", "Ek", "El", "Em", + "En", "Eo", "Er", "Es", "Ev", "Ex", "Fa", "Fc", "Fd", "Fl", "Fn", "Fo", "Fr", "Ft", "Fx", - "Hf", "Ic", "In", "It", "Lb", "Li", "Lk", "Lp", "LP", - "Me", "Ms", "Mt", "Nd", "Nm", "No", "Ns", "Nx", + "Hf", "Ic", "In", "It", "Lb", "Li", "Lk", "Lp", + "Ms", "Mt", "Nd", "Nm", "No", "Ns", "Nx", "Oc", "Oo", "Op", "Os", "Ot", "Ox", - "Pa", "Pc", "Pf", "Po", "Pp", "PP", "pp", "Pq", - "Qc", "Ql", "Qo", "Qq", "Or", "Rd", "Re", "Rs", "Rv", - "Sc", "Sf", "Sh", "SH", "Sm", "So", "Sq", + "Pa", "Pc", "Pf", "Po", "Pp", "Pq", + "Qc", "Ql", "Qo", "Qq", "Re", "Rs", "Rv", + "Sc", "Sh", "Sm", "So", "Sq", "Ss", "St", "Sx", "Sy", "Ta", "Tn", "Ud", "Ux", "Va", "Vt", "Xc", "Xo", "Xr", - "%A", "%B", "%D", "%I", "%J", "%N", "%O", + "%A", "%B", "%C", "%D", "%I", "%J", "%N", "%O", "%P", "%Q", "%R", "%T", "%U", "%V", NULL }; +/* not currently implemented: BT DE DS ME MT PT SY TQ YS */ const char *const __man_reserved[] = { - "AT", "B", "BI", "BR", "BT", "DE", "DS", "DT", - "EE", "EN", "EQ", "EX", "HF", "HP", "I", "IB", "IP", "IR", - "LP", "ME", "MT", "OP", "P", "PD", "PP", "PT", - "R", "RB", "RE", "RI", "RS", "SB", "SH", "SM", "SS", "SY", - "TE", "TH", "TP", "TQ", "TS", "T&", "UC", "UE", "UR", "YS", + "AT", "B", "BI", "BR", "DT", + "EE", "EN", "EQ", "EX", "HP", "I", "IB", "IP", "IR", + "LP", "OP", "P", "PD", "PP", + "R", "RB", "RE", "RI", "RS", "SB", "SH", "SM", "SS", + "TE", "TH", "TP", "TS", "T&", "UC", "UE", "UR", NULL }; @@ -463,14 +470,13 @@ roff_free(struct roff *r) struct roff * -roff_alloc(enum mparset type, struct mparse *parse, int quick) +roff_alloc(struct mparse *parse, int options) { struct roff *r; r = mandoc_calloc(1, sizeof(struct roff)); - r->parsetype = type; r->parse = parse; - r->quick = quick; + r->options = options; r->rstackpos = -1; roffhash_init(); @@ -655,11 +661,7 @@ roff_parsetext(char **bufp, size_t *szp, int pos, int /* Spring the input line trap. */ if (1 == roffit_lines) { - isz = asprintf(&p, "%s\n.%s", *bufp, roffit_macro); - if (-1 == isz) { - perror(NULL); - exit((int)MANDOCLEVEL_SYSERR); - } + isz = mandoc_asprintf(&p, "%s\n.%s", *bufp, roffit_macro); free(*bufp); *bufp = p; *szp = isz + 1; @@ -1107,6 +1109,12 @@ roff_cond_text(ROFF_ARGS) return(rr ? ROFF_CONT : ROFF_IGN); } +/* + * Parse a single signed integer number. Stop at the first non-digit. + * If there is at least one digit, return success and advance the + * parse point, else return failure and let the parse point unchanged. + * Ignore overflows, treat them just like the C language. + */ static int roff_getnum(const char *v, int *pos, int *res) { @@ -1118,7 +1126,7 @@ roff_getnum(const char *v, int *pos, int *res) p++; for (*res = 0; isdigit((unsigned char)v[p]); p++) - *res += 10 * *res + v[p] - '0'; + *res = 10 * *res + v[p] - '0'; if (p == *pos + n) return 0; @@ -1129,34 +1137,6 @@ roff_getnum(const char *v, int *pos, int *res) return 1; } -static int -roff_getop(const char *v, int *pos, char *res) -{ - int e; - - *res = v[*pos]; - e = v[*pos + 1] == '='; - - switch (*res) { - case '=': - break; - case '>': - if (e) - *res = 'g'; - break; - case '<': - if (e) - *res = 'l'; - break; - default: - return(0); - } - - *pos += 1 + e; - - return(*res); -} - /* * Evaluate a string comparison condition. * The first character is the delimiter. @@ -1200,11 +1180,14 @@ out: return(match); } +/* + * Evaluate an optionally negated single character, numerical, + * or string condition. + */ static int roff_evalcond(const char *v, int *pos) { - int wanttrue, lh, rh; - char op; + int wanttrue, number; if ('!' == v[*pos]) { wanttrue = 0; @@ -1233,27 +1216,10 @@ roff_evalcond(const char *v, int *pos) break; } - if (!roff_getnum(v, pos, &lh)) + if (roff_evalnum(v, pos, &number, 0)) + return((number > 0) == wanttrue); + else return(roff_evalstrcond(v, pos) == wanttrue); - if (!roff_getop(v, pos, &op)) - return((lh > 0) == wanttrue); - if (!roff_getnum(v, pos, &rh)) - return(0); - - switch (op) { - case 'g': - return((lh >= rh) == wanttrue); - case 'l': - return((lh <= rh) == wanttrue); - case '=': - return((lh == rh) == wanttrue); - case '>': - return((lh > rh) == wanttrue); - case '<': - return((lh < rh) == wanttrue); - default: - return(0); - } } /* ARGSUSED */ @@ -1371,6 +1337,194 @@ roff_ds(ROFF_ARGS) return(ROFF_IGN); } +/* + * Parse a single operator, one or two characters long. + * If the operator is recognized, return success and advance the + * parse point, else return failure and let the parse point unchanged. + */ +static int +roff_getop(const char *v, int *pos, char *res) +{ + + *res = v[*pos]; + + switch (*res) { + case ('+'): + /* FALLTHROUGH */ + case ('-'): + /* FALLTHROUGH */ + case ('*'): + /* FALLTHROUGH */ + case ('/'): + /* FALLTHROUGH */ + case ('%'): + /* FALLTHROUGH */ + case ('&'): + /* FALLTHROUGH */ + case (':'): + break; + case '<': + switch (v[*pos + 1]) { + case ('='): + *res = 'l'; + (*pos)++; + break; + case ('>'): + *res = '!'; + (*pos)++; + break; + case ('?'): + *res = 'i'; + (*pos)++; + break; + default: + break; + } + break; + case '>': + switch (v[*pos + 1]) { + case ('='): + *res = 'g'; + (*pos)++; + break; + case ('?'): + *res = 'a'; + (*pos)++; + break; + default: + break; + } + break; + case '=': + if ('=' == v[*pos + 1]) + (*pos)++; + break; + default: + return(0); + } + (*pos)++; + + return(*res); +} + +/* + * Evaluate either a parenthesized numeric expression + * or a single signed integer number. + */ +static int +roff_evalpar(const char *v, int *pos, int *res) +{ + + if ('(' != v[*pos]) + return(roff_getnum(v, pos, res)); + + (*pos)++; + if ( ! roff_evalnum(v, pos, res, 1)) + return(0); + + /* If the trailing parenthesis is missing, ignore the error. */ + if (')' == v[*pos]) + (*pos)++; + + return(1); +} + +/* + * Evaluate a complete numeric expression. + * Proceed left to right, there is no concept of precedence. + */ +static int +roff_evalnum(const char *v, int *pos, int *res, int skipwhite) +{ + int mypos, operand2; + char operator; + + if (NULL == pos) { + mypos = 0; + pos = &mypos; + } + + if (skipwhite) + while (isspace((unsigned char)v[*pos])) + (*pos)++; + + if ( ! roff_evalpar(v, pos, res)) + return(0); + + while (1) { + if (skipwhite) + while (isspace((unsigned char)v[*pos])) + (*pos)++; + + if ( ! roff_getop(v, pos, &operator)) + break; + + if (skipwhite) + while (isspace((unsigned char)v[*pos])) + (*pos)++; + + if ( ! roff_evalpar(v, pos, &operand2)) + return(0); + + if (skipwhite) + while (isspace((unsigned char)v[*pos])) + (*pos)++; + + switch (operator) { + case ('+'): + *res += operand2; + break; + case ('-'): + *res -= operand2; + break; + case ('*'): + *res *= operand2; + break; + case ('/'): + *res /= operand2; + break; + case ('%'): + *res %= operand2; + break; + case ('<'): + *res = *res < operand2; + break; + case ('>'): + *res = *res > operand2; + break; + case ('l'): + *res = *res <= operand2; + break; + case ('g'): + *res = *res >= operand2; + break; + case ('='): + *res = *res == operand2; + break; + case ('!'): + *res = *res != operand2; + break; + case ('&'): + *res = *res && operand2; + break; + case (':'): + *res = *res || operand2; + break; + case ('i'): + if (operand2 < *res) + *res = operand2; + break; + case ('a'): + if (operand2 > *res) + *res = operand2; + break; + default: + abort(); + } + } + return(1); +} + void roff_setreg(struct roff *r, const char *name, int val, char sign) { @@ -1480,13 +1634,11 @@ roff_freereg(struct roffreg *reg) } } -/* ARGSUSED */ static enum rofferr roff_nr(ROFF_ARGS) { const char *key; char *val; - size_t sz; int iv; char sign; @@ -1497,11 +1649,34 @@ roff_nr(ROFF_ARGS) if ('+' == sign || '-' == sign) val++; - sz = strspn(val, "0123456789"); - iv = sz ? mandoc_strntoi(val, sz, 10) : 0; + if (roff_evalnum(val, NULL, &iv, 0)) + roff_setreg(r, key, iv, sign); - roff_setreg(r, key, iv, sign); + return(ROFF_IGN); +} +static enum rofferr +roff_rr(ROFF_ARGS) +{ + struct roffreg *reg, **prev; + const char *name; + char *cp; + + cp = *bufp + pos; + name = roff_getname(r, &cp, ln, pos); + + prev = &r->regtab; + while (1) { + reg = *prev; + if (NULL == reg || !strcmp(name, reg->key.p)) + break; + prev = ®->next; + } + if (NULL != reg) { + *prev = reg->next; + free(reg->key.p); + free(reg); + } return(ROFF_IGN); } @@ -1552,7 +1727,7 @@ roff_Dd(ROFF_ARGS) { const char *const *cp; - if (0 == r->quick && MPARSE_MDOC != r->parsetype) + if (0 == ((MPARSE_MDOC | MPARSE_QUICK) & r->options)) for (cp = __mdoc_reserved; *cp; cp++) roff_setstr(r, *cp, NULL, 0); @@ -1565,7 +1740,7 @@ roff_TH(ROFF_ARGS) { const char *const *cp; - if (0 == r->quick && MPARSE_MDOC != r->parsetype) + if (0 == (MPARSE_QUICK & r->options)) for (cp = __man_reserved; *cp; cp++) roff_setstr(r, *cp, NULL, 0);