version 1.74, 2012/06/12 12:47:14 |
version 1.76, 2013/10/17 20:54:58 |
Line 88 const struct man_macro __man_macros[MAN_MAX] = { |
|
Line 88 const struct man_macro __man_macros[MAN_MAX] = { |
|
{ in_line_eoln, 0 }, /* OP */ |
{ in_line_eoln, 0 }, /* OP */ |
{ in_line_eoln, MAN_BSCOPE }, /* EX */ |
{ in_line_eoln, MAN_BSCOPE }, /* EX */ |
{ in_line_eoln, MAN_BSCOPE }, /* EE */ |
{ in_line_eoln, MAN_BSCOPE }, /* EE */ |
|
{ blk_exp, MAN_BSCOPE | MAN_EXPLICIT }, /* UR */ |
|
{ blk_close, 0 }, /* UE */ |
}; |
}; |
|
|
const struct man_macro * const man_macros = __man_macros; |
const struct man_macro * const man_macros = __man_macros; |
Line 97 const struct man_macro * const man_macros = __man_macr |
|
Line 99 const struct man_macro * const man_macros = __man_macr |
|
* Warn when "n" is an explicit non-roff macro. |
* Warn when "n" is an explicit non-roff macro. |
*/ |
*/ |
static void |
static void |
rew_warn(struct man *m, struct man_node *n, enum mandocerr er) |
rew_warn(struct man *man, struct man_node *n, enum mandocerr er) |
{ |
{ |
|
|
if (er == MANDOCERR_MAX || MAN_BLOCK != n->type) |
if (er == MANDOCERR_MAX || MAN_BLOCK != n->type) |
Line 108 rew_warn(struct man *m, struct man_node *n, enum mando |
|
Line 110 rew_warn(struct man *m, struct man_node *n, enum mando |
|
return; |
return; |
|
|
assert(er < MANDOCERR_FATAL); |
assert(er < MANDOCERR_FATAL); |
man_nmsg(m, n, er); |
man_nmsg(man, n, er); |
} |
} |
|
|
|
|
Line 117 rew_warn(struct man *m, struct man_node *n, enum mando |
|
Line 119 rew_warn(struct man *m, struct man_node *n, enum mando |
|
* will be used if an explicit block scope is being closed out. |
* will be used if an explicit block scope is being closed out. |
*/ |
*/ |
int |
int |
man_unscope(struct man *m, const struct man_node *to, |
man_unscope(struct man *man, const struct man_node *to, |
enum mandocerr er) |
enum mandocerr er) |
{ |
{ |
struct man_node *n; |
struct man_node *n; |
|
|
assert(to); |
assert(to); |
|
|
m->next = MAN_NEXT_SIBLING; |
man->next = MAN_NEXT_SIBLING; |
|
|
/* LINTED */ |
/* LINTED */ |
while (m->last != to) { |
while (man->last != to) { |
/* |
/* |
* Save the parent here, because we may delete the |
* Save the parent here, because we may delete the |
* m->last node in the post-validation phase and reset |
* man->last node in the post-validation phase and reset |
* it to m->last->parent, causing a step in the closing |
* it to man->last->parent, causing a step in the closing |
* out to be lost. |
* out to be lost. |
*/ |
*/ |
n = m->last->parent; |
n = man->last->parent; |
rew_warn(m, m->last, er); |
rew_warn(man, man->last, er); |
if ( ! man_valid_post(m)) |
if ( ! man_valid_post(man)) |
return(0); |
return(0); |
m->last = n; |
man->last = n; |
assert(m->last); |
assert(man->last); |
} |
} |
|
|
rew_warn(m, m->last, er); |
rew_warn(man, man->last, er); |
if ( ! man_valid_post(m)) |
if ( ! man_valid_post(man)) |
return(0); |
return(0); |
|
|
return(1); |
return(1); |
Line 241 rew_dohalt(enum mant tok, enum man_type type, const st |
|
Line 243 rew_dohalt(enum mant tok, enum man_type type, const st |
|
* scopes. When a scope is closed, it must be validated and actioned. |
* scopes. When a scope is closed, it must be validated and actioned. |
*/ |
*/ |
static int |
static int |
rew_scope(enum man_type type, struct man *m, enum mant tok) |
rew_scope(enum man_type type, struct man *man, enum mant tok) |
{ |
{ |
struct man_node *n; |
struct man_node *n; |
enum rew c; |
enum rew c; |
|
|
/* LINTED */ |
/* LINTED */ |
for (n = m->last; n; n = n->parent) { |
for (n = man->last; n; n = n->parent) { |
/* |
/* |
* Whether we should stop immediately (REW_HALT), stop |
* Whether we should stop immediately (REW_HALT), stop |
* and rewind until this point (REW_REWIND), or keep |
* and rewind until this point (REW_REWIND), or keep |
Line 266 rew_scope(enum man_type type, struct man *m, enum mant |
|
Line 268 rew_scope(enum man_type type, struct man *m, enum mant |
|
*/ |
*/ |
assert(n); |
assert(n); |
|
|
return(man_unscope(m, n, MANDOCERR_MAX)); |
return(man_unscope(man, n, MANDOCERR_MAX)); |
} |
} |
|
|
|
|
Line 284 blk_close(MACRO_PROT_ARGS) |
|
Line 286 blk_close(MACRO_PROT_ARGS) |
|
case (MAN_RE): |
case (MAN_RE): |
ntok = MAN_RS; |
ntok = MAN_RS; |
break; |
break; |
|
case (MAN_UE): |
|
ntok = MAN_UR; |
|
break; |
default: |
default: |
abort(); |
abort(); |
/* NOTREACHED */ |
/* NOTREACHED */ |
} |
} |
|
|
for (nn = m->last->parent; nn; nn = nn->parent) |
for (nn = man->last->parent; nn; nn = nn->parent) |
if (ntok == nn->tok && MAN_BLOCK == nn->type) |
if (ntok == nn->tok && MAN_BLOCK == nn->type) |
break; |
break; |
|
|
if (NULL != nn) |
if (NULL != nn) |
man_unscope(m, nn, MANDOCERR_MAX); |
man_unscope(man, nn, MANDOCERR_MAX); |
else |
else |
man_pmsg(m, line, ppos, MANDOCERR_NOSCOPE); |
man_pmsg(man, line, ppos, MANDOCERR_NOSCOPE); |
|
|
return(1); |
return(1); |
} |
} |
Line 312 blk_exp(MACRO_PROT_ARGS) |
|
Line 317 blk_exp(MACRO_PROT_ARGS) |
|
|
|
/* Close out prior implicit scopes. */ |
/* Close out prior implicit scopes. */ |
|
|
if ( ! rew_scope(MAN_BLOCK, m, tok)) |
if ( ! rew_scope(MAN_BLOCK, man, tok)) |
return(0); |
return(0); |
|
|
if ( ! man_block_alloc(m, line, ppos, tok)) |
if ( ! man_block_alloc(man, line, ppos, tok)) |
return(0); |
return(0); |
if ( ! man_head_alloc(m, line, ppos, tok)) |
if ( ! man_head_alloc(man, line, ppos, tok)) |
return(0); |
return(0); |
|
|
for (;;) { |
for (;;) { |
la = *pos; |
la = *pos; |
if ( ! man_args(m, line, pos, buf, &p)) |
if ( ! man_args(man, line, pos, buf, &p)) |
break; |
break; |
if ( ! man_word_alloc(m, line, la, p)) |
if ( ! man_word_alloc(man, line, la, p)) |
return(0); |
return(0); |
} |
} |
|
|
assert(m); |
assert(man); |
assert(tok != MAN_MAX); |
assert(tok != MAN_MAX); |
|
|
for (n = m->last; n; n = n->parent) { |
for (n = man->last; n; n = n->parent) { |
if (n->tok != tok) |
if (n->tok != tok) |
continue; |
continue; |
assert(MAN_HEAD == n->type); |
assert(MAN_HEAD == n->type); |
man_unscope(m, n, MANDOCERR_MAX); |
man_unscope(man, n, MANDOCERR_MAX); |
break; |
break; |
} |
} |
|
|
return(man_body_alloc(m, line, ppos, tok)); |
return(man_body_alloc(man, line, ppos, tok)); |
} |
} |
|
|
|
|
Line 360 blk_imp(MACRO_PROT_ARGS) |
|
Line 365 blk_imp(MACRO_PROT_ARGS) |
|
|
|
/* Close out prior scopes. */ |
/* Close out prior scopes. */ |
|
|
if ( ! rew_scope(MAN_BODY, m, tok)) |
if ( ! rew_scope(MAN_BODY, man, tok)) |
return(0); |
return(0); |
if ( ! rew_scope(MAN_BLOCK, m, tok)) |
if ( ! rew_scope(MAN_BLOCK, man, tok)) |
return(0); |
return(0); |
|
|
/* Allocate new block & head scope. */ |
/* Allocate new block & head scope. */ |
|
|
if ( ! man_block_alloc(m, line, ppos, tok)) |
if ( ! man_block_alloc(man, line, ppos, tok)) |
return(0); |
return(0); |
if ( ! man_head_alloc(m, line, ppos, tok)) |
if ( ! man_head_alloc(man, line, ppos, tok)) |
return(0); |
return(0); |
|
|
n = m->last; |
n = man->last; |
|
|
/* Add line arguments. */ |
/* Add line arguments. */ |
|
|
for (;;) { |
for (;;) { |
la = *pos; |
la = *pos; |
if ( ! man_args(m, line, pos, buf, &p)) |
if ( ! man_args(man, line, pos, buf, &p)) |
break; |
break; |
if ( ! man_word_alloc(m, line, la, p)) |
if ( ! man_word_alloc(man, line, la, p)) |
return(0); |
return(0); |
} |
} |
|
|
Line 389 blk_imp(MACRO_PROT_ARGS) |
|
Line 394 blk_imp(MACRO_PROT_ARGS) |
|
if (MAN_SCOPED & man_macros[tok].flags) { |
if (MAN_SCOPED & man_macros[tok].flags) { |
/* If we're forcing scope (`TP'), keep it open. */ |
/* If we're forcing scope (`TP'), keep it open. */ |
if (MAN_FSCOPED & man_macros[tok].flags) { |
if (MAN_FSCOPED & man_macros[tok].flags) { |
m->flags |= MAN_BLINE; |
man->flags |= MAN_BLINE; |
return(1); |
return(1); |
} else if (n == m->last) { |
} else if (n == man->last) { |
m->flags |= MAN_BLINE; |
man->flags |= MAN_BLINE; |
return(1); |
return(1); |
} |
} |
} |
} |
|
|
if ( ! rew_scope(MAN_HEAD, m, tok)) |
if ( ! rew_scope(MAN_HEAD, man, tok)) |
return(0); |
return(0); |
return(man_body_alloc(m, line, ppos, tok)); |
return(man_body_alloc(man, line, ppos, tok)); |
} |
} |
|
|
|
|
Line 411 in_line_eoln(MACRO_PROT_ARGS) |
|
Line 416 in_line_eoln(MACRO_PROT_ARGS) |
|
char *p; |
char *p; |
struct man_node *n; |
struct man_node *n; |
|
|
if ( ! man_elem_alloc(m, line, ppos, tok)) |
if ( ! man_elem_alloc(man, line, ppos, tok)) |
return(0); |
return(0); |
|
|
n = m->last; |
n = man->last; |
|
|
for (;;) { |
for (;;) { |
la = *pos; |
la = *pos; |
if ( ! man_args(m, line, pos, buf, &p)) |
if ( ! man_args(man, line, pos, buf, &p)) |
break; |
break; |
if ( ! man_word_alloc(m, line, la, p)) |
if ( ! man_word_alloc(man, line, la, p)) |
return(0); |
return(0); |
} |
} |
|
|
Line 430 in_line_eoln(MACRO_PROT_ARGS) |
|
Line 435 in_line_eoln(MACRO_PROT_ARGS) |
|
* waiting for terms to load into our context. |
* waiting for terms to load into our context. |
*/ |
*/ |
|
|
if (n == m->last && MAN_SCOPED & man_macros[tok].flags) { |
if (n == man->last && MAN_SCOPED & man_macros[tok].flags) { |
assert( ! (MAN_NSCOPED & man_macros[tok].flags)); |
assert( ! (MAN_NSCOPED & man_macros[tok].flags)); |
m->flags |= MAN_ELINE; |
man->flags |= MAN_ELINE; |
return(1); |
return(1); |
} |
} |
|
|
Line 440 in_line_eoln(MACRO_PROT_ARGS) |
|
Line 445 in_line_eoln(MACRO_PROT_ARGS) |
|
|
|
if (MAN_NSCOPED & man_macros[tok].flags) { |
if (MAN_NSCOPED & man_macros[tok].flags) { |
assert( ! (MAN_SCOPED & man_macros[tok].flags)); |
assert( ! (MAN_SCOPED & man_macros[tok].flags)); |
m->flags |= MAN_ILINE; |
man->flags |= MAN_ILINE; |
} |
} |
|
|
assert(MAN_ROOT != m->last->type); |
assert(MAN_ROOT != man->last->type); |
m->next = MAN_NEXT_SIBLING; |
man->next = MAN_NEXT_SIBLING; |
|
|
/* |
/* |
* Rewind our element scope. Note that when TH is pruned, we'll |
* Rewind our element scope. Note that when TH is pruned, we'll |
Line 452 in_line_eoln(MACRO_PROT_ARGS) |
|
Line 457 in_line_eoln(MACRO_PROT_ARGS) |
|
* its sibling. |
* its sibling. |
*/ |
*/ |
|
|
for ( ; m->last; m->last = m->last->parent) { |
for ( ; man->last; man->last = man->last->parent) { |
if (m->last == n) |
if (man->last == n) |
break; |
break; |
if (m->last->type == MAN_ROOT) |
if (man->last->type == MAN_ROOT) |
break; |
break; |
if ( ! man_valid_post(m)) |
if ( ! man_valid_post(man)) |
return(0); |
return(0); |
} |
} |
|
|
assert(m->last); |
assert(man->last); |
|
|
/* |
/* |
* Same here regarding whether we're back at the root. |
* Same here regarding whether we're back at the root. |
*/ |
*/ |
|
|
if (m->last->type != MAN_ROOT && ! man_valid_post(m)) |
if (man->last->type != MAN_ROOT && ! man_valid_post(man)) |
return(0); |
return(0); |
|
|
return(1); |
return(1); |
Line 475 in_line_eoln(MACRO_PROT_ARGS) |
|
Line 480 in_line_eoln(MACRO_PROT_ARGS) |
|
|
|
|
|
int |
int |
man_macroend(struct man *m) |
man_macroend(struct man *man) |
{ |
{ |
|
|
return(man_unscope(m, m->first, MANDOCERR_SCOPEEXIT)); |
return(man_unscope(man, man->first, MANDOCERR_SCOPEEXIT)); |
} |
} |
|
|
static int |
static int |
man_args(struct man *m, int line, int *pos, char *buf, char **v) |
man_args(struct man *man, int line, int *pos, char *buf, char **v) |
{ |
{ |
char *start; |
char *start; |
|
|
Line 493 man_args(struct man *m, int line, int *pos, char *buf, |
|
Line 498 man_args(struct man *m, int line, int *pos, char *buf, |
|
if ('\0' == *start) |
if ('\0' == *start) |
return(0); |
return(0); |
|
|
*v = mandoc_getarg(m->parse, v, line, pos); |
*v = mandoc_getarg(man->parse, v, line, pos); |
return(1); |
return(1); |
} |
} |