version 1.276, 2015/09/26 00:54:04 |
version 1.287, 2017/01/10 21:59:47 |
|
|
/* $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 Ingo Schwarze <schwarze@openbsd.org> |
* Copyright (c) 2010-2015, 2017 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 "roff_int.h" |
#include "roff_int.h" |
#include "libroff.h" |
#include "libroff.h" |
|
|
/* Maximum number of nested if-else conditionals. */ |
|
#define RSTACK_MAX 128 |
|
|
|
/* 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 |
|
|
Line 316 struct roffreg { |
|
Line 313 struct roffreg { |
|
|
|
struct roff { |
struct roff { |
struct mparse *parse; /* parse point */ |
struct mparse *parse; /* parse point */ |
const struct mchars *mchars; /* character table */ |
|
struct roffnode *last; /* leaf of stack */ |
struct roffnode *last; /* leaf of stack */ |
int *rstack; /* stack of inverted `ie' values */ |
int *rstack; /* stack of inverted `ie' values */ |
struct roffreg *regtab; /* number registers */ |
struct roffreg *regtab; /* number registers */ |
Line 785 roffhash_find(const char *p, size_t s) |
|
Line 781 roffhash_find(const char *p, size_t s) |
|
*/ |
*/ |
|
|
if (p[0] < ASCII_LO || p[0] > ASCII_HI) |
if (p[0] < ASCII_LO || p[0] > ASCII_HI) |
return(ROFF_MAX); |
return ROFF_MAX; |
|
|
buc = ROFF_HASH(p); |
buc = ROFF_HASH(p); |
|
|
if (NULL == (n = hash[buc])) |
if (NULL == (n = hash[buc])) |
return(ROFF_MAX); |
return ROFF_MAX; |
for ( ; n; n = n->next) |
for ( ; n; n = n->next) |
if (0 == strncmp(n->name, p, s) && '\0' == n->name[(int)s]) |
if (0 == strncmp(n->name, p, s) && '\0' == n->name[(int)s]) |
return((enum rofft)(n - roffs)); |
return (enum rofft)(n - roffs); |
|
|
return(ROFF_MAX); |
return ROFF_MAX; |
} |
} |
|
|
/* --- stack of request blocks -------------------------------------------- */ |
/* --- stack of request blocks -------------------------------------------- */ |
Line 901 roff_free(struct roff *r) |
|
Line 897 roff_free(struct roff *r) |
|
} |
} |
|
|
struct roff * |
struct roff * |
roff_alloc(struct mparse *parse, const struct mchars *mchars, int options) |
roff_alloc(struct mparse *parse, int options) |
{ |
{ |
struct roff *r; |
struct roff *r; |
|
|
r = mandoc_calloc(1, sizeof(struct roff)); |
r = mandoc_calloc(1, sizeof(struct roff)); |
r->parse = parse; |
r->parse = parse; |
r->mchars = mchars; |
|
r->options = options; |
r->options = options; |
r->format = options & (MPARSE_MDOC | MPARSE_MAN); |
r->format = options & (MPARSE_MDOC | MPARSE_MAN); |
r->rstackpos = -1; |
r->rstackpos = -1; |
|
|
roffhash_init(); |
roffhash_init(); |
|
|
return(r); |
return r; |
} |
} |
|
|
/* --- syntax tree state data management ---------------------------------- */ |
/* --- syntax tree state data management ---------------------------------- */ |
Line 977 roff_man_alloc(struct roff *roff, struct mparse *parse |
|
Line 972 roff_man_alloc(struct roff *roff, struct mparse *parse |
|
man->defos = defos; |
man->defos = defos; |
man->quick = quick; |
man->quick = quick; |
roff_man_alloc1(man); |
roff_man_alloc1(man); |
return(man); |
return man; |
} |
} |
|
|
/* --- syntax tree handling ----------------------------------------------- */ |
/* --- syntax tree handling ----------------------------------------------- */ |
Line 996 roff_node_alloc(struct roff_man *man, int line, int po |
|
Line 991 roff_node_alloc(struct roff_man *man, int line, int po |
|
n->sec = man->lastsec; |
n->sec = man->lastsec; |
|
|
if (man->flags & MDOC_SYNOPSIS) |
if (man->flags & MDOC_SYNOPSIS) |
n->flags |= MDOC_SYNPRETTY; |
n->flags |= NODE_SYNPRETTY; |
else |
else |
n->flags &= ~MDOC_SYNPRETTY; |
n->flags &= ~NODE_SYNPRETTY; |
if (man->flags & MDOC_NEWLINE) |
if (man->flags & MDOC_NEWLINE) |
n->flags |= MDOC_LINE; |
n->flags |= NODE_LINE; |
man->flags &= ~MDOC_NEWLINE; |
man->flags &= ~MDOC_NEWLINE; |
|
|
return(n); |
return n; |
} |
} |
|
|
void |
void |
Line 1012 roff_node_append(struct roff_man *man, struct roff_nod |
|
Line 1007 roff_node_append(struct roff_man *man, struct roff_nod |
|
|
|
switch (man->next) { |
switch (man->next) { |
case ROFF_NEXT_SIBLING: |
case ROFF_NEXT_SIBLING: |
|
if (man->last->next != NULL) { |
|
n->next = man->last->next; |
|
man->last->next->prev = n; |
|
} else |
|
man->last->parent->last = n; |
man->last->next = n; |
man->last->next = n; |
n->prev = man->last; |
n->prev = man->last; |
n->parent = man->last->parent; |
n->parent = man->last->parent; |
break; |
break; |
case ROFF_NEXT_CHILD: |
case ROFF_NEXT_CHILD: |
|
if (man->last->child != NULL) { |
|
n->next = man->last->child; |
|
man->last->child->prev = n; |
|
} else |
|
man->last->last = n; |
man->last->child = n; |
man->last->child = n; |
n->parent = man->last; |
n->parent = man->last; |
break; |
break; |
default: |
default: |
abort(); |
abort(); |
} |
} |
n->parent->nchild++; |
man->last = n; |
n->parent->last = n; |
|
|
|
/* |
|
* Copy over the normalised-data pointer of our parent. Not |
|
* everybody has one, but copying a null pointer is fine. |
|
*/ |
|
|
|
switch (n->type) { |
switch (n->type) { |
case ROFFT_BODY: |
|
if (n->end != ENDBODY_NOT) |
|
break; |
|
/* FALLTHROUGH */ |
|
case ROFFT_TAIL: |
|
/* FALLTHROUGH */ |
|
case ROFFT_HEAD: |
case ROFFT_HEAD: |
n->norm = n->parent->norm; |
|
break; |
|
default: |
|
break; |
|
} |
|
|
|
if (man->macroset == MACROSET_MDOC) |
|
mdoc_valid_pre(man, n); |
|
|
|
switch (n->type) { |
|
case ROFFT_HEAD: |
|
assert(n->parent->type == ROFFT_BLOCK); |
|
n->parent->head = n; |
n->parent->head = n; |
break; |
break; |
case ROFFT_BODY: |
case ROFFT_BODY: |
if (n->end) |
if (n->end != ENDBODY_NOT) |
break; |
return; |
assert(n->parent->type == ROFFT_BLOCK); |
|
n->parent->body = n; |
n->parent->body = n; |
break; |
break; |
case ROFFT_TAIL: |
case ROFFT_TAIL: |
assert(n->parent->type == ROFFT_BLOCK); |
|
n->parent->tail = n; |
n->parent->tail = n; |
break; |
break; |
default: |
default: |
break; |
return; |
} |
} |
man->last = n; |
|
|
/* |
|
* Copy over the normalised-data pointer of our parent. Not |
|
* everybody has one, but copying a null pointer is fine. |
|
*/ |
|
|
|
n->norm = n->parent->norm; |
|
assert(n->parent->type == ROFFT_BLOCK); |
} |
} |
|
|
void |
void |
Line 1077 roff_word_alloc(struct roff_man *man, int line, int po |
|
Line 1063 roff_word_alloc(struct roff_man *man, int line, int po |
|
n = roff_node_alloc(man, line, pos, ROFFT_TEXT, TOKEN_NONE); |
n = roff_node_alloc(man, line, pos, ROFFT_TEXT, TOKEN_NONE); |
n->string = roff_strdup(man->roff, word); |
n->string = roff_strdup(man->roff, word); |
roff_node_append(man, n); |
roff_node_append(man, n); |
if (man->macroset == MACROSET_MDOC) |
n->flags |= NODE_VALID | NODE_ENDED; |
mdoc_valid_post(man); |
|
else |
|
man_valid_post(man); |
|
man->next = ROFF_NEXT_SIBLING; |
man->next = ROFF_NEXT_SIBLING; |
} |
} |
|
|
Line 1117 roff_block_alloc(struct roff_man *man, int line, int p |
|
Line 1100 roff_block_alloc(struct roff_man *man, int line, int p |
|
n = roff_node_alloc(man, line, pos, ROFFT_BLOCK, tok); |
n = roff_node_alloc(man, line, pos, ROFFT_BLOCK, tok); |
roff_node_append(man, n); |
roff_node_append(man, n); |
man->next = ROFF_NEXT_CHILD; |
man->next = ROFF_NEXT_CHILD; |
return(n); |
return n; |
} |
} |
|
|
struct roff_node * |
struct roff_node * |
Line 1128 roff_head_alloc(struct roff_man *man, int line, int po |
|
Line 1111 roff_head_alloc(struct roff_man *man, int line, int po |
|
n = roff_node_alloc(man, line, pos, ROFFT_HEAD, tok); |
n = roff_node_alloc(man, line, pos, ROFFT_HEAD, tok); |
roff_node_append(man, n); |
roff_node_append(man, n); |
man->next = ROFF_NEXT_CHILD; |
man->next = ROFF_NEXT_CHILD; |
return(n); |
return n; |
} |
} |
|
|
struct roff_node * |
struct roff_node * |
Line 1139 roff_body_alloc(struct roff_man *man, int line, int po |
|
Line 1122 roff_body_alloc(struct roff_man *man, int line, int po |
|
n = roff_node_alloc(man, line, pos, ROFFT_BODY, tok); |
n = roff_node_alloc(man, line, pos, ROFFT_BODY, tok); |
roff_node_append(man, n); |
roff_node_append(man, n); |
man->next = ROFF_NEXT_CHILD; |
man->next = ROFF_NEXT_CHILD; |
return(n); |
return n; |
} |
} |
|
|
void |
void |
Line 1150 roff_addeqn(struct roff_man *man, const struct eqn *eq |
|
Line 1133 roff_addeqn(struct roff_man *man, const struct eqn *eq |
|
n = roff_node_alloc(man, eqn->ln, eqn->pos, ROFFT_EQN, TOKEN_NONE); |
n = roff_node_alloc(man, eqn->ln, eqn->pos, ROFFT_EQN, TOKEN_NONE); |
n->eqn = eqn; |
n->eqn = eqn; |
if (eqn->ln > man->last->line) |
if (eqn->ln > man->last->line) |
n->flags |= MDOC_LINE; |
n->flags |= NODE_LINE; |
roff_node_append(man, n); |
roff_node_append(man, n); |
man->next = ROFF_NEXT_SIBLING; |
man->next = ROFF_NEXT_SIBLING; |
} |
} |
Line 1165 roff_addtbl(struct roff_man *man, const struct tbl_spa |
|
Line 1148 roff_addtbl(struct roff_man *man, const struct tbl_spa |
|
n = roff_node_alloc(man, tbl->line, 0, ROFFT_TBL, TOKEN_NONE); |
n = roff_node_alloc(man, tbl->line, 0, ROFFT_TBL, TOKEN_NONE); |
n->span = tbl; |
n->span = tbl; |
roff_node_append(man, n); |
roff_node_append(man, n); |
if (man->macroset == MACROSET_MDOC) |
n->flags |= NODE_VALID | NODE_ENDED; |
mdoc_valid_post(man); |
|
else |
|
man_valid_post(man); |
|
man->next = ROFF_NEXT_SIBLING; |
man->next = ROFF_NEXT_SIBLING; |
} |
} |
|
|
Line 1186 roff_node_unlink(struct roff_man *man, struct roff_nod |
|
Line 1166 roff_node_unlink(struct roff_man *man, struct roff_nod |
|
/* Adjust parent. */ |
/* Adjust parent. */ |
|
|
if (n->parent != NULL) { |
if (n->parent != NULL) { |
n->parent->nchild--; |
|
if (n->parent->child == n) |
if (n->parent->child == n) |
n->parent->child = n->next; |
n->parent->child = n->next; |
if (n->parent->last == n) |
if (n->parent->last == n) |
Line 1228 roff_node_delete(struct roff_man *man, struct roff_nod |
|
Line 1207 roff_node_delete(struct roff_man *man, struct roff_nod |
|
|
|
while (n->child != NULL) |
while (n->child != NULL) |
roff_node_delete(man, n->child); |
roff_node_delete(man, n->child); |
assert(n->nchild == 0); |
|
roff_node_unlink(man, n); |
roff_node_unlink(man, n); |
roff_node_free(n); |
roff_node_free(n); |
} |
} |
Line 1335 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
Line 1313 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
res = NULL; |
res = NULL; |
break; |
break; |
case 'B': |
case 'B': |
/* FALLTHROUGH */ |
|
case 'w': |
case 'w': |
term = cp[1]; |
term = cp[1]; |
/* FALLTHROUGH */ |
/* FALLTHROUGH */ |
Line 1346 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
Line 1323 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
esc = mandoc_escape(&cp, &stnam, &inaml); |
esc = mandoc_escape(&cp, &stnam, &inaml); |
if (esc == ESCAPE_ERROR || |
if (esc == ESCAPE_ERROR || |
(esc == ESCAPE_SPECIAL && |
(esc == ESCAPE_SPECIAL && |
mchars_spec2cp(r->mchars, stnam, inaml) < 0)) |
mchars_spec2cp(stnam, inaml) < 0)) |
mandoc_vmsg(MANDOCERR_ESC_BAD, |
mandoc_vmsg(MANDOCERR_ESC_BAD, |
r->parse, ln, (int)(stesc - buf->buf), |
r->parse, ln, (int)(stesc - buf->buf), |
"%.*s", (int)(cp - stesc), stesc); |
"%.*s", (int)(cp - stesc), stesc); |
Line 1356 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
Line 1333 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
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 - buf->buf), NULL); |
ln, (int)(stesc - buf->buf), NULL); |
return(ROFF_IGN); |
return ROFF_IGN; |
} |
} |
|
|
/* |
/* |
Line 1410 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
Line 1387 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
} |
} |
switch (mandoc_escape(&cp, NULL, NULL)) { |
switch (mandoc_escape(&cp, NULL, NULL)) { |
case ESCAPE_SPECIAL: |
case ESCAPE_SPECIAL: |
/* FALLTHROUGH */ |
|
case ESCAPE_UNICODE: |
case ESCAPE_UNICODE: |
/* FALLTHROUGH */ |
|
case ESCAPE_NUMBERED: |
case ESCAPE_NUMBERED: |
/* FALLTHROUGH */ |
|
case ESCAPE_OVERSTRIKE: |
case ESCAPE_OVERSTRIKE: |
naml++; |
naml++; |
break; |
break; |
Line 1463 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
Line 1437 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
} 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, r->parse, |
ln, (int)(stesc - buf->buf), NULL); |
ln, (int)(stesc - buf->buf), NULL); |
return(ROFF_IGN); |
return ROFF_IGN; |
} |
} |
|
|
/* Replace the escape sequence by the string. */ |
/* Replace the escape sequence by the string. */ |
Line 1479 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
Line 1453 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
free(buf->buf); |
free(buf->buf); |
buf->buf = nbuf; |
buf->buf = nbuf; |
} |
} |
return(ROFF_CONT); |
return ROFF_CONT; |
} |
} |
|
|
/* |
/* |
Line 1504 roff_parsetext(struct buf *buf, int pos, int *offs) |
|
Line 1478 roff_parsetext(struct buf *buf, int pos, int *offs) |
|
*offs = 0; |
*offs = 0; |
free(roffit_macro); |
free(roffit_macro); |
roffit_lines = 0; |
roffit_lines = 0; |
return(ROFF_REPARSE); |
return ROFF_REPARSE; |
} else if (roffit_lines > 1) |
} else if (roffit_lines > 1) |
--roffit_lines; |
--roffit_lines; |
|
|
Line 1538 roff_parsetext(struct buf *buf, int pos, int *offs) |
|
Line 1512 roff_parsetext(struct buf *buf, int pos, int *offs) |
|
*p = ASCII_HYPH; |
*p = ASCII_HYPH; |
p++; |
p++; |
} |
} |
return(ROFF_CONT); |
return ROFF_CONT; |
} |
} |
|
|
enum rofferr |
enum rofferr |
Line 1560 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
Line 1534 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
(r->eqn == NULL || r->eqn_inline)) { |
(r->eqn == NULL || r->eqn_inline)) { |
e = roff_eqndelim(r, buf, 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 1568 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
Line 1542 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
|
|
e = roff_res(r, buf, ln, pos); |
e = roff_res(r, buf, ln, pos); |
if (e == ROFF_IGN) |
if (e == ROFF_IGN) |
return(e); |
return e; |
assert(e == ROFF_CONT); |
assert(e == ROFF_CONT); |
|
|
ctl = roff_getcontrol(r, buf->buf, &pos); |
ctl = roff_getcontrol(r, buf->buf, &pos); |
Line 1587 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
Line 1561 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
e = (*roffs[t].text)(r, t, buf, ln, pos, pos, offs); |
e = (*roffs[t].text)(r, t, buf, ln, pos, pos, offs); |
assert(e == ROFF_IGN || e == ROFF_CONT); |
assert(e == ROFF_IGN || e == ROFF_CONT); |
if (e != ROFF_CONT) |
if (e != ROFF_CONT) |
return(e); |
return e; |
} |
} |
if (r->eqn != NULL) |
if (r->eqn != NULL) |
return(eqn_read(&r->eqn, ln, buf->buf, ppos, offs)); |
return eqn_read(&r->eqn, ln, buf->buf, ppos, offs); |
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) |
return(roff_parsetext(buf, pos, offs)); |
return roff_parsetext(buf, pos, offs); |
|
|
/* 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, r->parse, |
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; |
|
|
/* |
/* |
* If a scope is open, go to the child handler for that macro, |
* If a scope is open, go to the child handler for that macro, |
Line 1614 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
Line 1588 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
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, buf, ln, ppos, pos, offs)); |
return (*roffs[t].sub)(r, t, buf, ln, ppos, pos, offs); |
} |
} |
|
|
/* No scope is open. This is a new request or macro. */ |
/* No scope is open. This is a new request or macro. */ |
Line 1628 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
Line 1602 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
mandoc_msg(MANDOCERR_TBLMACRO, r->parse, |
mandoc_msg(MANDOCERR_TBLMACRO, r->parse, |
ln, pos, buf->buf + spos); |
ln, pos, buf->buf + spos); |
if (t == ROFF_TS) |
if (t == ROFF_TS) |
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] != '\0' && buf->buf[pos] == ' ') |
while (buf->buf[pos] != '\0' && buf->buf[pos] == ' ') |
pos++; |
pos++; |
return(tbl_read(r->tbl, ln, buf->buf, pos)); |
return tbl_read(r->tbl, ln, buf->buf, pos); |
} |
} |
|
|
/* |
/* |
Line 1642 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
Line 1616 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
*/ |
*/ |
|
|
if (t == ROFF_MAX) |
if (t == ROFF_MAX) |
return(ROFF_CONT); |
return ROFF_CONT; |
|
|
/* Execute a roff request or a user defined macro. */ |
/* Execute a roff request or a user defined macro. */ |
|
|
assert(roffs[t].proc); |
assert(roffs[t].proc); |
return((*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs)); |
return (*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs); |
} |
} |
|
|
void |
void |
Line 1687 roff_parse(struct roff *r, char *buf, int *pos, int ln |
|
Line 1661 roff_parse(struct roff *r, char *buf, int *pos, int ln |
|
cp = buf + *pos; |
cp = buf + *pos; |
|
|
if ('\0' == *cp || '"' == *cp || '\t' == *cp || ' ' == *cp) |
if ('\0' == *cp || '"' == *cp || '\t' == *cp || ' ' == *cp) |
return(ROFF_MAX); |
return ROFF_MAX; |
|
|
mac = cp; |
mac = cp; |
maclen = roff_getname(r, &cp, ln, ppos); |
maclen = roff_getname(r, &cp, ln, ppos); |
Line 1698 roff_parse(struct roff *r, char *buf, int *pos, int ln |
|
Line 1672 roff_parse(struct roff *r, char *buf, int *pos, int ln |
|
if (ROFF_MAX != t) |
if (ROFF_MAX != t) |
*pos = cp - buf; |
*pos = cp - buf; |
|
|
return(t); |
return t; |
} |
} |
|
|
/* --- handling of request blocks ----------------------------------------- */ |
/* --- handling of request blocks ----------------------------------------- */ |
Line 1715 roff_cblock(ROFF_ARGS) |
|
Line 1689 roff_cblock(ROFF_ARGS) |
|
if (r->last == NULL) { |
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; |
} |
} |
|
|
switch (r->last->tok) { |
switch (r->last->tok) { |
case ROFF_am: |
case ROFF_am: |
/* ROFF_am1 is remapped to ROFF_am in roff_block(). */ |
/* ROFF_am1 is remapped to ROFF_am in roff_block(). */ |
/* FALLTHROUGH */ |
|
case ROFF_ami: |
case ROFF_ami: |
/* FALLTHROUGH */ |
|
case ROFF_de: |
case ROFF_de: |
/* ROFF_de1 is remapped to ROFF_de in roff_block(). */ |
/* ROFF_de1 is remapped to ROFF_de in roff_block(). */ |
/* FALLTHROUGH */ |
|
case ROFF_dei: |
case ROFF_dei: |
/* FALLTHROUGH */ |
|
case ROFF_ig: |
case ROFF_ig: |
break; |
break; |
default: |
default: |
mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse, |
mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse, |
ln, ppos, ".."); |
ln, ppos, ".."); |
return(ROFF_IGN); |
return ROFF_IGN; |
} |
} |
|
|
if (buf->buf[pos] != '\0') |
if (buf->buf[pos] != '\0') |
Line 1743 roff_cblock(ROFF_ARGS) |
|
Line 1713 roff_cblock(ROFF_ARGS) |
|
|
|
roffnode_pop(r); |
roffnode_pop(r); |
roffnode_cleanscope(r); |
roffnode_cleanscope(r); |
return(ROFF_IGN); |
return ROFF_IGN; |
|
|
} |
} |
|
|
Line 1770 roff_ccond(struct roff *r, int ln, int ppos) |
|
Line 1740 roff_ccond(struct roff *r, int ln, int ppos) |
|
|
|
switch (r->last->tok) { |
switch (r->last->tok) { |
case ROFF_el: |
case ROFF_el: |
/* FALLTHROUGH */ |
|
case ROFF_ie: |
case ROFF_ie: |
/* FALLTHROUGH */ |
|
case ROFF_if: |
case ROFF_if: |
break; |
break; |
default: |
default: |
Line 1838 roff_block(ROFF_ARGS) |
|
Line 1806 roff_block(ROFF_ARGS) |
|
if (namesz == 0 && tok != ROFF_ig) { |
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; |
} |
} |
|
|
roffnode_push(r, tok, name, ln, ppos); |
roffnode_push(r, tok, name, ln, ppos); |
Line 1853 roff_block(ROFF_ARGS) |
|
Line 1821 roff_block(ROFF_ARGS) |
|
roff_setstrn(&r->strtab, name, namesz, "", 0, 0); |
roff_setstrn(&r->strtab, name, namesz, "", 0, 0); |
|
|
if (*cp == '\0') |
if (*cp == '\0') |
return(ROFF_IGN); |
return ROFF_IGN; |
|
|
/* Get the custom end marker. */ |
/* Get the custom end marker. */ |
|
|
Line 1880 roff_block(ROFF_ARGS) |
|
Line 1848 roff_block(ROFF_ARGS) |
|
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); |
|
|
return(ROFF_IGN); |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static enum rofferr |
Line 1916 roff_block_sub(ROFF_ARGS) |
|
Line 1884 roff_block_sub(ROFF_ARGS) |
|
pos = i; |
pos = i; |
if (roff_parse(r, buf->buf, &pos, ln, ppos) != |
if (roff_parse(r, buf->buf, &pos, ln, ppos) != |
ROFF_MAX) |
ROFF_MAX) |
return(ROFF_RERUN); |
return ROFF_RERUN; |
return(ROFF_IGN); |
return ROFF_IGN; |
} |
} |
} |
} |
|
|
Line 1931 roff_block_sub(ROFF_ARGS) |
|
Line 1899 roff_block_sub(ROFF_ARGS) |
|
if (t != ROFF_cblock) { |
if (t != ROFF_cblock) { |
if (tok != ROFF_ig) |
if (tok != ROFF_ig) |
roff_setstr(r, r->last->name, buf->buf + 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, buf, ln, ppos, pos, offs)); |
return (*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs); |
} |
} |
|
|
static enum rofferr |
static enum rofferr |
Line 1945 roff_block_text(ROFF_ARGS) |
|
Line 1913 roff_block_text(ROFF_ARGS) |
|
if (tok != ROFF_ig) |
if (tok != ROFF_ig) |
roff_setstr(r, r->last->name, buf->buf + pos, 2); |
roff_setstr(r, r->last->name, buf->buf + pos, 2); |
|
|
return(ROFF_IGN); |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static enum rofferr |
Line 1967 roff_cond_sub(ROFF_ARGS) |
|
Line 1935 roff_cond_sub(ROFF_ARGS) |
|
if ((t != ROFF_MAX) && |
if ((t != ROFF_MAX) && |
(rr || roffs[t].flags & ROFFMAC_STRUCT)) { |
(rr || roffs[t].flags & ROFFMAC_STRUCT)) { |
assert(roffs[t].proc); |
assert(roffs[t].proc); |
return((*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs)); |
return (*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs); |
} |
} |
|
|
/* |
/* |
Line 1989 roff_cond_sub(ROFF_ARGS) |
|
Line 1957 roff_cond_sub(ROFF_ARGS) |
|
if (*ep != '\0') |
if (*ep != '\0') |
++ep; |
++ep; |
} |
} |
return(rr ? ROFF_CONT : ROFF_IGN); |
return rr ? ROFF_CONT : ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static enum rofferr |
Line 2010 roff_cond_text(ROFF_ARGS) |
|
Line 1978 roff_cond_text(ROFF_ARGS) |
|
if (*ep != '\0') |
if (*ep != '\0') |
++ep; |
++ep; |
} |
} |
return(rr ? ROFF_CONT : ROFF_IGN); |
return rr ? ROFF_CONT : ROFF_IGN; |
} |
} |
|
|
/* --- handling of numeric and conditional expressions -------------------- */ |
/* --- handling of numeric and conditional expressions -------------------- */ |
Line 2059 roff_getnum(const char *v, int *pos, int *res, int fla |
|
Line 2027 roff_getnum(const char *v, int *pos, int *res, int fla |
|
scaled = *res * 240 / 2.54; |
scaled = *res * 240 / 2.54; |
break; |
break; |
case 'v': |
case 'v': |
/* FALLTHROUGH */ |
|
case 'P': |
case 'P': |
scaled = *res * 40; |
scaled = *res * 40; |
break; |
break; |
case 'm': |
case 'm': |
/* FALLTHROUGH */ |
|
case 'n': |
case 'n': |
scaled = *res * 24; |
scaled = *res * 24; |
break; |
break; |
Line 2086 roff_getnum(const char *v, int *pos, int *res, int fla |
|
Line 2052 roff_getnum(const char *v, int *pos, int *res, int fla |
|
*res = scaled; |
*res = scaled; |
|
|
*pos = p + 1; |
*pos = p + 1; |
return(1); |
return 1; |
} |
} |
|
|
/* |
/* |
|
|
else if (*s3 != '\0') |
else if (*s3 != '\0') |
s3++; |
s3++; |
*pos = s3 - v; |
*pos = s3 - v; |
return(match); |
return match; |
} |
} |
|
|
/* |
/* |
Line 2151 roff_evalcond(struct roff *r, int ln, char *v, int *po |
|
Line 2117 roff_evalcond(struct roff *r, int ln, char *v, int *po |
|
|
|
switch (v[*pos]) { |
switch (v[*pos]) { |
case '\0': |
case '\0': |
return(0); |
return 0; |
case 'n': |
case 'n': |
/* FALLTHROUGH */ |
|
case 'o': |
case 'o': |
(*pos)++; |
(*pos)++; |
return(wanttrue); |
return wanttrue; |
case 'c': |
case 'c': |
/* FALLTHROUGH */ |
|
case 'd': |
case 'd': |
/* FALLTHROUGH */ |
|
case 'e': |
case 'e': |
/* FALLTHROUGH */ |
|
case 't': |
case 't': |
/* FALLTHROUGH */ |
|
case 'v': |
case 'v': |
(*pos)++; |
(*pos)++; |
return(!wanttrue); |
return !wanttrue; |
case 'r': |
case 'r': |
cp = name = v + ++*pos; |
cp = name = v + ++*pos; |
sz = roff_getname(r, &cp, ln, *pos); |
sz = roff_getname(r, &cp, ln, *pos); |
*pos = cp - v; |
*pos = cp - v; |
return((sz && roff_hasregn(r, name, sz)) == wanttrue); |
return (sz && roff_hasregn(r, name, sz)) == wanttrue; |
default: |
default: |
break; |
break; |
} |
} |
|
|
savepos = *pos; |
savepos = *pos; |
if (roff_evalnum(r, ln, v, pos, &number, ROFFNUM_SCALE)) |
if (roff_evalnum(r, ln, v, pos, &number, ROFFNUM_SCALE)) |
return((number > 0) == wanttrue); |
return (number > 0) == wanttrue; |
else if (*pos == savepos) |
else if (*pos == savepos) |
return(roff_evalstrcond(v, pos) == wanttrue); |
return roff_evalstrcond(v, pos) == wanttrue; |
else |
else |
return (0); |
return 0; |
} |
} |
|
|
static enum rofferr |
static enum rofferr |
roff_line_ignore(ROFF_ARGS) |
roff_line_ignore(ROFF_ARGS) |
{ |
{ |
|
|
return(ROFF_IGN); |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static enum rofferr |
Line 2199 roff_insec(ROFF_ARGS) |
|
Line 2160 roff_insec(ROFF_ARGS) |
|
|
|
mandoc_msg(MANDOCERR_REQ_INSEC, r->parse, |
mandoc_msg(MANDOCERR_REQ_INSEC, r->parse, |
ln, ppos, roffs[tok].name); |
ln, ppos, roffs[tok].name); |
return(ROFF_IGN); |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static enum rofferr |
Line 2208 roff_unsupp(ROFF_ARGS) |
|
Line 2169 roff_unsupp(ROFF_ARGS) |
|
|
|
mandoc_msg(MANDOCERR_REQ_UNSUPP, r->parse, |
mandoc_msg(MANDOCERR_REQ_UNSUPP, r->parse, |
ln, ppos, roffs[tok].name); |
ln, ppos, roffs[tok].name); |
return(ROFF_IGN); |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static enum rofferr |
Line 2286 roff_cond(ROFF_ARGS) |
|
Line 2247 roff_cond(ROFF_ARGS) |
|
|
|
out: |
out: |
*offs = pos; |
*offs = pos; |
return(ROFF_RERUN); |
return ROFF_RERUN; |
} |
} |
|
|
static enum rofferr |
static enum rofferr |
Line 2311 roff_ds(ROFF_ARGS) |
|
Line 2272 roff_ds(ROFF_ARGS) |
|
|
|
name = string = buf->buf + pos; |
name = string = buf->buf + pos; |
if (*name == '\0') |
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 == '"') |
Line 2324 roff_ds(ROFF_ARGS) |
|
Line 2285 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); |
return(ROFF_IGN); |
return ROFF_IGN; |
} |
} |
|
|
/* |
/* |
Line 2340 roff_getop(const char *v, int *pos, char *res) |
|
Line 2301 roff_getop(const char *v, int *pos, char *res) |
|
|
|
switch (*res) { |
switch (*res) { |
case '+': |
case '+': |
/* FALLTHROUGH */ |
|
case '-': |
case '-': |
/* FALLTHROUGH */ |
|
case '*': |
case '*': |
/* FALLTHROUGH */ |
|
case '/': |
case '/': |
/* FALLTHROUGH */ |
|
case '%': |
case '%': |
/* FALLTHROUGH */ |
|
case '&': |
case '&': |
/* FALLTHROUGH */ |
|
case ':': |
case ':': |
break; |
break; |
case '<': |
case '<': |
Line 2390 roff_getop(const char *v, int *pos, char *res) |
|
Line 2345 roff_getop(const char *v, int *pos, char *res) |
|
(*pos)++; |
(*pos)++; |
break; |
break; |
default: |
default: |
return(0); |
return 0; |
} |
} |
(*pos)++; |
(*pos)++; |
|
|
return(*res); |
return *res; |
} |
} |
|
|
/* |
/* |
Line 2407 roff_evalpar(struct roff *r, int ln, |
|
Line 2362 roff_evalpar(struct roff *r, int ln, |
|
{ |
{ |
|
|
if ('(' != v[*pos]) |
if ('(' != v[*pos]) |
return(roff_getnum(v, pos, res, flags)); |
return roff_getnum(v, pos, res, flags); |
|
|
(*pos)++; |
(*pos)++; |
if ( ! roff_evalnum(r, ln, v, pos, res, flags | ROFFNUM_WHITE)) |
if ( ! roff_evalnum(r, ln, v, pos, res, flags | ROFFNUM_WHITE)) |
return(0); |
return 0; |
|
|
/* |
/* |
* Omission of the closing parenthesis |
* Omission of the closing parenthesis |
Line 2422 roff_evalpar(struct roff *r, int ln, |
|
Line 2377 roff_evalpar(struct roff *r, int ln, |
|
if (')' == v[*pos]) |
if (')' == v[*pos]) |
(*pos)++; |
(*pos)++; |
else if (NULL == res) |
else if (NULL == res) |
return(0); |
return 0; |
|
|
return(1); |
return 1; |
} |
} |
|
|
/* |
/* |
Line 2448 roff_evalnum(struct roff *r, int ln, const char *v, |
|
Line 2403 roff_evalnum(struct roff *r, int ln, const char *v, |
|
(*pos)++; |
(*pos)++; |
|
|
if ( ! roff_evalpar(r, ln, v, pos, res, flags)) |
if ( ! roff_evalpar(r, ln, v, pos, res, flags)) |
return(0); |
return 0; |
|
|
while (1) { |
while (1) { |
if (flags & ROFFNUM_WHITE) |
if (flags & ROFFNUM_WHITE) |
Line 2463 roff_evalnum(struct roff *r, int ln, const char *v, |
|
Line 2418 roff_evalnum(struct roff *r, int ln, const char *v, |
|
(*pos)++; |
(*pos)++; |
|
|
if ( ! roff_evalpar(r, ln, v, pos, &operand2, flags)) |
if ( ! roff_evalpar(r, ln, v, pos, &operand2, flags)) |
return(0); |
return 0; |
|
|
if (flags & ROFFNUM_WHITE) |
if (flags & ROFFNUM_WHITE) |
while (isspace((unsigned char)v[*pos])) |
while (isspace((unsigned char)v[*pos])) |
Line 2536 roff_evalnum(struct roff *r, int ln, const char *v, |
|
Line 2491 roff_evalnum(struct roff *r, int ln, const char *v, |
|
abort(); |
abort(); |
} |
} |
} |
} |
return(1); |
return 1; |
} |
} |
|
|
/* --- register management ------------------------------------------------ */ |
/* --- register management ------------------------------------------------ */ |
Line 2582 roff_getregro(const struct roff *r, const char *name) |
|
Line 2537 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->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. */ |
return(1); |
return 1; |
case 'H': /* Fixed horizontal resolution. */ |
case 'H': /* Fixed horizontal resolution. */ |
return (24); |
return 24; |
case 'j': /* Always adjust left margin only. */ |
case 'j': /* Always adjust left margin only. */ |
return(0); |
return 0; |
case 'T': /* Some output device is always defined. */ |
case 'T': /* Some output device is always defined. */ |
return(1); |
return 1; |
case 'V': /* Fixed vertical resolution. */ |
case 'V': /* Fixed vertical resolution. */ |
return (40); |
return 40; |
default: |
default: |
return (-1); |
return -1; |
} |
} |
} |
} |
|
|
Line 2609 roff_getreg(const struct roff *r, const char *name) |
|
Line 2564 roff_getreg(const struct roff *r, const char *name) |
|
if ('.' == name[0] && '\0' != name[1] && '\0' == name[2]) { |
if ('.' == name[0] && '\0' != name[1] && '\0' == name[2]) { |
val = roff_getregro(r, name + 1); |
val = roff_getregro(r, name + 1); |
if (-1 != val) |
if (-1 != val) |
return (val); |
return val; |
} |
} |
|
|
for (reg = r->regtab; reg; reg = reg->next) |
for (reg = r->regtab; reg; reg = reg->next) |
if (0 == strcmp(name, reg->key.p)) |
if (0 == strcmp(name, reg->key.p)) |
return(reg->val); |
return reg->val; |
|
|
return(0); |
return 0; |
} |
} |
|
|
static int |
static int |
Line 2628 roff_getregn(const struct roff *r, const char *name, s |
|
Line 2583 roff_getregn(const struct roff *r, const char *name, s |
|
if ('.' == name[0] && 2 == len) { |
if ('.' == name[0] && 2 == len) { |
val = roff_getregro(r, name + 1); |
val = roff_getregro(r, name + 1); |
if (-1 != val) |
if (-1 != val) |
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)) |
return(reg->val); |
return reg->val; |
|
|
return(0); |
return 0; |
} |
} |
|
|
static int |
static int |
Line 2648 roff_hasregn(const struct roff *r, const char *name, s |
|
Line 2603 roff_hasregn(const struct roff *r, const char *name, s |
|
if ('.' == name[0] && 2 == len) { |
if ('.' == name[0] && 2 == len) { |
val = roff_getregro(r, name + 1); |
val = roff_getregro(r, name + 1); |
if (-1 != val) |
if (-1 != val) |
return(1); |
return 1; |
} |
} |
|
|
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)) |
return(1); |
return 1; |
|
|
return(0); |
return 0; |
} |
} |
|
|
static void |
static void |
Line 2682 roff_nr(ROFF_ARGS) |
|
Line 2637 roff_nr(ROFF_ARGS) |
|
|
|
key = val = buf->buf + pos; |
key = val = buf->buf + pos; |
if (*key == '\0') |
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; |
Line 2696 roff_nr(ROFF_ARGS) |
|
Line 2651 roff_nr(ROFF_ARGS) |
|
if (roff_evalnum(r, ln, val, NULL, &iv, ROFFNUM_SCALE)) |
if (roff_evalnum(r, ln, val, NULL, &iv, ROFFNUM_SCALE)) |
roff_setreg(r, key, iv, sign); |
roff_setreg(r, key, iv, sign); |
|
|
return(ROFF_IGN); |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static enum rofferr |
Line 2708 roff_rr(ROFF_ARGS) |
|
Line 2663 roff_rr(ROFF_ARGS) |
|
|
|
name = cp = buf->buf + pos; |
name = cp = buf->buf + pos; |
if (*name == '\0') |
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 2724 roff_rr(ROFF_ARGS) |
|
Line 2679 roff_rr(ROFF_ARGS) |
|
free(reg->key.p); |
free(reg->key.p); |
free(reg); |
free(reg); |
} |
} |
return(ROFF_IGN); |
return ROFF_IGN; |
} |
} |
|
|
/* --- handler functions for roff requests -------------------------------- */ |
/* --- handler functions for roff requests -------------------------------- */ |
Line 2744 roff_rm(ROFF_ARGS) |
|
Line 2699 roff_rm(ROFF_ARGS) |
|
if (name[namesz] == '\\') |
if (name[namesz] == '\\') |
break; |
break; |
} |
} |
return(ROFF_IGN); |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static enum rofferr |
Line 2757 roff_it(ROFF_ARGS) |
|
Line 2712 roff_it(ROFF_ARGS) |
|
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, r->parse, |
ln, ppos, buf->buf + 1); |
ln, ppos, buf->buf + 1); |
return(ROFF_IGN); |
return ROFF_IGN; |
} |
} |
|
|
while (isspace((unsigned char)buf->buf[pos])) |
while (isspace((unsigned char)buf->buf[pos])) |
Line 2773 roff_it(ROFF_ARGS) |
|
Line 2728 roff_it(ROFF_ARGS) |
|
roffit_macro = mandoc_strdup(iv != 1 || |
roffit_macro = mandoc_strdup(iv != 1 || |
strcmp(buf->buf + pos, "an-trap") ? |
strcmp(buf->buf + pos, "an-trap") ? |
buf->buf + pos : "br"); |
buf->buf + pos : "br"); |
return(ROFF_IGN); |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static enum rofferr |
Line 2788 roff_Dd(ROFF_ARGS) |
|
Line 2743 roff_Dd(ROFF_ARGS) |
|
if (r->format == 0) |
if (r->format == 0) |
r->format = MPARSE_MDOC; |
r->format = MPARSE_MDOC; |
|
|
return(ROFF_CONT); |
return ROFF_CONT; |
} |
} |
|
|
static enum rofferr |
static enum rofferr |
Line 2803 roff_TH(ROFF_ARGS) |
|
Line 2758 roff_TH(ROFF_ARGS) |
|
if (r->format == 0) |
if (r->format == 0) |
r->format = MPARSE_MAN; |
r->format = MPARSE_MAN; |
|
|
return(ROFF_CONT); |
return ROFF_CONT; |
} |
} |
|
|
static enum rofferr |
static enum rofferr |
Line 2817 roff_TE(ROFF_ARGS) |
|
Line 2772 roff_TE(ROFF_ARGS) |
|
free(buf->buf); |
free(buf->buf); |
buf->buf = mandoc_strdup(".sp"); |
buf->buf = mandoc_strdup(".sp"); |
buf->sz = 4; |
buf->sz = 4; |
return(ROFF_REPARSE); |
return ROFF_REPARSE; |
} |
} |
return(ROFF_IGN); |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static enum rofferr |
Line 2832 roff_T_(ROFF_ARGS) |
|
Line 2787 roff_T_(ROFF_ARGS) |
|
else |
else |
tbl_restart(ppos, ln, r->tbl); |
tbl_restart(ppos, ln, r->tbl); |
|
|
return(ROFF_IGN); |
return ROFF_IGN; |
} |
} |
|
|
/* |
/* |
Line 2855 roff_eqndelim(struct roff *r, struct buf *buf, int pos |
|
Line 2810 roff_eqndelim(struct roff *r, struct buf *buf, int 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) |
return(ROFF_CONT); |
return ROFF_CONT; |
|
|
*cp2++ = '\0'; |
*cp2++ = '\0'; |
bef_pr = bef_nl = aft_nl = aft_pr = ""; |
bef_pr = bef_nl = aft_nl = aft_pr = ""; |
Line 2898 roff_eqndelim(struct roff *r, struct buf *buf, int pos |
|
Line 2853 roff_eqndelim(struct roff *r, struct buf *buf, int pos |
|
/* Toggle the in-line state of the eqn subsystem. */ |
/* Toggle the in-line state of the eqn subsystem. */ |
|
|
r->eqn_inline = r->eqn == NULL; |
r->eqn_inline = r->eqn == NULL; |
return(ROFF_REPARSE); |
return ROFF_REPARSE; |
} |
} |
|
|
static enum rofferr |
static enum rofferr |
Line 2923 roff_EQ(ROFF_ARGS) |
|
Line 2878 roff_EQ(ROFF_ARGS) |
|
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); |
|
|
return(ROFF_IGN); |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static enum rofferr |
Line 2931 roff_EN(ROFF_ARGS) |
|
Line 2886 roff_EN(ROFF_ARGS) |
|
{ |
{ |
|
|
mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse, ln, ppos, "EN"); |
mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse, ln, ppos, "EN"); |
return(ROFF_IGN); |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static enum rofferr |
Line 2953 roff_TS(ROFF_ARGS) |
|
Line 2908 roff_TS(ROFF_ARGS) |
|
r->first_tbl = r->last_tbl = tbl; |
r->first_tbl = r->last_tbl = tbl; |
|
|
r->tbl = r->last_tbl = tbl; |
r->tbl = r->last_tbl = tbl; |
return(ROFF_IGN); |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static enum rofferr |
Line 2961 roff_brp(ROFF_ARGS) |
|
Line 2916 roff_brp(ROFF_ARGS) |
|
{ |
{ |
|
|
buf->buf[pos - 1] = '\0'; |
buf->buf[pos - 1] = '\0'; |
return(ROFF_CONT); |
return ROFF_CONT; |
} |
} |
|
|
static enum rofferr |
static enum rofferr |
Line 2978 roff_cc(ROFF_ARGS) |
|
Line 2933 roff_cc(ROFF_ARGS) |
|
mandoc_vmsg(MANDOCERR_ARG_EXCESS, r->parse, |
mandoc_vmsg(MANDOCERR_ARG_EXCESS, r->parse, |
ln, p - buf->buf, "cc ... %s", p); |
ln, p - buf->buf, "cc ... %s", p); |
|
|
return(ROFF_IGN); |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static enum rofferr |
Line 2992 roff_tr(ROFF_ARGS) |
|
Line 2947 roff_tr(ROFF_ARGS) |
|
|
|
if (*p == '\0') { |
if (*p == '\0') { |
mandoc_msg(MANDOCERR_REQ_EMPTY, r->parse, ln, ppos, "tr"); |
mandoc_msg(MANDOCERR_REQ_EMPTY, r->parse, ln, ppos, "tr"); |
return(ROFF_IGN); |
return ROFF_IGN; |
} |
} |
|
|
while (*p != '\0') { |
while (*p != '\0') { |
Line 3004 roff_tr(ROFF_ARGS) |
|
Line 2959 roff_tr(ROFF_ARGS) |
|
if (esc == ESCAPE_ERROR) { |
if (esc == ESCAPE_ERROR) { |
mandoc_msg(MANDOCERR_ESC_BAD, r->parse, |
mandoc_msg(MANDOCERR_ESC_BAD, r->parse, |
ln, (int)(p - buf->buf), first); |
ln, (int)(p - buf->buf), first); |
return(ROFF_IGN); |
return ROFF_IGN; |
} |
} |
fsz = (size_t)(p - first); |
fsz = (size_t)(p - first); |
} |
} |
Line 3015 roff_tr(ROFF_ARGS) |
|
Line 2970 roff_tr(ROFF_ARGS) |
|
if (esc == ESCAPE_ERROR) { |
if (esc == ESCAPE_ERROR) { |
mandoc_msg(MANDOCERR_ESC_BAD, r->parse, |
mandoc_msg(MANDOCERR_ESC_BAD, r->parse, |
ln, (int)(p - buf->buf), 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 (*second == '\0') { |
} else if (*second == '\0') { |
Line 3040 roff_tr(ROFF_ARGS) |
|
Line 2995 roff_tr(ROFF_ARGS) |
|
r->xtab[(int)*first].sz = ssz; |
r->xtab[(int)*first].sz = ssz; |
} |
} |
|
|
return(ROFF_IGN); |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static enum rofferr |
Line 3066 roff_so(ROFF_ARGS) |
|
Line 3021 roff_so(ROFF_ARGS) |
|
free(buf->buf); |
free(buf->buf); |
buf->buf = cp; |
buf->buf = cp; |
*offs = 0; |
*offs = 0; |
return(ROFF_REPARSE); |
return ROFF_REPARSE; |
} |
} |
|
|
*offs = pos; |
*offs = pos; |
return(ROFF_SO); |
return ROFF_SO; |
} |
} |
|
|
/* --- user defined strings and macros ------------------------------------ */ |
/* --- user defined strings and macros ------------------------------------ */ |
Line 3198 roff_userdef(ROFF_ARGS) |
|
Line 3153 roff_userdef(ROFF_ARGS) |
|
buf->buf = n1; |
buf->buf = n1; |
*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_APPEND; |
} |
} |
|
|
static size_t |
static size_t |
Line 3210 roff_getname(struct roff *r, char **cpp, int ln, int p |
|
Line 3165 roff_getname(struct roff *r, char **cpp, int ln, int p |
|
|
|
name = *cpp; |
name = *cpp; |
if ('\0' == *name) |
if ('\0' == *name) |
return(0); |
return 0; |
|
|
/* Read until end of name and terminate it with NUL. */ |
/* Read until end of name and terminate it with NUL. */ |
for (cp = name; 1; cp++) { |
for (cp = name; 1; cp++) { |
Line 3237 roff_getname(struct roff *r, char **cpp, int ln, int p |
|
Line 3192 roff_getname(struct roff *r, char **cpp, int ln, int p |
|
cp++; |
cp++; |
|
|
*cpp = cp; |
*cpp = cp; |
return(namesz); |
return namesz; |
} |
} |
|
|
/* |
/* |
Line 3337 roff_getstrn(const struct roff *r, const char *name, s |
|
Line 3292 roff_getstrn(const struct roff *r, const char *name, s |
|
for (n = r->strtab; n; n = n->next) |
for (n = r->strtab; n; n = n->next) |
if (0 == strncmp(name, n->key.p, len) && |
if (0 == strncmp(name, n->key.p, len) && |
'\0' == n->key.p[(int)len]) |
'\0' == n->key.p[(int)len]) |
return(n->val.p); |
return n->val.p; |
|
|
for (i = 0; i < PREDEFS_MAX; i++) |
for (i = 0; i < PREDEFS_MAX; i++) |
if (0 == strncmp(name, predefs[i].name, len) && |
if (0 == strncmp(name, predefs[i].name, len) && |
'\0' == predefs[i].name[(int)len]) |
'\0' == predefs[i].name[(int)len]) |
return(predefs[i].str); |
return predefs[i].str; |
|
|
return(NULL); |
return NULL; |
} |
} |
|
|
static void |
static void |
Line 3366 const struct tbl_span * |
|
Line 3321 const struct tbl_span * |
|
roff_span(const struct roff *r) |
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 * |
const struct eqn * |
roff_eqn(const struct roff *r) |
roff_eqn(const struct roff *r) |
{ |
{ |
|
|
return(r->last_eqn ? &r->last_eqn->eqn : NULL); |
return r->last_eqn ? &r->last_eqn->eqn : NULL; |
} |
} |
|
|
/* |
/* |
Line 3391 roff_strdup(const struct roff *r, const char *p) |
|
Line 3346 roff_strdup(const struct roff *r, const char *p) |
|
enum mandoc_esc esc; |
enum mandoc_esc esc; |
|
|
if (NULL == r->xmbtab && NULL == r->xtab) |
if (NULL == r->xmbtab && NULL == r->xtab) |
return(mandoc_strdup(p)); |
return mandoc_strdup(p); |
else if ('\0' == *p) |
else if ('\0' == *p) |
return(mandoc_strdup("")); |
return mandoc_strdup(""); |
|
|
/* |
/* |
* Step through each character looking for term matches |
* Step through each character looking for term matches |
Line 3465 roff_strdup(const struct roff *r, const char *p) |
|
Line 3420 roff_strdup(const struct roff *r, const char *p) |
|
} |
} |
|
|
res[(int)ssz] = '\0'; |
res[(int)ssz] = '\0'; |
return(res); |
return res; |
} |
} |
|
|
int |
int |
roff_getformat(const struct roff *r) |
roff_getformat(const struct roff *r) |
{ |
{ |
|
|
return(r->format); |
return r->format; |
} |
} |
|
|
/* |
/* |
Line 3495 roff_getcontrol(const struct roff *r, const char *cp, |
|
Line 3450 roff_getcontrol(const struct roff *r, const char *cp, |
|
if (0 != r->control && cp[pos] == r->control) |
if (0 != r->control && cp[pos] == r->control) |
pos++; |
pos++; |
else if (0 != r->control) |
else if (0 != r->control) |
return(0); |
return 0; |
else if ('\\' == cp[pos] && '.' == cp[pos + 1]) |
else if ('\\' == cp[pos] && '.' == cp[pos + 1]) |
pos += 2; |
pos += 2; |
else if ('.' == cp[pos] || '\'' == cp[pos]) |
else if ('.' == cp[pos] || '\'' == cp[pos]) |
pos++; |
pos++; |
else |
else |
return(0); |
return 0; |
|
|
while (' ' == cp[pos] || '\t' == cp[pos]) |
while (' ' == cp[pos] || '\t' == cp[pos]) |
pos++; |
pos++; |
|
|
*ppos = pos; |
*ppos = pos; |
return(1); |
return 1; |
} |
} |