=================================================================== RCS file: /cvs/texi2mdoc/util.c,v retrieving revision 1.15 retrieving revision 1.33 diff -u -p -r1.15 -r1.33 --- texi2mdoc/util.c 2015/02/25 14:49:14 1.15 +++ texi2mdoc/util.c 2015/03/13 08:07:34 1.33 @@ -1,4 +1,4 @@ -/* $Id: util.c,v 1.15 2015/02/25 14:49:14 kristaps Exp $ */ +/* $Id: util.c,v 1.33 2015/03/13 08:07:34 kristaps Exp $ */ /* * Copyright (c) 2015 Kristaps Dzonsons * @@ -20,8 +20,6 @@ #include #include #include -#include -#include #include #include #include @@ -33,6 +31,44 @@ #include "extern.h" /* + * Table of macros. + * These ABSOLUTELY MUST BE 2 or three characters long. + */ +static const char *const mdocs[] = { + "Ap", "Dd", "Dt", "Os", + "Sh", "Ss", "Pp", "D1", + "Dl", "Bd", "Ed", "Bl", + "El", "It", "Ad", "An", + "Ar", "Cd", "Cm", "Dv", + "Er", "Ev", "Ex", "Fa", + "Fd", "Fl", "Fn", "Ft", + "Ic", "In", "Li", "Nd", + "Nm", "Op", "Ot", "Pa", + "Rv", "St", "Va", "Vt", + "Xr", "%A", "%B", "%D", + "%I", "%J", "%N", "%O", + "%P", "%R", "%T", "%V", + "Ac", "Ao", "Aq", "At", + "Bc", "Bf", "Bo", "Bq", + "Bsx", "Bx", "Db", "Dc", + "Do", "Dq", "Ec", "Ef", + "Em", "Eo", "Fx", "Ms", + "No", "Ns", "Nx", "Ox", + "Pc", "Pf", "Po", "Pq", + "Qc", "Ql", "Qo", "Qq", + "Re", "Rs", "Sc", "So", + "Sq", "Sm", "Sx", "Sy", + "Tn", "Ux", "Xc", "Xo", + "Fo", "Fc", "Oo", "Oc", + "Bk", "Ek", "Bt", "Hf", + "Fr", "Ud", "Lb", "Lp", + "Lk", "Mt", "Brq", "Bro", + "Brc", "%C", "Es", "En", + "Dx", "%Q", "br", "sp", + "%U", "Ta", "ll", NULL, + }; + +/* * Unmap the top-most file in the stack of files currently opened (that * is, nested calls to parsefile()). */ @@ -67,7 +103,119 @@ texivaluefree(struct texivalue *p) free(p->value); } +static void +texidex_free(struct texidex *p) +{ + size_t i; + + for (i = 0; i < p->indexsz; i++) + free(p->index[i].term); + + free(p->index); + free(p->name); + p->index = NULL; + p->indexsz = 0; +} + /* + * Add the text beginning at "index" and of "sz" bytes to the index + * named "tok" with name size "toksz". + * This will also output the necessary mdoc(7) to construct the index. + */ +void +texindex(struct texi *p, const char *tok, + size_t toksz, const char *index, size_t sz) +{ + size_t i, isz; +#ifdef HAVE_INDEX + char *cp; +#endif + + if (0 == sz) { + texiwarn(p, "zero-length index entry"); + return; + } + + /* Look for the index. (Must be found.) */ + for (i = 0; i < p->indexsz; i++) { + if (strlen(p->indexs[i].name) != toksz) + continue; + if (strncmp(p->indexs[i].name, tok, toksz)) + continue; + break; + } + + assert(i < p->indexsz); + isz = p->indexs[i].indexsz; + /* Reallocate index's terms. */ + p->indexs[i].index = realloc + (p->indexs[i].index, + (isz + 1) * sizeof(struct texiterm)); + if (NULL == p->indexs[i].index) + texiabort(p, NULL); + + /* Add term to term array. */ + p->indexs[i].index[isz].chapter = p->nodecur; + p->indexs[i].index[isz].term = malloc(sz + 1); + if (NULL == p->indexs[i].index[isz].term) + 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; + teximacroopen(p, "Ix"); + texiputchars(p, "idx"); + texiputchars(p, p->indexs[i].name); + cp = p->indexs[i].index[isz].term; + while ('\n' != *cp) + texiputchar(p, *cp++); + teximacroclose(p); +#endif + p->indexs[i].indexsz++; +} + +/* + * Add an index entry named "tok" of length "sz". + * This usually consists of two letters, e.g., "cp" or "vr". + * This does nothing if the index exists or is zero-sized. + */ +void +texindex_add(struct texi *p, const char *tok, size_t sz) +{ + size_t i; + char *cp; + + if (0 == sz) + return; + + /* Make sure we don't have a duplicate. */ + for (i = 0; i < p->indexsz; i++) { + if (strlen(p->indexs[i].name) != sz) + continue; + if (strncmp(p->indexs[i].name, tok, sz)) + continue; + return; + } + + /* Reallocate indices. */ + p->indexs = realloc(p->indexs, + sizeof(struct texidex) * + (p->indexsz + 1)); + if (NULL == p->indexs) + texiabort(p, NULL); + if (NULL == (cp = malloc(sz + 1))) + texiabort(p, NULL); + memcpy(cp, tok, sz); + cp[sz] = '\0'; + p->indexs[p->indexsz].name = cp; + p->indexs[p->indexsz].index = NULL; + p->indexs[p->indexsz].indexsz = 0; + p->indexsz++; +} + +/* * Unmap all files that we're currently using and free all resources * that we've allocated during the parse. * The utility should exit(...) after this is called. @@ -79,7 +227,9 @@ texiexit(struct texi *p) /* Make sure we're newline-terminated. */ if (p->outcol) - putchar('\n'); + fputc('\n', p->outfile); + if (NULL != p->chapters) + teximdocclose(p, 1); /* Unmap all files. */ while (p->filepos > 0) @@ -90,16 +240,18 @@ texiexit(struct texi *p) for (i = 0; i < p->dirsz; i++) free(p->dirs[i]); for (i = 0; i < p->indexsz; i++) - free(p->indexs[i]); + texidex_free(&p->indexs[i]); for (i = 0; i < p->valsz; i++) texivaluefree(&p->vals[i]); + free(p->nodecache); free(p->macros); free(p->vals); free(p->indexs); free(p->dirs); free(p->subtitle); free(p->title); + free(p->copying); } /* @@ -180,14 +332,16 @@ texiputchar(struct texi *p, char c) if (p->ign) return; if ('.' == c && 0 == p->outcol) - fputs("\\&", stdout); + fputs("\\&", p->outfile); if ('\'' == c && 0 == p->outcol) - fputs("\\&", stdout); + fputs("\\&", p->outfile); - putchar(c); + if (p->uppercase) + fputc(toupper((unsigned int)c), p->outfile); + else + fputc(c, p->outfile); if ('\\' == c) - putchar('e'); - p->seenvs = 0; + fputc('e', p->outfile); if ('\n' == c) { p->outcol = 0; p->seenws = 0; @@ -207,11 +361,15 @@ texiputchars(struct texi *p, const char *s) if (p->ign) return; if ('.' == *s && 0 == p->outcol) - fputs("\\&", stdout); + fputs("\\&", p->outfile); if ('\'' == *s && 0 == p->outcol) - fputs("\\&", stdout); - p->outcol += fputs(s, stdout); - p->seenvs = 0; + fputs("\\&", p->outfile); + if (p->uppercase) + for ( ; '\0' != *s; s++) + p->outcol += fputc(toupper + ((unsigned int)*s), p->outfile); + else + p->outcol += fputs(s, p->outfile); } /* @@ -235,11 +393,11 @@ void teximacroclose(struct texi *p) { - if (p->ign) + if (p->ign || p->literal|| TEXILIST_TABLE == p->list) return; if (0 == --p->outmacro) { - putchar('\n'); + fputc('\n', p->outfile); p->outcol = p->seenws = 0; } } @@ -255,26 +413,29 @@ teximacroopen(struct texi *p, const char *s) { int rc; - if (p->ign) + if (p->ign || p->literal|| TEXILIST_TABLE == p->list) return; if (p->outcol && 0 == p->outmacro) { - putchar('\n'); + fputc('\n', p->outfile); p->outcol = 0; } + if (p->seenvs > 0 && 0 == p->outmacro) + fputs(".Pp\n", p->outfile); + if (0 == p->outmacro) - putchar('.'); + fputc('.', p->outfile); else - putchar(' '); + fputc(' ', p->outfile); - if (EOF != (rc = fputs(s, stdout))) + if (EOF != (rc = fputs(s, p->outfile))) p->outcol += rc; - putchar(' '); + fputc(' ', p->outfile); p->outcol++; p->outmacro++; - p->seenws = 0; + p->seenws = p->seenvs = 0; } /* @@ -291,12 +452,14 @@ teximacro(struct texi *p, const char *s) texierr(p, "\"%s\" in open line scope!?", s); if (p->literal) texierr(p, "\"%s\" in a literal scope!?", s); - if (p->outcol) - putchar('\n'); + fputc('\n', p->outfile); + if (p->seenvs > 0) + fputs(".Pp\n", p->outfile); - putchar('.'); - puts(s); + fputc('.', p->outfile); + fputs(s, p->outfile); + fputc('\n', p->outfile); p->outcol = p->seenws = 0; } @@ -307,10 +470,8 @@ void texivspace(struct texi *p) { - if (p->seenvs || TEXILIST_TABLE == p->list) - return; - teximacro(p, "Pp"); - p->seenvs = 1; + if (TEXILIST_TABLE != p->list && p->seenvs >= 0) + p->seenvs = 1; } /* @@ -330,8 +491,11 @@ advance(struct texi *p, size_t *pos) f->col = 0; } else f->col++; - } else + } else { --f->insplice; + if (0 == f->insplice) + f->depth = 0; + } (*pos)++; } @@ -358,6 +522,7 @@ texipunctuate(struct texi *p, size_t *pos) case ('.'): case ('"'): case (':'): + case (';'): case ('!'): case ('?'): continue; @@ -369,7 +534,7 @@ texipunctuate(struct texi *p, size_t *pos) if (end == *pos) return; if (end + 1 == BUFSZ(p) || ' ' == BUF(p)[end] || - '\n' == BUF(p)[end]) { + '@' == BUF(p)[end] || '\n' == BUF(p)[end]) { for ( ; start < end; start++) { texiputchar(p, ' '); texiputchar(p, BUF(p)[start]); @@ -397,13 +562,9 @@ advancenext(struct texi *p, size_t *pos) while (*pos < BUFSZ(p) && ismspace(BUF(p)[*pos])) { p->seenws = 1; - /* - * If it looks like we've printed a double-line, then - * output a paragraph. - * FIXME: this is stupid. - */ - if (*pos && '\n' == BUF(p)[*pos] && '\n' == BUF(p)[*pos - 1]) - texivspace(p); + if (0 == p->seenvs && '\n' == BUF(p)[*pos]) + if (*pos + 1 < BUFSZ(p) && '\n' == BUF(p)[*pos + 1]) + p->seenvs = 1; advance(p, pos); } return(*pos); @@ -411,15 +572,19 @@ advancenext(struct texi *p, size_t *pos) /* * Advance to the EOLN in the input stream. - * NOTE: THIS SHOULD NOT BE CALLED ON BLANK TEXT, as it will read up to - * the @\n. + * This will skip over '@' markers in an effort to ignore escaped + * newlines. */ size_t advanceeoln(struct texi *p, size_t *pos, int consumenl) { - while (*pos < BUFSZ(p) && '\n' != BUF(p)[*pos]) - advance(p, pos); + while (*pos < BUFSZ(p) && '\n' != BUF(p)[*pos]) { + if ('@' == BUF(p)[*pos]) + advance(p, pos); + if (*pos < BUFSZ(p)) + advance(p, pos); + } if (*pos < BUFSZ(p) && consumenl) advance(p, pos); return(*pos); @@ -439,7 +604,7 @@ advanceto(struct texi *p, size_t *pos, size_t end) } static void -texiexecmacro(struct texi *p, struct teximacro *m, size_t *pos) +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; @@ -447,17 +612,36 @@ texiexecmacro(struct texi *p, struct teximacro *m, siz char **args; const char *cp; + /* Disregard empty macros. */ + if (0 == (valsz = realsz = strlen(m->value))) { + args = argparse(p, pos, &asz, m->argsz); + for (i = 0; i < asz; i++) + free(args[i]); + free(args); + return; + } + + /* + * This is important: it protect us from macros that invoke more + * macros, possibly going on infinitely. + * We use "sv" instead of the current position because we might + * be invoked at the end of the macro (i.e., insplice == 0). + * The "sv" value was initialised at the start of the macro. + */ + if (sv > 0) + if (++p->files[p->filepos - 1].depth > 64) + texierr(p, "maximium recursive depth"); + args = argparse(p, pos, &asz, m->argsz); if (asz != m->argsz) texiwarn(p, "invalid macro argument length"); aasz = asz < m->argsz ? asz : m->argsz; if (0 == aasz) { - texisplice(p, m->value, strlen(m->value), pos); + texisplice(p, m->value, valsz, *pos); return; } - valsz = realsz = strlen(m->value); val = strdup(m->value); for (i = j = 0; i < realsz; i++) { @@ -517,7 +701,7 @@ texiexecmacro(struct texi *p, struct teximacro *m, siz i = end; } - texisplice(p, val, strlen(val), pos); + texisplice(p, val, strlen(val), *pos); for (i = 0; i < asz; i++) free(args[i]); @@ -533,16 +717,77 @@ 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 + * this text block with a `Pp'. + * We don't do this if we're in a literal context (we'll print + * out the newlines themselves) nor in a `TS' table. + */ + if (p->seenvs > 0 && 0 == p->literal && TEXILIST_TABLE != p->list) { + if (p->outcol > 0) + fputc('\n', p->outfile); + fputs(".Pp\n", p->outfile); + p->outcol = 0; + } + + /* + * Some line control: if we (non-macro, non-literal) already + * 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'); - /* FIXME: abstract this: we use it elsewhere. */ + + /* Usual padding in the case of seen whitespace. */ if (p->seenws && p->outcol && 0 == p->literal) texiputchar(p, ' '); p->seenws = 0; + /* + * If we're in a macro line, we might want to print text that + * happens to be the same as an mdoc(7) macro. + * Obviously, we need to escape these words. + */ + if (p->outmacro) { + end = *pos; + /* Read ahead to get the word length. */ + while (end < BUFSZ(p) && ! ismspace(BUF(p)[end])) { + switch ((c = BUF(p)[end])) { + case ('@'): + case ('}'): + case ('{'): + break; + default: + if ('\0' != extra && extra == c) + break; + end++; + continue; + } + break; + } + len = end - *pos; + /* See if we have a match. */ + for (i = 0; NULL != mdocs[i]; i++) { + /* All macros are 2 or three letters. */ + if (len < 2 || len > 3) + continue; + /* Check the macro word length. */ + if ('\0' == mdocs[i][2] && 2 != len) + continue; + else if ('\0' == mdocs[i][3] && 3 != len) + continue; + if (strncmp(mdocs[i], &BUF(p)[*pos], len)) + continue; + texiputchars(p, "\\&"); + break; + } + } + while (*pos < BUFSZ(p) && ! ismspace(BUF(p)[*pos])) { switch (BUF(p)[*pos]) { case ('@'): @@ -552,7 +797,28 @@ parseword(struct texi *p, size_t *pos, char extra) } if ('\0' != extra && BUF(p)[*pos] == extra) return; - if (*pos < BUFSZ(p) - 1 && + + if (p->literal) { + texiputchar(p, BUF(p)[*pos]); + advance(p, pos); + continue; + } + + 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); + 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"); @@ -564,8 +830,27 @@ parseword(struct texi *p, size_t *pos, char extra) advance(p, pos); } else texiputchar(p, BUF(p)[*pos]); + 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. + */ + if (0 == p->literal && 0 == p->outmacro && *pos < BUFSZ(p)) + switch (BUF(p)[*pos - 1]) { + case ('.'): + case ('!'): + case ('?'): + texiputchar(p, '\n'); + break; + default: + break; + } + + p->seenvs = 0; } /* @@ -574,7 +859,7 @@ parseword(struct texi *p, size_t *pos, char extra) * index after the command name. */ enum texicmd -texicmd(struct texi *p, size_t pos, size_t *end, struct teximacro **macro) +texicmd(const struct texi *p, size_t pos, size_t *end, struct teximacro **macro) { size_t i, len, toksz; @@ -589,7 +874,7 @@ texicmd(struct texi *p, size_t pos, size_t *end, struc return(TEXICMD__MAX); /* Alphabetic commands are special. */ - if ( ! isalpha(BUF(p)[pos])) { + if ( ! isalpha((unsigned int)BUF(p)[pos])) { if ((*end = pos + 1) == BUFSZ(p)) return(TEXICMD__MAX); for (i = 0; i < TEXICMD__MAX; i++) { @@ -619,10 +904,10 @@ texicmd(struct texi *p, size_t pos, size_t *end, struc /* Look for it in our indices. */ for (i = 0; i < p->indexsz; i++) { - toksz = strlen(p->indexs[i]); + toksz = strlen(p->indexs[i].name); if (len != 5 + toksz) continue; - if (strncmp(&BUF(p)[pos], p->indexs[i], toksz)) + if (strncmp(&BUF(p)[pos], p->indexs[i].name, toksz)) continue; if (0 == strncmp(&BUF(p)[pos + toksz], "index", 5)) return(TEXICMD_USER_INDEX); @@ -653,7 +938,7 @@ texicmd(struct texi *p, size_t pos, size_t *end, struc int parsearg(struct texi *p, size_t *pos, size_t num) { - size_t end; + size_t end, sv; enum texicmd cmd; struct teximacro *macro; @@ -684,10 +969,11 @@ parsearg(struct texi *p, size_t *pos, size_t num) continue; } + sv = p->files[p->filepos - 1].insplice; cmd = texicmd(p, *pos, &end, ¯o); advanceto(p, pos, end); if (NULL != macro) - texiexecmacro(p, macro, pos); + texiexecmacro(p, macro, sv, pos); if (TEXICMD__MAX == cmd) continue; if (NULL != texitoks[cmd].fp) @@ -701,9 +987,9 @@ parsearg(struct texi *p, size_t *pos, size_t num) * This will stop in the event of EOF or if we're not at a bracket. */ void -parsebracket(struct texi *p, size_t *pos) +parsebracket(struct texi *p, size_t *pos, int dostack) { - size_t end; + size_t end, sv, stack; enum texicmd cmd; struct teximacro *macro; @@ -714,12 +1000,25 @@ parsebracket(struct texi *p, size_t *pos) return; advance(p, pos); + stack = 0; while ((*pos = advancenext(p, pos)) < BUFSZ(p)) { switch (BUF(p)[*pos]) { case ('}'): + if (stack > 0) { + stack--; + advance(p, pos); + texiputchar(p, '}'); + continue; + } advance(p, pos); return; case ('{'): + if (dostack) { + stack++; + advance(p, pos); + texiputchar(p, '{'); + continue; + } if (0 == p->ign) texiwarn(p, "unexpected \"{\""); advance(p, pos); @@ -731,10 +1030,11 @@ parsebracket(struct texi *p, size_t *pos) continue; } + sv = p->files[p->filepos - 1].insplice; cmd = texicmd(p, *pos, &end, ¯o); advanceto(p, pos, end); if (NULL != macro) - texiexecmacro(p, macro, pos); + texiexecmacro(p, macro, sv, pos); if (TEXICMD__MAX == cmd) continue; if (NULL != texitoks[cmd].fp) @@ -750,7 +1050,7 @@ parsebracket(struct texi *p, size_t *pos) void parseeoln(struct texi *p, size_t *pos) { - size_t end; + size_t end, sv; enum texicmd cmd; struct teximacro *macro; @@ -761,6 +1061,10 @@ parseeoln(struct texi *p, size_t *pos) texiputchar(p, BUF(p)[*pos]); advance(p, pos); } + if (*pos == BUFSZ(p)) { + texiwarn(p, "unexpected EOF"); + return; + } switch (BUF(p)[*pos]) { case ('}'): if (0 == p->ign) @@ -772,6 +1076,8 @@ parseeoln(struct texi *p, size_t *pos) texiwarn(p, "unexpected \"{\""); advance(p, pos); continue; + case ('\n'): + continue; case ('@'): break; default: @@ -779,10 +1085,11 @@ parseeoln(struct texi *p, size_t *pos) continue; } + sv = p->files[p->filepos - 1].insplice; cmd = texicmd(p, *pos, &end, ¯o); advanceto(p, pos, end); if (NULL != macro) - texiexecmacro(p, macro, pos); + texiexecmacro(p, macro, sv, pos); if (TEXICMD__MAX == cmd) continue; if (NULL != texitoks[cmd].fp) @@ -793,14 +1100,43 @@ parseeoln(struct texi *p, size_t *pos) advance(p, pos); } +enum texicmd +peeklinecmd(const struct texi *p, size_t pos) +{ + size_t end; + + while (pos < BUFSZ(p) && isws(BUF(p)[pos])) + pos++; + if (pos == BUFSZ(p) || '@' != BUF(p)[pos]) + return(TEXICMD__MAX); + return(texicmd(p, pos, &end, NULL)); +} + /* + * Peek to see if there's a command after subsequent whitespace. + * If so, return the macro identifier. + * This DOES NOT work with user-defined macros. + */ +enum texicmd +peekcmd(const struct texi *p, size_t pos) +{ + size_t end; + + while (pos < BUFSZ(p) && ismspace(BUF(p)[pos])) + pos++; + if (pos == BUFSZ(p) || '@' != BUF(p)[pos]) + return(TEXICMD__MAX); + return(texicmd(p, pos, &end, NULL)); +} + +/* * Parse a single word or command. * This will return immediately at the EOF. */ -static void +void parsesingle(struct texi *p, size_t *pos) { - size_t end; + size_t end, sv; enum texicmd cmd; struct teximacro *macro; @@ -825,10 +1161,11 @@ parsesingle(struct texi *p, size_t *pos) return; } + sv = p->files[p->filepos - 1].insplice; cmd = texicmd(p, *pos, &end, ¯o); advanceto(p, pos, end); if (NULL != macro) - texiexecmacro(p, macro, pos); + texiexecmacro(p, macro, sv, pos); if (TEXICMD__MAX == cmd) return; if (NULL != texitoks[cmd].fp) @@ -853,7 +1190,7 @@ parselinearg(struct texi *p, size_t *pos) } if (*pos < BUFSZ(p) && '{' == BUF(p)[*pos]) - parsebracket(p, pos); + parsebracket(p, pos, 0); else if (*pos < BUFSZ(p) && '\n' != BUF(p)[*pos]) parsesingle(p, pos); else @@ -875,7 +1212,7 @@ parseeof(struct texi *p) } void -texisplice(struct texi *p, const char *buf, size_t sz, size_t *pos) +texisplice(struct texi *p, const char *buf, size_t sz, size_t pos) { char *cp; struct texifile *f; @@ -892,8 +1229,8 @@ texisplice(struct texi *p, const char *buf, size_t sz, } f->insplice += sz; - memmove(f->map + *pos + sz, f->map + *pos, f->mapsz - *pos); - memcpy(f->map + *pos, buf, sz); + memmove(f->map + pos + sz, f->map + pos, f->mapsz - pos); + memcpy(f->map + pos, buf, sz); f->mapsz += sz; } @@ -905,7 +1242,7 @@ texisplice(struct texi *p, const char *buf, size_t sz, void parseto(struct texi *p, size_t *pos, const char *endtoken) { - size_t end; + size_t end, sv; enum texicmd cmd; size_t endtoksz; struct teximacro *macro; @@ -932,6 +1269,7 @@ parseto(struct texi *p, size_t *pos, const char *endto continue; } + sv = p->files[p->filepos - 1].insplice; cmd = texicmd(p, *pos, &end, ¯o); advanceto(p, pos, end); if (TEXICMD_END == cmd) { @@ -952,12 +1290,15 @@ parseto(struct texi *p, size_t *pos, const char *endto continue; } if (NULL != macro) - texiexecmacro(p, macro, pos); + 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); } /* @@ -1209,6 +1550,9 @@ argparse(struct texi *p, size_t *pos, size_t *argsz, s args = NULL; *argsz = 0; + if (*pos == BUFSZ(p)) + return(args); + if ('{' != BUF(p)[*pos] && hint) { /* * Special case: if we encounter an unbracketed argument @@ -1235,6 +1579,8 @@ argparse(struct texi *p, size_t *pos, size_t *argsz, s } else if ('{' != BUF(p)[*pos]) return(args); + assert('{' == BUF(p)[*pos]); + /* Parse til the closing '}', putting into the array. */ advance(p, pos); while (*pos < BUFSZ(p)) { @@ -1291,3 +1637,137 @@ argparse(struct texi *p, size_t *pos, size_t *argsz, s advance(p, pos); return(args); } + +/* + * If we're printing chapters, then do some naviation here and then + * close our outfile. + * I want to call this the SEE ALSO section, but that's not really what + * it is: we'll refer to the "initial" (top) node and the next and + * previous chapters. + */ +void +teximdocclose(struct texi *p, int last) +{ + char buf[PATH_MAX]; + + if (NULL == p->chapters || 1 == p->nodesz) + return; + + teximacro(p, "Sh INFO NAVIGATION"); + + /* 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 "); + texiputchars(p, buf); + texiputchars(p, " ;"); + teximacroclose(p); + } + + 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,"); + snprintf(buf, sizeof(buf), "%s-%zd 7", + p->chapters, p->nodecache[p->nodecur].next); + p->seenvs = 0; + teximacroopen(p, "Xr "); + texiputchars(p, buf); + teximacroclose(p); + } + + fclose(p->outfile); + p->outfile = NULL; +} + +ssize_t +texicache(struct texi *p, const char *buf, size_t sz) +{ + size_t i; + + for (i = 0; i < p->nodecachesz; i++) { + if (sz != strlen(p->nodecache[i].name)) + continue; + if (strncmp(buf, p->nodecache[i].name, sz)) + continue; + break; + } + if (i < p->nodecachesz) + return(i); + if (NULL == buf) + return(-1); + p->nodecache = realloc + (p->nodecache, + (p->nodecachesz + 1) * sizeof(struct texinode)); + if (NULL == p->nodecache) + texiabort(p, NULL); + p->nodecache[p->nodecachesz].name = malloc(sz + 1); + if (NULL == p->nodecache[p->nodecachesz].name) + texiabort(p, NULL); + memcpy(p->nodecache[p->nodecachesz].name, buf, sz); + p->nodecache[p->nodecachesz].name[sz] = '\0'; + p->nodecache[p->nodecachesz].up = + p->nodecache[p->nodecachesz].next = + p->nodecache[p->nodecachesz].prev = -1; + p->nodecachesz++; + return(p->nodecachesz - 1); +} + +/* + * Here we print our standard mdoc(7) prologue. + * We use the title set with @settitle for the `Nd' description + * and the source document filename (the first one as invoked on + * the command line) for the title. + * The date is set to the current date. + */ +void +teximdocopen(struct texi *p, size_t *pos) +{ + const char *cp; + time_t t; + char date[32]; + + t = time(NULL); + strftime(date, sizeof(date), "%F", localtime(&t)); + + p->seenvs = -1; + teximacroopen(p, "Dd"); + texiputchars(p, date); + teximacroclose(p); + teximacroopen(p, "Dt"); + for (cp = p->title; '\0' != *cp; cp++) + texiputchar(p, toupper((unsigned int)*cp)); + texiputchars(p, " 7"); + teximacroclose(p); + teximacro(p, "Os"); + teximacro(p, "Sh NAME"); + teximacroopen(p, "Nm"); + for (cp = p->title; '\0' != *cp; cp++) + texiputchar(p, *cp); + teximacroclose(p); + teximacroopen(p, "Nd"); + /* + * The subtitle `Nd' can consist of arbitrary macros, so paste + * it and parse to the end of the line. + */ + if (NULL != p->subtitle) { + texisplice(p, p->subtitle, strlen(p->subtitle), *pos); + parseeoln(p, pos); + } else + texiputchars(p, "Unknown description"); + teximacroclose(p); +} +