[BACK]Return to main.c CVS log [TXT][DIR] Up to [cvsweb.bsd.lv] / texi2mdoc

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

version 1.32, 2015/02/23 12:28:20 version 1.45, 2015/02/25 10:01:54
Line 14 
Line 14 
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF   * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.   * 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 <assert.h>
 #include <ctype.h>  #include <ctype.h>
 #include <fcntl.h>  
 #include <getopt.h>  #include <getopt.h>
 #include <libgen.h>  #include <libgen.h>
 #include <limits.h>  #include <limits.h>
Line 28 
Line 27 
 #include <stdlib.h>  #include <stdlib.h>
 #include <string.h>  #include <string.h>
 #include <time.h>  #include <time.h>
 #include <unistd.h>  
   
 #include "extern.h"  #include "extern.h"
   
Line 47  static void dobye(struct texi *, enum texicmd, const c
Line 45  static void dobye(struct texi *, enum texicmd, const c
 static  void dodefindex(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void dodefindex(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 dodefn(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 doend(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 *);
 static  void doignargn(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void doignargn(struct texi *, enum texicmd, const char *, size_t, size_t *);
Line 74  static void dotab(struct texi *, enum texicmd, const c
Line 73  static void dotab(struct texi *, enum texicmd, const c
 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 dovalue(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void dovalue(struct texi *, enum texicmd, const char *, size_t, size_t *);
 static  void doverb(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void doverb(struct texi *, enum texicmd, const char *, size_t, size_t *);
   static  void doverbatim(struct texi *, enum texicmd, const char *, size_t, size_t *);
 static  void doverbinclude(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 */          /* TEXICMD__BEGIN */
           { doignline, "afourpaper", 10 }, /* TEXICMD_A4PAPER */
           { dosymbol, "AA", 2 }, /* TEXICMD_AA */
           { dosymbol, "aa", 2 }, /* TEXICMD_AASMALL */
         { doignargn, "acronym", 7 }, /* TEXICMD_ACRONYM */          { doignargn, "acronym", 7 }, /* TEXICMD_ACRONYM */
         { doaccent, "'", 1 }, /* TEXICMD_ACUTE */          { doaccent, "'", 1 }, /* TEXICMD_ACUTE */
         { doignline, "afourpaper", 10 }, /* TEXICMD_A4PAPER */          { dosymbol, "AE", 2 }, /* TEXICMD_AE */
           { dosymbol, "ae", 2 }, /* TEXICMD_AESMALL */
         { 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 */
Line 94  static const struct texitok __texitoks[TEXICMD__MAX] =
Line 98  static const struct texitok __texitoks[TEXICMD__MAX] =
         { dosymbol, "!", 1 }, /* TEXICMD_BANG */          { dosymbol, "!", 1 }, /* TEXICMD_BANG */
         { dosymbol, "bullet", 6 }, /* TEXICMD_BULLET */          { dosymbol, "bullet", 6 }, /* TEXICMD_BULLET */
         { dobye, "bye", 3 }, /* TEXICMD_BYE */          { dobye, "bye", 3 }, /* TEXICMD_BYE */
           { doblock, "cartouche", 9 }, /* TEXICMD_CARTOUCHE */
           { doaccent, ",", 1 }, /* TEXICMD_CEDILLA */
         { 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 */
Line 103  static const struct texitok __texitoks[TEXICMD__MAX] =
Line 109  static const struct texitok __texitoks[TEXICMD__MAX] =
         { doinline, "code", 4 }, /* TEXICMD_CODE */          { doinline, "code", 4 }, /* TEXICMD_CODE */
         { dosymbol, ":", 1 }, /* TEXICMD_COLON */          { dosymbol, ":", 1 }, /* TEXICMD_COLON */
         { NULL, "columnfractions", 15 }, /* TEXICMD_COLUMNFRACTIONS */          { NULL, "columnfractions", 15 }, /* TEXICMD_COLUMNFRACTIONS */
           { dosymbol, "comma", 5 }, /* TEXICMD_COMMA */
         { 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 */
Line 121  static const struct texitok __texitoks[TEXICMD__MAX] =
Line 128  static const struct texitok __texitoks[TEXICMD__MAX] =
         { dodefn, "deftypefnx", 10 }, /* TEXICMD_DEFTYPEFNX */          { dodefn, "deftypefnx", 10 }, /* TEXICMD_DEFTYPEFNX */
         { dodefn, "deftypefun", 10 }, /* TEXICMD_DEFTYPEFUN */          { dodefn, "deftypefun", 10 }, /* TEXICMD_DEFTYPEFUN */
         { dodefn, "deftypefunx", 11 }, /* TEXICMD_DEFTYPEFUNX */          { dodefn, "deftypefunx", 11 }, /* TEXICMD_DEFTYPEFUNX */
           { dodefn, "deftypemethod", 13 }, /* TEXICMD_DEFTYPEMETHOD */
           { dodefn, "deftypemethodx", 14 }, /* TEXICMD_DEFTYPEMETHODX */
         { dodefn, "deftypevar", 10 }, /* TEXICMD_DEFTYPEVAR */          { dodefn, "deftypevar", 10 }, /* TEXICMD_DEFTYPEVAR */
         { dodefn, "deftypevarx", 11 }, /* TEXICMD_DEFTYPEVARX */          { dodefn, "deftypevarx", 11 }, /* TEXICMD_DEFTYPEVARX */
         { dodefn, "deftypevr", 9 }, /* TEXICMD_DEFTYPEVR */          { dodefn, "deftypevr", 9 }, /* TEXICMD_DEFTYPEVR */
Line 133  static const struct texitok __texitoks[TEXICMD__MAX] =
Line 142  static const struct texitok __texitoks[TEXICMD__MAX] =
         { dodefn, "defvrx", 6 }, /* TEXICMD_DEFVRX */          { dodefn, "defvrx", 6 }, /* TEXICMD_DEFVRX */
         { doignblock, "detailmenu", 10 }, /* TEXICMD_DETAILMENU */          { doignblock, "detailmenu", 10 }, /* TEXICMD_DETAILMENU */
         { doinline, "dfn", 3 }, /* TEXICMD_DFN */          { doinline, "dfn", 3 }, /* TEXICMD_DFN */
           { dosymbol, "DH", 2 }, /* TEXICMD_DH */
           { dosymbol, "dh", 2 }, /* TEXICMD_DHSMALL */
         { doignline, "dircategory", 11 }, /* TEXICMD_DIRCATEGORY */          { doignline, "dircategory", 11 }, /* TEXICMD_DIRCATEGORY */
         { doignblock, "direntry", 8 }, /* TEXICMD_DIRENTRY */          { doignblock, "direntry", 8 }, /* TEXICMD_DIRENTRY */
         { dodisplay, "display", 7 }, /* TEXICMD_DISPLAY */          { dodisplay, "display", 7 }, /* TEXICMD_DISPLAY */
         { doignbracket, "dmn", 3 }, /* TEXICMD_DMN */          { 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 */          { dosymbol, "dots", 4 }, /* TEXICMD_DOTS */
         { dolink, "email", 5 }, /* TEXICMD_EMAIL */          { dolink, "email", 5 }, /* TEXICMD_EMAIL */
         { doinline, "emph", 4 }, /* TEXICMD_EMPH */          { 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 */          { doenumerate, "enumerate", 9 }, /* TEXICMD_ENUMERATE */
         { doinline, "env", 3 }, /* TEXICMD_ENV */          { doinline, "env", 3 }, /* TEXICMD_ENV */
         { dosymbol, "equiv", 5 }, /* TEXICMD_EQUIV */          { dosymbol, "equiv", 5 }, /* TEXICMD_EQUIV */
         { dosymbol, "error", 5 }, /* TEXICMD_ERROR */          { dosymbol, "error", 5 }, /* TEXICMD_ERROR */
           { dosymbol, "euro", 4 }, /* TEXICMD_EURO */
         { doexample, "example", 7 }, /* TEXICMD_EXAMPLE */          { doexample, "example", 7 }, /* TEXICMD_EXAMPLE */
           { dosymbol, "exclamdown", 10 }, /* TEXICMD_EXCLAMDOWN */
         { doignline, "exdent", 6 }, /* TEXICMD_EXDENT */          { doignline, "exdent", 6 }, /* TEXICMD_EXDENT */
         { dosymbol, "expansion", 9 }, /* TEXICMD_EXPANSION */          { dosymbol, "expansion", 9 }, /* TEXICMD_EXPANSION */
         { doinline, "file", 4 }, /* TEXICMD_FILE */          { doinline, "file", 4 }, /* TEXICMD_FILE */
         { doignline, "finalout", 8 }, /* TEXICMD_FINALOUT */          { doignline, "finalout", 8 }, /* TEXICMD_FINALOUT */
         { doignline, "findex", 6 }, /* TEXICMD_FINDEX */          { 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 */          { doignbracket, "footnote", 8 }, /* TEXICMD_FOOTNOTE */
           { doignline, "footnotestyle", 13 }, /* TEXICMD_FOOTNOTESTYLE */
         { dotable, "ftable", 6 }, /* TEXICMD_FTABLE */          { dotable, "ftable", 6 }, /* TEXICMD_FTABLE */
         { dodisplay, "format", 6 }, /* TEXICMD_FORMAT */          { dodisplay, "format", 6 }, /* TEXICMD_FORMAT */
           { dosymbol, "geq", 3 }, /* TEXICMD_GEQ */
         { doaccent, "`", 1 }, /* TEXICMD_GRAVE */          { doaccent, "`", 1 }, /* TEXICMD_GRAVE */
         { doblock, "group", 5 }, /* TEXICMD_GROUP */          { 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 */          { dosection, "heading", 7 }, /* TEXICMD_HEADING */
         { doignline, "headings", 8 }, /* TEXICMD_HEADINGS */          { doignline, "headings", 8 }, /* TEXICMD_HEADINGS */
         { doitem, "headitem", 8 }, /* TEXICMD_HEADITEM */          { doitem, "headitem", 8 }, /* TEXICMD_HEADITEM */
Line 180  static const struct texitok __texitoks[TEXICMD__MAX] =
Line 211  static const struct texitok __texitoks[TEXICMD__MAX] =
         { 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, "", 0 }, /* TEXICMD_USER_INDEX */          { dolink, "indicateurl", 11 }, /* TEXICMD_INDICATEURL */
           { dolink, "inforef", 7 }, /* TEXICMD_INFOREF */
         { 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 */
Line 188  static const struct texitok __texitoks[TEXICMD__MAX] =
Line 220  static const struct texitok __texitoks[TEXICMD__MAX] =
         { doinline, "kbd", 3 }, /* TEXICMD_KBD */          { doinline, "kbd", 3 }, /* TEXICMD_KBD */
         { dobracket, "key", 3 }, /* TEXICMD_KEY */          { dobracket, "key", 3 }, /* TEXICMD_KEY */
         { doignline, "kindex", 6 }, /* TEXICMD_KINDEX */          { doignline, "kindex", 6 }, /* TEXICMD_KINDEX */
           { dosymbol, "L", 1 }, /* TEXICMD_L */
         { dosymbol, "LaTeX", 5 }, /* TEXICMD_LATEX */          { dosymbol, "LaTeX", 5 }, /* TEXICMD_LATEX */
           { dosymbol, "leq", 3 }, /* TEXICMD_LEQ */
         { dosecoffs, "lowersections", 13 }, /* TEXICMD_LOWERSECTIONS */          { dosecoffs, "lowersections", 13 }, /* TEXICMD_LOWERSECTIONS */
           { dosymbol, "l", 1 }, /* TEXICMD_LSMALL */
         { domacro, "macro", 5 }, /* TEXICMD_MACRO */          { domacro, "macro", 5 }, /* TEXICMD_MACRO */
           { doaccent, "=", 1 }, /* TEXICMD_MACRON */
         { domath, "math", 4 }, /* TEXICMD_MATH */          { domath, "math", 4 }, /* TEXICMD_MATH */
         { doignblock, "menu", 4 }, /* TEXICMD_MENU */          { doignblock, "menu", 4 }, /* TEXICMD_MENU */
         { dosymbol, "minus", 5 }, /* TEXICMD_MINUS */          { dosymbol, "minus", 5 }, /* TEXICMD_MINUS */
Line 199  static const struct texitok __texitoks[TEXICMD__MAX] =
Line 235  static const struct texitok __texitoks[TEXICMD__MAX] =
         { 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 */
           { 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 */          { 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, "page", 4 }, /* TEXICMD_PAGE */
         { doignline, "paragraphindent", 15 }, /* TEXICMD_PARINDENT */          { doignline, "paragraphindent", 15 }, /* TEXICMD_PARINDENT */
         { dosymbol, ".", 1 }, /* TEXICMD_PERIOD */          { dosymbol, ".", 1 }, /* TEXICMD_PERIOD */
         { doignline, "pindex", 6 }, /* TEXICMD_PINDEX */          { doignline, "pindex", 6 }, /* TEXICMD_PINDEX */
           { dosymbol, "pounds", 6 }, /* TEXICMD_POUNDS */
         { doignline, "printindex", 10 }, /* TEXICMD_PRINTINDEX */          { 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 */          { doinline, "r", 1 }, /* TEXICMD_R */
         { dosecoffs, "raisesections", 13 }, /* TEXICMD_RAISESECTIONS */          { dosecoffs, "raisesections", 13 }, /* TEXICMD_RAISESECTIONS */
         { dobracket, "ref", 3 }, /* TEXICMD_REF */          { dobracket, "ref", 3 }, /* TEXICMD_REF */
         { doignline, "refill", 6 }, /* TEXICMD_REFILL */          { doignline, "refill", 6 }, /* TEXICMD_REFILL */
           { dosymbol, "registeredsymbol", 16 }, /* TEXICMD_REGISTEREDSYMBOL */
         { dosymbol, "result", 6 }, /* TEXICMD_RESULT */          { dosymbol, "result", 6 }, /* TEXICMD_RESULT */
           { doaccent, "ringaccent", 10 }, /* TEXICMD_RINGACCENT */
         { doinline, "samp", 4 }, /* TEXICMD_SAMP */          { doinline, "samp", 4 }, /* TEXICMD_SAMP */
         { doinline, "sansserif", 9 }, /* TEXICMD_SANSSERIF */          { doinline, "sansserif", 9 }, /* TEXICMD_SANSSERIF */
         { dobracket, "sc", 2 }, /* TEXICMD_SC */          { dobracket, "sc", 2 }, /* TEXICMD_SC */
         { dosection, "section", 7 }, /* TEXICMD_SECTION */          { dosection, "section", 7 }, /* TEXICMD_SECTION */
         { dovalue, "set", 3 }, /* TEXICMD_SET */          { dovalue, "set", 3 }, /* TEXICMD_SET */
         { doignline, "setchapternewpage", 17 }, /* TEXICMD_SETCHAPNEWPAGE */          { doignline, "setchapternewpage", 17 }, /* TEXICMD_SETCHAPNEWPAGE */
           { doignline, "setcontentsaftertitlepage", 25 }, /* TEXICMD_SETCONTENTSAFTER */
         { doignline, "setfilename", 11 }, /* TEXICMD_SETFILENAME */          { doignline, "setfilename", 11 }, /* TEXICMD_SETFILENAME */
         { dotitle, "settitle", 8 }, /* TEXICMD_SETTITLE */          { dotitle, "settitle", 8 }, /* TEXICMD_SETTITLE */
         { doignline, "shortcontents", 13 }, /* TEXICMD_SHORTCONTENTS */          { doignline, "shortcontents", 13 }, /* TEXICMD_SHORTCONTENTS */
         { doinline, "slanted", 7 }, /* TEXICMD_SLANTED */          { doinline, "slanted", 7 }, /* TEXICMD_SLANTED */
           { dosymbol, "/", 1 }, /* TEXICMD_SLASH */
         { dosp, "sp", 2 }, /* TEXICMD_SP */          { dosp, "sp", 2 }, /* TEXICMD_SP */
         { dosymbol, " ", 1 }, /* TEXICMD_SPACE */          { dosymbol, " ", 1 }, /* TEXICMD_SPACE */
         { doignline, "smallbook", 9 }, /* TEXICMD_SMALLBOOK */          { doignline, "smallbook", 9 }, /* TEXICMD_SMALLBOOK */
Line 232  static const struct texitok __texitoks[TEXICMD__MAX] =
Line 287  static const struct texitok __texitoks[TEXICMD__MAX] =
         { 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 */
           { dosymbol, "ss", 2 }, /* TEXICMD_SS */
         { doinline, "strong", 6 }, /* TEXICMD_STRONG */          { doinline, "strong", 6 }, /* TEXICMD_STRONG */
         { dosubsection, "subheading", 10 }, /* TEXICMD_SUBHEADING */          { dosubsection, "subheading", 10 }, /* TEXICMD_SUBHEADING */
         { dosubsection, "subsection", 10 }, /* TEXICMD_SUBSECTION */          { dosubsection, "subsection", 10 }, /* TEXICMD_SUBSECTION */
Line 247  static const struct texitok __texitoks[TEXICMD__MAX] =
Line 303  static const struct texitok __texitoks[TEXICMD__MAX] =
         { 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 */
           { 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 */          { doaccent, "~", 1 }, /* TEXICMD_TILDE */
         { doignline, "tindex", 6 }, /* TEXICMD_TINDEX */          { doignline, "tindex", 6 }, /* TEXICMD_TINDEX */
         { 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, "u", 1 }, /* TEXICMD_U */
           { doaccent, "ubaraccent", 10 }, /* TEXICMD_UBARACCENT */
           { doaccent, "udotaccent", 10 }, /* TEXICMD_UDOTACCENT */
         { doaccent, "\"", 1 }, /* TEXICMD_UMLAUT */          { doaccent, "\"", 1 }, /* TEXICMD_UMLAUT */
         { dosection, "unnumbered", 10 }, /* TEXICMD_UNNUMBERED */          { dosection, "unnumbered", 10 }, /* TEXICMD_UNNUMBERED */
         { dosection, "unnumberedsec", 13 }, /* TEXICMD_UNNUMBEREDSEC */          { dosection, "unnumberedsec", 13 }, /* TEXICMD_UNNUMBEREDSEC */
Line 260  static const struct texitok __texitoks[TEXICMD__MAX] =
Line 324  static const struct texitok __texitoks[TEXICMD__MAX] =
         { dosubsubsection, "unnumberedsubsubsec", 19 }, /* TEXICMD_UNNUMBEREDSUBSUBSEC */          { dosubsubsection, "unnumberedsubsubsec", 19 }, /* TEXICMD_UNNUMBEREDSUBSUBSEC */
         { dolink, "uref", 4 }, /* TEXICMD_UREF */          { dolink, "uref", 4 }, /* TEXICMD_UREF */
         { dolink, "url", 3 }, /* TEXICMD_URL */          { dolink, "url", 3 }, /* TEXICMD_URL */
           { doignline, "", 0 }, /* TEXICMD_USER_INDEX */
           { doaccent, "v", 1 }, /* TEXICMD_V */
         { dovalue, "value", 5 }, /* TEXICMD_VALUE */          { dovalue, "value", 5 }, /* TEXICMD_VALUE */
         { doinline, "var", 3 }, /* TEXICMD_VAR */          { 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 */          { doverbinclude, "verbatiminclude", 15 }, /* TEXICMD_VERBATIMINCLUDE */
         { doignline, "vindex", 6 }, /* TEXICMD_VINDEX */          { doignline, "vindex", 6 }, /* TEXICMD_VINDEX */
         { dosp, "vskip", 5 }, /* TEXICMD_VSKIP */          { dosp, "vskip", 5 }, /* TEXICMD_VSKIP */
Line 314  dodefn(struct texi *p, enum texicmd cmd, 
Line 381  dodefn(struct texi *p, enum texicmd cmd, 
         blk = NULL;          blk = NULL;
         switch (cmd) {          switch (cmd) {
         case (TEXICMD_DEFFN):          case (TEXICMD_DEFFN):
           case (TEXICMD_DEFMAC):
         case (TEXICMD_DEFTP):          case (TEXICMD_DEFTP):
         case (TEXICMD_DEFTYPEFN):          case (TEXICMD_DEFTYPEFN):
         case (TEXICMD_DEFTYPEFUN):          case (TEXICMD_DEFTYPEFUN):
           case (TEXICMD_DEFTYPEMETHOD):
         case (TEXICMD_DEFTYPEVAR):          case (TEXICMD_DEFTYPEVAR):
         case (TEXICMD_DEFTYPEVR):          case (TEXICMD_DEFTYPEVR):
         case (TEXICMD_DEFUN):          case (TEXICMD_DEFUN):
Line 339  dodefn(struct texi *p, enum texicmd cmd, 
Line 408  dodefn(struct texi *p, enum texicmd cmd, 
                 texivspace(p);                  texivspace(p);
   
         switch (cmd) {          switch (cmd) {
           case (TEXICMD_DEFTYPEMETHOD):
           case (TEXICMD_DEFTYPEMETHODX):
                   texiputchars(p, "Method");
                   break;
         case (TEXICMD_DEFMAC):          case (TEXICMD_DEFMAC):
         case (TEXICMD_DEFMACX):          case (TEXICMD_DEFMACX):
                 texiputchars(p, "Macro");                  texiputchars(p, "Macro");
Line 387  dodefn(struct texi *p, enum texicmd cmd, 
Line 460  dodefn(struct texi *p, enum texicmd cmd, 
         case (TEXICMD_DEFTYPEFUNX):          case (TEXICMD_DEFTYPEFUNX):
         case (TEXICMD_DEFTYPEFN):          case (TEXICMD_DEFTYPEFN):
         case (TEXICMD_DEFTYPEFNX):          case (TEXICMD_DEFTYPEFNX):
           case (TEXICMD_DEFTYPEMETHOD):
           case (TEXICMD_DEFTYPEMETHODX):
                 teximacroopen(p, "Ft");                  teximacroopen(p, "Ft");
                 parselinearg(p, buf, sz, pos);                  parselinearg(p, buf, sz, pos);
                 teximacroclose(p);                  teximacroclose(p);
Line 462  domacro(struct texi *p, enum texicmd cmd, 
Line 537  domacro(struct texi *p, enum texicmd cmd, 
         start = *pos;          start = *pos;
         endtok = "\n@end macro\n";          endtok = "\n@end macro\n";
         endtoksz = strlen(endtok);          endtoksz = strlen(endtok);
         blk = memmem(&buf[start], sz, endtok, endtoksz);          blk = memmem(&buf[start], sz - start, endtok, endtoksz);
         if (NULL == blk)          if (NULL == blk)
                 texierr(p, "unterminated macro body");                  texierr(p, "unterminated macro body");
         while (&buf[*pos] != blk)          while (&buf[*pos] != blk)
Line 491  static void
Line 566  static void
 doignblock(struct texi *p, enum texicmd cmd,  doignblock(struct texi *p, enum texicmd cmd,
         const char *buf, size_t sz, size_t *pos)          const char *buf, size_t sz, size_t *pos)
 {  {
         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
            *      @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 < sz) {
         endpos = NULL == term ? sz :                  if (stack > 10)
                 *pos + term - &buf[*pos];                          abort();
         assert(endpos <= sz);                  endt = memmem(&buf[*pos], sz - *pos, end, esz);
         while (*pos < endpos)                  startt = memmem(&buf[*pos], sz - *pos, start, ssz);
                 advance(p, buf, pos);                  if (NULL == endt) {
                           texiwarn(p, "unterminated \"%s\" "
                                   "block", texitoks[cmd].tok);
                           *pos = sz;
                           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[*pos]);
                           stack--;
                   } else {
                           newpos += ssz + (size_t)(startt - &buf[*pos]);
                           stack++;
                   }
   
                   assert(newpos <= sz);
                   while (*pos < newpos)
                           advance(p, buf, pos);
           }
 }  }
   
 static void  static void
Line 588  static void
Line 693  static void
 doverb(struct texi *p, enum texicmd cmd,  doverb(struct texi *p, enum texicmd cmd,
         const char *buf, size_t sz, size_t *pos)          const char *buf, size_t sz, size_t *pos)
 {  {
           char     delim;
           size_t   start;
   
           while (*pos < sz && isws(buf[*pos]))
                   advance(p, buf, pos);
           if (*pos == sz || '{' != buf[*pos])
                   return;
           advance(p, buf, pos);
           if (*pos == sz)
                   return;
   
           delim = buf[*pos];
           advance(p, buf, 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 < sz - 1) {
                   if (buf[*pos] == delim && buf[*pos + 1] == '}')
                           break;
                   advance(p, buf, pos);
           }
           if (*pos == sz - 1)
                   return;
           texiputbuf(p, buf, start, *pos);
   
           /* Make sure we read after the end-brace. */
           assert(delim == buf[*pos]);
           advance(p, buf, pos);
           assert('}' == buf[*pos]);
           advance(p, buf, pos);
   }
   
   static void
   doverbatim(struct texi *p, enum texicmd cmd,
           const char *buf, size_t sz, size_t *pos)
   {
         const char      *end, *term;          const char      *end, *term;
         size_t           endsz, endpos;          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";          end = "\n@end verbatim\n";
         endsz = strlen(end);          endsz = strlen(end);
           advanceeoln(p, buf, sz, pos, 0);
           if (*pos == sz) {
                   texiwarn(p, "unexpected end of file");
                   return;
           }
   
         /*          term = memmem(&buf[*pos], sz - *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 = sz;
          */          } else
         term = memmem(&buf[*pos], sz, end, endsz);                  endpos = *pos + (size_t)(term - &buf[*pos]);
         endpos = NULL == term ? sz :  
                 *pos + term - &buf[*pos];  
   
         teximacro(p, "Bd -literal -offset indent");  
         assert(endpos <= sz);          assert(endpos <= sz);
           assert('\n' == buf[*pos]);
           advance(p, buf, pos);
           teximacro(p, "Bd -literal -offset indent");
         while (*pos < endpos) {          while (*pos < endpos) {
                 if (buf[*pos] == '\n')                  texiputchar(p, buf[*pos]);
                         p->outcol = 0;  
                 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);                  advance(p, buf, pos);
         }          }
         teximacro(p, "Ed");          teximacro(p, "Ed");
         advanceto(p, buf, pos, endpos + endsz);          if (*pos < sz)
                   advanceto(p, buf, pos, endpos + endsz);
 }  }
   
 static void  static void
Line 826  static void
Line 965  static void
 doaccent(struct texi *p, enum texicmd cmd,  doaccent(struct texi *p, enum texicmd cmd,
         const char *buf, size_t sz, size_t *pos)          const char *buf, size_t sz, size_t *pos)
 {  {
           int      brace = 0;
   
         if (*pos == sz)          if (*pos == sz) {
                   texiwarn(p, "truncated: @%s", texitoks[cmd].tok);
                 return;                  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[*pos]) {
                   brace = 1;
                   advance(p, buf, pos);
           } else if (isalpha(texitoks[cmd].tok[0]))
                   while (*pos < sz && isws(buf[*pos]))
                           advance(p, buf, pos);
   
           if (*pos == sz) {
                   texiwarn(p, "truncated: @%s", texitoks[cmd].tok);
                   return;
           }
   
         switch (cmd) {          switch (cmd) {
         case (TEXICMD_ACUTE):          case (TEXICMD_ACUTE):
                 switch (buf[*pos]) {                  switch (buf[*pos]) {
Line 839  doaccent(struct texi *p, enum texicmd cmd, 
Line 1006  doaccent(struct texi *p, enum texicmd cmd, 
                 case ('o'): case ('O'):                  case ('o'): case ('O'):
                 case ('u'): case ('U'):                  case ('u'): case ('U'):
                         texiputchars(p, "\\(\'");                          texiputchars(p, "\\(\'");
                         texiputchar(p, buf[*pos]);  
                         break;                          break;
                 default:                  default:
                         texiputchar(p, buf[*pos]);                          texiwarn(p, "ignoring accent");
                           break;
                 }                  }
                   texiputchar(p, buf[*pos]);
                   advance(p, buf, pos);
                 break;                  break;
           case (TEXICMD_CEDILLA):
                   if ('c' == buf[*pos] || 'C' == buf[*pos])
                           texiputchars(p, "\\(,");
                   else
                           texiwarn(p, "ignoring accent");
                   texiputchar(p, buf[*pos]);
                   advance(p, buf, pos);
                   break;
         case (TEXICMD_CIRCUMFLEX):          case (TEXICMD_CIRCUMFLEX):
                 switch (buf[*pos]) {                  switch (buf[*pos]) {
                 case ('a'): case ('A'):                  case ('a'): case ('A'):
Line 853  doaccent(struct texi *p, enum texicmd cmd, 
Line 1030  doaccent(struct texi *p, enum texicmd cmd, 
                 case ('o'): case ('O'):                  case ('o'): case ('O'):
                 case ('u'): case ('U'):                  case ('u'): case ('U'):
                         texiputchars(p, "\\(^");                          texiputchars(p, "\\(^");
                         texiputchar(p, buf[*pos]);  
                         break;                          break;
                 default:                  default:
                         texiputchar(p, buf[*pos]);                          texiwarn(p, "ignoring accent");
                           break;
                 }                  }
                   texiputchar(p, buf[*pos]);
                   advance(p, buf, pos);
                 break;                  break;
           case (TEXICMD_DOTLESS):
                   if ('i' == buf[*pos] || 'j' == buf[*pos])
                           texiputchars(p, "\\(.");
                   else
                           texiwarn(p, "ignoring accent");
                   texiputchar(p, buf[*pos]);
                   advance(p, buf, pos);
                   break;
         case (TEXICMD_GRAVE):          case (TEXICMD_GRAVE):
                 switch (buf[*pos]) {                  switch (buf[*pos]) {
                 case ('a'): case ('A'):                  case ('a'): case ('A'):
Line 867  doaccent(struct texi *p, enum texicmd cmd, 
Line 1054  doaccent(struct texi *p, enum texicmd cmd, 
                 case ('o'): case ('O'):                  case ('o'): case ('O'):
                 case ('u'): case ('U'):                  case ('u'): case ('U'):
                         texiputchars(p, "\\(`");                          texiputchars(p, "\\(`");
                         texiputchar(p, buf[*pos]);  
                         break;                          break;
                 default:                  default:
                         texiputchar(p, buf[*pos]);                          texiwarn(p, "ignoring accent");
                           break;
                 }                  }
                   texiputchar(p, buf[*pos]);
                   advance(p, buf, pos);
                 break;                  break;
         case (TEXICMD_TILDE):          case (TEXICMD_TILDE):
                 switch (buf[*pos]) {                  switch (buf[*pos]) {
Line 879  doaccent(struct texi *p, enum texicmd cmd, 
Line 1068  doaccent(struct texi *p, enum texicmd cmd, 
                 case ('n'): case ('N'):                  case ('n'): case ('N'):
                 case ('o'): case ('O'):                  case ('o'): case ('O'):
                         texiputchars(p, "\\(~");                          texiputchars(p, "\\(~");
                         texiputchar(p, buf[*pos]);  
                         break;                          break;
                 default:                  default:
                         texiputchar(p, buf[*pos]);                          texiwarn(p, "ignoring accent");
                           break;
                 }                  }
                   texiputchar(p, buf[*pos]);
                   advance(p, buf, pos);
                 break;                  break;
         case (TEXICMD_UMLAUT):          case (TEXICMD_UMLAUT):
                 switch (buf[*pos]) {                  switch (buf[*pos]) {
Line 894  doaccent(struct texi *p, enum texicmd cmd, 
Line 1085  doaccent(struct texi *p, enum texicmd cmd, 
                 case ('u'): case ('U'):                  case ('u'): case ('U'):
                 case ('y'):                  case ('y'):
                         texiputchars(p, "\\(:");                          texiputchars(p, "\\(:");
                         texiputchar(p, buf[*pos]);  
                         break;                          break;
                 default:                  default:
                           texiwarn(p, "ignoring accent");
                           break;
                   }
                   texiputchar(p, buf[*pos]);
                   advance(p, buf, pos);
                   break;
           default:
                   texiputchar(p, buf[*pos]);
                   advance(p, buf, pos);
                   break;
           }
   
           if (brace) {
                   while (*pos < sz && '}' != buf[*pos]) {
                         texiputchar(p, buf[*pos]);                          texiputchar(p, buf[*pos]);
                           advance(p, buf, pos);
                 }                  }
                   if (*pos < sz)
                           advance(p, buf, pos);
           }
   
           switch (cmd) {
           case (TEXICMD_TIEACCENT):
                   texiputchar(p, ']');
                 break;                  break;
           case (TEXICMD_DOTACCENT):
                   texiputchar(p, '*');
                   break;
         default:          default:
                 abort();                  break;
         }          }
 }  }
   
Line 910  dosymbol(struct texi *p, enum texicmd cmd, 
Line 1125  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)
 {  {
   
         if (p->seenws && p->outcol && 0 == p->literal) {          /* Remember to pad us. */
           if (p->seenws && p->outcol && 0 == p->literal)
                 texiputchar(p, ' ');                  texiputchar(p, ' ');
                 p->seenws = 0;  
         }  
   
           p->seenws = 0;
   
         switch (cmd) {          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_ASTERISK):
         case (TEXICMD_NEWLINE):          case (TEXICMD_NEWLINE):
         case (TEXICMD_SPACE):          case (TEXICMD_SPACE):
Line 931  dosymbol(struct texi *p, enum texicmd cmd, 
Line 1159  dosymbol(struct texi *p, enum texicmd cmd, 
         case (TEXICMD_BULLET):          case (TEXICMD_BULLET):
                 texiputchars(p, "\\(bu");                  texiputchars(p, "\\(bu");
                 break;                  break;
           case (TEXICMD_COMMA):
                   texiputchar(p, ',');
                   break;
         case (TEXICMD_COPYRIGHT):          case (TEXICMD_COPYRIGHT):
                 texiputchars(p, "\\(co");                  texiputchars(p, "\\(co");
                 break;                  break;
           case (TEXICMD_DH):
                   texiputchars(p, "\\(-D");
                   break;
           case (TEXICMD_DHSMALL):
                   texiputchars(p, "\\(Sd");
                   break;
         case (TEXICMD_DOTS):          case (TEXICMD_DOTS):
           case (TEXICMD_ENDDOTS):
                 texiputchars(p, "...");                  texiputchars(p, "...");
                 break;                  break;
         case (TEXICMD_EQUIV):          case (TEXICMD_EQUIV):
Line 943  dosymbol(struct texi *p, enum texicmd cmd, 
Line 1181  dosymbol(struct texi *p, enum texicmd cmd, 
         case (TEXICMD_ERROR):          case (TEXICMD_ERROR):
                 texiputchars(p, "error\\(->");                  texiputchars(p, "error\\(->");
                 break;                  break;
           case (TEXICMD_EURO):
                   texiputchars(p, "\\(Eu");
                   break;
           case (TEXICMD_EXCLAMDOWN):
                   texiputchars(p, "\\(r!");
                   break;
         case (TEXICMD_EXPANSION):          case (TEXICMD_EXPANSION):
                 texiputchars(p, "\\(->");                  texiputchars(p, "\\(->");
                 break;                  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):          case (TEXICMD_LATEX):
                 texiputchars(p, "LaTeX");                  texiputchars(p, "LaTeX");
                 break;                  break;
           case (TEXICMD_LEQ):
                   texiputchars(p, "\\(<=");
                   break;
           case (TEXICMD_LSMALL):
                   texiputchars(p, "\\(/l");
                   break;
         case (TEXICMD_MINUS):          case (TEXICMD_MINUS):
                 texiputchars(p, "\\-");                  texiputchars(p, "\\-");
                 break;                  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):          case (TEXICMD_PERIOD):
                 texiputchar(p, '.');                  texiputchar(p, '.');
                 break;                  break;
           case (TEXICMD_POUNDS):
                   texiputchars(p, "\\(Po");
                   break;
           case (TEXICMD_QUESTIONDOWN):
                   texiputchars(p, "\\(r?");
                   break;
         case (TEXICMD_QUESTIONMARK):          case (TEXICMD_QUESTIONMARK):
                 texiputchar(p, '?');                  texiputchar(p, '?');
                 break;                  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):          case (TEXICMD_RESULT):
                 texiputchars(p, "\\(rA");                  texiputchars(p, "\\(rA");
                 break;                  break;
           case (TEXICMD_SLASH):
                   texiputchar(p, '/');
                   break;
           case (TEXICMD_SS):
                   texiputchars(p, "\\(ss");
                   break;
         case (TEXICMD_SQUIGGLE_LEFT):          case (TEXICMD_SQUIGGLE_LEFT):
                 texiputchars(p, "{");                  texiputchars(p, "{");
                 break;                  break;
Line 970  dosymbol(struct texi *p, enum texicmd cmd, 
Line 1291  dosymbol(struct texi *p, enum texicmd cmd, 
         case (TEXICMD_TEXSYM):          case (TEXICMD_TEXSYM):
                 texiputchars(p, "TeX");                  texiputchars(p, "TeX");
                 break;                  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_COLON):
         case (TEXICMD_HYPHEN):          case (TEXICMD_HYPHEN):
                 break;                  break;
Line 977  dosymbol(struct texi *p, enum texicmd cmd, 
Line 1310  dosymbol(struct texi *p, enum texicmd cmd, 
                 abort();                  abort();
         }          }
   
         if (texitoks[cmd].len > 1)          /* Alphabetic commands have braces we ignore. */
           if (isalpha(texitoks[cmd].tok[0]))
                 doignbracket(p, cmd, buf, sz, pos);                  doignbracket(p, cmd, buf, sz, pos);
 }  }
   
Line 995  static void
Line 1329  static void
 domath(struct texi *p, enum texicmd cmd,  domath(struct texi *p, enum texicmd cmd,
         const char *buf, size_t sz, size_t *pos)          const char *buf, size_t sz, size_t *pos)
 {  {
         size_t   nest;          size_t   nest, start;
   
         /*          /*
          * Math handling is different from everything else.           * Math handling is different from everything else.
Line 1011  domath(struct texi *p, enum texicmd cmd, 
Line 1345  domath(struct texi *p, enum texicmd cmd, 
         if (p->seenws && p->outcol && 0 == p->literal)          if (p->seenws && p->outcol && 0 == p->literal)
                 texiputchar(p, ' ');                  texiputchar(p, ' ');
         p->seenws = 0;          p->seenws = 0;
         for (nest = 1; *pos < sz && nest > 0; ) {          for (nest = 1, start = *pos; *pos < sz && nest > 0; ) {
                 if ('{' == buf[*pos])                  if ('{' == buf[*pos])
                         nest++;                          nest++;
                 else if ('}' == buf[*pos])                  else if ('}' == buf[*pos])
                         if (0 == --nest)                          if (0 == --nest)
                                 continue;                                  continue;
                 texiputchar(p, buf[*pos]);  
                 advance(p, buf, pos);                  advance(p, buf, pos);
         }          }
         if (*pos == sz)          if (*pos == sz)
                 return;                  return;
         assert('}' == buf[*pos]);          assert('}' == buf[*pos]);
           texiputbuf(p, buf, start, *pos);
         advance(p, buf, pos);          advance(p, buf, pos);
 }  }
   
Line 1108  dolink(struct texi *p, enum texicmd cmd, 
Line 1442  dolink(struct texi *p, enum texicmd cmd, 
                 break;                  break;
         case (TEXICMD_UREF):          case (TEXICMD_UREF):
         case (TEXICMD_URL):          case (TEXICMD_URL):
           case (TEXICMD_INDICATEURL):
                 teximacroopen(p, "Lk");                  teximacroopen(p, "Lk");
                 break;                  break;
         case (TEXICMD_XREF):          case (TEXICMD_XREF):
                 texiputchars(p, "See Section");                  texiputchars(p, "See Section");
                 teximacroopen(p, "Qq");                  teximacroopen(p, "Dq");
                 break;                  break;
         case (TEXICMD_PXREF):          case (TEXICMD_PXREF):
                 texiputchars(p, "see Section");                  texiputchars(p, "see Section");
                 teximacroopen(p, "Qq");                  teximacroopen(p, "Dq");
                 break;                  break;
           case (TEXICMD_INFOREF):
                   texiputchars(p, "See Info file node");
                   teximacroopen(p, "Dq");
                   break;
         default:          default:
                 abort();                  abort();
         }          }
Line 1195  dosubsection(struct texi *p, enum texicmd cmd, 
Line 1534  dosubsection(struct texi *p, enum texicmd cmd, 
                 texierr(p, "\"%s\" in a literal scope!?", sects[sec]);                  texierr(p, "\"%s\" in a literal scope!?", sects[sec]);
   
         /* We don't have a subsubsection, so make one up. */          /* We don't have a subsubsection, so make one up. */
         texivspace(p);          if (sec > 1)
                   texivspace(p);
         teximacroopen(p, sects[sec]);          teximacroopen(p, sects[sec]);
         parseeoln(p, buf, sz, pos);          parseeoln(p, buf, sz, pos);
         teximacroclose(p);          teximacroclose(p);
         texivspace(p);          if (sec > 1)
                   texivspace(p);
 }  }
   
 static void  static void
Line 1252  dosp(struct texi *p, enum texicmd cmd, 
Line 1593  dosp(struct texi *p, enum texicmd cmd, 
         const char *buf, size_t sz, size_t *pos)          const char *buf, size_t sz, size_t *pos)
 {  {
   
         texivspace(p);          if (p->literal)
                   texiputchar(p, '\n');
           else
                   texivspace(p);
         /* FIXME: ignore and parseeoln. */          /* FIXME: ignore and parseeoln. */
         advanceeoln(p, buf, sz, pos, 1);          advanceeoln(p, buf, sz, pos, 1);
 }  }
Line 1289  dotop(struct texi *p, enum texicmd cmd, 
Line 1633  dotop(struct texi *p, enum texicmd cmd, 
         teximacro(p, "Os");          teximacro(p, "Os");
         teximacro(p, "Sh NAME");          teximacro(p, "Sh NAME");
         teximacroopen(p, "Nm");          teximacroopen(p, "Nm");
         texiputchars(p, p->title);          for (cp = p->title; '\0' != *cp; cp++)
                   texiputchar(p, *cp);
         teximacroclose(p);          teximacroclose(p);
         teximacroopen(p, "Nd");          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);          teximacroclose(p);
         p->seenvs = 1;          p->seenvs = 1;
         dosection(p, cmd, buf, sz, pos);          dosection(p, cmd, buf, sz, pos);
Line 1435  dotable(struct texi *p, enum texicmd cmd, 
Line 1783  dotable(struct texi *p, enum texicmd cmd, 
 }  }
   
 static void  static void
   doend(struct texi *p, enum texicmd cmd,
           const char *buf, size_t sz, size_t *pos)
   {
           size_t   start;
   
           while (*pos < sz && isws(buf[*pos]))
                   advance(p, buf, pos);
           start = *pos;
           while (*pos < sz && '\n' != buf[*pos])
                   advance(p, buf, pos);
   
           texiwarn(p, "unexpected \"end\": %.*s", (int)(*pos - start), &buf[start]);
           advanceeoln(p, buf, sz, pos, 1);
   }
   
   static void
 doenumerate(struct texi *p, enum texicmd cmd,  doenumerate(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 1488  doignline(struct texi *p, enum texicmd cmd, 
Line 1852  doignline(struct texi *p, enum texicmd cmd, 
 /*  /*
  * Parse colon-separated directories from "cp" (if not NULL) and returns   * Parse colon-separated directories from "cp" (if not NULL) and returns
  * the array of pointers.   * the array of pointers.
  * Prepends "base" to the array.   * Prepends "base" to the array, if found.
  * This does NOT sanitise the directories!   * This does NOT sanitise the directories!
  */   */
 static char **  static char **
Line 1496  parsedirs(struct texi *p, const char *base, const char
Line 1860  parsedirs(struct texi *p, const char *base, const char
 {  {
         char             *tok, *str, *tofree;          char             *tok, *str, *tofree;
         const char       *cpp;          const char       *cpp;
         size_t            i;          size_t            i = 0;
         char            **dirs;          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++;                          cpp++;
   
           if (0 == *sz)
                   return(NULL);
         if (NULL == (dirs = calloc(*sz, sizeof(char *))))          if (NULL == (dirs = calloc(*sz, sizeof(char *))))
                 texiabort(p, NULL);                  texiabort(p, NULL);
         else if (NULL == (dirs[0] = strdup(base)))          if (NULL != base && NULL == (dirs[i++] = strdup(base)))
                 texiabort(p, NULL);                  texiabort(p, NULL);
   
         if (NULL == cp)          if (NULL == cp)
                 return(dirs);                  return(dirs);
   
         if (NULL == (tofree = tok = str = strdup(cp)))          if (NULL == (tofree = tok = str = strdup(cp)))
                 texiabort(p, NULL);                  texiabort(p, NULL);
   
         for (i = 1; NULL != (tok = strsep(&str, ":")); i++)          for ( ; NULL != (tok = strsep(&str, ":")); i++)
                 if (NULL == (dirs[i] = strdup(tok)))                  if (NULL == (dirs[i] = strdup(tok)))
                         texiabort(p, NULL);                          texiabort(p, NULL);
   
Line 1528  main(int argc, char *argv[])
Line 1893  main(int argc, char *argv[])
 {  {
         struct texi      texi;          struct texi      texi;
         int              c;          int              c;
         char            *path, *dir;          char            *dirpath, *dir, *ccp;
         const char      *progname, *Idir, *cp;          const char      *progname, *Idir, *cp;
   
         progname = strrchr(argv[0], '/');          progname = strrchr(argv[0], '/');
Line 1538  main(int argc, char *argv[])
Line 1903  main(int argc, char *argv[])
                 ++progname;                  ++progname;
   
         memset(&texi, 0, sizeof(struct texi));          memset(&texi, 0, sizeof(struct texi));
           texi.ign = 1;
         Idir = NULL;          Idir = NULL;
   
         while (-1 != (c = getopt(argc, argv, "I:")))          while (-1 != (c = getopt(argc, argv, "I:")))
Line 1550  main(int argc, char *argv[])
Line 1916  main(int argc, char *argv[])
                 }                  }
   
         argv += optind;          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);
                 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);          texiexit(&texi);
         return(EXIT_FAILURE);          return(EXIT_FAILURE);
 usage:  usage:
         fprintf(stderr, "usage: %s [-Idirs] file\n", progname);          fprintf(stderr, "usage: %s [-Idirs] [file]\n", progname);
         return(EXIT_FAILURE);          return(EXIT_FAILURE);
 }  }
Legend:
Removed from v.1.32  
changed lines
  Added in v.1.45
CVSweb