version 1.363, 2019/02/06 21:11:43 |
version 1.377, 2021/06/27 17:57:55 |
|
|
/* $Id$ */ |
/* $Id$ */ |
/* |
/* |
|
* Copyright (c) 2010-2015, 2017-2020 Ingo Schwarze <schwarze@openbsd.org> |
* Copyright (c) 2008-2012, 2014 Kristaps Dzonsons <kristaps@bsd.lv> |
* Copyright (c) 2008-2012, 2014 Kristaps Dzonsons <kristaps@bsd.lv> |
* Copyright (c) 2010-2015, 2017-2019 Ingo Schwarze <schwarze@openbsd.org> |
|
* |
* |
* Permission to use, copy, modify, and distribute this software for any |
* Permission to use, copy, modify, and distribute this software for any |
* purpose with or without fee is hereby granted, provided that the above |
* purpose with or without fee is hereby granted, provided that the above |
|
|
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN |
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF |
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. |
|
* |
|
* Implementation of the roff(7) parser for mandoc(1). |
*/ |
*/ |
#include "config.h" |
#include "config.h" |
|
|
|
|
char escape; /* escape character */ |
char escape; /* escape character */ |
}; |
}; |
|
|
|
/* |
|
* A macro definition, condition, or ignored block. |
|
*/ |
struct roffnode { |
struct roffnode { |
enum roff_tok tok; /* type of node */ |
enum roff_tok tok; /* type of node */ |
struct roffnode *parent; /* up one in stack */ |
struct roffnode *parent; /* up one in stack */ |
int line; /* parse line */ |
int line; /* parse line */ |
int col; /* parse col */ |
int col; /* parse col */ |
char *name; /* node name, e.g. macro name */ |
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 */ \ |
#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(ROFF_ARGS); |
static int roff_block_text(ROFF_ARGS); |
static int roff_block_text(ROFF_ARGS); |
static int roff_block_sub(ROFF_ARGS); |
static int roff_block_sub(ROFF_ARGS); |
|
static int roff_break(ROFF_ARGS); |
static int roff_cblock(ROFF_ARGS); |
static int roff_cblock(ROFF_ARGS); |
static int roff_cc(ROFF_ARGS); |
static int roff_cc(ROFF_ARGS); |
static int roff_ccond(struct roff *, int, int); |
static int roff_ccond(struct roff *, int, int); |
static int roff_char(ROFF_ARGS); |
static int roff_char(ROFF_ARGS); |
static int roff_cond(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_text(ROFF_ARGS); |
static int roff_cond_sub(ROFF_ARGS); |
static int roff_cond_sub(ROFF_ARGS); |
static int roff_ds(ROFF_ARGS); |
static int roff_ds(ROFF_ARGS); |
static int roff_ec(ROFF_ARGS); |
static int roff_ec(ROFF_ARGS); |
static int roff_eo(ROFF_ARGS); |
static int roff_eo(ROFF_ARGS); |
static int roff_eqndelim(struct roff *, struct buf *, int); |
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, |
static int roff_evalnum(struct roff *, int, |
const char *, int *, int *, int); |
const char *, int *, int *, int); |
static int roff_evalpar(struct roff *, int, |
static int roff_evalpar(struct roff *, int, |
Line 351 const char *__roff_name[MAN_MAX + 1] = { |
|
Line 358 const char *__roff_name[MAN_MAX + 1] = { |
|
"Lk", "Mt", "Brq", "Bro", |
"Lk", "Mt", "Brq", "Bro", |
"Brc", "%C", "Es", "En", |
"Brc", "%C", "Es", "En", |
"Dx", "%Q", "%U", "Ta", |
"Dx", "%Q", "%U", "Ta", |
NULL, |
"Tg", NULL, |
"TH", "SH", "SS", "TP", |
"TH", "SH", "SS", "TP", |
"TQ", |
"TQ", |
"LP", "PP", "P", "IP", |
"LP", "PP", "P", "IP", |
Line 400 static struct roffmac roffs[TOKEN_NONE] = { |
|
Line 407 static struct roffmac roffs[TOKEN_NONE] = { |
|
{ roff_unsupp, NULL, NULL, 0 }, /* boxa */ |
{ roff_unsupp, NULL, NULL, 0 }, /* boxa */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* bp */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* bp */ |
{ roff_unsupp, 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 }, /* breakchar */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* brnl */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* brnl */ |
{ roff_noarg, NULL, NULL, 0 }, /* brp */ |
{ roff_noarg, NULL, NULL, 0 }, /* brp */ |
Line 685 roffhash_find(struct ohash *htab, const char *name, si |
|
Line 692 roffhash_find(struct ohash *htab, const char *name, si |
|
|
|
/* |
/* |
* Pop the current node off of the stack of roff instructions currently |
* 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 |
static int |
roffnode_pop(struct roff *r) |
roffnode_pop(struct roff *r) |
|
|
roff_reset(struct roff *r) |
roff_reset(struct roff *r) |
{ |
{ |
roff_free1(r); |
roff_free1(r); |
|
r->options |= MPARSE_COMMENT; |
r->format = r->options & (MPARSE_MDOC | MPARSE_MAN); |
r->format = r->options & (MPARSE_MDOC | MPARSE_MAN); |
r->control = '\0'; |
r->control = '\0'; |
r->escape = '\\'; |
r->escape = '\\'; |
Line 779 roff_reset(struct roff *r) |
|
Line 787 roff_reset(struct roff *r) |
|
void |
void |
roff_free(struct roff *r) |
roff_free(struct roff *r) |
{ |
{ |
int i; |
int i; |
|
|
roff_free1(r); |
roff_free1(r); |
for (i = 0; i < r->mstacksz; i++) |
for (i = 0; i < r->mstacksz; i++) |
Line 796 roff_alloc(int options) |
|
Line 804 roff_alloc(int options) |
|
|
|
r = mandoc_calloc(1, sizeof(struct roff)); |
r = mandoc_calloc(1, sizeof(struct roff)); |
r->reqtab = roffhash_alloc(0, ROFF_RENAMED); |
r->reqtab = roffhash_alloc(0, ROFF_RENAMED); |
r->options = options; |
r->options = options | MPARSE_COMMENT; |
r->format = options & (MPARSE_MDOC | MPARSE_MAN); |
r->format = options & (MPARSE_MDOC | MPARSE_MAN); |
r->mstackpos = -1; |
r->mstackpos = -1; |
r->rstackpos = -1; |
r->rstackpos = -1; |
Line 1096 roff_node_free(struct roff_node *n) |
|
Line 1104 roff_node_free(struct roff_node *n) |
|
free(n->norm); |
free(n->norm); |
eqn_box_free(n->eqn); |
eqn_box_free(n->eqn); |
free(n->string); |
free(n->string); |
|
free(n->tag); |
free(n); |
free(n); |
} |
} |
|
|
Line 1109 roff_node_delete(struct roff_man *man, struct roff_nod |
|
Line 1118 roff_node_delete(struct roff_man *man, struct roff_nod |
|
roff_node_free(n); |
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 |
void |
deroff(char **dest, const struct roff_node *n) |
deroff(char **dest, const struct roff_node *n) |
{ |
{ |
char *cp; |
char *cp; |
size_t sz; |
size_t sz; |
|
|
if (n->type != ROFFT_TEXT) { |
if (n->string == NULL) { |
for (n = n->child; n != NULL; n = n->next) |
for (n = n->child; n != NULL; n = n->next) |
deroff(dest, n); |
deroff(dest, n); |
return; |
return; |
Line 1242 roff_expand(struct roff *r, struct buf *buf, int ln, i |
|
Line 1310 roff_expand(struct roff *r, struct buf *buf, int ln, i |
|
* in the syntax tree. |
* in the syntax tree. |
*/ |
*/ |
|
|
if (newesc != ASCII_ESC && r->format == 0) { |
if (newesc != ASCII_ESC && r->options & MPARSE_COMMENT) { |
while (*ep == ' ' || *ep == '\t') |
while (*ep == ' ' || *ep == '\t') |
ep--; |
ep--; |
ep[1] = '\0'; |
ep[1] = '\0'; |
|
|
roff_getarg(struct roff *r, char **cpp, int ln, int *pos) |
roff_getarg(struct roff *r, char **cpp, int ln, int *pos) |
{ |
{ |
struct buf buf; |
struct buf buf; |
char *cp, *start; |
char *cp, *start; |
int newesc, pairs, quoted, white; |
int newesc, pairs, quoted, white; |
|
|
/* Quoting can only start with a new word. */ |
/* Quoting can only start with a new word. */ |
Line 1755 roff_parsetext(struct roff *r, struct buf *buf, int po |
|
Line 1823 roff_parsetext(struct roff *r, struct buf *buf, int po |
|
} |
} |
|
|
int |
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; |
enum roff_tok t; |
int e; |
int e; |
Line 1766 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
Line 1834 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
|
|
ppos = pos = *offs; |
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. */ |
/* Handle in-line equation delimiters. */ |
|
|
if (r->tbl == NULL && |
if (r->tbl == NULL && |
Line 1811 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
Line 1887 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
roff_addtbl(r->man, ln, r->tbl); |
roff_addtbl(r->man, ln, r->tbl); |
return e; |
return e; |
} |
} |
if ( ! ctl) |
if ( ! ctl) { |
|
r->options &= ~MPARSE_COMMENT; |
return roff_parsetext(r, buf, pos, offs) | e; |
return roff_parsetext(r, buf, pos, offs) | e; |
|
} |
|
|
/* Skip empty request lines. */ |
/* Skip empty request lines. */ |
|
|
Line 1835 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
Line 1913 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
|
|
/* No scope is open. This is a new request or macro. */ |
/* No scope is open. This is a new request or macro. */ |
|
|
|
r->options &= ~MPARSE_COMMENT; |
spos = pos; |
spos = pos; |
t = roff_parse(r, buf->buf, &pos, ln, ppos); |
t = roff_parse(r, buf->buf, &pos, ln, ppos); |
|
|
Line 1964 roff_parse(struct roff *r, char *buf, int *pos, int ln |
|
Line 2043 roff_parse(struct roff *r, char *buf, int *pos, int ln |
|
|
|
/* --- handling of request blocks ----------------------------------------- */ |
/* --- handling of request blocks ----------------------------------------- */ |
|
|
|
/* |
|
* Close a macro definition block or an "ignore" block. |
|
*/ |
static int |
static int |
roff_cblock(ROFF_ARGS) |
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) { |
if (r->last == NULL) { |
mandoc_msg(MANDOCERR_BLK_NOTOPEN, ln, ppos, ".."); |
mandoc_msg(MANDOCERR_BLK_NOTOPEN, ln, ppos, ".."); |
return ROFF_IGN; |
return ROFF_IGN; |
Line 1980 roff_cblock(ROFF_ARGS) |
|
Line 2058 roff_cblock(ROFF_ARGS) |
|
|
|
switch (r->last->tok) { |
switch (r->last->tok) { |
case ROFF_am: |
case ROFF_am: |
/* ROFF_am1 is remapped to ROFF_am in roff_block(). */ |
|
case ROFF_ami: |
case ROFF_ami: |
case ROFF_de: |
case ROFF_de: |
/* ROFF_de1 is remapped to ROFF_de in roff_block(). */ |
|
case ROFF_dei: |
case ROFF_dei: |
case ROFF_ig: |
case ROFF_ig: |
break; |
break; |
|
case ROFF_am1: |
|
case ROFF_de1: |
|
/* Remapped in roff_block(). */ |
|
abort(); |
default: |
default: |
mandoc_msg(MANDOCERR_BLK_NOTOPEN, ln, ppos, ".."); |
mandoc_msg(MANDOCERR_BLK_NOTOPEN, ln, ppos, ".."); |
return ROFF_IGN; |
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') |
if (buf->buf[pos] != '\0') |
mandoc_msg(MANDOCERR_ARG_SKIP, ln, pos, |
mandoc_msg(MANDOCERR_ARG_SKIP, ln, pos, |
".. %s", buf->buf + pos); |
".. %s", buf->buf + pos); |
|
|
roffnode_pop(r); |
|
roffnode_cleanscope(r); |
|
return ROFF_IGN; |
return ROFF_IGN; |
|
|
} |
} |
|
|
|
/* |
|
* Pop all nodes ending at the end of the current input line. |
|
* Return the number of loops ended. |
|
*/ |
static int |
static int |
roffnode_cleanscope(struct roff *r) |
roffnode_cleanscope(struct roff *r) |
{ |
{ |
int inloop; |
int inloop; |
|
|
inloop = 0; |
inloop = 0; |
while (r->last != NULL) { |
while (r->last != NULL && r->last->endspan > 0) { |
if (--r->last->endspan != 0) |
if (--r->last->endspan != 0) |
break; |
break; |
inloop += roffnode_pop(r); |
inloop += roffnode_pop(r); |
Line 2016 roffnode_cleanscope(struct roff *r) |
|
Line 2110 roffnode_cleanscope(struct roff *r) |
|
return inloop; |
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 |
static int |
roff_ccond(struct roff *r, int ln, int ppos) |
roff_ccond(struct roff *r, int ln, int ppos) |
{ |
{ |
Line 2232 roff_block_text(ROFF_ARGS) |
|
Line 2331 roff_block_text(ROFF_ARGS) |
|
return ROFF_IGN; |
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 |
static int |
roff_cond_sub(ROFF_ARGS) |
roff_cond_checkend(ROFF_ARGS) |
{ |
{ |
char *ep; |
char *ep; |
int endloop, irc, rr; |
int endloop, irc, rr; |
enum roff_tok t; |
|
|
|
irc = ROFF_IGN; |
irc = ROFF_IGN; |
rr = r->last->rule; |
rr = r->last->rule; |
Line 2247 roff_cond_sub(ROFF_ARGS) |
|
Line 2354 roff_cond_sub(ROFF_ARGS) |
|
irc |= endloop; |
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; |
ep = buf->buf + pos; |
if (ep[0] == '\\' && ep[1] == '}') |
if (ep[0] == '\\' && ep[1] == '}' && (ep[2] == '\0' || *offs == 0)) |
rr = 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. |
* but is otherwise ignored when interpreting the line. |
*/ |
*/ |
|
|
while ((ep = strchr(ep, '\\')) != NULL) { |
while ((ep = strchr(ep, '\\')) != NULL) { |
switch (ep[1]) { |
switch (ep[1]) { |
case '}': |
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)) |
if (roff_ccond(r, ln, ep - buf->buf)) |
irc |= endloop; |
irc |= endloop; |
break; |
break; |
Line 2275 roff_cond_sub(ROFF_ARGS) |
|
Line 2387 roff_cond_sub(ROFF_ARGS) |
|
break; |
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; |
return irc; |
} |
} |
|
|
|
/* |
|
* Parse and process a request or macro line in conditional scope. |
|
*/ |
static int |
static int |
roff_cond_text(ROFF_ARGS) |
roff_cond_sub(ROFF_ARGS) |
{ |
{ |
char *ep; |
struct roffnode *bl; |
int endloop, irc, rr; |
int irc, rr; |
|
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 : |
t = roff_parse(r, buf->buf, &pos, ln, ppos); |
rr ? ROFF_LOOPCONT : ROFF_LOOPEXIT; |
|
if (roffnode_cleanscope(r)) |
|
irc |= endloop; |
|
|
|
/* |
/* For now, let high level macros abort .ce mode. */ |
* If `\}' occurs on a text line with neither preceding |
|
* nor following characters, drop the line completely. |
|
*/ |
|
|
|
ep = buf->buf + pos; |
if (roffce_node != NULL && |
if (strcmp(ep, "\\}") == 0) |
(t == TOKEN_NONE || t == ROFF_Dd || t == ROFF_EQ || |
rr = 0; |
t == ROFF_TH || t == ROFF_TS)) { |
|
r->man->last = roffce_node; |
|
r->man->next = ROFF_NEXT_SIBLING; |
|
roffce_lines = 0; |
|
roffce_node = NULL; |
|
} |
|
|
/* |
/* |
* The closing delimiter `\}' rewinds the conditional scope |
* Fully handle known macros when they are structurally |
* but is otherwise ignored when interpreting the line. |
* required or when the conditional evaluated to true. |
*/ |
*/ |
|
|
while ((ep = strchr(ep, '\\')) != NULL) { |
if (t == ROFF_break) { |
switch (ep[1]) { |
if (irc & ROFF_LOOPMASK) |
case '}': |
irc = ROFF_IGN | ROFF_LOOPEXIT; |
memmove(ep, ep + 2, strlen(ep + 2) + 1); |
else if (rr) { |
if (roff_ccond(r, ln, ep - buf->buf)) |
for (bl = r->last; bl != NULL; bl = bl->parent) { |
irc |= endloop; |
bl->rule = 0; |
break; |
if (bl->tok == ROFF_while) |
case '\0': |
break; |
++ep; |
} |
break; |
|
default: |
|
ep += 2; |
|
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; |
|
} |
|
|
|
/* |
|
* 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) |
if (rr) |
irc |= ROFF_CONT; |
irc |= ROFF_CONT; |
return irc; |
return irc; |
Line 3482 roff_als(ROFF_ARGS) |
|
Line 3601 roff_als(ROFF_ARGS) |
|
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
|
/* |
|
* The .break request only makes sense inside conditionals, |
|
* and that case is already handled in roff_cond_sub(). |
|
*/ |
static int |
static int |
|
roff_break(ROFF_ARGS) |
|
{ |
|
mandoc_msg(MANDOCERR_BLK_NOTOPEN, ln, pos, "break"); |
|
return ROFF_IGN; |
|
} |
|
|
|
static int |
roff_cc(ROFF_ARGS) |
roff_cc(ROFF_ARGS) |
{ |
{ |
const char *p; |
const char *p; |
Line 3804 roff_userdef(ROFF_ARGS) |
|
Line 3934 roff_userdef(ROFF_ARGS) |
|
char *arg, *ap, *dst, *src; |
char *arg, *ap, *dst, *src; |
size_t sz; |
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. */ |
/* Initialize a new macro stack context. */ |
|
|
if (++r->mstackpos == r->mstacksz) { |
if (++r->mstackpos == r->mstacksz) { |
Line 3851 roff_userdef(ROFF_ARGS) |
|
Line 3986 roff_userdef(ROFF_ARGS) |
|
buf->sz = strlen(buf->buf) + 1; |
buf->sz = strlen(buf->buf) + 1; |
*offs = 0; |
*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; |
ROFF_REPARSE | ROFF_USERCALL : ROFF_IGN | ROFF_APPEND; |
} |
} |
|
|