version 1.4, 2015/02/17 20:27:44 |
version 1.5, 2015/02/18 11:01:56 |
|
|
TEXICMD_AUTHOR, |
TEXICMD_AUTHOR, |
TEXICMD_BANG, |
TEXICMD_BANG, |
TEXICMD_BYE, |
TEXICMD_BYE, |
|
TEXICMD_CENTER, |
TEXICMD_CHAPTER, |
TEXICMD_CHAPTER, |
TEXICMD_CINDEX, |
TEXICMD_CINDEX, |
TEXICMD_CITE, |
TEXICMD_CITE, |
|
|
TEXICMD_IFSET, |
TEXICMD_IFSET, |
TEXICMD_IMAGE, |
TEXICMD_IMAGE, |
TEXICMD_INCLUDE, |
TEXICMD_INCLUDE, |
|
TEXICMD_INSERTCOPYING, |
TEXICMD_ITEM, |
TEXICMD_ITEM, |
TEXICMD_ITEMIZE, |
TEXICMD_ITEMIZE, |
TEXICMD_KBD, |
TEXICMD_KBD, |
|
|
* This keeps any necessary information handy. |
* This keeps any necessary information handy. |
*/ |
*/ |
struct texi { |
struct texi { |
struct texifile files[64]; |
struct texifile files[64]; /* stack of open files */ |
size_t filepos; |
size_t filepos; /* number of open files */ |
size_t outcol; /* column of output */ |
size_t outcol; /* column in output line */ |
int outmacro; /* whether output is in line macro */ |
char **dirs; /* texi directories */ |
int seenws; /* whitespace has been ignored */ |
size_t dirsz; /* number of texi directories */ |
int ign; /* don't print anything */ |
enum texilist list; |
int literal; |
int outmacro; /* whether output is in line macro */ |
char *dir; /* texi directory */ |
int seenws; /* whitespace has been ignored */ |
enum texilist list; |
int ign; /* don't print anything */ |
|
int literal; |
}; |
}; |
|
|
/* FIXME: don't use this crap. */ |
/* FIXME: don't use this crap. */ |
Line 233 static const struct texitok texitoks[TEXICMD__MAX] = { |
|
Line 236 static const struct texitok texitoks[TEXICMD__MAX] = { |
|
{ doignline, "author", 6 }, /* TEXICMD_AUTHOR */ |
{ doignline, "author", 6 }, /* TEXICMD_AUTHOR */ |
{ dosymbol, "!", 1 }, /* TEXICMD_BANG */ |
{ dosymbol, "!", 1 }, /* TEXICMD_BANG */ |
{ dobye, "bye", 3 }, /* TEXICMD_BYE */ |
{ dobye, "bye", 3 }, /* TEXICMD_BYE */ |
|
{ doignline, "center", 5 }, /* TEXICMD_CENTER */ |
{ dochapter, "chapter", 7 }, /* TEXICMD_CHAPTER */ |
{ dochapter, "chapter", 7 }, /* TEXICMD_CHAPTER */ |
{ doignline, "cindex", 6 }, /* TEXICMD_CINDEX */ |
{ doignline, "cindex", 6 }, /* TEXICMD_CINDEX */ |
{ doliteral, "code", 4 }, /* TEXICMD_CODE */ |
{ doliteral, "code", 4 }, /* TEXICMD_CODE */ |
Line 276 static const struct texitok texitoks[TEXICMD__MAX] = { |
|
Line 280 static const struct texitok texitoks[TEXICMD__MAX] = { |
|
{ doignblock, "ifset", 5 }, /* TEXICMD_IFSET */ |
{ doignblock, "ifset", 5 }, /* TEXICMD_IFSET */ |
{ doignbracket, "image", 5 }, /* TEXICMD_IMAGE */ |
{ doignbracket, "image", 5 }, /* TEXICMD_IMAGE */ |
{ doinclude, "include", 7 }, /* TEXICMD_INCLUDE */ |
{ doinclude, "include", 7 }, /* TEXICMD_INCLUDE */ |
|
{ doignline, "insertcopying", 13 }, /* TEXICMD_INSERTCOPYING */ |
{ doitem, "item", 4 }, /* TEXICMD_ITEM */ |
{ doitem, "item", 4 }, /* TEXICMD_ITEM */ |
{ doitemize, "itemize", 7 }, /* TEXICMD_ITEMIZE */ |
{ doitemize, "itemize", 7 }, /* TEXICMD_ITEMIZE */ |
{ doliteral, "kbd", 3 }, /* TEXICMD_KBD */ |
{ doliteral, "kbd", 3 }, /* TEXICMD_KBD */ |
Line 296 static const struct texitok texitoks[TEXICMD__MAX] = { |
|
Line 301 static const struct texitok texitoks[TEXICMD__MAX] = { |
|
{ doignline, "set", 3 }, /* TEXICMD_SET */ |
{ doignline, "set", 3 }, /* TEXICMD_SET */ |
{ doignline, "setchapternewpage", 17 }, /* TEXICMD_SETCHAPNEWPAGE */ |
{ doignline, "setchapternewpage", 17 }, /* TEXICMD_SETCHAPNEWPAGE */ |
{ doignline, "setfilename", 11 }, /* TEXICMD_SETFILENAME */ |
{ doignline, "setfilename", 11 }, /* TEXICMD_SETFILENAME */ |
|
{ doignline, "settitle", 8 }, /* TEXICMD_SETTITLE */ |
{ dosp, "sp", 2 }, /* TEXICMD_SP */ |
{ dosp, "sp", 2 }, /* TEXICMD_SP */ |
{ dosymbol, " ", 1 }, /* TEXICMD_SPACE */ |
{ dosymbol, " ", 1 }, /* TEXICMD_SPACE */ |
{ doexample, "smallexample", 12 }, /* TEXICMD_SMALLEXAMPLE */ |
{ doexample, "smallexample", 12 }, /* TEXICMD_SMALLEXAMPLE */ |
{ doignline, "settitle", 8 }, /* TEXICMD_SETTITLE */ |
|
{ dosymbol, "{", 1 }, /* TEXICMD_SQUIGGLE_LEFT */ |
{ dosymbol, "{", 1 }, /* TEXICMD_SQUIGGLE_LEFT */ |
{ dosymbol, "}", 1 }, /* TEXICMD_SQUIGGLE_RIGHT */ |
{ dosymbol, "}", 1 }, /* TEXICMD_SQUIGGLE_RIGHT */ |
{ dosubsection, "subsection", 10 }, /* TEXICMD_SUBSECTION */ |
{ dosubsection, "subsection", 10 }, /* TEXICMD_SUBSECTION */ |
Line 340 texifilepop(struct texi *p) |
|
Line 345 texifilepop(struct texi *p) |
|
static void |
static void |
texiexit(struct texi *p) |
texiexit(struct texi *p) |
{ |
{ |
|
size_t i; |
|
|
while (p->filepos > 0) |
|
texifilepop(p); |
|
free(p->dir); |
|
if (p->outcol) |
if (p->outcol) |
putchar('\n'); |
putchar('\n'); |
|
|
|
while (p->filepos > 0) |
|
texifilepop(p); |
|
|
|
for (i = 0; i < p->dirsz; i++) |
|
free(p->dirs[i]); |
|
free(p->dirs); |
} |
} |
|
|
/* |
/* |
|
|
teximacroclose(struct texi *p) |
teximacroclose(struct texi *p) |
{ |
{ |
|
|
p->outmacro--; |
if (0 == --p->outmacro) |
if (p->ign) |
texiputchar(p, '\n'); |
return; |
|
texiputchar(p, '\n'); |
|
} |
} |
|
|
/* |
/* |
Line 448 teximacroclose(struct texi *p) |
|
Line 456 teximacroclose(struct texi *p) |
|
static void |
static void |
teximacroopen(struct texi *p, const char *s) |
teximacroopen(struct texi *p, const char *s) |
{ |
{ |
int rc; |
|
|
|
p->outmacro++; |
if (p->outcol && 0 == p->outmacro) |
if (p->ign) |
|
return; |
|
if (p->outcol) |
|
texiputchar(p, '\n'); |
texiputchar(p, '\n'); |
if (EOF != (rc = fputs(s, stdout))) |
if (0 == p->outmacro) |
p->outcol += rc; |
texiputchar(p, '.'); |
|
else |
|
texiputchar(p, ' '); |
|
texiputchars(p, s); |
|
texiputchar(p, ' '); |
|
p->outmacro++; |
|
p->seenws = 0; |
} |
} |
|
|
/* |
/* |
Line 472 teximacro(struct texi *p, const char *s) |
|
Line 482 teximacro(struct texi *p, const char *s) |
|
else if (p->literal) |
else if (p->literal) |
texierr(p, "\"%s\" in a literal scope!?", s); |
texierr(p, "\"%s\" in a literal scope!?", s); |
|
|
if (p->ign) |
|
return; |
|
if (p->outcol) |
if (p->outcol) |
texiputchar(p, '\n'); |
texiputchar(p, '\n'); |
puts(s); |
|
p->outcol = 0; |
texiputchar(p, '.'); |
p->seenws = 0; |
texiputchars(p, s); |
|
texiputchar(p, '\n'); |
} |
} |
|
|
/* |
/* |
Line 508 advancenext(struct texi *p, const char *buf, size_t sz |
|
Line 517 advancenext(struct texi *p, const char *buf, size_t sz |
|
|
|
if (p->literal) { |
if (p->literal) { |
while (*pos < sz && isspace(buf[*pos])) { |
while (*pos < sz && isspace(buf[*pos])) { |
|
if (*pos && '\n' == buf[*pos] && |
|
'\\' == buf[*pos - 1]) |
|
texiputchar(p, 'e'); |
texiputchar(p, buf[*pos]); |
texiputchar(p, buf[*pos]); |
advance(p, buf, pos); |
advance(p, buf, pos); |
} |
} |
Line 521 advancenext(struct texi *p, const char *buf, size_t sz |
|
Line 533 advancenext(struct texi *p, const char *buf, size_t sz |
|
* output a paragraph. |
* output a paragraph. |
* FIXME: this is stupid. |
* FIXME: this is stupid. |
*/ |
*/ |
if (*pos && '\n' == buf[*pos] && '\n' == buf[*pos - 1]) |
if (*pos && '\n' == buf[*pos] && |
teximacro(p, ".Pp"); |
'\n' == buf[*pos - 1]) |
|
teximacro(p, "Pp"); |
advance(p, buf, pos); |
advance(p, buf, pos); |
} |
} |
return(*pos); |
return(*pos); |
Line 895 dodeftypevar(struct texi *p, enum texicmd cmd, |
|
Line 908 dodeftypevar(struct texi *p, enum texicmd cmd, |
|
return; |
return; |
} |
} |
|
|
teximacro(p, ".Pp"); |
teximacro(p, "Pp"); |
if (TEXICMD_DEFTYPEVR == cmd) { |
if (TEXICMD_DEFTYPEVR == cmd) { |
parsebracket(p, buf, sz, pos); |
parsebracket(p, buf, sz, pos); |
texiputchars(p, ":\n"); |
texiputchars(p, ":\n"); |
} |
} |
teximacroopen(p, ".Vt "); |
teximacroopen(p, "Vt"); |
parseeoln(p, buf, sz, pos); |
parseeoln(p, buf, sz, pos); |
teximacroclose(p); |
teximacroclose(p); |
teximacro(p, ".Pp"); |
teximacro(p, "Pp"); |
parseto(p, buf, sz, pos, blk); |
parseto(p, buf, sz, pos, blk); |
} |
} |
|
|
Line 913 dodeftypefun(struct texi *p, enum texicmd cmd, |
|
Line 926 dodeftypefun(struct texi *p, enum texicmd cmd, |
|
{ |
{ |
const char *blk; |
const char *blk; |
|
|
|
blk = NULL; |
switch (cmd) { |
switch (cmd) { |
case (TEXICMD_DEFTYPEFN): |
case (TEXICMD_DEFTYPEFN): |
blk = "deftypefn"; |
|
break; |
|
case (TEXICMD_DEFTYPEFUN): |
case (TEXICMD_DEFTYPEFUN): |
blk = "deftypefun"; |
blk = texitoks[cmd].tok; |
break; |
break; |
case (TEXICMD_DEFTYPEFNX): |
|
case (TEXICMD_DEFTYPEFUNX): |
|
blk = NULL; |
|
break; |
|
default: |
default: |
abort(); |
break; |
} |
} |
|
|
if (p->ign) { |
if (p->ign) { |
Line 937 dodeftypefun(struct texi *p, enum texicmd cmd, |
|
Line 945 dodeftypefun(struct texi *p, enum texicmd cmd, |
|
switch (cmd) { |
switch (cmd) { |
case (TEXICMD_DEFTYPEFN): |
case (TEXICMD_DEFTYPEFN): |
case (TEXICMD_DEFTYPEFUN): |
case (TEXICMD_DEFTYPEFUN): |
teximacro(p, ".Pp"); |
teximacro(p, "Pp"); |
break; |
break; |
default: |
default: |
break; |
break; |
Line 947 dodeftypefun(struct texi *p, enum texicmd cmd, |
|
Line 955 dodeftypefun(struct texi *p, enum texicmd cmd, |
|
parsebracket(p, buf, sz, pos); |
parsebracket(p, buf, sz, pos); |
texiputchars(p, ":\n"); |
texiputchars(p, ":\n"); |
} |
} |
teximacroopen(p, ".Ft "); |
teximacroopen(p, "Ft"); |
parsesingle(p, buf, sz, pos); |
parsesingle(p, buf, sz, pos); |
teximacroclose(p); |
teximacroclose(p); |
teximacroopen(p, ".Fn "); |
teximacroopen(p, "Fn"); |
parsesingle(p, buf, sz, pos); |
parsesingle(p, buf, sz, pos); |
teximacroclose(p); |
teximacroclose(p); |
teximacroopen(p, ".Li "); |
teximacroopen(p, "Li"); |
parseeoln(p, buf, sz, pos); |
parseeoln(p, buf, sz, pos); |
teximacroclose(p); |
teximacroclose(p); |
teximacro(p, ".Pp"); |
teximacro(p, "Pp"); |
if (NULL != blk) |
if (NULL != blk) |
parseto(p, buf, sz, pos, blk); |
parseto(p, buf, sz, pos, blk); |
} |
} |
|
|
doignblock(struct texi *p, enum texicmd cmd, |
doignblock(struct texi *p, enum texicmd cmd, |
const char *buf, size_t sz, size_t *pos) |
const char *buf, size_t sz, size_t *pos) |
{ |
{ |
const char *blk; |
|
|
|
switch (cmd) { |
|
case (TEXICMD_COPYING): |
|
blk = "copying"; |
|
break; |
|
case (TEXICMD_DETAILMENU): |
|
blk = "detailmenu"; |
|
break; |
|
case (TEXICMD_DIRENTRY): |
|
blk = "direntry"; |
|
break; |
|
case (TEXICMD_IFCLEAR): |
|
blk = "ifclear"; |
|
break; |
|
case (TEXICMD_IFHTML): |
|
blk = "ifhtml"; |
|
break; |
|
case (TEXICMD_IFINFO): |
|
blk = "ifinfo"; |
|
break; |
|
case (TEXICMD_IFSET): |
|
blk = "ifset"; |
|
break; |
|
case (TEXICMD_IFTEX): |
|
blk = "iftex"; |
|
break; |
|
case (TEXICMD_MENU): |
|
blk = "menu"; |
|
break; |
|
case (TEXICMD_TEX): |
|
blk = "tex"; |
|
break; |
|
case (TEXICMD_TITLEPAGE): |
|
blk = "titlepage"; |
|
break; |
|
default: |
|
abort(); |
|
} |
|
p->ign++; |
p->ign++; |
parseto(p, buf, sz, pos, blk); |
parseto(p, buf, sz, pos, texitoks[cmd].tok); |
p->ign--; |
p->ign--; |
} |
} |
|
|
|
|
doblock(struct texi *p, enum texicmd cmd, |
doblock(struct texi *p, enum texicmd cmd, |
const char *buf, size_t sz, size_t *pos) |
const char *buf, size_t sz, size_t *pos) |
{ |
{ |
const char *blk; |
|
|
|
switch (cmd) { |
|
case (TEXICMD_GROUP): |
|
blk = "group"; |
|
break; |
|
case (TEXICMD_IFNOTTEX): |
|
blk = "ifnottex"; |
|
break; |
|
default: |
|
abort(); |
|
} |
|
|
|
parseto(p, buf, sz, pos, blk); |
parseto(p, buf, sz, pos, texitoks[cmd].tok); |
} |
} |
|
|
static void |
static void |
doinline(struct texi *p, const char *buf, |
doinline(struct texi *p, const char *buf, |
size_t sz, size_t *pos, const char *macro) |
size_t sz, size_t *pos, const char *macro) |
{ |
{ |
int open = 0; |
|
|
|
if (0 == p->outmacro) { |
teximacroopen(p, macro); |
open = 1; |
|
teximacroopen(p, "."); |
|
} else |
|
texiputchar(p, ' '); |
|
|
|
texiputchars(p, macro); |
|
texiputchar(p, ' '); |
|
p->seenws = 0; |
p->seenws = 0; |
parsebracket(p, buf, sz, pos); |
parsebracket(p, buf, sz, pos); |
if (*pos < sz - 1 && |
if (*pos < sz - 1 && |
Line 1052 doinline(struct texi *p, const char *buf, |
|
Line 1002 doinline(struct texi *p, const char *buf, |
|
texiputchar(p, buf[*pos]); |
texiputchar(p, buf[*pos]); |
advance(p, buf, pos); |
advance(p, buf, pos); |
} |
} |
if (open) |
teximacroclose(p); |
teximacroclose(p); |
|
} |
} |
|
|
static void |
static void |
Line 1086 doinclude(struct texi *p, enum texicmd cmd, |
|
Line 1035 doinclude(struct texi *p, enum texicmd cmd, |
|
if (strstr(fname, "../") || strstr(fname, "/..")) |
if (strstr(fname, "../") || strstr(fname, "/..")) |
texierr(p, "insecure path"); |
texierr(p, "insecure path"); |
|
|
/* Append filename to original name's directory. */ |
for (i = 0; i < p->dirsz; i++) { |
rc = snprintf(path, sizeof(path), "%s/%s", p->dir, fname); |
rc = snprintf(path, sizeof(path), |
if (rc < 0) |
"%s/%s", p->dirs[i], fname); |
texierr(p, "couldn't format filename"); |
texiwarn(p, "trying: %s", path); |
else if ((size_t)rc >= sizeof(path)) |
if (rc < 0) |
texierr(p, "path too long"); |
texierr(p, "couldn't format path"); |
|
else if ((size_t)rc >= sizeof(path)) |
|
texierr(p, "path too long"); |
|
else if (-1 == access(path, R_OK)) |
|
continue; |
|
|
/* Pump through to parser. */ |
parsefile(p, path); |
parsefile(p, path); |
return; |
|
} |
|
|
|
texierr(p, "couldn't find %s in includes", fname); |
} |
} |
|
|
static void |
static void |
Line 1172 dodisplay(struct texi *p, enum texicmd cmd, |
|
Line 1128 dodisplay(struct texi *p, enum texicmd cmd, |
|
const char *buf, size_t sz, size_t *pos) |
const char *buf, size_t sz, size_t *pos) |
{ |
{ |
|
|
teximacro(p, ".Bd -display"); |
teximacro(p, "Bd -display -offset indent"); |
advanceeoln(p, buf, sz, pos, 1); |
advanceeoln(p, buf, sz, pos, 1); |
parseto(p, buf, sz, pos, "display"); |
parseto(p, buf, sz, pos, "display"); |
teximacro(p, ".Ed"); |
teximacro(p, "Ed"); |
} |
} |
|
|
static void |
static void |
Line 1186 doexample(struct texi *p, enum texicmd cmd, |
|
Line 1142 doexample(struct texi *p, enum texicmd cmd, |
|
|
|
blk = TEXICMD_EXAMPLE == cmd ? "example" : "smallexample"; |
blk = TEXICMD_EXAMPLE == cmd ? "example" : "smallexample"; |
|
|
teximacro(p, ".Bd -literal"); |
teximacro(p, "Bd -literal -offset indent"); |
advanceeoln(p, buf, sz, pos, 1); |
advanceeoln(p, buf, sz, pos, 1); |
p->literal++; |
p->literal++; |
parseto(p, buf, sz, pos, blk); |
parseto(p, buf, sz, pos, blk); |
p->literal--; |
p->literal--; |
teximacro(p, ".Ed"); |
teximacro(p, "Ed"); |
} |
} |
|
|
static void |
static void |
Line 1251 dosymbol(struct texi *p, enum texicmd cmd, |
|
Line 1207 dosymbol(struct texi *p, enum texicmd cmd, |
|
case (TEXICMD_HYPHEN): |
case (TEXICMD_HYPHEN): |
break; |
break; |
default: |
default: |
|
texiwarn(p, "sym: %d", cmd); |
abort(); |
abort(); |
} |
} |
|
|
doignbracket(p, cmd, buf, sz, pos); |
if (texitoks[cmd].len > 1) |
|
doignbracket(p, cmd, buf, sz, pos); |
} |
} |
|
|
static void |
static void |
Line 1262 doquotation(struct texi *p, enum texicmd cmd, |
|
Line 1220 doquotation(struct texi *p, enum texicmd cmd, |
|
const char *buf, size_t sz, size_t *pos) |
const char *buf, size_t sz, size_t *pos) |
{ |
{ |
|
|
teximacro(p, ".Qo"); |
teximacro(p, "Qo"); |
parseto(p, buf, sz, pos, "quotation"); |
parseto(p, buf, sz, pos, "quotation"); |
teximacro(p, ".Qc"); |
teximacro(p, "Qc"); |
} |
} |
|
|
/* FIXME */ |
/* FIXME */ |
|
|
doarg1(struct texi *p, enum texicmd cmd, |
doarg1(struct texi *p, enum texicmd cmd, |
const char *buf, size_t sz, size_t *pos) |
const char *buf, size_t sz, size_t *pos) |
{ |
{ |
int open = 0; |
|
|
|
if (*pos == sz || '{' != buf[*pos]) |
if (*pos == sz || '{' != buf[*pos]) |
return; |
return; |
advance(p, buf, pos); |
advance(p, buf, pos); |
switch (cmd) { |
switch (cmd) { |
case (TEXICMD_EMAIL): |
case (TEXICMD_EMAIL): |
if ( ! p->outmacro) { |
teximacroopen(p, "Mt"); |
open = 1; |
|
teximacroopen(p, "."); |
|
} |
|
texiputchars(p, "Lk "); |
|
break; |
break; |
case (TEXICMD_UREF): |
case (TEXICMD_UREF): |
case (TEXICMD_URL): |
case (TEXICMD_URL): |
if ( ! p->outmacro) { |
teximacroopen(p, "Lk"); |
open = 1; |
|
teximacroopen(p, "."); |
|
} |
|
texiputchars(p, "Mt "); |
|
break; |
break; |
default: |
default: |
break; |
break; |
Line 1348 doarg1(struct texi *p, enum texicmd cmd, |
|
Line 1297 doarg1(struct texi *p, enum texicmd cmd, |
|
texiputchar(p, buf[*pos]); |
texiputchar(p, buf[*pos]); |
advance(p, buf, pos); |
advance(p, buf, pos); |
} |
} |
if (open) |
switch (cmd) { |
|
case (TEXICMD_EMAIL): |
|
case (TEXICMD_UREF): |
|
case (TEXICMD_URL): |
teximacroclose(p); |
teximacroclose(p); |
|
break; |
|
default: |
|
break; |
|
} |
} |
} |
|
|
static void |
static void |
Line 1357 dosubsection(struct texi *p, enum texicmd cmd, |
|
Line 1313 dosubsection(struct texi *p, enum texicmd cmd, |
|
const char *buf, size_t sz, size_t *pos) |
const char *buf, size_t sz, size_t *pos) |
{ |
{ |
|
|
teximacro(p, ".Pp"); |
teximacro(p, "Pp"); |
|
teximacroopen(p, "Em"); |
parseeoln(p, buf, sz, pos); |
parseeoln(p, buf, sz, pos); |
teximacro(p, ".Pp"); |
teximacroclose(p); |
|
teximacro(p, "Pp"); |
} |
} |
|
|
static void |
static void |
Line 1372 dosection(struct texi *p, enum texicmd cmd, |
|
Line 1330 dosection(struct texi *p, enum texicmd cmd, |
|
else if (p->literal) |
else if (p->literal) |
texierr(p, "subsection in a literal scope!?"); |
texierr(p, "subsection in a literal scope!?"); |
|
|
teximacroopen(p, ".Ss "); |
teximacroopen(p, "Ss"); |
parseeoln(p, buf, sz, pos); |
parseeoln(p, buf, sz, pos); |
teximacroclose(p); |
teximacroclose(p); |
} |
} |
Line 1382 dosp(struct texi *p, enum texicmd cmd, |
|
Line 1340 dosp(struct texi *p, enum texicmd cmd, |
|
const char *buf, size_t sz, size_t *pos) |
const char *buf, size_t sz, size_t *pos) |
{ |
{ |
|
|
teximacro(p, ".Pp"); |
teximacro(p, "Pp"); |
advanceeoln(p, buf, sz, pos, 1); |
advanceeoln(p, buf, sz, pos, 1); |
} |
} |
|
|
Line 1396 dochapter(struct texi *p, enum texicmd cmd, |
|
Line 1354 dochapter(struct texi *p, enum texicmd cmd, |
|
else if (p->literal) |
else if (p->literal) |
texierr(p, "section in a literal scope!?"); |
texierr(p, "section in a literal scope!?"); |
|
|
teximacroopen(p, ".Sh "); |
teximacroopen(p, "Sh"); |
parseeoln(p, buf, sz, pos); |
parseeoln(p, buf, sz, pos); |
teximacroclose(p); |
teximacroclose(p); |
} |
} |
Line 1408 dotop(struct texi *p, enum texicmd cmd, |
|
Line 1366 dotop(struct texi *p, enum texicmd cmd, |
|
|
|
p->ign--; |
p->ign--; |
advanceeoln(p, buf, sz, pos, 1); |
advanceeoln(p, buf, sz, pos, 1); |
teximacro(p, ".Dd $Mdocdate$"); |
teximacro(p, "Dd $Mdocdate$"); |
teximacro(p, ".Dt SOMETHING 7"); |
teximacro(p, "Dt SOMETHING 7"); |
teximacro(p, ".Os"); |
teximacro(p, "Os"); |
teximacro(p, ".Sh NAME"); |
teximacro(p, "Sh NAME"); |
teximacro(p, ".Nm Something"); |
teximacro(p, "Nm Something"); |
teximacro(p, ".Nd Something"); |
teximacro(p, "Nd Something"); |
} |
} |
|
|
static void |
static void |
Line 1428 doitem(struct texi *p, enum texicmd cmd, |
|
Line 1386 doitem(struct texi *p, enum texicmd cmd, |
|
|
|
switch (p->list) { |
switch (p->list) { |
case (TEXILIST_ITEM): |
case (TEXILIST_ITEM): |
teximacroopen(p, ".It"); |
teximacroopen(p, "It"); |
break; |
break; |
case (TEXILIST_NOITEM): |
case (TEXILIST_NOITEM): |
teximacro(p, ".It"); |
teximacro(p, "It"); |
break; |
break; |
default: |
default: |
teximacro(p, ".Pp"); |
teximacro(p, "Pp"); |
break; |
break; |
} |
} |
|
|
Line 1453 dotable(struct texi *p, enum texicmd cmd, |
|
Line 1411 dotable(struct texi *p, enum texicmd cmd, |
|
enum texilist sv = p->list; |
enum texilist sv = p->list; |
|
|
p->list = TEXILIST_ITEM; |
p->list = TEXILIST_ITEM; |
teximacro(p, ".Bl -tag -width Ds"); |
teximacro(p, "Bl -tag -width Ds"); |
parseto(p, buf, sz, pos, "table"); |
parseto(p, buf, sz, pos, "table"); |
teximacro(p, ".El"); |
teximacro(p, "El"); |
p->list = sv; |
p->list = sv; |
} |
} |
|
|
Line 1466 doenumerate(struct texi *p, enum texicmd cmd, |
|
Line 1424 doenumerate(struct texi *p, enum texicmd cmd, |
|
enum texilist sv = p->list; |
enum texilist sv = p->list; |
|
|
p->list = TEXILIST_NOITEM; |
p->list = TEXILIST_NOITEM; |
teximacro(p, ".Bl -enum"); |
teximacro(p, "Bl -enum"); |
parseto(p, buf, sz, pos, "enumerate"); |
parseto(p, buf, sz, pos, "enumerate"); |
teximacro(p, ".El"); |
teximacro(p, "El"); |
p->list = sv; |
p->list = sv; |
} |
} |
|
|
Line 1479 doitemize(struct texi *p, enum texicmd cmd, |
|
Line 1437 doitemize(struct texi *p, enum texicmd cmd, |
|
enum texilist sv = p->list; |
enum texilist sv = p->list; |
|
|
p->list = TEXILIST_ITEM; |
p->list = TEXILIST_ITEM; |
teximacro(p, ".Bl -bullet"); |
teximacro(p, "Bl -bullet"); |
parseto(p, buf, sz, pos, "itemize"); |
parseto(p, buf, sz, pos, "itemize"); |
teximacro(p, ".El"); |
teximacro(p, "El"); |
p->list = sv; |
p->list = sv; |
} |
} |
|
|
Line 1503 doignline(struct texi *p, enum texicmd cmd, |
|
Line 1461 doignline(struct texi *p, enum texicmd cmd, |
|
advanceeoln(p, buf, sz, pos, 1); |
advanceeoln(p, buf, sz, pos, 1); |
} |
} |
|
|
|
static char ** |
|
parsedirs(const char *base, const char *cp, size_t *sz) |
|
{ |
|
char *tok, *str, *tofree; |
|
const char *cpp; |
|
size_t i; |
|
char **dirs; |
|
|
|
*sz = NULL != (cpp = cp) ? 2 : 1; |
|
if (*sz > 1) |
|
for ( ; NULL != (cpp = strchr(cpp, ':')); (*sz)++) |
|
cpp++; |
|
|
|
dirs = calloc(*sz, sizeof(char *)); |
|
if (NULL == dirs) { |
|
perror(NULL); |
|
exit(EXIT_FAILURE); |
|
} else if (NULL == (dirs[0] = strdup(base))) { |
|
perror(NULL); |
|
exit(EXIT_FAILURE); |
|
} |
|
|
|
if (NULL == cp) |
|
return(dirs); |
|
|
|
if (NULL == (tofree = tok = str = strdup(cp))) { |
|
perror(NULL); |
|
exit(EXIT_FAILURE); |
|
} |
|
|
|
for (i = 1; NULL != (tok = strsep(&str, ":")); i++) |
|
if (NULL == (dirs[i] = strdup(tok))) { |
|
perror(NULL); |
|
exit(EXIT_FAILURE); |
|
} |
|
|
|
free(tofree); |
|
return(dirs); |
|
} |
|
|
int |
int |
main(int argc, char *argv[]) |
main(int argc, char *argv[]) |
{ |
{ |
struct texi texi; |
struct texi texi; |
int c; |
int c; |
char *path, *dir; |
char *path, *dir; |
const char *progname; |
const char *progname, *Idir; |
|
|
progname = strrchr(argv[0], '/'); |
progname = strrchr(argv[0], '/'); |
if (progname == NULL) |
if (progname == NULL) |
Line 1517 main(int argc, char *argv[]) |
|
Line 1515 main(int argc, char *argv[]) |
|
else |
else |
++progname; |
++progname; |
|
|
while (-1 != (c = getopt(argc, argv, ""))) |
Idir = NULL; |
|
while (-1 != (c = getopt(argc, argv, "I:"))) |
switch (c) { |
switch (c) { |
|
case ('I'): |
|
Idir = optarg; |
|
break; |
default: |
default: |
goto usage; |
goto usage; |
} |
} |
Line 1539 main(int argc, char *argv[]) |
|
Line 1541 main(int argc, char *argv[]) |
|
|
|
memset(&texi, 0, sizeof(struct texi)); |
memset(&texi, 0, sizeof(struct texi)); |
texi.ign = 1; |
texi.ign = 1; |
texi.dir = strdup(dir); |
texi.dirs = parsedirs(dir, Idir, &texi.dirsz); |
parsefile(&texi, argv[0]); |
parsefile(&texi, argv[0]); |
|
/* We shouldn't get here. */ |
texiexit(&texi); |
texiexit(&texi); |
return(EXIT_FAILURE); |
return(EXIT_FAILURE); |
usage: |
usage: |