texi2mdoc/main.c - diff

Return to main.c CVS log

Up to [cvsweb.bsd.lv] / texi2mdoc

Diff for /texi2mdoc/main.c between version 1.24 and 1.30

version 1.24, 2015/02/20 09:58:50

version 1.30, 2015/02/23 11:44:30

Line 44 static void doaccent(struct texi *, enum texicmd, cons

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

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

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

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

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

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

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

Line 57 static void doinclude(struct texi *, enum texicmd, con

Line 58 static void doinclude(struct texi *, enum texicmd, con

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

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

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

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

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

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

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

Line 71 static void dosymbol(struct texi *, enum texicmd, cons

Line 73 static void dosymbol(struct texi *, enum texicmd, cons

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

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

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

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

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

static const struct texitok __texitoks[TEXICMD__MAX] = {

Line 83 static const struct texitok __texitoks[TEXICMD__MAX] =

Line 86 static const struct texitok __texitoks[TEXICMD__MAX] =

{ dosection, "appendixsec", 11 }, /* TEXICMD_APPENDIXSEC */

{ dosubsection, "appendixsubsec", 14 }, /* TEXICMD_APPENDIXSUBSEC */

{ dosubsubsection, "appendixsubsubsec", 17 }, /* TEXICMD_APPENDIXSUBSUBSEC */

{ doinline, "asis", 4 }, /* TEXICMD_ASIS */

{ dosymbol, "*", 1 }, /* TEXICMD_ASTERISK */

{ dosymbol, "@", 1 }, /* TEXICMD_AT */

{ doignline, "author", 6 }, /* TEXICMD_AUTHOR */

Line 105 static const struct texitok __texitoks[TEXICMD__MAX] =

Line 109 static const struct texitok __texitoks[TEXICMD__MAX] =

{ doignline, "contents", 8 }, /* TEXICMD_CONTENTS */

{ doignblock, "copying", 7 }, /* TEXICMD_COPYING */

{ dosymbol, "copyright", 9 }, /* TEXICMD_COPYRIGHT */

{ dodefindex, "defcodeindex", 12 }, /* TEXICMD_DEFCODEINDEX */

{ dodefn, "deffn", 5 }, /* TEXICMD_DEFFN */

{ dodefn, "deffnx", 6 }, /* TEXICMD_DEFFNX */

{ dodefindex, "defindex", 8 }, /* TEXICMD_DEFINDEX */

{ dodefn, "defmac", 6 }, /* TEXICMD_DEFMAC */

{ dodefn, "defmacx", 7 }, /* TEXICMD_DEFMACX */

{ dodefn, "deftp", 5 }, /* TEXICMD_DEFTP */

Line 130 static const struct texitok __texitoks[TEXICMD__MAX] =

Line 136 static const struct texitok __texitoks[TEXICMD__MAX] =

{ doignline, "dircategory", 11 }, /* TEXICMD_DIRCATEGORY */

{ doignblock, "direntry", 8 }, /* TEXICMD_DIRENTRY */

{ dodisplay, "display", 7 }, /* TEXICMD_DISPLAY */

{ doignbracket, "dmn", 3 }, /* TEXICMD_DMN */

{ dosymbol, "dots", 4 }, /* TEXICMD_DOTS */

{ dolink, "email", 5 }, /* TEXICMD_EMAIL */

{ doinline, "emph", 4 }, /* TEXICMD_EMPH */

{ NULL, "end", 3 }, /* TEXICMD_END */

{ doenumerate, "enumerate", 9 }, /* TEXICMD_ENUMERATE */

{ doinline, "env", 3 }, /* TEXICMD_ENV */

{ dosymbol, "equiv", 5 }, /* TEXICMD_EQUIV */

{ dosymbol, "error", 5 }, /* TEXICMD_ERROR */

{ doexample, "example", 7 }, /* TEXICMD_EXAMPLE */

{ doignline, "exdent", 6 }, /* TEXICMD_EXDENT */

{ dosymbol, "expansion", 9 }, /* TEXICMD_EXPANSION */

{ doinline, "file", 4 }, /* TEXICMD_FILE */

{ doignline, "finalout", 8 }, /* TEXICMD_FINALOUT */

Line 149 static const struct texitok __texitoks[TEXICMD__MAX] =

Line 158 static const struct texitok __texitoks[TEXICMD__MAX] =

{ dosection, "heading", 7 }, /* TEXICMD_HEADING */

{ doignline, "headings", 8 }, /* TEXICMD_HEADINGS */

{ doitem, "headitem", 8 }, /* TEXICMD_HEADITEM */

{ doignblock, "html", 4 }, /* TEXICMD_HTML */

{ dosymbol, "-", 1 }, /* TEXICMD_HYPHEN */

{ doinline, "i", 1 }, /* TEXICMD_I */

{ dovalue, "ifclear", 7 }, /* TEXICMD_IFCLEAR */

{ doignblock, "ifdocbook", 9 }, /* TEXICMD_IFDOCBOOK */

{ doignblock, "ifhtml", 6 }, /* TEXICMD_IFHTML */

{ doignblock, "ifinfo", 6 }, /* TEXICMD_IFINFO */

{ doblock, "ifinfo", 6 }, /* TEXICMD_IFINFO */

{ doblock, "ifnotdocbook", 12 }, /* TEXICMD_IFNOTDOCBOOK */

{ doblock, "ifnothtml", 9 }, /* TEXICMD_IFNOTHTML */

{ doblock, "ifnotinfo", 9 }, /* TEXICMD_IFNOTINFO */

Line 163 static const struct texitok __texitoks[TEXICMD__MAX] =

Line 173 static const struct texitok __texitoks[TEXICMD__MAX] =

{ doblock, "ifnotxml", 8 }, /* TEXICMD_IFNOTXML */

{ doblock, "ifplaintext", 11 }, /* TEXICMD_IFPLAINTEXT */

{ doignblock, "iftex", 5 }, /* TEXICMD_IFTEX */

{ doignblock, "ifset", 5 }, /* TEXICMD_IFSET */

{ dovalue, "ifset", 5 }, /* TEXICMD_IFSET */

{ doignblock, "ifxml", 5 }, /* TEXICMD_IFXML */

{ doignblock, "ignore", 6 }, /* TEXICMD_IGNORE */

{ doignbracket, "image", 5 }, /* TEXICMD_IMAGE */

{ doinclude, "include", 7 }, /* TEXICMD_INCLUDE */

{ dodisplay, "indentblock", 11 }, /* TEXICMD_INDENTBLOCK */

{ doignline, "", 0 }, /* TEXICMD_USER_INDEX */

{ doignline, "insertcopying", 13 }, /* TEXICMD_INSERTCOPYING */

{ doitem, "item", 4 }, /* TEXICMD_ITEM */

{ doitemize, "itemize", 7 }, /* TEXICMD_ITEMIZE */

Line 178 static const struct texitok __texitoks[TEXICMD__MAX] =

Line 189 static const struct texitok __texitoks[TEXICMD__MAX] =

{ doignline, "kindex", 6 }, /* TEXICMD_KINDEX */

{ dosymbol, "LaTeX", 5 }, /* TEXICMD_LATEX */

{ dosecoffs, "lowersections", 13 }, /* TEXICMD_LOWERSECTIONS */

{ domacro, "macro", 5 }, /* TEXICMD_MACRO */

{ domath, "math", 4 }, /* TEXICMD_MATH */

{ doignblock, "menu", 4 }, /* TEXICMD_MENU */

{ dosymbol, "minus", 5 }, /* TEXICMD_MINUS */

{ domultitable, "multitable", 10 }, /* TEXICMD_MULTITABLE */

{ doignline, "need", 4 }, /* TEXICMD_NEED */

{ dosymbol, "\n", 1 }, /* TEXICMD_NEWLINE */

Line 190 static const struct texitok __texitoks[TEXICMD__MAX] =

Line 203 static const struct texitok __texitoks[TEXICMD__MAX] =

{ dosymbol, "?", 1 }, /* TEXICMD_QUESTIONMARK */

{ doquotation, "quotation", 9 }, /* TEXICMD_QUOTATION */

{ doignline, "page", 4 }, /* TEXICMD_PAGE */

{ doignline, "paragraphindent", 14 }, /* TEXICMD_PARINDENT */

{ doignline, "paragraphindent", 15 }, /* TEXICMD_PARINDENT */

{ dosymbol, ".", 1 }, /* TEXICMD_PERIOD */

{ doignline, "pindex", 6 }, /* TEXICMD_PINDEX */

{ doignline, "printindex", 10 }, /* TEXICMD_PRINTINDEX */

{ doinline, "r", 1 }, /* TEXICMD_R */

{ dosecoffs, "raisesections", 13 }, /* TEXICMD_RAISESECTIONS */

{ dobracket, "ref", 3 }, /* TEXICMD_REF */

{ doignline, "refill", 6 }, /* TEXICMD_REFILL */

{ dosymbol, "result", 6 }, /* TEXICMD_RESULT */

{ doinline, "samp", 4 }, /* TEXICMD_SAMP */

{ doinline, "sansserif", 9 }, /* TEXICMD_SANSSERIF */

Line 204 static const struct texitok __texitoks[TEXICMD__MAX] =

Line 220 static const struct texitok __texitoks[TEXICMD__MAX] =

{ doignline, "setchapternewpage", 17 }, /* TEXICMD_SETCHAPNEWPAGE */

{ doignline, "setfilename", 11 }, /* TEXICMD_SETFILENAME */

{ dotitle, "settitle", 8 }, /* TEXICMD_SETTITLE */

{ doignline, "shortcontents", 13 }, /* TEXICMD_SHORTCONTENTS */

{ doinline, "slanted", 7 }, /* TEXICMD_SLANTED */

{ dosp, "sp", 2 }, /* TEXICMD_SP */

{ dosymbol, " ", 1 }, /* TEXICMD_SPACE */

Line 217 static const struct texitok __texitoks[TEXICMD__MAX] =

Line 234 static const struct texitok __texitoks[TEXICMD__MAX] =

{ doinline, "strong", 6 }, /* TEXICMD_STRONG */

{ dosubsection, "subheading", 10 }, /* TEXICMD_SUBHEADING */

{ dosubsection, "subsection", 10 }, /* TEXICMD_SUBSECTION */

{ dosubsubsection, "subsubheading", 13 }, /* TEXICMD_SUBSUBHEADING */

{ dosubsubsection, "subsubsection", 13 }, /* TEXICMD_SUBSUBSECTION */

{ doignline, "subtitle", 8 }, /* TEXICMD_SUBTITLE */

{ doignline, "summarycontents", 15 }, /* TEXICMD_SUMMARYCONTENTS */

{ doignline, "synindex", 8 }, /* TEXICMD_SYNINDEX */

{ doignline, "syncodeindex", 12 }, /* TEXICMD_SYNCODEINDEX */

{ doinline, "t", 1 }, /* TEXICMD_T */

{ dotab, "tab", 3 }, /* TEXICMD_TAB */

Line 227 static const struct texitok __texitoks[TEXICMD__MAX] =

Line 247 static const struct texitok __texitoks[TEXICMD__MAX] =

{ doignblock, "tex", 3 }, /* TEXICMD_TEX */

{ dosymbol, "TeX", 3 }, /* TEXICMD_TEXSYM */

{ doaccent, "~", 1 }, /* TEXICMD_TILDE */

{ doignline, "tindex", 6 }, /* TEXICMD_TINDEX */

{ doignline, "title", 5 }, /* TEXICMD_TITLE */

{ dobracket, "titlefont", 9 }, /* TEXICMD_TITLEFONT */

{ doignblock, "titlepage", 9 }, /* TEXICMD_TITLEPAGE */

Line 240 static const struct texitok __texitoks[TEXICMD__MAX] =

Line 261 static const struct texitok __texitoks[TEXICMD__MAX] =

{ dolink, "url", 3 }, /* TEXICMD_URL */

{ dovalue, "value", 5 }, /* TEXICMD_VALUE */

{ doinline, "var", 3 }, /* TEXICMD_VAR */

{ doverb, "verbatim", 8 }, /* TEXICMD_VERBATIM */

{ doverbinclude, "verbatiminclude", 15 }, /* TEXICMD_VERBATIMINCLUDE */

{ doignline, "vindex", 6 }, /* TEXICMD_VINDEX */

{ dosp, "vskip", 5 }, /* TEXICMD_VSKIP */

Line 251 static const struct texitok __texitoks[TEXICMD__MAX] =

Line 273 static const struct texitok __texitoks[TEXICMD__MAX] =

const struct texitok *const texitoks = __texitoks;

static char *

static void

lineargdup(struct texi *p, const char *buf, size_t sz, size_t *pos)

dodefindex(struct texi *p, enum texicmd cmd,

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

{

char *key;

size_t start, end;

char *cp;

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

advance(p, buf, pos);

if (*pos == sz)

return(NULL);

start = end = *pos;

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

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

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

end++;

break;

advanceto(p, buf, pos, end);

if (start == end) {

if (*pos < sz)

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

advance(p, buf, pos);

return;

key = malloc(end - start + 1);

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

if (NULL == key) {

texiabort(p, NULL);

perror(NULL);

exit(EXIT_FAILURE);

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

}

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

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

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

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

return(key);

sizeof(char *) * (p->indexsz + 1));

if (NULL == p->indexs)

texiabort(p, NULL);

p->indexs[p->indexsz++] = cp;

}

static void

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

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

}

static void

domacro(struct texi *p, enum texicmd cmd,

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

{

size_t start, end, endtoksz, len;

struct teximacro m;

const char *endtok, *blk;

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

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

advance(p, buf, pos);

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

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

break;

if (start == end)

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

advanceto(p, buf, pos, end);

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

if (NULL == m.key)

texiabort(p, NULL);

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

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

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

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

start = *pos;

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

endtoksz = strlen(endtok);

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

if (NULL == blk)

texierr(p, "unterminated macro body");

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

advance(p, buf, pos);

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

advance(p, buf, pos);

len = blk - &buf[start];

m.value = malloc(len + 1);

if (NULL == m.value)

texiabort(p, NULL);

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

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

p->macros = realloc

(p->macros,

(p->macrosz + 1) *

sizeof(struct teximacro));

if (NULL == p->macros)

texiabort(p, NULL);

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

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

}

static void

doignblock(struct texi *p, enum texicmd cmd,

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

{

char end[32];

p->ign++;

const char *term;

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

size_t endsz, endpos;

p->ign--;

* We want to completely ignore everything in these blocks, so

* simply jump to the @end block.

endsz = snprintf(end, sizeof(end),

"\n@end %s\n", texitoks[cmd].tok);

assert(endsz < sizeof(end));

* Look up where our end token occurs.

* Set our end position based on the relative offset of that

* from our current position, or the EOF if we don't have a

* proper ending point.

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

endpos = NULL == term ? sz :

*pos + term - &buf[*pos];

assert(endpos <= sz);

while (*pos < endpos)

advance(p, buf, pos);

/* Only do this if we're not already at the end. */

if (endpos < sz)

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

}

static void

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

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

break;

}

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

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

parsebracket(p, buf, sz, pos);

return;

}

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

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

}

static void

doverb(struct texi *p, enum texicmd cmd,

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

{

const char *end, *term;

size_t endsz, endpos;

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

/* We end at exactly this token. */

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

endsz = strlen(end);

* Look up where our end token occurs.

* Set our end position based on the relative offset of that

* from our current position.

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

endpos = NULL == term ? sz :

*pos + term - &buf[*pos];

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

assert(endpos <= sz);

while (*pos < endpos) {

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

p->outcol = 0;

else

p->outcol++;

if (*pos > 0 && '.' == buf[*pos])

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

fputs("\\&", stdout);

putchar(buf[*pos]);

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

putchar('e');

advance(p, buf, pos);

}

teximacro(p, "Ed");

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

}

static void

doverbinclude(struct texi *p, enum texicmd cmd,

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

{

char fname[PATH_MAX], path[PATH_MAX];

int rc;

size_t i;

size_t i, end;

const char *v;

enum texicmd type;

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

advance(p, buf, pos);

/* Read in the filename. */

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

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

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

break;

fname[i] = buf[*pos];

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

advance(p, buf, pos);

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

advance(p, buf, pos);

continue;

}

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

advanceto(p, buf, pos, end);

if (TEXICMD_VALUE != type)

texierr(p, "unknown verbatiminclude command");

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

if (NULL == v)

continue;

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

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

break;

fname[i++] = *v++;

}

if ('\0' != *v)

break;

}

if (i == 0)

Line 517 static void

Line 686 static void

doinclude(struct texi *p, enum texicmd cmd,

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

{

char fname[PATH_MAX], path[PATH_MAX];

size_t i;

size_t i, end;

int rc;

const char *v;

enum texicmd type;

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

advance(p, buf, pos);

/* Read in the filename. */

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

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

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

break;

fname[i] = buf[*pos];

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

advance(p, buf, pos);

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

advance(p, buf, pos);

continue;

}

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

advanceto(p, buf, pos, end);

if (TEXICMD_VALUE != type)

texierr(p, "unknown include command");

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

if (NULL == v)

continue;

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

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

break;

fname[i++] = *v++;

}

if ('\0' != *v)

break;

}

if (i == 0)

Line 624 dotitle(struct texi *p, enum texicmd cmd,

Line 812 dotitle(struct texi *p, enum texicmd cmd,

start = end = *pos;

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

end++;

advanceeoln(p, buf, sz, 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);

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

}

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

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

case (TEXICMD_DOTS):

texiputchars(p, "...");

break;

case (TEXICMD_EQUIV):

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

break;

case (TEXICMD_ERROR):

texiputchars(p, "error\\(->");

break;

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

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

case (TEXICMD_LATEX):

texiputchars(p, "LaTeX");

break;

case (TEXICMD_MINUS):

texiputchars(p, "\\-");

break;

case (TEXICMD_PERIOD):

texiputchar(p, '.');

break;

case (TEXICMD_QUESTIONMARK):

texiputchar(p, '?');

break;

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

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

case (TEXICMD_HYPHEN):

break;

default:

texiwarn(p, "sym: %d", cmd);

abort();

}

Line 830 static void

Line 1029 static void

dovalue(struct texi *p, enum texicmd cmd,

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

{

size_t i, start, end;

size_t start, end, i;

int clr;

char *key, *val;

const char *cp;

if (TEXICMD_SET == cmd) {

* If we're going to set a value, then first parse the

* key and value from the input stream.

* Disallow empty keys.

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

advance(p, buf, pos);

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

if (ismspace(buf[end]))

break;

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

if (start == end)

return;

advanceto(p, buf, pos, end);

key = malloc(end - start + 1);

if (NULL == key) {

if (NULL == key)

perror(NULL);

texiabort(p, NULL);

exit(EXIT_FAILURE);

}

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

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

advanceto(p, buf, pos, end);

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

advance(p, buf, pos);

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

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

break;

/* We do allow empty values. */

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

val = malloc(end - start + 1);

if (NULL == val) {

if (NULL == val)

perror(NULL);

texiabort(p, NULL);

exit(EXIT_FAILURE);

}

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

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

valueadd(p, key, val);

* Now look up the key in our table of existing keys.

* If we find it, then free the local key and replace

* the value (freeing the existing) of the existing.

* If not, reallocate the structure.

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

if (0 == strcmp(p->vals[i].key, key))

break;

if (i < p->valsz) {

free(key);

free(p->vals[i].value);

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

} else {

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

(p->valsz + 1) *

sizeof(struct texivalue));

if (NULL == p->vals) {

perror(NULL);

exit(EXIT_FAILURE);

}

p->vals[p->valsz].key = key;

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

p->valsz++;

}

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

} else if (TEXICMD_VALUE == cmd) {

* First, parse out the key from the stream, which is

* just the material within the quotes.

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

advance(p, buf, pos);

if (*pos == sz)

return;

advance(p, buf, pos);

start = *pos;

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

advance(p, buf, pos);

if ((end = *pos) < sz)

advance(p, buf, pos);

key = malloc(end - start + 1);

if (NULL == key) {

perror(NULL);

exit(EXIT_FAILURE);

}

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

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

* Next, look up the key in our table.

* If it exists, print it out, being mindful all the

* while of prior whitespace.

* If it doesn't, print out a message.

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

if (0 == strcmp(p->vals[i].key, key))

break;

if (p->seenws)

texiputchar(p, ' ');

p->seenws = 0;

if (i == p->valsz || NULL == p->vals[i].value) {

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

texiputchars(p, "{No value for \\(lq");

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

texiputchars(p, key);

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

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

break;

} else

if (i < p->valstackpos)

texiputchars(p, p->vals[i].value);

texierr(p, "recursive value");

free(key);

if (64 == p->valstackpos)

} else if (TEXICMD_CLEAR == cmd) {

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

key = lineargdup(p, buf, sz, pos);

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

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

parseeof(p, cp, strlen(cp));

if (0 == strcmp(p->vals[i].key, key)) {

p->valstackpos--;

free(p->vals[i].value);

} else

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

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

break;

}

free(key);

} else if (TEXICMD_IFCLEAR == cmd) {

key = lineargdup(p, buf, sz, pos);

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

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

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

if (0 == strcmp(p->vals[i].key, key))

else

break;

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

free(key);

} else if (TEXICMD_IFSET == cmd) {

clr = i < p->valsz && NULL != p->vals[i].value;

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

if (clr)

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

p->ign++;

else

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

if (clr)

} else if (TEXICMD_CLEAR == cmd)

p->ign--;

valuelclear(p, buf, sz, pos);

}

static void

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

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

time_t t;

char date[32];

if (--p->ign)

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

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

* We use the title set with @settitle for the `Nd' description

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

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

t = time(NULL);

strftime(date, sizeof(date), "%F", localtime(&t));

p->ign--;

teximacroopen(p, "Dd");

texiputchars(p, date);

teximacroclose(p);

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

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

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

* have.

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

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

advanceto(p, buf, pos, end);

if (TEXICMD_COLUMNFRACTIONS != type)

texierr(p, "unknown multitable type");

texierr(p, "unknown multitable command");

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

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

advance(p, buf, pos);

Line 1354 doignline(struct texi *p, enum texicmd cmd,

Line 1484 doignline(struct texi *p, enum texicmd cmd,

* This does NOT sanitise the directories!

static char **

parsedirs(const char *base, const char *cp, size_t *sz)

parsedirs(struct texi *p, const char *base, const char *cp, size_t *sz)

{

char *tok, *str, *tofree;

const char *cpp;

Line 1366 parsedirs(const char *base, const char *cp, size_t *sz

Line 1496 parsedirs(const char *base, const char *cp, size_t *sz

for ( ; NULL != (cpp = strchr(cpp, ':')); (*sz)++)

cpp++;

dirs = calloc(*sz, sizeof(char *));

if (NULL == (dirs = calloc(*sz, sizeof(char *))))

if (NULL == dirs) {

texiabort(p, NULL);

perror(NULL);

else if (NULL == (dirs[0] = strdup(base)))

exit(EXIT_FAILURE);

texiabort(p, NULL);

} else if (NULL == (dirs[0] = strdup(base))) {

perror(NULL);

exit(EXIT_FAILURE);

}

if (NULL == cp)

return(dirs);

if (NULL == (tofree = tok = str = strdup(cp))) {

if (NULL == (tofree = tok = str = strdup(cp)))

perror(NULL);

texiabort(p, NULL);

exit(EXIT_FAILURE);

}

for (i = 1; NULL != (tok = strsep(&str, ":")); i++)

if (NULL == (dirs[i] = strdup(tok))) {

if (NULL == (dirs[i] = strdup(tok)))

perror(NULL);

texiabort(p, NULL);

exit(EXIT_FAILURE);

}

free(tofree);

return(dirs);

Line 1423 main(int argc, char *argv[])

Line 1545 main(int argc, char *argv[])

if (0 == (argc -= optind))

goto usage;

if (NULL == (path = strdup(argv[0]))) {

if (NULL == (path = strdup(argv[0])))

perror(NULL);

texiabort(&texi, NULL);

exit(EXIT_FAILURE);

else if (NULL == (dir = dirname(path)))

} else if (NULL == (dir = dirname(path))) {

texiabort(&texi, NULL);

perror(argv[0]);

free(path);

exit(EXIT_FAILURE);

}

free(path);

if (NULL != (cp = strrchr(argv[0], '/')))

Line 1438 main(int argc, char *argv[])

Line 1557 main(int argc, char *argv[])

else

texi.title = strdup(argv[0]);

if (NULL == texi.title) {

if (NULL == texi.title)

perror(NULL);

texiabort(&texi, NULL);

exit(EXIT_FAILURE);

else if (NULL != (path = strchr(texi.title, '.')))

} else if (NULL != (path = strchr(texi.title, '.')))

*path = '\0';

texi.ign = 1;

texi.dirs = parsedirs(dir, Idir, &texi.dirsz);

texi.dirs = parsedirs(&texi, dir, Idir, &texi.dirsz);

parsefile(&texi, argv[0], 1);

/* We shouldn't get here. */

texiexit(&texi);

CVSweb