texi2mdoc/util.c - diff

Return to util.c CVS log

Up to [cvsweb.bsd.lv] / texi2mdoc

Diff for /texi2mdoc/util.c between version 1.33 and 1.34

version 1.33, 2015/03/13 08:07:34

version 1.34, 2015/03/19 09:53:36

Line 161 texindex(struct texi *p, const char *tok,

texiabort(p, NULL);

memcpy(p->indexs[i].index[isz].term, index, sz);

p->indexs[i].index[isz].term[sz] = '\0';

/* Output mdoc(7) for index. */

#ifdef HAVE_INDEX

p->seenvs = -1;

Line 200 texindex_add(struct texi *p, const char *tok, size_t s

}

/* Reallocate indices. */

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

sizeof(struct texidex) *

(p->indexsz + 1));

if (NULL == p->indexs)

texiabort(p, NULL);

Line 241 texiexit(struct texi *p)

free(p->dirs[i]);

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

texidex_free(&p->indexs[i]);

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

texivaluefree(&p->vals[i]);

free(p->nodecache);

Line 274 texiabort(struct texi *p, const char *errstring)

void

texiwarn(const struct texi *p, const char *fmt, ...)

{

va_list ap;

const struct texifile *f;

f = &p->files[p->filepos - 1];

if (f->insplice)

fprintf(stderr, "%s:%zu:%zu (%zuB left in splice): "

"warning: ", f->name, f->line + 1,

f->col + 1, f->insplice);

else

fprintf(stderr, "%s:%zu:%zu: warning: ",

Line 300 texiwarn(const struct texi *p, const char *fmt, ...)

void

texierr(struct texi *p, const char *fmt, ...)

{

va_list ap;

struct texifile *f;

f = &p->files[p->filepos - 1];

if (f->insplice)

fprintf(stderr, "%s:%zu:%zu: (%zuB left in splice): "

"error: ", f->name, f->line + 1,

f->col + 1, f->insplice);

else

fprintf(stderr, "%s:%zu:%zu: error: ",

Line 364 texiputchars(struct texi *p, const char *s)

fputs("\\&", p->outfile);

if ('\'' == *s && 0 == p->outcol)

fputs("\\&", p->outfile);

if (p->uppercase)

for ( ; '\0' != *s; s++)

p->outcol += fputc(toupper

((unsigned int)*s), p->outfile);

Line 533 texipunctuate(struct texi *p, size_t *pos)

}

if (end == *pos)

return;

if (end + 1 == BUFSZ(p) || ' ' == BUF(p)[end] ||

'@' == BUF(p)[end] || '\n' == BUF(p)[end]) {

for ( ; start < end; start++) {

texiputchar(p, ' ');

Line 551 texipunctuate(struct texi *p, size_t *pos)

static size_t

advancenext(struct texi *p, size_t *pos)

{

if (p->literal) {

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

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

advance(p, pos);

}

return(*pos);

}

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

p->seenws = 1;

Line 599 advanceto(struct texi *p, size_t *pos, size_t end)

{

assert(*pos <= end);

while (*pos < end)

advance(p, pos);

}

static void

texiexecmacro(struct texi *p, struct teximacro *m, size_t sv, size_t *pos)

{

size_t valsz, realsz, aasz, asz,

ssz, i, j, k, start, end;

char *val;

char **args;

Line 664 texiexecmacro(struct texi *p, struct teximacro *m, siz

/* Parse to terminating delimiter. */

/* FIXME: embedded, escaped delimiters? */

for (start = end = i + 1; end < realsz; end++)

if ('\\' == m->value[end])

break;

if (end == realsz)

Line 678 texiexecmacro(struct texi *p, struct teximacro *m, siz

break;

}

* Argument didn't exist in argument table.

* Just ignore it.

if (k == aasz) {

Line 694 texiexecmacro(struct texi *p, struct teximacro *m, siz

texiabort(p, NULL);

}

for (cp = args[k]; '\0' != *cp; cp++)

val[j++] = *cp;

val[j] = '\0';

Line 707 texiexecmacro(struct texi *p, struct teximacro *m, siz

free(args[i]);

free(args);

free(val);

}

* Output a free-form word in the input stream, progressing to the next

Line 717 texiexecmacro(struct texi *p, struct teximacro *m, siz

static void

parseword(struct texi *p, size_t *pos, char extra)

{

size_t i, end, len;

int c;

* If a prior word had a terminating double-newline, then begin

Line 738 parseword(struct texi *p, size_t *pos, char extra)

* have more than 72 characters written to the screen, then

* output a newline before getting started.

if (p->seenws && 0 == p->outmacro &&

p->outcol > 72 && 0 == p->literal)

texiputchar(p, '\n');

Line 806 parseword(struct texi *p, size_t *pos, char extra)

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

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

} else if (*pos < BUFSZ(p) - 2 &&

'-' == BUF(p)[*pos] &&

'-' == BUF(p)[*pos + 1] &&

'-' == BUF(p)[*pos + 2]) {

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

advance(p, pos);

} else if (*pos < BUFSZ(p) - 1 &&

'-' == BUF(p)[*pos] &&

'-' == BUF(p)[*pos + 1]) {

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

advance(p, pos);

} else if (*pos < BUFSZ(p) - 1 &&

'`' == BUF(p)[*pos] &&

'`' == BUF(p)[*pos + 1]) {

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

advance(p, pos);

} else if (*pos < BUFSZ(p) - 1 &&

'\'' == BUF(p)[*pos] &&

'\'' == BUF(p)[*pos + 1]) {

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

advance(p, pos);

Line 834 parseword(struct texi *p, size_t *pos, char extra)

advance(p, pos);

}

* New sentence, new line:if we (non-macro, non-literal) see a

* period at the end of the last printed word, then open a

* newline.

Line 889 texicmd(const struct texi *p, size_t pos, size_t *end,

/* Scan to the end of the possible command name. */

for (*end = pos; *end < BUFSZ(p) && ! ismspace(BUF(p)[*end]); (*end)++)

if ((*end > pos && ('@' == BUF(p)[*end] ||

'{' == BUF(p)[*end] || '}' == BUF(p)[*end])))

break;

Line 974 parsearg(struct texi *p, size_t *pos, size_t num)

advanceto(p, pos, end);

if (NULL != macro)

texiexecmacro(p, macro, sv, pos);

if (TEXICMD__MAX == cmd)

continue;

if (NULL != texitoks[cmd].fp)

(*texitoks[cmd].fp)(p, cmd, pos);

Line 1035 parsebracket(struct texi *p, size_t *pos, int dostack)

advanceto(p, pos, end);

if (NULL != macro)

texiexecmacro(p, macro, sv, pos);

if (TEXICMD__MAX == cmd)

continue;

if (NULL != texitoks[cmd].fp)

(*texitoks[cmd].fp)(p, cmd, pos);

Line 1090 parseeoln(struct texi *p, size_t *pos)

advanceto(p, pos, end);

if (NULL != macro)

texiexecmacro(p, macro, sv, pos);

if (TEXICMD__MAX == cmd)

continue;

if (NULL != texitoks[cmd].fp)

(*texitoks[cmd].fp)(p, cmd, pos);

Line 1166 parsesingle(struct texi *p, size_t *pos)

advanceto(p, pos, end);

if (NULL != macro)

texiexecmacro(p, macro, sv, pos);

if (TEXICMD__MAX == cmd)

return;

if (NULL != texitoks[cmd].fp)

(*texitoks[cmd].fp)(p, cmd, pos);

Line 1207 parseeof(struct texi *p)

{

size_t pos;

for (pos = 0; pos < BUFSZ(p); )

parsesingle(p, &pos);

}

Line 1249 parseto(struct texi *p, size_t *pos, const char *endto

endtoksz = strlen(endtoken);

assert(endtoksz > 0);

while ((*pos = advancenext(p, pos)) < BUFSZ(p)) {

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

case ('}'):

Line 1275 parseto(struct texi *p, size_t *pos, const char *endto

if (TEXICMD_END == cmd) {

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

advance(p, pos);

* FIXME: check the full word, not just its

* initial substring!

Line 1288 parseto(struct texi *p, size_t *pos, const char *endto

texiwarn(p, "unexpected \"end\"");

advanceeoln(p, pos, 0);

continue;

}

if (NULL != macro)

texiexecmacro(p, macro, sv, pos);

if (TEXICMD__MAX == cmd)

continue;

if (NULL != texitoks[cmd].fp)

(*texitoks[cmd].fp)(p, cmd, pos);

}

if (*pos == BUFSZ(p))

texiwarn(p, "EOF expecting \"%s\" end\n", endtoken);

}

Line 1322 parsestdin(struct texi *p)

if (f->mapsz == f->mapmaxsz) {

if (f->mapmaxsz == (1U << 31))

texierr(p, "stdin buffer too long");

f->mapmaxsz = f->mapmaxsz > 65536 / 2 ?

2 * f->mapmaxsz : 65536;

f->map = realloc(f->map, f->mapmaxsz);

if (NULL == f->map)

texiabort(p, NULL);

}

ssz = read(STDIN_FILENO, f->map +

(int)f->mapsz, f->mapmaxsz - f->mapsz);

if (0 == ssz)

break;

else if (-1 == ssz)

texiabort(p, NULL);

}

Line 1356 parsefile(struct texi *p, const char *fname, int parse

size_t i;

char *map;

if (64 == p->filepos)

texierr(p, "too many open files");

f = &p->files[p->filepos];

memset(f, 0, sizeof(struct texifile));

Line 1368 parsefile(struct texi *p, const char *fname, int parse

} else if (-1 == fstat(fd, &st)) {

close(fd);

texiabort(p, fname);

}

f->mapsz = f->mapmaxsz = st.st_size;

map = mmap(NULL, f->mapsz,

Line 1518 valueadd(struct texi *p, char *key, char *val)

p->vals[i].value = val;

} else {

/* FIXME: reallocarray() */

p->vals = realloc(p->vals,

(p->valsz + 1) *

sizeof(struct texivalue));

if (NULL == p->vals)

Line 1589 argparse(struct texi *p, size_t *pos, size_t *argsz, s

start = *pos;

stack = 0;

while (*pos < BUFSZ(p)) {

* According to the manual, commas within

* embedded commands are escaped.

* We keep track of embedded-ness in the "stack"

Line 1631 argparse(struct texi *p, size_t *pos, size_t *argsz, s

advance(p, pos);

}

if (*pos == BUFSZ(p))

texierr(p, "unterminated arguments");

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

advance(p, pos);

Line 1658 teximdocclose(struct texi *p, int last)

/* Print a reference to the "top" node. */

if (-1 != p->nodecache[p->nodecur].up) {

texiputchars(p, "Top node,");

snprintf(buf, sizeof(buf), "%s-%zd 7",

p->chapters, p->nodecache[p->nodecur].up);

p->seenvs = 0;

teximacroopen(p, "Xr ");

Line 1669 teximdocclose(struct texi *p, int last)

if (-1 != p->nodecache[p->nodecur].prev) {

texiputchars(p, "previous node,");

snprintf(buf, sizeof(buf), "%s-%zd 7",

p->chapters, p->nodecache[p->nodecur].prev);

p->seenvs = 0;

teximacroopen(p, "Xr ");

texiputchars(p, buf);

if ( ! last)

texiputchars(p, " ;");

teximacroclose(p);

}

if (-1 != p->nodecache[p->nodecur].next) {

texiputchars(p, "next node,");

Line 1710 texicache(struct texi *p, const char *buf, size_t sz)

if (NULL == buf)

return(-1);

p->nodecache = realloc

(p->nodecache,

(p->nodecachesz + 1) * sizeof(struct texinode));

if (NULL == p->nodecache)

texiabort(p, NULL);

CVSweb