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

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

version 1.66, 2015/03/11 12:51:41 version 1.68, 2015/03/12 10:44:34
Line 76  static void donode(struct texi *, enum texicmd, size_t
Line 76  static void donode(struct texi *, enum texicmd, size_t
 static  void doprintindex(struct texi *, enum texicmd, size_t *);  static  void doprintindex(struct texi *, enum texicmd, size_t *);
 static  void doquotation(struct texi *, enum texicmd, size_t *);  static  void doquotation(struct texi *, enum texicmd, size_t *);
 static  void dotable(struct texi *, enum texicmd, size_t *);  static  void dotable(struct texi *, enum texicmd, size_t *);
 static  void dotop(struct texi *, enum texicmd, size_t *);  
 static  void dosecoffs(struct texi *, enum texicmd, size_t *);  static  void dosecoffs(struct texi *, enum texicmd, size_t *);
 static  void dosection(struct texi *, enum texicmd, size_t *);  static  void dosection(struct texi *, enum texicmd, size_t *);
 static  void dosp(struct texi *, enum texicmd, size_t *);  static  void dosp(struct texi *, enum texicmd, size_t *);
Line 135  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 153  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 326  static const struct texitok __texitoks[TEXICMD__MAX] =
Line 329  static const struct texitok __texitoks[TEXICMD__MAX] =
         { doignline, "title", 5 }, /* TEXICMD_TITLE */          { doignline, "title", 5 }, /* TEXICMD_TITLE */
         { dobracket, "titlefont", 9 }, /* TEXICMD_TITLEFONT */          { dobracket, "titlefont", 9 }, /* TEXICMD_TITLEFONT */
         { doignblock, "titlepage", 9 }, /* TEXICMD_TITLEPAGE */          { doignblock, "titlepage", 9 }, /* TEXICMD_TITLEPAGE */
         { dotop, "top", 3 }, /* TEXICMD_TOP */          { dosection, "top", 3 }, /* TEXICMD_TOP */
         { doindex, "tpindex", 7 }, /* TEXICMD_TPINDEX */          { doindex, "tpindex", 7 }, /* TEXICMD_TPINDEX */
         { doaccent, "u", 1 }, /* TEXICMD_U */          { doaccent, "u", 1 }, /* TEXICMD_U */
         { doaccent, "ubaraccent", 10 }, /* TEXICMD_UBARACCENT */          { doaccent, "ubaraccent", 10 }, /* TEXICMD_UBARACCENT */
Line 394  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 430  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 472  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 501  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 532  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 663  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 847  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 1477  doquotation(struct texi *p, enum texicmd cmd, size_t *
Line 1501  doquotation(struct texi *p, enum texicmd cmd, size_t *
 static int  static int
 indexcmp(const void *p1, const void *p2)  indexcmp(const void *p1, const void *p2)
 {  {
           const struct texiterm *t1 = p1, *t2 = p2;
   
         return(strcasecmp(*(const char **)p1, *(const char **)p2));          return(strcasecmp(t1->term, t2->term));
 }  }
   
 static void  static void
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 1522  doprintindex(struct texi *p, enum texicmd cmd, size_t 
Line 1548  doprintindex(struct texi *p, enum texicmd cmd, size_t 
   
         /* Alphabetically sort our indices. */          /* Alphabetically sort our indices. */
         qsort(p->indexs[i].index,          qsort(p->indexs[i].index,
                 p->indexs[i].indexsz, sizeof(char *), indexcmp);                  p->indexs[i].indexsz,
                   sizeof(struct texiterm), indexcmp);
   
         texivspace(p);          texivspace(p);
         teximacro(p, "Bl -tag -width Ds -compact");          teximacro(p, "Bl -tag -width Ds -compact");
         for (j = 0; j < p->indexs[i].indexsz; j++) {          for (j = 0; j < p->indexs[i].indexsz; j++) {
                 teximacroopen(p, "It");                  teximacroopen(p, "It");
 #if HAVE_INDEX  #if HAVE_INDEX
                 teximacroopen(p, "Lkx");                  if (NULL == p->chapters) {
                 texiputchars(p, "\"idx");                          teximacroopen(p, "Lkx");
                 texiputchars(p, p->indexs[i].name);                          texiputchars(p, "\"idx");
                 cp = p->indexs[i].index[j];                          texiputchars(p, p->indexs[i].name);
                 while ('\n' != *cp) {                          cp = p->indexs[i].index[j].term;
                         assert('\0' != *cp);                          while ('\n' != *cp)
                         texiputchar(p, *cp++);                                  texiputchar(p, *cp++);
                           texiputchars(p, "\" \"");
                           p->literal++;
                   } else {
                           teximacroopen(p, "Xr");
                           snprintf(buf, sizeof(buf), "%s-%zd 7 \"idx",
                                   p->chapters, p->indexs[i].index[j].chapter);
                           texiputchars(p, buf);
                           texiputchars(p, p->indexs[i].name);
                           cp = p->indexs[i].index[j].term;
                           while ('\n' != *cp)
                                   texiputchar(p, *cp++);
                           texiputchars(p, "\" \"");
                           p->literal++;
                 }                  }
                 texiputchars(p, "\" \"");  
                 p->literal++;  
 #endif  #endif
                 texisplice(p, p->indexs[i].index[j],                  texisplice(p, p->indexs[i].index[j].term,
                         strlen(p->indexs[i].index[j]), *pos);                          strlen(p->indexs[i].index[j].term), *pos);
                 parseeoln(p, pos);                  parseeoln(p, pos);
 #if HAVE_INDEX  #if HAVE_INDEX
                 p->literal--;                  p->literal--;
Line 1559  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--;
                 return;  
         }  
   
 #if HAVE_INDEX          /* Grab our node name. */
         p->seenvs = -1;  
         teximacroopen(p, "Ix");  
         texiputchars(p, "node");  
         while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))          while (*pos < BUFSZ(p) && isws(BUF(p)[*pos]))
                 advance(p, pos);                  advance(p, pos);
           start = *pos;
         while (*pos < BUFSZ(p)) {          while (*pos < BUFSZ(p)) {
                 if (BUF(p)[*pos] == ',')                  if (BUF(p)[*pos] == ',')
                         break;                          break;
                 else if (BUF(p)[*pos] == '\n')                  else if (BUF(p)[*pos] == '\n')
                         break;                          break;
                 texiputchar(p, BUF(p)[*pos]);  
                 advance(p, pos);                  advance(p, pos);
         }          }
         teximacroclose(p);          if (*pos == BUFSZ(p)) {
 #endif                  texiwarn(p, "unexpected EOF");
                   return;
           }
           end = *pos;
         advanceeoln(p, pos, 1);          advanceeoln(p, pos, 1);
         p->seenvs = sv;  
           if (NULL != p->chapters)
                   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);
           } else if (p->nodesz > 1) {
                   /* Otherwise, mark our index. */
                   p->seenvs = -1;
   #if HAVE_INDEX
                   teximacroopen(p, "Ix");
                   texiputchars(p, "node");
                   texiputchars(p, p->nodecache[p->nodecur].name);
                   teximacroclose(p);
   #endif
                   p->seenvs = sv;
           } else
                   teximdocopen(p, pos);
 }  }
   
 /*  /*
Line 1593  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;
   
         if (NULL != p->chapters) {  
                 doignblock(p, cmd, pos);  
                 return;  
         }  
   
         advanceeoln(p, pos, 1);          advanceeoln(p, pos, 1);
   
         /*          /*
Line 1618  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 1633  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 1643  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 1677  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 1914  dosection(struct texi *p, enum texicmd cmd, size_t *po
Line 1994  dosection(struct texi *p, enum texicmd cmd, size_t *po
         else          else
                 texivspace(p);                  texivspace(p);
   
         if (0 == sec && NULL != p->chapters) {  
                 teximdocclose(p, 0);  
                 teximdocopen(p, pos);  
         }  
   
         teximacroopen(p, sects[sec]);          teximacroopen(p, sects[sec]);
         parseeoln(p, pos);          parseeoln(p, pos);
         teximacroclose(p);          teximacroclose(p);
Line 1927  dosection(struct texi *p, enum texicmd cmd, size_t *po
Line 2002  dosection(struct texi *p, enum texicmd cmd, size_t *po
                 p->seenvs = -1;                  p->seenvs = -1;
         else          else
                 texivspace(p);                  texivspace(p);
 }  
   
 static void  
 dotop(struct texi *p, enum texicmd cmd, size_t *pos)  
 {  
   
         if (--p->ign)  
                 texierr(p, "@top command while ignoring");  
   
         if (NULL == p->chapters)  
                 teximdocopen(p, pos);  
         dosection(p, cmd, pos);  
 }  }
   
 static void  static void
Legend:
Removed from v.1.66  
changed lines
  Added in v.1.68
CVSweb