texi2mdoc/main.c - diff

Return to main.c CVS log

Up to [cvsweb.bsd.lv] / texi2mdoc

Diff for /texi2mdoc/main.c between version 1.45 and 1.46

version 1.45, 2015/02/25 10:01:54

version 1.46, 2015/02/25 14:37:17

Line 38 static const char *const sects[SECTSZ] = {

"No",

};

static void doaccent(struct texi *, enum texicmd, const char *, size_t, size_t *);

static void doaccent(struct texi *, enum texicmd, size_t *);

static void doblock(struct texi *, enum texicmd, const char *, size_t, size_t *);

static void doblock(struct texi *, enum texicmd, size_t *);

static void dobracket(struct texi *, enum texicmd, const char *, size_t, size_t *);

static void dobracket(struct texi *, enum texicmd, size_t *);

static void dobye(struct texi *, enum texicmd, const char *, size_t, size_t *);

static void dobye(struct texi *, enum texicmd, size_t *);

static void dodefindex(struct texi *, enum texicmd, const char *, size_t, size_t *);

static void dodefindex(struct texi *, enum texicmd, size_t *);

static void dodefn(struct texi *, enum texicmd, const char *, size_t, size_t *);

static void dodefn(struct texi *, enum texicmd, size_t *);

static void dodisplay(struct texi *, enum texicmd, const char *, size_t, size_t *);

static void dodisplay(struct texi *, enum texicmd, size_t *);

static void doend(struct texi *, enum texicmd, const char *, size_t, size_t *);

static void doend(struct texi *, enum texicmd, size_t *);

static void doenumerate(struct texi *, enum texicmd, const char *, size_t, size_t *);

static void doenumerate(struct texi *, enum texicmd, size_t *);

static void doexample(struct texi *, enum texicmd, const char *, size_t, size_t *);

static void doexample(struct texi *, enum texicmd, size_t *);

static void doignargn(struct texi *, enum texicmd, const char *, size_t, size_t *);

static void doignargn(struct texi *, enum texicmd, size_t *);

static void doignblock(struct texi *, enum texicmd, const char *, size_t, size_t *);

static void doignblock(struct texi *, enum texicmd, size_t *);

static void doignbracket(struct texi *, enum texicmd, const char *, size_t, size_t *);

static void doignbracket(struct texi *, enum texicmd, size_t *);

static void doignline(struct texi *, enum texicmd, const char *, size_t, size_t *);

static void doignline(struct texi *, enum texicmd, size_t *);

static void doinline(struct texi *, enum texicmd, const char *, size_t, size_t *);

static void doinline(struct texi *, enum texicmd, size_t *);

static void doinclude(struct texi *, enum texicmd, const char *, size_t, size_t *);

static void doinclude(struct texi *, enum texicmd, size_t *);

static void doitem(struct texi *, enum texicmd, const char *, size_t, size_t *);

static void doitem(struct texi *, enum texicmd, size_t *);

static void doitemize(struct texi *, enum texicmd, const char *, size_t, size_t *);

static void doitemize(struct texi *, enum texicmd, size_t *);

static void dolink(struct texi *, enum texicmd, const char *, size_t, size_t *);

static void dolink(struct texi *, enum texicmd, size_t *);

static void domacro(struct texi *, enum texicmd, const char *, size_t, size_t *);

static void domacro(struct texi *, enum texicmd, size_t *);

static void domath(struct texi *, enum texicmd, const char *, size_t, size_t *);

static void domath(struct texi *, enum texicmd, size_t *);

static void domultitable(struct texi *, enum texicmd, const char *, size_t, size_t *);

static void domultitable(struct texi *, enum texicmd, size_t *);

static void doquotation(struct texi *, enum texicmd, const char *, size_t, size_t *);

static void doquotation(struct texi *, enum texicmd, size_t *);

static void dotable(struct texi *, enum texicmd, const char *, size_t, size_t *);

static void dotable(struct texi *, enum texicmd, size_t *);

static void dotop(struct texi *, enum texicmd, const char *, size_t, size_t *);

static void dotop(struct texi *, enum texicmd, size_t *);

static void dosecoffs(struct texi *, enum texicmd, const char *, size_t, size_t *);

static void dosecoffs(struct texi *, enum texicmd, size_t *);

static void dosection(struct texi *, enum texicmd, const char *, size_t, size_t *);

static void dosection(struct texi *, enum texicmd, size_t *);

static void dosp(struct texi *, enum texicmd, const char *, size_t, size_t *);

static void dosp(struct texi *, enum texicmd, size_t *);

static void dosubsection(struct texi *, enum texicmd, const char *, size_t, size_t *);

static void dosubsection(struct texi *, enum texicmd, size_t *);

static void dosubsubsection(struct texi *, enum texicmd, const char *, size_t, size_t *);

static void dosubsubsection(struct texi *, enum texicmd, size_t *);

static void dosymbol(struct texi *, enum texicmd, const char *, size_t, size_t *);

static void dosymbol(struct texi *, enum texicmd, size_t *);

static void dotab(struct texi *, enum texicmd, const char *, size_t, size_t *);

static void dotab(struct texi *, enum texicmd, size_t *);

static void dotitle(struct texi *, enum texicmd, const char *, size_t, size_t *);

static void dotitle(struct texi *, enum texicmd, size_t *);

static void dovalue(struct texi *, enum texicmd, const char *, size_t, size_t *);

static void dovalue(struct texi *, enum texicmd, size_t *);

static void doverb(struct texi *, enum texicmd, const char *, size_t, size_t *);

static void doverb(struct texi *, enum texicmd, size_t *);

static void doverbatim(struct texi *, enum texicmd, const char *, size_t, size_t *);

static void doverbatim(struct texi *, enum texicmd, size_t *);

static void doverbinclude(struct texi *, enum texicmd, const char *, size_t, size_t *);

static void doverbinclude(struct texi *, enum texicmd, size_t *);

static const struct texitok __texitoks[TEXICMD__MAX] = {

/* TEXICMD__BEGIN */

Line 342 static const struct texitok __texitoks[TEXICMD__MAX] =

const struct texitok *const texitoks = __texitoks;

static void

dodefindex(struct texi *p, enum texicmd cmd,

dodefindex(struct texi *p, enum texicmd cmd, size_t *pos)

const char *buf, size_t sz, size_t *pos)

{

size_t start, end;

char *cp;

while (*pos < sz && isws(buf[*pos]))

while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))

advance(p, buf, pos);

advance(p, pos);

start = end = *pos;

while (end < sz && ! ismspace(buf[end]))

while (end < BUFSZ(p) && ! ismspace(BUF(p)[end]))

end++;

if (start == end) {

advanceeoln(p, buf, sz, pos, 1);

advanceeoln(p, pos, 1);

return;

} else if (NULL == (cp = malloc(end - start + 1)))

texiabort(p, NULL);

memcpy(cp, &buf[start], end - start);

memcpy(cp, &BUF(p)[start], end - start);

cp[end - start] = '\0';

p->indexs = realloc(p->indexs,

Line 373 dodefindex(struct texi *p, enum texicmd cmd,

Line 372 dodefindex(struct texi *p, enum texicmd cmd,

}

static void

dodefn(struct texi *p, enum texicmd cmd,

dodefn(struct texi *p, enum texicmd cmd, size_t *pos)

const char *buf, size_t sz, size_t *pos)

{

const char *blk;

Line 399 dodefn(struct texi *p, enum texicmd cmd,

Line 397 dodefn(struct texi *p, enum texicmd cmd,

if (p->ign) {

NULL != blk ?

parseto(p, buf, sz, pos, blk) :

parseto(p, pos, blk) :

parseeoln(p, buf, sz, pos);

parseeoln(p, pos);

return;

}

Line 429 dodefn(struct texi *p, enum texicmd cmd,

Line 427 dodefn(struct texi *p, enum texicmd cmd,

texiputchars(p, "Function");

break;

default:

parselinearg(p, buf, sz, pos);

parselinearg(p, pos);

break;

}

Line 439 dodefn(struct texi *p, enum texicmd cmd,

Line 437 dodefn(struct texi *p, enum texicmd cmd,

case (TEXICMD_DEFMAC):

case (TEXICMD_DEFMACX):

teximacroopen(p, "Dv");

while (parselinearg(p, buf, sz, pos))

while (parselinearg(p, pos))

/* Spin. */ ;

teximacroclose(p);

break;

Line 448 dodefn(struct texi *p, enum texicmd cmd,

Line 446 dodefn(struct texi *p, enum texicmd cmd,

case (TEXICMD_DEFUN):

case (TEXICMD_DEFUNX):

teximacroopen(p, "Fo");

parselinearg(p, buf, sz, pos);

parselinearg(p, pos);

teximacroclose(p);

teximacroopen(p, "Fa");

while (parselinearg(p, buf, sz, pos))

while (parselinearg(p, pos))

/* Spin. */ ;

teximacroclose(p);

teximacro(p, "Fc");

Line 463 dodefn(struct texi *p, enum texicmd cmd,

Line 461 dodefn(struct texi *p, enum texicmd cmd,

case (TEXICMD_DEFTYPEMETHOD):

case (TEXICMD_DEFTYPEMETHODX):

teximacroopen(p, "Ft");

parselinearg(p, buf, sz, pos);

parselinearg(p, pos);

teximacroclose(p);

teximacroopen(p, "Fo");

parselinearg(p, buf, sz, pos);

parselinearg(p, pos);

teximacroclose(p);

teximacroopen(p, "Fa");

while (parselinearg(p, buf, sz, pos))

while (parselinearg(p, pos))

/* Spin. */ ;

teximacroclose(p);

teximacro(p, "Fc");

Line 481 dodefn(struct texi *p, enum texicmd cmd,

Line 479 dodefn(struct texi *p, enum texicmd cmd,

case (TEXICMD_DEFTYPEVR):

case (TEXICMD_DEFTYPEVRX):

teximacroopen(p, "Vt");

while (parselinearg(p, buf, sz, pos))

while (parselinearg(p, pos))

/* Spin. */ ;

teximacroclose(p);

break;

Line 490 dodefn(struct texi *p, enum texicmd cmd,

Line 488 dodefn(struct texi *p, enum texicmd cmd,

case (TEXICMD_DEFVR):

case (TEXICMD_DEFVRX):

teximacroopen(p, "Va");

while (parselinearg(p, buf, sz, pos))

while (parselinearg(p, pos))

/* Spin. */ ;

teximacroclose(p);

break;

Line 500 dodefn(struct texi *p, enum texicmd cmd,

Line 498 dodefn(struct texi *p, enum texicmd cmd,

texivspace(p);

if (NULL != blk)

parseto(p, buf, sz, pos, blk);

parseto(p, pos, blk);

}

static void

domacro(struct texi *p, enum texicmd cmd,

domacro(struct texi *p, enum texicmd cmd, size_t *pos)

const char *buf, size_t sz, size_t *pos)

{

size_t start, end, endtoksz, len;

struct teximacro m;

Line 513 domacro(struct texi *p, enum texicmd cmd,

Line 510 domacro(struct texi *p, enum texicmd cmd,

memset(&m, 0, sizeof(struct teximacro));

while (*pos < sz && isws(buf[*pos]))

while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))

advance(p, buf, pos);

advance(p, pos);

for (start = end = *pos; end < sz; end++)

for (start = end = *pos; end < BUFSZ(p); end++)

if (ismspace(buf[end]) || '{' == buf[end])

if (ismspace(BUF(p)[end]) || '{' == BUF(p)[end])

break;

if (start == end)

texierr(p, "zero-length macro name");

advanceto(p, buf, pos, end);

advanceto(p, pos, end);

m.key = malloc(end - start + 1);

if (NULL == m.key)

texiabort(p, NULL);

memcpy(m.key, &buf[start], end - start);

memcpy(m.key, &BUF(p)[start], end - start);

m.key[end - start] = '\0';

m.args = argparse(p, buf, sz, pos, &m.argsz, 0);

m.args = argparse(p, pos, &m.argsz, 0);

advanceeoln(p, buf, sz, pos, 0);

/* Note: we advance to the beginning of the macro. */

advanceeoln(p, pos, 1);

* According to the Texinfo manual, the macro ends on the

* newline subsequent the @end macro.

* That's COMPLETELY FUCKING WRONG.

* It ends inclusive the newline, which is why so many macros

* say things like @r{hello}@c, where the subsequent @c swallows

* the newline.

* However, it does swallow the leading newline, so look for the

* @end macro without the leading newline else we might look

* past empty macros.

start = *pos;

endtok = "\n@end macro\n";

endtok = "@end macro\n";

endtoksz = strlen(endtok);

blk = memmem(&buf[start], sz - start, endtok, endtoksz);

blk = memmem(&BUF(p)[start], BUFSZ(p) - start, endtok, endtoksz);

if (NULL == blk)

texierr(p, "unterminated macro body");

while (&buf[*pos] != blk)

/* Roll us back one character. */

advance(p, buf, pos);

while (&BUF(p)[*pos] != blk)

assert('\n' == buf[*pos]);

advance(p, pos);

advance(p, buf, pos);

assert('@' == BUF(p)[*pos]);

len = blk - &buf[start];

if ('\n' != BUF(p)[*pos - 1])

texierr(p, "cannot handle @end macro in-line");

len = blk - &BUF(p)[start];

m.value = malloc(len + 1);

if (NULL == m.value)

texiabort(p, NULL);

memcpy(m.value, &buf[start], len);

memcpy(m.value, &BUF(p)[start], len);

m.value[len] = '\0';

p->macros = realloc

Line 559 domacro(struct texi *p, enum texicmd cmd,

Line 572 domacro(struct texi *p, enum texicmd cmd,

texiabort(p, NULL);

p->macros[p->macrosz++] = m;

advanceeoln(p, buf, sz, pos, 1);

advanceeoln(p, pos, 1);

}

static void

doignblock(struct texi *p, enum texicmd cmd,

doignblock(struct texi *p, enum texicmd cmd, size_t *pos)

const char *buf, size_t sz, size_t *pos)

{

char end[32], start[32];

const char *endt, *startt;

Line 599 doignblock(struct texi *p, enum texicmd cmd,

Line 611 doignblock(struct texi *p, enum texicmd cmd,

* then there'll be an "end" token of the same kind between us.

* Thus, we keep track of scopes for matching "end" blocks.

while (stack > 0 && *pos < sz) {

while (stack > 0 && *pos < BUFSZ(p)) {

if (stack > 10)

abort();

endt = memmem(&buf[*pos], sz - *pos, end, esz);

endt = memmem(&BUF(p)[*pos], BUFSZ(p) - *pos, end, esz);

startt = memmem(&buf[*pos], sz - *pos, start, ssz);

startt = memmem(&BUF(p)[*pos], BUFSZ(p) - *pos, start, ssz);

if (NULL == endt) {

texiwarn(p, "unterminated \"%s\" "

"block", texitoks[cmd].tok);

*pos = sz;

*pos = BUFSZ(p);

break;

}

newpos = *pos;

if (NULL == startt || startt > endt) {

newpos += esz + (size_t)(endt - &buf[*pos]);

newpos += esz + (size_t)(endt - &BUF(p)[*pos]);

stack--;

} else {

newpos += ssz + (size_t)(startt - &buf[*pos]);

newpos += ssz + (size_t)(startt - &BUF(p)[*pos]);

stack++;

}

assert(newpos <= sz);

assert(newpos <= BUFSZ(p));

while (*pos < newpos)

advance(p, buf, pos);

advance(p, pos);

}

static void

doblock(struct texi *p, enum texicmd cmd,

doblock(struct texi *p, enum texicmd cmd, size_t *pos)

const char *buf, size_t sz, size_t *pos)

{

parseto(p, buf, sz, pos, texitoks[cmd].tok);

parseto(p, pos, texitoks[cmd].tok);

}

static void

doinline(struct texi *p, enum texicmd cmd,

doinline(struct texi *p, enum texicmd cmd, size_t *pos)

const char *buf, size_t sz, size_t *pos)

{

const char *macro = NULL;

Line 678 doinline(struct texi *p, enum texicmd cmd,

Line 688 doinline(struct texi *p, enum texicmd cmd,

}

if (NULL == macro || p->literal || TEXILIST_TABLE == p->list) {

parsebracket(p, buf, sz, pos);

parsebracket(p, pos);

return;

}

teximacroopen(p, macro);

p->seenws = 0;

parsebracket(p, buf, sz, pos);

parsebracket(p, pos);

texipunctuate(p, buf, sz, pos);

texipunctuate(p, pos);

teximacroclose(p);

}

static void

doverb(struct texi *p, enum texicmd cmd,

doverb(struct texi *p, enum texicmd cmd, size_t *pos)

const char *buf, size_t sz, size_t *pos)

{

char delim;

size_t start;

while (*pos < sz && isws(buf[*pos]))

while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))

advance(p, buf, pos);

advance(p, pos);

if (*pos == sz || '{' != buf[*pos])

if (*pos == BUFSZ(p) || '{' != BUF(p)[*pos])

return;

advance(p, buf, pos);

advance(p, pos);

if (*pos == sz)

if (*pos == BUFSZ(p))

return;

delim = buf[*pos];

delim = BUF(p)[*pos];

advance(p, buf, pos);

advance(p, pos);

/* Make sure we flush out our initial whitespace... */

if (p->seenws && p->outcol && 0 == p->literal)

texiputchar(p, ' ');

p->seenws = 0;

start = *pos;

/* Read until we see the delimiter then end-brace. */

while (*pos < sz - 1) {

while (*pos < BUFSZ(p) - 1) {

if (buf[*pos] == delim && buf[*pos + 1] == '}')

if (BUF(p)[*pos] == delim && BUF(p)[*pos + 1] == '}')

break;

advance(p, buf, pos);

advance(p, pos);

}

if (*pos == sz - 1)

if (*pos == BUFSZ(p) - 1)

return;

texiputbuf(p, buf, start, *pos);

texiputbuf(p, start, *pos);

/* Make sure we read after the end-brace. */

assert(delim == buf[*pos]);

assert(delim == BUF(p)[*pos]);

advance(p, buf, pos);

advance(p, pos);

assert('}' == buf[*pos]);

assert('}' == BUF(p)[*pos]);

advance(p, buf, pos);

advance(p, pos);

}

static void

doverbatim(struct texi *p, enum texicmd cmd,

doverbatim(struct texi *p, enum texicmd cmd, size_t *pos)

const char *buf, size_t sz, size_t *pos)

{

const char *end, *term;

size_t endsz, endpos;

Line 738 doverbatim(struct texi *p, enum texicmd cmd,

Line 746 doverbatim(struct texi *p, enum texicmd cmd,

/* We read from the @verbatim\n newline inclusive! */

end = "\n@end verbatim\n";

endsz = strlen(end);

advanceeoln(p, buf, sz, pos, 0);

advanceeoln(p, pos, 0);

if (*pos == sz) {

if (*pos == BUFSZ(p)) {

texiwarn(p, "unexpected end of file");

return;

}

term = memmem(&buf[*pos], sz - *pos, end, endsz);

term = memmem(&BUF(p)[*pos], BUFSZ(p) - *pos, end, endsz);

if (NULL == term) {

texiwarn(p, "unterminated verbatim block");

endpos = sz;

endpos = BUFSZ(p);

} else

endpos = *pos + (size_t)(term - &buf[*pos]);

endpos = *pos + (size_t)(term - &BUF(p)[*pos]);

assert(endpos <= sz);

assert(endpos <= BUFSZ(p));

assert('\n' == buf[*pos]);

assert('\n' == BUF(p)[*pos]);

advance(p, buf, pos);

advance(p, pos);

teximacro(p, "Bd -literal -offset indent");

while (*pos < endpos) {

texiputchar(p, buf[*pos]);

texiputchar(p, BUF(p)[*pos]);

advance(p, buf, pos);

advance(p, pos);

}

teximacro(p, "Ed");

if (*pos < sz)

if (*pos < BUFSZ(p))

advanceto(p, buf, pos, endpos + endsz);

advanceto(p, pos, endpos + endsz);

}

static void

doverbinclude(struct texi *p, enum texicmd cmd,

doverbinclude(struct texi *p, enum texicmd cmd, size_t *pos)

const char *buf, size_t sz, size_t *pos)

{

char fname[PATH_MAX], path[PATH_MAX];

int rc;

Line 774 doverbinclude(struct texi *p, enum texicmd cmd,

Line 781 doverbinclude(struct texi *p, enum texicmd cmd,

const char *v;

enum texicmd type;

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

while (*pos < BUFSZ(p) && ' ' == BUF(p)[*pos])

advance(p, buf, pos);

advance(p, pos);

for (i = 0; *pos < sz && '\n' != buf[*pos]; ) {

for (i = 0; *pos < BUFSZ(p) && '\n' != BUF(p)[*pos]; ) {

if (i == sizeof(fname) - 1)

break;

if ('@' != buf[*pos]) {

if ('@' != BUF(p)[*pos]) {

fname[i++] = buf[*pos];

fname[i++] = BUF(p)[*pos];

advance(p, buf, pos);

advance(p, pos);

continue;

}

type = texicmd(p, buf, *pos, sz, &end, NULL);

type = texicmd(p, *pos, &end, NULL);

advanceto(p, buf, pos, end);

advanceto(p, pos, end);

if (TEXICMD_VALUE != type)

texierr(p, "unknown verbatiminclude command");

v = valueblookup(p, buf, sz, pos);

v = valueblookup(p, pos);

if (NULL == v)

continue;

while ('\0' != *v) {

Line 803 doverbinclude(struct texi *p, enum texicmd cmd,

Line 810 doverbinclude(struct texi *p, enum texicmd cmd,

if (i == 0)

texierr(p, "path too short");

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

else if ('\n' != BUF(p)[*pos])

texierr(p, "path too long");

else if ('/' == fname[0])

texierr(p, "no absolute paths");

Line 823 doverbinclude(struct texi *p, enum texicmd cmd,

Line 830 doverbinclude(struct texi *p, enum texicmd cmd,

}

static void

doinclude(struct texi *p, enum texicmd cmd,

doinclude(struct texi *p, enum texicmd cmd, size_t *pos)

const char *buf, size_t sz, size_t *pos)

{

char fname[PATH_MAX], path[PATH_MAX];

size_t i, end;

Line 832 doinclude(struct texi *p, enum texicmd cmd,

Line 838 doinclude(struct texi *p, enum texicmd cmd,

const char *v;

enum texicmd type;

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

while (*pos < BUFSZ(p) && ' ' == BUF(p)[*pos])

advance(p, buf, pos);

advance(p, pos);

/* Read in the filename. */

for (i = 0; *pos < sz && '\n' != buf[*pos]; ) {

for (i = 0; *pos < BUFSZ(p) && '\n' != BUF(p)[*pos]; ) {

if (i == sizeof(fname) - 1)

break;

if ('@' != buf[*pos]) {

if ('@' != BUF(p)[*pos]) {

fname[i++] = buf[*pos];

fname[i++] = BUF(p)[*pos];

advance(p, buf, pos);

advance(p, pos);

continue;

}

type = texicmd(p, buf, *pos, sz, &end, NULL);

type = texicmd(p, *pos, &end, NULL);

advanceto(p, buf, pos, end);

advanceto(p, pos, end);

if (TEXICMD_VALUE != type)

texierr(p, "unknown include command");

v = valueblookup(p, buf, sz, pos);

v = valueblookup(p, pos);

if (NULL == v)

continue;

while ('\0' != *v) {

Line 862 doinclude(struct texi *p, enum texicmd cmd,

Line 868 doinclude(struct texi *p, enum texicmd cmd,

if (i == 0)

texierr(p, "path too short");

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

else if ('\n' != BUF(p)[*pos])

texierr(p, "path too long");

else if ('/' == fname[0])

texierr(p, "no absolute paths");

Line 889 doinclude(struct texi *p, enum texicmd cmd,

Line 895 doinclude(struct texi *p, enum texicmd cmd,

}

static void

dobracket(struct texi *p, enum texicmd cmd,

dobracket(struct texi *p, enum texicmd cmd, size_t *pos)

const char *buf, size_t sz, size_t *pos)

{

parsebracket(p, buf, sz, pos);

parsebracket(p, pos);

}

static void

dodisplay(struct texi *p, enum texicmd cmd,

dodisplay(struct texi *p, enum texicmd cmd, size_t *pos)

const char *buf, size_t sz, size_t *pos)

{

switch (cmd) {

Line 913 dodisplay(struct texi *p, enum texicmd cmd,

Line 917 dodisplay(struct texi *p, enum texicmd cmd,

p->seenvs = 1;

/* FIXME: ignore and parseeoln. */

advanceeoln(p, buf, sz, pos, 1);

advanceeoln(p, pos, 1);

parseto(p, buf, sz, pos, texitoks[cmd].tok);

parseto(p, pos, texitoks[cmd].tok);

teximacro(p, "Ed");

}

static void

doexample(struct texi *p, enum texicmd cmd,

doexample(struct texi *p, enum texicmd cmd, size_t *pos)

const char *buf, size_t sz, size_t *pos)

{

teximacro(p, "Bd -literal -offset indent");

/* FIXME: ignore and parseeoln. */

advanceeoln(p, buf, sz, pos, 1);

advanceeoln(p, pos, 1);

p->literal++;

parseto(p, buf, sz, pos, texitoks[cmd].tok);

parseto(p, pos, texitoks[cmd].tok);

p->literal--;

teximacro(p, "Ed");

}

static void

dobye(struct texi *p, enum texicmd cmd,

dobye(struct texi *p, enum texicmd cmd, size_t *pos)

const char *buf, size_t sz, size_t *pos)

{

texiexit(p);

Line 942 dobye(struct texi *p, enum texicmd cmd,

Line 944 dobye(struct texi *p, enum texicmd cmd,

}

static void

dotitle(struct texi *p, enum texicmd cmd,

dotitle(struct texi *p, enum texicmd cmd, size_t *pos)

const char *buf, size_t sz, size_t *pos)

{

size_t start, end;

while (*pos < sz && isws(buf[*pos]))

while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))

advance(p, buf, pos);

advance(p, pos);

start = end = *pos;

while (end < sz && '\n' != buf[end])

while (end < BUFSZ(p) && '\n' != BUF(p)[end])

end++;

advanceeoln(p, buf, sz, pos, 1);

advanceeoln(p, pos, 1);

free(p->subtitle);

p->subtitle = malloc(end - start + 1);

if (NULL == p->subtitle)

texiabort(p, NULL);

memcpy(p->subtitle, &buf[start], end - start);

memcpy(p->subtitle, &BUF(p)[start], end - start);

p->subtitle[end - start] = '\0';

}

static void

doaccent(struct texi *p, enum texicmd cmd,

doaccent(struct texi *p, enum texicmd cmd, size_t *pos)

const char *buf, size_t sz, size_t *pos)

{

int brace = 0;

if (*pos == sz) {

if (*pos == BUFSZ(p)) {

texiwarn(p, "truncated: @%s", texitoks[cmd].tok);

return;

}

Line 985 doaccent(struct texi *p, enum texicmd cmd,

* the critical one.

* Otherwise, space can sit between us and our argument.

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

if ('{' == BUF(p)[*pos]) {

brace = 1;

advance(p, buf, pos);

advance(p, pos);

} else if (isalpha(texitoks[cmd].tok[0]))

while (*pos < sz && isws(buf[*pos]))

while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))

advance(p, buf, pos);

advance(p, pos);

if (*pos == sz) {

if (*pos == BUFSZ(p)) {

texiwarn(p, "truncated: @%s", texitoks[cmd].tok);

return;

}

switch (cmd) {

case (TEXICMD_ACUTE):

switch (buf[*pos]) {

switch (BUF(p)[*pos]) {

case ('a'): case ('A'):

case ('e'): case ('E'):

case ('i'): case ('I'):

Line 1011 doaccent(struct texi *p, enum texicmd cmd,

texiwarn(p, "ignoring accent");

break;

}

texiputchar(p, buf[*pos]);

texiputchar(p, BUF(p)[*pos]);

advance(p, buf, pos);

advance(p, pos);

break;

case (TEXICMD_CEDILLA):

if ('c' == buf[*pos] || 'C' == buf[*pos])

if ('c' == BUF(p)[*pos] || 'C' == BUF(p)[*pos])

texiputchars(p, "\\(,");

else

texiwarn(p, "ignoring accent");

texiputchar(p, buf[*pos]);

texiputchar(p, BUF(p)[*pos]);

advance(p, buf, pos);

advance(p, pos);

break;

case (TEXICMD_CIRCUMFLEX):

switch (buf[*pos]) {

switch (BUF(p)[*pos]) {

case ('a'): case ('A'):

case ('e'): case ('E'):

case ('i'): case ('I'):

Line 1035 doaccent(struct texi *p, enum texicmd cmd,

texiwarn(p, "ignoring accent");

break;

}

texiputchar(p, buf[*pos]);

texiputchar(p, BUF(p)[*pos]);

advance(p, buf, pos);

advance(p, pos);

break;

case (TEXICMD_DOTLESS):

if ('i' == buf[*pos] || 'j' == buf[*pos])

if ('i' == BUF(p)[*pos] || 'j' == BUF(p)[*pos])

texiputchars(p, "\\(.");

else

texiwarn(p, "ignoring accent");

texiputchar(p, buf[*pos]);

texiputchar(p, BUF(p)[*pos]);

advance(p, buf, pos);

advance(p, pos);

break;

case (TEXICMD_GRAVE):

switch (buf[*pos]) {

switch (BUF(p)[*pos]) {

case ('a'): case ('A'):

case ('e'): case ('E'):

case ('i'): case ('I'):

Line 1059 doaccent(struct texi *p, enum texicmd cmd,

texiwarn(p, "ignoring accent");

break;

}

texiputchar(p, buf[*pos]);

texiputchar(p, BUF(p)[*pos]);

advance(p, buf, pos);

advance(p, pos);

break;

case (TEXICMD_TILDE):

switch (buf[*pos]) {

switch (BUF(p)[*pos]) {

case ('a'): case ('A'):

case ('n'): case ('N'):

case ('o'): case ('O'):

Line 1073 doaccent(struct texi *p, enum texicmd cmd,

texiwarn(p, "ignoring accent");

break;

}

texiputchar(p, buf[*pos]);

texiputchar(p, BUF(p)[*pos]);

advance(p, buf, pos);

advance(p, pos);

break;

case (TEXICMD_UMLAUT):

switch (buf[*pos]) {

switch (BUF(p)[*pos]) {

case ('a'): case ('A'):

case ('e'): case ('E'):

case ('i'): case ('I'):

Line 1090 doaccent(struct texi *p, enum texicmd cmd,

texiwarn(p, "ignoring accent");

break;

}

texiputchar(p, buf[*pos]);

texiputchar(p, BUF(p)[*pos]);

advance(p, buf, pos);

advance(p, pos);

break;

default:

texiputchar(p, buf[*pos]);

texiputchar(p, BUF(p)[*pos]);

advance(p, buf, pos);

advance(p, pos);

break;

}

if (brace) {

while (*pos < sz && '}' != buf[*pos]) {

while (*pos < BUFSZ(p) && '}' != BUF(p)[*pos]) {

texiputchar(p, buf[*pos]);

texiputchar(p, BUF(p)[*pos]);

advance(p, buf, pos);

advance(p, pos);

}

if (*pos < sz)

if (*pos < BUFSZ(p))

advance(p, buf, pos);

advance(p, pos);

}

switch (cmd) {

Line 1121 doaccent(struct texi *p, enum texicmd cmd,

}

static void

dosymbol(struct texi *p, enum texicmd cmd,

dosymbol(struct texi *p, enum texicmd cmd, size_t *pos)

const char *buf, size_t sz, size_t *pos)

{

/* Remember to pad us. */

Line 1312 dosymbol(struct texi *p, enum texicmd cmd,

Line 1311 dosymbol(struct texi *p, enum texicmd cmd,

/* Alphabetic commands have braces we ignore. */

if (isalpha(texitoks[cmd].tok[0]))

doignbracket(p, cmd, buf, sz, pos);

doignbracket(p, cmd, pos);

}

static void

doquotation(struct texi *p, enum texicmd cmd,

doquotation(struct texi *p, enum texicmd cmd, size_t *pos)

const char *buf, size_t sz, size_t *pos)

{

teximacro(p, "Qo");

parseto(p, buf, sz, pos, "quotation");

parseto(p, pos, "quotation");

teximacro(p, "Qc");

}

static void

domath(struct texi *p, enum texicmd cmd,

domath(struct texi *p, enum texicmd cmd, size_t *pos)

const char *buf, size_t sz, size_t *pos)

{

size_t nest, start;

Line 1337 domath(struct texi *p, enum texicmd cmd,

Line 1334 domath(struct texi *p, enum texicmd cmd,

* terms of @-commands.

* This departs from GNU's rules, but whatever.

while (*pos < sz && isws(buf[*pos]))

while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))

advance(p, buf, pos);

advance(p, pos);

if (*pos == sz || '{' != buf[*pos])

if (*pos == BUFSZ(p) || '{' != BUF(p)[*pos])

return;

advance(p, buf, pos);

advance(p, pos);

if (p->seenws && p->outcol && 0 == p->literal)

texiputchar(p, ' ');

p->seenws = 0;

for (nest = 1, start = *pos; *pos < sz && nest > 0; ) {

for (nest = 1, start = *pos; *pos < BUFSZ(p) && nest > 0; ) {

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

if ('{' == BUF(p)[*pos])

nest++;

else if ('}' == buf[*pos])

else if ('}' == BUF(p)[*pos])

if (0 == --nest)

continue;

advance(p, buf, pos);

advance(p, pos);

}

if (*pos == sz)

if (*pos == BUFSZ(p))

return;

assert('}' == buf[*pos]);

assert('}' == BUF(p)[*pos]);

texiputbuf(p, buf, start, *pos);

texiputbuf(p, start, *pos);

advance(p, buf, pos);

advance(p, pos);

}

static void

dovalue(struct texi *p, enum texicmd cmd,

dovalue(struct texi *p, enum texicmd cmd, size_t *pos)

const char *buf, size_t sz, size_t *pos)

{

size_t start, end, i;

size_t start, end;

char *key, *val;

const char *cp;

if (TEXICMD_SET == cmd) {

while (*pos < sz && isws(buf[*pos]))

while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))

advance(p, buf, pos);

advance(p, pos);

for (start = end = *pos; end < sz; end++)

for (start = end = *pos; end < BUFSZ(p); end++)

if (ismspace(buf[end]))

if (ismspace(BUF(p)[end]))

break;

/* We don't allow empty keys. */

if (start == end)

return;

advanceto(p, buf, pos, end);

advanceto(p, pos, end);

key = malloc(end - start + 1);

if (NULL == key)

texiabort(p, NULL);

memcpy(key, &buf[start], end - start);

memcpy(key, &BUF(p)[start], end - start);

key[end - start] = '\0';

while (*pos < sz && isws(buf[*pos]))

while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))

advance(p, buf, pos);

advance(p, pos);

for (start = end = *pos; end < sz; end++)

for (start = end = *pos; end < BUFSZ(p); end++)

if ('\n' == buf[end])

if ('\n' == BUF(p)[end])

break;

/* We do allow empty values. */

advanceeoln(p, buf, sz, pos, 1);

advanceeoln(p, pos, 1);

val = malloc(end - start + 1);

if (NULL == val)

texiabort(p, NULL);

memcpy(val, &buf[start], end - start);

memcpy(val, &BUF(p)[start], end - start);

val[end - start] = '\0';

valueadd(p, key, val);

} else if (TEXICMD_VALUE == cmd) {

if (p->seenws)

texiputchar(p, ' ');

p->seenws = 0;

if (NULL != (cp = valueblookup(p, buf, sz, pos))) {

if (NULL != (cp = valueblookup(p, pos)))

for (i = 0; i < p->valstackpos; i++)

texisplice(p, cp, strlen(cp), pos);

if (cp == p->valstack[i])

else

break;

if (i < p->valstackpos)

texierr(p, "recursive value");

if (64 == p->valstackpos)

texierr(p, "too many nested values");

p->valstack[p->valstackpos++] = cp;

parsemembuf(p, cp, strlen(cp));

p->valstackpos--;

} else

texiputchars(p, "{No value}");

} else if (TEXICMD_IFCLEAR == cmd) {

if (NULL != valuellookup(p, buf, sz, pos))

if (NULL != valuellookup(p, pos))

doignblock(p, cmd, buf, sz, pos);

doignblock(p, cmd, pos);

else

parseto(p, buf, sz, pos, texitoks[cmd].tok);

parseto(p, pos, texitoks[cmd].tok);

} else if (TEXICMD_IFSET == cmd) {

if (NULL == valuellookup(p, buf, sz, pos))

if (NULL == valuellookup(p, pos))

doignblock(p, cmd, buf, sz, pos);

doignblock(p, cmd, pos);

else

parseto(p, buf, sz, pos, texitoks[cmd].tok);

parseto(p, pos, texitoks[cmd].tok);

} else if (TEXICMD_CLEAR == cmd)

valuelclear(p, buf, sz, pos);

valuelclear(p, pos);

}

static void

dolink(struct texi *p, enum texicmd cmd,

dolink(struct texi *p, enum texicmd cmd, size_t *pos)

const char *buf, size_t sz, size_t *pos)

{

int c;

Line 1461 dolink(struct texi *p, enum texicmd cmd,

Line 1447 dolink(struct texi *p, enum texicmd cmd,

abort();

}

c = parsearg(p, buf, sz, pos, 0);

c = parsearg(p, pos, 0);

p->ign++;

while (c > 0)

c = parsearg(p, buf, sz, pos, 1);

c = parsearg(p, pos, 1);

p->ign--;

texipunctuate(p, buf, sz, pos);

texipunctuate(p, pos);

teximacroclose(p);

}

static void

doignargn(struct texi *p, enum texicmd cmd,

doignargn(struct texi *p, enum texicmd cmd, size_t *pos)

const char *buf, size_t sz, size_t *pos)

{

int c;

c = parsearg(p, buf, sz, pos, 0);

c = parsearg(p, pos, 0);

p->ign++;

while (c > 0)

c = parsearg(p, buf, sz, pos, 1);

c = parsearg(p, pos, 1);

p->ign--;

}

Line 1505 sectioner(struct texi *p, int sec)

Line 1490 sectioner(struct texi *p, int sec)

}

static void

dosubsubsection(struct texi *p, enum texicmd cmd,

dosubsubsection(struct texi *p, enum texicmd cmd, size_t *pos)

const char *buf, size_t sz, size_t *pos)

{

int sec;

Line 1515 dosubsubsection(struct texi *p, enum texicmd cmd,

Line 1499 dosubsubsection(struct texi *p, enum texicmd cmd,

/* We don't have a subsubsubsection, so make one up. */

texivspace(p);

teximacroopen(p, sects[sec]);

parseeoln(p, buf, sz, pos);

parseeoln(p, pos);

teximacroclose(p);

texivspace(p);

}

static void

dosubsection(struct texi *p, enum texicmd cmd,

dosubsection(struct texi *p, enum texicmd cmd, size_t *pos)

const char *buf, size_t sz, size_t *pos)

{

int sec;

Line 1537 dosubsection(struct texi *p, enum texicmd cmd,

Line 1520 dosubsection(struct texi *p, enum texicmd cmd,

if (sec > 1)

texivspace(p);

teximacroopen(p, sects[sec]);

parseeoln(p, buf, sz, pos);

parseeoln(p, pos);

teximacroclose(p);

if (sec > 1)

texivspace(p);

}

static void

dosecoffs(struct texi *p, enum texicmd cmd,

dosecoffs(struct texi *p, enum texicmd cmd, size_t *pos)

const char *buf, size_t sz, size_t *pos)

{

if (TEXICMD_RAISESECTIONS == cmd)

Line 1555 dosecoffs(struct texi *p, enum texicmd cmd,

Line 1537 dosecoffs(struct texi *p, enum texicmd cmd,

}

static void

dosection(struct texi *p, enum texicmd cmd,

dosection(struct texi *p, enum texicmd cmd, size_t *pos)

const char *buf, size_t sz, size_t *pos)

{

int sec;

Line 1583 dosection(struct texi *p, enum texicmd cmd,

Line 1564 dosection(struct texi *p, enum texicmd cmd,

texierr(p, "\"%s\" in a literal scope!?", sects[sec]);

teximacroopen(p, sects[sec]);

parseeoln(p, buf, sz, pos);

parseeoln(p, pos);

teximacroclose(p);

p->seenvs = 1;

}

static void

dosp(struct texi *p, enum texicmd cmd,

dosp(struct texi *p, enum texicmd cmd, size_t *pos)

const char *buf, size_t sz, size_t *pos)

{

if (p->literal)

Line 1598 dosp(struct texi *p, enum texicmd cmd,

Line 1578 dosp(struct texi *p, enum texicmd cmd,

else

texivspace(p);

/* FIXME: ignore and parseeoln. */

advanceeoln(p, buf, sz, pos, 1);

advanceeoln(p, pos, 1);

}

static void

dotop(struct texi *p, enum texicmd cmd,

dotop(struct texi *p, enum texicmd cmd, size_t *pos)

const char *buf, size_t sz, size_t *pos)

{

const char *cp;

time_t t;

char date[32];

if (--p->ign)

texierr(p, "@top command while ignoring (%d)", p->ign);

texierr(p, "@top command while ignoring");

* Here we print our standard mdoc(7) prologue.

Line 1644 dotop(struct texi *p, enum texicmd cmd,

Line 1623 dotop(struct texi *p, enum texicmd cmd,

texiputchars(p, "Unknown description");

teximacroclose(p);

p->seenvs = 1;

dosection(p, cmd, buf, sz, pos);

dosection(p, cmd, pos);

}

static void

doitem(struct texi *p, enum texicmd cmd,

doitem(struct texi *p, enum texicmd cmd, size_t *pos)

const char *buf, size_t sz, size_t *pos)

{

/* Multitable is using raw tbl(7). */

Line 1677 doitem(struct texi *p, enum texicmd cmd,

Line 1655 doitem(struct texi *p, enum texicmd cmd,

/* Trick so we don't start with Pp. */

p->seenvs = 1;

parseeoln(p, buf, sz, pos);

parseeoln(p, pos);

if (TEXILIST_ITEM == p->list)

teximacroclose(p);

Line 1686 doitem(struct texi *p, enum texicmd cmd,

Line 1664 doitem(struct texi *p, enum texicmd cmd,

}

static void

dotab(struct texi *p, enum texicmd cmd,

dotab(struct texi *p, enum texicmd cmd, size_t *pos)

const char *buf, size_t sz, size_t *pos)

{

/* This command is only useful in @multitable. */

Line 1696 dotab(struct texi *p, enum texicmd cmd,

Line 1673 dotab(struct texi *p, enum texicmd cmd,

}

static void

domultitable(struct texi *p, enum texicmd cmd,

domultitable(struct texi *p, enum texicmd cmd, size_t *pos)

const char *buf, size_t sz, size_t *pos)

{

enum texilist sv = p->list;

int svliteral = p->literal;

Line 1714 domultitable(struct texi *p, enum texicmd cmd,

Line 1690 domultitable(struct texi *p, enum texicmd cmd,

columns = 0;

/* Advance to the first argument... */

while (*pos < sz && isws(buf[*pos]))

while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))

advance(p, buf, pos);

advance(p, pos);

/* Make sure we don't print anything when scanning. */

p->ign++;

if ('@' == buf[*pos]) {

if ('@' == BUF(p)[*pos]) {

* Look for @columnfractions.

* We ignore these, but we do use the number of

* arguments to set the number of columns that we'll

* have.

type = texicmd(p, buf, *pos, sz, &end, NULL);

type = texicmd(p, *pos, &end, NULL);

advanceto(p, buf, pos, end);

advanceto(p, pos, end);

if (TEXICMD_COLUMNFRACTIONS != type)

texierr(p, "unknown multitable command");

while (*pos < sz && '\n' != buf[*pos]) {

while (*pos < BUFSZ(p) && '\n' != BUF(p)[*pos]) {

while (*pos < sz && isws(buf[*pos]))

while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))

advance(p, buf, pos);

advance(p, pos);

while (*pos < sz && ! isws(buf[*pos])) {

while (*pos < BUFSZ(p) && ! isws(BUF(p)[*pos])) {

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

if ('\n' == BUF(p)[*pos])

break;

advance(p, buf, pos);

advance(p, pos);

}

columns++;

}

Line 1747 domultitable(struct texi *p, enum texicmd cmd,

Line 1723 domultitable(struct texi *p, enum texicmd cmd,

* tbl(7) figure it out.

* So use this only to count arguments.

while (parselinearg(p, buf, sz, pos) > 0)

while (parselinearg(p, pos) > 0)

columns++;

p->ign--;

Line 1759 domultitable(struct texi *p, enum texicmd cmd,

Line 1735 domultitable(struct texi *p, enum texicmd cmd,

}

texiputchars(p, ".\n");

p->outmacro++;

parseto(p, buf, sz, pos, texitoks[cmd].tok);

parseto(p, pos, texitoks[cmd].tok);

p->outmacro--;

teximacro(p, "TE");

p->literal = svliteral;

Line 1767 domultitable(struct texi *p, enum texicmd cmd,

Line 1743 domultitable(struct texi *p, enum texicmd cmd,

}

static void

dotable(struct texi *p, enum texicmd cmd,

dotable(struct texi *p, enum texicmd cmd, size_t *pos)

const char *buf, size_t sz, size_t *pos)

{

enum texilist sv = p->list;

p->list = TEXILIST_ITEM;

teximacro(p, "Bl -tag -width Ds");

/* FIXME: ignore and parseeoln. */

advanceeoln(p, buf, sz, pos, 1);

advanceeoln(p, pos, 1);

p->seenvs = 1;

parseto(p, buf, sz, pos, texitoks[cmd].tok);

parseto(p, pos, texitoks[cmd].tok);

teximacro(p, "El");

p->list = sv;

}

static void

doend(struct texi *p, enum texicmd cmd,

doend(struct texi *p, enum texicmd cmd, size_t *pos)

const char *buf, size_t sz, size_t *pos)

{

size_t start;

while (*pos < sz && isws(buf[*pos]))

while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))

advance(p, buf, pos);

advance(p, pos);

start = *pos;

while (*pos < sz && '\n' != buf[*pos])

while (*pos < BUFSZ(p) && '\n' != BUF(p)[*pos])

advance(p, buf, pos);

advance(p, pos);

texiwarn(p, "unexpected \"end\": %.*s", (int)(*pos - start), &buf[start]);

texiwarn(p, "unexpected \"end\": %.*s", (int)(*pos - start), &BUF(p)[start]);

advanceeoln(p, buf, sz, pos, 1);

advanceeoln(p, pos, 1);

}

static void

doenumerate(struct texi *p, enum texicmd cmd,

doenumerate(struct texi *p, enum texicmd cmd, size_t *pos)

const char *buf, size_t sz, size_t *pos)

{

enum texilist sv = p->list;

Line 1808 doenumerate(struct texi *p, enum texicmd cmd,

Line 1781 doenumerate(struct texi *p, enum texicmd cmd,

teximacro(p, "Bl -enum");

p->seenvs = 1;

/* FIXME: ignore and parseeoln. */

advanceeoln(p, buf, sz, pos, 1);

advanceeoln(p, pos, 1);

parseto(p, buf, sz, pos, "enumerate");

parseto(p, pos, "enumerate");

teximacro(p, "El");

p->list = sv;

}

static void

doitemize(struct texi *p, enum texicmd cmd,

doitemize(struct texi *p, enum texicmd cmd, size_t *pos)

const char *buf, size_t sz, size_t *pos)

{

enum texilist sv = p->list;

Line 1824 doitemize(struct texi *p, enum texicmd cmd,

Line 1796 doitemize(struct texi *p, enum texicmd cmd,

teximacro(p, "Bl -bullet");

p->seenvs = 1;

/* FIXME: ignore and parseeoln. */

advanceeoln(p, buf, sz, pos, 1);

advanceeoln(p, pos, 1);

parseto(p, buf, sz, pos, "itemize");

parseto(p, pos, "itemize");

teximacro(p, "El");

p->list = sv;

}

static void

doignbracket(struct texi *p, enum texicmd cmd,

doignbracket(struct texi *p, enum texicmd cmd, size_t *pos)

const char *buf, size_t sz, size_t *pos)

{

p->ign++;

parsebracket(p, buf, sz, pos);

parsebracket(p, pos);

p->ign--;

}

static void

doignline(struct texi *p, enum texicmd cmd,

doignline(struct texi *p, enum texicmd cmd, size_t *pos)

const char *buf, size_t sz, size_t *pos)

{

/* FIXME: ignore and parseeoln. */

advanceeoln(p, buf, sz, pos, 1);

advanceeoln(p, pos, 1);

}

CVSweb