texi2mdoc/main.c - diff

Return to main.c CVS log

Up to [cvsweb.bsd.lv] / texi2mdoc

Diff for /texi2mdoc/main.c between version 1.32 and 1.53

version 1.32, 2015/02/23 12:28:20

version 1.53, 2015/02/28 08:41:59

Line 14

* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF

* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

#include <sys/mman.h>

#if defined(__linux__) || defined(__MINT__)

#include <sys/stat.h>

# define _GNU_SOURCE /* memmem */

#endif

#include <assert.h>

#include <ctype.h>

#include <fcntl.h>

#include <getopt.h>

#include <libgen.h>

#include <limits.h>

Line 40 static const char *const sects[SECTSZ] = {

Line 39 static const char *const sects[SECTSZ] = {

"No",

};

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

static void doaccent(struct texi *, enum texicmd, size_t *);

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

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

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

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

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

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

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

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

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

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

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

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

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

static void doend(struct texi *, enum texicmd, size_t *);

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

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

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

static void doexample(struct texi *, enum texicmd, size_t *);

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

static void doignargn(struct texi *, enum texicmd, size_t *);

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

static void doignblock(struct texi *, enum texicmd, size_t *);

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

static void doignbracket(struct texi *, enum texicmd, size_t *);

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

static void doignline(struct texi *, enum texicmd, size_t *);

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

static void doinline(struct texi *, enum texicmd, size_t *);

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

static void doinclude(struct texi *, enum texicmd, size_t *);

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

static void dotable(struct texi *, enum texicmd, size_t *);

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

static void dotop(struct texi *, enum texicmd, size_t *);

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

static void dosecoffs(struct texi *, enum texicmd, size_t *);

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

static void dosection(struct texi *, enum texicmd, size_t *);

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

static void dosp(struct texi *, enum texicmd, size_t *);

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

static void dosubsection(struct texi *, enum texicmd, size_t *);

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

static void dosubsubsection(struct texi *, enum texicmd, size_t *);

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

static void dosymbol(struct texi *, enum texicmd, size_t *);

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

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

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

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

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

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

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

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

static void doverbatim(struct texi *, enum texicmd, size_t *);

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

static const struct texitok __texitoks[TEXICMD__MAX] = {

/* TEXICMD__BEGIN */

{ doignline, "afourpaper", 10 }, /* TEXICMD_A4PAPER */

{ dosymbol, "AA", 2 }, /* TEXICMD_AA */

{ dosymbol, "aa", 2 }, /* TEXICMD_AASMALL */

{ doignargn, "acronym", 7 }, /* TEXICMD_ACRONYM */

{ doaccent, "'", 1 }, /* TEXICMD_ACUTE */

{ doignline, "afourpaper", 10 }, /* TEXICMD_A4PAPER */

{ dosymbol, "AE", 2 }, /* TEXICMD_AE */

{ dosymbol, "ae", 2 }, /* TEXICMD_AESMALL */

{ doignbracket, "anchor", 6 }, /* TEXICMD_ANCHOR */

{ dosection, "appendix", 8 }, /* TEXICMD_APPENDIX */

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

Line 94 static const struct texitok __texitoks[TEXICMD__MAX] =

Line 99 static const struct texitok __texitoks[TEXICMD__MAX] =

{ dosymbol, "!", 1 }, /* TEXICMD_BANG */

{ dosymbol, "bullet", 6 }, /* TEXICMD_BULLET */

{ dobye, "bye", 3 }, /* TEXICMD_BYE */

{ doblock, "cartouche", 9 }, /* TEXICMD_CARTOUCHE */

{ doaccent, ",", 1 }, /* TEXICMD_CEDILLA */

{ doignline, "center", 6 }, /* TEXICMD_CENTER */

{ dosection, "chapter", 7 }, /* TEXICMD_CHAPTER */

{ doignline, "cindex", 6 }, /* TEXICMD_CINDEX */

Line 103 static const struct texitok __texitoks[TEXICMD__MAX] =

Line 110 static const struct texitok __texitoks[TEXICMD__MAX] =

{ doinline, "code", 4 }, /* TEXICMD_CODE */

{ dosymbol, ":", 1 }, /* TEXICMD_COLON */

{ NULL, "columnfractions", 15 }, /* TEXICMD_COLUMNFRACTIONS */

{ dosymbol, "comma", 5 }, /* TEXICMD_COMMA */

{ doinline, "command", 7 }, /* TEXICMD_COMMAND */

{ doignline, "c", 1 }, /* TEXICMD_COMMENT */

{ doignline, "comment", 7 }, /* TEXICMD_COMMENT_LONG */

Line 121 static const struct texitok __texitoks[TEXICMD__MAX] =

Line 129 static const struct texitok __texitoks[TEXICMD__MAX] =

{ dodefn, "deftypefnx", 10 }, /* TEXICMD_DEFTYPEFNX */

{ dodefn, "deftypefun", 10 }, /* TEXICMD_DEFTYPEFUN */

{ dodefn, "deftypefunx", 11 }, /* TEXICMD_DEFTYPEFUNX */

{ dodefn, "deftypemethod", 13 }, /* TEXICMD_DEFTYPEMETHOD */

{ dodefn, "deftypemethodx", 14 }, /* TEXICMD_DEFTYPEMETHODX */

{ dodefn, "deftypevar", 10 }, /* TEXICMD_DEFTYPEVAR */

{ dodefn, "deftypevarx", 11 }, /* TEXICMD_DEFTYPEVARX */

{ dodefn, "deftypevr", 9 }, /* TEXICMD_DEFTYPEVR */

Line 133 static const struct texitok __texitoks[TEXICMD__MAX] =

Line 143 static const struct texitok __texitoks[TEXICMD__MAX] =

{ dodefn, "defvrx", 6 }, /* TEXICMD_DEFVRX */

{ doignblock, "detailmenu", 10 }, /* TEXICMD_DETAILMENU */

{ doinline, "dfn", 3 }, /* TEXICMD_DFN */

{ dosymbol, "DH", 2 }, /* TEXICMD_DH */

{ dosymbol, "dh", 2 }, /* TEXICMD_DHSMALL */

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

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

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

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

{ doignblock, "documentdescription", 19 }, /* TEXICMD_DOCUMENTDESCRIPTION */

{ doignline, "documentencoding", 16 }, /* TEXICMD_DOCUMENTENCODING */

{ doignline, "documentlanguage", 16 }, /* TEXICMD_DOCUMENTLANGUAGE */

{ doaccent, "dotaccent", 9 }, /* TEXICMD_DOTACCENT */

{ doaccent, "dotless", 7 }, /* TEXICMD_DOTLESS */

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

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

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

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

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

{ dosymbol, "enddots", 7 }, /* TEXICMD_ENDDOTS */

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

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

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

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

{ dosymbol, "euro", 4 }, /* TEXICMD_EURO */

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

{ dosymbol, "exclamdown", 10 }, /* TEXICMD_EXCLAMDOWN */

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

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

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

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

{ doignline, "findex", 6 }, /* TEXICMD_FINDEX */

{ doblock, "flushleft", 9 }, /* TEXICMD_FLUSHLEFT */

{ doblock, "flushright", 10 }, /* TEXICMD_FLUSHRIGHT */

{ doignline, "firstparagraphindent", 20 }, /* TEXICMD_FIRSTPARAGRAPHINDENT */

{ doignbracket, "footnote", 8 }, /* TEXICMD_FOOTNOTE */

{ doignline, "footnotestyle", 13 }, /* TEXICMD_FOOTNOTESTYLE */

{ dotable, "ftable", 6 }, /* TEXICMD_FTABLE */

{ dodisplay, "format", 6 }, /* TEXICMD_FORMAT */

{ dosymbol, "geq", 3 }, /* TEXICMD_GEQ */

{ doaccent, "`", 1 }, /* TEXICMD_GRAVE */

{ doblock, "group", 5 }, /* TEXICMD_GROUP */

{ dosymbol, "guillemetleft", 13 }, /* TEXICMD_GUILLEMETLEFT */

{ dosymbol, "guillemetright", 14 }, /* TEXICMD_GUILLEMETRIGHT */

{ dosymbol, "guillemotleft", 13 }, /* TEXICMD_GUILLEMOTLEFT */

{ dosymbol, "guillemotright", 14 }, /* TEXICMD_GUILLEMOTRIGHT */

{ dosymbol, "guilsinglleft", 13 }, /* TEXICMD_GUILSINGLLEFT */

{ dosymbol, "guilsinglright", 14 }, /* TEXICMD_GUILSINGLRIGHT */

{ doaccent, "H", 1 }, /* TEXICMD_H */

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

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

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

Line 180 static const struct texitok __texitoks[TEXICMD__MAX] =

Line 212 static const struct texitok __texitoks[TEXICMD__MAX] =

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

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

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

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

{ dolink, "indicateurl", 11 }, /* TEXICMD_INDICATEURL */

{ dolink, "inforef", 7 }, /* TEXICMD_INFOREF */

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

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

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

Line 188 static const struct texitok __texitoks[TEXICMD__MAX] =

Line 221 static const struct texitok __texitoks[TEXICMD__MAX] =

{ doinline, "kbd", 3 }, /* TEXICMD_KBD */

{ dobracket, "key", 3 }, /* TEXICMD_KEY */

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

{ dosymbol, "L", 1 }, /* TEXICMD_L */

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

{ dosymbol, "leq", 3 }, /* TEXICMD_LEQ */

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

{ dosymbol, "l", 1 }, /* TEXICMD_LSMALL */

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

{ doaccent, "=", 1 }, /* TEXICMD_MACRON */

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

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

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

Line 199 static const struct texitok __texitoks[TEXICMD__MAX] =

Line 236 static const struct texitok __texitoks[TEXICMD__MAX] =

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

{ doignline, "node", 4 }, /* TEXICMD_NODE */

{ doignline, "noindent", 8 }, /* TEXICMD_NOINDENT */

{ dosymbol, "O", 1 }, /* TEXICMD_O */

{ dosymbol, "OE", 2 }, /* TEXICMD_OE */

{ dosymbol, "oe", 2 }, /* TEXICMD_OESMALL */

{ doaccent, "ogonek", 6 }, /* TEXICMD_OGONEK */

{ doinline, "option", 6 }, /* TEXICMD_OPTION */

{ dolink, "pxref", 5 }, /* TEXICMD_PXREF */

{ dosymbol, "ordf", 4 }, /* TEXICMD_ORDF */

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

{ dosymbol, "ordm", 4 }, /* TEXICMD_ORDM */

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

{ dosymbol, "o", 1 }, /* TEXICMD_OSMALL */

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

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

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

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

{ dosymbol, "pounds", 6 }, /* TEXICMD_POUNDS */

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

{ dolink, "pxref", 5 }, /* TEXICMD_PXREF */

{ dosymbol, "questiondown", 12 }, /* TEXICMD_QUESTIONDOWN */

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

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

{ dosymbol, "quotedblbase", 12 }, /* TEXICMD_QUOTEDBLBASE */

{ dosymbol, "quotedblleft", 12 }, /* TEXICMD_QUOTEDBLLEFT */

{ dosymbol, "quotedblright", 13 }, /* TEXICMD_QUOTEDBLRIGHT */

{ dosymbol, "quotesinglbase", 14 }, /* TEXICMD_QUOTESINGLBASE */

{ dosymbol, "quoteleft", 9 }, /* TEXICMD_QUOTELEFT */

{ dosymbol, "quoteright", 10 }, /* TEXICMD_QUOTERIGHT */

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

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

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

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

{ dosymbol, "registeredsymbol", 16 }, /* TEXICMD_REGISTEREDSYMBOL */

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

{ doaccent, "ringaccent", 10 }, /* TEXICMD_RINGACCENT */

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

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

{ dobracket, "sc", 2 }, /* TEXICMD_SC */

{ dosection, "section", 7 }, /* TEXICMD_SECTION */

{ dovalue, "set", 3 }, /* TEXICMD_SET */

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

{ doignline, "setcontentsaftertitlepage", 25 }, /* TEXICMD_SETCONTENTSAFTER */

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

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

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

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

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

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

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

{ doignline, "smallbook", 9 }, /* TEXICMD_SMALLBOOK */

Line 232 static const struct texitok __texitoks[TEXICMD__MAX] =

Line 288 static const struct texitok __texitoks[TEXICMD__MAX] =

{ dodisplay, "smallindentblock", 16 }, /* TEXICMD_SMALLINDENTBLOCK */

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

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

{ dosymbol, "ss", 2 }, /* TEXICMD_SS */

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

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

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

Line 239 static const struct texitok __texitoks[TEXICMD__MAX] =

Line 296 static const struct texitok __texitoks[TEXICMD__MAX] =

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

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

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

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

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

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

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

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

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

{ dosymbol, "\t", 1 }, /* TEXICMD_TABSYM */

{ dotable, "table", 5 }, /* TEXICMD_TABLE */

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

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

{ dosymbol, "textdegree", 10 }, /* TEXICMD_TEXTDEGREE */

{ dosymbol, "TH", 2 }, /* TEXICMD_TH */

{ dosymbol, "th", 2 }, /* TEXICMD_THSMALL */

{ dosymbol, "tie", 3 }, /* TEXICMD_TIE */

{ doaccent, "tieaccent", 9 }, /* TEXICMD_TIEACCENT */

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

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

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

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

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

{ dotop, "top", 3 }, /* TEXICMD_TOP */

{ doaccent, "u", 1 }, /* TEXICMD_U */

{ doaccent, "ubaraccent", 10 }, /* TEXICMD_UBARACCENT */

{ doaccent, "udotaccent", 10 }, /* TEXICMD_UDOTACCENT */

{ doaccent, "\"", 1 }, /* TEXICMD_UMLAUT */

{ dosection, "unnumbered", 10 }, /* TEXICMD_UNNUMBERED */

{ dosection, "unnumberedsec", 13 }, /* TEXICMD_UNNUMBEREDSEC */

Line 260 static const struct texitok __texitoks[TEXICMD__MAX] =

Line 325 static const struct texitok __texitoks[TEXICMD__MAX] =

{ dosubsubsection, "unnumberedsubsubsec", 19 }, /* TEXICMD_UNNUMBEREDSUBSUBSEC */

{ dolink, "uref", 4 }, /* TEXICMD_UREF */

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

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

{ doaccent, "v", 1 }, /* TEXICMD_V */

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

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

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

{ doverb, "verb", 4 }, /* TEXICMD_VERB */

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

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

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

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

Line 275 static const struct texitok __texitoks[TEXICMD__MAX] =

Line 343 static const struct texitok __texitoks[TEXICMD__MAX] =

const struct texitok *const texitoks = __texitoks;

static void

dodefindex(struct texi *p, enum texicmd cmd,

dodefindex(struct texi *p, enum texicmd cmd, size_t *pos)

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

{

size_t start, end;

char *cp;

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

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

advance(p, buf, pos);

advance(p, pos);

start = end = *pos;

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

while (end < BUFSZ(p) && ! ismspace(BUF(p)[end]))

end++;

if (start == end) {

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

advanceeoln(p, pos, 1);

return;

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

texiabort(p, NULL);

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

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

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

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

Line 306 dodefindex(struct texi *p, enum texicmd cmd,

Line 373 dodefindex(struct texi *p, enum texicmd cmd,

}

static void

dodefn(struct texi *p, enum texicmd cmd,

dodefn(struct texi *p, enum texicmd cmd, size_t *pos)

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

{

const char *blk;

blk = NULL;

switch (cmd) {

case (TEXICMD_DEFFN):

case (TEXICMD_DEFMAC):

case (TEXICMD_DEFTP):

case (TEXICMD_DEFTYPEFN):

case (TEXICMD_DEFTYPEFUN):

case (TEXICMD_DEFTYPEMETHOD):

case (TEXICMD_DEFTYPEVAR):

case (TEXICMD_DEFTYPEVR):

case (TEXICMD_DEFUN):

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

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

if (p->ign) {

NULL != blk ?

parseto(p, buf, sz, pos, blk) :

parseto(p, pos, blk) :

parseeoln(p, buf, sz, pos);

parseeoln(p, pos);

return;

}

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

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

texivspace(p);

switch (cmd) {

case (TEXICMD_DEFTYPEMETHOD):

case (TEXICMD_DEFTYPEMETHODX):

texiputchars(p, "Method");

break;

case (TEXICMD_DEFMAC):

case (TEXICMD_DEFMACX):

texiputchars(p, "Macro");

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

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

texiputchars(p, "Function");

break;

default:

parselinearg(p, buf, sz, pos);

parselinearg(p, pos);

break;

}

texiputchars(p, ":\n");

texiputchar(p, ':');

texiputchar(p, '\n');

switch (cmd) {

case (TEXICMD_DEFMAC):

case (TEXICMD_DEFMACX):

teximacroopen(p, "Dv");

while (parselinearg(p, buf, sz, pos))

while (parselinearg(p, pos))

/* Spin. */ ;

teximacroclose(p);

break;

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

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

case (TEXICMD_DEFUN):

case (TEXICMD_DEFUNX):

teximacroopen(p, "Fo");

parselinearg(p, buf, sz, pos);

parselinearg(p, pos);

teximacroclose(p);

teximacroopen(p, "Fa");

while (parselinearg(p, buf, sz, pos))

while (parselinearg(p, pos))

/* Spin. */ ;

teximacroclose(p);

teximacro(p, "Fc");

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

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

case (TEXICMD_DEFTYPEFUNX):

case (TEXICMD_DEFTYPEFN):

case (TEXICMD_DEFTYPEFNX):

case (TEXICMD_DEFTYPEMETHOD):

case (TEXICMD_DEFTYPEMETHODX):

teximacroopen(p, "Ft");

parselinearg(p, buf, sz, pos);

parselinearg(p, pos);

teximacroclose(p);

teximacroopen(p, "Fo");

parselinearg(p, buf, sz, pos);

parselinearg(p, pos);

teximacroclose(p);

teximacroopen(p, "Fa");

while (parselinearg(p, buf, sz, pos))

while (parselinearg(p, pos))

/* Spin. */ ;

teximacroclose(p);

teximacro(p, "Fc");

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

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

case (TEXICMD_DEFTYPEVR):

case (TEXICMD_DEFTYPEVRX):

teximacroopen(p, "Vt");

while (parselinearg(p, buf, sz, pos))

while (parselinearg(p, pos))

/* Spin. */ ;

teximacroclose(p);

break;

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

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

case (TEXICMD_DEFVR):

case (TEXICMD_DEFVRX):

teximacroopen(p, "Va");

while (parselinearg(p, buf, sz, pos))

while (parselinearg(p, pos))

/* Spin. */ ;

teximacroclose(p);

break;

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

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

texivspace(p);

if (NULL != blk)

parseto(p, buf, sz, pos, blk);

parseto(p, pos, blk);

}

static void

domacro(struct texi *p, enum texicmd cmd,

domacro(struct texi *p, enum texicmd cmd, size_t *pos)

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

{

size_t start, end, endtoksz, len;

struct teximacro m;

Line 438 domacro(struct texi *p, enum texicmd cmd,

Line 512 domacro(struct texi *p, enum texicmd cmd,

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

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

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

advance(p, buf, pos);

advance(p, pos);

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

for (start = end = *pos; end < BUFSZ(p); end++)

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

if (ismspace(BUF(p)[end]) || '{' == BUF(p)[end])

break;

if (start == end)

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

advanceto(p, buf, pos, end);

advanceto(p, pos, end);

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

if (NULL == m.key)

texiabort(p, NULL);

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

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

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

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

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

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

/* Note: we advance to the beginning of the macro. */

advanceeoln(p, pos, 1);

* According to the Texinfo manual, the macro ends on the

* newline subsequent the @end macro.

* That's COMPLETELY FUCKING WRONG.

* It ends inclusive the newline, which is why so many macros

* say things like @r{hello}@c, where the subsequent @c swallows

* the newline.

* However, it does swallow the leading newline, so look for the

* @end macro without the leading newline else we might look

* past empty macros.

start = *pos;

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

endtok = "@end macro\n";

endtoksz = strlen(endtok);

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

blk = memmem(&BUF(p)[start], BUFSZ(p) - start, endtok, endtoksz);

if (NULL == blk)

texierr(p, "unterminated macro body");

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

/* Roll us back one character. */

advance(p, buf, pos);

while (&BUF(p)[*pos] != blk)

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

advance(p, pos);

advance(p, buf, pos);

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

len = blk - &buf[start];

if ('\n' != BUF(p)[*pos - 1])

texierr(p, "cannot handle @end macro in-line");

len = blk - &BUF(p)[start];

m.value = malloc(len + 1);

if (NULL == m.value)

texiabort(p, NULL);

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

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

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

p->macros = realloc

Line 484 domacro(struct texi *p, enum texicmd cmd,

Line 574 domacro(struct texi *p, enum texicmd cmd,

texiabort(p, NULL);

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

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

advanceeoln(p, pos, 1);

}

static void

doignblock(struct texi *p, enum texicmd cmd,

doignblock(struct texi *p, enum texicmd cmd, size_t *pos)

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

{

char end[32];

char end[32], start[32];

const char *term;

const char *endt, *startt;

size_t endsz, endpos;

size_t esz, ssz, newpos, stack;

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

* FIXME: this is cheating.

* simply jump to the @end block.

* These tokens are supposed to begin on a newline.

* However, if we do that, then we would need to check within

* the loop for trailer (or leading, as the case may be)

* newline, and that's just a bit too complicated right now.

* This is becasue

* @ifset BAR

* @ifset FOO

* @end ifset

* won't work right now: we'd read after the first "@end ifset"

* to the next line, then look for the next line after that.

endsz = snprintf(end, sizeof(end),

ssz = snprintf(start, sizeof(start),

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

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

assert(endsz < sizeof(end));

assert(ssz < sizeof(start));

esz = snprintf(end, sizeof(end),

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

assert(esz < sizeof(end));

stack = 1;

* Look up where our end token occurs.

* Here we look for the end token "end" somewhere in the file in

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

* front of us.

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

* It's not that easy, of course: if we have a nested block,

* proper ending point.

* then there'll be an "end" token of the same kind between us.

* Thus, we keep track of scopes for matching "end" blocks.

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

while (stack > 0 && *pos < BUFSZ(p)) {

endpos = NULL == term ? sz :

if (stack > 64)

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

texierr(p, "run-away nested stack?");

assert(endpos <= sz);

endt = memmem(&BUF(p)[*pos], BUFSZ(p) - *pos, end, esz);

while (*pos < endpos)

startt = memmem(&BUF(p)[*pos], BUFSZ(p) - *pos, start, ssz);

advance(p, buf, pos);

if (NULL == endt) {

texiwarn(p, "unterminated \"%s\" "

"block", texitoks[cmd].tok);

*pos = BUFSZ(p);

break;

}

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

newpos = *pos;

if (endpos < sz)

if (NULL == startt || startt > endt) {

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

newpos += esz + (size_t)(endt - &BUF(p)[*pos]);

stack--;

} else {

newpos += ssz + (size_t)(startt - &BUF(p)[*pos]);

stack++;

}

assert(newpos <= BUFSZ(p));

while (*pos < newpos)

advance(p, pos);

}

static void

doblock(struct texi *p, enum texicmd cmd,

doblock(struct texi *p, enum texicmd cmd, size_t *pos)

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

{

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

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

}

static void

doinline(struct texi *p, enum texicmd cmd,

doinline(struct texi *p, enum texicmd cmd, size_t *pos)

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

{

const char *macro = NULL;

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

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

}

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

parsebracket(p, buf, sz, pos);

parsebracket(p, pos, 0);

return;

}

teximacroopen(p, macro);

p->seenws = 0;

parsebracket(p, buf, sz, pos);

parsebracket(p, pos, 0);

texipunctuate(p, buf, sz, pos);

texipunctuate(p, pos);

teximacroclose(p);

}

static void

doverb(struct texi *p, enum texicmd cmd,

doverb(struct texi *p, enum texicmd cmd, size_t *pos)

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

{

char delim;

size_t start;

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

advance(p, pos);

if (*pos == BUFSZ(p) || '{' != BUF(p)[*pos])

return;

advance(p, pos);

if (*pos == BUFSZ(p))

return;

delim = BUF(p)[*pos];

advance(p, pos);

/* Make sure we flush out our initial whitespace... */

if (p->seenws && p->outcol && 0 == p->literal)

texiputchar(p, ' ');

p->seenws = 0;

start = *pos;

/* Read until we see the delimiter then end-brace. */

while (*pos < BUFSZ(p) - 1) {

if (BUF(p)[*pos] == delim && BUF(p)[*pos + 1] == '}')

break;

advance(p, pos);

}

if (*pos >= BUFSZ(p) - 1)

return;

texiputbuf(p, start, *pos);

/* Make sure we read after the end-brace. */

assert(delim == BUF(p)[*pos]);

advance(p, pos);

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

advance(p, pos);

}

static void

doverbatim(struct texi *p, enum texicmd cmd, size_t *pos)

{

const char *end, *term;

size_t endsz, endpos;

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

/* We read from the @verbatim\n newline inclusive! */

/* We end at exactly this token. */

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

endsz = strlen(end);

advanceeoln(p, pos, 0);

if (*pos == BUFSZ(p)) {

texiwarn(p, "unexpected end of file");

return;

}

term = memmem(&BUF(p)[*pos], BUFSZ(p) - *pos, end, endsz);

* Look up where our end token occurs.

if (NULL == term) {

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

texiwarn(p, "unterminated verbatim block");

* from our current position.

endpos = BUFSZ(p);

} else

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

endpos = *pos + (size_t)(term - &BUF(p)[*pos]);

endpos = NULL == term ? sz :

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

assert(endpos <= BUFSZ(p));

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

advance(p, pos);

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

assert(endpos <= sz);

while (*pos < endpos) {

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

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

p->outcol = 0;

advance(p, pos);

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);

if (*pos < BUFSZ(p))

advanceto(p, pos, endpos + endsz);

}

static void

doverbinclude(struct texi *p, enum texicmd cmd,

doverbinclude(struct texi *p, enum texicmd cmd, size_t *pos)

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

{

char fname[PATH_MAX], path[PATH_MAX];

int rc;

Line 635 doverbinclude(struct texi *p, enum texicmd cmd,

Line 783 doverbinclude(struct texi *p, enum texicmd cmd,

const char *v;

enum texicmd type;

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

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

advance(p, buf, pos);

advance(p, pos);

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

for (i = 0; *pos < BUFSZ(p) && '\n' != BUF(p)[*pos]; ) {

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

break;

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

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

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

fname[i++] = BUF(p)[*pos];

advance(p, buf, pos);

advance(p, pos);

continue;

}

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

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

advanceto(p, buf, pos, end);

advanceto(p, pos, end);

if (TEXICMD_VALUE != type)

texierr(p, "unknown verbatiminclude command");

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

v = valueblookup(p, pos);

if (NULL == v)

continue;

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

Line 664 doverbinclude(struct texi *p, enum texicmd cmd,

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

if (i == 0)

texierr(p, "path too short");

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

else if ('\n' != BUF(p)[*pos])

texierr(p, "path too long");

else if ('/' == fname[0])

texierr(p, "no absolute paths");

Line 684 doverbinclude(struct texi *p, enum texicmd cmd,

Line 832 doverbinclude(struct texi *p, enum texicmd cmd,

}

static void

doinclude(struct texi *p, enum texicmd cmd,

doinclude(struct texi *p, enum texicmd cmd, size_t *pos)

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

{

char fname[PATH_MAX], path[PATH_MAX];

size_t i, end;

Line 693 doinclude(struct texi *p, enum texicmd cmd,

Line 840 doinclude(struct texi *p, enum texicmd cmd,

const char *v;

enum texicmd type;

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

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

advance(p, buf, pos);

advance(p, pos);

/* Read in the filename. */

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

for (i = 0; *pos < BUFSZ(p) && '\n' != BUF(p)[*pos]; ) {

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

break;

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

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

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

fname[i++] = BUF(p)[*pos];

advance(p, buf, pos);

advance(p, pos);

continue;

}

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

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

advanceto(p, buf, pos, end);

advanceto(p, pos, end);

if (TEXICMD_VALUE != type)

texierr(p, "unknown include command");

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

v = valueblookup(p, pos);

if (NULL == v)

continue;

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

Line 723 doinclude(struct texi *p, enum texicmd cmd,

Line 870 doinclude(struct texi *p, enum texicmd cmd,

if (i == 0)

texierr(p, "path too short");

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

else if ('\n' != BUF(p)[*pos])

texierr(p, "path too long");

else if ('/' == fname[0])

texierr(p, "no absolute paths");

Line 750 doinclude(struct texi *p, enum texicmd cmd,

Line 897 doinclude(struct texi *p, enum texicmd cmd,

}

static void

dobracket(struct texi *p, enum texicmd cmd,

dobracket(struct texi *p, enum texicmd cmd, size_t *pos)

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

{

parsebracket(p, buf, sz, pos);

parsebracket(p, pos, 0);

}

static void

dodisplay(struct texi *p, enum texicmd cmd,

dodisplay(struct texi *p, enum texicmd cmd, size_t *pos)

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

{

switch (cmd) {

Line 774 dodisplay(struct texi *p, enum texicmd cmd,

Line 919 dodisplay(struct texi *p, enum texicmd cmd,

p->seenvs = 1;

/* FIXME: ignore and parseeoln. */

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

advanceeoln(p, pos, 1);

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

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

teximacro(p, "Ed");

}

static void

doexample(struct texi *p, enum texicmd cmd,

doexample(struct texi *p, enum texicmd cmd, size_t *pos)

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

{

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

/* FIXME: ignore and parseeoln. */

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

advanceeoln(p, pos, 1);

p->literal++;

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

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

p->literal--;

teximacro(p, "Ed");

}

static void

dobye(struct texi *p, enum texicmd cmd,

dobye(struct texi *p, enum texicmd cmd, size_t *pos)

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

{

texiexit(p);

Line 803 dobye(struct texi *p, enum texicmd cmd,

Line 946 dobye(struct texi *p, enum texicmd cmd,

}

static void

dotitle(struct texi *p, enum texicmd cmd,

dotitle(struct texi *p, enum texicmd cmd, size_t *pos)

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

{

size_t start, end;

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

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

advance(p, buf, pos);

advance(p, pos);

start = end = *pos;

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

while (end < BUFSZ(p) && '\n' != BUF(p)[end])

end++;

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

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

memcpy(p->subtitle, &BUF(p)[start], end - start);

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

}

static void

doaccent(struct texi *p, enum texicmd cmd,

doaccent(struct texi *p, enum texicmd cmd, size_t *pos)

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

{

int brace = 0;

if (*pos == sz)

if (*pos == BUFSZ(p)) {

texiwarn(p, "truncated: @%s", texitoks[cmd].tok);

return;

advance(p, buf, pos);

}

/* Pad us with space, if necessary. */

if (p->seenws && p->outcol && 0 == p->literal) {

texiputchar(p, ' ');

p->seenws = 0;

}

* If we're braced, then that's that.

* Otherwise, in a special Texinfo case: if we're a non

* alphabetic command of one letter, then the next character is

* the critical one.

* Otherwise, space can sit between us and our argument.

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

brace = 1;

advance(p, pos);

} else if (isalpha((unsigned char)texitoks[cmd].tok[0]))

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

advance(p, pos);

if (*pos == BUFSZ(p)) {

texiwarn(p, "truncated: @%s", texitoks[cmd].tok);

return;

}

switch (cmd) {

case (TEXICMD_ACUTE):

switch (buf[*pos]) {

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

case ('a'): case ('A'):

case ('e'): case ('E'):

case ('i'): case ('I'):

case ('o'): case ('O'):

case ('u'): case ('U'):

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

texiputchar(p, buf[*pos]);

break;

default:

texiputchar(p, buf[*pos]);

texiwarn(p, "ignoring accent");

break;

}

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

advance(p, pos);

break;

case (TEXICMD_CEDILLA):

if ('c' == BUF(p)[*pos] || 'C' == BUF(p)[*pos])

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

else

texiwarn(p, "ignoring accent");

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

advance(p, pos);

break;

case (TEXICMD_CIRCUMFLEX):

switch (buf[*pos]) {

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

case ('a'): case ('A'):

case ('e'): case ('E'):

case ('i'): case ('I'):

case ('o'): case ('O'):

case ('u'): case ('U'):

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

texiputchar(p, buf[*pos]);

break;

default:

texiputchar(p, buf[*pos]);

texiwarn(p, "ignoring accent");

break;

}

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

advance(p, pos);

break;

case (TEXICMD_DOTLESS):

if ('i' == BUF(p)[*pos] || 'j' == BUF(p)[*pos])

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

else

texiwarn(p, "ignoring accent");

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

advance(p, pos);

break;

case (TEXICMD_GRAVE):

switch (buf[*pos]) {

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

case ('a'): case ('A'):

case ('e'): case ('E'):

case ('i'): case ('I'):

case ('o'): case ('O'):

case ('u'): case ('U'):

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

texiputchar(p, buf[*pos]);

break;

default:

texiputchar(p, buf[*pos]);

texiwarn(p, "ignoring accent");

break;

}

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

advance(p, pos);

break;

case (TEXICMD_TILDE):

switch (buf[*pos]) {

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

case ('a'): case ('A'):

case ('n'): case ('N'):

case ('o'): case ('O'):

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

texiputchar(p, buf[*pos]);

break;

default:

texiputchar(p, buf[*pos]);

texiwarn(p, "ignoring accent");

break;

}

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

advance(p, pos);

break;

case (TEXICMD_UMLAUT):

switch (buf[*pos]) {

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

case ('a'): case ('A'):

case ('e'): case ('E'):

case ('i'): case ('I'):

Line 894 doaccent(struct texi *p, enum texicmd cmd,

Line 1087 doaccent(struct texi *p, enum texicmd cmd,

case ('u'): case ('U'):

case ('y'):

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

texiputchar(p, buf[*pos]);

break;

default:

texiputchar(p, buf[*pos]);

texiwarn(p, "ignoring accent");

break;

}

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

advance(p, pos);

break;

default:

abort();

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

advance(p, pos);

break;

}

if (brace) {

while (*pos < BUFSZ(p) && '}' != BUF(p)[*pos]) {

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

advance(p, pos);

}

if (*pos < BUFSZ(p))

advance(p, pos);

}

switch (cmd) {

case (TEXICMD_TIEACCENT):

texiputchar(p, ']');

break;

case (TEXICMD_DOTACCENT):

texiputchar(p, '*');

break;

default:

break;

}

static void

dosymbol(struct texi *p, enum texicmd cmd,

dosymbol(struct texi *p, enum texicmd cmd, size_t *pos)

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

{

if (p->seenws && p->outcol && 0 == p->literal) {

/* Remember to pad us. */

if (p->seenws && p->outcol && 0 == p->literal)

texiputchar(p, ' ');

p->seenws = 0;

}

p->seenws = 0;

switch (cmd) {

case (TEXICMD_AA):

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

break;

case (TEXICMD_AASMALL):

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

break;

case (TEXICMD_AE):

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

break;

case (TEXICMD_AESMALL):

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

break;

case (TEXICMD_ASTERISK):

case (TEXICMD_NEWLINE):

case (TEXICMD_SPACE):

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

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

case (TEXICMD_BULLET):

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

break;

case (TEXICMD_COMMA):

texiputchar(p, ',');

break;

case (TEXICMD_COPYRIGHT):

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

break;

case (TEXICMD_DH):

texiputchars(p, "\\(-D");

break;

case (TEXICMD_DHSMALL):

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

break;

case (TEXICMD_DOTS):

case (TEXICMD_ENDDOTS):

texiputchars(p, "...");

break;

case (TEXICMD_EQUIV):

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

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

case (TEXICMD_ERROR):

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

break;

case (TEXICMD_EURO):

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

break;

case (TEXICMD_EXCLAMDOWN):

texiputchars(p, "\\(r!");

break;

case (TEXICMD_EXPANSION):

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

break;

case (TEXICMD_GEQ):

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

break;

case (TEXICMD_GUILLEMETLEFT):

case (TEXICMD_GUILLEMOTLEFT):

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

break;

case (TEXICMD_GUILLEMETRIGHT):

case (TEXICMD_GUILLEMOTRIGHT):

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

break;

case (TEXICMD_GUILSINGLLEFT):

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

break;

case (TEXICMD_GUILSINGLRIGHT):

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

break;

case (TEXICMD_L):

texiputchars(p, "\\(/L");

break;

case (TEXICMD_LATEX):

texiputchars(p, "LaTeX");

break;

case (TEXICMD_LEQ):

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

break;

case (TEXICMD_LSMALL):

texiputchars(p, "\\(/l");

break;

case (TEXICMD_MINUS):

texiputchars(p, "\\-");

break;

case (TEXICMD_O):

texiputchars(p, "\\(/O");

break;

case (TEXICMD_OE):

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

break;

case (TEXICMD_OESMALL):

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

break;

case (TEXICMD_ORDF):

texiputchars(p, "a");

break;

case (TEXICMD_ORDM):

texiputchars(p, "o");

break;

case (TEXICMD_OSMALL):

texiputchars(p, "\\(/o");

break;

case (TEXICMD_PERIOD):

texiputchar(p, '.');

break;

case (TEXICMD_POUNDS):

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

break;

case (TEXICMD_QUESTIONDOWN):

texiputchars(p, "\\(r?");

break;

case (TEXICMD_QUESTIONMARK):

texiputchar(p, '?');

break;

case (TEXICMD_QUOTEDBLBASE):

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

break;

case (TEXICMD_QUOTEDBLLEFT):

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

break;

case (TEXICMD_QUOTEDBLRIGHT):

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

break;

case (TEXICMD_QUOTESINGLBASE):

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

break;

case (TEXICMD_QUOTELEFT):

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

break;

case (TEXICMD_QUOTERIGHT):

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

break;

case (TEXICMD_REGISTEREDSYMBOL):

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

break;

case (TEXICMD_RESULT):

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

break;

case (TEXICMD_SLASH):

texiputchar(p, '/');

break;

case (TEXICMD_SS):

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

break;

case (TEXICMD_SQUIGGLE_LEFT):

texiputchars(p, "{");

break;

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

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

case (TEXICMD_TEXSYM):

texiputchars(p, "TeX");

break;

case (TEXICMD_TEXTDEGREE):

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

break;

case (TEXICMD_TH):

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

break;

case (TEXICMD_THSMALL):

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

break;

case (TEXICMD_TIE):

texiputchars(p, "\\ ");

break;

case (TEXICMD_COLON):

case (TEXICMD_HYPHEN):

break;

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

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

abort();

}

if (texitoks[cmd].len > 1)

/* Alphabetic commands have braces we ignore. */

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

if (isalpha((unsigned char)texitoks[cmd].tok[0]))

doignbracket(p, cmd, pos);

}

static void

doquotation(struct texi *p, enum texicmd cmd,

doquotation(struct texi *p, enum texicmd cmd, size_t *pos)

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

{

teximacro(p, "Qo");

parseto(p, buf, sz, pos, "quotation");

parseto(p, pos, "quotation");

teximacro(p, "Qc");

}

static void

domath(struct texi *p, enum texicmd cmd,

domath(struct texi *p, enum texicmd cmd, size_t *pos)

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

{

size_t nest;

parsebracket(p, pos, 1);

* Math handling is different from everything else.

* We don't allow any subcomponents, and we ignore the rules in

* terms of @-commands.

* This departs from GNU's rules, but whatever.

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

advance(p, buf, pos);

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

return;

advance(p, buf, pos);

if (p->seenws && p->outcol && 0 == p->literal)

texiputchar(p, ' ');

p->seenws = 0;

for (nest = 1; *pos < sz && nest > 0; ) {

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

nest++;

else if ('}' == buf[*pos])

if (0 == --nest)

continue;

texiputchar(p, buf[*pos]);

advance(p, buf, pos);

}

if (*pos == sz)

return;

assert('}' == buf[*pos]);

advance(p, buf, pos);

}

static void

dovalue(struct texi *p, enum texicmd cmd,

dovalue(struct texi *p, enum texicmd cmd, size_t *pos)

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

{

size_t start, end, i;

size_t start, end;

char *key, *val;

const char *cp;

if (TEXICMD_SET == cmd) {

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

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

advance(p, buf, pos);

advance(p, pos);

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

for (start = end = *pos; end < BUFSZ(p); end++)

if (ismspace(buf[end]))

if (ismspace(BUF(p)[end]))

break;

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

if (start == end)

return;

advanceto(p, buf, pos, end);

advanceto(p, pos, end);

key = malloc(end - start + 1);

if (NULL == key)

texiabort(p, NULL);

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

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

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

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

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

advance(p, buf, pos);

advance(p, pos);

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

for (start = end = *pos; end < BUFSZ(p); end++)

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

if ('\n' == BUF(p)[end])

break;

/* We do allow empty values. */

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

advanceeoln(p, pos, 1);

val = malloc(end - start + 1);

if (NULL == val)

texiabort(p, NULL);

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

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

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

valueadd(p, key, val);

} else if (TEXICMD_VALUE == cmd) {

if (p->seenws)

texiputchar(p, ' ');

p->seenws = 0;

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

if (NULL != (cp = valueblookup(p, pos)))

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

texisplice(p, cp, strlen(cp), pos);

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

else

break;

if (i < p->valstackpos)

texierr(p, "recursive value");

if (64 == p->valstackpos)

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

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

parsemembuf(p, cp, strlen(cp));

p->valstackpos--;

} else

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

} else if (TEXICMD_IFCLEAR == cmd) {

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

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

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

doignblock(p, cmd, pos);

else

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

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

} else if (TEXICMD_IFSET == cmd) {

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

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

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

doignblock(p, cmd, pos);

else

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

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

} else if (TEXICMD_CLEAR == cmd)

valuelclear(p, buf, sz, pos);

valuelclear(p, pos);

}

static void

dolink(struct texi *p, enum texicmd cmd,

dolink(struct texi *p, enum texicmd cmd, size_t *pos)

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

{

int c;

Line 1108 dolink(struct texi *p, enum texicmd cmd,

Line 1403 dolink(struct texi *p, enum texicmd cmd,

break;

case (TEXICMD_UREF):

case (TEXICMD_URL):

case (TEXICMD_INDICATEURL):

teximacroopen(p, "Lk");

break;

case (TEXICMD_XREF):

texiputchars(p, "See Section");

teximacroopen(p, "Qq");

teximacroopen(p, "Dq");

break;

case (TEXICMD_PXREF):

texiputchars(p, "see Section");

teximacroopen(p, "Qq");

teximacroopen(p, "Dq");

break;

case (TEXICMD_INFOREF):

texiputchars(p, "See Info file node");

teximacroopen(p, "Dq");

break;

default:

abort();

}

c = parsearg(p, buf, sz, pos, 0);

c = parsearg(p, pos, 0);

p->ign++;

while (c > 0)

c = parsearg(p, buf, sz, pos, 1);

c = parsearg(p, pos, 1);

p->ign--;

texipunctuate(p, buf, sz, pos);

texipunctuate(p, pos);

teximacroclose(p);

}

static void

doignargn(struct texi *p, enum texicmd cmd,

doignargn(struct texi *p, enum texicmd cmd, size_t *pos)

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

{

int c;

c = parsearg(p, buf, sz, pos, 0);

c = parsearg(p, pos, 0);

p->ign++;

while (c > 0)

c = parsearg(p, buf, sz, pos, 1);

c = parsearg(p, pos, 1);

p->ign--;

}

Line 1166 sectioner(struct texi *p, int sec)

Line 1465 sectioner(struct texi *p, int sec)

}

static void

dosubsubsection(struct texi *p, enum texicmd cmd,

dosubsubsection(struct texi *p, enum texicmd cmd, size_t *pos)

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

{

int sec;

Line 1176 dosubsubsection(struct texi *p, enum texicmd cmd,

Line 1474 dosubsubsection(struct texi *p, enum texicmd cmd,

/* We don't have a subsubsubsection, so make one up. */

texivspace(p);

teximacroopen(p, sects[sec]);

parseeoln(p, buf, sz, pos);

parseeoln(p, pos);

teximacroclose(p);

texivspace(p);

}

static void

dosubsection(struct texi *p, enum texicmd cmd,

dosubsection(struct texi *p, enum texicmd cmd, size_t *pos)

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

{

int sec;

Line 1195 dosubsection(struct texi *p, enum texicmd cmd,

Line 1492 dosubsection(struct texi *p, enum texicmd cmd,

texierr(p, "\"%s\" in a literal scope!?", sects[sec]);

/* We don't have a subsubsection, so make one up. */

texivspace(p);

if (sec > 1)

texivspace(p);

teximacroopen(p, sects[sec]);

parseeoln(p, buf, sz, pos);

parseeoln(p, pos);

teximacroclose(p);

texivspace(p);

if (sec > 1)

texivspace(p);

}

static void

dosecoffs(struct texi *p, enum texicmd cmd,

dosecoffs(struct texi *p, enum texicmd cmd, size_t *pos)

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

{

if (TEXICMD_RAISESECTIONS == cmd)

Line 1214 dosecoffs(struct texi *p, enum texicmd cmd,

Line 1512 dosecoffs(struct texi *p, enum texicmd cmd,

}

static void

dosection(struct texi *p, enum texicmd cmd,

dosection(struct texi *p, enum texicmd cmd, size_t *pos)

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

{

int sec;

Line 1242 dosection(struct texi *p, enum texicmd cmd,

Line 1539 dosection(struct texi *p, enum texicmd cmd,

texierr(p, "\"%s\" in a literal scope!?", sects[sec]);

teximacroopen(p, sects[sec]);

parseeoln(p, buf, sz, pos);

parseeoln(p, pos);

teximacroclose(p);

p->seenvs = 1;

}

static void

dosp(struct texi *p, enum texicmd cmd,

dosp(struct texi *p, enum texicmd cmd, size_t *pos)

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

{

texivspace(p);

if (p->literal)

texiputchar(p, '\n');

else

texivspace(p);

/* FIXME: ignore and parseeoln. */

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

advanceeoln(p, pos, 1);

}

static void

dotop(struct texi *p, enum texicmd cmd,

dotop(struct texi *p, enum texicmd cmd, size_t *pos)

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

{

const char *cp;

time_t t;

char date[32];

if (--p->ign)

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

texierr(p, "@top command while ignoring");

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

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

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

teximacroclose(p);

teximacroopen(p, "Dt");

for (cp = p->title; '\0' != *cp; cp++)

texiputchar(p, toupper(*cp));

texiputchar(p, toupper((unsigned int)*cp));

texiputchars(p, " 7");

teximacroclose(p);

teximacro(p, "Os");

teximacro(p, "Sh NAME");

teximacroopen(p, "Nm");

texiputchars(p, p->title);

for (cp = p->title; '\0' != *cp; cp++)

texiputchar(p, *cp);

teximacroclose(p);

teximacroopen(p, "Nd");

texiputchars(p, NULL != p->subtitle ?

if (NULL != p->subtitle)

p->subtitle : "Unknown description");

for (cp = p->subtitle; '\0' != *cp; cp++)

texiputchar(p, *cp);

else

texiputchars(p, "Unknown description");

teximacroclose(p);

p->seenvs = 1;

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

dosection(p, cmd, pos);

}

static void

doitem(struct texi *p, enum texicmd cmd,

doitem(struct texi *p, enum texicmd cmd, size_t *pos)

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

{

/* Multitable is using raw tbl(7). */

Line 1329 doitem(struct texi *p, enum texicmd cmd,

Line 1630 doitem(struct texi *p, enum texicmd cmd,

/* Trick so we don't start with Pp. */

p->seenvs = 1;

parseeoln(p, buf, sz, pos);

parseeoln(p, pos);

if (TEXILIST_ITEM == p->list)

teximacroclose(p);

Line 1338 doitem(struct texi *p, enum texicmd cmd,

Line 1639 doitem(struct texi *p, enum texicmd cmd,

}

static void

dotab(struct texi *p, enum texicmd cmd,

dotab(struct texi *p, enum texicmd cmd, size_t *pos)

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

{

/* This command is only useful in @multitable. */

Line 1348 dotab(struct texi *p, enum texicmd cmd,

Line 1648 dotab(struct texi *p, enum texicmd cmd,

}

static void

domultitable(struct texi *p, enum texicmd cmd,

domultitable(struct texi *p, enum texicmd cmd, size_t *pos)

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

{

enum texilist sv = p->list;

int svliteral = p->literal;

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

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

columns = 0;

/* Advance to the first argument... */

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

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

advance(p, buf, pos);

advance(p, pos);

/* Make sure we don't print anything when scanning. */

p->ign++;

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

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

* Look for @columnfractions.

* We ignore these, but we do use the number of

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

* have.

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

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

advanceto(p, buf, pos, end);

advanceto(p, pos, end);

if (TEXICMD_COLUMNFRACTIONS != type)

texierr(p, "unknown multitable command");

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

while (*pos < BUFSZ(p) && '\n' != BUF(p)[*pos]) {

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

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

advance(p, buf, pos);

advance(p, pos);

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

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

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

if ('\n' == BUF(p)[*pos])

break;

advance(p, buf, pos);

advance(p, pos);

}

columns++;

}

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

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

* tbl(7) figure it out.

* So use this only to count arguments.

while (parselinearg(p, buf, sz, pos) > 0)

while (parselinearg(p, pos) > 0)

columns++;

p->ign--;

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

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

}

texiputchars(p, ".\n");

p->outmacro++;

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

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

p->outmacro--;

teximacro(p, "TE");

p->literal = svliteral;

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

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

}

static void

dotable(struct texi *p, enum texicmd cmd,

dotable(struct texi *p, enum texicmd cmd, size_t *pos)

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

{

enum texilist sv = p->list;

p->list = TEXILIST_ITEM;

teximacro(p, "Bl -tag -width Ds");

/* FIXME: ignore and parseeoln. */

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

advanceeoln(p, pos, 1);

p->seenvs = 1;

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

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

teximacro(p, "El");

p->list = sv;

}

static void

doenumerate(struct texi *p, enum texicmd cmd,

doend(struct texi *p, enum texicmd cmd, size_t *pos)

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

{

size_t start;

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

advance(p, pos);

start = *pos;

while (*pos < BUFSZ(p) && '\n' != BUF(p)[*pos])

advance(p, pos);

texiwarn(p, "unexpected \"end\": %.*s", (int)(*pos - start), &BUF(p)[start]);

advanceeoln(p, pos, 1);

}

static void

doenumerate(struct texi *p, enum texicmd cmd, size_t *pos)

{

enum texilist sv = p->list;

p->list = TEXILIST_NOITEM;

teximacro(p, "Bl -enum");

p->seenvs = 1;

/* FIXME: ignore and parseeoln. */

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

advanceeoln(p, pos, 1);

parseto(p, buf, sz, pos, "enumerate");

parseto(p, pos, "enumerate");

teximacro(p, "El");

p->list = sv;

}

static void

doitemize(struct texi *p, enum texicmd cmd,

doitemize(struct texi *p, enum texicmd cmd, size_t *pos)

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

{

enum texilist sv = p->list;

Line 1460 doitemize(struct texi *p, enum texicmd cmd,

Line 1771 doitemize(struct texi *p, enum texicmd cmd,

teximacro(p, "Bl -bullet");

p->seenvs = 1;

/* FIXME: ignore and parseeoln. */

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

advanceeoln(p, pos, 1);

parseto(p, buf, sz, pos, "itemize");

parseto(p, pos, "itemize");

teximacro(p, "El");

p->list = sv;

}

static void

doignbracket(struct texi *p, enum texicmd cmd,

doignbracket(struct texi *p, enum texicmd cmd, size_t *pos)

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

{

p->ign++;

parsebracket(p, buf, sz, pos);

parsebracket(p, pos, 0);

p->ign--;

}

static void

doignline(struct texi *p, enum texicmd cmd,

doignline(struct texi *p, enum texicmd cmd, size_t *pos)

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

{

/* FIXME: ignore and parseeoln. */

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

advanceeoln(p, pos, 1);

}

* Parse colon-separated directories from "cp" (if not NULL) and returns

* the array of pointers.

* Prepends "base" to the array.

* Prepends "base" to the array, if found.

* This does NOT sanitise the directories!

static char **

Line 1496 parsedirs(struct texi *p, const char *base, const char

Line 1805 parsedirs(struct texi *p, const char *base, const char

{

char *tok, *str, *tofree;

const char *cpp;

size_t i;

size_t i = 0;

char **dirs;

*sz = NULL != (cpp = cp) ? 2 : 1;

/* Count up our expected arguments. */

if (*sz > 1)

*sz = NULL != base;

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

if (NULL != (cpp = cp))

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

cpp++;

if (0 == *sz)

return(NULL);

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

texiabort(p, NULL);

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

if (NULL != base && NULL == (dirs[i++] = strdup(base)))

texiabort(p, NULL);

if (NULL == cp)

return(dirs);

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

texiabort(p, NULL);

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

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

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

texiabort(p, NULL);

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

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

{

struct texi texi;

int c;

char *path, *dir;

char *dirpath, *dir, *ccp;

const char *progname, *Idir, *cp;

progname = strrchr(argv[0], '/');

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

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

++progname;

memset(&texi, 0, sizeof(struct texi));

texi.ign = 1;

Idir = NULL;

while (-1 != (c = getopt(argc, argv, "I:")))

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

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

}

argv += optind;

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

argc -= optind;

goto usage;

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

if (argc > 0) {

texiabort(&texi, NULL);

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

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

texiabort(&texi, NULL);

if (NULL == (dir = dirname(dirpath)))

texiabort(&texi, NULL);

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

texi.title = strdup(cp + 1);

else

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

if (NULL == texi.title)

texiabort(&texi, NULL);

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

*ccp = '\0';

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

free(dirpath);

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

} else {

texi.title = strdup("Unknown Manual");

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

parsestdin(&texi);

}

free(path);

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

texi.title = strdup(cp + 1);

else

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

if (NULL == texi.title)

texiabort(&texi, NULL);

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

*path = '\0';

texi.ign = 1;

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

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

/* We shouldn't get here. */

texiexit(&texi);

return(EXIT_FAILURE);

usage:

fprintf(stderr, "usage: %s [-Idirs] file\n", progname);

fprintf(stderr, "usage: %s [-Idirs] [file]\n", progname);

return(EXIT_FAILURE);

}

CVSweb