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.152 and 1.178

version 1.152, 2014/11/28 23:21:32

version 1.178, 2015/02/06 03:38:45

Line 1

/* $Id$ */

* Permission to use, copy, modify, and distribute this software for any

* purpose with or without fee is hereby granted, provided that the above

Line 31

#include "libmdoc.h"

#include "libmandoc.h"

enum rew { /* see rew_dohalt() */

REWIND_NONE,

REWIND_THIS,

REWIND_MORE,

REWIND_FORCE,

REWIND_LATER,

REWIND_ERROR

};

static void blk_full(MACRO_PROT_ARGS);

static void blk_exp_close(MACRO_PROT_ARGS);

static void blk_part_exp(MACRO_PROT_ARGS);

Line 53 static void phrase_ta(MACRO_PROT_ARGS);

Line 44 static void phrase_ta(MACRO_PROT_ARGS);

static void dword(struct mdoc *, int, int, const char *,

enum mdelim, int);

static void append_delims(struct mdoc *, int, int *, char *);

static enum mdoct lookup(enum mdoct, const char *);

static enum mdoct lookup(struct mdoc *, enum mdoct,

static enum mdoct lookup_raw(const char *);

int, int, const char *);

static int make_pending(struct mdoc_node *, enum mdoct,

static int macro_or_word(MACRO_PROT_ARGS, int);

struct mdoc *, int, int);

static void make_pending(struct mdoc *, struct mdoc_node *,

static void phrase(struct mdoc *, int, int, char *);

struct mdoc_node *, int, int);

static int parse_rest(struct mdoc *, enum mdoct,

int, int *, char *);

static enum mdoct rew_alt(enum mdoct);

static enum rew rew_dohalt(enum mdoct, enum mdoc_type,

const struct mdoc_node *);

static void rew_elem(struct mdoc *, enum mdoct);

static void rew_last(struct mdoc *, const struct mdoc_node *);

static void rew_sub(enum mdoc_type, struct mdoc *,

static void rew_pending(struct mdoc *, const struct mdoc_node *);

enum mdoct, int, int);

const struct mdoc_macro __mdoc_macros[MDOC_MAX] = {

{ in_line_argn, MDOC_CALLABLE | MDOC_PARSED | MDOC_JOIN }, /* Ap */

Line 240 mdoc_macroend(struct mdoc *mdoc)

Line 230 mdoc_macroend(struct mdoc *mdoc)

}

* Look up a macro from within a subsequent context.

* Look up the macro at *p called by "from",

* or as a line macro if from == MDOC_MAX.

static enum mdoct

lookup(enum mdoct from, const char *p)

lookup(struct mdoc *mdoc, enum mdoct from, int line, int ppos, const char *p)

{

if ( ! (MDOC_PARSED & mdoc_macros[from].flags))

return(MDOC_MAX);

return(lookup_raw(p));

}

* Lookup a macro following the initial line macro.

static enum mdoct

lookup_raw(const char *p)

{

enum mdoct res;

if (MDOC_MAX == (res = mdoc_hash_find(p)))

if (from == MDOC_MAX || mdoc_macros[from].flags & MDOC_PARSED) {

return(MDOC_MAX);

res = mdoc_hash_find(p);

if (MDOC_CALLABLE & mdoc_macros[res].flags)

if (res != MDOC_MAX) {

return(res);

if (mdoc_macros[res].flags & MDOC_CALLABLE)

return(res);

if (res != MDOC_br && res != MDOC_sp && res != MDOC_ll)

mandoc_msg(MANDOCERR_MACRO_CALL,

mdoc->parse, line, ppos, p);

}

return(MDOC_MAX);

}

* Rewind up to and including a specific node.

static void

rew_last(struct mdoc *mdoc, const struct mdoc_node *to)

{

Line 291 rew_last(struct mdoc *mdoc, const struct mdoc_node *to

Line 279 rew_last(struct mdoc *mdoc, const struct mdoc_node *to

}

* Rewind up to a specific block, including all blocks that broke it.

static void

rew_pending(struct mdoc *mdoc, const struct mdoc_node *n)

{

rew_last(mdoc, n);

if (n->type != MDOC_BLOCK)

return;

while ((n = n->pending) != NULL) {

rew_last(mdoc, n);

if (n->type == MDOC_HEAD)

mdoc_body_alloc(mdoc, n->line, n->pos, n->tok);

}

* For a block closing macro, return the corresponding opening one.

* Otherwise, return the macro itself.

Line 336 rew_alt(enum mdoct tok)

Line 343 rew_alt(enum mdoct tok)

/* NOTREACHED */

}

* Rewinding to tok, how do we have to handle *p?

* REWIND_NONE: *p would delimit tok, but no tok scope is open

* inside *p, so there is no need to rewind anything at all.

* REWIND_THIS: *p matches tok, so rewind *p and nothing else.

* REWIND_MORE: *p is implicit, rewind it and keep searching for tok.

* REWIND_FORCE: *p is explicit, but tok is full, force rewinding *p.

* REWIND_LATER: *p is explicit and still open, postpone rewinding.

* REWIND_ERROR: No tok block is open at all.

static enum rew

rew_dohalt(enum mdoct tok, enum mdoc_type type,

const struct mdoc_node *p)

{

* No matching token, no delimiting block, no broken block.

* This can happen when full implicit macros are called for

* the first time but try to rewind their previous

* instance anyway.

if (MDOC_ROOT == p->type)

return(MDOC_BLOCK == type &&

MDOC_EXPLICIT & mdoc_macros[tok].flags ?

REWIND_ERROR : REWIND_NONE);

* When starting to rewind, skip plain text

* and nodes that have already been rewound.

if (MDOC_TEXT == p->type || MDOC_VALID & p->flags)

return(REWIND_MORE);

* The easiest case: Found a matching token.

* This applies to both blocks and elements.

tok = rew_alt(tok);

if (tok == p->tok)

return(p->end ? REWIND_NONE :

type == p->type ? REWIND_THIS : REWIND_MORE);

* While elements do require rewinding for themselves,

* they never affect rewinding of other nodes.

if (MDOC_ELEM == p->type)

return(REWIND_MORE);

* Blocks delimited by our target token get REWIND_MORE.

* Blocks delimiting our target token get REWIND_NONE.

switch (tok) {

case MDOC_Bl:

if (MDOC_It == p->tok)

return(REWIND_MORE);

break;

case MDOC_It:

if (MDOC_BODY == p->type && MDOC_Bl == p->tok)

return(REWIND_NONE);

break;

* XXX Badly nested block handling still fails badly

* when one block is breaking two blocks of the same type.

* This is an incomplete and extremely ugly workaround,

* required to let the OpenBSD tree build.

case MDOC_Oo:

if (MDOC_Op == p->tok)

return(REWIND_MORE);

break;

case MDOC_Nm:

return(REWIND_NONE);

case MDOC_Nd:

/* FALLTHROUGH */

case MDOC_Ss:

if (MDOC_BODY == p->type && MDOC_Sh == p->tok)

return(REWIND_NONE);

/* FALLTHROUGH */

case MDOC_Sh:

if (MDOC_ROOT == p->parent->type)

return(REWIND_THIS);

if (MDOC_Nd == p->tok || MDOC_Ss == p->tok ||

MDOC_Sh == p->tok)

return(REWIND_MORE);

break;

default:

break;

}

* Default block rewinding rules.

* In particular, always skip block end markers,

* and let all blocks rewind Nm children.

* Do not warn again when closing a block,

* since closing the body already warned.

if (ENDBODY_NOT != p->end || MDOC_Nm == p->tok ||

MDOC_BLOCK == type || (MDOC_BLOCK == p->type &&

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

return(REWIND_MORE);

* By default, closing out full blocks

* forces closing of broken explicit blocks,

* while closing out partial blocks

* allows delayed rewinding by default.

return (&blk_full == mdoc_macros[tok].fp ?

REWIND_FORCE : REWIND_LATER);

}

static void

rew_elem(struct mdoc *mdoc, enum mdoct tok)

{

Line 463 rew_elem(struct mdoc *mdoc, enum mdoct tok)

Line 357 rew_elem(struct mdoc *mdoc, enum mdoct tok)

}

* We are trying to close a block identified by tok,

* We are trying to close the block *breaker,

* but the child block *broken is still open.

* Thus, postpone closing the tok block

* Thus, postpone closing the *breaker

* until the rew_sub call closing *broken.

* until the rew_pending() call closing *broken.

static int

static void

make_pending(struct mdoc_node *broken, enum mdoct tok,

make_pending(struct mdoc *mdoc, struct mdoc_node *breaker,

struct mdoc *mdoc, int line, int ppos)

struct mdoc_node *broken, int line, int ppos)

{

struct mdoc_node *breaker;

struct mdoc_node *n;

mandoc_vmsg(MANDOCERR_BLK_NEST, mdoc->parse, line, ppos,

"%s breaks %s", mdoc_macronames[breaker->tok],

mdoc_macronames[broken->tok]);

* Iterate backwards, searching for the block matching tok,

* If the *broken block (Z) is already broken by a block (B)

* that is, the block breaking the *broken block.

* contained in the breaker (A), make the breaker pending

* on that inner breaker (B). Graphically,

* breaker=[A! broken=n=[B!->A (old broken=)[Z->B B] A] Z]

* In these graphics, "->" indicates the "pending" pointer and

* "!" indicates the MDOC_BREAK flag. Each of the cases gets

* one additional pointer (B->A) and one additional flag (A!).

for (breaker = broken->parent; breaker; breaker = breaker->parent) {

for (n = broken->parent; ; n = n->parent)

* If the *broken block had already been broken before

if (n == broken->pending)

* and we encounter its breaker, make the tok block

broken = n;

* pending on the inner breaker.

else if (n == breaker)

* Graphically, "[A breaker=[B broken=[C->B B] tok=A] C]"

break;

* becomes "[A broken=[B [C->B B] tok=A] C]"

* and finally "[A [B->A [C->B B] A] C]".

if (breaker == broken->pending) {

broken = breaker;

continue;

}

if (REWIND_THIS != rew_dohalt(tok, MDOC_BLOCK, breaker))

continue;

* Found the breaker.

if (MDOC_BODY == broken->type)

broken = broken->parent;

* If another, outer breaker (X) is already pending on

* the *broken block (B), we must not clobber the link

* to the outer breaker, but make it pending on the new,

* now inner breaker (A). Graphically,

* [X! n=breaker=[A!->X broken=[B(->X)->A X] A] B].

if (broken->pending != NULL) {

n = breaker;

* Found the breaker.

* If the inner breaker (A) is already broken, too,

* If another, outer breaker is already pending on

* it cannot take on the outer breaker (X) but must

* the *broken block, we must not clobber the link

* hand it on to its own breakers (Y). Graphically,

* to the outer breaker, but make it pending on the

* new, now inner breaker.

* [X! n=[Y!->X breaker=[A!->Y Y] broken=[B(->X)->A X] A] B]

* Graphically, "[A breaker=[B broken=[C->A A] tok=B] C]"

* becomes "[A breaker=[B->A broken=[C A] tok=B] C]"

* and finally "[A [B->A [C->B A] B] C]".

if (broken->pending) {

struct mdoc_node *taker;

while (n->pending)

* If the breaker had also been broken before,

n = n->pending;

* it cannot take on the outer breaker itself,

n->pending = broken->pending;

* but must hand it on to its own breakers.

* Graphically, this is the following situation:

* "[A [B breaker=[C->B B] broken=[D->A A] tok=C] D]"

* "[A taker=[B->A breaker=[C->B B] [D->C A] C] D]"

taker = breaker;

while (taker->pending)

taker = taker->pending;

taker->pending = broken->pending;

}

broken->pending = breaker;

mandoc_vmsg(MANDOCERR_BLK_NEST, mdoc->parse, line, ppos,

"%s breaks %s", mdoc_macronames[tok],

mdoc_macronames[broken->tok]);

return(1);

}

* Found no matching block for tok.

* Now we have reduced the situation to the simplest case:

* Are you trying to close a block that is not open?

* breaker=[A! broken=[B->A A] B].

return(0);

}

static void

broken->pending = breaker;

rew_sub(enum mdoc_type t, struct mdoc *mdoc,

breaker->flags |= MDOC_BREAK;

enum mdoct tok, int line, int ppos)

if (breaker->body != NULL)

{

breaker->body->flags |= MDOC_BREAK;

struct mdoc_node *n;

n = mdoc->last;

while (n) {

switch (rew_dohalt(tok, t, n)) {

case REWIND_NONE:

return;

case REWIND_THIS:

n->lastline = line -

(mdoc->flags & MDOC_NEWLINE &&

! (mdoc_macros[tok].flags & MDOC_EXPLICIT));

break;

case REWIND_FORCE:

mandoc_vmsg(MANDOCERR_BLK_BROKEN, mdoc->parse,

line, ppos, "%s breaks %s",

mdoc_macronames[tok],

mdoc_macronames[n->tok]);

/* FALLTHROUGH */

case REWIND_MORE:

n->lastline = line -

(mdoc->flags & MDOC_NEWLINE ? 1 : 0);

n = n->parent;

continue;

case REWIND_LATER:

if (make_pending(n, tok, mdoc, line, ppos) ||

t != MDOC_BLOCK)

return;

/* FALLTHROUGH */

case REWIND_ERROR:

mandoc_msg(MANDOCERR_BLK_NOTOPEN,

mdoc->parse, line, ppos,

mdoc_macronames[tok]);

return;

}

break;

}

assert(n);

rew_last(mdoc, n);

* The current block extends an enclosing block.

* Now that the current block ends, close the enclosing block, too.

while ((n = n->pending) != NULL) {

rew_last(mdoc, n);

if (n->type == MDOC_HEAD)

mdoc_body_alloc(mdoc, n->line, n->pos, n->tok);

}

Line 633 dword(struct mdoc *mdoc, int line, int col, const char

Line 469 dword(struct mdoc *mdoc, int line, int col, const char

static void

append_delims(struct mdoc *mdoc, int line, int *pos, char *buf)

{

int la;

enum margserr ac;

char *p;

int la;

if (buf[*pos] == '\0')

return;

for (;;) {

la = *pos;

ac = mdoc_zargs(mdoc, line, pos, buf, &p);

if (mdoc_args(mdoc, line, pos, buf, MDOC_MAX, &p) == ARGS_EOLN)

if (ac == ARGS_EOLN)

break;

dword(mdoc, line, la, p, DELIM_MAX, 1);

Line 665 append_delims(struct mdoc *mdoc, int line, int *pos, c

Line 499 append_delims(struct mdoc *mdoc, int line, int *pos, c

}

* Parse one word.

* If it is a macro, call it and return 1.

* Otherwise, allocate it and return 0.

static int

macro_or_word(MACRO_PROT_ARGS, int parsed)

{

char *p;

enum mdoct ntok;

p = buf + ppos;

ntok = MDOC_MAX;

if (*p == '"')

p++;

else if (parsed && ! (mdoc->flags & MDOC_PHRASELIT))

ntok = lookup(mdoc, tok, line, ppos, p);

if (ntok == MDOC_MAX) {

dword(mdoc, line, ppos, p, DELIM_MAX, tok == MDOC_MAX ||

mdoc_macros[tok].flags & MDOC_JOIN);

return(0);

} else {

if (mdoc_macros[tok].fp == in_line_eoln)

rew_elem(mdoc, tok);

mdoc_macro(mdoc, ntok, line, ppos, pos, buf);

if (tok == MDOC_MAX)

append_delims(mdoc, line, pos, buf);

return(1);

}

* Close out block partial/full explicit.

static void

Line 672 blk_exp_close(MACRO_PROT_ARGS)

Line 538 blk_exp_close(MACRO_PROT_ARGS)

{

struct mdoc_node *body; /* Our own body. */

struct mdoc_node *endbody; /* Our own end marker. */

struct mdoc_node *itblk; /* An It block starting later. */

struct mdoc_node *later; /* A sub-block starting later. */

struct mdoc_node *n; /* For searching backwards. */

struct mdoc_node *n; /* Search back to our block. */

int j, lastarg, maxargs, flushed, nl;

int j, lastarg, maxargs, nl;

enum margserr ac;

enum mdoct atok, ntok;

char *p;

Line 700 blk_exp_close(MACRO_PROT_ARGS)

Line 567 blk_exp_close(MACRO_PROT_ARGS)

atok = rew_alt(tok);

body = endbody = later = NULL;

body = endbody = itblk = later = NULL;

for (n = mdoc->last; n; n = n->parent) {

if (n->flags & MDOC_VALID)

if (n->flags & (MDOC_VALID | MDOC_BREAK))

continue;

/* Remember the start of our own body. */

Line 715 blk_exp_close(MACRO_PROT_ARGS)

Line 582 blk_exp_close(MACRO_PROT_ARGS)

if (n->type != MDOC_BLOCK || n->tok == MDOC_Nm)

continue;

if (n->tok == MDOC_It) {

itblk = n;

continue;

}

if (atok == n->tok) {

assert(body);

Line 724 blk_exp_close(MACRO_PROT_ARGS)

Line 597 blk_exp_close(MACRO_PROT_ARGS)

* just proceed to closing out.

if (later == NULL)

if (later == NULL ||

(tok == MDOC_El && itblk == NULL))

break;

* When there is a pending sub block,

* When there is a pending sub block, postpone

* postpone closing out the current block

* closing out the current block until the

* until the rew_sub() closing out the sub-block.

* rew_pending() closing out the sub-block.

make_pending(later, tok, mdoc, line, ppos);

make_pending(mdoc, n, later, line, ppos);

if (tok == MDOC_El)

itblk->flags |= MDOC_BREAK;

* Mark the place where the formatting - but not

* the scope - of the current block ends.

mdoc_endbody_alloc(mdoc, line, ppos,

endbody = mdoc_endbody_alloc(mdoc, line, ppos,

atok, body, ENDBODY_SPACE);

* If a block closing macro taking arguments

* breaks another block, put the arguments

* into the end marker and remeber the

* into the end marker.

* end marker in order to close it out.

if (maxargs) {

if (maxargs)

endbody = mdoc->last;

mdoc->next = MDOC_NEXT_CHILD;

}

break;

}

Line 763 blk_exp_close(MACRO_PROT_ARGS)

Line 636 blk_exp_close(MACRO_PROT_ARGS)

* implicit ones, the first open implicit block.

if (later &&

if (later == NULL ||

mdoc_macros[later->tok].flags & MDOC_EXPLICIT)

! (mdoc_macros[later->tok].flags & MDOC_EXPLICIT))

continue;

if (n->tok != MDOC_It)

later = n;

}

rew_sub(MDOC_BODY, mdoc, tok, line, ppos);

if (body == NULL) {

mandoc_msg(MANDOCERR_BLK_NOTOPEN, mdoc->parse,

line, ppos, mdoc_macronames[tok]);

if (maxargs && endbody == NULL) {

* Stray .Ec without previous .Eo:

* Break the output line, keep the arguments.

mdoc_elem_alloc(mdoc, line, ppos, MDOC_br, NULL);

rew_elem(mdoc, MDOC_br);

}

} else if (endbody == NULL) {

rew_last(mdoc, body);

if (maxargs)

mdoc_tail_alloc(mdoc, line, ppos, atok);

}

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

if (buf[*pos] != '\0')

mandoc_vmsg(MANDOCERR_ARG_SKIP,

mdoc->parse, line, ppos,

"%s %s", mdoc_macronames[tok],

buf + *pos);

rew_sub(MDOC_BLOCK, mdoc, tok, line, ppos);

if (endbody == NULL && n != NULL)

rew_pending(mdoc, n);

return;

}

if (maxargs && endbody == NULL) {

if (endbody != NULL)

if (n == NULL) {

n = endbody;

* Stray .Ec without previous .Eo:

* Break the output line, ignore any arguments.

mdoc_elem_alloc(mdoc, line, ppos, MDOC_br, NULL);

rew_elem(mdoc, MDOC_br);

} else

mdoc_tail_alloc(mdoc, line, ppos, atok);

}

flushed = n == NULL;

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

lastarg = *pos;

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

if (j == maxargs && n != NULL) {

if (endbody == NULL)

rew_pending(mdoc, n);

rew_sub(MDOC_BLOCK, mdoc, tok, line, ppos);

n = NULL;

else

rew_last(mdoc, endbody);

flushed = 1;

}

ac = mdoc_args(mdoc, line, pos, buf, tok, &p);

if (ac == ARGS_PUNCT || ac == ARGS_EOLN)

break;

ntok = ac == ARGS_QWORD ? MDOC_MAX : lookup(tok, p);

ntok = ac == ARGS_QWORD ? MDOC_MAX :

lookup(mdoc, tok, line, lastarg, p);

if (ntok == MDOC_MAX) {

dword(mdoc, line, lastarg, p, DELIM_MAX,

Line 817 blk_exp_close(MACRO_PROT_ARGS)

Line 692 blk_exp_close(MACRO_PROT_ARGS)

continue;

}

if ( ! flushed) {

if (n != NULL) {

if (endbody == NULL)

rew_pending(mdoc, n);

rew_sub(MDOC_BLOCK, mdoc, tok, line, ppos);

n = NULL;

else

rew_last(mdoc, endbody);

flushed = 1;

}

mdoc->flags &= ~MDOC_NEWLINE;

mdoc_macro(mdoc, ntok, line, lastarg, pos, buf);

break;

}

if ( ! flushed) {

if (n != NULL)

if (endbody == NULL)

rew_pending(mdoc, n);

rew_sub(MDOC_BLOCK, mdoc, tok, line, ppos);

else

rew_last(mdoc, endbody);

}

if (nl)

append_delims(mdoc, line, pos, buf);

}

Line 904 in_line(MACRO_PROT_ARGS)

Line 772 in_line(MACRO_PROT_ARGS)

if (ac == ARGS_PUNCT) {

if (cnt == 0 && nc == 0)

if (cnt == 0 && (nc == 0 || tok == MDOC_An))

mdoc->flags |= MDOC_NODELIMC;

break;

}

ntok = (ac == ARGS_QWORD || (tok == MDOC_Fn && !cnt)) ?

MDOC_MAX : lookup(tok, p);

MDOC_MAX : lookup(mdoc, tok, line, la, p);

* In this case, we've located a submacro and must

Line 1025 in_line(MACRO_PROT_ARGS)

Line 893 in_line(MACRO_PROT_ARGS)

static void

blk_full(MACRO_PROT_ARGS)

{

int la, nl, nparsed;

int la, nl, parsed;

struct mdoc_arg *arg;

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

struct mdoc_node *blk; /* Our own or a broken block. */

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

struct mdoc_node *head; /* Our own head. */

struct mdoc_node *body; /* Our own body. */

struct mdoc_node *n;

enum mdoct ntok;

enum margserr ac, lac;

char *p;

nl = MDOC_NEWLINE & mdoc->flags;

/* Skip items outside lists. */

if (buf[*pos] == '\0' && (tok == MDOC_Sh || tok == MDOC_Ss)) {

mandoc_msg(MANDOCERR_MACRO_EMPTY, mdoc->parse,

line, ppos, mdoc_macronames[tok]);

return;

}

if (tok == MDOC_It) {

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

for (n = mdoc->last; n; n = n->parent)

if (n->tok == MDOC_Bl &&

/* Here, tok is one of Sh Ss Nm Nd It. */

! (n->flags & MDOC_VALID))

blk = NULL;

for (n = mdoc->last; n != NULL; n = n->parent) {

if (n->flags & (MDOC_VALID | MDOC_BREAK) ||

n->type != MDOC_BLOCK)

continue;

if (tok == MDOC_It && n->tok == MDOC_Bl) {

if (blk != NULL) {

mandoc_vmsg(MANDOCERR_BLK_BROKEN,

mdoc->parse, line, ppos,

"It breaks %s",

mdoc_macronames[blk->tok]);

rew_pending(mdoc, blk);

}

break;

if (n == NULL) {

}

if (mdoc_macros[n->tok].flags & MDOC_EXPLICIT) {

switch (tok) {

case MDOC_Sh:

/* FALLTHROUGH */

case MDOC_Ss:

mandoc_vmsg(MANDOCERR_BLK_BROKEN,

mdoc->parse, line, ppos,

"%s breaks %s",

mdoc_macronames[tok],

mdoc_macronames[n->tok]);

rew_pending(mdoc, n);

continue;

case MDOC_It:

/* Delay in case it's astray. */

blk = n;

continue;

default:

break;

}

break;

}

/* Here, n is one of Sh Ss Nm Nd It. */

if (tok != MDOC_Sh && (n->tok == MDOC_Sh ||

(tok != MDOC_Ss && (n->tok == MDOC_Ss ||

(tok != MDOC_It && n->tok == MDOC_It)))))

break;

/* Item breaking an explicit block. */

if (blk != NULL) {

mandoc_vmsg(MANDOCERR_BLK_BROKEN,

mdoc->parse, line, ppos,

"It breaks %s",

mdoc_macronames[blk->tok]);

rew_pending(mdoc, blk);

blk = NULL;

}

/* Close out prior implicit scopes. */

rew_last(mdoc, n);

}

/* Skip items outside lists. */

if (tok == MDOC_It && (n == NULL || n->tok != MDOC_Bl)) {

mandoc_vmsg(MANDOCERR_IT_STRAY, mdoc->parse,

line, ppos, "It %s", buf + *pos);

mdoc_elem_alloc(mdoc, line, ppos, MDOC_br, NULL);

Line 1052 blk_full(MACRO_PROT_ARGS)

Line 986 blk_full(MACRO_PROT_ARGS)

}

/* Close out prior implicit scope. */

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

rew_sub(MDOC_BODY, mdoc, tok, line, ppos);

rew_sub(MDOC_BLOCK, mdoc, tok, line, ppos);

}

* This routine accommodates implicitly- and explicitly-scoped

* macro openings. Implicit ones first close out prior scope

Line 1069 blk_full(MACRO_PROT_ARGS)

Line 996 blk_full(MACRO_PROT_ARGS)

mdoc_argv(mdoc, line, tok, &arg, pos, buf);

mdoc_block_alloc(mdoc, line, ppos, tok, arg);

blk = mdoc_block_alloc(mdoc, line, ppos, tok, arg);

head = body = NULL;

Line 1077 blk_full(MACRO_PROT_ARGS)

Line 1004 blk_full(MACRO_PROT_ARGS)

* parsed, even though `It' macros in general are parsed.

nparsed = tok == MDOC_It &&

parsed = tok != MDOC_It ||

mdoc->last->parent->tok == MDOC_Bl &&

mdoc->last->parent->tok != MDOC_Bl ||

mdoc->last->parent->norm->Bl.type == LIST_diag;

mdoc->last->parent->norm->Bl.type != LIST_diag;

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

Line 1088 blk_full(MACRO_PROT_ARGS)

Line 1015 blk_full(MACRO_PROT_ARGS)

if (tok == MDOC_Nd) {

head = mdoc_head_alloc(mdoc, line, ppos, tok);

rew_sub(MDOC_HEAD, mdoc, tok, line, ppos);

rew_last(mdoc, head);

body = mdoc_body_alloc(mdoc, line, ppos, tok);

}

Line 1100 blk_full(MACRO_PROT_ARGS)

Line 1027 blk_full(MACRO_PROT_ARGS)

la = *pos;

lac = ac;

ac = mdoc_args(mdoc, line, pos, buf, tok, &p);

if (ac == ARGS_PUNCT)

break;

if (ac == ARGS_EOLN) {

if (lac != ARGS_PPHRASE && lac != ARGS_PHRASE)

break;

Line 1112 blk_full(MACRO_PROT_ARGS)

Line 1037 blk_full(MACRO_PROT_ARGS)

* reopen our scope if the last parse was a

* phrase or partial phrase.

rew_sub(MDOC_BODY, mdoc, tok, line, ppos);

if (body != NULL)

rew_last(mdoc, body);

body = mdoc_body_alloc(mdoc, line, ppos, tok);

break;

}

if (tok == MDOC_Bd || tok == MDOC_Bk) {

mandoc_vmsg(MANDOCERR_ARG_EXCESS,

mdoc->parse, line, la, "%s ... %s",

mdoc_macronames[tok], buf + la);

break;

}

if (tok == MDOC_Rs) {

mandoc_vmsg(MANDOCERR_ARG_SKIP, mdoc->parse,

line, la, "Rs %s", buf + la);

break;

}

if (ac == ARGS_PUNCT)

break;

* Emit leading punctuation (i.e., punctuation before

Line 1146 blk_full(MACRO_PROT_ARGS)

Line 1085 blk_full(MACRO_PROT_ARGS)

* head; if we have, rewind that instead.

rew_sub(body ? MDOC_BODY : MDOC_HEAD,

rew_last(mdoc, body == NULL ? head : body);

mdoc, tok, line, ppos);

body = mdoc_body_alloc(mdoc, line, ppos, tok);

Line 1160 blk_full(MACRO_PROT_ARGS)

Line 1098 blk_full(MACRO_PROT_ARGS)

mdoc->flags |= MDOC_PPHRASE;

if (ac == ARGS_PEND && lac == ARGS_PPHRASE)

mdoc->flags |= MDOC_PPHRASE;

phrase(mdoc, line, la, buf);

parse_rest(mdoc, MDOC_MAX, line, &la, buf);

mdoc->flags &= ~MDOC_PPHRASE;

continue;

}

ntok = nparsed || ac == ARGS_QWORD ?

if (macro_or_word(mdoc, tok, line, la, pos, buf, parsed))

MDOC_MAX : lookup(tok, p);

if (ntok != MDOC_MAX) {

mdoc_macro(mdoc, ntok, line, la, pos, buf);

break;

}

dword(mdoc, line, la, p, DELIM_MAX,

MDOC_JOIN & mdoc_macros[tok].flags);

}

if (blk->flags & MDOC_VALID)

return;

if (head == NULL)

head = mdoc_head_alloc(mdoc, line, ppos, tok);

if (nl)

if (nl && tok != MDOC_Bd && tok != MDOC_Bl && tok != MDOC_Rs)

append_delims(mdoc, line, pos, buf);

if (body != NULL)

goto out;

Line 1186 blk_full(MACRO_PROT_ARGS)

Line 1119 blk_full(MACRO_PROT_ARGS)

* If there is an open (i.e., unvalidated) sub-block requiring

* explicit close-out, postpone switching the current block from

* head to body until the rew_sub() call closing out that

* head to body until the rew_pending() call closing out that

* sub-block.

for (n = mdoc->last; n && n != head; n = n->parent) {

Line 1200 blk_full(MACRO_PROT_ARGS)

Line 1133 blk_full(MACRO_PROT_ARGS)

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

rew_sub(MDOC_HEAD, mdoc, tok, line, ppos);

rew_last(mdoc, head);

mdoc_body_alloc(mdoc, line, ppos, tok);

body = mdoc_body_alloc(mdoc, line, ppos, tok);

out:

if (mdoc->flags & MDOC_FREECOL) {

rew_sub(MDOC_BODY, mdoc, tok, line, ppos);

rew_last(mdoc, body);

rew_sub(MDOC_BLOCK, mdoc, tok, line, ppos);

rew_last(mdoc, blk);

mdoc->flags &= ~MDOC_FREECOL;

}

Line 1214 static void

Line 1147 static void

blk_part_imp(MACRO_PROT_ARGS)

{

int la, nl;

enum mdoct ntok;

enum margserr ac;

char *p;

struct mdoc_node *blk; /* saved block context */

Line 1233 blk_part_imp(MACRO_PROT_ARGS)

Line 1165 blk_part_imp(MACRO_PROT_ARGS)

blk = mdoc_block_alloc(mdoc, line, ppos, tok, NULL);

mdoc_head_alloc(mdoc, line, ppos, tok);

rew_last(mdoc, mdoc_head_alloc(mdoc, line, ppos, tok));

rew_sub(MDOC_HEAD, mdoc, tok, line, ppos);

* Open the body scope "on-demand", that is, after we've

Line 1257 blk_part_imp(MACRO_PROT_ARGS)

Line 1188 blk_part_imp(MACRO_PROT_ARGS)

if (body == NULL)

body = mdoc_body_alloc(mdoc, line, ppos, tok);

ntok = ac == ARGS_QWORD ? MDOC_MAX : lookup(tok, p);

if (macro_or_word(mdoc, tok, line, la, pos, buf, 1))

if (ntok != MDOC_MAX) {

mdoc_macro(mdoc, ntok, line, la, pos, buf);

break;

}

dword(mdoc, line, la, p, DELIM_MAX,

MDOC_JOIN & mdoc_macros[tok].flags);

}

if (body == NULL)

body = mdoc_body_alloc(mdoc, line, ppos, tok);

* If there is an open sub-block requiring explicit close-out,

* postpone closing out the current block

* postpone closing out the current block until the

* until the rew_sub() call closing out the sub-block.

* rew_pending() call closing out the sub-block.

for (n = mdoc->last; n && n != body && n != blk->parent;

Line 1280 blk_part_imp(MACRO_PROT_ARGS)

Line 1205 blk_part_imp(MACRO_PROT_ARGS)

if (n->type == MDOC_BLOCK &&

mdoc_macros[n->tok].flags & MDOC_EXPLICIT &&

! (n->flags & MDOC_VALID)) {

make_pending(n, tok, mdoc, line, ppos);

make_pending(mdoc, blk, n, line, ppos);

mdoc_endbody_alloc(mdoc, line, ppos,

tok, body, ENDBODY_NOSPACE);

return;

}

assert(n == body);

rew_sub(MDOC_BODY, mdoc, tok, line, ppos);

rew_last(mdoc, body);

if (nl)

append_delims(mdoc, line, pos, buf);

rew_sub(MDOC_BLOCK, mdoc, tok, line, ppos);

rew_pending(mdoc, blk);

/* Move trailing .Ns out of scope. */

Line 1306 blk_part_exp(MACRO_PROT_ARGS)

Line 1231 blk_part_exp(MACRO_PROT_ARGS)

int la, nl;

enum margserr ac;

struct mdoc_node *head; /* keep track of head */

struct mdoc_node *body; /* keep track of body */

char *p;

enum mdoct ntok;

nl = MDOC_NEWLINE & mdoc->flags;

Line 1319 blk_part_exp(MACRO_PROT_ARGS)

Line 1242 blk_part_exp(MACRO_PROT_ARGS)

mdoc_block_alloc(mdoc, line, ppos, tok, NULL);

for (head = body = NULL; ; ) {

head = NULL;

for (;;) {

la = *pos;

ac = mdoc_args(mdoc, line, pos, buf, tok, &p);

if (ac == ARGS_PUNCT || ac == ARGS_EOLN)

Line 1329 blk_part_exp(MACRO_PROT_ARGS)

Line 1253 blk_part_exp(MACRO_PROT_ARGS)

if (head == NULL && ac != ARGS_QWORD &&

mdoc_isdelim(p) == DELIM_OPEN) {

assert(NULL == body);

dword(mdoc, line, la, p, DELIM_OPEN, 0);

continue;

}

if (head == NULL) {

assert(body == NULL);

head = mdoc_head_alloc(mdoc, line, ppos, tok);

}

if (tok == MDOC_Eo) /* Not parsed. */

* `Eo' gobbles any data into the head, but most other

* macros just immediately close out and begin the body.

if (body == NULL) {

assert(head);

/* No check whether it's a macro! */

if (tok == MDOC_Eo)

dword(mdoc, line, la, p, DELIM_MAX, 0);

rew_sub(MDOC_HEAD, mdoc, tok, line, ppos);

rew_last(mdoc, head);

body = mdoc_body_alloc(mdoc, line, ppos, tok);

mdoc_body_alloc(mdoc, line, ppos, tok);

if (tok == MDOC_Eo)

continue;

}

assert(head != NULL && body != NULL);

ntok = ac == ARGS_QWORD ? MDOC_MAX : lookup(tok, p);

if (macro_or_word(mdoc, tok, line, la, pos, buf, 1))

if (ntok != MDOC_MAX) {

mdoc_macro(mdoc, ntok, line, la, pos, buf);

break;

}

dword(mdoc, line, la, p, DELIM_MAX,

MDOC_JOIN & mdoc_macros[tok].flags);

}

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

if (head == NULL)

if (head == NULL) {

mdoc_head_alloc(mdoc, line, ppos, tok);

rew_last(mdoc, mdoc_head_alloc(mdoc, line, ppos, tok));

if (body == NULL) {

rew_sub(MDOC_HEAD, mdoc, tok, line, ppos);

mdoc_body_alloc(mdoc, line, ppos, tok);

}

if (nl)

Line 1387 in_line_argn(MACRO_PROT_ARGS)

Line 1290 in_line_argn(MACRO_PROT_ARGS)

char *p;

enum mdoct ntok;

nl = MDOC_NEWLINE & mdoc->flags;

nl = mdoc->flags & MDOC_NEWLINE;

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

Line 1419 in_line_argn(MACRO_PROT_ARGS)

Line 1322 in_line_argn(MACRO_PROT_ARGS)

mdoc_argv(mdoc, line, tok, &arg, pos, buf);

for (flushed = j = 0; ; ) {

p = NULL;

flushed = j = 0;

for (;;) {

la = *pos;

ac = mdoc_args(mdoc, line, pos, buf, tok, &p);

if (ac == ARGS_PUNCT || ac == ARGS_EOLN)

if (ac == ARGS_PUNCT || ac == ARGS_EOLN) {

if (j < 2 && tok == MDOC_Pf)

mandoc_vmsg(MANDOCERR_PF_SKIP,

mdoc->parse, line, ppos, "Pf %s",

p == NULL ? "at eol" : p);

break;

}

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

ac != ARGS_QWORD && j == 0 &&

Line 1438 in_line_argn(MACRO_PROT_ARGS)

Line 1348 in_line_argn(MACRO_PROT_ARGS)

flushed = 1;

}

ntok = ac == ARGS_QWORD ? MDOC_MAX : lookup(tok, p);

ntok = (ac == ARGS_QWORD || (tok == MDOC_Pf && j == 0)) ?

MDOC_MAX : lookup(mdoc, tok, line, la, p);

if (ntok != MDOC_MAX) {

if ( ! flushed)

Line 1461 in_line_argn(MACRO_PROT_ARGS)

Line 1372 in_line_argn(MACRO_PROT_ARGS)

j++;

}

if (j == 0)

if (j == 0) {

if (tok == MDOC_In || tok == MDOC_St || tok == MDOC_Xr) {

mandoc_msg(MANDOCERR_MACRO_EMPTY, mdoc->parse,

line, ppos, mdoc_macronames[tok]);

return;

}

mdoc_elem_alloc(mdoc, line, ppos, tok, arg);

if (ac == ARGS_PUNCT && tok == MDOC_Pf)

append_delims(mdoc, line, pos, buf);

}

if ( ! flushed)

rew_elem(mdoc, tok);

if (nl)

Line 1472 in_line_argn(MACRO_PROT_ARGS)

Line 1391 in_line_argn(MACRO_PROT_ARGS)

static void

in_line_eoln(MACRO_PROT_ARGS)

{

int la;

struct mdoc_node *n;

enum margserr ac;

struct mdoc_arg *arg;

char *p;

enum mdoct ntok;

assert( ! (MDOC_PARSED & mdoc_macros[tok].flags));

if ((tok == MDOC_Pp || tok == MDOC_Lp) &&

! (mdoc->flags & MDOC_SYNOPSIS)) {

n = mdoc->last;

if (mdoc->next == MDOC_NEXT_SIBLING)

n = n->parent;

if (n->tok == MDOC_Nm)

rew_last(mdoc, mdoc->last->parent);

}

if (tok == MDOC_Pp)

if (buf[*pos] == '\0' && tok == MDOC_Fd) {

rew_sub(MDOC_BLOCK, mdoc, MDOC_Nm, line, ppos);

mandoc_msg(MANDOCERR_MACRO_EMPTY, mdoc->parse,

line, ppos, "Fd");

return;

}

mdoc_argv(mdoc, line, tok, &arg, pos, buf);

mdoc_elem_alloc(mdoc, line, ppos, tok, arg);

if (parse_rest(mdoc, tok, line, pos, buf))

return;

rew_elem(mdoc, tok);

}

/* Parse argument terms. */

* The simplest argument parser available: Parse the remaining

* words until the end of the phrase or line and return 0

* or until the next macro, call that macro, and return 1.

static int

parse_rest(struct mdoc *mdoc, enum mdoct tok, int line, int *pos, char *buf)

{

int la;

for (;;) {

la = *pos;

ac = mdoc_args(mdoc, line, pos, buf, tok, &p);

if (mdoc_args(mdoc, line, pos, buf, tok, NULL) == ARGS_EOLN)

if (ac == ARGS_EOLN)

return(0);

break;

if (macro_or_word(mdoc, tok, line, la, pos, buf, 1))

return(1);

ntok = ac == ARGS_QWORD ? MDOC_MAX : lookup(tok, p);

if (ntok != MDOC_MAX) {

rew_elem(mdoc, tok);

mdoc_macro(mdoc, ntok, line, la, pos, buf);

return;

}

dword(mdoc, line, la, p, DELIM_MAX,

MDOC_JOIN & mdoc_macros[tok].flags);

}

/* Close out (no delimiters). */

rew_elem(mdoc, tok);

}

static void

Line 1530 ctx_synopsis(MACRO_PROT_ARGS)

Line 1455 ctx_synopsis(MACRO_PROT_ARGS)

* macro is encountered.

static void

phrase(struct mdoc *mdoc, int line, int ppos, char *buf)

phrase_ta(MACRO_PROT_ARGS)

{

int la, pos;

struct mdoc_node *body, *n;

enum margserr ac;

enum mdoct ntok;

char *p;

for (pos = ppos; ; ) {

/* Make sure we are in a column list or ignore this macro. */

la = pos;

ac = mdoc_zargs(mdoc, line, &pos, buf, &p);

body = NULL;

if (ac == ARGS_EOLN)

for (n = mdoc->last; n != NULL; n = n->parent) {

if (n->flags & (MDOC_VALID | MDOC_BREAK))

continue;

if (n->tok == MDOC_It && n->type == MDOC_BODY)

body = n;

if (n->tok == MDOC_Bl)

break;

ntok = ac == ARGS_QWORD ? MDOC_MAX : lookup_raw(p);

if (ntok != MDOC_MAX) {

mdoc_macro(mdoc, ntok, line, la, &pos, buf);

append_delims(mdoc, line, &pos, buf);

return;

}

dword(mdoc, line, la, p, DELIM_MAX, 1);

}

static void

phrase_ta(MACRO_PROT_ARGS)

{

struct mdoc_node *n;

int la;

enum mdoct ntok;

enum margserr ac;

char *p;

/* Make sure we are in a column list or ignore this macro. */

n = mdoc->last;

while (n != NULL && n->tok != MDOC_Bl)

n = n->parent;

if (n == NULL || n->norm->Bl.type != LIST_column) {

mandoc_msg(MANDOCERR_TA_STRAY, mdoc->parse,

line, ppos, "Ta");

Line 1577 phrase_ta(MACRO_PROT_ARGS)

Line 1479 phrase_ta(MACRO_PROT_ARGS)

/* Advance to the next column. */

rew_sub(MDOC_BODY, mdoc, MDOC_It, line, ppos);

rew_last(mdoc, body);

mdoc_body_alloc(mdoc, line, ppos, MDOC_It);

parse_rest(mdoc, MDOC_MAX, line, pos, buf);

for (;;) {

la = *pos;

ac = mdoc_zargs(mdoc, line, pos, buf, &p);

if (ac == ARGS_EOLN)

break;

ntok = ac == ARGS_QWORD ? MDOC_MAX : lookup_raw(p);

if (ntok != MDOC_MAX) {

mdoc_macro(mdoc, ntok, line, la, pos, buf);

append_delims(mdoc, line, pos, buf);

return;

}

dword(mdoc, line, la, p, DELIM_MAX,

MDOC_JOIN & mdoc_macros[tok].flags);

}

CVSweb