version 1.306, 2017/06/07 00:50:34 |
version 1.350, 2018/12/14 05:18:03 |
|
|
/* $Id$ */ |
/* $Id$ */ |
/* |
/* |
* 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 Ingo Schwarze <schwarze@openbsd.org> |
* 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 |
|
|
#include <stdlib.h> |
#include <stdlib.h> |
#include <string.h> |
#include <string.h> |
|
|
#include "mandoc.h" |
|
#include "mandoc_aux.h" |
#include "mandoc_aux.h" |
#include "mandoc_ohash.h" |
#include "mandoc_ohash.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 "libroff.h" |
#include "tbl_parse.h" |
|
#include "eqn_parse.h" |
|
|
/* 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 |
|
|
|
/* Types of definitions of macros and strings. */ |
|
#define ROFFDEF_USER (1 << 1) /* User-defined. */ |
|
#define ROFFDEF_PRE (1 << 2) /* Predefined. */ |
|
#define ROFFDEF_REN (1 << 3) /* Renamed standard macro. */ |
|
#define ROFFDEF_STD (1 << 4) /* mdoc(7) or man(7) macro. */ |
|
#define ROFFDEF_ANY (ROFFDEF_USER | ROFFDEF_PRE | \ |
|
ROFFDEF_REN | ROFFDEF_STD) |
|
#define ROFFDEF_UNDEF (1 << 5) /* Completely undefined. */ |
|
|
/* --- data types --------------------------------------------------------- */ |
/* --- data types --------------------------------------------------------- */ |
|
|
/* |
/* |
|
|
struct roffreg { |
struct roffreg { |
struct roffstr key; |
struct roffstr key; |
int val; |
int val; |
|
int step; |
struct roffreg *next; |
struct roffreg *next; |
}; |
}; |
|
|
|
|
char name[]; |
char name[]; |
}; |
}; |
|
|
|
/* |
|
* A macro processing context. |
|
* More than one is needed when macro calls are nested. |
|
*/ |
|
struct mctx { |
|
char **argv; |
|
int argc; |
|
int argsz; |
|
}; |
|
|
struct roff { |
struct roff { |
struct mparse *parse; /* parse point */ |
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 */ |
int *rstack; /* stack of inverted `ie' values */ |
int *rstack; /* stack of inverted `ie' values */ |
struct ohash *reqtab; /* request lookup table */ |
struct ohash *reqtab; /* request lookup table */ |
struct roffreg *regtab; /* number registers */ |
struct roffreg *regtab; /* number registers */ |
|
|
struct tbl_node *first_tbl; /* first table parsed */ |
struct tbl_node *first_tbl; /* first table parsed */ |
struct tbl_node *last_tbl; /* last table parsed */ |
struct tbl_node *last_tbl; /* last table parsed */ |
struct tbl_node *tbl; /* current table being parsed */ |
struct tbl_node *tbl; /* current table being parsed */ |
struct eqn_node *last_eqn; /* last equation parsed */ |
struct eqn_node *last_eqn; /* equation parser */ |
struct eqn_node *first_eqn; /* first equation parsed */ |
struct eqn_node *eqn; /* active equation parser */ |
struct eqn_node *eqn; /* current equation being parsed */ |
|
int eqn_inline; /* current equation is inline */ |
int eqn_inline; /* current equation is inline */ |
int options; /* parse options */ |
int options; /* parse options */ |
|
int mstacksz; /* current size of mstack */ |
|
int mstackpos; /* position in mstack */ |
int rstacksz; /* current size limit of rstack */ |
int rstacksz; /* current size limit of rstack */ |
int rstackpos; /* position in rstack */ |
int rstackpos; /* position in rstack */ |
int format; /* current file in mdoc or man format */ |
int format; /* current file in mdoc or man format */ |
int argc; /* number of args of the last macro */ |
|
char control; /* control character */ |
char control; /* control character */ |
char escape; /* escape character */ |
char escape; /* escape character */ |
}; |
}; |
Line 122 struct roffnode { |
|
Line 145 struct roffnode { |
|
int pos, /* current pos in buffer */ \ |
int pos, /* current pos in buffer */ \ |
int *offs /* reset offset of buffer data */ |
int *offs /* reset offset of buffer data */ |
|
|
typedef enum rofferr (*roffproc)(ROFF_ARGS); |
typedef int (*roffproc)(ROFF_ARGS); |
|
|
struct roffmac { |
struct roffmac { |
roffproc proc; /* process new macro */ |
roffproc proc; /* process new macro */ |
|
|
|
|
/* --- function prototypes ------------------------------------------------ */ |
/* --- function prototypes ------------------------------------------------ */ |
|
|
static void roffnode_cleanscope(struct roff *); |
static int roffnode_cleanscope(struct roff *); |
static void roffnode_pop(struct roff *); |
static int roffnode_pop(struct roff *); |
static void roffnode_push(struct roff *, enum roff_tok, |
static void roffnode_push(struct roff *, enum roff_tok, |
const char *, int, int); |
const char *, int, int); |
static enum rofferr roff_block(ROFF_ARGS); |
static void roff_addtbl(struct roff_man *, int, struct tbl_node *); |
static enum rofferr roff_block_text(ROFF_ARGS); |
static int roff_als(ROFF_ARGS); |
static enum rofferr roff_block_sub(ROFF_ARGS); |
static int roff_block(ROFF_ARGS); |
static enum rofferr roff_br(ROFF_ARGS); |
static int roff_block_text(ROFF_ARGS); |
static enum rofferr roff_cblock(ROFF_ARGS); |
static int roff_block_sub(ROFF_ARGS); |
static enum rofferr roff_cc(ROFF_ARGS); |
static int roff_br(ROFF_ARGS); |
static void roff_ccond(struct roff *, int, int); |
static int roff_cblock(ROFF_ARGS); |
static enum rofferr roff_cond(ROFF_ARGS); |
static int roff_cc(ROFF_ARGS); |
static enum rofferr roff_cond_text(ROFF_ARGS); |
static int roff_ccond(struct roff *, int, int); |
static enum rofferr roff_cond_sub(ROFF_ARGS); |
static int roff_char(ROFF_ARGS); |
static enum rofferr roff_ds(ROFF_ARGS); |
static int roff_cond(ROFF_ARGS); |
static enum rofferr roff_ec(ROFF_ARGS); |
static int roff_cond_text(ROFF_ARGS); |
static enum rofferr roff_eo(ROFF_ARGS); |
static int roff_cond_sub(ROFF_ARGS); |
static enum rofferr roff_eqndelim(struct roff *, struct buf *, int); |
static int roff_ds(ROFF_ARGS); |
|
static int roff_ec(ROFF_ARGS); |
|
static int roff_eo(ROFF_ARGS); |
|
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 *r, 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); |
Line 172 static void roff_freestr(struct roffkv *); |
|
Line 198 static void roff_freestr(struct roffkv *); |
|
static size_t roff_getname(struct roff *, char **, int, int); |
static size_t roff_getname(struct roff *, char **, int, int); |
static int roff_getnum(const char *, int *, int *, int); |
static int roff_getnum(const char *, int *, int *, int); |
static int roff_getop(const char *, int *, char *); |
static int roff_getop(const char *, int *, char *); |
static int roff_getregn(const struct roff *, |
static int roff_getregn(struct roff *, |
const char *, size_t); |
const char *, size_t, char); |
static int roff_getregro(const struct roff *, |
static int roff_getregro(const struct roff *, |
const char *name); |
const char *name); |
static const char *roff_getrenn(const struct roff *, |
static const char *roff_getstrn(struct roff *, |
const char *, size_t); |
const char *, size_t, int *); |
static const char *roff_getstrn(const struct roff *, |
|
const char *, size_t); |
|
static int roff_hasregn(const struct roff *, |
static int roff_hasregn(const struct roff *, |
const char *, size_t); |
const char *, size_t); |
static enum rofferr roff_insec(ROFF_ARGS); |
static int roff_insec(ROFF_ARGS); |
static enum rofferr roff_it(ROFF_ARGS); |
static int roff_it(ROFF_ARGS); |
static enum rofferr roff_line_ignore(ROFF_ARGS); |
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 enum rofferr roff_manyarg(ROFF_ARGS); |
static int roff_manyarg(ROFF_ARGS); |
static enum rofferr roff_nr(ROFF_ARGS); |
static int roff_nop(ROFF_ARGS); |
static enum rofferr roff_onearg(ROFF_ARGS); |
static int roff_nr(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 enum rofferr roff_parsetext(struct roff *, struct buf *, |
static int roff_parsetext(struct roff *, struct buf *, |
int, int *); |
int, int *); |
static enum rofferr roff_renamed(ROFF_ARGS); |
static int roff_renamed(ROFF_ARGS); |
static enum rofferr roff_res(struct roff *, struct buf *, int, int); |
static int roff_res(struct roff *, struct buf *, int, int); |
static enum rofferr roff_rm(ROFF_ARGS); |
static int roff_return(ROFF_ARGS); |
static enum rofferr roff_rn(ROFF_ARGS); |
static int roff_rm(ROFF_ARGS); |
static enum rofferr roff_rr(ROFF_ARGS); |
static int roff_rn(ROFF_ARGS); |
|
static int roff_rr(ROFF_ARGS); |
|
static void roff_setregn(struct roff *, const char *, |
|
size_t, int, char, int); |
static void roff_setstr(struct roff *, |
static void roff_setstr(struct roff *, |
const char *, const char *, int); |
const char *, const char *, int); |
static void roff_setstrn(struct roffkv **, const char *, |
static void roff_setstrn(struct roffkv **, const char *, |
size_t, const char *, size_t, int); |
size_t, const char *, size_t, int); |
static enum rofferr roff_so(ROFF_ARGS); |
static int roff_shift(ROFF_ARGS); |
static enum rofferr roff_tr(ROFF_ARGS); |
static int roff_so(ROFF_ARGS); |
static enum rofferr roff_Dd(ROFF_ARGS); |
static int roff_tr(ROFF_ARGS); |
static enum rofferr roff_TH(ROFF_ARGS); |
static int roff_Dd(ROFF_ARGS); |
static enum rofferr roff_TE(ROFF_ARGS); |
static int roff_TE(ROFF_ARGS); |
static enum rofferr roff_TS(ROFF_ARGS); |
static int roff_TS(ROFF_ARGS); |
static enum rofferr roff_EQ(ROFF_ARGS); |
static int roff_EQ(ROFF_ARGS); |
static enum rofferr roff_EN(ROFF_ARGS); |
static int roff_EN(ROFF_ARGS); |
static enum rofferr roff_T_(ROFF_ARGS); |
static int roff_T_(ROFF_ARGS); |
static enum rofferr roff_unsupp(ROFF_ARGS); |
static int roff_unsupp(ROFF_ARGS); |
static enum rofferr roff_userdef(ROFF_ARGS); |
static int roff_userdef(ROFF_ARGS); |
|
|
/* --- constant data ------------------------------------------------------ */ |
/* --- constant data ------------------------------------------------------ */ |
|
|
Line 222 static enum rofferr roff_userdef(ROFF_ARGS); |
|
Line 250 static enum rofferr roff_userdef(ROFF_ARGS); |
|
|
|
const char *__roff_name[MAN_MAX + 1] = { |
const char *__roff_name[MAN_MAX + 1] = { |
"br", "ce", "ft", "ll", |
"br", "ce", "ft", "ll", |
"mc", "sp", "ta", "ti", |
"mc", "po", "rj", "sp", |
NULL, |
"ta", "ti", NULL, |
"ab", "ad", "af", "aln", |
"ab", "ad", "af", "aln", |
"als", "am", "am1", "ami", |
"als", "am", "am1", "ami", |
"ami1", "as", "as1", "asciify", |
"ami1", "as", "as1", "asciify", |
Line 264 const char *__roff_name[MAN_MAX + 1] = { |
|
Line 292 const char *__roff_name[MAN_MAX + 1] = { |
|
"open", "opena", "os", "output", |
"open", "opena", "os", "output", |
"padj", "papersize", "pc", "pev", |
"padj", "papersize", "pc", "pev", |
"pi", "PI", "pl", "pm", |
"pi", "PI", "pl", "pm", |
"pn", "pnr", "po", "ps", |
"pn", "pnr", "ps", |
"psbb", "pshape", "pso", "ptr", |
"psbb", "pshape", "pso", "ptr", |
"pvs", "rchar", "rd", "recursionlimit", |
"pvs", "rchar", "rd", "recursionlimit", |
"return", "rfschar", "rhang", "rj", |
"return", "rfschar", "rhang", |
"rm", "rn", "rnn", "rr", |
"rm", "rn", "rnn", "rr", |
"rs", "rt", "schar", "sentchar", |
"rs", "rt", "schar", "sentchar", |
"shc", "shift", "sizes", "so", |
"shc", "shift", "sizes", "so", |
Line 316 const char *__roff_name[MAN_MAX + 1] = { |
|
Line 344 const char *__roff_name[MAN_MAX + 1] = { |
|
"Dx", "%Q", "%U", "Ta", |
"Dx", "%Q", "%U", "Ta", |
NULL, |
NULL, |
"TH", "SH", "SS", "TP", |
"TH", "SH", "SS", "TP", |
|
"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", |
Line 323 const char *__roff_name[MAN_MAX + 1] = { |
|
Line 352 const char *__roff_name[MAN_MAX + 1] = { |
|
"nf", "fi", |
"nf", "fi", |
"RE", "RS", "DT", "UC", |
"RE", "RS", "DT", "UC", |
"PD", "AT", "in", |
"PD", "AT", "in", |
"OP", "EX", "EE", "UR", |
"SY", "YS", "OP", |
"UE", NULL |
"EX", "EE", "UR", |
|
"UE", "MT", "ME", NULL |
}; |
}; |
const char *const *roff_name = __roff_name; |
const char *const *roff_name = __roff_name; |
|
|
Line 334 static struct roffmac roffs[TOKEN_NONE] = { |
|
Line 364 static struct roffmac roffs[TOKEN_NONE] = { |
|
{ 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_onearg, NULL, NULL, 0 }, /* po */ |
|
{ roff_onearg, NULL, NULL, 0 }, /* rj */ |
{ roff_onearg, NULL, NULL, 0 }, /* sp */ |
{ roff_onearg, NULL, NULL, 0 }, /* sp */ |
{ roff_manyarg, NULL, NULL, 0 }, /* ta */ |
{ roff_manyarg, NULL, NULL, 0 }, /* ta */ |
{ roff_onearg, NULL, NULL, 0 }, /* ti */ |
{ roff_onearg, NULL, NULL, 0 }, /* ti */ |
Line 342 static struct roffmac roffs[TOKEN_NONE] = { |
|
Line 374 static struct roffmac roffs[TOKEN_NONE] = { |
|
{ roff_line_ignore, NULL, NULL, 0 }, /* ad */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* ad */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* af */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* af */ |
{ roff_unsupp, NULL, NULL, 0 }, /* aln */ |
{ roff_unsupp, NULL, NULL, 0 }, /* aln */ |
{ roff_unsupp, NULL, NULL, 0 }, /* als */ |
{ roff_als, NULL, NULL, 0 }, /* als */ |
{ roff_block, roff_block_text, roff_block_sub, 0 }, /* am */ |
{ roff_block, roff_block_text, roff_block_sub, 0 }, /* am */ |
{ roff_block, roff_block_text, roff_block_sub, 0 }, /* am1 */ |
{ roff_block, roff_block_text, roff_block_sub, 0 }, /* am1 */ |
{ roff_block, roff_block_text, roff_block_sub, 0 }, /* ami */ |
{ roff_block, roff_block_text, roff_block_sub, 0 }, /* ami */ |
Line 368 static struct roffmac roffs[TOKEN_NONE] = { |
|
Line 400 static struct roffmac roffs[TOKEN_NONE] = { |
|
{ roff_insec, NULL, NULL, 0 }, /* cf */ |
{ roff_insec, NULL, NULL, 0 }, /* cf */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* cflags */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* cflags */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* ch */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* ch */ |
{ roff_unsupp, NULL, NULL, 0 }, /* char */ |
{ roff_char, NULL, NULL, 0 }, /* char */ |
{ roff_unsupp, NULL, NULL, 0 }, /* chop */ |
{ roff_unsupp, NULL, NULL, 0 }, /* chop */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* class */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* class */ |
{ roff_insec, NULL, NULL, 0 }, /* close */ |
{ roff_insec, NULL, NULL, 0 }, /* close */ |
Line 478 static struct roffmac roffs[TOKEN_NONE] = { |
|
Line 510 static struct roffmac roffs[TOKEN_NONE] = { |
|
{ roff_line_ignore, NULL, NULL, 0 }, /* nhychar */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* nhychar */ |
{ roff_unsupp, NULL, NULL, 0 }, /* nm */ |
{ roff_unsupp, NULL, NULL, 0 }, /* nm */ |
{ roff_unsupp, NULL, NULL, 0 }, /* nn */ |
{ roff_unsupp, NULL, NULL, 0 }, /* nn */ |
{ roff_unsupp, NULL, NULL, 0 }, /* nop */ |
{ roff_nop, NULL, NULL, 0 }, /* nop */ |
{ roff_nr, NULL, NULL, 0 }, /* nr */ |
{ roff_nr, NULL, NULL, 0 }, /* nr */ |
{ roff_unsupp, NULL, NULL, 0 }, /* nrf */ |
{ roff_unsupp, NULL, NULL, 0 }, /* nrf */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* nroff */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* nroff */ |
Line 498 static struct roffmac roffs[TOKEN_NONE] = { |
|
Line 530 static struct roffmac roffs[TOKEN_NONE] = { |
|
{ roff_line_ignore, NULL, NULL, 0 }, /* pm */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* pm */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* pn */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* pn */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* pnr */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* pnr */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* po */ |
|
{ roff_line_ignore, NULL, NULL, 0 }, /* ps */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* ps */ |
{ roff_unsupp, NULL, NULL, 0 }, /* psbb */ |
{ roff_unsupp, NULL, NULL, 0 }, /* psbb */ |
{ roff_unsupp, NULL, NULL, 0 }, /* pshape */ |
{ roff_unsupp, NULL, NULL, 0 }, /* pshape */ |
Line 508 static struct roffmac roffs[TOKEN_NONE] = { |
|
Line 539 static struct roffmac roffs[TOKEN_NONE] = { |
|
{ roff_unsupp, NULL, NULL, 0 }, /* rchar */ |
{ roff_unsupp, NULL, NULL, 0 }, /* rchar */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* rd */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* rd */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* recursionlimit */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* recursionlimit */ |
{ roff_unsupp, NULL, NULL, 0 }, /* return */ |
{ roff_return, NULL, NULL, 0 }, /* return */ |
{ roff_unsupp, NULL, NULL, 0 }, /* rfschar */ |
{ roff_unsupp, NULL, NULL, 0 }, /* rfschar */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* rhang */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* rhang */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* rj */ |
|
{ roff_rm, NULL, NULL, 0 }, /* rm */ |
{ roff_rm, NULL, NULL, 0 }, /* rm */ |
{ roff_rn, NULL, NULL, 0 }, /* rn */ |
{ roff_rn, NULL, NULL, 0 }, /* rn */ |
{ roff_unsupp, NULL, NULL, 0 }, /* rnn */ |
{ roff_unsupp, NULL, NULL, 0 }, /* rnn */ |
Line 521 static struct roffmac roffs[TOKEN_NONE] = { |
|
Line 551 static struct roffmac roffs[TOKEN_NONE] = { |
|
{ roff_unsupp, NULL, NULL, 0 }, /* schar */ |
{ roff_unsupp, NULL, NULL, 0 }, /* schar */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* sentchar */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* sentchar */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* shc */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* shc */ |
{ roff_unsupp, NULL, NULL, 0 }, /* shift */ |
{ roff_shift, NULL, NULL, 0 }, /* shift */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* sizes */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* sizes */ |
{ roff_so, NULL, NULL, 0 }, /* so */ |
{ roff_so, NULL, NULL, 0 }, /* so */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* spacewidth */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* spacewidth */ |
Line 535 static struct roffmac roffs[TOKEN_NONE] = { |
|
Line 565 static struct roffmac roffs[TOKEN_NONE] = { |
|
{ roff_T_, NULL, NULL, 0 }, /* T& */ |
{ roff_T_, NULL, NULL, 0 }, /* T& */ |
{ roff_unsupp, NULL, NULL, 0 }, /* tc */ |
{ roff_unsupp, NULL, NULL, 0 }, /* tc */ |
{ roff_TE, NULL, NULL, 0 }, /* TE */ |
{ roff_TE, NULL, NULL, 0 }, /* TE */ |
{ roff_TH, NULL, NULL, 0 }, /* TH */ |
{ roff_Dd, NULL, NULL, 0 }, /* TH */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* tkf */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* tkf */ |
{ roff_unsupp, NULL, NULL, 0 }, /* tl */ |
{ roff_unsupp, NULL, NULL, 0 }, /* tl */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* tm */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* tm */ |
Line 563 static struct roffmac roffs[TOKEN_NONE] = { |
|
Line 593 static struct roffmac roffs[TOKEN_NONE] = { |
|
{ roff_line_ignore, NULL, NULL, 0 }, /* watchlength */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* watchlength */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* watchn */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* watchn */ |
{ roff_unsupp, NULL, NULL, 0 }, /* wh */ |
{ roff_unsupp, NULL, NULL, 0 }, /* wh */ |
{ roff_unsupp, NULL, NULL, 0 }, /* while */ |
{ roff_cond, roff_cond_text, roff_cond_sub, ROFFMAC_STRUCT }, /*while*/ |
{ roff_insec, NULL, NULL, 0 }, /* write */ |
{ roff_insec, NULL, NULL, 0 }, /* write */ |
{ roff_insec, NULL, NULL, 0 }, /* writec */ |
{ roff_insec, NULL, NULL, 0 }, /* writec */ |
{ roff_insec, NULL, NULL, 0 }, /* writem */ |
{ roff_insec, NULL, NULL, 0 }, /* writem */ |
Line 573 static struct roffmac roffs[TOKEN_NONE] = { |
|
Line 603 static struct roffmac roffs[TOKEN_NONE] = { |
|
{ roff_userdef, NULL, NULL, 0 } |
{ roff_userdef, NULL, NULL, 0 } |
}; |
}; |
|
|
/* not currently implemented: Ds em Eq LP Me PP pp Or Rd Sf SH */ |
|
const char *const __mdoc_reserved[] = { |
|
"Ac", "Ad", "An", "Ao", "Ap", "Aq", "Ar", "At", |
|
"Bc", "Bd", "Bf", "Bk", "Bl", "Bo", "Bq", |
|
"Brc", "Bro", "Brq", "Bsx", "Bt", "Bx", |
|
"Cd", "Cm", "Db", "Dc", "Dd", "Dl", "Do", "Dq", |
|
"Dt", "Dv", "Dx", "D1", |
|
"Ec", "Ed", "Ef", "Ek", "El", "Em", |
|
"En", "Eo", "Er", "Es", "Ev", "Ex", |
|
"Fa", "Fc", "Fd", "Fl", "Fn", "Fo", "Fr", "Ft", "Fx", |
|
"Hf", "Ic", "In", "It", "Lb", "Li", "Lk", "Lp", |
|
"Ms", "Mt", "Nd", "Nm", "No", "Ns", "Nx", |
|
"Oc", "Oo", "Op", "Os", "Ot", "Ox", |
|
"Pa", "Pc", "Pf", "Po", "Pp", "Pq", |
|
"Qc", "Ql", "Qo", "Qq", "Re", "Rs", "Rv", |
|
"Sc", "Sh", "Sm", "So", "Sq", |
|
"Ss", "St", "Sx", "Sy", |
|
"Ta", "Tn", "Ud", "Ux", "Va", "Vt", "Xc", "Xo", "Xr", |
|
"%A", "%B", "%C", "%D", "%I", "%J", "%N", "%O", |
|
"%P", "%Q", "%R", "%T", "%U", "%V", |
|
NULL |
|
}; |
|
|
|
/* not currently implemented: BT DE DS ME MT PT SY TQ YS */ |
|
const char *const __man_reserved[] = { |
|
"AT", "B", "BI", "BR", "DT", |
|
"EE", "EN", "EQ", "EX", "HP", "I", "IB", "IP", "IR", |
|
"LP", "OP", "P", "PD", "PP", |
|
"R", "RB", "RE", "RI", "RS", "SB", "SH", "SM", "SS", |
|
"TE", "TH", "TP", "TS", "T&", "UC", "UE", "UR", |
|
NULL |
|
}; |
|
|
|
/* Array of injected predefined strings. */ |
/* Array of injected predefined strings. */ |
#define PREDEFS_MAX 38 |
#define PREDEFS_MAX 38 |
static const struct predef predefs[PREDEFS_MAX] = { |
static const struct predef predefs[PREDEFS_MAX] = { |
Line 680 roffhash_find(struct ohash *htab, const char *name, si |
|
Line 677 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. |
*/ |
*/ |
static void |
static int |
roffnode_pop(struct roff *r) |
roffnode_pop(struct roff *r) |
{ |
{ |
struct roffnode *p; |
struct roffnode *p; |
|
int inloop; |
|
|
assert(r->last); |
|
p = r->last; |
p = r->last; |
|
inloop = p->tok == ROFF_while; |
r->last = r->last->parent; |
r->last = p->parent; |
free(p->name); |
free(p->name); |
free(p->end); |
free(p->end); |
free(p); |
free(p); |
|
return inloop; |
} |
} |
|
|
/* |
/* |
Line 721 roffnode_push(struct roff *r, enum roff_tok tok, const |
|
Line 719 roffnode_push(struct roff *r, enum roff_tok tok, const |
|
static void |
static void |
roff_free1(struct roff *r) |
roff_free1(struct roff *r) |
{ |
{ |
struct tbl_node *tbl; |
|
struct eqn_node *e; |
|
int i; |
int i; |
|
|
while (NULL != (tbl = r->first_tbl)) { |
tbl_free(r->first_tbl); |
r->first_tbl = tbl->next; |
|
tbl_free(tbl); |
|
} |
|
r->first_tbl = r->last_tbl = r->tbl = NULL; |
r->first_tbl = r->last_tbl = r->tbl = NULL; |
|
|
while (NULL != (e = r->first_eqn)) { |
eqn_free(r->last_eqn); |
r->first_eqn = e->next; |
r->last_eqn = r->eqn = NULL; |
eqn_free(e); |
|
} |
|
r->first_eqn = r->last_eqn = r->eqn = NULL; |
|
|
|
|
while (r->mstackpos >= 0) |
|
roff_userret(r); |
|
|
while (r->last) |
while (r->last) |
roffnode_pop(r); |
roffnode_pop(r); |
|
|
Line 767 roff_reset(struct roff *r) |
|
Line 760 roff_reset(struct roff *r) |
|
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 = '\\'; |
|
roffce_lines = 0; |
|
roffce_node = NULL; |
|
roffit_lines = 0; |
|
roffit_macro = NULL; |
} |
} |
|
|
void |
void |
roff_free(struct roff *r) |
roff_free(struct roff *r) |
{ |
{ |
|
int i; |
|
|
roff_free1(r); |
roff_free1(r); |
|
for (i = 0; i < r->mstacksz; i++) |
|
free(r->mstack[i].argv); |
|
free(r->mstack); |
roffhash_free(r->reqtab); |
roffhash_free(r->reqtab); |
free(r); |
free(r); |
} |
} |
Line 784 roff_alloc(struct mparse *parse, int options) |
|
Line 786 roff_alloc(struct mparse *parse, int options) |
|
|
|
r = mandoc_calloc(1, sizeof(struct roff)); |
r = mandoc_calloc(1, sizeof(struct roff)); |
r->parse = parse; |
r->parse = parse; |
r->reqtab = roffhash_alloc(0, ROFF_USERDEF); |
r->reqtab = roffhash_alloc(0, ROFF_RENAMED); |
r->options = options; |
r->options = options; |
r->format = options & (MPARSE_MDOC | MPARSE_MAN); |
r->format = options & (MPARSE_MDOC | MPARSE_MAN); |
|
r->mstackpos = -1; |
r->rstackpos = -1; |
r->rstackpos = -1; |
r->escape = '\\'; |
r->escape = '\\'; |
return r; |
return r; |
Line 842 roff_man_free(struct roff_man *man) |
|
Line 845 roff_man_free(struct roff_man *man) |
|
|
|
struct roff_man * |
struct roff_man * |
roff_man_alloc(struct roff *roff, struct mparse *parse, |
roff_man_alloc(struct roff *roff, struct mparse *parse, |
const char *defos, 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->parse = parse; |
man->roff = roff; |
man->roff = roff; |
man->defos = defos; |
man->os_s = os_s; |
man->quick = quick; |
man->quick = quick; |
roff_man_alloc1(man); |
roff_man_alloc1(man); |
roff->man = man; |
roff->man = man; |
Line 1006 roff_body_alloc(struct roff_man *man, int line, int po |
|
Line 1009 roff_body_alloc(struct roff_man *man, int line, int po |
|
return n; |
return n; |
} |
} |
|
|
void |
static void |
roff_addeqn(struct roff_man *man, const struct eqn *eqn) |
roff_addtbl(struct roff_man *man, int line, struct tbl_node *tbl) |
{ |
{ |
struct roff_node *n; |
struct roff_node *n; |
|
struct tbl_span *span; |
|
|
n = roff_node_alloc(man, eqn->ln, eqn->pos, ROFFT_EQN, TOKEN_NONE); |
|
n->eqn = eqn; |
|
if (eqn->ln > man->last->line) |
|
n->flags |= NODE_LINE; |
|
roff_node_append(man, n); |
|
man->next = ROFF_NEXT_SIBLING; |
|
} |
|
|
|
void |
|
roff_addtbl(struct roff_man *man, const struct tbl_span *tbl) |
|
{ |
|
struct roff_node *n; |
|
|
|
if (man->macroset == MACROSET_MAN) |
if (man->macroset == MACROSET_MAN) |
man_breakscope(man, ROFF_TS); |
man_breakscope(man, ROFF_TS); |
n = roff_node_alloc(man, tbl->line, 0, ROFFT_TBL, TOKEN_NONE); |
while ((span = tbl_span(tbl)) != NULL) { |
n->span = tbl; |
n = roff_node_alloc(man, line, 0, ROFFT_TBL, TOKEN_NONE); |
roff_node_append(man, n); |
n->span = span; |
n->flags |= NODE_VALID | NODE_ENDED; |
roff_node_append(man, n); |
man->next = ROFF_NEXT_SIBLING; |
n->flags |= NODE_VALID | NODE_ENDED; |
|
man->next = ROFF_NEXT_SIBLING; |
|
} |
} |
} |
|
|
void |
void |
Line 1071 roff_node_unlink(struct roff_man *man, struct roff_nod |
|
Line 1064 roff_node_unlink(struct roff_man *man, struct roff_nod |
|
} |
} |
|
|
void |
void |
|
roff_node_relink(struct roff_man *man, struct roff_node *n) |
|
{ |
|
roff_node_unlink(man, n); |
|
n->prev = n->next = NULL; |
|
roff_node_append(man, n); |
|
} |
|
|
|
void |
roff_node_free(struct roff_node *n) |
roff_node_free(struct roff_node *n) |
{ |
{ |
|
|
Line 1078 roff_node_free(struct roff_node *n) |
|
Line 1079 roff_node_free(struct roff_node *n) |
|
mdoc_argv_free(n->args); |
mdoc_argv_free(n->args); |
if (n->type == ROFFT_BLOCK || n->type == ROFFT_ELEM) |
if (n->type == ROFFT_BLOCK || n->type == ROFFT_ELEM) |
free(n->norm); |
free(n->norm); |
|
eqn_box_free(n->eqn); |
free(n->string); |
free(n->string); |
free(n); |
free(n); |
} |
} |
Line 1148 deroff(char **dest, const struct roff_node *n) |
|
Line 1150 deroff(char **dest, const struct roff_node *n) |
|
* used in numerical expressions and conditional requests. |
* used in numerical expressions and conditional requests. |
* Also check the syntax of the remaining escape sequences. |
* Also check the syntax of the remaining escape sequences. |
*/ |
*/ |
static enum rofferr |
static int |
roff_res(struct roff *r, struct buf *buf, int ln, int pos) |
roff_res(struct roff *r, struct buf *buf, int ln, int pos) |
{ |
{ |
|
struct mctx *ctx; /* current macro call context */ |
char ubuf[24]; /* buffer to print the number */ |
char ubuf[24]; /* buffer to print the number */ |
|
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 */ |
char *stesc; /* start of an escape sequence ('\\') */ |
char *stesc; /* start of an escape sequence ('\\') */ |
|
char *ep; /* end of comment string */ |
const char *stnam; /* start of the name, after "[(*" */ |
const char *stnam; /* start of the name, after "[(*" */ |
const char *cp; /* end of the name, e.g. before ']' */ |
const char *cp; /* end of the name, e.g. before ']' */ |
const char *res; /* the string to be substituted */ |
const char *res; /* the string to be substituted */ |
char *nbuf; /* new buffer to copy buf->buf to */ |
char *nbuf; /* new buffer to copy buf->buf to */ |
size_t maxl; /* expected length of the escape name */ |
size_t maxl; /* expected length of the escape name */ |
size_t naml; /* actual 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 */ |
enum mandoc_esc esc; /* type of the escape sequence */ |
int inaml; /* length returned from mandoc_escape() */ |
int inaml; /* length returned from mandoc_escape() */ |
int expand_count; /* to avoid infinite loops */ |
int expand_count; /* to avoid infinite loops */ |
int npos; /* position in numeric expression */ |
int npos; /* position in numeric expression */ |
int arg_complete; /* argument not interrupted by eol */ |
int arg_complete; /* argument not interrupted by eol */ |
|
int quote_args; /* true for \\$@, false for \\$* */ |
int done; /* no more input available */ |
int done; /* no more input available */ |
|
int deftype; /* type of definition to paste */ |
|
int rcsid; /* kind of RCS id seen */ |
|
char sign; /* increment number register */ |
char term; /* character terminating the escape */ |
char term; /* character terminating the escape */ |
|
|
/* Search forward for comments. */ |
/* Search forward for comments. */ |
Line 1178 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
Line 1189 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
stesc++; |
stesc++; |
if (*stesc != '"' && *stesc != '#') |
if (*stesc != '"' && *stesc != '#') |
continue; |
continue; |
cp = strchr(stesc--, '\0') - 1; |
|
if (*cp == '\n') { |
/* 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, ln, |
|
(int)(stesc - buf->buf) + 1, |
|
"%s", stesc + 1); |
|
r->man->meta.rcsids |= rcsid; |
|
} |
|
|
|
/* Handle trailing whitespace. */ |
|
|
|
ep = strchr(stesc--, '\0') - 1; |
|
if (*ep == '\n') { |
done = 1; |
done = 1; |
cp--; |
ep--; |
} |
} |
if (*cp == ' ' || *cp == '\t') |
if (*ep == ' ' || *ep == '\t') |
mandoc_msg(MANDOCERR_SPACE_EOL, r->parse, |
mandoc_msg(MANDOCERR_SPACE_EOL, |
ln, cp - buf->buf, NULL); |
ln, (int)(ep - buf->buf), NULL); |
while (stesc > start && stesc[-1] == ' ') |
|
|
/* |
|
* Save comments preceding the title macro |
|
* in the syntax tree. |
|
*/ |
|
|
|
if (r->format == 0) { |
|
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; |
|
} |
|
|
|
/* Line continuation with comment. */ |
|
|
|
if (stesc[1] == '#') { |
|
*stesc = '\0'; |
|
return ROFF_IGN | ROFF_APPEND; |
|
} |
|
|
|
/* Discard normal comments. */ |
|
|
|
while (stesc > start && stesc[-1] == ' ' && |
|
(stesc == start + 1 || stesc[-2] != '\\')) |
stesc--; |
stesc--; |
*stesc = '\0'; |
*stesc = '\0'; |
break; |
break; |
Line 1238 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
Line 1301 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
if (done) |
if (done) |
continue; |
continue; |
else |
else |
return ROFF_APPEND; |
return ROFF_IGN | ROFF_APPEND; |
} |
} |
|
|
/* Decide whether to expand or to check only. */ |
/* Decide whether to expand or to check only. */ |
Line 1247 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
Line 1310 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
cp = stesc + 1; |
cp = stesc + 1; |
switch (*cp) { |
switch (*cp) { |
case '*': |
case '*': |
|
case '$': |
res = NULL; |
res = NULL; |
break; |
break; |
case 'B': |
case 'B': |
Line 1254 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
Line 1318 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
term = cp[1]; |
term = cp[1]; |
/* FALLTHROUGH */ |
/* FALLTHROUGH */ |
case 'n': |
case 'n': |
|
sign = cp[1]; |
|
if (sign == '+' || sign == '-') |
|
cp++; |
res = ubuf; |
res = ubuf; |
break; |
break; |
default: |
default: |
Line 1261 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
Line 1328 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
if (esc == ESCAPE_ERROR || |
if (esc == ESCAPE_ERROR || |
(esc == ESCAPE_SPECIAL && |
(esc == ESCAPE_SPECIAL && |
mchars_spec2cp(stnam, inaml) < 0)) |
mchars_spec2cp(stnam, inaml) < 0)) |
mandoc_vmsg(MANDOCERR_ESC_BAD, |
mandoc_msg(MANDOCERR_ESC_BAD, |
r->parse, ln, (int)(stesc - buf->buf), |
ln, (int)(stesc - buf->buf), |
"%.*s", (int)(cp - stesc), stesc); |
"%.*s", (int)(cp - stesc), stesc); |
stesc--; |
stesc--; |
continue; |
continue; |
} |
} |
|
|
if (EXPAND_LIMIT < ++expand_count) { |
if (EXPAND_LIMIT < ++expand_count) { |
mandoc_msg(MANDOCERR_ROFFLOOP, r->parse, |
mandoc_msg(MANDOCERR_ROFFLOOP, |
ln, (int)(stesc - buf->buf), NULL); |
ln, (int)(stesc - buf->buf), NULL); |
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
Line 1310 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
Line 1377 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
arg_complete = 1; |
arg_complete = 1; |
while (maxl == 0 || naml < maxl) { |
while (maxl == 0 || naml < maxl) { |
if (*cp == '\0') { |
if (*cp == '\0') { |
mandoc_msg(MANDOCERR_ESC_BAD, r->parse, |
mandoc_msg(MANDOCERR_ESC_BAD, ln, |
ln, (int)(stesc - buf->buf), stesc); |
(int)(stesc - buf->buf), "%s", stesc); |
arg_complete = 0; |
arg_complete = 0; |
break; |
break; |
} |
} |
Line 1342 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
Line 1409 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
|
|
switch (stesc[1]) { |
switch (stesc[1]) { |
case '*': |
case '*': |
if (arg_complete) |
if (arg_complete) { |
res = roff_getstrn(r, stnam, naml); |
deftype = ROFFDEF_USER | ROFFDEF_PRE; |
|
res = roff_getstrn(r, stnam, naml, &deftype); |
|
|
|
/* |
|
* If not overriden, let \*(.T |
|
* through to the formatters. |
|
*/ |
|
|
|
if (res == NULL && naml == 2 && |
|
stnam[0] == '.' && stnam[1] == 'T') { |
|
roff_setstrn(&r->strtab, |
|
".T", 2, NULL, 0, 0); |
|
stesc--; |
|
continue; |
|
} |
|
} |
break; |
break; |
|
case '$': |
|
if (r->mstackpos < 0) { |
|
mandoc_msg(MANDOCERR_ARG_UNDEF, ln, |
|
(int)(stesc - buf->buf), "%.3s", stesc); |
|
break; |
|
} |
|
ctx = r->mstack + r->mstackpos; |
|
npos = stesc[2] - '1'; |
|
if (npos >= 0 && npos <= 8) { |
|
res = npos < ctx->argc ? |
|
ctx->argv[npos] : ""; |
|
break; |
|
} |
|
if (stesc[2] == '*') |
|
quote_args = 0; |
|
else if (stesc[2] == '@') |
|
quote_args = 1; |
|
else { |
|
mandoc_msg(MANDOCERR_ARG_NONUM, ln, |
|
(int)(stesc - buf->buf), "%.3s", stesc); |
|
break; |
|
} |
|
asz = 0; |
|
for (npos = 0; npos < ctx->argc; npos++) { |
|
if (npos) |
|
asz++; /* blank */ |
|
if (quote_args) |
|
asz += 2; /* quotes */ |
|
asz += strlen(ctx->argv[npos]); |
|
} |
|
if (asz != 3) { |
|
rsz = buf->sz - (stesc - buf->buf) - 3; |
|
if (asz < 3) |
|
memmove(stesc + asz, stesc + 3, rsz); |
|
buf->sz += asz - 3; |
|
nbuf = mandoc_realloc(buf->buf, buf->sz); |
|
start = nbuf + pos; |
|
stesc = nbuf + (stesc - buf->buf); |
|
buf->buf = nbuf; |
|
if (asz > 3) |
|
memmove(stesc + asz, stesc + 3, rsz); |
|
} |
|
for (npos = 0; npos < ctx->argc; npos++) { |
|
if (npos) |
|
*stesc++ = ' '; |
|
if (quote_args) |
|
*stesc++ = '"'; |
|
cp = ctx->argv[npos]; |
|
while (*cp != '\0') |
|
*stesc++ = *cp++; |
|
if (quote_args) |
|
*stesc++ = '"'; |
|
} |
|
continue; |
case 'B': |
case 'B': |
npos = 0; |
npos = 0; |
ubuf[0] = arg_complete && |
ubuf[0] = arg_complete && |
Line 1356 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
Line 1492 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
case 'n': |
case 'n': |
if (arg_complete) |
if (arg_complete) |
(void)snprintf(ubuf, sizeof(ubuf), "%d", |
(void)snprintf(ubuf, sizeof(ubuf), "%d", |
roff_getregn(r, stnam, naml)); |
roff_getregn(r, stnam, naml, sign)); |
else |
else |
ubuf[0] = '\0'; |
ubuf[0] = '\0'; |
break; |
break; |
Line 1368 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
Line 1504 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
} |
} |
|
|
if (res == NULL) { |
if (res == NULL) { |
mandoc_vmsg(MANDOCERR_STR_UNDEF, |
if (stesc[1] == '*') |
r->parse, ln, (int)(stesc - buf->buf), |
mandoc_msg(MANDOCERR_STR_UNDEF, |
"%.*s", (int)naml, stnam); |
ln, (int)(stesc - buf->buf), |
|
"%.*s", (int)naml, stnam); |
res = ""; |
res = ""; |
} else if (buf->sz + strlen(res) > SHRT_MAX) { |
} else if (buf->sz + strlen(res) > SHRT_MAX) { |
mandoc_msg(MANDOCERR_ROFFLOOP, r->parse, |
mandoc_msg(MANDOCERR_ROFFLOOP, |
ln, (int)(stesc - buf->buf), NULL); |
ln, (int)(stesc - buf->buf), NULL); |
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
Line 1397 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
Line 1534 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
/* |
/* |
* Process text streams. |
* Process text streams. |
*/ |
*/ |
static enum rofferr |
static int |
roff_parsetext(struct roff *r, struct buf *buf, int pos, int *offs) |
roff_parsetext(struct roff *r, struct buf *buf, int pos, int *offs) |
{ |
{ |
size_t sz; |
size_t sz; |
Line 1463 roff_parsetext(struct roff *r, struct buf *buf, int po |
|
Line 1600 roff_parsetext(struct roff *r, struct buf *buf, int po |
|
return ROFF_CONT; |
return ROFF_CONT; |
} |
} |
|
|
enum rofferr |
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) |
{ |
{ |
enum roff_tok t; |
enum roff_tok t; |
enum rofferr e; |
int e; |
int pos; /* parse point */ |
int pos; /* parse point */ |
int spos; /* saved parse point for messages */ |
int spos; /* saved parse point for messages */ |
int ppos; /* original offset in buf->buf */ |
int ppos; /* original offset in buf->buf */ |
Line 1489 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
Line 1626 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_res(r, buf, ln, pos); |
if (e == ROFF_IGN || e == ROFF_APPEND) |
if ((e & ROFF_MASK) == ROFF_IGN) |
return e; |
return e; |
assert(e == ROFF_CONT); |
assert(e == ROFF_CONT); |
|
|
Line 1506 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
Line 1643 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
if (r->last != NULL && ! ctl) { |
if (r->last != NULL && ! ctl) { |
t = r->last->tok; |
t = r->last->tok; |
e = (*roffs[t].text)(r, t, buf, ln, pos, pos, offs); |
e = (*roffs[t].text)(r, t, buf, ln, pos, pos, offs); |
if (e == ROFF_IGN) |
if ((e & ROFF_MASK) == ROFF_IGN) |
return e; |
return e; |
assert(e == ROFF_CONT); |
e &= ~ROFF_MASK; |
|
} else |
|
e = ROFF_IGN; |
|
if (r->eqn != NULL && strncmp(buf->buf + ppos, ".EN", 3)) { |
|
eqn_read(r->eqn, buf->buf + ppos); |
|
return e; |
} |
} |
if (r->eqn != NULL) |
if (r->tbl != NULL && (ctl == 0 || buf->buf[pos] == '\0')) { |
return eqn_read(&r->eqn, ln, buf->buf, ppos, offs); |
tbl_read(r->tbl, ln, buf->buf, ppos); |
if (r->tbl != NULL && ( ! ctl || buf->buf[pos] == '\0')) |
roff_addtbl(r->man, ln, r->tbl); |
return tbl_read(r->tbl, ln, buf->buf, ppos); |
return e; |
|
} |
if ( ! ctl) |
if ( ! ctl) |
return roff_parsetext(r, buf, pos, offs); |
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 1544 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
Line 1686 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
|
|
/* Tables ignore most macros. */ |
/* Tables ignore most macros. */ |
|
|
if (r->tbl != NULL && (t == TOKEN_NONE || t == ROFF_TS)) { |
if (r->tbl != NULL && (t == TOKEN_NONE || t == ROFF_TS || |
mandoc_msg(MANDOCERR_TBLMACRO, r->parse, |
t == ROFF_br || t == ROFF_ce || t == ROFF_rj || t == ROFF_sp)) { |
ln, pos, buf->buf + spos); |
mandoc_msg(MANDOCERR_TBLMACRO, |
if (t == ROFF_TS) |
ln, pos, "%s", buf->buf + spos); |
|
if (t != 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++; |
while (buf->buf[pos] == ' ') |
while (buf->buf[pos] == ' ') |
pos++; |
pos++; |
return tbl_read(r->tbl, ln, buf->buf, pos); |
tbl_read(r->tbl, ln, buf->buf, pos); |
|
roff_addtbl(r->man, ln, r->tbl); |
|
return ROFF_IGN; |
} |
} |
|
|
/* For now, let high level macros abort .ce mode. */ |
/* For now, let high level macros abort .ce mode. */ |
|
|
if (ctl && roffce_node != NULL && |
if (ctl && roffce_node != NULL && |
(t == TOKEN_NONE || t == ROFF_EQ || t == ROFF_TS)) { |
(t == TOKEN_NONE || t == ROFF_Dd || t == ROFF_EQ || |
|
t == ROFF_TH || t == 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 1579 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
Line 1725 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
return (*roffs[t].proc)(r, t, buf, ln, spos, pos, offs); |
return (*roffs[t].proc)(r, t, buf, ln, spos, pos, offs); |
} |
} |
|
|
|
/* |
|
* Internal interface function to tell the roff parser that execution |
|
* of the current macro ended. This is required because macro |
|
* definitions usually do not end with a .return request. |
|
*/ |
void |
void |
roff_endparse(struct roff *r) |
roff_userret(struct roff *r) |
{ |
{ |
|
struct mctx *ctx; |
|
int i; |
|
|
if (r->last) |
assert(r->mstackpos >= 0); |
mandoc_msg(MANDOCERR_BLK_NOEND, r->parse, |
ctx = r->mstack + r->mstackpos; |
r->last->line, r->last->col, |
for (i = 0; i < ctx->argc; i++) |
roff_name[r->last->tok]); |
free(ctx->argv[i]); |
|
ctx->argc = 0; |
|
r->mstackpos--; |
|
} |
|
|
if (r->eqn) { |
void |
mandoc_msg(MANDOCERR_BLK_NOEND, r->parse, |
roff_endparse(struct roff *r) |
r->eqn->eqn.ln, r->eqn->eqn.pos, "EQ"); |
{ |
eqn_end(&r->eqn); |
if (r->last != NULL) |
|
mandoc_msg(MANDOCERR_BLK_NOEND, r->last->line, |
|
r->last->col, "%s", roff_name[r->last->tok]); |
|
|
|
if (r->eqn != NULL) { |
|
mandoc_msg(MANDOCERR_BLK_NOEND, |
|
r->eqn->node->line, r->eqn->node->pos, "EQ"); |
|
eqn_parse(r->eqn); |
|
r->eqn = NULL; |
} |
} |
|
|
if (r->tbl) { |
if (r->tbl != NULL) { |
mandoc_msg(MANDOCERR_BLK_NOEND, r->parse, |
tbl_end(r->tbl, 1); |
r->tbl->line, r->tbl->pos, "TS"); |
r->tbl = NULL; |
tbl_end(&r->tbl); |
|
} |
} |
} |
} |
|
|
Line 1611 roff_parse(struct roff *r, char *buf, int *pos, int ln |
|
Line 1774 roff_parse(struct roff *r, char *buf, int *pos, int ln |
|
char *cp; |
char *cp; |
const char *mac; |
const char *mac; |
size_t maclen; |
size_t maclen; |
|
int deftype; |
enum roff_tok t; |
enum roff_tok t; |
|
|
cp = buf + *pos; |
cp = buf + *pos; |
Line 1621 roff_parse(struct roff *r, char *buf, int *pos, int ln |
|
Line 1785 roff_parse(struct roff *r, char *buf, int *pos, int ln |
|
mac = cp; |
mac = cp; |
maclen = roff_getname(r, &cp, ln, ppos); |
maclen = roff_getname(r, &cp, ln, ppos); |
|
|
t = (r->current_string = roff_getstrn(r, mac, maclen)) ? |
deftype = ROFFDEF_USER | ROFFDEF_REN; |
ROFF_USERDEF : |
r->current_string = roff_getstrn(r, mac, maclen, &deftype); |
(r->current_string = roff_getrenn(r, mac, maclen)) ? |
switch (deftype) { |
ROFF_RENAMED : roffhash_find(r->reqtab, mac, maclen); |
case ROFFDEF_USER: |
|
t = ROFF_USERDEF; |
|
break; |
|
case ROFFDEF_REN: |
|
t = ROFF_RENAMED; |
|
break; |
|
default: |
|
t = roffhash_find(r->reqtab, mac, maclen); |
|
break; |
|
} |
if (t != TOKEN_NONE) |
if (t != TOKEN_NONE) |
*pos = cp - buf; |
*pos = cp - buf; |
|
else if (deftype == ROFFDEF_UNDEF) { |
|
/* Using an undefined macro defines it to be empty. */ |
|
roff_setstrn(&r->strtab, mac, maclen, "", 0, 0); |
|
roff_setstrn(&r->rentab, mac, maclen, NULL, 0, 0); |
|
} |
return t; |
return t; |
} |
} |
|
|
/* --- handling of request blocks ----------------------------------------- */ |
/* --- handling of request blocks ----------------------------------------- */ |
|
|
static enum rofferr |
static int |
roff_cblock(ROFF_ARGS) |
roff_cblock(ROFF_ARGS) |
{ |
{ |
|
|
Line 1644 roff_cblock(ROFF_ARGS) |
|
Line 1820 roff_cblock(ROFF_ARGS) |
|
*/ |
*/ |
|
|
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; |
} |
} |
|
|
Line 1659 roff_cblock(ROFF_ARGS) |
|
Line 1834 roff_cblock(ROFF_ARGS) |
|
case ROFF_ig: |
case ROFF_ig: |
break; |
break; |
default: |
default: |
mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse, |
mandoc_msg(MANDOCERR_BLK_NOTOPEN, ln, ppos, ".."); |
ln, ppos, ".."); |
|
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
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_pop(r); |
Line 1674 roff_cblock(ROFF_ARGS) |
|
Line 1848 roff_cblock(ROFF_ARGS) |
|
|
|
} |
} |
|
|
static void |
static int |
roffnode_cleanscope(struct roff *r) |
roffnode_cleanscope(struct roff *r) |
{ |
{ |
|
int inloop; |
|
|
while (r->last) { |
inloop = 0; |
|
while (r->last != NULL) { |
if (--r->last->endspan != 0) |
if (--r->last->endspan != 0) |
break; |
break; |
roffnode_pop(r); |
inloop += roffnode_pop(r); |
} |
} |
|
return inloop; |
} |
} |
|
|
static void |
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; |
|
} |
} |
|
|
switch (r->last->tok) { |
switch (r->last->tok) { |
case ROFF_el: |
case ROFF_el: |
case ROFF_ie: |
case ROFF_ie: |
case ROFF_if: |
case ROFF_if: |
|
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; |
|
} |
} |
|
|
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; |
|
} |
} |
|
|
roffnode_pop(r); |
return roffnode_pop(r) + roffnode_cleanscope(r); |
roffnode_cleanscope(r); |
|
return; |
|
} |
} |
|
|
static enum rofferr |
static int |
roff_block(ROFF_ARGS) |
roff_block(ROFF_ARGS) |
{ |
{ |
const char *name; |
const char *name, *value; |
char *iname, *cp; |
char *call, *cp, *iname, *rname; |
size_t namesz; |
size_t csz, namesz, rsz; |
|
int deftype; |
|
|
/* Ignore groff compatibility mode for now. */ |
/* Ignore groff compatibility mode for now. */ |
|
|
Line 1750 roff_block(ROFF_ARGS) |
|
Line 1923 roff_block(ROFF_ARGS) |
|
/* Resolve the macro name argument if it is indirect. */ |
/* Resolve the macro name argument if it is indirect. */ |
|
|
if (namesz && (tok == ROFF_dei || tok == ROFF_ami)) { |
if (namesz && (tok == ROFF_dei || tok == ROFF_ami)) { |
if ((name = roff_getstrn(r, iname, namesz)) == NULL) { |
deftype = ROFFDEF_USER; |
mandoc_vmsg(MANDOCERR_STR_UNDEF, |
name = roff_getstrn(r, iname, namesz, &deftype); |
r->parse, ln, (int)(iname - buf->buf), |
if (name == NULL) { |
|
mandoc_msg(MANDOCERR_STR_UNDEF, |
|
ln, (int)(iname - buf->buf), |
"%.*s", (int)namesz, iname); |
"%.*s", (int)namesz, iname); |
namesz = 0; |
namesz = 0; |
} else |
} else |
Line 1761 roff_block(ROFF_ARGS) |
|
Line 1936 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 1774 roff_block(ROFF_ARGS) |
|
Line 1949 roff_block(ROFF_ARGS) |
|
* appended from roff_block_text() in multiline mode. |
* appended from roff_block_text() in multiline mode. |
*/ |
*/ |
|
|
if (tok == ROFF_de || tok == ROFF_dei) |
if (tok == ROFF_de || tok == ROFF_dei) { |
roff_setstrn(&r->strtab, name, namesz, "", 0, 0); |
roff_setstrn(&r->strtab, name, namesz, "", 0, 0); |
|
roff_setstrn(&r->rentab, name, namesz, NULL, 0, 0); |
|
} else if (tok == ROFF_am || tok == ROFF_ami) { |
|
deftype = ROFFDEF_ANY; |
|
value = roff_getstrn(r, iname, namesz, &deftype); |
|
switch (deftype) { /* Before appending, ... */ |
|
case ROFFDEF_PRE: /* copy predefined to user-defined. */ |
|
roff_setstrn(&r->strtab, name, namesz, |
|
value, strlen(value), 0); |
|
break; |
|
case ROFFDEF_REN: /* call original standard macro. */ |
|
csz = mandoc_asprintf(&call, ".%.*s \\$* \\\"\n", |
|
(int)strlen(value), value); |
|
roff_setstrn(&r->strtab, name, namesz, call, csz, 0); |
|
roff_setstrn(&r->rentab, name, namesz, NULL, 0, 0); |
|
free(call); |
|
break; |
|
case ROFFDEF_STD: /* rename and call standard macro. */ |
|
rsz = mandoc_asprintf(&rname, "__%s_renamed", name); |
|
roff_setstrn(&r->rentab, rname, rsz, name, namesz, 0); |
|
csz = mandoc_asprintf(&call, ".%.*s \\$* \\\"\n", |
|
(int)rsz, rname); |
|
roff_setstrn(&r->strtab, name, namesz, call, csz, 0); |
|
free(call); |
|
free(rname); |
|
break; |
|
default: |
|
break; |
|
} |
|
} |
|
|
if (*cp == '\0') |
if (*cp == '\0') |
return ROFF_IGN; |
return ROFF_IGN; |
Line 1788 roff_block(ROFF_ARGS) |
|
Line 1992 roff_block(ROFF_ARGS) |
|
/* Resolve the end marker if it is indirect. */ |
/* Resolve the end marker if it is indirect. */ |
|
|
if (namesz && (tok == ROFF_dei || tok == ROFF_ami)) { |
if (namesz && (tok == ROFF_dei || tok == ROFF_ami)) { |
if ((name = roff_getstrn(r, iname, namesz)) == NULL) { |
deftype = ROFFDEF_USER; |
mandoc_vmsg(MANDOCERR_STR_UNDEF, |
name = roff_getstrn(r, iname, namesz, &deftype); |
r->parse, ln, (int)(iname - buf->buf), |
if (name == NULL) { |
|
mandoc_msg(MANDOCERR_STR_UNDEF, |
|
ln, (int)(iname - buf->buf), |
"%.*s", (int)namesz, iname); |
"%.*s", (int)namesz, iname); |
namesz = 0; |
namesz = 0; |
} else |
} else |
Line 1802 roff_block(ROFF_ARGS) |
|
Line 2008 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; |
} |
} |
|
|
static enum rofferr |
static int |
roff_block_sub(ROFF_ARGS) |
roff_block_sub(ROFF_ARGS) |
{ |
{ |
enum roff_tok t; |
enum roff_tok t; |
Line 1862 roff_block_sub(ROFF_ARGS) |
|
Line 2068 roff_block_sub(ROFF_ARGS) |
|
return (*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs); |
return (*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs); |
} |
} |
|
|
static enum rofferr |
static int |
roff_block_text(ROFF_ARGS) |
roff_block_text(ROFF_ARGS) |
{ |
{ |
|
|
Line 1872 roff_block_text(ROFF_ARGS) |
|
Line 2078 roff_block_text(ROFF_ARGS) |
|
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static int |
roff_cond_sub(ROFF_ARGS) |
roff_cond_sub(ROFF_ARGS) |
{ |
{ |
enum roff_tok t; |
|
char *ep; |
char *ep; |
int rr; |
int endloop, irc, rr; |
|
enum roff_tok t; |
|
|
|
irc = ROFF_IGN; |
rr = r->last->rule; |
rr = r->last->rule; |
roffnode_cleanscope(r); |
endloop = tok != ROFF_while ? ROFF_IGN : |
t = roff_parse(r, buf->buf, &pos, ln, ppos); |
rr ? ROFF_LOOPCONT : ROFF_LOOPEXIT; |
|
if (roffnode_cleanscope(r)) |
|
irc |= endloop; |
|
|
/* |
/* |
* Fully handle known macros when they are structurally |
|
* required or when the conditional evaluated to true. |
|
*/ |
|
|
|
if (t != TOKEN_NONE && (rr || roffs[t].flags & ROFFMAC_STRUCT)) |
|
return (*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs); |
|
|
|
/* |
|
* If `\}' occurs on a macro line without a preceding macro, |
* If `\}' occurs on a macro line without a preceding macro, |
* drop the line completely. |
* drop the line completely. |
*/ |
*/ |
Line 1900 roff_cond_sub(ROFF_ARGS) |
|
Line 2101 roff_cond_sub(ROFF_ARGS) |
|
if (ep[0] == '\\' && ep[1] == '}') |
if (ep[0] == '\\' && ep[1] == '}') |
rr = 0; |
rr = 0; |
|
|
/* Always check for the closing delimiter `\}'. */ |
/* |
|
* The closing delimiter `\}' rewinds the conditional scope |
|
* but is otherwise ignored when interpreting the line. |
|
*/ |
|
|
while ((ep = strchr(ep, '\\')) != NULL) { |
while ((ep = strchr(ep, '\\')) != NULL) { |
if (*(++ep) == '}') { |
switch (ep[1]) { |
*ep = '&'; |
case '}': |
roff_ccond(r, ln, ep - buf->buf - 1); |
memmove(ep, ep + 2, strlen(ep + 2) + 1); |
} |
if (roff_ccond(r, ln, ep - buf->buf)) |
if (*ep != '\0') |
irc |= endloop; |
|
break; |
|
case '\0': |
++ep; |
++ep; |
|
break; |
|
default: |
|
ep += 2; |
|
break; |
|
} |
} |
} |
return rr ? ROFF_CONT : ROFF_IGN; |
|
|
/* |
|
* 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; |
} |
} |
|
|
static enum rofferr |
static int |
roff_cond_text(ROFF_ARGS) |
roff_cond_text(ROFF_ARGS) |
{ |
{ |
char *ep; |
char *ep; |
int rr; |
int endloop, irc, rr; |
|
|
|
irc = ROFF_IGN; |
rr = r->last->rule; |
rr = r->last->rule; |
roffnode_cleanscope(r); |
endloop = tok != ROFF_while ? ROFF_IGN : |
|
rr ? ROFF_LOOPCONT : ROFF_LOOPEXIT; |
|
if (roffnode_cleanscope(r)) |
|
irc |= endloop; |
|
|
|
/* |
|
* If `\}' occurs on a text line with neither preceding |
|
* nor following characters, drop the line completely. |
|
*/ |
|
|
ep = buf->buf + pos; |
ep = buf->buf + pos; |
|
if (strcmp(ep, "\\}") == 0) |
|
rr = 0; |
|
|
|
/* |
|
* The closing delimiter `\}' rewinds the conditional scope |
|
* but is otherwise ignored when interpreting the line. |
|
*/ |
|
|
while ((ep = strchr(ep, '\\')) != NULL) { |
while ((ep = strchr(ep, '\\')) != NULL) { |
if (*(++ep) == '}') { |
switch (ep[1]) { |
*ep = '&'; |
case '}': |
roff_ccond(r, ln, ep - buf->buf - 1); |
memmove(ep, ep + 2, strlen(ep + 2) + 1); |
} |
if (roff_ccond(r, ln, ep - buf->buf)) |
if (*ep != '\0') |
irc |= endloop; |
|
break; |
|
case '\0': |
++ep; |
++ep; |
|
break; |
|
default: |
|
ep += 2; |
|
break; |
|
} |
} |
} |
return rr ? ROFF_CONT : ROFF_IGN; |
if (rr) |
|
irc |= ROFF_CONT; |
|
return irc; |
} |
} |
|
|
/* --- handling of numeric and conditional expressions -------------------- */ |
/* --- handling of numeric and conditional expressions -------------------- */ |
|
|
static int |
static int |
roff_evalcond(struct roff *r, int ln, char *v, int *pos) |
roff_evalcond(struct roff *r, int ln, char *v, int *pos) |
{ |
{ |
char *cp, *name; |
const char *start, *end; |
size_t sz; |
char *cp, *name; |
int number, savepos, wanttrue; |
size_t sz; |
|
int deftype, len, number, savepos, istrue, wanttrue; |
|
|
if ('!' == v[*pos]) { |
if ('!' == v[*pos]) { |
wanttrue = 0; |
wanttrue = 0; |
Line 2075 roff_evalcond(struct roff *r, int ln, char *v, int *po |
|
Line 2323 roff_evalcond(struct roff *r, int ln, char *v, int *po |
|
case 'o': |
case 'o': |
(*pos)++; |
(*pos)++; |
return wanttrue; |
return wanttrue; |
case 'c': |
|
case 'd': |
|
case 'e': |
case 'e': |
case 't': |
case 't': |
case 'v': |
case 'v': |
(*pos)++; |
(*pos)++; |
return !wanttrue; |
return !wanttrue; |
|
case 'c': |
|
do { |
|
(*pos)++; |
|
} while (v[*pos] == ' '); |
|
|
|
/* |
|
* Quirk for groff compatibility: |
|
* The horizontal tab is neither available nor unavailable. |
|
*/ |
|
|
|
if (v[*pos] == '\t') { |
|
(*pos)++; |
|
return 0; |
|
} |
|
|
|
/* Printable ASCII characters are available. */ |
|
|
|
if (v[*pos] != '\\') { |
|
(*pos)++; |
|
return wanttrue; |
|
} |
|
|
|
end = v + ++*pos; |
|
switch (mandoc_escape(&end, &start, &len)) { |
|
case ESCAPE_SPECIAL: |
|
istrue = mchars_spec2cp(start, len) != -1; |
|
break; |
|
case ESCAPE_UNICODE: |
|
istrue = 1; |
|
break; |
|
case ESCAPE_NUMBERED: |
|
istrue = mchars_num2char(start, len) != -1; |
|
break; |
|
default: |
|
istrue = !wanttrue; |
|
break; |
|
} |
|
*pos = end - v; |
|
return istrue == wanttrue; |
|
case 'd': |
case 'r': |
case 'r': |
cp = name = v + ++*pos; |
cp = v + *pos + 1; |
sz = roff_getname(r, &cp, ln, *pos); |
while (*cp == ' ') |
|
cp++; |
|
name = cp; |
|
sz = roff_getname(r, &cp, ln, cp - v); |
|
if (sz == 0) |
|
istrue = 0; |
|
else if (v[*pos] == 'r') |
|
istrue = roff_hasregn(r, name, sz); |
|
else { |
|
deftype = ROFFDEF_ANY; |
|
roff_getstrn(r, name, sz, &deftype); |
|
istrue = !!deftype; |
|
} |
*pos = cp - v; |
*pos = cp - v; |
return (sz && roff_hasregn(r, name, sz)) == wanttrue; |
return istrue == wanttrue; |
default: |
default: |
break; |
break; |
} |
} |
Line 2100 roff_evalcond(struct roff *r, int ln, char *v, int *po |
|
Line 2398 roff_evalcond(struct roff *r, int ln, char *v, int *po |
|
return 0; |
return 0; |
} |
} |
|
|
static enum rofferr |
static int |
roff_line_ignore(ROFF_ARGS) |
roff_line_ignore(ROFF_ARGS) |
{ |
{ |
|
|
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static int |
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; |
} |
} |
|
|
static enum rofferr |
static int |
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; |
} |
} |
|
|
static enum rofferr |
static int |
roff_cond(ROFF_ARGS) |
roff_cond(ROFF_ARGS) |
{ |
{ |
|
int irc; |
|
|
roffnode_push(r, tok, NULL, ln, ppos); |
roffnode_push(r, tok, NULL, ln, ppos); |
|
|
Line 2166 roff_cond(ROFF_ARGS) |
|
Line 2463 roff_cond(ROFF_ARGS) |
|
* Determine scope. |
* Determine scope. |
* If there is nothing on the line after the conditional, |
* If there is nothing on the line after the conditional, |
* not even whitespace, use next-line scope. |
* not even whitespace, use next-line scope. |
|
* Except that .while does not support next-line scope. |
*/ |
*/ |
|
|
if (buf->buf[pos] == '\0') { |
if (buf->buf[pos] == '\0' && tok != ROFF_while) { |
r->last->endspan = 2; |
r->last->endspan = 2; |
goto out; |
goto out; |
} |
} |
Line 2193 roff_cond(ROFF_ARGS) |
|
Line 2491 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; |
|
|
out: |
out: |
*offs = pos; |
*offs = pos; |
return ROFF_RERUN; |
irc = ROFF_RERUN; |
|
if (tok == ROFF_while) |
|
irc |= ROFF_WHILE; |
|
return irc; |
} |
} |
|
|
static enum rofferr |
static int |
roff_ds(ROFF_ARGS) |
roff_ds(ROFF_ARGS) |
{ |
{ |
char *string; |
char *string; |
Line 2238 roff_ds(ROFF_ARGS) |
|
Line 2539 roff_ds(ROFF_ARGS) |
|
/* The rest is the value. */ |
/* The rest is the value. */ |
roff_setstrn(&r->strtab, name, namesz, string, strlen(string), |
roff_setstrn(&r->strtab, name, namesz, string, strlen(string), |
ROFF_as == tok); |
ROFF_as == tok); |
|
roff_setstrn(&r->rentab, name, namesz, NULL, 0, 0); |
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
Line 2393 roff_evalnum(struct roff *r, int ln, const char *v, |
|
Line 2695 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 2402 roff_evalnum(struct roff *r, int ln, const char *v, |
|
Line 2704 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 2452 roff_evalnum(struct roff *r, int ln, const char *v, |
|
Line 2754 roff_evalnum(struct roff *r, int ln, const char *v, |
|
void |
void |
roff_setreg(struct roff *r, const char *name, int val, char sign) |
roff_setreg(struct roff *r, const char *name, int val, char sign) |
{ |
{ |
|
roff_setregn(r, name, strlen(name), val, sign, INT_MIN); |
|
} |
|
|
|
static void |
|
roff_setregn(struct roff *r, const char *name, size_t len, |
|
int val, char sign, int step) |
|
{ |
struct roffreg *reg; |
struct roffreg *reg; |
|
|
/* Search for an existing register with the same name. */ |
/* Search for an existing register with the same name. */ |
reg = r->regtab; |
reg = r->regtab; |
|
|
while (reg && strcmp(name, reg->key.p)) |
while (reg != NULL && (reg->key.sz != len || |
|
strncmp(reg->key.p, name, len) != 0)) |
reg = reg->next; |
reg = reg->next; |
|
|
if (NULL == reg) { |
if (NULL == reg) { |
/* Create a new register. */ |
/* Create a new register. */ |
reg = mandoc_malloc(sizeof(struct roffreg)); |
reg = mandoc_malloc(sizeof(struct roffreg)); |
reg->key.p = mandoc_strdup(name); |
reg->key.p = mandoc_strndup(name, len); |
reg->key.sz = strlen(name); |
reg->key.sz = len; |
reg->val = 0; |
reg->val = 0; |
|
reg->step = 0; |
reg->next = r->regtab; |
reg->next = r->regtab; |
r->regtab = reg; |
r->regtab = reg; |
} |
} |
Line 2476 roff_setreg(struct roff *r, const char *name, int val, |
|
Line 2787 roff_setreg(struct roff *r, const char *name, int val, |
|
reg->val -= val; |
reg->val -= val; |
else |
else |
reg->val = val; |
reg->val = val; |
|
if (step != INT_MIN) |
|
reg->step = step; |
} |
} |
|
|
/* |
/* |
Line 2490 roff_getregro(const struct roff *r, const char *name) |
|
Line 2803 roff_getregro(const struct roff *r, const char *name) |
|
|
|
switch (*name) { |
switch (*name) { |
case '$': /* Number of arguments of the last macro evaluated. */ |
case '$': /* Number of arguments of the last macro evaluated. */ |
return r->argc; |
return r->mstackpos < 0 ? 0 : r->mstack[r->mstackpos].argc; |
case 'A': /* ASCII approximation mode is always off. */ |
case 'A': /* ASCII approximation mode is always off. */ |
return 0; |
return 0; |
case 'g': /* Groff compatibility mode is always on. */ |
case 'g': /* Groff compatibility mode is always on. */ |
Line 2509 roff_getregro(const struct roff *r, const char *name) |
|
Line 2822 roff_getregro(const struct roff *r, const char *name) |
|
} |
} |
|
|
int |
int |
roff_getreg(const struct roff *r, const char *name) |
roff_getreg(struct roff *r, const char *name) |
{ |
{ |
struct roffreg *reg; |
return roff_getregn(r, name, strlen(name), '\0'); |
int val; |
|
|
|
if ('.' == name[0] && '\0' != name[1] && '\0' == name[2]) { |
|
val = roff_getregro(r, name + 1); |
|
if (-1 != val) |
|
return val; |
|
} |
|
|
|
for (reg = r->regtab; reg; reg = reg->next) |
|
if (0 == strcmp(name, reg->key.p)) |
|
return reg->val; |
|
|
|
return 0; |
|
} |
} |
|
|
static int |
static int |
roff_getregn(const struct roff *r, const char *name, size_t len) |
roff_getregn(struct roff *r, const char *name, size_t len, char sign) |
{ |
{ |
struct roffreg *reg; |
struct roffreg *reg; |
int val; |
int val; |
Line 2539 roff_getregn(const struct roff *r, const char *name, s |
|
Line 2839 roff_getregn(const struct roff *r, const char *name, s |
|
return val; |
return val; |
} |
} |
|
|
for (reg = r->regtab; reg; reg = reg->next) |
for (reg = r->regtab; reg; reg = reg->next) { |
if (len == reg->key.sz && |
if (len == reg->key.sz && |
0 == strncmp(name, reg->key.p, len)) |
0 == strncmp(name, reg->key.p, len)) { |
|
switch (sign) { |
|
case '+': |
|
reg->val += reg->step; |
|
break; |
|
case '-': |
|
reg->val -= reg->step; |
|
break; |
|
default: |
|
break; |
|
} |
return reg->val; |
return reg->val; |
|
} |
|
} |
|
|
|
roff_setregn(r, name, len, 0, '\0', INT_MIN); |
return 0; |
return 0; |
} |
} |
|
|
Line 2580 roff_freereg(struct roffreg *reg) |
|
Line 2893 roff_freereg(struct roffreg *reg) |
|
} |
} |
} |
} |
|
|
static enum rofferr |
static int |
roff_nr(ROFF_ARGS) |
roff_nr(ROFF_ARGS) |
{ |
{ |
char *key, *val; |
char *key, *val, *step; |
size_t keysz; |
size_t keysz; |
int iv; |
int iv, is, len; |
char sign; |
char sign; |
|
|
key = val = buf->buf + pos; |
key = val = buf->buf + pos; |
Line 2595 roff_nr(ROFF_ARGS) |
|
Line 2908 roff_nr(ROFF_ARGS) |
|
keysz = roff_getname(r, &val, ln, pos); |
keysz = roff_getname(r, &val, ln, pos); |
if (key[keysz] == '\\') |
if (key[keysz] == '\\') |
return ROFF_IGN; |
return ROFF_IGN; |
key[keysz] = '\0'; |
|
|
|
sign = *val; |
sign = *val; |
if (sign == '+' || sign == '-') |
if (sign == '+' || sign == '-') |
val++; |
val++; |
|
|
if (roff_evalnum(r, ln, val, NULL, &iv, ROFFNUM_SCALE)) |
len = 0; |
roff_setreg(r, key, iv, sign); |
if (roff_evalnum(r, ln, val, &len, &iv, ROFFNUM_SCALE) == 0) |
|
return ROFF_IGN; |
|
|
|
step = val + len; |
|
while (isspace((unsigned char)*step)) |
|
step++; |
|
if (roff_evalnum(r, ln, step, NULL, &is, 0) == 0) |
|
is = INT_MIN; |
|
|
|
roff_setregn(r, key, keysz, iv, sign, is); |
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static int |
roff_rr(ROFF_ARGS) |
roff_rr(ROFF_ARGS) |
{ |
{ |
struct roffreg *reg, **prev; |
struct roffreg *reg, **prev; |
Line 2637 roff_rr(ROFF_ARGS) |
|
Line 2957 roff_rr(ROFF_ARGS) |
|
|
|
/* --- handler functions for roff requests -------------------------------- */ |
/* --- handler functions for roff requests -------------------------------- */ |
|
|
static enum rofferr |
static int |
roff_rm(ROFF_ARGS) |
roff_rm(ROFF_ARGS) |
{ |
{ |
const char *name; |
const char *name; |
Line 2649 roff_rm(ROFF_ARGS) |
|
Line 2969 roff_rm(ROFF_ARGS) |
|
name = cp; |
name = cp; |
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); |
if (name[namesz] == '\\') |
if (name[namesz] == '\\') |
break; |
break; |
} |
} |
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static int |
roff_it(ROFF_ARGS) |
roff_it(ROFF_ARGS) |
{ |
{ |
int iv; |
int iv; |
Line 2663 roff_it(ROFF_ARGS) |
|
Line 2984 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 2684 roff_it(ROFF_ARGS) |
|
Line 3005 roff_it(ROFF_ARGS) |
|
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static int |
roff_Dd(ROFF_ARGS) |
roff_Dd(ROFF_ARGS) |
{ |
{ |
const char *const *cp; |
int mask; |
|
enum roff_tok t, te; |
|
|
if ((r->options & (MPARSE_MDOC | MPARSE_QUICK)) == 0) |
switch (tok) { |
for (cp = __mdoc_reserved; *cp; cp++) |
case ROFF_Dd: |
roff_setstr(r, *cp, NULL, 0); |
tok = MDOC_Dd; |
|
te = MDOC_MAX; |
if (r->format == 0) |
if (r->format == 0) |
r->format = MPARSE_MDOC; |
r->format = MPARSE_MDOC; |
|
mask = MPARSE_MDOC | MPARSE_QUICK; |
|
break; |
|
case ROFF_TH: |
|
tok = MAN_TH; |
|
te = MAN_MAX; |
|
if (r->format == 0) |
|
r->format = MPARSE_MAN; |
|
mask = MPARSE_QUICK; |
|
break; |
|
default: |
|
abort(); |
|
} |
|
if ((r->options & mask) == 0) |
|
for (t = tok; t < te; t++) |
|
roff_setstr(r, roff_name[t], NULL, 0); |
return ROFF_CONT; |
return ROFF_CONT; |
} |
} |
|
|
static enum rofferr |
static int |
roff_TH(ROFF_ARGS) |
|
{ |
|
const char *const *cp; |
|
|
|
if ((r->options & MPARSE_QUICK) == 0) |
|
for (cp = __man_reserved; *cp; cp++) |
|
roff_setstr(r, *cp, NULL, 0); |
|
|
|
if (r->format == 0) |
|
r->format = MPARSE_MAN; |
|
|
|
return ROFF_CONT; |
|
} |
|
|
|
static enum rofferr |
|
roff_TE(ROFF_ARGS) |
roff_TE(ROFF_ARGS) |
{ |
{ |
|
if (r->tbl == NULL) { |
if (NULL == r->tbl) |
mandoc_msg(MANDOCERR_BLK_NOTOPEN, ln, ppos, "TE"); |
mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse, |
return ROFF_IGN; |
ln, ppos, "TE"); |
} |
else if ( ! tbl_end(&r->tbl)) { |
if (tbl_end(r->tbl, 0) == 0) { |
|
r->tbl = NULL; |
free(buf->buf); |
free(buf->buf); |
buf->buf = mandoc_strdup(".sp"); |
buf->buf = mandoc_strdup(".sp"); |
buf->sz = 4; |
buf->sz = 4; |
|
*offs = 0; |
return ROFF_REPARSE; |
return ROFF_REPARSE; |
} |
} |
|
r->tbl = NULL; |
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static int |
roff_T_(ROFF_ARGS) |
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 2746 roff_T_(ROFF_ARGS) |
|
Line 3069 roff_T_(ROFF_ARGS) |
|
/* |
/* |
* Handle in-line equation delimiters. |
* Handle in-line equation delimiters. |
*/ |
*/ |
static enum rofferr |
static int |
roff_eqndelim(struct roff *r, struct buf *buf, int pos) |
roff_eqndelim(struct roff *r, struct buf *buf, int pos) |
{ |
{ |
char *cp1, *cp2; |
char *cp1, *cp2; |
Line 2809 roff_eqndelim(struct roff *r, struct buf *buf, int pos |
|
Line 3132 roff_eqndelim(struct roff *r, struct buf *buf, int pos |
|
return ROFF_REPARSE; |
return ROFF_REPARSE; |
} |
} |
|
|
static enum rofferr |
static int |
roff_EQ(ROFF_ARGS) |
roff_EQ(ROFF_ARGS) |
{ |
{ |
struct eqn_node *e; |
struct roff_node *n; |
|
|
|
if (r->man->macroset == MACROSET_MAN) |
|
man_breakscope(r->man, ROFF_EQ); |
|
n = roff_node_alloc(r->man, ln, ppos, ROFFT_EQN, TOKEN_NONE); |
|
if (ln > r->man->last->line) |
|
n->flags |= NODE_LINE; |
|
n->eqn = eqn_box_new(); |
|
roff_node_append(r->man, n); |
|
r->man->next = ROFF_NEXT_SIBLING; |
|
|
assert(r->eqn == NULL); |
assert(r->eqn == NULL); |
e = eqn_alloc(ppos, ln, r->parse); |
if (r->last_eqn == NULL) |
|
r->last_eqn = eqn_alloc(r->parse); |
|
else |
|
eqn_reset(r->last_eqn); |
|
r->eqn = r->last_eqn; |
|
r->eqn->node = n; |
|
|
if (r->last_eqn) { |
|
r->last_eqn->next = e; |
|
e->delim = r->last_eqn->delim; |
|
e->odelim = r->last_eqn->odelim; |
|
e->cdelim = r->last_eqn->cdelim; |
|
} else |
|
r->first_eqn = r->last_eqn = e; |
|
|
|
r->eqn = r->last_eqn = e; |
|
|
|
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; |
} |
} |
|
|
static enum rofferr |
static int |
roff_EN(ROFF_ARGS) |
roff_EN(ROFF_ARGS) |
{ |
{ |
|
if (r->eqn != NULL) { |
mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse, ln, ppos, "EN"); |
eqn_parse(r->eqn); |
|
r->eqn = NULL; |
|
} else |
|
mandoc_msg(MANDOCERR_BLK_NOTOPEN, ln, ppos, "EN"); |
|
if (buf->buf[pos] != '\0') |
|
mandoc_msg(MANDOCERR_ARG_SKIP, ln, pos, |
|
"EN %s", buf->buf + pos); |
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static int |
roff_TS(ROFF_ARGS) |
roff_TS(ROFF_ARGS) |
{ |
{ |
struct tbl_node *tbl; |
if (r->tbl != NULL) { |
|
mandoc_msg(MANDOCERR_BLK_BROKEN, ln, ppos, "TS breaks TS"); |
if (r->tbl) { |
tbl_end(r->tbl, 0); |
mandoc_msg(MANDOCERR_BLK_BROKEN, r->parse, |
|
ln, ppos, "TS breaks TS"); |
|
tbl_end(&r->tbl); |
|
} |
} |
|
r->tbl = tbl_alloc(ppos, ln, r->parse, r->last_tbl); |
tbl = tbl_alloc(ppos, ln, r->parse); |
if (r->last_tbl == NULL) |
|
r->first_tbl = r->tbl; |
if (r->last_tbl) |
r->last_tbl = r->tbl; |
r->last_tbl->next = tbl; |
|
else |
|
r->first_tbl = r->last_tbl = tbl; |
|
|
|
r->tbl = r->last_tbl = tbl; |
|
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static int |
roff_onearg(ROFF_ARGS) |
roff_onearg(ROFF_ARGS) |
{ |
{ |
struct roff_node *n; |
struct roff_node *n; |
Line 2872 roff_onearg(ROFF_ARGS) |
|
Line 3197 roff_onearg(ROFF_ARGS) |
|
int npos; |
int npos; |
|
|
if (r->man->flags & (MAN_BLINE | MAN_ELINE) && |
if (r->man->flags & (MAN_BLINE | MAN_ELINE) && |
(tok == ROFF_sp || tok == ROFF_ti)) |
(tok == ROFF_ce || tok == ROFF_rj || tok == ROFF_sp || |
|
tok == ROFF_ti)) |
man_breakscope(r->man, tok); |
man_breakscope(r->man, tok); |
|
|
if (tok == ROFF_ce && roffce_node != NULL) { |
if (roffce_node != NULL && (tok == ROFF_ce || tok == ROFF_rj)) { |
r->man->last = roffce_node; |
r->man->last = roffce_node; |
r->man->next = ROFF_NEXT_SIBLING; |
r->man->next = ROFF_NEXT_SIBLING; |
} |
} |
Line 2890 roff_onearg(ROFF_ARGS) |
|
Line 3216 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); |
} |
} |
|
|
if (tok == ROFF_ce) { |
if (tok == ROFF_ce || tok == ROFF_rj) { |
if (r->man->last->tok == ROFF_ce) { |
if (r->man->last->type == ROFFT_ELEM) { |
roff_word_alloc(r->man, ln, pos, "1"); |
roff_word_alloc(r->man, ln, pos, "1"); |
r->man->last->flags |= NODE_NOSRC; |
r->man->last->flags |= NODE_NOSRC; |
} |
} |
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 2923 roff_onearg(ROFF_ARGS) |
|
Line 3249 roff_onearg(ROFF_ARGS) |
|
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static int |
roff_manyarg(ROFF_ARGS) |
roff_manyarg(ROFF_ARGS) |
{ |
{ |
struct roff_node *n; |
struct roff_node *n; |
Line 2946 roff_manyarg(ROFF_ARGS) |
|
Line 3272 roff_manyarg(ROFF_ARGS) |
|
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static int |
|
roff_als(ROFF_ARGS) |
|
{ |
|
char *oldn, *newn, *end, *value; |
|
size_t oldsz, newsz, valsz; |
|
|
|
newn = oldn = buf->buf + pos; |
|
if (*newn == '\0') |
|
return ROFF_IGN; |
|
|
|
newsz = roff_getname(r, &oldn, ln, pos); |
|
if (newn[newsz] == '\\' || *oldn == '\0') |
|
return ROFF_IGN; |
|
|
|
end = oldn; |
|
oldsz = roff_getname(r, &end, ln, oldn - buf->buf); |
|
if (oldsz == 0) |
|
return ROFF_IGN; |
|
|
|
valsz = mandoc_asprintf(&value, ".%.*s \\$@\\\"\n", |
|
(int)oldsz, oldn); |
|
roff_setstrn(&r->strtab, newn, newsz, value, valsz, 0); |
|
roff_setstrn(&r->rentab, newn, newsz, NULL, 0, 0); |
|
free(value); |
|
return ROFF_IGN; |
|
} |
|
|
|
static int |
roff_br(ROFF_ARGS) |
roff_br(ROFF_ARGS) |
{ |
{ |
if (r->man->flags & (MAN_BLINE | MAN_ELINE)) |
if (r->man->flags & (MAN_BLINE | MAN_ELINE)) |
man_breakscope(r->man, ROFF_br); |
man_breakscope(r->man, ROFF_br); |
roff_elem_alloc(r->man, ln, ppos, ROFF_br); |
roff_elem_alloc(r->man, ln, ppos, ROFF_br); |
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 %s", roff_name[tok], buf->buf + pos); |
"%s %s", roff_name[tok], buf->buf + pos); |
r->man->last->flags |= NODE_LINE | NODE_VALID | NODE_ENDED; |
r->man->last->flags |= NODE_LINE | NODE_VALID | NODE_ENDED; |
r->man->next = ROFF_NEXT_SIBLING; |
r->man->next = ROFF_NEXT_SIBLING; |
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static int |
roff_cc(ROFF_ARGS) |
roff_cc(ROFF_ARGS) |
{ |
{ |
const char *p; |
const char *p; |
Line 2971 roff_cc(ROFF_ARGS) |
|
Line 3324 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; |
} |
} |
|
|
static enum rofferr |
static int |
|
roff_char(ROFF_ARGS) |
|
{ |
|
const char *p, *kp, *vp; |
|
size_t ksz, vsz; |
|
int font; |
|
|
|
/* Parse the character to be replaced. */ |
|
|
|
kp = buf->buf + pos; |
|
p = kp + 1; |
|
if (*kp == '\0' || (*kp == '\\' && |
|
mandoc_escape(&p, NULL, NULL) != ESCAPE_SPECIAL) || |
|
(*p != ' ' && *p != '\0')) { |
|
mandoc_msg(MANDOCERR_CHAR_ARG, ln, pos, "char %s", kp); |
|
return ROFF_IGN; |
|
} |
|
ksz = p - kp; |
|
while (*p == ' ') |
|
p++; |
|
|
|
/* |
|
* If the replacement string contains a font escape sequence, |
|
* we have to restore the font at the end. |
|
*/ |
|
|
|
vp = p; |
|
vsz = strlen(p); |
|
font = 0; |
|
while (*p != '\0') { |
|
if (*p++ != '\\') |
|
continue; |
|
switch (mandoc_escape(&p, NULL, NULL)) { |
|
case ESCAPE_FONT: |
|
case ESCAPE_FONTROMAN: |
|
case ESCAPE_FONTITALIC: |
|
case ESCAPE_FONTBOLD: |
|
case ESCAPE_FONTBI: |
|
case ESCAPE_FONTCW: |
|
case ESCAPE_FONTPREV: |
|
font++; |
|
break; |
|
default: |
|
break; |
|
} |
|
} |
|
if (font > 1) |
|
mandoc_msg(MANDOCERR_CHAR_FONT, |
|
ln, (int)(vp - buf->buf), "%s", vp); |
|
|
|
/* |
|
* Approximate the effect of .char using the .tr tables. |
|
* XXX In groff, .char and .tr interact differently. |
|
*/ |
|
|
|
if (ksz == 1) { |
|
if (r->xtab == NULL) |
|
r->xtab = mandoc_calloc(128, sizeof(*r->xtab)); |
|
assert((unsigned int)*kp < 128); |
|
free(r->xtab[(int)*kp].p); |
|
r->xtab[(int)*kp].sz = mandoc_asprintf(&r->xtab[(int)*kp].p, |
|
"%s%s", vp, font ? "\fP" : ""); |
|
} else { |
|
roff_setstrn(&r->xmbtab, kp, ksz, vp, vsz, 0); |
|
if (font) |
|
roff_setstrn(&r->xmbtab, kp, ksz, "\\fP", 3, 1); |
|
} |
|
return ROFF_IGN; |
|
} |
|
|
|
static int |
roff_ec(ROFF_ARGS) |
roff_ec(ROFF_ARGS) |
{ |
{ |
const char *p; |
const char *p; |
Line 2988 roff_ec(ROFF_ARGS) |
|
Line 3411 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; |
} |
} |
|
|
static enum rofferr |
static int |
roff_eo(ROFF_ARGS) |
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 enum rofferr |
static int |
|
roff_nop(ROFF_ARGS) |
|
{ |
|
while (buf->buf[pos] == ' ') |
|
pos++; |
|
*offs = pos; |
|
return ROFF_RERUN; |
|
} |
|
|
|
static int |
roff_tr(ROFF_ARGS) |
roff_tr(ROFF_ARGS) |
{ |
{ |
const char *p, *first, *second; |
const char *p, *first, *second; |
Line 3014 roff_tr(ROFF_ARGS) |
|
Line 3446 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 3025 roff_tr(ROFF_ARGS) |
|
Line 3457 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 3036 roff_tr(ROFF_ARGS) |
|
Line 3468 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 3066 roff_tr(ROFF_ARGS) |
|
Line 3498 roff_tr(ROFF_ARGS) |
|
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
/* |
|
* Implementation of the .return request. |
|
* There is no need to call roff_userret() from here. |
|
* The read module will call that after rewinding the reader stack |
|
* to the place from where the current macro was called. |
|
*/ |
|
static int |
|
roff_return(ROFF_ARGS) |
|
{ |
|
if (r->mstackpos >= 0) |
|
return ROFF_IGN | ROFF_USERRET; |
|
|
|
mandoc_msg(MANDOCERR_REQ_NOMAC, ln, ppos, "return"); |
|
return ROFF_IGN; |
|
} |
|
|
|
static int |
roff_rn(ROFF_ARGS) |
roff_rn(ROFF_ARGS) |
{ |
{ |
const char *value; |
const char *value; |
char *oldn, *newn, *end; |
char *oldn, *newn, *end; |
size_t oldsz, newsz; |
size_t oldsz, newsz; |
|
int deftype; |
|
|
oldn = newn = buf->buf + pos; |
oldn = newn = buf->buf + pos; |
if (*oldn == '\0') |
if (*oldn == '\0') |
Line 3086 roff_rn(ROFF_ARGS) |
|
Line 3535 roff_rn(ROFF_ARGS) |
|
if (newsz == 0) |
if (newsz == 0) |
return ROFF_IGN; |
return ROFF_IGN; |
|
|
/* |
deftype = ROFFDEF_ANY; |
* Rename a user-defined macro bearing the old name, |
value = roff_getstrn(r, oldn, oldsz, &deftype); |
* overriding an existing renamed high-level macro |
switch (deftype) { |
* bearing the new name, if that exists. |
case ROFFDEF_USER: |
*/ |
|
|
|
if ((value = roff_getstrn(r, oldn, oldsz)) != NULL) { |
|
roff_setstrn(&r->strtab, newn, newsz, value, strlen(value), 0); |
roff_setstrn(&r->strtab, newn, newsz, value, strlen(value), 0); |
roff_setstrn(&r->strtab, oldn, oldsz, NULL, 0, 0); |
roff_setstrn(&r->strtab, oldn, oldsz, NULL, 0, 0); |
roff_setstrn(&r->rentab, newn, newsz, NULL, 0, 0); |
roff_setstrn(&r->rentab, newn, newsz, NULL, 0, 0); |
return ROFF_IGN; |
break; |
} |
case ROFFDEF_PRE: |
|
roff_setstrn(&r->strtab, newn, newsz, value, strlen(value), 0); |
/* |
roff_setstrn(&r->rentab, newn, newsz, NULL, 0, 0); |
* Rename a high-level macro bearing the old name, |
break; |
* either renaming it a second time if it was already |
case ROFFDEF_REN: |
* renamed before, or renaming it for the first time. |
|
* In both cases, override an existing user-defined |
|
* macro bearing the new name, if that exists. |
|
*/ |
|
|
|
if ((value = roff_getrenn(r, oldn, oldsz)) != NULL) { |
|
roff_setstrn(&r->rentab, newn, newsz, value, strlen(value), 0); |
roff_setstrn(&r->rentab, newn, newsz, value, strlen(value), 0); |
roff_setstrn(&r->rentab, oldn, oldsz, NULL, 0, 0); |
roff_setstrn(&r->rentab, oldn, oldsz, NULL, 0, 0); |
} else |
roff_setstrn(&r->strtab, newn, newsz, NULL, 0, 0); |
|
break; |
|
case ROFFDEF_STD: |
roff_setstrn(&r->rentab, newn, newsz, oldn, oldsz, 0); |
roff_setstrn(&r->rentab, newn, newsz, oldn, oldsz, 0); |
roff_setstrn(&r->strtab, newn, newsz, NULL, 0, 0); |
roff_setstrn(&r->strtab, newn, newsz, NULL, 0, 0); |
|
break; |
|
default: |
|
roff_setstrn(&r->strtab, newn, newsz, NULL, 0, 0); |
|
roff_setstrn(&r->rentab, newn, newsz, NULL, 0, 0); |
|
break; |
|
} |
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static int |
|
roff_shift(ROFF_ARGS) |
|
{ |
|
struct mctx *ctx; |
|
int levels, i; |
|
|
|
levels = 1; |
|
if (buf->buf[pos] != '\0' && |
|
roff_evalnum(r, ln, buf->buf, &pos, &levels, 0) == 0) { |
|
mandoc_msg(MANDOCERR_CE_NONUM, |
|
ln, pos, "shift %s", buf->buf + pos); |
|
levels = 1; |
|
} |
|
if (r->mstackpos < 0) { |
|
mandoc_msg(MANDOCERR_REQ_NOMAC, ln, ppos, "shift"); |
|
return ROFF_IGN; |
|
} |
|
ctx = r->mstack + r->mstackpos; |
|
if (levels > ctx->argc) { |
|
mandoc_msg(MANDOCERR_SHIFT, |
|
ln, pos, "%d, but max is %d", levels, ctx->argc); |
|
levels = ctx->argc; |
|
} |
|
if (levels == 0) |
|
return ROFF_IGN; |
|
for (i = 0; i < levels; i++) |
|
free(ctx->argv[i]); |
|
ctx->argc -= levels; |
|
for (i = 0; i < ctx->argc; i++) |
|
ctx->argv[i] = ctx->argv[i + levels]; |
|
return ROFF_IGN; |
|
} |
|
|
|
static int |
roff_so(ROFF_ARGS) |
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 3132 roff_so(ROFF_ARGS) |
|
Line 3613 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 3148 roff_so(ROFF_ARGS) |
|
Line 3628 roff_so(ROFF_ARGS) |
|
|
|
/* --- user defined strings and macros ------------------------------------ */ |
/* --- user defined strings and macros ------------------------------------ */ |
|
|
static enum rofferr |
static int |
roff_userdef(ROFF_ARGS) |
roff_userdef(ROFF_ARGS) |
{ |
{ |
const char *arg[9], *ap; |
struct mctx *ctx; |
char *cp, *n1, *n2; |
char *arg, *ap, *dst, *src; |
int expand_count, i, ib, ie; |
size_t sz; |
size_t asz, rsz; |
|
|
|
/* |
/* Initialize a new macro stack context. */ |
* Collect pointers to macro argument strings |
|
* and NUL-terminate them. |
|
*/ |
|
|
|
r->argc = 0; |
if (++r->mstackpos == r->mstacksz) { |
cp = buf->buf + pos; |
r->mstack = mandoc_recallocarray(r->mstack, |
for (i = 0; i < 9; i++) { |
r->mstacksz, r->mstacksz + 8, sizeof(*r->mstack)); |
if (*cp == '\0') |
r->mstacksz += 8; |
arg[i] = ""; |
|
else { |
|
arg[i] = mandoc_getarg(r->parse, &cp, ln, &pos); |
|
r->argc = i + 1; |
|
} |
|
} |
} |
|
ctx = r->mstack + r->mstackpos; |
|
ctx->argsz = 0; |
|
ctx->argc = 0; |
|
ctx->argv = NULL; |
|
|
/* |
/* |
* Expand macro arguments. |
* Collect pointers to macro argument strings, |
|
* NUL-terminating them and escaping quotes. |
*/ |
*/ |
|
|
buf->sz = strlen(r->current_string) + 1; |
src = buf->buf + pos; |
n1 = n2 = cp = mandoc_malloc(buf->sz); |
while (*src != '\0') { |
memcpy(n1, r->current_string, buf->sz); |
if (ctx->argc == ctx->argsz) { |
expand_count = 0; |
ctx->argsz += 8; |
while (*cp != '\0') { |
ctx->argv = mandoc_reallocarray(ctx->argv, |
|
ctx->argsz, sizeof(*ctx->argv)); |
/* Scan ahead for the next argument invocation. */ |
|
|
|
if (*cp++ != '\\') |
|
continue; |
|
if (*cp++ != '$') |
|
continue; |
|
if (*cp == '*') { /* \\$* inserts all arguments */ |
|
ib = 0; |
|
ie = r->argc - 1; |
|
} else { /* \\$1 .. \\$9 insert one argument */ |
|
ib = ie = *cp - '1'; |
|
if (ib < 0 || ib > 8) |
|
continue; |
|
} |
} |
cp -= 2; |
arg = mandoc_getarg(r->parse, &src, ln, &pos); |
|
sz = 1; /* For the terminating NUL. */ |
/* |
for (ap = arg; *ap != '\0'; ap++) |
* Prevent infinite recursion. |
sz += *ap == '"' ? 4 : 1; |
*/ |
ctx->argv[ctx->argc++] = dst = mandoc_malloc(sz); |
|
for (ap = arg; *ap != '\0'; ap++) { |
if (cp >= n2) |
if (*ap == '"') { |
expand_count = 1; |
memcpy(dst, "\\(dq", 4); |
else if (++expand_count > EXPAND_LIMIT) { |
dst += 4; |
mandoc_msg(MANDOCERR_ROFFLOOP, r->parse, |
} else |
ln, (int)(cp - n1), NULL); |
*dst++ = *ap; |
free(buf->buf); |
|
buf->buf = n1; |
|
return ROFF_IGN; |
|
} |
} |
|
*dst = '\0'; |
/* |
|
* Determine the size of the expanded argument, |
|
* taking escaping of quotes into account. |
|
*/ |
|
|
|
asz = ie > ib ? ie - ib : 0; /* for blanks */ |
|
for (i = ib; i <= ie; i++) { |
|
for (ap = arg[i]; *ap != '\0'; ap++) { |
|
asz++; |
|
if (*ap == '"') |
|
asz += 3; |
|
} |
|
} |
|
if (asz != 3) { |
|
|
|
/* |
|
* Determine the size of the rest of the |
|
* unexpanded macro, including the NUL. |
|
*/ |
|
|
|
rsz = buf->sz - (cp - n1) - 3; |
|
|
|
/* |
|
* When shrinking, move before |
|
* releasing the storage. |
|
*/ |
|
|
|
if (asz < 3) |
|
memmove(cp + asz, cp + 3, rsz); |
|
|
|
/* |
|
* Resize the storage for the macro |
|
* and readjust the parse pointer. |
|
*/ |
|
|
|
buf->sz += asz - 3; |
|
n2 = mandoc_realloc(n1, buf->sz); |
|
cp = n2 + (cp - n1); |
|
n1 = n2; |
|
|
|
/* |
|
* When growing, make room |
|
* for the expanded argument. |
|
*/ |
|
|
|
if (asz > 3) |
|
memmove(cp + asz, cp + 3, rsz); |
|
} |
|
|
|
/* Copy the expanded argument, escaping quotes. */ |
|
|
|
n2 = cp; |
|
for (i = ib; i <= ie; i++) { |
|
for (ap = arg[i]; *ap != '\0'; ap++) { |
|
if (*ap == '"') { |
|
memcpy(n2, "\\(dq", 4); |
|
n2 += 4; |
|
} else |
|
*n2++ = *ap; |
|
} |
|
if (i < ie) |
|
*n2++ = ' '; |
|
} |
|
} |
} |
|
|
/* |
/* Replace the macro invocation by the macro definition. */ |
* Replace the macro invocation |
|
* by the expanded macro. |
|
*/ |
|
|
|
free(buf->buf); |
free(buf->buf); |
buf->buf = n1; |
buf->buf = mandoc_strdup(r->current_string); |
|
buf->sz = strlen(buf->buf) + 1; |
*offs = 0; |
*offs = 0; |
|
|
return buf->sz > 1 && buf->buf[buf->sz - 2] == '\n' ? |
return buf->sz > 1 && buf->buf[buf->sz - 2] == '\n' ? |
ROFF_REPARSE : ROFF_APPEND; |
ROFF_REPARSE | ROFF_USERCALL : ROFF_IGN | ROFF_APPEND; |
} |
} |
|
|
/* |
/* |
* Calling a high-level macro that was renamed with .rn. |
* Calling a high-level macro that was renamed with .rn. |
* r->current_string has already been set up by roff_parse(). |
* r->current_string has already been set up by roff_parse(). |
*/ |
*/ |
static enum rofferr |
static int |
roff_renamed(ROFF_ARGS) |
roff_renamed(ROFF_ARGS) |
{ |
{ |
char *nbuf; |
char *nbuf; |
|
|
buf->sz = mandoc_asprintf(&nbuf, ".%s %s", r->current_string, |
buf->sz = mandoc_asprintf(&nbuf, ".%s%s%s", r->current_string, |
buf->buf + pos) + 1; |
buf->buf[pos] == '\0' ? "" : " ", buf->buf + pos) + 1; |
free(buf->buf); |
free(buf->buf); |
buf->buf = nbuf; |
buf->buf = nbuf; |
|
*offs = 0; |
return ROFF_CONT; |
return ROFF_CONT; |
} |
} |
|
|
Line 3330 roff_getname(struct roff *r, char **cpp, int ln, int p |
|
Line 3726 roff_getname(struct roff *r, char **cpp, int ln, int p |
|
cp++; |
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; |
|
|
roff_setstr(struct roff *r, const char *name, const char *string, |
roff_setstr(struct roff *r, const char *name, const char *string, |
int append) |
int append) |
{ |
{ |
|
size_t namesz; |
|
|
roff_setstrn(&r->strtab, name, strlen(name), string, |
namesz = strlen(name); |
|
roff_setstrn(&r->strtab, name, namesz, string, |
string ? strlen(string) : 0, append); |
string ? strlen(string) : 0, append); |
|
roff_setstrn(&r->rentab, name, namesz, NULL, 0, 0); |
} |
} |
|
|
static void |
static void |
Line 3433 roff_setstrn(struct roffkv **r, const char *name, size |
|
Line 3832 roff_setstrn(struct roffkv **r, const char *name, size |
|
} |
} |
|
|
static const char * |
static const char * |
roff_getstrn(const struct roff *r, const char *name, size_t len) |
roff_getstrn(struct roff *r, const char *name, size_t len, |
|
int *deftype) |
{ |
{ |
const struct roffkv *n; |
const struct roffkv *n; |
int i; |
int found, i; |
|
enum roff_tok tok; |
|
|
for (n = r->strtab; n; n = n->next) |
found = 0; |
if (0 == strncmp(name, n->key.p, len) && |
for (n = r->strtab; n != NULL; n = n->next) { |
'\0' == n->key.p[(int)len]) |
if (strncmp(name, n->key.p, len) != 0 || |
|
n->key.p[len] != '\0' || n->val.p == NULL) |
|
continue; |
|
if (*deftype & ROFFDEF_USER) { |
|
*deftype = ROFFDEF_USER; |
return n->val.p; |
return n->val.p; |
|
} else { |
for (i = 0; i < PREDEFS_MAX; i++) |
found = 1; |
if (0 == strncmp(name, predefs[i].name, len) && |
break; |
'\0' == predefs[i].name[(int)len]) |
} |
|
} |
|
for (n = r->rentab; n != NULL; n = n->next) { |
|
if (strncmp(name, n->key.p, len) != 0 || |
|
n->key.p[len] != '\0' || n->val.p == NULL) |
|
continue; |
|
if (*deftype & ROFFDEF_REN) { |
|
*deftype = ROFFDEF_REN; |
|
return n->val.p; |
|
} else { |
|
found = 1; |
|
break; |
|
} |
|
} |
|
for (i = 0; i < PREDEFS_MAX; i++) { |
|
if (strncmp(name, predefs[i].name, len) != 0 || |
|
predefs[i].name[len] != '\0') |
|
continue; |
|
if (*deftype & ROFFDEF_PRE) { |
|
*deftype = ROFFDEF_PRE; |
return predefs[i].str; |
return predefs[i].str; |
|
} else { |
|
found = 1; |
|
break; |
|
} |
|
} |
|
if (r->man->macroset != MACROSET_MAN) { |
|
for (tok = MDOC_Dd; tok < MDOC_MAX; tok++) { |
|
if (strncmp(name, roff_name[tok], len) != 0 || |
|
roff_name[tok][len] != '\0') |
|
continue; |
|
if (*deftype & ROFFDEF_STD) { |
|
*deftype = ROFFDEF_STD; |
|
return NULL; |
|
} else { |
|
found = 1; |
|
break; |
|
} |
|
} |
|
} |
|
if (r->man->macroset != MACROSET_MDOC) { |
|
for (tok = MAN_TH; tok < MAN_MAX; tok++) { |
|
if (strncmp(name, roff_name[tok], len) != 0 || |
|
roff_name[tok][len] != '\0') |
|
continue; |
|
if (*deftype & ROFFDEF_STD) { |
|
*deftype = ROFFDEF_STD; |
|
return NULL; |
|
} else { |
|
found = 1; |
|
break; |
|
} |
|
} |
|
} |
|
|
return NULL; |
if (found == 0 && *deftype != ROFFDEF_ANY) { |
} |
if (*deftype & ROFFDEF_REN) { |
|
/* |
|
* This might still be a request, |
|
* so do not treat it as undefined yet. |
|
*/ |
|
*deftype = ROFFDEF_UNDEF; |
|
return NULL; |
|
} |
|
|
/* |
/* Using an undefined string defines it to be empty. */ |
* Check whether *name is the renamed name of a high-level macro. |
|
* Return the standard name, or NULL if it is not. |
|
*/ |
|
static const char * |
|
roff_getrenn(const struct roff *r, const char *name, size_t len) |
|
{ |
|
const struct roffkv *n; |
|
|
|
for (n = r->rentab; n; n = n->next) |
roff_setstrn(&r->strtab, name, len, "", 0, 0); |
if (0 == strncmp(name, n->key.p, len) && |
roff_setstrn(&r->rentab, name, len, NULL, 0, 0); |
'\0' == n->key.p[(int)len]) |
} |
return n->val.p; |
|
|
|
|
*deftype = 0; |
return NULL; |
return NULL; |
} |
} |
|
|
Line 3482 roff_freestr(struct roffkv *r) |
|
Line 3939 roff_freestr(struct roffkv *r) |
|
} |
} |
|
|
/* --- accessors and utility functions ------------------------------------ */ |
/* --- accessors and utility functions ------------------------------------ */ |
|
|
const struct tbl_span * |
|
roff_span(const struct roff *r) |
|
{ |
|
|
|
return r->tbl ? tbl_span(r->tbl) : NULL; |
|
} |
|
|
|
const struct eqn * |
|
roff_eqn(const struct roff *r) |
|
{ |
|
|
|
return r->last_eqn ? &r->last_eqn->eqn : NULL; |
|
} |
|
|
|
/* |
/* |
* Duplicate an input string, making the appropriate character |
* Duplicate an input string, making the appropriate character |