version 1.339, 2018/08/23 14:29:39 |
version 1.341, 2018/08/25 16:53:39 |
Line 143 struct roffnode { |
|
Line 143 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 *, 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 204 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 398 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 591 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 675 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 1144 deroff(char **dest, const struct roff_node *n) |
|
Line 1146 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 1238 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 1296 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 1531 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 1597 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 1623 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 1640 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, 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 1808 roff_parse(struct roff *r, char *buf, int *pos, int ln |
|
Line 1811 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 1851 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 2020 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 2074 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 2084 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 2105 roff_cond_sub(ROFF_ARGS) |
|
Line 2113 roff_cond_sub(ROFF_ARGS) |
|
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 2131 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; |
|
|
ep = buf->buf + pos; |
ep = buf->buf + pos; |
while ((ep = strchr(ep, '\\')) != NULL) { |
while ((ep = strchr(ep, '\\')) != NULL) { |
if (*(++ep) == '}') { |
if (*(++ep) == '}') { |
*ep = '&'; |
*ep = '&'; |
roff_ccond(r, ln, ep - buf->buf - 1); |
if (roff_ccond(r, ln, ep - buf->buf - 1)) |
|
irc |= endloop; |
} |
} |
if (*ep != '\0') |
if (*ep != '\0') |
++ep; |
++ep; |
} |
} |
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 2382 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 2398 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 2407 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 2449 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 2484 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 2879 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 2913 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 2943 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 2962 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 2991 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 3021 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 3019 roff_TE(ROFF_ARGS) |
|
Line 3041 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 3057 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 3120 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 3128 roff_EQ(ROFF_ARGS) |
|
Line 3150 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 3164 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) { |
Line 3159 roff_TS(ROFF_ARGS) |
|
Line 3181 roff_TS(ROFF_ARGS) |
|
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 3241 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 3264 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 3291 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 3305 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 3322 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_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 3409 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 3419 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 3428 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 3496 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 3556 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 3589 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 3621 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 3675 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; |