version 1.70, 2010/05/29 18:47:54 |
version 1.78, 2010/05/31 22:39:55 |
Line 44 static int in_line_eoln(MACRO_PROT_ARGS); |
|
Line 44 static int in_line_eoln(MACRO_PROT_ARGS); |
|
static int in_line_argn(MACRO_PROT_ARGS); |
static int in_line_argn(MACRO_PROT_ARGS); |
static int in_line(MACRO_PROT_ARGS); |
static int in_line(MACRO_PROT_ARGS); |
static int obsolete(MACRO_PROT_ARGS); |
static int obsolete(MACRO_PROT_ARGS); |
|
static int phrase_ta(MACRO_PROT_ARGS); |
|
|
static int append_delims(struct mdoc *, |
static int append_delims(struct mdoc *, |
int, int *, char *); |
int, int *, char *); |
static enum mdoct lookup(enum mdoct, const char *); |
static enum mdoct lookup(enum mdoct, const char *); |
static enum mdoct lookup_raw(const char *); |
static enum mdoct lookup_raw(const char *); |
static int phrase(struct mdoc *, int, int, |
static int phrase(struct mdoc *, int, int, char *); |
char *, enum margserr); |
|
static enum mdoct rew_alt(enum mdoct); |
static enum mdoct rew_alt(enum mdoct); |
static int rew_dobreak(enum mdoct, |
static int rew_dobreak(enum mdoct, |
const struct mdoc_node *); |
const struct mdoc_node *); |
Line 186 const struct mdoc_macro __mdoc_macros[MDOC_MAX] = { |
|
Line 186 const struct mdoc_macro __mdoc_macros[MDOC_MAX] = { |
|
{ in_line_eoln, 0 }, /* br */ |
{ in_line_eoln, 0 }, /* br */ |
{ in_line_eoln, 0 }, /* sp */ |
{ in_line_eoln, 0 }, /* sp */ |
{ in_line_eoln, 0 }, /* %U */ |
{ in_line_eoln, 0 }, /* %U */ |
|
{ phrase_ta, MDOC_CALLABLE | MDOC_PARSED }, /* Ta */ |
}; |
}; |
|
|
const struct mdoc_macro * const mdoc_macros = __mdoc_macros; |
const struct mdoc_macro * const mdoc_macros = __mdoc_macros; |
Line 196 swarn(struct mdoc *mdoc, enum mdoc_type type, |
|
Line 197 swarn(struct mdoc *mdoc, enum mdoc_type type, |
|
int line, int pos, const struct mdoc_node *p) |
int line, int pos, const struct mdoc_node *p) |
{ |
{ |
const char *n, *t, *tt; |
const char *n, *t, *tt; |
int rc; |
enum mandocerr ec; |
|
|
n = t = "<root>"; |
n = t = "<root>"; |
tt = "block"; |
tt = "block"; |
Line 229 swarn(struct mdoc *mdoc, enum mdoc_type type, |
|
Line 230 swarn(struct mdoc *mdoc, enum mdoc_type type, |
|
break; |
break; |
} |
} |
|
|
rc = mdoc_vmsg(mdoc, MANDOCERR_SCOPE, line, pos, |
ec = (MDOC_IGN_SCOPE & mdoc->pflags) ? |
"%s scope breaks %s of %s", tt, t, n); |
MANDOCERR_SCOPE : MANDOCERR_SYNTSCOPE; |
|
|
/* FIXME: logic should be in driver. */ |
return(mdoc_vmsg(mdoc, ec, line, pos, |
return(MDOC_IGN_SCOPE & mdoc->pflags ? rc : 0); |
"%s scope breaks %s of %s", |
|
tt, t, n)); |
} |
} |
|
|
|
|
Line 937 blk_full(MACRO_PROT_ARGS) |
|
Line 939 blk_full(MACRO_PROT_ARGS) |
|
#ifdef UGLY |
#ifdef UGLY |
struct mdoc_node *n; |
struct mdoc_node *n; |
#endif |
#endif |
|
enum mdoc_type mtt; |
enum mdoct ntok; |
enum mdoct ntok; |
enum margserr ac, lac; |
enum margserr ac, lac; |
enum margverr av; |
enum margverr av; |
Line 1005 blk_full(MACRO_PROT_ARGS) |
|
Line 1008 blk_full(MACRO_PROT_ARGS) |
|
|
|
for ( ; ; ) { |
for ( ; ; ) { |
la = *pos; |
la = *pos; |
lac = ac; |
/* Initialise last-phrase-type with ARGS_PEND. */ |
|
lac = ARGS_ERROR == ac ? ARGS_PEND : ac; |
ac = mdoc_args(m, line, pos, buf, tok, &p); |
ac = mdoc_args(m, line, pos, buf, tok, &p); |
|
|
if (ARGS_ERROR == ac) |
if (ARGS_ERROR == ac) |
return(0); |
return(0); |
if (ARGS_EOLN == ac) |
|
break; |
|
|
|
if (ARGS_PEND == ac) { |
if (ARGS_EOLN == ac) { |
if (ARGS_PPHRASE == lac) |
if (ARGS_PPHRASE != lac && ARGS_PHRASE != lac) |
ac = ARGS_PPHRASE; |
break; |
else |
/* |
ac = ARGS_PHRASE; |
* This is necessary: if the last token on a |
|
* line is a `Ta' or tab, then we'll get |
|
* ARGS_EOLN, so we must be smart enough to |
|
* reopen our scope if the last parse was a |
|
* phrase or partial phrase. |
|
*/ |
|
if ( ! rew_sub(MDOC_BODY, m, tok, line, ppos)) |
|
return(0); |
|
if ( ! mdoc_body_alloc(m, line, ppos, tok)) |
|
return(0); |
|
body = m->last; |
|
break; |
} |
} |
|
|
/* Don't emit leading punct. for phrases. */ |
/* |
|
* Emit leading punctuation (i.e., punctuation before |
|
* the MDOC_HEAD) for non-phrase types. |
|
*/ |
|
|
if (NULL == head && |
if (NULL == head && |
|
ARGS_PEND != ac && |
ARGS_PHRASE != ac && |
ARGS_PHRASE != ac && |
ARGS_PPHRASE != ac && |
ARGS_PPHRASE != ac && |
ARGS_QWORD != ac && |
ARGS_QWORD != ac && |
Line 1032 blk_full(MACRO_PROT_ARGS) |
|
Line 1049 blk_full(MACRO_PROT_ARGS) |
|
continue; |
continue; |
} |
} |
|
|
/* Always re-open head for phrases. */ |
/* Open a head if one hasn't been opened. */ |
|
|
if (NULL == head || |
if (NULL == head) { |
ARGS_PHRASE == ac || |
|
ARGS_PPHRASE == ac) { |
|
if ( ! mdoc_head_alloc(m, line, ppos, tok)) |
if ( ! mdoc_head_alloc(m, line, ppos, tok)) |
return(0); |
return(0); |
head = m->last; |
head = m->last; |
} |
} |
|
|
if (ARGS_PHRASE == ac || ARGS_PPHRASE == ac) { |
if (ARGS_PHRASE == ac || |
|
ARGS_PEND == ac || |
|
ARGS_PPHRASE == ac) { |
|
/* |
|
* If we haven't opened a body yet, rewind the |
|
* head; if we have, rewind that instead. |
|
*/ |
|
|
|
mtt = body ? MDOC_BODY : MDOC_HEAD; |
|
if ( ! rew_sub(mtt, m, tok, line, ppos)) |
|
return(0); |
|
|
|
/* Then allocate our body context. */ |
|
|
|
if ( ! mdoc_body_alloc(m, line, ppos, tok)) |
|
return(0); |
|
body = m->last; |
|
|
|
/* |
|
* Process phrases: set whether we're in a |
|
* partial-phrase (this effects line handling) |
|
* then call down into the phrase parser. |
|
*/ |
|
|
if (ARGS_PPHRASE == ac) |
if (ARGS_PPHRASE == ac) |
m->flags |= MDOC_PPHRASE; |
m->flags |= MDOC_PPHRASE; |
if ( ! phrase(m, line, la, buf, ac)) |
if (ARGS_PEND == ac && ARGS_PPHRASE == lac) |
|
m->flags |= MDOC_PPHRASE; |
|
|
|
if ( ! phrase(m, line, la, buf)) |
return(0); |
return(0); |
|
|
m->flags &= ~MDOC_PPHRASE; |
m->flags &= ~MDOC_PPHRASE; |
if ( ! rew_sub(MDOC_HEAD, m, tok, line, ppos)) |
|
return(0); |
|
continue; |
continue; |
} |
} |
|
|
Line 1078 blk_full(MACRO_PROT_ARGS) |
|
Line 1118 blk_full(MACRO_PROT_ARGS) |
|
/* If we've already opened our body, exit now. */ |
/* If we've already opened our body, exit now. */ |
|
|
if (NULL != body) |
if (NULL != body) |
return(1); |
goto out; |
|
|
#ifdef UGLY |
#ifdef UGLY |
/* |
/* |
Line 1105 blk_full(MACRO_PROT_ARGS) |
|
Line 1145 blk_full(MACRO_PROT_ARGS) |
|
if ( ! mdoc_body_alloc(m, line, ppos, tok)) |
if ( ! mdoc_body_alloc(m, line, ppos, tok)) |
return(0); |
return(0); |
|
|
|
out: |
|
if ( ! (MDOC_FREECOL & m->flags)) |
|
return(1); |
|
|
|
if ( ! rew_sub(MDOC_BODY, m, tok, line, ppos)) |
|
return(0); |
|
if ( ! rew_sub(MDOC_BLOCK, m, tok, line, ppos)) |
|
return(0); |
|
|
|
m->flags &= ~MDOC_FREECOL; |
return(1); |
return(1); |
} |
} |
|
|
Line 1599 obsolete(MACRO_PROT_ARGS) |
|
Line 1649 obsolete(MACRO_PROT_ARGS) |
|
* macro is encountered. |
* macro is encountered. |
*/ |
*/ |
static int |
static int |
phrase(struct mdoc *m, int line, int ppos, char *buf, enum margserr ac) |
phrase(struct mdoc *m, int line, int ppos, char *buf) |
{ |
{ |
int la, pos; |
int la, pos; |
enum margserr aac; |
enum margserr ac; |
enum mdoct ntok; |
enum mdoct ntok; |
char *p; |
char *p; |
|
|
assert(ARGS_PHRASE == ac || ARGS_PPHRASE == ac); |
|
|
|
for (pos = ppos; ; ) { |
for (pos = ppos; ; ) { |
la = pos; |
la = pos; |
|
|
aac = mdoc_zargs(m, line, &pos, buf, 0, &p); |
ac = mdoc_zargs(m, line, &pos, buf, 0, &p); |
|
|
if (ARGS_ERROR == aac) |
if (ARGS_ERROR == ac) |
return(0); |
return(0); |
if (ARGS_EOLN == aac) |
if (ARGS_EOLN == ac) |
break; |
break; |
|
|
ntok = ARGS_QWORD == aac ? MDOC_MAX : lookup_raw(p); |
ntok = ARGS_QWORD == ac ? MDOC_MAX : lookup_raw(p); |
|
|
if (MDOC_MAX == ntok) { |
if (MDOC_MAX == ntok) { |
if ( ! mdoc_word_alloc(m, line, la, p)) |
if ( ! mdoc_word_alloc(m, line, la, p)) |
Line 1635 phrase(struct mdoc *m, int line, int ppos, char *buf, |
|
Line 1683 phrase(struct mdoc *m, int line, int ppos, char *buf, |
|
} |
} |
|
|
|
|
|
static int |
|
phrase_ta(MACRO_PROT_ARGS) |
|
{ |
|
int la; |
|
enum mdoct ntok; |
|
enum margserr ac; |
|
struct mdoc_node *n; |
|
char *p; |
|
|
|
/* |
|
* FIXME: this is overly restrictive: if the `Ta' is unexpected, |
|
* it should simply error out with ARGSLOST. |
|
*/ |
|
|
|
n = m->last; |
|
if ( ! rew_sub(MDOC_BODY, m, MDOC_It, line, ppos)) |
|
return(0); |
|
if ( ! mdoc_body_alloc(m, line, ppos, MDOC_It)) |
|
return(0); |
|
|
|
for (;;) { |
|
la = *pos; |
|
ac = mdoc_zargs(m, line, pos, buf, 0, &p); |
|
|
|
if (ARGS_ERROR == ac) |
|
return(0); |
|
if (ARGS_EOLN == ac) |
|
break; |
|
|
|
ntok = ARGS_QWORD == ac ? MDOC_MAX : lookup_raw(p); |
|
|
|
if (MDOC_MAX == ntok) { |
|
if ( ! mdoc_word_alloc(m, line, la, p)) |
|
return(0); |
|
continue; |
|
} |
|
|
|
if ( ! mdoc_macro(m, ntok, line, la, pos, buf)) |
|
return(0); |
|
return(append_delims(m, line, pos, buf)); |
|
} |
|
|
|
return(1); |
|
} |