version 1.339, 2018/08/23 14:29:39 |
version 1.349, 2018/12/13 11:55:47 |
|
|
#include <stdlib.h> |
#include <stdlib.h> |
#include <string.h> |
#include <string.h> |
|
|
#include "mandoc.h" |
|
#include "mandoc_aux.h" |
#include "mandoc_aux.h" |
#include "mandoc_ohash.h" |
#include "mandoc_ohash.h" |
|
#include "mandoc.h" |
#include "roff.h" |
#include "roff.h" |
|
#include "mandoc_parse.h" |
#include "libmandoc.h" |
#include "libmandoc.h" |
#include "roff_int.h" |
#include "roff_int.h" |
#include "libroff.h" |
#include "tbl_parse.h" |
|
#include "eqn_parse.h" |
|
|
/* Maximum number of string expansions per line, to break infinite loops. */ |
/* Maximum number of string expansions per line, to break infinite loops. */ |
#define EXPAND_LIMIT 1000 |
#define EXPAND_LIMIT 1000 |
Line 143 struct roffnode { |
|
Line 145 struct roffnode { |
|
int pos, /* current pos in buffer */ \ |
int pos, /* current pos in buffer */ \ |
int *offs /* reset offset of buffer data */ |
int *offs /* reset offset of buffer data */ |
|
|
typedef enum rofferr (*roffproc)(ROFF_ARGS); |
typedef int (*roffproc)(ROFF_ARGS); |
|
|
struct roffmac { |
struct roffmac { |
roffproc proc; /* process new macro */ |
roffproc proc; /* process new macro */ |
|
|
|
|
/* --- function prototypes ------------------------------------------------ */ |
/* --- function prototypes ------------------------------------------------ */ |
|
|
static void roffnode_cleanscope(struct roff *); |
static int roffnode_cleanscope(struct roff *); |
static void roffnode_pop(struct roff *); |
static int roffnode_pop(struct roff *); |
static void roffnode_push(struct roff *, enum roff_tok, |
static void roffnode_push(struct roff *, enum roff_tok, |
const char *, int, int); |
const char *, int, int); |
static void roff_addtbl(struct roff_man *, struct tbl_node *); |
static void roff_addtbl(struct roff_man *, int, struct tbl_node *); |
static enum rofferr roff_als(ROFF_ARGS); |
static int roff_als(ROFF_ARGS); |
static enum rofferr roff_block(ROFF_ARGS); |
static int roff_block(ROFF_ARGS); |
static enum rofferr roff_block_text(ROFF_ARGS); |
static int roff_block_text(ROFF_ARGS); |
static enum rofferr roff_block_sub(ROFF_ARGS); |
static int roff_block_sub(ROFF_ARGS); |
static enum rofferr roff_br(ROFF_ARGS); |
static int roff_br(ROFF_ARGS); |
static enum rofferr roff_cblock(ROFF_ARGS); |
static int roff_cblock(ROFF_ARGS); |
static enum rofferr roff_cc(ROFF_ARGS); |
static int roff_cc(ROFF_ARGS); |
static void roff_ccond(struct roff *, int, int); |
static int roff_ccond(struct roff *, int, int); |
static enum rofferr roff_cond(ROFF_ARGS); |
static int roff_char(ROFF_ARGS); |
static enum rofferr roff_cond_text(ROFF_ARGS); |
static int roff_cond(ROFF_ARGS); |
static enum rofferr roff_cond_sub(ROFF_ARGS); |
static int roff_cond_text(ROFF_ARGS); |
static enum rofferr roff_ds(ROFF_ARGS); |
static int roff_cond_sub(ROFF_ARGS); |
static enum rofferr roff_ec(ROFF_ARGS); |
static int roff_ds(ROFF_ARGS); |
static enum rofferr roff_eo(ROFF_ARGS); |
static int roff_ec(ROFF_ARGS); |
static enum rofferr roff_eqndelim(struct roff *, struct buf *, int); |
static int roff_eo(ROFF_ARGS); |
|
static int roff_eqndelim(struct roff *, struct buf *, int); |
static int roff_evalcond(struct roff *r, int, char *, int *); |
static int roff_evalcond(struct roff *r, int, char *, int *); |
static int roff_evalnum(struct roff *, int, |
static int roff_evalnum(struct roff *, int, |
const char *, int *, int *, int); |
const char *, int *, int *, int); |
Line 203 static const char *roff_getstrn(struct roff *, |
|
Line 206 static const char *roff_getstrn(struct roff *, |
|
const char *, size_t, int *); |
const char *, size_t, int *); |
static int roff_hasregn(const struct roff *, |
static int roff_hasregn(const struct roff *, |
const char *, size_t); |
const char *, size_t); |
static enum rofferr roff_insec(ROFF_ARGS); |
static int roff_insec(ROFF_ARGS); |
static enum rofferr roff_it(ROFF_ARGS); |
static int roff_it(ROFF_ARGS); |
static enum rofferr roff_line_ignore(ROFF_ARGS); |
static int roff_line_ignore(ROFF_ARGS); |
static void roff_man_alloc1(struct roff_man *); |
static void roff_man_alloc1(struct roff_man *); |
static void roff_man_free1(struct roff_man *); |
static void roff_man_free1(struct roff_man *); |
static enum rofferr roff_manyarg(ROFF_ARGS); |
static int roff_manyarg(ROFF_ARGS); |
static enum rofferr roff_nop(ROFF_ARGS); |
static int roff_nop(ROFF_ARGS); |
static enum rofferr roff_nr(ROFF_ARGS); |
static int roff_nr(ROFF_ARGS); |
static enum rofferr roff_onearg(ROFF_ARGS); |
static int roff_onearg(ROFF_ARGS); |
static enum roff_tok roff_parse(struct roff *, char *, int *, |
static enum roff_tok roff_parse(struct roff *, char *, int *, |
int, int); |
int, int); |
static enum rofferr roff_parsetext(struct roff *, struct buf *, |
static int roff_parsetext(struct roff *, struct buf *, |
int, int *); |
int, int *); |
static enum rofferr roff_renamed(ROFF_ARGS); |
static int roff_renamed(ROFF_ARGS); |
static enum rofferr roff_res(struct roff *, struct buf *, int, int); |
static int roff_res(struct roff *, struct buf *, int, int); |
static enum rofferr roff_return(ROFF_ARGS); |
static int roff_return(ROFF_ARGS); |
static enum rofferr roff_rm(ROFF_ARGS); |
static int roff_rm(ROFF_ARGS); |
static enum rofferr roff_rn(ROFF_ARGS); |
static int roff_rn(ROFF_ARGS); |
static enum rofferr roff_rr(ROFF_ARGS); |
static int roff_rr(ROFF_ARGS); |
static void roff_setregn(struct roff *, const char *, |
static void roff_setregn(struct roff *, const char *, |
size_t, int, char, int); |
size_t, int, char, int); |
static void roff_setstr(struct roff *, |
static void roff_setstr(struct roff *, |
const char *, const char *, int); |
const char *, const char *, int); |
static void roff_setstrn(struct roffkv **, const char *, |
static void roff_setstrn(struct roffkv **, const char *, |
size_t, const char *, size_t, int); |
size_t, const char *, size_t, int); |
static enum rofferr roff_shift(ROFF_ARGS); |
static int roff_shift(ROFF_ARGS); |
static enum rofferr roff_so(ROFF_ARGS); |
static int roff_so(ROFF_ARGS); |
static enum rofferr roff_tr(ROFF_ARGS); |
static int roff_tr(ROFF_ARGS); |
static enum rofferr roff_Dd(ROFF_ARGS); |
static int roff_Dd(ROFF_ARGS); |
static enum rofferr roff_TE(ROFF_ARGS); |
static int roff_TE(ROFF_ARGS); |
static enum rofferr roff_TS(ROFF_ARGS); |
static int roff_TS(ROFF_ARGS); |
static enum rofferr roff_EQ(ROFF_ARGS); |
static int roff_EQ(ROFF_ARGS); |
static enum rofferr roff_EN(ROFF_ARGS); |
static int roff_EN(ROFF_ARGS); |
static enum rofferr roff_T_(ROFF_ARGS); |
static int roff_T_(ROFF_ARGS); |
static enum rofferr roff_unsupp(ROFF_ARGS); |
static int roff_unsupp(ROFF_ARGS); |
static enum rofferr roff_userdef(ROFF_ARGS); |
static int roff_userdef(ROFF_ARGS); |
|
|
/* --- constant data ------------------------------------------------------ */ |
/* --- constant data ------------------------------------------------------ */ |
|
|
Line 397 static struct roffmac roffs[TOKEN_NONE] = { |
|
Line 400 static struct roffmac roffs[TOKEN_NONE] = { |
|
{ roff_insec, NULL, NULL, 0 }, /* cf */ |
{ roff_insec, NULL, NULL, 0 }, /* cf */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* cflags */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* cflags */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* ch */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* ch */ |
{ roff_unsupp, NULL, NULL, 0 }, /* char */ |
{ roff_char, NULL, NULL, 0 }, /* char */ |
{ roff_unsupp, NULL, NULL, 0 }, /* chop */ |
{ roff_unsupp, NULL, NULL, 0 }, /* chop */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* class */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* class */ |
{ roff_insec, NULL, NULL, 0 }, /* close */ |
{ roff_insec, NULL, NULL, 0 }, /* close */ |
Line 590 static struct roffmac roffs[TOKEN_NONE] = { |
|
Line 593 static struct roffmac roffs[TOKEN_NONE] = { |
|
{ roff_line_ignore, NULL, NULL, 0 }, /* watchlength */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* watchlength */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* watchn */ |
{ roff_line_ignore, NULL, NULL, 0 }, /* watchn */ |
{ roff_unsupp, NULL, NULL, 0 }, /* wh */ |
{ roff_unsupp, NULL, NULL, 0 }, /* wh */ |
{ roff_unsupp, NULL, NULL, 0 }, /* while */ |
{ roff_cond, roff_cond_text, roff_cond_sub, ROFFMAC_STRUCT }, /*while*/ |
{ roff_insec, NULL, NULL, 0 }, /* write */ |
{ roff_insec, NULL, NULL, 0 }, /* write */ |
{ roff_insec, NULL, NULL, 0 }, /* writec */ |
{ roff_insec, NULL, NULL, 0 }, /* writec */ |
{ roff_insec, NULL, NULL, 0 }, /* writem */ |
{ roff_insec, NULL, NULL, 0 }, /* writem */ |
Line 674 roffhash_find(struct ohash *htab, const char *name, si |
|
Line 677 roffhash_find(struct ohash *htab, const char *name, si |
|
* Pop the current node off of the stack of roff instructions currently |
* Pop the current node off of the stack of roff instructions currently |
* pending. |
* pending. |
*/ |
*/ |
static void |
static int |
roffnode_pop(struct roff *r) |
roffnode_pop(struct roff *r) |
{ |
{ |
struct roffnode *p; |
struct roffnode *p; |
|
int inloop; |
|
|
assert(r->last); |
|
p = r->last; |
p = r->last; |
|
inloop = p->tok == ROFF_while; |
r->last = r->last->parent; |
r->last = p->parent; |
free(p->name); |
free(p->name); |
free(p->end); |
free(p->end); |
free(p); |
free(p); |
|
return inloop; |
} |
} |
|
|
/* |
/* |
Line 715 roffnode_push(struct roff *r, enum roff_tok tok, const |
|
Line 719 roffnode_push(struct roff *r, enum roff_tok tok, const |
|
static void |
static void |
roff_free1(struct roff *r) |
roff_free1(struct roff *r) |
{ |
{ |
struct tbl_node *tbl; |
|
int i; |
int i; |
|
|
while (NULL != (tbl = r->first_tbl)) { |
tbl_free(r->first_tbl); |
r->first_tbl = tbl->next; |
|
tbl_free(tbl); |
|
} |
|
r->first_tbl = r->last_tbl = r->tbl = NULL; |
r->first_tbl = r->last_tbl = r->tbl = NULL; |
|
|
if (r->last_eqn != NULL) |
eqn_free(r->last_eqn); |
eqn_free(r->last_eqn); |
|
r->last_eqn = r->eqn = NULL; |
r->last_eqn = r->eqn = NULL; |
|
|
while (r->mstackpos >= 0) |
while (r->mstackpos >= 0) |
Line 1011 roff_body_alloc(struct roff_man *man, int line, int po |
|
Line 1010 roff_body_alloc(struct roff_man *man, int line, int po |
|
} |
} |
|
|
static void |
static void |
roff_addtbl(struct roff_man *man, struct tbl_node *tbl) |
roff_addtbl(struct roff_man *man, int line, struct tbl_node *tbl) |
{ |
{ |
struct roff_node *n; |
struct roff_node *n; |
const struct tbl_span *span; |
struct tbl_span *span; |
|
|
if (man->macroset == MACROSET_MAN) |
if (man->macroset == MACROSET_MAN) |
man_breakscope(man, ROFF_TS); |
man_breakscope(man, ROFF_TS); |
while ((span = tbl_span(tbl)) != NULL) { |
while ((span = tbl_span(tbl)) != NULL) { |
n = roff_node_alloc(man, tbl->line, 0, ROFFT_TBL, TOKEN_NONE); |
n = roff_node_alloc(man, line, 0, ROFFT_TBL, TOKEN_NONE); |
n->span = span; |
n->span = span; |
roff_node_append(man, n); |
roff_node_append(man, n); |
n->flags |= NODE_VALID | NODE_ENDED; |
n->flags |= NODE_VALID | NODE_ENDED; |
Line 1065 roff_node_unlink(struct roff_man *man, struct roff_nod |
|
Line 1064 roff_node_unlink(struct roff_man *man, struct roff_nod |
|
} |
} |
|
|
void |
void |
|
roff_node_relink(struct roff_man *man, struct roff_node *n) |
|
{ |
|
roff_node_unlink(man, n); |
|
n->prev = n->next = NULL; |
|
roff_node_append(man, n); |
|
} |
|
|
|
void |
roff_node_free(struct roff_node *n) |
roff_node_free(struct roff_node *n) |
{ |
{ |
|
|
Line 1072 roff_node_free(struct roff_node *n) |
|
Line 1079 roff_node_free(struct roff_node *n) |
|
mdoc_argv_free(n->args); |
mdoc_argv_free(n->args); |
if (n->type == ROFFT_BLOCK || n->type == ROFFT_ELEM) |
if (n->type == ROFFT_BLOCK || n->type == ROFFT_ELEM) |
free(n->norm); |
free(n->norm); |
if (n->eqn != NULL) |
eqn_box_free(n->eqn); |
eqn_box_free(n->eqn); |
|
free(n->string); |
free(n->string); |
free(n); |
free(n); |
} |
} |
Line 1144 deroff(char **dest, const struct roff_node *n) |
|
Line 1150 deroff(char **dest, const struct roff_node *n) |
|
* used in numerical expressions and conditional requests. |
* used in numerical expressions and conditional requests. |
* Also check the syntax of the remaining escape sequences. |
* Also check the syntax of the remaining escape sequences. |
*/ |
*/ |
static enum rofferr |
static int |
roff_res(struct roff *r, struct buf *buf, int ln, int pos) |
roff_res(struct roff *r, struct buf *buf, int ln, int pos) |
{ |
{ |
struct mctx *ctx; /* current macro call context */ |
struct mctx *ctx; /* current macro call context */ |
Line 1236 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
Line 1242 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
|
|
if (stesc[1] == '#') { |
if (stesc[1] == '#') { |
*stesc = '\0'; |
*stesc = '\0'; |
return ROFF_APPEND; |
return ROFF_IGN | ROFF_APPEND; |
} |
} |
|
|
/* Discard normal comments. */ |
/* Discard normal comments. */ |
Line 1294 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
Line 1300 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
if (done) |
if (done) |
continue; |
continue; |
else |
else |
return ROFF_APPEND; |
return ROFF_IGN | ROFF_APPEND; |
} |
} |
|
|
/* Decide whether to expand or to check only. */ |
/* Decide whether to expand or to check only. */ |
Line 1529 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
Line 1535 roff_res(struct roff *r, struct buf *buf, int ln, int |
|
/* |
/* |
* Process text streams. |
* Process text streams. |
*/ |
*/ |
static enum rofferr |
static int |
roff_parsetext(struct roff *r, struct buf *buf, int pos, int *offs) |
roff_parsetext(struct roff *r, struct buf *buf, int pos, int *offs) |
{ |
{ |
size_t sz; |
size_t sz; |
Line 1595 roff_parsetext(struct roff *r, struct buf *buf, int po |
|
Line 1601 roff_parsetext(struct roff *r, struct buf *buf, int po |
|
return ROFF_CONT; |
return ROFF_CONT; |
} |
} |
|
|
enum rofferr |
int |
roff_parseln(struct roff *r, int ln, struct buf *buf, int *offs) |
roff_parseln(struct roff *r, int ln, struct buf *buf, int *offs) |
{ |
{ |
enum roff_tok t; |
enum roff_tok t; |
enum rofferr e; |
int e; |
int pos; /* parse point */ |
int pos; /* parse point */ |
int spos; /* saved parse point for messages */ |
int spos; /* saved parse point for messages */ |
int ppos; /* original offset in buf->buf */ |
int ppos; /* original offset in buf->buf */ |
Line 1621 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
Line 1627 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
/* Expand some escape sequences. */ |
/* Expand some escape sequences. */ |
|
|
e = roff_res(r, buf, ln, pos); |
e = roff_res(r, buf, ln, pos); |
if (e == ROFF_IGN || e == ROFF_APPEND) |
if ((e & ROFF_MASK) == ROFF_IGN) |
return e; |
return e; |
assert(e == ROFF_CONT); |
assert(e == ROFF_CONT); |
|
|
Line 1638 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
Line 1644 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
if (r->last != NULL && ! ctl) { |
if (r->last != NULL && ! ctl) { |
t = r->last->tok; |
t = r->last->tok; |
e = (*roffs[t].text)(r, t, buf, ln, pos, pos, offs); |
e = (*roffs[t].text)(r, t, buf, ln, pos, pos, offs); |
if (e == ROFF_IGN) |
if ((e & ROFF_MASK) == ROFF_IGN) |
return e; |
return e; |
assert(e == ROFF_CONT); |
e &= ~ROFF_MASK; |
} |
} else |
|
e = ROFF_IGN; |
if (r->eqn != NULL && strncmp(buf->buf + ppos, ".EN", 3)) { |
if (r->eqn != NULL && strncmp(buf->buf + ppos, ".EN", 3)) { |
eqn_read(r->eqn, buf->buf + ppos); |
eqn_read(r->eqn, buf->buf + ppos); |
return ROFF_IGN; |
return e; |
} |
} |
if (r->tbl != NULL && (ctl == 0 || buf->buf[pos] == '\0')) { |
if (r->tbl != NULL && (ctl == 0 || buf->buf[pos] == '\0')) { |
tbl_read(r->tbl, ln, buf->buf, ppos); |
tbl_read(r->tbl, ln, buf->buf, ppos); |
roff_addtbl(r->man, r->tbl); |
roff_addtbl(r->man, ln, r->tbl); |
return ROFF_IGN; |
return e; |
} |
} |
if ( ! ctl) |
if ( ! ctl) |
return roff_parsetext(r, buf, pos, offs); |
return roff_parsetext(r, buf, pos, offs) | e; |
|
|
/* Skip empty request lines. */ |
/* Skip empty request lines. */ |
|
|
Line 1692 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
Line 1699 roff_parseln(struct roff *r, int ln, struct buf *buf, |
|
while (buf->buf[pos] == ' ') |
while (buf->buf[pos] == ' ') |
pos++; |
pos++; |
tbl_read(r->tbl, ln, buf->buf, pos); |
tbl_read(r->tbl, ln, buf->buf, pos); |
roff_addtbl(r->man, r->tbl); |
roff_addtbl(r->man, ln, r->tbl); |
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
Line 1755 roff_endparse(struct roff *r) |
|
Line 1762 roff_endparse(struct roff *r) |
|
} |
} |
|
|
if (r->tbl != NULL) { |
if (r->tbl != NULL) { |
mandoc_msg(MANDOCERR_BLK_NOEND, r->parse, |
tbl_end(r->tbl, 1); |
r->tbl->line, r->tbl->pos, "TS"); |
|
tbl_end(r->tbl); |
|
r->tbl = NULL; |
r->tbl = NULL; |
} |
} |
} |
} |
Line 1808 roff_parse(struct roff *r, char *buf, int *pos, int ln |
|
Line 1813 roff_parse(struct roff *r, char *buf, int *pos, int ln |
|
|
|
/* --- handling of request blocks ----------------------------------------- */ |
/* --- handling of request blocks ----------------------------------------- */ |
|
|
static enum rofferr |
static int |
roff_cblock(ROFF_ARGS) |
roff_cblock(ROFF_ARGS) |
{ |
{ |
|
|
Line 1848 roff_cblock(ROFF_ARGS) |
|
Line 1853 roff_cblock(ROFF_ARGS) |
|
|
|
} |
} |
|
|
static void |
static int |
roffnode_cleanscope(struct roff *r) |
roffnode_cleanscope(struct roff *r) |
{ |
{ |
|
int inloop; |
|
|
while (r->last) { |
inloop = 0; |
|
while (r->last != NULL) { |
if (--r->last->endspan != 0) |
if (--r->last->endspan != 0) |
break; |
break; |
roffnode_pop(r); |
inloop += roffnode_pop(r); |
} |
} |
|
return inloop; |
} |
} |
|
|
static void |
static int |
roff_ccond(struct roff *r, int ln, int ppos) |
roff_ccond(struct roff *r, int ln, int ppos) |
{ |
{ |
|
|
if (NULL == r->last) { |
if (NULL == r->last) { |
mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse, |
mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse, |
ln, ppos, "\\}"); |
ln, ppos, "\\}"); |
return; |
return 0; |
} |
} |
|
|
switch (r->last->tok) { |
switch (r->last->tok) { |
case ROFF_el: |
case ROFF_el: |
case ROFF_ie: |
case ROFF_ie: |
case ROFF_if: |
case ROFF_if: |
|
case ROFF_while: |
break; |
break; |
default: |
default: |
mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse, |
mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse, |
ln, ppos, "\\}"); |
ln, ppos, "\\}"); |
return; |
return 0; |
} |
} |
|
|
if (r->last->endspan > -1) { |
if (r->last->endspan > -1) { |
mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse, |
mandoc_msg(MANDOCERR_BLK_NOTOPEN, r->parse, |
ln, ppos, "\\}"); |
ln, ppos, "\\}"); |
return; |
return 0; |
} |
} |
|
|
roffnode_pop(r); |
return roffnode_pop(r) + roffnode_cleanscope(r); |
roffnode_cleanscope(r); |
|
return; |
|
} |
} |
|
|
static enum rofferr |
static int |
roff_block(ROFF_ARGS) |
roff_block(ROFF_ARGS) |
{ |
{ |
const char *name, *value; |
const char *name, *value; |
Line 2016 roff_block(ROFF_ARGS) |
|
Line 2022 roff_block(ROFF_ARGS) |
|
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static int |
roff_block_sub(ROFF_ARGS) |
roff_block_sub(ROFF_ARGS) |
{ |
{ |
enum roff_tok t; |
enum roff_tok t; |
Line 2070 roff_block_sub(ROFF_ARGS) |
|
Line 2076 roff_block_sub(ROFF_ARGS) |
|
return (*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs); |
return (*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs); |
} |
} |
|
|
static enum rofferr |
static int |
roff_block_text(ROFF_ARGS) |
roff_block_text(ROFF_ARGS) |
{ |
{ |
|
|
Line 2080 roff_block_text(ROFF_ARGS) |
|
Line 2086 roff_block_text(ROFF_ARGS) |
|
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static int |
roff_cond_sub(ROFF_ARGS) |
roff_cond_sub(ROFF_ARGS) |
{ |
{ |
enum roff_tok t; |
|
char *ep; |
char *ep; |
int rr; |
int endloop, irc, rr; |
|
enum roff_tok t; |
|
|
|
irc = ROFF_IGN; |
rr = r->last->rule; |
rr = r->last->rule; |
roffnode_cleanscope(r); |
endloop = tok != ROFF_while ? ROFF_IGN : |
|
rr ? ROFF_LOOPCONT : ROFF_LOOPEXIT; |
|
if (roffnode_cleanscope(r)) |
|
irc |= endloop; |
|
|
/* |
/* |
* If `\}' occurs on a macro line without a preceding macro, |
* If `\}' occurs on a macro line without a preceding macro, |
Line 2099 roff_cond_sub(ROFF_ARGS) |
|
Line 2109 roff_cond_sub(ROFF_ARGS) |
|
if (ep[0] == '\\' && ep[1] == '}') |
if (ep[0] == '\\' && ep[1] == '}') |
rr = 0; |
rr = 0; |
|
|
/* Always check for the closing delimiter `\}'. */ |
/* |
|
* The closing delimiter `\}' rewinds the conditional scope |
|
* but is otherwise ignored when interpreting the line. |
|
*/ |
|
|
while ((ep = strchr(ep, '\\')) != NULL) { |
while ((ep = strchr(ep, '\\')) != NULL) { |
switch (ep[1]) { |
switch (ep[1]) { |
case '}': |
case '}': |
memmove(ep, ep + 2, strlen(ep + 2) + 1); |
memmove(ep, ep + 2, strlen(ep + 2) + 1); |
roff_ccond(r, ln, ep - buf->buf); |
if (roff_ccond(r, ln, ep - buf->buf)) |
|
irc |= endloop; |
break; |
break; |
case '\0': |
case '\0': |
++ep; |
++ep; |
Line 2122 roff_cond_sub(ROFF_ARGS) |
|
Line 2136 roff_cond_sub(ROFF_ARGS) |
|
*/ |
*/ |
|
|
t = roff_parse(r, buf->buf, &pos, ln, ppos); |
t = roff_parse(r, buf->buf, &pos, ln, ppos); |
return t != TOKEN_NONE && (rr || roffs[t].flags & ROFFMAC_STRUCT) |
irc |= t != TOKEN_NONE && (rr || roffs[t].flags & ROFFMAC_STRUCT) ? |
? (*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs) : rr |
(*roffs[t].proc)(r, t, buf, ln, ppos, pos, offs) : |
? ROFF_CONT : ROFF_IGN; |
rr ? ROFF_CONT : ROFF_IGN; |
|
return irc; |
} |
} |
|
|
static enum rofferr |
static int |
roff_cond_text(ROFF_ARGS) |
roff_cond_text(ROFF_ARGS) |
{ |
{ |
char *ep; |
char *ep; |
int rr; |
int endloop, irc, rr; |
|
|
|
irc = ROFF_IGN; |
rr = r->last->rule; |
rr = r->last->rule; |
roffnode_cleanscope(r); |
endloop = tok != ROFF_while ? ROFF_IGN : |
|
rr ? ROFF_LOOPCONT : ROFF_LOOPEXIT; |
|
if (roffnode_cleanscope(r)) |
|
irc |= endloop; |
|
|
|
/* |
|
* If `\}' occurs on a text line with neither preceding |
|
* nor following characters, drop the line completely. |
|
*/ |
|
|
ep = buf->buf + pos; |
ep = buf->buf + pos; |
|
if (strcmp(ep, "\\}") == 0) |
|
rr = 0; |
|
|
|
/* |
|
* The closing delimiter `\}' rewinds the conditional scope |
|
* but is otherwise ignored when interpreting the line. |
|
*/ |
|
|
while ((ep = strchr(ep, '\\')) != NULL) { |
while ((ep = strchr(ep, '\\')) != NULL) { |
if (*(++ep) == '}') { |
switch (ep[1]) { |
*ep = '&'; |
case '}': |
roff_ccond(r, ln, ep - buf->buf - 1); |
memmove(ep, ep + 2, strlen(ep + 2) + 1); |
} |
if (roff_ccond(r, ln, ep - buf->buf)) |
if (*ep != '\0') |
irc |= endloop; |
|
break; |
|
case '\0': |
++ep; |
++ep; |
|
break; |
|
default: |
|
ep += 2; |
|
break; |
|
} |
} |
} |
return rr ? ROFF_CONT : ROFF_IGN; |
if (rr) |
|
irc |= ROFF_CONT; |
|
return irc; |
} |
} |
|
|
/* --- handling of numeric and conditional expressions -------------------- */ |
/* --- handling of numeric and conditional expressions -------------------- */ |
Line 2365 roff_evalcond(struct roff *r, int ln, char *v, int *po |
|
Line 2406 roff_evalcond(struct roff *r, int ln, char *v, int *po |
|
return 0; |
return 0; |
} |
} |
|
|
static enum rofferr |
static int |
roff_line_ignore(ROFF_ARGS) |
roff_line_ignore(ROFF_ARGS) |
{ |
{ |
|
|
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static int |
roff_insec(ROFF_ARGS) |
roff_insec(ROFF_ARGS) |
{ |
{ |
|
|
Line 2381 roff_insec(ROFF_ARGS) |
|
Line 2422 roff_insec(ROFF_ARGS) |
|
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static int |
roff_unsupp(ROFF_ARGS) |
roff_unsupp(ROFF_ARGS) |
{ |
{ |
|
|
Line 2390 roff_unsupp(ROFF_ARGS) |
|
Line 2431 roff_unsupp(ROFF_ARGS) |
|
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static int |
roff_cond(ROFF_ARGS) |
roff_cond(ROFF_ARGS) |
{ |
{ |
|
int irc; |
|
|
roffnode_push(r, tok, NULL, ln, ppos); |
roffnode_push(r, tok, NULL, ln, ppos); |
|
|
Line 2431 roff_cond(ROFF_ARGS) |
|
Line 2473 roff_cond(ROFF_ARGS) |
|
* Determine scope. |
* Determine scope. |
* If there is nothing on the line after the conditional, |
* If there is nothing on the line after the conditional, |
* not even whitespace, use next-line scope. |
* not even whitespace, use next-line scope. |
|
* Except that .while does not support next-line scope. |
*/ |
*/ |
|
|
if (buf->buf[pos] == '\0') { |
if (buf->buf[pos] == '\0' && tok != ROFF_while) { |
r->last->endspan = 2; |
r->last->endspan = 2; |
goto out; |
goto out; |
} |
} |
Line 2465 roff_cond(ROFF_ARGS) |
|
Line 2508 roff_cond(ROFF_ARGS) |
|
|
|
out: |
out: |
*offs = pos; |
*offs = pos; |
return ROFF_RERUN; |
irc = ROFF_RERUN; |
|
if (tok == ROFF_while) |
|
irc |= ROFF_WHILE; |
|
return irc; |
} |
} |
|
|
static enum rofferr |
static int |
roff_ds(ROFF_ARGS) |
roff_ds(ROFF_ARGS) |
{ |
{ |
char *string; |
char *string; |
Line 2857 roff_freereg(struct roffreg *reg) |
|
Line 2903 roff_freereg(struct roffreg *reg) |
|
} |
} |
} |
} |
|
|
static enum rofferr |
static int |
roff_nr(ROFF_ARGS) |
roff_nr(ROFF_ARGS) |
{ |
{ |
char *key, *val, *step; |
char *key, *val, *step; |
Line 2891 roff_nr(ROFF_ARGS) |
|
Line 2937 roff_nr(ROFF_ARGS) |
|
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static int |
roff_rr(ROFF_ARGS) |
roff_rr(ROFF_ARGS) |
{ |
{ |
struct roffreg *reg, **prev; |
struct roffreg *reg, **prev; |
Line 2921 roff_rr(ROFF_ARGS) |
|
Line 2967 roff_rr(ROFF_ARGS) |
|
|
|
/* --- handler functions for roff requests -------------------------------- */ |
/* --- handler functions for roff requests -------------------------------- */ |
|
|
static enum rofferr |
static int |
roff_rm(ROFF_ARGS) |
roff_rm(ROFF_ARGS) |
{ |
{ |
const char *name; |
const char *name; |
Line 2940 roff_rm(ROFF_ARGS) |
|
Line 2986 roff_rm(ROFF_ARGS) |
|
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static int |
roff_it(ROFF_ARGS) |
roff_it(ROFF_ARGS) |
{ |
{ |
int iv; |
int iv; |
Line 2969 roff_it(ROFF_ARGS) |
|
Line 3015 roff_it(ROFF_ARGS) |
|
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static int |
roff_Dd(ROFF_ARGS) |
roff_Dd(ROFF_ARGS) |
{ |
{ |
int mask; |
int mask; |
Line 2999 roff_Dd(ROFF_ARGS) |
|
Line 3045 roff_Dd(ROFF_ARGS) |
|
return ROFF_CONT; |
return ROFF_CONT; |
} |
} |
|
|
static enum rofferr |
static int |
roff_TE(ROFF_ARGS) |
roff_TE(ROFF_ARGS) |
{ |
{ |
if (r->tbl == NULL) { |
if (r->tbl == NULL) { |
Line 3007 roff_TE(ROFF_ARGS) |
|
Line 3053 roff_TE(ROFF_ARGS) |
|
ln, ppos, "TE"); |
ln, ppos, "TE"); |
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
if (tbl_end(r->tbl) == 0) { |
if (tbl_end(r->tbl, 0) == 0) { |
r->tbl = NULL; |
r->tbl = NULL; |
free(buf->buf); |
free(buf->buf); |
buf->buf = mandoc_strdup(".sp"); |
buf->buf = mandoc_strdup(".sp"); |
Line 3019 roff_TE(ROFF_ARGS) |
|
Line 3065 roff_TE(ROFF_ARGS) |
|
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static int |
roff_T_(ROFF_ARGS) |
roff_T_(ROFF_ARGS) |
{ |
{ |
|
|
Line 3035 roff_T_(ROFF_ARGS) |
|
Line 3081 roff_T_(ROFF_ARGS) |
|
/* |
/* |
* Handle in-line equation delimiters. |
* Handle in-line equation delimiters. |
*/ |
*/ |
static enum rofferr |
static int |
roff_eqndelim(struct roff *r, struct buf *buf, int pos) |
roff_eqndelim(struct roff *r, struct buf *buf, int pos) |
{ |
{ |
char *cp1, *cp2; |
char *cp1, *cp2; |
Line 3098 roff_eqndelim(struct roff *r, struct buf *buf, int pos |
|
Line 3144 roff_eqndelim(struct roff *r, struct buf *buf, int pos |
|
return ROFF_REPARSE; |
return ROFF_REPARSE; |
} |
} |
|
|
static enum rofferr |
static int |
roff_EQ(ROFF_ARGS) |
roff_EQ(ROFF_ARGS) |
{ |
{ |
struct roff_node *n; |
struct roff_node *n; |
Line 3108 roff_EQ(ROFF_ARGS) |
|
Line 3154 roff_EQ(ROFF_ARGS) |
|
n = roff_node_alloc(r->man, ln, ppos, ROFFT_EQN, TOKEN_NONE); |
n = roff_node_alloc(r->man, ln, ppos, ROFFT_EQN, TOKEN_NONE); |
if (ln > r->man->last->line) |
if (ln > r->man->last->line) |
n->flags |= NODE_LINE; |
n->flags |= NODE_LINE; |
n->eqn = mandoc_calloc(1, sizeof(*n->eqn)); |
n->eqn = eqn_box_new(); |
n->eqn->expectargs = UINT_MAX; |
|
roff_node_append(r->man, n); |
roff_node_append(r->man, n); |
r->man->next = ROFF_NEXT_SIBLING; |
r->man->next = ROFF_NEXT_SIBLING; |
|
|
Line 3128 roff_EQ(ROFF_ARGS) |
|
Line 3173 roff_EQ(ROFF_ARGS) |
|
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static int |
roff_EN(ROFF_ARGS) |
roff_EN(ROFF_ARGS) |
{ |
{ |
if (r->eqn != NULL) { |
if (r->eqn != NULL) { |
Line 3142 roff_EN(ROFF_ARGS) |
|
Line 3187 roff_EN(ROFF_ARGS) |
|
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static int |
roff_TS(ROFF_ARGS) |
roff_TS(ROFF_ARGS) |
{ |
{ |
if (r->tbl != NULL) { |
if (r->tbl != NULL) { |
mandoc_msg(MANDOCERR_BLK_BROKEN, r->parse, |
mandoc_msg(MANDOCERR_BLK_BROKEN, r->parse, |
ln, ppos, "TS breaks TS"); |
ln, ppos, "TS breaks TS"); |
tbl_end(r->tbl); |
tbl_end(r->tbl, 0); |
} |
} |
r->tbl = tbl_alloc(ppos, ln, r->parse); |
r->tbl = tbl_alloc(ppos, ln, r->parse, r->last_tbl); |
if (r->last_tbl) |
if (r->last_tbl == NULL) |
r->last_tbl->next = r->tbl; |
|
else |
|
r->first_tbl = r->tbl; |
r->first_tbl = r->tbl; |
r->last_tbl = r->tbl; |
r->last_tbl = r->tbl; |
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static int |
roff_onearg(ROFF_ARGS) |
roff_onearg(ROFF_ARGS) |
{ |
{ |
struct roff_node *n; |
struct roff_node *n; |
Line 3219 roff_onearg(ROFF_ARGS) |
|
Line 3262 roff_onearg(ROFF_ARGS) |
|
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static int |
roff_manyarg(ROFF_ARGS) |
roff_manyarg(ROFF_ARGS) |
{ |
{ |
struct roff_node *n; |
struct roff_node *n; |
Line 3242 roff_manyarg(ROFF_ARGS) |
|
Line 3285 roff_manyarg(ROFF_ARGS) |
|
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static int |
roff_als(ROFF_ARGS) |
roff_als(ROFF_ARGS) |
{ |
{ |
char *oldn, *newn, *end, *value; |
char *oldn, *newn, *end, *value; |
Line 3269 roff_als(ROFF_ARGS) |
|
Line 3312 roff_als(ROFF_ARGS) |
|
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static int |
roff_br(ROFF_ARGS) |
roff_br(ROFF_ARGS) |
{ |
{ |
if (r->man->flags & (MAN_BLINE | MAN_ELINE)) |
if (r->man->flags & (MAN_BLINE | MAN_ELINE)) |
Line 3283 roff_br(ROFF_ARGS) |
|
Line 3326 roff_br(ROFF_ARGS) |
|
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static int |
roff_cc(ROFF_ARGS) |
roff_cc(ROFF_ARGS) |
{ |
{ |
const char *p; |
const char *p; |
Line 3300 roff_cc(ROFF_ARGS) |
|
Line 3343 roff_cc(ROFF_ARGS) |
|
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static int |
|
roff_char(ROFF_ARGS) |
|
{ |
|
const char *p, *kp, *vp; |
|
size_t ksz, vsz; |
|
int font; |
|
|
|
/* Parse the character to be replaced. */ |
|
|
|
kp = buf->buf + pos; |
|
p = kp + 1; |
|
if (*kp == '\0' || (*kp == '\\' && |
|
mandoc_escape(&p, NULL, NULL) != ESCAPE_SPECIAL) || |
|
(*p != ' ' && *p != '\0')) { |
|
mandoc_vmsg(MANDOCERR_CHAR_ARG, r->parse, |
|
ln, pos, "char %s", kp); |
|
return ROFF_IGN; |
|
} |
|
ksz = p - kp; |
|
while (*p == ' ') |
|
p++; |
|
|
|
/* |
|
* If the replacement string contains a font escape sequence, |
|
* we have to restore the font at the end. |
|
*/ |
|
|
|
vp = p; |
|
vsz = strlen(p); |
|
font = 0; |
|
while (*p != '\0') { |
|
if (*p++ != '\\') |
|
continue; |
|
switch (mandoc_escape(&p, NULL, NULL)) { |
|
case ESCAPE_FONT: |
|
case ESCAPE_FONTROMAN: |
|
case ESCAPE_FONTITALIC: |
|
case ESCAPE_FONTBOLD: |
|
case ESCAPE_FONTBI: |
|
case ESCAPE_FONTCW: |
|
case ESCAPE_FONTPREV: |
|
font++; |
|
break; |
|
default: |
|
break; |
|
} |
|
} |
|
if (font > 1) |
|
mandoc_msg(MANDOCERR_CHAR_FONT, r->parse, |
|
ln, vp - buf->buf, vp); |
|
|
|
/* |
|
* Approximate the effect of .char using the .tr tables. |
|
* XXX In groff, .char and .tr interact differently. |
|
*/ |
|
|
|
if (ksz == 1) { |
|
if (r->xtab == NULL) |
|
r->xtab = mandoc_calloc(128, sizeof(*r->xtab)); |
|
assert((unsigned int)*kp < 128); |
|
free(r->xtab[(int)*kp].p); |
|
r->xtab[(int)*kp].sz = mandoc_asprintf(&r->xtab[(int)*kp].p, |
|
"%s%s", vp, font ? "\fP" : ""); |
|
} else { |
|
roff_setstrn(&r->xmbtab, kp, ksz, vp, vsz, 0); |
|
if (font) |
|
roff_setstrn(&r->xmbtab, kp, ksz, "\\fP", 3, 1); |
|
} |
|
return ROFF_IGN; |
|
} |
|
|
|
static int |
roff_ec(ROFF_ARGS) |
roff_ec(ROFF_ARGS) |
{ |
{ |
const char *p; |
const char *p; |
Line 3317 roff_ec(ROFF_ARGS) |
|
Line 3431 roff_ec(ROFF_ARGS) |
|
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static int |
roff_eo(ROFF_ARGS) |
roff_eo(ROFF_ARGS) |
{ |
{ |
r->escape = '\0'; |
r->escape = '\0'; |
Line 3327 roff_eo(ROFF_ARGS) |
|
Line 3441 roff_eo(ROFF_ARGS) |
|
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static int |
roff_nop(ROFF_ARGS) |
roff_nop(ROFF_ARGS) |
{ |
{ |
while (buf->buf[pos] == ' ') |
while (buf->buf[pos] == ' ') |
Line 3336 roff_nop(ROFF_ARGS) |
|
Line 3450 roff_nop(ROFF_ARGS) |
|
return ROFF_RERUN; |
return ROFF_RERUN; |
} |
} |
|
|
static enum rofferr |
static int |
roff_tr(ROFF_ARGS) |
roff_tr(ROFF_ARGS) |
{ |
{ |
const char *p, *first, *second; |
const char *p, *first, *second; |
Line 3404 roff_tr(ROFF_ARGS) |
|
Line 3518 roff_tr(ROFF_ARGS) |
|
* The read module will call that after rewinding the reader stack |
* The read module will call that after rewinding the reader stack |
* to the place from where the current macro was called. |
* to the place from where the current macro was called. |
*/ |
*/ |
static enum rofferr |
static int |
roff_return(ROFF_ARGS) |
roff_return(ROFF_ARGS) |
{ |
{ |
if (r->mstackpos >= 0) |
if (r->mstackpos >= 0) |
return ROFF_USERRET; |
return ROFF_IGN | ROFF_USERRET; |
|
|
mandoc_msg(MANDOCERR_REQ_NOMAC, r->parse, ln, ppos, "return"); |
mandoc_msg(MANDOCERR_REQ_NOMAC, r->parse, ln, ppos, "return"); |
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static int |
roff_rn(ROFF_ARGS) |
roff_rn(ROFF_ARGS) |
{ |
{ |
const char *value; |
const char *value; |
Line 3464 roff_rn(ROFF_ARGS) |
|
Line 3578 roff_rn(ROFF_ARGS) |
|
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static int |
roff_shift(ROFF_ARGS) |
roff_shift(ROFF_ARGS) |
{ |
{ |
struct mctx *ctx; |
struct mctx *ctx; |
Line 3497 roff_shift(ROFF_ARGS) |
|
Line 3611 roff_shift(ROFF_ARGS) |
|
return ROFF_IGN; |
return ROFF_IGN; |
} |
} |
|
|
static enum rofferr |
static int |
roff_so(ROFF_ARGS) |
roff_so(ROFF_ARGS) |
{ |
{ |
char *name, *cp; |
char *name, *cp; |
Line 3529 roff_so(ROFF_ARGS) |
|
Line 3643 roff_so(ROFF_ARGS) |
|
|
|
/* --- user defined strings and macros ------------------------------------ */ |
/* --- user defined strings and macros ------------------------------------ */ |
|
|
static enum rofferr |
static int |
roff_userdef(ROFF_ARGS) |
roff_userdef(ROFF_ARGS) |
{ |
{ |
struct mctx *ctx; |
struct mctx *ctx; |
Line 3583 roff_userdef(ROFF_ARGS) |
|
Line 3697 roff_userdef(ROFF_ARGS) |
|
*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_USERCALL : ROFF_APPEND; |
ROFF_REPARSE | ROFF_USERCALL : ROFF_IGN | ROFF_APPEND; |
} |
} |
|
|
/* |
/* |
* Calling a high-level macro that was renamed with .rn. |
* Calling a high-level macro that was renamed with .rn. |
* r->current_string has already been set up by roff_parse(). |
* r->current_string has already been set up by roff_parse(). |
*/ |
*/ |
static enum rofferr |
static int |
roff_renamed(ROFF_ARGS) |
roff_renamed(ROFF_ARGS) |
{ |
{ |
char *nbuf; |
char *nbuf; |