mandoc/roff.c - diff

Return to roff.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/roff.c between version 1.357 and 1.367

version 1.357, 2018/12/31 04:55:47

version 1.367, 2019/11/09 14:39:49

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 133 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 184 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_br(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);

Line 221 static int roff_line_ignore(ROFF_ARGS);

Line 224 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_noarg(ROFF_ARGS);

static int roff_nop(ROFF_ARGS);

static int roff_nr(ROFF_ARGS);

static int roff_onearg(ROFF_ARGS);

Line 257 static int roff_userdef(ROFF_ARGS);

Line 261 static int roff_userdef(ROFF_ARGS);

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

const char *__roff_name[MAN_MAX + 1] = {

"br", "ce", "ft", "ll",

"br", "ce", "fi", "ft",

"mc", "po", "rj", "sp",

"ll", "mc", "nf",

"po", "rj", "sp",

"ta", "ti", NULL,

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

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

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

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

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

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

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

"nf", "fi",

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

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

"SY", "YS", "OP",

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

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

const char *const *roff_name = __roff_name;

static struct roffmac roffs[TOKEN_NONE] = {

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

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

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

{ 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_noarg, NULL, NULL, 0 }, /* nf */

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

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

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

Line 398 static struct roffmac roffs[TOKEN_NONE] = {

Line 404 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_br, NULL, NULL, 0 }, /* brp */

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

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

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

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

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

Line 689 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 765 void

Line 771 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 777 roff_reset(struct roff *r)

Line 784 roff_reset(struct roff *r)

void

roff_free(struct roff *r)

{

int i;

roff_free1(r);

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

Line 794 roff_alloc(int options)

Line 801 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 887 roff_node_alloc(struct roff_man *man, int line, int po

Line 894 roff_node_alloc(struct roff_man *man, int line, int po

n->flags |= NODE_SYNPRETTY;

else

n->flags &= ~NODE_SYNPRETTY;

if ((man->flags & (ROFF_NOFILL | ROFF_NONOFILL)) == ROFF_NOFILL)

n->flags |= NODE_NOFILL;

else

n->flags &= ~NODE_NOFILL;

if (man->flags & MDOC_NEWLINE)

n->flags |= NODE_LINE;

man->flags &= ~MDOC_NEWLINE;

Line 1236 roff_expand(struct roff *r, struct buf *buf, int ln, i

Line 1247 roff_expand(struct roff *r, struct buf *buf, int ln, i

* in the syntax tree.

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

if (newesc != ASCII_ESC && r->options & MPARSE_COMMENT) {

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

ep--;

ep[1] = '\0';

Line 1580 char *

Line 1591 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 1805 roff_parseln(struct roff *r, int ln, struct buf *buf,

Line 1816 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 1829 roff_parseln(struct roff *r, int ln, struct buf *buf,

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

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

Line 1996 roff_cblock(ROFF_ARGS)

Line 2010 roff_cblock(ROFF_ARGS)

}

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

{

Line 2010 roffnode_cleanscope(struct roff *r)

Line 2028 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 2229 roff_block_text(ROFF_ARGS)

Line 2252 roff_block_text(ROFF_ARGS)

static int

roff_cond_sub(ROFF_ARGS)

{

struct roffnode *bl;

char *ep;

int endloop, irc, rr;

enum roff_tok t;

Line 2276 roff_cond_sub(ROFF_ARGS)

Line 2300 roff_cond_sub(ROFF_ARGS)

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

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

if (t == ROFF_break) {

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

if (irc & ROFF_LOOPMASK)

rr ? ROFF_CONT : ROFF_IGN;

irc = ROFF_IGN | ROFF_LOOPEXIT;

else if (rr) {

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

bl->rule = 0;

if (bl->tok == ROFF_while)

break;

}

} else if (t != TOKEN_NONE &&

(rr || roffs[t].flags & ROFFMAC_STRUCT))

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

else

irc |= rr ? ROFF_CONT : ROFF_IGN;

return irc;

}

Line 2531 roff_evalcond(struct roff *r, int ln, char *v, int *po

Line 2567 roff_evalcond(struct roff *r, int ln, char *v, int *po

roff_getstrn(r, name, sz, &deftype);

istrue = !!deftype;

}

*pos = cp - v;

*pos = (name + sz) - v;

return istrue == wanttrue;

default:

break;

Line 2677 roff_ds(ROFF_ARGS)

Line 2713 roff_ds(ROFF_ARGS)

return ROFF_IGN;

namesz = roff_getname(r, &string, ln, pos);

if (name[namesz] == '\\')

switch (name[namesz]) {

case '\\':

return ROFF_IGN;

case '\t':

string = buf->buf + pos + namesz;

break;

default:

break;

}

/* Read past the initial double-quote, if any. */

if (*string == '"')

Line 3054 roff_nr(ROFF_ARGS)

Line 3097 roff_nr(ROFF_ARGS)

return ROFF_IGN;

keysz = roff_getname(r, &val, ln, pos);

if (key[keysz] == '\\')

if (key[keysz] == '\\' || key[keysz] == '\t')

return ROFF_IGN;

sign = *val;

Line 3118 roff_rm(ROFF_ARGS)

Line 3161 roff_rm(ROFF_ARGS)

namesz = roff_getname(r, &cp, ln, (int)(cp - buf->buf));

roff_setstrn(&r->strtab, name, namesz, NULL, 0, 0);

roff_setstrn(&r->rentab, name, namesz, NULL, 0, 0);

if (name[namesz] == '\\')

if (name[namesz] == '\\' || name[namesz] == '\t')

break;

}

return ROFF_IGN;

Line 3186 roff_Dd(ROFF_ARGS)

Line 3229 roff_Dd(ROFF_ARGS)

static int

roff_TE(ROFF_ARGS)

{

r->man->flags &= ~ROFF_NONOFILL;

if (r->tbl == NULL) {

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

return ROFF_IGN;

Line 3330 roff_TS(ROFF_ARGS)

Line 3374 roff_TS(ROFF_ARGS)

mandoc_msg(MANDOCERR_BLK_BROKEN, ln, ppos, "TS breaks TS");

tbl_end(r->tbl, 0);

}

r->man->flags |= ROFF_NONOFILL;

r->tbl = tbl_alloc(ppos, ln, r->last_tbl);

if (r->last_tbl == NULL)

r->first_tbl = r->tbl;

Line 3338 roff_TS(ROFF_ARGS)

Line 3383 roff_TS(ROFF_ARGS)

}

static int

roff_noarg(ROFF_ARGS)

{

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

man_breakscope(r->man, tok);

if (tok == ROFF_brp)

tok = ROFF_br;

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

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

mandoc_msg(MANDOCERR_ARG_SKIP, ln, pos,

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

if (tok == ROFF_nf)

r->man->flags |= ROFF_NOFILL;

else if (tok == ROFF_fi)

r->man->flags &= ~ROFF_NOFILL;

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

r->man->next = ROFF_NEXT_SIBLING;

return ROFF_IGN;

}

static int

roff_onearg(ROFF_ARGS)

{

struct roff_node *n;

Line 3431 roff_als(ROFF_ARGS)

Line 3496 roff_als(ROFF_ARGS)

return ROFF_IGN;

newsz = roff_getname(r, &oldn, ln, pos);

if (newn[newsz] == '\\' || *oldn == '\0')

if (newn[newsz] == '\\' || newn[newsz] == '\t' || *oldn == '\0')

return ROFF_IGN;

end = oldn;

Line 3447 roff_als(ROFF_ARGS)

Line 3512 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_br(ROFF_ARGS)

roff_break(ROFF_ARGS)

{

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

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

man_breakscope(r->man, ROFF_br);

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

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

mandoc_msg(MANDOCERR_ARG_SKIP, 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;

}

Line 3675 roff_rn(ROFF_ARGS)

Line 3737 roff_rn(ROFF_ARGS)

return ROFF_IGN;

oldsz = roff_getname(r, &newn, ln, pos);

if (oldn[oldsz] == '\\' || *newn == '\0')

if (oldn[oldsz] == '\\' || oldn[oldsz] == '\t' || *newn == '\0')

return ROFF_IGN;

end = newn;

Line 3783 roff_userdef(ROFF_ARGS)

Line 3845 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 3830 roff_userdef(ROFF_ARGS)

Line 3897 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;

}

Line 3851 roff_renamed(ROFF_ARGS)

Line 3918 roff_renamed(ROFF_ARGS)

return ROFF_CONT;

}

* Measure the length in bytes of the roff identifier at *cpp

* and advance the pointer to the next word.

static size_t

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

{

Line 3858 roff_getname(struct roff *r, char **cpp, int ln, int p

Line 3929 roff_getname(struct roff *r, char **cpp, int ln, int p

size_t namesz;

name = *cpp;

if ('\0' == *name)

if (*name == '\0')

return 0;

/* Read until end of name and terminate it with NUL. */

/* Advance cp to the byte after the end of the name. */

for (cp = name; 1; cp++) {

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

namesz = cp - name;

if (*cp == '\0')

break;

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

cp++;

break;

}

if ('\\' != *cp)

if (*cp != '\\')

continue;

namesz = cp - name;

if (cp[1] == '{' || cp[1] == '}')

if ('{' == cp[1] || '}' == cp[1])

break;

cp++;

if (*++cp == '\\')

if ('\\' == *cp)

continue;

mandoc_msg(MANDOCERR_NAMESC, ln, pos,

"%.*s", (int)(cp - name + 1), name);

Line 3882 roff_getname(struct roff *r, char **cpp, int ln, int p

Line 3955 roff_getname(struct roff *r, char **cpp, int ln, int p

}

/* Read past spaces. */

while (' ' == *cp)

while (*cp == ' ')

cp++;

*cpp = cp;

CVSweb