mandoc/roff.c - diff

Return to roff.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/roff.c between version 1.295 and 1.304

version 1.295, 2017/04/29 12:45:42

version 1.304, 2017/06/04 22:44:15

Line 77 struct roffreq {

struct roff {

struct mparse *parse; /* parse point */

struct roff_man *man; /* mdoc or man parser */

struct roffnode *last; /* leaf of stack */

int *rstack; /* stack of inverted `ie' values */

struct ohash *reqtab; /* request lookup table */

Line 98 struct roff {

Line 99 struct roff {

int format; /* current file in mdoc or man format */

int argc; /* number of args of the last macro */

char control; /* control character */

char escape; /* escape character */

};

struct roffnode {

Line 146 static void roffnode_push(struct roff *, enum roff_t

Line 148 static void roffnode_push(struct roff *, enum roff_t

static enum rofferr roff_block(ROFF_ARGS);

static enum rofferr roff_block_text(ROFF_ARGS);

static enum rofferr roff_block_sub(ROFF_ARGS);

static enum rofferr roff_brp(ROFF_ARGS);

static enum rofferr roff_br(ROFF_ARGS);

static enum rofferr roff_cblock(ROFF_ARGS);

static enum rofferr roff_cc(ROFF_ARGS);

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

Line 154 static enum rofferr roff_cond(ROFF_ARGS);

Line 156 static enum rofferr roff_cond(ROFF_ARGS);

static enum rofferr roff_cond_text(ROFF_ARGS);

static enum rofferr roff_cond_sub(ROFF_ARGS);

static enum rofferr roff_ds(ROFF_ARGS);

static enum rofferr roff_ec(ROFF_ARGS);

static enum rofferr roff_eo(ROFF_ARGS);

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

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

static int roff_evalnum(struct roff *, int,

Line 180 static enum rofferr roff_it(ROFF_ARGS);

Line 184 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_manyarg(ROFF_ARGS);

static enum rofferr roff_nr(ROFF_ARGS);

static enum rofferr roff_onearg(ROFF_ARGS);

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

int, int);

static enum rofferr roff_parsetext(struct buf *, int, int *);

Line 209 static enum rofferr roff_userdef(ROFF_ARGS);

Line 215 static enum rofferr roff_userdef(ROFF_ARGS);

#define ROFFNUM_WHITE (1 << 1) /* Skip whitespace in roff_evalnum(). */

const char *__roff_name[MAN_MAX + 1] = {

"br", "ft", "ll", "mc",

"sp", "ta", "ti", NULL,

"ab", "ad", "af", "aln",

"als", "am", "am1", "ami",

"ami1", "as", "as1", "asciify",

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

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

"lc", "lc_ctype", "lds", "length",

"letadj", "lf", "lg", "lhang",

"linetabs", "lnr", "lnrf", "lpfx",

"ls", "lsm", "lt", "mc",

"ls", "lsm", "lt",

"mediasize", "minss", "mk", "mso",

"na", "ne", "nh", "nhychar",

"nm", "nn", "nop", "nr",

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

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

"shc", "shift", "sizes", "so",

"spacewidth", "special", "spreadwarn", "ss",

"sty", "substring", "sv", "sy",

"T&", "ta", "tc", "TE",

"T&", "tc", "TE",

"TH", "ti", "tkf", "tl",

"TH", "tkf", "tl",

"tm", "tm1", "tmc", "tr",

"track", "transchar", "trf", "trimat",

"trin", "trnt", "troff", "TS",

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

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

"Fr", "Ud", "Lb", "Lp",

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

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

"Dx", "%Q", "br", "sp",

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

"%U", "Ta", "ll", NULL,

NULL,

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

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

"HP", "SM", "SB", "BI",

"IB", "BR", "RB", "R",

"B", "I", "IR", "RI",

"br", "sp", "nf", "fi",

"nf", "fi",

"RE", "RS", "DT", "UC",

"PD", "AT", "in", "ft",

"PD", "AT", "in",

"OP", "EX", "EE", "UR",

"UE", "ll", NULL

"UE", NULL

};

const char *const *roff_name = __roff_name;

static struct roffmac roffs[TOKEN_NONE] = {

{ roff_br, NULL, NULL, 0 }, /* br */

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

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

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

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

{ roff_manyarg, NULL, NULL, 0 }, /* ta */

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

{ NULL, NULL, NULL, 0 }, /* ROFF_MAX */

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

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

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

Line 337 static struct roffmac roffs[TOKEN_NONE] = {

Line 353 static struct roffmac roffs[TOKEN_NONE] = {

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

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

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

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

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

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

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

{ roff_cc, NULL, NULL, 0 }, /* cc */

Line 373 static struct roffmac roffs[TOKEN_NONE] = {

Line 389 static struct roffmac roffs[TOKEN_NONE] = {

{ roff_ds, NULL, NULL, 0 }, /* ds1 */

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

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

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

{ roff_ec, NULL, NULL, 0 }, /* ec */

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

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

{ roff_cond, roff_cond_text, roff_cond_sub, ROFFMAC_STRUCT }, /* el */

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

{ roff_EN, NULL, NULL, 0 }, /* EN */

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

{ roff_eo, NULL, NULL, 0 }, /* eo */

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

{ roff_EQ, NULL, NULL, 0 }, /* EQ */

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

Line 445 static struct roffmac roffs[TOKEN_NONE] = {

Line 461 static struct roffmac roffs[TOKEN_NONE] = {

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

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

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

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

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

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

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

Line 511 static struct roffmac roffs[TOKEN_NONE] = {

Line 526 static struct roffmac roffs[TOKEN_NONE] = {

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

{ roff_insec, NULL, NULL, 0 }, /* sy */

{ roff_T_, NULL, NULL, 0 }, /* T& */

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

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

{ roff_TE, NULL, NULL, 0 }, /* TE */

{ roff_TH, NULL, NULL, 0 }, /* TH */

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

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

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

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

Line 610 roffhash_alloc(enum roff_tok mintok, enum roff_tok max

Line 623 roffhash_alloc(enum roff_tok mintok, enum roff_tok max

mandoc_ohash_init(htab, 8, offsetof(struct roffreq, name));

for (tok = mintok; tok < maxtok; tok++) {

if (roff_name[tok] == NULL)

continue;

sz = strlen(roff_name[tok]);

req = mandoc_malloc(sizeof(*req) + sz + 1);

req->tok = tok;

Line 739 roff_reset(struct roff *r)

Line 754 roff_reset(struct roff *r)

{

roff_free1(r);

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

r->control = 0;

r->control = '\0';

r->escape = '\\';

}

void

Line 761 roff_alloc(struct mparse *parse, int options)

Line 777 roff_alloc(struct mparse *parse, int options)

r->options = options;

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

r->rstackpos = -1;

r->escape = '\\';

return r;

}

Line 824 roff_man_alloc(struct roff *roff, struct mparse *parse

Line 841 roff_man_alloc(struct roff *roff, struct mparse *parse

man->defos = defos;

man->quick = quick;

roff_man_alloc1(man);

roff->man = man;

return man;

}

Line 996 roff_addtbl(struct roff_man *man, const struct tbl_spa

Line 1014 roff_addtbl(struct roff_man *man, const struct tbl_spa

struct roff_node *n;

if (man->macroset == MACROSET_MAN)

man_breakscope(man, TOKEN_NONE);

man_breakscope(man, ROFF_TS);

n = roff_node_alloc(man, tbl->line, 0, ROFFT_TBL, TOKEN_NONE);

n->span = tbl;

roff_node_append(man, n);

Line 1136 roff_res(struct roff *r, struct buf *buf, int ln, int

Line 1154 roff_res(struct roff *r, struct buf *buf, int ln, int

int expand_count; /* to avoid infinite loops */

int npos; /* position in numeric expression */

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

int done; /* no more input available */

char term; /* character terminating the escape */

expand_count = 0;

/* Search forward for comments. */

done = 0;

start = buf->buf + pos;

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

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

while (stesc-- > start) {

if (stesc[0] != r->escape || stesc[1] == '\0')

continue;

stesc++;

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

continue;

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

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

done = 1;

cp--;

}

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

mandoc_msg(MANDOCERR_SPACE_EOL, r->parse,

ln, cp - buf->buf, NULL);

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

stesc--;

*stesc = '\0';

break;

}

if (stesc == start)

return ROFF_CONT;

stesc--;

/* Notice the end of the input. */

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

*stesc-- = '\0';

done = 1;

}

expand_count = 0;

while (stesc >= start) {

/* Search backwards for the next backslash. */

if (*stesc != '\\')

if (*stesc != r->escape) {

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

*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;

}

stesc--;

continue;

}

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

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

if (*cp != '\\')

if (*cp != r->escape)

break;

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

stesc = (char *)cp;

while (stesc > cp)

*stesc-- = '\\';

continue;

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

*stesc = '\\';

} else {

*stesc-- = '\0';

if (done)

continue;

else

return ROFF_APPEND;

}

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

Line 1182 roff_res(struct roff *r, struct buf *buf, int ln, int

Line 1253 roff_res(struct roff *r, struct buf *buf, int ln, int

mandoc_vmsg(MANDOCERR_ESC_BAD,

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

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

stesc--;

continue;

}

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

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

/* Expand some escape sequences. */

e = roff_res(r, buf, ln, pos);

if (e == ROFF_IGN)

if (e == ROFF_IGN || e == ROFF_APPEND)

return e;

assert(e == ROFF_CONT);

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

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

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

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

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

}

void

Line 2633 roff_T_(ROFF_ARGS)

Line 2705 roff_T_(ROFF_ARGS)

mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse,

ln, ppos, "T&");

else

tbl_restart(ppos, ln, r->tbl);

tbl_restart(ln, ppos, r->tbl);

return ROFF_IGN;

}

Line 2760 roff_TS(ROFF_ARGS)

Line 2832 roff_TS(ROFF_ARGS)

}

static enum rofferr

roff_brp(ROFF_ARGS)

roff_onearg(ROFF_ARGS)

{

struct roff_node *n;

char *cp;

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

if (r->man->flags & (MAN_BLINE | MAN_ELINE) &&

return ROFF_CONT;

(tok == ROFF_sp || tok == ROFF_ti))

man_breakscope(r->man, tok);

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

n = r->man->last;

cp = buf->buf + pos;

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

while (*cp != '\0' && *cp != ' ')

cp++;

while (*cp == ' ')

*cp++ = '\0';

if (*cp != '\0')

mandoc_vmsg(MANDOCERR_ARG_EXCESS,

r->parse, ln, cp - buf->buf,

"%s ... %s", roff_name[tok], cp);

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 enum rofferr

roff_manyarg(ROFF_ARGS)

{

struct roff_node *n;

char *sp, *ep;

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

n = r->man->last;

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

while (*ep != '\0' && *ep != ' ')

ep++;

while (*ep == ' ')

*ep++ = '\0';

roff_word_alloc(r->man, ln, sp - buf->buf, sp);

}

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

r->man->last = n;

r->man->next = ROFF_NEXT_SIBLING;

return ROFF_IGN;

}

static enum rofferr

roff_br(ROFF_ARGS)

{

if (r->man->flags & (MAN_BLINE | MAN_ELINE))

man_breakscope(r->man, ROFF_br);

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

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

mandoc_vmsg(MANDOCERR_ARG_SKIP, r->parse, ln, pos,

"%s %s", roff_name[tok], buf->buf + pos);

r->man->last->flags |= NODE_LINE | NODE_VALID | NODE_ENDED;

r->man->next = ROFF_NEXT_SIBLING;

return ROFF_IGN;

}

static enum rofferr

roff_cc(ROFF_ARGS)

{

const char *p;

Line 2775 roff_cc(ROFF_ARGS)

Line 2908 roff_cc(ROFF_ARGS)

p = buf->buf + pos;

if (*p == '\0' || (r->control = *p++) == '.')

r->control = 0;

r->control = '\0';

if (*p != '\0')

mandoc_vmsg(MANDOCERR_ARG_EXCESS, r->parse,

Line 2785 roff_cc(ROFF_ARGS)

Line 2918 roff_cc(ROFF_ARGS)

}

static enum rofferr

roff_ec(ROFF_ARGS)

{

const char *p;

p = buf->buf + pos;

if (*p == '\0')

r->escape = '\\';

else {

r->escape = *p;

if (*++p != '\0')

mandoc_vmsg(MANDOCERR_ARG_EXCESS, r->parse,

ln, p - buf->buf, "ec ... %s", p);

}

return ROFF_IGN;

}

static enum rofferr

roff_eo(ROFF_ARGS)

{

r->escape = '\0';

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

mandoc_vmsg(MANDOCERR_ARG_SKIP, r->parse,

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

return ROFF_IGN;

}

static enum rofferr

roff_tr(ROFF_ARGS)

{

const char *p, *first, *second;

Line 3311 roff_getcontrol(const struct roff *r, const char *cp,

Line 3471 roff_getcontrol(const struct roff *r, const char *cp,

pos = *ppos;

if (0 != r->control && cp[pos] == r->control)

if (r->control != '\0' && cp[pos] == r->control)

pos++;

else if (0 != r->control)

else if (r->control != '\0')

return 0;

else if ('\\' == cp[pos] && '.' == cp[pos + 1])

pos += 2;

CVSweb