-/* $Id: roff.c,v 1.268 2015/04/19 14:57:38 schwarze Exp $ */
+/* $Id: roff.c,v 1.277 2015/10/06 18:32:20 schwarze Exp $ */
/*
* Copyright (c) 2008-2012, 2014 Kristaps Dzonsons <kristaps@bsd.lv>
* Copyright (c) 2010-2015 Ingo Schwarze <schwarze@openbsd.org>
int rstacksz; /* current size limit of rstack */
int rstackpos; /* position in rstack */
int format; /* current file in mdoc or man format */
+ int argc; /* number of args of the last macro */
char control; /* control character */
};
static enum rofferr roff_cond_sub(ROFF_ARGS);
static enum rofferr roff_ds(ROFF_ARGS);
static enum rofferr roff_eqndelim(struct roff *, struct buf *, int);
-static int roff_evalcond(struct roff *r, int,
- const char *, int *);
+static int roff_evalcond(struct roff *r, int, char *, int *);
static int roff_evalnum(struct roff *, int,
const char *, int *, int *, int);
static int roff_evalpar(struct roff *, int,
static int roff_getop(const char *, int *, char *);
static int roff_getregn(const struct roff *,
const char *, size_t);
-static int roff_getregro(const char *name);
+static int roff_getregro(const struct roff *,
+ const char *name);
static const char *roff_getstrn(const struct roff *,
const char *, size_t);
+static int roff_hasregn(const struct roff *,
+ const char *, size_t);
static enum rofferr roff_insec(ROFF_ARGS);
static enum rofferr roff_it(ROFF_ARGS);
static enum rofferr roff_line_ignore(ROFF_ARGS);
*/
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 -------------------------------------------- */
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->flags |= MDOC_LINE;
man->flags &= ~MDOC_NEWLINE;
- return(n);
+ return n;
}
void
break;
default:
abort();
- /* NOTREACHED */
}
n->parent->nchild++;
+ n->parent->last = n;
/*
* Copy over the normalised-data pointer of our parent. Not
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
roff_node_free(n);
}
+void
+deroff(char **dest, const struct roff_node *n)
+{
+ char *cp;
+ size_t sz;
+
+ if (n->type != ROFFT_TEXT) {
+ for (n = n->child; n != NULL; n = n->next)
+ deroff(dest, n);
+ return;
+ }
+
+ /* Skip leading whitespace and escape sequences. */
+
+ cp = n->string;
+ while (*cp != '\0') {
+ if ('\\' == *cp) {
+ cp++;
+ mandoc_escape((const char **)&cp, NULL, NULL);
+ } else if (isspace((unsigned char)*cp))
+ cp++;
+ else
+ break;
+ }
+
+ /* Skip trailing whitespace. */
+
+ for (sz = strlen(cp); sz; sz--)
+ if ( ! isspace((unsigned char)cp[sz-1]))
+ break;
+
+ /* Skip empty strings. */
+
+ if (sz == 0)
+ return;
+
+ if (*dest == NULL) {
+ *dest = mandoc_strndup(cp, sz);
+ return;
+ }
+
+ mandoc_asprintf(&cp, "%s %*s", *dest, (int)sz, cp);
+ free(*dest);
+ *dest = cp;
+}
+
/* --- main functions of the roff parser ---------------------------------- */
/*
if (EXPAND_LIMIT < ++expand_count) {
mandoc_msg(MANDOCERR_ROFFLOOP, r->parse,
ln, (int)(stesc - buf->buf), NULL);
- return(ROFF_IGN);
+ return ROFF_IGN;
}
/*
} 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;
}
/*
- * Process text streams:
- * Convert all breakable hyphens into ASCII_HYPH.
- * Decrement and spring input line trap.
+ * Process text streams.
*/
static enum rofferr
roff_parsetext(struct buf *buf, int pos, int *offs)
int isz;
enum mandoc_esc esc;
+ /* Spring the input line trap. */
+
+ if (roffit_lines == 1) {
+ isz = mandoc_asprintf(&p, "%s\n.%s", buf->buf, roffit_macro);
+ free(buf->buf);
+ buf->buf = p;
+ buf->sz = isz + 1;
+ *offs = 0;
+ free(roffit_macro);
+ roffit_lines = 0;
+ return ROFF_REPARSE;
+ } else if (roffit_lines > 1)
+ --roffit_lines;
+
+ /* Convert all breakable hyphens into ASCII_HYPH. */
+
start = p = buf->buf + pos;
while (*p != '\0') {
*p = ASCII_HYPH;
p++;
}
-
- /* Spring the input line trap. */
- if (roffit_lines == 1) {
- isz = mandoc_asprintf(&p, "%s\n.%s", buf->buf, roffit_macro);
- free(buf->buf);
- buf->buf = p;
- buf->sz = isz + 1;
- *offs = 0;
- free(roffit_macro);
- roffit_lines = 0;
- return(ROFF_REPARSE);
- } else if (roffit_lines > 1)
- --roffit_lines;
- 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] == ' ')
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) {
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;
}
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':
- /* FALLTROUGH */
+ /* FALLTHROUGH */
case 'P':
scaled = *res * 40;
break;
case 'm':
- /* FALLTROUGH */
+ /* 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;
}
/*
* or string condition.
*/
static int
-roff_evalcond(struct roff *r, int ln, const char *v, int *pos)
+roff_evalcond(struct roff *r, int ln, char *v, int *pos)
{
+ char *cp, *name;
+ size_t sz;
int number, savepos, wanttrue;
if ('!' == v[*pos]) {
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 'r':
- /* 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;
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
if (buf->buf[pos] == '\\' && buf->buf[pos + 1] == '{') {
r->last->endspan = -1;
pos += 2;
+ while (buf->buf[pos] == ' ')
+ pos++;
goto out;
}
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;
}
/*
(*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 ------------------------------------------------ */
* were to turn up, another special value would have to be chosen.
*/
static int
-roff_getregro(const char *name)
+roff_getregro(const struct roff *r, const char *name)
{
switch (*name) {
+ case '$': /* Number of arguments of the last macro evaluated. */
+ 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;
}
}
int val;
if ('.' == name[0] && '\0' != name[1] && '\0' == name[2]) {
- val = roff_getregro(name + 1);
+ 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
int val;
if ('.' == name[0] && 2 == len) {
- val = roff_getregro(name + 1);
+ val = roff_getregro(r, name + 1);
+ if (-1 != 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 0;
+}
+
+static int
+roff_hasregn(const struct roff *r, const char *name, size_t len)
+{
+ struct roffreg *reg;
+ int val;
+
+ if ('.' == name[0] && 2 == len) {
+ val = roff_getregro(r, name + 1);
if (-1 != val)
- return (val);
+ return 1;
}
for (reg = r->regtab; reg; reg = reg->next)
if (len == reg->key.sz &&
0 == strncmp(name, reg->key.p, len))
- return(reg->val);
+ 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;
+ int i, ib, ie;
size_t asz, rsz;
/*
* and NUL-terminate them.
*/
+ r->argc = 0;
cp = buf->buf + pos;
- for (i = 0; i < 9; i++)
- arg[i] = *cp == '\0' ? "" :
- mandoc_getarg(r->parse, &cp, ln, &pos);
+ for (i = 0; i < 9; i++) {
+ if (*cp == '\0')
+ arg[i] = "";
+ else {
+ arg[i] = mandoc_getarg(r->parse, &cp, ln, &pos);
+ r->argc = i + 1;
+ }
+ }
/*
* Expand macro arguments.
continue;
if (*cp++ != '$')
continue;
- i = *cp - '1';
- if (0 > i || 8 < i)
- continue;
+ if (*cp == '*') { /* \\$* inserts all arguments */
+ ib = 0;
+ ie = r->argc - 1;
+ } else { /* \\$1 .. \\$9 insert one argument */
+ ib = ie = *cp - '1';
+ if (ib < 0 || ib > 8)
+ continue;
+ }
cp -= 2;
/*
* taking escaping of quotes into account.
*/
- asz = 0;
- for (ap = arg[i]; *ap != '\0'; ap++) {
- asz++;
- if (*ap == '"')
- asz += 3;
+ asz = ie > ib ? ie - ib : 0; /* for blanks */
+ for (i = ib; i <= ie; i++) {
+ for (ap = arg[i]; *ap != '\0'; ap++) {
+ asz++;
+ if (*ap == '"')
+ asz += 3;
+ }
}
if (asz != 3) {
/* Copy the expanded argument, escaping quotes. */
n2 = cp;
- for (ap = arg[i]; *ap != '\0'; ap++) {
- if (*ap == '"') {
- memcpy(n2, "\\(dq", 4);
- n2 += 4;
- } else
- *n2++ = *ap;
+ for (i = ib; i <= ie; i++) {
+ for (ap = arg[i]; *ap != '\0'; ap++) {
+ if (*ap == '"') {
+ memcpy(n2, "\\(dq", 4);
+ n2 += 4;
+ } else
+ *n2++ = *ap;
+ }
+ if (i < ie)
+ *n2++ = ' ';
}
}
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
}
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