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

Diff for /texi2mdoc/main.c between version 1.67 and 1.68

version 1.67, 2015/03/12 04:24:19 version 1.68, 2015/03/12 10:44:34
Line 134  static const struct texitok __texitoks[TEXICMD__MAX] =
Line 134  static const struct texitok __texitoks[TEXICMD__MAX] =
         { dodefindex, "defindex", 8 }, /* TEXICMD_DEFINDEX */          { dodefindex, "defindex", 8 }, /* TEXICMD_DEFINDEX */
         { dodefn, "defmac", 6 }, /* TEXICMD_DEFMAC */          { dodefn, "defmac", 6 }, /* TEXICMD_DEFMAC */
         { dodefn, "defmacx", 7 }, /* TEXICMD_DEFMACX */          { dodefn, "defmacx", 7 }, /* TEXICMD_DEFMACX */
           { dodefn, "defop", 5 }, /* TEXICMD_DEFOP */
           { dodefn, "defopx", 6 }, /* TEXICMD_DEFOPX */
           { dodefn, "defopt", 6 }, /* TEXICMD_DEFOPT */
           { dodefn, "defoptx", 7 }, /* TEXICMD_DEFOPTX */
         { dodefn, "deftp", 5 }, /* TEXICMD_DEFTP */          { dodefn, "deftp", 5 }, /* TEXICMD_DEFTP */
         { dodefn, "deftpx", 6 }, /* TEXICMD_DEFTPX */          { dodefn, "deftpx", 6 }, /* TEXICMD_DEFTPX */
         { dodefn, "deftypefn", 9 }, /* TEXICMD_DEFTYPEFN */          { dodefn, "deftypefn", 9 }, /* TEXICMD_DEFTYPEFN */
Line 152  static const struct texitok __texitoks[TEXICMD__MAX] =
Line 156  static const struct texitok __texitoks[TEXICMD__MAX] =
         { dodefn, "defvarx", 7 }, /* TEXICMD_DEFVARX */          { dodefn, "defvarx", 7 }, /* TEXICMD_DEFVARX */
         { dodefn, "defvr", 5 }, /* TEXICMD_DEFVR */          { dodefn, "defvr", 5 }, /* TEXICMD_DEFVR */
         { dodefn, "defvrx", 6 }, /* TEXICMD_DEFVRX */          { dodefn, "defvrx", 6 }, /* TEXICMD_DEFVRX */
         { domenu, "detailmenu", 10 }, /* TEXICMD_DETAILMENU */          { doignblock, "detailmenu", 10 }, /* TEXICMD_DETAILMENU */
         { doinline, "dfn", 3 }, /* TEXICMD_DFN */          { doinline, "dfn", 3 }, /* TEXICMD_DFN */
         { dosymbol, "DH", 2 }, /* TEXICMD_DH */          { dosymbol, "DH", 2 }, /* TEXICMD_DH */
         { dosymbol, "dh", 2 }, /* TEXICMD_DHSMALL */          { dosymbol, "dh", 2 }, /* TEXICMD_DHSMALL */
Line 393  dodefn(struct texi *p, enum texicmd cmd, size_t *pos)
Line 397  dodefn(struct texi *p, enum texicmd cmd, size_t *pos)
         switch (cmd) {          switch (cmd) {
         case (TEXICMD_DEFFN):          case (TEXICMD_DEFFN):
         case (TEXICMD_DEFMAC):          case (TEXICMD_DEFMAC):
           case (TEXICMD_DEFOP):
           case (TEXICMD_DEFOPT):
         case (TEXICMD_DEFTP):          case (TEXICMD_DEFTP):
         case (TEXICMD_DEFTYPEFN):          case (TEXICMD_DEFTYPEFN):
         case (TEXICMD_DEFTYPEFUN):          case (TEXICMD_DEFTYPEFUN):
Line 429  dodefn(struct texi *p, enum texicmd cmd, size_t *pos)
Line 435  dodefn(struct texi *p, enum texicmd cmd, size_t *pos)
         case (TEXICMD_DEFMACX):          case (TEXICMD_DEFMACX):
                 texiputchars(p, "Macro");                  texiputchars(p, "Macro");
                 break;                  break;
           case (TEXICMD_DEFOPT):
           case (TEXICMD_DEFOPTX):
                   texiputchars(p, "User Option");
                   break;
         case (TEXICMD_DEFTYPEVAR):          case (TEXICMD_DEFTYPEVAR):
         case (TEXICMD_DEFTYPEVARX):          case (TEXICMD_DEFTYPEVARX):
         case (TEXICMD_DEFVAR):          case (TEXICMD_DEFVAR):
Line 471  dodefn(struct texi *p, enum texicmd cmd, size_t *pos)
Line 481  dodefn(struct texi *p, enum texicmd cmd, size_t *pos)
                 teximacroclose(p);                  teximacroclose(p);
                 teximacro(p, "Fc");                  teximacro(p, "Fc");
                 break;                  break;
           case (TEXICMD_DEFOP):
           case (TEXICMD_DEFOPX):
         case (TEXICMD_DEFTYPEFUN):          case (TEXICMD_DEFTYPEFUN):
         case (TEXICMD_DEFTYPEFUNX):          case (TEXICMD_DEFTYPEFUNX):
         case (TEXICMD_DEFTYPEFN):          case (TEXICMD_DEFTYPEFN):
Line 500  dodefn(struct texi *p, enum texicmd cmd, size_t *pos)
Line 512  dodefn(struct texi *p, enum texicmd cmd, size_t *pos)
                         /* Spin. */ ;                          /* Spin. */ ;
                 teximacroclose(p);                  teximacroclose(p);
                 break;                  break;
           case (TEXICMD_DEFOPT):
           case (TEXICMD_DEFOPTX):
         case (TEXICMD_DEFVAR):          case (TEXICMD_DEFVAR):
         case (TEXICMD_DEFVARX):          case (TEXICMD_DEFVARX):
         case (TEXICMD_DEFVR):          case (TEXICMD_DEFVR):
Line 531  dodefn(struct texi *p, enum texicmd cmd, size_t *pos)
Line 545  dodefn(struct texi *p, enum texicmd cmd, size_t *pos)
                 switch (peekcmd(p, *pos)) {                  switch (peekcmd(p, *pos)) {
                 case (TEXICMD_DEFFNX):                  case (TEXICMD_DEFFNX):
                 case (TEXICMD_DEFMACX):                  case (TEXICMD_DEFMACX):
                   case (TEXICMD_DEFOPX):
                   case (TEXICMD_DEFOPTX):
                 case (TEXICMD_DEFTPX):                  case (TEXICMD_DEFTPX):
                 case (TEXICMD_DEFTYPEFNX):                  case (TEXICMD_DEFTYPEFNX):
                 case (TEXICMD_DEFTYPEFUNX):                  case (TEXICMD_DEFTYPEFUNX):
Line 662  doignblock(struct texi *p, enum texicmd cmd, size_t *p
Line 678  doignblock(struct texi *p, enum texicmd cmd, size_t *p
                 "@%s", texitoks[cmd].tok);                  "@%s", texitoks[cmd].tok);
         assert(ssz < sizeof(start));          assert(ssz < sizeof(start));
         esz = snprintf(end, sizeof(end),          esz = snprintf(end, sizeof(end),
                 "@end %s\n", texitoks[cmd].tok);                  "@end %s", texitoks[cmd].tok);
         assert(esz < sizeof(end));          assert(esz < sizeof(end));
         stack = 1;          stack = 1;
   
Line 846  docopying(struct texi *p, enum texicmd cmd, size_t *po
Line 862  docopying(struct texi *p, enum texicmd cmd, size_t *po
         }          }
   
         term = memmem(&BUF(p)[*pos], BUFSZ(p) - *pos, end, endsz);          term = memmem(&BUF(p)[*pos], BUFSZ(p) - *pos, end, endsz);
         if (NULL == term) {          if (NULL == term)
                 texiwarn(p, "unterminated \"%s\"", texitoks[cmd].tok);                  texierr(p, "unterminated \"%s\"", texitoks[cmd].tok);
                 endpos = BUFSZ(p);          else
         } else  
                 endpos = *pos + (size_t)(term - &BUF(p)[*pos]);                  endpos = *pos + (size_t)(term - &BUF(p)[*pos]);
   
         assert(endpos <= BUFSZ(p));          if (endpos == *pos) {
                   advanceeoln(p, pos, 1);
                   return;
           }
   
           assert(endpos < BUFSZ(p) && endpos > *pos);
         assert('\n' == BUF(p)[*pos]);          assert('\n' == BUF(p)[*pos]);
         advance(p, pos);          advance(p, pos);
   
           if (*pos == BUFSZ(p)) {
                   texiwarn(p, "unterminated \"%s\"", texitoks[cmd].tok);
                   return;
           }
   
         p->copying = malloc(endpos - *pos + 1);          p->copying = malloc(endpos - *pos + 1);
         p->copyingsz = endpos - *pos;          p->copyingsz = endpos - *pos;
         memcpy(p->copying, &BUF(p)[*pos], p->copyingsz);          memcpy(p->copying, &BUF(p)[*pos], p->copyingsz);
Line 1487  doprintindex(struct texi *p, enum texicmd cmd, size_t 
Line 1512  doprintindex(struct texi *p, enum texicmd cmd, size_t 
         size_t   i, j, start, end, len;          size_t   i, j, start, end, len;
 #if HAVE_INDEX  #if HAVE_INDEX
         char    *cp;          char    *cp;
           char     buf[PATH_MAX];
 #endif  #endif
   
         while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))          while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
Line 1535  doprintindex(struct texi *p, enum texicmd cmd, size_t 
Line 1561  doprintindex(struct texi *p, enum texicmd cmd, size_t 
                         texiputchars(p, "\"idx");                          texiputchars(p, "\"idx");
                         texiputchars(p, p->indexs[i].name);                          texiputchars(p, p->indexs[i].name);
                         cp = p->indexs[i].index[j].term;                          cp = p->indexs[i].index[j].term;
                         while ('\n' != *cp) {                          while ('\n' != *cp)
                                 assert('\0' != *cp);  
                                 texiputchar(p, *cp++);                                  texiputchar(p, *cp++);
                         }  
                         texiputchars(p, "\" \"");                          texiputchars(p, "\" \"");
                         p->literal++;                          p->literal++;
                 } else {                  } else {
                         teximacroopen(p, "Xr");                          teximacroopen(p, "Xr");
                         texiputchars(p, p->nodes[p->indexs[i].index[j].chapter]);                          snprintf(buf, sizeof(buf), "%s-%zd 7 \"idx",
                         texiputchars(p, " 7 \"idx");                                  p->chapters, p->indexs[i].index[j].chapter);
                           texiputchars(p, buf);
                         texiputchars(p, p->indexs[i].name);                          texiputchars(p, p->indexs[i].name);
                         cp = p->indexs[i].index[j].term;                          cp = p->indexs[i].index[j].term;
                         while ('\n' != *cp) {                          while ('\n' != *cp)
                                 assert('\0' != *cp);  
                                 texiputchar(p, *cp++);                                  texiputchar(p, *cp++);
                         }  
                         texiputchars(p, "\" \"");                          texiputchars(p, "\" \"");
                         p->literal++;                          p->literal++;
                 }                  }
Line 1574  static void
Line 1597  static void
 donode(struct texi *p, enum texicmd cmd, size_t *pos)  donode(struct texi *p, enum texicmd cmd, size_t *pos)
 {  {
         int      sv = p->seenvs;          int      sv = p->seenvs;
           char     fname[PATH_MAX];
           size_t   end, start;
   
         if (NULL != p->chapters) {          if (0 == p->nodesz++)
                 advanceeoln(p, pos, 1);                  p->ign--;
                 if (0 == p->chapnum)  
                         p->ign--;          /* Grab our node name. */
           while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
                   advance(p, pos);
           start = *pos;
           while (*pos < BUFSZ(p)) {
                   if (BUF(p)[*pos] == ',')
                           break;
                   else if (BUF(p)[*pos] == '\n')
                           break;
                   advance(p, pos);
           }
           if (*pos == BUFSZ(p)) {
                   texiwarn(p, "unexpected EOF");
                   return;
           }
           end = *pos;
           advanceeoln(p, pos, 1);
   
           if (NULL != p->chapters)
                 teximdocclose(p, 0);                  teximdocclose(p, 0);
   
           /* Cache our node name. */
           p->nodecur = texicache(p, &BUF(p)[start], end - start);
   
           if (NULL != p->chapters) {
                   snprintf(fname, sizeof(fname),
                           "%s-%zd.7", p->chapters, p->nodecur);
                   p->outfile = fopen(fname, "w");
                   if (NULL == p->outfile)
                           texiabort(p, fname);
                 teximdocopen(p, pos);                  teximdocopen(p, pos);
         } else {          } else if (p->nodesz > 1) {
 #if HAVE_INDEX                  /* Otherwise, mark our index. */
                 p->seenvs = -1;                  p->seenvs = -1;
   #if HAVE_INDEX
                 teximacroopen(p, "Ix");                  teximacroopen(p, "Ix");
                 texiputchars(p, "node");                  texiputchars(p, "node");
                 while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))                  texiputchars(p, p->nodecache[p->nodecur].name);
                         advance(p, pos);  
                 while (*pos < BUFSZ(p)) {  
                         if (BUF(p)[*pos] == ',')  
                                 break;  
                         else if (BUF(p)[*pos] == '\n')  
                                 break;  
                         texiputchar(p, BUF(p)[*pos]);  
                         advance(p, pos);  
                 }  
                 teximacroclose(p);                  teximacroclose(p);
 #endif  #endif
                 advanceeoln(p, pos, 1);  
                 p->seenvs = sv;                  p->seenvs = sv;
         }          } else
                   teximdocopen(p, pos);
 }  }
   
 /*  /*
Line 1611  donode(struct texi *p, enum texicmd cmd, size_t *pos)
Line 1656  donode(struct texi *p, enum texicmd cmd, size_t *pos)
 static void  static void
 domenu(struct texi *p, enum texicmd cmd, size_t *pos)  domenu(struct texi *p, enum texicmd cmd, size_t *pos)
 {  {
         size_t   start, end, sv;          size_t           nodename, entryname;
           size_t           nodenameend, entrynameend, i;
           ssize_t          ppos, lastppos;
           char             buf[PATH_MAX];
           enum texicmd     tcmd;
   
         advanceeoln(p, pos, 1);          advanceeoln(p, pos, 1);
   
Line 1631  domenu(struct texi *p, enum texicmd cmd, size_t *pos)
Line 1680  domenu(struct texi *p, enum texicmd cmd, size_t *pos)
                         break;                          break;
         }          }
   
           lastppos = -1;
         texivspace(p);          texivspace(p);
         teximacro(p, "Bl -tag -width Ds -compact");          teximacro(p, "Bl -tag -width Ds -compact");
         while (*pos < BUFSZ(p)) {          while (*pos < BUFSZ(p)) {
Line 1646  domenu(struct texi *p, enum texicmd cmd, size_t *pos)
Line 1696  domenu(struct texi *p, enum texicmd cmd, size_t *pos)
                 while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))                  while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
                         advance(p, pos);                          advance(p, pos);
                 if ('*' != BUF(p)[*pos]) {                  if ('*' != BUF(p)[*pos]) {
                         if (TEXICMD_END == peeklinecmd(p, *pos))                          tcmd = peeklinecmd(p, *pos);
                           if (TEXICMD_END == tcmd)
                                 break;                                  break;
                         parseeoln(p, pos);                          else if (TEXICMD_COMMENT == tcmd)
                                   advanceeoln(p, pos, 1);
                           else
                                   parseeoln(p, pos);
                         continue;                          continue;
                 }                  }
   
Line 1656  domenu(struct texi *p, enum texicmd cmd, size_t *pos)
Line 1710  domenu(struct texi *p, enum texicmd cmd, size_t *pos)
                 advance(p, pos);                  advance(p, pos);
                 while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))                  while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
                         advance(p, pos);                          advance(p, pos);
                 start = sv = *pos;                  entryname = *pos;
                 while (*pos < BUFSZ(p) && ':' != BUF(p)[*pos])                  while (*pos < BUFSZ(p) && ':' != BUF(p)[*pos])
                         advance(p, pos);                          advance(p, pos);
                 end = *pos;                  entrynameend = *pos;
                 advance(p, pos);                  advance(p, pos);
   
                   p->seenvs = 0;
                   teximacroopen(p, "It");
                 if (*pos == BUFSZ(p)) {                  if (*pos == BUFSZ(p)) {
                         texiwarn(p, "bad menu syntax");                          texiwarn(p, "bad menu syntax");
                         break;                          break;
                 } else if (':' != BUF(p)[*pos]) {                  } else if (':' != BUF(p)[*pos]) {
                         while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))                          while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
                                 advance(p, pos);                                  advance(p, pos);
                         teximacroopen(p, "It");                          nodename = *pos;
 #ifdef HAVE_INDEX  
                         teximacroopen(p, "Lkx");  
                         texiputchars(p, "\"node");  
 #endif  
                         while (*pos < BUFSZ(p)) {                          while (*pos < BUFSZ(p)) {
                                 switch (BUF(p)[*pos]) {                                  switch (BUF(p)[*pos]) {
                                 case ('\t'):                                  case ('\t'):
Line 1690  domenu(struct texi *p, enum texicmd cmd, size_t *pos)
Line 1742  domenu(struct texi *p, enum texicmd cmd, size_t *pos)
                                         }                                          }
                                         /* FALLTHROUGH */                                          /* FALLTHROUGH */
                                 default:                                  default:
                                         texiputchar(p, BUF(p)[*pos]);  
                                         advance(p, pos);                                          advance(p, pos);
                                         continue;                                          continue;
                                 }                                  }
                                 advance(p, pos);                                  advance(p, pos);
                                 break;                                  break;
                         }                          }
 #ifdef HAVE_INDEX                          nodenameend = *pos;
                         texiputchars(p, "\" \"");  
                         for (start = sv; start < end; start++)  
                                 texiputchar(p, BUF(p)[start]);  
                         texiputchar(p, '"');  
 #endif  
                 } else {                  } else {
                         advance(p, pos);                          advance(p, pos);
                         p->seenvs = 0;                          nodename = entryname;
                         teximacroopen(p, "It");                          nodenameend = entrynameend;
                   }
                   ppos = texicache(p, &BUF(p)[nodename],
                           nodenameend - nodename);
                   if (-1 != lastppos)
                           p->nodecache[lastppos].next = ppos;
                   p->nodecache[ppos].prev = lastppos;
                   p->nodecache[ppos].up = p->nodecur;
                   lastppos = ppos;
 #ifdef HAVE_INDEX  #ifdef HAVE_INDEX
                   if (NULL == p->chapters) {
                         teximacroopen(p, "Lkx");                          teximacroopen(p, "Lkx");
                         texiputchars(p, "\"node");                          texiputchars(p, "\"node");
                         for (start = sv; start < end; start++)                          for (i = nodename; i < nodenameend; i++)
                                 texiputchar(p, BUF(p)[start]);                                  texiputchar(p, BUF(p)[i]);
                         texiputchars(p, "\" \"");                          texiputchars(p, "\" \"");
 #endif                          for (i = entryname; i < entrynameend; i++)
                         for (start = sv; start < end; start++)                                  texiputchar(p, BUF(p)[i]);
                                 texiputchar(p, BUF(p)[start]);                          texiputchars(p, "\"");
 #ifdef HAVE_INDEX                          teximacroclose(p);
                         texiputchar(p, '"');                  } else {
 #endif                          snprintf(buf, sizeof(buf),
                                   "%s-%zd 7 ", p->chapters, ppos);
                           teximacroopen(p, "Xr");
                           texiputchars(p, buf);
                           texiputchars(p, "\"node");
                           for (i = nodename; i < nodenameend; i++)
                                   texiputchar(p, BUF(p)[i]);
                           texiputchars(p, "\" \"");
                           for (i = entryname; i < entrynameend; i++)
                                   texiputchar(p, BUF(p)[i]);
                           texiputchars(p, "\"");
                           teximacroclose(p);
                 }                  }
 #ifdef HAVE_INDEX  #else
                 teximacroclose(p);                  for (i = entryname; i < entrynameend; i++)
                           texiputchar(p, BUF(p)[i]);
 #endif  #endif
                 teximacroclose(p);                  teximacroclose(p);
         }          }
Line 2155  doindex(struct texi *p, enum texicmd cmd, size_t *pos)
Line 2222  doindex(struct texi *p, enum texicmd cmd, size_t *pos)
                 advance(p, pos);                  advance(p, pos);
   
         start = *pos;          start = *pos;
         while (*pos < BUFSZ(p) && '\n' != BUF(p)[*pos]) {          while (*pos < BUFSZ(p) && '\n' != BUF(p)[*pos])
                 assert('\0' != BUF(p)[*pos]);  
                 advance(p, pos);                  advance(p, pos);
         }  
   
         if (*pos == BUFSZ(p)) {          if (*pos == BUFSZ(p)) {
                 texiwarn(p, "unexpected EOF");                  texiwarn(p, "unexpected EOF");
Legend:
Removed from v.1.67  
changed lines
  Added in v.1.68
CVSweb