version 1.14, 2015/02/19 08:09:55 |
version 1.20, 2015/02/19 16:15:17 |
|
|
*/ |
*/ |
enum texicmd { |
enum texicmd { |
TEXICMD_ACRONYM, |
TEXICMD_ACRONYM, |
|
TEXICMD_ACUTE, |
TEXICMD_A4PAPER, |
TEXICMD_A4PAPER, |
TEXICMD_ANCHOR, |
TEXICMD_ANCHOR, |
TEXICMD_APPENDIX, |
TEXICMD_APPENDIX, |
TEXICMD_APPENDIXSEC, |
TEXICMD_APPENDIXSEC, |
|
TEXICMD_APPENDIXSUBSEC, |
TEXICMD_ASTERISK, |
TEXICMD_ASTERISK, |
TEXICMD_AT, |
TEXICMD_AT, |
TEXICMD_AUTHOR, |
TEXICMD_AUTHOR, |
|
|
TEXICMD_CENTER, |
TEXICMD_CENTER, |
TEXICMD_CHAPTER, |
TEXICMD_CHAPTER, |
TEXICMD_CINDEX, |
TEXICMD_CINDEX, |
|
TEXICMD_CIRCUMFLEX, |
TEXICMD_CITE, |
TEXICMD_CITE, |
TEXICMD_CODE, |
TEXICMD_CODE, |
TEXICMD_COLON, |
TEXICMD_COLON, |
|
TEXICMD_COLUMNFRACTIONS, |
TEXICMD_COMMAND, |
TEXICMD_COMMAND, |
TEXICMD_COMMENT, |
TEXICMD_COMMENT, |
TEXICMD_COMMENT_LONG, |
TEXICMD_COMMENT_LONG, |
TEXICMD_CONTENTS, |
TEXICMD_CONTENTS, |
TEXICMD_COPYING, |
TEXICMD_COPYING, |
TEXICMD_COPYRIGHT, |
TEXICMD_COPYRIGHT, |
|
TEXICMD_DEFFN, |
|
TEXICMD_DEFFNX, |
|
TEXICMD_DEFMAC, |
|
TEXICMD_DEFMACX, |
|
TEXICMD_DEFTP, |
|
TEXICMD_DEFTPX, |
TEXICMD_DEFTYPEFN, |
TEXICMD_DEFTYPEFN, |
TEXICMD_DEFTYPEFNX, |
TEXICMD_DEFTYPEFNX, |
TEXICMD_DEFTYPEFUN, |
TEXICMD_DEFTYPEFUN, |
TEXICMD_DEFTYPEFUNX, |
TEXICMD_DEFTYPEFUNX, |
TEXICMD_DEFTYPEVAR, |
TEXICMD_DEFTYPEVAR, |
|
TEXICMD_DEFTYPEVARX, |
TEXICMD_DEFTYPEVR, |
TEXICMD_DEFTYPEVR, |
|
TEXICMD_DEFTYPEVRX, |
|
TEXICMD_DEFUN, |
|
TEXICMD_DEFUNX, |
|
TEXICMD_DEFVAR, |
|
TEXICMD_DEFVARX, |
|
TEXICMD_DEFVR, |
|
TEXICMD_DEFVRX, |
TEXICMD_DETAILMENU, |
TEXICMD_DETAILMENU, |
TEXICMD_DFN, |
TEXICMD_DFN, |
TEXICMD_DIRCATEGORY, |
TEXICMD_DIRCATEGORY, |
|
|
TEXICMD_END, |
TEXICMD_END, |
TEXICMD_ENUMERATE, |
TEXICMD_ENUMERATE, |
TEXICMD_ENV, |
TEXICMD_ENV, |
|
TEXICMD_ERROR, |
TEXICMD_EXAMPLE, |
TEXICMD_EXAMPLE, |
|
TEXICMD_EXPANSION, |
TEXICMD_FILE, |
TEXICMD_FILE, |
|
TEXICMD_FINALOUT, |
|
TEXICMD_FINDEX, |
|
TEXICMD_FTABLE, |
|
TEXICMD_FORMAT, |
|
TEXICMD_GRAVE, |
TEXICMD_GROUP, |
TEXICMD_GROUP, |
TEXICMD_HEADING, |
TEXICMD_HEADING, |
TEXICMD_HEADINGS, |
TEXICMD_HEADINGS, |
|
TEXICMD_HEADITEM, |
TEXICMD_HYPHEN, |
TEXICMD_HYPHEN, |
TEXICMD_I, |
TEXICMD_I, |
TEXICMD_IFCLEAR, |
TEXICMD_IFCLEAR, |
|
|
TEXICMD_IFTEX, |
TEXICMD_IFTEX, |
TEXICMD_IFSET, |
TEXICMD_IFSET, |
TEXICMD_IFXML, |
TEXICMD_IFXML, |
|
TEXICMD_IGNORE, |
TEXICMD_IMAGE, |
TEXICMD_IMAGE, |
TEXICMD_INCLUDE, |
TEXICMD_INCLUDE, |
TEXICMD_INDENTBLOCK, |
TEXICMD_INDENTBLOCK, |
TEXICMD_INSERTCOPYING, |
TEXICMD_INSERTCOPYING, |
TEXICMD_ITEM, |
TEXICMD_ITEM, |
TEXICMD_ITEMIZE, |
TEXICMD_ITEMIZE, |
|
TEXICMD_ITEMX, |
TEXICMD_KBD, |
TEXICMD_KBD, |
|
TEXICMD_KEY, |
|
TEXICMD_KINDEX, |
TEXICMD_LATEX, |
TEXICMD_LATEX, |
TEXICMD_MATH, |
TEXICMD_MATH, |
TEXICMD_MENU, |
TEXICMD_MENU, |
|
TEXICMD_MULTITABLE, |
|
TEXICMD_NEED, |
TEXICMD_NEWLINE, |
TEXICMD_NEWLINE, |
TEXICMD_NODE, |
TEXICMD_NODE, |
TEXICMD_NOINDENT, |
TEXICMD_NOINDENT, |
|
TEXICMD_OPTION, |
TEXICMD_PXREF, |
TEXICMD_PXREF, |
TEXICMD_QUESTIONMARK, |
TEXICMD_QUESTIONMARK, |
TEXICMD_QUOTATION, |
TEXICMD_QUOTATION, |
|
|
TEXICMD_PRINTINDEX, |
TEXICMD_PRINTINDEX, |
TEXICMD_R, |
TEXICMD_R, |
TEXICMD_REF, |
TEXICMD_REF, |
|
TEXICMD_RESULT, |
TEXICMD_SAMP, |
TEXICMD_SAMP, |
TEXICMD_SANSSERIF, |
TEXICMD_SANSSERIF, |
TEXICMD_SC, |
TEXICMD_SC, |
|
|
TEXICMD_SLANTED, |
TEXICMD_SLANTED, |
TEXICMD_SP, |
TEXICMD_SP, |
TEXICMD_SPACE, |
TEXICMD_SPACE, |
|
TEXICMD_SMALLBOOK, |
TEXICMD_SMALLDISPLAY, |
TEXICMD_SMALLDISPLAY, |
TEXICMD_SMALLEXAMPLE, |
TEXICMD_SMALLEXAMPLE, |
|
TEXICMD_SMALLFORMAT, |
TEXICMD_SMALLINDENTBLOCK, |
TEXICMD_SMALLINDENTBLOCK, |
TEXICMD_SQUIGGLE_LEFT, |
TEXICMD_SQUIGGLE_LEFT, |
TEXICMD_SQUIGGLE_RIGHT, |
TEXICMD_SQUIGGLE_RIGHT, |
TEXICMD_STRONG, |
TEXICMD_STRONG, |
|
TEXICMD_SUBHEADING, |
TEXICMD_SUBSECTION, |
TEXICMD_SUBSECTION, |
TEXICMD_SUBTITLE, |
TEXICMD_SUBTITLE, |
|
TEXICMD_SYNCODEINDEX, |
TEXICMD_T, |
TEXICMD_T, |
TEXICMD_TAB, |
TEXICMD_TAB, |
|
TEXICMD_TABSYM, |
TEXICMD_TABLE, |
TEXICMD_TABLE, |
TEXICMD_TEX, |
TEXICMD_TEX, |
TEXICMD_TEXSYM, |
TEXICMD_TEXSYM, |
|
TEXICMD_TILDE, |
TEXICMD_TITLE, |
TEXICMD_TITLE, |
TEXICMD_TITLEFONT, |
TEXICMD_TITLEFONT, |
TEXICMD_TITLEPAGE, |
TEXICMD_TITLEPAGE, |
TEXICMD_TOP, |
TEXICMD_TOP, |
|
TEXICMD_UMLAUT, |
TEXICMD_UNNUMBERED, |
TEXICMD_UNNUMBERED, |
TEXICMD_UNNUMBEREDSEC, |
TEXICMD_UNNUMBEREDSEC, |
|
TEXICMD_UNNUMBEREDSUBSEC, |
TEXICMD_UREF, |
TEXICMD_UREF, |
TEXICMD_URL, |
TEXICMD_URL, |
TEXICMD_VAR, |
TEXICMD_VAR, |
|
TEXICMD_VERBATIMINCLUDE, |
|
TEXICMD_VINDEX, |
TEXICMD_VSKIP, |
TEXICMD_VSKIP, |
|
TEXICMD_VTABLE, |
TEXICMD_W, |
TEXICMD_W, |
TEXICMD_XREF, |
TEXICMD_XREF, |
TEXICMD__MAX |
TEXICMD__MAX |
|
|
TEXILIST_NONE = 0, |
TEXILIST_NONE = 0, |
TEXILIST_ITEM, |
TEXILIST_ITEM, |
TEXILIST_NOITEM, |
TEXILIST_NOITEM, |
|
TEXILIST_TABLE |
}; |
}; |
|
|
/* |
/* |
|
|
#define ismspace(_x) \ |
#define ismspace(_x) \ |
(isws((_x)) || '\n' == (_x)) |
(isws((_x)) || '\n' == (_x)) |
|
|
|
static void doaccent(struct texi *, enum texicmd, const char *, size_t, size_t *); |
static void doblock(struct texi *, enum texicmd, const char *, size_t, size_t *); |
static void doblock(struct texi *, enum texicmd, const char *, size_t, size_t *); |
static void dobracket(struct texi *, enum texicmd, const char *, size_t, size_t *); |
static void dobracket(struct texi *, enum texicmd, const char *, size_t, size_t *); |
static void dobye(struct texi *, enum texicmd, const char *, size_t, size_t *); |
static void dobye(struct texi *, enum texicmd, const char *, size_t, size_t *); |
static void dodeftypefun(struct texi *, enum texicmd, const char *, size_t, size_t *); |
static void dodefn(struct texi *, enum texicmd, const char *, size_t, size_t *); |
static void dodeftypevar(struct texi *, enum texicmd, const char *, size_t, size_t *); |
|
static void dodisplay(struct texi *, enum texicmd, const char *, size_t, size_t *); |
static void dodisplay(struct texi *, enum texicmd, const char *, size_t, size_t *); |
static void doenumerate(struct texi *, enum texicmd, const char *, size_t, size_t *); |
static void doenumerate(struct texi *, enum texicmd, const char *, size_t, size_t *); |
static void doexample(struct texi *, enum texicmd, const char *, size_t, size_t *); |
static void doexample(struct texi *, enum texicmd, const char *, size_t, size_t *); |
Line 242 static void doitem(struct texi *, enum texicmd, const |
|
Line 288 static void doitem(struct texi *, enum texicmd, const |
|
static void doitemize(struct texi *, enum texicmd, const char *, size_t, size_t *); |
static void doitemize(struct texi *, enum texicmd, const char *, size_t, size_t *); |
static void dolink(struct texi *, enum texicmd, const char *, size_t, size_t *); |
static void dolink(struct texi *, enum texicmd, const char *, size_t, size_t *); |
static void domath(struct texi *, enum texicmd, const char *, size_t, size_t *); |
static void domath(struct texi *, enum texicmd, const char *, size_t, size_t *); |
|
static void domultitable(struct texi *, enum texicmd, const char *, size_t, size_t *); |
static void doquotation(struct texi *, enum texicmd, const char *, size_t, size_t *); |
static void doquotation(struct texi *, enum texicmd, const char *, size_t, size_t *); |
static void dotable(struct texi *, enum texicmd, const char *, size_t, size_t *); |
static void dotable(struct texi *, enum texicmd, const char *, size_t, size_t *); |
static void dotop(struct texi *, enum texicmd, const char *, size_t, size_t *); |
static void dotop(struct texi *, enum texicmd, const char *, size_t, size_t *); |
Line 249 static void dosection(struct texi *, enum texicmd, con |
|
Line 296 static void dosection(struct texi *, enum texicmd, con |
|
static void dosp(struct texi *, enum texicmd, const char *, size_t, size_t *); |
static void dosp(struct texi *, enum texicmd, const char *, size_t, size_t *); |
static void dosubsection(struct texi *, enum texicmd, const char *, size_t, size_t *); |
static void dosubsection(struct texi *, enum texicmd, const char *, size_t, size_t *); |
static void dosymbol(struct texi *, enum texicmd, const char *, size_t, size_t *); |
static void dosymbol(struct texi *, enum texicmd, const char *, size_t, size_t *); |
|
static void dotab(struct texi *, enum texicmd, const char *, size_t, size_t *); |
static void dotitle(struct texi *, enum texicmd, const char *, size_t, size_t *); |
static void dotitle(struct texi *, enum texicmd, const char *, size_t, size_t *); |
|
static void doverbinclude(struct texi *, enum texicmd, const char *, size_t, size_t *); |
|
|
static const struct texitok texitoks[TEXICMD__MAX] = { |
static const struct texitok texitoks[TEXICMD__MAX] = { |
|
/* TEXICMD__BEGIN */ |
{ doignargn, "acronym", 7 }, /* TEXICMD_ACRONYM */ |
{ doignargn, "acronym", 7 }, /* TEXICMD_ACRONYM */ |
|
{ doaccent, "'", 1 }, /* TEXICMD_ACUTE */ |
{ doignline, "afourpaper", 10 }, /* TEXICMD_A4PAPER */ |
{ doignline, "afourpaper", 10 }, /* TEXICMD_A4PAPER */ |
{ doignbracket, "anchor", 6 }, /* TEXICMD_ANCHOR */ |
{ doignbracket, "anchor", 6 }, /* TEXICMD_ANCHOR */ |
{ dosection, "appendix", 8 }, /* TEXICMD_APPENDIX */ |
{ dosection, "appendix", 8 }, /* TEXICMD_APPENDIX */ |
{ dosection, "appendixsec", 11 }, /* TEXICMD_APPENDIXSEC */ |
{ dosection, "appendixsec", 11 }, /* TEXICMD_APPENDIXSEC */ |
|
{ dosubsection, "appendixsubsec", 14 }, /* TEXICMD_APPENDIXSUBSEC */ |
{ dosymbol, "*", 1 }, /* TEXICMD_ASTERISK */ |
{ dosymbol, "*", 1 }, /* TEXICMD_ASTERISK */ |
{ dosymbol, "@", 1 }, /* TEXICMD_AT */ |
{ dosymbol, "@", 1 }, /* TEXICMD_AT */ |
{ doignline, "author", 6 }, /* TEXICMD_AUTHOR */ |
{ doignline, "author", 6 }, /* TEXICMD_AUTHOR */ |
Line 267 static const struct texitok texitoks[TEXICMD__MAX] = { |
|
Line 319 static const struct texitok texitoks[TEXICMD__MAX] = { |
|
{ doignline, "center", 6 }, /* TEXICMD_CENTER */ |
{ doignline, "center", 6 }, /* TEXICMD_CENTER */ |
{ dosection, "chapter", 7 }, /* TEXICMD_CHAPTER */ |
{ dosection, "chapter", 7 }, /* TEXICMD_CHAPTER */ |
{ doignline, "cindex", 6 }, /* TEXICMD_CINDEX */ |
{ doignline, "cindex", 6 }, /* TEXICMD_CINDEX */ |
|
{ doaccent, "^", 1 }, /* TEXICMD_CIRCUMFLEX */ |
{ dofont, "code", 4 }, /* TEXICMD_CODE */ |
{ dofont, "code", 4 }, /* TEXICMD_CODE */ |
{ dofont, "cite", 4 }, /* TEXICMD_CITE */ |
{ dofont, "cite", 4 }, /* TEXICMD_CITE */ |
{ dosymbol, ":", 1 }, /* TEXICMD_COLON */ |
{ dosymbol, ":", 1 }, /* TEXICMD_COLON */ |
|
{ NULL, "columnfractions", 15 }, /* TEXICMD_COLUMNFRACTIONS */ |
{ doinline, "command", 7 }, /* TEXICMD_COMMAND */ |
{ doinline, "command", 7 }, /* TEXICMD_COMMAND */ |
{ doignline, "c", 1 }, /* TEXICMD_COMMENT */ |
{ doignline, "c", 1 }, /* TEXICMD_COMMENT */ |
{ doignline, "comment", 7 }, /* TEXICMD_COMMENT_LONG */ |
{ doignline, "comment", 7 }, /* TEXICMD_COMMENT_LONG */ |
{ doignline, "contents", 8 }, /* TEXICMD_CONTENTS */ |
{ doignline, "contents", 8 }, /* TEXICMD_CONTENTS */ |
{ doignblock, "copying", 7 }, /* TEXICMD_COPYING */ |
{ doignblock, "copying", 7 }, /* TEXICMD_COPYING */ |
{ dosymbol, "copyright", 9 }, /* TEXICMD_COPYRIGHT */ |
{ dosymbol, "copyright", 9 }, /* TEXICMD_COPYRIGHT */ |
{ dodeftypefun, "deftypefn", 9 }, /* TEXICMD_DEFTYPEFN */ |
{ dodefn, "deffn", 5 }, /* TEXICMD_DEFFN */ |
{ dodeftypefun, "deftypefnx", 10 }, /* TEXICMD_DEFTYPEFNX */ |
{ dodefn, "deffnx", 6 }, /* TEXICMD_DEFFNX */ |
{ dodeftypefun, "deftypefun", 10 }, /* TEXICMD_DEFTYPEFUN */ |
{ dodefn, "defmac", 6 }, /* TEXICMD_DEFMAC */ |
{ dodeftypefun, "deftypefunx", 11 }, /* TEXICMD_DEFTYPEFUNX */ |
{ dodefn, "defmacx", 7 }, /* TEXICMD_DEFMACX */ |
{ dodeftypevar, "deftypevar", 10 }, /* TEXICMD_DEFTYPEVAR */ |
{ dodefn, "deftp", 5 }, /* TEXICMD_DEFTP */ |
{ dodeftypevar, "deftypevr", 9 }, /* TEXICMD_DEFTYPEVR */ |
{ dodefn, "deftpx", 6 }, /* TEXICMD_DEFTPX */ |
|
{ dodefn, "deftypefn", 9 }, /* TEXICMD_DEFTYPEFN */ |
|
{ dodefn, "deftypefnx", 10 }, /* TEXICMD_DEFTYPEFNX */ |
|
{ dodefn, "deftypefun", 10 }, /* TEXICMD_DEFTYPEFUN */ |
|
{ dodefn, "deftypefunx", 11 }, /* TEXICMD_DEFTYPEFUNX */ |
|
{ dodefn, "deftypevar", 10 }, /* TEXICMD_DEFTYPEVAR */ |
|
{ dodefn, "deftypevarx", 11 }, /* TEXICMD_DEFTYPEVARX */ |
|
{ dodefn, "deftypevr", 9 }, /* TEXICMD_DEFTYPEVR */ |
|
{ dodefn, "deftypevrx", 10 }, /* TEXICMD_DEFTYPEVRX */ |
|
{ dodefn, "defun", 5 }, /* TEXICMD_DEFUN */ |
|
{ dodefn, "defunx", 6 }, /* TEXICMD_DEFUNX */ |
|
{ dodefn, "defvar", 6 }, /* TEXICMD_DEFVAR */ |
|
{ dodefn, "defvarx", 7 }, /* TEXICMD_DEFVARX */ |
|
{ dodefn, "defvr", 5 }, /* TEXICMD_DEFVR */ |
|
{ dodefn, "defvrx", 6 }, /* TEXICMD_DEFVRX */ |
{ doignblock, "detailmenu", 10 }, /* TEXICMD_DETAILMENU */ |
{ doignblock, "detailmenu", 10 }, /* TEXICMD_DETAILMENU */ |
{ dofont, "dfn", 3 }, /* TEXICMD_DFN */ |
{ dofont, "dfn", 3 }, /* TEXICMD_DFN */ |
{ doignline, "dircategory", 11 }, /* TEXICMD_DIRCATEGORY */ |
{ doignline, "dircategory", 11 }, /* TEXICMD_DIRCATEGORY */ |
Line 293 static const struct texitok texitoks[TEXICMD__MAX] = { |
|
Line 361 static const struct texitok texitoks[TEXICMD__MAX] = { |
|
{ NULL, "end", 3 }, /* TEXICMD_END */ |
{ NULL, "end", 3 }, /* TEXICMD_END */ |
{ doenumerate, "enumerate", 9 }, /* TEXICMD_ENUMERATE */ |
{ doenumerate, "enumerate", 9 }, /* TEXICMD_ENUMERATE */ |
{ doinline, "env", 3 }, /* TEXICMD_ENV */ |
{ doinline, "env", 3 }, /* TEXICMD_ENV */ |
|
{ dosymbol, "error", 5 }, /* TEXICMD_ERROR */ |
{ doexample, "example", 7 }, /* TEXICMD_EXAMPLE */ |
{ doexample, "example", 7 }, /* TEXICMD_EXAMPLE */ |
|
{ dosymbol, "expansion", 9 }, /* TEXICMD_EXPANSION */ |
{ doinline, "file", 4 }, /* TEXICMD_FILE */ |
{ doinline, "file", 4 }, /* TEXICMD_FILE */ |
|
{ doignline, "finalout", 8 }, /* TEXICMD_FINALOUT */ |
|
{ doignline, "findex", 6 }, /* TEXICMD_FINDEX */ |
|
{ dotable, "ftable", 6 }, /* TEXICMD_FTABLE */ |
|
{ dodisplay, "format", 6 }, /* TEXICMD_FORMAT */ |
|
{ doaccent, "`", 1 }, /* TEXICMD_GRAVE */ |
{ doblock, "group", 5 }, /* TEXICMD_GROUP */ |
{ doblock, "group", 5 }, /* TEXICMD_GROUP */ |
{ dosection, "heading", 7 }, /* TEXICMD_HEADING */ |
{ dosection, "heading", 7 }, /* TEXICMD_HEADING */ |
{ doignline, "headings", 8 }, /* TEXICMD_HEADINGS */ |
{ doignline, "headings", 8 }, /* TEXICMD_HEADINGS */ |
|
{ doitem, "headitem", 8 }, /* TEXICMD_HEADITEM */ |
{ dosymbol, "-", 1 }, /* TEXICMD_HYPHEN */ |
{ dosymbol, "-", 1 }, /* TEXICMD_HYPHEN */ |
{ dofont, "i", 1 }, /* TEXICMD_I */ |
{ dofont, "i", 1 }, /* TEXICMD_I */ |
{ doignblock, "ifclear", 7 }, /* TEXICMD_IFCLEAR */ |
{ doignblock, "ifclear", 7 }, /* TEXICMD_IFCLEAR */ |
Line 314 static const struct texitok texitoks[TEXICMD__MAX] = { |
|
Line 390 static const struct texitok texitoks[TEXICMD__MAX] = { |
|
{ doignblock, "iftex", 5 }, /* TEXICMD_IFTEX */ |
{ doignblock, "iftex", 5 }, /* TEXICMD_IFTEX */ |
{ doignblock, "ifset", 5 }, /* TEXICMD_IFSET */ |
{ doignblock, "ifset", 5 }, /* TEXICMD_IFSET */ |
{ doignblock, "ifxml", 5 }, /* TEXICMD_IFXML */ |
{ doignblock, "ifxml", 5 }, /* TEXICMD_IFXML */ |
|
{ doignblock, "ignore", 6 }, /* TEXICMD_IGNORE */ |
{ doignbracket, "image", 5 }, /* TEXICMD_IMAGE */ |
{ doignbracket, "image", 5 }, /* TEXICMD_IMAGE */ |
{ doinclude, "include", 7 }, /* TEXICMD_INCLUDE */ |
{ doinclude, "include", 7 }, /* TEXICMD_INCLUDE */ |
{ dodisplay, "indentblock", 11 }, /* TEXICMD_INDENTBLOCK */ |
{ dodisplay, "indentblock", 11 }, /* TEXICMD_INDENTBLOCK */ |
{ doignline, "insertcopying", 13 }, /* TEXICMD_INSERTCOPYING */ |
{ 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 */ |
|
{ doitem, "itemx", 5 }, /* TEXICMD_ITEMX */ |
{ dofont, "kbd", 3 }, /* TEXICMD_KBD */ |
{ dofont, "kbd", 3 }, /* TEXICMD_KBD */ |
|
{ dobracket, "key", 3 }, /* TEXICMD_KEY */ |
|
{ doignline, "kindex", 6 }, /* TEXICMD_KINDEX */ |
{ dosymbol, "LaTeX", 5 }, /* TEXICMD_LATEX */ |
{ dosymbol, "LaTeX", 5 }, /* TEXICMD_LATEX */ |
{ domath, "math", 4 }, /* TEXICMD_MATH */ |
{ domath, "math", 4 }, /* TEXICMD_MATH */ |
{ doignblock, "menu", 4 }, /* TEXICMD_MENU */ |
{ doignblock, "menu", 4 }, /* TEXICMD_MENU */ |
|
{ domultitable, "multitable", 10 }, /* TEXICMD_MULTITABLE */ |
|
{ doignline, "need", 4 }, /* TEXICMD_NEED */ |
{ dosymbol, "\n", 1 }, /* TEXICMD_NEWLINE */ |
{ dosymbol, "\n", 1 }, /* TEXICMD_NEWLINE */ |
{ doignline, "node", 4 }, /* TEXICMD_NODE */ |
{ doignline, "node", 4 }, /* TEXICMD_NODE */ |
{ doignline, "noindent", 8 }, /* TEXICMD_NOINDENT */ |
{ doignline, "noindent", 8 }, /* TEXICMD_NOINDENT */ |
|
{ doinline, "option", 6 }, /* TEXICMD_OPTION */ |
{ dolink, "pxref", 5 }, /* TEXICMD_PXREF */ |
{ dolink, "pxref", 5 }, /* TEXICMD_PXREF */ |
{ dosymbol, "?", 1 }, /* TEXICMD_QUESTIONMARK */ |
{ dosymbol, "?", 1 }, /* TEXICMD_QUESTIONMARK */ |
{ doquotation, "quotation", 9 }, /* TEXICMD_QUOTATION */ |
{ doquotation, "quotation", 9 }, /* TEXICMD_QUOTATION */ |
Line 335 static const struct texitok texitoks[TEXICMD__MAX] = { |
|
Line 418 static const struct texitok texitoks[TEXICMD__MAX] = { |
|
{ doignline, "printindex", 10 }, /* TEXICMD_PRINTINDEX */ |
{ doignline, "printindex", 10 }, /* TEXICMD_PRINTINDEX */ |
{ dofont, "r", 1 }, /* TEXICMD_R */ |
{ dofont, "r", 1 }, /* TEXICMD_R */ |
{ dobracket, "ref", 3 }, /* TEXICMD_REF */ |
{ dobracket, "ref", 3 }, /* TEXICMD_REF */ |
|
{ dosymbol, "result", 6 }, /* TEXICMD_RESULT */ |
{ dofont, "samp", 4 }, /* TEXICMD_SAMP */ |
{ dofont, "samp", 4 }, /* TEXICMD_SAMP */ |
{ dofont, "sansserif", 9 }, /* TEXICMD_SANSSERIF */ |
{ dofont, "sansserif", 9 }, /* TEXICMD_SANSSERIF */ |
{ dobracket, "sc", 2 }, /* TEXICMD_SC */ |
{ dobracket, "sc", 2 }, /* TEXICMD_SC */ |
Line 346 static const struct texitok texitoks[TEXICMD__MAX] = { |
|
Line 430 static const struct texitok texitoks[TEXICMD__MAX] = { |
|
{ dofont, "slanted", 7 }, /* TEXICMD_SLANTED */ |
{ dofont, "slanted", 7 }, /* TEXICMD_SLANTED */ |
{ dosp, "sp", 2 }, /* TEXICMD_SP */ |
{ dosp, "sp", 2 }, /* TEXICMD_SP */ |
{ dosymbol, " ", 1 }, /* TEXICMD_SPACE */ |
{ dosymbol, " ", 1 }, /* TEXICMD_SPACE */ |
|
{ doignline, "smallbook", 9 }, /* TEXICMD_SMALLBOOK */ |
{ dodisplay, "smalldisplay", 12 }, /* TEXICMD_SMALLDISPLAY */ |
{ dodisplay, "smalldisplay", 12 }, /* TEXICMD_SMALLDISPLAY */ |
{ doexample, "smallexample", 12 }, /* TEXICMD_SMALLEXAMPLE */ |
{ doexample, "smallexample", 12 }, /* TEXICMD_SMALLEXAMPLE */ |
|
{ dodisplay, "smallformat", 11 }, /* TEXICMD_SMALLFORMAT */ |
{ dodisplay, "smallindentblock", 16 }, /* TEXICMD_SMALLINDENTBLOCK */ |
{ dodisplay, "smallindentblock", 16 }, /* TEXICMD_SMALLINDENTBLOCK */ |
{ dosymbol, "{", 1 }, /* TEXICMD_SQUIGGLE_LEFT */ |
{ dosymbol, "{", 1 }, /* TEXICMD_SQUIGGLE_LEFT */ |
{ dosymbol, "}", 1 }, /* TEXICMD_SQUIGGLE_RIGHT */ |
{ dosymbol, "}", 1 }, /* TEXICMD_SQUIGGLE_RIGHT */ |
{ dofont, "strong", 6 }, /* TEXICMD_STRONG */ |
{ dofont, "strong", 6 }, /* TEXICMD_STRONG */ |
|
{ dosubsection, "subheading", 10 }, /* TEXICMD_SUBHEADING */ |
{ dosubsection, "subsection", 10 }, /* TEXICMD_SUBSECTION */ |
{ dosubsection, "subsection", 10 }, /* TEXICMD_SUBSECTION */ |
{ doignline, "subtitle", 8 }, /* TEXICMD_SUBTITLE */ |
{ doignline, "subtitle", 8 }, /* TEXICMD_SUBTITLE */ |
|
{ doignline, "syncodeindex", 12 }, /* TEXICMD_SYNCODEINDEX */ |
{ dofont, "t", 1 }, /* TEXICMD_T */ |
{ dofont, "t", 1 }, /* TEXICMD_T */ |
{ dosymbol, "\t", 1 }, /* TEXICMD_TAB */ |
{ dotab, "tab", 3 }, /* TEXICMD_TAB */ |
|
{ dosymbol, "\t", 1 }, /* TEXICMD_TABSYM */ |
{ dotable, "table", 5 }, /* TEXICMD_TABLE */ |
{ dotable, "table", 5 }, /* TEXICMD_TABLE */ |
{ doignblock, "tex", 3 }, /* TEXICMD_TEX */ |
{ doignblock, "tex", 3 }, /* TEXICMD_TEX */ |
{ dosymbol, "TeX", 3 }, /* TEXICMD_TEXSYM */ |
{ dosymbol, "TeX", 3 }, /* TEXICMD_TEXSYM */ |
|
{ doaccent, "~", 1 }, /* TEXICMD_TILDE */ |
{ doignline, "title", 5 }, /* TEXICMD_TITLE */ |
{ doignline, "title", 5 }, /* TEXICMD_TITLE */ |
{ dobracket, "titlefont", 9 }, /* TEXICMD_TITLEFONT */ |
{ dobracket, "titlefont", 9 }, /* TEXICMD_TITLEFONT */ |
{ doignblock, "titlepage", 9 }, /* TEXICMD_TITLEPAGE */ |
{ doignblock, "titlepage", 9 }, /* TEXICMD_TITLEPAGE */ |
{ dotop, "top", 3 }, /* TEXICMD_TOP */ |
{ dotop, "top", 3 }, /* TEXICMD_TOP */ |
|
{ doaccent, "\"", 1 }, /* TEXICMD_UMLAUT */ |
{ dosection, "unnumbered", 10 }, /* TEXICMD_UNNUMBERED */ |
{ dosection, "unnumbered", 10 }, /* TEXICMD_UNNUMBERED */ |
{ dosection, "unnumberedsec", 13 }, /* TEXICMD_UNNUMBEREDSEC */ |
{ dosection, "unnumberedsec", 13 }, /* TEXICMD_UNNUMBEREDSEC */ |
|
{ dosubsection, "unnumberedsubsec", 16 }, /* TEXICMD_UNNUMBEREDSUBSEC */ |
{ dolink, "uref", 4 }, /* TEXICMD_UREF */ |
{ dolink, "uref", 4 }, /* TEXICMD_UREF */ |
{ dolink, "url", 3 }, /* TEXICMD_URL */ |
{ dolink, "url", 3 }, /* TEXICMD_URL */ |
{ doinline, "var", 3 }, /* TEXICMD_VAR */ |
{ doinline, "var", 3 }, /* TEXICMD_VAR */ |
|
{ doverbinclude, "verbatiminclude", 15 }, /* TEXICMD_VERBATIMINCLUDE */ |
|
{ doignline, "vindex", 6 }, /* TEXICMD_VINDEX */ |
{ dosp, "vskip", 5 }, /* TEXICMD_VSKIP */ |
{ dosp, "vskip", 5 }, /* TEXICMD_VSKIP */ |
|
{ dotable, "vtable", 6 }, /* TEXICMD_VTABLE */ |
{ dobracket, "w", 1 }, /* TEXICMD_W */ |
{ dobracket, "w", 1 }, /* TEXICMD_W */ |
{ dolink, "xref", 4 }, /* TEXICMD_XREF */ |
{ dolink, "xref", 4 }, /* TEXICMD_XREF */ |
|
/* TEXICMD__END */ |
}; |
}; |
|
|
/* |
/* |
Line 466 texierr(struct texi *p, const char *fmt, ...) |
|
Line 562 texierr(struct texi *p, const char *fmt, ...) |
|
/* |
/* |
* Put a single data character to the output if we're not ignoring. |
* Put a single data character to the output if we're not ignoring. |
* Adjusts our output status. |
* Adjusts our output status. |
|
* This shouldn't be called for macros: just for ordinary text. |
*/ |
*/ |
static void |
static void |
texiputchar(struct texi *p, char c) |
texiputchar(struct texi *p, char c) |
Line 473 texiputchar(struct texi *p, char c) |
|
Line 570 texiputchar(struct texi *p, char c) |
|
|
|
if (p->ign) |
if (p->ign) |
return; |
return; |
|
|
|
if ('.' == c && 0 == p->outcol) |
|
fputs("\\&", stdout); |
|
|
putchar(c); |
putchar(c); |
p->seenvs = 0; |
p->seenvs = 0; |
if ('\n' == c) { |
if ('\n' == c) { |
Line 484 texiputchar(struct texi *p, char c) |
|
Line 585 texiputchar(struct texi *p, char c) |
|
|
|
/* |
/* |
* Put multiple characters (see texiputchar()). |
* Put multiple characters (see texiputchar()). |
|
* This shouldn't be called for macros: just for ordinary text. |
*/ |
*/ |
static void |
static void |
texiputchars(struct texi *p, const char *s) |
texiputchars(struct texi *p, const char *s) |
|
|
teximacroclose(struct texi *p) |
teximacroclose(struct texi *p) |
{ |
{ |
|
|
/* FIXME: punctuation. */ |
if (p->ign) |
if (0 == --p->outmacro) |
return; |
texiputchar(p, '\n'); |
|
|
if (0 == --p->outmacro) { |
|
putchar('\n'); |
|
p->outcol = p->seenws = 0; |
|
} |
} |
} |
|
|
/* |
/* |
Line 514 teximacroclose(struct texi *p) |
|
Line 620 teximacroclose(struct texi *p) |
|
static void |
static void |
teximacroopen(struct texi *p, const char *s) |
teximacroopen(struct texi *p, const char *s) |
{ |
{ |
|
int rc; |
|
|
if (p->outcol && 0 == p->outmacro) |
if (p->ign) |
texiputchar(p, '\n'); |
return; |
|
|
|
if (p->outcol && 0 == p->outmacro) { |
|
putchar('\n'); |
|
p->outcol = 0; |
|
} |
|
|
if (0 == p->outmacro) |
if (0 == p->outmacro) |
texiputchar(p, '.'); |
putchar('.'); |
else |
else |
texiputchar(p, ' '); |
putchar(' '); |
texiputchars(p, s); |
|
texiputchar(p, ' '); |
if (EOF != (rc = fputs(s, stdout))) |
|
p->outcol += rc; |
|
|
|
putchar(' '); |
|
p->outcol++; |
p->outmacro++; |
p->outmacro++; |
p->seenws = 0; |
p->seenws = 0; |
} |
} |
|
|
teximacro(struct texi *p, const char *s) |
teximacro(struct texi *p, const char *s) |
{ |
{ |
|
|
|
if (p->ign) |
|
return; |
|
|
if (p->outmacro) |
if (p->outmacro) |
texierr(p, "\"%s\" in open line scope!?", s); |
texierr(p, "\"%s\" in open line scope!?", s); |
else if (p->literal) |
if (p->literal) |
texierr(p, "\"%s\" in a literal scope!?", s); |
texierr(p, "\"%s\" in a literal scope!?", s); |
|
|
if (p->outcol) |
if (p->outcol) |
texiputchar(p, '\n'); |
putchar('\n'); |
|
|
texiputchar(p, '.'); |
putchar('.'); |
texiputchars(p, s); |
puts(s); |
texiputchar(p, '\n'); |
p->outcol = p->seenws = 0; |
} |
} |
|
|
static void |
static void |
Line 680 texiword(struct texi *p, const char *buf, |
|
Line 800 texiword(struct texi *p, const char *buf, |
|
size_t sz, size_t *pos, char extra) |
size_t sz, size_t *pos, char extra) |
{ |
{ |
|
|
if (0 == p->outmacro && p->outcol > 72 && 0 == p->literal) |
if (p->seenws && 0 == p->outmacro && p->outcol > 72 && 0 == p->literal) |
texiputchar(p, '\n'); |
texiputchar(p, '\n'); |
/* FIXME: abstract this: we use it elsewhere. */ |
/* FIXME: abstract this: we use it elsewhere. */ |
if (p->seenws && p->outcol && 0 == p->literal) |
if (p->seenws && p->outcol && 0 == p->literal) |
Line 868 parseeoln(struct texi *p, const char *buf, size_t sz, |
|
Line 988 parseeoln(struct texi *p, const char *buf, size_t sz, |
|
size_t end; |
size_t end; |
enum texicmd cmd; |
enum texicmd cmd; |
|
|
assert(0 == p->literal); |
|
|
|
while (*pos < sz && '\n' != buf[*pos]) { |
while (*pos < sz && '\n' != buf[*pos]) { |
while (*pos < sz && isws(buf[*pos])) { |
while (*pos < sz && isws(buf[*pos])) { |
p->seenws = 1; |
p->seenws = 1; |
|
if (p->literal) |
|
texiputchar(p, buf[*pos]); |
advance(p, buf, pos); |
advance(p, buf, pos); |
} |
} |
switch (buf[*pos]) { |
switch (buf[*pos]) { |
Line 941 parsesingle(struct texi *p, const char *buf, size_t sz |
|
Line 1061 parsesingle(struct texi *p, const char *buf, size_t sz |
|
(*texitoks[cmd].fp)(p, cmd, buf, sz, pos); |
(*texitoks[cmd].fp)(p, cmd, buf, sz, pos); |
} |
} |
|
|
|
static int |
|
parselinearg(struct texi *p, const char *buf, size_t sz, size_t *pos) |
|
{ |
|
|
|
while (*pos < sz && isws(buf[*pos])) { |
|
p->seenws = 1; |
|
advance(p, buf, pos); |
|
} |
|
|
|
if (*pos < sz && '{' == buf[*pos]) |
|
parsebracket(p, buf, sz, pos); |
|
else if ('\n' != buf[*pos]) |
|
parsesingle(p, buf, sz, pos); |
|
else |
|
return(0); |
|
|
|
return(1); |
|
} |
|
|
/* |
/* |
* Parse til the end of the buffer. |
* Parse til the end of the buffer. |
*/ |
*/ |
Line 1017 parseto(struct texi *p, const char *buf, |
|
Line 1156 parseto(struct texi *p, const char *buf, |
|
* This can be called in a nested context. |
* This can be called in a nested context. |
*/ |
*/ |
static void |
static void |
parsefile(struct texi *p, const char *fname) |
parsefile(struct texi *p, const char *fname, int parse) |
{ |
{ |
struct texifile *f; |
struct texifile *f; |
int fd; |
int fd; |
struct stat st; |
struct stat st; |
|
size_t i; |
|
|
assert(p->filepos < 64); |
assert(p->filepos < 64); |
f = &p->files[p->filepos]; |
f = &p->files[p->filepos]; |
Line 1044 parsefile(struct texi *p, const char *fname) |
|
Line 1184 parsefile(struct texi *p, const char *fname) |
|
texiabort(p, fname); |
texiabort(p, fname); |
|
|
p->filepos++; |
p->filepos++; |
parseeof(p, f->map, f->mapsz); |
if ( ! parse) { |
|
/* |
|
* We're printing verbatim output. |
|
* Make sure it doesn't get interpreted as mdoc by |
|
* escaping escapes and making sure leading dots don't |
|
* trigger mdoc(7) expansion. |
|
*/ |
|
for (i = 0; i < f->mapsz; i++) { |
|
if (i > 0 && '.' == f->map[i]) |
|
if ('\n' == f->map[i - 1]) |
|
fputs("\\&", stdout); |
|
putchar(f->map[i]); |
|
if ('\\' == f->map[i]) |
|
putchar('e'); |
|
} |
|
} else |
|
parseeof(p, f->map, f->mapsz); |
texifilepop(p); |
texifilepop(p); |
} |
} |
|
|
static void |
static void |
dodeftypevar(struct texi *p, enum texicmd cmd, |
dodefn(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; |
const char *blk; |
|
|
blk = TEXICMD_DEFTYPEVR == cmd ? |
|
"deftypevr" : "deftypevar"; |
|
|
|
if (p->ign) { |
|
parseto(p, buf, sz, pos, blk); |
|
return; |
|
} |
|
|
|
texivspace(p); |
|
if (TEXICMD_DEFTYPEVR == cmd) { |
|
parsebracket(p, buf, sz, pos); |
|
texiputchars(p, ":\n"); |
|
} |
|
teximacroopen(p, "Vt"); |
|
parseeoln(p, buf, sz, pos); |
|
teximacroclose(p); |
|
texivspace(p); |
|
parseto(p, buf, sz, pos, blk); |
|
} |
|
|
|
static void |
|
dodeftypefun(struct texi *p, enum texicmd cmd, |
|
const char *buf, size_t sz, size_t *pos) |
|
{ |
|
const char *blk; |
|
|
|
blk = NULL; |
blk = NULL; |
switch (cmd) { |
switch (cmd) { |
|
case (TEXICMD_DEFFN): |
|
case (TEXICMD_DEFTP): |
case (TEXICMD_DEFTYPEFN): |
case (TEXICMD_DEFTYPEFN): |
case (TEXICMD_DEFTYPEFUN): |
case (TEXICMD_DEFTYPEFUN): |
|
case (TEXICMD_DEFTYPEVAR): |
|
case (TEXICMD_DEFTYPEVR): |
|
case (TEXICMD_DEFUN): |
|
case (TEXICMD_DEFVAR): |
|
case (TEXICMD_DEFVR): |
blk = texitoks[cmd].tok; |
blk = texitoks[cmd].tok; |
break; |
break; |
default: |
default: |
Line 1091 dodeftypefun(struct texi *p, enum texicmd cmd, |
|
Line 1228 dodeftypefun(struct texi *p, enum texicmd cmd, |
|
} |
} |
|
|
if (p->ign) { |
if (p->ign) { |
if (NULL != blk) |
NULL != blk ? |
parseto(p, buf, sz, pos, blk); |
parseto(p, buf, sz, pos, blk) : |
|
parseeoln(p, buf, sz, pos); |
return; |
return; |
} |
} |
|
|
|
if (NULL != blk) |
|
texivspace(p); |
|
|
switch (cmd) { |
switch (cmd) { |
case (TEXICMD_DEFTYPEFN): |
case (TEXICMD_DEFMAC): |
|
case (TEXICMD_DEFMACX): |
|
texiputchars(p, "Macro"); |
|
break; |
|
case (TEXICMD_DEFTYPEVAR): |
|
case (TEXICMD_DEFTYPEVARX): |
|
case (TEXICMD_DEFVAR): |
|
case (TEXICMD_DEFVARX): |
|
texiputchars(p, "Variable"); |
|
break; |
case (TEXICMD_DEFTYPEFUN): |
case (TEXICMD_DEFTYPEFUN): |
texivspace(p); |
case (TEXICMD_DEFTYPEFUNX): |
|
case (TEXICMD_DEFUN): |
|
case (TEXICMD_DEFUNX): |
|
texiputchars(p, "Function"); |
break; |
break; |
default: |
default: |
|
parselinearg(p, buf, sz, pos); |
break; |
break; |
} |
} |
if (TEXICMD_DEFTYPEFN == cmd || |
|
TEXICMD_DEFTYPEFNX == cmd) { |
texiputchars(p, ":\n"); |
parsebracket(p, buf, sz, pos); |
|
texiputchars(p, ":\n"); |
switch (cmd) { |
|
case (TEXICMD_DEFMAC): |
|
case (TEXICMD_DEFMACX): |
|
teximacroopen(p, "Dv"); |
|
while (parselinearg(p, buf, sz, pos)) |
|
/* Spin. */ ; |
|
teximacroclose(p); |
|
break; |
|
case (TEXICMD_DEFFN): |
|
case (TEXICMD_DEFFNX): |
|
case (TEXICMD_DEFUN): |
|
case (TEXICMD_DEFUNX): |
|
teximacroopen(p, "Fo"); |
|
parselinearg(p, buf, sz, pos); |
|
teximacroclose(p); |
|
teximacroopen(p, "Fa"); |
|
while (parselinearg(p, buf, sz, pos)) |
|
/* Spin. */ ; |
|
teximacroclose(p); |
|
teximacro(p, "Fc"); |
|
break; |
|
case (TEXICMD_DEFTYPEFUN): |
|
case (TEXICMD_DEFTYPEFUNX): |
|
case (TEXICMD_DEFTYPEFN): |
|
case (TEXICMD_DEFTYPEFNX): |
|
teximacroopen(p, "Ft"); |
|
parselinearg(p, buf, sz, pos); |
|
teximacroclose(p); |
|
teximacroopen(p, "Fo"); |
|
parselinearg(p, buf, sz, pos); |
|
teximacroclose(p); |
|
teximacroopen(p, "Fa"); |
|
while (parselinearg(p, buf, sz, pos)) |
|
/* Spin. */ ; |
|
teximacroclose(p); |
|
teximacro(p, "Fc"); |
|
break; |
|
case (TEXICMD_DEFTP): |
|
case (TEXICMD_DEFTPX): |
|
case (TEXICMD_DEFTYPEVAR): |
|
case (TEXICMD_DEFTYPEVARX): |
|
case (TEXICMD_DEFTYPEVR): |
|
case (TEXICMD_DEFTYPEVRX): |
|
teximacroopen(p, "Vt"); |
|
while (parselinearg(p, buf, sz, pos)) |
|
/* Spin. */ ; |
|
teximacroclose(p); |
|
break; |
|
case (TEXICMD_DEFVAR): |
|
case (TEXICMD_DEFVARX): |
|
case (TEXICMD_DEFVR): |
|
case (TEXICMD_DEFVRX): |
|
teximacroopen(p, "Va"); |
|
while (parselinearg(p, buf, sz, pos)) |
|
/* Spin. */ ; |
|
teximacroclose(p); |
|
break; |
|
default: |
|
abort(); |
} |
} |
teximacroopen(p, "Ft"); |
|
parsesingle(p, buf, sz, pos); |
|
teximacroclose(p); |
|
teximacroopen(p, "Fn"); |
|
parsesingle(p, buf, sz, pos); |
|
teximacroclose(p); |
|
teximacroopen(p, "Li"); |
|
parseeoln(p, buf, sz, pos); |
|
teximacroclose(p); |
|
texivspace(p); |
texivspace(p); |
if (NULL != blk) |
if (NULL != blk) |
parseto(p, buf, sz, pos, blk); |
parseto(p, buf, sz, pos, blk); |
Line 1157 doinline(struct texi *p, enum texicmd cmd, |
|
Line 1361 doinline(struct texi *p, enum texicmd cmd, |
|
case (TEXICMD_FILE): |
case (TEXICMD_FILE): |
macro = "Pa"; |
macro = "Pa"; |
break; |
break; |
|
case (TEXICMD_OPTION): |
|
macro = "Op"; |
|
break; |
case (TEXICMD_VAR): |
case (TEXICMD_VAR): |
macro = "Va"; |
macro = "Va"; |
break; |
break; |
Line 1177 doinline(struct texi *p, enum texicmd cmd, |
|
Line 1384 doinline(struct texi *p, enum texicmd cmd, |
|
} |
} |
|
|
static void |
static void |
|
doverbinclude(struct texi *p, enum texicmd cmd, |
|
const char *buf, size_t sz, size_t *pos) |
|
{ |
|
char fname[PATH_MAX], path[PATH_MAX]; |
|
int rc; |
|
size_t i; |
|
|
|
while (*pos < sz && ' ' == buf[*pos]) |
|
advance(p, buf, pos); |
|
|
|
/* Read in the filename. */ |
|
for (i = 0; *pos < sz && '\n' != buf[*pos]; i++) { |
|
if (i == sizeof(fname) - 1) |
|
break; |
|
fname[i] = buf[*pos]; |
|
advance(p, buf, pos); |
|
} |
|
|
|
if (i == 0) |
|
texierr(p, "path too short"); |
|
else if ('\n' != buf[*pos]) |
|
texierr(p, "path too long"); |
|
else if ('/' == fname[0]) |
|
texierr(p, "no absolute paths"); |
|
fname[i] = '\0'; |
|
|
|
if (strstr(fname, "../") || strstr(fname, "/..")) |
|
texierr(p, "insecure path"); |
|
|
|
rc = snprintf(path, sizeof(path), |
|
"%s/%s", p->dirs[0], fname); |
|
if (rc < 0) |
|
texierr(p, "couldn't format path"); |
|
else if ((size_t)rc >= sizeof(path)) |
|
texierr(p, "path too long"); |
|
|
|
parsefile(p, path, 0); |
|
} |
|
|
|
static void |
doinclude(struct texi *p, enum texicmd cmd, |
doinclude(struct texi *p, enum texicmd cmd, |
const char *buf, size_t sz, size_t *pos) |
const char *buf, size_t sz, size_t *pos) |
{ |
{ |
Line 1216 doinclude(struct texi *p, enum texicmd cmd, |
|
Line 1463 doinclude(struct texi *p, enum texicmd cmd, |
|
else if (-1 == access(path, R_OK)) |
else if (-1 == access(path, R_OK)) |
continue; |
continue; |
|
|
parsefile(p, path); |
parsefile(p, path, 1); |
return; |
return; |
} |
} |
|
|
Line 1253 dofont(struct texi *p, enum texicmd cmd, |
|
Line 1500 dofont(struct texi *p, enum texicmd cmd, |
|
abort(); |
abort(); |
} |
} |
|
|
|
if (p->seenws) { |
|
texiputchar(p, ' '); |
|
p->seenws = 0; |
|
} |
texiputchars(p, font); |
texiputchars(p, font); |
parsebracket(p, buf, sz, pos); |
parsebracket(p, buf, sz, pos); |
texiputchars(p, "\\fP"); |
texiputchars(p, "\\fP"); |
Line 1271 dodisplay(struct texi *p, enum texicmd cmd, |
|
Line 1522 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 -filled -offset indent"); |
switch (cmd) { |
|
case (TEXICMD_FORMAT): |
|
case (TEXICMD_SMALLFORMAT): |
|
teximacro(p, "Bd -filled"); |
|
break; |
|
default: |
|
teximacro(p, "Bd -filled -offset indent"); |
|
break; |
|
} |
|
|
p->seenvs = 1; |
p->seenvs = 1; |
/* FIXME: ignore and parseeoln. */ |
/* FIXME: ignore and parseeoln. */ |
advanceeoln(p, buf, sz, pos, 1); |
advanceeoln(p, buf, sz, pos, 1); |
Line 1320 dotitle(struct texi *p, enum texicmd cmd, |
|
Line 1580 dotitle(struct texi *p, enum texicmd cmd, |
|
} |
} |
|
|
static void |
static void |
|
doaccent(struct texi *p, enum texicmd cmd, |
|
const char *buf, size_t sz, size_t *pos) |
|
{ |
|
|
|
if (*pos == sz) |
|
return; |
|
advance(p, buf, pos); |
|
switch (cmd) { |
|
case (TEXICMD_ACUTE): |
|
switch (buf[*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]); |
|
} |
|
break; |
|
case (TEXICMD_CIRCUMFLEX): |
|
switch (buf[*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]); |
|
} |
|
break; |
|
case (TEXICMD_GRAVE): |
|
switch (buf[*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]); |
|
} |
|
break; |
|
case (TEXICMD_TILDE): |
|
switch (buf[*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]); |
|
} |
|
break; |
|
case (TEXICMD_UMLAUT): |
|
switch (buf[*pos]) { |
|
case ('a'): case ('A'): |
|
case ('e'): case ('E'): |
|
case ('i'): case ('I'): |
|
case ('o'): case ('O'): |
|
case ('u'): case ('U'): |
|
case ('y'): |
|
texiputchars(p, "\\(:"); |
|
texiputchar(p, buf[*pos]); |
|
break; |
|
default: |
|
texiputchar(p, buf[*pos]); |
|
} |
|
break; |
|
default: |
|
abort(); |
|
} |
|
} |
|
|
|
static void |
dosymbol(struct texi *p, enum texicmd cmd, |
dosymbol(struct texi *p, enum texicmd cmd, |
const char *buf, size_t sz, size_t *pos) |
const char *buf, size_t sz, size_t *pos) |
{ |
{ |
Line 1333 dosymbol(struct texi *p, enum texicmd cmd, |
|
Line 1676 dosymbol(struct texi *p, enum texicmd cmd, |
|
case (TEXICMD_ASTERISK): |
case (TEXICMD_ASTERISK): |
case (TEXICMD_NEWLINE): |
case (TEXICMD_NEWLINE): |
case (TEXICMD_SPACE): |
case (TEXICMD_SPACE): |
case (TEXICMD_TAB): |
case (TEXICMD_TABSYM): |
texiputchar(p, ' '); |
texiputchar(p, ' '); |
break; |
break; |
case (TEXICMD_AT): |
case (TEXICMD_AT): |
Line 1351 dosymbol(struct texi *p, enum texicmd cmd, |
|
Line 1694 dosymbol(struct texi *p, enum texicmd cmd, |
|
case (TEXICMD_DOTS): |
case (TEXICMD_DOTS): |
texiputchars(p, "..."); |
texiputchars(p, "..."); |
break; |
break; |
|
case (TEXICMD_ERROR): |
|
texiputchars(p, "error\\(->"); |
|
break; |
|
case (TEXICMD_EXPANSION): |
|
texiputchars(p, "\\(->"); |
|
break; |
case (TEXICMD_LATEX): |
case (TEXICMD_LATEX): |
texiputchars(p, "LaTeX"); |
texiputchars(p, "LaTeX"); |
break; |
break; |
case (TEXICMD_QUESTIONMARK): |
case (TEXICMD_QUESTIONMARK): |
texiputchar(p, '?'); |
texiputchar(p, '?'); |
break; |
break; |
|
case (TEXICMD_RESULT): |
|
texiputchars(p, "\\(rA"); |
|
break; |
case (TEXICMD_SQUIGGLE_LEFT): |
case (TEXICMD_SQUIGGLE_LEFT): |
texiputchars(p, "{"); |
texiputchars(p, "{"); |
break; |
break; |
Line 1541 dotop(struct texi *p, enum texicmd cmd, |
|
Line 1893 dotop(struct texi *p, enum texicmd cmd, |
|
time_t t; |
time_t t; |
char date[32]; |
char date[32]; |
|
|
|
/* |
|
* Here we print our standard mdoc(7) prologue. |
|
* We use the title set with @settitle for the `Nd' description |
|
* and the source document filename (the first one as invoked on |
|
* the command line) for the title. |
|
* The date is set to the current date. |
|
*/ |
t = time(NULL); |
t = time(NULL); |
strftime(date, sizeof(date), "%F", localtime(&t)); |
strftime(date, sizeof(date), "%F", localtime(&t)); |
|
|
Line 1571 doitem(struct texi *p, enum texicmd cmd, |
|
Line 1930 doitem(struct texi *p, enum texicmd cmd, |
|
const char *buf, size_t sz, size_t *pos) |
const char *buf, size_t sz, size_t *pos) |
{ |
{ |
|
|
|
/* Multitable is using raw tbl(7). */ |
|
if (TEXILIST_TABLE == p->list) { |
|
texiputchar(p, '\n'); |
|
return; |
|
} |
|
|
if (p->outmacro) |
if (p->outmacro) |
texierr(p, "item in open line scope!?"); |
texierr(p, "item in open line scope!?"); |
else if (p->literal) |
else if (p->literal) |
Line 1587 doitem(struct texi *p, enum texicmd cmd, |
|
Line 1952 doitem(struct texi *p, enum texicmd cmd, |
|
texivspace(p); |
texivspace(p); |
break; |
break; |
} |
} |
p->seenvs = 1; |
|
|
|
|
/* Trick so we don't start with Pp. */ |
|
p->seenvs = 1; |
parseeoln(p, buf, sz, pos); |
parseeoln(p, buf, sz, pos); |
|
|
if (TEXILIST_ITEM == p->list) |
if (TEXILIST_ITEM == p->list) |
Line 1598 doitem(struct texi *p, enum texicmd cmd, |
|
Line 1964 doitem(struct texi *p, enum texicmd cmd, |
|
} |
} |
|
|
static void |
static void |
|
dotab(struct texi *p, enum texicmd cmd, |
|
const char *buf, size_t sz, size_t *pos) |
|
{ |
|
|
|
/* This command is only useful in @multitable. */ |
|
if (TEXILIST_TABLE == p->list) |
|
texiputchar(p, '\t'); |
|
} |
|
|
|
static void |
|
domultitable(struct texi *p, enum texicmd cmd, |
|
const char *buf, size_t sz, size_t *pos) |
|
{ |
|
enum texilist sv = p->list; |
|
enum texicmd type; |
|
size_t i, end, columns; |
|
|
|
p->list = TEXILIST_TABLE; |
|
teximacro(p, "TS"); |
|
columns = 0; |
|
|
|
/* Advance to the first argument... */ |
|
while (*pos < sz && isws(buf[*pos])) |
|
advance(p, buf, pos); |
|
|
|
/* Make sure we don't print anything when scanning. */ |
|
p->ign++; |
|
if ('@' == buf[*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); |
|
advanceto(p, buf, pos, end); |
|
if (TEXICMD_COLUMNFRACTIONS != type) |
|
texierr(p, "unknown multitable type"); |
|
while (*pos < sz && '\n' != buf[*pos]) { |
|
while (*pos < sz && isws(buf[*pos])) |
|
advance(p, buf, pos); |
|
while (*pos < sz && ! isws(buf[*pos])) { |
|
if ('\n' == buf[*pos]) |
|
break; |
|
advance(p, buf, pos); |
|
} |
|
columns++; |
|
} |
|
} else |
|
/* |
|
* We have arguments. |
|
* We could parse these, but it's easier to just let |
|
* tbl(7) figure it out. |
|
* So use this only to count arguments. |
|
*/ |
|
while (parselinearg(p, buf, sz, pos) > 0) |
|
columns++; |
|
p->ign--; |
|
|
|
/* Left-justify each table entry. */ |
|
for (i = 0; i < columns; i++) { |
|
if (i > 0) |
|
texiputchar(p, ' '); |
|
texiputchar(p, 'l'); |
|
} |
|
texiputchars(p, ".\n"); |
|
p->outmacro++; |
|
parseto(p, buf, sz, pos, texitoks[cmd].tok); |
|
p->outmacro--; |
|
teximacro(p, "TE"); |
|
p->list = sv; |
|
} |
|
|
|
static void |
dotable(struct texi *p, enum texicmd cmd, |
dotable(struct texi *p, enum texicmd cmd, |
const char *buf, size_t sz, size_t *pos) |
const char *buf, size_t sz, size_t *pos) |
{ |
{ |
Line 1608 dotable(struct texi *p, enum texicmd cmd, |
|
Line 2048 dotable(struct texi *p, enum texicmd cmd, |
|
/* FIXME: ignore and parseeoln. */ |
/* FIXME: ignore and parseeoln. */ |
advanceeoln(p, buf, sz, pos, 1); |
advanceeoln(p, buf, sz, pos, 1); |
p->seenvs = 1; |
p->seenvs = 1; |
parseto(p, buf, sz, pos, "table"); |
parseto(p, buf, sz, pos, texitoks[cmd].tok); |
teximacro(p, "El"); |
teximacro(p, "El"); |
p->list = sv; |
p->list = sv; |
} |
} |
Line 1763 main(int argc, char *argv[]) |
|
Line 2203 main(int argc, char *argv[]) |
|
|
|
texi.ign = 1; |
texi.ign = 1; |
texi.dirs = parsedirs(dir, Idir, &texi.dirsz); |
texi.dirs = parsedirs(dir, Idir, &texi.dirsz); |
parsefile(&texi, argv[0]); |
parsefile(&texi, argv[0], 1); |
/* We shouldn't get here. */ |
/* We shouldn't get here. */ |
texiexit(&texi); |
texiexit(&texi); |
return(EXIT_FAILURE); |
return(EXIT_FAILURE); |