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.157 and 1.224

version 1.157, 2014/12/13 13:14:39

version 1.224, 2017/05/30 16:22:03

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

int, int, const char *);

int, int, 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 void break_intermediate(struct roff_node *,

struct mdoc *, int, int);

struct roff_node *);

static int parse_rest(struct mdoc *, enum mdoct,

static int parse_rest(struct roff_man *, enum roff_tok,

int, int *, char *);

static enum mdoct rew_alt(enum mdoct);

static enum roff_tok rew_alt(enum roff_tok);

static enum rew rew_dohalt(enum mdoct, enum mdoc_type,

static void rew_elem(struct roff_man *, enum roff_tok);

const struct mdoc_node *);

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

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

static void rew_pending(struct roff_man *,

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

const struct roff_node *);

static void rew_sub(enum mdoc_type, struct mdoc *,

enum mdoct, int, int);

const struct mdoc_macro __mdoc_macros[MDOC_MAX] = {

const struct mdoc_macro __mdoc_macros[MDOC_MAX - MDOC_Dd] = {

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

{ in_line_eoln, MDOC_PROLOGUE }, /* Dd */

{ in_line_eoln, MDOC_PROLOGUE }, /* Dt */

{ in_line_eoln, MDOC_PROLOGUE }, /* Os */

Line 85 const struct mdoc_macro __mdoc_macros[MDOC_MAX] = {

Line 76 const struct mdoc_macro __mdoc_macros[MDOC_MAX] = {

{ blk_full, MDOC_PARSED | MDOC_JOIN }, /* It */

{ in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Ad */

{ in_line, MDOC_CALLABLE | MDOC_PARSED | MDOC_JOIN }, /* An */

{ in_line_argn, MDOC_CALLABLE | MDOC_PARSED |

MDOC_IGNDELIM | MDOC_JOIN }, /* Ap */

{ in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Ar */

{ in_line, MDOC_CALLABLE | MDOC_PARSED | MDOC_JOIN }, /* Cd */

{ in_line, MDOC_CALLABLE | MDOC_PARSED }, /* Cm */

Line 205 const struct mdoc_macro __mdoc_macros[MDOC_MAX] = {

Line 198 const struct mdoc_macro __mdoc_macros[MDOC_MAX] = {

{ blk_part_imp, MDOC_CALLABLE | MDOC_PARSED | MDOC_JOIN }, /* En */

{ in_line_argn, MDOC_CALLABLE | MDOC_PARSED }, /* Dx */

{ in_line_eoln, MDOC_JOIN }, /* %Q */

{ in_line_eoln, 0 }, /* br */

{ in_line_eoln, 0 }, /* sp */

{ in_line_eoln, 0 }, /* %U */

{ phrase_ta, MDOC_CALLABLE | MDOC_PARSED | MDOC_JOIN }, /* Ta */

{ in_line_eoln, MDOC_PROLOGUE }, /* ll */

};

const struct mdoc_macro *const mdoc_macros = __mdoc_macros - MDOC_Dd;

const struct mdoc_macro * const mdoc_macros = __mdoc_macros;

* This is called at the end of parsing. It must traverse up the tree,

* closing out open [implicit] scopes. Obviously, open explicit scopes

* 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. */

n = mdoc->last->flags & MDOC_VALID ?

n = mdoc->last->flags & NODE_VALID ?

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

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

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

enum roff_tok res;

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

if (mdoc->flags & MDOC_PHRASEQF) {

res = mdoc_hash_find(p);

mdoc->flags &= ~MDOC_PHRASEQF;

if (res != MDOC_MAX) {

return TOKEN_NONE;

}

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

res = roffhash_find(mdoc->mdocmac, p, 0);

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

mdoc->next = MDOC_NEXT_SIBLING;

return;

while (mdoc->last != to) {

mdoc_state(mdoc, mdoc->last);

* Save the parent here, because we may delete the

mdoc->last->flags |= NODE_VALID | NODE_ENDED;

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

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

* 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 |= NODE_VALID | NODE_ENDED;

mdoc->next = ROFF_NEXT_SIBLING;

}

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

break;

case ROFFT_BLOCK:

break;

default:

return;

}

if ( ! (n->flags & NODE_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 & NODE_ENDED)

break;

else

return;

}

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

* Otherwise, return the macro itself.

static enum mdoct

static enum roff_tok

rew_alt(enum mdoct tok)

rew_alt(enum roff_tok 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.

* 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, enum roff_tok 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);

}

static void

break_intermediate(struct roff_node *n, struct roff_node *breaker)

{

if (n != breaker &&

n->type != ROFFT_BLOCK && n->type != ROFFT_HEAD &&

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

n = n->parent;

while (n != breaker) {

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

n->flags |= NODE_BROKEN;

n = n->parent;

}

* 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, enum roff_tok 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;

if (target->flags & NODE_VALID)

* Iterate backwards, searching for the block matching tok,

return 0;

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

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

irc = 0;

* If the *broken block had already been broken before

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

* and we encounter its breaker, make the tok block

if (n->flags & NODE_ENDED)

* pending on the inner breaker.

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

* 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 (n->type == ROFFT_BLOCK &&

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

irc = 1;

break_intermediate(mdoc->last, target);

if (target->type == ROFFT_HEAD)

target->flags |= NODE_ENDED;

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

mandoc_vmsg(MANDOCERR_BLK_NEST,

mdoc->parse, line, ppos,

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

roff_name[n->tok]);

mdoc_endbody_alloc(mdoc, line, ppos,

tok, target);

}

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

continue;

if (MDOC_BODY == broken->type)

broken = broken->parent;

* Found the breaker.

* If another, outer breaker is already pending on

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

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

* new, now inner breaker.

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

* If the breaker had also been broken before,

* it cannot take on the outer breaker itself,

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

}

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

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

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

if (d == DELIM_OPEN)

mdoc->last->flags |= MDOC_DELIMO;

mdoc->last->flags |= NODE_DELIMO;

else if (d == DELIM_CLOSE &&

! (mdoc->flags & MDOC_NODELIMC) &&

mdoc->last->parent->tok != MDOC_Fd)

mdoc->last->flags |= MDOC_DELIMC;

mdoc->last->flags |= NODE_DELIMC;

mdoc->flags &= ~MDOC_NODELIMC;

}

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

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

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

if (mandoc_eos(p, strlen(p)))

mdoc->last->flags |= MDOC_EOS;

mdoc->last->flags |= NODE_EOS;

}

Line 668 static int

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

if (tok != TOKEN_NONE &&

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 697 macro_or_word(MACRO_PROT_ARGS, int parsed)

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

enum roff_tok atok, ntok;

char *p;

nl = MDOC_NEWLINE & mdoc->flags;

Line 721 blk_exp_close(MACRO_PROT_ARGS)

Line 563 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 & NODE_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.

atok = rew_alt(tok);

endbody = itblk = later = NULL;

body = endbody = later = NULL;

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

if (n->flags & MDOC_VALID)

if (n->flags & NODE_ENDED)

continue;

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

* Mismatching end macros can never break anything

* and we only care about the breaking of BLOCKs.

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

if (body == NULL || n->type != ROFFT_BLOCK)

if (n->end == ENDBODY_NOT)

body = n;

continue;

* SYNOPSIS name blocks can not be broken themselves,

* but they do get broken together with a broken child.

if (n->tok == MDOC_Nm) {

if (later != NULL)

n->flags |= NODE_BROKEN | NODE_ENDED;

continue;

}

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

if (n->tok == MDOC_It) {

itblk = n;

continue;

}

if (atok == n->tok) {

assert(body);

* Found the start of our own block.

Line 751 blk_exp_close(MACRO_PROT_ARGS)

Line 617 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,

atok, body, ENDBODY_SPACE);

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

roff_name[atok], roff_name[later->tok]);

endbody = mdoc_endbody_alloc(mdoc, line, ppos,

atok, body);

if (tok == MDOC_El)

itblk->flags |= NODE_ENDED | NODE_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;

}

* When finding an open sub block, remember the last

* Explicit blocks close out description lines, but

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

* even those can get broken together with a child.

* implicit ones, the first open implicit block.

if (later &&

if (n->tok == MDOC_Nd) {

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

if (later != NULL)

n->flags |= NODE_BROKEN | NODE_ENDED;

else

rew_last(mdoc, n);

continue;

if (n->tok != MDOC_It)

}

/* Breaking an open sub block. */

break_intermediate(mdoc->last, body);

n->flags |= NODE_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, roff_name[tok]);

if (maxargs && endbody == NULL) {

* Stray .Ec without previous .Eo:

* Break the output line, keep the arguments.

roff_elem_alloc(mdoc, line, ppos, ROFF_br);

rew_elem(mdoc, ROFF_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],

"%s %s", roff_name[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;

ntok = TOKEN_NONE;

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 = lookup(mdoc, tok, line, lastarg, p);

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)

pending = 0;

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

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

else

target = n;

rew_last(mdoc, endbody);

target = target->parent;

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

pending = find_pending(mdoc, ntok, line, ppos, target);

}

if ( ! pending)

rew_pending(mdoc, n);

}

if (nl)

append_delims(mdoc, line, pos, buf);

Line 871 static void

Line 748 static void

in_line(MACRO_PROT_ARGS)

{

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

enum mdoct ntok;

enum roff_tok ntok;

enum margserr ac;

enum mdelim d;

struct mdoc_arg *arg;

Line 886 in_line(MACRO_PROT_ARGS)

Line 763 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 919 in_line(MACRO_PROT_ARGS)

Line 791 in_line(MACRO_PROT_ARGS)

if (ac == ARGS_EOLN) {

if (d == DELIM_OPEN)

mdoc->last->flags &= ~MDOC_DELIMO;

mdoc->last->flags &= ~NODE_DELIMO;

break;

}

Line 932 in_line(MACRO_PROT_ARGS)

Line 804 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)) ?

ntok = (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 947 in_line(MACRO_PROT_ARGS)

Line 819 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 957 in_line(MACRO_PROT_ARGS)

Line 829 in_line(MACRO_PROT_ARGS)

mdoc_argv_free(arg);

mandoc_msg(MANDOCERR_MACRO_EMPTY,

mdoc->parse, line, ppos,

mdoc_macronames[tok]);

roff_name[tok]);

}

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

if (nl)

Line 966 in_line(MACRO_PROT_ARGS)

Line 838 in_line(MACRO_PROT_ARGS)

}

* Non-quote-enclosed punctuation. Set up our scope, if

* Handle punctuation. Set up our scope, if a word;

* a word; rewind the scope, if a delimiter; then append

* rewind the scope, if a delimiter; then append the word.

* the word.

d = ac == ARGS_QWORD ? DELIM_NONE : mdoc_isdelim(p);

if ((d = mdoc_isdelim(p)) != DELIM_NONE) {

if (DELIM_NONE != d) {

* If we encounter closing punctuation, no word

* has been emitted, no scope is open, and we're

Line 993 in_line(MACRO_PROT_ARGS)

Line 862 in_line(MACRO_PROT_ARGS)

* Close out our scope, if one is open, before

* any punctuation.

if (scope)

if (scope && tok != MDOC_Lk) {

rew_elem(mdoc, tok);

scope = 0;

if (tok == MDOC_Fn)

mayopen = 0;

}

} else if (mayopen && !scope) {

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

scope = 1;

Line 1005 in_line(MACRO_PROT_ARGS)

Line 875 in_line(MACRO_PROT_ARGS)

}

dword(mdoc, line, la, p, d,

MDOC_JOIN & mdoc_macros[tok].flags);

mdoc_macros[tok].flags & MDOC_JOIN);

* If the first argument is a closing delimiter,

Line 1013 in_line(MACRO_PROT_ARGS)

Line 883 in_line(MACRO_PROT_ARGS)

if (firstarg && d == DELIM_CLOSE && !nc)

mdoc->last->flags &= ~MDOC_DELIMC;

mdoc->last->flags &= ~NODE_DELIMC;

firstarg = 0;

Line 1027 in_line(MACRO_PROT_ARGS)

Line 897 in_line(MACRO_PROT_ARGS)

}

if (scope)

if (scope && tok != MDOC_Lk) {

rew_elem(mdoc, tok);

scope = 0;

}

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

Line 1043 in_line(MACRO_PROT_ARGS)

Line 915 in_line(MACRO_PROT_ARGS)

} else {

mdoc_argv_free(arg);

mandoc_msg(MANDOCERR_MACRO_EMPTY, mdoc->parse,

line, ppos, mdoc_macronames[tok]);

line, ppos, roff_name[tok]);

}

if (nl)

append_delims(mdoc, line, pos, buf);

if (scope)

rew_elem(mdoc, tok);

}

static void

Line 1055 blk_full(MACRO_PROT_ARGS)

Line 929 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, roff_name[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 & NODE_ENDED) {

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

n->flags |= NODE_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",

roff_name[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", roff_name[tok],

roff_name[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", roff_name[blk->tok]);

rew_pending(mdoc, blk);

blk = NULL;

}

/* Close out prior implicit scopes. */

rew_pending(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, ROFF_br);

rew_elem(mdoc, MDOC_br);

rew_elem(mdoc, ROFF_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 1096 blk_full(MACRO_PROT_ARGS)

Line 1033 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 1114 blk_full(MACRO_PROT_ARGS)

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

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.

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

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

if (body != NULL)

rew_last(mdoc, body);

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

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

continue;

Line 1162 blk_full(MACRO_PROT_ARGS)

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

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

Line 1150 blk_full(MACRO_PROT_ARGS)

break;

}

if (blk->flags & NODE_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 1236 blk_part_imp(MACRO_PROT_ARGS)

Line 1179 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 1252 blk_part_imp(MACRO_PROT_ARGS)

Line 1195 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 1267 blk_part_imp(MACRO_PROT_ARGS)

Line 1209 blk_part_imp(MACRO_PROT_ARGS)

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

break;

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

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

mdoc_isdelim(p) == DELIM_OPEN) {

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

continue;

}

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

Line 1244 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 1330 blk_part_exp(MACRO_PROT_ARGS)

Line 1255 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 1339 blk_part_exp(MACRO_PROT_ARGS)

Line 1265 blk_part_exp(MACRO_PROT_ARGS)

/* Flush out leading punctuation. */

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

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

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

Line 1286 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 1388 blk_part_exp(MACRO_PROT_ARGS)

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

enum roff_tok ntok;

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

int la, maxargs, nl;

nl = mdoc->flags & MDOC_NEWLINE;

Line 1406 in_line_argn(MACRO_PROT_ARGS)

Line 1316 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 1426 in_line_argn(MACRO_PROT_ARGS)

Line 1332 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 = (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 (mdoc_macros[tok].flags & MDOC_IGNDELIM ||

ac != ARGS_QWORD && ! flushed &&

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

mdoc_macros[tok].flags & MDOC_JOIN);

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, roff_name[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 1490 in_line_argn(MACRO_PROT_ARGS)

Line 1409 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 || *roff_name[tok] == '%')) {

mandoc_msg(MANDOCERR_MACRO_EMPTY, mdoc->parse,

line, ppos, roff_name[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 1508 in_line_eoln(MACRO_PROT_ARGS)

Line 1441 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, enum roff_tok 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 1543 ctx_synopsis(MACRO_PROT_ARGS)

Line 1477 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 && n->tok != MDOC_Bl)

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

n = n->parent;

if (n->flags & NODE_ENDED)

continue;

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

body = n;

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

break;

}

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

mandoc_msg(MANDOCERR_TA_STRAY, mdoc->parse,

line, ppos, "Ta");

Line 1558 phrase_ta(MACRO_PROT_ARGS)

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