mandoc/mdoc.c - diff

Return to mdoc.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/mdoc.c between version 1.28 and 1.50

version 1.28, 2009/01/12 16:39:57

version 1.50, 2009/03/02 17:14:46

Line 26

#include "private.h"

* Main caller in the libmdoc library. This begins the parsing routine,

* handles allocation of data, and so forth. Most of the "work" is done

* in macro.c and validate.c.

static struct mdoc_arg *argdup(size_t, const struct mdoc_arg *);

static void argfree(size_t, struct mdoc_arg *);

static void argcpy(struct mdoc_arg *,

const struct mdoc_arg *);

static struct mdoc_node *mdoc_node_alloc(const struct mdoc *);

static int mdoc_node_append(struct mdoc *,

struct mdoc_node *);

static void mdoc_elem_free(struct mdoc_elem *);

static void mdoc_text_free(struct mdoc_text *);

const char *const __mdoc_macronames[MDOC_MAX] = {

"\\\"", "Dd", "Dt", "Os",

"Sh", "Ss", "Pp", "D1",

Line 83 const char *const __mdoc_argnames[MDOC_ARG_MAX] = {

Line 101 const char *const __mdoc_argnames[MDOC_ARG_MAX] = {

"emphasis", "symbolic",

};

const struct mdoc_macro __mdoc_macros[MDOC_MAX] = {

{ NULL, 0 }, /* \" */

{ macro_constant, MDOC_PROLOGUE }, /* Dd */

{ macro_constant, MDOC_PROLOGUE }, /* Dt */

{ macro_constant, MDOC_PROLOGUE }, /* Os */

{ macro_scoped, 0 }, /* Sh */

{ macro_scoped, 0 }, /* Ss */

{ macro_text, 0 }, /* Pp */

{ macro_scoped_line, MDOC_PARSED }, /* D1 */

{ macro_scoped_line, MDOC_PARSED }, /* Dl */

{ macro_scoped, MDOC_EXPLICIT }, /* Bd */

{ macro_close_explicit, 0 }, /* Ed */

{ macro_scoped, MDOC_EXPLICIT }, /* Bl */

{ macro_close_explicit, 0 }, /* El */

{ macro_scoped, MDOC_NESTED | MDOC_PARSED | MDOC_TABSEP}, /* It */

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

{ macro_constant, MDOC_PARSED }, /* An */

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

{ macro_constant, MDOC_QUOTABLE }, /* Cd */

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

{ macro_text, MDOC_CALLABLE | MDOC_PARSED }, /* Dv */

{ macro_text, MDOC_CALLABLE | MDOC_PARSED }, /* Er */

{ macro_text, MDOC_CALLABLE | MDOC_PARSED }, /* Ev */

{ macro_constant, 0 }, /* Ex */

{ macro_text, MDOC_CALLABLE | MDOC_QUOTABLE | MDOC_PARSED }, /* Fa */

{ macro_constant, 0 }, /* Fd */

{ macro_text, MDOC_CALLABLE | MDOC_PARSED }, /* Fl */

{ macro_text, MDOC_CALLABLE | MDOC_QUOTABLE | MDOC_PARSED }, /* Fn */

{ macro_text, MDOC_PARSED }, /* Ft */

{ macro_text, MDOC_CALLABLE | MDOC_PARSED }, /* Ic */

{ macro_constant, 0 }, /* In */

{ macro_text, MDOC_CALLABLE | MDOC_PARSED }, /* Li */

{ macro_constant, 0 }, /* Nd */

{ macro_text, MDOC_CALLABLE | MDOC_PARSED }, /* Nm */

{ macro_scoped_line, MDOC_CALLABLE | MDOC_PARSED }, /* Op */

{ macro_obsolete, 0 }, /* Ot */

{ macro_text, MDOC_CALLABLE | MDOC_PARSED }, /* Pa */

{ macro_constant, 0 }, /* Rv */

/* XXX - .St supposed to be (but isn't) callable. */

{ macro_constant_delimited, MDOC_PARSED }, /* St */

{ macro_text, MDOC_CALLABLE | MDOC_PARSED }, /* Va */

{ macro_text, MDOC_CALLABLE | MDOC_PARSED }, /* Vt */

{ macro_text, MDOC_CALLABLE | MDOC_PARSED }, /* Xr */

{ macro_constant, MDOC_QUOTABLE }, /* %A */

{ macro_constant, MDOC_QUOTABLE }, /* %B */

{ macro_constant, MDOC_QUOTABLE }, /* %D */

{ macro_constant, MDOC_QUOTABLE }, /* %I */

{ macro_constant, MDOC_QUOTABLE }, /* %J */

{ macro_constant, MDOC_QUOTABLE }, /* %N */

{ macro_constant, MDOC_QUOTABLE }, /* %O */

{ macro_constant, MDOC_QUOTABLE }, /* %P */

{ macro_constant, MDOC_QUOTABLE }, /* %R */

{ macro_constant, MDOC_QUOTABLE }, /* %T */

{ macro_constant, MDOC_QUOTABLE }, /* %V */

{ macro_close_explicit, MDOC_CALLABLE | MDOC_PARSED }, /* Ac */

{ macro_constant_scoped, MDOC_CALLABLE | MDOC_PARSED }, /* Ao */

{ macro_scoped_line, MDOC_CALLABLE | MDOC_PARSED }, /* Aq */

{ macro_constant, 0 }, /* At */

{ macro_close_explicit, MDOC_CALLABLE | MDOC_PARSED }, /* Bc */

{ macro_scoped, MDOC_EXPLICIT }, /* Bf */

{ macro_constant_scoped, MDOC_CALLABLE | MDOC_PARSED }, /* Bo */

{ macro_scoped_line, MDOC_CALLABLE | MDOC_PARSED }, /* Bq */

{ macro_constant_delimited, MDOC_PARSED }, /* Bsx */

{ macro_constant_delimited, MDOC_PARSED }, /* Bx */

{ macro_constant, 0 }, /* Db */

{ macro_close_explicit, MDOC_CALLABLE | MDOC_PARSED }, /* Dc */

{ macro_constant_scoped, MDOC_CALLABLE | MDOC_PARSED }, /* Do */

{ macro_scoped_line, MDOC_CALLABLE | MDOC_PARSED }, /* Dq */

{ macro_close_explicit, MDOC_CALLABLE | MDOC_PARSED }, /* Ec */

{ macro_close_explicit, 0 }, /* Ef */

{ macro_text, MDOC_CALLABLE | MDOC_PARSED }, /* Em */

{ macro_constant_scoped, MDOC_CALLABLE | MDOC_PARSED }, /* Eo */

{ macro_constant_delimited, MDOC_PARSED }, /* Fx */

{ macro_text, MDOC_PARSED }, /* Ms */

{ macro_constant_delimited, MDOC_CALLABLE | MDOC_PARSED }, /* No */

{ macro_constant_delimited, MDOC_CALLABLE | MDOC_PARSED }, /* Ns */

{ macro_constant_delimited, MDOC_PARSED }, /* Nx */

{ macro_constant_delimited, MDOC_PARSED }, /* Ox */

{ macro_close_explicit, MDOC_CALLABLE | MDOC_PARSED }, /* Pc */

{ macro_constant, MDOC_PARSED }, /* Pf */

{ macro_constant_scoped, MDOC_CALLABLE | MDOC_PARSED }, /* Po */

{ macro_scoped_line, MDOC_CALLABLE | MDOC_PARSED }, /* Pq */

{ macro_close_explicit, MDOC_CALLABLE | MDOC_PARSED }, /* Qc */

{ macro_scoped_line, MDOC_CALLABLE | MDOC_PARSED }, /* Ql */

{ macro_constant_scoped, MDOC_CALLABLE | MDOC_PARSED }, /* Qo */

{ macro_scoped_line, MDOC_CALLABLE | MDOC_PARSED }, /* Qq */

{ macro_close_explicit, 0 }, /* Re */

{ macro_scoped, MDOC_EXPLICIT }, /* Rs */

{ macro_close_explicit, MDOC_CALLABLE | MDOC_PARSED }, /* Sc */

{ macro_constant_scoped, MDOC_CALLABLE | MDOC_PARSED }, /* So */

{ macro_scoped_line, MDOC_CALLABLE | MDOC_PARSED }, /* Sq */

{ macro_constant, 0 }, /* Sm */

{ macro_text, MDOC_CALLABLE | MDOC_PARSED }, /* Sx */

{ macro_text, MDOC_CALLABLE | MDOC_PARSED }, /* Sy */

{ macro_text, MDOC_CALLABLE | MDOC_PARSED }, /* Tn */

{ macro_constant_delimited, MDOC_PARSED }, /* Ux */

{ macro_close_explicit, MDOC_CALLABLE | MDOC_PARSED }, /* Xc */

{ macro_constant_scoped, MDOC_CALLABLE | MDOC_PARSED }, /* Xo */

/* XXX - .Fo supposed to be (but isn't) callable. */

{ macro_scoped, MDOC_EXPLICIT | MDOC_PARSED }, /* Fo */

/* XXX - .Fc supposed to be (but isn't) callable. */

{ macro_close_explicit, MDOC_PARSED }, /* Fc */

{ macro_constant_scoped, MDOC_CALLABLE | MDOC_PARSED }, /* Oo */

{ macro_close_explicit, MDOC_CALLABLE | MDOC_PARSED }, /* Oc */

{ macro_scoped, MDOC_EXPLICIT }, /* Bk */

{ macro_close_explicit, 0 }, /* Ek */

{ macro_constant, 0 }, /* Bt */

{ macro_constant, 0 }, /* Hf */

{ macro_obsolete, 0 }, /* Fr */

{ macro_constant, 0 }, /* Ud */

};

const char * const *mdoc_macronames = __mdoc_macronames;

const char * const *mdoc_argnames = __mdoc_argnames;

const struct mdoc_macro * const mdoc_macros = __mdoc_macros;

static struct mdoc_arg *argdup(size_t, const struct mdoc_arg *);

const struct mdoc_node *

static void argfree(size_t, struct mdoc_arg *);

mdoc_node(const struct mdoc *mdoc)

static void argcpy(struct mdoc_arg *,

{

const struct mdoc_arg *);

static void mdoc_node_freelist(struct mdoc_node *);

return(mdoc->first);

static int mdoc_node_append(struct mdoc *,

}

struct mdoc_node *);

static void mdoc_elem_free(struct mdoc_elem *);

static void mdoc_text_free(struct mdoc_text *);

const struct mdoc_node *

const struct mdoc_meta *

mdoc_result(struct mdoc *mdoc)

mdoc_meta(const struct mdoc *mdoc)

{

return(mdoc->first);

return(&mdoc->meta);

}

Line 228 mdoc_free(struct mdoc *mdoc)

Line 129 mdoc_free(struct mdoc *mdoc)

mdoc_node_freelist(mdoc->first);

if (mdoc->htab)

mdoc_tokhash_free(mdoc->htab);

if (mdoc->meta.title)

free(mdoc->meta.title);

if (mdoc->meta.os)

free(mdoc->meta.os);

if (mdoc->meta.name)

free(mdoc->meta.name);

free(mdoc);

}

Line 241 mdoc_alloc(void *data, const struct mdoc_cb *cb)

Line 148 mdoc_alloc(void *data, const struct mdoc_cb *cb)

p = xcalloc(1, sizeof(struct mdoc));

p->data = data;

(void)memcpy(&p->cb, cb, sizeof(struct mdoc_cb));

if (cb)

(void)memcpy(&p->cb, cb, sizeof(struct mdoc_cb));

p->last = xcalloc(1, sizeof(struct mdoc_node));

p->last->type = MDOC_ROOT;

Line 272 mdoc_endparse(struct mdoc *mdoc)

Line 180 mdoc_endparse(struct mdoc *mdoc)

}

* Main line-parsing routine. If the line is a macro-line (started with

* a '.' control character), then pass along to the parser, which parses

* subsequent macros until the end of line. If normal text, simply

* append the entire line to the chain.

int

mdoc_parseln(struct mdoc *mdoc, int line, char *buf)

{

Line 281 mdoc_parseln(struct mdoc *mdoc, int line, char *buf)

Line 195 mdoc_parseln(struct mdoc *mdoc, int line, char *buf)

if (MDOC_HALT & mdoc->flags)

return(0);

mdoc->linetok = 0;

if ('.' != *buf) {

if (SEC_PROLOGUE != mdoc->sec_lastn) {

if ( ! mdoc_word_alloc(mdoc, line, 0, buf))

* Free-form text. Not allowed in the prologue.

return(0);

mdoc->next = MDOC_NEXT_SIBLING;

if (SEC_PROLOGUE == mdoc->lastnamed)

return(1);

return(mdoc_perr(mdoc, line, 0,

}

"no text in prologue"));

return(mdoc_perr(mdoc, line, 0, ERR_SYNTAX_NOTEXT));

if ( ! mdoc_word_alloc(mdoc, line, 0, buf))

return(0);

mdoc->next = MDOC_NEXT_SIBLING;

return(1);

}

* Control-character detected. Begin the parsing sequence.

if (buf[1] && '\\' == buf[1])

if (buf[2] && '\"' == buf[2])

return(1);

i = 1;

while (buf[i] && ! isspace(buf[i]) && i < (int)sizeof(tmp))

while (buf[i] && ! isspace((int)buf[i]) && i < (int)sizeof(tmp))

i++;

if (i == (int)sizeof(tmp)) {

mdoc->flags |= MDOC_HALT;

return(mdoc_perr(mdoc, line, 1, ERR_MACRO_NOTSUP));

return(mdoc_perr(mdoc, line, 1, "unknown macro"));

} else if (i <= 2) {

mdoc->flags |= MDOC_HALT;

return(mdoc_perr(mdoc, line, 1, ERR_MACRO_NOTSUP));

return(mdoc_perr(mdoc, line, 1, "unknown macro"));

}

i--;

Line 314 mdoc_parseln(struct mdoc *mdoc, int line, char *buf)

Line 238 mdoc_parseln(struct mdoc *mdoc, int line, char *buf)

if (MDOC_MAX == (c = mdoc_find(mdoc, tmp))) {

mdoc->flags |= MDOC_HALT;

return(mdoc_perr(mdoc, line, 1, ERR_MACRO_NOTSUP));

return(mdoc_perr(mdoc, line, 1, "unknown macro"));

}

while (buf[i] && isspace(buf[i]))

while (buf[i] && isspace((int)buf[i]))

i++;

if ( ! mdoc_macro(mdoc, c, line, 1, &i, buf)) {

mdoc->flags |= MDOC_HALT;

return(0);

}

return(1);

}

void

mdoc_msg(struct mdoc *mdoc, const char *fmt, ...)

mdoc_vmsg(struct mdoc *mdoc, int ln, int pos, const char *fmt, ...)

{

struct mdoc_node *n;

va_list ap;

char buf[256];

va_list ap;

if (NULL == mdoc->cb.mdoc_msg)

return;

n = mdoc->last;

assert(n);

va_start(ap, fmt);

(void)vsnprintf(buf, sizeof(buf), fmt, ap);

(void)vsnprintf(buf, sizeof(buf) - 1, fmt, ap);

va_end(ap);

(*mdoc->cb.mdoc_msg)(mdoc->data, ln, pos, buf);

(*mdoc->cb.mdoc_msg)(mdoc->data, n->line, n->pos, buf);

}

int

mdoc_perr(struct mdoc *mdoc,

mdoc_verr(struct mdoc *mdoc, int ln, int pos,

int line, int pos, enum mdoc_err type)

const char *fmt, ...)

{

char buf[256];

va_list ap;

if (NULL == mdoc->cb.mdoc_err)

return(0);

return((*mdoc->cb.mdoc_err)(mdoc->data, line, pos, type));

va_start(ap, fmt);

(void)vsnprintf(buf, sizeof(buf) - 1, fmt, ap);

va_end(ap);

return((*mdoc->cb.mdoc_err)(mdoc->data, ln, pos, buf));

}

int

mdoc_pwarn(struct mdoc *mdoc,

mdoc_vwarn(struct mdoc *mdoc, int ln, int pos,

int line, int pos, enum mdoc_warn type)

enum mdoc_warn type, const char *fmt, ...)

{

char buf[256];

va_list ap;

if (NULL == mdoc->cb.mdoc_warn)

return(0);

return((*mdoc->cb.mdoc_warn)(mdoc->data, line, pos, type));

va_start(ap, fmt);

(void)vsnprintf(buf, sizeof(buf) - 1, fmt, ap);

va_end(ap);

return((*mdoc->cb.mdoc_warn)(mdoc->data, ln, pos, type, buf));

}

Line 376 mdoc_macro(struct mdoc *mdoc, int tok,

Line 308 mdoc_macro(struct mdoc *mdoc, int tok,

int ln, int ppos, int *pos, char *buf)

{

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

assert(mdoc_macros[tok].fp);

SEC_PROLOGUE == mdoc->sec_lastn)

return(mdoc_perr(mdoc, ln, ppos, ERR_SEC_PROLOGUE));

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

if (MDOC_PROLOGUE & mdoc_macros[tok].flags &&

return(mdoc_perr(mdoc, ln, ppos, ERR_MACRO_NOTSUP));

SEC_PROLOGUE != mdoc->lastnamed)

return(mdoc_perr(mdoc, ln, ppos, "macro disallowed in document body"));

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

SEC_PROLOGUE == mdoc->lastnamed)

return(mdoc_perr(mdoc, ln, ppos, "macro disallowed in document prologue"));

if (1 != ppos && ! (MDOC_CALLABLE & mdoc_macros[tok].flags))

return(mdoc_perr(mdoc, ln, ppos, ERR_MACRO_NOTCALL));

return(mdoc_perr(mdoc, ln, ppos, "macro not callable"));

return((*mdoc_macros[tok].fp)(mdoc, tok, ln, ppos, pos, buf));

}

Line 393 mdoc_macro(struct mdoc *mdoc, int tok,

Line 325 mdoc_macro(struct mdoc *mdoc, int tok,

static int

mdoc_node_append(struct mdoc *mdoc, struct mdoc_node *p)

{

const char *on, *ot, *act;

const char *nn, *nt, *on, *ot, *act;

assert(mdoc->last);

assert(mdoc->first);

assert(MDOC_ROOT != p->type);

if (MDOC_TEXT == mdoc->last->type)

/* See if we exceed the suggest line-max. */

on = "<text>";

else if (MDOC_ROOT == mdoc->last->type)

on = "<root>";

else

on = mdoc_macronames[mdoc->last->tok];

/* FIXME: put this into util.c. */

switch (p->type) {

switch (mdoc->last->type) {

case (MDOC_TEXT):

ot = "text";

/* FALLTHROUGH */

break;

case (MDOC_BODY):

ot = "body";

break;

case (MDOC_ELEM):

ot = "elem";

/* FALLTHROUGH */

break;

case (MDOC_HEAD):

ot = "head";

break;

case (MDOC_TAIL):

ot = "tail";

break;

case (MDOC_BLOCK):

ot = "block";

mdoc->linetok++;

break;

case (MDOC_ROOT):

ot = "root";

break;

default:

abort();

break;

/* NOTREACHED */

}

/* This sort-of works (re-opening of text macros...). */

if (mdoc->linetok > MDOC_LINEARG_SOFTMAX)

if ( ! mdoc_nwarn(mdoc, p, WARN_COMPAT,

"suggested %d tokens per line exceeded (has %d)",

MDOC_LINEARG_SOFTMAX, mdoc->linetok))

return(0);

if (MDOC_TEXT == mdoc->last->type)

on = "<text>";

else if (MDOC_ROOT == mdoc->last->type)

on = "<root>";

else

on = mdoc_macronames[mdoc->last->tok];

if (MDOC_TEXT == p->type)

nn = "<text>";

else if (MDOC_ROOT == p->type)

nn = "<root>";

else

nn = mdoc_macronames[p->tok];

ot = mdoc_type2a(mdoc->last->type);

nt = mdoc_type2a(p->type);

switch (mdoc->next) {

case (MDOC_NEXT_SIBLING):

mdoc->last->next = p;

Line 453 mdoc_node_append(struct mdoc *mdoc, struct mdoc_node *

Line 388 mdoc_node_append(struct mdoc *mdoc, struct mdoc_node *

if ( ! mdoc_valid_pre(mdoc, p))

return(0);

if ( ! mdoc_action_pre(mdoc, p))

return(0);

switch (p->type) {

case (MDOC_HEAD):

Line 474 mdoc_node_append(struct mdoc *mdoc, struct mdoc_node *

Line 407 mdoc_node_append(struct mdoc *mdoc, struct mdoc_node *

}

mdoc->last = p;

mdoc_msg(mdoc, "parse: %s of %s `%s'", act, ot, on);

mdoc_msg(mdoc, "parse: %s `%s' %s of %s `%s'",

nt, nn, act, ot, on);

return(1);

}

static struct mdoc_node *

mdoc_node_alloc(const struct mdoc *mdoc)

{

struct mdoc_node *p;

p = xcalloc(1, sizeof(struct mdoc_node));

p->sec = mdoc->lastsec;

return(p);

}

int

mdoc_tail_alloc(struct mdoc *mdoc, int line, int pos, int tok)

{

Line 487 mdoc_tail_alloc(struct mdoc *mdoc, int line, int pos,

Line 433 mdoc_tail_alloc(struct mdoc *mdoc, int line, int pos,

assert(mdoc->first);

assert(mdoc->last);

p = xcalloc(1, sizeof(struct mdoc_node));

p = mdoc_node_alloc(mdoc);

p->line = line;

p->pos = pos;

Line 506 mdoc_head_alloc(struct mdoc *mdoc, int line, int pos,

Line 452 mdoc_head_alloc(struct mdoc *mdoc, int line, int pos,

assert(mdoc->first);

assert(mdoc->last);

p = xcalloc(1, sizeof(struct mdoc_node));

p = mdoc_node_alloc(mdoc);

p->line = line;

p->pos = pos;

Line 525 mdoc_body_alloc(struct mdoc *mdoc, int line, int pos,

Line 471 mdoc_body_alloc(struct mdoc *mdoc, int line, int pos,

assert(mdoc->first);

assert(mdoc->last);

p = xcalloc(1, sizeof(struct mdoc_node));

p = mdoc_node_alloc(mdoc);

p->line = line;

p->pos = pos;

Line 541 mdoc_root_alloc(struct mdoc *mdoc)

Line 487 mdoc_root_alloc(struct mdoc *mdoc)

{

struct mdoc_node *p;

p = xcalloc(1, sizeof(struct mdoc_node));

p = mdoc_node_alloc(mdoc);

p->type = MDOC_ROOT;

Line 555 mdoc_block_alloc(struct mdoc *mdoc, int line, int pos,

Line 501 mdoc_block_alloc(struct mdoc *mdoc, int line, int pos,

{

struct mdoc_node *p;

p = xcalloc(1, sizeof(struct mdoc_node));

p = mdoc_node_alloc(mdoc);

p->pos = pos;

p->line = line;

Line 574 mdoc_elem_alloc(struct mdoc *mdoc, int line, int pos,

Line 520 mdoc_elem_alloc(struct mdoc *mdoc, int line, int pos,

{

struct mdoc_node *p;

p = xcalloc(1, sizeof(struct mdoc_node));

p = mdoc_node_alloc(mdoc);

p->line = line;

p->pos = pos;

Line 593 mdoc_word_alloc(struct mdoc *mdoc,

Line 539 mdoc_word_alloc(struct mdoc *mdoc,

{

struct mdoc_node *p;

p = xcalloc(1, sizeof(struct mdoc_node));

p = mdoc_node_alloc(mdoc);

p->line = line;

p->pos = pos;

p->type = MDOC_TEXT;

Line 672 mdoc_node_free(struct mdoc_node *p)

Line 619 mdoc_node_free(struct mdoc_node *p)

}

static void

void

mdoc_node_freelist(struct mdoc_node *p)

{

Line 724 argdup(size_t argsz, const struct mdoc_arg *args)

Line 671 argdup(size_t argsz, const struct mdoc_arg *args)

return(pp);

}

/* FIXME: deprecate. */

char *

mdoc_node2a(struct mdoc_node *node)

{

static char buf[64];

assert(node);

buf[0] = 0;

(void)xstrlcat(buf, mdoc_type2a(node->type), 64);

if (MDOC_ROOT == node->type)

return(buf);

(void)xstrlcat(buf, " `", 64);

if (MDOC_TEXT == node->type)

(void)xstrlcat(buf, node->data.text.string, 64);

else

(void)xstrlcat(buf, mdoc_macronames[node->tok], 64);

(void)xstrlcat(buf, "'", 64);

return(buf);

}

CVSweb