version 1.347, 2018/12/13 03:40:13 |
version 1.388, 2022/05/19 15:37:47 |
|
|
/* $Id$ */ |
/* $Id$ */ |
/* |
/* |
|
* Copyright (c) 2010-2015, 2017-2022 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 "mandoc_ohash.h" |
#include "mandoc_ohash.h" |
#include "mandoc.h" |
#include "mandoc.h" |
#include "roff.h" |
#include "roff.h" |
|
#include "mandoc_parse.h" |
#include "libmandoc.h" |
#include "libmandoc.h" |
#include "roff_int.h" |
#include "roff_int.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 |
|
|
|
|
}; |
}; |
|
|
struct roff { |
struct roff { |
struct mparse *parse; /* parse point */ |
|
struct roff_man *man; /* mdoc or man parser */ |
struct roff_man *man; /* mdoc or man parser */ |
struct roffnode *last; /* leaf of stack */ |
struct roffnode *last; /* leaf of stack */ |
struct mctx *mstack; /* stack of macro contexts */ |
struct mctx *mstack; /* stack of macro contexts */ |
|
|
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); |
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, |
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_expand_patch(struct buf *, int, |
|
const char *, int); |
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 229 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_mc(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); |
static enum roff_tok roff_parse(struct roff *, char *, int *, |
static enum roff_tok roff_parse(struct roff *, char *, int *, |
int, int); |
int, int); |
|
static int roff_parse_comment(struct roff *, struct buf *, |
|
int, int, 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_req_or_macro(ROFF_ARGS); |
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 270 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 364 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 380 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_mc, 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 413 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 698 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 793 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 779 roff_free(struct roff *r) |
|
Line 804 roff_free(struct roff *r) |
|
} |
} |
|
|
struct roff * |
struct roff * |
roff_alloc(struct mparse *parse, int options) |
roff_alloc(int options) |
{ |
{ |
struct roff *r; |
struct roff *r; |
|
|
r = mandoc_calloc(1, sizeof(struct roff)); |
r = mandoc_calloc(1, sizeof(struct roff)); |
r->parse = parse; |
|
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 799 roff_alloc(struct mparse *parse, int options) |
|
Line 823 roff_alloc(struct mparse *parse, 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 809 roff_man_free1(struct roff_man *man) |
|
Line 832 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 837 roff_man_reset(struct roff_man *man) |
|
Line 866 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->os_r); |
free(man); |
free(man); |
} |
} |
|
|
struct roff_man * |
struct roff_man * |
roff_man_alloc(struct roff *roff, struct mparse *parse, |
roff_man_alloc(struct roff *roff, const char *os_s, int quick) |
const char *os_s, int quick) |
|
{ |
{ |
struct roff_man *man; |
struct roff_man *man; |
|
|
man = mandoc_calloc(1, sizeof(*man)); |
man = mandoc_calloc(1, sizeof(*man)); |
man->parse = parse; |
|
man->roff = roff; |
man->roff = roff; |
man->os_s = os_s; |
man->os_s = os_s; |
man->quick = quick; |
man->quick = quick; |
Line 877 roff_node_alloc(struct roff_man *man, int line, int po |
|
Line 904 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 1014 roff_addtbl(struct roff_man *man, int line, struct tbl |
|
Line 1045 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 1058 roff_node_unlink(struct roff_man *man, struct roff_nod |
|
Line 1089 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 1080 roff_node_free(struct roff_node *n) |
|
Line 1111 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 1093 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); |
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 1145 deroff(char **dest, const struct roff_node *n) |
|
Line 1236 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 |
* Save comments preceding the title macro, for example in order to |
* used in numerical expressions and conditional requests. |
* preserve Copyright and license headers in HTML output, |
* Also check the syntax of the remaining escape sequences. |
* 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 |
static int |
roff_res(struct roff *r, struct buf *buf, int ln, int pos) |
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 */ |
struct roff_node *n; /* used for header comments */ |
const char *start; /* start of the string to process */ |
const char *start; /* start of the string to process */ |
|
const char *cp; /* for RCS id parsing */ |
char *stesc; /* start of an escape sequence ('\\') */ |
char *stesc; /* start of an escape sequence ('\\') */ |
char *ep; /* end of comment string */ |
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 */ |
|
enum mandoc_esc esc; /* type of the escape sequence */ |
|
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 */ |
int rcsid; /* kind of RCS id seen */ |
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] != r->escape || 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, r->parse, |
|
ln, stesc + 1 - buf->buf, 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, r->parse, |
|
ln, 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 (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; |
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) { |
|
|
|
/* Search backwards for the next backslash. */ |
ep = strchr(stesc + 2, '\0') - 1; |
|
if (*ep == '\n') |
|
*ep-- = '\0'; |
|
if (*ep == ' ' || *ep == '\t') |
|
mandoc_msg(MANDOCERR_SPACE_EOL, |
|
ln, (int)(ep - buf->buf), NULL); |
|
|
if (*stesc != r->escape) { |
/* Save comments preceding the title macro in the syntax tree. */ |
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. */ |
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; |
|
} |
|
|
for (cp = stesc - 1; cp >= start; cp--) |
/* The comment requests line continuation. */ |
if (*cp != r->escape) |
|
break; |
|
|
|
if ((stesc - cp) % 2 == 0) { |
if (stesc[1] == '#') { |
while (stesc > cp) |
*stesc = '\0'; |
*stesc-- = '\\'; |
return ROFF_IGN | ROFF_APPEND; |
continue; |
} |
} else if (stesc[1] != '\0') { |
|
*stesc = '\\'; |
|
} else { |
|
*stesc-- = '\0'; |
|
if (done) |
|
continue; |
|
else |
|
return ROFF_IGN | ROFF_APPEND; |
|
} |
|
|
|
/* Decide whether to expand or to check only. */ |
/* Discard the comment including preceding whitespace. */ |
|
|
term = '\0'; |
while (stesc > start && stesc[-1] == ' ' && |
cp = stesc + 1; |
(stesc == start + 1 || stesc[-2] != '\\')) |
switch (*cp) { |
stesc--; |
case '*': |
*stesc = '\0'; |
case '$': |
return ROFF_CONT; |
res = NULL; |
} |
break; |
|
case 'B': |
|
case 'w': |
|
term = cp[1]; |
|
/* FALLTHROUGH */ |
|
case 'n': |
|
sign = cp[1]; |
|
if (sign == '+' || sign == '-') |
|
cp++; |
|
res = ubuf; |
|
break; |
|
default: |
|
esc = mandoc_escape(&cp, &stnam, &inaml); |
|
if (esc == ESCAPE_ERROR || |
|
(esc == ESCAPE_SPECIAL && |
|
mchars_spec2cp(stnam, inaml) < 0)) |
|
mandoc_vmsg(MANDOCERR_ESC_BAD, |
|
r->parse, ln, (int)(stesc - buf->buf), |
|
"%.*s", (int)(cp - stesc), stesc); |
|
stesc--; |
|
continue; |
|
} |
|
|
|
if (EXPAND_LIMIT < ++expand_count) { |
/* |
mandoc_msg(MANDOCERR_ROFFLOOP, r->parse, |
* In the current line, expand escape sequences that produce parsable |
ln, (int)(stesc - buf->buf), NULL); |
* input text. Also check the syntax of the remaining escape sequences, |
return ROFF_IGN; |
* 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 */ |
|
|
|
expand_count = 0; |
|
while (buf->buf[pos] != '\0') { |
|
|
/* |
/* |
* The third character decides the length |
* Skip plain ASCII characters. |
* of the name of the string or register. |
* If we have a non-standard escape character, |
* Save a pointer to the name. |
* escape literal backslashes because all processing in |
|
* subsequent functions uses the standard escaping rules. |
*/ |
*/ |
|
|
if (term == '\0') { |
if (buf->buf[pos] != ec) { |
switch (*++cp) { |
if (ec != ASCII_ESC && buf->buf[pos] == '\\') { |
case '\0': |
roff_expand_patch(buf, pos, "\\e", pos + 1); |
maxl = 0; |
pos++; |
break; |
|
case '(': |
|
cp++; |
|
maxl = 2; |
|
break; |
|
case '[': |
|
cp++; |
|
term = ']'; |
|
maxl = 0; |
|
break; |
|
default: |
|
maxl = 1; |
|
break; |
|
} |
} |
} else { |
pos++; |
cp += 2; |
continue; |
maxl = 0; |
|
} |
} |
stnam = cp; |
|
|
|
/* Advance to the end of the name. */ |
/* |
|
* Parse escape sequences, |
|
* issue diagnostic messages when appropriate, |
|
* 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. |
|
*/ |
|
|
naml = 0; |
if (roff_escape(buf->buf, ln, pos, |
arg_complete = 1; |
&iesc, &iarg, &iendarg, &iend) != ESCAPE_EXPAND) { |
while (maxl == 0 || naml < maxl) { |
while (pos < iend) { |
if (*cp == '\0') { |
if (buf->buf[pos] == ec) { |
mandoc_msg(MANDOCERR_ESC_BAD, r->parse, |
buf->buf[pos] = '\\'; |
ln, (int)(stesc - buf->buf), stesc); |
if (pos + 1 < iend) |
arg_complete = 0; |
pos++; |
break; |
} else if (buf->buf[pos] == '\\') { |
|
roff_expand_patch(buf, |
|
pos, "\\e", pos + 1); |
|
pos++; |
|
iend++; |
|
} |
|
pos++; |
} |
} |
if (maxl == 0 && *cp == term) { |
continue; |
cp++; |
|
break; |
|
} |
|
if (*cp++ != '\\' || stesc[1] != 'w') { |
|
naml++; |
|
continue; |
|
} |
|
switch (mandoc_escape(&cp, NULL, NULL)) { |
|
case ESCAPE_SPECIAL: |
|
case ESCAPE_UNICODE: |
|
case ESCAPE_NUMBERED: |
|
case ESCAPE_OVERSTRIKE: |
|
naml++; |
|
break; |
|
default: |
|
break; |
|
} |
|
} |
} |
|
|
/* |
/* |
* Retrieve the replacement string; if it is |
* Treat "\E" just like "\"; |
* undefined, resume searching for escapes. |
* it only makes a difference in copy mode. |
*/ |
*/ |
|
|
switch (stesc[1]) { |
inam = iesc + 1; |
|
while (buf->buf[inam] == 'E') |
|
inam++; |
|
|
|
/* Handle expansion. */ |
|
|
|
res = NULL; |
|
switch (buf->buf[inam]) { |
case '*': |
case '*': |
if (arg_complete) { |
if (iendarg == iarg) |
deftype = ROFFDEF_USER | ROFFDEF_PRE; |
break; |
res = roff_getstrn(r, stnam, naml, &deftype); |
deftype = ROFFDEF_USER | ROFFDEF_PRE; |
|
if ((res = roff_getstrn(r, buf->buf + iarg, |
|
iendarg - iarg, &deftype)) != NULL) |
|
break; |
|
|
/* |
/* |
* If not overriden, let \*(.T |
* If not overriden, |
* through to the formatters. |
* let \*(.T through to the formatters. |
*/ |
*/ |
|
|
if (res == NULL && naml == 2 && |
if (iendarg - iarg == 2 && |
stnam[0] == '.' && stnam[1] == 'T') { |
buf->buf[iarg] == '.' && |
roff_setstrn(&r->strtab, |
buf->buf[iarg + 1] == 'T') { |
".T", 2, NULL, 0, 0); |
roff_setstrn(&r->strtab, ".T", 2, NULL, 0, 0); |
stesc--; |
pos = iend; |
continue; |
continue; |
} |
|
} |
} |
|
|
|
mandoc_msg(MANDOCERR_STR_UNDEF, ln, iesc, |
|
"%.*s", iendarg - iarg, buf->buf + iarg); |
break; |
break; |
|
|
case '$': |
case '$': |
if (r->mstackpos < 0) { |
if (r->mstackpos < 0) { |
mandoc_vmsg(MANDOCERR_ARG_UNDEF, |
mandoc_msg(MANDOCERR_ARG_UNDEF, ln, iesc, |
r->parse, ln, (int)(stesc - buf->buf), |
"%.*s", iend - iesc, buf->buf + iesc); |
"%.3s", stesc); |
|
break; |
break; |
} |
} |
ctx = r->mstack + r->mstackpos; |
ctx = r->mstack + r->mstackpos; |
npos = stesc[2] - '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; |
break; |
} |
} |
if (stesc[2] == '*') |
if (buf->buf[iarg] == '*') |
quote_args = 0; |
quote_args = 0; |
else if (stesc[2] == '@') |
else if (buf->buf[iarg] == '@') |
quote_args = 1; |
quote_args = 1; |
else { |
else { |
mandoc_vmsg(MANDOCERR_ARG_NONUM, |
mandoc_msg(MANDOCERR_ARG_NONUM, ln, iesc, |
r->parse, ln, (int)(stesc - buf->buf), |
"%.*s", iend - iesc, buf->buf + iesc); |
"%.3s", stesc); |
|
break; |
break; |
} |
} |
asz = 0; |
asz = 0; |
for (npos = 0; npos < ctx->argc; npos++) { |
for (argi = 0; argi < ctx->argc; argi++) { |
if (npos) |
if (argi) |
asz++; /* blank */ |
asz++; /* blank */ |
if (quote_args) |
if (quote_args) |
asz += 2; /* quotes */ |
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) |
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) |
if (quote_args) |
*stesc++ = '"'; |
*dst++ = '"'; |
} |
} |
continue; |
continue; |
case 'B': |
case 'B': |
npos = 0; |
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) && |
NULL, ROFFNUM_SCALE) && |
stnam + npos + 1 == cp ? '1' : '0'; |
npos == iendarg - iarg ? '1' : '0'; |
ubuf[1] = '\0'; |
ubuf[1] = '\0'; |
|
res = ubuf; |
break; |
break; |
case 'n': |
case 'n': |
if (arg_complete) |
if (iendarg > iarg) |
(void)snprintf(ubuf, sizeof(ubuf), "%d", |
(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 |
else |
ubuf[0] = '\0'; |
ubuf[0] = '\0'; |
|
res = ubuf; |
break; |
break; |
case 'w': |
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; |
break; |
|
default: |
|
break; |
} |
} |
|
if (res == NULL) |
if (res == NULL) { |
|
if (stesc[1] == '*') |
|
mandoc_vmsg(MANDOCERR_STR_UNDEF, |
|
r->parse, ln, (int)(stesc - buf->buf), |
|
"%.*s", (int)naml, stnam); |
|
res = ""; |
res = ""; |
} else if (buf->sz + strlen(res) > SHRT_MAX) { |
if (++expand_count > EXPAND_LIMIT || |
mandoc_msg(MANDOCERR_ROFFLOOP, r->parse, |
buf->sz + strlen(res) > SHRT_MAX) { |
ln, (int)(stesc - buf->buf), NULL); |
mandoc_msg(MANDOCERR_ROFFLOOP, ln, iesc, NULL); |
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
roff_expand_patch(buf, iesc, res, iend); |
|
} |
|
return ROFF_CONT; |
|
} |
|
|
/* Replace the escape sequence by the string. */ |
/* |
|
* 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; |
|
|
*stesc = '\0'; |
buf->buf[start] = '\0'; |
buf->sz = mandoc_asprintf(&nbuf, "%s%s%s", |
buf->sz = mandoc_asprintf(&nbuf, "%s%s%s", buf->buf, repl, |
buf->buf, res, cp) + 1; |
buf->buf + end) + 1; |
|
free(buf->buf); |
|
buf->buf = nbuf; |
|
} |
|
|
/* Prepare for the next replacement. */ |
/* |
|
* 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. |
|
* NUL-terminate the argument in place. |
|
* Collapse pairs of quotes inside quoted arguments. |
|
* Advance the argument pointer to the next argument, |
|
* or to the NUL byte terminating the argument line. |
|
*/ |
|
char * |
|
roff_getarg(struct roff *r, char **cpp, int ln, int *pos) |
|
{ |
|
struct buf buf; |
|
char *cp, *start; |
|
int newesc, pairs, quoted, white; |
|
|
start = nbuf + pos; |
/* Quoting can only start with a new word. */ |
stesc = nbuf + (stesc - buf->buf) + strlen(res); |
start = *cpp; |
free(buf->buf); |
quoted = 0; |
buf->buf = nbuf; |
if ('"' == *start) { |
|
quoted = 1; |
|
start++; |
} |
} |
return ROFF_CONT; |
|
|
newesc = pairs = white = 0; |
|
for (cp = start; '\0' != *cp; cp++) { |
|
|
|
/* |
|
* Move the following text left |
|
* after quoted quotes and after "\\" and "\t". |
|
*/ |
|
if (pairs) |
|
cp[-pairs] = cp[0]; |
|
|
|
if ('\\' == cp[0]) { |
|
/* |
|
* In copy mode, translate double to single |
|
* backslashes and backslash-t to literal tabs. |
|
*/ |
|
switch (cp[1]) { |
|
case 'a': |
|
case 't': |
|
cp[-pairs] = '\t'; |
|
pairs++; |
|
cp++; |
|
break; |
|
case '\\': |
|
newesc = 1; |
|
cp[-pairs] = ASCII_ESC; |
|
pairs++; |
|
cp++; |
|
break; |
|
case ' ': |
|
/* Skip escaped blanks. */ |
|
if (0 == quoted) |
|
cp++; |
|
break; |
|
default: |
|
break; |
|
} |
|
} else if (0 == quoted) { |
|
if (' ' == cp[0]) { |
|
/* Unescaped blanks end unquoted args. */ |
|
white = 1; |
|
break; |
|
} |
|
} else if ('"' == cp[0]) { |
|
if ('"' == cp[1]) { |
|
/* Quoted quotes collapse. */ |
|
pairs++; |
|
cp++; |
|
} else { |
|
/* Unquoted quotes end quoted args. */ |
|
quoted = 2; |
|
break; |
|
} |
|
} |
|
} |
|
|
|
/* Quoted argument without a closing quote. */ |
|
if (1 == quoted) |
|
mandoc_msg(MANDOCERR_ARG_QUOTE, ln, *pos, NULL); |
|
|
|
/* NUL-terminate this argument and move to the next one. */ |
|
if (pairs) |
|
cp[-pairs] = '\0'; |
|
if ('\0' != *cp) { |
|
*cp++ = '\0'; |
|
while (' ' == *cp) |
|
cp++; |
|
} |
|
*pos += (int)(cp - start) + (quoted ? 1 : 0); |
|
*cpp = cp; |
|
|
|
if ('\0' == *cp && (white || ' ' == cp[-1])) |
|
mandoc_msg(MANDOCERR_SPACE_EOL, ln, *pos, NULL); |
|
|
|
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; |
} |
} |
|
|
|
|
/* |
/* |
* Process text streams. |
* Process text streams. |
*/ |
*/ |
Line 1601 roff_parsetext(struct roff *r, struct buf *buf, int po |
|
Line 1756 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 1612 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
Line 1767 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 1623 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
Line 1786 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
assert(e == ROFF_CONT); |
assert(e == ROFF_CONT); |
} |
} |
|
|
/* Expand some escape sequences. */ |
/* Handle comments and escape sequences. */ |
|
|
e = roff_res(r, buf, ln, pos); |
e = roff_parse_comment(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); |
|
|
|
e = roff_expand(r, buf, ln, pos, r->escape); |
|
if ((e & ROFF_MASK) == ROFF_IGN) |
|
return e; |
|
assert(e == ROFF_CONT); |
|
|
ctl = roff_getcontrol(r, buf->buf, &pos); |
ctl = roff_getcontrol(r, buf->buf, &pos); |
|
|
/* |
/* |
Line 1657 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
Line 1825 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. */ |
|
|
if (buf->buf[pos] == '"') { |
if (buf->buf[pos] == '"') { |
mandoc_msg(MANDOCERR_COMMENT_BAD, r->parse, |
mandoc_msg(MANDOCERR_COMMENT_BAD, ln, pos, NULL); |
ln, pos, NULL); |
|
return ROFF_IGN; |
return ROFF_IGN; |
} else if (buf->buf[pos] == '\0') |
} else if (buf->buf[pos] == '\0') |
return ROFF_IGN; |
return ROFF_IGN; |
Line 1672 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
Line 1841 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
/* |
/* |
* If a scope is open, go to the child handler for that macro, |
* If a scope is open, go to the child handler for that macro, |
* as it may want to preprocess before doing anything with it. |
* as it may want to preprocess before doing anything with it. |
* Don't do so if an equation is open. |
|
*/ |
*/ |
|
|
if (r->last) { |
if (r->last) { |
Line 1680 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
Line 1848 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
return (*roffs[t].sub)(r, t, buf, ln, ppos, pos, offs); |
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; |
spos = pos; |
t = roff_parse(r, buf->buf, &pos, ln, ppos); |
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)) { |
|
mandoc_msg(MANDOCERR_TBLMACRO, r->parse, |
if (r->tbl != NULL && (tok == TOKEN_NONE || tok == ROFF_TS || |
ln, pos, buf->buf + spos); |
tok == ROFF_br || tok == ROFF_ce || tok == ROFF_rj || |
if (t != TOKEN_NONE) |
tok == ROFF_sp)) { |
|
mandoc_msg(MANDOCERR_TBLMACRO, |
|
ln, ppos, "%s", buf->buf + ppos); |
|
if (tok != TOKEN_NONE) |
return ROFF_IGN; |
return ROFF_IGN; |
while (buf->buf[pos] != '\0' && buf->buf[pos] != ' ') |
while (buf->buf[pos] != '\0' && buf->buf[pos] != ' ') |
pos++; |
pos++; |
Line 1704 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
Line 1881 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
|
|
/* For now, let high level macros abort .ce mode. */ |
/* 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->last = roffce_node; |
r->man->next = ROFF_NEXT_SIBLING; |
r->man->next = ROFF_NEXT_SIBLING; |
roffce_lines = 0; |
roffce_lines = 0; |
Line 1718 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
Line 1895 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
* Let the standard macro set parsers handle it. |
* Let the standard macro set parsers handle it. |
*/ |
*/ |
|
|
if (t == TOKEN_NONE) |
if (tok == TOKEN_NONE) |
return ROFF_CONT; |
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); |
} |
} |
|
|
/* |
/* |
|
|
roff_endparse(struct roff *r) |
roff_endparse(struct roff *r) |
{ |
{ |
if (r->last != NULL) |
if (r->last != NULL) |
mandoc_msg(MANDOCERR_BLK_NOEND, r->parse, |
mandoc_msg(MANDOCERR_BLK_NOEND, r->last->line, |
r->last->line, r->last->col, |
r->last->col, "%s", roff_name[r->last->tok]); |
roff_name[r->last->tok]); |
|
|
|
if (r->eqn != NULL) { |
if (r->eqn != NULL) { |
mandoc_msg(MANDOCERR_BLK_NOEND, r->parse, |
mandoc_msg(MANDOCERR_BLK_NOEND, |
r->eqn->node->line, r->eqn->node->pos, "EQ"); |
r->eqn->node->line, r->eqn->node->pos, "EQ"); |
eqn_parse(r->eqn); |
eqn_parse(r->eqn); |
r->eqn = NULL; |
r->eqn = NULL; |
Line 1767 roff_endparse(struct roff *r) |
|
Line 1943 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 |
static enum roff_tok |
roff_parse(struct roff *r, char *buf, int *pos, int ln, int ppos) |
roff_parse(struct roff *r, char *buf, int *pos, int ln, int ppos) |
Line 1812 roff_parse(struct roff *r, char *buf, int *pos, int ln |
|
Line 1990 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, r->parse, |
mandoc_msg(MANDOCERR_BLK_NOTOPEN, ln, ppos, ".."); |
ln, ppos, ".."); |
|
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
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, r->parse, |
mandoc_msg(MANDOCERR_BLK_NOTOPEN, ln, ppos, ".."); |
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_vmsg(MANDOCERR_ARG_SKIP, r->parse, 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 1866 roffnode_cleanscope(struct roff *r) |
|
Line 2057 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) |
{ |
{ |
if (NULL == r->last) { |
if (NULL == r->last) { |
mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse, |
mandoc_msg(MANDOCERR_BLK_NOTOPEN, ln, ppos, "\\}"); |
ln, ppos, "\\}"); |
|
return 0; |
return 0; |
} |
} |
|
|
Line 1882 roff_ccond(struct roff *r, int ln, int ppos) |
|
Line 2077 roff_ccond(struct roff *r, int ln, int ppos) |
|
case ROFF_while: |
case ROFF_while: |
break; |
break; |
default: |
default: |
mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse, |
mandoc_msg(MANDOCERR_BLK_NOTOPEN, ln, ppos, "\\}"); |
ln, ppos, "\\}"); |
|
return 0; |
return 0; |
} |
} |
|
|
if (r->last->endspan > -1) { |
if (r->last->endspan > -1) { |
mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse, |
mandoc_msg(MANDOCERR_BLK_NOTOPEN, ln, ppos, "\\}"); |
ln, ppos, "\\}"); |
|
return 0; |
return 0; |
} |
} |
|
|
Line 1933 roff_block(ROFF_ARGS) |
|
Line 2126 roff_block(ROFF_ARGS) |
|
deftype = ROFFDEF_USER; |
deftype = ROFFDEF_USER; |
name = roff_getstrn(r, iname, namesz, &deftype); |
name = roff_getstrn(r, iname, namesz, &deftype); |
if (name == NULL) { |
if (name == NULL) { |
mandoc_vmsg(MANDOCERR_STR_UNDEF, |
mandoc_msg(MANDOCERR_STR_UNDEF, |
r->parse, ln, (int)(iname - buf->buf), |
ln, (int)(iname - buf->buf), |
"%.*s", (int)namesz, iname); |
"%.*s", (int)namesz, iname); |
namesz = 0; |
namesz = 0; |
} else |
} else |
Line 1943 roff_block(ROFF_ARGS) |
|
Line 2136 roff_block(ROFF_ARGS) |
|
name = iname; |
name = iname; |
|
|
if (namesz == 0 && tok != ROFF_ig) { |
if (namesz == 0 && tok != ROFF_ig) { |
mandoc_msg(MANDOCERR_REQ_EMPTY, r->parse, |
mandoc_msg(MANDOCERR_REQ_EMPTY, |
ln, ppos, roff_name[tok]); |
ln, ppos, "%s", roff_name[tok]); |
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
Line 2002 roff_block(ROFF_ARGS) |
|
Line 2195 roff_block(ROFF_ARGS) |
|
deftype = ROFFDEF_USER; |
deftype = ROFFDEF_USER; |
name = roff_getstrn(r, iname, namesz, &deftype); |
name = roff_getstrn(r, iname, namesz, &deftype); |
if (name == NULL) { |
if (name == NULL) { |
mandoc_vmsg(MANDOCERR_STR_UNDEF, |
mandoc_msg(MANDOCERR_STR_UNDEF, |
r->parse, ln, (int)(iname - buf->buf), |
ln, (int)(iname - buf->buf), |
"%.*s", (int)namesz, iname); |
"%.*s", (int)namesz, iname); |
namesz = 0; |
namesz = 0; |
} else |
} else |
Line 2015 roff_block(ROFF_ARGS) |
|
Line 2208 roff_block(ROFF_ARGS) |
|
r->last->end = mandoc_strndup(name, namesz); |
r->last->end = mandoc_strndup(name, namesz); |
|
|
if (*cp != '\0') |
if (*cp != '\0') |
mandoc_vmsg(MANDOCERR_ARG_EXCESS, r->parse, |
mandoc_msg(MANDOCERR_ARG_EXCESS, |
ln, pos, ".%s ... %s", roff_name[tok], cp); |
ln, pos, ".%s ... %s", roff_name[tok], cp); |
|
|
return ROFF_IGN; |
return ROFF_IGN; |
Line 2028 roff_block_sub(ROFF_ARGS) |
|
Line 2221 roff_block_sub(ROFF_ARGS) |
|
int i, j; |
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) { |
if (r->last->end) { |
Line 2059 roff_block_sub(ROFF_ARGS) |
|
Line 2248 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); |
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 |
static int |
Line 2085 roff_block_text(ROFF_ARGS) |
|
Line 2271 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 2100 roff_cond_sub(ROFF_ARGS) |
|
Line 2294 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 2128 roff_cond_sub(ROFF_ARGS) |
|
Line 2327 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, 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) |
if (rr) |
irc |= ROFF_CONT; |
irc |= ROFF_CONT; |
return irc; |
return irc; |
Line 2390 roff_evalcond(struct roff *r, int ln, char *v, int *po |
|
Line 2587 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; |
|
|
roff_insec(ROFF_ARGS) |
roff_insec(ROFF_ARGS) |
{ |
{ |
|
|
mandoc_msg(MANDOCERR_REQ_INSEC, r->parse, |
mandoc_msg(MANDOCERR_REQ_INSEC, ln, ppos, "%s", roff_name[tok]); |
ln, ppos, roff_name[tok]); |
|
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
|
|
roff_unsupp(ROFF_ARGS) |
roff_unsupp(ROFF_ARGS) |
{ |
{ |
|
|
mandoc_msg(MANDOCERR_REQ_UNSUPP, r->parse, |
mandoc_msg(MANDOCERR_REQ_UNSUPP, ln, ppos, "%s", roff_name[tok]); |
ln, ppos, roff_name[tok]); |
|
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
Line 2500 roff_cond(ROFF_ARGS) |
|
Line 2695 roff_cond(ROFF_ARGS) |
|
*/ |
*/ |
|
|
if (buf->buf[pos] == '\0') |
if (buf->buf[pos] == '\0') |
mandoc_msg(MANDOCERR_COND_EMPTY, r->parse, |
mandoc_msg(MANDOCERR_COND_EMPTY, |
ln, ppos, roff_name[tok]); |
ln, ppos, "%s", roff_name[tok]); |
|
|
r->last->endspan = 1; |
r->last->endspan = 1; |
|
|
Line 2538 roff_ds(ROFF_ARGS) |
|
Line 2733 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 2704 roff_evalnum(struct roff *r, int ln, const char *v, |
|
Line 2906 roff_evalnum(struct roff *r, int ln, const char *v, |
|
case '/': |
case '/': |
if (operand2 == 0) { |
if (operand2 == 0) { |
mandoc_msg(MANDOCERR_DIVZERO, |
mandoc_msg(MANDOCERR_DIVZERO, |
r->parse, ln, *pos, v); |
ln, *pos, "%s", v); |
*res = 0; |
*res = 0; |
break; |
break; |
} |
} |
Line 2713 roff_evalnum(struct roff *r, int ln, const char *v, |
|
Line 2915 roff_evalnum(struct roff *r, int ln, const char *v, |
|
case '%': |
case '%': |
if (operand2 == 0) { |
if (operand2 == 0) { |
mandoc_msg(MANDOCERR_DIVZERO, |
mandoc_msg(MANDOCERR_DIVZERO, |
r->parse, ln, *pos, v); |
ln, *pos, "%s", v); |
*res = 0; |
*res = 0; |
break; |
break; |
} |
} |
Line 2915 roff_nr(ROFF_ARGS) |
|
Line 3117 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 2979 roff_rm(ROFF_ARGS) |
|
Line 3181 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 2993 roff_it(ROFF_ARGS) |
|
Line 3195 roff_it(ROFF_ARGS) |
|
/* Parse the number of lines. */ |
/* Parse the number of lines. */ |
|
|
if ( ! roff_evalnum(r, ln, buf->buf, &pos, &iv, 0)) { |
if ( ! roff_evalnum(r, ln, buf->buf, &pos, &iv, 0)) { |
mandoc_msg(MANDOCERR_IT_NONUM, r->parse, |
mandoc_msg(MANDOCERR_IT_NONUM, |
ln, ppos, buf->buf + 1); |
ln, ppos, "%s", buf->buf + 1); |
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
Line 3047 roff_Dd(ROFF_ARGS) |
|
Line 3249 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, r->parse, |
mandoc_msg(MANDOCERR_BLK_NOTOPEN, ln, ppos, "TE"); |
ln, ppos, "TE"); |
|
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
if (tbl_end(r->tbl, 0) == 0) { |
if (tbl_end(r->tbl, 0) == 0) { |
Line 3069 roff_T_(ROFF_ARGS) |
|
Line 3271 roff_T_(ROFF_ARGS) |
|
{ |
{ |
|
|
if (NULL == r->tbl) |
if (NULL == r->tbl) |
mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse, |
mandoc_msg(MANDOCERR_BLK_NOTOPEN, ln, ppos, "T&"); |
ln, ppos, "T&"); |
|
else |
else |
tbl_restart(ln, ppos, r->tbl); |
tbl_restart(ln, ppos, r->tbl); |
|
|
Line 3148 roff_EQ(ROFF_ARGS) |
|
Line 3349 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) |
n->flags |= NODE_LINE; |
n->flags |= NODE_LINE; |
n->eqn = mandoc_calloc(1, sizeof(*n->eqn)); |
n->eqn = eqn_box_new(); |
n->eqn->expectargs = UINT_MAX; |
|
roff_node_append(r->man, n); |
roff_node_append(r->man, n); |
r->man->next = ROFF_NEXT_SIBLING; |
r->man->next = ROFF_NEXT_SIBLING; |
|
|
assert(r->eqn == NULL); |
assert(r->eqn == NULL); |
if (r->last_eqn == NULL) |
if (r->last_eqn == NULL) |
r->last_eqn = eqn_alloc(r->parse); |
r->last_eqn = eqn_alloc(); |
else |
else |
eqn_reset(r->last_eqn); |
eqn_reset(r->last_eqn); |
r->eqn = r->last_eqn; |
r->eqn = r->last_eqn; |
r->eqn->node = n; |
r->eqn->node = n; |
|
|
if (buf->buf[pos] != '\0') |
if (buf->buf[pos] != '\0') |
mandoc_vmsg(MANDOCERR_ARG_SKIP, r->parse, ln, pos, |
mandoc_msg(MANDOCERR_ARG_SKIP, ln, pos, |
".EQ %s", buf->buf + pos); |
".EQ %s", buf->buf + pos); |
|
|
return ROFF_IGN; |
return ROFF_IGN; |
Line 3180 roff_EN(ROFF_ARGS) |
|
Line 3380 roff_EN(ROFF_ARGS) |
|
eqn_parse(r->eqn); |
eqn_parse(r->eqn); |
r->eqn = NULL; |
r->eqn = NULL; |
} else |
} else |
mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse, ln, ppos, "EN"); |
mandoc_msg(MANDOCERR_BLK_NOTOPEN, ln, ppos, "EN"); |
if (buf->buf[pos] != '\0') |
if (buf->buf[pos] != '\0') |
mandoc_vmsg(MANDOCERR_ARG_SKIP, r->parse, ln, pos, |
mandoc_msg(MANDOCERR_ARG_SKIP, ln, pos, |
"EN %s", buf->buf + pos); |
"EN %s", buf->buf + pos); |
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
roff_TS(ROFF_ARGS) |
roff_TS(ROFF_ARGS) |
{ |
{ |
if (r->tbl != NULL) { |
if (r->tbl != NULL) { |
mandoc_msg(MANDOCERR_BLK_BROKEN, r->parse, |
mandoc_msg(MANDOCERR_BLK_BROKEN, ln, ppos, "TS breaks TS"); |
ln, ppos, "TS breaks TS"); |
|
tbl_end(r->tbl, 0); |
tbl_end(r->tbl, 0); |
} |
} |
r->tbl = tbl_alloc(ppos, ln, r->parse, r->last_tbl); |
r->man->flags |= ROFF_NONOFILL; |
|
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; |
r->last_tbl = r->tbl; |
r->last_tbl = r->tbl; |
Line 3203 roff_TS(ROFF_ARGS) |
|
Line 3403 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 3229 roff_onearg(ROFF_ARGS) |
|
Line 3449 roff_onearg(ROFF_ARGS) |
|
while (*cp == ' ') |
while (*cp == ' ') |
*cp++ = '\0'; |
*cp++ = '\0'; |
if (*cp != '\0') |
if (*cp != '\0') |
mandoc_vmsg(MANDOCERR_ARG_EXCESS, |
mandoc_msg(MANDOCERR_ARG_EXCESS, |
r->parse, ln, cp - buf->buf, |
ln, (int)(cp - buf->buf), |
"%s ... %s", roff_name[tok], cp); |
"%s ... %s", roff_name[tok], cp); |
roff_word_alloc(r->man, ln, pos, buf->buf + pos); |
roff_word_alloc(r->man, ln, pos, buf->buf + pos); |
} |
} |
Line 3243 roff_onearg(ROFF_ARGS) |
|
Line 3463 roff_onearg(ROFF_ARGS) |
|
npos = 0; |
npos = 0; |
if (roff_evalnum(r, ln, r->man->last->string, &npos, |
if (roff_evalnum(r, ln, r->man->last->string, &npos, |
&roffce_lines, 0) == 0) { |
&roffce_lines, 0) == 0) { |
mandoc_vmsg(MANDOCERR_CE_NONUM, |
mandoc_msg(MANDOCERR_CE_NONUM, |
r->parse, ln, pos, "ce %s", buf->buf + pos); |
ln, pos, "ce %s", buf->buf + pos); |
roffce_lines = 1; |
roffce_lines = 1; |
} |
} |
if (roffce_lines < 1) { |
if (roffce_lines < 1) { |
Line 3296 roff_als(ROFF_ARGS) |
|
Line 3516 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 3312 roff_als(ROFF_ARGS) |
|
Line 3532 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_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; |
return ROFF_IGN; |
} |
} |
|
|
Line 3337 roff_cc(ROFF_ARGS) |
|
Line 3554 roff_cc(ROFF_ARGS) |
|
r->control = '\0'; |
r->control = '\0'; |
|
|
if (*p != '\0') |
if (*p != '\0') |
mandoc_vmsg(MANDOCERR_ARG_EXCESS, r->parse, |
mandoc_msg(MANDOCERR_ARG_EXCESS, |
ln, p - buf->buf, "cc ... %s", p); |
ln, p - buf->buf, "cc ... %s", p); |
|
|
return ROFF_IGN; |
return ROFF_IGN; |
Line 3357 roff_char(ROFF_ARGS) |
|
Line 3574 roff_char(ROFF_ARGS) |
|
if (*kp == '\0' || (*kp == '\\' && |
if (*kp == '\0' || (*kp == '\\' && |
mandoc_escape(&p, NULL, NULL) != ESCAPE_SPECIAL) || |
mandoc_escape(&p, NULL, NULL) != ESCAPE_SPECIAL) || |
(*p != ' ' && *p != '\0')) { |
(*p != ' ' && *p != '\0')) { |
mandoc_vmsg(MANDOCERR_CHAR_ARG, r->parse, |
mandoc_msg(MANDOCERR_CHAR_ARG, ln, pos, "char %s", kp); |
ln, pos, "char %s", kp); |
|
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
ksz = p - kp; |
ksz = p - kp; |
Line 3382 roff_char(ROFF_ARGS) |
|
Line 3598 roff_char(ROFF_ARGS) |
|
case ESCAPE_FONTITALIC: |
case ESCAPE_FONTITALIC: |
case ESCAPE_FONTBOLD: |
case ESCAPE_FONTBOLD: |
case ESCAPE_FONTBI: |
case ESCAPE_FONTBI: |
case ESCAPE_FONTCW: |
case ESCAPE_FONTCR: |
|
case ESCAPE_FONTCB: |
|
case ESCAPE_FONTCI: |
case ESCAPE_FONTPREV: |
case ESCAPE_FONTPREV: |
font++; |
font++; |
break; |
break; |
Line 3391 roff_char(ROFF_ARGS) |
|
Line 3609 roff_char(ROFF_ARGS) |
|
} |
} |
} |
} |
if (font > 1) |
if (font > 1) |
mandoc_msg(MANDOCERR_CHAR_FONT, r->parse, |
mandoc_msg(MANDOCERR_CHAR_FONT, |
ln, vp - buf->buf, vp); |
ln, (int)(vp - buf->buf), "%s", vp); |
|
|
/* |
/* |
* Approximate the effect of .char using the .tr tables. |
* Approximate the effect of .char using the .tr tables. |
Line 3425 roff_ec(ROFF_ARGS) |
|
Line 3643 roff_ec(ROFF_ARGS) |
|
else { |
else { |
r->escape = *p; |
r->escape = *p; |
if (*++p != '\0') |
if (*++p != '\0') |
mandoc_vmsg(MANDOCERR_ARG_EXCESS, r->parse, |
mandoc_msg(MANDOCERR_ARG_EXCESS, ln, |
ln, p - buf->buf, "ec ... %s", p); |
(int)(p - buf->buf), "ec ... %s", p); |
} |
} |
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
Line 3436 roff_eo(ROFF_ARGS) |
|
Line 3654 roff_eo(ROFF_ARGS) |
|
{ |
{ |
r->escape = '\0'; |
r->escape = '\0'; |
if (buf->buf[pos] != '\0') |
if (buf->buf[pos] != '\0') |
mandoc_vmsg(MANDOCERR_ARG_SKIP, r->parse, |
mandoc_msg(MANDOCERR_ARG_SKIP, |
ln, pos, "eo %s", buf->buf + pos); |
ln, pos, "eo %s", buf->buf + pos); |
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
static int |
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) |
roff_nop(ROFF_ARGS) |
{ |
{ |
while (buf->buf[pos] == ' ') |
while (buf->buf[pos] == ' ') |
Line 3460 roff_tr(ROFF_ARGS) |
|
Line 3726 roff_tr(ROFF_ARGS) |
|
p = buf->buf + pos; |
p = buf->buf + pos; |
|
|
if (*p == '\0') { |
if (*p == '\0') { |
mandoc_msg(MANDOCERR_REQ_EMPTY, r->parse, ln, ppos, "tr"); |
mandoc_msg(MANDOCERR_REQ_EMPTY, ln, ppos, "tr"); |
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
Line 3471 roff_tr(ROFF_ARGS) |
|
Line 3737 roff_tr(ROFF_ARGS) |
|
if (*first == '\\') { |
if (*first == '\\') { |
esc = mandoc_escape(&p, NULL, NULL); |
esc = mandoc_escape(&p, NULL, NULL); |
if (esc == ESCAPE_ERROR) { |
if (esc == ESCAPE_ERROR) { |
mandoc_msg(MANDOCERR_ESC_BAD, r->parse, |
mandoc_msg(MANDOCERR_ESC_BAD, ln, |
ln, (int)(p - buf->buf), first); |
(int)(p - buf->buf), "%s", first); |
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
fsz = (size_t)(p - first); |
fsz = (size_t)(p - first); |
Line 3482 roff_tr(ROFF_ARGS) |
|
Line 3748 roff_tr(ROFF_ARGS) |
|
if (*second == '\\') { |
if (*second == '\\') { |
esc = mandoc_escape(&p, NULL, NULL); |
esc = mandoc_escape(&p, NULL, NULL); |
if (esc == ESCAPE_ERROR) { |
if (esc == ESCAPE_ERROR) { |
mandoc_msg(MANDOCERR_ESC_BAD, r->parse, |
mandoc_msg(MANDOCERR_ESC_BAD, ln, |
ln, (int)(p - buf->buf), second); |
(int)(p - buf->buf), "%s", second); |
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
ssz = (size_t)(p - second); |
ssz = (size_t)(p - second); |
} else if (*second == '\0') { |
} else if (*second == '\0') { |
mandoc_vmsg(MANDOCERR_TR_ODD, r->parse, |
mandoc_msg(MANDOCERR_TR_ODD, ln, |
ln, first - buf->buf, "tr %s", first); |
(int)(first - buf->buf), "tr %s", first); |
second = " "; |
second = " "; |
p--; |
p--; |
} |
} |
Line 3524 roff_return(ROFF_ARGS) |
|
Line 3790 roff_return(ROFF_ARGS) |
|
if (r->mstackpos >= 0) |
if (r->mstackpos >= 0) |
return ROFF_IGN | ROFF_USERRET; |
return ROFF_IGN | ROFF_USERRET; |
|
|
mandoc_msg(MANDOCERR_REQ_NOMAC, r->parse, ln, ppos, "return"); |
mandoc_msg(MANDOCERR_REQ_NOMAC, ln, ppos, "return"); |
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
Line 3541 roff_rn(ROFF_ARGS) |
|
Line 3807 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; |
|
|
roff_shift(ROFF_ARGS) |
roff_shift(ROFF_ARGS) |
{ |
{ |
struct mctx *ctx; |
struct mctx *ctx; |
int levels, i; |
int argpos, levels, i; |
|
|
|
argpos = pos; |
levels = 1; |
levels = 1; |
if (buf->buf[pos] != '\0' && |
if (buf->buf[pos] != '\0' && |
roff_evalnum(r, ln, buf->buf, &pos, &levels, 0) == 0) { |
roff_evalnum(r, ln, buf->buf, &pos, &levels, 0) == 0) { |
mandoc_vmsg(MANDOCERR_CE_NONUM, r->parse, |
mandoc_msg(MANDOCERR_CE_NONUM, |
ln, pos, "shift %s", buf->buf + pos); |
ln, pos, "shift %s", buf->buf + pos); |
levels = 1; |
levels = 1; |
} |
} |
if (r->mstackpos < 0) { |
if (r->mstackpos < 0) { |
mandoc_msg(MANDOCERR_REQ_NOMAC, r->parse, ln, ppos, "shift"); |
mandoc_msg(MANDOCERR_REQ_NOMAC, ln, ppos, "shift"); |
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
ctx = r->mstack + r->mstackpos; |
ctx = r->mstack + r->mstackpos; |
if (levels > ctx->argc) { |
if (levels > ctx->argc) { |
mandoc_vmsg(MANDOCERR_SHIFT, r->parse, |
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; |
levels = ctx->argc; |
} |
} |
|
if (levels < 0) { |
|
mandoc_msg(MANDOCERR_ARG_NEG, ln, argpos, "shift %d", levels); |
|
levels = 0; |
|
} |
if (levels == 0) |
if (levels == 0) |
return ROFF_IGN; |
return ROFF_IGN; |
for (i = 0; i < levels; i++) |
for (i = 0; i < levels; i++) |
Line 3617 roff_so(ROFF_ARGS) |
|
Line 3888 roff_so(ROFF_ARGS) |
|
char *name, *cp; |
char *name, *cp; |
|
|
name = buf->buf + pos; |
name = buf->buf + pos; |
mandoc_vmsg(MANDOCERR_SO, r->parse, ln, ppos, "so %s", name); |
mandoc_msg(MANDOCERR_SO, ln, ppos, "so %s", name); |
|
|
/* |
/* |
* Handle `so'. Be EXTREMELY careful, as we shouldn't be |
* Handle `so'. Be EXTREMELY careful, as we shouldn't be |
Line 3627 roff_so(ROFF_ARGS) |
|
Line 3898 roff_so(ROFF_ARGS) |
|
*/ |
*/ |
|
|
if (*name == '/' || strstr(name, "../") || strstr(name, "/..")) { |
if (*name == '/' || strstr(name, "../") || strstr(name, "/..")) { |
mandoc_vmsg(MANDOCERR_SO_PATH, r->parse, ln, ppos, |
mandoc_msg(MANDOCERR_SO_PATH, ln, ppos, ".so %s", name); |
".so %s", name); |
|
buf->sz = mandoc_asprintf(&cp, |
buf->sz = mandoc_asprintf(&cp, |
".sp\nSee the file %s.\n.sp", name) + 1; |
".sp\nSee the file %s.\n.sp", name) + 1; |
free(buf->buf); |
free(buf->buf); |
Line 3650 roff_userdef(ROFF_ARGS) |
|
Line 3920 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 3658 roff_userdef(ROFF_ARGS) |
|
Line 3933 roff_userdef(ROFF_ARGS) |
|
r->mstacksz += 8; |
r->mstacksz += 8; |
} |
} |
ctx = r->mstack + r->mstackpos; |
ctx = r->mstack + r->mstackpos; |
ctx->argsz = 0; |
|
ctx->argc = 0; |
ctx->argc = 0; |
ctx->argv = NULL; |
|
|
|
/* |
/* |
* Collect pointers to macro argument strings, |
* Collect pointers to macro argument strings, |
Line 3674 roff_userdef(ROFF_ARGS) |
|
Line 3947 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(r->parse, &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 3687 roff_userdef(ROFF_ARGS) |
|
Line 3960 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 3696 roff_userdef(ROFF_ARGS) |
|
Line 3970 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 3717 roff_renamed(ROFF_ARGS) |
|
Line 3991 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 3724 roff_getname(struct roff *r, char **cpp, int ln, int p |
|
Line 4002 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_vmsg(MANDOCERR_NAMESC, r->parse, ln, pos, |
mandoc_msg(MANDOCERR_NAMESC, ln, pos, |
"%.*s", (int)(cp - name + 1), name); |
"%.*s", (int)(cp - name + 1), name); |
mandoc_escape((const char **)&cp, NULL, NULL); |
mandoc_escape((const char **)&cp, NULL, NULL); |
break; |
break; |
} |
} |
|
|
/* Read past spaces. */ |
/* Read past spaces. */ |
while (' ' == *cp) |
|
|
while (*cp == ' ') |
cp++; |
cp++; |
|
|
*cpp = cp; |
*cpp = cp; |
Line 3891 roff_getstrn(struct roff *r, const char *name, size_t |
|
Line 4172 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 3905 roff_getstrn(struct roff *r, const char *name, size_t |
|
Line 4186 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 4036 roff_strdup(const struct roff *r, const char *p) |
|
Line 4317 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); |