mandoc/mdoc_argv.c - diff

Return to mdoc_argv.c CVS log

Up to [cvsweb.bsd.lv] / mandoc

Diff for /mandoc/mdoc_argv.c between version 1.84 and 1.107

version 1.84, 2012/11/16 18:41:18

version 1.107, 2015/10/17 00:21:07

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

* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#include <sys/types.h>

Line 26

Line 24

#include <stdio.h>

#include <string.h>

#include "mdoc.h"

#include "mandoc_aux.h"

#include "mandoc.h"

#include "libmdoc.h"

#include "roff.h"

#include "mdoc.h"

#include "libmandoc.h"

#include "libmdoc.h"

#define MULTI_STEP 5 /* pre-allocate argument values */

#define DELIMSZ 6 /* max possible size of a delimiter */

enum argsflag {

ARGSFL_NONE = 0,

Line 52 struct mdocarg {

};

static void argn_free(struct mdoc_arg *, int);

static enum margserr args(struct mdoc *, int, int *,

static enum margserr args(struct roff_man *, int, int *,

char *, enum argsflag, char **);

static int args_checkpunct(const char *, int);

static int argv_multi(struct mdoc *, int,

static void argv_multi(struct roff_man *, int,

struct mdoc_argv *, int *, char *);

static int argv_single(struct mdoc *, int,

static void argv_single(struct roff_man *, int,

struct mdoc_argv *, int *, char *);

static const enum argvflag argvflags[MDOC_ARG_MAX] = {

Line 149 static const struct mdocarg mdocargs[MDOC_MAX] = {

{ ARGSFL_NONE, NULL }, /* Dt */

{ ARGSFL_NONE, NULL }, /* Os */

{ ARGSFL_NONE, NULL }, /* Sh */

{ ARGSFL_NONE, NULL }, /* Ss */

{ ARGSFL_NONE, NULL }, /* Pp */

{ ARGSFL_DELIM, NULL }, /* D1 */

{ ARGSFL_DELIM, NULL }, /* Dl */

{ ARGSFL_NONE, args_Bd }, /* Bd */

Line 158 static const struct mdocarg mdocargs[MDOC_MAX] = {

{ ARGSFL_NONE, args_Bl }, /* Bl */

{ ARGSFL_NONE, NULL }, /* El */

{ ARGSFL_NONE, NULL }, /* It */

{ ARGSFL_DELIM, NULL }, /* Ad */

{ ARGSFL_DELIM, args_An }, /* An */

{ ARGSFL_DELIM, NULL }, /* Ar */

{ ARGSFL_NONE, NULL }, /* Cd */

{ ARGSFL_DELIM, NULL }, /* Cd */

{ ARGSFL_DELIM, NULL }, /* Cm */

{ ARGSFL_DELIM, NULL }, /* Dv */

{ ARGSFL_DELIM, NULL }, /* Er */

{ ARGSFL_DELIM, NULL }, /* Ev */

{ ARGSFL_NONE, args_Ex }, /* Ex */

{ ARGSFL_DELIM, NULL }, /* Fa */

{ ARGSFL_NONE, NULL }, /* Fd */

{ ARGSFL_DELIM, NULL }, /* Fl */

{ ARGSFL_DELIM, NULL }, /* Fn */

{ ARGSFL_DELIM, NULL }, /* Ft */

{ ARGSFL_DELIM, NULL }, /* Ic */

{ ARGSFL_DELIM, NULL }, /* In */

{ ARGSFL_DELIM, NULL }, /* Li */

{ ARGSFL_NONE, NULL }, /* Nd */

{ ARGSFL_DELIM, NULL }, /* Nm */

{ ARGSFL_DELIM, NULL }, /* Op */

{ ARGSFL_NONE, NULL }, /* Ot */

{ ARGSFL_DELIM, NULL }, /* Ot */

{ ARGSFL_DELIM, NULL }, /* Pa */

{ ARGSFL_NONE, args_Ex }, /* Rv */

{ ARGSFL_DELIM, NULL }, /* St */

{ ARGSFL_DELIM, NULL }, /* Va */

{ ARGSFL_DELIM, NULL }, /* Vt */

{ ARGSFL_DELIM, NULL }, /* Xr */

{ ARGSFL_NONE, NULL }, /* %A */

{ ARGSFL_NONE, NULL }, /* %B */

Line 201 static const struct mdocarg mdocargs[MDOC_MAX] = {

{ ARGSFL_DELIM, NULL }, /* Aq */

{ ARGSFL_DELIM, NULL }, /* At */

{ ARGSFL_DELIM, NULL }, /* Bc */

{ ARGSFL_NONE, args_Bf }, /* Bf */

{ ARGSFL_NONE, NULL }, /* Bo */

{ ARGSFL_DELIM, NULL }, /* Bq */

{ ARGSFL_DELIM, NULL }, /* Bsx */

Line 212 static const struct mdocarg mdocargs[MDOC_MAX] = {

{ ARGSFL_DELIM, NULL }, /* Dq */

{ ARGSFL_DELIM, NULL }, /* Ec */

{ ARGSFL_NONE, NULL }, /* Ef */

{ ARGSFL_DELIM, NULL }, /* Em */

{ ARGSFL_NONE, NULL }, /* Eo */

{ ARGSFL_DELIM, NULL }, /* Fx */

{ ARGSFL_DELIM, NULL }, /* Ms */

Line 240 static const struct mdocarg mdocargs[MDOC_MAX] = {

{ ARGSFL_DELIM, NULL }, /* Ux */

{ ARGSFL_DELIM, NULL }, /* Xc */

{ ARGSFL_NONE, NULL }, /* Xo */

{ ARGSFL_NONE, NULL }, /* Fo */

{ ARGSFL_NONE, NULL }, /* Fc */

{ ARGSFL_DELIM, NULL }, /* Fc */

{ ARGSFL_NONE, NULL }, /* Oo */

{ ARGSFL_DELIM, NULL }, /* Oc */

{ ARGSFL_NONE, args_Bk }, /* Bk */

{ ARGSFL_NONE, NULL }, /* Ek */

{ ARGSFL_NONE, NULL }, /* Bt */

{ ARGSFL_NONE, NULL }, /* Hf */

{ ARGSFL_NONE, NULL }, /* Fr */

{ ARGSFL_DELIM, NULL }, /* Fr */

{ ARGSFL_NONE, NULL }, /* Ud */

{ ARGSFL_NONE, NULL }, /* Lb */

{ ARGSFL_DELIM, NULL }, /* Lb */

{ ARGSFL_NONE, NULL }, /* Lp */

{ ARGSFL_DELIM, NULL }, /* Lk */

{ ARGSFL_DELIM, NULL }, /* Mt */

Line 259 static const struct mdocarg mdocargs[MDOC_MAX] = {

{ ARGSFL_DELIM, NULL }, /* Brc */

{ ARGSFL_NONE, NULL }, /* %C */

{ ARGSFL_NONE, NULL }, /* Es */

{ ARGSFL_NONE, NULL }, /* En */

{ ARGSFL_DELIM, NULL }, /* En */

{ ARGSFL_NONE, NULL }, /* Dx */

{ ARGSFL_DELIM, NULL }, /* Dx */

{ ARGSFL_NONE, NULL }, /* %Q */

{ ARGSFL_NONE, NULL }, /* br */

{ ARGSFL_NONE, NULL }, /* sp */

{ ARGSFL_NONE, NULL }, /* %U */

{ ARGSFL_NONE, NULL }, /* Ta */

{ ARGSFL_NONE, NULL }, /* ll */

};

* Parse an argument from line text. This comes in the form of -key

* Parse flags and their arguments from the input line.

* [value0...], which may either have a single mandatory value, at least

* These come in the form -flag [argument ...].

* one mandatory value, an optional single value, or no value.

* Some flags take no argument, some one, some multiple.

enum margverr

void

mdoc_argv(struct mdoc *m, int line, enum mdoct tok,

mdoc_argv(struct roff_man *mdoc, int line, int tok,

struct mdoc_arg **v, int *pos, char *buf)

struct mdoc_arg **reta, int *pos, char *buf)

{

char *p, sv;

struct mdoc_argv tmpv;

struct mdoc_argv tmp;

struct mdoc_argv **retv;

struct mdoc_arg *arg;

const enum mdocargt *argtable;

const enum mdocargt *ap;

char *argname;

int ipos, retc;

char savechar;

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

*reta = NULL;

return(ARGV_EOLN);

else if (NULL == (ap = mdocargs[tok].argvs))

return(ARGV_WORD);

else if ('-' != buf[*pos])

return(ARGV_WORD);

/* Seek to the first unescaped space. */

/* Which flags does this macro support? */

p = &buf[++(*pos)];

argtable = mdocargs[tok].argvs;

if (argtable == NULL)

return;

assert(*pos > 0);

/* Loop over the flags on the input line. */

for ( ; buf[*pos] ; (*pos)++)

ipos = *pos;

if (' ' == buf[*pos] && '\\' != buf[*pos - 1])

while (buf[ipos] == '-') {

break;

/* Seek to the first unescaped space. */

* We want to nil-terminate the word to look it up (it's easier

* that way). But we may not have a flag, in which case we need

* to restore the line as-is. So keep around the stray byte,

* which we'll reset upon exiting (if necessary).

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

for (argname = buf + ++ipos; buf[ipos] != '\0'; ipos++)

buf[(*pos)++] = '\0';

if (buf[ipos] == ' ' && buf[ipos - 1] != '\\')

break;

* Now look up the word as a flag. Use temporary storage that

* We want to nil-terminate the word to look it up.

* we'll copy into the node's flags, if necessary.

* But we may not have a flag, in which case we need

* to restore the line as-is. So keep around the

* stray byte, which we'll reset upon exiting.

memset(&tmp, 0, sizeof(struct mdoc_argv));

if ((savechar = buf[ipos]) != '\0')

buf[ipos++] = '\0';

tmp.line = line;

tmp.pos = *pos;

* Now look up the word as a flag. Use temporary

tmp.arg = MDOC_ARG_MAX;

* storage that we'll copy into the node's flags.

while (MDOC_ARG_MAX != (tmp.arg = *ap++))

while ((tmpv.arg = *argtable++) != MDOC_ARG_MAX)

if (0 == strcmp(p, mdoc_argnames[tmp.arg]))

if ( ! strcmp(argname, mdoc_argnames[tmpv.arg]))

break;

/* If it isn't a flag, restore the saved byte. */

if (tmpv.arg == MDOC_ARG_MAX) {

if (savechar != '\0')

buf[ipos - 1] = savechar;

break;

}

if (MDOC_ARG_MAX == tmp.arg) {

/* Read to the next word (the first argument). */

* The flag was not found.

* Restore saved zeroed byte and return as a word.

if (sv)

buf[*pos - 1] = sv;

return(ARGV_WORD);

}

/* Read to the next word (the argument). */

while (buf[ipos] == ' ')

ipos++;

while (buf[*pos] && ' ' == buf[*pos])

/* Parse the arguments of the flag. */

(*pos)++;

switch (argvflags[tmp.arg]) {

tmpv.line = line;

case (ARGV_SINGLE):

tmpv.pos = *pos;

if ( ! argv_single(m, line, &tmp, pos, buf))

tmpv.sz = 0;

return(ARGV_ERROR);

tmpv.value = NULL;

break;

case (ARGV_MULTI):

if ( ! argv_multi(m, line, &tmp, pos, buf))

return(ARGV_ERROR);

break;

case (ARGV_NONE):

break;

}

if (NULL == (arg = *v))

switch (argvflags[tmpv.arg]) {

arg = *v = mandoc_calloc(1, sizeof(struct mdoc_arg));

case ARGV_SINGLE:

argv_single(mdoc, line, &tmpv, &ipos, buf);

break;

case ARGV_MULTI:

argv_multi(mdoc, line, &tmpv, &ipos, buf);

break;

case ARGV_NONE:

break;

}

arg->argc++;

/* Append to the return values. */

arg->argv = mandoc_realloc

(arg->argv, arg->argc * sizeof(struct mdoc_argv));

memcpy(&arg->argv[(int)arg->argc - 1],

if (*reta == NULL)

&tmp, sizeof(struct mdoc_argv));

*reta = mandoc_calloc(1, sizeof(**reta));

return(ARGV_ARG);

retc = ++(*reta)->argc;

retv = &(*reta)->argv;

*retv = mandoc_reallocarray(*retv, retc, sizeof(**retv));

memcpy(*retv + retc - 1, &tmpv, sizeof(**retv));

/* Prepare for parsing the next flag. */

*pos = ipos;

argtable = mdocargs[tok].argvs;

}

void

Line 397 argn_free(struct mdoc_arg *p, int iarg)

Line 403 argn_free(struct mdoc_arg *p, int iarg)

arg = &p->argv[iarg];

if (arg->sz && arg->value) {

for (j = (int)arg->sz - 1; j >= 0; j--)

free(arg->value[j]);

free(arg->value);

}

Line 407 argn_free(struct mdoc_arg *p, int iarg)

Line 413 argn_free(struct mdoc_arg *p, int iarg)

}

enum margserr

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

mdoc_args(struct roff_man *mdoc, int line, int *pos,

char *buf, int tok, char **v)

{

struct roff_node *n;

return(args(m, line, pos, buf, ARGSFL_NONE, v));

char *v_local;

}

enum margserr

mdoc_args(struct mdoc *m, int line, int *pos,

char *buf, enum mdoct tok, char **v)

{

enum argsflag fl;

struct mdoc_node *n;

fl = mdocargs[tok].flags;

if (v == NULL)

v = &v_local;

fl = tok == TOKEN_NONE ? ARGSFL_NONE : mdocargs[tok].flags;

if (tok != MDOC_It)

return args(mdoc, line, pos, buf, fl, v);

if (MDOC_It != tok)

return(args(m, line, pos, buf, fl, v));

* We know that we're in an `It', so it's reasonable to expect

* us to be sitting in a `Bl'. Someday this may not be the case

Line 432 mdoc_args(struct mdoc *m, int line, int *pos,

Line 433 mdoc_args(struct mdoc *m, int line, int *pos,

* safe fall-back into the default behaviour.

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

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

if (MDOC_Bl == n->tok)

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

fl = ARGSFL_TABSEP;

break;

}

return(args(m, line, pos, buf, fl, v));

return args(mdoc, line, pos, buf, fl, v);

}

static enum margserr

args(struct mdoc *m, int line, int *pos,

args(struct roff_man *mdoc, int line, int *pos,

char *buf, enum argsflag fl, char **v)

{

char *p, *pp;

char *p;

enum margserr rc;

int pairs;

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

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

if (MDOC_PPHRASE & m->flags)

if (mdoc->flags & MDOC_PHRASELIT &&

return(ARGS_EOLN);

! (mdoc->flags & MDOC_PHRASE)) {

mandoc_msg(MANDOCERR_ARG_QUOTE,

* If we're not in a partial phrase and the flag for

mdoc->parse, line, *pos, NULL);

* being a phrase literal is still set, the punctuation

mdoc->flags &= ~MDOC_PHRASELIT;

* is unterminated.

}

return ARGS_EOLN;

if (MDOC_PHRASELIT & m->flags)

mdoc_pmsg(m, line, *pos, MANDOCERR_BADQUOTE);

m->flags &= ~MDOC_PHRASELIT;

return(ARGS_EOLN);

}

*v = &buf[*pos];

*v = buf + *pos;

if (ARGSFL_DELIM == fl)

if (fl == ARGSFL_DELIM && args_checkpunct(buf, *pos))

if (args_checkpunct(buf, *pos))

return ARGS_PUNCT;

return(ARGS_PUNCT);

* First handle TABSEP items, restricted to `Bl -column'. This

* Tabs in `It' lines in `Bl -column' can't be escaped.

* ignores conventional token parsing and instead uses tabs or

* Phrases are reparsed for `Ta' and other macros later.

* `Ta' macros to separate phrases. Phrases are parsed again

* for arguments at a later phase.

if (ARGSFL_TABSEP == fl) {

if (fl == ARGSFL_TABSEP) {

/* Scan ahead to tab (can't be escaped). */

if ((p = strchr(*v, '\t')) != NULL) {

p = strchr(*v, '\t');

pp = NULL;

/* Scan ahead to unescaped `Ta'. */

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

* Words right before and right after

for (pp = *v; ; pp++) {

* tab characters are not parsed,

if (NULL == (pp = strstr(pp, "Ta")))

* unless there is a blank in between.

break;

if (pp > *v && ' ' != *(pp - 1))

continue;

if (' ' == *(pp + 2) || '\0' == *(pp + 2))

break;

}

/* By default, assume a phrase. */

if (p[-1] != ' ')

rc = ARGS_PHRASE;

mdoc->flags |= MDOC_PHRASEQL;

if (p[1] != ' ')

mdoc->flags |= MDOC_PHRASEQN;

* Adjust new-buffer position to be beyond delimiter

* One or more blanks after a tab cause

* mark (e.g., Ta -> end + 2).

* one leading blank in the next column.

* So skip all but one of them.

if (p && pp) {

*pos += pp < p ? 2 : 1;

rc = pp < p ? ARGS_PHRASE : ARGS_PPHRASE;

p = pp < p ? pp : p;

} else if (p && ! pp) {

rc = ARGS_PPHRASE;

*pos += 1;

} else if (pp && ! p) {

p = pp;

*pos += 2;

} else {

rc = ARGS_PEND;

p = strchr(*v, 0);

}

/* Whitespace check for eoln case... */

*pos += (int)(p - *v) + 1;

if ('\0' == *p && ' ' == *(p - 1))

while (buf[*pos] == ' ' && buf[*pos + 1] == ' ')

mdoc_pmsg(m, line, *pos, MANDOCERR_EOLNSPACE);

(*pos)++;

*pos += (int)(p - *v);

* A tab at the end of an input line

* switches to the next column.

/* Strip delimiter's preceding whitespace. */

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

pp = p - 1;

mdoc->flags |= MDOC_PHRASEQN;

while (pp > *v && ' ' == *pp) {

} else {

if (pp > *v && '\\' == *(pp - 1))

p = strchr(*v, '\0');

break;

if (p[-1] == ' ')

pp--;

mandoc_msg(MANDOCERR_SPACE_EOL,

mdoc->parse, line, *pos, NULL);

*pos += (int)(p - *v);

}

*(pp + 1) = 0;

/* Strip delimiter's proceeding whitespace. */

/* Skip any trailing blank characters. */

for (pp = &buf[*pos]; ' ' == *pp; pp++, (*pos)++)

while (p > *v && p[-1] == ' ' &&

/* Skip ahead. */ ;

(p - 1 == *v || p[-2] != '\\'))

p--;

*p = '\0';

return(rc);

return ARGS_PHRASE;

}

* Process a quoted literal. A quote begins with a double-quote

* and ends with a double-quote NOT preceded by a double-quote.

* NUL-terminate the literal in place.

* Collapse pairs of quotes inside quoted literals.

* Whitespace is NOT involved in literal termination.

if (MDOC_PHRASELIT & m->flags || '\"' == buf[*pos]) {

if (mdoc->flags & MDOC_PHRASELIT || buf[*pos] == '\"') {

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

if ( ! (mdoc->flags & MDOC_PHRASELIT))

*v = &buf[++(*pos)];

if (MDOC_PPHRASE & m->flags)

if (mdoc->flags & MDOC_PHRASE)

m->flags |= MDOC_PHRASELIT;

mdoc->flags |= MDOC_PHRASELIT;

pairs = 0;

for ( ; buf[*pos]; (*pos)++) {

/* Move following text left after quoted quotes. */

if (pairs)

buf[*pos - pairs] = buf[*pos];

if ('\"' != buf[*pos])

continue;

/* Unquoted quotes end quoted args. */

if ('\"' != buf[*pos + 1])

break;

/* Quoted quotes collapse. */

pairs++;

(*pos)++;

}

if (pairs)

buf[*pos - pairs] = '\0';

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

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

if (MDOC_PPHRASE & m->flags)

if ( ! (mdoc->flags & MDOC_PHRASE))

return(ARGS_QWORD);

mandoc_msg(MANDOCERR_ARG_QUOTE,

mdoc_pmsg(m, line, *pos, MANDOCERR_BADQUOTE);

mdoc->parse, line, *pos, NULL);

return(ARGS_QWORD);

return ARGS_QWORD;

}

m->flags &= ~MDOC_PHRASELIT;

mdoc->flags &= ~MDOC_PHRASELIT;

buf[(*pos)++] = '\0';

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

return(ARGS_QWORD);

return ARGS_QWORD;

while (' ' == buf[*pos])

(*pos)++;

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

mdoc_pmsg(m, line, *pos, MANDOCERR_EOLNSPACE);

mandoc_msg(MANDOCERR_SPACE_EOL, mdoc->parse,

line, *pos, NULL);

return(ARGS_QWORD);

return ARGS_QWORD;

}

p = &buf[*pos];

*v = mandoc_getarg(m->parse, &p, line, pos);

*v = mandoc_getarg(mdoc->parse, &p, line, pos);

return(ARGS_WORD);

* After parsing the last word in this phrase,

* tell lookup() whether or not to interpret it.

if (*p == '\0' && mdoc->flags & MDOC_PHRASEQL) {

mdoc->flags &= ~MDOC_PHRASEQL;

mdoc->flags |= MDOC_PHRASEQF;

}

return ARGS_WORD;

}

* Check if the string consists only of space-separated closing

* delimiters. This is a bit of a dance: the first must be a close

* delimiter, but it may be followed by middle delimiters. Arbitrary

Line 605 args_checkpunct(const char *buf, int i)

Line 607 args_checkpunct(const char *buf, int i)

dbuf[j] = buf[i];

if (DELIMSZ == j)

return(0);

return 0;

dbuf[j] = '\0';

if (DELIM_CLOSE != mdoc_isdelim(dbuf))

return(0);

return 0;

while (' ' == buf[i])

i++;

/* Remaining must NOT be open/none. */

while (buf[i]) {

j = 0;

while (buf[i] && ' ' != buf[i] && j < DELIMSZ)

dbuf[j++] = buf[i++];

if (DELIMSZ == j)

return(0);

return 0;

dbuf[j] = '\0';

d = mdoc_isdelim(dbuf);

if (DELIM_NONE == d || DELIM_OPEN == d)

return(0);

return 0;

while (' ' == buf[i])

i++;

}

return('\0' == buf[i]);

return '\0' == buf[i];

}

static int

static void

argv_multi(struct mdoc *m, int line,

argv_multi(struct roff_man *mdoc, int line,

struct mdoc_argv *v, int *pos, char *buf)

{

enum margserr ac;

char *p;

for (v->sz = 0; ; v->sz++) {

if ('-' == buf[*pos])

if (buf[*pos] == '-')

break;

ac = args(m, line, pos, buf, ARGSFL_NONE, &p);

ac = args(mdoc, line, pos, buf, ARGSFL_NONE, &p);

if (ARGS_ERROR == ac)

if (ac == ARGS_EOLN)

return(0);

else if (ARGS_EOLN == ac)

break;

if (0 == v->sz % MULTI_STEP)

if (v->sz % MULTI_STEP == 0)

v->value = mandoc_realloc(v->value,

v->value = mandoc_reallocarray(v->value,

(v->sz + MULTI_STEP) * sizeof(char *));

v->sz + MULTI_STEP, sizeof(char *));

v->value[(int)v->sz] = mandoc_strdup(p);

}

return(1);

}

static int

static void

argv_single(struct mdoc *m, int line,

argv_single(struct roff_man *mdoc, int line,

struct mdoc_argv *v, int *pos, char *buf)

{

enum margserr ac;

char *p;

ac = args(m, line, pos, buf, ARGSFL_NONE, &p);

ac = args(mdoc, line, pos, buf, ARGSFL_NONE, &p);

if (ARGS_ERROR == ac)

if (ac == ARGS_EOLN)

return(0);

return;

if (ARGS_EOLN == ac)

return(1);

v->sz = 1;

v->value = mandoc_malloc(sizeof(char *));

v->value[0] = mandoc_strdup(p);

return(1);

}

CVSweb