mandoc/roff.c - diff

Return to roff.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/roff.c between version 1.13 and 1.22

version 1.13, 2008/11/27 17:27:50

version 1.22, 2008/11/30 18:53:11

Line 34

/* FIXME: warn about empty lists. */

/* FIXME: ; : } ) (etc.) after text macros? */

/* FIXME: roff_layout and roff_text have identical-ish lower bodies. */

/* FIXME: NAME section needs specific elements. */

Line 54 enum rofftype {

#define ROFFCALL_ARGS \

int tok, struct rofftree *tree, \

const char *argv[], enum roffd type

char *argv[], enum roffd type

struct rofftree;

Line 68 struct rofftok {

int flags;

#define ROFF_PARSED (1 << 0) /* "Parsed". */

#define ROFF_CALLABLE (1 << 1) /* "Callable". */

#define ROFF_QUOTES (1 << 2) /* Quoted args. */

#define ROFF_SHALLOW (1 << 2) /* Nesting block. */

#define ROFF_SHALLOW (1 << 3) /* Nesting block. */

};

struct roffarg {

Line 80 struct roffarg {

Line 79 struct roffarg {

struct roffnode {

int tok; /* Token id. */

struct roffnode *parent; /* Parent (or NULL). */

size_t line; /* Parsed at line. */

};

struct rofftree {

struct roffnode *last; /* Last parsed node. */

time_t date; /* `Dd' results. */

char *cur;

time_t date; /* `Dd' results. */

char os[64]; /* `Os' results. */

char title[64]; /* `Dt' results. */

char section[64]; /* `Dt' results. */

char volume[64]; /* `Dt' results. */

int state;

#define ROFF_PRELUDE (1 << 1) /* In roff prelude. */

/* FIXME: if we had prev ptrs, this wouldn't be necessary. */

#define ROFF_PRELUDE_Os (1 << 2) /* `Os' is parsed. */

#define ROFF_PRELUDE_Dt (1 << 3) /* `Dt' is parsed. */

#define ROFF_PRELUDE_Dd (1 << 4) /* `Dd' is parsed. */

#define ROFF_BODY (1 << 5) /* In roff body. */

struct md_mbuf *mbuf; /* Output (or NULL). */

const struct md_args *args; /* Global args. */

struct roffcb cb;

const struct md_rbuf *rbuf; /* Input. */

void *arg;

const struct roffcb *cb;

};

static int roff_Dd(ROFFCALL_ARGS);

Line 115 static int roff_close(ROFFCALL_ARGS);

Line 113 static int roff_close(ROFFCALL_ARGS);

static int roff_special(ROFFCALL_ARGS);

static struct roffnode *roffnode_new(int, struct rofftree *);

static void roffnode_free(int, struct rofftree *);

static void roffnode_free(struct rofftree *);

static void roff_warn(const struct rofftree *,

const char *, char *, ...);

Line 130 static int roffargs(const struct rofftree *,

Line 128 static int roffargs(const struct rofftree *,

int, char *, char **);

static int roffargok(int, int);

static int roffnextopt(const struct rofftree *,

int, const char ***, char **);

int, char ***, char **);

static int roffparse(struct rofftree *, char *, size_t);

static int roffparse(struct rofftree *, char *);

static int textparse(const struct rofftree *,

static int textparse(const struct rofftree *, char *);

const char *, size_t);

static const int roffarg_An[] = { ROFF_Split, ROFF_Nosplit,

Line 175 static const int roffparent_It[] = { ROFF_Bl, ROFF_It,

Line 172 static const int roffparent_It[] = { ROFF_Bl, ROFF_It,

static const int roffparent_Re[] = { ROFF_Rs, ROFF_MAX };

/* Table of all known tokens. */

static const struct rofftok tokens[ROFF_MAX] =

static const struct rofftok tokens[ROFF_MAX] = {

{

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

{ roff_Dd, NULL, NULL, NULL, 0, ROFF_TEXT, 0 }, /* Dd */

{ roff_Dt, NULL, NULL, NULL, 0, ROFF_TEXT, 0 }, /* Dt */

{ roff_Os, NULL, NULL, NULL, 0, ROFF_TEXT, ROFF_QUOTES }, /* Os */

{ roff_Os, NULL, NULL, NULL, 0, ROFF_TEXT, 0 }, /* Os */

{ roff_layout, NULL, NULL, NULL, ROFF_Sh, ROFF_LAYOUT, ROFF_PARSED }, /* Sh */

{ roff_layout, NULL, NULL, NULL, ROFF_Sh, ROFF_LAYOUT, 0 }, /* Sh */

{ roff_layout, NULL, NULL, NULL, ROFF_Ss, ROFF_LAYOUT, ROFF_PARSED }, /* Ss */

{ roff_layout, NULL, NULL, NULL, ROFF_Ss, ROFF_LAYOUT, 0 }, /* Ss */

{ roff_text, NULL, NULL, NULL, ROFF_Pp, ROFF_TEXT, 0 }, /* Pp */

{ roff_text, NULL, NULL, NULL, 0, ROFF_TEXT, ROFF_PARSED }, /* D1 */

{ roff_text, NULL, NULL, NULL, 0, ROFF_TEXT, ROFF_PARSED }, /* Dl */

Line 190 static const struct rofftok tokens[ROFF_MAX] =

Line 186 static const struct rofftok tokens[ROFF_MAX] =

{ roff_close, NULL, NULL, NULL, ROFF_Bd, ROFF_LAYOUT, 0 }, /* Ed */

{ roff_layout, roffarg_Bl, NULL, roffchild_Bl, 0, ROFF_LAYOUT, 0 }, /* Bl */

{ roff_close, NULL, roffparent_El, NULL, ROFF_Bl, ROFF_LAYOUT, 0 }, /* El */

{ roff_layout, NULL, roffparent_It, NULL, ROFF_It, ROFF_LAYOUT, ROFF_SHALLOW }, /* It */

{ roff_layout, NULL, roffparent_It, NULL, ROFF_It, ROFF_LAYOUT, ROFF_PARSED | ROFF_SHALLOW }, /* It */

{ roff_text, NULL, NULL, NULL, 0, ROFF_TEXT, ROFF_PARSED | ROFF_CALLABLE }, /* Ad */

{ roff_text, NULL, NULL, NULL, 0, ROFF_TEXT, ROFF_PARSED | ROFF_CALLABLE }, /* Ad */ /* FIXME */

{ roff_text, roffarg_An, NULL, NULL, 0, ROFF_TEXT, ROFF_PARSED }, /* An */

{ roff_text, NULL, NULL, NULL, 0, ROFF_TEXT, ROFF_PARSED | ROFF_CALLABLE }, /* Ar */

{ roff_text, NULL, NULL, NULL, 0, ROFF_TEXT, ROFF_QUOTES }, /* Cd */ /* XXX man.4 only */

{ roff_text, NULL, NULL, NULL, 0, ROFF_TEXT, 0 }, /* Cd */ /* XXX man.4 only */

{ roff_text, NULL, NULL, NULL, 0, ROFF_TEXT, ROFF_PARSED | ROFF_CALLABLE }, /* Cm */

{ roff_text, NULL, NULL, NULL, 0, ROFF_TEXT, ROFF_PARSED | ROFF_CALLABLE }, /* Dv */ /* XXX needs arg */

{ roff_text, NULL, NULL, NULL, 0, ROFF_TEXT, ROFF_PARSED | ROFF_CALLABLE }, /* Er */ /* XXX needs arg */

Line 208 static const struct rofftok tokens[ROFF_MAX] =

Line 204 static const struct rofftok tokens[ROFF_MAX] =

{ roff_text, NULL, NULL, NULL, 0, ROFF_TEXT, ROFF_PARSED | ROFF_CALLABLE }, /* Ic */ /* XXX needs arg */

{ roff_text, NULL, NULL, NULL, 0, ROFF_TEXT, 0 }, /* In */

{ roff_text, NULL, NULL, NULL, 0, ROFF_TEXT, ROFF_PARSED | ROFF_CALLABLE }, /* Li */

{ roff_text, NULL, NULL, NULL, 0, ROFF_TEXT, ROFF_QUOTES }, /* Nd */

{ roff_text, NULL, NULL, NULL, 0, ROFF_TEXT, 0 }, /* Nd */

{ roff_text, NULL, NULL, NULL, 0, ROFF_TEXT, ROFF_PARSED | ROFF_CALLABLE }, /* Nm */ /* FIXME */

{ roff_text, NULL, NULL, NULL, 0, ROFF_TEXT, ROFF_PARSED | ROFF_CALLABLE }, /* Op */

{ NULL, NULL, NULL, NULL, 0, ROFF_TEXT, 0 }, /* Ot */ /* XXX deprecated */

Line 236 static const struct rofftok tokens[ROFF_MAX] =

Line 232 static const struct rofftok tokens[ROFF_MAX] =

{ roff_text, NULL, NULL, NULL, 0, ROFF_TEXT, ROFF_PARSED | ROFF_CALLABLE }, /* Bc */

{ NULL, NULL, NULL, NULL, 0, ROFF_TEXT, 0 }, /* Bf */ /* FIXME */

{ roff_text, NULL, NULL, NULL, 0, ROFF_TEXT, ROFF_PARSED | ROFF_CALLABLE }, /* Bo */

{ NULL, NULL, NULL, NULL, 0, ROFF_TEXT, ROFF_PARSED | ROFF_CALLABLE }, /* Bq */

{ roff_text, NULL, NULL, NULL, 0, ROFF_TEXT, ROFF_PARSED | ROFF_CALLABLE }, /* Bq */

{ roff_text, NULL, NULL, NULL, 0, ROFF_TEXT, ROFF_PARSED }, /* Bsx */

{ roff_text, NULL, NULL, NULL, 0, ROFF_TEXT, ROFF_PARSED }, /* Bx */

{roff_special, NULL, NULL, NULL, 0, ROFF_SPECIAL, 0 }, /* Db */

Line 273 static const struct rofftok tokens[ROFF_MAX] =

Line 269 static const struct rofftok tokens[ROFF_MAX] =

{ roff_text, NULL, NULL, NULL, 0, ROFF_TEXT, ROFF_PARSED }, /* Ux */

{ NULL, NULL, NULL, NULL, 0, ROFF_TEXT, ROFF_PARSED | ROFF_CALLABLE }, /* Xc */

{ NULL, NULL, NULL, NULL, 0, ROFF_TEXT, ROFF_PARSED | ROFF_CALLABLE }, /* Xo */

{ roff_layout, NULL, NULL, NULL, 0, ROFF_LAYOUT, 0 }, /* Fo */

{ roff_layout, NULL, NULL, roffchild_Fo, 0, ROFF_LAYOUT, 0 }, /* Fo */

{ roff_close, NULL, roffparent_Fc, NULL, ROFF_Fo, ROFF_LAYOUT, 0 }, /* Fc */

{ roff_layout, NULL, NULL, NULL, 0, ROFF_LAYOUT, 0 }, /* Oo */

{ roff_layout, NULL, NULL, roffchild_Oo, 0, ROFF_LAYOUT, 0 }, /* Oo */

{ roff_close, NULL, roffparent_Oc, NULL, ROFF_Oo, ROFF_LAYOUT, 0 }, /* Oc */

{ roff_layout, roffarg_Bk, NULL, NULL, 0, ROFF_LAYOUT, 0 }, /* Bk */

{ roff_close, NULL, NULL, NULL, ROFF_Bk, ROFF_LAYOUT, 0 }, /* Ek */

};

/* Table of all known token arguments. */

static const int tokenargs[ROFF_ARGMAX] =

static const int tokenargs[ROFF_ARGMAX] = {

{

0, 0, 0, 0,

0, ROFF_VALUE, ROFF_VALUE, 0,

0, 0, 0, 0,

0, 0, ROFF_VALUE, 0,

0, 0, 0, 0,

Line 298 static const int tokenargs[ROFF_ARGMAX] =

Line 294 static const int tokenargs[ROFF_ARGMAX] =

0, 0, 0, 0,

};

const char *const toknamesp[ROFF_MAX] =

const char *const toknamesp[ROFF_MAX] = {

{

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

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

"Dl", "Bd", "Ed", "Bl",

Line 331 const char *const toknamesp[ROFF_MAX] =

Line 325 const char *const toknamesp[ROFF_MAX] =

"Bk", "Ek",

};

const char *const tokargnamesp[ROFF_ARGMAX] =

const char *const tokargnamesp[ROFF_ARGMAX] = {

{

"split", "nosplit", "ragged",

"unfilled", "literal", "file",

"offset", "bullet", "dash",

Line 355 const char *const tokargnamesp[ROFF_ARGMAX] =

Line 348 const char *const tokargnamesp[ROFF_ARGMAX] =

"svid4", "filled", "words",

};

const char *const *toknames = toknamesp;

const char *const *tokargnames = tokargnamesp;

Line 363 const char *const *tokargnames = tokargnamesp;

Line 355 const char *const *tokargnames = tokargnamesp;

int

roff_free(struct rofftree *tree, int flush)

{

int error;

int error, t;

struct roffnode *n;

assert(tree->mbuf);

error = 0;

if ( ! flush)

tree->mbuf = NULL;

goto end;

/* LINTED */

error = 1;

while (tree->last)

if ( ! (*tokens[tree->last->tok].cb)

(tree->last->tok, tree, NULL, ROFF_EXIT))

/* Disallow flushing. */

tree->mbuf = NULL;

error = tree->mbuf ? 0 : 1;

if (ROFF_PRELUDE & tree->state) {

roff_warn(tree, NULL, "prelude never finished");

goto end;

}

if (tree->mbuf && (ROFF_PRELUDE & tree->state)) {

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

/*roff_warn(tree, "prelude never finished");*/

if (0 != tokens[n->tok].ctx)

error = 1;

continue;

roff_warn(tree, NULL, "closing explicit scope `%s'",

toknames[n->tok]);

goto end;

}

while (tree->last) {

t = tree->last->tok;

if ( ! (*tokens[t].cb)(t, tree, NULL, ROFF_EXIT))

goto end;

}

error = 0;

end:

while (tree->last)

roffnode_free(tree);

free(tree);

return(error ? 0 : 1);

}

struct rofftree *

roff_alloc(const struct md_args *args, struct md_mbuf *out,

roff_alloc(const struct roffcb *cb, void *args)

const struct md_rbuf *in, const struct roffcb *cb)

{

struct rofftree *tree;

assert(args);

assert(cb);

if (NULL == (tree = calloc(1, sizeof(struct rofftree))))

err(1, "calloc");

tree->state = ROFF_PRELUDE;

tree->args = args;

tree->arg = args;

tree->mbuf = out;

tree->rbuf = in;

tree->cb = cb;

(void)memcpy(&tree->cb, cb, sizeof(struct roffcb));

return(tree);

}

int

roff_engine(struct rofftree *tree, char *buf, size_t sz)

roff_engine(struct rofftree *tree, char *buf)

{

tree->cur = buf;

assert(buf);

if (0 == sz) {

if (0 == *buf) {

roff_warn(tree, buf, "blank line");

return(0);

} else if ('.' != *buf)

return(textparse(tree, buf, sz));

return(textparse(tree, buf));

return(roffparse(tree, buf, sz));

return(roffparse(tree, buf));

}

static int

textparse(const struct rofftree *tree, const char *buf, size_t sz)

textparse(const struct rofftree *tree, char *buf)

{

/* Print text. */

return((*tree->cb.roffdata)(tree->arg, 1, buf));

return(1);

}

Line 498 roffscan(int tok, const int *tokv)

Line 508 roffscan(int tok, const int *tokv)

static int

roffparse(struct rofftree *tree, char *buf, size_t sz)

roffparse(struct rofftree *tree, char *buf)

{

int tok, t;

struct roffnode *n;

char *argv[ROFF_MAXARG];

const char **argvp;

char **argvp;

assert(sz > 0);

if (ROFF_MAX == (tok = rofffindtok(buf + 1))) {

roff_err(tree, buf + 1, "bogus line macro");

return(0);

Line 520 roffparse(struct rofftree *tree, char *buf, size_t sz)

Line 528 roffparse(struct rofftree *tree, char *buf, size_t sz)

if ( ! roffargs(tree, tok, buf, argv))

return(0);

argvp = (const char **)argv;

argvp = (char **)argv;

* Prelude macros break some assumptions, so branch now.

Line 540 roffparse(struct rofftree *tree, char *buf, size_t sz)

Line 548 roffparse(struct rofftree *tree, char *buf, size_t sz)

if ( ! roffscan(tree->last->tok, tokens[tok].parents)) {

warnx("%s: invalid parent `%s' for `%s' (line %zu)",

roff_err(tree, *argvp, "`%s' has invalid parent `%s'",

tree->rbuf->name,

toknames[tok],

toknames[tree->last->tok],

toknames[tree->last->tok]);

toknames[tok], tree->rbuf->line);

return(0);

}

if ( ! roffscan(tok, tokens[tree->last->tok].children)) {

warnx("%s: invalid child `%s' for `%s' (line %zu)",

roff_err(tree, *argvp, "`%s' is invalid child of `%s'",

tree->rbuf->name, toknames[tok],

toknames[tok],

toknames[tree->last->tok],

toknames[tree->last->tok]);

tree->rbuf->line);

return(0);

}

Line 632 roffparse(struct rofftree *tree, char *buf, size_t sz)

Line 638 roffparse(struct rofftree *tree, char *buf, size_t sz)

assert(tree->last);

assert(tok != tokens[tok].ctx && 0 != tokens[tok].ctx);

/* LINTED */

do {

t = tree->last->tok;

if ( ! (*tokens[t].cb)(t, tree, NULL, ROFF_EXIT))

Line 687 rofffindtok(const char *buf)

Line 694 rofffindtok(const char *buf)

static int

roffispunct(const char *p)

{

if (0 == *p)

return(0);

if (0 != *(p + 1))

return(0);

switch (*p) {

case('{'):

/* FALLTHROUGH */

case('.'):

/* FALLTHROUGH */

case(','):

/* FALLTHROUGH */

case(';'):

/* FALLTHROUGH */

case(':'):

/* FALLTHROUGH */

case('?'):

/* FALLTHROUGH */

case('!'):

/* FALLTHROUGH */

case('('):

/* FALLTHROUGH */

case(')'):

/* FALLTHROUGH */

case('['):

/* FALLTHROUGH */

case(']'):

/* FALLTHROUGH */

case('}'):

return(1);

default:

break;

}

return(0);

}

static int

rofffindcallable(const char *name)

{

int c;

Line 706 roffnode_new(int tokid, struct rofftree *tree)

Line 755 roffnode_new(int tokid, struct rofftree *tree)

if (NULL == (p = malloc(sizeof(struct roffnode))))

err(1, "malloc");

p->line = tree->rbuf->line;

p->tok = tokid;

p->parent = tree->last;

tree->last = p;

Line 732 roffargok(int tokid, int argid)

Line 780 roffargok(int tokid, int argid)

static void

roffnode_free(int tokid, struct rofftree *tree)

roffnode_free(struct rofftree *tree)

{

struct roffnode *p;

assert(tree->last);

assert(tree->last->tok == tokid);

p = tree->last;

tree->last = tree->last->parent;

Line 747 roffnode_free(int tokid, struct rofftree *tree)

Line 794 roffnode_free(int tokid, struct rofftree *tree)

static int

roffnextopt(const struct rofftree *tree, int tok,

const char ***in, char **val)

char ***in, char **val)

{

const char *arg, **argv;

char *arg, **argv;

int v;

*val = NULL;

Line 856 roff_Os(ROFFCALL_ARGS)

Line 903 roff_Os(ROFFCALL_ARGS)

{

if (ROFF_EXIT == type) {

assert(ROFF_PRELUDE_Os & tree->state);

roffnode_free(tree);

return(roff_layout(tok, tree, argv, type));

return((*tree->cb.rofftail)(tree->arg));

} else if (ROFF_BODY & tree->state) {

assert( ! (ROFF_PRELUDE & tree->state));

assert(ROFF_PRELUDE_Os & tree->state);

Line 879 roff_Os(ROFFCALL_ARGS)

Line 926 roff_Os(ROFFCALL_ARGS)

assert(NULL == tree->last);

return(roff_layout(tok, tree, argv, type));

if (NULL == roffnode_new(tok, tree))

return(0);

return((*tree->cb.roffhead)(tree->arg));

}

Line 897 roff_layout(ROFFCALL_ARGS)

Line 947 roff_layout(ROFFCALL_ARGS)

}

if (ROFF_EXIT == type) {

roffnode_free(tok, tree);

roffnode_free(tree);

return((*tree->cb->roffblkout)(tree->args, tok));

return((*tree->cb.roffblkout)(tree->arg, tok));

}

i = 0;

Line 920 roff_layout(ROFFCALL_ARGS)

Line 970 roff_layout(ROFFCALL_ARGS)

if (NULL == roffnode_new(tok, tree))

return(0);

if ( ! (*tree->cb->roffin)(tree->args, tok, argcp, argvp))

if ( ! (*tree->cb.roffblkin)(tree->arg, tok, argcp, argvp))

return(0);

if ( ! (ROFF_PARSED & tokens[tok].flags)) {

if (NULL == *argv)

return(1);

/* TODO: print all tokens. */

if ( ! (*tree->cb.roffin)(tree->arg, tok, argcp, argvp))

return(0);

if ( ! ((*tree->cb->roffout)(tree->args, tok)))

if ( ! (ROFF_PARSED & tokens[tok].flags)) {

return(0);

i = 0;

return((*tree->cb->roffblkin)(tree->args, tok));

while (*argv) {

if ( ! (*tree->cb.roffdata)(tree->arg, i, *argv++))

return(0);

i = 1;

}

return((*tree->cb.roffout)(tree->arg, tok));

}

i = 0;

while (*argv) {

if (ROFF_MAX != (c = rofffindcallable(*argv))) {

if (NULL == tokens[c].cb) {

Line 940 roff_layout(ROFFCALL_ARGS)

Line 998 roff_layout(ROFFCALL_ARGS)

toknames[c]);

return(0);

}

if ( ! (*tokens[c].cb)(c, tree,

if ( ! (*tokens[c].cb)(c, tree, argv, ROFF_ENTER))

argv, ROFF_ENTER))

return(0);

break;

}

/* TODO: print token. */

assert(tree->arg);

if ( ! (*tree->cb.roffdata)(tree->arg, i, *argv++))

argv++;

return(0);

i = 1;

}

if ( ! ((*tree->cb->roffout)(tree->args, tok)))

return(0);

* If we're the first parser (*argv == tree->cur) then purge out

* any additional punctuation, should there be any remaining at

* the end of line.

return((*tree->cb->roffblkin)(tree->args, tok));

if (ROFF_PARSED & tokens[tok].flags && *argv) {

i = 0;

while (argv[i])

i++;

assert(i > 0);

if ( ! roffispunct(argv[--i]))

return((*tree->cb.roffout)(tree->arg, tok));

while (i >= 0 && roffispunct(argv[i]))

i--;

assert(0 != i);

i++;

while (argv[i])

if ( ! (*tree->cb.roffdata)(tree->arg, 0, argv[i++]))

return(0);

}

return((*tree->cb.roffout)(tree->arg, tok));

}

Line 961 roff_layout(ROFFCALL_ARGS)

Line 1043 roff_layout(ROFFCALL_ARGS)

static int

roff_text(ROFFCALL_ARGS)

{

int i, c, argcp[ROFF_MAXARG];

int i, j, first, c, argcp[ROFF_MAXARG];

char *v, *argvp[ROFF_MAXARG];

if (ROFF_PRELUDE & tree->state) {

Line 970 roff_text(ROFFCALL_ARGS)

Line 1052 roff_text(ROFFCALL_ARGS)

return(0);

}

/* FIXME: breaks if passed from roff_layout. */

first = *argv == tree->cur;

i = 0;

argv++;

Line 986 roff_text(ROFFCALL_ARGS)

Line 1071 roff_text(ROFFCALL_ARGS)

argcp[i] = ROFF_ARGMAX;

argvp[i] = NULL;

if ( ! (*tree->cb->roffin)(tree->args, tok, argcp, argvp))

if ( ! (*tree->cb.roffin)(tree->arg, tok, argcp, argvp))

return(0);

if ( ! (ROFF_PARSED & tokens[tok].flags)) {

i = 0;

/* TODO: print all tokens. */

while (*argv) {

if ( ! (*tree->cb.roffdata)(tree->arg, i, *argv++))

return((*tree->cb->roffout)(tree->args, tok));

return(0);

i = 1;

}

return((*tree->cb.roffout)(tree->arg, tok));

}

i = 0;

while (*argv) {

if (ROFF_MAX != (c = rofffindcallable(*argv))) {

if (ROFF_MAX == (c = rofffindcallable(*argv))) {

if (NULL == tokens[c].cb) {

roff_err(tree, *argv, "unsupported "

* If all that remains is roff punctuation, then

"macro `%s'",

* close out our scope and return.

toknames[c]);

return(0);

if (roffispunct(*argv)) {

for (j = 0; argv[j]; j++)

if ( ! roffispunct(argv[j]))

break;

if (NULL == argv[j])

break;

i = 1;

}

if ( ! (*tokens[c].cb)(c, tree,

argv, ROFF_ENTER))

if ( ! (*tree->cb.roffdata)(tree->arg, i, *argv++))

return(0);

i = 1;

continue;

}

/* TODO: print token. */

* A sub-command has been found. Execute it and

* discontinue parsing for arguments.

argv++;

if (NULL == tokens[c].cb) {

roff_err(tree, *argv, "unsupported macro `%s'",

toknames[c]);

return(0);

}

if ( ! (*tokens[c].cb)(c, tree, argv, ROFF_ENTER))

return(0);

break;

}

return((*tree->cb->roffout)(tree->args, tok));

if ( ! (*tree->cb.roffout)(tree->arg, tok))

return(0);

* If we're the first parser (*argv == tree->cur) then purge out

* any additional punctuation, should there be any remaining at

* the end of line.

if (first && *argv) {

i = 0;

while (argv[i])

i++;

assert(i > 0);

if ( ! roffispunct(argv[--i]))

return(1);

while (i >= 0 && roffispunct(argv[i]))

i--;

assert(0 != i);

i++;

while (argv[i])

if ( ! (*tree->cb.roffdata)(tree->arg, 0, argv[i++]))

return(0);

}

return(1);

}

Line 1041 static int

Line 1180 static int

roff_special(ROFFCALL_ARGS)

{

return((*tree->cb->roffspecial)(tok));

return((*tree->cb.roffspecial)(tree->arg, tok));

}

Line 1055 roff_warn(const struct rofftree *tree, const char *pos

Line 1194 roff_warn(const struct rofftree *tree, const char *pos

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

va_end(ap);

(*tree->cb->roffmsg)(tree->args, ROFF_WARN, tree->cur, pos,

(*tree->cb.roffmsg)(tree->arg,

tree->rbuf->name, tree->rbuf->line, buf);

ROFF_WARN, tree->cur, pos, buf);

}

Line 1070 roff_err(const struct rofftree *tree, const char *pos,

Line 1209 roff_err(const struct rofftree *tree, const char *pos,

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

va_end(ap);

(*tree->cb->roffmsg)(tree->args, ROFF_ERROR, tree->cur, pos,

(*tree->cb.roffmsg)(tree->arg,

tree->rbuf->name, tree->rbuf->line, buf);

ROFF_ERROR, tree->cur, pos, buf);

}

CVSweb