-/* $Id: roff.c,v 1.276 2015/09/26 00:54:04 schwarze Exp $ */
+/* $Id: roff.c,v 1.293 2017/03/09 15:29:35 schwarze Exp $ */
/*
* Copyright (c) 2008-2012, 2014 Kristaps Dzonsons <kristaps@bsd.lv>
- * Copyright (c) 2010-2015 Ingo Schwarze <schwarze@openbsd.org>
+ * Copyright (c) 2010-2015, 2017 Ingo Schwarze <schwarze@openbsd.org>
*
* Permission to use, copy, modify, and distribute this software for any
* purpose with or without fee is hereby granted, provided that the above
#include "roff_int.h"
#include "libroff.h"
-/* Maximum number of nested if-else conditionals. */
-#define RSTACK_MAX 128
-
/* Maximum number of string expansions per line, to break infinite loops. */
#define EXPAND_LIMIT 1000
struct roff {
struct mparse *parse; /* parse point */
- const struct mchars *mchars; /* character table */
struct roffnode *last; /* leaf of stack */
int *rstack; /* stack of inverted `ie' values */
struct roffreg *regtab; /* number registers */
*/
if (p[0] < ASCII_LO || p[0] > ASCII_HI)
- return(ROFF_MAX);
+ return ROFF_MAX;
buc = ROFF_HASH(p);
if (NULL == (n = hash[buc]))
- return(ROFF_MAX);
+ return ROFF_MAX;
for ( ; n; n = n->next)
if (0 == strncmp(n->name, p, s) && '\0' == n->name[(int)s])
- return((enum rofft)(n - roffs));
+ return (enum rofft)(n - roffs);
- return(ROFF_MAX);
+ return ROFF_MAX;
}
/* --- stack of request blocks -------------------------------------------- */
}
struct roff *
-roff_alloc(struct mparse *parse, const struct mchars *mchars, int options)
+roff_alloc(struct mparse *parse, int options)
{
struct roff *r;
r = mandoc_calloc(1, sizeof(struct roff));
r->parse = parse;
- r->mchars = mchars;
r->options = options;
r->format = options & (MPARSE_MDOC | MPARSE_MAN);
r->rstackpos = -1;
roffhash_init();
- return(r);
+ return r;
}
/* --- syntax tree state data management ---------------------------------- */
man->defos = defos;
man->quick = quick;
roff_man_alloc1(man);
- return(man);
+ return man;
}
/* --- syntax tree handling ----------------------------------------------- */
n->sec = man->lastsec;
if (man->flags & MDOC_SYNOPSIS)
- n->flags |= MDOC_SYNPRETTY;
+ n->flags |= NODE_SYNPRETTY;
else
- n->flags &= ~MDOC_SYNPRETTY;
+ n->flags &= ~NODE_SYNPRETTY;
if (man->flags & MDOC_NEWLINE)
- n->flags |= MDOC_LINE;
+ n->flags |= NODE_LINE;
man->flags &= ~MDOC_NEWLINE;
- return(n);
+ return n;
}
void
switch (man->next) {
case ROFF_NEXT_SIBLING:
+ if (man->last->next != NULL) {
+ n->next = man->last->next;
+ man->last->next->prev = n;
+ } else
+ man->last->parent->last = n;
man->last->next = n;
n->prev = man->last;
n->parent = man->last->parent;
break;
case ROFF_NEXT_CHILD:
+ if (man->last->child != NULL) {
+ n->next = man->last->child;
+ man->last->child->prev = n;
+ } else
+ man->last->last = n;
man->last->child = n;
n->parent = man->last;
break;
default:
abort();
}
- n->parent->nchild++;
- n->parent->last = n;
-
- /*
- * Copy over the normalised-data pointer of our parent. Not
- * everybody has one, but copying a null pointer is fine.
- */
-
- switch (n->type) {
- case ROFFT_BODY:
- if (n->end != ENDBODY_NOT)
- break;
- /* FALLTHROUGH */
- case ROFFT_TAIL:
- /* FALLTHROUGH */
- case ROFFT_HEAD:
- n->norm = n->parent->norm;
- break;
- default:
- break;
- }
-
- if (man->macroset == MACROSET_MDOC)
- mdoc_valid_pre(man, n);
+ man->last = n;
switch (n->type) {
case ROFFT_HEAD:
- assert(n->parent->type == ROFFT_BLOCK);
n->parent->head = n;
break;
case ROFFT_BODY:
- if (n->end)
- break;
- assert(n->parent->type == ROFFT_BLOCK);
+ if (n->end != ENDBODY_NOT)
+ return;
n->parent->body = n;
break;
case ROFFT_TAIL:
- assert(n->parent->type == ROFFT_BLOCK);
n->parent->tail = n;
break;
default:
- break;
+ return;
}
- man->last = n;
+
+ /*
+ * Copy over the normalised-data pointer of our parent. Not
+ * everybody has one, but copying a null pointer is fine.
+ */
+
+ n->norm = n->parent->norm;
+ assert(n->parent->type == ROFFT_BLOCK);
}
void
n = roff_node_alloc(man, line, pos, ROFFT_TEXT, TOKEN_NONE);
n->string = roff_strdup(man->roff, word);
roff_node_append(man, n);
- if (man->macroset == MACROSET_MDOC)
- mdoc_valid_post(man);
- else
- man_valid_post(man);
+ n->flags |= NODE_VALID | NODE_ENDED;
man->next = ROFF_NEXT_SIBLING;
}
n = roff_node_alloc(man, line, pos, ROFFT_BLOCK, tok);
roff_node_append(man, n);
man->next = ROFF_NEXT_CHILD;
- return(n);
+ return n;
}
struct roff_node *
n = roff_node_alloc(man, line, pos, ROFFT_HEAD, tok);
roff_node_append(man, n);
man->next = ROFF_NEXT_CHILD;
- return(n);
+ return n;
}
struct roff_node *
n = roff_node_alloc(man, line, pos, ROFFT_BODY, tok);
roff_node_append(man, n);
man->next = ROFF_NEXT_CHILD;
- return(n);
+ return n;
}
void
n = roff_node_alloc(man, eqn->ln, eqn->pos, ROFFT_EQN, TOKEN_NONE);
n->eqn = eqn;
if (eqn->ln > man->last->line)
- n->flags |= MDOC_LINE;
+ n->flags |= NODE_LINE;
roff_node_append(man, n);
man->next = ROFF_NEXT_SIBLING;
}
n = roff_node_alloc(man, tbl->line, 0, ROFFT_TBL, TOKEN_NONE);
n->span = tbl;
roff_node_append(man, n);
- if (man->macroset == MACROSET_MDOC)
- mdoc_valid_post(man);
- else
- man_valid_post(man);
+ n->flags |= NODE_VALID | NODE_ENDED;
man->next = ROFF_NEXT_SIBLING;
}
/* Adjust parent. */
if (n->parent != NULL) {
- n->parent->nchild--;
if (n->parent->child == n)
n->parent->child = n->next;
if (n->parent->last == n)
while (n->child != NULL)
roff_node_delete(man, n->child);
- assert(n->nchild == 0);
roff_node_unlink(man, n);
roff_node_free(n);
}
return;
}
- /* Skip leading whitespace and escape sequences. */
+ /* Skip leading whitespace. */
- cp = n->string;
- while (*cp != '\0') {
- if ('\\' == *cp) {
+ for (cp = n->string; *cp != '\0'; cp++) {
+ if (cp[0] == '\\' && cp[1] != '\0' &&
+ strchr(" %&0^|~", cp[1]) != NULL)
cp++;
- mandoc_escape((const char **)&cp, NULL, NULL);
- } else if (isspace((unsigned char)*cp))
- cp++;
- else
+ else if ( ! isspace((unsigned char)*cp))
break;
}
+ /* Skip trailing backslash. */
+
+ sz = strlen(cp);
+ if (sz > 0 && cp[sz - 1] == '\\')
+ sz--;
+
/* Skip trailing whitespace. */
- for (sz = strlen(cp); sz; sz--)
+ for (; sz; sz--)
if ( ! isspace((unsigned char)cp[sz-1]))
break;
res = NULL;
break;
case 'B':
- /* FALLTHROUGH */
case 'w':
term = cp[1];
/* FALLTHROUGH */
esc = mandoc_escape(&cp, &stnam, &inaml);
if (esc == ESCAPE_ERROR ||
(esc == ESCAPE_SPECIAL &&
- mchars_spec2cp(r->mchars, stnam, inaml) < 0))
+ mchars_spec2cp(stnam, inaml) < 0))
mandoc_vmsg(MANDOCERR_ESC_BAD,
r->parse, ln, (int)(stesc - buf->buf),
"%.*s", (int)(cp - stesc), stesc);
if (EXPAND_LIMIT < ++expand_count) {
mandoc_msg(MANDOCERR_ROFFLOOP, r->parse,
ln, (int)(stesc - buf->buf), NULL);
- return(ROFF_IGN);
+ return ROFF_IGN;
}
/*
}
switch (mandoc_escape(&cp, NULL, NULL)) {
case ESCAPE_SPECIAL:
- /* FALLTHROUGH */
case ESCAPE_UNICODE:
- /* FALLTHROUGH */
case ESCAPE_NUMBERED:
- /* FALLTHROUGH */
case ESCAPE_OVERSTRIKE:
naml++;
break;
} else if (buf->sz + strlen(res) > SHRT_MAX) {
mandoc_msg(MANDOCERR_ROFFLOOP, r->parse,
ln, (int)(stesc - buf->buf), NULL);
- return(ROFF_IGN);
+ return ROFF_IGN;
}
/* Replace the escape sequence by the string. */
free(buf->buf);
buf->buf = nbuf;
}
- return(ROFF_CONT);
+ return ROFF_CONT;
}
/*
*offs = 0;
free(roffit_macro);
roffit_lines = 0;
- return(ROFF_REPARSE);
+ return ROFF_REPARSE;
} else if (roffit_lines > 1)
--roffit_lines;
*p = ASCII_HYPH;
p++;
}
- return(ROFF_CONT);
+ return ROFF_CONT;
}
enum rofferr
(r->eqn == NULL || r->eqn_inline)) {
e = roff_eqndelim(r, buf, pos);
if (e == ROFF_REPARSE)
- return(e);
+ return e;
assert(e == ROFF_CONT);
}
e = roff_res(r, buf, ln, pos);
if (e == ROFF_IGN)
- return(e);
+ return e;
assert(e == ROFF_CONT);
ctl = roff_getcontrol(r, buf->buf, &pos);
e = (*roffs[t].text)(r, t, buf, ln, pos, pos, offs);
assert(e == ROFF_IGN || e == ROFF_CONT);
if (e != ROFF_CONT)
- return(e);
+ return e;
}
if (r->eqn != NULL)
- return(eqn_read(&r->eqn, ln, buf->buf, ppos, offs));
+ return eqn_read(&r->eqn, ln, buf->buf, ppos, offs);
if (r->tbl != NULL && ( ! ctl || buf->buf[pos] == '\0'))
- return(tbl_read(r->tbl, ln, buf->buf, ppos));
+ return tbl_read(r->tbl, ln, buf->buf, ppos);
if ( ! ctl)
- return(roff_parsetext(buf, pos, offs));
+ return roff_parsetext(buf, pos, offs);
/* Skip empty request lines. */
if (buf->buf[pos] == '"') {
mandoc_msg(MANDOCERR_COMMENT_BAD, r->parse,
ln, pos, NULL);
- return(ROFF_IGN);
+ return ROFF_IGN;
} else if (buf->buf[pos] == '\0')
- return(ROFF_IGN);
+ return ROFF_IGN;
/*
* If a scope is open, go to the child handler for that macro,
if (r->last) {
t = r->last->tok;
assert(roffs[t].sub);
- return((*roffs[t].sub)(r, t, buf, ln, ppos, pos, offs));
+ return (*roffs[t].sub)(r, t, buf, ln, ppos, pos, offs);
}
/* No scope is open. This is a new request or macro. */
mandoc_msg(MANDOCERR_TBLMACRO, r->parse,
ln, pos, buf->buf + spos);
if (t == ROFF_TS)
- return(ROFF_IGN);
+ return ROFF_IGN;
while (buf->buf[pos] != '\0' && buf->buf[pos] != ' ')
pos++;
- while (buf->buf[pos] != '\0' && buf->buf[pos] == ' ')
+ while (buf->buf[pos] == ' ')
pos++;
- return(tbl_read(r->tbl, ln, buf->buf, pos));
+ return tbl_read(r->tbl, ln, buf->buf, pos);
}
/*
*/
if (t == ROFF_MAX)
- return(ROFF_CONT);
+ return ROFF_CONT;
/* Execute a roff request or a user defined macro. */
assert(roffs[t].proc);
- return((*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs));
+ return (*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs);
}
void
cp = buf + *pos;
if ('\0' == *cp || '"' == *cp || '\t' == *cp || ' ' == *cp)
- return(ROFF_MAX);
+ return ROFF_MAX;
mac = cp;
maclen = roff_getname(r, &cp, ln, ppos);
if (ROFF_MAX != t)
*pos = cp - buf;
- return(t);
+ return t;
}
/* --- handling of request blocks ----------------------------------------- */
if (r->last == NULL) {
mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse,
ln, ppos, "..");
- return(ROFF_IGN);
+ return ROFF_IGN;
}
switch (r->last->tok) {
case ROFF_am:
/* ROFF_am1 is remapped to ROFF_am in roff_block(). */
- /* FALLTHROUGH */
case ROFF_ami:
- /* FALLTHROUGH */
case ROFF_de:
/* ROFF_de1 is remapped to ROFF_de in roff_block(). */
- /* FALLTHROUGH */
case ROFF_dei:
- /* FALLTHROUGH */
case ROFF_ig:
break;
default:
mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse,
ln, ppos, "..");
- return(ROFF_IGN);
+ return ROFF_IGN;
}
if (buf->buf[pos] != '\0')
roffnode_pop(r);
roffnode_cleanscope(r);
- return(ROFF_IGN);
+ return ROFF_IGN;
}
switch (r->last->tok) {
case ROFF_el:
- /* FALLTHROUGH */
case ROFF_ie:
- /* FALLTHROUGH */
case ROFF_if:
break;
default:
if (namesz == 0 && tok != ROFF_ig) {
mandoc_msg(MANDOCERR_REQ_EMPTY, r->parse,
ln, ppos, roffs[tok].name);
- return(ROFF_IGN);
+ return ROFF_IGN;
}
roffnode_push(r, tok, name, ln, ppos);
roff_setstrn(&r->strtab, name, namesz, "", 0, 0);
if (*cp == '\0')
- return(ROFF_IGN);
+ return ROFF_IGN;
/* Get the custom end marker. */
mandoc_vmsg(MANDOCERR_ARG_EXCESS, r->parse,
ln, pos, ".%s ... %s", roffs[tok].name, cp);
- return(ROFF_IGN);
+ return ROFF_IGN;
}
static enum rofferr
pos = i;
if (roff_parse(r, buf->buf, &pos, ln, ppos) !=
ROFF_MAX)
- return(ROFF_RERUN);
- return(ROFF_IGN);
+ return ROFF_RERUN;
+ return ROFF_IGN;
}
}
if (t != ROFF_cblock) {
if (tok != ROFF_ig)
roff_setstr(r, r->last->name, buf->buf + ppos, 2);
- return(ROFF_IGN);
+ return ROFF_IGN;
}
assert(roffs[t].proc);
- return((*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs));
+ return (*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs);
}
static enum rofferr
if (tok != ROFF_ig)
roff_setstr(r, r->last->name, buf->buf + pos, 2);
- return(ROFF_IGN);
+ return ROFF_IGN;
}
static enum rofferr
if ((t != ROFF_MAX) &&
(rr || roffs[t].flags & ROFFMAC_STRUCT)) {
assert(roffs[t].proc);
- return((*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs));
+ return (*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs);
}
/*
if (*ep != '\0')
++ep;
}
- return(rr ? ROFF_CONT : ROFF_IGN);
+ return rr ? ROFF_CONT : ROFF_IGN;
}
static enum rofferr
if (*ep != '\0')
++ep;
}
- return(rr ? ROFF_CONT : ROFF_IGN);
+ return rr ? ROFF_CONT : ROFF_IGN;
}
/* --- handling of numeric and conditional expressions -------------------- */
scaled = *res * 240 / 2.54;
break;
case 'v':
- /* FALLTHROUGH */
case 'P':
scaled = *res * 40;
break;
case 'm':
- /* FALLTHROUGH */
case 'n':
scaled = *res * 24;
break;
*res = scaled;
*pos = p + 1;
- return(1);
+ return 1;
}
/*
else if (*s3 != '\0')
s3++;
*pos = s3 - v;
- return(match);
+ return match;
}
/*
switch (v[*pos]) {
case '\0':
- return(0);
+ return 0;
case 'n':
- /* FALLTHROUGH */
case 'o':
(*pos)++;
- return(wanttrue);
+ return wanttrue;
case 'c':
- /* FALLTHROUGH */
case 'd':
- /* FALLTHROUGH */
case 'e':
- /* FALLTHROUGH */
case 't':
- /* FALLTHROUGH */
case 'v':
(*pos)++;
- return(!wanttrue);
+ return !wanttrue;
case 'r':
cp = name = v + ++*pos;
sz = roff_getname(r, &cp, ln, *pos);
*pos = cp - v;
- return((sz && roff_hasregn(r, name, sz)) == wanttrue);
+ return (sz && roff_hasregn(r, name, sz)) == wanttrue;
default:
break;
}
savepos = *pos;
if (roff_evalnum(r, ln, v, pos, &number, ROFFNUM_SCALE))
- return((number > 0) == wanttrue);
+ return (number > 0) == wanttrue;
else if (*pos == savepos)
- return(roff_evalstrcond(v, pos) == wanttrue);
+ return roff_evalstrcond(v, pos) == wanttrue;
else
- return (0);
+ return 0;
}
static enum rofferr
roff_line_ignore(ROFF_ARGS)
{
- return(ROFF_IGN);
+ return ROFF_IGN;
}
static enum rofferr
mandoc_msg(MANDOCERR_REQ_INSEC, r->parse,
ln, ppos, roffs[tok].name);
- return(ROFF_IGN);
+ return ROFF_IGN;
}
static enum rofferr
mandoc_msg(MANDOCERR_REQ_UNSUPP, r->parse,
ln, ppos, roffs[tok].name);
- return(ROFF_IGN);
+ return ROFF_IGN;
}
static enum rofferr
out:
*offs = pos;
- return(ROFF_RERUN);
+ return ROFF_RERUN;
}
static enum rofferr
name = string = buf->buf + pos;
if (*name == '\0')
- return(ROFF_IGN);
+ return ROFF_IGN;
namesz = roff_getname(r, &string, ln, pos);
if (name[namesz] == '\\')
- return(ROFF_IGN);
+ return ROFF_IGN;
/* Read past the initial double-quote, if any. */
if (*string == '"')
/* The rest is the value. */
roff_setstrn(&r->strtab, name, namesz, string, strlen(string),
ROFF_as == tok);
- return(ROFF_IGN);
+ return ROFF_IGN;
}
/*
switch (*res) {
case '+':
- /* FALLTHROUGH */
case '-':
- /* FALLTHROUGH */
case '*':
- /* FALLTHROUGH */
case '/':
- /* FALLTHROUGH */
case '%':
- /* FALLTHROUGH */
case '&':
- /* FALLTHROUGH */
case ':':
break;
case '<':
(*pos)++;
break;
default:
- return(0);
+ return 0;
}
(*pos)++;
- return(*res);
+ return *res;
}
/*
{
if ('(' != v[*pos])
- return(roff_getnum(v, pos, res, flags));
+ return roff_getnum(v, pos, res, flags);
(*pos)++;
if ( ! roff_evalnum(r, ln, v, pos, res, flags | ROFFNUM_WHITE))
- return(0);
+ return 0;
/*
* Omission of the closing parenthesis
if (')' == v[*pos])
(*pos)++;
else if (NULL == res)
- return(0);
+ return 0;
- return(1);
+ return 1;
}
/*
(*pos)++;
if ( ! roff_evalpar(r, ln, v, pos, res, flags))
- return(0);
+ return 0;
while (1) {
if (flags & ROFFNUM_WHITE)
(*pos)++;
if ( ! roff_evalpar(r, ln, v, pos, &operand2, flags))
- return(0);
+ return 0;
if (flags & ROFFNUM_WHITE)
while (isspace((unsigned char)v[*pos]))
abort();
}
}
- return(1);
+ return 1;
}
/* --- register management ------------------------------------------------ */
switch (*name) {
case '$': /* Number of arguments of the last macro evaluated. */
- return(r->argc);
+ return r->argc;
case 'A': /* ASCII approximation mode is always off. */
- return(0);
+ return 0;
case 'g': /* Groff compatibility mode is always on. */
- return(1);
+ return 1;
case 'H': /* Fixed horizontal resolution. */
- return (24);
+ return 24;
case 'j': /* Always adjust left margin only. */
- return(0);
+ return 0;
case 'T': /* Some output device is always defined. */
- return(1);
+ return 1;
case 'V': /* Fixed vertical resolution. */
- return (40);
+ return 40;
default:
- return (-1);
+ return -1;
}
}
if ('.' == name[0] && '\0' != name[1] && '\0' == name[2]) {
val = roff_getregro(r, name + 1);
if (-1 != val)
- return (val);
+ return val;
}
for (reg = r->regtab; reg; reg = reg->next)
if (0 == strcmp(name, reg->key.p))
- return(reg->val);
+ return reg->val;
- return(0);
+ return 0;
}
static int
if ('.' == name[0] && 2 == len) {
val = roff_getregro(r, name + 1);
if (-1 != val)
- return (val);
+ return val;
}
for (reg = r->regtab; reg; reg = reg->next)
if (len == reg->key.sz &&
0 == strncmp(name, reg->key.p, len))
- return(reg->val);
+ return reg->val;
- return(0);
+ return 0;
}
static int
if ('.' == name[0] && 2 == len) {
val = roff_getregro(r, name + 1);
if (-1 != val)
- return(1);
+ return 1;
}
for (reg = r->regtab; reg; reg = reg->next)
if (len == reg->key.sz &&
0 == strncmp(name, reg->key.p, len))
- return(1);
+ return 1;
- return(0);
+ return 0;
}
static void
key = val = buf->buf + pos;
if (*key == '\0')
- return(ROFF_IGN);
+ return ROFF_IGN;
keysz = roff_getname(r, &val, ln, pos);
if (key[keysz] == '\\')
- return(ROFF_IGN);
+ return ROFF_IGN;
key[keysz] = '\0';
sign = *val;
if (roff_evalnum(r, ln, val, NULL, &iv, ROFFNUM_SCALE))
roff_setreg(r, key, iv, sign);
- return(ROFF_IGN);
+ return ROFF_IGN;
}
static enum rofferr
name = cp = buf->buf + pos;
if (*name == '\0')
- return(ROFF_IGN);
+ return ROFF_IGN;
namesz = roff_getname(r, &cp, ln, pos);
name[namesz] = '\0';
free(reg->key.p);
free(reg);
}
- return(ROFF_IGN);
+ return ROFF_IGN;
}
/* --- handler functions for roff requests -------------------------------- */
if (name[namesz] == '\\')
break;
}
- return(ROFF_IGN);
+ return ROFF_IGN;
}
static enum rofferr
if ( ! roff_evalnum(r, ln, buf->buf, &pos, &iv, 0)) {
mandoc_msg(MANDOCERR_IT_NONUM, r->parse,
ln, ppos, buf->buf + 1);
- return(ROFF_IGN);
+ return ROFF_IGN;
}
while (isspace((unsigned char)buf->buf[pos]))
roffit_macro = mandoc_strdup(iv != 1 ||
strcmp(buf->buf + pos, "an-trap") ?
buf->buf + pos : "br");
- return(ROFF_IGN);
+ return ROFF_IGN;
}
static enum rofferr
if (r->format == 0)
r->format = MPARSE_MDOC;
- return(ROFF_CONT);
+ return ROFF_CONT;
}
static enum rofferr
if (r->format == 0)
r->format = MPARSE_MAN;
- return(ROFF_CONT);
+ return ROFF_CONT;
}
static enum rofferr
free(buf->buf);
buf->buf = mandoc_strdup(".sp");
buf->sz = 4;
- return(ROFF_REPARSE);
+ return ROFF_REPARSE;
}
- return(ROFF_IGN);
+ return ROFF_IGN;
}
static enum rofferr
else
tbl_restart(ppos, ln, r->tbl);
- return(ROFF_IGN);
+ return ROFF_IGN;
}
/*
cp2 = strchr(cp1, r->eqn == NULL ?
r->last_eqn->odelim : r->last_eqn->cdelim);
if (cp2 == NULL)
- return(ROFF_CONT);
+ return ROFF_CONT;
*cp2++ = '\0';
bef_pr = bef_nl = aft_nl = aft_pr = "";
/* Toggle the in-line state of the eqn subsystem. */
r->eqn_inline = r->eqn == NULL;
- return(ROFF_REPARSE);
+ return ROFF_REPARSE;
}
static enum rofferr
mandoc_vmsg(MANDOCERR_ARG_SKIP, r->parse, ln, pos,
".EQ %s", buf->buf + pos);
- return(ROFF_IGN);
+ return ROFF_IGN;
}
static enum rofferr
{
mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse, ln, ppos, "EN");
- return(ROFF_IGN);
+ return ROFF_IGN;
}
static enum rofferr
r->first_tbl = r->last_tbl = tbl;
r->tbl = r->last_tbl = tbl;
- return(ROFF_IGN);
+ return ROFF_IGN;
}
static enum rofferr
{
buf->buf[pos - 1] = '\0';
- return(ROFF_CONT);
+ return ROFF_CONT;
}
static enum rofferr
mandoc_vmsg(MANDOCERR_ARG_EXCESS, r->parse,
ln, p - buf->buf, "cc ... %s", p);
- return(ROFF_IGN);
+ return ROFF_IGN;
}
static enum rofferr
if (*p == '\0') {
mandoc_msg(MANDOCERR_REQ_EMPTY, r->parse, ln, ppos, "tr");
- return(ROFF_IGN);
+ return ROFF_IGN;
}
while (*p != '\0') {
if (esc == ESCAPE_ERROR) {
mandoc_msg(MANDOCERR_ESC_BAD, r->parse,
ln, (int)(p - buf->buf), first);
- return(ROFF_IGN);
+ return ROFF_IGN;
}
fsz = (size_t)(p - first);
}
if (esc == ESCAPE_ERROR) {
mandoc_msg(MANDOCERR_ESC_BAD, r->parse,
ln, (int)(p - buf->buf), second);
- return(ROFF_IGN);
+ return ROFF_IGN;
}
ssz = (size_t)(p - second);
} else if (*second == '\0') {
r->xtab[(int)*first].sz = ssz;
}
- return(ROFF_IGN);
+ return ROFF_IGN;
}
static enum rofferr
free(buf->buf);
buf->buf = cp;
*offs = 0;
- return(ROFF_REPARSE);
+ return ROFF_REPARSE;
}
*offs = pos;
- return(ROFF_SO);
+ return ROFF_SO;
}
/* --- user defined strings and macros ------------------------------------ */
{
const char *arg[9], *ap;
char *cp, *n1, *n2;
- int i, ib, ie;
+ int expand_count, i, ib, ie;
size_t asz, rsz;
/*
*/
buf->sz = strlen(r->current_string) + 1;
- n1 = cp = mandoc_malloc(buf->sz);
+ n1 = n2 = cp = mandoc_malloc(buf->sz);
memcpy(n1, r->current_string, buf->sz);
+ expand_count = 0;
while (*cp != '\0') {
/* Scan ahead for the next argument invocation. */
}
cp -= 2;
+ /*
+ * Prevent infinite recursion.
+ */
+
+ if (cp >= n2)
+ expand_count = 1;
+ else if (++expand_count > EXPAND_LIMIT) {
+ mandoc_msg(MANDOCERR_ROFFLOOP, r->parse,
+ ln, (int)(cp - n1), NULL);
+ free(buf->buf);
+ buf->buf = n1;
+ return ROFF_IGN;
+ }
+
/*
* Determine the size of the expanded argument,
* taking escaping of quotes into account.
buf->buf = n1;
*offs = 0;
- return(buf->sz > 1 && buf->buf[buf->sz - 2] == '\n' ?
- ROFF_REPARSE : ROFF_APPEND);
+ return buf->sz > 1 && buf->buf[buf->sz - 2] == '\n' ?
+ ROFF_REPARSE : ROFF_APPEND;
}
static size_t
name = *cpp;
if ('\0' == *name)
- return(0);
+ return 0;
/* Read until end of name and terminate it with NUL. */
for (cp = name; 1; cp++) {
cp++;
*cpp = cp;
- return(namesz);
+ return namesz;
}
/*
for (n = r->strtab; n; n = n->next)
if (0 == strncmp(name, n->key.p, len) &&
'\0' == n->key.p[(int)len])
- return(n->val.p);
+ return n->val.p;
for (i = 0; i < PREDEFS_MAX; i++)
if (0 == strncmp(name, predefs[i].name, len) &&
'\0' == predefs[i].name[(int)len])
- return(predefs[i].str);
+ return predefs[i].str;
- return(NULL);
+ return NULL;
}
static void
roff_span(const struct roff *r)
{
- return(r->tbl ? tbl_span(r->tbl) : NULL);
+ return r->tbl ? tbl_span(r->tbl) : NULL;
}
const struct eqn *
roff_eqn(const struct roff *r)
{
- return(r->last_eqn ? &r->last_eqn->eqn : NULL);
+ return r->last_eqn ? &r->last_eqn->eqn : NULL;
}
/*
enum mandoc_esc esc;
if (NULL == r->xmbtab && NULL == r->xtab)
- return(mandoc_strdup(p));
+ return mandoc_strdup(p);
else if ('\0' == *p)
- return(mandoc_strdup(""));
+ return mandoc_strdup("");
/*
* Step through each character looking for term matches
ssz = 0;
while ('\0' != *p) {
- if ('\\' != *p && r->xtab && r->xtab[(int)*p].p) {
+ assert((unsigned int)*p < 128);
+ if ('\\' != *p && r->xtab && r->xtab[(unsigned int)*p].p) {
sz = r->xtab[(int)*p].sz;
res = mandoc_realloc(res, ssz + sz + 1);
memcpy(res + ssz, r->xtab[(int)*p].p, sz);
}
res[(int)ssz] = '\0';
- return(res);
+ return res;
}
int
roff_getformat(const struct roff *r)
{
- return(r->format);
+ return r->format;
}
/*
if (0 != r->control && cp[pos] == r->control)
pos++;
else if (0 != r->control)
- return(0);
+ return 0;
else if ('\\' == cp[pos] && '.' == cp[pos + 1])
pos += 2;
else if ('.' == cp[pos] || '\'' == cp[pos])
pos++;
else
- return(0);
+ return 0;
while (' ' == cp[pos] || '\t' == cp[pos])
pos++;
*ppos = pos;
- return(1);
+ return 1;
}
git.ckatri.com / mandoc.git / blobdiff