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

Diff for /texi2mdoc/main.c between version 1.39 and 1.72

version 1.39, 2015/02/23 20:54:53 version 1.72, 2018/11/13 08:45:29
Line 17 
Line 17 
 #if defined(__linux__) || defined(__MINT__)  #if defined(__linux__) || defined(__MINT__)
 # define _GNU_SOURCE /* memmem */  # define _GNU_SOURCE /* memmem */
 #endif  #endif
 #include <sys/mman.h>  
 #include <sys/stat.h>  #include <sys/stat.h>
   
 #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 35 
Line 34 
   
 #include "extern.h"  #include "extern.h"
   
   #define HAVE_INDEX 1
   
   /*
    * Texinfo can change the "meaning" of its section headings: chapter,
    * section, subsection, etc., can be promoted and/or demoted to other
    * levels of heading.
    * Thus, we use an offset and just jump into this array.
    */
 #define SECTSZ 4  #define SECTSZ 4
 static  const char *const sects[SECTSZ] = {  static  const char *const sects[SECTSZ] = {
         "Sh",          "Sh", /* Chapters (sections) */
         "Ss",          "Ss", /* Sections (subsections) */
         "Em",          "Em", /* Subsections (subsubsection) */
         "No",          "Sy", /* Subsubsections (...). */
 };  };
   
 static  void doaccent(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void doaccent(struct texi *, enum texicmd, size_t *);
 static  void doblock(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void doblock(struct texi *, enum texicmd, size_t *);
 static  void dobracket(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void dobracket(struct texi *, enum texicmd, size_t *);
 static  void dobye(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void dobye(struct texi *, enum texicmd, size_t *);
 static  void dodefindex(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void docopying(struct texi *, enum texicmd, size_t *);
 static  void dodefn(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void dodefindex(struct texi *, enum texicmd, size_t *);
 static  void dodisplay(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void dodefn(struct texi *, enum texicmd, size_t *);
 static  void doenumerate(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void dodisplay(struct texi *, enum texicmd, size_t *);
 static  void doexample(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void doend(struct texi *, enum texicmd, size_t *);
 static  void doignargn(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void doenumerate(struct texi *, enum texicmd, size_t *);
 static  void doignblock(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void doexample(struct texi *, enum texicmd, size_t *);
 static  void doignbracket(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void doignargn(struct texi *, enum texicmd, size_t *);
 static  void doignline(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void doignblock(struct texi *, enum texicmd, size_t *);
 static  void doinline(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void doignbracket(struct texi *, enum texicmd, size_t *);
 static  void doinclude(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void doignline(struct texi *, enum texicmd, size_t *);
 static  void doitem(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void doindex(struct texi *, enum texicmd, size_t *);
 static  void doitemize(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void doinline(struct texi *, enum texicmd, size_t *);
 static  void dolink(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void doinclude(struct texi *, enum texicmd, size_t *);
 static  void domacro(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void doinsertcopying(struct texi *, enum texicmd, size_t *);
 static  void domath(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void doitem(struct texi *, enum texicmd, size_t *);
 static  void domultitable(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void doitemize(struct texi *, enum texicmd, size_t *);
 static  void doquotation(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void dolink(struct texi *, enum texicmd, size_t *);
 static  void dotable(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void domacro(struct texi *, enum texicmd, size_t *);
 static  void dotop(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void domath(struct texi *, enum texicmd, size_t *);
 static  void dosecoffs(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void domenu(struct texi *, enum texicmd, size_t *);
 static  void dosection(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void domultitable(struct texi *, enum texicmd, size_t *);
 static  void dosp(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void donode(struct texi *, enum texicmd, size_t *);
 static  void dosubsection(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void doprintindex(struct texi *, enum texicmd, size_t *);
 static  void dosubsubsection(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void doquotation(struct texi *, enum texicmd, size_t *);
 static  void dosymbol(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void dotable(struct texi *, enum texicmd, size_t *);
 static  void dotab(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void dosecoffs(struct texi *, enum texicmd, size_t *);
 static  void dotitle(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void dosection(struct texi *, enum texicmd, size_t *);
 static  void dovalue(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void dosp(struct texi *, enum texicmd, size_t *);
 static  void doverb(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void dosymbol(struct texi *, enum texicmd, size_t *);
 static  void doverbatim(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void dotab(struct texi *, enum texicmd, size_t *);
 static  void doverbinclude(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void dotitle(struct texi *, enum texicmd, size_t *);
   static  void dovalue(struct texi *, enum texicmd, size_t *);
   static  void doverb(struct texi *, enum texicmd, size_t *);
   static  void doverbatim(struct texi *, enum texicmd, size_t *);
   static  void doverbinclude(struct texi *, enum texicmd, size_t *);
   
 static  const struct texitok __texitoks[TEXICMD__MAX] = {  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 */
         { dosubsection, "appendixsubsec", 14 }, /* TEXICMD_APPENDIXSUBSEC */          { dosection, "appendixsubsec", 14 }, /* TEXICMD_APPENDIXSUBSEC */
         { dosubsubsection, "appendixsubsubsec", 17 }, /* TEXICMD_APPENDIXSUBSUBSEC */          { dosection, "appendixsubsubsec", 17 }, /* TEXICMD_APPENDIXSUBSUBSEC */
         { doinline, "asis", 4 }, /* TEXICMD_ASIS */          { doinline, "asis", 4 }, /* TEXICMD_ASIS */
         { 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 */
         { doinline, "b", 1 }, /* TEXICMD_BOLD */          { doinline, "b", 1 }, /* TEXICMD_B */
           { dosymbol, "\\", 1 }, /* TEXICMD_BACKSLASH */
         { 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 */
Line 102  static const struct texitok __texitoks[TEXICMD__MAX] =
Line 118  static const struct texitok __texitoks[TEXICMD__MAX] =
         { doaccent, ",", 1 }, /* TEXICMD_CEDILLA */          { 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 */          { doindex, "cindex", 6 }, /* TEXICMD_CINDEX */
         { doaccent, "^", 1 }, /* TEXICMD_CIRCUMFLEX */          { doaccent, "^", 1 }, /* TEXICMD_CIRCUMFLEX */
         { doinline, "cite", 4 }, /* TEXICMD_CITE */          { doinline, "cite", 4 }, /* TEXICMD_CITE */
         { dovalue, "clear", 5 }, /* TEXICMD_CLEAR */          { dovalue, "clear", 5 }, /* TEXICMD_CLEAR */
Line 114  static const struct texitok __texitoks[TEXICMD__MAX] =
Line 130  static const struct texitok __texitoks[TEXICMD__MAX] =
         { 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 */          { docopying, "copying", 7 }, /* TEXICMD_COPYING */
         { dosymbol, "copyright", 9 }, /* TEXICMD_COPYRIGHT */          { dosymbol, "copyright", 9 }, /* TEXICMD_COPYRIGHT */
         { dodefindex, "defcodeindex", 12 }, /* TEXICMD_DEFCODEINDEX */          { dodefindex, "defcodeindex", 12 }, /* TEXICMD_DEFCODEINDEX */
         { dodefn, "deffn", 5 }, /* TEXICMD_DEFFN */          { dodefn, "deffn", 5 }, /* TEXICMD_DEFFN */
Line 122  static const struct texitok __texitoks[TEXICMD__MAX] =
Line 138  static const struct texitok __texitoks[TEXICMD__MAX] =
         { dodefindex, "defindex", 8 }, /* TEXICMD_DEFINDEX */          { dodefindex, "defindex", 8 }, /* TEXICMD_DEFINDEX */
         { dodefn, "defmac", 6 }, /* TEXICMD_DEFMAC */          { dodefn, "defmac", 6 }, /* TEXICMD_DEFMAC */
         { dodefn, "defmacx", 7 }, /* TEXICMD_DEFMACX */          { dodefn, "defmacx", 7 }, /* TEXICMD_DEFMACX */
           { dodefn, "defop", 5 }, /* TEXICMD_DEFOP */
           { dodefn, "defopx", 6 }, /* TEXICMD_DEFOPX */
           { dodefn, "defopt", 6 }, /* TEXICMD_DEFOPT */
           { dodefn, "defoptx", 7 }, /* TEXICMD_DEFOPTX */
         { dodefn, "deftp", 5 }, /* TEXICMD_DEFTP */          { dodefn, "deftp", 5 }, /* TEXICMD_DEFTP */
         { dodefn, "deftpx", 6 }, /* TEXICMD_DEFTPX */          { dodefn, "deftpx", 6 }, /* TEXICMD_DEFTPX */
         { dodefn, "deftypefn", 9 }, /* TEXICMD_DEFTYPEFN */          { dodefn, "deftypefn", 9 }, /* TEXICMD_DEFTYPEFN */
Line 142  static const struct texitok __texitoks[TEXICMD__MAX] =
Line 162  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 */          { 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 */          { doindex, "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 190  static const struct texitok __texitoks[TEXICMD__MAX] =
Line 231  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 */
         { dolink, "inforef", 7 }, /* TEXICMD_INDENTBLOCK */          { dolink, "indicateurl", 11 }, /* TEXICMD_INDICATEURL */
         { doignline, "insertcopying", 13 }, /* TEXICMD_INSERTCOPYING */          { dolink, "inforef", 7 }, /* TEXICMD_INFOREF */
           { doinsertcopying, "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 */          { doitem, "itemx", 5 }, /* TEXICMD_ITEMX */
         { 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 */          { domenu, "menu", 4 }, /* TEXICMD_MENU */
         { dosymbol, "minus", 5 }, /* TEXICMD_MINUS */          { dosymbol, "minus", 5 }, /* TEXICMD_MINUS */
         { domultitable, "multitable", 10 }, /* TEXICMD_MULTITABLE */          { domultitable, "multitable", 10 }, /* TEXICMD_MULTITABLE */
         { doignline, "need", 4 }, /* TEXICMD_NEED */          { doignline, "need", 4 }, /* TEXICMD_NEED */
         { dosymbol, "\n", 1 }, /* TEXICMD_NEWLINE */          { dosymbol, "\n", 1 }, /* TEXICMD_NEWLINE */
         { doignline, "node", 4 }, /* TEXICMD_NODE */          { donode, "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 */
         { doignline, "printindex", 10 }, /* TEXICMD_PRINTINDEX */          { dosymbol, "pounds", 6 }, /* TEXICMD_POUNDS */
           { doprintindex, "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 */          { doinline, "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 */
Line 246  static const struct texitok __texitoks[TEXICMD__MAX] =
Line 309  static const struct texitok __texitoks[TEXICMD__MAX] =
         { dosymbol, "}", 1 }, /* TEXICMD_SQUIGGLE_RIGHT */          { dosymbol, "}", 1 }, /* TEXICMD_SQUIGGLE_RIGHT */
         { dosymbol, "ss", 2 }, /* TEXICMD_SS */          { dosymbol, "ss", 2 }, /* TEXICMD_SS */
         { doinline, "strong", 6 }, /* TEXICMD_STRONG */          { doinline, "strong", 6 }, /* TEXICMD_STRONG */
         { dosubsection, "subheading", 10 }, /* TEXICMD_SUBHEADING */          { dosection, "subheading", 10 }, /* TEXICMD_SUBHEADING */
         { dosubsection, "subsection", 10 }, /* TEXICMD_SUBSECTION */          { dosection, "subsection", 10 }, /* TEXICMD_SUBSECTION */
         { dosubsubsection, "subsubheading", 13 }, /* TEXICMD_SUBSUBHEADING */          { dosection, "subsubheading", 13 }, /* TEXICMD_SUBSUBHEADING */
         { dosubsubsection, "subsubsection", 13 }, /* TEXICMD_SUBSUBSECTION */          { dosection, "subsubsection", 13 }, /* TEXICMD_SUBSUBSECTION */
         { doignline, "subtitle", 8 }, /* TEXICMD_SUBTITLE */          { doignline, "subtitle", 8 }, /* TEXICMD_SUBTITLE */
         { doignline, "summarycontents", 15 }, /* TEXICMD_SUMMARYCONTENTS */          { doignline, "summarycontents", 15 }, /* TEXICMD_SUMMARYCONTENTS */
         { doignline, "synindex", 8 }, /* TEXICMD_SYNINDEX */          { dodefindex, "synindex", 8 }, /* TEXICMD_SYNINDEX */
         { doignline, "syncodeindex", 12 }, /* TEXICMD_SYNCODEINDEX */          { dodefindex, "syncodeindex", 12 }, /* TEXICMD_SYNCODEINDEX */
         { doinline, "t", 1 }, /* TEXICMD_T */          { doinline, "t", 1 }, /* TEXICMD_T */
         { dotab, "tab", 3 }, /* TEXICMD_TAB */          { dotab, "tab", 3 }, /* TEXICMD_TAB */
         { dosymbol, "\t", 1 }, /* TEXICMD_TABSYM */          { 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 */
           { dosymbol, "textdegree", 10 }, /* TEXICMD_TEXTDEGREE */
           { dosymbol, "TH", 2 }, /* TEXICMD_TH */
           { dosymbol, "th", 2 }, /* TEXICMD_THSMALL */
         { dosymbol, "tie", 3 }, /* TEXICMD_TIE */          { dosymbol, "tie", 3 }, /* TEXICMD_TIE */
           { doaccent, "tieaccent", 9 }, /* TEXICMD_TIEACCENT */
         { doaccent, "~", 1 }, /* TEXICMD_TILDE */          { doaccent, "~", 1 }, /* TEXICMD_TILDE */
         { doignline, "tindex", 6 }, /* TEXICMD_TINDEX */          { doindex, "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 */          { dosection, "top", 3 }, /* TEXICMD_TOP */
           { doindex, "tpindex", 7 }, /* TEXICMD_TPINDEX */
           { 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 */
         { dosubsection, "unnumberedsubsec", 16 }, /* TEXICMD_UNNUMBEREDSUBSEC */          { dosection, "unnumberedsubsec", 16 }, /* TEXICMD_UNNUMBEREDSUBSEC */
         { dosubsubsection, "unnumberedsubsubsec", 19 }, /* TEXICMD_UNNUMBEREDSUBSUBSEC */          { dosection, "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 */          { 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, "verb", 4 }, /* TEXICMD_VERB */          { doverb, "verb", 4 }, /* TEXICMD_VERB */
         { doverbatim, "verbatim", 8 }, /* TEXICMD_VERBATIM */          { doverbatim, "verbatim", 8 }, /* TEXICMD_VERBATIM */
         { doverbinclude, "verbatiminclude", 15 }, /* TEXICMD_VERBATIMINCLUDE */          { doverbinclude, "verbatiminclude", 15 }, /* TEXICMD_VERBATIMINCLUDE */
         { doignline, "vindex", 6 }, /* TEXICMD_VINDEX */          { doindex, "vindex", 6 }, /* TEXICMD_VINDEX */
           { doindex, "vrindex", 7 }, /* TEXICMD_VRINDEX */
         { dosp, "vskip", 5 }, /* TEXICMD_VSKIP */          { dosp, "vskip", 5 }, /* TEXICMD_VSKIP */
         { dotable, "vtable", 6 }, /* TEXICMD_VTABLE */          { dotable, "vtable", 6 }, /* TEXICMD_VTABLE */
         { dobracket, "w", 1 }, /* TEXICMD_W */          { dobracket, "w", 1 }, /* TEXICMD_W */
Line 290  static const struct texitok __texitoks[TEXICMD__MAX] =
Line 363  static const struct texitok __texitoks[TEXICMD__MAX] =
   
 const   struct texitok *const texitoks = __texitoks;  const   struct texitok *const texitoks = __texitoks;
   
   /*
    * Define new indexes either by assignment or aliasing (both of these
    * accept the first argument as the new index).
    */
 static void  static void
 dodefindex(struct texi *p, enum texicmd cmd,  dodefindex(struct texi *p, enum texicmd cmd, size_t *pos)
         const char *buf, size_t sz, size_t *pos)  
 {  {
         size_t   start, end;          size_t   start;
         char    *cp;  
   
         while (*pos < sz && isws(buf[*pos]))          while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
                 advance(p, buf, pos);                  advance(p, pos);
           start = *pos;
         start = end = *pos;          while (*pos < BUFSZ(p) && '\n' != BUF(p)[*pos])
         while (end < sz && ! ismspace(buf[end]))                  advance(p, pos);
                 end++;          if (*pos == BUFSZ(p)) {
                   texiwarn(p, "unexpected EOF");
         if (start == end) {  
                 advanceeoln(p, buf, sz, pos, 1);  
                 return;                  return;
         } else if (NULL == (cp = malloc(end - start + 1)))          }
                 texiabort(p, NULL);          if (0 == *pos - start)
                   texiwarn(p, "zero-length index definition");
         memcpy(cp, &buf[start], end - start);          else
         cp[end - start] = '\0';                  texindex_add(p, &BUF(p)[start], *pos - start);
           advance(p, pos);
         p->indexs = realloc(p->indexs,  
                 sizeof(char *) * (p->indexsz + 1));  
   
         if (NULL == p->indexs)  
                 texiabort(p, NULL);  
         p->indexs[p->indexsz++] = cp;  
 }  }
   
   /*
    * Handle both possible "define function" (type, etc.) classes: where
    * we'll have a body and without one (suffixed with "x").
    */
 static void  static void
 dodefn(struct texi *p, enum texicmd cmd,  dodefn(struct texi *p, enum texicmd cmd, size_t *pos)
         const char *buf, size_t sz, size_t *pos)  
 {  {
         const char      *blk;          const char      *blk;
   
Line 331  dodefn(struct texi *p, enum texicmd cmd, 
Line 401  dodefn(struct texi *p, enum texicmd cmd, 
         switch (cmd) {          switch (cmd) {
         case (TEXICMD_DEFFN):          case (TEXICMD_DEFFN):
         case (TEXICMD_DEFMAC):          case (TEXICMD_DEFMAC):
           case (TEXICMD_DEFOP):
           case (TEXICMD_DEFOPT):
         case (TEXICMD_DEFTP):          case (TEXICMD_DEFTP):
         case (TEXICMD_DEFTYPEFN):          case (TEXICMD_DEFTYPEFN):
         case (TEXICMD_DEFTYPEFUN):          case (TEXICMD_DEFTYPEFUN):
Line 348  dodefn(struct texi *p, enum texicmd cmd, 
Line 420  dodefn(struct texi *p, enum texicmd cmd, 
   
         if (p->ign) {          if (p->ign) {
                 NULL != blk ?                  NULL != blk ?
                         parseto(p, buf, sz, pos, blk) :                          parseto(p, pos, blk) :
                         parseeoln(p, buf, sz, pos);                          parseeoln(p, pos);
                 return;                  return;
         }          }
   
         if (NULL != blk)          if (p->seenvs >= 0) {
                 texivspace(p);                  teximacro(p, "Pp");
                   p->seenvs = -1;
           }
   
         switch (cmd) {          switch (cmd) {
         case (TEXICMD_DEFTYPEMETHOD):          case (TEXICMD_DEFTYPEMETHOD):
Line 365  dodefn(struct texi *p, enum texicmd cmd, 
Line 439  dodefn(struct texi *p, enum texicmd cmd, 
         case (TEXICMD_DEFMACX):          case (TEXICMD_DEFMACX):
                 texiputchars(p, "Macro");                  texiputchars(p, "Macro");
                 break;                  break;
           case (TEXICMD_DEFOPT):
           case (TEXICMD_DEFOPTX):
                   texiputchars(p, "User Option");
                   break;
         case (TEXICMD_DEFTYPEVAR):          case (TEXICMD_DEFTYPEVAR):
         case (TEXICMD_DEFTYPEVARX):          case (TEXICMD_DEFTYPEVARX):
         case (TEXICMD_DEFVAR):          case (TEXICMD_DEFVAR):
Line 378  dodefn(struct texi *p, enum texicmd cmd, 
Line 456  dodefn(struct texi *p, enum texicmd cmd, 
                 texiputchars(p, "Function");                  texiputchars(p, "Function");
                 break;                  break;
         default:          default:
                 parselinearg(p, buf, sz, pos);                  parselinearg(p, pos);
                 break;                  break;
         }          }
   
         texiputchars(p, ":\n");          p->seenvs = 0;
           texiputchar(p, ':');
           texiputchar(p, '\n');
   
         switch (cmd) {          switch (cmd) {
         case (TEXICMD_DEFMAC):          case (TEXICMD_DEFMAC):
         case (TEXICMD_DEFMACX):          case (TEXICMD_DEFMACX):
                 teximacroopen(p, "Dv");                  teximacroopen(p, "Dv");
                 while (parselinearg(p, buf, sz, pos))                  while (parselinearg(p, pos))
                         /* Spin. */ ;                          /* Spin. */ ;
                 teximacroclose(p);                  teximacroclose(p);
                 break;                  break;
Line 397  dodefn(struct texi *p, enum texicmd cmd, 
Line 477  dodefn(struct texi *p, enum texicmd cmd, 
         case (TEXICMD_DEFUN):          case (TEXICMD_DEFUN):
         case (TEXICMD_DEFUNX):          case (TEXICMD_DEFUNX):
                 teximacroopen(p, "Fo");                  teximacroopen(p, "Fo");
                 parselinearg(p, buf, sz, pos);                  parselinearg(p, pos);
                 teximacroclose(p);                  teximacroclose(p);
                 teximacroopen(p, "Fa");                  teximacroopen(p, "Fa");
                 while (parselinearg(p, buf, sz, pos))                  while (parselinearg(p, pos))
                         /* Spin. */ ;                          /* Spin. */ ;
                 teximacroclose(p);                  teximacroclose(p);
                 teximacro(p, "Fc");                  teximacro(p, "Fc");
                 break;                  break;
           case (TEXICMD_DEFOP):
           case (TEXICMD_DEFOPX):
         case (TEXICMD_DEFTYPEFUN):          case (TEXICMD_DEFTYPEFUN):
         case (TEXICMD_DEFTYPEFUNX):          case (TEXICMD_DEFTYPEFUNX):
         case (TEXICMD_DEFTYPEFN):          case (TEXICMD_DEFTYPEFN):
Line 412  dodefn(struct texi *p, enum texicmd cmd, 
Line 494  dodefn(struct texi *p, enum texicmd cmd, 
         case (TEXICMD_DEFTYPEMETHOD):          case (TEXICMD_DEFTYPEMETHOD):
         case (TEXICMD_DEFTYPEMETHODX):          case (TEXICMD_DEFTYPEMETHODX):
                 teximacroopen(p, "Ft");                  teximacroopen(p, "Ft");
                 parselinearg(p, buf, sz, pos);                  parselinearg(p, pos);
                 teximacroclose(p);                  teximacroclose(p);
                 teximacroopen(p, "Fo");                  teximacroopen(p, "Fo");
                 parselinearg(p, buf, sz, pos);                  parselinearg(p, pos);
                 teximacroclose(p);                  teximacroclose(p);
                 teximacroopen(p, "Fa");                  teximacroopen(p, "Fa");
                 while (parselinearg(p, buf, sz, pos))                  while (parselinearg(p, pos))
                         /* Spin. */ ;                          /* Spin. */ ;
                 teximacroclose(p);                  teximacroclose(p);
                 teximacro(p, "Fc");                  teximacro(p, "Fc");
Line 430  dodefn(struct texi *p, enum texicmd cmd, 
Line 512  dodefn(struct texi *p, enum texicmd cmd, 
         case (TEXICMD_DEFTYPEVR):          case (TEXICMD_DEFTYPEVR):
         case (TEXICMD_DEFTYPEVRX):          case (TEXICMD_DEFTYPEVRX):
                 teximacroopen(p, "Vt");                  teximacroopen(p, "Vt");
                 while (parselinearg(p, buf, sz, pos))                  while (parselinearg(p, pos))
                         /* Spin. */ ;                          /* Spin. */ ;
                 teximacroclose(p);                  teximacroclose(p);
                 break;                  break;
           case (TEXICMD_DEFOPT):
           case (TEXICMD_DEFOPTX):
         case (TEXICMD_DEFVAR):          case (TEXICMD_DEFVAR):
         case (TEXICMD_DEFVARX):          case (TEXICMD_DEFVARX):
         case (TEXICMD_DEFVR):          case (TEXICMD_DEFVR):
         case (TEXICMD_DEFVRX):          case (TEXICMD_DEFVRX):
                 teximacroopen(p, "Va");                  teximacroopen(p, "Va");
                 while (parselinearg(p, buf, sz, pos))                  while (parselinearg(p, pos))
                         /* Spin. */ ;                          /* Spin. */ ;
                 teximacroclose(p);                  teximacroclose(p);
                 break;                  break;
Line 447  dodefn(struct texi *p, enum texicmd cmd, 
Line 531  dodefn(struct texi *p, enum texicmd cmd, 
                 abort();                  abort();
         }          }
   
           if (NULL == blk)
                   return;
   
           /*
            * All "block" definitions have their block bodies indented
            * unless they have the "x" form of the command following.
            * E.g.,
            *   @deffn some function
            *   @deffnx another
            *   An explanation.
            *   @end deffn
            * With this loop, we delay opening the indented block until we
            * skipped past conformant macros.
            */
           for (;;) {
                   switch (peekcmd(p, *pos)) {
                   case (TEXICMD_DEFFNX):
                   case (TEXICMD_DEFMACX):
                   case (TEXICMD_DEFOPX):
                   case (TEXICMD_DEFOPTX):
                   case (TEXICMD_DEFTPX):
                   case (TEXICMD_DEFTYPEFNX):
                   case (TEXICMD_DEFTYPEFUNX):
                   case (TEXICMD_DEFTYPEMETHODX):
                   case (TEXICMD_DEFTYPEVARX):
                   case (TEXICMD_DEFTYPEVRX):
                   case (TEXICMD_DEFUNX):
                   case (TEXICMD_DEFVARX):
                   case (TEXICMD_DEFVRX):
                           texivspace(p);
                           parseeoln(p, pos);
                           continue;
                   default:
                           break;
                   }
                   break;
           }
   
           if (TEXICMD_END == peekcmd(p, *pos)) {
                   parseto(p, pos, blk);
                   return;
           }
   
         texivspace(p);          texivspace(p);
         if (NULL != blk)          teximacro(p, "Bd -filled -offset indent -compact");
                 parseto(p, buf, sz, pos, blk);          p->seenvs = -1;
           parseto(p, pos, blk);
           p->seenvs = 0;
           teximacro(p, "Ed");
           texivspace(p);
 }  }
   
 static void  static void
 domacro(struct texi *p, enum texicmd cmd,  domacro(struct texi *p, enum texicmd cmd, size_t *pos)
         const char *buf, size_t sz, size_t *pos)  
 {  {
         size_t            start, end, endtoksz, len;          size_t            start, end, endtoksz, len;
         struct teximacro  m;          struct teximacro  m;
Line 462  domacro(struct texi *p, enum texicmd cmd, 
Line 592  domacro(struct texi *p, enum texicmd cmd, 
   
         memset(&m, 0, sizeof(struct teximacro));          memset(&m, 0, sizeof(struct teximacro));
   
         while (*pos < sz && isws(buf[*pos]))          while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
                 advance(p, buf, pos);                  advance(p, pos);
   
         for (start = end = *pos; end < sz; end++)          for (start = end = *pos; end < BUFSZ(p); end++)
                 if (ismspace(buf[end]) || '{' == buf[end])                  if (ismspace(BUF(p)[end]) || '{' == BUF(p)[end])
                         break;                          break;
   
         if (start == end)          if (start == end)
                 texierr(p, "zero-length macro name");                  texierr(p, "zero-length macro name");
   
         advanceto(p, buf, pos, end);          advanceto(p, pos, end);
   
         m.key = malloc(end - start + 1);          m.key = malloc(end - start + 1);
         if (NULL == m.key)          if (NULL == m.key)
                 texiabort(p, NULL);                  texiabort(p, NULL);
         memcpy(m.key, &buf[start], end - start);          memcpy(m.key, &BUF(p)[start], end - start);
         m.key[end - start] = '\0';          m.key[end - start] = '\0';
   
         m.args = argparse(p, buf, sz, pos, &m.argsz, 0);          m.args = argparse(p, pos, &m.argsz, 0);
         advanceeoln(p, buf, sz, pos, 0);          if (*pos == BUFSZ(p)) {
                   texiwarn(p, "unexpected EOF");
                   return;
           }
   
         start = *pos;          /* Note: we advance to the beginning of the macro. */
         endtok = "\n@end macro\n";          advanceeoln(p, pos, 1);
           if ((start = *pos) == BUFSZ(p)) {
                   texiwarn(p, "unexpected EOF");
                   return;
           }
   
           /*
            * According to the Texinfo manual, the macro ends on the
            * newline subsequent the @end macro.
            * That's COMPLETELY FUCKING WRONG.
            * It ends inclusive the newline, which is why so many macros
            * say things like @r{hello}@c, where the subsequent @c swallows
            * the newline.
            * However, it does swallow the leading newline, so look for the
            * @end macro without the leading newline else we might look
            * past empty macros.
            */
           endtok = "@end macro\n";
         endtoksz = strlen(endtok);          endtoksz = strlen(endtok);
         blk = memmem(&buf[start], sz, endtok, endtoksz);          blk = memmem(&BUF(p)[start], BUFSZ(p) - start, endtok, endtoksz);
         if (NULL == blk)          if (NULL == blk)
                 texierr(p, "unterminated macro body");                  texierr(p, "unterminated macro body");
         while (&buf[*pos] != blk)          /* Roll us back one character. */
                 advance(p, buf, pos);          while (&BUF(p)[*pos] != blk)
         assert('\n' == buf[*pos]);                  advance(p, pos);
         advance(p, buf, pos);          assert('@' == BUF(p)[*pos]);
         len = blk - &buf[start];          if ('\n' != BUF(p)[*pos - 1])
                   texierr(p, "cannot handle @end macro in-line");
   
           len = blk - &BUF(p)[start];
         m.value = malloc(len + 1);          m.value = malloc(len + 1);
         if (NULL == m.value)          if (NULL == m.value)
                 texiabort(p, NULL);                  texiabort(p, NULL);
         memcpy(m.value, &buf[start], len);          memcpy(m.value, &BUF(p)[start], len);
         m.value[len] = '\0';          m.value[len] = '\0';
   
         p->macros = realloc          p->macros = realloc
                 (p->macros,                  (p->macros,
                 (p->macrosz + 1) *                  (p->macrosz + 1) *
                 sizeof(struct teximacro));                  sizeof(struct teximacro));
         if (NULL == p->macros)          if (NULL == p->macros)
                 texiabort(p, NULL);                  texiabort(p, NULL);
   
         p->macros[p->macrosz++] = m;          p->macros[p->macrosz++] = m;
         advanceeoln(p, buf, sz, pos, 1);          advanceeoln(p, pos, 1);
 }  }
   
 static void  static void
 doignblock(struct texi *p, enum texicmd cmd,  doignblock(struct texi *p, enum texicmd cmd, size_t *pos)
         const char *buf, size_t sz, size_t *pos)  
 {  {
         char             end[32];          char             end[32], start[32];
         const char      *term;          const char      *endt, *startt;
         size_t           endsz, endpos;          size_t           esz, ssz, newpos, stack;
   
         /*          /*
          * We want to completely ignore everything in these blocks, so           * FIXME: this is cheating.
          * simply jump to the @end block.           * These tokens are supposed to begin on a newline.
            * However, if we do that, then we would need to check within
            * the loop for trailer (or leading, as the case may be)
            * newline, and that's just a bit too complicated right now.
            * This is becasue
            *      @ifset BAR
            *      @ifset FOO
            *      @end ifset
            *      @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", texitoks[cmd].tok);
           assert(esz < sizeof(end));
           stack = 1;
   
         /*          /*
          * Look up where our end token occurs.           * Here we look for the end token "end" somewhere in the file in
          * Set our end position based on the relative offset of that           * front of us.
          * from our current position, or the EOF if we don't have a           * It's not that easy, of course: if we have a nested block,
          * proper ending point.           * then there'll be an "end" token of the same kind between us.
            * Thus, we keep track of scopes for matching "end" blocks.
          */           */
         term = memmem(&buf[*pos], sz, end, endsz);          while (stack > 0 && *pos < BUFSZ(p)) {
         endpos = NULL == term ? sz :                  if (stack > 64)
                 *pos + (size_t)(term - &buf[*pos]);                          texierr(p, "run-away nested stack?");
         assert(endpos <= sz);                  endt = memmem(&BUF(p)[*pos], BUFSZ(p) - *pos, end, esz);
         while (*pos < endpos)                  startt = memmem(&BUF(p)[*pos], BUFSZ(p) - *pos, start, ssz);
                 advance(p, buf, pos);                  if (NULL == endt) {
                           texiwarn(p, "unterminated \"%s\" "
                                   "block", texitoks[cmd].tok);
                           *pos = BUFSZ(p);
                           break;
                   }
   
         /* Only do this if we're not already at the end. */                  newpos = *pos;
         if (endpos < sz)                  if (NULL == startt || startt > endt) {
                 advanceto(p, buf, pos, endpos + endsz);                          newpos += esz + (size_t)(endt - &BUF(p)[*pos]);
                           stack--;
                   } else {
                           newpos += ssz + (size_t)(startt - &BUF(p)[*pos]);
                           stack++;
                   }
   
                   assert(newpos <= BUFSZ(p));
                   while (*pos < newpos)
                           advance(p, pos);
           }
 }  }
   
 static void  static void
 doblock(struct texi *p, enum texicmd cmd,  doblock(struct texi *p, enum texicmd cmd, size_t *pos)
         const char *buf, size_t sz, size_t *pos)  
 {  {
   
         parseto(p, buf, sz, pos, texitoks[cmd].tok);          parseto(p, pos, texitoks[cmd].tok);
 }  }
   
 static void  static void
 doinline(struct texi *p, enum texicmd cmd,  doinline(struct texi *p, enum texicmd cmd, size_t *pos)
         const char *buf, size_t sz, size_t *pos)  
 {  {
         const char      *macro = NULL;          const char      *macro = NULL;
   
         switch (cmd) {          switch (cmd) {
         case (TEXICMD_CODE):          case (TEXICMD_CODE):
         case (TEXICMD_KBD):          case (TEXICMD_KBD):
           /* FIXME: quote around @samp{} */
         case (TEXICMD_SAMP):          case (TEXICMD_SAMP):
         case (TEXICMD_T):          case (TEXICMD_T):
                 macro = "Li";                  macro = "Li";
Line 597  doinline(struct texi *p, enum texicmd cmd,
Line 778  doinline(struct texi *p, enum texicmd cmd,
         }          }
   
         if (NULL == macro || p->literal || TEXILIST_TABLE == p->list) {          if (NULL == macro || p->literal || TEXILIST_TABLE == p->list) {
                 parsebracket(p, buf, sz, pos);                  if (TEXICMD_SC == cmd)
                           p->uppercase++;
                   parsebracket(p, pos, 0);
                   if (TEXICMD_SC == cmd)
                           p->uppercase--;
                 return;                  return;
         }          }
   
           /*
            * If we haven't seen any whitespace, then we don't want the
            * subsequent macro to insert any whitespace.
            */
           if (p->outmacro && 0 == p->seenws) {
                   teximacroopen(p, "Ns");
                   teximacroclose(p);
           }
   
         teximacroopen(p, macro);          teximacroopen(p, macro);
         p->seenws = 0;          p->seenws = 0;
         parsebracket(p, buf, sz, pos);          if (TEXICMD_CODE == cmd)
         texipunctuate(p, buf, sz, pos);                  p->literal++;
           if (TEXICMD_SC == cmd)
                   p->uppercase++;
           parsebracket(p, pos, 0);
           if (TEXICMD_SC == cmd)
                   p->uppercase--;
           if (TEXICMD_CODE == cmd)
                   p->literal--;
           texipunctuate(p, pos);
         teximacroclose(p);          teximacroclose(p);
 }  }
   
 static void  static void
 doverb(struct texi *p, enum texicmd cmd,  doverb(struct texi *p, enum texicmd cmd, size_t *pos)
         const char *buf, size_t sz, size_t *pos)  
 {  {
         char     delim;          char     delim;
         size_t   start;          size_t   start;
   
         while (*pos < sz && isws(buf[*pos]))          while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
                 advance(p, buf, pos);                  advance(p, pos);
         if (*pos == sz || '{' != buf[*pos])          if (*pos == BUFSZ(p) || '{' != BUF(p)[*pos])
                 return;                  return;
         advance(p, buf, pos);          advance(p, pos);
         if (*pos == sz)          if (*pos == BUFSZ(p))
                 return;                  return;
   
         delim = buf[*pos];          delim = BUF(p)[*pos];
         advance(p, buf, pos);          advance(p, pos);
         /* Make sure we flush out our initial whitespace... */          /* Make sure we flush out our initial whitespace... */
         if (p->seenws && p->outcol && 0 == p->literal)          if (p->seenws && p->outcol && 0 == p->literal)
                 texiputchar(p, ' ');                  texiputchar(p, ' ');
         p->seenws = 0;          p->seenws = 0;
         start = *pos;          start = *pos;
         /* Read until we see the delimiter then end-brace. */          /* Read until we see the delimiter then end-brace. */
         while (*pos < sz - 1) {          while (*pos < BUFSZ(p) - 1) {
                 if (buf[*pos] == delim && buf[*pos + 1] == '}')                  if (BUF(p)[*pos] == delim && BUF(p)[*pos + 1] == '}')
                         break;                          break;
                 advance(p, buf, pos);                  advance(p, pos);
         }          }
         if (*pos == sz - 1)          if (*pos >= BUFSZ(p) - 1)
                 return;                  return;
         texiputbuf(p, buf, start, *pos);          texiputbuf(p, start, *pos);
   
         /* Make sure we read after the end-brace. */          /* Make sure we read after the end-brace. */
         assert(delim == buf[*pos]);          assert(delim == BUF(p)[*pos]);
         advance(p, buf, pos);          advance(p, pos);
         assert('}' == buf[*pos]);          assert('}' == BUF(p)[*pos]);
         advance(p, buf, pos);          advance(p, pos);
 }  }
   
 static void  static void
 doverbatim(struct texi *p, enum texicmd cmd,  doinsertcopying(struct texi *p, enum texicmd cmd, size_t *pos)
         const char *buf, size_t sz, size_t *pos)  
 {  {
   
           advanceeoln(p, pos, 0);
           if (NULL != p->copying)
                   texisplice(p, p->copying, p->copyingsz, *pos);
   }
   
   static void
   docopying(struct texi *p, enum texicmd cmd, 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 retain our starting (but not ending) newlines. */
           end = "\n@end copying\n";
           endsz = strlen(end);
           advanceeoln(p, pos, 0);
           if (*pos == BUFSZ(p)) {
                   texiwarn(p, "unterminated \"%s\"", texitoks[cmd].tok);
                   return;
           }
   
         /* We end at exactly this token. */          term = memmem(&BUF(p)[*pos], BUFSZ(p) - *pos, end, endsz);
           if (NULL == term)
                   texierr(p, "unterminated \"%s\"", texitoks[cmd].tok);
           else
                   endpos = *pos + (size_t)(term - &BUF(p)[*pos]);
   
           if (endpos == *pos) {
                   advanceeoln(p, pos, 1);
                   return;
           }
   
           assert(endpos < BUFSZ(p) && endpos > *pos);
           assert('\n' == BUF(p)[*pos]);
           advance(p, pos);
   
           if (*pos == BUFSZ(p)) {
                   texiwarn(p, "unterminated \"%s\"", texitoks[cmd].tok);
                   return;
           }
   
           p->copying = malloc(endpos - *pos + 1);
           p->copyingsz = endpos - *pos;
           memcpy(p->copying, &BUF(p)[*pos], p->copyingsz);
           p->copying[endpos - *pos] = '\0';
   
           while (*pos < endpos)
                   advance(p, pos);
           if (*pos < BUFSZ(p))
                   advanceto(p, pos, endpos + endsz);
   }
   
   static void
   doverbatim(struct texi *p, enum texicmd cmd, size_t *pos)
   {
           const char      *end, *term;
           size_t           endsz, endpos;
   
           /* We read from the @verbatim\n newline inclusive! */
         end = "\n@end verbatim\n";          end = "\n@end verbatim\n";
         endsz = strlen(end);          endsz = strlen(end);
           advanceeoln(p, pos, 0);
           if (*pos == BUFSZ(p)) {
                   texiwarn(p, "unterminated \"%s\"", texitoks[cmd].tok);
                   return;
           }
   
         /*          term = memmem(&BUF(p)[*pos], BUFSZ(p) - *pos, end, endsz);
          * Look up where our end token occurs.          if (NULL == term) {
          * Set our end position based on the relative offset of that                  texiwarn(p, "unterminated \"%s\"", texitoks[cmd].tok);
          * from our current position.                  endpos = BUFSZ(p);
          */          } else
         term = memmem(&buf[*pos], sz, end, endsz);                  endpos = *pos + (size_t)(term - &BUF(p)[*pos]);
         endpos = NULL == term ? sz :  
                 *pos + (size_t)(term - &buf[*pos]);  
   
         teximacro(p, "Bd -literal -offset indent");          assert(endpos <= BUFSZ(p));
         assert(endpos <= sz);          assert('\n' == BUF(p)[*pos]);
           advance(p, pos);
           texivspace(p);
           teximacro(p, "Bd -literal -offset indent -compact");
           p->seenvs = -1;
         while (*pos < endpos) {          while (*pos < endpos) {
                 if (buf[*pos] == '\n')                  texiputchar(p, BUF(p)[*pos]);
                         p->outcol = 0;                  advance(p, pos);
                 else  
                         p->outcol++;  
                 if (*pos > 0 && '.' == buf[*pos])  
                         if ('\n' == buf[*pos - 1])  
                                 fputs("\\&", stdout);  
                 putchar(buf[*pos]);  
                 if ('\\' == buf[*pos])  
                         putchar('e');  
                 advance(p, buf, pos);  
         }          }
           p->seenvs = 0;
         teximacro(p, "Ed");          teximacro(p, "Ed");
         advanceto(p, buf, pos, endpos + endsz);          texivspace(p);
           if (*pos < BUFSZ(p))
                   advanceto(p, pos, endpos + endsz);
 }  }
   
 static void  static void
 doverbinclude(struct texi *p, enum texicmd cmd,  doverbinclude(struct texi *p, enum texicmd cmd, size_t *pos)
         const char *buf, size_t sz, size_t *pos)  
 {  {
         char             fname[PATH_MAX], path[PATH_MAX];          char             fname[PATH_MAX], path[PATH_MAX];
         int              rc;          int              rc;
         size_t           i, end;          size_t           i, end;
         const char      *v;          const char      *v;
         enum texicmd     type;          enum texicmd     type;
   
         while (*pos < sz && ' ' == buf[*pos])          while (*pos < BUFSZ(p) && ' ' == BUF(p)[*pos])
                 advance(p, buf, pos);                  advance(p, pos);
   
         for (i = 0; *pos < sz && '\n' != buf[*pos]; ) {          for (i = 0; *pos < BUFSZ(p) && '\n' != BUF(p)[*pos]; ) {
                 if (i == sizeof(fname) - 1)                  if (i == sizeof(fname) - 1)
                         break;                          break;
                 if ('@' != buf[*pos]) {                  if ('@' != BUF(p)[*pos]) {
                         fname[i++] = buf[*pos];                          fname[i++] = BUF(p)[*pos];
                         advance(p, buf, pos);                          advance(p, pos);
                         continue;                          continue;
                 }                  }
                 type = texicmd(p, buf, *pos, sz, &end, NULL);                  type = texicmd(p, *pos, &end, NULL);
                 advanceto(p, buf, pos, end);                  advanceto(p, pos, end);
                 if (TEXICMD_VALUE != type)                  if (TEXICMD_VALUE != type)
                         texierr(p, "unknown verbatiminclude command");                          texierr(p, "unknown verbatiminclude command");
                 v = valueblookup(p, buf, sz, pos);                  v = valueblookup(p, pos);
                 if (NULL == v)                  if (NULL == v)
                         continue;                          continue;
                 while ('\0' != *v) {                  while ('\0' != *v) {
Line 727  doverbinclude(struct texi *p, enum texicmd cmd, 
Line 980  doverbinclude(struct texi *p, enum texicmd cmd, 
   
         if (i == 0)          if (i == 0)
                 texierr(p, "path too short");                  texierr(p, "path too short");
         else if ('\n' != buf[*pos])          else if ('\n' != BUF(p)[*pos])
                 texierr(p, "path too long");                  texierr(p, "path too long");
         else if ('/' == fname[0])          else if ('/' == fname[0])
                 texierr(p, "no absolute paths");                  texierr(p, "no absolute paths");
Line 736  doverbinclude(struct texi *p, enum texicmd cmd, 
Line 989  doverbinclude(struct texi *p, enum texicmd cmd, 
         if (strstr(fname, "../") || strstr(fname, "/.."))          if (strstr(fname, "../") || strstr(fname, "/.."))
                 texierr(p, "insecure path");                  texierr(p, "insecure path");
   
         rc = snprintf(path, sizeof(path),          rc = snprintf(path, sizeof(path),
                 "%s/%s", p->dirs[0], fname);                  "%s/%s", p->dirs[0], fname);
         if (rc < 0)          if (rc < 0)
                 texierr(p, "couldn't format path");                  texierr(p, "couldn't format path");
         else if ((size_t)rc >= sizeof(path))          else if ((size_t)rc >= sizeof(path))
                 texierr(p, "path too long");                  texierr(p, "path too long");
Line 747  doverbinclude(struct texi *p, enum texicmd cmd, 
Line 1000  doverbinclude(struct texi *p, enum texicmd cmd, 
 }  }
   
 static void  static void
 doinclude(struct texi *p, enum texicmd cmd,  doinclude(struct texi *p, enum texicmd cmd, size_t *pos)
         const char *buf, size_t sz, size_t *pos)  
 {  {
         char             fname[PATH_MAX], path[PATH_MAX];          char             fname[PATH_MAX], path[PATH_MAX];
         size_t           i, end;          size_t           i, end;
         int              rc;          int              rc;
         const char      *v;          const char      *v;
         enum texicmd     type;          enum texicmd     type;
   
         while (*pos < sz && ' ' == buf[*pos])          while (*pos < BUFSZ(p) && ' ' == BUF(p)[*pos])
                 advance(p, buf, pos);                  advance(p, pos);
   
         /* Read in the filename. */          /* Read in the filename. */
         for (i = 0; *pos < sz && '\n' != buf[*pos]; ) {          for (i = 0; *pos < BUFSZ(p) && '\n' != BUF(p)[*pos]; ) {
                 if (i == sizeof(fname) - 1)                  if (i == sizeof(fname) - 1)
                         break;                          break;
                 if ('@' != buf[*pos]) {                  if ('@' != BUF(p)[*pos]) {
                         fname[i++] = buf[*pos];                          fname[i++] = BUF(p)[*pos];
                         advance(p, buf, pos);                          advance(p, pos);
                         continue;                          continue;
                 }                  }
                 type = texicmd(p, buf, *pos, sz, &end, NULL);                  type = texicmd(p, *pos, &end, NULL);
                 advanceto(p, buf, pos, end);                  advanceto(p, pos, end);
                 if (TEXICMD_VALUE != type)                  if (TEXICMD_VALUE != type)
                         texierr(p, "unknown include command");                          texierr(p, "unknown include command");
                 v = valueblookup(p, buf, sz, pos);                  v = valueblookup(p, pos);
                 if (NULL == v)                  if (NULL == v)
                         continue;                          continue;
                 while ('\0' != *v) {                  while ('\0' != *v) {
Line 786  doinclude(struct texi *p, enum texicmd cmd, 
Line 1038  doinclude(struct texi *p, enum texicmd cmd, 
   
         if (i == 0)          if (i == 0)
                 texierr(p, "path too short");                  texierr(p, "path too short");
         else if ('\n' != buf[*pos])          else if ('\n' != BUF(p)[*pos])
                 texierr(p, "path too long");                  texierr(p, "path too long");
         else if ('/' == fname[0])          else if ('/' == fname[0])
                 texierr(p, "no absolute paths");                  texierr(p, "no absolute paths");
Line 796  doinclude(struct texi *p, enum texicmd cmd, 
Line 1048  doinclude(struct texi *p, enum texicmd cmd, 
                 texierr(p, "insecure path");                  texierr(p, "insecure path");
   
         for (i = 0; i < p->dirsz; i++) {          for (i = 0; i < p->dirsz; i++) {
                 rc = snprintf(path, sizeof(path),                  rc = snprintf(path, sizeof(path),
                         "%s/%s", p->dirs[i], fname);                          "%s/%s", p->dirs[i], fname);
                 if (rc < 0)                  if (rc < 0)
                         texierr(p, "couldn't format path");                          texierr(p, "couldn't format path");
                 else if ((size_t)rc >= sizeof(path))                  else if ((size_t)rc >= sizeof(path))
                         texierr(p, "path too long");                          texierr(p, "path too long");
Line 813  doinclude(struct texi *p, enum texicmd cmd, 
Line 1065  doinclude(struct texi *p, enum texicmd cmd, 
 }  }
   
 static void  static void
 dobracket(struct texi *p, enum texicmd cmd,  dobracket(struct texi *p, enum texicmd cmd, size_t *pos)
         const char *buf, size_t sz, size_t *pos)  
 {  {
   
         parsebracket(p, buf, sz, pos);          parsebracket(p, pos, 0);
 }  }
   
 static void  static void
 dodisplay(struct texi *p, enum texicmd cmd,  dodisplay(struct texi *p, enum texicmd cmd, size_t *pos)
         const char *buf, size_t sz, size_t *pos)  
 {  {
   
           advanceeoln(p, pos, 1);
           texivspace(p);
   
         switch (cmd) {          switch (cmd) {
         case (TEXICMD_FORMAT):          case (TEXICMD_FORMAT):
         case (TEXICMD_SMALLFORMAT):          case (TEXICMD_SMALLFORMAT):
                 teximacro(p, "Bd -filled");                  teximacro(p, "Bd -filled -compact");
                 break;                  break;
         default:          default:
                 teximacro(p, "Bd -filled -offset indent");                  teximacro(p, "Bd -filled -offset indent -compact");
                 break;                  break;
         }          }
   
         p->seenvs = 1;          p->seenvs = -1;
         /* FIXME: ignore and parseeoln. */          parseto(p, pos, texitoks[cmd].tok);
         advanceeoln(p, buf, sz, pos, 1);          p->seenvs = 0;
         parseto(p, buf, sz, pos, texitoks[cmd].tok);  
         teximacro(p, "Ed");          teximacro(p, "Ed");
           texivspace(p);
 }  }
   
 static void  static void
 doexample(struct texi *p, enum texicmd cmd,  doexample(struct texi *p, enum texicmd cmd, size_t *pos)
         const char *buf, size_t sz, size_t *pos)  
 {  {
   
         teximacro(p, "Bd -literal -offset indent");          advanceeoln(p, pos, 1);
         /* FIXME: ignore and parseeoln. */  
         advanceeoln(p, buf, sz, pos, 1);          texivspace(p);
           teximacro(p, "Bd -literal -offset indent -compact");
         p->literal++;          p->literal++;
         parseto(p, buf, sz, pos, texitoks[cmd].tok);          parseto(p, pos, texitoks[cmd].tok);
         p->literal--;          p->literal--;
           p->seenvs = 0;
         teximacro(p, "Ed");          teximacro(p, "Ed");
           texivspace(p);
 }  }
   
 static void  static void
 dobye(struct texi *p, enum texicmd cmd,  dobye(struct texi *p, enum texicmd cmd, size_t *pos)
         const char *buf, size_t sz, size_t *pos)  
 {  {
   
         texiexit(p);          texiexit(p);
Line 866  dobye(struct texi *p, enum texicmd cmd, 
Line 1120  dobye(struct texi *p, enum texicmd cmd, 
 }  }
   
 static void  static void
 dotitle(struct texi *p, enum texicmd cmd,  dotitle(struct texi *p, enum texicmd cmd, size_t *pos)
         const char *buf, size_t sz, size_t *pos)  
 {  {
         size_t   start, end;          size_t   start;
   
         while (*pos < sz && isws(buf[*pos]))          while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
                 advance(p, buf, pos);                  advance(p, pos);
         start = end = *pos;  
         while (end < sz && '\n' != buf[end])          /* We want to suck down the entire line, inclusive \n. */
                 end++;          start = *pos;
         advanceeoln(p, buf, sz, pos, 1);          while (*pos < BUFSZ(p) && '\n' != BUF(p)[*pos]) {
                   if ('@' == BUF(p)[*pos])
                           advance(p, pos);
                   advance(p, pos);
           }
           if (*pos < BUFSZ(p))
                   advance(p, pos);
   
           /* Copy this into a buffer. */
         free(p->subtitle);          free(p->subtitle);
         p->subtitle = malloc(end - start + 1);          if (NULL == (p->subtitle = malloc(*pos - start + 1)))
         if (NULL == p->subtitle)  
                 texiabort(p, NULL);                  texiabort(p, NULL);
         memcpy(p->subtitle, &buf[start], end - start);          memcpy(p->subtitle, &BUF(p)[start], *pos - start);
         p->subtitle[end - start] = '\0';          p->subtitle[*pos - start] = '\0';
 }  }
   
 static void  static void
 doaccent(struct texi *p, enum texicmd cmd,  doaccent(struct texi *p, enum texicmd cmd, size_t *pos)
         const char *buf, size_t sz, size_t *pos)  
 {  {
           int      brace = 0;
   
         if (*pos == sz)          if (*pos == BUFSZ(p)) {
                   texiwarn(p, "truncated: @%s", texitoks[cmd].tok);
                 return;                  return;
         if (p->seenws && p->outcol && 0 == p->literal)          }
   
           /* Pad us with space, if necessary. */
           if (p->seenws && p->outcol && 0 == p->literal) {
                 texiputchar(p, ' ');                  texiputchar(p, ' ');
         p->seenws = 0;                  p->seenws = 0;
           }
   
           /*
            * If we're braced, then that's that.
            * Otherwise, in a special Texinfo case: if we're a non
            * alphabetic command of one letter, then the next character is
            * the critical one.
            * Otherwise, space can sit between us and our argument.
            */
           if ('{' == BUF(p)[*pos]) {
                   brace = 1;
                   advance(p, pos);
           } else if (isalpha((unsigned char)texitoks[cmd].tok[0]))
                   while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
                           advance(p, pos);
   
           if (*pos == BUFSZ(p)) {
                   texiwarn(p, "truncated: @%s", texitoks[cmd].tok);
                   return;
           }
   
         switch (cmd) {          switch (cmd) {
         case (TEXICMD_CEDILLA):  
                 /* Strange rules... */  
                 while (*pos < sz && isws(buf[*pos]))  
                         advance(p, buf, pos);  
                 if (*pos == sz || '{' != buf[*pos])  
                         return;  
                 advance(p, buf, pos);  
                 switch (buf[*pos]) {  
                 case ('c'): case ('C'):  
                         texiputchars(p, "\\(,");  
                         texiputchar(p, buf[*pos]);  
                         break;  
                 default:  
                         texiputchar(p, buf[*pos]);  
                         break;  
                 }  
                 advance(p, buf, pos);  
                 break;  
         case (TEXICMD_ACUTE):          case (TEXICMD_ACUTE):
                 switch (buf[*pos]) {                  switch (BUF(p)[*pos]) {
                 case ('a'): case ('A'):                  case ('a'): case ('A'):
                 case ('e'): case ('E'):                  case ('e'): case ('E'):
                 case ('i'): case ('I'):                  case ('i'): case ('I'):
                 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(p)[*pos]);
                   advance(p, pos);
                 break;                  break;
           case (TEXICMD_CEDILLA):
                   if ('c' == BUF(p)[*pos] || 'C' == BUF(p)[*pos])
                           texiputchars(p, "\\(,");
                   else
                           texiwarn(p, "ignoring accent");
                   texiputchar(p, BUF(p)[*pos]);
                   advance(p, pos);
                   break;
         case (TEXICMD_CIRCUMFLEX):          case (TEXICMD_CIRCUMFLEX):
                 switch (buf[*pos]) {                  switch (BUF(p)[*pos]) {
                 case ('a'): case ('A'):                  case ('a'): case ('A'):
                 case ('e'): case ('E'):                  case ('e'): case ('E'):
                 case ('i'): case ('I'):                  case ('i'): case ('I'):
                 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;                          break;
                 }                  }
                   texiputchar(p, BUF(p)[*pos]);
                   advance(p, pos);
                 break;                  break;
           case (TEXICMD_DOTLESS):
                   if ('i' == BUF(p)[*pos] || 'j' == BUF(p)[*pos])
                           texiputchars(p, "\\(.");
                   else
                           texiwarn(p, "ignoring accent");
                   texiputchar(p, BUF(p)[*pos]);
                   advance(p, pos);
                   break;
         case (TEXICMD_GRAVE):          case (TEXICMD_GRAVE):
                 switch (buf[*pos]) {                  switch (BUF(p)[*pos]) {
                 case ('a'): case ('A'):                  case ('a'): case ('A'):
                 case ('e'): case ('E'):                  case ('e'): case ('E'):
                 case ('i'): case ('I'):                  case ('i'): case ('I'):
                 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(p)[*pos]);
                   advance(p, pos);
                 break;                  break;
         case (TEXICMD_TILDE):          case (TEXICMD_TILDE):
                 switch (buf[*pos]) {                  switch (BUF(p)[*pos]) {
                 case ('a'): case ('A'):                  case ('a'): case ('A'):
                 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;                          break;
                 }                  }
                   texiputchar(p, BUF(p)[*pos]);
                   advance(p, pos);
                 break;                  break;
         case (TEXICMD_UMLAUT):          case (TEXICMD_UMLAUT):
                 switch (buf[*pos]) {                  switch (BUF(p)[*pos]) {
                 case ('a'): case ('A'):                  case ('a'): case ('A'):
                 case ('e'): case ('E'):                  case ('e'): case ('E'):
                 case ('i'): case ('I'):                  case ('i'): case ('I'):
Line 979  doaccent(struct texi *p, enum texicmd cmd, 
Line 1268  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:
                         texiputchar(p, buf[*pos]);                          texiwarn(p, "ignoring accent");
                         break;                          break;
                 }                  }
                   texiputchar(p, BUF(p)[*pos]);
                   advance(p, pos);
                 break;                  break;
         default:          default:
                 abort();                  texiputchar(p, BUF(p)[*pos]);
                   advance(p, pos);
                   break;
         }          }
         advance(p, buf, pos);  
           if (brace) {
                   while (*pos < BUFSZ(p) && '}' != BUF(p)[*pos]) {
                           texiputchar(p, BUF(p)[*pos]);
                           advance(p, pos);
                   }
                   if (*pos < BUFSZ(p))
                           advance(p, pos);
           }
   
           switch (cmd) {
           case (TEXICMD_TIEACCENT):
                   texiputchar(p, ']');
                   break;
           case (TEXICMD_DOTACCENT):
                   texiputchar(p, '*');
                   break;
           default:
                   break;
           }
 }  }
   
 static void  static void
 dosymbol(struct texi *p, enum texicmd cmd,  dosymbol(struct texi *p, enum texicmd cmd, size_t *pos)
         const char *buf, size_t sz, size_t *pos)  
 {  {
   
         if (p->seenws && p->outcol && 0 == p->literal) {          /* Remember to pad us. */
           if (p->seenws && p->outcol && 0 == p->literal)
                 texiputchar(p, ' ');                  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 1012  dosymbol(struct texi *p, enum texicmd cmd, 
Line 1335  dosymbol(struct texi *p, enum texicmd cmd, 
         case (TEXICMD_AT):          case (TEXICMD_AT):
                 texiputchar(p, '@');                  texiputchar(p, '@');
                 break;                  break;
           case (TEXICMD_BACKSLASH):
                   texiputchar(p, '\\');
                   break;
         case (TEXICMD_BANG):          case (TEXICMD_BANG):
                 texiputchar(p, '!');                  texiputchar(p, '!');
                 break;                  break;
Line 1024  dosymbol(struct texi *p, enum texicmd cmd, 
Line 1350  dosymbol(struct texi *p, enum texicmd cmd, 
         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):          case (TEXICMD_ENDDOTS):
                 texiputchars(p, "...");                  texiputchars(p, "...");
Line 1034  dosymbol(struct texi *p, enum texicmd cmd, 
Line 1366  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;
Line 1067  dosymbol(struct texi *p, enum texicmd cmd, 
Line 1476  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):          case (TEXICMD_TIE):
                 texiputchars(p, "\\ ");                  texiputchars(p, "\\ ");
                 break;                  break;
Line 1077  dosymbol(struct texi *p, enum texicmd cmd, 
Line 1495  dosymbol(struct texi *p, enum texicmd cmd, 
                 abort();                  abort();
         }          }
   
         if (texitoks[cmd].len > 1)          /* Alphabetic commands have braces we ignore. */
                 doignbracket(p, cmd, buf, sz, pos);          if (isalpha((unsigned char)texitoks[cmd].tok[0]))
                   doignbracket(p, cmd, pos);
 }  }
   
 static void  static void
 doquotation(struct texi *p, enum texicmd cmd,  doquotation(struct texi *p, enum texicmd cmd, size_t *pos)
         const char *buf, size_t sz, size_t *pos)  
 {  {
   
         teximacro(p, "Qo");          teximacro(p, "Qo");
         parseto(p, buf, sz, pos, "quotation");          parseto(p, pos, "quotation");
         teximacro(p, "Qc");          teximacro(p, "Qc");
 }  }
   
   static int
   indexcmp(const void *p1, const void *p2)
   {
           const struct texiterm *t1 = p1, *t2 = p2;
   
           return(strcasecmp(t1->term, t2->term));
   }
   
 static void  static void
 domath(struct texi *p, enum texicmd cmd,  doprintindex(struct texi *p, enum texicmd cmd, size_t *pos)
         const char *buf, size_t sz, size_t *pos)  
 {  {
         size_t   nest, start;          static size_t    guard = 0;
           size_t           i, j, start, end, len;
   #if HAVE_INDEX
           char            *cp;
           char             buf[PATH_MAX];
   #endif
   
         /*          if (guard++ > 8)
          * Math handling is different from everything else.                  texierr(p, "recursive @printindex");
          * We don't allow any subcomponents, and we ignore the rules in  
          * terms of @-commands.          while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
          * This departs from GNU's rules, but whatever.                  advance(p, pos);
          */          start = *pos;
         while (*pos < sz && isws(buf[*pos]))          while (*pos < BUFSZ(p) && '\n' != BUF(p)[*pos])
                 advance(p, buf, pos);                  advance(p, pos);
         if (*pos == sz || '{' != buf[*pos])          if ((end = *pos) == BUFSZ(p)) {
                   texiwarn(p, "unexpected EOF");
                   guard--;
                 return;                  return;
         advance(p, buf, pos);  
         if (p->seenws && p->outcol && 0 == p->literal)  
                 texiputchar(p, ' ');  
         p->seenws = 0;  
         for (nest = 1, start = *pos; *pos < sz && nest > 0; ) {  
                 if ('{' == buf[*pos])  
                         nest++;  
                 else if ('}' == buf[*pos])  
                         if (0 == --nest)  
                                 continue;  
                 advance(p, buf, pos);  
         }          }
         if (*pos == sz)  
           advance(p, pos);
           if (*pos == BUFSZ(p)) {
                   texiwarn(p, "unexpected EOF");
                   guard--;
                 return;                  return;
         assert('}' == buf[*pos]);          } else if (0 == (len = end - start)) {
         texiputbuf(p, buf, start, *pos);                  texiwarn(p, "zero-length index");
         advance(p, buf, pos);                  guard--;
                   return;
           }
   
           /* Look for the index in our table. */
           for (i = 0; i < p->indexsz; i++) {
                   if (strlen(p->indexs[i].name) != len)
                           continue;
                   if (strncmp(p->indexs[i].name, &BUF(p)[start], len))
                           continue;
                   break;
           }
   
           if (i == p->indexsz) {
                   texiwarn(p, "cannot find index");
                   guard--;
                   return;
           } else if (0 == p->indexs[i].indexsz) {
                   guard--;
                   return;
           }
   
           /* Alphabetically sort our indices. */
           qsort(p->indexs[i].index,
                   p->indexs[i].indexsz,
                   sizeof(struct texiterm), indexcmp);
   
           texivspace(p);
           teximacro(p, "Bl -tag -width Ds -compact");
           for (j = 0; j < p->indexs[i].indexsz; j++) {
                   teximacroopen(p, "It");
   #if HAVE_INDEX
                   if (NULL == p->chapters) {
                           teximacroopen(p, "Lkx");
                           texiputchars(p, "\"idx");
                           texiputchars(p, p->indexs[i].name);
                           cp = p->indexs[i].index[j].term;
                           while ('\n' != *cp)
                                   texiputchar(p, *cp++);
                           texiputchars(p, "\" \"");
                           p->literal++;
                   } else {
                           teximacroopen(p, "Xr");
                           snprintf(buf, sizeof(buf), "%s-%zd 7 \"idx",
                                   p->chapters, p->indexs[i].index[j].chapter);
                           texiputchars(p, buf);
                           texiputchars(p, p->indexs[i].name);
                           cp = p->indexs[i].index[j].term;
                           while ('\n' != *cp)
                                   texiputchar(p, *cp++);
                           texiputchars(p, "\" \"");
                           p->literal++;
                   }
   #endif
                   texisplice(p, p->indexs[i].index[j].term,
                           strlen(p->indexs[i].index[j].term), *pos);
                   parseeoln(p, pos);
   #if HAVE_INDEX
                   p->literal--;
                   texiputchars(p, "\"");
                   teximacroclose(p);
   #endif
                   teximacroclose(p);
           }
           p->seenvs = 0;
           teximacro(p, "El");
           texivspace(p);
           guard--;
 }  }
   
 static void  static void
 dovalue(struct texi *p, enum texicmd cmd,  donode(struct texi *p, enum texicmd cmd, size_t *pos)
         const char *buf, size_t sz, size_t *pos)  
 {  {
         size_t           start, end, i;          int      sv = p->seenvs;
           char     fname[PATH_MAX];
           size_t   end, start;
   
           if (0 == p->nodesz++)
                   p->ign--;
   
           /* Grab our node name. */
           while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
                   advance(p, pos);
           start = *pos;
           while (*pos < BUFSZ(p)) {
                   if (BUF(p)[*pos] == ',')
                           break;
                   else if (BUF(p)[*pos] == '\n')
                           break;
                   advance(p, pos);
           }
           if (*pos == BUFSZ(p)) {
                   texiwarn(p, "unexpected EOF");
                   return;
           }
           end = *pos;
           advanceeoln(p, pos, 1);
   
           if (NULL != p->chapters)
                   teximdocclose(p, 0);
   
           /* Cache our node name. */
           p->nodecur = texicache(p, &BUF(p)[start], end - start);
   
           if (NULL != p->chapters) {
                   snprintf(fname, sizeof(fname),
                           "%s-%zd.7", p->chapters, p->nodecur);
                   p->outfile = fopen(fname, "w");
                   if (NULL == p->outfile)
                           texiabort(p, fname);
                   teximdocopen(p, pos);
           } else if (p->nodesz > 1) {
                   /* Otherwise, mark our index. */
                   p->seenvs = -1;
   #if HAVE_INDEX
                   teximacroopen(p, "Ix");
                   texiputchars(p, "node");
                   texiputchars(p, p->nodecache[p->nodecur].name);
                   teximacroclose(p);
   #endif
                   p->seenvs = sv;
           } else
                   teximdocopen(p, pos);
   }
   
   /*
    * This handles both menu and detailedmenu.
    * The syntax of these is fairly... unspecific, but what we do here
    * seems to work with most manuals.
    */
   static void
   domenu(struct texi *p, enum texicmd cmd, size_t *pos)
   {
           size_t           nodename, entryname;
           size_t           nodenameend, entrynameend, i;
           ssize_t          ppos, lastppos;
           char             buf[PATH_MAX];
           enum texicmd     tcmd;
   
           advanceeoln(p, pos, 1);
   
           /*
            * Parse past initial stuff.
            * TODO: the manual says we're supposed to make this in bold or
            * something.
            */
           while (*pos < BUFSZ(p)) {
                   while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
                           advance(p, pos);
                   if (*pos < BUFSZ(p) && '*' != BUF(p)[*pos]) {
                           if (TEXICMD_END == peeklinecmd(p, *pos))
                                   break;
                           parseeoln(p, pos);
                   } else
                           break;
           }
   
           lastppos = -1;
           texivspace(p);
           teximacro(p, "Bl -tag -width Ds -compact");
           while (*pos < BUFSZ(p)) {
                   /*
                    * Read to next menu item.
                    * We simply parse every line until we get a magic '*'.
                    * These lines might occur interspersed OR as the
                    * description of an entry.
                    * Either way it's in the `It' block.
                    */
                   if (0 == p->seenws)
                           p->seenws = *pos < BUFSZ(p) && isws(BUF(p)[*pos]);
                   while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
                           advance(p, pos);
                   if (*pos == BUFSZ(p)) {
                           texiwarn(p, "unexpected EOF");
                           return;
                   } else if ('*' != BUF(p)[*pos]) {
                           tcmd = peeklinecmd(p, *pos);
                           if (TEXICMD_END == tcmd)
                                   break;
                           else if (TEXICMD_COMMENT == tcmd)
                                   advanceeoln(p, pos, 1);
                           else
                                   parseeoln(p, pos);
                           continue;
                   }
   
                   /* Now we're parsing a menu item. */
                   advance(p, pos);
                   while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
                           advance(p, pos);
                   entryname = *pos;
                   while (*pos < BUFSZ(p) && ':' != BUF(p)[*pos])
                           advance(p, pos);
                   entrynameend = *pos;
                   if (*pos == BUFSZ(p)) {
                           texiwarn(p, "unexpected EOF");
                           return;
                   }
                   advance(p, pos);
   
                   p->seenvs = 0;
                   teximacroopen(p, "It");
                   if (*pos == BUFSZ(p)) {
                           texiwarn(p, "bad menu syntax");
                           break;
                   } else if (':' != BUF(p)[*pos]) {
                           while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
                                   advance(p, pos);
                           nodename = *pos;
                           while (*pos < BUFSZ(p)) {
                                   switch (BUF(p)[*pos]) {
                                   case ('\t'):
                                   case ('\n'):
                                   case (','):
                                           break;
                                   case ('.'):
                                           if (*pos + 1 == BUFSZ(p)) {
                                                   advance(p, pos);
                                                   continue;
                                           }
                                           if (' ' == BUF(p)[*pos + 1]) {
                                                   advance(p, pos);
                                                   break;
                                           }
                                           /* FALLTHROUGH */
                                   default:
                                           advance(p, pos);
                                           continue;
                                   }
                                   advance(p, pos);
                                   break;
                           }
                           nodenameend = *pos;
                   } else {
                           advance(p, pos);
                           nodename = entryname;
                           nodenameend = entrynameend;
                   }
                   ppos = texicache(p, &BUF(p)[nodename],
                           nodenameend - nodename);
                   if (-1 != lastppos)
                           p->nodecache[lastppos].next = ppos;
                   p->nodecache[ppos].prev = lastppos;
                   p->nodecache[ppos].up = p->nodecur;
                   lastppos = ppos;
   #ifdef HAVE_INDEX
                   if (NULL == p->chapters) {
                           teximacroopen(p, "Lkx");
                           texiputchars(p, "\"node");
                           for (i = nodename; i < nodenameend; i++)
                                   texiputchar(p, BUF(p)[i]);
                           texiputchars(p, "\" \"");
                           for (i = entryname; i < entrynameend; i++)
                                   texiputchar(p, BUF(p)[i]);
                           texiputchars(p, "\"");
                           teximacroclose(p);
                   } else {
                           snprintf(buf, sizeof(buf),
                                   "%s-%zd 7 ", p->chapters, ppos);
                           teximacroopen(p, "Xr");
                           texiputchars(p, buf);
                           texiputchars(p, "\"node");
                           for (i = nodename; i < nodenameend; i++)
                                   texiputchar(p, BUF(p)[i]);
                           texiputchars(p, "\" \"");
                           for (i = entryname; i < entrynameend; i++)
                                   texiputchar(p, BUF(p)[i]);
                           texiputchars(p, "\"");
                           teximacroclose(p);
                   }
   #else
                   for (i = entryname; i < entrynameend; i++)
                           texiputchar(p, BUF(p)[i]);
   #endif
                   teximacroclose(p);
           }
   
           advanceeoln(p, pos, 0);
           p->seenvs = 0;
           teximacro(p, "El");
           texivspace(p);
   }
   
   static void
   domath(struct texi *p, enum texicmd cmd, size_t *pos)
   {
   
           parsebracket(p, pos, 1);
   }
   
   static void
   dovalue(struct texi *p, enum texicmd cmd, size_t *pos)
   {
           size_t           start, end;
         char            *key, *val;          char            *key, *val;
         const char      *cp;          const char      *cp;
   
         if (TEXICMD_SET == cmd) {          if (TEXICMD_SET == cmd) {
                 while (*pos < sz && isws(buf[*pos]))                  while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
                         advance(p, buf, pos);                          advance(p, pos);
                 for (start = end = *pos; end < sz; end++)                  for (start = end = *pos; end < BUFSZ(p); end++)
                         if (ismspace(buf[end]))                          if (ismspace(BUF(p)[end]))
                                 break;                                  break;
                 /* We don't allow empty keys. */                  /* We don't allow empty keys. */
                 if (start == end)                  if (start == end)
                         return;                          return;
                 advanceto(p, buf, pos, end);                  advanceto(p, pos, end);
   
                 key = malloc(end - start + 1);                  key = malloc(end - start + 1);
                 if (NULL == key)                  if (NULL == key)
                         texiabort(p, NULL);                          texiabort(p, NULL);
                 memcpy(key, &buf[start], end - start);                  memcpy(key, &BUF(p)[start], end - start);
                 key[end - start] = '\0';                  key[end - start] = '\0';
   
                 while (*pos < sz && isws(buf[*pos]))                  while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
                         advance(p, buf, pos);                          advance(p, pos);
                 for (start = end = *pos; end < sz; end++)                  for (start = end = *pos; end < BUFSZ(p); end++)
                         if ('\n' == buf[end])                          if ('\n' == BUF(p)[end])
                                 break;                                  break;
                 /* We do allow empty values. */                  /* We do allow empty values. */
                 advanceeoln(p, buf, sz, pos, 1);                  advanceeoln(p, pos, 1);
   
                 val = malloc(end - start + 1);                  val = malloc(end - start + 1);
                 if (NULL == val)                  if (NULL == val)
                         texiabort(p, NULL);                          texiabort(p, NULL);
                 memcpy(val, &buf[start], end - start);                  memcpy(val, &BUF(p)[start], end - start);
                 val[end - start] = '\0';                  val[end - start] = '\0';
                 valueadd(p, key, val);                  valueadd(p, key, val);
         } else if (TEXICMD_VALUE == cmd) {          } else if (TEXICMD_VALUE == cmd) {
                 if (p->seenws)                  if (p->seenws)
                         texiputchar(p, ' ');                          texiputchar(p, ' ');
                 p->seenws = 0;                  p->seenws = 0;
                 if (NULL != (cp = valueblookup(p, buf, sz, pos))) {                  if (NULL != (cp = valueblookup(p, pos)))
                         for (i = 0; i < p->valstackpos; i++)                          texisplice(p, cp, strlen(cp), *pos);
                                 if (cp == p->valstack[i])                  else
                                         break;  
                         if (i < p->valstackpos)  
                                 texierr(p, "recursive value");  
                         if (64 == p->valstackpos)  
                                 texierr(p, "too many nested values");  
                         p->valstack[p->valstackpos++] = cp;  
                         parsemembuf(p, cp, strlen(cp));  
                         p->valstackpos--;  
                 } else  
                         texiputchars(p, "{No value}");                          texiputchars(p, "{No value}");
         } else if (TEXICMD_IFCLEAR == cmd) {          } else if (TEXICMD_IFCLEAR == cmd) {
                 if (NULL != valuellookup(p, buf, sz, pos))                  if (NULL != valuellookup(p, pos))
                         doignblock(p, cmd, buf, sz, pos);                          doignblock(p, cmd, pos);
                 else                  else
                         parseto(p, buf, sz, pos, texitoks[cmd].tok);                          parseto(p, pos, texitoks[cmd].tok);
         } else if (TEXICMD_IFSET == cmd) {          } else if (TEXICMD_IFSET == cmd) {
                 if (NULL == valuellookup(p, buf, sz, pos))                  if (NULL == valuellookup(p, pos))
                         doignblock(p, cmd, buf, sz, pos);                          doignblock(p, cmd,  pos);
                 else                  else
                         parseto(p, buf, sz, pos, texitoks[cmd].tok);                          parseto(p, pos, texitoks[cmd].tok);
         } else if (TEXICMD_CLEAR == cmd)          } else if (TEXICMD_CLEAR == cmd)
                 valuelclear(p, buf, sz, pos);                  valuelclear(p, pos);
 }  }
   
 static void  static void
 dolink(struct texi *p, enum texicmd cmd,  dolink(struct texi *p, enum texicmd cmd, size_t *pos)
         const char *buf, size_t sz, size_t *pos)  
 {  {
         int      c;          int      c;
   
Line 1208  dolink(struct texi *p, enum texicmd cmd, 
Line 1909  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):
Line 1226  dolink(struct texi *p, enum texicmd cmd, 
Line 1928  dolink(struct texi *p, enum texicmd cmd, 
                 abort();                  abort();
         }          }
   
         c = parsearg(p, buf, sz, pos, 0);          c = parsearg(p, pos, 0);
         p->ign++;          p->ign++;
         while (c > 0)          while (c > 0)
                 c = parsearg(p, buf, sz, pos, 1);                  c = parsearg(p, pos, 1);
         p->ign--;          p->ign--;
   
         texipunctuate(p, buf, sz, pos);          texipunctuate(p, pos);
         teximacroclose(p);          teximacroclose(p);
 }  }
   
 static void  static void
 doignargn(struct texi *p, enum texicmd cmd,  doignargn(struct texi *p, enum texicmd cmd, size_t *pos)
         const char *buf, size_t sz, size_t *pos)  
 {  {
         int      c;          int      c;
   
         c = parsearg(p, buf, sz, pos, 0);          c = parsearg(p, pos, 0);
         p->ign++;          p->ign++;
         while (c > 0)          while (c > 0)
                 c = parsearg(p, buf, sz, pos, 1);                  c = parsearg(p, pos, 1);
         p->ign--;          p->ign--;
 }  }
   
Line 1270  sectioner(struct texi *p, int sec)
Line 1971  sectioner(struct texi *p, int sec)
 }  }
   
 static void  static void
 dosubsubsection(struct texi *p, enum texicmd cmd,  dosecoffs(struct texi *p, enum texicmd cmd, size_t *pos)
                 const char *buf, size_t sz, size_t *pos)  
 {  {
         int      sec;  
   
         sec = sectioner(p, 3);  
   
         /* We don't have a subsubsubsection, so make one up. */  
         texivspace(p);  
         teximacroopen(p, sects[sec]);  
         parseeoln(p, buf, sz, pos);  
         teximacroclose(p);  
         texivspace(p);  
 }  
   
 static void  
 dosubsection(struct texi *p, enum texicmd cmd,  
                 const char *buf, size_t sz, size_t *pos)  
 {  
         int      sec;  
   
         sec = sectioner(p, 2);  
   
         if (p->outmacro)  
                 texierr(p, "\"%s\" in open line scope!?", sects[sec]);  
         else if (p->literal)  
                 texierr(p, "\"%s\" in a literal scope!?", sects[sec]);  
   
         /* We don't have a subsubsection, so make one up. */  
         if (sec > 1)  
                 texivspace(p);  
         teximacroopen(p, sects[sec]);  
         parseeoln(p, buf, sz, pos);  
         teximacroclose(p);  
         if (sec > 1)  
                 texivspace(p);  
 }  
   
 static void  
 dosecoffs(struct texi *p, enum texicmd cmd,  
         const char *buf, size_t sz, size_t *pos)  
 {  
   
         if (TEXICMD_RAISESECTIONS == cmd)          if (TEXICMD_RAISESECTIONS == cmd)
                 p->secoffs++;                  p->secoffs++;
         else          else
Line 1320  dosecoffs(struct texi *p, enum texicmd cmd, 
Line 1981  dosecoffs(struct texi *p, enum texicmd cmd, 
 }  }
   
 static void  static void
 dosection(struct texi *p, enum texicmd cmd,  dosection(struct texi *p, enum texicmd cmd, size_t *pos)
         const char *buf, size_t sz, size_t *pos)  
 {  {
         int              sec;          int              sec;
   
         switch (cmd) {          switch (cmd) {
           case (TEXICMD_TOP):
                   sec = 0;
                   break;
         case (TEXICMD_APPENDIX):          case (TEXICMD_APPENDIX):
         case (TEXICMD_CHAPTER):          case (TEXICMD_CHAPTER):
         case (TEXICMD_TOP):  
         case (TEXICMD_UNNUMBERED):          case (TEXICMD_UNNUMBERED):
                 sec = sectioner(p, 0);                  sec = sectioner(p, 0);
                 break;                  break;
Line 1338  dosection(struct texi *p, enum texicmd cmd, 
Line 2000  dosection(struct texi *p, enum texicmd cmd, 
         case (TEXICMD_UNNUMBEREDSEC):          case (TEXICMD_UNNUMBEREDSEC):
                 sec = sectioner(p, 1);                  sec = sectioner(p, 1);
                 break;                  break;
           case (TEXICMD_APPENDIXSUBSEC):
           case (TEXICMD_SUBHEADING):
           case (TEXICMD_SUBSECTION):
           case (TEXICMD_UNNUMBEREDSUBSEC):
                   sec = sectioner(p, 2);
                   break;
           case (TEXICMD_APPENDIXSUBSUBSEC):
           case (TEXICMD_SUBSUBHEADING):
           case (TEXICMD_SUBSUBSECTION):
           case (TEXICMD_UNNUMBEREDSUBSUBSEC):
                   sec = sectioner(p, 3);
                   break;
         default:          default:
                 abort();                  abort();
         }          }
Line 1347  dosection(struct texi *p, enum texicmd cmd, 
Line 2021  dosection(struct texi *p, enum texicmd cmd, 
         else if (p->literal)          else if (p->literal)
                 texierr(p, "\"%s\" in a literal scope!?", sects[sec]);                  texierr(p, "\"%s\" in a literal scope!?", sects[sec]);
   
           if (sec < 2)
                   p->seenvs = -1;
           else
                   texivspace(p);
   
         teximacroopen(p, sects[sec]);          teximacroopen(p, sects[sec]);
         parseeoln(p, buf, sz, pos);          parseeoln(p, pos);
         teximacroclose(p);          teximacroclose(p);
         p->seenvs = 1;  
           if (sec < 2)
                   p->seenvs = -1;
           else
                   texivspace(p);
 }  }
   
 static void  static void
 dosp(struct texi *p, enum texicmd cmd,  dosp(struct texi *p, enum texicmd cmd, size_t *pos)
         const char *buf, size_t sz, size_t *pos)  
 {  {
   
           advanceeoln(p, pos, 1);
         if (p->literal)          if (p->literal)
                 texiputchar(p, '\n');                  texiputchar(p, '\n');
         else          else
                 texivspace(p);                  texivspace(p);
         /* FIXME: ignore and parseeoln. */  
         advanceeoln(p, buf, sz, pos, 1);  
 }  }
   
 static void  static void
 dotop(struct texi *p, enum texicmd cmd,  doitem(struct texi *p, enum texicmd cmd, size_t *pos)
         const char *buf, size_t sz, size_t *pos)  
 {  {
         const char      *cp;  
         time_t           t;  
         char             date[32];  
   
         if (--p->ign)  
                 texierr(p, "@top command while ignoring (%d)", p->ign);  
   
         /*  
          * 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);  
         strftime(date, sizeof(date), "%F", localtime(&t));  
   
         teximacroopen(p, "Dd");  
         texiputchars(p, date);  
         teximacroclose(p);  
         teximacroopen(p, "Dt");  
         for (cp = p->title; '\0' != *cp; cp++)  
                 texiputchar(p, toupper(*cp));  
         texiputchars(p, " 7");  
         teximacroclose(p);  
         teximacro(p, "Os");  
         teximacro(p, "Sh NAME");  
         teximacroopen(p, "Nm");  
         texiputchars(p, p->title);  
         teximacroclose(p);  
         teximacroopen(p, "Nd");  
         texiputchars(p, NULL != p->subtitle ?  
                 p->subtitle : "Unknown description");  
         teximacroclose(p);  
         p->seenvs = 1;  
         dosection(p, cmd, buf, sz, pos);  
 }  
   
 static void  
 doitem(struct texi *p, enum texicmd cmd,  
         const char *buf, size_t sz, size_t *pos)  
 {  
   
         /* Multitable is using raw tbl(7). */          /* Multitable is using raw tbl(7). */
         if (TEXILIST_TABLE == p->list) {          if (TEXILIST_TABLE == p->list) {
                 texiputchar(p, '\n');                  if (p->outcol > 0)
                           texiputchar(p, '\n');
                 return;                  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 1426  doitem(struct texi *p, enum texicmd cmd, 
Line 2065  doitem(struct texi *p, enum texicmd cmd, 
   
         switch (p->list) {          switch (p->list) {
         case (TEXILIST_ITEM):          case (TEXILIST_ITEM):
                   p->seenvs = -1;
                 teximacroopen(p, "It");                  teximacroopen(p, "It");
                 break;                  break;
         case (TEXILIST_NOITEM):          case (TEXILIST_NOITEM):
                   p->seenvs = -1;
                 teximacro(p, "It");                  teximacro(p, "It");
                 break;                  break;
         default:          default:
Line 1437  doitem(struct texi *p, enum texicmd cmd, 
Line 2078  doitem(struct texi *p, enum texicmd cmd, 
         }          }
   
         /* Trick so we don't start with Pp. */          /* Trick so we don't start with Pp. */
         p->seenvs = 1;          parseeoln(p, pos);
         parseeoln(p, buf, sz, pos);  
   
         if (TEXILIST_ITEM == p->list)          if (TEXILIST_ITEM == p->list)
                 teximacroclose(p);                  teximacroclose(p);
Line 1447  doitem(struct texi *p, enum texicmd cmd, 
Line 2087  doitem(struct texi *p, enum texicmd cmd, 
 }  }
   
 static void  static void
 dotab(struct texi *p, enum texicmd cmd,  dotab(struct texi *p, enum texicmd cmd, size_t *pos)
         const char *buf, size_t sz, size_t *pos)  
 {  {
   
         /* This command is only useful in @multitable. */          /* This command is only useful in @multitable. */
         if (TEXILIST_TABLE == p->list)          if (TEXILIST_TABLE == p->list && p->outcol)
                 texiputchar(p, '\t');                  texiputchar(p, '\t');
 }  }
   
 static void  static void
 domultitable(struct texi *p, enum texicmd cmd,  domultitable(struct texi *p, enum texicmd cmd, size_t *pos)
         const char *buf, size_t sz, size_t *pos)  
 {  {
         enum texilist   sv = p->list;          enum texilist   sv = p->list;
         int             svliteral = p->literal;          int             svliteral = p->literal;
         enum texicmd    type;          enum texicmd    type;
         size_t          i, end, columns;          size_t          i, end, columns;
   
           texivspace(p);
         p->list = TEXILIST_TABLE;          p->list = TEXILIST_TABLE;
         /*          /*
          * TS/TE blocks aren't "in mdoc(7)", so we can disregard the           * TS/TE blocks aren't "in mdoc(7)", so we can disregard the
          * fact that we're in literal mode right now.           * fact that we're in literal mode right now.
          */           */
Line 1475  domultitable(struct texi *p, enum texicmd cmd, 
Line 2114  domultitable(struct texi *p, enum texicmd cmd, 
         columns = 0;          columns = 0;
   
         /* Advance to the first argument... */          /* Advance to the first argument... */
         while (*pos < sz && isws(buf[*pos]))          while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
                 advance(p, buf, pos);                  advance(p, pos);
   
         /* Make sure we don't print anything when scanning. */          /* Make sure we don't print anything when scanning. */
         p->ign++;          p->ign++;
         if ('@' == buf[*pos]) {          if (*pos < BUFSZ(p) && '@' == BUF(p)[*pos]) {
                 /*                  /*
                  * Look for @columnfractions.                   * Look for @columnfractions.
                  * We ignore these, but we do use the number of                   * We ignore these, but we do use the number of
                  * arguments to set the number of columns that we'll                   * arguments to set the number of columns that we'll
                  * have.                   * have.
                  */                   */
                 type = texicmd(p, buf, *pos, sz, &end, NULL);                  type = texicmd(p, *pos, &end, NULL);
                 advanceto(p, buf, pos, end);                  advanceto(p, pos, end);
                 if (TEXICMD_COLUMNFRACTIONS != type)                  if (TEXICMD_COLUMNFRACTIONS != type)
                         texierr(p, "unknown multitable command");                          texierr(p, "unknown multitable command");
                 while (*pos < sz && '\n' != buf[*pos]) {                  while (*pos < BUFSZ(p) && '\n' != BUF(p)[*pos]) {
                         while (*pos < sz && isws(buf[*pos]))                          while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
                                 advance(p, buf, pos);                                  advance(p, pos);
                         while (*pos < sz && ! isws(buf[*pos])) {                          while (*pos < BUFSZ(p) && ! isws(BUF(p)[*pos])) {
                                 if ('\n' == buf[*pos])                                  if ('\n' == BUF(p)[*pos])
                                         break;                                          break;
                                 advance(p, buf, pos);                                  advance(p, pos);
                         }                          }
                         columns++;                          columns++;
                 }                  }
         } else          } else
                 /*                  /*
                  * We have arguments.                   * We have arguments.
                  * We could parse these, but it's easier to just let                   * We could parse these, but it's easier to just let
                  * tbl(7) figure it out.                   * tbl(7) figure it out.
                  * So use this only to count arguments.                   * So use this only to count arguments.
                  */                   */
                 while (parselinearg(p, buf, sz, pos) > 0)                  while (parselinearg(p, pos) > 0)
                         columns++;                          columns++;
         p->ign--;          p->ign--;
   
Line 1518  domultitable(struct texi *p, enum texicmd cmd, 
Line 2157  domultitable(struct texi *p, enum texicmd cmd, 
                         texiputchar(p, ' ');                          texiputchar(p, ' ');
                 texiputchar(p, 'l');                  texiputchar(p, 'l');
         }          }
         texiputchars(p, ".\n");  
           texiputchar(p, '.');
           texiputchar(p, '\n');
         p->outmacro++;          p->outmacro++;
         parseto(p, buf, sz, pos, texitoks[cmd].tok);          parseto(p, pos, texitoks[cmd].tok);
         p->outmacro--;          p->outmacro--;
         teximacro(p, "TE");          teximacro(p, "TE");
         p->literal = svliteral;          p->literal = svliteral;
         p->list = sv;          p->list = sv;
           texivspace(p);
 }  }
   
 static void  static void
 dotable(struct texi *p, enum texicmd cmd,  dotable(struct texi *p, enum texicmd cmd, size_t *pos)
         const char *buf, size_t sz, size_t *pos)  
 {  {
         enum texilist   sv = p->list;          enum texilist   sv = p->list;
   
           advanceeoln(p, pos, 1);
   
         p->list = TEXILIST_ITEM;          p->list = TEXILIST_ITEM;
         teximacro(p, "Bl -tag -width Ds");          texivspace(p);
         /* FIXME: ignore and parseeoln. */          teximacro(p, "Bl -tag -width Ds -compact");
         advanceeoln(p, buf, sz, pos, 1);          parseto(p, pos, texitoks[cmd].tok);
         p->seenvs = 1;          p->seenvs = 0;
         parseto(p, buf, sz, pos, texitoks[cmd].tok);  
         teximacro(p, "El");          teximacro(p, "El");
           texivspace(p);
         p->list = sv;          p->list = sv;
 }  }
   
 static void  static void
 doenumerate(struct texi *p, enum texicmd cmd,  doend(struct texi *p, enum texicmd cmd, size_t *pos)
         const char *buf, size_t sz, size_t *pos)  
 {  {
           size_t   start;
   
           while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
                   advance(p, pos);
           start = *pos;
           while (*pos < BUFSZ(p) && '\n' != BUF(p)[*pos])
                   advance(p, pos);
   
           texiwarn(p, "unexpected \"end\": %.*s",
                   (int)(*pos - start), &BUF(p)[start]);
           advanceeoln(p, pos, 1);
   }
   
   static void
   doenumerate(struct texi *p, enum texicmd cmd, size_t *pos)
   {
         enum texilist    sv = p->list;          enum texilist    sv = p->list;
   
           advanceeoln(p, pos, 1);
   
         p->list = TEXILIST_NOITEM;          p->list = TEXILIST_NOITEM;
         teximacro(p, "Bl -enum");          texivspace(p);
         p->seenvs = 1;          teximacro(p, "Bl -enum -compact");
         /* FIXME: ignore and parseeoln. */          parseto(p, pos, texitoks[cmd].tok);
         advanceeoln(p, buf, sz, pos, 1);          p->seenvs = 0;
         parseto(p, buf, sz, pos, "enumerate");  
         teximacro(p, "El");          teximacro(p, "El");
           texivspace(p);
         p->list = sv;          p->list = sv;
 }  }
   
 static void  static void
 doitemize(struct texi *p, enum texicmd cmd,  doitemize(struct texi *p, enum texicmd cmd, size_t *pos)
         const char *buf, size_t sz, size_t *pos)  
 {  {
         enum texilist   sv = p->list;          enum texilist   sv = p->list;
   
           advanceeoln(p, pos, 1);
   
         p->list = TEXILIST_NOITEM;          p->list = TEXILIST_NOITEM;
         teximacro(p, "Bl -bullet");          texivspace(p);
         p->seenvs = 1;          teximacro(p, "Bl -bullet -compact");
         /* FIXME: ignore and parseeoln. */          parseto(p, pos, texitoks[cmd].tok);
         advanceeoln(p, buf, sz, pos, 1);          p->seenvs = 0;
         parseto(p, buf, sz, pos, "itemize");  
         teximacro(p, "El");          teximacro(p, "El");
           texivspace(p);
         p->list = sv;          p->list = sv;
 }  }
   
 static void  static void
 doignbracket(struct texi *p, enum texicmd cmd,  doignbracket(struct texi *p, enum texicmd cmd, size_t *pos)
         const char *buf, size_t sz, size_t *pos)  
 {  {
   
         p->ign++;          p->ign++;
         parsebracket(p, buf, sz, pos);          parsebracket(p, pos, 0);
         p->ign--;          p->ign--;
 }  }
   
 static void  static void
 doignline(struct texi *p, enum texicmd cmd,  doindex(struct texi *p, enum texicmd cmd, size_t *pos)
         const char *buf, size_t sz, size_t *pos)  
 {  {
           size_t   start, end, len;
   
         /* FIXME: ignore and parseeoln. */          while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
         advanceeoln(p, buf, sz, pos, 1);                  advance(p, pos);
   
           start = *pos;
           while (*pos < BUFSZ(p) && '\n' != BUF(p)[*pos])
                   advance(p, pos);
   
           if (*pos == BUFSZ(p)) {
                   texiwarn(p, "unexpected EOF");
                   return;
           }
   
           advance(p, pos);
           end = *pos;
           if (0 == (len = end - start)) {
                   texiwarn(p, "zero-length index");
                   return;
           }
   
           /* Two-letter combos we can look up verbatim. */
           if (7 == texitoks[cmd].len) {
                   texindex(p, texitoks[cmd].tok, 2, &BUF(p)[start], len);
                   return;
           }
   
           assert(6 == texitoks[cmd].len);
           /* Newer one-letter combos need to be mapped. */
           switch (texitoks[cmd].tok[0]) {
           case ('c'):
                   texindex(p, "cp", 2, &BUF(p)[start], len);
                   break;
           case ('v'):
                   texindex(p, "vr", 2, &BUF(p)[start], len);
                   break;
           case ('f'):
                   texindex(p, "fn", 2, &BUF(p)[start], len);
                   break;
           case ('t'):
                   texindex(p, "tp", 2, &BUF(p)[start], len);
                   break;
           default:
                   abort();
           }
 }  }
   
   static void
   doignline(struct texi *p, enum texicmd cmd, size_t *pos)
   {
   
           advanceeoln(p, pos, 1);
   }
   
 /*  /*
  * 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 **
 parsedirs(struct texi *p, const char *base, const char *cp, size_t *sz)  parsedirs(struct texi *p, const char *base, const char *cp, size_t *sz)
 {  {
         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);
   
         free(tofree);          free(tofree);
Line 1636  int
Line 2345  int
 main(int argc, char *argv[])  main(int argc, char *argv[])
 {  {
         struct texi      texi;          struct texi      texi;
         int              c;          char             date[32];
           struct stat      st;
         char            *dirpath, *dir, *ccp;          char            *dirpath, *dir, *ccp;
         const char      *progname, *Idir, *cp;          const char      *progname, *Idir, *cp;
           time_t           t;
           int              c;
   
         progname = strrchr(argv[0], '/');          progname = strrchr(argv[0], '/');
         if (progname == NULL)          if (progname == NULL)
Line 1647  main(int argc, char *argv[])
Line 2359  main(int argc, char *argv[])
                 ++progname;                  ++progname;
   
         memset(&texi, 0, sizeof(struct texi));          memset(&texi, 0, sizeof(struct texi));
           texi.ign = 1;
           texi.outfile = stdout;
           texi.seenvs = -1;
         Idir = NULL;          Idir = NULL;
   
         while (-1 != (c = getopt(argc, argv, "I:")))          while (-1 != (c = getopt(argc, argv, "C:d:I:")))
                 switch (c) {                  switch (c) {
                   case ('C'):
                           texi.chapters = optarg;
                           break;
                   case ('d'):
                           texi.date = optarg;
                           break;
                 case ('I'):                  case ('I'):
                         Idir = optarg;                          Idir = optarg;
                         break;                          break;
Line 1659  main(int argc, char *argv[])
Line 2380  main(int argc, char *argv[])
                 }                  }
   
         argv += optind;          argv += optind;
         if (0 == (argc -= optind))          argc -= optind;
                 goto usage;  
   
         if (NULL == (dirpath = strdup(argv[0])))          /* Add the default Texinfo indices. */
                 texiabort(&texi, NULL);          texindex_add(&texi, "cp", 2);
         if (NULL == (dir = dirname(dirpath)))          texindex_add(&texi, "vr", 2);
                 texiabort(&texi, NULL);          texindex_add(&texi, "tp", 2);
           texindex_add(&texi, "fn", 2);
   
         if (NULL != (cp = strrchr(argv[0], '/')))          if (argc > 0) {
                 texi.title = strdup(cp + 1);                  if (NULL == (dirpath = strdup(argv[0])))
         else                          texiabort(&texi, NULL);
                 texi.title = strdup(argv[0]);                  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);
                   if (NULL == texi.date) {
                           t = stat(argv[0], &st) == 0 ? st.st_mtime : time(NULL);
                           strftime(date, sizeof(date),
                                "%B %e, %Y", localtime(&t));
                           texi.date = date;
                   }
                   parsefile(&texi, argv[0], 1);
           } else {
                   texi.title = strdup("Unknown Manual");
                   texi.dirs = parsedirs(&texi, NULL, Idir, &texi.dirsz);
                   if (NULL == texi.date) {
                           t = time(NULL);
                           strftime(date, sizeof(date),
                                "%B %e, %Y", localtime(&t));
                           texi.date = date;
                   }
                   parsestdin(&texi);
           }
   
         if (NULL == texi.title)  
                 texiabort(&texi, NULL);  
         else if (NULL != (ccp = strchr(texi.title, '.')))  
                 *ccp = '\0';  
   
         texi.ign = 1;  
         texi.dirs = parsedirs(&texi, dir, Idir, &texi.dirsz);  
         free(dirpath);  
         parsefile(&texi, argv[0], 1);  
         /* We shouldn't get here. */  
         texiexit(&texi);          texiexit(&texi);
         return(EXIT_FAILURE);          exit(EXIT_SUCCESS);
 usage:  usage:
         fprintf(stderr, "usage: %s [-Idirs] file\n", progname);          fprintf(stderr, "usage: %s [-C dir] [-d date] [-I dirs] [file]\n",
               progname);
         return(EXIT_FAILURE);          return(EXIT_FAILURE);
 }  }
Legend:
Removed from v.1.39  
changed lines
  Added in v.1.72
CVSweb