version 1.150, 2011/07/23 18:41:18 |
version 1.154, 2011/07/27 07:09:41 |
Line 159 static const char *roff_getstrn(const struct roff *, |
|
Line 159 static const char *roff_getstrn(const struct roff *, |
|
const char *, size_t); |
const char *, size_t); |
static enum rofferr roff_line_ignore(ROFF_ARGS); |
static enum rofferr roff_line_ignore(ROFF_ARGS); |
static enum rofferr roff_nr(ROFF_ARGS); |
static enum rofferr roff_nr(ROFF_ARGS); |
static int roff_res(struct roff *, |
static void roff_res(struct roff *, |
char **, size_t *, int, int); |
char **, size_t *, int, int); |
static enum rofferr roff_rm(ROFF_ARGS); |
static enum rofferr roff_rm(ROFF_ARGS); |
static void roff_setstr(struct roff *, |
static void roff_setstr(struct roff *, |
Line 395 roff_alloc(struct mparse *parse) |
|
Line 395 roff_alloc(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 void |
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 412 roff_res(struct roff *r, char **bufp, size_t *szp, int |
|
Line 413 roff_res(struct roff *r, char **bufp, size_t *szp, int |
|
size_t nsz; |
size_t nsz; |
char *n; |
char *n; |
|
|
/* Search for a leading backslash and save a pointer to it. */ |
again: |
|
|
cp = *bufp + pos; |
cp = *bufp + pos; |
while (NULL != (cp = strchr(cp, '\\'))) { |
while (NULL != (cp = strchr(cp, '\\'))) { |
stesc = cp++; |
stesc = cp++; |
Line 425 roff_res(struct roff *r, char **bufp, size_t *szp, int |
|
Line 425 roff_res(struct roff *r, char **bufp, size_t *szp, int |
|
*/ |
*/ |
|
|
if ('\0' == *cp) |
if ('\0' == *cp) |
return(1); |
return; |
if ('*' != *cp++) |
|
continue; |
|
|
|
|
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); |
|
return; |
|
} |
|
|
|
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 437 roff_res(struct roff *r, char **bufp, size_t *szp, int |
|
Line 449 roff_res(struct roff *r, char **bufp, size_t *szp, int |
|
|
|
switch (*cp) { |
switch (*cp) { |
case ('\0'): |
case ('\0'): |
return(1); |
return; |
case ('('): |
case ('('): |
cp++; |
cp++; |
maxl = 2; |
maxl = 2; |
Line 455 roff_res(struct roff *r, char **bufp, size_t *szp, int |
|
Line 467 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; |
|
} |
if (0 == maxl && ']' == *cp) |
if (0 == maxl && ']' == *cp) |
break; |
break; |
} |
} |
Line 469 roff_res(struct roff *r, char **bufp, size_t *szp, int |
|
Line 486 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 = ""; |
} |
} |
|
|
/* Replace the escape sequence by the string. */ |
/* Replace the escape sequence by the string. */ |
|
|
|
pos += (stesc - *bufp); |
|
|
nsz = *szp + strlen(res) + 1; |
nsz = *szp + strlen(res) + 1; |
n = mandoc_malloc(nsz); |
n = mandoc_malloc(nsz); |
|
|
Line 487 roff_res(struct roff *r, char **bufp, size_t *szp, int |
|
Line 507 roff_res(struct roff *r, char **bufp, size_t *szp, int |
|
|
|
*bufp = n; |
*bufp = n; |
*szp = nsz; |
*szp = nsz; |
return(0); |
goto again; |
} |
} |
|
|
return(1); |
|
} |
} |
|
|
|
/* |
|
* Process text streams: convert all breakable hyphens into ASCII_HYPH. |
|
*/ |
|
static enum rofferr |
|
roff_parsetext(char *p) |
|
{ |
|
size_t sz; |
|
const char *start; |
|
enum mandoc_esc esc; |
|
|
|
start = p; |
|
|
|
while ('\0' != *p) { |
|
sz = strcspn(p, "-\\"); |
|
p += sz; |
|
|
|
if ('\\' == *p) { |
|
/* Skip over escapes. */ |
|
p++; |
|
esc = mandoc_escape |
|
((const char **)&p, NULL, NULL); |
|
if (ESCAPE_ERROR == esc) |
|
break; |
|
} else if ('-' == *p) { |
|
if (mandoc_hyph(start, p)) |
|
*p = ASCII_HYPH; |
|
p++; |
|
} |
|
} |
|
|
|
return(ROFF_CONT); |
|
} |
|
|
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 507 roff_parseln(struct roff *r, int ln, char **bufp, |
|
Line 557 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)) |
roff_res(r, bufp, szp, ln, pos); |
return(ROFF_REPARSE); |
|
|
|
ppos = pos; |
ppos = pos; |
ctl = mandoc_getcontrol(*bufp, &pos); |
ctl = mandoc_getcontrol(*bufp, &pos); |
Line 533 roff_parseln(struct roff *r, int ln, char **bufp, |
|
Line 582 roff_parseln(struct roff *r, int ln, char **bufp, |
|
return(eqn_read(&r->eqn, ln, *bufp, pos, offs)); |
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_parsetext(*bufp + pos)); |
} else if ( ! ctl) { |
} else if ( ! ctl) { |
if (r->eqn) |
if (r->eqn) |
return(eqn_read(&r->eqn, ln, *bufp, pos, offs)); |
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_parsetext(*bufp + pos)); |
} else if (r->eqn) |
} else if (r->eqn) |
return(eqn_read(&r->eqn, ln, *bufp, ppos, offs)); |
return(eqn_read(&r->eqn, ln, *bufp, ppos, offs)); |
|
|
Line 584 roff_endparse(struct roff *r) |
|
Line 633 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.ln, 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 1182 roff_TE(ROFF_ARGS) |
|
Line 1229 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 1201 roff_T_(ROFF_ARGS) |
|
Line 1247 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(*bufp + pos, 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 1216 roff_EQ(ROFF_ARGS) |
|
Line 1270 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 1236 roff_TS(ROFF_ARGS) |
|
Line 1303 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 1471 roff_eqn(const struct roff *r) |
|
Line 1538 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'); |
} |
} |