Return to roff.c CVS log | Up to [cvsweb.bsd.lv] / mandoc |
version 1.68, 2010/05/15 18:43:59 | version 1.87, 2010/06/09 20:00:38 | ||
---|---|---|---|
|
|
||
#endif | #endif | ||
#include <assert.h> | #include <assert.h> | ||
#include <ctype.h> | |||
#include <stdlib.h> | #include <stdlib.h> | ||
#include <string.h> | #include <string.h> | ||
#include <stdio.h> | |||
#include "mandoc.h" | #include "mandoc.h" | ||
#include "roff.h" | #include "roff.h" | ||
#define RSTACK_MAX 128 | |||
#define ROFF_CTL(c) \ | |||
('.' == (c) || '\'' == (c)) | |||
enum rofft { | enum rofft { | ||
ROFF_de, | |||
ROFF_dei, | |||
ROFF_am, | ROFF_am, | ||
ROFF_ami, | ROFF_ami, | ||
ROFF_am1, | |||
ROFF_de, | |||
ROFF_dei, | |||
ROFF_de1, | |||
ROFF_ds, | |||
ROFF_el, | |||
ROFF_ie, | |||
ROFF_if, | |||
ROFF_ig, | ROFF_ig, | ||
ROFF_close, | ROFF_rm, | ||
ROFF_tr, | |||
ROFF_cblock, | |||
ROFF_ccond, | |||
ROFF_MAX | ROFF_MAX | ||
}; | }; | ||
enum roffrule { | |||
ROFFRULE_ALLOW, | |||
ROFFRULE_DENY | |||
}; | |||
struct roff { | struct roff { | ||
struct roffnode *last; /* leaf of stack */ | struct roffnode *last; /* leaf of stack */ | ||
mandocmsg msg; /* err/warn/fatal messages */ | mandocmsg msg; /* err/warn/fatal messages */ | ||
void *data; /* privdata for messages */ | void *data; /* privdata for messages */ | ||
enum roffrule rstack[RSTACK_MAX]; /* stack of !`ie' rules */ | |||
int rstackpos; /* position in rstack */ | |||
}; | }; | ||
struct roffnode { | struct roffnode { | ||
|
|
||
struct roffnode *parent; /* up one in stack */ | struct roffnode *parent; /* up one in stack */ | ||
int line; /* parse line */ | int line; /* parse line */ | ||
int col; /* parse col */ | int col; /* parse col */ | ||
char *end; /* end-rules: custom token */ | |||
int endspan; /* end-rules: next-line or infty */ | |||
enum roffrule rule; /* current evaluation rule */ | |||
}; | }; | ||
#define ROFF_ARGS struct roff *r, /* parse ctx */ \ | #define ROFF_ARGS struct roff *r, /* parse ctx */ \ | ||
enum rofft tok, /* tok of macro */ \ | |||
char **bufp, /* input buffer */ \ | char **bufp, /* input buffer */ \ | ||
size_t *szp, /* size of input buffer */ \ | size_t *szp, /* size of input buffer */ \ | ||
int ln, /* parse line */ \ | int ln, /* parse line */ \ | ||
int ppos /* current pos in buffer */ | int ppos, /* original pos in buffer */ \ | ||
int pos, /* current pos in buffer */ \ | |||
int *offs /* reset offset of buffer data */ | |||
typedef enum rofferr (*roffproc)(ROFF_ARGS); | typedef enum rofferr (*roffproc)(ROFF_ARGS); | ||
struct roffmac { | struct roffmac { | ||
const char *name; /* macro name */ | const char *name; /* macro name */ | ||
roffproc sub; /* child of control black */ | roffproc proc; /* process new macro */ | ||
roffproc new; /* root of stack (type = ROFF_MAX) */ | roffproc text; /* process as child text of macro */ | ||
roffproc sub; /* process as child of macro */ | |||
int flags; | |||
#define ROFFMAC_STRUCT (1 << 0) /* always interpret */ | |||
struct roffmac *next; | |||
}; | }; | ||
static enum rofferr roff_ignore(ROFF_ARGS); | static enum rofferr roff_block(ROFF_ARGS); | ||
static enum rofferr roff_new_close(ROFF_ARGS); | static enum rofferr roff_block_text(ROFF_ARGS); | ||
static enum rofferr roff_new_ig(ROFF_ARGS); | static enum rofferr roff_block_sub(ROFF_ARGS); | ||
static enum rofferr roff_sub_ig(ROFF_ARGS); | static enum rofferr roff_cblock(ROFF_ARGS); | ||
static enum rofferr roff_ccond(ROFF_ARGS); | |||
static enum rofferr roff_cond(ROFF_ARGS); | |||
static enum rofferr roff_cond_text(ROFF_ARGS); | |||
static enum rofferr roff_cond_sub(ROFF_ARGS); | |||
static enum rofferr roff_line(ROFF_ARGS); | |||
const struct roffmac roffs[ROFF_MAX] = { | /* See roff_hash_find() */ | ||
{ "de", NULL, roff_ignore }, | |||
{ "dei", NULL, roff_ignore }, | #define ASCII_HI 126 | ||
{ "am", NULL, roff_ignore }, | #define ASCII_LO 33 | ||
{ "ami", NULL, roff_ignore }, | #define HASHWIDTH (ASCII_HI - ASCII_LO + 1) | ||
{ "ig", roff_sub_ig, roff_new_ig }, | |||
{ ".", NULL, roff_new_close }, | static struct roffmac *hash[HASHWIDTH]; | ||
static struct roffmac roffs[ROFF_MAX] = { | |||
{ "am", roff_block, roff_block_text, roff_block_sub, 0, NULL }, | |||
{ "ami", roff_block, roff_block_text, roff_block_sub, 0, NULL }, | |||
{ "am1", roff_block, roff_block_text, roff_block_sub, 0, NULL }, | |||
{ "de", roff_block, roff_block_text, roff_block_sub, 0, NULL }, | |||
{ "dei", roff_block, roff_block_text, roff_block_sub, 0, NULL }, | |||
{ "de1", roff_block, roff_block_text, roff_block_sub, 0, NULL }, | |||
{ "ds", roff_line, NULL, NULL, 0, NULL }, | |||
{ "el", roff_cond, roff_cond_text, roff_cond_sub, ROFFMAC_STRUCT, NULL }, | |||
{ "ie", roff_cond, roff_cond_text, roff_cond_sub, ROFFMAC_STRUCT, NULL }, | |||
{ "if", roff_cond, roff_cond_text, roff_cond_sub, ROFFMAC_STRUCT, NULL }, | |||
{ "ig", roff_block, roff_block_text, roff_block_sub, 0, NULL }, | |||
{ "rm", roff_line, NULL, NULL, 0, NULL }, | |||
{ "tr", roff_line, NULL, NULL, 0, NULL }, | |||
{ ".", roff_cblock, NULL, NULL, 0, NULL }, | |||
{ "\\}", roff_ccond, NULL, NULL, 0, NULL }, | |||
}; | }; | ||
static void roff_alloc1(struct roff *); | |||
static void roff_free1(struct roff *); | static void roff_free1(struct roff *); | ||
static enum rofft roff_hash_find(const char *); | static enum rofft roff_hash_find(const char *); | ||
static void roff_hash_init(void); | |||
static void roffnode_cleanscope(struct roff *); | |||
static int roffnode_push(struct roff *, | static int roffnode_push(struct roff *, | ||
enum rofft, int, int); | enum rofft, int, int); | ||
static void roffnode_pop(struct roff *); | static void roffnode_pop(struct roff *); | ||
static enum rofft roff_parse(const char *, int *); | static enum rofft roff_parse(const char *, int *); | ||
/* See roff_hash_find() */ | |||
#define ROFF_HASH(p) (p[0] - ASCII_LO) | |||
static void | |||
roff_hash_init(void) | |||
{ | |||
struct roffmac *n; | |||
int buc, i; | |||
for (i = 0; i < (int)ROFF_MAX; i++) { | |||
assert(roffs[i].name[0] >= ASCII_LO); | |||
assert(roffs[i].name[0] <= ASCII_HI); | |||
buc = ROFF_HASH(roffs[i].name); | |||
if (NULL != (n = hash[buc])) { | |||
for ( ; n->next; n = n->next) | |||
/* Do nothing. */ ; | |||
n->next = &roffs[i]; | |||
} else | |||
hash[buc] = &roffs[i]; | |||
} | |||
} | |||
/* | /* | ||
* Look up a roff token by its name. Returns ROFF_MAX if no macro by | * Look up a roff token by its name. Returns ROFF_MAX if no macro by | ||
* the nil-terminated string name could be found. | * the nil-terminated string name could be found. | ||
|
|
||
static enum rofft | static enum rofft | ||
roff_hash_find(const char *p) | roff_hash_find(const char *p) | ||
{ | { | ||
int i; | int buc; | ||
struct roffmac *n; | |||
/* FIXME: make this be fast and efficient. */ | /* | ||
* libroff has an extremely simple hashtable, for the time | |||
* being, which simply keys on the first character, which must | |||
* be printable, then walks a chain. It works well enough until | |||
* optimised. | |||
*/ | |||
for (i = 0; i < (int)ROFF_MAX; i++) | if (p[0] < ASCII_LO || p[0] > ASCII_HI) | ||
if (0 == strcmp(roffs[i].name, p)) | return(ROFF_MAX); | ||
return((enum rofft)i); | |||
buc = ROFF_HASH(p); | |||
if (NULL == (n = hash[buc])) | |||
return(ROFF_MAX); | |||
for ( ; n; n = n->next) | |||
if (0 == strcmp(n->name, p)) | |||
return((enum rofft)(n - roffs)); | |||
return(ROFF_MAX); | return(ROFF_MAX); | ||
} | } | ||
|
|
||
{ | { | ||
struct roffnode *p; | struct roffnode *p; | ||
if (NULL == (p = r->last)) | assert(r->last); | ||
return; | p = r->last; | ||
r->last = p->parent; | |||
if (ROFF_el == p->tok) | |||
if (r->rstackpos > -1) | |||
r->rstackpos--; | |||
r->last = r->last->parent; | |||
if (p->end) | |||
free(p->end); | |||
free(p); | free(p); | ||
} | } | ||
|
|
||
p->parent = r->last; | p->parent = r->last; | ||
p->line = line; | p->line = line; | ||
p->col = col; | p->col = col; | ||
p->rule = p->parent ? p->parent->rule : ROFFRULE_DENY; | |||
r->last = p; | r->last = p; | ||
return(1); | return(1); | ||
|
|
||
} | } | ||
static void | |||
roff_alloc1(struct roff *r) | |||
{ | |||
/* Do nothing for now. */ | |||
} | |||
void | void | ||
roff_reset(struct roff *r) | roff_reset(struct roff *r) | ||
{ | { | ||
roff_free1(r); | roff_free1(r); | ||
roff_alloc1(r); | |||
} | } | ||
|
|
||
r->msg = msg; | r->msg = msg; | ||
r->data = data; | r->data = data; | ||
r->rstackpos = -1; | |||
roff_hash_init(); | |||
return(r); | return(r); | ||
} | } | ||
enum rofferr | enum rofferr | ||
roff_parseln(struct roff *r, int ln, char **bufp, size_t *szp) | roff_parseln(struct roff *r, int ln, | ||
char **bufp, size_t *szp, int pos, int *offs) | |||
{ | { | ||
enum rofft t; | enum rofft t; | ||
int ppos; | int ppos; | ||
if (NULL != r->last) { | /* | ||
/* | * First, if a scope is open and we're not a macro, pass the | ||
* If there's a node on the stack, then jump directly | * text through the macro's filter. If a scope isn't open and | ||
* into its processing function. | * we're not a macro, just let it through. | ||
*/ | */ | ||
if (r->last && ! ROFF_CTL((*bufp)[pos])) { | |||
t = r->last->tok; | t = r->last->tok; | ||
assert(roffs[t].sub); | assert(roffs[t].text); | ||
return((*roffs[t].sub)(r, bufp, szp, ln, 0)); | return((*roffs[t].text) | ||
} else if ('.' != (*bufp)[0] && NULL == r->last) | (r, t, bufp, szp, ln, pos, pos, offs)); | ||
/* Return when in free text without a context. */ | } else if ( ! ROFF_CTL((*bufp)[pos])) | ||
return(ROFF_CONT); | return(ROFF_CONT); | ||
/* There's nothing on the stack: make us anew. */ | /* | ||
* If a scope is open, go to the child handler for that macro, | |||
* as it may want to preprocess before doing anything with it. | |||
*/ | |||
if (ROFF_MAX == (t = roff_parse(*bufp, &ppos))) | if (r->last) { | ||
t = r->last->tok; | |||
assert(roffs[t].sub); | |||
return((*roffs[t].sub) | |||
(r, t, bufp, szp, ln, pos, pos, offs)); | |||
} | |||
/* | |||
* Lastly, as we've no scope open, try to look up and execute | |||
* the new macro. If no macro is found, simply return and let | |||
* the compilers handle it. | |||
*/ | |||
ppos = pos; | |||
if (ROFF_MAX == (t = roff_parse(*bufp, &pos))) | |||
return(ROFF_CONT); | return(ROFF_CONT); | ||
assert(roffs[t].new); | assert(roffs[t].proc); | ||
return((*roffs[t].new)(r, bufp, szp, ln, ppos)); | return((*roffs[t].proc) | ||
(r, t, bufp, szp, ln, ppos, pos, offs)); | |||
} | } | ||
int | |||
roff_endparse(struct roff *r) | |||
{ | |||
if (NULL == r->last) | |||
return(1); | |||
return((*r->msg)(MANDOCERR_SCOPEEXIT, r->data, r->last->line, | |||
r->last->col, NULL)); | |||
} | |||
/* | /* | ||
* Parse a roff node's type from the input buffer. This must be in the | * Parse a roff node's type from the input buffer. This must be in the | ||
* form of ".foo xxx" in the usual way. | * form of ".foo xxx" in the usual way. | ||
|
|
||
char mac[5]; | char mac[5]; | ||
enum rofft t; | enum rofft t; | ||
assert('.' == buf[0]); | assert(ROFF_CTL(buf[*pos])); | ||
*pos = 1; | (*pos)++; | ||
while (buf[*pos] && (' ' == buf[*pos] || '\t' == buf[*pos])) | while (buf[*pos] && (' ' == buf[*pos] || '\t' == buf[*pos])) | ||
(*pos)++; | (*pos)++; | ||
|
|
||
for (j = 0; j < 4; j++, (*pos)++) | for (j = 0; j < 4; j++, (*pos)++) | ||
if ('\0' == (mac[j] = buf[*pos])) | if ('\0' == (mac[j] = buf[*pos])) | ||
break; | break; | ||
else if (' ' == buf[*pos]) | else if (' ' == buf[*pos] || (j && '\\' == buf[*pos])) | ||
break; | break; | ||
if (j == 4 || j < 1) | if (j == 4 || j < 1) | ||
|
|
||
/* ARGSUSED */ | /* ARGSUSED */ | ||
static enum rofferr | static enum rofferr | ||
roff_ignore(ROFF_ARGS) | roff_cblock(ROFF_ARGS) | ||
{ | { | ||
/* | |||
* A block-close `..' should only be invoked as a child of an | |||
* ignore macro, otherwise raise a warning and just ignore it. | |||
*/ | |||
if (NULL == r->last) { | |||
if ( ! (*r->msg)(MANDOCERR_NOSCOPE, r->data, ln, ppos, NULL)) | |||
return(ROFF_ERR); | |||
return(ROFF_IGN); | |||
} | |||
switch (r->last->tok) { | |||
case (ROFF_am): | |||
/* FALLTHROUGH */ | |||
case (ROFF_ami): | |||
/* FALLTHROUGH */ | |||
case (ROFF_am1): | |||
/* FALLTHROUGH */ | |||
case (ROFF_de): | |||
/* FALLTHROUGH */ | |||
case (ROFF_dei): | |||
/* FALLTHROUGH */ | |||
case (ROFF_de1): | |||
/* FALLTHROUGH */ | |||
case (ROFF_ig): | |||
break; | |||
default: | |||
if ( ! (*r->msg)(MANDOCERR_NOSCOPE, r->data, ln, ppos, NULL)) | |||
return(ROFF_ERR); | |||
return(ROFF_IGN); | |||
} | |||
if ((*bufp)[pos]) | |||
if ( ! (*r->msg)(MANDOCERR_ARGSLOST, r->data, ln, pos, NULL)) | |||
return(ROFF_ERR); | |||
roffnode_pop(r); | |||
roffnode_cleanscope(r); | |||
return(ROFF_IGN); | return(ROFF_IGN); | ||
} | } | ||
static void | |||
roffnode_cleanscope(struct roff *r) | |||
{ | |||
while (r->last) { | |||
if (--r->last->endspan < 0) | |||
break; | |||
roffnode_pop(r); | |||
} | |||
} | |||
/* ARGSUSED */ | /* ARGSUSED */ | ||
static enum rofferr | static enum rofferr | ||
roff_sub_ig(ROFF_ARGS) | roff_ccond(ROFF_ARGS) | ||
{ | { | ||
enum rofft t; | |||
int pos; | |||
/* Ignore free-text lines. */ | if (NULL == r->last) { | ||
if ( ! (*r->msg)(MANDOCERR_NOSCOPE, r->data, ln, ppos, NULL)) | |||
return(ROFF_ERR); | |||
return(ROFF_IGN); | |||
} | |||
if ('.' != (*bufp)[ppos]) | switch (r->last->tok) { | ||
case (ROFF_el): | |||
/* FALLTHROUGH */ | |||
case (ROFF_ie): | |||
/* FALLTHROUGH */ | |||
case (ROFF_if): | |||
break; | |||
default: | |||
if ( ! (*r->msg)(MANDOCERR_NOSCOPE, r->data, ln, ppos, NULL)) | |||
return(ROFF_ERR); | |||
return(ROFF_IGN); | return(ROFF_IGN); | ||
} | |||
/* Ignore macros unless it's a closing macro. */ | if (r->last->endspan > -1) { | ||
if ( ! (*r->msg)(MANDOCERR_NOSCOPE, r->data, ln, ppos, NULL)) | |||
t = roff_parse(*bufp, &pos); | return(ROFF_ERR); | ||
if (ROFF_close != t) | |||
return(ROFF_IGN); | return(ROFF_IGN); | ||
} | |||
if ((*bufp)[pos]) | |||
if ( ! (*r->msg)(MANDOCERR_ARGSLOST, r->data, ln, pos, NULL)) | |||
return(ROFF_ERR); | |||
roffnode_pop(r); | roffnode_pop(r); | ||
roffnode_cleanscope(r); | |||
return(ROFF_IGN); | return(ROFF_IGN); | ||
} | } | ||
/* ARGSUSED */ | /* ARGSUSED */ | ||
static enum rofferr | static enum rofferr | ||
roff_new_close(ROFF_ARGS) | roff_block(ROFF_ARGS) | ||
{ | { | ||
int sv; | |||
size_t sz; | |||
if (ROFF_ig != tok && '\0' == (*bufp)[pos]) { | |||
if ( ! (*r->msg)(MANDOCERR_NOARGS, r->data, ln, ppos, NULL)) | |||
return(ROFF_ERR); | |||
return(ROFF_IGN); | |||
} else if (ROFF_ig != tok) { | |||
while ((*bufp)[pos] && ' ' != (*bufp)[pos]) | |||
pos++; | |||
while (' ' == (*bufp)[pos]) | |||
pos++; | |||
} | |||
if ( ! roffnode_push(r, tok, ln, ppos)) | |||
return(ROFF_ERR); | |||
if ('\0' == (*bufp)[pos]) | |||
return(ROFF_IGN); | |||
sv = pos; | |||
while ((*bufp)[pos] && ' ' != (*bufp)[pos] && | |||
'\t' != (*bufp)[pos]) | |||
pos++; | |||
/* | /* | ||
if ( ! (*r->msg)(MANDOCERR_NOSCOPE, r->data, ln, ppos, NULL)) | * Note: groff does NOT like escape characters in the input. | ||
* Instead of detecting this, we're just going to let it fly and | |||
* to hell with it. | |||
*/ | |||
assert(pos > sv); | |||
sz = (size_t)(pos - sv); | |||
if (1 == sz && '.' == (*bufp)[sv]) | |||
return(ROFF_IGN); | |||
r->last->end = malloc(sz + 1); | |||
if (NULL == r->last->end) { | |||
(*r->msg)(MANDOCERR_MEM, r->data, ln, pos, NULL); | |||
return(ROFF_ERR); | return(ROFF_ERR); | ||
*/ | } | ||
return(ROFF_CONT); | |||
memcpy(r->last->end, *bufp + sv, sz); | |||
r->last->end[(int)sz] = '\0'; | |||
if ((*bufp)[pos]) | |||
if ( ! (*r->msg)(MANDOCERR_ARGSLOST, r->data, ln, pos, NULL)) | |||
return(ROFF_ERR); | |||
return(ROFF_IGN); | |||
} | } | ||
/* ARGSUSED */ | /* ARGSUSED */ | ||
static enum rofferr | static enum rofferr | ||
roff_new_ig(ROFF_ARGS) | roff_block_sub(ROFF_ARGS) | ||
{ | { | ||
enum rofft t; | |||
int i, j; | |||
return(roffnode_push(r, ROFF_ig, ln, ppos) ? | /* | ||
ROFF_IGN : ROFF_ERR); | * First check whether a custom macro exists at this level. If | ||
* it does, then check against it. This is some of groff's | |||
* stranger behaviours. If we encountered a custom end-scope | |||
* tag and that tag also happens to be a "real" macro, then we | |||
* need to try interpreting it again as a real macro. If it's | |||
* not, then return ignore. Else continue. | |||
*/ | |||
if (r->last->end) { | |||
i = pos + 1; | |||
while (' ' == (*bufp)[i] || '\t' == (*bufp)[i]) | |||
i++; | |||
for (j = 0; r->last->end[j]; j++, i++) | |||
if ((*bufp)[i] != r->last->end[j]) | |||
break; | |||
if ('\0' == r->last->end[j] && | |||
('\0' == (*bufp)[i] || | |||
' ' == (*bufp)[i] || | |||
'\t' == (*bufp)[i])) { | |||
roffnode_pop(r); | |||
roffnode_cleanscope(r); | |||
if (ROFF_MAX != roff_parse(*bufp, &pos)) | |||
return(ROFF_RERUN); | |||
return(ROFF_IGN); | |||
} | |||
} | |||
/* | |||
* If we have no custom end-query or lookup failed, then try | |||
* pulling it out of the hashtable. | |||
*/ | |||
ppos = pos; | |||
t = roff_parse(*bufp, &pos); | |||
/* If we're not a comment-end, then throw it away. */ | |||
if (ROFF_cblock != t) | |||
return(ROFF_IGN); | |||
assert(roffs[t].proc); | |||
return((*roffs[t].proc)(r, t, bufp, | |||
szp, ln, ppos, pos, offs)); | |||
} | } | ||
int | /* ARGSUSED */ | ||
roff_endparse(struct roff *r) | static enum rofferr | ||
roff_block_text(ROFF_ARGS) | |||
{ | { | ||
if (NULL == r->last) | return(ROFF_IGN); | ||
return(1); | } | ||
return((*r->msg)(MANDOCERR_SCOPEEXIT, r->data, | |||
r->last->line, r->last->col, NULL)); | |||
/* ARGSUSED */ | |||
static enum rofferr | |||
roff_cond_sub(ROFF_ARGS) | |||
{ | |||
enum rofft t; | |||
enum roffrule rr; | |||
struct roffnode *l; | |||
ppos = pos; | |||
rr = r->last->rule; | |||
/* | |||
* Clean out scope. If we've closed ourselves, then don't | |||
* continue. | |||
*/ | |||
l = r->last; | |||
roffnode_cleanscope(r); | |||
if (l != r->last) | |||
return(ROFFRULE_DENY == rr ? ROFF_IGN : ROFF_CONT); | |||
if (ROFF_MAX == (t = roff_parse(*bufp, &pos))) | |||
return(ROFFRULE_DENY == rr ? ROFF_IGN : ROFF_CONT); | |||
/* | |||
* A denied conditional must evaluate its children if and only | |||
* if they're either structurally required (such as loops and | |||
* conditionals) or a closing macro. | |||
*/ | |||
if (ROFFRULE_DENY == rr) | |||
if ( ! (ROFFMAC_STRUCT & roffs[t].flags)) | |||
if (ROFF_ccond != t) | |||
return(ROFF_IGN); | |||
assert(roffs[t].proc); | |||
return((*roffs[t].proc) | |||
(r, t, bufp, szp, ln, ppos, pos, offs)); | |||
} | |||
/* ARGSUSED */ | |||
static enum rofferr | |||
roff_cond_text(ROFF_ARGS) | |||
{ | |||
char *ep, *st; | |||
enum roffrule rr; | |||
rr = r->last->rule; | |||
/* | |||
* We display the value of the text if out current evaluation | |||
* scope permits us to do so. | |||
*/ | |||
st = &(*bufp)[pos]; | |||
if (NULL == (ep = strstr(st, "\\}"))) { | |||
roffnode_cleanscope(r); | |||
return(ROFFRULE_DENY == rr ? ROFF_IGN : ROFF_CONT); | |||
} | |||
if (ep == st || (ep > st && '\\' != *(ep - 1))) | |||
roffnode_pop(r); | |||
roffnode_cleanscope(r); | |||
return(ROFFRULE_DENY == rr ? ROFF_IGN : ROFF_CONT); | |||
} | |||
/* ARGSUSED */ | |||
static enum rofferr | |||
roff_cond(ROFF_ARGS) | |||
{ | |||
int cpos; /* position of the condition */ | |||
int sv; | |||
/* Stack overflow! */ | |||
if (ROFF_ie == tok && r->rstackpos == RSTACK_MAX - 1) { | |||
(*r->msg)(MANDOCERR_MEM, r->data, ln, ppos, NULL); | |||
return(ROFF_ERR); | |||
} | |||
cpos = pos; | |||
if (ROFF_if == tok || ROFF_ie == tok) { | |||
/* | |||
* Read ahead past the conditional. FIXME: this does | |||
* not work, as conditionals don't end on whitespace, | |||
* but are parsed according to a formal grammar. It's | |||
* good enough for now, however. | |||
*/ | |||
while ((*bufp)[pos] && ' ' != (*bufp)[pos]) | |||
pos++; | |||
} | |||
sv = pos; | |||
while (' ' == (*bufp)[pos]) | |||
pos++; | |||
/* | |||
* Roff is weird. If we have just white-space after the | |||
* conditional, it's considered the BODY and we exit without | |||
* really doing anything. Warn about this. It's probably | |||
* wrong. | |||
*/ | |||
if ('\0' == (*bufp)[pos] && sv != pos) { | |||
if ( ! (*r->msg)(MANDOCERR_NOARGS, r->data, ln, ppos, NULL)) | |||
return(ROFF_ERR); | |||
return(ROFF_IGN); | |||
} | |||
if ( ! roffnode_push(r, tok, ln, ppos)) | |||
return(ROFF_ERR); | |||
/* XXX: Implement more conditionals. */ | |||
if (ROFF_if == tok || ROFF_ie == tok) | |||
r->last->rule = 'n' == (*bufp)[cpos] ? | |||
ROFFRULE_ALLOW : ROFFRULE_DENY; | |||
else if (ROFF_el == tok) { | |||
/* | |||
* An `.el' will get the value of the current rstack | |||
* entry set in prior `ie' calls or defaults to DENY. | |||
*/ | |||
if (r->rstackpos < 0) | |||
r->last->rule = ROFFRULE_DENY; | |||
else | |||
r->last->rule = r->rstack[r->rstackpos]; | |||
} | |||
if (ROFF_ie == tok) { | |||
/* | |||
* An if-else will put the NEGATION of the current | |||
* evaluated conditional into the stack. | |||
*/ | |||
r->rstackpos++; | |||
if (ROFFRULE_DENY == r->last->rule) | |||
r->rstack[r->rstackpos] = ROFFRULE_ALLOW; | |||
else | |||
r->rstack[r->rstackpos] = ROFFRULE_DENY; | |||
} | |||
if (r->last->parent && ROFFRULE_DENY == r->last->parent->rule) | |||
r->last->rule = ROFFRULE_DENY; | |||
r->last->endspan = 1; | |||
if ('\\' == (*bufp)[pos] && '{' == (*bufp)[pos + 1]) { | |||
r->last->endspan = -1; | |||
pos += 2; | |||
} | |||
/* | |||
* If there are no arguments on the line, the next-line scope is | |||
* assumed. | |||
*/ | |||
if ('\0' == (*bufp)[pos]) | |||
return(ROFF_IGN); | |||
/* Otherwise re-run the roff parser after recalculating. */ | |||
*offs = pos; | |||
return(ROFF_RERUN); | |||
} | |||
/* ARGSUSED */ | |||
static enum rofferr | |||
roff_line(ROFF_ARGS) | |||
{ | |||
return(ROFF_IGN); | |||
} | } |