version 1.353, 2018/12/18 22:00:02 |
version 1.374, 2020/04/08 11:56:03 |
|
|
/* $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, 2018 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" |
|
|
|
|
#include "tbl_parse.h" |
#include "tbl_parse.h" |
#include "eqn_parse.h" |
#include "eqn_parse.h" |
|
|
|
/* |
|
* ASCII_ESC is used to signal from roff_getarg() to roff_expand() |
|
* that an escape sequence resulted from copy-in processing and |
|
* needs to be checked or interpolated. As it is used nowhere |
|
* else, it is defined here rather than in a header file. |
|
*/ |
|
#define ASCII_ESC 27 |
|
|
/* Maximum number of string expansions per line, to break infinite loops. */ |
/* Maximum number of string expansions per line, to break infinite loops. */ |
#define EXPAND_LIMIT 1000 |
#define EXPAND_LIMIT 1000 |
|
|
|
|
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 173 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_br(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); |
Line 185 static int roff_ds(ROFF_ARGS); |
|
Line 198 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, |
const char *, int *, int *, int); |
const char *, int *, int *, int); |
static int roff_evalstrcond(const char *, int *); |
static int roff_evalstrcond(const char *, int *); |
|
static int roff_expand(struct roff *, struct buf *, |
|
int, int, char); |
static void roff_free1(struct roff *); |
static void roff_free1(struct roff *); |
static void roff_freereg(struct roffreg *); |
static void roff_freereg(struct roffreg *); |
static void roff_freestr(struct roffkv *); |
static void roff_freestr(struct roffkv *); |
Line 211 static int roff_line_ignore(ROFF_ARGS); |
|
Line 226 static int roff_line_ignore(ROFF_ARGS); |
|
static void roff_man_alloc1(struct roff_man *); |
static void roff_man_alloc1(struct roff_man *); |
static void roff_man_free1(struct roff_man *); |
static void roff_man_free1(struct roff_man *); |
static int roff_manyarg(ROFF_ARGS); |
static int roff_manyarg(ROFF_ARGS); |
|
static int roff_noarg(ROFF_ARGS); |
static int roff_nop(ROFF_ARGS); |
static int roff_nop(ROFF_ARGS); |
static int roff_nr(ROFF_ARGS); |
static int roff_nr(ROFF_ARGS); |
static int roff_onearg(ROFF_ARGS); |
static int roff_onearg(ROFF_ARGS); |
Line 219 static enum roff_tok roff_parse(struct roff *, char * |
|
Line 235 static enum roff_tok roff_parse(struct roff *, char * |
|
static int roff_parsetext(struct roff *, struct buf *, |
static int roff_parsetext(struct roff *, struct buf *, |
int, int *); |
int, int *); |
static int roff_renamed(ROFF_ARGS); |
static int roff_renamed(ROFF_ARGS); |
static int roff_res(struct roff *, struct buf *, int, int); |
|
static int roff_return(ROFF_ARGS); |
static int roff_return(ROFF_ARGS); |
static int roff_rm(ROFF_ARGS); |
static int roff_rm(ROFF_ARGS); |
static int roff_rn(ROFF_ARGS); |
static int roff_rn(ROFF_ARGS); |
Line 248 static int roff_userdef(ROFF_ARGS); |
|
Line 263 static int roff_userdef(ROFF_ARGS); |
|
#define ROFFNUM_WHITE (1 << 1) /* Skip whitespace in roff_evalnum(). */ |
#define ROFFNUM_WHITE (1 << 1) /* Skip whitespace in roff_evalnum(). */ |
|
|
const char *__roff_name[MAN_MAX + 1] = { |
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, |
"ta", "ti", NULL, |
"ab", "ad", "af", "aln", |
"ab", "ad", "af", "aln", |
"als", "am", "am1", "ami", |
"als", "am", "am1", "ami", |
Line 341 const char *__roff_name[MAN_MAX + 1] = { |
|
Line 357 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", |
"HP", "SM", "SB", "BI", |
"HP", "SM", "SB", "BI", |
"IB", "BR", "RB", "R", |
"IB", "BR", "RB", "R", |
"B", "I", "IR", "RI", |
"B", "I", "IR", "RI", |
"nf", "fi", |
|
"RE", "RS", "DT", "UC", |
"RE", "RS", "DT", "UC", |
"PD", "AT", "in", |
"PD", "AT", "in", |
"SY", "YS", "OP", |
"SY", "YS", "OP", |
Line 358 const char *__roff_name[MAN_MAX + 1] = { |
|
Line 373 const char *__roff_name[MAN_MAX + 1] = { |
|
const char *const *roff_name = __roff_name; |
const char *const *roff_name = __roff_name; |
|
|
static struct roffmac roffs[TOKEN_NONE] = { |
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_onearg, NULL, NULL, 0 }, /* ce */ |
|
{ roff_noarg, NULL, NULL, 0 }, /* fi */ |
{ roff_onearg, NULL, NULL, 0 }, /* ft */ |
{ roff_onearg, NULL, NULL, 0 }, /* ft */ |
{ roff_onearg, NULL, NULL, 0 }, /* ll */ |
{ roff_onearg, NULL, NULL, 0 }, /* ll */ |
{ roff_onearg, NULL, NULL, 0 }, /* mc */ |
{ roff_onearg, NULL, NULL, 0 }, /* mc */ |
|
{ roff_noarg, NULL, NULL, 0 }, /* nf */ |
{ roff_onearg, NULL, NULL, 0 }, /* po */ |
{ roff_onearg, NULL, NULL, 0 }, /* po */ |
{ roff_onearg, NULL, NULL, 0 }, /* rj */ |
{ roff_onearg, NULL, NULL, 0 }, /* rj */ |
{ roff_onearg, NULL, NULL, 0 }, /* sp */ |
{ roff_onearg, NULL, NULL, 0 }, /* sp */ |
Line 389 static struct roffmac roffs[TOKEN_NONE] = { |
|
Line 406 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_br, NULL, NULL, 0 }, /* brp */ |
{ roff_noarg, NULL, NULL, 0 }, /* brp */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* brpnl */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* brpnl */ |
{ roff_unsupp, NULL, NULL, 0 }, /* c2 */ |
{ roff_unsupp, NULL, NULL, 0 }, /* c2 */ |
{ roff_cc, NULL, NULL, 0 }, /* cc */ |
{ roff_cc, NULL, NULL, 0 }, /* cc */ |
Line 674 roffhash_find(struct ohash *htab, const char *name, si |
|
Line 691 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 768 roff_reset(struct roff *r) |
|
Line 786 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 785 roff_alloc(int options) |
|
Line 803 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 798 roff_alloc(int options) |
|
Line 816 roff_alloc(int options) |
|
static void |
static void |
roff_man_free1(struct roff_man *man) |
roff_man_free1(struct roff_man *man) |
{ |
{ |
|
if (man->meta.first != NULL) |
if (man->first != NULL) |
roff_node_delete(man, man->meta.first); |
roff_node_delete(man, man->first); |
|
free(man->meta.msec); |
free(man->meta.msec); |
free(man->meta.vol); |
free(man->meta.vol); |
free(man->meta.os); |
free(man->meta.os); |
Line 808 roff_man_free1(struct roff_man *man) |
|
Line 825 roff_man_free1(struct roff_man *man) |
|
free(man->meta.title); |
free(man->meta.title); |
free(man->meta.name); |
free(man->meta.name); |
free(man->meta.date); |
free(man->meta.date); |
|
free(man->meta.sodest); |
} |
} |
|
|
static void |
void |
roff_man_alloc1(struct roff_man *man) |
roff_state_reset(struct roff_man *man) |
{ |
{ |
|
man->last = man->meta.first; |
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->last_es = NULL; |
man->flags = 0; |
man->flags = 0; |
man->macroset = MACROSET_NONE; |
|
man->lastsec = man->lastnamed = SEC_NONE; |
man->lastsec = man->lastnamed = SEC_NONE; |
man->next = ROFF_NEXT_CHILD; |
man->next = ROFF_NEXT_CHILD; |
|
roff_setreg(man->roff, "nS", 0, '='); |
} |
} |
|
|
|
static void |
|
roff_man_alloc1(struct roff_man *man) |
|
{ |
|
memset(&man->meta, 0, sizeof(man->meta)); |
|
man->meta.first = mandoc_calloc(1, sizeof(*man->meta.first)); |
|
man->meta.first->type = ROFFT_ROOT; |
|
man->meta.macroset = MACROSET_NONE; |
|
roff_state_reset(man); |
|
} |
|
|
void |
void |
roff_man_reset(struct roff_man *man) |
roff_man_reset(struct roff_man *man) |
{ |
{ |
|
|
roff_man_free1(man); |
roff_man_free1(man); |
roff_man_alloc1(man); |
roff_man_alloc1(man); |
} |
} |
Line 836 roff_man_reset(struct roff_man *man) |
|
Line 859 roff_man_reset(struct roff_man *man) |
|
void |
void |
roff_man_free(struct roff_man *man) |
roff_man_free(struct roff_man *man) |
{ |
{ |
|
|
roff_man_free1(man); |
roff_man_free1(man); |
free(man); |
free(man); |
} |
} |
Line 874 roff_node_alloc(struct roff_man *man, int line, int po |
|
Line 896 roff_node_alloc(struct roff_man *man, int line, int po |
|
n->flags |= NODE_SYNPRETTY; |
n->flags |= NODE_SYNPRETTY; |
else |
else |
n->flags &= ~NODE_SYNPRETTY; |
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) |
if (man->flags & MDOC_NEWLINE) |
n->flags |= NODE_LINE; |
n->flags |= NODE_LINE; |
man->flags &= ~MDOC_NEWLINE; |
man->flags &= ~MDOC_NEWLINE; |
Line 1011 roff_addtbl(struct roff_man *man, int line, struct tbl |
|
Line 1037 roff_addtbl(struct roff_man *man, int line, struct tbl |
|
struct roff_node *n; |
struct roff_node *n; |
struct tbl_span *span; |
struct tbl_span *span; |
|
|
if (man->macroset == MACROSET_MAN) |
if (man->meta.macroset == MACROSET_MAN) |
man_breakscope(man, ROFF_TS); |
man_breakscope(man, ROFF_TS); |
while ((span = tbl_span(tbl)) != NULL) { |
while ((span = tbl_span(tbl)) != NULL) { |
n = roff_node_alloc(man, line, 0, ROFFT_TBL, TOKEN_NONE); |
n = roff_node_alloc(man, line, 0, ROFFT_TBL, TOKEN_NONE); |
Line 1055 roff_node_unlink(struct roff_man *man, struct roff_nod |
|
Line 1081 roff_node_unlink(struct roff_man *man, struct roff_nod |
|
man->next = ROFF_NEXT_SIBLING; |
man->next = ROFF_NEXT_SIBLING; |
} |
} |
} |
} |
if (man->first == n) |
if (man->meta.first == n) |
man->first = NULL; |
man->meta.first = NULL; |
} |
} |
|
|
void |
void |
Line 1077 roff_node_free(struct roff_node *n) |
|
Line 1103 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 1090 roff_node_delete(struct roff_man *man, struct roff_nod |
|
Line 1117 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 1142 deroff(char **dest, const struct roff_node *n) |
|
Line 1228 deroff(char **dest, const struct roff_node *n) |
|
/* --- main functions of the roff parser ---------------------------------- */ |
/* --- main functions of the roff parser ---------------------------------- */ |
|
|
/* |
/* |
* In the current line, expand escape sequences that tend to get |
* In the current line, expand escape sequences that produce parsable |
* used in numerical expressions and conditional requests. |
* input text. Also check the syntax of the remaining escape sequences, |
* Also check the syntax of the remaining escape sequences. |
* which typically produce output glyphs or change formatter state. |
*/ |
*/ |
static int |
static int |
roff_res(struct roff *r, struct buf *buf, int ln, int pos) |
roff_expand(struct roff *r, struct buf *buf, int ln, int pos, char newesc) |
{ |
{ |
struct mctx *ctx; /* current macro call context */ |
struct mctx *ctx; /* current macro call context */ |
char ubuf[24]; /* buffer to print the number */ |
char ubuf[24]; /* buffer to print the number */ |
Line 1181 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
Line 1267 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
done = 0; |
done = 0; |
start = buf->buf + pos; |
start = buf->buf + pos; |
for (stesc = buf->buf + pos; *stesc != '\0'; stesc++) { |
for (stesc = buf->buf + pos; *stesc != '\0'; stesc++) { |
if (stesc[0] != r->escape || stesc[1] == '\0') |
if (stesc[0] != newesc || stesc[1] == '\0') |
continue; |
continue; |
stesc++; |
stesc++; |
if (*stesc != '"' && *stesc != '#') |
if (*stesc != '"' && *stesc != '#') |
Line 1223 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
Line 1309 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
* in the syntax tree. |
* in the syntax tree. |
*/ |
*/ |
|
|
if (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'; |
Line 1264 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
Line 1350 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
|
|
expand_count = 0; |
expand_count = 0; |
while (stesc >= start) { |
while (stesc >= start) { |
|
if (*stesc != newesc) { |
|
|
/* Search backwards for the next backslash. */ |
/* |
|
* If we have a non-standard escape character, |
|
* escape literal backslashes because all |
|
* processing in subsequent functions uses |
|
* the standard escaping rules. |
|
*/ |
|
|
if (*stesc != r->escape) { |
if (newesc != ASCII_ESC && *stesc == '\\') { |
if (*stesc == '\\') { |
|
*stesc = '\0'; |
*stesc = '\0'; |
buf->sz = mandoc_asprintf(&nbuf, "%s\\e%s", |
buf->sz = mandoc_asprintf(&nbuf, "%s\\e%s", |
buf->buf, stesc + 1) + 1; |
buf->buf, stesc + 1) + 1; |
Line 1277 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
Line 1368 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
free(buf->buf); |
free(buf->buf); |
buf->buf = nbuf; |
buf->buf = nbuf; |
} |
} |
|
|
|
/* Search backwards for the next escape. */ |
|
|
stesc--; |
stesc--; |
continue; |
continue; |
} |
} |
Line 1556 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
Line 1650 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
* or to the NUL byte terminating the argument line. |
* or to the NUL byte terminating the argument line. |
*/ |
*/ |
char * |
char * |
mandoc_getarg(char **cpp, int ln, int *pos) |
roff_getarg(struct roff *r, char **cpp, int ln, int *pos) |
{ |
{ |
char *start, *cp; |
struct buf buf; |
int quoted, pairs, white; |
char *cp, *start; |
|
int newesc, pairs, quoted, white; |
|
|
/* Quoting can only start with a new word. */ |
/* Quoting can only start with a new word. */ |
start = *cpp; |
start = *cpp; |
Line 1569 mandoc_getarg(char **cpp, int ln, int *pos) |
|
Line 1664 mandoc_getarg(char **cpp, int ln, int *pos) |
|
start++; |
start++; |
} |
} |
|
|
pairs = 0; |
newesc = pairs = white = 0; |
white = 0; |
|
for (cp = start; '\0' != *cp; cp++) { |
for (cp = start; '\0' != *cp; cp++) { |
|
|
/* |
/* |
Line 1588 mandoc_getarg(char **cpp, int ln, int *pos) |
|
Line 1682 mandoc_getarg(char **cpp, int ln, int *pos) |
|
switch (cp[1]) { |
switch (cp[1]) { |
case 'a': |
case 'a': |
case 't': |
case 't': |
cp[0] = '\t'; |
cp[-pairs] = '\t'; |
/* FALLTHROUGH */ |
pairs++; |
|
cp++; |
|
break; |
case '\\': |
case '\\': |
|
newesc = 1; |
|
cp[-pairs] = ASCII_ESC; |
pairs++; |
pairs++; |
cp++; |
cp++; |
break; |
break; |
Line 1639 mandoc_getarg(char **cpp, int ln, int *pos) |
|
Line 1737 mandoc_getarg(char **cpp, int ln, int *pos) |
|
if ('\0' == *cp && (white || ' ' == cp[-1])) |
if ('\0' == *cp && (white || ' ' == cp[-1])) |
mandoc_msg(MANDOCERR_SPACE_EOL, ln, *pos, NULL); |
mandoc_msg(MANDOCERR_SPACE_EOL, ln, *pos, NULL); |
|
|
return start; |
start = mandoc_strdup(start); |
|
if (newesc == 0) |
|
return start; |
|
|
|
buf.buf = start; |
|
buf.sz = strlen(start) + 1; |
|
buf.next = NULL; |
|
if (roff_expand(r, &buf, ln, 0, ASCII_ESC) & ROFF_IGN) { |
|
free(buf.buf); |
|
buf.buf = mandoc_strdup(""); |
|
} |
|
return buf.buf; |
} |
} |
|
|
|
|
Line 1737 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
Line 1846 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
|
|
/* Expand some escape sequences. */ |
/* Expand some escape sequences. */ |
|
|
e = roff_res(r, buf, ln, pos); |
e = roff_expand(r, buf, ln, pos, r->escape); |
if ((e & ROFF_MASK) == ROFF_IGN) |
if ((e & ROFF_MASK) == ROFF_IGN) |
return e; |
return e; |
assert(e == ROFF_CONT); |
assert(e == ROFF_CONT); |
Line 1769 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
Line 1878 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 1793 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
Line 1904 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 1960 roff_cblock(ROFF_ARGS) |
|
Line 2072 roff_cblock(ROFF_ARGS) |
|
|
|
} |
} |
|
|
|
/* |
|
* 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) |
{ |
{ |
Line 1974 roffnode_cleanscope(struct roff *r) |
|
Line 2090 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 2193 roff_block_text(ROFF_ARGS) |
|
Line 2314 roff_block_text(ROFF_ARGS) |
|
static int |
static int |
roff_cond_sub(ROFF_ARGS) |
roff_cond_sub(ROFF_ARGS) |
{ |
{ |
|
struct roffnode *bl; |
char *ep; |
char *ep; |
int endloop, irc, rr; |
int endloop, irc, rr; |
enum roff_tok t; |
enum roff_tok t; |
Line 2234 roff_cond_sub(ROFF_ARGS) |
|
Line 2356 roff_cond_sub(ROFF_ARGS) |
|
} |
} |
} |
} |
|
|
|
t = roff_parse(r, buf->buf, &pos, ln, ppos); |
|
|
|
/* For now, let high level macros abort .ce mode. */ |
|
|
|
if (roffce_node != NULL && |
|
(t == TOKEN_NONE || t == ROFF_Dd || t == ROFF_EQ || |
|
t == ROFF_TH || t == ROFF_TS)) { |
|
r->man->last = roffce_node; |
|
r->man->next = ROFF_NEXT_SIBLING; |
|
roffce_lines = 0; |
|
roffce_node = NULL; |
|
} |
|
|
/* |
/* |
* Fully handle known macros when they are structurally |
* Fully handle known macros when they are structurally |
* required or when the conditional evaluated to true. |
* required or when the conditional evaluated to true. |
*/ |
*/ |
|
|
t = roff_parse(r, buf->buf, &pos, ln, ppos); |
if (t == ROFF_break) { |
irc |= t != TOKEN_NONE && (rr || roffs[t].flags & ROFFMAC_STRUCT) ? |
if (irc & ROFF_LOOPMASK) |
(*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs) : |
irc = ROFF_IGN | ROFF_LOOPEXIT; |
rr ? ROFF_CONT : ROFF_IGN; |
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; |
return irc; |
} |
} |
|
|
Line 2495 roff_evalcond(struct roff *r, int ln, char *v, int *po |
|
Line 2641 roff_evalcond(struct roff *r, int ln, char *v, int *po |
|
roff_getstrn(r, name, sz, &deftype); |
roff_getstrn(r, name, sz, &deftype); |
istrue = !!deftype; |
istrue = !!deftype; |
} |
} |
*pos = cp - v; |
*pos = (name + sz) - v; |
return istrue == wanttrue; |
return istrue == wanttrue; |
default: |
default: |
break; |
break; |
Line 2641 roff_ds(ROFF_ARGS) |
|
Line 2787 roff_ds(ROFF_ARGS) |
|
return ROFF_IGN; |
return ROFF_IGN; |
|
|
namesz = roff_getname(r, &string, ln, pos); |
namesz = roff_getname(r, &string, ln, pos); |
if (name[namesz] == '\\') |
switch (name[namesz]) { |
|
case '\\': |
return ROFF_IGN; |
return ROFF_IGN; |
|
case '\t': |
|
string = buf->buf + pos + namesz; |
|
break; |
|
default: |
|
break; |
|
} |
|
|
/* Read past the initial double-quote, if any. */ |
/* Read past the initial double-quote, if any. */ |
if (*string == '"') |
if (*string == '"') |
Line 3018 roff_nr(ROFF_ARGS) |
|
Line 3171 roff_nr(ROFF_ARGS) |
|
return ROFF_IGN; |
return ROFF_IGN; |
|
|
keysz = roff_getname(r, &val, ln, pos); |
keysz = roff_getname(r, &val, ln, pos); |
if (key[keysz] == '\\') |
if (key[keysz] == '\\' || key[keysz] == '\t') |
return ROFF_IGN; |
return ROFF_IGN; |
|
|
sign = *val; |
sign = *val; |
Line 3082 roff_rm(ROFF_ARGS) |
|
Line 3235 roff_rm(ROFF_ARGS) |
|
namesz = roff_getname(r, &cp, ln, (int)(cp - buf->buf)); |
namesz = roff_getname(r, &cp, ln, (int)(cp - buf->buf)); |
roff_setstrn(&r->strtab, name, namesz, NULL, 0, 0); |
roff_setstrn(&r->strtab, name, namesz, NULL, 0, 0); |
roff_setstrn(&r->rentab, name, namesz, NULL, 0, 0); |
roff_setstrn(&r->rentab, name, namesz, NULL, 0, 0); |
if (name[namesz] == '\\') |
if (name[namesz] == '\\' || name[namesz] == '\t') |
break; |
break; |
} |
} |
return ROFF_IGN; |
return ROFF_IGN; |
Line 3150 roff_Dd(ROFF_ARGS) |
|
Line 3303 roff_Dd(ROFF_ARGS) |
|
static int |
static int |
roff_TE(ROFF_ARGS) |
roff_TE(ROFF_ARGS) |
{ |
{ |
|
r->man->flags &= ~ROFF_NONOFILL; |
if (r->tbl == NULL) { |
if (r->tbl == NULL) { |
mandoc_msg(MANDOCERR_BLK_NOTOPEN, ln, ppos, "TE"); |
mandoc_msg(MANDOCERR_BLK_NOTOPEN, ln, ppos, "TE"); |
return ROFF_IGN; |
return ROFF_IGN; |
Line 3249 roff_EQ(ROFF_ARGS) |
|
Line 3403 roff_EQ(ROFF_ARGS) |
|
{ |
{ |
struct roff_node *n; |
struct roff_node *n; |
|
|
if (r->man->macroset == MACROSET_MAN) |
if (r->man->meta.macroset == MACROSET_MAN) |
man_breakscope(r->man, ROFF_EQ); |
man_breakscope(r->man, ROFF_EQ); |
n = roff_node_alloc(r->man, ln, ppos, ROFFT_EQN, TOKEN_NONE); |
n = roff_node_alloc(r->man, ln, ppos, ROFFT_EQN, TOKEN_NONE); |
if (ln > r->man->last->line) |
if (ln > r->man->last->line) |
Line 3294 roff_TS(ROFF_ARGS) |
|
Line 3448 roff_TS(ROFF_ARGS) |
|
mandoc_msg(MANDOCERR_BLK_BROKEN, ln, ppos, "TS breaks TS"); |
mandoc_msg(MANDOCERR_BLK_BROKEN, ln, ppos, "TS breaks TS"); |
tbl_end(r->tbl, 0); |
tbl_end(r->tbl, 0); |
} |
} |
|
r->man->flags |= ROFF_NONOFILL; |
r->tbl = tbl_alloc(ppos, ln, r->last_tbl); |
r->tbl = tbl_alloc(ppos, ln, r->last_tbl); |
if (r->last_tbl == NULL) |
if (r->last_tbl == NULL) |
r->first_tbl = r->tbl; |
r->first_tbl = r->tbl; |
Line 3302 roff_TS(ROFF_ARGS) |
|
Line 3457 roff_TS(ROFF_ARGS) |
|
} |
} |
|
|
static int |
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) |
roff_onearg(ROFF_ARGS) |
{ |
{ |
struct roff_node *n; |
struct roff_node *n; |
Line 3395 roff_als(ROFF_ARGS) |
|
Line 3570 roff_als(ROFF_ARGS) |
|
return ROFF_IGN; |
return ROFF_IGN; |
|
|
newsz = roff_getname(r, &oldn, ln, pos); |
newsz = roff_getname(r, &oldn, ln, pos); |
if (newn[newsz] == '\\' || *oldn == '\0') |
if (newn[newsz] == '\\' || newn[newsz] == '\t' || *oldn == '\0') |
return ROFF_IGN; |
return ROFF_IGN; |
|
|
end = oldn; |
end = oldn; |
Line 3411 roff_als(ROFF_ARGS) |
|
Line 3586 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_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; |
return ROFF_IGN; |
} |
} |
|
|
Line 3639 roff_rn(ROFF_ARGS) |
|
Line 3811 roff_rn(ROFF_ARGS) |
|
return ROFF_IGN; |
return ROFF_IGN; |
|
|
oldsz = roff_getname(r, &newn, ln, pos); |
oldsz = roff_getname(r, &newn, ln, pos); |
if (oldn[oldsz] == '\\' || *newn == '\0') |
if (oldn[oldsz] == '\\' || oldn[oldsz] == '\t' || *newn == '\0') |
return ROFF_IGN; |
return ROFF_IGN; |
|
|
end = newn; |
end = newn; |
Line 3747 roff_userdef(ROFF_ARGS) |
|
Line 3919 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 3771 roff_userdef(ROFF_ARGS) |
|
Line 3948 roff_userdef(ROFF_ARGS) |
|
ctx->argv = mandoc_reallocarray(ctx->argv, |
ctx->argv = mandoc_reallocarray(ctx->argv, |
ctx->argsz, sizeof(*ctx->argv)); |
ctx->argsz, sizeof(*ctx->argv)); |
} |
} |
arg = mandoc_getarg(&src, ln, &pos); |
arg = roff_getarg(r, &src, ln, &pos); |
sz = 1; /* For the terminating NUL. */ |
sz = 1; /* For the terminating NUL. */ |
for (ap = arg; *ap != '\0'; ap++) |
for (ap = arg; *ap != '\0'; ap++) |
sz += *ap == '"' ? 4 : 1; |
sz += *ap == '"' ? 4 : 1; |
Line 3784 roff_userdef(ROFF_ARGS) |
|
Line 3961 roff_userdef(ROFF_ARGS) |
|
*dst++ = *ap; |
*dst++ = *ap; |
} |
} |
*dst = '\0'; |
*dst = '\0'; |
|
free(arg); |
} |
} |
|
|
/* Replace the macro invocation by the macro definition. */ |
/* Replace the macro invocation by the macro definition. */ |
Line 3793 roff_userdef(ROFF_ARGS) |
|
Line 3971 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; |
} |
} |
|
|
Line 3814 roff_renamed(ROFF_ARGS) |
|
Line 3992 roff_renamed(ROFF_ARGS) |
|
return ROFF_CONT; |
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 |
static size_t |
roff_getname(struct roff *r, char **cpp, int ln, int pos) |
roff_getname(struct roff *r, char **cpp, int ln, int pos) |
{ |
{ |
Line 3821 roff_getname(struct roff *r, char **cpp, int ln, int p |
|
Line 4003 roff_getname(struct roff *r, char **cpp, int ln, int p |
|
size_t namesz; |
size_t namesz; |
|
|
name = *cpp; |
name = *cpp; |
if ('\0' == *name) |
if (*name == '\0') |
return 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++) { |
for (cp = name; 1; cp++) { |
if ('\0' == *cp || ' ' == *cp) { |
namesz = cp - name; |
namesz = cp - name; |
if (*cp == '\0') |
break; |
break; |
|
if (*cp == ' ' || *cp == '\t') { |
|
cp++; |
|
break; |
} |
} |
if ('\\' != *cp) |
if (*cp != '\\') |
continue; |
continue; |
namesz = cp - name; |
if (cp[1] == '{' || cp[1] == '}') |
if ('{' == cp[1] || '}' == cp[1]) |
|
break; |
break; |
cp++; |
if (*++cp == '\\') |
if ('\\' == *cp) |
|
continue; |
continue; |
mandoc_msg(MANDOCERR_NAMESC, ln, pos, |
mandoc_msg(MANDOCERR_NAMESC, ln, pos, |
"%.*s", (int)(cp - name + 1), name); |
"%.*s", (int)(cp - name + 1), name); |
Line 3845 roff_getname(struct roff *r, char **cpp, int ln, int p |
|
Line 4029 roff_getname(struct roff *r, char **cpp, int ln, int p |
|
} |
} |
|
|
/* Read past spaces. */ |
/* Read past spaces. */ |
while (' ' == *cp) |
|
|
while (*cp == ' ') |
cp++; |
cp++; |
|
|
*cpp = cp; |
*cpp = cp; |
Line 3988 roff_getstrn(struct roff *r, const char *name, size_t |
|
Line 4173 roff_getstrn(struct roff *r, const char *name, size_t |
|
break; |
break; |
} |
} |
} |
} |
if (r->man->macroset != MACROSET_MAN) { |
if (r->man->meta.macroset != MACROSET_MAN) { |
for (tok = MDOC_Dd; tok < MDOC_MAX; tok++) { |
for (tok = MDOC_Dd; tok < MDOC_MAX; tok++) { |
if (strncmp(name, roff_name[tok], len) != 0 || |
if (strncmp(name, roff_name[tok], len) != 0 || |
roff_name[tok][len] != '\0') |
roff_name[tok][len] != '\0') |
Line 4002 roff_getstrn(struct roff *r, const char *name, size_t |
|
Line 4187 roff_getstrn(struct roff *r, const char *name, size_t |
|
} |
} |
} |
} |
} |
} |
if (r->man->macroset != MACROSET_MDOC) { |
if (r->man->meta.macroset != MACROSET_MDOC) { |
for (tok = MAN_TH; tok < MAN_MAX; tok++) { |
for (tok = MAN_TH; tok < MAN_MAX; tok++) { |
if (strncmp(name, roff_name[tok], len) != 0 || |
if (strncmp(name, roff_name[tok], len) != 0 || |
roff_name[tok][len] != '\0') |
roff_name[tok][len] != '\0') |
Line 4133 roff_strdup(const struct roff *r, const char *p) |
|
Line 4318 roff_strdup(const struct roff *r, const char *p) |
|
/* |
/* |
* We bail out on bad escapes. |
* We bail out on bad escapes. |
* No need to warn: we already did so when |
* No need to warn: we already did so when |
* roff_res() was called. |
* roff_expand() was called. |
*/ |
*/ |
sz = (int)(p - pp); |
sz = (int)(p - pp); |
res = mandoc_realloc(res, ssz + sz + 1); |
res = mandoc_realloc(res, ssz + sz + 1); |