mandoc/roff.c - diff

Return to roff.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/roff.c between version 1.363 and 1.392

version 1.363, 2019/02/06 21:11:43

version 1.392, 2022/06/02 11:29:07

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 14

* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN

* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF

* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

* Implementation of the roff(7) parser for mandoc(1).

#include "config.h"

Line 133 struct roff {

Line 135 struct roff {

char escape; /* escape character */

};

* A macro definition, condition, or ignored block.

struct roffnode {

enum roff_tok tok; /* type of node */

struct roffnode *parent; /* up one in stack */

int line; /* parse line */

int col; /* parse col */

char *name; /* node name, e.g. macro name */

char *end; /* end-rules: custom token */

char *end; /* custom end macro of the block */

int endspan; /* end-rules: next-line or infty */

int endspan; /* scope to: 1=eol 2=next line -1=\} */

int rule; /* current evaluation rule */

int rule; /* content is: 1=evaluated 0=skipped */

};

#define ROFF_ARGS struct roff *r, /* parse ctx */ \

Line 181 static int roff_als(ROFF_ARGS);

Line 186 static int roff_als(ROFF_ARGS);

static int roff_block(ROFF_ARGS);

static int roff_block_text(ROFF_ARGS);

static int roff_block_sub(ROFF_ARGS);

static int roff_break(ROFF_ARGS);

static int roff_cblock(ROFF_ARGS);

static int roff_cc(ROFF_ARGS);

static int roff_ccond(struct roff *, int, int);

static int roff_char(ROFF_ARGS);

static int roff_cond(ROFF_ARGS);

static int roff_cond_checkend(ROFF_ARGS);

static int roff_cond_text(ROFF_ARGS);

static int roff_cond_sub(ROFF_ARGS);

static int roff_ds(ROFF_ARGS);

static int roff_ec(ROFF_ARGS);

static int roff_eo(ROFF_ARGS);

static int roff_eqndelim(struct roff *, struct buf *, int);

static int roff_evalcond(struct roff *r, int, char *, int *);

static int roff_evalcond(struct roff *, int, char *, int *);

static int roff_evalnum(struct roff *, int,

const char *, int *, int *, int);

static int roff_evalpar(struct roff *, int,

Line 200 static int roff_evalpar(struct roff *, int,

Line 207 static int roff_evalpar(struct roff *, int,

static int roff_evalstrcond(const char *, int *);

static int roff_expand(struct roff *, struct buf *,

int, int, char);

static void roff_expand_patch(struct buf *, int,

const char *, int);

static void roff_free1(struct roff *);

static void roff_freereg(struct roffreg *);

static void roff_freestr(struct roffkv *);

Line 220 static int roff_line_ignore(ROFF_ARGS);

Line 229 static int roff_line_ignore(ROFF_ARGS);

static void roff_man_alloc1(struct roff_man *);

static void roff_man_free1(struct roff_man *);

static int roff_manyarg(ROFF_ARGS);

static int roff_mc(ROFF_ARGS);

static int roff_noarg(ROFF_ARGS);

static int roff_nop(ROFF_ARGS);

static int roff_nr(ROFF_ARGS);

static int roff_onearg(ROFF_ARGS);

static enum roff_tok roff_parse(struct roff *, char *, int *,

int, int);

static int roff_parse_comment(struct roff *, struct buf *,

int, int, char);

static int roff_parsetext(struct roff *, struct buf *,

int, int *);

static int roff_renamed(ROFF_ARGS);

static int roff_req_or_macro(ROFF_ARGS);

static int roff_return(ROFF_ARGS);

static int roff_rm(ROFF_ARGS);

static int roff_rn(ROFF_ARGS);

Line 351 const char *__roff_name[MAN_MAX + 1] = {

Line 364 const char *__roff_name[MAN_MAX + 1] = {

"Lk", "Mt", "Brq", "Bro",

"Brc", "%C", "Es", "En",

"Dx", "%Q", "%U", "Ta",

NULL,

"Tg", NULL,

"TH", "SH", "SS", "TP",

"TQ",

"LP", "PP", "P", "IP",

Line 372 static struct roffmac roffs[TOKEN_NONE] = {

Line 385 static struct roffmac roffs[TOKEN_NONE] = {

{ roff_noarg, NULL, NULL, 0 }, /* fi */

{ roff_onearg, NULL, NULL, 0 }, /* ft */

{ roff_onearg, NULL, NULL, 0 }, /* ll */

{ roff_onearg, NULL, NULL, 0 }, /* mc */

{ roff_mc, NULL, NULL, 0 }, /* mc */

{ roff_noarg, NULL, NULL, 0 }, /* nf */

{ roff_onearg, NULL, NULL, 0 }, /* po */

{ roff_onearg, NULL, NULL, 0 }, /* rj */

Line 400 static struct roffmac roffs[TOKEN_NONE] = {

Line 413 static struct roffmac roffs[TOKEN_NONE] = {

{ roff_unsupp, NULL, NULL, 0 }, /* boxa */

{ roff_line_ignore, NULL, NULL, 0 }, /* bp */

{ roff_unsupp, NULL, NULL, 0 }, /* BP */

{ roff_unsupp, NULL, NULL, 0 }, /* break */

{ roff_break, NULL, NULL, 0 }, /* break */

{ roff_line_ignore, NULL, NULL, 0 }, /* breakchar */

{ roff_line_ignore, NULL, NULL, 0 }, /* brnl */

{ roff_noarg, NULL, NULL, 0 }, /* brp */

Line 685 roffhash_find(struct ohash *htab, const char *name, si

Line 698 roffhash_find(struct ohash *htab, const char *name, si

* Pop the current node off of the stack of roff instructions currently

* pending.

* pending. Return 1 if it is a loop or 0 otherwise.

static int

roffnode_pop(struct roff *r)

Line 767 void

Line 780 void

roff_reset(struct roff *r)

{

roff_free1(r);

r->options |= MPARSE_COMMENT;

r->format = r->options & (MPARSE_MDOC | MPARSE_MAN);

r->control = '\0';

r->escape = '\\';

Line 779 roff_reset(struct roff *r)

Line 793 roff_reset(struct roff *r)

void

roff_free(struct roff *r)

{

int i;

roff_free1(r);

for (i = 0; i < r->mstacksz; i++)

Line 796 roff_alloc(int options)

Line 810 roff_alloc(int options)

r = mandoc_calloc(1, sizeof(struct roff));

r->reqtab = roffhash_alloc(0, ROFF_RENAMED);

r->options = options;

r->options = options | MPARSE_COMMENT;

r->format = options & (MPARSE_MDOC | MPARSE_MAN);

r->mstackpos = -1;

r->rstackpos = -1;

Line 853 void

Line 867 void

roff_man_free(struct roff_man *man)

{

roff_man_free1(man);

free(man->os_r);

free(man);

}

Line 1096 roff_node_free(struct roff_node *n)

Line 1111 roff_node_free(struct roff_node *n)

free(n->norm);

eqn_box_free(n->eqn);

free(n->string);

free(n->tag);

free(n);

}

Line 1109 roff_node_delete(struct roff_man *man, struct roff_nod

Line 1125 roff_node_delete(struct roff_man *man, struct roff_nod

roff_node_free(n);

}

int

roff_node_transparent(struct roff_node *n)

{

if (n == NULL)

return 0;

if (n->type == ROFFT_COMMENT || n->flags & NODE_NOPRT)

return 1;

return roff_tok_transparent(n->tok);

}

int

roff_tok_transparent(enum roff_tok tok)

{

switch (tok) {

case ROFF_ft:

case ROFF_ll:

case ROFF_mc:

case ROFF_po:

case ROFF_ta:

case MDOC_Db:

case MDOC_Es:

case MDOC_Sm:

case MDOC_Tg:

case MAN_DT:

case MAN_UC:

case MAN_PD:

case MAN_AT:

return 1;

default:

return 0;

}

struct roff_node *

roff_node_child(struct roff_node *n)

{

for (n = n->child; roff_node_transparent(n); n = n->next)

continue;

return n;

}

struct roff_node *

roff_node_prev(struct roff_node *n)

{

do {

n = n->prev;

} while (roff_node_transparent(n));

return n;

}

struct roff_node *

roff_node_next(struct roff_node *n)

{

do {

n = n->next;

} while (roff_node_transparent(n));

return n;

}

void

deroff(char **dest, const struct roff_node *n)

{

char *cp;

size_t sz;

if (n->type != ROFFT_TEXT) {

if (n->string == NULL) {

for (n = n->child; n != NULL; n = n->next)

deroff(dest, n);

return;

Line 1161 deroff(char **dest, const struct roff_node *n)

Line 1236 deroff(char **dest, const struct roff_node *n)

/* --- main functions of the roff parser ---------------------------------- */

* In the current line, expand escape sequences that produce parsable

* Save comments preceding the title macro, for example in order to

* input text. Also check the syntax of the remaining escape sequences,

* preserve Copyright and license headers in HTML output,

* which typically produce output glyphs or change formatter state.

* provide diagnostics about RCS ids and trailing whitespace in comments,

* then discard comments including preceding whitespace.

* This function also handles input line continuation.

static int

roff_expand(struct roff *r, struct buf *buf, int ln, int pos, char newesc)

roff_parse_comment(struct roff *r, struct buf *buf, int ln, int pos, char ec)

{

struct mctx *ctx; /* current macro call context */

char ubuf[24]; /* buffer to print the number */

struct roff_node *n; /* used for header comments */

const char *start; /* start of the string to process */

const char *cp; /* for RCS id parsing */

char *stesc; /* start of an escape sequence ('\\') */

const char *esct; /* type of esccape sequence */

char *ep; /* end of comment string */

const char *stnam; /* start of the name, after "[(*" */

const char *cp; /* end of the name, e.g. before ']' */

const char *res; /* the string to be substituted */

char *nbuf; /* new buffer to copy buf->buf to */

size_t maxl; /* expected length of the escape name */

size_t naml; /* actual length of the escape name */

size_t asz; /* length of the replacement */

size_t rsz; /* length of the rest of the string */

int inaml; /* length returned from mandoc_escape() */

int expand_count; /* to avoid infinite loops */

int npos; /* position in numeric expression */

int arg_complete; /* argument not interrupted by eol */

int quote_args; /* true for \\$@, false for \\$* */

int done; /* no more input available */

int deftype; /* type of definition to paste */

int rcsid; /* kind of RCS id seen */

enum mandocerr err; /* for escape sequence problems */

char sign; /* increment number register */

char term; /* character terminating the escape */

/* Search forward for comments. */

for (start = stesc = buf->buf + pos;; stesc++) {

done = 0;

* XXX Ugly hack: Remove the newline character that

start = buf->buf + pos;

* mparse_buf_r() appended to mark the end of input

for (stesc = buf->buf + pos; *stesc != '\0'; stesc++) {

* if it is not preceded by an escape character.

if (stesc[0] != newesc || stesc[1] == '\0')

continue;

if (stesc[0] == '\n') {

stesc++;

assert(stesc[1] == '\0');

if (*stesc != '"' && *stesc != '#')

stesc[0] = '\0';

continue;

/* Comment found, look for RCS id. */

rcsid = 0;

if ((cp = strstr(stesc, "$" "OpenBSD")) != NULL) {

rcsid = 1 << MANDOC_OS_OPENBSD;

cp += 8;

} else if ((cp = strstr(stesc, "$" "NetBSD")) != NULL) {

rcsid = 1 << MANDOC_OS_NETBSD;

cp += 7;

}

if (cp != NULL &&

isalnum((unsigned char)*cp) == 0 &&

strchr(cp, '$') != NULL) {

if (r->man->meta.rcsids & rcsid)

mandoc_msg(MANDOCERR_RCS_REP, ln,

(int)(stesc - buf->buf) + 1,

"%s", stesc + 1);

r->man->meta.rcsids |= rcsid;

}

/* Handle trailing whitespace. */

/* The line ends without continuation or comment. */

if (stesc[0] == '\0')

return ROFF_CONT;

ep = strchr(stesc--, '\0') - 1;

/* Unescaped byte: skip it. */

if (*ep == '\n') {

if (stesc[0] != ec)

done = 1;

continue;

ep--;

}

if (*ep == ' ' || *ep == '\t')

mandoc_msg(MANDOCERR_SPACE_EOL,

ln, (int)(ep - buf->buf), NULL);

* Save comments preceding the title macro

* XXX Ugly hack: Do not attempt to append another line

* in the syntax tree.

* if the function mparse_buf_r() appended a newline

* character to indicate the end of input.

if (stesc[1] == '\n') {

if (newesc != ASCII_ESC && r->format == 0) {

assert(stesc[2] == '\0');

while (*ep == ' ' || *ep == '\t')

stesc[0] = '\0';

ep--;

return ROFF_CONT;

ep[1] = '\0';

n = roff_node_alloc(r->man,

ln, stesc + 1 - buf->buf,

ROFFT_COMMENT, TOKEN_NONE);

n->string = mandoc_strdup(stesc + 2);

roff_node_append(r->man, n);

n->flags |= NODE_VALID | NODE_ENDED;

r->man->next = ROFF_NEXT_SIBLING;

}

/* Line continuation with comment. */

* An escape character at the end of an input line

if (stesc[1] == '#') {

* requests line continuation.

*stesc = '\0';

if (stesc[1] == '\0') {

stesc[0] = '\0';

return ROFF_IGN | ROFF_APPEND;

}

/* Discard normal comments. */

/* Found a comment: process it. */

if (stesc[1] == '"' || stesc[1] == '#')

break;

while (stesc > start && stesc[-1] == ' ' &&

/* Escaped escape character: skip them both. */

(stesc == start + 1 || stesc[-2] != '\\'))

if (stesc[1] == ec)

stesc--;

stesc++;

*stesc = '\0';

break;

}

if (stesc == start)

return ROFF_CONT;

stesc--;

/* Notice the end of the input. */

/* Look for an RCS id in the comment. */

if (*stesc == '\n') {

rcsid = 0;

*stesc-- = '\0';

if ((cp = strstr(stesc + 2, "$" "OpenBSD")) != NULL) {

done = 1;

rcsid = 1 << MANDOC_OS_OPENBSD;

cp += 8;

} else if ((cp = strstr(stesc + 2, "$" "NetBSD")) != NULL) {

rcsid = 1 << MANDOC_OS_NETBSD;

cp += 7;

}

if (cp != NULL && isalnum((unsigned char)*cp) == 0 &&

strchr(cp, '$') != NULL) {

if (r->man->meta.rcsids & rcsid)

mandoc_msg(MANDOCERR_RCS_REP, ln,

(int)(stesc - buf->buf) + 2, "%s", stesc + 1);

r->man->meta.rcsids |= rcsid;

}

expand_count = 0;

/* Warn about trailing whitespace at the end of the comment. */

while (stesc >= start) {

if (*stesc != newesc) {

ep = strchr(stesc + 2, '\0') - 1;

* If we have a non-standard escape character,

if (*ep == '\n')

* escape literal backslashes because all

*ep-- = '\0';

* processing in subsequent functions uses

if (*ep == ' ' || *ep == '\t')

* the standard escaping rules.

mandoc_msg(MANDOCERR_SPACE_EOL,

ln, (int)(ep - buf->buf), NULL);

if (newesc != ASCII_ESC && *stesc == '\\') {

/* Save comments preceding the title macro in the syntax tree. */

*stesc = '\0';

buf->sz = mandoc_asprintf(&nbuf, "%s\\e%s",

buf->buf, stesc + 1) + 1;

start = nbuf + pos;

stesc = nbuf + (stesc - buf->buf);

free(buf->buf);

buf->buf = nbuf;

}

/* Search backwards for the next escape. */

if (r->options & MPARSE_COMMENT) {

while (*ep == ' ' || *ep == '\t')

ep--;

ep[1] = '\0';

n = roff_node_alloc(r->man, ln, stesc + 1 - buf->buf,

ROFFT_COMMENT, TOKEN_NONE);

n->string = mandoc_strdup(stesc + 2);

roff_node_append(r->man, n);

n->flags |= NODE_VALID | NODE_ENDED;

r->man->next = ROFF_NEXT_SIBLING;

}

stesc--;

/* The comment requests line continuation. */

continue;

}

/* If it is escaped, skip it. */

if (stesc[1] == '#') {

*stesc = '\0';

return ROFF_IGN | ROFF_APPEND;

}

for (cp = stesc - 1; cp >= start; cp--)

/* Discard the comment including preceding whitespace. */

if (*cp != r->escape)

break;

if ((stesc - cp) % 2 == 0) {

while (stesc > start && stesc[-1] == ' ' &&

while (stesc > cp)

(stesc == start + 1 || stesc[-2] != '\\'))

*stesc-- = '\\';

stesc--;

continue;

*stesc = '\0';

} else if (stesc[1] != '\0') {

return ROFF_CONT;

*stesc = '\\';

}

} else {

*stesc-- = '\0';

if (done)

continue;

else

return ROFF_IGN | ROFF_APPEND;

}

/* Decide whether to expand or to check only. */

* In the current line, expand escape sequences that produce parsable

* input text. Also check the syntax of the remaining escape sequences,

* which typically produce output glyphs or change formatter state.

static int

roff_expand(struct roff *r, struct buf *buf, int ln, int pos, char ec)

{

char ubuf[24]; /* buffer to print a number */

struct mctx *ctx; /* current macro call context */

const char *res; /* the string to be pasted */

const char *src; /* source for copying */

char *dst; /* destination for copying */

int iesc; /* index of leading escape char */

int inam; /* index of the escape name */

int iarg; /* index beginning the argument */

int iendarg; /* index right after the argument */

int iend; /* index right after the sequence */

int deftype; /* type of definition to paste */

int argi; /* macro argument index */

int quote_args; /* true for \\$@, false for \\$* */

int asz; /* length of the replacement */

int rsz; /* length of the rest of the string */

int npos; /* position in numeric expression */

int expand_count; /* to avoid infinite loops */

term = '\0';

expand_count = 0;

cp = stesc + 1;

while (buf->buf[pos] != '\0') {

if (*cp == 'E')

cp++;

esct = cp;

* Skip plain ASCII characters.

switch (*esct) {

* If we have a non-standard escape character,

case '*':

* escape literal backslashes because all processing in

case '$':

* subsequent functions uses the standard escaping rules.

res = NULL;

break;

case 'B':

if (buf->buf[pos] != ec) {

case 'w':

if (ec != ASCII_ESC && buf->buf[pos] == '\\') {

term = cp[1];

roff_expand_patch(buf, pos, "\\e", pos + 1);

/* FALLTHROUGH */

pos++;

case 'n':

sign = cp[1];

if (sign == '+' || sign == '-')

cp++;

res = ubuf;

break;

default:

err = MANDOCERR_OK;

switch(mandoc_escape(&cp, &stnam, &inaml)) {

case ESCAPE_SPECIAL:

if (mchars_spec2cp(stnam, inaml) >= 0)

break;

/* FALLTHROUGH */

case ESCAPE_ERROR:

err = MANDOCERR_ESC_BAD;

break;

case ESCAPE_UNDEF:

err = MANDOCERR_ESC_UNDEF;

break;

case ESCAPE_UNSUPP:

err = MANDOCERR_ESC_UNSUPP;

break;

default:

break;

}

if (err != MANDOCERR_OK)

pos++;

mandoc_msg(err, ln, (int)(stesc - buf->buf),

"%.*s", (int)(cp - stesc), stesc);

stesc--;

continue;

}

if (EXPAND_LIMIT < ++expand_count) {

mandoc_msg(MANDOCERR_ROFFLOOP,

ln, (int)(stesc - buf->buf), NULL);

return ROFF_IGN;

}

* The third character decides the length

* Parse escape sequences,

* of the name of the string or register.

* issue diagnostic messages when appropriate,

* Save a pointer to the name.

* and skip sequences that do not need expansion.

* If we have a non-standard escape character, translate

* it to backslashes and translate backslashes to \e.

if (term == '\0') {

if (roff_escape(buf->buf, ln, pos, &iesc, &inam,

switch (*++cp) {

&iarg, &iendarg, &iend) != ESCAPE_EXPAND) {

case '\0':

while (pos < iend) {

maxl = 0;

if (buf->buf[pos] == ec) {

break;

buf->buf[pos] = '\\';

case '(':

if (pos + 1 < iend)

cp++;

pos++;

maxl = 2;

} else if (buf->buf[pos] == '\\') {

break;

roff_expand_patch(buf,

case '[':

pos, "\\e", pos + 1);

cp++;

pos++;

term = ']';

iend++;

maxl = 0;

}

break;

pos++;

default:

maxl = 1;

break;

}

} else {

continue;

cp += 2;

maxl = 0;

}

stnam = cp;

/* Advance to the end of the name. */

/* Handle expansion. */

naml = 0;

res = NULL;

arg_complete = 1;

switch (buf->buf[inam]) {

while (maxl == 0 || naml < maxl) {

case '*':

if (*cp == '\0') {

if (iendarg == iarg)

mandoc_msg(MANDOCERR_ESC_BAD, ln,

(int)(stesc - buf->buf), "%s", stesc);

arg_complete = 0;

break;

}

deftype = ROFFDEF_USER | ROFFDEF_PRE;

if (maxl == 0 && *cp == term) {

if ((res = roff_getstrn(r, buf->buf + iarg,

cp++;

iendarg - iarg, &deftype)) != NULL)

break;

}

if (*cp++ != '\\' || *esct != 'w') {

naml++;

continue;

}

switch (mandoc_escape(&cp, NULL, NULL)) {

case ESCAPE_SPECIAL:

case ESCAPE_UNICODE:

case ESCAPE_NUMBERED:

case ESCAPE_UNDEF:

case ESCAPE_OVERSTRIKE:

naml++;

break;

default:

break;

}

* Retrieve the replacement string; if it is

* If not overriden,

* undefined, resume searching for escapes.

* let \*(.T through to the formatters.

switch (*esct) {

if (iendarg - iarg == 2 &&

case '*':

buf->buf[iarg] == '.' &&

if (arg_complete) {

buf->buf[iarg + 1] == 'T') {

deftype = ROFFDEF_USER | ROFFDEF_PRE;

roff_setstrn(&r->strtab, ".T", 2, NULL, 0, 0);

res = roff_getstrn(r, stnam, naml, &deftype);

pos = iend;

continue;

* If not overriden, let \*(.T

* through to the formatters.

if (res == NULL && naml == 2 &&

stnam[0] == '.' && stnam[1] == 'T') {

roff_setstrn(&r->strtab,

".T", 2, NULL, 0, 0);

stesc--;

continue;

}

mandoc_msg(MANDOCERR_STR_UNDEF, ln, iesc,

"%.*s", iendarg - iarg, buf->buf + iarg);

break;

case '$':

if (r->mstackpos < 0) {

mandoc_msg(MANDOCERR_ARG_UNDEF, ln,

mandoc_msg(MANDOCERR_ARG_UNDEF, ln, iesc,

(int)(stesc - buf->buf), "%.3s", stesc);

"%.*s", iend - iesc, buf->buf + iesc);

break;

}

ctx = r->mstack + r->mstackpos;

npos = esct[1] - '1';

argi = buf->buf[iarg] - '1';

if (npos >= 0 && npos <= 8) {

if (argi >= 0 && argi <= 8) {

res = npos < ctx->argc ?

if (argi < ctx->argc)

ctx->argv[npos] : "";

res = ctx->argv[argi];

break;

}

if (esct[1] == '*')

if (buf->buf[iarg] == '*')

quote_args = 0;

else if (esct[1] == '@')

else if (buf->buf[iarg] == '@')

quote_args = 1;

else {

mandoc_msg(MANDOCERR_ARG_NONUM, ln,

mandoc_msg(MANDOCERR_ARG_NONUM, ln, iesc,

(int)(stesc - buf->buf), "%.3s", stesc);

"%.*s", iend - iesc, buf->buf + iesc);

break;

}

asz = 0;

for (npos = 0; npos < ctx->argc; npos++) {

for (argi = 0; argi < ctx->argc; argi++) {

if (npos)

if (argi)

asz++; /* blank */

if (quote_args)

asz += 2; /* quotes */

asz += strlen(ctx->argv[npos]);

asz += strlen(ctx->argv[argi]);

}

if (asz != 3) {

if (asz != iend - iesc) {

rsz = buf->sz - (stesc - buf->buf) - 3;

rsz = buf->sz - iend;

if (asz < 3)

if (asz < iend - iesc)

memmove(stesc + asz, stesc + 3, rsz);

memmove(buf->buf + iesc + asz,

buf->sz += asz - 3;

buf->buf + iend, rsz);

nbuf = mandoc_realloc(buf->buf, buf->sz);

buf->sz = iesc + asz + rsz;

start = nbuf + pos;

buf->buf = mandoc_realloc(buf->buf, buf->sz);

stesc = nbuf + (stesc - buf->buf);

if (asz > iend - iesc)

buf->buf = nbuf;

memmove(buf->buf + iesc + asz,

if (asz > 3)

buf->buf + iend, rsz);

memmove(stesc + asz, stesc + 3, rsz);

}

for (npos = 0; npos < ctx->argc; npos++) {

dst = buf->buf + iesc;

if (npos)

for (argi = 0; argi < ctx->argc; argi++) {

*stesc++ = ' ';

if (argi)

*dst++ = ' ';

if (quote_args)

*stesc++ = '"';

*dst++ = '"';

cp = ctx->argv[npos];

src = ctx->argv[argi];

while (*cp != '\0')

while (*src != '\0')

*stesc++ = *cp++;

*dst++ = *src++;

if (quote_args)

*stesc++ = '"';

*dst++ = '"';

}

continue;

case 'A':

ubuf[0] = iendarg > iarg ? '1' : '0';

ubuf[1] = '\0';

res = ubuf;

break;

case 'B':

npos = 0;

ubuf[0] = arg_complete &&

ubuf[0] = iendarg > iarg && iend > iendarg &&

roff_evalnum(r, ln, stnam, &npos,

roff_evalnum(r, ln, buf->buf + iarg, &npos,

NULL, ROFFNUM_SCALE) &&

stnam + npos + 1 == cp ? '1' : '0';

npos == iendarg - iarg ? '1' : '0';

ubuf[1] = '\0';

res = ubuf;

break;

case 'V':

mandoc_msg(MANDOCERR_UNSUPP, ln, iesc,

"%.*s", iend - iesc, buf->buf + iesc);

roff_expand_patch(buf, iendarg, "}", iend);

roff_expand_patch(buf, iesc, "${", iarg);

continue;

case 'g':

break;

case 'n':

if (arg_complete)

if (iendarg > iarg)

(void)snprintf(ubuf, sizeof(ubuf), "%d",

roff_getregn(r, stnam, naml, sign));

roff_getregn(r, buf->buf + iarg,

iendarg - iarg, buf->buf[inam + 1]));

else

ubuf[0] = '\0';

res = ubuf;

break;

case 'w':

/* use even incomplete args */

(void)snprintf(ubuf, sizeof(ubuf),

(void)snprintf(ubuf, sizeof(ubuf), "%d",

"%d", (iendarg - iarg) * 24);

24 * (int)naml);

res = ubuf;

break;

default:

break;

}

if (res == NULL)

if (res == NULL) {

if (*esct == '*')

mandoc_msg(MANDOCERR_STR_UNDEF,

ln, (int)(stesc - buf->buf),

"%.*s", (int)naml, stnam);

res = "";

} else if (buf->sz + strlen(res) > SHRT_MAX) {

if (++expand_count > EXPAND_LIMIT ||

mandoc_msg(MANDOCERR_ROFFLOOP,

buf->sz + strlen(res) > SHRT_MAX) {

ln, (int)(stesc - buf->buf), NULL);

mandoc_msg(MANDOCERR_ROFFLOOP, ln, iesc, NULL);

return ROFF_IGN;

}

roff_expand_patch(buf, iesc, res, iend);

/* Replace the escape sequence by the string. */

*stesc = '\0';

buf->sz = mandoc_asprintf(&nbuf, "%s%s%s",

buf->buf, res, cp) + 1;

/* Prepare for the next replacement. */

start = nbuf + pos;

stesc = nbuf + (stesc - buf->buf) + strlen(res);

free(buf->buf);

buf->buf = nbuf;

}

return ROFF_CONT;

}

* Replace the substring from the start position (inclusive)

* to end position (exclusive) with the repl(acement) string.

static void

roff_expand_patch(struct buf *buf, int start, const char *repl, int end)

{

char *nbuf;

buf->sz = mandoc_asprintf(&nbuf, "%.*s%s%s", start, buf->buf,

repl, buf->buf + end) + 1;

free(buf->buf);

buf->buf = nbuf;

}

* Parse a quoted or unquoted roff-style request or macro argument.

* Return a pointer to the parsed argument, which is either the original

* pointer or advanced by one byte in case the argument is quoted.

Line 1586 char *

Line 1590 char *

roff_getarg(struct roff *r, char **cpp, int ln, int *pos)

{

struct buf buf;

char *cp, *start;

int newesc, pairs, quoted, white;

/* Quoting can only start with a new word. */

Line 1755 roff_parsetext(struct roff *r, struct buf *buf, int po

Line 1759 roff_parsetext(struct roff *r, struct buf *buf, int po

}

int

roff_parseln(struct roff *r, int ln, struct buf *buf, int *offs)

roff_parseln(struct roff *r, int ln, struct buf *buf, int *offs, size_t len)

{

enum roff_tok t;

int e;

Line 1766 roff_parseln(struct roff *r, int ln, struct buf *buf,

Line 1770 roff_parseln(struct roff *r, int ln, struct buf *buf,

ppos = pos = *offs;

if (len > 80 && r->tbl == NULL && r->eqn == NULL &&

(r->man->flags & ROFF_NOFILL) == 0 &&

strchr(" .\\", buf->buf[pos]) == NULL &&

buf->buf[pos] != r->control &&

strcspn(buf->buf, " ") < 80)

mandoc_msg(MANDOCERR_TEXT_LONG, ln, (int)len - 1,

"%.20s...", buf->buf + pos);

/* Handle in-line equation delimiters. */

if (r->tbl == NULL &&

Line 1777 roff_parseln(struct roff *r, int ln, struct buf *buf,

Line 1789 roff_parseln(struct roff *r, int ln, struct buf *buf,

assert(e == ROFF_CONT);

}

/* Expand some escape sequences. */

/* Handle comments and escape sequences. */

e = roff_parse_comment(r, buf, ln, pos, r->escape);

if ((e & ROFF_MASK) == ROFF_IGN)

return e;

assert(e == ROFF_CONT);

e = roff_expand(r, buf, ln, pos, r->escape);

if ((e & ROFF_MASK) == ROFF_IGN)

return e;

Line 1811 roff_parseln(struct roff *r, int ln, struct buf *buf,

Line 1828 roff_parseln(struct roff *r, int ln, struct buf *buf,

roff_addtbl(r->man, ln, r->tbl);

return e;

}

if ( ! ctl)

if ( ! ctl) {

r->options &= ~MPARSE_COMMENT;

return roff_parsetext(r, buf, pos, offs) | e;

}

/* Skip empty request lines. */

Line 1825 roff_parseln(struct roff *r, int ln, struct buf *buf,

Line 1844 roff_parseln(struct roff *r, int ln, struct buf *buf,

* If a scope is open, go to the child handler for that macro,

* as it may want to preprocess before doing anything with it.

* Don't do so if an equation is open.

if (r->last) {

Line 1833 roff_parseln(struct roff *r, int ln, struct buf *buf,

Line 1851 roff_parseln(struct roff *r, int ln, struct buf *buf,

return (*roffs[t].sub)(r, t, buf, ln, ppos, pos, offs);

}

/* No scope is open. This is a new request or macro. */

r->options &= ~MPARSE_COMMENT;

spos = pos;

t = roff_parse(r, buf->buf, &pos, ln, ppos);

return roff_req_or_macro(r, t, buf, ln, spos, pos, offs);

}

/* Tables ignore most macros. */

* Handle a new request or macro.

* May be called outside any scope or from inside a conditional scope.

static int

roff_req_or_macro(ROFF_ARGS) {

if (r->tbl != NULL && (t == TOKEN_NONE || t == ROFF_TS ||

/* For now, tables ignore most macros and some request. */

t == ROFF_br || t == ROFF_ce || t == ROFF_rj || t == ROFF_sp)) {

if (r->tbl != NULL && (tok == TOKEN_NONE || tok == ROFF_TS ||

tok == ROFF_br || tok == ROFF_ce || tok == ROFF_rj ||

tok == ROFF_sp)) {

mandoc_msg(MANDOCERR_TBLMACRO,

ln, pos, "%s", buf->buf + spos);

ln, ppos, "%s", buf->buf + ppos);

if (t != TOKEN_NONE)

if (tok != TOKEN_NONE)

return ROFF_IGN;

while (buf->buf[pos] != '\0' && buf->buf[pos] != ' ')

pos++;

Line 1857 roff_parseln(struct roff *r, int ln, struct buf *buf,

Line 1884 roff_parseln(struct roff *r, int ln, struct buf *buf,

/* For now, let high level macros abort .ce mode. */

if (ctl && roffce_node != NULL &&

if (roffce_node != NULL &&

(t == TOKEN_NONE || t == ROFF_Dd || t == ROFF_EQ ||

(tok == TOKEN_NONE || tok == ROFF_Dd || tok == ROFF_EQ ||

t == ROFF_TH || t == ROFF_TS)) {

tok == ROFF_TH || tok == ROFF_TS)) {

r->man->last = roffce_node;

r->man->next = ROFF_NEXT_SIBLING;

roffce_lines = 0;

Line 1871 roff_parseln(struct roff *r, int ln, struct buf *buf,

Line 1898 roff_parseln(struct roff *r, int ln, struct buf *buf,

* Let the standard macro set parsers handle it.

if (t == TOKEN_NONE)

if (tok == TOKEN_NONE)

return ROFF_CONT;

/* Execute a roff request or a user defined macro. */

/* Execute a roff request or a user-defined macro. */

return (*roffs[t].proc)(r, t, buf, ln, spos, pos, offs);

return (*roffs[tok].proc)(r, tok, buf, ln, ppos, pos, offs);

}

Line 1919 roff_endparse(struct roff *r)

Line 1946 roff_endparse(struct roff *r)

}

* Parse a roff node's type from the input buffer. This must be in the

* Parse the request or macro name at buf[*pos].

* form of ".foo xxx" in the usual way.

* Return ROFF_RENAMED, ROFF_USERDEF, or a ROFF_* token value.

* For empty, undefined, mdoc(7), and man(7) macros, return TOKEN_NONE.

* As a side effect, set r->current_string to the definition or to NULL.

static enum roff_tok

roff_parse(struct roff *r, char *buf, int *pos, int ln, int ppos)

Line 1964 roff_parse(struct roff *r, char *buf, int *pos, int ln

Line 1993 roff_parse(struct roff *r, char *buf, int *pos, int ln

/* --- handling of request blocks ----------------------------------------- */

* Close a macro definition block or an "ignore" block.

static int

roff_cblock(ROFF_ARGS)

{

int rr;

* A block-close `..' should only be invoked as a child of an

* ignore macro, otherwise raise a warning and just ignore it.

if (r->last == NULL) {

mandoc_msg(MANDOCERR_BLK_NOTOPEN, ln, ppos, "..");

return ROFF_IGN;

Line 1980 roff_cblock(ROFF_ARGS)

Line 2008 roff_cblock(ROFF_ARGS)

switch (r->last->tok) {

case ROFF_am:

/* ROFF_am1 is remapped to ROFF_am in roff_block(). */

case ROFF_ami:

case ROFF_de:

/* ROFF_de1 is remapped to ROFF_de in roff_block(). */

case ROFF_dei:

case ROFF_ig:

break;

case ROFF_am1:

case ROFF_de1:

/* Remapped in roff_block(). */

abort();

default:

mandoc_msg(MANDOCERR_BLK_NOTOPEN, ln, ppos, "..");

return ROFF_IGN;

}

roffnode_pop(r);

roffnode_cleanscope(r);

* If a conditional block with braces is still open,

* check for "\}" block end markers.

if (r->last != NULL && r->last->endspan < 0) {

rr = 1; /* If arguments follow "\}", warn about them. */

roff_cond_checkend(r, tok, buf, ln, ppos, pos, &rr);

}

if (buf->buf[pos] != '\0')

mandoc_msg(MANDOCERR_ARG_SKIP, ln, pos,

".. %s", buf->buf + pos);

roffnode_pop(r);

roffnode_cleanscope(r);

return ROFF_IGN;

}

* Pop all nodes ending at the end of the current input line.

* Return the number of loops ended.

static int

roffnode_cleanscope(struct roff *r)

{

int inloop;

inloop = 0;

while (r->last != NULL) {

while (r->last != NULL && r->last->endspan > 0) {

if (--r->last->endspan != 0)

break;

inloop += roffnode_pop(r);

Line 2016 roffnode_cleanscope(struct roff *r)

Line 2060 roffnode_cleanscope(struct roff *r)

return inloop;

}

* Handle the closing "\}" of a conditional block.

* Apart from generating warnings, this only pops nodes.

* Return the number of loops ended.

static int

roff_ccond(struct roff *r, int ln, int ppos)

{

Line 2175 roff_block_sub(ROFF_ARGS)

Line 2224 roff_block_sub(ROFF_ARGS)

int i, j;

* First check whether a custom macro exists at this level. If

* If a custom end marker is a user-defined or predefined macro

* it does, then check against it. This is some of groff's

* or a request, interpret it.

* stranger behaviours. If we encountered a custom end-scope

* tag and that tag also happens to be a "real" macro, then we

* need to try interpreting it again as a real macro. If it's

* not, then return ignore. Else continue.

if (r->last->end) {

Line 2206 roff_block_sub(ROFF_ARGS)

Line 2251 roff_block_sub(ROFF_ARGS)

}

/* Handle the standard end marker. */

* If we have no custom end-query or lookup failed, then try

* pulling it out of the hashtable.

t = roff_parse(r, buf->buf, &pos, ln, ppos);

if (t == ROFF_cblock)

return roff_cblock(r, t, buf, ln, ppos, pos, offs);

if (t != ROFF_cblock) {

/* Not an end marker, so append the line to the block. */

if (tok != ROFF_ig)

roff_setstr(r, r->last->name, buf->buf + ppos, 2);

return ROFF_IGN;

}

return (*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs);

if (tok != ROFF_ig)

roff_setstr(r, r->last->name, buf->buf + ppos, 2);

return ROFF_IGN;

}

static int

Line 2232 roff_block_text(ROFF_ARGS)

Line 2274 roff_block_text(ROFF_ARGS)

return ROFF_IGN;

}

* Check for a closing "\}" and handle it.

* In this function, the final "int *offs" argument is used for

* different purposes than elsewhere:

* Input: *offs == 0: caller wants to discard arguments following \}

* *offs == 1: caller wants to preserve text following \}

* Output: *offs = 0: tell caller to discard input line

* *offs = 1: tell caller to use input line

static int

roff_cond_sub(ROFF_ARGS)

roff_cond_checkend(ROFF_ARGS)

{

char *ep;

int endloop, irc, rr;

enum roff_tok t;

irc = ROFF_IGN;

rr = r->last->rule;

Line 2247 roff_cond_sub(ROFF_ARGS)

Line 2297 roff_cond_sub(ROFF_ARGS)

irc |= endloop;

* If `\}' occurs on a macro line without a preceding macro,

* If "\}" occurs on a macro line without a preceding macro or

* drop the line completely.

* a text line contains nothing else, drop the line completely.

ep = buf->buf + pos;

if (ep[0] == '\\' && ep[1] == '}')

if (ep[0] == '\\' && ep[1] == '}' && (ep[2] == '\0' || *offs == 0))

rr = 0;

* The closing delimiter `\}' rewinds the conditional scope

* The closing delimiter "\}" rewinds the conditional scope

* but is otherwise ignored when interpreting the line.

while ((ep = strchr(ep, '\\')) != NULL) {

switch (ep[1]) {

case '}':

memmove(ep, ep + 2, strlen(ep + 2) + 1);

if (ep[2] == '\0')

ep[0] = '\0';

else if (rr)

ep[1] = '&';

else

memmove(ep, ep + 2, strlen(ep + 2) + 1);

if (roff_ccond(r, ln, ep - buf->buf))

irc |= endloop;

break;

Line 2275 roff_cond_sub(ROFF_ARGS)

Line 2330 roff_cond_sub(ROFF_ARGS)

break;

}

*offs = rr;

* Fully handle known macros when they are structurally

* required or when the conditional evaluated to true.

t = roff_parse(r, buf->buf, &pos, ln, ppos);

irc |= t != TOKEN_NONE && (rr || roffs[t].flags & ROFFMAC_STRUCT) ?

(*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs) :

rr ? ROFF_CONT : ROFF_IGN;

return irc;

}

* Parse and process a request or macro line in conditional scope.

static int

roff_cond_text(ROFF_ARGS)

roff_cond_sub(ROFF_ARGS)

{

char *ep;

struct roffnode *bl;

int endloop, irc, rr;

int irc, rr, spos;

enum roff_tok t;

irc = ROFF_IGN;

rr = 0; /* If arguments follow "\}", skip them. */

rr = r->last->rule;

irc = roff_cond_checkend(r, tok, buf, ln, ppos, pos, &rr);

endloop = tok != ROFF_while ? ROFF_IGN :

spos = pos;

rr ? ROFF_LOOPCONT : ROFF_LOOPEXIT;

t = roff_parse(r, buf->buf, &pos, ln, ppos);

if (roffnode_cleanscope(r))

irc |= endloop;

* If `\}' occurs on a text line with neither preceding

* Handle requests and macros if the conditional evaluated

* nor following characters, drop the line completely.

* to true or if they are structurally required.

* The .break request is always handled specially.

ep = buf->buf + pos;

if (t == ROFF_break) {

if (strcmp(ep, "\\}") == 0)

if (irc & ROFF_LOOPMASK)

rr = 0;

irc = ROFF_IGN | ROFF_LOOPEXIT;

else if (rr) {

for (bl = r->last; bl != NULL; bl = bl->parent) {

* The closing delimiter `\}' rewinds the conditional scope

bl->rule = 0;

* but is otherwise ignored when interpreting the line.

if (bl->tok == ROFF_while)

break;

}

while ((ep = strchr(ep, '\\')) != NULL) {

switch (ep[1]) {

case '}':

memmove(ep, ep + 2, strlen(ep + 2) + 1);

if (roff_ccond(r, ln, ep - buf->buf))

irc |= endloop;

break;

case '\0':

++ep;

break;

default:

ep += 2;

break;

}

} else if (rr || (t < TOKEN_NONE && roffs[t].flags & ROFFMAC_STRUCT)) {

irc |= roff_req_or_macro(r, t, buf, ln, spos, pos, offs);

if (irc & ROFF_WHILE)

irc &= ~(ROFF_LOOPCONT | ROFF_LOOPEXIT);

}

return irc;

}

* Parse and process a text line in conditional scope.

static int

roff_cond_text(ROFF_ARGS)

{

int irc, rr;

rr = 1; /* If arguments follow "\}", preserve them. */

irc = roff_cond_checkend(r, tok, buf, ln, ppos, pos, &rr);

if (rr)

irc |= ROFF_CONT;

return irc;

Line 3482 roff_als(ROFF_ARGS)

Line 3535 roff_als(ROFF_ARGS)

return ROFF_IGN;

}

* The .break request only makes sense inside conditionals,

* and that case is already handled in roff_cond_sub().

static int

roff_break(ROFF_ARGS)

{

mandoc_msg(MANDOCERR_BLK_NOTOPEN, ln, pos, "break");

return ROFF_IGN;

}

static int

roff_cc(ROFF_ARGS)

{

const char *p;

Line 3537 roff_char(ROFF_ARGS)

Line 3601 roff_char(ROFF_ARGS)

case ESCAPE_FONTITALIC:

case ESCAPE_FONTBOLD:

case ESCAPE_FONTBI:

case ESCAPE_FONTCW:

case ESCAPE_FONTCR:

case ESCAPE_FONTCB:

case ESCAPE_FONTCI:

case ESCAPE_FONTPREV:

font++;

break;

Line 3597 roff_eo(ROFF_ARGS)

Line 3663 roff_eo(ROFF_ARGS)

}

static int

roff_mc(ROFF_ARGS)

{

struct roff_node *n;

char *cp;

/* Parse the first argument. */

cp = buf->buf + pos;

if (*cp != '\0')

cp++;

if (buf->buf[pos] == '\\') {

switch (mandoc_escape((const char **)&cp, NULL, NULL)) {

case ESCAPE_SPECIAL:

case ESCAPE_UNICODE:

case ESCAPE_NUMBERED:

break;

default:

*cp = '\0';

mandoc_msg(MANDOCERR_MC_ESC, ln, pos,

"mc %s", buf->buf + pos);

buf->buf[pos] = '\0';

break;

}

/* Ignore additional arguments. */

while (*cp == ' ')

*cp++ = '\0';

if (*cp != '\0') {

mandoc_msg(MANDOCERR_MC_DIST, ln, (int)(cp - buf->buf),

"mc ... %s", cp);

*cp = '\0';

}

/* Create the .mc node. */

roff_elem_alloc(r->man, ln, ppos, tok);

n = r->man->last;

if (buf->buf[pos] != '\0')

roff_word_alloc(r->man, ln, pos, buf->buf + pos);

n->flags |= NODE_LINE | NODE_VALID | NODE_ENDED;

r->man->last = n;

r->man->next = ROFF_NEXT_SIBLING;

return ROFF_IGN;

}

static int

roff_nop(ROFF_ARGS)

{

while (buf->buf[pos] == ' ')

Line 3737 static int

Line 3851 static int

roff_shift(ROFF_ARGS)

{

struct mctx *ctx;

int levels, i;

int argpos, levels, i;

argpos = pos;

levels = 1;

if (buf->buf[pos] != '\0' &&

roff_evalnum(r, ln, buf->buf, &pos, &levels, 0) == 0) {

Line 3753 roff_shift(ROFF_ARGS)

Line 3868 roff_shift(ROFF_ARGS)

ctx = r->mstack + r->mstackpos;

if (levels > ctx->argc) {

mandoc_msg(MANDOCERR_SHIFT,

ln, pos, "%d, but max is %d", levels, ctx->argc);

ln, argpos, "%d, but max is %d", levels, ctx->argc);

levels = ctx->argc;

}

if (levels < 0) {

mandoc_msg(MANDOCERR_ARG_NEG, ln, argpos, "shift %d", levels);

levels = 0;

}

if (levels == 0)

return ROFF_IGN;

for (i = 0; i < levels; i++)

Line 3804 roff_userdef(ROFF_ARGS)

Line 3923 roff_userdef(ROFF_ARGS)

char *arg, *ap, *dst, *src;

size_t sz;

/* If the macro is empty, ignore it altogether. */

if (*r->current_string == '\0')

return ROFF_IGN;

/* Initialize a new macro stack context. */

if (++r->mstackpos == r->mstacksz) {

Line 3812 roff_userdef(ROFF_ARGS)

Line 3936 roff_userdef(ROFF_ARGS)

r->mstacksz += 8;

}

ctx = r->mstack + r->mstackpos;

ctx->argsz = 0;

ctx->argc = 0;

ctx->argv = NULL;

* Collect pointers to macro argument strings,

Line 3851 roff_userdef(ROFF_ARGS)

Line 3973 roff_userdef(ROFF_ARGS)

buf->sz = strlen(buf->buf) + 1;

*offs = 0;

return buf->sz > 1 && buf->buf[buf->sz - 2] == '\n' ?

return buf->buf[buf->sz - 2] == '\n' ?

ROFF_REPARSE | ROFF_USERCALL : ROFF_IGN | ROFF_APPEND;

}

CVSweb