mandoc/mdoc_macro.c - diff

Return to mdoc_macro.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/mdoc_macro.c between version 1.43 and 1.46

version 1.43, 2010/03/29 19:28:04

version 1.46, 2010/03/30 08:24:01

Line 714 in_line(MACRO_PROT_ARGS)

* Whether we allow ignored elements (those without content,

* usually because of reserved words) to squeak by.

switch (tok) {

case (MDOC_An):

/* FALLTHROUGH */

Line 835 in_line(MACRO_PROT_ARGS)

Line 836 in_line(MACRO_PROT_ARGS)

* If no elements have been collected and we're allowed to have

* empties (nc), open a scope and close it out. Otherwise,

* raise a warning.

if (nc && 0 == cnt) {

if ( ! mdoc_elem_alloc(m, line, ppos, tok, arg))

return(0);

Line 857 in_line(MACRO_PROT_ARGS)

Line 858 in_line(MACRO_PROT_ARGS)

static int

blk_full(MACRO_PROT_ARGS)

{

int c, lastarg, reopen, dohead;

int c, la;

struct mdoc_arg *arg;

struct mdoc_node *head; /* save of head macro */

char *p;

/* Close out prior implicit scope. */

* Whether to process a block-head section. If this is

* non-zero, then a head will be opened for all line arguments.

* If not, then the head will always be empty and only a body

* will be opened, which will stay open at the eoln.

switch (tok) {

case (MDOC_Nd):

dohead = 0;

break;

default:

dohead = 1;

break;

}

if ( ! (MDOC_EXPLICIT & mdoc_macros[tok].flags)) {

if ( ! rew_sub(MDOC_BODY, m, tok, line, ppos))

return(0);

Line 884 blk_full(MACRO_PROT_ARGS)

Line 872 blk_full(MACRO_PROT_ARGS)

return(0);

}

* This routine accomodates implicitly- and explicitly-scoped

* macro openings. Implicit ones first close out prior scope

* (seen above). Delay opening the head until necessary to

* allow leading punctuation to print. Special consideration

* for `It -column', which has phrase-part syntax instead of

* regular child nodes.

for (arg = NULL;; ) {

lastarg = *pos;

la = *pos;

c = mdoc_argv(m, line, tok, &arg, pos, buf);

if (ARGV_WORD == c) {

*pos = lastarg;

*pos = la;

break;

}

Line 905 blk_full(MACRO_PROT_ARGS)

Line 902 blk_full(MACRO_PROT_ARGS)

if ( ! mdoc_block_alloc(m, line, ppos, tok, arg))

return(0);

if (0 == buf[*pos]) {

head = NULL;

* The `Nd' macro has all arguments in its body: it's a hybrid

* of block partial-explicit and full-implicit. Stupid.

if (MDOC_Nd == tok) {

if ( ! mdoc_head_alloc(m, line, ppos, tok))

return(0);

head = m->last;

if ( ! rew_sub(MDOC_HEAD, m, tok, line, ppos))

return(0);

if ( ! mdoc_body_alloc(m, line, ppos, tok))

return(0);

return(1);

}

if ( ! mdoc_head_alloc(m, line, ppos, tok))

return(0);

/* Immediately close out head and enter body, if applicable. */

if (0 == dohead) {

if ( ! rew_sub(MDOC_HEAD, m, tok, line, ppos))

return(0);

if ( ! mdoc_body_alloc(m, line, ppos, tok))

return(0);

}

for (reopen = 0;; ) {

for (;;) {

lastarg = *pos;

la = *pos;

c = mdoc_args(m, line, pos, buf, tok, &p);

if (ARGS_ERROR == c)

return(0);

if (ARGS_EOLN == c)

break;

if (ARGS_PHRASE == c) {

assert(dohead);

/* Don't emit leading punct. for phrases. */

if (reopen && ! mdoc_head_alloc(m, line, ppos, tok))

if (NULL == head && ARGS_PHRASE != c &&

1 == mdoc_isdelim(p)) {

if ( ! mdoc_word_alloc(m, line, la, p))

return(0);

continue;

* Phrases are self-contained macro phrases used

}

* in the columnar output of a macro. They need

* special handling.

/* Always re-open head for phrases. */

if ( ! phrase(m, line, lastarg, buf))

if (NULL == head || ARGS_PHRASE == c) {

if ( ! mdoc_head_alloc(m, line, ppos, tok))

return(0);

head = m->last;

}

if (ARGS_PHRASE == c) {

if ( ! phrase(m, line, la, buf))

return(0);

if ( ! rew_sub(MDOC_HEAD, m, tok, line, ppos))

return(0);

reopen = 1;

continue;

}

if (MDOC_MAX == (c = lookup(tok, p))) {

c = lookup(tok, p);

if ( ! mdoc_word_alloc(m, line, lastarg, p))

if (MDOC_MAX != c) {

if ( ! mdoc_macro(m, c, line, la, pos, buf))

return(0);

continue;

break;

}

if ( ! mdoc_word_alloc(m, line, la, p))

return(0);

if ( ! mdoc_macro(m, c, line, lastarg, pos, buf))

}

if (NULL == head) {

if ( ! mdoc_head_alloc(m, line, ppos, tok))

return(0);

break;

head = m->last;

}

if (1 == ppos && ! append_delims(m, line, pos, buf))

return(0);

/* If the body's already open, then just return. */

/* See notes on `Nd' hybrid, above. */

if (0 == dohead)

if (MDOC_Nd == tok)

return(1);

/* Close out scopes to remain in a consistent state. */

if ( ! rew_sub(MDOC_HEAD, m, tok, line, ppos))

return(0);

if ( ! mdoc_body_alloc(m, line, ppos, tok))

Line 1027 blk_part_imp(MACRO_PROT_ARGS)

Line 1036 blk_part_imp(MACRO_PROT_ARGS)

if (ARGS_PUNCT == c)

break;

if (1 == mdoc_isdelim(p) && NULL == body) {

if (NULL == body && 1 == mdoc_isdelim(p)) {

if ( ! mdoc_word_alloc(m, line, la, p))

return(0);

continue;

Line 1051 blk_part_imp(MACRO_PROT_ARGS)

Line 1060 blk_part_imp(MACRO_PROT_ARGS)

/* Clean-ups to leave in a consistent state. */

if (NULL == body && ! mdoc_body_alloc(m, line, ppos, tok))

if (NULL == body) {

return(0);

if ( ! mdoc_body_alloc(m, line, ppos, tok))

return(0);

body = m->last;

}

body = m->last;

* If we can't rewind to our body, then our scope has already

* been closed by another macro (like `Oc' closing `Op'). This

Line 1119 blk_part_exp(MACRO_PROT_ARGS)

Line 1129 blk_part_exp(MACRO_PROT_ARGS)

/* Flush out leading punctuation. */

if (1 == mdoc_isdelim(p) && NULL == head) {

if (NULL == head && 1 == mdoc_isdelim(p)) {

assert(NULL == body);

if ( ! mdoc_word_alloc(m, line, la, p))

return(0);

Line 1199 in_line_argn(MACRO_PROT_ARGS)

Line 1209 in_line_argn(MACRO_PROT_ARGS)

struct mdoc_arg *arg;

char *p;

/* Fixed maximum arguments per macro, if applicable. */

* A line macro that has a fixed number of arguments (maxargs).

* Only open the scope once the first non-leading-punctuation is

* found (unless MDOC_IGNDELIM is noted, like in `Pf'), then

* keep it open until the maximum number of arguments are

* exhausted.

switch (tok) {

case (MDOC_Ap):

Line 1219 in_line_argn(MACRO_PROT_ARGS)

Line 1235 in_line_argn(MACRO_PROT_ARGS)

break;

}

/* Macro argument processing. */

for (arg = NULL; ; ) {

for (arg = NULL;; ) {

la = *pos;

c = mdoc_argv(m, line, tok, &arg, pos, buf);

Line 1239 in_line_argn(MACRO_PROT_ARGS)

Line 1253 in_line_argn(MACRO_PROT_ARGS)

return(0);

}

/* Open the element scope. */

for (flushed = j = 0; ; ) {

if ( ! mdoc_elem_alloc(m, line, ppos, tok, arg))

return(0);

/* Process element arguments. */

for (flushed = j = 0; ; j++) {

la = *pos;

if (j == maxargs && ! flushed) {

if ( ! rew_elem(m, tok))

return(0);

flushed = 1;

}

c = mdoc_args(m, line, pos, buf, tok, &p);

if (ARGS_ERROR == c)

Line 1264 in_line_argn(MACRO_PROT_ARGS)

if (ARGS_EOLN == c)

break;

if ( ! (MDOC_IGNDELIM & mdoc_macros[tok].flags) &&

0 == j && 1 == mdoc_isdelim(p)) {

if ( ! mdoc_word_alloc(m, line, la, p))

return(0);

continue;

} else if (0 == j)

if ( ! mdoc_elem_alloc(m, line, la, tok, arg))

return(0);

if (j == maxargs && ! flushed) {

if ( ! rew_elem(m, tok))

return(0);

flushed = 1;

}

if (MDOC_MAX != (c = lookup(tok, p))) {

if ( ! flushed && ! rew_elem(m, tok))

return(0);

flushed = 1;

if ( ! mdoc_macro(m, c, line, la, pos, buf))

return(0);

j++;

break;

}

Line 1287 in_line_argn(MACRO_PROT_ARGS)

Line 1303 in_line_argn(MACRO_PROT_ARGS)

* code is no here, it's unlikely to be removed.

#ifdef __OpenBSD__

if (MDOC_Xr == tok && j == maxargs) {

if ( ! mdoc_elem_alloc(m, line, ppos, MDOC_Ns, NULL))

if ( ! mdoc_elem_alloc(m, line, la, MDOC_Ns, NULL))

return(0);

if ( ! rew_elem(m, MDOC_Ns))

return(0);

}

#endif

if ( ! mdoc_word_alloc(m, line, la, p))

return(0);

j++;

}

/* Close out and append delimiters. */

if (0 == j && ! mdoc_elem_alloc(m, line, la, tok, arg))

return(0);

/* Close out in a consistent state. */

if ( ! flushed && ! rew_elem(m, tok))

return(0);

CVSweb