version 1.145, 2011/07/12 21:32:43 |
version 1.153, 2011/07/26 14:24:06 |
|
|
ROFFRULE_DENY |
ROFFRULE_DENY |
}; |
}; |
|
|
|
/* |
|
* A single register entity. If "set" is zero, the value of the |
|
* register should be the default one, which is per-register. |
|
* Registers are assumed to be unsigned ints for now. |
|
*/ |
|
struct reg { |
|
int set; /* whether set or not */ |
|
unsigned int u; /* unsigned integer */ |
|
}; |
|
|
struct roffstr { |
struct roffstr { |
char *name; /* key of symbol */ |
char *name; /* key of symbol */ |
char *string; /* current value */ |
char *string; /* current value */ |
|
|
struct roffnode *last; /* leaf of stack */ |
struct roffnode *last; /* leaf of stack */ |
enum roffrule rstack[RSTACK_MAX]; /* stack of !`ie' rules */ |
enum roffrule rstack[RSTACK_MAX]; /* stack of !`ie' rules */ |
int rstackpos; /* position in rstack */ |
int rstackpos; /* position in rstack */ |
struct regset *regs; /* read/writable registers */ |
struct reg regs[REG__MAX]; |
struct roffstr *first_string; /* user-defined strings & macros */ |
struct roffstr *first_string; /* user-defined strings & macros */ |
const char *current_string; /* value of last called user macro */ |
const char *current_string; /* value of last called user macro */ |
struct tbl_node *first_tbl; /* first table parsed */ |
struct tbl_node *first_tbl; /* first table parsed */ |
Line 351 roff_reset(struct roff *r) |
|
Line 361 roff_reset(struct roff *r) |
|
|
|
roff_free1(r); |
roff_free1(r); |
|
|
|
memset(&r->regs, 0, sizeof(struct reg) * REG__MAX); |
|
|
for (i = 0; i < PREDEFS_MAX; i++) |
for (i = 0; i < PREDEFS_MAX; i++) |
roff_setstr(r, predefs[i].name, predefs[i].str, 0); |
roff_setstr(r, predefs[i].name, predefs[i].str, 0); |
} |
} |
Line 366 roff_free(struct roff *r) |
|
Line 378 roff_free(struct roff *r) |
|
|
|
|
|
struct roff * |
struct roff * |
roff_alloc(struct regset *regs, struct mparse *parse) |
roff_alloc(struct mparse *parse) |
{ |
{ |
struct roff *r; |
struct roff *r; |
int i; |
int i; |
|
|
r = mandoc_calloc(1, sizeof(struct roff)); |
r = mandoc_calloc(1, sizeof(struct roff)); |
r->regs = regs; |
|
r->parse = parse; |
r->parse = parse; |
r->rstackpos = -1; |
r->rstackpos = -1; |
|
|
Line 384 roff_alloc(struct regset *regs, struct mparse *parse) |
|
Line 395 roff_alloc(struct regset *regs, struct mparse *parse) |
|
return(r); |
return(r); |
} |
} |
|
|
|
|
/* |
/* |
* Pre-filter each and every line for reserved words (one beginning with |
* Pre-filter each and every line for reserved words (one beginning with |
* `\*', e.g., `\*(ab'). These must be handled before the actual line |
* `\*', e.g., `\*(ab'). These must be handled before the actual line |
* is processed. |
* is processed. |
*/ |
* This also checks the syntax of regular escapes. |
|
*/ |
static int |
static int |
roff_res(struct roff *r, char **bufp, size_t *szp, int ln, int pos) |
roff_res(struct roff *r, char **bufp, size_t *szp, int ln, int pos) |
{ |
{ |
|
enum mandoc_esc esc; |
const char *stesc; /* start of an escape sequence ('\\') */ |
const char *stesc; /* start of an escape sequence ('\\') */ |
const char *stnam; /* start of the name, after "[(*" */ |
const char *stnam; /* start of the name, after "[(*" */ |
const char *cp; /* end of the name, e.g. before ']' */ |
const char *cp; /* end of the name, e.g. before ']' */ |
Line 415 roff_res(struct roff *r, char **bufp, size_t *szp, int |
|
Line 427 roff_res(struct roff *r, char **bufp, size_t *szp, int |
|
|
|
if ('\0' == *cp) |
if ('\0' == *cp) |
return(1); |
return(1); |
if ('*' != *cp++) |
|
|
if ('*' != *cp) { |
|
res = cp; |
|
esc = mandoc_escape(&cp, NULL, NULL); |
|
if (ESCAPE_ERROR != esc) |
|
continue; |
|
cp = res; |
|
mandoc_msg |
|
(MANDOCERR_BADESCAPE, r->parse, |
|
ln, (int)(stesc - *bufp), NULL); |
continue; |
continue; |
|
} |
|
|
|
cp++; |
|
|
/* |
/* |
* The third character decides the length |
* The third character decides the length |
* of the name of the string. |
* of the name of the string. |
Line 444 roff_res(struct roff *r, char **bufp, size_t *szp, int |
|
Line 468 roff_res(struct roff *r, char **bufp, size_t *szp, int |
|
/* Advance to the end of the name. */ |
/* Advance to the end of the name. */ |
|
|
for (i = 0; 0 == maxl || i < maxl; i++, cp++) { |
for (i = 0; 0 == maxl || i < maxl; i++, cp++) { |
if ('\0' == *cp) |
if ('\0' == *cp) { |
return(1); /* Error. */ |
mandoc_msg |
|
(MANDOCERR_BADESCAPE, |
|
r->parse, ln, |
|
(int)(stesc - *bufp), NULL); |
|
return(1); |
|
} |
if (0 == maxl && ']' == *cp) |
if (0 == maxl && ']' == *cp) |
break; |
break; |
} |
} |
Line 458 roff_res(struct roff *r, char **bufp, size_t *szp, int |
|
Line 487 roff_res(struct roff *r, char **bufp, size_t *szp, int |
|
res = roff_getstrn(r, stnam, (size_t)i); |
res = roff_getstrn(r, stnam, (size_t)i); |
|
|
if (NULL == res) { |
if (NULL == res) { |
/* TODO: keep track of the correct position. */ |
mandoc_msg |
mandoc_msg(MANDOCERR_BADESCAPE, r->parse, ln, pos, NULL); |
(MANDOCERR_BADESCAPE, r->parse, |
|
ln, (int)(stesc - *bufp), NULL); |
res = ""; |
res = ""; |
} |
} |
|
|
Line 482 roff_res(struct roff *r, char **bufp, size_t *szp, int |
|
Line 512 roff_res(struct roff *r, char **bufp, size_t *szp, int |
|
return(1); |
return(1); |
} |
} |
|
|
|
|
enum rofferr |
enum rofferr |
roff_parseln(struct roff *r, int ln, char **bufp, |
roff_parseln(struct roff *r, int ln, char **bufp, |
size_t *szp, int pos, int *offs) |
size_t *szp, int pos, int *offs) |
Line 496 roff_parseln(struct roff *r, int ln, char **bufp, |
|
Line 525 roff_parseln(struct roff *r, int ln, char **bufp, |
|
* words to fill in. |
* words to fill in. |
*/ |
*/ |
|
|
if (r->first_string && ! roff_res(r, bufp, szp, ln, pos)) |
if ( ! roff_res(r, bufp, szp, ln, pos)) |
return(ROFF_REPARSE); |
return(ROFF_REPARSE); |
|
|
ppos = pos; |
ppos = pos; |
Line 519 roff_parseln(struct roff *r, int ln, char **bufp, |
|
Line 548 roff_parseln(struct roff *r, int ln, char **bufp, |
|
if (ROFF_CONT != e) |
if (ROFF_CONT != e) |
return(e); |
return(e); |
if (r->eqn) |
if (r->eqn) |
return(eqn_read(&r->eqn, ln, *bufp, pos)); |
return(eqn_read(&r->eqn, ln, *bufp, pos, offs)); |
if (r->tbl) |
if (r->tbl) |
return(tbl_read(r->tbl, ln, *bufp, pos)); |
return(tbl_read(r->tbl, ln, *bufp, pos)); |
return(ROFF_CONT); |
return(ROFF_CONT); |
} else if ( ! ctl) { |
} else if ( ! ctl) { |
if (r->eqn) |
if (r->eqn) |
return(eqn_read(&r->eqn, ln, *bufp, pos)); |
return(eqn_read(&r->eqn, ln, *bufp, pos, offs)); |
if (r->tbl) |
if (r->tbl) |
return(tbl_read(r->tbl, ln, *bufp, pos)); |
return(tbl_read(r->tbl, ln, *bufp, pos)); |
return(ROFF_CONT); |
return(ROFF_CONT); |
} else if (r->eqn) |
} else if (r->eqn) |
return(eqn_read(&r->eqn, ln, *bufp, ppos)); |
return(eqn_read(&r->eqn, ln, *bufp, ppos, offs)); |
|
|
/* |
/* |
* 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 572 roff_endparse(struct roff *r) |
|
Line 601 roff_endparse(struct roff *r) |
|
|
|
if (r->eqn) { |
if (r->eqn) { |
mandoc_msg(MANDOCERR_SCOPEEXIT, r->parse, |
mandoc_msg(MANDOCERR_SCOPEEXIT, r->parse, |
r->eqn->eqn.line, r->eqn->eqn.pos, NULL); |
r->eqn->eqn.ln, r->eqn->eqn.pos, NULL); |
eqn_end(r->eqn); |
eqn_end(&r->eqn); |
r->eqn = NULL; |
|
} |
} |
|
|
if (r->tbl) { |
if (r->tbl) { |
mandoc_msg(MANDOCERR_SCOPEEXIT, r->parse, |
mandoc_msg(MANDOCERR_SCOPEEXIT, r->parse, |
r->tbl->line, r->tbl->pos, NULL); |
r->tbl->line, r->tbl->pos, NULL); |
tbl_end(r->tbl); |
tbl_end(&r->tbl); |
r->tbl = NULL; |
|
} |
} |
} |
} |
|
|
Line 1104 roff_ds(ROFF_ARGS) |
|
Line 1131 roff_ds(ROFF_ARGS) |
|
return(ROFF_IGN); |
return(ROFF_IGN); |
} |
} |
|
|
|
int |
|
roff_regisset(const struct roff *r, enum regs reg) |
|
{ |
|
|
|
return(r->regs[(int)reg].set); |
|
} |
|
|
|
unsigned int |
|
roff_regget(const struct roff *r, enum regs reg) |
|
{ |
|
|
|
return(r->regs[(int)reg].u); |
|
} |
|
|
|
void |
|
roff_regunset(struct roff *r, enum regs reg) |
|
{ |
|
|
|
r->regs[(int)reg].set = 0; |
|
} |
|
|
/* ARGSUSED */ |
/* ARGSUSED */ |
static enum rofferr |
static enum rofferr |
roff_nr(ROFF_ARGS) |
roff_nr(ROFF_ARGS) |
Line 1112 roff_nr(ROFF_ARGS) |
|
Line 1159 roff_nr(ROFF_ARGS) |
|
const char *key; |
const char *key; |
char *val; |
char *val; |
int iv; |
int iv; |
struct reg *rg; |
|
|
|
val = *bufp + pos; |
val = *bufp + pos; |
key = roff_getname(r, &val, ln, pos); |
key = roff_getname(r, &val, ln, pos); |
rg = r->regs->regs; |
|
|
|
if (0 == strcmp(key, "nS")) { |
if (0 == strcmp(key, "nS")) { |
rg[(int)REG_nS].set = 1; |
r->regs[(int)REG_nS].set = 1; |
if ((iv = mandoc_strntou(val, strlen(val), 10)) >= 0) |
if ((iv = mandoc_strntoi(val, strlen(val), 10)) >= 0) |
rg[REG_nS].v.u = (unsigned)iv; |
r->regs[(int)REG_nS].u = (unsigned)iv; |
else |
else |
rg[(int)REG_nS].v.u = 0u; |
r->regs[(int)REG_nS].u = 0u; |
} |
} |
|
|
return(ROFF_IGN); |
return(ROFF_IGN); |
Line 1153 roff_TE(ROFF_ARGS) |
|
Line 1198 roff_TE(ROFF_ARGS) |
|
if (NULL == r->tbl) |
if (NULL == r->tbl) |
mandoc_msg(MANDOCERR_NOSCOPE, r->parse, ln, ppos, NULL); |
mandoc_msg(MANDOCERR_NOSCOPE, r->parse, ln, ppos, NULL); |
else |
else |
tbl_end(r->tbl); |
tbl_end(&r->tbl); |
|
|
r->tbl = NULL; |
|
return(ROFF_IGN); |
return(ROFF_IGN); |
} |
} |
|
|
Line 1172 roff_T_(ROFF_ARGS) |
|
Line 1216 roff_T_(ROFF_ARGS) |
|
return(ROFF_IGN); |
return(ROFF_IGN); |
} |
} |
|
|
/* ARGSUSED */ |
int |
static enum rofferr |
roff_closeeqn(struct roff *r) |
roff_EQ(ROFF_ARGS) |
|
{ |
{ |
struct eqn_node *e; |
|
|
|
|
return(r->eqn && ROFF_EQN == eqn_end(&r->eqn) ? 1 : 0); |
|
} |
|
|
|
void |
|
roff_openeqn(struct roff *r, const char *name, int line, |
|
int offs, const char *buf) |
|
{ |
|
struct eqn_node *e; |
|
int poff; |
|
|
assert(NULL == r->eqn); |
assert(NULL == r->eqn); |
e = eqn_alloc(ppos, ln, r->parse); |
e = eqn_alloc(name, offs, line, r->parse); |
|
|
if (r->last_eqn) |
if (r->last_eqn) |
r->last_eqn->next = e; |
r->last_eqn->next = e; |
Line 1187 roff_EQ(ROFF_ARGS) |
|
Line 1239 roff_EQ(ROFF_ARGS) |
|
r->first_eqn = r->last_eqn = e; |
r->first_eqn = r->last_eqn = e; |
|
|
r->eqn = r->last_eqn = e; |
r->eqn = r->last_eqn = e; |
|
|
|
if (buf) { |
|
poff = 0; |
|
eqn_read(&r->eqn, line, buf, offs, &poff); |
|
} |
|
} |
|
|
|
/* ARGSUSED */ |
|
static enum rofferr |
|
roff_EQ(ROFF_ARGS) |
|
{ |
|
|
|
roff_openeqn(r, *bufp + pos, ln, ppos, NULL); |
return(ROFF_IGN); |
return(ROFF_IGN); |
} |
} |
|
|
Line 1207 roff_TS(ROFF_ARGS) |
|
Line 1272 roff_TS(ROFF_ARGS) |
|
|
|
if (r->tbl) { |
if (r->tbl) { |
mandoc_msg(MANDOCERR_SCOPEBROKEN, r->parse, ln, ppos, NULL); |
mandoc_msg(MANDOCERR_SCOPEBROKEN, r->parse, ln, ppos, NULL); |
tbl_end(r->tbl); |
tbl_end(&r->tbl); |
} |
} |
|
|
t = tbl_alloc(ppos, ln, r->parse); |
t = tbl_alloc(ppos, ln, r->parse); |
Line 1442 roff_eqn(const struct roff *r) |
|
Line 1507 roff_eqn(const struct roff *r) |
|
{ |
{ |
|
|
return(r->last_eqn ? &r->last_eqn->eqn : NULL); |
return(r->last_eqn ? &r->last_eqn->eqn : NULL); |
|
} |
|
|
|
char |
|
roff_eqndelim(const struct roff *r) |
|
{ |
|
|
|
return('\0'); |
} |
} |