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

Diff for /texi2mdoc/main.c between version 1.3 and 1.20

version 1.3, 2015/02/17 17:02:03 version 1.20, 2015/02/19 16:15:17
Line 27 
Line 27 
 #include <stdio.h>  #include <stdio.h>
 #include <stdlib.h>  #include <stdlib.h>
 #include <string.h>  #include <string.h>
   #include <time.h>
   #include <unistd.h>
   
 /*  /*
  * This defines each one of the Texinfo commands that we understand.   * This defines each one of the Texinfo commands that we understand.
Line 35 
Line 37 
  */   */
 enum    texicmd {  enum    texicmd {
         TEXICMD_ACRONYM,          TEXICMD_ACRONYM,
           TEXICMD_ACUTE,
         TEXICMD_A4PAPER,          TEXICMD_A4PAPER,
         TEXICMD_ANCHOR,          TEXICMD_ANCHOR,
         TEXICMD_APPENDIX,          TEXICMD_APPENDIX,
         TEXICMD_APPENDIXSEC,          TEXICMD_APPENDIXSEC,
           TEXICMD_APPENDIXSUBSEC,
         TEXICMD_ASTERISK,          TEXICMD_ASTERISK,
         TEXICMD_AT,          TEXICMD_AT,
         TEXICMD_AUTHOR,          TEXICMD_AUTHOR,
           TEXICMD_B,
         TEXICMD_BANG,          TEXICMD_BANG,
           TEXICMD_BULLET,
         TEXICMD_BYE,          TEXICMD_BYE,
           TEXICMD_CENTER,
         TEXICMD_CHAPTER,          TEXICMD_CHAPTER,
         TEXICMD_CINDEX,          TEXICMD_CINDEX,
           TEXICMD_CIRCUMFLEX,
         TEXICMD_CITE,          TEXICMD_CITE,
         TEXICMD_CODE,          TEXICMD_CODE,
         TEXICMD_COLON,          TEXICMD_COLON,
           TEXICMD_COLUMNFRACTIONS,
         TEXICMD_COMMAND,          TEXICMD_COMMAND,
         TEXICMD_COMMENT,          TEXICMD_COMMENT,
         TEXICMD_COMMENT_LONG,          TEXICMD_COMMENT_LONG,
         TEXICMD_CONTENTS,          TEXICMD_CONTENTS,
         TEXICMD_COPYING,          TEXICMD_COPYING,
         TEXICMD_COPYRIGHT,          TEXICMD_COPYRIGHT,
           TEXICMD_DEFFN,
           TEXICMD_DEFFNX,
           TEXICMD_DEFMAC,
           TEXICMD_DEFMACX,
           TEXICMD_DEFTP,
           TEXICMD_DEFTPX,
         TEXICMD_DEFTYPEFN,          TEXICMD_DEFTYPEFN,
         TEXICMD_DEFTYPEFNX,          TEXICMD_DEFTYPEFNX,
         TEXICMD_DEFTYPEFUN,          TEXICMD_DEFTYPEFUN,
         TEXICMD_DEFTYPEFUNX,          TEXICMD_DEFTYPEFUNX,
         TEXICMD_DEFTYPEVAR,          TEXICMD_DEFTYPEVAR,
           TEXICMD_DEFTYPEVARX,
         TEXICMD_DEFTYPEVR,          TEXICMD_DEFTYPEVR,
           TEXICMD_DEFTYPEVRX,
           TEXICMD_DEFUN,
           TEXICMD_DEFUNX,
           TEXICMD_DEFVAR,
           TEXICMD_DEFVARX,
           TEXICMD_DEFVR,
           TEXICMD_DEFVRX,
         TEXICMD_DETAILMENU,          TEXICMD_DETAILMENU,
         TEXICMD_DFN,          TEXICMD_DFN,
         TEXICMD_DIRCATEGORY,          TEXICMD_DIRCATEGORY,
Line 72  enum texicmd {
Line 95  enum texicmd {
         TEXICMD_END,          TEXICMD_END,
         TEXICMD_ENUMERATE,          TEXICMD_ENUMERATE,
         TEXICMD_ENV,          TEXICMD_ENV,
           TEXICMD_ERROR,
         TEXICMD_EXAMPLE,          TEXICMD_EXAMPLE,
           TEXICMD_EXPANSION,
         TEXICMD_FILE,          TEXICMD_FILE,
           TEXICMD_FINALOUT,
           TEXICMD_FINDEX,
           TEXICMD_FTABLE,
           TEXICMD_FORMAT,
           TEXICMD_GRAVE,
         TEXICMD_GROUP,          TEXICMD_GROUP,
         TEXICMD_HEADING,          TEXICMD_HEADING,
         TEXICMD_HEADINGS,          TEXICMD_HEADINGS,
           TEXICMD_HEADITEM,
         TEXICMD_HYPHEN,          TEXICMD_HYPHEN,
         TEXICMD_I,          TEXICMD_I,
         TEXICMD_IFCLEAR,          TEXICMD_IFCLEAR,
           TEXICMD_IFDOCBOOK,
         TEXICMD_IFHTML,          TEXICMD_IFHTML,
         TEXICMD_IFINFO,          TEXICMD_IFINFO,
           TEXICMD_IFNOTDOCBOOK,
           TEXICMD_IFNOTHTML,
           TEXICMD_IFNOTINFO,
           TEXICMD_IFNOTPLAINTEXT,
         TEXICMD_IFNOTTEX,          TEXICMD_IFNOTTEX,
           TEXICMD_IFNOTXML,
           TEXICMD_IFPLAINTEXT,
         TEXICMD_IFTEX,          TEXICMD_IFTEX,
         TEXICMD_IFSET,          TEXICMD_IFSET,
           TEXICMD_IFXML,
           TEXICMD_IGNORE,
         TEXICMD_IMAGE,          TEXICMD_IMAGE,
         TEXICMD_INCLUDE,          TEXICMD_INCLUDE,
           TEXICMD_INDENTBLOCK,
           TEXICMD_INSERTCOPYING,
         TEXICMD_ITEM,          TEXICMD_ITEM,
         TEXICMD_ITEMIZE,          TEXICMD_ITEMIZE,
           TEXICMD_ITEMX,
         TEXICMD_KBD,          TEXICMD_KBD,
           TEXICMD_KEY,
           TEXICMD_KINDEX,
         TEXICMD_LATEX,          TEXICMD_LATEX,
         TEXICMD_MATH,          TEXICMD_MATH,
         TEXICMD_MENU,          TEXICMD_MENU,
           TEXICMD_MULTITABLE,
           TEXICMD_NEED,
         TEXICMD_NEWLINE,          TEXICMD_NEWLINE,
         TEXICMD_NODE,          TEXICMD_NODE,
         TEXICMD_NOINDENT,          TEXICMD_NOINDENT,
           TEXICMD_OPTION,
           TEXICMD_PXREF,
         TEXICMD_QUESTIONMARK,          TEXICMD_QUESTIONMARK,
         TEXICMD_QUOTATION,          TEXICMD_QUOTATION,
         TEXICMD_PAGE,          TEXICMD_PAGE,
         TEXICMD_PARINDENT,          TEXICMD_PARINDENT,
         TEXICMD_PRINTINDEX,          TEXICMD_PRINTINDEX,
           TEXICMD_R,
         TEXICMD_REF,          TEXICMD_REF,
           TEXICMD_RESULT,
         TEXICMD_SAMP,          TEXICMD_SAMP,
           TEXICMD_SANSSERIF,
           TEXICMD_SC,
         TEXICMD_SECTION,          TEXICMD_SECTION,
         TEXICMD_SET,          TEXICMD_SET,
         TEXICMD_SETCHAPNEWPAGE,          TEXICMD_SETCHAPNEWPAGE,
         TEXICMD_SETFILENAME,          TEXICMD_SETFILENAME,
         TEXICMD_SETTITLE,          TEXICMD_SETTITLE,
           TEXICMD_SLANTED,
         TEXICMD_SP,          TEXICMD_SP,
         TEXICMD_SPACE,          TEXICMD_SPACE,
           TEXICMD_SMALLBOOK,
           TEXICMD_SMALLDISPLAY,
         TEXICMD_SMALLEXAMPLE,          TEXICMD_SMALLEXAMPLE,
           TEXICMD_SMALLFORMAT,
           TEXICMD_SMALLINDENTBLOCK,
         TEXICMD_SQUIGGLE_LEFT,          TEXICMD_SQUIGGLE_LEFT,
         TEXICMD_SQUIGGLE_RIGHT,          TEXICMD_SQUIGGLE_RIGHT,
           TEXICMD_STRONG,
           TEXICMD_SUBHEADING,
         TEXICMD_SUBSECTION,          TEXICMD_SUBSECTION,
         TEXICMD_SUBTITLE,          TEXICMD_SUBTITLE,
           TEXICMD_SYNCODEINDEX,
           TEXICMD_T,
         TEXICMD_TAB,          TEXICMD_TAB,
           TEXICMD_TABSYM,
         TEXICMD_TABLE,          TEXICMD_TABLE,
         TEXICMD_TEX,          TEXICMD_TEX,
         TEXICMD_TEXSYM,          TEXICMD_TEXSYM,
           TEXICMD_TILDE,
         TEXICMD_TITLE,          TEXICMD_TITLE,
         TEXICMD_TITLEFONT,          TEXICMD_TITLEFONT,
         TEXICMD_TITLEPAGE,          TEXICMD_TITLEPAGE,
         TEXICMD_TOP,          TEXICMD_TOP,
           TEXICMD_UMLAUT,
         TEXICMD_UNNUMBERED,          TEXICMD_UNNUMBERED,
         TEXICMD_UNNUMBEREDSEC,          TEXICMD_UNNUMBEREDSEC,
           TEXICMD_UNNUMBEREDSUBSEC,
         TEXICMD_UREF,          TEXICMD_UREF,
         TEXICMD_URL,          TEXICMD_URL,
         TEXICMD_VAR,          TEXICMD_VAR,
           TEXICMD_VERBATIMINCLUDE,
           TEXICMD_VINDEX,
           TEXICMD_VSKIP,
           TEXICMD_VTABLE,
         TEXICMD_W,          TEXICMD_W,
           TEXICMD_XREF,
         TEXICMD__MAX          TEXICMD__MAX
 };  };
   
Line 165  enum texilist {
Line 236  enum texilist {
         TEXILIST_NONE = 0,          TEXILIST_NONE = 0,
         TEXILIST_ITEM,          TEXILIST_ITEM,
         TEXILIST_NOITEM,          TEXILIST_NOITEM,
           TEXILIST_TABLE
 };  };
   
 /*  /*
Line 172  enum texilist {
Line 244  enum texilist {
  * This keeps any necessary information handy.   * This keeps any necessary information handy.
  */   */
 struct  texi {  struct  texi {
         struct texifile  files[64];          struct texifile   files[64]; /* stack of open files */
         size_t           filepos;          size_t            filepos; /* number of open files */
         size_t           outcol; /* column of output */          size_t            outcol; /* column in output line */
         int              outmacro; /* whether output is in line macro */          char            **dirs; /* texi directories */
         int              seenws; /* whitespace has been ignored */          size_t            dirsz; /* number of texi directories */
         int              ign; /* don't print anything */          char             *title; /* title of document */
         int              literal;          char             *subtitle; /* subtitle of document */
         char            *dir; /* texi directory */          /*
         enum texilist    list;           * The following control what we output to the screen.
            * The complexity is required to accomodate for mdoc(7).
            */
           enum texilist     list; /* current list (set recursively) */
           int               outmacro; /* if >0, output is in line macro */
           int               seenws; /* ws has been seen (and ignored) */
           int               seenvs; /* newline has been Pp'd */
           int               ign; /* if >0, don't print anything */
           int               literal; /* if >0, literal context */
 };  };
   
 /* FIXME: don't use this crap. */  /* Texi disregards spaces and tabs. */
 #define ismpunct(_x) \  
         ('.' == (_x) || \  
          ',' == (_x) || \  
          ';' == (_x))  
 #define isws(_x) \  #define isws(_x) \
         (' ' == (_x) || '\t' == (_x))          (' ' == (_x) || '\t' == (_x))
   #define ismspace(_x) \
           (isws((_x)) || '\n' == (_x))
   
 static  void doarg1(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void doaccent(struct texi *, enum texicmd, const char *, size_t, size_t *);
 static  void doblock(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void doblock(struct texi *, enum texicmd, const char *, size_t, size_t *);
 static  void dobracket(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void dobracket(struct texi *, enum texicmd, const char *, size_t, size_t *);
 static  void dobye(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void dobye(struct texi *, enum texicmd, const char *, size_t, size_t *);
 static  void dochapter(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void dodefn(struct texi *, enum texicmd, const char *, size_t, size_t *);
 static  void docommand(struct texi *, enum texicmd, const char *, size_t, size_t *);  
 static  void dodeftypefun(struct texi *, enum texicmd, const char *, size_t, size_t *);  
 static  void dodeftypevar(struct texi *, enum texicmd, const char *, size_t, size_t *);  
 static  void dodisplay(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void dodisplay(struct texi *, enum texicmd, const char *, size_t, size_t *);
 static  void doemph(struct texi *, enum texicmd, const char *, size_t, size_t *);  
 static  void doenumerate(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void doenumerate(struct texi *, enum texicmd, const char *, size_t, size_t *);
 static  void doenv(struct texi *, enum texicmd, const char *, size_t, size_t *);  
 static  void doexample(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void doexample(struct texi *, enum texicmd, const char *, size_t, size_t *);
 static  void dofile(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void dofont(struct texi *, enum texicmd, const char *, size_t, size_t *);
   static  void doignargn(struct texi *, enum texicmd, const char *, size_t, size_t *);
 static  void doignblock(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 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 doignline(struct texi *, enum texicmd, const char *, size_t, size_t *);
   static  void doinline(struct texi *, enum texicmd, const char *, size_t, size_t *);
 static  void doinclude(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void doinclude(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 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 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 dolink(struct texi *, enum texicmd, const char *, size_t, size_t *);
 static  void domath(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void domath(struct texi *, enum texicmd, const char *, size_t, size_t *);
   static  void domultitable(struct texi *, enum texicmd, const char *, size_t, size_t *);
 static  void doquotation(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void doquotation(struct texi *, enum texicmd, const char *, size_t, size_t *);
 static  void dotable(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void dotable(struct texi *, enum texicmd, const char *, size_t, size_t *);
 static  void dotop(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void dotop(struct texi *, enum texicmd, const char *, size_t, size_t *);
Line 221  static void dosection(struct texi *, enum texicmd, con
Line 296  static void dosection(struct texi *, enum texicmd, con
 static  void dosp(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void dosp(struct texi *, enum texicmd, const char *, size_t, size_t *);
 static  void dosubsection(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void dosubsection(struct texi *, enum texicmd, const char *, size_t, size_t *);
 static  void dosymbol(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void dosymbol(struct texi *, enum texicmd, const char *, size_t, size_t *);
   static  void dotab(struct texi *, enum texicmd, const char *, size_t, size_t *);
   static  void dotitle(struct texi *, enum texicmd, const char *, size_t, size_t *);
   static  void doverbinclude(struct texi *, enum texicmd, const char *, size_t, size_t *);
   
 static  const struct texitok texitoks[TEXICMD__MAX] = {  static  const struct texitok texitoks[TEXICMD__MAX] = {
         { doarg1, "acronym", 7 }, /* TEXICMD_ACRONYM */          /* TEXICMD__BEGIN */
           { doignargn, "acronym", 7 }, /* TEXICMD_ACRONYM */
           { doaccent, "'", 1 }, /* TEXICMD_ACUTE */
         { doignline, "afourpaper", 10 }, /* TEXICMD_A4PAPER */          { doignline, "afourpaper", 10 }, /* TEXICMD_A4PAPER */
         { doignbracket, "anchor", 6 }, /* TEXICMD_ANCHOR */          { doignbracket, "anchor", 6 }, /* TEXICMD_ANCHOR */
         { dochapter, "appendix", 8 }, /* TEXICMD_APPENDIX */          { dosection, "appendix", 8 }, /* TEXICMD_APPENDIX */
         { dochapter, "appendixsec", 11 }, /* TEXICMD_APPENDIXSEC */          { dosection, "appendixsec", 11 }, /* TEXICMD_APPENDIXSEC */
           { dosubsection, "appendixsubsec", 14 }, /* TEXICMD_APPENDIXSUBSEC */
         { dosymbol, "*", 1 }, /* TEXICMD_ASTERISK */          { dosymbol, "*", 1 }, /* TEXICMD_ASTERISK */
         { dosymbol, "@", 1 }, /* TEXICMD_AT */          { dosymbol, "@", 1 }, /* TEXICMD_AT */
         { doignline, "author", 6 }, /* TEXICMD_AUTHOR */          { doignline, "author", 6 }, /* TEXICMD_AUTHOR */
           { dofont, "b", 1 }, /* TEXICMD_BOLD */
         { dosymbol, "!", 1 }, /* TEXICMD_BANG */          { dosymbol, "!", 1 }, /* TEXICMD_BANG */
           { dosymbol, "bullet", 6 }, /* TEXICMD_BULLET */
         { dobye, "bye", 3 }, /* TEXICMD_BYE */          { dobye, "bye", 3 }, /* TEXICMD_BYE */
         { dochapter, "chapter", 7 }, /* TEXICMD_CHAPTER */          { 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 */
         { doitalic, "cite", 4 }, /* TEXICMD_CITE */          { dofont, "code", 4 }, /* TEXICMD_CODE */
           { dofont, "cite", 4 }, /* TEXICMD_CITE */
         { dosymbol, ":", 1 }, /* TEXICMD_COLON */          { dosymbol, ":", 1 }, /* TEXICMD_COLON */
         { docommand, "command", 7 }, /* TEXICMD_COMMAND */          { NULL, "columnfractions", 15 }, /* TEXICMD_COLUMNFRACTIONS */
           { doinline, "command", 7 }, /* TEXICMD_COMMAND */
         { doignline, "c", 1 }, /* TEXICMD_COMMENT */          { doignline, "c", 1 }, /* TEXICMD_COMMENT */
         { doignline, "comment", 7 }, /* TEXICMD_COMMENT_LONG */          { doignline, "comment", 7 }, /* TEXICMD_COMMENT_LONG */
         { doignline, "contents", 8 }, /* TEXICMD_CONTENTS */          { doignline, "contents", 8 }, /* TEXICMD_CONTENTS */
         { doignblock, "copying", 7 }, /* TEXICMD_COPYING */          { doignblock, "copying", 7 }, /* TEXICMD_COPYING */
         { dosymbol, "copyright", 9 }, /* TEXICMD_COPYRIGHT */          { dosymbol, "copyright", 9 }, /* TEXICMD_COPYRIGHT */
         { dodeftypefun, "deftypefn", 9 }, /* TEXICMD_DEFTYPEFN */          { dodefn, "deffn", 5 }, /* TEXICMD_DEFFN */
         { dodeftypefun, "deftypefnx", 10 }, /* TEXICMD_DEFTYPEFNX */          { dodefn, "deffnx", 6 }, /* TEXICMD_DEFFNX */
         { dodeftypefun, "deftypefun", 10 }, /* TEXICMD_DEFTYPEFUN */          { dodefn, "defmac", 6 }, /* TEXICMD_DEFMAC */
         { dodeftypefun, "deftypefunx", 11 }, /* TEXICMD_DEFTYPEFUNX */          { dodefn, "defmacx", 7 }, /* TEXICMD_DEFMACX */
         { dodeftypevar, "deftypevar", 10 }, /* TEXICMD_DEFTYPEVAR */          { dodefn, "deftp", 5 }, /* TEXICMD_DEFTP */
         { dodeftypevar, "deftypevr", 9 }, /* TEXICMD_DEFTYPEVR */          { dodefn, "deftpx", 6 }, /* TEXICMD_DEFTPX */
           { dodefn, "deftypefn", 9 }, /* TEXICMD_DEFTYPEFN */
           { dodefn, "deftypefnx", 10 }, /* TEXICMD_DEFTYPEFNX */
           { dodefn, "deftypefun", 10 }, /* TEXICMD_DEFTYPEFUN */
           { dodefn, "deftypefunx", 11 }, /* TEXICMD_DEFTYPEFUNX */
           { dodefn, "deftypevar", 10 }, /* TEXICMD_DEFTYPEVAR */
           { dodefn, "deftypevarx", 11 }, /* TEXICMD_DEFTYPEVARX */
           { dodefn, "deftypevr", 9 }, /* TEXICMD_DEFTYPEVR */
           { dodefn, "deftypevrx", 10 }, /* TEXICMD_DEFTYPEVRX */
           { dodefn, "defun", 5 }, /* TEXICMD_DEFUN */
           { dodefn, "defunx", 6 }, /* TEXICMD_DEFUNX */
           { dodefn, "defvar", 6 }, /* TEXICMD_DEFVAR */
           { dodefn, "defvarx", 7 }, /* TEXICMD_DEFVARX */
           { dodefn, "defvr", 5 }, /* TEXICMD_DEFVR */
           { dodefn, "defvrx", 6 }, /* TEXICMD_DEFVRX */
         { doignblock, "detailmenu", 10 }, /* TEXICMD_DETAILMENU */          { doignblock, "detailmenu", 10 }, /* TEXICMD_DETAILMENU */
         { doitalic, "dfn", 3 }, /* TEXICMD_DFN */          { dofont, "dfn", 3 }, /* TEXICMD_DFN */
         { doignline, "dircategory", 11 }, /* TEXICMD_DIRCATEGORY */          { doignline, "dircategory", 11 }, /* TEXICMD_DIRCATEGORY */
         { doignblock, "direntry", 8 }, /* TEXICMD_DIRENTRY */          { doignblock, "direntry", 8 }, /* TEXICMD_DIRENTRY */
         { dodisplay, "display", 7 }, /* TEXICMD_DISPLAY */          { dodisplay, "display", 7 }, /* TEXICMD_DISPLAY */
         { dosymbol, "dots", 4 }, /* TEXICMD_DOTS */          { dosymbol, "dots", 4 }, /* TEXICMD_DOTS */
         { doarg1, "email", 5 }, /* TEXICMD_EMAIL */          { dolink, "email", 5 }, /* TEXICMD_EMAIL */
         { doemph, "emph", 4 }, /* TEXICMD_EMPH */          { dofont, "emph", 4 }, /* TEXICMD_EMPH */
         { NULL, "end", 3 }, /* TEXICMD_END */          { NULL, "end", 3 }, /* TEXICMD_END */
         { doenumerate, "enumerate", 9 }, /* TEXICMD_ENUMERATE */          { doenumerate, "enumerate", 9 }, /* TEXICMD_ENUMERATE */
         { doenv, "env", 3 }, /* TEXICMD_ENV */          { doinline, "env", 3 }, /* TEXICMD_ENV */
           { dosymbol, "error", 5 }, /* TEXICMD_ERROR */
         { doexample, "example", 7 }, /* TEXICMD_EXAMPLE */          { doexample, "example", 7 }, /* TEXICMD_EXAMPLE */
         { dofile, "file", 4 }, /* TEXICMD_FILE */          { dosymbol, "expansion", 9 }, /* TEXICMD_EXPANSION */
           { doinline, "file", 4 }, /* TEXICMD_FILE */
           { doignline, "finalout", 8 }, /* TEXICMD_FINALOUT */
           { doignline, "findex", 6 }, /* TEXICMD_FINDEX */
           { dotable, "ftable", 6 }, /* TEXICMD_FTABLE */
           { dodisplay, "format", 6 }, /* TEXICMD_FORMAT */
           { doaccent, "`", 1 }, /* TEXICMD_GRAVE */
         { doblock, "group", 5 }, /* TEXICMD_GROUP */          { doblock, "group", 5 }, /* TEXICMD_GROUP */
         { dosection, "heading", 7 }, /* TEXICMD_HEADING */          { dosection, "heading", 7 }, /* TEXICMD_HEADING */
         { doignline, "headings", 8 }, /* TEXICMD_HEADINGS */          { doignline, "headings", 8 }, /* TEXICMD_HEADINGS */
           { doitem, "headitem", 8 }, /* TEXICMD_HEADITEM */
         { dosymbol, "-", 1 }, /* TEXICMD_HYPHEN */          { dosymbol, "-", 1 }, /* TEXICMD_HYPHEN */
         { doitalic, "i", 1 }, /* TEXICMD_I */          { dofont, "i", 1 }, /* TEXICMD_I */
         { doignblock, "ifclear", 7 }, /* TEXICMD_IFCLEAR */          { doignblock, "ifclear", 7 }, /* TEXICMD_IFCLEAR */
           { doignblock, "ifdocbook", 9 }, /* TEXICMD_IFDOCBOOK */
         { doignblock, "ifhtml", 6 }, /* TEXICMD_IFHTML */          { doignblock, "ifhtml", 6 }, /* TEXICMD_IFHTML */
         { doignblock, "ifinfo", 6 }, /* TEXICMD_IFINFO */          { doignblock, "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, "ifnottex", 8 }, /* TEXICMD_IFNOTTEX */
           { doblock, "ifnotxml", 8 }, /* TEXICMD_IFNOTXML */
           { doblock, "ifplaintext", 11 }, /* TEXICMD_IFPLAINTEXT */
         { doignblock, "iftex", 5 }, /* TEXICMD_IFTEX */          { doignblock, "iftex", 5 }, /* TEXICMD_IFTEX */
         { doignblock, "ifset", 5 }, /* TEXICMD_IFSET */          { doignblock, "ifset", 5 }, /* TEXICMD_IFSET */
           { doignblock, "ifxml", 5 }, /* TEXICMD_IFXML */
           { doignblock, "ignore", 6 }, /* TEXICMD_IGNORE */
         { doignbracket, "image", 5 }, /* TEXICMD_IMAGE */          { doignbracket, "image", 5 }, /* TEXICMD_IMAGE */
         { doinclude, "include", 7 }, /* TEXICMD_INCLUDE */          { doinclude, "include", 7 }, /* TEXICMD_INCLUDE */
           { dodisplay, "indentblock", 11 }, /* TEXICMD_INDENTBLOCK */
           { doignline, "insertcopying", 13 }, /* TEXICMD_INSERTCOPYING */
         { doitem, "item", 4 }, /* TEXICMD_ITEM */          { doitem, "item", 4 }, /* TEXICMD_ITEM */
         { doitemize, "itemize", 7 }, /* TEXICMD_ITEMIZE */          { doitemize, "itemize", 7 }, /* TEXICMD_ITEMIZE */
         { doliteral, "kbd", 3 }, /* TEXICMD_KBD */          { doitem, "itemx", 5 }, /* TEXICMD_ITEMX */
           { dofont, "kbd", 3 }, /* TEXICMD_KBD */
           { dobracket, "key", 3 }, /* TEXICMD_KEY */
           { doignline, "kindex", 6 }, /* TEXICMD_KINDEX */
         { dosymbol, "LaTeX", 5 }, /* TEXICMD_LATEX */          { dosymbol, "LaTeX", 5 }, /* TEXICMD_LATEX */
         { domath, "math", 4 }, /* TEXICMD_MATH */          { domath, "math", 4 }, /* TEXICMD_MATH */
         { doignblock, "menu", 4 }, /* TEXICMD_MENU */          { doignblock, "menu", 4 }, /* TEXICMD_MENU */
           { domultitable, "multitable", 10 }, /* TEXICMD_MULTITABLE */
           { doignline, "need", 4 }, /* TEXICMD_NEED */
         { dosymbol, "\n", 1 }, /* TEXICMD_NEWLINE */          { dosymbol, "\n", 1 }, /* TEXICMD_NEWLINE */
         { doignline, "node", 4 }, /* TEXICMD_NODE */          { doignline, "node", 4 }, /* TEXICMD_NODE */
         { doignline, "noindent", 8 }, /* TEXICMD_NOINDENT */          { doignline, "noindent", 8 }, /* TEXICMD_NOINDENT */
           { doinline, "option", 6 }, /* TEXICMD_OPTION */
           { dolink, "pxref", 5 }, /* TEXICMD_PXREF */
         { dosymbol, "?", 1 }, /* TEXICMD_QUESTIONMARK */          { dosymbol, "?", 1 }, /* TEXICMD_QUESTIONMARK */
         { doquotation, "quotation", 9 }, /* TEXICMD_QUOTATION */          { doquotation, "quotation", 9 }, /* TEXICMD_QUOTATION */
         { doignline, "page", 4 }, /* TEXICMD_PAGE */          { doignline, "page", 4 }, /* TEXICMD_PAGE */
         { doignline, "paragraphindent", 14 }, /* TEXICMD_PARINDENT */          { doignline, "paragraphindent", 14 }, /* TEXICMD_PARINDENT */
         { doignline, "printindex", 10 }, /* TEXICMD_PRINTINDEX */          { doignline, "printindex", 10 }, /* TEXICMD_PRINTINDEX */
           { dofont, "r", 1 }, /* TEXICMD_R */
         { dobracket, "ref", 3 }, /* TEXICMD_REF */          { dobracket, "ref", 3 }, /* TEXICMD_REF */
         { doliteral, "samp", 4 }, /* TEXICMD_SAMP */          { dosymbol, "result", 6 }, /* TEXICMD_RESULT */
           { dofont, "samp", 4 }, /* TEXICMD_SAMP */
           { dofont, "sansserif", 9 }, /* TEXICMD_SANSSERIF */
           { dobracket, "sc", 2 }, /* TEXICMD_SC */
         { dosection, "section", 7 }, /* TEXICMD_SECTION */          { dosection, "section", 7 }, /* TEXICMD_SECTION */
         { doignline, "set", 3 }, /* TEXICMD_SET */          { doignline, "set", 3 }, /* TEXICMD_SET */
         { doignline, "setchapternewpage", 17 }, /* TEXICMD_SETCHAPNEWPAGE */          { doignline, "setchapternewpage", 17 }, /* TEXICMD_SETCHAPNEWPAGE */
         { doignline, "setfilename", 11 }, /* TEXICMD_SETFILENAME */          { doignline, "setfilename", 11 }, /* TEXICMD_SETFILENAME */
           { dotitle, "settitle", 8 }, /* TEXICMD_SETTITLE */
           { dofont, "slanted", 7 }, /* TEXICMD_SLANTED */
         { dosp, "sp", 2 }, /* TEXICMD_SP */          { dosp, "sp", 2 }, /* TEXICMD_SP */
         { dosymbol, " ", 1 }, /* TEXICMD_SPACE */          { dosymbol, " ", 1 }, /* TEXICMD_SPACE */
           { doignline, "smallbook", 9 }, /* TEXICMD_SMALLBOOK */
           { dodisplay, "smalldisplay", 12 }, /* TEXICMD_SMALLDISPLAY */
         { doexample, "smallexample", 12 }, /* TEXICMD_SMALLEXAMPLE */          { doexample, "smallexample", 12 }, /* TEXICMD_SMALLEXAMPLE */
         { doignline, "settitle", 8 }, /* TEXICMD_SETTITLE */          { dodisplay, "smallformat", 11 }, /* TEXICMD_SMALLFORMAT */
           { dodisplay, "smallindentblock", 16 }, /* TEXICMD_SMALLINDENTBLOCK */
         { dosymbol, "{", 1 }, /* TEXICMD_SQUIGGLE_LEFT */          { dosymbol, "{", 1 }, /* TEXICMD_SQUIGGLE_LEFT */
         { dosymbol, "}", 1 }, /* TEXICMD_SQUIGGLE_RIGHT */          { dosymbol, "}", 1 }, /* TEXICMD_SQUIGGLE_RIGHT */
           { dofont, "strong", 6 }, /* TEXICMD_STRONG */
           { dosubsection, "subheading", 10 }, /* TEXICMD_SUBHEADING */
         { dosubsection, "subsection", 10 }, /* TEXICMD_SUBSECTION */          { dosubsection, "subsection", 10 }, /* TEXICMD_SUBSECTION */
         { doignline, "subtitle", 8 }, /* TEXICMD_SUBTITLE */          { doignline, "subtitle", 8 }, /* TEXICMD_SUBTITLE */
         { dosymbol, "\t", 1 }, /* TEXICMD_TAB */          { doignline, "syncodeindex", 12 }, /* TEXICMD_SYNCODEINDEX */
           { dofont, "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 */
           { doaccent, "~", 1 }, /* TEXICMD_TILDE */
         { doignline, "title", 5 }, /* TEXICMD_TITLE */          { doignline, "title", 5 }, /* TEXICMD_TITLE */
         { dobracket, "titlefont", 9 }, /* TEXICMD_TITLEFONT */          { dobracket, "titlefont", 9 }, /* TEXICMD_TITLEFONT */
         { doignblock, "titlepage", 9 }, /* TEXICMD_TITLEPAGE */          { doignblock, "titlepage", 9 }, /* TEXICMD_TITLEPAGE */
         { dotop, "top", 3 }, /* TEXICMD_TOP */          { dotop, "top", 3 }, /* TEXICMD_TOP */
         { dochapter, "unnumbered", 10 }, /* TEXICMD_UNNUMBERED */          { doaccent, "\"", 1 }, /* TEXICMD_UMLAUT */
           { dosection, "unnumbered", 10 }, /* TEXICMD_UNNUMBERED */
         { dosection, "unnumberedsec", 13 }, /* TEXICMD_UNNUMBEREDSEC */          { dosection, "unnumberedsec", 13 }, /* TEXICMD_UNNUMBEREDSEC */
         { doarg1, "uref", 4 }, /* TEXICMD_UREF */          { dosubsection, "unnumberedsubsec", 16 }, /* TEXICMD_UNNUMBEREDSUBSEC */
         { doarg1, "url", 3 }, /* TEXICMD_URL */          { dolink, "uref", 4 }, /* TEXICMD_UREF */
         { doliteral, "var", 3 }, /* TEXICMD_VAR */          { dolink, "url", 3 }, /* TEXICMD_URL */
           { doinline, "var", 3 }, /* TEXICMD_VAR */
           { 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 */          { dobracket, "w", 1 }, /* TEXICMD_W */
           { dolink, "xref", 4 }, /* TEXICMD_XREF */
           /* TEXICMD__END */
 };  };
   
 /*  /*
Line 334  texifilepop(struct texi *p)
Line 483  texifilepop(struct texi *p)
 }  }
   
 /*  /*
  * Unmap all files that we're currently using.   * Unmap all files that we're currently using and free all resources
    * that we've allocated during the parse.
  * The utility should exit(...) after this is called.   * The utility should exit(...) after this is called.
  */   */
 static void  static void
 texiexit(struct texi *p)  texiexit(struct texi *p)
 {  {
           size_t   i;
   
         while (p->filepos > 0)  
                 texifilepop(p);  
         free(p->dir);  
         if (p->outcol)          if (p->outcol)
                 putchar('\n');                  putchar('\n');
   
           while (p->filepos > 0)
                   texifilepop(p);
   
           for (i = 0; i < p->dirsz; i++)
                   free(p->dirs[i]);
   
           free(p->dirs);
           free(p->subtitle);
           free(p->title);
 }  }
   
 /*  /*
Line 380  texiwarn(const struct texi *p, const char *fmt, ...)
Line 538  texiwarn(const struct texi *p, const char *fmt, ...)
         fputc('\n', stderr);          fputc('\n', stderr);
 }  }
   
   /*
    * Print an error message (to stderr) tied to our current location in
    * the parse sequence, invoke texiexit(), then die.
    */
 static void  static void
 texierr(struct texi *p, const char *fmt, ...)  texierr(struct texi *p, const char *fmt, ...)
 {  {
Line 398  texierr(struct texi *p, const char *fmt, ...)
Line 560  texierr(struct texi *p, const char *fmt, ...)
 }  }
   
 /*  /*
  * Put a single data character.   * Put a single data character to the output if we're not ignoring.
  * This MUST NOT be a mdoc(7) command: it should be free text that's   * Adjusts our output status.
  * outputted to the screen.   * This shouldn't be called for macros: just for ordinary text.
  */   */
 static void  static void
 texiputchar(struct texi *p, char c)  texiputchar(struct texi *p, char c)
Line 408  texiputchar(struct texi *p, char c)
Line 570  texiputchar(struct texi *p, char c)
   
         if (p->ign)          if (p->ign)
                 return;                  return;
   
           if ('.' == c && 0 == p->outcol)
                   fputs("\\&", stdout);
   
         putchar(c);          putchar(c);
           p->seenvs = 0;
         if ('\n' == c) {          if ('\n' == c) {
                 p->outcol = 0;                  p->outcol = 0;
                 p->seenws = 0;                  p->seenws = 0;
Line 418  texiputchar(struct texi *p, char c)
Line 585  texiputchar(struct texi *p, char c)
   
 /*  /*
  * Put multiple characters (see texiputchar()).   * Put multiple characters (see texiputchar()).
    * This shouldn't be called for macros: just for ordinary text.
  */   */
 static void  static void
 texiputchars(struct texi *p, const char *s)  texiputchars(struct texi *p, const char *s)
Line 428  texiputchars(struct texi *p, const char *s)
Line 596  texiputchars(struct texi *p, const char *s)
 }  }
   
 /*  /*
  * Put an mdoc(7) command without the trailing newline.   * Close an mdoc(7) macro opened with teximacroopen().
  * This should ONLY be used for mdoc(7) commands!   * If there are no more macros on the line, prints a newline.
  */   */
 static void  static void
 teximacroclose(struct texi *p)  teximacroclose(struct texi *p)
 {  {
   
         p->outmacro--;  
         if (p->ign)          if (p->ign)
                 return;                  return;
         texiputchar(p, '\n');  
           if (0 == --p->outmacro) {
                   putchar('\n');
                   p->outcol = p->seenws = 0;
           }
 }  }
   
 /*  /*
  * Put an mdoc(7) command without the trailing newline.   * Open a mdoc(7) macro.
  * This should ONLY be used for mdoc(7) commands!   * This is used for line macros, e.g., Qq [foo bar baz].
    * It can be invoked for nested macros, e.g., Qq Li foo .
  */   */
 static void  static void
 teximacroopen(struct texi *p, const char *s)  teximacroopen(struct texi *p, const char *s)
 {  {
         int      rc;          int      rc;
   
         p->outmacro++;  
         if (p->ign)          if (p->ign)
                 return;                  return;
         if (p->outcol)  
                 texiputchar(p, '\n');          if (p->outcol && 0 == p->outmacro) {
                   putchar('\n');
                   p->outcol = 0;
           }
   
           if (0 == p->outmacro)
                   putchar('.');
           else
                   putchar(' ');
   
         if (EOF != (rc = fputs(s, stdout)))          if (EOF != (rc = fputs(s, stdout)))
                 p->outcol += rc;                  p->outcol += rc;
   
           putchar(' ');
           p->outcol++;
           p->outmacro++;
           p->seenws = 0;
 }  }
   
 /*  /*
  * Put an mdoc(7) command with the trailing newline.   * Put a stadnalone 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)  teximacro(struct texi *p, const char *s)
Line 469  teximacro(struct texi *p, const char *s)
Line 653  teximacro(struct texi *p, const char *s)
   
         if (p->ign)          if (p->ign)
                 return;                  return;
   
           if (p->outmacro)
                   texierr(p, "\"%s\" in open line scope!?", s);
           if (p->literal)
                   texierr(p, "\"%s\" in a literal scope!?", s);
   
         if (p->outcol)          if (p->outcol)
                 texiputchar(p, '\n');                  putchar('\n');
   
           putchar('.');
         puts(s);          puts(s);
         p->outcol = 0;          p->outcol = p->seenws = 0;
         p->seenws = 0;  
 }  }
   
   static void
   texivspace(struct texi *p)
   {
   
           if (p->seenvs)
                   return;
           teximacro(p, "Pp");
           p->seenvs = 1;
   }
   
 /*  /*
  * Advance by a single byte in the input stream.   * Advance by a single byte in the input stream.
  */   */
Line 492  advance(struct texi *p, const char *buf, size_t *pos)
Line 693  advance(struct texi *p, const char *buf, size_t *pos)
         (*pos)++;          (*pos)++;
 }  }
   
   static void
   texipunctuate(struct texi *p, const char *buf, size_t sz, size_t *pos)
   {
           size_t   start, end;
   
           if (1 != p->outmacro)
                   return;
   
           for (start = end = *pos; end < sz; end++) {
                   switch (buf[end]) {
                   case (','):
                   case (')'):
                   case ('.'):
                   case ('"'):
                   case (':'):
                   case ('!'):
                   case ('?'):
                           continue;
                   default:
                           break;
                   }
                   break;
           }
           if (end == *pos)
                   return;
           if (end + 1 == sz || ' ' == buf[end] || '\n' == buf[end]) {
                   for ( ; start < end; start++) {
                           texiputchar(p, ' ');
                           texiputchar(p, buf[start]);
                           advance(p, buf, pos);
                   }
           }
   }
   
 /*  /*
  * Advance to the next non-whitespace word in the input stream.   * Advance to the next non-whitespace word in the input stream.
  * If we're in literal mode, then print all of the whitespace as we're   * If we're in literal mode, then print all of the whitespace as we're
Line 502  advancenext(struct texi *p, const char *buf, size_t sz
Line 737  advancenext(struct texi *p, const char *buf, size_t sz
 {  {
   
         if (p->literal) {          if (p->literal) {
                 while (*pos < sz && isspace(buf[*pos])) {                  while (*pos < sz && ismspace(buf[*pos])) {
                           if (*pos && '\n' == buf[*pos] &&
                                   '\\' == buf[*pos - 1])
                                   texiputchar(p, 'e');
                         texiputchar(p, buf[*pos]);                          texiputchar(p, buf[*pos]);
                         advance(p, buf, pos);                          advance(p, buf, pos);
                 }                  }
                 return(*pos);                  return(*pos);
         }          }
   
         while (*pos < sz && isspace(buf[*pos])) {          while (*pos < sz && ismspace(buf[*pos])) {
                 p->seenws = 1;                  p->seenws = 1;
                 /*                  /*
                  * If it looks like we've printed a double-line, then                   * If it looks like we've printed a double-line, then
Line 517  advancenext(struct texi *p, const char *buf, size_t sz
Line 755  advancenext(struct texi *p, const char *buf, size_t sz
                  * FIXME: this is stupid.                   * FIXME: this is stupid.
                  */                   */
                 if (*pos && '\n' == buf[*pos] && '\n' == buf[*pos - 1])                  if (*pos && '\n' == buf[*pos] && '\n' == buf[*pos - 1])
                         teximacro(p, ".Pp");                          texivspace(p);
                 advance(p, buf, pos);                  advance(p, buf, pos);
         }          }
         return(*pos);          return(*pos);
Line 531  advanceeoln(struct texi *p, const char *buf, 
Line 769  advanceeoln(struct texi *p, const char *buf, 
         size_t sz, size_t *pos, int consumenl)          size_t sz, size_t *pos, int consumenl)
 {  {
   
           /* FIXME: disregards @NEWLINE. */
         while (*pos < sz && '\n' != buf[*pos])          while (*pos < sz && '\n' != buf[*pos])
                 advance(p, buf, pos);                  advance(p, buf, pos);
         if (*pos < sz && consumenl)          if (*pos < sz && consumenl)
Line 557  advanceto(struct texi *p, const char *buf, size_t *pos
Line 796  advanceto(struct texi *p, const char *buf, size_t *pos
  * This also will advance the input stream.   * This also will advance the input stream.
  */   */
 static void  static void
 texiword(struct texi *p, const char *buf, size_t sz, size_t *pos)  texiword(struct texi *p, const char *buf,
           size_t sz, size_t *pos, char extra)
 {  {
   
         /*          if (p->seenws && 0 == p->outmacro && p->outcol > 72 && 0 == p->literal)
          * XXX: if we're in literal mode, then we shouldn't do any  
          * reflowing of text here.  
          */  
         if (0 == p->outmacro && p->outcol > 72 && 0 == p->literal)  
                 texiputchar(p, '\n');                  texiputchar(p, '\n');
           /* FIXME: abstract this: we use it elsewhere. */
         if (p->seenws && p->outcol && 0 == p->literal)          if (p->seenws && p->outcol && 0 == p->literal)
                 texiputchar(p, ' ');                  texiputchar(p, ' ');
   
         p->seenws = 0;          p->seenws = 0;
   
         while (*pos < sz && ! isspace(buf[*pos])) {          while (*pos < sz && ! ismspace(buf[*pos])) {
                 switch (buf[*pos]) {                  switch (buf[*pos]) {
                 case ('@'):                  case ('@'):
                 case ('}'):                  case ('}'):
                 case ('{'):                  case ('{'):
                         return;                          return;
                 }                  }
                   if ('\0' != extra && buf[*pos] == extra)
                           return;
                 if (*pos < sz - 1 &&                  if (*pos < sz - 1 &&
                          '`' == buf[*pos] &&                           '`' == buf[*pos] &&
                          '`' == buf[*pos + 1]) {                           '`' == buf[*pos + 1]) {
Line 595  texiword(struct texi *p, const char *buf, size_t sz, s
Line 833  texiword(struct texi *p, const char *buf, size_t sz, s
         }          }
 }  }
   
   /*
    * Look up the command at position "pos" in the buffer, returning it (or
    * TEXICMD__MAX if none found) and setting "end" to be the absolute
    * index after the command name.
    */
 static enum texicmd  static enum texicmd
 texicmd(struct texi *p, const char *buf,  texicmd(struct texi *p, const char *buf,
         size_t pos, size_t sz, size_t *end)          size_t pos, size_t sz, size_t *end)
Line 603  texicmd(struct texi *p, const char *buf, 
Line 846  texicmd(struct texi *p, const char *buf, 
   
         assert('@' == buf[pos]);          assert('@' == buf[pos]);
   
         if (++pos >= sz)          if ((*end = pos) == sz)
                 return(TEXICMD__MAX);                  return(TEXICMD__MAX);
           else if ((*end = ++pos) == sz)
                   return(TEXICMD__MAX);
   
         /* Alphabetic commands are special. */          /* Alphabetic commands are special. */
         if ( ! isalpha(buf[pos])) {          if ( ! isalpha(buf[pos])) {
                 *end = pos + 1;                  if ((*end = pos + 1) == sz)
                           return(TEXICMD__MAX);
                 for (i = 0; i < TEXICMD__MAX; i++) {                  for (i = 0; i < TEXICMD__MAX; i++) {
                         if (1 != texitoks[i].len)                          if (1 != texitoks[i].len)
                                 continue;                                  continue;
Line 619  texicmd(struct texi *p, const char *buf, 
Line 865  texicmd(struct texi *p, const char *buf, 
                 return(TEXICMD__MAX);                  return(TEXICMD__MAX);
         }          }
   
         for (*end = pos; *end < sz && ! isspace(buf[*end]); (*end)++)          for (*end = pos; *end < sz && ! ismspace(buf[*end]); (*end)++)
                 if ((*end > pos && ('@' == buf[*end] ||                  if ((*end > pos && ('@' == buf[*end] ||
                           '{' == buf[*end] || '}' == buf[*end])))                            '{' == buf[*end] || '}' == buf[*end])))
                         break;                          break;
Line 636  texicmd(struct texi *p, const char *buf, 
Line 882  texicmd(struct texi *p, const char *buf, 
         return(TEXICMD__MAX);          return(TEXICMD__MAX);
 }  }
   
 static void  /*
 parseeof(struct texi *p, const char *buf, size_t sz)   * Parse an argument from a bracketed command, e.g., @url{foo, baz}.
    * Num should be set to the argument we're currently parsing, although
    * it suffixes for it to be zero or non-zero.
    * This will return 1 if there are more arguments, 0 otherwise.
    * This will stop (returning 0) in the event of EOF or if we're not at a
    * bracket for the zeroth parse.
    */
   static int
   parsearg(struct texi *p, const char *buf,
           size_t sz, size_t *pos, size_t num)
 {  {
         size_t           pos = 0;          size_t           end;
         enum texicmd     cmd;          enum texicmd     cmd;
         size_t           end;  
   
         while ((pos = advancenext(p, buf, sz, &pos)) < sz) {          while (*pos < sz && ismspace(buf[*pos]))
                 switch (buf[pos]) {                  advance(p, buf, pos);
           if (*pos == sz || (0 == num && '{' != buf[*pos]))
                   return(0);
           if (0 == num)
                   advance(p, buf, pos);
   
           while ((*pos = advancenext(p, buf, sz, pos)) < sz) {
                   switch (buf[*pos]) {
                   case (','):
                           advance(p, buf, pos);
                           return(1);
                 case ('}'):                  case ('}'):
                         if (0 == p->ign)                          advance(p, buf, pos);
                                 texiwarn(p, "unexpected \"}\"");                          return(0);
                         advance(p, buf, &pos);  
                         continue;  
                 case ('{'):                  case ('{'):
                         if (0 == p->ign)                          if (0 == p->ign)
                                 texiwarn(p, "unexpected \"{\"");                                  texiwarn(p, "unexpected \"{\"");
                         advance(p, buf, &pos);                          advance(p, buf, pos);
                         continue;                          continue;
                 case ('@'):                  case ('@'):
                         break;                          break;
                 default:                  default:
                         texiword(p, buf, sz, &pos);                          texiword(p, buf, sz, pos, ',');
                         continue;                          continue;
                 }                  }
   
                 cmd = texicmd(p, buf, pos, sz, &end);                  cmd = texicmd(p, buf, *pos, sz, &end);
                 advanceto(p, buf, &pos, end);                  advanceto(p, buf, pos, end);
                 if (TEXICMD__MAX == cmd)                  if (TEXICMD__MAX == cmd)
                         continue;                          continue;
                 if (NULL != texitoks[cmd].fp)                  if (NULL != texitoks[cmd].fp)
                         (*texitoks[cmd].fp)(p, cmd, buf, sz, &pos);                          (*texitoks[cmd].fp)(p, cmd, buf, sz, pos);
         }          }
           return(0);
 }  }
   
   /*
    * Parse until the end of a bracketed statement, e.g., @foo{bar baz}.
    * This will stop in the event of EOF or if we're not at a bracket.
    */
 static void  static void
 parsebracket(struct texi *p, const char *buf, size_t sz, size_t *pos)  parsebracket(struct texi *p, const char *buf, size_t sz, size_t *pos)
 {  {
         size_t           end;          size_t           end;
         enum texicmd     cmd;          enum texicmd     cmd;
   
         while (*pos < sz && isspace(buf[*pos]))          while (*pos < sz && ismspace(buf[*pos]))
                 advance(p, buf, pos);                  advance(p, buf, pos);
   
         if (*pos == sz || '{' != buf[*pos])          if (*pos == sz || '{' != buf[*pos])
Line 697  parsebracket(struct texi *p, const char *buf, size_t s
Line 964  parsebracket(struct texi *p, const char *buf, size_t s
                 case ('@'):                  case ('@'):
                         break;                          break;
                 default:                  default:
                         texiword(p, buf, sz, pos);                          texiword(p, buf, sz, pos, '\0');
                         continue;                          continue;
                 }                  }
   
Line 721  parseeoln(struct texi *p, const char *buf, size_t sz, 
Line 988  parseeoln(struct texi *p, const char *buf, size_t sz, 
         size_t           end;          size_t           end;
         enum texicmd     cmd;          enum texicmd     cmd;
   
         assert(0 == p->literal);  
   
         while (*pos < sz && '\n' != buf[*pos]) {          while (*pos < sz && '\n' != buf[*pos]) {
                 while (*pos < sz && isws(buf[*pos])) {                  while (*pos < sz && isws(buf[*pos])) {
                         p->seenws = 1;                          p->seenws = 1;
                           if (p->literal)
                                   texiputchar(p, buf[*pos]);
                         advance(p, buf, pos);                          advance(p, buf, pos);
                 }                  }
                 switch (buf[*pos]) {                  switch (buf[*pos]) {
Line 742  parseeoln(struct texi *p, const char *buf, size_t sz, 
Line 1009  parseeoln(struct texi *p, const char *buf, size_t sz, 
                 case ('@'):                  case ('@'):
                         break;                          break;
                 default:                  default:
                         texiword(p, buf, sz, pos);                          texiword(p, buf, sz, pos, '\0');
                         continue;                          continue;
                 }                  }
   
Line 755  parseeoln(struct texi *p, const char *buf, size_t sz, 
Line 1022  parseeoln(struct texi *p, const char *buf, size_t sz, 
         }          }
 }  }
   
   /*
    * Parse a single word or command.
    * This will return immediately at the EOF.
    */
 static void  static void
 parsesingle(struct texi *p, const char *buf, size_t sz, size_t *pos)  parsesingle(struct texi *p, const char *buf, size_t sz, size_t *pos)
 {  {
Line 778  parsesingle(struct texi *p, const char *buf, size_t sz
Line 1049  parsesingle(struct texi *p, const char *buf, size_t sz
         case ('@'):          case ('@'):
                 break;                  break;
         default:          default:
                 texiword(p, buf, sz, pos);                  texiword(p, buf, sz, pos, '\0');
                 return;                  return;
         }          }
   
Line 790  parsesingle(struct texi *p, const char *buf, size_t sz
Line 1061  parsesingle(struct texi *p, const char *buf, size_t sz
                 (*texitoks[cmd].fp)(p, cmd, buf, sz, pos);                  (*texitoks[cmd].fp)(p, cmd, buf, sz, pos);
 }  }
   
   static int
   parselinearg(struct texi *p, const char *buf, size_t sz, size_t *pos)
   {
   
           while (*pos < sz && isws(buf[*pos])) {
                   p->seenws = 1;
                   advance(p, buf, pos);
           }
   
           if (*pos < sz && '{' == buf[*pos])
                   parsebracket(p, buf, sz, pos);
           else if ('\n' != buf[*pos])
                   parsesingle(p, buf, sz, pos);
           else
                   return(0);
   
           return(1);
   }
   
   /*
    * Parse til the end of the buffer.
    */
 static void  static void
   parseeof(struct texi *p, const char *buf, size_t sz)
   {
           size_t   pos;
   
           for (pos = 0; pos < sz; )
                   parsesingle(p, buf, sz, &pos);
   }
   
   /*
    * Parse a block sequence until we have the "@end endtoken" command
    * invocation.
    * This will return immediately at EOF.
    */
   static void
 parseto(struct texi *p, const char *buf,  parseto(struct texi *p, const char *buf,
         size_t sz, size_t *pos, const char *endtoken)          size_t sz, size_t *pos, const char *endtoken)
 {  {
Line 816  parseto(struct texi *p, const char *buf, 
Line 1123  parseto(struct texi *p, const char *buf, 
                 case ('@'):                  case ('@'):
                         break;                          break;
                 default:                  default:
                         texiword(p, buf, sz, pos);                          texiword(p, buf, sz, pos, '\0');
                         continue;                          continue;
                 }                  }
   
Line 826  parseto(struct texi *p, const char *buf, 
Line 1133  parseto(struct texi *p, const char *buf, 
                         while (*pos < sz && isws(buf[*pos]))                          while (*pos < sz && isws(buf[*pos]))
                                 advance(p, buf, pos);                                  advance(p, buf, pos);
                         /*                          /*
                          * FIXME: skip tabs and also check the full                           * FIXME: check the full word, not just its
                          * word, not just its initial substring!                           * initial substring!
                          */                           */
                         if (sz - *pos >= endtoksz && 0 == strncmp                          if (sz - *pos >= endtoksz && 0 == strncmp
                                  (&buf[*pos], endtoken, endtoksz)) {                                   (&buf[*pos], endtoken, endtoksz)) {
Line 844  parseto(struct texi *p, const char *buf, 
Line 1151  parseto(struct texi *p, const char *buf, 
         }          }
 }  }
   
   /*
    * Memory-map the file "fname" and begin parsing it.
    * This can be called in a nested context.
    */
 static void  static void
 parsefile(struct texi *p, const char *fname)  parsefile(struct texi *p, const char *fname, int parse)
 {  {
         struct texifile  *f;          struct texifile *f;
         int               fd;          int              fd;
         struct stat       st;          struct stat      st;
           size_t           i;
   
         assert(p->filepos < 64);          assert(p->filepos < 64);
         f = &p->files[p->filepos];          f = &p->files[p->filepos];
Line 872  parsefile(struct texi *p, const char *fname)
Line 1184  parsefile(struct texi *p, const char *fname)
                 texiabort(p, fname);                  texiabort(p, fname);
   
         p->filepos++;          p->filepos++;
         parseeof(p, f->map, f->mapsz);          if ( ! parse) {
                   /*
                    * We're printing verbatim output.
                    * Make sure it doesn't get interpreted as mdoc by
                    * escaping escapes and making sure leading dots don't
                    * trigger mdoc(7) expansion.
                    */
                   for (i = 0; i < f->mapsz; i++) {
                           if (i > 0 && '.' == f->map[i])
                                   if ('\n' == f->map[i - 1])
                                           fputs("\\&", stdout);
                           putchar(f->map[i]);
                           if ('\\' == f->map[i])
                                   putchar('e');
                   }
           } else
                   parseeof(p, f->map, f->mapsz);
         texifilepop(p);          texifilepop(p);
 }  }
   
 static void  static void
 dodeftypevar(struct texi *p, enum texicmd cmd,  dodefn(struct texi *p, enum texicmd cmd,
         const char *buf, size_t sz, size_t *pos)          const char *buf, size_t sz, size_t *pos)
 {  {
         const char      *blk;          const char      *blk;
   
         blk = TEXICMD_DEFTYPEVR == cmd ?          blk = NULL;
                 "deftypevr" : "deftypevar";          switch (cmd) {
           case (TEXICMD_DEFFN):
           case (TEXICMD_DEFTP):
           case (TEXICMD_DEFTYPEFN):
           case (TEXICMD_DEFTYPEFUN):
           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) {          if (p->ign) {
                 parseto(p, buf, sz, pos, blk);                  NULL != blk ?
                           parseto(p, buf, sz, pos, blk) :
                           parseeoln(p, buf, sz, pos);
                 return;                  return;
         }          }
   
         teximacro(p, ".Pp");          if (NULL != blk)
         if (TEXICMD_DEFTYPEVR == cmd) {                  texivspace(p);
                 parsebracket(p, buf, sz, pos);  
                 texiputchars(p, ":\n");  
         }  
         p->literal++;  
         teximacroopen(p, ".Vt ");  
         while (*pos < sz && '\n' != buf[*pos])  
                 parsesingle(p, buf, sz, pos);  
         teximacroclose(p);  
         p->literal--;  
         teximacro(p, ".Pp");  
         parseto(p, buf, sz, pos, blk);  
 }  
   
 static void  
 dodeftypefun(struct texi *p, enum texicmd cmd,  
         const char *buf, size_t sz, size_t *pos)  
 {  
         const char      *blk;  
   
         switch (cmd) {          switch (cmd) {
         case (TEXICMD_DEFTYPEFN):          case (TEXICMD_DEFMAC):
                 blk = "deftypefn";          case (TEXICMD_DEFMACX):
                   texiputchars(p, "Macro");
                 break;                  break;
         case (TEXICMD_DEFTYPEFUN):          case (TEXICMD_DEFTYPEVAR):
                 blk = "deftypefun";          case (TEXICMD_DEFTYPEVARX):
           case (TEXICMD_DEFVAR):
           case (TEXICMD_DEFVARX):
                   texiputchars(p, "Variable");
                 break;                  break;
         case (TEXICMD_DEFTYPEFNX):          case (TEXICMD_DEFTYPEFUN):
         case (TEXICMD_DEFTYPEFUNX):          case (TEXICMD_DEFTYPEFUNX):
                 blk = NULL;          case (TEXICMD_DEFUN):
           case (TEXICMD_DEFUNX):
                   texiputchars(p, "Function");
                 break;                  break;
         default:          default:
                 abort();                  parselinearg(p, buf, sz, pos);
                   break;
         }          }
   
         if (p->ign) {          texiputchars(p, ":\n");
                 if (NULL != blk)  
                         parseto(p, buf, sz, pos, blk);  
                 return;  
         }  
   
         switch (cmd) {          switch (cmd) {
         case (TEXICMD_DEFTYPEFN):          case (TEXICMD_DEFMAC):
           case (TEXICMD_DEFMACX):
                   teximacroopen(p, "Dv");
                   while (parselinearg(p, buf, sz, pos))
                           /* Spin. */ ;
                   teximacroclose(p);
                   break;
           case (TEXICMD_DEFFN):
           case (TEXICMD_DEFFNX):
           case (TEXICMD_DEFUN):
           case (TEXICMD_DEFUNX):
                   teximacroopen(p, "Fo");
                   parselinearg(p, buf, sz, pos);
                   teximacroclose(p);
                   teximacroopen(p, "Fa");
                   while (parselinearg(p, buf, sz, pos))
                           /* Spin. */ ;
                   teximacroclose(p);
                   teximacro(p, "Fc");
                   break;
         case (TEXICMD_DEFTYPEFUN):          case (TEXICMD_DEFTYPEFUN):
                 teximacro(p, ".Pp");          case (TEXICMD_DEFTYPEFUNX):
           case (TEXICMD_DEFTYPEFN):
           case (TEXICMD_DEFTYPEFNX):
                   teximacroopen(p, "Ft");
                   parselinearg(p, buf, sz, pos);
                   teximacroclose(p);
                   teximacroopen(p, "Fo");
                   parselinearg(p, buf, sz, pos);
                   teximacroclose(p);
                   teximacroopen(p, "Fa");
                   while (parselinearg(p, buf, sz, pos))
                           /* Spin. */ ;
                   teximacroclose(p);
                   teximacro(p, "Fc");
                 break;                  break;
         default:          case (TEXICMD_DEFTP):
           case (TEXICMD_DEFTPX):
           case (TEXICMD_DEFTYPEVAR):
           case (TEXICMD_DEFTYPEVARX):
           case (TEXICMD_DEFTYPEVR):
           case (TEXICMD_DEFTYPEVRX):
                   teximacroopen(p, "Vt");
                   while (parselinearg(p, buf, sz, pos))
                           /* Spin. */ ;
                   teximacroclose(p);
                 break;                  break;
           case (TEXICMD_DEFVAR):
           case (TEXICMD_DEFVARX):
           case (TEXICMD_DEFVR):
           case (TEXICMD_DEFVRX):
                   teximacroopen(p, "Va");
                   while (parselinearg(p, buf, sz, pos))
                           /* Spin. */ ;
                   teximacroclose(p);
                   break;
           default:
                   abort();
         }          }
         if (TEXICMD_DEFTYPEFN == cmd ||  
                         TEXICMD_DEFTYPEFNX == cmd) {          texivspace(p);
                 parsebracket(p, buf, sz, pos);  
                 texiputchars(p, ":\n");  
         }  
         teximacroopen(p, ".Ft ");  
         parsesingle(p, buf, sz, pos);  
         teximacroclose(p);  
         teximacroopen(p, ".Fn ");  
         parsesingle(p, buf, sz, pos);  
         teximacroclose(p);  
         teximacroopen(p, ".Li ");  
         while (*pos < sz && '\n' != buf[*pos])  
                 parsesingle(p, buf, sz, pos);  
         teximacroclose(p);  
         teximacro(p, ".Pp");  
         if (NULL != blk)          if (NULL != blk)
                 parseto(p, buf, sz, pos, blk);                  parseto(p, buf, sz, pos, blk);
 }  }
Line 964  static void
Line 1331  static void
 doignblock(struct texi *p, enum texicmd cmd,  doignblock(struct texi *p, enum texicmd cmd,
         const char *buf, size_t sz, size_t *pos)          const char *buf, size_t sz, size_t *pos)
 {  {
         const char      *blk;  
   
         switch (cmd) {  
         case (TEXICMD_COPYING):  
                 blk = "copying";  
                 break;  
         case (TEXICMD_DETAILMENU):  
                 blk = "detailmenu";  
                 break;  
         case (TEXICMD_DIRENTRY):  
                 blk = "direntry";  
                 break;  
         case (TEXICMD_IFCLEAR):  
                 blk = "ifclear";  
                 break;  
         case (TEXICMD_IFHTML):  
                 blk = "ifhtml";  
                 break;  
         case (TEXICMD_IFINFO):  
                 blk = "ifinfo";  
                 break;  
         case (TEXICMD_IFSET):  
                 blk = "ifset";  
                 break;  
         case (TEXICMD_IFTEX):  
                 blk = "iftex";  
                 break;  
         case (TEXICMD_MENU):  
                 blk = "menu";  
                 break;  
         case (TEXICMD_TEX):  
                 blk = "tex";  
                 break;  
         case (TEXICMD_TITLEPAGE):  
                 blk = "titlepage";  
                 break;  
         default:  
                 abort();  
         }  
         p->ign++;          p->ign++;
         parseto(p, buf, sz, pos, blk);          parseto(p, buf, sz, pos, texitoks[cmd].tok);
         p->ign--;          p->ign--;
 }  }
   
Line 1012  static void
Line 1341  static void
 doblock(struct texi *p, enum texicmd cmd,  doblock(struct texi *p, enum texicmd cmd,
         const char *buf, size_t sz, size_t *pos)          const char *buf, size_t sz, size_t *pos)
 {  {
         const char      *blk;  
           parseto(p, buf, sz, pos, texitoks[cmd].tok);
   }
   
   static void
   doinline(struct texi *p, enum texicmd cmd,
           const char *buf, size_t sz, size_t *pos)
   {
           const char      *macro;
   
         switch (cmd) {          switch (cmd) {
         case (TEXICMD_GROUP):          case (TEXICMD_COMMAND):
                 blk = "group";                  macro = "Xr";
                 break;                  break;
         case (TEXICMD_IFNOTTEX):          case (TEXICMD_ENV):
                 blk = "ifnottex";                  macro = "Ev";
                 break;                  break;
           case (TEXICMD_FILE):
                   macro = "Pa";
                   break;
           case (TEXICMD_OPTION):
                   macro = "Op";
                   break;
           case (TEXICMD_VAR):
                   macro = "Va";
                   break;
         default:          default:
                 abort();                  abort();
         }          }
   
         parseto(p, buf, sz, pos, blk);  
 }  
   
 static void          if (p->literal) {
 doinline(struct texi *p, const char *buf,                  parsebracket(p, buf, sz, pos);
         size_t sz, size_t *pos, const char *macro)                  return;
 {          }
         int      open = 0;  
   
         if (0 == p->outmacro) {          teximacroopen(p, macro);
                 open = 1;  
                 teximacroopen(p, ".");  
         } else  
                 texiputchar(p, ' ');  
   
         texiputchars(p, macro);  
         texiputchar(p, ' ');  
         p->seenws = 0;          p->seenws = 0;
         parsebracket(p, buf, sz, pos);          parsebracket(p, buf, sz, pos);
         if (*pos < sz - 1 &&          texipunctuate(p, buf, sz, pos);
                  ismpunct(buf[*pos]) &&          teximacroclose(p);
                  isspace(buf[*pos + 1])) {  
                 texiputchar(p, ' ');  
                 texiputchar(p, buf[*pos]);  
                 advance(p, buf, pos);  
         }  
         if (open)  
                 teximacroclose(p);  
 }  }
   
 static void  static void
 doinclude(struct texi *p, enum texicmd cmd,  doverbinclude(struct texi *p, enum texicmd cmd,
         const char *buf, size_t sz, size_t *pos)          const char *buf, size_t sz, size_t *pos)
 {  {
         char     fname[PATH_MAX], path[PATH_MAX];          char     fname[PATH_MAX], path[PATH_MAX];
         size_t   i;  
         int      rc;          int      rc;
           size_t   i;
   
         while (*pos < sz && ' ' == buf[*pos])          while (*pos < sz && ' ' == buf[*pos])
                 advance(p, buf, pos);                  advance(p, buf, pos);
Line 1085  doinclude(struct texi *p, enum texicmd cmd, 
Line 1413  doinclude(struct texi *p, enum texicmd cmd, 
         if (strstr(fname, "../") || strstr(fname, "/.."))          if (strstr(fname, "../") || strstr(fname, "/.."))
                 texierr(p, "insecure path");                  texierr(p, "insecure path");
   
         /* Append filename to original name's directory. */          rc = snprintf(path, sizeof(path),
         rc = snprintf(path, sizeof(path), "%s/%s", p->dir, fname);                  "%s/%s", p->dirs[0], fname);
         if (rc < 0)          if (rc < 0)
                 texierr(p, "couldn't format filename");                  texierr(p, "couldn't format path");
         else if ((size_t)rc >= sizeof(path))          else if ((size_t)rc >= sizeof(path))
                 texierr(p, "path too long");                  texierr(p, "path too long");
   
         /* Pump through to parser. */          parsefile(p, path, 0);
         parsefile(p, path);  
 }  }
   
 static void  static void
 doitalic(struct texi *p, enum texicmd cmd,  doinclude(struct texi *p, enum texicmd cmd,
         const char *buf, size_t sz, size_t *pos)          const char *buf, size_t sz, size_t *pos)
 {  {
           char     fname[PATH_MAX], path[PATH_MAX];
           size_t   i;
           int      rc;
   
         texiputchars(p, "\\fI");          while (*pos < sz && ' ' == buf[*pos])
         parsebracket(p, buf, sz, pos);                  advance(p, buf, pos);
         texiputchars(p, "\\fP");  
 }  
   
 static void          /* Read in the filename. */
 doenv(struct texi *p, enum texicmd cmd,          for (i = 0; *pos < sz && '\n' != buf[*pos]; i++) {
         const char *buf, size_t sz, size_t *pos)                  if (i == sizeof(fname) - 1)
 {                          break;
                   fname[i] = buf[*pos];
                   advance(p, buf, pos);
           }
   
         if (p->literal)          if (i == 0)
                 parsebracket(p, buf, sz, pos);                  texierr(p, "path too short");
         else          else if ('\n' != buf[*pos])
                 doinline(p, buf, sz, pos, "Ev");                  texierr(p, "path too long");
 }          else if ('/' == fname[0])
                   texierr(p, "no absolute paths");
           fname[i] = '\0';
   
 static void          if (strstr(fname, "../") || strstr(fname, "/.."))
 doliteral(struct texi *p, enum texicmd cmd,                  texierr(p, "insecure path");
         const char *buf, size_t sz, size_t *pos)  
 {  
   
         if (p->literal)          for (i = 0; i < p->dirsz; i++) {
                 parsebracket(p, buf, sz, pos);                  rc = snprintf(path, sizeof(path),
         else                          "%s/%s", p->dirs[i], fname);
                 doinline(p, buf, sz, pos, "Li");                  if (rc < 0)
 }                          texierr(p, "couldn't format path");
                   else if ((size_t)rc >= sizeof(path))
                           texierr(p, "path too long");
                   else if (-1 == access(path, R_OK))
                           continue;
   
 static void                  parsefile(p, path, 1);
 doemph(struct texi *p, enum texicmd cmd,                  return;
         const char *buf, size_t sz, size_t *pos)          }
 {  
   
         if (p->literal)          texierr(p, "couldn't find %s in includes", fname);
                 doitalic(p, cmd, buf, sz, pos);  
         else  
                 doinline(p, buf, sz, pos, "Em");  
 }  }
   
 static void  static void
 docommand(struct texi *p, enum texicmd cmd,  dofont(struct texi *p, enum texicmd cmd,
         const char *buf, size_t sz, size_t *pos)          const char *buf, size_t sz, size_t *pos)
 {  {
           const char      *font;
   
         doinline(p, buf, sz, pos, "Xr");          switch (cmd) {
           case (TEXICMD_B):
           case (TEXICMD_STRONG):
                   font = "\\fB";
                   break;
           case (TEXICMD_CITE):
           case (TEXICMD_DFN):
           case (TEXICMD_EMPH):
           case (TEXICMD_I):
           case (TEXICMD_SLANTED):
                   font = "\\fI";
                   break;
           case (TEXICMD_CODE):
           case (TEXICMD_KBD):
           case (TEXICMD_R):
           case (TEXICMD_SAMP):
           case (TEXICMD_SANSSERIF):
           case (TEXICMD_T):
                   font = "\\fR";
                   break;
           default:
                   abort();
           }
   
           if (p->seenws) {
                   texiputchar(p, ' ');
                   p->seenws = 0;
           }
           texiputchars(p, font);
           parsebracket(p, buf, sz, pos);
           texiputchars(p, "\\fP");
 }  }
   
 static void  static void
Line 1156  dobracket(struct texi *p, enum texicmd cmd, 
Line 1518  dobracket(struct texi *p, enum texicmd cmd, 
 }  }
   
 static void  static void
 dofile(struct texi *p, enum texicmd cmd,  
         const char *buf, size_t sz, size_t *pos)  
 {  
   
         if (p->literal)  
                 parsebracket(p, buf, sz, pos);  
         else  
                 doinline(p, buf, sz, pos, "Pa");  
 }  
   
 static void  
 dodisplay(struct texi *p, enum texicmd cmd,  dodisplay(struct texi *p, enum texicmd cmd,
         const char *buf, size_t sz, size_t *pos)          const char *buf, size_t sz, size_t *pos)
 {  {
   
         if (p->outmacro)          switch (cmd) {
                 texierr(p, "display in open line scope!?");          case (TEXICMD_FORMAT):
         else if (p->literal)          case (TEXICMD_SMALLFORMAT):
                 texierr(p, "display in a literal scope!?");                  teximacro(p, "Bd -filled");
                   break;
           default:
                   teximacro(p, "Bd -filled -offset indent");
                   break;
           }
   
         teximacro(p, ".Bd -display");          p->seenvs = 1;
           /* FIXME: ignore and parseeoln. */
         advanceeoln(p, buf, sz, pos, 1);          advanceeoln(p, buf, sz, pos, 1);
         parseto(p, buf, sz, pos, "display");          parseto(p, buf, sz, pos, texitoks[cmd].tok);
         teximacro(p, ".Ed");          teximacro(p, "Ed");
 }  }
   
 static void  static void
 doexample(struct texi *p, enum texicmd cmd,  doexample(struct texi *p, enum texicmd cmd,
         const char *buf, size_t sz, size_t *pos)          const char *buf, size_t sz, size_t *pos)
 {  {
         const char      *blk;  
   
         if (p->outmacro)          teximacro(p, "Bd -literal -offset indent");
                 texierr(p, "example in open line scope!?");          /* FIXME: ignore and parseeoln. */
         else if (p->literal)  
                 texierr(p, "example in a literal scope!?");  
   
         blk = TEXICMD_EXAMPLE == cmd ?  "example" : "smallexample";  
   
         teximacro(p, ".Bd -literal");  
         advanceeoln(p, buf, sz, pos, 1);          advanceeoln(p, buf, sz, pos, 1);
         p->literal++;          p->literal++;
         parseto(p, buf, sz, pos, blk);          parseto(p, buf, sz, pos, texitoks[cmd].tok);
         p->literal--;          p->literal--;
         teximacro(p, ".Ed");          teximacro(p, "Ed");
 }  }
   
 static void  static void
Line 1213  dobye(struct texi *p, enum texicmd cmd, 
Line 1563  dobye(struct texi *p, enum texicmd cmd, 
 }  }
   
 static void  static void
   dotitle(struct texi *p, enum texicmd cmd,
           const char *buf, size_t sz, size_t *pos)
   {
           size_t   start, end;
   
           while (*pos < sz && isws(buf[*pos]))
                   advance(p, buf, pos);
           start = end = *pos;
           while (end < sz && '\n' != buf[end])
                   end++;
           free(p->subtitle);
           p->subtitle = malloc(end - start + 1);
           memcpy(p->subtitle, &buf[start], end - start);
           p->subtitle[end - start] = '\0';
   }
   
   static void
   doaccent(struct texi *p, enum texicmd cmd,
           const char *buf, size_t sz, size_t *pos)
   {
   
           if (*pos == sz)
                   return;
           advance(p, buf, pos);
           switch (cmd) {
           case (TEXICMD_ACUTE):
                   switch (buf[*pos]) {
                   case ('a'): case ('A'):
                   case ('e'): case ('E'):
                   case ('i'): case ('I'):
                   case ('o'): case ('O'):
                   case ('u'): case ('U'):
                           texiputchars(p, "\\(\'");
                           texiputchar(p, buf[*pos]);
                           break;
                   default:
                           texiputchar(p, buf[*pos]);
                   }
                   break;
           case (TEXICMD_CIRCUMFLEX):
                   switch (buf[*pos]) {
                   case ('a'): case ('A'):
                   case ('e'): case ('E'):
                   case ('i'): case ('I'):
                   case ('o'): case ('O'):
                   case ('u'): case ('U'):
                           texiputchars(p, "\\(^");
                           texiputchar(p, buf[*pos]);
                           break;
                   default:
                           texiputchar(p, buf[*pos]);
                   }
                   break;
           case (TEXICMD_GRAVE):
                   switch (buf[*pos]) {
                   case ('a'): case ('A'):
                   case ('e'): case ('E'):
                   case ('i'): case ('I'):
                   case ('o'): case ('O'):
                   case ('u'): case ('U'):
                           texiputchars(p, "\\(`");
                           texiputchar(p, buf[*pos]);
                           break;
                   default:
                           texiputchar(p, buf[*pos]);
                   }
                   break;
           case (TEXICMD_TILDE):
                   switch (buf[*pos]) {
                   case ('a'): case ('A'):
                   case ('n'): case ('N'):
                   case ('o'): case ('O'):
                           texiputchars(p, "\\(~");
                           texiputchar(p, buf[*pos]);
                           break;
                   default:
                           texiputchar(p, buf[*pos]);
                   }
                   break;
           case (TEXICMD_UMLAUT):
                   switch (buf[*pos]) {
                   case ('a'): case ('A'):
                   case ('e'): case ('E'):
                   case ('i'): case ('I'):
                   case ('o'): case ('O'):
                   case ('u'): case ('U'):
                   case ('y'):
                           texiputchars(p, "\\(:");
                           texiputchar(p, buf[*pos]);
                           break;
                   default:
                           texiputchar(p, buf[*pos]);
                   }
                   break;
           default:
                   abort();
           }
   }
   
   static void
 dosymbol(struct texi *p, enum texicmd cmd,  dosymbol(struct texi *p, enum texicmd cmd,
         const char *buf, size_t sz, size_t *pos)          const char *buf, size_t sz, size_t *pos)
 {  {
Line 1226  dosymbol(struct texi *p, enum texicmd cmd, 
Line 1676  dosymbol(struct texi *p, enum texicmd cmd, 
         case (TEXICMD_ASTERISK):          case (TEXICMD_ASTERISK):
         case (TEXICMD_NEWLINE):          case (TEXICMD_NEWLINE):
         case (TEXICMD_SPACE):          case (TEXICMD_SPACE):
         case (TEXICMD_TAB):          case (TEXICMD_TABSYM):
                 texiputchar(p, ' ');                  texiputchar(p, ' ');
                 break;                  break;
         case (TEXICMD_AT):          case (TEXICMD_AT):
Line 1235  dosymbol(struct texi *p, enum texicmd cmd, 
Line 1685  dosymbol(struct texi *p, enum texicmd cmd, 
         case (TEXICMD_BANG):          case (TEXICMD_BANG):
                 texiputchar(p, '!');                  texiputchar(p, '!');
                 break;                  break;
           case (TEXICMD_BULLET):
                   texiputchars(p, "\\(bu");
                   break;
         case (TEXICMD_COPYRIGHT):          case (TEXICMD_COPYRIGHT):
                 texiputchars(p, "\\(co");                  texiputchars(p, "\\(co");
                 break;                  break;
         case (TEXICMD_DOTS):          case (TEXICMD_DOTS):
                 texiputchars(p, "...");                  texiputchars(p, "...");
                 break;                  break;
           case (TEXICMD_ERROR):
                   texiputchars(p, "error\\(->");
                   break;
           case (TEXICMD_EXPANSION):
                   texiputchars(p, "\\(->");
                   break;
         case (TEXICMD_LATEX):          case (TEXICMD_LATEX):
                 texiputchars(p, "LaTeX");                  texiputchars(p, "LaTeX");
                 break;                  break;
         case (TEXICMD_QUESTIONMARK):          case (TEXICMD_QUESTIONMARK):
                 texiputchar(p, '?');                  texiputchar(p, '?');
                 break;                  break;
           case (TEXICMD_RESULT):
                   texiputchars(p, "\\(rA");
                   break;
         case (TEXICMD_SQUIGGLE_LEFT):          case (TEXICMD_SQUIGGLE_LEFT):
                 texiputchars(p, "{");                  texiputchars(p, "{");
                 break;                  break;
Line 1260  dosymbol(struct texi *p, enum texicmd cmd, 
Line 1722  dosymbol(struct texi *p, enum texicmd cmd, 
         case (TEXICMD_HYPHEN):          case (TEXICMD_HYPHEN):
                 break;                  break;
         default:          default:
                   texiwarn(p, "sym: %d", cmd);
                 abort();                  abort();
         }          }
   
         doignbracket(p, cmd, buf, sz, pos);          if (texitoks[cmd].len > 1)
                   doignbracket(p, cmd, buf, sz, pos);
 }  }
   
 static void  static void
Line 1271  doquotation(struct texi *p, enum texicmd cmd, 
Line 1735  doquotation(struct texi *p, enum texicmd cmd, 
         const char *buf, size_t sz, size_t *pos)          const char *buf, size_t sz, size_t *pos)
 {  {
   
         teximacro(p, ".Qo");          teximacro(p, "Qo");
         parseto(p, buf, sz, pos, "quotation");          parseto(p, buf, sz, pos, "quotation");
         teximacro(p, ".Qc");          teximacro(p, "Qc");
 }  }
   
 /* FIXME */  
 static void  static void
 domath(struct texi *p, enum texicmd cmd,  domath(struct texi *p, enum texicmd cmd,
         const char *buf, size_t sz, size_t *pos)          const char *buf, size_t sz, size_t *pos)
Line 1312  domath(struct texi *p, enum texicmd cmd, 
Line 1775  domath(struct texi *p, enum texicmd cmd, 
         advance(p, buf, pos);          advance(p, buf, pos);
 }  }
   
 /* FIXME */  
 static void  static void
 doarg1(struct texi *p, enum texicmd cmd,  dolink(struct texi *p, enum texicmd cmd,
         const char *buf, size_t sz, size_t *pos)          const char *buf, size_t sz, size_t *pos)
 {  {
         int      open = 0;          int      c;
   
         if (*pos == sz || '{' != buf[*pos])  
                 return;  
         advance(p, buf, pos);  
         switch (cmd) {          switch (cmd) {
         case (TEXICMD_EMAIL):          case (TEXICMD_EMAIL):
                 if ( ! p->outmacro) {                  teximacroopen(p, "Mt");
                         open = 1;  
                         teximacroopen(p, ".");  
                 }  
                 texiputchars(p, "Lk ");  
                 break;                  break;
         case (TEXICMD_UREF):          case (TEXICMD_UREF):
         case (TEXICMD_URL):          case (TEXICMD_URL):
                 if ( ! p->outmacro) {                  teximacroopen(p, "Lk");
                         open = 1;  
                         teximacroopen(p, ".");  
                 }  
                 texiputchars(p, "Mt ");  
                 break;                  break;
         default:          case (TEXICMD_XREF):
                   texiputchars(p, "See Section");
                   teximacroopen(p, "Qq");
                 break;                  break;
           case (TEXICMD_PXREF):
                   texiputchars(p, "see Section");
                   teximacroopen(p, "Qq");
                   break;
           default:
                   abort();
         }          }
         /* FIXME: this is ugly */  
         while (*pos < sz && '}' != buf[*pos] && ',' != buf[*pos]) {          c = parsearg(p, buf, sz, pos, 0);
                 texiputchar(p, buf[*pos]);          p->ign++;
                 advance(p, buf, pos);          while (c > 0)
         }                  c = parsearg(p, buf, sz, pos, 1);
         while (*pos < sz && '}' != buf[*pos])          p->ign--;
                 advance(p, buf, pos);  
         if (*pos < sz)          texipunctuate(p, buf, sz, pos);
                 advance(p, buf, pos);          teximacroclose(p);
         if (*pos < sz - 1 &&  
                  ismpunct(buf[*pos]) &&  
                  isspace(buf[*pos + 1])) {  
                 texiputchar(p, ' ');  
                 texiputchar(p, buf[*pos]);  
                 advance(p, buf, pos);  
         }  
         if (open)  
                 teximacroclose(p);  
 }  }
   
 static void  static void
   doignargn(struct texi *p, enum texicmd cmd,
           const char *buf, size_t sz, size_t *pos)
   {
           int      c;
   
           c = parsearg(p, buf, sz, pos, 0);
           p->ign++;
           while (c > 0)
                   c = parsearg(p, buf, sz, pos, 1);
           p->ign--;
   }
   
   static void
 dosubsection(struct texi *p, enum texicmd cmd,  dosubsection(struct texi *p, enum texicmd cmd,
                 const char *buf, size_t sz, size_t *pos)                  const char *buf, size_t sz, size_t *pos)
 {  {
   
         if (p->outmacro)          if (p->outmacro)
                 texierr(p, "subsubsection in open line scope!?");                  texierr(p, "\"Em\" in open line scope!?");
         else if (p->literal)          else if (p->literal)
                 texierr(p, "subsubsection in a literal scope!?");                  texierr(p, "\"Em\" in a literal scope!?");
   
         teximacro(p, ".Pp");          texivspace(p);
           teximacroopen(p, "Em");
         parseeoln(p, buf, sz, pos);          parseeoln(p, buf, sz, pos);
         teximacro(p, ".Pp");          teximacroclose(p);
           texivspace(p);
 }  }
   
 static void  static void
 dosection(struct texi *p, enum texicmd cmd,  dosection(struct texi *p, enum texicmd cmd,
                 const char *buf, size_t sz, size_t *pos)                  const char *buf, size_t sz, size_t *pos)
 {  {
           const char      *blk;
   
           switch (cmd) {
           case (TEXICMD_APPENDIX):
           case (TEXICMD_CHAPTER):
           case (TEXICMD_TOP):
           case (TEXICMD_UNNUMBERED):
                   blk = "Sh";
                   break;
           case (TEXICMD_APPENDIXSEC):
           case (TEXICMD_HEADING):
           case (TEXICMD_SECTION):
           case (TEXICMD_UNNUMBEREDSEC):
                   blk = "Ss";
                   break;
           default:
                   abort();
           }
   
         if (p->outmacro)          if (p->outmacro)
                 texierr(p, "subsection in open line scope!?");                  texierr(p, "%s in open line scope!?", blk);
         else if (p->literal)          else if (p->literal)
                 texierr(p, "subsection in a literal scope!?");                  texierr(p, "%s in a literal scope!?", blk);
   
         teximacroopen(p, ".Ss ");          teximacroopen(p, blk);
         parseeoln(p, buf, sz, pos);          parseeoln(p, buf, sz, pos);
         teximacroclose(p);          teximacroclose(p);
           p->seenvs = 1;
 }  }
   
 static void  static void
Line 1396  dosp(struct texi *p, enum texicmd cmd, 
Line 1880  dosp(struct texi *p, enum texicmd cmd, 
         const char *buf, size_t sz, size_t *pos)          const char *buf, size_t sz, size_t *pos)
 {  {
   
         if (p->outmacro)          texivspace(p);
                 texierr(p, "spacing in open line scope!?");          /* FIXME: ignore and parseeoln. */
         else if (p->literal)  
                 texierr(p, "spacing in a literal scope!?");  
   
         teximacro(p, ".Pp");  
         advanceeoln(p, buf, sz, pos, 1);          advanceeoln(p, buf, sz, pos, 1);
 }  }
   
 static void  static void
 dochapter(struct texi *p, enum texicmd cmd,  dotop(struct texi *p, enum texicmd cmd,
         const char *buf, size_t sz, size_t *pos)          const char *buf, size_t sz, size_t *pos)
 {  {
           const char      *cp;
           time_t           t;
           char             date[32];
   
         if (p->outmacro)          /*
                 texierr(p, "section in open line scope!?");           * Here we print our standard mdoc(7) prologue.
         else if (p->literal)           * We use the title set with @settitle for the `Nd' description
                 texierr(p, "section in a literal scope!?");           * and the source document filename (the first one as invoked on
            * the command line) for the title.
            * The date is set to the current date.
            */
           t = time(NULL);
           strftime(date, sizeof(date), "%F", localtime(&t));
   
         teximacroopen(p, ".Sh ");          p->ign--;
         parseeoln(p, buf, sz, pos);          teximacroopen(p, "Dd");
           texiputchars(p, date);
         teximacroclose(p);          teximacroclose(p);
           teximacroopen(p, "Dt");
           for (cp = p->title; '\0' != *cp; cp++)
                   texiputchar(p, toupper(*cp));
           texiputchars(p, " 7");
           teximacroclose(p);
           teximacro(p, "Os");
           teximacro(p, "Sh NAME");
           teximacroopen(p, "Nm");
           texiputchars(p, p->title);
           teximacroclose(p);
           teximacroopen(p, "Nd");
           texiputchars(p, NULL != p->subtitle ?
                   p->subtitle : "Unknown description");
           teximacroclose(p);
           p->seenvs = 1;
           dosection(p, cmd, buf, sz, pos);
 }  }
   
 static void  static void
 dotop(struct texi *p, enum texicmd cmd,  
         const char *buf, size_t sz, size_t *pos)  
 {  
   
         p->ign--;  
         advanceeoln(p, buf, sz, pos, 1);  
         teximacro(p, ".Dd $Mdocdate$");  
         teximacro(p, ".Dt SOMETHING 7");  
         teximacro(p, ".Os");  
         teximacro(p, ".Sh NAME");  
         teximacro(p, ".Nm Something");  
         teximacro(p, ".Nd Something");  
 }  
   
 static void  
 doitem(struct texi *p, enum texicmd cmd,  doitem(struct texi *p, enum texicmd cmd,
         const char *buf, size_t sz, size_t *pos)          const char *buf, size_t sz, size_t *pos)
 {  {
   
           /* Multitable is using raw tbl(7). */
           if (TEXILIST_TABLE == p->list) {
                   texiputchar(p, '\n');
                   return;
           }
   
         if (p->outmacro)          if (p->outmacro)
                 texierr(p, "item in open line scope!?");                  texierr(p, "item in open line scope!?");
         else if (p->literal)          else if (p->literal)
Line 1447  doitem(struct texi *p, enum texicmd cmd, 
Line 1943  doitem(struct texi *p, enum texicmd cmd, 
   
         switch (p->list) {          switch (p->list) {
         case (TEXILIST_ITEM):          case (TEXILIST_ITEM):
                 teximacroopen(p, ".It");                  teximacroopen(p, "It");
                 break;                  break;
         case (TEXILIST_NOITEM):          case (TEXILIST_NOITEM):
                 teximacro(p, ".It");                  teximacro(p, "It");
                 break;                  break;
         default:          default:
                 teximacro(p, ".Pp");                  texivspace(p);
                 break;                  break;
         }          }
   
           /* Trick so we don't start with Pp. */
           p->seenvs = 1;
         parseeoln(p, buf, sz, pos);          parseeoln(p, buf, sz, pos);
   
         if (TEXILIST_ITEM == p->list)          if (TEXILIST_ITEM == p->list)
                 teximacroclose(p);                  teximacroclose(p);
         else          else if (p->outcol > 0)
                 texiputchar(p, '\n');                  texiputchar(p, '\n');
 }  }
   
 static void  static void
 dotable(struct texi *p, enum texicmd cmd,  dotab(struct texi *p, enum texicmd cmd,
         const char *buf, size_t sz, size_t *pos)          const char *buf, size_t sz, size_t *pos)
 {  {
   
           /* This command is only useful in @multitable. */
           if (TEXILIST_TABLE == p->list)
                   texiputchar(p, '\t');
   }
   
   static void
   domultitable(struct texi *p, enum texicmd cmd,
           const char *buf, size_t sz, size_t *pos)
   {
         enum texilist   sv = p->list;          enum texilist   sv = p->list;
           enum texicmd    type;
           size_t          i, end, columns;
   
         if (p->outmacro)          p->list = TEXILIST_TABLE;
                 texierr(p, "table in open line scope!?");          teximacro(p, "TS");
         else if (p->literal)          columns = 0;
                 texierr(p, "table in a literal scope!?");  
   
           /* Advance to the first argument... */
           while (*pos < sz && isws(buf[*pos]))
                   advance(p, buf, pos);
   
           /* Make sure we don't print anything when scanning. */
           p->ign++;
           if ('@' == buf[*pos]) {
                   /*
                    * Look for @columnfractions.
                    * We ignore these, but we do use the number of
                    * arguments to set the number of columns that we'll
                    * have.
                    */
                   type = texicmd(p, buf, *pos, sz, &end);
                   advanceto(p, buf, pos, end);
                   if (TEXICMD_COLUMNFRACTIONS != type)
                           texierr(p, "unknown multitable type");
                   while (*pos < sz && '\n' != buf[*pos]) {
                           while (*pos < sz && isws(buf[*pos]))
                                   advance(p, buf, pos);
                           while (*pos < sz && ! isws(buf[*pos])) {
                                   if ('\n' == buf[*pos])
                                           break;
                                   advance(p, buf, pos);
                           }
                           columns++;
                   }
           } else
                   /*
                    * We have arguments.
                    * We could parse these, but it's easier to just let
                    * tbl(7) figure it out.
                    * So use this only to count arguments.
                    */
                   while (parselinearg(p, buf, sz, pos) > 0)
                           columns++;
           p->ign--;
   
           /* Left-justify each table entry. */
           for (i = 0; i < columns; i++) {
                   if (i > 0)
                           texiputchar(p, ' ');
                   texiputchar(p, 'l');
           }
           texiputchars(p, ".\n");
           p->outmacro++;
           parseto(p, buf, sz, pos, texitoks[cmd].tok);
           p->outmacro--;
           teximacro(p, "TE");
           p->list = sv;
   }
   
   static void
   dotable(struct texi *p, enum texicmd cmd,
           const char *buf, size_t sz, size_t *pos)
   {
           enum texilist   sv = p->list;
   
         p->list = TEXILIST_ITEM;          p->list = TEXILIST_ITEM;
         teximacro(p, ".Bl -tag -width Ds");          teximacro(p, "Bl -tag -width Ds");
         parseto(p, buf, sz, pos, "table");          /* FIXME: ignore and parseeoln. */
         teximacro(p, ".El");          advanceeoln(p, buf, sz, pos, 1);
           p->seenvs = 1;
           parseto(p, buf, sz, pos, texitoks[cmd].tok);
           teximacro(p, "El");
         p->list = sv;          p->list = sv;
 }  }
   
Line 1489  doenumerate(struct texi *p, enum texicmd cmd, 
Line 2059  doenumerate(struct texi *p, enum texicmd cmd, 
 {  {
         enum texilist    sv = p->list;          enum texilist    sv = p->list;
   
         if (p->outmacro)  
                 texierr(p, "enumerate in open line scope!?");  
         else if (p->literal)  
                 texierr(p, "enumerate in a literal scope!?");  
   
         p->list = TEXILIST_NOITEM;          p->list = TEXILIST_NOITEM;
         teximacro(p, ".Bl -enum");          teximacro(p, "Bl -enum");
           p->seenvs = 1;
           /* FIXME: ignore and parseeoln. */
           advanceeoln(p, buf, sz, pos, 1);
         parseto(p, buf, sz, pos, "enumerate");          parseto(p, buf, sz, pos, "enumerate");
         teximacro(p, ".El");          teximacro(p, "El");
         p->list = sv;          p->list = sv;
 }  }
   
Line 1507  doitemize(struct texi *p, enum texicmd cmd, 
Line 2075  doitemize(struct texi *p, enum texicmd cmd, 
 {  {
         enum texilist   sv = p->list;          enum texilist   sv = p->list;
   
         if (p->outmacro)  
                 texierr(p, "itemize in open line scope!?");  
         else if (p->literal)  
                 texierr(p, "itemize in a literal scope!?");  
   
         p->list = TEXILIST_ITEM;          p->list = TEXILIST_ITEM;
         teximacro(p, ".Bl -bullet");          teximacro(p, "Bl -bullet");
           p->seenvs = 1;
           /* FIXME: ignore and parseeoln. */
           advanceeoln(p, buf, sz, pos, 1);
         parseto(p, buf, sz, pos, "itemize");          parseto(p, buf, sz, pos, "itemize");
         teximacro(p, ".El");          teximacro(p, "El");
         p->list = sv;          p->list = sv;
 }  }
   
Line 1534  doignline(struct texi *p, enum texicmd cmd, 
Line 2100  doignline(struct texi *p, enum texicmd cmd, 
         const char *buf, size_t sz, size_t *pos)          const char *buf, size_t sz, size_t *pos)
 {  {
   
           /* FIXME: ignore and parseeoln. */
         advanceeoln(p, buf, sz, pos, 1);          advanceeoln(p, buf, sz, pos, 1);
 }  }
   
   /*
    * Parse colon-separated directories from "cp" (if not NULL) and returns
    * the array of pointers.
    * Prepends "base" to the array.
    * This does NOT sanitise the directories!
    */
   static char **
   parsedirs(const char *base, const char *cp, size_t *sz)
   {
           char             *tok, *str, *tofree;
           const char       *cpp;
           size_t            i;
           char            **dirs;
   
           *sz = NULL != (cpp = cp) ? 2 : 1;
           if (*sz > 1)
                   for ( ; NULL != (cpp = strchr(cpp, ':')); (*sz)++)
                           cpp++;
   
           dirs = calloc(*sz, sizeof(char *));
           if (NULL == dirs) {
                   perror(NULL);
                   exit(EXIT_FAILURE);
           } else if (NULL == (dirs[0] = strdup(base))) {
                   perror(NULL);
                   exit(EXIT_FAILURE);
           }
   
           if (NULL == cp)
                   return(dirs);
   
           if (NULL == (tofree = tok = str = strdup(cp))) {
                   perror(NULL);
                   exit(EXIT_FAILURE);
           }
   
           for (i = 1; NULL != (tok = strsep(&str, ":")); i++)
                   if (NULL == (dirs[i] = strdup(tok))) {
                           perror(NULL);
                           exit(EXIT_FAILURE);
                   }
   
           free(tofree);
           return(dirs);
   }
   
 int  int
 main(int argc, char *argv[])  main(int argc, char *argv[])
 {  {
         struct texi      texi;          struct texi      texi;
         int              c;          int              c;
         char            *path, *dir;          char            *path, *dir;
         const char      *progname;          const char      *progname, *Idir, *cp;
   
         progname = strrchr(argv[0], '/');          progname = strrchr(argv[0], '/');
         if (progname == NULL)          if (progname == NULL)
Line 1551  main(int argc, char *argv[])
Line 2164  main(int argc, char *argv[])
         else          else
                 ++progname;                  ++progname;
   
         while (-1 != (c = getopt(argc, argv, "")))          memset(&texi, 0, sizeof(struct texi));
           Idir = NULL;
   
           while (-1 != (c = getopt(argc, argv, "I:")))
                 switch (c) {                  switch (c) {
                   case ('I'):
                           Idir = optarg;
                           break;
                 default:                  default:
                         goto usage;                          goto usage;
                 }                  }
Line 1571  main(int argc, char *argv[])
Line 2190  main(int argc, char *argv[])
         }          }
         free(path);          free(path);
   
         memset(&texi, 0, sizeof(struct texi));          if (NULL != (cp = strrchr(argv[0], '/')))
                   texi.title = strdup(cp + 1);
           else
                   texi.title = strdup(argv[0]);
   
           if (NULL == texi.title) {
                   perror(NULL);
                   exit(EXIT_FAILURE);
           } else if (NULL != (path = strchr(texi.title, '.')))
                   *path = '\0';
   
         texi.ign = 1;          texi.ign = 1;
         texi.dir = strdup(dir);          texi.dirs = parsedirs(dir, Idir, &texi.dirsz);
         parsefile(&texi, argv[0]);          parsefile(&texi, argv[0], 1);
           /* We shouldn't get here. */
         texiexit(&texi);          texiexit(&texi);
         return(EXIT_FAILURE);          return(EXIT_FAILURE);
 usage:  usage:
         fprintf(stderr, "usage: %s file\n", progname);          fprintf(stderr, "usage: %s [-Idirs] file\n", progname);
         return(EXIT_FAILURE);          return(EXIT_FAILURE);
 }  }
Legend:
Removed from v.1.3  
changed lines
  Added in v.1.20
CVSweb