version 1.315, 2017/06/18 17:36:03 |
version 1.320, 2017/07/08 15:28:09 |
|
|
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 rstacksz; /* current size limit of rstack */ |
int rstacksz; /* current size limit of rstack */ |
Line 330 const char *__roff_name[MAN_MAX + 1] = { |
|
Line 329 const char *__roff_name[MAN_MAX + 1] = { |
|
"RE", "RS", "DT", "UC", |
"RE", "RS", "DT", "UC", |
"PD", "AT", "in", |
"PD", "AT", "in", |
"OP", "EX", "EE", "UR", |
"OP", "EX", "EE", "UR", |
"UE", NULL |
"UE", "MT", "ME", NULL |
}; |
}; |
const char *const *roff_name = __roff_name; |
const char *const *roff_name = __roff_name; |
|
|
|
|
roff_free1(struct roff *r) |
roff_free1(struct roff *r) |
{ |
{ |
struct tbl_node *tbl; |
struct tbl_node *tbl; |
struct eqn_node *e; |
|
int i; |
int i; |
|
|
while (NULL != (tbl = r->first_tbl)) { |
while (NULL != (tbl = r->first_tbl)) { |
Line 704 roff_free1(struct roff *r) |
|
Line 702 roff_free1(struct roff *r) |
|
} |
} |
r->first_tbl = r->last_tbl = r->tbl = NULL; |
r->first_tbl = r->last_tbl = r->tbl = NULL; |
|
|
while (NULL != (e = r->first_eqn)) { |
if (r->last_eqn != NULL) |
r->first_eqn = e->next; |
eqn_free(r->last_eqn); |
eqn_free(e); |
r->last_eqn = r->eqn = NULL; |
} |
|
r->first_eqn = r->last_eqn = r->eqn = NULL; |
|
|
|
while (r->last) |
while (r->last) |
roffnode_pop(r); |
roffnode_pop(r); |
Line 819 roff_man_free(struct roff_man *man) |
|
Line 815 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 984 roff_body_alloc(struct roff_man *man, int line, int po |
|
Line 980 roff_body_alloc(struct roff_man *man, int line, int po |
|
} |
} |
|
|
void |
void |
roff_addeqn(struct roff_man *man, const struct eqn *eqn) |
|
{ |
|
struct roff_node *n; |
|
|
|
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) |
roff_addtbl(struct roff_man *man, const struct tbl_span *tbl) |
{ |
{ |
struct roff_node *n; |
struct roff_node *n; |
Line 1055 roff_node_free(struct roff_node *n) |
|
Line 1038 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); |
|
if (n->eqn != NULL) |
|
eqn_box_free(n->eqn); |
free(n->string); |
free(n->string); |
free(n); |
free(n); |
} |
} |
Line 1138 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
Line 1123 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
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 */ |
enum mdoc_os os_e; /* kind of RCS id seen */ |
enum mandoc_os os_e; /* kind of RCS id seen */ |
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 */ |
Line 1161 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
Line 1146 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
/* Comment found, look for RCS id. */ |
/* Comment found, look for RCS id. */ |
|
|
if ((cp = strstr(stesc, "$" "OpenBSD")) != NULL) { |
if ((cp = strstr(stesc, "$" "OpenBSD")) != NULL) { |
os_e = MDOC_OS_OPENBSD; |
os_e = MANDOC_OS_OPENBSD; |
cp += 8; |
cp += 8; |
} else if ((cp = strstr(stesc, "$" "NetBSD")) != NULL) { |
} else if ((cp = strstr(stesc, "$" "NetBSD")) != NULL) { |
os_e = MDOC_OS_NETBSD; |
os_e = MANDOC_OS_NETBSD; |
cp += 7; |
cp += 7; |
} |
} |
if (cp != NULL && |
if (cp != NULL && |
Line 1512 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
Line 1497 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
return e; |
return e; |
assert(e == ROFF_CONT); |
assert(e == ROFF_CONT); |
} |
} |
if (r->eqn != NULL) |
if (r->eqn != NULL && strncmp(buf->buf + ppos, ".EN", 3)) { |
return eqn_read(&r->eqn, ln, buf->buf, ppos, offs); |
eqn_read(r->eqn, buf->buf + ppos); |
|
return ROFF_IGN; |
|
} |
if (r->tbl != NULL && ( ! ctl || buf->buf[pos] == '\0')) |
if (r->tbl != NULL && ( ! ctl || buf->buf[pos] == '\0')) |
return tbl_read(r->tbl, ln, buf->buf, ppos); |
return tbl_read(r->tbl, ln, buf->buf, ppos); |
if ( ! ctl) |
if ( ! ctl) |
Line 1593 roff_endparse(struct roff *r) |
|
Line 1580 roff_endparse(struct roff *r) |
|
|
|
if (r->eqn) { |
if (r->eqn) { |
mandoc_msg(MANDOCERR_BLK_NOEND, r->parse, |
mandoc_msg(MANDOCERR_BLK_NOEND, r->parse, |
r->eqn->eqn.ln, r->eqn->eqn.pos, "EQ"); |
r->eqn->node->line, r->eqn->node->pos, "EQ"); |
eqn_end(&r->eqn); |
eqn_parse(r->eqn); |
|
r->eqn = NULL; |
} |
} |
|
|
if (r->tbl) { |
if (r->tbl) { |
Line 1926 roff_cond_sub(ROFF_ARGS) |
|
Line 1914 roff_cond_sub(ROFF_ARGS) |
|
|
|
rr = r->last->rule; |
rr = r->last->rule; |
roffnode_cleanscope(r); |
roffnode_cleanscope(r); |
t = roff_parse(r, buf->buf, &pos, ln, ppos); |
|
|
|
/* |
/* |
* 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 1948 roff_cond_sub(ROFF_ARGS) |
|
Line 1927 roff_cond_sub(ROFF_ARGS) |
|
/* Always check for the closing delimiter `\}'. */ |
/* Always check for the closing delimiter `\}'. */ |
|
|
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); |
} |
roff_ccond(r, ln, ep - buf->buf); |
if (*ep != '\0') |
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); |
|
return t != TOKEN_NONE && (rr || roffs[t].flags & ROFFMAC_STRUCT) |
|
? (*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs) : rr |
|
? ROFF_CONT : ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static enum rofferr |
Line 2871 roff_eqndelim(struct roff *r, struct buf *buf, int pos |
|
Line 2865 roff_eqndelim(struct roff *r, struct buf *buf, int pos |
|
static enum rofferr |
static enum rofferr |
roff_EQ(ROFF_ARGS) |
roff_EQ(ROFF_ARGS) |
{ |
{ |
struct eqn_node *e; |
struct roff_node *n; |
|
|
|
n = roff_node_alloc(r->man, ln, ppos, ROFFT_EQN, TOKEN_NONE); |
|
if (ln > r->man->last->line) |
|
n->flags |= NODE_LINE; |
|
n->eqn = mandoc_calloc(1, sizeof(*n->eqn)); |
|
n->eqn->expectargs = UINT_MAX; |
|
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_vmsg(MANDOCERR_ARG_SKIP, r->parse, ln, pos, |
".EQ %s", buf->buf + pos); |
".EQ %s", buf->buf + pos); |
Line 2896 roff_EQ(ROFF_ARGS) |
|
Line 2893 roff_EQ(ROFF_ARGS) |
|
static enum rofferr |
static enum rofferr |
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, r->parse, ln, ppos, "EN"); |
|
if (buf->buf[pos] != '\0') |
|
mandoc_vmsg(MANDOCERR_ARG_SKIP, r->parse, ln, pos, |
|
"EN %s", buf->buf + pos); |
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
Line 2931 roff_onearg(ROFF_ARGS) |
|
Line 2934 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 (roffce_node != NULL && (tok == ROFF_ce || tok == ROFF_rj)) { |
if (roffce_node != NULL && (tok == ROFF_ce || tok == ROFF_rj)) { |
Line 3602 roff_span(const struct roff *r) |
|
Line 3606 roff_span(const struct roff *r) |
|
{ |
{ |
|
|
return r->tbl ? tbl_span(r->tbl) : NULL; |
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; |
|
} |
} |
|
|
/* |
/* |