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.159 and 1.194

version 1.159, 2014/12/18 20:58:32

version 1.194, 2015/04/21 16:14:25

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

* copyright notice and this permission notice appear in all copies.

* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES

* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHORS DISCLAIM ALL WARRANTIES

* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF

* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR

* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR

* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES

* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN

* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF

Line 26

#include <string.h>

#include <time.h>

#include "mdoc.h"

#include "mandoc.h"

#include "libmdoc.h"

#include "roff.h"

#include "mdoc.h"

#include "libmandoc.h"

#include "roff_int.h"

#include "libmdoc.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 50 static void in_line_argn(MACRO_PROT_ARGS);

Line 43 static void in_line_argn(MACRO_PROT_ARGS);

static void in_line(MACRO_PROT_ARGS);

static void phrase_ta(MACRO_PROT_ARGS);

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

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

enum mdelim, int);

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

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

enum mdelim, int);

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

static int find_pending(struct roff_man *, int, int, int,

int, int, const char *);

struct roff_node *);

static int lookup(struct roff_man *, int, int, int, const char *);

static int macro_or_word(MACRO_PROT_ARGS, int);

static int make_pending(struct mdoc_node *, enum mdoct,

static int parse_rest(struct roff_man *, int, int, int *, char *);

struct mdoc *, int, int);

static int rew_alt(int);

static int parse_rest(struct mdoc *, enum mdoct,

static void rew_elem(struct roff_man *, int);

int, int *, char *);

static void rew_last(struct roff_man *, const struct roff_node *);

static enum mdoct rew_alt(enum mdoct);

static void rew_pending(struct roff_man *,

static enum rew rew_dohalt(enum mdoct, enum mdoc_type,

const struct roff_node *);

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 *,

enum mdoct, int, int);

const struct mdoc_macro __mdoc_macros[MDOC_MAX] = {

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

Line 221 const struct mdoc_macro * const mdoc_macros = __mdoc_m

Line 210 const struct mdoc_macro * const mdoc_macros = __mdoc_m

* are errors.

void

mdoc_macroend(struct mdoc *mdoc)

mdoc_macroend(struct roff_man *mdoc)

{

struct mdoc_node *n;

struct roff_node *n;

/* Scan for open explicit scopes. */

Line 231 mdoc_macroend(struct mdoc *mdoc)

Line 220 mdoc_macroend(struct mdoc *mdoc)

mdoc->last->parent : mdoc->last;

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

if (n->type == MDOC_BLOCK &&

if (n->type == ROFFT_BLOCK &&

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

mandoc_msg(MANDOCERR_BLK_NOEND, mdoc->parse,

n->line, n->pos, mdoc_macronames[n->tok]);

Line 243 mdoc_macroend(struct mdoc *mdoc)

Line 232 mdoc_macroend(struct mdoc *mdoc)

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

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

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

static enum mdoct

static int

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

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

{

enum mdoct res;

int res;

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

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

res = mdoc_hash_find(p);

if (res != MDOC_MAX) {

if (res != TOKEN_NONE) {

if (mdoc_macros[res].flags & MDOC_CALLABLE)

return(res);

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

Line 260 lookup(struct mdoc *mdoc, enum mdoct from, int line, i

Line 249 lookup(struct mdoc *mdoc, enum mdoct from, int line, i

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

}

return(MDOC_MAX);

return(TOKEN_NONE);

}

* Rewind up to and including a specific node.

static void

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

rew_last(struct roff_man *mdoc, const struct roff_node *to)

{

struct mdoc_node *n, *np;

struct roff_node *n, *np;

assert(to);

if (to->flags & MDOC_VALID)

mdoc->next = MDOC_NEXT_SIBLING;

return;

mdoc->next = ROFF_NEXT_SIBLING;

while (mdoc->last != to) {

* Save the parent here, because we may delete the

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

Line 282 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 roff_man *mdoc, const struct roff_node *n)

{

for (;;) {

rew_last(mdoc, n);

if (mdoc->last == n) {

switch (n->type) {

case ROFFT_HEAD:

roff_body_alloc(mdoc, n->line, n->pos,

n->tok);

return;

case ROFFT_BLOCK:

break;

default:

return;

}

if ( ! (n->flags & MDOC_BROKEN))

return;

} else

n = mdoc->last;

for (;;) {

if ((n = n->parent) == NULL)

return;

if (n->type == ROFFT_BLOCK ||

n->type == ROFFT_HEAD) {

if (n->flags & MDOC_ENDED)

break;

else

return;

}

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

* Otherwise, return the macro itself.

static enum mdoct

static int

rew_alt(enum mdoct tok)

rew_alt(int tok)

{

switch (tok) {

case MDOC_Ac:

Line 333 rew_alt(enum mdoct tok)

Line 368 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)

rew_elem(struct roff_man *mdoc, int tok)

{

struct mdoc_node *n;

struct roff_node *n;

n = mdoc->last;

if (MDOC_ELEM != n->type)

if (n->type != ROFFT_ELEM)

n = n->parent;

assert(MDOC_ELEM == n->type);

assert(n->type == ROFFT_ELEM);

assert(tok == n->tok);

rew_last(mdoc, n);

}

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

* If there is an open sub-block of the target requiring

* but the child block *broken is still open.

* explicit close-out, postpone closing out the target until

* Thus, postpone closing the tok block

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

* until the rew_sub call closing *broken.

static int

make_pending(struct mdoc_node *broken, enum mdoct tok,

find_pending(struct roff_man *mdoc, int tok, int line, int ppos,

struct mdoc *mdoc, int line, int ppos)

struct roff_node *target)

{

struct mdoc_node *breaker;

struct roff_node *n;

int irc;

irc = 0;

* Iterate backwards, searching for the block matching tok,

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

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

if (n->flags & MDOC_ENDED) {

if ( ! (n->flags & MDOC_VALID))

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

n->flags |= MDOC_BROKEN;

* If the *broken block (Z) is already broken and we

* encounter its breaker (B), make the tok block (A)

* pending on that inner breaker (B).

* Graphically, [A breaker=[B! broken=[Z->B B] tok=A] Z]

* becomes breaker=[A broken=[B! [Z->B B] tok=A] Z]

* and finally [A! [B!->A [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!).

if (breaker == broken->pending) {

broken = breaker;

continue;

}

if (n->type == ROFFT_BLOCK &&

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

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

continue;

irc = 1;

if (MDOC_BODY == broken->type)

n->flags = MDOC_BROKEN;

broken = broken->parent;

if (target->type == ROFFT_HEAD)

target->flags = MDOC_ENDED;

else if ( ! (target->flags & MDOC_ENDED)) {

* Found the breaker.

mandoc_vmsg(MANDOCERR_BLK_NEST,

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

mdoc->parse, line, ppos,

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

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

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

mdoc_macronames[n->tok]);

* new, now inner breaker (A).

mdoc_endbody_alloc(mdoc, line, ppos,

* Graphically, [X! breaker=[A broken=[B->X X] tok=A] B]

tok, target, ENDBODY_NOSPACE);

* becomes [X! breaker=[A->X broken=[B X] tok=A] B]

}

* and finally [X! [A!->X [B->A X] A] B].

if (broken->pending) {

struct mdoc_node *taker;

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

* too, it cannot take on the outer breaker (X)

* but must hand it on to its own breakers (Y):

* [X! [Y! breaker=[A->Y Y] broken=[B->X X] tok=A] B]

* [X! take=[Y!->X brea=[A->Y Y] brok=[B X] tok=A] B]

* and finally [X! [Y!->X [A!->Y Y] [B->A X] A] B].

taker = breaker;

while (taker->pending)

taker = taker->pending;

taker->pending = broken->pending;

}

* Now we have reduced the situation to the simplest

* case, which is just breaker=[A broken=[B tok=A] B]

* and becomes [A! [B->A A] B].

broken->pending = breaker;

breaker->flags |= MDOC_BREAK;

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

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

mdoc_macronames[broken->tok]);

return(1);

}

return(irc);

* Found no matching block for tok.

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

return(0);

}

static void

rew_sub(enum mdoc_type t, struct mdoc *mdoc,

enum mdoct tok, int line, int ppos)

{

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);

}

* Allocate a word and check whether it's punctuation or not.

* Punctuation consists of those tokens found in mdoc_isdelim().

static void

dword(struct mdoc *mdoc, int line, int col, const char *p,

dword(struct roff_man *mdoc, int line, int col, const char *p,

enum mdelim d, int may_append)

{

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

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

if (may_append &&

! (mdoc->flags & (MDOC_SYNOPSIS | MDOC_KEEP | MDOC_SMOFF)) &&

d == DELIM_NONE && mdoc->last->type == MDOC_TEXT &&

d == DELIM_NONE && mdoc->last->type == ROFFT_TEXT &&

mdoc_isdelim(mdoc->last->string) == DELIM_NONE) {

mdoc_word_append(mdoc, p);

roff_word_append(mdoc, p);

return;

}

mdoc_word_alloc(mdoc, line, col, p);

roff_word_alloc(mdoc, line, col, p);

* If the word consists of a bare delimiter,

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

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

}

static void

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

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

{

char *p;

int la;

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

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

for (;;) {

la = *pos;

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

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

ARGS_EOLN)

break;

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

Line 679 static int

Line 499 static int

macro_or_word(MACRO_PROT_ARGS, int parsed)

{

char *p;

enum mdoct ntok;

int ntok;

p = buf + ppos;

ntok = MDOC_MAX;

ntok = TOKEN_NONE;

if (*p == '"')

p++;

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

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

if (ntok == MDOC_MAX) {

if (ntok == TOKEN_NONE) {

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

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

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)

if (tok == TOKEN_NONE)

append_delims(mdoc, line, pos, buf);

return(1);

}

Line 708 macro_or_word(MACRO_PROT_ARGS, int parsed)

Line 528 macro_or_word(MACRO_PROT_ARGS, int parsed)

static void

blk_exp_close(MACRO_PROT_ARGS)

{

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

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

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

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

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

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

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

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

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

struct roff_node *target; /* For find_pending(). */

int j, lastarg, maxargs, flushed, nl;

int j, lastarg, maxargs, nl, pending;

enum margserr ac;

enum mdoct atok, ntok;

int atok, ntok;

char *p;

nl = MDOC_NEWLINE & mdoc->flags;

Line 738 blk_exp_close(MACRO_PROT_ARGS)

Line 560 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_ENDED) {

if ( ! (n->flags & MDOC_VALID))

n->flags |= MDOC_BROKEN;

continue;

}

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

if (n->type == MDOC_BODY && atok == n->tok) {

if (n->type == ROFFT_BODY && atok == n->tok) {

if (n->end == ENDBODY_NOT)

body = n;

continue;

}

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

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

continue;

if (n->tok == MDOC_It) {

itblk = n;

continue;

}

if (atok == n->tok) {

assert(body);

Line 762 blk_exp_close(MACRO_PROT_ARGS)

Line 593 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);

* Mark the place where the formatting - but not

* the scope - of the current block ends.

mdoc_endbody_alloc(mdoc, line, ppos,

mandoc_vmsg(MANDOCERR_BLK_NEST, mdoc->parse,

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

mdoc_macronames[atok],

mdoc_macronames[later->tok]);

endbody = mdoc_endbody_alloc(mdoc, line, ppos,

atok, body, ENDBODY_SPACE);

if (tok == MDOC_El)

itblk->flags |= MDOC_ENDED | MDOC_BROKEN;

* 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 = ROFF_NEXT_CHILD;

mdoc->next = MDOC_NEXT_CHILD;

}

break;

}

/* Explicit blocks close out description lines. */

* When finding an open sub block, remember the last

* open explicit block, or, in case there are only

* implicit ones, the first open implicit block.

if (later &&

if (n->tok == MDOC_Nd) {

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

rew_last(mdoc, n);

continue;

if (n->tok != MDOC_It)

}

/* Breaking an open sub block. */

n->flags |= MDOC_BROKEN;

if (later == NULL)

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.

roff_elem_alloc(mdoc, line, ppos, MDOC_br);

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_last(mdoc, n);

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

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 :

ntok = ac == ARGS_QWORD ? TOKEN_NONE :

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

if (ntok == MDOC_MAX) {

if (ntok == TOKEN_NONE) {

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

MDOC_JOIN & mdoc_macros[tok].flags);

continue;

}

if ( ! flushed) {

if (n != NULL)

if (endbody == NULL)

rew_last(mdoc, n);

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

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)

if (n != mdoc->last && n->flags & MDOC_BROKEN) {

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

target = n;

else

rew_last(mdoc, endbody);

target = target->parent;

while ( ! (target->flags & MDOC_ENDED));

pending = find_pending(mdoc, ntok, line, ppos,

target);

} else

pending = 0;

if ( ! pending)

rew_pending(mdoc, n);

}

if (nl)

append_delims(mdoc, line, pos, buf);

Line 882 static void

Line 718 static void

in_line(MACRO_PROT_ARGS)

{

int la, scope, cnt, firstarg, mayopen, nc, nl;

enum mdoct ntok;

int ntok;

enum margserr ac;

enum mdelim d;

struct mdoc_arg *arg;

Line 943 in_line(MACRO_PROT_ARGS)

Line 779 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(mdoc, tok, line, la, p);

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

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

Line 958 in_line(MACRO_PROT_ARGS)

Line 794 in_line(MACRO_PROT_ARGS)

* or raise a warning.

if (ntok != MDOC_MAX) {

if (ntok != TOKEN_NONE) {

if (scope)

rew_elem(mdoc, tok);

if (nc && ! cnt) {

Line 1066 blk_full(MACRO_PROT_ARGS)

Line 902 blk_full(MACRO_PROT_ARGS)

{

int la, nl, parsed;

struct mdoc_arg *arg;

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

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

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

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

struct mdoc_node *n;

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

struct roff_node *n;

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 && n->type == MDOC_BLOCK &&

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

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

blk = NULL;

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

if (n->flags & MDOC_ENDED) {

if ( ! (n->flags & MDOC_VALID))

n->flags |= MDOC_BROKEN;

continue;

}

if (n->type != ROFFT_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);

n = mdoc->last;

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);

roff_elem_alloc(mdoc, line, ppos, MDOC_br);

rew_elem(mdoc, MDOC_br);

return;

}

/* 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 1107 blk_full(MACRO_PROT_ARGS)

Line 1009 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 1125 blk_full(MACRO_PROT_ARGS)

Line 1027 blk_full(MACRO_PROT_ARGS)

if (tok == MDOC_Nd) {

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

head = roff_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);

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

}

if (tok == MDOC_Bk)

Line 1138 blk_full(MACRO_PROT_ARGS)

Line 1040 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 1150 blk_full(MACRO_PROT_ARGS)

Line 1050 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)

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

rew_last(mdoc, body);

body = roff_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

* the MDOC_HEAD) for non-phrase types.

* the ROFFT_HEAD) for non-phrase types.

if (head == NULL &&

Line 1173 blk_full(MACRO_PROT_ARGS)

Line 1087 blk_full(MACRO_PROT_ARGS)

/* Open a head if one hasn't been opened. */

if (head == NULL)

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

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

if (ac == ARGS_PHRASE ||

ac == ARGS_PEND ||

Line 1184 blk_full(MACRO_PROT_ARGS)

Line 1098 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 = roff_body_alloc(mdoc, line, ppos, tok);

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

* Process phrases: set whether we're in a

Line 1198 blk_full(MACRO_PROT_ARGS)

Line 1111 blk_full(MACRO_PROT_ARGS)

mdoc->flags |= MDOC_PPHRASE;

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

mdoc->flags |= MDOC_PPHRASE;

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

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

mdoc->flags &= ~MDOC_PPHRASE;

continue;

}

Line 1207 blk_full(MACRO_PROT_ARGS)

Line 1120 blk_full(MACRO_PROT_ARGS)

break;

}

if (blk->flags & MDOC_VALID)

return;

if (head == NULL)

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

head = roff_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;

if (find_pending(mdoc, tok, line, ppos, head))

return;

* 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

* sub-block.

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

if (n->type == MDOC_BLOCK &&

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

! (n->flags & MDOC_VALID)) {

n->pending = head;

return;

}

/* 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 = roff_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 1247 blk_part_imp(MACRO_PROT_ARGS)

Line 1149 blk_part_imp(MACRO_PROT_ARGS)

int la, nl;

enum margserr ac;

char *p;

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

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

struct mdoc_node *body; /* saved body context */

struct roff_node *body; /* saved body context */

struct mdoc_node *n;

struct roff_node *n;

nl = MDOC_NEWLINE & mdoc->flags;

Line 1263 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, roff_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 1285 blk_part_imp(MACRO_PROT_ARGS)

Line 1186 blk_part_imp(MACRO_PROT_ARGS)

}

if (body == NULL)

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

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

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

break;

}

if (body == NULL)

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

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

if (find_pending(mdoc, tok, line, ppos, body))

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

return;

* postpone closing out the current block

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

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

rew_last(mdoc, body);

n = n->parent) {

if (n->type == MDOC_BLOCK &&

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

! (n->flags & MDOC_VALID)) {

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

mdoc_endbody_alloc(mdoc, line, ppos,

tok, body, ENDBODY_NOSPACE);

return;

}

assert(n == body);

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

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 1329 blk_part_exp(MACRO_PROT_ARGS)

Line 1215 blk_part_exp(MACRO_PROT_ARGS)

{

int la, nl;

enum margserr ac;

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

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

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

char *p;

nl = MDOC_NEWLINE & mdoc->flags;

Line 1341 blk_part_exp(MACRO_PROT_ARGS)

Line 1226 blk_part_exp(MACRO_PROT_ARGS)

* case of `Eo'); and a body that may be empty.

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

roff_block_alloc(mdoc, line, ppos, tok);

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 1352 blk_part_exp(MACRO_PROT_ARGS)

Line 1238 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 = roff_head_alloc(mdoc, line, ppos, tok);

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);

roff_body_alloc(mdoc, line, ppos, tok);

if (tok == MDOC_Eo)

continue;

}

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

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

break;

Line 1385 blk_part_exp(MACRO_PROT_ARGS)

Line 1258 blk_part_exp(MACRO_PROT_ARGS)

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

if (head == NULL)

if (head == NULL) {

mdoc_head_alloc(mdoc, line, ppos, tok);

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

roff_body_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)

append_delims(mdoc, line, pos, buf);

Line 1399 blk_part_exp(MACRO_PROT_ARGS)

Line 1269 blk_part_exp(MACRO_PROT_ARGS)

static void

in_line_argn(MACRO_PROT_ARGS)

{

int la, flushed, j, maxargs, nl;

enum margserr ac;

struct mdoc_arg *arg;

char *p;

enum mdoct ntok;

enum margserr ac;

int ntok;

int state; /* arg#; -1: not yet open; -2: closed */

int la, maxargs, nl;

nl = mdoc->flags & MDOC_NEWLINE;

Line 1437 in_line_argn(MACRO_PROT_ARGS)

Line 1308 in_line_argn(MACRO_PROT_ARGS)

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

state = -1;

p = NULL;

flushed = j = 0;

for (;;) {

la = *pos;

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

if (ac == ARGS_WORD && state == -1 &&

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

mdoc_isdelim(p) == DELIM_OPEN) {

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

continue;

}

if (state == -1 && tok != MDOC_In &&

tok != MDOC_St && tok != MDOC_Xr) {

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

state = 0;

}

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

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

if (abs(state) < 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) &&

if (state == maxargs) {

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

mdoc_isdelim(p) == DELIM_OPEN) {

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

continue;

} else if (j == 0)

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

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

rew_elem(mdoc, tok);

flushed = 1;

state = -2;

}

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

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

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

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

if (ntok != MDOC_MAX) {

if (ntok != TOKEN_NONE) {

if ( ! flushed)

if (state >= 0) {

rew_elem(mdoc, tok);

flushed = 1;

state = -2;

}

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

j++;

break;

}

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

if (ac == ARGS_QWORD ||

ac != ARGS_QWORD && ! flushed &&

mdoc_macros[tok].flags & MDOC_IGNDELIM ||

mdoc_isdelim(p) != DELIM_NONE) {

mdoc_isdelim(p) == DELIM_NONE) {

if (state == -1) {

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

state = 1;

} else if (state >= 0)

state++;

} else if (state >= 0) {

rew_elem(mdoc, tok);

flushed = 1;

state = -2;

}

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

MDOC_JOIN & mdoc_macros[tok].flags);

j++;

}

if (j == 0) {

if (state == -1) {

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

mandoc_msg(MANDOCERR_MACRO_EMPTY, mdoc->parse,

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

line, ppos, mdoc_macronames[tok]);

append_delims(mdoc, line, pos, buf);

return;

}

if ( ! flushed)

if (state == 0 && tok == MDOC_Pf)

append_delims(mdoc, line, pos, buf);

if (state >= 0)

rew_elem(mdoc, tok);

if (nl)

append_delims(mdoc, line, pos, buf);

Line 1501 in_line_argn(MACRO_PROT_ARGS)

Line 1386 in_line_argn(MACRO_PROT_ARGS)

static void

in_line_eoln(MACRO_PROT_ARGS)

{

struct mdoc_arg *arg;

struct roff_node *n;

struct mdoc_arg *arg;

if (tok == MDOC_Pp)

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

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

! (mdoc->flags & MDOC_SYNOPSIS)) {

n = mdoc->last;

if (mdoc->next == ROFF_NEXT_SIBLING)

n = n->parent;

if (n->tok == MDOC_Nm)

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

}

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

(tok == MDOC_Fd || mdoc_macronames[tok][0] == '%')) {

mandoc_msg(MANDOCERR_MACRO_EMPTY, mdoc->parse,

line, ppos, mdoc_macronames[tok]);

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))

Line 1519 in_line_eoln(MACRO_PROT_ARGS)

Line 1418 in_line_eoln(MACRO_PROT_ARGS)

* 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)

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

{

int la;

Line 1554 ctx_synopsis(MACRO_PROT_ARGS)

Line 1453 ctx_synopsis(MACRO_PROT_ARGS)

static void

phrase_ta(MACRO_PROT_ARGS)

{

struct mdoc_node *n;

struct roff_node *body, *n;

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

n = mdoc->last;

body = NULL;

while (n != NULL &&

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

(n->tok != MDOC_Bl || n->flags & (MDOC_VALID | MDOC_BREAK)))

if (n->flags & MDOC_ENDED)

n = n->parent;

continue;

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

body = n;

if (n->tok == MDOC_Bl)

break;

}

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

mandoc_msg(MANDOCERR_TA_STRAY, mdoc->parse,

line, ppos, "Ta");

Line 1570 phrase_ta(MACRO_PROT_ARGS)

Line 1475 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);

roff_body_alloc(mdoc, line, ppos, MDOC_It);

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

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

}

CVSweb