version 1.237, 2014/10/28 17:36:19 |
version 1.243, 2014/12/16 23:44:41 |
Line 142 struct roffnode { |
|
Line 142 struct roffnode { |
|
|
|
#define ROFF_ARGS struct roff *r, /* parse ctx */ \ |
#define ROFF_ARGS struct roff *r, /* parse ctx */ \ |
enum rofft tok, /* tok of macro */ \ |
enum rofft tok, /* tok of macro */ \ |
char **bufp, /* input buffer */ \ |
struct buf *buf, /* input buffer */ \ |
size_t *szp, /* size of input buffer */ \ |
|
int ln, /* parse line */ \ |
int ln, /* parse line */ \ |
int ppos, /* original pos in buffer */ \ |
int ppos, /* original pos in buffer */ \ |
int pos, /* current pos in buffer */ \ |
int pos, /* current pos in buffer */ \ |
Line 185 static enum rofferr roff_cond(ROFF_ARGS); |
|
Line 184 static enum rofferr roff_cond(ROFF_ARGS); |
|
static enum rofferr roff_cond_text(ROFF_ARGS); |
static enum rofferr roff_cond_text(ROFF_ARGS); |
static enum rofferr roff_cond_sub(ROFF_ARGS); |
static enum rofferr roff_cond_sub(ROFF_ARGS); |
static enum rofferr roff_ds(ROFF_ARGS); |
static enum rofferr roff_ds(ROFF_ARGS); |
static enum rofferr roff_eqndelim(struct roff *, |
static enum rofferr roff_eqndelim(struct roff *, struct buf *, int); |
char **, size_t *, int); |
|
static int roff_evalcond(struct roff *r, int, |
static int roff_evalcond(struct roff *r, int, |
const char *, int *); |
const char *, int *); |
static int roff_evalnum(struct roff *, int, |
static int roff_evalnum(struct roff *, int, |
Line 210 static enum rofferr roff_line_ignore(ROFF_ARGS); |
|
Line 208 static enum rofferr roff_line_ignore(ROFF_ARGS); |
|
static enum rofferr roff_nr(ROFF_ARGS); |
static enum rofferr roff_nr(ROFF_ARGS); |
static enum rofft roff_parse(struct roff *, char *, int *, |
static enum rofft roff_parse(struct roff *, char *, int *, |
int, int); |
int, int); |
static enum rofferr roff_parsetext(char **, size_t *, int, int *); |
static enum rofferr roff_parsetext(struct buf *, int, int *); |
static enum rofferr roff_res(struct roff *, |
static enum rofferr roff_res(struct roff *, struct buf *, int, int); |
char **, size_t *, int, int); |
|
static enum rofferr roff_rm(ROFF_ARGS); |
static enum rofferr roff_rm(ROFF_ARGS); |
static enum rofferr roff_rr(ROFF_ARGS); |
static enum rofferr roff_rr(ROFF_ARGS); |
static void roff_setstr(struct roff *, |
static void roff_setstr(struct roff *, |
Line 499 roff_alloc(struct mparse *parse, const struct mchars * |
|
Line 496 roff_alloc(struct mparse *parse, const struct mchars * |
|
* Also check the syntax of the remaining escape sequences. |
* Also check the syntax of the remaining escape sequences. |
*/ |
*/ |
static enum rofferr |
static enum rofferr |
roff_res(struct roff *r, char **bufp, size_t *szp, int ln, int pos) |
roff_res(struct roff *r, struct buf *buf, int ln, int pos) |
{ |
{ |
char ubuf[24]; /* buffer to print the number */ |
char ubuf[24]; /* buffer to print the number */ |
const char *start; /* start of the string to process */ |
const char *start; /* start of the string to process */ |
Line 507 roff_res(struct roff *r, char **bufp, size_t *szp, int |
|
Line 504 roff_res(struct roff *r, char **bufp, size_t *szp, int |
|
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 bufp 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 */ |
enum mandoc_esc esc; /* type of the escape sequence */ |
enum mandoc_esc esc; /* type of the escape sequence */ |
Line 518 roff_res(struct roff *r, char **bufp, size_t *szp, int |
|
Line 515 roff_res(struct roff *r, char **bufp, size_t *szp, int |
|
char term; /* character terminating the escape */ |
char term; /* character terminating the escape */ |
|
|
expand_count = 0; |
expand_count = 0; |
start = *bufp + pos; |
start = buf->buf + pos; |
stesc = strchr(start, '\0') - 1; |
stesc = strchr(start, '\0') - 1; |
while (stesc-- > start) { |
while (stesc-- > start) { |
|
|
/* Search backwards for the next backslash. */ |
/* Search backwards for the next backslash. */ |
|
|
if ('\\' != *stesc) |
if (*stesc != '\\') |
continue; |
continue; |
|
|
/* If it is escaped, skip it. */ |
/* If it is escaped, skip it. */ |
|
|
for (cp = stesc - 1; cp >= start; cp--) |
for (cp = stesc - 1; cp >= start; cp--) |
if ('\\' != *cp) |
if (*cp != '\\') |
break; |
break; |
|
|
if (0 == (stesc - cp) % 2) { |
if ((stesc - cp) % 2 == 0) { |
stesc = (char *)cp; |
stesc = (char *)cp; |
continue; |
continue; |
} |
} |
Line 560 roff_res(struct roff *r, char **bufp, size_t *szp, int |
|
Line 557 roff_res(struct roff *r, char **bufp, size_t *szp, int |
|
(esc == ESCAPE_SPECIAL && |
(esc == ESCAPE_SPECIAL && |
mchars_spec2cp(r->mchars, stnam, inaml) < 0)) |
mchars_spec2cp(r->mchars, stnam, inaml) < 0)) |
mandoc_vmsg(MANDOCERR_ESC_BAD, |
mandoc_vmsg(MANDOCERR_ESC_BAD, |
r->parse, ln, (int)(stesc - *bufp), |
r->parse, ln, (int)(stesc - buf->buf), |
"%.*s", (int)(cp - stesc), stesc); |
"%.*s", (int)(cp - stesc), stesc); |
continue; |
continue; |
} |
} |
|
|
if (EXPAND_LIMIT < ++expand_count) { |
if (EXPAND_LIMIT < ++expand_count) { |
mandoc_msg(MANDOCERR_ROFFLOOP, r->parse, |
mandoc_msg(MANDOCERR_ROFFLOOP, r->parse, |
ln, (int)(stesc - *bufp), NULL); |
ln, (int)(stesc - buf->buf), NULL); |
return(ROFF_IGN); |
return(ROFF_IGN); |
} |
} |
|
|
Line 577 roff_res(struct roff *r, char **bufp, size_t *szp, int |
|
Line 574 roff_res(struct roff *r, char **bufp, size_t *szp, int |
|
* Save a pointer to the name. |
* Save a pointer to the name. |
*/ |
*/ |
|
|
if ('\0' == term) { |
if (term == '\0') { |
switch (*++cp) { |
switch (*++cp) { |
case '\0': |
case '\0': |
maxl = 0; |
maxl = 0; |
Line 604 roff_res(struct roff *r, char **bufp, size_t *szp, int |
|
Line 601 roff_res(struct roff *r, char **bufp, size_t *szp, int |
|
/* Advance to the end of the name. */ |
/* Advance to the end of the name. */ |
|
|
arg_complete = 1; |
arg_complete = 1; |
for (naml = 0; 0 == maxl || naml < maxl; naml++, cp++) { |
for (naml = 0; maxl == 0 || naml < maxl; naml++, cp++) { |
if ('\0' == *cp) { |
if (*cp == '\0') { |
mandoc_msg(MANDOCERR_ESC_BAD, r->parse, |
mandoc_msg(MANDOCERR_ESC_BAD, r->parse, |
ln, (int)(stesc - *bufp), stesc); |
ln, (int)(stesc - buf->buf), stesc); |
arg_complete = 0; |
arg_complete = 0; |
break; |
break; |
} |
} |
if (0 == maxl && *cp == term) { |
if (maxl == 0 && *cp == term) { |
cp++; |
cp++; |
break; |
break; |
} |
} |
Line 648 roff_res(struct roff *r, char **bufp, size_t *szp, int |
|
Line 645 roff_res(struct roff *r, char **bufp, size_t *szp, int |
|
break; |
break; |
} |
} |
|
|
if (NULL == res) { |
if (res == NULL) { |
mandoc_vmsg(MANDOCERR_STR_UNDEF, |
mandoc_vmsg(MANDOCERR_STR_UNDEF, |
r->parse, ln, (int)(stesc - *bufp), |
r->parse, ln, (int)(stesc - buf->buf), |
"%.*s", (int)naml, stnam); |
"%.*s", (int)naml, stnam); |
res = ""; |
res = ""; |
} |
} |
Line 658 roff_res(struct roff *r, char **bufp, size_t *szp, int |
|
Line 655 roff_res(struct roff *r, char **bufp, size_t *szp, int |
|
/* Replace the escape sequence by the string. */ |
/* Replace the escape sequence by the string. */ |
|
|
*stesc = '\0'; |
*stesc = '\0'; |
*szp = mandoc_asprintf(&nbuf, "%s%s%s", |
buf->sz = mandoc_asprintf(&nbuf, "%s%s%s", |
*bufp, res, cp) + 1; |
buf->buf, res, cp) + 1; |
|
|
/* Prepare for the next replacement. */ |
/* Prepare for the next replacement. */ |
|
|
start = nbuf + pos; |
start = nbuf + pos; |
stesc = nbuf + (stesc - *bufp) + strlen(res); |
stesc = nbuf + (stesc - buf->buf) + strlen(res); |
free(*bufp); |
free(buf->buf); |
*bufp = nbuf; |
buf->buf = nbuf; |
} |
} |
return(ROFF_CONT); |
return(ROFF_CONT); |
} |
} |
Line 677 roff_res(struct roff *r, char **bufp, size_t *szp, int |
|
Line 674 roff_res(struct roff *r, char **bufp, size_t *szp, int |
|
* Decrement and spring input line trap. |
* Decrement and spring input line trap. |
*/ |
*/ |
static enum rofferr |
static enum rofferr |
roff_parsetext(char **bufp, size_t *szp, int pos, int *offs) |
roff_parsetext(struct buf *buf, int pos, int *offs) |
{ |
{ |
size_t sz; |
size_t sz; |
const char *start; |
const char *start; |
Line 685 roff_parsetext(char **bufp, size_t *szp, int pos, int |
|
Line 682 roff_parsetext(char **bufp, size_t *szp, int pos, int |
|
int isz; |
int isz; |
enum mandoc_esc esc; |
enum mandoc_esc esc; |
|
|
start = p = *bufp + pos; |
start = p = buf->buf + pos; |
|
|
while ('\0' != *p) { |
while (*p != '\0') { |
sz = strcspn(p, "-\\"); |
sz = strcspn(p, "-\\"); |
p += sz; |
p += sz; |
|
|
if ('\0' == *p) |
if (*p == '\0') |
break; |
break; |
|
|
if ('\\' == *p) { |
if (*p == '\\') { |
/* Skip over escapes. */ |
/* Skip over escapes. */ |
p++; |
p++; |
esc = mandoc_escape((const char **)&p, NULL, NULL); |
esc = mandoc_escape((const char **)&p, NULL, NULL); |
if (ESCAPE_ERROR == esc) |
if (esc == ESCAPE_ERROR) |
break; |
break; |
continue; |
continue; |
} else if (p == start) { |
} else if (p == start) { |
Line 713 roff_parsetext(char **bufp, size_t *szp, int pos, int |
|
Line 710 roff_parsetext(char **bufp, size_t *szp, int pos, int |
|
} |
} |
|
|
/* Spring the input line trap. */ |
/* Spring the input line trap. */ |
if (1 == roffit_lines) { |
if (roffit_lines == 1) { |
isz = mandoc_asprintf(&p, "%s\n.%s", *bufp, roffit_macro); |
isz = mandoc_asprintf(&p, "%s\n.%s", buf->buf, roffit_macro); |
free(*bufp); |
free(buf->buf); |
*bufp = p; |
buf->buf = p; |
*szp = isz + 1; |
buf->sz = isz + 1; |
*offs = 0; |
*offs = 0; |
free(roffit_macro); |
free(roffit_macro); |
roffit_lines = 0; |
roffit_lines = 0; |
return(ROFF_REPARSE); |
return(ROFF_REPARSE); |
} else if (1 < roffit_lines) |
} else if (roffit_lines > 1) |
--roffit_lines; |
--roffit_lines; |
return(ROFF_CONT); |
return(ROFF_CONT); |
} |
} |
|
|
enum rofferr |
enum rofferr |
roff_parseln(struct roff *r, int ln, char **bufp, |
roff_parseln(struct roff *r, int ln, struct buf *buf, int *offs) |
size_t *szp, int pos, int *offs) |
|
{ |
{ |
enum rofft t; |
enum rofft t; |
enum rofferr e; |
enum rofferr e; |
int ppos, ctl; |
int pos; /* parse point */ |
|
int spos; /* saved parse point for messages */ |
|
int ppos; /* original offset in buf->buf */ |
|
int ctl; /* macro line (boolean) */ |
|
|
|
ppos = pos = *offs; |
|
|
/* Handle in-line equation delimiters. */ |
/* Handle in-line equation delimiters. */ |
|
|
if (r->tbl == NULL && |
if (r->tbl == NULL && |
r->last_eqn != NULL && r->last_eqn->delim && |
r->last_eqn != NULL && r->last_eqn->delim && |
(r->eqn == NULL || r->eqn_inline)) { |
(r->eqn == NULL || r->eqn_inline)) { |
e = roff_eqndelim(r, bufp, szp, pos); |
e = roff_eqndelim(r, buf, pos); |
if (e == ROFF_REPARSE) |
if (e == ROFF_REPARSE) |
return(e); |
return(e); |
assert(e == ROFF_CONT); |
assert(e == ROFF_CONT); |
Line 748 roff_parseln(struct roff *r, int ln, char **bufp, |
|
Line 749 roff_parseln(struct roff *r, int ln, char **bufp, |
|
|
|
/* Expand some escape sequences. */ |
/* Expand some escape sequences. */ |
|
|
e = roff_res(r, bufp, szp, ln, pos); |
e = roff_res(r, buf, ln, pos); |
if (ROFF_IGN == e) |
if (e == ROFF_IGN) |
return(e); |
return(e); |
assert(ROFF_CONT == e); |
assert(e == ROFF_CONT); |
|
|
ppos = pos; |
ctl = roff_getcontrol(r, buf->buf, &pos); |
ctl = roff_getcontrol(r, *bufp, &pos); |
|
|
|
/* |
/* |
* First, if a scope is open and we're not a macro, pass the |
* First, if a scope is open and we're not a macro, pass the |
Line 767 roff_parseln(struct roff *r, int ln, char **bufp, |
|
Line 767 roff_parseln(struct roff *r, int ln, char **bufp, |
|
if (r->last && ! ctl) { |
if (r->last && ! ctl) { |
t = r->last->tok; |
t = r->last->tok; |
assert(roffs[t].text); |
assert(roffs[t].text); |
e = (*roffs[t].text)(r, t, bufp, szp, ln, pos, pos, offs); |
e = (*roffs[t].text)(r, t, buf, ln, pos, pos, offs); |
assert(ROFF_IGN == e || ROFF_CONT == e); |
assert(e == ROFF_IGN || e == ROFF_CONT); |
if (ROFF_CONT != e) |
if (e != ROFF_CONT) |
return(e); |
return(e); |
} |
} |
if (r->eqn) |
if (r->eqn) |
return(eqn_read(&r->eqn, ln, *bufp, ppos, offs)); |
return(eqn_read(&r->eqn, ln, buf->buf, ppos, offs)); |
if ( ! ctl) { |
if ( ! ctl) { |
if (r->tbl) |
if (r->tbl) |
return(tbl_read(r->tbl, ln, *bufp, pos)); |
return(tbl_read(r->tbl, ln, buf->buf, pos)); |
return(roff_parsetext(bufp, szp, pos, offs)); |
return(roff_parsetext(buf, pos, offs)); |
} |
} |
|
|
/* Skip empty request lines. */ |
/* Skip empty request lines. */ |
|
|
if ((*bufp)[pos] == '"') { |
if (buf->buf[pos] == '"') { |
mandoc_msg(MANDOCERR_COMMENT_BAD, r->parse, |
mandoc_msg(MANDOCERR_COMMENT_BAD, r->parse, |
ln, pos, NULL); |
ln, pos, NULL); |
return(ROFF_IGN); |
return(ROFF_IGN); |
} else if ((*bufp)[pos] == '\0') |
} else if (buf->buf[pos] == '\0') |
return(ROFF_IGN); |
return(ROFF_IGN); |
|
|
/* |
/* |
Line 798 roff_parseln(struct roff *r, int ln, char **bufp, |
|
Line 798 roff_parseln(struct roff *r, int ln, char **bufp, |
|
if (r->last) { |
if (r->last) { |
t = r->last->tok; |
t = r->last->tok; |
assert(roffs[t].sub); |
assert(roffs[t].sub); |
return((*roffs[t].sub)(r, t, bufp, szp, |
return((*roffs[t].sub)(r, t, buf, ln, ppos, pos, offs)); |
ln, ppos, pos, offs)); |
|
} |
} |
|
|
|
/* No scope is open. This is a new request or macro. */ |
|
|
|
spos = pos; |
|
t = roff_parse(r, buf->buf, &pos, ln, ppos); |
|
|
|
/* Tables ignore most macros. */ |
|
|
|
if (r->tbl != NULL && (t == ROFF_MAX || t == ROFF_TS)) { |
|
mandoc_msg(MANDOCERR_TBLMACRO, r->parse, |
|
ln, pos, buf->buf + spos); |
|
return(ROFF_IGN); |
|
} |
|
|
/* |
/* |
* Lastly, as we've no scope open, try to look up and execute |
* This is neither a roff request nor a user-defined macro. |
* the new macro. If no macro is found, simply return and let |
* Let the standard macro set parsers handle it. |
* the compilers handle it. |
|
*/ |
*/ |
|
|
if (ROFF_MAX == (t = roff_parse(r, *bufp, &pos, ln, ppos))) |
if (t == ROFF_MAX) |
return(ROFF_CONT); |
return(ROFF_CONT); |
|
|
|
/* Execute a roff request or a user defined macro. */ |
|
|
assert(roffs[t].proc); |
assert(roffs[t].proc); |
return((*roffs[t].proc)(r, t, bufp, szp, ln, ppos, pos, offs)); |
return((*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs)); |
} |
} |
|
|
void |
void |
Line 875 roff_cblock(ROFF_ARGS) |
|
Line 888 roff_cblock(ROFF_ARGS) |
|
* ignore macro, otherwise raise a warning and just ignore it. |
* ignore macro, otherwise raise a warning and just ignore it. |
*/ |
*/ |
|
|
if (NULL == r->last) { |
if (r->last == NULL) { |
mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse, |
mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse, |
ln, ppos, ".."); |
ln, ppos, ".."); |
return(ROFF_IGN); |
return(ROFF_IGN); |
Line 900 roff_cblock(ROFF_ARGS) |
|
Line 913 roff_cblock(ROFF_ARGS) |
|
return(ROFF_IGN); |
return(ROFF_IGN); |
} |
} |
|
|
if ((*bufp)[pos]) |
if (buf->buf[pos] != '\0') |
mandoc_vmsg(MANDOCERR_ARG_SKIP, r->parse, ln, pos, |
mandoc_vmsg(MANDOCERR_ARG_SKIP, r->parse, ln, pos, |
".. %s", *bufp + pos); |
".. %s", buf->buf + pos); |
|
|
roffnode_pop(r); |
roffnode_pop(r); |
roffnode_cleanscope(r); |
roffnode_cleanscope(r); |
Line 964 roff_block(ROFF_ARGS) |
|
Line 977 roff_block(ROFF_ARGS) |
|
|
|
/* Ignore groff compatibility mode for now. */ |
/* Ignore groff compatibility mode for now. */ |
|
|
if (ROFF_de1 == tok) |
if (tok == ROFF_de1) |
tok = ROFF_de; |
tok = ROFF_de; |
else if (ROFF_am1 == tok) |
else if (tok == ROFF_am1) |
tok = ROFF_am; |
tok = ROFF_am; |
|
|
/* Parse the macro name argument. */ |
/* Parse the macro name argument. */ |
|
|
cp = *bufp + pos; |
cp = buf->buf + pos; |
if (ROFF_ig == tok) { |
if (tok == ROFF_ig) { |
iname = NULL; |
iname = NULL; |
namesz = 0; |
namesz = 0; |
} else { |
} else { |
Line 983 roff_block(ROFF_ARGS) |
|
Line 996 roff_block(ROFF_ARGS) |
|
|
|
/* Resolve the macro name argument if it is indirect. */ |
/* Resolve the macro name argument if it is indirect. */ |
|
|
if (namesz && (ROFF_dei == tok || ROFF_ami == tok)) { |
if (namesz && (tok == ROFF_dei || tok == ROFF_ami)) { |
if (NULL == (name = roff_getstrn(r, iname, namesz))) { |
if ((name = roff_getstrn(r, iname, namesz)) == NULL) { |
mandoc_vmsg(MANDOCERR_STR_UNDEF, |
mandoc_vmsg(MANDOCERR_STR_UNDEF, |
r->parse, ln, (int)(iname - *bufp), |
r->parse, ln, (int)(iname - buf->buf), |
"%.*s", (int)namesz, iname); |
"%.*s", (int)namesz, iname); |
namesz = 0; |
namesz = 0; |
} else |
} else |
Line 994 roff_block(ROFF_ARGS) |
|
Line 1007 roff_block(ROFF_ARGS) |
|
} else |
} else |
name = iname; |
name = iname; |
|
|
if (0 == namesz && ROFF_ig != tok) { |
if (namesz == 0 && tok != ROFF_ig) { |
mandoc_msg(MANDOCERR_REQ_EMPTY, r->parse, |
mandoc_msg(MANDOCERR_REQ_EMPTY, r->parse, |
ln, ppos, roffs[tok].name); |
ln, ppos, roffs[tok].name); |
return(ROFF_IGN); |
return(ROFF_IGN); |
Line 1008 roff_block(ROFF_ARGS) |
|
Line 1021 roff_block(ROFF_ARGS) |
|
* appended from roff_block_text() in multiline mode. |
* appended from roff_block_text() in multiline mode. |
*/ |
*/ |
|
|
if (ROFF_de == tok || ROFF_dei == tok) |
if (tok == ROFF_de || tok == ROFF_dei) |
roff_setstrn(&r->strtab, name, namesz, "", 0, 0); |
roff_setstrn(&r->strtab, name, namesz, "", 0, 0); |
|
|
if ('\0' == *cp) |
if (*cp == '\0') |
return(ROFF_IGN); |
return(ROFF_IGN); |
|
|
/* Get the custom end marker. */ |
/* Get the custom end marker. */ |
Line 1021 roff_block(ROFF_ARGS) |
|
Line 1034 roff_block(ROFF_ARGS) |
|
|
|
/* Resolve the end marker if it is indirect. */ |
/* Resolve the end marker if it is indirect. */ |
|
|
if (namesz && (ROFF_dei == tok || ROFF_ami == tok)) { |
if (namesz && (tok == ROFF_dei || tok == ROFF_ami)) { |
if (NULL == (name = roff_getstrn(r, iname, namesz))) { |
if ((name = roff_getstrn(r, iname, namesz)) == NULL) { |
mandoc_vmsg(MANDOCERR_STR_UNDEF, |
mandoc_vmsg(MANDOCERR_STR_UNDEF, |
r->parse, ln, (int)(iname - *bufp), |
r->parse, ln, (int)(iname - buf->buf), |
"%.*s", (int)namesz, iname); |
"%.*s", (int)namesz, iname); |
namesz = 0; |
namesz = 0; |
} else |
} else |
Line 1035 roff_block(ROFF_ARGS) |
|
Line 1048 roff_block(ROFF_ARGS) |
|
if (namesz) |
if (namesz) |
r->last->end = mandoc_strndup(name, namesz); |
r->last->end = mandoc_strndup(name, namesz); |
|
|
if ('\0' != *cp) |
if (*cp != '\0') |
mandoc_vmsg(MANDOCERR_ARG_EXCESS, r->parse, |
mandoc_vmsg(MANDOCERR_ARG_EXCESS, r->parse, |
ln, pos, ".%s ... %s", roffs[tok].name, cp); |
ln, pos, ".%s ... %s", roffs[tok].name, cp); |
|
|
Line 1059 roff_block_sub(ROFF_ARGS) |
|
Line 1072 roff_block_sub(ROFF_ARGS) |
|
|
|
if (r->last->end) { |
if (r->last->end) { |
for (i = pos, j = 0; r->last->end[j]; j++, i++) |
for (i = pos, j = 0; r->last->end[j]; j++, i++) |
if ((*bufp)[i] != r->last->end[j]) |
if (buf->buf[i] != r->last->end[j]) |
break; |
break; |
|
|
if ('\0' == r->last->end[j] && |
if (r->last->end[j] == '\0' && |
('\0' == (*bufp)[i] || |
(buf->buf[i] == '\0' || |
' ' == (*bufp)[i] || |
buf->buf[i] == ' ' || |
'\t' == (*bufp)[i])) { |
buf->buf[i] == '\t')) { |
roffnode_pop(r); |
roffnode_pop(r); |
roffnode_cleanscope(r); |
roffnode_cleanscope(r); |
|
|
while (' ' == (*bufp)[i] || '\t' == (*bufp)[i]) |
while (buf->buf[i] == ' ' || buf->buf[i] == '\t') |
i++; |
i++; |
|
|
pos = i; |
pos = i; |
if (ROFF_MAX != roff_parse(r, *bufp, &pos, ln, ppos)) |
if (roff_parse(r, buf->buf, &pos, ln, ppos) != |
|
ROFF_MAX) |
return(ROFF_RERUN); |
return(ROFF_RERUN); |
return(ROFF_IGN); |
return(ROFF_IGN); |
} |
} |
Line 1084 roff_block_sub(ROFF_ARGS) |
|
Line 1098 roff_block_sub(ROFF_ARGS) |
|
* pulling it out of the hashtable. |
* pulling it out of the hashtable. |
*/ |
*/ |
|
|
t = roff_parse(r, *bufp, &pos, ln, ppos); |
t = roff_parse(r, buf->buf, &pos, ln, ppos); |
|
|
if (ROFF_cblock != t) { |
if (t != ROFF_cblock) { |
if (ROFF_ig != tok) |
if (tok != ROFF_ig) |
roff_setstr(r, r->last->name, *bufp + ppos, 2); |
roff_setstr(r, r->last->name, buf->buf + ppos, 2); |
return(ROFF_IGN); |
return(ROFF_IGN); |
} |
} |
|
|
assert(roffs[t].proc); |
assert(roffs[t].proc); |
return((*roffs[t].proc)(r, t, bufp, szp, ln, ppos, pos, offs)); |
return((*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs)); |
} |
} |
|
|
static enum rofferr |
static enum rofferr |
roff_block_text(ROFF_ARGS) |
roff_block_text(ROFF_ARGS) |
{ |
{ |
|
|
if (ROFF_ig != tok) |
if (tok != ROFF_ig) |
roff_setstr(r, r->last->name, *bufp + pos, 2); |
roff_setstr(r, r->last->name, buf->buf + pos, 2); |
|
|
return(ROFF_IGN); |
return(ROFF_IGN); |
} |
} |
Line 1115 roff_cond_sub(ROFF_ARGS) |
|
Line 1129 roff_cond_sub(ROFF_ARGS) |
|
|
|
rr = r->last->rule; |
rr = r->last->rule; |
roffnode_cleanscope(r); |
roffnode_cleanscope(r); |
t = roff_parse(r, *bufp, &pos, ln, ppos); |
t = roff_parse(r, buf->buf, &pos, ln, ppos); |
|
|
/* |
/* |
* Fully handle known macros when they are structurally |
* Fully handle known macros when they are structurally |
* required or when the conditional evaluated to true. |
* required or when the conditional evaluated to true. |
*/ |
*/ |
|
|
if ((ROFF_MAX != t) && |
if ((t != ROFF_MAX) && |
(rr || ROFFMAC_STRUCT & roffs[t].flags)) { |
(rr || roffs[t].flags & ROFFMAC_STRUCT)) { |
assert(roffs[t].proc); |
assert(roffs[t].proc); |
return((*roffs[t].proc)(r, t, bufp, szp, |
return((*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs)); |
ln, ppos, pos, offs)); |
|
} |
} |
|
|
/* |
/* |
Line 1134 roff_cond_sub(ROFF_ARGS) |
|
Line 1147 roff_cond_sub(ROFF_ARGS) |
|
* drop the line completely. |
* drop the line completely. |
*/ |
*/ |
|
|
ep = *bufp + pos; |
ep = buf->buf + pos; |
if ('\\' == ep[0] && '}' == ep[1]) |
if (ep[0] == '\\' && ep[1] == '}') |
rr = 0; |
rr = 0; |
|
|
/* Always check for the closing delimiter `\}'. */ |
/* Always check for the closing delimiter `\}'. */ |
|
|
while (NULL != (ep = strchr(ep, '\\'))) { |
while ((ep = strchr(ep, '\\')) != NULL) { |
if ('}' == *(++ep)) { |
if (*(++ep) == '}') { |
*ep = '&'; |
*ep = '&'; |
roff_ccond(r, ln, ep - *bufp - 1); |
roff_ccond(r, ln, ep - buf->buf - 1); |
} |
} |
++ep; |
++ep; |
} |
} |
Line 1159 roff_cond_text(ROFF_ARGS) |
|
Line 1172 roff_cond_text(ROFF_ARGS) |
|
rr = r->last->rule; |
rr = r->last->rule; |
roffnode_cleanscope(r); |
roffnode_cleanscope(r); |
|
|
ep = *bufp + pos; |
ep = buf->buf + pos; |
while (NULL != (ep = strchr(ep, '\\'))) { |
while ((ep = strchr(ep, '\\')) != NULL) { |
if ('}' == *(++ep)) { |
if (*(++ep) == '}') { |
*ep = '&'; |
*ep = '&'; |
roff_ccond(r, ln, ep - *bufp - 1); |
roff_ccond(r, ln, ep - buf->buf - 1); |
} |
} |
++ep; |
++ep; |
} |
} |
Line 1238 roff_evalstrcond(const char *v, int *pos) |
|
Line 1251 roff_evalstrcond(const char *v, int *pos) |
|
out: |
out: |
if (NULL == s3) |
if (NULL == s3) |
s3 = strchr(s2, '\0'); |
s3 = strchr(s2, '\0'); |
else |
else if (*s3 != '\0') |
s3++; |
s3++; |
*pos = s3 - v; |
*pos = s3 - v; |
return(match); |
return(match); |
|
|
static int |
static int |
roff_evalcond(struct roff *r, int ln, const char *v, int *pos) |
roff_evalcond(struct roff *r, int ln, const char *v, int *pos) |
{ |
{ |
int wanttrue, number; |
int number, savepos, wanttrue; |
|
|
if ('!' == v[*pos]) { |
if ('!' == v[*pos]) { |
wanttrue = 0; |
wanttrue = 0; |
Line 1260 roff_evalcond(struct roff *r, int ln, const char *v, i |
|
Line 1273 roff_evalcond(struct roff *r, int ln, const char *v, i |
|
wanttrue = 1; |
wanttrue = 1; |
|
|
switch (v[*pos]) { |
switch (v[*pos]) { |
|
case '\0': |
|
return(0); |
case 'n': |
case 'n': |
/* FALLTHROUGH */ |
/* FALLTHROUGH */ |
case 'o': |
case 'o': |
Line 1274 roff_evalcond(struct roff *r, int ln, const char *v, i |
|
Line 1289 roff_evalcond(struct roff *r, int ln, const char *v, i |
|
case 'r': |
case 'r': |
/* FALLTHROUGH */ |
/* FALLTHROUGH */ |
case 't': |
case 't': |
|
/* FALLTHROUGH */ |
|
case 'v': |
(*pos)++; |
(*pos)++; |
return(!wanttrue); |
return(!wanttrue); |
default: |
default: |
break; |
break; |
} |
} |
|
|
|
savepos = *pos; |
if (roff_evalnum(r, ln, v, pos, &number, 0)) |
if (roff_evalnum(r, ln, v, pos, &number, 0)) |
return((number > 0) == wanttrue); |
return((number > 0) == wanttrue); |
else |
else if (*pos == savepos) |
return(roff_evalstrcond(v, pos) == wanttrue); |
return(roff_evalstrcond(v, pos) == wanttrue); |
|
else |
|
return (0); |
} |
} |
|
|
static enum rofferr |
static enum rofferr |
Line 1307 roff_cond(ROFF_ARGS) |
|
Line 1327 roff_cond(ROFF_ARGS) |
|
* If we're not an `el', however, then evaluate the conditional. |
* If we're not an `el', however, then evaluate the conditional. |
*/ |
*/ |
|
|
r->last->rule = ROFF_el == tok ? |
r->last->rule = tok == ROFF_el ? |
(r->rstackpos < 0 ? 0 : r->rstack[r->rstackpos--]) : |
(r->rstackpos < 0 ? 0 : r->rstack[r->rstackpos--]) : |
roff_evalcond(r, ln, *bufp, &pos); |
roff_evalcond(r, ln, buf->buf, &pos); |
|
|
/* |
/* |
* An if-else will put the NEGATION of the current evaluated |
* An if-else will put the NEGATION of the current evaluated |
* conditional into the stack of rules. |
* conditional into the stack of rules. |
*/ |
*/ |
|
|
if (ROFF_ie == tok) { |
if (tok == ROFF_ie) { |
if (r->rstackpos + 1 == r->rstacksz) { |
if (r->rstackpos + 1 == r->rstacksz) { |
r->rstacksz += 16; |
r->rstacksz += 16; |
r->rstack = mandoc_reallocarray(r->rstack, |
r->rstack = mandoc_reallocarray(r->rstack, |
Line 1336 roff_cond(ROFF_ARGS) |
|
Line 1356 roff_cond(ROFF_ARGS) |
|
* not even whitespace, use next-line scope. |
* not even whitespace, use next-line scope. |
*/ |
*/ |
|
|
if ('\0' == (*bufp)[pos]) { |
if (buf->buf[pos] == '\0') { |
r->last->endspan = 2; |
r->last->endspan = 2; |
goto out; |
goto out; |
} |
} |
|
|
while (' ' == (*bufp)[pos]) |
while (buf->buf[pos] == ' ') |
pos++; |
pos++; |
|
|
/* An opening brace requests multiline scope. */ |
/* An opening brace requests multiline scope. */ |
|
|
if ('\\' == (*bufp)[pos] && '{' == (*bufp)[pos + 1]) { |
if (buf->buf[pos] == '\\' && buf->buf[pos + 1] == '{') { |
r->last->endspan = -1; |
r->last->endspan = -1; |
pos += 2; |
pos += 2; |
goto out; |
goto out; |
Line 1358 roff_cond(ROFF_ARGS) |
|
Line 1378 roff_cond(ROFF_ARGS) |
|
* nothing but trailing whitespace. |
* nothing but trailing whitespace. |
*/ |
*/ |
|
|
if ('\0' == (*bufp)[pos]) |
if (buf->buf[pos] == '\0') |
mandoc_msg(MANDOCERR_COND_EMPTY, r->parse, |
mandoc_msg(MANDOCERR_COND_EMPTY, r->parse, |
ln, ppos, roffs[tok].name); |
ln, ppos, roffs[tok].name); |
|
|
Line 1382 roff_ds(ROFF_ARGS) |
|
Line 1402 roff_ds(ROFF_ARGS) |
|
* abort the `ds' request without defining anything. |
* abort the `ds' request without defining anything. |
*/ |
*/ |
|
|
name = string = *bufp + pos; |
name = string = buf->buf + pos; |
if ('\0' == *name) |
if (*name == '\0') |
return(ROFF_IGN); |
return(ROFF_IGN); |
|
|
namesz = roff_getname(r, &string, ln, pos); |
namesz = roff_getname(r, &string, ln, pos); |
if ('\\' == name[namesz]) |
if (name[namesz] == '\\') |
return(ROFF_IGN); |
return(ROFF_IGN); |
|
|
/* Read past the initial double-quote, if any. */ |
/* Read past the initial double-quote, if any. */ |
if ('"' == *string) |
if (*string == '"') |
string++; |
string++; |
|
|
/* The rest is the value. */ |
/* The rest is the value. */ |
Line 1723 roff_nr(ROFF_ARGS) |
|
Line 1743 roff_nr(ROFF_ARGS) |
|
int iv; |
int iv; |
char sign; |
char sign; |
|
|
key = val = *bufp + pos; |
key = val = buf->buf + pos; |
if ('\0' == *key) |
if (*key == '\0') |
return(ROFF_IGN); |
return(ROFF_IGN); |
|
|
keysz = roff_getname(r, &val, ln, pos); |
keysz = roff_getname(r, &val, ln, pos); |
if ('\\' == key[keysz]) |
if (key[keysz] == '\\') |
return(ROFF_IGN); |
return(ROFF_IGN); |
key[keysz] = '\0'; |
key[keysz] = '\0'; |
|
|
sign = *val; |
sign = *val; |
if ('+' == sign || '-' == sign) |
if (sign == '+' || sign == '-') |
val++; |
val++; |
|
|
if (roff_evalnum(r, ln, val, NULL, &iv, 0)) |
if (roff_evalnum(r, ln, val, NULL, &iv, 0)) |
Line 1749 roff_rr(ROFF_ARGS) |
|
Line 1769 roff_rr(ROFF_ARGS) |
|
char *name, *cp; |
char *name, *cp; |
size_t namesz; |
size_t namesz; |
|
|
name = cp = *bufp + pos; |
name = cp = buf->buf + pos; |
if ('\0' == *name) |
if (*name == '\0') |
return(ROFF_IGN); |
return(ROFF_IGN); |
namesz = roff_getname(r, &cp, ln, pos); |
namesz = roff_getname(r, &cp, ln, pos); |
name[namesz] = '\0'; |
name[namesz] = '\0'; |
Line 1758 roff_rr(ROFF_ARGS) |
|
Line 1778 roff_rr(ROFF_ARGS) |
|
prev = &r->regtab; |
prev = &r->regtab; |
while (1) { |
while (1) { |
reg = *prev; |
reg = *prev; |
if (NULL == reg || !strcmp(name, reg->key.p)) |
if (reg == NULL || !strcmp(name, reg->key.p)) |
break; |
break; |
prev = ®->next; |
prev = ®->next; |
} |
} |
if (NULL != reg) { |
if (reg != NULL) { |
*prev = reg->next; |
*prev = reg->next; |
free(reg->key.p); |
free(reg->key.p); |
free(reg); |
free(reg); |
Line 1777 roff_rm(ROFF_ARGS) |
|
Line 1797 roff_rm(ROFF_ARGS) |
|
char *cp; |
char *cp; |
size_t namesz; |
size_t namesz; |
|
|
cp = *bufp + pos; |
cp = buf->buf + pos; |
while ('\0' != *cp) { |
while (*cp != '\0') { |
name = cp; |
name = cp; |
namesz = roff_getname(r, &cp, ln, (int)(cp - *bufp)); |
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); |
if ('\\' == name[namesz]) |
if (name[namesz] == '\\') |
break; |
break; |
} |
} |
return(ROFF_IGN); |
return(ROFF_IGN); |
Line 1796 roff_it(ROFF_ARGS) |
|
Line 1816 roff_it(ROFF_ARGS) |
|
int iv; |
int iv; |
|
|
/* Parse the number of lines. */ |
/* Parse the number of lines. */ |
cp = *bufp + pos; |
cp = buf->buf + pos; |
len = strcspn(cp, " \t"); |
len = strcspn(cp, " \t"); |
cp[len] = '\0'; |
cp[len] = '\0'; |
if ((iv = mandoc_strntoi(cp, len, 10)) <= 0) { |
if ((iv = mandoc_strntoi(cp, len, 10)) <= 0) { |
mandoc_msg(MANDOCERR_IT_NONUM, r->parse, |
mandoc_msg(MANDOCERR_IT_NONUM, r->parse, |
ln, ppos, *bufp + 1); |
ln, ppos, buf->buf + 1); |
return(ROFF_IGN); |
return(ROFF_IGN); |
} |
} |
cp += len + 1; |
cp += len + 1; |
Line 1872 roff_T_(ROFF_ARGS) |
|
Line 1892 roff_T_(ROFF_ARGS) |
|
* Handle in-line equation delimiters. |
* Handle in-line equation delimiters. |
*/ |
*/ |
static enum rofferr |
static enum rofferr |
roff_eqndelim(struct roff *r, char **bufp, size_t *szp, int pos) |
roff_eqndelim(struct roff *r, struct buf *buf, int pos) |
{ |
{ |
char *cp1, *cp2; |
char *cp1, *cp2; |
const char *bef_pr, *bef_nl, *mac, *aft_nl, *aft_pr; |
const char *bef_pr, *bef_nl, *mac, *aft_nl, *aft_pr; |
Line 1884 roff_eqndelim(struct roff *r, char **bufp, size_t *szp |
|
Line 1904 roff_eqndelim(struct roff *r, char **bufp, size_t *szp |
|
* so look for a closing delimiter. |
* so look for a closing delimiter. |
*/ |
*/ |
|
|
cp1 = *bufp + pos; |
cp1 = buf->buf + pos; |
cp2 = strchr(cp1, r->eqn == NULL ? |
cp2 = strchr(cp1, r->eqn == NULL ? |
r->last_eqn->odelim : r->last_eqn->cdelim); |
r->last_eqn->odelim : r->last_eqn->cdelim); |
if (cp2 == NULL) |
if (cp2 == NULL) |
Line 1895 roff_eqndelim(struct roff *r, char **bufp, size_t *szp |
|
Line 1915 roff_eqndelim(struct roff *r, char **bufp, size_t *szp |
|
|
|
/* Handle preceding text, protecting whitespace. */ |
/* Handle preceding text, protecting whitespace. */ |
|
|
if (**bufp != '\0') { |
if (*buf->buf != '\0') { |
if (r->eqn == NULL) |
if (r->eqn == NULL) |
bef_pr = "\\&"; |
bef_pr = "\\&"; |
bef_nl = "\n"; |
bef_nl = "\n"; |
Line 1923 roff_eqndelim(struct roff *r, char **bufp, size_t *szp |
|
Line 1943 roff_eqndelim(struct roff *r, char **bufp, size_t *szp |
|
|
|
/* Do the actual replacement. */ |
/* Do the actual replacement. */ |
|
|
*szp = mandoc_asprintf(&cp1, "%s%s%s%s%s%s%s", *bufp, |
buf->sz = mandoc_asprintf(&cp1, "%s%s%s%s%s%s%s", buf->buf, |
bef_pr, bef_nl, mac, aft_nl, aft_pr, cp2) + 1; |
bef_pr, bef_nl, mac, aft_nl, aft_pr, cp2) + 1; |
free(*bufp); |
free(buf->buf); |
*bufp = cp1; |
buf->buf = cp1; |
|
|
/* Toggle the in-line state of the eqn subsystem. */ |
/* Toggle the in-line state of the eqn subsystem. */ |
|
|
Line 1939 roff_EQ(ROFF_ARGS) |
|
Line 1959 roff_EQ(ROFF_ARGS) |
|
{ |
{ |
struct eqn_node *e; |
struct eqn_node *e; |
|
|
assert(NULL == r->eqn); |
assert(r->eqn == NULL); |
e = eqn_alloc(ppos, ln, r->parse); |
e = eqn_alloc(ppos, ln, r->parse); |
|
|
if (r->last_eqn) { |
if (r->last_eqn) { |
Line 1952 roff_EQ(ROFF_ARGS) |
|
Line 1972 roff_EQ(ROFF_ARGS) |
|
|
|
r->eqn = r->last_eqn = e; |
r->eqn = r->last_eqn = e; |
|
|
if ((*bufp)[pos]) |
if (buf->buf[pos] != '\0') |
mandoc_vmsg(MANDOCERR_ARG_SKIP, r->parse, ln, pos, |
mandoc_vmsg(MANDOCERR_ARG_SKIP, r->parse, ln, pos, |
".EQ %s", *bufp + pos); |
".EQ %s", buf->buf + pos); |
|
|
return(ROFF_IGN); |
return(ROFF_IGN); |
} |
} |
Line 1994 roff_cc(ROFF_ARGS) |
|
Line 2014 roff_cc(ROFF_ARGS) |
|
{ |
{ |
const char *p; |
const char *p; |
|
|
p = *bufp + pos; |
p = buf->buf + pos; |
|
|
if ('\0' == *p || '.' == (r->control = *p++)) |
if (*p == '\0' || (r->control = *p++) == '.') |
r->control = 0; |
r->control = 0; |
|
|
if ('\0' != *p) |
if (*p != '\0') |
mandoc_msg(MANDOCERR_ARGCOUNT, r->parse, ln, ppos, NULL); |
mandoc_msg(MANDOCERR_ARGCOUNT, r->parse, ln, ppos, NULL); |
|
|
return(ROFF_IGN); |
return(ROFF_IGN); |
Line 2012 roff_tr(ROFF_ARGS) |
|
Line 2032 roff_tr(ROFF_ARGS) |
|
size_t fsz, ssz; |
size_t fsz, ssz; |
enum mandoc_esc esc; |
enum mandoc_esc esc; |
|
|
p = *bufp + pos; |
p = buf->buf + pos; |
|
|
if ('\0' == *p) { |
if (*p == '\0') { |
mandoc_msg(MANDOCERR_ARGCOUNT, r->parse, ln, ppos, NULL); |
mandoc_msg(MANDOCERR_ARGCOUNT, r->parse, ln, ppos, NULL); |
return(ROFF_IGN); |
return(ROFF_IGN); |
} |
} |
|
|
while ('\0' != *p) { |
while (*p != '\0') { |
fsz = ssz = 1; |
fsz = ssz = 1; |
|
|
first = p++; |
first = p++; |
if ('\\' == *first) { |
if (*first == '\\') { |
esc = mandoc_escape(&p, NULL, NULL); |
esc = mandoc_escape(&p, NULL, NULL); |
if (ESCAPE_ERROR == esc) { |
if (esc == ESCAPE_ERROR) { |
mandoc_msg(MANDOCERR_ESC_BAD, r->parse, |
mandoc_msg(MANDOCERR_ESC_BAD, r->parse, |
ln, (int)(p - *bufp), first); |
ln, (int)(p - buf->buf), first); |
return(ROFF_IGN); |
return(ROFF_IGN); |
} |
} |
fsz = (size_t)(p - first); |
fsz = (size_t)(p - first); |
} |
} |
|
|
second = p++; |
second = p++; |
if ('\\' == *second) { |
if (*second == '\\') { |
esc = mandoc_escape(&p, NULL, NULL); |
esc = mandoc_escape(&p, NULL, NULL); |
if (ESCAPE_ERROR == esc) { |
if (esc == ESCAPE_ERROR) { |
mandoc_msg(MANDOCERR_ESC_BAD, r->parse, |
mandoc_msg(MANDOCERR_ESC_BAD, r->parse, |
ln, (int)(p - *bufp), second); |
ln, (int)(p - buf->buf), second); |
return(ROFF_IGN); |
return(ROFF_IGN); |
} |
} |
ssz = (size_t)(p - second); |
ssz = (size_t)(p - second); |
} else if ('\0' == *second) { |
} else if (*second == '\0') { |
mandoc_msg(MANDOCERR_ARGCOUNT, r->parse, |
mandoc_msg(MANDOCERR_ARGCOUNT, r->parse, |
ln, (int)(p - *bufp), NULL); |
ln, (int)(p - buf->buf), NULL); |
second = " "; |
second = " "; |
p--; |
p--; |
} |
} |
Line 2055 roff_tr(ROFF_ARGS) |
|
Line 2075 roff_tr(ROFF_ARGS) |
|
continue; |
continue; |
} |
} |
|
|
if (NULL == r->xtab) |
if (r->xtab == NULL) |
r->xtab = mandoc_calloc(128, |
r->xtab = mandoc_calloc(128, |
sizeof(struct roffstr)); |
sizeof(struct roffstr)); |
|
|
Line 2072 roff_so(ROFF_ARGS) |
|
Line 2092 roff_so(ROFF_ARGS) |
|
{ |
{ |
char *name; |
char *name; |
|
|
name = *bufp + pos; |
name = buf->buf + pos; |
mandoc_vmsg(MANDOCERR_SO, r->parse, ln, ppos, "so %s", name); |
mandoc_vmsg(MANDOCERR_SO, r->parse, ln, ppos, "so %s", name); |
|
|
/* |
/* |
Line 2082 roff_so(ROFF_ARGS) |
|
Line 2102 roff_so(ROFF_ARGS) |
|
* or using absolute paths. |
* or using absolute paths. |
*/ |
*/ |
|
|
if ('/' == *name || strstr(name, "../") || strstr(name, "/..")) { |
if (*name == '/' || strstr(name, "../") || strstr(name, "/..")) { |
mandoc_vmsg(MANDOCERR_SO_PATH, r->parse, ln, ppos, |
mandoc_vmsg(MANDOCERR_SO_PATH, r->parse, ln, ppos, |
".so %s", name); |
".so %s", name); |
return(ROFF_ERR); |
return(ROFF_ERR); |
Line 2103 roff_userdef(ROFF_ARGS) |
|
Line 2123 roff_userdef(ROFF_ARGS) |
|
* Collect pointers to macro argument strings |
* Collect pointers to macro argument strings |
* and NUL-terminate them. |
* and NUL-terminate them. |
*/ |
*/ |
cp = *bufp + pos; |
cp = buf->buf + pos; |
for (i = 0; i < 9; i++) |
for (i = 0; i < 9; i++) |
arg[i] = '\0' == *cp ? "" : |
arg[i] = *cp == '\0' ? "" : |
mandoc_getarg(r->parse, &cp, ln, &pos); |
mandoc_getarg(r->parse, &cp, ln, &pos); |
|
|
/* |
/* |
* Expand macro arguments. |
* Expand macro arguments. |
*/ |
*/ |
*szp = 0; |
buf->sz = 0; |
n1 = cp = mandoc_strdup(r->current_string); |
n1 = cp = mandoc_strdup(r->current_string); |
while (NULL != (cp = strstr(cp, "\\$"))) { |
while ((cp = strstr(cp, "\\$")) != NULL) { |
i = cp[2] - '1'; |
i = cp[2] - '1'; |
if (0 > i || 8 < i) { |
if (0 > i || 8 < i) { |
/* Not an argument invocation. */ |
/* Not an argument invocation. */ |
Line 2121 roff_userdef(ROFF_ARGS) |
|
Line 2141 roff_userdef(ROFF_ARGS) |
|
continue; |
continue; |
} |
} |
*cp = '\0'; |
*cp = '\0'; |
*szp = mandoc_asprintf(&n2, "%s%s%s", |
buf->sz = mandoc_asprintf(&n2, "%s%s%s", |
n1, arg[i], cp + 3) + 1; |
n1, arg[i], cp + 3) + 1; |
cp = n2 + (cp - n1); |
cp = n2 + (cp - n1); |
free(n1); |
free(n1); |
Line 2132 roff_userdef(ROFF_ARGS) |
|
Line 2152 roff_userdef(ROFF_ARGS) |
|
* Replace the macro invocation |
* Replace the macro invocation |
* by the expanded macro. |
* by the expanded macro. |
*/ |
*/ |
free(*bufp); |
free(buf->buf); |
*bufp = n1; |
buf->buf = n1; |
if (0 == *szp) |
if (buf->sz == 0) |
*szp = strlen(*bufp) + 1; |
buf->sz = strlen(buf->buf) + 1; |
|
|
return(*szp > 1 && '\n' == (*bufp)[(int)*szp - 2] ? |
return(buf->sz > 1 && buf->buf[buf->sz - 2] == '\n' ? |
ROFF_REPARSE : ROFF_APPEND); |
ROFF_REPARSE : ROFF_APPEND); |
} |
} |
|
|