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

Diff for /texi2mdoc/main.c between version 1.4 and 1.5

version 1.4, 2015/02/17 20:27:44 version 1.5, 2015/02/18 11:01:56
Line 44  enum texicmd {
Line 44  enum texicmd {
         TEXICMD_AUTHOR,          TEXICMD_AUTHOR,
         TEXICMD_BANG,          TEXICMD_BANG,
         TEXICMD_BYE,          TEXICMD_BYE,
           TEXICMD_CENTER,
         TEXICMD_CHAPTER,          TEXICMD_CHAPTER,
         TEXICMD_CINDEX,          TEXICMD_CINDEX,
         TEXICMD_CITE,          TEXICMD_CITE,
Line 87  enum texicmd {
Line 88  enum texicmd {
         TEXICMD_IFSET,          TEXICMD_IFSET,
         TEXICMD_IMAGE,          TEXICMD_IMAGE,
         TEXICMD_INCLUDE,          TEXICMD_INCLUDE,
           TEXICMD_INSERTCOPYING,
         TEXICMD_ITEM,          TEXICMD_ITEM,
         TEXICMD_ITEMIZE,          TEXICMD_ITEMIZE,
         TEXICMD_KBD,          TEXICMD_KBD,
Line 172  enum texilist {
Line 174  enum texilist {
  * This keeps any necessary information handy.   * This keeps any necessary information handy.
  */   */
 struct  texi {  struct  texi {
         struct texifile  files[64];          struct texifile   files[64]; /* stack of open files */
         size_t           filepos;          size_t            filepos; /* number of open files */
         size_t           outcol; /* column of output */          size_t            outcol; /* column in output line */
         int              outmacro; /* whether output is in line macro */          char            **dirs; /* texi directories */
         int              seenws; /* whitespace has been ignored */          size_t            dirsz; /* number of texi directories */
         int              ign; /* don't print anything */          enum texilist     list;
         int              literal;          int               outmacro; /* whether output is in line macro */
         char            *dir; /* texi directory */          int               seenws; /* whitespace has been ignored */
         enum texilist    list;          int               ign; /* don't print anything */
           int               literal;
 };  };
   
 /* FIXME: don't use this crap. */  /* FIXME: don't use this crap. */
Line 233  static const struct texitok texitoks[TEXICMD__MAX] = {
Line 236  static const struct texitok texitoks[TEXICMD__MAX] = {
         { doignline, "author", 6 }, /* TEXICMD_AUTHOR */          { doignline, "author", 6 }, /* TEXICMD_AUTHOR */
         { dosymbol, "!", 1 }, /* TEXICMD_BANG */          { dosymbol, "!", 1 }, /* TEXICMD_BANG */
         { dobye, "bye", 3 }, /* TEXICMD_BYE */          { dobye, "bye", 3 }, /* TEXICMD_BYE */
           { doignline, "center", 5 }, /* TEXICMD_CENTER */
         { dochapter, "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 */
Line 276  static const struct texitok texitoks[TEXICMD__MAX] = {
Line 280  static const struct texitok texitoks[TEXICMD__MAX] = {
         { doignblock, "ifset", 5 }, /* TEXICMD_IFSET */          { 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 */
           { doignline, "insertcopying", 13 }, /* TEXICMD_INSERTCOPYING */
         { doitem, "item", 4 }, /* TEXICMD_ITEM */          { doitem, "item", 4 }, /* TEXICMD_ITEM */
         { doitemize, "itemize", 7 }, /* TEXICMD_ITEMIZE */          { doitemize, "itemize", 7 }, /* TEXICMD_ITEMIZE */
         { doliteral, "kbd", 3 }, /* TEXICMD_KBD */          { doliteral, "kbd", 3 }, /* TEXICMD_KBD */
Line 296  static const struct texitok texitoks[TEXICMD__MAX] = {
Line 301  static const struct texitok texitoks[TEXICMD__MAX] = {
         { doignline, "set", 3 }, /* TEXICMD_SET */          { doignline, "set", 3 }, /* TEXICMD_SET */
         { doignline, "setchapternewpage", 17 }, /* TEXICMD_SETCHAPNEWPAGE */          { doignline, "setchapternewpage", 17 }, /* TEXICMD_SETCHAPNEWPAGE */
         { doignline, "setfilename", 11 }, /* TEXICMD_SETFILENAME */          { doignline, "setfilename", 11 }, /* TEXICMD_SETFILENAME */
           { doignline, "settitle", 8 }, /* TEXICMD_SETTITLE */
         { dosp, "sp", 2 }, /* TEXICMD_SP */          { dosp, "sp", 2 }, /* TEXICMD_SP */
         { dosymbol, " ", 1 }, /* TEXICMD_SPACE */          { dosymbol, " ", 1 }, /* TEXICMD_SPACE */
         { doexample, "smallexample", 12 }, /* TEXICMD_SMALLEXAMPLE */          { doexample, "smallexample", 12 }, /* TEXICMD_SMALLEXAMPLE */
         { doignline, "settitle", 8 }, /* TEXICMD_SETTITLE */  
         { dosymbol, "{", 1 }, /* TEXICMD_SQUIGGLE_LEFT */          { dosymbol, "{", 1 }, /* TEXICMD_SQUIGGLE_LEFT */
         { dosymbol, "}", 1 }, /* TEXICMD_SQUIGGLE_RIGHT */          { dosymbol, "}", 1 }, /* TEXICMD_SQUIGGLE_RIGHT */
         { dosubsection, "subsection", 10 }, /* TEXICMD_SUBSECTION */          { dosubsection, "subsection", 10 }, /* TEXICMD_SUBSECTION */
Line 340  texifilepop(struct texi *p)
Line 345  texifilepop(struct texi *p)
 static void  static void
 texiexit(struct texi *p)  texiexit(struct texi *p)
 {  {
           size_t   i;
   
         while (p->filepos > 0)  
                 texifilepop(p);  
         free(p->dir);  
         if (p->outcol)          if (p->outcol)
                 putchar('\n');                  putchar('\n');
   
           while (p->filepos > 0)
                   texifilepop(p);
   
           for (i = 0; i < p->dirsz; i++)
                   free(p->dirs[i]);
           free(p->dirs);
 }  }
   
 /*  /*
Line 435  static void
Line 445  static void
 teximacroclose(struct texi *p)  teximacroclose(struct texi *p)
 {  {
   
         p->outmacro--;          if (0 == --p->outmacro)
         if (p->ign)                  texiputchar(p, '\n');
                 return;  
         texiputchar(p, '\n');  
 }  }
   
 /*  /*
Line 448  teximacroclose(struct texi *p)
Line 456  teximacroclose(struct texi *p)
 static void  static void
 teximacroopen(struct texi *p, const char *s)  teximacroopen(struct texi *p, const char *s)
 {  {
         int      rc;  
   
         p->outmacro++;          if (p->outcol && 0 == p->outmacro)
         if (p->ign)  
                 return;  
         if (p->outcol)  
                 texiputchar(p, '\n');                  texiputchar(p, '\n');
         if (EOF != (rc = fputs(s, stdout)))          if (0 == p->outmacro)
                 p->outcol += rc;                  texiputchar(p, '.');
           else
                   texiputchar(p, ' ');
           texiputchars(p, s);
           texiputchar(p, ' ');
           p->outmacro++;
           p->seenws = 0;
 }  }
   
 /*  /*
Line 472  teximacro(struct texi *p, const char *s)
Line 482  teximacro(struct texi *p, const char *s)
         else if (p->literal)          else if (p->literal)
                 texierr(p, "\"%s\" in a literal scope!?", s);                  texierr(p, "\"%s\" in a literal scope!?", s);
   
         if (p->ign)  
                 return;  
         if (p->outcol)          if (p->outcol)
                 texiputchar(p, '\n');                  texiputchar(p, '\n');
         puts(s);  
         p->outcol = 0;          texiputchar(p, '.');
         p->seenws = 0;          texiputchars(p, s);
           texiputchar(p, '\n');
 }  }
   
 /*  /*
Line 508  advancenext(struct texi *p, const char *buf, size_t sz
Line 517  advancenext(struct texi *p, const char *buf, size_t sz
   
         if (p->literal) {          if (p->literal) {
                 while (*pos < sz && isspace(buf[*pos])) {                  while (*pos < sz && isspace(buf[*pos])) {
                           if (*pos && '\n' == buf[*pos] &&
                                   '\\' == buf[*pos - 1])
                                   texiputchar(p, 'e');
                         texiputchar(p, buf[*pos]);                          texiputchar(p, buf[*pos]);
                         advance(p, buf, pos);                          advance(p, buf, pos);
                 }                  }
Line 521  advancenext(struct texi *p, const char *buf, size_t sz
Line 533  advancenext(struct texi *p, const char *buf, size_t sz
                  * output a paragraph.                   * output a paragraph.
                  * FIXME: this is stupid.                   * FIXME: this is stupid.
                  */                   */
                 if (*pos && '\n' == buf[*pos] && '\n' == buf[*pos - 1])                  if (*pos && '\n' == buf[*pos] &&
                         teximacro(p, ".Pp");                          '\n' == buf[*pos - 1])
                           teximacro(p, "Pp");
                 advance(p, buf, pos);                  advance(p, buf, pos);
         }          }
         return(*pos);          return(*pos);
Line 895  dodeftypevar(struct texi *p, enum texicmd cmd, 
Line 908  dodeftypevar(struct texi *p, enum texicmd cmd, 
                 return;                  return;
         }          }
   
         teximacro(p, ".Pp");          teximacro(p, "Pp");
         if (TEXICMD_DEFTYPEVR == cmd) {          if (TEXICMD_DEFTYPEVR == cmd) {
                 parsebracket(p, buf, sz, pos);                  parsebracket(p, buf, sz, pos);
                 texiputchars(p, ":\n");                  texiputchars(p, ":\n");
         }          }
         teximacroopen(p, ".Vt ");          teximacroopen(p, "Vt");
         parseeoln(p, buf, sz, pos);          parseeoln(p, buf, sz, pos);
         teximacroclose(p);          teximacroclose(p);
         teximacro(p, ".Pp");          teximacro(p, "Pp");
         parseto(p, buf, sz, pos, blk);          parseto(p, buf, sz, pos, blk);
 }  }
   
Line 913  dodeftypefun(struct texi *p, enum texicmd cmd, 
Line 926  dodeftypefun(struct texi *p, enum texicmd cmd, 
 {  {
         const char      *blk;          const char      *blk;
   
           blk = NULL;
         switch (cmd) {          switch (cmd) {
         case (TEXICMD_DEFTYPEFN):          case (TEXICMD_DEFTYPEFN):
                 blk = "deftypefn";  
                 break;  
         case (TEXICMD_DEFTYPEFUN):          case (TEXICMD_DEFTYPEFUN):
                 blk = "deftypefun";                  blk = texitoks[cmd].tok;
                 break;                  break;
         case (TEXICMD_DEFTYPEFNX):  
         case (TEXICMD_DEFTYPEFUNX):  
                 blk = NULL;  
                 break;  
         default:          default:
                 abort();                  break;
         }          }
   
         if (p->ign) {          if (p->ign) {
Line 937  dodeftypefun(struct texi *p, enum texicmd cmd, 
Line 945  dodeftypefun(struct texi *p, enum texicmd cmd, 
         switch (cmd) {          switch (cmd) {
         case (TEXICMD_DEFTYPEFN):          case (TEXICMD_DEFTYPEFN):
         case (TEXICMD_DEFTYPEFUN):          case (TEXICMD_DEFTYPEFUN):
                 teximacro(p, ".Pp");                  teximacro(p, "Pp");
                 break;                  break;
         default:          default:
                 break;                  break;
Line 947  dodeftypefun(struct texi *p, enum texicmd cmd, 
Line 955  dodeftypefun(struct texi *p, enum texicmd cmd, 
                 parsebracket(p, buf, sz, pos);                  parsebracket(p, buf, sz, pos);
                 texiputchars(p, ":\n");                  texiputchars(p, ":\n");
         }          }
         teximacroopen(p, ".Ft ");          teximacroopen(p, "Ft");
         parsesingle(p, buf, sz, pos);          parsesingle(p, buf, sz, pos);
         teximacroclose(p);          teximacroclose(p);
         teximacroopen(p, ".Fn ");          teximacroopen(p, "Fn");
         parsesingle(p, buf, sz, pos);          parsesingle(p, buf, sz, pos);
         teximacroclose(p);          teximacroclose(p);
         teximacroopen(p, ".Li ");          teximacroopen(p, "Li");
         parseeoln(p, buf, sz, pos);          parseeoln(p, buf, sz, pos);
         teximacroclose(p);          teximacroclose(p);
         teximacro(p, ".Pp");          teximacro(p, "Pp");
         if (NULL != blk)          if (NULL != blk)
                 parseto(p, buf, sz, pos, blk);                  parseto(p, buf, sz, pos, blk);
 }  }
Line 965  static void
Line 973  static void
 doignblock(struct texi *p, enum texicmd cmd,  doignblock(struct texi *p, enum texicmd cmd,
         const char *buf, size_t sz, size_t *pos)          const char *buf, size_t sz, size_t *pos)
 {  {
         const char      *blk;  
   
         switch (cmd) {  
         case (TEXICMD_COPYING):  
                 blk = "copying";  
                 break;  
         case (TEXICMD_DETAILMENU):  
                 blk = "detailmenu";  
                 break;  
         case (TEXICMD_DIRENTRY):  
                 blk = "direntry";  
                 break;  
         case (TEXICMD_IFCLEAR):  
                 blk = "ifclear";  
                 break;  
         case (TEXICMD_IFHTML):  
                 blk = "ifhtml";  
                 break;  
         case (TEXICMD_IFINFO):  
                 blk = "ifinfo";  
                 break;  
         case (TEXICMD_IFSET):  
                 blk = "ifset";  
                 break;  
         case (TEXICMD_IFTEX):  
                 blk = "iftex";  
                 break;  
         case (TEXICMD_MENU):  
                 blk = "menu";  
                 break;  
         case (TEXICMD_TEX):  
                 blk = "tex";  
                 break;  
         case (TEXICMD_TITLEPAGE):  
                 blk = "titlepage";  
                 break;  
         default:  
                 abort();  
         }  
         p->ign++;          p->ign++;
         parseto(p, buf, sz, pos, blk);          parseto(p, buf, sz, pos, texitoks[cmd].tok);
         p->ign--;          p->ign--;
 }  }
   
Line 1013  static void
Line 983  static void
 doblock(struct texi *p, enum texicmd cmd,  doblock(struct texi *p, enum texicmd cmd,
         const char *buf, size_t sz, size_t *pos)          const char *buf, size_t sz, size_t *pos)
 {  {
         const char      *blk;  
   
         switch (cmd) {  
         case (TEXICMD_GROUP):  
                 blk = "group";  
                 break;  
         case (TEXICMD_IFNOTTEX):  
                 blk = "ifnottex";  
                 break;  
         default:  
                 abort();  
         }  
   
         parseto(p, buf, sz, pos, blk);          parseto(p, buf, sz, pos, texitoks[cmd].tok);
 }  }
   
 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 (0 == p->outmacro) {          teximacroopen(p, macro);
                 open = 1;  
                 teximacroopen(p, ".");  
         } else  
                 texiputchar(p, ' ');  
   
         texiputchars(p, macro);  
         texiputchar(p, ' ');  
         p->seenws = 0;          p->seenws = 0;
         parsebracket(p, buf, sz, pos);          parsebracket(p, buf, sz, pos);
         if (*pos < sz - 1 &&          if (*pos < sz - 1 &&
Line 1052  doinline(struct texi *p, const char *buf, 
Line 1002  doinline(struct texi *p, const char *buf, 
                 texiputchar(p, buf[*pos]);                  texiputchar(p, buf[*pos]);
                 advance(p, buf, pos);                  advance(p, buf, pos);
         }          }
         if (open)          teximacroclose(p);
                 teximacroclose(p);  
 }  }
   
 static void  static void
Line 1086  doinclude(struct texi *p, enum texicmd cmd, 
Line 1035  doinclude(struct texi *p, enum texicmd cmd, 
         if (strstr(fname, "../") || strstr(fname, "/.."))          if (strstr(fname, "../") || strstr(fname, "/.."))
                 texierr(p, "insecure path");                  texierr(p, "insecure path");
   
         /* Append filename to original name's directory. */          for (i = 0; i < p->dirsz; i++) {
         rc = snprintf(path, sizeof(path), "%s/%s", p->dir, fname);                  rc = snprintf(path, sizeof(path),
         if (rc < 0)                          "%s/%s", p->dirs[i], fname);
                 texierr(p, "couldn't format filename");                  texiwarn(p, "trying: %s", path);
         else if ((size_t)rc >= sizeof(path))                  if (rc < 0)
                 texierr(p, "path too long");                          texierr(p, "couldn't format path");
                   else if ((size_t)rc >= sizeof(path))
                           texierr(p, "path too long");
                   else if (-1 == access(path, R_OK))
                           continue;
   
         /* Pump through to parser. */                  parsefile(p, path);
         parsefile(p, path);                  return;
           }
   
           texierr(p, "couldn't find %s in includes", fname);
 }  }
   
 static void  static void
Line 1172  dodisplay(struct texi *p, enum texicmd cmd, 
Line 1128  dodisplay(struct texi *p, enum texicmd cmd, 
         const char *buf, size_t sz, size_t *pos)          const char *buf, size_t sz, size_t *pos)
 {  {
   
         teximacro(p, ".Bd -display");          teximacro(p, "Bd -display -offset indent");
         advanceeoln(p, buf, sz, pos, 1);          advanceeoln(p, buf, sz, pos, 1);
         parseto(p, buf, sz, pos, "display");          parseto(p, buf, sz, pos, "display");
         teximacro(p, ".Ed");          teximacro(p, "Ed");
 }  }
   
 static void  static void
Line 1186  doexample(struct texi *p, enum texicmd cmd, 
Line 1142  doexample(struct texi *p, enum texicmd cmd, 
   
         blk = TEXICMD_EXAMPLE == cmd ?  "example" : "smallexample";          blk = TEXICMD_EXAMPLE == cmd ?  "example" : "smallexample";
   
         teximacro(p, ".Bd -literal");          teximacro(p, "Bd -literal -offset indent");
         advanceeoln(p, buf, sz, pos, 1);          advanceeoln(p, buf, sz, pos, 1);
         p->literal++;          p->literal++;
         parseto(p, buf, sz, pos, blk);          parseto(p, buf, sz, pos, blk);
         p->literal--;          p->literal--;
         teximacro(p, ".Ed");          teximacro(p, "Ed");
 }  }
   
 static void  static void
Line 1251  dosymbol(struct texi *p, enum texicmd cmd, 
Line 1207  dosymbol(struct texi *p, enum texicmd cmd, 
         case (TEXICMD_HYPHEN):          case (TEXICMD_HYPHEN):
                 break;                  break;
         default:          default:
                   texiwarn(p, "sym: %d", cmd);
                 abort();                  abort();
         }          }
   
         doignbracket(p, cmd, buf, sz, pos);          if (texitoks[cmd].len > 1)
                   doignbracket(p, cmd, buf, sz, pos);
 }  }
   
 static void  static void
Line 1262  doquotation(struct texi *p, enum texicmd cmd, 
Line 1220  doquotation(struct texi *p, enum texicmd cmd, 
         const char *buf, size_t sz, size_t *pos)          const char *buf, size_t sz, size_t *pos)
 {  {
   
         teximacro(p, ".Qo");          teximacro(p, "Qo");
         parseto(p, buf, sz, pos, "quotation");          parseto(p, buf, sz, pos, "quotation");
         teximacro(p, ".Qc");          teximacro(p, "Qc");
 }  }
   
 /* FIXME */  /* FIXME */
Line 1308  static void
Line 1266  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);
         switch (cmd) {          switch (cmd) {
         case (TEXICMD_EMAIL):          case (TEXICMD_EMAIL):
                 if ( ! p->outmacro) {                  teximacroopen(p, "Mt");
                         open = 1;  
                         teximacroopen(p, ".");  
                 }  
                 texiputchars(p, "Lk ");  
                 break;                  break;
         case (TEXICMD_UREF):          case (TEXICMD_UREF):
         case (TEXICMD_URL):          case (TEXICMD_URL):
                 if ( ! p->outmacro) {                  teximacroopen(p, "Lk");
                         open = 1;  
                         teximacroopen(p, ".");  
                 }  
                 texiputchars(p, "Mt ");  
                 break;                  break;
         default:          default:
                 break;                  break;
Line 1348  doarg1(struct texi *p, enum texicmd cmd, 
Line 1297  doarg1(struct texi *p, enum texicmd cmd, 
                 texiputchar(p, buf[*pos]);                  texiputchar(p, buf[*pos]);
                 advance(p, buf, pos);                  advance(p, buf, pos);
         }          }
         if (open)          switch (cmd) {
           case (TEXICMD_EMAIL):
           case (TEXICMD_UREF):
           case (TEXICMD_URL):
                 teximacroclose(p);                  teximacroclose(p);
                   break;
           default:
                   break;
           }
 }  }
   
 static void  static void
Line 1357  dosubsection(struct texi *p, enum texicmd cmd, 
Line 1313  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)
 {  {
   
         teximacro(p, ".Pp");          teximacro(p, "Pp");
           teximacroopen(p, "Em");
         parseeoln(p, buf, sz, pos);          parseeoln(p, buf, sz, pos);
         teximacro(p, ".Pp");          teximacroclose(p);
           teximacro(p, "Pp");
 }  }
   
 static void  static void
Line 1372  dosection(struct texi *p, enum texicmd cmd, 
Line 1330  dosection(struct texi *p, enum texicmd cmd, 
         else if (p->literal)          else if (p->literal)
                 texierr(p, "subsection in a literal scope!?");                  texierr(p, "subsection in a literal scope!?");
   
         teximacroopen(p, ".Ss ");          teximacroopen(p, "Ss");
         parseeoln(p, buf, sz, pos);          parseeoln(p, buf, sz, pos);
         teximacroclose(p);          teximacroclose(p);
 }  }
Line 1382  dosp(struct texi *p, enum texicmd cmd, 
Line 1340  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)
 {  {
   
         teximacro(p, ".Pp");          teximacro(p, "Pp");
         advanceeoln(p, buf, sz, pos, 1);          advanceeoln(p, buf, sz, pos, 1);
 }  }
   
Line 1396  dochapter(struct texi *p, enum texicmd cmd, 
Line 1354  dochapter(struct texi *p, enum texicmd cmd, 
         else if (p->literal)          else if (p->literal)
                 texierr(p, "section in a literal scope!?");                  texierr(p, "section in a literal scope!?");
   
         teximacroopen(p, ".Sh ");          teximacroopen(p, "Sh");
         parseeoln(p, buf, sz, pos);          parseeoln(p, buf, sz, pos);
         teximacroclose(p);          teximacroclose(p);
 }  }
Line 1408  dotop(struct texi *p, enum texicmd cmd, 
Line 1366  dotop(struct texi *p, enum texicmd cmd, 
   
         p->ign--;          p->ign--;
         advanceeoln(p, buf, sz, pos, 1);          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");
         teximacro(p, ".Sh NAME");          teximacro(p, "Sh NAME");
         teximacro(p, ".Nm Something");          teximacro(p, "Nm Something");
         teximacro(p, ".Nd Something");          teximacro(p, "Nd Something");
 }  }
   
 static void  static void
Line 1428  doitem(struct texi *p, enum texicmd cmd, 
Line 1386  doitem(struct texi *p, enum texicmd cmd, 
   
         switch (p->list) {          switch (p->list) {
         case (TEXILIST_ITEM):          case (TEXILIST_ITEM):
                 teximacroopen(p, ".It");                  teximacroopen(p, "It");
                 break;                  break;
         case (TEXILIST_NOITEM):          case (TEXILIST_NOITEM):
                 teximacro(p, ".It");                  teximacro(p, "It");
                 break;                  break;
         default:          default:
                 teximacro(p, ".Pp");                  teximacro(p, "Pp");
                 break;                  break;
         }          }
   
Line 1453  dotable(struct texi *p, enum texicmd cmd, 
Line 1411  dotable(struct texi *p, enum texicmd cmd, 
         enum texilist   sv = p->list;          enum texilist   sv = p->list;
   
         p->list = TEXILIST_ITEM;          p->list = TEXILIST_ITEM;
         teximacro(p, ".Bl -tag -width Ds");          teximacro(p, "Bl -tag -width Ds");
         parseto(p, buf, sz, pos, "table");          parseto(p, buf, sz, pos, "table");
         teximacro(p, ".El");          teximacro(p, "El");
         p->list = sv;          p->list = sv;
 }  }
   
Line 1466  doenumerate(struct texi *p, enum texicmd cmd, 
Line 1424  doenumerate(struct texi *p, enum texicmd cmd, 
         enum texilist    sv = p->list;          enum texilist    sv = p->list;
   
         p->list = TEXILIST_NOITEM;          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;          p->list = sv;
 }  }
   
Line 1479  doitemize(struct texi *p, enum texicmd cmd, 
Line 1437  doitemize(struct texi *p, enum texicmd cmd, 
         enum texilist   sv = p->list;          enum texilist   sv = p->list;
   
         p->list = TEXILIST_ITEM;          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;          p->list = sv;
 }  }
   
Line 1503  doignline(struct texi *p, enum texicmd cmd, 
Line 1461  doignline(struct texi *p, enum texicmd cmd, 
         advanceeoln(p, buf, sz, pos, 1);          advanceeoln(p, buf, sz, pos, 1);
 }  }
   
   static char **
   parsedirs(const char *base, const char *cp, size_t *sz)
   {
           char             *tok, *str, *tofree;
           const char       *cpp;
           size_t            i;
           char            **dirs;
   
           *sz = NULL != (cpp = cp) ? 2 : 1;
           if (*sz > 1)
                   for ( ; NULL != (cpp = strchr(cpp, ':')); (*sz)++)
                           cpp++;
   
           dirs = calloc(*sz, sizeof(char *));
           if (NULL == dirs) {
                   perror(NULL);
                   exit(EXIT_FAILURE);
           } else if (NULL == (dirs[0] = strdup(base))) {
                   perror(NULL);
                   exit(EXIT_FAILURE);
           }
   
           if (NULL == cp)
                   return(dirs);
   
           if (NULL == (tofree = tok = str = strdup(cp))) {
                   perror(NULL);
                   exit(EXIT_FAILURE);
           }
   
           for (i = 1; NULL != (tok = strsep(&str, ":")); i++)
                   if (NULL == (dirs[i] = strdup(tok))) {
                           perror(NULL);
                           exit(EXIT_FAILURE);
                   }
   
           free(tofree);
           return(dirs);
   }
   
 int  int
 main(int argc, char *argv[])  main(int argc, char *argv[])
 {  {
         struct texi      texi;          struct texi      texi;
         int              c;          int              c;
         char            *path, *dir;          char            *path, *dir;
         const char      *progname;          const char      *progname, *Idir;
   
         progname = strrchr(argv[0], '/');          progname = strrchr(argv[0], '/');
         if (progname == NULL)          if (progname == NULL)
Line 1517  main(int argc, char *argv[])
Line 1515  main(int argc, char *argv[])
         else          else
                 ++progname;                  ++progname;
   
         while (-1 != (c = getopt(argc, argv, "")))          Idir = NULL;
           while (-1 != (c = getopt(argc, argv, "I:")))
                 switch (c) {                  switch (c) {
                   case ('I'):
                           Idir = optarg;
                           break;
                 default:                  default:
                         goto usage;                          goto usage;
                 }                  }
Line 1539  main(int argc, char *argv[])
Line 1541  main(int argc, char *argv[])
   
         memset(&texi, 0, sizeof(struct texi));          memset(&texi, 0, sizeof(struct texi));
         texi.ign = 1;          texi.ign = 1;
         texi.dir = strdup(dir);          texi.dirs = parsedirs(dir, Idir, &texi.dirsz);
         parsefile(&texi, argv[0]);          parsefile(&texi, argv[0]);
           /* We shouldn't get here. */
         texiexit(&texi);          texiexit(&texi);
         return(EXIT_FAILURE);          return(EXIT_FAILURE);
 usage:  usage:
Legend:
Removed from v.1.4  
changed lines
  Added in v.1.5
CVSweb