-/* $Id: roff.c,v 1.256 2015/01/24 02:41:49 schwarze Exp $ */
+/* $Id: roff.c,v 1.284 2016/01/08 17:48:10 schwarze Exp $ */
/*
- * Copyright (c) 2010, 2011, 2012, 2014 Kristaps Dzonsons <kristaps@bsd.lv>
+ * Copyright (c) 2008-2012, 2014 Kristaps Dzonsons <kristaps@bsd.lv>
* Copyright (c) 2010-2015 Ingo Schwarze <schwarze@openbsd.org>
*
* Permission to use, copy, modify, and distribute this software for any
#include "mandoc.h"
#include "mandoc_aux.h"
+#include "roff.h"
#include "libmandoc.h"
+#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
+/* --- data types --------------------------------------------------------- */
+
enum rofft {
ROFF_ab,
ROFF_ad,
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 */
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 */
};
#define PREDEF(__name, __str) \
{ (__name), (__str) },
+/* --- function prototypes ------------------------------------------------ */
+
static enum rofft roffhash_find(const char *, size_t);
static void roffhash_init(void);
static void roffnode_cleanscope(struct roff *);
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,
- const char *, int *, int *);
+ const char *, int *, int *, int);
static int roff_evalstrcond(const char *, int *);
static void roff_free1(struct roff *);
static void roff_freereg(struct roffreg *);
static void roff_freestr(struct roffkv *);
static size_t roff_getname(struct roff *, char **, int, int);
-static int roff_getnum(const char *, int *, int *);
+static int roff_getnum(const char *, int *, int *, 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);
+static void roff_man_alloc1(struct roff_man *);
+static void roff_man_free1(struct roff_man *);
static enum rofferr roff_nr(ROFF_ARGS);
static enum rofft roff_parse(struct roff *, char *, int *,
int, int);
static enum rofferr roff_unsupp(ROFF_ARGS);
static enum rofferr roff_userdef(ROFF_ARGS);
+/* --- constant data ------------------------------------------------------ */
+
/* See roffhash_find() */
#define ASCII_HI 126
#define ASCII_LO 33
#define HASHWIDTH (ASCII_HI - ASCII_LO + 1)
+#define ROFFNUM_SCALE (1 << 0) /* Honour scaling in roff_getnum(). */
+#define ROFFNUM_WHITE (1 << 1) /* Skip whitespace in roff_evalnum(). */
+
static struct roffmac *hash[HASHWIDTH];
static struct roffmac roffs[ROFF_MAX] = {
static char *roffit_macro; /* nil-terminated macro line */
+/* --- request table ------------------------------------------------------ */
+
static void
roffhash_init(void)
{
*/
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 -------------------------------------------- */
+
/*
* Pop the current node off of the stack of roff instructions currently
* pending.
r->last = p;
}
+/* --- roff parser state data management ---------------------------------- */
+
static void
roff_free1(struct roff *r)
{
}
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 ---------------------------------- */
+
+static void
+roff_man_free1(struct roff_man *man)
+{
+
+ if (man->first != NULL)
+ roff_node_delete(man, man->first);
+ free(man->meta.msec);
+ free(man->meta.vol);
+ free(man->meta.os);
+ free(man->meta.arch);
+ free(man->meta.title);
+ free(man->meta.name);
+ free(man->meta.date);
+}
+
+static void
+roff_man_alloc1(struct roff_man *man)
+{
+
+ memset(&man->meta, 0, sizeof(man->meta));
+ man->first = mandoc_calloc(1, sizeof(*man->first));
+ man->first->type = ROFFT_ROOT;
+ man->last = man->first;
+ man->last_es = NULL;
+ man->flags = 0;
+ man->macroset = MACROSET_NONE;
+ man->lastsec = man->lastnamed = SEC_NONE;
+ man->next = ROFF_NEXT_CHILD;
+}
+
+void
+roff_man_reset(struct roff_man *man)
+{
+
+ roff_man_free1(man);
+ roff_man_alloc1(man);
+}
+
+void
+roff_man_free(struct roff_man *man)
+{
+
+ roff_man_free1(man);
+ free(man);
+}
+
+struct roff_man *
+roff_man_alloc(struct roff *roff, struct mparse *parse,
+ const char *defos, int quick)
+{
+ struct roff_man *man;
+
+ man = mandoc_calloc(1, sizeof(*man));
+ man->parse = parse;
+ man->roff = roff;
+ man->defos = defos;
+ man->quick = quick;
+ roff_man_alloc1(man);
+ return man;
+}
+
+/* --- syntax tree handling ----------------------------------------------- */
+
+struct roff_node *
+roff_node_alloc(struct roff_man *man, int line, int pos,
+ enum roff_type type, int tok)
+{
+ struct roff_node *n;
+
+ n = mandoc_calloc(1, sizeof(*n));
+ n->line = line;
+ n->pos = pos;
+ n->tok = tok;
+ n->type = type;
+ n->sec = man->lastsec;
+
+ if (man->flags & MDOC_SYNOPSIS)
+ n->flags |= MDOC_SYNPRETTY;
+ else
+ n->flags &= ~MDOC_SYNPRETTY;
+ if (man->flags & MDOC_NEWLINE)
+ n->flags |= MDOC_LINE;
+ man->flags &= ~MDOC_NEWLINE;
+
+ return n;
+}
+
+void
+roff_node_append(struct roff_man *man, struct roff_node *n)
+{
+
+ 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:
+ man->last->child = n;
+ n->parent = man->last;
+ n->parent->last = n;
+ break;
+ default:
+ abort();
+ }
+ man->last = n;
+
+ switch (n->type) {
+ case ROFFT_HEAD:
+ n->parent->head = n;
+ break;
+ case ROFFT_BODY:
+ if (n->end != ENDBODY_NOT)
+ return;
+ n->parent->body = n;
+ break;
+ case ROFFT_TAIL:
+ n->parent->tail = n;
+ break;
+ default:
+ return;
+ }
+
+ /*
+ * 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
+roff_word_alloc(struct roff_man *man, int line, int pos, const char *word)
+{
+ struct roff_node *n;
+
+ 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)
+ n->flags |= MDOC_VALID | MDOC_ENDED;
+ else
+ n->flags |= MAN_VALID;
+ man->next = ROFF_NEXT_SIBLING;
+}
+
+void
+roff_word_append(struct roff_man *man, const char *word)
+{
+ struct roff_node *n;
+ char *addstr, *newstr;
+
+ n = man->last;
+ addstr = roff_strdup(man->roff, word);
+ mandoc_asprintf(&newstr, "%s %s", n->string, addstr);
+ free(addstr);
+ free(n->string);
+ n->string = newstr;
+ man->next = ROFF_NEXT_SIBLING;
+}
+
+void
+roff_elem_alloc(struct roff_man *man, int line, int pos, int tok)
+{
+ struct roff_node *n;
+
+ n = roff_node_alloc(man, line, pos, ROFFT_ELEM, tok);
+ roff_node_append(man, n);
+ man->next = ROFF_NEXT_CHILD;
+}
+
+struct roff_node *
+roff_block_alloc(struct roff_man *man, int line, int pos, int tok)
+{
+ struct roff_node *n;
+
+ n = roff_node_alloc(man, line, pos, ROFFT_BLOCK, tok);
+ roff_node_append(man, n);
+ man->next = ROFF_NEXT_CHILD;
+ return n;
}
+struct roff_node *
+roff_head_alloc(struct roff_man *man, int line, int pos, int tok)
+{
+ struct roff_node *n;
+
+ n = roff_node_alloc(man, line, pos, ROFFT_HEAD, tok);
+ roff_node_append(man, n);
+ man->next = ROFF_NEXT_CHILD;
+ return n;
+}
+
+struct roff_node *
+roff_body_alloc(struct roff_man *man, int line, int pos, int tok)
+{
+ struct roff_node *n;
+
+ n = roff_node_alloc(man, line, pos, ROFFT_BODY, tok);
+ roff_node_append(man, n);
+ man->next = ROFF_NEXT_CHILD;
+ return n;
+}
+
+void
+roff_addeqn(struct roff_man *man, const struct eqn *eqn)
+{
+ struct roff_node *n;
+
+ 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;
+ roff_node_append(man, n);
+ man->next = ROFF_NEXT_SIBLING;
+}
+
+void
+roff_addtbl(struct roff_man *man, const struct tbl_span *tbl)
+{
+ struct roff_node *n;
+
+ if (man->macroset == MACROSET_MAN)
+ man_breakscope(man, TOKEN_NONE);
+ 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)
+ n->flags |= MDOC_VALID | MDOC_ENDED;
+ else
+ n->flags |= MAN_VALID;
+ man->next = ROFF_NEXT_SIBLING;
+}
+
+void
+roff_node_unlink(struct roff_man *man, struct roff_node *n)
+{
+
+ /* Adjust siblings. */
+
+ if (n->prev)
+ n->prev->next = n->next;
+ if (n->next)
+ n->next->prev = n->prev;
+
+ /* Adjust parent. */
+
+ if (n->parent != NULL) {
+ if (n->parent->child == n)
+ n->parent->child = n->next;
+ if (n->parent->last == n)
+ n->parent->last = n->prev;
+ }
+
+ /* Adjust parse point. */
+
+ if (man == NULL)
+ return;
+ if (man->last == n) {
+ if (n->prev == NULL) {
+ man->last = n->parent;
+ man->next = ROFF_NEXT_CHILD;
+ } else {
+ man->last = n->prev;
+ man->next = ROFF_NEXT_SIBLING;
+ }
+ }
+ if (man->first == n)
+ man->first = NULL;
+}
+
+void
+roff_node_free(struct roff_node *n)
+{
+
+ if (n->args != NULL)
+ mdoc_argv_free(n->args);
+ if (n->type == ROFFT_BLOCK || n->type == ROFFT_ELEM)
+ free(n->norm);
+ free(n->string);
+ free(n);
+}
+
+void
+roff_node_delete(struct roff_man *man, struct roff_node *n)
+{
+
+ while (n->child != NULL)
+ roff_node_delete(man, n->child);
+ roff_node_unlink(man, n);
+ 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 ---------------------------------- */
+
/*
* In the current line, expand escape sequences that tend to get
* used in numerical expressions and conditional requests.
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;
case 'B':
npos = 0;
ubuf[0] = arg_complete &&
- roff_evalnum(r, ln, stnam, &npos, NULL, 0) &&
+ roff_evalnum(r, ln, stnam, &npos,
+ NULL, ROFFNUM_SCALE) &&
stnam + npos + 1 == cp ? '1' : '0';
ubuf[1] = '\0';
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;
}
/*
- * 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') {
esc = mandoc_escape((const char **)&p, NULL, NULL);
if (esc == ESCAPE_ERROR)
break;
+ while (*p == '-')
+ p++;
continue;
} else if (p == start) {
p++;
*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, pos));
+ 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. */
if (r->tbl != NULL && (t == ROFF_MAX || t == ROFF_TS)) {
mandoc_msg(MANDOCERR_TBLMACRO, r->parse,
ln, pos, buf->buf + spos);
- return(ROFF_IGN);
+ if (t == ROFF_TS)
+ 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);
}
/*
*/
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 ----------------------------------------- */
+
static enum rofferr
roff_cblock(ROFF_ARGS)
{
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 -------------------- */
+
/*
* Parse a single signed integer number. Stop at the first non-digit.
* If there is at least one digit, return success and advance the
* Ignore overflows, treat them just like the C language.
*/
static int
-roff_getnum(const char *v, int *pos, int *res)
+roff_getnum(const char *v, int *pos, int *res, int flags)
{
- int myres, n, p;
+ int myres, scaled, n, p;
if (NULL == res)
res = &myres;
p = *pos;
n = v[p] == '-';
- if (n)
+ if (n || v[p] == '+')
p++;
+ if (flags & ROFFNUM_WHITE)
+ while (isspace((unsigned char)v[p]))
+ p++;
+
for (*res = 0; isdigit((unsigned char)v[p]); p++)
*res = 10 * *res + v[p] - '0';
if (p == *pos + n)
switch (v[p]) {
case 'f':
- *res *= 65536;
+ scaled = *res * 65536;
break;
case 'i':
- *res *= 240;
+ scaled = *res * 240;
break;
case 'c':
- *res *= 240;
- *res /= 2.54;
+ scaled = *res * 240 / 2.54;
break;
case 'v':
- /* FALLTROUGH */
case 'P':
- *res *= 40;
+ scaled = *res * 40;
break;
case 'm':
- /* FALLTROUGH */
case 'n':
- *res *= 24;
+ scaled = *res * 24;
break;
case 'p':
- *res *= 10;
- *res /= 3;
+ scaled = *res * 10 / 3;
break;
case 'u':
+ scaled = *res;
break;
case 'M':
- *res *= 6;
- *res /= 25;
+ scaled = *res * 6 / 25;
break;
default:
+ scaled = *res;
p--;
break;
}
+ if (flags & ROFFNUM_SCALE)
+ *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, 0))
- return((number > 0) == wanttrue);
+ if (roff_evalnum(r, ln, v, pos, &number, ROFFNUM_SCALE))
+ 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;
}
/*
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;
}
/*
*/
static int
roff_evalpar(struct roff *r, int ln,
- const char *v, int *pos, int *res)
+ const char *v, int *pos, int *res, int flags)
{
if ('(' != v[*pos])
- return(roff_getnum(v, pos, res));
+ return roff_getnum(v, pos, res, flags);
(*pos)++;
- if ( ! roff_evalnum(r, ln, v, pos, res, 1))
- return(0);
+ if ( ! roff_evalnum(r, ln, v, pos, res, flags | ROFFNUM_WHITE))
+ return 0;
/*
* Omission of the closing parenthesis
if (')' == v[*pos])
(*pos)++;
else if (NULL == res)
- return(0);
+ return 0;
- return(1);
+ return 1;
}
/*
*/
static int
roff_evalnum(struct roff *r, int ln, const char *v,
- int *pos, int *res, int skipwhite)
+ int *pos, int *res, int flags)
{
int mypos, operand2;
char operator;
pos = &mypos;
}
- if (skipwhite)
+ if (flags & ROFFNUM_WHITE)
while (isspace((unsigned char)v[*pos]))
(*pos)++;
- if ( ! roff_evalpar(r, ln, v, pos, res))
- return(0);
+ if ( ! roff_evalpar(r, ln, v, pos, res, flags))
+ return 0;
while (1) {
- if (skipwhite)
+ if (flags & ROFFNUM_WHITE)
while (isspace((unsigned char)v[*pos]))
(*pos)++;
if ( ! roff_getop(v, pos, &operator))
break;
- if (skipwhite)
+ if (flags & ROFFNUM_WHITE)
while (isspace((unsigned char)v[*pos]))
(*pos)++;
- if ( ! roff_evalpar(r, ln, v, pos, &operand2))
- return(0);
+ if ( ! roff_evalpar(r, ln, v, pos, &operand2, flags))
+ return 0;
- if (skipwhite)
+ if (flags & ROFFNUM_WHITE)
while (isspace((unsigned char)v[*pos]))
(*pos)++;
abort();
}
}
- return(1);
+ return 1;
}
+/* --- register management ------------------------------------------------ */
+
void
roff_setreg(struct roff *r, const char *name, int val, char sign)
{
* 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);
+ 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
+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 1;
+ }
+
+ for (reg = r->regtab; reg; reg = reg->next)
+ if (len == reg->key.sz &&
+ 0 == strncmp(name, reg->key.p, len))
+ return 1;
+
+ 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 (sign == '+' || sign == '-')
val++;
- if (roff_evalnum(r, ln, val, NULL, &iv, 0))
+ 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 -------------------------------- */
+
static enum rofferr
roff_rm(ROFF_ARGS)
{
if (name[namesz] == '\\')
break;
}
- return(ROFF_IGN);
+ return ROFF_IGN;
}
static enum rofferr
roff_it(ROFF_ARGS)
{
- char *cp;
- size_t len;
int iv;
/* Parse the number of lines. */
- cp = buf->buf + pos;
- len = strcspn(cp, " \t");
- cp[len] = '\0';
- if ((iv = mandoc_strntoi(cp, len, 10)) <= 0) {
+
+ 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;
}
- cp += len + 1;
- /* Arm the input line trap. */
+ while (isspace((unsigned char)buf->buf[pos]))
+ pos++;
+
+ /*
+ * Arm the input line trap.
+ * Special-casing "an-trap" is an ugly workaround to cope
+ * with DocBook stupidly fiddling with man(7) internals.
+ */
+
roffit_lines = iv;
- roffit_macro = mandoc_strdup(cp);
- return(ROFF_IGN);
+ roffit_macro = mandoc_strdup(iv != 1 ||
+ strcmp(buf->buf + pos, "an-trap") ?
+ buf->buf + pos : "br");
+ 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
if (NULL == r->tbl)
mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse,
ln, ppos, "TE");
- else
- tbl_end(&r->tbl);
-
- return(ROFF_IGN);
+ else if ( ! tbl_end(&r->tbl)) {
+ free(buf->buf);
+ buf->buf = mandoc_strdup(".sp");
+ buf->sz = 4;
+ return ROFF_REPARSE;
+ }
+ 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
r->control = 0;
if (*p != '\0')
- mandoc_msg(MANDOCERR_ARGCOUNT, r->parse, ln, ppos, NULL);
+ mandoc_vmsg(MANDOCERR_ARG_EXCESS, r->parse,
+ ln, p - buf->buf, "cc ... %s", p);
- return(ROFF_IGN);
+ return ROFF_IGN;
}
static enum rofferr
p = buf->buf + pos;
if (*p == '\0') {
- mandoc_msg(MANDOCERR_ARGCOUNT, r->parse, ln, ppos, NULL);
- return(ROFF_IGN);
+ mandoc_msg(MANDOCERR_REQ_EMPTY, r->parse, ln, ppos, "tr");
+ 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') {
- mandoc_msg(MANDOCERR_ARGCOUNT, r->parse,
- ln, (int)(p - buf->buf), NULL);
+ mandoc_vmsg(MANDOCERR_TR_ODD, r->parse,
+ ln, first - buf->buf, "tr %s", first);
second = " ";
p--;
}
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 ------------------------------------ */
+
static enum rofferr
roff_userdef(ROFF_ARGS)
{
- const char *arg[9];
+ const char *arg[9], *ap;
char *cp, *n1, *n2;
- int i;
+ int i, ib, ie;
+ size_t asz, rsz;
/*
* Collect pointers to macro argument strings
* 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.
*/
- buf->sz = 0;
- n1 = cp = mandoc_strdup(r->current_string);
- while ((cp = strstr(cp, "\\$")) != NULL) {
- i = cp[2] - '1';
- if (0 > i || 8 < i) {
- /* Not an argument invocation. */
- cp += 2;
+
+ buf->sz = strlen(r->current_string) + 1;
+ n1 = cp = mandoc_malloc(buf->sz);
+ memcpy(n1, r->current_string, buf->sz);
+ while (*cp != '\0') {
+
+ /* Scan ahead for the next argument invocation. */
+
+ if (*cp++ != '\\')
+ continue;
+ if (*cp++ != '$')
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;
+
+ /*
+ * Determine the size of the expanded argument,
+ * taking escaping of quotes into account.
+ */
+
+ 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) {
+
+ /*
+ * Determine the size of the rest of the
+ * unexpanded macro, including the NUL.
+ */
+
+ rsz = buf->sz - (cp - n1) - 3;
+
+ /*
+ * When shrinking, move before
+ * releasing the storage.
+ */
+
+ if (asz < 3)
+ memmove(cp + asz, cp + 3, rsz);
+
+ /*
+ * Resize the storage for the macro
+ * and readjust the parse pointer.
+ */
+
+ buf->sz += asz - 3;
+ n2 = mandoc_realloc(n1, buf->sz);
+ cp = n2 + (cp - n1);
+ n1 = n2;
+
+ /*
+ * When growing, make room
+ * for the expanded argument.
+ */
+
+ if (asz > 3)
+ memmove(cp + asz, cp + 3, rsz);
+ }
+
+ /* Copy the expanded argument, escaping quotes. */
+
+ n2 = cp;
+ 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++ = ' ';
}
- *cp = '\0';
- buf->sz = mandoc_asprintf(&n2, "%s%s%s",
- n1, arg[i], cp + 3) + 1;
- cp = n2 + (cp - n1);
- free(n1);
- n1 = n2;
}
/*
* Replace the macro invocation
* by the expanded macro.
*/
+
free(buf->buf);
buf->buf = n1;
- if (buf->sz == 0)
- buf->sz = strlen(buf->buf) + 1;
*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
}
}
+/* --- accessors and utility functions ------------------------------------ */
+
const struct tbl_span *
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