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.54 and 1.82

version 1.54, 2010/05/07 05:39:35

version 1.82, 2010/06/27 15:52:41

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

Line 25

#include <string.h>

#include <time.h>

#include "mandoc.h"

#include "libmdoc.h"

#include "libmandoc.h"

enum rew {

REWIND_REWIND,

Line 42 static int in_line_eoln(MACRO_PROT_ARGS);

Line 44 static int in_line_eoln(MACRO_PROT_ARGS);

static int in_line_argn(MACRO_PROT_ARGS);

static int in_line(MACRO_PROT_ARGS);

static int obsolete(MACRO_PROT_ARGS);

static int phrase_ta(MACRO_PROT_ARGS);

static int append_delims(struct mdoc *,

int, int *, char *);

static enum mdoct lookup(int, const char *);

static enum mdoct lookup(enum mdoct, const char *);

static enum mdoct lookup_raw(const char *);

static int phrase(struct mdoc *, int, int, char *);

static enum mdoct rew_alt(enum mdoct);

Line 168 const struct mdoc_macro __mdoc_macros[MDOC_MAX] = {

Line 171 const struct mdoc_macro __mdoc_macros[MDOC_MAX] = {

{ in_line_eoln, 0 }, /* Hf */

{ obsolete, 0 }, /* Fr */

{ in_line_eoln, 0 }, /* Ud */

{ in_line_eoln, 0 }, /* Lb */

{ in_line, 0 }, /* Lb */

{ in_line_eoln, 0 }, /* Lp */

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

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

Line 183 const struct mdoc_macro __mdoc_macros[MDOC_MAX] = {

Line 186 const struct mdoc_macro __mdoc_macros[MDOC_MAX] = {

{ in_line_eoln, 0 }, /* br */

{ in_line_eoln, 0 }, /* sp */

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

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

};

const struct mdoc_macro * const mdoc_macros = __mdoc_macros;

Line 193 swarn(struct mdoc *mdoc, enum mdoc_type type,

Line 197 swarn(struct mdoc *mdoc, enum mdoc_type type,

int line, int pos, const struct mdoc_node *p)

{

const char *n, *t, *tt;

enum mandocerr ec;

n = t = "<root>";

tt = "block";

Line 225 swarn(struct mdoc *mdoc, enum mdoc_type type,

Line 230 swarn(struct mdoc *mdoc, enum mdoc_type type,

break;

}

if ( ! (MDOC_IGN_SCOPE & mdoc->pflags))

ec = (MDOC_IGN_SCOPE & mdoc->pflags) ?

return(mdoc_verr(mdoc, line, pos,

MANDOCERR_SCOPE : MANDOCERR_SYNTSCOPE;

"%s scope breaks %s scope of %s",

return(mdoc_vmsg(mdoc, ec, line, pos,

"%s scope breaks %s of %s",

tt, t, n));

return(mdoc_vwarn(mdoc, line, pos,

"%s scope breaks %s scope of %s",

tt, t, n));

}

Line 254 mdoc_macroend(struct mdoc *m)

Line 258 mdoc_macroend(struct mdoc *m)

continue;

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

continue;

return(mdoc_nerr(m, n, EOPEN));

mdoc_nmsg(m, n, MANDOCERR_SYNTSCOPE);

return(0);

}

/* Rewind to the first. */

Line 267 mdoc_macroend(struct mdoc *m)

Line 272 mdoc_macroend(struct mdoc *m)

* Look up a macro from within a subsequent context.

static enum mdoct

lookup(int from, const char *p)

lookup(enum mdoct from, const char *p)

{

/* FIXME: make -diag lists be un-PARSED. */

Line 283 lookup(int from, const char *p)

Line 288 lookup(int from, const char *p)

static enum mdoct

lookup_raw(const char *p)

{

int res;

enum mdoct res;

if (MDOC_MAX == (res = mdoc_hash_find(p)))

return(MDOC_MAX);

Line 586 rew_sub(enum mdoc_type t, struct mdoc *m,

Line 591 rew_sub(enum mdoc_type t, struct mdoc *m,

return(1);

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

return(1);

return(mdoc_perr(m, line, ppos, ENOCTX));

/* FIXME: shouldn't raise an error */

mdoc_pmsg(m, line, ppos, MANDOCERR_SYNTNOSCOPE);

return(0);

}

if (REWIND_REWIND == c)

break;

Line 600 rew_sub(enum mdoc_type t, struct mdoc *m,

Line 607 rew_sub(enum mdoc_type t, struct mdoc *m,

if ( ! rew_last(m, n))

return(0);

#ifdef UGLY

* The current block extends an enclosing block beyond a line

* break. Now that the current block ends, close the enclosing

Line 613 rew_sub(enum mdoc_type t, struct mdoc *m,

Line 619 rew_sub(enum mdoc_type t, struct mdoc *m,

if ( ! mdoc_body_alloc(m, n->line, n->pos, n->tok))

return(0);

}

#endif

return(1);

}

static int

append_delims(struct mdoc *mdoc, int line, int *pos, char *buf)

append_delims(struct mdoc *m, int line, int *pos, char *buf)

{

int lastarg;

int la;

enum margerr ac;

enum margserr ac;

char *p;

if (0 == buf[*pos])

if ('\0' == buf[*pos])

return(1);

for (;;) {

lastarg = *pos;

la = *pos;

ac = mdoc_zargs(mdoc, line, pos, buf, ARGS_NOWARN, &p);

ac = mdoc_zargs(m, line, pos, buf, ARGS_NOWARN, &p);

assert(ARGS_PHRASE != ac);

if (ARGS_ERROR == ac)

return(0);

else if (ARGS_EOLN == ac)

break;

assert(mdoc_isdelim(p));

if ( ! mdoc_word_alloc(mdoc, line, lastarg, p))

assert(DELIM_NONE != mdoc_isdelim(p));

if ( ! mdoc_word_alloc(m, line, la, p))

return(0);

* If we encounter end-of-sentence symbols, then trigger

* the double-space.

* XXX: it's easy to allow this to propogate outward to

* the last symbol, such that `. )' will cause the

* correct double-spacing. However, (1) groff isn't

* smart enough to do this and (2) it would require

* knowing which symbols break this behaviour, for

* example, `. ;' shouldn't propogate the double-space.

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

m->last->flags |= MDOC_EOS;

}

return(1);

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

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

static int

blk_exp_close(MACRO_PROT_ARGS)

{

int j, lastarg, maxargs, flushed;

int j, lastarg, maxargs, flushed, nl;

enum margerr ac;

enum margserr ac;

enum mdoct ntok;

char *p;

nl = MDOC_NEWLINE & m->flags;

switch (tok) {

case (MDOC_Ec):

maxargs = 1;

Line 668 blk_exp_close(MACRO_PROT_ARGS)

Line 689 blk_exp_close(MACRO_PROT_ARGS)

}

if ( ! (MDOC_CALLABLE & mdoc_macros[tok].flags)) {

/* FIXME: do this in validate */

if (buf[*pos])

if ( ! mdoc_pwarn(m, line, ppos, ENOLINE))

if ( ! mdoc_pmsg(m, line, ppos, MANDOCERR_ARGSLOST))

return(0);

if ( ! rew_sub(MDOC_BODY, m, tok, line, ppos))

Line 723 blk_exp_close(MACRO_PROT_ARGS)

Line 745 blk_exp_close(MACRO_PROT_ARGS)

if ( ! flushed && ! rew_sub(MDOC_BLOCK, m, tok, line, ppos))

return(0);

if (ppos > 1)

if ( ! nl)

return(1);

return(append_delims(m, line, pos, buf));

}

Line 732 blk_exp_close(MACRO_PROT_ARGS)

Line 754 blk_exp_close(MACRO_PROT_ARGS)

static int

in_line(MACRO_PROT_ARGS)

{

int la, lastpunct, c, cnt, d, nc;

int la, scope, cnt, nc, nl;

enum margverr av;

enum mdoct ntok;

enum margerr ac;

enum margserr ac;

enum mdelim d;

struct mdoc_arg *arg;

char *p;

nl = MDOC_NEWLINE & m->flags;

* Whether we allow ignored elements (those without content,

* usually because of reserved words) to squeak by.

Line 764 in_line(MACRO_PROT_ARGS)

Line 790 in_line(MACRO_PROT_ARGS)

for (arg = NULL;; ) {

la = *pos;

c = mdoc_argv(m, line, tok, &arg, pos, buf);

av = mdoc_argv(m, line, tok, &arg, pos, buf);

if (ARGV_WORD == c) {

if (ARGV_WORD == av) {

*pos = la;

break;

}

if (ARGV_EOLN == c)

if (ARGV_EOLN == av)

break;

if (ARGV_ARG == c)

if (ARGV_ARG == av)

continue;

mdoc_argv_free(arg);

return(0);

}

for (cnt = 0, lastpunct = 1;; ) {

for (cnt = scope = 0;; ) {

la = *pos;

ac = mdoc_args(m, line, pos, buf, tok, &p);

Line 800 in_line(MACRO_PROT_ARGS)

Line 826 in_line(MACRO_PROT_ARGS)

if (MDOC_MAX != ntok) {

if (0 == lastpunct && ! rew_elem(m, tok))

if (scope && ! rew_elem(m, tok))

return(0);

if (nc && 0 == cnt) {

if ( ! mdoc_elem_alloc(m, line, ppos, tok, arg))

Line 809 in_line(MACRO_PROT_ARGS)

Line 835 in_line(MACRO_PROT_ARGS)

return(0);

} else if ( ! nc && 0 == cnt) {

mdoc_argv_free(arg);

if ( ! mdoc_pwarn(m, line, ppos, EIGNE))

if ( ! mdoc_pmsg(m, line, ppos, MANDOCERR_MACROEMPTY))

return(0);

}

if ( ! mdoc_macro(m, ntok, line, la, pos, buf))

return(0);

if (ppos > 1)

if ( ! nl)

return(1);

return(append_delims(m, line, pos, buf));

}

Line 825 in_line(MACRO_PROT_ARGS)

Line 851 in_line(MACRO_PROT_ARGS)

* the word.

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

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

if (ARGS_QWORD != ac && d) {

if (DELIM_NONE != d) {

if (0 == lastpunct && ! rew_elem(m, tok))

* If we encounter closing punctuation, no word

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

* allowed to have an empty element, then start

* a new scope. `Ar', `Fl', and `Li', only do

* this once per invocation. There may be more

* of these (all of them?).

if (0 == cnt && (nc || MDOC_Li == tok) &&

DELIM_CLOSE == d && ! scope) {

if ( ! mdoc_elem_alloc(m, line, ppos, tok, arg))

return(0);

if (MDOC_Ar == tok || MDOC_Li == tok ||

MDOC_Fl == tok)

cnt++;

scope = 1;

}

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

* any punctuation.

if (scope && ! rew_elem(m, tok))

return(0);

lastpunct = 1;

scope = 0;

} else if (lastpunct) {

} else if ( ! scope) {

if ( ! mdoc_elem_alloc(m, line, ppos, tok, arg))

return(0);

lastpunct = 0;

scope = 1;

}

if ( ! d)

if (DELIM_NONE == d)

cnt++;

if ( ! mdoc_word_alloc(m, line, la, p))

return(0);

Line 847 in_line(MACRO_PROT_ARGS)

Line 894 in_line(MACRO_PROT_ARGS)

* word so that the `-' can be added to each one without

* having to parse out spaces.

if (0 == lastpunct && MDOC_Fl == tok) {

if (scope && MDOC_Fl == tok) {

if ( ! rew_elem(m, tok))

return(0);

lastpunct = 1;

scope = 0;

}

if (0 == lastpunct && ! rew_elem(m, tok))

if (scope && ! rew_elem(m, tok))

return(0);

Line 870 in_line(MACRO_PROT_ARGS)

Line 917 in_line(MACRO_PROT_ARGS)

return(0);

} else if ( ! nc && 0 == cnt) {

mdoc_argv_free(arg);

if ( ! mdoc_pwarn(m, line, ppos, EIGNE))

if ( ! mdoc_pmsg(m, line, ppos, MANDOCERR_MACROEMPTY))

return(0);

}

if (ppos > 1)

if ( ! nl)

return(1);

return(append_delims(m, line, pos, buf));

}

Line 883 in_line(MACRO_PROT_ARGS)

Line 930 in_line(MACRO_PROT_ARGS)

static int

blk_full(MACRO_PROT_ARGS)

{

int c, la;

int la, nl;

struct mdoc_arg *arg;

struct mdoc_node *head; /* save of head macro */

struct mdoc_node *body; /* save of body macro */

#ifdef UGLY

struct mdoc_node *n;

#endif

enum mdoc_type mtt;

enum mdoct ntok;

enum margerr ac;

enum margserr ac, lac;

enum margverr av;

char *p;

nl = MDOC_NEWLINE & m->flags;

/* Close out prior implicit scope. */

if ( ! (MDOC_EXPLICIT & mdoc_macros[tok].flags)) {

Line 914 blk_full(MACRO_PROT_ARGS)

Line 963 blk_full(MACRO_PROT_ARGS)

for (arg = NULL;; ) {

la = *pos;

c = mdoc_argv(m, line, tok, &arg, pos, buf);

av = mdoc_argv(m, line, tok, &arg, pos, buf);

if (ARGV_WORD == c) {

if (ARGV_WORD == av) {

*pos = la;

break;

}

if (ARGV_EOLN == c)

if (ARGV_EOLN == av)

break;

if (ARGV_ARG == c)

if (ARGV_ARG == av)

continue;

mdoc_argv_free(arg);

Line 951 blk_full(MACRO_PROT_ARGS)

Line 1000 blk_full(MACRO_PROT_ARGS)

body = m->last;

}

for (;;) {

ac = ARGS_ERROR;

for ( ; ; ) {

la = *pos;

/* Initialise last-phrase-type with ARGS_PEND. */

lac = ARGS_ERROR == ac ? ARGS_PEND : ac;

ac = mdoc_args(m, line, pos, buf, tok, &p);

if (ARGS_ERROR == ac)

return(0);

if (ARGS_EOLN == ac)

if (ARGS_EOLN == ac) {

if (ARGS_PPHRASE != lac && ARGS_PHRASE != lac)

break;

* This is necessary: if the last token on a

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

* ARGS_EOLN, so we must be smart enough to

* reopen our scope if the last parse was a

* phrase or partial phrase.

if ( ! rew_sub(MDOC_BODY, m, tok, line, ppos))

return(0);

if ( ! mdoc_body_alloc(m, line, ppos, tok))

return(0);

body = m->last;

break;

}

/* Don't emit leading punct. for phrases. */

* Emit leading punctuation (i.e., punctuation before

* the MDOC_HEAD) for non-phrase types.

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

if (NULL == head &&

ARGS_PEND != ac &&

ARGS_PHRASE != ac &&

ARGS_PPHRASE != ac &&

ARGS_QWORD != ac &&

1 == mdoc_isdelim(p)) {

DELIM_OPEN == mdoc_isdelim(p)) {

if ( ! mdoc_word_alloc(m, line, la, p))

return(0);

continue;

}

/* Always re-open head for phrases. */

/* Open a head if one hasn't been opened. */

if (NULL == head || ARGS_PHRASE == ac) {

if (NULL == head) {

if ( ! mdoc_head_alloc(m, line, ppos, tok))

return(0);

head = m->last;

}

if (ARGS_PHRASE == ac) {

if (ARGS_PHRASE == ac ||

if ( ! phrase(m, line, la, buf))

ARGS_PEND == ac ||

ARGS_PPHRASE == ac) {

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

* head; if we have, rewind that instead.

mtt = body ? MDOC_BODY : MDOC_HEAD;

if ( ! rew_sub(mtt, m, tok, line, ppos))

return(0);

if ( ! rew_sub(MDOC_HEAD, m, tok, line, ppos))

/* Then allocate our body context. */

if ( ! mdoc_body_alloc(m, line, ppos, tok))

return(0);

body = m->last;

* Process phrases: set whether we're in a

* partial-phrase (this effects line handling)

* then call down into the phrase parser.

if (ARGS_PPHRASE == ac)

m->flags |= MDOC_PPHRASE;

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

m->flags |= MDOC_PPHRASE;

if ( ! phrase(m, line, la, buf))

return(0);

m->flags &= ~MDOC_PPHRASE;

continue;

}

Line 1005 blk_full(MACRO_PROT_ARGS)

Line 1108 blk_full(MACRO_PROT_ARGS)

head = m->last;

}

if (1 == ppos && ! append_delims(m, line, pos, buf))

if (nl && ! append_delims(m, line, pos, buf))

return(0);

/* If we've already opened our body, exit now. */

if (NULL != body)

return(1);

goto out;

#ifdef UGLY

* If there is an open (i.e., unvalidated) sub-block requiring

* explicit close-out, postpone switching the current block from

Line 1029 blk_full(MACRO_PROT_ARGS)

Line 1131 blk_full(MACRO_PROT_ARGS)

return(1);

}

#endif

/* Close out scopes to remain in a consistent state. */

Line 1038 blk_full(MACRO_PROT_ARGS)

Line 1139 blk_full(MACRO_PROT_ARGS)

if ( ! mdoc_body_alloc(m, line, ppos, tok))

return(0);

out:

if ( ! (MDOC_FREECOL & m->flags))

return(1);

if ( ! rew_sub(MDOC_BODY, m, tok, line, ppos))

return(0);

if ( ! rew_sub(MDOC_BLOCK, m, tok, line, ppos))

return(0);

m->flags &= ~MDOC_FREECOL;

return(1);

}

Line 1045 blk_full(MACRO_PROT_ARGS)

Line 1156 blk_full(MACRO_PROT_ARGS)

static int

blk_part_imp(MACRO_PROT_ARGS)

{

int la;

int la, nl;

enum mdoct ntok;

enum margerr ac;

enum margserr ac;

char *p;

struct mdoc_node *blk; /* saved block context */

struct mdoc_node *body; /* saved body context */

struct mdoc_node *n;

nl = MDOC_NEWLINE & m->flags;

* A macro that spans to the end of the line. This is generally

* (but not necessarily) called as the first macro. The block

Line 1082 blk_part_imp(MACRO_PROT_ARGS)

Line 1195 blk_part_imp(MACRO_PROT_ARGS)

la = *pos;

ac = mdoc_args(m, line, pos, buf, tok, &p);

assert(ARGS_PHRASE != ac);

if (ARGS_ERROR == ac)

return(0);

if (ARGS_EOLN == ac)

Line 1092 blk_part_imp(MACRO_PROT_ARGS)

Line 1203 blk_part_imp(MACRO_PROT_ARGS)

break;

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

1 == mdoc_isdelim(p)) {

DELIM_OPEN == mdoc_isdelim(p)) {

if ( ! mdoc_word_alloc(m, line, la, p))

return(0);

continue;

Line 1125 blk_part_imp(MACRO_PROT_ARGS)

Line 1236 blk_part_imp(MACRO_PROT_ARGS)

body = m->last;

}

for (n = body->child; n && n->next; n = n->next)

/* Do nothing. */ ;

* End of sentence spacing: if the last node is a text node and

* has a trailing period, then mark it as being end-of-sentence.

if (n && MDOC_TEXT == n->type && n->string)

if (mandoc_eos(n->string, strlen(n->string)))

n->flags |= MDOC_EOS;

/* Up-propogate the end-of-space flag. */

if (n && (MDOC_EOS & n->flags)) {

body->flags |= MDOC_EOS;

body->parent->flags |= MDOC_EOS;

}

* If we can't rewind to our body, then our scope has already

* been closed by another macro (like `Oc' closing `Op'). This

* is ugly behaviour nodding its head to OpenBSD's overwhelming

* crufty use of `Op' breakage.

* FIXME - this should be ifdef'd OpenBSD?

for (n = m->last; n; n = n->parent)

if (body == n)

break;

if (NULL == n && ! mdoc_nwarn(m, body, EIMPBRK))

if (NULL == n && ! mdoc_nmsg(m, body, MANDOCERR_SCOPE))

return(0);

if (n && ! rew_last(m, body))

Line 1143 blk_part_imp(MACRO_PROT_ARGS)

Line 1275 blk_part_imp(MACRO_PROT_ARGS)

/* Standard appending of delimiters. */

if (1 == ppos && ! append_delims(m, line, pos, buf))

if (nl && ! append_delims(m, line, pos, buf))

return(0);

/* Rewind scope, if applicable. */

Line 1158 blk_part_imp(MACRO_PROT_ARGS)

Line 1290 blk_part_imp(MACRO_PROT_ARGS)

static int

blk_part_exp(MACRO_PROT_ARGS)

{

int la;

int la, nl;

enum margerr ac;

enum margserr ac;

struct mdoc_node *head; /* keep track of head */

struct mdoc_node *body; /* keep track of body */

char *p;

enum mdoct ntok;

nl = MDOC_NEWLINE & m->flags;

* The opening of an explicit macro having zero or more leading

* punctuation nodes; a head with optional single element (the

Line 1185 blk_part_exp(MACRO_PROT_ARGS)

Line 1319 blk_part_exp(MACRO_PROT_ARGS)

if (ARGS_EOLN == ac)

break;

assert(ARGS_PHRASE != ac);

/* Flush out leading punctuation. */

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

1 == mdoc_isdelim(p)) {

DELIM_OPEN == mdoc_isdelim(p)) {

assert(NULL == body);

if ( ! mdoc_word_alloc(m, line, la, p))

return(0);

Line 1259 blk_part_exp(MACRO_PROT_ARGS)

Line 1391 blk_part_exp(MACRO_PROT_ARGS)

/* Standard appending of delimiters. */

if (ppos > 1)

if ( ! nl)

return(1);

return(append_delims(m, line, pos, buf));

}

/* ARGSUSED */

static int

in_line_argn(MACRO_PROT_ARGS)

{

int la, flushed, j, c, maxargs;

int la, flushed, j, maxargs, nl;

enum margerr ac;

enum margserr ac;

enum margverr av;

struct mdoc_arg *arg;

char *p;

enum mdoct ntok;

nl = MDOC_NEWLINE & m->flags;

* A line macro that has a fixed number of arguments (maxargs).

* Only open the scope once the first non-leading-punctuation is

Line 1303 in_line_argn(MACRO_PROT_ARGS)

Line 1438 in_line_argn(MACRO_PROT_ARGS)

for (arg = NULL; ; ) {

la = *pos;

c = mdoc_argv(m, line, tok, &arg, pos, buf);

av = mdoc_argv(m, line, tok, &arg, pos, buf);

if (ARGV_WORD == c) {

if (ARGV_WORD == av) {

*pos = la;

break;

}

if (ARGV_EOLN == c)

if (ARGV_EOLN == av)

break;

if (ARGV_ARG == c)

if (ARGV_ARG == av)

continue;

mdoc_argv_free(arg);

Line 1332 in_line_argn(MACRO_PROT_ARGS)

Line 1467 in_line_argn(MACRO_PROT_ARGS)

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

ARGS_QWORD != ac &&

0 == j && 1 == mdoc_isdelim(p)) {

0 == j && DELIM_OPEN == mdoc_isdelim(p)) {

if ( ! mdoc_word_alloc(m, line, la, p))

return(0);

continue;

Line 1360 in_line_argn(MACRO_PROT_ARGS)

Line 1495 in_line_argn(MACRO_PROT_ARGS)

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

ARGS_QWORD != ac &&

! flushed && mdoc_isdelim(p)) {

! flushed &&

DELIM_NONE != mdoc_isdelim(p)) {

if ( ! rew_elem(m, tok))

return(0);

flushed = 1;

Line 1394 in_line_argn(MACRO_PROT_ARGS)

Line 1530 in_line_argn(MACRO_PROT_ARGS)

if ( ! flushed && ! rew_elem(m, tok))

return(0);

if ( ! nl)

if (ppos > 1)

return(1);

return(append_delims(m, line, pos, buf));

}

Line 1404 in_line_argn(MACRO_PROT_ARGS)

Line 1539 in_line_argn(MACRO_PROT_ARGS)

static int

in_line_eoln(MACRO_PROT_ARGS)

{

int c, la;

int la;

enum margerr ac;

enum margserr ac;

enum margverr av;

struct mdoc_arg *arg;

char *p;

enum mdoct ntok;

Line 1416 in_line_eoln(MACRO_PROT_ARGS)

Line 1552 in_line_eoln(MACRO_PROT_ARGS)

for (arg = NULL; ; ) {

la = *pos;

c = mdoc_argv(m, line, tok, &arg, pos, buf);

av = mdoc_argv(m, line, tok, &arg, pos, buf);

if (ARGV_WORD == c) {

if (ARGV_WORD == av) {

*pos = la;

break;

}

if (ARGV_EOLN == c)

if (ARGV_EOLN == av)

break;

if (ARGV_ARG == c)

if (ARGV_ARG == av)

continue;

mdoc_argv_free(arg);

Line 1470 in_line_eoln(MACRO_PROT_ARGS)

Line 1606 in_line_eoln(MACRO_PROT_ARGS)

static int

ctx_synopsis(MACRO_PROT_ARGS)

{

int nl;

nl = MDOC_NEWLINE & m->flags;

/* If we're not in the SYNOPSIS, go straight to in-line. */

if (SEC_SYNOPSIS != m->lastsec)

return(in_line(m, tok, line, ppos, pos, buf));

/* If we're a nested call, same place. */

if (ppos > 1)

if ( ! nl)

return(in_line(m, tok, line, ppos, pos, buf));

Line 1494 static int

Line 1633 static int

obsolete(MACRO_PROT_ARGS)

{

return(mdoc_pwarn(m, line, ppos, EOBS));

return(mdoc_pmsg(m, line, ppos, MANDOCERR_MACROOBS));

}

Line 1507 static int

Line 1646 static int

phrase(struct mdoc *m, int line, int ppos, char *buf)

{

int la, pos;

enum margerr ac;

enum margserr ac;

enum mdoct ntok;

char *p;

for (pos = ppos; ; ) {

la = pos;

/* Note: no calling context! */

ac = mdoc_zargs(m, line, &pos, buf, 0, &p);

if (ARGS_ERROR == ac)

Line 1539 phrase(struct mdoc *m, int line, int ppos, char *buf)

Line 1677 phrase(struct mdoc *m, int line, int ppos, char *buf)

}

/* ARGSUSED */

static int

phrase_ta(MACRO_PROT_ARGS)

{

int la;

enum mdoct ntok;

enum margserr ac;

char *p;

* FIXME: this is overly restrictive: if the `Ta' is unexpected,

* it should simply error out with ARGSLOST.

if ( ! rew_sub(MDOC_BODY, m, MDOC_It, line, ppos))

return(0);

if ( ! mdoc_body_alloc(m, line, ppos, MDOC_It))

return(0);

for (;;) {

la = *pos;

ac = mdoc_zargs(m, line, pos, buf, 0, &p);

if (ARGS_ERROR == ac)

return(0);

if (ARGS_EOLN == ac)

break;

ntok = ARGS_QWORD == ac ? MDOC_MAX : lookup_raw(p);

if (MDOC_MAX == ntok) {

if ( ! mdoc_word_alloc(m, line, la, p))

return(0);

continue;

}

if ( ! mdoc_macro(m, ntok, line, la, pos, buf))

return(0);

return(append_delims(m, line, pos, buf));

}

return(1);

}

CVSweb