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.169 and 1.209

version 1.169, 2015/02/02 19:23:23

version 1.209, 2016/08/20 17:59:34

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

};

static void blk_full(MACRO_PROT_ARGS);

static void blk_exp_close(MACRO_PROT_ARGS);

static void blk_part_exp(MACRO_PROT_ARGS);

Line 48 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 void make_pending(struct mdoc *, struct mdoc_node *,

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

struct mdoc_node *, 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_pending(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 220 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_endparse(struct roff_man *mdoc)

{

struct mdoc_node *n;

struct roff_node *n;

/* Scan for open explicit scopes. */

Line 230 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 238 mdoc_macroend(struct mdoc *mdoc)

Line 228 mdoc_macroend(struct mdoc *mdoc)

/* Rewind to the first. */

rew_last(mdoc, mdoc->first);

mdoc_state_reset(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 (mdoc->flags & MDOC_PHRASEQF) {

mdoc->flags &= ~MDOC_PHRASEQF;

return TOKEN_NONE;

}

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

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

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;

assert(to);

if (to->flags & MDOC_VALID)

mdoc->next = MDOC_NEXT_SIBLING;

return;

while (mdoc->last != to) {

if ( ! (mdoc->last->flags & MDOC_VALID))

mdoc_state(mdoc, mdoc->last);

mdoc->last->lastline = to->lastline -

mdoc->last->flags |= MDOC_VALID | MDOC_ENDED;

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

mdoc->last = mdoc->last->parent;

* Save the parent here, because we may delete the

* mdoc->last node in the post-validation phase and reset

* it to mdoc->last->parent, causing a step in the closing

* out to be lost.

np = mdoc->last->parent;

mdoc_valid_post(mdoc);

n = mdoc->last;

mdoc->last = np;

assert(mdoc->last);

mdoc->last->last = n;

}

mdoc_valid_post(mdoc);

mdoc_state(mdoc, mdoc->last);

mdoc->last->flags |= MDOC_VALID | MDOC_ENDED;

mdoc->next = ROFF_NEXT_SIBLING;

}

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

{

rew_last(mdoc, n);

for (;;) {

rew_last(mdoc, n);

if (n->type != MDOC_BLOCK)

if (mdoc->last == n) {

return;

switch (n->type) {

case ROFFT_HEAD:

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

n->tok);

break;

case ROFFT_BLOCK:

break;

default:

return;

}

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

return;

} else

n = mdoc->last;

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

for (;;) {

rew_last(mdoc, n);

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

if (n->type == MDOC_HEAD)

return;

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

if (n->type == ROFFT_BLOCK ||

n->type == ROFFT_HEAD) {

if (n->flags & MDOC_ENDED)

break;

else

return;

}

Line 315 rew_pending(struct mdoc *mdoc, const struct mdoc_node

Line 322 rew_pending(struct mdoc *mdoc, const struct mdoc_node

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

return(MDOC_Ao);

return MDOC_Ao;

case MDOC_Bc:

return(MDOC_Bo);

return MDOC_Bo;

case MDOC_Brc:

return(MDOC_Bro);

return MDOC_Bro;

case MDOC_Dc:

return(MDOC_Do);

return MDOC_Do;

case MDOC_Ec:

return(MDOC_Eo);

return MDOC_Eo;

case MDOC_Ed:

return(MDOC_Bd);

return MDOC_Bd;

case MDOC_Ef:

return(MDOC_Bf);

return MDOC_Bf;

case MDOC_Ek:

return(MDOC_Bk);

return MDOC_Bk;

case MDOC_El:

return(MDOC_Bl);

return MDOC_Bl;

case MDOC_Fc:

return(MDOC_Fo);

return MDOC_Fo;

case MDOC_Oc:

return(MDOC_Oo);

return MDOC_Oo;

case MDOC_Pc:

return(MDOC_Po);

return MDOC_Po;

case MDOC_Qc:

return(MDOC_Qo);

return MDOC_Qo;

case MDOC_Re:

return(MDOC_Rs);

return MDOC_Rs;

case MDOC_Sc:

return(MDOC_So);

return MDOC_So;

case MDOC_Xc:

return(MDOC_Xo);

return MDOC_Xo;

default:

return(tok);

return 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.

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

* When starting to rewind, skip plain text

* and nodes that have already been rewound.

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

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(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_It:

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

return(REWIND_NONE);

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, let all blocks rewind Nm children.

* Do not warn again when closing a block,

* since closing the body already warned.

if (MDOC_Nm == p->tok ||

MDOC_BLOCK == type || MDOC_BLOCK == p->type)

return(REWIND_MORE);

* By default, closing out full blocks

* forces closing of broken explicit blocks.

return (REWIND_FORCE);

}

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 the block *breaker,

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

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

* until the rew_pending() call closing *broken.

static void

static int

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

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

struct mdoc_node *broken, int line, int ppos)

struct roff_node *target)

{

struct mdoc_node *n;

struct roff_node *n;

int irc;

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

irc = 0;

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

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

mdoc_macronames[broken->tok]);

if (n->flags & MDOC_ENDED) {

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

n->flags |= MDOC_BROKEN;

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

* 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 (n = broken->parent; ; n = n->parent)

if (n == broken->pending)

broken = n;

else if (n == breaker)

break;

* Found the breaker.

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

* 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). Graphically,

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

while (n->pending)

n = n->pending;

n->pending = broken->pending;

}

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

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

broken->pending = breaker;

breaker->flags |= MDOC_BREAK;

if (breaker->body != NULL)

breaker->body->flags |= MDOC_BREAK;

}

static void

rew_sub(enum mdoc_type t, struct mdoc *mdoc,

enum mdoct tok, int line, int ppos)

{

struct mdoc_node *n, *to;

to = NULL;

n = mdoc->last;

while (n) {

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

case REWIND_NONE:

if (to == NULL)

return;

n = to;

break;

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

to = n;

n = n->parent;

continue;

}

break;

if (n->type == ROFFT_BLOCK &&

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

irc = 1;

n->flags = MDOC_BROKEN;

if (target->type == ROFFT_HEAD)

target->flags = MDOC_ENDED;

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

mandoc_vmsg(MANDOCERR_BLK_NEST,

mdoc->parse, line, ppos,

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

mdoc_macronames[n->tok]);

mdoc_endbody_alloc(mdoc, line, ppos,

tok, target, ENDBODY_NOSPACE);

}

assert(n);

return irc;

rew_pending(mdoc, n);

}

Line 575 rew_sub(enum mdoc_type t, struct mdoc *mdoc,

Line 419 rew_sub(enum mdoc_type t, struct mdoc *mdoc,

* 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 584 dword(struct mdoc *mdoc, int line, int col, const char

Line 428 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 609 dword(struct mdoc *mdoc, int line, int col, const char

Line 453 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 619 append_delims(struct mdoc *mdoc, int line, int *pos, c

Line 463 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 649 static int

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

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

return 1;

}

Line 678 macro_or_word(MACRO_PROT_ARGS, int parsed)

Line 523 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; /* Search back to our block. */

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 have_it, j, lastarg, maxargs, 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 702 blk_exp_close(MACRO_PROT_ARGS)

Line 549 blk_exp_close(MACRO_PROT_ARGS)

break;

}

/* Search backwards for the beginning of our own body. */

atok = rew_alt(tok);

body = NULL;

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

if (n->flags & MDOC_ENDED || n->tok != atok ||

n->type != ROFFT_BODY || n->end != ENDBODY_NOT)

continue;

body = n;

break;

}

* Search backwards for beginnings of blocks,

* both of our own and of pending sub-blocks.

have_it = 0;

endbody = itblk = later = NULL;

atok = rew_alt(tok);

body = endbody = later = NULL;

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

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

if (n->flags & MDOC_ENDED) {

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

n->flags |= MDOC_BROKEN;

continue;

}

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

* Mismatching end macros can never break anything,

* SYNOPSIS name blocks can never be broken,

* and we only care about the breaking of BLOCKs.

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

if (body == NULL ||

if (n->end == ENDBODY_NOT) {

n->tok == MDOC_Nm ||

body = n;

n->type != ROFFT_BLOCK)

n->lastline = line;

}

continue;

}

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

continue;

if (n->tok == MDOC_It) {

have_it = 1;

itblk = n;

continue;

}

if (atok == n->tok) {

n->lastline = line;

assert(body);

Line 743 blk_exp_close(MACRO_PROT_ARGS)

Line 600 blk_exp_close(MACRO_PROT_ARGS)

if (later == NULL ||

(tok == MDOC_El && !have_it))

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

break;

* When there is a pending sub block, postpone

* closing out the current block until the

* rew_pending() closing out the sub-block.

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

* Mark the place where the formatting - but not

* the scope - of the current block ends.

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

Line 769 blk_exp_close(MACRO_PROT_ARGS)

Line 629 blk_exp_close(MACRO_PROT_ARGS)

if (maxargs)

mdoc->next = MDOC_NEXT_CHILD;

mdoc->next = ROFF_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 == NULL ||

if (n->tok == MDOC_Nd) {

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

rew_last(mdoc, n);

continue;

}

/* Breaking an open sub block. */

n->flags |= MDOC_BROKEN;

if (later == NULL)

later = n;

}

Line 792 blk_exp_close(MACRO_PROT_ARGS)

Line 655 blk_exp_close(MACRO_PROT_ARGS)

* Stray .Ec without previous .Eo:

* Break the output line, keep the arguments.

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

roff_elem_alloc(mdoc, line, ppos, MDOC_br);

rew_elem(mdoc, MDOC_br);

}

} else if (endbody == NULL) {

Line 807 blk_exp_close(MACRO_PROT_ARGS)

Line 670 blk_exp_close(MACRO_PROT_ARGS)

mdoc->parse, line, ppos,

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

buf + *pos);

if (endbody == NULL)

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

rew_pending(mdoc, n);

return;

}

if (endbody != NULL)

n = endbody;

ntok = TOKEN_NONE;

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

lastarg = *pos;

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

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

rew_pending(mdoc, n);

rew_last(mdoc, n);

n = NULL;

}

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 (n != NULL) {

if (n != NULL)

rew_pending(mdoc, n);

rew_last(mdoc, n);

n = NULL;

}

mdoc->flags &= ~MDOC_NEWLINE;

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

break;

}

if (n != NULL)

if (n != NULL) {

rew_pending(mdoc, n);

if (ntok != TOKEN_NONE && n->flags & MDOC_BROKEN) {

target = n;

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 854 static void

Line 726 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 869 in_line(MACRO_PROT_ARGS)

Line 741 in_line(MACRO_PROT_ARGS)

switch (tok) {

case MDOC_An:

/* FALLTHROUGH */

case MDOC_Ar:

/* FALLTHROUGH */

case MDOC_Fl:

/* FALLTHROUGH */

case MDOC_Mt:

/* FALLTHROUGH */

case MDOC_Nm:

/* FALLTHROUGH */

case MDOC_Pa:

nc = 1;

break;

Line 915 in_line(MACRO_PROT_ARGS)

Line 782 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 930 in_line(MACRO_PROT_ARGS)

Line 797 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 1038 blk_full(MACRO_PROT_ARGS)

Line 905 blk_full(MACRO_PROT_ARGS)

{

int la, nl, parsed;

struct mdoc_arg *arg;

struct mdoc_node *blk; /* Our own block. */

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

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

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

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

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

struct mdoc_node *n;

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:

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 1098 blk_full(MACRO_PROT_ARGS)

Line 1029 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_last(mdoc, head);

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

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

}

if (tok == MDOC_Bk)

mdoc->flags |= MDOC_KEEP;

ac = ARGS_PEND;

ac = ARGS_EOLN;

for (;;) {

* If we are right after a tab character,

* do not parse the first word for macros.

if (mdoc->flags & MDOC_PHRASEQN) {

mdoc->flags &= ~MDOC_PHRASEQN;

mdoc->flags |= MDOC_PHRASEQF;

}

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)

if (lac != ARGS_PHRASE ||

! (mdoc->flags & MDOC_PHRASEQF))

break;

* This is necessary: if the last token on a

* This line ends in a tab; start the next

* line is a `Ta' or tab, then we'll get

* column now, with a leading blank.

* ARGS_EOLN, so we must be smart enough to

* reopen our scope if the last parse was a

* phrase or partial phrase.

if (body != NULL)

rew_last(mdoc, body);

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

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

roff_word_alloc(mdoc, line, ppos, "\\&");

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

ac != ARGS_PEND &&

ac != ARGS_PHRASE &&

ac != ARGS_PPHRASE &&

ac != ARGS_QWORD &&

mdoc_isdelim(p) == DELIM_OPEN) {

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

Line 1147 blk_full(MACRO_PROT_ARGS)

Line 1100 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 ||

if (ac == ARGS_PHRASE) {

ac == ARGS_PEND ||

ac == ARGS_PPHRASE) {

* If we haven't opened a body yet, rewind the

Line 1159 blk_full(MACRO_PROT_ARGS)

Line 1110 blk_full(MACRO_PROT_ARGS)

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

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

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

/* Process to the tab or to the end of the line. */

* Process phrases: set whether we're in a

* partial-phrase (this effects line handling)

* then call down into the phrase parser.

if (ac == ARGS_PPHRASE)

mdoc->flags |= MDOC_PHRASE;

mdoc->flags |= MDOC_PPHRASE;

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

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

mdoc->flags &= ~MDOC_PHRASE;

mdoc->flags |= MDOC_PPHRASE;

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

/* There may have been `Ta' macros. */

mdoc->flags &= ~MDOC_PPHRASE;

while (body->next != NULL)

body = body->next;

continue;

}

Line 1183 blk_full(MACRO_PROT_ARGS)

Line 1132 blk_full(MACRO_PROT_ARGS)

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

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

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

out:

if (mdoc->flags & MDOC_FREECOL) {

rew_last(mdoc, body);

Line 1222 blk_part_imp(MACRO_PROT_ARGS)

Line 1158 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 1238 blk_part_imp(MACRO_PROT_ARGS)

Line 1174 blk_part_imp(MACRO_PROT_ARGS)

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

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

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

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

Line 1259 blk_part_imp(MACRO_PROT_ARGS)

Line 1195 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_pending() call closing out the sub-block.

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

n = n->parent) {

if (n->type == MDOC_BLOCK &&

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

! (n->flags & MDOC_VALID)) {

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

mdoc_endbody_alloc(mdoc, line, ppos,

tok, body, ENDBODY_NOSPACE);

return;

}

assert(n == body);

rew_last(mdoc, body);

if (nl)

append_delims(mdoc, line, pos, buf);

Line 1303 blk_part_exp(MACRO_PROT_ARGS)

Line 1224 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 */

char *p;

nl = MDOC_NEWLINE & mdoc->flags;

Line 1314 blk_part_exp(MACRO_PROT_ARGS)

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

head = NULL;

for (;;) {

la = *pos;

Line 1331 blk_part_exp(MACRO_PROT_ARGS)

Line 1252 blk_part_exp(MACRO_PROT_ARGS)

}

if (head == NULL) {

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

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

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

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

rew_last(mdoc, head);

mdoc_body_alloc(mdoc, line, ppos, tok);

roff_body_alloc(mdoc, line, ppos, tok);

if (tok == MDOC_Eo)

continue;

}

Line 1347 blk_part_exp(MACRO_PROT_ARGS)

Line 1268 blk_part_exp(MACRO_PROT_ARGS)

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

if (head == NULL) {

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

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

mdoc_body_alloc(mdoc, line, ppos, tok);

roff_body_alloc(mdoc, line, ppos, tok);

}

if (nl)

append_delims(mdoc, line, pos, buf);

Line 1357 blk_part_exp(MACRO_PROT_ARGS)

Line 1278 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 1375 in_line_argn(MACRO_PROT_ARGS)

Line 1297 in_line_argn(MACRO_PROT_ARGS)

switch (tok) {

case MDOC_Ap:

/* FALLTHROUGH */

case MDOC_Ns:

/* FALLTHROUGH */

case MDOC_Ux:

maxargs = 0;

break;

case MDOC_Bx:

/* FALLTHROUGH */

case MDOC_Es:

/* FALLTHROUGH */

case MDOC_Xr:

maxargs = 2;

break;

Line 1395 in_line_argn(MACRO_PROT_ARGS)

Line 1313 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 1459 in_line_argn(MACRO_PROT_ARGS)

Line 1391 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, n->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 1477 in_line_eoln(MACRO_PROT_ARGS)

Line 1423 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;

for (;;) {

la = *pos;

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

return(0);

return 0;

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

return(1);

return 1;

}

Line 1512 ctx_synopsis(MACRO_PROT_ARGS)

Line 1458 ctx_synopsis(MACRO_PROT_ARGS)

static void

phrase_ta(MACRO_PROT_ARGS)

{

struct mdoc_node *body, *n;

struct roff_node *body, *n;

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

body = NULL;

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

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

if (n->flags & MDOC_ENDED)

continue;

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

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

body = n;

if (n->tok == MDOC_Bl)

if (n->tok == MDOC_Bl && n->end == ENDBODY_NOT)

break;

}

Line 1535 phrase_ta(MACRO_PROT_ARGS)

Line 1481 phrase_ta(MACRO_PROT_ARGS)

/* Advance to the next column. */

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