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

Diff for /texi2mdoc/main.c between version 1.22 and 1.27

version 1.22, 2015/02/19 16:44:26 version 1.27, 2015/02/21 17:00:33
Line 30 
Line 30 
 #include <time.h>  #include <time.h>
 #include <unistd.h>  #include <unistd.h>
   
 /*  #include "extern.h"
  * This defines each one of the Texinfo commands that we understand.  
  * Obviously this only refers to native commands; overriden names are a  
  * different story.  
  */  
 enum    texicmd {  
         TEXICMD_ACRONYM,  
         TEXICMD_ACUTE,  
         TEXICMD_A4PAPER,  
         TEXICMD_ANCHOR,  
         TEXICMD_APPENDIX,  
         TEXICMD_APPENDIXSEC,  
         TEXICMD_APPENDIXSUBSEC,  
         TEXICMD_ASTERISK,  
         TEXICMD_AT,  
         TEXICMD_AUTHOR,  
         TEXICMD_B,  
         TEXICMD_BANG,  
         TEXICMD_BULLET,  
         TEXICMD_BYE,  
         TEXICMD_CENTER,  
         TEXICMD_CHAPTER,  
         TEXICMD_CINDEX,  
         TEXICMD_CIRCUMFLEX,  
         TEXICMD_CITE,  
         TEXICMD_CODE,  
         TEXICMD_COLON,  
         TEXICMD_COLUMNFRACTIONS,  
         TEXICMD_COMMAND,  
         TEXICMD_COMMENT,  
         TEXICMD_COMMENT_LONG,  
         TEXICMD_CONTENTS,  
         TEXICMD_COPYING,  
         TEXICMD_COPYRIGHT,  
         TEXICMD_DEFFN,  
         TEXICMD_DEFFNX,  
         TEXICMD_DEFMAC,  
         TEXICMD_DEFMACX,  
         TEXICMD_DEFTP,  
         TEXICMD_DEFTPX,  
         TEXICMD_DEFTYPEFN,  
         TEXICMD_DEFTYPEFNX,  
         TEXICMD_DEFTYPEFUN,  
         TEXICMD_DEFTYPEFUNX,  
         TEXICMD_DEFTYPEVAR,  
         TEXICMD_DEFTYPEVARX,  
         TEXICMD_DEFTYPEVR,  
         TEXICMD_DEFTYPEVRX,  
         TEXICMD_DEFUN,  
         TEXICMD_DEFUNX,  
         TEXICMD_DEFVAR,  
         TEXICMD_DEFVARX,  
         TEXICMD_DEFVR,  
         TEXICMD_DEFVRX,  
         TEXICMD_DETAILMENU,  
         TEXICMD_DFN,  
         TEXICMD_DIRCATEGORY,  
         TEXICMD_DIRENTRY,  
         TEXICMD_DISPLAY,  
         TEXICMD_DOTS,  
         TEXICMD_EMAIL,  
         TEXICMD_EMPH,  
         TEXICMD_END,  
         TEXICMD_ENUMERATE,  
         TEXICMD_ENV,  
         TEXICMD_ERROR,  
         TEXICMD_EXAMPLE,  
         TEXICMD_EXPANSION,  
         TEXICMD_FILE,  
         TEXICMD_FINALOUT,  
         TEXICMD_FINDEX,  
         TEXICMD_FTABLE,  
         TEXICMD_FORMAT,  
         TEXICMD_GRAVE,  
         TEXICMD_GROUP,  
         TEXICMD_HEADING,  
         TEXICMD_HEADINGS,  
         TEXICMD_HEADITEM,  
         TEXICMD_HYPHEN,  
         TEXICMD_I,  
         TEXICMD_IFCLEAR,  
         TEXICMD_IFDOCBOOK,  
         TEXICMD_IFHTML,  
         TEXICMD_IFINFO,  
         TEXICMD_IFNOTDOCBOOK,  
         TEXICMD_IFNOTHTML,  
         TEXICMD_IFNOTINFO,  
         TEXICMD_IFNOTPLAINTEXT,  
         TEXICMD_IFNOTTEX,  
         TEXICMD_IFNOTXML,  
         TEXICMD_IFPLAINTEXT,  
         TEXICMD_IFTEX,  
         TEXICMD_IFSET,  
         TEXICMD_IFXML,  
         TEXICMD_IGNORE,  
         TEXICMD_IMAGE,  
         TEXICMD_INCLUDE,  
         TEXICMD_INDENTBLOCK,  
         TEXICMD_INSERTCOPYING,  
         TEXICMD_ITEM,  
         TEXICMD_ITEMIZE,  
         TEXICMD_ITEMX,  
         TEXICMD_KBD,  
         TEXICMD_KEY,  
         TEXICMD_KINDEX,  
         TEXICMD_LATEX,  
         TEXICMD_MATH,  
         TEXICMD_MENU,  
         TEXICMD_MULTITABLE,  
         TEXICMD_NEED,  
         TEXICMD_NEWLINE,  
         TEXICMD_NODE,  
         TEXICMD_NOINDENT,  
         TEXICMD_OPTION,  
         TEXICMD_PXREF,  
         TEXICMD_QUESTIONMARK,  
         TEXICMD_QUOTATION,  
         TEXICMD_PAGE,  
         TEXICMD_PARINDENT,  
         TEXICMD_PRINTINDEX,  
         TEXICMD_R,  
         TEXICMD_REF,  
         TEXICMD_RESULT,  
         TEXICMD_SAMP,  
         TEXICMD_SANSSERIF,  
         TEXICMD_SC,  
         TEXICMD_SECTION,  
         TEXICMD_SET,  
         TEXICMD_SETCHAPNEWPAGE,  
         TEXICMD_SETFILENAME,  
         TEXICMD_SETTITLE,  
         TEXICMD_SLANTED,  
         TEXICMD_SP,  
         TEXICMD_SPACE,  
         TEXICMD_SMALLBOOK,  
         TEXICMD_SMALLDISPLAY,  
         TEXICMD_SMALLEXAMPLE,  
         TEXICMD_SMALLFORMAT,  
         TEXICMD_SMALLINDENTBLOCK,  
         TEXICMD_SQUIGGLE_LEFT,  
         TEXICMD_SQUIGGLE_RIGHT,  
         TEXICMD_STRONG,  
         TEXICMD_SUBHEADING,  
         TEXICMD_SUBSECTION,  
         TEXICMD_SUBTITLE,  
         TEXICMD_SYNCODEINDEX,  
         TEXICMD_T,  
         TEXICMD_TAB,  
         TEXICMD_TABSYM,  
         TEXICMD_TABLE,  
         TEXICMD_TEX,  
         TEXICMD_TEXSYM,  
         TEXICMD_TILDE,  
         TEXICMD_TITLE,  
         TEXICMD_TITLEFONT,  
         TEXICMD_TITLEPAGE,  
         TEXICMD_TOP,  
         TEXICMD_UMLAUT,  
         TEXICMD_UNNUMBERED,  
         TEXICMD_UNNUMBEREDSEC,  
         TEXICMD_UNNUMBEREDSUBSEC,  
         TEXICMD_UREF,  
         TEXICMD_URL,  
         TEXICMD_VAR,  
         TEXICMD_VERBATIMINCLUDE,  
         TEXICMD_VINDEX,  
         TEXICMD_VSKIP,  
         TEXICMD_VTABLE,  
         TEXICMD_W,  
         TEXICMD_XREF,  
         TEXICMD__MAX  
 };  
   
 /*  #define SECTSZ 4
  * The file currently being parsed.  static  const char *const sects[SECTSZ] = {
  * This keeps track of our location within that file.          "Sh",
  */          "Ss",
 struct  texifile {          "Em",
         const char      *name; /* name of the file */          "No",
         size_t           line; /* current line (from zero) */  
         size_t           col; /* current column in line (from zero) */  
         char            *map; /* mmap'd file */  
         size_t           mapsz; /* size of mmap */  
 };  };
   
 struct  texi;  
   
 /*  
  * Callback for functions implementing texi commands.  
  */  
 typedef void (*texicmdfp)(struct texi *,  
         enum texicmd, const char *, size_t, size_t *);  
   
 /*  
  * Describes Texinfo commands, whether native or overriden.  
  */  
 struct  texitok {  
         texicmdfp        fp; /* callback (or NULL if none) */  
         const char      *tok; /* name of the token */  
         size_t           len; /* strlen(tok) */  
 };  
   
 enum    texilist {  
         TEXILIST_NONE = 0,  
         TEXILIST_ITEM,  
         TEXILIST_NOITEM,  
         TEXILIST_TABLE  
 };  
   
 /*  
  * The main parse structure.  
  * This keeps any necessary information handy.  
  */  
 struct  texi {  
         struct texifile   files[64]; /* stack of open files */  
         size_t            filepos; /* number of open files */  
         size_t            outcol; /* column in output line */  
         char            **dirs; /* texi directories */  
         size_t            dirsz; /* number of texi directories */  
         char             *title; /* title of document */  
         char             *subtitle; /* subtitle of document */  
         /*  
          * 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 */  
 };  
   
 /* Texi disregards spaces and tabs. */  
 #define isws(_x) \  
         (' ' == (_x) || '\t' == (_x))  
 #define ismspace(_x) \  
         (isws((_x)) || '\n' == (_x))  
   
 static  void doaccent(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 dodefindex(struct texi *, enum texicmd, const char *, size_t, size_t *);
 static  void dodefn(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void dodefn(struct texi *, enum texicmd, const char *, size_t, size_t *);
 static  void dodisplay(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void dodisplay(struct texi *, enum texicmd, const char *, size_t, size_t *);
 static  void doenumerate(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void doenumerate(struct texi *, enum texicmd, const char *, size_t, size_t *);
Line 291  static void domultitable(struct texi *, enum texicmd, 
Line 63  static void domultitable(struct texi *, enum texicmd, 
 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 *);
   static  void dosecoffs(struct texi *, enum texicmd, const char *, size_t, size_t *);
 static  void dosection(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void dosection(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 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 dosubsubsection(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 dotab(struct texi *, enum texicmd, const char *, size_t, size_t *);
 static  void dotitle(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void dotitle(struct texi *, enum texicmd, const char *, size_t, size_t *);
   static  void dovalue(struct texi *, enum texicmd, const char *, size_t, size_t *);
   static  void doverb(struct texi *, enum texicmd, const char *, size_t, size_t *);
 static  void doverbinclude(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void doverbinclude(struct texi *, enum texicmd, const char *, size_t, size_t *);
   
 static  const struct texitok texitoks[TEXICMD__MAX] = {  static  const struct texitok __texitoks[TEXICMD__MAX] = {
         /* TEXICMD__BEGIN */          /* TEXICMD__BEGIN */
         { doignargn, "acronym", 7 }, /* TEXICMD_ACRONYM */          { doignargn, "acronym", 7 }, /* TEXICMD_ACRONYM */
         { doaccent, "'", 1 }, /* TEXICMD_ACUTE */          { doaccent, "'", 1 }, /* TEXICMD_ACUTE */
Line 308  static const struct texitok texitoks[TEXICMD__MAX] = {
Line 84  static const struct texitok texitoks[TEXICMD__MAX] = {
         { dosection, "appendix", 8 }, /* TEXICMD_APPENDIX */          { dosection, "appendix", 8 }, /* TEXICMD_APPENDIX */
         { dosection, "appendixsec", 11 }, /* TEXICMD_APPENDIXSEC */          { dosection, "appendixsec", 11 }, /* TEXICMD_APPENDIXSEC */
         { dosubsection, "appendixsubsec", 14 }, /* TEXICMD_APPENDIXSUBSEC */          { dosubsection, "appendixsubsec", 14 }, /* TEXICMD_APPENDIXSUBSEC */
           { dosubsubsection, "appendixsubsubsec", 17 }, /* TEXICMD_APPENDIXSUBSUBSEC */
           { doinline, "asis", 4 }, /* TEXICMD_ASIS */
         { dosymbol, "*", 1 }, /* TEXICMD_ASTERISK */          { dosymbol, "*", 1 }, /* TEXICMD_ASTERISK */
         { dosymbol, "@", 1 }, /* TEXICMD_AT */          { dosymbol, "@", 1 }, /* TEXICMD_AT */
         { doignline, "author", 6 }, /* TEXICMD_AUTHOR */          { doignline, "author", 6 }, /* TEXICMD_AUTHOR */
Line 319  static const struct texitok texitoks[TEXICMD__MAX] = {
Line 97  static const struct texitok texitoks[TEXICMD__MAX] = {
         { dosection, "chapter", 7 }, /* TEXICMD_CHAPTER */          { dosection, "chapter", 7 }, /* TEXICMD_CHAPTER */
         { doignline, "cindex", 6 }, /* TEXICMD_CINDEX */          { doignline, "cindex", 6 }, /* TEXICMD_CINDEX */
         { doaccent, "^", 1 }, /* TEXICMD_CIRCUMFLEX */          { doaccent, "^", 1 }, /* TEXICMD_CIRCUMFLEX */
         { doinline, "code", 4 }, /* TEXICMD_CODE */  
         { doinline, "cite", 4 }, /* TEXICMD_CITE */          { doinline, "cite", 4 }, /* TEXICMD_CITE */
           { dovalue, "clear", 5 }, /* TEXICMD_CLEAR */
           { doinline, "code", 4 }, /* TEXICMD_CODE */
         { dosymbol, ":", 1 }, /* TEXICMD_COLON */          { dosymbol, ":", 1 }, /* TEXICMD_COLON */
         { NULL, "columnfractions", 15 }, /* TEXICMD_COLUMNFRACTIONS */          { NULL, "columnfractions", 15 }, /* TEXICMD_COLUMNFRACTIONS */
         { doinline, "command", 7 }, /* TEXICMD_COMMAND */          { doinline, "command", 7 }, /* TEXICMD_COMMAND */
Line 329  static const struct texitok texitoks[TEXICMD__MAX] = {
Line 108  static const struct texitok texitoks[TEXICMD__MAX] = {
         { 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 */
           { dodefindex, "defcodeindex", 12 }, /* TEXICMD_DEFCODEINDEX */
         { dodefn, "deffn", 5 }, /* TEXICMD_DEFFN */          { dodefn, "deffn", 5 }, /* TEXICMD_DEFFN */
         { dodefn, "deffnx", 6 }, /* TEXICMD_DEFFNX */          { dodefn, "deffnx", 6 }, /* TEXICMD_DEFFNX */
           { dodefindex, "defindex", 8 }, /* TEXICMD_DEFINDEX */
         { dodefn, "defmac", 6 }, /* TEXICMD_DEFMAC */          { dodefn, "defmac", 6 }, /* TEXICMD_DEFMAC */
         { dodefn, "defmacx", 7 }, /* TEXICMD_DEFMACX */          { dodefn, "defmacx", 7 }, /* TEXICMD_DEFMACX */
         { dodefn, "deftp", 5 }, /* TEXICMD_DEFTP */          { dodefn, "deftp", 5 }, /* TEXICMD_DEFTP */
Line 362  static const struct texitok texitoks[TEXICMD__MAX] = {
Line 143  static const struct texitok texitoks[TEXICMD__MAX] = {
         { doinline, "env", 3 }, /* TEXICMD_ENV */          { doinline, "env", 3 }, /* TEXICMD_ENV */
         { dosymbol, "error", 5 }, /* TEXICMD_ERROR */          { dosymbol, "error", 5 }, /* TEXICMD_ERROR */
         { doexample, "example", 7 }, /* TEXICMD_EXAMPLE */          { doexample, "example", 7 }, /* TEXICMD_EXAMPLE */
           { doignline, "exdent", 6 }, /* TEXICMD_EXDENT */
         { dosymbol, "expansion", 9 }, /* TEXICMD_EXPANSION */          { dosymbol, "expansion", 9 }, /* TEXICMD_EXPANSION */
         { doinline, "file", 4 }, /* TEXICMD_FILE */          { doinline, "file", 4 }, /* TEXICMD_FILE */
         { doignline, "finalout", 8 }, /* TEXICMD_FINALOUT */          { doignline, "finalout", 8 }, /* TEXICMD_FINALOUT */
Line 373  static const struct texitok texitoks[TEXICMD__MAX] = {
Line 155  static const struct texitok texitoks[TEXICMD__MAX] = {
         { dosection, "heading", 7 }, /* TEXICMD_HEADING */          { dosection, "heading", 7 }, /* TEXICMD_HEADING */
         { doignline, "headings", 8 }, /* TEXICMD_HEADINGS */          { doignline, "headings", 8 }, /* TEXICMD_HEADINGS */
         { doitem, "headitem", 8 }, /* TEXICMD_HEADITEM */          { doitem, "headitem", 8 }, /* TEXICMD_HEADITEM */
           { doignblock, "html", 4 }, /* TEXICMD_HTML */
         { dosymbol, "-", 1 }, /* TEXICMD_HYPHEN */          { dosymbol, "-", 1 }, /* TEXICMD_HYPHEN */
         { doinline, "i", 1 }, /* TEXICMD_I */          { doinline, "i", 1 }, /* TEXICMD_I */
         { doignblock, "ifclear", 7 }, /* TEXICMD_IFCLEAR */          { dovalue, "ifclear", 7 }, /* TEXICMD_IFCLEAR */
         { doignblock, "ifdocbook", 9 }, /* TEXICMD_IFDOCBOOK */          { doignblock, "ifdocbook", 9 }, /* TEXICMD_IFDOCBOOK */
         { doignblock, "ifhtml", 6 }, /* TEXICMD_IFHTML */          { doignblock, "ifhtml", 6 }, /* TEXICMD_IFHTML */
         { doignblock, "ifinfo", 6 }, /* TEXICMD_IFINFO */          { doblock, "ifinfo", 6 }, /* TEXICMD_IFINFO */
         { doblock, "ifnotdocbook", 12 }, /* TEXICMD_IFNOTDOCBOOK */          { doblock, "ifnotdocbook", 12 }, /* TEXICMD_IFNOTDOCBOOK */
         { doblock, "ifnothtml", 9 }, /* TEXICMD_IFNOTHTML */          { doblock, "ifnothtml", 9 }, /* TEXICMD_IFNOTHTML */
         { doblock, "ifnotinfo", 9 }, /* TEXICMD_IFNOTINFO */          { doblock, "ifnotinfo", 9 }, /* TEXICMD_IFNOTINFO */
Line 393  static const struct texitok texitoks[TEXICMD__MAX] = {
Line 176  static const struct texitok texitoks[TEXICMD__MAX] = {
         { doignbracket, "image", 5 }, /* TEXICMD_IMAGE */          { doignbracket, "image", 5 }, /* TEXICMD_IMAGE */
         { doinclude, "include", 7 }, /* TEXICMD_INCLUDE */          { doinclude, "include", 7 }, /* TEXICMD_INCLUDE */
         { dodisplay, "indentblock", 11 }, /* TEXICMD_INDENTBLOCK */          { dodisplay, "indentblock", 11 }, /* TEXICMD_INDENTBLOCK */
           { doignline, "", 0 }, /* TEXICMD_INDEX */
         { doignline, "insertcopying", 13 }, /* TEXICMD_INSERTCOPYING */          { doignline, "insertcopying", 13 }, /* TEXICMD_INSERTCOPYING */
         { doitem, "item", 4 }, /* TEXICMD_ITEM */          { doitem, "item", 4 }, /* TEXICMD_ITEM */
         { doitemize, "itemize", 7 }, /* TEXICMD_ITEMIZE */          { doitemize, "itemize", 7 }, /* TEXICMD_ITEMIZE */
Line 401  static const struct texitok texitoks[TEXICMD__MAX] = {
Line 185  static const struct texitok texitoks[TEXICMD__MAX] = {
         { dobracket, "key", 3 }, /* TEXICMD_KEY */          { dobracket, "key", 3 }, /* TEXICMD_KEY */
         { doignline, "kindex", 6 }, /* TEXICMD_KINDEX */          { doignline, "kindex", 6 }, /* TEXICMD_KINDEX */
         { dosymbol, "LaTeX", 5 }, /* TEXICMD_LATEX */          { dosymbol, "LaTeX", 5 }, /* TEXICMD_LATEX */
           { dosecoffs, "lowersections", 13 }, /* TEXICMD_LOWERSECTIONS */
         { domath, "math", 4 }, /* TEXICMD_MATH */          { domath, "math", 4 }, /* TEXICMD_MATH */
         { doignblock, "menu", 4 }, /* TEXICMD_MENU */          { doignblock, "menu", 4 }, /* TEXICMD_MENU */
           { dosymbol, "minus", 5 }, /* TEXICMD_MINUS */
         { domultitable, "multitable", 10 }, /* TEXICMD_MULTITABLE */          { domultitable, "multitable", 10 }, /* TEXICMD_MULTITABLE */
         { doignline, "need", 4 }, /* TEXICMD_NEED */          { doignline, "need", 4 }, /* TEXICMD_NEED */
         { dosymbol, "\n", 1 }, /* TEXICMD_NEWLINE */          { dosymbol, "\n", 1 }, /* TEXICMD_NEWLINE */
Line 413  static const struct texitok texitoks[TEXICMD__MAX] = {
Line 199  static const struct texitok texitoks[TEXICMD__MAX] = {
         { 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", 15 }, /* TEXICMD_PARINDENT */
           { dosymbol, ".", 1 }, /* TEXICMD_PERIOD */
         { doignline, "printindex", 10 }, /* TEXICMD_PRINTINDEX */          { doignline, "printindex", 10 }, /* TEXICMD_PRINTINDEX */
         { doinline, "r", 1 }, /* TEXICMD_R */          { doinline, "r", 1 }, /* TEXICMD_R */
           { dosecoffs, "raisesections", 13 }, /* TEXICMD_RAISESECTIONS */
         { dobracket, "ref", 3 }, /* TEXICMD_REF */          { dobracket, "ref", 3 }, /* TEXICMD_REF */
         { dosymbol, "result", 6 }, /* TEXICMD_RESULT */          { dosymbol, "result", 6 }, /* TEXICMD_RESULT */
         { doinline, "samp", 4 }, /* TEXICMD_SAMP */          { doinline, "samp", 4 }, /* TEXICMD_SAMP */
         { doinline, "sansserif", 9 }, /* TEXICMD_SANSSERIF */          { doinline, "sansserif", 9 }, /* TEXICMD_SANSSERIF */
         { dobracket, "sc", 2 }, /* TEXICMD_SC */          { dobracket, "sc", 2 }, /* TEXICMD_SC */
         { dosection, "section", 7 }, /* TEXICMD_SECTION */          { dosection, "section", 7 }, /* TEXICMD_SECTION */
         { doignline, "set", 3 }, /* TEXICMD_SET */          { dovalue, "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 */          { dotitle, "settitle", 8 }, /* TEXICMD_SETTITLE */
           { doignline, "shortcontents", 13 }, /* TEXICMD_SHORTCONTENTS */
         { doinline, "slanted", 7 }, /* TEXICMD_SLANTED */          { doinline, "slanted", 7 }, /* TEXICMD_SLANTED */
         { dosp, "sp", 2 }, /* TEXICMD_SP */          { dosp, "sp", 2 }, /* TEXICMD_SP */
         { dosymbol, " ", 1 }, /* TEXICMD_SPACE */          { dosymbol, " ", 1 }, /* TEXICMD_SPACE */
Line 439  static const struct texitok texitoks[TEXICMD__MAX] = {
Line 228  static const struct texitok texitoks[TEXICMD__MAX] = {
         { doinline, "strong", 6 }, /* TEXICMD_STRONG */          { doinline, "strong", 6 }, /* TEXICMD_STRONG */
         { dosubsection, "subheading", 10 }, /* TEXICMD_SUBHEADING */          { dosubsection, "subheading", 10 }, /* TEXICMD_SUBHEADING */
         { dosubsection, "subsection", 10 }, /* TEXICMD_SUBSECTION */          { dosubsection, "subsection", 10 }, /* TEXICMD_SUBSECTION */
           { dosubsubsection, "subsubsection", 13 }, /* TEXICMD_SUBSUBSECTION */
         { doignline, "subtitle", 8 }, /* TEXICMD_SUBTITLE */          { doignline, "subtitle", 8 }, /* TEXICMD_SUBTITLE */
           { doignline, "summarycontents", 15 }, /* TEXICMD_SUMMARYCONTENTS */
           { doignline, "synindex", 8 }, /* TEXICMD_SYNINDEX */
         { doignline, "syncodeindex", 12 }, /* TEXICMD_SYNCODEINDEX */          { doignline, "syncodeindex", 12 }, /* TEXICMD_SYNCODEINDEX */
         { doinline, "t", 1 }, /* TEXICMD_T */          { doinline, "t", 1 }, /* TEXICMD_T */
         { dotab, "tab", 3 }, /* TEXICMD_TAB */          { dotab, "tab", 3 }, /* TEXICMD_TAB */
Line 448  static const struct texitok texitoks[TEXICMD__MAX] = {
Line 240  static const struct texitok texitoks[TEXICMD__MAX] = {
         { doignblock, "tex", 3 }, /* TEXICMD_TEX */          { doignblock, "tex", 3 }, /* TEXICMD_TEX */
         { dosymbol, "TeX", 3 }, /* TEXICMD_TEXSYM */          { dosymbol, "TeX", 3 }, /* TEXICMD_TEXSYM */
         { doaccent, "~", 1 }, /* TEXICMD_TILDE */          { doaccent, "~", 1 }, /* TEXICMD_TILDE */
           { doignline, "tindex", 6 }, /* TEXICMD_TINDEX */
         { doignline, "title", 5 }, /* TEXICMD_TITLE */          { doignline, "title", 5 }, /* TEXICMD_TITLE */
         { dobracket, "titlefont", 9 }, /* TEXICMD_TITLEFONT */          { dobracket, "titlefont", 9 }, /* TEXICMD_TITLEFONT */
         { doignblock, "titlepage", 9 }, /* TEXICMD_TITLEPAGE */          { doignblock, "titlepage", 9 }, /* TEXICMD_TITLEPAGE */
Line 456  static const struct texitok texitoks[TEXICMD__MAX] = {
Line 249  static const struct texitok texitoks[TEXICMD__MAX] = {
         { dosection, "unnumbered", 10 }, /* TEXICMD_UNNUMBERED */          { dosection, "unnumbered", 10 }, /* TEXICMD_UNNUMBERED */
         { dosection, "unnumberedsec", 13 }, /* TEXICMD_UNNUMBEREDSEC */          { dosection, "unnumberedsec", 13 }, /* TEXICMD_UNNUMBEREDSEC */
         { dosubsection, "unnumberedsubsec", 16 }, /* TEXICMD_UNNUMBEREDSUBSEC */          { dosubsection, "unnumberedsubsec", 16 }, /* TEXICMD_UNNUMBEREDSUBSEC */
           { dosubsubsection, "unnumberedsubsubsec", 19 }, /* TEXICMD_UNNUMBEREDSUBSUBSEC */
         { dolink, "uref", 4 }, /* TEXICMD_UREF */          { dolink, "uref", 4 }, /* TEXICMD_UREF */
         { dolink, "url", 3 }, /* TEXICMD_URL */          { dolink, "url", 3 }, /* TEXICMD_URL */
           { dovalue, "value", 5 }, /* TEXICMD_VALUE */
         { doinline, "var", 3 }, /* TEXICMD_VAR */          { doinline, "var", 3 }, /* TEXICMD_VAR */
           { doverb, "verbatim", 8 }, /* TEXICMD_VERBATIM */
         { doverbinclude, "verbatiminclude", 15 }, /* TEXICMD_VERBATIMINCLUDE */          { doverbinclude, "verbatiminclude", 15 }, /* TEXICMD_VERBATIMINCLUDE */
         { doignline, "vindex", 6 }, /* TEXICMD_VINDEX */          { doignline, "vindex", 6 }, /* TEXICMD_VINDEX */
         { dosp, "vskip", 5 }, /* TEXICMD_VSKIP */          { dosp, "vskip", 5 }, /* TEXICMD_VSKIP */
Line 468  static const struct texitok texitoks[TEXICMD__MAX] = {
Line 264  static const struct texitok texitoks[TEXICMD__MAX] = {
         /* TEXICMD__END */          /* TEXICMD__END */
 };  };
   
 /*  const   struct texitok *const texitoks = __texitoks;
  * Unmap the top-most file that we're using.  
  */  
 static void  
 texifilepop(struct texi *p)  
 {  
         struct texifile *f;  
   
         assert(p->filepos > 0);  
         f = &p->files[--p->filepos];  
         munmap(f->map, f->mapsz);  
 }  
   
 /*  
  * 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.  
  */  
 static void  static void
 texiexit(struct texi *p)  dodefindex(struct texi *p, enum texicmd cmd,
           const char *buf, size_t sz, size_t *pos)
 {  {
         size_t   i;  
   
         if (p->outcol)  
                 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);  
 }  
   
 /*  
  * Fatal error: unmap all files and exit.  
  * The "errstring" is passed to perror(3).  
  */  
 static void  
 texiabort(struct texi *p, const char *errstring)  
 {  
   
         perror(errstring);  
         texiexit(p);  
         exit(EXIT_FAILURE);  
 }  
   
 /*  
  * Print a generic warning message (to stderr) tied to our current  
  * location in the parse sequence.  
  */  
 static void  
 texiwarn(const struct texi *p, const char *fmt, ...)  
 {  
         va_list  ap;  
   
         fprintf(stderr, "%s:%zu:%zu: warning: ",  
                 p->files[p->filepos - 1].name,  
                 p->files[p->filepos - 1].line + 1,  
                 p->files[p->filepos - 1].col + 1);  
         va_start(ap, fmt);  
         vfprintf(stderr, fmt, ap);  
         va_end(ap);  
         fputc('\n', stderr);  
 }  
   
 /*  
  * Print an error message (to stderr) tied to our current location in  
  * the parse sequence, invoke texiexit(), then die.  
  */  
 static void  
 texierr(struct texi *p, const char *fmt, ...)  
 {  
         va_list  ap;  
   
         fprintf(stderr, "%s:%zu:%zu: error: ",  
                 p->files[p->filepos - 1].name,  
                 p->files[p->filepos - 1].line + 1,  
                 p->files[p->filepos - 1].col + 1);  
         va_start(ap, fmt);  
         vfprintf(stderr, fmt, ap);  
         va_end(ap);  
         fputc('\n', stderr);  
         texiexit(p);  
         exit(EXIT_FAILURE);  
 }  
   
 /*  
  * Put a single data character to the output if we're not ignoring.  
  * Adjusts our output status.  
  * This shouldn't be called for macros: just for ordinary text.  
  */  
 static void  
 texiputchar(struct texi *p, char c)  
 {  
   
         if (p->ign)  
                 return;  
   
         if ('.' == c && 0 == p->outcol)  
                 fputs("\\&", stdout);  
   
         putchar(c);  
         p->seenvs = 0;  
         if ('\n' == c) {  
                 p->outcol = 0;  
                 p->seenws = 0;  
         } else  
                 p->outcol++;  
 }  
   
 /*  
  * Put multiple characters (see texiputchar()).  
  * This shouldn't be called for macros: just for ordinary text.  
  */  
 static void  
 texiputchars(struct texi *p, const char *s)  
 {  
   
         while ('\0' != *s)  
                 texiputchar(p, *s++);  
 }  
   
 /*  
  * Close an mdoc(7) macro opened with teximacroopen().  
  * If there are no more macros on the line, prints a newline.  
  */  
 static void  
 teximacroclose(struct texi *p)  
 {  
   
         if (p->ign)  
                 return;  
   
         if (0 == --p->outmacro) {  
                 putchar('\n');  
                 p->outcol = p->seenws = 0;  
         }  
 }  
   
 /*  
  * Open a mdoc(7) macro.  
  * 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  
 teximacroopen(struct texi *p, const char *s)  
 {  
         int      rc;  
   
         if (p->ign)  
                 return;  
   
         if (p->outcol && 0 == p->outmacro) {  
                 putchar('\n');  
                 p->outcol = 0;  
         }  
   
         if (0 == p->outmacro)  
                 putchar('.');  
         else  
                 putchar(' ');  
   
         if (EOF != (rc = fputs(s, stdout)))  
                 p->outcol += rc;  
   
         putchar(' ');  
         p->outcol++;  
         p->outmacro++;  
         p->seenws = 0;  
 }  
   
 /*  
  * Put a stadnalone mdoc(7) command with the trailing newline.  
  */  
 static void  
 teximacro(struct texi *p, const char *s)  
 {  
   
         if (p->ign)  
                 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)  
                 putchar('\n');  
   
         putchar('.');  
         puts(s);  
         p->outcol = 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.  
  */  
 static void  
 advance(struct texi *p, const char *buf, size_t *pos)  
 {  
   
         if ('\n' == buf[*pos]) {  
                 p->files[p->filepos - 1].line++;  
                 p->files[p->filepos - 1].col = 0;  
         } else  
                 p->files[p->filepos - 1].col++;  
   
         (*pos)++;  
 }  
   
 static void  
 texipunctuate(struct texi *p, const char *buf, size_t sz, size_t *pos)  
 {  
         size_t   start, end;          size_t   start, end;
           char    *cp;
   
         if (1 != p->outmacro)          while (*pos < sz && isws(buf[*pos]))
                 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.  
  * If we're in literal mode, then print all of the whitespace as we're  
  * doing so.  
  */  
 static size_t  
 advancenext(struct texi *p, const char *buf, size_t sz, size_t *pos)  
 {  
   
         if (p->literal) {  
                 while (*pos < sz && ismspace(buf[*pos])) {  
                         if (*pos && '\n' == buf[*pos] &&  
                                 '\\' == buf[*pos - 1])  
                                 texiputchar(p, 'e');  
                         texiputchar(p, buf[*pos]);  
                         advance(p, buf, pos);  
                 }  
                 return(*pos);  
         }  
   
         while (*pos < sz && ismspace(buf[*pos])) {  
                 p->seenws = 1;  
                 /*  
                  * If it looks like we've printed a double-line, then  
                  * output a paragraph.  
                  * FIXME: this is stupid.  
                  */  
                 if (*pos && '\n' == buf[*pos] && '\n' == buf[*pos - 1])  
                         texivspace(p);  
                 advance(p, buf, pos);                  advance(p, buf, pos);
         }  
         return(*pos);  
 }  
   
 /*          start = end = *pos;
  * Advance to the EOLN in the input stream.          while (end < sz && ! ismspace(buf[end]))
  */                  end++;
 static size_t  
 advanceeoln(struct texi *p, const char *buf,  
         size_t sz, size_t *pos, int consumenl)  
 {  
   
         /* FIXME: disregards @NEWLINE. */          if (start == end) {
         while (*pos < sz && '\n' != buf[*pos])                  advanceeoln(p, buf, sz, pos, 1);
                 advance(p, buf, pos);  
         if (*pos < sz && consumenl)  
                 advance(p, buf, pos);  
         return(*pos);  
 }  
   
 /*  
  * Advance to position "end", which is an absolute position in the  
  * current buffer greater than or equal to the current position.  
  */  
 static void  
 advanceto(struct texi *p, const char *buf, size_t *pos, size_t end)  
 {  
   
         assert(*pos <= end);  
         while (*pos < end)  
                 advance(p, buf, pos);  
 }  
   
 /*  
  * Output a free-form word in the input stream, progressing to the next  
  * command or white-space.  
  * This also will advance the input stream.  
  */  
 static void  
 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)  
                 texiputchar(p, '\n');  
         /* FIXME: abstract this: we use it elsewhere. */  
         if (p->seenws && p->outcol && 0 == p->literal)  
                 texiputchar(p, ' ');  
   
         p->seenws = 0;  
   
         while (*pos < sz && ! ismspace(buf[*pos])) {  
                 switch (buf[*pos]) {  
                 case ('@'):  
                 case ('}'):  
                 case ('{'):  
                         return;  
                 }  
                 if ('\0' != extra && buf[*pos] == extra)  
                         return;  
                 if (*pos < sz - 1 &&  
                          '`' == buf[*pos] &&  
                          '`' == buf[*pos + 1]) {  
                         texiputchars(p, "\\(lq");  
                         advance(p, buf, pos);  
                 } else if (*pos < sz - 1 &&  
                          '\'' == buf[*pos] &&  
                          '\'' == buf[*pos + 1]) {  
                         texiputchars(p, "\\(rq");  
                         advance(p, buf, pos);  
                 } else  
                         texiputchar(p, buf[*pos]);  
                 advance(p, buf, pos);  
         }  
 }  
   
 /*  
  * 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  
 texicmd(struct texi *p, const char *buf,  
         size_t pos, size_t sz, size_t *end)  
 {  
         size_t   i, len;  
   
         assert('@' == buf[pos]);  
   
         if ((*end = pos) == sz)  
                 return(TEXICMD__MAX);  
         else if ((*end = ++pos) == sz)  
                 return(TEXICMD__MAX);  
   
         /* Alphabetic commands are special. */  
         if ( ! isalpha(buf[pos])) {  
                 if ((*end = pos + 1) == sz)  
                         return(TEXICMD__MAX);  
                 for (i = 0; i < TEXICMD__MAX; i++) {  
                         if (1 != texitoks[i].len)  
                                 continue;  
                         if (0 == strncmp(texitoks[i].tok, &buf[pos], 1))  
                                 return(i);  
                 }  
                 texiwarn(p, "bad command: @%c", buf[pos]);  
                 return(TEXICMD__MAX);  
         }  
   
         for (*end = pos; *end < sz && ! ismspace(buf[*end]); (*end)++)  
                 if ((*end > pos && ('@' == buf[*end] ||  
                           '{' == buf[*end] || '}' == buf[*end])))  
                         break;  
   
         len = *end - pos;  
         for (i = 0; i < TEXICMD__MAX; i++) {  
                 if (len != texitoks[i].len)  
                         continue;  
                 if (0 == strncmp(texitoks[i].tok, &buf[pos], len))  
                         return(i);  
         }  
   
         texiwarn(p, "bad command: @%.*s", (int)len, &buf[pos]);  
         return(TEXICMD__MAX);  
 }  
   
 /*  
  * 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           end;  
         enum texicmd     cmd;  
   
         while (*pos < sz && ismspace(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 ('}'):  
                         advance(p, buf, pos);  
                         return(0);  
                 case ('{'):  
                         if (0 == p->ign)  
                                 texiwarn(p, "unexpected \"{\"");  
                         advance(p, buf, pos);  
                         continue;  
                 case ('@'):  
                         break;  
                 default:  
                         texiword(p, buf, sz, pos, ',');  
                         continue;  
                 }  
   
                 cmd = texicmd(p, buf, *pos, sz, &end);  
                 advanceto(p, buf, pos, end);  
                 if (TEXICMD__MAX == cmd)  
                         continue;  
                 if (NULL != texitoks[cmd].fp)  
                         (*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  
 parsebracket(struct texi *p, const char *buf, size_t sz, size_t *pos)  
 {  
         size_t           end;  
         enum texicmd     cmd;  
   
         while (*pos < sz && ismspace(buf[*pos]))  
                 advance(p, buf, pos);  
   
         if (*pos == sz || '{' != buf[*pos])  
                 return;                  return;
         advance(p, buf, pos);          } else if (NULL == (cp = malloc(end - start + 1)))
                   texiabort(p, NULL);
   
         while ((*pos = advancenext(p, buf, sz, pos)) < sz) {          memcpy(cp, &buf[start], end - start);
                 switch (buf[*pos]) {          cp[end - start] = '\0';
                 case ('}'):  
                         advance(p, buf, pos);  
                         return;  
                 case ('{'):  
                         if (0 == p->ign)  
                                 texiwarn(p, "unexpected \"{\"");  
                         advance(p, buf, pos);  
                         continue;  
                 case ('@'):  
                         break;  
                 default:  
                         texiword(p, buf, sz, pos, '\0');  
                         continue;  
                 }  
   
                 cmd = texicmd(p, buf, *pos, sz, &end);          p->indexs = realloc(p->indexs,
                 advanceto(p, buf, pos, end);                  sizeof(char *) * (p->indexsz + 1));
                 if (TEXICMD__MAX == cmd)  
                         continue;  
                 if (NULL != texitoks[cmd].fp)  
                         (*texitoks[cmd].fp)(p, cmd, buf, sz, pos);  
         }  
 }  
   
 /*          if (NULL == p->indexs)
  * This should be invoked when we're on a macro line and want to process                  texiabort(p, NULL);
  * to the end of the current input line, doing all of our macros along          p->indexs[p->indexsz++] = cp;
  * the way.  
  */  
 static void  
 parseeoln(struct texi *p, const char *buf, size_t sz, size_t *pos)  
 {  
         size_t           end;  
         enum texicmd     cmd;  
   
         while (*pos < sz && '\n' != buf[*pos]) {  
                 while (*pos < sz && isws(buf[*pos])) {  
                         p->seenws = 1;  
                         if (p->literal)  
                                 texiputchar(p, buf[*pos]);  
                         advance(p, buf, pos);  
                 }  
                 switch (buf[*pos]) {  
                 case ('}'):  
                         if (0 == p->ign)  
                                 texiwarn(p, "unexpected \"}\"");  
                         advance(p, buf, pos);  
                         continue;  
                 case ('{'):  
                         if (0 == p->ign)  
                                 texiwarn(p, "unexpected \"{\"");  
                         advance(p, buf, pos);  
                         continue;  
                 case ('@'):  
                         break;  
                 default:  
                         texiword(p, buf, sz, pos, '\0');  
                         continue;  
                 }  
   
                 cmd = texicmd(p, buf, *pos, sz, &end);  
                 advanceto(p, buf, pos, end);  
                 if (TEXICMD__MAX == cmd)  
                         continue;  
                 if (NULL != texitoks[cmd].fp)  
                         (*texitoks[cmd].fp)(p, cmd, buf, sz, pos);  
         }  
 }  }
   
 /*  
  * 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)  
 {  
         size_t           end;  
         enum texicmd     cmd;  
   
         if ((*pos = advancenext(p, buf, sz, pos)) >= sz)  
                 return;  
   
         switch (buf[*pos]) {  
         case ('}'):  
                 if (0 == p->ign)  
                         texiwarn(p, "unexpected \"}\"");  
                 advance(p, buf, pos);  
                 return;  
         case ('{'):  
                 if (0 == p->ign)  
                         texiwarn(p, "unexpected \"{\"");  
                 advance(p, buf, pos);  
                 return;  
         case ('@'):  
                 break;  
         default:  
                 texiword(p, buf, sz, pos, '\0');  
                 return;  
         }  
   
         cmd = texicmd(p, buf, *pos, sz, &end);  
         advanceto(p, buf, pos, end);  
         if (TEXICMD__MAX == cmd)  
                 return;  
         if (NULL != texitoks[cmd].fp)  
                 (*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  
 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,  
         size_t sz, size_t *pos, const char *endtoken)  
 {  
         size_t           end;  
         enum texicmd     cmd;  
         size_t           endtoksz;  
   
         endtoksz = strlen(endtoken);  
         assert(endtoksz > 0);  
   
         while ((*pos = advancenext(p, buf, sz, pos)) < sz) {  
                 switch (buf[*pos]) {  
                 case ('}'):  
                         if (0 == p->ign)  
                                 texiwarn(p, "unexpected \"}\"");  
                         advance(p, buf, pos);  
                         continue;  
                 case ('{'):  
                         if (0 == p->ign)  
                                 texiwarn(p, "unexpected \"{\"");  
                         advance(p, buf, pos);  
                         continue;  
                 case ('@'):  
                         break;  
                 default:  
                         texiword(p, buf, sz, pos, '\0');  
                         continue;  
                 }  
   
                 cmd = texicmd(p, buf, *pos, sz, &end);  
                 advanceto(p, buf, pos, end);  
                 if (TEXICMD_END == cmd) {  
                         while (*pos < sz && isws(buf[*pos]))  
                                 advance(p, buf, pos);  
                         /*  
                          * FIXME: check the full word, not just its  
                          * initial substring!  
                          */  
                         if (sz - *pos >= endtoksz && 0 == strncmp  
                                  (&buf[*pos], endtoken, endtoksz)) {  
                                 advanceeoln(p, buf, sz, pos, 0);  
                                 break;  
                         }  
                         if (0 == p->ign)  
                                 texiwarn(p, "unexpected \"end\"");  
                         advanceeoln(p, buf, sz, pos, 0);  
                         continue;  
                 } else if (TEXICMD__MAX != cmd)  
                         if (NULL != texitoks[cmd].fp)  
                                 (*texitoks[cmd].fp)(p, cmd, buf, sz, pos);  
         }  
 }  
   
 /*  
  * Memory-map the file "fname" and begin parsing it.  
  * This can be called in a nested context.  
  */  
 static void  
 parsefile(struct texi *p, const char *fname, int parse)  
 {  
         struct texifile *f;  
         int              fd;  
         struct stat      st;  
         size_t           i;  
   
         assert(p->filepos < 64);  
         f = &p->files[p->filepos];  
         memset(f, 0, sizeof(struct texifile));  
   
         f->name = fname;  
         if (-1 == (fd = open(fname, O_RDONLY, 0))) {  
                 texiabort(p, fname);  
         } else if (-1 == fstat(fd, &st)) {  
                 close(fd);  
                 texiabort(p, fname);  
         }  
   
         f->mapsz = st.st_size;  
         f->map = mmap(NULL, f->mapsz,  
                 PROT_READ, MAP_SHARED, fd, 0);  
         close(fd);  
   
         if (MAP_FAILED == f->map)  
                 texiabort(p, fname);  
   
         p->filepos++;  
         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);  
 }  
   
 static void  
 dodefn(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)
 {  {
Line 1330  static void
Line 424  static void
 doignblock(struct texi *p, enum texicmd cmd,  doignblock(struct texi *p, enum texicmd cmd,
         const char *buf, size_t sz, size_t *pos)          const char *buf, size_t sz, size_t *pos)
 {  {
           char             end[32];
         p->ign++;          const char      *term;
         parseto(p, buf, sz, pos, texitoks[cmd].tok);          size_t           endsz, endpos;
         p->ign--;  
           /*
            * We want to completely ignore everything in these blocks, so
            * simply jump to the @end block.
            */
           endsz = snprintf(end, sizeof(end),
                   "\n@end %s\n", texitoks[cmd].tok);
           assert(endsz < sizeof(end));
   
           /*
            * Look up where our end token occurs.
            * Set our end position based on the relative offset of that
            * from our current position, or the EOF if we don't have a
            * proper ending point.
            */
           term = memmem(&buf[*pos], sz, end, endsz);
           endpos = NULL == term ? sz :
                   *pos + term - &buf[*pos];
           assert(endpos <= sz);
           while (*pos < endpos)
                   advance(p, buf, pos);
   
           /* Only do this if we're not already at the end. */
           if (endpos < sz)
                   advanceto(p, buf, pos, endpos + endsz);
 }  }
   
 static void  static void
Line 1387  doinline(struct texi *p, enum texicmd cmd,
Line 505  doinline(struct texi *p, enum texicmd cmd,
                 break;                  break;
         }          }
   
         if (NULL == macro || p->literal) {          if (NULL == macro || p->literal || TEXILIST_TABLE == p->list) {
                 parsebracket(p, buf, sz, pos);                  parsebracket(p, buf, sz, pos);
                 return;                  return;
         }          }
Line 1400  doinline(struct texi *p, enum texicmd cmd,
Line 518  doinline(struct texi *p, enum texicmd cmd,
 }  }
   
 static void  static void
   doverb(struct texi *p, enum texicmd cmd,
           const char *buf, size_t sz, size_t *pos)
   {
           const char      *end, *term;
           size_t           endsz, endpos;
   
           advanceeoln(p, buf, sz, pos, 1);
   
           /* We end at exactly this token. */
           end = "\n@end verbatim\n";
           endsz = strlen(end);
   
           /*
            * Look up where our end token occurs.
            * Set our end position based on the relative offset of that
            * from our current position.
            */
           term = memmem(&buf[*pos], sz, end, endsz);
           endpos = NULL == term ? sz :
                   *pos + term - &buf[*pos];
   
           teximacro(p, "Bd -literal -offset indent");
           assert(endpos <= sz);
           while (*pos < endpos) {
                   if (buf[*pos] == '\n')
                           p->outcol = 0;
                   else
                           p->outcol++;
                   if (*pos > 0 && '.' == buf[*pos])
                           if ('\n' == buf[*pos - 1])
                                   fputs("\\&", stdout);
                   putchar(buf[*pos]);
                   if ('\\' == buf[*pos])
                           putchar('e');
                   advance(p, buf, pos);
           }
           teximacro(p, "Ed");
           advanceto(p, buf, pos, endpos + endsz);
   }
   
   static void
 doverbinclude(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];
         int      rc;          int              rc;
         size_t   i;          size_t           i, end;
           const char      *v;
           enum texicmd     type;
   
         while (*pos < sz && ' ' == buf[*pos])          while (*pos < sz && ' ' == buf[*pos])
                 advance(p, buf, pos);                  advance(p, buf, pos);
   
         /* Read in the filename. */          for (i = 0; *pos < sz && '\n' != buf[*pos]; ) {
         for (i = 0; *pos < sz && '\n' != buf[*pos]; i++) {  
                 if (i == sizeof(fname) - 1)                  if (i == sizeof(fname) - 1)
                         break;                          break;
                 fname[i] = buf[*pos];                  if ('@' != buf[*pos]) {
                 advance(p, buf, pos);                          fname[i++] = buf[*pos];
                           advance(p, buf, pos);
                           continue;
                   }
                   type = texicmd(p, buf, *pos, sz, &end);
                   advanceto(p, buf, pos, end);
                   if (TEXICMD_VALUE != type)
                           texierr(p, "unknown verbatiminclude command");
                   v = valueblookup(p, buf, sz, pos);
                   if (NULL == v)
                           continue;
                   while ('\0' != *v) {
                           if (i == sizeof(fname) - 1)
                                   break;
                           fname[i++] = *v++;
                   }
                   if ('\0' != *v)
                           break;
         }          }
   
         if (i == 0)          if (i == 0)
Line 1443  static void
Line 620  static void
 doinclude(struct texi *p, enum texicmd cmd,  doinclude(struct texi *p, enum texicmd cmd,
         const char *buf, size_t sz, size_t *pos)          const char *buf, size_t sz, size_t *pos)
 {  {
         char     fname[PATH_MAX], path[PATH_MAX];          char             fname[PATH_MAX], path[PATH_MAX];
         size_t   i;          size_t           i, end;
         int      rc;          int              rc;
           const char      *v;
           enum texicmd     type;
   
         while (*pos < sz && ' ' == buf[*pos])          while (*pos < sz && ' ' == buf[*pos])
                 advance(p, buf, pos);                  advance(p, buf, pos);
   
         /* Read in the filename. */          /* Read in the filename. */
         for (i = 0; *pos < sz && '\n' != buf[*pos]; i++) {          for (i = 0; *pos < sz && '\n' != buf[*pos]; ) {
                 if (i == sizeof(fname) - 1)                  if (i == sizeof(fname) - 1)
                         break;                          break;
                 fname[i] = buf[*pos];                  if ('@' != buf[*pos]) {
                 advance(p, buf, pos);                          fname[i++] = buf[*pos];
                           advance(p, buf, pos);
                           continue;
                   }
                   type = texicmd(p, buf, *pos, sz, &end);
                   advanceto(p, buf, pos, end);
                   if (TEXICMD_VALUE != type)
                           texierr(p, "unknown include command");
                   v = valueblookup(p, buf, sz, pos);
                   if (NULL == v)
                           continue;
                   while ('\0' != *v) {
                           if (i == sizeof(fname) - 1)
                                   break;
                           fname[i++] = *v++;
                   }
                   if ('\0' != *v)
                           break;
         }          }
   
         if (i == 0)          if (i == 0)
Line 1550  dotitle(struct texi *p, enum texicmd cmd, 
Line 746  dotitle(struct texi *p, enum texicmd cmd, 
         start = end = *pos;          start = end = *pos;
         while (end < sz && '\n' != buf[end])          while (end < sz && '\n' != buf[end])
                 end++;                  end++;
           advanceeoln(p, buf, sz, pos, 1);
         free(p->subtitle);          free(p->subtitle);
         p->subtitle = malloc(end - start + 1);          p->subtitle = malloc(end - start + 1);
           if (NULL == p->subtitle)
                   texiabort(p, NULL);
         memcpy(p->subtitle, &buf[start], end - start);          memcpy(p->subtitle, &buf[start], end - start);
         p->subtitle[end - start] = '\0';          p->subtitle[end - start] = '\0';
 }  }
Line 1680  dosymbol(struct texi *p, enum texicmd cmd, 
Line 879  dosymbol(struct texi *p, enum texicmd cmd, 
         case (TEXICMD_LATEX):          case (TEXICMD_LATEX):
                 texiputchars(p, "LaTeX");                  texiputchars(p, "LaTeX");
                 break;                  break;
           case (TEXICMD_MINUS):
                   texiputchars(p, "\\-");
                   break;
           case (TEXICMD_PERIOD):
                   texiputchar(p, '.');
                   break;
         case (TEXICMD_QUESTIONMARK):          case (TEXICMD_QUESTIONMARK):
                 texiputchar(p, '?');                  texiputchar(p, '?');
                 break;                  break;
Line 1753  domath(struct texi *p, enum texicmd cmd, 
Line 958  domath(struct texi *p, enum texicmd cmd, 
 }  }
   
 static void  static void
   dovalue(struct texi *p, enum texicmd cmd,
           const char *buf, size_t sz, size_t *pos)
   {
           size_t           start, end;
           char            *key, *val;
           const char      *cp;
   
           if (TEXICMD_SET == cmd) {
                   while (*pos < sz && isws(buf[*pos]))
                           advance(p, buf, pos);
                   for (start = end = *pos; end < sz; end++)
                           if (ismspace(buf[end]))
                                   break;
                   /* We don't allow empty keys. */
                   if (start == end)
                           return;
                   advanceto(p, buf, pos, end);
   
                   key = malloc(end - start + 1);
                   if (NULL == key)
                           texiabort(p, NULL);
                   memcpy(key, &buf[start], end - start);
                   key[end - start] = '\0';
   
                   while (*pos < sz && isws(buf[*pos]))
                           advance(p, buf, pos);
                   for (start = end = *pos; end < sz; end++)
                           if ('\n' == buf[end])
                                   break;
                   /* We do allow empty values. */
                   advanceeoln(p, buf, sz, pos, 1);
   
                   val = malloc(end - start + 1);
                   if (NULL == val)
                           texiabort(p, NULL);
                   memcpy(val, &buf[start], end - start);
                   val[end - start] = '\0';
                   valueadd(p, key, val);
           } else if (TEXICMD_VALUE == cmd) {
                   if (p->seenws)
                           texiputchar(p, ' ');
                   p->seenws = 0;
                   if (NULL == (cp = valueblookup(p, buf, sz, pos)))
                           texiputchars(p, "{No value}");
                   else
                           texiputchars(p, cp);
           } else if (TEXICMD_IFCLEAR == cmd) {
                   if (NULL != valuellookup(p, buf, sz, pos))
                           doignblock(p, cmd, buf, sz, pos);
                   else
                           parseto(p, buf, sz, pos, texitoks[cmd].tok);
           } else if (TEXICMD_CLEAR == cmd)
                   valuelclear(p, buf, sz, pos);
   }
   
   static void
 dolink(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)
 {  {
Line 1801  doignargn(struct texi *p, enum texicmd cmd, 
Line 1062  doignargn(struct texi *p, enum texicmd cmd, 
         p->ign--;          p->ign--;
 }  }
   
   /*
    * Sections can be made subsections and so on by way of the
    * @raiseections and @lowersections commands.
    * Perform this check here and return the actual section number adjusted
    * to the raise level.
    */
   static int
   sectioner(struct texi *p, int sec)
   {
   
           if ((sec -= p->secoffs) < 0) {
                   texiwarn(p, "section below minimum, clamping");
                   return(0);
           } else if (sec >= SECTSZ) {
                   texiwarn(p, "section above maximum, clamping");
                   return(SECTSZ - 1);
           }
           return(sec);
   }
   
 static void  static void
   dosubsubsection(struct texi *p, enum texicmd cmd,
                   const char *buf, size_t sz, size_t *pos)
   {
           int      sec;
   
           sec = sectioner(p, 3);
   
           /* We don't have a subsubsubsection, so make one up. */
           texivspace(p);
           teximacroopen(p, sects[sec]);
           parseeoln(p, buf, sz, pos);
           teximacroclose(p);
           texivspace(p);
   }
   
   static void
 dosubsection(struct texi *p, enum texicmd cmd,  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)
 {  {
           int      sec;
   
           sec = sectioner(p, 2);
   
         if (p->outmacro)          if (p->outmacro)
                 texierr(p, "\"Em\" in open line scope!?");                  texierr(p, "\"%s\" in open line scope!?", sects[sec]);
         else if (p->literal)          else if (p->literal)
                 texierr(p, "\"Em\" in a literal scope!?");                  texierr(p, "\"%s\" in a literal scope!?", sects[sec]);
   
         /* We don't have a subsubsection, so make one up. */          /* We don't have a subsubsection, so make one up. */
         texivspace(p);          texivspace(p);
         teximacroopen(p, "Em");          teximacroopen(p, sects[sec]);
         parseeoln(p, buf, sz, pos);          parseeoln(p, buf, sz, pos);
         teximacroclose(p);          teximacroclose(p);
         texivspace(p);          texivspace(p);
 }  }
   
 static void  static void
   dosecoffs(struct texi *p, enum texicmd cmd,
           const char *buf, size_t sz, size_t *pos)
   {
   
           if (TEXICMD_RAISESECTIONS == cmd)
                   p->secoffs++;
           else
                   p->secoffs--;
   }
   
   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;          int              sec;
   
         switch (cmd) {          switch (cmd) {
         case (TEXICMD_APPENDIX):          case (TEXICMD_APPENDIX):
         case (TEXICMD_CHAPTER):          case (TEXICMD_CHAPTER):
         case (TEXICMD_TOP):          case (TEXICMD_TOP):
         case (TEXICMD_UNNUMBERED):          case (TEXICMD_UNNUMBERED):
                 blk = "Sh";                  sec = sectioner(p, 0);
                 break;                  break;
         case (TEXICMD_APPENDIXSEC):          case (TEXICMD_APPENDIXSEC):
         case (TEXICMD_HEADING):          case (TEXICMD_HEADING):
         case (TEXICMD_SECTION):          case (TEXICMD_SECTION):
         case (TEXICMD_UNNUMBEREDSEC):          case (TEXICMD_UNNUMBEREDSEC):
                 blk = "Ss";                  sec = sectioner(p, 1);
                 break;                  break;
         default:          default:
                 abort();                  abort();
         }          }
   
         if (p->outmacro)          if (p->outmacro)
                 texierr(p, "%s in open line scope!?", blk);                  texierr(p, "\"%s\" in open line scope!?", sects[sec]);
         else if (p->literal)          else if (p->literal)
                 texierr(p, "%s in a literal scope!?", blk);                  texierr(p, "\"%s\" in a literal scope!?", sects[sec]);
   
         teximacroopen(p, blk);          teximacroopen(p, sects[sec]);
         parseeoln(p, buf, sz, pos);          parseeoln(p, buf, sz, pos);
         teximacroclose(p);          teximacroclose(p);
         p->seenvs = 1;          p->seenvs = 1;
Line 1871  dotop(struct texi *p, enum texicmd cmd, 
Line 1182  dotop(struct texi *p, enum texicmd cmd, 
         time_t           t;          time_t           t;
         char             date[32];          char             date[32];
   
           if (--p->ign)
                   texierr(p, "@top command while ignoring (%d)", p->ign);
   
         /*          /*
          * Here we print our standard mdoc(7) prologue.           * Here we print our standard mdoc(7) prologue.
          * We use the title set with @settitle for the `Nd' description           * We use the title set with @settitle for the `Nd' description
Line 1881  dotop(struct texi *p, enum texicmd cmd, 
Line 1195  dotop(struct texi *p, enum texicmd cmd, 
         t = time(NULL);          t = time(NULL);
         strftime(date, sizeof(date), "%F", localtime(&t));          strftime(date, sizeof(date), "%F", localtime(&t));
   
         p->ign--;  
         teximacroopen(p, "Dd");          teximacroopen(p, "Dd");
         texiputchars(p, date);          texiputchars(p, date);
         teximacroclose(p);          teximacroclose(p);
Line 1979  domultitable(struct texi *p, enum texicmd cmd, 
Line 1292  domultitable(struct texi *p, enum texicmd cmd, 
                 type = texicmd(p, buf, *pos, sz, &end);                  type = texicmd(p, buf, *pos, sz, &end);
                 advanceto(p, buf, pos, end);                  advanceto(p, buf, pos, end);
                 if (TEXICMD_COLUMNFRACTIONS != type)                  if (TEXICMD_COLUMNFRACTIONS != type)
                         texierr(p, "unknown multitable type");                          texierr(p, "unknown multitable command");
                 while (*pos < sz && '\n' != buf[*pos]) {                  while (*pos < sz && '\n' != buf[*pos]) {
                         while (*pos < sz && isws(buf[*pos]))                          while (*pos < sz && isws(buf[*pos]))
                                 advance(p, buf, pos);                                  advance(p, buf, pos);
Line 2089  doignline(struct texi *p, enum texicmd cmd, 
Line 1402  doignline(struct texi *p, enum texicmd cmd, 
  * This does NOT sanitise the directories!   * This does NOT sanitise the directories!
  */   */
 static char **  static char **
 parsedirs(const char *base, const char *cp, size_t *sz)  parsedirs(struct texi *p, const char *base, const char *cp, size_t *sz)
 {  {
         char             *tok, *str, *tofree;          char             *tok, *str, *tofree;
         const char       *cpp;          const char       *cpp;
Line 2101  parsedirs(const char *base, const char *cp, size_t *sz
Line 1414  parsedirs(const char *base, const char *cp, size_t *sz
                 for ( ; NULL != (cpp = strchr(cpp, ':')); (*sz)++)                  for ( ; NULL != (cpp = strchr(cpp, ':')); (*sz)++)
                         cpp++;                          cpp++;
   
         dirs = calloc(*sz, sizeof(char *));          if (NULL == (dirs = calloc(*sz, sizeof(char *))))
         if (NULL == dirs) {                  texiabort(p, NULL);
                 perror(NULL);          else if (NULL == (dirs[0] = strdup(base)))
                 exit(EXIT_FAILURE);                  texiabort(p, NULL);
         } else if (NULL == (dirs[0] = strdup(base))) {  
                 perror(NULL);  
                 exit(EXIT_FAILURE);  
         }  
   
         if (NULL == cp)          if (NULL == cp)
                 return(dirs);                  return(dirs);
   
         if (NULL == (tofree = tok = str = strdup(cp))) {          if (NULL == (tofree = tok = str = strdup(cp)))
                 perror(NULL);                  texiabort(p, NULL);
                 exit(EXIT_FAILURE);  
         }  
   
         for (i = 1; NULL != (tok = strsep(&str, ":")); i++)          for (i = 1; NULL != (tok = strsep(&str, ":")); i++)
                 if (NULL == (dirs[i] = strdup(tok))) {                  if (NULL == (dirs[i] = strdup(tok)))
                         perror(NULL);                          texiabort(p, NULL);
                         exit(EXIT_FAILURE);  
                 }  
   
         free(tofree);          free(tofree);
         return(dirs);          return(dirs);
Line 2158  main(int argc, char *argv[])
Line 1463  main(int argc, char *argv[])
         if (0 == (argc -= optind))          if (0 == (argc -= optind))
                 goto usage;                  goto usage;
   
         if (NULL == (path = strdup(argv[0]))) {          if (NULL == (path = strdup(argv[0])))
                 perror(NULL);                  texiabort(&texi, NULL);
                 exit(EXIT_FAILURE);          else if (NULL == (dir = dirname(path)))
         } else if (NULL == (dir = dirname(path))) {                  texiabort(&texi, NULL);
                 perror(argv[0]);  
                 free(path);  
                 exit(EXIT_FAILURE);  
         }  
         free(path);          free(path);
   
         if (NULL != (cp = strrchr(argv[0], '/')))          if (NULL != (cp = strrchr(argv[0], '/')))
Line 2173  main(int argc, char *argv[])
Line 1475  main(int argc, char *argv[])
         else          else
                 texi.title = strdup(argv[0]);                  texi.title = strdup(argv[0]);
   
         if (NULL == texi.title) {          if (NULL == texi.title)
                 perror(NULL);                  texiabort(&texi, NULL);
                 exit(EXIT_FAILURE);          else if (NULL != (path = strchr(texi.title, '.')))
         } else if (NULL != (path = strchr(texi.title, '.')))  
                 *path = '\0';                  *path = '\0';
   
         texi.ign = 1;          texi.ign = 1;
         texi.dirs = parsedirs(dir, Idir, &texi.dirsz);          texi.dirs = parsedirs(&texi, dir, Idir, &texi.dirsz);
         parsefile(&texi, argv[0], 1);          parsefile(&texi, argv[0], 1);
         /* We shouldn't get here. */          /* We shouldn't get here. */
         texiexit(&texi);          texiexit(&texi);
Legend:
Removed from v.1.22  
changed lines
  Added in v.1.27
CVSweb