![]() ![]() | ![]() |
version 1.44, 2010/05/15 22:44:04 | version 1.87, 2014/07/30 23:01:39 | ||
---|---|---|---|
|
|
||
/* $Id$ */ | /* $Id$ */ | ||
/* | /* | ||
* Copyright (c) 2008, 2009 Kristaps Dzonsons <kristaps@kth.se> | * Copyright (c) 2008, 2009, 2010, 2011 Kristaps Dzonsons <kristaps@bsd.lv> | ||
* Copyright (c) 2012, 2013 Ingo Schwarze <schwarze@openbsd.org> | |||
* Copyright (c) 2013 Franco Fichtner <franco@lastsummer.de> | |||
* | * | ||
* Permission to use, copy, modify, and distribute this software for any | * Permission to use, copy, modify, and distribute this software for any | ||
* purpose with or without fee is hereby granted, provided that the above | * purpose with or without fee is hereby granted, provided that the above | ||
|
|
||
#include <stdlib.h> | #include <stdlib.h> | ||
#include <string.h> | #include <string.h> | ||
#include "man.h" | |||
#include "mandoc.h" | |||
#include "libmandoc.h" | |||
#include "libman.h" | #include "libman.h" | ||
enum rew { | enum rew { | ||
|
|
||
static int blk_exp(MACRO_PROT_ARGS); | static int blk_exp(MACRO_PROT_ARGS); | ||
static int blk_imp(MACRO_PROT_ARGS); | static int blk_imp(MACRO_PROT_ARGS); | ||
static int in_line_eoln(MACRO_PROT_ARGS); | static int in_line_eoln(MACRO_PROT_ARGS); | ||
static int man_args(struct man *, int, | |||
int *, char *, char **); | |||
static int rew_scope(enum man_type, | static int rew_scope(enum man_type, | ||
struct man *, enum mant); | struct man *, enum mant); | ||
static enum rew rew_dohalt(enum mant, enum man_type, | static enum rew rew_dohalt(enum mant, enum man_type, | ||
const struct man_node *); | const struct man_node *); | ||
static enum rew rew_block(enum mant, enum man_type, | static enum rew rew_block(enum mant, enum man_type, | ||
const struct man_node *); | const struct man_node *); | ||
static int rew_warn(struct man *, | |||
struct man_node *, enum merr); | |||
const struct man_macro __man_macros[MAN_MAX] = { | const struct man_macro __man_macros[MAN_MAX] = { | ||
{ in_line_eoln, MAN_NSCOPED }, /* br */ | { in_line_eoln, MAN_NSCOPED }, /* br */ | ||
{ in_line_eoln, 0 }, /* TH */ | { in_line_eoln, MAN_BSCOPE }, /* TH */ | ||
{ blk_imp, MAN_SCOPED }, /* SH */ | { blk_imp, MAN_BSCOPE | MAN_SCOPED }, /* SH */ | ||
{ blk_imp, MAN_SCOPED }, /* SS */ | { blk_imp, MAN_BSCOPE | MAN_SCOPED }, /* SS */ | ||
{ blk_imp, MAN_SCOPED | MAN_FSCOPED }, /* TP */ | { blk_imp, MAN_BSCOPE | MAN_SCOPED | MAN_FSCOPED }, /* TP */ | ||
{ blk_imp, 0 }, /* LP */ | { blk_imp, MAN_BSCOPE }, /* LP */ | ||
{ blk_imp, 0 }, /* PP */ | { blk_imp, MAN_BSCOPE }, /* PP */ | ||
{ blk_imp, 0 }, /* P */ | { blk_imp, MAN_BSCOPE }, /* P */ | ||
{ blk_imp, 0 }, /* IP */ | { blk_imp, MAN_BSCOPE }, /* IP */ | ||
{ blk_imp, 0 }, /* HP */ | { blk_imp, MAN_BSCOPE }, /* HP */ | ||
{ in_line_eoln, MAN_SCOPED }, /* SM */ | { in_line_eoln, MAN_SCOPED }, /* SM */ | ||
{ in_line_eoln, MAN_SCOPED }, /* SB */ | { in_line_eoln, MAN_SCOPED }, /* SB */ | ||
{ in_line_eoln, 0 }, /* BI */ | { in_line_eoln, 0 }, /* BI */ | ||
|
|
||
{ in_line_eoln, 0 }, /* IR */ | { in_line_eoln, 0 }, /* IR */ | ||
{ in_line_eoln, 0 }, /* RI */ | { in_line_eoln, 0 }, /* RI */ | ||
{ in_line_eoln, MAN_NSCOPED }, /* na */ | { in_line_eoln, MAN_NSCOPED }, /* na */ | ||
{ in_line_eoln, 0 }, /* i */ | |||
{ in_line_eoln, MAN_NSCOPED }, /* sp */ | { in_line_eoln, MAN_NSCOPED }, /* sp */ | ||
{ in_line_eoln, 0 }, /* nf */ | { in_line_eoln, MAN_BSCOPE }, /* nf */ | ||
{ in_line_eoln, 0 }, /* fi */ | { in_line_eoln, MAN_BSCOPE }, /* fi */ | ||
{ in_line_eoln, 0 }, /* r */ | |||
{ blk_close, 0 }, /* RE */ | { blk_close, 0 }, /* RE */ | ||
{ blk_exp, MAN_EXPLICIT }, /* RS */ | { blk_exp, MAN_BSCOPE | MAN_EXPLICIT }, /* RS */ | ||
{ in_line_eoln, 0 }, /* DT */ | { in_line_eoln, 0 }, /* DT */ | ||
{ in_line_eoln, 0 }, /* UC */ | { in_line_eoln, 0 }, /* UC */ | ||
{ in_line_eoln, 0 }, /* PD */ | { in_line_eoln, 0 }, /* PD */ | ||
{ in_line_eoln, MAN_NSCOPED }, /* Sp */ | { in_line_eoln, 0 }, /* AT */ | ||
{ in_line_eoln, 0 }, /* Vb */ | { in_line_eoln, 0 }, /* in */ | ||
{ in_line_eoln, 0 }, /* Ve */ | { in_line_eoln, 0 }, /* ft */ | ||
{ in_line_eoln, 0 }, /* OP */ | |||
{ in_line_eoln, MAN_BSCOPE }, /* EX */ | |||
{ in_line_eoln, MAN_BSCOPE }, /* EE */ | |||
{ blk_exp, MAN_BSCOPE | MAN_EXPLICIT }, /* UR */ | |||
{ blk_close, 0 }, /* UE */ | |||
{ in_line_eoln, 0 }, /* ll */ | |||
}; | }; | ||
const struct man_macro * const man_macros = __man_macros; | const struct man_macro * const man_macros = __man_macros; | ||
/* | int | ||
* Warn when "n" is an explicit non-roff macro. | man_unscope(struct man *man, const struct man_node *to) | ||
*/ | |||
static int | |||
rew_warn(struct man *m, struct man_node *n, enum merr er) | |||
{ | { | ||
struct man_node *n; | |||
if (er == WERRMAX || MAN_BLOCK != n->type) | man->next = MAN_NEXT_SIBLING; | ||
return(1); | to = to->parent; | ||
if (MAN_VALID & n->flags) | n = man->last; | ||
return(1); | while (n != to) { | ||
if ( ! (MAN_EXPLICIT & man_macros[n->tok].flags)) | |||
return(1); | |||
return(man_nwarn(m, n, er)); | |||
} | |||
/* Reached the end of the document? */ | |||
/* | if (to == NULL && ! (n->flags & MAN_VALID)) { | ||
* Rewind scope. If a code "er" != WERRMAX has been provided, it will | if (man->flags & (MAN_BLINE | MAN_ELINE) && | ||
* be used if an explicit block scope is being closed out. | man_macros[n->tok].flags & MAN_SCOPED) { | ||
*/ | mandoc_vmsg(MANDOCERR_BLK_LINE, | ||
int | man->parse, n->line, n->pos, | ||
man_unscope(struct man *m, const struct man_node *n, enum merr er) | "EOF breaks %s", | ||
{ | man_macronames[n->tok]); | ||
if (man->flags & MAN_ELINE) | |||
man->flags &= ~MAN_ELINE; | |||
else { | |||
assert(n->type == MAN_HEAD); | |||
n = n->parent; | |||
man->flags &= ~MAN_BLINE; | |||
} | |||
man->last = n; | |||
n = n->parent; | |||
man_node_delete(man, man->last); | |||
continue; | |||
} | |||
if (n->type == MAN_BLOCK && | |||
man_macros[n->tok].flags & MAN_EXPLICIT) | |||
mandoc_msg(MANDOCERR_BLK_NOEND, | |||
man->parse, n->line, n->pos, | |||
man_macronames[n->tok]); | |||
} | |||
assert(n); | /* | ||
* We might delete the man->last node | |||
/* LINTED */ | * in the post-validation phase. | ||
while (m->last != n) { | * Save a pointer to the parent such that | ||
if ( ! rew_warn(m, m->last, er)) | * we know where to continue the iteration. | ||
*/ | |||
man->last = n; | |||
n = n->parent; | |||
if ( ! man_valid_post(man)) | |||
return(0); | return(0); | ||
if ( ! man_valid_post(m)) | |||
return(0); | |||
if ( ! man_action_post(m)) | |||
return(0); | |||
m->last = m->last->parent; | |||
assert(m->last); | |||
} | } | ||
if ( ! rew_warn(m, m->last, er)) | |||
return(0); | |||
if ( ! man_valid_post(m)) | |||
return(0); | |||
if ( ! man_action_post(m)) | |||
return(0); | |||
m->next = MAN_ROOT == m->last->type ? | |||
MAN_NEXT_CHILD : MAN_NEXT_SIBLING; | |||
return(1); | return(1); | ||
} | } | ||
static enum rew | static enum rew | ||
rew_block(enum mant ntok, enum man_type type, const struct man_node *n) | rew_block(enum mant ntok, enum man_type type, const struct man_node *n) | ||
{ | { | ||
if (MAN_BLOCK == type && ntok == n->parent->tok && | if (MAN_BLOCK == type && ntok == n->parent->tok && | ||
MAN_BODY == n->parent->type) | MAN_BODY == n->parent->type) | ||
return(REW_REWIND); | return(REW_REWIND); | ||
return(ntok == n->tok ? REW_HALT : REW_NOHALT); | return(ntok == n->tok ? REW_HALT : REW_NOHALT); | ||
} | } | ||
/* | /* | ||
* There are three scope levels: scoped to the root (all), scoped to the | * There are three scope levels: scoped to the root (all), scoped to the | ||
* section (all less sections), and scoped to subsections (all less | * section (all less sections), and scoped to subsections (all less | ||
* sections and subsections). | * sections and subsections). | ||
*/ | */ | ||
static enum rew | static enum rew | ||
rew_dohalt(enum mant tok, enum man_type type, const struct man_node *n) | rew_dohalt(enum mant tok, enum man_type type, const struct man_node *n) | ||
{ | { | ||
enum rew c; | enum rew c; | ||
|
|
||
return(REW_NOHALT); | return(REW_NOHALT); | ||
/* First: rewind to ourselves. */ | /* First: rewind to ourselves. */ | ||
if (type == n->type && tok == n->tok) | if (type == n->type && tok == n->tok) { | ||
return(REW_REWIND); | if (MAN_EXPLICIT & man_macros[n->tok].flags) | ||
return(REW_HALT); | |||
else | |||
return(REW_REWIND); | |||
} | |||
/* | /* | ||
* Next follow the implicit scope-smashings as defined by man.7: | * Next follow the implicit scope-smashings as defined by man.7: | ||
* section, sub-section, etc. | * section, sub-section, etc. | ||
*/ | */ | ||
switch (tok) { | switch (tok) { | ||
case (MAN_SH): | case MAN_SH: | ||
break; | break; | ||
case (MAN_SS): | case MAN_SS: | ||
/* Rewind to a section, if a block. */ | /* Rewind to a section, if a block. */ | ||
if (REW_NOHALT != (c = rew_block(MAN_SH, type, n))) | if (REW_NOHALT != (c = rew_block(MAN_SH, type, n))) | ||
return(c); | return(c); | ||
break; | break; | ||
case (MAN_RS): | case MAN_RS: | ||
/* Preserve empty paragraphs before RS. */ | |||
if (0 == n->nchild && (MAN_P == n->tok || | |||
MAN_PP == n->tok || MAN_LP == n->tok)) | |||
return(REW_HALT); | |||
/* Rewind to a subsection, if a block. */ | /* Rewind to a subsection, if a block. */ | ||
if (REW_NOHALT != (c = rew_block(MAN_SS, type, n))) | if (REW_NOHALT != (c = rew_block(MAN_SS, type, n))) | ||
return(c); | return(c); | ||
|
|
||
return(REW_NOHALT); | return(REW_NOHALT); | ||
} | } | ||
/* | /* | ||
* Rewinding entails ascending the parse tree until a coherent point, | * Rewinding entails ascending the parse tree until a coherent point, | ||
* for example, the `SH' macro will close out any intervening `SS' | * for example, the `SH' macro will close out any intervening `SS' | ||
* scopes. When a scope is closed, it must be validated and actioned. | * scopes. When a scope is closed, it must be validated and actioned. | ||
*/ | */ | ||
static int | static int | ||
rew_scope(enum man_type type, struct man *m, enum mant tok) | rew_scope(enum man_type type, struct man *man, enum mant tok) | ||
{ | { | ||
struct man_node *n; | struct man_node *n; | ||
enum rew c; | enum rew c; | ||
/* LINTED */ | for (n = man->last; n; n = n->parent) { | ||
for (n = m->last; n; n = n->parent) { | /* | ||
/* | |||
* Whether we should stop immediately (REW_HALT), stop | * Whether we should stop immediately (REW_HALT), stop | ||
* and rewind until this point (REW_REWIND), or keep | * and rewind until this point (REW_REWIND), or keep | ||
* rewinding (REW_NOHALT). | * rewinding (REW_NOHALT). | ||
|
|
||
break; | break; | ||
} | } | ||
/* | /* | ||
* Rewind until the current point. Warn if we're a roff | * Rewind until the current point. Warn if we're a roff | ||
* instruction that's mowing over explicit scopes. | * instruction that's mowing over explicit scopes. | ||
*/ | */ | ||
assert(n); | assert(n); | ||
return(man_unscope(m, n, WERRMAX)); | return(man_unscope(man, n)); | ||
} | } | ||
/* | /* | ||
* Close out a generic explicit macro. | * Close out a generic explicit macro. | ||
*/ | */ | ||
/* ARGSUSED */ | |||
int | int | ||
blk_close(MACRO_PROT_ARGS) | blk_close(MACRO_PROT_ARGS) | ||
{ | { | ||
enum mant ntok; | enum mant ntok; | ||
const struct man_node *nn; | const struct man_node *nn; | ||
switch (tok) { | switch (tok) { | ||
case (MAN_RE): | case MAN_RE: | ||
ntok = MAN_RS; | ntok = MAN_RS; | ||
break; | break; | ||
case MAN_UE: | |||
ntok = MAN_UR; | |||
break; | |||
default: | default: | ||
abort(); | abort(); | ||
/* NOTREACHED */ | /* NOTREACHED */ | ||
} | } | ||
for (nn = m->last->parent; nn; nn = nn->parent) | for (nn = man->last->parent; nn; nn = nn->parent) | ||
if (ntok == nn->tok) | if (ntok == nn->tok && MAN_BLOCK == nn->type) | ||
break; | break; | ||
if (NULL == nn) | if (NULL == nn) { | ||
if ( ! man_pwarn(m, line, ppos, WNOSCOPE)) | mandoc_msg(MANDOCERR_BLK_NOTOPEN, man->parse, | ||
line, ppos, man_macronames[tok]); | |||
if ( ! rew_scope(MAN_BLOCK, man, MAN_PP)) | |||
return(0); | return(0); | ||
} else | |||
man_unscope(man, nn); | |||
if ( ! rew_scope(MAN_BODY, m, ntok)) | |||
return(0); | |||
if ( ! rew_scope(MAN_BLOCK, m, ntok)) | |||
return(0); | |||
return(1); | return(1); | ||
} | } | ||
int | int | ||
blk_exp(MACRO_PROT_ARGS) | blk_exp(MACRO_PROT_ARGS) | ||
{ | { | ||
int w, la; | struct man_node *n; | ||
int la; | |||
char *p; | char *p; | ||
/* | /* Close out prior implicit scopes. */ | ||
* Close out prior scopes. "Regular" explicit macros cannot be | |||
* nested, but we allow roff macros to be placed just about | |||
* anywhere. | |||
*/ | |||
if ( ! rew_scope(MAN_BODY, m, tok)) | if ( ! rew_scope(MAN_BLOCK, man, tok)) | ||
return(0); | return(0); | ||
if ( ! rew_scope(MAN_BLOCK, m, tok)) | |||
return(0); | |||
if ( ! man_block_alloc(m, line, ppos, tok)) | if ( ! man_block_alloc(man, line, ppos, tok)) | ||
return(0); | return(0); | ||
if ( ! man_head_alloc(m, line, ppos, tok)) | if ( ! man_head_alloc(man, line, ppos, tok)) | ||
return(0); | return(0); | ||
for (;;) { | for (;;) { | ||
la = *pos; | la = *pos; | ||
w = man_args(m, line, pos, buf, &p); | if ( ! man_args(man, line, pos, buf, &p)) | ||
if (-1 == w) | |||
return(0); | |||
if (0 == w) | |||
break; | break; | ||
if ( ! man_word_alloc(man, line, la, p)) | |||
if ( ! man_word_alloc(m, line, la, p)) | |||
return(0); | return(0); | ||
} | } | ||
assert(m); | assert(man); | ||
assert(tok != MAN_MAX); | assert(tok != MAN_MAX); | ||
if ( ! rew_scope(MAN_HEAD, m, tok)) | for (n = man->last; n; n = n->parent) { | ||
return(0); | if (n->tok != tok) | ||
return(man_body_alloc(m, line, ppos, tok)); | continue; | ||
assert(MAN_HEAD == n->type); | |||
man_unscope(man, n); | |||
break; | |||
} | |||
return(man_body_alloc(man, line, ppos, tok)); | |||
} | } | ||
/* | /* | ||
* Parse an implicit-block macro. These contain a MAN_HEAD and a | * Parse an implicit-block macro. These contain a MAN_HEAD and a | ||
* MAN_BODY contained within a MAN_BLOCK. Rules for closing out other | * MAN_BODY contained within a MAN_BLOCK. Rules for closing out other | ||
|
|
||
int | int | ||
blk_imp(MACRO_PROT_ARGS) | blk_imp(MACRO_PROT_ARGS) | ||
{ | { | ||
int w, la; | int la; | ||
char *p; | char *p; | ||
struct man_node *n; | struct man_node *n; | ||
/* Close out prior scopes. */ | /* Close out prior scopes. */ | ||
if ( ! rew_scope(MAN_BODY, m, tok)) | if ( ! rew_scope(MAN_BODY, man, tok)) | ||
return(0); | return(0); | ||
if ( ! rew_scope(MAN_BLOCK, m, tok)) | if ( ! rew_scope(MAN_BLOCK, man, tok)) | ||
return(0); | return(0); | ||
/* Allocate new block & head scope. */ | /* Allocate new block & head scope. */ | ||
if ( ! man_block_alloc(m, line, ppos, tok)) | if ( ! man_block_alloc(man, line, ppos, tok)) | ||
return(0); | return(0); | ||
if ( ! man_head_alloc(m, line, ppos, tok)) | if ( ! man_head_alloc(man, line, ppos, tok)) | ||
return(0); | return(0); | ||
n = m->last; | n = man->last; | ||
/* Add line arguments. */ | /* Add line arguments. */ | ||
for (;;) { | for (;;) { | ||
la = *pos; | la = *pos; | ||
w = man_args(m, line, pos, buf, &p); | if ( ! man_args(man, line, pos, buf, &p)) | ||
if (-1 == w) | |||
return(0); | |||
if (0 == w) | |||
break; | break; | ||
if ( ! man_word_alloc(man, line, la, p)) | |||
if ( ! man_word_alloc(m, line, la, p)) | |||
return(0); | return(0); | ||
} | } | ||
|
|
||
if (MAN_SCOPED & man_macros[tok].flags) { | if (MAN_SCOPED & man_macros[tok].flags) { | ||
/* If we're forcing scope (`TP'), keep it open. */ | /* If we're forcing scope (`TP'), keep it open. */ | ||
if (MAN_FSCOPED & man_macros[tok].flags) { | if (MAN_FSCOPED & man_macros[tok].flags) { | ||
m->flags |= MAN_BLINE; | man->flags |= MAN_BLINE; | ||
return(1); | return(1); | ||
} else if (n == m->last) { | } else if (n == man->last) { | ||
m->flags |= MAN_BLINE; | man->flags |= MAN_BLINE; | ||
return(1); | return(1); | ||
} | } | ||
} | } | ||
if ( ! rew_scope(MAN_HEAD, m, tok)) | if ( ! rew_scope(MAN_HEAD, man, tok)) | ||
return(0); | return(0); | ||
return(man_body_alloc(m, line, ppos, tok)); | return(man_body_alloc(man, line, ppos, tok)); | ||
} | } | ||
int | int | ||
in_line_eoln(MACRO_PROT_ARGS) | in_line_eoln(MACRO_PROT_ARGS) | ||
{ | { | ||
int w, la; | int la; | ||
char *p; | char *p; | ||
struct man_node *n; | struct man_node *n; | ||
if ( ! man_elem_alloc(m, line, ppos, tok)) | if ( ! man_elem_alloc(man, line, ppos, tok)) | ||
return(0); | return(0); | ||
n = m->last; | n = man->last; | ||
for (;;) { | for (;;) { | ||
la = *pos; | la = *pos; | ||
w = man_args(m, line, pos, buf, &p); | if ( ! man_args(man, line, pos, buf, &p)) | ||
if (-1 == w) | |||
return(0); | |||
if (0 == w) | |||
break; | break; | ||
if ( ! man_word_alloc(m, line, la, p)) | if ( ! man_word_alloc(man, line, la, p)) | ||
return(0); | return(0); | ||
} | } | ||
/* | /* | ||
* Append MAN_EOS in case the last snipped argument | |||
* ends with a dot, e.g. `.IR syslog (3).' | |||
*/ | |||
if (n != man->last && | |||
mandoc_eos(man->last->string, strlen(man->last->string))) | |||
man->last->flags |= MAN_EOS; | |||
/* | |||
* If no arguments are specified and this is MAN_SCOPED (i.e., | * If no arguments are specified and this is MAN_SCOPED (i.e., | ||
* next-line scoped), then set our mode to indicate that we're | * next-line scoped), then set our mode to indicate that we're | ||
* waiting for terms to load into our context. | * waiting for terms to load into our context. | ||
*/ | */ | ||
if (n == m->last && MAN_SCOPED & man_macros[tok].flags) { | if (n == man->last && MAN_SCOPED & man_macros[tok].flags) { | ||
assert( ! (MAN_NSCOPED & man_macros[tok].flags)); | assert( ! (MAN_NSCOPED & man_macros[tok].flags)); | ||
m->flags |= MAN_ELINE; | man->flags |= MAN_ELINE; | ||
return(1); | return(1); | ||
} | } | ||
/* Set ignorable context, if applicable. */ | assert(MAN_ROOT != man->last->type); | ||
man->next = MAN_NEXT_SIBLING; | |||
if (MAN_NSCOPED & man_macros[tok].flags) { | |||
assert( ! (MAN_SCOPED & man_macros[tok].flags)); | |||
m->flags |= MAN_ILINE; | |||
} | |||
/* | /* | ||
* Rewind our element scope. Note that when TH is pruned, we'll | * Rewind our element scope. Note that when TH is pruned, we'll | ||
* be back at the root, so make sure that we don't clobber as | * be back at the root, so make sure that we don't clobber as | ||
* its sibling. | * its sibling. | ||
*/ | */ | ||
for ( ; m->last; m->last = m->last->parent) { | for ( ; man->last; man->last = man->last->parent) { | ||
if (m->last == n) | if (man->last == n) | ||
break; | break; | ||
if (m->last->type == MAN_ROOT) | if (man->last->type == MAN_ROOT) | ||
break; | break; | ||
if ( ! man_valid_post(m)) | if ( ! man_valid_post(man)) | ||
return(0); | return(0); | ||
if ( ! man_action_post(m)) | |||
return(0); | |||
} | } | ||
assert(m->last); | assert(man->last); | ||
/* | /* | ||
* Same here regarding whether we're back at the root. | * Same here regarding whether we're back at the root. | ||
*/ | */ | ||
if (m->last->type != MAN_ROOT && ! man_valid_post(m)) | if (man->last->type != MAN_ROOT && ! man_valid_post(man)) | ||
return(0); | return(0); | ||
if (m->last->type != MAN_ROOT && ! man_action_post(m)) | |||
return(0); | |||
m->next = MAN_ROOT == m->last->type ? | |||
MAN_NEXT_CHILD : MAN_NEXT_SIBLING; | |||
return(1); | return(1); | ||
} | } | ||
int | int | ||
man_macroend(struct man *m) | man_macroend(struct man *man) | ||
{ | { | ||
return(man_unscope(m, m->first, WEXITSCOPE)); | return(man_unscope(man, man->first)); | ||
} | } | ||
static int | |||
man_args(struct man *man, int line, int *pos, char *buf, char **v) | |||
{ | |||
char *start; | |||
assert(*pos); | |||
*v = start = buf + *pos; | |||
assert(' ' != *start); | |||
if ('\0' == *start) | |||
return(0); | |||
*v = mandoc_getarg(man->parse, v, line, pos); | |||
return(1); | |||
} |