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

Diff for /texi2mdoc/main.c between version 1.1.1.1 and 1.64

version 1.1.1.1, 2015/02/16 22:24:43 version 1.64, 2015/03/07 11:49:32
Line 14 
Line 14 
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF   * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.   * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */   */
 #include <sys/mman.h>  #if defined(__linux__) || defined(__MINT__)
 #include <sys/stat.h>  # define _GNU_SOURCE /* memmem */
   #endif
 #include <assert.h>  #include <assert.h>
 #include <ctype.h>  #include <ctype.h>
 #include <fcntl.h>  
 #include <getopt.h>  #include <getopt.h>
   #include <libgen.h>
   #include <limits.h>
 #include <stdarg.h>  #include <stdarg.h>
 #include <stdio.h>  #include <stdio.h>
 #include <stdlib.h>  #include <stdlib.h>
 #include <string.h>  #include <string.h>
   #include <unistd.h>
   
 /*  #include "extern.h"
  * This defines each one of the Texinfo commands that we understand.  
  * Obviously this only refers to native commands; overriden names are a  
  * different story.  
  */  
 enum    texicmd {  
         TEXICMD_A4PAPER,  
         TEXICMD_ANCHOR,  
         TEXICMD_AT,  
         TEXICMD_BYE,  
         TEXICMD_CHAPTER,  
         TEXICMD_CINDEX,  
         TEXICMD_CODE,  
         TEXICMD_COMMAND,  
         TEXICMD_COMMENT,  
         TEXICMD_CONTENTS,  
         TEXICMD_COPYING,  
         TEXICMD_COPYRIGHT,  
         TEXICMD_DETAILMENU,  
         TEXICMD_DIRCATEGORY,  
         TEXICMD_DIRENTRY,  
         TEXICMD_EMAIL,  
         TEXICMD_EMPH,  
         TEXICMD_END,  
         TEXICMD_EXAMPLE,  
         TEXICMD_FILE,  
         TEXICMD_I,  
         TEXICMD_IFHTML,  
         TEXICMD_IFNOTTEX,  
         TEXICMD_IFTEX,  
         TEXICMD_IMAGE,  
         TEXICMD_ITEM,  
         TEXICMD_ITEMIZE,  
         TEXICMD_KBD,  
         TEXICMD_LATEX,  
         TEXICMD_MENU,  
         TEXICMD_NODE,  
         TEXICMD_QUOTATION,  
         TEXICMD_PARINDENT,  
         TEXICMD_REF,  
         TEXICMD_SAMP,  
         TEXICMD_SECTION,  
         TEXICMD_SETCHAPNEWPAGE,  
         TEXICMD_SETFILENAME,  
         TEXICMD_SETTITLE,  
         TEXICMD_SUBSECTION,  
         TEXICMD_TABLE,  
         TEXICMD_TEX,  
         TEXICMD_TEXSYM,  
         TEXICMD_TITLEFONT,  
         TEXICMD_TITLEPAGE,  
         TEXICMD_TOP,  
         TEXICMD_UNNUMBERED,  
         TEXICMD_URL,  
         TEXICMD_VAR,  
         TEXICMD__MAX  
 };  
   
 /*  #define SECTSZ 4
  * The file currently being parsed.  static  const char *const sects[SECTSZ] = {
  * This keeps track of our location within that file.          "Sh",
  */          "Ss",
 struct  texifile {          "Em",
         const char      *name; /* name of the file */          "No",
         size_t           line; /* current line (from zero) */  
         size_t           col; /* current column in line (from zero) */  
         char            *map; /* mmap'd file */  
         size_t           mapsz; /* size of mmap */  
 };  };
   
 struct  texi;  static  void doaccent(struct texi *, enum texicmd, size_t *);
   static  void doblock(struct texi *, enum texicmd, size_t *);
   static  void dobracket(struct texi *, enum texicmd, size_t *);
   static  void dobye(struct texi *, enum texicmd, size_t *);
   static  void docopying(struct texi *, enum texicmd, size_t *);
   static  void dodefindex(struct texi *, enum texicmd, size_t *);
   static  void dodefn(struct texi *, enum texicmd, size_t *);
   static  void dodisplay(struct texi *, enum texicmd, size_t *);
   static  void doend(struct texi *, enum texicmd, size_t *);
   static  void doenumerate(struct texi *, enum texicmd, size_t *);
   static  void doexample(struct texi *, enum texicmd, size_t *);
   static  void doignargn(struct texi *, enum texicmd, size_t *);
   static  void doignblock(struct texi *, enum texicmd, size_t *);
   static  void doignbracket(struct texi *, enum texicmd, size_t *);
   static  void doignline(struct texi *, enum texicmd, size_t *);
   static  void doinline(struct texi *, enum texicmd, size_t *);
   static  void doinclude(struct texi *, enum texicmd, size_t *);
   static  void doinsertcopying(struct texi *, enum texicmd, size_t *);
   static  void doitem(struct texi *, enum texicmd, size_t *);
   static  void doitemize(struct texi *, enum texicmd, size_t *);
   static  void dolink(struct texi *, enum texicmd, size_t *);
   static  void domacro(struct texi *, enum texicmd, size_t *);
   static  void domath(struct texi *, enum texicmd, size_t *);
   #if 0
   static  void domenu(struct texi *, enum texicmd, size_t *);
   #endif
   static  void domultitable(struct texi *, enum texicmd, size_t *);
   static  void doquotation(struct texi *, enum texicmd, size_t *);
   static  void dotable(struct texi *, enum texicmd, size_t *);
   static  void dotop(struct texi *, enum texicmd, size_t *);
   static  void dosecoffs(struct texi *, enum texicmd, size_t *);
   static  void dosection(struct texi *, enum texicmd, size_t *);
   static  void dosp(struct texi *, enum texicmd, size_t *);
   static  void dosubsection(struct texi *, enum texicmd, size_t *);
   static  void dosubsubsection(struct texi *, enum texicmd, size_t *);
   static  void dosymbol(struct texi *, enum texicmd, size_t *);
   static  void dotab(struct texi *, enum texicmd, 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 *);
   
 typedef void (*texicmdfp)(struct texi *,  static  const struct texitok __texitoks[TEXICMD__MAX] = {
         enum texicmd, const char *, size_t, size_t *);          /* TEXICMD__BEGIN */
   
 /*  
  * Describes Texinfo commands, whether native or overriden.  
  */  
 struct  texitok {  
         texicmdfp        fp; /* callback (or NULL if none) */  
         const char      *tok; /* name of the token */  
         size_t           len; /* strlen(tok) */  
 };  
   
 /*  
  * The main parse structure.  
  * This keeps any necessary information handy.  
  */  
 struct  texi {  
         struct texifile  files[64];  
         size_t           filepos;  
         unsigned         flags;  
 #define TEXI_IGN         0x01 /* don't print anything */  
 #define TEXI_HEADER     (TEXI_IGN | 0x02) /* haven't seen @top yet */  
 #define TEXI_LITERAL     0x04 /* output all whitespace */  
         size_t           outcol; /* column of output */  
         int              outmacro; /* whether output is in line macro */  
         int              seenws; /* whitespace has been ignored */  
 };  
   
 #define ismpunct(_x) \  
         ('.' == (_x) || \  
          ',' == (_x) || \  
          ';' == (_x))  
   
 static  void doarg1(struct texi *, enum texicmd, const char *, size_t, size_t *);  
 static  void dobracket(struct texi *, enum texicmd, const char *, size_t, size_t *);  
 static  void dobye(struct texi *, enum texicmd, const char *, size_t, size_t *);  
 static  void docommand(struct texi *, enum texicmd, const char *, size_t, size_t *);  
 static  void doemph(struct texi *, enum texicmd, const char *, size_t, size_t *);  
 static  void doexample(struct texi *, enum texicmd, const char *, size_t, size_t *);  
 static  void dofile(struct texi *, enum texicmd, const char *, size_t, size_t *);  
 static  void doifnottex(struct texi *, enum texicmd, const char *, size_t, size_t *);  
 static  void doignblock(struct texi *, enum texicmd, const char *, size_t, size_t *);  
 static  void doignbracket(struct texi *, enum texicmd, const char *, size_t, size_t *);  
 static  void doignline(struct texi *, enum texicmd, const char *, size_t, size_t *);  
 static  void doitalic(struct texi *, enum texicmd, const char *, size_t, size_t *);  
 static  void doitem(struct texi *, enum texicmd, const char *, size_t, size_t *);  
 static  void doitemize(struct texi *, enum texicmd, const char *, size_t, size_t *);  
 static  void doliteral(struct texi *, enum texicmd, const char *, size_t, size_t *);  
 static  void doquotation(struct texi *, enum texicmd, const char *, size_t, size_t *);  
 static  void dotable(struct texi *, enum texicmd, const char *, size_t, size_t *);  
 static  void dotop(struct texi *, enum texicmd, const char *, size_t, size_t *);  
 static  void dosection(struct texi *, enum texicmd, const char *, size_t, size_t *);  
 static  void dosh(struct texi *, enum texicmd, const char *, size_t, size_t *);  
 static  void dosubsection(struct texi *, enum texicmd, const char *, size_t, size_t *);  
 static  void dosymbol(struct texi *, enum texicmd, const char *, size_t, size_t *);  
   
 static  const struct texitok texitoks[TEXICMD__MAX] = {  
         { doignline, "afourpaper", 10 }, /* TEXICMD_A4PAPER */          { doignline, "afourpaper", 10 }, /* TEXICMD_A4PAPER */
           { dosymbol, "AA", 2 }, /* TEXICMD_AA */
           { dosymbol, "aa", 2 }, /* TEXICMD_AASMALL */
           { doignargn, "acronym", 7 }, /* TEXICMD_ACRONYM */
           { doaccent, "'", 1 }, /* TEXICMD_ACUTE */
           { 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, "appendixsec", 11 }, /* TEXICMD_APPENDIXSEC */
           { dosubsection, "appendixsubsec", 14 }, /* TEXICMD_APPENDIXSUBSEC */
           { dosubsubsection, "appendixsubsubsec", 17 }, /* TEXICMD_APPENDIXSUBSUBSEC */
           { doinline, "asis", 4 }, /* TEXICMD_ASIS */
           { dosymbol, "*", 1 }, /* TEXICMD_ASTERISK */
         { dosymbol, "@", 1 }, /* TEXICMD_AT */          { dosymbol, "@", 1 }, /* TEXICMD_AT */
           { doignline, "author", 6 }, /* TEXICMD_AUTHOR */
           { doinline, "b", 1 }, /* TEXICMD_B */
           { dosymbol, "\\", 1 }, /* TEXICMD_BACKSLASH */
           { dosymbol, "!", 1 }, /* TEXICMD_BANG */
           { dosymbol, "bullet", 6 }, /* TEXICMD_BULLET */
         { dobye, "bye", 3 }, /* TEXICMD_BYE */          { dobye, "bye", 3 }, /* TEXICMD_BYE */
         { dosh, "chapter", 7 }, /* TEXICMD_CHAPTER */          { doblock, "cartouche", 9 }, /* TEXICMD_CARTOUCHE */
           { doaccent, ",", 1 }, /* TEXICMD_CEDILLA */
           { doignline, "center", 6 }, /* TEXICMD_CENTER */
           { dosection, "chapter", 7 }, /* TEXICMD_CHAPTER */
         { doignline, "cindex", 6 }, /* TEXICMD_CINDEX */          { doignline, "cindex", 6 }, /* TEXICMD_CINDEX */
         { doliteral, "code", 4 }, /* TEXICMD_CODE */          { doaccent, "^", 1 }, /* TEXICMD_CIRCUMFLEX */
         { docommand, "command", 7 }, /* TEXICMD_COMMAND */          { doinline, "cite", 4 }, /* TEXICMD_CITE */
           { dovalue, "clear", 5 }, /* TEXICMD_CLEAR */
           { doinline, "code", 4 }, /* TEXICMD_CODE */
           { dosymbol, ":", 1 }, /* TEXICMD_COLON */
           { NULL, "columnfractions", 15 }, /* TEXICMD_COLUMNFRACTIONS */
           { dosymbol, "comma", 5 }, /* TEXICMD_COMMA */
           { doinline, "command", 7 }, /* TEXICMD_COMMAND */
         { doignline, "c", 1 }, /* TEXICMD_COMMENT */          { doignline, "c", 1 }, /* TEXICMD_COMMENT */
           { 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 */
           { dodefn, "deffn", 5 }, /* TEXICMD_DEFFN */
           { dodefn, "deffnx", 6 }, /* TEXICMD_DEFFNX */
           { dodefindex, "defindex", 8 }, /* TEXICMD_DEFINDEX */
           { dodefn, "defmac", 6 }, /* TEXICMD_DEFMAC */
           { dodefn, "defmacx", 7 }, /* TEXICMD_DEFMACX */
           { dodefn, "deftp", 5 }, /* TEXICMD_DEFTP */
           { dodefn, "deftpx", 6 }, /* TEXICMD_DEFTPX */
           { dodefn, "deftypefn", 9 }, /* TEXICMD_DEFTYPEFN */
           { dodefn, "deftypefnx", 10 }, /* TEXICMD_DEFTYPEFNX */
           { dodefn, "deftypefun", 10 }, /* TEXICMD_DEFTYPEFUN */
           { dodefn, "deftypefunx", 11 }, /* TEXICMD_DEFTYPEFUNX */
           { dodefn, "deftypemethod", 13 }, /* TEXICMD_DEFTYPEMETHOD */
           { dodefn, "deftypemethodx", 14 }, /* TEXICMD_DEFTYPEMETHODX */
           { dodefn, "deftypevar", 10 }, /* TEXICMD_DEFTYPEVAR */
           { dodefn, "deftypevarx", 11 }, /* TEXICMD_DEFTYPEVARX */
           { dodefn, "deftypevr", 9 }, /* TEXICMD_DEFTYPEVR */
           { dodefn, "deftypevrx", 10 }, /* TEXICMD_DEFTYPEVRX */
           { dodefn, "defun", 5 }, /* TEXICMD_DEFUN */
           { dodefn, "defunx", 6 }, /* TEXICMD_DEFUNX */
           { dodefn, "defvar", 6 }, /* TEXICMD_DEFVAR */
           { dodefn, "defvarx", 7 }, /* TEXICMD_DEFVARX */
           { dodefn, "defvr", 5 }, /* TEXICMD_DEFVR */
           { dodefn, "defvrx", 6 }, /* TEXICMD_DEFVRX */
         { doignblock, "detailmenu", 10 }, /* TEXICMD_DETAILMENU */          { doignblock, "detailmenu", 10 }, /* TEXICMD_DETAILMENU */
           { 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 */
         { doarg1, "email", 5 }, /* TEXICMD_EMAIL */          { dodisplay, "display", 7 }, /* TEXICMD_DISPLAY */
         { doemph, "emph", 4 }, /* TEXICMD_EMPH */          { doignbracket, "dmn", 3 }, /* TEXICMD_DMN */
         { NULL, "end", 3 }, /* TEXICMD_END */          { doignblock, "documentdescription", 19 }, /* TEXICMD_DOCUMENTDESCRIPTION */
           { doignline, "documentencoding", 16 }, /* TEXICMD_DOCUMENTENCODING */
           { doignline, "documentlanguage", 16 }, /* TEXICMD_DOCUMENTLANGUAGE */
           { doaccent, "dotaccent", 9 }, /* TEXICMD_DOTACCENT */
           { doaccent, "dotless", 7 }, /* TEXICMD_DOTLESS */
           { dosymbol, "dots", 4 }, /* TEXICMD_DOTS */
           { dolink, "email", 5 }, /* TEXICMD_EMAIL */
           { doinline, "emph", 4 }, /* TEXICMD_EMPH */
           { doend, "end", 3 }, /* TEXICMD_END */
           { dosymbol, "enddots", 7 }, /* TEXICMD_ENDDOTS */
           { doenumerate, "enumerate", 9 }, /* TEXICMD_ENUMERATE */
           { doinline, "env", 3 }, /* TEXICMD_ENV */
           { dosymbol, "equiv", 5 }, /* TEXICMD_EQUIV */
           { dosymbol, "error", 5 }, /* TEXICMD_ERROR */
           { dosymbol, "euro", 4 }, /* TEXICMD_EURO */
         { doexample, "example", 7 }, /* TEXICMD_EXAMPLE */          { doexample, "example", 7 }, /* TEXICMD_EXAMPLE */
         { dofile, "file", 4 }, /* TEXICMD_FILE */          { dosymbol, "exclamdown", 10 }, /* TEXICMD_EXCLAMDOWN */
         { doitalic, "i", 1 }, /* TEXICMD_I */          { doignline, "exdent", 6 }, /* TEXICMD_EXDENT */
           { dosymbol, "expansion", 9 }, /* TEXICMD_EXPANSION */
           { doinline, "file", 4 }, /* TEXICMD_FILE */
           { doignline, "finalout", 8 }, /* TEXICMD_FINALOUT */
           { doignline, "findex", 6 }, /* TEXICMD_FINDEX */
           { doblock, "flushleft", 9 }, /* TEXICMD_FLUSHLEFT */
           { doblock, "flushright", 10 }, /* TEXICMD_FLUSHRIGHT */
           { doignline, "firstparagraphindent", 20 }, /* TEXICMD_FIRSTPARAGRAPHINDENT */
           { doignbracket, "footnote", 8 }, /* TEXICMD_FOOTNOTE */
           { doignline, "footnotestyle", 13 }, /* TEXICMD_FOOTNOTESTYLE */
           { dotable, "ftable", 6 }, /* TEXICMD_FTABLE */
           { dodisplay, "format", 6 }, /* TEXICMD_FORMAT */
           { dosymbol, "geq", 3 }, /* TEXICMD_GEQ */
           { doaccent, "`", 1 }, /* TEXICMD_GRAVE */
           { doblock, "group", 5 }, /* TEXICMD_GROUP */
           { dosymbol, "guillemetleft", 13 }, /* TEXICMD_GUILLEMETLEFT */
           { dosymbol, "guillemetright", 14 }, /* TEXICMD_GUILLEMETRIGHT */
           { dosymbol, "guillemotleft", 13 }, /* TEXICMD_GUILLEMOTLEFT */
           { dosymbol, "guillemotright", 14 }, /* TEXICMD_GUILLEMOTRIGHT */
           { dosymbol, "guilsinglleft", 13 }, /* TEXICMD_GUILSINGLLEFT */
           { dosymbol, "guilsinglright", 14 }, /* TEXICMD_GUILSINGLRIGHT */
           { doaccent, "H", 1 }, /* TEXICMD_H */
           { dosection, "heading", 7 }, /* TEXICMD_HEADING */
           { doignline, "headings", 8 }, /* TEXICMD_HEADINGS */
           { doitem, "headitem", 8 }, /* TEXICMD_HEADITEM */
           { doignblock, "html", 4 }, /* TEXICMD_HTML */
           { dosymbol, "-", 1 }, /* TEXICMD_HYPHEN */
           { doinline, "i", 1 }, /* TEXICMD_I */
           { dovalue, "ifclear", 7 }, /* TEXICMD_IFCLEAR */
           { doignblock, "ifdocbook", 9 }, /* TEXICMD_IFDOCBOOK */
         { doignblock, "ifhtml", 6 }, /* TEXICMD_IFHTML */          { doignblock, "ifhtml", 6 }, /* TEXICMD_IFHTML */
         { doifnottex, "ifnottex", 8 }, /* TEXICMD_IFNOTTEX */          { doblock, "ifinfo", 6 }, /* TEXICMD_IFINFO */
           { doblock, "ifnotdocbook", 12 }, /* TEXICMD_IFNOTDOCBOOK */
           { doblock, "ifnothtml", 9 }, /* TEXICMD_IFNOTHTML */
           { doblock, "ifnotinfo", 9 }, /* TEXICMD_IFNOTINFO */
           { doignblock, "ifnotplaintext", 14 }, /* TEXICMD_IFNOTPLAINTEXT */
           { doblock, "ifnottex", 8 }, /* TEXICMD_IFNOTTEX */
           { doblock, "ifnotxml", 8 }, /* TEXICMD_IFNOTXML */
           { doblock, "ifplaintext", 11 }, /* TEXICMD_IFPLAINTEXT */
         { doignblock, "iftex", 5 }, /* TEXICMD_IFTEX */          { doignblock, "iftex", 5 }, /* TEXICMD_IFTEX */
           { dovalue, "ifset", 5 }, /* TEXICMD_IFSET */
           { doignblock, "ifxml", 5 }, /* TEXICMD_IFXML */
           { doignblock, "ignore", 6 }, /* TEXICMD_IGNORE */
         { doignbracket, "image", 5 }, /* TEXICMD_IMAGE */          { doignbracket, "image", 5 }, /* TEXICMD_IMAGE */
           { doinclude, "include", 7 }, /* TEXICMD_INCLUDE */
           { dodisplay, "indentblock", 11 }, /* TEXICMD_INDENTBLOCK */
           { dolink, "indicateurl", 11 }, /* TEXICMD_INDICATEURL */
           { 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 */
         { doliteral, "kbd", 3 }, /* TEXICMD_KBD */          { doitem, "itemx", 5 }, /* TEXICMD_ITEMX */
           { doinline, "kbd", 3 }, /* TEXICMD_KBD */
           { dobracket, "key", 3 }, /* TEXICMD_KEY */
           { doignline, "kindex", 6 }, /* TEXICMD_KINDEX */
           { dosymbol, "L", 1 }, /* TEXICMD_L */
         { dosymbol, "LaTeX", 5 }, /* TEXICMD_LATEX */          { dosymbol, "LaTeX", 5 }, /* TEXICMD_LATEX */
           { dosymbol, "leq", 3 }, /* TEXICMD_LEQ */
           { dosecoffs, "lowersections", 13 }, /* TEXICMD_LOWERSECTIONS */
           { dosymbol, "l", 1 }, /* TEXICMD_LSMALL */
           { domacro, "macro", 5 }, /* TEXICMD_MACRO */
           { doaccent, "=", 1 }, /* TEXICMD_MACRON */
           { domath, "math", 4 }, /* TEXICMD_MATH */
         { doignblock, "menu", 4 }, /* TEXICMD_MENU */          { doignblock, "menu", 4 }, /* TEXICMD_MENU */
           { dosymbol, "minus", 5 }, /* TEXICMD_MINUS */
           { domultitable, "multitable", 10 }, /* TEXICMD_MULTITABLE */
           { doignline, "need", 4 }, /* TEXICMD_NEED */
           { dosymbol, "\n", 1 }, /* TEXICMD_NEWLINE */
         { doignline, "node", 4 }, /* TEXICMD_NODE */          { doignline, "node", 4 }, /* TEXICMD_NODE */
           { doignline, "noindent", 8 }, /* TEXICMD_NOINDENT */
           { dosymbol, "O", 1 }, /* TEXICMD_O */
           { dosymbol, "OE", 2 }, /* TEXICMD_OE */
           { dosymbol, "oe", 2 }, /* TEXICMD_OESMALL */
           { doaccent, "ogonek", 6 }, /* TEXICMD_OGONEK */
           { doinline, "option", 6 }, /* TEXICMD_OPTION */
           { dosymbol, "ordf", 4 }, /* TEXICMD_ORDF */
           { dosymbol, "ordm", 4 }, /* TEXICMD_ORDM */
           { dosymbol, "o", 1 }, /* TEXICMD_OSMALL */
           { doignline, "page", 4 }, /* TEXICMD_PAGE */
           { doignline, "paragraphindent", 15 }, /* TEXICMD_PARINDENT */
           { dosymbol, ".", 1 }, /* TEXICMD_PERIOD */
           { doignline, "pindex", 6 }, /* TEXICMD_PINDEX */
           { dosymbol, "pounds", 6 }, /* TEXICMD_POUNDS */
           { doignline, "printindex", 10 }, /* TEXICMD_PRINTINDEX */
           { dolink, "pxref", 5 }, /* TEXICMD_PXREF */
           { dosymbol, "questiondown", 12 }, /* TEXICMD_QUESTIONDOWN */
           { dosymbol, "?", 1 }, /* TEXICMD_QUESTIONMARK */
         { doquotation, "quotation", 9 }, /* TEXICMD_QUOTATION */          { doquotation, "quotation", 9 }, /* TEXICMD_QUOTATION */
         { doignline, "paragraphindent", 14 }, /* TEXICMD_PARINDENT */          { dosymbol, "quotedblbase", 12 }, /* TEXICMD_QUOTEDBLBASE */
           { dosymbol, "quotedblleft", 12 }, /* TEXICMD_QUOTEDBLLEFT */
           { dosymbol, "quotedblright", 13 }, /* TEXICMD_QUOTEDBLRIGHT */
           { dosymbol, "quotesinglbase", 14 }, /* TEXICMD_QUOTESINGLBASE */
           { dosymbol, "quoteleft", 9 }, /* TEXICMD_QUOTELEFT */
           { dosymbol, "quoteright", 10 }, /* TEXICMD_QUOTERIGHT */
           { doinline, "r", 1 }, /* TEXICMD_R */
           { dosecoffs, "raisesections", 13 }, /* TEXICMD_RAISESECTIONS */
         { dobracket, "ref", 3 }, /* TEXICMD_REF */          { dobracket, "ref", 3 }, /* TEXICMD_REF */
         { doliteral, "samp", 4 }, /* TEXICMD_SAMP */          { doignline, "refill", 6 }, /* TEXICMD_REFILL */
           { dosymbol, "registeredsymbol", 16 }, /* TEXICMD_REGISTEREDSYMBOL */
           { dosymbol, "result", 6 }, /* TEXICMD_RESULT */
           { doaccent, "ringaccent", 10 }, /* TEXICMD_RINGACCENT */
           { doinline, "samp", 4 }, /* TEXICMD_SAMP */
           { doinline, "sansserif", 9 }, /* TEXICMD_SANSSERIF */
           { doinline, "sc", 2 }, /* TEXICMD_SC */
         { dosection, "section", 7 }, /* TEXICMD_SECTION */          { dosection, "section", 7 }, /* TEXICMD_SECTION */
           { dovalue, "set", 3 }, /* TEXICMD_SET */
         { doignline, "setchapternewpage", 17 }, /* TEXICMD_SETCHAPNEWPAGE */          { doignline, "setchapternewpage", 17 }, /* TEXICMD_SETCHAPNEWPAGE */
           { doignline, "setcontentsaftertitlepage", 25 }, /* TEXICMD_SETCONTENTSAFTER */
         { doignline, "setfilename", 11 }, /* TEXICMD_SETFILENAME */          { doignline, "setfilename", 11 }, /* TEXICMD_SETFILENAME */
         { doignline, "settitle", 8 }, /* TEXICMD_SETTITLE */          { dotitle, "settitle", 8 }, /* TEXICMD_SETTITLE */
           { doignline, "shortcontents", 13 }, /* TEXICMD_SHORTCONTENTS */
           { doinline, "slanted", 7 }, /* TEXICMD_SLANTED */
           { dosymbol, "/", 1 }, /* TEXICMD_SLASH */
           { dosp, "sp", 2 }, /* TEXICMD_SP */
           { dosymbol, " ", 1 }, /* TEXICMD_SPACE */
           { doignline, "smallbook", 9 }, /* TEXICMD_SMALLBOOK */
           { dodisplay, "smalldisplay", 12 }, /* TEXICMD_SMALLDISPLAY */
           { doexample, "smallexample", 12 }, /* TEXICMD_SMALLEXAMPLE */
           { dodisplay, "smallformat", 11 }, /* TEXICMD_SMALLFORMAT */
           { dodisplay, "smallindentblock", 16 }, /* TEXICMD_SMALLINDENTBLOCK */
           { dosymbol, "{", 1 }, /* TEXICMD_SQUIGGLE_LEFT */
           { dosymbol, "}", 1 }, /* TEXICMD_SQUIGGLE_RIGHT */
           { dosymbol, "ss", 2 }, /* TEXICMD_SS */
           { doinline, "strong", 6 }, /* TEXICMD_STRONG */
           { dosubsection, "subheading", 10 }, /* TEXICMD_SUBHEADING */
         { dosubsection, "subsection", 10 }, /* TEXICMD_SUBSECTION */          { dosubsection, "subsection", 10 }, /* TEXICMD_SUBSECTION */
           { dosubsubsection, "subsubheading", 13 }, /* TEXICMD_SUBSUBHEADING */
           { dosubsubsection, "subsubsection", 13 }, /* TEXICMD_SUBSUBSECTION */
           { doignline, "subtitle", 8 }, /* TEXICMD_SUBTITLE */
           { doignline, "summarycontents", 15 }, /* TEXICMD_SUMMARYCONTENTS */
           { dodefindex, "synindex", 8 }, /* TEXICMD_SYNINDEX */
           { dodefindex, "syncodeindex", 12 }, /* TEXICMD_SYNCODEINDEX */
           { doinline, "t", 1 }, /* TEXICMD_T */
           { dotab, "tab", 3 }, /* TEXICMD_TAB */
           { dosymbol, "\t", 1 }, /* TEXICMD_TABSYM */
         { dotable, "table", 5 }, /* TEXICMD_TABLE */          { dotable, "table", 5 }, /* TEXICMD_TABLE */
         { doignblock, "tex", 3 }, /* TEXICMD_TEX */          { doignblock, "tex", 3 }, /* TEXICMD_TEX */
         { dosymbol, "TeX", 3 }, /* TEXICMD_TEXSYM */          { dosymbol, "TeX", 3 }, /* TEXICMD_TEXSYM */
           { dosymbol, "textdegree", 10 }, /* TEXICMD_TEXTDEGREE */
           { dosymbol, "TH", 2 }, /* TEXICMD_TH */
           { dosymbol, "th", 2 }, /* TEXICMD_THSMALL */
           { dosymbol, "tie", 3 }, /* TEXICMD_TIE */
           { doaccent, "tieaccent", 9 }, /* TEXICMD_TIEACCENT */
           { doaccent, "~", 1 }, /* TEXICMD_TILDE */
           { doignline, "tindex", 6 }, /* TEXICMD_TINDEX */
           { doignline, "title", 5 }, /* TEXICMD_TITLE */
         { dobracket, "titlefont", 9 }, /* TEXICMD_TITLEFONT */          { dobracket, "titlefont", 9 }, /* TEXICMD_TITLEFONT */
         { doignblock, "titlepage", 9 }, /* TEXICMD_TITLEPAGE */          { doignblock, "titlepage", 9 }, /* TEXICMD_TITLEPAGE */
         { dotop, "top", 3 }, /* TEXICMD_TOP */          { dotop, "top", 3 }, /* TEXICMD_TOP */
         { dosh, "unnumbered", 10 }, /* TEXICMD_UNNUMBERED */          { doaccent, "u", 1 }, /* TEXICMD_U */
         { doarg1, "url", 3 }, /* TEXICMD_URL */          { doaccent, "ubaraccent", 10 }, /* TEXICMD_UBARACCENT */
         { doliteral, "var", 3 }, /* TEXICMD_VAR */          { doaccent, "udotaccent", 10 }, /* TEXICMD_UDOTACCENT */
           { doaccent, "\"", 1 }, /* TEXICMD_UMLAUT */
           { dosection, "unnumbered", 10 }, /* TEXICMD_UNNUMBERED */
           { dosection, "unnumberedsec", 13 }, /* TEXICMD_UNNUMBEREDSEC */
           { dosubsection, "unnumberedsubsec", 16 }, /* TEXICMD_UNNUMBEREDSUBSEC */
           { dosubsubsection, "unnumberedsubsubsec", 19 }, /* TEXICMD_UNNUMBEREDSUBSUBSEC */
           { dolink, "uref", 4 }, /* TEXICMD_UREF */
           { dolink, "url", 3 }, /* TEXICMD_URL */
           { doignline, "", 0 }, /* TEXICMD_USER_INDEX */
           { doaccent, "v", 1 }, /* TEXICMD_V */
           { dovalue, "value", 5 }, /* TEXICMD_VALUE */
           { doinline, "var", 3 }, /* TEXICMD_VAR */
           { doverb, "verb", 4 }, /* TEXICMD_VERB */
           { doverbatim, "verbatim", 8 }, /* TEXICMD_VERBATIM */
           { doverbinclude, "verbatiminclude", 15 }, /* TEXICMD_VERBATIMINCLUDE */
           { doignline, "vindex", 6 }, /* TEXICMD_VINDEX */
           { dosp, "vskip", 5 }, /* TEXICMD_VSKIP */
           { dotable, "vtable", 6 }, /* TEXICMD_VTABLE */
           { dobracket, "w", 1 }, /* TEXICMD_W */
           { dolink, "xref", 4 }, /* TEXICMD_XREF */
           /* TEXICMD__END */
 };  };
   
   const   struct texitok *const texitoks = __texitoks;
   
   /*
    * Texinfo has lots of indexes.
    * You can add new ones in a variety of ways.
    * We maintain an array of all of these index names (usually a few
    * letters) and pass unknown commands through the array list.
    */
 static void  static void
 texifilepop(struct texi *p)  dodefindex(struct texi *p, enum texicmd cmd, size_t *pos)
 {  {
         struct texifile *f;          size_t   start, end;
           char    *cp;
   
         assert(p->filepos > 0);          while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
         f = &p->files[--p->filepos];                  advance(p, pos);
         munmap(f->map, f->mapsz);          start = end = *pos;
           while (end < BUFSZ(p) && ! ismspace(BUF(p)[end]))
                   end++;
   
           if (start == end) {
                   advanceeoln(p, pos, 1);
                   return;
           }
   
           if (NULL == (cp = malloc(end - start + 1)))
                   texiabort(p, NULL);
           memcpy(cp, &BUF(p)[start], end - start);
           cp[end - start] = '\0';
   
           /* FIXME: use reallocarray(). */
           p->indexs = realloc(p->indexs,
                   sizeof(char *) * (p->indexsz + 1));
           if (NULL == p->indexs)
                   texiabort(p, NULL);
           p->indexs[p->indexsz++] = cp;
   
           advanceeoln(p, pos, 1);
 }  }
   
 static void  static void
 texiexit(struct texi *p)  dodefn(struct texi *p, enum texicmd cmd, size_t *pos)
 {  {
           const char      *blk;
   
         while (p->filepos > 0)          blk = NULL;
                 texifilepop(p);          switch (cmd) {
           case (TEXICMD_DEFFN):
           case (TEXICMD_DEFMAC):
           case (TEXICMD_DEFTP):
           case (TEXICMD_DEFTYPEFN):
           case (TEXICMD_DEFTYPEFUN):
           case (TEXICMD_DEFTYPEMETHOD):
           case (TEXICMD_DEFTYPEVAR):
           case (TEXICMD_DEFTYPEVR):
           case (TEXICMD_DEFUN):
           case (TEXICMD_DEFVAR):
           case (TEXICMD_DEFVR):
                   blk = texitoks[cmd].tok;
                   break;
           default:
                   break;
           }
   
           if (p->ign) {
                   NULL != blk ?
                           parseto(p, pos, blk) :
                           parseeoln(p, pos);
                   return;
           }
   
           if (NULL != blk)
                   texivspace(p);
   
           switch (cmd) {
           case (TEXICMD_DEFTYPEMETHOD):
           case (TEXICMD_DEFTYPEMETHODX):
                   texiputchars(p, "Method");
                   break;
           case (TEXICMD_DEFMAC):
           case (TEXICMD_DEFMACX):
                   texiputchars(p, "Macro");
                   break;
           case (TEXICMD_DEFTYPEVAR):
           case (TEXICMD_DEFTYPEVARX):
           case (TEXICMD_DEFVAR):
           case (TEXICMD_DEFVARX):
                   texiputchars(p, "Variable");
                   break;
           case (TEXICMD_DEFTYPEFUN):
           case (TEXICMD_DEFTYPEFUNX):
           case (TEXICMD_DEFUN):
           case (TEXICMD_DEFUNX):
                   texiputchars(p, "Function");
                   break;
           default:
                   parselinearg(p, pos);
                   break;
           }
   
           texiputchar(p, ':');
           texiputchar(p, '\n');
   
           switch (cmd) {
           case (TEXICMD_DEFMAC):
           case (TEXICMD_DEFMACX):
                   teximacroopen(p, "Dv");
                   while (parselinearg(p, pos))
                           /* Spin. */ ;
                   teximacroclose(p);
                   break;
           case (TEXICMD_DEFFN):
           case (TEXICMD_DEFFNX):
           case (TEXICMD_DEFUN):
           case (TEXICMD_DEFUNX):
                   teximacroopen(p, "Fo");
                   parselinearg(p, pos);
                   teximacroclose(p);
                   teximacroopen(p, "Fa");
                   while (parselinearg(p, pos))
                           /* Spin. */ ;
                   teximacroclose(p);
                   teximacro(p, "Fc");
                   break;
           case (TEXICMD_DEFTYPEFUN):
           case (TEXICMD_DEFTYPEFUNX):
           case (TEXICMD_DEFTYPEFN):
           case (TEXICMD_DEFTYPEFNX):
           case (TEXICMD_DEFTYPEMETHOD):
           case (TEXICMD_DEFTYPEMETHODX):
                   teximacroopen(p, "Ft");
                   parselinearg(p, pos);
                   teximacroclose(p);
                   teximacroopen(p, "Fo");
                   parselinearg(p, pos);
                   teximacroclose(p);
                   teximacroopen(p, "Fa");
                   while (parselinearg(p, pos))
                           /* Spin. */ ;
                   teximacroclose(p);
                   teximacro(p, "Fc");
                   break;
           case (TEXICMD_DEFTP):
           case (TEXICMD_DEFTPX):
           case (TEXICMD_DEFTYPEVAR):
           case (TEXICMD_DEFTYPEVARX):
           case (TEXICMD_DEFTYPEVR):
           case (TEXICMD_DEFTYPEVRX):
                   teximacroopen(p, "Vt");
                   while (parselinearg(p, pos))
                           /* Spin. */ ;
                   teximacroclose(p);
                   break;
           case (TEXICMD_DEFVAR):
           case (TEXICMD_DEFVARX):
           case (TEXICMD_DEFVR):
           case (TEXICMD_DEFVRX):
                   teximacroopen(p, "Va");
                   while (parselinearg(p, pos))
                           /* Spin. */ ;
                   teximacroclose(p);
                   break;
           default:
                   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_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;
           }
           teximacro(p, "Bd -filled -offset indent");
           parseto(p, pos, blk);
           teximacro(p, "Ed");
           p->seenvs = 1;
 }  }
   
 static void  static void
 texifatal(struct texi *p, const char *errstring)  domacro(struct texi *p, enum texicmd cmd, size_t *pos)
 {  {
           size_t            start, end, endtoksz, len;
           struct teximacro  m;
           const char       *endtok, *blk;
   
         perror(errstring);          memset(&m, 0, sizeof(struct teximacro));
         texiexit(p);  
         exit(EXIT_FAILURE);          while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
                   advance(p, pos);
   
           for (start = end = *pos; end < BUFSZ(p); end++)
                   if (ismspace(BUF(p)[end]) || '{' == BUF(p)[end])
                           break;
   
           if (start == end)
                   texierr(p, "zero-length macro name");
   
           advanceto(p, pos, end);
   
           m.key = malloc(end - start + 1);
           if (NULL == m.key)
                   texiabort(p, NULL);
           memcpy(m.key, &BUF(p)[start], end - start);
           m.key[end - start] = '\0';
   
           m.args = argparse(p, pos, &m.argsz, 0);
   
           /* Note: we advance to the beginning of the macro. */
           advanceeoln(p, pos, 1);
   
           /*
            * According to the Texinfo manual, the macro ends on the
            * newline subsequent the @end macro.
            * That's COMPLETELY FUCKING WRONG.
            * It ends inclusive the newline, which is why so many macros
            * say things like @r{hello}@c, where the subsequent @c swallows
            * the newline.
            * However, it does swallow the leading newline, so look for the
            * @end macro without the leading newline else we might look
            * past empty macros.
            */
           start = *pos;
           endtok = "@end macro\n";
           endtoksz = strlen(endtok);
           blk = memmem(&BUF(p)[start], BUFSZ(p) - start, endtok, endtoksz);
           if (NULL == blk)
                   texierr(p, "unterminated macro body");
           /* Roll us back one character. */
           while (&BUF(p)[*pos] != blk)
                   advance(p, pos);
           assert('@' == BUF(p)[*pos]);
           if ('\n' != BUF(p)[*pos - 1])
                   texierr(p, "cannot handle @end macro in-line");
   
           len = blk - &BUF(p)[start];
           m.value = malloc(len + 1);
           if (NULL == m.value)
                   texiabort(p, NULL);
           memcpy(m.value, &BUF(p)[start], len);
           m.value[len] = '\0';
   
           p->macros = realloc
                   (p->macros,
                   (p->macrosz + 1) *
                   sizeof(struct teximacro));
           if (NULL == p->macros)
                   texiabort(p, NULL);
   
           p->macros[p->macrosz++] = m;
           advanceeoln(p, pos, 1);
 }  }
   
 /*  
  * Print a generic warning message (to stderr) tied to our current  
  * location in the parse sequence.  
  */  
 static void  static void
 texiwarn(const struct texi *p, const char *fmt, ...)  doignblock(struct texi *p, enum texicmd cmd, size_t *pos)
 {  {
         va_list  ap;          char             end[32], start[32];
           const char      *endt, *startt;
           size_t           esz, ssz, newpos, stack;
   
         fprintf(stderr, "%s:%zu:%zu: ",          /*
                 p->files[p->filepos - 1].name,           * FIXME: this is cheating.
                 p->files[p->filepos - 1].line + 1,           * These tokens are supposed to begin on a newline.
                 p->files[p->filepos - 1].col + 1);           * However, if we do that, then we would need to check within
         va_start(ap, fmt);           * the loop for trailer (or leading, as the case may be)
         vfprintf(stderr, fmt, ap);           * newline, and that's just a bit too complicated right now.
         va_end(ap);           * This is becasue
         fputc('\n', stderr);           *      @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.
            */
           ssz = snprintf(start, sizeof(start),
                   "@%s", texitoks[cmd].tok);
           assert(ssz < sizeof(start));
           esz = snprintf(end, sizeof(end),
                   "@end %s\n", texitoks[cmd].tok);
           assert(esz < sizeof(end));
           stack = 1;
   
           /*
            * Here we look for the end token "end" somewhere in the file in
            * front of us.
            * It's not that easy, of course: if we have a nested block,
            * then there'll be an "end" token of the same kind between us.
            * Thus, we keep track of scopes for matching "end" blocks.
            */
           while (stack > 0 && *pos < BUFSZ(p)) {
                   if (stack > 64)
                           texierr(p, "run-away nested stack?");
                   endt = memmem(&BUF(p)[*pos], BUFSZ(p) - *pos, end, esz);
                   startt = memmem(&BUF(p)[*pos], BUFSZ(p) - *pos, start, ssz);
                   if (NULL == endt) {
                           texiwarn(p, "unterminated \"%s\" "
                                   "block", texitoks[cmd].tok);
                           *pos = BUFSZ(p);
                           break;
                   }
   
                   newpos = *pos;
                   if (NULL == startt || startt > endt) {
                           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);
           }
 }  }
   
 /*  
  * Put a single data character.  
  * This MUST NOT be a mdoc(7) command: it should be free text that's  
  * outputted to the screen.  
  */  
 static void  static void
 texiputchar(struct texi *p, char c)  doblock(struct texi *p, enum texicmd cmd, size_t *pos)
 {  {
   
         if (TEXI_IGN & p->flags)          parseto(p, pos, texitoks[cmd].tok);
                 return;  
   
         putchar(c);  
         if ('\n' == c) {  
                 p->outcol = 0;  
                 p->outmacro = 0;  
                 p->seenws = 0;  
         } else  
                 p->outcol++;  
 }  }
   
 /*  
  * Put multiple characters (see texiputchar()).  
  */  
 static void  static void
 texiputchars(struct texi *p, const char *s)  doinline(struct texi *p, enum texicmd cmd, size_t *pos)
 {  {
           const char      *macro = NULL;
   
         while ('\0' != *s)          switch (cmd) {
                 texiputchar(p, *s++);          case (TEXICMD_CODE):
           case (TEXICMD_KBD):
           case (TEXICMD_SAMP):
           case (TEXICMD_T):
                   macro = "Li";
                   break;
           case (TEXICMD_CITE):
           case (TEXICMD_DFN):
           case (TEXICMD_EMPH):
           case (TEXICMD_I):
           case (TEXICMD_SLANTED):
                   macro = "Em";
                   break;
           case (TEXICMD_B):
           case (TEXICMD_STRONG):
                   macro = "Sy";
                   break;
           case (TEXICMD_COMMAND):
                   macro = "Xr";
                   break;
           case (TEXICMD_ENV):
                   macro = "Ev";
                   break;
           case (TEXICMD_FILE):
                   macro = "Pa";
                   break;
           case (TEXICMD_OPTION):
                   macro = "Op";
                   break;
           case (TEXICMD_VAR):
                   macro = "Va";
                   break;
           default:
                   break;
           }
   
           if (NULL == macro || p->literal || TEXILIST_TABLE == p->list) {
                   if (TEXICMD_SC == cmd)
                           p->uppercase++;
                   parsebracket(p, pos, 0);
                   if (TEXICMD_SC == cmd)
                           p->uppercase--;
                   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);
           p->seenws = 0;
           if (TEXICMD_CODE == cmd)
                   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);
 }  }
   
 /*  
  * Put an mdoc(7) command without the trailing newline.  
  * This should ONLY be used for mdoc(7) commands!  
  */  
 static void  static void
 texifputs(struct texi *p, const char *s)  doverb(struct texi *p, enum texicmd cmd, size_t *pos)
 {  {
         int      rc;          char     delim;
           size_t   start;
   
         if (TEXI_IGN & p->flags)          while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
                   advance(p, pos);
           if (*pos == BUFSZ(p) || '{' != BUF(p)[*pos])
                 return;                  return;
         if (p->outcol)          advance(p, pos);
                 texiputchar(p, '\n');          if (*pos == BUFSZ(p))
         if (EOF != (rc = fputs(s, stdout)))                  return;
                 p->outcol += rc;  
           delim = BUF(p)[*pos];
           advance(p, pos);
           /* Make sure we flush out our initial whitespace... */
           if (p->seenws && p->outcol && 0 == p->literal)
                   texiputchar(p, ' ');
           p->seenws = 0;
           start = *pos;
           /* Read until we see the delimiter then end-brace. */
           while (*pos < BUFSZ(p) - 1) {
                   if (BUF(p)[*pos] == delim && BUF(p)[*pos + 1] == '}')
                           break;
                   advance(p, pos);
           }
           if (*pos >= BUFSZ(p) - 1)
                   return;
           texiputbuf(p, start, *pos);
   
           /* Make sure we read after the end-brace. */
           assert(delim == BUF(p)[*pos]);
           advance(p, pos);
           assert('}' == BUF(p)[*pos]);
           advance(p, pos);
 }  }
   
 /*  
  * Put an mdoc(7) command with the trailing newline.  
  * This should ONLY be used for mdoc(7) commands!  
  */  
 static void  static void
 teximacro(struct texi *p, const char *s)  doinsertcopying(struct texi *p, enum texicmd cmd, size_t *pos)
 {  {
   
         if (TEXI_IGN & p->flags)          advanceeoln(p, pos, 0);
           if (NULL == p->copying)
                 return;                  return;
         if (p->outcol)          texisplice(p, p->copying, p->copyingsz, *pos);
                 texiputchar(p, '\n');  
         puts(s);  
         p->outcol = 0;  
         p->seenws = 0;  
 }  }
   
 /*  
  * Advance by a single byte in the input stream.  
  */  
 static void  static void
 advance(struct texi *p, const char *buf, size_t *pos)  docopying(struct texi *p, enum texicmd cmd, size_t *pos)
 {  {
           const char      *end, *term;
           size_t           endsz, endpos;
   
         if ('\n' == buf[*pos]) {          /* We retain our starting (but not ending) newlines. */
                 p->files[p->filepos - 1].line++;          end = "\n@end copying\n";
                 p->files[p->filepos - 1].col = 0;          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);
           if (NULL == term) {
                   texiwarn(p, "unterminated \"%s\"", texitoks[cmd].tok);
                   endpos = BUFSZ(p);
         } else          } else
                 p->files[p->filepos - 1].col++;                  endpos = *pos + (size_t)(term - &BUF(p)[*pos]);
   
         (*pos)++;          assert(endpos <= BUFSZ(p));
           assert('\n' == BUF(p)[*pos]);
           advance(p, pos);
   
           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
  * Advance to the next non-whitespace word in the input stream.  doverbatim(struct texi *p, enum texicmd cmd, size_t *pos)
  * If we're in literal mode, then print all of the whitespace as we're  
  * doing so.  
  */  
 static size_t  
 advancenext(struct texi *p, const char *buf, size_t sz, size_t *pos)  
 {  {
           const char      *end, *term;
         if (TEXI_LITERAL & p->flags) {          size_t           endsz, endpos;
                 while (*pos < sz && isspace(buf[*pos])) {  
                         texiputchar(p, buf[*pos]);  
                         advance(p, buf, pos);  
                 }  
                 return(*pos);  
         }  
   
         while (*pos < sz && isspace(buf[*pos])) {          /* We read from the @verbatim\n newline inclusive! */
                 p->seenws = 1;          end = "\n@end verbatim\n";
                 /*          endsz = strlen(end);
                  * If it looks like we've printed a double-line, then          advanceeoln(p, pos, 0);
                  * output a paragraph.          if (*pos == BUFSZ(p)) {
                  * FIXME: this is stupid.                  texiwarn(p, "unterminated \"%s\"", texitoks[cmd].tok);
                  */                  return;
                 if (*pos && '\n' == buf[*pos] && '\n' == buf[*pos - 1])  
                         teximacro(p, ".Pp");  
                 advance(p, buf, pos);  
         }          }
         return(*pos);  
 }  
   
 /*          term = memmem(&BUF(p)[*pos], BUFSZ(p) - *pos, end, endsz);
  * Advance to the EOLN in the input stream.          if (NULL == term) {
  */                  texiwarn(p, "unterminated \"%s\"", texitoks[cmd].tok);
 static size_t                  endpos = BUFSZ(p);
 advanceeoln(struct texi *p, const char *buf, size_t sz, size_t *pos)          } else
 {                  endpos = *pos + (size_t)(term - &BUF(p)[*pos]);
   
         while (*pos < sz && '\n' != buf[*pos])          assert(endpos <= BUFSZ(p));
                 advance(p, buf, pos);          assert('\n' == BUF(p)[*pos]);
         return(*pos);          advance(p, pos);
           teximacro(p, "Bd -literal -offset indent");
           while (*pos < endpos) {
                   texiputchar(p, BUF(p)[*pos]);
                   advance(p, pos);
           }
           teximacro(p, "Ed");
           p->seenvs = 1;
           if (*pos < BUFSZ(p))
                   advanceto(p, pos, endpos + endsz);
 }  }
   
 /*  
  * Advance to position "end", which is an absolute position in the  
  * current buffer greater than or equal to the current position.  
  */  
 static void  static void
 advanceto(struct texi *p, const char *buf, size_t *pos, size_t end)  doverbinclude(struct texi *p, enum texicmd cmd, size_t *pos)
 {  {
           char             fname[PATH_MAX], path[PATH_MAX];
           int              rc;
           size_t           i, end;
           const char      *v;
           enum texicmd     type;
   
         assert(*pos <= end);          while (*pos < BUFSZ(p) && ' ' == BUF(p)[*pos])
         while (*pos < end)                  advance(p, pos);
                 advance(p, buf, pos);  
           for (i = 0; *pos < BUFSZ(p) && '\n' != BUF(p)[*pos]; ) {
                   if (i == sizeof(fname) - 1)
                           break;
                   if ('@' != BUF(p)[*pos]) {
                           fname[i++] = BUF(p)[*pos];
                           advance(p, pos);
                           continue;
                   }
                   type = texicmd(p, *pos, &end, NULL);
                   advanceto(p, pos, end);
                   if (TEXICMD_VALUE != type)
                           texierr(p, "unknown verbatiminclude command");
                   v = valueblookup(p, pos);
                   if (NULL == v)
                           continue;
                   while ('\0' != *v) {
                           if (i == sizeof(fname) - 1)
                                   break;
                           fname[i++] = *v++;
                   }
                   if ('\0' != *v)
                           break;
           }
   
           if (i == 0)
                   texierr(p, "path too short");
           else if ('\n' != BUF(p)[*pos])
                   texierr(p, "path too long");
           else if ('/' == fname[0])
                   texierr(p, "no absolute paths");
           fname[i] = '\0';
   
           if (strstr(fname, "../") || strstr(fname, "/.."))
                   texierr(p, "insecure path");
   
           rc = snprintf(path, sizeof(path),
                   "%s/%s", p->dirs[0], fname);
           if (rc < 0)
                   texierr(p, "couldn't format path");
           else if ((size_t)rc >= sizeof(path))
                   texierr(p, "path too long");
   
           parsefile(p, path, 0);
 }  }
   
 /*  
  * Output a free-form word in the input stream, progressing to the next  
  * command or white-space.  
  * This also will advance the input stream.  
  */  
 static void  static void
 texiword(struct texi *p, const char *buf, size_t sz, size_t *pos)  doinclude(struct texi *p, enum texicmd cmd, size_t *pos)
 {  {
           char             fname[PATH_MAX], path[PATH_MAX];
           size_t           i, end;
           int              rc;
           const char      *v;
           enum texicmd     type;
   
         /*          while (*pos < BUFSZ(p) && ' ' == BUF(p)[*pos])
          * XXX: if we're in literal mode, then we shouldn't do any                  advance(p, pos);
          * reflowing of text here.  
          */  
         if (p->outcol > 72 && ! (TEXI_LITERAL & p->flags))  
                 texiputchar(p, '\n');  
   
         if (p->seenws && p->outcol && ! (TEXI_LITERAL & p->flags))          /* Read in the filename. */
                 texiputchar(p, ' ');          for (i = 0; *pos < BUFSZ(p) && '\n' != BUF(p)[*pos]; ) {
                   if (i == sizeof(fname) - 1)
                           break;
                   if ('@' != BUF(p)[*pos]) {
                           fname[i++] = BUF(p)[*pos];
                           advance(p, pos);
                           continue;
                   }
                   type = texicmd(p, *pos, &end, NULL);
                   advanceto(p, pos, end);
                   if (TEXICMD_VALUE != type)
                           texierr(p, "unknown include command");
                   v = valueblookup(p, pos);
                   if (NULL == v)
                           continue;
                   while ('\0' != *v) {
                           if (i == sizeof(fname) - 1)
                                   break;
                           fname[i++] = *v++;
                   }
                   if ('\0' != *v)
                           break;
           }
   
         p->seenws = 0;          if (i == 0)
                   texierr(p, "path too short");
           else if ('\n' != BUF(p)[*pos])
                   texierr(p, "path too long");
           else if ('/' == fname[0])
                   texierr(p, "no absolute paths");
           fname[i] = '\0';
   
         while (*pos < sz && ! isspace(buf[*pos])) {          if (strstr(fname, "../") || strstr(fname, "/.."))
                 switch (buf[*pos]) {                  texierr(p, "insecure path");
                 case ('@'):  
                 case ('}'):          for (i = 0; i < p->dirsz; i++) {
                 case ('{'):                  rc = snprintf(path, sizeof(path),
                         return;                          "%s/%s", p->dirs[i], fname);
                 }                  if (rc < 0)
                 if (*pos < sz - 1 &&                          texierr(p, "couldn't format path");
                          '`' == buf[*pos] &&                  else if ((size_t)rc >= sizeof(path))
                          '`' == buf[*pos + 1]) {                          texierr(p, "path too long");
                         texiputchars(p, "\\(lq");                  else if (-1 == access(path, R_OK))
                         advance(p, buf, pos);                          continue;
                 } else if (*pos < sz - 1 &&  
                          '\'' == buf[*pos] &&                  parsefile(p, path, 1);
                          '\'' == buf[*pos + 1]) {                  return;
                         texiputchars(p, "\\(rq");  
                         advance(p, buf, pos);  
                 } else  
                         texiputchar(p, buf[*pos]);  
                 advance(p, buf, pos);  
         }          }
   
           texierr(p, "couldn't find %s in includes", fname);
 }  }
   
 static enum texicmd  static void
 texicmd(struct texi *p, const char *buf,  dobracket(struct texi *p, enum texicmd cmd, size_t *pos)
         size_t pos, size_t sz, size_t *end)  
 {  {
         size_t   i, len;  
   
         assert('@' == buf[pos]);          parsebracket(p, pos, 0);
         for (*end = ++pos; *end < sz && ! isspace(buf[*end]); (*end)++)  }
                 if ('@' == buf[*end] || '{' == buf[*end])  
                         break;  
   
         len = *end - pos;  static void
         for (i = 0; i < TEXICMD__MAX; i++) {  dodisplay(struct texi *p, enum texicmd cmd, size_t *pos)
                 if (len != texitoks[i].len)  {
                         continue;  
                 if (0 == strncmp(texitoks[i].tok, &buf[pos], len))          advanceeoln(p, pos, 1);
                         return(i);  
           switch (cmd) {
           case (TEXICMD_FORMAT):
           case (TEXICMD_SMALLFORMAT):
                   teximacro(p, "Bd -filled");
                   break;
           default:
                   teximacro(p, "Bd -filled -offset indent");
                   break;
         }          }
   
         texiwarn(p, "bad command: %.*s", (int)len, &buf[pos]);          parseto(p, pos, texitoks[cmd].tok);
         return(TEXICMD__MAX);          teximacro(p, "Ed");
           p->seenvs = 1;
 }  }
   
 static void  static void
 parseeof(struct texi *p, const char *buf, size_t sz)  doexample(struct texi *p, enum texicmd cmd, size_t *pos)
 {  {
         size_t           pos = 0;  
         enum texicmd     cmd;  
         size_t           end;  
   
         while ((pos = advancenext(p, buf, sz, &pos)) < sz) {          advanceeoln(p, pos, 1);
                 switch (buf[pos]) {  
                 case ('}'):  
                         texiwarn(p, "unexpected \"}\"");  
                         advance(p, buf, &pos);  
                         continue;  
                 case ('{'):  
                         texiwarn(p, "unexpected \"{\"");  
                         advance(p, buf, &pos);  
                         continue;  
                 case ('@'):  
                         break;  
                 default:  
                         texiword(p, buf, sz, &pos);  
                         continue;  
                 }  
   
                 cmd = texicmd(p, buf, pos, sz, &end);          teximacro(p, "Bd -literal -offset indent");
                 advanceto(p, buf, &pos, end);          p->literal++;
                 if (TEXICMD__MAX == cmd)          parseto(p, pos, texitoks[cmd].tok);
                         continue;          p->literal--;
                 if (NULL != texitoks[cmd].fp)          teximacro(p, "Ed");
                         (*texitoks[cmd].fp)(p, cmd, buf, sz, &pos);          p->seenvs = 1;
         }  
 }  }
   
 static void  static void
 parsebracket(struct texi *p, const char *buf, size_t sz, size_t *pos)  dobye(struct texi *p, enum texicmd cmd, size_t *pos)
 {  {
         size_t           end;  
         enum texicmd     cmd;  
   
         if (*pos == sz || '{' != buf[*pos])          texiexit(p);
                 return;          exit(EXIT_SUCCESS);
         advance(p, buf, pos);  }
   
         while ((*pos = advancenext(p, buf, sz, pos)) < sz) {  static void
                 switch (buf[*pos]) {  dotitle(struct texi *p, enum texicmd cmd, size_t *pos)
                 case ('}'):  {
                         advance(p, buf, pos);          size_t   start;
                         return;  
                 case ('{'):  
                         texiwarn(p, "unexpected \"{\"");  
                         advance(p, buf, pos);  
                         continue;  
                 case ('@'):  
                         break;  
                 default:  
                         texiword(p, buf, sz, pos);  
                         continue;  
                 }  
   
                 cmd = texicmd(p, buf, *pos, sz, &end);          while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
                 advanceto(p, buf, pos, end);                  advance(p, pos);
                 if (TEXICMD__MAX == cmd)  
                         continue;          /* We want to suck down the entire line, inclusive \n. */
                 if (NULL != texitoks[cmd].fp)          start = *pos;
                         (*texitoks[cmd].fp)(p, cmd, buf, sz, pos);          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);
           if (NULL == (p->subtitle = malloc(*pos - start + 1)))
                   texiabort(p, NULL);
           memcpy(p->subtitle, &BUF(p)[start], *pos - start);
           p->subtitle[*pos - start] = '\0';
 }  }
   
 static void  static void
 parseto(struct texi *p, const char *buf,  doaccent(struct texi *p, enum texicmd cmd, size_t *pos)
         size_t sz, size_t *pos, const char *endtoken)  
 {  {
         size_t           end;          int      brace = 0;
         enum texicmd     cmd;  
         size_t           endtoksz;  
   
         endtoksz = strlen(endtoken);          if (*pos == BUFSZ(p)) {
         assert(endtoksz > 0);                  texiwarn(p, "truncated: @%s", texitoks[cmd].tok);
                   return;
         while ((*pos = advancenext(p, buf, sz, pos)) < sz) {          }
                 switch (buf[*pos]) {  
                 case ('}'):          /* Pad us with space, if necessary. */
                         texiwarn(p, "unexpected \"}\"");          if (p->seenws && p->outcol && 0 == p->literal) {
                         advance(p, buf, pos);                  texiputchar(p, ' ');
                         continue;                  p->seenws = 0;
                 case ('{'):          }
                         texiwarn(p, "unexpected \"{\"");  
                         advance(p, buf, pos);          /*
                         continue;           * If we're braced, then that's that.
                 case ('@'):           * Otherwise, in a special Texinfo case: if we're a non
            * alphabetic command of one letter, then the next character is
            * the critical one.
            * Otherwise, space can sit between us and our argument.
            */
           if ('{' == BUF(p)[*pos]) {
                   brace = 1;
                   advance(p, pos);
           } else if (isalpha((unsigned char)texitoks[cmd].tok[0]))
                   while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
                           advance(p, pos);
   
           if (*pos == BUFSZ(p)) {
                   texiwarn(p, "truncated: @%s", texitoks[cmd].tok);
                   return;
           }
   
           switch (cmd) {
           case (TEXICMD_ACUTE):
                   switch (BUF(p)[*pos]) {
                   case ('a'): case ('A'):
                   case ('e'): case ('E'):
                   case ('i'): case ('I'):
                   case ('o'): case ('O'):
                   case ('u'): case ('U'):
                           texiputchars(p, "\\(\'");
                         break;                          break;
                 default:                  default:
                         texiword(p, buf, sz, pos);                          texiwarn(p, "ignoring accent");
                         continue;                          break;
                 }                  }
                   texiputchar(p, BUF(p)[*pos]);
                   advance(p, pos);
                   break;
           case (TEXICMD_CEDILLA):
                   if ('c' == BUF(p)[*pos] || 'C' == BUF(p)[*pos])
                           texiputchars(p, "\\(,");
                   else
                           texiwarn(p, "ignoring accent");
                   texiputchar(p, BUF(p)[*pos]);
                   advance(p, pos);
                   break;
           case (TEXICMD_CIRCUMFLEX):
                   switch (BUF(p)[*pos]) {
                   case ('a'): case ('A'):
                   case ('e'): case ('E'):
                   case ('i'): case ('I'):
                   case ('o'): case ('O'):
                   case ('u'): case ('U'):
                           texiputchars(p, "\\(^");
                           break;
                   default:
                           texiwarn(p, "ignoring accent");
                           break;
                   }
                   texiputchar(p, BUF(p)[*pos]);
                   advance(p, pos);
                   break;
           case (TEXICMD_DOTLESS):
                   if ('i' == BUF(p)[*pos] || 'j' == BUF(p)[*pos])
                           texiputchars(p, "\\(.");
                   else
                           texiwarn(p, "ignoring accent");
                   texiputchar(p, BUF(p)[*pos]);
                   advance(p, pos);
                   break;
           case (TEXICMD_GRAVE):
                   switch (BUF(p)[*pos]) {
                   case ('a'): case ('A'):
                   case ('e'): case ('E'):
                   case ('i'): case ('I'):
                   case ('o'): case ('O'):
                   case ('u'): case ('U'):
                           texiputchars(p, "\\(`");
                           break;
                   default:
                           texiwarn(p, "ignoring accent");
                           break;
                   }
                   texiputchar(p, BUF(p)[*pos]);
                   advance(p, pos);
                   break;
           case (TEXICMD_TILDE):
                   switch (BUF(p)[*pos]) {
                   case ('a'): case ('A'):
                   case ('n'): case ('N'):
                   case ('o'): case ('O'):
                           texiputchars(p, "\\(~");
                           break;
                   default:
                           texiwarn(p, "ignoring accent");
                           break;
                   }
                   texiputchar(p, BUF(p)[*pos]);
                   advance(p, pos);
                   break;
           case (TEXICMD_UMLAUT):
                   switch (BUF(p)[*pos]) {
                   case ('a'): case ('A'):
                   case ('e'): case ('E'):
                   case ('i'): case ('I'):
                   case ('o'): case ('O'):
                   case ('u'): case ('U'):
                   case ('y'):
                           texiputchars(p, "\\(:");
                           break;
                   default:
                           texiwarn(p, "ignoring accent");
                           break;
                   }
                   texiputchar(p, BUF(p)[*pos]);
                   advance(p, pos);
                   break;
           default:
                   texiputchar(p, BUF(p)[*pos]);
                   advance(p, pos);
                   break;
           }
   
                 cmd = texicmd(p, buf, *pos, sz, &end);          if (brace) {
                 advanceto(p, buf, pos, end);                  while (*pos < BUFSZ(p) && '}' != BUF(p)[*pos]) {
                 if (TEXICMD_END == cmd) {                          texiputchar(p, BUF(p)[*pos]);
                         while (*pos < sz && ' ' == buf[*pos])                          advance(p, pos);
                                 advance(p, buf, pos);                  }
                         /*                  if (*pos < BUFSZ(p))
                          * FIXME: skip tabs and also check the full                          advance(p, pos);
                          * word, not just its initial substring!          }
                          */  
                         if (sz - *pos >= endtoksz && 0 == strncmp          switch (cmd) {
                                  (&buf[*pos], endtoken, endtoksz)) {          case (TEXICMD_TIEACCENT):
                                 advanceeoln(p, buf, sz, pos);                  texiputchar(p, ']');
                                 break;                  break;
                         }          case (TEXICMD_DOTACCENT):
                         texiwarn(p, "unexpected \"end\"");                  texiputchar(p, '*');
                         advanceeoln(p, buf, sz, pos);                  break;
                         continue;          default:
                 } else if (TEXICMD__MAX != cmd)                  break;
                         if (NULL != texitoks[cmd].fp)  
                                 (*texitoks[cmd].fp)(p, cmd, buf, sz, pos);  
         }          }
 }  }
   
 static void  static void
 doignblock(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)  
 {  {
         unsigned int     sv = p->flags;  
         const char      *blockname;          /* Remember to pad us. */
           if (p->seenws && p->outcol && 0 == p->literal)
         p->flags |= TEXI_IGN;                  texiputchar(p, ' ');
   
           p->seenws = 0;
   
         switch (cmd) {          switch (cmd) {
         case (TEXICMD_COPYING):          case (TEXICMD_AA):
                 blockname = "copying";                  texiputchars(p, "\\(oA");
                 break;                  break;
         case (TEXICMD_DETAILMENU):          case (TEXICMD_AASMALL):
                 blockname = "detailmenu";                  texiputchars(p, "\\(oa");
                 break;                  break;
         case (TEXICMD_DIRENTRY):          case (TEXICMD_AE):
                 blockname = "direntry";                  texiputchars(p, "\\(AE");
                 break;                  break;
         case (TEXICMD_IFHTML):          case (TEXICMD_AESMALL):
                 blockname = "ifhtml";                  texiputchars(p, "\\(ae");
                 break;                  break;
         case (TEXICMD_IFTEX):          case (TEXICMD_ASTERISK):
                 blockname = "iftex";          case (TEXICMD_NEWLINE):
           case (TEXICMD_SPACE):
           case (TEXICMD_TABSYM):
                   texiputchar(p, ' ');
                 break;                  break;
         case (TEXICMD_MENU):          case (TEXICMD_AT):
                 blockname = "menu";                  texiputchar(p, '@');
                 break;                  break;
         case (TEXICMD_TEX):          case (TEXICMD_BACKSLASH):
                 blockname = "tex";                  texiputchar(p, '\\');
                 break;                  break;
         case (TEXICMD_TITLEPAGE):          case (TEXICMD_BANG):
                 blockname = "titlepage";                  texiputchar(p, '!');
                 break;                  break;
           case (TEXICMD_BULLET):
                   texiputchars(p, "\\(bu");
                   break;
           case (TEXICMD_COMMA):
                   texiputchar(p, ',');
                   break;
           case (TEXICMD_COPYRIGHT):
                   texiputchars(p, "\\(co");
                   break;
           case (TEXICMD_DH):
                   texiputchars(p, "\\(-D");
                   break;
           case (TEXICMD_DHSMALL):
                   texiputchars(p, "\\(Sd");
                   break;
           case (TEXICMD_DOTS):
           case (TEXICMD_ENDDOTS):
                   texiputchars(p, "...");
                   break;
           case (TEXICMD_EQUIV):
                   texiputchars(p, "\\(==");
                   break;
           case (TEXICMD_ERROR):
                   texiputchars(p, "error\\(->");
                   break;
           case (TEXICMD_EURO):
                   texiputchars(p, "\\(Eu");
                   break;
           case (TEXICMD_EXCLAMDOWN):
                   texiputchars(p, "\\(r!");
                   break;
           case (TEXICMD_EXPANSION):
                   texiputchars(p, "\\(->");
                   break;
           case (TEXICMD_GEQ):
                   texiputchars(p, "\\(>=");
                   break;
           case (TEXICMD_GUILLEMETLEFT):
           case (TEXICMD_GUILLEMOTLEFT):
                   texiputchars(p, "\\(Fo");
                   break;
           case (TEXICMD_GUILLEMETRIGHT):
           case (TEXICMD_GUILLEMOTRIGHT):
                   texiputchars(p, "\\(Fc");
                   break;
           case (TEXICMD_GUILSINGLLEFT):
                   texiputchars(p, "\\(fo");
                   break;
           case (TEXICMD_GUILSINGLRIGHT):
                   texiputchars(p, "\\(fc");
                   break;
           case (TEXICMD_L):
                   texiputchars(p, "\\(/L");
                   break;
           case (TEXICMD_LATEX):
                   texiputchars(p, "LaTeX");
                   break;
           case (TEXICMD_LEQ):
                   texiputchars(p, "\\(<=");
                   break;
           case (TEXICMD_LSMALL):
                   texiputchars(p, "\\(/l");
                   break;
           case (TEXICMD_MINUS):
                   texiputchars(p, "\\-");
                   break;
           case (TEXICMD_O):
                   texiputchars(p, "\\(/O");
                   break;
           case (TEXICMD_OE):
                   texiputchars(p, "\\(OE");
                   break;
           case (TEXICMD_OESMALL):
                   texiputchars(p, "\\(oe");
                   break;
           case (TEXICMD_ORDF):
                   texiputchars(p, "a");
                   break;
           case (TEXICMD_ORDM):
                   texiputchars(p, "o");
                   break;
           case (TEXICMD_OSMALL):
                   texiputchars(p, "\\(/o");
                   break;
           case (TEXICMD_PERIOD):
                   texiputchar(p, '.');
                   break;
           case (TEXICMD_POUNDS):
                   texiputchars(p, "\\(Po");
                   break;
           case (TEXICMD_QUESTIONDOWN):
                   texiputchars(p, "\\(r?");
                   break;
           case (TEXICMD_QUESTIONMARK):
                   texiputchar(p, '?');
                   break;
           case (TEXICMD_QUOTEDBLBASE):
                   texiputchars(p, "\\(Bq");
                   break;
           case (TEXICMD_QUOTEDBLLEFT):
                   texiputchars(p, "\\(lq");
                   break;
           case (TEXICMD_QUOTEDBLRIGHT):
                   texiputchars(p, "\\(rq");
                   break;
           case (TEXICMD_QUOTESINGLBASE):
                   texiputchars(p, "\\(bq");
                   break;
           case (TEXICMD_QUOTELEFT):
                   texiputchars(p, "\\(oq");
                   break;
           case (TEXICMD_QUOTERIGHT):
                   texiputchars(p, "\\(cq");
                   break;
           case (TEXICMD_REGISTEREDSYMBOL):
                   texiputchars(p, "\\(rg");
                   break;
           case (TEXICMD_RESULT):
                   texiputchars(p, "\\(rA");
                   break;
           case (TEXICMD_SLASH):
                   texiputchar(p, '/');
                   break;
           case (TEXICMD_SS):
                   texiputchars(p, "\\(ss");
                   break;
           case (TEXICMD_SQUIGGLE_LEFT):
                   texiputchars(p, "{");
                   break;
           case (TEXICMD_SQUIGGLE_RIGHT):
                   texiputchars(p, "}");
                   break;
           case (TEXICMD_TEXSYM):
                   texiputchars(p, "TeX");
                   break;
           case (TEXICMD_TEXTDEGREE):
                   texiputchars(p, "\\(de");
                   break;
           case (TEXICMD_TH):
                   texiputchars(p, "\\(TP");
                   break;
           case (TEXICMD_THSMALL):
                   texiputchars(p, "\\(Tp");
                   break;
           case (TEXICMD_TIE):
                   texiputchars(p, "\\ ");
                   break;
           case (TEXICMD_COLON):
           case (TEXICMD_HYPHEN):
                   break;
         default:          default:
                 abort();                  abort();
         }          }
         parseto(p, buf, sz, pos, blockname);  
         p->flags = sv;          /* Alphabetic commands have braces we ignore. */
           if (isalpha((unsigned char)texitoks[cmd].tok[0]))
                   doignbracket(p, cmd, pos);
 }  }
   
 static void  static void
 doifnottex(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)  
 {  {
   
         parseto(p, buf, sz, pos, "ifnottex");          teximacro(p, "Qo");
           parseto(p, pos, "quotation");
           teximacro(p, "Qc");
 }  }
   
   #if 0
 static void  static void
 doinline(struct texi *p, const char *buf,  domenu(struct texi *p, enum texicmd cmd, size_t *pos)
         size_t sz, size_t *pos, const char *macro)  
 {  {
           size_t   start;
   
         if ( ! p->outmacro)          if (NULL != p->chapters) {
                 texifputs(p, ".");                  doignblock(p, cmd, pos);
         texiputchars(p, macro);                  return;
         texiputchar(p, ' ');  
         p->seenws = 0;  
         p->outmacro++;  
         parsebracket(p, buf, sz, pos);  
         p->outmacro--;  
         if (*pos < sz - 1 &&  
                  ismpunct(buf[*pos]) &&  
                  isspace(buf[*pos + 1])) {  
                 texiputchar(p, ' ');  
                 texiputchar(p, buf[*pos]);  
                 advance(p, buf, pos);  
         }          }
         if ( ! p->outmacro)  
                 texiputchar(p, '\n');          advanceeoln(p, pos, 1);
   
           teximacro(p, "Bl -tag -width Ds");
           while (*pos < BUFSZ(p)) {
                   /* Read to next menu item. */
                   while (*pos < BUFSZ(p) && ismspace(BUF(p)[*pos]))
                           advance(p, pos);
                   if ('*' != BUF(p)[*pos])
                           break;
   
                   assert('*' == BUF(p)[*pos]);
                   advance(p, pos);
                   while (*pos < BUFSZ(p) && ismspace(BUF(p)[*pos]))
                           advance(p, pos);
                   start = *pos;
                   while (*pos < BUFSZ(p) && ':' != BUF(p)[*pos])
                           advance(p, pos);
                   if (*pos == BUFSZ(p) || *pos == start) {
                           texiwarn(p, "empty menu name");
                           break;
                   }
                   teximacroopen(p, "It");
                   teximacroopen(p, "Sx");
                   for ( ; start < *pos; start++)
                           texiputchar(p, BUF(p)[start]);
                   teximacroclose(p);
                   teximacroclose(p);
   
                   advance(p, pos);
                   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);
                           start = *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;
                           }
                   } else
                           advance(p, pos);
   
                   while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
                           advance(p, pos);
   
                   if (*pos == BUFSZ(p)) {
                           texiwarn(p, "bad menu syntax");
                           break;
                   }
   
                   while (*pos < BUFSZ(p)) {
                           if ('*' == BUF(p)[*pos])
                                   break;
                           if ('\n' != BUF(p)[*pos]) {
                                   texiputchar(p, BUF(p)[*pos]);
                                   advance(p, pos);
                                   continue;
                           }
                           advance(p, pos);
                           while (*pos == BUFSZ(p)) {
                                   texiwarn(p, "bad menu syntax");
                                   break;
                           }
                           if ('\n' == BUF(p)[*pos]) {
                                   advance(p, pos);
                                   break;
                           } else if ('*' == BUF(p)[*pos]) {
                                   continue;
                           } else if ('@' == BUF(p)[*pos])
                                   break;
                           texiputchar(p, ' ');
                   }
           }
   
           teximacro(p, "El");
   
           doignblock(p, cmd, pos);
 }  }
   #endif
   
 static void  static void
 doitalic(struct texi *p, enum texicmd cmd,  domath(struct texi *p, enum texicmd cmd, size_t *pos)
         const char *buf, size_t sz, size_t *pos)  
 {  {
   
         texiputchars(p, "\\fI");          parsebracket(p, pos, 1);
         parsebracket(p, buf, sz, pos);  
         texiputchars(p, "\\fP");  
 }  }
   
 static void  static void
 doliteral(struct texi *p, enum texicmd cmd,  dovalue(struct texi *p, enum texicmd cmd, size_t *pos)
         const char *buf, size_t sz, size_t *pos)  
 {  {
           size_t           start, end;
           char            *key, *val;
           const char      *cp;
   
         if (TEXI_LITERAL & p->flags)          if (TEXICMD_SET == cmd) {
                 parsebracket(p, buf, sz, pos);                  while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
         else                          advance(p, pos);
                 doinline(p, buf, sz, pos, "Li");                  for (start = end = *pos; end < BUFSZ(p); end++)
                           if (ismspace(BUF(p)[end]))
                                   break;
                   /* We don't allow empty keys. */
                   if (start == end)
                           return;
                   advanceto(p, pos, end);
   
                   key = malloc(end - start + 1);
                   if (NULL == key)
                           texiabort(p, NULL);
                   memcpy(key, &BUF(p)[start], end - start);
                   key[end - start] = '\0';
   
                   while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
                           advance(p, pos);
                   for (start = end = *pos; end < BUFSZ(p); end++)
                           if ('\n' == BUF(p)[end])
                                   break;
                   /* We do allow empty values. */
                   advanceeoln(p, pos, 1);
   
                   val = malloc(end - start + 1);
                   if (NULL == val)
                           texiabort(p, NULL);
                   memcpy(val, &BUF(p)[start], end - start);
                   val[end - start] = '\0';
                   valueadd(p, key, val);
           } else if (TEXICMD_VALUE == cmd) {
                   if (p->seenws)
                           texiputchar(p, ' ');
                   p->seenws = 0;
                   if (NULL != (cp = valueblookup(p, pos)))
                           texisplice(p, cp, strlen(cp), *pos);
                   else
                           texiputchars(p, "{No value}");
           } else if (TEXICMD_IFCLEAR == cmd) {
                   if (NULL != valuellookup(p, pos))
                           doignblock(p, cmd, pos);
                   else
                           parseto(p, pos, texitoks[cmd].tok);
           } else if (TEXICMD_IFSET == cmd) {
                   if (NULL == valuellookup(p, pos))
                           doignblock(p, cmd,  pos);
                   else
                           parseto(p, pos, texitoks[cmd].tok);
           } else if (TEXICMD_CLEAR == cmd)
                   valuelclear(p, pos);
 }  }
   
 static void  static void
 doemph(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;
   
         if (TEXI_LITERAL & p->flags)          switch (cmd) {
                 doitalic(p, cmd, buf, sz, pos);          case (TEXICMD_EMAIL):
         else                  teximacroopen(p, "Mt");
                 doinline(p, buf, sz, pos, "Em");                  break;
           case (TEXICMD_UREF):
           case (TEXICMD_URL):
           case (TEXICMD_INDICATEURL):
                   teximacroopen(p, "Lk");
                   break;
           case (TEXICMD_XREF):
                   texiputchars(p, "See Section");
                   teximacroopen(p, "Dq");
                   break;
           case (TEXICMD_PXREF):
                   texiputchars(p, "see Section");
                   teximacroopen(p, "Dq");
                   break;
           case (TEXICMD_INFOREF):
                   texiputchars(p, "See Info file node");
                   teximacroopen(p, "Dq");
                   break;
           default:
                   abort();
           }
   
           c = parsearg(p, pos, 0);
           p->ign++;
           while (c > 0)
                   c = parsearg(p, pos, 1);
           p->ign--;
   
           texipunctuate(p, pos);
           teximacroclose(p);
 }  }
   
 static void  static void
 docommand(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;
   
         doinline(p, buf, sz, pos, "Xr");          c = parsearg(p, pos, 0);
           p->ign++;
           while (c > 0)
                   c = parsearg(p, pos, 1);
           p->ign--;
 }  }
   
 static void  /*
 dobracket(struct texi *p, enum texicmd cmd,   * Sections can be made subsections and so on by way of the
         const char *buf, size_t sz, size_t *pos)   * @raiseections and @lowersections commands.
    * Perform this check here and return the actual section number adjusted
    * to the raise level.
    */
   static int
   sectioner(struct texi *p, int sec)
 {  {
   
         parsebracket(p, buf, sz, pos);          if ((sec -= p->secoffs) < 0) {
                   texiwarn(p, "section below minimum, clamping");
                   return(0);
           } else if (sec >= SECTSZ) {
                   texiwarn(p, "section above maximum, clamping");
                   return(SECTSZ - 1);
           }
           return(sec);
 }  }
   
 static void  static void
 dofile(struct texi *p, enum texicmd cmd,  dosubsubsection(struct texi *p, enum texicmd cmd, size_t *pos)
         const char *buf, size_t sz, size_t *pos)  
 {  {
           int      sec;
   
         if (TEXI_LITERAL & p->flags)          sec = sectioner(p, 3);
                 parsebracket(p, buf, sz, pos);  
         else          /* We don't have a subsubsubsection, so make one up. */
                 doinline(p, buf, sz, pos, "Pa");          texivspace(p);
           teximacroopen(p, sects[sec]);
           parseeoln(p, pos);
           teximacroclose(p);
           texivspace(p);
 }  }
   
 static void  static void
 doexample(struct texi *p, enum texicmd cmd,  dosubsection(struct texi *p, enum texicmd cmd, size_t *pos)
         const char *buf, size_t sz, size_t *pos)  
 {  {
         unsigned int    sv;          int      sec;
   
         teximacro(p, ".Bd -literal");          sec = sectioner(p, 2);
         advanceeoln(p, buf, sz, pos);  
         if ('\n' == buf[*pos])          if (p->outmacro)
                 advance(p, buf, pos);                  texierr(p, "\"%s\" in open line scope!?", sects[sec]);
         sv = p->flags;          else if (p->literal)
         p->flags |= TEXI_LITERAL;                  texierr(p, "\"%s\" in a literal scope!?", sects[sec]);
         parseto(p, buf, sz, pos, "example");  
         p->flags = sv;          /* We don't have a subsubsection, so make one up. */
         teximacro(p, ".Ed");          if (sec > 1)
                   texivspace(p);
           teximacroopen(p, sects[sec]);
           parseeoln(p, pos);
           teximacroclose(p);
           if (sec > 1)
                   texivspace(p);
 }  }
   
 static void  static void
 dobye(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)  
 {  {
   
         texiexit(p);          if (TEXICMD_RAISESECTIONS == cmd)
         exit(EXIT_SUCCESS);                  p->secoffs++;
           else
                   p->secoffs--;
 }  }
   
 static void  static void
 dosymbol(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;
   
         switch (cmd) {          switch (cmd) {
         case (TEXICMD_AT):          case (TEXICMD_TOP):
                 texiputchars(p, "@");                  sec = 0;
                 break;                  break;
         case (TEXICMD_COPYRIGHT):          case (TEXICMD_APPENDIX):
                 texiputchars(p, "\\(co");          case (TEXICMD_CHAPTER):
           case (TEXICMD_UNNUMBERED):
                   sec = sectioner(p, 0);
                 break;                  break;
         case (TEXICMD_LATEX):          case (TEXICMD_APPENDIXSEC):
                 texiputchars(p, "LaTeX");          case (TEXICMD_HEADING):
           case (TEXICMD_SECTION):
           case (TEXICMD_UNNUMBEREDSEC):
                   sec = sectioner(p, 1);
                 break;                  break;
         case (TEXICMD_TEXSYM):  
                 texiputchars(p, "TeX");  
                 break;  
         default:          default:
                 abort();                  abort();
         }          }
   
         doignbracket(p, cmd, buf, sz, pos);          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]);
   
           if (0 == sec && NULL != p->chapters) {
                   teximdocclose(p, 0);
                   teximdocopen(p, pos);
           }
   
           teximacroopen(p, sects[sec]);
           parseeoln(p, pos);
           teximacroclose(p);
 }  }
   
 static void  static void
 doquotation(struct texi *p, enum texicmd cmd,  dotop(struct texi *p, enum texicmd cmd, size_t *pos)
         const char *buf, size_t sz, size_t *pos)  
 {  {
   
         teximacro(p, ".Qo");          if (--p->ign)
         parseto(p, buf, sz, pos, "quotation");                  texierr(p, "@top command while ignoring");
         teximacro(p, ".Qc");  
           if (NULL == p->chapters)
                   teximdocopen(p, pos);
           dosection(p, cmd, pos);
 }  }
   
 static void  static void
 doarg1(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)  
 {  {
   
         if (*pos == sz || '{' != buf[*pos])          advanceeoln(p, pos, 1);
                 return;          if (p->literal)
         advance(p, buf, pos);  
         if ( ! p->outmacro)  
                 texifputs(p, ".");  
         switch (cmd) {  
         case (TEXICMD_EMAIL):  
                 texiputchars(p, "Lk ");  
                 break;  
         case (TEXICMD_URL):  
                 texiputchars(p, "Mt ");  
                 break;  
         default:  
                 abort();  
         }  
         while (*pos < sz && '}' != buf[*pos] && ',' != buf[*pos]) {  
                 texiputchar(p, buf[*pos]);  
                 advance(p, buf, pos);  
         }  
         while (*pos < sz && '}' != buf[*pos])  
                 advance(p, buf, pos);  
         if (*pos < sz)  
                 advance(p, buf, pos);  
         if (*pos < sz - 1 &&  
                  ismpunct(buf[*pos]) &&  
                  isspace(buf[*pos + 1])) {  
                 texiputchar(p, ' ');  
                 texiputchar(p, buf[*pos]);  
                 advance(p, buf, pos);  
         }  
         if ( ! p->outmacro)  
                 texiputchar(p, '\n');                  texiputchar(p, '\n');
           else
                   texivspace(p);
 }  }
   
 static void  static void
 dosubsection(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)  
 {  {
   
         if (TEXI_IGN & p->flags) {          /* Multitable is using raw tbl(7). */
                 advanceeoln(p, buf, sz, pos);          if (TEXILIST_TABLE == p->list) {
                   if (p->outcol > 0)
                           texiputchar(p, '\n');
                 return;                  return;
           }
   
           if (p->outmacro)
                   texierr(p, "item in open line scope!?");
           else if (p->literal)
                   texierr(p, "item in a literal scope!?");
   
           switch (p->list) {
           case (TEXILIST_ITEM):
                   teximacroopen(p, "It");
                   break;
           case (TEXILIST_NOITEM):
                   teximacro(p, "It");
                   break;
           default:
                   texivspace(p);
                   break;
         }          }
         while (*pos < sz && ' ' == buf[*pos])  
                 advance(p, buf, pos);          /* Trick so we don't start with Pp. */
         texifputs(p, ".Pp");          parseeoln(p, pos);
         while (*pos < sz && '\n' != buf[*pos]) {  
                 texiputchar(p, buf[*pos]);          if (TEXILIST_ITEM == p->list)
                 advance(p, buf, pos);                  teximacroclose(p);
         }          else if (p->outcol > 0)
         texifputs(p, ".Pp");                  texiputchar(p, '\n');
 }  }
   
 static void  static void
 dosection(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)  
 {  {
   
         if (TEXI_IGN & p->flags) {          /* This command is only useful in @multitable. */
                 advanceeoln(p, buf, sz, pos);          if (TEXILIST_TABLE == p->list && p->outcol)
                 return;                  texiputchar(p, '\t');
         }  
         while (*pos < sz && ' ' == buf[*pos])  
                 advance(p, buf, pos);  
         texifputs(p, ".Ss ");  
         while (*pos < sz && '\n' != buf[*pos]) {  
                 texiputchar(p, buf[*pos]);  
                 advance(p, buf, pos);  
         }  
         texiputchar(p, '\n');  
 }  }
   
 static void  static void
 dosh(struct texi *p, enum texicmd cmd,  domultitable(struct texi *p, enum texicmd cmd, size_t *pos)
         const char *buf, size_t sz, size_t *pos)  
 {  {
           enum texilist   sv = p->list;
           int             svliteral = p->literal;
           enum texicmd    type;
           size_t          i, end, columns;
   
         if (TEXI_IGN & p->flags) {          texivspace(p);
                 advanceeoln(p, buf, sz, pos);          p->list = TEXILIST_TABLE;
                 return;          /*
            * TS/TE blocks aren't "in mdoc(7)", so we can disregard the
            * fact that we're in literal mode right now.
            */
           p->literal = 0;
           teximacro(p, "TS");
           columns = 0;
   
           /* Advance to the first argument... */
           while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
                   advance(p, pos);
   
           /* Make sure we don't print anything when scanning. */
           p->ign++;
           if (*pos < BUFSZ(p) && '@' == BUF(p)[*pos]) {
                   /*
                    * Look for @columnfractions.
                    * We ignore these, but we do use the number of
                    * arguments to set the number of columns that we'll
                    * have.
                    */
                   type = texicmd(p, *pos, &end, NULL);
                   advanceto(p, pos, end);
                   if (TEXICMD_COLUMNFRACTIONS != type)
                           texierr(p, "unknown multitable command");
                   while (*pos < BUFSZ(p) && '\n' != BUF(p)[*pos]) {
                           while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
                                   advance(p, pos);
                           while (*pos < BUFSZ(p) && ! isws(BUF(p)[*pos])) {
                                   if ('\n' == BUF(p)[*pos])
                                           break;
                                   advance(p, pos);
                           }
                           columns++;
                   }
           } else
                   /*
                    * We have arguments.
                    * We could parse these, but it's easier to just let
                    * tbl(7) figure it out.
                    * So use this only to count arguments.
                    */
                   while (parselinearg(p, pos) > 0)
                           columns++;
           p->ign--;
   
           /* Left-justify each table entry. */
           for (i = 0; i < columns; i++) {
                   if (i > 0)
                           texiputchar(p, ' ');
                   texiputchar(p, 'l');
         }          }
         while (*pos < sz && ' ' == buf[*pos])  
                 advance(p, buf, pos);          texiputchar(p, '.');
         texifputs(p, ".Sh ");  
         while (*pos < sz && '\n' != buf[*pos]) {  
                 texiputchar(p, toupper(buf[*pos]));  
                 advance(p, buf, pos);  
         }  
         texiputchar(p, '\n');          texiputchar(p, '\n');
           p->outmacro++;
           parseto(p, pos, texitoks[cmd].tok);
           p->outmacro--;
           teximacro(p, "TE");
           p->literal = svliteral;
           p->list = sv;
 }  }
   
 static void  static void
 dotop(struct texi *p, enum texicmd cmd,  dotable(struct texi *p, enum texicmd cmd, size_t *pos)
         const char *buf, size_t sz, size_t *pos)  
 {  {
           enum texilist   sv = p->list;
   
         p->flags &= ~TEXI_HEADER;          advanceeoln(p, pos, 1);
         advanceeoln(p, buf, sz, pos);  
         teximacro(p, ".Dd $Mdocdate$");          p->list = TEXILIST_ITEM;
         teximacro(p, ".Dt SOMETHING 7");          teximacro(p, "Bl -tag -width Ds");
         teximacro(p, ".Os");          parseto(p, pos, texitoks[cmd].tok);
         teximacro(p, ".Sh NAME");          teximacro(p, "El");
         teximacro(p, ".Nm Something");          p->seenvs = 1;
         teximacro(p, ".Nd Something");          p->list = sv;
 }  }
   
 static void  static void
 doitem(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   end;          size_t   start;
   
         /* See if we have arguments... */          while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
         for (end = *pos; end < sz; end++)                  advance(p, pos);
                 if (' ' != buf[end] && '\t' != buf[end])          start = *pos;
                         break;          while (*pos < BUFSZ(p) && '\n' != BUF(p)[*pos])
                   advance(p, pos);
   
         /* If we have arguments, print them too. */          texiwarn(p, "unexpected \"end\": %.*s",
         if ('\n' != buf[end]) {                  (int)(*pos - start), &BUF(p)[start]);
                 texifputs(p, ".It");          advanceeoln(p, pos, 1);
                 /* FIXME: process commands. */  
                 while (*pos < sz && '\n' != buf[*pos]) {  
                         texiputchar(p, buf[*pos]);  
                         advance(p, buf, pos);  
                 }  
                 texiputchar(p, '\n');  
         } else  
                 teximacro(p, ".It");  
 }  }
   
 static void  static void
 dotable(struct texi *p, enum texicmd cmd,  doenumerate(struct texi *p, enum texicmd cmd, size_t *pos)
         const char *buf, size_t sz, size_t *pos)  
 {  {
           enum texilist    sv = p->list;
   
         teximacro(p, ".Bl -tag -width Ds");          advanceeoln(p, pos, 1);
         parseto(p, buf, sz, pos, "table");  
         teximacro(p, ".El");          p->list = TEXILIST_NOITEM;
           teximacro(p, "Bl -enum");
           parseto(p, pos, texitoks[cmd].tok);
           teximacro(p, "El");
           p->seenvs = 1;
           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;
   
         teximacro(p, ".Bl -bullet");          advanceeoln(p, pos, 1);
         parseto(p, buf, sz, pos, "itemize");  
         teximacro(p, ".El");          p->list = TEXILIST_NOITEM;
           teximacro(p, "Bl -bullet");
           parseto(p, pos, texitoks[cmd].tok);
           teximacro(p, "El");
           p->seenvs = 1;
           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)  
 {  {
         unsigned int     sv = p->flags;  
   
         p->flags |= TEXI_IGN;          p->ign++;
         parsebracket(p, buf, sz, pos);          parsebracket(p, pos, 0);
         p->flags = sv;          p->ign--;
 }  }
   
 static void  static void
 doignline(struct texi *p, enum texicmd cmd,  doignline(struct texi *p, enum texicmd cmd, size_t *pos)
         const char *buf, size_t sz, size_t *pos)  
 {  {
   
         advanceeoln(p, buf, sz, pos);          advanceeoln(p, pos, 1);
         if (*pos < sz)  
                 advance(p, buf, pos);  
 }  }
   
 static int  /*
 parsefile(struct texi *p, const char *fname)   * Parse colon-separated directories from "cp" (if not NULL) and returns
    * the array of pointers.
    * Prepends "base" to the array, if found.
    * This does NOT sanitise the directories!
    */
   static char **
   parsedirs(struct texi *p, const char *base, const char *cp, size_t *sz)
 {  {
         struct texifile  *f;          char             *tok, *str, *tofree;
         int               fd;          const char       *cpp;
         struct stat       st;          size_t            i = 0;
           char            **dirs;
   
         assert(p->filepos < 64);          /* Count up our expected arguments. */
         f = &p->files[p->filepos];          *sz = NULL != base;
         memset(f, 0, sizeof(struct texifile));          if (NULL != (cpp = cp))
                   for ((*sz)++; NULL != (cpp = strchr(cpp, ':')); (*sz)++)
                           cpp++;
   
         f->name = fname;          if (0 == *sz)
         if (-1 == (fd = open(fname, O_RDONLY, 0))) {                  return(NULL);
                 texifatal(p, fname);          if (NULL == (dirs = calloc(*sz, sizeof(char *))))
         } else if (-1 == fstat(fd, &st)) {                  texiabort(p, NULL);
                 close(fd);          if (NULL != base && NULL == (dirs[i++] = strdup(base)))
                 texifatal(p, fname);                  texiabort(p, NULL);
         }          if (NULL == cp)
                   return(dirs);
           if (NULL == (tofree = tok = str = strdup(cp)))
                   texiabort(p, NULL);
   
         f->mapsz = st.st_size;          for ( ; NULL != (tok = strsep(&str, ":")); i++)
         f->map = mmap(NULL, f->mapsz,                  if (NULL == (dirs[i] = strdup(tok)))
                 PROT_READ, MAP_SHARED, fd, 0);                          texiabort(p, NULL);
         close(fd);  
   
         if (MAP_FAILED == f->map) {          free(tofree);
                 texifatal(p, fname);          return(dirs);
                 return(0);  
         }  
   
         p->filepos++;  
         parseeof(p, f->map, f->mapsz);  
         texifilepop(p);  
         return(1);  
 }  }
   
 int  int
 main(int argc, char *argv[])  main(int argc, char *argv[])
 {  {
         struct texi      texi;          struct texi      texi;
         int              c, rc;          int              c;
         const char      *progname;          char            *dirpath, *dir, *ccp;
           const char      *progname, *Idir, *cp;
   
         progname = strrchr(argv[0], '/');          progname = strrchr(argv[0], '/');
         if (progname == NULL)          if (progname == NULL)
Line 992  main(int argc, char *argv[])
Line 2062  main(int argc, char *argv[])
         else          else
                 ++progname;                  ++progname;
   
         while (-1 != (c = getopt(argc, argv, "")))          memset(&texi, 0, sizeof(struct texi));
           texi.ign = 1;
           texi.outfile = stdout;
           Idir = NULL;
   
           while (-1 != (c = getopt(argc, argv, "C:I:")))
                 switch (c) {                  switch (c) {
                   case ('C'):
                           texi.chapters = optarg;
                           break;
                   case ('I'):
                           Idir = optarg;
                           break;
                 default:                  default:
                         goto usage;                          goto usage;
                 }                  }
   
         argv += optind;          argv += optind;
         if (0 == (argc -= optind))          argc -= optind;
                 goto usage;  
   
         memset(&texi, 0, sizeof(struct texi));          if (argc > 0) {
         texi.flags = TEXI_HEADER;                  if (NULL == (dirpath = strdup(argv[0])))
         rc = parsefile(&texi, argv[0]);                          texiabort(&texi, NULL);
         return(rc ? EXIT_SUCCESS : EXIT_FAILURE);                  if (NULL == (dir = dirname(dirpath)))
                           texiabort(&texi, NULL);
                   if (NULL != (cp = strrchr(argv[0], '/')))
                           texi.title = strdup(cp + 1);
                   else
                           texi.title = strdup(argv[0]);
                   if (NULL == texi.title)
                           texiabort(&texi, NULL);
                   else if (NULL != (ccp = strchr(texi.title, '.')))
                           *ccp = '\0';
                   texi.dirs = parsedirs(&texi, dir, Idir, &texi.dirsz);
                   free(dirpath);
                   parsefile(&texi, argv[0], 1);
           } else {
                   texi.title = strdup("Unknown Manual");
                   texi.dirs = parsedirs(&texi, NULL, Idir, &texi.dirsz);
                   parsestdin(&texi);
           }
   
           texiexit(&texi);
           exit(EXIT_SUCCESS);
 usage:  usage:
         fprintf(stderr, "usage: %s file\n", progname);          fprintf(stderr, "usage: %s [-Cdir] [-Idirs] [file]\n", progname);
         return(EXIT_FAILURE);          return(EXIT_FAILURE);
 }  }
Legend:
Removed from v.1.1.1.1  
changed lines
  Added in v.1.64
CVSweb