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

Diff for /texi2mdoc/main.c between version 1.8 and 1.11

version 1.8, 2015/02/18 12:03:21 version 1.11, 2015/02/18 16:35:49
Line 27 
Line 27 
 #include <stdio.h>  #include <stdio.h>
 #include <stdlib.h>  #include <stdlib.h>
 #include <string.h>  #include <string.h>
   #include <time.h>
 #include <unistd.h>  #include <unistd.h>
   
 /*  /*
Line 135  enum texicmd {
Line 136  enum texicmd {
         TEXICMD_UREF,          TEXICMD_UREF,
         TEXICMD_URL,          TEXICMD_URL,
         TEXICMD_VAR,          TEXICMD_VAR,
           TEXICMD_VSKIP,
         TEXICMD_W,          TEXICMD_W,
         TEXICMD_XREF,          TEXICMD_XREF,
         TEXICMD__MAX          TEXICMD__MAX
Line 185  struct texi {
Line 187  struct texi {
         size_t            outcol; /* column in output line */          size_t            outcol; /* column in output line */
         char            **dirs; /* texi directories */          char            **dirs; /* texi directories */
         size_t            dirsz; /* number of 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) */          enum texilist     list; /* current list (set recursively) */
         int               outmacro; /* if >0, output is in line macro */          int               outmacro; /* if >0, output is in line macro */
         int               seenws; /* ws has been seen (and ignored) */          int               seenws; /* ws has been seen (and ignored) */
           int               seenvs; /* newline has been Pp'd */
         int               ign; /* if >0, don't print anything */          int               ign; /* if >0, don't print anything */
         int               literal; /* if >0, literal context */          int               literal; /* if >0, literal context */
 };  };
   
 /* FIXME: FIND A BETTER WAY. */  
 #define ismpunct(_x) \  
         ('.' == (_x) || \  
          ',' == (_x) || \  
          ';' == (_x))  
 /* Texi disregards spaces and tabs. */  /* Texi disregards spaces and tabs. */
 #define isws(_x) \  #define isws(_x) \
         (' ' == (_x) || '\t' == (_x))          (' ' == (_x) || '\t' == (_x))
   #define ismspace(_x) \
           (isws((_x)) || '\n' == (_x))
   
 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 *);
Line 232  static void dosection(struct texi *, enum texicmd, con
Line 238  static void dosection(struct texi *, enum texicmd, con
 static  void dosp(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void dosp(struct texi *, enum texicmd, const char *, size_t, size_t *);
 static  void dosubsection(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void dosubsection(struct texi *, enum texicmd, const char *, size_t, size_t *);
 static  void dosymbol(struct texi *, enum texicmd, const char *, size_t, size_t *);  static  void dosymbol(struct texi *, enum texicmd, const char *, size_t, size_t *);
   static  void dotitle(struct texi *, enum texicmd, const char *, size_t, size_t *);
   
 static  const struct texitok texitoks[TEXICMD__MAX] = {  static  const struct texitok texitoks[TEXICMD__MAX] = {
         { doignargn, "acronym", 7 }, /* TEXICMD_ACRONYM */          { doignargn, "acronym", 7 }, /* TEXICMD_ACRONYM */
Line 312  static const struct texitok texitoks[TEXICMD__MAX] = {
Line 319  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 */          { dotitle, "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 */
Line 334  static const struct texitok texitoks[TEXICMD__MAX] = {
Line 341  static const struct texitok texitoks[TEXICMD__MAX] = {
         { dolink, "uref", 4 }, /* TEXICMD_UREF */          { dolink, "uref", 4 }, /* TEXICMD_UREF */
         { dolink, "url", 3 }, /* TEXICMD_URL */          { dolink, "url", 3 }, /* TEXICMD_URL */
         { doliteral, "var", 3 }, /* TEXICMD_VAR */          { doliteral, "var", 3 }, /* TEXICMD_VAR */
           { dosp, "vskip", 5 }, /* TEXICMD_VSKIP */
         { dobracket, "w", 1 }, /* TEXICMD_W */          { dobracket, "w", 1 }, /* TEXICMD_W */
         { dolink, "xref", 4 }, /* TEXICMD_XREF */          { dolink, "xref", 4 }, /* TEXICMD_XREF */
 };  };
Line 369  texiexit(struct texi *p)
Line 377  texiexit(struct texi *p)
   
         for (i = 0; i < p->dirsz; i++)          for (i = 0; i < p->dirsz; i++)
                 free(p->dirs[i]);                  free(p->dirs[i]);
   
         free(p->dirs);          free(p->dirs);
           free(p->subtitle);
           free(p->title);
 }  }
   
 /*  /*
Line 436  texiputchar(struct texi *p, char c)
Line 447  texiputchar(struct texi *p, char c)
         if (p->ign)          if (p->ign)
                 return;                  return;
         putchar(c);          putchar(c);
           p->seenvs = 0;
         if ('\n' == c) {          if ('\n' == c) {
                 p->outcol = 0;                  p->outcol = 0;
                 p->seenws = 0;                  p->seenws = 0;
Line 508  teximacro(struct texi *p, const char *s)
Line 520  teximacro(struct texi *p, const char *s)
         texiputchar(p, '\n');          texiputchar(p, '\n');
 }  }
   
   static void
   texivspace(struct texi *p)
   {
   
           if (p->seenvs)
                   return;
           teximacro(p, "Pp");
           p->seenvs = 1;
   }
   
 /*  /*
  * Advance by a single byte in the input stream.   * Advance by a single byte in the input stream.
  */   */
Line 524  advance(struct texi *p, const char *buf, size_t *pos)
Line 546  advance(struct texi *p, const char *buf, size_t *pos)
         (*pos)++;          (*pos)++;
 }  }
   
   static void
   texipunctuate(struct texi *p, const char *buf, size_t sz, size_t *pos)
   {
           size_t   start, end;
   
           if (1 != p->outmacro)
                   return;
   
           for (start = end = *pos; end < sz; end++) {
                   switch (buf[end]) {
                   case (','):
                   case (')'):
                   case ('.'):
                   case ('"'):
                   case (':'):
                   case ('!'):
                   case ('?'):
                           continue;
                   default:
                           break;
                   }
                   break;
           }
           if (end == *pos)
                   return;
           if (end + 1 == sz || ' ' == buf[end] || '\n' == buf[end]) {
                   for ( ; start < end; start++) {
                           texiputchar(p, ' ');
                           texiputchar(p, buf[start]);
                           advance(p, buf, pos);
                   }
           }
   }
   
 /*  /*
  * Advance to the next non-whitespace word in the input stream.   * Advance to the next non-whitespace word in the input stream.
  * If we're in literal mode, then print all of the whitespace as we're   * If we're in literal mode, then print all of the whitespace as we're
Line 534  advancenext(struct texi *p, const char *buf, size_t sz
Line 590  advancenext(struct texi *p, const char *buf, size_t sz
 {  {
   
         if (p->literal) {          if (p->literal) {
                 while (*pos < sz && isspace(buf[*pos])) {                  while (*pos < sz && ismspace(buf[*pos])) {
                         if (*pos && '\n' == buf[*pos] &&                          if (*pos && '\n' == buf[*pos] &&
                                 '\\' == buf[*pos - 1])                                  '\\' == buf[*pos - 1])
                                 texiputchar(p, 'e');                                  texiputchar(p, 'e');
Line 544  advancenext(struct texi *p, const char *buf, size_t sz
Line 600  advancenext(struct texi *p, const char *buf, size_t sz
                 return(*pos);                  return(*pos);
         }          }
   
         while (*pos < sz && isspace(buf[*pos])) {          while (*pos < sz && ismspace(buf[*pos])) {
                 p->seenws = 1;                  p->seenws = 1;
                 /*                  /*
                  * If it looks like we've printed a double-line, then                   * If it looks like we've printed a double-line, then
                  * output a paragraph.                   * output a paragraph.
                  * FIXME: this is stupid.                   * FIXME: this is stupid.
                  */                   */
                 if (*pos && '\n' == buf[*pos] &&                  if (*pos && '\n' == buf[*pos] && '\n' == buf[*pos - 1])
                         '\n' == buf[*pos - 1])                          texivspace(p);
                         teximacro(p, "Pp");  
                 advance(p, buf, pos);                  advance(p, buf, pos);
         }          }
         return(*pos);          return(*pos);
Line 606  texiword(struct texi *p, const char *buf, 
Line 661  texiword(struct texi *p, const char *buf, 
   
         p->seenws = 0;          p->seenws = 0;
   
         while (*pos < sz && ! isspace(buf[*pos])) {          while (*pos < sz && ! ismspace(buf[*pos])) {
                 switch (buf[*pos]) {                  switch (buf[*pos]) {
                 case ('@'):                  case ('@'):
                 case ('}'):                  case ('}'):
Line 644  texicmd(struct texi *p, const char *buf, 
Line 699  texicmd(struct texi *p, const char *buf, 
   
         assert('@' == buf[pos]);          assert('@' == buf[pos]);
   
         if (++pos >= sz)          if ((*end = pos) == sz)
                 return(TEXICMD__MAX);                  return(TEXICMD__MAX);
           else if ((*end = ++pos) == sz)
                   return(TEXICMD__MAX);
   
         /* Alphabetic commands are special. */          /* Alphabetic commands are special. */
         if ( ! isalpha(buf[pos])) {          if ( ! isalpha(buf[pos])) {
                 *end = pos + 1;                  if ((*end = pos + 1) == sz)
                           return(TEXICMD__MAX);
                 for (i = 0; i < TEXICMD__MAX; i++) {                  for (i = 0; i < TEXICMD__MAX; i++) {
                         if (1 != texitoks[i].len)                          if (1 != texitoks[i].len)
                                 continue;                                  continue;
Line 660  texicmd(struct texi *p, const char *buf, 
Line 718  texicmd(struct texi *p, const char *buf, 
                 return(TEXICMD__MAX);                  return(TEXICMD__MAX);
         }          }
   
         for (*end = pos; *end < sz && ! isspace(buf[*end]); (*end)++)          for (*end = pos; *end < sz && ! ismspace(buf[*end]); (*end)++)
                 if ((*end > pos && ('@' == buf[*end] ||                  if ((*end > pos && ('@' == buf[*end] ||
                           '{' == buf[*end] || '}' == buf[*end])))                            '{' == buf[*end] || '}' == buf[*end])))
                         break;                          break;
Line 692  parsearg(struct texi *p, const char *buf, 
Line 750  parsearg(struct texi *p, const char *buf, 
         size_t           end;          size_t           end;
         enum texicmd     cmd;          enum texicmd     cmd;
   
         while (*pos < sz && isspace(buf[*pos]))          while (*pos < sz && ismspace(buf[*pos]))
                 advance(p, buf, pos);                  advance(p, buf, pos);
         if (*pos == sz || (0 == num && '{' != buf[*pos]))          if (*pos == sz || (0 == num && '{' != buf[*pos]))
                 return(0);                  return(0);
Line 739  parsebracket(struct texi *p, const char *buf, size_t s
Line 797  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]))          while (*pos < sz && ismspace(buf[*pos]))
                 advance(p, buf, pos);                  advance(p, buf, pos);
   
         if (*pos == sz || '{' != buf[*pos])          if (*pos == sz || '{' != buf[*pos])
Line 977  dodeftypevar(struct texi *p, enum texicmd cmd, 
Line 1035  dodeftypevar(struct texi *p, enum texicmd cmd, 
                 return;                  return;
         }          }
   
         teximacro(p, "Pp");          texivspace(p);
         if (TEXICMD_DEFTYPEVR == cmd) {          if (TEXICMD_DEFTYPEVR == cmd) {
                 parsebracket(p, buf, sz, pos);                  parsebracket(p, buf, sz, pos);
                 texiputchars(p, ":\n");                  texiputchars(p, ":\n");
Line 985  dodeftypevar(struct texi *p, enum texicmd cmd, 
Line 1043  dodeftypevar(struct texi *p, enum texicmd cmd, 
         teximacroopen(p, "Vt");          teximacroopen(p, "Vt");
         parseeoln(p, buf, sz, pos);          parseeoln(p, buf, sz, pos);
         teximacroclose(p);          teximacroclose(p);
         teximacro(p, "Pp");          texivspace(p);
         parseto(p, buf, sz, pos, blk);          parseto(p, buf, sz, pos, blk);
 }  }
   
Line 1014  dodeftypefun(struct texi *p, enum texicmd cmd, 
Line 1072  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");                  texivspace(p);
                 break;                  break;
         default:          default:
                 break;                  break;
Line 1033  dodeftypefun(struct texi *p, enum texicmd cmd, 
Line 1091  dodeftypefun(struct texi *p, enum texicmd cmd, 
         teximacroopen(p, "Li");          teximacroopen(p, "Li");
         parseeoln(p, buf, sz, pos);          parseeoln(p, buf, sz, pos);
         teximacroclose(p);          teximacroclose(p);
         teximacro(p, "Pp");          texivspace(p);
         if (NULL != blk)          if (NULL != blk)
                 parseto(p, buf, sz, pos, blk);                  parseto(p, buf, sz, pos, blk);
 }  }
Line 1064  doinline(struct texi *p, const char *buf, 
Line 1122  doinline(struct texi *p, const char *buf, 
         teximacroopen(p, macro);          teximacroopen(p, macro);
         p->seenws = 0;          p->seenws = 0;
         parsebracket(p, buf, sz, pos);          parsebracket(p, buf, sz, pos);
         if (*pos < sz - 1 &&          texipunctuate(p, buf, sz, pos);
                  ismpunct(buf[*pos]) &&  
                  isspace(buf[*pos + 1])) {  
                 texiputchar(p, ' ');  
                 texiputchar(p, buf[*pos]);  
                 advance(p, buf, pos);  
         }  
         teximacroclose(p);          teximacroclose(p);
 }  }
   
Line 1197  dodisplay(struct texi *p, enum texicmd cmd, 
Line 1249  dodisplay(struct texi *p, enum texicmd cmd, 
 {  {
   
         teximacro(p, "Bd -display -offset indent");          teximacro(p, "Bd -display -offset indent");
           p->seenvs = 1;
         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");
Line 1228  dobye(struct texi *p, enum texicmd cmd, 
Line 1281  dobye(struct texi *p, enum texicmd cmd, 
 }  }
   
 static void  static void
   dotitle(struct texi *p, enum texicmd cmd,
           const char *buf, size_t sz, size_t *pos)
   {
           size_t   start, end;
   
           while (*pos < sz && isws(buf[*pos]))
                   advance(p, buf, pos);
           start = end = *pos;
           while (end < sz && '\n' != buf[end])
                   end++;
           free(p->subtitle);
           p->subtitle = malloc(end - start + 1);
           memcpy(p->subtitle, &buf[start], end - start);
           p->subtitle[end - start] = '\0';
   }
   
   static void
 dosymbol(struct texi *p, enum texicmd cmd,  dosymbol(struct texi *p, enum texicmd cmd,
         const char *buf, size_t sz, size_t *pos)          const char *buf, size_t sz, size_t *pos)
 {  {
Line 1363  dolink(struct texi *p, enum texicmd cmd, 
Line 1433  dolink(struct texi *p, enum texicmd cmd, 
                 c = parsearg(p, buf, sz, pos, 1);                  c = parsearg(p, buf, sz, pos, 1);
         p->ign--;          p->ign--;
   
         if (*pos < sz - 1 &&          texipunctuate(p, buf, sz, pos);
                  ismpunct(buf[*pos]) &&  
                  isspace(buf[*pos + 1])) {  
                 texiputchar(p, ' ');  
                 texiputchar(p, buf[*pos]);  
                 advance(p, buf, pos);  
         }  
   
         teximacroclose(p);          teximacroclose(p);
 }  }
   
Line 1392  dosubsection(struct texi *p, enum texicmd cmd, 
Line 1455  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");          texivspace(p);
         teximacroopen(p, "Em");          teximacroopen(p, "Em");
         parseeoln(p, buf, sz, pos);          parseeoln(p, buf, sz, pos);
         teximacroclose(p);          teximacroclose(p);
         teximacro(p, "Pp");          texivspace(p);
 }  }
   
 static void  static void
Line 1412  dosection(struct texi *p, enum texicmd cmd, 
Line 1475  dosection(struct texi *p, enum texicmd cmd, 
         teximacroopen(p, "Ss");          teximacroopen(p, "Ss");
         parseeoln(p, buf, sz, pos);          parseeoln(p, buf, sz, pos);
         teximacroclose(p);          teximacroclose(p);
           p->seenvs = 1;
 }  }
   
 static void  static void
Line 1419  dosp(struct texi *p, enum texicmd cmd, 
Line 1483  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");          texivspace(p);
         advanceeoln(p, buf, sz, pos, 1);          advanceeoln(p, buf, sz, pos, 1);
 }  }
   
Line 1436  dochapter(struct texi *p, enum texicmd cmd, 
Line 1500  dochapter(struct texi *p, enum texicmd cmd, 
         teximacroopen(p, "Sh");          teximacroopen(p, "Sh");
         parseeoln(p, buf, sz, pos);          parseeoln(p, buf, sz, pos);
         teximacroclose(p);          teximacroclose(p);
           p->seenvs = 1;
 }  }
   
 static void  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)
 {  {
           const char      *cp;
           time_t           t;
           char             date[32];
   
           t = time(NULL);
           strftime(date, sizeof(date), "%F", localtime(&t));
   
         p->ign--;          p->ign--;
         advanceeoln(p, buf, sz, pos, 1);          teximacroopen(p, "Dd");
         teximacro(p, "Dd $Mdocdate$");          texiputchars(p, date);
         teximacro(p, "Dt SOMETHING 7");          teximacroclose(p);
           teximacroopen(p, "Dt");
           for (cp = p->title; '\0' != *cp; cp++)
                   texiputchar(p, toupper(*cp));
           texiputchars(p, " 7");
           teximacroclose(p);
         teximacro(p, "Os");          teximacro(p, "Os");
         teximacro(p, "Sh NAME");          teximacro(p, "Sh NAME");
         teximacro(p, "Nm Something");          teximacroopen(p, "Nm");
         teximacro(p, "Nd Something");          texiputchars(p, p->title);
           teximacroclose(p);
           teximacroopen(p, "Nd");
           texiputchars(p, NULL != p->subtitle ?
                   p->subtitle : "Unknown description");
           teximacroclose(p);
           p->seenvs = 1;
           dochapter(p, cmd, buf, sz, pos);
 }  }
   
 static void  static void
Line 1471  doitem(struct texi *p, enum texicmd cmd, 
Line 1554  doitem(struct texi *p, enum texicmd cmd, 
                 teximacro(p, "It");                  teximacro(p, "It");
                 break;                  break;
         default:          default:
                 teximacro(p, "Pp");                  texivspace(p);
                 break;                  break;
         }          }
           p->seenvs = 1;
   
         parseeoln(p, buf, sz, pos);          parseeoln(p, buf, sz, pos);
   
         if (TEXILIST_ITEM == p->list)          if (TEXILIST_ITEM == p->list)
                 teximacroclose(p);                  teximacroclose(p);
         else          else if (p->outcol > 0)
                 texiputchar(p, '\n');                  texiputchar(p, '\n');
 }  }
   
Line 1491  dotable(struct texi *p, enum texicmd cmd, 
Line 1575  dotable(struct texi *p, enum texicmd cmd, 
   
         p->list = TEXILIST_ITEM;          p->list = TEXILIST_ITEM;
         teximacro(p, "Bl -tag -width Ds");          teximacro(p, "Bl -tag -width Ds");
           p->seenvs = 1;
         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 1504  doenumerate(struct texi *p, enum texicmd cmd, 
Line 1589  doenumerate(struct texi *p, enum texicmd cmd, 
   
         p->list = TEXILIST_NOITEM;          p->list = TEXILIST_NOITEM;
         teximacro(p, "Bl -enum");          teximacro(p, "Bl -enum");
           p->seenvs = 1;
         parseto(p, buf, sz, pos, "enumerate");          parseto(p, buf, sz, pos, "enumerate");
         teximacro(p, "El");          teximacro(p, "El");
         p->list = sv;          p->list = sv;
Line 1517  doitemize(struct texi *p, enum texicmd cmd, 
Line 1603  doitemize(struct texi *p, enum texicmd cmd, 
   
         p->list = TEXILIST_ITEM;          p->list = TEXILIST_ITEM;
         teximacro(p, "Bl -bullet");          teximacro(p, "Bl -bullet");
           p->seenvs = 1;
         parseto(p, buf, sz, pos, "itemize");          parseto(p, buf, sz, pos, "itemize");
         teximacro(p, "El");          teximacro(p, "El");
         p->list = sv;          p->list = sv;
Line 1592  main(int argc, char *argv[])
Line 1679  main(int argc, char *argv[])
         struct texi      texi;          struct texi      texi;
         int              c;          int              c;
         char            *path, *dir;          char            *path, *dir;
         const char      *progname, *Idir;          const char      *progname, *Idir, *cp;
   
         progname = strrchr(argv[0], '/');          progname = strrchr(argv[0], '/');
         if (progname == NULL)          if (progname == NULL)
Line 1600  main(int argc, char *argv[])
Line 1687  main(int argc, char *argv[])
         else          else
                 ++progname;                  ++progname;
   
           memset(&texi, 0, sizeof(struct texi));
         Idir = NULL;          Idir = NULL;
   
         while (-1 != (c = getopt(argc, argv, "I:")))          while (-1 != (c = getopt(argc, argv, "I:")))
                 switch (c) {                  switch (c) {
                 case ('I'):                  case ('I'):
Line 1624  main(int argc, char *argv[])
Line 1713  main(int argc, char *argv[])
         }          }
         free(path);          free(path);
   
         memset(&texi, 0, sizeof(struct texi));          if (NULL != (cp = strrchr(argv[0], '/')))
                   texi.title = strdup(cp + 1);
           else
                   texi.title = strdup(argv[0]);
   
           if (NULL == texi.title) {
                   perror(NULL);
                   exit(EXIT_FAILURE);
           } else if (NULL != (path = strchr(texi.title, '.')))
                   *path = '\0';
   
         texi.ign = 1;          texi.ign = 1;
         texi.dirs = parsedirs(dir, Idir, &texi.dirsz);          texi.dirs = parsedirs(dir, Idir, &texi.dirsz);
         parsefile(&texi, argv[0]);          parsefile(&texi, argv[0]);
Legend:
Removed from v.1.8  
changed lines
  Added in v.1.11
CVSweb