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

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

version 1.2, 2015/02/17 10:27:18 version 1.3, 2015/02/17 17:02:03
Line 39  enum texicmd {
Line 39  enum texicmd {
         TEXICMD_ANCHOR,          TEXICMD_ANCHOR,
         TEXICMD_APPENDIX,          TEXICMD_APPENDIX,
         TEXICMD_APPENDIXSEC,          TEXICMD_APPENDIXSEC,
           TEXICMD_ASTERISK,
         TEXICMD_AT,          TEXICMD_AT,
           TEXICMD_AUTHOR,
           TEXICMD_BANG,
         TEXICMD_BYE,          TEXICMD_BYE,
         TEXICMD_CHAPTER,          TEXICMD_CHAPTER,
         TEXICMD_CINDEX,          TEXICMD_CINDEX,
           TEXICMD_CITE,
         TEXICMD_CODE,          TEXICMD_CODE,
           TEXICMD_COLON,
         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_DEFTYPEFN,
           TEXICMD_DEFTYPEFNX,
           TEXICMD_DEFTYPEFUN,
           TEXICMD_DEFTYPEFUNX,
           TEXICMD_DEFTYPEVAR,
           TEXICMD_DEFTYPEVR,
         TEXICMD_DETAILMENU,          TEXICMD_DETAILMENU,
           TEXICMD_DFN,
         TEXICMD_DIRCATEGORY,          TEXICMD_DIRCATEGORY,
         TEXICMD_DIRENTRY,          TEXICMD_DIRENTRY,
           TEXICMD_DISPLAY,
         TEXICMD_DOTS,          TEXICMD_DOTS,
         TEXICMD_EMAIL,          TEXICMD_EMAIL,
         TEXICMD_EMPH,          TEXICMD_EMPH,
         TEXICMD_END,          TEXICMD_END,
         TEXICMD_ENUMERATE,          TEXICMD_ENUMERATE,
           TEXICMD_ENV,
         TEXICMD_EXAMPLE,          TEXICMD_EXAMPLE,
         TEXICMD_FILE,          TEXICMD_FILE,
           TEXICMD_GROUP,
         TEXICMD_HEADING,          TEXICMD_HEADING,
           TEXICMD_HEADINGS,
           TEXICMD_HYPHEN,
         TEXICMD_I,          TEXICMD_I,
           TEXICMD_IFCLEAR,
         TEXICMD_IFHTML,          TEXICMD_IFHTML,
           TEXICMD_IFINFO,
         TEXICMD_IFNOTTEX,          TEXICMD_IFNOTTEX,
         TEXICMD_IFTEX,          TEXICMD_IFTEX,
           TEXICMD_IFSET,
         TEXICMD_IMAGE,          TEXICMD_IMAGE,
         TEXICMD_INCLUDE,          TEXICMD_INCLUDE,
         TEXICMD_ITEM,          TEXICMD_ITEM,
         TEXICMD_ITEMIZE,          TEXICMD_ITEMIZE,
         TEXICMD_KBD,          TEXICMD_KBD,
         TEXICMD_LATEX,          TEXICMD_LATEX,
           TEXICMD_MATH,
         TEXICMD_MENU,          TEXICMD_MENU,
           TEXICMD_NEWLINE,
         TEXICMD_NODE,          TEXICMD_NODE,
           TEXICMD_NOINDENT,
           TEXICMD_QUESTIONMARK,
         TEXICMD_QUOTATION,          TEXICMD_QUOTATION,
           TEXICMD_PAGE,
         TEXICMD_PARINDENT,          TEXICMD_PARINDENT,
         TEXICMD_PRINTINDEX,          TEXICMD_PRINTINDEX,
         TEXICMD_REF,          TEXICMD_REF,
         TEXICMD_SAMP,          TEXICMD_SAMP,
         TEXICMD_SECTION,          TEXICMD_SECTION,
           TEXICMD_SET,
         TEXICMD_SETCHAPNEWPAGE,          TEXICMD_SETCHAPNEWPAGE,
         TEXICMD_SETFILENAME,          TEXICMD_SETFILENAME,
         TEXICMD_SETTITLE,          TEXICMD_SETTITLE,
           TEXICMD_SP,
           TEXICMD_SPACE,
           TEXICMD_SMALLEXAMPLE,
           TEXICMD_SQUIGGLE_LEFT,
           TEXICMD_SQUIGGLE_RIGHT,
         TEXICMD_SUBSECTION,          TEXICMD_SUBSECTION,
           TEXICMD_SUBTITLE,
           TEXICMD_TAB,
         TEXICMD_TABLE,          TEXICMD_TABLE,
         TEXICMD_TEX,          TEXICMD_TEX,
         TEXICMD_TEXSYM,          TEXICMD_TEXSYM,
           TEXICMD_TITLE,
         TEXICMD_TITLEFONT,          TEXICMD_TITLEFONT,
         TEXICMD_TITLEPAGE,          TEXICMD_TITLEPAGE,
         TEXICMD_TOP,          TEXICMD_TOP,
         TEXICMD_UNNUMBERED,          TEXICMD_UNNUMBERED,
         TEXICMD_UNNUMBEREDSEC,          TEXICMD_UNNUMBEREDSEC,
           TEXICMD_UREF,
         TEXICMD_URL,          TEXICMD_URL,
         TEXICMD_VAR,          TEXICMD_VAR,
           TEXICMD_W,
         TEXICMD__MAX          TEXICMD__MAX
 };  };
   
Line 125  struct texitok {
Line 161  struct texitok {
         size_t           len; /* strlen(tok) */          size_t           len; /* strlen(tok) */
 };  };
   
   enum    texilist {
           TEXILIST_NONE = 0,
           TEXILIST_ITEM,
           TEXILIST_NOITEM,
   };
   
 /*  /*
  * The main parse structure.   * The main parse structure.
  * This keeps any necessary information handy.   * This keeps any necessary information handy.
Line 132  struct texitok {
Line 174  struct texitok {
 struct  texi {  struct  texi {
         struct texifile  files[64];          struct texifile  files[64];
         size_t           filepos;          size_t           filepos;
         unsigned         flags;  
 #define TEXI_IGN         0x01 /* don't print anything */  
 #define TEXI_HEADER     (TEXI_IGN | 0x02) /* haven't seen @top yet */  
 #define TEXI_LITERAL     0x04 /* output all whitespace */  
         size_t           outcol; /* column of output */          size_t           outcol; /* column of output */
         int              outmacro; /* whether output is in line macro */          int              outmacro; /* whether output is in line macro */
         int              seenws; /* whitespace has been ignored */          int              seenws; /* whitespace has been ignored */
           int              ign; /* don't print anything */
           int              literal;
         char            *dir; /* texi directory */          char            *dir; /* texi directory */
           enum texilist    list;
 };  };
   
 /* FIXME: don't use this crap. */  /* FIXME: don't use this crap. */
Line 151  struct texi {
Line 192  struct texi {
         (' ' == (_x) || '\t' == (_x))          (' ' == (_x) || '\t' == (_x))
   
 static  void doarg1(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void doarg1(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 docommand(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 doemph(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 dofile(struct texi *, enum texicmd, const char *, size_t, size_t *);
 static  void doifnottex(struct texi *, enum texicmd, const char *, size_t, size_t *);  
 static  void doignblock(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void 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 *);
Line 167  static void doitalic(struct texi *, enum texicmd, cons
Line 213  static void doitalic(struct texi *, enum texicmd, cons
 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 doliteral(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 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 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 dosh(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 *);
   
Line 179  static const struct texitok texitoks[TEXICMD__MAX] = {
Line 226  static const struct texitok texitoks[TEXICMD__MAX] = {
         { doarg1, "acronym", 7 }, /* TEXICMD_ACRONYM */          { doarg1, "acronym", 7 }, /* TEXICMD_ACRONYM */
         { doignline, "afourpaper", 10 }, /* TEXICMD_A4PAPER */          { doignline, "afourpaper", 10 }, /* TEXICMD_A4PAPER */
         { doignbracket, "anchor", 6 }, /* TEXICMD_ANCHOR */          { doignbracket, "anchor", 6 }, /* TEXICMD_ANCHOR */
         { dosh, "appendix", 8 }, /* TEXICMD_APPENDIX */          { dochapter, "appendix", 8 }, /* TEXICMD_APPENDIX */
         { dosh, "appendixsec", 11 }, /* TEXICMD_APPENDIXSEC */          { dochapter, "appendixsec", 11 }, /* TEXICMD_APPENDIXSEC */
           { dosymbol, "*", 1 }, /* TEXICMD_ASTERISK */
         { dosymbol, "@", 1 }, /* TEXICMD_AT */          { dosymbol, "@", 1 }, /* TEXICMD_AT */
           { doignline, "author", 6 }, /* TEXICMD_AUTHOR */
           { dosymbol, "!", 1 }, /* TEXICMD_BANG */
         { dobye, "bye", 3 }, /* TEXICMD_BYE */          { dobye, "bye", 3 }, /* TEXICMD_BYE */
         { dosh, "chapter", 7 }, /* TEXICMD_CHAPTER */          { dochapter, "chapter", 7 }, /* TEXICMD_CHAPTER */
         { doignline, "cindex", 6 }, /* TEXICMD_CINDEX */          { doignline, "cindex", 6 }, /* TEXICMD_CINDEX */
         { doliteral, "code", 4 }, /* TEXICMD_CODE */          { doliteral, "code", 4 }, /* TEXICMD_CODE */
           { doitalic, "cite", 4 }, /* TEXICMD_CITE */
           { dosymbol, ":", 1 }, /* TEXICMD_COLON */
         { docommand, "command", 7 }, /* TEXICMD_COMMAND */          { docommand, "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 */
           { dodeftypefun, "deftypefnx", 10 }, /* TEXICMD_DEFTYPEFNX */
           { dodeftypefun, "deftypefun", 10 }, /* TEXICMD_DEFTYPEFUN */
           { dodeftypefun, "deftypefunx", 11 }, /* TEXICMD_DEFTYPEFUNX */
           { dodeftypevar, "deftypevar", 10 }, /* TEXICMD_DEFTYPEVAR */
           { dodeftypevar, "deftypevr", 9 }, /* TEXICMD_DEFTYPEVR */
         { doignblock, "detailmenu", 10 }, /* TEXICMD_DETAILMENU */          { doignblock, "detailmenu", 10 }, /* TEXICMD_DETAILMENU */
           { doitalic, "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 */
         { dosymbol, "dots", 4 }, /* TEXICMD_DOTS */          { dosymbol, "dots", 4 }, /* TEXICMD_DOTS */
         { doarg1, "email", 5 }, /* TEXICMD_EMAIL */          { doarg1, "email", 5 }, /* TEXICMD_EMAIL */
         { doemph, "emph", 4 }, /* TEXICMD_EMPH */          { doemph, "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 */
         { doexample, "example", 7 }, /* TEXICMD_EXAMPLE */          { doexample, "example", 7 }, /* TEXICMD_EXAMPLE */
         { dofile, "file", 4 }, /* TEXICMD_FILE */          { dofile, "file", 4 }, /* TEXICMD_FILE */
           { doblock, "group", 5 }, /* TEXICMD_GROUP */
         { dosection, "heading", 7 }, /* TEXICMD_HEADING */          { dosection, "heading", 7 }, /* TEXICMD_HEADING */
           { doignline, "headings", 8 }, /* TEXICMD_HEADINGS */
           { dosymbol, "-", 1 }, /* TEXICMD_HYPHEN */
         { doitalic, "i", 1 }, /* TEXICMD_I */          { doitalic, "i", 1 }, /* TEXICMD_I */
           { doignblock, "ifclear", 7 }, /* TEXICMD_IFCLEAR */
         { doignblock, "ifhtml", 6 }, /* TEXICMD_IFHTML */          { doignblock, "ifhtml", 6 }, /* TEXICMD_IFHTML */
         { doifnottex, "ifnottex", 8 }, /* TEXICMD_IFNOTTEX */          { doignblock, "ifinfo", 6 }, /* TEXICMD_IFINFO */
           { doblock, "ifnottex", 8 }, /* TEXICMD_IFNOTTEX */
         { doignblock, "iftex", 5 }, /* TEXICMD_IFTEX */          { doignblock, "iftex", 5 }, /* TEXICMD_IFTEX */
           { doignblock, "ifset", 5 }, /* TEXICMD_IFSET */
         { doignbracket, "image", 5 }, /* TEXICMD_IMAGE */          { doignbracket, "image", 5 }, /* TEXICMD_IMAGE */
         { doinclude, "include", 7 }, /* TEXICMD_INCLUDE */          { doinclude, "include", 7 }, /* TEXICMD_INCLUDE */
         { 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 */          { doliteral, "kbd", 3 }, /* TEXICMD_KBD */
         { dosymbol, "LaTeX", 5 }, /* TEXICMD_LATEX */          { dosymbol, "LaTeX", 5 }, /* TEXICMD_LATEX */
           { domath, "math", 4 }, /* TEXICMD_MATH */
         { doignblock, "menu", 4 }, /* TEXICMD_MENU */          { doignblock, "menu", 4 }, /* TEXICMD_MENU */
           { dosymbol, "\n", 1 }, /* TEXICMD_NEWLINE */
         { doignline, "node", 4 }, /* TEXICMD_NODE */          { doignline, "node", 4 }, /* TEXICMD_NODE */
           { doignline, "noindent", 8 }, /* TEXICMD_NOINDENT */
           { dosymbol, "?", 1 }, /* TEXICMD_QUESTIONMARK */
         { doquotation, "quotation", 9 }, /* TEXICMD_QUOTATION */          { doquotation, "quotation", 9 }, /* TEXICMD_QUOTATION */
         { doignline, "printindex", 10 }, /* TEXICMD_PRINTINDEX */          { doignline, "page", 4 }, /* TEXICMD_PAGE */
         { doignline, "paragraphindent", 14 }, /* TEXICMD_PARINDENT */          { doignline, "paragraphindent", 14 }, /* TEXICMD_PARINDENT */
           { doignline, "printindex", 10 }, /* TEXICMD_PRINTINDEX */
         { dobracket, "ref", 3 }, /* TEXICMD_REF */          { dobracket, "ref", 3 }, /* TEXICMD_REF */
         { doliteral, "samp", 4 }, /* TEXICMD_SAMP */          { doliteral, "samp", 4 }, /* TEXICMD_SAMP */
         { dosection, "section", 7 }, /* TEXICMD_SECTION */          { dosection, "section", 7 }, /* TEXICMD_SECTION */
           { 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 */
           { dosp, "sp", 2 }, /* TEXICMD_SP */
           { dosymbol, " ", 1 }, /* TEXICMD_SPACE */
           { doexample, "smallexample", 12 }, /* TEXICMD_SMALLEXAMPLE */
         { doignline, "settitle", 8 }, /* TEXICMD_SETTITLE */          { doignline, "settitle", 8 }, /* TEXICMD_SETTITLE */
           { dosymbol, "{", 1 }, /* TEXICMD_SQUIGGLE_LEFT */
           { dosymbol, "}", 1 }, /* TEXICMD_SQUIGGLE_RIGHT */
         { dosubsection, "subsection", 10 }, /* TEXICMD_SUBSECTION */          { dosubsection, "subsection", 10 }, /* TEXICMD_SUBSECTION */
           { doignline, "subtitle", 8 }, /* TEXICMD_SUBTITLE */
           { dosymbol, "\t", 1 }, /* TEXICMD_TAB */
         { 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 */
           { doignline, "title", 5 }, /* TEXICMD_TITLE */
         { dobracket, "titlefont", 9 }, /* TEXICMD_TITLEFONT */          { dobracket, "titlefont", 9 }, /* TEXICMD_TITLEFONT */
         { doignblock, "titlepage", 9 }, /* TEXICMD_TITLEPAGE */          { doignblock, "titlepage", 9 }, /* TEXICMD_TITLEPAGE */
         { dotop, "top", 3 }, /* TEXICMD_TOP */          { dotop, "top", 3 }, /* TEXICMD_TOP */
         { dosh, "unnumbered", 10 }, /* TEXICMD_UNNUMBERED */          { dochapter, "unnumbered", 10 }, /* TEXICMD_UNNUMBERED */
         { dosection, "unnumberedsec", 13 }, /* TEXICMD_UNNUMBEREDSEC */          { dosection, "unnumberedsec", 13 }, /* TEXICMD_UNNUMBEREDSEC */
           { doarg1, "uref", 4 }, /* TEXICMD_UREF */
         { doarg1, "url", 3 }, /* TEXICMD_URL */          { doarg1, "url", 3 }, /* TEXICMD_URL */
         { doliteral, "var", 3 }, /* TEXICMD_VAR */          { doliteral, "var", 3 }, /* TEXICMD_VAR */
           { dobracket, "w", 1 }, /* TEXICMD_W */
 };  };
   
 /*  /*
Line 261  texiexit(struct texi *p)
Line 344  texiexit(struct texi *p)
         while (p->filepos > 0)          while (p->filepos > 0)
                 texifilepop(p);                  texifilepop(p);
         free(p->dir);          free(p->dir);
           if (p->outcol)
                   putchar('\n');
 }  }
   
 /*  /*
Line 321  static void
Line 406  static void
 texiputchar(struct texi *p, char c)  texiputchar(struct texi *p, char c)
 {  {
   
         if (TEXI_IGN & p->flags)          if (p->ign)
                 return;                  return;
   
         putchar(c);          putchar(c);
         if ('\n' == c) {          if ('\n' == c) {
                 p->outcol = 0;                  p->outcol = 0;
                 p->outmacro = 0;  
                 p->seenws = 0;                  p->seenws = 0;
         } else          } else
                 p->outcol++;                  p->outcol++;
Line 349  texiputchars(struct texi *p, const char *s)
Line 432  texiputchars(struct texi *p, const char *s)
  * This should ONLY be used for mdoc(7) commands!   * This should ONLY be used for mdoc(7) commands!
  */   */
 static void  static void
 texifputs(struct texi *p, const char *s)  teximacroclose(struct texi *p)
 {  {
   
           p->outmacro--;
           if (p->ign)
                   return;
           texiputchar(p, '\n');
   }
   
   /*
    * Put an mdoc(7) command without the trailing newline.
    * This should ONLY be used for mdoc(7) commands!
    */
   static void
   teximacroopen(struct texi *p, const char *s)
   {
         int      rc;          int      rc;
   
         if (TEXI_IGN & p->flags)          p->outmacro++;
           if (p->ign)
                 return;                  return;
         if (p->outcol)          if (p->outcol)
                 texiputchar(p, '\n');                  texiputchar(p, '\n');
Line 369  static void
Line 467  static void
 teximacro(struct texi *p, const char *s)  teximacro(struct texi *p, const char *s)
 {  {
   
         if (TEXI_IGN & p->flags)          if (p->ign)
                 return;                  return;
         if (p->outcol)          if (p->outcol)
                 texiputchar(p, '\n');                  texiputchar(p, '\n');
Line 403  static size_t
Line 501  static size_t
 advancenext(struct texi *p, const char *buf, size_t sz, size_t *pos)  advancenext(struct texi *p, const char *buf, size_t sz, size_t *pos)
 {  {
   
         if (TEXI_LITERAL & p->flags) {          if (p->literal) {
                 while (*pos < sz && isspace(buf[*pos])) {                  while (*pos < sz && isspace(buf[*pos])) {
                         texiputchar(p, buf[*pos]);                          texiputchar(p, buf[*pos]);
                         advance(p, buf, pos);                          advance(p, buf, pos);
Line 429  advancenext(struct texi *p, const char *buf, size_t sz
Line 527  advancenext(struct texi *p, const char *buf, size_t sz
  * Advance to the EOLN in the input stream.   * Advance to the EOLN in the input stream.
  */   */
 static size_t  static size_t
 advanceeoln(struct texi *p, const char *buf, size_t sz, size_t *pos)  advanceeoln(struct texi *p, const char *buf,
           size_t sz, size_t *pos, int consumenl)
 {  {
   
         while (*pos < sz && '\n' != buf[*pos])          while (*pos < sz && '\n' != buf[*pos])
                 advance(p, buf, pos);                  advance(p, buf, pos);
           if (*pos < sz && consumenl)
                   advance(p, buf, pos);
         return(*pos);          return(*pos);
 }  }
   
Line 463  texiword(struct texi *p, const char *buf, size_t sz, s
Line 564  texiword(struct texi *p, const char *buf, size_t sz, s
          * XXX: if we're in literal mode, then we shouldn't do any           * XXX: if we're in literal mode, then we shouldn't do any
          * reflowing of text here.           * reflowing of text here.
          */           */
         if (p->outcol > 72 && ! (TEXI_LITERAL & p->flags))          if (0 == p->outmacro && p->outcol > 72 && 0 == p->literal)
                 texiputchar(p, '\n');                  texiputchar(p, '\n');
   
         if (p->seenws && p->outcol && ! (TEXI_LITERAL & p->flags))          if (p->seenws && p->outcol && 0 == p->literal)
                 texiputchar(p, ' ');                  texiputchar(p, ' ');
   
         p->seenws = 0;          p->seenws = 0;
Line 501  texicmd(struct texi *p, const char *buf, 
Line 602  texicmd(struct texi *p, const char *buf, 
         size_t   i, len;          size_t   i, len;
   
         assert('@' == buf[pos]);          assert('@' == buf[pos]);
         for (*end = ++pos; *end < sz && ! isspace(buf[*end]); (*end)++)  
                 if ((*end > pos && '@' == buf[*end]) || '{' == buf[*end])          if (++pos >= sz)
                   return(TEXICMD__MAX);
   
           /* Alphabetic commands are special. */
           if ( ! isalpha(buf[pos])) {
                   *end = pos + 1;
                   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 && ! isspace(buf[*end]); (*end)++)
                   if ((*end > pos && ('@' == buf[*end] ||
                             '{' == buf[*end] || '}' == buf[*end])))
                         break;                          break;
   
         len = *end - pos;          len = *end - pos;
Line 513  texicmd(struct texi *p, const char *buf, 
Line 632  texicmd(struct texi *p, const char *buf, 
                         return(i);                          return(i);
         }          }
   
         texiwarn(p, "bad command: %.*s", (int)len, &buf[pos]);          texiwarn(p, "bad command: @%.*s", (int)len, &buf[pos]);
         return(TEXICMD__MAX);          return(TEXICMD__MAX);
 }  }
   
Line 527  parseeof(struct texi *p, const char *buf, size_t sz)
Line 646  parseeof(struct texi *p, const char *buf, size_t sz)
         while ((pos = advancenext(p, buf, sz, &pos)) < sz) {          while ((pos = advancenext(p, buf, sz, &pos)) < sz) {
                 switch (buf[pos]) {                  switch (buf[pos]) {
                 case ('}'):                  case ('}'):
                         texiwarn(p, "unexpected \"}\"");                          if (0 == p->ign)
                                   texiwarn(p, "unexpected \"}\"");
                         advance(p, buf, &pos);                          advance(p, buf, &pos);
                         continue;                          continue;
                 case ('{'):                  case ('{'):
                         texiwarn(p, "unexpected \"{\"");                          if (0 == p->ign)
                                   texiwarn(p, "unexpected \"{\"");
                         advance(p, buf, &pos);                          advance(p, buf, &pos);
                         continue;                          continue;
                 case ('@'):                  case ('@'):
Line 556  parsebracket(struct texi *p, const char *buf, size_t s
Line 677  parsebracket(struct texi *p, const char *buf, size_t s
         size_t           end;          size_t           end;
         enum texicmd     cmd;          enum texicmd     cmd;
   
           while (*pos < sz && isspace(buf[*pos]))
                   advance(p, buf, pos);
   
         if (*pos == sz || '{' != buf[*pos])          if (*pos == sz || '{' != buf[*pos])
                 return;                  return;
         advance(p, buf, pos);          advance(p, buf, pos);
Line 566  parsebracket(struct texi *p, const char *buf, size_t s
Line 690  parsebracket(struct texi *p, const char *buf, size_t s
                         advance(p, buf, pos);                          advance(p, buf, pos);
                         return;                          return;
                 case ('{'):                  case ('{'):
                         texiwarn(p, "unexpected \"{\"");                          if (0 == p->ign)
                                   texiwarn(p, "unexpected \"{\"");
                         advance(p, buf, pos);                          advance(p, buf, pos);
                         continue;                          continue;
                 case ('@'):                  case ('@'):
Line 585  parsebracket(struct texi *p, const char *buf, size_t s
Line 710  parsebracket(struct texi *p, const char *buf, size_t s
         }          }
 }  }
   
   /*
    * This should be invoked when we're on a macro line and want to process
    * to the end of the current input line, doing all of our macros along
    * the way.
    */
 static void  static void
   parseeoln(struct texi *p, const char *buf, size_t sz, size_t *pos)
   {
           size_t           end;
           enum texicmd     cmd;
   
           assert(0 == p->literal);
   
           while (*pos < sz && '\n' != buf[*pos]) {
                   while (*pos < sz && isws(buf[*pos])) {
                           p->seenws = 1;
                           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);
                           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);
           }
   }
   
   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);
                   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 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 599  parseto(struct texi *p, const char *buf, 
Line 804  parseto(struct texi *p, const char *buf, 
         while ((*pos = advancenext(p, buf, sz, pos)) < sz) {          while ((*pos = advancenext(p, buf, sz, pos)) < sz) {
                 switch (buf[*pos]) {                  switch (buf[*pos]) {
                 case ('}'):                  case ('}'):
                         texiwarn(p, "unexpected \"}\"");                          if (0 == p->ign)
                                   texiwarn(p, "unexpected \"}\"");
                         advance(p, buf, pos);                          advance(p, buf, pos);
                         continue;                          continue;
                 case ('{'):                  case ('{'):
                         texiwarn(p, "unexpected \"{\"");                          if (0 == p->ign)
                                   texiwarn(p, "unexpected \"{\"");
                         advance(p, buf, pos);                          advance(p, buf, pos);
                         continue;                          continue;
                 case ('@'):                  case ('@'):
Line 624  parseto(struct texi *p, const char *buf, 
Line 831  parseto(struct texi *p, const char *buf, 
                          */                           */
                         if (sz - *pos >= endtoksz && 0 == strncmp                          if (sz - *pos >= endtoksz && 0 == strncmp
                                  (&buf[*pos], endtoken, endtoksz)) {                                   (&buf[*pos], endtoken, endtoksz)) {
                                 advanceeoln(p, buf, sz, pos);                                  advanceeoln(p, buf, sz, pos, 0);
                                 break;                                  break;
                         }                          }
                         texiwarn(p, "unexpected \"end\"");                          if (0 == p->ign)
                         advanceeoln(p, buf, sz, pos);                                  texiwarn(p, "unexpected \"end\"");
                           advanceeoln(p, buf, sz, pos, 0);
                         continue;                          continue;
                 } else if (TEXICMD__MAX != cmd)                  } else if (TEXICMD__MAX != cmd)
                         if (NULL != texitoks[cmd].fp)                          if (NULL != texitoks[cmd].fp)
Line 669  parsefile(struct texi *p, const char *fname)
Line 877  parsefile(struct texi *p, const char *fname)
 }  }
   
 static void  static void
   dodeftypevar(struct texi *p, enum texicmd cmd,
           const char *buf, size_t sz, size_t *pos)
   {
           const char      *blk;
   
           blk = TEXICMD_DEFTYPEVR == cmd ?
                   "deftypevr" : "deftypevar";
   
           if (p->ign) {
                   parseto(p, buf, sz, pos, blk);
                   return;
           }
   
           teximacro(p, ".Pp");
           if (TEXICMD_DEFTYPEVR == cmd) {
                   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) {
           case (TEXICMD_DEFTYPEFN):
                   blk = "deftypefn";
                   break;
           case (TEXICMD_DEFTYPEFUN):
                   blk = "deftypefun";
                   break;
           case (TEXICMD_DEFTYPEFNX):
           case (TEXICMD_DEFTYPEFUNX):
                   blk = NULL;
                   break;
           default:
                   abort();
           }
   
           if (p->ign) {
                   if (NULL != blk)
                           parseto(p, buf, sz, pos, blk);
                   return;
           }
   
           switch (cmd) {
           case (TEXICMD_DEFTYPEFN):
           case (TEXICMD_DEFTYPEFUN):
                   teximacro(p, ".Pp");
                   break;
           default:
                   break;
           }
           if (TEXICMD_DEFTYPEFN == cmd ||
                           TEXICMD_DEFTYPEFNX == cmd) {
                   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)
                   parseto(p, buf, sz, pos, blk);
   }
   
   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)
 {  {
         unsigned int     sv = p->flags;          const char      *blk;
         const char      *blockname;  
   
         p->flags |= TEXI_IGN;  
         switch (cmd) {          switch (cmd) {
         case (TEXICMD_COPYING):          case (TEXICMD_COPYING):
                 blockname = "copying";                  blk = "copying";
                 break;                  break;
         case (TEXICMD_DETAILMENU):          case (TEXICMD_DETAILMENU):
                 blockname = "detailmenu";                  blk = "detailmenu";
                 break;                  break;
         case (TEXICMD_DIRENTRY):          case (TEXICMD_DIRENTRY):
                 blockname = "direntry";                  blk = "direntry";
                 break;                  break;
           case (TEXICMD_IFCLEAR):
                   blk = "ifclear";
                   break;
         case (TEXICMD_IFHTML):          case (TEXICMD_IFHTML):
                 blockname = "ifhtml";                  blk = "ifhtml";
                 break;                  break;
           case (TEXICMD_IFINFO):
                   blk = "ifinfo";
                   break;
           case (TEXICMD_IFSET):
                   blk = "ifset";
                   break;
         case (TEXICMD_IFTEX):          case (TEXICMD_IFTEX):
                 blockname = "iftex";                  blk = "iftex";
                 break;                  break;
         case (TEXICMD_MENU):          case (TEXICMD_MENU):
                 blockname = "menu";                  blk = "menu";
                 break;                  break;
         case (TEXICMD_TEX):          case (TEXICMD_TEX):
                 blockname = "tex";                  blk = "tex";
                 break;                  break;
         case (TEXICMD_TITLEPAGE):          case (TEXICMD_TITLEPAGE):
                 blockname = "titlepage";                  blk = "titlepage";
                 break;                  break;
         default:          default:
                 abort();                  abort();
         }          }
         parseto(p, buf, sz, pos, blockname);          p->ign++;
         p->flags = sv;          parseto(p, buf, sz, pos, blk);
           p->ign--;
 }  }
   
 static void  static void
 doifnottex(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;
   
           switch (cmd) {
           case (TEXICMD_GROUP):
                   blk = "group";
                   break;
           case (TEXICMD_IFNOTTEX):
                   blk = "ifnottex";
                   break;
           default:
                   abort();
           }
   
         parseto(p, buf, sz, pos, "ifnottex");          parseto(p, buf, sz, pos, blk);
 }  }
   
 static void  static void
 doinline(struct texi *p, const char *buf,  doinline(struct texi *p, const char *buf,
         size_t sz, size_t *pos, const char *macro)          size_t sz, size_t *pos, const char *macro)
 {  {
           int      open = 0;
   
         if ( ! p->outmacro)          if (0 == p->outmacro) {
                 texifputs(p, ".");                  open = 1;
                   teximacroopen(p, ".");
           } else
                   texiputchar(p, ' ');
   
         texiputchars(p, macro);          texiputchars(p, macro);
         texiputchar(p, ' ');          texiputchar(p, ' ');
         p->seenws = 0;          p->seenws = 0;
         p->outmacro++;  
         parsebracket(p, buf, sz, pos);          parsebracket(p, buf, sz, pos);
         p->outmacro--;  
         if (*pos < sz - 1 &&          if (*pos < sz - 1 &&
                  ismpunct(buf[*pos]) &&                   ismpunct(buf[*pos]) &&
                  isspace(buf[*pos + 1])) {                   isspace(buf[*pos + 1])) {
Line 736  doinline(struct texi *p, const char *buf, 
Line 1051  doinline(struct texi *p, const char *buf, 
                 texiputchar(p, buf[*pos]);                  texiputchar(p, buf[*pos]);
                 advance(p, buf, pos);                  advance(p, buf, pos);
         }          }
         if ( ! p->outmacro)          if (open)
                 texiputchar(p, '\n');                  teximacroclose(p);
 }  }
   
 static void  static void
Line 792  doitalic(struct texi *p, enum texicmd cmd, 
Line 1107  doitalic(struct texi *p, enum texicmd cmd, 
 }  }
   
 static void  static void
   doenv(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, "Ev");
   }
   
   static void
 doliteral(struct texi *p, enum texicmd cmd,  doliteral(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 (TEXI_LITERAL & p->flags)          if (p->literal)
                 parsebracket(p, buf, sz, pos);                  parsebracket(p, buf, sz, pos);
         else          else
                 doinline(p, buf, sz, pos, "Li");                  doinline(p, buf, sz, pos, "Li");
Line 807  doemph(struct texi *p, enum texicmd cmd, 
Line 1133  doemph(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 (TEXI_LITERAL & p->flags)          if (p->literal)
                 doitalic(p, cmd, buf, sz, pos);                  doitalic(p, cmd, buf, sz, pos);
         else          else
                 doinline(p, buf, sz, pos, "Em");                  doinline(p, buf, sz, pos, "Em");
Line 834  dofile(struct texi *p, enum texicmd cmd, 
Line 1160  dofile(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 (TEXI_LITERAL & p->flags)          if (p->literal)
                 parsebracket(p, buf, sz, pos);                  parsebracket(p, buf, sz, pos);
         else          else
                 doinline(p, buf, sz, pos, "Pa");                  doinline(p, buf, sz, pos, "Pa");
 }  }
   
 static void  static void
   dodisplay(struct texi *p, enum texicmd cmd,
           const char *buf, size_t sz, size_t *pos)
   {
   
           if (p->outmacro)
                   texierr(p, "display in open line scope!?");
           else if (p->literal)
                   texierr(p, "display in a literal scope!?");
   
           teximacro(p, ".Bd -display");
           advanceeoln(p, buf, sz, pos, 1);
           parseto(p, buf, sz, pos, "display");
           teximacro(p, ".Ed");
   }
   
   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)
 {  {
         unsigned int    sv;          const char      *blk;
   
           if (p->outmacro)
                   texierr(p, "example in open line scope!?");
           else if (p->literal)
                   texierr(p, "example in a literal scope!?");
   
           blk = TEXICMD_EXAMPLE == cmd ?  "example" : "smallexample";
   
         teximacro(p, ".Bd -literal");          teximacro(p, ".Bd -literal");
         advanceeoln(p, buf, sz, pos);          advanceeoln(p, buf, sz, pos, 1);
         if ('\n' == buf[*pos])          p->literal++;
                 advance(p, buf, pos);          parseto(p, buf, sz, pos, blk);
         sv = p->flags;          p->literal--;
         p->flags |= TEXI_LITERAL;  
         parseto(p, buf, sz, pos, "example");  
         p->flags = sv;  
         teximacro(p, ".Ed");          teximacro(p, ".Ed");
 }  }
   
Line 871  dosymbol(struct texi *p, enum texicmd cmd, 
Line 1217  dosymbol(struct texi *p, enum texicmd cmd, 
         const char *buf, size_t sz, size_t *pos)          const char *buf, size_t sz, size_t *pos)
 {  {
   
           if (p->seenws && p->outcol && 0 == p->literal) {
                   texiputchar(p, ' ');
                   p->seenws = 0;
           }
   
         switch (cmd) {          switch (cmd) {
           case (TEXICMD_ASTERISK):
           case (TEXICMD_NEWLINE):
           case (TEXICMD_SPACE):
           case (TEXICMD_TAB):
                   texiputchar(p, ' ');
                   break;
         case (TEXICMD_AT):          case (TEXICMD_AT):
                 texiputchars(p, "@");                  texiputchar(p, '@');
                 break;                  break;
           case (TEXICMD_BANG):
                   texiputchar(p, '!');
                   break;
         case (TEXICMD_COPYRIGHT):          case (TEXICMD_COPYRIGHT):
                 texiputchars(p, "\\(co");                  texiputchars(p, "\\(co");
                 break;                  break;
Line 884  dosymbol(struct texi *p, enum texicmd cmd, 
Line 1244  dosymbol(struct texi *p, enum texicmd cmd, 
         case (TEXICMD_LATEX):          case (TEXICMD_LATEX):
                 texiputchars(p, "LaTeX");                  texiputchars(p, "LaTeX");
                 break;                  break;
           case (TEXICMD_QUESTIONMARK):
                   texiputchar(p, '?');
                   break;
           case (TEXICMD_SQUIGGLE_LEFT):
                   texiputchars(p, "{");
                   break;
           case (TEXICMD_SQUIGGLE_RIGHT):
                   texiputchars(p, "}");
                   break;
         case (TEXICMD_TEXSYM):          case (TEXICMD_TEXSYM):
                 texiputchars(p, "TeX");                  texiputchars(p, "TeX");
                 break;                  break;
           case (TEXICMD_COLON):
           case (TEXICMD_HYPHEN):
                   break;
         default:          default:
                 abort();                  abort();
         }          }
Line 904  doquotation(struct texi *p, enum texicmd cmd, 
Line 1276  doquotation(struct texi *p, enum texicmd cmd, 
         teximacro(p, ".Qc");          teximacro(p, ".Qc");
 }  }
   
   /* FIXME */
 static void  static void
   domath(struct texi *p, enum texicmd cmd,
           const char *buf, size_t sz, size_t *pos)
   {
           size_t   nest;
   
           /*
            * Math handling is different from everything else.
            * We don't allow any subcomponents, and we ignore the rules in
            * terms of @-commands.
            * This departs from GNU's rules, but whatever.
            */
           while (*pos < sz && isws(buf[*pos]))
                   advance(p, buf, pos);
           if (*pos == sz || '{' != buf[*pos])
                   return;
           advance(p, buf, pos);
           if (p->seenws && p->outcol && 0 == p->literal)
                   texiputchar(p, ' ');
           p->seenws = 0;
           for (nest = 1; *pos < sz && nest > 0; ) {
                   if ('{' == buf[*pos])
                           nest++;
                   else if ('}' == buf[*pos])
                           if (0 == --nest)
                                   continue;
                   texiputchar(p, buf[*pos]);
                   advance(p, buf, pos);
           }
           if (*pos == sz)
                   return;
           assert('}' == buf[*pos]);
           advance(p, buf, pos);
   }
   
   /* FIXME */
   static void
 doarg1(struct texi *p, enum texicmd cmd,  doarg1(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;
   
         if (*pos == sz || '{' != buf[*pos])          if (*pos == sz || '{' != buf[*pos])
                 return;                  return;
         advance(p, buf, pos);          advance(p, buf, pos);
         if ( ! p->outmacro)  
                 texifputs(p, ".");  
         switch (cmd) {          switch (cmd) {
         case (TEXICMD_EMAIL):          case (TEXICMD_EMAIL):
                   if ( ! p->outmacro) {
                           open = 1;
                           teximacroopen(p, ".");
                   }
                 texiputchars(p, "Lk ");                  texiputchars(p, "Lk ");
                 break;                  break;
           case (TEXICMD_UREF):
         case (TEXICMD_URL):          case (TEXICMD_URL):
                   if ( ! p->outmacro) {
                           open = 1;
                           teximacroopen(p, ".");
                   }
                 texiputchars(p, "Mt ");                  texiputchars(p, "Mt ");
                 break;                  break;
         default:          default:
                 abort();                  break;
         }          }
           /* FIXME: this is ugly */
         while (*pos < sz && '}' != buf[*pos] && ',' != buf[*pos]) {          while (*pos < sz && '}' != buf[*pos] && ',' != buf[*pos]) {
                 texiputchar(p, buf[*pos]);                  texiputchar(p, buf[*pos]);
                 advance(p, buf, pos);                  advance(p, buf, pos);
Line 939  doarg1(struct texi *p, enum texicmd cmd, 
Line 1357  doarg1(struct texi *p, enum texicmd cmd, 
                 texiputchar(p, buf[*pos]);                  texiputchar(p, buf[*pos]);
                 advance(p, buf, pos);                  advance(p, buf, pos);
         }          }
         if ( ! p->outmacro)          if (open)
                 texiputchar(p, '\n');                  teximacroclose(p);
 }  }
   
 static void  static void
Line 948  dosubsection(struct texi *p, enum texicmd cmd, 
Line 1366  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 (TEXI_IGN & p->flags) {          if (p->outmacro)
                 advanceeoln(p, buf, sz, pos);                  texierr(p, "subsubsection in open line scope!?");
                 return;          else if (p->literal)
         }                  texierr(p, "subsubsection in a literal scope!?");
         while (*pos < sz && ' ' == buf[*pos])  
                 advance(p, buf, pos);          teximacro(p, ".Pp");
         texifputs(p, ".Pp");          parseeoln(p, buf, sz, pos);
         while (*pos < sz && '\n' != buf[*pos]) {          teximacro(p, ".Pp");
                 texiputchar(p, buf[*pos]);  
                 advance(p, buf, pos);  
         }  
         texifputs(p, ".Pp");  
 }  }
   
 static void  static void
Line 967  dosection(struct texi *p, enum texicmd cmd, 
Line 1381  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)
 {  {
   
         if (TEXI_IGN & p->flags) {          if (p->outmacro)
                 advanceeoln(p, buf, sz, pos);                  texierr(p, "subsection in open line scope!?");
                 return;          else if (p->literal)
         }                  texierr(p, "subsection in a literal scope!?");
         while (*pos < sz && isws(buf[*pos]) )  
                 advance(p, buf, pos);          teximacroopen(p, ".Ss ");
         texifputs(p, ".Ss ");          parseeoln(p, buf, sz, pos);
         while (*pos < sz && '\n' != buf[*pos]) {          teximacroclose(p);
                 texiputchar(p, buf[*pos]);  
                 advance(p, buf, pos);  
         }  
         texiputchar(p, '\n');  
 }  }
   
 static void  static void
 dosh(struct texi *p, enum texicmd cmd,  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 (TEXI_IGN & p->flags) {          if (p->outmacro)
                 advanceeoln(p, buf, sz, pos);                  texierr(p, "spacing in open line scope!?");
                 return;          else if (p->literal)
         }                  texierr(p, "spacing in a literal scope!?");
         while (*pos < sz && isws(buf[*pos]))  
                 advance(p, buf, pos);          teximacro(p, ".Pp");
         texifputs(p, ".Sh ");          advanceeoln(p, buf, sz, pos, 1);
         while (*pos < sz && '\n' != buf[*pos]) {  
                 texiputchar(p, toupper(buf[*pos]));  
                 advance(p, buf, pos);  
         }  
         texiputchar(p, '\n');  
 }  }
   
 static void  static void
   dochapter(struct texi *p, enum texicmd cmd,
           const char *buf, size_t sz, size_t *pos)
   {
   
           if (p->outmacro)
                   texierr(p, "section in open line scope!?");
           else if (p->literal)
                   texierr(p, "section in a literal scope!?");
   
           teximacroopen(p, ".Sh ");
           parseeoln(p, buf, sz, pos);
           teximacroclose(p);
   }
   
   static void
 dotop(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)
 {  {
   
         p->flags &= ~TEXI_HEADER;          p->ign--;
         advanceeoln(p, buf, sz, pos);          advanceeoln(p, buf, sz, pos, 1);
         teximacro(p, ".Dd $Mdocdate$");          teximacro(p, ".Dd $Mdocdate$");
         teximacro(p, ".Dt SOMETHING 7");          teximacro(p, ".Dt SOMETHING 7");
         teximacro(p, ".Os");          teximacro(p, ".Os");
Line 1019  static void
Line 1439  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)
 {  {
         size_t   end;  
   
         /* See if we have arguments... */          if (p->outmacro)
         for (end = *pos; end < sz; end++)                  texierr(p, "item in open line scope!?");
                 if ( ! isws(buf[end]))          else if (p->literal)
                         break;                  texierr(p, "item in a literal scope!?");
   
         /* If we have arguments, print them too. */          switch (p->list) {
         if ('\n' != buf[end]) {          case (TEXILIST_ITEM):
                 texifputs(p, ".It");                  teximacroopen(p, ".It");
                 /* FIXME: process commands. */                  break;
                 while (*pos < sz && '\n' != buf[*pos]) {          case (TEXILIST_NOITEM):
                         texiputchar(p, buf[*pos]);  
                         advance(p, buf, pos);  
                 }  
                 texiputchar(p, '\n');  
         } else  
                 teximacro(p, ".It");                  teximacro(p, ".It");
                   break;
           default:
                   teximacro(p, ".Pp");
                   break;
           }
   
           parseeoln(p, buf, sz, pos);
   
           if (TEXILIST_ITEM == p->list)
                   teximacroclose(p);
           else
                   texiputchar(p, '\n');
 }  }
   
 static void  static void
 dotable(struct texi *p, enum texicmd cmd,  dotable(struct texi *p, enum texicmd cmd,
         const char *buf, size_t sz, size_t *pos)          const char *buf, size_t sz, size_t *pos)
 {  {
           enum texilist   sv = p->list;
   
           if (p->outmacro)
                   texierr(p, "table in open line scope!?");
           else if (p->literal)
                   texierr(p, "table in a literal scope!?");
   
           p->list = TEXILIST_ITEM;
         teximacro(p, ".Bl -tag -width Ds");          teximacro(p, ".Bl -tag -width Ds");
         parseto(p, buf, sz, pos, "table");          parseto(p, buf, sz, pos, "table");
         teximacro(p, ".El");          teximacro(p, ".El");
           p->list = sv;
 }  }
   
 static void  static void
 doenumerate(struct texi *p, enum texicmd cmd,  doenumerate(struct texi *p, enum texicmd cmd,
         const char *buf, size_t sz, size_t *pos)          const char *buf, size_t sz, size_t *pos)
 {  {
           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;
         teximacro(p, ".Bl -enum");          teximacro(p, ".Bl -enum");
         parseto(p, buf, sz, pos, "enumerate");          parseto(p, buf, sz, pos, "enumerate");
         teximacro(p, ".El");          teximacro(p, ".El");
           p->list = sv;
 }  }
   
 static void  static void
 doitemize(struct texi *p, enum texicmd cmd,  doitemize(struct texi *p, enum texicmd cmd,
         const char *buf, size_t sz, size_t *pos)          const char *buf, size_t sz, size_t *pos)
 {  {
           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;
         teximacro(p, ".Bl -bullet");          teximacro(p, ".Bl -bullet");
         parseto(p, buf, sz, pos, "itemize");          parseto(p, buf, sz, pos, "itemize");
         teximacro(p, ".El");          teximacro(p, ".El");
           p->list = sv;
 }  }
   
 static void  static void
 doignbracket(struct texi *p, enum texicmd cmd,  doignbracket(struct texi *p, enum texicmd cmd,
         const char *buf, size_t sz, size_t *pos)          const char *buf, size_t sz, size_t *pos)
 {  {
         unsigned int     sv = p->flags;  
   
         p->flags |= TEXI_IGN;          p->ign++;
         parsebracket(p, buf, sz, pos);          parsebracket(p, buf, sz, pos);
         p->flags = sv;          p->ign--;
 }  }
   
 static void  static void
Line 1085  doignline(struct texi *p, enum texicmd cmd, 
Line 1534  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)
 {  {
   
         advanceeoln(p, buf, sz, pos);          advanceeoln(p, buf, sz, pos, 1);
         if (*pos < sz)  
                 advance(p, buf, pos);  
 }  }
   
 int  int
Line 1125  main(int argc, char *argv[])
Line 1572  main(int argc, char *argv[])
         free(path);          free(path);
   
         memset(&texi, 0, sizeof(struct texi));          memset(&texi, 0, sizeof(struct texi));
         texi.flags = TEXI_HEADER;          texi.ign = 1;
         texi.dir = strdup(dir);          texi.dir = strdup(dir);
         parsefile(&texi, argv[0]);          parsefile(&texi, argv[0]);
         texiexit(&texi);          texiexit(&texi);
Legend:
Removed from v.1.2  
changed lines
  Added in v.1.3
CVSweb