version 1.21, 2015/03/01 13:39:51 |
version 1.29, 2015/03/07 11:53:21 |
|
|
#include "extern.h" |
#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 |
* Unmap the top-most file in the stack of files currently opened (that |
* is, nested calls to parsefile()). |
* is, nested calls to parsefile()). |
*/ |
*/ |
Line 100 texiexit(struct texi *p) |
|
Line 138 texiexit(struct texi *p) |
|
free(p->dirs); |
free(p->dirs); |
free(p->subtitle); |
free(p->subtitle); |
free(p->title); |
free(p->title); |
|
free(p->copying); |
} |
} |
|
|
/* |
/* |
Line 184 texiputchar(struct texi *p, char c) |
|
Line 223 texiputchar(struct texi *p, char c) |
|
if ('\'' == c && 0 == p->outcol) |
if ('\'' == c && 0 == p->outcol) |
fputs("\\&", p->outfile); |
fputs("\\&", p->outfile); |
|
|
fputc(c, p->outfile); |
if (p->uppercase) |
|
fputc(toupper((unsigned int)c), p->outfile); |
|
else |
|
fputc(c, p->outfile); |
if ('\\' == c) |
if ('\\' == c) |
fputc('e', p->outfile); |
fputc('e', p->outfile); |
p->seenvs = 0; |
|
if ('\n' == c) { |
if ('\n' == c) { |
p->outcol = 0; |
p->outcol = 0; |
p->seenws = 0; |
p->seenws = 0; |
Line 210 texiputchars(struct texi *p, const char *s) |
|
Line 251 texiputchars(struct texi *p, const char *s) |
|
fputs("\\&", p->outfile); |
fputs("\\&", p->outfile); |
if ('\'' == *s && 0 == p->outcol) |
if ('\'' == *s && 0 == p->outcol) |
fputs("\\&", p->outfile); |
fputs("\\&", p->outfile); |
p->outcol += fputs(s, p->outfile); |
if (p->uppercase) |
p->seenvs = 0; |
for ( ; '\0' != *s; s++) |
|
p->outcol += fputc(toupper |
|
((unsigned int)*s), p->outfile); |
|
else |
|
p->outcol += fputs(s, p->outfile); |
} |
} |
|
|
/* |
/* |
Line 242 teximacroclose(struct texi *p) |
|
Line 287 teximacroclose(struct texi *p) |
|
fputc('\n', p->outfile); |
fputc('\n', p->outfile); |
p->outcol = p->seenws = 0; |
p->outcol = p->seenws = 0; |
} |
} |
|
p->seenvs = 0; |
} |
} |
|
|
/* |
/* |
Line 275 teximacroopen(struct texi *p, const char *s) |
|
Line 321 teximacroopen(struct texi *p, const char *s) |
|
p->outcol++; |
p->outcol++; |
p->outmacro++; |
p->outmacro++; |
p->seenws = 0; |
p->seenws = 0; |
|
p->seenvs = 0; |
} |
} |
|
|
/* |
/* |
Line 299 teximacro(struct texi *p, const char *s) |
|
Line 346 teximacro(struct texi *p, const char *s) |
|
fputs(s, p->outfile); |
fputs(s, p->outfile); |
fputc('\n', p->outfile); |
fputc('\n', p->outfile); |
p->outcol = p->seenws = 0; |
p->outcol = p->seenws = 0; |
|
p->seenvs = 0; |
} |
} |
|
|
/* |
/* |
|
|
texivspace(struct texi *p) |
texivspace(struct texi *p) |
{ |
{ |
|
|
if (p->seenvs || TEXILIST_TABLE == p->list) |
if (TEXILIST_TABLE != p->list) |
return; |
teximacro(p, "Pp"); |
teximacro(p, "Pp"); |
|
p->seenvs = 1; |
|
} |
} |
|
|
/* |
/* |
Line 362 texipunctuate(struct texi *p, size_t *pos) |
|
Line 408 texipunctuate(struct texi *p, size_t *pos) |
|
case ('.'): |
case ('.'): |
case ('"'): |
case ('"'): |
case (':'): |
case (':'): |
|
case (';'): |
case ('!'): |
case ('!'): |
case ('?'): |
case ('?'): |
continue; |
continue; |
Line 401 advancenext(struct texi *p, size_t *pos) |
|
Line 448 advancenext(struct texi *p, size_t *pos) |
|
|
|
while (*pos < BUFSZ(p) && ismspace(BUF(p)[*pos])) { |
while (*pos < BUFSZ(p) && ismspace(BUF(p)[*pos])) { |
p->seenws = 1; |
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); |
|
advance(p, pos); |
advance(p, pos); |
} |
} |
return(*pos); |
return(*pos); |
Line 415 advancenext(struct texi *p, size_t *pos) |
|
Line 455 advancenext(struct texi *p, size_t *pos) |
|
|
|
/* |
/* |
* Advance to the EOLN in the input stream. |
* Advance to the EOLN in the input stream. |
* NOTE: THIS SHOULD NOT BE CALLED ON BLANK TEXT, as it will read up to |
* This will skip over '@' markers in an effort to ignore escaped |
* the @\n. |
* newlines. |
*/ |
*/ |
size_t |
size_t |
advanceeoln(struct texi *p, size_t *pos, int consumenl) |
advanceeoln(struct texi *p, size_t *pos, int consumenl) |
{ |
{ |
|
|
while (*pos < BUFSZ(p) && '\n' != BUF(p)[*pos]) |
while (*pos < BUFSZ(p) && '\n' != BUF(p)[*pos]) { |
|
if ('@' == BUF(p)[*pos]) |
|
advance(p, pos); |
advance(p, pos); |
advance(p, pos); |
|
} |
if (*pos < BUFSZ(p) && consumenl) |
if (*pos < BUFSZ(p) && consumenl) |
advance(p, pos); |
advance(p, pos); |
return(*pos); |
return(*pos); |
Line 452 texiexecmacro(struct texi *p, struct teximacro *m, siz |
|
Line 495 texiexecmacro(struct texi *p, struct teximacro *m, siz |
|
const char *cp; |
const char *cp; |
|
|
/* Disregard empty macros. */ |
/* Disregard empty macros. */ |
if (0 == (valsz = realsz = strlen(m->value))) |
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; |
return; |
|
} |
|
|
/* |
/* |
* This is important: it protect us from macros that invoke more |
* This is important: it protect us from macros that invoke more |
Line 463 texiexecmacro(struct texi *p, struct teximacro *m, siz |
|
Line 511 texiexecmacro(struct texi *p, struct teximacro *m, siz |
|
* The "sv" value was initialised at the start of the macro. |
* The "sv" value was initialised at the start of the macro. |
*/ |
*/ |
if (sv > 0) |
if (sv > 0) |
if (++p->files[p->filepos].depth > 64) |
if (++p->files[p->filepos - 1].depth > 64) |
texierr(p, "maximium recursive depth"); |
texierr(p, "maximium recursive depth"); |
|
|
args = argparse(p, pos, &asz, m->argsz); |
args = argparse(p, pos, &asz, m->argsz); |
Line 551 texiexecmacro(struct texi *p, struct teximacro *m, siz |
|
Line 599 texiexecmacro(struct texi *p, struct teximacro *m, siz |
|
static void |
static void |
parseword(struct texi *p, size_t *pos, char extra) |
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 == p->literal && TEXILIST_TABLE != p->list) |
|
teximacro(p, "Pp"); |
|
|
|
p->seenvs = 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 && |
if (p->seenws && 0 == p->outmacro && |
p->outcol > 72 && 0 == p->literal) |
p->outcol > 72 && 0 == p->literal) |
texiputchar(p, '\n'); |
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) |
if (p->seenws && p->outcol && 0 == p->literal) |
texiputchar(p, ' '); |
texiputchar(p, ' '); |
|
|
p->seenws = 0; |
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])) { |
while (*pos < BUFSZ(p) && ! ismspace(BUF(p)[*pos])) { |
switch (BUF(p)[*pos]) { |
switch (BUF(p)[*pos]) { |
case ('@'): |
case ('@'): |
Line 570 parseword(struct texi *p, size_t *pos, char extra) |
|
Line 677 parseword(struct texi *p, size_t *pos, char extra) |
|
} |
} |
if ('\0' != extra && BUF(p)[*pos] == extra) |
if ('\0' != extra && BUF(p)[*pos] == extra) |
return; |
return; |
if (*pos < BUFSZ(p) - 1 && |
|
|
if (p->literal) { |
|
texiputchar(p, BUF(p)[*pos]); |
|
advance(p, pos); |
|
continue; |
|
} |
|
|
|
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] && |
'`' == BUF(p)[*pos + 1]) { |
'`' == BUF(p)[*pos + 1]) { |
texiputchars(p, "\\(lq"); |
texiputchars(p, "\\(lq"); |
Line 582 parseword(struct texi *p, size_t *pos, char extra) |
|
Line 708 parseword(struct texi *p, size_t *pos, char extra) |
|
advance(p, pos); |
advance(p, pos); |
} else |
} else |
texiputchar(p, BUF(p)[*pos]); |
texiputchar(p, BUF(p)[*pos]); |
|
|
advance(p, pos); |
advance(p, pos); |
} |
} |
|
|
|
if (*pos + 1 < BUFSZ(p) && |
|
'\n' == BUF(p)[*pos] && |
|
'\n' == BUF(p)[*pos + 1]) |
|
p->seenvs = 1; |
|
|
|
/* |
|
* 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) && '.' == BUF(p)[*pos - 1]) |
|
texiputchar(p, '\n'); |
} |
} |
|
|
/* |
/* |
Line 607 texicmd(const struct texi *p, size_t pos, size_t *end, |
|
Line 748 texicmd(const struct texi *p, size_t pos, size_t *end, |
|
return(TEXICMD__MAX); |
return(TEXICMD__MAX); |
|
|
/* Alphabetic commands are special. */ |
/* Alphabetic commands are special. */ |
if ( ! isalpha((unsigned char)BUF(p)[pos])) { |
if ( ! isalpha((unsigned int)BUF(p)[pos])) { |
if ((*end = pos + 1) == BUFSZ(p)) |
if ((*end = pos + 1) == BUFSZ(p)) |
return(TEXICMD__MAX); |
return(TEXICMD__MAX); |
for (i = 0; i < TEXICMD__MAX; i++) { |
for (i = 0; i < TEXICMD__MAX; i++) { |
Line 1369 teximdocclose(struct texi *p, int last) |
|
Line 1510 teximdocclose(struct texi *p, int last) |
|
|
|
/* Print a reference to the "top" node. */ |
/* Print a reference to the "top" node. */ |
if (p->chapnum > 1) { |
if (p->chapnum > 1) { |
|
texiputchars(p, "Top node,"); |
snprintf(buf, sizeof(buf), "node1 7"); |
snprintf(buf, sizeof(buf), "node1 7"); |
teximacroopen(p, "Xr "); |
teximacroopen(p, "Xr "); |
texiputchars(p, buf); |
texiputchars(p, buf); |
texiputchars(p, " ,"); |
texiputchars(p, " ;"); |
teximacroclose(p); |
teximacroclose(p); |
} |
} |
|
|
/* Print a reference to the previous node. */ |
/* Print a reference to the previous node. */ |
if (p->chapnum > 2) { |
if (p->chapnum > 2) { |
|
texiputchars(p, "previous node,"); |
snprintf(buf, sizeof(buf), |
snprintf(buf, sizeof(buf), |
"node%zu 7", p->chapnum - 1); |
"node%zu 7", p->chapnum - 1); |
teximacroopen(p, "Xr "); |
teximacroopen(p, "Xr "); |
texiputchars(p, buf); |
texiputchars(p, buf); |
if ( ! last) |
if ( ! last) |
texiputchars(p, " ,"); |
texiputchars(p, " ;"); |
teximacroclose(p); |
teximacroclose(p); |
} |
} |
|
|
/* Print a reference to the next node. */ |
/* Print a reference to the next node. */ |
if ( ! last) { |
if ( ! last) { |
|
if (1 == p->chapnum) |
|
texiputchars(p, "Next node,"); |
|
else |
|
texiputchars(p, "next node,"); |
snprintf(buf, sizeof(buf), |
snprintf(buf, sizeof(buf), |
"node%zu 7", p->chapnum + 1); |
"node%zu 7", p->chapnum + 1); |
teximacroopen(p, "Xr "); |
teximacroopen(p, "Xr "); |
Line 1455 teximdocopen(struct texi *p, size_t *pos) |
|
Line 1602 teximdocopen(struct texi *p, size_t *pos) |
|
} else |
} else |
texiputchars(p, "Unknown description"); |
texiputchars(p, "Unknown description"); |
teximacroclose(p); |
teximacroclose(p); |
p->seenvs = 1; |
|
} |
} |
|
|